dbxout.c (dbxout_range_type): Add LOW and HIGH parameters.

	* dbxout.c (dbxout_range_type): Add LOW and HIGH parameters.  Use them
	for bounds.
	(print_int_cst_bounds_in_octal_p): Likewise.
	(dbxout_type): Adjust calls to above functions.  Be prepared to deal
	with subtypes.
	* dwarf2out.c (base_type_die): Likewise.
	(is_subrange_type): Delete.
	(subrange_type_die): Add LOW and HIGH parameters.  Use them for bounds.
	(modified_type_die): Call subrange_type_for_debug_p on subtypes.
	* fold-const.c (fold_truth_not_expr) <CONVERT_EXPR>: Do not strip it if
	the destination type is boolean.
	(build_range_check): Do not special-case subtypes.
	(fold_sign_changed_comparison): Likewise.
	(fold_unary): Likewise.
	* langhooks-def.h (LANG_HOOKS_GET_SUBRANGE_BOUNDS): Define.
	(LANG_HOOKS_FOR_TYPES_INITIALIZER): Add LANG_HOOKS_GET_SUBRANGE_BOUNDS.
	* langhooks.h (lang_hooks_for_types): Add get_subrange_bounds.
	* tree.c (subrange_type_for_debug_p): New predicate based on the former
	is_subrange_type.
	* tree.h (subrange_type_for_debug_p): Declare.
	* tree-chrec.c (avoid_arithmetics_in_type_p): Delete.
	(convert_affine_scev): Remove call to above function.
	(chrec_convert_aggressive): Likewise.
	* tree-ssa.c (useless_type_conversion_p_1): Do not specifically return
	false for conversions involving subtypes.
	* tree-vrp.c (vrp_val_max): Do not special-case subtypes.
	(vrp_val_min): Likewise.
	(needs_overflow_infinity): Likewise.
	(extract_range_from_unary_expr): Likewise.
ada/
	* gcc-interface/ada-tree.h (TYPE_GCC_MIN_VALUE, TYPE_GCC_MAX_VALUE):
	New macros.
	(TYPE_RM_VALUES): Likewise.
	(TYPE_RM_SIZE): Rewrite in terms of TYPE_RM_VALUES.
	(SET_TYPE_RM_SIZE): New macro.
	(TYPE_RM_MIN_VALUE, TYPE_RM_MAX_VALUE): Likewise.
	(SET_TYPE_RM_SIZE, SET_TYPE_RM_MAX_VALUE): Likewise.
	(TYPE_MIN_VALUE, TYPE_MAX_VALUE): Redefine.
	* gcc-interface/gigi.h (create_range_type): Declare.
	* gcc-interface/decl.c (gnat_to_gnu_entity) <E_Modular_Integer_Type>
	Use SET_TYPE_RM_MAX_VALUE to set the upper bound on the UMT type.
	<E_Signed_Integer_Subtype>: Build a regular integer type first and
	then set the RM bounds.  Use SET_TYPE_RM_SIZE to set the RM size.
	<E_Floating_Point_Subtype>: Build a regular floating-point type first
	and then set the RM bounds.
	<E_Array_Type>: Use create_range_type instead of build_range_type.
	<E_Array_Subtype>: Build a regular integer type first and then set
	the RM bounds for the extra subtype.
	<E_String_Literal_Subtype>: Use create_range_type instead of
	build_range_type.
	<all>: Set the RM bounds for enumeration types and the GCC bounds for
	floating-point types.
	(set_rm_size): Use SET_TYPE_RM_SIZE to set the RM size.
	(make_type_from_size) <INTEGER_TYPE>: Use SET_TYPE_RM_{MIN,MAX}_VALUE
	to set the bounds.  Use SET_TYPE_RM_SIZE to set the RM size.
	(substitute_in_type) <INTEGER_TYPE>: Deal with GCC bounds for domain
	types and with RM bounds for subtypes.
	* gcc-interface/misc.c (LANG_HOOKS_GET_SUBRANGE_BOUNDS): Define.
	(gnat_print_type) <REAL_TYPE>: New case.
	<ENUMERAL_TYPE>: Fall through to above case.
	(gnat_get_subrange_bounds): New function.
	* gcc-interface/trans.c (add_decl_expr): Mark the trees rooted as
	TYPE_RM_MIN_VALUE and TYPE_RM_MAX_VALUE, if any.
	* gcc-interface/utils.c (gnat_init_decl_processing): Use precision 8
	for booleans.  Adjust and use SET_TYPE_RM_SIZE to set the RM size.
	(create_range_type): New function.
	(create_param_decl): Build a regular integer type first and then set
	the RM bounds for the extra subtype.
	(unchecked_convert): Remove kludge for 'Valid.
	* gcc-interface/utils2.c (build_binary_op) <ARRAY_RANGE_REF>: Convert
	the index to sizetype instead of TYPE_DOMAIN.

