[WinEH] Recognize CoreCLR personality function

[JosephTremoulet]

Summary

• Add CoreCLR to if/else ladders and switches as appropriate.
• Rename isMSVCEHPersonality to isFuncletEHPersonality to better reflect what it captures.

[JosephTremoulet]

I'm not wedded to the name isWinCFIPersonality if people are opposed to conflating WinCFI with use of these handlers. I just thought MSVC didn't make sense with CLR included. I thought about isWinEHPersonality and variants, but since (a) we don't use these on e.g. MinGW and (b) CoreCLR will likely use these on non-Windows, tying it to WinCFI seemed most apt.

[rnk]

In D13449#260132, @JosephTremoulet wrote:

I'm not wedded to the name isWinCFIPersonality if people are opposed to conflating WinCFI with use of these handlers. I just thought MSVC didn't make sense with CLR included. I thought about isWinEHPersonality and variants, but since (a) we don't use these on e.g. MinGW and (b) CoreCLR will likely use these on non-Windows, tying it to WinCFI seemed most apt.

I agree, MSVC doesn't make sense. I don't think "CFI" makes sense, since that's mainly about call frame information, which x86 Windows doesn't even have. My first thought was that it should be isWinEHPersonality. I rationalized that the CoreCLR personality comes from Windows even if it works elsewhere, and __gxx_personality_seh0 comes from Unix even though it runs on Windows.

David likes isFuncletEHPersonality, and I think that's a winner for me. Does that sound like a reasonable shade of chartreuse for the bikeshed? :)

[JosephTremoulet]

In D13449#260224, @rnk wrote:

In D13449#260132, @JosephTremoulet wrote:

I'm not wedded to the name isWinCFIPersonality if people are opposed to conflating WinCFI with use of these handlers. I just thought MSVC didn't make sense with CLR included. I thought about isWinEHPersonality and variants, but since (a) we don't use these on e.g. MinGW and (b) CoreCLR will likely use these on non-Windows, tying it to WinCFI seemed most apt.

I agree, MSVC doesn't make sense. I don't think "CFI" makes sense, since that's mainly about call frame information, which x86 Windows doesn't even have. My first thought was that it should be isWinEHPersonality. I rationalized that the CoreCLR personality comes from Windows even if it works elsewhere, and __gxx_personality_seh0 comes from Unix even though it runs on Windows.

David likes isFuncletEHPersonality, and I think that's a winner for me. Does that sound like a reasonable shade of chartreuse for the bikeshed? :)

Yeah, isFuncletEHPersonality sounds better than the others to me, will update. Thanks!

[JosephTremoulet]

• Rename isWinCFIPersonality -> isFuncletEHPersonality
• Rebase

[rnk]

lgtm

include/llvm/Analysis/LibCallSemantics.h

enum class EHPersonality {
     Unknown,
     GNU_Ada,
     GNU_C,
     GNU_CXX,
     GNU_ObjC,
     MSVC_X86SEH,
     MSVC_Win64SEH,
     MSVC_CXX,
+    CoreCLR
   };
 
   /// \brief See if the given exception handling personality function is one
   /// that we understand.  If so, return a description of it; otherwise return
   /// Unknown.
   EHPersonality classifyEHPersonality(const Value *Pers);
 
   /// \brief Returns true if this personality function catches asynchronous
   /// exceptions.
   inline bool isAsynchronousEHPersonality(EHPersonality Pers) {
     // The two SEH personality functions can catch asynch exceptions. We assume
     // unknown personalities don't catch asynch exceptions.
     switch (Pers) {
     case EHPersonality::MSVC_X86SEH:
     case EHPersonality::MSVC_Win64SEH:
       return true;
     default: return false;
     }
     llvm_unreachable("invalid enum");
   }
 
