From a02ed62ac9f8bd81bf60ff0064ec5b2319beaf3f Mon Sep 17 00:00:00 2001 From: doko Date: Tue, 1 Jul 2014 09:23:49 +0000 Subject: * Update to SVN 20140701 (r212193) from the gcc-4_8-branch. git-svn-id: svn://svn.debian.org/svn/gcccvs/branches/sid/gcc-4.8@7489 6ca36cf4-e1d1-0310-8c6f-e303bb2178ca --- debian/changelog | 4 +- debian/patches/svn-updates.diff | 595 +++++++++++++++++++++++++++++++++++++++- 2 files changed, 590 insertions(+), 9 deletions(-) diff --git a/debian/changelog b/debian/changelog index 2ccab49..88cdb9b 100644 --- a/debian/changelog +++ b/debian/changelog @@ -1,8 +1,8 @@ gcc-4.8 (4.8.3-5) UNRELEASED; urgency=medium - * Update to SVN 20140626 (r212051) from the gcc-4_8-branch. + * Update to SVN 20140701 (r212193) from the gcc-4_8-branch. - -- Matthias Klose Thu, 26 Jun 2014 21:26:54 +0200 + -- Matthias Klose Tue, 01 Jul 2014 11:21:36 +0200 gcc-4.8 (4.8.3-4) unstable; urgency=medium diff --git a/debian/patches/svn-updates.diff b/debian/patches/svn-updates.diff index 797f4ab..9c95d00 100644 --- a/debian/patches/svn-updates.diff +++ b/debian/patches/svn-updates.diff @@ -1,10 +1,10 @@ -# DP: updates from the 4.8 branch upto 20140626 (r212051). +# DP: updates from the 4.8 branch upto 20140701 (r212193). last_updated() { cat > ${dir}LAST_UPDATED < ++ ++ Backport from Mainline ++ 2014-06-20 Jakub Jelinek ++ 2014-06-11 Thomas Preud'homme ++ ++ PR tree-optimization/61306 ++ * tree-ssa-math-opts.c (struct symbolic_number): Store type of ++ expression instead of its size. ++ (do_shift_rotate): Adapt to change in struct symbolic_number. Return ++ false to prevent optimization when the result is unpredictable due to ++ arithmetic right shift of signed type with highest byte is set. ++ (verify_symbolic_number_p): Adapt to change in struct symbolic_number. ++ (find_bswap_1): Likewise. Return NULL to prevent optimization when the ++ result is unpredictable due to sign extension. ++ (find_bswap): Adapt to change in struct symbolic_number. ++ ++2014-06-27 Uros Bizjak ++ ++ Backport from mainline ++ 2014-06-26 Uros Bizjak ++ ++ PR target/61586 ++ * config/alpha/alpha.c (alpha_handle_trap_shadows): Handle BARRIER RTX. ++ +2014-06-26 Bill Schmidt + + PR target/61542 @@ -576,6 +601,21 @@ Index: gcc/testsuite/gcc.target/powerpc/htm-ttest.c +{ + return _HTM_STATE(__builtin_ttest()); +} +Index: gcc/testsuite/gcc.target/alpha/pr61586.c +=================================================================== +--- a/src/gcc/testsuite/gcc.target/alpha/pr61586.c (.../tags/gcc_4_8_3_release) ++++ b/src/gcc/testsuite/gcc.target/alpha/pr61586.c (.../branches/gcc-4_8-branch) +@@ -0,0 +1,10 @@ ++/* { dg-do compile } */ ++/* { dg-options "-O2 -mieee" } */ ++ ++void foo (int *dimensions, double **params, int hh) ++{ ++ if (params[hh]) ++ ; ++ else if (dimensions[hh] > 0) ++ params[hh][0] = 1.0f; ++} Index: gcc/testsuite/gcc.target/aarch64/aapcs64/va_arg-14.c =================================================================== --- a/src/gcc/testsuite/gcc.target/aarch64/aapcs64/va_arg-14.c (.../tags/gcc_4_8_3_release) @@ -1021,6 +1061,127 @@ Index: gcc/testsuite/gfortran.dg/cray_pointers_10.f90 + a = 42 + if (z /= 42) call abort +end program test +Index: gcc/testsuite/gfortran.dg/nint_2.f90 +=================================================================== +--- a/src/gcc/testsuite/gfortran.dg/nint_2.f90 (.../tags/gcc_4_8_3_release) ++++ b/src/gcc/testsuite/gfortran.dg/nint_2.f90 (.../branches/gcc-4_8-branch) +@@ -4,7 +4,8 @@ + ! http://gcc.gnu.org/ml/fortran/2005-04/msg00139.html + ! + ! { dg-do run } +-! { dg-xfail-run-if "PR 33271, math library bug" { powerpc-ibm-aix powerpc*-*-linux* *-*-mingw* } { "-O0" } { "" } } ++! { dg-xfail-run-if "PR 33271, math library bug" { powerpc-ibm-aix powerpc-*-linux* powerpc64-*-linux* *-*-mingw* } { "-O0" } { "" } } ++! Note that this doesn't fail on powerpc64le-*-linux*. + real(kind=8) :: a + integer(kind=8) :: i1, i2 + real :: b +Index: gcc/testsuite/gcc.c-torture/execute/pr61306-1.c +=================================================================== +--- a/src/gcc/testsuite/gcc.c-torture/execute/pr61306-1.c (.../tags/gcc_4_8_3_release) ++++ b/src/gcc/testsuite/gcc.c-torture/execute/pr61306-1.c (.../branches/gcc-4_8-branch) +@@ -0,0 +1,39 @@ ++#ifdef __INT32_TYPE__ ++typedef __INT32_TYPE__ int32_t; ++#else ++typedef int int32_t; ++#endif ++ ++#ifdef __UINT32_TYPE__ ++typedef __UINT32_TYPE__ uint32_t; ++#else ++typedef unsigned uint32_t; ++#endif ++ ++#define __fake_const_swab32(x) ((uint32_t)( \ ++ (((uint32_t)(x) & (uint32_t)0x000000ffUL) << 24) | \ ++ (((uint32_t)(x) & (uint32_t)0x0000ff00UL) << 8) | \ ++ (((uint32_t)(x) & (uint32_t)0x00ff0000UL) >> 8) | \ ++ (( (int32_t)(x) & (int32_t)0xff000000UL) >> 24))) ++ ++/* Previous version of bswap optimization failed to consider sign extension ++ and as a result would replace an expression *not* doing a bswap by a ++ bswap. */ ++ ++__attribute__ ((noinline, noclone)) uint32_t ++fake_bswap32 (uint32_t in) ++{ ++ return __fake_const_swab32 (in); ++} ++ ++int ++main(void) ++{ ++ if (sizeof (int32_t) * __CHAR_BIT__ != 32) ++ return 0; ++ if (sizeof (uint32_t) * __CHAR_BIT__ != 32) ++ return 0; ++ if (fake_bswap32 (0x87654321) != 0xffffff87) ++ __builtin_abort (); ++ return 0; ++} +Index: gcc/testsuite/gcc.c-torture/execute/pr61306-3.c +=================================================================== +--- a/src/gcc/testsuite/gcc.c-torture/execute/pr61306-3.c (.../tags/gcc_4_8_3_release) ++++ b/src/gcc/testsuite/gcc.c-torture/execute/pr61306-3.c (.../branches/gcc-4_8-branch) +@@ -0,0 +1,13 @@ ++short a = -1; ++int b; ++char c; ++ ++int ++main () ++{ ++ c = a; ++ b = a | c; ++ if (b != -1) ++ __builtin_abort (); ++ return 0; ++} +Index: gcc/testsuite/gcc.c-torture/execute/pr61306-2.c +=================================================================== +--- a/src/gcc/testsuite/gcc.c-torture/execute/pr61306-2.c (.../tags/gcc_4_8_3_release) ++++ b/src/gcc/testsuite/gcc.c-torture/execute/pr61306-2.c (.../branches/gcc-4_8-branch) +@@ -0,0 +1,40 @@ ++#ifdef __INT16_TYPE__ ++typedef __INT16_TYPE__ int16_t; ++#else ++typedef short int16_t; ++#endif ++ ++#ifdef __UINT32_TYPE__ ++typedef __UINT32_TYPE__ uint32_t; ++#else ++typedef unsigned uint32_t; ++#endif ++ ++#define __fake_const_swab32(x) ((uint32_t)( \ ++ (((uint32_t) (x) & (uint32_t)0x000000ffUL) << 24) | \ ++ (((uint32_t)(int16_t)(x) & (uint32_t)0x00ffff00UL) << 8) | \ ++ (((uint32_t) (x) & (uint32_t)0x00ff0000UL) >> 8) | \ ++ (((uint32_t) (x) & (uint32_t)0xff000000UL) >> 24))) ++ ++ ++/* Previous version of bswap optimization failed to consider sign extension ++ and as a result would replace an expression *not* doing a bswap by a ++ bswap. */ ++ ++__attribute__ ((noinline, noclone)) uint32_t ++fake_bswap32 (uint32_t in) ++{ ++ return __fake_const_swab32 (in); ++} ++ ++int ++main(void) ++{ ++ if (sizeof (uint32_t) * __CHAR_BIT__ != 32) ++ return 0; ++ if (sizeof (int16_t) * __CHAR_BIT__ != 16) ++ return 0; ++ if (fake_bswap32 (0x81828384) != 0xff838281) ++ __builtin_abort (); ++ return 0; ++} Index: gcc/testsuite/gnat.dg/overflow_fixed.adb =================================================================== --- a/src/gcc/testsuite/gnat.dg/overflow_fixed.adb (.../tags/gcc_4_8_3_release) @@ -1123,7 +1284,29 @@ Index: gcc/testsuite/ChangeLog =================================================================== --- a/src/gcc/testsuite/ChangeLog (.../tags/gcc_4_8_3_release) +++ b/src/gcc/testsuite/ChangeLog (.../branches/gcc-4_8-branch) -@@ -1,3 +1,95 @@ +@@ -1,3 +1,117 @@ ++2014-06-30 Thomas Preud'homme ++ ++ Backport from mainline ++ 2014-06-11 Thomas Preud'homme ++ ++ PR tree-optimization/61306 ++ * gcc.c-torture/execute/pr61306-1.c: New test. ++ * gcc.c-torture/execute/pr61306-2.c: Likewise. ++ * gcc.c-torture/execute/pr61306-3.c: Likewise. ++ ++2014-06-27 Bill Schmidt ++ ++ * gfortran.dg/nint_2.f90: Don't XFAIL for powerpc64le-*-linux*. ++ ++2014-06-27 Uros Bizjak ++ ++ Backport from mainline ++ 2014-06-26 Uros Bizjak ++ ++ PR target/61586 ++ * gcc.target/alpha/pr61586.c: New test. ++ +2014-06-25 Bill Schmidt + + * gfortran.dg/default_format_denormal_2.f90: Remove xfail for @@ -1248,6 +1431,60 @@ Index: gcc/testsuite/g++.dg/cpp0x/variadic158.C +{ + CreateMetric("abcd", "def", Base()); +} +Index: gcc/testsuite/g++.dg/cpp0x/variadic160.C +=================================================================== +--- a/src/gcc/testsuite/g++.dg/cpp0x/variadic160.C (.../tags/gcc_4_8_3_release) ++++ b/src/gcc/testsuite/g++.dg/cpp0x/variadic160.C (.../branches/gcc-4_8-branch) +@@ -0,0 +1,49 @@ ++// PR c++/61539 ++// { dg-do compile { target c++11 } } ++ ++template class A; ++template class B; ++template class C; ++template <> class C ++{ ++ virtual void xparse (int &, const B > &) const; ++}; ++template class G : C ++{ ++public: ++ G (void *) {} ++ void default_value (const T &); ++ void xparse (int &, const B > &) const; ++}; ++template ++void validate (int &, const B > &, T *, int); ++template ++void G::xparse (int &p1, const B > &p2) const ++{ ++ validate (p1, p2, (T *)0, 0); ++} ++template G *value (T *) { return new G(0); } ++namespace Eigen ++{ ++template struct D; ++template class F; ++template ++struct D > ++{ ++ typedef _Scalar Scalar; ++}; ++template class F ++{ ++public: ++ typedef typename Eigen::D::Scalar Scalar; ++ F (const Scalar &, const Scalar &, const Scalar &); ++}; ++template ++void validate (int &, const B > &, Eigen::F *); ++} ++int main (int, char *[]) ++{ ++ Eigen::F a (0, 0, 0); ++ value (&a)->default_value (Eigen::F(0, 0, 0)); ++} Index: gcc/testsuite/g++.dg/template/local-fn1.C =================================================================== --- a/src/gcc/testsuite/g++.dg/template/local-fn1.C (.../tags/gcc_4_8_3_release) @@ -1261,11 +1498,106 @@ Index: gcc/testsuite/g++.dg/template/local-fn1.C + void bug(); + } +}; +Index: gcc/testsuite/g++.dg/template/conv14.C +=================================================================== +--- a/src/gcc/testsuite/g++.dg/template/conv14.C (.../tags/gcc_4_8_3_release) ++++ b/src/gcc/testsuite/g++.dg/template/conv14.C (.../branches/gcc-4_8-branch) +@@ -0,0 +1,30 @@ ++// PR c++/61647 ++ ++class XX; ++ ++template ++struct Accessor; ++ ++template ++class Variant { ++protected: ++ KeyStore index; ++ Container state; ++public: ++ Variant(Container st, const Key& i) : index(i), state(st) {} ++ ++ template ++ operator T() const { ++ return Accessor::template get(state, index); ++ } ++}; ++ ++class AutoCleanVariant : public Variant { ++public: ++ AutoCleanVariant(XX* st, int i) : Variant(st,i) {} ++ ++ template ++ operator T() const { ++ return Variant::operator T(); ++ } ++}; +Index: gcc/testsuite/g++.dg/template/ptrmem27.C +=================================================================== +--- a/src/gcc/testsuite/g++.dg/template/ptrmem27.C (.../tags/gcc_4_8_3_release) ++++ b/src/gcc/testsuite/g++.dg/template/ptrmem27.C (.../branches/gcc-4_8-branch) +@@ -0,0 +1,22 @@ ++// PR c++/61500 ++ ++struct X { ++ int i; ++ int j; ++ ++ int foo(int X::* ptr); ++ ++ template ++ int bar(); ++}; ++ ++int X::foo(int X::* ptr) { ++ int* p = &(this->*ptr); // OK. ++ return *p; ++} ++ ++template ++int X::bar() { ++ int* p = &(this->*ptr); // gcc 4.9.0: OK in C++98 mode, fails in C++11 mode. ++ return *p; ++} +Index: gcc/cp/tree.c +=================================================================== +--- a/src/gcc/cp/tree.c (.../tags/gcc_4_8_3_release) ++++ b/src/gcc/cp/tree.c (.../branches/gcc-4_8-branch) +@@ -97,6 +97,16 @@ + case IMAGPART_EXPR: + return lvalue_kind (TREE_OPERAND (ref, 0)); + ++ case MEMBER_REF: ++ case DOTSTAR_EXPR: ++ if (TREE_CODE (ref) == MEMBER_REF) ++ op1_lvalue_kind = clk_ordinary; ++ else ++ op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 0)); ++ if (TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (ref, 1)))) ++ op1_lvalue_kind = clk_none; ++ return op1_lvalue_kind; ++ + case COMPONENT_REF: + op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 0)); + /* Look at the member designator. */ Index: gcc/cp/ChangeLog =================================================================== --- a/src/gcc/cp/ChangeLog (.../tags/gcc_4_8_3_release) +++ b/src/gcc/cp/ChangeLog (.../branches/gcc-4_8-branch) -@@ -1,3 +1,13 @@ +@@ -1,3 +1,25 @@ ++2014-06-30 Jason Merrill ++ ++ PR c++/61647 ++ * pt.c (type_dependent_expression_p): Check BASELINK_OPTYPE. ++ ++ PR c++/61539 ++ * pt.c (unify_one_argument): Type/expression mismatch just causes ++ deduction failure. ++ ++ PR c++/61500 ++ * tree.c (lvalue_kind): Handle MEMBER_REF and DOTSTAR_EXPR. ++ +2014-06-17 Jason Merrill + + PR c++/60605 @@ -1302,6 +1634,32 @@ Index: gcc/cp/pt.c { /* The template parameter pack is used in a function parameter pack. If this is the end of the parameter list, the +@@ -15502,8 +15503,9 @@ + maybe_adjust_types_for_deduction (strict, &parm, &arg, arg_expr); + } + else +- gcc_assert ((TYPE_P (parm) || TREE_CODE (parm) == TEMPLATE_DECL) +- == (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)); ++ if ((TYPE_P (parm) || TREE_CODE (parm) == TEMPLATE_DECL) ++ != (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)) ++ return unify_template_argument_mismatch (explain_p, parm, arg); + + /* For deduction from an init-list we need the actual list. */ + if (arg_expr && BRACE_ENCLOSED_INITIALIZER_P (arg_expr)) +@@ -20009,7 +20011,12 @@ + return true; + + if (BASELINK_P (expression)) +- expression = BASELINK_FUNCTIONS (expression); ++ { ++ if (BASELINK_OPTYPE (expression) ++ && dependent_type_p (BASELINK_OPTYPE (expression))) ++ return true; ++ expression = BASELINK_FUNCTIONS (expression); ++ } + + if (TREE_CODE (expression) == TEMPLATE_ID_EXPR) + { Index: gcc/double-int.c =================================================================== --- a/src/gcc/double-int.c (.../tags/gcc_4_8_3_release) @@ -1315,6 +1673,205 @@ Index: gcc/double-int.c /* quo = quo - 1; */ add_double (*lquo, *hquo, (HOST_WIDE_INT) -1, (HOST_WIDE_INT) -1, lquo, hquo); +Index: gcc/tree-ssa-math-opts.c +=================================================================== +--- a/src/gcc/tree-ssa-math-opts.c (.../tags/gcc_4_8_3_release) ++++ b/src/gcc/tree-ssa-math-opts.c (.../branches/gcc-4_8-branch) +@@ -1537,7 +1537,7 @@ + + struct symbolic_number { + unsigned HOST_WIDEST_INT n; +- int size; ++ tree type; + }; + + /* Perform a SHIFT or ROTATE operation by COUNT bits on symbolic +@@ -1549,13 +1549,15 @@ + struct symbolic_number *n, + int count) + { ++ int bitsize = TYPE_PRECISION (n->type); ++ + if (count % 8 != 0) + return false; + + /* Zero out the extra bits of N in order to avoid them being shifted + into the significant bits. */ +- if (n->size < (int)sizeof (HOST_WIDEST_INT)) +- n->n &= ((unsigned HOST_WIDEST_INT)1 << (n->size * BITS_PER_UNIT)) - 1; ++ if (bitsize < 8 * (int)sizeof (HOST_WIDEST_INT)) ++ n->n &= ((unsigned HOST_WIDEST_INT)1 << bitsize) - 1; + + switch (code) + { +@@ -1563,20 +1565,24 @@ + n->n <<= count; + break; + case RSHIFT_EXPR: ++ /* Arithmetic shift of signed type: result is dependent on the value. */ ++ if (!TYPE_UNSIGNED (n->type) ++ && (n->n & ((unsigned HOST_WIDEST_INT) 0xff << (bitsize - 8)))) ++ return false; + n->n >>= count; + break; + case LROTATE_EXPR: +- n->n = (n->n << count) | (n->n >> ((n->size * BITS_PER_UNIT) - count)); ++ n->n = (n->n << count) | (n->n >> (bitsize - count)); + break; + case RROTATE_EXPR: +- n->n = (n->n >> count) | (n->n << ((n->size * BITS_PER_UNIT) - count)); ++ n->n = (n->n >> count) | (n->n << (bitsize - count)); + break; + default: + return false; + } + /* Zero unused bits for size. */ +- if (n->size < (int)sizeof (HOST_WIDEST_INT)) +- n->n &= ((unsigned HOST_WIDEST_INT)1 << (n->size * BITS_PER_UNIT)) - 1; ++ if (bitsize < 8 * (int)sizeof (HOST_WIDEST_INT)) ++ n->n &= ((unsigned HOST_WIDEST_INT)1 << bitsize) - 1; + return true; + } + +@@ -1593,7 +1599,7 @@ + if (TREE_CODE (lhs_type) != INTEGER_TYPE) + return false; + +- if (TYPE_PRECISION (lhs_type) != n->size * BITS_PER_UNIT) ++ if (TYPE_PRECISION (lhs_type) != TYPE_PRECISION (n->type)) + return false; + + return true; +@@ -1650,20 +1656,23 @@ + to initialize the symbolic number. */ + if (!source_expr1) + { ++ int size; ++ + /* Set up the symbolic number N by setting each byte to a + value between 1 and the byte size of rhs1. The highest + order byte is set to n->size and the lowest order + byte to 1. */ +- n->size = TYPE_PRECISION (TREE_TYPE (rhs1)); +- if (n->size % BITS_PER_UNIT != 0) ++ n->type = TREE_TYPE (rhs1); ++ size = TYPE_PRECISION (n->type); ++ if (size % BITS_PER_UNIT != 0) + return NULL_TREE; +- n->size /= BITS_PER_UNIT; ++ size /= BITS_PER_UNIT; + n->n = (sizeof (HOST_WIDEST_INT) < 8 ? 0 : + (unsigned HOST_WIDEST_INT)0x08070605 << 32 | 0x04030201); + +- if (n->size < (int)sizeof (HOST_WIDEST_INT)) ++ if (size < (int)sizeof (HOST_WIDEST_INT)) + n->n &= ((unsigned HOST_WIDEST_INT)1 << +- (n->size * BITS_PER_UNIT)) - 1; ++ (size * BITS_PER_UNIT)) - 1; + + source_expr1 = rhs1; + } +@@ -1672,12 +1681,12 @@ + { + case BIT_AND_EXPR: + { +- int i; ++ int i, size = TYPE_PRECISION (n->type) / BITS_PER_UNIT; + unsigned HOST_WIDEST_INT val = widest_int_cst_value (rhs2); + unsigned HOST_WIDEST_INT tmp = val; + + /* Only constants masking full bytes are allowed. */ +- for (i = 0; i < n->size; i++, tmp >>= BITS_PER_UNIT) ++ for (i = 0; i < size; i++, tmp >>= BITS_PER_UNIT) + if ((tmp & 0xff) != 0 && (tmp & 0xff) != 0xff) + return NULL_TREE; + +@@ -1693,12 +1702,22 @@ + break; + CASE_CONVERT: + { +- int type_size; ++ int type_size, old_type_size; ++ tree type; + +- type_size = TYPE_PRECISION (gimple_expr_type (stmt)); ++ type = gimple_expr_type (stmt); ++ type_size = TYPE_PRECISION (type); + if (type_size % BITS_PER_UNIT != 0) + return NULL_TREE; + ++ /* Sign extension: result is dependent on the value. */ ++ old_type_size = TYPE_PRECISION (n->type); ++ if (!TYPE_UNSIGNED (n->type) ++ && type_size > old_type_size ++ && n->n & ++ ((unsigned HOST_WIDEST_INT) 0xff << (old_type_size - 8))) ++ return NULL_TREE; ++ + if (type_size / BITS_PER_UNIT < (int)(sizeof (HOST_WIDEST_INT))) + { + /* If STMT casts to a smaller type mask out the bits not +@@ -1705,7 +1724,7 @@ + belonging to the target type. */ + n->n &= ((unsigned HOST_WIDEST_INT)1 << type_size) - 1; + } +- n->size = type_size / BITS_PER_UNIT; ++ n->type = type; + } + break; + default: +@@ -1718,7 +1737,7 @@ + + if (rhs_class == GIMPLE_BINARY_RHS) + { +- int i; ++ int i, size; + struct symbolic_number n1, n2; + unsigned HOST_WIDEST_INT mask; + tree source_expr2; +@@ -1742,11 +1761,12 @@ + source_expr2 = find_bswap_1 (rhs2_stmt, &n2, limit - 1); + + if (source_expr1 != source_expr2 +- || n1.size != n2.size) ++ || TYPE_PRECISION (n1.type) != TYPE_PRECISION (n2.type)) + return NULL_TREE; + +- n->size = n1.size; +- for (i = 0, mask = 0xff; i < n->size; i++, mask <<= BITS_PER_UNIT) ++ n->type = n1.type; ++ size = TYPE_PRECISION (n->type) / BITS_PER_UNIT; ++ for (i = 0, mask = 0xff; i < size; i++, mask <<= BITS_PER_UNIT) + { + unsigned HOST_WIDEST_INT masked1, masked2; + +@@ -1785,7 +1805,7 @@ + + struct symbolic_number n; + tree source_expr; +- int limit; ++ int limit, bitsize; + + /* The last parameter determines the depth search limit. It usually + correlates directly to the number of bytes to be touched. We +@@ -1800,13 +1820,14 @@ + return NULL_TREE; + + /* Zero out the extra bits of N and CMP. */ +- if (n.size < (int)sizeof (HOST_WIDEST_INT)) ++ bitsize = TYPE_PRECISION (n.type); ++ if (bitsize < 8 * (int)sizeof (HOST_WIDEST_INT)) + { + unsigned HOST_WIDEST_INT mask = +- ((unsigned HOST_WIDEST_INT)1 << (n.size * BITS_PER_UNIT)) - 1; ++ ((unsigned HOST_WIDEST_INT)1 << bitsize) - 1; + + n.n &= mask; +- cmp >>= (sizeof (HOST_WIDEST_INT) - n.size) * BITS_PER_UNIT; ++ cmp >>= sizeof (HOST_WIDEST_INT) * BITS_PER_UNIT - bitsize; + } + + /* A complete byte swap should make the symbolic number to start Index: gcc/tree-ssa-ifcombine.c =================================================================== --- a/src/gcc/tree-ssa-ifcombine.c (.../tags/gcc_4_8_3_release) @@ -1586,6 +2143,30 @@ Index: gcc/common.opt floop-flatten Common Ignore Does nothing. Preserved for backward compatibility. +Index: gcc/config/alpha/alpha.c +=================================================================== +--- a/src/gcc/config/alpha/alpha.c (.../tags/gcc_4_8_3_release) ++++ b/src/gcc/config/alpha/alpha.c (.../branches/gcc-4_8-branch) +@@ -8658,6 +8658,11 @@ + } + break; + ++ case BARRIER: ++ /* __builtin_unreachable can expand to no code at all, ++ leaving (barrier) RTXes in the instruction stream. */ ++ goto close_shadow_notrapb; ++ + case JUMP_INSN: + case CALL_INSN: + case CODE_LABEL: +@@ -8673,6 +8678,7 @@ + n = emit_insn_before (gen_trapb (), i); + PUT_MODE (n, TImode); + PUT_MODE (i, TImode); ++ close_shadow_notrapb: + trap_pending = 0; + shadow.used.i = 0; + shadow.used.fp = 0; Index: gcc/config/elfos.h =================================================================== --- a/src/gcc/config/elfos.h (.../tags/gcc_4_8_3_release) -- cgit v1.2.3