Merge in trunk.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/branches/wide-int@209030 138bc75d-0d04-0410-961f-82ee72b054a4

diff --cc gcc/Makefile.in
Simple merge

diff --cc gcc/builtins.c
Simple merge

diff --cc gcc/c-family/c-common.c
Simple merge

diff --cc gcc/c-family/cilk.c
Simple merge

diff --cc gcc/c/c-decl.c
Simple merge

diff --cc gcc/c/c-parser.c
Simple merge

diff --cc gcc/c/c-typeck.c
Simple merge

diff --cc gcc/cgraph.c
Simple merge

diff --cc gcc/combine.c
Simple merge

diff --cc gcc/config/aarch64/aarch64.c
Simple merge

diff --cc gcc/config/arc/arc.c
Simple merge

diff --cc gcc/config/arm/arm.c
Simple merge

diff --cc gcc/config/avr/avr.c
Simple merge

diff --cc gcc/config/i386/i386.c
Simple merge

diff --cc gcc/config/msp430/msp430.c
Simple merge

diff --cc gcc/config/nds32/nds32.c
Simple merge

diff --cc gcc/config/rs6000/predicates.md
Simple merge

diff --cc gcc/config/rs6000/rs6000-c.c
Simple merge

diff --cc gcc/config/rs6000/rs6000.c
index 1fc8ad6,c500191..6724dcb
--- 1/gcc/config/rs6000/rs6000.c
--- 2/gcc/config/rs6000/rs6000.c
+++ b/gcc/config/rs6000/rs6000.c
@@@ -5099,8 -5110,10 +5119,8 @@@ easy_altivec_constant (rtx op, enum mac
    if (mode == V2DFmode)
      return zero_constant (op, mode);
  
-   if (mode == V2DImode)
+   else if (mode == V2DImode)
      {
 -      /* In case the compiler is built 32-bit, CONST_DOUBLE constants are not
 -       easy.  */
        if (GET_CODE (CONST_VECTOR_ELT (op, 0)) != CONST_INT
          || GET_CODE (CONST_VECTOR_ELT (op, 1)) != CONST_INT)
        return false;

diff --cc gcc/config/rs6000/rs6000.h
Simple merge

diff --cc gcc/config/rs6000/rs6000.md
Simple merge

diff --cc gcc/config/sparc/sparc.c
Simple merge

diff --cc gcc/cp/call.c
Simple merge

diff --cc gcc/cp/class.c
Simple merge

diff --cc gcc/cp/decl.c
Simple merge

diff --cc gcc/cp/init.c
Simple merge

diff --cc gcc/cp/mangle.c
Simple merge

diff --cc gcc/cp/tree.c
Simple merge

diff --cc gcc/cp/typeck2.c
Simple merge

diff --cc gcc/cse.c
Simple merge

diff --cc gcc/cselib.c
index b805884,7918b2b..c55b027
--- 1/gcc/cselib.c
--- 2/gcc/cselib.c
+++ b/gcc/cselib.c
@@@ -1117,14 -1137,9 +1136,14 @@@ cselib_hash_rtx (rtx x, int create, enu
        return hash ? hash : (unsigned int) ENTRY_VALUE;
  
      case CONST_INT:
-       hash += ((unsigned) CONST_INT << 7) + INTVAL (x);
+       hash += ((unsigned) CONST_INT << 7) + UINTVAL (x);
        return hash ? hash : (unsigned int) CONST_INT;
  
 +    case CONST_WIDE_INT:
 +      for (i = 0; i < CONST_WIDE_INT_NUNITS (x); i++)
 +      hash += CONST_WIDE_INT_ELT (x, i);
 +      return hash;
 +
      case CONST_DOUBLE:
        /* This is like the general case, except that it only counts
         the integers representing the constant.  */

diff --cc gcc/doc/generic.texi
Simple merge

diff --cc gcc/doc/tm.texi
Simple merge

diff --cc gcc/doc/tm.texi.in
Simple merge

diff --cc gcc/dojump.c
Simple merge

diff --cc gcc/dwarf2out.c
Simple merge

diff --cc gcc/emit-rtl.c
index acfd3e9,4736f8d..f98d494
--- 1/gcc/emit-rtl.c
--- 2/gcc/emit-rtl.c
+++ b/gcc/emit-rtl.c
@@@ -126,13 -126,6 +126,9 @@@ rtx cc0_rtx
  static GTY ((if_marked ("ggc_marked_p"), param_is (struct rtx_def)))
       htab_t const_int_htab;
  
- /* A hash table storing memory attribute structures.  */
- static GTY ((if_marked ("ggc_marked_p"), param_is (struct mem_attrs)))
-      htab_t mem_attrs_htab;
- 
 +static GTY ((if_marked ("ggc_marked_p"), param_is (struct rtx_def)))
 +     htab_t const_wide_int_htab;
 +
  /* A hash table storing register attribute structures.  */
  static GTY ((if_marked ("ggc_marked_p"), param_is (struct reg_attrs)))
       htab_t reg_attrs_htab;

diff --cc gcc/expr.c
Simple merge

diff --cc gcc/final.c
Simple merge

diff --cc gcc/fortran/trans-array.c
Simple merge

diff --cc gcc/fortran/trans-decl.c
Simple merge

diff --cc gcc/fortran/trans-expr.c
Simple merge

diff --cc gcc/fortran/trans-intrinsic.c
Simple merge

diff --cc gcc/fortran/trans-types.c
Simple merge

diff --cc gcc/gimple-fold.c
Simple merge

diff --cc gcc/gimple-pretty-print.c
Simple merge

diff --cc gcc/go/go-gcc.cc
Simple merge

diff --cc gcc/graphite-clast-to-gimple.c
Simple merge

diff --cc gcc/internal-fn.c
index 1aef48c,1062ea8..c2845f0
--- 1/gcc/internal-fn.c
--- 2/gcc/internal-fn.c
+++ b/gcc/internal-fn.c
@@@ -235,14 -237,14 +237,14 @@@ ubsan_expand_si_overflow_addsub_check (
        }
        else if (CONST_INT_P (op1))
        ;
-       else if (TREE_CODE (arg0) == SSA_NAME)
+       else if (code == PLUS_EXPR && TREE_CODE (arg0) == SSA_NAME)
        {
 -        double_int arg0_min, arg0_max;
 +        wide_int arg0_min, arg0_max;
          if (get_range_info (arg0, &arg0_min, &arg0_max) == VR_RANGE)
            {
 -            if (!arg0_min.is_negative ())
 +            if (!wi::neg_p (arg0_min, TYPE_SIGN (TREE_TYPE (arg0))))
                pos_neg = 1;
 -            else if (arg0_max.is_negative ())
 +            else if (wi::neg_p (arg0_max, TYPE_SIGN (TREE_TYPE (arg0))))
                pos_neg = 2;
            }
          if (pos_neg != 3)

diff --cc gcc/ipa-devirt.c
Simple merge

diff --cc gcc/ipa-prop.c
Simple merge

diff --cc gcc/lto-streamer-in.c
Simple merge

diff --cc gcc/lto-streamer-out.c
Simple merge

diff --cc gcc/lto/lto-lang.c
Simple merge

diff --cc gcc/lto/lto.c
Simple merge

diff --cc gcc/omp-low.c
Simple merge

diff --cc gcc/optabs.c
Simple merge

diff --cc gcc/predict.c
Simple merge

diff --cc gcc/print-rtl.c
Simple merge

diff --cc gcc/real.c
index 9ed08b0,5cf2525..f8e8d7f
--- 1/gcc/real.c
--- 2/gcc/real.c
+++ b/gcc/real.c
@@@ -1412,45 -1415,35 +1412,47 @@@ real_to_integer (const REAL_VALUE_TYPE 
         undefined, so it doesn't matter what we return, and some callers
         expect to be able to use this routine for both signed and
         unsigned conversions.  */
 -      if (exp > HOST_BITS_PER_DOUBLE_INT)
 +      if (exp > precision)
        goto overflow;
  
 -      rshift_significand (&t, r, HOST_BITS_PER_DOUBLE_INT - exp);
 -      if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
 +      words = (precision + HOST_BITS_PER_WIDE_INT - 1) / HOST_BITS_PER_WIDE_INT;
 +
 +      for (unsigned int i = 0; i < ARRAY_SIZE (val); i++)
 +      val[i] = 0;
 +
 +#if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
 +      for (int i = 0; i < words; i++)
        {
 -        high = t.sig[SIGSZ-1];
 -        low = t.sig[SIGSZ-2];
 +        int j = SIGSZ - words + i;
 +        val[i] = (j < 0) ? 0 : r->sig[j];
        }
 -      else
 +#else
 +      gcc_assert (HOST_BITS_PER_WIDE_INT == 2*HOST_BITS_PER_LONG);
 +      for (int i = 0; i < words; i++)
        {
 -        gcc_assert (HOST_BITS_PER_WIDE_INT == 2*HOST_BITS_PER_LONG);
 -        high = t.sig[SIGSZ-1];
 -        high = high << (HOST_BITS_PER_LONG - 1) << 1;
 -        high |= t.sig[SIGSZ-2];
 -
 -        low = t.sig[SIGSZ-3];
 -        low = low << (HOST_BITS_PER_LONG - 1) << 1;
 -        low |= t.sig[SIGSZ-4];
 +        int j = SIGSZ - (words * 2) + (i + 2) + 1;
 +        if (j < 0)
 +          val[i] = 0;
 +        else
 +          {
 +            val[i] = r->sig[j];
-             val[i] <<= HOST_BITS_PER_LONG;
++            unsigned HOST_WIDE_INT v = val[i];
++            v <<= HOST_BITS_PER_LONG;
++            val[i] = v;
 +            val[i] |= r->sig[j - 1];
 +          }
        }
 +#endif
 +      w = SIGSZ * HOST_BITS_PER_LONG + words * HOST_BITS_PER_WIDE_INT;
 +      tmp = real_int::from_array
 +      (val, (w + HOST_BITS_PER_WIDE_INT - 1) / HOST_BITS_PER_WIDE_INT, w);
 +      tmp = wi::lrshift (tmp, (words * HOST_BITS_PER_WIDE_INT) - exp);
 +      result = wide_int::from (tmp, precision, UNSIGNED);
  
        if (r->sign)
 -      {
 -        if (low == 0)
 -          high = -high;
 -        else
 -          low = -low, high = ~high;
 -      }
 -      break;
 +      return -result;
 +      else
 +      return result;
  
      default:
        gcc_unreachable ();

diff --cc gcc/recog.c
Simple merge

diff --cc gcc/rtlanal.c
Simple merge

diff --cc gcc/targhooks.c
Simple merge

diff --cc gcc/tree-cfg.c
Simple merge

diff --cc gcc/tree-core.h
Simple merge

diff --cc gcc/tree-dfa.c
index cdbbc46,fcf8d80..068984f
--- 1/gcc/tree-dfa.c
--- 2/gcc/tree-dfa.c
+++ b/gcc/tree-dfa.c
@@@ -389,11 -389,10 +389,10 @@@ get_ref_base_and_extent (tree exp, HOST
                         HOST_WIDE_INT *psize,
                         HOST_WIDE_INT *pmax_size)
  {
-   HOST_WIDE_INT bitsize = -1;
-   HOST_WIDE_INT maxsize = -1;
 -  double_int bitsize = double_int_minus_one;
 -  double_int maxsize;
++  offset_int bitsize = -1;
++  offset_int maxsize;
    tree size_tree = NULL_TREE;
 -  double_int bit_offset = double_int_zero;
 +  offset_int bit_offset = 0;
-   HOST_WIDE_INT hbit_offset;
    bool seen_variable_array_ref = false;
  
    /* First get the final access size from just the outermost expression.  */
@@@ -407,15 -406,11 +406,11 @@@
        if (mode == BLKmode)
        size_tree = TYPE_SIZE (TREE_TYPE (exp));
        else
-       bitsize = GET_MODE_BITSIZE (mode);
-     }
-   if (size_tree != NULL_TREE)
-     {
-       if (! tree_fits_uhwi_p (size_tree))
-       bitsize = -1;
-       else
-       bitsize = tree_to_uhwi (size_tree);
 -      bitsize = double_int::from_uhwi (GET_MODE_BITSIZE (mode));
++      bitsize = wi::to_offset (GET_MODE_BITSIZE (mode));
      }
 -    bitsize = tree_to_double_int (size_tree);
+   if (size_tree != NULL_TREE
+       && TREE_CODE (size_tree) == INTEGER_CST)
++    bitsize = wi::to_offset (size_tree);
  
    /* Initially, maxsize is the same as the accessed element size.
       In the following it will only grow (or become -1).  */
@@@ -458,15 -454,22 +453,22 @@@
                      {
                        tree fsize = DECL_SIZE_UNIT (field);
                        tree ssize = TYPE_SIZE_UNIT (stype);
-                       if (tree_fits_shwi_p (fsize)
-                           && tree_fits_shwi_p (ssize)
-                           && wi::fits_shwi_p (woffset))
-                         maxsize += ((tree_to_shwi (ssize)
-                                      - tree_to_shwi (fsize))
-                                     * BITS_PER_UNIT
-                                       - woffset.to_shwi ());
-                       else
+                       if (fsize == NULL
+                           || TREE_CODE (fsize) != INTEGER_CST
+                           || ssize == NULL
+                           || TREE_CODE (ssize) != INTEGER_CST)
 -                        maxsize = double_int_minus_one;
 +                        maxsize = -1;
+                       else
+                         {
 -                          double_int tem = tree_to_double_int (ssize)
 -                                           - tree_to_double_int (fsize);
++                          offset_int tem = (wi::to_offset (ssize)
++                                            - wi::to_offset (fsize);
+                           if (BITS_PER_UNIT == 8)
 -                            tem = tem.lshift (3);
++                            tem = wi::lshift (tem, 3);
+                           else
 -                            tem *= double_int::from_uhwi (BITS_PER_UNIT);
 -                          tem -= doffset;
++                            tem *= wi::to_offset (BITS_PER_UNIT);
++                          tem -= woffset;
+                           maxsize += tem;
+                         }
                      }
                  }
              }
@@@ -476,13 -479,12 +478,12 @@@
                /* 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.is_minus_one ()
 +              if (maxsize != -1
                    && csize
-                   && tree_fits_uhwi_p (csize)
-                   && wi::fits_shwi_p (bit_offset))
-                 maxsize = tree_to_uhwi (csize) - bit_offset.to_shwi ();
+                   && TREE_CODE (csize) == INTEGER_CST)
 -                maxsize = tree_to_double_int (csize) - bit_offset;
++                maxsize = wi::to_offset (csize) - bit_offset;
                else
 -                maxsize = double_int_minus_one;
 +                maxsize = -1;
              }
          }
          break;
@@@ -518,13 -521,12 +519,12 @@@
                /* 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.is_minus_one ()
 +              if (maxsize != -1
                    && asize
-                   && tree_fits_uhwi_p (asize)
-                   && wi::fits_shwi_p (bit_offset))
-                 maxsize = tree_to_uhwi (asize) - bit_offset.to_shwi ();
+                   && TREE_CODE (asize) == INTEGER_CST)
 -                maxsize = tree_to_double_int (asize) - bit_offset;
++                maxsize = wi::to_offset (asize) - bit_offset;
                else
 -                maxsize = double_int_minus_one;
 +                maxsize = -1;
  
                /* Remember that we have seen an array ref with a variable
                   index.  */
@@@ -567,13 -569,12 +567,12 @@@
             base type boundary.  This needs to include possible trailing
             padding that is there for alignment purposes.  */
          if (seen_variable_array_ref
 -            && !maxsize.is_minus_one ()
 +            && maxsize != -1
-             && (!wi::fits_shwi_p (bit_offset)
-                 || !tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (exp)))
-                 || (bit_offset.to_shwi () + maxsize
-                     == (HOST_WIDE_INT) tree_to_uhwi
-                           (TYPE_SIZE (TREE_TYPE (exp))))))
+             && (TYPE_SIZE (TREE_TYPE (exp)) == NULL_TREE
+                 || TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) != INTEGER_CST
+                 || (bit_offset + maxsize
 -                    == tree_to_double_int (TYPE_SIZE (TREE_TYPE (exp))))))
 -          maxsize = double_int_minus_one;
