Index: gcc/ada/gcc-interface/cuintp.c
===================================================================
--- gcc/ada/gcc-interface/cuintp.c	2013-08-25 07:17:37.505554513 +0100
+++ gcc/ada/gcc-interface/cuintp.c	2013-08-25 07:42:29.133616663 +0100
@@ -177,7 +177,7 @@ UI_From_gnu (tree Input)
      in a signed 64-bit integer.  */
   if (tree_fits_shwi_p (Input))
     return UI_From_Int (tree_to_shwi (Input));
-  else if (wide_int::lts_p (Input, 0) && TYPE_UNSIGNED (gnu_type))
+  else if (wi::lts_p (Input, 0) && TYPE_UNSIGNED (gnu_type))
     return No_Uint;
 #endif
 
Index: gcc/alias.c
===================================================================
--- gcc/alias.c	2013-08-25 07:17:37.505554513 +0100
+++ gcc/alias.c	2013-08-25 07:42:29.134616672 +0100
@@ -340,8 +340,8 @@ ao_ref_from_mem (ao_ref *ref, const_rtx
 	  || (DECL_P (ref->base)
 	      && (DECL_SIZE (ref->base) == NULL_TREE
 		  || TREE_CODE (DECL_SIZE (ref->base)) != INTEGER_CST
-		  || wide_int::ltu_p (DECL_SIZE (ref->base),
-				      ref->offset + ref->size)))))
+		  || wi::ltu_p (DECL_SIZE (ref->base),
+				ref->offset + ref->size)))))
     return false;
 
   return true;
Index: gcc/c-family/c-common.c
===================================================================
--- gcc/c-family/c-common.c	2013-08-25 07:17:37.505554513 +0100
+++ gcc/c-family/c-common.c	2013-08-25 07:42:29.138616711 +0100
@@ -7925,8 +7925,8 @@ handle_alloc_size_attribute (tree *node,
       wide_int p;
 
       if (TREE_CODE (position) != INTEGER_CST
-	  || (p = wide_int (position)).ltu_p (1)
-	  || p.gtu_p (arg_count) )
+	  || wi::ltu_p (p = wide_int (position), 1)
+	  || wi::gtu_p (p, arg_count))
 	{
 	  warning (OPT_Wattributes,
 	           "alloc_size parameter outside range");
Index: gcc/c-family/c-lex.c
===================================================================
--- gcc/c-family/c-lex.c	2013-08-25 07:17:37.505554513 +0100
+++ gcc/c-family/c-lex.c	2013-08-25 07:42:29.139616721 +0100
@@ -545,7 +545,7 @@ narrowest_unsigned_type (const wide_int
 	continue;
       upper = TYPE_MAX_VALUE (integer_types[itk]);
 
-      if (wide_int::geu_p (upper, val))
+      if (wi::geu_p (upper, val))
 	return (enum integer_type_kind) itk;
     }
 
@@ -573,7 +573,7 @@ narrowest_signed_type (const wide_int &v
 	continue;
       upper = TYPE_MAX_VALUE (integer_types[itk]);
 
-      if (wide_int::geu_p (upper, val))
+      if (wi::geu_p (upper, val))
 	return (enum integer_type_kind) itk;
     }
 
Index: gcc/c-family/c-pretty-print.c
===================================================================
--- gcc/c-family/c-pretty-print.c	2013-08-25 07:17:37.505554513 +0100
+++ gcc/c-family/c-pretty-print.c	2013-08-25 07:42:29.140616730 +0100
@@ -919,7 +919,7 @@ pp_c_integer_constant (c_pretty_printer
     {
       wide_int wi = i;
 
-      if (wi.lt_p (i, 0, TYPE_SIGN (TREE_TYPE (i))))
+      if (wi::lt_p (i, 0, TYPE_SIGN (TREE_TYPE (i))))
 	{
 	  pp_minus (pp);
 	  wi = -wi;
Index: gcc/cgraph.c
===================================================================
--- gcc/cgraph.c	2013-08-25 07:17:37.505554513 +0100
+++ gcc/cgraph.c	2013-08-25 07:42:29.141616740 +0100
@@ -624,7 +624,7 @@ cgraph_add_thunk (struct cgraph_node *de
   
   node = cgraph_create_node (alias);
   gcc_checking_assert (!virtual_offset
-		       || wide_int::eq_p (virtual_offset, virtual_value));
+		       || wi::eq_p (virtual_offset, virtual_value));
   node->thunk.fixed_offset = fixed_offset;
   node->thunk.this_adjusting = this_adjusting;
   node->thunk.virtual_value = virtual_value;
Index: gcc/config/bfin/bfin.c
===================================================================
--- gcc/config/bfin/bfin.c	2013-08-25 07:17:37.505554513 +0100
+++ gcc/config/bfin/bfin.c	2013-08-25 07:42:29.168617001 +0100
@@ -3285,7 +3285,7 @@ bfin_local_alignment (tree type, unsigne
      memcpy can use 32 bit loads/stores.  */
   if (TYPE_SIZE (type)
       && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
-      && (!wide_int::gtu_p (TYPE_SIZE (type), 8))
+      && !wi::gtu_p (TYPE_SIZE (type), 8)
       && align < 32)
     return 32;
   return align;
Index: gcc/config/i386/i386.c
===================================================================
--- gcc/config/i386/i386.c	2013-08-25 07:17:37.505554513 +0100
+++ gcc/config/i386/i386.c	2013-08-25 07:42:29.175617069 +0100
@@ -25695,7 +25695,7 @@ ix86_data_alignment (tree type, int alig
       && AGGREGATE_TYPE_P (type)
       && TYPE_SIZE (type)
       && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
-      && (wide_int::geu_p (TYPE_SIZE (type), max_align))
+      && wi::geu_p (TYPE_SIZE (type), max_align)
       && align < max_align)
     align = max_align;
 
@@ -25706,7 +25706,7 @@ ix86_data_alignment (tree type, int alig
       if ((opt ? AGGREGATE_TYPE_P (type) : TREE_CODE (type) == ARRAY_TYPE)
 	  && TYPE_SIZE (type)
 	  && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
-	  && (wide_int::geu_p (TYPE_SIZE (type), 128))
+	  && wi::geu_p (TYPE_SIZE (type), 128)
 	  && align < 128)
 	return 128;
     }
@@ -25821,7 +25821,7 @@ ix86_local_alignment (tree exp, enum mac
 		  != TYPE_MAIN_VARIANT (va_list_type_node)))
 	  && TYPE_SIZE (type)
 	  && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
-	  && (wide_int::geu_p (TYPE_SIZE (type), 16))
+	  && wi::geu_p (TYPE_SIZE (type), 16)
 	  && align < 128)
 	return 128;
     }
Index: gcc/config/rs6000/rs6000-c.c
===================================================================
--- gcc/config/rs6000/rs6000-c.c	2013-08-25 07:17:37.505554513 +0100
+++ gcc/config/rs6000/rs6000-c.c	2013-08-25 07:42:29.188617194 +0100
@@ -4196,7 +4196,7 @@ altivec_resolve_overloaded_builtin (loca
       mode = TYPE_MODE (arg1_type);
       if ((mode == V2DFmode || mode == V2DImode) && VECTOR_MEM_VSX_P (mode)
 	  && TREE_CODE (arg2) == INTEGER_CST
-	  && wide_int::ltu_p (arg2, 2))
+	  && wi::ltu_p (arg2, 2))
 	{
 	  tree call = NULL_TREE;
 
@@ -4281,7 +4281,7 @@ altivec_resolve_overloaded_builtin (loca
       mode = TYPE_MODE (arg1_type);
       if ((mode == V2DFmode || mode == V2DImode) && VECTOR_UNIT_VSX_P (mode)
 	  && tree_fits_uhwi_p (arg2)
-	  && wide_int::ltu_p (arg2, 2))
+	  && wi::ltu_p (arg2, 2))
 	{
 	  tree call = NULL_TREE;
 
Index: gcc/cp/init.c
===================================================================
--- gcc/cp/init.c	2013-08-25 07:17:37.505554513 +0100
+++ gcc/cp/init.c	2013-08-25 07:42:29.189617204 +0100
@@ -2381,7 +2381,7 @@ build_new_1 (vec<tree, va_gc> **placemen
       gcc_assert (TREE_CODE (size) == INTEGER_CST);
       cookie_size = targetm.cxx.get_cookie_size (elt_type);
       gcc_assert (TREE_CODE (cookie_size) == INTEGER_CST);
-      gcc_checking_assert (addr_wide_int (cookie_size).ltu_p(max_size));
+      gcc_checking_assert (wi::ltu_p (cookie_size, max_size));
       /* Unconditionally subtract the cookie size.  This decreases the
 	 maximum object size and is safe even if we choose not to use
 	 a cookie after all.  */
@@ -2389,7 +2389,7 @@ build_new_1 (vec<tree, va_gc> **placemen
       bool overflow;
       inner_size = addr_wide_int (size)
 		   .mul (inner_nelts_count, SIGNED, &overflow);
-      if (overflow || inner_size.gtu_p (max_size))
+      if (overflow || wi::gtu_p (inner_size, max_size))
 	{
 	  if (complain & tf_error)
 	    error ("size of array is too large");
Index: gcc/dwarf2out.c
===================================================================
--- gcc/dwarf2out.c	2013-08-25 07:17:37.505554513 +0100
+++ gcc/dwarf2out.c	2013-08-25 07:42:29.192617233 +0100
@@ -14783,7 +14783,7 @@ field_byte_offset (const_tree decl)
       object_offset_in_bits
 	= round_up_to_align (object_offset_in_bits, type_align_in_bits);
 
-      if (object_offset_in_bits.gtu_p (bitpos_int))
+      if (wi::gtu_p (object_offset_in_bits, bitpos_int))
 	{
 	  object_offset_in_bits = deepest_bitpos - type_size_in_bits;
 
@@ -16218,7 +16218,7 @@ add_bound_info (dw_die_ref subrange_die,
 		  	     zext_hwi (tree_to_hwi (bound), prec));
 	  }
 	else if (prec == HOST_BITS_PER_WIDE_INT 
-		 || (cst_fits_uhwi_p (bound) && wide_int (bound).ges_p (0)))
+		 || (cst_fits_uhwi_p (bound) && wi::ges_p (bound, 0)))
 	  add_AT_unsigned (subrange_die, bound_attr, tree_to_hwi (bound));
 	else
 	  add_AT_wide (subrange_die, bound_attr, wide_int (bound));
Index: gcc/fold-const.c
===================================================================
--- gcc/fold-const.c	2013-08-25 07:42:28.417609742 +0100
+++ gcc/fold-const.c	2013-08-25 07:42:29.194617252 +0100
@@ -510,7 +510,7 @@ negate_expr_p (tree t)
       if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
 	{
 	  tree op1 = TREE_OPERAND (t, 1);
-	  if (wide_int::eq_p (op1, TYPE_PRECISION (type) - 1))
+	  if (wi::eq_p (op1, TYPE_PRECISION (type) - 1))
 	    return true;
 	}
       break;
@@ -721,7 +721,7 @@ fold_negate_expr (location_t loc, tree t
       if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
 	{
 	  tree op1 = TREE_OPERAND (t, 1);
-	  if (wide_int::eq_p (op1, TYPE_PRECISION (type) - 1))
+	  if (wi::eq_p (op1, TYPE_PRECISION (type) - 1))
 	    {
 	      tree ntype = TYPE_UNSIGNED (type)
 			   ? signed_type_for (type)
@@ -5836,7 +5836,7 @@ extract_muldiv_1 (tree t, tree c, enum t
 	  && (tcode == RSHIFT_EXPR || TYPE_UNSIGNED (TREE_TYPE (op0)))
 	  /* const_binop may not detect overflow correctly,
 	     so check for it explicitly here.  */
-	  && wide_int::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node)), op1)
+	  && wi::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node)), op1)
 	  && 0 != (t1 = fold_convert (ctype,
 				      const_binop (LSHIFT_EXPR,
 						   size_one_node,
@@ -6602,7 +6602,8 @@ fold_single_bit_test (location_t loc, en
 	 not overflow, adjust BITNUM and INNER.  */
       if (TREE_CODE (inner) == RSHIFT_EXPR
 	  && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST
-	  && (wide_int (TREE_OPERAND (inner, 1) + bitnum).ltu_p (TYPE_PRECISION (type))))
+	  && wi::ltu_p (TREE_OPERAND (inner, 1) + bitnum,
+			TYPE_PRECISION (type)))
 	{
 	  bitnum += tree_to_hwi (TREE_OPERAND (inner, 1));
 	  inner = TREE_OPERAND (inner, 0);
@@ -12911,7 +12912,7 @@ fold_binary_loc (location_t loc,
 	  prec = TYPE_PRECISION (itype);
 
 	  /* Check for a valid shift count.  */
-	  if (wide_int::ltu_p (arg001, prec))
+	  if (wi::ltu_p (arg001, prec))
 	    {
 	      tree arg01 = TREE_OPERAND (arg0, 1);
 	      tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
@@ -13036,7 +13037,7 @@ fold_binary_loc (location_t loc,
 	  tree arg00 = TREE_OPERAND (arg0, 0);
 	  tree arg01 = TREE_OPERAND (arg0, 1);
 	  tree itype = TREE_TYPE (arg00);
-	  if (wide_int::eq_p (arg01, TYPE_PRECISION (itype) - 1))
+	  if (wi::eq_p (arg01, TYPE_PRECISION (itype) - 1))
 	    {
 	      if (TYPE_UNSIGNED (itype))
 		{
@@ -14341,7 +14342,7 @@ fold_ternary_loc (location_t loc, enum t
 	      /* Make sure that the perm value is in an acceptable
 		 range.  */
 	      t = val;
-	      if (t.gtu_p (nelts_cnt))
+	      if (wi::gtu_p (t, nelts_cnt))
 		{
 		  need_mask_canon = true;
 		  sel[i] = t.to_uhwi () & (nelts_cnt - 1);
@@ -15163,7 +15164,7 @@ multiple_of_p (tree type, const_tree top
 	  op1 = TREE_OPERAND (top, 1);
 	  /* const_binop may not detect overflow correctly,
 	     so check for it explicitly here.  */
-	  if (wide_int::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node)), op1)
+	  if (wi::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node)), op1)
 	      && 0 != (t1 = fold_convert (type,
 					  const_binop (LSHIFT_EXPR,
 						       size_one_node,
Index: gcc/fortran/trans-intrinsic.c
===================================================================
--- gcc/fortran/trans-intrinsic.c	2013-08-25 07:17:37.505554513 +0100
+++ gcc/fortran/trans-intrinsic.c	2013-08-25 07:42:29.195617262 +0100
@@ -986,8 +986,9 @@ trans_this_image (gfc_se * se, gfc_expr
 	{
 	  wide_int wdim_arg = dim_arg;
 
-	  if (wdim_arg.ltu_p (1)
-	      || wdim_arg.gtu_p (GFC_TYPE_ARRAY_CORANK (TREE_TYPE (desc))))
+	  if (wi::ltu_p (wdim_arg, 1)
+	      || wi::gtu_p (wdim_arg,
+			    GFC_TYPE_ARRAY_CORANK (TREE_TYPE (desc))))
 	    gfc_error ("'dim' argument of %s intrinsic at %L is not a valid "
 		       "dimension index", expr->value.function.isym->name,
 		       &expr->where);
@@ -1346,8 +1347,8 @@ gfc_conv_intrinsic_bound (gfc_se * se, g
     {
       wide_int wbound = bound;
       if (((!as || as->type != AS_ASSUMED_RANK)
-	      && wbound.geu_p (GFC_TYPE_ARRAY_RANK (TREE_TYPE (desc))))
-	  || wbound.gtu_p (GFC_MAX_DIMENSIONS))
+	   && wi::geu_p (wbound, GFC_TYPE_ARRAY_RANK (TREE_TYPE (desc))))
+	  || wi::gtu_p (wbound, GFC_MAX_DIMENSIONS))
 	gfc_error ("'dim' argument of %s intrinsic at %L is not a valid "
 		   "dimension index", upper ? "UBOUND" : "LBOUND",
 		   &expr->where);
@@ -1543,7 +1544,8 @@ conv_intrinsic_cobound (gfc_se * se, gfc
       if (INTEGER_CST_P (bound))
 	{
 	  wide_int wbound = bound;
-	  if (wbound.ltu_p (1) || wbound.gtu_p (GFC_TYPE_ARRAY_CORANK (TREE_TYPE (desc))))
+	  if (wi::ltu_p (wbound, 1)
+	      || wi::gtu_p (wbound, GFC_TYPE_ARRAY_CORANK (TREE_TYPE (desc))))
 	    gfc_error ("'dim' argument of %s intrinsic at %L is not a valid "
 		       "dimension index", expr->value.function.isym->name,
 		       &expr->where);
Index: gcc/gimple-fold.c
===================================================================
--- gcc/gimple-fold.c	2013-08-25 07:17:37.505554513 +0100
+++ gcc/gimple-fold.c	2013-08-25 07:42:29.195617262 +0100
@@ -2799,7 +2799,7 @@ fold_array_ctor_reference (tree type, tr
      be larger than size of array element.  */
   if (!TYPE_SIZE_UNIT (type)
       || TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST
-      || elt_size.lts_p (addr_wide_int (TYPE_SIZE_UNIT (type))))
+      || wi::lts_p (elt_size, TYPE_SIZE_UNIT (type)))
     return NULL_TREE;
 
   /* Compute the array index we look for.  */
@@ -2902,7 +2902,7 @@ fold_nonarray_ctor_reference (tree type,
 	 [BITOFFSET, BITOFFSET_END)?  */
       if (access_end.cmps (bitoffset) > 0
 	  && (field_size == NULL_TREE
-	      || addr_wide_int (offset).lts_p (bitoffset_end)))
+	      || wi::lts_p (offset, bitoffset_end)))
 	{
 	  addr_wide_int inner_offset = addr_wide_int (offset) - bitoffset;
 	  /* We do have overlap.  Now see if field is large enough to
@@ -2910,7 +2910,7 @@ fold_nonarray_ctor_reference (tree type,
 	     fields.  */
 	  if (access_end.cmps (bitoffset_end) > 0)
 	    return NULL_TREE;
-	  if (addr_wide_int (offset).lts_p (bitoffset))
+	  if (wi::lts_p (offset, bitoffset))
 	    return NULL_TREE;
 	  return fold_ctor_reference (type, cval,
 				      inner_offset.to_uhwi (), size,
Index: gcc/gimple-ssa-strength-reduction.c
===================================================================
--- gcc/gimple-ssa-strength-reduction.c	2013-08-25 07:42:28.418609752 +0100
+++ gcc/gimple-ssa-strength-reduction.c	2013-08-25 07:42:29.196617272 +0100
@@ -2355,8 +2355,8 @@ record_increment (slsr_cand_t c, const m
       if (c->kind == CAND_ADD
 	  && !is_phi_adjust
 	  && c->index == increment
-	  && (increment.gts_p (1)
-	      || increment.lts_p (-1))
+	  && (wi::gts_p (increment, 1)
+	      || wi::lts_p (increment, -1))
 	  && (gimple_assign_rhs_code (c->cand_stmt) == PLUS_EXPR
 	      || gimple_assign_rhs_code (c->cand_stmt) == POINTER_PLUS_EXPR))
 	{
Index: gcc/loop-doloop.c
===================================================================
--- gcc/loop-doloop.c	2013-08-25 07:17:37.505554513 +0100
+++ gcc/loop-doloop.c	2013-08-25 07:42:29.196617272 +0100
@@ -461,9 +461,10 @@ doloop_modify (struct loop *loop, struct
       /* Determine if the iteration counter will be non-negative.
 	 Note that the maximum value loaded is iterations_max - 1.  */
       if (max_loop_iterations (loop, &iterations)
-	  && (iterations.leu_p (wide_int::set_bit_in_zero 
-				(GET_MODE_PRECISION (mode) - 1,
-				 GET_MODE_PRECISION (mode)))))
+	  && wi::leu_p (iterations,
+			wide_int::set_bit_in_zero
+			(GET_MODE_PRECISION (mode) - 1,
+			 GET_MODE_PRECISION (mode))))
 	nonneg = 1;
       break;
 
@@ -697,7 +698,7 @@ doloop_optimize (struct loop *loop)
 	 computed, we must be sure that the number of iterations fits into
 	 the new mode.  */
       && (word_mode_size >= GET_MODE_PRECISION (mode)
-	  || iter.leu_p (word_mode_max)))
+	  || wi::leu_p (iter, word_mode_max)))
     {
       if (word_mode_size > GET_MODE_PRECISION (mode))
 	{
Index: gcc/loop-unroll.c
===================================================================
--- gcc/loop-unroll.c	2013-08-25 07:42:28.420609771 +0100
+++ gcc/loop-unroll.c	2013-08-25 07:42:29.196617272 +0100
@@ -693,7 +693,7 @@ decide_unroll_constant_iterations (struc
   if (desc->niter < 2 * nunroll
       || ((estimated_loop_iterations (loop, &iterations)
 	   || max_loop_iterations (loop, &iterations))
-	  && iterations.ltu_p (2 * nunroll)))
+	  && wi::ltu_p (iterations, 2 * nunroll)))
     {
       if (dump_file)
 	fprintf (dump_file, ";; Not unrolling loop, doesn't roll\n");
@@ -816,7 +816,7 @@ unroll_loop_constant_iterations (struct
 	  desc->niter -= exit_mod;
 	  loop->nb_iterations_upper_bound -= exit_mod;
 	  if (loop->any_estimate
-	      && wide_int::leu_p (exit_mod, loop->nb_iterations_estimate))
+	      && wi::leu_p (exit_mod, loop->nb_iterations_estimate))
 	    loop->nb_iterations_estimate -= exit_mod;
 	  else
 	    loop->any_estimate = false;
@@ -859,7 +859,7 @@ unroll_loop_constant_iterations (struct
 	  desc->niter -= exit_mod + 1;
 	  loop->nb_iterations_upper_bound -= exit_mod + 1;
 	  if (loop->any_estimate
-	      && wide_int::leu_p (exit_mod + 1, loop->nb_iterations_estimate))
+	      && wi::leu_p (exit_mod + 1, loop->nb_iterations_estimate))
 	    loop->nb_iterations_estimate -= exit_mod + 1;
 	  else
 	    loop->any_estimate = false;
@@ -992,7 +992,7 @@ decide_unroll_runtime_iterations (struct
   /* Check whether the loop rolls.  */
   if ((estimated_loop_iterations (loop, &iterations)
        || max_loop_iterations (loop, &iterations))
-      && iterations.ltu_p (2 * nunroll))
+      && wi::ltu_p (iterations, 2 * nunroll))
     {
       if (dump_file)
 	fprintf (dump_file, ";; Not unrolling loop, doesn't roll\n");
@@ -1379,7 +1379,7 @@ decide_peel_simple (struct loop *loop, i
   if (estimated_loop_iterations (loop, &iterations))
     {
       /* TODO: unsigned/signed confusion */
-      if (wide_int::leu_p (npeel, iterations))
+      if (wi::leu_p (npeel, iterations))
 	{
 	  if (dump_file)
 	    {
@@ -1396,7 +1396,7 @@ decide_peel_simple (struct loop *loop, i
   /* If we have small enough bound on iterations, we can still peel (completely
      unroll).  */
   else if (max_loop_iterations (loop, &iterations)
-           && iterations.ltu_p (npeel))
+           && wi::ltu_p (iterations, npeel))
     npeel = iterations.to_shwi () + 1;
   else
     {
@@ -1547,7 +1547,7 @@ decide_unroll_stupid (struct loop *loop,
   /* Check whether the loop rolls.  */
   if ((estimated_loop_iterations (loop, &iterations)
        || max_loop_iterations (loop, &iterations))
-      && iterations.ltu_p (2 * nunroll))
+      && wi::ltu_p (iterations, 2 * nunroll))
     {
       if (dump_file)
 	fprintf (dump_file, ";; Not unrolling loop, doesn't roll\n");
Index: gcc/lto/lto.c
===================================================================
--- gcc/lto/lto.c	2013-08-25 07:17:37.505554513 +0100
+++ gcc/lto/lto.c	2013-08-25 07:42:29.206617368 +0100
@@ -1778,7 +1778,7 @@ #define compare_values(X) \
 
   if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
     {
-      if (!wide_int::eq_p (t1, t2))
+      if (!wi::eq_p (t1, t2))
 	return false;
     }
 
Index: gcc/rtl.h
===================================================================
--- gcc/rtl.h	2013-08-25 07:17:37.505554513 +0100
+++ gcc/rtl.h	2013-08-25 07:42:29.197617281 +0100
@@ -1402,10 +1402,10 @@ get_mode (const rtx_mode_t p)
 
 /* Specialization of to_shwi1 function in wide-int.h for rtl.  This
    cannot be in wide-int.h because of circular includes.  */
-template<>
-inline const HOST_WIDE_INT*
-wide_int_ro::to_shwi1 (HOST_WIDE_INT *s ATTRIBUTE_UNUSED, 
-		       unsigned int *l, unsigned int *p, const rtx_mode_t& rp)
+inline const HOST_WIDE_INT *
+wide_int_accessors <rtx_mode_t>::to_shwi (HOST_WIDE_INT *, unsigned int *l,
+					  unsigned int *p,
+					  const rtx_mode_t &rp)
 {
   const rtx rcst = get_rtx (rp);
   enum machine_mode mode = get_mode (rp);
@@ -1414,34 +1414,6 @@ wide_int_ro::to_shwi1 (HOST_WIDE_INT *s
 
   switch (GET_CODE (rcst))
     {
-    case CONST_INT:
-      *l = 1;
-      return &INTVAL (rcst);
-      
-    case CONST_WIDE_INT:
-      *l = CONST_WIDE_INT_NUNITS (rcst);
-      return &CONST_WIDE_INT_ELT (rcst, 0);
-      
-    case CONST_DOUBLE:
-      *l = 2;
-      return &CONST_DOUBLE_LOW (rcst);
-      
-    default:
-      gcc_unreachable ();
-    }
-}
-
-/* Specialization of to_shwi2 function in wide-int.h for rtl.  This
-   cannot be in wide-int.h because of circular includes.  */
-template<>
-inline const HOST_WIDE_INT*
-wide_int_ro::to_shwi2 (HOST_WIDE_INT *s ATTRIBUTE_UNUSED, 
-		       unsigned int *l, const rtx_mode_t& rp)
-{
-  const rtx rcst = get_rtx (rp);
-
-  switch (GET_CODE (rcst))
-    {
     case CONST_INT:
       *l = 1;
       return &INTVAL (rcst);
Index: gcc/simplify-rtx.c
===================================================================
--- gcc/simplify-rtx.c	2013-08-25 07:17:37.505554513 +0100
+++ gcc/simplify-rtx.c	2013-08-25 07:42:29.198617291 +0100
@@ -4649,8 +4649,8 @@ simplify_const_relational_operation (enu
 	return comparison_result (code, CMP_EQ);
       else
 	{
-	  int cr = wo0.lts_p (ptrueop1) ? CMP_LT : CMP_GT;
-	  cr |= wo0.ltu_p (ptrueop1) ? CMP_LTU : CMP_GTU;
+	  int cr = wi::lts_p (wo0, ptrueop1) ? CMP_LT : CMP_GT;
+	  cr |= wi::ltu_p (wo0, ptrueop1) ? CMP_LTU : CMP_GTU;
 	  return comparison_result (code, cr);
 	}
     }
Index: gcc/tree-affine.c
===================================================================
--- gcc/tree-affine.c	2013-08-25 07:17:37.505554513 +0100
+++ gcc/tree-affine.c	2013-08-25 07:42:29.198617291 +0100
@@ -911,7 +911,7 @@ aff_comb_cannot_overlap_p (aff_tree *dif
   else
     {
       /* We succeed if the second object starts after the first one ends.  */
-      return size1.les_p (d);
+      return wi::les_p (size1, d);
     }
 }
 
Index: gcc/tree-chrec.c
===================================================================
--- gcc/tree-chrec.c	2013-08-25 07:17:37.505554513 +0100
+++ gcc/tree-chrec.c	2013-08-25 07:42:29.198617291 +0100
@@ -475,7 +475,7 @@ tree_fold_binomial (tree type, tree n, u
   num = n;
 
   /* Check that k <= n.  */
-  if (num.ltu_p (k))
+  if (wi::ltu_p (num, k))
     return NULL_TREE;
 
   /* Denominator = 2.  */
Index: gcc/tree-predcom.c
===================================================================
--- gcc/tree-predcom.c	2013-08-25 07:42:28.421609781 +0100
+++ gcc/tree-predcom.c	2013-08-25 07:42:29.199617301 +0100
@@ -921,9 +921,9 @@ add_ref_to_chain (chain_p chain, dref re
   dref root = get_chain_root (chain);
   max_wide_int dist;
 
-  gcc_assert (root->offset.les_p (ref->offset));
+  gcc_assert (wi::les_p (root->offset, ref->offset));
   dist = ref->offset - root->offset;
-  if (wide_int::leu_p (MAX_DISTANCE, dist))
+  if (wi::leu_p (MAX_DISTANCE, dist))
     {
       free (ref);
       return;
@@ -1194,7 +1194,7 @@ determine_roots_comp (struct loop *loop,
   FOR_EACH_VEC_ELT (comp->refs, i, a)
     {
       if (!chain || DR_IS_WRITE (a->ref)
-	  || max_wide_int (MAX_DISTANCE).leu_p (a->offset - last_ofs))
+	  || wi::leu_p (MAX_DISTANCE, a->offset - last_ofs))
 	{
 	  if (nontrivial_chain_p (chain))
 	    {
Index: gcc/tree-ssa-loop-ivcanon.c
===================================================================
--- gcc/tree-ssa-loop-ivcanon.c	2013-08-25 07:17:37.505554513 +0100
+++ gcc/tree-ssa-loop-ivcanon.c	2013-08-25 07:42:29.199617301 +0100
@@ -488,7 +488,7 @@ remove_exits_and_undefined_stmts (struct
 	 into unreachable (or trap when debugging experience is supposed
 	 to be good).  */
       if (!elt->is_exit
-	  && elt->bound.ltu_p (max_wide_int (npeeled)))
+	  && wi::ltu_p (elt->bound, npeeled))
 	{
 	  gimple_stmt_iterator gsi = gsi_for_stmt (elt->stmt);
 	  gimple stmt = gimple_build_call
@@ -505,7 +505,7 @@ remove_exits_and_undefined_stmts (struct
 	}
       /* If we know the exit will be taken after peeling, update.  */
       else if (elt->is_exit
-	       && elt->bound.leu_p (max_wide_int (npeeled)))
+	       && wi::leu_p (elt->bound, npeeled))
 	{
 	  basic_block bb = gimple_bb (elt->stmt);
 	  edge exit_edge = EDGE_SUCC (bb, 0);
@@ -545,7 +545,7 @@ remove_redundant_iv_tests (struct loop *
       /* Exit is pointless if it won't be taken before loop reaches
 	 upper bound.  */
       if (elt->is_exit && loop->any_upper_bound
-          && loop->nb_iterations_upper_bound.ltu_p (elt->bound))
+          && wi::ltu_p (loop->nb_iterations_upper_bound, elt->bound))
 	{
 	  basic_block bb = gimple_bb (elt->stmt);
 	  edge exit_edge = EDGE_SUCC (bb, 0);
@@ -562,7 +562,7 @@ remove_redundant_iv_tests (struct loop *
 	      || !integer_zerop (niter.may_be_zero)
 	      || !niter.niter
 	      || TREE_CODE (niter.niter) != INTEGER_CST
-	      || !loop->nb_iterations_upper_bound.ltu_p (niter.niter))
+	      || !wi::ltu_p (loop->nb_iterations_upper_bound, niter.niter))
 	    continue;
 	  
 	  if (dump_file && (dump_flags & TDF_DETAILS))
Index: gcc/tree-ssa-loop-ivopts.c
===================================================================
--- gcc/tree-ssa-loop-ivopts.c	2013-08-25 07:17:37.505554513 +0100
+++ gcc/tree-ssa-loop-ivopts.c	2013-08-25 07:42:29.200617310 +0100
@@ -4659,7 +4659,7 @@ may_eliminate_iv (struct ivopts_data *da
       if (stmt_after_increment (loop, cand, use->stmt))
         max_niter += 1;
       period_value = period;
-      if (max_niter.gtu_p (period_value))
+      if (wi::gtu_p (max_niter, period_value))
         {
           /* See if we can take advantage of inferred loop bound information.  */
           if (data->loop_single_exit_p)
@@ -4667,7 +4667,7 @@ may_eliminate_iv (struct ivopts_data *da
               if (!max_loop_iterations (loop, &max_niter))
                 return false;
               /* The loop bound is already adjusted by adding 1.  */
-              if (max_niter.gtu_p (period_value))
+              if (wi::gtu_p (max_niter, period_value))
                 return false;
             }
           else
Index: gcc/tree-ssa-loop-niter.c
===================================================================
--- gcc/tree-ssa-loop-niter.c	2013-08-25 07:17:37.505554513 +0100
+++ gcc/tree-ssa-loop-niter.c	2013-08-25 07:42:29.200617310 +0100
@@ -2410,7 +2410,7 @@ derive_constant_upper_bound_ops (tree ty
 
       /* If the bound does not fit in TYPE, max. value of TYPE could be
 	 attained.  */
-      if (max.ltu_p (bnd))
+      if (wi::ltu_p (max, bnd))
 	return max;
 
       return bnd;
@@ -2443,7 +2443,7 @@ derive_constant_upper_bound_ops (tree ty
 	     BND <= MAX (type) - CST.  */
 
 	  mmax -= cst;
-	  if (bnd.ltu_p (mmax))
+	  if (wi::ltu_p (bnd, max))
 	    return max;
 
 	  return bnd + cst;
@@ -2463,7 +2463,7 @@ derive_constant_upper_bound_ops (tree ty
 	  /* This should only happen if the type is unsigned; however, for
 	     buggy programs that use overflowing signed arithmetics even with
 	     -fno-wrapv, this condition may also be true for signed values.  */
-	  if (bnd.ltu_p (cst))
+	  if (wi::ltu_p (bnd, cst))
 	    return max;
 
 	  if (TYPE_UNSIGNED (type))
@@ -2519,14 +2519,14 @@ record_niter_bound (struct loop *loop, c
      current estimation is smaller.  */
   if (upper
       && (!loop->any_upper_bound
-	  || i_bound.ltu_p (loop->nb_iterations_upper_bound)))
+	  || wi::ltu_p (i_bound, loop->nb_iterations_upper_bound)))
     {
       loop->any_upper_bound = true;
       loop->nb_iterations_upper_bound = i_bound;
     }
   if (realistic
       && (!loop->any_estimate
-	  || i_bound.ltu_p (loop->nb_iterations_estimate)))
+	  || wi::ltu_p (i_bound, loop->nb_iterations_estimate)))
     {
       loop->any_estimate = true;
       loop->nb_iterations_estimate = i_bound;
@@ -2536,7 +2536,8 @@ record_niter_bound (struct loop *loop, c
      number of iterations, use the upper bound instead.  */
   if (loop->any_upper_bound
       && loop->any_estimate
-      && loop->nb_iterations_upper_bound.ltu_p (loop->nb_iterations_estimate))
+      && wi::ltu_p (loop->nb_iterations_upper_bound,
+		    loop->nb_iterations_estimate))
     loop->nb_iterations_estimate = loop->nb_iterations_upper_bound;
 }
 
@@ -2642,7 +2643,7 @@ record_estimate (struct loop *loop, tree
   i_bound += delta;
 
   /* If an overflow occurred, ignore the result.  */
-  if (i_bound.ltu_p (delta))
+  if (wi::ltu_p (i_bound, delta))
     return;
 
   if (upper && !is_exit)
@@ -3051,7 +3052,7 @@ bound_index (vec<max_wide_int> bounds, c
 
       if (index == bound)
 	return middle;
-      else if (index.ltu_p (bound))
+      else if (wi::ltu_p (index, bound))
 	begin = middle + 1;
       else
 	end = middle;
@@ -3093,7 +3094,7 @@ discover_iteration_bound_by_body_walk (s
 	}
 
       if (!loop->any_upper_bound
-	  || bound.ltu_p (loop->nb_iterations_upper_bound))
+	  || wi::ltu_p (bound, loop->nb_iterations_upper_bound))
         bounds.safe_push (bound);
     }
 
@@ -3124,7 +3125,7 @@ discover_iteration_bound_by_body_walk (s
 	}
 
       if (!loop->any_upper_bound
-	  || bound.ltu_p (loop->nb_iterations_upper_bound))
+	  || wi::ltu_p (bound, loop->nb_iterations_upper_bound))
 	{
 	  ptrdiff_t index = bound_index (bounds, bound);
 	  void **entry = pointer_map_contains (bb_bounds,
@@ -3259,7 +3260,7 @@ maybe_lower_iteration_bound (struct loop
   for (elt = loop->bounds; elt; elt = elt->next)
     {
       if (!elt->is_exit
-	  && elt->bound.ltu_p (loop->nb_iterations_upper_bound))
+	  && wi::ltu_p (elt->bound, loop->nb_iterations_upper_bound))
 	{
 	  if (!not_executed_last_iteration)
 	    not_executed_last_iteration = pointer_set_create ();
@@ -3556,7 +3557,7 @@ max_stmt_executions (struct loop *loop,
 
   *nit += 1;
 
-  return (*nit).gtu_p (nit_minus_one);
+  return wi::gtu_p (*nit, nit_minus_one);
 }
 
 /* Sets NIT to the estimated number of executions of the latch of the
@@ -3575,7 +3576,7 @@ estimated_stmt_executions (struct loop *
 
   *nit += 1;
 
-  return (*nit).gtu_p (nit_minus_one);
+  return wi::gtu_p (*nit, nit_minus_one);
 }
 
 /* Records estimates on numbers of iterations of loops.  */
Index: gcc/tree-ssa.c
===================================================================
--- gcc/tree-ssa.c	2013-08-25 07:17:37.505554513 +0100
+++ gcc/tree-ssa.c	2013-08-25 07:42:29.201617320 +0100
@@ -1829,8 +1829,8 @@ non_rewritable_mem_ref_base (tree ref)
 	  && useless_type_conversion_p (TREE_TYPE (base),
 					TREE_TYPE (TREE_TYPE (decl)))
 	  && mem_ref_offset (base).fits_uhwi_p ()
-	  && addr_wide_int (TYPE_SIZE_UNIT (TREE_TYPE (decl)))
-	     .gtu_p (mem_ref_offset (base))
+	  && wi::gtu_p (TYPE_SIZE_UNIT (TREE_TYPE (decl)),
+			mem_ref_offset (base))
 	  && multiple_of_p (sizetype, TREE_OPERAND (base, 1),
 			    TYPE_SIZE_UNIT (TREE_TYPE (base))))
 	return NULL_TREE;
Index: gcc/tree-vrp.c
===================================================================
--- gcc/tree-vrp.c	2013-08-25 07:42:28.470610254 +0100
+++ gcc/tree-vrp.c	2013-08-25 07:42:29.202617330 +0100
@@ -2652,13 +2652,13 @@ extract_range_from_binary_expr_1 (value_
 	  /* Canonicalize the intervals.  */
 	  if (sign == UNSIGNED)
 	    {
-	      if (size.ltu_p (min0 + max0))
+	      if (wi::ltu_p (size, min0 + max0))
 		{
 		  min0 -= size;
 		  max0 -= size;
 		}
 
-	      if (size.ltu_p (min1 + max1))
+	      if (wi::ltu_p (size, min1 + max1))
 		{
 		  min1 -= size;
 		  max1 -= size;
@@ -2673,7 +2673,7 @@ extract_range_from_binary_expr_1 (value_
 	  /* Sort the 4 products so that min is in prod0 and max is in
 	     prod3.  */
 	  /* min0min1 > max0max1 */
-	  if (prod0.gts_p (prod3))
+	  if (wi::gts_p (prod0, prod3))
 	    {
 	      wide_int tmp = prod3;
 	      prod3 = prod0;
@@ -2681,21 +2681,21 @@ extract_range_from_binary_expr_1 (value_
 	    }
 
 	  /* min0max1 > max0min1 */
-	  if (prod1.gts_p (prod2))
+	  if (wi::gts_p (prod1, prod2))
 	    {
 	      wide_int tmp = prod2;
 	      prod2 = prod1;
 	      prod1 = tmp;
 	    }
 
-	  if (prod0.gts_p (prod1))
+	  if (wi::gts_p (prod0, prod1))
 	    {
 	      wide_int tmp = prod1;
 	      prod1 = prod0;
 	      prod0 = tmp;
 	    }
 
-	  if (prod2.gts_p (prod3))
+	  if (wi::gts_p (prod2, prod3))
 	    {
 	      wide_int tmp = prod3;
 	      prod3 = prod2;
@@ -2704,7 +2704,7 @@ extract_range_from_binary_expr_1 (value_
 
 	  /* diff = max - min.  */
 	  prod2 = prod3 - prod0;
-	  if (prod2.geu_p (sizem1))
+	  if (wi::geu_p (prod2, sizem1))
 	    {
 	      /* the range covers all values.  */
 	      set_value_range_to_varying (vr);
@@ -2801,14 +2801,14 @@ extract_range_from_binary_expr_1 (value_
 		{
 		  low_bound = bound;
 		  high_bound = complement;
-		  if (wide_int::ltu_p (vr0.max, low_bound))
+		  if (wi::ltu_p (vr0.max, low_bound))
 		    {
 		      /* [5, 6] << [1, 2] == [10, 24].  */
 		      /* We're shifting out only zeroes, the value increases
 			 monotonically.  */
 		      in_bounds = true;
 		    }
-		  else if (high_bound.ltu_p (vr0.min))
+		  else if (wi::ltu_p (high_bound, vr0.min))
 		    {
 		      /* [0xffffff00, 0xffffffff] << [1, 2]
 		         == [0xfffffc00, 0xfffffffe].  */
@@ -2822,8 +2822,8 @@ extract_range_from_binary_expr_1 (value_
 		  /* [-1, 1] << [1, 2] == [-4, 4].  */
 		  low_bound = complement;
 		  high_bound = bound;
-		  if (wide_int::lts_p (vr0.max, high_bound)
-		      && low_bound.lts_p (wide_int (vr0.min)))
+		  if (wi::lts_p (vr0.max, high_bound)
+		      && wi::lts_p (low_bound, vr0.min))
 		    {
 		      /* For non-negative numbers, we're shifting out only
 			 zeroes, the value increases monotonically.
@@ -3844,7 +3844,7 @@ adjust_range_with_scev (value_range_t *v
 	  if (!overflow
 	      && wtmp.fits_to_tree_p (TREE_TYPE (init))
 	      && (sgn == UNSIGNED
-		  || (wtmp.gts_p (0) == wide_int::gts_p (step, 0))))
+		  || wi::gts_p (wtmp, 0) == wi::gts_p (step, 0)))
 	    {
 	      tem = wide_int_to_tree (TREE_TYPE (init), wtmp);
 	      extract_range_from_binary_expr (&maxvr, PLUS_EXPR,
@@ -4736,7 +4736,7 @@ masked_increment (wide_int val, wide_int
       res = bit - 1;
       res = (val + bit).and_not (res);
       res &= mask;
-      if (res.gtu_p (val))
+      if (wi::gtu_p (res, val))
 	return res ^ sgnbit;
     }
   return val ^ sgnbit;
@@ -6235,7 +6235,7 @@ search_for_addr_array (tree t, location_
 
       idx = mem_ref_offset (t);
       idx = idx.sdiv_trunc (addr_wide_int (el_sz));
-      if (idx.lts_p (0))
+      if (wi::lts_p (idx, 0))
 	{
 	  if (dump_file && (dump_flags & TDF_DETAILS))
 	    {
@@ -6247,9 +6247,7 @@ search_for_addr_array (tree t, location_
 		      "array subscript is below array bounds");
 	  TREE_NO_WARNING (t) = 1;
 	}
-      else if (idx.gts_p (addr_wide_int (up_bound)
-			  - low_bound
-			  + 1))
+      else if (wi::gts_p (idx, addr_wide_int (up_bound) - low_bound + 1))
 	{
 	  if (dump_file && (dump_flags & TDF_DETAILS))
 	    {
@@ -8681,7 +8679,7 @@ range_fits_type_p (value_range_t *vr, un
      a signed wide_int, while a negative value cannot be represented
      by an unsigned wide_int.  */
   if (src_sgn != dest_sgn
-      && (max_wide_int (vr->min).lts_p (0) || max_wide_int (vr->max).lts_p (0)))
+      && (wi::lts_p (vr->min, 0) || wi::lts_p (vr->max, 0)))
     return false;
 
   /* Then we can perform the conversion on both ends and compare
@@ -8985,7 +8983,7 @@ simplify_conversion_using_ranges (gimple
 
   /* If the first conversion is not injective, the second must not
      be widening.  */
-  if ((innermax - innermin).gtu_p (max_wide_int::mask (middle_prec, false))
+  if (wi::gtu_p (innermax - innermin, max_wide_int::mask (middle_prec, false))
       && middle_prec < final_prec)
     return false;
   /* We also want a medium value so that we can track the effect that
Index: gcc/tree.c
===================================================================
--- gcc/tree.c	2013-08-25 07:42:28.423609800 +0100
+++ gcc/tree.c	2013-08-25 07:42:29.203617339 +0100
@@ -1228,7 +1228,7 @@ wide_int_to_tree (tree type, const wide_
     case BOOLEAN_TYPE:
       /* Cache false or true.  */
       limit = 2;
-      if (cst.leu_p (1))
+      if (wi::leu_p (cst, 1))
 	ix = cst.to_uhwi ();
       break;
 
@@ -1247,7 +1247,7 @@ wide_int_to_tree (tree type, const wide_
 	      if (cst.to_uhwi () < (unsigned HOST_WIDE_INT) INTEGER_SHARE_LIMIT)
 		ix = cst.to_uhwi ();
 	    }
-	  else if (cst.ltu_p (INTEGER_SHARE_LIMIT))
+	  else if (wi::ltu_p (cst, INTEGER_SHARE_LIMIT))
 	    ix = cst.to_uhwi ();
 	}
       else
@@ -1264,7 +1264,7 @@ wide_int_to_tree (tree type, const wide_
 		  if (cst.to_shwi () < INTEGER_SHARE_LIMIT)
 		    ix = cst.to_shwi () + 1;
 		}
-	      else if (cst.lts_p (INTEGER_SHARE_LIMIT))
+	      else if (wi::lts_p (cst, INTEGER_SHARE_LIMIT))
 		ix = cst.to_shwi () + 1;
 	    }
 	}
@@ -1381,7 +1381,7 @@ cache_integer_cst (tree t)
     case BOOLEAN_TYPE:
       /* Cache false or true.  */
       limit = 2;
-      if (wide_int::ltu_p (t, 2))
+      if (wi::ltu_p (t, 2))
 	ix = TREE_INT_CST_ELT (t, 0);
       break;
 
@@ -1400,7 +1400,7 @@ cache_integer_cst (tree t)
 	      if (tree_to_uhwi (t) < (unsigned HOST_WIDE_INT) INTEGER_SHARE_LIMIT)
 		ix = tree_to_uhwi (t);
 	    }
-	  else if (wide_int::ltu_p (t, INTEGER_SHARE_LIMIT))
+	  else if (wi::ltu_p (t, INTEGER_SHARE_LIMIT))
 	    ix = tree_to_uhwi (t);
 	}
       else
@@ -1417,7 +1417,7 @@ cache_integer_cst (tree t)
 		  if (tree_to_shwi (t) < INTEGER_SHARE_LIMIT)
 		    ix = tree_to_shwi (t) + 1;
 		}
-	      else if (wide_int::ltu_p (t, INTEGER_SHARE_LIMIT))
+	      else if (wi::ltu_p (t, INTEGER_SHARE_LIMIT))
 		ix = tree_to_shwi (t) + 1;
 	    }
 	}
@@ -1451,7 +1451,7 @@ cache_integer_cst (tree t)
       /* If there is already an entry for the number verify it's the
          same.  */
       if (*slot)
-	gcc_assert (wide_int::eq_p (((tree)*slot), t));
+	gcc_assert (wi::eq_p (tree (*slot), t));
       else
 	/* Otherwise insert this one into the hash table.  */
 	*slot = t;
@@ -6757,7 +6757,7 @@ tree_int_cst_equal (const_tree t1, const
   prec2 = TYPE_PRECISION (TREE_TYPE (t2));
 
   if (prec1 == prec2)
-    return wide_int::eq_p (t1, t2);
+    return wi::eq_p (t1, t2);
   else if (prec1 < prec2)
     return (wide_int (t1)).force_to_size (prec2, TYPE_SIGN (TREE_TYPE (t1))) == t2;
   else
@@ -8562,7 +8562,7 @@ int_fits_type_p (const_tree c, const_tre
 
 	  if (c_neg && !t_neg)
 	    return false;
-	  if ((c_neg || !t_neg) && wc.ltu_p (wd))
+	  if ((c_neg || !t_neg) && wi::ltu_p (wc, wd))
 	    return false;
 	}
       else if (wc.cmp (wd, TYPE_SIGN (TREE_TYPE (type_low_bound))) < 0)
@@ -8583,7 +8583,7 @@ int_fits_type_p (const_tree c, const_tre
 
 	  if (t_neg && !c_neg)
 	    return false;
-	  if ((t_neg || !c_neg) && wc.gtu_p (wd))
+	  if ((t_neg || !c_neg) && wi::gtu_p (wc, wd))
 	    return false;
 	}
       else if (wc.cmp (wd, TYPE_SIGN (TREE_TYPE (type_high_bound))) > 0)
Index: gcc/tree.h
===================================================================
--- gcc/tree.h	2013-08-25 07:17:37.505554513 +0100
+++ gcc/tree.h	2013-08-25 07:42:29.204617349 +0100
@@ -1411,10 +1411,10 @@ #define TREE_LANG_FLAG_6(NODE) \
 /* Define additional fields and accessors for nodes representing constants.  */
 
 #define INT_CST_LT(A, B)				\
-  (wide_int::lts_p (A, B))
+  (wi::lts_p (A, B))
 
 #define INT_CST_LT_UNSIGNED(A, B)			\
-  (wide_int::ltu_p (A, B))
+  (wi::ltu_p (A, B))
 
 #define TREE_INT_CST_NUNITS(NODE) (INTEGER_CST_CHECK (NODE)->base.u.length)
 #define TREE_INT_CST_ELT(NODE, I) TREE_INT_CST_ELT_CHECK (NODE, I)
Index: gcc/wide-int.cc
===================================================================
--- gcc/wide-int.cc	2013-08-25 07:42:28.471610264 +0100
+++ gcc/wide-int.cc	2013-08-25 07:42:29.205617359 +0100
@@ -598,9 +598,9 @@ top_bit_of (const HOST_WIDE_INT *a, unsi
 
 /* Return true if OP0 == OP1.  */
 bool
-wide_int_ro::eq_p_large (const HOST_WIDE_INT *op0, unsigned int op0len,
-			 unsigned int prec,
-			 const HOST_WIDE_INT *op1, unsigned int op1len)
+wi::eq_p_large (const HOST_WIDE_INT *op0, unsigned int op0len,
+		unsigned int prec,
+		const HOST_WIDE_INT *op1, unsigned int op1len)
 {
   int l0 = op0len - 1;
   unsigned int small_prec = prec & (HOST_BITS_PER_WIDE_INT - 1);
@@ -628,10 +628,10 @@ wide_int_ro::eq_p_large (const HOST_WIDE
 
 /* Return true if OP0 < OP1 using signed comparisons.  */
 bool
-wide_int_ro::lts_p_large (const HOST_WIDE_INT *op0, unsigned int op0len,
-			  unsigned int p0,
-			  const HOST_WIDE_INT *op1, unsigned int op1len,
-			  unsigned int p1)
+wi::lts_p_large (const HOST_WIDE_INT *op0, unsigned int op0len,
+		 unsigned int p0,
+		 const HOST_WIDE_INT *op1, unsigned int op1len,
+		 unsigned int p1)
 {
   HOST_WIDE_INT s0, s1;
   unsigned HOST_WIDE_INT u0, u1;
@@ -709,8 +709,8 @@ wide_int_ro::cmps_large (const HOST_WIDE
 
 /* Return true if OP0 < OP1 using unsigned comparisons.  */
 bool
-wide_int_ro::ltu_p_large (const HOST_WIDE_INT *op0, unsigned int op0len, unsigned int p0,
-			  const HOST_WIDE_INT *op1, unsigned int op1len, unsigned int p1)
+wi::ltu_p_large (const HOST_WIDE_INT *op0, unsigned int op0len, unsigned int p0,
+		 const HOST_WIDE_INT *op1, unsigned int op1len, unsigned int p1)
 {
   unsigned HOST_WIDE_INT x0;
   unsigned HOST_WIDE_INT x1;
Index: gcc/wide-int.h
===================================================================
--- gcc/wide-int.h	2013-08-25 07:42:28.424609809 +0100
+++ gcc/wide-int.h	2013-08-25 08:23:14.445592968 +0100
@@ -304,6 +304,95 @@ signedp <unsigned long> (unsigned long)
   return false;
 }
 
+/* This class, which has no default implementation, is expected to
+   provide the following routines:
+
+   HOST_WIDE_INT *to_shwi (HOST_WIDE_INT *s, unsigned int *l, unsigned int *p,
+			   ... x)
+     -- Decompose integer X into a length, precision and array of
+	HOST_WIDE_INTs.  Store the length in *L, the precision in *P
+	and return the array.  S is available as scratch space if needed.  */
+template <typename T> struct wide_int_accessors;
+
+namespace wi
+{
+  template <typename T1, typename T2>
+  bool eq_p (const T1 &, const T2 &);
+
+  template <typename T1, typename T2>
+  bool lt_p (const T1 &, const T2 &, signop);
+
+  template <typename T1, typename T2>
+  bool lts_p (const T1 &, const T2 &);
+
+  template <typename T1, typename T2>
+  bool ltu_p (const T1 &, const T2 &);
+
+  template <typename T1, typename T2>
+  bool le_p (const T1 &, const T2 &, signop);
+
+  template <typename T1, typename T2>
+  bool les_p (const T1 &, const T2 &);
+
+  template <typename T1, typename T2>
+  bool leu_p (const T1 &, const T2 &);
+
+  template <typename T1, typename T2>
+  bool gt_p (const T1 &, const T2 &, signop);
+
+  template <typename T1, typename T2>
+  bool gts_p (const T1 &, const T2 &);
+
+  template <typename T1, typename T2>
+  bool gtu_p (const T1 &, const T2 &);
+
+  template <typename T1, typename T2>
+  bool ge_p (const T1 &, const T2 &, signop);
+
+  template <typename T1, typename T2>
+  bool ges_p (const T1 &, const T2 &);
+
+  template <typename T1, typename T2>
+  bool geu_p (const T1 &, const T2 &);
+
+  /* Comparisons.  */
+  bool eq_p_large (const HOST_WIDE_INT *, unsigned int, unsigned int,
+		   const HOST_WIDE_INT *, unsigned int);
+  bool lts_p_large (const HOST_WIDE_INT *, unsigned int, unsigned int,
+		    const HOST_WIDE_INT *, unsigned int, unsigned int);
+  bool ltu_p_large (const HOST_WIDE_INT *, unsigned int, unsigned int,
+		    const HOST_WIDE_INT *, unsigned int, unsigned int);
+  void check_precision (unsigned int *, unsigned int *, bool, bool);
+
+  template <typename T>
+  const HOST_WIDE_INT *to_shwi1 (HOST_WIDE_INT *, unsigned int *,
+				 unsigned int *, const T &);
+
+  template <typename T>
+  const HOST_WIDE_INT *to_shwi2 (HOST_WIDE_INT *, unsigned int *, const T &);
+}
+
+/* Decompose integer X into a length, precision and array of HOST_WIDE_INTs.
+   Store the length in *L, the precision in *P and return the array.
+   S is available as a scratch array if needed, and can be used as
+   the return value.  */
+template <typename T>
+inline const HOST_WIDE_INT *
+wi::to_shwi1 (HOST_WIDE_INT *s, unsigned int *l, unsigned int *p,
+	      const T &x)
+{
+  return wide_int_accessors <T>::to_shwi (s, l, p, x);
+}
+
+/* Like to_shwi1, but without the precision.  */
+template <typename T>
+inline const HOST_WIDE_INT *
+wi::to_shwi2 (HOST_WIDE_INT *s, unsigned int *l, const T &x)
+{
+  unsigned int p;
+  return wide_int_accessors <T>::to_shwi (s, l, &p, x);
+}
+
 class wide_int;
 
 class GTY(()) wide_int_ro
@@ -323,7 +412,6 @@ class GTY(()) wide_int_ro
   unsigned short len;
   unsigned int precision;
 
-  const HOST_WIDE_INT *get_val () const;
   wide_int_ro &operator = (const wide_int_ro &);
 
 public:
@@ -374,6 +462,7 @@ class GTY(()) wide_int_ro
   /* Public accessors for the interior of a wide int.  */
   unsigned short get_len () const;
   unsigned int get_precision () const;
+  const HOST_WIDE_INT *get_val () const;
   HOST_WIDE_INT elt (unsigned int) const;
 
   /* Comparative functions.  */
@@ -389,85 +478,10 @@ class GTY(()) wide_int_ro
   template <typename T>
   bool operator == (const T &) const;
 
-  template <typename T1, typename T2>
-  static bool eq_p (const T1 &, const T2 &);
-
   template <typename T>
   bool operator != (const T &) const;
 
   template <typename T>
-  bool lt_p (const T &, signop) const;
-
-  template <typename T1, typename T2>
-  static bool lt_p (const T1 &, const T2 &, signop);
-
-  template <typename T>
-  bool lts_p (const T &) const;
-
-  template <typename T1, typename T2>
-  static bool lts_p (const T1 &, const T2 &);
-
-  template <typename T>
-  bool ltu_p (const T &) const;
-
-  template <typename T1, typename T2>
-  static bool ltu_p (const T1 &, const T2 &);
-
-  template <typename T>
-  bool le_p (const T &, signop) const;
-
-  template <typename T1, typename T2>
-  static bool le_p (const T1 &, const T2 &, signop);
-
-  template <typename T>
-  bool les_p (const T &) const;
-
-  template <typename T1, typename T2>
-  static bool les_p (const T1 &, const T2 &);
-
-  template <typename T>
-  bool leu_p (const T &) const;
-
-  template <typename T1, typename T2>
-  static bool leu_p (const T1 &, const T2 &);
-
-  template <typename T>
-  bool gt_p (const T &, signop) const;
-
-  template <typename T1, typename T2>
-  static bool gt_p (const T1 &, const T2 &, signop);
-
-  template <typename T>
-  bool gts_p (const T &) const;
-
-  template <typename T1, typename T2>
-  static bool gts_p (const T1 &, const T2 &);
-
-  template <typename T>
-  bool gtu_p (const T &) const;
-
-  template <typename T1, typename T2>
-  static bool gtu_p (const T1 &, const T2 &);
-
-  template <typename T>
-  bool ge_p (const T &, signop) const;
-
-  template <typename T1, typename T2>
-  static bool ge_p (const T1 &, const T2 &, signop);
-
-  template <typename T>
-  bool ges_p (const T &) const;
-
-  template <typename T1, typename T2>
-  static bool ges_p (const T1 &, const T2 &);
-
-  template <typename T>
-  bool geu_p (const T &) const;
-
-  template <typename T1, typename T2>
-  static bool geu_p (const T1 &, const T2 &);
-
-  template <typename T>
   int cmp (const T &, signop) const;
 
   template <typename T>
@@ -705,18 +719,10 @@ class GTY(()) wide_int_ro
   /* Internal versions that do the work if the values do not fit in a HWI.  */
 
   /* Comparisons */
-  static bool eq_p_large (const HOST_WIDE_INT *, unsigned int, unsigned int,
-			  const HOST_WIDE_INT *, unsigned int);
-  static bool lts_p_large (const HOST_WIDE_INT *, unsigned int, unsigned int,
-			   const HOST_WIDE_INT *, unsigned int, unsigned int);
   static int cmps_large (const HOST_WIDE_INT *, unsigned int, unsigned int,
 			 const HOST_WIDE_INT *, unsigned int, unsigned int);
-  static bool ltu_p_large (const HOST_WIDE_INT *, unsigned int, unsigned int,
-			   const HOST_WIDE_INT *, unsigned int, unsigned int);
   static int cmpu_large (const HOST_WIDE_INT *, unsigned int, unsigned int,
 			 const HOST_WIDE_INT *, unsigned int, unsigned int);
-  static void check_precision (unsigned int *, unsigned int *, bool, bool);
-
 
   /* Logicals.  */
   static wide_int_ro and_large (const HOST_WIDE_INT *, unsigned int,
@@ -769,17 +775,6 @@ class GTY(()) wide_int_ro
   int trunc_shift (const HOST_WIDE_INT *, unsigned int, unsigned int,
 		   ShiftOp) const;
 
-  template <typename T>
-  static bool top_bit_set (T);
-
-  template <typename T>
-  static const HOST_WIDE_INT *to_shwi1 (HOST_WIDE_INT *, unsigned int *,
-					unsigned int *, const T &);
-
-  template <typename T>
-  static const HOST_WIDE_INT *to_shwi2 (HOST_WIDE_INT *, unsigned int *,
-					const T &);
-
 #ifdef DEBUG_WIDE_INT
   /* Debugging routines.  */
   static void debug_wa (const char *, const wide_int_ro &,
@@ -1163,51 +1158,11 @@ wide_int_ro::neg_p (signop sgn) const
   return sign_mask () != 0;
 }
 
-/* Return true if THIS == C.  If both operands have nonzero precisions,
-   the precisions must be the same.  */
-template <typename T>
-inline bool
-wide_int_ro::operator == (const T &c) const
-{
-  bool result;
-  HOST_WIDE_INT ws[WIDE_INT_MAX_ELTS];
-  const HOST_WIDE_INT *s;
-  unsigned int cl;
-  unsigned int p1, p2;
-
-  p1 = precision;
-
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, true, false);
-
-  if (p1 == 0)
-    /* There are prec 0 types and we need to do this to check their
-       min and max values.  */
-    result = (len == cl) && (val[0] == s[0]);
-  else if (p1 < HOST_BITS_PER_WIDE_INT)
-    {
-      unsigned HOST_WIDE_INT mask = ((HOST_WIDE_INT)1 << p1) - 1;
-      result = (val[0] & mask) == (s[0] & mask);
-    }
-  else if (p1 == HOST_BITS_PER_WIDE_INT)
-    result = val[0] == s[0];
-  else
-    result = eq_p_large (val, len, p1, s, cl);
-
-  if (result)
-    gcc_assert (len == cl);
-
-#ifdef DEBUG_WIDE_INT
-  debug_vwa ("wide_int_ro:: %d = (%s == %s)\n", result, *this, s, cl, p2);
-#endif
-  return result;
-}
-
 /* Return true if C1 == C2.  If both parameters have nonzero precisions,
    then those precisions must be equal.  */
 template <typename T1, typename T2>
 inline bool
-wide_int_ro::eq_p (const T1 &c1, const T2 &c2)
+wi::eq_p (const T1 &c1, const T2 &c2)
 {
   bool result;
   HOST_WIDE_INT ws1[WIDE_INT_MAX_ELTS];
@@ -1237,51 +1192,28 @@ wide_int_ro::eq_p (const T1 &c1, const T
   return result;
 }
 
-/* Return true if THIS != C.  If both parameters have nonzero precisions,
-   then those precisions must be equal.  */
+/* Return true if THIS == C.  If both operands have nonzero precisions,
+   the precisions must be the same.  */
 template <typename T>
 inline bool
-wide_int_ro::operator != (const T &c) const
+wide_int_ro::operator == (const T &c) const
 {
-  return !(*this == c);
+  return wi::eq_p (*this, c);
 }
 
-/* Return true if THIS < C using signed comparisons.  */
+/* Return true if THIS != C.  If both parameters have nonzero precisions,
+   then those precisions must be equal.  */
 template <typename T>
 inline bool
-wide_int_ro::lts_p (const T &c) const
+wide_int_ro::operator != (const T &c) const
 {
-  bool result;
-  HOST_WIDE_INT ws[WIDE_INT_MAX_ELTS];
-  const HOST_WIDE_INT *s;
-  unsigned int cl;
-  unsigned int p1, p2;
-
-  p1 = precision;
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, false, true);
-
-  if (p1 <= HOST_BITS_PER_WIDE_INT
-      && p2 <= HOST_BITS_PER_WIDE_INT)
-    {
-      gcc_assert (cl != 0);
-      HOST_WIDE_INT x0 = sext_hwi (val[0], p1);
-      HOST_WIDE_INT x1 = sext_hwi (s[0], p2);
-      result = x0 < x1;
-    }
-  else
-    result = lts_p_large (val, len, p1, s, cl, p2);
-
-#ifdef DEBUG_WIDE_INT
-  debug_vwa ("wide_int_ro:: %d = (%s lts_p %s\n", result, *this, s, cl, p2);
-#endif
-  return result;
+  return !wi::eq_p (*this, c);
 }
 
 /* Return true if C1 < C2 using signed comparisons.  */
 template <typename T1, typename T2>
 inline bool
-wide_int_ro::lts_p (const T1 &c1, const T2 &c2)
+wi::lts_p (const T1 &c1, const T2 &c2)
 {
   bool result;
   HOST_WIDE_INT ws1[WIDE_INT_MAX_ELTS];
@@ -1305,38 +1237,8 @@ wide_int_ro::lts_p (const T1 &c1, const
     result = lts_p_large (s1, cl1, p1, s2, cl2, p2);
 
 #ifdef DEBUG_WIDE_INT
-  debug_vaa ("wide_int_ro:: %d = (%s lts_p %s\n", result, s1, cl1, p1, s2, cl2, p2);
-#endif
-  return result;
-}
-
-/* Return true if THIS < C using unsigned comparisons.  */
-template <typename T>
-inline bool
-wide_int_ro::ltu_p (const T &c) const
-{
-  bool result;
-  HOST_WIDE_INT ws[WIDE_INT_MAX_ELTS];
-  const HOST_WIDE_INT *s;
-  unsigned int cl;
-  unsigned int p1, p2;
-
-  p1 = precision;
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, false, true);
-
-  if (p1 <= HOST_BITS_PER_WIDE_INT
-      && p2 <= HOST_BITS_PER_WIDE_INT)
-    {
-      unsigned HOST_WIDE_INT x0 = zext_hwi (val[0], p1);
-      unsigned HOST_WIDE_INT x1 = zext_hwi (s[0], p2);
-      result = x0 < x1;
-    }
-  else
-    result = ltu_p_large (val, len, p1, s, cl, p2);
-
-#ifdef DEBUG_WIDE_INT
-  debug_vwa ("wide_int_ro:: %d = (%s ltu_p %s)\n", result, *this, s, cl, p2);
+  wide_int_ro::debug_vaa ("wide_int_ro:: %d = (%s lts_p %s\n",
+			  result, s1, cl1, p1, s2, cl2, p2);
 #endif
   return result;
 }
@@ -1344,7 +1246,7 @@ wide_int_ro::ltu_p (const T &c) const
 /* Return true if C1 < C2 using unsigned comparisons.  */
 template <typename T1, typename T2>
 inline bool
-wide_int_ro::ltu_p (const T1 &c1, const T2 &c2)
+wi::ltu_p (const T1 &c1, const T2 &c2)
 {
   bool result;
   HOST_WIDE_INT ws1[WIDE_INT_MAX_ELTS];
@@ -1372,21 +1274,10 @@ wide_int_ro::ltu_p (const T1 &c1, const
   return result;
 }
 
-/* Return true if THIS < C.  Signedness is indicated by SGN.  */
-template <typename T>
-inline bool
-wide_int_ro::lt_p (const T &c, signop sgn) const
-{
-  if (sgn == SIGNED)
-    return lts_p (c);
-  else
-    return ltu_p (c);
-}
-
 /* Return true if C1 < C2.  Signedness is indicated by SGN.  */
 template <typename T1, typename T2>
 inline bool
-wide_int_ro::lt_p (const T1 &c1, const T2 &c2, signop sgn)
+wi::lt_p (const T1 &c1, const T2 &c2, signop sgn)
 {
   if (sgn == SIGNED)
     return lts_p (c1, c2);
@@ -1394,53 +1285,26 @@ wide_int_ro::lt_p (const T1 &c1, const T
     return ltu_p (c1, c2);
 }
 
-/* Return true if THIS <= C using signed comparisons.  */
-template <typename T>
-inline bool
-wide_int_ro::les_p (const T &c) const
-{
-  return !gts_p (c);
-}
-
 /* Return true if C1 <= C2 using signed comparisons.  */
 template <typename T1, typename T2>
 inline bool
-wide_int_ro::les_p (const T1 &c1, const T2 &c2)
+wi::les_p (const T1 &c1, const T2 &c2)
 {
   return !gts_p (c1, c2);
 }
 
-/* Return true if THIS <= C using unsigned comparisons.  */
-template <typename T>
-inline bool
-wide_int_ro::leu_p (const T &c) const
-{
-  return !gtu_p (c);
-}
-
 /* Return true if C1 <= C2 using unsigned comparisons.  */
 template <typename T1, typename T2>
 inline bool
-wide_int_ro::leu_p (const T1 &c1, const T2 &c2)
+wi::leu_p (const T1 &c1, const T2 &c2)
 {
   return !gtu_p (c1, c2);
 }
 
-/* Return true if THIS <= C.  Signedness is indicated by SGN.  */
-template <typename T>
-inline bool
-wide_int_ro::le_p (const T &c, signop sgn) const
-{
-  if (sgn == SIGNED)
-    return les_p (c);
-  else
-    return leu_p (c);
-}
-
 /* Return true if C1 <= C2.  Signedness is indicated by SGN.  */
 template <typename T1, typename T2>
 inline bool
-wide_int_ro::le_p (const T1 &c1, const T2 &c2, signop sgn)
+wi::le_p (const T1 &c1, const T2 &c2, signop sgn)
 {
   if (sgn == SIGNED)
     return les_p (c1, c2);
@@ -1448,53 +1312,26 @@ wide_int_ro::le_p (const T1 &c1, const T
     return leu_p (c1, c2);
 }
 
-/* Return true if THIS > C using signed comparisons.  */
-template <typename T>
-inline bool
-wide_int_ro::gts_p (const T &c) const
-{
-  return lts_p (c, *this);
-}
-
 /* Return true if C1 > C2 using signed comparisons.  */
 template <typename T1, typename T2>
 inline bool
-wide_int_ro::gts_p (const T1 &c1, const T2 &c2)
+wi::gts_p (const T1 &c1, const T2 &c2)
 {
   return lts_p (c2, c1);
 }
 
-/* Return true if THIS > C using unsigned comparisons.  */
-template <typename T>
-inline bool
-wide_int_ro::gtu_p (const T &c) const
-{
-  return ltu_p (c, *this);
-}
-
 /* Return true if C1 > C2 using unsigned comparisons.  */
 template <typename T1, typename T2>
 inline bool
-wide_int_ro::gtu_p (const T1 &c1, const T2 &c2)
+wi::gtu_p (const T1 &c1, const T2 &c2)
 {
   return ltu_p (c2, c1);
 }
 
-/* Return true if THIS > C.  Signedness is indicated by SGN.  */
-template <typename T>
-inline bool
-wide_int_ro::gt_p (const T &c, signop sgn) const
-{
-  if (sgn == SIGNED)
-    return gts_p (c);
-  else
-    return gtu_p (c);
-}
-
 /* Return true if C1 > C2.  Signedness is indicated by SGN.  */
 template <typename T1, typename T2>
 inline bool
-wide_int_ro::gt_p (const T1 &c1, const T2 &c2, signop sgn)
+wi::gt_p (const T1 &c1, const T2 &c2, signop sgn)
 {
   if (sgn == SIGNED)
     return gts_p (c1, c2);
@@ -1502,53 +1339,26 @@ wide_int_ro::gt_p (const T1 &c1, const T
     return gtu_p (c1, c2);
 }
 
-/* Return true if THIS >= C using signed comparisons.  */
-template <typename T>
-inline bool
-wide_int_ro::ges_p (const T &c) const
-{
-  return !lts_p (c);
-}
-
 /* Return true if C1 >= C2 using signed comparisons.  */
 template <typename T1, typename T2>
 inline bool
-wide_int_ro::ges_p (const T1 &c1, const T2 &c2)
+wi::ges_p (const T1 &c1, const T2 &c2)
 {
   return !lts_p (c1, c2);
 }
 
-/* Return true if THIS >= C using unsigned comparisons.  */
-template <typename T>
-inline bool
-wide_int_ro::geu_p (const T &c) const
-{
-  return !ltu_p (c);
-}
-
 /* Return true if C1 >= C2 using unsigned comparisons.  */
 template <typename T1, typename T2>
 inline bool
-wide_int_ro::geu_p (const T1 &c1, const T2 &c2)
+wi::geu_p (const T1 &c1, const T2 &c2)
 {
   return !ltu_p (c1, c2);
 }
 
-/* Return true if THIS >= C.  Signedness is indicated by SGN.  */
-template <typename T>
-inline bool
-wide_int_ro::ge_p (const T &c, signop sgn) const
-{
-  if (sgn == SIGNED)
-    return ges_p (c);
-  else
-    return geu_p (c);
-}
-
 /* Return true if C1 >= C2.  Signedness is indicated by SGN.  */
 template <typename T1, typename T2>
 inline bool
-wide_int_ro::ge_p (const T1 &c1, const T2 &c2, signop sgn)
+wi::ge_p (const T1 &c1, const T2 &c2, signop sgn)
 {
   if (sgn == SIGNED)
     return ges_p (c1, c2);
@@ -1568,7 +1378,7 @@ wide_int_ro::cmps (const T &c) const
   unsigned int cl;
   unsigned int prec;
 
-  s = to_shwi1 (ws, &cl, &prec, c);
+  s = wi::to_shwi1 (ws, &cl, &prec, c);
   if (prec == 0)
     prec = precision;
 
@@ -1606,7 +1416,7 @@ wide_int_ro::cmpu (const T &c) const
   unsigned int cl;
   unsigned int prec;
 
-  s = to_shwi1 (ws, &cl, &prec, c);
+  s = wi::to_shwi1 (ws, &cl, &prec, c);
   if (prec == 0)
     prec = precision;
 
@@ -1681,13 +1491,12 @@ wide_int_ro::min (const T &c, signop sgn
 
   p1 = precision;
 
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, true, true);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, true, true);
 
-  if (sgn == SIGNED)
-    return lts_p (c) ? (*this) : wide_int_ro::from_array (s, cl, p1, false);
-  else
-    return ltu_p (c) ? (*this) : wide_int_ro::from_array (s, cl, p1, false);
+  return (wi::lt_p (*this, c, sgn)
+	  ? *this
+	  : wide_int_ro::from_array (s, cl, p1, false));
 }
 
 /* Return the signed or unsigned min of THIS and OP1.  */
@@ -1695,9 +1504,9 @@ wide_int_ro::min (const T &c, signop sgn
 wide_int_ro::min (const wide_int_ro &op1, signop sgn) const
 {
   if (sgn == SIGNED)
-    return lts_p (op1) ? (*this) : op1;
+    return wi::lts_p (*this, op1) ? *this : op1;
   else
-    return ltu_p (op1) ? (*this) : op1;
+    return wi::ltu_p (*this, op1) ? *this : op1;
 }
 
 /* Return the signed or unsigned max of THIS and C.  */
@@ -1712,22 +1521,18 @@ wide_int_ro::max (const T &c, signop sgn
 
   p1 = precision;
 
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, true, true);
-  if (sgn == SIGNED)
-    return gts_p (c) ? (*this) : wide_int_ro::from_array (s, cl, p1, false);
-  else
-    return gtu_p (c) ? (*this) : wide_int_ro::from_array (s, cl, p1, false);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, true, true);
+  return (wi::gt_p (*this, c, sgn)
+	  ? *this
+	  : wide_int_ro::from_array (s, cl, p1, false));
 }
 
 /* Return the signed or unsigned max of THIS and OP1.  */
 inline wide_int_ro
 wide_int_ro::max (const wide_int_ro &op1, signop sgn) const
 {
-  if (sgn == SIGNED)
-    return gts_p (op1) ? (*this) : op1;
-  else
-    return gtu_p (op1) ? (*this) : op1;
+  return wi::gt_p (*this, op1, sgn) ? *this : op1;
 }
 
 /* Return the signed min of THIS and C.  */
@@ -1742,17 +1547,19 @@ wide_int_ro::smin (const T &c) const
 
   p1 = precision;
 
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, true, true);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, true, true);
 
-  return lts_p (c) ? (*this) : wide_int_ro::from_array (s, cl, p1, false);
+  return (wi::lts_p (*this, c)
+	  ? *this
+	  : wide_int_ro::from_array (s, cl, p1, false));
 }
 
 /* Return the signed min of THIS and OP1.  */
 inline wide_int_ro
 wide_int_ro::smin (const wide_int_ro &op1) const
 {
-  return lts_p (op1) ? (*this) : op1;
+  return wi::lts_p (*this, op1) ? *this : op1;
 }
 
 /* Return the signed max of THIS and C.  */
@@ -1767,17 +1574,19 @@ wide_int_ro::smax (const T &c) const
 
   p1 = precision;
 
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, true, true);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, true, true);
 
-  return gts_p (c) ? (*this) : wide_int_ro::from_array (s, cl, p1, false);
+  return (wi::gts_p (*this, c)
+	  ? *this
+	  : wide_int_ro::from_array (s, cl, p1, false));
 }
 
 /* Return the signed max of THIS and OP1.  */
 inline wide_int_ro
 wide_int_ro::smax (const wide_int_ro &op1) const
 {
-  return gts_p (op1) ? (*this) : op1;
+  return wi::gts_p (*this, op1) ? *this : op1;
 }
 
 /* Return the unsigned min of THIS and C.  */
@@ -1792,15 +1601,17 @@ wide_int_ro::umin (const T &c) const
 
   p1 = precision;
 
-  s = to_shwi1 (ws, &cl, &p2, c);
-  return ltu_p (c) ? (*this) : wide_int_ro::from_array (s, cl, p1, false);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  return (wi::ltu_p (*this, c)
+	  ? *this
+	  : wide_int_ro::from_array (s, cl, p1, false));
 }
 
 /* Return the unsigned min of THIS and OP1.  */
 inline wide_int_ro
 wide_int_ro::umin (const wide_int_ro &op1) const
 {
-  return ltu_p (op1) ? (*this) : op1;
+  return wi::ltu_p (*this, op1) ? *this : op1;
 }
 
 /* Return the unsigned max of THIS and C.  */
@@ -1815,17 +1626,19 @@ wide_int_ro::umax (const T &c) const
 
   p1 = precision;
 
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, true, true);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, true, true);
 
-  return gtu_p (c) ? (*this) : wide_int_ro::from_array (s, cl, p1, false);
+  return (wi::gtu_p (*this, c)
+	  ? *this
+	  : wide_int_ro::from_array (s, cl, p1, false));
 }
 
 /* Return the unsigned max of THIS and OP1.  */
 inline wide_int_ro
 wide_int_ro::umax (const wide_int_ro &op1) const
 {
-  return gtu_p (op1) ? (*this) : op1;
+  return wi::gtu_p (*this, op1) ? *this : op1;
 }
 
 /* Return THIS extended to PREC.  The signedness of the extension is
@@ -1891,8 +1704,8 @@ wide_int_ro::operator & (const T &c) con
   unsigned int p1, p2;
 
   p1 = precision;
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, true, true);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, true, true);
 
   if (p1 <= HOST_BITS_PER_WIDE_INT)
     {
@@ -1921,8 +1734,8 @@ wide_int_ro::and_not (const T &c) const
   unsigned int p1, p2;
 
   p1 = precision;
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, true, true);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, true, true);
 
   if (p1 <= HOST_BITS_PER_WIDE_INT)
     {
@@ -1973,8 +1786,8 @@ wide_int_ro::operator | (const T &c) con
   unsigned int p1, p2;
 
   p1 = precision;
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, true, true);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, true, true);
 
   if (p1 <= HOST_BITS_PER_WIDE_INT)
     {
@@ -2003,8 +1816,8 @@ wide_int_ro::or_not (const T &c) const
   unsigned int p1, p2;
 
   p1 = precision;
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, true, true);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, true, true);
 
   if (p1 <= HOST_BITS_PER_WIDE_INT)
     {
@@ -2033,8 +1846,8 @@ wide_int_ro::operator ^ (const T &c) con
   unsigned int p1, p2;
 
   p1 = precision;
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, true, true);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, true, true);
 
   if (p1 <= HOST_BITS_PER_WIDE_INT)
     {
@@ -2063,8 +1876,8 @@ wide_int_ro::operator + (const T &c) con
   unsigned int p1, p2;
 
   p1 = precision;
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, true, true);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, true, true);
 
   if (p1 <= HOST_BITS_PER_WIDE_INT)
     {
@@ -2096,8 +1909,8 @@ wide_int_ro::add (const T &c, signop sgn
   unsigned int p1, p2;
 
   p1 = precision;
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, true, true);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, true, true);
 
   if (p1 <= HOST_BITS_PER_WIDE_INT)
     {
@@ -2141,8 +1954,8 @@ wide_int_ro::operator * (const T &c) con
   unsigned int p1, p2;
 
   p1 = precision;
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, true, true);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, true, true);
 
   if (p1 <= HOST_BITS_PER_WIDE_INT)
     {
@@ -2176,8 +1989,8 @@ wide_int_ro::mul (const T &c, signop sgn
   if (overflow)
     *overflow = false;
   p1 = precision;
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, true, true);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, true, true);
 
   return mul_internal (false, false,
 		       val, len, p1,
@@ -2217,8 +2030,8 @@ wide_int_ro::mul_full (const T &c, signo
   unsigned int p1, p2;
 
   p1 = precision;
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, true, true);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, true, true);
 
   return mul_internal (false, true,
 		       val, len, p1,
@@ -2257,8 +2070,8 @@ wide_int_ro::mul_high (const T &c, signo
   unsigned int p1, p2;
 
   p1 = precision;
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, true, true);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, true, true);
 
   return mul_internal (true, false,
 		       val, len, p1,
@@ -2298,8 +2111,8 @@ wide_int_ro::operator - (const T &c) con
   unsigned int p1, p2;
 
   p1 = precision;
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, true, true);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, true, true);
 
   if (p1 <= HOST_BITS_PER_WIDE_INT)
     {
@@ -2331,8 +2144,8 @@ wide_int_ro::sub (const T &c, signop sgn
   unsigned int p1, p2;
 
   p1 = precision;
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, true, true);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, true, true);
 
   if (p1 <= HOST_BITS_PER_WIDE_INT)
     {
@@ -2379,8 +2192,8 @@ wide_int_ro::div_trunc (const T &c, sign
   if (overflow)
     *overflow = false;
   p1 = precision;
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, false, true);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, false, true);
 
   return divmod_internal (true, val, len, p1, s, cl, p2, sgn,
 			  &remainder, false, overflow);
@@ -2420,8 +2233,8 @@ wide_int_ro::div_floor (const T &c, sign
   if (overflow)
     *overflow = false;
   p1 = precision;
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, false, true);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, false, true);
 
   return divmod_internal (true, val, len, p1, s, cl, p2, sgn,
 			  &remainder, false, overflow);
@@ -2461,8 +2274,8 @@ wide_int_ro::div_ceil (const T &c, signo
   if (overflow)
     *overflow = false;
   p1 = precision;
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, false, true);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, false, true);
 
   quotient = divmod_internal (true, val, len, p1, s, cl, p2, sgn,
 			      &remainder, true, overflow);
@@ -2490,8 +2303,8 @@ wide_int_ro::div_round (const T &c, sign
   if (overflow)
     *overflow = false;
   p1 = precision;
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, false, true);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, false, true);
 
   quotient = divmod_internal (true, val, len, p1, s, cl, p2, sgn,
 			      &remainder, true, overflow);
@@ -2505,7 +2318,7 @@ wide_int_ro::div_round (const T &c, sign
 	  wide_int_ro p_divisor = divisor.neg_p (SIGNED) ? -divisor : divisor;
 	  p_divisor = p_divisor.rshiftu_large (1);
 
-	  if (p_divisor.gts_p (p_remainder))
+	  if (wi::gts_p (p_divisor, p_remainder))
 	    {
 	      if (quotient.neg_p (SIGNED))
 		return quotient - 1;
@@ -2516,7 +2329,7 @@ wide_int_ro::div_round (const T &c, sign
       else
 	{
 	  wide_int_ro p_divisor = divisor.rshiftu_large (1);
-	  if (p_divisor.gtu_p (remainder))
+	  if (wi::gtu_p (p_divisor, remainder))
 	    return quotient + 1;
 	}
     }
@@ -2537,8 +2350,8 @@ wide_int_ro::divmod_trunc (const T &c, w
   unsigned int p1, p2;
 
   p1 = precision;
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, false, true);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, false, true);
 
   return divmod_internal (true, val, len, p1, s, cl, p2, sgn,
 			  remainder, true, 0);
@@ -2575,8 +2388,8 @@ wide_int_ro::divmod_floor (const T &c, w
   unsigned int p1, p2;
 
   p1 = precision;
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, false, true);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, false, true);
 
   quotient = divmod_internal (true, val, len, p1, s, cl, p2, sgn,
 			      remainder, true, 0);
@@ -2613,8 +2426,8 @@ wide_int_ro::mod_trunc (const T &c, sign
   if (overflow)
     *overflow = false;
   p1 = precision;
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, false, true);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, false, true);
 
   divmod_internal (false, val, len, p1, s, cl, p2, sgn,
 		   &remainder, true, overflow);
@@ -2655,8 +2468,8 @@ wide_int_ro::mod_floor (const T &c, sign
   if (overflow)
     *overflow = false;
   p1 = precision;
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, false, true);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, false, true);
 
   quotient = divmod_internal (true, val, len, p1, s, cl, p2, sgn,
 			      &remainder, true, overflow);
@@ -2692,8 +2505,8 @@ wide_int_ro::mod_ceil (const T &c, signo
   if (overflow)
     *overflow = false;
   p1 = precision;
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, false, true);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, false, true);
 
   quotient = divmod_internal (true, val, len, p1, s, cl, p2, sgn,
 			      &remainder, true, overflow);
@@ -2721,8 +2534,8 @@ wide_int_ro::mod_round (const T &c, sign
   if (overflow)
     *overflow = false;
   p1 = precision;
-  s = to_shwi1 (ws, &cl, &p2, c);
-  check_precision (&p1, &p2, false, true);
+  s = wi::to_shwi1 (ws, &cl, &p2, c);
+  wi::check_precision (&p1, &p2, false, true);
 
   quotient = divmod_internal (true, val, len, p1, s, cl, p2, sgn,
 			      &remainder, true, overflow);
@@ -2737,7 +2550,7 @@ wide_int_ro::mod_round (const T &c, sign
 	  wide_int_ro p_divisor = divisor.neg_p (SIGNED) ? -divisor : divisor;
 	  p_divisor = p_divisor.rshiftu_large (1);
 
-	  if (p_divisor.gts_p (p_remainder))
+	  if (wi::gts_p (p_divisor, p_remainder))
 	    {
 	      if (quotient.neg_p (SIGNED))
 		return remainder + divisor;
@@ -2748,7 +2561,7 @@ wide_int_ro::mod_round (const T &c, sign
       else
 	{
 	  wide_int_ro p_divisor = divisor.rshiftu_large (1);
-	  if (p_divisor.gtu_p (remainder))
+	  if (wi::gtu_p (p_divisor, remainder))
 	    return remainder - divisor;
 	}
     }
@@ -2768,7 +2581,7 @@ wide_int_ro::lshift (const T &c, unsigne
   unsigned int cl;
   HOST_WIDE_INT shift;
 
-  s = to_shwi2 (ws, &cl, c);
+  s = wi::to_shwi2 (ws, &cl, c);
 
   gcc_checking_assert (precision);
 
@@ -2806,7 +2619,7 @@ wide_int_ro::lshift_widen (const T &c, u
   unsigned int cl;
   HOST_WIDE_INT shift;
 
-  s = to_shwi2 (ws, &cl, c);
+  s = wi::to_shwi2 (ws, &cl, c);
 
   gcc_checking_assert (precision);
   gcc_checking_assert (res_prec);
@@ -2843,7 +2656,7 @@ wide_int_ro::lrotate (const T &c, unsign
   const HOST_WIDE_INT *s;
   unsigned int cl;
 
-  s = to_shwi2 (ws, &cl, c);
+  s = wi::to_shwi2 (ws, &cl, c);
 
   return lrotate ((unsigned HOST_WIDE_INT) s[0], prec);
 }
@@ -2901,7 +2714,7 @@ wide_int_ro::rshiftu (const T &c, unsign
   unsigned int cl;
   HOST_WIDE_INT shift;
 
-  s = to_shwi2 (ws, &cl, c);
+  s = wi::to_shwi2 (ws, &cl, c);
   gcc_checking_assert (precision);
   shift = trunc_shift (s, cl, bitsize, trunc_op);
 
@@ -2944,7 +2757,7 @@ wide_int_ro::rshifts (const T &c, unsign
   unsigned int cl;
   HOST_WIDE_INT shift;
 
-  s = to_shwi2 (ws, &cl, c);
+  s = wi::to_shwi2 (ws, &cl, c);
   gcc_checking_assert (precision);
   shift = trunc_shift (s, cl, bitsize, trunc_op);
 
@@ -2989,7 +2802,7 @@ wide_int_ro::rrotate (const T &c, unsign
   const HOST_WIDE_INT *s;
   unsigned int cl;
 
-  s = to_shwi2 (ws, &cl, c);
+  s = wi::to_shwi2 (ws, &cl, c);
   return rrotate ((unsigned HOST_WIDE_INT) s[0], prec);
 }
 
@@ -3080,25 +2893,26 @@ wide_int_ro::trunc_shift (const HOST_WID
     return cnt[0] & (bitsize - 1);
 }
 
+/* Implementation of wide_int_accessors for primitive integer types
+   like "int".  */
+template <typename T>
+struct primitive_wide_int_accessors
+{
+  static const HOST_WIDE_INT *to_shwi (HOST_WIDE_INT *, unsigned int *,
+				       unsigned int *, const T &);
+};
+
 template <typename T>
 inline bool
-wide_int_ro::top_bit_set (T x)
+top_bit_set (T x)
 {
-  return (x >> (sizeof (x)*8 - 1)) != 0;
+  return (x >> (sizeof (x) * 8 - 1)) != 0;
 }
 
-/* The following template and its overrides are used for the first
-   and second operand of static binary comparison functions.
-   These have been implemented so that pointer copying is done
-   from the rep of the operands rather than actual data copying.
-   This is safe even for garbage collected objects since the value
-   is immediately throw away.
-
-   This template matches all integers.  */
 template <typename T>
 inline const HOST_WIDE_INT *
-wide_int_ro::to_shwi1 (HOST_WIDE_INT *s, unsigned int *l, unsigned int *p,
-		       const T &x)
+primitive_wide_int_accessors <T>::to_shwi (HOST_WIDE_INT *s, unsigned int *l,
+					   unsigned int *p, const T &x)
 {
   s[0] = x;
   if (signedp (x)
@@ -3114,29 +2928,23 @@ wide_int_ro::to_shwi1 (HOST_WIDE_INT *s,
   return s;
 }
 
-/* The following template and its overrides are used for the second
-   operand of binary functions.  These have been implemented so that
-   pointer copying is done from the rep of the second operand rather
-   than actual data copying.  This is safe even for garbage collected
-   objects since the value is immediately throw away.
+template <>
+struct wide_int_accessors <int>
+  : public primitive_wide_int_accessors <int> {};
 
-   The next template matches all integers.  */
-template <typename T>
-inline const HOST_WIDE_INT *
-wide_int_ro::to_shwi2 (HOST_WIDE_INT *s, unsigned int *l, const T &x)
-{
-  s[0] = x;
-  if (signedp (x)
-      || sizeof (T) < sizeof (HOST_WIDE_INT)
-      || ! top_bit_set (x))
-    *l = 1;
-  else
-    {
-      s[1] = 0;
-      *l = 2;
-    }
-  return s;
-}
+template <>
+struct wide_int_accessors <unsigned int>
+  : public primitive_wide_int_accessors <unsigned int> {};
+
+#if HOST_BITS_PER_INT != HOST_BITS_PER_WIDE_INT
+template <>
+struct wide_int_accessors <HOST_WIDE_INT>
+  : public primitive_wide_int_accessors <HOST_WIDE_INT> {};
+
+template <>
+struct wide_int_accessors <unsigned HOST_WIDE_INT>
+  : public primitive_wide_int_accessors <unsigned HOST_WIDE_INT> {};
+#endif
 
 inline wide_int::wide_int () {}
 
@@ -3275,7 +3083,6 @@ class GTY(()) fixed_wide_int : public wi
 protected:
   fixed_wide_int &operator = (const wide_int &);
   fixed_wide_int (const wide_int_ro);
-  const HOST_WIDE_INT *get_val () const;
 
   using wide_int_ro::val;
 
@@ -3285,16 +3092,8 @@ class GTY(()) fixed_wide_int : public wi
   using wide_int_ro::to_short_addr;
   using wide_int_ro::fits_uhwi_p;
   using wide_int_ro::fits_shwi_p;
-  using wide_int_ro::gtu_p;
-  using wide_int_ro::gts_p;
-  using wide_int_ro::geu_p;
-  using wide_int_ro::ges_p;
   using wide_int_ro::to_shwi;
   using wide_int_ro::operator ==;
-  using wide_int_ro::ltu_p;
-  using wide_int_ro::lts_p;
-  using wide_int_ro::leu_p;
-  using wide_int_ro::les_p;
   using wide_int_ro::to_uhwi;
   using wide_int_ro::cmps;
   using wide_int_ro::neg_p;
@@ -3510,13 +3309,6 @@ inline fixed_wide_int <bitsize>::fixed_w
 }
 
 template <int bitsize>
-inline const HOST_WIDE_INT *
-fixed_wide_int <bitsize>::get_val () const
-{
-  return val;
-}
-
-template <int bitsize>
 inline fixed_wide_int <bitsize>
 fixed_wide_int <bitsize>::from_wide_int (const wide_int &w)
 {
@@ -4165,118 +3957,62 @@ extern void gt_pch_nx(max_wide_int*);
 
 extern addr_wide_int mem_ref_offset (const_tree);
 
-/* The wide-int overload templates.  */
-
 template <>
-inline const HOST_WIDE_INT*
-wide_int_ro::to_shwi1 (HOST_WIDE_INT *s ATTRIBUTE_UNUSED,
-		       unsigned int *l, unsigned int *p,
-		       const wide_int_ro &y)
-{
-  *p = y.precision;
-  *l = y.len;
-  return y.val;
-}
-
-template <>
-inline const HOST_WIDE_INT*
-wide_int_ro::to_shwi1 (HOST_WIDE_INT *s ATTRIBUTE_UNUSED,
-		       unsigned int *l, unsigned int *p,
-		       const wide_int &y)
-{
-  *p = y.precision;
-  *l = y.len;
-  return y.val;
-}
-
-
-template <>
-inline const HOST_WIDE_INT*
-wide_int_ro::to_shwi1 (HOST_WIDE_INT *s ATTRIBUTE_UNUSED,
-		       unsigned int *l, unsigned int *p,
-		       const fixed_wide_int <addr_max_precision> &y)
+struct wide_int_accessors <wide_int_ro>
 {
-  *p = y.get_precision ();
-  *l = y.get_len ();
-  return y.get_val ();
-}
+  static const HOST_WIDE_INT *to_shwi (HOST_WIDE_INT *, unsigned int *,
+				       unsigned int *, const wide_int_ro &);
+};
 
-#if addr_max_precision != MAX_BITSIZE_MODE_ANY_INT
-template <>
-inline const HOST_WIDE_INT*
-wide_int_ro::to_shwi1 (HOST_WIDE_INT *s ATTRIBUTE_UNUSED,
-		       unsigned int *l, unsigned int *p,
-		       const fixed_wide_int <MAX_BITSIZE_MODE_ANY_INT> &y)
+inline const HOST_WIDE_INT *
+wide_int_accessors <wide_int_ro>::to_shwi (HOST_WIDE_INT *, unsigned int *l,
+					   unsigned int *p,
+					   const wide_int_ro &y)
 {
   *p = y.get_precision ();
   *l = y.get_len ();
   return y.get_val ();
 }
-#endif
 
 template <>
-inline const HOST_WIDE_INT*
-wide_int_ro::to_shwi2 (HOST_WIDE_INT *s ATTRIBUTE_UNUSED,
-		       unsigned int *l, const wide_int &y)
-{
-  *l = y.len;
-  return y.val;
-}
+struct wide_int_accessors <wide_int>
+  : public wide_int_accessors <wide_int_ro> {};
 
+template <>
+template <int N>
+struct wide_int_accessors <fixed_wide_int <N> >
+  : public wide_int_accessors <wide_int_ro> {};
 
 /* The tree and const_tree overload templates.   */
 template <>
-inline const HOST_WIDE_INT*
-wide_int_ro::to_shwi1 (HOST_WIDE_INT *s ATTRIBUTE_UNUSED,
-		       unsigned int *l, unsigned int *p,
-		       const tree &tcst)
+struct wide_int_accessors <const_tree>
 {
-  tree type = TREE_TYPE (tcst);
-
-  *p = TYPE_PRECISION (type);
-  *l = TREE_INT_CST_NUNITS (tcst);
-  return (const HOST_WIDE_INT*)&TREE_INT_CST_ELT (tcst, 0);
-}
+  static const HOST_WIDE_INT *to_shwi (HOST_WIDE_INT *, unsigned int *,
+				       unsigned int *, const_tree);
+};
 
-template <>
-inline const HOST_WIDE_INT*
-wide_int_ro::to_shwi1 (HOST_WIDE_INT *s ATTRIBUTE_UNUSED,
-		       unsigned int *l, unsigned int *p,
-		       const const_tree &tcst)
+inline const HOST_WIDE_INT *
+wide_int_accessors <const_tree>::to_shwi (HOST_WIDE_INT *, unsigned int *l,
+					  unsigned int *p, const_tree tcst)
 {
   tree type = TREE_TYPE (tcst);
 
   *p = TYPE_PRECISION (type);
   *l = TREE_INT_CST_NUNITS (tcst);
-  return (const HOST_WIDE_INT*)&TREE_INT_CST_ELT (tcst, 0);
+  return (const HOST_WIDE_INT *) &TREE_INT_CST_ELT (tcst, 0);
 }
 
 template <>
-inline const HOST_WIDE_INT*
-wide_int_ro::to_shwi2 (HOST_WIDE_INT *s ATTRIBUTE_UNUSED,
-		       unsigned int *l, const tree &tcst)
-{
-  *l = TREE_INT_CST_NUNITS (tcst);
-  return (const HOST_WIDE_INT*)&TREE_INT_CST_ELT (tcst, 0);
-}
-
-template <>
-inline const HOST_WIDE_INT*
-wide_int_ro::to_shwi2 (HOST_WIDE_INT *s ATTRIBUTE_UNUSED,
-		       unsigned int *l, const const_tree &tcst)
-{
-  *l = TREE_INT_CST_NUNITS (tcst);
-  return (const HOST_WIDE_INT*)&TREE_INT_CST_ELT (tcst, 0);
-}
+struct wide_int_accessors <tree> : public wide_int_accessors <const_tree> {};
 
 /* Checking for the functions that require that at least one of the
    operands have a nonzero precision.  If both of them have a precision,
    then if CHECK_EQUAL is true, require that the precision be the same.  */
 
 inline void
-wide_int_ro::check_precision (unsigned int *p1, unsigned int *p2,
-			      bool check_equal ATTRIBUTE_UNUSED,
-			      bool check_zero ATTRIBUTE_UNUSED)
+wi::check_precision (unsigned int *p1, unsigned int *p2,
+		     bool check_equal ATTRIBUTE_UNUSED,
+		     bool check_zero ATTRIBUTE_UNUSED)
 {
   gcc_checking_assert ((!check_zero) || *p1 != 0 || *p2 != 0);
 
@@ -4298,9 +4034,11 @@ typedef std::pair <rtx, enum machine_mod
 /* There should logically be an overload for rtl here, but it cannot
    be here because of circular include issues.  It is in rtl.h.  */
 template <>
-inline const HOST_WIDE_INT*
-wide_int_ro::to_shwi2 (HOST_WIDE_INT *s ATTRIBUTE_UNUSED,
-		       unsigned int *l, const rtx_mode_t &rp);
+struct wide_int_accessors <rtx_mode_t>
+{
+  static const HOST_WIDE_INT *to_shwi (HOST_WIDE_INT *, unsigned int *,
+				       unsigned int *, const rtx_mode_t &);
+};
 
 /* tree related routines.  */
 