From-SVN: r147563

1 files changed, 113 insertions, 87 deletions

diff --git a/gcc/ada/gcc-interface/decl.c b/gcc/ada/gcc-interface/decl.c
index 6feadbd..46215da 100644
--- a/gcc/ada/gcc-interface/decl.c
+++ b/gcc/ada/gcc-interface/decl.c
@@ -1503,7 +1503,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	    && !tree_int_cst_equal (gnu_high, TYPE_MAX_VALUE (gnu_type)))
 	  {
 	    tree gnu_subtype = make_unsigned_type (esize);
-	    TYPE_MAX_VALUE (gnu_subtype) = gnu_high;
+	    SET_TYPE_RM_MAX_VALUE (gnu_subtype, gnu_high);
 	    TREE_TYPE (gnu_subtype) = gnu_type;
 	    TYPE_EXTRA_SUBTYPE_P (gnu_subtype) = 1;
 	    TYPE_NAME (gnu_type) = create_concat_name (gnat_entity, "UMT");
@@ -1519,7 +1519,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
     case E_Decimal_Fixed_Point_Subtype:
 
       /* For integral subtypes, we make a new INTEGER_TYPE.  Note that we do
-	 not want to call build_range_type since we would like each subtype
+	 not want to call create_range_type since we would like each subtype
 	 node to be distinct.  ??? Historically this was in preparation for
 	 when memory aliasing is implemented, but that's obsolete now given
 	 the call to relate_alias_sets below.
@@ -1539,39 +1539,37 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	      || !Compile_Time_Known_Value (Type_High_Bound (gnat_entity))))
 	gnat_to_gnu_entity (Ancestor_Subtype (gnat_entity), gnu_expr, 0);
 
-      gnu_type = make_node (INTEGER_TYPE);
-      TREE_TYPE (gnu_type) = get_unpadded_type (Etype (gnat_entity));
-
-      /* This should be an unsigned type if the base type is unsigned or
-	 if the lower bound is constant and non-negative or if the type
-	 is biased.  */
-      TYPE_UNSIGNED (gnu_type) = (Is_Unsigned_Type (Etype (gnat_entity))
-				  || Is_Unsigned_Type (gnat_entity)
-				  || Has_Biased_Representation (gnat_entity));
-
-      /* Set the precision to the Esize except for bit-packed arrays and
-	 subtypes of Standard.Boolean.  */
+      /* Set the precision to the Esize except for bit-packed arrays.  */
       if (Is_Packed_Array_Type (gnat_entity)
 	  && Is_Bit_Packed_Array (Original_Array_Type (gnat_entity)))
 	esize = UI_To_Int (RM_Size (gnat_entity));
-      else if (Is_Boolean_Type (gnat_entity))
-	esize = 1;
-
-      TYPE_PRECISION (gnu_type) = esize;
 
-      TYPE_MIN_VALUE (gnu_type)
-	= convert (TREE_TYPE (gnu_type),
-		   elaborate_expression (Type_Low_Bound (gnat_entity),
-					 gnat_entity, get_identifier ("L"),
-					 definition, true,
-					 Needs_Debug_Info (gnat_entity)));
+      /* This should be an unsigned type if the base type is unsigned or
+	 if the lower bound is constant and non-negative or if the type
+	 is biased.  */
+      if (Is_Unsigned_Type (Etype (gnat_entity))
+	  || Is_Unsigned_Type (gnat_entity)
+	  || Has_Biased_Representation (gnat_entity))
+	gnu_type = make_unsigned_type (esize);
+      else
+	gnu_type = make_signed_type (esize);
+      TREE_TYPE (gnu_type) = get_unpadded_type (Etype (gnat_entity));
 
-      TYPE_MAX_VALUE (gnu_type)
-	= convert (TREE_TYPE (gnu_type),
-		   elaborate_expression (Type_High_Bound (gnat_entity),
-					 gnat_entity, get_identifier ("U"),
-					 definition, true,
-					 Needs_Debug_Info (gnat_entity)));
+      SET_TYPE_RM_MIN_VALUE
+	(gnu_type,
+	 convert (TREE_TYPE (gnu_type),
+		  elaborate_expression (Type_Low_Bound (gnat_entity),
+					gnat_entity, get_identifier ("L"),
+					definition, true,
+					Needs_Debug_Info (gnat_entity))));
+
+      SET_TYPE_RM_MAX_VALUE
+	(gnu_type,
+	 convert (TREE_TYPE (gnu_type),
+		  elaborate_expression (Type_High_Bound (gnat_entity),
+					gnat_entity, get_identifier ("U"),
+					definition, true,
+					Needs_Debug_Info (gnat_entity))));
 
       /* One of the above calls might have caused us to be elaborated,
 	 so don't blow up if so.  */
@@ -1584,8 +1582,6 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
       TYPE_BIASED_REPRESENTATION_P (gnu_type)
 	= Has_Biased_Representation (gnat_entity);
 
-      layout_type (gnu_type);
-
       /* Attach the TYPE_STUB_DECL in case we have a parallel type.  */
       TYPE_STUB_DECL (gnu_type)
 	= create_type_stub_decl (gnu_entity_name, gnu_type);
@@ -1616,8 +1612,8 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	  tree gnu_field_type, gnu_field;
 
 	  /* Set the RM size before wrapping up the type.  */
-	  TYPE_RM_SIZE (gnu_type)
-	    = UI_To_gnu (RM_Size (gnat_entity), bitsizetype);
+	  SET_TYPE_RM_SIZE (gnu_type,
+			    UI_To_gnu (RM_Size (gnat_entity), bitsizetype));
 	  TYPE_PACKED_ARRAY_TYPE_P (gnu_type) = 1;
 	  gnu_field_type = gnu_type;
 
@@ -1669,8 +1665,8 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	  tree gnu_field_type, gnu_field;
 
 	  /* Set the RM size before wrapping up the type.  */
-	  TYPE_RM_SIZE (gnu_type)
-	    = UI_To_gnu (RM_Size (gnat_entity), bitsizetype);
+	  SET_TYPE_RM_SIZE (gnu_type,
+			    UI_To_gnu (RM_Size (gnat_entity), bitsizetype));
 	  gnu_field_type = gnu_type;
 
 	  gnu_type = make_node (RECORD_TYPE);
@@ -1741,20 +1737,27 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	gnu_type = make_node (REAL_TYPE);
 	TREE_TYPE (gnu_type) = get_unpadded_type (Etype (gnat_entity));
 	TYPE_PRECISION (gnu_type) = fp_size_to_prec (esize);
+	TYPE_GCC_MIN_VALUE (gnu_type)
+	  = TYPE_GCC_MIN_VALUE (TREE_TYPE (gnu_type));
+	TYPE_GCC_MAX_VALUE (gnu_type)
+	  = TYPE_GCC_MAX_VALUE (TREE_TYPE (gnu_type));
+	layout_type (gnu_type);
 
-	TYPE_MIN_VALUE (gnu_type)
-	  = convert (TREE_TYPE (gnu_type),
-		     elaborate_expression (Type_Low_Bound (gnat_entity),
-					   gnat_entity, get_identifier ("L"),
-					   definition, true,
-					   Needs_Debug_Info (gnat_entity)));
-
-	TYPE_MAX_VALUE (gnu_type)
-	  = convert (TREE_TYPE (gnu_type),
-		     elaborate_expression (Type_High_Bound (gnat_entity),
-					   gnat_entity, get_identifier ("U"),
-					   definition, true,
-					   Needs_Debug_Info (gnat_entity)));
+	SET_TYPE_RM_MIN_VALUE
+	  (gnu_type,
+	   convert (TREE_TYPE (gnu_type),
+		    elaborate_expression (Type_Low_Bound (gnat_entity),
+					  gnat_entity, get_identifier ("L"),
+					  definition, true,
+					  Needs_Debug_Info (gnat_entity))));
+
+	SET_TYPE_RM_MAX_VALUE
+	  (gnu_type,
+	   convert (TREE_TYPE (gnu_type),
+		    elaborate_expression (Type_High_Bound (gnat_entity),
+					  gnat_entity, get_identifier ("U"),
+					  definition, true,
+					  Needs_Debug_Info (gnat_entity))));
 
 	/* One of the above calls might have caused us to be elaborated,
 	   so don't blow up if so.  */
@@ -1764,8 +1767,6 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	    break;
 	  }
 
-	layout_type (gnu_type);
-
 	/* Inherit our alias set from what we're a subtype of, as for
 	   integer subtypes.  */
 	relate_alias_sets (gnu_type, TREE_TYPE (gnu_type), ALIAS_SET_COPY);
@@ -1899,8 +1900,8 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	    gnu_index_types[index]
 	      = create_index_type (convert (sizetype, gnu_min),
 				   convert (sizetype, gnu_max),
-				   build_range_type (gnu_ind_subtype,
-						     gnu_min, gnu_max),
+				   create_range_type (gnu_ind_subtype,
+						      gnu_min, gnu_max),
 				   gnat_entity);
 	    /* Update the maximum size of the array, in elements.  */
 	    gnu_max_size
@@ -2585,19 +2586,14 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 		     subtype if necessary.  */
 		  if (TYPE_MODULAR_P (gnu_inner_type))
 		    {
-		      tree gnu_subtype = make_node (INTEGER_TYPE);
+		      tree gnu_subtype
+			= make_unsigned_type (TYPE_PRECISION (gnu_inner_type));
 		      TREE_TYPE (gnu_subtype) = gnu_inner_type;
 		      TYPE_EXTRA_SUBTYPE_P (gnu_subtype) = 1;
-
-		      TYPE_UNSIGNED (gnu_subtype) = 1;
-		      TYPE_PRECISION (gnu_subtype)
-			= TYPE_PRECISION (gnu_inner_type);
-		      TYPE_MIN_VALUE (gnu_subtype)
-			= TYPE_MIN_VALUE (gnu_inner_type);
-		      TYPE_MAX_VALUE (gnu_subtype)
-			= TYPE_MAX_VALUE (gnu_inner_type);
-		      layout_type (gnu_subtype);
-
+		      SET_TYPE_RM_MIN_VALUE (gnu_subtype,
+					     TYPE_MIN_VALUE (gnu_inner_type));
+		      SET_TYPE_RM_MAX_VALUE (gnu_subtype,
+					     TYPE_MAX_VALUE (gnu_inner_type));
 		      gnu_inner_type = gnu_subtype;
 		    }
 
