builtins.c (c_strlen): Use size_diffop and return ssizetype value.

	* builtins.c (c_strlen): Use size_diffop and return ssizetype value.
	(expand_builtin_strcpy): Pass correct type to size_binop.
	(expand_builtin_strcmp): Likewise.
	Clean up conditional structure.
	* c-decl.c (init_decl_processing): Don't call set_sizetype twice.
	(complete_array_type): Don't use size_binop for MAXINDEX.
	* c-typeck.c (c_sizeof): Use size_one_node and TYPE_SIZE_UNIT.
	(c_sizeof_nowarn, c_size_in_bytes): Likewise.
	(c_alignof): Use size_one_node.
	(build_unary_op): Pass arg of proper type to size_binop.
	(really_start_incremental_init, push_init_level): Use sizetype for
	constructor{,_bit,_unfilled}_index.
	(pop_init_label, output_init_element): Likewise.
	(output_pending_init_elements, process_init_element): Likewise.
	* calls.c (compute_argument_block_size): Field VAR is ssizetype.
	* expr.c (store_expr): Use size_int.
	(store_constructor): Use proper types for size_binop args.
	(get_inner_reference, expand_expr, case ARRAY_REF): Likewise.
	(expand_expr_unaligned): Likewise.
	(string_contant): Return object of sizetype.
	* expr.h (SUB_PARM_SIZE): Call size_diffop and pass proper types.
	(ARGS_SIZE_RTX): Call ARGS_SIZE_TREE.
	(ARGS_SIZE_TREE): Pass proper types to size_binop.
	* fold-const.c (int_const_binop): Refine when size_int is called.
	(fold_convert): Likewise.
	(size_int_wide): Rework to take KIND as arg, only take low order
	bits, handle new sizetype_tab datatype, and chain entries in
	size_table.
	(size_int_type_wide): New function.
	(size_binop): Validate types of arguments.
	(ssize_binop): Deleted.
	(size_diffop): New function.
	(extract_muldiv): Only fold division into multiplication for sizetypes.
	* function.c (assign_parms): Use size_diffop and make sure
	VAR field is of ssizetype; also pass proper type to size_binop.
	(locate_and_pad_parm, pad_to_arg_alignment): Likewise.
	(round_down): Deleted from here.
	* store-layout.c (sizetype_tab): Now an array.
	(sizetype_set, early_root_list): New variables.
	(variable_size): Use size_one_node.
	(round_up): Pass proper type to size_binop.
	(round_down): Moved to here and corrected as above.
	(layout_record): Pass proper arg types to size_binop.
	(layout_type): Likewise.
	If sizetype_set is zero, record the type just laid out.
	(make_unsigned_type): Don't call set_sizetype;
	(make_signed_type): Likewise; also, call fixup_signed_type.
	(initialize_sizetypes): New function.
	(set_sizetype): Make copy of types, set TYPE_IS_SIZETYPE, and
	set name of bitsizetype to "bit_size_type".
	Fix up type of sizes of all types made before call.
	* tm.texi (ROUND_TYPE_SIZE_UNIT): New macro.
	* tree.c (fix_sizetype): Deleted.
	(build_common_tree_nodes): Call initialize_sizetypes.
	(build_common_tree_nodes_2): Don't call fix_sizetype.
	* tree.h (TYPE_IS_SIZETYPE): New macro.
	(initialize_sizetype): New declaration.
	(enum size_type_kind): New type.
	(struct sizetype_tab): Deleted.
	(sizetype_tab): Now array; adjust sizetype macros.
	(size_diffop, size_int_type_wide): New functions.
	(size_int_wide): Change number of args and type; access macros changed.
	(ssize_int, sbitsize_int): New macros.
	* config/i960/i960.h (ROUND_TYPE_SIZE): Use size_int.
	(ROUND_TYPE_SIZE_UNIT): New macro.
	* ch/actions.c (chill_convert_for_assignment): Don't use size_binop
	for things that aren't sizes.
	(expand_varying_length_assignment): Likewise.
	* ch/convert.c (digest_array_tuple, convert): Likewise.
	* ch/typeck.c (build_chill_slice, smash_dummy_type): Likewise.
	(build_chill_slice_with_range): Likewise.
	(build_chill_slice_with_length): Likewise.
	(build_array_from_set): Adjust types for size_binop.
	* ch/expr.c (build_concat_expr, build_chill_repetition_op): Likewise.
	(build_chill_sizeof): Use TYPE_SIZE_UNIT.
	* ch/tree.c (build_string_type): Pass proper type to size_binop.
	* cp/class.c (dfs_build_vtable_offset_vtbl_entries): Don't use
	size_binop on things that are not sizes; ssize_binop deleted.
	Call size_diffop when appropriate.
	(dfs_build_vcall_offset_vtbl_entries): Likewise.
	(build_primary_vtable, build_secondary_vtable): Likewise.
	(dfs_set_offset_for_unshared_vbases, dfs_modify_vtables): Likewise.
	Variable I is HOST_WIDE_INT.
	(get_vfield_offset): Pass proper types to size_binop.
	(size_extra_vtbl_entries, layout_virtual_bases): Likewise.
	(finish_struct_1): Likewise.
	(skip_rtti_stuff): Arg N is now pointer to signed.
	(layout_class_type): Use size_zero_node.
	* cp/cp-tree.h (skip_rtti_stuff): Arg N is pointer to signed.
	* cp/cvt.c (cp_convert_to_pointer): Pass proper types to size_binop.
	* cp/decl.c (complete_arry_type): Pass proper types to size_binop.
	(xref_basetypes): BINFO_OFFSET is sizetype.
	* cp/error.c (dump_expr): Don't use size_binop non-sizes.
	* cp/expr.c (cplus_expand_constant): Pass proper types to size_binop.
	* cp/init.c (construct_virtual_bases): Fix type error.
	(build_vec_delete_1): Pass proper type to size_binop and don't
	fold result.
	* cp/lex.c (cp_make_lang_type): BINFO_OFFSET is sizetype.
	* cp/rtti.c (get_base_offset): Pass proper type to size_binop.
	* cp/search.c (dfs_find_vbases): Fix type error.
	(expand_upcast_fixups): Arg to skip_rtti_stuff is pointer to signed.
	(dfs_get_vbase_types): BINFO_OFFSET is sizetype.
	* cp/tree.c (debug_binfo): Variable N is signed.
	Use HOST_WIDE_INT_PRINT_DEC.
	* cp/typeck.c (comptypes): sizetype is same as equivalent integer type.
	(c_sizeof, c_sizeof_nowarn, expr_sizeof): Use TYPE_SIZE_UNIT,
	size_one_node and size_zero_node.
	(c_alignof): Use size_one_node.
	(build_component_addr): Pass proper types to size_binop.
	(expand_ptrmemfunc_cst): Don't use size_binop on non-sizes.
	* f/com.c (ffecom_arrayref_): Convert args to size_binop to proper
	type.
	(ffecom_tree_canonize_ptr_): Don't use size_binop for non-sizes.
	(ffecom_tree_canonize_ref_): Likewise.
	(type_for_mode): Handle TImode.
	* f/ste.c (ffeste_io_dofio_, ffeste_io_douio_): Use TYPE_SIZE_UNIT.
	(ffeste_io_ciclist_): Likewise.
	* java/expr.c (build_java_ret): Pass proper type to size_binop.

