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

1 files changed, 38 insertions, 20 deletions

diff --git a/gcc/tree.h b/gcc/tree.h
index 2803514..27737dc 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -874,6 +874,11 @@ struct tree_block
    its size.  */
 #define TYPE_NO_FORCE_BLK(NODE) (TYPE_CHECK (NODE)->type.no_force_blk_flag)
 
+/* In an INTEGER_TYPE, it means the type represents a size.  We use this
+   both for validity checking and to permit optimziations that are unsafe
+   for other types.  */
+#define TYPE_IS_SIZETYPE(NODE) (TYPE_CHECK (NODE)->type.no_force_blk_flag)
+
 /* Nonzero in a type considered volatile as a whole.  */
 #define TYPE_VOLATILE(NODE) ((NODE)->common.volatile_flag)
 
@@ -1657,6 +1662,7 @@ extern tree build_expr_wfl              PARAMS ((tree, const char *, int, int));
 
 extern tree make_signed_type		PARAMS ((int));
 extern tree make_unsigned_type		PARAMS ((int));
+extern void initialize_sizetypes	PARAMS ((void));
 extern void set_sizetype		PARAMS ((tree));
 extern tree signed_or_unsigned_type 	PARAMS ((int, tree));
 extern void fixup_unsigned_type		PARAMS ((tree));
@@ -1784,12 +1790,40 @@ extern tree convert			PARAMS ((tree, tree));
 extern unsigned int expr_align		PARAMS ((tree));
 extern tree size_in_bytes		PARAMS ((tree));
 extern HOST_WIDE_INT int_size_in_bytes	PARAMS ((tree));
+
+/* Define data structures, macros, and functions for handling sizes
+   and the various types used to represent sizes.  */
+
+enum size_type_kind
+{
+  SIZETYPE,		/* Normal representation of sizes in bytes. */
+  SSIZETYPE,		/* Signed representation of sizes in bytes. */
+  USIZETYPE,		/* Unsigned representation of sizes in bytes.  */
+  BITSIZETYPE,		/* Normal representation of sizes in bits.  */
+  SBITSIZETYPE,		/* Signed representation of sizes in bits.  */
+  UBITSIZETYPE,	        /* Unsifgned representation of sizes in bits.  */
+  TYPE_KIND_LAST};
+
+extern tree sizetype_tab[(int) TYPE_KIND_LAST];
+
+#define sizetype sizetype_tab[(int) SIZETYPE]
+#define bitsizetype sizetype_tab[(int) BITSIZETYPE]
+#define ssizetype sizetype_tab[(int) SSIZETYPE]
+#define usizetype sizetype_tab[(int) USIZETYPE]
+#define sbitsizetype sizetype_tab[(int) SBITSIZETYPE]
+#define ubitsizetype sizetype_tab[(int) UBITSIZETYPE]
+
 extern tree size_binop			PARAMS ((enum tree_code, tree, tree));
-extern tree ssize_binop			PARAMS ((enum tree_code, tree, tree));
-extern tree size_int_wide		PARAMS ((HOST_WIDE_INT, int));
+extern tree size_diffop			PARAMS ((tree, tree));
+extern tree size_int_wide		PARAMS ((HOST_WIDE_INT,
+						 enum size_type_kind));
+extern tree size_int_type_wide		PARAMS ((HOST_WIDE_INT, tree));
 
-#define size_int(L) size_int_wide ((HOST_WIDE_INT) (L), 0)
-#define bitsize_int(L) size_int_wide ((HOST_WIDE_INT) (L), 1)
+#define size_int_type(L, T) size_int_type_wide ((HOST_WIDE_INT) (L), T)
+#define size_int(L) size_int_wide ((HOST_WIDE_INT) (L), SIZETYPE)
+#define ssize_int(L) size_int_wide ((HOST_WIDE_INT) (L), SSIZETYPE)
+#define bitsize_int(L) size_int_wide ((HOST_WIDE_INT) (L), BITSIZETYPE)
+#define sbitsize_int(L) size_int_wide ((HOST_WIDE_INT) (L), SBITSIZETYPE)
 
 extern tree round_up			PARAMS ((tree, int));
 extern tree get_pending_sizes		PARAMS ((void));
@@ -1802,22 +1836,6 @@ extern void put_pending_sizes		PARAMS ((tree));
    + (BITS_PER_UNIT > 8) + (BITS_PER_UNIT > 16) + (BITS_PER_UNIT > 32) \
    + (BITS_PER_UNIT > 64) + (BITS_PER_UNIT > 128) + (BITS_PER_UNIT > 256))
 
-struct sizetype_tab
-{
-  tree xsizetype, xbitsizetype;
-  tree xssizetype, xusizetype;
-  tree xsbitsizetype, xubitsizetype;
-};
-
-extern struct sizetype_tab sizetype_tab;
-
-#define sizetype sizetype_tab.xsizetype
-#define bitsizetype sizetype_tab.xbitsizetype
-#define ssizetype sizetype_tab.xssizetype
-#define usizetype sizetype_tab.xusizetype
-#define sbitsizetype sizetype_tab.xsbitsizetype
-#define ubitsizetype sizetype_tab.xubitsizetype
-
 /* If nonzero, an upper limit on alignment of structure fields, in bits. */
 extern unsigned int maximum_field_alignment;