Re: Remove build_int_cst_wide_type function.

[Richard Guenther <richard dot guenther at gmail dot com>]

2010/5/7 Anatoly Sokolov <aesok@post.ru>:
> Hello.
>
>
> ?The build_int_cst_wide_type and double_int_to_tree functions do the same
> work but differ only in argument types. The build_int_cst_wide_type get
> INT_CST as doule_int type, build_int_cst_wide_type as pair HOST_WIDE_INT.
> This patch change all uses build_int_cst_wide_type with double_int_to_tree and
> remove build_int_cst_wide_type function.
>
> ?Bootstrapped/regtested on x86_64-unknown-linux-gnu for c, c++ and java.
>
> ?OK for mainline?

Comments inline

> ? ? ? ?* double-int.h (double_int_ior): New function.
> ? ? ? ?* tree.h (build_int_cst_wide_type): Remove.
> ? ? ? ?* tree.c (build_int_cst_wide_type): Remove.
> ? ? ? ?(double_int_to_tree, double_int_fits_to_tree_p): Handle size types as
> ? ? ? ?sign extended.
> ? ? ? ?* fold-const.c (native_interpret_int): Use double_int_to_tree instead
> ? ? ? ?of build_int_cst_wide_type.
> ? ? ? ?* dojump.c (do_jump): (Ditto.).
> ? ? ? ?* stor-layout.c (set_sizetype): (Ditto.).
>
> /java
> ? ? ? ?* jcf-parse.c (get_constant): Use double_int_to_tree instead of
> ? ? ? ?build_int_cst_wide_type.
>
>
> Index: gcc/java/jcf-parse.c
> ===================================================================
> --- gcc/java/jcf-parse.c ? ? ? ?(revision 159109)
> +++ gcc/java/jcf-parse.c ? ? ? ?(working copy)
> @@ -1040,14 +1040,15 @@
> ? ? ? }
> ? ? case CONSTANT_Long:
> ? ? ? {
> - ? ? ? unsigned HOST_WIDE_INT num = JPOOL_UINT (jcf, index);
> - ? ? ? unsigned HOST_WIDE_INT lo;
> - ? ? ? HOST_WIDE_INT hi;
> -
> - ? ? ? lshift_double (num, 0, 32, 64, &lo, &hi, 0);
> - ? ? ? num = JPOOL_UINT (jcf, index+1);
> - ? ? ? add_double (lo, hi, num, 0, &lo, &hi);
> - ? ? ? value = build_int_cst_wide_type (long_type_node, lo, hi);
> + ? ? ? unsigned HOST_WIDE_INT num;
> + ? ? ? double_int val;
> +
> + ? ? ? num = JPOOL_UINT (jcf, index);
> + ? ? ? val = double_int_lshift (uhwi_to_double_int (num), 32, 64, false);
> + ? ? ? num = JPOOL_UINT (jcf, index + 1);
> + ? ? ? val = double_int_ior (val, uhwi_to_double_int (num));
> +
> + ? ? ? value = double_int_to_tree (long_type_node, val);
> ? ? ? ?break;
> ? ? ? }
>
> Index: gcc/tree.c
> ===================================================================
> --- gcc/tree.c ?(revision 159109)
> +++ gcc/tree.c ?(working copy)
> @@ -1071,25 +1071,19 @@
> ? return build_int_cst_wide (type, low1, hi);
> ?}
>
> -/* Create an INT_CST node of TYPE and value HI:LOW. ?The value is truncated
> - ? and sign extended according to the value range of TYPE. ?*/
> -
> -tree
> -build_int_cst_wide_type (tree type,
> - ? ? ? ? ? ? ? ? ? ? ? ?unsigned HOST_WIDE_INT low, HOST_WIDE_INT high)
> -{
> - ?fit_double_type (low, high, &low, &high, type);
> - ?return build_int_cst_wide (type, low, high);
> -}
> -
> ?/* Constructs tree in type TYPE from with value given by CST. ?Signedness
> ? ?of CST is assumed to be the same as the signedness of TYPE. ?*/
>
> ?tree
> ?double_int_to_tree (tree type, double_int cst)
> ?{
> - ?cst = double_int_ext (cst, TYPE_PRECISION (type), TYPE_UNSIGNED (type));
> + ?/* Size types *are* sign extended. ?*/
> + ?bool sign_extended_type = (!TYPE_UNSIGNED (type)
> + ? ? ? ? ? ? ? ? ? ? ? ? ? ?|| (TREE_CODE (type) == INTEGER_TYPE
> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?&& TYPE_IS_SIZETYPE (type)));

whoops - thanks for catching this.

> + ?cst = double_int_ext (cst, TYPE_PRECISION (type), !sign_extended_type);
> +
> ? return build_int_cst_wide (type, cst.low, cst.high);
> ?}
>
> @@ -1099,10 +1093,14 @@
> ?bool
> ?double_int_fits_to_tree_p (const_tree type, double_int cst)
> ?{
> - ?double_int ext = double_int_ext (cst,
> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?TYPE_PRECISION (type),
> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?TYPE_UNSIGNED (type));
> + ?/* Size types *are* sign extended. ?*/
> + ?bool sign_extended_type = (!TYPE_UNSIGNED (type)
> + ? ? ? ? ? ? ? ? ? ? ? ? ? ?|| (TREE_CODE (type) == INTEGER_TYPE
> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?&& TYPE_IS_SIZETYPE (type)));
>
> + ?double_int ext
> + ? ?= double_int_ext (cst, TYPE_PRECISION (type), !sign_extended_type);
> +
> ? return double_int_equal_p (cst, ext);
> ?}
>
> Index: gcc/tree.h
> ===================================================================
> --- gcc/tree.h ?(revision 159109)
> +++ gcc/tree.h ?(working copy)
> @@ -4013,8 +4013,6 @@
> ?extern tree build_int_cst_type (tree, HOST_WIDE_INT);
> ?extern tree build_int_cstu (tree, unsigned HOST_WIDE_INT);
> ?extern tree build_int_cst_wide (tree, unsigned HOST_WIDE_INT, HOST_WIDE_INT);
> -extern tree build_int_cst_wide_type (tree,
> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?unsigned HOST_WIDE_INT, HOST_WIDE_INT);
> ?extern tree build_vector (tree, tree);
> ?extern tree build_vector_from_ctor (tree, VEC(constructor_elt,gc) *);
> ?extern tree build_constructor (tree, VEC(constructor_elt,gc) *);
> Index: gcc/fold-const.c
> ===================================================================
> --- gcc/fold-const.c ? ?(revision 159109)
> +++ gcc/fold-const.c ? ?(working copy)
> @@ -7408,13 +7408,14 @@
> ? int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
> ? int byte, offset, word, words;
> ? unsigned char value;
> - ?unsigned int HOST_WIDE_INT lo = 0;
> - ?HOST_WIDE_INT hi = 0;
> + ?double_int result;
>
> ? if (total_bytes > len)
> ? ? return NULL_TREE;
> ? if (total_bytes * BITS_PER_UNIT > 2 * HOST_BITS_PER_WIDE_INT)
> ? ? return NULL_TREE;
> +
> + ?result = double_int_zero;
> ? words = total_bytes / UNITS_PER_WORD;
>
> ? for (byte = 0; byte < total_bytes; byte++)
> @@ -7436,13 +7437,13 @@
> ? ? ? value = ptr[offset];
>
> ? ? ? if (bitpos < HOST_BITS_PER_WIDE_INT)
> - ? ? ? lo |= (unsigned HOST_WIDE_INT) value << bitpos;
> + ? ? ? result.low |= (unsigned HOST_WIDE_INT) value << bitpos;
> ? ? ? else
> - ? ? ? hi |= (unsigned HOST_WIDE_INT) value
> - ? ? ? ? ? ? << (bitpos - HOST_BITS_PER_WIDE_INT);
> + ? ? ? result.high |= (unsigned HOST_WIDE_INT) value
> + ? ? ? ? ? ? ? ? ? ? ?<< (bitpos - HOST_BITS_PER_WIDE_INT);
> ? ? }
>
> - ?return build_int_cst_wide_type (type, lo, hi);
> + ?return double_int_to_tree (type, result);
> ?}
>
>
> Index: gcc/dojump.c
> ===================================================================
> --- gcc/dojump.c ? ? ? ?(revision 159109)
> +++ gcc/dojump.c ? ? ? ?(working copy)
> @@ -539,10 +539,11 @@
> ? ? ? ? ? ? ? ? ?&& prefer_and_bit_test (TYPE_MODE (argtype),
> ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?TREE_INT_CST_LOW (shift)))
> ? ? ? ? ? ? ? ?{
> - ? ? ? ? ? ? ? ? unsigned HOST_WIDE_INT mask
> - ? ? ? ? ? ? ? ? ? = (unsigned HOST_WIDE_INT) 1 << TREE_INT_CST_LOW (shift);
> + ? ? ? ? ? ? ? ? double_int mask
> + ? ? ? ? ? ? ? ? ? = double_int_setbit (double_int_zero,
> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?TREE_INT_CST_LOW (shift));
> ? ? ? ? ? ? ? ? ?do_jump (build2 (BIT_AND_EXPR, argtype, arg,
> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?build_int_cst_wide_type (argtype, mask, 0)),
> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?double_int_to_tree (argtype, mask)),

Use build_int_cstu instead and retain using HOST_WIDE_INTs.  Btw,
both build_int_cst and build_int_cstu should do proper sign/zero
extension as the types precision may be lower than that of
HOST_WIDE_INT.

> ? ? ? ? ? ? ? ? ? ? ? ? ? clr_label, set_label, setclr_prob);
> ? ? ? ? ? ? ? ? ?break;
> ? ? ? ? ? ? ? ?}
> Index: gcc/double-int.h
> ===================================================================
> --- gcc/double-int.h ? ?(revision 159109)
> +++ gcc/double-int.h ? ?(working copy)
> @@ -126,6 +126,7 @@
> ?double_int double_int_setbit (double_int, unsigned);
>
> ?/* Logical operations. ?*/
> +
> ?static inline double_int
> ?double_int_not (double_int a)
> ?{
> @@ -134,6 +135,14 @@
> ? return a;
> ?}
>
> +static inline double_int
> +double_int_ior (double_int a, double_int b)
> +{
> + ?a.low |= b.low;
> + ?a.high |= b.high;
> + ?return a;
> +}
> +
> ?/* Shift operations. ?*/
> ?double_int double_int_lshift (double_int, HOST_WIDE_INT, unsigned int, bool);
> ?double_int double_int_rshift (double_int, HOST_WIDE_INT, unsigned int, bool);
> Index: gcc/stor-layout.c
> ===================================================================
> --- gcc/stor-layout.c ? (revision 159109)
> +++ gcc/stor-layout.c ? (working copy)
> @@ -2275,9 +2275,7 @@
> ? ? ?sign-extended in a way consistent with force_fit_type. ?*/
> ? max = TYPE_MAX_VALUE (sizetype);
> ? TYPE_MAX_VALUE (sizetype)
> - ? ?= build_int_cst_wide_type (sizetype,
> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?TREE_INT_CST_LOW (max),
> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?TREE_INT_CST_HIGH (max));
> + ? ?= double_int_to_tree (sizetype, tree_to_double_int (max));

Ok with these changes.

Thanks,
Richard.