Require wi::to_wide for trees

The wide_int routines allow things like:

   wi::add (t, 1)

to add 1 to an INTEGER_CST T in its native precision.  But we also have:

   wi::to_offset (t)      // Treat T as an offset_int
   wi::to_widest (t)      // Treat T as a widest_int

Recently we also gained:

   wi::to_wide (t, prec)  // Treat T as a wide_int in preccision PREC

This patch therefore requires:

   wi::to_wide (t)

when operating on INTEGER_CSTs in their native precision.  This is
just as efficient, and makes it clearer that a deliberate choice is
being made to treat the tree as a wide_int in its native precision.
This also removes the inconsistency that

a) INTEGER_CSTs in their native precision can be used without an accessor
   but must use wi:: functions instead of C++ operators

b) the other forms need an explicit accessor but the result can be used
   with C++ operators.

It also helps with SVE, where there's the additional possibility
that the tree could be a runtime value.

2017-10-10  Richard Sandiford  <richard.sandiford@linaro.org>

gcc/
	* wide-int.h (wide_int_ref_storage): Make host_dependent_precision
	a template parameter.
	(WIDE_INT_REF_FOR): Update accordingly.
	* tree.h (wi::int_traits <const_tree>): Delete.
	(wi::tree_to_widest_ref, wi::tree_to_offset_ref): New typedefs.
	(wi::to_widest, wi::to_offset): Use them.  Expand commentary.
	(wi::tree_to_wide_ref): New typedef.
	(wi::to_wide): New function.
	* calls.c (get_size_range): Use wi::to_wide when operating on
	trees as wide_ints.
	* cgraph.c (cgraph_node::create_thunk): Likewise.
	* config/i386/i386.c (ix86_data_alignment): Likewise.
	(ix86_local_alignment): Likewise.
	* dbxout.c (stabstr_O): Likewise.
	* dwarf2out.c (add_scalar_info, gen_enumeration_type_die): Likewise.
	* expr.c (const_vector_from_tree): Likewise.
	* fold-const-call.c (host_size_t_cst_p, fold_const_call_1): Likewise.
	* fold-const.c (may_negate_without_overflow_p, negate_expr_p)
	(fold_negate_expr_1, int_const_binop_1, const_binop)
	(fold_convert_const_int_from_real, optimize_bit_field_compare)
	(all_ones_mask_p, sign_bit_p, unextend, extract_muldiv_1)
	(fold_div_compare, fold_single_bit_test, fold_plusminus_mult_expr)
	(pointer_may_wrap_p, expr_not_equal_to, fold_binary_loc)
	(fold_ternary_loc, multiple_of_p, fold_negate_const, fold_abs_const)
	(fold_not_const, round_up_loc): Likewise.
	* gimple-fold.c (gimple_fold_indirect_ref): Likewise.
	* gimple-ssa-warn-alloca.c (alloca_call_type_by_arg): Likewise.
	(alloca_call_type): Likewise.
	* gimple.c (preprocess_case_label_vec_for_gimple): Likewise.
	* godump.c (go_output_typedef): Likewise.
	* graphite-sese-to-poly.c (tree_int_to_gmp): Likewise.
	* internal-fn.c (get_min_precision): Likewise.
	* ipa-cp.c (ipcp_store_vr_results): Likewise.
	* ipa-polymorphic-call.c
	(ipa_polymorphic_call_context::ipa_polymorphic_call_context): Likewise.
	* ipa-prop.c (ipa_print_node_jump_functions_for_edge): Likewise.
	(ipa_modify_call_arguments): Likewise.
	* match.pd: Likewise.
	* omp-low.c (scan_omp_1_op, lower_omp_ordered_clauses): Likewise.
	* print-tree.c (print_node_brief, print_node): Likewise.
	* stmt.c (expand_case): Likewise.
	* stor-layout.c (layout_type): Likewise.
	* tree-affine.c (tree_to_aff_combination): Likewise.
	* tree-cfg.c (group_case_labels_stmt): Likewise.
	* tree-data-ref.c (dr_analyze_indices): Likewise.
	(prune_runtime_alias_test_list): Likewise.
	* tree-dump.c (dequeue_and_dump): Likewise.
	* tree-inline.c (remap_gimple_op_r, copy_tree_body_r): Likewise.
	* tree-predcom.c (is_inv_store_elimination_chain): Likewise.
	* tree-pretty-print.c (dump_generic_node): Likewise.
	* tree-scalar-evolution.c (iv_can_overflow_p): Likewise.
	(simple_iv_with_niters): Likewise.
	* tree-ssa-address.c (addr_for_mem_ref): Likewise.
	* tree-ssa-ccp.c (ccp_finalize, evaluate_stmt): Likewise.
	* tree-ssa-loop-ivopts.c (constant_multiple_of): Likewise.
	* tree-ssa-loop-niter.c (split_to_var_and_offset)
	(refine_value_range_using_guard, number_of_iterations_ne_max)
	(number_of_iterations_lt_to_ne, number_of_iterations_lt)
	(get_cst_init_from_scev, record_nonwrapping_iv)
	(scev_var_range_cant_overflow): Likewise.
	* tree-ssa-phiopt.c (minmax_replacement): Likewise.
	* tree-ssa-pre.c (compute_avail): Likewise.
	* tree-ssa-sccvn.c (vn_reference_fold_indirect): Likewise.
	(vn_reference_maybe_forwprop_address, valueized_wider_op): Likewise.
	* tree-ssa-structalias.c (get_constraint_for_ptr_offset): Likewise.
	* tree-ssa-uninit.c (is_pred_expr_subset_of): Likewise.
	* tree-ssanames.c (set_nonzero_bits, get_nonzero_bits): Likewise.
	* tree-switch-conversion.c (collect_switch_conv_info, array_value_type)
	(dump_case_nodes, try_switch_expansion): Likewise.
	* tree-vect-loop-manip.c (vect_gen_vector_loop_niters): Likewise.
	(vect_do_peeling): Likewise.
	* tree-vect-patterns.c (vect_recog_bool_pattern): Likewise.
	* tree-vect-stmts.c (vectorizable_load): Likewise.
	* tree-vrp.c (compare_values_warnv, vrp_int_const_binop): Likewise.
	(zero_nonzero_bits_from_vr, ranges_from_anti_range): Likewise.
	(extract_range_from_binary_expr_1, adjust_range_with_scev): Likewise.
	(overflow_comparison_p_1, register_edge_assert_for_2): Likewise.
	(is_masked_range_test, find_switch_asserts, maybe_set_nonzero_bits)
	(vrp_evaluate_conditional_warnv_with_ops, intersect_ranges): Likewise.
	(range_fits_type_p, two_valued_val_range_p, vrp_finalize): Likewise.
	(evrp_dom_walker::before_dom_children): Likewise.
	* tree.c (cache_integer_cst, real_value_from_int_cst, integer_zerop)
	(integer_all_onesp, integer_pow2p, integer_nonzerop, tree_log2)
	(tree_floor_log2, tree_ctz, mem_ref_offset, tree_int_cst_sign_bit)
	(tree_int_cst_sgn, get_unwidened, int_fits_type_p): Likewise.
	(get_type_static_bounds, num_ending_zeros, drop_tree_overflow)
	(get_range_pos_neg): Likewise.
	* ubsan.c (ubsan_expand_ptr_ifn): Likewise.
	* config/darwin.c (darwin_mergeable_constant_section): Likewise.
	* config/aarch64/aarch64.c (aapcs_vfp_sub_candidate): Likewise.
	* config/arm/arm.c (aapcs_vfp_sub_candidate): Likewise.
	* config/avr/avr.c (avr_fold_builtin): Likewise.
	* config/bfin/bfin.c (bfin_local_alignment): Likewise.
	* config/msp430/msp430.c (msp430_attr): Likewise.
	* config/nds32/nds32.c (nds32_insert_attributes): Likewise.
	* config/powerpcspe/powerpcspe-c.c
	(altivec_resolve_overloaded_builtin): Likewise.
	* config/powerpcspe/powerpcspe.c (rs6000_aggregate_candidate)
	(rs6000_expand_ternop_builtin): Likewise.
	* config/rs6000/rs6000-c.c
	(altivec_resolve_overloaded_builtin): Likewise.
	* config/rs6000/rs6000.c (rs6000_aggregate_candidate): Likewise.
	(rs6000_expand_ternop_builtin): Likewise.
	* config/s390/s390.c (s390_handle_hotpatch_attribute): Likewise.

