linaro-toolchain

linaro-toolchain@lists.linaro.org

1 participants
5625 discussions

[CI-NOTIFY]: TCWG Bisect tcwg_bmk_tk1/llvm-release-arm-spec2k6-Oz - Build # 9 - Successful!

by ci_notify＠linaro.org

Successfully identified regression in *llvm* in CI configuration tcwg_bmk_llvm_tk1/llvm-release-arm-spec2k6-Oz. So far, this commit has regressed CI configurations: - tcwg_bmk_llvm_tk1/llvm-release-arm-spec2k6-Oz Culprit: <cut> commit b4916918e5219ac25a5b6472c5638450f867d975 Author: Roman Lebedev <lebedev.ri(a)gmail.com> Date: Fri Oct 30 09:12:49 2020 +0300 [SCEV] SCEVPtrToIntExpr simplifications If we've got an SCEVPtrToIntExpr(op), where op is not an SCEVUnknown, we want to sink the SCEVPtrToIntExpr into an operand, so that the operation is performed on integers, and eventually we end up with just an `SCEVPtrToIntExpr(SCEVUnknown)`. Reviewed By: mkazantsev Differential Revision: https://reviews.llvm.org/D89692 </cut> Results regressed to (for first_bad == b4916918e5219ac25a5b6472c5638450f867d975) # reset_artifacts: -10 # build_abe binutils: -9 # build_abe stage1 -- --set gcc_override_configure=--with-mode=thumb --set gcc_override_configure=--disable-libsanitizer: -8 # build_abe linux: -7 # build_abe glibc: -6 # build_abe stage2 -- --set gcc_override_configure=--with-mode=thumb --set gcc_override_configure=--disable-libsanitizer: -5 # build_llvm true: -3 # true: 0 # benchmark -Oz_mthumb -- artifacts/build-b4916918e5219ac25a5b6472c5638450f867d975/results_id: 1 # 483.xalancbmk,[.] _ZSt9__find_ifIN9__gnu_cxx17__normal_iterat regressed by 111 from (for last_good == 81fc53a36a4e3ca5cc9d5bc9b3ea32f304e35b93) # reset_artifacts: -10 # build_abe binutils: -9 # build_abe stage1 -- --set gcc_override_configure=--with-mode=thumb --set gcc_override_configure=--disable-libsanitizer: -8 # build_abe linux: -7 # build_abe glibc: -6 # build_abe stage2 -- --set gcc_override_configure=--with-mode=thumb --set gcc_override_configure=--disable-libsanitizer: -5 # build_llvm true: -3 # true: 0 # benchmark -Oz_mthumb -- artifacts/build-81fc53a36a4e3ca5cc9d5bc9b3ea32f304e35b93/results_id: 1 Artifacts of last_good build: https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tk1-llvm-release… Results ID of last_good: tk1_32/tcwg_bmk_llvm_tk1/bisect-llvm-release-arm-spec2k6-Oz/749 Artifacts of first_bad build: https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tk1-llvm-release… Results ID of first_bad: tk1_32/tcwg_bmk_llvm_tk1/bisect-llvm-release-arm-spec2k6-Oz/752 Build top page/logs: https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tk1-llvm-release… Configuration details: Reproduce builds: <cut> mkdir investigate-llvm-b4916918e5219ac25a5b6472c5638450f867d975 cd investigate-llvm-b4916918e5219ac25a5b6472c5638450f867d975 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-release… --fail curl -o artifacts/manifests/build-parameters.sh https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tk1-llvm-release… --fail curl -o artifacts/test.sh https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tk1-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 b4916918e5219ac25a5b6472c5638450f867d975 ../artifacts/test.sh # Reproduce last_good build git checkout --detach 81fc53a36a4e3ca5cc9d5bc9b3ea32f304e35b93 ../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-release… Build log: https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tk1-llvm-release… Full commit (up to 1000 lines): <cut> commit b4916918e5219ac25a5b6472c5638450f867d975 Author: Roman Lebedev <lebedev.ri(a)gmail.com> Date: Fri Oct 30 09:12:49 2020 +0300 [SCEV] SCEVPtrToIntExpr simplifications If we've got an SCEVPtrToIntExpr(op), where op is not an SCEVUnknown, we want to sink the SCEVPtrToIntExpr into an operand, so that the operation is performed on integers, and eventually we end up with just an `SCEVPtrToIntExpr(SCEVUnknown)`. Reviewed By: mkazantsev Differential Revision: https://reviews.llvm.org/D89692 --- llvm/lib/Analysis/ScalarEvolution.cpp | 56 +++++++++++++++++++--- llvm/test/Analysis/ScalarEvolution/ptrtoint.ll | 52 ++++++++++---------- .../LoopStrengthReduce/X86/expander-crashes.ll | 54 ++++++++++----------- polly/test/ScopInfo/int2ptr_ptr2int.ll | 16 +++---- polly/test/ScopInfo/int2ptr_ptr2int_2.ll | 17 ++++--- 5 files changed, 118 insertions(+), 77 deletions(-) diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp index 11b99553bf6b..91f3b947fc50 100644 --- a/llvm/lib/Analysis/ScalarEvolution.cpp +++ b/llvm/lib/Analysis/ScalarEvolution.cpp @@ -1047,17 +1047,61 @@ const SCEV *ScalarEvolution::getPtrToIntExpr(const SCEV *Op, Type *Ty, ID.AddPointer(Op); void *IP = nullptr; if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) - return getTruncateOrZeroExtend(S, Ty); + return getTruncateOrZeroExtend(S, Ty, Depth); - assert(!isa<SCEVConstant>(Op) && - "SCEVConstant is an integer, no constant folding to do."); + assert((isa<SCEVNAryExpr>(Op) || isa<SCEVUnknown>(Op)) && + "We can only gen an nary expression, or an unknown here."); - // FIXME: simplifications. + Type *IntPtrTy = getDataLayout().getIntPtrType(Op->getType()); + + // If the input operand is not an unknown (and thus is an nary expression), + // sink the cast to operands, so that the operation is performed on integers, + // and we eventually end up with just an ptrtoint(unknown). + if (const SCEVNAryExpr *NaryExpr = dyn_cast<SCEVNAryExpr>(Op)) { + SmallVector<const SCEV *, 2> NewOps; + NewOps.reserve(NaryExpr->getNumOperands()); + for (const SCEV *Op : NaryExpr->operands()) + NewOps.push_back(Op->getType()->isPointerTy() + ? getPtrToIntExpr(Op, IntPtrTy, Depth + 1) + : Op); + const SCEV *NewNaryExpr = nullptr; + switch (SCEVTypes SCEVType = NaryExpr->getSCEVType()) { + case scAddExpr: + NewNaryExpr = getAddExpr(NewOps, NaryExpr->getNoWrapFlags(), Depth + 1); + break; + case scAddRecExpr: + NewNaryExpr = + getAddRecExpr(NewOps, cast<SCEVAddRecExpr>(NaryExpr)->getLoop(), + NaryExpr->getNoWrapFlags()); + break; + case scUMaxExpr: + case scSMaxExpr: + case scUMinExpr: + case scSMinExpr: + NewNaryExpr = getMinMaxExpr(SCEVType, NewOps); + break; + + case scMulExpr: + NewNaryExpr = getMulExpr(NewOps, NaryExpr->getNoWrapFlags(), Depth + 1); + break; + case scUDivExpr: + NewNaryExpr = getUDivExpr(NewOps[0], NewOps[1]); + break; + case scConstant: + case scTruncate: + case scZeroExtend: + case scSignExtend: + case scPtrToInt: + case scUnknown: + case scCouldNotCompute: + llvm_unreachable("We can't get these types here."); + } + return getTruncateOrZeroExtend(NewNaryExpr, Ty, Depth); + } // The cast wasn't folded; create an explicit cast node. We can reuse // the existing insert position since if we get here, we won't have // made any changes which would invalidate it. - Type *IntPtrTy = getDataLayout().getIntPtrType(Op->getType()); assert(getDataLayout().getTypeSizeInBits(getEffectiveSCEVType( Op->getType())) == getDataLayout().getTypeSizeInBits(IntPtrTy) && "We can only model ptrtoint if SCEV's effective (integer) type is " @@ -1066,7 +1110,7 @@ const SCEV *ScalarEvolution::getPtrToIntExpr(const SCEV *Op, Type *Ty, SCEVPtrToIntExpr(ID.Intern(SCEVAllocator), Op, IntPtrTy); UniqueSCEVs.InsertNode(S, IP); addToLoopUseLists(S); - return getTruncateOrZeroExtend(S, Ty); + return getTruncateOrZeroExtend(S, Ty, Depth); } const SCEV *ScalarEvolution::getTruncateExpr(const SCEV *Op, Type *Ty, diff --git a/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll b/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll index 9a6c77e8968e..70fb37984d8a 100644 --- a/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll +++ b/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll @@ -196,7 +196,7 @@ define void @ptrtoint_of_gep(i8* %in, i64* %out0) { ; X64-NEXT: %in_adj = getelementptr inbounds i8, i8* %in, i64 42 ; X64-NEXT: --> (42 + %in)<nsw> U: [-9223372036854775766,-9223372036854775808) S: [-9223372036854775766,-9223372036854775808) ; X64-NEXT: %p0 = ptrtoint i8* %in_adj to i64 -; X64-NEXT: --> (ptrtoint i8* (42 + %in)<nsw> to i64) U: [-9223372036854775766,-9223372036854775808) S: [-9223372036854775766,-9223372036854775808) +; X64-NEXT: --> (42 + (ptrtoint i8* %in to i64))<nsw> U: [-9223372036854775766,-9223372036854775808) S: [-9223372036854775766,-9223372036854775808) ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_gep ; ; X32-LABEL: 'ptrtoint_of_gep' @@ -204,7 +204,7 @@ define void @ptrtoint_of_gep(i8* %in, i64* %out0) { ; X32-NEXT: %in_adj = getelementptr inbounds i8, i8* %in, i64 42 ; X32-NEXT: --> (42 + %in)<nsw> U: [-2147483606,-2147483648) S: [-2147483606,-2147483648) ; X32-NEXT: %p0 = ptrtoint i8* %in_adj to i64 -; X32-NEXT: --> (zext i32 (ptrtoint i8* (42 + %in)<nsw> to i32) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: --> (zext i32 (42 + (ptrtoint i8* %in to i32))<nsw> to i64) U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_gep ; %in_adj = getelementptr inbounds i8, i8* %in, i64 42 @@ -226,7 +226,7 @@ define void @ptrtoint_of_addrec(i32* %in, i32 %count) { ; X64-NEXT: %i7 = getelementptr inbounds i32, i32* %in, i64 %i6 ; X64-NEXT: --> {%in,+,4}<nsw><%loop> U: full-set S: full-set Exits: (-4 + (4 * (zext i32 %count to i64))<nuw><nsw> + %in) LoopDispositions: { %loop: Computable } ; X64-NEXT: %i8 = ptrtoint i32* %i7 to i64 -; X64-NEXT: --> (ptrtoint i32* {%in,+,4}<nsw><%loop> to i64) U: full-set S: full-set Exits: (ptrtoint i32* (-4 + (4 * (zext i32 %count to i64))<nuw><nsw> + %in) to i64) LoopDispositions: { %loop: Computable } +; X64-NEXT: --> {(ptrtoint i32* %in to i64),+,4}<nsw><%loop> U: full-set S: full-set Exits: (-4 + (4 * (zext i32 %count to i64))<nuw><nsw> + (ptrtoint i32* %in to i64)) LoopDispositions: { %loop: Computable } ; X64-NEXT: %i9 = add nuw nsw i64 %i6, 1 ; X64-NEXT: --> {1,+,1}<nuw><%loop> U: [1,0) S: [1,0) Exits: (zext i32 %count to i64) LoopDispositions: { %loop: Computable } ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_addrec @@ -245,7 +245,7 @@ define void @ptrtoint_of_addrec(i32* %in, i32 %count) { ; X32-NEXT: %i7 = getelementptr inbounds i32, i32* %in, i64 %i6 ; X32-NEXT: --> {%in,+,4}<%loop> U: full-set S: full-set Exits: (-4 + (4 * %count) + %in) LoopDispositions: { %loop: Computable } ; X32-NEXT: %i8 = ptrtoint i32* %i7 to i64 -; X32-NEXT: --> (zext i32 (ptrtoint i32* {%in,+,4}<%loop> to i32) to i64) U: [0,4294967296) S: [0,4294967296) Exits: (zext i32 (ptrtoint i32* (-4 + (4 * %count) + %in) to i32) to i64) LoopDispositions: { %loop: Computable } +; X32-NEXT: --> (zext i32 {(ptrtoint i32* %in to i32),+,4}<%loop> to i64) U: [0,4294967296) S: [0,4294967296) Exits: (zext i32 (-4 + (4 * %count) + (ptrtoint i32* %in to i32)) to i64) LoopDispositions: { %loop: Computable } ; X32-NEXT: %i9 = add nuw nsw i64 %i6, 1 ; X32-NEXT: --> {1,+,1}<nuw><%loop> U: [1,0) S: [1,0) Exits: (zext i32 %count to i64) LoopDispositions: { %loop: Computable } ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_addrec @@ -280,7 +280,7 @@ define void @ptrtoint_of_umax(i8* %in0, i8* %in1, i64* %out0) { ; X64-NEXT: %s = select i1 %c, i8* %in0, i8* %in1 ; X64-NEXT: --> (%in0 umax %in1) U: full-set S: full-set ; X64-NEXT: %p0 = ptrtoint i8* %s to i64 -; X64-NEXT: --> (ptrtoint i8* (%in0 umax %in1) to i64) U: full-set S: full-set +; X64-NEXT: --> ((ptrtoint i8* %in0 to i64) umax (ptrtoint i8* %in1 to i64)) U: full-set S: full-set ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_umax ; ; X32-LABEL: 'ptrtoint_of_umax' @@ -288,7 +288,7 @@ define void @ptrtoint_of_umax(i8* %in0, i8* %in1, i64* %out0) { ; X32-NEXT: %s = select i1 %c, i8* %in0, i8* %in1 ; X32-NEXT: --> (%in0 umax %in1) U: full-set S: full-set ; X32-NEXT: %p0 = ptrtoint i8* %s to i64 -; X32-NEXT: --> (zext i32 (ptrtoint i8* (%in0 umax %in1) to i32) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: --> (zext i32 ((ptrtoint i8* %in0 to i32) umax (ptrtoint i8* %in1 to i32)) to i64) U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_umax ; %c = icmp uge i8* %in0, %in1 @@ -304,7 +304,7 @@ define void @ptrtoint_of_smax(i8* %in0, i8* %in1, i64* %out0) { ; X64-NEXT: %s = select i1 %c, i8* %in0, i8* %in1 ; X64-NEXT: --> (%in0 smax %in1) U: full-set S: full-set ; X64-NEXT: %p0 = ptrtoint i8* %s to i64 -; X64-NEXT: --> (ptrtoint i8* (%in0 smax %in1) to i64) U: full-set S: full-set +; X64-NEXT: --> ((ptrtoint i8* %in0 to i64) smax (ptrtoint i8* %in1 to i64)) U: full-set S: full-set ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_smax ; ; X32-LABEL: 'ptrtoint_of_smax' @@ -312,7 +312,7 @@ define void @ptrtoint_of_smax(i8* %in0, i8* %in1, i64* %out0) { ; X32-NEXT: %s = select i1 %c, i8* %in0, i8* %in1 ; X32-NEXT: --> (%in0 smax %in1) U: full-set S: full-set ; X32-NEXT: %p0 = ptrtoint i8* %s to i64 -; X32-NEXT: --> (zext i32 (ptrtoint i8* (%in0 smax %in1) to i32) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: --> (zext i32 ((ptrtoint i8* %in0 to i32) smax (ptrtoint i8* %in1 to i32)) to i64) U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_smax ; %c = icmp sge i8* %in0, %in1 @@ -328,7 +328,7 @@ define void @ptrtoint_of_umin(i8* %in0, i8* %in1, i64* %out0) { ; X64-NEXT: %s = select i1 %c, i8* %in0, i8* %in1 ; X64-NEXT: --> (%in0 umin %in1) U: full-set S: full-set ; X64-NEXT: %p0 = ptrtoint i8* %s to i64 -; X64-NEXT: --> (ptrtoint i8* (%in0 umin %in1) to i64) U: full-set S: full-set +; X64-NEXT: --> ((ptrtoint i8* %in0 to i64) umin (ptrtoint i8* %in1 to i64)) U: full-set S: full-set ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_umin ; ; X32-LABEL: 'ptrtoint_of_umin' @@ -336,7 +336,7 @@ define void @ptrtoint_of_umin(i8* %in0, i8* %in1, i64* %out0) { ; X32-NEXT: %s = select i1 %c, i8* %in0, i8* %in1 ; X32-NEXT: --> (%in0 umin %in1) U: full-set S: full-set ; X32-NEXT: %p0 = ptrtoint i8* %s to i64 -; X32-NEXT: --> (zext i32 (ptrtoint i8* (%in0 umin %in1) to i32) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: --> (zext i32 ((ptrtoint i8* %in0 to i32) umin (ptrtoint i8* %in1 to i32)) to i64) U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_umin ; %c = icmp ule i8* %in0, %in1 @@ -352,7 +352,7 @@ define void @ptrtoint_of_smin(i8* %in0, i8* %in1, i64* %out0) { ; X64-NEXT: %s = select i1 %c, i8* %in0, i8* %in1 ; X64-NEXT: --> (%in0 smin %in1) U: full-set S: full-set ; X64-NEXT: %p0 = ptrtoint i8* %s to i64 -; X64-NEXT: --> (ptrtoint i8* (%in0 smin %in1) to i64) U: full-set S: full-set +; X64-NEXT: --> ((ptrtoint i8* %in0 to i64) smin (ptrtoint i8* %in1 to i64)) U: full-set S: full-set ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_smin ; ; X32-LABEL: 'ptrtoint_of_smin' @@ -360,7 +360,7 @@ define void @ptrtoint_of_smin(i8* %in0, i8* %in1, i64* %out0) { ; X32-NEXT: %s = select i1 %c, i8* %in0, i8* %in1 ; X32-NEXT: --> (%in0 smin %in1) U: full-set S: full-set ; X32-NEXT: %p0 = ptrtoint i8* %s to i64 -; X32-NEXT: --> (zext i32 (ptrtoint i8* (%in0 smin %in1) to i32) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: --> (zext i32 ((ptrtoint i8* %in0 to i32) smin (ptrtoint i8* %in1 to i32)) to i64) U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_smin ; %c = icmp sle i8* %in0, %in1 @@ -384,11 +384,11 @@ define void @pr46786_c26_char(i8* %arg, i8* %arg1, i8* %arg2) { ; X64-NEXT: %i8 = load i8, i8* %i7, align 1 ; X64-NEXT: --> %i8 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant } ; X64-NEXT: %i9 = ptrtoint i8* %i7 to i64 -; X64-NEXT: --> (ptrtoint i8* {%arg,+,1}<nuw><%bb6> to i64) U: full-set S: full-set Exits: (ptrtoint i8* (-1 + %arg1) to i64) LoopDispositions: { %bb6: Computable } +; X64-NEXT: --> {(ptrtoint i8* %arg to i64),+,1}<nuw><%bb6> U: full-set S: full-set Exits: (-1 + (-1 * %arg) + (ptrtoint i8* %arg to i64) + %arg1) LoopDispositions: { %bb6: Computable } ; X64-NEXT: %i10 = sub i64 %i9, %i4 -; X64-NEXT: --> ((-1 * (ptrtoint i8* %arg to i64)) + (ptrtoint i8* {%arg,+,1}<nuw><%bb6> to i64)) U: full-set S: full-set Exits: ((-1 * (ptrtoint i8* %arg to i64)) + (ptrtoint i8* (-1 + %arg1) to i64)) LoopDispositions: { %bb6: Computable } +; X64-NEXT: --> {0,+,1}<nw><%bb6> U: [0,-1) S: [0,-1) Exits: (-1 + (-1 * %arg) + %arg1) LoopDispositions: { %bb6: Computable } ; X64-NEXT: %i11 = getelementptr inbounds i8, i8* %arg2, i64 %i10 -; X64-NEXT: --> ((-1 * (ptrtoint i8* %arg to i64)) + (ptrtoint i8* {%arg,+,1}<nuw><%bb6> to i64) + %arg2) U: full-set S: full-set Exits: ((-1 * (ptrtoint i8* %arg to i64)) + (ptrtoint i8* (-1 + %arg1) to i64) + %arg2) LoopDispositions: { %bb6: Computable } +; X64-NEXT: --> {%arg2,+,1}<nw><%bb6> U: full-set S: full-set Exits: (-1 + (-1 * %arg) + %arg1 + %arg2) LoopDispositions: { %bb6: Computable } ; X64-NEXT: %i12 = load i8, i8* %i11, align 1 ; X64-NEXT: --> %i12 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant } ; X64-NEXT: %i13 = add i8 %i12, %i8 @@ -411,11 +411,11 @@ define void @pr46786_c26_char(i8* %arg, i8* %arg1, i8* %arg2) { ; X32-NEXT: %i8 = load i8, i8* %i7, align 1 ; X32-NEXT: --> %i8 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant } ; X32-NEXT: %i9 = ptrtoint i8* %i7 to i64 -; X32-NEXT: --> (zext i32 (ptrtoint i8* {%arg,+,1}<nuw><%bb6> to i32) to i64) U: [0,4294967296) S: [0,4294967296) Exits: (zext i32 (ptrtoint i8* (-1 + %arg1) to i32) to i64) LoopDispositions: { %bb6: Computable } +; X32-NEXT: --> {(zext i32 (ptrtoint i8* %arg to i32) to i64),+,1}<nuw><%bb6> U: [0,8589934590) S: [0,8589934590) Exits: ((zext i8* (-1 + (-1 * %arg) + %arg1) to i64) + (zext i32 (ptrtoint i8* %arg to i32) to i64)) LoopDispositions: { %bb6: Computable } ; X32-NEXT: %i10 = sub i64 %i9, %i4 -; X32-NEXT: --> ((zext i32 (ptrtoint i8* {%arg,+,1}<nuw><%bb6> to i32) to i64) + (-1 * (zext i32 (ptrtoint i8* %arg to i32) to i64))<nsw>) U: [-4294967295,4294967296) S: [-4294967295,4294967296) Exits: ((zext i32 (ptrtoint i8* (-1 + %arg1) to i32) to i64) + (-1 * (zext i32 (ptrtoint i8* %arg to i32) to i64))<nsw>) LoopDispositions: { %bb6: Computable } +; X32-NEXT: --> {0,+,1}<nw><%bb6> U: [0,4294967295) S: [0,4294967295) Exits: (zext i8* (-1 + (-1 * %arg) + %arg1) to i64) LoopDispositions: { %bb6: Computable } ; X32-NEXT: %i11 = getelementptr inbounds i8, i8* %arg2, i64 %i10 -; X32-NEXT: --> ((-1 * (ptrtoint i8* %arg to i32)) + (ptrtoint i8* {%arg,+,1}<nuw><%bb6> to i32) + %arg2) U: full-set S: full-set Exits: ((-1 * (ptrtoint i8* %arg to i32)) + (ptrtoint i8* (-1 + %arg1) to i32) + %arg2) LoopDispositions: { %bb6: Computable } +; X32-NEXT: --> {%arg2,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * %arg) + %arg1 + %arg2) LoopDispositions: { %bb6: Computable } ; X32-NEXT: %i12 = load i8, i8* %i11, align 1 ; X32-NEXT: --> %i12 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant } ; X32-NEXT: %i13 = add i8 %i12, %i8 @@ -469,13 +469,13 @@ define void @pr46786_c26_int(i32* %arg, i32* %arg1, i32* %arg2) { ; X64-NEXT: %i8 = load i32, i32* %i7, align 4 ; X64-NEXT: --> %i8 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant } ; X64-NEXT: %i9 = ptrtoint i32* %i7 to i64 -; X64-NEXT: --> (ptrtoint i32* {%arg,+,4}<nuw><%bb6> to i64) U: full-set S: full-set Exits: (ptrtoint i32* ((4 * ((-4 + (-1 * %arg) + %arg1) /u 4))<nuw> + %arg) to i64) LoopDispositions: { %bb6: Computable } +; X64-NEXT: --> {(ptrtoint i32* %arg to i64),+,4}<nuw><%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * %arg) + %arg1) /u 4))<nuw> + (ptrtoint i32* %arg to i64)) LoopDispositions: { %bb6: Computable } ; X64-NEXT: %i10 = sub i64 %i9, %i4 -; X64-NEXT: --> ((-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* {%arg,+,4}<nuw><%bb6> to i64)) U: full-set S: full-set Exits: ((-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* ((4 * ((-4 + (-1 * %arg) + %arg1) /u 4))<nuw> + %arg) to i64)) LoopDispositions: { %bb6: Computable } +; X64-NEXT: --> {0,+,4}<nw><%bb6> U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: (4 * ((-4 + (-1 * %arg) + %arg1) /u 4))<nuw> LoopDispositions: { %bb6: Computable } ; X64-NEXT: %i11 = ashr exact i64 %i10, 2 -; X64-NEXT: --> (((((-1 * (ptrtoint i32* {%arg,+,4}<nuw><%bb6> to i64)) + (ptrtoint i32* %arg to i64)) smax ((-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* {%arg,+,4}<nuw><%bb6> to i64))) /u 4) * (1 smin (-1 smax ((-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* {%arg,+,4}<nuw><%bb6> to i64)))))<nsw> U: [-4611686018427387903,4611686018427387904) S: [-4611686018427387903,4611686018427387904) Exits: (((((-1 * (ptrtoint i32* ((4 * ((-4 + (-1 * %arg) + %arg1) /u 4))<nuw> + %arg) to i64)) + (ptrtoint i32* %arg to i64)) smax ((-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* ((4 * ((-4 + (-1 * %arg) + %arg1) /u 4))<nuw> + %arg) to i64))) /u 4) * (1 smin (-1 smax ((-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* ((4 * ((-4 + (-1 * %arg) + %arg1) /u 4))<nuw> + %arg) to i64)))))<nsw> LoopDispositions: { %bb6: Computable } +; X64-NEXT: --> ((({0,+,4}<nw><%bb6> smax {0,+,-4}<nw><%bb6>) /u 4) * (1 smin (-1 smax {0,+,4}<nw><%bb6>)))<nsw> U: [-4611686018427387903,4611686018427387904) S: [-4611686018427387903,4611686018427387904) Exits: ((((4 * ((-4 + (-1 * %arg) + %arg1) /u 4))<nuw> smax (-4 * ((-4 + (-1 * %arg) + %arg1) /u 4))) /u 4) * (1 smin (-1 smax (4 * ((-4 + (-1 * %arg) + %arg1) /u 4))<nuw>)))<nsw> LoopDispositions: { %bb6: Computable } ; X64-NEXT: %i12 = getelementptr inbounds i32, i32* %arg2, i64 %i11 -; X64-NEXT: --> ((4 * ((((-1 * (ptrtoint i32* {%arg,+,4}<nuw><%bb6> to i64)) + (ptrtoint i32* %arg to i64)) smax ((-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* {%arg,+,4}<nuw><%bb6> to i64))) /u 4) * (1 smin (-1 smax ((-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* {%arg,+,4}<nuw><%bb6> to i64))))) + %arg2)<nsw> U: full-set S: full-set Exits: ((4 * ((((-1 * (ptrtoint i32* ((4 * ((-4 + (-1 * %arg) + %arg1) /u 4))<nuw> + %arg) to i64)) + (ptrtoint i32* %arg to i64)) smax ((-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* ((4 * ((-4 + (-1 * %arg) + %arg1) /u 4))<nuw> + %arg) to i64))) /u 4) * (1 smin (-1 smax ((-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* ((4 * ((-4 + (-1 * %arg) + %arg1) /u 4))<nuw> + %arg) to i64))))) + %arg2)<nsw> LoopDispositions: { %bb6: Computable } +; X64-NEXT: --> ((4 * (({0,+,4}<nw><%bb6> smax {0,+,-4}<nw><%bb6>) /u 4) * (1 smin (-1 smax {0,+,4}<nw><%bb6>))) + %arg2)<nsw> U: full-set S: full-set Exits: ((4 * (((4 * ((-4 + (-1 * %arg) + %arg1) /u 4))<nuw> smax (-4 * ((-4 + (-1 * %arg) + %arg1) /u 4))) /u 4) * (1 smin (-1 smax (4 * ((-4 + (-1 * %arg) + %arg1) /u 4))<nuw>))) + %arg2)<nsw> LoopDispositions: { %bb6: Computable } ; X64-NEXT: %i13 = load i32, i32* %i12, align 4 ; X64-NEXT: --> %i13 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant } ; X64-NEXT: %i14 = add nsw i32 %i13, %i8 @@ -498,13 +498,13 @@ define void @pr46786_c26_int(i32* %arg, i32* %arg1, i32* %arg2) { ; X32-NEXT: %i8 = load i32, i32* %i7, align 4 ; X32-NEXT: --> %i8 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant } ; X32-NEXT: %i9 = ptrtoint i32* %i7 to i64 -; X32-NEXT: --> (zext i32 (ptrtoint i32* {%arg,+,4}<nuw><%bb6> to i32) to i64) U: [0,4294967296) S: [0,4294967296) Exits: (zext i32 (ptrtoint i32* ((4 * ((-4 + (-1 * %arg) + %arg1) /u 4))<nuw> + %arg) to i32) to i64) LoopDispositions: { %bb6: Computable } +; X32-NEXT: --> {(zext i32 (ptrtoint i32* %arg to i32) to i64),+,4}<nuw><%bb6> U: [0,8589934588) S: [0,8589934588) Exits: ((zext i32 (ptrtoint i32* %arg to i32) to i64) + (4 * ((zext i32* (-4 + (-1 * %arg) + %arg1) to i64) /u 4))<nuw><nsw>) LoopDispositions: { %bb6: Computable } ; X32-NEXT: %i10 = sub i64 %i9, %i4 -; X32-NEXT: --> ((zext i32 (ptrtoint i32* {%arg,+,4}<nuw><%bb6> to i32) to i64) + (-1 * (zext i32 (ptrtoint i32* %arg to i32) to i64))<nsw>) U: [-4294967295,4294967296) S: [-4294967295,4294967296) Exits: ((zext i32 (ptrtoint i32* ((4 * ((-4 + (-1 * %arg) + %arg1) /u 4))<nuw> + %arg) to i32) to i64) + (-1 * (zext i32 (ptrtoint i32* %arg to i32) to i64))<nsw>) LoopDispositions: { %bb6: Computable } +; X32-NEXT: --> {0,+,4}<nw><%bb6> U: [0,4294967293) S: [0,4294967293) Exits: (4 * ((zext i32* (-4 + (-1 * %arg) + %arg1) to i64) /u 4))<nuw><nsw> LoopDispositions: { %bb6: Computable } ; X32-NEXT: %i11 = ashr exact i64 %i10, 2 -; X32-NEXT: --> (((((zext i32 (ptrtoint i32* {%arg,+,4}<nuw><%bb6> to i32) to i64) + (-1 * (zext i32 (ptrtoint i32* %arg to i32) to i64))<nsw>) smax ((zext i32 (ptrtoint i32* %arg to i32) to i64) + (-1 * (zext i32 (ptrtoint i32* {%arg,+,4}<nuw><%bb6> to i32) to i64))<nsw>)) /u 4) * (1 smin (-1 smax ((zext i32 (ptrtoint i32* {%arg,+,4}<nuw><%bb6> to i32) to i64) + (-1 * (zext i32 (ptrtoint i32* %arg to i32) to i64))<nsw>))))<nsw> U: [-4611686018427387903,4611686018427387904) S: [-4611686018427387903,4611686018427387904) Exits: (((((zext i32 (ptrtoint i32* ((4 * ((-4 + (-1 * %arg) + %arg1) /u 4))<nuw> + %arg) to i32) to i64) + (-1 * (zext i32 (ptrtoint i32* %arg to i32) to i64))<nsw>) smax ((zext i32 (ptrtoint i32* %arg to i32) to i64) + (-1 * (zext i32 (ptrtoint i32* ((4 * ((-4 + (-1 * %arg) + %arg1) /u 4))<nuw> + %arg) to i32) to i64))<nsw>)) /u 4) * (1 smin (-1 smax ((zext i32 (ptrtoint i32* ((4 * ((-4 + (-1 * %arg) + %arg1) /u 4))<nuw> + %arg) to i32) to i64) + (-1 * (zext i32 (ptrtoint i32* %arg to i32) to i64))<nsw>))))<nsw> LoopDispositions: { %bb6: Computable } +; X32-NEXT: --> ({0,+,1}<nw><%bb6> * (1 smin {0,+,4}<nuw><nsw><%bb6>))<nuw><nsw> U: [0,1073741824) S: [0,1073741824) Exits: (((zext i32* (-4 + (-1 * %arg) + %arg1) to i64) /u 4) * (1 smin (4 * ((zext i32* (-4 + (-1 * %arg) + %arg1) to i64) /u 4))<nuw><nsw>))<nuw><nsw> LoopDispositions: { %bb6: Computable } ; X32-NEXT: %i12 = getelementptr inbounds i32, i32* %arg2, i64 %i11 -; X32-NEXT: --> ((4 * (trunc i64 (((((zext i32 (ptrtoint i32* {%arg,+,4}<nuw><%bb6> to i32) to i64) + (-1 * (zext i32 (ptrtoint i32* %arg to i32) to i64))<nsw>) smax ((zext i32 (ptrtoint i32* %arg to i32) to i64) + (-1 * (zext i32 (ptrtoint i32* {%arg,+,4}<nuw><%bb6> to i32) to i64))<nsw>)) /u 4) * (1 smin (-1 smax ((zext i32 (ptrtoint i32* {%arg,+,4}<nuw><%bb6> to i32) to i64) + (-1 * (zext i32 (ptrtoint i32* %arg to i32) to i64))<nsw>))))<nsw> to i32))<nsw> + %arg2)<nsw> U: full-set S: full-set Exits: ((4 * (trunc i64 (((((zext i32 (ptrtoint i32* ((4 * ((-4 + (-1 * %arg) + %arg1) /u 4))<nuw> + %arg) to i32) to i64) + (-1 * (zext i32 (ptrtoint i32* %arg to i32) to i64))<nsw>) smax ((zext i32 (ptrtoint i32* %arg to i32) to i64) + (-1 * (zext i32 (ptrtoint i32* ((4 * ((-4 + (-1 * %arg) + %arg1) /u 4))<nuw> + %arg) to i32) to i64))<nsw>)) /u 4) * (1 smin (-1 smax ((zext i32 (ptrtoint i32* ((4 * ((-4 + (-1 * %arg) + %arg1) /u 4))<nuw> + %arg) to i32) to i64) + (-1 * (zext i32 (ptrtoint i32* %arg to i32) to i64))<nsw>))))<nsw> to i32))<nsw> + %arg2)<nsw> LoopDispositions: { %bb6: Computable } +; X32-NEXT: --> (((trunc i64 (1 smin {0,+,4}<nuw><nsw><%bb6>) to i32) * {0,+,4}<%bb6>) + %arg2)<nsw> U: full-set S: full-set Exits: ((4 * (trunc i64 (1 smin (4 * ((zext i32* (-4 + (-1 * %arg) + %arg1) to i64) /u 4))<nuw><nsw>) to i32) * ((-4 + (-1 * %arg) + %arg1) /u 4)) + %arg2)<nsw> LoopDispositions: { %bb6: Computable } ; X32-NEXT: %i13 = load i32, i32* %i12, align 4 ; X32-NEXT: --> %i13 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant } ; X32-NEXT: %i14 = add nsw i32 %i13, %i8 diff --git a/llvm/test/Transforms/LoopStrengthReduce/X86/expander-crashes.ll b/llvm/test/Transforms/LoopStrengthReduce/X86/expander-crashes.ll index c895a10ba110..1525b811c0ca 100644 --- a/llvm/test/Transforms/LoopStrengthReduce/X86/expander-crashes.ll +++ b/llvm/test/Transforms/LoopStrengthReduce/X86/expander-crashes.ll @@ -11,44 +11,42 @@ target triple = "x86_64-apple-macosx10.15.0" define i64 @blam(%struct.hoge* %start, %struct.hoge* %end, %struct.hoge* %ptr.2) { ; CHECK-LABEL: @blam( ; CHECK-NEXT: entry: -; CHECK-NEXT: [[END16:%.*]] = bitcast %struct.hoge* [[END:%.*]] to i8* -; CHECK-NEXT: [[START17:%.*]] = ptrtoint %struct.hoge* [[START:%.*]] to i64 -; CHECK-NEXT: [[SCEVGEP12:%.*]] = getelementptr [[STRUCT_HOGE:%.*]], %struct.hoge* [[START]], i64 0, i32 3 -; CHECK-NEXT: [[SCEVGEP1213:%.*]] = bitcast i32* [[SCEVGEP12]] to %struct.hoge* -; CHECK-NEXT: [[TMP0:%.*]] = sub i64 0, [[START17]] -; CHECK-NEXT: [[UGLYGEP18:%.*]] = getelementptr i8, i8* [[END16]], i64 [[TMP0]] -; CHECK-NEXT: [[UGLYGEP1819:%.*]] = bitcast i8* [[UGLYGEP18]] to %struct.hoge* +; CHECK-NEXT: [[START9:%.*]] = ptrtoint %struct.hoge* [[START:%.*]] to i64 +; CHECK-NEXT: [[START6:%.*]] = bitcast %struct.hoge* [[START]] to i8* +; CHECK-NEXT: [[END8:%.*]] = bitcast %struct.hoge* [[END:%.*]] to i8* +; CHECK-NEXT: [[TMP0:%.*]] = ptrtoint %struct.hoge* [[START]] to i64 +; CHECK-NEXT: [[TMP1:%.*]] = sub i64 0, [[START9]] +; CHECK-NEXT: [[UGLYGEP10:%.*]] = getelementptr i8, i8* [[END8]], i64 [[TMP1]] ; CHECK-NEXT: br label [[LOOP_1_HEADER:%.*]] ; CHECK: loop.1.header: -; CHECK-NEXT: [[LSR_IV20:%.*]] = phi %struct.hoge* [ [[SCEVGEP21:%.*]], [[LOOP_1_HEADER]] ], [ [[UGLYGEP1819]], [[ENTRY:%.*]] ] -; CHECK-NEXT: [[LSR_IV14:%.*]] = phi %struct.hoge* [ [[SCEVGEP15:%.*]], [[LOOP_1_HEADER]] ], [ [[SCEVGEP1213]], [[ENTRY]] ] -; CHECK-NEXT: [[SCEVGEP15]] = getelementptr [[STRUCT_HOGE]], %struct.hoge* [[LSR_IV14]], i64 1 -; CHECK-NEXT: [[SCEVGEP21]] = getelementptr [[STRUCT_HOGE]], %struct.hoge* [[LSR_IV20]], i64 -1 -; CHECK-NEXT: [[EC:%.*]] = icmp eq %struct.hoge* [[SCEVGEP21]], null +; CHECK-NEXT: [[LSR_IV4:%.*]] = phi i64 [ [[LSR_IV_NEXT5:%.*]], [[LOOP_1_HEADER]] ], [ 0, [[ENTRY:%.*]] ] +; CHECK-NEXT: [[LSR_IV_NEXT5]] = add i64 [[LSR_IV4]], -16 +; CHECK-NEXT: [[SCEVGEP11:%.*]] = getelementptr i8, i8* [[UGLYGEP10]], i64 [[LSR_IV_NEXT5]] +; CHECK-NEXT: [[SCEVGEP1112:%.*]] = bitcast i8* [[SCEVGEP11]] to %struct.hoge* +; CHECK-NEXT: [[EC:%.*]] = icmp eq %struct.hoge* [[SCEVGEP1112]], null ; CHECK-NEXT: br i1 [[EC]], label [[LOOP_2_PH:%.*]], label [[LOOP_1_HEADER]] ; CHECK: loop.2.ph: +; CHECK-NEXT: [[TMP2:%.*]] = sub i64 [[TMP0]], [[LSR_IV_NEXT5]] +; CHECK-NEXT: [[TMP3:%.*]] = mul i64 [[LSR_IV_NEXT5]], -1 +; CHECK-NEXT: [[UGLYGEP:%.*]] = getelementptr i8, i8* [[START6]], i64 [[TMP3]] +; CHECK-NEXT: [[UGLYGEP7:%.*]] = bitcast i8* [[UGLYGEP]] to %struct.hoge* ; CHECK-NEXT: br label [[LOOP_2_HEADER:%.*]] ; CHECK: loop.2.header: -; CHECK-NEXT: [[LSR_IV3:%.*]] = phi %struct.hoge* [ [[SCEVGEP4:%.*]], [[LOOP_2_LATCH:%.*]] ], [ [[SCEVGEP15]], [[LOOP_2_PH]] ] -; CHECK-NEXT: [[LSR_IV310:%.*]] = bitcast %struct.hoge* [[LSR_IV3]] to i32* -; CHECK-NEXT: [[LSR_IV37:%.*]] = bitcast %struct.hoge* [[LSR_IV3]] to i8* -; CHECK-NEXT: [[UGLYGEP8:%.*]] = getelementptr i8, i8* [[LSR_IV37]], i64 -12 -; CHECK-NEXT: [[UGLYGEP89:%.*]] = bitcast i8* [[UGLYGEP8]] to %struct.hoge* -; CHECK-NEXT: [[LSR_IV35:%.*]] = bitcast %struct.hoge* [[LSR_IV3]] to i8* -; CHECK-NEXT: [[TMP8:%.*]] = ptrtoint i32* [[LSR_IV310]] to i64 -; CHECK-NEXT: call void @use.i64(i64 [[TMP8]]) -; CHECK-NEXT: [[SCEVGEP11:%.*]] = getelementptr i32, i32* [[LSR_IV310]], i64 -1 -; CHECK-NEXT: store i32 10, i32* [[SCEVGEP11]], align 8 -; CHECK-NEXT: [[EC_2:%.*]] = icmp ugt %struct.hoge* [[UGLYGEP89]], [[PTR_2:%.*]] +; CHECK-NEXT: [[LSR_IV1:%.*]] = phi i64 [ [[LSR_IV_NEXT2:%.*]], [[LOOP_2_LATCH:%.*]] ], [ [[TMP2]], [[LOOP_2_PH]] ] +; CHECK-NEXT: [[IV2:%.*]] = phi %struct.hoge* [ [[IV2_NEXT:%.*]], [[LOOP_2_LATCH]] ], [ [[UGLYGEP7]], [[LOOP_2_PH]] ] +; CHECK-NEXT: [[IV23:%.*]] = bitcast %struct.hoge* [[IV2]] to i32* +; CHECK-NEXT: [[TMP4:%.*]] = add i64 [[LSR_IV1]], 12 +; CHECK-NEXT: call void @use.i64(i64 [[TMP4]]) +; CHECK-NEXT: [[SCEVGEP:%.*]] = getelementptr i32, i32* [[IV23]], i64 2 +; CHECK-NEXT: store i32 10, i32* [[SCEVGEP]], align 8 +; CHECK-NEXT: [[EC_2:%.*]] = icmp ugt %struct.hoge* [[IV2]], [[PTR_2:%.*]] ; CHECK-NEXT: br i1 [[EC_2]], label [[LOOP_2_EXIT:%.*]], label [[LOOP_2_LATCH]] ; CHECK: loop.2.latch: -; CHECK-NEXT: [[SCEVGEP4]] = getelementptr [[STRUCT_HOGE]], %struct.hoge* [[LSR_IV3]], i64 1 +; CHECK-NEXT: [[IV2_NEXT]] = getelementptr inbounds [[STRUCT_HOGE:%.*]], %struct.hoge* [[IV2]], i64 1 +; CHECK-NEXT: [[LSR_IV_NEXT2]] = add i64 [[LSR_IV1]], 16 ; CHECK-NEXT: br label [[LOOP_2_HEADER]] ; CHECK: loop.2.exit: -; CHECK-NEXT: [[UGLYGEP:%.*]] = getelementptr i8, i8* [[LSR_IV35]], i64 -12 -; CHECK-NEXT: [[UGLYGEP6:%.*]] = bitcast i8* [[UGLYGEP]] to %struct.hoge* -; CHECK-NEXT: [[IV2_CAST:%.*]] = ptrtoint %struct.hoge* [[UGLYGEP6]] to i64 -; CHECK-NEXT: ret i64 [[IV2_CAST]] +; CHECK-NEXT: ret i64 [[LSR_IV1]] ; entry: br label %loop.1.header diff --git a/polly/test/ScopInfo/int2ptr_ptr2int.ll b/polly/test/ScopInfo/int2ptr_ptr2int.ll index 9618ea068e1b..2a0b69c7536f 100644 --- a/polly/test/ScopInfo/int2ptr_ptr2int.ll +++ b/polly/test/ScopInfo/int2ptr_ptr2int.ll @@ -17,25 +17,25 @@ ; CHECK-NEXT: [val, ptr] -> { Stmt_for_body[i0] -> MemRef_A[9 + ptr] }; ; ; IR: polly.stmt.for.body: -; IR-NEXT: %p_tmp1 = inttoptr i64 %0 to i64* +; IR-NEXT: %p_tmp1 = inttoptr i64 %14 to i64* ; IR-NEXT: %p_add.ptr2 = getelementptr inbounds i64, i64* %p_tmp1, i64 1 ; IR-NEXT: %p_tmp2 = ptrtoint i64* %p_add.ptr2 to i64 ; IR-NEXT: %p_arrayidx = getelementptr inbounds i64, i64* %A, i64 %p_tmp2 ; IR-NEXT: %tmp3_p_scalar_ = load i64, i64* %p_arrayidx, align 8, !alias.scope !0, !noalias !2 -; IR-NEXT: %tmp4_p_scalar_ = load i64, i64* %scevgep1, align 8, !alias.scope !0, !noalias !2 +; IR-NEXT: %tmp4_p_scalar_ = load i64, i64* %scevgep, align 8, !alias.scope !0, !noalias !2 ; IR-NEXT: %p_add4 = add nsw i64 %tmp4_p_scalar_, %tmp3_p_scalar_ -; IR-NEXT: store i64 %p_add4, i64* %scevgep1, align 8, !alias.scope !0, !noalias !2 +; IR-NEXT: store i64 %p_add4, i64* %scevgep, align 8, !alias.scope !0, !noalias !2 ; IR-NEXT: %polly.indvar_next = add nsw i64 %polly.indvar, 1 ; IR-NEXT: %polly.loop_cond = icmp sle i64 %polly.indvar_next, 99 ; IR-NEXT: br i1 %polly.loop_cond, label %polly.loop_header, label %polly.loop_exit ; ; IR: polly.loop_preheader: -; IR-NEXT: %0 = add i64 %val, 1 -; IR-NEXT: %scevgep = getelementptr i64, i64* %ptr, i32 1 -; IR-NEXT: %1 = ptrtoint i64* %scevgep to i32 -; IR-NEXT: %2 = add i32 %1, 1 -; IR-NEXT: %scevgep1 = getelementptr i64, i64* %A, i32 %2 +; IR-NEXT: %14 = add i64 %val, 1 +; IR-NEXT: %15 = ptrtoint i64* %ptr to i32 +; IR-NEXT: %16 = add i32 %15, 9 +; IR-NEXT: %scevgep = getelementptr i64, i64* %A, i32 %16 ; IR-NEXT: br label %polly.loop_header + ; target datalayout = "e-p:32:32:32-m:e-i64:64-f80:128-n8:16:32:64-S128" diff --git a/polly/test/ScopInfo/int2ptr_ptr2int_2.ll b/polly/test/ScopInfo/int2ptr_ptr2int_2.ll index 894f5f308a07..c0bd80b1e242 100644 --- a/polly/test/ScopInfo/int2ptr_ptr2int_2.ll +++ b/polly/test/ScopInfo/int2ptr_ptr2int_2.ll @@ -13,7 +13,7 @@ ; ; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: [val, ptr] -> { Stmt_for_body[i0] -> MemRef_B[9 + val] }; -; CHECK-NEXT: Execution Context: [val, ptr] -> { : val <= 32766 } +; CHECK-NEXT: Execution Context: [val, ptr] -> { : -4097 <= val <= 4086 } ; ; CHECK: ReadAccess := [Reduction Type: +] [Scalar: 0] ; CHECK-NEXT: [val, ptr] -> { Stmt_for_body[i0] -> MemRef_A[9 + ptr] }; @@ -21,19 +21,18 @@ ; CHECK-NEXT: [val, ptr] -> { Stmt_for_body[i0] -> MemRef_A[9 + ptr] }; ; ; IR: polly.stmt.for.body: -; IR-NEXT: %tmp4_p_scalar_ = load i64, i64* %scevgep13, align 8, !alias.scope !3, !noalias !4 +; IR-NEXT: %tmp4_p_scalar_ = load i64, i64* %scevgep, align 8, !alias.scope !3, !noalias !4 ; IR-NEXT: %p_add4 = add nsw i64 %tmp4_p_scalar_, %polly.preload.tmp3.merge -; IR-NEXT: store i64 %p_add4, i64* %scevgep13, align 8, !alias.scope !3, !noalias !4 +; IR-NEXT: store i64 %p_add4, i64* %scevgep, align 8, !alias.scope !3, !noalias !4 ; IR-NEXT: %polly.indvar_next = add nsw i64 %polly.indvar, 1 ; IR-NEXT: %polly.loop_cond = icmp sle i64 %polly.indvar_next, 99 ; IR-NEXT: br i1 %polly.loop_cond, label %polly.loop_header, label %polly.loop_exit -; + ; IR: polly.loop_preheader: -; IR-NEXT: %35 = add i16 %val, 1 -; IR-NEXT: %scevgep = getelementptr i64, i64* %ptr, i16 1 -; IR-NEXT: %36 = ptrtoint i64* %scevgep to i16 -; IR-NEXT: %37 = add i16 %36, 1 -; IR-NEXT: %scevgep13 = getelementptr i64, i64* %A, i16 %37 +; IR-NEXT: %41 = add i16 %val, 1 +; IR-NEXT: %42 = ptrtoint i64* %ptr to i16 +; IR-NEXT: %43 = add i16 %42, 9 +; IR-NEXT: %scevgep = getelementptr i64, i64* %A, i16 %43 ; IR-NEXT: br label %polly.loop_header ; target datalayout = "e-p:16:16:16-m:e-i64:64-f80:128-n8:16:16:64-S128" </cut>