-  /// \brief Returns true if this is an MSVC personality function.
-  inline bool isMSVCEHPersonality(EHPersonality Pers) {
-    // The two SEH personality functions can catch asynch exceptions. We assume
-    // unknown personalities don't catch asynch exceptions.
+  /// \brief Returns true if this is a personality function that invokes
+  /// handler funclets (which must return to it).
+  inline bool isFuncletEHPersonality(EHPersonality Pers) {
     switch (Pers) {
     case EHPersonality::MSVC_CXX:
     case EHPersonality::MSVC_X86SEH:
     case EHPersonality::MSVC_Win64SEH:
+    case EHPersonality::CoreCLR:
       return true;
     default: return false;
     }
     llvm_unreachable("invalid enum");
   }
 
   /// \brief Return true if this personality may be safely removed if there
   /// are no invoke instructions remaining in the current function.

lib/Analysis/LibCallSemantics.cpp

return StringSwitch<EHPersonality>(F->getName())
     .Case("__gnat_eh_personality", EHPersonality::GNU_Ada)
     .Case("__gxx_personality_v0",  EHPersonality::GNU_CXX)
     .Case("__gcc_personality_v0",  EHPersonality::GNU_C)
     .Case("__objc_personality_v0", EHPersonality::GNU_ObjC)
     .Case("_except_handler3",      EHPersonality::MSVC_X86SEH)
     .Case("_except_handler4",      EHPersonality::MSVC_X86SEH)
     .Case("__C_specific_handler",  EHPersonality::MSVC_Win64SEH)
     .Case("__CxxFrameHandler3",    EHPersonality::MSVC_CXX)
+    .Case("ProcessCLRException",   EHPersonality::CoreCLR)
     .Default(EHPersonality::Unknown);
 }
 
 bool llvm::canSimplifyInvokeNoUnwind(const Function *F) {
   EHPersonality Personality = classifyEHPersonality(F->getPersonalityFn());
   // We can't simplify any invokes to nounwind functions if the personality
   // function wants to catch asynch exceptions.  The nounwind attribute only
   // implies that the function does not throw synchronous exceptions.
   return !isAsynchronousEHPersonality(Personality);
 }

lib/CodeGen/AsmPrinter/WinException.cpp

