+Mon Dec 16 22:43:31 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
+
+ * cp-tree.h (ptr_reasonably_similar): Add decl.
+
+Thu Dec 12 15:00:35 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
+
+ * decl.c (grokvardecl): Change SPECBITS parm to be the SPECBITS_IN
+ pointer. New local SPECBITS with the parm's value.
+ (grokdeclarator): Pass &specbits down.
+
+ * parse.y (expr_no_commas): Make sure $$ is not an error_mark_node
+ before we try to do C_SET_EXP_ORIGINAL_CODE on it.
+
+ * search.c (envelope_add_decl): Check that the CLASSTYPE_CID of
+ CONTEXT is not 0 before we try to use TYPE_DERIVES_FROM.
+
+ * decl.c (cplus_expand_expr_stmt): Only expand the expr if EXP is
+ not an error_mark_node.
+
+Sat Dec 7 17:20:22 1996 Jason Merrill <jason@yorick.cygnus.com>
+
+ * cp-tree.h (TYPE_MAIN_DECL): Use TYPE_STUB_DECL.
+ * *.c: Use TYPE_MAIN_DECL instead of TYPE_NAME where appropriate.
+
+Fri Dec 6 14:40:09 1996 Jason Merrill <jason@yorick.cygnus.com>
+
+ * decl.c (grokdeclarator): When giving an anonymous struct a name,
+ replace TYPE_NAME instead of TYPE_IDENTIFIER (so TYPE_STUB_DECL is
+ not affected).
+
+ * typeck2.c (build_m_component_ref): If component is a pointer
+ to data member, resolve the OFFSET_REF now.
+
+ * call.c (convert_like): Don't go into infinite recursion.
+
+ * pt.c (coerce_template_parms): Use tsubst_expr for non-type args.
+
+ * class.c (finish_struct_1): Set DECL_ARTIFICIAL on the vptr.
+ * tree.c (layout_basetypes): And on the vbase ptr.
+
+Thu Dec 5 02:11:28 1996 Jason Merrill <jason@yorick.cygnus.com>
+
+ * decl.c (BOOL_TYPE_SIZE): Define in terms of POINTER_SIZE or
+ CHAR_TYPE_SIZE so bool is always the same size as another type.
+
+ * decl.c (pushtag): Set DECL_IGNORED_P for DWARF, too.
+
+Tue Dec 3 23:18:37 1996 Jason Merrill <jason@yorick.cygnus.com>
+
+ * decl2.c (grok_x_components): Remove synthesized methods from
+ TYPE_METHODS of an anonymous union, complain about member
+ functions.
+ * decl.c (shadow_tag): Wipe out memory of synthesized methods in
+ anonymous unions.
+ (finish_function): Just clear the DECL_RTL of our arguments.
+
+Fri Nov 29 21:54:17 1996 Jason Merrill <jason@yorick.cygnus.com>
+
+ * decl2.c (finish_file): Emit DWARF debugging info for static data
+ members.
+
+ * pt.c (tsubst): If t is a stub decl, return the stub decl for type.
+
+Wed Nov 27 14:47:15 1996 Bob Manson <manson@charmed.cygnus.com>
+
+ * typeck.c (build_component_ref): Don't die if COMPONENT isn't a
+ IDENTIFIER_NODE.
+
+Wed Nov 27 16:05:19 1996 Michael Meissner <meissner@tiktok.cygnus.com>
+
+ * Make-lang.in (g++-cross$(exeext)): Fix typo.
+
+Wed Nov 27 08:14:00 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
+
+ Make the g++ driver now be a standalone program, rather than one
+ that tries to run the gcc driver after munging up the options.
+ * Make-lang.in (g++.c, g++spec.o): New rules.
+ (g++.o): New rule, based on gcc.o with -DLANG_SPECIFIC_DRIVER
+ added.
+ (g++$(exeext)): New rule, based on xgcc rule.
+ (g++-cross$(exeext)): Now just copies g++$(exeext) over.
+ * g++spec.c: New file.
+ * g++.c: Removed file.
+
+Tue Nov 26 19:01:09 1996 Mike Stump <mrs@cygnus.com>
+
+ * cvt.c (build_up_reference): Arrange for any temporary values
+ that have been keep in registers until now to be put into memory.
+
Mon Nov 25 15:16:41 1996 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
* Make-lang.in (c++.stage[1234]): Depend upon stage[1-4]-start, so
* typeck.c (c_expand_return): Fix logic.
(unary_complex_lvalue): Avoid unused warning on address of INIT_EXPR.
- * decl.c (grokfndecl): Also note_debug_info_needed on ctype here.
-
Wed Nov 20 18:47:31 1996 Bob Manson <manson@charmed.cygnus.com>
* g++.c (main): Make sure arglist has a final NULL entry. Add
Fri Nov 8 17:38:44 1996 Jason Merrill <jason@yorick.cygnus.com>
* decl2.c (finish_file): Don't emit debug info.
- * decl.c (start_function): Call note_debug_info_needed for context.
- (start_decl): Likewise.
- (cp_finish_decl): Not here.
- (finish_function): Or here.
- (pushdecl): Lose obsolete code.
+ * decl.c (pushdecl): Lose obsolete code.
(grokdeclarator): Still do the long long thing after complaining.
- (finish_enum): Don't call rest_of_type_compilation
- for DWARF.
- * class.c (finish_struct_1): Don't call rest_of_type_compilation
- for DWARF.
- * search.c (dfs_debug_mark): For DWARF, just call
- rest_of_type_compilation.
- (note_debug_info_needed): Don't do anything if we're in a template.
- * parse.y (named_complex_class_head_sans_basetype): Likewise.
+ * search.c (note_debug_info_needed): Don't do anything if we're in a
+ template.
* method.c (synthesize_method): For non-local classes,
push_to_top_level first.
# Tell GNU make to ignore these if they exist.
.PHONY: C++ c++
+g++.c: $(srcdir)/gcc.c
+ -rm -f $@
+ ln -s $(srcdir)/gcc.c $@ || cp $(srcdir)/gcc.c $@
+
+g++spec.o: $(srcdir)/cp/g++spec.c
+ $(CC) -c $(ALL_CFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $<
+
+# N.B.: This is a copy of the gcc.o rule, with -DLANG_SPECIFIC_DRIVER added.
+# It'd be nice if we could find an easier way to do this---rather than have
+# to track changes to the toplevel gcc Makefile as well.
+# We depend on g++.c last, to make it obvious where it came from.
+g++.o: $(CONFIG_H) multilib.h config.status $(lang_specs_files) g++.c
+ $(CC) $(ALL_CFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \
+ $(DRIVER_DEFINES) \
+ -DLANG_SPECIFIC_DRIVER \
+ -c g++.c
+
# Create the compiler driver for g++.
-g++: $(srcdir)/cp/g++.c $(CONFIG_H) choose-temp.o pexecute.o $(LIBDEPS)
- $(CC) $(ALL_CFLAGS) $(INCLUDES) $(LDFLAGS) -o $@ $(srcdir)/cp/g++.c choose-temp.o pexecute.o $(LIBS)
+g++$(exeext): g++.o g++spec.o version.o choose-temp.o pexecute.o $(LIBDEPS) $(EXTRA_GCC_OBJS)
+ $(CC) $(ALL_CFLAGS) $(LDFLAGS) -o $@ g++.o g++spec.o version.o \
+ choose-temp.o pexecute.o $(EXTRA_GCC_OBJS) $(LIBS)
# Create a version of the g++ driver which calls the cross-compiler.
-g++-cross: $(srcdir)/cp/g++.c choose-temp.o pexecute.o $(LIBDEPS)
- $(CC) $(ALL_CFLAGS) $(INCLUDES) $(LDFLAGS) -o $@ \
- -DGCC_NAME=\"$(GCC_CROSS_NAME)\" $(srcdir)/cp/g++.c choose-temp.o pexecute.o $(LIBS)
+g++-cross$(exeext): g++$(exeext)
+ -rm -f g++-cross$(exeext)
+ cp g++$(exeext) g++-cross$(exeext)
cxxmain.o: cplus-dem.c demangle.h
rm -f cxxmain.c
if (TREE_PURPOSE (tags) == inner_name)
{
if (inner_types == NULL_TREE)
- return TYPE_NAME (TREE_VALUE (tags));
+ return TYPE_MAIN_DECL (TREE_VALUE (tags));
return resolve_scope_to_name (TREE_VALUE (tags), inner_types);
}
tags = TREE_CHAIN (tags);
if (rval != NULL_TREE)
return rval;
- type = DECL_CONTEXT (TYPE_NAME (type));
+ type = DECL_CONTEXT (TYPE_MAIN_DECL (type));
}
}
cand = candidates; /* any one will do */
cand->second_conv = build1 (AMBIG_CONV, totype, expr);
ICS_USER_FLAG (cand->second_conv) = 1;
+ ICS_BAD_FLAG (cand->second_conv) = 1;
return cand;
}
convert_like (convs, expr)
tree convs, expr;
{
- if (ICS_BAD_FLAG (convs))
+ if (ICS_BAD_FLAG (convs)
+ && TREE_CODE (convs) != USER_CONV
+ && TREE_CODE (convs) != AMBIG_CONV)
{
tree t = convs;
for (; t; t = TREE_OPERAND (t, 0))
&& CLASSTYPE_NON_AGGREGATE (t)))
{
tree variants;
- if (TREE_CODE (TYPE_NAME (t)) == TYPE_DECL)
- DECL_MODE (TYPE_NAME (t)) = BLKmode;
+ DECL_MODE (TYPE_MAIN_DECL (t)) = BLKmode;
for (variants = t; variants; variants = TYPE_NEXT_VARIANT (variants))
{
TYPE_MODE (variants) = BLKmode;
if (nonprivate_method == 0
&& CLASSTYPE_FRIEND_CLASSES (t) == NULL_TREE
- && DECL_FRIENDLIST (TYPE_NAME (t)) == NULL_TREE)
+ && DECL_FRIENDLIST (TYPE_MAIN_DECL (t)) == NULL_TREE)
{
tree binfos = BINFO_BASETYPES (TYPE_BINFO (t));
for (i = 0; i < n_baseclasses; i++)
TYPE_HAS_DESTRUCTOR (t) = 0;
else if (TREE_PRIVATE (dtor)
&& CLASSTYPE_FRIEND_CLASSES (t) == NULL_TREE
- && DECL_FRIENDLIST (TYPE_NAME (t)) == NULL_TREE
+ && DECL_FRIENDLIST (TYPE_MAIN_DECL (t)) == NULL_TREE
&& warn_ctor_dtor_privacy)
cp_warning ("`%#T' only defines a private destructor and has no friends",
t);
if (TYPE_HAS_CONSTRUCTOR (t)
&& CLASSTYPE_FRIEND_CLASSES (t) == NULL_TREE
- && DECL_FRIENDLIST (TYPE_NAME (t)) == NULL_TREE)
+ && DECL_FRIENDLIST (TYPE_MAIN_DECL (t)) == NULL_TREE)
{
int nonprivate_ctor = 0;
tree ctor;
DECL_ASSEMBLER_NAME (vfield) = get_identifier (VFIELD_BASE);
CLASSTYPE_VFIELD (t) = vfield;
DECL_VIRTUAL_P (vfield) = 1;
+ DECL_ARTIFICIAL (vfield) = 1;
DECL_FIELD_CONTEXT (vfield) = t;
DECL_CLASS_CONTEXT (vfield) = t;
DECL_FCONTEXT (vfield) = t;
value for DECL_OFFSET, so that we can use it as part
of a COMPONENT_REF for multiple inheritance. */
- if (TREE_CODE (TYPE_NAME (t)) == TYPE_DECL)
- layout_decl (TYPE_NAME (t), 0);
+ layout_decl (TYPE_MAIN_DECL (t), 0);
/* Now fix up any virtual base class types that we left lying
around. We must get these done before we try to lay out the
{
/* Be smarter about nested classes here. If a type is nested,
only output it if we would output the enclosing type. */
- if (DECL_CONTEXT (TYPE_NAME (t))
- && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (TYPE_NAME (t)))) == 't')
- DECL_IGNORED_P (TYPE_NAME (t)) = TREE_ASM_WRITTEN (TYPE_NAME (t));
+ if (DECL_CONTEXT (TYPE_MAIN_DECL (t))
+ && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (TYPE_MAIN_DECL (t)))) == 't')
+ DECL_IGNORED_P (TYPE_MAIN_DECL (t)) = TREE_ASM_WRITTEN (TYPE_MAIN_DECL (t));
}
#endif
/* Don't output full info about any type
which does not have its implementation defined here. */
if (TYPE_VIRTUAL_P (t) && write_virtuals == 2)
- TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t))
+ TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t))
= (value_member (TYPE_IDENTIFIER (t), pending_vtables) == 0);
else if (CLASSTYPE_INTERFACE_ONLY (t))
- TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = 1;
+ TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 1;
#if 0
/* XXX do something about this. */
else if (CLASSTYPE_INTERFACE_UNKNOWN (t))
/* Only a first approximation! */
- TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = 1;
+ TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 1;
#endif
}
else if (CLASSTYPE_INTERFACE_ONLY (t))
- TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = 1;
-
- /* Finish debugging output for this type. */
- rest_of_type_compilation (t, toplevel_bindings_p ());
+ TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 1;
}
+ /* Finish debugging output for this type. */
+ rest_of_type_compilation (t, toplevel_bindings_p ());
+
return t;
}
CLASSTYPE_TAGS (t) = x = nreverse (CLASSTYPE_TAGS (t));
while (x)
{
- tree tag = TYPE_NAME (TREE_VALUE (x));
+ tree tag = TYPE_MAIN_DECL (TREE_VALUE (x));
TREE_NONLOCAL_FLAG (TREE_VALUE (x)) = 0;
x = TREE_CHAIN (x);
|| TREE_CODE (type) == TEMPLATE_TYPE_PARM)
return;
- context = DECL_CONTEXT (TYPE_NAME (type));
+ context = DECL_CONTEXT (TYPE_MAIN_DECL (type));
if (context && TREE_CODE (context) == RECORD_TYPE)
push_nested_class (context, 2);
pop_nested_class (modify)
int modify;
{
- tree context = DECL_CONTEXT (TYPE_NAME (current_class_type));
+ tree context = DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type));
popclass (modify);
if (context && TREE_CODE (context) == RECORD_TYPE)
#define TYPE_ASSEMBLER_NAME_LENGTH(NODE) (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (TYPE_NAME (NODE))))
/* The _DECL for this _TYPE. */
-#define TYPE_MAIN_DECL(NODE) (TYPE_NAME (NODE))
+#define TYPE_MAIN_DECL(NODE) (TYPE_STUB_DECL (TYPE_MAIN_VARIANT (NODE)))
#define IS_AGGR_TYPE(t) (TYPE_LANG_FLAG_5 (t))
#define IS_AGGR_TYPE_CODE(t) (t == RECORD_TYPE || t == UNION_TYPE)
extern void c_expand_asm_operands PROTO((tree, tree, tree, tree, int, char *, int));
extern void c_expand_return PROTO((tree));
extern tree c_expand_start_case PROTO((tree));
+extern int ptr_reasonably_similar PROTO((tree, tree));
extern tree build_component_ref PROTO((tree, tree, tree, int));
extern tree build_ptrmemfunc PROTO((tree, tree, int));
if (distance == -2)
{
ambig:
- cp_error ("type `%T' is ambiguous baseclass of `%s'", TREE_TYPE (type),
- TYPE_NAME_STRING (TREE_TYPE (intype)));
+ cp_error ("type `%T' is ambiguous baseclass of `%s'",
+ TREE_TYPE (type),
+ TYPE_NAME_STRING (TREE_TYPE (intype)));
return error_mark_node;
}
if (distance == -1)
arg = build (TARGET_EXPR, argtype, slot, arg, NULL_TREE, NULL_TREE);
}
+ /* If we had a way to wrap this up, and say, if we ever needed it's
+ address, transform all occurrences of the register, into a memory
+ reference we could win better. */
+ mark_addressable (arg);
rval = build1 (ADDR_EXPR, type, arg);
done:
#ifndef BOOL_TYPE_SIZE
#ifdef SLOW_BYTE_ACCESS
-#define BOOL_TYPE_SIZE ((SLOW_BYTE_ACCESS) ? (BITS_PER_WORD) : (BITS_PER_UNIT))
+#define BOOL_TYPE_SIZE ((SLOW_BYTE_ACCESS) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
#else
-#define BOOL_TYPE_SIZE BITS_PER_UNIT
+#define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
#endif
#endif
set_identifier_type_value_with_scope (name, type, b);
}
else
- d = TYPE_NAME (d);
+ d = TYPE_MAIN_DECL (d);
TYPE_NAME (type) = d;
DECL_CONTEXT (d) = context;
newdecl = 1;
d = build_decl (TYPE_DECL, name, type);
SET_DECL_ARTIFICIAL (d);
- TYPE_MAIN_DECL (type) = d;
+ TYPE_NAME (type) = d;
DECL_CONTEXT (d) = context;
if (! globalize && processing_template_decl && IS_AGGR_TYPE (type))
push_template_decl (d);
}
if (newdecl)
{
- if (write_symbols != DWARF_DEBUG && write_symbols != DWARF2_DEBUG)
- {
- if (ANON_AGGRNAME_P (name))
- DECL_IGNORED_P (d) = 1;
- }
+ if (ANON_AGGRNAME_P (name))
+ DECL_IGNORED_P (d) = 1;
TYPE_CONTEXT (type) = DECL_CONTEXT (d);
DECL_ASSEMBLER_NAME (d)
if (TYPE_SIZE (context) == NULL_TREE)
goto no_context;
/* Go to next enclosing type, if any. */
- context = DECL_CONTEXT (TYPE_NAME (context));
+ context = DECL_CONTEXT (TYPE_MAIN_DECL (context));
break;
case 'd':
context = DECL_CONTEXT (context);
}
return NULL_TREE;
}
-
-/* Given type TYPE which was not declared in C++ language context,
- attempt to find a name by which it is referred. */
-
-tree
-typedecl_for_tag (tag)
- tree tag;
-{
- struct binding_level *b = current_binding_level;
-
- if (TREE_CODE (TYPE_NAME (tag)) == TYPE_DECL)
- return TYPE_NAME (tag);
-
- while (b)
- {
- tree decls = b->names;
- while (decls)
- {
- if (TREE_CODE (decls) == TYPE_DECL && TREE_TYPE (decls) == tag)
- break;
- decls = TREE_CHAIN (decls);
- }
- if (decls)
- return decls;
- b = b->level_chain;
- }
- return NULL_TREE;
-}
\f
/* Lookup TYPE in CONTEXT (a chain of nested types or a FUNCTION_DECL).
Return the type value, or NULL_TREE if not found. */
pop_obstacks ();
TYPE_CONTEXT (t) = context;
- TYPE_MAIN_DECL (TREE_TYPE (d)) = d;
+ TYPE_NAME (TREE_TYPE (d)) = d;
+ TYPE_STUB_DECL (TREE_TYPE (d)) = d;
DECL_CONTEXT (d) = context;
CLASSTYPE_GOT_SEMICOLON (t) = 1;
|| TREE_CODE (val) == TYPE_DECL || prefer_type <= 0)
;
else if (IDENTIFIER_HAS_TYPE_VALUE (name))
- val = TYPE_NAME (IDENTIFIER_TYPE_VALUE (name));
+ val = TYPE_MAIN_DECL (IDENTIFIER_TYPE_VALUE (name));
else if (TREE_TYPE (val) == error_mark_node)
val = error_mark_node;
}
code = TREE_CODE (value);
if (IS_AGGR_TYPE_CODE (code) || code == ENUMERAL_TYPE)
{
- my_friendly_assert (TYPE_NAME (value) != NULL_TREE, 261);
+ my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
if (IS_AGGR_TYPE (value) && CLASSTYPE_USE_TEMPLATE (value))
{
|| (TREE_CODE (TYPE_NAME (t)) == TYPE_DECL
&& ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))))
{
+ /* See also grok_x_components. */
+
tree fn;
+ tree *q;
+
+ /* Wipe out memory of synthesized methods */
+ TYPE_HAS_CONSTRUCTOR (t) = 0;
+ TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
+ TYPE_HAS_INIT_REF (t) = 0;
+ TYPE_HAS_CONST_INIT_REF (t) = 0;
+ TYPE_HAS_ASSIGN_REF (t) = 0;
+ TYPE_HAS_ASSIGNMENT (t) = 0;
+ TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
+
+ q = &TYPE_METHODS (t);
+ while (*q)
+ {
+ if (DECL_ARTIFICIAL (*q))
+ *q = TREE_CHAIN (*q);
+ else
+ q = &TREE_CHAIN (*q);
+ }
/* ANSI C++ June 5 1992 WP 9.5.3. Anonymous unions may not have
function members. */
- for (fn = TYPE_METHODS (t); fn; fn = TREE_CHAIN (fn))
- if (! DECL_ARTIFICIAL (fn))
- {
- error ("an anonymous union cannot have function members");
- break;
- }
+ if (TYPE_METHODS (t))
+ error ("an anonymous union cannot have function members");
if (TYPE_FIELDS (t))
{
}
}
- /* Do this before the decl is actually defined so that the DWARF debug
- info for the class reflects the declaration, rather than the
- definition, of this decl. */
- if (TREE_CODE (decl) == VAR_DECL && context)
- note_debug_info_needed (context);
-
if (initialized)
{
if (! toplevel_bindings_p ()
/* If we have installed this as the canonical typedef for this
type, and that type has not been defined yet, delay emitting
the debug informaion for it, as we will emit it later. */
- if (TYPE_NAME (TREE_TYPE (decl)) == decl
+ if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
&& TYPE_SIZE (TREE_TYPE (decl)) == NULL_TREE)
TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
/* Let debugger know it should output info for this type. */
note_debug_info_needed (ttype);
+ if (TREE_STATIC (decl) && DECL_CONTEXT (decl)
+ && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (decl))) == 't')
+ note_debug_info_needed (DECL_CONTEXT (decl));
+
if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
&& DECL_SIZE (decl) != NULL_TREE
&& ! TREE_CONSTANT (DECL_SIZE (decl)))
return decl;
if (check && funcdef_flag)
- {
- /* Do this before the decl is actually defined so that the DWARF debug
- info for the class reflects the declaration, rather than the
- definition, of this decl. */
- if (ctype)
- note_debug_info_needed (ctype);
-
- DECL_INITIAL (decl) = error_mark_node;
- }
+ DECL_INITIAL (decl) = error_mark_node;
if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
{
}
static tree
-grokvardecl (type, declarator, specbits, initialized, constp)
+grokvardecl (type, declarator, specbits_in, initialized, constp)
tree type;
tree declarator;
- RID_BIT_TYPE specbits;
+ RID_BIT_TYPE *specbits_in;
int initialized;
int constp;
{
tree decl;
+ RID_BIT_TYPE specbits = *specbits_in;
if (TREE_CODE (type) == OFFSET_TYPE)
{
if (constp || volatilep)
type = cp_build_type_variant (type, constp, volatilep);
+ if (decl_context == FIELD)
+ {
+ if (declarator == current_class_name)
+ cp_pedwarn ("ANSI C++ forbids nested type `%D' with same name as enclosing class",
+ declarator);
+ decl = build_lang_decl (TYPE_DECL, declarator, type);
+ if (IS_SIGNATURE (current_class_type) && opaque_typedef)
+ SIGNATURE_HAS_OPAQUE_TYPEDECLS (current_class_type) = 1;
+ }
+ else
+ decl = build_decl (TYPE_DECL, declarator, type);
+
/* If the user declares "struct {...} foo" then `foo' will have
an anonymous name. Fill that name in now. Nothing can
refer to it, so nothing needs know about the name change.
{
/* replace the anonymous name with the real name everywhere. */
lookup_tag_reverse (type, declarator);
- TYPE_IDENTIFIER (type) = declarator;
+ TYPE_NAME (type) = decl;
if (TYPE_LANG_SPECIFIC (type))
TYPE_WAS_ANONYMOUS (type) = 1;
- {
- tree d = TYPE_NAME (type), c = DECL_CONTEXT (d);
-
- DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
- DECL_ASSEMBLER_NAME (d)
- = get_identifier (build_overload_name (type, 1, 1));
- }
- }
-
- if (decl_context == FIELD)
- {
- if (declarator == current_class_name)
- cp_pedwarn ("ANSI C++ forbids nested type `%D' with same name as enclosing class",
- declarator);
- decl = build_lang_decl (TYPE_DECL, declarator, type);
- if (IS_SIGNATURE (current_class_type) && opaque_typedef)
- SIGNATURE_HAS_OPAQUE_TYPEDECLS (current_class_type) = 1;
+ DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
+ DECL_ASSEMBLER_NAME (decl)
+ = get_identifier (build_overload_name (type, 1, 1));
}
- else
- decl = build_decl (TYPE_DECL, declarator, type);
if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
{
instantiation made the field's type be incomplete. */
if (current_class_type
&& TYPE_NAME (current_class_type)
- && IDENTIFIER_TEMPLATE (DECL_NAME (TYPE_NAME (current_class_type)))
+ && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
&& declspecs && TREE_VALUE (declspecs)
&& TREE_TYPE (TREE_VALUE (declspecs)) == type)
cp_error (" in instantiation of template `%T'",
}
/* An uninitialized decl with `extern' is a reference. */
- decl = grokvardecl (type, declarator, specbits, initialized, constp);
+ decl = grokvardecl (type, declarator, &specbits, initialized, constp);
bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
inlinep, friendp, raises != NULL_TREE);
}
/* Finish debugging output for this type. */
- if (write_symbols != DWARF_DEBUG && write_symbols != DWARF2_DEBUG)
- rest_of_type_compilation (enumtype, global_bindings_p ());
+ rest_of_type_compilation (enumtype, global_bindings_p ());
return enumtype;
}
if (! DECL_ARGUMENTS (decl1)
&& !DECL_STATIC_FUNCTION_P (decl1)
&& DECL_CONTEXT (decl1)
- && DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl1)))
- && IDENTIFIER_TEMPLATE (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl1)))))
+ && TYPE_IDENTIFIER (DECL_CONTEXT (decl1))
+ && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (DECL_CONTEXT (decl1))))
{
cp_error ("redeclaration of `%#D'", decl1);
if (IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1)))
}
}
- /* Do this before the decl is actually defined so that the DWARF debug
- info for the class reflects the declaration, rather than the
- definition, of this decl. */
- if (DECL_FUNCTION_MEMBER_P (decl1))
- note_debug_info_needed (DECL_CLASS_CONTEXT (decl1));
-
/* Warn if function was previously implicitly declared
(but not if we warned then). */
if (! warn_implicit
mark_inline_for_output (fndecl);
}
+ if (ctype && TREE_ASM_WRITTEN (fndecl))
+ note_debug_info_needed (ctype);
+
current_function_returns_null |= can_reach_end;
/* Since we don't normally go through c_expand_return for constructors,
if (DECL_SAVED_INSNS (fndecl) == NULL_RTX)
{
+ tree t;
+
/* 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 (fndecl) = error_mark_node;
- /* And we need the arguments for template instantiation. */
- if (! processing_template_decl)
- DECL_ARGUMENTS (fndecl) = NULL_TREE;
+ for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
+ DECL_RTL (t) = NULL_RTX;
}
if (DECL_STATIC_CONSTRUCTOR (fndecl))
libg++ to miscompile, and tString to core dump. */
exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
#endif
- expand_expr_stmt (break_out_cleanups (exp));
+ /* If we don't do this, we end up down inside expand_expr
+ trying to do TYPE_MODE on the ERROR_MARK, and really
+ go outside the bounds of the type. */
+ if (exp != error_mark_node)
+ expand_expr_stmt (break_out_cleanups (exp));
}
/* Clean up any pending cleanups. This happens when a function call
if (TREE_CODE (t) == UNION_TYPE
&& ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
{
+ /* See also shadow_tag. */
+
struct pending_inline **p;
+ tree *q;
x = build_lang_field_decl (FIELD_DECL, NULL_TREE, t);
/* Wipe out memory of synthesized methods */
TYPE_HAS_ASSIGNMENT (t) = 0;
TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
+ q = &TYPE_METHODS (t);
+ while (*q)
+ {
+ if (DECL_ARTIFICIAL (*q))
+ *q = TREE_CHAIN (*q);
+ else
+ q = &TREE_CHAIN (*q);
+ }
+ if (TYPE_METHODS (t))
+ error ("an anonymous union cannot have function members");
+
p = &pending_inlines;
for (; *p; *p = (*p)->next)
if (DECL_CONTEXT ((*p)->fndecl) != t)
#else
TYPE_NAME (type) = build_decl (TYPE_DECL, get_identifier (name), type);
#endif
+ TYPE_STUB_DECL (type) = TYPE_NAME (type);
layout_decl (TYPE_NAME (type), 0);
}
\f
{
tree decl = TREE_VALUE (pending_statics);
- if (TREE_USED (decl) == 1
- || TREE_READONLY (decl) == 0
- || DECL_INITIAL (decl) == 0)
- {
- DECL_DEFER_OUTPUT (decl) = 0;
- rest_of_decl_compilation (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), 1, 1);
- }
+ /* Output DWARF debug information. */
+#ifdef DWARF_DEBUGGING_INFO
+ if (write_symbols == DWARF_DEBUG)
+ dwarfout_file_scope_decl (decl, 1);
+#endif
+#ifdef DWARF2_DEBUGGING_INFO
+ if (write_symbols == DWARF2_DEBUG)
+ dwarf2out_decl (decl);
+#endif
+
+ DECL_DEFER_OUTPUT (decl) = 0;
+ rest_of_decl_compilation
+ (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), 1, 1);
+
pending_statics = TREE_CHAIN (pending_statics);
}
if (TREE_CODE (t) == PARM_DECL)
return DECL_SOURCE_FILE (DECL_CONTEXT (t));
else if (TREE_CODE_CLASS (TREE_CODE (t)) == 't')
- return DECL_SOURCE_FILE (TYPE_NAME (t));
+ return DECL_SOURCE_FILE (TYPE_MAIN_DECL (t));
else
return DECL_SOURCE_FILE (t);
}
t = TREE_TYPE (t);
if (TREE_CODE_CLASS (TREE_CODE (t)) == 't')
- line = DECL_SOURCE_LINE (TYPE_NAME (t));
+ line = DECL_SOURCE_LINE (TYPE_MAIN_DECL (t));
else
line = DECL_SOURCE_LINE (t);
if (declp)
/* It's a function decl. */
{
- tree list = DECL_FRIENDLIST (TYPE_NAME (type));
+ tree list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type));
tree name = DECL_NAME (supplicant);
tree ctype;
if (type == supplicant)
return 1;
- list = CLASSTYPE_FRIEND_CLASSES (TREE_TYPE (TYPE_NAME (type)));
+ list = CLASSTYPE_FRIEND_CLASSES (TREE_TYPE (TYPE_MAIN_DECL (type)));
for (; list ; list = TREE_CHAIN (list))
if (supplicant == TREE_VALUE (list))
return 1;
if (IS_AGGR_TYPE (supplicant))
context = NULL_TREE;
else
- context = DECL_CONTEXT (TYPE_NAME (supplicant));
+ context = DECL_CONTEXT (TYPE_MAIN_DECL (supplicant));
}
else if (DECL_FUNCTION_MEMBER_P (supplicant))
context = DECL_CLASS_CONTEXT (supplicant);
add_friend (type, decl)
tree type, decl;
{
- tree typedecl = TYPE_NAME (type);
+ tree typedecl = TYPE_MAIN_DECL (type);
tree list = DECL_FRIENDLIST (typedecl);
tree name = DECL_NAME (decl);
add_friends (type, name, friend_type)
tree type, name, friend_type;
{
- tree typedecl = TYPE_NAME (type);
+ tree typedecl = TYPE_MAIN_DECL (type);
tree list = DECL_FRIENDLIST (typedecl);
while (list)
if (IS_SIGNATURE (friend_type))
{
error ("signature type `%s' declared `friend'",
- IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (friend_type))));
+ IDENTIFIER_POINTER (TYPE_IDENTIFIER (friend_type)));
return;
}
if (type == friend_type)
warning ("implicitly declaring `%s' as struct",
IDENTIFIER_POINTER (declarator));
decl = xref_tag (record_type_node, declarator, NULL_TREE, 1);
- decl = TYPE_NAME (decl);
+ decl = TYPE_MAIN_DECL (decl);
}
/* Allow abbreviated declarations of overloaded functions,
{
/* An aggregate type. */
type = IDENTIFIER_TYPE_VALUE (decl);
- decl = TYPE_NAME (type);
+ decl = TYPE_MAIN_DECL (type);
}
else
{
{
type = decl;
true_type = type;
- decl = TYPE_NAME (type);
+ decl = TYPE_MAIN_DECL (type);
}
if (processing_template_decl)
if (CLASSTYPE_INTERFACE_KNOWN (type))
{
if (CLASSTYPE_INTERFACE_ONLY (type))
- set_typedecl_interface_info (prev, TYPE_NAME (type));
+ set_typedecl_interface_info (prev, TYPE_MAIN_DECL (type));
else
CLASSTYPE_VTABLE_NEEDS_WRITING (type) = 1;
DECL_EXTERNAL (vars) = CLASSTYPE_INTERFACE_ONLY (type);
do (IDENTIFIER_GLOBAL_VALUE (node));
#undef do
/* Will this one ever happen? */
- if (TYPE_NAME (type))
- return TYPE_NAME (type);
+ if (TYPE_MAIN_DECL (type))
+ return TYPE_MAIN_DECL (type);
/* We used to do an internal error of 62 here, but instead we will
handle the return of a null appropriately in the callers. */
))
{
pedwarn ("floating point number exceeds range of `%s'",
- IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
+ IDENTIFIER_POINTER (TYPE_IDENTIFIER (type)));
}
/* Note: garbage_chars is -1 if first char is *not* garbage. */
while (isalnum (c))
{
tree context = DECL_CONTEXT (decl);
if (TREE_CODE_CLASS (TREE_CODE (context)) == 't')
- context = TYPE_MAIN_DECL (context);
+ context = TYPE_NAME (context);
build_overload_nested_name (context);
}
if (i > 9)
OB_PUTC ('_');
numeric_output_need_bar = 0;
- build_overload_nested_name (TYPE_MAIN_DECL (parmtype));
+ build_overload_nested_name (TYPE_NAME (parmtype));
}
else
- build_overload_identifier (TYPE_MAIN_DECL (parmtype));
+ build_overload_identifier (TYPE_NAME (parmtype));
break;
}
id = get_identifier (obstack_base (&scratch_obstack));
IDENTIFIER_OPNAME_P (id) = 1;
#if 0
- IDENTIFIER_GLOBAL_VALUE (id) = TYPE_NAME (type);
+ IDENTIFIER_GLOBAL_VALUE (id) = TYPE_MAIN_DECL (type);
#endif
TREE_TYPE (id) = type;
return id;
{ $$ = build_x_conditional_expr ($$, $3, $5); }
| expr_no_commas '=' expr_no_commas
{ $$ = build_x_modify_expr ($$, NOP_EXPR, $3);
- C_SET_EXP_ORIGINAL_CODE ($$, MODIFY_EXPR); }
+ if ($$ != error_mark_node)
+ C_SET_EXP_ORIGINAL_CODE ($$, MODIFY_EXPR); }
| expr_no_commas ASSIGN expr_no_commas
{ $$ = build_x_modify_expr ($$, $2, $3); }
| THROW
{
current_aggr = $1;
if (TREE_CODE ($3) == TYPE_DECL)
- {
- $$ = $3;
- note_debug_info_needed (DECL_CONTEXT ($$));
- }
+ $$ = $3;
else
{
cp_error ("`%T' does not have a nested type named `%D'",
tree t = make_lang_type (TEMPLATE_TYPE_PARM);
CLASSTYPE_GOT_SEMICOLON (t) = 1;
decl = build_decl (TYPE_DECL, TREE_VALUE (parm), t);
- TYPE_MAIN_DECL (t) = decl;
+ TYPE_NAME (t) = decl;
+ TYPE_STUB_DECL (t) = decl;
parm = decl;
TEMPLATE_TYPE_SET_INFO (t, idx, processing_template_decl);
}
else
arg = TREE_VALUE (arg);
}
- else
+ else if (TREE_CODE (TREE_VALUE (TREE_VEC_ELT (parms, i)))
+ == TYPE_DECL)
arg = tsubst (TREE_PURPOSE (TREE_VEC_ELT (parms, i)),
&TREE_VEC_ELT (vec, 0), i, in_decl);
+ else
+ arg = tsubst_expr (TREE_PURPOSE (TREE_VEC_ELT (parms, i)),
+ &TREE_VEC_ELT (vec, 0), i, in_decl);
TREE_VEC_ELT (vec, i) = arg;
}
}
case TYPE_DECL:
+ if (t == TYPE_NAME (TREE_TYPE (t)))
+ return TYPE_NAME (type);
+
{
tree r = copy_node (t);
TREE_TYPE (r) = type;
if (methods == 0)
return;
- /* We can't do the TYPE_DECL_SUPPRESS_DEBUG thing with DWARF, which
- does not support name references between translation units. Well, we
- could, but that would mean putting global labels in the debug output
- before each exported type and each of its functions and static data
- members. */
- if (write_symbols == DWARF_DEBUG || write_symbols == DWARF2_DEBUG)
- {
- rest_of_type_compilation (t, global_bindings_p ());
- return;
- }
-
/* If interface info is known, either we've already emitted the debug
info or we don't need to. */
if (CLASSTYPE_INTERFACE_KNOWN (t)
if (current_template_parms)
return;
+ /* We can't do the TYPE_DECL_SUPPRESS_DEBUG thing with DWARF, which
+ does not support name references between translation units. Well, we
+ could, but that would mean putting global labels in the debug output
+ before each exported type and each of its functions and static data
+ members. */
+ if (write_symbols == DWARF_DEBUG || write_symbols == DWARF2_DEBUG)
+ return;
+
dfs_walk (TYPE_BINFO (type), dfs_debug_mark, dfs_debug_unmarkedp);
for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
{
else
dont_add = 1;
}
- else if (context && TYPE_DERIVES_FROM (context, type))
+ /* If we don't check CLASSTYPE_CID on CONTEXT right now, we'll end
+ up subtracting from the address of MI_MATRIX, putting us off
+ in la la land. */
+ else if (context
+ && CLASSTYPE_CID (context)
+ && TYPE_DERIVES_FROM (context, type))
{
/* Don't add in *values to list */
*values = NULL_TREE;
? DECL_CLASS_CONTEXT (value)
: DECL_CONTEXT (value);
- if (context && TYPE_DERIVES_FROM (context, type))
+ /* If we don't check CLASSTYPE_CID on CONTEXT right now, we'll end
+ up subtracting from the address of MI_MATRIX, putting us off
+ in la la land. */
+ if (context
+ && CLASSTYPE_CID (context)
+ && TYPE_DERIVES_FROM (context, type))
{
/* remove *tmp from list */
*tmp = TREE_CHAIN (*tmp);
them too. */
DECL_ASSEMBLER_NAME (decl) = get_identifier (VTABLE_BASE);
DECL_VIRTUAL_P (decl) = 1;
+ DECL_ARTIFICIAL (decl) = 1;
DECL_FIELD_CONTEXT (decl) = rec;
DECL_CLASS_CONTEXT (decl) = rec;
DECL_FCONTEXT (decl) = basetype;
}
else
{
+ tree name = component;
+ if (TREE_CODE (component) == VAR_DECL)
+ name = DECL_NAME (component);
if (basetype_path == NULL_TREE)
basetype_path = TYPE_BINFO (basetype);
- field = lookup_field (basetype_path, component,
- protect && ! VFIELD_NAME_P (component), 0);
+ field = lookup_field (basetype_path, name,
+ protect && !VFIELD_NAME_P (name), 0);
if (field == error_mark_node)
return error_mark_node;
/* Not found as a data field, look for it as a method. If found,
then if this is the only possible one, return it, else
report ambiguity error. */
- tree fndecls = lookup_fnfields (basetype_path, component, 1);
+ tree fndecls = lookup_fnfields (basetype_path, name, 1);
if (fndecls == error_mark_node)
return error_mark_node;
if (fndecls)
}
}
- cp_error ("`%#T' has no member named `%D'", basetype, component);
+ cp_error ("`%#T' has no member named `%D'", basetype, name);
return error_mark_node;
}
else if (TREE_TYPE (field) == error_mark_node)
else if (binfo == error_mark_node)
return error_mark_node;
- return build (OFFSET_REF, rettype, datum, component);
+ component = build (OFFSET_REF, rettype, datum, component);
+ if (TREE_CODE (type) == OFFSET_TYPE)
+ component = resolve_offset_ref (component);
+ return component;
}
/* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
OSDN Git Service
