2010-04-16 Eric Botcazou <ebotcazou@adacore.com>
+ * uintp.adb (UI_From_Dint): Remove useless code.
+ (UI_From_Int): Likewise.
+ * uintp.h: Reorder declarations.
+ (UI_From_gnu): Declare.
+ (UI_Base): Likewise.
+ (Vector_Template): Likewise.
+ (Vector_To_Uint): Likewise.
+ (Uint_0): Remove.
+ (Uint_1): Likewise.
+ * gcc-interface/gigi.h: Tweak comments.
+ * gcc-interface/cuintp.c (UI_From_gnu): New global function.
+ * gcc-interface/decl.c (maybe_pad_type): Do not warn if either size
+ overflows.
+ (annotate_value) <INTEGER_CST>: Call UI_From_gnu.
+ * gcc-interface/trans.c (post_error_ne_num): Call post_error_ne.
+ (post_error_ne_tree): Call UI_From_gnu and post_error_ne.
+ * gcc-interface/utils.c (max_size) <tcc_binary>: Do not special-case
+ TYPE_MAX_VALUE.
+
+2010-04-16 Eric Botcazou <ebotcazou@adacore.com>
+
* gcc-interface/decl.c (make_type_from_size) <INTEGER_TYPE>: Just copy
TYPE_NAME.
* gcc-interface/trans.c (smaller_packable_type_p): Rename into...
&& !operand_equal_p (size, orig_size, 0)
&& !(TREE_CODE (size) == INTEGER_CST
&& TREE_CODE (orig_size) == INTEGER_CST
- && tree_int_cst_lt (size, orig_size)))
+ && (TREE_OVERFLOW (size)
+ || TREE_OVERFLOW (orig_size)
+ || tree_int_cst_lt (size, orig_size))))
{
Node_Id gnat_error_node = Empty;
TCode tcode;
Node_Ref_Or_Val ops[3], ret;
struct tree_int_map **h = NULL;
- int size, i;
+ int i;
/* See if we've already saved the value for this node. */
if (EXPR_P (gnu_size))
return annotate_value (temp);
}
- if (!host_integerp (gnu_size, 1))
- return No_Uint;
-
- size = tree_low_cst (gnu_size, 1);
-
- /* This peculiar test is to make sure that the size fits in an int
- on machines where HOST_WIDE_INT is not "int". */
- if (tree_low_cst (gnu_size, 1) == size)
- return UI_From_Int (size);
- else
- return No_Uint;
+ return UI_From_gnu (gnu_size);
case COMPONENT_REF:
/* The only case we handle here is a simple discriminant reference. */
/* Post an error message. MSG is the error message, properly annotated.
NODE is the node at which to post the error and the node to use for the
- "&" substitution. */
+ '&' substitution. */
extern void post_error (const char *msg, Node_Id node);
-/* Similar, but NODE is the node at which to post the error and ENT
- is the node to use for the "&" substitution. */
+/* Similar to post_error, but NODE is the node at which to post the error and
+ ENT is the node to use for the '&' substitution. */
extern void post_error_ne (const char *msg, Node_Id node, Entity_Id ent);
-/* Similar, but NODE is the node at which to post the error, ENT is the node
- to use for the "&" substitution, and NUM is the number to use for ^. */
+/* Similar to post_error_ne, but NUM is the number to use for the '^'. */
extern void post_error_ne_num (const char *msg, Node_Id node, Entity_Id ent,
int num);
-/* Similar to post_error_ne_num, but T is a GCC tree representing the number
- to write. If the tree represents a constant that fits within a
- host integer, the text inside curly brackets in MSG will be output
- (presumably including a '^'). Otherwise that text will not be output
- and the text inside square brackets will be output instead. */
+/* Similar to post_error_ne, but T is a GCC tree representing the number to
+ write. If T represents a constant, the text inside curly brackets in
+ MSG will be output (presumably including a '^'). Otherwise it will not
+ be output and the text inside square brackets will be output instead. */
extern void post_error_ne_tree (const char *msg, Node_Id node, Entity_Id ent,
tree t);
-/* Similar to post_error_ne_tree, except that NUM is a second integer to write
- in the message. */
+/* Similar to post_error_ne_tree, but NUM is a second integer to write. */
extern void post_error_ne_tree_2 (const char *msg, Node_Id node, Entity_Id ent,
tree t, int num);
\f
/* Post an error message. MSG is the error message, properly annotated.
NODE is the node at which to post the error and the node to use for the
- "&" substitution. */
+ '&' substitution. */
void
post_error (const char *msg, Node_Id node)
Error_Msg_N (fp, node);
}
-/* Similar, but NODE is the node at which to post the error and ENT
- is the node to use for the "&" substitution. */
+/* Similar to post_error, but NODE is the node at which to post the error and
+ ENT is the node to use for the '&' substitution. */
void
post_error_ne (const char *msg, Node_Id node, Entity_Id ent)
Error_Msg_NE (fp, node, ent);
}
-/* Similar, but NODE is the node at which to post the error, ENT is the node
- to use for the "&" substitution, and NUM is the number to use for ^. */
+/* Similar to post_error_ne, but NUM is the number to use for the '^'. */
void
post_error_ne_num (const char *msg, Node_Id node, Entity_Id ent, int num)
{
- String_Template temp;
- Fat_Pointer fp;
-
- temp.Low_Bound = 1, temp.High_Bound = strlen (msg);
- fp.Array = msg, fp.Bounds = &temp;
Error_Msg_Uint_1 = UI_From_Int (num);
-
- if (Present (node))
- Error_Msg_NE (fp, node, ent);
+ post_error_ne (msg, node, ent);
}
\f
-/* Similar to post_error_ne_num, but T is a GCC tree representing the
- number to write. If the tree represents a constant that fits within
- a host integer, the text inside curly brackets in MSG will be output
- (presumably including a '^'). Otherwise that text will not be output
- and the text inside square brackets will be output instead. */
+/* Similar to post_error_ne, but T is a GCC tree representing the number to
+ write. If T represents a constant, the text inside curly brackets in
+ MSG will be output (presumably including a '^'). Otherwise it will not
+ be output and the text inside square brackets will be output instead. */
void
post_error_ne_tree (const char *msg, Node_Id node, Entity_Id ent, tree t)
{
- char *newmsg = XALLOCAVEC (char, strlen (msg) + 1);
- String_Template temp = {1, 0};
- Fat_Pointer fp;
+ char *new_msg = XALLOCAVEC (char, strlen (msg) + 1);
char start_yes, end_yes, start_no, end_no;
const char *p;
char *q;
- fp.Array = newmsg, fp.Bounds = &temp;
-
- if (host_integerp (t, 1)
-#if HOST_BITS_PER_WIDE_INT > HOST_BITS_PER_INT
- &&
- compare_tree_int
- (t, (((unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_INT - 1)) - 1)) < 0
-#endif
- )
+ if (TREE_CODE (t) == INTEGER_CST)
{
- Error_Msg_Uint_1 = UI_From_Int (tree_low_cst (t, 1));
+ Error_Msg_Uint_1 = UI_From_gnu (t);
start_yes = '{', end_yes = '}', start_no = '[', end_no = ']';
}
else
start_yes = '[', end_yes = ']', start_no = '{', end_no = '}';
- for (p = msg, q = newmsg; *p; p++)
+ for (p = msg, q = new_msg; *p; p++)
{
if (*p == start_yes)
for (p++; *p != end_yes; p++)
*q = 0;
- temp.High_Bound = strlen (newmsg);
- if (Present (node))
- Error_Msg_NE (fp, node, ent);
+ post_error_ne (new_msg, node, ent);
}
-/* Similar to post_error_ne_tree, except that NUM is a second integer to write
- in the message. */
+/* Similar to post_error_ne_tree, but NUM is a second integer to write. */
void
post_error_ne_tree_2 (const char *msg, Node_Id node, Entity_Id ent, tree t,
In that case, if one side overflows, return the other.
sizetype is signed, but we know sizes are non-negative.
Likewise, handle a MINUS_EXPR or PLUS_EXPR with the LHS
- overflowing or the maximum possible value and the RHS
- a variable. */
+ overflowing and the RHS a variable. */
if (max_p
&& code == MIN_EXPR
&& TREE_CODE (rhs) == INTEGER_CST
&& TREE_OVERFLOW (lhs))
return rhs;
else if ((code == MINUS_EXPR || code == PLUS_EXPR)
- && ((TREE_CODE (lhs) == INTEGER_CST
- && TREE_OVERFLOW (lhs))
- || operand_equal_p (lhs, TYPE_MAX_VALUE (type), 0))
+ && TREE_CODE (lhs) == INTEGER_CST
+ && TREE_OVERFLOW (lhs)
&& !TREE_CONSTANT (rhs))
return lhs;
else
#define Vector_To_Uint uintp__vector_to_uint
extern Uint Vector_To_Uint (Int_Vector, Boolean);
-/* Compare integer values for less than. */
-#define UI_Lt uintp__ui_lt
-extern Boolean UI_Lt (Uint, Uint);
-
/* Universal integers are represented by the Uint type which is an index into
the Uints_Ptr table containing Uint_Entry values. A Uint_Entry contains an
index and length for getting the "digits" of the universal integer from the