This is an archive of the discontinued LLVM Phabricator instance.

Differential D38987

[GVN] Revert rL315440
ClosedPublic

Authored by mkazantsev on Oct 16 2017, 10:45 PM.

Details

Reviewers
reames
Summary

This patch reverts rL315440 because of the bug described at
https://bugs.llvm.org/show_bug.cgi?id=34937
The fix for the bug is on review as D38944. The reverted change
should be restored together with the fix.

Diff Detail

Event Timeline

mkazantsev created this revision.Oct 16 2017, 10:45 PM
reames accepted this revision.Oct 16 2017, 11:21 PM
This revision is now accepted and ready to land.Oct 16 2017, 11:21 PM
reames closed this revision.Oct 16 2017, 11:21 PM

Sending include/llvm/Transforms/Scalar/GVN.h
Sending lib/Transforms/Scalar/GVN.cpp
Sending test/Transforms/GVN/PRE/pre-load.ll
Transmitting file data ...done
Committing transaction...
Committed revision 315974.

Revision Contents

PathSize
include/
llvm/
Transforms/
Scalar/
7 lines
lib/
Transforms/
Scalar/
77 lines
test/
Transforms/
GVN/
PRE/
31 lines
28 lines

Diff 119253

include/llvm/Transforms/Scalar/GVN.h

Show All 12 Lines
/// ///
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_TRANSFORMS_SCALAR_GVN_H #ifndef LLVM_TRANSFORMS_SCALAR_GVN_H
#define LLVM_TRANSFORMS_SCALAR_GVN_H #define LLVM_TRANSFORMS_SCALAR_GVN_H
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/MapVector.h" #include "llvm/ADT/MapVector.h"
#include "llvm/ADT/PostOrderIterator.h"
#include "llvm/ADT/SetVector.h" #include "llvm/ADT/SetVector.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#include "llvm/Analysis/AliasAnalysis.h" #include "llvm/Analysis/AliasAnalysis.h"
#include "llvm/Analysis/MemoryDependenceAnalysis.h" #include "llvm/Analysis/MemoryDependenceAnalysis.h"
#include "llvm/IR/Dominators.h" #include "llvm/IR/Dominators.h"
#include "llvm/IR/InstrTypes.h" #include "llvm/IR/InstrTypes.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
#include "llvm/Support/Allocator.h" #include "llvm/Support/Allocator.h"
#include "llvm/Support/Compiler.h" #include "llvm/Support/Compiler.h"
#include "llvm/Transforms/Utils/OrderedInstructions.h"
#include <cstdint> #include <cstdint>
#include <utility> #include <utility>
#include <vector> #include <vector>
namespace llvm { namespace llvm {
class AssumptionCache; class AssumptionCache;
class BasicBlock; class BasicBlock;
▲ Show 20 Lines • Show All 113 Lines • ▼ Show 20 Linesprivate:
friend struct DenseMapInfo<Expression>; friend struct DenseMapInfo<Expression>;
MemoryDependenceResults *MD; MemoryDependenceResults *MD;
DominatorTree *DT; DominatorTree *DT;
const TargetLibraryInfo *TLI; const TargetLibraryInfo *TLI;
AssumptionCache *AC; AssumptionCache *AC;
SetVector<BasicBlock *> DeadBlocks; SetVector<BasicBlock *> DeadBlocks;
OptimizationRemarkEmitter *ORE; OptimizationRemarkEmitter *ORE;
// Maps a block to the topmost instruction with implicit control flow in it.
DenseMap<const BasicBlock *, const Instruction *>
FirstImplicitControlFlowInsts;
OrderedInstructions *OI;
ValueTable VN; ValueTable VN;
/// A mapping from value numbers to lists of Value*'s that /// A mapping from value numbers to lists of Value*'s that
/// have that value number. Use findLeader to query it. /// have that value number. Use findLeader to query it.
struct LeaderTableEntry { struct LeaderTableEntry {
Value *Val; Value *Val;
const BasicBlock *BB; const BasicBlock *BB;
LeaderTableEntry *Next; LeaderTableEntry *Next;
▲ Show 20 Lines • Show All 95 Lines • ▼ Show 20 Linesprivate:
void dump(DenseMap<uint32_t, Value *> &d) const; void dump(DenseMap<uint32_t, Value *> &d) const;
bool iterateOnFunction(Function &F); bool iterateOnFunction(Function &F);
bool performPRE(Function &F); bool performPRE(Function &F);
bool performScalarPRE(Instruction *I); bool performScalarPRE(Instruction *I);
bool performScalarPREInsertion(Instruction *Instr, BasicBlock *Pred, bool performScalarPREInsertion(Instruction *Instr, BasicBlock *Pred,
BasicBlock *Curr, unsigned int ValNo); BasicBlock *Curr, unsigned int ValNo);
Value *findLeader(const BasicBlock *BB, uint32_t num); Value *findLeader(const BasicBlock *BB, uint32_t num);
void cleanupGlobalSets(); void cleanupGlobalSets();
void fillImplicitControlFlowInfo(ReversePostOrderTraversal<Function *> &RPOT);
void verifyRemoved(const Instruction *I) const; void verifyRemoved(const Instruction *I) const;
bool splitCriticalEdges(); bool splitCriticalEdges();
BasicBlock *splitCriticalEdges(BasicBlock *Pred, BasicBlock *Succ); BasicBlock *splitCriticalEdges(BasicBlock *Pred, BasicBlock *Succ);
bool replaceOperandsWithConsts(Instruction *I) const; bool replaceOperandsWithConsts(Instruction *I) const;
bool propagateEquality(Value *LHS, Value *RHS, const BasicBlockEdge &Root, bool propagateEquality(Value *LHS, Value *RHS, const BasicBlockEdge &Root,
bool DominatesByEdge); bool DominatesByEdge);
bool processFoldableCondBr(BranchInst *BI); bool processFoldableCondBr(BranchInst *BI);
void addDeadBlock(BasicBlock *BB); void addDeadBlock(BasicBlock *BB);
Show All 25 Lines

lib/Transforms/Scalar/GVN.cpp

Show All 32 Lines
#include "llvm/Analysis/GlobalsModRef.h" #include "llvm/Analysis/GlobalsModRef.h"
#include "llvm/Analysis/InstructionSimplify.h" #include "llvm/Analysis/InstructionSimplify.h"
#include "llvm/Analysis/LoopInfo.h" #include "llvm/Analysis/LoopInfo.h"
#include "llvm/Analysis/MemoryBuiltins.h" #include "llvm/Analysis/MemoryBuiltins.h"
#include "llvm/Analysis/MemoryDependenceAnalysis.h" #include "llvm/Analysis/MemoryDependenceAnalysis.h"
#include "llvm/Analysis/OptimizationRemarkEmitter.h" #include "llvm/Analysis/OptimizationRemarkEmitter.h"
#include "llvm/Analysis/PHITransAddr.h" #include "llvm/Analysis/PHITransAddr.h"
#include "llvm/Analysis/TargetLibraryInfo.h" #include "llvm/Analysis/TargetLibraryInfo.h"
#include "llvm/Analysis/ValueTracking.h"
#include "llvm/IR/Attributes.h" #include "llvm/IR/Attributes.h"
#include "llvm/IR/BasicBlock.h" #include "llvm/IR/BasicBlock.h"
#include "llvm/IR/CallSite.h" #include "llvm/IR/CallSite.h"
#include "llvm/IR/Constant.h" #include "llvm/IR/Constant.h"
#include "llvm/IR/Constants.h" #include "llvm/IR/Constants.h"
#include "llvm/IR/DataLayout.h" #include "llvm/IR/DataLayout.h"
#include "llvm/IR/DebugLoc.h" #include "llvm/IR/DebugLoc.h"
#include "llvm/IR/Dominators.h" #include "llvm/IR/Dominators.h"
▲ Show 20 Lines • Show All 994 Lines • ▼ Show 20 Linesbool GVN::PerformLoadPRE(LoadInst *LI, AvailValInBlkVect &ValuesPerBlock,
SmallPtrSet<BasicBlock *, 4> Blockers(UnavailableBlocks.begin(), SmallPtrSet<BasicBlock *, 4> Blockers(UnavailableBlocks.begin(),
UnavailableBlocks.end()); UnavailableBlocks.end());
// Let's find the first basic block with more than one predecessor. Walk // Let's find the first basic block with more than one predecessor. Walk
// backwards through predecessors if needed. // backwards through predecessors if needed.
BasicBlock *LoadBB = LI->getParent(); BasicBlock *LoadBB = LI->getParent();
BasicBlock *TmpBB = LoadBB; BasicBlock *TmpBB = LoadBB;
bool IsSafeToSpeculativelyExecute = isSafeToSpeculativelyExecute(LI);
// Check that there is no implicit control flow instructions above our load in
// its block. If there is an instruction that doesn't always pass the
// execution to the following instruction, then moving through it may become
// invalid. For example:
//
// int arr[LEN];
// int index = ???;
// ...
// guard(0 <= index && index < LEN);
// use(arr[index]);
//
// It is illegal to move the array access to any point above the guard,
// because if the index is out of bounds we should deoptimize rather than
// access the array.
// Check that there is no guard in this block above our intruction.
if (!IsSafeToSpeculativelyExecute) {
auto It = FirstImplicitControlFlowInsts.find(TmpBB);
if (It != FirstImplicitControlFlowInsts.end()) {
assert(It->second->getParent() == TmpBB &&
"Implicit control flow map broken?");
if (OI->dominates(It->second, LI))
return false;
}
}
while (TmpBB->getSinglePredecessor()) { while (TmpBB->getSinglePredecessor()) {
TmpBB = TmpBB->getSinglePredecessor(); TmpBB = TmpBB->getSinglePredecessor();
if (TmpBB == LoadBB) // Infinite (unreachable) loop. if (TmpBB == LoadBB) // Infinite (unreachable) loop.
return false; return false;
if (Blockers.count(TmpBB)) if (Blockers.count(TmpBB))
return false; return false;
// If any of these blocks has more than one successor (i.e. if the edge we // If any of these blocks has more than one successor (i.e. if the edge we
// just traversed was critical), then there are other paths through this // just traversed was critical), then there are other paths through this
// block along which the load may not be anticipated. Hoisting the load // block along which the load may not be anticipated. Hoisting the load
// above this block would be adding the load to execution paths along // above this block would be adding the load to execution paths along
// which it was not previously executed. // which it was not previously executed.
if (TmpBB->getTerminator()->getNumSuccessors() != 1) if (TmpBB->getTerminator()->getNumSuccessors() != 1)
return false; return false;
// Check that there is no implicit control flow in a block above.
if (!IsSafeToSpeculativelyExecute &&
FirstImplicitControlFlowInsts.count(TmpBB))
return false;
} }
assert(TmpBB); assert(TmpBB);
LoadBB = TmpBB; LoadBB = TmpBB;
// Check to see how many predecessors have the loaded value fully // Check to see how many predecessors have the loaded value fully
// available. // available.
MapVector<BasicBlock *, Value *> PredLoads; MapVector<BasicBlock *, Value *> PredLoads;
▲ Show 20 Lines • Show All 904 Lines • ▼ Show 20 Linesbool GVN::runImpl(Function &F, AssumptionCache &RunAC, DominatorTree &RunDT,
MemoryDependenceResults *RunMD, LoopInfo *LI, MemoryDependenceResults *RunMD, LoopInfo *LI,
OptimizationRemarkEmitter *RunORE) { OptimizationRemarkEmitter *RunORE) {
AC = &RunAC; AC = &RunAC;
DT = &RunDT; DT = &RunDT;
VN.setDomTree(DT); VN.setDomTree(DT);
TLI = &RunTLI; TLI = &RunTLI;
VN.setAliasAnalysis(&RunAA); VN.setAliasAnalysis(&RunAA);
MD = RunMD; MD = RunMD;
OrderedInstructions OrderedInstrs(DT);
OI = &OrderedInstrs;
VN.setMemDep(MD); VN.setMemDep(MD);
ORE = RunORE; ORE = RunORE;
bool Changed = false; bool Changed = false;
bool ShouldContinue = true; bool ShouldContinue = true;
// Merge unconditional branches, allowing PRE to catch more // Merge unconditional branches, allowing PRE to catch more
// optimization opportunities. // optimization opportunities.
▲ Show 20 Lines • Show All 73 Lines • ▼ Show 20 Lines for (BasicBlock::iterator BI = BB->begin(), BE = BB->end();
for (SmallVectorImpl<Instruction *>::iterator I = InstrsToErase.begin(), for (SmallVectorImpl<Instruction *>::iterator I = InstrsToErase.begin(),
E = InstrsToErase.end(); I != E; ++I) { E = InstrsToErase.end(); I != E; ++I) {
DEBUG(dbgs() << "GVN removed: " << **I << '\n'); DEBUG(dbgs() << "GVN removed: " << **I << '\n');
if (MD) MD->removeInstruction(*I); if (MD) MD->removeInstruction(*I);
DEBUG(verifyRemoved(*I)); DEBUG(verifyRemoved(*I));
(*I)->eraseFromParent(); (*I)->eraseFromParent();
} }
if (!InstrsToErase.empty())
OI->invalidateBlock(BB);
InstrsToErase.clear(); InstrsToErase.clear();
if (AtStart) if (AtStart)
BI = BB->begin(); BI = BB->begin();
else else
++BI; ++BI;
} }
▲ Show 20 Lines • Show All 179 Lines • ▼ Show 20 Linesbool GVN::performScalarPRE(Instruction *CurInst) {
VN.erase(CurInst); VN.erase(CurInst);
removeFromLeaderTable(ValNo, CurInst, CurrentBlock); removeFromLeaderTable(ValNo, CurInst, CurrentBlock);
DEBUG(dbgs() << "GVN PRE removed: " << *CurInst << '\n'); DEBUG(dbgs() << "GVN PRE removed: " << *CurInst << '\n');
if (MD) if (MD)
MD->removeInstruction(CurInst); MD->removeInstruction(CurInst);
DEBUG(verifyRemoved(CurInst)); DEBUG(verifyRemoved(CurInst));
CurInst->eraseFromParent(); CurInst->eraseFromParent();
OI->invalidateBlock(CurrentBlock);
++NumGVNInstr; ++NumGVNInstr;
return true; return true;
} }
/// Perform a purely local form of PRE that looks for diamond /// Perform a purely local form of PRE that looks for diamond
/// control flow patterns and attempts to perform simple PRE at the join point. /// control flow patterns and attempts to perform simple PRE at the join point.
bool GVN::performPRE(Function &F) { bool GVN::performPRE(Function &F) {
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Linesbool GVN::iterateOnFunction(Function &F) {
cleanupGlobalSets(); cleanupGlobalSets();
// Top-down walk of the dominator tree // Top-down walk of the dominator tree
bool Changed = false; bool Changed = false;
// Needed for value numbering with phi construction to work. // Needed for value numbering with phi construction to work.
// RPOT walks the graph in its constructor and will not be invalidated during // RPOT walks the graph in its constructor and will not be invalidated during
// processBlock. // processBlock.
ReversePostOrderTraversal<Function *> RPOT(&F); ReversePostOrderTraversal<Function *> RPOT(&F);
fillImplicitControlFlowInfo(RPOT);
for (BasicBlock *BB : RPOT) for (BasicBlock *BB : RPOT)
Changed |= processBlock(BB); Changed |= processBlock(BB);
return Changed; return Changed;
} }
void GVN::cleanupGlobalSets() { void GVN::cleanupGlobalSets() {
VN.clear(); VN.clear();
LeaderTable.clear(); LeaderTable.clear();
BlockRPONumber.clear(); BlockRPONumber.clear();
TableAllocator.Reset(); TableAllocator.Reset();
FirstImplicitControlFlowInsts.clear();
}
void
GVN::fillImplicitControlFlowInfo(ReversePostOrderTraversal<Function *> &RPOT) {
auto MayNotTransferExecutionToSuccessor = [&](const Instruction *I) {
// If a block's instruction doesn't always pass the control to its successor
// instruction, mark the block as having implicit control flow. We use them
// to avoid wrong assumptions of sort "if A is executed and B post-dominates
// A, then B is also executed". This is not true is there is an implicit
// control flow instruction (e.g. a guard) between them.
//
// TODO: Currently, isGuaranteedToTransferExecutionToSuccessor returns false
// for volatile stores and loads because they can trap. The discussion on
// whether or not it is correct is still ongoing. We might want to get rid
// of this logic in the future. Anyways, trapping instructions shouldn't
// introduce implicit control flow, so we explicitly allow them here. This
// must be removed once isGuaranteedToTransferExecutionToSuccessor is fixed.
if (isGuaranteedToTransferExecutionToSuccessor(I))
return false;
if (isa<LoadInst>(I)) {
assert(cast<LoadInst>(I)->isVolatile() &&
"Non-volatile load should transfer execution to successor!");
return false;
}
if (isa<StoreInst>(I)) {
assert(cast<StoreInst>(I)->isVolatile() &&
"Non-volatile store should transfer execution to successor!");
return false;
}
return true;
};
for (BasicBlock *BB : RPOT)
for (auto &I : *BB)
if (MayNotTransferExecutionToSuccessor(&I)) {
FirstImplicitControlFlowInsts[BB] = &I;
break;
}
} }
/// Verify that the specified instruction does not occur in our /// Verify that the specified instruction does not occur in our
/// internal data structures. /// internal data structures.
void GVN::verifyRemoved(const Instruction *Inst) const { void GVN::verifyRemoved(const Instruction *Inst) const {
VN.verifyRemoved(Inst); VN.verifyRemoved(Inst);
// Walk through the value number scope to make sure the instruction isn't // Walk through the value number scope to make sure the instruction isn't
▲ Show 20 Lines • Show All 197 Lines • Show Last 20 Lines

test/Transforms/GVN/PRE/2017-10-16-LoadPRECrash.ll

; RUN: opt -S -gvn -enable-load-pre < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
%ArrayImpl = type { i64, i64 addrspace(100)*, [1 x i64], [1 x i64], [1 x i64], i64, i64, double addrspace(100)*, double addrspace(100)*, i8, i64 }
; Function Attrs: readnone
declare %ArrayImpl* @getaddr_ArrayImpl(%ArrayImpl addrspace(100)*) #0
; Function Attrs: readnone
declare i64* @getaddr_i64(i64 addrspace(100)*) #0
; Make sure that the test compiles without a crash.
define hidden void @wrapon_fn173() {
; CHECK-LABEL: @wrapon_fn173
entry:
%0 = call %ArrayImpl* @getaddr_ArrayImpl(%ArrayImpl addrspace(100)* undef)
br label %loop
loop:
%1 = call %ArrayImpl* @getaddr_ArrayImpl(%ArrayImpl addrspace(100)* undef)
%2 = load i64 addrspace(100)*, i64 addrspace(100)** null, align 8
%3 = call i64* @getaddr_i64(i64 addrspace(100)* %2)
br label %loop
}
attributes #0 = { readnone }

test/Transforms/GVN/PRE/pre-load-guards.ll

  • This file was deleted.
; RUN: opt < %s -basicaa -gvn -enable-load-pre -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
declare void @llvm.experimental.guard(i1, ...)
; This is a motivating example on why we prohibit hoisting through guards.
; In the bottom block, we check that the index is within bounds and only access
; the element in this case and deoptimize otherwise. If we hoist the load to a
; place above the guard, it will may lead to out-of-bound array access.
define i32 @test_motivation(i32* %p, i32* %q, i1 %C, i32 %index, i32 %len) {
; CHECK-LABEL: @test_motivation(
block1:
%el1 = getelementptr inbounds i32, i32* %q, i32 %index
%el2 = getelementptr inbounds i32, i32* %p, i32 %index
br i1 %C, label %block2, label %block3
block2:
; CHECK: block2:
; CHECK-NEXT: br
; CHECK-NOT: load
; CHECK-NOT: sge
; CHECK-NOT: slt
; CHECK-NOT: and
br label %block4
block3:
store i32 0, i32* %el1
br label %block4
block4:
; CHECK: block4:
; CHECK: %cond1 = icmp sge i32 %index, 0
; CHECK-NEXT: %cond2 = icmp slt i32 %index, %len
; CHECK-NEXT: %in.bounds = and i1 %cond1, %cond2
; CHECK: call void (i1, ...) @llvm.experimental.guard(i1 %in.bounds)
; CHECK-NEXT: %PRE = load i32, i32* %P2
; CHECK: ret i32 %PRE
%P2 = phi i32* [%el2, %block3], [%el1, %block2]
%cond1 = icmp sge i32 %index, 0
%cond2 = icmp slt i32 %index, %len
%in.bounds = and i1 %cond1, %cond2
call void (i1, ...) @llvm.experimental.guard(i1 %in.bounds) [ "deopt"() ]
%PRE = load i32, i32* %P2
ret i32 %PRE
}
; Guard in load's block that is above the load should prohibit the PRE.
define i32 @test_guard_01(i32* %p, i32* %q, i1 %C, i1 %G) {
; CHECK-LABEL: @test_guard_01(
block1:
br i1 %C, label %block2, label %block3
block2:
; CHECK: block2:
; CHECK-NEXT: br
; CHECK-NOT: load
br label %block4
block3:
store i32 0, i32* %p
br label %block4
block4:
; CHECK: block4:
; CHECK: call void (i1, ...) @llvm.experimental.guard(i1 %G)
; CHECK-NEXT: load
; CHECK: ret i32
%P2 = phi i32* [%p, %block3], [%q, %block2]
call void (i1, ...) @llvm.experimental.guard(i1 %G) [ "deopt"() ]
%PRE = load i32, i32* %P2
ret i32 %PRE
}
; Guard in load's block that is below the load should not prohibit the PRE.
define i32 @test_guard_02(i32* %p, i32* %q, i1 %C, i1 %G) {
; CHECK-LABEL: @test_guard_02(
block1:
br i1 %C, label %block2, label %block3
block2:
; CHECK: block2:
; CHECK-NEXT: load i32, i32* %q
br label %block4
block3:
store i32 0, i32* %p
br label %block4
block4:
; CHECK: block4:
; CHECK-NEXT: phi i32 [
; CHECK-NEXT: phi i32* [
; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 %G)
; CHECK-NOT: load
; CHECK: ret i32
%P2 = phi i32* [%p, %block3], [%q, %block2]
%PRE = load i32, i32* %P2
call void (i1, ...) @llvm.experimental.guard(i1 %G) [ "deopt"() ]
ret i32 %PRE
}
; Guard above the load's block should prevent PRE from hoisting through it.
define i32 @test_guard_03(i32* %p, i32* %q, i1 %C, i1 %G) {
; CHECK-LABEL: @test_guard_03(
block1:
br i1 %C, label %block2, label %block3
block2:
; CHECK: block2:
; CHECK-NEXT: br
; CHECK-NOT: load
br label %block4
block3:
store i32 0, i32* %p
br label %block4
block4:
; CHECK: block4:
; CHECK-NEXT: phi i32*
; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 %G)
; CHECK-NEXT: load
; CHECK-NEXT: ret i32
%P2 = phi i32* [%p, %block3], [%q, %block2]
call void (i1, ...) @llvm.experimental.guard(i1 %G) [ "deopt"() ]
br label %block5
block5:
%PRE = load i32, i32* %P2
ret i32 %PRE
}

test/Transforms/GVN/PRE/pre-load.ll

Show First 20 Lines • Show All 424 Lines • ▼ Show 20 Lines
; CHECK-NEXT: %c2 = cleanuppad within none [] ; CHECK-NEXT: %c2 = cleanuppad within none []
; CHECK-NEXT: %NOTPRE = load i32, i32* %p ; CHECK-NEXT: %NOTPRE = load i32, i32* %p
cleanup2: cleanup2:
%c2 = cleanuppad within none [] %c2 = cleanuppad within none []
%NOTPRE = load i32, i32* %p %NOTPRE = load i32, i32* %p
call void @g(i32 %NOTPRE) call void @g(i32 %NOTPRE)
cleanupret from %c2 unwind to caller cleanupret from %c2 unwind to caller
} }
; Don't PRE load across calls.
define i32 @test13(i32* noalias nocapture readonly %x, i32* noalias nocapture %r, i32 %a) {
; CHECK-LABEL: @test13(
; CHECK: entry:
; CHECK-NEXT: icmp eq
; CHECK-NEXT: br i1
entry:
%tobool = icmp eq i32 %a, 0
br i1 %tobool, label %if.end, label %if.then
; CHECK: if.then:
; CHECK-NEXT: load i32
; CHECK-NEXT: store i32
if.then:
%uu = load i32, i32* %x, align 4
store i32 %uu, i32* %r, align 4
br label %if.end
; CHECK: if.end:
; CHECK-NEXT: call void @f()
; CHECK-NEXT: load i32
if.end:
call void @f()
%vv = load i32, i32* %x, align 4
ret i32 %vv
}
test/Transforms/GVN/PRE/2017-10-16-LoadPRECrash.ll