RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-21 18:22:53 +01:00
Code Issues Projects Releases Wiki Activity

[Local] Do not introduce a new llvm.trap before unreachable

Browse Source 
This is the second attempt to remove the `llvm.trap` insertion after
https://reviews.llvm.org/rGe14e7bc4b889dfaffb7180d176a03311df2d4ae6
reverted the first one. It is not clear what the exact issue was back
then and it might already be gone by now, it has been >5 years after
all.

Replaces D106299.

Differential Revision: https://reviews.llvm.org/D106308
This commit is contained in:
Johannes Doerfert 2021-07-19 15:31:10 -05:00
parent 95f415bd34
commit 4ce16022d3
19 changed files with 35 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
include/llvm/Transforms/Utils/Local.h
View File

@ -328,8 +328,7 @@ removeAllNonTerminatorAndEHPadInstructions(BasicBlock *BB);
/// Insert an unreachable instruction before the specified
/// instruction, making it and the rest of the code in the block dead.
unsigned changeToUnreachable(Instruction *I, bool UseLLVMTrap,
bool PreserveLCSSA = false,
unsigned changeToUnreachable(Instruction *I, bool PreserveLCSSA = false,
DomTreeUpdater *DTU = nullptr,
MemorySSAUpdater *MSSAU = nullptr);

6
lib/CodeGen/WinEHPrepare.cpp
View File

@ -984,9 +984,9 @@ void WinEHPrepare::removeImplausibleInstructions(Function &F) {
BasicBlock::iterator CallI =
std::prev(BB->getTerminator()->getIterator());
auto *CI = cast<CallInst>(&*CallI);
changeToUnreachable(CI, /*UseLLVMTrap=*/false);
changeToUnreachable(CI);
} else {
changeToUnreachable(&I, /*UseLLVMTrap=*/false);
changeToUnreachable(&I);
}
// There are no more instructions in the block (except for unreachable),
@ -1007,7 +1007,7 @@ void WinEHPrepare::removeImplausibleInstructions(Function &F) {
IsUnreachableCleanupret = CRI->getCleanupPad() != CleanupPad;
if (IsUnreachableRet || IsUnreachableCatchret ||
IsUnreachableCleanupret) {
changeToUnreachable(TI, /*UseLLVMTrap=*/false);
changeToUnreachable(TI);
} else if (isa<InvokeInst>(TI)) {
if (Personality == EHPersonality::MSVC_CXX && CleanupPad) {
// Invokes within a cleanuppad for the MSVC++ personality never

2
lib/Transforms/Coroutines/CoroSplit.cpp
View File

@ -955,7 +955,7 @@ void CoroCloner::create() {
case coro::ABI::RetconOnce:
// Remove old returns.
for (ReturnInst *Return : Returns)
changeToUnreachable(Return, /*UseLLVMTrap=*/false);
changeToUnreachable(Return);
break;
// With multi-suspend continuations, we'll already have eliminated the

2
lib/Transforms/Coroutines/Coroutines.cpp
View File

@ -361,7 +361,7 @@ void coro::Shape::buildFrom(Function &F) {
// Replace all coro.ends with unreachable instruction.
for (AnyCoroEndInst *CE : CoroEnds)
changeToUnreachable(CE, /*UseLLVMTrap=*/false);
changeToUnreachable(CE);
return;
}

2
lib/Transforms/IPO/Attributor.cpp
View File

@ -1705,7 +1705,7 @@ ChangeStatus Attributor::cleanupIR() {
if (!isRunOn(*I->getFunction()))
continue;
CGModifiedFunctions.insert(I->getFunction());
changeToUnreachable(I, /* UseLLVMTrap */ false);
changeToUnreachable(I);
}
for (auto &V : ToBeDeletedInsts) {

2
lib/Transforms/IPO/PruneEH.cpp
View File

@ -251,7 +251,7 @@ static void DeleteBasicBlock(BasicBlock *BB, CallGraphUpdater &CGU) {
if (TokenInst) {
if (!TokenInst->isTerminator())
changeToUnreachable(TokenInst->getNextNode(), /*UseLLVMTrap=*/false);
changeToUnreachable(TokenInst->getNextNode());
} else {
// Get the list of successors of this block.
std::vector<BasicBlock *> Succs(succ_begin(BB), succ_end(BB));

6
lib/Transforms/Scalar/SCCP.cpp
View File

@ -526,13 +526,11 @@ bool llvm::runIPSCCP(
// nodes in executable blocks we found values for. The function's entry
// block is not part of BlocksToErase, so we have to handle it separately.
for (BasicBlock *BB : BlocksToErase) {
NumInstRemoved +=
changeToUnreachable(BB->getFirstNonPHI(), /*UseLLVMTrap=*/false,
/*PreserveLCSSA=*/false, &DTU);
NumInstRemoved += changeToUnreachable(BB->getFirstNonPHI(),
/*PreserveLCSSA=*/false, &DTU);
}
if (!Solver.isBlockExecutable(&F.front()))
NumInstRemoved += changeToUnreachable(F.front().getFirstNonPHI(),
/*UseLLVMTrap=*/false,
/*PreserveLCSSA=*/false, &DTU);
for (BasicBlock &BB : F)

2
lib/Transforms/Utils/InlineFunction.cpp
View File

@ -2327,7 +2327,7 @@ llvm::InlineResult llvm::InlineFunction(CallBase &CB, InlineFunctionInfo &IFI,
// As such, we replace the cleanupret with unreachable.
if (auto *CleanupRet = dyn_cast<CleanupReturnInst>(BB->getTerminator()))
if (CleanupRet->unwindsToCaller() && EHPadForCallUnwindsLocally)
changeToUnreachable(CleanupRet, /*UseLLVMTrap=*/false);
changeToUnreachable(CleanupRet);
Instruction *I = BB->getFirstNonPHI();
if (!I->isEHPad())

25
lib/Transforms/Utils/Local.cpp
View File

@ -2110,8 +2110,8 @@ llvm::removeAllNonTerminatorAndEHPadInstructions(BasicBlock *BB) {
return {NumDeadInst, NumDeadDbgInst};
}
unsigned llvm::changeToUnreachable(Instruction *I, bool UseLLVMTrap,
bool PreserveLCSSA, DomTreeUpdater *DTU,
unsigned llvm::changeToUnreachable(Instruction *I, bool PreserveLCSSA,
DomTreeUpdater *DTU,
MemorySSAUpdater *MSSAU) {
BasicBlock *BB = I->getParent();
@ -2127,14 +2127,6 @@ unsigned llvm::changeToUnreachable(Instruction *I, bool UseLLVMTrap,
if (DTU)
UniqueSuccessors.insert(Successor);
}
// Insert a call to llvm.trap right before this. This turns the undefined
// behavior into a hard fail instead of falling through into random code.
if (UseLLVMTrap) {
Function *TrapFn =
Intrinsic::getDeclaration(BB->getParent()->getParent(), Intrinsic::trap);
CallInst *CallTrap = CallInst::Create(TrapFn, "", I);
CallTrap->setDebugLoc(I->getDebugLoc());
}
auto *UI = new UnreachableInst(I->getContext(), I);
UI->setDebugLoc(I->getDebugLoc());
@ -2271,7 +2263,7 @@ static bool markAliveBlocks(Function &F,
if (IntrinsicID == Intrinsic::assume) {
if (match(CI->getArgOperand(0), m_CombineOr(m_Zero(), m_Undef()))) {
// Don't insert a call to llvm.trap right before the unreachable.
changeToUnreachable(CI, false, false, DTU);
changeToUnreachable(CI, false, DTU);
Changed = true;
break;
}
@ -2287,8 +2279,7 @@ static bool markAliveBlocks(Function &F,
// still be useful for widening.
if (match(CI->getArgOperand(0), m_Zero()))
if (!isa<UnreachableInst>(CI->getNextNode())) {
changeToUnreachable(CI->getNextNode(), /*UseLLVMTrap=*/false,
false, DTU);
changeToUnreachable(CI->getNextNode(), false, DTU);
Changed = true;
break;
}
@ -2296,7 +2287,7 @@ static bool markAliveBlocks(Function &F,
} else if ((isa<ConstantPointerNull>(Callee) &&
!NullPointerIsDefined(CI->getFunction())) ||
isa<UndefValue>(Callee)) {
changeToUnreachable(CI, /*UseLLVMTrap=*/false, false, DTU);
changeToUnreachable(CI, false, DTU);
Changed = true;
break;
}
@ -2306,7 +2297,7 @@ static bool markAliveBlocks(Function &F,
// though.
if (!isa<UnreachableInst>(CI->getNextNode())) {
// Don't insert a call to llvm.trap right before the unreachable.
changeToUnreachable(CI->getNextNode(), false, false, DTU);
changeToUnreachable(CI->getNextNode(), false, DTU);
Changed = true;
}
break;
@ -2325,7 +2316,7 @@ static bool markAliveBlocks(Function &F,
(isa<ConstantPointerNull>(Ptr) &&
!NullPointerIsDefined(SI->getFunction(),
SI->getPointerAddressSpace()))) {
changeToUnreachable(SI, true, false, DTU);
changeToUnreachable(SI, false, DTU);
Changed = true;
break;
}
@ -2339,7 +2330,7 @@ static bool markAliveBlocks(Function &F,
if ((isa<ConstantPointerNull>(Callee) &&
!NullPointerIsDefined(BB->getParent())) ||
isa<UndefValue>(Callee)) {
changeToUnreachable(II, true, false, DTU);
changeToUnreachable(II, false, DTU);
Changed = true;
} else if (II->doesNotThrow() && canSimplifyInvokeNoUnwind(&F)) {
if (II->use_empty() && II->onlyReadsMemory()) {

2
lib/Transforms/Utils/LoopSimplify.cpp
View File

@ -513,7 +513,7 @@ ReprocessLoop:
// Zap the dead pred's terminator and replace it with unreachable.
Instruction *TI = P->getTerminator();
changeToUnreachable(TI, /*UseLLVMTrap=*/false, PreserveLCSSA,
changeToUnreachable(TI, PreserveLCSSA,
/*DTU=*/nullptr, MSSAU);
Changed = true;
}

3
lib/Transforms/Utils/LoopUnroll.cpp
View File

@ -739,8 +739,7 @@ LoopUnrollResult llvm::UnrollLoop(Loop *L, UnrollLoopOptions ULO, LoopInfo *LI,
// When completely unrolling, the last latch becomes unreachable.
if (!LatchIsExiting && CompletelyUnroll)
changeToUnreachable(Latches.back()->getTerminator(), /* UseTrap */ false,
PreserveLCSSA, &DTU);
changeToUnreachable(Latches.back()->getTerminator(), PreserveLCSSA, &DTU);
// Merge adjacent basic blocks, if possible.
for (BasicBlock *Latch : Latches) {

4
lib/Transforms/Utils/LoopUtils.cpp
View File

@ -723,8 +723,8 @@ void llvm::breakLoopBackedge(Loop *L, DominatorTree &DT, ScalarEvolution &SE,
auto *BackedgeBB = SplitEdge(Latch, Header, &DT, &LI, MSSAU.get());
DomTreeUpdater DTU(&DT, DomTreeUpdater::UpdateStrategy::Eager);
(void)changeToUnreachable(BackedgeBB->getTerminator(), /*UseTrap*/false,
/*PreserveLCSSA*/true, &DTU, MSSAU.get());
(void)changeToUnreachable(BackedgeBB->getTerminator(),
/*PreserveLCSSA*/ true, &DTU, MSSAU.get());
// Erase (and destroy) this loop instance. Handles relinking sub-loops
// and blocks within the loop as needed.

7
test/CodeGen/ARM/vmul.ll
View File

@ -731,11 +731,6 @@ define i16 @vmullWithInconsistentExtensions(<8 x i8> %vec) {
define void @vmull_buildvector() nounwind optsize ssp align 2 {
; CHECK-LABEL: vmull_buildvector:
; CHECK: @ %bb.0: @ %entry
; CHECK-NEXT: mov r0, #0
; CHECK-NEXT: cmp r0, #0
; CHECK-NEXT: bxne lr
; CHECK-NEXT: .LBB55_1: @ %for.body33.lr.ph
; CHECK-NEXT: .inst 0xe7ffdefe
entry:
br i1 undef, label %for.end179, label %for.body.lr.ph
@ -812,7 +807,6 @@ declare <8 x i8> @llvm.arm.neon.vqmovnu.v8i8(<8 x i16>) nounwind readnone
define void @no_illegal_types_vmull_sext(<4 x i32> %a) {
; CHECK-LABEL: no_illegal_types_vmull_sext:
; CHECK: @ %bb.0: @ %entry
; CHECK-NEXT: .inst 0xe7ffdefe
entry:
%wide.load283.i = load <4 x i8>, <4 x i8>* undef, align 1
%0 = sext <4 x i8> %wide.load283.i to <4 x i32>
@ -825,7 +819,6 @@ entry:
define void @no_illegal_types_vmull_zext(<4 x i32> %a) {
; CHECK-LABEL: no_illegal_types_vmull_zext:
; CHECK: @ %bb.0: @ %entry
; CHECK-NEXT: .inst 0xe7ffdefe
entry:
%wide.load283.i = load <4 x i8>, <4 x i8>* undef, align 1
%0 = zext <4 x i8> %wide.load283.i to <4 x i32>

6
test/CodeGen/Hexagon/swp-art-deps-rec.ll
View File

@ -3,6 +3,12 @@
; RUN: llc -march=hexagon -mcpu=hexagonv65 -O3 -debug-only=pipeliner \
; RUN: < %s 2>&1 -pipeliner-experimental-cg=true | FileCheck %s
; As part of https://reviews.llvm.org/D106308 this test broke.
; It is not surprising as the tts is full of UB and run with O3.
; FIXME: It is unclear what to do with this test now, replacing null/undef
; with pointer arguments could be a way to go.
; XFAIL: *
; Test that the artificial dependences are ignored while computing the
; circuits.

2
test/CodeGen/Thumb2/ifcvt-rescan-diamonds.ll
View File

@ -1,4 +1,4 @@
; RUN: llc -O2 -o - %s | FileCheck %s
; RUN: llc -O2 -arm-atomic-cfg-tidy=0 -o - %s | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
target triple = "thumbv8-unknown-linux-gnueabihf"

6
test/Transforms/SimplifyCFG/invoke.ll
View File

@ -13,7 +13,6 @@ declare i32 @fn()
define i8* @f1() nounwind uwtable ssp personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
; CHECK-LABEL: @f1(
; CHECK-NEXT: entry:
; CHECK-NEXT: call void @llvm.trap()
; CHECK-NEXT: unreachable
;
entry:
@ -34,7 +33,6 @@ lpad:
define i8* @f2() nounwind uwtable ssp personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
; CHECK-LABEL: @f2(
; CHECK-NEXT: entry:
; CHECK-NEXT: call void @llvm.trap()
; CHECK-NEXT: unreachable
;
entry:
@ -63,7 +61,7 @@ define i8* @f2_no_null_opt() nounwind uwtable ssp #0 personality i8* bitcast (i3
; CHECK-NEXT: [[TMP0:%.*]] = landingpad { i8*, i32 }
; CHECK-NEXT: filter [0 x i8*] zeroinitializer
; CHECK-NEXT: [[TMP1:%.*]] = extractvalue { i8*, i32 } [[TMP0]], 0
; CHECK-NEXT: tail call void @__cxa_call_unexpected(i8* [[TMP1]]) #[[ATTR6:[0-9]+]]
; CHECK-NEXT: tail call void @__cxa_call_unexpected(i8* [[TMP1]]) #[[ATTR5:[0-9]+]]
; CHECK-NEXT: unreachable
;
entry:
@ -138,7 +136,7 @@ define i32 @f5(i1 %cond, i8* %a, i8* %b) personality i8* bitcast (i32 (...)* @__
; CHECK: lpad:
; CHECK-NEXT: [[TMP0:%.*]] = landingpad { i8*, i32 }
; CHECK-NEXT: filter [0 x i8*] zeroinitializer
; CHECK-NEXT: tail call void @__cxa_call_unexpected(i8* [[A:%.*]]) #[[ATTR6]]
; CHECK-NEXT: tail call void @__cxa_call_unexpected(i8* [[A:%.*]]) #[[ATTR5]]
; CHECK-NEXT: unreachable
;
entry:

4
test/Transforms/SimplifyCFG/trap-debugloc.ll
View File

@ -1,8 +1,8 @@
; RUN: opt -S -simplifycfg -simplifycfg-require-and-preserve-domtree=1 < %s | FileCheck %s
; Radar 9342286
; Assign DebugLoc to trap instruction.
; Assign DebugLoc to unreachable instruction.
define void @foo() nounwind ssp !dbg !0 {
; CHECK: call void @llvm.trap(), !dbg
; CHECK: unreachable, !dbg
store i32 42, i32* null, !dbg !5
ret void, !dbg !7
}

1
test/Transforms/SimplifyCFG/trapping-load-unreachable.ll
View File

@ -52,7 +52,6 @@ return: ; preds = %entry
define void @test2() nounwind {
; CHECK-LABEL: @test2(
; CHECK-NEXT: entry:
; CHECK-NEXT: call void @llvm.trap()
; CHECK-NEXT: unreachable
;
entry:

2
unittests/Transforms/Utils/LocalTest.cpp
View File

@ -623,7 +623,7 @@ TEST(Local, ChangeToUnreachable) {
ASSERT_TRUE(isa<ReturnInst>(&A));
// One instruction should be affected.
EXPECT_EQ(changeToUnreachable(&A, /*UseLLVMTrap*/false), 1U);
EXPECT_EQ(changeToUnreachable(&A), 1U);
Instruction &B = BB.front();