From-SVN: r32225

6 files changed, 113 insertions, 81 deletions

diff --git a/gcc/ch/ChangeLog b/gcc/ch/ChangeLog
index e8501c9..35df1ba 100644
--- a/gcc/ch/ChangeLog
+++ b/gcc/ch/ChangeLog
@@ -1,3 +1,17 @@
+Sun Feb 27 16:40:33 2000  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
+
+	* actions.c (chill_convert_for_assignment): Don't use size_binop
+	for things that aren't sizes.
+	(expand_varying_length_assignment): Likewise.
+	* convert.c (digest_array_tuple, convert): Likewise.
+	* typeck.c (build_chill_slice, smash_dummy_type): Likewise.
+	(build_chill_slice_with_range): Likewise.
+	(build_chill_slice_with_length): Likewise.
+	(build_array_from_set): Adjust types for size_binop.
+	* expr.c (build_concat_expr, build_chill_repetition_op): Likewise.
+	(build_chill_sizeof): Use TYPE_SIZE_UNIT.
+	* tree.c (build_string_type): Pass proper type to size_binop.
+
 Sat Feb 19 18:43:13 2000  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
 
 	* decl.c (layout_enum): Set DECL_SIZE_UNIT.	
diff --git a/gcc/ch/actions.c b/gcc/ch/actions.c
index b07a532..c97c1b6 100644
--- a/gcc/ch/actions.c
+++ b/gcc/ch/actions.c
@@ -1,5 +1,6 @@
 /* Implement actions for CHILL.
-   Copyright (C) 1992, 93, 94, 98, 99, 2000 Free Software Foundation, Inc.
+   Copyright (C) 1992, 1993, 1994, 1998, 1999, 2000
+   Free Software Foundation, Inc.
    Authors: Per Bothner, Bill Cox, Michael Tiemann, Michael North
 
 This file is part of GNU CC.
@@ -466,13 +467,12 @@ check_non_null (expr)
   return expr;
 }
 
-/*
- * There are four conditions to generate a runtime check:
- *    1) assigning a longer INT to a shorter (signs irrelevant)
- *    2) assigning a signed to an unsigned
- *    3) assigning an unsigned to a signed of the same size.
- *    4) TYPE is a discrete subrange
- */
+/*  There are four conditions to generate a runtime check:
+    1) assigning a longer INT to a shorter (signs irrelevant)
+    2) assigning a signed to an unsigned
+    3) assigning an unsigned to a signed of the same size.
+    4) TYPE is a discrete subrange  */
+
 tree
 chill_convert_for_assignment (type, expr, place)
      tree type, expr;
