Index: gcc/ada/gcc-interface/cuintp.c
===================================================================
--- gcc/ada/gcc-interface/cuintp.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/ada/gcc-interface/cuintp.c	2013-11-19 12:09:07.933676448 +0000
@@ -150,28 +150,28 @@ UI_From_gnu (tree Input)
   Int_Vector vec;
 
 #if HOST_BITS_PER_WIDE_INT == 64
   /* On 64-bit hosts, tree_fits_shwi_p tells whether the input fits in a
      signed 64-bit integer.  Then a truncation tells whether it fits
      in a signed 32-bit integer.  */
   if (tree_fits_shwi_p (Input))
     {
-      HOST_WIDE_INT hw_input = TREE_INT_CST_LOW (Input);
+      HOST_WIDE_INT hw_input = tree_to_shwi (Input);
       if (hw_input == (int) hw_input)
 	return UI_From_Int (hw_input);
     }
   else
     return No_Uint;
 #else
   /* On 32-bit hosts, tree_fits_shwi_p tells whether the input fits in a
      signed 32-bit integer.  Then a sign test tells whether it fits
      in a signed 64-bit integer.  */
   if (tree_fits_shwi_p (Input))
-    return UI_From_Int (TREE_INT_CST_LOW (Input));
+    return UI_From_Int (tree_to_shwi (Input));
   else if (TREE_INT_CST_HIGH (Input) < 0 && TYPE_UNSIGNED (gnu_type))
     return No_Uint;
 #endif
 
   gnu_base = build_int_cst (gnu_type, UI_Base);
   gnu_temp = Input;
 
   for (i = Max_For_Dint - 1; i >= 0; i--)
Index: gcc/ada/gcc-interface/decl.c
===================================================================
--- gcc/ada/gcc-interface/decl.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/ada/gcc-interface/decl.c	2013-11-19 12:09:07.934676456 +0000
@@ -4918,17 +4918,17 @@ gnat_to_gnu_entity (Entity_Id gnat_entit
 		       && !TYPE_FAT_POINTER_P (gnu_type))
 		size = rm_size (gnu_type);
 	      else
 	        size = TYPE_SIZE (gnu_type);
 
 	      /* Consider an alignment as suspicious if the alignment/size
 		 ratio is greater or equal to the byte/bit ratio.  */
 	      if (tree_fits_uhwi_p (size)
-		  && align >= TREE_INT_CST_LOW (size) * BITS_PER_UNIT)
+		  && align >= tree_to_uhwi (size) * BITS_PER_UNIT)
 		post_error_ne ("?suspiciously large alignment specified for&",
 			       Expression (Alignment_Clause (gnat_entity)),
 			       gnat_entity);
 	    }
 	}
       else if (Is_Atomic (gnat_entity) && !gnu_size
 	       && tree_fits_uhwi_p (TYPE_SIZE (gnu_type))
 	       && integer_pow2p (TYPE_SIZE (gnu_type)))
Index: gcc/ada/gcc-interface/utils.c
===================================================================
--- gcc/ada/gcc-interface/utils.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/ada/gcc-interface/utils.c	2013-11-19 12:09:07.935676464 +0000
@@ -806,17 +806,17 @@ make_packable_type (tree type, bool in_r
 
       /* Do not try to shrink the size if the RM size is not constant.  */
       if (TYPE_CONTAINS_TEMPLATE_P (type)
 	  || !tree_fits_uhwi_p (TYPE_ADA_SIZE (type)))
 	return type;
 
       /* Round the RM size up to a unit boundary to get the minimal size
 	 for a BLKmode record.  Give up if it's already the size.  */
-      new_size = TREE_INT_CST_LOW (TYPE_ADA_SIZE (type));
+      new_size = tree_to_uhwi (TYPE_ADA_SIZE (type));
       new_size = (new_size + BITS_PER_UNIT - 1) & -BITS_PER_UNIT;
       if (new_size == size)
 	return type;
 
       align = new_size & -new_size;
       TYPE_ALIGN (new_type) = MIN (TYPE_ALIGN (type), align);
     }
 
Index: gcc/c-family/c-ada-spec.c
===================================================================
--- gcc/c-family/c-ada-spec.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/c-family/c-ada-spec.c	2013-11-19 12:09:07.938676488 +0000
@@ -1798,29 +1798,29 @@ dump_ada_template (pretty_printer *buffe
 }
 
 /* Return true if NODE is a simple enum types, that can be mapped to an
    Ada enum type directly.  */
 
 static bool
 is_simple_enum (tree node)
 {
-  unsigned HOST_WIDE_INT count = 0;
+  HOST_WIDE_INT count = 0;
   tree value;
 
   for (value = TYPE_VALUES (node); value; value = TREE_CHAIN (value))
     {
       tree int_val = TREE_VALUE (value);
 
       if (TREE_CODE (int_val) != INTEGER_CST)
 	int_val = DECL_INITIAL (int_val);
 
       if (!tree_fits_shwi_p (int_val))
 	return false;
-      else if (TREE_INT_CST_LOW (int_val) != count)
+      else if (tree_to_shwi (int_val) != count)
 	return false;
 
       count++;
     }
 
   return true;
 }
 
@@ -2201,19 +2201,19 @@ dump_generic_ada_node (pretty_printer *b
 
     case INTEGER_CST:
       /* We treat the upper half of the sizetype range as negative.  This
 	 is consistent with the internal treatment and makes it possible
 	 to generate the (0 .. -1) range for flexible array members.  */
       if (TREE_TYPE (node) == sizetype)
 	node = fold_convert (ssizetype, node);
       if (tree_fits_shwi_p (node))
-	pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
+	pp_wide_integer (buffer, tree_to_shwi (node));
       else if (tree_fits_uhwi_p (node))
-	pp_unsigned_wide_integer (buffer, TREE_INT_CST_LOW (node));
+	pp_unsigned_wide_integer (buffer, tree_to_uhwi (node));
       else
 	{
 	  tree val = node;
 	  unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (val);
 	  HOST_WIDE_INT high = TREE_INT_CST_HIGH (val);
 
 	  if (tree_int_cst_sgn (val) < 0)
 	    {
Index: gcc/c-family/c-format.c
===================================================================
--- gcc/c-family/c-format.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/c-family/c-format.c	2013-11-19 12:09:07.938676488 +0000
@@ -1534,17 +1534,17 @@ check_format_arg (void *ctx, tree format
   format_length = TREE_STRING_LENGTH (format_tree);
   if (array_size != 0)
     {
       /* Variable length arrays can't be initialized.  */
       gcc_assert (TREE_CODE (array_size) == INTEGER_CST);
 
       if (tree_fits_shwi_p (array_size))
 	{
-	  HOST_WIDE_INT array_size_value = TREE_INT_CST_LOW (array_size);
+	  HOST_WIDE_INT array_size_value = tree_to_shwi (array_size);
 	  if (array_size_value > 0
 	      && array_size_value == (int) array_size_value
 	      && format_length > array_size_value)
 	    format_length = array_size_value;
 	}
     }
   if (offset)
     {
Index: gcc/c-family/c-pretty-print.c
===================================================================
--- gcc/c-family/c-pretty-print.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/c-family/c-pretty-print.c	2013-11-19 12:09:07.939676496 +0000
@@ -911,19 +911,19 @@ pp_c_integer_constant (c_pretty_printer
   /* We are going to compare the type of I to other types using
      pointer comparison so we need to use its canonical type.  */
   tree type =
     TYPE_CANONICAL (TREE_TYPE (i))
     ? TYPE_CANONICAL (TREE_TYPE (i))
     : TREE_TYPE (i);
 
   if (tree_fits_shwi_p (i))
-    pp_wide_integer (pp, TREE_INT_CST_LOW (i));
+    pp_wide_integer (pp, tree_to_shwi (i));
   else if (tree_fits_uhwi_p (i))
-    pp_unsigned_wide_integer (pp, TREE_INT_CST_LOW (i));
+    pp_unsigned_wide_integer (pp, tree_to_uhwi (i));
   else
     {
       unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (i);
       HOST_WIDE_INT high = TREE_INT_CST_HIGH (i);
       if (tree_int_cst_sgn (i) < 0)
 	{
 	  pp_minus (pp);
 	  high = ~high + !low;
Index: gcc/alias.c
===================================================================
--- gcc/alias.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/alias.c	2013-11-19 12:09:07.954676615 +0000
@@ -334,18 +334,18 @@ ao_ref_from_mem (ao_ref *ref, const_rtx
     ref->max_size = ref->size;
 
   /* If MEM_OFFSET and MEM_SIZE get us outside of the base object of
      the MEM_EXPR punt.  This happens for STRICT_ALIGNMENT targets a lot.  */
   if (MEM_EXPR (mem) != get_spill_slot_decl (false)
       && (ref->offset < 0
 	  || (DECL_P (ref->base)
 	      && (!tree_fits_uhwi_p (DECL_SIZE (ref->base))
-		  || (TREE_INT_CST_LOW (DECL_SIZE ((ref->base)))
-		      < (unsigned HOST_WIDE_INT)(ref->offset + ref->size))))))
+		  || (tree_to_uhwi (DECL_SIZE (ref->base))
+		      < (unsigned HOST_WIDE_INT) (ref->offset + ref->size))))))
     return false;
 
   return true;
 }
 
 /* Query the alias-oracle on whether the two memory rtx X and MEM may
    alias.  If TBAA_P is set also apply TBAA.  Returns true if the
    two rtxen may alias, false otherwise.  */
Index: gcc/builtins.c
===================================================================
--- gcc/builtins.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/builtins.c	2013-11-19 12:09:07.937676480 +0000
@@ -8544,17 +8544,17 @@ fold_builtin_powi (location_t loc, tree
     return NULL_TREE;
 
   /* Optimize pow(1.0,y) = 1.0.  */
   if (real_onep (arg0))
     return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
 
   if (tree_fits_shwi_p (arg1))
     {
-      HOST_WIDE_INT c = TREE_INT_CST_LOW (arg1);
+      HOST_WIDE_INT c = tree_to_shwi (arg1);
 
       /* Evaluate powi at compile-time.  */
       if (TREE_CODE (arg0) == REAL_CST
 	  && !TREE_OVERFLOW (arg0))
 	{
 	  REAL_VALUE_TYPE x;
 	  x = TREE_REAL_CST (arg0);
 	  real_powi (&x, TYPE_MODE (type), &x, c);
Index: gcc/config/epiphany/epiphany.c
===================================================================
--- gcc/config/epiphany/epiphany.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/config/epiphany/epiphany.c	2013-11-19 12:09:07.939676496 +0000
@@ -2754,20 +2754,20 @@ epiphany_special_round_type_align (tree
       tree offset, size;
 
       if (TREE_CODE (field) != FIELD_DECL
 	  || TREE_TYPE (field) == error_mark_node)
 	continue;
       offset = bit_position (field);
       size = DECL_SIZE (field);
       if (!tree_fits_uhwi_p (offset) || !tree_fits_uhwi_p (size)
-	  || TREE_INT_CST_LOW (offset) >= try_align
-	  || TREE_INT_CST_LOW (size) >= try_align)
+	  || tree_to_uhwi (offset) >= try_align
+	  || tree_to_uhwi (size) >= try_align)
 	return try_align;
-      total = TREE_INT_CST_LOW (offset) + TREE_INT_CST_LOW (size);
+      total = tree_to_uhwi (offset) + tree_to_uhwi (size);
       if (total > max)
 	max = total;
     }
   if (max >= (HOST_WIDE_INT) try_align)
     align = try_align;
   else if (try_align > 32 && max >= 32)
     align = max > 32 ? 64 : 32;
   return align;
Index: gcc/dbxout.c
===================================================================
--- gcc/dbxout.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/dbxout.c	2013-11-19 12:09:07.954676615 +0000
@@ -2919,17 +2919,17 @@ dbxout_symbol (tree decl, int local ATTR
 	      || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
 	  && TREE_PUBLIC (decl) == 0)
 	{
 	  /* The sun4 assembler does not grok this.  */
 
 	  if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
 	      || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
 	    {
-	      HOST_WIDE_INT ival = TREE_INT_CST_LOW (DECL_INITIAL (decl));
+	      HOST_WIDE_INT ival = tree_to_shwi (DECL_INITIAL (decl));
 
 	      dbxout_begin_complex_stabs ();
 	      dbxout_symbol_name (decl, NULL, 'c');
 	      stabstr_S ("=i");
 	      stabstr_D (ival);
 	      dbxout_finish_complex_stabs (0, N_LSYM, 0, 0, 0);
 	      DBXOUT_DECR_NESTING;
 	      return 1;
Index: gcc/expr.c
===================================================================
--- gcc/expr.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/expr.c	2013-11-19 12:09:07.941676512 +0000
@@ -9630,17 +9630,17 @@ expand_expr_real_1 (tree exp, rtx target
 	   might end up in a register.  */
 	if (mem_ref_refers_to_non_mem_p (exp))
 	  {
 	    HOST_WIDE_INT offset = mem_ref_offset (exp).low;
 	    base = TREE_OPERAND (base, 0);
 	    if (offset == 0
 		&& tree_fits_uhwi_p (TYPE_SIZE (type))
 		&& (GET_MODE_BITSIZE (DECL_MODE (base))
-		    == TREE_INT_CST_LOW (TYPE_SIZE (type))))
+		    == tree_to_uhwi (TYPE_SIZE (type))))
 	      return expand_expr (build1 (VIEW_CONVERT_EXPR, type, base),
 				  target, tmode, modifier);
 	    if (TYPE_MODE (type) == BLKmode)
 	      {
 		temp = assign_stack_temp (DECL_MODE (base),
 					  GET_MODE_SIZE (DECL_MODE (base)));
 		store_expr (base, temp, 0, false);
 		temp = adjust_address (temp, BLKmode, offset);
Index: gcc/fold-const.c
===================================================================
--- gcc/fold-const.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/fold-const.c	2013-11-19 12:09:07.943676528 +0000
@@ -6640,20 +6640,20 @@ fold_single_bit_test (location_t loc, en
 	 Similarly for (A & C) == 0.  */
 
       /* If INNER is a right shift of a constant and it plus BITNUM does
 	 not overflow, adjust BITNUM and INNER.  */
       if (TREE_CODE (inner) == RSHIFT_EXPR
 	  && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST
 	  && tree_fits_uhwi_p (TREE_OPERAND (inner, 1))
 	  && bitnum < TYPE_PRECISION (type)
-	  && (TREE_INT_CST_LOW (TREE_OPERAND (inner, 1))
+	  && (tree_to_uhwi (TREE_OPERAND (inner, 1))
 	      < (unsigned) (TYPE_PRECISION (type) - bitnum)))
 	{
-	  bitnum += TREE_INT_CST_LOW (TREE_OPERAND (inner, 1));
+	  bitnum += tree_to_uhwi (TREE_OPERAND (inner, 1));
 	  inner = TREE_OPERAND (inner, 0);
 	}
 
       /* If we are going to be able to omit the AND below, we must do our
 	 operations as unsigned.  If we must use the AND, we have a choice.
 	 Normally unsigned is faster, but for some machines signed is.  */
 #ifdef LOAD_EXTEND_OP
       ops_unsigned = (LOAD_EXTEND_OP (operand_mode) == SIGN_EXTEND
@@ -7256,18 +7256,18 @@ fold_plusminus_mult_expr (location_t loc
      power-of-two factor in non-power-of-two multiplies.  This
      can help in multi-dimensional array access.  */
   else if (tree_fits_shwi_p (arg01)
 	   && tree_fits_shwi_p (arg11))
     {
       HOST_WIDE_INT int01, int11, tmp;
       bool swap = false;
       tree maybe_same;
-      int01 = TREE_INT_CST_LOW (arg01);
-      int11 = TREE_INT_CST_LOW (arg11);
+      int01 = tree_to_shwi (arg01);
+      int11 = tree_to_shwi (arg11);
 
       /* Move min of absolute values to int11.  */
       if (absu_hwi (int01) < absu_hwi (int11))
         {
 	  tmp = int01, int01 = int11, int11 = tmp;
 	  alt0 = arg00, arg00 = arg10, arg10 = alt0;
 	  maybe_same = arg01;
 	  swap = true;
@@ -12011,17 +12011,17 @@ fold_binary_loc (location_t loc,
 	}
 
       /* If arg0 is derived from the address of an object or function, we may
 	 be able to fold this expression using the object or function's
 	 alignment.  */
       if (POINTER_TYPE_P (TREE_TYPE (arg0)) && tree_fits_uhwi_p (arg1))
 	{
 	  unsigned HOST_WIDE_INT modulus, residue;
-	  unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (arg1);
+	  unsigned HOST_WIDE_INT low = tree_to_uhwi (arg1);
 
 	  modulus = get_pointer_modulus_and_residue (arg0, &residue,
 						     integer_onep (arg1));
 
 	  /* This works because modulus is a power of 2.  If this weren't the
 	     case, we'd have to replace it by its greatest power-of-2
 	     divisor: modulus & -modulus.  */
 	  if (low < modulus)
@@ -12642,22 +12642,22 @@ fold_binary_loc (location_t loc,
 	 don't try to compute it in the compiler.  */
       if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
 	return NULL_TREE;
 
       prec = element_precision (type);
 
       /* Turn (a OP c1) OP c2 into a OP (c1+c2).  */
       if (TREE_CODE (op0) == code && tree_fits_uhwi_p (arg1)
-	  && TREE_INT_CST_LOW (arg1) < prec
+	  && tree_to_uhwi (arg1) < prec
 	  && tree_fits_uhwi_p (TREE_OPERAND (arg0, 1))
-	  && TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)) < prec)
+	  && tree_to_uhwi (TREE_OPERAND (arg0, 1)) < prec)
 	{
-	  unsigned int low = (TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1))
-			      + TREE_INT_CST_LOW (arg1));
+	  unsigned int low = (tree_to_uhwi (TREE_OPERAND (arg0, 1))
+			      + tree_to_uhwi (arg1));
 
 	  /* Deal with a OP (c1 + c2) being undefined but (a OP c1) OP c2
 	     being well defined.  */
 	  if (low >= prec)
 	    {
 	      if (code == LROTATE_EXPR || code == RROTATE_EXPR)
 	        low = low % prec;
 	      else if (TYPE_UNSIGNED (type) || code == LSHIFT_EXPR)
Index: gcc/gimple-fold.c
===================================================================
--- gcc/gimple-fold.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/gimple-fold.c	2013-11-19 12:09:07.955676623 +0000
@@ -3058,33 +3058,33 @@ fold_const_aggregate_ref_1 (tree t, tree
 	       TREE_CODE (low_bound) == INTEGER_CST)
 	      && (unit_size = array_ref_element_size (t),
 		  tree_fits_uhwi_p (unit_size))
 	      && (doffset = (TREE_INT_CST (idx) - TREE_INT_CST (low_bound))
 			    .sext (TYPE_PRECISION (TREE_TYPE (idx))),
 		  doffset.fits_shwi ()))
 	    {
 	      offset = doffset.to_shwi ();
-	      offset *= TREE_INT_CST_LOW (unit_size);
+	      offset *= tree_to_uhwi (unit_size);
 	      offset *= BITS_PER_UNIT;
 
 	      base = TREE_OPERAND (t, 0);
 	      ctor = get_base_constructor (base, &offset, valueize);
 	      /* Empty constructor.  Always fold to 0.  */
 	      if (ctor == error_mark_node)
 		return build_zero_cst (TREE_TYPE (t));
 	      /* Out of bound array access.  Value is undefined,
 		 but don't fold.  */
 	      if (offset < 0)
 		return NULL_TREE;
 	      /* We can not determine ctor.  */
 	      if (!ctor)
 		return NULL_TREE;
 	      return fold_ctor_reference (TREE_TYPE (t), ctor, offset,
-					  TREE_INT_CST_LOW (unit_size)
+					  tree_to_uhwi (unit_size)
 					  * BITS_PER_UNIT,
 					  base);
 	    }
 	}
       /* Fallthru.  */
 
     case COMPONENT_REF:
     case BIT_FIELD_REF:
Index: gcc/gimple-ssa-strength-reduction.c
===================================================================
--- gcc/gimple-ssa-strength-reduction.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/gimple-ssa-strength-reduction.c	2013-11-19 12:09:07.944676536 +0000
@@ -605,17 +605,17 @@ stmt_cost (gimple gs, bool speed)
   lhs_mode = TYPE_MODE (TREE_TYPE (lhs));
   
   switch (gimple_assign_rhs_code (gs))
     {
     case MULT_EXPR:
       rhs2 = gimple_assign_rhs2 (gs);
 
       if (tree_fits_shwi_p (rhs2))
-	return mult_by_coeff_cost (TREE_INT_CST_LOW (rhs2), lhs_mode, speed);
+	return mult_by_coeff_cost (tree_to_shwi (rhs2), lhs_mode, speed);
 
       gcc_assert (TREE_CODE (rhs1) != INTEGER_CST);
       return mul_cost (speed, lhs_mode);
 
     case PLUS_EXPR:
     case POINTER_PLUS_EXPR:
     case MINUS_EXPR:
       return add_cost (speed, lhs_mode);
Index: gcc/omp-low.c
===================================================================
--- gcc/omp-low.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/omp-low.c	2013-11-19 12:09:07.945676544 +0000
@@ -8828,17 +8828,17 @@ lower_omp_for_lastprivate (struct omp_fo
 
   cond_code = fd->loop.cond_code;
   cond_code = cond_code == LT_EXPR ? GE_EXPR : LE_EXPR;
 
   /* When possible, use a strict equality expression.  This can let VRP
      type optimizations deduce the value and remove a copy.  */
   if (tree_fits_shwi_p (fd->loop.step))
     {
-      HOST_WIDE_INT step = TREE_INT_CST_LOW (fd->loop.step);
+      HOST_WIDE_INT step = tree_to_shwi (fd->loop.step);
       if (step == 1 || step == -1)
 	cond_code = EQ_EXPR;
     }
 
   cond = build2 (cond_code, boolean_type_node, fd->loop.v, fd->loop.n2);
 
   clauses = gimple_omp_for_clauses (fd->for_stmt);
   stmts = NULL;
Index: gcc/simplify-rtx.c
===================================================================
--- gcc/simplify-rtx.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/simplify-rtx.c	2013-11-19 12:09:07.956676631 +0000
@@ -299,17 +299,17 @@ delegitimize_mem_from_attrs (rtx x)
 	    if (bitsize != GET_MODE_BITSIZE (mode)
 		|| (bitpos % BITS_PER_UNIT)
 		|| (toffset && !tree_fits_shwi_p (toffset)))
 	      decl = NULL;
 	    else
 	      {
 		offset += bitpos / BITS_PER_UNIT;
 		if (toffset)
-		  offset += TREE_INT_CST_LOW (toffset);
+		  offset += tree_to_shwi (toffset);
 	      }
 	    break;
 	  }
 	}
 
       if (decl
 	  && mode == GET_MODE (x)
 	  && TREE_CODE (decl) == VAR_DECL
Index: gcc/stor-layout.c
===================================================================
--- gcc/stor-layout.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/stor-layout.c	2013-11-19 12:09:07.946676552 +0000
@@ -1616,17 +1616,17 @@ compute_record_mode (tree type)
 	return;
     }
 
   /* If we only have one real field; use its mode if that mode's size
      matches the type's size.  This only applies to RECORD_TYPE.  This
      does not apply to unions.  */
   if (TREE_CODE (type) == RECORD_TYPE && mode != VOIDmode
       && tree_fits_uhwi_p (TYPE_SIZE (type))
-      && GET_MODE_BITSIZE (mode) == TREE_INT_CST_LOW (TYPE_SIZE (type)))
+      && GET_MODE_BITSIZE (mode) == tree_to_uhwi (TYPE_SIZE (type)))
     SET_TYPE_MODE (type, mode);
   else
     SET_TYPE_MODE (type, mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1));
 
   /* If structure's known alignment is less than what the scalar
      mode would need, and it matters, then stick with BLKmode.  */
   if (TYPE_MODE (type) != BLKmode
       && STRICT_ALIGNMENT
Index: gcc/tree-cfg.c
===================================================================
--- gcc/tree-cfg.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/tree-cfg.c	2013-11-19 12:09:07.947676560 +0000
@@ -2704,26 +2704,26 @@ #define CHECK_OP(N, MSG) \
 	  if (!tree_fits_uhwi_p (TREE_OPERAND (t, 1))
 	      || !tree_fits_uhwi_p (TREE_OPERAND (t, 2)))
 	    {
 	      error ("invalid position or size operand to BIT_FIELD_REF");
 	      return t;
 	    }
 	  if (INTEGRAL_TYPE_P (TREE_TYPE (t))
 	      && (TYPE_PRECISION (TREE_TYPE (t))
-		  != TREE_INT_CST_LOW (TREE_OPERAND (t, 1))))
+		  != tree_to_uhwi (TREE_OPERAND (t, 1))))
 	    {
 	      error ("integral result type precision does not match "
 		     "field size of BIT_FIELD_REF");
 	      return t;
 	    }
 	  else if (!INTEGRAL_TYPE_P (TREE_TYPE (t))
 		   && TYPE_MODE (TREE_TYPE (t)) != BLKmode
 		   && (GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (t)))
-		       != TREE_INT_CST_LOW (TREE_OPERAND (t, 1))))
+		       != tree_to_uhwi (TREE_OPERAND (t, 1))))
 	    {
 	      error ("mode precision of non-integral result does not "
 		     "match field size of BIT_FIELD_REF");
 	      return t;
 	    }
 	}
       t = TREE_OPERAND (t, 0);
 
Index: gcc/tree-dfa.c
===================================================================
--- gcc/tree-dfa.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/tree-dfa.c	2013-11-19 12:09:07.947676560 +0000
@@ -405,17 +405,17 @@ get_ref_base_and_extent (tree exp, HOST_
       else
 	bitsize = GET_MODE_BITSIZE (mode);
     }
   if (size_tree != NULL_TREE)
     {
       if (! tree_fits_uhwi_p (size_tree))
 	bitsize = -1;
       else
-	bitsize = TREE_INT_CST_LOW (size_tree);
+	bitsize = tree_to_uhwi (size_tree);
     }
 
   /* Initially, maxsize is the same as the accessed element size.
      In the following it will only grow (or become -1).  */
   maxsize = bitsize;
 
   /* Compute cumulative bit-offset for nested component-refs and array-refs,
      and find the ultimate containing object.  */
@@ -453,18 +453,18 @@ get_ref_base_and_extent (tree exp, HOST_
 		    if (!next
 			|| TREE_CODE (stype) != RECORD_TYPE)
 		      {
 			tree fsize = DECL_SIZE_UNIT (field);
 			tree ssize = TYPE_SIZE_UNIT (stype);
 			if (tree_fits_shwi_p (fsize)
 			    && tree_fits_shwi_p (ssize)
 			    && doffset.fits_shwi ())
-			  maxsize += ((TREE_INT_CST_LOW (ssize)
-				       - TREE_INT_CST_LOW (fsize))
+			  maxsize += ((tree_to_shwi (ssize)
+				       - tree_to_shwi (fsize))
 				      * BITS_PER_UNIT
 					- doffset.to_shwi ());
 			else
 			  maxsize = -1;
 		      }
 		  }
 	      }
 	    else
@@ -472,18 +472,17 @@ get_ref_base_and_extent (tree exp, HOST_
 		tree csize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)));
 		/* We need to adjust maxsize to the whole structure bitsize.
 		   But we can subtract any constant offset seen so far,
 		   because that would get us out of the structure otherwise.  */
 		if (maxsize != -1
 		    && csize
 		    && tree_fits_uhwi_p (csize)
 		    && bit_offset.fits_shwi ())
-		  maxsize = TREE_INT_CST_LOW (csize)
-			    - bit_offset.to_shwi ();
+		  maxsize = tree_to_uhwi (csize) - bit_offset.to_shwi ();
 		else
 		  maxsize = -1;
 	      }
 	  }
 	  break;
 
 	case ARRAY_REF:
 	case ARRAY_RANGE_REF:
@@ -516,18 +515,17 @@ get_ref_base_and_extent (tree exp, HOST_
 		tree asize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0)));
 		/* We need to adjust maxsize to the whole array bitsize.
 		   But we can subtract any constant offset seen so far,
 		   because that would get us outside of the array otherwise.  */
 		if (maxsize != -1
 		    && asize
 		    && tree_fits_uhwi_p (asize)
 		    && bit_offset.fits_shwi ())
-		  maxsize = TREE_INT_CST_LOW (asize)
-			    - bit_offset.to_shwi ();
+		  maxsize = tree_to_uhwi (asize) - bit_offset.to_shwi ();
 		else
 		  maxsize = -1;
 
 		/* Remember that we have seen an array ref with a variable
 		   index.  */
 		seen_variable_array_ref = true;
 	      }
 	  }
@@ -566,17 +564,17 @@ get_ref_base_and_extent (tree exp, HOST_
 	     is to punt in the case that offset + maxsize reaches the
 	     base type boundary.  This needs to include possible trailing
 	     padding that is there for alignment purposes.  */
 	  if (seen_variable_array_ref
 	      && maxsize != -1
 	      && (!bit_offset.fits_shwi ()
 		  || !tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (exp)))
 		  || (bit_offset.to_shwi () + maxsize
-		      == (HOST_WIDE_INT) TREE_INT_CST_LOW
+		      == (HOST_WIDE_INT) tree_to_uhwi
 		            (TYPE_SIZE (TREE_TYPE (exp))))))
 	    maxsize = -1;
 
 	  /* Hand back the decl for MEM[&decl, off].  */
 	  if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR)
 	    {
 	      if (integer_zerop (TREE_OPERAND (exp, 1)))
 		exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
@@ -603,17 +601,17 @@ get_ref_base_and_extent (tree exp, HOST_
     }
 
   /* We need to deal with variable arrays ending structures.  */
   if (seen_variable_array_ref
       && maxsize != -1
       && (!bit_offset.fits_shwi ()
 	  || !tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (exp)))
 	  || (bit_offset.to_shwi () + maxsize
-	      == (HOST_WIDE_INT) TREE_INT_CST_LOW
+	      == (HOST_WIDE_INT) tree_to_uhwi
 	           (TYPE_SIZE (TREE_TYPE (exp))))))
     maxsize = -1;
 
  done:
   if (!bit_offset.fits_shwi ())
     {
       *poffset = 0;
       *psize = bitsize;
@@ -627,25 +625,25 @@ get_ref_base_and_extent (tree exp, HOST_
   /* In case of a decl or constant base object we can do better.  */
 
   if (DECL_P (exp))
     {
       /* If maxsize is unknown adjust it according to the size of the
          base decl.  */
       if (maxsize == -1
 	  && tree_fits_uhwi_p (DECL_SIZE (exp)))
-	maxsize = TREE_INT_CST_LOW (DECL_SIZE (exp)) - hbit_offset;
+	maxsize = tree_to_uhwi (DECL_SIZE (exp)) - hbit_offset;
     }
   else if (CONSTANT_CLASS_P (exp))
     {
       /* If maxsize is unknown adjust it according to the size of the
          base type constant.  */
       if (maxsize == -1
 	  && tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (exp))))
-	maxsize = TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp))) - hbit_offset;
+	maxsize = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (exp))) - hbit_offset;
     }
 
   /* ???  Due to negative offsets in ARRAY_REF we can end up with
      negative bit_offset here.  We might want to store a zero offset
      in this case.  */
   *poffset = hbit_offset;
   *psize = bitsize;
   *pmax_size = maxsize;
Index: gcc/tree-pretty-print.c
===================================================================
--- gcc/tree-pretty-print.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/tree-pretty-print.c	2013-11-19 12:09:07.947676560 +0000
@@ -268,17 +268,17 @@ dump_array_domain (pretty_printer *buffe
   if (domain)
     {
       tree min = TYPE_MIN_VALUE (domain);
       tree max = TYPE_MAX_VALUE (domain);
 
       if (min && max
 	  && integer_zerop (min)
 	  && tree_fits_shwi_p (max))
-	pp_wide_integer (buffer, TREE_INT_CST_LOW (max) + 1);
+	pp_wide_integer (buffer, tree_to_shwi (max) + 1);
       else
 	{
 	  if (min)
 	    dump_generic_node (buffer, min, spc, flags, false);
 	  pp_colon (buffer);
 	  if (max)
 	    dump_generic_node (buffer, max, spc, flags, false);
 	}
Index: gcc/tree-sra.c
===================================================================
--- gcc/tree-sra.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/tree-sra.c	2013-11-19 12:09:07.948676568 +0000
@@ -1648,22 +1648,22 @@ build_user_friendly_ref_for_offset (tree
 	      tree tr_pos, expr, *expr_ptr;
 
 	      if (TREE_CODE (fld) != FIELD_DECL)
 		continue;
 
 	      tr_pos = bit_position (fld);
 	      if (!tr_pos || !tree_fits_uhwi_p (tr_pos))
 		continue;
-	      pos = TREE_INT_CST_LOW (tr_pos);
+	      pos = tree_to_uhwi (tr_pos);
 	      gcc_assert (TREE_CODE (type) == RECORD_TYPE || pos == 0);
 	      tr_size = DECL_SIZE (fld);
 	      if (!tr_size || !tree_fits_uhwi_p (tr_size))
 		continue;
-	      size = TREE_INT_CST_LOW (tr_size);
+	      size = tree_to_uhwi (tr_size);
 	      if (size == 0)
 		{
 		  if (pos != offset)
 		    continue;
 		}
 	      else if (pos > offset || (pos + size) <= offset)
 		continue;
 
Index: gcc/tree-ssa-ccp.c
===================================================================
--- gcc/tree-ssa-ccp.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/tree-ssa-ccp.c	2013-11-19 12:09:07.956676631 +0000
@@ -1879,17 +1879,17 @@ fold_builtin_alloca_with_align (gimple s
 
   /* Detect constant argument.  */
   arg = get_constant_value (gimple_call_arg (stmt, 0));
   if (arg == NULL_TREE
       || TREE_CODE (arg) != INTEGER_CST
       || !tree_fits_uhwi_p (arg))
     return NULL_TREE;
 
-  size = TREE_INT_CST_LOW (arg);
+  size = tree_to_uhwi (arg);
 
   /* Heuristic: don't fold large allocas.  */
   threshold = (unsigned HOST_WIDE_INT)PARAM_VALUE (PARAM_LARGE_STACK_FRAME);
   /* In case the alloca is located at function entry, it has the same lifetime
      as a declared array, so we allow a larger size.  */
   block = gimple_block (stmt);
   if (!(cfun->after_inlining
         && TREE_CODE (BLOCK_SUPERCONTEXT (block)) == FUNCTION_DECL))
Index: gcc/tree-ssa-loop-ivopts.c
===================================================================
--- gcc/tree-ssa-loop-ivopts.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/tree-ssa-loop-ivopts.c	2013-11-19 12:09:07.949676576 +0000
@@ -3966,25 +3966,25 @@ get_loop_invariant_expr_id (struct ivopt
 
           usym = TREE_OPERAND (ubase, 0);
           csym = TREE_OPERAND (cbase, 0);
           if (TREE_CODE (usym) == ARRAY_REF)
             {
               tree ind = TREE_OPERAND (usym, 1);
               if (TREE_CODE (ind) == INTEGER_CST
                   && tree_fits_shwi_p (ind)
-                  && TREE_INT_CST_LOW (ind) == 0)
+                  && tree_to_shwi (ind) == 0)
                 usym = TREE_OPERAND (usym, 0);
             }
           if (TREE_CODE (csym) == ARRAY_REF)
             {
               tree ind = TREE_OPERAND (csym, 1);
               if (TREE_CODE (ind) == INTEGER_CST
                   && tree_fits_shwi_p (ind)
-                  && TREE_INT_CST_LOW (ind) == 0)
+                  && tree_to_shwi (ind) == 0)
                 csym = TREE_OPERAND (csym, 0);
             }
           if (operand_equal_p (usym, csym, 0))
             return -1;
         }
       /* Now do more complex comparison  */
       tree_to_aff_combination (ubase, TREE_TYPE (ubase), &ubase_aff);
       tree_to_aff_combination (cbase, TREE_TYPE (cbase), &cbase_aff);
Index: gcc/tree-ssa-math-opts.c
===================================================================
--- gcc/tree-ssa-math-opts.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/tree-ssa-math-opts.c	2013-11-19 12:09:07.949676576 +0000
@@ -1500,17 +1500,17 @@ execute_cse_sincos (void)
 		      gimple_set_location (stmt, loc);
 		      gsi_insert_before (&gsi, stmt, GSI_SAME_STMT);
 		    }
 		  else
 		    {
 		      if (!tree_fits_shwi_p (arg1))
 			break;
 
-		      n = TREE_INT_CST_LOW (arg1);
+		      n = tree_to_shwi (arg1);
 		      result = gimple_expand_builtin_powi (&gsi, loc, arg0, n);
 		    }
 
 		  if (result)
 		    {
 		      tree lhs = gimple_get_lhs (stmt);
 		      gimple new_stmt = gimple_build_assign (lhs, result);
 		      gimple_set_location (new_stmt, loc);
Index: gcc/tree-ssa-phiopt.c
===================================================================
--- gcc/tree-ssa-phiopt.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/tree-ssa-phiopt.c	2013-11-19 12:09:07.950676584 +0000
@@ -1975,19 +1975,19 @@ hoist_adjacent_loads (basic_block bb0, b
       tree_offset2 = bit_position (field2);
       tree_size2 = DECL_SIZE (field2);
 
       if (!tree_fits_uhwi_p (tree_offset1)
 	  || !tree_fits_uhwi_p (tree_offset2)
 	  || !tree_fits_uhwi_p (tree_size2))
 	continue;
 
-      offset1 = TREE_INT_CST_LOW (tree_offset1);
-      offset2 = TREE_INT_CST_LOW (tree_offset2);
-      size2 = TREE_INT_CST_LOW (tree_size2);
+      offset1 = tree_to_uhwi (tree_offset1);
+      offset2 = tree_to_uhwi (tree_offset2);
+      size2 = tree_to_uhwi (tree_size2);
       align1 = DECL_ALIGN (field1) % param_align_bits;
 
       if (offset1 % BITS_PER_UNIT != 0)
 	continue;
 
       /* For profitability, the two field references should fit within
 	 a single cache line.  */
       if (align1 + offset2 - offset1 + size2 > param_align_bits)
Index: gcc/tree-ssa-reassoc.c
===================================================================
--- gcc/tree-ssa-reassoc.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/tree-ssa-reassoc.c	2013-11-19 12:09:07.951676592 +0000
@@ -3633,17 +3633,17 @@ acceptable_pow_call (gimple stmt, tree *
 
     CASE_FLT_FN (BUILT_IN_POWI):
       *base = gimple_call_arg (stmt, 0);
       arg1 = gimple_call_arg (stmt, 1);
 
       if (!tree_fits_shwi_p (arg1))
 	return false;
 
-      *exponent = TREE_INT_CST_LOW (arg1);
+      *exponent = tree_to_shwi (arg1);
       break;
 
     default:
       return false;
     }
 
   /* Expanding negative exponents is generally unproductive, so we don't
      complicate matters with those.  Exponents of zero and one should
Index: gcc/tree-ssa-sccvn.c
===================================================================
--- gcc/tree-ssa-sccvn.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/tree-ssa-sccvn.c	2013-11-19 12:09:07.951676592 +0000
@@ -778,17 +778,17 @@ copy_reference_ops_from_ref (tree ref, v
 	case WITH_SIZE_EXPR:
 	  temp.op0 = TREE_OPERAND (ref, 1);
 	  temp.off = 0;
 	  break;
 	case MEM_REF:
 	  /* The base address gets its own vn_reference_op_s structure.  */
 	  temp.op0 = TREE_OPERAND (ref, 1);
 	  if (tree_fits_shwi_p (TREE_OPERAND (ref, 1)))
-	    temp.off = TREE_INT_CST_LOW (TREE_OPERAND (ref, 1));
+	    temp.off = tree_to_shwi (TREE_OPERAND (ref, 1));
 	  break;
 	case BIT_FIELD_REF:
 	  /* Record bits and position.  */
 	  temp.op0 = TREE_OPERAND (ref, 1);
 	  temp.op1 = TREE_OPERAND (ref, 2);
 	  break;
 	case COMPONENT_REF:
 	  /* The field decl is enough to unambiguously specify the field,
@@ -934,17 +934,17 @@ ao_ref_init_from_vn_reference (ao_ref *r
       else
         size = GET_MODE_BITSIZE (mode);
     }
   if (size_tree != NULL_TREE)
     {
       if (!tree_fits_uhwi_p (size_tree))
 	size = -1;
       else
-	size = TREE_INT_CST_LOW (size_tree);
+	size = tree_to_uhwi (size_tree);
     }
 
   /* Initially, maxsize is the same as the accessed element size.
      In the following it will only grow (or become -1).  */
   max_size = size;
 
   /* Compute cumulative bit-offset for nested component-refs and array-refs,
      and find the ultimate containing object.  */
@@ -1005,35 +1005,35 @@ ao_ref_init_from_vn_reference (ao_ref *r
 	       cannot use component_ref_field_offset.  Do the interesting
 	       parts manually.  */
 
 	    if (op->op1
 		|| !tree_fits_uhwi_p (DECL_FIELD_OFFSET (field)))
 	      max_size = -1;
 	    else
 	      {
-		offset += (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (field))
+		offset += (tree_to_uhwi (DECL_FIELD_OFFSET (field))
 			   * BITS_PER_UNIT);
 		offset += TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field));
 	      }
 	    break;
 	  }
 
 	case ARRAY_RANGE_REF:
 	case ARRAY_REF:
 	  /* We recorded the lower bound and the element size.  */
 	  if (!tree_fits_shwi_p (op->op0)
 	      || !tree_fits_shwi_p (op->op1)
 	      || !tree_fits_shwi_p (op->op2))
 	    max_size = -1;
 	  else
 	    {
-	      HOST_WIDE_INT hindex = TREE_INT_CST_LOW (op->op0);
-	      hindex -= TREE_INT_CST_LOW (op->op1);
-	      hindex *= TREE_INT_CST_LOW (op->op2);
+	      HOST_WIDE_INT hindex = tree_to_shwi (op->op0);
+	      hindex -= tree_to_shwi (op->op1);
+	      hindex *= tree_to_shwi (op->op2);
 	      hindex *= BITS_PER_UNIT;
 	      offset += hindex;
 	    }
 	  break;
 
 	case REALPART_EXPR:
 	  break;
 
@@ -1152,17 +1152,17 @@ vn_reference_fold_indirect (vec<vn_refer
   if (addr_base != TREE_OPERAND (op->op0, 0))
     {
       double_int off = tree_to_double_int (mem_op->op0);
       off = off.sext (TYPE_PRECISION (TREE_TYPE (mem_op->op0)));
       off += double_int::from_shwi (addr_offset);
       mem_op->op0 = double_int_to_tree (TREE_TYPE (mem_op->op0), off);
       op->op0 = build_fold_addr_expr (addr_base);
       if (tree_fits_shwi_p (mem_op->op0))
-	mem_op->off = TREE_INT_CST_LOW (mem_op->op0);
+	mem_op->off = tree_to_shwi (mem_op->op0);
       else
 	mem_op->off = -1;
     }
 }
 
 /* Fold *& at position *I_P in a vn_reference_op_s vector *OPS.  Updates
    *I_P to point to the last element of the replacement.  */
 static void
@@ -1217,17 +1217,17 @@ vn_reference_maybe_forwprop_address (vec
 	return;
 
       off += tree_to_double_int (ptroff);
       op->op0 = ptr;
     }
 
   mem_op->op0 = double_int_to_tree (TREE_TYPE (mem_op->op0), off);
   if (tree_fits_shwi_p (mem_op->op0))
-    mem_op->off = TREE_INT_CST_LOW (mem_op->op0);
+    mem_op->off = tree_to_shwi (mem_op->op0);
   else
     mem_op->off = -1;
   if (TREE_CODE (op->op0) == SSA_NAME)
     op->op0 = SSA_VAL (op->op0);
   if (TREE_CODE (op->op0) != SSA_NAME)
     op->opcode = TREE_CODE (op->op0);
 
   /* And recurse.  */
@@ -1588,19 +1588,19 @@ vn_reference_lookup_3 (ao_ref *ref, tree
       && integer_zerop (gimple_call_arg (def_stmt, 1))
       && tree_fits_uhwi_p (gimple_call_arg (def_stmt, 2))
       && TREE_CODE (gimple_call_arg (def_stmt, 0)) == ADDR_EXPR)
     {
       tree ref2 = TREE_OPERAND (gimple_call_arg (def_stmt, 0), 0);
       tree base2;
       HOST_WIDE_INT offset2, size2, maxsize2;
       base2 = get_ref_base_and_extent (ref2, &offset2, &size2, &maxsize2);
-      size2 = TREE_INT_CST_LOW (gimple_call_arg (def_stmt, 2)) * 8;
+      size2 = tree_to_uhwi (gimple_call_arg (def_stmt, 2)) * 8;
       if ((unsigned HOST_WIDE_INT)size2 / 8
-	  == TREE_INT_CST_LOW (gimple_call_arg (def_stmt, 2))
+	  == tree_to_uhwi (gimple_call_arg (def_stmt, 2))
 	  && maxsize2 != -1
 	  && operand_equal_p (base, base2, 0)
 	  && offset2 <= offset
 	  && offset2 + size2 >= offset + maxsize)
 	{
 	  tree val = build_zero_cst (vr->type);
 	  return vn_reference_lookup_or_insert_for_pieces
 	           (vuse, vr->set, vr->type, vr->operands, val);
@@ -1860,17 +1860,17 @@ vn_reference_lookup_3 (ao_ref *ref, tree
 	  tree tem = get_addr_base_and_unit_offset (TREE_OPERAND (lhs, 0),
 						    &lhs_offset);
 	  if (!tem)
 	    return (void *)-1;
 	  if (TREE_CODE (tem) == MEM_REF
 	      && tree_fits_uhwi_p (TREE_OPERAND (tem, 1)))
 	    {
 	      lhs = TREE_OPERAND (tem, 0);
-	      lhs_offset += TREE_INT_CST_LOW (TREE_OPERAND (tem, 1));
+	      lhs_offset += tree_to_uhwi (TREE_OPERAND (tem, 1));
 	    }
 	  else if (DECL_P (tem))
 	    lhs = build_fold_addr_expr (tem);
 	  else
 	    return (void *)-1;
 	}
       if (TREE_CODE (lhs) != SSA_NAME
 	  && TREE_CODE (lhs) != ADDR_EXPR)
@@ -1886,44 +1886,44 @@ vn_reference_lookup_3 (ao_ref *ref, tree
 	  tree tem = get_addr_base_and_unit_offset (TREE_OPERAND (rhs, 0),
 						    &rhs_offset);
 	  if (!tem)
 	    return (void *)-1;
 	  if (TREE_CODE (tem) == MEM_REF
 	      && tree_fits_uhwi_p (TREE_OPERAND (tem, 1)))
 	    {
 	      rhs = TREE_OPERAND (tem, 0);
-	      rhs_offset += TREE_INT_CST_LOW (TREE_OPERAND (tem, 1));
+	      rhs_offset += tree_to_uhwi (TREE_OPERAND (tem, 1));
 	    }
 	  else if (DECL_P (tem))
 	    rhs = build_fold_addr_expr (tem);
 	  else
 	    return (void *)-1;
 	}
       if (TREE_CODE (rhs) != SSA_NAME
 	  && TREE_CODE (rhs) != ADDR_EXPR)
 	return (void *)-1;
 
-      copy_size = TREE_INT_CST_LOW (gimple_call_arg (def_stmt, 2));
+      copy_size = tree_to_uhwi (gimple_call_arg (def_stmt, 2));
 
       /* The bases of the destination and the references have to agree.  */
       if ((TREE_CODE (base) != MEM_REF
 	   && !DECL_P (base))
 	  || (TREE_CODE (base) == MEM_REF
 	      && (TREE_OPERAND (base, 0) != lhs
 		  || !tree_fits_uhwi_p (TREE_OPERAND (base, 1))))
 	  || (DECL_P (base)
 	      && (TREE_CODE (lhs) != ADDR_EXPR
 		  || TREE_OPERAND (lhs, 0) != base)))
 	return (void *)-1;
 
       /* And the access has to be contained within the memcpy destination.  */
       at = offset / BITS_PER_UNIT;
       if (TREE_CODE (base) == MEM_REF)
-	at += TREE_INT_CST_LOW (TREE_OPERAND (base, 1));
+	at += tree_to_uhwi (TREE_OPERAND (base, 1));
       if (lhs_offset > at
 	  || lhs_offset + copy_size < at + maxsize / BITS_PER_UNIT)
 	return (void *)-1;
 
       /* Make room for 2 operands in the new reference.  */
       if (vr->operands.length () < 2)
 	{
 	  vec<vn_reference_op_s> old = vr->operands;
@@ -3221,17 +3221,17 @@ simplify_binary_expression (gimple stmt)
   /* Pointer plus constant can be represented as invariant address.
      Do so to allow further propatation, see also tree forwprop.  */
   if (code == POINTER_PLUS_EXPR
       && tree_fits_uhwi_p (op1)
       && TREE_CODE (op0) == ADDR_EXPR
       && is_gimple_min_invariant (op0))
     return build_invariant_address (TREE_TYPE (op0),
 				    TREE_OPERAND (op0, 0),
-				    TREE_INT_CST_LOW (op1));
+				    tree_to_uhwi (op1));
 
   /* Avoid folding if nothing changed.  */
   if (op0 == gimple_assign_rhs1 (stmt)
       && op1 == gimple_assign_rhs2 (stmt))
     return NULL_TREE;
 
   fold_defer_overflow_warnings ();
 
Index: gcc/tree-ssa-structalias.c
===================================================================
--- gcc/tree-ssa-structalias.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/tree-ssa-structalias.c	2013-11-19 12:09:07.952676600 +0000
@@ -2993,18 +2993,18 @@ process_constraint (constraint_t t)
 
 static HOST_WIDE_INT
 bitpos_of_field (const tree fdecl)
 {
   if (!tree_fits_shwi_p (DECL_FIELD_OFFSET (fdecl))
       || !tree_fits_shwi_p (DECL_FIELD_BIT_OFFSET (fdecl)))
     return -1;
 
-  return (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (fdecl)) * BITS_PER_UNIT
-	  + TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (fdecl)));
+  return (tree_to_shwi (DECL_FIELD_OFFSET (fdecl)) * BITS_PER_UNIT
+	  + tree_to_shwi (DECL_FIELD_BIT_OFFSET (fdecl)));
 }
 
 
 /* Get constraint expressions for offsetting PTR by OFFSET.  Stores the
    resulting constraint expressions in *RESULTS.  */
 
 static void
 get_constraint_for_ptr_offset (tree ptr, tree offset,
@@ -3425,17 +3425,17 @@ get_constraint_for_1 (tree t, vec<ce_s>
 
 	      vi = get_varinfo (cs.var);
 	      curr = vi_next (vi);
 	      if (!vi->is_full_var
 		  && curr)
 		{
 		  unsigned HOST_WIDE_INT size;
 		  if (tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (t))))
-		    size = TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (t)));
+		    size = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (t)));
 		  else
 		    size = -1;
 		  for (; curr; curr = vi_next (curr))
 		    {
 		      if (curr->offset - vi->offset < size)
 			{
 			  cs.var = curr->id;
 			  results->safe_push (cs);
@@ -5355,25 +5355,25 @@ push_fields_onto_fieldstack (tree type,
 	    must_have_pointers_p = field_must_have_pointers (field);
 	    if (pair
 		&& !has_unknown_size
 		&& !must_have_pointers_p
 		&& !pair->must_have_pointers
 		&& !pair->has_unknown_size
 		&& pair->offset + (HOST_WIDE_INT)pair->size == offset + foff)
 	      {
-		pair->size += TREE_INT_CST_LOW (DECL_SIZE (field));
+		pair->size += tree_to_uhwi (DECL_SIZE (field));
 	      }
 	    else
 	      {
 		fieldoff_s e;
 		e.offset = offset + foff;
 		e.has_unknown_size = has_unknown_size;
 		if (!has_unknown_size)
-		  e.size = TREE_INT_CST_LOW (DECL_SIZE (field));
+		  e.size = tree_to_uhwi (DECL_SIZE (field));
 		else
 		  e.size = -1;
 		e.must_have_pointers = must_have_pointers_p;
 		e.may_have_pointers = true;
 		e.only_restrict_pointers
 		  = (!has_unknown_size
 		     && POINTER_TYPE_P (TREE_TYPE (field))
 		     && TYPE_RESTRICT (TREE_TYPE (field)));
@@ -5680,25 +5680,25 @@ create_variable_info_for_1 (tree decl, c
   /* If we didn't end up collecting sub-variables create a full
      variable for the decl.  */
   if (fieldstack.length () <= 1
       || fieldstack.length () > MAX_FIELDS_FOR_FIELD_SENSITIVE)
     {
       vi = new_var_info (decl, name);
       vi->offset = 0;
       vi->may_have_pointers = true;
-      vi->fullsize = TREE_INT_CST_LOW (declsize);
+      vi->fullsize = tree_to_uhwi (declsize);
       vi->size = vi->fullsize;
       vi->is_full_var = true;
       fieldstack.release ();
       return vi;
     }
 
   vi = new_var_info (decl, name);
-  vi->fullsize = TREE_INT_CST_LOW (declsize);
+  vi->fullsize = tree_to_uhwi (declsize);
   for (i = 0, newvi = vi;
        fieldstack.iterate (i, &fo);
        ++i, newvi = vi_next (newvi))
     {
       const char *newname = "NULL";
       char *tempname;
 
       if (dump_file)
Index: gcc/tree-vect-data-refs.c
===================================================================
--- gcc/tree-vect-data-refs.c	2013-11-19 11:59:43.285326264 +0000
+++ gcc/tree-vect-data-refs.c	2013-11-19 12:09:07.953676607 +0000
@@ -776,17 +776,17 @@ vect_compute_data_ref_alignment (struct
     {
       /* Negative or overflowed misalignment value.  */
       if (dump_enabled_p ())
 	dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
 	                 "unexpected misalign value\n");
       return false;
     }
 
-  SET_DR_MISALIGNMENT (dr, TREE_INT_CST_LOW (misalign));
+  SET_DR_MISALIGNMENT (dr, tree_to_uhwi (misalign));
 
   if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                        "misalign = %d bytes of ref ", DR_MISALIGNMENT (dr));
       dump_generic_expr (MSG_MISSED_OPTIMIZATION, TDF_SLIM, ref);
       dump_printf (MSG_MISSED_OPTIMIZATION, "\n");
     }
@@ -958,17 +958,17 @@ vect_verify_datarefs_alignment (loop_vec
    than its size.  */
 
 static bool
 not_size_aligned (tree exp)
 {
   if (!tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (exp))))
     return true;
 
-  return (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp)))
+  return (tree_to_uhwi (TYPE_SIZE (TREE_TYPE (exp)))
 	  > get_object_alignment (exp));
 }
 
 /* Function vector_alignment_reachable_p
 
    Return true if vector alignment for DR is reachable by peeling
    a few loop iterations.  Return false otherwise.  */
 
@@ -2564,23 +2564,23 @@ vect_analyze_data_ref_accesses (loop_vec
 
 	  /* Sorting has ensured that DR_INIT (dra) <= DR_INIT (drb).  */
 	  HOST_WIDE_INT init_a = TREE_INT_CST_LOW (DR_INIT (dra));
 	  HOST_WIDE_INT init_b = TREE_INT_CST_LOW (DR_INIT (drb));
 	  gcc_assert (init_a < init_b);
 
 	  /* If init_b == init_a + the size of the type * k, we have an
 	     interleaving, and DRA is accessed before DRB.  */
-	  HOST_WIDE_INT type_size_a = TREE_INT_CST_LOW (sza);
+	  HOST_WIDE_INT type_size_a = tree_to_uhwi (sza);
 	  if ((init_b - init_a) % type_size_a != 0)
 	    break;
 
 	  /* The step (if not zero) is greater than the difference between
 	     data-refs' inits.  This splits groups into suitable sizes.  */
-	  HOST_WIDE_INT step = TREE_INT_CST_LOW (DR_STEP (dra));
+	  HOST_WIDE_INT step = tree_to_shwi (DR_STEP (dra));
 	  if (step != 0 && step <= (init_b - init_a))
 	    break;
 
 	  if (dump_enabled_p ())
 	    {
 	      dump_printf_loc (MSG_NOTE, vect_location,
 			       "Detected interleaving ");
 	      dump_generic_expr (MSG_NOTE, TDF_SLIM, DR_REF (dra));
@@ -2876,18 +2876,18 @@ vect_prune_runtime_alias_test_list (loop
 
 	  if (!operand_equal_p (DR_BASE_ADDRESS (dr_a1->dr),
 				DR_BASE_ADDRESS (dr_a2->dr),
 				0)
 	      || !tree_fits_shwi_p (dr_a1->offset)
 	      || !tree_fits_shwi_p (dr_a2->offset))
 	    continue;
 
-	  HOST_WIDE_INT diff = TREE_INT_CST_LOW (dr_a2->offset) -
-			       TREE_INT_CST_LOW (dr_a1->offset);
+	  HOST_WIDE_INT diff = (tree_to_shwi (dr_a2->offset)
+				- tree_to_shwi (dr_a1->offset));
 
 
 	  /* Now we check if the following condition is satisfied:
 
 	     DIFF - SEGMENT_LENGTH_A < SEGMENT_LENGTH_B
 
 	     where DIFF = DR_A2->OFFSET - DR_A1->OFFSET.  However,
 	     SEGMENT_LENGTH_A or SEGMENT_LENGTH_B may not be constant so we
Index: gcc/tree-vectorizer.h
===================================================================
--- gcc/tree-vectorizer.h	2013-11-19 11:59:43.285326264 +0000
+++ gcc/tree-vectorizer.h	2013-11-19 12:09:07.953676607 +0000
@@ -384,17 +384,17 @@ #define LOOP_VINFO_OPERANDS_SWAPPED(L)
 
 #define LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT(L) \
 (L)->may_misalign_stmts.length () > 0
 #define LOOP_REQUIRES_VERSIONING_FOR_ALIAS(L)     \
 (L)->may_alias_ddrs.length () > 0
 
 #define NITERS_KNOWN_P(n)                     \
 (tree_fits_shwi_p ((n))                        \
-&& TREE_INT_CST_LOW ((n)) > 0)
+&& tree_to_shwi ((n)) > 0)
 
 #define LOOP_VINFO_NITERS_KNOWN_P(L)          \
 NITERS_KNOWN_P ((L)->num_iters)
 
 static inline loop_vec_info
 loop_vec_info_for_loop (struct loop *loop)
 {
   return (loop_vec_info) loop->aux;
