[llvm] r220178 - Teach the load analysis driving core instcombine logic and other bits of
Renato Golin
renato.golin at linaro.org
Mon Oct 20 02:26:13 PDT 2014
Hi Chandler,
Seems this commit broke our ARM64 LNT:
http://lab.llvm.org:8011/builders/clang-aarch64-lnt/builds/1561
The error on both cases:
clang: /home/bgabor/work/lntbot/slave/clang-aarch64-lnt/llvm.src/include/llvm/Support/Casting.h:95:
static bool llvm::isa_impl_cl<To, const From*>::doit(const From*)
[with To = llvm::BranchInst; From = llvm::TerminatorInst]: Assertion
`Val && "isa<> used on a null pointer"' failed.
0 clang 0x000000000254f190 llvm::sys::PrintStackTrace(_IO_FILE*) + 52
Stack dump:
1. <eof> parser at end of file
2. Per-module optimization passes
3. Running pass 'CallGraph Pass Manager' on module
'/home/bgabor/work/lntbot/slave/clang-aarch64-lnt/test-suite/MultiSource/Benchmarks/MiBench/consumer-typeset/z29.c'.
4. Running pass 'Jump Threading' on function '@ChildSymWithCode'
qemu: uncaught target signal 6 (Aborted) - core dumped
clang: error: unable to execute command: Aborted (core dumped)
clang: error: clang frontend command failed due to signal (use -v to
see invocation)
clang version 3.6.0 (trunk 220178)
Target: aarch64-unknown-linux-gnu
cheers,
--renato
On 20 October 2014 01:24, Chandler Carruth <chandlerc at gmail.com> wrote:
> Author: chandlerc
> Date: Sun Oct 19 19:24:14 2014
> New Revision: 220178
>
> URL: http://llvm.org/viewvc/llvm-project?rev=220178&view=rev
> Log:
> Teach the load analysis driving core instcombine logic and other bits of
> logic to look through pointer casts, making them trivially stronger in
> the face of loads and stores with intervening pointer casts.
>
> I've included a few test cases that demonstrate the kind of folding
> instcombine can do without pointer casts and then variations which
> obfuscate the logic through bitcasts. Without this patch, the variations
> all fail to optimize fully.
>
> This is more important now than it has been in the past as I've started
> moving the load canonicialization to more closely follow the value type
> requirements rather than the pointer type requirements and thus this
> needs to be prepared for more pointer casts. When I made the same change
> to stores several test cases regressed without logic along these lines
> so I wanted to systematically improve matters first.
>
> Modified:
> llvm/trunk/lib/Analysis/Loads.cpp
> llvm/trunk/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
> llvm/trunk/lib/Transforms/Scalar/JumpThreading.cpp
> llvm/trunk/test/Transforms/InstCombine/select.ll
>
> Modified: llvm/trunk/lib/Analysis/Loads.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/Loads.cpp?rev=220178&r1=220177&r2=220178&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/Loads.cpp (original)
> +++ llvm/trunk/lib/Analysis/Loads.cpp Sun Oct 19 19:24:14 2014
> @@ -86,6 +86,9 @@ bool llvm::isSafeToLoadUnconditionally(V
> }
> }
>
> + PointerType *AddrTy = cast<PointerType>(V->getType());
> + uint64_t LoadSize = DL ? DL->getTypeStoreSize(AddrTy->getElementType()) : 0;
> +
> // If we found a base allocated type from either an alloca or global variable,
> // try to see if we are definitively within the allocated region. We need to
> // know the size of the base type and the loaded type to do anything in this
> @@ -96,8 +99,6 @@ bool llvm::isSafeToLoadUnconditionally(V
>
> if (Align <= BaseAlign) {
> // Check if the load is within the bounds of the underlying object.
> - PointerType *AddrTy = cast<PointerType>(V->getType());
> - uint64_t LoadSize = DL->getTypeStoreSize(AddrTy->getElementType());
> if (ByteOffset + LoadSize <= DL->getTypeAllocSize(BaseType) &&
> (Align == 0 || (ByteOffset % Align) == 0))
> return true;
> @@ -111,6 +112,10 @@ bool llvm::isSafeToLoadUnconditionally(V
> // the load entirely).
> BasicBlock::iterator BBI = ScanFrom, E = ScanFrom->getParent()->begin();
>
> + // We can at least always strip pointer casts even though we can't use the
> + // base here.
> + V = V->stripPointerCasts();
> +
> while (BBI != E) {
> --BBI;
>
> @@ -120,13 +125,25 @@ bool llvm::isSafeToLoadUnconditionally(V
> !isa<DbgInfoIntrinsic>(BBI))
> return false;
>
> - if (LoadInst *LI = dyn_cast<LoadInst>(BBI)) {
> - if (AreEquivalentAddressValues(LI->getOperand(0), V))
> - return true;
> - } else if (StoreInst *SI = dyn_cast<StoreInst>(BBI)) {
> - if (AreEquivalentAddressValues(SI->getOperand(1), V))
> - return true;
> - }
> + Value *AccessedPtr;
> + if (LoadInst *LI = dyn_cast<LoadInst>(BBI))
> + AccessedPtr = LI->getPointerOperand();
> + else if (StoreInst *SI = dyn_cast<StoreInst>(BBI))
> + AccessedPtr = SI->getPointerOperand();
> + else
> + continue;
> +
> + // Handle trivial cases even w/o DataLayout or other work.
> + if (AccessedPtr == V)
> + return true;
> +
> + if (!DL)
> + continue;
> +
> + auto *AccessedTy = cast<PointerType>(AccessedPtr->getType());
> + if (AreEquivalentAddressValues(AccessedPtr->stripPointerCasts(), V) &&
> + LoadSize <= DL->getTypeStoreSize(AccessedTy->getElementType()))
> + return true;
> }
> return false;
> }
> @@ -157,12 +174,12 @@ Value *llvm::FindAvailableLoadedValue(Va
> if (MaxInstsToScan == 0)
> MaxInstsToScan = ~0U;
>
> + Type *AccessTy = cast<PointerType>(Ptr->getType())->getElementType();
> +
> // If we're using alias analysis to disambiguate get the size of *Ptr.
> - uint64_t AccessSize = 0;
> - if (AA) {
> - Type *AccessTy = cast<PointerType>(Ptr->getType())->getElementType();
> - AccessSize = AA->getTypeStoreSize(AccessTy);
> - }
> + uint64_t AccessSize = AA ? AA->getTypeStoreSize(AccessTy) : 0;
> +
> + Value *StrippedPtr = Ptr->stripPointerCasts();
>
> while (ScanFrom != ScanBB->begin()) {
> // We must ignore debug info directives when counting (otherwise they
> @@ -183,17 +200,21 @@ Value *llvm::FindAvailableLoadedValue(Va
> // (This is true even if the load is volatile or atomic, although
> // those cases are unlikely.)
> if (LoadInst *LI = dyn_cast<LoadInst>(Inst))
> - if (AreEquivalentAddressValues(LI->getOperand(0), Ptr)) {
> + if (AreEquivalentAddressValues(
> + LI->getPointerOperand()->stripPointerCasts(), StrippedPtr) &&
> + CastInst::isBitCastable(LI->getType(), AccessTy)) {
> if (AATags)
> LI->getAAMetadata(*AATags);
> return LI;
> }
>
> if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
> + Value *StorePtr = SI->getPointerOperand()->stripPointerCasts();
> // If this is a store through Ptr, the value is available!
> // (This is true even if the store is volatile or atomic, although
> // those cases are unlikely.)
> - if (AreEquivalentAddressValues(SI->getOperand(1), Ptr)) {
> + if (AreEquivalentAddressValues(StorePtr, StrippedPtr) &&
> + CastInst::isBitCastable(SI->getValueOperand()->getType(), AccessTy)) {
> if (AATags)
> SI->getAAMetadata(*AATags);
> return SI->getOperand(0);
> @@ -202,15 +223,15 @@ Value *llvm::FindAvailableLoadedValue(Va
> // If Ptr is an alloca and this is a store to a different alloca, ignore
> // the store. This is a trivial form of alias analysis that is important
> // for reg2mem'd code.
> - if ((isa<AllocaInst>(Ptr) || isa<GlobalVariable>(Ptr)) &&
> - (isa<AllocaInst>(SI->getOperand(1)) ||
> - isa<GlobalVariable>(SI->getOperand(1))))
> + if ((isa<AllocaInst>(StrippedPtr) || isa<GlobalVariable>(StrippedPtr)) &&
> + (isa<AllocaInst>(StorePtr) || isa<GlobalVariable>(StorePtr)))
> continue;
>
> // If we have alias analysis and it says the store won't modify the loaded
> // value, ignore the store.
> if (AA &&
> - (AA->getModRefInfo(SI, Ptr, AccessSize) & AliasAnalysis::Mod) == 0)
> + (AA->getModRefInfo(SI, StrippedPtr, AccessSize) &
> + AliasAnalysis::Mod) == 0)
> continue;
>
> // Otherwise the store that may or may not alias the pointer, bail out.
> @@ -223,7 +244,8 @@ Value *llvm::FindAvailableLoadedValue(Va
> // If alias analysis claims that it really won't modify the load,
> // ignore it.
> if (AA &&
> - (AA->getModRefInfo(Inst, Ptr, AccessSize) & AliasAnalysis::Mod) == 0)
> + (AA->getModRefInfo(Inst, StrippedPtr, AccessSize) &
> + AliasAnalysis::Mod) == 0)
> continue;
>
> // May modify the pointer, bail out.
>
> Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp?rev=220178&r1=220177&r2=220178&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp (original)
> +++ llvm/trunk/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp Sun Oct 19 19:24:14 2014
> @@ -420,7 +420,8 @@ Instruction *InstCombiner::visitLoadInst
> // separated by a few arithmetic operations.
> BasicBlock::iterator BBI = &LI;
> if (Value *AvailableVal = FindAvailableLoadedValue(Op, LI.getParent(), BBI,6))
> - return ReplaceInstUsesWith(LI, AvailableVal);
> + return ReplaceInstUsesWith(
> + LI, Builder->CreateBitCast(AvailableVal, LI.getType()));
>
> // load(gep null, ...) -> unreachable
> if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(Op)) {
>
> Modified: llvm/trunk/lib/Transforms/Scalar/JumpThreading.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/JumpThreading.cpp?rev=220178&r1=220177&r2=220178&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Scalar/JumpThreading.cpp (original)
> +++ llvm/trunk/lib/Transforms/Scalar/JumpThreading.cpp Sun Oct 19 19:24:14 2014
> @@ -901,6 +901,9 @@ bool JumpThreading::SimplifyPartiallyRed
> // If the returned value is the load itself, replace with an undef. This can
> // only happen in dead loops.
> if (AvailableVal == LI) AvailableVal = UndefValue::get(LI->getType());
> + if (AvailableVal->getType() != LI->getType())
> + AvailableVal = CastInst::Create(CastInst::BitCast, AvailableVal,
> + LI->getType(), "", LI);
> LI->replaceAllUsesWith(AvailableVal);
> LI->eraseFromParent();
> return true;
> @@ -1031,7 +1034,13 @@ bool JumpThreading::SimplifyPartiallyRed
> assert(I != AvailablePreds.end() && I->first == P &&
> "Didn't find entry for predecessor!");
>
> - PN->addIncoming(I->second, I->first);
> + // If we have an available predecessor but it requires casting, insert the
> + // cast in the predecessor and use the cast.
> + Value *PredV = I->second;
> + if (PredV->getType() != LI->getType())
> + PredV = CastInst::Create(CastInst::BitCast, PredV, LI->getType(), "", P);
> +
> + PN->addIncoming(PredV, I->first);
> }
>
> //cerr << "PRE: " << *LI << *PN << "\n";
>
> Modified: llvm/trunk/test/Transforms/InstCombine/select.ll
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/InstCombine/select.ll?rev=220178&r1=220177&r2=220178&view=diff
> ==============================================================================
> --- llvm/trunk/test/Transforms/InstCombine/select.ll (original)
> +++ llvm/trunk/test/Transforms/InstCombine/select.ll Sun Oct 19 19:24:14 2014
> @@ -1276,3 +1276,112 @@ define i32 @test77(i1 %flag, i32* %x) {
> %v = load i32* %p
> ret i32 %v
> }
> +
> +define i32 @test78(i1 %flag, i32* %x, i32* %y, i32* %z) {
> +; Test that we can speculate the loads around the select even when we can't
> +; fold the load completely away.
> +; CHECK-LABEL: @test78(
> +; CHECK: %[[V1:.*]] = load i32* %x
> +; CHECK-NEXT: %[[V2:.*]] = load i32* %y
> +; CHECK-NEXT: %[[S:.*]] = select i1 %flag, i32 %[[V1]], i32 %[[V2]]
> +; CHECK-NEXT: ret i32 %[[S]]
> +entry:
> + store i32 0, i32* %x
> + store i32 0, i32* %y
> + ; Block forwarding by storing to %z which could alias either %x or %y.
> + store i32 42, i32* %z
> + %p = select i1 %flag, i32* %x, i32* %y
> + %v = load i32* %p
> + ret i32 %v
> +}
> +
> +define float @test79(i1 %flag, float* %x, i32* %y, i32* %z) {
> +; Test that we can speculate the loads around the select even when we can't
> +; fold the load completely away.
> +; CHECK-LABEL: @test79(
> +; CHECK: %[[V1:.*]] = load float* %x
> +; CHECK-NEXT: %[[V2:.*]] = load float* %y
> +; CHECK-NEXT: %[[S:.*]] = select i1 %flag, float %[[V1]], float %[[V2]]
> +; CHECK-NEXT: ret float %[[S]]
> +entry:
> + %x1 = bitcast float* %x to i32*
> + %y1 = bitcast i32* %y to float*
> + store i32 0, i32* %x1
> + store i32 0, i32* %y
> + ; Block forwarding by storing to %z which could alias either %x or %y.
> + store i32 42, i32* %z
> + %p = select i1 %flag, float* %x, float* %y1
> + %v = load float* %p
> + ret float %v
> +}
> +
> +define i32 @test80(i1 %flag) {
> +; Test that when we speculate the loads around the select they fold throug
> +; load->load folding and load->store folding.
> +; CHECK-LABEL: @test80(
> +; CHECK: %[[X:.*]] = alloca i32
> +; CHECK-NEXT: %[[Y:.*]] = alloca i32
> +; CHECK: %[[V:.*]] = load i32* %[[X]]
> +; CHECK-NEXT: store i32 %[[V]], i32* %[[Y]]
> +; CHECK-NEXT: ret i32 %[[V]]
> +entry:
> + %x = alloca i32
> + %y = alloca i32
> + call void @scribble_on_memory(i32* %x)
> + call void @scribble_on_memory(i32* %y)
> + %tmp = load i32* %x
> + store i32 %tmp, i32* %y
> + %p = select i1 %flag, i32* %x, i32* %y
> + %v = load i32* %p
> + ret i32 %v
> +}
> +
> +define float @test81(i1 %flag) {
> +; Test that we can speculate the load around the select even though they use
> +; differently typed pointers.
> +; CHECK-LABEL: @test81(
> +; CHECK: %[[X:.*]] = alloca i32
> +; CHECK-NEXT: %[[Y:.*]] = alloca i32
> +; CHECK: %[[V:.*]] = load i32* %[[X]]
> +; CHECK-NEXT: store i32 %[[V]], i32* %[[Y]]
> +; CHECK-NEXT: %[[C:.*]] = bitcast i32 %[[V]] to float
> +; CHECK-NEXT: ret float %[[C]]
> +entry:
> + %x = alloca float
> + %y = alloca i32
> + %x1 = bitcast float* %x to i32*
> + %y1 = bitcast i32* %y to float*
> + call void @scribble_on_memory(i32* %x1)
> + call void @scribble_on_memory(i32* %y)
> + %tmp = load i32* %x1
> + store i32 %tmp, i32* %y
> + %p = select i1 %flag, float* %x, float* %y1
> + %v = load float* %p
> + ret float %v
> +}
> +
> +define i32 @test82(i1 %flag) {
> +; Test that we can speculate the load around the select even though they use
> +; differently typed pointers.
> +; CHECK-LABEL: @test82(
> +; CHECK: %[[X:.*]] = alloca float
> +; CHECK-NEXT: %[[Y:.*]] = alloca i32
> +; CHECK-NEXT: %[[X1:.*]] = bitcast float* %[[X]] to i32*
> +; CHECK-NEXT: %[[Y1:.*]] = bitcast i32* %[[Y]] to float*
> +; CHECK: %[[V:.*]] = load float* %[[X]]
> +; CHECK-NEXT: store float %[[V]], float* %[[Y1]]
> +; CHECK-NEXT: %[[C:.*]] = bitcast float %[[V]] to i32
> +; CHECK-NEXT: ret i32 %[[C]]
> +entry:
> + %x = alloca float
> + %y = alloca i32
> + %x1 = bitcast float* %x to i32*
> + %y1 = bitcast i32* %y to float*
> + call void @scribble_on_memory(i32* %x1)
> + call void @scribble_on_memory(i32* %y)
> + %tmp = load float* %x
> + store float %tmp, float* %y1
> + %p = select i1 %flag, i32* %x1, i32* %y
> + %v = load i32* %p
> + ret i32 %v
> +}
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
More information about the llvm-commits
mailing list