@@ -558,10 +558,10 @@ chill_convert_for_assignment (type, expr, place)
     }
   result = convert (type, expr);
 
-  /* If the type is a array of PACK bits and the expression is an array constructor,
-     then build a CONSTRUCTOR for a bitstring.  Bitstrings are zero based, so
-     decrement the value of each CONSTRUCTOR element by the amount of the lower
-     bound of the array.  */
+  /* If the type is a array of PACK bits and the expression is an array
+     constructor, then build a CONSTRUCTOR for a bitstring.  Bitstrings are
+     zero based, so decrement the value of each CONSTRUCTOR element by the
+     amount of the lower bound of the array.  */
   if (TREE_CODE (type) == ARRAY_TYPE && TYPE_PACKED (type)
       && TREE_CODE (result) == CONSTRUCTOR)
     {
@@ -569,6 +569,7 @@ chill_convert_for_assignment (type, expr, place)
       tree new_list = NULL_TREE;
       long index;
       tree element;
+
       for (element = TREE_OPERAND (result, 1);
 	   element != NULL_TREE;
 	   element = TREE_CHAIN (element))
@@ -579,18 +580,21 @@ chill_convert_for_assignment (type, expr, place)
 	      switch (TREE_CODE (purpose))
 		{
 		case INTEGER_CST:
-		  new_list = tree_cons (NULL_TREE,
-					size_binop (MINUS_EXPR, purpose, domain_min),
-					new_list);
+		  new_list
+		    = tree_cons (NULL_TREE,
+				 fold (build (MINUS_EXPR, TREE_TYPE (purpose),
+					      purpose, domain_min)),
+				 new_list);
 		  break;
 		case RANGE_EXPR:
 		  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,
-					  size_binop (MINUS_EXPR,
-						      build_int_2 (index, 0),
-						      domain_min),
+					  fold (build (MINUS_EXPR,
+						       integer_type_node,
+						       build_int_2 (index, 0),
+						       domain_min)),
 					  new_list);
 		  break;
 		default:
@@ -1697,11 +1701,12 @@ chill_expand_assignment (lhs, modifycode, rhs)
       tree from_pos = save_expr (TREE_OPERAND (lhs, 0));
       tree set = TREE_OPERAND (lhs, 1);
       tree domain = TYPE_DOMAIN (TREE_TYPE (set));
-      tree set_length = size_binop (PLUS_EXPR,
-				    size_binop (MINUS_EXPR,
-						TYPE_MAX_VALUE (domain),
-						TYPE_MIN_VALUE (domain)),
-				    integer_one_node);
+      tree set_length
+	= fold (build (PLUS_EXPR, integer_type_node,
+		       fold (build (MINUS_EXPR, integer_type_node,
+				    TYPE_MAX_VALUE (domain),
+				    TYPE_MIN_VALUE (domain))),
+		       integer_one_node));
       tree filename = force_addr_of (get_chill_filename());
       
       if (TREE_CODE (TREE_TYPE (lhs)) != BOOLEAN_TYPE)
@@ -1750,19 +1755,22 @@ chill_expand_assignment (lhs, modifycode, rhs)
       tree numbits = TREE_OPERAND (lhs, 1);
       tree from_pos = save_expr (TREE_OPERAND (lhs, 2));
       tree domain = TYPE_DOMAIN (TREE_TYPE (set));
-      tree set_length = size_binop (PLUS_EXPR,
-				    size_binop (MINUS_EXPR,
-						TYPE_MAX_VALUE (domain),
-						TYPE_MIN_VALUE (domain)),
-				    integer_one_node);
+      tree set_length
+	= fold (build (PLUS_EXPR, integer_type_node,
+		       fold (build (MINUS_EXPR, integer_type_node,
+				    TYPE_MAX_VALUE (domain),
+				    TYPE_MIN_VALUE (domain))),
+		       integer_one_node));
       tree filename = force_addr_of (get_chill_filename());
       tree to_pos;
+
       switch (TREE_CODE (TREE_TYPE (rhs)))
 	{
 	case SET_TYPE:
-	  to_pos = size_binop (MINUS_EXPR,
-			       size_binop (PLUS_EXPR, from_pos, numbits),
-			       integer_one_node);
+	  to_pos = fold (build (MINUS_EXPR, integer_type_node,
+				fold (build (PLUS_EXPR, integer_type_node,
+					     from_pos, numbits)),
+				integer_one_node));
 	  break;
 	case BOOLEAN_TYPE:
 	  to_pos = from_pos;
@@ -1812,7 +1820,7 @@ expand_varying_length_assignment (lhs, rhs)
   min_domain_val = TYPE_MIN_VALUE (TYPE_DOMAIN (base_array));
 
   lhs = build_component_ref (lhs, var_length_id);
-  rhs = size_binop (MINUS_EXPR, rhs, min_domain_val);
+  rhs = fold (build (MINUS_EXPR, TREE_TYPE (rhs), rhs, min_domain_val));
 
   expand_expr_stmt (build_chill_modify_expr (lhs, rhs));
 }
diff --git a/gcc/ch/convert.c b/gcc/ch/convert.c
index 80405da..dcea057 100644
--- a/gcc/ch/convert.c
+++ b/gcc/ch/convert.c
@@ -1,5 +1,6 @@
 /* Language-level data type conversion for GNU CHILL.
-   Copyright (C) 1992, 93, 94, 98, 99, 2000 Free Software Foundation, Inc.
+   Copyright (C) 1992, 1993, 1994, 1998, 1999, 2000
+   Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -858,14 +859,12 @@ digest_array_tuple (type, init, allow_missing_elements)
 	    }
 	  /* Calculate the last element of the gap. */
 	  if (*ptr)
-	    {
-	      /* Actually end up with correct type. */
-	      last = size_binop (MINUS_EXPR,
-				 CONSTRUCTOR_ELT_LO (*ptr),
-				 integer_one_node);
-	    }
+	    last = fold (build (MINUS_EXPR, integer_type_node,
+				CONSTRUCTOR_ELT_LO (*ptr),
+				integer_one_node));
 	  else
 	    last = domain_max;
+
 	  if (TREE_CODE (last) == INTEGER_CST && tree_int_cst_lt (last, first))
 	    ; /* Empty "gap" - no missing elements. */
 	  else if (default_value)
@@ -1058,16 +1057,17 @@ convert (type, expr)
 	{
 	  /* Note that array_type_nelts returns 1 less than the size. */
 	  nentries = array_type_nelts (TREE_TYPE (e));
-	  needed_padding = size_binop (MINUS_EXPR,
-				       array_type_nelts (target_array_type),
-				       nentries);
+	  needed_padding = fold (build (MINUS_EXPR, integer_type_node,
+					array_type_nelts (target_array_type),
+					nentries));
 	  if (TREE_CODE (needed_padding) != INTEGER_CST)
 	    {
 	      padding_max_size = size_in_bytes (TREE_TYPE (e));
 	      if (TREE_CODE (padding_max_size) != INTEGER_CST)
 		padding_max_size = TYPE_ARRAY_MAX_SIZE (TREE_TYPE (e));
 	    }
-	  nentries = size_binop (PLUS_EXPR, nentries, integer_one_node);
+	  nentries = fold (build (PLUS_EXPR, integer_type_node,
+				  nentries, integer_one_node));
 	}
       else if (TREE_CODE (e) == CONSTRUCTOR)
 	{
diff --git a/gcc/ch/expr.c b/gcc/ch/expr.c
index 13e5bd8..b4bdf35 100644
--- a/gcc/ch/expr.c
+++ b/gcc/ch/expr.c
@@ -1,6 +1,7 @@
 /* Convert language-specific tree expression to rtl instructions,
    for GNU CHILL compiler.
-   Copyright (C) 1992, 93, 94, 98, 99, 2000 Free Software Foundation, Inc.
+   Copyright (C) 1992, 1993, 1994, 1998, 1999, 2000
+   Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -2264,8 +2265,9 @@ build_chill_sizeof (type)
 	  return error_mark_node;
 	}
       
-      temp = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type),
-			 size_int (TYPE_PRECISION (char_type_node)));
+      temp = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
+			 size_int (TYPE_PRECISION (char_type_node)
+				   / BITS_PER_UNIT));
       if (signame != NULL_TREE)
         {
           /* we have a signal definition. This signal may have no
@@ -3344,9 +3346,9 @@ build_concat_expr (op0, op1)
 
       if (TREE_CODE (type0) == SET_TYPE)
 	{
-	  result_size = size_binop (PLUS_EXPR,
-				    discrete_count (TYPE_DOMAIN (type0)),
-				    discrete_count (TYPE_DOMAIN (type1)));
+	  result_size = fold (build (PLUS_EXPR, integer_type_node,
+				     discrete_count (TYPE_DOMAIN (type0)),
+				     discrete_count (TYPE_DOMAIN (type1))));
 	  result_class.mode = build_bitstring_type (result_size);
 	}
       else
@@ -4250,15 +4252,16 @@ build_chill_repetition_op (count_op, string)
 	    for (temp = vallist; temp; temp = TREE_CHAIN (temp))
 	      {
 		tree new_value
-		  = fold (size_binop (PLUS_EXPR, origin, TREE_VALUE (temp)));
+		  = fold (build (PLUS_EXPR, TREE_TYPE (origin),
+				 TREE_VALUE (temp)));
 		tree new_purpose = NULL_TREE;
+
 		if (! TREE_CONSTANT (TREE_VALUE (temp)))
 		  tree_const = 0;
 		if (TREE_PURPOSE (temp))
 		  {
-		    new_purpose = fold (size_binop (PLUS_EXPR,
-						    origin,
-						    TREE_PURPOSE (temp)));
+		    new_purpose = fold (build (PLUS_EXPR, TREE_TYPE (origin),
+					       origin, TREE_PURPOSE (temp)));
 		    if (! TREE_CONSTANT (TREE_PURPOSE (temp)))
 		      tree_const = 0;
 		  }
diff --git a/gcc/ch/tree.c b/gcc/ch/tree.c
index 88fd5ff..53485db 100644
--- a/gcc/ch/tree.c
+++ b/gcc/ch/tree.c
@@ -1,5 +1,6 @@
 /* Language-dependent node constructors for parse phase of GNU compiler.
-   Copyright (C) 1992, 93, 94, 98, 99, 2000  Free Software Foundation, Inc.
+   Copyright (C) 1992, 1993, 1994, 1998, 1999, 2000
+   Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -65,9 +66,9 @@ build_string_type (elt_type, length)
   /* Subtract 1 from length to get max index value.
      Note we cannot use size_binop for pass 1 expressions. */
   if (TREE_CODE (length) == INTEGER_CST || pass != 1)
-    length = size_binop (MINUS_EXPR, length, integer_one_node);
+    length = size_binop (MINUS_EXPR, length, size_one_node);
   else
-    length = build (MINUS_EXPR, sizetype, length, integer_one_node);
+    length = build (MINUS_EXPR, sizetype, length, size_one_node);
 
   t = make_node (elt_type == boolean_type_node ? SET_TYPE : ARRAY_TYPE);
   TREE_TYPE (t) = elt_type;
@@ -289,7 +290,9 @@ discrete_count (t)
      tree t;
 {
   tree hi = convert (sizetype, TYPE_MAX_VALUE (t));
+
   if (TYPE_MIN_VALUE (t))
     hi = size_binop (MINUS_EXPR, hi, convert (sizetype, TYPE_MIN_VALUE (t)));
+
   return size_binop (PLUS_EXPR, hi, integer_one_node);
 }
diff --git a/gcc/ch/typeck.c b/gcc/ch/typeck.c
index 5082b78..8c74896 100644
--- a/gcc/ch/typeck.c
+++ b/gcc/ch/typeck.c
@@ -1,5 +1,6 @@
 /* Build expressions with type checking for CHILL compiler.
-   Copyright (C) 1992, 93, 94, 98, 99, 2000 Free Software Foundation, Inc.
+   Copyright (C) 1992, 1993, 1994, 1998, 1999, 2000
+   Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -215,17 +216,17 @@ build_chill_slice (array, min_value, length)
      
      The static allocation info is passed by using the parent array's
      limits to compute a temp_size, which is passed in the lang_specific
-     field of the slice_type.
-   */
+     field of the slice_type. */
      
   if (TREE_CODE (array_type) == ARRAY_TYPE)
     {
       tree domain_type = TYPE_DOMAIN (array_type);
       tree domain_min = TYPE_MIN_VALUE (domain_type);
-      tree domain_max = fold (build (PLUS_EXPR, domain_type,
-				     domain_min,
-				     size_binop (MINUS_EXPR,
-						 length, integer_one_node)));
+      tree domain_max
+	= fold (build (PLUS_EXPR, domain_type,
+		       domain_min,
+		       fold (build (MINUS_EXPR, integer_type_node,
+				    length, integer_one_node))));
       tree index_type = build_chill_range_type (TYPE_DOMAIN (array_type),
 						domain_min,
 						domain_max);
@@ -408,13 +409,15 @@ build_chill_slice_with_range (array, min_value, max_value)
       && tree_int_cst_lt (max_value, min_value))
     return build_empty_string (TREE_TYPE (TREE_TYPE (array)));
 
-  return build_chill_slice (array, min_value,
-	     save_expr (size_binop (PLUS_EXPR,
-	       size_binop (MINUS_EXPR, max_value, min_value),
-				    integer_one_node)));
+  return
+    build_chill_slice
+      (array, min_value,
+       save_expr (fold (build (PLUS_EXPR, integer_type_node,
+			       fold (build (MINUS_EXPR, integer_type_node,
+					    max_value, min_value)),
+			       integer_one_node))));
 }
 
-
 tree
 build_chill_slice_with_length (array, min_value, length)
      tree array, min_value, length;
@@ -450,9 +453,10 @@ build_chill_slice_with_length (array, min_value, length)
       length = integer_one_node;
     }
 