@@ -2665,9 +2661,9 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
 	tree gnu_index_type
 	  = create_index_type (convert (sizetype, gnu_lower_bound),
 			       convert (sizetype, gnu_upper_bound),
-			       build_range_type (gnu_string_index_type,
-						 gnu_lower_bound,
-						 gnu_upper_bound),
+			       create_range_type (gnu_string_index_type,
+						  gnu_lower_bound,
+						  gnu_upper_bound),
 			       gnat_entity);
 
 	gnu_type
@@ -4743,6 +4739,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
       || (kind == E_Floating_Point_Type && !Vax_Float (gnat_entity)))
     {
       tree gnu_scalar_type = gnu_type;
+      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
@@ -4754,19 +4751,27 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
       if (!longest_float_type_node && kind == E_Floating_Point_Type)
 	longest_float_type_node = gnu_scalar_type;
 
-      TYPE_MIN_VALUE (gnu_scalar_type)
-	= gnat_to_gnu (Type_Low_Bound (gnat_entity));
-      TYPE_MAX_VALUE (gnu_scalar_type)
-	= gnat_to_gnu (Type_High_Bound (gnat_entity));
+      gnu_low_bound = gnat_to_gnu (Type_Low_Bound (gnat_entity));
+      gnu_high_bound = gnat_to_gnu (Type_High_Bound (gnat_entity));
 
-      /* For enumeration types, write full debugging information.  */
       if (kind == E_Enumeration_Type)
 	{
-	  /* Since this has both a typedef and a tag, avoid outputting
-	     the name twice.  */
+	  /* 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.  Since this has both a
+	     typedef and a tag, avoid outputting the name twice.  */
 	  DECL_ARTIFICIAL (gnu_decl) = 1;
 	  rest_of_type_decl_compilation (gnu_decl);
 	}
+
+      else
+	{
+	  /* Floating-point types don't have specific RM bounds.  */
+	  TYPE_GCC_MIN_VALUE (gnu_scalar_type) = gnu_low_bound;
+	  TYPE_GCC_MAX_VALUE (gnu_scalar_type) = gnu_high_bound;
+	}
     }
 
   /* If we deferred processing of incomplete types, re-enable it.  If there
@@ -7391,7 +7396,7 @@ set_rm_size (Uint uint_size, tree gnu_type, Entity_Id gnat_entity)
        && Is_Discrete_Or_Fixed_Point_Type (gnat_entity))
       || (TREE_CODE (gnu_type) == ENUMERAL_TYPE
 	  || TREE_CODE (gnu_type) == BOOLEAN_TYPE))
-    TYPE_RM_SIZE (gnu_type) = size;
+    SET_TYPE_RM_SIZE (gnu_type, size);
 
   /* ...or the Ada size for record and union types.  */
   else if ((TREE_CODE (gnu_type) == RECORD_TYPE
@@ -7443,10 +7448,12 @@ make_type_from_size (tree type, tree size_tree, bool for_biased)
       else
 	new_type = make_signed_type (size);
       TREE_TYPE (new_type) = TREE_TYPE (type) ? TREE_TYPE (type) : type;
-      TYPE_MIN_VALUE (new_type)
-	= convert (TREE_TYPE (new_type), TYPE_MIN_VALUE (type));
-      TYPE_MAX_VALUE (new_type)
-	= convert (TREE_TYPE (new_type), TYPE_MAX_VALUE (type));
+      SET_TYPE_RM_MIN_VALUE (new_type,
+			     convert (TREE_TYPE (new_type),
+				      TYPE_MIN_VALUE (type)));
+      SET_TYPE_RM_MAX_VALUE (new_type,
+			     convert (TREE_TYPE (new_type),
+				      TYPE_MAX_VALUE (type)));
       /* Propagate the name to avoid creating a fake subrange type.  */
       if (TYPE_NAME (type))
 	{
@@ -7456,7 +7463,7 @@ make_type_from_size (tree type, tree size_tree, bool for_biased)
 	    TYPE_NAME (new_type) = TYPE_NAME (type);
 	}
       TYPE_BIASED_REPRESENTATION_P (new_type) = biased_p;
-      TYPE_RM_SIZE (new_type) = bitsize_int (size);
+      SET_TYPE_RM_SIZE (new_type, bitsize_int (size));
       return new_type;
 
     case RECORD_TYPE:
@@ -7703,18 +7710,20 @@ substitute_in_type (tree t, tree f, tree r)
     case ENUMERAL_TYPE:
     case BOOLEAN_TYPE:
     case REAL_TYPE:
-      if (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (t))
-	  || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (t)))
+
+      /* First the domain types of arrays.  */
+      if (CONTAINS_PLACEHOLDER_P (TYPE_GCC_MIN_VALUE (t))
+	  || CONTAINS_PLACEHOLDER_P (TYPE_GCC_MAX_VALUE (t)))
 	{
-	  tree low = SUBSTITUTE_IN_EXPR (TYPE_MIN_VALUE (t), f, r);
-	  tree high = SUBSTITUTE_IN_EXPR (TYPE_MAX_VALUE (t), f, r);
+	  tree low = SUBSTITUTE_IN_EXPR (TYPE_GCC_MIN_VALUE (t), f, r);
+	  tree high = SUBSTITUTE_IN_EXPR (TYPE_GCC_MAX_VALUE (t), f, r);
 
-	  if (low == TYPE_MIN_VALUE (t) && high == TYPE_MAX_VALUE (t))
+	  if (low == TYPE_GCC_MIN_VALUE (t) && high == TYPE_GCC_MAX_VALUE (t))
 	    return t;
 
 	  new = copy_type (t);
-	  TYPE_MIN_VALUE (new) = low;
-	  TYPE_MAX_VALUE (new) = high;
+	  TYPE_GCC_MIN_VALUE (new) = low;
+	  TYPE_GCC_MAX_VALUE (new) = high;
 
 	  if (TREE_CODE (t) == INTEGER_TYPE && TYPE_INDEX_TYPE (t))
 	    SET_TYPE_INDEX_TYPE
@@ -7723,6 +7732,23 @@ substitute_in_type (tree t, tree f, tree r)
 	  return new;
 	}
 
+      /* Then the subtypes.  */
+      if (CONTAINS_PLACEHOLDER_P (TYPE_RM_MIN_VALUE (t))
+	  || CONTAINS_PLACEHOLDER_P (TYPE_RM_MAX_VALUE (t)))
+	{
+	  tree low = SUBSTITUTE_IN_EXPR (TYPE_RM_MIN_VALUE (t), f, r);
+	  tree high = SUBSTITUTE_IN_EXPR (TYPE_RM_MAX_VALUE (t), f, r);
+
+	  if (low == TYPE_RM_MIN_VALUE (t) && high == TYPE_RM_MAX_VALUE (t))
+	    return t;
+
+	  new = copy_type (t);
+	  SET_TYPE_RM_MIN_VALUE (new, low);
+	  SET_TYPE_RM_MAX_VALUE (new, high);
+
+	  return new;
+	}
+
       return t;
 
     case COMPLEX_TYPE: