This is an archive of the discontinued LLVM Phabricator instance.

Differential D9684

[WinEH] Handle the case of nested landing pads that return to a block in the parent function.
ClosedPublic

Authored by andrew.w.kaylor on May 11 2015, 3:16 PM.

Details

Reviewers
majnemer
rnk
Commits
rGcc14f387e83b: [WinEH] Handle nested landing pads that return directly to the parent function.
rL237063: [WinEH] Handle nested landing pads that return directly to the parent function.
Summary

This adds support for preserving the correct control flow representation in the case where a nested landing pad returns to a block in the parent function. This can happen, for instance, in a case where the landing pad in question originally enclosed the handler in which it is nested in the user's source code but can only be reached from the enclosed landing pad. The following code is an example:

void test1() {
  try {
    try {
      throw 1;
    } catch(...) { throw; }
  } catch (...) { }
}

In such a case, we must represent the block to which the "nested" landing pad returns as a possible target of the landing pad in which it is enclosed in order to prevent the target block from being eliminated as dead code.

This patch only handles to case described at the WinEHPrepare level. There are still problem executing a program which includes the case above, but I can reproduce the same failures without the scenario that this patch is meant to address.

Diff Detail

Repository
rL LLVM

Event Timeline

andrew.w.kaylor updated this revision to Diff 25517.May 11 2015, 3:16 PM
andrew.w.kaylor retitled this revision from to [WinEH] Handle the case of nested landing pads that return to a block in the parent function..
andrew.w.kaylor updated this object.
andrew.w.kaylor edited the test plan for this revision. (Show Details)
andrew.w.kaylor added reviewers: rnk, majnemer.
andrew.w.kaylor set the repository for this revision to rL LLVM.
andrew.w.kaylor added a subscriber: Unknown Object (MLST).
rnk accepted this revision.May 11 2015, 3:51 PM
rnk edited edge metadata.

LGTM

lib/CodeGen/WinEHPrepare.cpp
894 ↗(On Diff #25517)

wrap

This revision is now accepted and ready to land.May 11 2015, 3:51 PM
Closed by commit rL237063: [WinEH] Handle nested landing pads that return directly to the parent function. (authored by akaylor). · Explain WhyMay 11 2015, 4:09 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
trunk/
lib/
CodeGen/
114 lines
test/
CodeGen/
WinEH/
2 lines
2 lines
4 lines
2 lines
214 lines

Diff 25520

llvm/trunk/lib/CodeGen/WinEHPrepare.cpp

Show First 20 Lines • Show All 92 Lines • ▼ Show 20 Lines bool prepareExceptionHandlers(Function &F,
SmallVectorImpl<LandingPadInst *> &LPads); SmallVectorImpl<LandingPadInst *> &LPads);
void promoteLandingPadValues(LandingPadInst *LPad); void promoteLandingPadValues(LandingPadInst *LPad);
void demoteValuesLiveAcrossHandlers(Function &F, void demoteValuesLiveAcrossHandlers(Function &F,
SmallVectorImpl<LandingPadInst *> &LPads); SmallVectorImpl<LandingPadInst *> &LPads);
void findSEHEHReturnPoints(Function &F, void findSEHEHReturnPoints(Function &F,
SetVector<BasicBlock *> &EHReturnBlocks); SetVector<BasicBlock *> &EHReturnBlocks);
void findCXXEHReturnPoints(Function &F, void findCXXEHReturnPoints(Function &F,
SetVector<BasicBlock *> &EHReturnBlocks); SetVector<BasicBlock *> &EHReturnBlocks);
void getPossibleReturnTargets(Function *ParentF, Function *HandlerF,
SetVector<BasicBlock*> &Targets);
void completeNestedLandingPad(Function *ParentFn, void completeNestedLandingPad(Function *ParentFn,
LandingPadInst *OutlinedLPad, LandingPadInst *OutlinedLPad,
const LandingPadInst *OriginalLPad, const LandingPadInst *OriginalLPad,
FrameVarInfoMap &VarInfo); FrameVarInfoMap &VarInfo);
Function *createHandlerFunc(Type *RetTy, const Twine &Name, Module *M, Function *createHandlerFunc(Type *RetTy, const Twine &Name, Module *M,
Value *&ParentFP); Value *&ParentFP);
bool outlineHandler(ActionHandler *Action, Function *SrcFn, bool outlineHandler(ActionHandler *Action, Function *SrcFn,
LandingPadInst *LPad, BasicBlock *StartBB, LandingPadInst *LPad, BasicBlock *StartBB,
▲ Show 20 Lines • Show All 586 Lines • ▼ Show 20 Linesbool WinEHPrepare::prepareExceptionHandlers(
if (isAsynchronousEHPersonality(Personality)) { if (isAsynchronousEHPersonality(Personality)) {
// FIXME: Switch the ehptr type to i32 and then switch this. // FIXME: Switch the ehptr type to i32 and then switch this.
SEHExceptionCodeSlot = SEHExceptionCodeSlot =
new AllocaInst(Int8PtrType, nullptr, "seh_exception_code", new AllocaInst(Int8PtrType, nullptr, "seh_exception_code",
F.getEntryBlock().getFirstInsertionPt()); F.getEntryBlock().getFirstInsertionPt());
} }
// This container stores the llvm.eh.recover and IndirectBr instructions
// that make up the body of each landing pad after it has been outlined.
// We need to defer the population of the target list for the indirectbr
// until all landing pads have been outlined so that we can handle the
// case of blocks in the target that are reached only from nested
// landing pads.
SmallVector<std::pair<CallInst*, IndirectBrInst *>, 4> LPadImpls;
for (LandingPadInst *LPad : LPads) { for (LandingPadInst *LPad : LPads) {
// Look for evidence that this landingpad has already been processed. // Look for evidence that this landingpad has already been processed.
bool LPadHasActionList = false; bool LPadHasActionList = false;
BasicBlock *LPadBB = LPad->getParent(); BasicBlock *LPadBB = LPad->getParent();
for (Instruction &Inst : *LPadBB) { for (Instruction &Inst : *LPadBB) {
if (match(&Inst, m_Intrinsic<Intrinsic::eh_actions>())) { if (match(&Inst, m_Intrinsic<Intrinsic::eh_actions>())) {
LPadHasActionList = true; LPadHasActionList = true;
break; break;
▲ Show 20 Lines • Show All 103 Lines • ▼ Show 20 Lines for (ActionHandler *Action : Actions) {
} else { } else {
ActionArgs.push_back(ConstantInt::get(Int32Type, 0)); ActionArgs.push_back(ConstantInt::get(Int32Type, 0));
} }
ActionArgs.push_back(Action->getHandlerBlockOrFunc()); ActionArgs.push_back(Action->getHandlerBlockOrFunc());
} }
CallInst *Recover = CallInst *Recover =
CallInst::Create(ActionIntrin, ActionArgs, "recover", LPadBB); CallInst::Create(ActionIntrin, ActionArgs, "recover", LPadBB);
// Add an indirect branch listing possible successors of the catch handlers. if (isAsynchronousEHPersonality(Personality)) {
// SEH can create the target list directly, since catch handlers
// are not outlined.
SetVector<BasicBlock *> ReturnTargets; SetVector<BasicBlock *> ReturnTargets;
for (ActionHandler *Action : Actions) { for (ActionHandler *Action : Actions) {
if (auto *CatchAction = dyn_cast<CatchHandler>(Action)) { if (auto *CatchAction = dyn_cast<CatchHandler>(Action)) {
const auto &CatchTargets = CatchAction->getReturnTargets(); const auto &CatchTargets = CatchAction->getReturnTargets();
ReturnTargets.insert(CatchTargets.begin(), CatchTargets.end()); ReturnTargets.insert(CatchTargets.begin(), CatchTargets.end());
} }
} }
IndirectBrInst *Branch = IndirectBrInst *Branch =
IndirectBrInst::Create(Recover, ReturnTargets.size(), LPadBB); IndirectBrInst::Create(Recover, ReturnTargets.size(), LPadBB);
for (BasicBlock *Target : ReturnTargets) for (BasicBlock *Target : ReturnTargets)
Branch->addDestination(Target); Branch->addDestination(Target);
} else {
// C++ EH must defer populating the targets to handle the case of
// targets that are reached indirectly through nested landing pads.
IndirectBrInst *Branch =
IndirectBrInst::Create(Recover, 0, LPadBB);
LPadImpls.push_back(std::make_pair(Recover, Branch));
}
} // End for each landingpad } // End for each landingpad
// If nothing got outlined, there is no more processing to be done. // If nothing got outlined, there is no more processing to be done.
if (!HandlersOutlined) if (!HandlersOutlined)
return false; return false;
// Replace any nested landing pad stubs with the correct action handler. // Replace any nested landing pad stubs with the correct action handler.
// This must be done before we remove unreachable blocks because it // This must be done before we remove unreachable blocks because it
// cleans up references to outlined blocks that will be deleted. // cleans up references to outlined blocks that will be deleted.
for (auto &LPadPair : NestedLPtoOriginalLP) for (auto &LPadPair : NestedLPtoOriginalLP)
completeNestedLandingPad(&F, LPadPair.first, LPadPair.second, FrameVarInfo); completeNestedLandingPad(&F, LPadPair.first, LPadPair.second, FrameVarInfo);
NestedLPtoOriginalLP.clear(); NestedLPtoOriginalLP.clear();
// Populate the indirectbr instructions' target lists if we deferred
// doing so above.
SetVector<BasicBlock*> CheckedTargets;
for (auto &LPadImplPair : LPadImpls) {
IntrinsicInst *Recover = cast<IntrinsicInst>(LPadImplPair.first);
IndirectBrInst *Branch = LPadImplPair.second;
// Get a list of handlers called by
SmallVector<ActionHandler *, 4> ActionList;
parseEHActions(Recover, ActionList);
// Add an indirect branch listing possible successors of the catch handlers.
SetVector<BasicBlock *> ReturnTargets;
for (ActionHandler *Action : ActionList) {
if (auto *CA = dyn_cast<CatchHandler>(Action)) {
Function *Handler = cast<Function>(CA->getHandlerBlockOrFunc());
getPossibleReturnTargets(&F, Handler, ReturnTargets);
}
}
for (BasicBlock *Target : ReturnTargets) {
Branch->addDestination(Target);
// The target may be a block that we excepted to get pruned.
// If it is, it may contain a call to llvm.eh.endcatch.
if (CheckedTargets.insert(Target)) {
// Earlier preparations guarantee that all calls to llvm.eh.endcatch
// will be followed by an unconditional branch.
auto *Br = dyn_cast<BranchInst>(Target->getTerminator());
if (Br && Br->isUnconditional() &&
Br != Target->getFirstNonPHIOrDbgOrLifetime()) {
Instruction *Prev = Br->getPrevNode();
if (match(cast<Value>(Prev), m_Intrinsic<Intrinsic::eh_endcatch>()))
Prev->eraseFromParent();
}
}
}
}
LPadImpls.clear();
F.addFnAttr("wineh-parent", F.getName()); F.addFnAttr("wineh-parent", F.getName());
// Delete any blocks that were only used by handlers that were outlined above. // Delete any blocks that were only used by handlers that were outlined above.
removeUnreachableBlocks(F); removeUnreachableBlocks(F);
BasicBlock *Entry = &F.getEntryBlock(); BasicBlock *Entry = &F.getEntryBlock();
IRBuilder<> Builder(F.getParent()->getContext()); IRBuilder<> Builder(F.getParent()->getContext());
Builder.SetInsertPoint(Entry->getFirstInsertionPt()); Builder.SetInsertPoint(Entry->getFirstInsertionPt());
▲ Show 20 Lines • Show All 116 Lines • ▼ Show 20 Linesvoid WinEHPrepare::promoteLandingPadValues(LandingPadInst *LPad) {
} }
// After promotion, some extracts may be trivially dead. Remove them. // After promotion, some extracts may be trivially dead. Remove them.
SmallVector<Value *, 4> Users(LPad->user_begin(), LPad->user_end()); SmallVector<Value *, 4> Users(LPad->user_begin(), LPad->user_end());
for (auto *U : Users) for (auto *U : Users)
RecursivelyDeleteTriviallyDeadInstructions(U); RecursivelyDeleteTriviallyDeadInstructions(U);
} }
void WinEHPrepare::getPossibleReturnTargets(Function *ParentF,
Function *HandlerF,
SetVector<BasicBlock*> &Targets) {
for (BasicBlock &BB : *HandlerF) {
// If the handler contains landing pads, check for any
// handlers that may return directly to a block in the
// parent function.
if (auto *LPI = BB.getLandingPadInst()) {
IntrinsicInst *Recover = cast<IntrinsicInst>(LPI->getNextNode());
SmallVector<ActionHandler *, 4> ActionList;
parseEHActions(Recover, ActionList);
for (auto *Action : ActionList) {
if (auto *CH = dyn_cast<CatchHandler>(Action)) {
Function *NestedF = cast<Function>(CH->getHandlerBlockOrFunc());
getPossibleReturnTargets(ParentF, NestedF, Targets);
}
}
}
auto *Ret = dyn_cast<ReturnInst>(BB.getTerminator());
if (!Ret)
continue;
// Handler functions must always return a block address.
BlockAddress *BA = cast<BlockAddress>(Ret->getReturnValue());
// If this is the handler for a nested landing pad, the
// return address may have been remapped to a block in the
// parent handler. We're not interested in those.
if (BA->getFunction() != ParentF)
continue;
Targets.insert(BA->getBasicBlock());
}
}
void WinEHPrepare::completeNestedLandingPad(Function *ParentFn, void WinEHPrepare::completeNestedLandingPad(Function *ParentFn,
LandingPadInst *OutlinedLPad, LandingPadInst *OutlinedLPad,
const LandingPadInst *OriginalLPad, const LandingPadInst *OriginalLPad,
FrameVarInfoMap &FrameVarInfo) { FrameVarInfoMap &FrameVarInfo) {
// Get the nested block and erase the unreachable instruction that was // Get the nested block and erase the unreachable instruction that was
// temporarily inserted as its terminator. // temporarily inserted as its terminator.
LLVMContext &Context = ParentFn->getContext(); LLVMContext &Context = ParentFn->getContext();
BasicBlock *OutlinedBB = OutlinedLPad->getParent(); BasicBlock *OutlinedBB = OutlinedLPad->getParent();
▲ Show 20 Lines • Show All 1,269 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WinEH/cppeh-catch-unwind.ll

Show First 20 Lines • Show All 92 Lines • ▼ Show 20 Lineslpad1: ; preds = %invoke.cont
%7 = extractvalue { i8*, i32 } %5, 1 %7 = extractvalue { i8*, i32 } %5, 1
br label %ehcleanup br label %ehcleanup
; CHECK: [[LPAD3_LABEL]]:{{[ ]+}}; preds = %invoke.cont2 ; CHECK: [[LPAD3_LABEL]]:{{[ ]+}}; preds = %invoke.cont2
; CHECK: [[LPAD3_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) ; CHECK: [[LPAD3_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
; CHECK-NEXT: cleanup ; CHECK-NEXT: cleanup
; CHECK-NEXT: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*) ; CHECK-NEXT: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
; CHECK-NEXT: [[RECOVER3:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32 2, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch1", i32 0, void (i8*, i8*)* @"\01?test@@YAXXZ.cleanup") ; CHECK-NEXT: [[RECOVER3:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32 2, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch1", i32 0, void (i8*, i8*)* @"\01?test@@YAXXZ.cleanup")
; CHECK-NEXT: indirectbr i8* [[RECOVER3]], [label %try.cont] ; CHECK-NEXT: indirectbr i8* [[RECOVER3]], [label %try.cont, label %try.cont15]
lpad3: ; preds = %invoke.cont2 lpad3: ; preds = %invoke.cont2
%8 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) %8 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
cleanup cleanup
catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*) catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
%9 = extractvalue { i8*, i32 } %8, 0 %9 = extractvalue { i8*, i32 } %8, 0
%10 = extractvalue { i8*, i32 } %8, 1 %10 = extractvalue { i8*, i32 } %8, 1
%11 = call i32 @llvm.eh.typeid.for(i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)) #3 %11 = call i32 @llvm.eh.typeid.for(i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)) #3
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WinEH/cppeh-nested-1.ll

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
invoke.cont: ; preds = %entry invoke.cont: ; preds = %entry
br label %try.cont br label %try.cont
; CHECK: [[LPAD_LABEL]]: ; CHECK: [[LPAD_LABEL]]:
; CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) ; CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*) ; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*) ; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
; CHECK: [[RECOVER:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32 0, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch", i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), i32 1, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch1") ; CHECK: [[RECOVER:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32 0, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch", i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), i32 1, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch1")
; CHECK: indirectbr i8* [[RECOVER]], [label %try.cont, label %try.cont10] ; CHECK: indirectbr i8* [[RECOVER]], [label %try.cont10, label %try.cont]
lpad: ; preds = %entry lpad: ; preds = %entry
%0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*) catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*) catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
%1 = extractvalue { i8*, i32 } %0, 0 %1 = extractvalue { i8*, i32 } %0, 0
store i8* %1, i8** %exn.slot store i8* %1, i8** %exn.slot
%2 = extractvalue { i8*, i32 } %0, 1 %2 = extractvalue { i8*, i32 } %0, 1
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WinEH/cppeh-nested-2.ll

Show First 20 Lines • Show All 108 Lines • ▼ Show 20 Lines
; CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) ; CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
; CHECK-NEXT: cleanup ; CHECK-NEXT: cleanup
; CHECK-NEXT: catch i8* bitcast (i8** @_ZTIi to i8*) ; CHECK-NEXT: catch i8* bitcast (i8** @_ZTIi to i8*)
; CHECK-NEXT: catch i8* bitcast (i8** @_ZTIf to i8*) ; CHECK-NEXT: catch i8* bitcast (i8** @_ZTIf to i8*)
; CHECK-NEXT: [[RECOVER1:\%.+]] = call i8* (...) @llvm.eh.actions( ; CHECK-NEXT: [[RECOVER1:\%.+]] = call i8* (...) @llvm.eh.actions(
; CHECK-SAME: i32 1, i8* bitcast (i8** @_ZTIi to i8*), i32 1, i8* (i8*, i8*)* @_Z4testv.catch1, ; CHECK-SAME: i32 1, i8* bitcast (i8** @_ZTIi to i8*), i32 1, i8* (i8*, i8*)* @_Z4testv.catch1,
; CHECK-SAME: i32 0, void (i8*, i8*)* @_Z4testv.cleanup, ; CHECK-SAME: i32 0, void (i8*, i8*)* @_Z4testv.cleanup,
; CHECK-SAME: i32 1, i8* bitcast (i8** @_ZTIf to i8*), i32 0, i8* (i8*, i8*)* @_Z4testv.catch) ; CHECK-SAME: i32 1, i8* bitcast (i8** @_ZTIf to i8*), i32 0, i8* (i8*, i8*)* @_Z4testv.catch)
; CHECK-NEXT: indirectbr i8* [[RECOVER1]], [label %try.cont, label %try.cont19] ; CHECK-NEXT: indirectbr i8* [[RECOVER1]], [label %try.cont19, label %try.cont]
lpad1: ; preds = %invoke.cont4, %invoke.cont lpad1: ; preds = %invoke.cont4, %invoke.cont
%tmp3 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) %tmp3 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
cleanup cleanup
catch i8* bitcast (i8** @_ZTIi to i8*) catch i8* bitcast (i8** @_ZTIi to i8*)
catch i8* bitcast (i8** @_ZTIf to i8*) catch i8* bitcast (i8** @_ZTIf to i8*)
%tmp4 = extractvalue { i8*, i32 } %tmp3, 0 %tmp4 = extractvalue { i8*, i32 } %tmp3, 0
store i8* %tmp4, i8** %exn.slot store i8* %tmp4, i8** %exn.slot
%tmp5 = extractvalue { i8*, i32 } %tmp3, 1 %tmp5 = extractvalue { i8*, i32 } %tmp3, 1
store i32 %tmp5, i32* %ehselector.slot store i32 %tmp5, i32* %ehselector.slot
br label %catch.dispatch br label %catch.dispatch
; CHECK: [[LPAD3_LABEL]]: ; CHECK: [[LPAD3_LABEL]]:
; CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) ; CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
; CHECK-NEXT: cleanup ; CHECK-NEXT: cleanup
; CHECK-NEXT: catch i8* bitcast (i8** @_ZTIi to i8*) ; CHECK-NEXT: catch i8* bitcast (i8** @_ZTIi to i8*)
; CHECK-NEXT: catch i8* bitcast (i8** @_ZTIf to i8*) ; CHECK-NEXT: catch i8* bitcast (i8** @_ZTIf to i8*)
; CHECK-NEXT: [[RECOVER3:\%.+]] = call i8* (...) @llvm.eh.actions( ; CHECK-NEXT: [[RECOVER3:\%.+]] = call i8* (...) @llvm.eh.actions(
; CHECK-SAME: i32 0, void (i8*, i8*)* @_Z4testv.cleanup2, ; CHECK-SAME: i32 0, void (i8*, i8*)* @_Z4testv.cleanup2,
; CHECK-SAME: i32 1, i8* bitcast (i8** @_ZTIi to i8*), i32 1, i8* (i8*, i8*)* @_Z4testv.catch1, ; CHECK-SAME: i32 1, i8* bitcast (i8** @_ZTIi to i8*), i32 1, i8* (i8*, i8*)* @_Z4testv.catch1,
; CHECK-SAME: i32 0, void (i8*, i8*)* @_Z4testv.cleanup, ; CHECK-SAME: i32 0, void (i8*, i8*)* @_Z4testv.cleanup,
; CHECK-SAME: i32 1, i8* bitcast (i8** @_ZTIf to i8*), i32 0, i8* (i8*, i8*)* @_Z4testv.catch) ; CHECK-SAME: i32 1, i8* bitcast (i8** @_ZTIf to i8*), i32 0, i8* (i8*, i8*)* @_Z4testv.catch)
; CHECK-NEXT: indirectbr i8* [[RECOVER3]], [label %try.cont, label %try.cont19] ; CHECK-NEXT: indirectbr i8* [[RECOVER3]], [label %try.cont19, label %try.cont]
lpad3: ; preds = %invoke.cont2 lpad3: ; preds = %invoke.cont2
%tmp6 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) %tmp6 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
cleanup cleanup
catch i8* bitcast (i8** @_ZTIi to i8*) catch i8* bitcast (i8** @_ZTIi to i8*)
catch i8* bitcast (i8** @_ZTIf to i8*) catch i8* bitcast (i8** @_ZTIf to i8*)
%tmp7 = extractvalue { i8*, i32 } %tmp6, 0 %tmp7 = extractvalue { i8*, i32 } %tmp6, 0
store i8* %tmp7, i8** %exn.slot store i8* %tmp7, i8** %exn.slot
▲ Show 20 Lines • Show All 176 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WinEH/cppeh-nested-3.ll

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines
invoke.cont: ; preds = %entry invoke.cont: ; preds = %entry
br label %try.cont10 br label %try.cont10
; CHECK: [[LPAD_LABEL]]: ; CHECK: [[LPAD_LABEL]]:
; CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) ; CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*) ; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*) ; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
; CHECK: [[RECOVER:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32 0, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch", i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), i32 1, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch1") ; CHECK: [[RECOVER:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32 0, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch", i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), i32 1, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch1")
; CHECK: indirectbr i8* [[RECOVER]], [label %try.cont10, label %try.cont19] ; CHECK: indirectbr i8* [[RECOVER]], [label %try.cont19, label %try.cont10]
lpad: ; preds = %entry lpad: ; preds = %entry
%0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*) catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*) catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
%1 = extractvalue { i8*, i32 } %0, 0 %1 = extractvalue { i8*, i32 } %0, 0
store i8* %1, i8** %exn.slot store i8* %1, i8** %exn.slot
%2 = extractvalue { i8*, i32 } %0, 1 %2 = extractvalue { i8*, i32 } %0, 1
▲ Show 20 Lines • Show All 186 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/WinEH/cppeh-nested-rethrow.ll

; RUN: opt -mtriple=x86_64-pc-windows-msvc -winehprepare -S -o - < %s | FileCheck %s
; This test was generated from the following code.
;
; void test1() {
; try {
; try {
; throw 1;
; } catch(...) { throw; }
; } catch (...) { }
; }
; void test2() {
; try {
; throw 1;
; } catch(...) {
; try {
; throw;
; } catch (...) {}
; }
; }
;
; These two functions result in functionally equivalent code, but the last
; catch block contains a call to llvm.eh.endcatch that tripped up processing
; during development.
;
; The main purpose of this test is to verify that we can correctly
; handle the case of nested landing pads that return directly to a block in
; the parent function.
; ModuleID = 'cppeh-nested-rethrow.cpp'
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc"
%rtti.TypeDescriptor2 = type { i8**, i8*, [3 x i8] }
%eh.CatchableType = type { i32, i32, i32, i32, i32, i32, i32 }
%eh.CatchableTypeArray.1 = type { i32, [1 x i32] }
%eh.ThrowInfo = type { i32, i32, i32, i32 }
$"\01??_R0H@8" = comdat any
$"_CT??_R0H@84" = comdat any
$_CTA1H = comdat any
$_TI1H = comdat any
@"\01??_7type_info@@6B@" = external constant i8*
@"\01??_R0H@8" = linkonce_odr global %rtti.TypeDescriptor2 { i8** @"\01??_7type_info@@6B@", i8* null, [3 x i8] c".H\00" }, comdat
@__ImageBase = external constant i8
@"_CT??_R0H@84" = linkonce_odr unnamed_addr constant %eh.CatchableType { i32 1, i32 trunc (i64 sub nuw nsw (i64 ptrtoint (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i64), i64 ptrtoint (i8* @__ImageBase to i64)) to i32), i32 0, i32 -1, i32 0, i32 4, i32 0 }, section ".xdata", comdat
@_CTA1H = linkonce_odr unnamed_addr constant %eh.CatchableTypeArray.1 { i32 1, [1 x i32] [i32 trunc (i64 sub nuw nsw (i64 ptrtoint (%eh.CatchableType* @"_CT??_R0H@84" to i64), i64 ptrtoint (i8* @__ImageBase to i64)) to i32)] }, section ".xdata", comdat
@_TI1H = linkonce_odr unnamed_addr constant %eh.ThrowInfo { i32 0, i32 0, i32 0, i32 trunc (i64 sub nuw nsw (i64 ptrtoint (%eh.CatchableTypeArray.1* @_CTA1H to i64), i64 ptrtoint (i8* @__ImageBase to i64)) to i32) }, section ".xdata", comdat
; CHECK-LABEL: define void @"\01?test1@@YAXXZ"()
; CHECK: entry:
; CHECK: call void (...) @llvm.frameescape
; Function Attrs: nounwind uwtable
define void @"\01?test1@@YAXXZ"() #0 {
entry:
%tmp = alloca i32, align 4
%exn.slot = alloca i8*
%ehselector.slot = alloca i32
store i32 1, i32* %tmp
%0 = bitcast i32* %tmp to i8*
invoke void @_CxxThrowException(i8* %0, %eh.ThrowInfo* @_TI1H) #2
to label %unreachable unwind label %lpad
lpad: ; preds = %entry
%1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
catch i8* null
%2 = extractvalue { i8*, i32 } %1, 0
store i8* %2, i8** %exn.slot
%3 = extractvalue { i8*, i32 } %1, 1
store i32 %3, i32* %ehselector.slot
br label %catch
catch: ; preds = %lpad
%exn = load i8*, i8** %exn.slot
call void @llvm.eh.begincatch(i8* %exn, i8* null) #1
invoke void @_CxxThrowException(i8* null, %eh.ThrowInfo* null) #2
to label %unreachable unwind label %lpad1
lpad1: ; preds = %catch
%4 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
catch i8* null
%5 = extractvalue { i8*, i32 } %4, 0
store i8* %5, i8** %exn.slot
%6 = extractvalue { i8*, i32 } %4, 1
store i32 %6, i32* %ehselector.slot
br label %catch2
catch2: ; preds = %lpad1
%exn3 = load i8*, i8** %exn.slot
call void @llvm.eh.begincatch(i8* %exn3, i8* null) #1
call void @llvm.eh.endcatch() #1
br label %try.cont4
; This block should not be eliminated.
; CHECK: try.cont4:
try.cont4: ; preds = %catch2, %try.cont
ret void
try.cont: ; No predecessors!
br label %try.cont4
unreachable: ; preds = %catch, %entry
unreachable
; CHECK: }
}
declare void @_CxxThrowException(i8*, %eh.ThrowInfo*)
declare i32 @__CxxFrameHandler3(...)
; Function Attrs: nounwind
declare void @llvm.eh.begincatch(i8* nocapture, i8* nocapture) #1
; Function Attrs: nounwind
declare void @llvm.eh.endcatch() #1
; CHECK-LABEL: define void @"\01?test2@@YAXXZ"()
; CHECK: entry:
; CHECK: call void (...) @llvm.frameescape
; Function Attrs: nounwind uwtable
define void @"\01?test2@@YAXXZ"() #0 {
entry:
%tmp = alloca i32, align 4
%exn.slot = alloca i8*
%ehselector.slot = alloca i32
store i32 1, i32* %tmp
%0 = bitcast i32* %tmp to i8*
invoke void @_CxxThrowException(i8* %0, %eh.ThrowInfo* @_TI1H) #2
to label %unreachable unwind label %lpad
lpad: ; preds = %entry
%1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
catch i8* null
%2 = extractvalue { i8*, i32 } %1, 0
store i8* %2, i8** %exn.slot
%3 = extractvalue { i8*, i32 } %1, 1
store i32 %3, i32* %ehselector.slot
br label %catch
catch: ; preds = %lpad
%exn = load i8*, i8** %exn.slot
call void @llvm.eh.begincatch(i8* %exn, i8* null) #1
invoke void @_CxxThrowException(i8* null, %eh.ThrowInfo* null) #2
to label %unreachable unwind label %lpad1
lpad1: ; preds = %catch
%4 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
catch i8* null
%5 = extractvalue { i8*, i32 } %4, 0
store i8* %5, i8** %exn.slot
%6 = extractvalue { i8*, i32 } %4, 1
store i32 %6, i32* %ehselector.slot
br label %catch2
catch2: ; preds = %lpad1
%exn3 = load i8*, i8** %exn.slot
call void @llvm.eh.begincatch(i8* %exn3, i8* null) #1
call void @llvm.eh.endcatch() #1
br label %try.cont
; This block should not be eliminated.
; CHECK: try.cont:
; The endcatch call should be eliminated.
; CHECK-NOT: call void @llvm.eh.endcatch()
try.cont: ; preds = %catch2
call void @llvm.eh.endcatch() #1
br label %try.cont4
try.cont4: ; preds = %try.cont
ret void
unreachable: ; preds = %catch, %entry
unreachable
; CHECK: }
}
; The outlined test1.catch handler should not contain a return instruction.
; CHECK-LABEL: define internal i8* @"\01?test1@@YAXXZ.catch"(i8*, i8*)
; CHECK-NOT: ret
; CHECK: }
; The outlined test1.catch1 handler should return to a valid block address.
; CHECK-LABEL: define internal i8* @"\01?test1@@YAXXZ.catch1"(i8*, i8*)
; WILL-CHECK: ret i8* inttoptr (
; CHECK-NOT: ret i8* inttoptr (i32 1 to i8*)
; CHECK: }
; The outlined test2.catch handler should not contain a return instruction.
; CHECK-LABEL: define internal i8* @"\01?test2@@YAXXZ.catch"(i8*, i8*)
; CHECK-NOT: ret
; CHECK: }
; The outlined test2.catch1 handler should return to a valid block address.
; CHECK-LABEL: define internal i8* @"\01?test2@@YAXXZ.catch2"(i8*, i8*)
; WILL-CHECK: ret i8* inttoptr (
; CHECK-NOT: ret i8* inttoptr (i32 1 to i8*)
; CHECK: }
attributes #0 = { nounwind uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { nounwind }
attributes #2 = { noreturn }
!llvm.module.flags = !{!0}
!llvm.ident = !{!1}
!0 = !{i32 1, !"PIC Level", i32 2}
!1 = !{!"clang version 3.7.0 (trunk 236059)"}