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 *);
}
\f
/* Walks through the namespace- or function-scope anonymous union
- OBJECT, with the indicated TYPE, building appropriate ALIAS_DECLs.
+ OBJECT, with the indicated TYPE, building appropriate VAR_DECLs.
Returns one of the fields for use in the mangled name. */
static tree
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)))
{
/* 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 = 0;
- tree cond;
tree guard;
- tree init_cond;
- priority_info pi;
- /* Figure out the priority for this declaration. */
- if (DECL_HAS_INIT_PRIORITY_P (decl))
- 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
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_cst (NULL_TREE, priority));
- 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;
/* We need a guard if this is an object with external linkage that
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;
/*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 (guard_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);
+ tree node, init_if_stmt, cond;
- /* Perform the initialization. */
- if (init)
- finish_expr_stmt (init);
-
- /* 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));
-
- /* 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. */
- gcc_assert (!flag_use_cxa_atexit);
-
- /* 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
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;
if (!DECL_SAVED_TREE (decl))
continue;
- import_export_decl (decl);
-
/* 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))
{
if (/* Check online inline functions that were actually used. */
TREE_USED (decl) && DECL_DECLARED_INLINE_P (decl)
- /* But not defined. */
- && DECL_REALLY_EXTERN (decl)
- /* If we decided to emit this function in another
- translation unit, the fact that the definition was
- missing here likely indicates only that the repository
- decided to place the function elsewhere. With -Winline,
- we will still warn if we could not inline the
- function. */
- && !flag_use_repository
+ /* 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))
{
warning (0, "inline function %q+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;
+ /* Avoid a duplicate warning from check_global_declaration_1. */
+ TREE_NO_WARNING (decl) = 1;
}
}
etc., and emit debugging information. */
walk_namespaces (wrapup_globals_for_namespace, /*data=*/&reconsider);
if (VEC_length (tree, pending_statics) != 0)
- check_global_declarations (VEC_address (tree, pending_statics),
- VEC_length (tree, pending_statics));
+ {
+ 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 ();
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 (processing_template_decl)
- {
- if (TREE_CODE (decl) == VAR_DECL
- && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl)
- && DECL_CLASS_SCOPE_P (decl)
- && !dependent_type_p (DECL_CONTEXT (decl)))
- {
- /* Pretend that we are not in a template so that the
- initializer for the static data member will be full
- simplified. */
- saved_processing_template_decl = processing_template_decl;
- processing_template_decl = 0;
- }
- else
- return;
+ 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))
OSDN Git Service