++                    == wi::to_offset (TYPE_SIZE (TREE_TYPE (exp))))))
 +          maxsize = -1;
  
          /* Hand back the decl for MEM[&decl, off].  */
          if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR)
@@@ -604,25 -605,32 +603,32 @@@
  
    /* We need to deal with variable arrays ending structures.  */
    if (seen_variable_array_ref
 -      && !maxsize.is_minus_one ()
 +      && maxsize != -1
-       && (!wi::fits_shwi_p (bit_offset)
-         || !tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (exp)))
-         || (bit_offset.to_shwi () + maxsize
-             == (HOST_WIDE_INT) tree_to_uhwi
-                  (TYPE_SIZE (TREE_TYPE (exp))))))
+       && (TYPE_SIZE (TREE_TYPE (exp)) == NULL_TREE
+         || TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) != INTEGER_CST
+         || (bit_offset + maxsize
 -            == tree_to_double_int (TYPE_SIZE (TREE_TYPE (exp))))))
 -    maxsize = double_int_minus_one;
++            == wi::to_offset (TYPE_SIZE (TREE_TYPE (exp))))))
 +    maxsize = -1;
  
   done:
-   if (!wi::fits_shwi_p (bit_offset))
 -  if (!bitsize.fits_shwi () || bitsize.is_negative ())
