* gcc-interface/gigi.h (create_index_type): Adjust head comment.
* gcc-interface/decl.c (gnat_to_gnu_entity) <E_Signed_Integer_Subtype>:
Use front-end predicates to compute signedness and precision.
<E_String_Literal_Subtype>: Fold range type.
Make sure to set longest_float_type_node to a scalar type.
(elaborate_entity): Use consistent Constraint_Error spelling.
(substitute_in_type) <INTEGER_TYPE>: Always copy the type.
* gcc-interface/misc.c (gnat_print_type) <INTEGER_TYPE>: Use brief
output for the modulus, if any.
<ENUMERAL_TYPE>: Likewise for the RM size.
* gcc-interface/trans.c (gnat_to_gnu): Use consistent Constraint_Error
spelling.
* gcc-interface/utils.c (finish_record_type): Really test the alignment
of BLKmode bit-fields to compute their addressability.
(create_index_type): Adjust comments.
(create_param_decl): Create the biased subtype manually.
* gcc-interface/utils2.c (build_component_ref): Use consistent
Constraint_Error spelling.
From-SVN: r146644
+2009-04-23 Eric Botcazou <ebotcazou@adacore.com>
+
+ * gcc-interface/gigi.h (create_index_type): Adjust head comment.
+ * gcc-interface/decl.c (gnat_to_gnu_entity) <E_Signed_Integer_Subtype>:
+ Use front-end predicates to compute signedness and precision.
+ <E_String_Literal_Subtype>: Fold range type.
+ Make sure to set longest_float_type_node to a scalar type.
+ (elaborate_entity): Use consistent Constraint_Error spelling.
+ (substitute_in_type) <INTEGER_TYPE>: Always copy the type.
+ * gcc-interface/misc.c (gnat_print_type) <INTEGER_TYPE>: Use brief
+ output for the modulus, if any.
+ <ENUMERAL_TYPE>: Likewise for the RM size.
+ * gcc-interface/trans.c (gnat_to_gnu): Use consistent Constraint_Error
+ spelling.
+ * gcc-interface/utils.c (finish_record_type): Really test the alignment
+ of BLKmode bit-fields to compute their addressability.
+ (create_index_type): Adjust comments.
+ (create_param_decl): Create the biased subtype manually.
+ * gcc-interface/utils2.c (build_component_ref): Use consistent
+ Constraint_Error spelling.
+
2009-04-23 Eric Botcazou <ebotcazou@adacore.com>
* gcc-interface/cuintp.c: Clean up include directives.
/* 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
node to be distinct. ??? Historically this was in preparation for
- when memory aliasing is implemented. But that's obsolete now given
+ when memory aliasing is implemented, but that's obsolete now given
the call to relate_alias_sets below.
The TREE_TYPE field of the INTEGER_TYPE points to the base type;
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. */
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 (TREE_CODE (TREE_TYPE (gnu_type)) == BOOLEAN_TYPE)
+ else if (Is_Boolean_Type (gnat_entity))
esize = 1;
TYPE_PRECISION (gnu_type) = esize;
TYPE_BIASED_REPRESENTATION_P (gnu_type)
= Has_Biased_Representation (gnat_entity);
- /* This should be an unsigned type if the base type is unsigned or
- if the lower bound is constant and non-negative (as computed by
- layout_type) or if the type is biased. */
- TYPE_UNSIGNED (gnu_type) = (TYPE_UNSIGNED (TREE_TYPE (gnu_type))
- || TYPE_BIASED_REPRESENTATION_P (gnu_type)
- || Is_Unsigned_Type (gnat_entity));
-
layout_type (gnu_type);
/* Inherit our alias set from what we're a subtype of. Subtypes
= build_binary_op (PLUS_EXPR, gnu_string_index_type,
gnu_lower_bound,
convert (gnu_string_index_type, gnu_length));
- tree gnu_range_type
- = build_range_type (gnu_string_index_type,
- gnu_lower_bound, gnu_upper_bound);
tree gnu_index_type
- = create_index_type (convert (sizetype,
- TYPE_MIN_VALUE (gnu_range_type)),
- convert (sizetype,
- TYPE_MAX_VALUE (gnu_range_type)),
- gnu_range_type, gnat_entity);
+ = 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),
+ gnat_entity);
gnu_type
= build_array_type (gnat_to_gnu_type (Component_Type (gnat_entity)),
if (!saved)
save_gnu_tree (gnat_entity, gnu_decl, false);
- /* If this is an enumeral or floating-point type, we were not able to set
- the bounds since they refer to the type. These bounds are always static.
- For enumeration types, also write debugging information and declare the
- enumeration literal table, if needed. */
+ /* If this is an enumeration or floating-point type, we were not able to set
+ the bounds since they refer to the type. These are always static. */
if ((kind == E_Enumeration_Type && Present (First_Literal (gnat_entity)))
|| (kind == E_Floating_Point_Type && !Vax_Float (gnat_entity)))
{
/* If this is a floating point type and we haven't set a floating
point type yet, use this in the evaluation of the bounds. */
if (!longest_float_type_node && kind == E_Floating_Point_Type)
- longest_float_type_node = gnu_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));
- if (TREE_CODE (gnu_scalar_type) == ENUMERAL_TYPE)
+ /* 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. */
Node_Id gnat_lb = Type_Low_Bound (gnat_entity);
Node_Id gnat_hb = Type_High_Bound (gnat_entity);
- /* ??? Tests for avoiding static constraint error expression
- is needed until the front stops generating bogus conversions
- on bounds of real types. */
-
+ /* ??? Tests to avoid Constraint_Error in static expressions
+ are needed until after the front stops generating bogus
+ conversions on bounds of real types. */
if (!Raises_Constraint_Error (gnat_lb))
elaborate_expression (gnat_lb, gnat_entity, get_identifier ("L"),
1, 0, Needs_Debug_Info (gnat_entity));
if (low == TYPE_MIN_VALUE (t) && high == TYPE_MAX_VALUE (t))
return t;
- new = build_range_type (TREE_TYPE (t), low, high);
+ new = copy_type (t);
+ TYPE_MIN_VALUE (new) = low;
+ TYPE_MAX_VALUE (new) = high;
if (TYPE_INDEX_TYPE (t))
SET_TYPE_INDEX_TYPE
(new, substitute_in_type (TYPE_INDEX_TYPE (t), f, r));
nothing has changed. */
extern tree substitute_in_type (tree t, tree f, tree r);
-/* Return the "RM size" of GNU_TYPE. This is the actual number of bits
+/* Return the RM size of GNU_TYPE. This is the actual number of bits
needed to represent the object. */
extern tree rm_size (tree gnu_type);
/* Return a copy of TYPE, but safe to modify in any way. */
extern tree copy_type (tree type);
-/* Return an INTEGER_TYPE of SIZETYPE with range MIN to MAX and whose
- TYPE_INDEX_TYPE is INDEX. GNAT_NODE is used for the position of
- the decl. */
+/* Return a subtype of sizetype with range MIN to MAX and whose
+ TYPE_INDEX_TYPE is INDEX. GNAT_NODE is used for the position
+ of the associated TYPE_DECL. */
extern tree create_index_type (tree min, tree max, tree index,
Node_Id gnat_node);
case INTEGER_TYPE:
if (TYPE_MODULAR_P (node))
- print_node (file, "modulus", TYPE_MODULUS (node), indent + 4);
+ print_node_brief (file, "modulus", TYPE_MODULUS (node), indent + 4);
else if (TYPE_HAS_ACTUAL_BOUNDS_P (node))
print_node (file, "actual bounds", TYPE_ACTUAL_BOUNDS (node),
indent + 4);
case ENUMERAL_TYPE:
case BOOLEAN_TYPE:
- print_node (file, "RM size", TYPE_RM_SIZE (node), indent + 4);
+ print_node_brief (file, "RM size", TYPE_RM_SIZE (node), indent + 4);
break;
case ARRAY_TYPE:
if (TREE_CODE (gnu_result_type) == VOID_TYPE)
return gnu_result;
- /* If the result is a constant that overflows, raise constraint error. */
- else if (TREE_CODE (gnu_result) == INTEGER_CST
- && TREE_OVERFLOW (gnu_result))
+ /* If the result is a constant that overflowed, raise Constraint_Error. */
+ if (TREE_CODE (gnu_result) == INTEGER_CST && TREE_OVERFLOW (gnu_result))
{
post_error ("Constraint_Error will be raised at run-time?", gnat_node);
-
gnu_result
= build1 (NULL_EXPR, gnu_result_type,
build_call_raise (CE_Overflow_Check_Failed, gnat_node,
DECL_BIT_FIELD (field) = 0;
}
- /* If we still have DECL_BIT_FIELD set at this point, we know the field
- is technically not addressable. Except that it can actually be
- addressed if the field is BLKmode and happens to be properly
- aligned. */
- DECL_NONADDRESSABLE_P (field)
- |= DECL_BIT_FIELD (field) && DECL_MODE (field) != BLKmode;
+ /* If we still have DECL_BIT_FIELD set at this point, we know that the
+ field is technically not addressable. Except that it can actually
+ be addressed if it is BLKmode and happens to be properly aligned. */
+ if (DECL_BIT_FIELD (field)
+ && !(DECL_MODE (field) == BLKmode
+ && value_factor_p (pos, BITS_PER_UNIT)))
+ DECL_NONADDRESSABLE_P (field) = 1;
/* A type must be as aligned as its most aligned field that is not
a bit-field. But this is already enforced by layout_type. */
return new;
}
\f
-/* Return an INTEGER_TYPE of SIZETYPE with range MIN to MAX and whose
- TYPE_INDEX_TYPE is INDEX. GNAT_NODE is used for the position of
- the decl. */
+/* Return a subtype of sizetype with range MIN to MAX and whose
+ TYPE_INDEX_TYPE is INDEX. GNAT_NODE is used for the position
+ of the associated TYPE_DECL. */
tree
create_index_type (tree min, tree max, tree index, Node_Id gnat_node)
/* First build a type for the desired range. */
tree type = build_index_2_type (min, max);
- /* If this type has the TYPE_INDEX_TYPE we want, return it. Otherwise, if it
- doesn't have TYPE_INDEX_TYPE set, set it to INDEX. If TYPE_INDEX_TYPE
- is set, but not to INDEX, make a copy of this type with the requested
- index type. Note that we have no way of sharing these types, but that's
- only a small hole. */
+ /* If this type has the TYPE_INDEX_TYPE we want, return it. */
if (TYPE_INDEX_TYPE (type) == index)
return type;
- else if (TYPE_INDEX_TYPE (type))
+
+ /* Otherwise, if TYPE_INDEX_TYPE is set, make a copy. Note that we have
+ no way of sharing these types, but that's only a small hole. */
+ if (TYPE_INDEX_TYPE (type))
type = copy_type (type);
SET_TYPE_INDEX_TYPE (type, index);
create_type_decl (NULL_TREE, type, NULL, true, false, gnat_node);
+
return type;
}
\f
if (TREE_CODE (param_type) == INTEGER_TYPE
&& TYPE_BIASED_REPRESENTATION_P (param_type))
{
- param_type
- = copy_type (build_range_type (integer_type_node,
- TYPE_MIN_VALUE (param_type),
- TYPE_MAX_VALUE (param_type)));
+ tree subtype = make_node (INTEGER_TYPE);
+ TREE_TYPE (subtype) = integer_type_node;
+ TYPE_BIASED_REPRESENTATION_P (subtype) = 1;
+
+ TYPE_UNSIGNED (subtype) = 1;
+ TYPE_PRECISION (subtype) = TYPE_PRECISION (integer_type_node);
+ TYPE_MIN_VALUE (subtype) = TYPE_MIN_VALUE (param_type);
+ TYPE_MAX_VALUE (subtype) = TYPE_MAX_VALUE (param_type);
+ layout_type (subtype);
- TYPE_BIASED_REPRESENTATION_P (param_type) = 1;
+ param_type = subtype;
}
else
param_type = integer_type_node;
if (ref)
return ref;
- /* If FIELD was specified, assume this is an invalid user field so
- raise constraint error. Otherwise, we can't find the type to return, so
- abort. */
+ /* If FIELD was specified, assume this is an invalid user field so raise
+ Constraint_Error. Otherwise, we have no type to return so abort. */
gcc_assert (field);
return build1 (NULL_EXPR, TREE_TYPE (field),
build_call_raise (CE_Discriminant_Check_Failed, Empty,
projects / thirdparty / gcc.git / commitdiff
