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

3 files changed, 78 insertions, 60 deletions

diff --git a/gcc/f/ChangeLog b/gcc/f/ChangeLog
index aa023a5..9a4a86f 100644
--- a/gcc/f/ChangeLog
+++ b/gcc/f/ChangeLog
@@ -1,3 +1,12 @@
+Sun Feb 27 16:40:33 2000  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
+
+	* 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.
+	* ste.c (ffeste_io_dofio_, ffeste_io_douio_): Use TYPE_SIZE_UNIT.
+	(ffeste_io_ciclist_): Likewise.
+
 2000-02-23  Zack Weinberg  <zack@wolery.cumb.org>
 
 	* com.c (ffecom_type_permanent_copy_): Delete unused function.
diff --git a/gcc/f/com.c b/gcc/f/com.c
index 14193eb..ff2e45c 100644
--- a/gcc/f/com.c
+++ b/gcc/f/com.c
@@ -969,10 +969,10 @@ ffecom_arrayref_ (tree item, ffebld expr, int want_ptr)
 			   item,
 			   size_binop (MULT_EXPR,
 				       size_in_bytes (TREE_TYPE (array)),
-				       fold (build (MINUS_EXPR,
-						    tree_type_x,
-						    element,
-						    min))));
+				       convert (sizetype,
+						fold (build (MINUS_EXPR,
+							     tree_type_x,
+							     element, min)))));
 	}
       if (! want_ptr)
 	{
@@ -9090,14 +9090,13 @@ ffecom_tree_canonize_ptr_ (tree *decl, tree *offset,
       if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
 	{
 	  /* An offset into COMMON.  */
-	  *offset = size_binop (PLUS_EXPR,
-				*offset,
-				TREE_OPERAND (t, 1));
+	  *offset = fold (build (PLUS_EXPR, TREE_TYPE (*offset),
+				 *offset, TREE_OPERAND (t, 1)));
 	  /* Convert offset (presumably in bytes) into canonical units
 	     (presumably bits).  */
-	  *offset = size_binop (MULT_EXPR,
-				TYPE_SIZE (TREE_TYPE (TREE_TYPE (t))),
-				*offset);
+	  *offset = fold (build (MULT_EXPR, TREE_TYPE (*offset),
+				 TYPE_SIZE (TREE_TYPE (TREE_TYPE (t))),
+				 *offset));
 	  break;
 	}
       /* Not a COMMON reference, so an unrecognized pattern.  */
@@ -9258,16 +9257,17 @@ ffecom_tree_canonize_ref_ (tree *decl, tree *offset,
 	    || (*decl == error_mark_node))
 	  return;
 
-	*offset = size_binop (MULT_EXPR,
-			      TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))),
-			      size_binop (MINUS_EXPR,
-					  element,
-					  TYPE_MIN_VALUE
-					  (TYPE_DOMAIN
-					   (TREE_TYPE (array)))));
-
-	*offset = size_binop (PLUS_EXPR,
-			      init_offset,
+	*offset
+	  = size_binop (MULT_EXPR,
+			TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))),
+			convert (sizetype,
+				 fold (build (MINUS_EXPR, TREE_TYPE (element),
+					      element,
+					      TYPE_MIN_VALUE
+					      (TYPE_DOMAIN
+					       (TREE_TYPE (array)))))));;
+
+	*offset = size_binop (PLUS_EXPR, convert (sizetype, init_offset),
 			      *offset);
 
 	*size = TYPE_SIZE (TREE_TYPE (t));
@@ -15633,6 +15633,11 @@ type_for_mode (mode, unsignedp)
   if (mode == TYPE_MODE (long_long_integer_type_node))
     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
 
+#if HOST_BITS_PER_WIDE_INT >= 64
+  if (mode == TYPE_MODE (intTI_type_node))
+    return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
+#endif
+
   if (mode == TYPE_MODE (float_type_node))
     return float_type_node;
 
diff --git a/gcc/f/ste.c b/gcc/f/ste.c
index 6db4d48..f25b929 100644
--- a/gcc/f/ste.c
+++ b/gcc/f/ste.c
@@ -1,5 +1,5 @@
 /* ste.c -- Implementation File (module.c template V1.0)
-   Copyright (C) 1995, 1996 Free Software Foundation, Inc.
+   Copyright (C) 1995, 1996, 2000 Free Software Foundation, Inc.
    Contributed by James Craig Burley.
 
 This file is part of GNU Fortran.
@@ -959,8 +959,9 @@ ffeste_io_dofio_ (ffebld expr)
   if (size == NULL_TREE)	/* Already filled in for CHARACTER type. */
     {				/* "(ftnlen) sizeof(type)" */
       size = size_binop (CEIL_DIV_EXPR,
-			 TYPE_SIZE (ffecom_tree_type[bt][kt]),
-			 size_int (TYPE_PRECISION (char_type_node)));
+			 TYPE_SIZE_UNIT (ffecom_tree_type[bt][kt]),
+			 size_int (TYPE_PRECISION (char_type_node)
+				   / BITS_PER_UNIT));
 #if 0	/* Assume that while it is possible that char * is wider than
 	   ftnlen, no object in Fortran space can get big enough for its
 	   size to be wider than ftnlen.  I really hope nobody wastes
@@ -977,13 +978,13 @@ ffeste_io_dofio_ (ffebld expr)
       = is_complex ? ffecom_f2c_ftnlen_two_node : ffecom_f2c_ftnlen_one_node;
   else
     {
-      num_elements = size_binop (CEIL_DIV_EXPR,
-				 TYPE_SIZE (TREE_TYPE (TREE_TYPE (variable))),
-				 size);
-      num_elements = size_binop (CEIL_DIV_EXPR,
-				 num_elements,
-				 size_int (TYPE_PRECISION
-					   (char_type_node)));
+      num_elements
+	= size_binop (CEIL_DIV_EXPR,
+		      TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (variable))),
+		      convert (sizetype, size));
+      num_elements = size_binop (CEIL_DIV_EXPR, num_elements,
+				 size_int (TYPE_PRECISION (char_type_node)
+					   / BITS_PER_UNIT));
       num_elements = convert (ffecom_f2c_ftnlen_type_node,
 			      num_elements);
     }
@@ -1050,8 +1051,9 @@ ffeste_io_dolio_ (ffebld expr)
   if (size == NULL_TREE)	/* Already filled in for CHARACTER type. */
     {				/* "(ftnlen) sizeof(type)" */
       size = size_binop (CEIL_DIV_EXPR,
-			 TYPE_SIZE (ffecom_tree_type[bt][kt]),
-			 size_int (TYPE_PRECISION (char_type_node)));
+			 TYPE_SIZE_UNIT (ffecom_tree_type[bt][kt]),
+			 size_int (TYPE_PRECISION (char_type_node)
+				   / BITS_PER_UNIT));
 #if 0	/* Assume that while it is possible that char * is wider than
 	   ftnlen, no object in Fortran space can get big enough for its
 	   size to be wider than ftnlen.  I really hope nobody wastes
@@ -1067,13 +1069,13 @@ ffeste_io_dolio_ (ffebld expr)
     num_elements = ffecom_integer_one_node;
   else
     {
-      num_elements = size_binop (CEIL_DIV_EXPR,
-				 TYPE_SIZE (TREE_TYPE (TREE_TYPE (variable))),
-				 size);
-      num_elements = size_binop (CEIL_DIV_EXPR,
-				 num_elements,
-				 size_int (TYPE_PRECISION
-					   (char_type_node)));
+      num_elements
+	= size_binop (CEIL_DIV_EXPR,
+		      TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (variable))),
+		      convert (sizetype, size));
+      num_elements = size_binop (CEIL_DIV_EXPR, num_elements,
+				 size_int (TYPE_PRECISION (char_type_node)
+					   / BITS_PER_UNIT));
       num_elements = convert (ffecom_f2c_ftnlen_type_node,
 			      num_elements);
     }
