aboutsummaryrefslogtreecommitdiff
path: root/gcc
diff options
context:
space:
mode:
Diffstat (limited to 'gcc')
-rw-r--r--gcc/ChangeLog22
-rw-r--r--gcc/alias.c4
-rw-r--r--gcc/cp/ChangeLog4
-rw-r--r--gcc/cp/init.c3
-rw-r--r--gcc/expr.c6
-rw-r--r--gcc/fold-const.c4
-rw-r--r--gcc/gimple-fold.c3
-rw-r--r--gcc/gimple-ssa-strength-reduction.c2
-rw-r--r--gcc/tree-dfa.c10
-rw-r--r--gcc/tree-ssa-alias.c21
-rw-r--r--gcc/tree-ssa-ccp.c4
-rw-r--r--gcc/tree-ssa-math-opts.c4
-rw-r--r--gcc/tree-ssa-sccvn.c9
-rw-r--r--gcc/tree.h2
-rw-r--r--gcc/wide-int.h36
15 files changed, 93 insertions, 41 deletions
diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index acc6b79..d83a16a 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,6 +1,28 @@
2016-05-02 Richard Sandiford <richard.sandiford@arm.com>
* wide-int.h: Update offset_int and widest_int documentation.
+ (WI_SIGNED_SHIFT_RESULT): New macro.
+ (wi::binary_shift): Define signed_shift_result_type for
+ shifts on offset_int- and widest_int-like types.
+ (generic_wide_int): Support <<= and >>= if << and >> are supported.
+ * tree.h (int_bit_position): Use shift operators instead of wi::
+ shifts.
+ * alias.c (adjust_offset_for_component_ref): Likewise.
+ * expr.c (get_inner_reference): Likewise.
+ * fold-const.c (fold_comparison): Likewise.
+ * gimple-fold.c (fold_nonarray_ctor_reference): Likewise.
+ * gimple-ssa-strength-reduction.c (restructure_reference): Likewise.
+ * tree-dfa.c (get_ref_base_and_extent): Likewise.
+ * tree-ssa-alias.c (indirect_ref_may_alias_decl_p): Likewise.
+ (stmt_kills_ref_p): Likewise.
+ * tree-ssa-ccp.c (bit_value_binop_1): Likewise.
+ * tree-ssa-math-opts.c (find_bswap_or_nop_load): Likewise.
+ * tree-ssa-sccvn.c (copy_reference_ops_from_ref): Likewise.
+ (ao_ref_init_from_vn_reference): Likewise.
+
+2016-05-02 Richard Sandiford <richard.sandiford@arm.com>
+
+ * wide-int.h: Update offset_int and widest_int documentation.
(WI_SIGNED_BINARY_PREDICATE_RESULT): New macro.
(wi::binary_traits): Allow ordered comparisons between offset_int and
offset_int, between widest_int and widest_int, and between either
diff --git a/gcc/alias.c b/gcc/alias.c
index a0e25dc..451f8f3 100644
--- a/gcc/alias.c
+++ b/gcc/alias.c
@@ -2651,8 +2651,8 @@ adjust_offset_for_component_ref (tree x, bool *known_p,
offset_int woffset
= (wi::to_offset (xoffset)
- + wi::lrshift (wi::to_offset (DECL_FIELD_BIT_OFFSET (field)),
- LOG2_BITS_PER_UNIT));
+ + (wi::to_offset (DECL_FIELD_BIT_OFFSET (field))
+ >> LOG2_BITS_PER_UNIT));
if (!wi::fits_uhwi_p (woffset))
{
*known_p = false;
diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 792c9c8..c40efcf 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,7 @@
+2016-05-02 Richard Sandiford <richard.sandiford@arm.com>
+
+ * init.c (build_new_1): Use shift operators instead of wi:: shifts.
+
2016-05-02 Richard Biener <rguenther@suse.de>
* decl.c (grokdeclarator): Properly insert a DECL_EXPR for
diff --git a/gcc/cp/init.c b/gcc/cp/init.c
index 4d19e46..681ca12 100644
--- a/gcc/cp/init.c
+++ b/gcc/cp/init.c
@@ -2812,8 +2812,7 @@ build_new_1 (vec<tree, va_gc> **placement, tree type, tree nelts,
unsigned shift = (max_outer_nelts.get_precision ()) - 7
- wi::clz (max_outer_nelts);
- max_outer_nelts = wi::lshift (wi::lrshift (max_outer_nelts, shift),
- shift);
+ max_outer_nelts = (max_outer_nelts >> shift) << shift;
outer_nelts_check = fold_build2 (LE_EXPR, boolean_type_node,
outer_nelts,
diff --git a/gcc/expr.c b/gcc/expr.c
index 248d3d7..8870a0c 100644
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -6989,7 +6989,7 @@ get_inner_reference (tree exp, HOST_WIDE_INT *pbitsize,
if (!integer_zerop (off))
{
offset_int boff, coff = mem_ref_offset (exp);
- boff = wi::lshift (coff, LOG2_BITS_PER_UNIT);
+ boff = coff << LOG2_BITS_PER_UNIT;
bit_offset += boff;
}
exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
@@ -7015,7 +7015,7 @@ get_inner_reference (tree exp, HOST_WIDE_INT *pbitsize,
{
offset_int tem = wi::sext (wi::to_offset (offset),
TYPE_PRECISION (sizetype));
- tem = wi::lshift (tem, LOG2_BITS_PER_UNIT);
+ tem <<= LOG2_BITS_PER_UNIT;
tem += bit_offset;
if (wi::fits_shwi_p (tem))
{
@@ -7035,7 +7035,7 @@ get_inner_reference (tree exp, HOST_WIDE_INT *pbitsize,
/* TEM is the bitpos rounded to BITS_PER_UNIT towards -Inf.
Subtract it to BIT_OFFSET and add it (scaled) to OFFSET. */
bit_offset -= tem;
- tem = wi::arshift (tem, LOG2_BITS_PER_UNIT);
+ tem >>= LOG2_BITS_PER_UNIT;
offset = size_binop (PLUS_EXPR, offset,
wide_int_to_tree (sizetype, tem));
}
diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 4aa2412..8ece0f8 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -8521,7 +8521,7 @@ fold_comparison (location_t loc, enum tree_code code, tree type,
{
offset_int tem = wi::sext (wi::to_offset (offset0),
TYPE_PRECISION (sizetype));
- tem = wi::lshift (tem, LOG2_BITS_PER_UNIT);
+ tem <<= LOG2_BITS_PER_UNIT;
tem += bitpos0;
if (wi::fits_shwi_p (tem))
{
@@ -8568,7 +8568,7 @@ fold_comparison (location_t loc, enum tree_code code, tree type,
{
offset_int tem = wi::sext (wi::to_offset (offset1),
TYPE_PRECISION (sizetype));
- tem = wi::lshift (tem, LOG2_BITS_PER_UNIT);
+ tem <<= LOG2_BITS_PER_UNIT;
tem += bitpos1;
if (wi::fits_shwi_p (tem))
{
diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c
index 6ed72dc..5607598 100644
--- a/gcc/gimple-fold.c
+++ b/gcc/gimple-fold.c
@@ -5435,8 +5435,7 @@ fold_nonarray_ctor_reference (tree type, tree ctor,
/* Compute bit offset of the field. */
bitoffset = (wi::to_offset (field_offset)
- + wi::lshift (wi::to_offset (byte_offset),
- LOG2_BITS_PER_UNIT));
+ + (wi::to_offset (byte_offset) << LOG2_BITS_PER_UNIT));
/* Compute bit offset where the field ends. */
if (field_size != NULL_TREE)
bitoffset_end = bitoffset + wi::to_offset (field_size);
diff --git a/gcc/gimple-ssa-strength-reduction.c b/gcc/gimple-ssa-strength-reduction.c
index b235151..0824f17 100644
--- a/gcc/gimple-ssa-strength-reduction.c
+++ b/gcc/gimple-ssa-strength-reduction.c
@@ -951,7 +951,7 @@ restructure_reference (tree *pbase, tree *poffset, widest_int *pindex,
c2 = 0;
}
- c4 = wi::lrshift (index, LOG2_BITS_PER_UNIT);
+ c4 = index >> LOG2_BITS_PER_UNIT;
c5 = backtrace_base_for_ref (&t2);
*pbase = t1;
diff --git a/gcc/tree-dfa.c b/gcc/tree-dfa.c
index f133abc..f6986c1 100644
--- a/gcc/tree-dfa.c
+++ b/gcc/tree-dfa.c
@@ -424,8 +424,8 @@ get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset,
if (this_offset && TREE_CODE (this_offset) == INTEGER_CST)
{
- offset_int woffset = wi::lshift (wi::to_offset (this_offset),
- LOG2_BITS_PER_UNIT);
+ offset_int woffset = (wi::to_offset (this_offset)
+ << LOG2_BITS_PER_UNIT);
woffset += wi::to_offset (DECL_FIELD_BIT_OFFSET (field));
bit_offset += woffset;
@@ -453,7 +453,7 @@ get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset,
{
offset_int tem = (wi::to_offset (ssize)
- wi::to_offset (fsize));
- tem = wi::lshift (tem, LOG2_BITS_PER_UNIT);
+ tem <<= LOG2_BITS_PER_UNIT;
tem -= woffset;
maxsize += tem;
}
@@ -493,7 +493,7 @@ get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset,
= wi::sext (wi::to_offset (index) - wi::to_offset (low_bound),
TYPE_PRECISION (TREE_TYPE (index)));
woffset *= wi::to_offset (unit_size);
- woffset = wi::lshift (woffset, LOG2_BITS_PER_UNIT);
+ woffset <<= LOG2_BITS_PER_UNIT;
bit_offset += woffset;
/* An array ref with a constant index up in the structure
@@ -570,7 +570,7 @@ get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset,
else
{
offset_int off = mem_ref_offset (exp);
- off = wi::lshift (off, LOG2_BITS_PER_UNIT);
+ off <<= LOG2_BITS_PER_UNIT;
off += bit_offset;
if (wi::fits_shwi_p (off))
{
diff --git a/gcc/tree-ssa-alias.c b/gcc/tree-ssa-alias.c
index 4ffefaf..58920e0 100644
--- a/gcc/tree-ssa-alias.c
+++ b/gcc/tree-ssa-alias.c
@@ -1101,7 +1101,7 @@ indirect_ref_may_alias_decl_p (tree ref1 ATTRIBUTE_UNUSED, tree base1,
/* The offset embedded in MEM_REFs can be negative. Bias them
so that the resulting offset adjustment is positive. */
offset_int moff = mem_ref_offset (base1);
- moff = wi::lshift (moff, LOG2_BITS_PER_UNIT);
+ moff <<= LOG2_BITS_PER_UNIT;
if (wi::neg_p (moff))
offset2p += (-moff).to_short_addr ();
else
@@ -1173,7 +1173,7 @@ indirect_ref_may_alias_decl_p (tree ref1 ATTRIBUTE_UNUSED, tree base1,
|| TREE_CODE (dbase2) == TARGET_MEM_REF)
{
offset_int moff = mem_ref_offset (dbase2);
- moff = wi::lshift (moff, LOG2_BITS_PER_UNIT);
+ moff <<= LOG2_BITS_PER_UNIT;
if (wi::neg_p (moff))
doffset1 -= (-moff).to_short_addr ();
else
@@ -1271,13 +1271,13 @@ indirect_refs_may_alias_p (tree ref1 ATTRIBUTE_UNUSED, tree base1,
/* The offset embedded in MEM_REFs can be negative. Bias them
so that the resulting offset adjustment is positive. */
moff = mem_ref_offset (base1);
- moff = wi::lshift (moff, LOG2_BITS_PER_UNIT);
+ moff <<= LOG2_BITS_PER_UNIT;
if (wi::neg_p (moff))
offset2 += (-moff).to_short_addr ();
else
offset1 += moff.to_shwi ();
moff = mem_ref_offset (base2);
- moff = wi::lshift (moff, LOG2_BITS_PER_UNIT);
+ moff <<= LOG2_BITS_PER_UNIT;
if (wi::neg_p (moff))
offset1 += (-moff).to_short_addr ();
else
@@ -2358,10 +2358,10 @@ stmt_kills_ref_p (gimple *stmt, ao_ref *ref)
TREE_OPERAND (ref->base, 1)))
{
offset_int off1 = mem_ref_offset (base);
- off1 = wi::lshift (off1, LOG2_BITS_PER_UNIT);
+ off1 <<= LOG2_BITS_PER_UNIT;
off1 += offset;
offset_int off2 = mem_ref_offset (ref->base);
- off2 = wi::lshift (off2, LOG2_BITS_PER_UNIT);
+ off2 <<= LOG2_BITS_PER_UNIT;
off2 += ref_offset;
if (wi::fits_shwi_p (off1) && wi::fits_shwi_p (off2))
{
@@ -2432,18 +2432,15 @@ stmt_kills_ref_p (gimple *stmt, ao_ref *ref)
if (TREE_CODE (rbase) != MEM_REF)
return false;
// Compare pointers.
- offset += wi::lshift (mem_ref_offset (base),
- LOG2_BITS_PER_UNIT);
- roffset += wi::lshift (mem_ref_offset (rbase),
- LOG2_BITS_PER_UNIT);
+ offset += mem_ref_offset (base) << LOG2_BITS_PER_UNIT;
+ roffset += mem_ref_offset (rbase) << LOG2_BITS_PER_UNIT;
base = TREE_OPERAND (base, 0);
rbase = TREE_OPERAND (rbase, 0);
}
if (base == rbase
&& offset <= roffset
&& (roffset + ref->max_size
- <= offset + wi::lshift (wi::to_offset (len),
- LOG2_BITS_PER_UNIT)))
+ <= offset + (wi::to_offset (len) << LOG2_BITS_PER_UNIT)))
return true;
break;
}
diff --git a/gcc/tree-ssa-ccp.c b/gcc/tree-ssa-ccp.c
index 2568a41..baae03f 100644
--- a/gcc/tree-ssa-ccp.c
+++ b/gcc/tree-ssa-ccp.c
@@ -1372,8 +1372,8 @@ bit_value_binop_1 (enum tree_code code, tree type,
}
else
{
- *mask = wi::ext (wi::lshift (r1mask, shift), width, sgn);
- *val = wi::ext (wi::lshift (r1val, shift), width, sgn);
+ *mask = wi::ext (r1mask << shift, width, sgn);
+ *val = wi::ext (r1val << shift, width, sgn);
}
}
}
diff --git a/gcc/tree-ssa-math-opts.c b/gcc/tree-ssa-math-opts.c
index 735b7c6..3fcf24c 100644
--- a/gcc/tree-ssa-math-opts.c
+++ b/gcc/tree-ssa-math-opts.c
@@ -2104,7 +2104,7 @@ find_bswap_or_nop_load (gimple *stmt, tree ref, struct symbolic_number *n)
if (!integer_zerop (off))
{
offset_int boff, coff = mem_ref_offset (base_addr);
- boff = wi::lshift (coff, LOG2_BITS_PER_UNIT);
+ boff = coff << LOG2_BITS_PER_UNIT;
bit_offset += boff;
}
@@ -2118,7 +2118,7 @@ find_bswap_or_nop_load (gimple *stmt, tree ref, struct symbolic_number *n)
/* TEM is the bitpos rounded to BITS_PER_UNIT towards -Inf.
Subtract it to BIT_OFFSET and add it (scaled) to OFFSET. */
bit_offset -= tem;
- tem = wi::arshift (tem, LOG2_BITS_PER_UNIT);
+ tem >>= LOG2_BITS_PER_UNIT;
if (offset)
offset = size_binop (PLUS_EXPR, offset,
wide_int_to_tree (sizetype, tem));
diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c
index f6735dd..2dbe408 100644
--- a/gcc/tree-ssa-sccvn.c
+++ b/gcc/tree-ssa-sccvn.c
@@ -788,8 +788,7 @@ copy_reference_ops_from_ref (tree ref, vec<vn_reference_op_s> *result)
{
offset_int off
= (wi::to_offset (this_offset)
- + wi::lrshift (wi::to_offset (bit_offset),
- LOG2_BITS_PER_UNIT));
+ + (wi::to_offset (bit_offset) >> LOG2_BITS_PER_UNIT));
if (wi::fits_shwi_p (off)
/* Probibit value-numbering zero offset components
of addresses the same before the pass folding
@@ -999,8 +998,8 @@ ao_ref_init_from_vn_reference (ao_ref *ref,
max_size = -1;
else
{
- offset_int woffset = wi::lshift (wi::to_offset (this_offset),
- LOG2_BITS_PER_UNIT);
+ offset_int woffset = (wi::to_offset (this_offset)
+ << LOG2_BITS_PER_UNIT);
woffset += wi::to_offset (DECL_FIELD_BIT_OFFSET (field));
offset += woffset;
}
@@ -1020,7 +1019,7 @@ ao_ref_init_from_vn_reference (ao_ref *ref,
= wi::sext (wi::to_offset (op->op0) - wi::to_offset (op->op1),
TYPE_PRECISION (TREE_TYPE (op->op0)));
woffset *= wi::to_offset (op->op2);
- woffset = wi::lshift (woffset, LOG2_BITS_PER_UNIT);
+ woffset <<= LOG2_BITS_PER_UNIT;
offset += woffset;
}
break;
diff --git a/gcc/tree.h b/gcc/tree.h
index aa76f50..024cf3d 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -5375,7 +5375,7 @@ extern GTY(()) struct int_n_trees_t int_n_trees[NUM_INT_N_ENTS];
inline HOST_WIDE_INT
int_bit_position (const_tree field)
{
- return (wi::lshift (wi::to_offset (DECL_FIELD_OFFSET (field)), BITS_PER_UNIT_LOG)
+ return ((wi::to_offset (DECL_FIELD_OFFSET (field)) << BITS_PER_UNIT_LOG)
+ wi::to_offset (DECL_FIELD_BIT_OFFSET (field))).to_shwi ();
}
diff --git a/gcc/wide-int.h b/gcc/wide-int.h
index b1dfcff..7dde74f 100644
--- a/gcc/wide-int.h
+++ b/gcc/wide-int.h
@@ -68,6 +68,8 @@ along with GCC; see the file COPYING3. If not see
Since the values are logically signed, there is no need to
distinguish between signed and unsigned operations. Sign-sensitive
comparison operators <, <=, > and >= are therefore supported.
+ Shift operators << and >> are also supported, with >> being
+ an _arithmetic_ right shift.
[ Note that, even though offset_int is effectively int128_t,
it can still be useful to use unsigned comparisons like
@@ -82,7 +84,8 @@ along with GCC; see the file COPYING3. If not see
Like offset_int, widest_int is wider than all the values that
it needs to represent, so the integers are logically signed.
- Sign-sensitive comparison operators <, <=, > and >= are supported.
+ Sign-sensitive comparison operators <, <=, > and >= are supported,
+ as are << and >>.
There are several places in the GCC where this should/must be used:
@@ -259,6 +262,11 @@ along with GCC; see the file COPYING3. If not see
#define WI_BINARY_RESULT(T1, T2) \
typename wi::binary_traits <T1, T2>::result_type
+/* The type of result produced by T1 << T2. Leads to substitution failure
+ if the operation isn't supported. Defined purely for brevity. */
+#define WI_SIGNED_SHIFT_RESULT(T1, T2) \
+ typename wi::binary_traits <T1, T2>::signed_shift_result_type
+
/* The type of result produced by a signed binary predicate on types T1 and T2.
This is bool if signed comparisons make sense for T1 and T2 and leads to
substitution failure otherwise. */
@@ -405,6 +413,7 @@ namespace wi
so as not to confuse gengtype. */
typedef generic_wide_int < fixed_wide_int_storage
<int_traits <T1>::precision> > result_type;
+ typedef result_type signed_shift_result_type;
typedef bool signed_predicate_result;
};
@@ -416,6 +425,7 @@ namespace wi
STATIC_ASSERT (int_traits <T1>::precision == int_traits <T2>::precision);
typedef generic_wide_int < fixed_wide_int_storage
<int_traits <T1>::precision> > result_type;
+ typedef result_type signed_shift_result_type;
typedef bool signed_predicate_result;
};
@@ -681,6 +691,11 @@ public:
template <typename T> \
generic_wide_int &OP (const T &c) { return (*this = wi::F (*this, c)); }
+/* Restrict these to cases where the shift operator is defined. */
+#define SHIFT_ASSIGNMENT_OPERATOR(OP, OP2) \
+ template <typename T> \
+ generic_wide_int &OP (const T &c) { return (*this = *this OP2 c); }
+
#define INCDEC_OPERATOR(OP, DELTA) \
generic_wide_int &OP () { *this += DELTA; return *this; }
@@ -702,12 +717,15 @@ public:
ASSIGNMENT_OPERATOR (operator +=, add)
ASSIGNMENT_OPERATOR (operator -=, sub)
ASSIGNMENT_OPERATOR (operator *=, mul)
+ SHIFT_ASSIGNMENT_OPERATOR (operator <<=, <<)
+ SHIFT_ASSIGNMENT_OPERATOR (operator >>=, >>)
INCDEC_OPERATOR (operator ++, 1)
INCDEC_OPERATOR (operator --, -1)
#undef BINARY_PREDICATE
#undef UNARY_OPERATOR
#undef BINARY_OPERATOR
+#undef SHIFT_ASSIGNMENT_OPERATOR
#undef ASSIGNMENT_OPERATOR
#undef INCDEC_OPERATOR
@@ -857,7 +875,7 @@ generic_wide_int <storage>::elt (unsigned int i) const
template <typename storage>
template <typename T>
-generic_wide_int <storage> &
+inline generic_wide_int <storage> &
generic_wide_int <storage>::operator = (const T &x)
{
storage::operator = (x);
@@ -3078,6 +3096,20 @@ SIGNED_BINARY_PREDICATE (operator >=, ges_p)
#undef SIGNED_BINARY_PREDICATE
+template <typename T1, typename T2>
+inline WI_SIGNED_SHIFT_RESULT (T1, T2)
+operator << (const T1 &x, const T2 &y)
+{
+ return wi::lshift (x, y);
+}
+
+template <typename T1, typename T2>
+inline WI_SIGNED_SHIFT_RESULT (T1, T2)
+operator >> (const T1 &x, const T2 &y)
+{
+ return wi::arshift (x, y);
+}
+
template<typename T>
void
gt_ggc_mx (generic_wide_int <T> *)
generated by cgit v1.1 at 2024-10-28 13:13:04 +0000