exp_dbug.ads: Adjust type names in comments.

	* exp_dbug.ads: Adjust type names in comments.
	* gcc-interface/decl.c (maybe_pad_type): Remove NAME_TRAILER parameter,
	add new IS_COMPONENT_TYPE parameter.  Adjust.  Remove dead code.
	(gnat_to_gnu_entity): Adjust for above change.
	(gnat_to_gnu_component_type): Likewise.
	(gnat_to_gnu_field): Likewise.
	* gcc-interface/trans.c (call_to_gnu): Likewise.  Do not unnecessarily
	call max_size.
	* gcc-interface/utils.c (finish_record_type): Remove obsolete code.
	* gcc-interface/gigi.h (maybe_pad_type): Adjust prototype.

From-SVN: r152916

4 files changed, 39 insertions, 53 deletions

diff --git a/gcc/ada/gcc-interface/decl.c b/gcc/ada/gcc-interface/decl.c
index f2f0f15..afef46e 100644
--- a/gcc/ada/gcc-interface/decl.c
+++ b/gcc/ada/gcc-interface/decl.c
@@ -633,7 +633,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	    else
 	      gnu_type
 		= maybe_pad_type (gnu_type, NULL_TREE, align, gnat_entity,
-				  "PAD", false, definition, true);
+				  false, false, definition, true);
 	  }
 
 	/* If we are defining the object, see if it has a Size value and
@@ -838,7 +838,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	gnu_object_size = gnu_size ? gnu_size : TYPE_SIZE (gnu_type);
 	if (gnu_size || align > 0)
 	  gnu_type = maybe_pad_type (gnu_type, gnu_size, align, gnat_entity,
-				     "PAD", false, definition,
+				     false, false, definition,
 				     gnu_size ? true : false);
 
 	/* If this is a renaming, avoid as much as possible to create a new
@@ -1017,8 +1017,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	    && !gnu_expr
 	    && TREE_CODE (gnu_type) == RECORD_TYPE
 	    && (TYPE_CONTAINS_TEMPLATE_P (gnu_type)
-	        /* Beware that padding might have been introduced
-		   via maybe_pad_type above.  */
+	        /* Beware that padding might have been introduced above.  */
 		|| (TYPE_IS_PADDING_P (gnu_type)
 		    && TREE_CODE (TREE_TYPE (TYPE_FIELDS (gnu_type)))
 		       == RECORD_TYPE
@@ -4446,7 +4445,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	 us when we make the new TYPE_DECL below.  */
       if (gnu_size || align > 0)
 	gnu_type = maybe_pad_type (gnu_type, gnu_size, align, gnat_entity,
-				   "PAD", true, definition, false);
+				   false, true, definition, false);
 
       if (TREE_CODE (gnu_type) == RECORD_TYPE
 	  && TYPE_IS_PADDING_P (gnu_type))
@@ -5037,7 +5036,7 @@ gnat_to_gnu_component_type (Entity_Id gnat_array, bool definition,
 	orig_type = gnu_type;
 
       gnu_type = maybe_pad_type (gnu_type, gnu_comp_size, 0, gnat_array,
-				 "C_PAD", false, definition, true);
+				 true, false, definition, true);
 
       /* If a padding record was made, declare it now since it will never be
 	 declared otherwise.  This is necessary to ensure that its subtrees
@@ -6046,25 +6045,20 @@ make_packable_type (tree type, bool in_record)
 
 /* Ensure that TYPE has SIZE and ALIGN.  Make and return a new padded type
    if needed.  We have already verified that SIZE and TYPE are large enough.
-
-   GNAT_ENTITY and NAME_TRAILER are used to name the resulting record and
-   to issue a warning.
-
-   IS_USER_TYPE is true if we must complete the original type.
-
-   DEFINITION is true if this type is being defined.
-
-   SAME_RM_SIZE is true if the RM size of the resulting type is to be set
-   to SIZE too; otherwise, it's set to the RM size of the original type.  */
+   GNAT_ENTITY is used to name the resulting record and to issue a warning.
+   IS_COMPONENT_TYPE is true if this is being done for the component type
+   of an array.  IS_USER_TYPE is true if we must complete the original type.
+   DEFINITION is true if this type is being defined.  SAME_RM_SIZE is true
+   if the RM size of the resulting type is to be set to SIZE too; otherwise,
+   it's set to the RM size of the original type.  */
 
 tree
 maybe_pad_type (tree type, tree size, unsigned int align,
-		Entity_Id gnat_entity, const char *name_trailer,
+		Entity_Id gnat_entity, bool is_component_type,
 		bool is_user_type, bool definition, bool same_rm_size)
 {
   tree orig_rm_size = same_rm_size ? NULL_TREE : rm_size (type);
   tree orig_size = TYPE_SIZE (type);
-  unsigned int orig_align = align;
   tree record, field;
 
   /* If TYPE is a padded type, see if it agrees with any size and alignment
@@ -6124,15 +6118,12 @@ maybe_pad_type (tree type, tree size, unsigned int align,
   TYPE_IS_PADDING_P (record) = 1;
 
   if (Present (gnat_entity))
-    TYPE_NAME (record) = create_concat_name (gnat_entity, name_trailer);
+    TYPE_NAME (record) = create_concat_name (gnat_entity, "PAD");
 
   TYPE_VOLATILE (record)
     = Present (gnat_entity) && Treat_As_Volatile (gnat_entity);
 
   TYPE_ALIGN (record) = align;
-  if (orig_align)
-    TYPE_USER_ALIGN (record) = align;
-
   TYPE_SIZE (record) = size ? size : orig_size;
   TYPE_SIZE_UNIT (record)
     = convert (sizetype,
@@ -6256,7 +6247,7 @@ maybe_pad_type (tree type, tree size, unsigned int align,
 	    post_error_ne_tree ("{^ }bits of & unused?",
 				gnat_error_node, gnat_entity,
 				size_diffop (size, orig_size));
-	  else if (name_trailer[0] == 'C')
+	  else if (is_component_type)
 	    post_error_ne_tree ("component of& padded{ by ^ bits}?",
 				gnat_entity, gnat_entity,
 				size_diffop (size, orig_size));
@@ -6634,7 +6625,7 @@ gnat_to_gnu_field (Entity_Id gnat_field, tree gnu_record_type, int packed,
 
       orig_field_type = gnu_field_type;
       gnu_field_type = maybe_pad_type (gnu_field_type, gnu_size, 0, gnat_field,
-				       "PAD", false, definition, true);
+				       false, false, definition, true);
 
       /* If a padding record was made, declare it now since it will never be
 	 declared otherwise.  This is necessary to ensure that its subtrees
diff --git a/gcc/ada/gcc-interface/gigi.h b/gcc/ada/gcc-interface/gigi.h
index ea1a65d..f376b22 100644
--- a/gcc/ada/gcc-interface/gigi.h
+++ b/gcc/ada/gcc-interface/gigi.h
@@ -124,21 +124,16 @@ extern tree make_aligning_type (tree type, unsigned int align, tree size,
 
 /* Ensure that TYPE has SIZE and ALIGN.  Make and return a new padded type
    if needed.  We have already verified that SIZE and TYPE are large enough.
-
-   GNAT_ENTITY and NAME_TRAILER are used to name the resulting record and
-   to issue a warning.
-
-   IS_USER_TYPE is true if we must be sure we complete the original type.
-
-   DEFINITION is true if this type is being defined.
-
-   SAME_RM_SIZE is true if the RM_Size of the resulting type is to be
-   set to its TYPE_SIZE; otherwise, it's set to the RM_Size of the original
-   type.  */
+   GNAT_ENTITY is used to name the resulting record and to issue a warning.
+   IS_COMPONENT_TYPE is true if this is being done for the component type
+   of an array.  IS_USER_TYPE is true if we must complete the original type.
+   DEFINITION is true if this type is being defined.  SAME_RM_SIZE is true
+   if the RM size of the resulting type is to be set to SIZE too; otherwise,
+   it's set to the RM size of the original type.  */
 extern tree maybe_pad_type (tree type, tree size, unsigned int align,
-                            Entity_Id gnat_entity, const char *name_trailer,
+			    Entity_Id gnat_entity, bool is_component_type,
 			    bool is_user_type, bool definition,
-                            bool same_rm_size);
+			    bool same_rm_size);
 
 /* Given a GNU tree and a GNAT list of choices, generate an expression to test
    the value passed against the list of choices.  */
diff --git a/gcc/ada/gcc-interface/trans.c b/gcc/ada/gcc-interface/trans.c
index d94d1f4..74aa2b6 100644
--- a/gcc/ada/gcc-interface/trans.c
+++ b/gcc/ada/gcc-interface/trans.c
@@ -2423,22 +2423,27 @@ call_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, tree gnu_target)
       }
     }
 
-  /* If we are calling by supplying a pointer to a target, set up that
-     pointer as the first argument.  Use GNU_TARGET if one was passed;
-     otherwise, make a target by building a variable of the maximum size
-     of the type.  */
+  /* If we are calling by supplying a pointer to a target, set up that pointer
+     as the first argument.  Use GNU_TARGET if one was passed; otherwise, make
+     a target by building a variable and use the maximum size of the type if
+     it has self-referential size.  */
   if (TYPE_RETURNS_BY_TARGET_PTR_P (gnu_subprog_type))
     {
-      tree gnu_real_ret_type
+      tree gnu_ret_type
 	= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (gnu_subprog_type)));
 
       if (!gnu_target)
 	{
-	  tree gnu_obj_type
-	    = maybe_pad_type (gnu_real_ret_type,
-			      max_size (TYPE_SIZE (gnu_real_ret_type), true),
-			      0, Etype (Name (gnat_node)), "PAD", false,
-			      false, false);
+	  tree gnu_obj_type;
+
+	  if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (gnu_ret_type)))
+	    gnu_obj_type
+	      = maybe_pad_type (gnu_ret_type,
+				max_size (TYPE_SIZE (gnu_ret_type), true),
+				0, Etype (Name (gnat_node)), false, false,
+				false, true);
+	  else
+	    gnu_obj_type = gnu_ret_type;
 
 	  /* ??? We may be about to create a static temporary if we happen to
 	     be at the global binding level.  That's a regression from what
@@ -2454,7 +2459,7 @@ call_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, tree gnu_target)
       gnu_actual_list
 	= tree_cons (NULL_TREE,
 		     build_unary_op (ADDR_EXPR, NULL_TREE,
-				     unchecked_convert (gnu_real_ret_type,
+				     unchecked_convert (gnu_ret_type,
 							gnu_target,
 							false)),
 		     NULL_TREE);
diff --git a/gcc/ada/gcc-interface/utils.c b/gcc/ada/gcc-interface/utils.c
index 7acb2ce..f1a4b00 100644
--- a/gcc/ada/gcc-interface/utils.c
+++ b/gcc/ada/gcc-interface/utils.c
@@ -739,11 +739,6 @@ finish_record_type (tree record_type, tree fieldlist, int rep_level,
   if (code == QUAL_UNION_TYPE)
     nreverse (fieldlist);
 
-  /* If the type is discriminated, it can be used to access all its
-     constrained subtypes, so force structural equality checks.  */
-  if (CONTAINS_PLACEHOLDER_P (size))
-    SET_TYPE_STRUCTURAL_EQUALITY (record_type);
-
   if (rep_level < 2)
     {
       /* If this is a padding record, we never want to make the size smaller