From: Eric Botcazou Date: Wed, 7 Mar 2012 20:08:17 +0000 (+0000) Subject: gigi.h (rest_of_type_decl_compilation): Delete. X-Git-Tag: upstream/12.2.0~77531 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=50741117df35bb9ef6bd36718f12b2b20607f059;p=platform%2Fupstream%2Fgcc.git gigi.h (rest_of_type_decl_compilation): Delete. * 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. From-SVN: r185075 --- diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog index 65fc50a..636d6cc 100644 --- a/gcc/ada/ChangeLog +++ b/gcc/ada/ChangeLog @@ -1,5 +1,19 @@ 2012-03-07 Eric Botcazou + * 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 + * gcc-interface/trans.c (Identifier_to_gnu): Don't unshare initializer. (add_decl_expr): Mark external DECLs as used. * gcc-interface/utils.c (convert) : Copy the vector. diff --git a/gcc/ada/gcc-interface/decl.c b/gcc/ada/gcc-interface/decl.c index 5b6d2f7..0172789 100644 --- a/gcc/ada/gcc-interface/decl.c +++ b/gcc/ada/gcc-interface/decl.c @@ -97,11 +97,6 @@ static struct incomplete *defer_incomplete_list; 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; @@ -181,7 +176,6 @@ static tree get_rep_part (tree); 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. */ @@ -3880,10 +3874,8 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition) 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 { @@ -5112,11 +5104,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition) /* 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. */ @@ -5139,11 +5127,6 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition) 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; @@ -5153,23 +5136,6 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition) 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 @@ -5290,45 +5256,6 @@ get_minimal_subprog_decl (Entity_Id gnat_entity) create_subprog_decl (gnu_entity_name, gnu_ext_name, void_ftype, NULL_TREE, false, true, true, true, attr_list, gnat_entity); } - -/* 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. */ diff --git a/gcc/ada/gcc-interface/gigi.h b/gcc/ada/gcc-interface/gigi.h index 00f6465..5e6495a 100644 --- a/gcc/ada/gcc-interface/gigi.h +++ b/gcc/ada/gcc-interface/gigi.h @@ -51,9 +51,6 @@ extern tree gnat_to_gnu_field_decl (Entity_Id gnat_entity); the GCC type corresponding to that entity. */ extern tree gnat_to_gnu_type (Entity_Id gnat_entity); -/* Wrap up compilation of T, a TYPE_DECL, possibly deferring it. */ -extern void rest_of_type_decl_compilation (tree t); - /* Start a new statement group chained to the previous group. */ extern void start_stmt_group (void); diff --git a/gcc/ada/gcc-interface/utils.c b/gcc/ada/gcc-interface/utils.c index f9214fb..a2191c0 100644 --- a/gcc/ada/gcc-interface/utils.c +++ b/gcc/ada/gcc-interface/utils.c @@ -1056,15 +1056,8 @@ rest_of_record_type_compilation (tree record_type) 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. */ @@ -1354,21 +1347,10 @@ create_type_decl (tree type_name, tree type, struct attrib *attr_list, 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; } @@ -3531,12 +3513,6 @@ update_pointer_to (tree old_type, tree new_type) 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)