void WinException::endFunction(const MachineFunction *MF) {
   if (!shouldEmitPersonality && !shouldEmitMoves && !shouldEmitLSDA)
     return;
 
   const Function *F = MF->getFunction();
   EHPersonality Per = EHPersonality::Unknown;
   if (F->hasPersonalityFn())
     Per = classifyEHPersonality(F->getPersonalityFn());
 
-  // Get rid of any dead landing pads if we're not using a Windows EH scheme. In
-  // Windows EH schemes, the landing pad is not actually reachable. It only
-  // exists so that we can emit the right table data.
-  if (!isMSVCEHPersonality(Per))
+  // Get rid of any dead landing pads if we're not using funclets. In funclet
+  // schemes, the landing pad is not actually reachable. It only exists so
+  // that we can emit the right table data.
+  if (!isFuncletEHPersonality(Per))
     MMI->TidyLandingPads();
 
   endFunclet();
 
   // endFunclet will emit the necessary .xdata tables for x64 SEH.
   if (Per == EHPersonality::MSVC_Win64SEH && MMI->hasEHFunclets())
     return;
 

lib/CodeGen/DwarfEHPrepare.cpp

for (BasicBlock &BB : Fn) {
     if (auto *LP = BB.getLandingPadInst())
       if (LP->isCleanup())
         CleanupLPads.push_back(LP);
   }
 
   if (Resumes.empty())
     return false;
 
-  // Check the personality, don't do anything if it's for MSVC.
+  // Check the personality, don't do anything if it's funclet-based.
   EHPersonality Pers = classifyEHPersonality(Fn.getPersonalityFn());
-  if (isMSVCEHPersonality(Pers))
+  if (isFuncletEHPersonality(Pers))
     return false;
 
   LLVMContext &Ctx = Fn.getContext();
 
   size_t ResumesLeft = pruneUnreachableResumes(Fn, Resumes, CleanupLPads);
   if (ResumesLeft == 0)
     return true; // We pruned them all.
 

lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp

void FunctionLoweringInfo::set(const Function &fn, MachineFunction &mf,
   for (BB = Fn->begin(); BB != EB; ++BB) {
     const Instruction *FNP = BB->getFirstNonPHI();
     if (BB->isEHPad() && MBBMap.count(BB))
       MBBMap[BB]->setIsEHPad();
     if (const auto *LPI = dyn_cast<LandingPadInst>(FNP))
       LPads.push_back(LPI);
   }
 
-  // If this is an MSVC EH personality, we need to do a bit more work.
+  // If this personality uses funclets, we need to do a bit more work.
   if (!Fn->hasPersonalityFn())
     return;
   EHPersonality Personality = classifyEHPersonality(Fn->getPersonalityFn());
-  if (!isMSVCEHPersonality(Personality))
+  if (!isFuncletEHPersonality(Personality))
     return;
 
   if (Personality == EHPersonality::MSVC_Win64SEH ||
       Personality == EHPersonality::MSVC_X86SEH) {
     addSEHHandlersForLPads(LPads);
   }
 
   // Calculate state numbers if we haven't already.

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 /// destination, but in the machine CFG, we enumerate all the possible blocks.
 /// This function skips over imaginary basic blocks that hold catchpad,
 /// terminatepad, or catchendpad instructions, and finds all the "real" machine
 /// basic block destinations.
 static void
 findUnwindDestinations(FunctionLoweringInfo &FuncInfo,
                        const BasicBlock *EHPadBB,
                        SmallVectorImpl<MachineBasicBlock *> &UnwindDests) {
-  bool IsMSVCCXX = classifyEHPersonality(FuncInfo.Fn->getPersonalityFn()) ==
-                   EHPersonality::MSVC_CXX;
+  EHPersonality Personality =
+    classifyEHPersonality(FuncInfo.Fn->getPersonalityFn());
+  bool IsMSVCCXX = Personality == EHPersonality::MSVC_CXX;
+  bool IsCoreCLR = Personality == EHPersonality::CoreCLR;
   while (EHPadBB) {
     const Instruction *Pad = EHPadBB->getFirstNonPHI();
     if (isa<LandingPadInst>(Pad)) {
       // Stop on landingpads. They are not funclets.
       UnwindDests.push_back(FuncInfo.MBBMap[EHPadBB]);
       break;
     } else if (isa<CleanupPadInst>(Pad)) {
       // Stop on cleanup pads. Cleanups are always funclet entries for all known
       // personalities.
       UnwindDests.push_back(FuncInfo.MBBMap[EHPadBB]);
       UnwindDests.back()->setIsEHFuncletEntry();
       break;
     } else if (const auto *CPI = dyn_cast<CatchPadInst>(Pad)) {
       // Add the catchpad handler to the possible destinations.
       UnwindDests.push_back(FuncInfo.MBBMap[CPI->getNormalDest()]);
-      // In MSVC C++, catchblocks are funclets and need prologues.
-      if (IsMSVCCXX)
+      // In MSVC C++ and CoreCLR, catchblocks are funclets and need prologues.
+      if (IsMSVCCXX || IsCoreCLR)
         UnwindDests.back()->setIsEHFuncletEntry();
       EHPadBB = CPI->getUnwindDest();
     } else if (const auto *CEPI = dyn_cast<CatchEndPadInst>(Pad)) {
       EHPadBB = CEPI->getUnwindDest();
     } else if (const auto *CEPI = dyn_cast<CleanupEndPadInst>(Pad)) {
       EHPadBB = CEPI->getUnwindDest();
     }
   }

lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

bool SelectionDAGISel::PrepareEHLandingPad() {
 
   // Assign the call site to the landing pad's begin label.
   MF->getMMI().setCallSiteLandingPad(Label, SDB->LPadToCallSiteMap[MBB]);
 
   const MCInstrDesc &II = TII->get(TargetOpcode::EH_LABEL);
   BuildMI(*MBB, FuncInfo->InsertPt, SDB->getCurDebugLoc(), II)
     .addSym(Label);
 
-  // If this is an MSVC-style personality function, we need to split the landing
+  // If this personality function uses funclets, we need to split the landing
   // pad into several BBs.
   const BasicBlock *LLVMBB = MBB->getBasicBlock();
   const Constant *Personality = MF->getFunction()->getPersonalityFn();
   if (const auto *PF = dyn_cast<Function>(Personality->stripPointerCasts()))
     MF->getMMI().addPersonality(PF);
   EHPersonality PersonalityType = classifyEHPersonality(Personality);
 
-  if (isMSVCEHPersonality(PersonalityType)) {
+  if (isFuncletEHPersonality(PersonalityType)) {
     SmallVector<MachineBasicBlock *, 4> ClauseBBs;
     const IntrinsicInst *ActionsCall =
         dyn_cast<IntrinsicInst>(LLVMBB->getFirstInsertionPt());
     // Get all invoke BBs that unwind to this landingpad.
     SmallVector<MachineBasicBlock *, 4> InvokeBBs(MBB->pred_begin(),
                                                   MBB->pred_end());
     if (ActionsCall && ActionsCall->getIntrinsicID() == Intrinsic::eh_actions) {
       // If this is a call to llvm.eh.actions followed by indirectbr, then we've

lib/CodeGen/WinEHPrepare.cpp

bool WinEHPrepare::runOnFunction(Function &Fn) {
 
   // No need to prepare outlined handlers.
   if (Fn.hasFnAttribute("wineh-parent"))
     return false;
 
   // Classify the personality to see what kind of preparation we need.
   Personality = classifyEHPersonality(Fn.getPersonalityFn());
 
-  // Do nothing if this is not an MSVC personality.
-  if (!isMSVCEHPersonality(Personality))
+  // Do nothing if this is not a funclet-based personality.
+  if (!isFuncletEHPersonality(Personality))
     return false;
 
   SmallVector<LandingPadInst *, 4> LPads;
   SmallVector<ResumeInst *, 4> Resumes;
   SmallVector<BasicBlock *, 4> EntryBlocks;
   bool ForExplicitEH =
       findExceptionalConstructs(Fn, LPads, Resumes, EntryBlocks);
 

lib/Target/X86/X86ISelLowering.cpp

X86TargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI,
   for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i)
     Ops.push_back(DAG.getRegister(RegsToPass[i].first,
                                   RegsToPass[i].second.getValueType()));
 
   // Add a register mask operand representing the call-preserved registers.
   const uint32_t *Mask = RegInfo->getCallPreservedMask(MF, CallConv);
   assert(Mask && "Missing call preserved mask for calling convention");
 
-  // If this is an invoke in a 32-bit function using an MSVC personality, assume
-  // the function clobbers all registers. If an exception is thrown, the runtime
-  // will not restore CSRs.
+  // If this is an invoke in a 32-bit function using a funclet-based
+  // personality, assume the function clobbers all registers. If an exception
+  // is thrown, the runtime will not restore CSRs.
   // FIXME: Model this more precisely so that we can register allocate across
   // the normal edge and spill and fill across the exceptional edge.
   if (!Is64Bit && CLI.CS && CLI.CS->isInvoke()) {
     const Function *CallerFn = MF.getFunction();
     EHPersonality Pers =
         CallerFn->hasPersonalityFn()
             ? classifyEHPersonality(CallerFn->getPersonalityFn())
             : EHPersonality::Unknown;
-    if (isMSVCEHPersonality(Pers))
+    if (isFuncletEHPersonality(Pers))
       Mask = RegInfo->getNoPreservedMask();
   }
 
   Ops.push_back(DAG.getRegisterMask(Mask));
 
   if (InFlag.getNode())
     Ops.push_back(InFlag);
 

lib/Target/X86/X86WinEHState.cpp

 bool WinEHStatePass::runOnFunction(Function &F) {
   // If this is an outlined handler, don't do anything. We'll do state insertion
   // for it in the parent.
   StringRef WinEHParentName =
       F.getFnAttribute("wineh-parent").getValueAsString();
   if (WinEHParentName != F.getName() && !WinEHParentName.empty())
     return false;
 
-  // Check the personality. Do nothing if this is not an MSVC personality.
+  // Check the personality. Do nothing if this personality doesn't use funclets.
   if (!F.hasPersonalityFn())
     return false;
   PersonalityFn =
       dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts());
   if (!PersonalityFn)
     return false;
   Personality = classifyEHPersonality(PersonalityFn);
-  if (!isMSVCEHPersonality(Personality))
+  if (!isFuncletEHPersonality(Personality))
     return false;
 
   // Skip this function if there are no EH pads and we aren't using IR-level
   // outlining.
   if (WinEHParentName.empty()) {
     bool HasPads = false;
     for (BasicBlock &BB : F) {
       if (BB.isEHPad()) {

lib/Transforms/InstCombine/InstructionCombining.cpp

case EHPersonality::GNU_Ada:
     // While __gnat_all_others_value will match any Ada exception, it doesn't
     // match foreign exceptions (or didn't, before gcc-4.7).
     return false;
   case EHPersonality::GNU_CXX:
   case EHPersonality::GNU_ObjC:
   case EHPersonality::MSVC_X86SEH:
   case EHPersonality::MSVC_Win64SEH:
   case EHPersonality::MSVC_CXX:
+  case EHPersonality::CoreCLR:
     return TypeInfo->isNullValue();
   }
   llvm_unreachable("invalid enum");
 }
 
 static bool shorter_filter(const Value *LHS, const Value *RHS) {
   return
     cast<ArrayType>(LHS->getType())->getNumElements()