++  if (!wi::fits_shwi_p (bitsize) || wi::neg_p (bitsize))
      {
        *poffset = 0;
-       *psize = bitsize;
+       *psize = -1;
        *pmax_size = -1;
  
        return exp;
      }
  
-   hbit_offset = bit_offset.to_shwi ();
+   *psize = bitsize.to_shwi ();
+ 
 -  if (!bit_offset.fits_shwi ())
++  if (!wi::fits_shwi_p (bit_offset))
+     {
+       *poffset = 0;
+       *pmax_size = -1;
+ 
+       return exp;
+     }
  
    /* In case of a decl or constant base object we can do better.  */
  
@@@ -630,25 -638,30 +636,30 @@@
      {
        /* If maxsize is unknown adjust it according to the size of the
           base decl.  */
 -      if (maxsize.is_minus_one ()
 +      if (maxsize == -1
-         && tree_fits_uhwi_p (DECL_SIZE (exp)))
-       maxsize = tree_to_uhwi (DECL_SIZE (exp)) - hbit_offset;
+         && DECL_SIZE (exp)
+         && TREE_CODE (DECL_SIZE (exp)) == INTEGER_CST)
 -      maxsize = tree_to_double_int (DECL_SIZE (exp)) - bit_offset;
++      maxsize = wi::to_offset (DECL_SIZE (exp)) - bit_offset;
      }
    else if (CONSTANT_CLASS_P (exp))
      {
        /* If maxsize is unknown adjust it according to the size of the
           base type constant.  */
 -      if (maxsize.is_minus_one ()
 +      if (maxsize == -1
-         && tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (exp))))
-       maxsize = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (exp))) - hbit_offset;
+         && TYPE_SIZE (TREE_TYPE (exp))
+         && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) == INTEGER_CST)
 -      maxsize = tree_to_double_int (TYPE_SIZE (TREE_TYPE (exp)))
 -                - bit_offset;
