tree.h (convert_to_ptrofftype_loc): New function.

2011-08-17  Richard Guenther  <rguenther@suse.de>

	* tree.h (convert_to_ptrofftype_loc): New function.
	(convert_to_ptrofftype): Define.
	* builtins.c (expand_builtin_bzero): Use size_type_node.
	(fold_builtin_bzero): Likewise.
	(std_gimplify_va_arg_expr): Build the BIT_AND_EXPR on the pointer.
	* c-typeck.c (build_unary_op): Use convert_to_ptrofftype_loc.
	* cgraphunit.c (thunk_adjust): Use fold_build_pointer_plus_loc.
	(cgraph_redirect_edge_call_stmt_to_callee): Use size_int.
	* expr.c (expand_expr_addr_expr_1): Use fold_build_pointer_plus.
	* fold-const.c (build_range_check): Negate using the original
	type.
	(fold_unary_loc): Use fold_build_pointer_plus_loc.
	* gimple-fold.c (gimple_adjust_this_by_delta): Use
	convert_to_ptrofftype.
	* gimplify.c (gimplify_self_mod_expr): Likewise.
	* graphite-clast-to-gimple.c (clast_to_gcc_expression): Likewise.
	(graphite_create_new_loop_guard): Likewise.
	* graphite-sese-to-poly.c (my_long_long): Remove.
	(scop_ivs_can_be_represented): Adjust.
	* tree-cfg.c (verify_gimple_assign_unary): Use ptrofftype_p.
	* tree-chrec.c (chrec_fold_plus_1): Use fold_build_pointer_plus.
	* tree-loop-distribution.c (build_size_arg_loc): Use
	size_type_node.
	(generate_memset_zero): Simplify.
	* tree-mudflap.c: Use fold_convert, not convert.
	* tree-predcom.c (suitable_reference_p): Expand DR_OFFSET in
	its own type.
	(determine_offset): Likewise for DR_STEP.
	(valid_initializer_p): Likewise.
	* tree-profile.c (prepare_instrumented_value): Convert the pointer
	to an integer type of same size.
	* tree-scalar-evolution.c (interpret_rhs_expr): Do not refer
	to sizetype without need.
	* tree-ssa-address.c (tree_mem_ref_addr): Likewise.
	* tree-ssa-loop-ivopts.c (find_bivs): Use convert_to_ptrofftype.
	* tree-ssa-loop-manip.c (create_iv): Likewise.
	(determine_exit_conditions): Adjust comment.
	* tree-ssa-pre.c (create_expression_by_pieces): Use
	convert_to_ptrofftype.
	* tree-ssa-structalias.c (get_constraint_for_1): Likewise.
	* varasm.c (array_size_for_constructor): Compute using double_ints.

From-SVN: r177828

1 files changed, 10 insertions, 12 deletions

diff --git a/gcc/tree-mudflap.c b/gcc/tree-mudflap.c
index 26ef23e..f9b4599 100644
--- a/gcc/tree-mudflap.c
+++ b/gcc/tree-mudflap.c
@@ -851,7 +851,7 @@ mf_xform_derefs_1 (gimple_stmt_iterator *iter, tree *tp,
 
         limit = fold_build2_loc (location, MINUS_EXPR, mf_uintptr_type,
                              fold_build2_loc (location, PLUS_EXPR, mf_uintptr_type,
-					  convert (mf_uintptr_type, addr),
+					  fold_convert (mf_uintptr_type, addr),
 					  size),
                              integer_one_node);
       }
@@ -897,20 +897,17 @@ mf_xform_derefs_1 (gimple_stmt_iterator *iter, tree *tp,
           return;
 
         bpu = bitsize_int (BITS_PER_UNIT);
-        ofs = convert (bitsizetype, TREE_OPERAND (t, 2));
+        ofs = fold_convert (bitsizetype, TREE_OPERAND (t, 2));
         rem = size_binop_loc (location, TRUNC_MOD_EXPR, ofs, bpu);
-        ofs = fold_convert_loc (location,
-				sizetype,
-				size_binop_loc (location,
-						TRUNC_DIV_EXPR, ofs, bpu));
+        ofs = size_binop_loc (location, TRUNC_DIV_EXPR, ofs, bpu);
 
-        size = convert (bitsizetype, TREE_OPERAND (t, 1));
+        size = fold_convert (bitsizetype, TREE_OPERAND (t, 1));
         size = size_binop_loc (location, PLUS_EXPR, size, rem);
         size = size_binop_loc (location, CEIL_DIV_EXPR, size, bpu);
-        size = convert (sizetype, size);
+        size = fold_convert (sizetype, size);
 
         addr = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
-        addr = convert (ptr_type_node, addr);
+        addr = fold_convert (ptr_type_node, addr);
         addr = fold_build_pointer_plus_loc (location, addr, ofs);
 
         base = addr;
@@ -1049,7 +1046,8 @@ mx_register_decls (tree decl, gimple_seq seq, location_t location)
 
 	  /* Variable-sized objects should have sizes already been
 	     gimplified when we got here. */
-	  size = convert (size_type_node, TYPE_SIZE_UNIT (TREE_TYPE (decl)));
+	  size = fold_convert (size_type_node,
+			       TYPE_SIZE_UNIT (TREE_TYPE (decl)));
 	  gcc_assert (is_gimple_val (size));
 
 
@@ -1233,11 +1231,11 @@ mudflap_register_call (tree obj, tree object_size, tree varname)
   tree arg, call_stmt;
 
   arg = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (obj)), obj);
-  arg = convert (ptr_type_node, arg);
+  arg = fold_convert (ptr_type_node, arg);
 
   call_stmt = build_call_expr (mf_register_fndecl, 4,
 			       arg,
-			       convert (size_type_node, object_size),
+			       fold_convert (size_type_node, object_size),
 			       /* __MF_TYPE_STATIC */
 			       build_int_cst (integer_type_node, 4),
 			       varname);