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, 80 insertions, 2 deletions

diff --git a/gcc/ada/gcc-interface/ada-tree.h b/gcc/ada/gcc-interface/ada-tree.h
index 19c9fa5..38bc862 100644
--- a/gcc/ada/gcc-interface/ada-tree.h
+++ b/gcc/ada/gcc-interface/ada-tree.h
@@ -167,9 +167,87 @@ struct GTY(()) lang_decl { tree t; };
    mechanism refer to the routine gnat_to_gnu_entity. */
 #define TYPE_CI_CO_LIST(NODE) TYPE_LANG_SLOT_1 (FUNCTION_TYPE_CHECK (NODE))
 
-/* For integral types, this is the RM size of the type.  */
+/* For numerical types, this is the GCC lower bound of the type.  The GCC
+   type system is based on the invariant that an object X of a given type
+   cannot hold at run time a value smaller than its lower bound; otherwise
+   the behavior is undefined.  The optimizer takes advantage of this and
+   considers that the assertion X >= LB is always true.  */
+#define TYPE_GCC_MIN_VALUE(NODE) (NUMERICAL_TYPE_CHECK (NODE)->type.minval)
+
+/* For numerical types, this is the GCC upper bound of the type.  The GCC
+   type system is based on the invariant that an object X of a given type
+   cannot hold at run time a value larger than its upper bound; otherwise
+   the behavior is undefined.  The optimizer takes advantage of this and
+   considers that the assertion X <= UB is always true.  */
+#define TYPE_GCC_MAX_VALUE(NODE) (NUMERICAL_TYPE_CHECK (NODE)->type.maxval)
+
+/* For numerical types, this holds various RM-defined values.  */
+#define TYPE_RM_VALUES(NODE) TYPE_LANG_SLOT_1 (NUMERICAL_TYPE_CHECK (NODE))
+
+/* For numerical types, this is the RM size of the type, aka its precision.
+   There is a discrepancy between what is called precision here (and more
+   generally throughout gigi) and what is called precision in the GCC type
+   system: in the former case it's TYPE_RM_SIZE whereas it's TYPE_PRECISION
+   in the latter case.  They are not identical because of the need to support
+   invalid values.
+
+   These values can be outside the range of values allowed by the RM size
+   but they must nevertheless be valid in the GCC type system, otherwise
+   the optimizer can pretend that they simply don't exist.  Therefore they
+   must be within the range of values allowed by the precision in the GCC
+   sense, hence TYPE_PRECISION be set to the Esize, not the RM size.  */
 #define TYPE_RM_SIZE(NODE) \
-  TYPE_LANG_SLOT_1 (TREE_CHECK3 (NODE, ENUMERAL_TYPE, BOOLEAN_TYPE, INTEGER_TYPE))
+  (TYPE_RM_VALUES (NODE) ? TREE_VEC_ELT (TYPE_RM_VALUES (NODE), 0) : NULL_TREE)
+#define SET_TYPE_RM_SIZE(NODE, X)		\
+  TREE_VEC_ELT ((TYPE_RM_VALUES (NODE)		\
+		 = (TYPE_RM_VALUES (NODE)	\
+		    ? TYPE_RM_VALUES (NODE) : make_tree_vec (3))), 0) = (X)
+
+/* For numerical types, this is the RM lower bound of the type.  There is
+   again a discrepancy between this lower bound and the GCC lower bound,
+   again because of the need to support invalid values.
+
+   These values can be outside the range of values allowed by the RM lower
+   bound but they must nevertheless be valid in the GCC type system, otherwise
+   the optimizer can pretend that they simply don't exist.  Therefore they
+   must be within the range of values allowed by the lower bound in the GCC
+   sense, hence the GCC lower bound be set to that of the base type.  */
+#define TYPE_RM_MIN_VALUE(NODE) \
+  (TYPE_RM_VALUES (NODE) ? TREE_VEC_ELT (TYPE_RM_VALUES (NODE), 1) : NULL_TREE)
+#define SET_TYPE_RM_MIN_VALUE(NODE, X)		\
+  TREE_VEC_ELT ((TYPE_RM_VALUES (NODE)		\
+		 = (TYPE_RM_VALUES (NODE)	\
+		    ? TYPE_RM_VALUES (NODE) : make_tree_vec (3))), 1) = (X)
+
+/* For numerical types, this is the RM upper bound of the type.  There is
+   again a discrepancy between this upper bound and the GCC upper bound,
+   again because of the need to support invalid values.
+
+   These values can be outside the range of values allowed by the RM upper
+   bound but they must nevertheless be valid in the GCC type system, otherwise
+   the optimizer can pretend that they simply don't exist.  Therefore they
+   must be within the range of values allowed by the upper bound in the GCC
+   sense, hence the GCC upper bound be set to that of the base type.  */
+#define TYPE_RM_MAX_VALUE(NODE) \
+  (TYPE_RM_VALUES (NODE) ? TREE_VEC_ELT (TYPE_RM_VALUES (NODE), 2) : NULL_TREE)
+#define SET_TYPE_RM_MAX_VALUE(NODE, X)		\
+  TREE_VEC_ELT ((TYPE_RM_VALUES (NODE)		\
+		 = (TYPE_RM_VALUES (NODE)	\
+		    ? TYPE_RM_VALUES (NODE) : make_tree_vec (3))), 2) = (X)
+
+/* For numerical types, this is the lower bound of the type, i.e. the RM lower
+   bound for language-defined types and the GCC lower bound for others.  */
+#undef TYPE_MIN_VALUE
+#define TYPE_MIN_VALUE(NODE) \
+  (TYPE_RM_MIN_VALUE (NODE) \
+   ? TYPE_RM_MIN_VALUE (NODE) : TYPE_GCC_MIN_VALUE (NODE))
+
+/* For numerical types, this is the upper bound of the type, i.e. the RM upper
+   bound for language-defined types and the GCC upper bound for others.  */
+#undef TYPE_MAX_VALUE
+#define TYPE_MAX_VALUE(NODE) \
+  (TYPE_RM_MAX_VALUE (NODE) \
+   ? TYPE_RM_MAX_VALUE (NODE) : TYPE_GCC_MAX_VALUE (NODE))
 
 /* In an UNCONSTRAINED_ARRAY_TYPE, points to the record containing both
    the template and object.