/* Process declarations and variables for C++ compiler.
Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+ 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
Hacked by Michael Tiemann (tiemann@cygnus.com)
This file is part of GCC.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to
-the Free Software Foundation, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA. */
/* Process declarations and symbol lookup for C++ front end.
#include "flags.h"
#include "cp-tree.h"
#include "decl.h"
-#include "lex.h"
#include "output.h"
#include "except.h"
#include "toplev.h"
#include "tree-mudflap.h"
#include "cgraph.h"
#include "tree-inline.h"
+#include "c-pragma.h"
+#include "tree-dump.h"
+#include "intl.h"
extern cpp_reader *parse_in;
} *priority_info;
static void mark_vtable_entries (tree);
-static void grok_function_init (tree, tree);
static bool maybe_emit_vtables (tree);
-static tree build_anon_union_vars (tree);
static bool acceptable_java_type (tree);
static tree start_objects (int, int);
static void finish_objects (int, int, tree);
static tree start_static_storage_duration_function (unsigned);
static void finish_static_storage_duration_function (tree);
static priority_info get_priority_info (int);
-static void do_static_initialization (tree, tree);
-static void do_static_destruction (tree);
-static tree start_static_initialization_or_destruction (tree, int);
-static void finish_static_initialization_or_destruction (tree);
+static void do_static_initialization_or_destruction (tree, bool);
+static void one_static_initialization_or_destruction (tree, tree, bool);
static void generate_ctor_or_dtor_function (bool, int, location_t *);
static int generate_ctor_and_dtor_functions_for_priority (splay_tree_node,
- void *);
+ void *);
static tree prune_vars_needing_no_initialization (tree *);
static void write_out_vars (tree);
static void import_export_class (tree);
/* A list of static class variables. This is needed, because a
static class variable can be declared inside the class without
an initializer, and then initialized, statically, outside the class. */
-static GTY(()) varray_type pending_statics;
-#define pending_statics_used \
- (pending_statics ? pending_statics->elements_used : 0)
+static GTY(()) VEC(tree,gc) *pending_statics;
/* A list of functions which were declared inline, but which we
may need to emit outline anyway. */
-static GTY(()) varray_type deferred_fns;
-#define deferred_fns_used \
- (deferred_fns ? deferred_fns->elements_used : 0)
-
-/* Flag used when debugging spew.c */
-
-extern int spew_debug;
+static GTY(()) VEC(tree,gc) *deferred_fns;
/* Nonzero if we're done parsing and into end-of-file activities. */
TYPE_UNQUALIFIED will be an extension. */
int
-grok_method_quals (tree ctype, tree function, tree quals)
+grok_method_quals (tree ctype, tree function, cp_cv_quals quals)
{
tree fntype = TREE_TYPE (function);
tree raises = TYPE_RAISES_EXCEPTIONS (fntype);
int type_quals = TYPE_UNQUALIFIED;
- int dup_quals = TYPE_UNQUALIFIED;
int this_quals = TYPE_UNQUALIFIED;
- do
- {
- int tq = cp_type_qual_from_rid (TREE_VALUE (quals));
-
- if ((type_quals | this_quals) & tq)
- dup_quals |= tq;
- else if (tq & TYPE_QUAL_RESTRICT)
- this_quals |= tq;
- else
- type_quals |= tq;
- quals = TREE_CHAIN (quals);
- }
- while (quals);
-
- if (dup_quals != TYPE_UNQUALIFIED)
- error ("duplicate type qualifiers in %s declaration",
- TREE_CODE (function) == FUNCTION_DECL
- ? "member function" : "type");
+ type_quals = quals & ~TYPE_QUAL_RESTRICT;
+ this_quals = quals & TYPE_QUAL_RESTRICT;
ctype = cp_build_qualified_type (ctype, type_quals);
fntype = build_method_type_directly (ctype, TREE_TYPE (fntype),
return this_quals;
}
-/* A subroutine of the parser, to handle a component list. */
-
-void
-grok_x_components (tree specs)
-{
- tree t;
-
- specs = strip_attrs (specs);
-
- check_tag_decl (specs);
- t = groktypename (build_tree_list (specs, NULL_TREE));
-
- /* The only case where we need to do anything additional here is an
- anonymous union field, e.g.: `struct S { union { int i; }; };'. */
- if (t == NULL_TREE || !ANON_AGGR_TYPE_P (t))
- return;
-
- fixup_anonymous_aggr (t);
- finish_member_declaration (build_decl (FIELD_DECL, NULL_TREE, t));
-}
-
/* Build a PARM_DECL with NAME and TYPE, and set DECL_ARG_TYPE
appropriately. */
/* Returns a PARM_DECL for a parameter of the indicated TYPE, with the
indicated NAME. */
-tree
+static tree
build_artificial_parm (tree name, tree type)
{
tree parm = cp_build_parm_decl (name, type);
/* We don't need an in-charge parameter for constructors that don't
have virtual bases. */
if (DECL_CONSTRUCTOR_P (fn)
- && !TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn)))
+ && !CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn)))
return;
arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
/* If this is a subobject constructor or destructor, our caller will
pass us a pointer to our VTT. */
- if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn)))
+ if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn)))
{
parm = build_artificial_parm (vtt_parm_identifier, vtt_parm_type);
QUALS are the qualifiers for the this pointer. */
void
-grokclassfn (tree ctype, tree function, enum overload_flags flags, tree quals)
+grokclassfn (tree ctype, tree function, enum overload_flags flags,
+ cp_cv_quals quals)
{
tree fn_name = DECL_NAME (function);
- int this_quals = TYPE_UNQUALIFIED;
+ cp_cv_quals this_quals = TYPE_UNQUALIFIED;
/* Even within an `extern "C"' block, members get C++ linkage. See
[dcl.link] for details. */
this_quals |= TYPE_QUAL_CONST;
qual_type = cp_build_qualified_type (type, this_quals);
parm = build_artificial_parm (this_identifier, qual_type);
- c_apply_type_quals_to_decl (this_quals, parm);
+ cp_apply_type_quals_to_decl (this_quals, parm);
TREE_CHAIN (parm) = DECL_ARGUMENTS (function);
DECL_ARGUMENTS (function) = parm;
}
{
if (type_dependent_expression_p (array_expr)
|| type_dependent_expression_p (index_exp))
- return build_min_nt (ARRAY_REF, array_expr, index_exp);
+ return build_min_nt (ARRAY_REF, array_expr, index_exp,
+ NULL_TREE, NULL_TREE);
array_expr = build_non_dependent_expr (array_expr);
index_exp = build_non_dependent_expr (index_exp);
}
type = TREE_TYPE (array_expr);
- my_friendly_assert (type, 20030626);
+ gcc_assert (type);
type = non_reference (type);
/* If they have an `operator[]', use that. */
else
p2 = build_expr_type_conversion (WANT_POINTER, index_exp, false);
- i1 = build_expr_type_conversion (WANT_INT | WANT_ENUM, array_expr,
+ i1 = build_expr_type_conversion (WANT_INT | WANT_ENUM, array_expr,
false);
- i2 = build_expr_type_conversion (WANT_INT | WANT_ENUM, index_exp,
+ i2 = build_expr_type_conversion (WANT_INT | WANT_ENUM, index_exp,
false);
if ((p1 && i2) && (i1 && p2))
array_expr = p2, index_exp = i1;
else
{
- error ("invalid types `%T[%T]' for array subscript",
- type, TREE_TYPE (index_exp));
+ error ("invalid types %<%T[%T]%> for array subscript",
+ type, TREE_TYPE (index_exp));
return error_mark_node;
}
expr = build_array_ref (array_expr, index_exp);
}
if (processing_template_decl && expr != error_mark_node)
- return build_min_non_dep (ARRAY_REF, expr,
- orig_array_expr, orig_index_exp);
+ return build_min_non_dep (ARRAY_REF, expr, orig_array_expr, orig_index_exp,
+ NULL_TREE, NULL_TREE);
return expr;
}
return t;
}
- exp = convert_from_reference (exp);
-
/* An array can't have been allocated by new, so complain. */
if (TREE_CODE (exp) == VAR_DECL
&& TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
- warning ("deleting array `%#D'", exp);
+ warning (0, "deleting array %q#D", exp);
t = build_expr_type_conversion (WANT_POINTER, exp, true);
if (t == NULL_TREE || t == error_mark_node)
{
- error ("type `%#T' argument given to `delete', expected pointer",
- TREE_TYPE (exp));
+ error ("type %q#T argument given to %<delete%>, expected pointer",
+ TREE_TYPE (exp));
return error_mark_node;
}
/* You can't delete functions. */
if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
{
- error ("cannot delete a function. Only pointer-to-objects are valid arguments to `delete'");
+ error ("cannot delete a function. Only pointer-to-objects are "
+ "valid arguments to %<delete%>");
return error_mark_node;
}
/* Deleting ptr to void is undefined behavior [expr.delete/3]. */
if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE)
{
- warning ("deleting `%T' is undefined", type);
+ warning (0, "deleting %qT is undefined", type);
doing_vec = 0;
}
return build1 (NOP_EXPR, void_type_node, t);
if (doing_vec)
- return build_vec_delete (t, /*maxindex=*/NULL_TREE,
+ return build_vec_delete (t, /*maxindex=*/NULL_TREE,
sfk_deleting_destructor,
use_global_delete);
else
{
tree decl;
- my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 0);
+ gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
decl = DECL_TEMPLATE_RESULT (tmpl);
if (TREE_CODE (decl) == FUNCTION_DECL
{
if (current_function_decl)
/* 14.5.2.2 [temp.mem]
-
+
A local class shall not have member templates. */
- error ("invalid declaration of member template `%#D' in local class",
- decl);
-
+ error ("invalid declaration of member template %q#D in local class",
+ decl);
+
if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VIRTUAL_P (decl))
{
/* 14.5.2.3 [temp.mem]
A member function template shall not be virtual. */
- error
- ("invalid use of `virtual' in template declaration of `%#D'",
+ error
+ ("invalid use of %<virtual%> in template declaration of %q#D",
decl);
DECL_VIRTUAL_P (decl) = 0;
}
/* The debug-information generating code doesn't know what to do
- with member templates. */
+ with member templates. */
DECL_IGNORED_P (tmpl) = 1;
- }
+ }
else
- error ("template declaration of `%#D'", decl);
+ error ("template declaration of %q#D", decl);
}
/* Return true iff TYPE is a valid Java parameter or return type. */
if (!acceptable_java_type (ret_type))
{
- error ("Java method '%D' has non-Java return type `%T'",
- method, ret_type);
+ error ("Java method %qD has non-Java return type %qT",
+ method, ret_type);
jerr = true;
}
arg_types = TREE_CHAIN (arg_types);
if (DECL_HAS_VTT_PARM_P (method))
arg_types = TREE_CHAIN (arg_types);
-
+
for (; arg_types != NULL_TREE; arg_types = TREE_CHAIN (arg_types))
{
tree type = TREE_VALUE (arg_types);
if (!acceptable_java_type (type))
{
- error ("Java method '%D' has non-Java parameter type `%T'",
- method, type);
+ error ("Java method %qD has non-Java parameter type %qT",
+ method, type);
jerr = true;
}
}
/* Sanity check: report error if this function FUNCTION is not
really a member of the class (CTYPE) it is supposed to belong to.
- TEMPLATE_PARMS is used to specifiy the template parameters of a member
- template passed as FUNCTION_DECL. If the member template is passed as a
+ TEMPLATE_PARMS is used to specify the template parameters of a member
+ template passed as FUNCTION_DECL. If the member template is passed as a
TEMPLATE_DECL, it can be NULL since the parameters can be extracted
from the declaration. If the function is not a function template, it
must be NULL.
{
int ix;
bool is_template;
-
+
if (DECL_USE_TEMPLATE (function)
&& !(TREE_CODE (function) == TEMPLATE_DECL
&& DECL_TEMPLATE_SPECIALIZATION (function))
- && is_member_template (DECL_TI_TEMPLATE (function)))
+ && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (function)))
/* Since this is a specialization of a member template,
we're not going to find the declaration in the class.
For example, in:
-
- struct S { template <typename T> void f(T); };
- template <> void S::f(int);
-
+
+ struct S { template <typename T> void f(T); };
+ template <> void S::f(int);
+
we're not going to find `S::f(int)', but there's no
reason we should, either. We let our callers know we didn't
find the method, but we don't complain. */
either were not passed, or they are the same of DECL_TEMPLATE_PARMS. */
if (TREE_CODE (function) == TEMPLATE_DECL)
{
- my_friendly_assert (!template_parms
- || comp_template_parms
- (template_parms,
- DECL_TEMPLATE_PARMS (function)),
- 20040303);
+ gcc_assert (!template_parms
+ || comp_template_parms (template_parms,
+ DECL_TEMPLATE_PARMS (function)));
template_parms = DECL_TEMPLATE_PARMS (function);
}
/* OK, is this a definition of a member template? */
is_template = (template_parms != NULL_TREE);
- ix = lookup_fnfields_1 (complete_type (ctype),
- DECL_CONSTRUCTOR_P (function) ? ctor_identifier :
- DECL_DESTRUCTOR_P (function) ? dtor_identifier :
- DECL_NAME (function));
-
+ ix = class_method_index_for_fn (complete_type (ctype), function);
if (ix >= 0)
{
- tree methods = CLASSTYPE_METHOD_VEC (ctype);
+ VEC(tree,gc) *methods = CLASSTYPE_METHOD_VEC (ctype);
tree fndecls, fndecl = 0;
bool is_conv_op;
- bool pop_p;
+ tree pushed_scope;
const char *format = NULL;
-
- pop_p = push_scope (ctype);
- for (fndecls = TREE_VEC_ELT (methods, ix);
+
+ pushed_scope = push_scope (ctype);
+ for (fndecls = VEC_index (tree, methods, ix);
fndecls; fndecls = OVL_NEXT (fndecls))
{
tree p1, p2;
-
+
fndecl = OVL_CURRENT (fndecls);
p1 = TYPE_ARG_TYPES (TREE_TYPE (function));
p2 = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
/* We cannot simply call decls_match because this doesn't
work for static member functions that are pretending to
be methods, and because the name may have been changed by
- asm("new_name"). */
-
+ asm("new_name"). */
+
/* Get rid of the this parameter on functions that become
static. */
if (DECL_STATIC_FUNCTION_P (fndecl)
declaration. */
if (is_template != (TREE_CODE (fndecl) == TEMPLATE_DECL))
continue;
-
+
if (same_type_p (TREE_TYPE (TREE_TYPE (function)),
TREE_TYPE (TREE_TYPE (fndecl)))
&& compparms (p1, p2)
&& (!is_template
- || comp_template_parms (template_parms,
+ || comp_template_parms (template_parms,
DECL_TEMPLATE_PARMS (fndecl)))
&& (DECL_TEMPLATE_SPECIALIZATION (function)
== DECL_TEMPLATE_SPECIALIZATION (fndecl))
&& (!DECL_TEMPLATE_SPECIALIZATION (function)
- || (DECL_TI_TEMPLATE (function)
+ || (DECL_TI_TEMPLATE (function)
== DECL_TI_TEMPLATE (fndecl))))
break;
}
- if (pop_p)
- pop_scope (ctype);
+ if (pushed_scope)
+ pop_scope (pushed_scope);
if (fndecls)
return OVL_CURRENT (fndecls);
- error ("prototype for `%#D' does not match any in class `%T'",
+ error ("prototype for %q#D does not match any in class %qT",
function, ctype);
is_conv_op = DECL_CONV_FN_P (fndecl);
if (is_conv_op)
ix = CLASSTYPE_FIRST_CONVERSION_SLOT;
- fndecls = TREE_VEC_ELT (methods, ix);
+ fndecls = VEC_index (tree, methods, ix);
while (fndecls)
{
fndecl = OVL_CURRENT (fndecls);
if (!fndecls && is_conv_op)
{
- if (TREE_VEC_LENGTH (methods) > ix)
+ if (VEC_length (tree, methods) > (size_t) ++ix)
{
- ix++;
- fndecls = TREE_VEC_ELT (methods, ix);
+ fndecls = VEC_index (tree, methods, ix);
if (!DECL_CONV_FN_P (OVL_CURRENT (fndecls)))
{
fndecls = NULL_TREE;
is_conv_op = false;
}
if (format)
- format = " %#D";
+ format = " %+#D";
else if (fndecls)
- format = "candidates are: %#D";
+ format = N_("candidates are: %+#D");
else
- format = "candidate is: %#D";
- cp_error_at (format, fndecl);
+ format = N_("candidate is: %+#D");
+ error (format, fndecl);
}
}
else if (!COMPLETE_TYPE_P (ctype))
cxx_incomplete_type_error (function, ctype);
else
- error ("no `%#D' member function declared in class `%T'",
+ error ("no %q#D member function declared in class %qT",
function, ctype);
/* If we did not find the method in the class, add it to avoid
case we'll only confuse ourselves when the function is declared
properly within the class. */
if (COMPLETE_TYPE_P (ctype))
- add_method (ctype, function, /*error_p=*/1);
+ add_method (ctype, function, NULL_TREE);
return NULL_TREE;
}
+/* DECL is a function with vague linkage. Remember it so that at the
+ end of the translation unit we can decide whether or not to emit
+ it. */
+
+void
+note_vague_linkage_fn (tree decl)
+{
+ if (!DECL_DEFERRED_FN (decl))
+ {
+ DECL_DEFERRED_FN (decl) = 1;
+ DECL_DEFER_OUTPUT (decl) = 1;
+ VEC_safe_push (tree, gc, deferred_fns, decl);
+ }
+}
+
+/* Like note_vague_linkage_fn but for variables. */
+
+static void
+note_vague_linkage_var (tree var)
+{
+ VEC_safe_push (tree, gc, pending_statics, var);
+}
+
/* We have just processed the DECL, which is a static data member.
Its initializer, if present, is INIT. The ASMSPEC_TREE, if
present, is the assembly-language name for the data member.
void
finish_static_data_member_decl (tree decl, tree init, tree asmspec_tree,
- int flags)
+ int flags)
{
- my_friendly_assert (TREE_PUBLIC (decl), 0);
+ gcc_assert (TREE_PUBLIC (decl));
DECL_CONTEXT (decl) = current_class_type;
DECL_INITIAL (decl) = error_mark_node;
if (! processing_template_decl)
- {
- if (!pending_statics)
- VARRAY_TREE_INIT (pending_statics, 32, "pending_statics");
- VARRAY_PUSH_TREE (pending_statics, decl);
- }
+ note_vague_linkage_var (decl);
if (LOCAL_CLASS_P (current_class_type))
- pedwarn ("local class `%#T' shall not have static data member `%#D'",
+ pedwarn ("local class %q#T shall not have static data member %q#D",
current_class_type, decl);
/* Static consts need not be initialized in the class definition. */
if (init != NULL_TREE && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
{
static int explained = 0;
-
+
error ("initializer invalid for static member with constructor");
if (!explained)
- {
+ {
error ("(an out of class initialization is required)");
explained = 1;
}
CHANGES TO CODE IN `start_method'. */
tree
-grokfield (tree declarator, tree declspecs, tree init, tree asmspec_tree,
- tree attrlist)
+grokfield (const cp_declarator *declarator,
+ cp_decl_specifier_seq *declspecs,
+ tree init, tree asmspec_tree,
+ tree attrlist)
{
tree value;
const char *asmspec = 0;
int flags = LOOKUP_ONLYCONVERTING;
- if (declspecs == NULL_TREE
- && TREE_CODE (declarator) == SCOPE_REF
- && TREE_CODE (TREE_OPERAND (declarator, 1)) == IDENTIFIER_NODE)
- {
- /* Access declaration */
- if (! IS_AGGR_TYPE_CODE (TREE_CODE (TREE_OPERAND (declarator, 0))))
- ;
- else if (TREE_COMPLEXITY (declarator) == current_class_depth)
- pop_nested_class ();
- return do_class_using_decl (declarator);
- }
+ if (!declspecs->any_specifiers_p
+ && declarator->kind == cdk_id
+ && declarator->u.id.qualifying_scope
+ && TREE_CODE (declarator->u.id.unqualified_name) == IDENTIFIER_NODE)
+ /* Access declaration */
+ return do_class_using_decl (declarator->u.id.qualifying_scope,
+ declarator->u.id.unqualified_name);
if (init
&& TREE_CODE (init) == TREE_LIST
if (TREE_CODE (value) == TYPE_DECL && init)
{
- error ("typedef `%D' is initialized (use __typeof__ instead)", value);
+ error ("typedef %qD is initialized (use __typeof__ instead)", value);
init = NULL_TREE;
}
if (DECL_NAME (value) != NULL_TREE
&& IDENTIFIER_POINTER (DECL_NAME (value))[0] == '_'
&& ! strcmp (IDENTIFIER_POINTER (DECL_NAME (value)), "_vptr"))
- error ("member `%D' conflicts with virtual function table field name",
- value);
+ error ("member %qD conflicts with virtual function table field name",
+ value);
/* Stash away type declarations. */
if (TREE_CODE (value) == TYPE_DECL)
if (processing_template_decl)
value = push_template_decl (value);
+ if (attrlist)
+ {
+ /* Avoid storing attributes in template parameters:
+ tsubst is not ready to handle them. */
+ tree type = TREE_TYPE (value);
+ if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
+ || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
+ sorry ("applying attributes to template parameters is not implemented");
+ else
+ cplus_decl_attributes (&value, attrlist, 0);
+ }
+
return value;
}
if (DECL_IN_AGGR_P (value))
{
- error ("`%D' is already defined in `%T'", value,
- DECL_CONTEXT (value));
+ error ("%qD is already defined in %qT", value, DECL_CONTEXT (value));
return void_type_node;
}
{
if (TREE_CODE (value) == FUNCTION_DECL)
{
- grok_function_init (value, init);
- init = NULL_TREE;
+ /* Initializers for functions are rejected early in the parser.
+ If we get here, it must be a pure specifier for a method. */
+ if (TREE_CODE (TREE_TYPE (value)) == METHOD_TYPE)
+ {
+ gcc_assert (error_operand_p (init) || integer_zerop (init));
+ DECL_PURE_VIRTUAL_P (value) = 1;
+ }
+ else
+ {
+ gcc_assert (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE);
+ error ("initializer specified for static member function %qD",
+ value);
+ }
}
else if (pedantic && TREE_CODE (value) != VAR_DECL)
/* Already complained in grokdeclarator. */
init = NULL_TREE;
- else
+ else if (!processing_template_decl)
{
- /* We allow initializers to become parameters to base
- initializers. */
- if (TREE_CODE (init) == TREE_LIST)
- {
- if (TREE_CHAIN (init) == NULL_TREE)
- init = TREE_VALUE (init);
- else
- init = digest_init (TREE_TYPE (value), init, (tree *)0);
- }
+ if (TREE_CODE (init) == CONSTRUCTOR)
+ init = digest_init (TREE_TYPE (value), init);
+ else
+ init = integral_constant_value (init);
- if (!processing_template_decl)
+ if (init != error_mark_node && !TREE_CONSTANT (init))
{
- if (TREE_CODE (init) == CONST_DECL)
- init = DECL_INITIAL (init);
- else if (TREE_READONLY_DECL_P (init))
- init = decl_constant_value (init);
- else if (TREE_CODE (init) == CONSTRUCTOR)
- init = digest_init (TREE_TYPE (value), init, (tree *)0);
- if (init != error_mark_node && ! TREE_CONSTANT (init))
+ /* We can allow references to things that are effectively
+ static, since references are initialized with the
+ address. */
+ if (TREE_CODE (TREE_TYPE (value)) != REFERENCE_TYPE
+ || (TREE_STATIC (init) == 0
+ && (!DECL_P (init) || DECL_EXTERNAL (init) == 0)))
{
- /* We can allow references to things that are effectively
- static, since references are initialized with the
- address. */
- if (TREE_CODE (TREE_TYPE (value)) != REFERENCE_TYPE
- || (TREE_STATIC (init) == 0
- && (!DECL_P (init) || DECL_EXTERNAL (init) == 0)))
- {
- error ("field initializer is not constant");
- init = error_mark_node;
- }
+ error ("field initializer is not constant");
+ init = error_mark_node;
}
}
}
if (attrlist)
cplus_decl_attributes (&value, attrlist, 0);
- if (TREE_CODE (value) == VAR_DECL)
+ switch (TREE_CODE (value))
{
- finish_static_data_member_decl (value, init, asmspec_tree,
+ case VAR_DECL:
+ finish_static_data_member_decl (value, init, asmspec_tree,
flags);
return value;
- }
- if (TREE_CODE (value) == FIELD_DECL)
- {
+
+ case FIELD_DECL:
if (asmspec)
- error ("`asm' specifiers are not permitted on non-static data members");
+ error ("%<asm%> specifiers are not permitted on non-static data members");
if (DECL_INITIAL (value) == error_mark_node)
init = error_mark_node;
cp_finish_decl (value, init, NULL_TREE, flags);
DECL_INITIAL (value) = init;
DECL_IN_AGGR_P (value) = 1;
return value;
- }
- if (TREE_CODE (value) == FUNCTION_DECL)
- {
+
+ case FUNCTION_DECL:
if (asmspec)
- {
- /* This must override the asm specifier which was placed
- by grokclassfn. Lay this out fresh. */
- SET_DECL_RTL (value, NULL_RTX);
- change_decl_assembler_name (value, get_identifier (asmspec));
- }
+ set_user_assembler_name (value, asmspec);
if (!DECL_FRIEND_P (value))
grok_special_member_properties (value);
-
+
cp_finish_decl (value, init, asmspec_tree, flags);
/* Pass friends back this way. */
DECL_IN_AGGR_P (value) = 1;
return value;
+
+ default:
+ gcc_unreachable ();
}
- abort ();
- /* NOTREACHED */
return NULL_TREE;
}
WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node. */
tree
-grokbitfield (tree declarator, tree declspecs, tree width)
+grokbitfield (const cp_declarator *declarator,
+ cp_decl_specifier_seq *declspecs, tree width)
{
tree value = grokdeclarator (declarator, declspecs, BITFIELD, 0, NULL);
if (TREE_CODE (value) == TYPE_DECL)
{
- error ("cannot declare `%D' to be a bit-field type", value);
+ error ("cannot declare %qD to be a bit-field type", value);
return NULL_TREE;
}
check here. */
if (TREE_CODE (value) == FUNCTION_DECL)
{
- error ("cannot declare bit-field `%D' with function type",
+ error ("cannot declare bit-field %qD with function type",
DECL_NAME (value));
return NULL_TREE;
}
if (DECL_IN_AGGR_P (value))
{
- error ("`%D' is already defined in the class %T", value,
- DECL_CONTEXT (value));
+ error ("%qD is already defined in the class %qT", value,
+ DECL_CONTEXT (value));
return void_type_node;
}
if (TREE_STATIC (value))
{
- error ("static member `%D' cannot be a bit-field", value);
+ error ("static member %qD cannot be a bit-field", value);
return NULL_TREE;
}
cp_finish_decl (value, NULL_TREE, NULL_TREE, 0);
return value;
}
-/* When a function is declared with an initializer,
- do the right thing. Currently, there are two possibilities:
-
- class B
- {
- public:
- // initialization possibility #1.
- virtual void f () = 0;
- int g ();
- };
-
- class D1 : B
- {
- public:
- int d1;
- // error, no f ();
- };
-
- class D2 : B
- {
- public:
- int d2;
- void f ();
- };
-
- class D3 : B
- {
- public:
- int d3;
- // initialization possibility #2
- void f () = B::f;
- };
-
-*/
-
-static void
-grok_function_init (tree decl, tree init)
-{
- /* An initializer for a function tells how this function should
- be inherited. */
- tree type = TREE_TYPE (decl);
-
- if (TREE_CODE (type) == FUNCTION_TYPE)
- error ("initializer specified for non-member function `%D'", decl);
- else if (integer_zerop (init))
- DECL_PURE_VIRTUAL_P (decl) = 1;
- else
- error ("invalid initializer for virtual method `%D'", decl);
-}
\f
void
cplus_decl_attributes (tree *decl, tree attributes, int flags)
SET_IDENTIFIER_TYPE_VALUE (DECL_NAME (*decl), TREE_TYPE (*decl));
}
\f
-/* Defer the compilation of the FN until the end of compilation. */
-
-void
-defer_fn (tree fn)
-{
- if (DECL_DEFERRED_FN (fn))
- return;
- DECL_DEFERRED_FN (fn) = 1;
- DECL_DEFER_OUTPUT (fn) = 1;
- if (!deferred_fns)
- VARRAY_TREE_INIT (deferred_fns, 32, "deferred_fns");
-
- VARRAY_PUSH_TREE (deferred_fns, fn);
-}
-
-/* Walks through the namespace- or function-scope anonymous union OBJECT,
- building appropriate ALIAS_DECLs. Returns one of the fields for use in
- the mangled name. */
+/* Walks through the namespace- or function-scope anonymous union
+ OBJECT, with the indicated TYPE, building appropriate VAR_DECLs.
+ Returns one of the fields for use in the mangled name. */
static tree
-build_anon_union_vars (tree object)
+build_anon_union_vars (tree type, tree object)
{
- tree type = TREE_TYPE (object);
tree main_decl = NULL_TREE;
tree field;
if (TREE_CODE (type) != UNION_TYPE)
error ("anonymous struct not inside named type");
- for (field = TYPE_FIELDS (type);
- field != NULL_TREE;
+ for (field = TYPE_FIELDS (type);
+ field != NULL_TREE;
field = TREE_CHAIN (field))
{
tree decl;
continue;
if (TREE_CODE (field) != FIELD_DECL)
{
- cp_pedwarn_at ("\
-`%#D' invalid; an anonymous union can only have non-static data members",
- field);
+ pedwarn ("%q+#D invalid; an anonymous union can only "
+ "have non-static data members", field);
continue;
}
if (TREE_PRIVATE (field))
- cp_pedwarn_at ("private member `%#D' in anonymous union", field);
+ pedwarn ("private member %q+#D in anonymous union", field);
else if (TREE_PROTECTED (field))
- cp_pedwarn_at ("protected member `%#D' in anonymous union", field);
+ pedwarn ("protected member %q+#D in anonymous union", field);
if (processing_template_decl)
- ref = build_min_nt (COMPONENT_REF, object, DECL_NAME (field));
+ ref = build_min_nt (COMPONENT_REF, object,
+ DECL_NAME (field), NULL_TREE);
else
ref = build_class_member_access_expr (object, field, NULL_TREE,
false);
if (DECL_NAME (field))
{
- decl = build_decl (ALIAS_DECL, DECL_NAME (field), TREE_TYPE (field));
- DECL_INITIAL (decl) = ref;
- TREE_PUBLIC (decl) = 0;
- TREE_STATIC (decl) = 0;
- DECL_EXTERNAL (decl) = 1;
+ tree base;
+
+ decl = build_decl (VAR_DECL, DECL_NAME (field), TREE_TYPE (field));
+
+ base = get_base_address (object);
+ TREE_PUBLIC (decl) = TREE_PUBLIC (base);
+ TREE_STATIC (decl) = TREE_STATIC (base);
+ DECL_EXTERNAL (decl) = DECL_EXTERNAL (base);
+
+ SET_DECL_VALUE_EXPR (decl, ref);
+ DECL_HAS_VALUE_EXPR_P (decl) = 1;
+
decl = pushdecl (decl);
}
else if (ANON_AGGR_TYPE_P (TREE_TYPE (field)))
- decl = build_anon_union_vars (ref);
+ decl = build_anon_union_vars (TREE_TYPE (field), ref);
else
decl = 0;
void
finish_anon_union (tree anon_union_decl)
{
- tree type = TREE_TYPE (anon_union_decl);
+ tree type;
tree main_decl;
- bool public_p = TREE_PUBLIC (anon_union_decl);
+ bool public_p;
+
+ if (anon_union_decl == error_mark_node)
+ return;
+
+ type = TREE_TYPE (anon_union_decl);
+ public_p = TREE_PUBLIC (anon_union_decl);
/* The VAR_DECL's context is the same as the TYPE's context. */
DECL_CONTEXT (anon_union_decl) = DECL_CONTEXT (TYPE_NAME (type));
-
+
if (TYPE_FIELDS (type) == NULL_TREE)
return;
return;
}
- main_decl = build_anon_union_vars (anon_union_decl);
+ main_decl = build_anon_union_vars (type, anon_union_decl);
if (main_decl == NULL_TREE)
{
- warning ("anonymous union with no members");
+ warning (0, "anonymous union with no members");
return;
}
pushdecl (anon_union_decl);
if (building_stmt_tree ()
&& at_function_scope_p ())
- add_decl_stmt (anon_union_decl);
+ add_decl_expr (anon_union_decl);
else if (!processing_template_decl)
- rest_of_decl_compilation (anon_union_decl, NULL,
+ rest_of_decl_compilation (anon_union_decl,
toplevel_bindings_p (), at_eof);
}
\f
int e = 0;
tree args = TYPE_ARG_TYPES (type);
- my_friendly_assert (TREE_CODE (type) == FUNCTION_TYPE, 20001107);
-
+ gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
+
if (!same_type_p (TREE_TYPE (type), ptr_type_node))
- e = 1, error ("`operator new' must return type `%T'", ptr_type_node);
+ {
+ e = 1;
+ error ("%<operator new%> must return type %qT", ptr_type_node);
+ }
if (!args || args == void_list_node
|| !same_type_p (TREE_VALUE (args), size_type_node))
{
e = 2;
if (args && args != void_list_node)
- args = TREE_CHAIN (args);
- pedwarn ("`operator new' takes type `size_t' (`%T') as first parameter", size_type_node);
+ args = TREE_CHAIN (args);
+ pedwarn ("%<operator new%> takes type %<size_t%> (%qT) "
+ "as first parameter", size_type_node);
}
switch (e)
{
/* Fall through. */
case 1:
type = build_exception_variant
- (build_function_type (ptr_type_node, args),
- TYPE_RAISES_EXCEPTIONS (type));
+ (build_function_type (ptr_type_node, args),
+ TYPE_RAISES_EXCEPTIONS (type));
/* Fall through. */
default:;
}
{
int e = 0;
tree args = TYPE_ARG_TYPES (type);
-
- my_friendly_assert (TREE_CODE (type) == FUNCTION_TYPE, 20001107);
+
+ gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
if (!same_type_p (TREE_TYPE (type), void_type_node))
- e = 1, error ("`operator delete' must return type `%T'", void_type_node);
+ {
+ e = 1;
+ error ("%<operator delete%> must return type %qT", void_type_node);
+ }
if (!args || args == void_list_node
|| !same_type_p (TREE_VALUE (args), ptr_type_node))
{
e = 2;
if (args && args != void_list_node)
- args = TREE_CHAIN (args);
- error ("`operator delete' takes type `%T' as first parameter", ptr_type_node);
+ args = TREE_CHAIN (args);
+ error ("%<operator delete%> takes type %qT as first parameter",
+ ptr_type_node);
}
switch (e)
{
/* Fall through. */
case 1:
type = build_exception_variant
- (build_function_type (void_type_node, args),
- TYPE_RAISES_EXCEPTIONS (type));
+ (build_function_type (void_type_node, args),
+ TYPE_RAISES_EXCEPTIONS (type));
/* Fall through. */
default:;
}
static void
mark_vtable_entries (tree decl)
{
- tree entries = CONSTRUCTOR_ELTS (DECL_INITIAL (decl));
+ tree fnaddr;
+ unsigned HOST_WIDE_INT idx;
- for (; entries; entries = TREE_CHAIN (entries))
+ FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (decl)),
+ idx, fnaddr)
{
- tree fnaddr = TREE_VALUE (entries);
tree fn;
STRIP_NOPS (fnaddr);
we output the vtables that contain them. With vcall offsets,
we know all the thunks we'll need when we emit a virtual
function, so we emit the thunks there instead. */
- if (DECL_THUNK_P (fn))
+ if (DECL_THUNK_P (fn))
use_thunk (fn, /*emit_p=*/0);
mark_used (fn);
}
{
if (flag_weak)
make_decl_one_only (decl);
- else if (TREE_CODE (decl) == FUNCTION_DECL
+ else if (TREE_CODE (decl) == FUNCTION_DECL
|| (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)))
/* We can just emit function and compiler-generated variables
statically; having multiple copies is (for the most part) only
- a waste of space.
+ a waste of space.
There are two correctness issues, however: the address of a
template instantiation with external linkage should be the
same, independent of what translation unit asks for the
address, and this will not hold when we emit multiple copies of
- the function. However, there's little else we can do.
+ the function. However, there's little else we can do.
Also, by default, the typeinfo implementation assumes that
there will be only one copy of the string used as the name for
/* For win32 we also want to put explicit instantiations in
linkonce sections, so that they will be merged with implicit
- instantiations; otherwise we get duplicate symbol errors.
- For Darwin we do not want explicit instantiations to be
+ instantiations; otherwise we get duplicate symbol errors.
+ For Darwin we do not want explicit instantiations to be
linkonce. */
void
if (! flag_weak)
return;
- /* We can't set DECL_COMDAT on functions, or finish_file will think
+ /* We can't set DECL_COMDAT on functions, or cp_finish_file will think
we can get away with not emitting them if they aren't used. We need
to for variables so that cp_finish_decl will update their linkage,
because their DECL_INITIAL may not have been set properly yet. */
}
}
-/* Set TREE_PUBLIC and/or DECL_EXTERN on the vtable DECL,
- based on TYPE and other static flags.
-
- Note that anything public is tagged TREE_PUBLIC, whether
- it's public in this file or in another one. */
-
-void
-import_export_vtable (tree decl, tree type, int final)
-{
- if (DECL_INTERFACE_KNOWN (decl))
- return;
-
- if (TYPE_FOR_JAVA (type))
- {
- TREE_PUBLIC (decl) = 1;
- DECL_EXTERNAL (decl) = 1;
- DECL_INTERFACE_KNOWN (decl) = 1;
- }
- else if (CLASSTYPE_INTERFACE_KNOWN (type))
- {
- TREE_PUBLIC (decl) = 1;
- DECL_EXTERNAL (decl) = CLASSTYPE_INTERFACE_ONLY (type);
- DECL_INTERFACE_KNOWN (decl) = 1;
- }
- else
- {
- /* We can only wait to decide if we have real non-inline virtual
- functions in our class, or if we come from a template. */
-
- int found = (CLASSTYPE_TEMPLATE_INSTANTIATION (type)
- || CLASSTYPE_KEY_METHOD (type) != NULL_TREE);
-
- if (final || ! found)
- {
- comdat_linkage (decl);
- DECL_EXTERNAL (decl) = 0;
- }
- else
- {
- TREE_PUBLIC (decl) = 1;
- DECL_EXTERNAL (decl) = 1;
- }
- }
-}
-
/* Determine whether or not we want to specifically import or export CTYPE,
using various heuristics. */
non-abstract virtual member function has been defined in this
translation unit. But, we can't possibly know that until we've
seen the entire translation unit. */
- my_friendly_assert (at_eof, 20000226);
+ gcc_assert (at_eof);
if (CLASSTYPE_INTERFACE_KNOWN (ctype))
return;
- /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma interface,
+ /* If MULTIPLE_SYMBOL_SPACES is set and we saw a #pragma interface,
we will have CLASSTYPE_INTERFACE_ONLY set but not
CLASSTYPE_INTERFACE_KNOWN. In that case, we don't want to use this
heuristic because someone will supply a #pragma implementation
import_export = -1;
else if (lookup_attribute ("dllexport", TYPE_ATTRIBUTES (ctype)))
import_export = 1;
-
- /* If we got -fno-implicit-templates, we import template classes that
- weren't explicitly instantiated. */
- if (import_export == 0
- && CLASSTYPE_IMPLICIT_INSTANTIATION (ctype)
- && ! flag_implicit_templates)
- import_export = -1;
-
- /* Base our import/export status on that of the first non-inline,
- non-pure virtual function, if any. */
- if (import_export == 0
- && TYPE_POLYMORPHIC_P (ctype))
- {
+ else if (CLASSTYPE_IMPLICIT_INSTANTIATION (ctype)
+ && !flag_implicit_templates)
+ /* For a template class, without -fimplicit-templates, check the
+ repository. If the virtual table is assigned to this
+ translation unit, then export the class; otherwise, import
+ it. */
+ import_export = repo_export_class_p (ctype) ? 1 : -1;
+ else if (TYPE_POLYMORPHIC_P (ctype))
+ {
+ /* The ABI specifies that the virtual table and associated
+ information are emitted with the key method, if any. */
tree method = CLASSTYPE_KEY_METHOD (ctype);
- if (method)
+ /* If weak symbol support is not available, then we must be
+ careful not to emit the vtable when the key function is
+ inline. An inline function can be defined in multiple
+ translation units. If we were to emit the vtable in each
+ translation unit containing a definition, we would get
+ multiple definition errors at link-time. */
+ if (method && (flag_weak || ! DECL_DECLARED_INLINE_P (method)))
import_export = (DECL_REALLY_EXTERN (method) ? -1 : 1);
}
-#ifdef MULTIPLE_SYMBOL_SPACES
- if (import_export == -1)
+ /* When MULTIPLE_SYMBOL_SPACES is set, we cannot count on seeing
+ a definition anywhere else. */
+ if (MULTIPLE_SYMBOL_SPACES && import_export == -1)
import_export = 0;
-#endif
+
+ /* Allow backends the chance to overrule the decision. */
+ if (targetm.cxx.import_export_class)
+ import_export = targetm.cxx.import_export_class (ctype, import_export);
if (import_export)
{
static bool
var_finalized_p (tree var)
{
- if (flag_unit_at_a_time)
- return cgraph_varpool_node (var)->finalized;
- else
- return TREE_ASM_WRITTEN (var);
+ return cgraph_varpool_node (var)->finalized;
+}
+
+/* DECL is a VAR_DECL or FUNCTION_DECL which, for whatever reason,
+ must be emitted in this translation unit. Mark it as such. */
+
+void
+mark_needed (tree decl)
+{
+ /* It's possible that we no longer need to set
+ TREE_SYMBOL_REFERENCED here directly, but doing so is
+ harmless. */
+ TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)) = 1;
+ mark_decl_referenced (decl);
+}
+
+/* DECL is either a FUNCTION_DECL or a VAR_DECL. This function
+ returns true if a definition of this entity should be provided in
+ this object file. Callers use this function to determine whether
+ or not to let the back end know that a definition of DECL is
+ available in this translation unit. */
+
+bool
+decl_needed_p (tree decl)
+{
+ gcc_assert (TREE_CODE (decl) == VAR_DECL
+ || TREE_CODE (decl) == FUNCTION_DECL);
+ /* This function should only be called at the end of the translation
+ unit. We cannot be sure of whether or not something will be
+ COMDAT until that point. */
+ gcc_assert (at_eof);
+
+ /* All entities with external linkage that are not COMDAT should be
+ emitted; they may be referred to from other object files. */
+ if (TREE_PUBLIC (decl) && !DECL_COMDAT (decl))
+ return true;
+ /* If this entity was used, let the back-end see it; it will decide
+ whether or not to emit it into the object file. */
+ if (TREE_USED (decl)
+ || (DECL_ASSEMBLER_NAME_SET_P (decl)
+ && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
+ return true;
+ /* Otherwise, DECL does not need to be emitted -- yet. A subsequent
+ reference to DECL might cause it to be emitted later. */
+ return false;
}
/* If necessary, write out the vtables for the dynamic class CTYPE.
{
tree vtbl;
tree primary_vtbl;
- bool needed = false;
- bool weaken_vtables;
+ int needed = 0;
/* If the vtables for this class have already been emitted there is
nothing more to do. */
if (TREE_TYPE (primary_vtbl) == void_type_node)
return false;
- import_export_class (ctype);
- import_export_vtable (primary_vtbl, ctype, 1);
+ /* On some targets, we cannot determine the key method until the end
+ of the translation unit -- which is when this function is
+ called. */
+ if (!targetm.cxx.key_method_may_be_inline ())
+ determine_key_method (ctype);
/* See if any of the vtables are needed. */
for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = TREE_CHAIN (vtbl))
- if (!DECL_EXTERNAL (vtbl) && DECL_NEEDED_P (vtbl))
- break;
- if (!vtbl)
+ {
+ import_export_decl (vtbl);
+ if (DECL_NOT_REALLY_EXTERN (vtbl) && decl_needed_p (vtbl))
+ needed = 1;
+ }
+ if (!needed)
{
/* If the references to this class' vtables are optimized away,
still emit the appropriate debugging information. See
dfs_debug_mark. */
- if (DECL_COMDAT (primary_vtbl)
+ if (DECL_COMDAT (primary_vtbl)
&& CLASSTYPE_DEBUG_REQUESTED (ctype))
note_debug_info_needed (ctype);
return false;
}
- else if (TREE_PUBLIC (vtbl) && !DECL_COMDAT (vtbl))
- needed = true;
-
- /* Determine whether to make vtables weak. The ABI requires that we
- do so. There are two cases in which we have to violate the ABI
- specification: targets where we don't have weak symbols
- (obviously), and targets where weak symbols don't appear in
- static archives' tables of contents. On such targets, avoiding
- undefined symbol link errors requires that we only make a symbol
- weak if we know that it will be emitted everywhere it's needed.
- So on such targets we don't make vtables weak in the common case
- where we're emitting a vtable of a nontemplate class in the
- translation unit containing the definition of a noninline key
- method. */
- if (flag_weak && !TARGET_WEAK_NOT_IN_ARCHIVE_TOC)
- weaken_vtables = true;
- else if (flag_weak)
- {
- if (CLASSTYPE_USE_TEMPLATE (ctype))
- weaken_vtables = CLASSTYPE_IMPLICIT_INSTANTIATION (ctype);
- else
- weaken_vtables = !CLASSTYPE_KEY_METHOD (ctype)
- || DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (ctype));
- }
- else
- weaken_vtables = false;
/* The ABI requires that we emit all of the vtables if we emit any
of them. */
for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = TREE_CHAIN (vtbl))
{
- /* Write it out. */
- import_export_vtable (vtbl, ctype, 1);
+ /* Mark entities references from the virtual table as used. */
mark_vtable_entries (vtbl);
- /* If we know that DECL is needed, mark it as such for the varpool. */
- if (needed)
- cgraph_varpool_mark_needed_node (cgraph_varpool_node (vtbl));
-
if (TREE_TYPE (DECL_INITIAL (vtbl)) == 0)
{
- /* It had better be all done at compile-time. */
- if (store_init_value (vtbl, DECL_INITIAL (vtbl)))
- abort ();
- }
+ tree expr = store_init_value (vtbl, DECL_INITIAL (vtbl));
- if (write_symbols == DWARF_DEBUG || write_symbols == DWARF2_DEBUG)
- {
- /* Mark the VAR_DECL node representing the vtable itself as a
- "gratuitous" one, thereby forcing dwarfout.c to ignore it.
- It is rather important that such things be ignored because
- any effort to actually generate DWARF for them will run
- into trouble when/if we encounter code like:
-
- #pragma interface
- struct S { virtual void member (); };
-
- because the artificial declaration of the vtable itself (as
- manufactured by the g++ front end) will say that the vtable
- is a static member of `S' but only *after* the debug output
- for the definition of `S' has already been output. This causes
- grief because the DWARF entry for the definition of the vtable
- will try to refer back to an earlier *declaration* of the
- vtable as a static member of `S' and there won't be one.
- We might be able to arrange to have the "vtable static member"
- attached to the member list for `S' before the debug info for
- `S' get written (which would solve the problem) but that would
- require more intrusive changes to the g++ front end. */
-
- DECL_IGNORED_P (vtbl) = 1;
+ /* It had better be all done at compile-time. */
+ gcc_assert (!expr);
}
- /* Always make vtables weak. Or at least almost always; see above. */
- if (weaken_vtables)
- comdat_linkage (vtbl);
-
- rest_of_decl_compilation (vtbl, NULL, 1, 1);
+ /* Write it out. */
+ DECL_EXTERNAL (vtbl) = 0;
+ rest_of_decl_compilation (vtbl, 1, 1);
/* Because we're only doing syntax-checking, we'll never end up
actually marking the variable as written. */
return true;
}
-/* Determines the proper settings of TREE_PUBLIC and DECL_EXTERNAL for an
- inline function or template instantiation at end-of-file. */
+/* Like c_determine_visibility, but with additional C++-specific
+ behavior. */
+
+void
+determine_visibility (tree decl)
+{
+ tree class_type;
+
+ /* Cloned constructors and destructors get the same visibility as
+ the underlying function. That should be set up in
+ maybe_clone_body. */
+ gcc_assert (!DECL_CLONED_FUNCTION_P (decl));
+
+ /* Give the common code a chance to make a determination. */
+ if (c_determine_visibility (decl))
+ return;
+
+ /* If DECL is a member of a class, visibility specifiers on the
+ class can influence the visibility of the DECL. */
+ if (DECL_CLASS_SCOPE_P (decl))
+ class_type = DECL_CONTEXT (decl);
+ else if (TREE_CODE (decl) == VAR_DECL
+ && DECL_TINFO_P (decl)
+ && CLASS_TYPE_P (TREE_TYPE (DECL_NAME (decl))))
+ class_type = TREE_TYPE (DECL_NAME (decl));
+ else
+ {
+ /* Virtual tables have DECL_CONTEXT set to their associated class,
+ so they are automatically handled above. */
+ gcc_assert (TREE_CODE (decl) != VAR_DECL
+ || !DECL_VTABLE_OR_VTT_P (decl));
+ /* Entities not associated with any class just get the
+ visibility specified by their attributes. */
+ return;
+ }
+
+ /* By default, static data members and function members receive
+ the visibility of their containing class. */
+ if (class_type)
+ {
+ if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
+ && lookup_attribute ("dllexport", TYPE_ATTRIBUTES (class_type)))
+ {
+ DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
+ DECL_VISIBILITY_SPECIFIED (decl) = 1;
+ }
+ else if (TREE_CODE (decl) == FUNCTION_DECL
+ && DECL_DECLARED_INLINE_P (decl)
+ && visibility_options.inlines_hidden)
+ {
+ /* Don't change it if it has been set explicitly by user. */
+ if (!DECL_VISIBILITY_SPECIFIED (decl))
+ {
+ DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
+ DECL_VISIBILITY_SPECIFIED (decl) = 1;
+ }
+ }
+ else if (CLASSTYPE_VISIBILITY_SPECIFIED (class_type))
+ {
+ DECL_VISIBILITY (decl) = CLASSTYPE_VISIBILITY (class_type);
+ DECL_VISIBILITY_SPECIFIED (decl) = 1;
+ }
+ else if (!DECL_VISIBILITY_SPECIFIED (decl))
+ {
+ DECL_VISIBILITY (decl) = CLASSTYPE_VISIBILITY (class_type);
+ DECL_VISIBILITY_SPECIFIED (decl) = 0;
+ }
+ }
+}
+
+/* DECL is a FUNCTION_DECL or VAR_DECL. If the object file linkage
+ for DECL has not already been determined, do so now by setting
+ DECL_EXTERNAL, DECL_COMDAT and other related flags. Until this
+ function is called entities with vague linkage whose definitions
+ are available must have TREE_PUBLIC set.
+
+ If this function decides to place DECL in COMDAT, it will set
+ appropriate flags -- but will not clear DECL_EXTERNAL. It is up to
+ the caller to decide whether or not to clear DECL_EXTERNAL. Some
+ callers defer that decision until it is clear that DECL is actually
+ required. */
void
import_export_decl (tree decl)
{
+ int emit_p;
+ bool comdat_p;
+ bool import_p;
+ tree class_type = NULL_TREE;
+
if (DECL_INTERFACE_KNOWN (decl))
return;
- if (DECL_TEMPLATE_INSTANTIATION (decl)
- || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl))
- {
- DECL_NOT_REALLY_EXTERN (decl) = 1;
- if ((DECL_IMPLICIT_INSTANTIATION (decl)
- || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl))
- && (flag_implicit_templates
- || (flag_implicit_inline_templates
- && TREE_CODE (decl) == FUNCTION_DECL
- && DECL_DECLARED_INLINE_P (decl))))
+ /* We cannot determine what linkage to give to an entity with vague
+ linkage until the end of the file. For example, a virtual table
+ for a class will be defined if and only if the key method is
+ defined in this translation unit. As a further example, consider
+ that when compiling a translation unit that uses PCH file with
+ "-frepo" it would be incorrect to make decisions about what
+ entities to emit when building the PCH; those decisions must be
+ delayed until the repository information has been processed. */
+ gcc_assert (at_eof);
+ /* Object file linkage for explicit instantiations is handled in
+ mark_decl_instantiated. For static variables in functions with
+ vague linkage, maybe_commonize_var is used.
+
+ Therefore, the only declarations that should be provided to this
+ function are those with external linkage that are:
+
+ * implicit instantiations of function templates
+
+ * inline function
+
+ * implicit instantiations of static data members of class
+ templates
+
+ * virtual tables
+
+ * typeinfo objects
+
+ Furthermore, all entities that reach this point must have a
+ definition available in this translation unit.
+
+ The following assertions check these conditions. */
+ gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
+ || TREE_CODE (decl) == VAR_DECL);
+ /* Any code that creates entities with TREE_PUBLIC cleared should
+ also set DECL_INTERFACE_KNOWN. */
+ gcc_assert (TREE_PUBLIC (decl));
+ if (TREE_CODE (decl) == FUNCTION_DECL)
+ gcc_assert (DECL_IMPLICIT_INSTANTIATION (decl)
+ || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl)
+ || DECL_DECLARED_INLINE_P (decl));
+ else
+ gcc_assert (DECL_IMPLICIT_INSTANTIATION (decl)
+ || DECL_VTABLE_OR_VTT_P (decl)
+ || DECL_TINFO_P (decl));
+ /* Check that a definition of DECL is available in this translation
+ unit. */
+ gcc_assert (!DECL_REALLY_EXTERN (decl));
+
+ /* Assume that DECL will not have COMDAT linkage. */
+ comdat_p = false;
+ /* Assume that DECL will not be imported into this translation
+ unit. */
+ import_p = false;
+
+ /* See if the repository tells us whether or not to emit DECL in
+ this translation unit. */
+ emit_p = repo_emit_p (decl);
+ if (emit_p == 0)
+ import_p = true;
+ else if (emit_p == 1)
+ {
+ /* The repository indicates that this entity should be defined
+ here. Make sure the back end honors that request. */
+ if (TREE_CODE (decl) == VAR_DECL)
+ mark_needed (decl);
+ else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)
+ || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
{
- if (!TREE_PUBLIC (decl))
- /* Templates are allowed to have internal linkage. See
- [basic.link]. */
- ;
+ tree clone;
+ FOR_EACH_CLONE (clone, decl)
+ mark_needed (clone);
+ }
+ else
+ mark_needed (decl);
+ /* Output the definition as an ordinary strong definition. */
+ DECL_EXTERNAL (decl) = 0;
+ DECL_INTERFACE_KNOWN (decl) = 1;
+ return;
+ }
+
+ if (import_p)
+ /* We have already decided what to do with this DECL; there is no
+ need to check anything further. */
+ ;
+ else if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
+ {
+ class_type = DECL_CONTEXT (decl);
+ import_export_class (class_type);
+ if (TYPE_FOR_JAVA (class_type))
+ import_p = true;
+ else if (CLASSTYPE_INTERFACE_KNOWN (class_type)
+ && CLASSTYPE_INTERFACE_ONLY (class_type))
+ import_p = true;
+ else if ((!flag_weak || TARGET_WEAK_NOT_IN_ARCHIVE_TOC)
+ && !CLASSTYPE_USE_TEMPLATE (class_type)
+ && CLASSTYPE_KEY_METHOD (class_type)
+ && !DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (class_type)))
+ /* The ABI requires that all virtual tables be emitted with
+ COMDAT linkage. However, on systems where COMDAT symbols
+ don't show up in the table of contents for a static
+ archive, or on systems without weak symbols (where we
+ approximate COMDAT linkage by using internal linkage), the
+ linker will report errors about undefined symbols because
+ it will not see the virtual table definition. Therefore,
+ in the case that we know that the virtual table will be
+ emitted in only one translation unit, we make the virtual
+ table an ordinary definition with external linkage. */
+ DECL_EXTERNAL (decl) = 0;
+ else if (CLASSTYPE_INTERFACE_KNOWN (class_type))
+ {
+ /* CLASS_TYPE is being exported from this translation unit,
+ so DECL should be defined here. */
+ if (!flag_weak && CLASSTYPE_EXPLICIT_INSTANTIATION (class_type))
+ /* If a class is declared in a header with the "extern
+ template" extension, then it will not be instantiated,
+ even in translation units that would normally require
+ it. Often such classes are explicitly instantiated in
+ one translation unit. Therefore, the explicit
+ instantiation must be made visible to other translation
+ units. */
+ DECL_EXTERNAL (decl) = 0;
else
- comdat_linkage (decl);
+ {
+ /* The generic C++ ABI says that class data is always
+ COMDAT, even if there is a key function. Some
+ variants (e.g., the ARM EABI) says that class data
+ only has COMDAT linkage if the class data might
+ be emitted in more than one translation unit. */
+ if (!CLASSTYPE_KEY_METHOD (class_type)
+ || targetm.cxx.class_data_always_comdat ())
+ {
+ /* The ABI requires COMDAT linkage. Normally, we
+ only emit COMDAT things when they are needed;
+ make sure that we realize that this entity is
+ indeed needed. */
+ comdat_p = true;
+ mark_needed (decl);
+ }
+ }
}
+ else if (!flag_implicit_templates
+ && CLASSTYPE_IMPLICIT_INSTANTIATION (class_type))
+ import_p = true;
else
+ comdat_p = true;
+ }
+ else if (TREE_CODE (decl) == VAR_DECL && DECL_TINFO_P (decl))
+ {
+ tree type = TREE_TYPE (DECL_NAME (decl));
+ if (CLASS_TYPE_P (type))
{
- DECL_EXTERNAL (decl) = 1;
- DECL_NOT_REALLY_EXTERN (decl) = 0;
+ class_type = type;
+ import_export_class (type);
+ if (CLASSTYPE_INTERFACE_KNOWN (type)
+ && TYPE_POLYMORPHIC_P (type)
+ && CLASSTYPE_INTERFACE_ONLY (type)
+ /* If -fno-rtti was specified, then we cannot be sure
+ that RTTI information will be emitted with the
+ virtual table of the class, so we must emit it
+ wherever it is used. */
+ && flag_rtti)
+ import_p = true;
+ else
+ {
+ if (CLASSTYPE_INTERFACE_KNOWN (type)
+ && !CLASSTYPE_INTERFACE_ONLY (type))
+ {
+ comdat_p = targetm.cxx.class_data_always_comdat ();
+ mark_needed (decl);
+ if (!flag_weak)
+ {
+ comdat_p = false;
+ DECL_EXTERNAL (decl) = 0;
+ }
+ }
+ else
+ comdat_p = true;
+ }
}
+ else
+ comdat_p = true;
+ }
+ else if (DECL_TEMPLATE_INSTANTIATION (decl)
+ || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl))
+ {
+ /* DECL is an implicit instantiation of a function or static
+ data member. */
+ if (flag_implicit_templates
+ || (flag_implicit_inline_templates
+ && TREE_CODE (decl) == FUNCTION_DECL
+ && DECL_DECLARED_INLINE_P (decl)))
+ comdat_p = true;
+ else
+ /* If we are not implicitly generating templates, then mark
+ this entity as undefined in this translation unit. */
+ import_p = true;
}
else if (DECL_FUNCTION_MEMBER_P (decl))
{
{
DECL_NOT_REALLY_EXTERN (decl)
= ! (CLASSTYPE_INTERFACE_ONLY (ctype)
- || (DECL_DECLARED_INLINE_P (decl)
+ || (DECL_DECLARED_INLINE_P (decl)
&& ! flag_implement_inlines
&& !DECL_VINDEX (decl)));
/* Always make artificials weak. */
if (DECL_ARTIFICIAL (decl) && flag_weak)
- comdat_linkage (decl);
+ comdat_p = true;
else
maybe_make_one_only (decl);
}
}
else
- comdat_linkage (decl);
+ comdat_p = true;
}
else
- comdat_linkage (decl);
-
- DECL_INTERFACE_KNOWN (decl) = 1;
-}
-
-/* Here, we only decide whether or not the tinfo node should be
- emitted with the vtable. IS_IN_LIBRARY is nonzero iff the
- typeinfo for TYPE should be in the runtime library. */
+ comdat_p = true;
-void
-import_export_tinfo (tree decl, tree type, bool is_in_library)
-{
- if (DECL_INTERFACE_KNOWN (decl))
- return;
-
- if (IS_AGGR_TYPE (type))
- import_export_class (type);
-
- if (IS_AGGR_TYPE (type) && CLASSTYPE_INTERFACE_KNOWN (type)
- && TYPE_POLYMORPHIC_P (type)
- /* If -fno-rtti, we're not necessarily emitting this stuff with
- the class, so go ahead and emit it now. This can happen when
- a class is used in exception handling. */
- && flag_rtti)
- {
- DECL_NOT_REALLY_EXTERN (decl) = !CLASSTYPE_INTERFACE_ONLY (type);
- DECL_COMDAT (decl) = 0;
- }
- else
+ if (import_p)
{
- DECL_NOT_REALLY_EXTERN (decl) = 1;
- DECL_COMDAT (decl) = 1;
- }
+ /* If we are importing DECL into this translation unit, mark is
+ an undefined here. */
+ DECL_EXTERNAL (decl) = 1;
+ DECL_NOT_REALLY_EXTERN (decl) = 0;
+ }
+ else if (comdat_p)
+ {
+ /* If we decided to put DECL in COMDAT, mark it accordingly at
+ this point. */
+ comdat_linkage (decl);
+ }
+
+ /* Give the target a chance to override the visibility associated
+ with DECL. */
+ if (TREE_CODE (decl) == VAR_DECL
+ && (DECL_TINFO_P (decl)
+ || (DECL_VTABLE_OR_VTT_P (decl)
+ /* Construction virtual tables are not exported because
+ they cannot be referred to from other object files;
+ their name is not standardized by the ABI. */
+ && !DECL_CONSTRUCTION_VTABLE_P (decl)))
+ && TREE_PUBLIC (decl)
+ && !DECL_REALLY_EXTERN (decl)
+ && DECL_VISIBILITY_SPECIFIED (decl)
+ && (!class_type || !CLASSTYPE_VISIBILITY_SPECIFIED (class_type)))
+ targetm.cxx.determine_class_data_visibility (decl);
- /* Now override some cases. */
- if (flag_weak)
- DECL_COMDAT (decl) = 1;
- else if (is_in_library)
- DECL_COMDAT (decl) = 0;
-
DECL_INTERFACE_KNOWN (decl) = 1;
}
/* This function should only be called for declarations that really
require cleanups. */
- my_friendly_assert (!TYPE_HAS_TRIVIAL_DESTRUCTOR (type), 20030106);
+ gcc_assert (!TYPE_HAS_TRIVIAL_DESTRUCTOR (type));
/* Treat all objects with destructors as used; the destructor may do
something substantive. */
/* We use a type that is big enough to contain a mutex as well
as an integer counter. */
- guard_type = long_long_integer_type_node;
+ guard_type = targetm.cxx.guard_type ();
guard = build_decl (VAR_DECL, sname, guard_type);
-
+
/* The guard should have the same linkage as what it guards. */
TREE_PUBLIC (guard) = TREE_PUBLIC (decl);
TREE_STATIC (guard) = TREE_STATIC (decl);
DECL_COMMON (guard) = DECL_COMMON (decl);
DECL_ONE_ONLY (guard) = DECL_ONE_ONLY (decl);
if (TREE_PUBLIC (decl))
- DECL_WEAK (guard) = DECL_WEAK (decl);
-
+ DECL_WEAK (guard) = DECL_WEAK (decl);
+
DECL_ARTIFICIAL (guard) = 1;
+ DECL_IGNORED_P (guard) = 1;
TREE_USED (guard) = 1;
pushdecl_top_level_and_finish (guard, NULL_TREE);
}
static tree
get_guard_bits (tree guard)
{
- /* We only set the first byte of the guard, in order to leave room
- for a mutex in the high-order bits. */
- guard = build1 (ADDR_EXPR,
- build_pointer_type (TREE_TYPE (guard)),
- guard);
- guard = build1 (NOP_EXPR,
- build_pointer_type (char_type_node),
- guard);
- guard = build1 (INDIRECT_REF, char_type_node, guard);
+ if (!targetm.cxx.guard_mask_bit ())
+ {
+ /* We only set the first byte of the guard, in order to leave room
+ for a mutex in the high-order bits. */
+ guard = build1 (ADDR_EXPR,
+ build_pointer_type (TREE_TYPE (guard)),
+ guard);
+ guard = build1 (NOP_EXPR,
+ build_pointer_type (char_type_node),
+ guard);
+ guard = build1 (INDIRECT_REF, char_type_node, guard);
+ }
return guard;
}
/* Check to see if the GUARD is zero. */
guard = get_guard_bits (guard);
+
+ /* Mask off all but the low bit. */
+ if (targetm.cxx.guard_mask_bit ())
+ {
+ guard_value = integer_one_node;
+ if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard)))
+ guard_value = convert (TREE_TYPE (guard), guard_value);
+ guard = cp_build_binary_op (BIT_AND_EXPR, guard, guard_value);
+ }
+
guard_value = integer_zero_node;
if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard)))
guard_value = convert (TREE_TYPE (guard), guard_value);
static tree
start_objects (int method_type, int initp)
{
- tree fnname;
tree body;
+ tree fndecl;
char type[10];
/* Make ctor or dtor function. METHOD_TYPE may be 'I' or 'D'. */
else
sprintf (type, "%c", method_type);
- fnname = get_file_function_name_long (type);
-
- start_function (void_list_node,
- make_call_declarator (fnname, void_list_node, NULL_TREE,
- NULL_TREE),
- NULL_TREE, SF_DEFAULT);
+ fndecl = build_lang_decl (FUNCTION_DECL,
+ get_file_function_name_long (type),
+ build_function_type (void_type_node,
+ void_list_node));
+ start_preparsed_function (fndecl, /*attrs=*/NULL_TREE, SF_PRE_PARSED);
/* It can be a static function as long as collect2 does not have
to scan the object file to find its ctor/dtor routine. */
DECL_GLOBAL_DTOR_P (current_function_decl) = 1;
DECL_LANG_SPECIFIC (current_function_decl)->decl_flags.u2sel = 1;
- body = begin_compound_stmt (/*has_no_scope=*/false);
+ body = begin_compound_stmt (BCS_FN_BODY);
/* We cannot allow these functions to be elided, even if they do not
have external linkage. And, there's no point in deferring
if (targetm.have_ctors_dtors)
{
rtx fnsym = XEXP (DECL_RTL (fn), 0);
+ cgraph_mark_needed_node (cgraph_node (fn));
if (method_type == 'I')
(* targetm.asm_out.constructor) (fnsym, initp);
else
/* All the static storage duration functions created in this
translation unit. */
-static GTY(()) varray_type ssdf_decls;
+static GTY(()) VEC(tree,gc) *ssdf_decls;
/* A map from priority levels to information about that priority
level. There may be many such levels, so efficient lookup is
nonzero, it performs initializations. Otherwise, it performs
destructions. It only performs those initializations or
destructions with the indicated __PRIORITY. The generated function
- returns no value.
+ returns no value.
It is assumed that this function will only be called once per
translation unit. */
type = build_function_type (void_type_node, parm_types);
/* Create the FUNCTION_DECL itself. */
- ssdf_decl = build_lang_decl (FUNCTION_DECL,
+ ssdf_decl = build_lang_decl (FUNCTION_DECL,
get_identifier (id),
type);
TREE_PUBLIC (ssdf_decl) = 0;
static constructors and destructors. */
if (!ssdf_decls)
{
- VARRAY_TREE_INIT (ssdf_decls, 32, "ssdf_decls");
+ ssdf_decls = VEC_alloc (tree, gc, 32);
/* Take this opportunity to initialize the map from priority
numbers to information about that priority level. */
get_priority_info (DEFAULT_INIT_PRIORITY);
}
- VARRAY_PUSH_TREE (ssdf_decls, ssdf_decl);
+ VEC_safe_push (tree, gc, ssdf_decls, ssdf_decl);
/* Create the argument list. */
initialize_p_decl = cp_build_parm_decl
function as:
static void __ssdf (int __initialize_p, init __priority_p);
-
+
It is static because we only need to call this function from the
various constructor and destructor functions for this module. */
- start_function (/*specs=*/NULL_TREE,
- ssdf_decl,
- /*attrs=*/NULL_TREE,
- SF_PRE_PARSED);
+ start_preparsed_function (ssdf_decl,
+ /*attrs=*/NULL_TREE,
+ SF_PRE_PARSED);
/* Set up the scope of the outermost block in the function. */
- body = begin_compound_stmt (/*has_no_scope=*/false);
+ body = begin_compound_stmt (BCS_FN_BODY);
/* This function must not be deferred because we are depending on
its compilation to tell us what is TREE_SYMBOL_REFERENCED. */
priority_info pi;
splay_tree_node n;
- n = splay_tree_lookup (priority_info_map,
+ n = splay_tree_lookup (priority_info_map,
(splay_tree_key) priority);
if (!n)
{
/* Create a new priority information structure, and insert it
into the map. */
- pi = xmalloc (sizeof (struct priority_info_s));
+ pi = XNEW (struct priority_info_s);
pi->initializations_p = 0;
pi->destructions_p = 0;
splay_tree_insert (priority_info_map,
return pi;
}
+/* The effective initialization priority of a DECL. */
+
+#define DECL_EFFECTIVE_INIT_PRIORITY(decl) \
+ ((!DECL_HAS_INIT_PRIORITY_P (decl) || DECL_INIT_PRIORITY (decl) == 0) \
+ ? DEFAULT_INIT_PRIORITY : DECL_INIT_PRIORITY (decl))
+
+/* Whether a DECL needs a guard to protect it against multiple
+ initialization. */
+
+#define NEEDS_GUARD_P(decl) (TREE_PUBLIC (decl) && (DECL_COMMON (decl) \
+ || DECL_ONE_ONLY (decl) \
+ || DECL_WEAK (decl)))
+
/* Set up to handle the initialization or destruction of DECL. If
INITP is nonzero, we are initializing the variable. Otherwise, we
are destroying it. */
-static tree
-start_static_initialization_or_destruction (tree decl, int initp)
+static void
+one_static_initialization_or_destruction (tree decl, tree init, bool initp)
{
tree guard_if_stmt = NULL_TREE;
- int priority;
- tree cond;
tree guard;
- tree init_cond;
- priority_info pi;
-
- /* Figure out the priority for this declaration. */
- priority = DECL_INIT_PRIORITY (decl);
- if (!priority)
- priority = DEFAULT_INIT_PRIORITY;
- /* Remember that we had an initialization or finalization at this
- priority. */
- pi = get_priority_info (priority);
- if (initp)
- pi->initializations_p = 1;
- else
- pi->destructions_p = 1;
+ /* If we are supposed to destruct and there's a trivial destructor,
+ nothing has to be done. */
+ if (!initp
+ && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
+ return;
/* Trick the compiler into thinking we are at the file and line
where DECL was declared so that error-messages make sense, and so
the conversion functions, or the destructor called to
create and destroy a static data member is performed as
if these calls appeared in the scope of the member's
- class.
+ class.
we pretend we are in a static member function of the class of
which the DECL is a member. */
DECL_CONTEXT (current_function_decl) = DECL_CONTEXT (decl);
DECL_STATIC_FUNCTION_P (current_function_decl) = 1;
}
-
- /* Conditionalize this initialization on being in the right priority
- and being initializing/finalizing appropriately. */
- guard_if_stmt = begin_if_stmt ();
- cond = cp_build_binary_op (EQ_EXPR,
- priority_decl,
- build_int_2 (priority, 0));
- init_cond = initp ? integer_one_node : integer_zero_node;
- init_cond = cp_build_binary_op (EQ_EXPR,
- initialize_p_decl,
- init_cond);
- cond = cp_build_binary_op (TRUTH_ANDIF_EXPR, cond, init_cond);
/* Assume we don't need a guard. */
guard = NULL_TREE;
might be initialized in more than one place. (For example, a
static data member of a template, when the data member requires
construction.) */
- if (TREE_PUBLIC (decl) && (DECL_COMMON (decl)
- || DECL_ONE_ONLY (decl)
- || DECL_WEAK (decl)))
+ if (NEEDS_GUARD_P (decl))
{
tree guard_cond;
{
/* When using __cxa_atexit, we never try to destroy
anything from a static destructor. */
- my_friendly_assert (initp, 20000629);
+ gcc_assert (initp);
guard_cond = get_guard_cond (guard);
}
/* If we don't have __cxa_atexit, then we will be running
destructions only if the GUARD is one, i.e., if we are the
last to destroy the variable. */
else if (initp)
- guard_cond
+ guard_cond
= cp_build_binary_op (EQ_EXPR,
build_unary_op (PREINCREMENT_EXPR,
guard,
/*noconvert=*/1),
integer_one_node);
else
- guard_cond
+ guard_cond
= cp_build_binary_op (EQ_EXPR,
build_unary_op (PREDECREMENT_EXPR,
guard,
/*noconvert=*/1),
integer_zero_node);
- cond = cp_build_binary_op (TRUTH_ANDIF_EXPR, cond, guard_cond);
+ guard_if_stmt = begin_if_stmt ();
+ finish_if_stmt_cond (guard_cond, guard_if_stmt);
}
- finish_if_stmt_cond (cond, guard_if_stmt);
/* If we're using __cxa_atexit, we have not already set the GUARD,
so we must do so now. */
if (guard && initp && flag_use_cxa_atexit)
finish_expr_stmt (set_guard (guard));
- return guard_if_stmt;
-}
+ /* Perform the initialization or destruction. */
+ if (initp)
+ {
+ if (init)
+ finish_expr_stmt (init);
-/* We've just finished generating code to do an initialization or
- finalization. GUARD_IF_STMT is the if-statement we used to guard
- the initialization. */
+ /* If we're using __cxa_atexit, register a function that calls the
+ destructor for the object. */
+ if (flag_use_cxa_atexit)
+ finish_expr_stmt (register_dtor_fn (decl));
+ }
+ else
+ finish_expr_stmt (build_cleanup (decl));
-static void
-finish_static_initialization_or_destruction (tree guard_if_stmt)
-{
- finish_then_clause (guard_if_stmt);
- finish_if_stmt ();
+ /* Finish the guard if-stmt, if necessary. */
+ if (guard)
+ {
+ finish_then_clause (guard_if_stmt);
+ finish_if_stmt (guard_if_stmt);
+ }
/* Now that we're done with DECL we don't need to pretend to be a
member of its class any longer. */
DECL_STATIC_FUNCTION_P (current_function_decl) = 0;
}
-/* Generate code to do the initialization of DECL, a VAR_DECL with
- static storage duration. The initialization is INIT. */
+/* Generate code to do the initialization or destruction of the decls in VARS,
+ a TREE_LIST of VAR_DECL with static storage duration.
+ Whether initialization or destruction is performed is specified by INITP. */
static void
-do_static_initialization (tree decl, tree init)
+do_static_initialization_or_destruction (tree vars, bool initp)
{
- tree guard_if_stmt;
-
- /* Set up for the initialization. */
- guard_if_stmt
- = start_static_initialization_or_destruction (decl,
- /*initp=*/1);
-
- /* Perform the initialization. */
- if (init)
- finish_expr_stmt (init);
-
- /* If we're using __cxa_atexit, register a a function that calls the
- destructor for the object. */
- if (flag_use_cxa_atexit)
- register_dtor_fn (decl);
+ tree node, init_if_stmt, cond;
- /* Finish up. */
- finish_static_initialization_or_destruction (guard_if_stmt);
-}
-
-/* Generate code to do the static destruction of DECL. If DECL may be
- initialized more than once in different object files, GUARD is the
- guard variable to check. PRIORITY is the priority for the
- destruction. */
-
-static void
-do_static_destruction (tree decl)
-{
- tree guard_if_stmt;
-
- /* If we're using __cxa_atexit, then destructors are registered
- immediately after objects are initialized. */
- my_friendly_assert (!flag_use_cxa_atexit, 20000121);
-
- /* If we don't need a destructor, there's nothing to do. */
- if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
- return;
+ /* Build the outer if-stmt to check for initialization or destruction. */
+ init_if_stmt = begin_if_stmt ();
+ cond = initp ? integer_one_node : integer_zero_node;
+ cond = cp_build_binary_op (EQ_EXPR,
+ initialize_p_decl,
+ cond);
+ finish_if_stmt_cond (cond, init_if_stmt);
+
+ node = vars;
+ do {
+ tree decl = TREE_VALUE (node);
+ tree priority_if_stmt;
+ int priority;
+ priority_info pi;
+
+ /* If we don't need a destructor, there's nothing to do. Avoid
+ creating a possibly empty if-stmt. */
+ if (!initp && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
+ {
+ node = TREE_CHAIN (node);
+ continue;
+ }
- /* Actually do the destruction. */
- guard_if_stmt = start_static_initialization_or_destruction (decl,
- /*initp=*/0);
- finish_expr_stmt (build_cleanup (decl));
- finish_static_initialization_or_destruction (guard_if_stmt);
+ /* Remember that we had an initialization or finalization at this
+ priority. */
+ priority = DECL_EFFECTIVE_INIT_PRIORITY (decl);
+ pi = get_priority_info (priority);
+ if (initp)
+ pi->initializations_p = 1;
+ else
+ pi->destructions_p = 1;
+
+ /* Conditionalize this initialization on being in the right priority
+ and being initializing/finalizing appropriately. */
+ priority_if_stmt = begin_if_stmt ();
+ cond = cp_build_binary_op (EQ_EXPR,
+ priority_decl,
+ build_int_cst (NULL_TREE, priority));
+ finish_if_stmt_cond (cond, priority_if_stmt);
+
+ /* Process initializers with same priority. */
+ for (; node
+ && DECL_EFFECTIVE_INIT_PRIORITY (TREE_VALUE (node)) == priority;
+ node = TREE_CHAIN (node))
+ /* Do one initialization or destruction. */
+ one_static_initialization_or_destruction (TREE_VALUE (node),
+ TREE_PURPOSE (node), initp);
+
+ /* Finish up the priority if-stmt body. */
+ finish_then_clause (priority_if_stmt);
+ finish_if_stmt (priority_if_stmt);
+
+ } while (node);
+
+ /* Finish up the init/destruct if-stmt body. */
+ finish_then_clause (init_if_stmt);
+ finish_if_stmt (init_if_stmt);
}
/* VARS is a list of variables with static storage duration which may
}
/* The only things that can be initialized are variables. */
- my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 19990420);
+ gcc_assert (TREE_CODE (decl) == VAR_DECL);
/* If this object is not defined, we don't need to do anything
here. */
/* Also, if the initializer already contains errors, we can bail
out now. */
- if (init && TREE_CODE (init) == TREE_LIST
+ if (init && TREE_CODE (init) == TREE_LIST
&& value_member (error_mark_node, init))
{
var = &TREE_CHAIN (t);
tree v;
for (v = vars; v; v = TREE_CHAIN (v))
- if (!var_finalized_p (TREE_VALUE (v)))
- rest_of_decl_compilation (TREE_VALUE (v), 0, 1, 1);
+ {
+ tree var = TREE_VALUE (v);
+ if (!var_finalized_p (var))
+ {
+ import_export_decl (var);
+ rest_of_decl_compilation (var, 1, 1);
+ }
+ }
}
/* Generate a static constructor (if CONSTRUCTOR_P) or destructor
size_t i;
input_location = *locus;
+#ifdef USE_MAPPED_LOCATION
+ /* ??? */
+#else
locus->line++;
-
+#endif
+
/* We use `I' to indicate initialization and `D' to indicate
destruction. */
function_key = constructor_p ? 'I' : 'D';
global constructors and destructors. */
body = NULL_TREE;
+ /* For Objective-C++, we may need to initialize metadata found in this module.
+ This must be done _before_ any other static initializations. */
+ if (c_dialect_objc () && (priority == DEFAULT_INIT_PRIORITY)
+ && constructor_p && objc_static_init_needed_p ())
+ {
+ body = start_objects (function_key, priority);
+ static_ctors = objc_generate_static_init_call (static_ctors);
+ }
+
/* Call the static storage duration function with appropriate
arguments. */
- if (ssdf_decls)
- for (i = 0; i < ssdf_decls->elements_used; ++i)
- {
- fndecl = VARRAY_TREE (ssdf_decls, i);
-
- /* Calls to pure or const functions will expand to nothing. */
- if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE)))
- {
- if (! body)
- body = start_objects (function_key, priority);
-
- arguments = tree_cons (NULL_TREE, build_int_2 (priority, 0),
- NULL_TREE);
- arguments = tree_cons (NULL_TREE, build_int_2 (constructor_p, 0),
- arguments);
- finish_expr_stmt (build_function_call (fndecl, arguments));
- }
- }
+ for (i = 0; VEC_iterate (tree, ssdf_decls, i, fndecl); ++i)
+ {
+ /* Calls to pure or const functions will expand to nothing. */
+ if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE)))
+ {
+ if (! body)
+ body = start_objects (function_key, priority);
+
+ arguments = tree_cons (NULL_TREE,
+ build_int_cst (NULL_TREE, priority),
+ NULL_TREE);
+ arguments = tree_cons (NULL_TREE,
+ build_int_cst (NULL_TREE, constructor_p),
+ arguments);
+ finish_expr_stmt (build_function_call (fndecl, arguments));
+ }
+ }
/* If we're generating code for the DEFAULT_INIT_PRIORITY, throw in
calls to any functions marked with attributes indicating that
{
tree fns;
- for (fns = constructor_p ? static_ctors : static_dtors;
+ for (fns = constructor_p ? static_ctors : static_dtors;
fns;
fns = TREE_CHAIN (fns))
{
{
tree t = *tp;
- if (flag_unit_at_a_time)
- switch (TREE_CODE (t))
- {
- case PTRMEM_CST:
- if (TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
- cgraph_mark_needed_node (cgraph_node (PTRMEM_CST_MEMBER (t)));
- break;
- case BASELINK:
- if (TREE_CODE (BASELINK_FUNCTIONS (t)) == FUNCTION_DECL)
- cgraph_mark_needed_node (cgraph_node (BASELINK_FUNCTIONS (t)));
- break;
-
- default:
- break;
- }
+ switch (TREE_CODE (t))
+ {
+ case PTRMEM_CST:
+ if (TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
+ cgraph_mark_needed_node (cgraph_node (PTRMEM_CST_MEMBER (t)));
+ break;
+ case BASELINK:
+ if (TREE_CODE (BASELINK_FUNCTIONS (t)) == FUNCTION_DECL)
+ cgraph_mark_needed_node (cgraph_node (BASELINK_FUNCTIONS (t)));
+ break;
+ case VAR_DECL:
+ if (DECL_VTABLE_OR_VTT_P (t))
+ {
+ /* The ABI requires that all virtual tables be emitted
+ whenever one of them is. */
+ tree vtbl;
+ for (vtbl = CLASSTYPE_VTABLES (DECL_CONTEXT (t));
+ vtbl;
+ vtbl = TREE_CHAIN (vtbl))
+ mark_decl_referenced (vtbl);
+ }
+ else if (DECL_CONTEXT (t)
+ && TREE_CODE (DECL_CONTEXT (t)) == FUNCTION_DECL)
+ /* If we need a static variable in a function, then we
+ need the containing function. */
+ mark_decl_referenced (DECL_CONTEXT (t));
+ break;
+ default:
+ break;
+ }
return NULL;
}
+/* Java requires that we be able to reference a local address for a
+ method, and not be confused by PLT entries. If hidden aliases are
+ supported, emit one for each java function that we've emitted. */
+
+static void
+build_java_method_aliases (void)
+{
+ struct cgraph_node *node;
+
+#ifndef HAVE_GAS_HIDDEN
+ return;
+#endif
+
+ for (node = cgraph_nodes; node ; node = node->next)
+ {
+ tree fndecl = node->decl;
+
+ if (TREE_ASM_WRITTEN (fndecl)
+ && DECL_CONTEXT (fndecl)
+ && TYPE_P (DECL_CONTEXT (fndecl))
+ && TYPE_FOR_JAVA (DECL_CONTEXT (fndecl))
+ && TARGET_USE_LOCAL_THUNK_ALIAS_P (fndecl))
+ {
+ /* Mangle the name in a predictable way; we need to reference
+ this from a java compiled object file. */
+ tree oid, nid, alias;
+ const char *oname;
+ char *nname;
+
+ oid = DECL_ASSEMBLER_NAME (fndecl);
+ oname = IDENTIFIER_POINTER (oid);
+ gcc_assert (oname[0] == '_' && oname[1] == 'Z');
+ nname = ACONCAT (("_ZGA", oname+2, NULL));
+ nid = get_identifier (nname);
+
+ alias = make_alias_for (fndecl, nid);
+ TREE_PUBLIC (alias) = 1;
+ DECL_VISIBILITY (alias) = VISIBILITY_HIDDEN;
+
+ assemble_alias (alias, oid);
+ }
+ }
+}
+
/* This routine is called from the last rule in yyparse ().
Its job is to create all the code needed to initialize and
destroy the global aggregates. We do the destruction
first, since that way we only need to reverse the decls once. */
void
-finish_file (void)
+cp_finish_file (void)
{
tree vars;
bool reconsider;
size_t i;
location_t locus;
unsigned ssdf_count = 0;
+ int retries = 0;
+ tree decl;
locus = input_location;
at_eof = 1;
if (pch_file)
c_common_write_pch ();
+#ifdef USE_MAPPED_LOCATION
+ /* FIXME - huh? */
+#else
/* Otherwise, GDB can get confused, because in only knows
about source for LINENO-1 lines. */
input_line -= 1;
-
- interface_unknown = 1;
- interface_only = 0;
+#endif
/* We now have to write out all the stuff we put off writing out.
These include:
o Template specializations that we have not yet instantiated,
- but which are needed.
+ but which are needed.
o Initialization and destruction for non-local objects with
- static storage duration. (Local objects with static storage
+ static storage duration. (Local objects with static storage
duration are initialized when their scope is first entered,
and are cleaned up via atexit.)
- o Virtual function tables.
+ o Virtual function tables.
All of these may cause others to be needed. For example,
instantiating one function may cause another to be needed, and
emit_support_tinfos ();
- do
+ do
{
tree t;
- size_t n_old, n_new;
+ tree decl;
reconsider = false;
/* If there are templates that we've put off instantiating, do
them now. */
- instantiate_pending_templates ();
+ instantiate_pending_templates (retries);
ggc_collect ();
/* Write out virtual tables as required. Note that writing out
- the virtual table for a template class may cause the
- instantiation of members of that class. If we write out
- vtables then we remove the class from our list so we don't
- have to look at it again. */
-
+ the virtual table for a template class may cause the
+ instantiation of members of that class. If we write out
+ vtables then we remove the class from our list so we don't
+ have to look at it again. */
+
while (keyed_classes != NULL_TREE
- && maybe_emit_vtables (TREE_VALUE (keyed_classes)))
- {
- reconsider = true;
- keyed_classes = TREE_CHAIN (keyed_classes);
- }
-
+ && maybe_emit_vtables (TREE_VALUE (keyed_classes)))
+ {
+ reconsider = true;
+ keyed_classes = TREE_CHAIN (keyed_classes);
+ }
+
t = keyed_classes;
if (t != NULL_TREE)
- {
- tree next = TREE_CHAIN (t);
-
- while (next)
- {
- if (maybe_emit_vtables (TREE_VALUE (next)))
- {
- reconsider = true;
- TREE_CHAIN (t) = TREE_CHAIN (next);
- }
- else
- t = next;
-
- next = TREE_CHAIN (t);
- }
- }
-
+ {
+ tree next = TREE_CHAIN (t);
+
+ while (next)
+ {
+ if (maybe_emit_vtables (TREE_VALUE (next)))
+ {
+ reconsider = true;
+ TREE_CHAIN (t) = TREE_CHAIN (next);
+ }
+ else
+ t = next;
+
+ next = TREE_CHAIN (t);
+ }
+ }
+
/* Write out needed type info variables. We have to be careful
- looping through unemitted decls, because emit_tinfo_decl may
- cause other variables to be needed. We stick new elements
- (and old elements that we may need to reconsider) at the end
- of the array, then shift them back to the beginning once we're
- done. */
-
- n_old = VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls);
- for (i = 0; i < n_old; ++i)
- {
- tree tinfo_decl = VARRAY_TREE (unemitted_tinfo_decls, i);
- if (emit_tinfo_decl (tinfo_decl))
- reconsider = true;
- else
- VARRAY_PUSH_TREE (unemitted_tinfo_decls, tinfo_decl);
- }
-
- /* The only elements we want to keep are the new ones. Copy
- them to the beginning of the array, then get rid of the
- leftovers. */
- n_new = VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls) - n_old;
- if (n_new)
- memmove (&VARRAY_TREE (unemitted_tinfo_decls, 0),
- &VARRAY_TREE (unemitted_tinfo_decls, n_old),
- n_new * sizeof (tree));
- memset (&VARRAY_TREE (unemitted_tinfo_decls, n_new),
- 0, n_old * sizeof (tree));
- VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls) = n_new;
+ looping through unemitted decls, because emit_tinfo_decl may
+ cause other variables to be needed. New elements will be
+ appended, and we remove from the vector those that actually
+ get emitted. */
+ for (i = VEC_length (tree, unemitted_tinfo_decls);
+ VEC_iterate (tree, unemitted_tinfo_decls, --i, t);)
+ if (emit_tinfo_decl (t))
+ {
+ reconsider = true;
+ VEC_unordered_remove (tree, unemitted_tinfo_decls, i);
+ }
/* The list of objects with static storage duration is built up
in reverse order. We clear STATIC_AGGREGATES so that any new
if (vars)
{
- tree v;
-
/* We need to start a new initialization function each time
through the loop. That's because we need to know which
vtables have been referenced, and TREE_SYMBOL_REFERENCED
write_out_vars (vars);
/* First generate code to do all the initializations. */
- for (v = vars; v; v = TREE_CHAIN (v))
- do_static_initialization (TREE_VALUE (v),
- TREE_PURPOSE (v));
+ if (vars)
+ do_static_initialization_or_destruction (vars, /*initp=*/true);
/* Then, generate code to do all the destructions. Do these
in reverse order so that the most recently constructed
__cxa_atexit, then we don't need to do this; functions
were registered at initialization time to destroy the
local statics. */
- if (!flag_use_cxa_atexit)
+ if (!flag_use_cxa_atexit && vars)
{
vars = nreverse (vars);
- for (v = vars; v; v = TREE_CHAIN (v))
- do_static_destruction (TREE_VALUE (v));
+ do_static_initialization_or_destruction (vars, /*initp=*/false);
}
else
vars = NULL_TREE;
instantiations, etc. */
reconsider = true;
ssdf_count++;
+#ifdef USE_MAPPED_LOCATION
+ /* ??? */
+#else
locus.line++;
+#endif
}
-
- for (i = 0; i < deferred_fns_used; ++i)
- {
- tree decl = VARRAY_TREE (deferred_fns, i);
+ /* Go through the set of inline functions whose bodies have not
+ been emitted yet. If out-of-line copies of these functions
+ are required, emit them. */
+ for (i = 0; VEC_iterate (tree, deferred_fns, i, decl); ++i)
+ {
/* Does it need synthesizing? */
if (DECL_ARTIFICIAL (decl) && ! DECL_INITIAL (decl)
- && TREE_USED (decl)
&& (! DECL_REALLY_EXTERN (decl) || DECL_INLINE (decl)))
{
/* Even though we're already at the top-level, we push
finish_function doesn't clean things up, and we end
up with CURRENT_FUNCTION_DECL set. */
push_to_top_level ();
+ /* The decl's location will mark where it was first
+ needed. Save that so synthesize method can indicate
+ where it was needed from, in case of error */
+ input_location = DECL_SOURCE_LOCATION (decl);
synthesize_method (decl);
pop_from_top_level ();
reconsider = true;
}
- /* If the function has no body, avoid calling
- import_export_decl. On a system without weak symbols,
- calling import_export_decl will make an inline template
- instantiation "static", which will result in errors about
- the use of undefined functions if there is no body for
- the function. In fact, all the functions in this list
- *should* have a body. */
if (!DECL_SAVED_TREE (decl))
- {
- if (! DECL_DECLARED_INLINE_P (decl) || ! TREE_USED (decl))
- abort ();
- continue;
- }
-
- import_export_decl (decl);
+ continue;
/* We lie to the back-end, pretending that some functions
are not defined when they really are. This keeps these
functions from being put out unnecessarily. But, we must
stop lying when the functions are referenced, or if they
- are not comdat since they need to be put out now. This
- is done in a separate for cycle, because if some deferred
- function is contained in another deferred function later
- in deferred_fns varray, rest_of_compilation would skip
- this function and we really cannot expand the same
- function twice. */
+ are not comdat since they need to be put out now. If
+ DECL_INTERFACE_KNOWN, then we have already set
+ DECL_EXTERNAL appropriately, so there's no need to check
+ again, and we do not want to clear DECL_EXTERNAL if a
+ previous call to import_export_decl set it.
+
+ This is done in a separate for cycle, because if some
+ deferred function is contained in another deferred
+ function later in deferred_fns varray,
+ rest_of_compilation would skip this function and we
+ really cannot expand the same function twice. */
+ import_export_decl (decl);
if (DECL_NOT_REALLY_EXTERN (decl)
&& DECL_INITIAL (decl)
- && DECL_NEEDED_P (decl))
+ && decl_needed_p (decl))
DECL_EXTERNAL (decl) = 0;
/* If we're going to need to write this function out, and
(There might be no body if this is a method we haven't
gotten around to synthesizing yet.) */
if (!DECL_EXTERNAL (decl)
- && DECL_NEEDED_P (decl)
+ && decl_needed_p (decl)
&& !TREE_ASM_WRITTEN (decl)
- && (!flag_unit_at_a_time
- || !cgraph_node (decl)->local.finalized))
+ && !cgraph_node (decl)->local.finalized)
{
/* We will output the function; no longer consider it in this
loop. */
reconsider = true;
/* Static data members are just like namespace-scope globals. */
- for (i = 0; i < pending_statics_used; ++i)
+ for (i = 0; VEC_iterate (tree, pending_statics, i, decl); ++i)
{
- tree decl = VARRAY_TREE (pending_statics, i);
- if (var_finalized_p (decl))
+ if (var_finalized_p (decl) || DECL_REALLY_EXTERN (decl))
continue;
import_export_decl (decl);
- if (DECL_NOT_REALLY_EXTERN (decl) && ! DECL_IN_AGGR_P (decl))
+ /* If this static data member is needed, provide it to the
+ back end. */
+ if (DECL_NOT_REALLY_EXTERN (decl) && decl_needed_p (decl))
DECL_EXTERNAL (decl) = 0;
}
- if (pending_statics
- && wrapup_global_declarations (&VARRAY_TREE (pending_statics, 0),
- pending_statics_used))
+ if (VEC_length (tree, pending_statics) != 0
+ && wrapup_global_declarations (VEC_address (tree, pending_statics),
+ VEC_length (tree, pending_statics)))
reconsider = true;
- if (cgraph_assemble_pending_functions ())
- reconsider = true;
- }
+ retries++;
+ }
while (reconsider);
/* All used inline functions must have a definition at this point. */
- for (i = 0; i < deferred_fns_used; ++i)
- {
- tree decl = VARRAY_TREE (deferred_fns, i);
-
- if (TREE_USED (decl) && DECL_DECLARED_INLINE_P (decl)
- && !(TREE_ASM_WRITTEN (decl) || DECL_SAVED_TREE (decl)
- /* An explicit instantiation can be used to specify
- that the body is in another unit. It will have
- already verified there was a definition. */
- || DECL_EXPLICIT_INSTANTIATION (decl)))
+ for (i = 0; VEC_iterate (tree, deferred_fns, i, decl); ++i)
+ {
+ if (/* Check online inline functions that were actually used. */
+ TREE_USED (decl) && DECL_DECLARED_INLINE_P (decl)
+ /* If the definition actually was available here, then the
+ fact that the function was not defined merely represents
+ that for some reason (use of a template repository,
+ #pragma interface, etc.) we decided not to emit the
+ definition here. */
+ && !DECL_INITIAL (decl)
+ /* An explicit instantiation can be used to specify
+ that the body is in another unit. It will have
+ already verified there was a definition. */
+ && !DECL_EXPLICIT_INSTANTIATION (decl))
{
- cp_warning_at ("inline function `%D' used but never defined", decl);
- /* This symbol is effectively an "extern" declaration now.
- This is not strictly necessary, but removes a duplicate
- warning. */
- TREE_PUBLIC (decl) = 1;
+ warning (0, "inline function %q+D used but never defined", decl);
+ /* Avoid a duplicate warning from check_global_declaration_1. */
+ TREE_NO_WARNING (decl) = 1;
}
-
}
-
+
/* We give C linkage to static constructors and destructors. */
push_lang_context (lang_name_c);
/* Generate initialization and destruction functions for all
priorities for which they are required. */
if (priority_info_map)
- splay_tree_foreach (priority_info_map,
+ splay_tree_foreach (priority_info_map,
generate_ctor_and_dtor_functions_for_priority,
/*data=*/&locus);
else
{
-
- if (static_ctors)
+ /* If we have a ctor or this is obj-c++ and we need a static init,
+ call generate_ctor_or_dtor_function. */
+ if (static_ctors || (c_dialect_objc () && objc_static_init_needed_p ()))
generate_ctor_or_dtor_function (/*constructor_p=*/true,
DEFAULT_INIT_PRIORITY, &locus);
if (static_dtors)
if (priority_info_map)
splay_tree_delete (priority_info_map);
+ /* Generate any missing aliases. */
+ maybe_apply_pending_pragma_weaks ();
+
/* We're done with static constructors, so we can go back to "C++"
linkage now. */
pop_lang_context ();
- if (flag_unit_at_a_time)
- {
- cgraph_finalize_compilation_unit ();
- cgraph_optimize ();
- }
-
- /* Emit mudflap static registration function. This must be done
- after all the user functions have been expanded. */
- if (flag_mudflap)
- mudflap_finish_file ();
+ cgraph_finalize_compilation_unit ();
+ cgraph_optimize ();
/* Now, issue warnings about static, but not defined, functions,
etc., and emit debugging information. */
walk_namespaces (wrapup_globals_for_namespace, /*data=*/&reconsider);
- if (pending_statics)
- check_global_declarations (&VARRAY_TREE (pending_statics, 0),
- pending_statics_used);
+ if (VEC_length (tree, pending_statics) != 0)
+ {
+ check_global_declarations (VEC_address (tree, pending_statics),
+ VEC_length (tree, pending_statics));
+ emit_debug_global_declarations (VEC_address (tree, pending_statics),
+ VEC_length (tree, pending_statics));
+ }
+
+ /* Generate hidden aliases for Java. */
+ build_java_method_aliases ();
finish_repo ();
dump_end (TDI_tu, stream);
}
}
-
+
timevar_pop (TV_VARCONST);
if (flag_detailed_statistics)
if (processing_template_decl)
{
- my_friendly_assert (TREE_CODE (fn) == DOTSTAR_EXPR
- || TREE_CODE (fn) == MEMBER_REF,
- 20030708);
+ gcc_assert (TREE_CODE (fn) == DOTSTAR_EXPR
+ || TREE_CODE (fn) == MEMBER_REF);
if (type_dependent_expression_p (fn)
|| any_type_dependent_arguments_p (args))
return build_min_nt (CALL_EXPR, fn, args, NULL_TREE);
return build_min_non_dep (CALL_EXPR, expr, orig_fn, orig_args, NULL_TREE);
return expr;
}
-
+
void
check_default_args (tree x)
saw_def = true;
else if (saw_def)
{
- cp_error_at ("default argument missing for parameter %P of `%+#D'",
- i, x);
+ error ("default argument missing for parameter %P of %q+#D", i, x);
break;
}
}
}
+/* Mark DECL as "used" in the program. If DECL is a specialization or
+ implicitly declared class member, generate the actual definition. */
+
void
mark_used (tree decl)
{
+ HOST_WIDE_INT saved_processing_template_decl = 0;
+
TREE_USED (decl) = 1;
- if (processing_template_decl || skip_evaluation)
+ /* If we don't need a value, then we don't need to synthesize DECL. */
+ if (skip_evaluation)
return;
+ /* Normally, we can wait until instantiation-time to synthesize
+ DECL. However, if DECL is a static data member initialized with
+ a constant, we need the value right now because a reference to
+ such a data member is not value-dependent. */
+ if (TREE_CODE (decl) == VAR_DECL
+ && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl)
+ && DECL_CLASS_SCOPE_P (decl))
+ {
+ /* Don't try to instantiate members of dependent types. We
+ cannot just use dependent_type_p here because this function
+ may be called from fold_non_dependent_expr, and then we may
+ see dependent types, even though processing_template_decl
+ will not be set. */
+ if (CLASSTYPE_TEMPLATE_INFO ((DECL_CONTEXT (decl)))
+ && uses_template_parms (CLASSTYPE_TI_ARGS (DECL_CONTEXT (decl))))
+ return;
+ /* Pretend that we are not in a template, even if we are, so
+ that the static data member initializer will be processed. */
+ saved_processing_template_decl = processing_template_decl;
+ processing_template_decl = 0;
+ }
+
+ if (processing_template_decl)
+ return;
if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl)
&& !TREE_ASM_WRITTEN (decl))
/* Remember it, so we can check it was defined. */
- defer_fn (decl);
+ {
+ if (DECL_DEFERRED_FN (decl))
+ return;
+
+ /* Remember the current location for a function we will end up
+ synthesizing. Then we can inform the user where it was
+ required in the case of error. */
+ if (DECL_ARTIFICIAL (decl) && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
+ && !DECL_THUNK_P (decl))
+ DECL_SOURCE_LOCATION (decl) = input_location;
+
+ note_vague_linkage_fn (decl);
+ }
assemble_external (decl);
/* Is it a synthesized method that needs to be synthesized? */
if (TREE_CODE (decl) == FUNCTION_DECL
&& DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
- && DECL_ARTIFICIAL (decl)
+ && DECL_ARTIFICIAL (decl)
&& !DECL_THUNK_P (decl)
&& ! DECL_INITIAL (decl)
- /* Kludge: don't synthesize for default args. */
+ /* Kludge: don't synthesize for default args. Unfortunately this
+ rules out initializers of namespace-scoped objects too, but
+ it's sort-of ok if the implicit ctor or dtor decl keeps
+ pointing to the class location. */
&& current_function_decl)
{
synthesize_method (decl);
if ((DECL_NON_THUNK_FUNCTION_P (decl) || TREE_CODE (decl) == VAR_DECL)
&& DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
&& (!DECL_EXPLICIT_INSTANTIATION (decl)
- || (TREE_CODE (decl) == FUNCTION_DECL
- && DECL_INLINE (DECL_TEMPLATE_RESULT
- (template_for_substitution (decl))))))
- {
- bool defer;
-
- /* Normally, we put off instantiating functions in order to
- improve compile times. Maintaining a stack of active
- functions is expensive, and the inliner knows to
- instantiate any functions it might need.
-
- However, if instantiating this function might help us mark
- the current function TREE_NOTHROW, we go ahead and
- instantiate it now.
-
- This is not needed for unit-at-a-time since we reorder the functions
- in topological order anyway.
- */
- defer = (!flag_exceptions
- || flag_unit_at_a_time
- || !optimize
- || TREE_CODE (decl) != FUNCTION_DECL
- /* If the called function can't throw, we don't need to
- generate its body to find that out. */
- || TREE_NOTHROW (decl)
- || !cfun
- || !current_function_decl
- /* If we already know the current function can't throw,
- then we don't need to work hard to prove it. */
- || TREE_NOTHROW (current_function_decl)
- /* If we already know that the current function *can*
- throw, there's no point in gathering more
- information. */
- || cp_function_chain->can_throw);
-
- instantiate_decl (decl, defer, /*undefined_ok=*/0);
- }
+ || (TREE_CODE (decl) == FUNCTION_DECL
+ && DECL_INLINE (DECL_TEMPLATE_RESULT
+ (template_for_substitution (decl))))
+ /* We need to instantiate static data members so that there
+ initializers are available in integral constant
+ expressions. */
+ || (TREE_CODE (decl) == VAR_DECL
+ && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl))))
+ /* We put off instantiating functions in order to improve compile
+ times. Maintaining a stack of active functions is expensive,
+ and the inliner knows to instantiate any functions it might
+ need. */
+ instantiate_decl (decl, /*defer_ok=*/true,
+ /*expl_inst_class_mem_p=*/false);
+
+ processing_template_decl = saved_processing_template_decl;
}
#include "gt-cp-decl2.h"
OSDN Git Service
