[gcc-6] 147/401: * Update to SVN 20160519 (r236478, 6.1.1) from the gcc-6-branch.

Ximin Luo infinity0 at debian.org
Wed Apr 5 15:48:34 UTC 2017


This is an automated email from the git hooks/post-receive script.

infinity0 pushed a commit to branch pu/reproducible_builds
in repository gcc-6.

commit 81400347393a60d4d2ec1cf154e5c7e9678ed883
Author: doko <doko at 6ca36cf4-e1d1-0310-8c6f-e303bb2178ca>
Date:   Thu May 19 16:41:25 2016 +0000

      * Update to SVN 20160519 (r236478, 6.1.1) from the gcc-6-branch.
    
    
    git-svn-id: svn://anonscm.debian.org/gcccvs/branches/sid/gcc-6@8851 6ca36cf4-e1d1-0310-8c6f-e303bb2178ca
---
 debian/changelog                |   6 +-
 debian/patches/svn-updates.diff | 517 +++++++++++++++++++++++++++++++++++++++-
 2 files changed, 514 insertions(+), 9 deletions(-)

diff --git a/debian/changelog b/debian/changelog
index 962cec8..409c7e4 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,16 +1,16 @@
 gcc-6 (6.1.1-4) unstable; urgency=medium
 
-  * Update to SVN 20160519 (r236452, 6.1.1) from the gcc-6-branch.
+  * Update to SVN 20160519 (r236478, 6.1.1) from the gcc-6-branch.
     - Fix PR sanitizer/71160, PR c++/70498, PR target/71161 (x86),
       PR fortran/70856, PR c++/71100, PR target/71145 (alpha), PR c++/70466,
       PR target/70860 (nvptx), PR target/70809 (AArch64), PR hsa/70857,
       PR driver/68463, PR target/70947 (PPC), PR ipa/70760, PR middle-end/70931,
       PR middle-end/70941, PR tree-optimization/71006, PR target/70830 (ARM),
-      PR fortran/69603, PR fortran/71047, PR fortran/56226.
+      PR fortran/69603, PR fortran/71047, PR fortran/56226, PR ipa/70646.
   * libgnat{prj,svn}-dev: Don't recommend gnat when building cross compiler
     packages.
 
- -- Matthias Klose <doko at debian.org>  Thu, 19 May 2016 15:50:56 +0200
+ -- Matthias Klose <doko at debian.org>  Thu, 19 May 2016 18:40:49 +0200
 
 gcc-6 (6.1.1-3) unstable; urgency=medium
 
diff --git a/debian/patches/svn-updates.diff b/debian/patches/svn-updates.diff
index dc4fb66..db660d2 100644
--- a/debian/patches/svn-updates.diff
+++ b/debian/patches/svn-updates.diff
@@ -1,10 +1,10 @@
-# DP: updates from the 6 branch upto 20160519 (r236452).
+# DP: updates from the 6 branch upto 20160519 (r236478).
 
 last_update()
 {
 	cat > ${dir}LAST_UPDATED <EOF
-Thu May 19 13:28:08 CEST 2016
-Thu May 19 11:28:08 UTC 2016 (revision 236452)
+Thu May 19 18:34:13 CEST 2016
+Thu May 19 16:34:13 UTC 2016 (revision 236478)
 EOF
 }
 
@@ -1445,7 +1445,34 @@ Index: gcc/ChangeLog
 ===================================================================
 --- a/src/gcc/ChangeLog	(.../tags/gcc_6_1_0_release)
 +++ b/src/gcc/ChangeLog	(.../branches/gcc-6-branch)
-@@ -1,3 +1,315 @@
+@@ -1,3 +1,342 @@
++2016-05-19  Martin Jambor  <mjambor at suse.cz>
++
++	PR ipa/70646
++	* ipa-prop.c (determine_locally_known_aggregate_parts): Bail out early
++	if parameter PARAM_IPA_MAX_AGG_ITEMS is zero.
++
++2016-05-19  Martin Jambor  <mjambor at suse.cz>
++
++	PR ipa/70646
++	* ipa-inline.h (condition): New field size.
++	* ipa-inline-analysis.c (add_condition): New parameter SIZE, use it
++	for comaprison and store it into the new condition.
++	(evaluate_conditions_for_known_args): Use condition size to check
++	access sizes for all but CHANGED conditions.
++	(unmodified_parm_1): New parameter size_p, store access size into it.
++	(unmodified_parm): Likewise.
++	(unmodified_parm_or_parm_agg_item): Likewise.
++	(eliminated_by_inlining_prob): Pass NULL to unmodified_parm as size_p.
++	(set_cond_stmt_execution_predicate): Extract access sizes and store
++	them to conditions.
++	(set_switch_stmt_execution_predicate): Likewise.
++	(will_be_nonconstant_expr_predicate): Likewise.
++	(will_be_nonconstant_predicate): Likewise.
++	(inline_read_section): Stream condition size.
++	(inline_write_summary): Likewise.
++	* lto-streamer.h (LTO_minor_version): Bump.
++
 +2016-05-18  Martin Liska  <mliska at suse.cz>
 +
 +	Backport from mainline
@@ -1761,7 +1788,7 @@ Index: gcc/ChangeLog
  2016-04-27  Release Manager
  
  	* GCC 6.1.0 released.
-@@ -49,7 +361,7 @@
+@@ -49,7 +388,7 @@
  	constant boolean.
  
  2016-04-20  Andrew Pinski  <apinski at cavium.com>
@@ -3501,6 +3528,51 @@ Index: gcc/testsuite/gcc.dg/torture/pr70941.c
 +    __builtin_abort ();
 +  return 0;
 +}
+Index: gcc/testsuite/gcc.dg/ipa/pr70646.c
+===================================================================
+--- a/src/gcc/testsuite/gcc.dg/ipa/pr70646.c	(.../tags/gcc_6_1_0_release)
++++ b/src/gcc/testsuite/gcc.dg/ipa/pr70646.c	(.../branches/gcc-6-branch)
+@@ -0,0 +1,40 @@
++/* { dg-do run } */
++/* { dg-options "-O2" } */
++
++#pragma GCC optimize("no-unit-at-a-time")
++
++typedef unsigned char u8;
++typedef unsigned long long u64;
++
++static inline __attribute__((always_inline)) u64 __swab64p(const u64 *p)
++{
++ return (__builtin_constant_p((u64)(*p)) ? ((u64)( (((u64)(*p) & (u64)0x00000000000000ffULL) << 56) | (((u64)(*p) & (u64)0x000000000000ff00ULL) << 40) | (((u64)(*p) & (u64)0x0000000000ff0000ULL) << 24) | (((u64)(*p) & (u64)0x00000000ff000000ULL) << 8) | (((u64)(*p) & (u64)0x000000ff00000000ULL) >> 8) | (((u64)(*p) & (u64)0x0000ff0000000000ULL) >> 24) | (((u64)(*p) & (u64)0x00ff000000000000ULL) >> 40) | (((u64)(*p) & (u64)0xff00000000000000ULL) >> 56))) : __builtin_bswap64(*p));
++}
++
++static inline u64 wwn_to_u64(void *wwn)
++{
++ return __swab64p(wwn);
++}
++
++void __attribute__((noinline,noclone)) broken(u64* shost)
++{
++ u8 node_name[8] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
++ *shost = wwn_to_u64(node_name);
++}
++
++void __attribute__((noinline,noclone)) dummy(void)
++{
++ __builtin_abort();
++}
++
++int main(int argc, char* argv[])
++{
++ u64 v;
++
++ broken(&v);
++
++ if(v != (u64)-1)
++  __builtin_abort();
++
++ return 0;
++}
 Index: gcc/testsuite/gcc.dg/vect/tree-vect.h
 ===================================================================
 --- a/src/gcc/testsuite/gcc.dg/vect/tree-vect.h	(.../tags/gcc_6_1_0_release)
@@ -3558,7 +3630,12 @@ Index: gcc/testsuite/ChangeLog
 ===================================================================
 --- a/src/gcc/testsuite/ChangeLog	(.../tags/gcc_6_1_0_release)
 +++ b/src/gcc/testsuite/ChangeLog	(.../branches/gcc-6-branch)
-@@ -1,3 +1,244 @@
+@@ -1,3 +1,249 @@
++2016-05-19  Martin Jambor  <mjambor at suse.cz>
++
++	PR ipa/70646
++	* gcc.dg/ipa/pr70646.c: New test.
++
 +2016-05-18  Jakub Jelinek  <jakub at redhat.com>
 +
 +	PR c++/71100