gcc/ada/
	* gcc-interface/decl.c (annotate_value): Use wi::to_wide when
	operating on trees as wide_ints.

gcc/c/
	* c-parser.c (c_parser_cilk_clause_vectorlength): Use wi::to_wide when
	operating on trees as wide_ints.
	* c-typeck.c (build_c_cast, c_finish_omp_clauses): Likewise.
	(c_tree_equal): Likewise.

gcc/c-family/
	* c-ada-spec.c (dump_generic_ada_node): Use wi::to_wide when
	operating on trees as wide_ints.
	* c-common.c (pointer_int_sum): Likewise.
	* c-pretty-print.c (pp_c_integer_constant): Likewise.
	* c-warn.c (match_case_to_enum_1): Likewise.
	(c_do_switch_warnings): Likewise.
	(maybe_warn_shift_overflow): Likewise.

gcc/cp/
	* cvt.c (ignore_overflows): Use wi::to_wide when
	operating on trees as wide_ints.
	* decl.c (check_array_designated_initializer): Likewise.
	* mangle.c (write_integer_cst): Likewise.
	* semantics.c (cp_finish_omp_clause_depend_sink): Likewise.

gcc/fortran/
	* target-memory.c (gfc_interpret_logical): Use wi::to_wide when
	operating on trees as wide_ints.
	* trans-const.c (gfc_conv_tree_to_mpz): Likewise.
	* trans-expr.c (gfc_conv_cst_int_power): Likewise.
	* trans-intrinsic.c (trans_this_image): Likewise.
	(gfc_conv_intrinsic_bound): Likewise.
	(conv_intrinsic_cobound): Likewise.