4 years, 2 months

[CI-NOTIFY]: TCWG Bisect tcwg_bmk_tk1/llvm-release-arm-spec2k6-Os - Build # 15 - Successful!

by ci_notify＠linaro.org

Successfully identified regression in *llvm* in CI configuration tcwg_bmk_llvm_tk1/llvm-release-arm-spec2k6-Os. So far, this commit has regressed CI configurations: - tcwg_bmk_llvm_tk1/llvm-release-arm-spec2k6-Os Culprit: <cut> commit 3a2b05f9fe74fcf9560632cf2695058d47d8683b Author: Evgeniy Brevnov <ybrevnov(a)azul.com> Date: Fri Jul 24 18:57:10 2020 +0700 [BPI][NFC] Consolidate code to deal with SCCs under a dedicated data structure. In order to facilitate review of D79485 here is a small NFC change which restructures code around handling of SCCs in BPI. Reviewed By: davidxl Differential Revision: https://reviews.llvm.org/D84514 </cut> Results regressed to (for first_bad == 3a2b05f9fe74fcf9560632cf2695058d47d8683b) # reset_artifacts: -10 # build_abe binutils: -9 # build_abe stage1 -- --set gcc_override_configure=--with-mode=thumb --set gcc_override_configure=--disable-libsanitizer: -8 # build_abe linux: -7 # build_abe glibc: -6 # build_abe stage2 -- --set gcc_override_configure=--with-mode=thumb --set gcc_override_configure=--disable-libsanitizer: -5 # build_llvm true: -3 # true: 0 # benchmark -Os_mthumb -- artifacts/build-3a2b05f9fe74fcf9560632cf2695058d47d8683b/results_id: 1 # 401.bzip2,bzip2_base.default regressed by 104 from (for last_good == 7294ca3f6ecacd05a197bbf0637e10afcb99b6d6) # reset_artifacts: -10 # build_abe binutils: -9 # build_abe stage1 -- --set gcc_override_configure=--with-mode=thumb --set gcc_override_configure=--disable-libsanitizer: -8 # build_abe linux: -7 # build_abe glibc: -6 # build_abe stage2 -- --set gcc_override_configure=--with-mode=thumb --set gcc_override_configure=--disable-libsanitizer: -5 # build_llvm true: -3 # true: 0 # benchmark -Os_mthumb -- artifacts/build-7294ca3f6ecacd05a197bbf0637e10afcb99b6d6/results_id: 1 Artifacts of last_good build: https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tk1-llvm-release… Results ID of last_good: tk1_32/tcwg_bmk_llvm_tk1/bisect-llvm-release-arm-spec2k6-Os/699 Artifacts of first_bad build: https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tk1-llvm-release… Results ID of first_bad: tk1_32/tcwg_bmk_llvm_tk1/bisect-llvm-release-arm-spec2k6-Os/688 Build top page/logs: https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tk1-llvm-release… Configuration details: Reproduce builds: <cut> mkdir investigate-llvm-3a2b05f9fe74fcf9560632cf2695058d47d8683b cd investigate-llvm-3a2b05f9fe74fcf9560632cf2695058d47d8683b 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-release… --fail curl -o artifacts/manifests/build-parameters.sh https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tk1-llvm-release… --fail curl -o artifacts/test.sh https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tk1-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 3a2b05f9fe74fcf9560632cf2695058d47d8683b ../artifacts/test.sh # Reproduce last_good build git checkout --detach 7294ca3f6ecacd05a197bbf0637e10afcb99b6d6 ../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-release… Build log: https://ci.linaro.org/job/tcwg_bmk_ci_llvm-bisect-tcwg_bmk_tk1-llvm-release… Full commit (up to 1000 lines): <cut> commit 3a2b05f9fe74fcf9560632cf2695058d47d8683b Author: Evgeniy Brevnov <ybrevnov(a)azul.com> Date: Fri Jul 24 18:57:10 2020 +0700 [BPI][NFC] Consolidate code to deal with SCCs under a dedicated data structure. In order to facilitate review of D79485 here is a small NFC change which restructures code around handling of SCCs in BPI. Reviewed By: davidxl Differential Revision: https://reviews.llvm.org/D84514 --- llvm/include/llvm/Analysis/BranchProbabilityInfo.h | 71 ++++++++- llvm/lib/Analysis/BranchProbabilityInfo.cpp | 164 +++++++++++++-------- 2 files changed, 169 insertions(+), 66 deletions(-) diff --git a/llvm/include/llvm/Analysis/BranchProbabilityInfo.h b/llvm/include/llvm/Analysis/BranchProbabilityInfo.h index 3e72afba36c3..7feb5b625938 100644 --- a/llvm/include/llvm/Analysis/BranchProbabilityInfo.h +++ b/llvm/include/llvm/Analysis/BranchProbabilityInfo.h @@ -151,13 +151,66 @@ public: /// Forget analysis results for the given basic block. void eraseBlock(const BasicBlock *BB); - // Use to track SCCs for handling irreducible loops. - using SccMap = DenseMap<const BasicBlock *, int>; - using SccHeaderMap = DenseMap<const BasicBlock *, bool>; - using SccHeaderMaps = std::vector<SccHeaderMap>; - struct SccInfo { + class SccInfo { + // Enum of types to classify basic blocks in SCC. Basic block belonging to + // SCC is 'Inner' until it is either 'Header' or 'Exiting'. Note that a + // basic block can be 'Header' and 'Exiting' at the same time. + enum SccBlockType { + Inner = 0x0, + Header = 0x1, + Exiting = 0x2, + }; + // Map of basic blocks to SCC IDs they belong to. If basic block doesn't + // belong to any SCC it is not in the map. + using SccMap = DenseMap<const BasicBlock *, int>; + // Each basic block in SCC is attributed with one or several types from + // SccBlockType. Map value has uint32_t type (instead of SccBlockType) + // since basic block may be for example "Header" and "Exiting" at the same + // time and we need to be able to keep more than one value from + // SccBlockType. + using SccBlockTypeMap = DenseMap<const BasicBlock *, uint32_t>; + // Vector containing classification of basic blocks for all SCCs where i'th + // vector element corresponds to SCC with ID equal to i. + using SccBlockTypeMaps = std::vector<SccBlockTypeMap>; + SccMap SccNums; - SccHeaderMaps SccHeaders; + SccBlockTypeMaps SccBlocks; + + public: + explicit SccInfo(const Function &F); + + /// If \p BB belongs to some SCC then ID of that SCC is returned, otherwise + /// -1 is returned. If \p BB belongs to more than one SCC at the same time + /// result is undefined. + int getSCCNum(const BasicBlock *BB) const; + /// Returns true if \p BB is a 'header' block in SCC with \p SccNum ID, + /// false otherwise. + bool isSCCHeader(const BasicBlock *BB, int SccNum) const { + return getSccBlockType(BB, SccNum) & Header; + } + /// Returns true if \p BB is an 'exiting' block in SCC with \p SccNum ID, + /// false otherwise. + bool isSCCExitingBlock(const BasicBlock *BB, int SccNum) const { + return getSccBlockType(BB, SccNum) & Exiting; + } + /// Fills in \p Enters vector with all such blocks that don't belong to + /// SCC with \p SccNum ID but there is an edge to a block belonging to the + /// SCC. + void getSccEnterBlocks(int SccNum, + SmallVectorImpl<BasicBlock *> &Enters) const; + /// Fills in \p Exits vector with all such blocks that don't belong to + /// SCC with \p SccNum ID but there is an edge from a block belonging to the + /// SCC. + void getSccExitBlocks(int SccNum, + SmallVectorImpl<BasicBlock *> &Exits) const; + + private: + /// Returns \p BB's type according to classification given by SccBlockType + /// enum. Please note that \p BB must belong to SSC with \p SccNum ID. + uint32_t getSccBlockType(const BasicBlock *BB, int SccNum) const; + /// Calculates \p BB's type and stores it in internal data structures for + /// future use. Please note that \p BB must belong to SSC with \p SccNum ID. + void calculateSccBlockType(const BasicBlock *BB, int SccNum); }; private: @@ -196,6 +249,9 @@ private: /// Track the last function we run over for printing. const Function *LastF = nullptr; + /// Keeps information about all SCCs in a function. + std::unique_ptr<const SccInfo> SccI; + /// Track the set of blocks directly succeeded by a returning block. SmallPtrSet<const BasicBlock *, 16> PostDominatedByUnreachable; @@ -210,8 +266,7 @@ private: bool calcMetadataWeights(const BasicBlock *BB); bool calcColdCallHeuristics(const BasicBlock *BB); bool calcPointerHeuristics(const BasicBlock *BB); - bool calcLoopBranchHeuristics(const BasicBlock *BB, const LoopInfo &LI, - SccInfo &SccI); + bool calcLoopBranchHeuristics(const BasicBlock *BB, const LoopInfo &LI); bool calcZeroHeuristics(const BasicBlock *BB, const TargetLibraryInfo *TLI); bool calcFloatingPointHeuristics(const BasicBlock *BB); bool calcInvokeHeuristics(const BasicBlock *BB); diff --git a/llvm/lib/Analysis/BranchProbabilityInfo.cpp b/llvm/lib/Analysis/BranchProbabilityInfo.cpp index a396b5ad21c6..195fc69d9601 100644 --- a/llvm/lib/Analysis/BranchProbabilityInfo.cpp +++ b/llvm/lib/Analysis/BranchProbabilityInfo.cpp @@ -148,6 +148,105 @@ static const uint32_t IH_TAKEN_WEIGHT = 1024 * 1024 - 1; /// instruction. This is essentially never taken. static const uint32_t IH_NONTAKEN_WEIGHT = 1; +BranchProbabilityInfo::SccInfo::SccInfo(const Function &F) { + // Record SCC numbers of blocks in the CFG to identify irreducible loops. + // FIXME: We could only calculate this if the CFG is known to be irreducible + // (perhaps cache this info in LoopInfo if we can easily calculate it there?). + int SccNum = 0; + for (scc_iterator<const Function *> It = scc_begin(&F); !It.isAtEnd(); + ++It, ++SccNum) { + // Ignore single-block SCCs since they either aren't loops or LoopInfo will + // catch them. + const std::vector<const BasicBlock *> &Scc = *It; + if (Scc.size() == 1) + continue; + + LLVM_DEBUG(dbgs() << "BPI: SCC " << SccNum << ":"); + for (const auto *BB : Scc) { + LLVM_DEBUG(dbgs() << " " << BB->getName()); + SccNums[BB] = SccNum; + calculateSccBlockType(BB, SccNum); + } + LLVM_DEBUG(dbgs() << "\n"); + } +} + +int BranchProbabilityInfo::SccInfo::getSCCNum(const BasicBlock *BB) const { + auto SccIt = SccNums.find(BB); + if (SccIt == SccNums.end()) + return -1; + return SccIt->second; +} + +void BranchProbabilityInfo::SccInfo::getSccEnterBlocks( + int SccNum, SmallVectorImpl<BasicBlock *> &Enters) const { + + for (auto MapIt : SccBlocks[SccNum]) { + const auto *BB = MapIt.first; + if (isSCCHeader(BB, SccNum)) + for (const auto *Pred : predecessors(BB)) + if (getSCCNum(Pred) != SccNum) + Enters.push_back(const_cast<BasicBlock *>(BB)); + } +} + +void BranchProbabilityInfo::SccInfo::getSccExitBlocks( + int SccNum, SmallVectorImpl<BasicBlock *> &Exits) const { + for (auto MapIt : SccBlocks[SccNum]) { + const auto *BB = MapIt.first; + if (isSCCExitingBlock(BB, SccNum)) + for (const auto *Succ : successors(BB)) + if (getSCCNum(Succ) != SccNum) + Exits.push_back(const_cast<BasicBlock *>(BB)); + } +} + +uint32_t BranchProbabilityInfo::SccInfo::getSccBlockType(const BasicBlock *BB, + int SccNum) const { + assert(getSCCNum(BB) == SccNum); + + assert(SccBlocks.size() > static_cast<unsigned>(SccNum) && "Unknown SCC"); + const auto &SccBlockTypes = SccBlocks[SccNum]; + + auto It = SccBlockTypes.find(BB); + if (It != SccBlockTypes.end()) { + return It->second; + } + return Inner; +} + +void BranchProbabilityInfo::SccInfo::calculateSccBlockType(const BasicBlock *BB, + int SccNum) { + assert(getSCCNum(BB) == SccNum); + uint32_t BlockType = Inner; + + if (llvm::any_of(make_range(pred_begin(BB), pred_end(BB)), + [&](const BasicBlock *Pred) { + // Consider any block that is an entry point to the SCC as + // a header. + return getSCCNum(Pred) != SccNum; + })) + BlockType |= Header; + + if (llvm::any_of( + make_range(succ_begin(BB), succ_end(BB)), + [&](const BasicBlock *Succ) { return getSCCNum(Succ) != SccNum; })) + BlockType |= Exiting; + + // Lazily compute the set of headers for a given SCC and cache the results + // in the SccHeaderMap. + if (SccBlocks.size() <= static_cast<unsigned>(SccNum)) + SccBlocks.resize(SccNum + 1); + auto &SccBlockTypes = SccBlocks[SccNum]; + + if (BlockType != Inner) { + bool IsInserted; + std::tie(std::ignore, IsInserted) = + SccBlockTypes.insert(std::make_pair(BB, BlockType)); + assert(IsInserted && "Duplicated block in SCC"); + } +} + static void UpdatePDTWorklist(const BasicBlock *BB, PostDominatorTree *PDT, SmallVectorImpl<const BasicBlock *> &WorkList, SmallPtrSetImpl<const BasicBlock *> &TargetSet) { @@ -511,38 +610,6 @@ bool BranchProbabilityInfo::calcPointerHeuristics(const BasicBlock *BB) { return true; } -static int getSCCNum(const BasicBlock *BB, - const BranchProbabilityInfo::SccInfo &SccI) { - auto SccIt = SccI.SccNums.find(BB); - if (SccIt == SccI.SccNums.end()) - return -1; - return SccIt->second; -} - -// Consider any block that is an entry point to the SCC as a header. -static bool isSCCHeader(const BasicBlock *BB, int SccNum, - BranchProbabilityInfo::SccInfo &SccI) { - assert(getSCCNum(BB, SccI) == SccNum); - - // Lazily compute the set of headers for a given SCC and cache the results - // in the SccHeaderMap. - if (SccI.SccHeaders.size() <= static_cast<unsigned>(SccNum)) - SccI.SccHeaders.resize(SccNum + 1); - auto &HeaderMap = SccI.SccHeaders[SccNum]; - bool Inserted; - BranchProbabilityInfo::SccHeaderMap::iterator HeaderMapIt; - std::tie(HeaderMapIt, Inserted) = HeaderMap.insert(std::make_pair(BB, false)); - if (Inserted) { - bool IsHeader = llvm::any_of(make_range(pred_begin(BB), pred_end(BB)), - [&](const BasicBlock *Pred) { - return getSCCNum(Pred, SccI) != SccNum; - }); - HeaderMapIt->second = IsHeader; - return IsHeader; - } else - return HeaderMapIt->second; -} - // Compute the unlikely successors to the block BB in the loop L, specifically // those that are unlikely because this is a loop, and add them to the // UnlikelyBlocks set. @@ -653,12 +720,11 @@ computeUnlikelySuccessors(const BasicBlock *BB, Loop *L, // Calculate Edge Weights using "Loop Branch Heuristics". Predict backedges // as taken, exiting edges as not-taken. bool BranchProbabilityInfo::calcLoopBranchHeuristics(const BasicBlock *BB, - const LoopInfo &LI, - SccInfo &SccI) { + const LoopInfo &LI) { int SccNum; Loop *L = LI.getLoopFor(BB); if (!L) { - SccNum = getSCCNum(BB, SccI); + SccNum = SccI->getSCCNum(BB); if (SccNum < 0) return false; } @@ -685,9 +751,9 @@ bool BranchProbabilityInfo::calcLoopBranchHeuristics(const BasicBlock *BB, else InEdges.push_back(I.getSuccessorIndex()); } else { - if (getSCCNum(*I, SccI) != SccNum) + if (SccI->getSCCNum(*I) != SccNum) ExitingEdges.push_back(I.getSuccessorIndex()); - else if (isSCCHeader(*I, SccNum, SccI)) + else if (SccI->isSCCHeader(*I, SccNum)) BackEdges.push_back(I.getSuccessorIndex()); else InEdges.push_back(I.getSuccessorIndex()); @@ -1072,26 +1138,7 @@ void BranchProbabilityInfo::calculate(const Function &F, const LoopInfo &LI, assert(PostDominatedByUnreachable.empty()); assert(PostDominatedByColdCall.empty()); - // Record SCC numbers of blocks in the CFG to identify irreducible loops. - // FIXME: We could only calculate this if the CFG is known to be irreducible - // (perhaps cache this info in LoopInfo if we can easily calculate it there?). - int SccNum = 0; - SccInfo SccI; - for (scc_iterator<const Function *> It = scc_begin(&F); !It.isAtEnd(); - ++It, ++SccNum) { - // Ignore single-block SCCs since they either aren't loops or LoopInfo will - // catch them. - const std::vector<const BasicBlock *> &Scc = *It; - if (Scc.size() == 1) - continue; - - LLVM_DEBUG(dbgs() << "BPI: SCC " << SccNum << ":"); - for (auto *BB : Scc) { - LLVM_DEBUG(dbgs() << " " << BB->getName()); - SccI.SccNums[BB] = SccNum; - } - LLVM_DEBUG(dbgs() << "\n"); - } + SccI = std::make_unique<SccInfo>(F); std::unique_ptr<PostDominatorTree> PDTPtr; @@ -1119,7 +1166,7 @@ void BranchProbabilityInfo::calculate(const Function &F, const LoopInfo &LI, continue; if (calcColdCallHeuristics(BB)) continue; - if (calcLoopBranchHeuristics(BB, LI, SccI)) + if (calcLoopBranchHeuristics(BB, LI)) continue; if (calcPointerHeuristics(BB)) continue; @@ -1131,6 +1178,7 @@ void BranchProbabilityInfo::calculate(const Function &F, const LoopInfo &LI, PostDominatedByUnreachable.clear(); PostDominatedByColdCall.clear(); + SccI.release(); if (PrintBranchProb && (PrintBranchProbFuncName.empty() || </cut>

4 years, 2 months

Binutils help? Aarch64 PE/COFF support to enable UEFI Secure Boot

by Steve McIntyre

Hi folks, I'm hoping that I might be able to get some development help with binutils for aarch64... I'm maintaining the UEFI Secure Boot stack in Debian (shim etc.), including for arm64/aarch64 (as I wanted to make that work too!). UEFI binaries are awkward for those of used to the Linux and ELF world - they're PE/COFF format with different calling conventions to match the Microsoft world. But we've made things work. On x86 platforms, the shim build process uses objcopy --target=efi-app-$(ARCH) to produce the final output binaries. We've never had similar support for the aarch64 platform, and instead somebody came up with a method using locally-hacked linker script and "-O binary" to generate the output binaries. That's worked well enough for a while, but it's been annoying for various reasons (particularly debugging problems). *However*, recently for security reasons we've tweaked the layout of Secure Boot binaries [1] and this has caused lots of problems. The older hacks to hand-build the right sections etc. needed significant extra work, and we're still dealing with awkward bugs related to this. Based ont these problems, I recently had to make the painful decision to drop support for arm64 SB in Debian. I know that other distributions are feeling similar pain. :-( Rather than continuing to hack on things, I think it's (way past) time that we did things correctly! We need aarch64 binary format support in binutils so we can just use it like we do on x86. AFAICS, there is already a bug open asking for this from last year [2]. Could I please prevail on some friendly neighourhood aarch64 toolchain engineer to help with that? Thanks for considering, Steve [1] https://github.com/rhboot/shim/blob/main/SBAT.md [2] https://sourceware.org/bugzilla/show_bug.cgi?id=26206#add_comment -- Steve McIntyre, Cambridge, UK. steve(a)einval.com "...In the UNIX world, people tend to interpret `non-technical user' as meaning someone who's only ever written one device driver." -- Daniel Pead

4 years, 2 months

[CI-NOTIFY]: TCWG Bisect tcwg_bmk_tx1/llvm-master-aarch64-spec2k6-O2_LTO - Build # 15 - 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 8fe62b7af1127691d6732438b322e66ae6d39a03 Author: Max Kazantsev <mkazantsev(a)azul.com> Date: Thu Apr 22 12:50:38 2021 +0700 [GVN] Introduce loop load PRE This patch allows PRE of the following type of loads: ``` preheader: br label %loop loop: br i1 ..., label %merge, label %clobber clobber: call foo() // Clobbers %p br label %merge merge: ... br i1 ..., label %loop, label %exit ``` Into ``` preheader: %x0 = load %p br label %loop loop: %x.pre = phi(x0, x2) br i1 ..., label %merge, label %clobber clobber: call foo() // Clobbers %p %x1 = load %p br label %merge merge: x2 = phi(x.pre, x1) ... br i1 ..., label %loop, label %exit ``` So instead of loading from %p on every iteration, we load only when the actual clobber happens. The typical pattern which it is trying to address is: hot loop, with all code inlined and provably having no side effects, and some side-effecting calls on cold path. The worst overhead from it is, if we always take clobber block, we make 1 more load overall (in preheader). It only matters if loop has very few iteration. If clobber block is not taken at least once, the transform is neutral or profitable. There are several improvements prospect open up: - We can sometimes be smarter in loop-exiting blocks via split of critical edges; - If we have block frequency info, we can handle multiple clobbers. The only obstacle now is that we don't know if their sum is colder than the header. Differential Revision: https://reviews.llvm.org/D99926 Reviewed By: reames </cut> Results regressed to (for first_bad == 8fe62b7af1127691d6732438b322e66ae6d39a03) # 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-8fe62b7af1127691d6732438b322e66ae6d39a03/results_id: 1 # 464.h264ref,h264ref_base.default regressed by 104 from (for last_good == 722d4d8e7585457d407d0639a4ae2610157e06a8) # 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-722d4d8e7585457d407d0639a4ae2610157e06a8/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/641 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/642 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-8fe62b7af1127691d6732438b322e66ae6d39a03 cd investigate-llvm-8fe62b7af1127691d6732438b322e66ae6d39a03 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 8fe62b7af1127691d6732438b322e66ae6d39a03 ../artifacts/test.sh # Reproduce last_good build git checkout --detach 722d4d8e7585457d407d0639a4ae2610157e06a8 ../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 8fe62b7af1127691d6732438b322e66ae6d39a03 Author: Max Kazantsev <mkazantsev(a)azul.com> Date: Thu Apr 22 12:50:38 2021 +0700 [GVN] Introduce loop load PRE This patch allows PRE of the following type of loads: ``` preheader: br label %loop loop: br i1 ..., label %merge, label %clobber clobber: call foo() // Clobbers %p br label %merge merge: ... br i1 ..., label %loop, label %exit ``` Into ``` preheader: %x0 = load %p br label %loop loop: %x.pre = phi(x0, x2) br i1 ..., label %merge, label %clobber clobber: call foo() // Clobbers %p %x1 = load %p br label %merge merge: x2 = phi(x.pre, x1) ... br i1 ..., label %loop, label %exit ``` So instead of loading from %p on every iteration, we load only when the actual clobber happens. The typical pattern which it is trying to address is: hot loop, with all code inlined and provably having no side effects, and some side-effecting calls on cold path. The worst overhead from it is, if we always take clobber block, we make 1 more load overall (in preheader). It only matters if loop has very few iteration. If clobber block is not taken at least once, the transform is neutral or profitable. There are several improvements prospect open up: - We can sometimes be smarter in loop-exiting blocks via split of critical edges; - If we have block frequency info, we can handle multiple clobbers. The only obstacle now is that we don't know if their sum is colder than the header. Differential Revision: https://reviews.llvm.org/D99926 Reviewed By: reames --- llvm/include/llvm/Transforms/Scalar/GVN.h | 6 ++ llvm/lib/Transforms/Scalar/GVN.cpp | 92 +++++++++++++++++++++++++-- llvm/test/Transforms/GVN/PRE/pre-loop-load.ll | 9 ++- 3 files changed, 98 insertions(+), 9 deletions(-) diff --git a/llvm/include/llvm/Transforms/Scalar/GVN.h b/llvm/include/llvm/Transforms/Scalar/GVN.h index 13f55ddcf2d6..70662ca213c3 100644 --- a/llvm/include/llvm/Transforms/Scalar/GVN.h +++ b/llvm/include/llvm/Transforms/Scalar/GVN.h @@ -328,6 +328,12 @@ private: bool PerformLoadPRE(LoadInst *Load, AvailValInBlkVect &ValuesPerBlock, UnavailBlkVect &UnavailableBlocks); + /// Try to replace a load which executes on each loop iteraiton with Phi + /// translation of load in preheader and load(s) in conditionally executed + /// paths. + bool performLoopLoadPRE(LoadInst *Load, AvailValInBlkVect &ValuesPerBlock, + UnavailBlkVect &UnavailableBlocks); + /// Eliminates partially redundant \p Load, replacing it with \p /// AvailableLoads (connected by Phis if needed). void eliminatePartiallyRedundantLoad( diff --git a/llvm/lib/Transforms/Scalar/GVN.cpp b/llvm/lib/Transforms/Scalar/GVN.cpp index 846a5cdb33d1..29da739fa16e 100644 --- a/llvm/lib/Transforms/Scalar/GVN.cpp +++ b/llvm/lib/Transforms/Scalar/GVN.cpp @@ -91,13 +91,14 @@ using namespace PatternMatch; #define DEBUG_TYPE "gvn" -STATISTIC(NumGVNInstr, "Number of instructions deleted"); -STATISTIC(NumGVNLoad, "Number of loads deleted"); -STATISTIC(NumGVNPRE, "Number of instructions PRE'd"); +STATISTIC(NumGVNInstr, "Number of instructions deleted"); +STATISTIC(NumGVNLoad, "Number of loads deleted"); +STATISTIC(NumGVNPRE, "Number of instructions PRE'd"); STATISTIC(NumGVNBlocks, "Number of blocks merged"); -STATISTIC(NumGVNSimpl, "Number of instructions simplified"); +STATISTIC(NumGVNSimpl, "Number of instructions simplified"); STATISTIC(NumGVNEqProp, "Number of equalities propagated"); -STATISTIC(NumPRELoad, "Number of loads PRE'd"); +STATISTIC(NumPRELoad, "Number of loads PRE'd"); +STATISTIC(NumPRELoopLoad, "Number of loop loads PRE'd"); STATISTIC(IsValueFullyAvailableInBlockNumSpeculationsMax, "Number of blocks speculated as available in " @@ -1447,6 +1448,84 @@ bool GVN::PerformLoadPRE(LoadInst *Load, AvailValInBlkVect &ValuesPerBlock, return true; } +bool GVN::performLoopLoadPRE(LoadInst *Load, AvailValInBlkVect &ValuesPerBlock, + UnavailBlkVect &UnavailableBlocks) { + if (!LI) + return false; + + const Loop *L = LI->getLoopFor(Load->getParent()); + // TODO: Generalize to other loop blocks that dominate the latch. + if (!L || L->getHeader() != Load->getParent()) + return false; + + BasicBlock *Preheader = L->getLoopPreheader(); + BasicBlock *Latch = L->getLoopLatch(); + if (!Preheader || !Latch) + return false; + + Value *LoadPtr = Load->getPointerOperand(); + // Must be available in preheader. + if (!L->isLoopInvariant(LoadPtr)) + return false; + + // We plan to hoist the load to preheader without introducing a new fault. + // In order to do it, we need to prove that we cannot side-exit the loop + // once loop header is first entered before execution of the load. + if (ICF->isDominatedByICFIFromSameBlock(Load)) + return false; + + BasicBlock *LoopBlock = nullptr; + for (auto *Blocker : UnavailableBlocks) { + // Blockers from outside the loop are handled in preheader. + if (!L->contains(Blocker)) + continue; + + // Only allow one loop block. Loop header is not less frequently executed + // than each loop block, and likely it is much more frequently executed. But + // in case of multiple loop blocks, we need extra information (such as block + // frequency info) to understand whether it is profitable to PRE into + // multiple loop blocks. + if (LoopBlock) + return false; + + // Do not sink into inner loops. This may be non-profitable. + if (L != LI->getLoopFor(Blocker)) + return false; + + // Blocks that dominate the latch execute on every single iteration, maybe + // except the last one. So PREing into these blocks doesn't make much sense + // in most cases. But the blocks that do not necessarily execute on each + // iteration are sometimes much colder than the header, and this is when + // PRE is potentially profitable. + if (DT->dominates(Blocker, Latch)) + return false; + + // Make sure that the terminator itself doesn't clobber. + if (Blocker->getTerminator()->mayWriteToMemory()) + return false; + + LoopBlock = Blocker; + } + + if (!LoopBlock) + return false; + + // Make sure the memory at this pointer cannot be freed, therefore we can + // safely reload from it after clobber. + if (LoadPtr->canBeFreed()) + return false; + + // TODO: Support critical edge splitting if blocker has more than 1 successor. + MapVector<BasicBlock *, Value *> AvailableLoads; + AvailableLoads[LoopBlock] = LoadPtr; + AvailableLoads[Preheader] = LoadPtr; + + LLVM_DEBUG(dbgs() << "GVN REMOVING PRE LOOP LOAD: " << *Load << '\n'); + eliminatePartiallyRedundantLoad(Load, ValuesPerBlock, AvailableLoads); + ++NumPRELoopLoad; + return true; +} + static void reportLoadElim(LoadInst *Load, Value *AvailableValue, OptimizationRemarkEmitter *ORE) { using namespace ore; @@ -1544,7 +1623,8 @@ bool GVN::processNonLocalLoad(LoadInst *Load) { if (!isLoadInLoopPREEnabled() && LI && LI->getLoopFor(Load->getParent())) return Changed; - return Changed || PerformLoadPRE(Load, ValuesPerBlock, UnavailableBlocks); + return Changed || PerformLoadPRE(Load, ValuesPerBlock, UnavailableBlocks) || + performLoopLoadPRE(Load, ValuesPerBlock, UnavailableBlocks); } static bool impliesEquivalanceIfTrue(CmpInst* Cmp) { diff --git a/llvm/test/Transforms/GVN/PRE/pre-loop-load.ll b/llvm/test/Transforms/GVN/PRE/pre-loop-load.ll index 15bc49e7ab9a..8ca12284d5c4 100644 --- a/llvm/test/Transforms/GVN/PRE/pre-loop-load.ll +++ b/llvm/test/Transforms/GVN/PRE/pre-loop-load.ll @@ -7,22 +7,25 @@ declare void @may_free_memory() declare i32 @personality_function() -; TODO: We can PRE the load from gc-managed memory away from the hot path. +; We can PRE the load from gc-managed memory away from the hot path. define i32 @test_load_on_cold_path_gc(i32 addrspace(1)* %p) gc "statepoint-example" personality i32 ()* @"personality_function" { ; CHECK-LABEL: @test_load_on_cold_path_gc( ; CHECK-NEXT: entry: +; CHECK-NEXT: [[X_PRE1:%.*]] = load i32, i32 addrspace(1)* [[P:%.*]], align 4 ; CHECK-NEXT: br label [[LOOP:%.*]] ; CHECK: loop: -; CHECK-NEXT: [[IV:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[BACKEDGE:%.*]] ] -; CHECK-NEXT: [[X:%.*]] = load i32, i32 addrspace(1)* [[P:%.*]], align 4 +; CHECK-NEXT: [[X:%.*]] = phi i32 [ [[X_PRE1]], [[ENTRY:%.*]] ], [ [[X2:%.*]], [[BACKEDGE:%.*]] ] +; CHECK-NEXT: [[IV:%.*]] = phi i32 [ 0, [[ENTRY]] ], [ [[IV_NEXT:%.*]], [[BACKEDGE]] ] ; CHECK-NEXT: [[COND:%.*]] = icmp ne i32 [[X]], 0 ; CHECK-NEXT: br i1 [[COND]], label [[HOT_PATH:%.*]], label [[COLD_PATH:%.*]] ; CHECK: hot_path: ; CHECK-NEXT: br label [[BACKEDGE]] ; CHECK: cold_path: ; CHECK-NEXT: call void @may_free_memory() +; CHECK-NEXT: [[X_PRE:%.*]] = load i32, i32 addrspace(1)* [[P]], align 4 ; CHECK-NEXT: br label [[BACKEDGE]] ; CHECK: backedge: +; CHECK-NEXT: [[X2]] = phi i32 [ [[X_PRE]], [[COLD_PATH]] ], [ [[X]], [[HOT_PATH]] ] ; CHECK-NEXT: [[IV_NEXT]] = add i32 [[IV]], [[X]] ; CHECK-NEXT: [[LOOP_COND:%.*]] = icmp ult i32 [[IV_NEXT]], 1000 ; CHECK-NEXT: br i1 [[LOOP_COND]], label [[LOOP]], label [[EXIT:%.*]] </cut>

4 years, 2 months

Re: Buildbot failure in LLVM Buildbot on clang-armv7-quick

by Philip Reames

This bot failure appears to be unrelated to the fingered change. From the commit log, I'd guess that 9eaf0d120 by Joel E. Denny <jdenny.ornl(a)gmail.com> was the triggering change, but that's not in the blame list. Joel, FYI. Linaro folks, as bot owner, you should investigate why the blame list is wrong. JFYI, this is not the only bot failing with the wrong blame list, so it might be a common problem. Philip On 6/25/21 10:43 AM, llvm.buildmaster(a)lab.llvm.org wrote: > The Buildbot has detected a failed build on builder clang-armv7-quick while building llvm. > > Full details are available at: > https://lab.llvm.org/buildbot#builders/171/builds/113 > > Worker for this Build: linaro-clang-armv7-quick > Blamelist: > Philip Reames <listmail(a)philipreames.com> > > BUILD FAILED: failed 48104 expected passes 1 unexpected failures 72 expected failures Unexpected test result output SKIPPED 26089 unsupported tests (failure) > > Step 5 (ninja check 1) failure: 48104 expected passes 1 unexpected failures 72 expected failures Unexpected test result output SKIPPED 26089 unsupported tests (failure) > ******************** TEST 'Clang :: utils/update_cc_test_checks/check-globals.test' FAILED ******************** > Script: > -- > : 'RUN: at line 1'; rm -rf /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp && mkdir /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp > : 'RUN: at line 5'; cp /home/tcwg-buildslave/worker/clang-armv7-quick/llvm/clang/test/utils/update_cc_test_checks/Inputs/check-globals.c /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp/norm.c > : 'RUN: at line 6'; /usr/bin/python3.6 /home/tcwg-buildslave/worker/clang-armv7-quick/llvm/llvm/utils/update_cc_test_checks.py --clang /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/bin/clang --opt /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/bin/opt /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp/norm.c --check-globals > : 'RUN: at line 7'; /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/bin/FileCheck /home/tcwg-buildslave/worker/clang-armv7-quick/llvm/clang/test/utils/update_cc_test_checks/check-globals.test --input-file=/home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp/norm.c --match-full-lines -strict-whitespace -check-prefixes=BOTH,NRM > : 'RUN: at line 10'; cp /home/tcwg-buildslave/worker/clang-armv7-quick/llvm/clang/test/utils/update_cc_test_checks/Inputs/check-globals.c /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp/igf.c > : 'RUN: at line 11'; /usr/bin/python3.6 /home/tcwg-buildslave/worker/clang-armv7-quick/llvm/llvm/utils/update_cc_test_checks.py --clang /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/bin/clang --opt /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/bin/opt /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp/igf.c --check-globals --include-generated-funcs > : 'RUN: at line 12'; /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/bin/FileCheck /home/tcwg-buildslave/worker/clang-armv7-quick/llvm/clang/test/utils/update_cc_test_checks/check-globals.test --input-file=/home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp/igf.c --match-full-lines -strict-whitespace -check-prefixes=BOTH,IGF > : 'RUN: at line 17'; cp /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp/norm.c /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp/norm-again.c > : 'RUN: at line 18'; /usr/bin/python3.6 /home/tcwg-buildslave/worker/clang-armv7-quick/llvm/llvm/utils/update_cc_test_checks.py --clang /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/bin/clang --opt /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/bin/opt /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp/norm-again.c --check-globals > : 'RUN: at line 19'; diff -u /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp/norm.c /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp/norm-again.c > : 'RUN: at line 20'; rm /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp/norm-again.c > : 'RUN: at line 22'; cp /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp/igf.c /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp/igf-again.c > : 'RUN: at line 23'; /usr/bin/python3.6 /home/tcwg-buildslave/worker/clang-armv7-quick/llvm/llvm/utils/update_cc_test_checks.py --clang /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/bin/clang --opt /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/bin/opt /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp/igf-again.c --check-globals --include-generated-funcs > : 'RUN: at line 25'; diff -u /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp/igf.c /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp/igf-again.c > : 'RUN: at line 26'; rm /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp/igf-again.c > : 'RUN: at line 31'; cp /home/tcwg-buildslave/worker/clang-armv7-quick/llvm/clang/test/utils/update_cc_test_checks/Inputs/lit.cfg.example /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp/lit.cfg > : 'RUN: at line 33'; /usr/bin/python3.6 /home/tcwg-buildslave/worker/clang-armv7-quick/llvm/llvm/utils/lit/lit.py -Dclang_obj_root=/home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang -j1 -vv /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp > : 'RUN: at line 35'; /usr/bin/python3.6 /home/tcwg-buildslave/worker/clang-armv7-quick/llvm/llvm/utils/lit/lit.py -Dclang_obj_root=/home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang -j1 -vv /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp 2>&1 | /home/tcwg-buildslave/worker/clang-armv7-quick/stage1/bin/FileCheck -check-prefix=LIT-RUN /home/tcwg-buildslave/worker/clang-armv7-quick/llvm/clang/test/utils/update_cc_test_checks/check-globals.test > -- > Exit Code: 1 > > Command Output (stdout): > -- > $ ":" "RUN: at line 1" > $ "rm" "-rf" "/home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp" > $ "mkdir" "/home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp" > $ ":" "RUN: at line 5" > $ "cp" "/home/tcwg-buildslave/worker/clang-armv7-quick/llvm/clang/test/utils/update_cc_test_checks/Inputs/check-globals.c" "/home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp/norm.c" > $ ":" "RUN: at line 6" > $ "/usr/bin/python3.6" "/home/tcwg-buildslave/worker/clang-armv7-quick/llvm/llvm/utils/update_cc_test_checks.py" "--clang" "/home/tcwg-buildslave/worker/clang-armv7-quick/stage1/bin/clang" "--opt" "/home/tcwg-buildslave/worker/clang-armv7-quick/stage1/bin/opt" "/home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp/norm.c" "--check-globals" > # command stderr: > NOTE: Executing non-FileChecked RUN line: true > > $ ":" "RUN: at line 7" > $ "/home/tcwg-buildslave/worker/clang-armv7-quick/stage1/bin/FileCheck" "/home/tcwg-buildslave/worker/clang-armv7-quick/llvm/clang/test/utils/update_cc_test_checks/check-globals.test" "--input-file=/home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp/norm.c" "--match-full-lines" "-strict-whitespace" "-check-prefixes=BOTH,NRM" > $ ":" "RUN: at line 10" > $ "cp" "/home/tcwg-buildslave/worker/clang-armv7-quick/llvm/clang/test/utils/update_cc_test_checks/Inputs/check-globals.c" "/home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp/igf.c" > $ ":" "RUN: at line 11" > $ "/usr/bin/python3.6" "/home/tcwg-buildslave/worker/clang-armv7-quick/llvm/llvm/utils/update_cc_test_checks.py" "--clang" "/home/tcwg-buildslave/worker/clang-armv7-quick/stage1/bin/clang" "--opt" "/home/tcwg-buildslave/worker/clang-armv7-quick/stage1/bin/opt" "/home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp/igf.c" "--check-globals" "--include-generated-funcs" > # command stderr: > NOTE: Executing non-FileChecked RUN line: true > > $ ":" "RUN: at line 12" > $ "/home/tcwg-buildslave/worker/clang-armv7-quick/stage1/bin/FileCheck" "/home/tcwg-buildslave/worker/clang-armv7-quick/llvm/clang/test/utils/update_cc_test_checks/check-globals.test" "--input-file=/home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp/igf.c" "--match-full-lines" "-strict-whitespace" "-check-prefixes=BOTH,IGF" > $ ":" "RUN: at line 17" > $ "cp" "/home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp/norm.c" "/home/tcwg-buildslave/worker/clang-armv7-quick/stage1/tools/clang/test/utils/update_cc_test_checks/Output/check-globals.test.tmp/norm-again.c" > $ ":" "RUN: at line 18" > ... > > Sincerely, > LLVM Buildbot >

4 years, 2 months

Re: [CI-NOTIFY]: TCWG Bisect tcwg_bmk_tk1/gnu-release-arm-spec2k6-Os_LTO - Build # 31 - Fixed!

by Maxim Kuvyrkov

I’m running historical performance experiments, and this commit from 2019 showed up on my radar. Just in case someone is interested in running Fortran code on memory-constrained M-profile cores ... It appears that Janne’s patch increases code-size of 437.leslie3d by around 2% on 32-bit ARM (well, Thumb2, to be precise). It may be interesting to check what’s going on, since AArch64 is not affected. One possibility is that before this patch all literal-pool entries for error messages were shared, and with variation of error messages all of them became different entries, thus increasing code size. -- Maxim Kuvyrkov https://www.linaro.org > On 28 Jun 2021, at 00:54, ci_notify(a)linaro.org wrote: > > Successfully identified regression in *gcc* in CI configuration tcwg_bmk_gnu_tk1/gnu-release-arm-spec2k6-Os_LTO. So far, this commit has regressed CI configurations: > - tcwg_bmk_gnu_tk1/gnu-release-arm-spec2k6-Os_LTO > - tcwg_bmk_tk1/gnu-release-arm-spec2k6-Os > > Culprit: > <cut> > commit d74a8b0579edd0c42921eccc45ab986d24f2fef0 > Author: Janne Blomqvist <jb(a)gcc.gnu.org> > > PR fortran/68401 Improve allocation error message > </cut> > > Results regressed to (for first_bad == d74a8b0579edd0c42921eccc45ab986d24f2fef0) > # reset_artifacts: > -10 > # build_abe binutils: > -9 > # build_abe stage1 -- --set gcc_override_configure=--with-mode=thumb --set gcc_override_configure=--disable-libsanitizer: > -8 > # build_abe linux: > -7 > # build_abe glibc: > -6 > # build_abe stage2 -- --set gcc_override_configure=--with-mode=thumb --set gcc_override_configure=--disable-libsanitizer: > -5 > # true: > 0 > # benchmark -Os_LTO_mthumb -- artifacts/build-d74a8b0579edd0c42921eccc45ab986d24f2fef0/results_id: > 1 > # 437.leslie3d,leslie3d_base.default regressed by 102 > > from (for last_good == 777c02825229f14cf91c6044827ea42a77ded4a3) > # reset_artifacts: > -10 > # build_abe binutils: > -9 > # build_abe stage1 -- --set gcc_override_configure=--with-mode=thumb --set gcc_override_configure=--disable-libsanitizer: > -8 > # build_abe linux: > -7 > # build_abe glibc: > -6 > # build_abe stage2 -- --set gcc_override_configure=--with-mode=thumb --set gcc_override_configure=--disable-libsanitizer: > -5 > # true: > 0 > # benchmark -Os_LTO_mthumb -- artifacts/build-777c02825229f14cf91c6044827ea42a77ded4a3/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-Os_LTO/531 > 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-Os_LTO/539 > 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-d74a8b0579edd0c42921eccc45ab986d24f2fef0 > cd investigate-gcc-d74a8b0579edd0c42921eccc45ab986d24f2fef0 > > 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 d74a8b0579edd0c42921eccc45ab986d24f2fef0 > ../artifacts/test.sh > > # Reproduce last_good build > git checkout --detach 777c02825229f14cf91c6044827ea42a77ded4a3 > ../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 d74a8b0579edd0c42921eccc45ab986d24f2fef0 > Author: Janne Blomqvist <jb(a)gcc.gnu.org> > Date: Sat Aug 17 08:45:37 2019 +0300 > > PR fortran/68401 Improve allocation error message > > Improve the error message that is printed when a memory allocation > fails, by including the location, and the size of the allocation that > failed. > > Regtested on x86_64-pc-linux-gnu. > > gcc/fortran/ChangeLog: > > 2019-08-17 Janne Blomqvist <jb(a)gcc.gnu.org> > > PR fortran/68401 > * trans-decl.c (gfc_build_builtin_function_decls): Replace > os_error with os_error_at decl. > * trans.c (trans_runtime_error_vararg): Modify so the error > function decl is passed directly. > (gfc_trans_runtime_error): Pass correct error function decl. > (gfc_trans_runtime_check): Likewise. > (trans_os_error_at): New function. > (gfc_call_malloc): Use trans_os_error_at. > (gfc_allocate_using_malloc): Likewise. > (gfc_call_realloc): Likewise. > * trans.h (gfor_fndecl_os_error): Replace with gfor_fndecl_os_error_at. > > libgfortran/ChangeLog: > > 2019-08-17 Janne Blomqvist <jb(a)gcc.gnu.org> > > PR fortran/68401 > * gfortran.map: Add GFORTRAN_10 node, add _gfortran_os_error_at > symbol. > * libgfortran.h (os_error_at): New prototype. > * runtime/error.c (os_error_at): New function. > > From-SVN: r274599 > --- > gcc/fortran/ChangeLog | 17 +++++++++++- > gcc/fortran/trans-decl.c | 12 ++++---- > gcc/fortran/trans.c | 68 +++++++++++++++++++++++++++------------------ > gcc/fortran/trans.h | 2 +- > libgfortran/ChangeLog | 8 ++++++ > libgfortran/gfortran.map | 5 ++++ > libgfortran/libgfortran.h | 4 +++ > libgfortran/runtime/error.c | 46 +++++++++++++++++++++++++++++- > 8 files changed, 126 insertions(+), 36 deletions(-) > > diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog > index bab69f3000e..a3b9e6bf486 100644 > --- a/gcc/fortran/ChangeLog > +++ b/gcc/fortran/ChangeLog > @@ -1,3 +1,18 @@ > +2019-08-17 Janne Blomqvist <jb(a)gcc.gnu.org> > + > + PR fortran/68401 > + * trans-decl.c (gfc_build_builtin_function_decls): Replace > + os_error with os_error_at decl. > + * trans.c (trans_runtime_error_vararg): Modify so the error > + function decl is passed directly. > + (gfc_trans_runtime_error): Pass correct error function decl. > + (gfc_trans_runtime_check): Likewise. > + (trans_os_error_at): New function. > + (gfc_call_malloc): Use trans_os_error_at. > + (gfc_allocate_using_malloc): Likewise. > + (gfc_call_realloc): Likewise. > + * trans.h (gfor_fndecl_os_error): Replace with gfor_fndecl_os_error_at. > + > 2019-08-16 Jeff Law <law(a)redhat.com> > Mark Eggleston <mark.eggleston(a)codethink.com> > > @@ -18,7 +33,7 @@ > * trans-common.c (find_equivalence) : New local variable dummy_symbol, > accumulated equivalence attributes from each symbol then check for > conflicts. > - > + > 2019-08-16 Richard Biener <rguenther(a)suse.de> > > * trans-intrinsic.c (gfc_conv_intrinsic_findloc): Initialize > diff --git a/gcc/fortran/trans-decl.c b/gcc/fortran/trans-decl.c > index 2a9b852568a..3c6ab60e9b2 100644 > --- a/gcc/fortran/trans-decl.c > +++ b/gcc/fortran/trans-decl.c > @@ -102,7 +102,7 @@ tree gfor_fndecl_error_stop_string; > tree gfor_fndecl_runtime_error; > tree gfor_fndecl_runtime_error_at; > tree gfor_fndecl_runtime_warning_at; > -tree gfor_fndecl_os_error; > +tree gfor_fndecl_os_error_at; > tree gfor_fndecl_generate_error; > tree gfor_fndecl_set_args; > tree gfor_fndecl_set_fpe; > @@ -3679,11 +3679,11 @@ gfc_build_builtin_function_decls (void) > void_type_node, 3, pvoid_type_node, integer_type_node, > pchar_type_node); > > - gfor_fndecl_os_error = gfc_build_library_function_decl_with_spec ( > - get_identifier (PREFIX("os_error")), ".R", > - void_type_node, 1, pchar_type_node); > - /* The runtime_error function does not return. */ > - TREE_THIS_VOLATILE (gfor_fndecl_os_error) = 1; > + gfor_fndecl_os_error_at = gfc_build_library_function_decl_with_spec ( > + get_identifier (PREFIX("os_error_at")), ".RR", > + void_type_node, -2, pchar_type_node, pchar_type_node); > + /* The os_error_at function does not return. */ > + TREE_THIS_VOLATILE (gfor_fndecl_os_error_at) = 1; > > gfor_fndecl_set_args = gfc_build_library_function_decl ( > get_identifier (PREFIX("set_args")), > diff --git a/gcc/fortran/trans.c b/gcc/fortran/trans.c > index 84511477b39..583f6e3b25b 100644 > --- a/gcc/fortran/trans.c > +++ b/gcc/fortran/trans.c > @@ -447,7 +447,7 @@ gfc_build_array_ref (tree base, tree offset, tree decl, tree vptr) > arguments and a locus. */ > > static tree > -trans_runtime_error_vararg (bool error, locus* where, const char* msgid, > +trans_runtime_error_vararg (tree errorfunc, locus* where, const char* msgid, > va_list ap) > { > stmtblock_t block; > @@ -501,18 +501,13 @@ trans_runtime_error_vararg (bool error, locus* where, const char* msgid, > /* Build the function call to runtime_(warning,error)_at; because of the > variable number of arguments, we can't use build_call_expr_loc dinput_location, > irectly. */ > - if (error) > - fntype = TREE_TYPE (gfor_fndecl_runtime_error_at); > - else > - fntype = TREE_TYPE (gfor_fndecl_runtime_warning_at); > + fntype = TREE_TYPE (errorfunc); > > loc = where ? where->lb->location : input_location; > tmp = fold_build_call_array_loc (loc, TREE_TYPE (fntype), > fold_build1_loc (loc, ADDR_EXPR, > build_pointer_type (fntype), > - error > - ? gfor_fndecl_runtime_error_at > - : gfor_fndecl_runtime_warning_at), > + errorfunc), > nargs + 2, argarray); > gfc_add_expr_to_block (&block, tmp); > > @@ -527,7 +522,10 @@ gfc_trans_runtime_error (bool error, locus* where, const char* msgid, ...) > tree result; > > va_start (ap, msgid); > - result = trans_runtime_error_vararg (error, where, msgid, ap); > + result = trans_runtime_error_vararg (error > + ? gfor_fndecl_runtime_error_at > + : gfor_fndecl_runtime_warning_at, > + where, msgid, ap); > va_end (ap); > return result; > } > @@ -566,8 +564,10 @@ gfc_trans_runtime_check (bool error, bool once, tree cond, stmtblock_t * pblock, > /* The code to generate the error. */ > va_start (ap, msgid); > gfc_add_expr_to_block (&block, > - trans_runtime_error_vararg (error, where, > - msgid, ap)); > + trans_runtime_error_vararg > + (error ? gfor_fndecl_runtime_error_at > + : gfor_fndecl_runtime_warning_at, > + where, msgid, ap)); > va_end (ap); > > if (once) > @@ -595,13 +595,28 @@ gfc_trans_runtime_check (bool error, bool once, tree cond, stmtblock_t * pblock, > } > > > +static tree > +trans_os_error_at (locus* where, const char* msgid, ...) > +{ > + va_list ap; > + tree result; > + > + va_start (ap, msgid); > + result = trans_runtime_error_vararg (gfor_fndecl_os_error_at, > + where, msgid, ap); > + va_end (ap); > + return result; > +} > + > + > + > /* Call malloc to allocate size bytes of memory, with special conditions: > + if size == 0, return a malloced area of size 1, > + if malloc returns NULL, issue a runtime error. */ > tree > gfc_call_malloc (stmtblock_t * block, tree type, tree size) > { > - tree tmp, msg, malloc_result, null_result, res, malloc_tree; > + tree tmp, malloc_result, null_result, res, malloc_tree; > stmtblock_t block2; > > /* Create a variable to hold the result. */ > @@ -626,13 +641,14 @@ gfc_call_malloc (stmtblock_t * block, tree type, tree size) > null_result = fold_build2_loc (input_location, EQ_EXPR, > logical_type_node, res, > build_int_cst (pvoid_type_node, 0)); > - msg = gfc_build_addr_expr (pchar_type_node, > - gfc_build_localized_cstring_const ("Memory allocation failed")); > tmp = fold_build3_loc (input_location, COND_EXPR, void_type_node, > null_result, > - build_call_expr_loc (input_location, > - gfor_fndecl_os_error, 1, msg), > - build_empty_stmt (input_location)); > + trans_os_error_at (NULL, > + "Error allocating %lu bytes", > + fold_convert > + (long_unsigned_type_node, > + size)), > + build_empty_stmt (input_location)); > gfc_add_expr_to_block (&block2, tmp); > } > > @@ -701,11 +717,9 @@ gfc_allocate_using_malloc (stmtblock_t * block, tree pointer, > } > else > { > - /* Here, os_error already implies PRED_NORETURN. */ > - tmp = build_call_expr_loc (input_location, gfor_fndecl_os_error, 1, > - gfc_build_addr_expr (pchar_type_node, > - gfc_build_localized_cstring_const > - ("Allocation would exceed memory limit"))); > + /* Here, os_error_at already implies PRED_NORETURN. */ > + tree lusize = fold_convert (long_unsigned_type_node, size); > + tmp = trans_os_error_at (NULL, "Error allocating %lu bytes", lusize); > gfc_add_expr_to_block (&on_error, tmp); > } > > @@ -1664,7 +1678,7 @@ internal_realloc (void *mem, size_t size) > tree > gfc_call_realloc (stmtblock_t * block, tree mem, tree size) > { > - tree msg, res, nonzero, null_result, tmp; > + tree res, nonzero, null_result, tmp; > tree type = TREE_TYPE (mem); > > /* Only evaluate the size once. */ > @@ -1684,12 +1698,12 @@ gfc_call_realloc (stmtblock_t * block, tree mem, tree size) > build_int_cst (size_type_node, 0)); > null_result = fold_build2_loc (input_location, TRUTH_AND_EXPR, logical_type_node, > null_result, nonzero); > - msg = gfc_build_addr_expr (pchar_type_node, gfc_build_localized_cstring_const > - ("Allocation would exceed memory limit")); > tmp = fold_build3_loc (input_location, COND_EXPR, void_type_node, > null_result, > - build_call_expr_loc (input_location, > - gfor_fndecl_os_error, 1, msg), > + trans_os_error_at (NULL, > + "Error reallocating to %lu bytes", > + fold_convert > + (long_unsigned_type_node, size)), > build_empty_stmt (input_location)); > gfc_add_expr_to_block (block, tmp); > > diff --git a/gcc/fortran/trans.h b/gcc/fortran/trans.h > index a3726e84140..8082b414df1 100644 > --- a/gcc/fortran/trans.h > +++ b/gcc/fortran/trans.h > @@ -803,7 +803,7 @@ extern GTY(()) tree gfor_fndecl_error_stop_string; > extern GTY(()) tree gfor_fndecl_runtime_error; > extern GTY(()) tree gfor_fndecl_runtime_error_at; > extern GTY(()) tree gfor_fndecl_runtime_warning_at; > -extern GTY(()) tree gfor_fndecl_os_error; > +extern GTY(()) tree gfor_fndecl_os_error_at; > extern GTY(()) tree gfor_fndecl_generate_error; > extern GTY(()) tree gfor_fndecl_set_fpe; > extern GTY(()) tree gfor_fndecl_set_options; > diff --git a/libgfortran/ChangeLog b/libgfortran/ChangeLog > index 7a11ca29fd3..23a4c579351 100644 > --- a/libgfortran/ChangeLog > +++ b/libgfortran/ChangeLog > @@ -1,3 +1,11 @@ > +2019-08-17 Janne Blomqvist <jb(a)gcc.gnu.org> > + > + PR fortran/68401 > + * gfortran.map: Add GFORTRAN_10 node, add _gfortran_os_error_at > + symbol. > + * libgfortran.h (os_error_at): New prototype. > + * runtime/error.c (os_error_at): New function. > + > 2019-08-13 Janne Blomqvist <jb(a)gcc.gnu.org> > > PR fortran/91414 > diff --git a/libgfortran/gfortran.map b/libgfortran/gfortran.map > index 2b2243b4fd4..3601bc24414 100644 > --- a/libgfortran/gfortran.map > +++ b/libgfortran/gfortran.map > @@ -1602,3 +1602,8 @@ GFORTRAN_9.2 { > _gfortran_mfindloc1_r10; > _gfortran_sfindloc1_r10; > } GFORTRAN_9; > + > +GFORTRAN_10 { > + global: > + _gfortran_os_error_at; > +} GFORTRAN_9.2; > diff --git a/libgfortran/libgfortran.h b/libgfortran/libgfortran.h > index c0db96f02a8..9f535b12e73 100644 > --- a/libgfortran/libgfortran.h > +++ b/libgfortran/libgfortran.h > @@ -728,6 +728,10 @@ internal_proto(gfc_xtoa); > extern _Noreturn void os_error (const char *); > iexport_proto(os_error); > > +extern _Noreturn void os_error_at (const char *, const char *, ...) > + __attribute__ ((format (gfc_printf, 2, 3))); > +iexport_proto(os_error_at); > + > extern void show_locus (st_parameter_common *); > internal_proto(show_locus); > > diff --git a/libgfortran/runtime/error.c b/libgfortran/runtime/error.c > index 0335a165edc..cbe0642f3f8 100644 > --- a/libgfortran/runtime/error.c > +++ b/libgfortran/runtime/error.c > @@ -403,7 +403,51 @@ os_error (const char *message) > estr_writev (iov, 5); > exit_error (1); > } > -iexport(os_error); > +iexport(os_error); /* TODO, DEPRECATED, ABI: Should not be exported > + anymore when bumping so version. */ > + > + > +/* Improved version of os_error with a printf style format string and > + a locus. */ > + > +void > +os_error_at (const char *where, const char *message, ...) > +{ > + char errmsg[STRERR_MAXSZ]; > + char buffer[STRERR_MAXSZ]; > + struct iovec iov[6]; > + va_list ap; > + recursion_check (); > + int written; > + > + iov[0].iov_base = (char*) where; > + iov[0].iov_len = strlen (where); > + > + iov[1].iov_base = (char*) ": "; > + iov[1].iov_len = strlen (iov[1].iov_base); > + > + va_start (ap, message); > + written = vsnprintf (buffer, STRERR_MAXSZ, message, ap); > + va_end (ap); > + iov[2].iov_base = buffer; > + if (written >= 0) > + iov[2].iov_len = written; > + else > + iov[2].iov_len = 0; > + > + iov[3].iov_base = (char*) ": "; > + iov[3].iov_len = strlen (iov[3].iov_base); > + > + iov[4].iov_base = gf_strerror (errno, errmsg, STRERR_MAXSZ); > + iov[4].iov_len = strlen (iov[4].iov_base); > + > + iov[5].iov_base = (char*) "\n"; > + iov[5].iov_len = 1; > + > + estr_writev (iov, 6); > + exit_error (1); > +} > +iexport(os_error_at); > > > /* void runtime_error()-- These are errors associated with an > </cut>

4 years, 2 months

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

by ci_notify＠linaro.org

Successfully identified regression in *gcc* in CI configuration tcwg_bmk_gnu_tk1/gnu-master-arm-spec2k6-O2_LTO. So far, this commit has regressed CI configurations: - tcwg_bmk_gnu_tk1/gnu-master-arm-spec2k6-O2_LTO Culprit: <cut> commit 32955416d8040b1fa1ba21cd4179b3264e6c5bd6 Author: Richard Biener <rguenther(a)suse.de> Date: Mon May 3 12:07:58 2021 +0200 Improve PHI handling in DSE This improves handling of PHI defs when walking uses in dse_classify_store to track two PHI defs. This happens when there are CFG merges and one PHI feeds into another. If we decide to want more then using a sbitmap for this might be the way to go. 2021-05-03 Richard Biener <rguenther(a)suse.de> * tree-ssa-dse.c (dse_classify_store): Track two PHI defs. * gcc.dg/tree-ssa/ssa-dse-42.c: New testcase. * gcc.dg/pr81192.c: Disable DSE. </cut> Results regressed to (for first_bad == 32955416d8040b1fa1ba21cd4179b3264e6c5bd6) # 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 -O2_LTO_marm -- artifacts/build-32955416d8040b1fa1ba21cd4179b3264e6c5bd6/results_id: 1 # 483.xalancbmk,Xalan_base.default regressed by 103 from (for last_good == ed3c43224cc4e378dbab066122bc63536ccb1276) # 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 -O2_LTO_marm -- artifacts/build-ed3c43224cc4e378dbab066122bc63536ccb1276/results_id: 1 Artifacts of last_good build: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tk1-gnu-master-ar… Results ID of last_good: tk1_32/tcwg_bmk_gnu_tk1/bisect-gnu-master-arm-spec2k6-O2_LTO/458 Artifacts of first_bad build: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tk1-gnu-master-ar… Results ID of first_bad: tk1_32/tcwg_bmk_gnu_tk1/bisect-gnu-master-arm-spec2k6-O2_LTO/480 Build top page/logs: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tk1-gnu-master-ar… Configuration details: Reproduce builds: <cut> mkdir investigate-gcc-32955416d8040b1fa1ba21cd4179b3264e6c5bd6 cd investigate-gcc-32955416d8040b1fa1ba21cd4179b3264e6c5bd6 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-master-ar… --fail curl -o artifacts/manifests/build-parameters.sh https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tk1-gnu-master-ar… --fail curl -o artifacts/test.sh https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tk1-gnu-master-ar… --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 32955416d8040b1fa1ba21cd4179b3264e6c5bd6 ../artifacts/test.sh # Reproduce last_good build git checkout --detach ed3c43224cc4e378dbab066122bc63536ccb1276 ../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-master-ar… Build log: https://ci.linaro.org/job/tcwg_bmk_ci_gnu-bisect-tcwg_bmk_tk1-gnu-master-ar… Full commit (up to 1000 lines): <cut> commit 32955416d8040b1fa1ba21cd4179b3264e6c5bd6 Author: Richard Biener <rguenther(a)suse.de> Date: Mon May 3 12:07:58 2021 +0200 Improve PHI handling in DSE This improves handling of PHI defs when walking uses in dse_classify_store to track two PHI defs. This happens when there are CFG merges and one PHI feeds into another. If we decide to want more then using a sbitmap for this might be the way to go. 2021-05-03 Richard Biener <rguenther(a)suse.de> * tree-ssa-dse.c (dse_classify_store): Track two PHI defs. * gcc.dg/tree-ssa/ssa-dse-42.c: New testcase. * gcc.dg/pr81192.c: Disable DSE. --- gcc/testsuite/gcc.dg/pr81192.c | 4 +++- gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-42.c | 20 ++++++++++++++++++++ gcc/tree-ssa-dse.c | 23 ++++++++++++++--------- 3 files changed, 37 insertions(+), 10 deletions(-) diff --git a/gcc/testsuite/gcc.dg/pr81192.c b/gcc/testsuite/gcc.dg/pr81192.c index 71bbc13a0e9..6cab6056558 100644 --- a/gcc/testsuite/gcc.dg/pr81192.c +++ b/gcc/testsuite/gcc.dg/pr81192.c @@ -1,4 +1,4 @@ -/* { dg-options "-Os -fdump-tree-pre-details -fdisable-tree-evrp" } */ +/* { dg-options "-Os -fdump-tree-pre-details -fdisable-tree-evrp -fno-tree-dse" } */ /* Disable tree-evrp because the new version of evrp sees <bb 3> : @@ -16,6 +16,8 @@ produces # iftmp.2_12 = PHI <2147483647(3), iftmp.2_11(4)> which causes the situation being tested to dissapear before we get to PRE. */ +/* Likewise disable DSE which also elides the tail merging "opportunity". */ + #if __SIZEOF_INT__ == 2 #define unsigned __UINT32_TYPE__ #define int __INT32_TYPE__ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-42.c b/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-42.c new file mode 100644 index 00000000000..34108c83828 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-42.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-options "-O -fdump-tree-dse1" } */ + +int a[2]; +void foo(int i, int k, int j) +{ + a[0] = i; + if (k) + a[0] = a[i] + k; + else + { + if (j) + a[1] = 1; + a[0] = a[i] + 3; + } + a[0] = 0; +} + +/* The last stores to a[0] and a[1] remain. */ +/* { dg-final { scan-tree-dump-times " = " 2 "dse1" } } */ diff --git a/gcc/tree-ssa-dse.c b/gcc/tree-ssa-dse.c index e0a944c704a..dfa6d314727 100644 --- a/gcc/tree-ssa-dse.c +++ b/gcc/tree-ssa-dse.c @@ -799,7 +799,8 @@ dse_classify_store (ao_ref *ref, gimple *stmt, return DSE_STORE_LIVE; auto_vec<gimple *, 10> defs; - gimple *phi_def = NULL; + gimple *first_phi_def = NULL; + gimple *last_phi_def = NULL; FOR_EACH_IMM_USE_STMT (use_stmt, ui, defvar) { /* Limit stmt walking. */ @@ -825,7 +826,9 @@ dse_classify_store (ao_ref *ref, gimple *stmt, SSA_NAME_VERSION (PHI_RESULT (use_stmt)))) { defs.safe_push (use_stmt); - phi_def = use_stmt; + if (!first_phi_def) + first_phi_def = use_stmt; + last_phi_def = use_stmt; } } /* If the statement is a use the store is not dead. */ @@ -889,6 +892,8 @@ dse_classify_store (ao_ref *ref, gimple *stmt, gimple *def = defs[i]; gimple *use_stmt; use_operand_p use_p; + tree vdef = (gimple_code (def) == GIMPLE_PHI + ? gimple_phi_result (def) : gimple_vdef (def)); /* If the path to check starts with a kill we do not need to process it further. ??? With byte tracking we need only kill the bytes currently @@ -901,8 +906,7 @@ dse_classify_store (ao_ref *ref, gimple *stmt, } /* If the path ends here we do not need to process it further. This for example happens with calls to noreturn functions. */ - else if (gimple_code (def) != GIMPLE_PHI - && has_zero_uses (gimple_vdef (def))) + else if (has_zero_uses (vdef)) { /* But if the store is to global memory it is definitely not dead. */ @@ -912,12 +916,13 @@ dse_classify_store (ao_ref *ref, gimple *stmt, } /* In addition to kills we can remove defs whose only use is another def in defs. That can only ever be PHIs of which - we track a single for simplicity reasons (we fail for multiple - PHIs anyways). We can also ignore defs that feed only into + we track two for simplicity reasons, the first and last in + {first,last}_phi_def (we fail for multiple PHIs anyways). + We can also ignore defs that feed only into already visited PHIs. */ - else if (gimple_code (def) != GIMPLE_PHI - && single_imm_use (gimple_vdef (def), &use_p, &use_stmt) - && (use_stmt == phi_def + else if (single_imm_use (vdef, &use_p, &use_stmt) + && (use_stmt == first_phi_def + || use_stmt == last_phi_def || (gimple_code (use_stmt) == GIMPLE_PHI && bitmap_bit_p (visited, SSA_NAME_VERSION </cut>

4 years, 2 months

[ACTIVITY] 14 - 25 June 2021

by Prathamesh Kulkarni

== This Week == * PR97906 (missed lowering to vac) - Committed patch. * PR66791 (replace builtins with vector extensions in neon intrinsics): - Committed patch for vceq - Submitted patch for vca - Submitted patch for vdup * PR98435 (missed opt in expanding vector constructor) - Patch conditionally approved by Kyrill == Next Week == - PR98435: Address changes and commit the fix. - PR66791: Continue with intrinsics.

4 years, 2 months

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

by ci_notify＠linaro.org

Successfully identified regression in *gcc* in CI configuration tcwg_bmk_gnu_tx1/gnu-master-aarch64-spec2k6-O2. So far, this commit has regressed CI configurations: - tcwg_bmk_gnu_tx1/gnu-master-aarch64-spec2k6-O2 Culprit: <cut> commit 87a7d10c2e9ec34a276e6acb5d2282a35b9cfafb Author: GCC Administrator <gccadmin(a)gcc.gnu.org> Date: Sat May 15 00:16:27 2021 +0000 Daily bump. </cut> Results regressed to (for first_bad == 87a7d10c2e9ec34a276e6acb5d2282a35b9cfafb) # 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 -- artifacts/build-87a7d10c2e9ec34a276e6acb5d2282a35b9cfafb/results_id: 1 # 459.GemsFDTD,GemsFDTD_base.default regressed by 103 from (for last_good == 0e3702f8daeec5897982d185650b78a5c1c53c25) # 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 -- artifacts/build-0e3702f8daeec5897982d185650b78a5c1c53c25/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/533 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/530 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-87a7d10c2e9ec34a276e6acb5d2282a35b9cfafb cd investigate-gcc-87a7d10c2e9ec34a276e6acb5d2282a35b9cfafb 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 87a7d10c2e9ec34a276e6acb5d2282a35b9cfafb ../artifacts/test.sh # Reproduce last_good build git checkout --detach 0e3702f8daeec5897982d185650b78a5c1c53c25 ../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 87a7d10c2e9ec34a276e6acb5d2282a35b9cfafb Author: GCC Administrator <gccadmin(a)gcc.gnu.org> Date: Sat May 15 00:16:27 2021 +0000 Daily bump. --- contrib/ChangeLog | 14 +++++++++++ gcc/ChangeLog | 55 ++++++++++++++++++++++++++++++++++++++++++++ gcc/DATESTAMP | 2 +- gcc/ada/ChangeLog | 6 +++++ gcc/c-family/ChangeLog | 4 ++++ gcc/cp/ChangeLog | 21 +++++++++++++++++ gcc/fortran/ChangeLog | 25 ++++++++++++++++++++ gcc/testsuite/ChangeLog | 42 +++++++++++++++++++++++++++++++++ libgomp/ChangeLog | 4 ++++ libphobos/ChangeLog | 5 ++++ maintainer-scripts/ChangeLog | 4 ++++ 11 files changed, 181 insertions(+), 1 deletion(-) diff --git a/contrib/ChangeLog b/contrib/ChangeLog index f7c1e867879..8e393b7ed72 100644 --- a/contrib/ChangeLog +++ b/contrib/ChangeLog @@ -1,3 +1,17 @@ +2021-05-14 Martin Liska <mliska(a)suse.cz> + + * download_prerequisites: Use version 4.1.0. + +2021-05-14 Jakub Jelinek <jakub(a)redhat.com> + + * gcc-changelog/git_update_version.py: Remove releases/gcc-8 from + active_refs. + +2021-05-14 Martin Liska <mliska(a)suse.cz> + + * gcc-changelog/git_commit.py: Support Co-Authored-By before + a first ChangeLog entry. + 2021-05-13 Martin Liska <mliska(a)suse.cz> * mklog.py: Put PR entries before all ChangeLog entries diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 3b937d4d66f..dfa8ae2824f 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,58 @@ +2021-05-14 Jason Merrill <jason(a)redhat.com> + + * intl.h: Add comments. + +2021-05-14 Kyrylo Tkachov <kyrylo.tkachov(a)arm.com> + + * config/aarch64/aarch64-simd.md + (aarch64_sqdml<SBINQOPS:as>l2_lane<mode>_internal): Split into... + (aarch64_sqdmlsl2_lane<mode>_internal): ... This... + (aarch64_sqdmlal2_lane<mode>_internal): ... And this. + (aarch64_sqdml<SBINQOPS:as>l2_laneq<mode>_internal): Split into ... + (aarch64_sqdmlsl2_laneq<mode>_internal): ... This... + (aarch64_sqdmlal2_laneq<mode>_internal): ... And this. + (aarch64_sqdml<SBINQOPS:as>l2_n<mode>_internal): Split into... + (aarch64_sqdmlsl2_n<mode>_internal): ... This... + (aarch64_sqdmlal2_n<mode>_internal): ... And this. + +2021-05-14 Prathamesh Kulkarni <prathamesh.kulkarni(a)linaro.org> + + PR target/66791 + * config/arm/arm_neon.h (vtst_s8): Replace call to vtst builtin with it's + boolean logic equivalent. + (vtst_s16): Likewise. + (vtst_s32): Likewise. + (vtst_u8): Likewise. + (vtst_u16): Likewise. + (vtst_u32): Likewise. + (vtst_p8): Likewise. + (vtst_p16): Likewise. + (vtstq_s8): Likewise. + (vtstq_s16): Likewise. + (vtstq_s32): Likewise. + (vtstq_u8): Likewise. + (vtstq_u16): Likewise. + (vtstq_u32): Likewise. + (vtstq_p8): Likewise. + (vtstq_p16): Likewise. + * config/arm/arm_neon_builtins.def: Remove entry for vtst. + * config/arm/neon.md (neon_vtst<mode>): Remove pattern. + +2021-05-14 Kyrylo Tkachov <kyrylo.tkachov(a)arm.com> + + * config/aarch64/aarch64-simd.md (aarch64_sqdmlal2<mode>): Merge into... + (aarch64_sqdml<SBINQOPS:as>l2<mode>): ... This. + (aarch64_sqdmlsl2<mode>): Delete. + (aarch64_sqdmlal2_lane<mode>): Merge this... + (aarch64_sqdmlsl2_lane<mode>): ... And this... + (aarch64_sqdml<SBINQOPS:as>l2_lane<mode>): ... Into this. + (aarch64_sqdmlal2_laneq<mode>): Merge this... + (aarch64_sqdmlsl2_laneq<mode>): ... And this... + (aarch64_sqdml<SBINQOPS:as>l2_laneq<mode>): ... Into this. + (aarch64_sqdmlal2_n<mode>): Merge this... + (aarch64_sqdmlsl2_n<mode>): ... And this... + (aarch64_sqdml<SBINQOPS:as>l2_n<mode>): ... Into this. + 2021-05-13 Martin Sebor <msebor(a)redhat.com> PR middle-end/100574 diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP index 552c3b209c0..40eb1cad583 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20210514 +20210515 diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog index 2279e46b775..514682006a7 100644 --- a/gcc/ada/ChangeLog +++ b/gcc/ada/ChangeLog @@ -1,3 +1,9 @@ +2021-05-14 Martin Liska <mliska(a)suse.cz> + + * doc/Makefile: Add gnat-style target. + * doc/share/conf.py: Likewise. + * doc/gnat-style.rst: New file. + 2021-05-12 Bob Duff <duff(a)adacore.com> PR ada/100564 diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog index d33ad4a4c57..7fc64a513d5 100644 --- a/gcc/c-family/ChangeLog +++ b/gcc/c-family/ChangeLog @@ -1,3 +1,7 @@ +2021-05-14 Martin Liska <mliska(a)suse.cz> + + * c.opt: Add Warning keyword for 2 options. + 2021-05-13 Martin Liska <mliska(a)suse.cz> PR middle-end/100504 diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 5a8a650d3d7..48425b9dc67 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,24 @@ +2021-05-14 Jason Merrill <jason(a)redhat.com> + + PR c++/95870 + * pt.c (enclosing_instantiation_of): Just compare + DECL_SOURCE_LOCATION. + (regenerate_decl_from_template): Copy DECL_SOURCE_LOCATION. + +2021-05-14 Marek Polacek <polacek(a)redhat.com> + Jason Merrill <jason(a)redhat.com> + + PR c++/99032 + * cp-tree.h (any_non_type_attribute_p): Declare. + * decl.c (grokdeclarator): Diagnose when an attribute appertains to + a friend declaration that is not a definition. + * decl2.c (any_non_type_attribute_p): New. + * parser.c (cp_parser_decl_specifier_seq): Diagnose standard attributes + in the middle of decl-specifiers. + (cp_parser_elaborated_type_specifier): Diagnose when an attribute + appertains to a friend declaration that is not a definition. + (cp_parser_member_declaration): Likewise. + 2021-05-12 Marek Polacek <polacek(a)redhat.com> * pt.c (tsubst_copy_and_build): Add warn_int_in_bool_context diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog index 71cc3d86491..781dedd8220 100644 --- a/gcc/fortran/ChangeLog +++ b/gcc/fortran/ChangeLog @@ -1,3 +1,28 @@ +2021-05-14 Tobias Burnus <tobias(a)codesourcery.com> + + * dump-parse-tree.c (show_omp_node, show_code_node): Handle + EXEC_OMP_PARALLEL_MASTER. + * frontend-passes.c (gfc_code_walker): Likewise. + * gfortran.h (enum gfc_statement): Add ST_OMP_PARALLEL_MASTER and + ST_OMP_END_PARALLEL_MASTER. + (enum gfc_exec_op): Add EXEC_OMP_PARALLEL_MASTER.. + * match.h (gfc_match_omp_parallel_master): Handle it. + * openmp.c (gfc_match_omp_parallel_master, resolve_omp_clauses, + omp_code_to_statement, gfc_resolve_omp_directive): Likewise. + * parse.c (decode_omp_directive, case_exec_markers, + gfc_ascii_statement, parse_omp_structured_block, + parse_executable): Likewise. + * resolve.c (gfc_resolve_blocks, gfc_resolve_code): Likewise. + * st.c (gfc_free_statement): Likewise. + * trans-openmp.c (gfc_trans_omp_parallel_master, + gfc_trans_omp_workshare, gfc_trans_omp_directive): Likewise. + * trans.c (trans_code): Likewise. + +2021-05-14 Tobias Burnus <tobias(a)codesourcery.com> + + * resolve.c (resolve_symbol): Handle implicit SAVE of main-program + for vars in 'omp threadprivate' and 'omp declare target'. + 2021-05-10 Martin Liska <mliska(a)suse.cz> * decl.c (variable_decl): Use startswith diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 9dfab7b873d..564795068b0 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,45 @@ +2021-05-14 Tobias Burnus <tobias(a)codesourcery.com> + + * gfortran.dg/gomp/parallel-master-1.f90: New test. + * gfortran.dg/gomp/parallel-master-2.f90: New test. + +2021-05-14 Tobias Burnus <tobias(a)codesourcery.com> + + * gfortran.dg/gomp/implicit-save.f90: New test. + +2021-05-14 Jakub Jelinek <jakub(a)redhat.com> + + PR c++/95226 + * g++.dg/cpp1y/pr95226.C: New test. + +2021-05-14 Jakub Jelinek <jakub(a)redhat.com> + + PR c++/94616 + * g++.dg/cpp0x/pr94616.C: New test. + +2021-05-14 Jakub Jelinek <jakub(a)redhat.com> + + PR c++/90019 + * g++.dg/cpp0x/sfinae68.C: New test. + +2021-05-14 Jakub Jelinek <jakub(a)redhat.com> + + * g++.dg/cpp1y/pr88872.C: New test. + +2021-05-14 Michael de Lang <kingoipo(a)gmail.com> + + * g++.dg/tsan/pthread_cond_clockwait.C: New test. + +2021-05-14 Marek Polacek <polacek(a)redhat.com> + Jason Merrill <jason(a)redhat.com> + + PR c++/99032 + * g++.dg/cpp0x/friend7.C: New test. + * g++.dg/cpp0x/gen-attrs-4.C: Add dg-error. + * g++.dg/cpp0x/gen-attrs-39-1.C: Likewise. + * g++.dg/cpp0x/gen-attrs-74.C: New test. + * g++.dg/ext/attrib63.C: New test. + 2021-05-13 Martin Sebor <msebor(a)redhat.com> PR tree-optimization/93100 diff --git a/libgomp/ChangeLog b/libgomp/ChangeLog index 1daf0c82f2c..424c574dce8 100644 --- a/libgomp/ChangeLog +++ b/libgomp/ChangeLog @@ -1,3 +1,7 @@ +2021-05-14 Tobias Burnus <tobias(a)codesourcery.com> + + * testsuite/libgomp.fortran/parallel-master.f90: New test. + 2021-05-13 Martin Liska <mliska(a)suse.cz> PR testsuite/100569 diff --git a/libphobos/ChangeLog b/libphobos/ChangeLog index 7574416b9aa..7b57d92f64a 100644 --- a/libphobos/ChangeLog +++ b/libphobos/ChangeLog @@ -1,3 +1,8 @@ +2021-05-14 Bernd Edlinger <bernd.edlinger(a)hotmail.de> + + * src/std/process.d (unittest): Remove tmpname on exit. + * src/MERGE: Merge upstream phobos 63f4caa90. + 2021-05-13 Iain Buclaw <ibuclaw(a)gdcproject.org> * libdruntime/MERGE: Merge upstream druntime 98c6ff0c. diff --git a/maintainer-scripts/ChangeLog b/maintainer-scripts/ChangeLog index ab18cfd905d..8f306552396 100644 --- a/maintainer-scripts/ChangeLog +++ b/maintainer-scripts/ChangeLog @@ -1,3 +1,7 @@ +2021-05-14 Jakub Jelinek <jakub(a)redhat.com> + + * crontab: Stop doing gcc-8 snapshots. + 2021-04-20 Jakub Jelinek <jakub(a)redhat.com> * crontab: Snapshots from trunk are now GCC 12 related. </cut>

4 years, 2 months

[CI-NOTIFY]: TCWG Bisect tcwg_bmk_tx1/gnu-master-aarch64-spec2k6-O2_LTO - Build # 18 - 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 f79f2065817e080f65f3c3a2fee966f5a97f1746 Author: Florian Weimer <fweimer(a)redhat.com> Date: Wed Apr 21 19:49:50 2021 +0200 nptl: Move legacy unwinding implementation into libc It is still used internally. Since unwinding is now available unconditionally, avoid indirect calls through function pointers loaded from the stack by inlining the non-cancellation cleanup code. This avoids a regression in security hardening. The out-of-line __libc_cleanup_routine implementation is no longer needed because the inline definition is now static __always_inline. Reviewed-by: Adhemerval Zanella <adhemerval.zanella(a)linaro.org> </cut> Results regressed to (for first_bad == f79f2065817e080f65f3c3a2fee966f5a97f1746) # 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-f79f2065817e080f65f3c3a2fee966f5a97f1746/results_id: 1 # 410.bwaves,bwaves_base.default regressed by 104 from (for last_good == 5715c29e91076800418833f2196f2082f439da75) # 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-5715c29e91076800418833f2196f2082f439da75/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/461 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/470 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-f79f2065817e080f65f3c3a2fee966f5a97f1746 cd investigate-glibc-f79f2065817e080f65f3c3a2fee966f5a97f1746 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 f79f2065817e080f65f3c3a2fee966f5a97f1746 ../artifacts/test.sh # Reproduce last_good build git checkout --detach 5715c29e91076800418833f2196f2082f439da75 ../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 f79f2065817e080f65f3c3a2fee966f5a97f1746 Author: Florian Weimer <fweimer(a)redhat.com> Date: Wed Apr 21 19:49:50 2021 +0200 nptl: Move legacy unwinding implementation into libc It is still used internally. Since unwinding is now available unconditionally, avoid indirect calls through function pointers loaded from the stack by inlining the non-cancellation cleanup code. This avoids a regression in security hardening. The out-of-line __libc_cleanup_routine implementation is no longer needed because the inline definition is now static __always_inline. Reviewed-by: Adhemerval Zanella <adhemerval.zanella(a)linaro.org> --- nptl/Versions | 2 ++ nptl/cleanup_defer_compat.c | 56 ++--------------------------------- nptl/libc-cleanup.c | 64 ++++++++++++++++++++++++++++++++++++++-- nptl/nptl-init.c | 2 -- sysdeps/nptl/libc-lock.h | 59 ++++++++++++++++++------------------ sysdeps/nptl/libc-lockP.h | 26 +--------------- sysdeps/nptl/pthread-functions.h | 4 --- 7 files changed, 97 insertions(+), 116 deletions(-) diff --git a/nptl/Versions b/nptl/Versions index 60202b4969..2e5a964b11 100644 --- a/nptl/Versions +++ b/nptl/Versions @@ -87,6 +87,8 @@ libc { __futex_abstimed_wait64; __futex_abstimed_wait_cancelable64; __libc_alloca_cutoff; + __libc_cleanup_pop_restore; + __libc_cleanup_push_defer; __libc_dl_error_tsd; __libc_pthread_init; __lll_clocklock_elision; diff --git a/nptl/cleanup_defer_compat.c b/nptl/cleanup_defer_compat.c index 49ef53ea60..1957318208 100644 --- a/nptl/cleanup_defer_compat.c +++ b/nptl/cleanup_defer_compat.c @@ -17,41 +17,15 @@ <https://www.gnu.org/licenses/>. */ #include "pthreadP.h" - +#include <libc-lock.h> void _pthread_cleanup_push_defer (struct _pthread_cleanup_buffer *buffer, void (*routine) (void *), void *arg) { - struct pthread *self = THREAD_SELF; - buffer->__routine = routine; buffer->__arg = arg; - buffer->__prev = THREAD_GETMEM (self, cleanup); - - int cancelhandling = THREAD_GETMEM (self, cancelhandling); - - /* Disable asynchronous cancellation for now. */ - if (__glibc_unlikely (cancelhandling & CANCELTYPE_BITMASK)) - while (1) - { - int curval = THREAD_ATOMIC_CMPXCHG_VAL (self, cancelhandling, - cancelhandling - & ~CANCELTYPE_BITMASK, - cancelhandling); - if (__glibc_likely (curval == cancelhandling)) - /* Successfully replaced the value. */ - break; - - /* Prepare for the next round. */ - cancelhandling = curval; - } - - buffer->__canceltype = (cancelhandling & CANCELTYPE_BITMASK - ? PTHREAD_CANCEL_ASYNCHRONOUS - : PTHREAD_CANCEL_DEFERRED); - - THREAD_SETMEM (self, cleanup, buffer); + __libc_cleanup_push_defer (buffer); } strong_alias (_pthread_cleanup_push_defer, __pthread_cleanup_push_defer) @@ -60,31 +34,7 @@ void _pthread_cleanup_pop_restore (struct _pthread_cleanup_buffer *buffer, int execute) { - struct pthread *self = THREAD_SELF; - - THREAD_SETMEM (self, cleanup, buffer->__prev); - - int cancelhandling; - if (__builtin_expect (buffer->__canceltype != PTHREAD_CANCEL_DEFERRED, 0) - && ((cancelhandling = THREAD_GETMEM (self, cancelhandling)) - & CANCELTYPE_BITMASK) == 0) - { - while (1) - { - int curval = THREAD_ATOMIC_CMPXCHG_VAL (self, cancelhandling, - cancelhandling - | CANCELTYPE_BITMASK, - cancelhandling); - if (__glibc_likely (curval == cancelhandling)) - /* Successfully replaced the value. */ - break; - - /* Prepare for the next round. */ - cancelhandling = curval; - } - - CANCELLATION_P (self); - } + __libc_cleanup_pop_restore (buffer); /* If necessary call the cleanup routine after we removed the current cleanup block from the list. */ diff --git a/nptl/libc-cleanup.c b/nptl/libc-cleanup.c index 61f97eceda..14ccfe9285 100644 --- a/nptl/libc-cleanup.c +++ b/nptl/libc-cleanup.c @@ -17,11 +17,69 @@ <https://www.gnu.org/licenses/>. */ #include "pthreadP.h" +#include <tls.h> +#include <libc-lock.h> +void +__libc_cleanup_push_defer (struct _pthread_cleanup_buffer *buffer) +{ + struct pthread *self = THREAD_SELF; + + buffer->__prev = THREAD_GETMEM (self, cleanup); + + int cancelhandling = THREAD_GETMEM (self, cancelhandling); + + /* Disable asynchronous cancellation for now. */ + if (__glibc_unlikely (cancelhandling & CANCELTYPE_BITMASK)) + while (1) + { + int curval = THREAD_ATOMIC_CMPXCHG_VAL (self, cancelhandling, + cancelhandling + & ~CANCELTYPE_BITMASK, + cancelhandling); + if (__glibc_likely (curval == cancelhandling)) + /* Successfully replaced the value. */ + break; + + /* Prepare for the next round. */ + cancelhandling = curval; + } + + buffer->__canceltype = (cancelhandling & CANCELTYPE_BITMASK + ? PTHREAD_CANCEL_ASYNCHRONOUS + : PTHREAD_CANCEL_DEFERRED); + + THREAD_SETMEM (self, cleanup, buffer); +} +libc_hidden_def (__libc_cleanup_push_defer) void -__libc_cleanup_routine (struct __pthread_cleanup_frame *f) +__libc_cleanup_pop_restore (struct _pthread_cleanup_buffer *buffer) { - if (f->__do_it) - f->__cancel_routine (f->__cancel_arg); + struct pthread *self = THREAD_SELF; + + THREAD_SETMEM (self, cleanup, buffer->__prev); + + int cancelhandling; + if (__builtin_expect (buffer->__canceltype != PTHREAD_CANCEL_DEFERRED, 0) + && ((cancelhandling = THREAD_GETMEM (self, cancelhandling)) + & CANCELTYPE_BITMASK) == 0) + { + while (1) + { + int curval = THREAD_ATOMIC_CMPXCHG_VAL (self, cancelhandling, + cancelhandling + | CANCELTYPE_BITMASK, + cancelhandling); + if (__glibc_likely (curval == cancelhandling)) + /* Successfully replaced the value. */ + break; + + /* Prepare for the next round. */ + cancelhandling = curval; + } + + CANCELLATION_P (self); + } } +libc_hidden_def (__libc_cleanup_pop_restore) diff --git a/nptl/nptl-init.c b/nptl/nptl-init.c index 2c7e2222d4..43e2564e59 100644 --- a/nptl/nptl-init.c +++ b/nptl/nptl-init.c @@ -95,8 +95,6 @@ static const struct pthread_functions pthread_functions = .ptr___pthread_key_create = __pthread_key_create, .ptr___pthread_getspecific = __pthread_getspecific, .ptr___pthread_setspecific = __pthread_setspecific, - .ptr__pthread_cleanup_push_defer = __pthread_cleanup_push_defer, - .ptr__pthread_cleanup_pop_restore = __pthread_cleanup_pop_restore, .ptr_nthreads = &__nptl_nthreads, .ptr___pthread_unwind = &__pthread_unwind, .ptr__nptl_deallocate_tsd = __nptl_deallocate_tsd, diff --git a/sysdeps/nptl/libc-lock.h b/sysdeps/nptl/libc-lock.h index dea96121b3..e8a5e68a12 100644 --- a/sysdeps/nptl/libc-lock.h +++ b/sysdeps/nptl/libc-lock.h @@ -143,39 +143,40 @@ typedef struct __libc_lock_recursive_opaque__ __libc_lock_recursive_t; __libc_maybe_call (__pthread_mutex_unlock, (&(NAME).mutex), 0) #endif -/* Note that for I/O cleanup handling we are using the old-style - cancel handling. It does not have to be integrated with C++ since - no C++ code is called in the middle. The old-style handling is - faster and the support is not going away. */ -extern void _pthread_cleanup_push_defer (struct _pthread_cleanup_buffer *buffer, - void (*routine) (void *), void *arg); -extern void _pthread_cleanup_pop_restore (struct _pthread_cleanup_buffer *buffer, - int execute); +/* Put the unwind buffer BUFFER on the per-thread callback stack. The + caller must fill BUFFER->__routine and BUFFER->__arg before calling + this function. */ +void __libc_cleanup_push_defer (struct _pthread_cleanup_buffer *buffer); +libc_hidden_proto (__libc_cleanup_push_defer) +/* Remove BUFFER from the unwind callback stack. The caller must invoke + the callback if desired. */ +void __libc_cleanup_pop_restore (struct _pthread_cleanup_buffer *buffer); +libc_hidden_proto (__libc_cleanup_pop_restore) /* Start critical region with cleanup. */ -#define __libc_cleanup_region_start(DOIT, FCT, ARG) \ - { struct _pthread_cleanup_buffer _buffer; \ - int _avail; \ - if (DOIT) { \ - _avail = PTFAVAIL (_pthread_cleanup_push_defer); \ - if (_avail) { \ - __libc_ptf_call_always (_pthread_cleanup_push_defer, (&_buffer, FCT, \ - ARG)); \ - } else { \ - _buffer.__routine = (FCT); \ - _buffer.__arg = (ARG); \ - } \ - } else { \ - _avail = 0; \ - } +#define __libc_cleanup_region_start(DOIT, FCT, ARG) \ + { bool _cleanup_start_doit; \ + struct _pthread_cleanup_buffer _buffer; \ + /* Non-addressable copy of FCT, so that we avoid indirect calls on \ + the non-unwinding path. */ \ + void (*_cleanup_routine) (void *) = (FCT); \ + _buffer.__arg = (ARG); \ + if (DOIT) \ + { \ + _cleanup_start_doit = true; \ + _buffer.__routine = _cleanup_routine; \ + __libc_cleanup_push_defer (&_buffer); \ + } \ + else \ + _cleanup_start_doit = false; /* End critical region with cleanup. */ -#define __libc_cleanup_region_end(DOIT) \ - if (_avail) { \ - __libc_ptf_call_always (_pthread_cleanup_pop_restore, (&_buffer, DOIT));\ - } else if (DOIT) \ - _buffer.__routine (_buffer.__arg); \ - } +#define __libc_cleanup_region_end(DOIT) \ + if (_cleanup_start_doit) \ + __libc_cleanup_pop_restore (&_buffer); \ + if (DOIT) \ + _cleanup_routine (_buffer.__arg); \ + } /* matches __libc_cleanup_region_start */ /* Hide the definitions which are only supposed to be used inside libc in diff --git a/sysdeps/nptl/libc-lockP.h b/sysdeps/nptl/libc-lockP.h index 63b605dee2..2c928b7a76 100644 --- a/sysdeps/nptl/libc-lockP.h +++ b/sysdeps/nptl/libc-lockP.h @@ -251,32 +251,12 @@ _Static_assert (LLL_LOCK_INITIALIZER == 0, "LLL_LOCK_INITIALIZER != 0"); /* Get once control variable. */ #define __libc_once_get(ONCE_CONTROL) ((ONCE_CONTROL) != PTHREAD_ONCE_INIT) -/* Note that for I/O cleanup handling we are using the old-style - cancel handling. It does not have to be integrated with C++ snce - no C++ code is called in the middle. The old-style handling is - faster and the support is not going away. */ -extern void _pthread_cleanup_push (struct _pthread_cleanup_buffer *buffer, - void (*routine) (void *), void *arg); -extern void _pthread_cleanup_pop (struct _pthread_cleanup_buffer *buffer, - int execute); -extern void _pthread_cleanup_push_defer (struct _pthread_cleanup_buffer *buffer, - void (*routine) (void *), void *arg); -extern void _pthread_cleanup_pop_restore (struct _pthread_cleanup_buffer *buffer, - int execute); - -/* Sometimes we have to exit the block in the middle. */ -#define __libc_cleanup_end(DOIT) \ - if (_avail) { \ - __libc_ptf_call_always (_pthread_cleanup_pop_restore, (&_buffer, DOIT));\ - } else if (DOIT) \ - _buffer.__routine (_buffer.__arg) - /* __libc_cleanup_push and __libc_cleanup_pop depend on exception handling and stack unwinding. */ #ifdef __EXCEPTIONS /* Normal cleanup handling, based on C cleanup attribute. */ -__extern_inline void +static __always_inline void __libc_cleanup_routine (struct __pthread_cleanup_frame *f) { if (f->__do_it) @@ -388,8 +368,6 @@ weak_extern (__pthread_once) weak_extern (__pthread_initialize) weak_extern (__pthread_atfork) weak_extern (__pthread_setcancelstate) -weak_extern (_pthread_cleanup_push_defer) -weak_extern (_pthread_cleanup_pop_restore) # else # pragma weak __pthread_mutex_init # pragma weak __pthread_mutex_destroy @@ -412,8 +390,6 @@ weak_extern (_pthread_cleanup_pop_restore) # pragma weak __pthread_initialize # pragma weak __pthread_atfork # pragma weak __pthread_setcancelstate -# pragma weak _pthread_cleanup_push_defer -# pragma weak _pthread_cleanup_pop_restore # endif #endif diff --git a/sysdeps/nptl/pthread-functions.h b/sysdeps/nptl/pthread-functions.h index 97a5c48939..4268084b66 100644 --- a/sysdeps/nptl/pthread-functions.h +++ b/sysdeps/nptl/pthread-functions.h @@ -57,10 +57,6 @@ struct pthread_functions int (*ptr___pthread_key_create) (pthread_key_t *, void (*) (void *)); void *(*ptr___pthread_getspecific) (pthread_key_t); int (*ptr___pthread_setspecific) (pthread_key_t, const void *); - void (*ptr__pthread_cleanup_push_defer) (struct _pthread_cleanup_buffer *, - void (*) (void *), void *); - void (*ptr__pthread_cleanup_pop_restore) (struct _pthread_cleanup_buffer *, - int); #define HAVE_PTR_NTHREADS unsigned int *ptr_nthreads; void (*ptr___pthread_unwind) (__pthread_unwind_buf_t *) </cut>

4 years, 2 months

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

linaro-toolchain