Skip to content

R
riscv-gcc-1
Commit db5ae43f by Mike Stump
Options

49th Cygnus<->FSF merge 

From-SVN: r8570
parent c7a7ac46
Showing with 875 additions and 662 deletions
gcc/cp/Make-lang.in
......@@ -61,7 +61,7 @@ g++: $(srcdir)/cp/g++.c $(CONFIG_H) $(LIBDEPS)
$(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)
......
gcc/cp/Makefile.in
......@@ -187,15 +187,26 @@ RTL_H = $(srcdir)/../rtl.h $(srcdir)/../rtl.def \
TREE_H = $(srcdir)/../tree.h $(srcdir)/../real.h $(srcdir)/../tree.def \
$(srcdir)/../machmode.h $(srcdir)/../machmode.def
CXX_TREE_H = $(TREE_H) cp-tree.h 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,
......@@ -206,9 +217,9 @@ $(srcdir)/hash.h:
$(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 \
......@@ -229,7 +240,7 @@ expr.o : expr.c $(CONFIG_H) $(CXX_TREE_H) $(RTL_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
......
gcc/cp/call.c
......@@ -525,13 +525,6 @@ convert_harshness (type, parmtype, parm)
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
......@@ -551,6 +544,13 @@ convert_harshness (type, parmtype, parm)
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)
......@@ -2197,6 +2197,12 @@ build_method_call (instance, name, parms, basetype_path, flags)
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))
......@@ -2434,6 +2440,13 @@ build_method_call (instance, name, parms, basetype_path, flags)
/* 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);
......
gcc/cp/cp-tree.h
......@@ -408,7 +408,7 @@ struct lang_type
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;
......@@ -442,13 +442,12 @@ struct lang_type
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;
......@@ -495,7 +494,7 @@ struct lang_type
char *mi_matrix;
union tree_node *conversions[last_conversion_type];
union tree_node *dossier;
union tree_node *rtti;
union tree_node *methods;
......@@ -629,8 +628,8 @@ struct lang_type
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. */
......@@ -816,8 +815,6 @@ struct lang_type
/* 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)
......@@ -947,7 +944,10 @@ struct lang_decl_flags
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;
......@@ -1032,6 +1032,10 @@ struct lang_decl
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)
......@@ -1322,6 +1326,18 @@ struct lang_decl
#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. */
......@@ -1330,7 +1346,7 @@ struct lang_decl
/* 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. */
......@@ -1387,8 +1403,14 @@ extern tree void_zero_node;
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;
......@@ -1402,7 +1424,7 @@ extern tree error_mark_list;
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".
......@@ -1419,11 +1441,6 @@ extern tree long_long_integer_type_node, long_long_unsigned_type_node;
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
......@@ -1715,9 +1732,9 @@ extern int flag_int_enum_equivalence;
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. */
......@@ -1782,7 +1799,8 @@ extern tree current_class_type; /* _TYPE: the type of the current class */
#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)
......@@ -1953,7 +1971,7 @@ extern tree grok_enum_decls PROTO((tree, tree));
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));
......
gcc/cp/cvt.c
......@@ -663,10 +663,12 @@ convert_to_reference (reftype, expr, convtype, flags, decl)
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;
}
......@@ -725,7 +727,8 @@ convert_to_reference (reftype, expr, convtype, flags, decl)
&& (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;
......@@ -736,7 +739,8 @@ convert_to_reference (reftype, expr, convtype, flags, decl)
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;
......@@ -750,7 +754,8 @@ convert_to_reference (reftype, expr, convtype, flags, decl)
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;
......@@ -1283,12 +1288,9 @@ cp_convert (type, expr, convtype, flags)
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
......@@ -1321,87 +1323,78 @@ cp_convert (type, expr, convtype, flags)
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;
}
}
......@@ -1483,9 +1476,9 @@ build_type_conversion_1 (xtype, basetype, expr, typename, for_sure)
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)
......@@ -1615,9 +1608,9 @@ build_type_conversion (code, xtype, expr, for_sure)
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);
......
gcc/cp/decl.h
......@@ -22,6 +22,7 @@ enum decl_context
{ 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) */
......
gcc/cp/decl2.c
......@@ -301,9 +301,9 @@ int flag_cadillac;
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. */
......@@ -365,7 +365,7 @@ static struct { char *string; int *variable; int on_value;} lang_f_options[] =
{"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},
......@@ -442,14 +442,14 @@ lang_decode_option (p)
{
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"))
......@@ -707,15 +707,10 @@ grok_x_components (specs, components)
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;
......@@ -2170,7 +2165,9 @@ finish_table (name, type, init, publicp)
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);
......@@ -2347,9 +2344,6 @@ mark_vtable_entries (decl)
{
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));
......@@ -2439,14 +2433,18 @@ finish_vtable_vardecl (prev, vars)
/* 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);
......@@ -2565,30 +2563,32 @@ void
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) \
......@@ -2693,7 +2693,7 @@ finish_file ()
poplevel (1, 0, 0);
pop_momentary ();
finish_function (lineno, 0);
finish_function (lineno, 0, 0);
assemble_destructor (IDENTIFIER_POINTER (fnname));
......@@ -2818,7 +2818,7 @@ finish_file ()
poplevel (1, 0, 0);
pop_momentary ();
finish_function (lineno, 0);
finish_function (lineno, 0, 0);
assemble_constructor (IDENTIFIER_POINTER (fnname));
}
......@@ -2871,74 +2871,86 @@ finish_file ()
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;
}
}
}
......
gcc/cp/except.c
......@@ -43,6 +43,9 @@ tree builtin_return_address_fndecl;
#define TRY_NEW_EH
#endif
#endif
#if defined(__i386) || defined(__rs6000) || defined(__hppa)
#define TRY_NEW_EH
#endif
#endif
#ifndef TRY_NEW_EH
......@@ -188,60 +191,6 @@ easy_expand_asm (str)
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. */
......@@ -834,10 +783,26 @@ init_exception_processing ()
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);
......@@ -1112,7 +1077,7 @@ expand_start_catch_block (declspecs, declarator)
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);
......@@ -1247,6 +1212,82 @@ do_function_call (func, params, return_type)
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.
......@@ -1306,6 +1347,12 @@ expand_builtin_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);
......@@ -1344,7 +1391,8 @@ expand_exception_blocks ()
{
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 ();
......@@ -1394,7 +1442,7 @@ expand_throw (exp)
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);
......@@ -1437,7 +1485,8 @@ build_exception_table ()
/* 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,
......@@ -1449,7 +1498,8 @@ build_exception_table ()
{
/* 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 */
......@@ -1472,7 +1522,10 @@ tree
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;
}
gcc/cp/gxx.gperf
......@@ -27,7 +27,11 @@ __volatile, TYPE_QUAL, RID_VOLATILE
__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,
......@@ -35,6 +39,7 @@ catch, CATCH, 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,
......@@ -45,6 +50,7 @@ double, TYPESPEC, RID_DOUBLE,
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,
......@@ -57,8 +63,13 @@ inline, SCSPEC, RID_INLINE,
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,
......@@ -75,17 +86,21 @@ static, SCSPEC, RID_STATIC,
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,
gcc/cp/gxxint.texi
......@@ -1185,7 +1185,7 @@ On an rs6000, xlC stores exception objects on that stack, under the try
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.
......
gcc/cp/init.c
......@@ -125,6 +125,7 @@ expand_direct_vtbls_init (real_binfo, binfo, init_self, can_elide, addr)
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++)
{
......@@ -133,8 +134,12 @@ expand_direct_vtbls_init (real_binfo, binfo, init_self, can_elide, addr)
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. */
......@@ -142,7 +147,7 @@ expand_direct_vtbls_init (real_binfo, binfo, init_self, can_elide, addr)
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);
......@@ -421,13 +426,14 @@ emit_base_init (t, immediately)
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);
......@@ -449,9 +455,9 @@ emit_base_init (t, immediately)
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;
}
}
......@@ -641,9 +647,8 @@ emit_base_init (t, immediately)
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;
}
......@@ -745,8 +750,7 @@ expand_aggr_vbase_init_1 (binfo, exp, addr, init_list)
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);
}
......@@ -1196,12 +1200,12 @@ expand_default_init (binfo, true_exp, exp, type, init, alias_this, flags)
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))
{
......@@ -1213,16 +1217,6 @@ expand_default_init (binfo, true_exp, exp, type, init, alias_this, flags)
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)
......@@ -1232,114 +1226,43 @@ expand_default_init (binfo, true_exp, exp, type, init, alias_this, flags)
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
......@@ -2707,7 +2630,6 @@ do_friend (ctype, declarator, decl, parmdecls, flags, quals)
{
/* 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;
......
gcc/cp/lex.c
......@@ -660,6 +660,9 @@ init_lex ()
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]));
......@@ -681,11 +684,6 @@ init_lex ()
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;
......@@ -790,7 +788,7 @@ init_lex ()
}
#endif
if (! (flag_gc || flag_dossier))
if (! (flag_gc || flag_rtti))
{
UNSET_RESERVED_WORD ("classof");
UNSET_RESERVED_WORD ("headof");
......@@ -806,6 +804,17 @@ init_lex ()
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;
......@@ -1125,19 +1134,7 @@ do_pending_inlines ()
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
......@@ -1712,6 +1709,7 @@ cons_up_default_function (type, name, kind)
tree fn, args;
tree argtype;
int retref = 0;
int complex = 0;
name = constructor_name (name);
switch (kind)
......@@ -1722,10 +1720,13 @@ cons_up_default_function (type, name, 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:
......@@ -1739,6 +1740,7 @@ cons_up_default_function (type, name, kind)
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:
......@@ -1755,6 +1757,7 @@ cons_up_default_function (type, name, kind)
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:
......@@ -1777,20 +1780,34 @@ cons_up_default_function (type, name, kind)
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;
......@@ -3474,6 +3491,52 @@ real_yylex ()
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;
}
}
......
gcc/cp/lex.h
......@@ -58,6 +58,7 @@ enum rid
RID_VOLATILE,
RID_FRIEND,
RID_VIRTUAL,
RID_EXPLICIT,
RID_SIGNED,
RID_AUTO,
RID_MUTABLE,
......
gcc/cp/method.c
......@@ -59,6 +59,7 @@ static char *scratch_firstobj;
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 ();
......@@ -317,19 +318,39 @@ static int numeric_outputed_need_bar;
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
......@@ -514,6 +535,7 @@ build_overload_name (parmtypes, begin, end)
tree parmtype;
if (begin) OB_INIT ();
numeric_outputed_need_bar = 0;
if ((just_one = (TREE_CODE (parmtypes) != TREE_LIST)))
{
......@@ -761,6 +783,13 @@ build_overload_name (parmtypes, begin, end)
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;
......@@ -779,8 +808,8 @@ build_overload_name (parmtypes, begin, end)
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);
......@@ -920,7 +949,6 @@ build_decl_overload (dname, parms, for_method)
{
ALLOCATE_TYPEVEC (parms);
nofold = 0;
numeric_outputed_need_bar = 0;
if (for_method)
{
build_overload_name (TREE_VALUE (parms), 0, 0);
......@@ -1906,6 +1934,10 @@ emit_thunk (thunk_fndecl)
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;
......@@ -1971,16 +2003,6 @@ emit_thunk (thunk_fndecl)
/* 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
......@@ -2000,14 +2022,12 @@ largest_union_member (type)
/* 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 ();
......@@ -2085,17 +2105,15 @@ build_copy_constructor (fndecl)
}
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);
......@@ -2158,14 +2176,45 @@ build_assign_ref (fndecl)
}
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);
}
gcc/cp/parse.y
......@@ -150,6 +150,7 @@ empty_parms ()
%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
......@@ -170,6 +171,7 @@ empty_parms ()
%left '{' ',' ';'
%nonassoc THROW
%right <code> ASSIGN '='
%right <code> '?' ':'
%left <code> OROR
......@@ -190,7 +192,7 @@ empty_parms ()
%left <code> POINTSAT '.' '(' '['
%right SCOPE /* C++ extension */
%nonassoc NEW DELETE TRY CATCH THROW
%nonassoc NEW DELETE TRY CATCH
%type <code> unop
......@@ -430,9 +432,7 @@ template_def:
{
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? :-) */
......@@ -564,7 +564,7 @@ datadef:
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);
......@@ -577,7 +577,7 @@ fndef:
}
| 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);
......@@ -589,13 +589,13 @@ fndef:
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
{}
......@@ -1148,7 +1148,7 @@ sub_cast_expr:
{
tree type = IDENTIFIER_TYPE_VALUE ($3);
if (! IS_SIGNATURE(type))
$$ = CLASSTYPE_DOSSIER (type);
$$ = CLASSTYPE_RTTI (type);
else
{
sorry ("signature name as argument of `classof'");
......@@ -2109,9 +2109,6 @@ structsp:
if (TREE_CODE ($$) == ENUMERAL_TYPE)
/* $$ = $1 from default rule. */;
else if (CLASSTYPE_DECLARED_EXCEPTION ($$))
{
}
else
{
$$ = finish_struct ($$, $3, semi);
......@@ -2435,8 +2432,12 @@ left_curly: '{'
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
......@@ -3422,7 +3423,7 @@ handler_args:
{ 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)); }
......
gcc/cp/pt.c
......@@ -97,8 +97,7 @@ process_template_parm (list, next)
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;
......@@ -466,7 +465,7 @@ coerce_template_parms (parms, arglist, in_decl)
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;
......@@ -683,7 +682,8 @@ push_template_decls (parmlist, arglist, class_level)
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;
}
......@@ -834,6 +834,11 @@ uses_template_parms (t)
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)))
{
......@@ -898,19 +903,6 @@ instantiate_member_templates (classname)
&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. */
......@@ -1116,15 +1108,11 @@ lookup_nested_type_by_name (ctype, name)
{
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;
}
......@@ -1198,9 +1186,12 @@ tsubst (t, args, nargs, in_decl)
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)];
......@@ -1404,9 +1395,10 @@ tsubst (t, args, nargs, in_decl)
}
}
}
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 */
......@@ -1719,10 +1711,21 @@ instantiate_template (tmpl, targ_ptr)
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;
......@@ -2008,6 +2011,9 @@ type_unification (tparms, targs, parms, args, nsubsts, subr)
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
......@@ -2068,9 +2074,6 @@ unify (tparms, targs, ntparms, parm, arg, nsubsts)
if (arg == parm)
return 0;
if (TREE_CODE (arg) == REFERENCE_TYPE)
arg = TREE_TYPE (arg);
switch (TREE_CODE (parm))
{
case TEMPLATE_TYPE_PARM:
......@@ -2082,6 +2085,7 @@ unify (tparms, targs, ntparms, parm, arg, nsubsts)
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). */
......@@ -2089,6 +2093,13 @@ unify (tparms, targs, ntparms, parm, arg, nsubsts)
|| 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;
......@@ -2205,22 +2216,19 @@ unify (tparms, targs, ntparms, parm, arg, nsubsts)
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);
......@@ -2295,6 +2303,9 @@ do_pending_expansions ()
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?
......@@ -2425,17 +2436,14 @@ do_function_instantiation (declspecs, declarator, storage)
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])
;
......@@ -2475,7 +2483,7 @@ do_type_instantiation (name, storage)
}
/* 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);
......@@ -2485,22 +2493,29 @@ do_type_instantiation (name, storage)
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)
......@@ -2509,12 +2524,12 @@ do_type_instantiation (name, storage)
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;
}
}
......
gcc/cp/search.c
......@@ -377,8 +377,8 @@ pop_memoized_context (use_old)
type_stack = (struct type_level *)type_stack->base.prev;
}
#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
......@@ -1995,12 +1995,9 @@ get_abstract_virtuals_1 (binfo, do_self, abstract_virtuals)
/* 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));
......@@ -2417,10 +2414,10 @@ dfs_init_vbase_pointers (binfo)
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);
......
gcc/cp/tree.c
......@@ -1250,9 +1250,8 @@ debug_binfo (elem)
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)
......
gcc/cp/typeck.c
......@@ -3404,6 +3404,10 @@ build_binary_op_nodefault (code, orig_op0, orig_op1, error_code)
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
......@@ -3756,8 +3760,12 @@ build_x_unary_op (code, xarg)
{
/* & 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);
......@@ -3813,6 +3821,9 @@ build_unary_op (code, xarg, noconvert)
if (typecode == ENUMERAL_TYPE)
typecode = INTEGER_TYPE;
if (typecode == BOOLEAN_TYPE && ! noconvert)
typecode = INTEGER_TYPE;
isaggrtype = IS_AGGR_TYPE_CODE (typecode);
switch (code)
......@@ -5435,7 +5446,14 @@ build_modify_expr (lhs, modifycode, rhs)
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),
......@@ -5449,7 +5467,17 @@ build_modify_expr (lhs, modifycode, 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));
......@@ -5655,6 +5683,8 @@ build_modify_expr (lhs, modifycode, rhs)
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
......@@ -5673,14 +5703,6 @@ build_modify_expr (lhs, modifycode, rhs)
|| (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;
......@@ -5756,8 +5778,8 @@ build_modify_expr (lhs, modifycode, rhs)
TYPE_BINFO (lhstype)),
result);
return build_compound_expr (result);
#endif
}
#endif
/* Convert new value to destination type. */
......@@ -5811,6 +5833,7 @@ build_modify_expr (lhs, modifycode, rhs)
}
else
{
#if 0
if (IS_AGGR_TYPE (lhstype))
{
if (result = build_opfncall (MODIFY_EXPR,
......@@ -5818,6 +5841,7 @@ build_modify_expr (lhs, modifycode, rhs)
make_node (NOP_EXPR)))
return result;
}
#endif
/* Avoid warnings on enum bit fields. */
if (TREE_CODE (olhstype) == ENUMERAL_TYPE
&& TREE_CODE (lhstype) == INTEGER_TYPE)
......@@ -6603,8 +6627,7 @@ convert_for_assignment (type, rhs, errtype, fndecl, parmnum)
`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);
......@@ -6742,6 +6765,8 @@ convert_for_initialization (exp, type, rhs, flags, errtype, fndecl, parmnum)
}
/* 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);
......
gcc/cp/typeck2.c
......@@ -329,7 +329,7 @@ ack (s, v, v2)
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;
......@@ -1342,6 +1342,7 @@ build_m_component_ref (datum, component)
if (TREE_CODE (objtype) == REFERENCE_TYPE)
objtype = TREE_TYPE (objtype);
objtype = TYPE_MAIN_VARIANT (objtype);
if (! IS_AGGR_TYPE (objtype))
{
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment