[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