Merge in trunk.

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

diff --cc gcc/Makefile.in
Simple merge

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

diff --cc gcc/ada/gcc-interface/utils.c
Simple merge

diff --cc gcc/builtins.c
Simple merge

diff --cc gcc/c-family/c-ada-spec.c
Simple merge

diff --cc gcc/c-family/c-common.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/config/aarch64/aarch64.c
Simple merge

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

diff --cc gcc/config/i386/i386.c
index d10fe95,1b7bb3e..8d83547
--- 1/gcc/config/i386/i386.c
--- 2/gcc/config/i386/i386.c
+++ b/gcc/config/i386/i386.c
@@@ -26480,10 -26567,17 +26568,15 @@@ ix86_data_alignment (tree type, int ali
    if (opt
        && AGGREGATE_TYPE_P (type)
        && TYPE_SIZE (type)
-       && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
-       && wi::geu_p (TYPE_SIZE (type), max_align)
-       && align < max_align)
-     align = max_align;
+       && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
+     {
 -      if ((TREE_INT_CST_LOW (TYPE_SIZE (type)) >= (unsigned) max_align_compat
 -         || TREE_INT_CST_HIGH (TYPE_SIZE (type)))
++      if (wi::geu_p (TYPE_SIZE (type), max_align_compat)
+         && align < max_align_compat)
+       align = max_align_compat;
 -      if ((TREE_INT_CST_LOW (TYPE_SIZE (type)) >= (unsigned) max_align
 -         || TREE_INT_CST_HIGH (TYPE_SIZE (type)))
 -        && align < max_align)
 -      align = max_align;
++       if (wi::geu_p (TYPE_SIZE (type), max_align)
++         && align < max_align)
++       align = max_align;
+     }
  
    /* x86-64 ABI requires arrays greater than 16 bytes to be aligned
       to 16byte boundary.  */

diff --cc gcc/config/msp430/msp430.c
index 4f24644,97fa3f5..7567385
--- 1/gcc/config/msp430/msp430.c
--- 2/gcc/config/msp430/msp430.c
+++ b/gcc/config/msp430/msp430.c
@@@ -1093,7 -1104,7 +1104,7 @@@ msp430_attr (tree * node
          break;
  
        case INTEGER_CST:
-         if (wi::gtu_p (value, 31))
 -        if (TREE_INT_CST_LOW (value) > 63)
++        if (wi::gtu_p (value, 63))
            /* Allow the attribute to be added - the linker script
               being used may still recognise this value.  */
            warning (OPT_Wattributes,

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
Simple merge

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

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

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

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

diff --cc gcc/cp/cvt.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/dwarf2out.c
Simple merge

diff --cc gcc/expmed.c
Simple merge

diff --cc gcc/expr.c
Simple merge

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

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

diff --cc gcc/gimple-fold.c
index e3c1a56,fd25939..f9eef64
--- 1/gcc/gimple-fold.c
--- 2/gcc/gimple-fold.c
+++ b/gcc/gimple-fold.c
@@@ -2938,7 -2881,8 +2880,8 @@@ fold_array_ctor_reference (tree type, t
       be larger than size of array element.  */
    if (!TYPE_SIZE_UNIT (type)
        || TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST
-       || wi::lts_p (elt_size, wi::to_offset (TYPE_SIZE_UNIT (type))))
 -      || elt_size.slt (tree_to_double_int (TYPE_SIZE_UNIT (type)))
 -      || elt_size.is_zero ())
++      || wi::lts_p (elt_size, wi::to_offset (TYPE_SIZE_UNIT (type)))
++      || elt_size == 0)
      return NULL_TREE;
  
    /* Compute the array index we look for.  */

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

diff --cc gcc/internal-fn.c
Simple merge

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

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

diff --cc gcc/loop-iv.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/print-rtl.c
Simple merge

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

diff --cc gcc/recog.c
Simple merge

diff --cc gcc/rtl.h
Simple merge

diff --cc gcc/rtlanal.c
Simple merge

diff --cc gcc/sel-sched-ir.c
Simple merge

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

diff --cc gcc/tree-data-ref.c
Simple merge

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

diff --cc gcc/tree-scalar-evolution.c
Simple merge

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

diff --cc gcc/tree-ssa-ccp.c
index 69ed73f,eeefeaf..e525668
--- 1/gcc/tree-ssa-ccp.c
--- 2/gcc/tree-ssa-ccp.c
+++ b/gcc/tree-ssa-ccp.c
@@@ -1518,41 -1481,86 +1523,86 @@@ bit_value_binop (enum tree_code code, t
    return val;
  }
  
- /* Return the propagation value when applying __builtin_assume_aligned to
-    its arguments.  */
+ /* Return the propagation value for __builtin_assume_aligned
+    and functions with assume_aligned or alloc_aligned attribute.
+    For __builtin_assume_aligned, ATTR is NULL_TREE,
+    for assume_aligned attribute ATTR is non-NULL and ALLOC_ALIGNED
+    is false, for alloc_aligned attribute ATTR is non-NULL and
+    ALLOC_ALIGNED is true.  */
  
  static prop_value_t
- bit_value_assume_aligned (gimple stmt)
+ bit_value_assume_aligned (gimple stmt, tree attr, prop_value_t ptrval,
+                         bool alloc_aligned)
  {
-   tree ptr = gimple_call_arg (stmt, 0), align, misalign = NULL_TREE;
-   tree type = TREE_TYPE (ptr);
+   tree align, misalign = NULL_TREE, type;
    unsigned HOST_WIDE_INT aligni, misaligni = 0;
-   prop_value_t ptrval = get_value_for_expr (ptr, true);
    prop_value_t alignval;
 -  double_int value, mask;
 +  widest_int value, mask;
    prop_value_t val;
  
+   if (attr == NULL_TREE)
+     {
+       tree ptr = gimple_call_arg (stmt, 0);
+       type = TREE_TYPE (ptr);
+       ptrval = get_value_for_expr (ptr, true);
+     }
+   else
+     {
+       tree lhs = gimple_call_lhs (stmt);
+       type = TREE_TYPE (lhs);
+     }
+ 
    if (ptrval.lattice_val == UNDEFINED)
      return ptrval;
    gcc_assert ((ptrval.lattice_val == CONSTANT
               && TREE_CODE (ptrval.value) == INTEGER_CST)
 -            || ptrval.mask.is_minus_one ());
 +            || ptrval.mask == -1);
-   align = gimple_call_arg (stmt, 1);
-   if (!tree_fits_uhwi_p (align))
-     return ptrval;
-   aligni = tree_to_uhwi (align);
-   if (aligni <= 1
-       || (aligni & (aligni - 1)) != 0)
-     return ptrval;
-   if (gimple_call_num_args (stmt) > 2)
+   if (attr == NULL_TREE)
+     {
+       /* Get aligni and misaligni from __builtin_assume_aligned.  */
+       align = gimple_call_arg (stmt, 1);
+       if (!tree_fits_uhwi_p (align))
+       return ptrval;
+       aligni = tree_to_uhwi (align);
+       if (gimple_call_num_args (stmt) > 2)
+       {
+         misalign = gimple_call_arg (stmt, 2);
+         if (!tree_fits_uhwi_p (misalign))
+           return ptrval;
+         misaligni = tree_to_uhwi (misalign);
+       }
+     }
+   else
      {
-       misalign = gimple_call_arg (stmt, 2);
-       if (!tree_fits_uhwi_p (misalign))
+       /* Get aligni and misaligni from assume_aligned or
+        alloc_align attributes.  */
+       if (TREE_VALUE (attr) == NULL_TREE)
        return ptrval;
-       misaligni = tree_to_uhwi (misalign);
-       if (misaligni >= aligni)
+       attr = TREE_VALUE (attr);
+       align = TREE_VALUE (attr);
+       if (!tree_fits_uhwi_p (align))
        return ptrval;
+       aligni = tree_to_uhwi (align);
+       if (alloc_aligned)
+       {
+         if (aligni == 0 || aligni > gimple_call_num_args (stmt))
+           return ptrval;
+         align = gimple_call_arg (stmt, aligni - 1);
+         if (!tree_fits_uhwi_p (align))
+           return ptrval;
+         aligni = tree_to_uhwi (align);
+       }
+       else if (TREE_CHAIN (attr) && TREE_VALUE (TREE_CHAIN (attr)))
+       {
+         misalign = TREE_VALUE (TREE_CHAIN (attr));
+         if (!tree_fits_uhwi_p (misalign))
+           return ptrval;
+         misaligni = tree_to_uhwi (misalign);
+       }
      }
+   if (aligni <= 1 || (aligni & (aligni - 1)) != 0 || misaligni >= aligni)
+     return ptrval;
+ 
    align = build_int_cst_type (type, -aligni);
    alignval = get_value_for_expr (align, true);
    bit_value_binop_1 (BIT_AND_EXPR, type, &value, &mask,

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

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

diff --cc gcc/tree-ssa-sccvn.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-vect-data-refs.c
index 17c4279,e973b34..8cb11c6
--- 1/gcc/tree-vect-data-refs.c
--- 2/gcc/tree-vect-data-refs.c
+++ b/gcc/tree-vect-data-refs.c
@@@ -2870,14 -2891,34 +2891,32 @@@ vect_prune_runtime_alias_test_list (loo
  
             */
  
 -        HOST_WIDE_INT
 -        min_seg_len_b = (TREE_CODE (dr_b1->seg_len) == INTEGER_CST) ?
 -                           TREE_INT_CST_LOW (dr_b1->seg_len) :
 -                           vect_factor;
 +        HOST_WIDE_INT  min_seg_len_b = (tree_fits_shwi_p (dr_b1->seg_len)
 +                                        ? tree_to_shwi (dr_b1->seg_len)
 +                                        : vect_factor);
  
          if (diff <= min_seg_len_b
 -            || (TREE_CODE (dr_a1->seg_len) == INTEGER_CST
 -                && diff - (HOST_WIDE_INT) TREE_INT_CST_LOW (dr_a1->seg_len) <
 -                   min_seg_len_b))
 +            || (tree_fits_shwi_p (dr_a1->seg_len)
 +                && diff - tree_to_shwi (dr_a1->seg_len) < min_seg_len_b))
            {
+             if (dump_enabled_p ())
+               {
+                 dump_printf_loc (MSG_NOTE, vect_location,
+                                  "merging ranges for ");
+                 dump_generic_expr (MSG_NOTE, TDF_SLIM,
+                                    DR_REF (dr_a1->dr));
+                 dump_printf (MSG_NOTE,  ", ");
+                 dump_generic_expr (MSG_NOTE, TDF_SLIM,
+                                    DR_REF (dr_b1->dr));
+                 dump_printf (MSG_NOTE,  " and ");
+                 dump_generic_expr (MSG_NOTE, TDF_SLIM,
+                                    DR_REF (dr_a2->dr));
+                 dump_printf (MSG_NOTE,  ", ");
+                 dump_generic_expr (MSG_NOTE, TDF_SLIM,
+                                    DR_REF (dr_b2->dr));
+                 dump_printf (MSG_NOTE, "\n");
+               }
+ 
              dr_a1->seg_len = size_binop (PLUS_EXPR,
                                           dr_a2->seg_len, size_int (diff));
              comp_alias_ddrs.ordered_remove (i--);

diff --cc gcc/tree-vect-loop-manip.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

diff --cc gcc/varasm.c
Simple merge