@@ -1139,8 +1141,9 @@ ffeste_io_douio_ (ffebld expr)
   if (size == NULL_TREE)	/* Already filled in for CHARACTER type. */
     {				/* "(ftnlen) sizeof(type)" */
       size = size_binop (CEIL_DIV_EXPR,
-			 TYPE_SIZE (ffecom_tree_type[bt][kt]),
-			 size_int (TYPE_PRECISION (char_type_node)));
+			 TYPE_SIZE_UNIT (ffecom_tree_type[bt][kt]),
+			 size_int (TYPE_PRECISION (char_type_node)
+				   / BITS_PER_UNIT));
 #if 0	/* Assume that while it is possible that char * is wider than
 	   ftnlen, no object in Fortran space can get big enough for its
 	   size to be wider than ftnlen.  I really hope nobody wastes
@@ -1157,12 +1160,13 @@ ffeste_io_douio_ (ffebld expr)
       = is_complex ? ffecom_f2c_ftnlen_two_node : ffecom_f2c_ftnlen_one_node;
   else
     {
-      num_elements = size_binop (CEIL_DIV_EXPR,
-				 TYPE_SIZE (TREE_TYPE (TREE_TYPE (variable))),
-				 size);
+      num_elements
+	= size_binop (CEIL_DIV_EXPR,
+		      TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (variable))),
+		      convert (sizetype, size));
       num_elements = size_binop (CEIL_DIV_EXPR, num_elements,
-				 size_int (TYPE_PRECISION
-					   (char_type_node)));
+				 size_int (TYPE_PRECISION (char_type_node)
+					   / BITS_PER_UNIT));
       num_elements = convert (ffecom_f2c_ftnlen_type_node,
 			      num_elements);
     }
@@ -1759,13 +1763,13 @@ ffeste_io_icilist_ (bool have_err,
   else if (unitexp && unitlenexp)
     {
       /* An array, but all the info is constant, so compute now.  */
-      unitnuminit = size_binop (CEIL_DIV_EXPR,
-				TYPE_SIZE (TREE_TYPE (TREE_TYPE (unitexp))),
-				unitlenexp);
-      unitnuminit = size_binop (CEIL_DIV_EXPR,
-				unitnuminit,
-				size_int (TYPE_PRECISION
-					  (char_type_node)));
+      unitnuminit
+	= size_binop (CEIL_DIV_EXPR,
+		      TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (unitexp))),
+		      convert (sizetype, unitlenexp));
+      unitnuminit = size_binop (CEIL_DIV_EXPR, unitnuminit,
+				size_int (TYPE_PRECISION (char_type_node)
+					  / BITS_PER_UNIT));
       unitnumexp = unitnuminit;
     }
   else
@@ -1874,13 +1878,13 @@ ffeste_io_icilist_ (bool have_err,
       && unitexp != error_mark_node
       && unitlenexp != error_mark_node)
     {
-      unitnumexp = size_binop (CEIL_DIV_EXPR,
-			       TYPE_SIZE (TREE_TYPE (TREE_TYPE (unitexp))),
-			       unitlenexp);
-      unitnumexp = size_binop (CEIL_DIV_EXPR,
-			       unitnumexp,
-			       size_int (TYPE_PRECISION
-					 (char_type_node)));
+      unitnumexp
+	= size_binop (CEIL_DIV_EXPR,
+		      TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (unitexp))),
+		      convert (sizetype, unitlenexp));
+      unitnumexp = size_binop (CEIL_DIV_EXPR, unitnumexp,
+			       size_int (TYPE_PRECISION (char_type_node)
+					 / BITS_PER_UNIT));
       ffeste_f2c_compile_ (unitnumfield, unitnumexp);
     }