+Tue Jun 14 12:23:38 1994 Jason Merrill (jason@deneb.cygnus.com)
+
+ * decl.c (grok_op_properties): Const objects can be passed by value.
+
+Mon Jun 13 03:10:59 1994 Jason Merrill (jason@deneb.cygnus.com)
+
+ * decl2.c (import_export_vtable): Force implicit instantiations to
+ be interface_only when -fno-implicit-templates.
+
+ * decl.c (duplicate_decls): Redeclaring a class template name is an
+ error.
+
+ * pt.c (end_template_decl): Call GNU_xref_decl for class templates.
+ * xref.c (GNU_xref_decl): Support templates.
+
+Sat Jun 11 17:09:05 1994 Jason Merrill (jason@deneb.cygnus.com)
+
+ * decl.c (grok_op_properties): Split out checking for whether this
+ function should suppress the default assignment operator.
+ * decl2.c (grok_function_init): Ditto.
+ (copy_assignment_arg_p): New function do do just that.
+ Now considers virtual assignment operators that take a base as an
+ argument to count as copy assignment operators.
+
+ * search.c (dfs_debug_mark): Lose checks for DWARF_DEBUG and
+ TREE_ASM_WRITTEN, as they are redundant.
+
+ * pt.c (end_template_decl): Don't try to set DECL_CLASS_CONTEXT on a
+ decl that has no LANG_SPECIFIC part.
+ (do_type_instantiation): Force the debugging information for this
+ type to be emitted.
+
+ * decl.c (start_decl): Clear up uses of various types of templates
+ (say sorry for static data members, rather than "invalid template").
+ (expand_static_init): Fix initialization of static data members of
+ template classes.
+
+Fri Jun 10 00:41:19 1994 Jason Merrill (jason@deneb.cygnus.com)
+
+ * decl.c (grokdeclarator): Set DECL_CONTEXT on static data members.
+
+ * g++.c (main): Use -xc++-cpp-output for .i files.
+
+ * pt.c (tsubst): Give meaningful error about declaring template for
+ a copy constructor which was not declared in the class template.
+ (do_type_instantiation): Explicit instantiation before the class
+ template is an error.
+ (instantiate_template): Don't die if tsubst returns error_mark_node.
+
+Thu Jun 9 19:04:59 1994 Jason Merrill (jason@deneb.cygnus.com)
+
+ Don't synthesize the copy assignment operator if the one in a base
+ class is pure virtual.
+ * cp-tree.h (TYPE_HAS_ABSTRACT_ASSIGN_REF): New macro to indicate
+ whether the type has a pure virtual copy assignment operator.
+ * class.c (finish_base_struct): Don't generate the copy assignment
+ operator if a base class has a pure virtual one.
+ * decl.c (grok_op_properties): Add disabled code to set
+ TYPE_HAS_ABSTRACT_ASSIGN_REF with comment pointing to where it is
+ actually set.
+ * decl2.c (grok_function_init): Set TYPE_HAS_ABSTRACT_ASSIGN_REF.
+
+ * decl2.c (import_export_vtable): Always treat template
+ instantiations as if write_virtuals >= 2, and treat implicit
+ instantiations as external if -fno-implicit-templates.
+ (finish_file): Output all pending inlines if
+ flag_keep_inline_functions.
+
+Wed Jun 8 20:48:02 1994 Mike Stump (mrs@cygnus.com)
+
+ * tree.c (layout_vbasetypes): Align virtual base classes inside
+ complete objects, so that we don't core dump on machines such as
+ SPARCs when we access members that require larger than normal
+ alignments, such as a double. Also, we bump up the total alignment
+ on the complete type, as necessary.
+
+Wed Jun 8 16:18:14 1994 Jason Merrill (jason@deneb.cygnus.com)
+
+ * gxxint.texi (Free Store): New section with code for examining
+ cookie.
+ (Limitations of g++): Remove operator delete entry, since it is no
+ longer accurate. Fix access control entry.
+
+ * typeck.c (build_unary_op): Pedwarn about taking the address of or
+ incrementing a cast to non-reference type.
+ (build_modify_expr): Use convert instead of convert_force again.
+
+ * search.c (get_base_distance): Use IS_AGGR_TYPE_CODE to check for
+ class type, not == RECORD_TYPE.
+
+ * decl.c (grokdeclarator): Cope with grokfndecl returning NULL_TREE.
+
+ * typeck2.c (report_case_error): #if 0 out.
+ * lex.c (real_yylex): Lose RANGE.
+ * parse.y: Ditto.
+
+Tue Jun 7 18:17:35 1994 Jason Merrill (jason@deneb.cygnus.com)
+
+ * parse.y (simple_stmt, case ranges): Use ELLIPSIS instead of RANGE.
+
+Mon Jun 6 19:39:57 1994 Jason Merrill (jason@deneb.cygnus.com)
+
+ * typeck.c (build_c_cast): Don't shortcut conversions to the same
+ type. Don't replace consts with their values here, since that's now
+ done in cp_convert.
+
+ * cvt.c (cp_convert): When converting to bool, take
+ integer_zero_node to false_node and all other INTEGER_CSTs to
+ true_node.
+ (build_type_conversion): Don't complain about multiple conversions
+ to float if we're not really converting.
+
Fri Jun 3 02:10:56 1994 Jason Merrill (jason@deneb.cygnus.com)
+ Implement 'extern template class A<int>;' syntax for suppressing
+ specific implicit instantiations.
+ * cp-tree.h: Update prototypes for do_*_instantiation.
+ * pt.c (do_pending_expansions): Don't compile 'extern' explicit
+ instantiations.
+ (do_function_instantiation): Set DECL_EXTERNAL on 'extern' explicit
+ instantiations.
+ (do_type_instantiation): Ditto.
+ * parse.y (explicit_instantiation): Support 'extern template class
+ A<int>;' syntax.
+ * decl.c (start_function): Don't modify the settings of TREE_PUBLIC
+ and DECL_EXTERNAL on explicit instantiations.
+
* cvt.c (cp_convert): Replace constants with their values before
converting.
+ (cp_convert): Consistently use 'e' instead of 'expr'.
Thu Jun 2 03:53:30 1994 Jason Merrill (jason@deneb.cygnus.com)
&& !TYPE_HAS_CONST_ASSIGN_REF (basetype))
b->no_const_asn_ref = 1;
if (! TYPE_HAS_ASSIGN_REF (basetype)
+ || TYPE_HAS_ABSTRACT_ASSIGN_REF (basetype)
|| (TYPE_HAS_NONPUBLIC_ASSIGN_REF (basetype) == 2
&& ! is_friend_type (t, basetype)))
b->cant_synth_asn_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 : 20;
+ unsigned dummy : 19;
unsigned n_vancestors : 16;
} type_flags;
/* Nonzero if there is a user-defined X::op=(x&) for this class. */
#define TYPE_HAS_REAL_ASSIGN_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_real_assign_ref)
#define TYPE_HAS_COMPLEX_ASSIGN_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_complex_assign_ref)
+#define TYPE_HAS_ABSTRACT_ASSIGN_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_abstract_assign_ref)
#define TYPE_HAS_COMPLEX_INIT_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_complex_init_ref)
/* Nonzero for _TYPE node means that destroying an object of this type
extern int do_pending_expansions PROTO((void));
extern void do_pending_templates PROTO((void));
struct tinst_level *tinst_for_decl PROTO((void));
-extern void do_function_instantiation PROTO((tree, tree));
+extern void do_function_instantiation PROTO((tree, tree, tree));
+extern void do_type_instantiation PROTO((tree, tree));
extern tree create_nested_upt PROTO((tree, tree));
/* in search.c */
register tree e = expr;
register enum tree_code code = TREE_CODE (type);
- if (type == TREE_TYPE (expr)
- || TREE_CODE (expr) == ERROR_MARK)
- return expr;
- if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
+ if (type == TREE_TYPE (e)
+ || TREE_CODE (e) == ERROR_MARK)
+ return e;
+ if (TREE_CODE (TREE_TYPE (e)) == ERROR_MARK)
return error_mark_node;
/* Trivial conversion: cv-qualifiers do not matter on rvalues. */
- if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (expr)))
- return fold (build1 (NOP_EXPR, type, expr));
+ if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (e)))
+ return fold (build1 (NOP_EXPR, type, e));
if (code == VOID_TYPE && (convtype & CONV_STATIC))
return build1 (CONVERT_EXPR, type, e);
#if 0
/* This is incorrect. A truncation can't be stripped this way.
Extensions will be stripped by the use of get_unwidened. */
- if (TREE_CODE (expr) == NOP_EXPR)
- return convert (type, TREE_OPERAND (expr, 0));
+ if (TREE_CODE (e) == NOP_EXPR)
+ return convert (type, TREE_OPERAND (e, 0));
#endif
/* Just convert to the type of the member. */
if (INTEGRAL_CODE_P (code))
{
- tree intype = TREE_TYPE (expr);
+ tree intype = TREE_TYPE (e);
enum tree_code form = TREE_CODE (intype);
/* enum = enum, enum = int, enum = float are all errors. */
if (flag_int_enum_equivalence == 0
else if (IS_AGGR_TYPE (intype))
{
tree rval;
- rval = build_type_conversion (CONVERT_EXPR, type, expr, 1);
+ rval = build_type_conversion (CONVERT_EXPR, type, e, 1);
if (rval) return rval;
if (code == BOOLEAN_TYPE)
cp_error ("`%#T' used where a `bool' was expected", intype);
e = newe;
if (TREE_TYPE (e) == bool_type_node)
return e;
+ else if (TREE_CODE (e) == INTEGER_CST)
+ {
+ if (e == integer_zero_node)
+ e = false_node;
+ else
+ e = true_node;
+ }
else
return build1 (NOP_EXPR, bool_type_node, e);
}
}
}
- /* If TYPE or TREE_TYPE (EXPR) is not on the permanent_obstack,
+ /* If TYPE or TREE_TYPE (E) is not on the permanent_obstack,
then the it won't be hashed and hence compare as not equal,
even when it is. */
if (code == ARRAY_TYPE
- && TREE_TYPE (TREE_TYPE (expr)) == TREE_TYPE (type)
- && index_type_equal (TYPE_DOMAIN (TREE_TYPE (expr)), TYPE_DOMAIN (type)))
- return expr;
+ && TREE_TYPE (TREE_TYPE (e)) == TREE_TYPE (type)
+ && index_type_equal (TYPE_DOMAIN (TREE_TYPE (e)), TYPE_DOMAIN (type)))
+ return e;
cp_error ("conversion from `%T' to non-scalar type `%T' requested",
TREE_TYPE (expr), type);
operator int(). */
if (TYPE_HAS_INT_CONVERSION (basetype))
{
- error ("two possible conversions for type `%s'",
- TYPE_NAME_STRING (type));
- return error_mark_node;
+ if (for_sure)
+ {
+ cp_error ("two possible conversions for type `%T'", type);
+ return error_mark_node;
+ }
+ else
+ return NULL_TREE;
}
typename = DECL_NAME (CLASSTYPE_CONVERSION (basetype, real_conv));
else if (!types_match)
{
if (TREE_CODE (newdecl) == TEMPLATE_DECL)
- return 0;
+ {
+ /* The name of a class template may not be declared to refer to
+ any other template, class, function, object, namespace, value,
+ or type in the same scope. */
+ if (DECL_TEMPLATE_IS_CLASS (olddecl)
+ || DECL_TEMPLATE_IS_CLASS (newdecl))
+ {
+ cp_error ("declaration of template `%#D'", newdecl);
+ cp_error_at ("conflicts with previous declaration `%#D'",
+ olddecl);
+ }
+ return 0;
+ }
if (TREE_CODE (newdecl) == FUNCTION_DECL)
{
if (DECL_LANGUAGE (newdecl) == lang_c
return NULL_TREE;
}
- if (/* TREE_CODE (result) == VAR_DECL */ 1)
- {
+ if (TREE_CODE (result) == FUNCTION_DECL)
+ return tem;
+ else if (TREE_CODE (result) == VAR_DECL)
+ {
#if 0
tree tmpl = UPT_TEMPLATE (type);
DECL_TEMPLATE_MEMBERS (tmpl)
= perm_tree_cons (DECL_NAME (tem), tem,
DECL_TEMPLATE_MEMBERS (tmpl));
-#endif
return tem;
+#else
+ sorry ("static data member templates");
+ return NULL_TREE;
+#endif
}
- my_friendly_abort (13);
+ else
+ my_friendly_abort (13);
}
else if (TREE_CODE (result) == FUNCTION_DECL)
/*tem = push_overloaded_decl (tem, 0)*/;
- else if (TREE_CODE (result) == VAR_DECL
- || TREE_CODE (result) == TYPE_DECL)
+ else if (TREE_CODE (result) == VAR_DECL)
+ {
+ cp_error ("data template `%#D' must be member of a class template",
+ result);
+ return NULL_TREE;
+ }
+ else if (TREE_CODE (result) == TYPE_DECL)
{
cp_error ("invalid template `%#D'", result);
return NULL_TREE;
if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
cp_error ("multiple initializations given for `%D'", decl);
}
- else if (current_binding_level != global_binding_level)
+ else if (current_binding_level != global_binding_level
+ && current_binding_level->pseudo_global == 0)
{
/* Emit code to perform this initialization but once. */
tree temp;
decl = grokfndecl (ctype, type, declarator,
virtualp, flags, quals,
raises, friendp ? -1 : 0, publicp);
+ if (decl == NULL_TREE)
+ return NULL_TREE;
+
DECL_INLINE (decl) = inlinep;
}
else if (TREE_CODE (type) == METHOD_TYPE)
decl = grokfndecl (ctype, type, declarator,
virtualp, flags, quals,
raises, friendp ? -1 : 0, 1);
+ if (decl == NULL_TREE)
+ return NULL_TREE;
+
DECL_INLINE (decl) = inlinep;
}
else if (TREE_CODE (type) == RECORD_TYPE
raises,
processing_template_decl ? 0 : friendp ? 2 : 1,
publicp);
+ if (decl == NULL_TREE)
+ return NULL_TREE;
if (ctype == NULL_TREE && DECL_LANGUAGE (decl) != lang_c)
DECL_ASSEMBLER_NAME (decl) = declarator;
if (ctype)
{
+ DECL_CONTEXT (decl) = ctype;
if (staticp == 1)
{
cp_error ("static member `%D' re-declared as static",
}
parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
- if (TREE_CODE (parmtype) == REFERENCE_TYPE
- && (TYPE_MAIN_VARIANT (TREE_TYPE (parmtype))
- == current_class_type)
+ if (copy_assignment_arg_p (parmtype, virtualp)
&& ! friendp)
{
TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
- if (TYPE_READONLY (TREE_TYPE (parmtype)))
+ if (TREE_CODE (parmtype) != REFERENCE_TYPE
+ || TYPE_READONLY (TREE_TYPE (parmtype)))
TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
+#if 0 /* Too soon; done in grok_function_init */
+ if (DECL_ABSTRACT_VIRTUAL_P (decl))
+ TYPE_HAS_ABSTRACT_ASSIGN_REF (current_class_type) = 1;
+#endif
}
}
else if (name == ansi_opname[(int) COND_EXPR])
|| (DECL_INLINE (decl1) && ! flag_implement_inlines));
}
else if (DECL_EXPLICIT_INSTANTIATION (decl1))
- {
- TREE_PUBLIC (decl1) = 1;
- DECL_EXTERNAL (decl1) = (DECL_INLINE (decl1)
- && ! flag_implement_inlines);
- }
+ /* PUBLIC and EXTERNAL set by do_*_instantiation */;
else
{
/* This is a definition, not a reference.
*/
+int
+copy_assignment_arg_p (parmtype, virtualp)
+ tree parmtype;
+ int virtualp;
+{
+ if (TREE_CODE (parmtype) == REFERENCE_TYPE)
+ parmtype = TREE_TYPE (parmtype);
+
+ if ((TYPE_MAIN_VARIANT (parmtype) == current_class_type)
+ || (virtualp && DERIVED_FROM_P (parmtype, current_class_type)))
+ return 1;
+
+ return 0;
+}
+
static void
grok_function_init (decl, init)
tree decl;
}
#endif
DECL_ABSTRACT_VIRTUAL_P (decl) = 1;
+ if (DECL_NAME (decl) == ansi_opname [(int) MODIFY_EXPR])
+ {
+ tree parmtype
+ = TREE_VALUE (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl))));
+
+ if (copy_assignment_arg_p (parmtype, 1))
+ TYPE_HAS_ABSTRACT_ASSIGN_REF (current_class_type) = 1;
+ }
}
else if (TREE_CODE (init) == OFFSET_REF
&& TREE_OPERAND (init, 0) == NULL_TREE
import_export_vtable (decl, type)
tree decl, type;
{
- if (write_virtuals >= 2)
+ if (write_virtuals >= 2
+ || CLASSTYPE_TEMPLATE_INSTANTIATION (type))
{
+ if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
+ && ! flag_implicit_templates
+ && CLASSTYPE_INTERFACE_UNKNOWN (type))
+ {
+ SET_CLASSTYPE_INTERFACE_KNOWN (type);
+ CLASSTYPE_INTERFACE_ONLY (type) = 1;
+ CLASSTYPE_VTABLE_NEEDS_WRITING (type) = 0;
+ }
+
if (CLASSTYPE_INTERFACE_KNOWN (type))
{
TREE_PUBLIC (decl) = 1;
|| (DECL_INLINE (decl) && ! flag_implement_inlines));
}
}
- if (TREE_PUBLIC (decl) || TREE_ADDRESSABLE (decl))
+ if (TREE_PUBLIC (decl) || TREE_ADDRESSABLE (decl)
+ || flag_keep_inline_functions)
{
if (DECL_EXTERNAL (decl)
|| (DECL_IMPLICIT_INSTANTIATION (decl)
* Error Reporting::
* Parser::
* Copying Objects::
-* Exception Handling::
+* Exception Handling::
+* Free Store::
* Concept Index::
@end menu
set_identifier_type_value in tandem with the call to
pushdecl_class_level. It would seem to be an omission.
-@cindex delete, two argument
-@item
-For two argument delete, the second argument is always calculated by
-``virtual_size ='' in the source. It currently has a problem, in that
-object size is not calculated by the virtual destructor and passed back
-for the second parameter to delete. Destructors need to return a value
-just like constructors. ANSI C++ Jun 5 92 wp 12.5.6
-
-The second argument is magically deleted in build_method_call, if it is
-not used. It needs to be deleted for global operator delete also.
-
@cindex access checking
@item
-Access checking in general is unimplemented, there are a few cases
-where it is implemented. grok_enum_decls should be used in more places
-to do access checking, but this is only the tip of a bigger problem.
+Access checking is unimplemented for nested types.
@cindex @code{volatile}
@item
This issue is currently under discussion in the core reflector
(2/28/94).
-@node Copying Objects, Concept Index, Copying Objects, Top
+@node Exception Handling, Free Store, Copying Objects, Top
@section Exception Handling
This section describes the mapping of C++ exceptions in the C++
The C++ front-end exceptions are mapping into the unwind-protect
semantics by the C++ front-end. The mapping is describe below.
-Objects with RTTI support, should use the RTTI information to do mapping
+Objects with RTTI support should use the RTTI information to do mapping
and checking. Objects without RTTI, like int and const char *, have to
use another means of matching. Currently we use the normal mangling used in
building functions names. Int's are "i", const char * is PCc, etc...
actions to perform. I hope they add this logic into the back-end, as it
would be nice to get that alternative approach in C++.
-@node Concept Index, , Exception Handling, Top
+@node Free Store, Concept Index, Exception Handling, Top
+@section Free Store
+
+operator new [] adds a magic cookie to the beginning of arrays for which
+the number of elements will be needed by operator delete []. These are
+arrays of objects with destructors and arrays of objects that define
+operator delete [] with the optional size_t argument. This cookie can
+be examined from a program as follows:
+
+@example
+typedef unsigned long size_t;
+extern "C" int printf (const char *, ...);
+
+size_t nelts (void *p)
+@{
+ struct cookie @{
+ size_t nelts __attribute__ ((aligned (sizeof (double))));
+ @};
+
+ cookie *cp = (cookie *)p;
+ --cp;
+
+ return cp->nelts;
+@}
+
+struct A @{
+ ~A() @{ @}
+@};
+
+main()
+@{
+ A *ap = new A[3];
+ printf ("%ld\n", nelts (ap));
+@}
+@end example
+
+@node Concept Index, , Free Store, Top
@section Concept Index
@printindex cp
value = ELLIPSIS;
goto done;
}
- nextchar = c1;
- token_buffer[2] = '\0';
- value = RANGE;
- goto done;
+ error ("parse error at `..'");
}
if (isdigit (c1))
{
value = ELLIPSIS;
goto done;
}
- nextchar = c;
- token_buffer[2] = '\0';
- value = RANGE;
- goto done;
+ error ("parse error at `..'");
}
nextchar = c;
token_buffer[1] = '\0';
%left '{' ',' ';'
%right <code> ASSIGN '='
-%right <code> '?' ':' RANGE
+%right <code> '?' ':'
%left <code> OROR
%left <code> ANDAND
%left <code> '|'
explicit_instantiation:
TEMPLATE specialization template_instantiation
- { do_type_instantiation ($3 ? $3 : $2); }
+ { do_type_instantiation ($3 ? $3 : $2, NULL_TREE); }
| TEMPLATE typed_declspecs declarator
- { do_function_instantiation ($2, $3); }
+ { do_function_instantiation ($2, $3, NULL_TREE); }
+ | SCSPEC TEMPLATE specialization template_instantiation
+ { do_type_instantiation ($4 ? $4 : $3, $1); }
+ | SCSPEC TEMPLATE typed_declspecs declarator
+ { do_function_instantiation ($3, $4, $1); }
;
template_type:
define_case_label (label);
}
stmt
- | CASE expr_no_commas RANGE expr_no_commas ':'
+ | CASE expr_no_commas ELLIPSIS expr_no_commas ':'
{ register tree value1 = check_cp_case_value ($2);
register tree value2 = check_cp_case_value ($4);
register tree label
#include "cp-tree.h"
#include "decl.h"
#include "parse.h"
+#include "lex.h"
extern struct obstack permanent_obstack;
extern tree grokdeclarator ();
if (is_class)
{
decl = build_lang_decl (TEMPLATE_DECL, d2, NULL_TREE);
+ GNU_xref_decl (current_function_decl, decl);
}
else
{
}
/* If this is for a method, there's an extra binding level here. */
- if (! DECL_TEMPLATE_IS_CLASS (decl)
- && DECL_CONTEXT (DECL_TEMPLATE_RESULT (decl)) != NULL_TREE)
+ if (DECL_CONTEXT (DECL_TEMPLATE_RESULT (decl)) != NULL_TREE)
{
/* @@ Find out where this should be getting set! */
tree r = DECL_TEMPLATE_RESULT (decl);
- if (DECL_CLASS_CONTEXT (r) == NULL_TREE)
+ if (DECL_LANG_SPECIFIC (r) && DECL_CLASS_CONTEXT (r) == NULL_TREE)
DECL_CLASS_CONTEXT (r) = DECL_CONTEXT (r);
}
}
/* If context of decl is non-null (i.e., method template), add it
to the appropriate class template, and pop the binding levels. */
- if (! DECL_TEMPLATE_IS_CLASS (decl)
- && DECL_CONTEXT (DECL_TEMPLATE_RESULT (decl)) != NULL_TREE)
+ if (! is_class && DECL_CONTEXT (DECL_TEMPLATE_RESULT (decl)) != NULL_TREE)
{
tree ctx = DECL_CONTEXT (DECL_TEMPLATE_RESULT (decl));
tree tmpl, t;
fprintf (stderr, "\tfound %s\n\n",
IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method)));
#endif
+ if (DECL_ARTIFICIAL (method))
+ {
+ cp_error ("template for method `%D' which has default implementation in class `%T'", name, ctx);
+ if (in_decl)
+ cp_error_at ("in attempt to instantiate `%D' declared at this point in file", in_decl);
+ return error_mark_node;
+ }
if (DECL_ARGUMENTS (method)
&& ! TREE_PERMANENT (DECL_ARGUMENTS (method)))
/* Here, we have a match. */
fndecl = TREE_VALUE (fndecl);
- function_maybepermanent_obstack = old_fmp_obstack;
- pop_obstacks ();
- return fndecl;
+ goto exit;
no_match:
;
fndecl = tsubst (DECL_RESULT (tmpl), targ_ptr,
TREE_VEC_LENGTH (targs), tmpl);
+ if (fndecl == error_mark_node)
+ goto exit;
+
/* If it's a static member fn in the template, we need to change it
into a FUNCTION_TYPE and chop off its this pointer. */
if (TREE_CODE (TREE_TYPE (DECL_RESULT (tmpl))) == METHOD_TYPE
- && fndecl != error_mark_node
&& DECL_STATIC_FUNCTION_P (fndecl))
{
tree olddecl = DECL_RESULT (tmpl);
DECL_TEMPLATE_INSTANTIATIONS (tmpl) =
tree_cons (targs, fndecl, DECL_TEMPLATE_INSTANTIATIONS (tmpl));
- function_maybepermanent_obstack = old_fmp_obstack;
- pop_obstacks ();
-
- if (fndecl == error_mark_node || p == (struct pending_inline *)0)
+ if (p == (struct pending_inline *)0)
{
/* do nothing */
}
p->next = pending_template_expansions;
pending_template_expansions = p;
}
+ exit:
+ function_maybepermanent_obstack = old_fmp_obstack;
+ pop_obstacks ();
+
return fndecl;
}
DECIDE (0);
if (DECL_EXPLICIT_INSTANTIATION (t))
- DECIDE (1);
+ DECIDE (! DECL_EXTERNAL (t));
else if (! flag_implicit_templates)
DECIDE (0);
/* called from the parser. */
void
-do_function_instantiation (declspecs, declarator)
- tree declspecs, declarator;
+do_function_instantiation (declspecs, declarator, storage)
+ tree declspecs, declarator, storage;
{
tree decl = grokdeclarator (declarator, declspecs, NORMAL, 0, 0);
tree name = DECL_NAME (decl);
SET_DECL_EXPLICIT_INSTANTIATION (result);
TREE_PUBLIC (result) = 1;
- DECL_EXTERNAL (result) = DECL_INLINE (result) && ! flag_implement_inlines;
+
+ if (storage == NULL_TREE)
+ DECL_EXTERNAL (result) = DECL_INLINE (result) && ! flag_implement_inlines;
+ else if (storage == ridpointers[(int) RID_EXTERN])
+ DECL_EXTERNAL (result) = 1;
+ else
+ cp_error ("storage class `%D' applied to template instantiation",
+ storage);
}
void
-do_type_instantiation (name)
- tree name;
+do_type_instantiation (name, storage)
+ tree name, storage;
{
tree t = TREE_TYPE (name);
+ int extern_p;
if (flag_external_templates)
return;
+ if (TYPE_SIZE (t) == NULL_TREE)
+ {
+ cp_error ("explicit instantiation of `%#T' before definition of template",
+ t);
+ return;
+ }
+
+ if (storage == NULL_TREE)
+ extern_p = 0;
+ else if (storage == ridpointers[(int) RID_EXTERN])
+ extern_p = 1;
+ else
+ {
+ cp_error ("storage class `%D' applied to template instantiation",
+ storage);
+ extern_p = 0;
+ }
+
SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
- CLASSTYPE_VTABLE_NEEDS_WRITING (t) = 1;
+ CLASSTYPE_VTABLE_NEEDS_WRITING (t) = ! extern_p;
SET_CLASSTYPE_INTERFACE_KNOWN (t);
- CLASSTYPE_INTERFACE_ONLY (t) = 0;
+ CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
+ if (! extern_p)
+ {
+ CLASSTYPE_DEBUG_REQUESTED (t) = 1;
+ TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = 0;
+ rest_of_type_compilation (t, 1);
+ }
/* this should really be done by instantiate_member_templates */
{
{
SET_DECL_EXPLICIT_INSTANTIATION (method);
TREE_PUBLIC (method) = 1;
- DECL_EXTERNAL (method) = (DECL_INLINE (method)
- && ! flag_implement_inlines);
+ DECL_EXTERNAL (method)
+ = (extern_p || (DECL_INLINE (method) && ! flag_implement_inlines));
}
}
if (TREE_CODE (binfo) == TREE_VEC)
type = BINFO_TYPE (binfo);
- else if (TREE_CODE (binfo) == RECORD_TYPE)
+ else if (IS_AGGR_TYPE_CODE (TREE_CODE (binfo)))
{
type = binfo;
binfo = TYPE_BINFO (type);
}
/* We cannot rely on some alien method to solve our problems,
so we must write out the debug info ourselves. */
- if (write_symbols != DWARF_DEBUG)
- TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = 0;
- if (! TREE_ASM_WRITTEN (TYPE_NAME (t)))
- rest_of_type_compilation (t, global_bindings_p ());
+ TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = 0;
+ rest_of_type_compilation (t, global_bindings_p ());
}
\f
/* Attach to the type of the virtual base class, the pointer to the
#else
unsigned record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (rec));
#endif
+ int desired_align;
/* Record size so far is CONST_SIZE + VAR_SIZE bits,
where CONST_SIZE is an integer
tree basetype = BINFO_TYPE (vbase_types);
tree offset;
+ desired_align = TYPE_ALIGN (basetype);
+ record_align = MAX (record_align, desired_align);
+
if (const_size == 0)
offset = integer_zero_node;
else
- offset = size_int ((const_size + BITS_PER_UNIT - 1) / BITS_PER_UNIT);
+ {
+ /* Give each virtual base type the alignment it wants. */
+ const_size = CEIL (const_size, TYPE_ALIGN (basetype))
+ * TYPE_ALIGN (basetype);
+ offset = size_int (CEIL (const_size, BITS_PER_UNIT));
+ }
if (CLASSTYPE_VSIZE (basetype) > max)
max = CLASSTYPE_VSIZE (basetype);
BINFO_OFFSET (vbase_types) = offset;
if (TREE_CODE (TYPE_SIZE (basetype)) == INTEGER_CST)
- const_size += MAX (record_align,
+ const_size += MAX (BITS_PER_UNIT,
TREE_INT_CST_LOW (TYPE_SIZE (basetype))
- TREE_INT_CST_LOW (CLASSTYPE_VBASE_SIZE (basetype)));
else if (var_size == 0)
vbase_types = TREE_CHAIN (vbase_types);
}
+ /* Set the alignment in the complete type. We don't set CLASSTYPE_ALIGN
+ here, as that is for this class, without any virtual base classes. */
+ TYPE_ALIGN (rec) = record_align;
if (const_size != nonvirtual_const_size)
{
CLASSTYPE_VBASE_SIZE (rec)
case FIX_CEIL_EXPR:
{
tree incremented, modify, value;
+ if (! lvalue_p (arg) && pedantic)
+ pedwarn ("cast to non-reference type used as lvalue");
arg = stabilize_reference (arg);
if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
value = arg;
if (val != 0)
return val;
-#if 0 /* Turned off because inconsistent;
- float f; *&(int)f = 3.4 stores in int format
- whereas (int)f = 3.4 stores in float format. */
- /* Address of a cast is just a cast of the address
- of the operand of the cast. */
switch (TREE_CODE (arg))
{
case NOP_EXPR:
case FIX_FLOOR_EXPR:
case FIX_ROUND_EXPR:
case FIX_CEIL_EXPR:
- if (pedantic)
- pedwarn ("ANSI C++ forbids taking the address of a cast expression");
- return convert (build_pointer_type (TREE_TYPE (arg)),
- build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), 0));
+ if (! lvalue_p (arg) && pedantic)
+ pedwarn ("taking the address of a cast to non-reference type");
}
-#endif
/* Allow the address of a constructor if all the elements
are constant. */
return error_mark_node;
}
- if (TREE_TYPE (value)
- && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
- return build1 (NOP_EXPR, type, value);
-
/* If there's only one function in the overloaded space,
just take it. */
if (TREE_CODE (value) == TREE_LIST
&& TREE_CHAIN (value) == NULL_TREE)
value = TREE_VALUE (value);
- /* Make up for the fact that we do not always perform
- `default_conversion' anymore. */
- if (TREE_READONLY_DECL_P (value))
- value = decl_constant_value (value);
-
if (TREE_CODE (type) == VOID_TYPE)
value = build1 (NOP_EXPR, type, value);
else if (TREE_TYPE (value) == NULL_TREE
convert (lhstype, newrhs)));
if (TREE_CODE (result) == ERROR_MARK)
return result;
- return convert_force (TREE_TYPE (lhs), result);
+ return convert (TREE_TYPE (lhs), result);
}
}
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: 357. Free: */
+/* First used: 0 (reserved), Last used: 358. Free: */
static int abortcount = 0;
return IDENTIFIER_POINTER (TREE_PURPOSE (values));
}
+#if 0
/* Print out a language-specific error message for
(Pascal) case or (C) switch statements.
CODE tells what sort of message to print.
error ("range values reversed");
}
}
+#endif
decl = TYPE_NAME (decl);
uselin = TRUE;
}
+ else if (TREE_CODE (decl) == TEMPLATE_DECL)
+ {
+ if (DECL_TEMPLATE_IS_CLASS (decl))
+ cls = "CLASSTEMP";
+ else if (TREE_CODE (DECL_RESULT (decl)) == FUNCTION_DECL)
+ cls = "FUNCTEMP";
+ else if (TREE_CODE (DECL_RESULT (decl)) == VAR_DECL)
+ cls = "VARTEMP";
+ else
+ my_friendly_abort (358);
+ uselin = TRUE;
+ }
else cls = "UNKNOWN";
if (decl == NULL || DECL_NAME (decl) == NULL) return;
projects / thirdparty / gcc.git / commitdiff
