This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: [4/4] The rest of the tree_to_[su]hwi changes


On Tue, Nov 19, 2013 at 1:10 PM, Richard Sandiford
<rdsandiford@googlemail.com> wrote:
> This patch just changes TREE_INT_CST_LOW to tree_to_[su]hwi in cases
> where there is already a protecting tree_fits_[su]hwi_p.  I've upped
> the number of context lines in case that helps, but there are still
> some hunks where the tree_fits_* call is too high up.

Ok.

Thanks,
Richard.

> Thanks,
> Richard
>
>
> gcc/ada/
> 2013-11-19  Kenneth Zadeck  <zadeck@naturalbridge.com>
>             Mike Stump  <mikestump@comcast.net>
>             Richard Sandiford  <rdsandiford@googlemail.com>
>
>         * gcc-interface/cuintp.c (UI_From_gnu): Use tree_to_shwi.
>         * gcc-interface/decl.c (gnat_to_gnu_entity): Use tree_to_uhwi.
>         * gcc-interface/utils.c (make_packable_type): Likewise.
>
> gcc/c-family/
> 2013-11-19  Kenneth Zadeck  <zadeck@naturalbridge.com>
>             Mike Stump  <mikestump@comcast.net>
>             Richard Sandiford  <rdsandiford@googlemail.com>
>
>         * c-ada-spec.c (is_simple_enum): Use tree_to_shwi and tree_to_uhwi
>         instead of TREE_INT_CST_LOW, in cases where there is a protecting
>         tree_fits_shwi_p or tree_fits_uhwi_p.
>         (dump_generic_ada_node): Likewise.
>         * c-format.c (check_format_arg): Likewise.
>         * c-pretty-print.c (pp_c_integer_constant): Likewise.
>
> gcc/
> 2013-11-19  Kenneth Zadeck  <zadeck@naturalbridge.com>
>             Mike Stump  <mikestump@comcast.net>
>             Richard Sandiford  <rdsandiford@googlemail.com>
>
>         * alias.c (ao_ref_from_mem): Use tree_to_shwi and tree_to_uhwi
>         instead of TREE_INT_CST_LOW, in cases where there is a protecting
>         tree_fits_shwi_p or tree_fits_uhwi_p.
>         * builtins.c (fold_builtin_powi): Likewise.
>         * config/epiphany/epiphany.c (epiphany_special_round_type_align):
>         Likewise.
>         * dbxout.c (dbxout_symbol): Likewise.
>         * expr.c (expand_expr_real_1): Likewise.
>         * fold-const.c (fold_single_bit_test, fold_plusminus_mult_expr)
>         (fold_binary_loc): Likewise.
>         * gimple-fold.c (fold_const_aggregate_ref_1): Likewise.
>         * gimple-ssa-strength-reduction.c (stmt_cost): Likewise.
>         * omp-low.c (lower_omp_for_lastprivate): Likewise.
>         * simplify-rtx.c (delegitimize_mem_from_attrs): Likewise.
>         * stor-layout.c (compute_record_mode): Likewise.
>         * tree-cfg.c (verify_expr): Likewise.
>         * tree-dfa.c (get_ref_base_and_extent): Likewise.
>         * tree-pretty-print.c (dump_array_domain): Likewise.
>         * tree-sra.c (build_user_friendly_ref_for_offset): Likewise.
>         * tree-ssa-ccp.c (fold_builtin_alloca_with_align): Likewise.
>         * tree-ssa-loop-ivopts.c (get_loop_invariant_expr_id): Likewise.
>         * tree-ssa-math-opts.c (execute_cse_sincos): Likewise.
>         * tree-ssa-phiopt.c (hoist_adjacent_loads): Likewise.
>         * tree-ssa-reassoc.c (acceptable_pow_call): Likewise.
>         * tree-ssa-sccvn.c (copy_reference_ops_from_ref): Likewise.
>         (ao_ref_init_from_vn_reference, vn_reference_fold_indirect): Likewise.
>         (vn_reference_lookup_3, simplify_binary_expression): Likewise.
>         * tree-ssa-structalias.c (bitpos_of_field): Likewise.
>         (get_constraint_for_1, push_fields_onto_fieldstack): Likewise.
>         (create_variable_info_for_1): Likewise.
>         * tree-vect-data-refs.c (vect_compute_data_ref_alignment): Likewise.
>         (vect_verify_datarefs_alignment): Likewise.
>         (vect_analyze_data_ref_accesses): Likewise.
>         (vect_prune_runtime_alias_test_list): Likewise.
>         * tree-vectorizer.h (NITERS_KNOWN_P): Likewise.
>
> 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;


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]