linaro-toolchain

linaro-toolchain@lists.linaro.org

4 participants
5604 discussions

[CI-NOTIFY]: TCWG Bisect tcwg_bmk_tx1/gnu-master-aarch64-spec2k6-O3_LTO - Build # 16 - Successful!

by ci_notify＠linaro.org

Successfully identified regression in *gcc* in CI configuration tcwg_bmk_gnu_tx1/gnu-master-aarch64-spec2k6-O3_LTO. So far, this commit has regressed CI configurations: - tcwg_bmk_gnu_tx1/gnu-master-aarch64-spec2k6-O3_LTO Culprit: <cut> commit 39ed6a88c74db5412652f0167d03f71eca4f02fc Author: Ian Lance Taylor <iant(a)golang.org> Date: Tue May 18 18:28:17 2021 -0700 libgo: use Windows line endings in testwinsignal </cut> Results regressed to (for first_bad == 39ed6a88c74db5412652f0167d03f71eca4f02fc) # reset_artifacts: -10 # build_abe binutils: -9 # build_abe stage1 -- --set gcc_override_configure=--disable-libsanitizer: -8 # build_abe linux: -7 # build_abe glibc: -6 # build_abe stage2 -- --set gcc_override_configure=--disable-libsanitizer: -5 # true: 0 # benchmark -O3_LTO -- artifacts/build-39ed6a88c74db5412652f0167d03f71eca4f02fc/results_id: 1 # 453.povray,povray_base.default regressed by 103 from (for last_good == 01b2864757540d24c4e717a77b40b29369c064b2) # reset_artifacts: -10 # build_abe binutils: -9 # build_abe stage1 -- --set gcc_override_configure=--disable-libsanitizer: -8 # build_abe linux: -7 # build_abe glibc: -6 # build_abe stage2 -- --set gcc_override_configure=--disable-libsanitizer: -5 # true: 0 # benchmark -O3_LTO -- artifacts/build-01b2864757540d24c4e717a77b40b29369c064b2/results_id: 1 Artifacts of last_good build: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tx1-gnu-master-aa… Results ID of last_good: tx1_64/tcwg_bmk_gnu_tx1/bisect-gnu-master-aarch64-spec2k6-O3_LTO/1130 Artifacts of first_bad build: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tx1-gnu-master-aa… Results ID of first_bad: tx1_64/tcwg_bmk_gnu_tx1/bisect-gnu-master-aarch64-spec2k6-O3_LTO/1096 Build top page/logs: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tx1-gnu-master-aa… Configuration details: Reproduce builds: <cut> mkdir investigate-gcc-39ed6a88c74db5412652f0167d03f71eca4f02fc cd investigate-gcc-39ed6a88c74db5412652f0167d03f71eca4f02fc git clone https://git.linaro.org/toolchain/jenkins-scripts mkdir -p artifacts/manifests curl -o artifacts/manifests/build-baseline.sh https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tx1-gnu-master-aa… --fail curl -o artifacts/manifests/build-parameters.sh https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tx1-gnu-master-aa… --fail curl -o artifacts/test.sh https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tx1-gnu-master-aa… --fail chmod +x artifacts/test.sh # Reproduce the baseline build (build all pre-requisites) ./jenkins-scripts/tcwg_bmk-build.sh @@ artifacts/manifests/build-baseline.sh cd gcc # Reproduce first_bad build git checkout --detach 39ed6a88c74db5412652f0167d03f71eca4f02fc ../artifacts/test.sh # Reproduce last_good build git checkout --detach 01b2864757540d24c4e717a77b40b29369c064b2 ../artifacts/test.sh cd .. </cut> History of pending regressions and results: https://git.linaro.org/toolchain/ci/base-artifacts.git/log/?h=linaro-local/… Artifacts: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tx1-gnu-master-aa… Build log: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tx1-gnu-master-aa… Full commit (up to 1000 lines): <cut> commit 39ed6a88c74db5412652f0167d03f71eca4f02fc Author: Ian Lance Taylor <iant(a)golang.org> Date: Tue May 18 18:28:17 2021 -0700 libgo: use Windows line endings in testwinsignal --- libgo/go/runtime/testdata/testwinsignal/main.go | 38 ++++++++++++------------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/libgo/go/runtime/testdata/testwinsignal/main.go b/libgo/go/runtime/testdata/testwinsignal/main.go index 1e7c9475fd6..d8cd884ffac 100644 --- a/libgo/go/runtime/testdata/testwinsignal/main.go +++ b/libgo/go/runtime/testdata/testwinsignal/main.go @@ -1,19 +1,19 @@ -package main - -import ( - "fmt" - "os" - "os/signal" - "time" -) - -func main() { - c := make(chan os.Signal, 1) - signal.Notify(c) - - fmt.Println("ready") - sig := <-c - - time.Sleep(time.Second) - fmt.Println(sig) -} +package main + +import ( + "fmt" + "os" + "os/signal" + "time" +) + +func main() { + c := make(chan os.Signal, 1) + signal.Notify(c) + + fmt.Println("ready") + sig := <-c + + time.Sleep(time.Second) + fmt.Println(sig) +} </cut>

4 years

[CI-NOTIFY]: TCWG Bisect tcwg_bmk_tx1/llvm-release-aarch64-spec2k6-O2 - Build # 9 - Fixed!

by ci_notify＠linaro.org

Successfully identified regression in *llvm* in CI configuration tcwg_bmk_llvm_tx1/llvm-release-aarch64-spec2k6-O2. So far, this commit has regressed CI configurations: - tcwg_bmk_llvm_tx1/llvm-release-aarch64-spec2k6-O2 Culprit: <cut> commit e00f189d392dd9bf95f6a98f05f2d341d06cd65c Author: Roman Lebedev <lebedev.ri(a)gmail.com> Date: Mon Oct 5 22:35:59 2020 +0300 [InstCombine] Revert rL226781 "Teach InstCombine to canonicalize loads which are only ever stored to always use a legal integer type if one is available." (PR47592) (it was introduced in https://lists.llvm.org/pipermail/llvm-dev/2015-January/080956.html) This canonicalization seems dubious. Most importantly, while it does not create `inttoptr` casts by itself, it may cause them to appear later, see e.g. D88788. I think it's pretty obvious that it is an undesirable outcome, by now we've established that seemingly no-op `inttoptr`/`ptrtoint` casts are not no-op, and are no longer eager to look past them. Which e.g. means that given ``` %a = load i32 %b = inttoptr %a %c = inttoptr %a ``` we likely won't be able to tell that `%b` and `%c` is the same thing. As we can see in D88789 / D88788 / D88806 / D75505, we can't really teach SCEV about this (not without the https://bugs.llvm.org/show_bug.cgi?id=47592 at least) And we can't recover the situation post-inlining in instcombine. So it really does look like this fold is actively breaking otherwise-good IR, in a way that is not recoverable. And that means, this fold isn't helpful in exposing the passes that are otherwise unaware of these patterns it produces. Thusly, i propose to simply not perform such a canonicalization. The original motivational RFC does not state what larger problem that canonicalization was trying to solve, so i'm not sure how this plays out in the larger picture. On vanilla llvm test-suite + RawSpeed, this results in increase of asm instructions and final object size by ~+0.05% decreases final count of bitcasts by -4.79% (-28990), ptrtoint casts by -15.41% (-3423), and of inttoptr casts by -25.59% (-6919, *sic*). Overall, there's -0.04% less IR blocks, -0.39% instructions. See https://bugs.llvm.org/show_bug.cgi?id=47592 Differential Revision: https://reviews.llvm.org/D88789 </cut> Results regressed to (for first_bad == e00f189d392dd9bf95f6a98f05f2d341d06cd65c) # reset_artifacts: -10 # build_abe binutils: -9 # build_abe stage1 -- --set gcc_override_configure=--disable-libsanitizer: -8 # build_abe linux: -7 # build_abe glibc: -6 # build_abe stage2 -- --set gcc_override_configure=--disable-libsanitizer: -5 # build_llvm true: -3 # true: 0 # benchmark -O2 -- artifacts/build-e00f189d392dd9bf95f6a98f05f2d341d06cd65c/results_id: 1 # 470.lbm,lbm_base.default regressed by 111 # 470.lbm,[.] LBM_performStreamCollide regressed by 111 from (for last_good == 567462b48eba1c2d286ce97117994463f4535d2e) # reset_artifacts: -10 # build_abe binutils: -9 # build_abe stage1 -- --set gcc_override_configure=--disable-libsanitizer: -8 # build_abe linux: -7 # build_abe glibc: -6 # build_abe stage2 -- --set gcc_override_configure=--disable-libsanitizer: -5 # build_llvm true: -3 # true: 0 # benchmark -O2 -- artifacts/build-567462b48eba1c2d286ce97117994463f4535d2e/results_id: 1 Artifacts of last_good build: https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tx1-llvm-release… Results ID of last_good: tx1_64/tcwg_bmk_llvm_tx1/bisect-llvm-release-aarch64-spec2k6-O2/1124 Artifacts of first_bad build: https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tx1-llvm-release… Results ID of first_bad: tx1_64/tcwg_bmk_llvm_tx1/bisect-llvm-release-aarch64-spec2k6-O2/1119 Build top page/logs: https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tx1-llvm-release… Configuration details: Reproduce builds: <cut> mkdir investigate-llvm-e00f189d392dd9bf95f6a98f05f2d341d06cd65c cd investigate-llvm-e00f189d392dd9bf95f6a98f05f2d341d06cd65c git clone https://git.linaro.org/toolchain/jenkins-scripts mkdir -p artifacts/manifests curl -o artifacts/manifests/build-baseline.sh https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tx1-llvm-release… --fail curl -o artifacts/manifests/build-parameters.sh https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tx1-llvm-release… --fail curl -o artifacts/test.sh https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tx1-llvm-release… --fail chmod +x artifacts/test.sh # Reproduce the baseline build (build all pre-requisites) ./jenkins-scripts/tcwg_bmk-build.sh @@ artifacts/manifests/build-baseline.sh cd llvm # Reproduce first_bad build git checkout --detach e00f189d392dd9bf95f6a98f05f2d341d06cd65c ../artifacts/test.sh # Reproduce last_good build git checkout --detach 567462b48eba1c2d286ce97117994463f4535d2e ../artifacts/test.sh cd .. </cut> History of pending regressions and results: https://git.linaro.org/toolchain/ci/base-artifacts.git/log/?h=linaro-local/… Artifacts: https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tx1-llvm-release… Build log: https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tx1-llvm-release… Full commit (up to 1000 lines): <cut> commit e00f189d392dd9bf95f6a98f05f2d341d06cd65c Author: Roman Lebedev <lebedev.ri(a)gmail.com> Date: Mon Oct 5 22:35:59 2020 +0300 [InstCombine] Revert rL226781 "Teach InstCombine to canonicalize loads which are only ever stored to always use a legal integer type if one is available." (PR47592) (it was introduced in https://lists.llvm.org/pipermail/llvm-dev/2015-January/080956.html) This canonicalization seems dubious. Most importantly, while it does not create `inttoptr` casts by itself, it may cause them to appear later, see e.g. D88788. I think it's pretty obvious that it is an undesirable outcome, by now we've established that seemingly no-op `inttoptr`/`ptrtoint` casts are not no-op, and are no longer eager to look past them. Which e.g. means that given ``` %a = load i32 %b = inttoptr %a %c = inttoptr %a ``` we likely won't be able to tell that `%b` and `%c` is the same thing. As we can see in D88789 / D88788 / D88806 / D75505, we can't really teach SCEV about this (not without the https://bugs.llvm.org/show_bug.cgi?id=47592 at least) And we can't recover the situation post-inlining in instcombine. So it really does look like this fold is actively breaking otherwise-good IR, in a way that is not recoverable. And that means, this fold isn't helpful in exposing the passes that are otherwise unaware of these patterns it produces. Thusly, i propose to simply not perform such a canonicalization. The original motivational RFC does not state what larger problem that canonicalization was trying to solve, so i'm not sure how this plays out in the larger picture. On vanilla llvm test-suite + RawSpeed, this results in increase of asm instructions and final object size by ~+0.05% decreases final count of bitcasts by -4.79% (-28990), ptrtoint casts by -15.41% (-3423), and of inttoptr casts by -25.59% (-6919, *sic*). Overall, there's -0.04% less IR blocks, -0.39% instructions. See https://bugs.llvm.org/show_bug.cgi?id=47592 Differential Revision: https://reviews.llvm.org/D88789 --- .../CodeGen/attr-arm-sve-vector-bits-bitcast.c | 18 +++-- clang/test/CodeGen/attr-arm-sve-vector-bits-call.c | 78 ++++++++++------------ clang/test/CodeGen/attr-arm-sve-vector-bits-cast.c | 24 +++---- .../CodeGen/attr-arm-sve-vector-bits-globals.c | 6 +- .../InstCombine/InstCombineLoadStoreAlloca.cpp | 34 ---------- llvm/test/Transforms/InstCombine/atomic.ll | 18 ++--- llvm/test/Transforms/InstCombine/load.ll | 44 ++++++------ .../Transforms/InstCombine/loadstore-metadata.ll | 19 +----- .../InstCombine/non-integral-pointers.ll | 16 ++--- .../PhaseOrdering/instcombine-sroa-inttoptr.ll | 32 ++++----- 10 files changed, 107 insertions(+), 182 deletions(-) diff --git a/clang/test/CodeGen/attr-arm-sve-vector-bits-bitcast.c b/clang/test/CodeGen/attr-arm-sve-vector-bits-bitcast.c index 3a5628d7f57e..5df1e83b13bf 100644 --- a/clang/test/CodeGen/attr-arm-sve-vector-bits-bitcast.c +++ b/clang/test/CodeGen/attr-arm-sve-vector-bits-bitcast.c @@ -255,22 +255,20 @@ svbool_t read_bool(struct struct_bool *s) { // CHECK-256-NEXT: entry: // CHECK-256-NEXT: [[X_ADDR:%.*]] = alloca <vscale x 16 x i1>, align 16 // CHECK-256-NEXT: store <vscale x 16 x i1> [[X:%.*]], <vscale x 16 x i1>* [[X_ADDR]], align 16, [[TBAA15:!tbaa !.*]] -// CHECK-256-NEXT: [[TMP0:%.*]] = bitcast <vscale x 16 x i1>* [[X_ADDR]] to i32* -// CHECK-256-NEXT: [[TMP1:%.*]] = load i32, i32* [[TMP0]], align 16, [[TBAA6]] -// CHECK-256-NEXT: [[Y:%.*]] = getelementptr inbounds [[STRUCT_STRUCT_BOOL:%.*]], %struct.struct_bool* [[S:%.*]], i64 0, i32 1 -// CHECK-256-NEXT: [[TMP2:%.*]] = bitcast [3 x <4 x i8>]* [[Y]] to i32* -// CHECK-256-NEXT: store i32 [[TMP1]], i32* [[TMP2]], align 2, [[TBAA6]] +// CHECK-256-NEXT: [[TMP0:%.*]] = bitcast <vscale x 16 x i1>* [[X_ADDR]] to <4 x i8>* +// CHECK-256-NEXT: [[TMP1:%.*]] = load <4 x i8>, <4 x i8>* [[TMP0]], align 16, [[TBAA6]] +// CHECK-256-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds [[STRUCT_STRUCT_BOOL:%.*]], %struct.struct_bool* [[S:%.*]], i64 0, i32 1, i64 0 +// CHECK-256-NEXT: store <4 x i8> [[TMP1]], <4 x i8>* [[ARRAYIDX]], align 2, [[TBAA6]] // CHECK-256-NEXT: ret void // // CHECK-512-LABEL: @write_bool( // CHECK-512-NEXT: entry: // CHECK-512-NEXT: [[X_ADDR:%.*]] = alloca <vscale x 16 x i1>, align 16 // CHECK-512-NEXT: store <vscale x 16 x i1> [[X:%.*]], <vscale x 16 x i1>* [[X_ADDR]], align 16, [[TBAA15:!tbaa !.*]] -// CHECK-512-NEXT: [[TMP0:%.*]] = bitcast <vscale x 16 x i1>* [[X_ADDR]] to i64* -// CHECK-512-NEXT: [[TMP1:%.*]] = load i64, i64* [[TMP0]], align 16, [[TBAA6]] -// CHECK-512-NEXT: [[Y:%.*]] = getelementptr inbounds [[STRUCT_STRUCT_BOOL:%.*]], %struct.struct_bool* [[S:%.*]], i64 0, i32 1 -// CHECK-512-NEXT: [[TMP2:%.*]] = bitcast [3 x <8 x i8>]* [[Y]] to i64* -// CHECK-512-NEXT: store i64 [[TMP1]], i64* [[TMP2]], align 2, [[TBAA6]] +// CHECK-512-NEXT: [[TMP0:%.*]] = bitcast <vscale x 16 x i1>* [[X_ADDR]] to <8 x i8>* +// CHECK-512-NEXT: [[TMP1:%.*]] = load <8 x i8>, <8 x i8>* [[TMP0]], align 16, [[TBAA6]] +// CHECK-512-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds [[STRUCT_STRUCT_BOOL:%.*]], %struct.struct_bool* [[S:%.*]], i64 0, i32 1, i64 0 +// CHECK-512-NEXT: store <8 x i8> [[TMP1]], <8 x i8>* [[ARRAYIDX]], align 2, [[TBAA6]] // CHECK-512-NEXT: ret void // void write_bool(struct struct_bool *s, svbool_t x) { diff --git a/clang/test/CodeGen/attr-arm-sve-vector-bits-call.c b/clang/test/CodeGen/attr-arm-sve-vector-bits-call.c index 5442d58e96be..13979197999e 100644 --- a/clang/test/CodeGen/attr-arm-sve-vector-bits-call.c +++ b/clang/test/CodeGen/attr-arm-sve-vector-bits-call.c @@ -169,28 +169,24 @@ fixed_float64_t call_float64_ff(svbool_t pg, fixed_float64_t op1, fixed_float64_ // CHECK-NEXT: [[RETVAL_COERCE:%.*]] = alloca <vscale x 16 x i1>, align 16 // CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x i8>* [[OP1]] to <vscale x 16 x i1>* // CHECK-NEXT: store <vscale x 16 x i1> [[OP1_COERCE:%.*]], <vscale x 16 x i1>* [[TMP0]], align 16 -// CHECK-NEXT: [[TMP1:%.*]] = bitcast <8 x i8>* [[OP1]] to i64* -// CHECK-NEXT: [[OP113:%.*]] = load i64, i64* [[TMP1]], align 16, [[TBAA6]] -// CHECK-NEXT: [[TMP2:%.*]] = bitcast <8 x i8>* [[OP2]] to <vscale x 16 x i1>* -// CHECK-NEXT: store <vscale x 16 x i1> [[OP2_COERCE:%.*]], <vscale x 16 x i1>* [[TMP2]], align 16 -// CHECK-NEXT: [[TMP3:%.*]] = bitcast <8 x i8>* [[OP2]] to i64* -// CHECK-NEXT: [[OP224:%.*]] = load i64, i64* [[TMP3]], align 16, [[TBAA6]] -// CHECK-NEXT: [[TMP4:%.*]] = bitcast <8 x i8>* [[OP1_ADDR]] to i64* -// CHECK-NEXT: store i64 [[OP113]], i64* [[TMP4]], align 16, [[TBAA6]] -// CHECK-NEXT: [[TMP5:%.*]] = bitcast <8 x i8>* [[OP2_ADDR]] to i64* -// CHECK-NEXT: store i64 [[OP224]], i64* [[TMP5]], align 16, [[TBAA6]] -// CHECK-NEXT: [[TMP6:%.*]] = bitcast <8 x i8>* [[OP1_ADDR]] to <vscale x 16 x i1>* -// CHECK-NEXT: [[TMP7:%.*]] = load <vscale x 16 x i1>, <vscale x 16 x i1>* [[TMP6]], align 16, [[TBAA6]] -// CHECK-NEXT: [[TMP8:%.*]] = bitcast <8 x i8>* [[OP2_ADDR]] to <vscale x 16 x i1>* -// CHECK-NEXT: [[TMP9:%.*]] = load <vscale x 16 x i1>, <vscale x 16 x i1>* [[TMP8]], align 16, [[TBAA6]] -// CHECK-NEXT: [[TMP10:%.*]] = call <vscale x 16 x i1> @llvm.aarch64.sve.sel.nxv16i1(<vscale x 16 x i1> [[PG:%.*]], <vscale x 16 x i1> [[TMP7]], <vscale x 16 x i1> [[TMP9]]) -// CHECK-NEXT: store <vscale x 16 x i1> [[TMP10]], <vscale x 16 x i1>* [[SAVED_CALL_RVALUE]], align 16, [[TBAA13:!tbaa !.*]] -// CHECK-NEXT: [[TMP11:%.*]] = bitcast <vscale x 16 x i1>* [[SAVED_CALL_RVALUE]] to i64* -// CHECK-NEXT: [[TMP12:%.*]] = load i64, i64* [[TMP11]], align 16, [[TBAA6]] -// CHECK-NEXT: [[TMP13:%.*]] = bitcast <vscale x 16 x i1>* [[RETVAL_COERCE]] to i64* -// CHECK-NEXT: store i64 [[TMP12]], i64* [[TMP13]], align 16 -// CHECK-NEXT: [[TMP14:%.*]] = load <vscale x 16 x i1>, <vscale x 16 x i1>* [[RETVAL_COERCE]], align 16 -// CHECK-NEXT: ret <vscale x 16 x i1> [[TMP14]] +// CHECK-NEXT: [[OP11:%.*]] = load <8 x i8>, <8 x i8>* [[OP1]], align 16, [[TBAA6]] +// CHECK-NEXT: [[TMP1:%.*]] = bitcast <8 x i8>* [[OP2]] to <vscale x 16 x i1>* +// CHECK-NEXT: store <vscale x 16 x i1> [[OP2_COERCE:%.*]], <vscale x 16 x i1>* [[TMP1]], align 16 +// CHECK-NEXT: [[OP22:%.*]] = load <8 x i8>, <8 x i8>* [[OP2]], align 16, [[TBAA6]] +// CHECK-NEXT: store <8 x i8> [[OP11]], <8 x i8>* [[OP1_ADDR]], align 16, [[TBAA6]] +// CHECK-NEXT: store <8 x i8> [[OP22]], <8 x i8>* [[OP2_ADDR]], align 16, [[TBAA6]] +// CHECK-NEXT: [[TMP2:%.*]] = bitcast <8 x i8>* [[OP1_ADDR]] to <vscale x 16 x i1>* +// CHECK-NEXT: [[TMP3:%.*]] = load <vscale x 16 x i1>, <vscale x 16 x i1>* [[TMP2]], align 16, [[TBAA6]] +// CHECK-NEXT: [[TMP4:%.*]] = bitcast <8 x i8>* [[OP2_ADDR]] to <vscale x 16 x i1>* +// CHECK-NEXT: [[TMP5:%.*]] = load <vscale x 16 x i1>, <vscale x 16 x i1>* [[TMP4]], align 16, [[TBAA6]] +// CHECK-NEXT: [[TMP6:%.*]] = call <vscale x 16 x i1> @llvm.aarch64.sve.sel.nxv16i1(<vscale x 16 x i1> [[PG:%.*]], <vscale x 16 x i1> [[TMP3]], <vscale x 16 x i1> [[TMP5]]) +// CHECK-NEXT: store <vscale x 16 x i1> [[TMP6]], <vscale x 16 x i1>* [[SAVED_CALL_RVALUE]], align 16, [[TBAA13:!tbaa !.*]] +// CHECK-NEXT: [[CASTFIXEDSVE:%.*]] = bitcast <vscale x 16 x i1>* [[SAVED_CALL_RVALUE]] to <8 x i8>* +// CHECK-NEXT: [[TMP7:%.*]] = load <8 x i8>, <8 x i8>* [[CASTFIXEDSVE]], align 16, [[TBAA6]] +// CHECK-NEXT: [[RETVAL_0__SROA_CAST:%.*]] = bitcast <vscale x 16 x i1>* [[RETVAL_COERCE]] to <8 x i8>* +// CHECK-NEXT: store <8 x i8> [[TMP7]], <8 x i8>* [[RETVAL_0__SROA_CAST]], align 16 +// CHECK-NEXT: [[TMP8:%.*]] = load <vscale x 16 x i1>, <vscale x 16 x i1>* [[RETVAL_COERCE]], align 16 +// CHECK-NEXT: ret <vscale x 16 x i1> [[TMP8]] // fixed_bool_t call_bool_ff(svbool_t pg, fixed_bool_t op1, fixed_bool_t op2) { return svsel(pg, op1, op2); @@ -260,20 +256,18 @@ fixed_float64_t call_float64_fs(svbool_t pg, fixed_float64_t op1, svfloat64_t op // CHECK-NEXT: [[RETVAL_COERCE:%.*]] = alloca <vscale x 16 x i1>, align 16 // CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x i8>* [[OP1]] to <vscale x 16 x i1>* // CHECK-NEXT: store <vscale x 16 x i1> [[OP1_COERCE:%.*]], <vscale x 16 x i1>* [[TMP0]], align 16 -// CHECK-NEXT: [[TMP1:%.*]] = bitcast <8 x i8>* [[OP1]] to i64* -// CHECK-NEXT: [[OP112:%.*]] = load i64, i64* [[TMP1]], align 16, [[TBAA6]] -// CHECK-NEXT: [[TMP2:%.*]] = bitcast <8 x i8>* [[OP1_ADDR]] to i64* -// CHECK-NEXT: store i64 [[OP112]], i64* [[TMP2]], align 16, [[TBAA6]] -// CHECK-NEXT: [[TMP3:%.*]] = bitcast <8 x i8>* [[OP1_ADDR]] to <vscale x 16 x i1>* -// CHECK-NEXT: [[TMP4:%.*]] = load <vscale x 16 x i1>, <vscale x 16 x i1>* [[TMP3]], align 16, [[TBAA6]] -// CHECK-NEXT: [[TMP5:%.*]] = call <vscale x 16 x i1> @llvm.aarch64.sve.sel.nxv16i1(<vscale x 16 x i1> [[PG:%.*]], <vscale x 16 x i1> [[TMP4]], <vscale x 16 x i1> [[OP2:%.*]]) -// CHECK-NEXT: store <vscale x 16 x i1> [[TMP5]], <vscale x 16 x i1>* [[SAVED_CALL_RVALUE]], align 16, [[TBAA13]] -// CHECK-NEXT: [[TMP6:%.*]] = bitcast <vscale x 16 x i1>* [[SAVED_CALL_RVALUE]] to i64* -// CHECK-NEXT: [[TMP7:%.*]] = load i64, i64* [[TMP6]], align 16, [[TBAA6]] -// CHECK-NEXT: [[TMP8:%.*]] = bitcast <vscale x 16 x i1>* [[RETVAL_COERCE]] to i64* -// CHECK-NEXT: store i64 [[TMP7]], i64* [[TMP8]], align 16 -// CHECK-NEXT: [[TMP9:%.*]] = load <vscale x 16 x i1>, <vscale x 16 x i1>* [[RETVAL_COERCE]], align 16 -// CHECK-NEXT: ret <vscale x 16 x i1> [[TMP9]] +// CHECK-NEXT: [[OP11:%.*]] = load <8 x i8>, <8 x i8>* [[OP1]], align 16, [[TBAA6]] +// CHECK-NEXT: store <8 x i8> [[OP11]], <8 x i8>* [[OP1_ADDR]], align 16, [[TBAA6]] +// CHECK-NEXT: [[TMP1:%.*]] = bitcast <8 x i8>* [[OP1_ADDR]] to <vscale x 16 x i1>* +// CHECK-NEXT: [[TMP2:%.*]] = load <vscale x 16 x i1>, <vscale x 16 x i1>* [[TMP1]], align 16, [[TBAA6]] +// CHECK-NEXT: [[TMP3:%.*]] = call <vscale x 16 x i1> @llvm.aarch64.sve.sel.nxv16i1(<vscale x 16 x i1> [[PG:%.*]], <vscale x 16 x i1> [[TMP2]], <vscale x 16 x i1> [[OP2:%.*]]) +// CHECK-NEXT: store <vscale x 16 x i1> [[TMP3]], <vscale x 16 x i1>* [[SAVED_CALL_RVALUE]], align 16, [[TBAA13]] +// CHECK-NEXT: [[CASTFIXEDSVE:%.*]] = bitcast <vscale x 16 x i1>* [[SAVED_CALL_RVALUE]] to <8 x i8>* +// CHECK-NEXT: [[TMP4:%.*]] = load <8 x i8>, <8 x i8>* [[CASTFIXEDSVE]], align 16, [[TBAA6]] +// CHECK-NEXT: [[RETVAL_0__SROA_CAST:%.*]] = bitcast <vscale x 16 x i1>* [[RETVAL_COERCE]] to <8 x i8>* +// CHECK-NEXT: store <8 x i8> [[TMP4]], <8 x i8>* [[RETVAL_0__SROA_CAST]], align 16 +// CHECK-NEXT: [[TMP5:%.*]] = load <vscale x 16 x i1>, <vscale x 16 x i1>* [[RETVAL_COERCE]], align 16 +// CHECK-NEXT: ret <vscale x 16 x i1> [[TMP5]] // fixed_bool_t call_bool_fs(svbool_t pg, fixed_bool_t op1, svbool_t op2) { return svsel(pg, op1, op2); @@ -325,12 +319,12 @@ fixed_float64_t call_float64_ss(svbool_t pg, svfloat64_t op1, svfloat64_t op2) { // CHECK-NEXT: [[RETVAL_COERCE:%.*]] = alloca <vscale x 16 x i1>, align 16 // CHECK-NEXT: [[TMP0:%.*]] = call <vscale x 16 x i1> @llvm.aarch64.sve.sel.nxv16i1(<vscale x 16 x i1> [[PG:%.*]], <vscale x 16 x i1> [[OP1:%.*]], <vscale x 16 x i1> [[OP2:%.*]]) // CHECK-NEXT: store <vscale x 16 x i1> [[TMP0]], <vscale x 16 x i1>* [[SAVED_CALL_RVALUE]], align 16, [[TBAA13]] -// CHECK-NEXT: [[TMP1:%.*]] = bitcast <vscale x 16 x i1>* [[SAVED_CALL_RVALUE]] to i64* -// CHECK-NEXT: [[TMP2:%.*]] = load i64, i64* [[TMP1]], align 16, [[TBAA6]] -// CHECK-NEXT: [[TMP3:%.*]] = bitcast <vscale x 16 x i1>* [[RETVAL_COERCE]] to i64* -// CHECK-NEXT: store i64 [[TMP2]], i64* [[TMP3]], align 16 -// CHECK-NEXT: [[TMP4:%.*]] = load <vscale x 16 x i1>, <vscale x 16 x i1>* [[RETVAL_COERCE]], align 16 -// CHECK-NEXT: ret <vscale x 16 x i1> [[TMP4]] +// CHECK-NEXT: [[CASTFIXEDSVE:%.*]] = bitcast <vscale x 16 x i1>* [[SAVED_CALL_RVALUE]] to <8 x i8>* +// CHECK-NEXT: [[TMP1:%.*]] = load <8 x i8>, <8 x i8>* [[CASTFIXEDSVE]], align 16, [[TBAA6]] +// CHECK-NEXT: [[RETVAL_0__SROA_CAST:%.*]] = bitcast <vscale x 16 x i1>* [[RETVAL_COERCE]] to <8 x i8>* +// CHECK-NEXT: store <8 x i8> [[TMP1]], <8 x i8>* [[RETVAL_0__SROA_CAST]], align 16 +// CHECK-NEXT: [[TMP2:%.*]] = load <vscale x 16 x i1>, <vscale x 16 x i1>* [[RETVAL_COERCE]], align 16 +// CHECK-NEXT: ret <vscale x 16 x i1> [[TMP2]] // fixed_bool_t call_bool_ss(svbool_t pg, svbool_t op1, svbool_t op2) { return svsel(pg, op1, op2); diff --git a/clang/test/CodeGen/attr-arm-sve-vector-bits-cast.c b/clang/test/CodeGen/attr-arm-sve-vector-bits-cast.c index 17267d6038e4..8568c820ae6f 100644 --- a/clang/test/CodeGen/attr-arm-sve-vector-bits-cast.c +++ b/clang/test/CodeGen/attr-arm-sve-vector-bits-cast.c @@ -81,13 +81,11 @@ fixed_float64_t from_svfloat64_t(svfloat64_t type) { // CHECK-NEXT: [[TYPE_ADDR:%.*]] = alloca <8 x i8>, align 16 // CHECK-NEXT: [[TMP0:%.*]] = bitcast <8 x i8>* [[TYPE]] to <vscale x 16 x i1>* // CHECK-NEXT: store <vscale x 16 x i1> [[TYPE_COERCE:%.*]], <vscale x 16 x i1>* [[TMP0]], align 16 -// CHECK-NEXT: [[TMP1:%.*]] = bitcast <8 x i8>* [[TYPE]] to i64* -// CHECK-NEXT: [[TYPE12:%.*]] = load i64, i64* [[TMP1]], align 16, [[TBAA6]] -// CHECK-NEXT: [[TMP2:%.*]] = bitcast <8 x i8>* [[TYPE_ADDR]] to i64* -// CHECK-NEXT: store i64 [[TYPE12]], i64* [[TMP2]], align 16, [[TBAA6]] -// CHECK-NEXT: [[TMP3:%.*]] = bitcast <8 x i8>* [[TYPE_ADDR]] to <vscale x 16 x i1>* -// CHECK-NEXT: [[TMP4:%.*]] = load <vscale x 16 x i1>, <vscale x 16 x i1>* [[TMP3]], align 16, [[TBAA6]] -// CHECK-NEXT: ret <vscale x 16 x i1> [[TMP4]] +// CHECK-NEXT: [[TYPE1:%.*]] = load <8 x i8>, <8 x i8>* [[TYPE]], align 16, [[TBAA6]] +// CHECK-NEXT: store <8 x i8> [[TYPE1]], <8 x i8>* [[TYPE_ADDR]], align 16, [[TBAA6]] +// CHECK-NEXT: [[TMP1:%.*]] = bitcast <8 x i8>* [[TYPE_ADDR]] to <vscale x 16 x i1>* +// CHECK-NEXT: [[TMP2:%.*]] = load <vscale x 16 x i1>, <vscale x 16 x i1>* [[TMP1]], align 16, [[TBAA6]] +// CHECK-NEXT: ret <vscale x 16 x i1> [[TMP2]] // svbool_t to_svbool_t(fixed_bool_t type) { return type; @@ -98,12 +96,12 @@ svbool_t to_svbool_t(fixed_bool_t type) { // CHECK-NEXT: [[TYPE_ADDR:%.*]] = alloca <vscale x 16 x i1>, align 16 // CHECK-NEXT: [[RETVAL_COERCE:%.*]] = alloca <vscale x 16 x i1>, align 16 // CHECK-NEXT: store <vscale x 16 x i1> [[TYPE:%.*]], <vscale x 16 x i1>* [[TYPE_ADDR]], align 16, [[TBAA13:!tbaa !.*]] -// CHECK-NEXT: [[TMP0:%.*]] = bitcast <vscale x 16 x i1>* [[TYPE_ADDR]] to i64* -// CHECK-NEXT: [[TMP1:%.*]] = load i64, i64* [[TMP0]], align 16, [[TBAA6]] -// CHECK-NEXT: [[TMP2:%.*]] = bitcast <vscale x 16 x i1>* [[RETVAL_COERCE]] to i64* -// CHECK-NEXT: store i64 [[TMP1]], i64* [[TMP2]], align 16 -// CHECK-NEXT: [[TMP3:%.*]] = load <vscale x 16 x i1>, <vscale x 16 x i1>* [[RETVAL_COERCE]], align 16 -// CHECK-NEXT: ret <vscale x 16 x i1> [[TMP3]] +// CHECK-NEXT: [[TMP0:%.*]] = bitcast <vscale x 16 x i1>* [[TYPE_ADDR]] to <8 x i8>* +// CHECK-NEXT: [[TMP1:%.*]] = load <8 x i8>, <8 x i8>* [[TMP0]], align 16, [[TBAA6]] +// CHECK-NEXT: [[RETVAL_0__SROA_CAST:%.*]] = bitcast <vscale x 16 x i1>* [[RETVAL_COERCE]] to <8 x i8>* +// CHECK-NEXT: store <8 x i8> [[TMP1]], <8 x i8>* [[RETVAL_0__SROA_CAST]], align 16 +// CHECK-NEXT: [[TMP2:%.*]] = load <vscale x 16 x i1>, <vscale x 16 x i1>* [[RETVAL_COERCE]], align 16 +// CHECK-NEXT: ret <vscale x 16 x i1> [[TMP2]] // fixed_bool_t from_svbool_t(svbool_t type) { return type; diff --git a/clang/test/CodeGen/attr-arm-sve-vector-bits-globals.c b/clang/test/CodeGen/attr-arm-sve-vector-bits-globals.c index 5babb9c7c410..8f0d3c9f97e7 100644 --- a/clang/test/CodeGen/attr-arm-sve-vector-bits-globals.c +++ b/clang/test/CodeGen/attr-arm-sve-vector-bits-globals.c @@ -72,9 +72,9 @@ void write_global_bf16(svbfloat16_t v) { global_bf16 = v; } // CHECK-512-NEXT: entry: // CHECK-512-NEXT: [[V_ADDR:%.*]] = alloca <vscale x 16 x i1>, align 16 // CHECK-512-NEXT: store <vscale x 16 x i1> [[V:%.*]], <vscale x 16 x i1>* [[V_ADDR]], align 16, [[TBAA13:!tbaa !.*]] -// CHECK-512-NEXT: [[TMP0:%.*]] = bitcast <vscale x 16 x i1>* [[V_ADDR]] to i64* -// CHECK-512-NEXT: [[TMP1:%.*]] = load i64, i64* [[TMP0]], align 16, [[TBAA10]] -// CHECK-512-NEXT: store i64 [[TMP1]], i64* bitcast (<8 x i8>* @global_bool to i64*), align 2, [[TBAA10]] +// CHECK-512-NEXT: [[TMP0:%.*]] = bitcast <vscale x 16 x i1>* [[V_ADDR]] to <8 x i8>* +// CHECK-512-NEXT: [[TMP1:%.*]] = load <8 x i8>, <8 x i8>* [[TMP0]], align 16, [[TBAA10]] +// CHECK-512-NEXT: store <8 x i8> [[TMP1]], <8 x i8>* @global_bool, align 2, [[TBAA10]] // CHECK-512-NEXT: ret void // void write_global_bool(svbool_t v) { global_bool = v; } diff --git a/llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp b/llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp index 328cbde4da67..b7bb34022ecc 100644 --- a/llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp +++ b/llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp @@ -554,42 +554,8 @@ static Instruction *combineLoadToOperationType(InstCombinerImpl &IC, if (LI.getPointerOperand()->isSwiftError()) return nullptr; - Type *Ty = LI.getType(); const DataLayout &DL = IC.getDataLayout(); - // Try to canonicalize loads which are only ever stored to operate over - // integers instead of any other type. We only do this when the loaded type - // is sized and has a size exactly the same as its store size and the store - // size is a legal integer type. - // Do not perform canonicalization if minmax pattern is found (to avoid - // infinite loop). - Type *Dummy; - if (!Ty->isIntegerTy() && Ty->isSized() && !isa<ScalableVectorType>(Ty) && - DL.isLegalInteger(DL.getTypeStoreSizeInBits(Ty)) && - DL.typeSizeEqualsStoreSize(Ty) && !DL.isNonIntegralPointerType(Ty) && - !isMinMaxWithLoads(InstCombiner::peekThroughBitcast( - LI.getPointerOperand(), /*OneUseOnly=*/true), - Dummy)) { - if (all_of(LI.users(), [&LI](User *U) { - auto *SI = dyn_cast<StoreInst>(U); - return SI && SI->getPointerOperand() != &LI && - !SI->getPointerOperand()->isSwiftError(); - })) { - LoadInst *NewLoad = IC.combineLoadToNewType( - LI, Type::getIntNTy(LI.getContext(), DL.getTypeStoreSizeInBits(Ty))); - // Replace all the stores with stores of the newly loaded value. - for (auto UI = LI.user_begin(), UE = LI.user_end(); UI != UE;) { - auto *SI = cast<StoreInst>(*UI++); - IC.Builder.SetInsertPoint(SI); - combineStoreToNewValue(IC, *SI, NewLoad); - IC.eraseInstFromFunction(*SI); - } - assert(LI.use_empty() && "Failed to remove all users of the load!"); - // Return the old load so the combiner can delete it safely. - return &LI; - } - } - // Fold away bit casts of the loaded value by loading the desired type. // We can do this for BitCastInsts as well as casts from and to pointer types, // as long as those are noops (i.e., the source or dest type have the same diff --git a/llvm/test/Transforms/InstCombine/atomic.ll b/llvm/test/Transforms/InstCombine/atomic.ll index 382d23d15309..fc134bcd7e4b 100644 --- a/llvm/test/Transforms/InstCombine/atomic.ll +++ b/llvm/test/Transforms/InstCombine/atomic.ll @@ -325,11 +325,9 @@ declare void @clobber() define i32 @test18(float* %p) { ; CHECK-LABEL: @test18( -; CHECK-NEXT: [[TMP1:%.*]] = bitcast float* [[P:%.*]] to i32* -; CHECK-NEXT: [[X1:%.*]] = load atomic i32, i32* [[TMP1]] unordered, align 4 +; CHECK-NEXT: [[X:%.*]] = load atomic float, float* [[P:%.*]] unordered, align 4 ; CHECK-NEXT: call void @clobber() -; CHECK-NEXT: [[TMP2:%.*]] = bitcast float* [[P]] to i32* -; CHECK-NEXT: store atomic i32 [[X1]], i32* [[TMP2]] unordered, align 4 +; CHECK-NEXT: store atomic float [[X]], float* [[P]] unordered, align 4 ; CHECK-NEXT: ret i32 0 ; %x = load atomic float, float* %p unordered, align 4 @@ -376,10 +374,8 @@ define i32 @test21(i32** %p, i8* %v) { define void @pr27490a(i8** %p1, i8** %p2) { ; CHECK-LABEL: @pr27490a( -; CHECK-NEXT: [[TMP1:%.*]] = bitcast i8** [[P1:%.*]] to i64* -; CHECK-NEXT: [[L1:%.*]] = load i64, i64* [[TMP1]], align 8 -; CHECK-NEXT: [[TMP2:%.*]] = bitcast i8** [[P2:%.*]] to i64* -; CHECK-NEXT: store volatile i64 [[L1]], i64* [[TMP2]], align 8 +; CHECK-NEXT: [[L:%.*]] = load i8*, i8** [[P1:%.*]], align 8 +; CHECK-NEXT: store volatile i8* [[L]], i8** [[P2:%.*]], align 8 ; CHECK-NEXT: ret void ; %l = load i8*, i8** %p1 @@ -389,10 +385,8 @@ define void @pr27490a(i8** %p1, i8** %p2) { define void @pr27490b(i8** %p1, i8** %p2) { ; CHECK-LABEL: @pr27490b( -; CHECK-NEXT: [[TMP1:%.*]] = bitcast i8** [[P1:%.*]] to i64* -; CHECK-NEXT: [[L1:%.*]] = load i64, i64* [[TMP1]], align 8 -; CHECK-NEXT: [[TMP2:%.*]] = bitcast i8** [[P2:%.*]] to i64* -; CHECK-NEXT: store atomic i64 [[L1]], i64* [[TMP2]] seq_cst, align 8 +; CHECK-NEXT: [[L:%.*]] = load i8*, i8** [[P1:%.*]], align 8 +; CHECK-NEXT: store atomic i8* [[L]], i8** [[P2:%.*]] seq_cst, align 8 ; CHECK-NEXT: ret void ; %l = load i8*, i8** %p1 diff --git a/llvm/test/Transforms/InstCombine/load.ll b/llvm/test/Transforms/InstCombine/load.ll index 4fc87219fa83..032da41de6a5 100644 --- a/llvm/test/Transforms/InstCombine/load.ll +++ b/llvm/test/Transforms/InstCombine/load.ll @@ -205,18 +205,16 @@ define i8 @test15(i8 %x, i32 %y) { define void @test16(i8* %x, i8* %a, i8* %b, i8* %c) { ; CHECK-LABEL: @test16( ; CHECK-NEXT: entry: -; CHECK-NEXT: [[TMP0:%.*]] = bitcast i8* [[X:%.*]] to i32* -; CHECK-NEXT: [[X11:%.*]] = load i32, i32* [[TMP0]], align 4 -; CHECK-NEXT: [[TMP1:%.*]] = bitcast i8* [[A:%.*]] to i32* -; CHECK-NEXT: store i32 [[X11]], i32* [[TMP1]], align 4 -; CHECK-NEXT: [[TMP2:%.*]] = bitcast i8* [[B:%.*]] to i32* -; CHECK-NEXT: store i32 [[X11]], i32* [[TMP2]], align 4 -; CHECK-NEXT: [[TMP3:%.*]] = bitcast i8* [[X]] to i32* -; CHECK-NEXT: [[X22:%.*]] = load i32, i32* [[TMP3]], align 4 -; CHECK-NEXT: [[TMP4:%.*]] = bitcast i8* [[B]] to i32* -; CHECK-NEXT: store i32 [[X22]], i32* [[TMP4]], align 4 -; CHECK-NEXT: [[TMP5:%.*]] = bitcast i8* [[C:%.*]] to i32* -; CHECK-NEXT: store i32 [[X22]], i32* [[TMP5]], align 4 +; CHECK-NEXT: [[X_CAST:%.*]] = bitcast i8* [[X:%.*]] to float* +; CHECK-NEXT: [[A_CAST:%.*]] = bitcast i8* [[A:%.*]] to float* +; CHECK-NEXT: [[B_CAST:%.*]] = bitcast i8* [[B:%.*]] to float* +; CHECK-NEXT: [[X1:%.*]] = load float, float* [[X_CAST]], align 4 +; CHECK-NEXT: store float [[X1]], float* [[A_CAST]], align 4 +; CHECK-NEXT: store float [[X1]], float* [[B_CAST]], align 4 +; CHECK-NEXT: [[X2:%.*]] = load float, float* [[X_CAST]], align 4 +; CHECK-NEXT: store float [[X2]], float* [[B_CAST]], align 4 +; CHECK-NEXT: [[TMP0:%.*]] = bitcast i8* [[C:%.*]] to float* +; CHECK-NEXT: store float [[X2]], float* [[TMP0]], align 4 ; CHECK-NEXT: ret void ; entry: @@ -240,18 +238,16 @@ entry: define void @test16-vect(i8* %x, i8* %a, i8* %b, i8* %c) { ; CHECK-LABEL: @test16-vect( ; CHECK-NEXT: entry: -; CHECK-NEXT: [[TMP0:%.*]] = bitcast i8* [[X:%.*]] to i32* -; CHECK-NEXT: [[X11:%.*]] = load i32, i32* [[TMP0]], align 4 -; CHECK-NEXT: [[TMP1:%.*]] = bitcast i8* [[A:%.*]] to i32* -; CHECK-NEXT: store i32 [[X11]], i32* [[TMP1]], align 4 -; CHECK-NEXT: [[TMP2:%.*]] = bitcast i8* [[B:%.*]] to i32* -; CHECK-NEXT: store i32 [[X11]], i32* [[TMP2]], align 4 -; CHECK-NEXT: [[TMP3:%.*]] = bitcast i8* [[X]] to i32* -; CHECK-NEXT: [[X22:%.*]] = load i32, i32* [[TMP3]], align 4 -; CHECK-NEXT: [[TMP4:%.*]] = bitcast i8* [[B]] to i32* -; CHECK-NEXT: store i32 [[X22]], i32* [[TMP4]], align 4 -; CHECK-NEXT: [[TMP5:%.*]] = bitcast i8* [[C:%.*]] to i32* -; CHECK-NEXT: store i32 [[X22]], i32* [[TMP5]], align 4 +; CHECK-NEXT: [[X_CAST:%.*]] = bitcast i8* [[X:%.*]] to <4 x i8>* +; CHECK-NEXT: [[A_CAST:%.*]] = bitcast i8* [[A:%.*]] to <4 x i8>* +; CHECK-NEXT: [[B_CAST:%.*]] = bitcast i8* [[B:%.*]] to <4 x i8>* +; CHECK-NEXT: [[X1:%.*]] = load <4 x i8>, <4 x i8>* [[X_CAST]], align 4 +; CHECK-NEXT: store <4 x i8> [[X1]], <4 x i8>* [[A_CAST]], align 4 +; CHECK-NEXT: store <4 x i8> [[X1]], <4 x i8>* [[B_CAST]], align 4 +; CHECK-NEXT: [[X2:%.*]] = load <4 x i8>, <4 x i8>* [[X_CAST]], align 4 +; CHECK-NEXT: store <4 x i8> [[X2]], <4 x i8>* [[B_CAST]], align 4 +; CHECK-NEXT: [[TMP0:%.*]] = bitcast i8* [[C:%.*]] to <4 x i8>* +; CHECK-NEXT: store <4 x i8> [[X2]], <4 x i8>* [[TMP0]], align 4 ; CHECK-NEXT: ret void ; entry: diff --git a/llvm/test/Transforms/InstCombine/loadstore-metadata.ll b/llvm/test/Transforms/InstCombine/loadstore-metadata.ll index e443c6ed0075..42f6900c2ab5 100644 --- a/llvm/test/Transforms/InstCombine/loadstore-metadata.ll +++ b/llvm/test/Transforms/InstCombine/loadstore-metadata.ll @@ -161,24 +161,11 @@ exit: } define void @test_load_cast_combine_nonnull(float** %ptr) { -; We can't preserve nonnull metadata when converting a load of a pointer to -; a load of an integer. Instead, we translate it to range metadata. -; FIXME: We should also transform range metadata back into nonnull metadata. -; FIXME: This test is very fragile. If any LABEL lines are added after -; this point, the test will fail, because this test depends on a metadata tuple, -; which is always emitted at the end of the file. At some point, we should -; consider an option to the IR printer to emit MD tuples after the function -; that first uses them--this will allow us to refer to them like this and not -; have the tests break. For now, this function must always come last in this -; file, and no LABEL lines are to be added after this point. -; ; CHECK-LABEL: @test_load_cast_combine_nonnull( ; CHECK-NEXT: entry: -; CHECK-NEXT: [[TMP0:%.*]] = bitcast float** [[PTR:%.*]] to i64* -; CHECK-NEXT: [[P1:%.*]] = load i64, i64* [[TMP0]], align 8, !range ![[MD:[0-9]+]] +; CHECK-NEXT: [[P:%.*]] = load float*, float** [[PTR:%.*]], align 8, !nonnull !7 ; CHECK-NEXT: [[GEP:%.*]] = getelementptr float*, float** [[PTR]], i64 42 -; CHECK-NEXT: [[TMP1:%.*]] = bitcast float** [[GEP]] to i64* -; CHECK-NEXT: store i64 [[P1]], i64* [[TMP1]], align 8 +; CHECK-NEXT: store float* [[P]], float** [[GEP]], align 8 ; CHECK-NEXT: ret void ; entry: @@ -188,8 +175,6 @@ entry: ret void } -; This is the metadata tuple that we reference above: -; CHECK: ![[MD]] = !{i64 1, i64 0} !0 = !{!1, !1, i64 0} !1 = !{!"scalar type", !2} !2 = !{!"root"} diff --git a/llvm/test/Transforms/InstCombine/non-integral-pointers.ll b/llvm/test/Transforms/InstCombine/non-integral-pointers.ll index e8f0013604a9..a1166bf49193 100644 --- a/llvm/test/Transforms/InstCombine/non-integral-pointers.ll +++ b/llvm/test/Transforms/InstCombine/non-integral-pointers.ll @@ -41,10 +41,8 @@ define void @f_3(i8 addrspace(3)** %ptr0, i8 addrspace(3)** %ptr1) { ; integers, since pointers in address space 3 are integral. ; CHECK-LABEL: @f_3( ; CHECK-NEXT: entry: -; CHECK-NEXT: [[TMP0:%.*]] = bitcast i8 addrspace(3)** [[PTR0:%.*]] to i64* -; CHECK-NEXT: [[VAL1:%.*]] = load i64, i64* [[TMP0]], align 8 -; CHECK-NEXT: [[TMP1:%.*]] = bitcast i8 addrspace(3)** [[PTR1:%.*]] to i64* -; CHECK-NEXT: store i64 [[VAL1]], i64* [[TMP1]], align 8 +; CHECK-NEXT: [[VAL:%.*]] = load i8 addrspace(3)*, i8 addrspace(3)** [[PTR0:%.*]], align 8 +; CHECK-NEXT: store i8 addrspace(3)* [[VAL]], i8 addrspace(3)** [[PTR1:%.*]], align 8 ; CHECK-NEXT: ret void ; entry: @@ -79,13 +77,13 @@ define i64 @g(i8 addrspace(4)** %gp) { define i64 @g2(i8* addrspace(4)* %gp) { ; CHECK-LABEL: @g2( -; CHECK-NEXT: [[TMP1:%.*]] = bitcast i8* addrspace(4)* [[GP:%.*]] to i64 addrspace(4)* -; CHECK-NEXT: [[DOTPRE1:%.*]] = load i64, i64 addrspace(4)* [[TMP1]], align 8 +; CHECK-NEXT: [[DOTPRE:%.*]] = load i8*, i8* addrspace(4)* [[GP:%.*]], align 8 ; CHECK-NEXT: [[V74:%.*]] = call i8 addrspace(4)* @alloc() ; CHECK-NEXT: [[V77:%.*]] = getelementptr i8, i8 addrspace(4)* [[V74]], i64 -8 -; CHECK-NEXT: [[TMP2:%.*]] = bitcast i8 addrspace(4)* [[V77]] to i64 addrspace(4)* -; CHECK-NEXT: store i64 [[DOTPRE1]], i64 addrspace(4)* [[TMP2]], align 8 -; CHECK-NEXT: ret i64 [[DOTPRE1]] +; CHECK-NEXT: [[TMP1:%.*]] = bitcast i8 addrspace(4)* [[V77]] to i8* addrspace(4)* +; CHECK-NEXT: store i8* [[DOTPRE]], i8* addrspace(4)* [[TMP1]], align 8 +; CHECK-NEXT: [[V81_CAST:%.*]] = ptrtoint i8* [[DOTPRE]] to i64 +; CHECK-NEXT: ret i64 [[V81_CAST]] ; %.pre = load i8*, i8* addrspace(4)* %gp, align 8 %v74 = call i8 addrspace(4)* @alloc() diff --git a/llvm/test/Transforms/PhaseOrdering/instcombine-sroa-inttoptr.ll b/llvm/test/Transforms/PhaseOrdering/instcombine-sroa-inttoptr.ll index 6de0282e9448..3308a0ecc7fa 100644 --- a/llvm/test/Transforms/PhaseOrdering/instcombine-sroa-inttoptr.ll +++ b/llvm/test/Transforms/PhaseOrdering/instcombine-sroa-inttoptr.ll @@ -50,10 +50,10 @@ target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16 define dso_local void @_Z3gen1S(%0* noalias sret align 8 %arg, %0* byval(%0) align 8 %arg1) { ; CHECK-LABEL: @_Z3gen1S( ; CHECK-NEXT: bb: -; CHECK-NEXT: [[TMP0:%.*]] = bitcast %0* [[ARG1:%.*]] to i64* -; CHECK-NEXT: [[I21:%.*]] = load i64, i64* [[TMP0]], align 8 -; CHECK-NEXT: [[TMP1:%.*]] = bitcast %0* [[ARG:%.*]] to i64* -; CHECK-NEXT: store i64 [[I21]], i64* [[TMP1]], align 8 +; CHECK-NEXT: [[I:%.*]] = getelementptr inbounds [[TMP0:%.*]], %0* [[ARG1:%.*]], i64 0, i32 0 +; CHECK-NEXT: [[I2:%.*]] = load i32*, i32** [[I]], align 8 +; CHECK-NEXT: [[I3:%.*]] = getelementptr inbounds [[TMP0]], %0* [[ARG:%.*]], i64 0, i32 0 +; CHECK-NEXT: store i32* [[I2]], i32** [[I3]], align 8 ; CHECK-NEXT: ret void ; bb: @@ -68,13 +68,12 @@ define dso_local i32* @_Z3foo1S(%0* byval(%0) align 8 %arg) { ; CHECK-LABEL: @_Z3foo1S( ; CHECK-NEXT: bb: ; CHECK-NEXT: [[I2:%.*]] = alloca [[TMP0:%.*]], align 8 -; CHECK-NEXT: [[I1_SROA_0_0_I5_SROA_CAST:%.*]] = bitcast %0* [[ARG:%.*]] to i64* -; CHECK-NEXT: [[I1_SROA_0_0_COPYLOAD:%.*]] = load i64, i64* [[I1_SROA_0_0_I5_SROA_CAST]], align 8 -; CHECK-NEXT: [[I_SROA_0_0_I6_SROA_CAST:%.*]] = bitcast %0* [[I2]] to i64* -; CHECK-NEXT: store i64 [[I1_SROA_0_0_COPYLOAD]], i64* [[I_SROA_0_0_I6_SROA_CAST]], align 8 +; CHECK-NEXT: [[I1_SROA_0_0_I5_SROA_IDX:%.*]] = getelementptr inbounds [[TMP0]], %0* [[ARG:%.*]], i64 0, i32 0 +; CHECK-NEXT: [[I1_SROA_0_0_COPYLOAD:%.*]] = load i32*, i32** [[I1_SROA_0_0_I5_SROA_IDX]], align 8 +; CHECK-NEXT: [[I_SROA_0_0_I6_SROA_IDX:%.*]] = getelementptr inbounds [[TMP0]], %0* [[I2]], i64 0, i32 0 +; CHECK-NEXT: store i32* [[I1_SROA_0_0_COPYLOAD]], i32** [[I_SROA_0_0_I6_SROA_IDX]], align 8 ; CHECK-NEXT: tail call void @_Z7escape01S(%0* nonnull byval(%0) align 8 [[I2]]) -; CHECK-NEXT: [[TMP0]] = inttoptr i64 [[I1_SROA_0_0_COPYLOAD]] to i32* -; CHECK-NEXT: ret i32* [[TMP0]] +; CHECK-NEXT: ret i32* [[I1_SROA_0_0_COPYLOAD]] ; bb: %i = alloca %0, align 8 @@ -108,24 +107,21 @@ declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture) define dso_local i32* @_Z3bar1S(%0* byval(%0) align 8 %arg) { ; CHECK-LABEL: @_Z3bar1S( ; CHECK-NEXT: bb: -; CHECK-NEXT: [[I1_SROA_0_0_I4_SROA_CAST:%.*]] = bitcast %0* [[ARG:%.*]] to i64* -; CHECK-NEXT: [[I1_SROA_0_0_COPYLOAD:%.*]] = load i64, i64* [[I1_SROA_0_0_I4_SROA_CAST]], align 8 +; CHECK-NEXT: [[I1_SROA_0_0_I4_SROA_IDX:%.*]] = getelementptr inbounds [[TMP0:%.*]], %0* [[ARG:%.*]], i64 0, i32 0 +; CHECK-NEXT: [[I1_SROA_0_0_COPYLOAD:%.*]] = load i32*, i32** [[I1_SROA_0_0_I4_SROA_IDX]], align 8 ; CHECK-NEXT: [[I5:%.*]] = tail call i32 @_Z4condv() ; CHECK-NEXT: [[I6_NOT:%.*]] = icmp eq i32 [[I5]], 0 ; CHECK-NEXT: br i1 [[I6_NOT]], label [[BB10:%.*]], label [[BB7:%.*]] ; CHECK: bb7: ; CHECK-NEXT: tail call void @_Z5sync0v() -; CHECK-NEXT: [[TMP0:%.*]] = inttoptr i64 [[I1_SROA_0_0_COPYLOAD]] to i32* -; CHECK-NEXT: tail call void @_Z7escape0Pi(i32* [[TMP0]]) +; CHECK-NEXT: tail call void @_Z7escape0Pi(i32* [[I1_SROA_0_0_COPYLOAD]]) ; CHECK-NEXT: br label [[BB13:%.*]] ; CHECK: bb10: ; CHECK-NEXT: tail call void @_Z5sync1v() -; CHECK-NEXT: [[TMP1:%.*]] = inttoptr i64 [[I1_SROA_0_0_COPYLOAD]] to i32* -; CHECK-NEXT: tail call void @_Z7escape1Pi(i32* [[TMP1]]) +; CHECK-NEXT: tail call void @_Z7escape1Pi(i32* [[I1_SROA_0_0_COPYLOAD]]) ; CHECK-NEXT: br label [[BB13]] ; CHECK: bb13: -; CHECK-NEXT: [[DOTPRE_PHI:%.*]] = phi i32* [ [[TMP1]], [[BB10]] ], [ [[TMP0]], [[BB7]] ] -; CHECK-NEXT: ret i32* [[DOTPRE_PHI]] +; CHECK-NEXT: ret i32* [[I1_SROA_0_0_COPYLOAD]] ; bb: %i = alloca %0, align 8 </cut>

4 years

[CI-NOTIFY]: TCWG Bisect tcwg_gnu/gnu-master-arm-check_bootstrap - Build # 73 - Successful!

by ci_notify＠linaro.org

Successfully identified regression in *gcc* in CI configuration tcwg_gnu/gnu-master-arm-check_bootstrap. So far, this commit has regressed CI configurations: - tcwg_gnu/gnu-master-arm-check_bootstrap Culprit: <cut> commit 7d8211603a3d04384812b481b0ae01205a287a72 Author: Richard Biener <rguenther(a)suse.de> Date: Wed Jun 30 16:28:50 2021 +0200 tree-optimization/101178 - handle VEC_PERM in SLP permute propagation This adds handling of VEC_PERM nodes to SLP permute propagation. Previously VEC_PERM acted as forced materialization of incoming permutes since it is a good place to do that (with the constraint of those only appearing for two-operator nodes). The following patch, in addition to supporting (but not forcing) this, enables VEC_PERM nodes acting as "any" permute on the outgoing side since they also can consume arbitrary permutes on that side. This again (meh) changes how we represent permutes and materialization on the graph vertices now explicitely having the common incoming permute as well as an outgoing permute and in case both are different the vertex acts as materialization point of the incoming permute. 2021-06-30 Richard Biener <rguenther(a)suse.de> PR tree-optimization/101178 * tree-vect-slp.c (slpg_vertex::materialize): Remove. (slpg::perm_in): Add. (slpg::get_perm_in): Remove. (slpg::get_perm_materialized): Add. (vect_optimize_slp): Handle VEC_PERM nodes more optimally during permute propagation and materialization. * gcc.dg/vect/bb-slp-72.c: New testcase. * gcc.dg/vect/bb-slp-73.c: Likewise. * gcc.dg/vect/bb-slp-74.c: Likewise. </cut> Results regressed to (for first_bad == 7d8211603a3d04384812b481b0ae01205a287a72) # reset_artifacts: -10 # build_abe bootstrap: 0 # build_abe check_bootstrap: 1 # # Comparing directories # # REFERENCE: base-artifacts/sumfiles # # CURRENT: /home/tcwg-buildslave/workspace/tcwg_gnu_2/artifacts/build-7d8211603a3d04384812b481b0ae01205a287a72/sumfiles # # # Comparing 12 common sum files: # g++.sum # gcc.sum # gfortran.sum # go.sum # gotools.sum # libatomic.sum # libffi.sum # libgo.sum # libgomp.sum # libitm.sum # libstdc++.sum # objc.sum # Comparing: # REFERENCE:/tmp/gxx-sum1.3498108 # CURRENT: /tmp/gxx-sum2.3498108 # # ` +---------+---------+ # o RUN STATUS: | REF | RES | # +------------------------------------------+---------+---------+ # | Passes [PASS] | 460520 | 460704 | # | Unexpected fails [FAIL] | 196 | 195 | # | Errors [ERROR] | 0 | 0 | # | Unexpected passes [XPASS] | 15 | 15 | # | Expected fails [XFAIL] | 2737 | 2723 | # | Unresolved [UNRESOLVED] | 104 | 104 | # | Unsupported [UNSUPPORTED] | 22896 | 22903 | # | Untested [UNTESTED] | 10 | 10 | # +------------------------------------------+---------+---------+ # # REF PASS ratio: 0.952267 # RES PASS ratio: 0.952272 # # o REGRESSIONS: # +------------------------------------------+---------+ # | FAIL appears [ => FAIL] | 2 | # +------------------------------------------+---------+ # | TOTAL_REGRESSIONS | 2 | # +------------------------------------------+---------+ # # - FAIL appears [ => FAIL]: # # Executed from: gcc.dg/vect/vect.exp # gcc:gcc.dg/vect/bb-slp-74.c -flto -ffat-lto-objects scan-tree-dump-times slp2 " [^ ]+ = VEC_PERM_EXPR" 1 # gcc:gcc.dg/vect/bb-slp-74.c scan-tree-dump-times slp2 " [^ ]+ = VEC_PERM_EXPR" 1 # # # # o IMPROVEMENTS TO BE CHECKED: # +------------------------------------------+---------+ # | PASS disappears [PASS => ] | 114 | # | New PASS [ => PASS] | 296 | # | FAIL now PASS [FAIL => PASS] | 2 | # | FAIL disappears [FAIL => ] | 1 | # | XFAIL disappears [XFAIL=> ] | 17 | # | XFAIL appears [ =>XFAIL] | 3 | # | UNSUPPORTED appears [ =>UNSUP] | 7 | # +------------------------------------------+---------+ # | TOTAL_IMPROVEMENTS_TO_BE_CHECKED | 440 | # +------------------------------------------+---------+ # # - PASS disappears [PASS => ]: # # Executed from: g++.dg/dg.exp # g++:g++.dg/cpp0x/auto24.C -std=c++14 (test for errors, line 5) # g++:g++.dg/cpp0x/auto24.C -std=c++17 (test for errors, line 5) # g++:g++.dg/cpp0x/auto24.C -std=c++2a (test for errors, line 5) # g++:g++.dg/diagnostic/auto1.C -std=c++17 (test for errors, line 4) # g++:g++.dg/diagnostic/auto1.C -std=c++2a (test for errors, line 4) # Executed from: gcc.dg/analyzer/analyzer.exp # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 1007) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 1009) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 1010) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 1013) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 1018) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 1025) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 1026) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 510) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 518) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 519) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 539) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 540) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 557) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 559) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 562) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 565) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 566) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 570) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 573) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 574) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 578) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 579) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 581) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 582) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 586) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 587) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 604) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 606) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 609) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 612) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 613) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 617) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 620) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 621) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 628) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 629) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 632) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 635) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 636) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 654) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 656) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 659) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 662) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 663) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 667) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 670) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 671) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 676) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 678) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 679) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 682) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 684) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 685) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 703) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 705) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 708) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 711) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 712) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 716) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 719) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 720) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 725) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 727) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 728) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 731) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 733) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 744) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 745) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 765) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 769) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 770) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 781) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 787) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 795) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 800) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 801) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 812) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 816) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 842) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 850) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 870) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 873) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 875) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 895) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 908) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 909) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 914) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 923) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 932) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 947) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 950) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 965) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 968) # gcc:gcc.dg/analyzer/data-model-1.c status quo (test for warnings, line 1038) # gcc:gcc.dg/analyzer/data-model-1.c status quo (test for warnings, line 506) # gcc:gcc.dg/analyzer/data-model-1.c status quo (test for warnings, line 511) # gcc:gcc.dg/analyzer/data-model-1.c status quo (test for warnings, line 525) # gcc:gcc.dg/analyzer/data-model-1.c status quo (test for warnings, line 528) # gcc:gcc.dg/analyzer/data-model-1.c status quo (test for warnings, line 532) # gcc:gcc.dg/analyzer/data-model-1.c status quo (test for warnings, line 535) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 63) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 67) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 68) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 77) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 81) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 82) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 98) # Executed from: libstdc++-dg/conformance.exp # libstdc++:26_numerics/random/pr60037-neg.cc (test for errors, line 167) # libstdc++:26_numerics/random/pr60037-neg.cc (test for errors, line 3346) # # # - New PASS [ => PASS]: # # Executed from: g++.dg/dg.exp # g++:g++.dg/cpp0x/constexpr-empty16.C -std=c++14 (test for excess errors) # g++:g++.dg/cpp0x/constexpr-empty16.C -std=c++17 (test for excess errors) # g++:g++.dg/cpp0x/constexpr-empty16.C -std=c++2a (test for excess errors) # g++:g++.dg/cpp23/auto-array.C -std=c++14 (test for excess errors) # g++:g++.dg/cpp23/auto-array.C -std=c++17 (test for excess errors) # g++:g++.dg/cpp23/auto-array.C -std=c++2a (test for excess errors) # g++:g++.dg/cpp2a/concepts-access2.C -std=c++2a (test for errors, line 13) # g++:g++.dg/cpp2a/concepts-access2.C -std=c++2a (test for errors, line 4) # g++:g++.dg/cpp2a/concepts-access2.C -std=c++2a (test for excess errors) # g++:g++.dg/template/access41.C -std=c++14 (test for excess errors) # g++:g++.dg/template/access41.C -std=c++17 (test for excess errors) # g++:g++.dg/template/access41.C -std=c++2a (test for excess errors) # g++:g++.dg/template/access41a.C -std=c++14 (test for excess errors) # g++:g++.dg/template/access41a.C -std=c++17 (test for excess errors) # g++:g++.dg/template/access41a.C -std=c++2a (test for excess errors) # Executed from: gcc.misc-tests/help.exp # gcc:compiler driver --help=common option(s): ^ +-.*[^:.]$ # Executed from: gcc.dg/analyzer/analyzer.exp # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 22) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 24) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 25) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 33) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 35) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 36) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 44) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 46) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 47) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 54) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 55) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 67) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 68) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 69) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 70) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 71) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 72) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 73) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 74) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 88) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 89) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 90) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 91) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 92) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 93) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 94) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 95) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 96) # gcc:gcc.dg/analyzer/clobbers-1.c (test for warnings, line 97) # gcc:gcc.dg/analyzer/clobbers-1.c (test for excess errors) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 11) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 12) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 13) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 14) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 15) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 19) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 20) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 21) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 22) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 23) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 24) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 31) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 32) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 33) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 37) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 38) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 39) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 40) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 47) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 48) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 49) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 53) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 54) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 55) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 56) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 63) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 64) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 68) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 69) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 70) # gcc:gcc.dg/analyzer/clobbers-2.c (test for warnings, line 71) # gcc:gcc.dg/analyzer/clobbers-2.c (test for excess errors) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 1000) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 1003) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 1015) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 1028) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 1029) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 506) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 508) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 516) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 517) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 523) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 524) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 526) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 527) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 529) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 530) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 546) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 547) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 549) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 550) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 552) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 553) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 555) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 561) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 564) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 568) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 569) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 572) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 576) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 577) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 593) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 594) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 596) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 597) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 599) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 600) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 602) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 608) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 611) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 615) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 616) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 619) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 622) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 643) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 644) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 646) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 647) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 649) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 650) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 652) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 658) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 661) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 665) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 666) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 669) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 672) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 674) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 692) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 693) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 695) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 696) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 698) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 699) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 701) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 707) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 710) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 714) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 715) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 718) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 721) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 723) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 735) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 755) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 759) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 760) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 767) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 771) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 785) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 790) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 791) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 802) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 806) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 832) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 840) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 860) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 863) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 865) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 885) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 898) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 899) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 903) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 904) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 922) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 937) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 940) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 955) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 958) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 996) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 997) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 998) # gcc:gcc.dg/analyzer/data-model-1.c (test for warnings, line 999) # gcc:gcc.dg/analyzer/data-model-1.c status quo (test for warnings, line 509) # gcc:gcc.dg/analyzer/explode-1.c (test for warnings, line 15) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 100) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 110) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 111) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 112) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 126) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 127) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 128) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 129) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 130) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 131) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 132) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 133) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 134) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 135) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 136) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 137) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 138) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 139) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 140) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 141) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 142) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 143) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 144) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 145) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 154) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 155) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 156) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 157) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 158) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 159) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 160) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 161) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 164) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 165) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 166) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 167) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 168) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 169) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 170) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 171) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 174) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 175) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 176) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 177) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 178) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 179) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 180) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 181) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 184) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 185) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 186) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 187) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 188) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 189) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 190) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 191) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 194) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 195) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 196) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 197) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 198) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 199) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 200) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 201) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 39) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 48) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 57) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 61) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 62) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 71) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 75) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 76) # gcc:gcc.dg/analyzer/memset-1.c (test for warnings, line 92) # gcc:gcc.dg/analyzer/memset-CVE-2017-18549-1.c (test for warnings, line 100) # gcc:gcc.dg/analyzer/memset-CVE-2017-18549-1.c (test for warnings, line 101) # gcc:gcc.dg/analyzer/memset-CVE-2017-18549-1.c (test for warnings, line 102) # gcc:gcc.dg/analyzer/memset-CVE-2017-18549-1.c (test for warnings, line 103) # gcc:gcc.dg/analyzer/memset-CVE-2017-18549-1.c (test for warnings, line 104) # gcc:gcc.dg/analyzer/memset-CVE-2017-18549-1.c (test for warnings, line 105) # gcc:gcc.dg/analyzer/memset-CVE-2017-18549-1.c (test for warnings, line 106) # gcc:gcc.dg/analyzer/memset-CVE-2017-18549-1.c (test for warnings, line 62) # gcc:gcc.dg/analyzer/memset-CVE-2017-18549-1.c (test for warnings, line 63) # gcc:gcc.dg/analyzer/memset-CVE-2017-18549-1.c (test for warnings, line 64) # gcc:gcc.dg/analyzer/memset-CVE-2017-18549-1.c (test for warnings, line 65) # gcc:gcc.dg/analyzer/memset-CVE-2017-18549-1.c (test for warnings, line 66) # gcc:gcc.dg/analyzer/memset-CVE-2017-18549-1.c (test for warnings, line 67) # gcc:gcc.dg/analyzer/memset-CVE-2017-18549-1.c (test for warnings, line 68) # gcc:gcc.dg/analyzer/memset-CVE-2017-18549-1.c (test for warnings, line 71) # gcc:gcc.dg/analyzer/memset-CVE-2017-18549-1.c (test for warnings, line 72) # gcc:gcc.dg/analyzer/memset-CVE-2017-18549-1.c (test for warnings, line 98) # gcc:gcc.dg/analyzer/memset-CVE-2017-18549-1.c (test for warnings, line 99) # gcc:gcc.dg/analyzer/memset-CVE-2017-18549-1.c (test for excess errors) # gcc:gcc.dg/analyzer/symbolic-8.c (test for excess errors) # Executed from: gcc.dg/dg.exp # gcc:gcc.dg/pr101254.c (test for excess errors) # gcc:gcc.dg/pr101254.c execution test # gcc:gcc.dg/pr101266.c (test for excess errors) # Executed from: gcc.dg/vect/vect.exp # gcc:gcc.dg/vect/bb-slp-72.c (test for excess errors) # gcc:gcc.dg/vect/bb-slp-72.c -flto -ffat-lto-objects (test for excess errors) # gcc:gcc.dg/vect/bb-slp-72.c -flto -ffat-lto-objects execution test # gcc:gcc.dg/vect/bb-slp-72.c execution test # gcc:gcc.dg/vect/bb-slp-73.c (test for excess errors) # gcc:gcc.dg/vect/bb-slp-73.c -flto -ffat-lto-objects (test for excess errors) # gcc:gcc.dg/vect/bb-slp-73.c -flto -ffat-lto-objects execution test # gcc:gcc.dg/vect/bb-slp-73.c execution test # gcc:gcc.dg/vect/bb-slp-74.c (test for excess errors) # gcc:gcc.dg/vect/bb-slp-74.c -flto -ffat-lto-objects (test for excess errors) # gcc:gcc.dg/vect/bb-slp-74.c -flto -ffat-lto-objects execution test # gcc:gcc.dg/vect/bb-slp-74.c execution test # Executed from: gfortran.dg/dg.exp # gfortran:gfortran.dg/pr101264.f90 -O (test for excess errors) # gfortran:gfortran.dg/pr101267.f90 -O (test for excess errors) # Executed from: libgomp.c++/c++.exp # libgomp:libgomp.c++/../libgomp.c-c++-common/pr94366.c (test for excess errors) # libgomp:libgomp.c++/../libgomp.c-c++-common/pr94366.c execution test # Executed from: libgomp.c/c.exp # libgomp:libgomp.c/../libgomp.c-c++-common/pr94366.c (test for excess errors) # libgomp:libgomp.c/../libgomp.c-c++-common/pr94366.c execution test # Executed from: libstdc++-dg/conformance.exp # libstdc++:26_numerics/random/pr60037-neg.cc (test for errors, line 166) # libstdc++:26_numerics/random/pr60037-neg.cc (test for errors, line 3350) # # # - FAIL now PASS [FAIL => PASS]: # # Executed from: gcc.dg/debug/ctf/ctf.exp # gcc:gcc.dg/debug/ctf/ctf-skip-types-2.c (test for excess errors) # Executed from: go.test/go-test.exp # go:go.test/test/fixedbugs/issue19182.go execution, -O2 -g # # # - FAIL disappears [FAIL => ]: # # Executed from: gcc.misc-tests/help.exp # gcc:compiler driver --help=common option(s): "^ +-.*[^:.]$" absent from output: " -foffload=<targets>=<options> Specify options for the offloading targets" # # # - XFAIL disappears [XFAIL=> ]: # # Executed from: gcc.dg/analyzer/analyzer.exp # gcc:gcc.dg/analyzer/data-model-1.c desired (test for warnings, line 1038) # gcc:gcc.dg/analyzer/data-model-1.c desired (test for warnings, line 506) # gcc:gcc.dg/analyzer/data-model-1.c desired (test for warnings, line 511) # gcc:gcc.dg/analyzer/data-model-1.c desired (test for warnings, line 525) # gcc:gcc.dg/analyzer/data-model-1.c desired (test for warnings, line 528) # gcc:gcc.dg/analyzer/data-model-1.c desired (test for warnings, line 532) # gcc:gcc.dg/analyzer/data-model-1.c desired (test for warnings, line 535) # gcc:gcc.dg/analyzer/data-model-1.c uninit-warning-removed (test for warnings, line 824) # gcc:gcc.dg/analyzer/data-model-1.c uninit-warning-removed (test for warnings, line 832) # gcc:gcc.dg/analyzer/memset-1.c known nonzero (test for warnings, line 110) # gcc:gcc.dg/analyzer/memset-1.c known nonzero (test for warnings, line 112) # gcc:gcc.dg/analyzer/memset-1.c known nonzero (test for warnings, line 41) # gcc:gcc.dg/analyzer/memset-1.c known nonzero (test for warnings, line 53) # gcc:gcc.dg/analyzer/memset-1.c status quo (test for bogus messages, line 110) # gcc:gcc.dg/analyzer/memset-1.c status quo (test for bogus messages, line 112) # gcc:gcc.dg/analyzer/memset-1.c status quo (test for bogus messages, line 41) # gcc:gcc.dg/analyzer/memset-1.c status quo (test for bogus messages, line 53) # # # - XFAIL appears [ =>XFAIL]: # # Executed from: gcc.dg/analyzer/analyzer.exp # gcc:gcc.dg/analyzer/data-model-1.c desired (test for warnings, line 509) # gcc:gcc.dg/analyzer/data-model-1.c uninit-warning-removed (test for warnings, line 814) # gcc:gcc.dg/analyzer/data-model-1.c uninit-warning-removed (test for warnings, line 822) # # # - UNSUPPORTED appears [ =>UNSUP]: # # Executed from: g++.dg/dg.exp # g++:g++.dg/cpp0x/constexpr-empty16.C -std=c++98 # g++:g++.dg/cpp23/auto-array.C -std=c++98 # g++:g++.dg/cpp2a/concepts-access2.C -std=c++14 # g++:g++.dg/cpp2a/concepts-access2.C -std=c++17 # g++:g++.dg/cpp2a/concepts-access2.C -std=c++98 # g++:g++.dg/template/access41.C -std=c++98 # g++:g++.dg/template/access41a.C -std=c++98 # # # # # Regressions found # # Regressions in 12 common sum files found from (for last_good == b0ab968999c9af88d45acf552ca673ef3960306a) # reset_artifacts: -10 # build_abe bootstrap: 0 # build_abe check_bootstrap: 1 Artifacts of last_good build: https://ci.linaro.org/job/tcwg_gcc-bisect-gnu-master-arm-check_bootstrap/73… Artifacts of first_bad build: https://ci.linaro.org/job/tcwg_gcc-bisect-gnu-master-arm-check_bootstrap/73… Build top page/logs: https://ci.linaro.org/job/tcwg_gcc-bisect-gnu-master-arm-check_bootstrap/73/ Configuration details: Reproduce builds: <cut> mkdir investigate-gcc-7d8211603a3d04384812b481b0ae01205a287a72 cd investigate-gcc-7d8211603a3d04384812b481b0ae01205a287a72 git clone https://git.linaro.org/toolchain/jenkins-scripts mkdir -p artifacts/manifests curl -o artifacts/manifests/build-baseline.sh https://ci.linaro.org/job/tcwg_gcc-bisect-gnu-master-arm-check_bootstrap/73… --fail curl -o artifacts/manifests/build-parameters.sh https://ci.linaro.org/job/tcwg_gcc-bisect-gnu-master-arm-check_bootstrap/73… --fail curl -o artifacts/test.sh https://ci.linaro.org/job/tcwg_gcc-bisect-gnu-master-arm-check_bootstrap/73… --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 cd gcc # Reproduce first_bad build git checkout --detach 7d8211603a3d04384812b481b0ae01205a287a72 ../artifacts/test.sh # Reproduce last_good build git checkout --detach b0ab968999c9af88d45acf552ca673ef3960306a ../artifacts/test.sh cd .. </cut> History of pending regressions and results: https://git.linaro.org/toolchain/ci/base-artifacts.git/log/?h=linaro-local/… Artifacts: https://ci.linaro.org/job/tcwg_gcc-bisect-gnu-master-arm-check_bootstrap/73… Build log: https://ci.linaro.org/job/tcwg_gcc-bisect-gnu-master-arm-check_bootstrap/73… Full commit (up to 1000 lines): <cut> commit 7d8211603a3d04384812b481b0ae01205a287a72 Author: Richard Biener <rguenther(a)suse.de> Date: Wed Jun 30 16:28:50 2021 +0200 tree-optimization/101178 - handle VEC_PERM in SLP permute propagation This adds handling of VEC_PERM nodes to SLP permute propagation. Previously VEC_PERM acted as forced materialization of incoming permutes since it is a good place to do that (with the constraint of those only appearing for two-operator nodes). The following patch, in addition to supporting (but not forcing) this, enables VEC_PERM nodes acting as "any" permute on the outgoing side since they also can consume arbitrary permutes on that side. This again (meh) changes how we represent permutes and materialization on the graph vertices now explicitely having the common incoming permute as well as an outgoing permute and in case both are different the vertex acts as materialization point of the incoming permute. 2021-06-30 Richard Biener <rguenther(a)suse.de> PR tree-optimization/101178 * tree-vect-slp.c (slpg_vertex::materialize): Remove. (slpg::perm_in): Add. (slpg::get_perm_in): Remove. (slpg::get_perm_materialized): Add. (vect_optimize_slp): Handle VEC_PERM nodes more optimally during permute propagation and materialization. * gcc.dg/vect/bb-slp-72.c: New testcase. * gcc.dg/vect/bb-slp-73.c: Likewise. * gcc.dg/vect/bb-slp-74.c: Likewise. --- gcc/testsuite/gcc.dg/vect/bb-slp-72.c | 29 +++++ gcc/testsuite/gcc.dg/vect/bb-slp-73.c | 29 +++++ gcc/testsuite/gcc.dg/vect/bb-slp-74.c | 30 +++++ gcc/tree-vect-slp.c | 200 ++++++++++++++++++++-------------- 4 files changed, 204 insertions(+), 84 deletions(-) diff --git a/gcc/testsuite/gcc.dg/vect/bb-slp-72.c b/gcc/testsuite/gcc.dg/vect/bb-slp-72.c new file mode 100644 index 00000000000..5b243fc1ace --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/bb-slp-72.c @@ -0,0 +1,29 @@ +/* { dg-do run } */ + +#include "tree-vect.h" + +double x[2], y[2], z[2], w[2]; + +void __attribute__((noipa)) foo () +{ + double tem0 = x[1] + y[1]; + double tem1 = x[0] - y[0]; + double tem2 = z[1] * tem0; + double tem3 = z[0] * tem1; + z[0] = tem2 - w[0]; + z[1] = tem3 + w[1]; +} + +int main() +{ + check_vect (); + + x[0] = 1.; x[1] = 2.; + y[0] = 7.; y[1] = -5.; + z[0] = 2.; z[1] = 3.; + w[0] = 9.; w[1] = -5.; + foo (); + if (z[0] != -18. || z[1] != -17.) + __builtin_abort (); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/vect/bb-slp-73.c b/gcc/testsuite/gcc.dg/vect/bb-slp-73.c new file mode 100644 index 00000000000..d4c8a514b1c --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/bb-slp-73.c @@ -0,0 +1,29 @@ +/* { dg-do run } */ + +#include "tree-vect.h" + +double x[2], y[2], z[2], w[2]; + +void __attribute__((noipa)) foo () +{ + double tem0 = x[1] + y[1]; + double tem1 = x[0] - y[0]; + double tem2 = z[1] * tem0; + double tem3 = z[0] * tem1; + z[0] = tem2 - w[1]; + z[1] = tem3 + w[0]; +} + +int main() +{ + check_vect (); + + x[0] = 1.; x[1] = 2.; + y[0] = 7.; y[1] = -5.; + z[0] = 2.; z[1] = 3.; + w[0] = 9.; w[1] = -5.; + foo (); + if (z[0] != -4. || z[1] != -3.) + __builtin_abort (); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/vect/bb-slp-74.c b/gcc/testsuite/gcc.dg/vect/bb-slp-74.c new file mode 100644 index 00000000000..d3d5a02a29b --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/bb-slp-74.c @@ -0,0 +1,30 @@ +/* { dg-do run } */ + +#include "tree-vect.h" + +double a[2], b[2], c[2]; + +void __attribute__((noipa)) foo () +{ + double tem0 = a[1] + b[1]; + double tem1 = a[0] - b[0]; + c[0] = 2. * tem0; + c[1] = 5. * tem1; +} + +int main() +{ + check_vect (); + + a[0] = 1.; a[1] = 3.; + b[0] = -5.; b[1] = 13.; + foo (); + if (c[0] != 32. || c[1] != 30.) + __builtin_abort (); + return 0; +} + +/* We'd like to see at most one VEC_PERM_EXPR, not one for a blend + and one for a permute materialized somewhere else. But addsub + pattern recog can likely get in the way here. */ +/* { dg-final { scan-tree-dump-times " \[^ \]\+ = VEC_PERM_EXPR" 1 "slp2" } } */ diff --git a/gcc/tree-vect-slp.c b/gcc/tree-vect-slp.c index 10195d3629f..966b281ffae 100644 --- a/gcc/tree-vect-slp.c +++ b/gcc/tree-vect-slp.c @@ -3470,16 +3470,19 @@ vect_analyze_slp (vec_info *vinfo, unsigned max_tree_size) struct slpg_vertex { slpg_vertex (slp_tree node_) - : node (node_), perm_out (-1), materialize (0) {} + : node (node_), perm_in (-1), perm_out (-1) {} - int get_perm_in () const { return materialize ? materialize : perm_out; } + int get_perm_materialized () const + { return perm_in != perm_out ? perm_in : 0; } slp_tree node; - /* The permutation on the outgoing lanes (towards SLP parents). */ + /* The common permutation on the incoming lanes (towards SLP children). */ + int perm_in; + /* The permutation on the outgoing lanes (towards SLP parents). When + the node is a materialization point for a permute this differs + from perm_in (and is then usually zero). Materialization happens + on the input side. */ int perm_out; - /* The permutation that is applied by this node. perm_out is - relative to this. */ - int materialize; }; /* Fill the vertices and leafs vector with all nodes in the SLP graph. */ @@ -3614,7 +3617,11 @@ vect_optimize_slp (vec_info *vinfo) /* Leafs do not change across iterations. Note leafs also double as entries to the reverse graph. */ if (!slpg->vertices[idx].succ) - vertices[idx].perm_out = 0; + { + vertices[idx].perm_in = 0; + vertices[idx].perm_out = 0; + } + /* Loads are the only thing generating permutes. */ if (!SLP_TREE_LOAD_PERMUTATION (node).exists ()) continue; @@ -3663,6 +3670,7 @@ vect_optimize_slp (vec_info *vinfo) for (unsigned j = 0; j < SLP_TREE_LANES (node); ++j) perm[j] = SLP_TREE_LOAD_PERMUTATION (node)[j] - imin; perms.safe_push (perm); + vertices[idx].perm_in = perms.length () - 1; vertices[idx].perm_out = perms.length () - 1; } @@ -3702,8 +3710,11 @@ vect_optimize_slp (vec_info *vinfo) if (STMT_VINFO_DATA_REF (rep) && DR_IS_WRITE (STMT_VINFO_DATA_REF (rep))) { + /* ??? We're forcing materialization in place + of the child here, we'd need special handling + in materialization to leave perm_in -1 here. */ + vertices[idx].perm_in = 0; vertices[idx].perm_out = 0; - continue; } /* We cannot move a permute across an operation that is not independent on lanes. Note this is an explicit @@ -3717,20 +3728,19 @@ vect_optimize_slp (vec_info *vinfo) case CFN_COMPLEX_MUL: case CFN_COMPLEX_MUL_CONJ: case CFN_VEC_ADDSUB: + vertices[idx].perm_in = 0; vertices[idx].perm_out = 0; - continue; default:; } } - int perm; if (!slpg->vertices[idx].succ) /* Pick up pre-computed leaf values. */ - perm = vertices[idx].perm_out; + ; else { bool any_succ_perm_out_m1 = false; - perm = vertices[idx].get_perm_in (); + int perm_in = vertices[idx].perm_in; for (graph_edge *succ = slpg->vertices[idx].succ; succ; succ = succ->succ_next) { @@ -3752,18 +3762,18 @@ vect_optimize_slp (vec_info *vinfo) any_succ_perm_out_m1 = true; continue; } - if (perm == -1) - perm = succ_perm; + if (perm_in == -1) + perm_in = succ_perm; else if (succ_perm == 0 - || !vect_slp_perms_eq (perms, perm, succ_perm)) + || !vect_slp_perms_eq (perms, perm_in, succ_perm)) { - perm = 0; + perm_in = 0; break; } } /* Adjust any incoming permutes we treated optimistically. */ - if (perm != -1 && any_succ_perm_out_m1) + if (perm_in != -1 && any_succ_perm_out_m1) { for (graph_edge *succ = slpg->vertices[idx].succ; succ; succ = succ->succ_next) @@ -3772,24 +3782,36 @@ vect_optimize_slp (vec_info *vinfo) if (vertices[succ->dest].perm_out == -1 && SLP_TREE_DEF_TYPE (succ_node) != vect_external_def && SLP_TREE_DEF_TYPE (succ_node) != vect_constant_def) - vertices[succ->dest].perm_out = perm; + { + vertices[succ->dest].perm_out = perm_in; + /* And ensure this propagates. */ + if (vertices[succ->dest].perm_in == -1) + vertices[succ->dest].perm_in = perm_in; + } } changed = true; } - if (!vect_slp_perms_eq (perms, perm, - vertices[idx].get_perm_in ())) + if (!vect_slp_perms_eq (perms, perm_in, + vertices[idx].perm_in)) { /* Make sure we eventually converge. */ - gcc_checking_assert (vertices[idx].get_perm_in () == -1 - || perm == 0); - if (perm == 0) - { - vertices[idx].perm_out = 0; - vertices[idx].materialize = 0; - } - if (!vertices[idx].materialize) - vertices[idx].perm_out = perm; + gcc_checking_assert (vertices[idx].perm_in == -1 + || perm_in == 0); + vertices[idx].perm_in = perm_in; + + /* While we can handle VEC_PERM nodes as transparent + pass-through they can be a cheap materialization + point as well. In addition they can act as source + of a random permutation as well. + The following ensures that former materialization + points that now have zero incoming permutes no + longer appear as such and that former "any" permutes + get pass-through. We keep VEC_PERM nodes optimistic + as "any" outgoing permute though. */ + if (vertices[idx].perm_out != 0 + && SLP_TREE_CODE (node) != VEC_PERM_EXPR) + vertices[idx].perm_out = perm_in; changed = true; } } @@ -3799,25 +3821,19 @@ vect_optimize_slp (vec_info *vinfo) if (!do_materialization) continue; + int perm = vertices[idx].perm_out; if (perm == 0 || perm == -1) continue; /* Decide on permute materialization. Look whether there's a use (pred) edge that is permuted differently than us. - In that case mark ourselves so the permutation is applied. - For VEC_PERM_EXPRs the permutation doesn't carry along - from children to parents so force materialization at the - point of the VEC_PERM_EXPR. In principle VEC_PERM_EXPRs - are a source of an arbitrary permutation again, similar - to constants/externals - that's something we do not yet - optimally handle. */ - bool all_preds_permuted = (SLP_TREE_CODE (node) != VEC_PERM_EXPR - && slpg->vertices[idx].pred != NULL); + In that case mark ourselves so the permutation is applied. */ + bool all_preds_permuted = slpg->vertices[idx].pred != NULL; if (all_preds_permuted) for (graph_edge *pred = slpg->vertices[idx].pred; pred; pred = pred->pred_next) { - int pred_perm = vertices[pred->src].get_perm_in (); + int pred_perm = vertices[pred->src].perm_in; gcc_checking_assert (pred_perm != -1); if (!vect_slp_perms_eq (perms, perm, pred_perm)) { @@ -3827,10 +3843,8 @@ vect_optimize_slp (vec_info *vinfo) } if (!all_preds_permuted) { - if (!vertices[idx].materialize) - changed = true; - vertices[idx].materialize = perm; vertices[idx].perm_out = 0; + changed = true; } } @@ -3848,46 +3862,43 @@ vect_optimize_slp (vec_info *vinfo) /* Materialize. */ for (i = 0; i < vertices.length (); ++i) { - int perm = vertices[i].get_perm_in (); - if (perm <= 0) - continue; - + int perm_in = vertices[i].perm_in; slp_tree node = vertices[i].node; - /* First permute invariant/external original successors. */ + /* First permute invariant/external original successors, we handle + those optimistically during propagation and duplicate them if + they are used with different permutations. */ unsigned j; slp_tree child; - FOR_EACH_VEC_ELT (SLP_TREE_CHILDREN (node), j, child) - { - if (!child - || (SLP_TREE_DEF_TYPE (child) != vect_constant_def - && SLP_TREE_DEF_TYPE (child) != vect_external_def)) - continue; + if (perm_in > 0) + FOR_EACH_VEC_ELT (SLP_TREE_CHILDREN (node), j, child) + { + if (!child + || (SLP_TREE_DEF_TYPE (child) != vect_constant_def + && SLP_TREE_DEF_TYPE (child) != vect_external_def)) + continue; - /* If the vector is uniform there's nothing to do. */ - if (vect_slp_tree_uniform_p (child)) - continue; + /* If the vector is uniform there's nothing to do. */ + if (vect_slp_tree_uniform_p (child)) + continue; - /* We can end up sharing some externals via two_operator - handling. Be prepared to unshare those. */ - if (child->refcnt != 1) - { - gcc_assert (slpg->vertices[child->vertex].pred->pred_next); - SLP_TREE_CHILDREN (node)[j] = child - = vect_create_new_slp_node - (SLP_TREE_SCALAR_OPS (child).copy ()); - } - vect_slp_permute (perms[perm], - SLP_TREE_SCALAR_OPS (child), true); - } + /* We can end up sharing some externals via two_operator + handling. Be prepared to unshare those. */ + if (child->refcnt != 1) + { + gcc_assert (slpg->vertices[child->vertex].pred->pred_next); + SLP_TREE_CHILDREN (node)[j] = child + = vect_create_new_slp_node + (SLP_TREE_SCALAR_OPS (child).copy ()); + } + vect_slp_permute (perms[perm_in], + SLP_TREE_SCALAR_OPS (child), true); + } - if (vertices[i].materialize) + if (SLP_TREE_CODE (node) == VEC_PERM_EXPR) { - if (SLP_TREE_LOAD_PERMUTATION (node).exists ()) - /* For loads simply drop the permutation, the load permutation - already performs the desired permutation. */ - ; - else if (SLP_TREE_LANE_PERMUTATION (node).exists ()) + /* Apply the common permutes to the input vectors. */ + if (perm_in > 0) { /* If the node is already a permute node we can apply the permutation to the lane selection, effectively @@ -3896,12 +3907,30 @@ vect_optimize_slp (vec_info *vinfo) dump_printf_loc (MSG_NOTE, vect_location, "simplifying permute node %p\n", node); - for (unsigned k = 0; k < SLP_TREE_LANE_PERMUTATION (node).length (); ++k) SLP_TREE_LANE_PERMUTATION (node)[k].second - = perms[perm][SLP_TREE_LANE_PERMUTATION (node)[k].second]; + = perms[perm_in][SLP_TREE_LANE_PERMUTATION (node)[k].second]; + } + /* Apply the anticipated output permute to the permute and + stmt vectors. */ + int perm_out = vertices[i].perm_out; + if (perm_out > 0) + { + vect_slp_permute (perms[perm_out], + SLP_TREE_SCALAR_STMTS (node), true); + vect_slp_permute (perms[perm_out], + SLP_TREE_LANE_PERMUTATION (node), true); } + } + else if (vertices[i].get_perm_materialized () != 0) + { + if (SLP_TREE_LOAD_PERMUTATION (node).exists ()) + /* For loads simply drop the permutation, the load permutation + already performs the desired permutation. */ + ; + else if (SLP_TREE_LANE_PERMUTATION (node).exists ()) + gcc_unreachable (); else { if (dump_enabled_p ()) @@ -3916,7 +3945,7 @@ vect_optimize_slp (vec_info *vinfo) SLP_TREE_CHILDREN (node) = vNULL; SLP_TREE_SCALAR_STMTS (copy) = SLP_TREE_SCALAR_STMTS (node).copy (); - vect_slp_permute (perms[perm], + vect_slp_permute (perms[perm_in], SLP_TREE_SCALAR_STMTS (copy), true); gcc_assert (!SLP_TREE_SCALAR_OPS (node).exists ()); SLP_TREE_REPRESENTATIVE (copy) = SLP_TREE_REPRESENTATIVE (node); @@ -3936,28 +3965,31 @@ vect_optimize_slp (vec_info *vinfo) SLP_TREE_LANE_PERMUTATION (node).create (SLP_TREE_LANES (node)); for (unsigned j = 0; j < SLP_TREE_LANES (node); ++j) SLP_TREE_LANE_PERMUTATION (node) - .quick_push (std::make_pair (0, perms[perm][j])); + .quick_push (std::make_pair (0, perms[perm_in][j])); SLP_TREE_CODE (node) = VEC_PERM_EXPR; } } - else + else if (perm_in > 0) /* perm_in == perm_out */ { /* Apply the reverse permutation to our stmts. */ - vect_slp_permute (perms[perm], + vect_slp_permute (perms[perm_in], SLP_TREE_SCALAR_STMTS (node), true); - /* And to the load permutation, which we can simply + /* And to the lane/load permutation, which we can simply make regular by design. */ if (SLP_TREE_LOAD_PERMUTATION (node).exists ()) { + gcc_assert (!SLP_TREE_LANE_PERMUTATION (node).exists ()); /* ??? When we handle non-bijective permutes the idea is that we can force the load-permutation to be { min, min + 1, min + 2, ... max }. But then the scalar defs might no longer match the lane content which means wrong-code with live lane vectorization. So we possibly have to have NULL entries for those. */ - vect_slp_permute (perms[perm], + vect_slp_permute (perms[perm_in], SLP_TREE_LOAD_PERMUTATION (node), true); } + else if (SLP_TREE_LANE_PERMUTATION (node).exists ()) + gcc_unreachable (); } } @@ -3991,14 +4023,14 @@ vect_optimize_slp (vec_info *vinfo) } else if (SLP_TREE_LOAD_PERMUTATION (old).exists () && SLP_TREE_REF_COUNT (old) == 1 - && vertices[old->vertex].materialize) + && vertices[old->vertex].get_perm_materialized () != 0) { /* ??? For loads the situation is more complex since we can't modify the permute in place in case the node is used multiple times. In fact for loads this should be somehow handled in the propagation engine. */ /* Apply the reverse permutation to our stmts. */ - int perm = vertices[old->vertex].get_perm_in (); + int perm = vertices[old->vertex].get_perm_materialized (); vect_slp_permute (perms[perm], SLP_TREE_SCALAR_STMTS (old), true); vect_slp_permute (perms[perm], </cut>

4 years

[CI-NOTIFY]: TCWG Bisect tcwg_bmk_tk1/gnu-release-arm-spec2k6-O3_LTO - Build # 26 - Successful!

by ci_notify＠linaro.org

Successfully identified regression in *gcc* in CI configuration tcwg_bmk_gnu_tk1/gnu-release-arm-spec2k6-O3_LTO. So far, this commit has regressed CI configurations: - tcwg_bmk_gnu_tk1/gnu-release-arm-spec2k6-O3_LTO Culprit: <cut> commit 9b0365879b3c4917f5a2485a1fca8bb678484bfe Author: Richard Sandiford <richard.sandiford(a)arm.com> Date: Mon Oct 7 08:39:12 2019 +0000 [IRA] Handle fully-tied destinations in a similar way to earlyclobbers IRA's make_early_clobber_and_input_conflicts checks for cases in which an output operand is likely to be an earlyclobber and an input operand is unlikely to be tieable with it. If so, the allocno for the output conflicts with the allocno for the input. This seems to work well. However, a similar situation arises if an output operand is likely to be tied to one of a set of input operands X and if another input operand has a different value from all of the operands in X. E.g. if we have: 0: "=r, r" 1: "0, r" 2: "r, 0" 3: "r, r" operand 0 will always be tied to operand 1 or operand 2, so if operand 3 is different from them both, operand 0 acts like an earlyclobber as far as operand 3 (only) is concerned. The same is true for operand 2 in: 0: "=r" 1: "0" 2: "r" In the second example, we'd normally have a copy between operand 1 and operand 0 if operand 1 dies in the instruction, and so there's rarely a problem. But if operand 1 doesn't die in the instruction, operand 0 still acts as an earlyclobber for operand 2 (if different from operand 1), since in that case LRA must copy operand 1 to operand 0 before the instruction. As the existing comment says: Avoid introducing unnecessary conflicts by checking classes of the constraints and pseudos because otherwise significant code degradation is possible for some targets. I think that's doubly true here. E.g. it's perfectly reasonable to have constraints like: 0: "=r, r" 1: "0, r" 2: "r, r" on targets like s390 that have shorter instructions for tied operands, but that don't want the size difference to influence RA too much. We shouldn't treat operand 0 as earlyclobber wrt operand 2 in that case. This patch therefore treats a normal tied non-earlyclobber output as being effectively earlyclobber wrt to an input if it is so for *all* preferred alternatives. 2019-10-07 Richard Sandiford <richard.sandiford(a)arm.com> gcc/ * ira-lives.c (check_and_make_def_conflict): Handle cases in which DEF is not a true earlyclobber but is tied to a specific input operand, and so is effectively earlyclobber wrt inputs that have different values. (make_early_clobber_and_input_conflicts): Pass this case to the above. From-SVN: r276650 </cut> Results regressed to (for first_bad == 9b0365879b3c4917f5a2485a1fca8bb678484bfe) # reset_artifacts: -10 # build_abe binutils: -9 # build_abe stage1 -- --set gcc_override_configure=--with-mode=arm --set gcc_override_configure=--disable-libsanitizer: -8 # build_abe linux: -7 # build_abe glibc: -6 # build_abe stage2 -- --set gcc_override_configure=--with-mode=arm --set gcc_override_configure=--disable-libsanitizer: -5 # true: 0 # benchmark -O3_LTO_marm -- artifacts/build-9b0365879b3c4917f5a2485a1fca8bb678484bfe/results_id: 1 # 470.lbm,lbm_base.default regressed by 122 # 454.calculix,calculix_base.default regressed by 105 from (for last_good == ad00d6c1746fdcbfd86b2d50f2500d7ccb0d1691) # reset_artifacts: -10 # build_abe binutils: -9 # build_abe stage1 -- --set gcc_override_configure=--with-mode=arm --set gcc_override_configure=--disable-libsanitizer: -8 # build_abe linux: -7 # build_abe glibc: -6 # build_abe stage2 -- --set gcc_override_configure=--with-mode=arm --set gcc_override_configure=--disable-libsanitizer: -5 # true: 0 # benchmark -O3_LTO_marm -- artifacts/build-ad00d6c1746fdcbfd86b2d50f2500d7ccb0d1691/results_id: 1 Artifacts of last_good build: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tk1-gnu-release-a… Results ID of last_good: tk1_32/tcwg_bmk_gnu_tk1/bisect-gnu-release-arm-spec2k6-O3_LTO/1079 Artifacts of first_bad build: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tk1-gnu-release-a… Results ID of first_bad: tk1_32/tcwg_bmk_gnu_tk1/bisect-gnu-release-arm-spec2k6-O3_LTO/1049 Build top page/logs: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tk1-gnu-release-a… Configuration details: Reproduce builds: <cut> mkdir investigate-gcc-9b0365879b3c4917f5a2485a1fca8bb678484bfe cd investigate-gcc-9b0365879b3c4917f5a2485a1fca8bb678484bfe git clone https://git.linaro.org/toolchain/jenkins-scripts mkdir -p artifacts/manifests curl -o artifacts/manifests/build-baseline.sh https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tk1-gnu-release-a… --fail curl -o artifacts/manifests/build-parameters.sh https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tk1-gnu-release-a… --fail curl -o artifacts/test.sh https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tk1-gnu-release-a… --fail chmod +x artifacts/test.sh # Reproduce the baseline build (build all pre-requisites) ./jenkins-scripts/tcwg_bmk-build.sh @@ artifacts/manifests/build-baseline.sh cd gcc # Reproduce first_bad build git checkout --detach 9b0365879b3c4917f5a2485a1fca8bb678484bfe ../artifacts/test.sh # Reproduce last_good build git checkout --detach ad00d6c1746fdcbfd86b2d50f2500d7ccb0d1691 ../artifacts/test.sh cd .. </cut> History of pending regressions and results: https://git.linaro.org/toolchain/ci/base-artifacts.git/log/?h=linaro-local/… Artifacts: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tk1-gnu-release-a… Build log: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tk1-gnu-release-a… Full commit (up to 1000 lines): <cut> commit 9b0365879b3c4917f5a2485a1fca8bb678484bfe Author: Richard Sandiford <richard.sandiford(a)arm.com> Date: Mon Oct 7 08:39:12 2019 +0000 [IRA] Handle fully-tied destinations in a similar way to earlyclobbers IRA's make_early_clobber_and_input_conflicts checks for cases in which an output operand is likely to be an earlyclobber and an input operand is unlikely to be tieable with it. If so, the allocno for the output conflicts with the allocno for the input. This seems to work well. However, a similar situation arises if an output operand is likely to be tied to one of a set of input operands X and if another input operand has a different value from all of the operands in X. E.g. if we have: 0: "=r, r" 1: "0, r" 2: "r, 0" 3: "r, r" operand 0 will always be tied to operand 1 or operand 2, so if operand 3 is different from them both, operand 0 acts like an earlyclobber as far as operand 3 (only) is concerned. The same is true for operand 2 in: 0: "=r" 1: "0" 2: "r" In the second example, we'd normally have a copy between operand 1 and operand 0 if operand 1 dies in the instruction, and so there's rarely a problem. But if operand 1 doesn't die in the instruction, operand 0 still acts as an earlyclobber for operand 2 (if different from operand 1), since in that case LRA must copy operand 1 to operand 0 before the instruction. As the existing comment says: Avoid introducing unnecessary conflicts by checking classes of the constraints and pseudos because otherwise significant code degradation is possible for some targets. I think that's doubly true here. E.g. it's perfectly reasonable to have constraints like: 0: "=r, r" 1: "0, r" 2: "r, r" on targets like s390 that have shorter instructions for tied operands, but that don't want the size difference to influence RA too much. We shouldn't treat operand 0 as earlyclobber wrt operand 2 in that case. This patch therefore treats a normal tied non-earlyclobber output as being effectively earlyclobber wrt to an input if it is so for *all* preferred alternatives. 2019-10-07 Richard Sandiford <richard.sandiford(a)arm.com> gcc/ * ira-lives.c (check_and_make_def_conflict): Handle cases in which DEF is not a true earlyclobber but is tied to a specific input operand, and so is effectively earlyclobber wrt inputs that have different values. (make_early_clobber_and_input_conflicts): Pass this case to the above. From-SVN: r276650 --- gcc/ChangeLog | 8 ++++++ gcc/ira-lives.c | 86 +++++++++++++++++++++++++++++++++++++++++++++++---------- 2 files changed, 80 insertions(+), 14 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index ce915859592..798d16cf0c6 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,11 @@ +2019-10-07 Richard Sandiford <richard.sandiford(a)arm.com> + + * ira-lives.c (check_and_make_def_conflict): Handle cases in which + DEF is not a true earlyclobber but is tied to a specific input + operand, and so is effectively earlyclobber wrt inputs that have + different values. + (make_early_clobber_and_input_conflicts): Pass this case to the above. + 2019-10-07 Richard Sandiford <richard.sandiford(a)arm.com> * machmode.h (opt_mode): Mark constructors with CONSTEXPR. diff --git a/gcc/ira-lives.c b/gcc/ira-lives.c index cce73a1c3d4..098b0e73953 100644 --- a/gcc/ira-lives.c +++ b/gcc/ira-lives.c @@ -633,9 +633,28 @@ check_and_make_def_use_conflict (rtx dreg, rtx orig_dreg, /* Check and make if necessary conflicts for definition DEF of class DEF_CL of the current insn with input operands. Process only - constraints of alternative ALT. */ + constraints of alternative ALT. + + One of three things is true when this function is called: + + (1) DEF is an earlyclobber for alternative ALT. Input operands then + conflict with DEF in ALT unless they explicitly match DEF via 0-9 + constraints. + + (2) DEF matches (via 0-9 constraints) an operand that is an + earlyclobber for alternative ALT. Other input operands then + conflict with DEF in ALT. + + (3) [FOR_TIE_P] Some input operand X matches DEF for alternative ALT. + Input operands with a different value from X then conflict with + DEF in ALT. + + However, there's still a judgement call to make when deciding + whether a conflict in ALT is important enough to be reflected + in the pan-alternative allocno conflict set. */ static void -check_and_make_def_conflict (int alt, int def, enum reg_class def_cl) +check_and_make_def_conflict (int alt, int def, enum reg_class def_cl, + bool for_tie_p) { int use, use_match; ira_allocno_t a; @@ -669,14 +688,40 @@ check_and_make_def_conflict (int alt, int def, enum reg_class def_cl) if (use == def || recog_data.operand_type[use] == OP_OUT) continue; + /* An earlyclobber on DEF doesn't apply to an input operand X if X + explicitly matches DEF, but it applies to other input operands + even if they happen to be the same value as X. + + In contrast, if an input operand X is tied to a non-earlyclobber + DEF, there's no conflict with other input operands that have the + same value as X. */ + if (op_alt[use].matches == def + || (for_tie_p + && rtx_equal_p (recog_data.operand[use], + recog_data.operand[op_alt[def].matched]))) + continue; + if (op_alt[use].anything_ok) use_cl = ALL_REGS; else use_cl = op_alt[use].cl; + if (use_cl == NO_REGS) + continue; + + /* If DEF is simply a tied operand, ignore cases in which this + alternative requires USE to have a likely-spilled class. + Adding a conflict would just constrain USE further if DEF + happens to be allocated first. */ + if (for_tie_p && targetm.class_likely_spilled_p (use_cl)) + continue; /* If there's any alternative that allows USE to match DEF, do not record a conflict. If that causes us to create an invalid - instruction due to the earlyclobber, reload must fix it up. */ + instruction due to the earlyclobber, reload must fix it up. + + Likewise, if we're treating a tied DEF like a partial earlyclobber, + do not record a conflict if there's another alternative in which + DEF is neither tied nor earlyclobber. */ for (alt1 = 0; alt1 < recog_data.n_alternatives; alt1++) { if (!TEST_BIT (preferred_alternatives, alt1)) @@ -691,6 +736,12 @@ check_and_make_def_conflict (int alt, int def, enum reg_class def_cl) && recog_data.constraints[use - 1][0] == '%' && op_alt1[use - 1].matches == def)) break; + if (for_tie_p + && !op_alt1[def].earlyclobber + && op_alt1[def].matched < 0 + && alternative_class (op_alt1, def) != NO_REGS + && alternative_class (op_alt1, use) != NO_REGS) + break; } if (alt1 < recog_data.n_alternatives) @@ -701,8 +752,7 @@ check_and_make_def_conflict (int alt, int def, enum reg_class def_cl) if ((use_match = op_alt[use].matches) >= 0) { - if (use_match == def) - continue; + gcc_checking_assert (use_match != def); if (op_alt[use_match].anything_ok) use_cl = ALL_REGS; @@ -717,7 +767,11 @@ check_and_make_def_conflict (int alt, int def, enum reg_class def_cl) /* Make conflicts of early clobber pseudo registers of the current insn with its inputs. Avoid introducing unnecessary conflicts by checking classes of the constraints and pseudos because otherwise - significant code degradation is possible for some targets. */ + significant code degradation is possible for some targets. + + For these purposes, tying an input to an output makes that output act + like an earlyclobber for inputs with a different value, since the output + register then has a predetermined purpose on input to the instruction. */ static void make_early_clobber_and_input_conflicts (void) { @@ -732,15 +786,19 @@ make_early_clobber_and_input_conflicts (void) if (TEST_BIT (preferred_alternatives, alt)) for (def = 0; def < n_operands; def++) { - def_cl = NO_REGS; - if (op_alt[def].earlyclobber) + if (op_alt[def].anything_ok) + def_cl = ALL_REGS; + else + def_cl = op_alt[def].cl; + if (def_cl != NO_REGS) { - if (op_alt[def].anything_ok) - def_cl = ALL_REGS; - else - def_cl = op_alt[def].cl; - check_and_make_def_conflict (alt, def, def_cl); + if (op_alt[def].earlyclobber) + check_and_make_def_conflict (alt, def, def_cl, false); + else if (op_alt[def].matched >= 0 + && !targetm.class_likely_spilled_p (def_cl)) + check_and_make_def_conflict (alt, def, def_cl, true); } + if ((def_match = op_alt[def].matches) >= 0 && (op_alt[def_match].earlyclobber || op_alt[def].earlyclobber)) @@ -749,7 +807,7 @@ make_early_clobber_and_input_conflicts (void) def_cl = ALL_REGS; else def_cl = op_alt[def_match].cl; - check_and_make_def_conflict (alt, def, def_cl); + check_and_make_def_conflict (alt, def, def_cl, false); } } } </cut>

4 years

[CI-NOTIFY]: TCWG Bisect tcwg_bmk_tx1/gnu-master-aarch64-spec2k6-O3 - Build # 28 - Successful!

by ci_notify＠linaro.org

Successfully identified regression in *gcc* in CI configuration tcwg_bmk_gnu_tx1/gnu-master-aarch64-spec2k6-O3. So far, this commit has regressed CI configurations: - tcwg_bmk_gnu_tx1/gnu-master-aarch64-spec2k6-O3 Culprit: <cut> commit a7e655ae4016eaf04e261ff32fc67a14ebb0e329 Author: Andrew MacLeod <amacleod(a)redhat.com> Date: Fri Jun 25 11:24:30 2021 -0400 Add stmt context in simplify_using_ranges. There were places simplify_using_ranges was not utilzing the stmt context. * vr-values.c (vr_values::vrp_stmt_computes_nonzero): Use stmt. (simplify_using_ranges::op_with_boolean_value_range_p): Add a statement for location context. (check_for_binary_op_overflow): Ditto. (simplify_using_ranges::get_vr_for_comparison): Ditto. (simplify_using_ranges::compare_name_with_value): Ditto. (simplify_using_ranges::compare_names): Ditto. (vrp_evaluate_conditional_warnv_with_ops_using_ranges): Ditto. (simplify_using_ranges::simplify_truth_ops_using_ranges): Ditto. (simplify_using_ranges::simplify_min_or_max_using_ranges): Ditto. (simplify_using_ranges::simplify_internal_call_using_ranges): Ditto. (simplify_using_ranges::two_valued_val_range_p): Ditto. (simplify_using_ranges::simplify): Ditto. * vr-values.h: Adjust prototypes. </cut> Results regressed to (for first_bad == a7e655ae4016eaf04e261ff32fc67a14ebb0e329) # reset_artifacts: -10 # build_abe binutils: -9 # build_abe stage1 -- --set gcc_override_configure=--disable-libsanitizer: -8 # build_abe linux: -7 # build_abe glibc: -6 # build_abe stage2 -- --set gcc_override_configure=--disable-libsanitizer: -5 # true: 0 # benchmark -O3 -- artifacts/build-a7e655ae4016eaf04e261ff32fc67a14ebb0e329/results_id: 1 # 447.dealII,dealII_base.default regressed by 104 # 447.dealII,[.] _ZNK12SparseMatrixIdE5vmultI6VectorIdES3_EEvRT regressed by 125 from (for last_good == 8a8a7d332d5d01db5aea7336a36d9fd71a679fb1) # reset_artifacts: -10 # build_abe binutils: -9 # build_abe stage1 -- --set gcc_override_configure=--disable-libsanitizer: -8 # build_abe linux: -7 # build_abe glibc: -6 # build_abe stage2 -- --set gcc_override_configure=--disable-libsanitizer: -5 # true: 0 # benchmark -O3 -- artifacts/build-8a8a7d332d5d01db5aea7336a36d9fd71a679fb1/results_id: 1 Artifacts of last_good build: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tx1-gnu-master-aa… Results ID of last_good: tx1_64/tcwg_bmk_gnu_tx1/bisect-gnu-master-aarch64-spec2k6-O3/1076 Artifacts of first_bad build: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tx1-gnu-master-aa… Results ID of first_bad: tx1_64/tcwg_bmk_gnu_tx1/bisect-gnu-master-aarch64-spec2k6-O3/1068 Build top page/logs: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tx1-gnu-master-aa… Configuration details: Reproduce builds: <cut> mkdir investigate-gcc-a7e655ae4016eaf04e261ff32fc67a14ebb0e329 cd investigate-gcc-a7e655ae4016eaf04e261ff32fc67a14ebb0e329 git clone https://git.linaro.org/toolchain/jenkins-scripts mkdir -p artifacts/manifests curl -o artifacts/manifests/build-baseline.sh https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tx1-gnu-master-aa… --fail curl -o artifacts/manifests/build-parameters.sh https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tx1-gnu-master-aa… --fail curl -o artifacts/test.sh https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tx1-gnu-master-aa… --fail chmod +x artifacts/test.sh # Reproduce the baseline build (build all pre-requisites) ./jenkins-scripts/tcwg_bmk-build.sh @@ artifacts/manifests/build-baseline.sh cd gcc # Reproduce first_bad build git checkout --detach a7e655ae4016eaf04e261ff32fc67a14ebb0e329 ../artifacts/test.sh # Reproduce last_good build git checkout --detach 8a8a7d332d5d01db5aea7336a36d9fd71a679fb1 ../artifacts/test.sh cd .. </cut> History of pending regressions and results: https://git.linaro.org/toolchain/ci/base-artifacts.git/log/?h=linaro-local/… Artifacts: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tx1-gnu-master-aa… Build log: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tx1-gnu-master-aa… Full commit (up to 1000 lines): <cut> commit a7e655ae4016eaf04e261ff32fc67a14ebb0e329 Author: Andrew MacLeod <amacleod(a)redhat.com> Date: Fri Jun 25 11:24:30 2021 -0400 Add stmt context in simplify_using_ranges. There were places simplify_using_ranges was not utilzing the stmt context. * vr-values.c (vr_values::vrp_stmt_computes_nonzero): Use stmt. (simplify_using_ranges::op_with_boolean_value_range_p): Add a statement for location context. (check_for_binary_op_overflow): Ditto. (simplify_using_ranges::get_vr_for_comparison): Ditto. (simplify_using_ranges::compare_name_with_value): Ditto. (simplify_using_ranges::compare_names): Ditto. (vrp_evaluate_conditional_warnv_with_ops_using_ranges): Ditto. (simplify_using_ranges::simplify_truth_ops_using_ranges): Ditto. (simplify_using_ranges::simplify_min_or_max_using_ranges): Ditto. (simplify_using_ranges::simplify_internal_call_using_ranges): Ditto. (simplify_using_ranges::two_valued_val_range_p): Ditto. (simplify_using_ranges::simplify): Ditto. * vr-values.h: Adjust prototypes. --- gcc/vr-values.c | 71 ++++++++++++++++++++++++++++++--------------------------- gcc/vr-values.h | 14 +++++++----- 2 files changed, 46 insertions(+), 39 deletions(-) diff --git a/gcc/vr-values.c b/gcc/vr-values.c index 3ae2c68499d..190676de2c0 100644 --- a/gcc/vr-values.c +++ b/gcc/vr-values.c @@ -429,7 +429,7 @@ vr_values::vrp_stmt_computes_nonzero (gimple *stmt) && !TYPE_OVERFLOW_WRAPS (TREE_TYPE (expr)))) { const value_range_equiv *vr - = get_value_range (TREE_OPERAND (base, 0)); + = get_value_range (TREE_OPERAND (base, 0), stmt); if (!range_includes_zero_p (vr)) return true; } @@ -486,7 +486,7 @@ vr_values::op_with_constant_singleton_value_range (tree op) /* Return true if op is in a boolean [0, 1] value-range. */ bool -simplify_using_ranges::op_with_boolean_value_range_p (tree op) +simplify_using_ranges::op_with_boolean_value_range_p (tree op, gimple *s) { if (TYPE_PRECISION (TREE_TYPE (op)) == 1) return true; @@ -500,7 +500,7 @@ simplify_using_ranges::op_with_boolean_value_range_p (tree op) /* ?? Errr, this should probably check for [0,0] and [1,1] as well as [0,1]. */ - const value_range *vr = query->get_value_range (op); + const value_range *vr = query->get_value_range (op, s); return *vr == value_range (build_zero_cst (TREE_TYPE (op)), build_one_cst (TREE_TYPE (op))); } @@ -1057,18 +1057,18 @@ vr_values::extract_range_from_comparison (value_range_equiv *vr, static bool check_for_binary_op_overflow (range_query *query, enum tree_code subcode, tree type, - tree op0, tree op1, bool *ovf) + tree op0, tree op1, bool *ovf, gimple *s = NULL) { value_range vr0, vr1; if (TREE_CODE (op0) == SSA_NAME) - vr0 = *query->get_value_range (op0); + vr0 = *query->get_value_range (op0, s); else if (TREE_CODE (op0) == INTEGER_CST) vr0.set (op0); else vr0.set_varying (TREE_TYPE (op0)); if (TREE_CODE (op1) == SSA_NAME) - vr1 = *query->get_value_range (op1); + vr1 = *query->get_value_range (op1, s); else if (TREE_CODE (op1) == INTEGER_CST) vr1.set (op1); else @@ -1980,10 +1980,11 @@ vr_values::vrp_visit_assignment_or_call (gimple *stmt, tree *output_p, is varying or undefined. Uses TEM as storage for the alternate range. */ const value_range_equiv * -simplify_using_ranges::get_vr_for_comparison (int i, value_range_equiv *tem) +simplify_using_ranges::get_vr_for_comparison (int i, value_range_equiv *tem, + gimple *s) { /* Shallow-copy equiv bitmap. */ - const value_range_equiv *vr = query->get_value_range (ssa_name (i)); + const value_range_equiv *vr = query->get_value_range (ssa_name (i), s); /* If name N_i does not have a valid range, use N_i as its own range. This allows us to compare against names that may @@ -2005,10 +2006,11 @@ simplify_using_ranges::get_vr_for_comparison (int i, value_range_equiv *tem) tree simplify_using_ranges::compare_name_with_value (enum tree_code comp, tree var, tree val, - bool *strict_overflow_p, bool use_equiv_p) + bool *strict_overflow_p, bool use_equiv_p, + gimple *s) { /* Get the set of equivalences for VAR. */ - bitmap e = query->get_value_range (var)->equiv (); + bitmap e = query->get_value_range (var, s)->equiv (); /* Start at -1. Set it to 0 if we do a comparison without relying on overflow, or 1 if all comparisons rely on overflow. */ @@ -2017,7 +2019,7 @@ simplify_using_ranges::compare_name_with_value /* Compare vars' value range with val. */ value_range_equiv tem_vr; const value_range_equiv *equiv_vr - = get_vr_for_comparison (SSA_NAME_VERSION (var), &tem_vr); + = get_vr_for_comparison (SSA_NAME_VERSION (var), &tem_vr, s); bool sop = false; tree retval = compare_range_with_value (comp, equiv_vr, val, &sop); if (retval) @@ -2044,7 +2046,7 @@ simplify_using_ranges::compare_name_with_value && prop_simulate_again_p (SSA_NAME_DEF_STMT (name))) continue; - equiv_vr = get_vr_for_comparison (i, &tem_vr); + equiv_vr = get_vr_for_comparison (i, &tem_vr, s); sop = false; tree t = compare_range_with_value (comp, equiv_vr, val, &sop); if (t) @@ -2084,12 +2086,12 @@ simplify_using_ranges::compare_name_with_value tree simplify_using_ranges::compare_names (enum tree_code comp, tree n1, tree n2, - bool *strict_overflow_p) + bool *strict_overflow_p, gimple *s) { /* Compare the ranges of every name equivalent to N1 against the ranges of every name equivalent to N2. */ - bitmap e1 = query->get_value_range (n1)->equiv (); - bitmap e2 = query->get_value_range (n2)->equiv (); + bitmap e1 = query->get_value_range (n1, s)->equiv (); + bitmap e2 = query->get_value_range (n2, s)->equiv (); /* Use the fake bitmaps if e1 or e2 are not available. */ static bitmap s_e1 = NULL, s_e2 = NULL; @@ -2139,7 +2141,7 @@ simplify_using_ranges::compare_names (enum tree_code comp, tree n1, tree n2, continue; value_range_equiv tem_vr1; - const value_range_equiv *vr1 = get_vr_for_comparison (i1, &tem_vr1); + const value_range_equiv *vr1 = get_vr_for_comparison (i1, &tem_vr1, s); tree t = NULL_TREE, retval = NULL_TREE; bitmap_iterator bi2; @@ -2152,7 +2154,8 @@ simplify_using_ranges::compare_names (enum tree_code comp, tree n1, tree n2, bool sop = false; value_range_equiv tem_vr2; - const value_range_equiv *vr2 = get_vr_for_comparison (i2, &tem_vr2); + const value_range_equiv *vr2 = get_vr_for_comparison (i2, &tem_vr2, + s); t = compare_ranges (comp, vr1, vr2, &sop); if (t) @@ -2198,11 +2201,12 @@ simplify_using_ranges::compare_names (enum tree_code comp, tree n1, tree n2, tree simplify_using_ranges::vrp_evaluate_conditional_warnv_with_ops_using_ranges - (enum tree_code code, tree op0, tree op1, bool * strict_overflow_p) + (enum tree_code code, tree op0, tree op1, bool * strict_overflow_p, + gimple *s) { const value_range_equiv *vr0, *vr1; - vr0 = (TREE_CODE (op0) == SSA_NAME) ? query->get_value_range (op0) : NULL; - vr1 = (TREE_CODE (op1) == SSA_NAME) ? query->get_value_range (op1) : NULL; + vr0 = (TREE_CODE (op0) == SSA_NAME) ? query->get_value_range (op0, s) : NULL; + vr1 = (TREE_CODE (op1) == SSA_NAME) ? query->get_value_range (op1, s) : NULL; tree res = NULL_TREE; if (vr0 && vr1) @@ -2302,20 +2306,20 @@ simplify_using_ranges::vrp_evaluate_conditional_warnv_with_ops } if ((ret = vrp_evaluate_conditional_warnv_with_ops_using_ranges - (code, op0, op1, strict_overflow_p))) + (code, op0, op1, strict_overflow_p, stmt))) return ret; if (only_ranges) *only_ranges = false; /* Do not use compare_names during propagation, it's quadratic. */ if (TREE_CODE (op0) == SSA_NAME && TREE_CODE (op1) == SSA_NAME && use_equiv_p) - return compare_names (code, op0, op1, strict_overflow_p); + return compare_names (code, op0, op1, strict_overflow_p, stmt); else if (TREE_CODE (op0) == SSA_NAME) return compare_name_with_value (code, op0, op1, - strict_overflow_p, use_equiv_p); + strict_overflow_p, use_equiv_p, stmt); else if (TREE_CODE (op1) == SSA_NAME) return compare_name_with_value (swap_tree_comparison (code), op1, op0, - strict_overflow_p, use_equiv_p); + strict_overflow_p, use_equiv_p, stmt); return NULL_TREE; } @@ -2929,11 +2933,11 @@ simplify_using_ranges::simplify_truth_ops_using_ranges gcc_assert (rhs_code == EQ_EXPR || rhs_code == NE_EXPR); op0 = gimple_assign_rhs1 (stmt); - if (!op_with_boolean_value_range_p (op0)) + if (!op_with_boolean_value_range_p (op0, stmt)) return false; op1 = gimple_assign_rhs2 (stmt); - if (!op_with_boolean_value_range_p (op1)) + if (!op_with_boolean_value_range_p (op1, stmt)) return false; /* Reduce number of cases to handle to NE_EXPR. As there is no @@ -3131,12 +3135,12 @@ simplify_using_ranges::simplify_min_or_max_using_ranges tree val; val = (vrp_evaluate_conditional_warnv_with_ops_using_ranges - (LE_EXPR, op0, op1, &sop)); + (LE_EXPR, op0, op1, &sop, stmt)); if (!val) { sop = false; val = (vrp_evaluate_conditional_warnv_with_ops_using_ranges - (LT_EXPR, op0, op1, &sop)); + (LT_EXPR, op0, op1, &sop, stmt)); } if (val) @@ -4000,7 +4004,7 @@ simplify_using_ranges::simplify_internal_call_using_ranges return false; else type = TREE_TYPE (TREE_TYPE (gimple_call_lhs (stmt))); - if (!check_for_binary_op_overflow (query, subcode, type, op0, op1, &ovf) + if (!check_for_binary_op_overflow (query, subcode, type, op0, op1, &ovf, stmt) || (is_ubsan && ovf)) return false; @@ -4057,9 +4061,10 @@ simplify_using_ranges::simplify_internal_call_using_ranges two-values when it is true. Return false otherwise. */ bool -simplify_using_ranges::two_valued_val_range_p (tree var, tree *a, tree *b) +simplify_using_ranges::two_valued_val_range_p (tree var, tree *a, tree *b, + gimple *s) { - value_range vr = *query->get_value_range (var); + value_range vr = *query->get_value_range (var, s); vr.normalize_symbolics (); if (vr.varying_p () || vr.undefined_p ()) return false; @@ -4133,7 +4138,7 @@ simplify_using_ranges::simplify (gimple_stmt_iterator *gsi) tree cmp_var = NULL_TREE; if (TREE_CODE (rhs2) == SSA_NAME - && two_valued_val_range_p (rhs2, &val1, &val2)) + && two_valued_val_range_p (rhs2, &val1, &val2, stmt)) { /* Optimize RHS1 OP [VAL1, VAL2]. */ new_rhs1 = int_const_binop (rhs_code, rhs1, val1); @@ -4141,7 +4146,7 @@ simplify_using_ranges::simplify (gimple_stmt_iterator *gsi) cmp_var = rhs2; } else if (TREE_CODE (rhs1) == SSA_NAME - && two_valued_val_range_p (rhs1, &val1, &val2)) + && two_valued_val_range_p (rhs1, &val1, &val2, stmt)) { /* Optimize [VAL1, VAL2] OP RHS2. */ new_rhs1 = int_const_binop (rhs_code, val1, rhs2); diff --git a/gcc/vr-values.h b/gcc/vr-values.h index 81b9131f7f1..7fdefef2fdf 100644 --- a/gcc/vr-values.h +++ b/gcc/vr-values.h @@ -56,14 +56,16 @@ private: gimple *); bool simplify_internal_call_using_ranges (gimple_stmt_iterator *, gimple *); - bool two_valued_val_range_p (tree, tree *, tree *); - bool op_with_boolean_value_range_p (tree); - tree compare_name_with_value (enum tree_code, tree, tree, bool *, bool); - tree compare_names (enum tree_code, tree, tree, bool *); - const value_range_equiv *get_vr_for_comparison (int, value_range_equiv *); + bool two_valued_val_range_p (tree, tree *, tree *, gimple *); + bool op_with_boolean_value_range_p (tree, gimple *); + tree compare_name_with_value (enum tree_code, tree, tree, bool *, bool, + gimple *); + tree compare_names (enum tree_code, tree, tree, bool *, gimple *s); + const value_range_equiv *get_vr_for_comparison (int, value_range_equiv *, + gimple *s); tree vrp_evaluate_conditional_warnv_with_ops_using_ranges (enum tree_code, tree, tree, - bool *); + bool *, gimple *s); void cleanup_edges_and_switches (void); /* Vectors of edges that need removing and switch statements that </cut>

4 years

[CI-NOTIFY]: TCWG Bisect tcwg_bmk_tk1/llvm-master-arm-spec2k6-O2_LTO - Build # 10 - Successful!

by ci_notify＠linaro.org

Successfully identified regression in *gcc* in CI configuration tcwg_bmk_llvm_tk1/llvm-master-arm-spec2k6-O2_LTO. So far, this commit has regressed CI configurations: - tcwg_bmk_llvm_tk1/llvm-master-arm-spec2k6-O2_LTO Culprit: <cut> commit a310bb73edc9548e08d1fa28e7a56246caf27757 Author: Richard Biener <rguenther(a)suse.de> Date: Tue May 4 10:07:35 2021 +0200 tree-optimization/100329 - avoid reassociating asm goto defs This avoids reassociating asm goto defs because we have no idea on which outgoing edge to insert defs. 2021-05-04 Richard Biener <rguenther(a)suse.de> PR tree-optimization/100329 * tree-ssa-reassoc.c (can_reassociate_p): Do not reassociate asm goto defs. (insert_stmt_after): Assert we're not running into asm goto. * gcc.dg/torture/pr100329.c: New testcase. </cut> Results regressed to (for first_bad == a310bb73edc9548e08d1fa28e7a56246caf27757) # reset_artifacts: -10 # build_abe binutils: -9 # build_abe stage1 -- --set gcc_override_configure=--with-mode=arm --set gcc_override_configure=--disable-libsanitizer: -8 # build_abe linux: -7 # build_abe glibc: -6 # build_abe stage2 -- --set gcc_override_configure=--with-mode=arm --set gcc_override_configure=--disable-libsanitizer: -5 # build_llvm true: -3 # true: 0 # benchmark -O2_LTO_marm -- artifacts/build-a310bb73edc9548e08d1fa28e7a56246caf27757/results_id: 1 # 471.omnetpp,omnetpp_base.default regressed by 103 from (for last_good == 2326627eb19d8c21251fd60479f1a190621c475b) # reset_artifacts: -10 # build_abe binutils: -9 # build_abe stage1 -- --set gcc_override_configure=--with-mode=arm --set gcc_override_configure=--disable-libsanitizer: -8 # build_abe linux: -7 # build_abe glibc: -6 # build_abe stage2 -- --set gcc_override_configure=--with-mode=arm --set gcc_override_configure=--disable-libsanitizer: -5 # build_llvm true: -3 # true: 0 # benchmark -O2_LTO_marm -- artifacts/build-2326627eb19d8c21251fd60479f1a190621c475b/results_id: 1 Artifacts of last_good build: https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tk1-llvm-master-… Results ID of last_good: tk1_32/tcwg_bmk_llvm_tk1/bisect-llvm-master-arm-spec2k6-O2_LTO/1063 Artifacts of first_bad build: https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tk1-llvm-master-… Results ID of first_bad: tk1_32/tcwg_bmk_llvm_tk1/bisect-llvm-master-arm-spec2k6-O2_LTO/1045 Build top page/logs: https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tk1-llvm-master-… Configuration details: Reproduce builds: <cut> mkdir investigate-gcc-a310bb73edc9548e08d1fa28e7a56246caf27757 cd investigate-gcc-a310bb73edc9548e08d1fa28e7a56246caf27757 git clone https://git.linaro.org/toolchain/jenkins-scripts mkdir -p artifacts/manifests curl -o artifacts/manifests/build-baseline.sh https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tk1-llvm-master-… --fail curl -o artifacts/manifests/build-parameters.sh https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tk1-llvm-master-… --fail curl -o artifacts/test.sh https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tk1-llvm-master-… --fail chmod +x artifacts/test.sh # Reproduce the baseline build (build all pre-requisites) ./jenkins-scripts/tcwg_bmk-build.sh @@ artifacts/manifests/build-baseline.sh cd gcc # Reproduce first_bad build git checkout --detach a310bb73edc9548e08d1fa28e7a56246caf27757 ../artifacts/test.sh # Reproduce last_good build git checkout --detach 2326627eb19d8c21251fd60479f1a190621c475b ../artifacts/test.sh cd .. </cut> History of pending regressions and results: https://git.linaro.org/toolchain/ci/base-artifacts.git/log/?h=linaro-local/… Artifacts: https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tk1-llvm-master-… Build log: https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tk1-llvm-master-… Full commit (up to 1000 lines): <cut> commit a310bb73edc9548e08d1fa28e7a56246caf27757 Author: Richard Biener <rguenther(a)suse.de> Date: Tue May 4 10:07:35 2021 +0200 tree-optimization/100329 - avoid reassociating asm goto defs This avoids reassociating asm goto defs because we have no idea on which outgoing edge to insert defs. 2021-05-04 Richard Biener <rguenther(a)suse.de> PR tree-optimization/100329 * tree-ssa-reassoc.c (can_reassociate_p): Do not reassociate asm goto defs. (insert_stmt_after): Assert we're not running into asm goto. * gcc.dg/torture/pr100329.c: New testcase. --- gcc/testsuite/gcc.dg/torture/pr100329.c | 16 ++++++++++++++++ gcc/tree-ssa-reassoc.c | 10 ++++++++++ 2 files changed, 26 insertions(+) diff --git a/gcc/testsuite/gcc.dg/torture/pr100329.c b/gcc/testsuite/gcc.dg/torture/pr100329.c new file mode 100644 index 00000000000..b90700dd5f0 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr100329.c @@ -0,0 +1,16 @@ +/* { dg-do compile } */ +/* { dg-additional-options "--param tree-reassoc-width=2" } */ + +unsigned int a0; + +unsigned int +foo (unsigned int a1, unsigned int a2) +{ + unsigned int x; + + asm goto ("" : "=r" (x) : : : lab); + a0 = x; + + lab: + return x + a1 + a2 + 1; +} diff --git a/gcc/tree-ssa-reassoc.c b/gcc/tree-ssa-reassoc.c index 8e2a4896d14..359367c9382 100644 --- a/gcc/tree-ssa-reassoc.c +++ b/gcc/tree-ssa-reassoc.c @@ -1446,6 +1446,10 @@ insert_stmt_after (gimple *stmt, gimple *insert_point) gsi_insert_after (&gsi, stmt, GSI_NEW_STMT); return; } + else if (gimple_code (insert_point) == GIMPLE_ASM) + /* We have no idea where to insert - it depends on where the + uses will be placed. */ + gcc_unreachable (); else /* We assume INSERT_POINT is a SSA_NAME_DEF_STMT of some SSA_NAME, thus if it must end a basic block, it should be a call that can @@ -5893,6 +5897,12 @@ can_reassociate_p (tree op) tree type = TREE_TYPE (op); if (TREE_CODE (op) == SSA_NAME && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (op)) return false; + /* Make sure asm goto outputs do not participate in reassociation since + we have no way to find an insertion place after asm goto. */ + if (TREE_CODE (op) == SSA_NAME + && gimple_code (SSA_NAME_DEF_STMT (op)) == GIMPLE_ASM + && gimple_asm_nlabels (as_a <gasm *> (SSA_NAME_DEF_STMT (op))) != 0) + return false; if ((ANY_INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_WRAPS (type)) || NON_SAT_FIXED_POINT_TYPE_P (type) || (flag_associative_math && FLOAT_TYPE_P (type))) </cut>

4 years

[CI-NOTIFY]: TCWG Bisect tcwg_gnu/gnu-master-arm-check_bootstrap - Build # 72 - Successful!

by ci_notify＠linaro.org

4 years

[CI-NOTIFY]: TCWG Bisect tcwg_bmk_tx1/llvm-master-aarch64-spec2k6-O2_LTO - Build # 16 - Successful!

by ci_notify＠linaro.org

Successfully identified regression in *llvm* in CI configuration tcwg_bmk_llvm_tx1/llvm-master-aarch64-spec2k6-O2_LTO. So far, this commit has regressed CI configurations: - tcwg_bmk_llvm_tx1/llvm-master-aarch64-spec2k6-O2_LTO Culprit: <cut> commit 6998f8ae2d14e096aff33968f226587b5c1a193a Author: David Sherwood <david.sherwood(a)arm.com> Date: Wed Mar 10 08:34:19 2021 +0000 [LoopVectorize] Simplify scalar cost calculation in getInstructionCost This patch simplifies the calculation of certain costs in getInstructionCost when isScalarAfterVectorization() returns a true value. There are a few places where we multiply a cost by a number N, i.e. unsigned N = isScalarAfterVectorization(I, VF) ? VF.getKnownMinValue() : 1; return N * TTI.getArithmeticInstrCost(... After some investigation it seems that there are only these cases that occur in practice: 1. VF is a scalar, in which case N = 1. 2. VF is a vector. We can only get here if: a) the instruction is a GEP/bitcast/PHI with scalar uses, or b) this is an update to an induction variable that remains scalar. I have changed the code so that N is assumed to always be 1. For GEPs the cost is always 0, since this is calculated later on as part of the load/store cost. PHI nodes are costed separately and were never previously multiplied by VF. For all other cases I have added an assert that none of the users needs scalarising, which didn't fire in any unit tests. Only one test required fixing and I believe the original cost for the scalar add instruction to have been wrong, since only one copy remains after vectorisation. I have also added a new test for the case when a pointer PHI feeds directly into a store that will be scalarised as we were previously never testing it. Differential Revision: https://reviews.llvm.org/D99718 </cut> Results regressed to (for first_bad == 6998f8ae2d14e096aff33968f226587b5c1a193a) # reset_artifacts: -10 # build_abe binutils: -9 # build_abe stage1 -- --set gcc_override_configure=--disable-libsanitizer: -8 # build_abe linux: -7 # build_abe glibc: -6 # build_abe stage2 -- --set gcc_override_configure=--disable-libsanitizer: -5 # build_llvm true: -3 # true: 0 # benchmark -O2_LTO -- artifacts/build-6998f8ae2d14e096aff33968f226587b5c1a193a/results_id: 1 # 462.libquantum,libquantum_base.default regressed by 113 from (for last_good == c835630c25a4f9925517949579f66a43b113fbc9) # reset_artifacts: -10 # build_abe binutils: -9 # build_abe stage1 -- --set gcc_override_configure=--disable-libsanitizer: -8 # build_abe linux: -7 # build_abe glibc: -6 # build_abe stage2 -- --set gcc_override_configure=--disable-libsanitizer: -5 # build_llvm true: -3 # true: 0 # benchmark -O2_LTO -- artifacts/build-c835630c25a4f9925517949579f66a43b113fbc9/results_id: 1 Artifacts of last_good build: https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tx1-llvm-master-… Results ID of last_good: tx1_64/tcwg_bmk_llvm_tx1/bisect-llvm-master-aarch64-spec2k6-O2_LTO/1050 Artifacts of first_bad build: https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tx1-llvm-master-… Results ID of first_bad: tx1_64/tcwg_bmk_llvm_tx1/bisect-llvm-master-aarch64-spec2k6-O2_LTO/1048 Build top page/logs: https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tx1-llvm-master-… Configuration details: Reproduce builds: <cut> mkdir investigate-llvm-6998f8ae2d14e096aff33968f226587b5c1a193a cd investigate-llvm-6998f8ae2d14e096aff33968f226587b5c1a193a git clone https://git.linaro.org/toolchain/jenkins-scripts mkdir -p artifacts/manifests curl -o artifacts/manifests/build-baseline.sh https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tx1-llvm-master-… --fail curl -o artifacts/manifests/build-parameters.sh https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tx1-llvm-master-… --fail curl -o artifacts/test.sh https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tx1-llvm-master-… --fail chmod +x artifacts/test.sh # Reproduce the baseline build (build all pre-requisites) ./jenkins-scripts/tcwg_bmk-build.sh @@ artifacts/manifests/build-baseline.sh cd llvm # Reproduce first_bad build git checkout --detach 6998f8ae2d14e096aff33968f226587b5c1a193a ../artifacts/test.sh # Reproduce last_good build git checkout --detach c835630c25a4f9925517949579f66a43b113fbc9 ../artifacts/test.sh cd .. </cut> History of pending regressions and results: https://git.linaro.org/toolchain/ci/base-artifacts.git/log/?h=linaro-local/… Artifacts: https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tx1-llvm-master-… Build log: https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tx1-llvm-master-… Full commit (up to 1000 lines): <cut> commit 6998f8ae2d14e096aff33968f226587b5c1a193a Author: David Sherwood <david.sherwood(a)arm.com> Date: Wed Mar 10 08:34:19 2021 +0000 [LoopVectorize] Simplify scalar cost calculation in getInstructionCost This patch simplifies the calculation of certain costs in getInstructionCost when isScalarAfterVectorization() returns a true value. There are a few places where we multiply a cost by a number N, i.e. unsigned N = isScalarAfterVectorization(I, VF) ? VF.getKnownMinValue() : 1; return N * TTI.getArithmeticInstrCost(... After some investigation it seems that there are only these cases that occur in practice: 1. VF is a scalar, in which case N = 1. 2. VF is a vector. We can only get here if: a) the instruction is a GEP/bitcast/PHI with scalar uses, or b) this is an update to an induction variable that remains scalar. I have changed the code so that N is assumed to always be 1. For GEPs the cost is always 0, since this is calculated later on as part of the load/store cost. PHI nodes are costed separately and were never previously multiplied by VF. For all other cases I have added an assert that none of the users needs scalarising, which didn't fire in any unit tests. Only one test required fixing and I believe the original cost for the scalar add instruction to have been wrong, since only one copy remains after vectorisation. I have also added a new test for the case when a pointer PHI feeds directly into a store that will be scalarised as we were previously never testing it. Differential Revision: https://reviews.llvm.org/D99718 --- llvm/lib/Transforms/Vectorize/LoopVectorize.cpp | 73 +++++++++++++--------- .../AArch64/no_vector_instructions.ll | 2 +- .../LoopVectorize/AArch64/predication_costs.ll | 35 +++++++++++ .../Transforms/LoopVectorize/scalarized-bitcast.ll | 40 ++++++++++++ 4 files changed, 121 insertions(+), 29 deletions(-) diff --git a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp index 2b413fc49505..f25af23c86c2 100644 --- a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp +++ b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp @@ -7383,10 +7383,39 @@ LoopVectorizationCostModel::getInstructionCost(Instruction *I, ElementCount VF, Type *RetTy = I->getType(); if (canTruncateToMinimalBitwidth(I, VF)) RetTy = IntegerType::get(RetTy->getContext(), MinBWs[I]); - VectorTy = isScalarAfterVectorization(I, VF) ? RetTy : ToVectorTy(RetTy, VF); auto SE = PSE.getSE(); TTI::TargetCostKind CostKind = TTI::TCK_RecipThroughput; + auto hasSingleCopyAfterVectorization = [this](Instruction *I, + ElementCount VF) -> bool { + if (VF.isScalar()) + return true; + + auto Scalarized = InstsToScalarize.find(VF); + assert(Scalarized != InstsToScalarize.end() && + "VF not yet analyzed for scalarization profitability"); + return !Scalarized->second.count(I) && + llvm::all_of(I->users(), [&](User *U) { + auto *UI = cast<Instruction>(U); + return !Scalarized->second.count(UI); + }); + }; + + if (isScalarAfterVectorization(I, VF)) { + // With the exception of GEPs and PHIs, after scalarization there should + // only be one copy of the instruction generated in the loop. This is + // because the VF is either 1, or any instructions that need scalarizing + // have already been dealt with by the the time we get here. As a result, + // it means we don't have to multiply the instruction cost by VF. + assert(I->getOpcode() == Instruction::GetElementPtr || + I->getOpcode() == Instruction::PHI || + (I->getOpcode() == Instruction::BitCast && + I->getType()->isPointerTy()) || + hasSingleCopyAfterVectorization(I, VF)); + VectorTy = RetTy; + } else + VectorTy = ToVectorTy(RetTy, VF); + // TODO: We need to estimate the cost of intrinsic calls. switch (I->getOpcode()) { case Instruction::GetElementPtr: @@ -7514,21 +7543,16 @@ LoopVectorizationCostModel::getInstructionCost(Instruction *I, ElementCount VF, Op2VK = TargetTransformInfo::OK_UniformValue; SmallVector<const Value *, 4> Operands(I->operand_values()); - unsigned N = isScalarAfterVectorization(I, VF) ? VF.getKnownMinValue() : 1; - return N * TTI.getArithmeticInstrCost( - I->getOpcode(), VectorTy, CostKind, - TargetTransformInfo::OK_AnyValue, - Op2VK, TargetTransformInfo::OP_None, Op2VP, Operands, I); + return TTI.getArithmeticInstrCost( + I->getOpcode(), VectorTy, CostKind, TargetTransformInfo::OK_AnyValue, + Op2VK, TargetTransformInfo::OP_None, Op2VP, Operands, I); } case Instruction::FNeg: { assert(!VF.isScalable() && "VF is assumed to be non scalable."); - unsigned N = isScalarAfterVectorization(I, VF) ? VF.getKnownMinValue() : 1; - return N * TTI.getArithmeticInstrCost( - I->getOpcode(), VectorTy, CostKind, - TargetTransformInfo::OK_AnyValue, - TargetTransformInfo::OK_AnyValue, - TargetTransformInfo::OP_None, TargetTransformInfo::OP_None, - I->getOperand(0), I); + return TTI.getArithmeticInstrCost( + I->getOpcode(), VectorTy, CostKind, TargetTransformInfo::OK_AnyValue, + TargetTransformInfo::OK_AnyValue, TargetTransformInfo::OP_None, + TargetTransformInfo::OP_None, I->getOperand(0), I); } case Instruction::Select: { SelectInst *SI = cast<SelectInst>(I); @@ -7583,6 +7607,10 @@ LoopVectorizationCostModel::getInstructionCost(Instruction *I, ElementCount VF, VectorTy = ToVectorTy(getMemInstValueType(I), Width); return getMemoryInstructionCost(I, VF); } + case Instruction::BitCast: + if (I->getType()->isPointerTy()) + return 0; + LLVM_FALLTHROUGH; case Instruction::ZExt: case Instruction::SExt: case Instruction::FPToUI: @@ -7593,8 +7621,7 @@ LoopVectorizationCostModel::getInstructionCost(Instruction *I, ElementCount VF, case Instruction::SIToFP: case Instruction::UIToFP: case Instruction::Trunc: - case Instruction::FPTrunc: - case Instruction::BitCast: { + case Instruction::FPTrunc: { // Computes the CastContextHint from a Load/Store instruction. auto ComputeCCH = [&](Instruction *I) -> TTI::CastContextHint { assert((isa<LoadInst>(I) || isa<StoreInst>(I)) && @@ -7672,14 +7699,7 @@ LoopVectorizationCostModel::getInstructionCost(Instruction *I, ElementCount VF, } } - unsigned N; - if (isScalarAfterVectorization(I, VF)) { - assert(!VF.isScalable() && "VF is assumed to be non scalable"); - N = VF.getKnownMinValue(); - } else - N = 1; - return N * - TTI.getCastInstrCost(Opcode, VectorTy, SrcVecTy, CCH, CostKind, I); + return TTI.getCastInstrCost(Opcode, VectorTy, SrcVecTy, CCH, CostKind, I); } case Instruction::Call: { bool NeedToScalarize; @@ -7694,11 +7714,8 @@ LoopVectorizationCostModel::getInstructionCost(Instruction *I, ElementCount VF, case Instruction::ExtractValue: return TTI.getInstructionCost(I, TTI::TCK_RecipThroughput); default: - // The cost of executing VF copies of the scalar instruction. This opcode - // is unknown. Assume that it is the same as 'mul'. - return VF.getKnownMinValue() * TTI.getArithmeticInstrCost( - Instruction::Mul, VectorTy, CostKind) + - getScalarizationOverhead(I, VF); + // This opcode is unknown. Assume that it is the same as 'mul'. + return TTI.getArithmeticInstrCost(Instruction::Mul, VectorTy, CostKind); } // end of switch. } diff --git a/llvm/test/Transforms/LoopVectorize/AArch64/no_vector_instructions.ll b/llvm/test/Transforms/LoopVectorize/AArch64/no_vector_instructions.ll index 247ea35ff5d0..3061998518ad 100644 --- a/llvm/test/Transforms/LoopVectorize/AArch64/no_vector_instructions.ll +++ b/llvm/test/Transforms/LoopVectorize/AArch64/no_vector_instructions.ll @@ -6,7 +6,7 @@ target triple = "aarch64--linux-gnu" ; CHECK-LABEL: all_scalar ; CHECK: LV: Found scalar instruction: %i.next = add nuw nsw i64 %i, 2 -; CHECK: LV: Found an estimated cost of 2 for VF 2 For instruction: %i.next = add nuw nsw i64 %i, 2 +; CHECK: LV: Found an estimated cost of 1 for VF 2 For instruction: %i.next = add nuw nsw i64 %i, 2 ; CHECK: LV: Not considering vector loop of width 2 because it will not generate any vector instructions ; define void @all_scalar(i64* %a, i64 %n) { diff --git a/llvm/test/Transforms/LoopVectorize/AArch64/predication_costs.ll b/llvm/test/Transforms/LoopVectorize/AArch64/predication_costs.ll index b0ebb4edf2ad..858b28ddd321 100644 --- a/llvm/test/Transforms/LoopVectorize/AArch64/predication_costs.ll +++ b/llvm/test/Transforms/LoopVectorize/AArch64/predication_costs.ll @@ -86,6 +86,41 @@ for.end: ret void } +; CHECK-LABEL: predicated_store_phi +; +; Same as predicate_store except we use a pointer PHI to maintain the address +; +; CHECK: Found new scalar instruction: %addr = phi i32* [ %a, %entry ], [ %addr.next, %for.inc ] +; CHECK: Found new scalar instruction: %addr.next = getelementptr inbounds i32, i32* %addr, i64 1 +; CHECK: Scalarizing and predicating: store i32 %tmp2, i32* %addr, align 4 +; CHECK: Found an estimated cost of 0 for VF 2 For instruction: %addr = phi i32* [ %a, %entry ], [ %addr.next, %for.inc ] +; CHECK: Found an estimated cost of 3 for VF 2 For instruction: store i32 %tmp2, i32* %addr, align 4 +; +define void @predicated_store_phi(i32* %a, i1 %c, i32 %x, i64 %n) { +entry: + br label %for.body + +for.body: + %i = phi i64 [ 0, %entry ], [ %i.next, %for.inc ] + %addr = phi i32 * [ %a, %entry ], [ %addr.next, %for.inc ] + %tmp1 = load i32, i32* %addr, align 4 + %tmp2 = add nsw i32 %tmp1, %x + br i1 %c, label %if.then, label %for.inc + +if.then: + store i32 %tmp2, i32* %addr, align 4 + br label %for.inc + +for.inc: + %i.next = add nuw nsw i64 %i, 1 + %cond = icmp slt i64 %i.next, %n + %addr.next = getelementptr inbounds i32, i32* %addr, i64 1 + br i1 %cond, label %for.body, label %for.end + +for.end: + ret void +} + ; CHECK-LABEL: predicated_udiv_scalarized_operand ; ; This test checks that we correctly compute the cost of the predicated udiv diff --git a/llvm/test/Transforms/LoopVectorize/scalarized-bitcast.ll b/llvm/test/Transforms/LoopVectorize/scalarized-bitcast.ll new file mode 100644 index 000000000000..0c97e6ac475e --- /dev/null +++ b/llvm/test/Transforms/LoopVectorize/scalarized-bitcast.ll @@ -0,0 +1,40 @@ +; REQUIRES: asserts +; RUN: opt -loop-vectorize -force-vector-width=2 -debug-only=loop-vectorize -S -o - < %s 2>&1 | FileCheck %s + +%struct.foo = type { i32, i64 } + +; CHECK: LV: Found an estimated cost of 0 for VF 2 For instruction: %0 = bitcast i64* %b to i32* + +; The bitcast below will be scalarized due to the predication in the loop. Bitcasts +; between pointer types should be treated as free, despite the scalarization. +define void @foo(%struct.foo* noalias nocapture %in, i32* noalias nocapture readnone %out, i64 %n) { +entry: + br label %for.body + +for.body: ; preds = %entry, %if.end + %i.012 = phi i64 [ %inc, %if.end ], [ 0, %entry ] + %b = getelementptr inbounds %struct.foo, %struct.foo* %in, i64 %i.012, i32 1 + %0 = bitcast i64* %b to i32* + %a = getelementptr inbounds %struct.foo, %struct.foo* %in, i64 %i.012, i32 0 + %1 = load i32, i32* %a, align 8 + %tobool.not = icmp eq i32 %1, 0 + br i1 %tobool.not, label %if.end, label %land.lhs.true + +land.lhs.true: ; preds = %for.body + %2 = load i32, i32* %0, align 4 + %cmp2 = icmp sgt i32 %2, 0 + br i1 %cmp2, label %if.then, label %if.end + +if.then: ; preds = %land.lhs.true + %sub = add nsw i32 %2, -1 + store i32 %sub, i32* %0, align 4 + br label %if.end + +if.end: ; preds = %if.then, %land.lhs.true, %for.body + %inc = add nuw nsw i64 %i.012, 1 + %exitcond.not = icmp eq i64 %inc, %n + br i1 %exitcond.not, label %for.end, label %for.body + +for.end: ; preds = %if.end + ret void +} </cut>

4 years

[CI-NOTIFY]: TCWG Bisect tcwg_gnu/gnu-master-arm-check_bootstrap - Build # 71 - Successful!

by ci_notify＠linaro.org

4 years

[CI-NOTIFY]: TCWG Bisect tcwg_bmk_tx1/gnu-master-aarch64-spec2k6-O2_LTO - Build # 19 - Successful!

by ci_notify＠linaro.org

Successfully identified regression in *glibc* in CI configuration tcwg_bmk_gnu_tx1/gnu-master-aarch64-spec2k6-O2_LTO. So far, this commit has regressed CI configurations: - tcwg_bmk_gnu_tx1/gnu-master-aarch64-spec2k6-O2_LTO Culprit: <cut> commit 8208be389bce84be0e1c35a3daa0c3467418f921 Author: Florian Weimer <fweimer(a)redhat.com> Date: Mon Jun 28 08:33:57 2021 +0200 Install shared objects under their ABI names Previously, the installed objects were named like libc-2.33.so, and the ABI soname libc.so.6 was just a symbolic link. The Makefile targets to install these symbolic links are no longer needed after this, so they are removed with this commit. The more general $(make-link) command (which invokes scripts/rellns-sh) is retained because other symbolic links are still needed. Reviewed-by: Carlos O'Donell <carlos(a)redhat.com> Tested-by: Carlos O'Donell <carlos(a)rehdat.com> </cut> Results regressed to (for first_bad == 8208be389bce84be0e1c35a3daa0c3467418f921) # reset_artifacts: -10 # build_abe binutils: -9 # build_abe stage1 -- --set gcc_override_configure=--disable-libsanitizer: -8 # build_abe linux: -7 # build_abe glibc: -6 # build_abe stage2 -- --set gcc_override_configure=--disable-libsanitizer: -5 # true: 0 # benchmark -O2_LTO -- artifacts/build-8208be389bce84be0e1c35a3daa0c3467418f921/results_id: 1 # 434.zeusmp,zeusmp_base.default regressed by 7549591 # 435.gromacs,gromacs_base.default regressed by 10863956 # 447.dealII,dealII_base.default regressed by 12999253 # 454.calculix,calculix_base.default regressed by 3929138 # 465.tonto,tonto_base.default regressed by 12056000 # 459.GemsFDTD,GemsFDTD_base.default regressed by 7978538 # 410.bwaves,bwaves_base.default regressed by 8373106 # 416.gamess,gamess_base.default regressed by 4372732 # 481.wrf,wrf_base.default regressed by 8973237 # 436.cactusADM,cactusADM_base.default regressed by 4181826 # 437.leslie3d,leslie3d_base.default regressed by 7255644 from (for last_good == 6bf789d69e6be48419094ca98f064e00297a27d5) # reset_artifacts: -10 # build_abe binutils: -9 # build_abe stage1 -- --set gcc_override_configure=--disable-libsanitizer: -8 # build_abe linux: -7 # build_abe glibc: -6 # build_abe stage2 -- --set gcc_override_configure=--disable-libsanitizer: -5 # true: 0 # benchmark -O2_LTO -- artifacts/build-6bf789d69e6be48419094ca98f064e00297a27d5/results_id: 1 Artifacts of last_good build: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tx1-gnu-master-aa… Results ID of last_good: tx1_64/tcwg_bmk_gnu_tx1/bisect-gnu-master-aarch64-spec2k6-O2_LTO/976 Artifacts of first_bad build: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tx1-gnu-master-aa… Results ID of first_bad: tx1_64/tcwg_bmk_gnu_tx1/bisect-gnu-master-aarch64-spec2k6-O2_LTO/988 Build top page/logs: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tx1-gnu-master-aa… Configuration details: Reproduce builds: <cut> mkdir investigate-glibc-8208be389bce84be0e1c35a3daa0c3467418f921 cd investigate-glibc-8208be389bce84be0e1c35a3daa0c3467418f921 git clone https://git.linaro.org/toolchain/jenkins-scripts mkdir -p artifacts/manifests curl -o artifacts/manifests/build-baseline.sh https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tx1-gnu-master-aa… --fail curl -o artifacts/manifests/build-parameters.sh https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tx1-gnu-master-aa… --fail curl -o artifacts/test.sh https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tx1-gnu-master-aa… --fail chmod +x artifacts/test.sh # Reproduce the baseline build (build all pre-requisites) ./jenkins-scripts/tcwg_bmk-build.sh @@ artifacts/manifests/build-baseline.sh cd glibc # Reproduce first_bad build git checkout --detach 8208be389bce84be0e1c35a3daa0c3467418f921 ../artifacts/test.sh # Reproduce last_good build git checkout --detach 6bf789d69e6be48419094ca98f064e00297a27d5 ../artifacts/test.sh cd .. </cut> History of pending regressions and results: https://git.linaro.org/toolchain/ci/base-artifacts.git/log/?h=linaro-local/… Artifacts: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tx1-gnu-master-aa… Build log: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tx1-gnu-master-aa… Full commit (up to 1000 lines): <cut> commit 8208be389bce84be0e1c35a3daa0c3467418f921 Author: Florian Weimer <fweimer(a)redhat.com> Date: Mon Jun 28 08:33:57 2021 +0200 Install shared objects under their ABI names Previously, the installed objects were named like libc-2.33.so, and the ABI soname libc.so.6 was just a symbolic link. The Makefile targets to install these symbolic links are no longer needed after this, so they are removed with this commit. The more general $(make-link) command (which invokes scripts/rellns-sh) is retained because other symbolic links are still needed. Reviewed-by: Carlos O'Donell <carlos(a)redhat.com> Tested-by: Carlos O'Donell <carlos(a)rehdat.com> --- Makefile | 6 ------ Makerules | 45 +++++---------------------------------------- NEWS | 8 ++++++++ elf/Makefile | 10 ++-------- 4 files changed, 15 insertions(+), 54 deletions(-) diff --git a/Makefile b/Makefile index 0157b53cb8..f98d5a9e67 100644 --- a/Makefile +++ b/Makefile @@ -109,12 +109,6 @@ elf/ldso_install: # Ignore the error if we cannot update /etc/ld.so.cache. ifeq (no,$(cross-compiling)) ifeq (yes,$(build-shared)) -install: install-symbolic-link -.PHONY: install-symbolic-link -install-symbolic-link: subdir_install - $(symbolic-link-prog) $(symbolic-link-list) - rm -f $(symbolic-link-list) - install: -test ! -x $(elf-objpfx)ldconfig || LC_ALL=C \ $(elf-objpfx)ldconfig $(addprefix -r ,$(install_root)) \ diff --git a/Makerules b/Makerules index f2587907fb..596fa68376 100644 --- a/Makerules +++ b/Makerules @@ -990,14 +990,12 @@ versioned := $(strip $(foreach so,$(install-lib.so),\ install-lib.so-versioned := $(filter $(versioned), $(install-lib.so)) install-lib.so-unversioned := $(filter-out $(versioned), $(install-lib.so)) -# For libraries whose soname have version numbers, we install three files: +# For libraries whose soname have version numbers, we install two files: # $(inst_libdir)/libfoo.so -- for linking, symlink or ld script -# $(inst_slibdir)/libfoo.so.NN -- for loading by SONAME, symlink -# $(inst_slibdir)/libfoo-X.Y.Z.so -- the real shared object file +# $(inst_slibdir)/libfoo.so.NN -- for loading by SONAME install-lib-nosubdir: $(install-lib.so-unversioned:%=$(inst_slibdir)/%) \ $(foreach L,$(install-lib.so-versioned),\ $(inst_libdir)/$L \ - $(inst_slibdir)/$(L:.so=)-$(version).so \ $(inst_slibdir)/$L$($L-version)) # Install all the unversioned shared libraries. @@ -1030,35 +1028,10 @@ ln -f $(objpfx)/$(@F) $@ endef endif -ifeq (yes,$(build-shared)) -ifeq (no,$(cross-compiling)) -symbolic-link-prog := $(elf-objpfx)sln -symbolic-link-list := $(elf-objpfx)symlink.list -define make-shlib-link -echo `$(..)scripts/rellns-sh -p $< $@` $@ >> $(symbolic-link-list) -endef -else # cross-compiling -# We need a definition that can be used by elf/Makefile's install rules. -symbolic-link-prog = $(LN_S) -endif -endif -ifndef make-shlib-link -define make-shlib-link -rm -f $@ -$(LN_S) `$(..)scripts/rellns-sh -p $< $@` $@ -endef -endif - ifdef libc.so-version -# For a library specified to be version N, install three files: -# libc.so -> libc.so.N (e.g. libc.so.6) -# libc.so.6 -> libc-VERSION.so (e.g. libc-1.10.so) - -$(inst_slibdir)/libc.so$(libc.so-version): $(inst_slibdir)/libc-$(version).so \ - $(+force) - $(make-shlib-link) -$(inst_slibdir)/libc-$(version).so: $(common-objpfx)libc.so $(+force) +$(inst_slibdir)/libc.so$(libc.so-version): $(common-objpfx)libc.so $(+force) $(do-install-program) + install: $(inst_slibdir)/libc.so$(libc.so-version) # This fragment of linker script gives the OUTPUT_FORMAT statement @@ -1126,15 +1099,7 @@ include $(o-iterator) generated += $(foreach o,$(versioned),$o$($o-version)) define o-iterator-doit -$(inst_slibdir)/$o$($o-version): $(inst_slibdir)/$(o:.so=)-$(version).so \ - $(+force); - $$(make-shlib-link) -endef -object-suffixes-left := $(versioned) -include $(o-iterator) - -define o-iterator-doit -$(inst_slibdir)/$(o:.so=)-$(version).so: $(objpfx)$o $(+force); +$(inst_slibdir)/$o$($o-version): $(objpfx)$o $(+force); $$(do-install-program) endef object-suffixes-left := $(versioned) diff --git a/NEWS b/NEWS index b24ebf9898..37ba4334c6 100644 --- a/NEWS +++ b/NEWS @@ -74,6 +74,14 @@ Deprecated and removed features, and other changes affecting compatibility: buggy kernel interfaces (for instance some CIFS version) that could still see spurious EINTR error when cancellation interrupts a blocking syscall. +* Previously, glibc installed its various shared objects under versioned + file names such as libc-2.33.so. The ABI sonames (e.g., libc.so.6) + were provided as symbolic links. Starting with glibc 2.34, the shared + objects are installed under their ABI sonames directly, without + symbolic links. This increases compatibility with distribution + package managers that delete removed files late during the package + upgrade or downgrade process. + Changes to build and runtime requirements: * On Linux, the shm_open, sem_open, and related functions now expect the diff --git a/elf/Makefile b/elf/Makefile index 62f7e8a225..cdbcc14087 100644 --- a/elf/Makefile +++ b/elf/Makefile @@ -630,20 +630,14 @@ $(objpfx)trusted-dirs.st: Makefile $(..)Makeconfig CPPFLAGS-dl-load.c += -I$(objpfx). -I$(csu-objpfx). ifeq (yes,$(build-shared)) -$(inst_slibdir)/$(rtld-version-installed-name): $(objpfx)ld.so $(+force) +$(inst_rtlddir)/$(rtld-installed-name): $(objpfx)ld.so $(+force) $(make-target-directory) $(do-install-program) -$(inst_rtlddir)/$(rtld-installed-name): \ - $(inst_slibdir)/$(rtld-version-installed-name) \ - $(inst_slibdir)/libc-$(version).so - $(make-target-directory) - $(make-shlib-link) - # Special target called by parent to install just the dynamic linker. .PHONY: ldso_install ldso_install: $(inst_rtlddir)/$(rtld-installed-name) -endif +endif # $(build-shared) # Workarounds for ${exec_prefix} expansion in configure variables. </cut>

4 years

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

linaro-toolchain