++      maxsize = (wi::to_offset (TYPE_SIZE (TREE_TYPE (exp)))
++                 - bit_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;
+   *poffset = bit_offset.to_shwi ();
 -  if (!maxsize.fits_shwi () || maxsize.is_negative ())
++  if (!wi::fits_shwi (maxsize) || wi::neg_p (maxsize))
+     *pmax_size = -1;
+   else
+     *pmax_size = maxsize.to_shwi ();
  
    return exp;
  }

diff --cc gcc/tree-eh.c
Simple merge

diff --cc gcc/tree-inline.c
Simple merge

diff --cc gcc/tree-pretty-print.c
Simple merge

diff --cc gcc/tree-ssa-math-opts.c
Simple merge

diff --cc gcc/tree-ssa-reassoc.c
Simple merge

diff --cc gcc/tree-ssa-structalias.c
Simple merge

diff --cc gcc/tree-ssa-uninit.c
Simple merge

diff --cc gcc/tree-ssa.c
Simple merge

diff --cc gcc/tree-streamer-in.c
Simple merge

diff --cc gcc/tree-streamer-out.c
Simple merge

diff --cc gcc/tree-vect-data-refs.c
Simple merge

diff --cc gcc/tree-vect-loop.c
Simple merge

diff --cc gcc/tree-vect-stmts.c
Simple merge

diff --cc gcc/tree-vrp.c
Simple merge

diff --cc gcc/tree.c
Simple merge

diff --cc gcc/tree.h
Simple merge

diff --cc gcc/var-tracking.c
Simple merge