gcc/lto/
	* lto.c (compare_tree_sccs_1): Use wi::to_wide when
	operating on trees as wide_ints.

gcc/objc/
	* objc-act.c (objc_decl_method_attributes): Use wi::to_wide when
	operating on trees as wide_ints.

From-SVN: r253595

1 files changed, 21 insertions, 23 deletions

diff --git a/gcc/tree-ssa-loop-niter.c b/gcc/tree-ssa-loop-niter.c
index 27244eb..f8f2eeb 100644
--- a/gcc/tree-ssa-loop-niter.c
+++ b/gcc/tree-ssa-loop-niter.c
@@ -92,14 +92,14 @@ split_to_var_and_offset (tree expr, tree *var, mpz_t offset)
 
       *var = op0;
       /* Always sign extend the offset.  */
-      wi::to_mpz (op1, offset, SIGNED);
+      wi::to_mpz (wi::to_wide (op1), offset, SIGNED);
       if (negate)
 	mpz_neg (offset, offset);
       break;
 
     case INTEGER_CST:
       *var = build_int_cst_type (type, 0);
-      wi::to_mpz (expr, offset, TYPE_SIGN (type));
+      wi::to_mpz (wi::to_wide (expr), offset, TYPE_SIGN (type));
       break;
 
     default:
@@ -164,7 +164,7 @@ refine_value_range_using_guard (tree type, tree var,
 
 	  /* Case of comparing VAR with its below/up bounds.  */
 	  mpz_init (valc1);
-	  wi::to_mpz (c1, valc1, TYPE_SIGN (type));
+	  wi::to_mpz (wi::to_wide (c1), valc1, TYPE_SIGN (type));
 	  if (mpz_cmp (valc1, below) == 0)
 	    cmp = GT_EXPR;
 	  if (mpz_cmp (valc1, up) == 0)
@@ -178,9 +178,9 @@ refine_value_range_using_guard (tree type, tree var,
 	  wide_int min = wi::min_value (type);
 	  wide_int max = wi::max_value (type);
 
-	  if (wi::eq_p (c1, min))
+	  if (wi::to_wide (c1) == min)
 	    cmp = GT_EXPR;
-	  if (wi::eq_p (c1, max))
+	  if (wi::to_wide (c1) == max)
 	    cmp = LT_EXPR;
 	}
 
@@ -221,8 +221,8 @@ refine_value_range_using_guard (tree type, tree var,
   /* Setup range information for varc1.  */
   if (integer_zerop (varc1))
     {
-      wi::to_mpz (integer_zero_node, minc1, TYPE_SIGN (type));
-      wi::to_mpz (integer_zero_node, maxc1, TYPE_SIGN (type));
+      wi::to_mpz (0, minc1, TYPE_SIGN (type));
+      wi::to_mpz (0, maxc1, TYPE_SIGN (type));
     }
   else if (TREE_CODE (varc1) == SSA_NAME
 	   && INTEGRAL_TYPE_P (type)
@@ -903,7 +903,8 @@ number_of_iterations_ne_max (mpz_t bnd, bool no_overflow, tree c, tree s,
   if (integer_onep (s)
       || (TREE_CODE (c) == INTEGER_CST
 	  && TREE_CODE (s) == INTEGER_CST
-	  && wi::mod_trunc (c, s, TYPE_SIGN (type)) == 0)
+	  && wi::mod_trunc (wi::to_wide (c), wi::to_wide (s),
+			    TYPE_SIGN (type)) == 0)
       || (TYPE_OVERFLOW_UNDEFINED (type)
 	  && multiple_of_p (type, c, s)))
     {
@@ -922,7 +923,8 @@ number_of_iterations_ne_max (mpz_t bnd, bool no_overflow, tree c, tree s,
      the whole # of iterations analysis will fail).  */
   if (!no_overflow)
     {
-      max = wi::mask <widest_int> (TYPE_PRECISION (type) - wi::ctz (s), false);
+      max = wi::mask <widest_int> (TYPE_PRECISION (type)
+				   - wi::ctz (wi::to_wide (s)), false);
       wi::to_mpz (max, bnd, UNSIGNED);
       return;
     }
@@ -938,13 +940,13 @@ number_of_iterations_ne_max (mpz_t bnd, bool no_overflow, tree c, tree s,
       /* ... then we can strengthen this to C / S, and possibly we can use
 	 the upper bound on C given by BNDS.  */
       if (TREE_CODE (c) == INTEGER_CST)
-	wi::to_mpz (c, bnd, UNSIGNED);
+	wi::to_mpz (wi::to_wide (c), bnd, UNSIGNED);
       else if (bnds_u_valid)
 	mpz_set (bnd, bnds->up);
     }
 
   mpz_init (d);
-  wi::to_mpz (s, d, UNSIGNED);
+  wi::to_mpz (wi::to_wide (s), d, UNSIGNED);
   mpz_fdiv_q (bnd, bnd, d);
   mpz_clear (d);
 }
@@ -1157,7 +1159,7 @@ number_of_iterations_lt_to_ne (tree type, affine_iv *iv0, affine_iv *iv1,
   tmod = fold_convert (type1, mod);
 
   mpz_init (mmod);
-  wi::to_mpz (mod, mmod, UNSIGNED);
+  wi::to_mpz (wi::to_wide (mod), mmod, UNSIGNED);
   mpz_neg (mmod, mmod);
 
   /* If the induction variable does not overflow and the exit is taken,
@@ -1543,7 +1545,7 @@ number_of_iterations_lt (struct loop *loop, tree type, affine_iv *iv0,
 
   mpz_init (mstep);
   mpz_init (tmp);
-  wi::to_mpz (step, mstep, UNSIGNED);
+  wi::to_mpz (wi::to_wide (step), mstep, UNSIGNED);
   mpz_add (tmp, bnds->up, mstep);
   mpz_sub_ui (tmp, tmp, 1);
   mpz_fdiv_q (tmp, tmp, mstep);
@@ -3178,7 +3180,7 @@ get_cst_init_from_scev (tree var, wide_int *init, bool is_min)
   if (is_min == tree_int_cst_sign_bit (iv.step))
     return false;
 
-  *init = iv.base;
+  *init = wi::to_wide (iv.base);
   return true;
 }
 
@@ -3225,7 +3227,7 @@ record_nonwrapping_iv (struct loop *loop, tree base, tree step, gimple *stmt,
 	  && INTEGRAL_TYPE_P (TREE_TYPE (orig_base))
 	  && (get_range_info (orig_base, &min, &max) == VR_RANGE
 	      || get_cst_init_from_scev (orig_base, &max, false))
-	  && wi::gts_p (high, max))
+	  && wi::gts_p (wi::to_wide (high), max))
 	base = wide_int_to_tree (unsigned_type, max);
       else if (TREE_CODE (base) != INTEGER_CST
 	       && dominated_by_p (CDI_DOMINATORS,
@@ -3243,7 +3245,7 @@ record_nonwrapping_iv (struct loop *loop, tree base, tree step, gimple *stmt,
 	  && INTEGRAL_TYPE_P (TREE_TYPE (orig_base))
 	  && (get_range_info (orig_base, &min, &max) == VR_RANGE
 	      || get_cst_init_from_scev (orig_base, &min, true))
-	  && wi::gts_p (min, low))
+	  && wi::gts_p (min, wi::to_wide (low)))
 	base = wide_int_to_tree (unsigned_type, min);
       else if (TREE_CODE (base) != INTEGER_CST
 	       && dominated_by_p (CDI_DOMINATORS,
@@ -4499,19 +4501,15 @@ scev_var_range_cant_overflow (tree var, tree step, struct loop *loop)
        MIN - type_MIN >= |step| ; if step < 0.
 
      Or VAR must take value outside of value range, which is not true.  */
-  step_wi = step;
+  step_wi = wi::to_wide (step);
   type = TREE_TYPE (var);
   if (tree_int_cst_sign_bit (step))
     {
-      diff = lower_bound_in_type (type, type);
-      diff = minv - diff;
+      diff = minv - wi::to_wide (lower_bound_in_type (type, type));
       step_wi = - step_wi;
     }
   else
-    {
-      diff = upper_bound_in_type (type, type);
-      diff = diff - maxv;
-    }
+    diff = wi::to_wide (upper_bound_in_type (type, type)) - maxv;
 
   return (wi::geu_p (diff, step_wi));
 }