2012-03-07 Eric Botcazou <ebotcazou@adacore.com>
+ * gcc-interface/gigi.h (rest_of_type_decl_compilation): Delete.
+ * gcc-interface/decl.c (defer_finalize_level): Likewise.
+ (defer_finalize_list): Likewise.
+ (gnat_to_gnu_entity): Delete references to above variables and do not
+ call rest_of_type_decl_compilation.
+ (rest_of_type_decl_compilation): Delete.
+ (rest_of_type_decl_compilation_no_defer): Likewise.
+ * gcc-interface/utils.c (rest_of_record_type_compilation): Do not call
+ rest_of_type_decl_compilation.
+ (create_type_decl): Likewise.
+ (update_pointer_to): Likewise.
+
+2012-03-07 Eric Botcazou <ebotcazou@adacore.com>
+
* gcc-interface/trans.c (Identifier_to_gnu): Don't unshare initializer.
(add_decl_expr): Mark external DECLs as used.
* gcc-interface/utils.c (convert) <CONSTRUCTOR>: Copy the vector.
end of the spec. */
static struct incomplete *defer_limited_with;
-/* These variables are used to defer finalizing types. The element of the
- list is the TYPE_DECL associated with the type. */
-static int defer_finalize_level = 0;
-static VEC (tree,heap) *defer_finalize_list;
-
typedef struct subst_pair_d {
tree discriminant;
tree replacement;
static tree create_variant_part_from (tree, VEC(variant_desc,heap) *, tree,
tree, VEC(subst_pair,heap) *);
static void copy_and_substitute_in_size (tree, tree, VEC(subst_pair,heap) *);
-static void rest_of_type_decl_compilation_no_defer (tree);
/* The relevant constituents of a subprogram binding to a GCC builtin. Used
to pass around calls performing profile compatibility checks. */
care of those situations. */
if (defer_incomplete_level == 0 && !is_from_limited_with)
{
- defer_finalize_level++;
update_pointer_to (TYPE_MAIN_VARIANT (gnu_old_desig_type),
gnat_to_gnu_type (gnat_desig_equiv));
- defer_finalize_level--;
}
else
{
/* Enumeration types have specific RM bounds. */
SET_TYPE_RM_MIN_VALUE (gnu_scalar_type, gnu_low_bound);
SET_TYPE_RM_MAX_VALUE (gnu_scalar_type, gnu_high_bound);
-
- /* Write full debugging information. */
- rest_of_type_decl_compilation (gnu_decl);
}
-
else
{
/* Floating-point types don't have specific RM bounds. */
p = defer_incomplete_list;
defer_incomplete_list = NULL;
- /* For finalization, however, all types must be complete so we
- cannot do the same because deferred incomplete types may end up
- referencing each other. Process them all recursively first. */
- defer_finalize_level++;
-
for (; p; p = next)
{
next = p->next;
gnat_to_gnu_type (p->full_type));
free (p);
}
-
- defer_finalize_level--;
- }
-
- /* If all the deferred incomplete types have been processed, we can proceed
- with the finalization of the deferred types. */
- if (defer_incomplete_level == 0
- && defer_finalize_level == 0
- && defer_finalize_list)
- {
- unsigned int i;
- tree t;
-
- FOR_EACH_VEC_ELT (tree, defer_finalize_list, i, t)
- rest_of_type_decl_compilation_no_defer (t);
-
- VEC_free (tree, heap, defer_finalize_list);
}
/* If we are not defining this type, see if it's on one of the lists of
create_subprog_decl (gnu_entity_name, gnu_ext_name, void_ftype, NULL_TREE,
false, true, true, true, attr_list, gnat_entity);
}
-\f
-/* Wrap up compilation of DECL, a TYPE_DECL, possibly deferring it.
- Every TYPE_DECL generated for a type definition must be passed
- to this function once everything else has been done for it. */
-
-void
-rest_of_type_decl_compilation (tree decl)
-{
- /* We need to defer finalizing the type if incomplete types
- are being deferred or if they are being processed. */
- if (defer_incomplete_level != 0 || defer_finalize_level != 0)
- VEC_safe_push (tree, heap, defer_finalize_list, decl);
- else
- rest_of_type_decl_compilation_no_defer (decl);
-}
-
-/* Same as above but without deferring the compilation. This
- function should not be invoked directly on a TYPE_DECL. */
-
-static void
-rest_of_type_decl_compilation_no_defer (tree decl)
-{
- const int toplev = global_bindings_p ();
- tree t = TREE_TYPE (decl);
-
- rest_of_decl_compilation (decl, toplev, 0);
-
- /* Now process all the variants. This is needed for STABS. */
- for (t = TYPE_MAIN_VARIANT (t); t; t = TYPE_NEXT_VARIANT (t))
- {
- if (t == TREE_TYPE (decl))
- continue;
-
- if (!TYPE_STUB_DECL (t))
- TYPE_STUB_DECL (t) = create_type_stub_decl (DECL_NAME (decl), t);
-
- rest_of_type_compilation (t, toplev);
- }
-}
/* Finalize the processing of From_With_Type incomplete types. */
TYPE_FIELDS (new_record_type)
= nreverse (TYPE_FIELDS (new_record_type));
- /* We used to explicitly invoke rest_of_type_decl_compilation on the
- parallel type for the sake of STABS. We don't do it any more, so
- as to ensure that the parallel type be processed after the type
- by the debug back-end and, thus, prevent it from interfering with
- the processing of a recursive type. */
add_parallel_type (TYPE_STUB_DECL (record_type), new_record_type);
}
-
- rest_of_type_decl_compilation (TYPE_STUB_DECL (record_type));
}
/* Append PARALLEL_TYPE on the chain of parallel types for decl. */
if (!named)
TYPE_STUB_DECL (type) = type_decl;
- /* Pass the type declaration to the debug back-end unless this is an
- UNCONSTRAINED_ARRAY_TYPE that the back-end does not support, or a
- type for which debugging information was not requested, or else an
- ENUMERAL_TYPE or RECORD_TYPE (except for fat pointers) which are
- handled separately. And do not pass dummy types either. */
+ /* Do not generate debug info for UNCONSTRAINED_ARRAY_TYPE that the
+ back-end doesn't support, and for others if we don't need to. */
if (code == UNCONSTRAINED_ARRAY_TYPE || !debug_info_p)
DECL_IGNORED_P (type_decl) = 1;
- else if (code != ENUMERAL_TYPE
- && (code != RECORD_TYPE || TYPE_FAT_POINTER_P (type))
- && !((code == POINTER_TYPE || code == REFERENCE_TYPE)
- && TYPE_IS_DUMMY_P (TREE_TYPE (type)))
- && !(code == RECORD_TYPE
- && TYPE_IS_DUMMY_P
- (TREE_TYPE (TREE_TYPE (TYPE_FIELDS (type))))))
- rest_of_type_decl_compilation (type_decl);
return type_decl;
}
TREE_TYPE (TREE_OPERAND (TYPE_NULL_BOUNDS (t), 0)) = new_type;
}
- /* If we have adjusted named types, finalize them. This is necessary
- since we had forced a DWARF typedef for them in gnat_pushdecl. */
- for (ptr = TYPE_POINTER_TO (old_type); ptr; ptr = TYPE_NEXT_PTR_TO (ptr))
- if (TYPE_NAME (ptr) && TREE_CODE (TYPE_NAME (ptr)) == TYPE_DECL)
- rest_of_type_decl_compilation (TYPE_NAME (ptr));
-
/* Chain REF and its variants at the end. */
new_ref = TYPE_REFERENCE_TO (new_type);
if (new_ref)
projects / platform / upstream / gcc.git / commitdiff