int at_eof;
-/* Functions called along with real static constructors and destructors. */
-
-tree static_ctors;
-tree static_dtors;
-
\f
/* Return a member function type (a METHOD_TYPE), given FNTYPE (a
sees templates. */
if (!processing_template_decl)
DECL_ARG_TYPE (parm) = type_passed_as (type);
+
+ /* If the type is a pack expansion, then we have a function
+ parameter pack. */
+ if (type && TREE_CODE (type) == TYPE_PACK_EXPANSION)
+ FUNCTION_PARAMETER_PACK_P (parm) = 1;
+
return parm;
}
|| (TREE_CODE (decl) == TYPE_DECL
&& IS_AGGR_TYPE (TREE_TYPE (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 %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 %q#D",
- decl);
- DECL_VIRTUAL_P (decl) = 0;
- }
+ /* The parser rejects template declarations in local classes. */
+ gcc_assert (!current_function_decl);
+ /* The parser rejects any use of virtual in a function template. */
+ gcc_assert (!(TREE_CODE (decl) == FUNCTION_DECL
+ && DECL_VIRTUAL_P (decl)));
/* The debug-information generating code doesn't know what to do
with member templates. */
static bool
acceptable_java_type (tree type)
{
+ if (type == error_mark_node)
+ return false;
+
if (TREE_CODE (type) == VOID_TYPE || TYPE_FOR_JAVA (type))
- return 1;
+ return true;
if (TREE_CODE (type) == POINTER_TYPE || TREE_CODE (type) == REFERENCE_TYPE)
{
type = TREE_TYPE (type);
tree type = TREE_VALUE (arg_types);
if (!acceptable_java_type (type))
{
- error ("Java method %qD has non-Java parameter type %qT",
- method, type);
+ if (type != error_mark_node)
+ error ("Java method %qD has non-Java parameter type %qT",
+ method, type);
jerr = true;
}
}
{
int ix;
bool is_template;
-
+ tree pushed_scope;
+
if (DECL_USE_TEMPLATE (function)
&& !(TREE_CODE (function) == TEMPLATE_DECL
&& DECL_TEMPLATE_SPECIALIZATION (function))
/* OK, is this a definition of a member template? */
is_template = (template_parms != NULL_TREE);
+ /* We must enter the scope here, because conversion operators are
+ named by target type, and type equivalence relies on typenames
+ resolving within the scope of CTYPE. */
+ pushed_scope = push_scope (ctype);
ix = class_method_index_for_fn (complete_type (ctype), function);
if (ix >= 0)
{
VEC(tree,gc) *methods = CLASSTYPE_METHOD_VEC (ctype);
tree fndecls, fndecl = 0;
bool is_conv_op;
- tree pushed_scope;
const char *format = NULL;
- pushed_scope = push_scope (ctype);
for (fndecls = VEC_index (tree, methods, ix);
fndecls; fndecls = OVL_NEXT (fndecls))
{
== DECL_TI_TEMPLATE (fndecl))))
break;
}
- if (pushed_scope)
- pop_scope (pushed_scope);
if (fndecls)
- return OVL_CURRENT (fndecls);
+ {
+ if (pushed_scope)
+ pop_scope (pushed_scope);
+ return OVL_CURRENT (fndecls);
+ }
+
error ("prototype for %q#D does not match any in class %qT",
function, ctype);
is_conv_op = DECL_CONV_FN_P (fndecl);
properly within the class. */
if (COMPLETE_TYPE_P (ctype))
add_method (ctype, function, NULL_TREE);
+
+ if (pushed_scope)
+ pop_scope (pushed_scope);
return NULL_TREE;
}
}
}
-/* 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.
The other parameters are as for cp_finish_decl. */
void
-finish_static_data_member_decl (tree decl,
+finish_static_data_member_decl (tree decl,
tree init, bool init_const_expr_p,
tree asmspec_tree,
int flags)
{
- gcc_assert (TREE_PUBLIC (decl));
-
DECL_CONTEXT (decl) = current_class_type;
/* We cannot call pushdecl here, because that would fill in the
TREE_CHAIN of our decl. Instead, we modify cp_finish_decl to do
the right thing, namely, to put this decl out straight away. */
- /* current_class_type can be NULL_TREE in case of error. */
- if (!asmspec_tree && current_class_type)
- DECL_INITIAL (decl) = error_mark_node;
if (! processing_template_decl)
- note_vague_linkage_var (decl);
+ VEC_safe_push (tree, gc, pending_statics, decl);
if (LOCAL_CLASS_P (current_class_type))
pedwarn ("local class %q#T shall not have static data member %q#D",
/* DECLARATOR and DECLSPECS correspond to a class member. The other
parameters are as for cp_finish_decl. Return the DECL for the
- class member declared. */
+ class member declared. */
tree
grokfield (const cp_declarator *declarator,
const char *asmspec = 0;
int flags = LOOKUP_ONLYCONVERTING;
- 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
&& TREE_VALUE (init) == error_mark_node
return void_type_node;
}
- if (asmspec_tree)
+ if (asmspec_tree && asmspec_tree != error_mark_node)
asmspec = TREE_STRING_POINTER (asmspec_tree);
if (init)
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, /*init_const_expr_p=*/false,
+ cp_finish_decl (value, init, /*init_const_expr_p=*/false,
NULL_TREE, flags);
DECL_INITIAL (value) = init;
DECL_IN_AGGR_P (value) = 1;
if (asmspec)
set_user_assembler_name (value, asmspec);
- cp_finish_decl (value, init, /*init_const_expr_p=*/false,
+ cp_finish_decl (value,
+ /*init=*/NULL_TREE,
+ /*init_const_expr_p=*/false,
asmspec_tree, flags);
/* Pass friends back this way. */
{
tree value = grokdeclarator (declarator, declspecs, BITFIELD, 0, NULL);
- if (! value) return NULL_TREE; /* friends went bad. */
+ if (value == error_mark_node)
+ return NULL_TREE; /* friends went bad. */
/* Pass friendly classes back. */
if (TREE_CODE (value) == VOID_TYPE)
return void_type_node;
+ if (!INTEGRAL_TYPE_P (TREE_TYPE (value))
+ && (POINTER_TYPE_P (value)
+ || !dependent_type_p (TREE_TYPE (value))))
+ {
+ error ("bit-field %qD with non-integral type", value);
+ return error_mark_node;
+ }
+
if (TREE_CODE (value) == TYPE_DECL)
{
error ("cannot declare %qD to be a bit-field type", value);
void
cplus_decl_attributes (tree *decl, tree attributes, int flags)
{
- if (*decl == NULL_TREE || *decl == void_type_node)
+ if (*decl == NULL_TREE || *decl == void_type_node
+ || *decl == error_mark_node)
return;
if (TREE_CODE (*decl) == TEMPLATE_DECL)
}
main_decl = build_anon_union_vars (type, anon_union_decl);
+ if (main_decl == error_mark_node)
+ return;
if (main_decl == NULL_TREE)
{
warning (0, "anonymous union with no members");
if (MULTIPLE_SYMBOL_SPACES && import_export == -1)
import_export = 0;
- /* Allow backends the chance to overrule the decision. */
+ /* Allow back ends the chance to overrule the decision. */
if (targetm.cxx.import_export_class)
import_export = targetm.cxx.import_export_class (ctype, import_export);
static bool
var_finalized_p (tree var)
{
- return cgraph_varpool_node (var)->finalized;
+ return varpool_node (var)->finalized;
}
/* DECL is a VAR_DECL or FUNCTION_DECL which, for whatever reason,
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
+ /* 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)
return true;
}
+/* A special return value from type_visibility meaning internal
+ linkage. */
+
+enum { VISIBILITY_ANON = VISIBILITY_INTERNAL+1 };
+
+/* walk_tree helper function for type_visibility. */
+
+static tree
+min_vis_r (tree *tp, int *walk_subtrees, void *data)
+{
+ int *vis_p = (int *)data;
+ if (! TYPE_P (*tp))
+ {
+ *walk_subtrees = 0;
+ }
+ else if (CLASS_TYPE_P (*tp))
+ {
+ if (!TREE_PUBLIC (TYPE_MAIN_DECL (*tp)))
+ {
+ *vis_p = VISIBILITY_ANON;
+ return *tp;
+ }
+ else if (CLASSTYPE_VISIBILITY (*tp) > *vis_p)
+ *vis_p = CLASSTYPE_VISIBILITY (*tp);
+ }
+ return NULL;
+}
+
+/* Returns the visibility of TYPE, which is the minimum visibility of its
+ component types. */
+
+static int
+type_visibility (tree type)
+{
+ int vis = VISIBILITY_DEFAULT;
+ walk_tree_without_duplicates (&type, min_vis_r, &vis);
+ return vis;
+}
+
+/* Limit the visibility of DECL to VISIBILITY, if not explicitly
+ specified (or if VISIBILITY is static). */
+
+static bool
+constrain_visibility (tree decl, int visibility)
+{
+ if (visibility == VISIBILITY_ANON)
+ {
+ /* extern "C" declarations aren't affected by the anonymous
+ namespace. */
+ if (!DECL_EXTERN_C_P (decl))
+ {
+ TREE_PUBLIC (decl) = 0;
+ DECL_INTERFACE_KNOWN (decl) = 1;
+ if (DECL_LANG_SPECIFIC (decl))
+ DECL_NOT_REALLY_EXTERN (decl) = 1;
+ }
+ }
+ else if (visibility > DECL_VISIBILITY (decl)
+ && !DECL_VISIBILITY_SPECIFIED (decl))
+ {
+ DECL_VISIBILITY (decl) = visibility;
+ return true;
+ }
+ return false;
+}
+
+/* Constrain the visibility of DECL based on the visibility of its template
+ arguments. */
+
+static void
+constrain_visibility_for_template (tree decl, tree targs)
+{
+ /* If this is a template instantiation, check the innermost
+ template args for visibility constraints. The outer template
+ args are covered by the class check. */
+ tree args = INNERMOST_TEMPLATE_ARGS (targs);
+ int i;
+ for (i = TREE_VEC_LENGTH (args); i > 0; --i)
+ {
+ int vis = 0;
+
+ tree arg = TREE_VEC_ELT (args, i-1);
+ if (TYPE_P (arg))
+ vis = type_visibility (arg);
+ else if (TREE_TYPE (arg) && POINTER_TYPE_P (TREE_TYPE (arg)))
+ {
+ STRIP_NOPS (arg);
+ if (TREE_CODE (arg) == ADDR_EXPR)
+ arg = TREE_OPERAND (arg, 0);
+ if (TREE_CODE (arg) == VAR_DECL
+ || TREE_CODE (arg) == FUNCTION_DECL)
+ {
+ if (! TREE_PUBLIC (arg))
+ vis = VISIBILITY_ANON;
+ else
+ vis = DECL_VISIBILITY (arg);
+ }
+ }
+ if (vis)
+ constrain_visibility (decl, vis);
+ }
+}
+
/* Like c_determine_visibility, but with additional C++-specific
behavior.
Note that because namespaces have multiple independent definitions,
namespace visibility is handled elsewhere using the #pragma visibility
- machinery rather than by decorating the namespace declaration. */
+ machinery rather than by decorating the namespace declaration.
+
+ The goal is for constraints from the type to give a diagnostic, and
+ other constraints to be applied silently. */
void
determine_visibility (tree decl)
{
- tree class_type;
+ tree class_type = NULL_TREE;
+ bool use_template;
+
+ /* Remember that all decls get VISIBILITY_DEFAULT when built. */
/* Only relevant for names with external linkage. */
if (!TREE_PUBLIC (decl))
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 (TREE_CODE (decl) == TYPE_DECL)
+ {
+ if (CLASS_TYPE_P (TREE_TYPE (decl)))
+ use_template = CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl));
+ else if (TYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
+ use_template = 1;
+ else
+ use_template = 0;
+ }
+ else if (DECL_LANG_SPECIFIC (decl))
+ use_template = DECL_USE_TEMPLATE (decl);
+ else
+ use_template = 0;
+
+ /* Anything that is exported must have default visibility. */
+ if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
+ && lookup_attribute ("dllexport",
+ TREE_CODE (decl) == TYPE_DECL
+ ? TYPE_ATTRIBUTES (TREE_TYPE (decl))
+ : DECL_ATTRIBUTES (decl)))
+ {
+ DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
+ DECL_VISIBILITY_SPECIFIED (decl) = 1;
+ }
/* If DECL is a member of a class, visibility specifiers on the
class can influence the visibility of the DECL. */
class_type = TREE_TYPE (DECL_NAME (decl));
else
{
+ /* Not a class member. */
+
/* 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));
- if (DECL_FUNCTION_SCOPE_P (decl))
+ if (DECL_FUNCTION_SCOPE_P (decl) && ! DECL_VISIBILITY_SPECIFIED (decl))
{
+ /* Local statics and classes get the visibility of their
+ containing function by default, except that
+ -fvisibility-inlines-hidden doesn't affect them. */
tree fn = DECL_CONTEXT (decl);
- DECL_VISIBILITY (decl) = DECL_VISIBILITY (fn);
- DECL_VISIBILITY_SPECIFIED (decl) = DECL_VISIBILITY_SPECIFIED (fn);
+ if (DECL_VISIBILITY_SPECIFIED (fn) || ! DECL_CLASS_SCOPE_P (fn))
+ {
+ DECL_VISIBILITY (decl) = DECL_VISIBILITY (fn);
+ DECL_VISIBILITY_SPECIFIED (decl) =
+ DECL_VISIBILITY_SPECIFIED (fn);
+ }
+ else
+ determine_visibility_from_class (decl, DECL_CONTEXT (fn));
+
+ /* Local classes in templates have CLASSTYPE_USE_TEMPLATE set,
+ but have no TEMPLATE_INFO, so don't try to check it. */
+ use_template = 0;
+ }
+ else if (TREE_CODE (decl) == VAR_DECL && DECL_TINFO_P (decl))
+ {
+ /* tinfo visibility is based on the type it's for. */
+ constrain_visibility
+ (decl, type_visibility (TREE_TYPE (DECL_NAME (decl))));
}
+ else if (use_template)
+ /* Template instantiations and specializations get visibility based
+ on their template unless they override it with an attribute. */;
+ else if (! DECL_VISIBILITY_SPECIFIED (decl))
+ {
+ /* Set default visibility to whatever the user supplied with
+ #pragma GCC visibility or a namespace visibility attribute. */
+ DECL_VISIBILITY (decl) = default_visibility;
+ DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
+ }
+ }
- /* Entities not associated with any class just get the
- visibility specified by their attributes. */
- return;
+ if (use_template)
+ {
+ /* If the specialization doesn't specify visibility, use the
+ visibility from the template. */
+ tree tinfo = (TREE_CODE (decl) == TYPE_DECL
+ ? TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
+ : DECL_TEMPLATE_INFO (decl));
+ tree args = TI_ARGS (tinfo);
+
+ if (args != error_mark_node)
+ {
+ int depth = TMPL_ARGS_DEPTH (args);
+ tree pattern = DECL_TEMPLATE_RESULT (TI_TEMPLATE (tinfo));
+
+ if (!DECL_VISIBILITY_SPECIFIED (decl))
+ {
+ DECL_VISIBILITY (decl) = DECL_VISIBILITY (pattern);
+ DECL_VISIBILITY_SPECIFIED (decl)
+ = DECL_VISIBILITY_SPECIFIED (pattern);
+ }
+
+ /* FIXME should TMPL_ARGS_DEPTH really return 1 for null input? */
+ if (args && depth > template_class_depth (class_type))
+ /* Limit visibility based on its template arguments. */
+ constrain_visibility_for_template (decl, args);
+ }
}
- /* By default, static data members and function members receive
- the visibility of their containing class. */
if (class_type)
+ determine_visibility_from_class (decl, class_type);
+
+ if (decl_anon_ns_mem_p (decl))
+ /* Names in an anonymous namespace get internal linkage.
+ This might change once we implement export. */
+ constrain_visibility (decl, VISIBILITY_ANON);
+ else if (TREE_CODE (decl) != TYPE_DECL)
{
- determine_visibility_from_class (decl, class_type);
-
- /* 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);
- }
+ /* Propagate anonymity from type to decl. */
+ int tvis = type_visibility (TREE_TYPE (decl));
+ if (tvis == VISIBILITY_ANON)
+ constrain_visibility (decl, tvis);
+ }
}
+/* By default, static data members and function members receive
+ the visibility of their containing class. */
+
static void
determine_visibility_from_class (tree decl, tree 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))
+ if (visibility_options.inlines_hidden
+ /* Don't do this for inline templates; specializations might not be
+ inline, and we don't want them to inherit the hidden
+ visibility. We'll set it here for all inline instantiations. */
+ && !processing_template_decl
+ && ! DECL_VISIBILITY_SPECIFIED (decl)
+ && TREE_CODE (decl) == FUNCTION_DECL
+ && DECL_DECLARED_INLINE_P (decl)
+ && (! DECL_LANG_SPECIFIC (decl)
+ || ! DECL_EXPLICIT_INSTANTIATION (decl)))
+ DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
+ else if (!DECL_VISIBILITY_SPECIFIED (decl))
{
+ /* Default to the class visibility. */
DECL_VISIBILITY (decl) = CLASSTYPE_VISIBILITY (class_type);
- DECL_VISIBILITY_SPECIFIED (decl) = 1;
- }
- else if (TYPE_CLASS_SCOPE_P (class_type))
- determine_visibility_from_class (decl, TYPE_CONTEXT (class_type));
- else if (TYPE_FUNCTION_SCOPE_P (class_type))
- {
- tree fn = TYPE_CONTEXT (class_type);
- DECL_VISIBILITY (decl) = DECL_VISIBILITY (fn);
- DECL_VISIBILITY_SPECIFIED (decl) = DECL_VISIBILITY_SPECIFIED (fn);
+ DECL_VISIBILITY_SPECIFIED (decl)
+ = CLASSTYPE_VISIBILITY_SPECIFIED (class_type);
}
- else if (!DECL_VISIBILITY_SPECIFIED (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)
+ && !CLASSTYPE_VISIBILITY_SPECIFIED (class_type))
+ targetm.cxx.determine_class_data_visibility (decl);
+}
+
+/* Constrain the visibility of a class TYPE based on the visibility of its
+ field types. Warn if any fields require lesser visibility. */
+
+void
+constrain_class_visibility (tree type)
+{
+ tree binfo;
+ tree t;
+ int i;
+
+ int vis = type_visibility (type);
+
+ if (vis == VISIBILITY_ANON
+ || DECL_IN_SYSTEM_HEADER (TYPE_MAIN_DECL (type)))
+ return;
+
+ /* Don't warn about visibility if the class has explicit visibility. */
+ if (CLASSTYPE_VISIBILITY_SPECIFIED (type))
+ vis = VISIBILITY_INTERNAL;
+
+ for (t = TYPE_FIELDS (type); t; t = TREE_CHAIN (t))
+ if (TREE_CODE (t) == FIELD_DECL && TREE_TYPE (t) != error_mark_node)
+ {
+ tree ftype = strip_pointer_or_array_types (TREE_TYPE (t));
+ int subvis = type_visibility (ftype);
+
+ if (subvis == VISIBILITY_ANON)
+ {
+ if (strcmp (main_input_filename,
+ DECL_SOURCE_FILE (TYPE_MAIN_DECL (ftype))))
+ warning (0, "\
+%qT has a field %qD whose type uses the anonymous namespace",
+ type, t);
+ }
+ else if (IS_AGGR_TYPE (ftype)
+ && vis < VISIBILITY_HIDDEN
+ && subvis >= VISIBILITY_HIDDEN)
+ warning (OPT_Wattributes, "\
+%qT declared with greater visibility than the type of its field %qD",
+ type, t);
+ }
+
+ binfo = TYPE_BINFO (type);
+ for (i = 0; BINFO_BASE_ITERATE (binfo, i, t); ++i)
{
- DECL_VISIBILITY (decl) = CLASSTYPE_VISIBILITY (class_type);
- DECL_VISIBILITY_SPECIFIED (decl) = 0;
+ int subvis = type_visibility (TREE_TYPE (t));
+
+ if (subvis == VISIBILITY_ANON)
+ {
+ if (strcmp (main_input_filename,
+ DECL_SOURCE_FILE (TYPE_MAIN_DECL (TREE_TYPE (t)))))
+ warning (0, "\
+%qT has a base %qT whose type uses the anonymous namespace",
+ type, TREE_TYPE (t));
+ }
+ else if (vis < VISIBILITY_HIDDEN
+ && subvis >= VISIBILITY_HIDDEN)
+ warning (OPT_Wattributes, "\
+%qT declared with greater visibility than its base %qT",
+ type, TREE_TYPE (t));
}
}
if (TREE_CODE (type) == ARRAY_TYPE)
temp = decl;
else
- {
- cxx_mark_addressable (decl);
- temp = build1 (ADDR_EXPR, build_pointer_type (type), decl);
- }
+ temp = build_address (decl);
temp = build_delete (TREE_TYPE (temp), temp,
sfk_complete_destructor,
LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
sprintf (type, "%c", method_type);
fndecl = build_lang_decl (FUNCTION_DECL,
- get_file_function_name_long (type),
+ get_file_function_name (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. */
- TREE_PUBLIC (current_function_decl) = ! targetm.have_ctors_dtors;
+ TREE_PUBLIC (current_function_decl) = 0;
/* Mark this declaration as used to avoid spurious warnings. */
TREE_USED (current_function_decl) = 1;
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
- compilation of thes functions; they're all going to have to be
- out anyhow. */
- DECL_INLINE (current_function_decl) = 0;
- DECL_UNINLINABLE (current_function_decl) = 1;
-
return body;
}
/* Finish up. */
finish_compound_stmt (body);
fn = finish_function (0);
- expand_or_defer_fn (fn);
- /* When only doing semantic analysis, and no RTL generation, we
- can't call functions that directly emit assembly code; there is
- no assembly file in which to put the code. */
- if (flag_syntax_only)
- return;
-
- if (targetm.have_ctors_dtors)
+ if (method_type == 'I')
{
- 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
- (* targetm.asm_out.destructor) (fnsym, initp);
+ DECL_STATIC_CONSTRUCTOR (fn) = 1;
+ decl_init_priority_insert (fn, initp);
}
+ else
+ {
+ DECL_STATIC_DESTRUCTOR (fn) = 1;
+ decl_fini_priority_insert (fn, initp);
+ }
+
+ expand_or_defer_fn (fn);
}
/* The names of the parameters to the function created to handle
type);
TREE_PUBLIC (ssdf_decl) = 0;
DECL_ARTIFICIAL (ssdf_decl) = 1;
+ DECL_INLINE (ssdf_decl) = 1;
/* Put this function in the list of functions to be called from the
static constructors and destructors. */
/* Set up the scope of the outermost block in the function. */
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. */
- DECL_INLINE (ssdf_decl) = 0;
- DECL_UNINLINABLE (ssdf_decl) = 1;
-
return body;
}
if (initp)
{
if (init)
- finish_expr_stmt (init);
+ finish_expr_stmt (init);
/* If we're using __cxa_atexit, register a function that calls the
- destructor for the object. */
+ destructor for the object. */
if (flag_use_cxa_atexit)
- finish_expr_stmt (register_dtor_fn (decl));
+ finish_expr_stmt (register_dtor_fn (decl));
}
else
finish_expr_stmt (build_cleanup (decl));
node = TREE_CHAIN (node))
/* Do one initialization or destruction. */
one_static_initialization_or_destruction (TREE_VALUE (node),
- TREE_PURPOSE (node), initp);
+ TREE_PURPOSE (node), initp);
/* Finish up the priority if-stmt body. */
finish_then_clause (priority_if_stmt);
}
/* Generate a static constructor (if CONSTRUCTOR_P) or destructor
- (otherwise) that will initialize all gobal objects with static
+ (otherwise) that will initialize all global objects with static
storage duration having the indicated PRIORITY. */
static void
&& constructor_p && objc_static_init_needed_p ())
{
body = start_objects (function_key, priority);
- static_ctors = objc_generate_static_init_call (static_ctors);
+ objc_generate_static_init_call (NULL_TREE);
}
/* Call the static storage duration function with appropriate
}
}
- /* If we're generating code for the DEFAULT_INIT_PRIORITY, throw in
- calls to any functions marked with attributes indicating that
- they should be called at initialization- or destruction-time. */
- if (priority == DEFAULT_INIT_PRIORITY)
- {
- tree fns;
-
- for (fns = constructor_p ? static_ctors : static_dtors;
- fns;
- fns = TREE_CHAIN (fns))
- {
- fndecl = TREE_VALUE (fns);
-
- /* Calls to pure/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);
- finish_expr_stmt (build_function_call (fndecl, NULL_TREE));
- }
- }
- }
-
/* Close out the function. */
if (body)
finish_objects (function_key, priority, body);
/* Generate the functions themselves, but only if they are really
needed. */
- if (pi->initializations_p
- || (priority == DEFAULT_INIT_PRIORITY && static_ctors))
+ if (pi->initializations_p)
generate_ctor_or_dtor_function (/*constructor_p=*/true, priority, locus);
- if (pi->destructions_p
- || (priority == DEFAULT_INIT_PRIORITY && static_dtors))
+ if (pi->destructions_p)
generate_ctor_or_dtor_function (/*constructor_p=*/false, priority, locus);
/* Keep iterating. */
}
/* Called via LANGHOOK_CALLGRAPH_ANALYZE_EXPR. It is supposed to mark
- decls referenced from frontend specific constructs; it will be called
+ decls referenced from front-end specific constructs; it will be called
only for language-specific tree nodes.
Here we must deal with member pointers. */
}
}
-/* This routine is called from the last rule in yyparse ().
+/* This routine is called at the end of compilation.
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
-cp_finish_file (void)
+cp_write_global_declarations (void)
{
tree vars;
bool reconsider;
through the loop. That's because we need to know which
vtables have been referenced, and TREE_SYMBOL_REFERENCED
isn't computed until a function is finished, and written
- out. That's a deficiency in the back-end. When this is
+ out. That's a deficiency in the back end. When this is
fixed, these initialization functions could all become
inline, with resulting performance improvements. */
tree ssdf_body;
if (!DECL_SAVED_TREE (decl))
continue;
- /* We lie to the back-end, pretending that some functions
+ /* 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
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,
splay_tree_foreach (priority_info_map,
generate_ctor_and_dtor_functions_for_priority,
/*data=*/&locus);
- else
- {
- /* 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)
- generate_ctor_or_dtor_function (/*constructor_p=*/false,
- DEFAULT_INIT_PRIORITY, &locus);
- }
+ else if (c_dialect_objc () && objc_static_init_needed_p ())
+ /* If this is obj-c++ and we need a static init, call
+ generate_ctor_or_dtor_function. */
+ generate_ctor_or_dtor_function (/*constructor_p=*/true,
+ DEFAULT_INIT_PRIORITY, &locus);
/* We're done with the splay-tree now. */
if (priority_info_map)
if (VEC_length (tree, pending_statics) != 0)
{
check_global_declarations (VEC_address (tree, pending_statics),
- VEC_length (tree, pending_statics));
+ VEC_length (tree, pending_statics));
emit_debug_global_declarations (VEC_address (tree, pending_statics),
VEC_length (tree, pending_statics));
}
|| 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_nt_call_list (fn, args);
/* Transform the arguments and add the implicit "this"
parameter. That must be done before the FN is transformed
expr = build_function_call (fn, args);
if (processing_template_decl && expr != error_mark_node)
- return build_min_non_dep (CALL_EXPR, expr, orig_fn, orig_args, NULL_TREE);
+ return build_min_non_dep_call_list (expr, orig_fn, orig_args);
return expr;
}
}
TREE_USED (decl) = 1;
- /* If we don't need a value, then we don't need to synthesize DECL. */
+ if (DECL_CLONED_FUNCTION_P (decl))
+ TREE_USED (DECL_CLONED_FUNCTION (decl)) = 1;
+ /* 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
saved_processing_template_decl = processing_template_decl;
processing_template_decl = 0;
}
-
+
if (processing_template_decl)
- return;
+ return;
if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl)
&& !TREE_ASM_WRITTEN (decl))
template, we now know that we will need to actually do the
instantiation. We check that DECL is not an explicit
instantiation because that is not checked in instantiate_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. Therefore, we always try to defer instantiation. */
- instantiate_decl (decl, /*defer_ok=*/true,
+ instantiate_decl (decl, /*defer_ok=*/true,
/*expl_inst_class_mem_p=*/false);
processing_template_decl = saved_processing_template_decl;
OSDN Git Service
