[llvm] r237854 - [WinEH] C++ EH state numbering fixes
Manuel Klimek
klimek at google.com
Thu May 21 08:42:25 PDT 2015
Fixed in r237906
On Thu, May 21, 2015 at 5:24 PM Manuel Klimek <klimek at google.com> wrote:
> On Thu, May 21, 2015 at 1:28 AM Andrew Kaylor <andrew.kaylor at intel.com>
> wrote:
>
>> Author: akaylor
>> Date: Wed May 20 18:22:24 2015
>> New Revision: 237854
>>
>> URL: http://llvm.org/viewvc/llvm-project?rev=237854&view=rev
>> Log:
>> [WinEH] C++ EH state numbering fixes
>>
>> Differential Revision: http://reviews.llvm.org/D9787
>>
>>
>> Modified:
>> llvm/trunk/include/llvm/CodeGen/WinEHFuncInfo.h
>> llvm/trunk/lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp
>> llvm/trunk/lib/CodeGen/WinEHPrepare.cpp
>> llvm/trunk/test/CodeGen/WinEH/cppeh-nested-1.ll
>> llvm/trunk/test/CodeGen/WinEH/cppeh-nested-2.ll
>> llvm/trunk/test/CodeGen/WinEH/cppeh-nested-3.ll
>> llvm/trunk/test/CodeGen/WinEH/cppeh-nested-rethrow.ll
>> llvm/trunk/test/CodeGen/WinEH/cppeh-similar-catch-blocks.ll
>> llvm/trunk/test/CodeGen/WinEH/cppeh-state-calc-1.ll
>>
>> Modified: llvm/trunk/include/llvm/CodeGen/WinEHFuncInfo.h
>> URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/WinEHFuncInfo.h?rev=237854&r1=237853&r2=237854&view=diff
>>
>> ==============================================================================
>> --- llvm/trunk/include/llvm/CodeGen/WinEHFuncInfo.h (original)
>> +++ llvm/trunk/include/llvm/CodeGen/WinEHFuncInfo.h Wed May 20 18:22:24
>> 2015
>> @@ -131,6 +131,10 @@ struct WinEHTryBlockMapEntry {
>> };
>>
>> struct WinEHFuncInfo {
>> + DenseMap<const Function *, const LandingPadInst *> RootLPad;
>> + DenseMap<const Function *, const InvokeInst *> LastInvoke;
>> + DenseMap<const Function *, int> HandlerEnclosedState;
>> + DenseMap<const Function *, bool> LastInvokeVisited;
>> DenseMap<const LandingPadInst *, int> LandingPadStateMap;
>> DenseMap<const Function *, int> CatchHandlerParentFrameObjIdx;
>> DenseMap<const Function *, int> CatchHandlerParentFrameObjOffset;
>>
>> Modified: llvm/trunk/lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp?rev=237854&r1=237853&r2=237854&view=diff
>>
>> ==============================================================================
>> --- llvm/trunk/lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp
>> (original)
>> +++ llvm/trunk/lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp Wed May
>> 20 18:22:24 2015
>> @@ -101,7 +101,9 @@ struct WinEHNumbering {
>> ArrayRef<CatchHandler *> Handlers);
>> void processCallSite(MutableArrayRef<std::unique_ptr<ActionHandler>>
>> Actions,
>> ImmutableCallSite CS);
>> + void popUnmatchedActions(int FirstMismatch);
>> void calculateStateNumbers(const Function &F);
>> + void findActionRootLPads(const Function &F);
>> };
>> }
>>
>> @@ -297,9 +299,16 @@ void FunctionLoweringInfo::set(const Fun
>> EHInfo = &MMI.getWinEHFuncInfo(WinEHParentFn);
>> if (EHInfo->LandingPadStateMap.empty()) {
>> WinEHNumbering Num(*EHInfo);
>> + Num.findActionRootLPads(*WinEHParentFn);
>> + // The VisitedHandlers list is used by both findActionRootLPads and
>> + // calculateStateNumbers, but both functions need to visit all
>> handlers.
>> + Num.VisitedHandlers.clear();
>> Num.calculateStateNumbers(*WinEHParentFn);
>> // Pop everything on the handler stack.
>> - Num.processCallSite(None, ImmutableCallSite());
>> + // It may be necessary to call this more than once because a
>> handler can
>> + // be pushed on the stack as a result of clearing the stack.
>> + while (!Num.HandlerStack.empty())
>> + Num.processCallSite(None, ImmutableCallSite());
>> }
>>
>> // Copy the state numbers to LandingPadInfo for the current
>> function, which
>> @@ -361,6 +370,45 @@ void WinEHNumbering::createUnwindMapEntr
>>
>> void WinEHNumbering::createTryBlockMapEntry(int TryLow, int TryHigh,
>> ArrayRef<CatchHandler *>
>> Handlers) {
>> + // See if we already have an entry for this set of handlers.
>> + // This is using iterators rather than a range-based for loop because
>> + // if we find the entry we're looking for we'll need the iterator to
>> erase it.
>> + int NumHandlers = Handlers.size();
>> + auto I = FuncInfo.TryBlockMap.begin();
>> + auto E = FuncInfo.TryBlockMap.end();
>> + for ( ; I != E; ++I) {
>> + auto &Entry = *I;
>> + if (Entry.HandlerArray.size() != NumHandlers)
>> + continue;
>> + int N;
>> + for (N = 0; N < NumHandlers; ++N) {
>> + if (Entry.HandlerArray[N].Handler !=
>> Handlers[N]->getHandlerBlockOrFunc())
>> + break; // breaks out of inner loop
>> + }
>> + // If all the handlers match, this is what we were looking for.
>> + if (N == NumHandlers) {
>> + break;
>> + }
>> + }
>> +
>> + // If we found an existing entry for this set of handlers, extend the
>> range
>> + // but move the entry to the end of the map vector. The order of
>> entries
>> + // in the map is critical to the way that the runtime finds handlers.
>> + // FIXME: Depending on what has happened with block ordering, this may
>> + // incorrectly combine entries that should remain separate.
>> + if (I != E) {
>> + // Copy the existing entry.
>> + WinEHTryBlockMapEntry Entry = *I;
>> + Entry.TryLow = std::min(TryLow, Entry.TryLow);
>> + Entry.TryHigh = std::max(TryHigh, Entry.TryHigh);
>> + assert(Entry.TryLow <= Entry.TryHigh);
>> + // Erase the old entry and add this one to the back.
>> + FuncInfo.TryBlockMap.erase(I);
>> + FuncInfo.TryBlockMap.push_back(Entry);
>> + return;
>> + }
>> +
>> + // If we didn't find an entry, create a new one.
>> WinEHTryBlockMapEntry TBME;
>> TBME.TryLow = TryLow;
>> TBME.TryHigh = TryHigh;
>> @@ -429,6 +477,65 @@ void WinEHNumbering::processCallSite(
>> break;
>> }
>>
>> + // Remove unmatched actions from the stack and process their EH states.
>> + popUnmatchedActions(FirstMismatch);
>> +
>> + DEBUG(dbgs() << "Pushing actions for CallSite: ");
>> + print_name(CS ? CS.getCalledValue() : nullptr);
>> + DEBUG(dbgs() << '\n');
>> +
>> + bool LastActionWasCatch = false;
>> + const LandingPadInst *LastRootLPad = nullptr;
>> + for (size_t I = FirstMismatch; I != Actions.size(); ++I) {
>> + // We can reuse eh states when pushing two catches for the same
>> invoke.
>> + bool CurrActionIsCatch = isa<CatchHandler>(Actions[I].get());
>> + auto *Handler = cast<Function>(Actions[I]->getHandlerBlockOrFunc());
>> + // Various conditions can lead to a handler being popped from the
>> + // stack and re-pushed later. That shouldn't create a new state.
>> + // FIXME: Can code optimization lead to re-used handlers?
>> + if (FuncInfo.HandlerEnclosedState.count(Handler)) {
>> + // If we already assigned the state enclosed by this handler
>> re-use it.
>> + Actions[I]->setEHState(FuncInfo.HandlerEnclosedState[Handler]);
>> + continue;
>> + }
>> + const LandingPadInst* RootLPad = FuncInfo.RootLPad[Handler];
>> + if (CurrActionIsCatch && LastActionWasCatch && RootLPad ==
>> LastRootLPad) {
>> + DEBUG(dbgs() << "setEHState for handler to " << currentEHNumber()
>> << "\n");
>> + Actions[I]->setEHState(currentEHNumber());
>> + } else {
>> + DEBUG(dbgs() << "createUnwindMapEntry(" << currentEHNumber() << ",
>> ");
>> + print_name(Actions[I]->getHandlerBlockOrFunc());
>> + DEBUG(dbgs() << ") with EH state " << NextState << "\n");
>> + createUnwindMapEntry(currentEHNumber(), Actions[I].get());
>> + DEBUG(dbgs() << "setEHState for handler to " << NextState << "\n");
>> + Actions[I]->setEHState(NextState);
>> + NextState++;
>> + }
>> + HandlerStack.push_back(std::move(Actions[I]));
>> + LastActionWasCatch = CurrActionIsCatch;
>> + LastRootLPad = RootLPad;
>> + }
>> +
>> + // This is used to defer numbering states for a handler until after the
>> + // last time it appears in an invoke action list.
>> + if (CS.isInvoke()) {
>> + for (int I = 0, E = HandlerStack.size(); I < E; ++I) {
>> + auto *Handler =
>> cast<Function>(HandlerStack[I]->getHandlerBlockOrFunc());
>> + if (FuncInfo.LastInvoke[Handler] !=
>> cast<InvokeInst>(CS.getInstruction()))
>> + continue;
>> + FuncInfo.LastInvokeVisited[Handler] = true;
>> + DEBUG(dbgs() << "Last invoke of ");
>> + print_name(Handler);
>> + DEBUG(dbgs() << " has been visited.\n");
>> + }
>> + }
>> +
>> + DEBUG(dbgs() << "In EHState " << currentEHNumber() << " for CallSite:
>> ");
>> + print_name(CS ? CS.getCalledValue() : nullptr);
>> + DEBUG(dbgs() << '\n');
>> +}
>> +
>> +void WinEHNumbering::popUnmatchedActions(int FirstMismatch) {
>> // Don't recurse while we are looping over the handler stack.
>> Instead, defer
>> // the numbering of the catch handlers until we are done popping.
>> SmallVector<CatchHandler *, 4> PoppedCatches;
>> @@ -460,60 +567,25 @@ void WinEHNumbering::processCallSite(
>>
>> for (CatchHandler *CH : PoppedCatches) {
>> if (auto *F = dyn_cast<Function>(CH->getHandlerBlockOrFunc())) {
>> - DEBUG(dbgs() << "Assigning base state " << NextState << " to ");
>> - print_name(F);
>> - DEBUG(dbgs() << '\n');
>> - FuncInfo.HandlerBaseState[F] = NextState;
>> - DEBUG(dbgs() << "createUnwindMapEntry(" << currentEHNumber()
>> - << ", null)\n");
>> - createUnwindMapEntry(currentEHNumber(), nullptr);
>> - ++NextState;
>> - calculateStateNumbers(*F);
>> + if (FuncInfo.LastInvokeVisited[F]) {
>> + DEBUG(dbgs() << "Assigning base state " << NextState << " to ");
>> + print_name(F);
>> + DEBUG(dbgs() << '\n');
>> + FuncInfo.HandlerBaseState[F] = NextState;
>> + DEBUG(dbgs() << "createUnwindMapEntry(" << currentEHNumber()
>> + << ", null)\n");
>> + createUnwindMapEntry(currentEHNumber(), nullptr);
>> + ++NextState;
>> + calculateStateNumbers(*F);
>> + }
>> + else {
>> + DEBUG(dbgs() << "Deferring handling of ");
>> + print_name(F);
>> + DEBUG(dbgs() << " until last invoke visited.\n");
>> + }
>> }
>> delete CH;
>> }
>> -
>> - // The handler functions may have pushed actions onto the handler stack
>> - // that we expected to push here. Compare the handler stack to our
>> - // actions again to check for that possibility.
>> - if (HandlerStack.size() > (size_t)FirstMismatch) {
>> - for (int E = std::min(HandlerStack.size(), Actions.size());
>> - FirstMismatch < E; ++FirstMismatch) {
>> - if (HandlerStack[FirstMismatch]->getHandlerBlockOrFunc() !=
>> - Actions[FirstMismatch]->getHandlerBlockOrFunc())
>> - break;
>> - }
>> - }
>> -
>> - DEBUG(dbgs() << "Pushing actions for CallSite: ");
>> - print_name(CS ? CS.getCalledValue() : nullptr);
>> - DEBUG(dbgs() << '\n');
>> -
>> - bool LastActionWasCatch = false;
>> - for (size_t I = FirstMismatch; I != Actions.size(); ++I) {
>> - // We can reuse eh states when pushing two catches for the same
>> invoke.
>> - bool CurrActionIsCatch = isa<CatchHandler>(Actions[I].get());
>> - // FIXME: Reenable this optimization!
>> - if (CurrActionIsCatch && LastActionWasCatch && false) {
>> - DEBUG(dbgs() << "setEHState for handler to " << currentEHNumber()
>> - << "\n");
>> - Actions[I]->setEHState(currentEHNumber());
>> - } else {
>> - DEBUG(dbgs() << "createUnwindMapEntry(" << currentEHNumber() << ",
>> ");
>> - print_name(Actions[I]->getHandlerBlockOrFunc());
>> - DEBUG(dbgs() << ")\n");
>> - createUnwindMapEntry(currentEHNumber(), Actions[I].get());
>> - DEBUG(dbgs() << "setEHState for handler to " << NextState << "\n");
>> - Actions[I]->setEHState(NextState);
>> - NextState++;
>> - }
>> - HandlerStack.push_back(std::move(Actions[I]));
>> - LastActionWasCatch = CurrActionIsCatch;
>> - }
>> -
>> - DEBUG(dbgs() << "In EHState " << currentEHNumber() << " for CallSite:
>> ");
>> - print_name(CS ? CS.getCalledValue() : nullptr);
>> - DEBUG(dbgs() << '\n');
>> }
>>
>> void WinEHNumbering::calculateStateNumbers(const Function &F) {
>> @@ -526,6 +598,8 @@ void WinEHNumbering::calculateStateNumbe
>> CurrentBaseState = FuncInfo.HandlerBaseState[&F];
>> }
>>
>> + size_t SavedHandlerStackSize = HandlerStack.size();
>> +
>> DEBUG(dbgs() << "Calculating state numbers for: " << F.getName() <<
>> '\n');
>> SmallVector<std::unique_ptr<ActionHandler>, 4> ActionList;
>> for (const BasicBlock &BB : F) {
>> @@ -554,11 +628,64 @@ void WinEHNumbering::calculateStateNumbe
>> << '\n');
>> }
>>
>> + // Pop any actions that were pushed on the stack for this function.
>> + popUnmatchedActions(SavedHandlerStackSize);
>> +
>> + DEBUG(dbgs() << "Assigning max state " << NextState - 1
>> + << " to " << F.getName() << '\n');
>> FuncInfo.CatchHandlerMaxState[&F] = NextState - 1;
>>
>> CurrentBaseState = OldBaseState;
>> }
>>
>> +// This function follows the same basic traversal as
>> calculateStateNumbers
>> +// but it is necessary to identify the root landing pad associated
>> +// with each action before we start assigning state numbers.
>> +void WinEHNumbering::findActionRootLPads(const Function &F) {
>> + auto I = VisitedHandlers.insert(&F);
>> + if (!I.second)
>> + return; // We've already visited this handler, don't revisit it.
>> +
>> + SmallVector<std::unique_ptr<ActionHandler>, 4> ActionList;
>> + for (const BasicBlock &BB : F) {
>> + const auto *II = dyn_cast<InvokeInst>(BB.getTerminator());
>> + if (!II)
>> + continue;
>> + const LandingPadInst *LPI = II->getLandingPadInst();
>> + auto *ActionsCall = dyn_cast<IntrinsicInst>(LPI->getNextNode());
>> + if (!ActionsCall)
>> + continue;
>> +
>> + assert(ActionsCall->getIntrinsicID() == Intrinsic::eh_actions);
>> + parseEHActions(ActionsCall, ActionList);
>> + if (ActionList.empty())
>> + continue;
>> + for (int I = 0, E = ActionList.size(); I < E; ++I) {
>> + if (auto *Handler
>> + =
>> dyn_cast<Function>(ActionList[I]->getHandlerBlockOrFunc())) {
>> + FuncInfo.LastInvoke[Handler] = II;
>> + // Don't replace the root landing pad if we previously saw this
>> + // handler in a different function.
>> + if (FuncInfo.RootLPad.count(Handler) &&
>> + FuncInfo.RootLPad[Handler]->getParent()->getParent() != &F)
>> + continue;
>> + DEBUG(dbgs() << "Setting root lpad for ");
>> + print_name(Handler);
>> + DEBUG(dbgs() << " to " << LPI->getParent()->getName() << '\n');
>> + FuncInfo.RootLPad[Handler] = LPI;
>> + }
>> + }
>> + // Walk the actions again and look for nested handlers. This has to
>> + // happen after all of the actions have been processed in the current
>> + // function.
>> + for (int I = 0, E = ActionList.size(); I < E; ++I)
>> + if (auto *Handler
>> + =
>> dyn_cast<Function>(ActionList[I]->getHandlerBlockOrFunc()))
>> + findActionRootLPads(*Handler);
>> + ActionList.clear();
>> + }
>> +}
>> +
>> /// clear - Clear out all the function-specific state. This returns this
>> /// FunctionLoweringInfo to an empty state, ready to be used for a
>> /// different function.
>>
>> Modified: llvm/trunk/lib/CodeGen/WinEHPrepare.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/WinEHPrepare.cpp?rev=237854&r1=237853&r2=237854&view=diff
>>
>> ==============================================================================
>> --- llvm/trunk/lib/CodeGen/WinEHPrepare.cpp (original)
>> +++ llvm/trunk/lib/CodeGen/WinEHPrepare.cpp Wed May 20 18:22:24 2015
>> @@ -91,6 +91,7 @@ public:
>> private:
>> bool prepareExceptionHandlers(Function &F,
>> SmallVectorImpl<LandingPadInst *>
>> &LPads);
>> + void identifyEHBlocks(Function &F, SmallVectorImpl<LandingPadInst *>
>> &LPads);
>> void promoteLandingPadValues(LandingPadInst *LPad);
>> void demoteValuesLiveAcrossHandlers(Function &F,
>> SmallVectorImpl<LandingPadInst *>
>> &LPads);
>> @@ -127,6 +128,9 @@ private:
>> CatchHandlerMapTy CatchHandlerMap;
>> CleanupHandlerMapTy CleanupHandlerMap;
>> DenseMap<const LandingPadInst *, LandingPadMap> LPadMaps;
>> + SmallPtrSet<BasicBlock *, 4> NormalBlocks;
>> + SmallPtrSet<BasicBlock *, 4> EHBlocks;
>> + SetVector<BasicBlock *> EHReturnBlocks;
>>
>> // This maps landing pad instructions found in outlined handlers to
>> // the landing pad instruction in the parent function from which they
>> @@ -214,6 +218,9 @@ public:
>> virtual CloningAction handleTypeIdFor(ValueToValueMapTy &VMap,
>> const Instruction *Inst,
>> BasicBlock *NewBB) = 0;
>> + virtual CloningAction handleIndirectBr(ValueToValueMapTy &VMap,
>> + const IndirectBrInst *IBr,
>> + BasicBlock *NewBB) = 0;
>> virtual CloningAction handleInvoke(ValueToValueMapTy &VMap,
>> const InvokeInst *Invoke,
>> BasicBlock *NewBB) = 0;
>> @@ -244,10 +251,12 @@ public:
>> WinEHCatchDirector(
>> Function *CatchFn, Value *ParentFP, Value *Selector,
>> FrameVarInfoMap &VarInfo, LandingPadMap &LPadMap,
>> - DenseMap<LandingPadInst *, const LandingPadInst *> &NestedLPads)
>> + DenseMap<LandingPadInst *, const LandingPadInst *> &NestedLPads,
>> + DominatorTree *DT, SmallPtrSetImpl<BasicBlock *> &EHBlocks)
>> : WinEHCloningDirectorBase(CatchFn, ParentFP, VarInfo, LPadMap),
>> CurrentSelector(Selector->stripPointerCasts()),
>> - ExceptionObjectVar(nullptr), NestedLPtoOriginalLP(NestedLPads) {}
>> + ExceptionObjectVar(nullptr), NestedLPtoOriginalLP(NestedLPads),
>> + DT(DT), EHBlocks(EHBlocks) {}
>>
>> CloningAction handleBeginCatch(ValueToValueMapTy &VMap,
>> const Instruction *Inst,
>> @@ -257,6 +266,9 @@ public:
>> CloningAction handleTypeIdFor(ValueToValueMapTy &VMap,
>> const Instruction *Inst,
>> BasicBlock *NewBB) override;
>> + CloningAction handleIndirectBr(ValueToValueMapTy &VMap,
>> + const IndirectBrInst *IBr,
>> + BasicBlock *NewBB) override;
>> CloningAction handleInvoke(ValueToValueMapTy &VMap, const InvokeInst
>> *Invoke,
>> BasicBlock *NewBB) override;
>> CloningAction handleResume(ValueToValueMapTy &VMap, const ResumeInst
>> *Resume,
>> @@ -279,6 +291,8 @@ private:
>> // This will be a reference to the field of the same name in the
>> WinEHPrepare
>> // object which instantiates this WinEHCatchDirector object.
>> DenseMap<LandingPadInst *, const LandingPadInst *>
>> &NestedLPtoOriginalLP;
>> + DominatorTree *DT;
>> + SmallPtrSetImpl<BasicBlock *> &EHBlocks;
>> };
>>
>> class WinEHCleanupDirector : public WinEHCloningDirectorBase {
>> @@ -296,6 +310,9 @@ public:
>> CloningAction handleTypeIdFor(ValueToValueMapTy &VMap,
>> const Instruction *Inst,
>> BasicBlock *NewBB) override;
>> + CloningAction handleIndirectBr(ValueToValueMapTy &VMap,
>> + const IndirectBrInst *IBr,
>> + BasicBlock *NewBB) override;
>> CloningAction handleInvoke(ValueToValueMapTy &VMap, const InvokeInst
>> *Invoke,
>> BasicBlock *NewBB) override;
>> CloningAction handleResume(ValueToValueMapTy &VMap, const ResumeInst
>> *Resume,
>> @@ -525,13 +542,8 @@ void WinEHPrepare::findSEHEHReturnPoints
>> }
>> }
>>
>> -/// Ensure that all values live into and out of exception handlers are
>> stored
>> -/// in memory.
>> -/// FIXME: This falls down when values are defined in one handler and
>> live into
>> -/// another handler. For example, a cleanup defines a value used only by
>> a
>> -/// catch handler.
>> -void WinEHPrepare::demoteValuesLiveAcrossHandlers(
>> - Function &F, SmallVectorImpl<LandingPadInst *> &LPads) {
>> +void WinEHPrepare::identifyEHBlocks(Function &F,
>> + SmallVectorImpl<LandingPadInst *>
>> &LPads) {
>> DEBUG(dbgs() << "Demoting values live across exception handlers in
>> function "
>> << F.getName() << '\n');
>>
>> @@ -541,10 +553,6 @@ void WinEHPrepare::demoteValuesLiveAcros
>> // - Exceptional blocks are blocks reachable from landingpads.
>> Analysis does
>> // not follow llvm.eh.endcatch blocks, which mark a transition from
>> // exceptional to normal control.
>> - SmallPtrSet<BasicBlock *, 4> NormalBlocks;
>> - SmallPtrSet<BasicBlock *, 4> EHBlocks;
>> - SetVector<BasicBlock *> EHReturnBlocks;
>> - SetVector<BasicBlock *> Worklist;
>>
>> if (Personality == EHPersonality::MSVC_CXX)
>> findCXXEHReturnPoints(F, EHReturnBlocks);
>> @@ -567,6 +575,7 @@ void WinEHPrepare::demoteValuesLiveAcros
>>
>> // Normal blocks are the blocks reachable from the entry block and all
>> EH
>> // return points.
>> + SetVector<BasicBlock *> Worklist;
>> Worklist = EHReturnBlocks;
>> Worklist.insert(&F.getEntryBlock());
>> findReachableBlocks(NormalBlocks, Worklist, nullptr);
>> @@ -588,6 +597,21 @@ void WinEHPrepare::demoteValuesLiveAcros
>> dbgs() << " " << BB->getName() << '\n';
>> });
>>
>> +}
>> +
>> +/// Ensure that all values live into and out of exception handlers are
>> stored
>> +/// in memory.
>> +/// FIXME: This falls down when values are defined in one handler and
>> live into
>> +/// another handler. For example, a cleanup defines a value used only by
>> a
>> +/// catch handler.
>> +void WinEHPrepare::demoteValuesLiveAcrossHandlers(
>> + Function &F, SmallVectorImpl<LandingPadInst *> &LPads) {
>> + DEBUG(dbgs() << "Demoting values live across exception handlers in
>> function "
>> + << F.getName() << '\n');
>> +
>> + // identifyEHBlocks() should have been called before this function.
>> + assert(!NormalBlocks.empty());
>> +
>> SetVector<Argument *> ArgsToDemote;
>> SetVector<Instruction *> InstrsToDemote;
>> for (BasicBlock &BB : F) {
>> @@ -678,6 +702,7 @@ bool WinEHPrepare::prepareExceptionHandl
>> return false;
>> }
>>
>> + identifyEHBlocks(F, LPads);
>> demoteValuesLiveAcrossHandlers(F, LPads);
>>
>> // These containers are used to re-map frame variables that are used in
>> @@ -702,6 +727,16 @@ bool WinEHPrepare::prepareExceptionHandl
>> F.getEntryBlock().getFirstInsertionPt());
>> }
>>
>> + // In order to handle the case where one outlined catch handler returns
>> + // to a block within another outlined catch handler that would
>> otherwise
>> + // be unreachable, we need to outline the nested landing pad before we
>> + // outline the landing pad which encloses it.
>> + if (!isAsynchronousEHPersonality(Personality))
>> + std::sort(LPads.begin(), LPads.end(),
>> + [this](LandingPadInst* &L, LandingPadInst* &R) {
>> + return DT->dominates(R->getParent(), L->getParent());
>> + });
>>
>
> This doesn't seem to be a strict weak ordering - an stl with weak ordering
> assertions enabled dislikes that we put that into std::sort...
> what(): strict weak ordering: (__x LT __x) != false
>
> +
>> // 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
>> @@ -829,28 +864,24 @@ bool WinEHPrepare::prepareExceptionHandl
>> CallInst *Recover =
>> CallInst::Create(ActionIntrin, ActionArgs, "recover", LPadBB);
>>
>> - if (isAsynchronousEHPersonality(Personality)) {
>> - // SEH can create the target list directly, since catch handlers
>> - // are not outlined.
>> - SetVector<BasicBlock *> ReturnTargets;
>> - for (ActionHandler *Action : Actions) {
>> - if (auto *CatchAction = dyn_cast<CatchHandler>(Action)) {
>> - const auto &CatchTargets = CatchAction->getReturnTargets();
>> - ReturnTargets.insert(CatchTargets.begin(), CatchTargets.end());
>> - }
>> + SetVector<BasicBlock *> ReturnTargets;
>> + for (ActionHandler *Action : Actions) {
>> + if (auto *CatchAction = dyn_cast<CatchHandler>(Action)) {
>> + const auto &CatchTargets = CatchAction->getReturnTargets();
>> + ReturnTargets.insert(CatchTargets.begin(), CatchTargets.end());
>> }
>> - IndirectBrInst *Branch =
>> - IndirectBrInst::Create(Recover, ReturnTargets.size(), LPadBB);
>> - for (BasicBlock *Target : ReturnTargets)
>> - 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);
>> + }
>> + IndirectBrInst *Branch =
>> + IndirectBrInst::Create(Recover, ReturnTargets.size(), LPadBB);
>> + for (BasicBlock *Target : ReturnTargets)
>> + Branch->addDestination(Target);
>>
>> + if (!isAsynchronousEHPersonality(Personality)) {
>> + // C++ EH must repopulate the targets later to handle the case of
>> + // targets that are reached indirectly through nested landing pads.
>> LPadImpls.push_back(std::make_pair(Recover, Branch));
>> }
>> +
>> } // End for each landingpad
>>
>> // If nothing got outlined, there is no more processing to be done.
>> @@ -864,8 +895,7 @@ bool WinEHPrepare::prepareExceptionHandl
>> completeNestedLandingPad(&F, LPadPair.first, LPadPair.second,
>> FrameVarInfo);
>> NestedLPtoOriginalLP.clear();
>>
>> - // Populate the indirectbr instructions' target lists if we deferred
>> - // doing so above.
>> + // Update the indirectbr instructions' target lists if necessary.
>> SetVector<BasicBlock*> CheckedTargets;
>> SmallVector<std::unique_ptr<ActionHandler>, 4> ActionList;
>> for (auto &LPadImplPair : LPadImpls) {
>> @@ -884,6 +914,12 @@ bool WinEHPrepare::prepareExceptionHandl
>> }
>> }
>> ActionList.clear();
>> + // Clear any targets we already knew about.
>> + for (unsigned int I = 0, E = Branch->getNumDestinations(); I < E;
>> ++I) {
>> + BasicBlock *KnownTarget = Branch->getDestination(I);
>> + if (ReturnTargets.count(KnownTarget))
>> + ReturnTargets.remove(KnownTarget);
>> + }
>> for (BasicBlock *Target : ReturnTargets) {
>> Branch->addDestination(Target);
>> // The target may be a block that we excepted to get pruned.
>> @@ -994,6 +1030,9 @@ bool WinEHPrepare::prepareExceptionHandl
>> HandlerToParentFP.clear();
>> DT = nullptr;
>> SEHExceptionCodeSlot = nullptr;
>> + EHBlocks.clear();
>> + NormalBlocks.clear();
>> + EHReturnBlocks.clear();
>>
>> return HandlersOutlined;
>> }
>> @@ -1079,10 +1118,19 @@ void WinEHPrepare::completeNestedLanding
>> // temporarily inserted as its terminator.
>> LLVMContext &Context = ParentFn->getContext();
>> BasicBlock *OutlinedBB = OutlinedLPad->getParent();
>> - assert(isa<UnreachableInst>(OutlinedBB->getTerminator()));
>> - OutlinedBB->getTerminator()->eraseFromParent();
>> - // That should leave OutlinedLPad as the last instruction in its block.
>> - assert(&OutlinedBB->back() == OutlinedLPad);
>> + // If the nested landing pad was outlined before the landing pad that
>> enclosed
>> + // it, it will already be in outlined form. In that case, we just
>> need to see
>> + // if the returns and the enclosing branch instruction need to be
>> updated.
>> + IndirectBrInst *Branch =
>> + dyn_cast<IndirectBrInst>(OutlinedBB->getTerminator());
>> + if (!Branch) {
>> + // If the landing pad wasn't in outlined form, it should be a stub
>> with
>> + // an unreachable terminator.
>> + assert(isa<UnreachableInst>(OutlinedBB->getTerminator()));
>> + OutlinedBB->getTerminator()->eraseFromParent();
>> + // That should leave OutlinedLPad as the last instruction in its
>> block.
>> + assert(&OutlinedBB->back() == OutlinedLPad);
>> + }
>>
>> // The original landing pad will have already had its action intrinsic
>> // built by the outlining loop. We need to clone that into the
>> outlined
>> @@ -1096,9 +1144,9 @@ void WinEHPrepare::completeNestedLanding
>> // The instruction after the landing pad should now be a call to
>> eh.actions.
>> const Instruction *Recover = II;
>> assert(match(Recover, m_Intrinsic<Intrinsic::eh_actions>()));
>> - IntrinsicInst *EHActions = cast<IntrinsicInst>(Recover->clone());
>> + const IntrinsicInst *EHActions = cast<IntrinsicInst>(Recover);
>>
>> - // Remap the exception variables into the outlined function.
>> + // Remap the return target in the nested handler.
>> SmallVector<BlockAddress *, 4> ActionTargets;
>> SmallVector<std::unique_ptr<ActionHandler>, 4> ActionList;
>> parseEHActions(EHActions, ActionList);
>> @@ -1125,7 +1173,7 @@ void WinEHPrepare::completeNestedLanding
>> // should be a block that was outlined into OutlinedHandlerFn.
>> assert(BA->getFunction() == ParentFn);
>>
>> - // Ignore targets that aren't part of OutlinedHandlerFn.
>> + // Ignore targets that aren't part of an outlined handler function.
>> if (!LPadTargetBlocks.count(BA->getBasicBlock()))
>> continue;
>>
>> @@ -1142,13 +1190,25 @@ void WinEHPrepare::completeNestedLanding
>> }
>> }
>> ActionList.clear();
>> - OutlinedBB->getInstList().push_back(EHActions);
>>
>> - // Insert an indirect branch into the outlined landing pad BB.
>> - IndirectBrInst *IBr = IndirectBrInst::Create(EHActions, 0, OutlinedBB);
>> - // Add the previously collected action targets.
>> - for (auto *Target : ActionTargets)
>> - IBr->addDestination(Target->getBasicBlock());
>> + if (Branch) {
>> + // If the landing pad was already in outlined form, just update its
>> targets.
>> + for (unsigned int I = Branch->getNumDestinations(); I > 0; --I)
>> + Branch->removeDestination(I);
>> + // Add the previously collected action targets.
>> + for (auto *Target : ActionTargets)
>> + Branch->addDestination(Target->getBasicBlock());
>> + } else {
>> + // If the landing pad was previously stubbed out, fill in its
>> outlined form.
>> + IntrinsicInst *NewEHActions =
>> cast<IntrinsicInst>(EHActions->clone());
>> + OutlinedBB->getInstList().push_back(NewEHActions);
>> +
>> + // Insert an indirect branch into the outlined landing pad BB.
>> + IndirectBrInst *IBr = IndirectBrInst::Create(NewEHActions, 0,
>> OutlinedBB);
>> + // Add the previously collected action targets.
>> + for (auto *Target : ActionTargets)
>> + IBr->addDestination(Target->getBasicBlock());
>> + }
>> }
>>
>> // This function examines a block to determine whether the block ends
>> with a
>> @@ -1326,9 +1386,9 @@ bool WinEHPrepare::outlineHandler(Action
>> LPadMap.mapLandingPad(LPad);
>> if (auto *CatchAction = dyn_cast<CatchHandler>(Action)) {
>> Constant *Sel = CatchAction->getSelector();
>> - Director.reset(new WinEHCatchDirector(Handler, ParentFP, Sel,
>> - VarInfo, LPadMap,
>> - NestedLPtoOriginalLP));
>> + Director.reset(new WinEHCatchDirector(Handler, ParentFP, Sel,
>> VarInfo,
>> + LPadMap, NestedLPtoOriginalLP,
>> DT,
>> + EHBlocks));
>> LPadMap.remapEHValues(VMap, UndefValue::get(Int8PtrType),
>> ConstantInt::get(Type::getInt32Ty(Context),
>> 1));
>> } else {
>> @@ -1532,15 +1592,22 @@ CloningDirector::CloningAction WinEHClon
>> if (LPadMap.isLandingPadSpecificInst(Inst))
>> return CloningDirector::SkipInstruction;
>>
>> - // Nested landing pads will be cloned as stubs, with just the
>> - // landingpad instruction and an unreachable instruction. When
>> - // all landingpads have been outlined, we'll replace this with the
>> - // llvm.eh.actions call and indirect branch created when the
>> - // landing pad was outlined.
>> + // Nested landing pads that have not already been outlined will be
>> cloned as
>> + // stubs, with just the landingpad instruction and an unreachable
>> instruction.
>> + // When all landingpads have been outlined, we'll replace this with the
>> + // llvm.eh.actions call and indirect branch created when the landing
>> pad was
>> + // outlined.
>> if (auto *LPad = dyn_cast<LandingPadInst>(Inst)) {
>> return handleLandingPad(VMap, LPad, NewBB);
>> }
>>
>> + // Nested landing pads that have already been outlined will be cloned
>> in their
>> + // outlined form, but we need to intercept the ibr instruction to
>> filter out
>> + // targets that do not return to the handler we are outlining.
>> + if (auto *IBr = dyn_cast<IndirectBrInst>(Inst)) {
>> + return handleIndirectBr(VMap, IBr, NewBB);
>> + }
>> +
>> if (auto *Invoke = dyn_cast<InvokeInst>(Inst))
>> return handleInvoke(VMap, Invoke, NewBB);
>>
>> @@ -1570,6 +1637,20 @@ CloningDirector::CloningAction WinEHClon
>>
>> CloningDirector::CloningAction WinEHCatchDirector::handleLandingPad(
>> ValueToValueMapTy &VMap, const LandingPadInst *LPad, BasicBlock
>> *NewBB) {
>> + // If the instruction after the landing pad is a call to
>> llvm.eh.actions
>> + // the landing pad has already been outlined. In this case, we should
>> + // clone it because it may return to a block in the handler we are
>> + // outlining now that would otherwise be unreachable. The landing pads
>> + // are sorted before outlining begins to enable this case to work
>> + // properly.
>> + const Instruction *NextI = LPad->getNextNode();
>> + if (match(NextI, m_Intrinsic<Intrinsic::eh_actions>()))
>> + return CloningDirector::CloneInstruction;
>> +
>> + // If the landing pad hasn't been outlined yet, the landing pad we are
>> + // outlining now does not dominate it and so it cannot return to a
>> block
>> + // in this handler. In that case, we can just insert a stub landing
>> + // pad now and patch it up later.
>> Instruction *NewInst = LPad->clone();
>> if (LPad->hasName())
>> NewInst->setName(LPad->getName());
>> @@ -1661,6 +1742,48 @@ CloningDirector::CloningAction WinEHCatc
>> return CloningDirector::SkipInstruction;
>> }
>>
>> +CloningDirector::CloningAction WinEHCatchDirector::handleIndirectBr(
>> + ValueToValueMapTy &VMap,
>> + const IndirectBrInst *IBr,
>> + BasicBlock *NewBB) {
>> + // If this indirect branch is not part of a landing pad block, just
>> clone it.
>> + const BasicBlock *ParentBB = IBr->getParent();
>> + if (!ParentBB->isLandingPad())
>> + return CloningDirector::CloneInstruction;
>> +
>> + // If it is part of a landing pad, we want to filter out target blocks
>> + // that are not part of the handler we are outlining.
>> + const LandingPadInst *LPad = ParentBB->getLandingPadInst();
>> +
>> + // Save this correlation for later processing.
>> + NestedLPtoOriginalLP[cast<LandingPadInst>(VMap[LPad])] = LPad;
>> +
>> + // We should only get here for landing pads that have already been
>> outlined.
>> + assert(match(LPad->getNextNode(),
>> m_Intrinsic<Intrinsic::eh_actions>()));
>> +
>> + // Copy the indirectbr, but only include targets that were previously
>> + // identified as EH blocks and are dominated by the nested landing pad.
>> + SetVector<const BasicBlock *> ReturnTargets;
>> + for (int I = 0, E = IBr->getNumDestinations(); I < E; ++I) {
>> + auto *TargetBB = IBr->getDestination(I);
>> + if (EHBlocks.count(const_cast<BasicBlock*>(TargetBB)) &&
>> + DT->dominates(ParentBB, TargetBB)) {
>> + DEBUG(dbgs() << " Adding destination " << TargetBB->getName() <<
>> "\n");
>> + ReturnTargets.insert(TargetBB);
>> + }
>> + }
>> + IndirectBrInst *NewBranch =
>> + IndirectBrInst::Create(const_cast<Value *>(IBr->getAddress()),
>> + ReturnTargets.size(), NewBB);
>> + for (auto *Target : ReturnTargets)
>> + NewBranch->addDestination(const_cast<BasicBlock*>(Target));
>> +
>> + // The operands and targets of the branch instruction are remapped
>> later
>> + // because it is a terminator. Tell the cloning code to clone the
>> + // blocks we just added to the target list.
>> + return CloningDirector::CloneSuccessors;
>> +}
>> +
>> CloningDirector::CloningAction
>> WinEHCatchDirector::handleInvoke(ValueToValueMapTy &VMap,
>> const InvokeInst *Invoke, BasicBlock
>> *NewBB) {
>> @@ -1750,6 +1873,14 @@ CloningDirector::CloningAction WinEHClea
>> return CloningDirector::SkipInstruction;
>> }
>>
>> +CloningDirector::CloningAction WinEHCleanupDirector::handleIndirectBr(
>> + ValueToValueMapTy &VMap,
>> + const IndirectBrInst *IBr,
>> + BasicBlock *NewBB) {
>> + // No special handling is required for cleanup cloning.
>> + return CloningDirector::CloneInstruction;
>> +}
>> +
>> CloningDirector::CloningAction WinEHCleanupDirector::handleInvoke(
>> ValueToValueMapTy &VMap, const InvokeInst *Invoke, BasicBlock
>> *NewBB) {
>> // All invokes in cleanup handlers can be replaced with calls.
>>
>> Modified: llvm/trunk/test/CodeGen/WinEH/cppeh-nested-1.ll
>> URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/test/CodeGen/WinEH/cppeh-nested-1.ll?rev=237854&r1=237853&r2=237854&view=diff
>>
>> ==============================================================================
>> --- llvm/trunk/test/CodeGen/WinEH/cppeh-nested-1.ll (original)
>> +++ llvm/trunk/test/CodeGen/WinEH/cppeh-nested-1.ll Wed May 20 18:22:24
>> 2015
>> @@ -34,7 +34,7 @@ $"\01??_R0H at 8" = comdat any
>> ; CHECK: entry:
>> ; CHECK: %i = alloca i32, align 4
>> ; CHECK: %f = alloca float, align 4
>> -; CHECK: call void (...) @llvm.frameescape(i32* %i, float* %f)
>> +; CHECK: call void (...) @llvm.frameescape(float* %f, i32* %i)
>> ; CHECK: invoke void @"\01?may_throw@@YAXXZ"()
>> ; CHECK: to label %invoke.cont unwind label
>> %[[LPAD_LABEL:lpad[0-9]*]]
>>
>> @@ -55,8 +55,8 @@ invoke.cont:
>> ; CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)*
>> @__CxxFrameHandler3 to i8*)
>> ; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2*
>> @"\01??_R0H at 8" to i8*)
>> ; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2*
>> @"\01??_R0M at 8" to i8*)
>> -; CHECK: [[RECOVER:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8*
>> bitcast (%rtti.TypeDescriptor2* @"\01??_R0H at 8" to i8*), i32 0, i8* (i8*,
>> i8*)* @"\01?test@@YAXXZ.catch", i32 1, i8* bitcast
>> (%rtti.TypeDescriptor2* @"\01??_R0M at 8" to i8*), i32 1, i8* (i8*, i8*)*
>> @"\01?test@@YAXXZ.catch.1")
>> -; CHECK: indirectbr i8* [[RECOVER]], [label %try.cont10, label
>> %try.cont]
>> +; CHECK: [[RECOVER:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8*
>> bitcast (%rtti.TypeDescriptor2* @"\01??_R0H at 8" to i8*), i32 1, i8* (i8*,
>> i8*)* @"\01?test@@YAXXZ.catch.1", i32 1, i8* bitcast
>> (%rtti.TypeDescriptor2* @"\01??_R0M at 8" to i8*), i32 0, i8* (i8*, i8*)*
>> @"\01?test@@YAXXZ.catch")
>> +; CHECK: indirectbr i8* [[RECOVER]], [label %try.cont, label
>> %try.cont10]
>>
>> lpad: ; preds = %entry
>> %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)*
>> @__CxxFrameHandler3 to i8*)
>> @@ -136,7 +136,16 @@ eh.resume:
>>
>> ; CHECK: define internal i8* @"\01?test@@YAXXZ.catch"(i8*, i8*)
>> ; CHECK: entry:
>> -; CHECK: [[RECOVER_I:\%.+]] = call i8* @llvm.framerecover(i8* bitcast
>> (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 0)
>> +; CHECK: [[RECOVER_F1:\%.+]] = call i8* @llvm.framerecover(i8* bitcast
>> (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 0)
>> +; CHECK: [[F_PTR1:\%.+]] = bitcast i8* [[RECOVER_F1]] to float*
>> +; CHECK: [[TMP2:\%.+]] = load float, float* [[F_PTR1]], align 4
>> +; CHECK: call void @"\01?handle_float@@YAXM at Z"(float [[TMP2]])
>> +; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ", %try.cont10)
>> +; CHECK: }
>> +
>> +; CHECK: define internal i8* @"\01?test@@YAXXZ.catch.1"(i8*, i8*)
>> +; CHECK: entry:
>> +; CHECK: [[RECOVER_I:\%.+]] = call i8* @llvm.framerecover(i8* bitcast
>> (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 1)
>> ; CHECK: [[I_PTR:\%.+]] = bitcast i8* [[RECOVER_I]] to i32*
>> ; CHECK: [[TMP1:\%.+]] = load i32, i32* [[I_PTR]], align 4
>> ; CHECK: invoke void @"\01?handle_int@@YAXH at Z"(i32 [[TMP1]])
>> @@ -148,20 +157,11 @@ eh.resume:
>> ; CHECK: [[LPAD1_LABEL]]:{{[ ]+}}; preds = %entry
>> ; CHECK: [[LPAD1_VAL:\%.+]] = landingpad { i8*, i32 } personality i8*
>> bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
>> ; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2*
>> @"\01??_R0M at 8" to i8*)
>> -; CHECK: [[RECOVER1:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1,
>> i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M at 8" to i8*), i32 1, i8*
>> (i8*, i8*)* @"\01?test@@YAXXZ.catch.1")
>> +; CHECK: [[RECOVER1:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1,
>> i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M at 8" to i8*), i32 0, i8*
>> (i8*, i8*)* @"\01?test@@YAXXZ.catch")
>> ; CHECK: indirectbr i8* [[RECOVER1]], []
>> ;
>> ; CHECK: }
>>
>> -; CHECK: define internal i8* @"\01?test@@YAXXZ.catch.1"(i8*, i8*)
>> -; CHECK: entry:
>> -; CHECK: [[RECOVER_F1:\%.+]] = call i8* @llvm.framerecover(i8* bitcast
>> (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 1)
>> -; CHECK: [[F_PTR1:\%.+]] = bitcast i8* [[RECOVER_F1]] to float*
>> -; CHECK: [[TMP2:\%.+]] = load float, float* [[F_PTR1]], align 4
>> -; CHECK: call void @"\01?handle_float@@YAXM at Z"(float [[TMP2]])
>> -; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ", %try.cont10)
>> -; CHECK: }
>> -
>>
>> declare void @"\01?may_throw@@YAXXZ"() #1
>>
>>
>> Modified: llvm/trunk/test/CodeGen/WinEH/cppeh-nested-2.ll
>> URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/test/CodeGen/WinEH/cppeh-nested-2.ll?rev=237854&r1=237853&r2=237854&view=diff
>>
>> ==============================================================================
>> --- llvm/trunk/test/CodeGen/WinEH/cppeh-nested-2.ll (original)
>> +++ llvm/trunk/test/CodeGen/WinEH/cppeh-nested-2.ll Wed May 20 18:22:24
>> 2015
>> @@ -114,7 +114,7 @@ lpad:
>> ; CHECK-SAME: i32 1, i8* bitcast (i8** @_ZTIi to i8*), i32 1, i8*
>> (i8*, i8*)* @_Z4testv.catch.1,
>> ; 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-NEXT: indirectbr i8* [[RECOVER1]], [label %try.cont19, label
>> %try.cont]
>> +; CHECK-NEXT: indirectbr i8* [[RECOVER1]], [label %try.cont, label
>> %try.cont19]
>>
>> lpad1: ; preds =
>> %invoke.cont4, %invoke.cont
>> %tmp3 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)*
>> @__CxxFrameHandler3 to i8*)
>> @@ -137,7 +137,7 @@ lpad1:
>> ; CHECK-SAME: i32 1, i8* bitcast (i8** @_ZTIi to i8*), i32 1, i8*
>> (i8*, i8*)* @_Z4testv.catch.1,
>> ; 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-NEXT: indirectbr i8* [[RECOVER3]], [label %try.cont19, label
>> %try.cont]
>> +; CHECK-NEXT: indirectbr i8* [[RECOVER3]], [label %try.cont, label
>> %try.cont19]
>>
>> lpad3: ; preds = %invoke.cont2
>> %tmp6 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)*
>> @__CxxFrameHandler3 to i8*)
>>
>> Modified: llvm/trunk/test/CodeGen/WinEH/cppeh-nested-3.ll
>> URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/test/CodeGen/WinEH/cppeh-nested-3.ll?rev=237854&r1=237853&r2=237854&view=diff
>>
>> ==============================================================================
>> --- llvm/trunk/test/CodeGen/WinEH/cppeh-nested-3.ll (original)
>> +++ llvm/trunk/test/CodeGen/WinEH/cppeh-nested-3.ll Wed May 20 18:22:24
>> 2015
>> @@ -41,7 +41,7 @@ $"\01??_R0H at 8" = comdat any
>> ; CHECK: %i = alloca i32, align 4
>> ; CHECK: %j = alloca i32, align 4
>> ; CHECK: %f = alloca float, align 4
>> -; CHECK: call void (...) @llvm.frameescape(i32* %i, float* %f, i32* %j)
>> +; CHECK: call void (...) @llvm.frameescape(i32* %j, i32* %i, float* %f)
>> ; CHECK: invoke void @"\01?may_throw@@YAXXZ"()
>> ; CHECK: to label %invoke.cont unwind label
>> %[[LPAD_LABEL:lpad[0-9]*]]
>>
>> @@ -63,8 +63,8 @@ invoke.cont:
>> ; CHECK: landingpad { i8*, i32 } personality i8* bitcast (i32 (...)*
>> @__CxxFrameHandler3 to i8*)
>> ; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2*
>> @"\01??_R0H at 8" to i8*)
>> ; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2*
>> @"\01??_R0M at 8" to i8*)
>> -; CHECK: [[RECOVER:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8*
>> bitcast (%rtti.TypeDescriptor2* @"\01??_R0H at 8" to i8*), i32 0, i8* (i8*,
>> i8*)* @"\01?test@@YAXXZ.catch", i32 1, i8* bitcast
>> (%rtti.TypeDescriptor2* @"\01??_R0M at 8" to i8*), i32 1, i8* (i8*, i8*)*
>> @"\01?test@@YAXXZ.catch.1")
>> -; CHECK: indirectbr i8* [[RECOVER]], [label %try.cont19, label
>> %try.cont10]
>> +; CHECK: [[RECOVER:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8*
>> bitcast (%rtti.TypeDescriptor2* @"\01??_R0H at 8" to i8*), i32 1, i8* (i8*,
>> i8*)* @"\01?test@@YAXXZ.catch.2", i32 1, i8* bitcast
>> (%rtti.TypeDescriptor2* @"\01??_R0M at 8" to i8*), i32 2, i8* (i8*, i8*)*
>> @"\01?test@@YAXXZ.catch.1")
>> +; CHECK: indirectbr i8* [[RECOVER]], [label %try.cont10, label
>> %try.cont19]
>>
>> lpad: ; preds = %entry
>> %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)*
>> @__CxxFrameHandler3 to i8*)
>> @@ -181,7 +181,27 @@ eh.resume:
>>
>> ; CHECK: define internal i8* @"\01?test@@YAXXZ.catch"(i8*, i8*)
>> ; CHECK: entry:
>> -; CHECK: [[RECOVER_I:\%.+]] = call i8* @llvm.framerecover(i8* bitcast
>> (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 0)
>> +; CHECK: [[RECOVER_J:\%.+]] = call i8* @llvm.framerecover(i8* bitcast
>> (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 0)
>> +; CHECK: [[J_PTR:\%.+]] = bitcast i8* [[RECOVER_J]] to i32*
>> +; CHECK: [[RECOVER_I1:\%.+]] = call i8* @llvm.framerecover(i8* bitcast
>> (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 1)
>> +; CHECK: [[I_PTR1:\%.+]] = bitcast i8* [[RECOVER_I1]] to i32*
>> +; CHECK: [[TMP3:\%.+]] = load i32, i32* [[J_PTR]], align 4
>> +; CHECK: store i32 [[TMP3]], i32* [[I_PTR1]]
>> +; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ.catch.2",
>> %invoke.cont2)
>> +; CHECK: }
>> +
>> +; CHECK: define internal i8* @"\01?test@@YAXXZ.catch.1"(i8*, i8*)
>> +; CHECK: entry:
>> +; CHECK: [[RECOVER_F:\%.+]] = call i8* @llvm.framerecover(i8* bitcast
>> (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 2)
>> +; CHECK: [[F_PTR:\%.+]] = bitcast i8* [[RECOVER_F]] to float*
>> +; CHECK: [[TMP2:\%.+]] = load float, float* [[F_PTR]], align 4
>> +; CHECK: call void @"\01?handle_float@@YAXM at Z"(float [[TMP2]])
>> +; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ", %try.cont19)
>> +; CHECK: }
>> +
>> +; CHECK: define internal i8* @"\01?test@@YAXXZ.catch.2"(i8*, i8*)
>> +; CHECK: entry:
>> +; CHECK: [[RECOVER_I:\%.+]] = call i8* @llvm.framerecover(i8* bitcast
>> (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 1)
>> ; CHECK: [[I_PTR:\%.+]] = bitcast i8* [[RECOVER_I]] to i32*
>> ; CHECK: invoke void @"\01?may_throw@@YAXXZ"()
>> ; CHECK: to label %invoke.cont2 unwind label
>> %[[LPAD1_LABEL:lpad[0-9]*]]
>> @@ -195,7 +215,7 @@ eh.resume:
>> ; CHECK: [[LPAD1_VAL:\%.+]] = landingpad { i8*, i32 } personality i8*
>> bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
>> ; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2*
>> @"\01??_R0H at 8" to i8*)
>> ; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2*
>> @"\01??_R0M at 8" to i8*)
>> -; CHECK: [[RECOVER1:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1,
>> i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H at 8" to i8*), i32 2, i8*
>> (i8*, i8*)* @"\01?test@@YAXXZ.catch.2", i32 1, i8* bitcast
>> (%rtti.TypeDescriptor2* @"\01??_R0M at 8" to i8*), i32 1, i8* (i8*, i8*)*
>> @"\01?test@@YAXXZ.catch.1")
>> +; CHECK: [[RECOVER1:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1,
>> i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H at 8" to i8*), i32 0, i8*
>> (i8*, i8*)* @"\01?test@@YAXXZ.catch", i32 1, i8* bitcast
>> (%rtti.TypeDescriptor2* @"\01??_R0M at 8" to i8*), i32 2, i8* (i8*, i8*)*
>> @"\01?test@@YAXXZ.catch.1")
>> ; CHECK: indirectbr i8* [[RECOVER1]], [label %invoke.cont2]
>> ;
>> ; CHECK: invoke.cont9:
>> @@ -204,32 +224,11 @@ eh.resume:
>> ; CHECK: [[LPAD8_LABEL]]:{{[ ]+}}; preds = %invoke.cont2
>> ; CHECK: [[LPAD8_VAL:\%.+]] = landingpad { i8*, i32 } personality i8*
>> bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
>> ; CHECK: catch i8* bitcast (%rtti.TypeDescriptor2*
>> @"\01??_R0M at 8" to i8*)
>> -; CHECK: [[RECOVER2:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1,
>> i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M at 8" to i8*), i32 1, i8*
>> (i8*, i8*)* @"\01?test@@YAXXZ.catch.1")
>> +; CHECK: [[RECOVER2:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1,
>> i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M at 8" to i8*), i32 2, i8*
>> (i8*, i8*)* @"\01?test@@YAXXZ.catch.1")
>> ; CHECK: indirectbr i8* [[RECOVER2]], []
>> ;
>> ; CHECK: }
>>
>> -; CHECK: define internal i8* @"\01?test@@YAXXZ.catch.1"(i8*, i8*)
>> -; CHECK: entry:
>> -; CHECK: [[RECOVER_F:\%.+]] = call i8* @llvm.framerecover(i8* bitcast
>> (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 1)
>> -; CHECK: [[F_PTR:\%.+]] = bitcast i8* [[RECOVER_F]] to float*
>> -; CHECK: [[TMP2:\%.+]] = load float, float* [[F_PTR]], align 4
>> -; CHECK: call void @"\01?handle_float@@YAXM at Z"(float [[TMP2]])
>> -; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ", %try.cont19)
>> -; CHECK: }
>> -
>> -; CHECK: define internal i8* @"\01?test@@YAXXZ.catch.2"(i8*, i8*)
>> -; CHECK: entry:
>> -; CHECK: [[RECOVER_J:\%.+]] = call i8* @llvm.framerecover(i8* bitcast
>> (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 2)
>> -; CHECK: [[J_PTR:\%.+]] = bitcast i8* [[RECOVER_J]] to i32*
>> -; CHECK: [[RECOVER_I1:\%.+]] = call i8* @llvm.framerecover(i8* bitcast
>> (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 0)
>> -; CHECK: [[I_PTR1:\%.+]] = bitcast i8* [[RECOVER_I1]] to i32*
>> -; CHECK: [[TMP3:\%.+]] = load i32, i32* [[J_PTR]], align 4
>> -; CHECK: store i32 [[TMP3]], i32* [[I_PTR1]]
>> -; CHECK: ret i8* blockaddress(@"\01?test@@YAXXZ.catch", %invoke.cont2)
>> -; CHECK: }
>> -
>> -
>> declare void @"\01?may_throw@@YAXXZ"() #1
>>
>> declare i32 @__CxxFrameHandler3(...)
>>
>> Modified: llvm/trunk/test/CodeGen/WinEH/cppeh-nested-rethrow.ll
>> URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/test/CodeGen/WinEH/cppeh-nested-rethrow.ll?rev=237854&r1=237853&r2=237854&view=diff
>>
>> ==============================================================================
>> --- llvm/trunk/test/CodeGen/WinEH/cppeh-nested-rethrow.ll (original)
>> +++ llvm/trunk/test/CodeGen/WinEH/cppeh-nested-rethrow.ll Wed May 20
>> 18:22:24 2015
>> @@ -180,26 +180,24 @@ unreachable:
>> ; CHECK: }
>> }
>>
>> -; The outlined test1.catch handler should not contain a return
>> instruction.
>> +; The outlined test1.catch handler should return to a valid block
>> address.
>> ; CHECK-LABEL: define internal i8* @"\01?test1@@YAXXZ.catch"(i8*, i8*)
>> -; CHECK-NOT: ret
>> +; CHECK-NOT: ret i8* inttoptr (i32 1 to i8*)
>> ; CHECK: }
>>
>> -; The outlined test1.catch1 handler should return to a valid block
>> address.
>> +; The outlined test1.catch1 handler should not contain a return
>> instruction.
>> ; CHECK-LABEL: define internal i8* @"\01?test1@@YAXXZ.catch.1"(i8*, i8*)
>> -; WILL-CHECK: ret i8* inttoptr (
>> -; CHECK-NOT: ret i8* inttoptr (i32 1 to i8*)
>> +; CHECK-NOT: ret
>> ; CHECK: }
>>
>> -; The outlined test2.catch handler should not contain a return
>> instruction.
>> +; The outlined test2.catch handler should return to a valid block
>> address.
>> ; CHECK-LABEL: define internal i8* @"\01?test2@@YAXXZ.catch"(i8*, i8*)
>> -; CHECK-NOT: ret
>> +; CHECK-NOT: ret i8* inttoptr (i32 1 to i8*)
>> ; CHECK: }
>>
>> -; The outlined test2.catch1 handler should return to a valid block
>> address.
>> +; The outlined test2.catch2 handler should not contain a return
>> instruction.
>> ; CHECK-LABEL: define internal i8* @"\01?test2@@YAXXZ.catch.2"(i8*, i8*)
>> -; WILL-CHECK: ret i8* inttoptr (
>> -; CHECK-NOT: ret i8* inttoptr (i32 1 to i8*)
>> +; CHECK-NOT: ret
>> ; CHECK: }
>>
>>
>>
>> Modified: llvm/trunk/test/CodeGen/WinEH/cppeh-similar-catch-blocks.ll
>> URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/test/CodeGen/WinEH/cppeh-similar-catch-blocks.ll?rev=237854&r1=237853&r2=237854&view=diff
>>
>> ==============================================================================
>> --- llvm/trunk/test/CodeGen/WinEH/cppeh-similar-catch-blocks.ll (original)
>> +++ llvm/trunk/test/CodeGen/WinEH/cppeh-similar-catch-blocks.ll Wed May
>> 20 18:22:24 2015
>> @@ -86,7 +86,7 @@ $"\01??_C at _03PMGGPEJJ@?$CFd?6?$AA@" = co
>> ; This is just a minimal check to verify that main was handled by
>> WinEHPrepare.
>> ; CHECK: define i32 @main()
>> ; CHECK: entry:
>> -; CHECK: call void (...) @llvm.frameescape(i8* [[C_PTR:\%.+]], i32*
>> [[X_PTR:\%.+]], i8* [[C2_PTR:\%.+]], i32* [[X2_PTR:\%.+]], i8*
>> [[C3_PTR:\%.+]])
>> +; CHECK: call void (...) @llvm.frameescape(i32* [[X_PTR:\%.+]], i32*
>> [[X2_PTR:\%.+]], i8* [[C2_PTR:\%.+]], i8* [[C3_PTR:\%.+]], i8*
>> [[C_PTR:\%.+]])
>> ; CHECK: invoke void @_CxxThrowException
>> ; CHECK: }
>>
>>
>> Modified: llvm/trunk/test/CodeGen/WinEH/cppeh-state-calc-1.ll
>> URL:
>> http://llvm.org/viewvc/llvm-project/llvm/trunk/test/CodeGen/WinEH/cppeh-state-calc-1.ll?rev=237854&r1=237853&r2=237854&view=diff
>>
>> ==============================================================================
>> --- llvm/trunk/test/CodeGen/WinEH/cppeh-state-calc-1.ll (original)
>> +++ llvm/trunk/test/CodeGen/WinEH/cppeh-state-calc-1.ll Wed May 20
>> 18:22:24 2015
>> @@ -274,16 +274,16 @@ attributes #5 = { noreturn }
>> ; CHECK-NEXT: .long .Lfunc_begin0 at IMGREL
>> ; CHECK-NEXT: .long -1
>> ; CHECK-NEXT: .long .Ltmp0 at IMGREL
>> -; CHECK-NEXT: .long 3
>> -; CHECK-NEXT: .long .Ltmp3 at IMGREL
>> ; CHECK-NEXT: .long 2
>> -; CHECK-NEXT: .long .Ltmp6 at IMGREL
>> +; CHECK-NEXT: .long .Ltmp3 at IMGREL
>> ; CHECK-NEXT: .long 1
>> +; CHECK-NEXT: .long .Ltmp6 at IMGREL
>> +; CHECK-NEXT: .long 0
>> ; CHECK-NEXT: .long .Lfunc_begin1 at IMGREL
>> -; CHECK-NEXT: .long 4
>> +; CHECK-NEXT: .long 3
>> ; CHECK-NEXT: .long .Lfunc_begin2 at IMGREL
>> -; CHECK-NEXT: .long 5
>> +; CHECK-NEXT: .long 4
>> ; CHECK-NEXT: .long .Lfunc_begin3 at IMGREL
>> -; CHECK-NEXT: .long 6
>> +; CHECK-NEXT: .long 5
>> ; CHECK-NEXT: .long .Lfunc_begin4 at IMGREL
>> -; CHECK-NEXT: .long 7
>> +; CHECK-NEXT: .long 6
>>
>>
>> _______________________________________________
>> llvm-commits mailing list
>> llvm-commits at cs.uiuc.edu
>> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20150521/3a503436/attachment.html>
More information about the llvm-commits
mailing list