-  max_index = size_binop (MINUS_EXPR, 
-	        size_binop (PLUS_EXPR, length, min_value),
-			  integer_one_node);
+  max_index = fold (build (MINUS_EXPR, integer_type_node,
+			   fold (build (PLUS_EXPR, integer_type_node,
+					length, min_value)),
+			   integer_one_node));
   max_index = convert_to_class (chill_expr_class (min_value), max_index);
 
   min_value = valid_array_index_p (array, min_value,
@@ -1208,22 +1212,22 @@ build_chill_cast (type, expr)
   return expr;
 }
 
-/*
- * given a set_type, build an integer array from it that C will grok.
- */
+/* Given a set_type, build an integer array from it that C will grok. */
+
 tree
 build_array_from_set (type)
      tree type;
 {
   tree bytespint, bit_array_size, int_array_count;
  
-  if (type == NULL_TREE || type == error_mark_node || TREE_CODE (type) != SET_TYPE)
+  if (type == NULL_TREE || type == error_mark_node
+      || TREE_CODE (type) != SET_TYPE)
     return error_mark_node;
 
-  bytespint = build_int_2 (HOST_BITS_PER_INT / HOST_BITS_PER_CHAR, 0);
+  /* ??? Should this really be *HOST*??  */
+  bytespint = size_int (HOST_BITS_PER_INT / HOST_BITS_PER_CHAR);
   bit_array_size = size_in_bytes (type);
-  int_array_count = fold (size_binop (TRUNC_DIV_EXPR, bit_array_size,
-						 bytespint));
+  int_array_count = size_binop (TRUNC_DIV_EXPR, bit_array_size, bytespint);
   if (integer_zerop (int_array_count))
     int_array_count = size_one_node;
   type = build_array_type (integer_type_node, 
@@ -3371,9 +3375,9 @@ smash_dummy_type (type)
 	    {
 	      tree oldindex = TYPE_DOMAIN (origin);
 	      new_max = check_range (new_max, new_max, NULL_TREE,
-				     size_binop (PLUS_EXPR,
-						 TYPE_MAX_VALUE (oldindex),
-						 integer_one_node));
+				     fold (build (PLUS_EXPR, integer_type_node,
+						  TYPE_MAX_VALUE (oldindex),
+						  integer_one_node)));
 	      origin = build_string_type (TREE_TYPE (origin), new_max);
 	    }
 	  else if (TREE_CODE (origin) == ARRAY_TYPE)