tree.h (INT_CST_LT, [...]): Remove unneeded casts.

	* 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

1 files changed, 38 insertions, 55 deletions

diff --git a/gcc/c-common.c b/gcc/c-common.c
index 262022f..35e2b02 100644
--- a/gcc/c-common.c
+++ b/gcc/c-common.c
@@ -282,16 +282,17 @@ declare_hidden_char_array (name, value)
      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;
@@ -775,7 +776,7 @@ decl_attributes (node, attributes, prefix_attributes)
 	    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
@@ -789,18 +790,18 @@ decl_attributes (node, attributes, prefix_attributes)
 		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;
 
@@ -810,11 +811,10 @@ decl_attributes (node, attributes, prefix_attributes)
 	    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)
 	      {
@@ -859,9 +859,11 @@ decl_attributes (node, attributes, prefix_attributes)
 	      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;
 	      }
 
@@ -879,12 +881,10 @@ decl_attributes (node, attributes, prefix_attributes)
 	    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)))
@@ -893,17 +893,19 @@ decl_attributes (node, attributes, prefix_attributes)
 		    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;
+		      }
 		  }
 	      }
 
@@ -916,7 +918,8 @@ decl_attributes (node, attributes, prefix_attributes)
 	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)
@@ -933,9 +936,10 @@ decl_attributes (node, attributes, prefix_attributes)
 		   || 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;
 	      }
 
@@ -947,12 +951,10 @@ decl_attributes (node, attributes, prefix_attributes)
 	    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)))
@@ -2407,7 +2409,7 @@ signed_or_unsigned_type (unsignedp, type)
 /* 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;
@@ -2427,10 +2429,8 @@ min_precision (value, 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;
 }
@@ -2888,24 +2888,7 @@ truthvalue_conversion (expr)
 
   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: