public inbox for gcc-regression@sourceware.org
help / color / mirror / Atom feed
From: ci_notify@linaro.org
To: Richard Biener <rguenther@suse.de>
Cc: gcc-regression@gcc.gnu.org
Subject: [TCWG CI] Regression caused by gcc: Teach VN about masked/len stores
Date: Thu, 21 Jul 2022 16:54:41 +0000 (UTC) [thread overview]
Message-ID: <279373770.2069.1658422483393@jenkins.jenkins> (raw)
[TCWG CI] Regression caused by gcc: Teach VN about masked/len stores:
commit bd9837bc3ca1344c32aef7ba9f8fa1785063132e
Author: Richard Biener <rguenther@suse.de>
Teach VN about masked/len stores
Results regressed to
# reset_artifacts:
-10
# true:
0
# build_abe binutils:
1
# First few build errors in logs:
# 00:06:14 make[3]: [Makefile:1787: armv8l-unknown-linux-gnueabihf/bits/largefile-config.h] Error 1 (ignored)
# 00:08:57 /home/tcwg-buildslave/workspace/tcwg_gnu_2/abe/snapshots/gcc.git~master/libiberty/../include/xregex.h:8:19: internal compiler error: Segmentation fault
# 00:08:58 make[3]: *** [Makefile:1218: regex.o] Error 1
# 00:09:30 make[2]: *** [Makefile:12585: all-stage2-libiberty] Error 2
# 00:09:30 make[1]: *** [Makefile:25739: stage2-bubble] Error 2
# 00:09:30 make: *** [Makefile:1072: all] Error 2
from
# reset_artifacts:
-10
# true:
0
# build_abe binutils:
1
# build_abe bootstrap_O3:
2
THIS IS THE END OF INTERESTING STUFF. BELOW ARE LINKS TO BUILDS, REPRODUCTION INSTRUCTIONS, AND THE RAW COMMIT.
This commit has regressed these CI configurations:
- tcwg_gcc_bootstrap/master-arm-bootstrap_O3
First_bad build: https://ci.linaro.org/job/tcwg_gcc_bootstrap-bisect-master-arm-bootstrap_O3/11/artifact/artifacts/build-bd9837bc3ca1344c32aef7ba9f8fa1785063132e/
Last_good build: https://ci.linaro.org/job/tcwg_gcc_bootstrap-bisect-master-arm-bootstrap_O3/11/artifact/artifacts/build-f4ed610d02aaf8cfcdcb5cf03e0cde65f1f5f890/
Baseline build: https://ci.linaro.org/job/tcwg_gcc_bootstrap-bisect-master-arm-bootstrap_O3/11/artifact/artifacts/build-baseline/
Even more details: https://ci.linaro.org/job/tcwg_gcc_bootstrap-bisect-master-arm-bootstrap_O3/11/artifact/artifacts/
Reproduce builds:
<cut>
mkdir investigate-gcc-bd9837bc3ca1344c32aef7ba9f8fa1785063132e
cd investigate-gcc-bd9837bc3ca1344c32aef7ba9f8fa1785063132e
# Fetch scripts
git clone https://git.linaro.org/toolchain/jenkins-scripts
# Fetch manifests and test.sh script
mkdir -p artifacts/manifests
curl -o artifacts/manifests/build-baseline.sh https://ci.linaro.org/job/tcwg_gcc_bootstrap-bisect-master-arm-bootstrap_O3/11/artifact/artifacts/manifests/build-baseline.sh --fail
curl -o artifacts/manifests/build-parameters.sh https://ci.linaro.org/job/tcwg_gcc_bootstrap-bisect-master-arm-bootstrap_O3/11/artifact/artifacts/manifests/build-parameters.sh --fail
curl -o artifacts/test.sh https://ci.linaro.org/job/tcwg_gcc_bootstrap-bisect-master-arm-bootstrap_O3/11/artifact/artifacts/test.sh --fail
chmod +x artifacts/test.sh
# Reproduce the baseline build (build all pre-requisites)
./jenkins-scripts/tcwg_gnu-build.sh @@ artifacts/manifests/build-baseline.sh
# Save baseline build state (which is then restored in artifacts/test.sh)
mkdir -p ./bisect
rsync -a --del --delete-excluded --exclude /bisect/ --exclude /artifacts/ --exclude /gcc/ ./ ./bisect/baseline/
cd gcc
# Reproduce first_bad build
git checkout --detach bd9837bc3ca1344c32aef7ba9f8fa1785063132e
../artifacts/test.sh
# Reproduce last_good build
git checkout --detach f4ed610d02aaf8cfcdcb5cf03e0cde65f1f5f890
../artifacts/test.sh
cd ..
</cut>
Full commit (up to 1000 lines):
<cut>
commit bd9837bc3ca1344c32aef7ba9f8fa1785063132e
Author: Richard Biener <rguenther@suse.de>
Date: Wed Jul 20 12:28:26 2022 +0200
Teach VN about masked/len stores
The following teaches VN to handle reads from .MASK_STORE and
.LEN_STORE. For this push_partial_def is extended first for
convenience so we don't have to handle the full def case in the
caller (possibly other paths can be simplified then). Also
the partial definition stored value can have an offset applied
so we don't have to build a fake RHS when we register the pieces
of an existing store.
PR tree-optimization/106365
* tree-ssa-sccvn.cc (pd_data::rhs_off): New field determining
the offset to start encoding of RHS from.
(vn_walk_cb_data::vn_walk_cb_data): Initialize it.
(vn_walk_cb_data::push_partial_def): Allow the first partial
definition to be fully providing the def. Offset RHS
before encoding if requested.
(vn_reference_lookup_3): Initialize def_rhs everywhere.
Add support for .MASK_STORE and .LEN_STORE (partial) definitions.
* gcc.target/i386/vec-maskstore-vn.c: New testcase.
---
gcc/testsuite/gcc.target/i386/vec-maskstore-vn.c | 30 +++
gcc/tree-ssa-sccvn.cc | 255 ++++++++++++++++++-----
2 files changed, 228 insertions(+), 57 deletions(-)
diff --git a/gcc/testsuite/gcc.target/i386/vec-maskstore-vn.c b/gcc/testsuite/gcc.target/i386/vec-maskstore-vn.c
new file mode 100644
index 00000000000..98213905ece
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/vec-maskstore-vn.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -mavx2 -fdump-tree-fre5" } */
+
+void __attribute__((noinline,noclone))
+foo (int *out, int *res)
+{
+ int mask[] = { 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1 };
+ int i;
+ for (i = 0; i < 16; ++i)
+ {
+ if (mask[i])
+ out[i] = i;
+ }
+ int o0 = out[0];
+ int o7 = out[7];
+ int o14 = out[14];
+ int o15 = out[15];
+ res[0] = o0;
+ res[2] = o7;
+ res[4] = o14;
+ res[6] = o15;
+}
+
+/* Vectorization produces .MASK_STORE, unrolling will unroll the two
+ vector iterations. FRE5 after that should be able to CSE
+ out[7] and out[15], but leave out[0] and out[14] alone. */
+/* { dg-final { scan-tree-dump " = o0_\[0-9\]+;" "fre5" } } */
+/* { dg-final { scan-tree-dump " = 7;" "fre5" } } */
+/* { dg-final { scan-tree-dump " = o14_\[0-9\]+;" "fre5" } } */
+/* { dg-final { scan-tree-dump " = 15;" "fre5" } } */
diff --git a/gcc/tree-ssa-sccvn.cc b/gcc/tree-ssa-sccvn.cc
index f41d5031365..7d947b55a27 100644
--- a/gcc/tree-ssa-sccvn.cc
+++ b/gcc/tree-ssa-sccvn.cc
@@ -1790,6 +1790,7 @@ struct pd_range
struct pd_data
{
tree rhs;
+ HOST_WIDE_INT rhs_off;
HOST_WIDE_INT offset;
HOST_WIDE_INT size;
};
@@ -1816,6 +1817,7 @@ struct vn_walk_cb_data
unsigned int pos = 0, prec = w.get_precision ();
pd_data pd;
pd.rhs = build_constructor (NULL_TREE, NULL);
+ pd.rhs_off = 0;
/* When bitwise and with a constant is done on a memory load,
we don't really need all the bits to be defined or defined
to constants, we don't really care what is in the position
@@ -1976,6 +1978,7 @@ vn_walk_cb_data::push_partial_def (pd_data pd,
bool pd_constant_p = (TREE_CODE (pd.rhs) == CONSTRUCTOR
|| CONSTANT_CLASS_P (pd.rhs));
+ pd_range *r;
if (partial_defs.is_empty ())
{
/* If we get a clobber upfront, fail. */
@@ -1989,65 +1992,70 @@ vn_walk_cb_data::push_partial_def (pd_data pd,
first_set = set;
first_base_set = base_set;
last_vuse_ptr = NULL;
- /* Continue looking for partial defs. */
- return NULL;
- }
-
- if (!known_ranges)
- {
- /* ??? Optimize the case where the 2nd partial def completes things. */
- gcc_obstack_init (&ranges_obstack);
- known_ranges = splay_tree_new_with_allocator (pd_range_compare, 0, 0,
- pd_tree_alloc,
- pd_tree_dealloc, this);
- splay_tree_insert (known_ranges,
- (splay_tree_key)&first_range.offset,
- (splay_tree_value)&first_range);
- }
-
- pd_range newr = { pd.offset, pd.size };
- splay_tree_node n;
- pd_range *r;
- /* Lookup the predecessor of offset + 1 and see if we need to merge. */
- HOST_WIDE_INT loffset = newr.offset + 1;
- if ((n = splay_tree_predecessor (known_ranges, (splay_tree_key)&loffset))
- && ((r = (pd_range *)n->value), true)
- && ranges_known_overlap_p (r->offset, r->size + 1,
- newr.offset, newr.size))
- {
- /* Ignore partial defs already covered. Here we also drop shadowed
- clobbers arriving here at the floor. */
- if (known_subrange_p (newr.offset, newr.size, r->offset, r->size))
- return NULL;
- r->size = MAX (r->offset + r->size, newr.offset + newr.size) - r->offset;
+ r = &first_range;
+ /* Go check if the first partial definition was a full one in case
+ the caller didn't optimize for this. */
}
else
{
- /* newr.offset wasn't covered yet, insert the range. */
- r = XOBNEW (&ranges_obstack, pd_range);
- *r = newr;
- splay_tree_insert (known_ranges, (splay_tree_key)&r->offset,
- (splay_tree_value)r);
- }
- /* Merge r which now contains newr and is a member of the splay tree with
- adjacent overlapping ranges. */
- pd_range *rafter;
- while ((n = splay_tree_successor (known_ranges, (splay_tree_key)&r->offset))
- && ((rafter = (pd_range *)n->value), true)
- && ranges_known_overlap_p (r->offset, r->size + 1,
- rafter->offset, rafter->size))
- {
- r->size = MAX (r->offset + r->size,
- rafter->offset + rafter->size) - r->offset;
- splay_tree_remove (known_ranges, (splay_tree_key)&rafter->offset);
- }
- /* If we get a clobber, fail. */
- if (TREE_CLOBBER_P (pd.rhs))
- return (void *)-1;
- /* Non-constants are OK as long as they are shadowed by a constant. */
- if (!pd_constant_p)
- return (void *)-1;
- partial_defs.safe_push (pd);
+ if (!known_ranges)
+ {
+ /* ??? Optimize the case where the 2nd partial def completes
+ things. */
+ gcc_obstack_init (&ranges_obstack);
+ known_ranges = splay_tree_new_with_allocator (pd_range_compare, 0, 0,
+ pd_tree_alloc,
+ pd_tree_dealloc, this);
+ splay_tree_insert (known_ranges,
+ (splay_tree_key)&first_range.offset,
+ (splay_tree_value)&first_range);
+ }
+
+ pd_range newr = { pd.offset, pd.size };
+ splay_tree_node n;
+ /* Lookup the predecessor of offset + 1 and see if we need to merge. */
+ HOST_WIDE_INT loffset = newr.offset + 1;
+ if ((n = splay_tree_predecessor (known_ranges, (splay_tree_key)&loffset))
+ && ((r = (pd_range *)n->value), true)
+ && ranges_known_overlap_p (r->offset, r->size + 1,
+ newr.offset, newr.size))
+ {
+ /* Ignore partial defs already covered. Here we also drop shadowed
+ clobbers arriving here at the floor. */
+ if (known_subrange_p (newr.offset, newr.size, r->offset, r->size))
+ return NULL;
+ r->size
+ = MAX (r->offset + r->size, newr.offset + newr.size) - r->offset;
+ }
+ else
+ {
+ /* newr.offset wasn't covered yet, insert the range. */
+ r = XOBNEW (&ranges_obstack, pd_range);
+ *r = newr;
+ splay_tree_insert (known_ranges, (splay_tree_key)&r->offset,
+ (splay_tree_value)r);
+ }
+ /* Merge r which now contains newr and is a member of the splay tree with
+ adjacent overlapping ranges. */
+ pd_range *rafter;
+ while ((n = splay_tree_successor (known_ranges,
+ (splay_tree_key)&r->offset))
+ && ((rafter = (pd_range *)n->value), true)
+ && ranges_known_overlap_p (r->offset, r->size + 1,
+ rafter->offset, rafter->size))
+ {
+ r->size = MAX (r->offset + r->size,
+ rafter->offset + rafter->size) - r->offset;
+ splay_tree_remove (known_ranges, (splay_tree_key)&rafter->offset);
+ }
+ /* If we get a clobber, fail. */
+ if (TREE_CLOBBER_P (pd.rhs))
+ return (void *)-1;
+ /* Non-constants are OK as long as they are shadowed by a constant. */
+ if (!pd_constant_p)
+ return (void *)-1;
+ partial_defs.safe_push (pd);
+ }
/* Now we have merged newr into the range tree. When we have covered
[offseti, sizei] then the tree will contain exactly one node which has
@@ -2081,7 +2089,8 @@ vn_walk_cb_data::push_partial_def (pd_data pd,
else
{
len = native_encode_expr (pd.rhs, this_buffer, bufsize,
- MAX (0, -pd.offset) / BITS_PER_UNIT);
+ (MAX (0, -pd.offset)
+ + pd.rhs_off) / BITS_PER_UNIT);
if (len <= 0
|| len < (ROUND_UP (pd.size, BITS_PER_UNIT) / BITS_PER_UNIT
- MAX (0, -pd.offset) / BITS_PER_UNIT))
@@ -2906,6 +2915,7 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *data_,
{
pd_data pd;
pd.rhs = build_constructor (NULL_TREE, NULL);
+ pd.rhs_off = 0;
pd.offset = offset2i;
pd.size = leni << LOG2_BITS_PER_UNIT;
return data->push_partial_def (pd, 0, 0, offseti, maxsizei);
@@ -2955,6 +2965,7 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *data_,
by a later def. */
pd_data pd;
pd.rhs = gimple_assign_rhs1 (def_stmt);
+ pd.rhs_off = 0;
pd.offset = offset2i;
pd.size = size2i;
return data->push_partial_def (pd, ao_ref_alias_set (&lhs_ref),
@@ -3107,6 +3118,7 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *data_,
if (TREE_CODE (rhs) == SSA_NAME)
rhs = SSA_VAL (rhs);
pd.rhs = rhs;
+ pd.rhs_off = 0;
pd.offset = offset2i;
pd.size = size2i;
return data->push_partial_def (pd, ao_ref_alias_set (&lhs_ref),
@@ -3186,6 +3198,7 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *data_,
{
pd_data pd;
pd.rhs = SSA_VAL (def_rhs);
+ pd.rhs_off = 0;
pd.offset = offset2i;
pd.size = size2i;
return data->push_partial_def (pd, ao_ref_alias_set (&lhs_ref),
@@ -3195,6 +3208,133 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *data_,
}
}
+ /* 4b) Assignment done via one of the vectorizer internal store
+ functions where we may be able to access pieces from or we can
+ combine to a larger entity. */
+ else if (known_eq (ref->size, maxsize)
+ && is_gimple_reg_type (vr->type)
+ && !reverse_storage_order_for_component_p (vr->operands)
+ && !contains_storage_order_barrier_p (vr->operands)
+ && is_gimple_call (def_stmt)
+ && gimple_call_internal_p (def_stmt)
+ && internal_store_fn_p (gimple_call_internal_fn (def_stmt)))
+ {
+ gcall *call = as_a <gcall *> (def_stmt);
+ internal_fn fn = gimple_call_internal_fn (call);
+ tree def_rhs = gimple_call_arg (call,
+ internal_fn_stored_value_index (fn));
+ def_rhs = vn_valueize (def_rhs);
+ if (TREE_CODE (def_rhs) != VECTOR_CST)
+ return (void *)-1;
+
+ tree mask = NULL_TREE, len = NULL_TREE, bias = NULL_TREE;
+ switch (fn)
+ {
+ case IFN_MASK_STORE:
+ mask = gimple_call_arg (call, internal_fn_mask_index (fn));
+ mask = vn_valueize (mask);
+ if (TREE_CODE (mask) != VECTOR_CST)
+ return (void *)-1;
+ break;
+ case IFN_LEN_STORE:
+ len = gimple_call_arg (call, 2);
+ bias = gimple_call_arg (call, 4);
+ if (!tree_fits_uhwi_p (len) || !tree_fits_shwi_p (bias))
+ return (void *)-1;
+ break;
+ default:
+ return (void *)-1;
+ }
+ ao_ref_init_from_ptr_and_size (&lhs_ref,
+ vn_valueize (gimple_call_arg (call, 0)),
+ TYPE_SIZE_UNIT (TREE_TYPE (def_rhs)));
+ tree base2;
+ poly_int64 offset2, size2, maxsize2;
+ HOST_WIDE_INT offset2i, size2i, offseti;
+ base2 = ao_ref_base (&lhs_ref);
+ offset2 = lhs_ref.offset;
+ size2 = lhs_ref.size;
+ maxsize2 = lhs_ref.max_size;
+ if (known_size_p (maxsize2)
+ && known_eq (maxsize2, size2)
+ && adjust_offsets_for_equal_base_address (base, &offset,
+ base2, &offset2)
+ && maxsize.is_constant (&maxsizei)
+ && offset.is_constant (&offseti)
+ && offset2.is_constant (&offset2i)
+ && size2.is_constant (&size2i))
+ {
+ if (!ranges_maybe_overlap_p (offset, maxsize, offset2, size2))
+ /* Poor-mans disambiguation. */
+ return NULL;
+ else if (ranges_known_overlap_p (offset, maxsize, offset2, size2))
+ {
+ pd_data pd;
+ pd.rhs = def_rhs;
+ tree aa = gimple_call_arg (call, 1);
+ alias_set_type set = get_deref_alias_set (TREE_TYPE (aa));
+ tree vectype = TREE_TYPE (def_rhs);
+ unsigned HOST_WIDE_INT elsz
+ = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (vectype)));
+ if (mask)
+ {
+ HOST_WIDE_INT start = 0, len = 0;
+ unsigned mask_idx = 0;
+ do
+ {
+ if (integer_zerop (VECTOR_CST_ELT (mask, mask_idx)))
+ {
+ if (len != 0)
+ {
+ pd.rhs_off = start;
+ pd.offset = offset2i + start;
+ pd.size = len;
+ if (ranges_known_overlap_p
+ (offset, maxsize, pd.offset, pd.size))
+ {
+ void *res = data->push_partial_def
+ (pd, set, set, offseti, maxsizei);
+ if (res != NULL)
+ return res;
+ }
+ }
+ start = (mask_idx + 1) * elsz;
+ len = 0;
+ }
+ else
+ len += elsz;
+ mask_idx++;
+ }
+ while (known_lt (mask_idx, TYPE_VECTOR_SUBPARTS (vectype)));
+ if (len != 0)
+ {
+ pd.rhs_off = start;
+ pd.offset = offset2i + start;
+ pd.size = len;
+ if (ranges_known_overlap_p (offset, maxsize,
+ pd.offset, pd.size))
+ return data->push_partial_def (pd, set, set,
+ offseti, maxsizei);
+ }
+ }
+ else if (fn == IFN_LEN_STORE)
+ {
+ pd.rhs_off = 0;
+ pd.offset = offset2i;
+ pd.size = (tree_to_uhwi (len)
+ + -tree_to_shwi (bias)) * BITS_PER_UNIT;
+ if (ranges_known_overlap_p (offset, maxsize,
+ pd.offset, pd.size))
+ return data->push_partial_def (pd, set, set,
+ offseti, maxsizei);
+ }
+ else
+ gcc_unreachable ();
+ return NULL;
+ }
+ }
+ }
+
/* 5) For aggregate copies translate the reference through them if
the copy kills ref. */
else if (data->vn_walk_kind == VN_WALKREWRITE
@@ -3327,6 +3467,7 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *data_,
{
pd_data pd;
pd.rhs = val;
+ pd.rhs_off = 0;
pd.offset = 0;
pd.size = maxsizei;
return data->push_partial_def (pd, ao_ref_alias_set (&lhs_ref),
</cut>
>From ci_notify@linaro.org Thu Jul 21 20:13:05 2022
Return-Path: <ci_notify@linaro.org>
X-Original-To: gcc-regression@gcc.gnu.org
Delivered-To: gcc-regression@gcc.gnu.org
Received: from mail-wm1-x330.google.com (mail-wm1-x330.google.com
[IPv6:2a00:1450:4864:20::330])
by sourceware.org (Postfix) with ESMTPS id E8DCD3838F33
for <gcc-regression@gcc.gnu.org>; Thu, 21 Jul 2022 20:13:01 +0000 (GMT)
DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org E8DCD3838F33
Received: by mail-wm1-x330.google.com with SMTP id
j29-20020a05600c1c1d00b003a2fdafdefbso1405360wms.2
for <gcc-regression@gcc.gnu.org>; Thu, 21 Jul 2022 13:13:01 -0700 (PDT)
X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;
d=1e100.net; s=20210112;
h=x-gm-message-state:from:date:to:cc:message-id:subject:mime-version
:list-id;
bh=0dGlzuU7g06SjR54MAC9azlcQdLs6GWjR4AIqnvaIbw=;
b=HjQLpvUsZcDJeYAoDLQVnol7r0+ZBkwoI76x+5POW6+GM3b6h0xPEcUYroC19IlQPi
svQ7G1g94nJI4mtO4ZeeylvEdlX9xtmyZS3MAFFRDdr6qg3UN8dhgh4mY8mxOZD9seJ5
/W4g9PWMsO+fuPBCroGeBMOzywjLxhXoK1gyZFT2L4P0ZtYOTGPYbOS0cSiY8wn7mr0C
P4GU+x+iubFSlfH0uD/SbQtGNu12JnVyKY7gEswOfCxGV6hb4IWBDO6m88ZXtQPAwJey
o7TVgB9m2zVDYG6JfRUKbJsdGlYGM6RSq+ExCISaafGcDlC0+qtgoyI+mykBPraizv+4
GcQA==
X-Gm-Message-State: AJIora/+7WrS4TG/AKklOLkVeFIdiUhGEjpmUxAo9rm3umrI67Sa5m6O
gJ/ZWX/ELuTdTaMlsAJ/r6keeA==
X-Google-Smtp-Source: AGRyM1s2SBBko519Zfln9WPhaDxhT36i042sc+MlemAtcPSTuTwET6jYIR1kByCNdj12Ni5ufNrB9w==
X-Received: by 2002:a7b:c450:0:b0:3a3:2121:c690 with SMTP id
l16-20020a7bc450000000b003a32121c690mr9520353wmi.99.1658434380135;
Thu, 21 Jul 2022 13:13:00 -0700 (PDT)
Received: from jenkins.jenkins (ci.linaro.org. [88.99.136.175])
by smtp.gmail.com with ESMTPSA id
e10-20020adfe7ca000000b0021dbaa4f38dsm3519093wrn.18.2022.07.21.13.12.59
(version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256);
Thu, 21 Jul 2022 13:12:59 -0700 (PDT)
From: ci_notify@linaro.org
X-Google-Original-From: linaro-infrastructure-errors@lists.linaro.org
Date: Thu, 21 Jul 2022 20:12:57 +0000 (UTC)
To: Richard Biener <rguenther@suse.de>
Cc: gcc-regression@gcc.gnu.org
Message-ID: <2000386721.2106.1658434379326@jenkins.jenkins>
Subject: [TCWG CI] Regression caused by gcc: Teach VN about masked/len stores
MIME-Version: 1.0
X-Jenkins-Job: TCWG Bisect tcwg_gnu_native_build/master-arm
X-Jenkins-Result: SUCCESS
X-Spam-Status: No, score=-13.5 required=5.0 tests=BAYES_00, DKIM_SIGNED,
DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_LOTSOFHASH,
KAM_SHORT, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS,
TXREP autolearn=ham autolearn_force=no version=3.4.6
X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on
server2.sourceware.org
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 7bit
X-Content-Filtered-By: Mailman/MimeDel 2.1.29
X-BeenThere: gcc-regression@gcc.gnu.org
X-Mailman-Version: 2.1.29
Precedence: list
List-Id: Gcc-regression mailing list <gcc-regression.gcc.gnu.org>
List-Unsubscribe: <https://gcc.gnu.org/mailman/options/gcc-regression>,
<mailto:gcc-regression-request@gcc.gnu.org?subject=unsubscribe>
List-Archive: <https://gcc.gnu.org/pipermail/gcc-regression/>
List-Post: <mailto:gcc-regression@gcc.gnu.org>
List-Help: <mailto:gcc-regression-request@gcc.gnu.org?subject=help>
List-Subscribe: <https://gcc.gnu.org/mailman/listinfo/gcc-regression>,
<mailto:gcc-regression-request@gcc.gnu.org?subject=subscribe>
X-List-Received-Date: Thu, 21 Jul 2022 20:13:05 -0000
[TCWG CI] Regression caused by gcc: Teach VN about masked/len stores:
commit bd9837bc3ca1344c32aef7ba9f8fa1785063132e
Author: Richard Biener <rguenther@suse.de>
Teach VN about masked/len stores
Results regressed to
# reset_artifacts:
-10
# true:
0
# build_abe binutils:
1
# build_abe gcc:
2
# build_abe linux:
4
# First few build errors in logs:
# 00:02:21 crypt_util.c:607:1: internal compiler error: Segmentation fault
# 00:02:21 crypt_util.c:607:1: internal compiler error: Segmentation fault
# 00:02:21 make[2]: *** [../o-iterator.mk:9: /home/tcwg-buildslave/workspace/tcwg_gnu_13/abe/builds/armv8l-unknown-linux-gnueabihf/armv8l-unknown-linux-gnueabihf/glibc-glibc.git~master/crypt/crypt_util.o] Error 1
# 00:02:21 make[2]: *** [../o-iterator.mk:9: /home/tcwg-buildslave/workspace/tcwg_gnu_13/abe/builds/armv8l-unknown-linux-gnueabihf/armv8l-unknown-linux-gnueabihf/glibc-glibc.git~master/crypt/crypt_util.os] Error 1
# 00:02:21 make[1]: *** [Makefile:484: crypt/others] Error 2
# 00:02:21 make: *** [Makefile:9: all] Error 2
from
# reset_artifacts:
-10
# true:
0
# build_abe binutils:
1
# build_abe gcc:
2
# build_abe linux:
4
# build_abe glibc:
5
# build_abe gdb:
6
THIS IS THE END OF INTERESTING STUFF. BELOW ARE LINKS TO BUILDS, REPRODUCTION INSTRUCTIONS, AND THE RAW COMMIT.
This commit has regressed these CI configurations:
- tcwg_gnu_native_build/master-arm
First_bad build: https://ci.linaro.org/job/tcwg_gnu_native_build-bisect-master-arm/11/artifact/artifacts/build-bd9837bc3ca1344c32aef7ba9f8fa1785063132e/
Last_good build: https://ci.linaro.org/job/tcwg_gnu_native_build-bisect-master-arm/11/artifact/artifacts/build-f4ed610d02aaf8cfcdcb5cf03e0cde65f1f5f890/
Baseline build: https://ci.linaro.org/job/tcwg_gnu_native_build-bisect-master-arm/11/artifact/artifacts/build-baseline/
Even more details: https://ci.linaro.org/job/tcwg_gnu_native_build-bisect-master-arm/11/artifact/artifacts/
Reproduce builds:
<cut>
mkdir investigate-gcc-bd9837bc3ca1344c32aef7ba9f8fa1785063132e
cd investigate-gcc-bd9837bc3ca1344c32aef7ba9f8fa1785063132e
# Fetch scripts
git clone https://git.linaro.org/toolchain/jenkins-scripts
# Fetch manifests and test.sh script
mkdir -p artifacts/manifests
curl -o artifacts/manifests/build-baseline.sh https://ci.linaro.org/job/tcwg_gnu_native_build-bisect-master-arm/11/artifact/artifacts/manifests/build-baseline.sh --fail
curl -o artifacts/manifests/build-parameters.sh https://ci.linaro.org/job/tcwg_gnu_native_build-bisect-master-arm/11/artifact/artifacts/manifests/build-parameters.sh --fail
curl -o artifacts/test.sh https://ci.linaro.org/job/tcwg_gnu_native_build-bisect-master-arm/11/artifact/artifacts/test.sh --fail
chmod +x artifacts/test.sh
# Reproduce the baseline build (build all pre-requisites)
./jenkins-scripts/tcwg_gnu-build.sh @@ artifacts/manifests/build-baseline.sh
# Save baseline build state (which is then restored in artifacts/test.sh)
mkdir -p ./bisect
rsync -a --del --delete-excluded --exclude /bisect/ --exclude /artifacts/ --exclude /gcc/ ./ ./bisect/baseline/
cd gcc
# Reproduce first_bad build
git checkout --detach bd9837bc3ca1344c32aef7ba9f8fa1785063132e
../artifacts/test.sh
# Reproduce last_good build
git checkout --detach f4ed610d02aaf8cfcdcb5cf03e0cde65f1f5f890
../artifacts/test.sh
cd ..
</cut>
Full commit (up to 1000 lines):
<cut>
commit bd9837bc3ca1344c32aef7ba9f8fa1785063132e
Author: Richard Biener <rguenther@suse.de>
Date: Wed Jul 20 12:28:26 2022 +0200
Teach VN about masked/len stores
The following teaches VN to handle reads from .MASK_STORE and
.LEN_STORE. For this push_partial_def is extended first for
convenience so we don't have to handle the full def case in the
caller (possibly other paths can be simplified then). Also
the partial definition stored value can have an offset applied
so we don't have to build a fake RHS when we register the pieces
of an existing store.
PR tree-optimization/106365
* tree-ssa-sccvn.cc (pd_data::rhs_off): New field determining
the offset to start encoding of RHS from.
(vn_walk_cb_data::vn_walk_cb_data): Initialize it.
(vn_walk_cb_data::push_partial_def): Allow the first partial
definition to be fully providing the def. Offset RHS
before encoding if requested.
(vn_reference_lookup_3): Initialize def_rhs everywhere.
Add support for .MASK_STORE and .LEN_STORE (partial) definitions.
* gcc.target/i386/vec-maskstore-vn.c: New testcase.
---
gcc/testsuite/gcc.target/i386/vec-maskstore-vn.c | 30 +++
gcc/tree-ssa-sccvn.cc | 255 ++++++++++++++++++-----
2 files changed, 228 insertions(+), 57 deletions(-)
diff --git a/gcc/testsuite/gcc.target/i386/vec-maskstore-vn.c b/gcc/testsuite/gcc.target/i386/vec-maskstore-vn.c
new file mode 100644
index 00000000000..98213905ece
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/vec-maskstore-vn.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+/* { dg-options "-O3 -mavx2 -fdump-tree-fre5" } */
+
+void __attribute__((noinline,noclone))
+foo (int *out, int *res)
+{
+ int mask[] = { 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1 };
+ int i;
+ for (i = 0; i < 16; ++i)
+ {
+ if (mask[i])
+ out[i] = i;
+ }
+ int o0 = out[0];
+ int o7 = out[7];
+ int o14 = out[14];
+ int o15 = out[15];
+ res[0] = o0;
+ res[2] = o7;
+ res[4] = o14;
+ res[6] = o15;
+}
+
+/* Vectorization produces .MASK_STORE, unrolling will unroll the two
+ vector iterations. FRE5 after that should be able to CSE
+ out[7] and out[15], but leave out[0] and out[14] alone. */
+/* { dg-final { scan-tree-dump " = o0_\[0-9\]+;" "fre5" } } */
+/* { dg-final { scan-tree-dump " = 7;" "fre5" } } */
+/* { dg-final { scan-tree-dump " = o14_\[0-9\]+;" "fre5" } } */
+/* { dg-final { scan-tree-dump " = 15;" "fre5" } } */
diff --git a/gcc/tree-ssa-sccvn.cc b/gcc/tree-ssa-sccvn.cc
index f41d5031365..7d947b55a27 100644
--- a/gcc/tree-ssa-sccvn.cc
+++ b/gcc/tree-ssa-sccvn.cc
@@ -1790,6 +1790,7 @@ struct pd_range
struct pd_data
{
tree rhs;
+ HOST_WIDE_INT rhs_off;
HOST_WIDE_INT offset;
HOST_WIDE_INT size;
};
@@ -1816,6 +1817,7 @@ struct vn_walk_cb_data
unsigned int pos = 0, prec = w.get_precision ();
pd_data pd;
pd.rhs = build_constructor (NULL_TREE, NULL);
+ pd.rhs_off = 0;
/* When bitwise and with a constant is done on a memory load,
we don't really need all the bits to be defined or defined
to constants, we don't really care what is in the position
@@ -1976,6 +1978,7 @@ vn_walk_cb_data::push_partial_def (pd_data pd,
bool pd_constant_p = (TREE_CODE (pd.rhs) == CONSTRUCTOR
|| CONSTANT_CLASS_P (pd.rhs));
+ pd_range *r;
if (partial_defs.is_empty ())
{
/* If we get a clobber upfront, fail. */
@@ -1989,65 +1992,70 @@ vn_walk_cb_data::push_partial_def (pd_data pd,
first_set = set;
first_base_set = base_set;
last_vuse_ptr = NULL;
- /* Continue looking for partial defs. */
- return NULL;
- }
-
- if (!known_ranges)
- {
- /* ??? Optimize the case where the 2nd partial def completes things. */
- gcc_obstack_init (&ranges_obstack);
- known_ranges = splay_tree_new_with_allocator (pd_range_compare, 0, 0,
- pd_tree_alloc,
- pd_tree_dealloc, this);
- splay_tree_insert (known_ranges,
- (splay_tree_key)&first_range.offset,
- (splay_tree_value)&first_range);
- }
-
- pd_range newr = { pd.offset, pd.size };
- splay_tree_node n;
- pd_range *r;
- /* Lookup the predecessor of offset + 1 and see if we need to merge. */
- HOST_WIDE_INT loffset = newr.offset + 1;
- if ((n = splay_tree_predecessor (known_ranges, (splay_tree_key)&loffset))
- && ((r = (pd_range *)n->value), true)
- && ranges_known_overlap_p (r->offset, r->size + 1,
- newr.offset, newr.size))
- {
- /* Ignore partial defs already covered. Here we also drop shadowed
- clobbers arriving here at the floor. */
- if (known_subrange_p (newr.offset, newr.size, r->offset, r->size))
- return NULL;
- r->size = MAX (r->offset + r->size, newr.offset + newr.size) - r->offset;
+ r = &first_range;
+ /* Go check if the first partial definition was a full one in case
+ the caller didn't optimize for this. */
}
else
{
- /* newr.offset wasn't covered yet, insert the range. */
- r = XOBNEW (&ranges_obstack, pd_range);
- *r = newr;
- splay_tree_insert (known_ranges, (splay_tree_key)&r->offset,
- (splay_tree_value)r);
- }
- /* Merge r which now contains newr and is a member of the splay tree with
- adjacent overlapping ranges. */
- pd_range *rafter;
- while ((n = splay_tree_successor (known_ranges, (splay_tree_key)&r->offset))
- && ((rafter = (pd_range *)n->value), true)
- && ranges_known_overlap_p (r->offset, r->size + 1,
- rafter->offset, rafter->size))
- {
- r->size = MAX (r->offset + r->size,
- rafter->offset + rafter->size) - r->offset;
- splay_tree_remove (known_ranges, (splay_tree_key)&rafter->offset);
- }
- /* If we get a clobber, fail. */
- if (TREE_CLOBBER_P (pd.rhs))
- return (void *)-1;
- /* Non-constants are OK as long as they are shadowed by a constant. */
- if (!pd_constant_p)
- return (void *)-1;
- partial_defs.safe_push (pd);
+ if (!known_ranges)
+ {
+ /* ??? Optimize the case where the 2nd partial def completes
+ things. */
+ gcc_obstack_init (&ranges_obstack);
+ known_ranges = splay_tree_new_with_allocator (pd_range_compare, 0, 0,
+ pd_tree_alloc,
+ pd_tree_dealloc, this);
+ splay_tree_insert (known_ranges,
+ (splay_tree_key)&first_range.offset,
+ (splay_tree_value)&first_range);
+ }
+
+ pd_range newr = { pd.offset, pd.size };
+ splay_tree_node n;
+ /* Lookup the predecessor of offset + 1 and see if we need to merge. */
+ HOST_WIDE_INT loffset = newr.offset + 1;
+ if ((n = splay_tree_predecessor (known_ranges, (splay_tree_key)&loffset))
+ && ((r = (pd_range *)n->value), true)
+ && ranges_known_overlap_p (r->offset, r->size + 1,
+ newr.offset, newr.size))
+ {
+ /* Ignore partial defs already covered. Here we also drop shadowed
+ clobbers arriving here at the floor. */
+ if (known_subrange_p (newr.offset, newr.size, r->offset, r->size))
+ return NULL;
+ r->size
+ = MAX (r->offset + r->size, newr.offset + newr.size) - r->offset;
+ }
+ else
+ {
+ /* newr.offset wasn't covered yet, insert the range. */
+ r = XOBNEW (&ranges_obstack, pd_range);
+ *r = newr;
+ splay_tree_insert (known_ranges, (splay_tree_key)&r->offset,
+ (splay_tree_value)r);
+ }
+ /* Merge r which now contains newr and is a member of the splay tree with
+ adjacent overlapping ranges. */
+ pd_range *rafter;
+ while ((n = splay_tree_successor (known_ranges,
+ (splay_tree_key)&r->offset))
+ && ((rafter = (pd_range *)n->value), true)
+ && ranges_known_overlap_p (r->offset, r->size + 1,
+ rafter->offset, rafter->size))
+ {
+ r->size = MAX (r->offset + r->size,
+ rafter->offset + rafter->size) - r->offset;
+ splay_tree_remove (known_ranges, (splay_tree_key)&rafter->offset);
+ }
+ /* If we get a clobber, fail. */
+ if (TREE_CLOBBER_P (pd.rhs))
+ return (void *)-1;
+ /* Non-constants are OK as long as they are shadowed by a constant. */
+ if (!pd_constant_p)
+ return (void *)-1;
+ partial_defs.safe_push (pd);
+ }
/* Now we have merged newr into the range tree. When we have covered
[offseti, sizei] then the tree will contain exactly one node which has
@@ -2081,7 +2089,8 @@ vn_walk_cb_data::push_partial_def (pd_data pd,
else
{
len = native_encode_expr (pd.rhs, this_buffer, bufsize,
- MAX (0, -pd.offset) / BITS_PER_UNIT);
+ (MAX (0, -pd.offset)
+ + pd.rhs_off) / BITS_PER_UNIT);
if (len <= 0
|| len < (ROUND_UP (pd.size, BITS_PER_UNIT) / BITS_PER_UNIT
- MAX (0, -pd.offset) / BITS_PER_UNIT))
@@ -2906,6 +2915,7 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *data_,
{
pd_data pd;
pd.rhs = build_constructor (NULL_TREE, NULL);
+ pd.rhs_off = 0;
pd.offset = offset2i;
pd.size = leni << LOG2_BITS_PER_UNIT;
return data->push_partial_def (pd, 0, 0, offseti, maxsizei);
@@ -2955,6 +2965,7 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *data_,
by a later def. */
pd_data pd;
pd.rhs = gimple_assign_rhs1 (def_stmt);
+ pd.rhs_off = 0;
pd.offset = offset2i;
pd.size = size2i;
return data->push_partial_def (pd, ao_ref_alias_set (&lhs_ref),
@@ -3107,6 +3118,7 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *data_,
if (TREE_CODE (rhs) == SSA_NAME)
rhs = SSA_VAL (rhs);
pd.rhs = rhs;
+ pd.rhs_off = 0;
pd.offset = offset2i;
pd.size = size2i;
return data->push_partial_def (pd, ao_ref_alias_set (&lhs_ref),
@@ -3186,6 +3198,7 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *data_,
{
pd_data pd;
pd.rhs = SSA_VAL (def_rhs);
+ pd.rhs_off = 0;
pd.offset = offset2i;
pd.size = size2i;
return data->push_partial_def (pd, ao_ref_alias_set (&lhs_ref),
@@ -3195,6 +3208,133 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *data_,
}
}
+ /* 4b) Assignment done via one of the vectorizer internal store
+ functions where we may be able to access pieces from or we can
+ combine to a larger entity. */
+ else if (known_eq (ref->size, maxsize)
+ && is_gimple_reg_type (vr->type)
+ && !reverse_storage_order_for_component_p (vr->operands)
+ && !contains_storage_order_barrier_p (vr->operands)
+ && is_gimple_call (def_stmt)
+ && gimple_call_internal_p (def_stmt)
+ && internal_store_fn_p (gimple_call_internal_fn (def_stmt)))
+ {
+ gcall *call = as_a <gcall *> (def_stmt);
+ internal_fn fn = gimple_call_internal_fn (call);
+ tree def_rhs = gimple_call_arg (call,
+ internal_fn_stored_value_index (fn));
+ def_rhs = vn_valueize (def_rhs);
+ if (TREE_CODE (def_rhs) != VECTOR_CST)
+ return (void *)-1;
+
+ tree mask = NULL_TREE, len = NULL_TREE, bias = NULL_TREE;
+ switch (fn)
+ {
+ case IFN_MASK_STORE:
+ mask = gimple_call_arg (call, internal_fn_mask_index (fn));
+ mask = vn_valueize (mask);
+ if (TREE_CODE (mask) != VECTOR_CST)
+ return (void *)-1;
+ break;
+ case IFN_LEN_STORE:
+ len = gimple_call_arg (call, 2);
+ bias = gimple_call_arg (call, 4);
+ if (!tree_fits_uhwi_p (len) || !tree_fits_shwi_p (bias))
+ return (void *)-1;
+ break;
+ default:
+ return (void *)-1;
+ }
+ ao_ref_init_from_ptr_and_size (&lhs_ref,
+ vn_valueize (gimple_call_arg (call, 0)),
+ TYPE_SIZE_UNIT (TREE_TYPE (def_rhs)));
+ tree base2;
+ poly_int64 offset2, size2, maxsize2;
+ HOST_WIDE_INT offset2i, size2i, offseti;
+ base2 = ao_ref_base (&lhs_ref);
+ offset2 = lhs_ref.offset;
+ size2 = lhs_ref.size;
+ maxsize2 = lhs_ref.max_size;
+ if (known_size_p (maxsize2)
+ && known_eq (maxsize2, size2)
+ && adjust_offsets_for_equal_base_address (base, &offset,
+ base2, &offset2)
+ && maxsize.is_constant (&maxsizei)
+ && offset.is_constant (&offseti)
+ && offset2.is_constant (&offset2i)
+ && size2.is_constant (&size2i))
+ {
+ if (!ranges_maybe_overlap_p (offset, maxsize, offset2, size2))
+ /* Poor-mans disambiguation. */
+ return NULL;
+ else if (ranges_known_overlap_p (offset, maxsize, offset2, size2))
+ {
+ pd_data pd;
+ pd.rhs = def_rhs;
+ tree aa = gimple_call_arg (call, 1);
+ alias_set_type set = get_deref_alias_set (TREE_TYPE (aa));
+ tree vectype = TREE_TYPE (def_rhs);
+ unsigned HOST_WIDE_INT elsz
+ = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (vectype)));
+ if (mask)
+ {
+ HOST_WIDE_INT start = 0, len = 0;
+ unsigned mask_idx = 0;
+ do
+ {
+ if (integer_zerop (VECTOR_CST_ELT (mask, mask_idx)))
+ {
+ if (len != 0)
+ {
+ pd.rhs_off = start;
+ pd.offset = offset2i + start;
+ pd.size = len;
+ if (ranges_known_overlap_p
+ (offset, maxsize, pd.offset, pd.size))
+ {
+ void *res = data->push_partial_def
+ (pd, set, set, offseti, maxsizei);
+ if (res != NULL)
+ return res;
+ }
+ }
+ start = (mask_idx + 1) * elsz;
+ len = 0;
+ }
+ else
+ len += elsz;
+ mask_idx++;
+ }
+ while (known_lt (mask_idx, TYPE_VECTOR_SUBPARTS (vectype)));
+ if (len != 0)
+ {
+ pd.rhs_off = start;
+ pd.offset = offset2i + start;
+ pd.size = len;
+ if (ranges_known_overlap_p (offset, maxsize,
+ pd.offset, pd.size))
+ return data->push_partial_def (pd, set, set,
+ offseti, maxsizei);
+ }
+ }
+ else if (fn == IFN_LEN_STORE)
+ {
+ pd.rhs_off = 0;
+ pd.offset = offset2i;
+ pd.size = (tree_to_uhwi (len)
+ + -tree_to_shwi (bias)) * BITS_PER_UNIT;
+ if (ranges_known_overlap_p (offset, maxsize,
+ pd.offset, pd.size))
+ return data->push_partial_def (pd, set, set,
+ offseti, maxsizei);
+ }
+ else
+ gcc_unreachable ();
+ return NULL;
+ }
+ }
+ }
+
/* 5) For aggregate copies translate the reference through them if
the copy kills ref. */
else if (data->vn_walk_kind == VN_WALKREWRITE
@@ -3327,6 +3467,7 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *data_,
{
pd_data pd;
pd.rhs = val;
+ pd.rhs_off = 0;
pd.offset = 0;
pd.size = maxsizei;
return data->push_partial_def (pd, ao_ref_alias_set (&lhs_ref),
</cut>
>From hjl@sc.intel.com Thu Jul 21 23:51:43 2022
Return-Path: <hjl@sc.intel.com>
X-Original-To: gcc-regression@gcc.gnu.org
Delivered-To: gcc-regression@gcc.gnu.org
Received: from mga14.intel.com (mga14.intel.com [192.55.52.115])
by sourceware.org (Postfix) with ESMTPS id E526D3835839
for <gcc-regression@gcc.gnu.org>; Thu, 21 Jul 2022 23:51:42 +0000 (GMT)
DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org E526D3835839
X-IronPort-AV: E=McAfee;i="6400,9594,10415"; a="287202289"
X-IronPort-AV: E=Sophos;i="5.93,184,1654585200"; d="scan'208";a="287202289"
Received: from fmsmga007.fm.intel.com ([10.253.24.52])
by fmsmga103.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384;
21 Jul 2022 16:51:25 -0700
X-ExtLoop1: 1
X-IronPort-AV: E=Sophos;i="5.93,184,1654585200"; d="scan'208";a="602490863"
Received: from scymds01.sc.intel.com ([10.148.94.138])
by fmsmga007.fm.intel.com with ESMTP; 21 Jul 2022 16:51:25 -0700
Received: from gnu-clx-1.sc.intel.com (gnu-clx-1.sc.intel.com [172.25.70.216])
by scymds01.sc.intel.com with ESMTP id 26LNpPsA007953;
Thu, 21 Jul 2022 16:51:25 -0700
Received: by gnu-clx-1.sc.intel.com (Postfix, from userid 1000)
id 4F8A93E001E; Thu, 21 Jul 2022 16:51:25 -0700 (PDT)
Date: Thu, 21 Jul 2022 16:51:25 -0700
To: skpgkp2@gmail.com, hjl.tools@gmail.com, gcc-regression@gcc.gnu.org
Subject: Regressions on native/master at commit r13-1786 vs commit
r13-1780 on Linux/x86_64
User-Agent: Heirloom mailx 12.5 7/5/10
MIME-Version: 1.0
Content-Type: text/plain; charset=us-ascii
Content-Transfer-Encoding: 7bit
Message-Id: <20220721235125.4F8A93E001E@gnu-clx-1.sc.intel.com>
From: "H. J. Lu" <hjl@sc.intel.com>
X-Spam-Status: No, score=-3459.2 required=5.0 tests=BAYES_00, KAM_DMARC_STATUS,
KAM_LAZY_DOMAIN_SECURITY, KAM_NUMSUBJECT, SPF_HELO_NONE, SPF_NONE,
TXREP autolearn=no autolearn_force=no version=3.4.6
X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on
server2.sourceware.org
X-BeenThere: gcc-regression@gcc.gnu.org
X-Mailman-Version: 2.1.29
Precedence: list
List-Id: Gcc-regression mailing list <gcc-regression.gcc.gnu.org>
List-Unsubscribe: <https://gcc.gnu.org/mailman/options/gcc-regression>,
<mailto:gcc-regression-request@gcc.gnu.org?subject=unsubscribe>
List-Archive: <https://gcc.gnu.org/pipermail/gcc-regression/>
List-Post: <mailto:gcc-regression@gcc.gnu.org>
List-Help: <mailto:gcc-regression-request@gcc.gnu.org?subject=help>
List-Subscribe: <https://gcc.gnu.org/mailman/listinfo/gcc-regression>,
<mailto:gcc-regression-request@gcc.gnu.org?subject=subscribe>
X-List-Received-Date: Thu, 21 Jul 2022 23:51:44 -0000
New failures:
FAIL: gcc.dg/analyzer/stdarg-3.c (test for excess errors)
FAIL: gcc.dg/analyzer/stdarg-3.c (test for excess errors)
FAIL: gcc.dg/analyzer/stdarg-3.c (test for excess errors)
New passes:
reply other threads:[~2022-07-21 16:54 UTC|newest]
Thread overview: [no followups] expand[flat|nested] mbox.gz Atom feed
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=279373770.2069.1658422483393@jenkins.jenkins \
--to=ci_notify@linaro.org \
--cc=gcc-regression@gcc.gnu.org \
--cc=rguenther@suse.de \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).