@@ -4130,6 +4207,19 @@ Index: gcc/cp/call.c
  	    /* And in C++98 a default constructor can't be explicit.  */
  	    && cxx_dialect >= cxx11)
  	  {
+Index: gcc/ipa-inline.h
+===================================================================
+--- a/src/gcc/ipa-inline.h	(.../tags/gcc_6_1_0_release)
++++ b/src/gcc/ipa-inline.h	(.../branches/gcc-6-branch)
+@@ -34,6 +34,8 @@
+   /* If agg_contents is set, this is the offset from which the used data was
+      loaded.  */
+   HOST_WIDE_INT offset;
++  /* Size of the access reading the data (or the PARM_DECL SSA_NAME).  */
++  HOST_WIDE_INT size;
+   tree val;
+   int operand_num;
+   ENUM_BITFIELD(tree_code) code : 16;
 Index: gcc/dwarf2out.c
 ===================================================================
 --- a/src/gcc/dwarf2out.c	(.../tags/gcc_6_1_0_release)
@@ -9163,6 +9253,394 @@ Index: gcc/tree-vect-loop.c
  		{
  		  if (STMT_VINFO_RELEVANT_P (stmt_info))
  		    mask_producers.safe_push (stmt_info);
+Index: gcc/ipa-inline-analysis.c
+===================================================================
+--- a/src/gcc/ipa-inline-analysis.c	(.../tags/gcc_6_1_0_release)
++++ b/src/gcc/ipa-inline-analysis.c	(.../branches/gcc-6-branch)
+@@ -216,13 +216,14 @@
+   bool by_ref;
+ };
+ 
+-/* Add condition to condition list CONDS.  AGGPOS describes whether the used
+-   oprand is loaded from an aggregate and where in the aggregate it is.  It can
+-   be NULL, which means this not a load from an aggregate.  */
++/* Add condition to condition list SUMMARY. OPERAND_NUM, SIZE, CODE and VAL
++   correspond to fields of condition structure.  AGGPOS describes whether the
++   used operand is loaded from an aggregate and where in the aggregate it is.
++   It can be NULL, which means this not a load from an aggregate.  */
+ 
+ static struct predicate
+ add_condition (struct inline_summary *summary, int operand_num,
+-	       struct agg_position_info *aggpos,
++	       HOST_WIDE_INT size, struct agg_position_info *aggpos,
+ 	       enum tree_code code, tree val)
+ {
+   int i;
+@@ -248,6 +249,7 @@
+   for (i = 0; vec_safe_iterate (summary->conds, i, &c); i++)
+     {
+       if (c->operand_num == operand_num
++	  && c->size == size
+ 	  && c->code == code
+ 	  && c->val == val
+ 	  && c->agg_contents == agg_contents
+@@ -264,6 +266,7 @@
+   new_cond.agg_contents = agg_contents;
+   new_cond.by_ref = by_ref;
+   new_cond.offset = offset;
++  new_cond.size = size;
+   vec_safe_push (summary->conds, new_cond);
+   return single_cond_predicate (i + predicate_first_dynamic_condition);
+ }
+@@ -867,21 +870,25 @@
+ 	  clause |= 1 << (i + predicate_first_dynamic_condition);
+ 	  continue;
+ 	}
+-      if (c->code == IS_NOT_CONSTANT || c->code == CHANGED)
++      if (c->code == CHANGED)
+ 	continue;
+ 
+-      if (operand_equal_p (TYPE_SIZE (TREE_TYPE (c->val)),
+-			   TYPE_SIZE (TREE_TYPE (val)), 0))
++      if (tree_to_shwi (TYPE_SIZE (TREE_TYPE (val))) != c->size)
+ 	{
+-	  val = fold_unary (VIEW_CONVERT_EXPR, TREE_TYPE (c->val), val);
++	  clause |= 1 << (i + predicate_first_dynamic_condition);
++	  continue;
++	}
++      if (c->code == IS_NOT_CONSTANT)
++	continue;
+ 
+-	  res = val
+-	    ? fold_binary_to_constant (c->code, boolean_type_node, val, c->val)
+-	    : NULL;
++      val = fold_unary (VIEW_CONVERT_EXPR, TREE_TYPE (c->val), val);
++      res = val
++	? fold_binary_to_constant (c->code, boolean_type_node, val, c->val)
++	: NULL;
+ 
+-	  if (res && integer_zerop (res))
+-	    continue;
+-	}
++      if (res && integer_zerop (res))
++	continue;
++
+       clause |= 1 << (i + predicate_first_dynamic_condition);
+     }
+   return clause;
+@@ -1515,16 +1522,21 @@
+ }
+ 
+ /* If OP refers to value of function parameter, return the corresponding
+-   parameter.  */
++   parameter.  If non-NULL, the size of the memory load (or the SSA_NAME of the
++   PARM_DECL) will be stored to *SIZE_P in that case too.  */
+ 
+ static tree
+-unmodified_parm_1 (gimple *stmt, tree op)
++unmodified_parm_1 (gimple *stmt, tree op, HOST_WIDE_INT *size_p)
+ {
+   /* SSA_NAME referring to parm default def?  */
+   if (TREE_CODE (op) == SSA_NAME
+       && SSA_NAME_IS_DEFAULT_DEF (op)
+       && TREE_CODE (SSA_NAME_VAR (op)) == PARM_DECL)
+-    return SSA_NAME_VAR (op);
++    {
++      if (size_p)
++	*size_p = tree_to_shwi (TYPE_SIZE (TREE_TYPE (op)));
++      return SSA_NAME_VAR (op);
++    }
+   /* Non-SSA parm reference?  */
+   if (TREE_CODE (op) == PARM_DECL)
+     {
+@@ -1535,18 +1547,24 @@
+       walk_aliased_vdefs (&refd, gimple_vuse (stmt), mark_modified, &modified,
+ 			  NULL);
+       if (!modified)
+-	return op;
++	{
++	  if (size_p)
++	    *size_p = tree_to_shwi (TYPE_SIZE (TREE_TYPE (op)));
++	  return op;
++	}
+     }
+   return NULL_TREE;
+ }
+ 
+ /* If OP refers to value of function parameter, return the corresponding
+-   parameter.  Also traverse chains of SSA register assignments.  */
++   parameter.  Also traverse chains of SSA register assignments.  If non-NULL,
++   the size of the memory load (or the SSA_NAME of the PARM_DECL) will be
++   stored to *SIZE_P in that case too.  */
+ 
+ static tree
+-unmodified_parm (gimple *stmt, tree op)
++unmodified_parm (gimple *stmt, tree op, HOST_WIDE_INT *size_p)
+ {
+-  tree res = unmodified_parm_1 (stmt, op);
++  tree res = unmodified_parm_1 (stmt, op, size_p);
+   if (res)
+     return res;
+ 
+@@ -1554,23 +1572,25 @@
+       && !SSA_NAME_IS_DEFAULT_DEF (op)
+       && gimple_assign_single_p (SSA_NAME_DEF_STMT (op)))
+     return unmodified_parm (SSA_NAME_DEF_STMT (op),
+-			    gimple_assign_rhs1 (SSA_NAME_DEF_STMT (op)));
++			    gimple_assign_rhs1 (SSA_NAME_DEF_STMT (op)),
++			    size_p);
+   return NULL_TREE;
+ }
+ 
+ /* If OP refers to a value of a function parameter or value loaded from an
+    aggregate passed to a parameter (either by value or reference), return TRUE
+-   and store the number of the parameter to *INDEX_P and information whether
+-   and how it has been loaded from an aggregate into *AGGPOS.  INFO describes
+-   the function parameters, STMT is the statement in which OP is used or
+-   loaded.  */
++   and store the number of the parameter to *INDEX_P, the access size into
++   *SIZE_P, and information whether and how it has been loaded from an
++   aggregate into *AGGPOS.  INFO describes the function parameters, STMT is the
++   statement in which OP is used or loaded.  */
+ 
+ static bool
+ unmodified_parm_or_parm_agg_item (struct ipa_func_body_info *fbi,
+ 				  gimple *stmt, tree op, int *index_p,
++				  HOST_WIDE_INT *size_p,
+ 				  struct agg_position_info *aggpos)
+ {
+-  tree res = unmodified_parm_1 (stmt, op);
++  tree res = unmodified_parm_1 (stmt, op, size_p);
+ 
+   gcc_checking_assert (aggpos);
+   if (res)
+@@ -1591,7 +1611,7 @@
+       stmt = SSA_NAME_DEF_STMT (op);
+       op = gimple_assign_rhs1 (stmt);
+       if (!REFERENCE_CLASS_P (op))
+-	return unmodified_parm_or_parm_agg_item (fbi, stmt, op, index_p,
++	return unmodified_parm_or_parm_agg_item (fbi, stmt, op, index_p, size_p,
+ 						 aggpos);
+     }
+ 
+@@ -1598,7 +1618,7 @@
+   aggpos->agg_contents = true;
+   return ipa_load_from_parm_agg (fbi, fbi->info->descriptors,
+ 				 stmt, op, index_p, &aggpos->offset,
+-				 NULL, &aggpos->by_ref);
++				 size_p, &aggpos->by_ref);
+ }
+ 
+ /* See if statement might disappear after inlining.
+@@ -1649,7 +1669,7 @@
+ 	    inner_lhs = lhs;
+ 
+ 	  /* Reads of parameter are expected to be free.  */
+-	  if (unmodified_parm (stmt, inner_rhs))
++	  if (unmodified_parm (stmt, inner_rhs, NULL))
+ 	    rhs_free = true;
+ 	  /* Match expressions of form &this->field. Those will most likely
+ 	     combine with something upstream after inlining.  */
+@@ -1659,7 +1679,7 @@
+ 	      if (TREE_CODE (op) == PARM_DECL)
+ 		rhs_free = true;
+ 	      else if (TREE_CODE (op) == MEM_REF
+-		       && unmodified_parm (stmt, TREE_OPERAND (op, 0)))
++		       && unmodified_parm (stmt, TREE_OPERAND (op, 0), NULL))
+ 		rhs_free = true;
+ 	    }
+ 
+@@ -1672,7 +1692,7 @@
+ 	  /* Reads of parameters passed by reference
+ 	     expected to be free (i.e. optimized out after inlining).  */
+ 	  if (TREE_CODE (inner_rhs) == MEM_REF
+-	      && unmodified_parm (stmt, TREE_OPERAND (inner_rhs, 0)))
++	      && unmodified_parm (stmt, TREE_OPERAND (inner_rhs, 0), NULL))
+ 	    rhs_free = true;
+ 
+ 	  /* Copying parameter passed by reference into gimple register is
+@@ -1713,7 +1733,7 @@
+ 	  if (TREE_CODE (inner_lhs) == PARM_DECL
+ 	      || TREE_CODE (inner_lhs) == RESULT_DECL
+ 	      || (TREE_CODE (inner_lhs) == MEM_REF
+-		  && (unmodified_parm (stmt, TREE_OPERAND (inner_lhs, 0))
++		  && (unmodified_parm (stmt, TREE_OPERAND (inner_lhs, 0), NULL)
+ 		      || (TREE_CODE (TREE_OPERAND (inner_lhs, 0)) == SSA_NAME
+ 			  && SSA_NAME_VAR (TREE_OPERAND (inner_lhs, 0))
+ 			  && TREE_CODE (SSA_NAME_VAR (TREE_OPERAND
+@@ -1744,6 +1764,7 @@
+   gimple *last;
+   tree op;
+   int index;
++  HOST_WIDE_INT size;
+   struct agg_position_info aggpos;
+   enum tree_code code, inverted_code;
+   edge e;
+@@ -1760,7 +1781,7 @@
+   /* TODO: handle conditionals like
+      var = op0 < 4;
+      if (var != 0).  */
+-  if (unmodified_parm_or_parm_agg_item (fbi, last, op, &index, &aggpos))
++  if (unmodified_parm_or_parm_agg_item (fbi, last, op, &index, &size, &aggpos))
+     {
+       code = gimple_cond_code (last);
+       inverted_code = invert_tree_comparison (code, HONOR_NANS (op));
+@@ -1774,9 +1795,10 @@
+ 	     unordered one.  Be sure it is not confused with NON_CONSTANT.  */
+ 	  if (this_code != ERROR_MARK)
+ 	    {
+-	      struct predicate p = add_condition
+-		 (summary, index, &aggpos, this_code,
+-		  unshare_expr_without_location (gimple_cond_rhs (last)));
++	      struct predicate p
++		= add_condition (summary, index, size, &aggpos, this_code,
++				 unshare_expr_without_location
++				 (gimple_cond_rhs (last)));
+ 	      e->aux = edge_predicate_pool.allocate ();
+ 	      *(struct predicate *) e->aux = p;
+ 	    }
+@@ -1803,11 +1825,12 @@
+       || gimple_call_num_args (set_stmt) != 1)
+     return;
+   op2 = gimple_call_arg (set_stmt, 0);
+-  if (!unmodified_parm_or_parm_agg_item (fbi, set_stmt, op2, &index, &aggpos))
++  if (!unmodified_parm_or_parm_agg_item (fbi, set_stmt, op2, &index, &size,
++					 &aggpos))
+     return;
+   FOR_EACH_EDGE (e, ei, bb->succs) if (e->flags & EDGE_FALSE_VALUE)
+     {
+-      struct predicate p = add_condition (summary, index, &aggpos,
++      struct predicate p = add_condition (summary, index, size, &aggpos,
+ 					  IS_NOT_CONSTANT, NULL_TREE);
+       e->aux = edge_predicate_pool.allocate ();
+       *(struct predicate *) e->aux = p;
+@@ -1826,6 +1849,7 @@
+   gimple *lastg;
+   tree op;
+   int index;
++  HOST_WIDE_INT size;
+   struct agg_position_info aggpos;
+   edge e;
+   edge_iterator ei;
+@@ -1837,7 +1861,7 @@
+     return;
+   gswitch *last = as_a <gswitch *> (lastg);
+   op = gimple_switch_index (last);
+-  if (!unmodified_parm_or_parm_agg_item (fbi, last, op, &index, &aggpos))
++  if (!unmodified_parm_or_parm_agg_item (fbi, last, op, &index, &size, &aggpos))
+     return;
+ 
+   FOR_EACH_EDGE (e, ei, bb->succs)
+@@ -1862,14 +1886,14 @@
+       if (!min && !max)
+ 	p = true_predicate ();
+       else if (!max)
+-	p = add_condition (summary, index, &aggpos, EQ_EXPR,
++	p = add_condition (summary, index, size, &aggpos, EQ_EXPR,
+ 			   unshare_expr_without_location (min));
+       else
+ 	{
+ 	  struct predicate p1, p2;
+-	  p1 = add_condition (summary, index, &aggpos, GE_EXPR,
++	  p1 = add_condition (summary, index, size, &aggpos, GE_EXPR,
+ 			      unshare_expr_without_location (min));
+-	  p2 = add_condition (summary, index, &aggpos, LE_EXPR,
++	  p2 = add_condition (summary, index, size, &aggpos, LE_EXPR,
+ 			      unshare_expr_without_location (max));
+ 	  p = and_predicates (summary->conds, &p1, &p2);
+ 	}
+@@ -1970,13 +1994,14 @@
+ {
+   tree parm;
+   int index;
++  HOST_WIDE_INT size;
+ 
+   while (UNARY_CLASS_P (expr))
+     expr = TREE_OPERAND (expr, 0);
+ 
+-  parm = unmodified_parm (NULL, expr);
++  parm = unmodified_parm (NULL, expr, &size);
+   if (parm && (index = ipa_get_param_decl_index (info, parm)) >= 0)
+-    return add_condition (summary, index, NULL, CHANGED, NULL_TREE);
++    return add_condition (summary, index, size, NULL, CHANGED, NULL_TREE);
+   if (is_gimple_min_invariant (expr))
+     return false_predicate ();
+   if (TREE_CODE (expr) == SSA_NAME)
+@@ -2037,6 +2062,7 @@
+   struct predicate op_non_const;
+   bool is_load;
+   int base_index;
++  HOST_WIDE_INT size;
+   struct agg_position_info aggpos;
+ 
+   /* What statments might be optimized away
+@@ -2060,7 +2086,7 @@
+       tree op;
+       gcc_assert (gimple_assign_single_p (stmt));
+       op = gimple_assign_rhs1 (stmt);
+-      if (!unmodified_parm_or_parm_agg_item (fbi, stmt, op, &base_index,
++      if (!unmodified_parm_or_parm_agg_item (fbi, stmt, op, &base_index, &size,
+ 					     &aggpos))
+ 	return p;
+     }
+@@ -2071,7 +2097,7 @@
+      adding conditionals.  */
+   FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE)
+     {
+-      tree parm = unmodified_parm (stmt, use);
++      tree parm = unmodified_parm (stmt, use, NULL);
+       /* For arguments we can build a condition.  */
+       if (parm && ipa_get_param_decl_index (fbi->info, parm) >= 0)
+ 	continue;
+@@ -2086,18 +2112,19 @@
+ 
+   if (is_load)
+     op_non_const =
+-      add_condition (summary, base_index, &aggpos, CHANGED, NULL);
++      add_condition (summary, base_index, size, &aggpos, CHANGED, NULL);
+   else
+     op_non_const = false_predicate ();
+   FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE)
+     {
+-      tree parm = unmodified_parm (stmt, use);
++      HOST_WIDE_INT size;
++      tree parm = unmodified_parm (stmt, use, &size);
+       int index;
+ 
+       if (parm && (index = ipa_get_param_decl_index (fbi->info, parm)) >= 0)
+ 	{
+ 	  if (index != base_index)
+-	    p = add_condition (summary, index, NULL, CHANGED, NULL_TREE);
++	    p = add_condition (summary, index, size, NULL, CHANGED, NULL_TREE);
+ 	  else
+ 	    continue;
+ 	}
+@@ -3377,7 +3404,8 @@
+ 		    ap.by_ref = c->by_ref;
+ 		    cond_predicate = add_condition (info,
+ 						    operand_map[c->operand_num],
+-						    &ap, c->code, c->val);
++						    c->size, &ap, c->code,
++						    c->val);
+ 		  }
+ 	      }
+ 	    /* Fixed conditions remains same, construct single
+@@ -4236,6 +4264,7 @@
+ 	{
+ 	  struct condition c;
+ 	  c.operand_num = streamer_read_uhwi (&ib);
++	  c.size = streamer_read_uhwi (&ib);
+ 	  c.code = (enum tree_code) streamer_read_uhwi (&ib);
+ 	  c.val = stream_read_tree (&ib, data_in);
+ 	  bp = streamer_read_bitpack (&ib);
+@@ -4400,6 +4429,7 @@
+ 	  for (i = 0; vec_safe_iterate (info->conds, i, &c); i++)
+ 	    {
+ 	      streamer_write_uhwi (ob, c->operand_num);
++	      streamer_write_uhwi (ob, c->size);
+ 	      streamer_write_uhwi (ob, c->code);
+ 	      stream_write_tree (ob, c->val, true);
+ 	      bp = bitpack_create (ob->main_stream);
 Index: gcc/gimplify.c
 ===================================================================
 --- a/src/gcc/gimplify.c	(.../tags/gcc_6_1_0_release)
@@ -9288,6 +9766,20 @@ Index: gcc/ubsan.c
    if (TREE_CODE (type) == REAL_TYPE)
      return tree_to_uhwi (TYPE_SIZE (type));
    else if (INTEGRAL_TYPE_P (type))
+Index: gcc/ipa-prop.c
+===================================================================
+--- a/src/gcc/ipa-prop.c	(.../tags/gcc_6_1_0_release)
++++ b/src/gcc/ipa-prop.c	(.../branches/gcc-6-branch)
+@@ -1414,6 +1414,9 @@
+   bool check_ref, by_ref;
+   ao_ref r;
+ 
++  if (PARAM_VALUE (PARAM_IPA_MAX_AGG_ITEMS) == 0)
++    return;
++
+   /* The function operates in three stages.  First, we prepare check_ref, r,
+      arg_base and arg_offset based on what is actually passed as an actual
+      argument.  */
 Index: gcc/po/es.po
 ===================================================================
 --- a/src/gcc/po/es.po	(.../tags/gcc_6_1_0_release)
@@ -752717,6 +753209,19 @@ Index: gcc/ipa-icf.c
  
        if (dump_file)
  	fprintf (dump_file, "Unified; Variable alias has been created.\n\n");
+Index: gcc/lto-streamer.h
+===================================================================
+--- a/src/gcc/lto-streamer.h	(.../tags/gcc_6_1_0_release)
++++ b/src/gcc/lto-streamer.h	(.../branches/gcc-6-branch)
+@@ -129,7 +129,7 @@
+      form followed by the data for the string.  */
+ 
+ #define LTO_major_version 5
+-#define LTO_minor_version 0
++#define LTO_minor_version 1
+ 
+ typedef unsigned char	lto_decl_flags_t;
+ 
 Index: libvtv/Makefile.in
 ===================================================================
 --- a/src/libvtv/Makefile.in	(.../tags/gcc_6_1_0_release)

-- 
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/reproducible/gcc-6.git



More information about the Reproducible-commits mailing list