1 files changed, 43 insertions, 58 deletions
diff --git a/gcc/ada/gcc-interface/decl.c b/gcc/ada/gcc-interface/decl.c
index afef46e..a2af179 100644
--- a/gcc/ada/gcc-interface/decl.c
+++ b/gcc/ada/gcc-interface/decl.c
@@ -676,8 +676,6 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 		       despite having a nominal type with self-referential
 		       size, we can get the size directly from it.  */
 		    if (TREE_CODE (gnu_expr) == COMPONENT_REF
-			&& TREE_CODE (TREE_TYPE (TREE_OPERAND (gnu_expr, 0)))
-			   == RECORD_TYPE
 			&& TYPE_IS_PADDING_P
 			   (TREE_TYPE (TREE_OPERAND (gnu_expr, 0)))
 			&& TREE_CODE (TREE_OPERAND (gnu_expr, 0)) == VAR_DECL
@@ -852,8 +850,6 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	    /* If the renamed object had padding, strip off the reference
 	       to the inner object and reset our type.  */
 	    if ((TREE_CODE (gnu_expr) == COMPONENT_REF
-		 && TREE_CODE (TREE_TYPE (TREE_OPERAND (gnu_expr, 0)))
-		    == RECORD_TYPE
 		 && TYPE_IS_PADDING_P (TREE_TYPE (TREE_OPERAND (gnu_expr, 0))))
 		/* Strip useless conversions around the object.  */
 		|| (TREE_CODE (gnu_expr) == NOP_EXPR
@@ -1018,14 +1014,14 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	    && TREE_CODE (gnu_type) == RECORD_TYPE
 	    && (TYPE_CONTAINS_TEMPLATE_P (gnu_type)
 	        /* Beware that padding might have been introduced above.  */
-		|| (TYPE_IS_PADDING_P (gnu_type)
+		|| (TYPE_PADDING_P (gnu_type)
 		    && TREE_CODE (TREE_TYPE (TYPE_FIELDS (gnu_type)))
 		       == RECORD_TYPE
 		    && TYPE_CONTAINS_TEMPLATE_P
 		       (TREE_TYPE (TYPE_FIELDS (gnu_type))))))
 	  {
 	    tree template_field
-	      = TYPE_IS_PADDING_P (gnu_type)
+	      = TYPE_PADDING_P (gnu_type)
 		? TYPE_FIELDS (TREE_TYPE (TYPE_FIELDS (gnu_type)))
 		: TYPE_FIELDS (gnu_type);
 
@@ -1049,17 +1045,16 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	if (gnu_expr
 	    && TREE_CODE (gnu_type) != UNCONSTRAINED_ARRAY_TYPE
 	    && !CONTAINS_PLACEHOLDER_P (TYPE_SIZE (gnu_type))
-	    && !(TREE_CODE (gnu_type) == RECORD_TYPE
-		 && TYPE_IS_PADDING_P (gnu_type)
-		 && (CONTAINS_PLACEHOLDER_P
-		     (TYPE_SIZE (TREE_TYPE (TYPE_FIELDS (gnu_type)))))))
+	    && !(TYPE_IS_PADDING_P (gnu_type)
+		 && CONTAINS_PLACEHOLDER_P
+		    (TYPE_SIZE (TREE_TYPE (TYPE_FIELDS (gnu_type))))))
 	  gnu_expr = convert (gnu_type, gnu_expr);
 
 	/* If this is a pointer and it does not have an initializing
 	   expression, initialize it to NULL, unless the object is
 	   imported.  */
 	if (definition
-	    && (POINTER_TYPE_P (gnu_type) || TYPE_FAT_POINTER_P (gnu_type))
+	    && (POINTER_TYPE_P (gnu_type) || TYPE_IS_FAT_POINTER_P (gnu_type))
 	    && !Is_Imported (gnat_entity) && !gnu_expr)
 	  gnu_expr = integer_zero_node;
 
@@ -1278,10 +1273,9 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	if (gnu_expr
 	    && TREE_CODE (gnu_type) != UNCONSTRAINED_ARRAY_TYPE
 	    && !CONTAINS_PLACEHOLDER_P (TYPE_SIZE (gnu_type))
-	    && !(TREE_CODE (gnu_type) == RECORD_TYPE
-		 && TYPE_IS_PADDING_P (gnu_type)
-		 && (CONTAINS_PLACEHOLDER_P
-		     (TYPE_SIZE (TREE_TYPE (TYPE_FIELDS (gnu_type)))))))
+	    && !(TYPE_IS_PADDING_P (gnu_type)
+		 && CONTAINS_PLACEHOLDER_P
+		    (TYPE_SIZE (TREE_TYPE (TYPE_FIELDS (gnu_type))))))
 	  gnu_expr = convert (gnu_type, gnu_expr);
 
 	/* If this name is external or there was a name specified, use it,
@@ -1303,8 +1297,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	    && gnu_expr && TREE_CONSTANT (gnu_expr)
 	    && AGGREGATE_TYPE_P (gnu_type)
 	    && host_integerp (TYPE_SIZE_UNIT (gnu_type), 1)
-	    && !(TREE_CODE (gnu_type) == RECORD_TYPE
-		 && TYPE_IS_PADDING_P (gnu_type)
+	    && !(TYPE_IS_PADDING_P (gnu_type)
 		 && !host_integerp (TYPE_SIZE_UNIT
 				    (TREE_TYPE (TYPE_FIELDS (gnu_type))), 1)))
 	  static_p = true;
@@ -1686,7 +1679,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 					 gnu_field_type, gnu_type, 1, 0, 0, 0);
 
 	  finish_record_type (gnu_type, gnu_field, 0, false);
-	  TYPE_IS_PADDING_P (gnu_type) = 1;
+	  TYPE_PADDING_P (gnu_type) = 1;
 
 	  relate_alias_sets (gnu_type, gnu_field_type, ALIAS_SET_COPY);
 	}
@@ -1834,7 +1827,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	/* Do not finalize this record type since the types of its fields
 	   are still incomplete at this point.  */
 	finish_record_type (gnu_fat_type, tem, 0, true);
-	TYPE_IS_FAT_POINTER_P (gnu_fat_type) = 1;
+	TYPE_FAT_POINTER_P (gnu_fat_type) = 1;
 
 	/* Build a reference to the template from a PLACEHOLDER_EXPR that
 	   is the fat pointer.  This will be used to access the individual
@@ -2476,7 +2469,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	      gnu_inner = gnu_type;
 	      while (TREE_CODE (gnu_inner) == RECORD_TYPE
 		     && (TYPE_JUSTIFIED_MODULAR_P (gnu_inner)
-			 || TYPE_IS_PADDING_P (gnu_inner)))
+			 || TYPE_PADDING_P (gnu_inner)))
 		gnu_inner = TREE_TYPE (TYPE_FIELDS (gnu_inner));
 
 	      /* We need to attach the index type to the type we just made so
@@ -2985,8 +2978,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	      copy_and_substitute_in_size (gnu_type, gnu_base_type,
 					   gnu_subst_list);
 
-	      if (TREE_CODE (gnu_base_type) == RECORD_TYPE
-		  && TYPE_IS_PADDING_P (gnu_base_type))
+	      if (TYPE_IS_PADDING_P (gnu_base_type))
 		gnu_unpad_base_type = TREE_TYPE (TYPE_FIELDS (gnu_base_type));
 	      else
 		gnu_unpad_base_type = gnu_base_type;
@@ -3096,7 +3088,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 		      {
 			gnu_size = DECL_SIZE (gnu_old_field);
 			if (TREE_CODE (gnu_field_type) == RECORD_TYPE
-			    && !TYPE_IS_FAT_POINTER_P (gnu_field_type)
+			    && !TYPE_FAT_POINTER_P (gnu_field_type)
 			    && host_integerp (TYPE_SIZE (gnu_field_type), 1))
 			  gnu_field_type
 			    = make_packable_type (gnu_field_type, true);
@@ -3464,7 +3456,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 		/* Make sure we can place this into a register.  */
 		TYPE_ALIGN (gnu_type)
 		  = MIN (BIGGEST_ALIGNMENT, 2 * POINTER_SIZE);
-		TYPE_IS_FAT_POINTER_P (gnu_type) = 1;
+		TYPE_FAT_POINTER_P (gnu_type) = 1;
 
 		/* Do not finalize this record type since the types of
 		   its fields are incomplete.  */
@@ -3598,11 +3590,11 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	if ((! in_main_unit || is_from_limited_with) && made_dummy)
 	  {
 	    tree gnu_old_type
-	      = TYPE_FAT_POINTER_P (gnu_type)
+	      = TYPE_IS_FAT_POINTER_P (gnu_type)
 		? TYPE_UNCONSTRAINED_ARRAY (gnu_type) : TREE_TYPE (gnu_type);
 
 	    if (esize == POINTER_SIZE
-		&& (got_fat_p || TYPE_FAT_POINTER_P (gnu_type)))
+		&& (got_fat_p || TYPE_IS_FAT_POINTER_P (gnu_type)))
 	      gnu_type
 		= build_pointer_type
 		  (TYPE_OBJECT_RECORD_TYPE
@@ -3914,8 +3906,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	/* If the type is a padded type and the underlying type would not
 	   be passed by reference or this function has a foreign convention,
 	   return the underlying type.  */
-	else if (TREE_CODE (gnu_return_type) == RECORD_TYPE
-		 && TYPE_IS_PADDING_P (gnu_return_type)
+	else if (TYPE_IS_PADDING_P (gnu_return_type)
 		 && (!default_pass_by_ref (TREE_TYPE
 					   (TYPE_FIELDS (gnu_return_type)))
 		     || Has_Foreign_Convention (gnat_entity)))
@@ -4053,7 +4044,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 		   between two calls, so they can't be CSE'ed.  The latter
 		   case also handles by-ref parameters.  */
 		if (POINTER_TYPE_P (gnu_param_type)
-		    || TYPE_FAT_POINTER_P (gnu_param_type))
+		    || TYPE_IS_FAT_POINTER_P (gnu_param_type))
 		  const_flag = false;
 	      }
 
@@ -4416,7 +4407,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	      else if ((TREE_CODE (gnu_type) == RECORD_TYPE
 			|| TREE_CODE (gnu_type) == UNION_TYPE
 			|| TREE_CODE (gnu_type) == QUAL_UNION_TYPE)
-		       && !TYPE_IS_FAT_POINTER_P (gnu_type))
+		       && !TYPE_FAT_POINTER_P (gnu_type))
 		size = rm_size (gnu_type);
 	      else
 	        size = TYPE_SIZE (gnu_type);
@@ -4447,8 +4438,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	gnu_type = maybe_pad_type (gnu_type, gnu_size, align, gnat_entity,
 				   false, true, definition, false);
 
-      if (TREE_CODE (gnu_type) == RECORD_TYPE
-	  && TYPE_IS_PADDING_P (gnu_type))
+      if (TYPE_IS_PADDING_P (gnu_type))
 	{
 	  gnu_entity_name = TYPE_NAME (gnu_type);
 	  if (TREE_CODE (gnu_entity_name) == TYPE_DECL)
@@ -4704,8 +4694,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
       tree gnu_low_bound, gnu_high_bound;
 
       /* If this is a padded type, we need to use the underlying type.  */
-      if (TREE_CODE (gnu_scalar_type) == RECORD_TYPE
-	  && TYPE_IS_PADDING_P (gnu_scalar_type))
+      if (TYPE_IS_PADDING_P (gnu_scalar_type))
 	gnu_scalar_type = TREE_TYPE (TYPE_FIELDS (gnu_scalar_type));
 
       /* If this is a floating point type and we haven't set a floating
@@ -4851,7 +4840,7 @@ get_unpadded_type (Entity_Id gnat_entity)
 {
   tree type = gnat_to_gnu_type (gnat_entity);
 
-  if (TREE_CODE (type) == RECORD_TYPE && TYPE_IS_PADDING_P (type))
+  if (TYPE_IS_PADDING_P (type))
     type = TREE_TYPE (TYPE_FIELDS (type));
 
   return type;
@@ -4984,7 +4973,7 @@ gnat_to_gnu_component_type (Entity_Id gnat_array, bool definition,
       && !Has_Aliased_Components (gnat_array)
       && !Strict_Alignment (Component_Type (gnat_array))
       && TREE_CODE (gnu_type) == RECORD_TYPE
-      && !TYPE_IS_FAT_POINTER_P (gnu_type)
+      && !TYPE_FAT_POINTER_P (gnu_type)
       && host_integerp (TYPE_SIZE (gnu_type), 1))
     gnu_type = make_packable_type (gnu_type, false);
 
@@ -5088,8 +5077,7 @@ gnat_to_gnu_param (Entity_Id gnat_param, Mechanism_Type mech,
 
   /* If this is either a foreign function or if the underlying type won't
      be passed by reference, strip off possible padding type.  */
-  if (TREE_CODE (gnu_param_type) == RECORD_TYPE
-      && TYPE_IS_PADDING_P (gnu_param_type))
+  if (TYPE_IS_PADDING_P (gnu_param_type))
     {
       tree unpadded_type = TREE_TYPE (TYPE_FIELDS (gnu_param_type));
 
@@ -5161,7 +5149,7 @@ gnat_to_gnu_param (Entity_Id gnat_param, Mechanism_Type mech,
     }
 
   /* Fat pointers are passed as thin pointers for foreign conventions.  */
-  else if (foreign && TYPE_FAT_POINTER_P (gnu_param_type))
+  else if (foreign && TYPE_IS_FAT_POINTER_P (gnu_param_type))
     gnu_param_type
       = make_type_from_size (gnu_param_type, size_int (POINTER_SIZE), 0);
 
@@ -5462,7 +5450,7 @@ relate_alias_sets (tree gnu_new_type, tree gnu_old_type, enum alias_set_op op)
      see the inner types.  */
   while (TREE_CODE (gnu_old_type) == RECORD_TYPE
 	 && (TYPE_JUSTIFIED_MODULAR_P (gnu_old_type)
-	     || TYPE_IS_PADDING_P (gnu_old_type)))
+	     || TYPE_PADDING_P (gnu_old_type)))
     gnu_old_type = TREE_TYPE (TYPE_FIELDS (gnu_old_type));
 
   /* Unconstrained array types are deemed incomplete and would thus be given
@@ -5928,7 +5916,7 @@ make_packable_type (tree type, bool in_record)
   TYPE_JUSTIFIED_MODULAR_P (new_type) = TYPE_JUSTIFIED_MODULAR_P (type);
   TYPE_CONTAINS_TEMPLATE_P (new_type) = TYPE_CONTAINS_TEMPLATE_P (type);
   if (TREE_CODE (type) == RECORD_TYPE)
-    TYPE_IS_PADDING_P (new_type) = TYPE_IS_PADDING_P (type);
+    TYPE_PADDING_P (new_type) = TYPE_PADDING_P (type);
 
   /* If we are in a record and have a small size, set the alignment to
      try for an integral mode.  Otherwise set it to try for a smaller
@@ -5971,7 +5959,7 @@ make_packable_type (tree type, bool in_record)
       if ((TREE_CODE (new_field_type) == RECORD_TYPE
 	   || TREE_CODE (new_field_type) == UNION_TYPE
 	   || TREE_CODE (new_field_type) == QUAL_UNION_TYPE)
-	  && !TYPE_IS_FAT_POINTER_P (new_field_type)
+	  && !TYPE_FAT_POINTER_P (new_field_type)
 	  && host_integerp (TYPE_SIZE (new_field_type), 1))
 	new_field_type = make_packable_type (new_field_type, true);
 
@@ -5983,7 +5971,7 @@ make_packable_type (tree type, bool in_record)
 	  && (TREE_CODE (new_field_type) == RECORD_TYPE
 	      || TREE_CODE (new_field_type) == UNION_TYPE
 	      || TREE_CODE (new_field_type) == QUAL_UNION_TYPE)
-	  && !TYPE_IS_FAT_POINTER_P (new_field_type)
+	  && !TYPE_FAT_POINTER_P (new_field_type)
 	  && !TYPE_CONTAINS_TEMPLATE_P (new_field_type)
 	  && TYPE_ADA_SIZE (new_field_type))
 	new_size = TYPE_ADA_SIZE (new_field_type);
@@ -6012,8 +6000,7 @@ make_packable_type (tree type, bool in_record)
 
   /* If this is a padding record, we never want to make the size smaller
      than what was specified.  For QUAL_UNION_TYPE, also copy the size.  */
-  if ((TREE_CODE (type) == RECORD_TYPE && TYPE_IS_PADDING_P (type))
-      || TREE_CODE (type) == QUAL_UNION_TYPE)
+  if (TYPE_IS_PADDING_P (type) || TREE_CODE (type) == QUAL_UNION_TYPE)
     {
       TYPE_SIZE (new_type) = TYPE_SIZE (type);
       TYPE_SIZE_UNIT (new_type) = TYPE_SIZE_UNIT (type);
@@ -6066,7 +6053,7 @@ maybe_pad_type (tree type, tree size, unsigned int align,
      off the padding, since we will either be returning the inner type
      or repadding it.  If no size or alignment is specified, use that of
      the original padded type.  */
-  if (TREE_CODE (type) == RECORD_TYPE && TYPE_IS_PADDING_P (type))
+  if (TYPE_IS_PADDING_P (type))
     {
       if ((!size
 	   || operand_equal_p (round_up (size,
@@ -6115,7 +6102,7 @@ maybe_pad_type (tree type, tree size, unsigned int align,
      generate incorrect debugging information.  So make a new record
      type and name.  */
   record = make_node (RECORD_TYPE);
-  TYPE_IS_PADDING_P (record) = 1;
+  TYPE_PADDING_P (record) = 1;
 
   if (Present (gnat_entity))
     TYPE_NAME (record) = create_concat_name (gnat_entity, "PAD");
@@ -6438,7 +6425,7 @@ gnat_to_gnu_field (Entity_Id gnat_field, tree gnu_record_type, int packed,
      from a component clause.  */
 
   if (TREE_CODE (gnu_field_type) == RECORD_TYPE
-      && !TYPE_IS_FAT_POINTER_P (gnu_field_type)
+      && !TYPE_FAT_POINTER_P (gnu_field_type)
       && host_integerp (TYPE_SIZE (gnu_field_type), 1)
       && (packed == 1
 	  || (gnu_size
@@ -6668,8 +6655,7 @@ is_variable_size (tree type)
   if (!TREE_CONSTANT (TYPE_SIZE (type)))
     return true;
 
-  if (TREE_CODE (type) == RECORD_TYPE
-      && TYPE_IS_PADDING_P (type)
+  if (TYPE_IS_PADDING_P (type)
       && !TREE_CONSTANT (DECL_SIZE (TYPE_FIELDS (type))))
     return true;
 
@@ -7218,7 +7204,7 @@ annotate_object (Entity_Id gnat_entity, tree gnu_type, tree size, bool by_ref)
 {
   if (by_ref)
     {
-      if (TYPE_FAT_POINTER_P (gnu_type))
+      if (TYPE_IS_FAT_POINTER_P (gnu_type))
 	gnu_type = TYPE_UNCONSTRAINED_ARRAY (gnu_type);
       else
 	gnu_type = TREE_TYPE (gnu_type);
@@ -7533,7 +7519,7 @@ validate_size (Uint uint_size, tree gnu_type, Entity_Id gnat_object,
 
   /* If this is an access type or a fat pointer, the minimum size is that given
      by the smallest integral mode that's valid for pointers.  */
-  if ((TREE_CODE (gnu_type) == POINTER_TYPE) || TYPE_FAT_POINTER_P (gnu_type))
+  if (TREE_CODE (gnu_type) == POINTER_TYPE || TYPE_IS_FAT_POINTER_P (gnu_type))
     {
       enum machine_mode p_mode;
 
@@ -7627,8 +7613,7 @@ set_rm_size (Uint uint_size, tree gnu_type, Entity_Id gnat_entity)
       || (AGGREGATE_TYPE_P (gnu_type)
 	  && !(TREE_CODE (gnu_type) == ARRAY_TYPE
 	       && TYPE_PACKED_ARRAY_TYPE_P (gnu_type))
-	  && !(TREE_CODE (gnu_type) == RECORD_TYPE
-	       && TYPE_IS_PADDING_P (gnu_type)
+	  && !(TYPE_IS_PADDING_P (gnu_type)
 	       && TREE_CODE (TREE_TYPE (TYPE_FIELDS (gnu_type))) == ARRAY_TYPE
 	       && TYPE_PACKED_ARRAY_TYPE_P (TREE_TYPE (TYPE_FIELDS (gnu_type))))
 	  && tree_int_cst_lt (size, old_size)))
@@ -7651,7 +7636,7 @@ set_rm_size (Uint uint_size, tree gnu_type, Entity_Id gnat_entity)
   else if ((TREE_CODE (gnu_type) == RECORD_TYPE
 	    || TREE_CODE (gnu_type) == UNION_TYPE
 	    || TREE_CODE (gnu_type) == QUAL_UNION_TYPE)
-	   && !TYPE_IS_FAT_POINTER_P (gnu_type))
+	   && !TYPE_FAT_POINTER_P (gnu_type))
     SET_TYPE_ADA_SIZE (gnu_type, size);
 }
 
@@ -7718,7 +7703,7 @@ make_type_from_size (tree type, tree size_tree, bool for_biased)
     case RECORD_TYPE:
       /* Do something if this is a fat pointer, in which case we
 	 may need to return the thin pointer.  */
-      if (TYPE_IS_FAT_POINTER_P (type) && size < POINTER_SIZE * 2)
+      if (TYPE_FAT_POINTER_P (type) && size < POINTER_SIZE * 2)
 	{
 	  enum machine_mode p_mode = mode_for_size (size, MODE_INT, 0);
 	  if (!targetm.valid_pointer_mode (p_mode))
@@ -7733,7 +7718,7 @@ make_type_from_size (tree type, tree size_tree, bool for_biased)
     case POINTER_TYPE:
       /* Only do something if this is a thin pointer, in which case we
 	 may need to return the fat pointer.  */
-      if (TYPE_THIN_POINTER_P (type) && size >= POINTER_SIZE * 2)
+      if (TYPE_IS_THIN_POINTER_P (type) && size >= POINTER_SIZE * 2)
 	return
 	  build_pointer_type (TYPE_UNCONSTRAINED_ARRAY (TREE_TYPE (type)));
       break;
@@ -8384,7 +8369,7 @@ rm_size (tree gnu_type)
   if ((TREE_CODE (gnu_type) == RECORD_TYPE
        || TREE_CODE (gnu_type) == UNION_TYPE
        || TREE_CODE (gnu_type) == QUAL_UNION_TYPE)
-      && !TYPE_IS_FAT_POINTER_P (gnu_type)
+      && !TYPE_FAT_POINTER_P (gnu_type)
       && TYPE_ADA_SIZE (gnu_type))
     return TYPE_ADA_SIZE (gnu_type);