* tree.h (INT_CST_LT, INT_CST_LT_UNSIGNED): Remove unneeded casts.
(struct tree_int_cst): int_cst_low is now unsigned HOST_WIDE_INT.
(attribute_hash_list, type_hash_canon): hashcode is now unsigned.
(type_hash_lookup, type_hash_add, type_hash_list): Likewise.
(min_precision): Result is unsignd.
(add_double, neg_double, mul_double): Low word is unsigned.
(lshift_double, rshift_double, lrotate_double): Likewise.
(rrotate_double, div_and_round_double): Likewise.
(tree_floor_log2, compare_tree_int): New functions.
(preserve_rtl_expr_temps): New declaration.
* c-common.c (declare_hidden_char_array): Use compare_tree_int.
(decl_attributes): Use tree_log2 to find alignment.
Check for TREE_INT_CST_HIGH for format args.
(min_precision): Now unsigned.
Use tree_floor_log2.
(truthvalue_conversion): Delete long-disabled code.
* c-decl.c (finish_struct): Clean up tests on field width.
(finish_function): Use compare_tree_int.
* c-pragma.c (handle_pragma_token): Use tree_log2 for alignment.
* c-typeck.c (comptypes): Use tree_int_cst_equal.
(default_conversion, digest_init): Use compare_tree_int.
(build_binary_op): Use integer_all_onesp and compare_tree_int.
Fix type errors in forming masks.
* calls.c (initialize_argument_information): Use compare_tree_int.
* dbxout.c (dbxout_type): Cast TREE_INT_CST_LOW to HOST_WIDE_INT.
* except.c (expand_eh_region_start_tree): Use compare_tree_int.
* expr.c (is_zeros_p, case INTEGER_CST): Use integer_zerop.
(store_field): Use compare_tree_int.
(expand_expr, case CONSTRUCTOR): Use TYPE_SIZE_UNIT.
(expand_expr, case ARRAY_REF): Use compare_tree_int.
(do_jump, case BIT_AND_EXPR): Use tree_floor_log2.
(do_store_flag): Use compare_tree_int.
* fold-const.c (encode, decode): Low part is always unsigned.
(force_fit_type, add_double, neg_double, mul_double): Likewise.
(lshift_double, rshift_double, lrotate_double): Likewise.
(rrotate_double, div_and_round_double, int_const_binop): Likewise.
(fold_convert): Use compare_tree_int.
(operand_equal_p, case INTEGER_CST): Use tree_int_cst_equal.
(invert_truthvalue, case INTEGER_CST): Likewise.
(fold): Use compare_tree_int; add casts for unsigned TREE_INT_CST_LOW.
* mkdeps.c (deps_dummy_targets): Make I unsigned.
* rtl.h (add_double, neg_double, mul_double): Low words are unsigned.
(lshift_double, rshift_double, lrotate_double, rrotate_double):
Likewise.
* stmt.c (expand_decl): Use compare_tree_int and mode_for_size_tree.
(expand_end_case): Use compare_tree_int.
(estimate_case_costs): Cast TREE_INT_CST_LOW to HOST_WIDE_INT.
* stor-layout.c (mode_for_size_tree): Use compare_tree_int.
(layout_decl): Likewise.
(layout_record, layout_union): Make sizes unsigned.
(layout_type, case VOID_TYPE): TYPE_SIZE must be bitsizetype.
(layout_type, case QUAL_UNION_TYPE): Use compare_tree_int.
* tree.c (struct type_hash): hashcode is unsigned.
(build_type_attribute_variant, type_hash_list): Likewise.
(type_hash_lookup, type_hash_add, type_hash_canon): Likewise.
(attribute_hash_list, build_array_type, build_method_type): Likewise.
(build_complex_type): Likewise.
(real_value_from_int_cst): Remove unneeded casts.
(integer_all_onesp): Add casts.
(tree_floor_log2, compare_tree_int): New functions.
(build_index_type): Use tree_int_cst_sgn.
* varasm.c (assemble_variable): Use compare_tree_int.
* ch/actions.c (chill_convert_for_assignment): INDEX is unsigned
HOST_WIDE_INT.
* ch/ch-tree.h (DECL_NESTING_LEVEL): Use TREE_INT_CST_HIGH
since unsigned.
* ch/except.c (chill_handle_on_labels): ALTERNATIVE is unsigned.
Use compare_tree_int.
(expand_goto_except_cleanup): Likewise.
* cp/class.c (dfs_modify_vtables): I is now unsigned.
(check_bitfield_decl): Use tree_int_cst_sgn and compare_tree_int.
(build_base_field): Add casts of TREE_INT_CST_LOW to HOST_WIDE_INT.
* cp/error.c (dump_expr): Cast TREE_INT_CST_HIGH to unsigned.
* cp/init.c (build_vec_init): Cast TREE_INT_CST_LOW to HOST_WIDE_INT.
* cp/method.c (build_overload_int): Cast TREE_INT_CST_HIGH to unsigned.
* cp/typeck.c (build_binary_op, case TRUNC_DIV_EXPR):
Call integer_all_onesp.
* cp/typeck2.c (process_init_constructor): Use compare_tree_int.
* f/com.c (ffecom_f2c_set_lio_code_): Use compare_tree_int.
(ffecom_sym_transform_, ffecom_transform_common_): Likewise.
(ffecom_transform_equiv_): Likewise.
* java/decl.c (emit_init_test_initialization): Mark KEY as unused.
* java/expr.c (build_newarray): Cast TREE_INT_CST_LOW to HOST_WIDE_INT.
(build_anewarray): Likewise.
* java/parse.y (patch_newarray): Likewise.
* java/parse.c: Regenerated.
From-SVN: r32383
+Mon Mar 6 15:22:29 2000 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * tree.h (INT_CST_LT, INT_CST_LT_UNSIGNED): Remove unneeded casts.
+ (struct tree_int_cst): int_cst_low is now unsigned HOST_WIDE_INT.
+ (attribute_hash_list, type_hash_canon): hashcode is now unsigned.
+ (type_hash_lookup, type_hash_add, type_hash_list): Likewise.
+ (min_precision): Result is unsignd.
+ (add_double, neg_double, mul_double): Low word is unsigned.
+ (lshift_double, rshift_double, lrotate_double): Likewise.
+ (rrotate_double, div_and_round_double): Likewise.
+ (tree_floor_log2, compare_tree_int): New functions.
+ (preserve_rtl_expr_temps): New declaration.
+ * c-common.c (declare_hidden_char_array): Use compare_tree_int.
+ (decl_attributes): Use tree_log2 to find alignment.
+ Check for TREE_INT_CST_HIGH for format args.
+ (min_precision): Now unsigned.
+ Use tree_floor_log2.
+ (truthvalue_conversion): Delete long-disabled code.
+ * c-decl.c (finish_struct): Clean up tests on field width.
+ (finish_function): Use compare_tree_int.
+ * c-pragma.c (handle_pragma_token): Use tree_log2 for alignment.
+ * c-typeck.c (comptypes): Use tree_int_cst_equal.
+ (default_conversion, digest_init): Use compare_tree_int.
+ (build_binary_op): Use integer_all_onesp and compare_tree_int.
+ Fix type errors in forming masks.
+ * calls.c (initialize_argument_information): Use compare_tree_int.
+ * dbxout.c (dbxout_type): Cast TREE_INT_CST_LOW to HOST_WIDE_INT.
+ * except.c (expand_eh_region_start_tree): Use compare_tree_int.
+ * expr.c (is_zeros_p, case INTEGER_CST): Use integer_zerop.
+ (store_field): Use compare_tree_int.
+ (expand_expr, case CONSTRUCTOR): Use TYPE_SIZE_UNIT.
+ (expand_expr, case ARRAY_REF): Use compare_tree_int.
+ (do_jump, case BIT_AND_EXPR): Use tree_floor_log2.
+ (do_store_flag): Use compare_tree_int.
+ * fold-const.c (encode, decode): Low part is always unsigned.
+ (force_fit_type, add_double, neg_double, mul_double): Likewise.
+ (lshift_double, rshift_double, lrotate_double): Likewise.
+ (rrotate_double, div_and_round_double, int_const_binop): Likewise.
+ (fold_convert): Use compare_tree_int.
+ (operand_equal_p, case INTEGER_CST): Use tree_int_cst_equal.
+ (invert_truthvalue, case INTEGER_CST): Likewise.
+ (fold): Use compare_tree_int; add casts for unsigned TREE_INT_CST_LOW.
+ * mkdeps.c (deps_dummy_targets): Make I unsigned.
+ * rtl.h (add_double, neg_double, mul_double): Low words are unsigned.
+ (lshift_double, rshift_double, lrotate_double, rrotate_double):
+ Likewise.
+ * stmt.c (expand_decl): Use compare_tree_int and mode_for_size_tree.
+ (expand_end_case): Use compare_tree_int.
+ (estimate_case_costs): Cast TREE_INT_CST_LOW to HOST_WIDE_INT.
+ * stor-layout.c (mode_for_size_tree): Use compare_tree_int.
+ (layout_decl): Likewise.
+ (layout_record, layout_union): Make sizes unsigned.
+ (layout_type, case VOID_TYPE): TYPE_SIZE must be bitsizetype.
+ (layout_type, case QUAL_UNION_TYPE): Use compare_tree_int.
+ * tree.c (struct type_hash): hashcode is unsigned.
+ (build_type_attribute_variant, type_hash_list): Likewise.
+ (type_hash_lookup, type_hash_add, type_hash_canon): Likewise.
+ (attribute_hash_list, build_array_type, build_method_type): Likewise.
+ (build_complex_type): Likewise.
+ (real_value_from_int_cst): Remove unneeded casts.
+ (integer_all_onesp): Add casts.
+ (tree_floor_log2, compare_tree_int): New functions.
+ (build_index_type): Use tree_int_cst_sgn.
+ * varasm.c (assemble_variable): Use compare_tree_int.
+
2000-03-06 Jason Merrill <jason@casey.cygnus.com>
* cpphash.c (collect_expansion): Also catch ## at start of macro.
const char *name, *value;
{
tree decl, type, init;
- int vlen;
+ unsigned int vlen;
/* If the default size of char arrays isn't big enough for the name,
or if we want to give warnings for large objects, make a bigger one. */
vlen = strlen (value) + 1;
type = char_array_type_node;
- if (TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) < vlen
+ if (compare_tree_int (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), vlen) < 0
|| warn_larger_than)
type = build_array_type (char_type_node,
build_index_type (build_int_2 (vlen, 0)));
+
decl = build_decl (VAR_DECL, get_identifier (name), type);
TREE_STATIC (decl) = 1;
TREE_READONLY (decl) = 1;
tree align_expr
= (args ? TREE_VALUE (args)
: size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
- int align;
+ int i;
/* Strip any NOPs of any kind. */
while (TREE_CODE (align_expr) == NOP_EXPR
continue;
}
- align = TREE_INT_CST_LOW (align_expr) * BITS_PER_UNIT;
-
- if (exact_log2 (align) == -1)
+ if ((i = tree_log2 (align_expr)) == -1)
error ("requested alignment is not a power of 2");
+ else if (i > HOST_BITS_PER_INT - 2)
+ error ("requested alignment is too large");
else if (is_type)
- TYPE_ALIGN (type) = align;
+ TYPE_ALIGN (type) = (1 << i) * BITS_PER_UNIT;
else if (TREE_CODE (decl) != VAR_DECL
&& TREE_CODE (decl) != FIELD_DECL)
error_with_decl (decl,
"alignment may not be specified for `%s'");
else
- DECL_ALIGN (decl) = align;
+ DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
}
break;
tree format_num_expr = TREE_VALUE (TREE_CHAIN (args));
tree first_arg_num_expr
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args)));
- int format_num;
- int first_arg_num;
+ unsigned HOST_WIDE_INT format_num, first_arg_num;
enum format_type format_type;
tree argument;
- int arg_num;
+ unsigned int arg_num;
if (TREE_CODE (decl) != FUNCTION_DECL)
{
first_arg_num_expr = TREE_OPERAND (first_arg_num_expr, 0);
if (TREE_CODE (format_num_expr) != INTEGER_CST
- || TREE_CODE (first_arg_num_expr) != INTEGER_CST)
+ || TREE_INT_CST_HIGH (format_num_expr) != 0
+ || TREE_CODE (first_arg_num_expr) != INTEGER_CST
+ || TREE_INT_CST_HIGH (first_arg_num_expr) != 0)
{
- error ("format string has non-constant operand number");
+ error ("format string has invalid operand number");
continue;
}
argument = TYPE_ARG_TYPES (type);
if (argument)
{
- for (arg_num = 1; ; ++arg_num)
- {
- if (argument == 0 || arg_num == format_num)
- break;
- argument = TREE_CHAIN (argument);
- }
+ for (arg_num = 1; argument != 0 && arg_num != format_num;
+ ++arg_num, argument = TREE_CHAIN (argument))
+ ;
+
if (! argument
|| TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE
|| (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument)))
error ("format string arg not a string type");
continue;
}
- if (first_arg_num != 0)
+
+ else if (first_arg_num != 0)
{
/* Verify that first_arg_num points to the last arg,
the ... */
while (argument)
arg_num++, argument = TREE_CHAIN (argument);
- if (arg_num != first_arg_num)
- {
- error ("args to be formatted is not ...");
- continue;
- }
+
+ if (arg_num != first_arg_num)
+ {
+ error ("args to be formatted is not '...'");
+ continue;
+ }
}
}
case A_FORMAT_ARG:
{
tree format_num_expr = TREE_VALUE (args);
- int format_num, arg_num;
+ unsigned HOST_WIDE_INT format_num;
+ unsigned int arg_num;
tree argument;
if (TREE_CODE (decl) != FUNCTION_DECL)
|| TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
format_num_expr = TREE_OPERAND (format_num_expr, 0);
- if (TREE_CODE (format_num_expr) != INTEGER_CST)
+ if (TREE_CODE (format_num_expr) != INTEGER_CST
+ || TREE_INT_CST_HIGH (format_num_expr) != 0)
{
- error ("format string has non-constant operand number");
+ error ("format string has invalid operand number");
continue;
}
argument = TYPE_ARG_TYPES (type);
if (argument)
{
- for (arg_num = 1; ; ++arg_num)
- {
- if (argument == 0 || arg_num == format_num)
- break;
- argument = TREE_CHAIN (argument);
- }
+ for (arg_num = 1; argument != 0 && arg_num != format_num;
+ ++arg_num, argument = TREE_CHAIN (argument))
+ ;
+
if (! argument
|| TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE
|| (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument)))
/* Return the minimum number of bits needed to represent VALUE in a
signed or unsigned type, UNSIGNEDP says which. */
-int
+unsigned int
min_precision (value, unsignedp)
tree value;
int unsignedp;
if (integer_zerop (value))
log = 0;
- else if (TREE_INT_CST_HIGH (value) != 0)
- log = HOST_BITS_PER_WIDE_INT + floor_log2 (TREE_INT_CST_HIGH (value));
else
- log = floor_log2 (TREE_INT_CST_LOW (value));
+ log = tree_floor_log2 (value);
return log + 1 + ! unsignedp;
}
switch (TREE_CODE (expr))
{
- /* It is simpler and generates better code to have only TRUTH_*_EXPR
- or comparison expressions as truth values at this level. */
-#if 0
- case COMPONENT_REF:
- /* A one-bit unsigned bit-field is already acceptable. */
- if (1 == TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (expr, 1)))
- && TREE_UNSIGNED (TREE_OPERAND (expr, 1)))
- return expr;
- break;
-#endif
-
case EQ_EXPR:
- /* It is simpler and generates better code to have only TRUTH_*_EXPR
- or comparison expressions as truth values at this level. */
-#if 0
- if (integer_zerop (TREE_OPERAND (expr, 1)))
- return build_unary_op (TRUTH_NOT_EXPR, TREE_OPERAND (expr, 0), 0);
-#endif
case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
case TRUTH_ANDIF_EXPR:
case TRUTH_ORIF_EXPR:
== TYPE_PRECISION (integer_type_node))))
pedwarn_with_decl (x, "bit-field `%s' type invalid in ANSI C");
- /* Detect and ignore out of range field width. */
+ /* Detect and ignore out of range field width and process valid
+ field widths. */
if (DECL_INITIAL (x))
{
if (tree_int_cst_sgn (DECL_INITIAL (x)) < 0)
- {
- DECL_INITIAL (x) = NULL;
- error_with_decl (x, "negative width in bit-field `%s'");
- }
- else if (TREE_INT_CST_HIGH (DECL_INITIAL (x)) != 0
- || (TREE_INT_CST_LOW (DECL_INITIAL (x))
- > TYPE_PRECISION (TREE_TYPE (x))))
- {
- DECL_INITIAL (x) = NULL;
- pedwarn_with_decl (x, "width of `%s' exceeds its type");
- }
+ error_with_decl (x, "negative width in bit-field `%s'");
+ else if (0 < compare_tree_int (DECL_INITIAL (x),
+ TYPE_PRECISION (TREE_TYPE (x))))
+ pedwarn_with_decl (x, "width of `%s' exceeds its type");
else if (integer_zerop (DECL_INITIAL (x)) && DECL_NAME (x) != 0)
+ error_with_decl (x, "zero width for bit-field `%s'");
+ else
{
- error_with_decl (x, "zero width for bit-field `%s'");
- DECL_INITIAL (x) = NULL;
- }
- }
-
- /* Process valid field width. */
- if (DECL_INITIAL (x))
- {
- register int width = TREE_INT_CST_LOW (DECL_INITIAL (x));
-
- if (TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
- && (width < min_precision (TYPE_MIN_VALUE (TREE_TYPE (x)),
- TREE_UNSIGNED (TREE_TYPE (x)))
- || width < min_precision (TYPE_MAX_VALUE (TREE_TYPE (x)),
- TREE_UNSIGNED (TREE_TYPE (x)))))
- warning_with_decl (x, "`%s' is narrower than values of its type");
-
- DECL_SIZE (x) = bitsize_int (width);
- DECL_BIT_FIELD (x) = DECL_C_BIT_FIELD (x) = 1;
- DECL_INITIAL (x) = NULL;
-
- if (width == 0)
- {
- /* field size 0 => force desired amount of alignment. */
+ /* The test above has assured us that TREE_INT_CST_HIGH is 0. */
+ unsigned HOST_WIDE_INT width
+ = TREE_INT_CST_LOW (DECL_INITIAL (x));
+
+ if (TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
+ && (width < min_precision (TYPE_MIN_VALUE (TREE_TYPE (x)),
+ TREE_UNSIGNED (TREE_TYPE (x)))
+ || (width
+ < min_precision (TYPE_MAX_VALUE (TREE_TYPE (x)),
+ TREE_UNSIGNED (TREE_TYPE (x))))))
+ warning_with_decl (x,
+ "`%s' is narrower than values of its type");
+
+ DECL_SIZE (x) = bitsize_int (width);
+ DECL_BIT_FIELD (x) = DECL_C_BIT_FIELD (x) = 1;
+
+ if (width == 0)
+ {
+ /* field size 0 => force desired amount of alignment. */
#ifdef EMPTY_FIELD_BOUNDARY
- DECL_ALIGN (x) = MAX (DECL_ALIGN (x), EMPTY_FIELD_BOUNDARY);
+ DECL_ALIGN (x) = MAX (DECL_ALIGN (x), EMPTY_FIELD_BOUNDARY);
#endif
#ifdef PCC_BITFIELD_TYPE_MATTERS
- if (PCC_BITFIELD_TYPE_MATTERS)
- DECL_ALIGN (x) = MAX (DECL_ALIGN (x),
- TYPE_ALIGN (TREE_TYPE (x)));
+ if (PCC_BITFIELD_TYPE_MATTERS)
+ DECL_ALIGN (x) = MAX (DECL_ALIGN (x),
+ TYPE_ALIGN (TREE_TYPE (x)));
#endif
+ }
}
}
+
else if (TREE_TYPE (x) != error_mark_node)
{
unsigned int min_align = (DECL_PACKED (x) ? BITS_PER_UNIT
fields which require only BITS_PER_UNIT alignment. */
DECL_ALIGN (x) = MAX (DECL_ALIGN (x), min_align);
}
- }
- /* Now DECL_INITIAL is null on all members. */
+ DECL_INITIAL (x) = 0;
+ }
/* Delete all duplicate fields from the fieldlist */
for (x = fieldlist; x && TREE_CHAIN (x);)
if (warn_larger_than && !DECL_EXTERNAL (fndecl) && TREE_TYPE (fndecl))
{
- register tree ret_type = TREE_TYPE (TREE_TYPE (fndecl));
+ tree ret_type = TREE_TYPE (TREE_TYPE (fndecl));
- if (ret_type)
+ if (ret_type && TREE_CODE (TYPE_SIZE_UNIT (ret_type)) == INTEGER_CST
+ && 0 < compare_tree_int (TYPE_SIZE_UNIT (ret_type),
+ larger_than_size))
{
- register tree ret_type_size = TYPE_SIZE (ret_type);
+ unsigned int size_as_int
+ = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (ret_type));
- if (TREE_CODE (ret_type_size) == INTEGER_CST)
- {
- unsigned units
- = TREE_INT_CST_LOW (ret_type_size) / BITS_PER_UNIT;
-
- if (units > larger_than_size)
- warning_with_decl (fndecl,
- "size of return value of `%s' is %u bytes",
- units);
- }
+ if (compare_tree_int (TYPE_SIZE_UNIT (ret_type), size_as_int) == 0)
+ warning_with_decl (fndecl,
+ "size of return value of `%s' is %u bytes",
+ size_as_int);
+ else
+ warning_with_decl (fndecl,
+ "size of return value of `%s' is larger than %d bytes",
+ larger_than_size);
}
}
if (DECL_SAVED_INSNS (fndecl) == 0 && ! nested)
{
- /* Stop pointing to the local nodes about to be freed. */
- /* But DECL_INITIAL must remain nonzero so we know this
- was an actual function definition. */
- /* For a nested function, this is done in pop_c_function_context. */
- /* If rest_of_compilation set this to 0, leave it 0. */
+ /* Stop pointing to the local nodes about to be freed.
+ But DECL_INITIAL must remain nonzero so we know this
+ was an actual function definition.
+ For a nested function, this is done in pop_c_function_context.
+ If rest_of_compilation set this to 0, leave it 0. */
if (DECL_INITIAL (fndecl) != 0)
DECL_INITIAL (fndecl) = error_mark_node;
+
DECL_ARGUMENTS (fndecl) = 0;
}
\f
/* Iff C is a carriage return, warn about it - if appropriate -
and return nonzero. */
+
static int
whitespace_cr (c)
int c;
it needs to be preserved.
If STRING is non-NULL, then the return value will be ignored, and there
- will be futher calls to handle_pragma_token() in order to handle the rest of
+ will be futher calls to handle_pragma_token in order to handle the rest of
the line containing the #pragma directive. If STRING is NULL, the entire
- line has now been presented to handle_pragma_token() and the return value
+ line has now been presented to handle_pragma_token and the return value
should be zero if the pragma flawed in some way, or if the pragma was not
recognised, and non-zero if it was successfully handled. */
int
handle_pragma_token (string, token)
- const char * string;
+ const char *string;
tree token;
{
static enum pragma_state state = ps_start;
static enum pragma_state type;
#ifdef HANDLE_PRAGMA_WEAK
- static char * name;
- static char * value;
+ static char *name;
+ static char *value;
#endif
#if defined(HANDLE_PRAGMA_PACK) || defined(HANDLE_PRAGMA_PACK_PUSH_POP)
- static int align;
+ static unsigned int align;
#endif
static tree id;
break;
handle_align:
- align = TREE_INT_CST_LOW (token);
- switch (align)
+ switch (tree_log2 (token))
{
+ case 0:
case 1:
case 2:
+ case 3:
case 4:
- case 8:
- case 16:
state = ps_align;
+ align = 1 << tree_log2 (token);
break;
default:
|| TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST)
break;
- if (! ((TREE_INT_CST_LOW (TYPE_MIN_VALUE (d1))
- == TREE_INT_CST_LOW (TYPE_MIN_VALUE (d2)))
- && (TREE_INT_CST_HIGH (TYPE_MIN_VALUE (d1))
- == TREE_INT_CST_HIGH (TYPE_MIN_VALUE (d2)))
- && (TREE_INT_CST_LOW (TYPE_MAX_VALUE (d1))
- == TREE_INT_CST_LOW (TYPE_MAX_VALUE (d2)))
- && (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (d1))
- == TREE_INT_CST_HIGH (TYPE_MAX_VALUE (d2)))))
- val = 0;
+ if (! tree_int_cst_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2))
+ || ! tree_int_cst_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2)))
+ val = 0;
+
break;
}
}
/* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
- an lvalue. */
- /* Do not use STRIP_NOPS here! It will remove conversions from pointer
+ an lvalue.
+
+ Do not use STRIP_NOPS here! It will remove conversions from pointer
to integer and cause infinite recursion. */
while (TREE_CODE (exp) == NON_LVALUE_EXPR
|| (TREE_CODE (exp) == NOP_EXPR
|| (TYPE_PRECISION (type)
>= TYPE_PRECISION (integer_type_node)))
&& TREE_UNSIGNED (type)));
+
return convert (type, exp);
}
if (TREE_CODE (exp) == COMPONENT_REF
- && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1)))
- {
- tree width = DECL_SIZE (TREE_OPERAND (exp, 1));
- HOST_WIDE_INT low = TREE_INT_CST_LOW (width);
-
+ && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1))
/* If it's thinner than an int, promote it like a
C_PROMOTING_INTEGER_TYPE_P, otherwise leave it alone. */
-
- if (low < TYPE_PRECISION (integer_type_node))
- {
- if (flag_traditional && TREE_UNSIGNED (type))
- return convert (unsigned_type_node, exp);
- else
- return convert (integer_type_node, exp);
- }
- }
+ && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)),
+ TYPE_PRECISION (integer_type_node)))
+ return convert (flag_traditional && TREE_UNSIGNED (type)
+ ? unsigned_type_node : integer_type_node,
+ exp);
if (C_PROMOTING_INTEGER_TYPE_P (type))
{
&& (flag_traditional
|| TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
return convert (unsigned_type_node, exp);
+
return convert (integer_type_node, exp);
}
+
if (flag_traditional && !flag_allow_single_precision
&& TYPE_MAIN_VARIANT (type) == float_type_node)
return convert (double_type_node, exp);
+
if (code == VOID_TYPE)
{
error ("void value not ignored as it ought to be");
if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
resultcode = RDIV_EXPR;
else
- {
- /* Although it would be tempting to shorten always here, that
- loses on some targets, since the modulo instruction is
- undefined if the quotient can't be represented in the
- computation mode. We shorten only if unsigned or if
- dividing by something we know != -1. */
- shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
- || (TREE_CODE (op1) == INTEGER_CST
- && (TREE_INT_CST_LOW (op1) != -1
- || TREE_INT_CST_HIGH (op1) != -1)));
- }
+ /* Although it would be tempting to shorten always here, that
+ loses on some targets, since the modulo instruction is
+ undefined if the quotient can't be represented in the
+ computation mode. We shorten only if unsigned or if
+ dividing by something we know != -1. */
+ shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
+ || (TREE_CODE (op1) == INTEGER_CST
+ && ! integer_all_onesp (op1)));
common = 1;
}
break;
only if unsigned or if dividing by something we know != -1. */
shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
|| (TREE_CODE (op1) == INTEGER_CST
- && (TREE_INT_CST_LOW (op1) != -1
- || TREE_INT_CST_HIGH (op1) != -1)));
+ && ! integer_all_onesp (op1)));
common = 1;
}
break;
warning ("right shift count is negative");
else
{
- if (TREE_INT_CST_LOW (op1) | TREE_INT_CST_HIGH (op1))
+ if (! integer_zerop (op1))
short_shift = 1;
- if (TREE_INT_CST_HIGH (op1) != 0
- || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
- >= TYPE_PRECISION (type0)))
+
+ if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
warning ("right shift count >= width of type");
}
}
+
/* Use the type of the value to be shifted.
This is what most traditional C compilers do. */
result_type = type0;
{
if (tree_int_cst_sgn (op1) < 0)
warning ("left shift count is negative");
- else if (TREE_INT_CST_HIGH (op1) != 0
- || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
- >= TYPE_PRECISION (type0)))
+
+ else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
warning ("left shift count >= width of type");
}
+
/* Use the type of the value to be shifted.
This is what most traditional C compilers do. */
result_type = type0;
{
if (tree_int_cst_sgn (op1) < 0)
warning ("shift count is negative");
- else if (TREE_INT_CST_HIGH (op1) != 0
- || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
- >= TYPE_PRECISION (type0)))
+ else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
warning ("shift count >= width of type");
}
+
/* Use the type of the value to be shifted.
This is what most traditional C compilers do. */
result_type = type0;
if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
/* We can shorten only if the shift count is less than the
number of bits in the smaller type size. */
- && TREE_INT_CST_HIGH (op1) == 0
- && TYPE_PRECISION (TREE_TYPE (arg0)) > TREE_INT_CST_LOW (op1)
+ && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
/* If arg is sign-extended and then unsigned-shifted,
we can simulate this with a signed shift in arg's type
only if the extended result is at least twice as wide
it never happens because available widths are 2**N. */
&& (!TREE_UNSIGNED (final_type)
|| unsigned_arg
- || 2 * TYPE_PRECISION (TREE_TYPE (arg0)) <= TYPE_PRECISION (result_type)))
+ || (2 * TYPE_PRECISION (TREE_TYPE (arg0))
+ <= TYPE_PRECISION (result_type))))
{
/* Do an unsigned shift if the operand was zero-extended. */
result_type
|| TREE_CODE (primop1) == INTEGER_CST)
{
tree primop;
- long constant, mask;
+ HOST_WIDE_INT constant, mask;
int unsignedp, bits;
if (TREE_CODE (primop0) == INTEGER_CST)
bits = TYPE_PRECISION (TREE_TYPE (primop));
if (bits < TYPE_PRECISION (result_type)
- && bits < HOST_BITS_PER_LONG && unsignedp)
+ && bits < HOST_BITS_PER_WIDE_INT && unsignedp)
{
- mask = (~0L) << bits;
+ mask = (~ (HOST_WIDE_INT) 0) << bits;
if ((mask & constant) != mask)
warning ("comparison of promoted ~unsigned with constant");
}
TREE_TYPE (inside_init) = type;
if (TYPE_DOMAIN (type) != 0
- && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
- {
- register int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
- size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
+ && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
/* Subtract 1 (or sizeof (wchar_t))
because it's ok to ignore the terminating null char
that is counted in the length of the constant. */
- if (size < TREE_STRING_LENGTH (inside_init)
- - (TYPE_PRECISION (typ1) != TYPE_PRECISION (char_type_node)
- ? TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT
- : 1))
- pedwarn_init ("initializer-string for array of chars is too long");
- }
+ && 0 > compare_tree_int (TYPE_SIZE_UNIT (type),
+ TREE_STRING_LENGTH (inside_init)
+ - ((TYPE_PRECISION (typ1)
+ != TYPE_PRECISION (char_type_node))
+ ? (TYPE_PRECISION (wchar_type_node)
+ / BITS_PER_UNIT)
+ : 1)))
+ pedwarn_init ("initializer-string for array of chars is too long");
+
return inside_init;
}
}
if (TYPE_SIZE (type) == 0
|| TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST
|| (flag_stack_check && ! STACK_CHECK_BUILTIN
- && (TREE_INT_CST_HIGH (TYPE_SIZE (type)) != 0
- || (TREE_INT_CST_LOW (TYPE_SIZE (type))
- > STACK_CHECK_MAX_VAR_SIZE * BITS_PER_UNIT))))
+ && (0 < compare_tree_int (TYPE_SIZE_UNIT (type),
+ STACK_CHECK_MAX_VAR_SIZE))))
{
/* This is a variable-sized object. Make space on the stack
for it. */
+Mon Mar 6 17:52:48 2000 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * actions.c (chill_convert_for_assignment): INDEX is unsigned
+ HOST_WIDE_INT.
+ * ch-tree.h (DECL_NESTING_LEVEL): Use TREE_INT_CST_HIGH since unsigned.
+ * except.c (chill_handle_on_labels): ALTERNATIVE is unsigned.
+ Use compare_tree_int.
+ (expand_goto_except_cleanup): Likewise.
+
2000-03-01 Martin von Loewis <loewis@informatik.hu-berlin.de>
* decl.c (current_function_decl): Move to toplev.c.
{
tree domain_min = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
tree new_list = NULL_TREE;
- long index;
+ unsigned HOST_WIDE_INT index;
tree element;
for (element = TREE_OPERAND (result, 1);
new_list);
break;
case RANGE_EXPR:
- for (index = TREE_INT_CST_LOW (TREE_OPERAND (purpose, 0));
+ for (index = TREE_INT_CST_LOW (TREE_OPERAND (purpose, 0));
index <= TREE_INT_CST_LOW (TREE_OPERAND (purpose, 1));
index++)
new_list = tree_cons (NULL_TREE,
Predefined declarations have level -1; the global scope is level 0.
*/
#define DECL_NESTING_LEVEL(DECL) \
- ((DECL)->decl.vindex ? TREE_INT_CST_LOW((DECL)->decl.vindex) : -1)
+ ((DECL)->decl.vindex ? TREE_INT_CST_HIGH((DECL)->decl.vindex) : -1)
/* Nesting of things that can have an ON-unit attached. */
extern int action_nesting_level;
chill_handle_on_labels (labels)
tree labels;
{
- int alternative = ++current_handler->prev_on_alternative;
+ unsigned int alternative = ++current_handler->prev_on_alternative;
if (pass == 1)
{
tree handler_number = build_int_2 (alternative, 0);
else
{
/* Find handler_number saved in pass 1. */
- tree tmp = current_handler->on_alt_list;
- while (TREE_INT_CST_LOW (TREE_PURPOSE (tmp)) != alternative)
- tmp = TREE_CHAIN (tmp);
+ tree tmp;
+
+ for (tmp = current_handler->on_alt_list;
+ compare_tree_int (TREE_PURPOSE (tmp), alternative) != 0;
+ tmp = TREE_CHAIN (tmp))
+ ;
+
if (expand_exit_needed)
expand_exit_something (), expand_exit_needed = 0;
chill_handle_case_label (TREE_PURPOSE (tmp),
tree last = NULL_TREE;
for ( ; list != NULL_TREE; list = TREE_CHAIN (list))
{
- if (TREE_INT_CST_LOW (TREE_PURPOSE (list)) > label_level)
+ if (compare_tree_int (TREE_PURPOSE (list), label_level) > 0)
last = list;
else
break;
Mon Mar 6 08:46:47 2000 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+ * class.c (dfs_modify_vtables): I is now unsigned.
+ (check_bitfield_decl): Use tree_int_cst_sgn and compare_tree_int.
+ (build_base_field): Add casts of TREE_INT_CST_LOW to HOST_WIDE_INT.
+ * error.c (dump_expr): Cast TREE_INT_CST_HIGH to unsigned.
+ * init.c (build_vec_init): Cast TREE_INT_CST_LOW to HOST_WIDE_INT.
+ * method.c (build_overload_int): Cast TREE_INT_CST_HIGH to unsigned.
+ * typeck.c (build_binary_op, case TRUNC_DIV_EXPR):
+ Call integer_all_onesp.
+ * typeck2.c (process_init_constructor): Use compare_tree_int.
+
* lang-specs.h (as): Don't call if -syntax-only.
2000-03-06 Mark Mitchell <mark@codesourcery.com>
tree overrider;
tree vindex;
tree delta;
- HOST_WIDE_INT i;
+ unsigned HOST_WIDE_INT i;
/* Find the function which originally caused this vtable
entry to be present. */
if (DECL_INITIAL (field))
{
tree w = DECL_INITIAL (field);
- register int width = 0;
/* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs. */
STRIP_NOPS (w);
field);
DECL_INITIAL (field) = NULL_TREE;
}
- else if (width = TREE_INT_CST_LOW (w),
- width < 0)
+ else if (tree_int_cst_sgn (w) < 0)
{
DECL_INITIAL (field) = NULL;
cp_error_at ("negative width in bit-field `%D'", field);
}
- else if (width == 0 && DECL_NAME (field) != 0)
+ else if (integer_zerop (w) && DECL_NAME (field) != 0)
{
DECL_INITIAL (field) = NULL;
cp_error_at ("zero width for bit-field `%D'", field);
}
- else if (width
- > TYPE_PRECISION (long_long_unsigned_type_node))
+ else if (0 < compare_tree_int (w,
+ TYPE_PRECISION
+ (long_long_unsigned_type_node)))
{
/* The backend will dump if you try to use something too
big; avoid that. */
TYPE_PRECISION (long_long_unsigned_type_node));
cp_error_at (" in declaration of `%D'", field);
}
- else if (width > TYPE_PRECISION (type)
+ else if (compare_tree_int (w, TYPE_PRECISION (type)) > 0
&& TREE_CODE (type) != ENUMERAL_TYPE
&& TREE_CODE (type) != BOOLEAN_TYPE)
cp_warning_at ("width of `%D' exceeds its type", field);
else if (TREE_CODE (type) == ENUMERAL_TYPE
- && ((min_precision (TYPE_MIN_VALUE (type),
- TREE_UNSIGNED (type)) > width)
- || (min_precision (TYPE_MAX_VALUE (type),
- TREE_UNSIGNED (type)) > width)))
+ && (0 > compare_tree_int (w,
+ min_precision (TYPE_MIN_VALUE (type),
+ TREE_UNSIGNED (type)))
+ || 0 > compare_tree_int (w,
+ min_precision
+ (TYPE_MAX_VALUE (type),
+ TREE_UNSIGNED (type)))))
cp_warning_at ("`%D' is too small to hold all values of `%#T'",
field, type);
if (DECL_INITIAL (field))
{
DECL_INITIAL (field) = NULL_TREE;
- DECL_SIZE (field) = bitsize_int (width);
+ DECL_SIZE (field) = bitsize_int (TREE_INT_CST_LOW (w));
DECL_BIT_FIELD (field) = 1;
- if (width == 0)
+ if (integer_zerop (w))
{
#ifdef EMPTY_FIELD_BOUNDARY
DECL_ALIGN (field) = MAX (DECL_ALIGN (field),
here. */
*base_align = MAX (*base_align, DECL_ALIGN (decl));
DECL_SIZE (decl)
- = size_int (MAX (TREE_INT_CST_LOW (DECL_SIZE (decl)),
+ = size_int (MAX ((HOST_WIDE_INT) TREE_INT_CST_LOW (DECL_SIZE (decl)),
(int) (*base_align)));
DECL_SIZE_UNIT (decl)
- = size_int (MAX (TREE_INT_CST_LOW (DECL_SIZE_UNIT (decl)),
+ = size_int (MAX (((HOST_WIDE_INT) TREE_INT_CST_LOW
+ (DECL_SIZE_UNIT (decl))),
(int) *base_align / BITS_PER_UNIT));
}
dump_char (TREE_INT_CST_LOW (t));
OB_PUTC ('\'');
}
- else if (TREE_INT_CST_HIGH (t)
+ else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (t)
!= (TREE_INT_CST_LOW (t) >> (HOST_BITS_PER_WIDE_INT - 1)))
{
tree val = t;
- if (TREE_INT_CST_HIGH (val) < 0)
+
+ if (tree_int_cst_sgn (val) < 0)
{
OB_PUTC ('-');
val = build_int_2 (~TREE_INT_CST_LOW (val),
if (from_array
|| (TYPE_NEEDS_CONSTRUCTING (type)
- && !(TREE_CODE (maxindex) == INTEGER_CST
- && num_initialized_elts == TREE_INT_CST_LOW (maxindex) + 1)))
+ && ! (TREE_CODE (maxindex) == INTEGER_CST
+ && (num_initialized_elts
+ == (HOST_WIDE_INT) TREE_INT_CST_LOW (maxindex) + 1))))
{
/* If the ITERATOR is equal to -1, then we don't have to loop;
we've already initialized all the elements. */
/* If the high-order word is not merely a sign-extension of the
low-order word, we must use a special output routine that can
deal with this. */
- if (TREE_INT_CST_HIGH (value)
+ if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (value)
!= (TREE_INT_CST_LOW (value) >> (HOST_BITS_PER_WIDE_INT - 1)))
{
multiple_words_p = 1;
multiple_digits_p = 1;
}
else
- multiple_digits_p = (TREE_INT_CST_LOW (value) > 9
- || TREE_INT_CST_LOW (value) < -9);
+ multiple_digits_p = ((HOST_WIDE_INT) TREE_INT_CST_LOW (value) > 9
+ || (HOST_WIDE_INT) TREE_INT_CST_LOW (value) < -9);
/* If necessary, add a leading underscore. */
if (multiple_digits_p && (flags & mf_use_underscores_around_value))
shorten = ((TREE_CODE (op0) == NOP_EXPR
&& TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
|| (TREE_CODE (op1) == INTEGER_CST
- && (TREE_INT_CST_LOW (op1) != -1
- || TREE_INT_CST_HIGH (op1) != -1)));
+ && ! integer_all_onesp (op1)));
+
common = 1;
}
break;
shorten = ((TREE_CODE (op0) == NOP_EXPR
&& TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
|| (TREE_CODE (op1) == INTEGER_CST
- && (TREE_INT_CST_LOW (op1) != -1
- || TREE_INT_CST_HIGH (op1) != -1)));
+ && ! integer_all_onesp (op1)));
common = 1;
}
break;
{
if (TREE_PURPOSE (tail)
&& (TREE_CODE (TREE_PURPOSE (tail)) != INTEGER_CST
- || TREE_INT_CST_LOW (TREE_PURPOSE (tail)) != i))
+ || compare_tree_int (TREE_PURPOSE (tail), i) != 0))
sorry ("non-trivial labeled initializers");
if (TREE_VALUE (tail) != 0)
tree type;
{
register tree values = TYPE_VALUES (type);
- register HOST_WIDE_INT intval = TREE_INT_CST_LOW (value);
my_friendly_assert (TREE_CODE (type) == ENUMERAL_TYPE, 324);
- while (values
- && TREE_INT_CST_LOW (TREE_VALUE (values)) != intval)
+
+ while (values && ! tree_int_cst_equal (TREE_VALUE (values), value))
values = TREE_CHAIN (values);
+
if (values == NULL_TREE)
{
- char *buf = (char *)oballoc (16 + TYPE_NAME_LENGTH (type));
+ char *buf = (char *) oballoc (16 + TYPE_NAME_LENGTH (type));
/* Value must have been cast. */
sprintf (buf, "(enum %s)%ld",
- TYPE_NAME_STRING (type), (long) intval);
+ TYPE_NAME_STRING (type), (long) TREE_INT_CST_LOW (value));
return buf;
}
return IDENTIFIER_POINTER (TREE_PURPOSE (values));
fprintf (asmfile, HOST_WIDE_INT_PRINT_UNSIGNED,
TREE_INT_CST_LOW (TREE_VALUE (tem)));
else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1
- && TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
+ && (HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
TREE_INT_CST_LOW (TREE_VALUE (tem)));
else
/* is the second argument 2? */
&& TREE_CODE (TREE_VALUE (args)) == INTEGER_CST
- && TREE_INT_CST_LOW (TREE_VALUE (args)) == 2
- && TREE_INT_CST_HIGH (TREE_VALUE (args)) == 0
+ && compare_tree_int (TREE_VALUE (args), 2) == 0
/* Make sure there are no other arguments. */
&& TREE_CHAIN (args) == NULL_TREE)
return is_zeros_p (TREE_OPERAND (exp, 0));
case INTEGER_CST:
- return TREE_INT_CST_LOW (exp) == 0 && TREE_INT_CST_HIGH (exp) == 0;
+ return integer_zerop (exp);
case COMPLEX_CST:
return
{
tree lo_index = TREE_OPERAND (index, 0);
tree hi_index = TREE_OPERAND (index, 1);
+
if (TREE_CODE (lo_index) != INTEGER_CST
|| TREE_CODE (hi_index) != INTEGER_CST)
{
need_to_clear = 1;
break;
}
- this_node_count = TREE_INT_CST_LOW (hi_index)
- - TREE_INT_CST_LOW (lo_index) + 1;
+ this_node_count = (TREE_INT_CST_LOW (hi_index)
+ - TREE_INT_CST_LOW (lo_index) + 1);
}
else
this_node_count = 1;
? nbits != 1
: (TREE_CODE (TREE_VALUE (elt)) != INTEGER_CST
|| TREE_CODE (TREE_PURPOSE (elt)) != INTEGER_CST
- || (TREE_INT_CST_LOW (TREE_VALUE (elt))
- - TREE_INT_CST_LOW (TREE_PURPOSE (elt)) + 1
+ || ((HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_VALUE (elt))
+ - (HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_PURPOSE (elt)) + 1
!= nbits))))
clear_storage (target, expr_size (exp),
TYPE_ALIGN (type) / BITS_PER_UNIT);
/* If the RHS and field are a constant size and the size of the
RHS isn't the same size as the bitfield, we must use bitfield
operations. */
- || ((bitsize >= 0
- && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) == INTEGER_CST)
- && (TREE_INT_CST_HIGH (TYPE_SIZE (TREE_TYPE (exp))) != 0
- || TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp))) != bitsize)))
+ || (bitsize >= 0
+ && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) == INTEGER_CST
+ && compare_tree_int (TYPE_SIZE (TREE_TYPE (exp)), bitsize) != 0))
{
rtx temp = expand_expr (exp, NULL_RTX, VOIDmode, 0);
case INTEGER_CST:
return immed_double_const (TREE_INT_CST_LOW (exp),
- TREE_INT_CST_HIGH (exp),
- mode);
+ TREE_INT_CST_HIGH (exp), mode);
case CONST_DECL:
return expand_expr (DECL_INITIAL (exp), target, VOIDmode,
&& ((mode == BLKmode
&& ! (target != 0 && safe_from_p (target, exp, 1)))
|| TREE_ADDRESSABLE (exp)
- || (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
- && (!MOVE_BY_PIECES_P
- (TREE_INT_CST_LOW (TYPE_SIZE (type))/BITS_PER_UNIT,
+ || (TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
+ && TREE_INT_CST_HIGH (TYPE_SIZE_UNIT (type)) == 0
+ && (! MOVE_BY_PIECES_P
+ (TREE_INT_CST_LOW (TYPE_SIZE_UNIT (type)),
TYPE_ALIGN (type) / BITS_PER_UNIT))
&& ! mostly_zeros_p (exp))))
|| (modifier == EXPAND_INITIALIZER && TREE_CONSTANT (exp)))
tree exp2;
tree index;
tree string = string_constant (exp1, &index);
- int i;
/* Try to optimize reads from const strings. */
if (string
&& TREE_CODE (string) == STRING_CST
&& TREE_CODE (index) == INTEGER_CST
- && !TREE_INT_CST_HIGH (index)
- && (i = TREE_INT_CST_LOW (index)) < TREE_STRING_LENGTH (string)
+ && compare_tree_int (index, TREE_STRING_LENGTH (string)) < 0
&& GET_MODE_CLASS (mode) == MODE_INT
&& GET_MODE_SIZE (mode) == 1
&& modifier != EXPAND_MEMORY_USE_WO)
- return GEN_INT (TREE_STRING_POINTER (string)[i]);
+ return
+ GEN_INT (TREE_STRING_POINTER (string)[TREE_INT_CST_LOW (index)]);
op0 = expand_expr (exp1, NULL_RTX, VOIDmode, EXPAND_SUM);
op0 = memory_address (mode, op0);
if (TREE_CODE (array) == STRING_CST
&& TREE_CODE (index) == INTEGER_CST
- && !TREE_INT_CST_HIGH (index)
- && (i = TREE_INT_CST_LOW (index)) < TREE_STRING_LENGTH (array)
+ && compare_tree_int (index, TREE_STRING_LENGTH (array)) < 0
&& GET_MODE_CLASS (mode) == MODE_INT
&& GET_MODE_SIZE (mode) == 1)
- return GEN_INT (TREE_STRING_POINTER (array)[i]);
+ return
+ GEN_INT (TREE_STRING_POINTER (array)[TREE_INT_CST_LOW (index)]);
/* If this is a constant index into a constant array,
just get the value from the array. Handle both the cases when
we have an explicit constructor and when our operand is a variable
that was declared const. */
- if (TREE_CODE (array) == CONSTRUCTOR && ! TREE_SIDE_EFFECTS (array))
+ if (TREE_CODE (array) == CONSTRUCTOR && ! TREE_SIDE_EFFECTS (array)
+ && TREE_CODE (index) == INTEGER_CST
+ && 0 > compare_tree_int (index,
+ list_length (CONSTRUCTOR_ELTS
+ (TREE_OPERAND (exp, 0)))))
{
- if (TREE_CODE (index) == INTEGER_CST
- && TREE_INT_CST_HIGH (index) == 0)
- {
- tree elem = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0));
-
- i = TREE_INT_CST_LOW (index);
- while (elem && i--)
- elem = TREE_CHAIN (elem);
- if (elem)
- return expand_expr (fold (TREE_VALUE (elem)), target,
- tmode, ro_modifier);
- }
+ tree elem;
+
+ for (elem = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0)),
+ i = TREE_INT_CST_LOW (index);
+ elem != 0 && i != 0; i--, elem = TREE_CHAIN (elem))
+ ;
+
+ if (elem)
+ return expand_expr (fold (TREE_VALUE (elem)), target,
+ tmode, ro_modifier);
}
else if (optimize >= 1
{
tree init = DECL_INITIAL (array);
- i = TREE_INT_CST_LOW (index);
if (TREE_CODE (init) == CONSTRUCTOR)
{
tree elem = CONSTRUCTOR_ELTS (init);
- while (elem
- && !tree_int_cst_equal (TREE_PURPOSE (elem), index))
- elem = TREE_CHAIN (elem);
+ for (elem = CONSTRUCTOR_ELTS (init);
+ ! tree_int_cst_equal (TREE_PURPOSE (elem), index);
+ elem = TREE_CHAIN (elem))
+ ;
+
if (elem)
return expand_expr (fold (TREE_VALUE (elem)), target,
tmode, ro_modifier);
}
else if (TREE_CODE (init) == STRING_CST
- && TREE_INT_CST_HIGH (index) == 0
- && (TREE_INT_CST_LOW (index)
- < TREE_STRING_LENGTH (init)))
+ && 0 > compare_tree_int (index,
+ TREE_STRING_LENGTH (init)))
return (GEN_INT
(TREE_STRING_POINTER
(init)[TREE_INT_CST_LOW (index)]));
|| ((bitsize >= 0
&& (TREE_CODE (TYPE_SIZE (TREE_TYPE (exp)))
== INTEGER_CST)
- && ((TREE_INT_CST_HIGH (TYPE_SIZE (TREE_TYPE (exp)))
- != 0)
- || (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp)))
- != bitsize))))))
+ && 0 != compare_tree_int (TYPE_SIZE (TREE_TYPE (exp)),
+ bitsize)))))
|| (modifier != EXPAND_CONST_ADDRESS
&& modifier != EXPAND_INITIALIZER
&& mode == BLKmode
|| TREE_CODE (rhs) == BIT_AND_EXPR)
&& TREE_OPERAND (rhs, 0) == lhs
&& TREE_CODE (TREE_OPERAND (rhs, 1)) == COMPONENT_REF
- && TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (lhs, 1))) == 1
- && TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (TREE_OPERAND (rhs, 1), 1))) == 1)
+ && integer_onep (DECL_SIZE (TREE_OPERAND (lhs, 1)))
+ && integer_onep (DECL_SIZE (TREE_OPERAND (TREE_OPERAND (rhs, 1), 1))))
{
rtx label = gen_label_rtx ();
we have an explicit constructor and when our operand is a variable
that was declared const. */
- if (TREE_CODE (array) == CONSTRUCTOR && ! TREE_SIDE_EFFECTS (array))
+ if (TREE_CODE (array) == CONSTRUCTOR && ! TREE_SIDE_EFFECTS (array)
+ && 0 > compare_tree_int (index,
+ list_length (CONSTRUCTOR_ELTS
+ (TREE_OPERAND (exp, 0)))))
{
- if (TREE_CODE (index) == INTEGER_CST
- && TREE_INT_CST_HIGH (index) == 0)
- {
- tree elem = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0));
-
- i = TREE_INT_CST_LOW (index);
- while (elem && i--)
- elem = TREE_CHAIN (elem);
- if (elem)
- return expand_expr_unaligned (fold (TREE_VALUE (elem)),
- palign);
- }
+ tree elem;
+
+ for (elem = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0)),
+ i = TREE_INT_CST_LOW (index);
+ elem != 0 && i != 0; i--, elem = TREE_CHAIN (elem))
+ ;
+
+ if (elem)
+ return expand_expr_unaligned (fold (TREE_VALUE (elem)), palign);
}
else if (optimize >= 1
{
tree init = DECL_INITIAL (array);
- i = TREE_INT_CST_LOW (index);
if (TREE_CODE (init) == CONSTRUCTOR)
{
- tree elem = CONSTRUCTOR_ELTS (init);
+ tree elem;
+
+ for (elem = CONSTRUCTOR_ELTS (init);
+ ! tree_int_cst_equal (TREE_PURPOSE (elem), index);
+ elem = TREE_CHAIN (elem))
+ ;
- while (elem
- && !tree_int_cst_equal (TREE_PURPOSE (elem), index))
- elem = TREE_CHAIN (elem);
if (elem)
return expand_expr_unaligned (fold (TREE_VALUE (elem)),
palign);
if (! SLOW_BYTE_ACCESS
&& TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
&& TYPE_PRECISION (TREE_TYPE (exp)) <= HOST_BITS_PER_WIDE_INT
- && (i = floor_log2 (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)))) >= 0
+ && (i = tree_floor_log2 (TREE_OPERAND (exp, 1))) >= 0
&& (mode = mode_for_size (i + 1, MODE_INT, 0)) != BLKmode
&& (type = type_for_mode (mode, 1)) != 0
&& TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))
if (TREE_CODE (inner) == RSHIFT_EXPR
&& TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST
&& TREE_INT_CST_HIGH (TREE_OPERAND (inner, 1)) == 0
- && (bitnum + TREE_INT_CST_LOW (TREE_OPERAND (inner, 1))
- < TYPE_PRECISION (type)))
+ && bitnum < TYPE_PRECISION (type)
+ && 0 > compare_tree_int (TREE_OPERAND (inner, 1),
+ bitnum - TYPE_PRECISION (type)))
{
bitnum += TREE_INT_CST_LOW (TREE_OPERAND (inner, 1));
inner = TREE_OPERAND (inner, 0);
+Mon Mar 6 18:05:19 2000 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * com.c (ffecom_f2c_set_lio_code_): Use compare_tree_int.
+ (ffecom_sym_transform_, ffecom_transform_common_): Likewise.
+ (ffecom_transform_equiv_): Likewise.
+
Mon Mar 6 13:01:19 2000 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
* ansify.c (die_unless): Don't use ANSI string concatenation.
tree t;
for (j = 0; ((size_t) j) < ARRAY_SIZE (ffecom_tree_type[0]); ++j)
- if (((t = ffecom_tree_type[bt][j]) != NULL_TREE)
- && (TREE_INT_CST_LOW (TYPE_SIZE (t)) == size))
+ if ((t = ffecom_tree_type[bt][j]) != NULL_TREE
+ && compare_tree_int (TYPE_SIZE (t), size) == 0)
{
assert (code != -1);
ffecom_f2c_typecode_[bt][j] = code;
if (st != NULL && DECL_SIZE (t) != error_mark_node)
{
assert (TREE_CODE (DECL_SIZE_UNIT (t)) == INTEGER_CST);
- assert (TREE_INT_CST_HIGH (DECL_SIZE_UNIT (t)) == 0);
- assert (TREE_INT_CST_LOW (DECL_SIZE_UNIT (t))
- == ffestorag_size (st));
+ assert (0 == compare_tree_int (DECL_SIZE_UNIT (t),
+ ffestorag_size (st)));
}
resume_momentary (yes);
{
assert (DECL_SIZE_UNIT (cbt) != NULL_TREE);
assert (TREE_CODE (DECL_SIZE_UNIT (cbt)) == INTEGER_CST);
- assert (TREE_INT_CST_HIGH (DECL_SIZE_UNIT (cbt)) == 0);
- assert (TREE_INT_CST_LOW (DECL_SIZE_UNIT (cbt))
- == ffeglobal_common_size (g) + ffeglobal_common_pad (g));
+ assert (0 == compare_tree_int (DECL_SIZE_UNIT (cbt),
+ (ffeglobal_common_size (g)
+ + ffeglobal_common_pad (g))));
}
ffeglobal_set_hook (g, cbt);
{
assert (TREE_CODE (DECL_SIZE_UNIT (eqt)) == INTEGER_CST);
- assert (TREE_INT_CST_HIGH (DECL_SIZE_UNIT (eqt)) == 0);
- assert (TREE_INT_CST_LOW (DECL_SIZE_UNIT (eqt))
- == ffestorag_size (eqst) + ffestorag_modulo (eqst));
+ assert (0 == compare_tree_int (DECL_SIZE_UNIT (eqt),
+ (ffestorag_size (eqst)
+ + ffestorag_modulo (eqst))));
}
ffestorag_set_hook (eqst, eqt);
#include "ggc.h"
static void encode PARAMS ((HOST_WIDE_INT *,
- HOST_WIDE_INT, HOST_WIDE_INT));
+ unsigned HOST_WIDE_INT,
+ HOST_WIDE_INT));
static void decode PARAMS ((HOST_WIDE_INT *,
- HOST_WIDE_INT *, HOST_WIDE_INT *));
-int div_and_round_double PARAMS ((enum tree_code, int, HOST_WIDE_INT,
- HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT, HOST_WIDE_INT *,
- HOST_WIDE_INT *, HOST_WIDE_INT *,
+ unsigned HOST_WIDE_INT *,
HOST_WIDE_INT *));
static tree negate_expr PARAMS ((tree));
static tree split_tree PARAMS ((tree, enum tree_code, tree *, tree *,
static void
encode (words, low, hi)
HOST_WIDE_INT *words;
- HOST_WIDE_INT low, hi;
+ unsigned HOST_WIDE_INT low;
+ HOST_WIDE_INT hi;
{
words[0] = LOWPART (low);
words[1] = HIGHPART (low);
static void
decode (words, low, hi)
HOST_WIDE_INT *words;
- HOST_WIDE_INT *low, *hi;
+ unsigned HOST_WIDE_INT *low;
+ HOST_WIDE_INT *hi;
{
*low = words[0] + words[1] * BASE;
*hi = words[2] + words[3] * BASE;
tree t;
int overflow;
{
- HOST_WIDE_INT low, high;
- register int prec;
+ unsigned HOST_WIDE_INT low;
+ HOST_WIDE_INT high;
+ unsigned int prec;
if (TREE_CODE (t) == REAL_CST)
{
{
TREE_INT_CST_HIGH (t) = 0;
if (prec < HOST_BITS_PER_WIDE_INT)
- TREE_INT_CST_LOW (t) &= ~((HOST_WIDE_INT) (-1) << prec);
+ TREE_INT_CST_LOW (t) &= ~((unsigned HOST_WIDE_INT) (-1) << prec);
}
/* Unsigned types do not suffer sign extension or overflow. */
/* If the value's sign bit is set, extend the sign. */
if (prec != 2 * HOST_BITS_PER_WIDE_INT
&& (prec > HOST_BITS_PER_WIDE_INT
- ? (TREE_INT_CST_HIGH (t)
- & ((HOST_WIDE_INT) 1 << (prec - HOST_BITS_PER_WIDE_INT - 1)))
- : TREE_INT_CST_LOW (t) & ((HOST_WIDE_INT) 1 << (prec - 1))))
+ ? 0 != (TREE_INT_CST_HIGH (t)
+ & ((HOST_WIDE_INT) 1
+ << (prec - HOST_BITS_PER_WIDE_INT - 1)))
+ : 0 != (TREE_INT_CST_LOW (t)
+ & ((unsigned HOST_WIDE_INT) 1 << (prec - 1)))))
{
/* Value is negative:
set to 1 all the bits that are outside this type's precision. */
{
TREE_INT_CST_HIGH (t) = -1;
if (prec < HOST_BITS_PER_WIDE_INT)
- TREE_INT_CST_LOW (t) |= ((HOST_WIDE_INT) (-1) << prec);
+ TREE_INT_CST_LOW (t) |= ((unsigned HOST_WIDE_INT) (-1) << prec);
}
}
int
add_double (l1, h1, l2, h2, lv, hv)
- HOST_WIDE_INT l1, h1, l2, h2;
- HOST_WIDE_INT *lv, *hv;
+ unsigned HOST_WIDE_INT l1, l2;
+ HOST_WIDE_INT h1, h2;
+ unsigned HOST_WIDE_INT *lv;
+ HOST_WIDE_INT *hv;
{
- HOST_WIDE_INT l, h;
+ unsigned HOST_WIDE_INT l;
+ HOST_WIDE_INT h;
l = l1 + l2;
- h = h1 + h2 + ((unsigned HOST_WIDE_INT) l < (unsigned HOST_WIDE_INT) l1);
+ h = h1 + h2 + (l < l1);
*lv = l;
*hv = h;
int
neg_double (l1, h1, lv, hv)
- HOST_WIDE_INT l1, h1;
- HOST_WIDE_INT *lv, *hv;
+ unsigned HOST_WIDE_INT l1;
+ HOST_WIDE_INT h1;
+ unsigned HOST_WIDE_INT *lv;
+ HOST_WIDE_INT *hv;
{
if (l1 == 0)
{
int
mul_double (l1, h1, l2, h2, lv, hv)
- HOST_WIDE_INT l1, h1, l2, h2;
- HOST_WIDE_INT *lv, *hv;
+ unsigned HOST_WIDE_INT l1, l2;
+ HOST_WIDE_INT h1, h2;
+ unsigned HOST_WIDE_INT *lv;
+ HOST_WIDE_INT *hv;
{
HOST_WIDE_INT arg1[4];
HOST_WIDE_INT arg2[4];
HOST_WIDE_INT prod[4 * 2];
register unsigned HOST_WIDE_INT carry;
register int i, j, k;
- HOST_WIDE_INT toplow, tophigh, neglow, neghigh;
+ unsigned HOST_WIDE_INT toplow, neglow;
+ HOST_WIDE_INT tophigh, neghigh;
encode (arg1, l1, h1);
encode (arg2, l2, h2);
void
lshift_double (l1, h1, count, prec, lv, hv, arith)
- HOST_WIDE_INT l1, h1, count;
- int prec;
- HOST_WIDE_INT *lv, *hv;
+ unsigned HOST_WIDE_INT l1;
+ HOST_WIDE_INT h1, count;
+ unsigned int prec;
+ unsigned HOST_WIDE_INT *lv;
+ HOST_WIDE_INT *hv;
int arith;
{
if (count < 0)
}
else if (count >= HOST_BITS_PER_WIDE_INT)
{
- *hv = (unsigned HOST_WIDE_INT) l1 << (count - HOST_BITS_PER_WIDE_INT);
+ *hv = l1 << (count - HOST_BITS_PER_WIDE_INT);
*lv = 0;
}
else
{
*hv = (((unsigned HOST_WIDE_INT) h1 << count)
- | ((unsigned HOST_WIDE_INT) l1 >> (HOST_BITS_PER_WIDE_INT - count - 1) >> 1));
- *lv = (unsigned HOST_WIDE_INT) l1 << count;
+ | (l1 >> (HOST_BITS_PER_WIDE_INT - count - 1) >> 1));
+ *lv = l1 << count;
}
}
void
rshift_double (l1, h1, count, prec, lv, hv, arith)
- HOST_WIDE_INT l1, h1, count;
- int prec ATTRIBUTE_UNUSED;
- HOST_WIDE_INT *lv, *hv;
+ unsigned HOST_WIDE_INT l1;
+ HOST_WIDE_INT h1, count;
+ unsigned int prec ATTRIBUTE_UNUSED;
+ unsigned HOST_WIDE_INT *lv;
+ HOST_WIDE_INT *hv;
int arith;
{
unsigned HOST_WIDE_INT signmask;
+
signmask = (arith
? -((unsigned HOST_WIDE_INT) h1 >> (HOST_BITS_PER_WIDE_INT - 1))
: 0);
}
else
{
- *lv = (((unsigned HOST_WIDE_INT) l1 >> count)
+ *lv = ((l1 >> count)
| ((unsigned HOST_WIDE_INT) h1 << (HOST_BITS_PER_WIDE_INT - count - 1) << 1));
*hv = ((signmask << (HOST_BITS_PER_WIDE_INT - count))
| ((unsigned HOST_WIDE_INT) h1 >> count));
void
lrotate_double (l1, h1, count, prec, lv, hv)
- HOST_WIDE_INT l1, h1, count;
- int prec;
- HOST_WIDE_INT *lv, *hv;
+ unsigned HOST_WIDE_INT l1;
+ HOST_WIDE_INT h1, count;
+ unsigned int prec;
+ unsigned HOST_WIDE_INT *lv;
+ HOST_WIDE_INT *hv;
{
- HOST_WIDE_INT s1l, s1h, s2l, s2h;
+ unsigned HOST_WIDE_INT s1l, s2l;
+ HOST_WIDE_INT s1h, s2h;
count %= prec;
if (count < 0)
void
rrotate_double (l1, h1, count, prec, lv, hv)
- HOST_WIDE_INT l1, h1, count;
- int prec;
- HOST_WIDE_INT *lv, *hv;
+ unsigned HOST_WIDE_INT l1;
+ HOST_WIDE_INT h1, count;
+ unsigned int prec;
+ unsigned HOST_WIDE_INT *lv;
+ HOST_WIDE_INT *hv;
{
- HOST_WIDE_INT s1l, s1h, s2l, s2h;
+ unsigned HOST_WIDE_INT s1l, s2l;
+ HOST_WIDE_INT s1h, s2h;
count %= prec;
if (count < 0)
lquo, hquo, lrem, hrem)
enum tree_code code;
int uns;
- HOST_WIDE_INT lnum_orig, hnum_orig; /* num == numerator == dividend */
- HOST_WIDE_INT lden_orig, hden_orig; /* den == denominator == divisor */
- HOST_WIDE_INT *lquo, *hquo, *lrem, *hrem;
+ unsigned HOST_WIDE_INT lnum_orig; /* num == numerator == dividend */
+ HOST_WIDE_INT hnum_orig;
+ unsigned HOST_WIDE_INT lden_orig; /* den == denominator == divisor */
+ HOST_WIDE_INT hden_orig;
+ unsigned HOST_WIDE_INT *lquo, *lrem;
+ HOST_WIDE_INT *hquo, *hrem;
{
int quo_neg = 0;
HOST_WIDE_INT num[4 + 1]; /* extra element for scaling. */
HOST_WIDE_INT den[4], quo[4];
register int i, j;
unsigned HOST_WIDE_INT work;
- register unsigned HOST_WIDE_INT carry = 0;
- HOST_WIDE_INT lnum = lnum_orig;
+ unsigned HOST_WIDE_INT carry = 0;
+ unsigned HOST_WIDE_INT lnum = lnum_orig;
HOST_WIDE_INT hnum = hnum_orig;
- HOST_WIDE_INT lden = lden_orig;
+ unsigned HOST_WIDE_INT lden = lden_orig;
HOST_WIDE_INT hden = hden_orig;
int overflow = 0;
- if ((hden == 0) && (lden == 0))
+ if (hden == 0 && lden == 0)
overflow = 1, lden = 1;
/* calculate quotient sign and convert operands to unsigned. */
{
quo_neg = ~ quo_neg;
/* (minimum integer) / (-1) is the only overflow case. */
- if (neg_double (lnum, hnum, &lnum, &hnum) && (lden & hden) == -1)
+ if (neg_double (lnum, hnum, &lnum, &hnum)
+ && ((HOST_WIDE_INT) lden & hden) == -1)
overflow = 1;
}
if (hden < 0)
{ /* single precision */
*hquo = *hrem = 0;
/* This unsigned division rounds toward zero. */
- *lquo = lnum / (unsigned HOST_WIDE_INT) lden;
+ *lquo = lnum / lden;
goto finish_up;
}
encode (den, lden, hden);
/* Special code for when the divisor < BASE. */
- if (hden == 0 && lden < (HOST_WIDE_INT) BASE)
+ if (hden == 0 && lden < (unsigned HOST_WIDE_INT) BASE)
{
/* hnum != 0 already checked. */
for (i = 4 - 1; i >= 0; i--)
{
work = num[i] + carry * BASE;
- quo[i] = work / (unsigned HOST_WIDE_INT) lden;
- carry = work % (unsigned HOST_WIDE_INT) lden;
+ quo[i] = work / lden;
+ carry = work % lden;
}
}
else
{
/* Full double precision division,
with thanks to Don Knuth's "Seminumerical Algorithms". */
- int num_hi_sig, den_hi_sig;
- unsigned HOST_WIDE_INT quo_est, scale;
-
- /* Find the highest non-zero divisor digit. */
- for (i = 4 - 1; ; i--)
- if (den[i] != 0) {
- den_hi_sig = i;
- break;
- }
-
- /* Insure that the first digit of the divisor is at least BASE/2.
- This is required by the quotient digit estimation algorithm. */
-
- scale = BASE / (den[den_hi_sig] + 1);
- if (scale > 1) { /* scale divisor and dividend */
- carry = 0;
- for (i = 0; i <= 4 - 1; i++) {
- work = (num[i] * scale) + carry;
- num[i] = LOWPART (work);
- carry = HIGHPART (work);
- } num[4] = carry;
- carry = 0;
- for (i = 0; i <= 4 - 1; i++) {
- work = (den[i] * scale) + carry;
- den[i] = LOWPART (work);
- carry = HIGHPART (work);
- if (den[i] != 0) den_hi_sig = i;
- }
- }
+ int num_hi_sig, den_hi_sig;
+ unsigned HOST_WIDE_INT quo_est, scale;
- num_hi_sig = 4;
+ /* Find the highest non-zero divisor digit. */
+ for (i = 4 - 1; ; i--)
+ if (den[i] != 0) {
+ den_hi_sig = i;
+ break;
+ }
- /* Main loop */
- for (i = num_hi_sig - den_hi_sig - 1; i >= 0; i--) {
- /* guess the next quotient digit, quo_est, by dividing the first
- two remaining dividend digits by the high order quotient digit.
- quo_est is never low and is at most 2 high. */
- unsigned HOST_WIDE_INT tmp;
+ /* Insure that the first digit of the divisor is at least BASE/2.
+ This is required by the quotient digit estimation algorithm. */
- num_hi_sig = i + den_hi_sig + 1;
- work = num[num_hi_sig] * BASE + num[num_hi_sig - 1];
- if (num[num_hi_sig] != den[den_hi_sig])
- quo_est = work / den[den_hi_sig];
- else
- quo_est = BASE - 1;
+ scale = BASE / (den[den_hi_sig] + 1);
+ if (scale > 1)
+ { /* scale divisor and dividend */
+ carry = 0;
+ for (i = 0; i <= 4 - 1; i++)
+ {
+ work = (num[i] * scale) + carry;
+ num[i] = LOWPART (work);
+ carry = HIGHPART (work);
+ }
- /* refine quo_est so it's usually correct, and at most one high. */
- tmp = work - quo_est * den[den_hi_sig];
- if (tmp < BASE
- && den[den_hi_sig - 1] * quo_est > (tmp * BASE + num[num_hi_sig - 2]))
- quo_est--;
+ num[4] = carry;
+ carry = 0;
+ for (i = 0; i <= 4 - 1; i++)
+ {
+ work = (den[i] * scale) + carry;
+ den[i] = LOWPART (work);
+ carry = HIGHPART (work);
+ if (den[i] != 0) den_hi_sig = i;
+ }
+ }
- /* Try QUO_EST as the quotient digit, by multiplying the
- divisor by QUO_EST and subtracting from the remaining dividend.
- Keep in mind that QUO_EST is the I - 1st digit. */
+ num_hi_sig = 4;
- carry = 0;
- for (j = 0; j <= den_hi_sig; j++)
+ /* Main loop */
+ for (i = num_hi_sig - den_hi_sig - 1; i >= 0; i--)
{
- work = quo_est * den[j] + carry;
- carry = HIGHPART (work);
- work = num[i + j] - LOWPART (work);
- num[i + j] = LOWPART (work);
- carry += HIGHPART (work) != 0;
- }
+ /* Guess the next quotient digit, quo_est, by dividing the first
+ two remaining dividend digits by the high order quotient digit.
+ quo_est is never low and is at most 2 high. */
+ unsigned HOST_WIDE_INT tmp;
+
+ num_hi_sig = i + den_hi_sig + 1;
+ work = num[num_hi_sig] * BASE + num[num_hi_sig - 1];
+ if (num[num_hi_sig] != den[den_hi_sig])
+ quo_est = work / den[den_hi_sig];
+ else
+ quo_est = BASE - 1;
- /* if quo_est was high by one, then num[i] went negative and
- we need to correct things. */
+ /* Refine quo_est so it's usually correct, and at most one high. */
+ tmp = work - quo_est * den[den_hi_sig];
+ if (tmp < BASE
+ && (den[den_hi_sig - 1] * quo_est
+ > (tmp * BASE + num[num_hi_sig - 2])))
+ quo_est--;
- if (num[num_hi_sig] < carry)
- {
- quo_est--;
- carry = 0; /* add divisor back in */
+ /* Try QUO_EST as the quotient digit, by multiplying the
+ divisor by QUO_EST and subtracting from the remaining dividend.
+ Keep in mind that QUO_EST is the I - 1st digit. */
+
+ carry = 0;
for (j = 0; j <= den_hi_sig; j++)
{
- work = num[i + j] + den[j] + carry;
+ work = quo_est * den[j] + carry;
carry = HIGHPART (work);
+ work = num[i + j] - LOWPART (work);
num[i + j] = LOWPART (work);
+ carry += HIGHPART (work) != 0;
}
- num [num_hi_sig] += carry;
- }
- /* store the quotient digit. */
- quo[i] = quo_est;
+ /* If quo_est was high by one, then num[i] went negative and
+ we need to correct things. */
+ if (num[num_hi_sig] < carry)
+ {
+ quo_est--;
+ carry = 0; /* add divisor back in */
+ for (j = 0; j <= den_hi_sig; j++)
+ {
+ work = num[i + j] + den[j] + carry;
+ carry = HIGHPART (work);
+ num[i + j] = LOWPART (work);
+ }
+
+ num [num_hi_sig] += carry;
+ }
+
+ /* Store the quotient digit. */
+ quo[i] = quo_est;
+ }
}
- }
decode (quo, lquo, hquo);
add_double (*lquo, *hquo, (HOST_WIDE_INT) -1, (HOST_WIDE_INT) -1,
lquo, hquo);
}
- else return overflow;
+ else
+ return overflow;
break;
case CEIL_DIV_EXPR:
add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
lquo, hquo);
}
- else return overflow;
+ else
+ return overflow;
break;
case ROUND_DIV_EXPR:
case ROUND_MOD_EXPR: /* round to closest integer */
{
- HOST_WIDE_INT labs_rem = *lrem, habs_rem = *hrem;
- HOST_WIDE_INT labs_den = lden, habs_den = hden, ltwice, htwice;
-
- /* get absolute values */
- if (*hrem < 0) neg_double (*lrem, *hrem, &labs_rem, &habs_rem);
- if (hden < 0) neg_double (lden, hden, &labs_den, &habs_den);
-
- /* if (2 * abs (lrem) >= abs (lden)) */
+ unsigned HOST_WIDE_INT labs_rem = *lrem;
+ HOST_WIDE_INT habs_rem = *hrem;
+ unsigned HOST_WIDE_INT labs_den = lden, ltwice;
+ HOST_WIDE_INT habs_den = hden, htwice;
+
+ /* Get absolute values */
+ if (*hrem < 0)
+ neg_double (*lrem, *hrem, &labs_rem, &habs_rem);
+ if (hden < 0)
+ neg_double (lden, hden, &labs_den, &habs_den);
+
+ /* If (2 * abs (lrem) >= abs (lden)) */
mul_double ((HOST_WIDE_INT) 2, (HOST_WIDE_INT) 0,
labs_rem, habs_rem, <wice, &htwice);
+
if (((unsigned HOST_WIDE_INT) habs_den
< (unsigned HOST_WIDE_INT) htwice)
|| (((unsigned HOST_WIDE_INT) habs_den
== (unsigned HOST_WIDE_INT) htwice)
- && ((HOST_WIDE_INT unsigned) labs_den
- < (unsigned HOST_WIDE_INT) ltwice)))
+ && (labs_den < ltwice)))
{
if (*hquo < 0)
/* quo = quo - 1; */
add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
lquo, hquo);
}
- else return overflow;
+ else
+ return overflow;
}
break;
register tree arg1, arg2;
int notrunc, forsize;
{
- HOST_WIDE_INT int1l, int1h, int2l, int2h;
- HOST_WIDE_INT low, hi;
- HOST_WIDE_INT garbagel, garbageh;
+ unsigned HOST_WIDE_INT int1l, int2l;
+ HOST_WIDE_INT int1h, int2h;
+ unsigned HOST_WIDE_INT low;
+ HOST_WIDE_INT hi;
+ unsigned HOST_WIDE_INT garbagel;
+ HOST_WIDE_INT garbageh;
register tree t;
int uns = TREE_UNSIGNED (TREE_TYPE (arg1));
int overflow = 0;
case FLOOR_DIV_EXPR: case CEIL_DIV_EXPR:
case EXACT_DIV_EXPR:
/* This is a shortcut for a common special case. */
- if (int2h == 0 && int2l > 0
+ if (int2h == 0 && (HOST_WIDE_INT) int2l > 0
&& ! TREE_CONSTANT_OVERFLOW (arg1)
&& ! TREE_CONSTANT_OVERFLOW (arg2)
- && int1h == 0 && int1l >= 0)
+ && int1h == 0 && (HOST_WIDE_INT) int1l >= 0)
{
if (code == CEIL_DIV_EXPR)
int1l += int2l - 1;
+
low = int1l / int2l, hi = 0;
break;
}
case TRUNC_MOD_EXPR:
case FLOOR_MOD_EXPR: case CEIL_MOD_EXPR:
/* This is a shortcut for a common special case. */
- if (int2h == 0 && int2l > 0
+ if (int2h == 0 && (HOST_WIDE_INT) int2l > 0
&& ! TREE_CONSTANT_OVERFLOW (arg1)
&& ! TREE_CONSTANT_OVERFLOW (arg2)
- && int1h == 0 && int1l >= 0)
+ && int1h == 0 && (HOST_WIDE_INT) int1l >= 0)
{
if (code == CEIL_MOD_EXPR)
int1l += int2l - 1;
< (unsigned HOST_WIDE_INT) int2h)
|| (((unsigned HOST_WIDE_INT) int1h
== (unsigned HOST_WIDE_INT) int2h)
- && ((unsigned HOST_WIDE_INT) int1l
- < (unsigned HOST_WIDE_INT) int2l)));
+ && int1l < int2l));
else
- low = ((int1h < int2h)
- || ((int1h == int2h)
- && ((unsigned HOST_WIDE_INT) int1l
- < (unsigned HOST_WIDE_INT) int2l)));
+ low = (int1h < int2h
+ || (int1h == int2h && int1l < int2l));
if (low == (code == MIN_EXPR))
low = int1l, hi = int1h;
abort ();
}
- if (forsize && hi == 0 && low >= 0 && low < 1000)
+ if (forsize && hi == 0 && low < 1000)
return size_int_type_wide (low, TREE_TYPE (arg1));
else
{
/* If we are trying to make a sizetype for a small integer, use
size_int to pick up cached types to reduce duplicate nodes. */
if (TREE_CODE (type) == INTEGER_CST && TYPE_IS_SIZETYPE (type)
- && TREE_INT_CST_HIGH (arg1) == 0
- && TREE_INT_CST_LOW (arg1) >= 0
- && TREE_INT_CST_LOW (arg1) < 1000)
+ && compare_tree_int (arg1, 1000) < 0)
return size_int_type_wide (TREE_INT_CST_LOW (arg1), type);
/* Given an integer constant, make new constant with new type,
case INTEGER_CST:
return (! TREE_CONSTANT_OVERFLOW (arg0)
&& ! TREE_CONSTANT_OVERFLOW (arg1)
- && TREE_INT_CST_LOW (arg0) == TREE_INT_CST_LOW (arg1)
- && TREE_INT_CST_HIGH (arg0) == TREE_INT_CST_HIGH (arg1));
+ && tree_int_cst_equal (arg0, arg1));
case REAL_CST:
return (! TREE_CONSTANT_OVERFLOW (arg0)
switch (code)
{
case INTEGER_CST:
- return convert (type, build_int_2 (TREE_INT_CST_LOW (arg) == 0
- && TREE_INT_CST_HIGH (arg) == 0, 0));
+ return convert (type, build_int_2 (integer_zerop (arg), 0));
case TRUTH_AND_EXPR:
return build (TRUTH_OR_EXPR, type,
/* Fold an expression like: "foo"[2] */
if (TREE_CODE (arg0) == STRING_CST
&& TREE_CODE (arg1) == INTEGER_CST
- && !TREE_INT_CST_HIGH (arg1)
- && (i = TREE_INT_CST_LOW (arg1)) < TREE_STRING_LENGTH (arg0))
+ && compare_tree_int (arg1, TREE_STRING_LENGTH (arg0)) < 0)
{
- t = build_int_2 (TREE_STRING_POINTER (arg0)[i], 0);
+ t = build_int_2 (TREE_STRING_POINTER (arg0)[TREE_INT_CST_LOW (arg))], 0);
TREE_TYPE (t) = TREE_TYPE (TREE_TYPE (arg0));
force_fit_type (t, 0);
}
STRIP_NOPS (tree110);
STRIP_NOPS (tree111);
if (TREE_CODE (tree110) == INTEGER_CST
- && TREE_INT_CST_HIGH (tree110) == 0
- && (TREE_INT_CST_LOW (tree110)
- == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0))))
+ && 0 == compare_tree_int (tree110,
+ TYPE_PRECISION
+ (TREE_TYPE (TREE_OPERAND
+ (arg0, 0))))
&& operand_equal_p (tree01, tree111, 0))
return build ((code0 == LSHIFT_EXPR
? LROTATE_EXPR
STRIP_NOPS (tree010);
STRIP_NOPS (tree011);
if (TREE_CODE (tree010) == INTEGER_CST
- && TREE_INT_CST_HIGH (tree010) == 0
- && (TREE_INT_CST_LOW (tree010)
- == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0))))
+ && 0 == compare_tree_int (tree010,
+ TYPE_PRECISION
+ (TREE_TYPE (TREE_OPERAND
+ (arg0, 0))))
&& operand_equal_p (tree11, tree011, 0))
return build ((code0 != LSHIFT_EXPR
? LROTATE_EXPR
&& TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
&& ((TREE_INT_CST_LOW (arg1)
+ TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)))
- == GET_MODE_BITSIZE (TYPE_MODE (type))))
+ == (unsigned int) GET_MODE_BITSIZE (TYPE_MODE (type))))
return TREE_OPERAND (arg0, 0);
goto binary;
{
if (TREE_INT_CST_HIGH (arg1) == 0
&& (TREE_INT_CST_LOW (arg1)
- == ((HOST_WIDE_INT) 1 << (width - 1)) - 1)
+ == ((unsigned HOST_WIDE_INT) 1 << (width - 1)) - 1)
&& ! TREE_UNSIGNED (TREE_TYPE (arg1)))
switch (TREE_CODE (t))
{
else if (TREE_INT_CST_HIGH (arg1) == -1
&& (- TREE_INT_CST_LOW (arg1)
- == ((HOST_WIDE_INT) 1 << (width - 1)))
+ == ((unsigned HOST_WIDE_INT) 1 << (width - 1)))
&& ! TREE_UNSIGNED (TREE_TYPE (arg1)))
switch (TREE_CODE (t))
{
else if (TREE_INT_CST_HIGH (arg1) == 0
&& (TREE_INT_CST_LOW (arg1)
- == ((HOST_WIDE_INT) 1 << (width - 1)) - 1)
+ == ((unsigned HOST_WIDE_INT) 1 << (width - 1)) - 1)
&& TREE_UNSIGNED (TREE_TYPE (arg1)))
switch (TREE_CODE (t))
if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
{
if (code == EQ_EXPR)
- t1 = build_int_2 ((TREE_INT_CST_LOW (arg0)
- == TREE_INT_CST_LOW (arg1))
- && (TREE_INT_CST_HIGH (arg0)
- == TREE_INT_CST_HIGH (arg1)),
- 0);
+ t1 = build_int_2 (tree_int_cst_equal (arg0, arg1), 0);
else
t1 = build_int_2 ((TREE_UNSIGNED (TREE_TYPE (arg0))
? INT_CST_LT_UNSIGNED (arg0, arg1)
+Mon Mar 6 18:07:07 2000 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * decl.c (emit_init_test_initialization): Mark KEY as unused.
+ * expr.c (build_newarray): Cast TREE_INT_CST_LOW to HOST_WIDE_INT.
+ (build_anewarray): Likewise.
+ * parse.y (patch_newarray): Likewise.
+ * parse.c: Regenerated.
+
2000-03-06 Bryce McKinlay <bryce@albatross.co.nz>
* decl.c (init_decl_processing): Added new class fields `depth',
/* Process declarations and variables for the GNU compiler for the
Java(TM) language.
-
Copyright (C) 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
This file is part of GNU CC.
static boolean
emit_init_test_initialization (entry, key)
struct hash_entry *entry;
- hash_table_key key;
+ hash_table_key key ATTRIBUTE_UNUSED;
{
struct init_test_hash_entry *ite = (struct init_test_hash_entry *) entry;
expand_decl (ite->init_test_decl);
int atype_value;
tree length;
{
- tree type = build_java_array_type (decode_newarray_type (atype_value),
- TREE_CODE (length) == INTEGER_CST
- ? TREE_INT_CST_LOW (length)
- : -1);
+ tree type
+ = build_java_array_type (decode_newarray_type (atype_value),
+ TREE_CODE (length) == INTEGER_CST
+ ? (HOST_WIDE_INT) TREE_INT_CST_LOW (length) : -1);
+
return build (CALL_EXPR, promote_type (type),
build_address_of (soft_newarray_node),
tree_cons (NULL_TREE,
tree class_type;
tree length;
{
- tree type = build_java_array_type (class_type,
- TREE_CODE (length) == INTEGER_CST
- ? TREE_INT_CST_LOW (length)
- : -1);
+ tree type
+ = build_java_array_type (class_type,
+ TREE_CODE (length) == INTEGER_CST
+ ? (HOST_WIDE_INT) TREE_INT_CST_LOW (length) : -1);
+
return build (CALL_EXPR, promote_type (type),
build_address_of (soft_anewarray_node),
tree_cons (NULL_TREE, length,
for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
{
type = array_type;
- array_type = build_java_array_type (type,
- TREE_CODE (cdim) == INTEGER_CST ?
- TREE_INT_CST_LOW (cdim) : -1);
+ array_type
+ = build_java_array_type (type,
+ TREE_CODE (cdim) == INTEGER_CST
+ ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
+ : -1);
array_type = promote_type (array_type);
}
dims = nreverse (dims);
for (cdim = dims; cdim; cdim = TREE_CHAIN (cdim))
{
type = array_type;
- array_type = build_java_array_type (type,
- TREE_CODE (cdim) == INTEGER_CST ?
- TREE_INT_CST_LOW (cdim) : -1);
+ array_type
+ = build_java_array_type (type,
+ TREE_CODE (cdim) == INTEGER_CST
+ ? (HOST_WIDE_INT) TREE_INT_CST_LOW (cdim)
+ : -1);
array_type = promote_type (array_type);
}
dims = nreverse (dims);
/* Given a pathname, calculate the non-directory part. This always
knows how to handle Unix-style pathnames, and understands VMS and
DOS paths on those systems. */
+
/* Find the base name of a (partial) pathname FNAME.
Returns a pointer into the string passed in.
Accepts Unix (/-separated) paths on all systems,
DOS and VMS paths on those systems. */
+
static const char *
base_name (fname)
const char *fname;
struct deps *d;
{
unsigned int i;
+
for (i = 0; i < d->ntargets; i++)
free ((PTR) d->targetv[i]);
+
for (i = 0; i < d->ndeps; i++)
free ((PTR) d->depv[i]);
d->targetv = xrealloc (d->targetv,
d->targets_size * sizeof (const char *));
}
+
d->targetv[d->ntargets++] = t;
}
const struct deps *d;
FILE *fp;
{
- int i;
+ unsigned int i;
for (i = 1; i < d->ndeps; i++)
{
{
fprintf (file, "-");
fprintf (file, HOST_WIDE_INT_PRINT_UNSIGNED,
- -TREE_INT_CST_LOW (node));
+ -TREE_INT_CST_LOW (node));
}
else
fprintf (file, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
#endif
/* In fold-const.c */
-extern int add_double PARAMS ((HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT *, HOST_WIDE_INT *));
-extern int neg_double PARAMS ((HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT *, HOST_WIDE_INT *));
-extern int mul_double PARAMS ((HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT *, HOST_WIDE_INT *));
-extern void lshift_double PARAMS ((HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT, int, HOST_WIDE_INT *,
- HOST_WIDE_INT *, int));
-extern void rshift_double PARAMS ((HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT, int,
- HOST_WIDE_INT *, HOST_WIDE_INT *, int));
-extern void lrotate_double PARAMS ((HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT, int, HOST_WIDE_INT *,
- HOST_WIDE_INT *));
-extern void rrotate_double PARAMS ((HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT, int, HOST_WIDE_INT *,
- HOST_WIDE_INT *));
+extern int add_double PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT *,
+ HOST_WIDE_INT *));
+extern int neg_double PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT *,
+ HOST_WIDE_INT *));
+extern int mul_double PARAMS ((unsigned HOST_WIDE_INT,
+ HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT *,
+ HOST_WIDE_INT *));
+extern void lshift_double PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ HOST_WIDE_INT, unsigned int,
+ unsigned HOST_WIDE_INT *,
+ HOST_WIDE_INT *, int));
+extern void rshift_double PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ HOST_WIDE_INT, unsigned int,
+ unsigned HOST_WIDE_INT *,
+ HOST_WIDE_INT *, int));
+extern void lrotate_double PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ HOST_WIDE_INT, unsigned int,
+ unsigned HOST_WIDE_INT *,
+ HOST_WIDE_INT *));
+extern void rrotate_double PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ HOST_WIDE_INT, unsigned int,
+ unsigned HOST_WIDE_INT *,
+ HOST_WIDE_INT *));
/* In calls.c */
extern void emit_library_call PARAMS ((rtx, int, enum machine_mode,
else if (TREE_CODE (DECL_SIZE_UNIT (decl)) == INTEGER_CST
&& ! (flag_stack_check && ! STACK_CHECK_BUILTIN
- && (TREE_INT_CST_HIGH (DECL_SIZE_UNIT (decl)) != 0
- || (TREE_INT_CST_LOW (DECL_SIZE_UNIT (decl))
- > STACK_CHECK_MAX_VAR_SIZE))))
+ && 0 < compare_tree_int (DECL_SIZE_UNIT (decl),
+ STACK_CHECK_MAX_VAR_SIZE)))
{
/* Variable of fixed size that goes on the stack. */
rtx oldaddr = 0;
change the element's mode to the appropriate one for its size. */
if (mode == BLKmode && DECL_MODE (decl) != BLKmode)
DECL_MODE (decl_elt) = mode
- = mode_for_size (TREE_INT_CST_LOW (DECL_SIZE (decl_elt)),
- MODE_INT, 1);
+ = mode_for_size_tree (DECL_SIZE (decl_elt), MODE_INT, 1);
/* (SUBREG (MEM ...)) at RTL generation time is invalid, so we
instead create a new MEM rtx with the proper mode. */
{
if (TREE_CODE (TYPE_MIN_VALUE (type)) != INTEGER_CST
|| TREE_CODE (TREE_VALUE (t)) != INTEGER_CST
- || TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)) + count
- != TREE_INT_CST_LOW (TREE_VALUE (t)))
+ || (TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)) + count
+ != TREE_INT_CST_LOW (TREE_VALUE (t))))
*spareness = 1;
count++;
}
#endif /* HAVE_casesi */
#endif /* CASE_VALUES_THRESHOLD */
- else if (TREE_INT_CST_HIGH (range) != 0
- || count < (unsigned int) CASE_VALUES_THRESHOLD
- || ((unsigned HOST_WIDE_INT) (TREE_INT_CST_LOW (range))
- > 10 * count)
+ else if (count < CASE_VALUES_THRESHOLD
+ || compare_tree_int (range, 10 * count) > 0
#ifndef ASM_OUTPUT_ADDR_DIFF_ELT
|| flag_pic
#endif
if ((INT_CST_LT (n->low, min_ascii)) || INT_CST_LT (max_ascii, n->high))
return 0;
- for (i = TREE_INT_CST_LOW (n->low); i <= TREE_INT_CST_LOW (n->high); i++)
+ for (i = (HOST_WIDE_INT) TREE_INT_CST_LOW (n->low);
+ i <= (HOST_WIDE_INT) TREE_INT_CST_LOW (n->high); i++)
if (cost_table[i] < 0)
return 0;
}
int limit;
{
if (TREE_CODE (size) != INTEGER_CST
- || TREE_INT_CST_HIGH (size) != 0
- /* If the low-order part is so high as to appear negative, we can't
- find a mode for that many bits. */
- || TREE_INT_CST_LOW (size) < 0
/* What we really want to say here is that the size can fit in a
host integer, but we know there's no way we'd find a mode for
this many bits, so there's no point in doing the precise test. */
- || TREE_INT_CST_LOW (size) > 1000)
+ || compare_tree_int (size, 1000) > 0)
return BLKmode;
else
return mode_for_size (TREE_INT_CST_LOW (size), class, limit);
case MODE_CC:
default:
- abort();
+ abort ();
}
return mode;
tree size = DECL_SIZE_UNIT (decl);
if (size != 0 && TREE_CODE (size) == INTEGER_CST
- && (TREE_INT_CST_HIGH (size) != 0
- || TREE_INT_CST_LOW (size) > larger_than_size))
+ && compare_tree_int (size, larger_than_size) > 0)
{
- int size_as_int = TREE_INT_CST_LOW (size);
+ unsigned int size_as_int = TREE_INT_CST_LOW (size);
- if (size_as_int == TREE_INT_CST_LOW (size)
- && TREE_INT_CST_HIGH (size) == 0)
+ if (compare_tree_int (size, size_as_int) == 0)
warning_with_decl (decl, "size of `%s' is %d bytes", size_as_int);
else
warning_with_decl (decl, "size of `%s' is larger than %d bytes",
and VAR_SIZE is a tree expression.
If VAR_SIZE is null, the size is just CONST_SIZE.
Naturally we try to avoid using VAR_SIZE. */
- HOST_WIDE_INT const_size = 0;
+ unsigned HOST_WIDE_INT const_size = 0;
tree var_size = 0;
/* Once we start using VAR_SIZE, this is the maximum alignment
that we know VAR_SIZE has. */
{
unsigned int type_align = TYPE_ALIGN (type);
register tree dsize = DECL_SIZE (field);
- int field_size = TREE_INT_CST_LOW (dsize);
+ unsigned int field_size = TREE_INT_CST_LOW (dsize);
/* A bit field may not span more units of alignment of its type
than its type itself. Advance to next boundary if necessary. */
/* The size of the union, based on the fields scanned so far,
is max (CONST_SIZE, VAR_SIZE).
VAR_SIZE may be null; then CONST_SIZE by itself is the size. */
- register HOST_WIDE_INT const_size = 0;
+ unsigned HOST_WIDE_INT const_size = 0;
register tree var_size = 0;
#ifdef STRUCTURE_SIZE_BOUNDARY
break;
case VOID_TYPE:
- TYPE_SIZE (type) = size_zero_node;
+ TYPE_SIZE (type) = bitsize_int (0);
TYPE_SIZE_UNIT (type) = size_zero_node;
TYPE_ALIGN (type) = 1;
TYPE_MODE (type) = VOIDmode;
Unless the member is BLKmode only because it isn't aligned. */
for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
{
- int bitpos;
+ unsigned HOST_WIDE_INT bitpos;
if (TREE_CODE (field) != FIELD_DECL
|| TREE_CODE (TREE_TYPE (field)) == ERROR_MARK)
then stick with BLKmode. */
&& (! STRICT_ALIGNMENT
|| TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT
- || ((int) TYPE_ALIGN (type)
- >= TREE_INT_CST_LOW (TYPE_SIZE (type)))))
+ || compare_tree_int (TYPE_SIZE (type), TYPE_ALIGN (type)) <= 0))
{
tree field;
struct type_hash
{
struct type_hash *next; /* Next structure in the bucket. */
- int hashcode; /* Hash code of this type. */
+ unsigned int hashcode; /* Hash code of this type. */
tree type; /* The type recorded here. */
};
e = ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
* (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
d *= e;
- e = (double) (unsigned HOST_WIDE_INT) (~ TREE_INT_CST_LOW (i));
+ e = (double) (~ TREE_INT_CST_LOW (i));
d += e;
d = (- d - 1.0);
}
e = ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
* (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
d *= e;
- e = (double) (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (i);
+ e = (double) TREE_INT_CST_LOW (i);
d += e;
}
#endif /* not REAL_ARITHMETIC */
uns = TREE_UNSIGNED (TREE_TYPE (expr));
if (!uns)
- return TREE_INT_CST_LOW (expr) == -1 && TREE_INT_CST_HIGH (expr) == -1;
+ return (TREE_INT_CST_LOW (expr) == ~ (unsigned HOST_WIDE_INT) 0
+ && TREE_INT_CST_HIGH (expr) == -1);
/* Note that using TYPE_PRECISION here is wrong. We care about the
actual bits, not the (arbitrary) range of the type. */
prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)));
if (prec >= HOST_BITS_PER_WIDE_INT)
{
- int high_value, shift_amount;
+ HOST_WIDE_INT high_value;
+ int shift_amount;
shift_amount = prec - HOST_BITS_PER_WIDE_INT;
else
high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1;
- return TREE_INT_CST_LOW (expr) == -1
- && TREE_INT_CST_HIGH (expr) == high_value;
+ return (TREE_INT_CST_LOW (expr) == ~ (unsigned HOST_WIDE_INT) 0
+ && TREE_INT_CST_HIGH (expr) == high_value);
}
else
- return TREE_INT_CST_LOW (expr) == ((HOST_WIDE_INT) 1 << prec) - 1;
+ return TREE_INT_CST_LOW (expr) == ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
}
/* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
: exact_log2 (low));
}
+/* Similar, but return the largest integer Y such that 2 ** Y is less
+ than or equal to EXPR. */
+
+int
+tree_floor_log2 (expr)
+ tree expr;
+{
+ int prec;
+ HOST_WIDE_INT high, low;
+
+ STRIP_NOPS (expr);
+
+ if (TREE_CODE (expr) == COMPLEX_CST)
+ return tree_log2 (TREE_REALPART (expr));
+
+ prec = (POINTER_TYPE_P (TREE_TYPE (expr))
+ ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
+
+ high = TREE_INT_CST_HIGH (expr);
+ low = TREE_INT_CST_LOW (expr);
+
+ /* First clear all bits that are beyond the type's precision in case
+ we've been sign extended. Ignore if type's precision hasn't been set
+ since what we are doing is setting it. */
+
+ if (prec == 2 * HOST_BITS_PER_WIDE_INT || prec == 0)
+ ;
+ else if (prec > HOST_BITS_PER_WIDE_INT)
+ high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
+ else
+ {
+ high = 0;
+ if (prec < HOST_BITS_PER_WIDE_INT)
+ low &= ~((HOST_WIDE_INT) (-1) << prec);
+ }
+
+ return (high != 0 ? HOST_BITS_PER_WIDE_INT + floor_log2 (high)
+ : floor_log2 (low));
+}
+
/* Return 1 if EXPR is the real constant zero. */
int
{
if ( ! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
{
- register int hashcode;
+ unsigned int hashcode;
tree ntype;
push_obstacks (TYPE_OBSTACK (ttype), TYPE_OBSTACK (ttype));
TYPE_NEXT_VARIANT (ntype) = 0;
set_type_quals (ntype, TYPE_UNQUALIFIED);
- hashcode = TYPE_HASH (TREE_CODE (ntype))
- + TYPE_HASH (TREE_TYPE (ntype))
- + attribute_hash_list (attribute);
+ hashcode = (TYPE_HASH (TREE_CODE (ntype))
+ + TYPE_HASH (TREE_TYPE (ntype))
+ + attribute_hash_list (attribute));
switch (TREE_CODE (ntype))
{
with types in the TREE_VALUE slots), by adding the hash codes
of the individual types. */
-int
+unsigned int
type_hash_list (list)
tree list;
{
- register int hashcode;
+ unsigned int hashcode;
register tree tail;
for (hashcode = 0, tail = list; tail; tail = TREE_CHAIN (tail))
tree
type_hash_lookup (hashcode, type)
- int hashcode;
+ unsigned int hashcode;
tree type;
{
register struct type_hash *h;
void
type_hash_add (hashcode, type)
- int hashcode;
+ unsigned int hashcode;
tree type;
{
register struct type_hash *h;
tree
type_hash_canon (hashcode, type)
- int hashcode;
+ unsigned int hashcode;
tree type;
{
tree t1;
with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
by adding the hash codes of the individual attributes. */
-int
+unsigned int
attribute_hash_list (list)
tree list;
{
- register int hashcode;
+ unsigned int hashcode;
register tree tail;
for (hashcode = 0, tail = list; tail; tail = TREE_CHAIN (tail))
return -1;
}
}
+
+/* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
+ Return -1, 0, or 1 if the value of T is less than, equal to, or greater
+ than U, respectively. */
+
+int
+compare_tree_int (t, u)
+ tree t;
+ unsigned int u;
+{
+ if (tree_int_cst_sgn (t) < 0)
+ return -1;
+ else if (TREE_INT_CST_HIGH (t) != 0)
+ return 1;
+ else if (TREE_INT_CST_LOW (t) == u)
+ return 0;
+ else if (TREE_INT_CST_LOW (t) < u)
+ return -1;
+ else
+ return 1;
+}
\f
/* Constructors for pointer, array and function types.
(RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
TYPE_ALIGN (itype) = TYPE_ALIGN (sizetype);
if (TREE_CODE (maxval) == INTEGER_CST)
{
- int maxint = (int) TREE_INT_CST_LOW (maxval);
+ int maxint = TREE_INT_CST_LOW (maxval);
+
/* If the domain should be empty, make sure the maxval
remains -1 and is not spoiled by truncation. */
- if (INT_CST_LT (maxval, integer_zero_node))
+ if (tree_int_cst_sgn (maxval) < 0)
{
TYPE_MAX_VALUE (itype) = build_int_2 (-1, -1);
TREE_TYPE (TYPE_MAX_VALUE (itype)) = sizetype;
}
+
return type_hash_canon (maxint < 0 ? ~maxint : maxint, itype);
}
else
if (highval && TREE_CODE (highval) == INTEGER_CST)
highint = TREE_INT_CST_LOW (highval);
else
- highint = (~(unsigned HOST_WIDE_INT)0) >> 1;
+ highint = (~(unsigned HOST_WIDE_INT) 0) >> 1;
maxint = (int) (highint - lowint);
+
return type_hash_canon (maxint < 0 ? ~maxint : maxint, itype);
}
else
tree elt_type, index_type;
{
register tree t;
- int hashcode;
+ unsigned int hashcode;
if (TREE_CODE (elt_type) == FUNCTION_TYPE)
{
tree value_type, arg_types;
{
register tree t;
- int hashcode;
+ unsigned int hashcode;
if (TREE_CODE (value_type) == FUNCTION_TYPE)
{
tree basetype, type;
{
register tree t;
- int hashcode;
+ unsigned int hashcode;
/* Make a node of the sort we want. */
t = make_node (METHOD_TYPE);
tree basetype, type;
{
register tree t;
- int hashcode;
+ unsigned int hashcode;
/* Make a node of the sort we want. */
t = make_node (OFFSET_TYPE);
tree component_type;
{
register tree t;
- int hashcode;
+ unsigned int hashcode;
/* Make a node of the sort we want. */
t = make_node (COMPLEX_TYPE);
/* Don't crash if field not laid out yet. */
&& DECL_SIZE (TREE_OPERAND (op, 1)) != 0)
{
- unsigned innerprec = TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (op, 1)));
+ unsigned int innerprec
+ = TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (op, 1)));
+
type = type_for_size (innerprec, TREE_UNSIGNED (TREE_OPERAND (op, 1)));
/* We can get this structure field in the narrowest type it fits in.
/* Since type_for_size always gives an integer type. */
&& TREE_CODE (TREE_TYPE (op)) != REAL_TYPE)
{
- unsigned innerprec = TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (op, 1)));
+ unsigned int innerprec
+ = TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (op, 1)));
+
tree type = type_for_size (innerprec, TREE_UNSIGNED (op));
/* We can get this structure field in a narrower type that fits it,
= TREE_INT_CST_LOW (TREE_PURPOSE (vals)) - domain_min;
HOST_WIDE_INT hi_index
= TREE_INT_CST_LOW (TREE_VALUE (vals)) - domain_min;
+
if (lo_index < 0 || lo_index >= bit_size
|| hi_index < 0 || hi_index >= bit_size)
abort ();
build_common_tree_nodes_2 (short_double)
int short_double;
{
+ /* Define these next since types below may used them. */
integer_zero_node = build_int_2 (0, 0);
TREE_TYPE (integer_zero_node) = integer_type_node;
integer_one_node = build_int_2 (1, 0);
TREE_TYPE (size_one_node) = sizetype;
void_type_node = make_node (VOID_TYPE);
- layout_type (void_type_node); /* Uses size_zero_node */
+ layout_type (void_type_node);
/* We are not going to have real types in C with less than byte alignment,
so we might as well not have any types that claim to have it. */
#define INT_CST_LT(A, B) \
(TREE_INT_CST_HIGH (A) < TREE_INT_CST_HIGH (B) \
|| (TREE_INT_CST_HIGH (A) == TREE_INT_CST_HIGH (B) \
- && ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (A) \
- < (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (B))))
+ && TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B)))
#define INT_CST_LT_UNSIGNED(A, B) \
(((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A) \
< (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B)) \
|| (((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A) \
- == (unsigned HOST_WIDE_INT ) TREE_INT_CST_HIGH (B)) \
- && (((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (A) \
- < (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (B)))))
+ == (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B)) \
+ && TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B)))
struct tree_int_cst
{
char common[sizeof (struct tree_common)];
struct rtx_def *rtl; /* acts as link to register transfer language
(rtl) info */
- HOST_WIDE_INT int_cst_low;
+ unsigned HOST_WIDE_INT int_cst_low;
HOST_WIDE_INT int_cst_high;
};
extern tree value_member PARAMS ((tree, tree));
extern tree purpose_member PARAMS ((tree, tree));
extern tree binfo_member PARAMS ((tree, tree));
-extern int attribute_hash_list PARAMS ((tree));
+extern unsigned int attribute_hash_list PARAMS ((tree));
extern int attribute_list_equal PARAMS ((tree, tree));
extern int attribute_list_contained PARAMS ((tree, tree));
extern int tree_int_cst_equal PARAMS ((tree, tree));
How the hash code is computed is up to the caller, as long as any two
callers that could hash identical-looking type nodes agree. */
-extern tree type_hash_canon PARAMS ((int, tree));
+extern tree type_hash_canon PARAMS ((unsigned int, tree));
/* Given a VAR_DECL, PARM_DECL, RESULT_DECL or FIELD_DECL node,
calculates the DECL_SIZE, DECL_SIZE_UNIT, DECL_ALIGN and DECL_MODE
extern tree fold PARAMS ((tree));
extern int force_fit_type PARAMS ((tree, int));
-extern int add_double PARAMS ((HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT *, HOST_WIDE_INT *));
-extern int neg_double PARAMS ((HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT *, HOST_WIDE_INT *));
-extern int mul_double PARAMS ((HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT *, HOST_WIDE_INT *));
-extern void lshift_double PARAMS ((HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT, int, HOST_WIDE_INT *,
- HOST_WIDE_INT *, int));
-extern void rshift_double PARAMS ((HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT, int,
- HOST_WIDE_INT *, HOST_WIDE_INT *, int));
-extern void lrotate_double PARAMS ((HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT, int, HOST_WIDE_INT *,
- HOST_WIDE_INT *));
-extern void rrotate_double PARAMS ((HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT, int, HOST_WIDE_INT *,
- HOST_WIDE_INT *));
+extern int add_double PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT *,
+ HOST_WIDE_INT *));
+extern int neg_double PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT *,
+ HOST_WIDE_INT *));
+extern int mul_double PARAMS ((unsigned HOST_WIDE_INT,
+ HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT *,
+ HOST_WIDE_INT *));
+extern void lshift_double PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ HOST_WIDE_INT, unsigned int,
+ unsigned HOST_WIDE_INT *,
+ HOST_WIDE_INT *, int));
+extern void rshift_double PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ HOST_WIDE_INT, unsigned int,
+ unsigned HOST_WIDE_INT *,
+ HOST_WIDE_INT *, int));
+extern void lrotate_double PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ HOST_WIDE_INT, unsigned int,
+ unsigned HOST_WIDE_INT *,
+ HOST_WIDE_INT *));
+extern void rrotate_double PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ HOST_WIDE_INT, unsigned int,
+ unsigned HOST_WIDE_INT *,
+ HOST_WIDE_INT *));
extern int operand_equal_p PARAMS ((tree, tree, int));
extern tree invert_truthvalue PARAMS ((tree));
extern void set_identifier_size PARAMS ((int));
extern int int_fits_type_p PARAMS ((tree, tree));
extern int tree_log2 PARAMS ((tree));
+extern int tree_floor_log2 PARAMS ((tree));
extern void preserve_initializer PARAMS ((void));
extern void preserve_data PARAMS ((void));
extern int object_permanent_p PARAMS ((tree));
extern int type_precision PARAMS ((tree));
extern int simple_cst_equal PARAMS ((tree, tree));
+extern int compare_tree_int PARAMS ((tree, unsigned int));
extern int type_list_equal PARAMS ((tree, tree));
extern int chain_member PARAMS ((tree, tree));
extern int chain_member_purpose PARAMS ((tree, tree));
extern int chain_member_value PARAMS ((tree, tree));
extern tree listify PARAMS ((tree));
-extern tree type_hash_lookup PARAMS ((int, tree));
-extern void type_hash_add PARAMS ((int, tree));
-extern int type_hash_list PARAMS ((tree));
+extern tree type_hash_lookup PARAMS ((unsigned int, tree));
+extern void type_hash_add PARAMS ((unsigned int, tree));
+extern unsigned int type_hash_list PARAMS ((tree));
extern int simple_cst_list_equal PARAMS ((tree, tree));
extern void debug_obstack PARAMS ((char *));
extern void rtl_in_current_obstack PARAMS ((void));
extern void pop_temp_slots PARAMS ((void));
extern void push_temp_slots PARAMS ((void));
extern void preserve_temp_slots PARAMS ((struct rtx_def *));
+extern void preserve_rtl_expr_temps PARAMS ((tree));
extern int aggregate_value_p PARAMS ((tree));
extern tree reorder_blocks PARAMS ((tree,
struct rtx_def *));
/* In c-common.c */
extern tree truthvalue_conversion PARAMS ((tree));
-extern int min_precision PARAMS ((tree, int));
+extern unsigned int min_precision PARAMS ((tree, int));
extern void split_specs_attrs PARAMS ((tree, tree *, tree *));
/* In c-decl.c */
/* In fold-const.c */
extern int div_and_round_double PARAMS ((enum tree_code, int,
- HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT *,
- HOST_WIDE_INT *,
- HOST_WIDE_INT *,
- HOST_WIDE_INT *));
+ unsigned HOST_WIDE_INT,
+ HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT,
+ HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT *,
+ HOST_WIDE_INT *,
+ unsigned HOST_WIDE_INT *,
+ HOST_WIDE_INT *));
/* In stmt.c */
extern void emit_nop PARAMS ((void));
if (! dont_output_data)
{
- int size;
+ unsigned int size;
if (TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST)
goto finish;
size_tree = DECL_SIZE_UNIT (decl);
size = TREE_INT_CST_LOW (size_tree);
- if (TREE_INT_CST_HIGH (size_tree) != 0
- || size != TREE_INT_CST_LOW (size_tree))
+ if (compare_tree_int (size_tree, size) != 0)
{
error_with_decl (decl, "size of variable `%s' is too large");
goto finish;
projects / thirdparty / gcc.git / commitdiff
