contrib/llvm/lib/Target/X86/X86WinEHState.cpp

   1 //===-- X86WinEHState - Insert EH state updates for win32 exceptions ------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // All functions using an MSVC EH personality use an explicitly updated state
  11 // number stored in an exception registration stack object. The registration
  12 // object is linked into a thread-local chain of registrations stored at fs:00.
  13 // This pass adds the registration object and EH state updates.
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 #include "X86.h"
  18 #include "llvm/ADT/PostOrderIterator.h"
  19 #include "llvm/Analysis/CFG.h"
  20 #include "llvm/Analysis/EHPersonalities.h"
  21 #include "llvm/CodeGen/MachineModuleInfo.h"
  22 #include "llvm/CodeGen/WinEHFuncInfo.h"
  23 #include "llvm/IR/CallSite.h"
  24 #include "llvm/IR/Function.h"
  25 #include "llvm/IR/Instructions.h"
  26 #include "llvm/IR/IntrinsicInst.h"
  27 #include "llvm/IR/IRBuilder.h"
  28 #include "llvm/IR/Module.h"
  29 #include "llvm/Pass.h"
  30 #include "llvm/Support/Debug.h"
  31 #include <deque>
  32
  33 using namespace llvm;
  34
  35 #define DEBUG_TYPE "winehstate"
  36
  37 namespace llvm {
  38 void initializeWinEHStatePassPass(PassRegistry &);
  39 }
  40
  41 namespace {
  42 const int OverdefinedState = INT_MIN;
  43
  44 class WinEHStatePass : public FunctionPass {
  45 public:
  46   static char ID; // Pass identification, replacement for typeid.
  47
  48   WinEHStatePass() : FunctionPass(ID) {
  49     initializeWinEHStatePassPass(*PassRegistry::getPassRegistry());
  50   }
  51
  52   bool runOnFunction(Function &Fn) override;
  53
  54   bool doInitialization(Module &M) override;
  55
  56   bool doFinalization(Module &M) override;
  57
  58   void getAnalysisUsage(AnalysisUsage &AU) const override;
  59
  60   StringRef getPassName() const override {
  61     return "Windows 32-bit x86 EH state insertion";
  62   }
  63
  64 private:
  65   void emitExceptionRegistrationRecord(Function *F);
  66
  67   void linkExceptionRegistration(IRBuilder<> &Builder, Function *Handler);
  68   void unlinkExceptionRegistration(IRBuilder<> &Builder);
  69   void addStateStores(Function &F, WinEHFuncInfo &FuncInfo);
  70   void insertStateNumberStore(Instruction *IP, int State);
  71
  72   Value *emitEHLSDA(IRBuilder<> &Builder, Function *F);
  73
  74   Function *generateLSDAInEAXThunk(Function *ParentFunc);
  75
  76   bool isStateStoreNeeded(EHPersonality Personality, CallSite CS);
  77   void rewriteSetJmpCallSite(IRBuilder<> &Builder, Function &F, CallSite CS,
  78                              Value *State);
  79   int getBaseStateForBB(DenseMap<BasicBlock *, ColorVector> &BlockColors,
  80                         WinEHFuncInfo &FuncInfo, BasicBlock *BB);
  81   int getStateForCallSite(DenseMap<BasicBlock *, ColorVector> &BlockColors,
  82                           WinEHFuncInfo &FuncInfo, CallSite CS);
  83
  84   // Module-level type getters.
  85   Type *getEHLinkRegistrationType();
  86   Type *getSEHRegistrationType();
  87   Type *getCXXEHRegistrationType();
  88
  89   // Per-module data.
  90   Module *TheModule = nullptr;
  91   StructType *EHLinkRegistrationTy = nullptr;
  92   StructType *CXXEHRegistrationTy = nullptr;
  93   StructType *SEHRegistrationTy = nullptr;
  94   Constant *SetJmp3 = nullptr;
  95   Constant *CxxLongjmpUnwind = nullptr;
  96
  97   // Per-function state
  98   EHPersonality Personality = EHPersonality::Unknown;
  99   Function *PersonalityFn = nullptr;
 100   bool UseStackGuard = false;
 101   int ParentBaseState;
 102   Constant *SehLongjmpUnwind = nullptr;
 103   Constant *Cookie = nullptr;
 104
 105   /// The stack allocation containing all EH data, including the link in the
 106   /// fs:00 chain and the current state.
 107   AllocaInst *RegNode = nullptr;
 108
 109   // The allocation containing the EH security guard.
 110   AllocaInst *EHGuardNode = nullptr;
 111
 112   /// The index of the state field of RegNode.
 113   int StateFieldIndex = ~0U;
 114
 115   /// The linked list node subobject inside of RegNode.
 116   Value *Link = nullptr;
 117 };
 118 }
 119
 120 FunctionPass *llvm::createX86WinEHStatePass() { return new WinEHStatePass(); }
 121
 122 char WinEHStatePass::ID = 0;
 123
 124 INITIALIZE_PASS(WinEHStatePass, "x86-winehstate",
 125                 "Insert stores for EH state numbers", false, false)
 126
 127 bool WinEHStatePass::doInitialization(Module &M) {
 128   TheModule = &M;
 129   return false;
 130 }
 131
 132 bool WinEHStatePass::doFinalization(Module &M) {
 133   assert(TheModule == &M);
 134   TheModule = nullptr;
 135   EHLinkRegistrationTy = nullptr;
 136   CXXEHRegistrationTy = nullptr;
 137   SEHRegistrationTy = nullptr;
 138   SetJmp3 = nullptr;
 139   CxxLongjmpUnwind = nullptr;
 140   SehLongjmpUnwind = nullptr;
 141   Cookie = nullptr;
 142   return false;
 143 }
 144
 145 void WinEHStatePass::getAnalysisUsage(AnalysisUsage &AU) const {
 146   // This pass should only insert a stack allocation, memory accesses, and
 147   // localrecovers.
 148   AU.setPreservesCFG();
 149 }
 150
 151 bool WinEHStatePass::runOnFunction(Function &F) {
 152   // Check the personality. Do nothing if this personality doesn't use funclets.
 153   if (!F.hasPersonalityFn())
 154     return false;
 155   PersonalityFn =
 156       dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts());
 157   if (!PersonalityFn)
 158     return false;
 159   Personality = classifyEHPersonality(PersonalityFn);
 160   if (!isFuncletEHPersonality(Personality))
 161     return false;
 162
 163   // Skip this function if there are no EH pads and we aren't using IR-level
 164   // outlining.
 165   bool HasPads = false;
 166   for (BasicBlock &BB : F) {
 167     if (BB.isEHPad()) {
 168       HasPads = true;
 169       break;
 170     }
 171   }
 172   if (!HasPads)
 173     return false;
 174
 175   Type *Int8PtrType = Type::getInt8PtrTy(TheModule->getContext());
 176   SetJmp3 = TheModule->getOrInsertFunction(
 177       "_setjmp3", FunctionType::get(
 178                       Type::getInt32Ty(TheModule->getContext()),
 179                       {Int8PtrType, Type::getInt32Ty(TheModule->getContext())},
 180                       /*isVarArg=*/true));
 181
 182   // Disable frame pointer elimination in this function.
 183   // FIXME: Do the nested handlers need to keep the parent ebp in ebp, or can we
 184   // use an arbitrary register?
 185   F.addFnAttr("no-frame-pointer-elim", "true");
 186
 187   emitExceptionRegistrationRecord(&F);
 188
 189   // The state numbers calculated here in IR must agree with what we calculate
 190   // later on for the MachineFunction. In particular, if an IR pass deletes an
 191   // unreachable EH pad after this point before machine CFG construction, we
 192   // will be in trouble. If this assumption is ever broken, we should turn the
 193   // numbers into an immutable analysis pass.
 194   WinEHFuncInfo FuncInfo;
 195   addStateStores(F, FuncInfo);
 196
 197   // Reset per-function state.
 198   PersonalityFn = nullptr;
 199   Personality = EHPersonality::Unknown;
 200   UseStackGuard = false;
 201   RegNode = nullptr;
 202   EHGuardNode = nullptr;
 203
 204   return true;
 205 }
 206
 207 /// Get the common EH registration subobject:
 208 ///   typedef _EXCEPTION_DISPOSITION (*PEXCEPTION_ROUTINE)(
 209 ///       _EXCEPTION_RECORD *, void *, _CONTEXT *, void *);
 210 ///   struct EHRegistrationNode {
 211 ///     EHRegistrationNode *Next;
 212 ///     PEXCEPTION_ROUTINE Handler;
 213 ///   };
 214 Type *WinEHStatePass::getEHLinkRegistrationType() {
 215   if (EHLinkRegistrationTy)
 216     return EHLinkRegistrationTy;
 217   LLVMContext &Context = TheModule->getContext();
 218   EHLinkRegistrationTy = StructType::create(Context, "EHRegistrationNode");
 219   Type *FieldTys[] = {
 220       EHLinkRegistrationTy->getPointerTo(0), // EHRegistrationNode *Next
 221       Type::getInt8PtrTy(Context) // EXCEPTION_DISPOSITION (*Handler)(...)
 222   };
 223   EHLinkRegistrationTy->setBody(FieldTys, false);
 224   return EHLinkRegistrationTy;
 225 }
 226
 227 /// The __CxxFrameHandler3 registration node:
 228 ///   struct CXXExceptionRegistration {
 229 ///     void *SavedESP;
 230 ///     EHRegistrationNode SubRecord;
 231 ///     int32_t TryLevel;
 232 ///   };
 233 Type *WinEHStatePass::getCXXEHRegistrationType() {
 234   if (CXXEHRegistrationTy)
 235     return CXXEHRegistrationTy;
 236   LLVMContext &Context = TheModule->getContext();
 237   Type *FieldTys[] = {
 238       Type::getInt8PtrTy(Context), // void *SavedESP
 239       getEHLinkRegistrationType(), // EHRegistrationNode SubRecord
 240       Type::getInt32Ty(Context)    // int32_t TryLevel
 241   };
 242   CXXEHRegistrationTy =
 243       StructType::create(FieldTys, "CXXExceptionRegistration");
 244   return CXXEHRegistrationTy;
 245 }
 246
 247 /// The _except_handler3/4 registration node:
 248 ///   struct EH4ExceptionRegistration {
 249 ///     void *SavedESP;
 250 ///     _EXCEPTION_POINTERS *ExceptionPointers;
 251 ///     EHRegistrationNode SubRecord;
 252 ///     int32_t EncodedScopeTable;
 253 ///     int32_t TryLevel;
 254 ///   };
 255 Type *WinEHStatePass::getSEHRegistrationType() {
 256   if (SEHRegistrationTy)
 257     return SEHRegistrationTy;
 258   LLVMContext &Context = TheModule->getContext();
 259   Type *FieldTys[] = {
 260       Type::getInt8PtrTy(Context), // void *SavedESP
 261       Type::getInt8PtrTy(Context), // void *ExceptionPointers
 262       getEHLinkRegistrationType(), // EHRegistrationNode SubRecord
 263       Type::getInt32Ty(Context),   // int32_t EncodedScopeTable
 264       Type::getInt32Ty(Context)    // int32_t TryLevel
 265   };
 266   SEHRegistrationTy = StructType::create(FieldTys, "SEHExceptionRegistration");
 267   return SEHRegistrationTy;
 268 }
 269
 270 // Emit an exception registration record. These are stack allocations with the
 271 // common subobject of two pointers: the previous registration record (the old
 272 // fs:00) and the personality function for the current frame. The data before
 273 // and after that is personality function specific.
 274 void WinEHStatePass::emitExceptionRegistrationRecord(Function *F) {
 275   assert(Personality == EHPersonality::MSVC_CXX ||
 276          Personality == EHPersonality::MSVC_X86SEH);
 277
 278   // Struct type of RegNode. Used for GEPing.
 279   Type *RegNodeTy;
 280
 281   IRBuilder<> Builder(&F->getEntryBlock(), F->getEntryBlock().begin());
 282   Type *Int8PtrType = Builder.getInt8PtrTy();
 283   Type *Int32Ty = Builder.getInt32Ty();
 284   Type *VoidTy = Builder.getVoidTy();
 285
 286   if (Personality == EHPersonality::MSVC_CXX) {
 287     RegNodeTy = getCXXEHRegistrationType();
 288     RegNode = Builder.CreateAlloca(RegNodeTy);
 289     // SavedESP = llvm.stacksave()
 290     Value *SP = Builder.CreateCall(
 291         Intrinsic::getDeclaration(TheModule, Intrinsic::stacksave), {});
 292     Builder.CreateStore(SP, Builder.CreateStructGEP(RegNodeTy, RegNode, 0));
 293     // TryLevel = -1
 294     StateFieldIndex = 2;
 295     ParentBaseState = -1;
 296     insertStateNumberStore(&*Builder.GetInsertPoint(), ParentBaseState);
 297     // Handler = __ehhandler$F
 298     Function *Trampoline = generateLSDAInEAXThunk(F);
 299     Link = Builder.CreateStructGEP(RegNodeTy, RegNode, 1);
 300     linkExceptionRegistration(Builder, Trampoline);
 301
 302     CxxLongjmpUnwind = TheModule->getOrInsertFunction(
 303         "__CxxLongjmpUnwind",
 304         FunctionType::get(VoidTy, Int8PtrType, /*isVarArg=*/false));
 305     cast<Function>(CxxLongjmpUnwind->stripPointerCasts())
 306         ->setCallingConv(CallingConv::X86_StdCall);
 307   } else if (Personality == EHPersonality::MSVC_X86SEH) {
 308     // If _except_handler4 is in use, some additional guard checks and prologue
 309     // stuff is required.
 310     StringRef PersonalityName = PersonalityFn->getName();
 311     UseStackGuard = (PersonalityName == "_except_handler4");
 312
 313     // Allocate local structures.
 314     RegNodeTy = getSEHRegistrationType();
 315     RegNode = Builder.CreateAlloca(RegNodeTy);
 316     if (UseStackGuard)
 317       EHGuardNode = Builder.CreateAlloca(Int32Ty);
 318
 319     // SavedESP = llvm.stacksave()
 320     Value *SP = Builder.CreateCall(
 321         Intrinsic::getDeclaration(TheModule, Intrinsic::stacksave), {});
 322     Builder.CreateStore(SP, Builder.CreateStructGEP(RegNodeTy, RegNode, 0));
 323     // TryLevel = -2 / -1
 324     StateFieldIndex = 4;
 325     ParentBaseState = UseStackGuard ? -2 : -1;
 326     insertStateNumberStore(&*Builder.GetInsertPoint(), ParentBaseState);
 327     // ScopeTable = llvm.x86.seh.lsda(F)
 328     Value *LSDA = emitEHLSDA(Builder, F);
 329     LSDA = Builder.CreatePtrToInt(LSDA, Int32Ty);
 330     // If using _except_handler4, xor the address of the table with
 331     // __security_cookie.
 332     if (UseStackGuard) {
 333       Cookie = TheModule->getOrInsertGlobal("__security_cookie", Int32Ty);
 334       Value *Val = Builder.CreateLoad(Int32Ty, Cookie, "cookie");
 335       LSDA = Builder.CreateXor(LSDA, Val);
 336     }
 337     Builder.CreateStore(LSDA, Builder.CreateStructGEP(RegNodeTy, RegNode, 3));
 338
 339     // If using _except_handler4, the EHGuard contains: FramePtr xor Cookie.
 340     if (UseStackGuard) {
 341       Value *Val = Builder.CreateLoad(Int32Ty, Cookie);
 342       Value *FrameAddr = Builder.CreateCall(
 343           Intrinsic::getDeclaration(TheModule, Intrinsic::frameaddress),
 344           Builder.getInt32(0), "frameaddr");
 345       Value *FrameAddrI32 = Builder.CreatePtrToInt(FrameAddr, Int32Ty);
 346       FrameAddrI32 = Builder.CreateXor(FrameAddrI32, Val);
 347       Builder.CreateStore(FrameAddrI32, EHGuardNode);
 348     }
 349
 350     // Register the exception handler.
 351     Link = Builder.CreateStructGEP(RegNodeTy, RegNode, 2);
 352     linkExceptionRegistration(Builder, PersonalityFn);
 353
 354     SehLongjmpUnwind = TheModule->getOrInsertFunction(
 355         UseStackGuard ? "_seh_longjmp_unwind4" : "_seh_longjmp_unwind",
 356         FunctionType::get(Type::getVoidTy(TheModule->getContext()), Int8PtrType,
 357                           /*isVarArg=*/false));
 358     cast<Function>(SehLongjmpUnwind->stripPointerCasts())
 359         ->setCallingConv(CallingConv::X86_StdCall);
 360   } else {
 361     llvm_unreachable("unexpected personality function");
 362   }
 363
 364   // Insert an unlink before all returns.
 365   for (BasicBlock &BB : *F) {
 366     TerminatorInst *T = BB.getTerminator();
 367     if (!isa<ReturnInst>(T))
 368       continue;
 369     Builder.SetInsertPoint(T);
 370     unlinkExceptionRegistration(Builder);
 371   }
 372 }
 373
 374 Value *WinEHStatePass::emitEHLSDA(IRBuilder<> &Builder, Function *F) {
 375   Value *FI8 = Builder.CreateBitCast(F, Type::getInt8PtrTy(F->getContext()));
 376   return Builder.CreateCall(
 377       Intrinsic::getDeclaration(TheModule, Intrinsic::x86_seh_lsda), FI8);
 378 }
 379
 380 /// Generate a thunk that puts the LSDA of ParentFunc in EAX and then calls
 381 /// PersonalityFn, forwarding the parameters passed to PEXCEPTION_ROUTINE:
 382 ///   typedef _EXCEPTION_DISPOSITION (*PEXCEPTION_ROUTINE)(
 383 ///       _EXCEPTION_RECORD *, void *, _CONTEXT *, void *);
 384 /// We essentially want this code:
 385 ///   movl $lsda, %eax
 386 ///   jmpl ___CxxFrameHandler3
 387 Function *WinEHStatePass::generateLSDAInEAXThunk(Function *ParentFunc) {
 388   LLVMContext &Context = ParentFunc->getContext();
 389   Type *Int32Ty = Type::getInt32Ty(Context);
 390   Type *Int8PtrType = Type::getInt8PtrTy(Context);
 391   Type *ArgTys[5] = {Int8PtrType, Int8PtrType, Int8PtrType, Int8PtrType,
 392                      Int8PtrType};
 393   FunctionType *TrampolineTy =
 394       FunctionType::get(Int32Ty, makeArrayRef(&ArgTys[0], 4),
 395                         /*isVarArg=*/false);
 396   FunctionType *TargetFuncTy =
 397       FunctionType::get(Int32Ty, makeArrayRef(&ArgTys[0], 5),
 398                         /*isVarArg=*/false);
 399   Function *Trampoline =
 400       Function::Create(TrampolineTy, GlobalValue::InternalLinkage,
 401                        Twine("__ehhandler$") + GlobalValue::getRealLinkageName(
 402                                                    ParentFunc->getName()),
 403                        TheModule);
 404   BasicBlock *EntryBB = BasicBlock::Create(Context, "entry", Trampoline);
 405   IRBuilder<> Builder(EntryBB);
 406   Value *LSDA = emitEHLSDA(Builder, ParentFunc);
 407   Value *CastPersonality =
 408       Builder.CreateBitCast(PersonalityFn, TargetFuncTy->getPointerTo());
 409   auto AI = Trampoline->arg_begin();
 410   Value *Args[5] = {LSDA, &*AI++, &*AI++, &*AI++, &*AI++};
 411   CallInst *Call = Builder.CreateCall(CastPersonality, Args);
 412   // Can't use musttail due to prototype mismatch, but we can use tail.
 413   Call->setTailCall(true);
 414   // Set inreg so we pass it in EAX.
 415   Call->addParamAttr(0, Attribute::InReg);
 416   Builder.CreateRet(Call);
 417   return Trampoline;
 418 }
 419
 420 void WinEHStatePass::linkExceptionRegistration(IRBuilder<> &Builder,
 421                                                Function *Handler) {
 422   // Emit the .safeseh directive for this function.
 423   Handler->addFnAttr("safeseh");
 424
 425   Type *LinkTy = getEHLinkRegistrationType();
 426   // Handler = Handler
 427   Value *HandlerI8 = Builder.CreateBitCast(Handler, Builder.getInt8PtrTy());
 428   Builder.CreateStore(HandlerI8, Builder.CreateStructGEP(LinkTy, Link, 1));
 429   // Next = [fs:00]
 430   Constant *FSZero =
 431       Constant::getNullValue(LinkTy->getPointerTo()->getPointerTo(257));
 432   Value *Next = Builder.CreateLoad(FSZero);
 433   Builder.CreateStore(Next, Builder.CreateStructGEP(LinkTy, Link, 0));
 434   // [fs:00] = Link
 435   Builder.CreateStore(Link, FSZero);
 436 }
 437
 438 void WinEHStatePass::unlinkExceptionRegistration(IRBuilder<> &Builder) {
 439   // Clone Link into the current BB for better address mode folding.
 440   if (auto *GEP = dyn_cast<GetElementPtrInst>(Link)) {
 441     GEP = cast<GetElementPtrInst>(GEP->clone());
 442     Builder.Insert(GEP);
 443     Link = GEP;
 444   }
 445   Type *LinkTy = getEHLinkRegistrationType();
 446   // [fs:00] = Link->Next
 447   Value *Next =
 448       Builder.CreateLoad(Builder.CreateStructGEP(LinkTy, Link, 0));
 449   Constant *FSZero =
 450       Constant::getNullValue(LinkTy->getPointerTo()->getPointerTo(257));
 451   Builder.CreateStore(Next, FSZero);
 452 }
 453
 454 // Calls to setjmp(p) are lowered to _setjmp3(p, 0) by the frontend.
 455 // The idea behind _setjmp3 is that it takes an optional number of personality
 456 // specific parameters to indicate how to restore the personality-specific frame
 457 // state when longjmp is initiated.  Typically, the current TryLevel is saved.
 458 void WinEHStatePass::rewriteSetJmpCallSite(IRBuilder<> &Builder, Function &F,
 459                                            CallSite CS, Value *State) {
 460   // Don't rewrite calls with a weird number of arguments.
 461   if (CS.getNumArgOperands() != 2)
 462     return;
 463
 464   Instruction *Inst = CS.getInstruction();
 465
 466   SmallVector<OperandBundleDef, 1> OpBundles;
 467   CS.getOperandBundlesAsDefs(OpBundles);
 468
 469   SmallVector<Value *, 3> OptionalArgs;
 470   if (Personality == EHPersonality::MSVC_CXX) {
 471     OptionalArgs.push_back(CxxLongjmpUnwind);
 472     OptionalArgs.push_back(State);
 473     OptionalArgs.push_back(emitEHLSDA(Builder, &F));
 474   } else if (Personality == EHPersonality::MSVC_X86SEH) {
 475     OptionalArgs.push_back(SehLongjmpUnwind);
 476     OptionalArgs.push_back(State);
 477     if (UseStackGuard)
 478       OptionalArgs.push_back(Cookie);
 479   } else {
 480     llvm_unreachable("unhandled personality!");
 481   }
 482
 483   SmallVector<Value *, 5> Args;
 484   Args.push_back(
 485       Builder.CreateBitCast(CS.getArgOperand(0), Builder.getInt8PtrTy()));
 486   Args.push_back(Builder.getInt32(OptionalArgs.size()));
 487   Args.append(OptionalArgs.begin(), OptionalArgs.end());
 488
 489   CallSite NewCS;
 490   if (CS.isCall()) {
 491     auto *CI = cast<CallInst>(Inst);
 492     CallInst *NewCI = Builder.CreateCall(SetJmp3, Args, OpBundles);
 493     NewCI->setTailCallKind(CI->getTailCallKind());
 494     NewCS = NewCI;
 495   } else {
 496     auto *II = cast<InvokeInst>(Inst);
 497     NewCS = Builder.CreateInvoke(
 498         SetJmp3, II->getNormalDest(), II->getUnwindDest(), Args, OpBundles);
 499   }
 500   NewCS.setCallingConv(CS.getCallingConv());
 501   NewCS.setAttributes(CS.getAttributes());
 502   NewCS->setDebugLoc(CS->getDebugLoc());
 503
 504   Instruction *NewInst = NewCS.getInstruction();
 505   NewInst->takeName(Inst);
 506   Inst->replaceAllUsesWith(NewInst);
 507   Inst->eraseFromParent();
 508 }
 509
 510 // Figure out what state we should assign calls in this block.
 511 int WinEHStatePass::getBaseStateForBB(
 512     DenseMap<BasicBlock *, ColorVector> &BlockColors, WinEHFuncInfo &FuncInfo,
 513     BasicBlock *BB) {
 514   int BaseState = ParentBaseState;
 515   auto &BBColors = BlockColors[BB];
 516
 517   assert(BBColors.size() == 1 && "multi-color BB not removed by preparation");
 518   BasicBlock *FuncletEntryBB = BBColors.front();
 519   if (auto *FuncletPad =
 520           dyn_cast<FuncletPadInst>(FuncletEntryBB->getFirstNonPHI())) {
 521     auto BaseStateI = FuncInfo.FuncletBaseStateMap.find(FuncletPad);
 522     if (BaseStateI != FuncInfo.FuncletBaseStateMap.end())
 523       BaseState = BaseStateI->second;
 524   }
 525
 526   return BaseState;
 527 }
 528
 529 // Calculate the state a call-site is in.
 530 int WinEHStatePass::getStateForCallSite(
 531     DenseMap<BasicBlock *, ColorVector> &BlockColors, WinEHFuncInfo &FuncInfo,
 532     CallSite CS) {
 533   if (auto *II = dyn_cast<InvokeInst>(CS.getInstruction())) {
 534     // Look up the state number of the EH pad this unwinds to.
 535     assert(FuncInfo.InvokeStateMap.count(II) && "invoke has no state!");
 536     return FuncInfo.InvokeStateMap[II];
 537   }
 538   // Possibly throwing call instructions have no actions to take after
 539   // an unwind. Ensure they are in the -1 state.
 540   return getBaseStateForBB(BlockColors, FuncInfo, CS.getParent());
 541 }
 542
 543 // Calculate the intersection of all the FinalStates for a BasicBlock's
 544 // predecessors.
 545 static int getPredState(DenseMap<BasicBlock *, int> &FinalStates, Function &F,
 546                         int ParentBaseState, BasicBlock *BB) {
 547   // The entry block has no predecessors but we know that the prologue always
 548   // sets us up with a fixed state.
 549   if (&F.getEntryBlock() == BB)
 550     return ParentBaseState;
 551
 552   // This is an EH Pad, conservatively report this basic block as overdefined.
 553   if (BB->isEHPad())
 554     return OverdefinedState;
 555
 556   int CommonState = OverdefinedState;
 557   for (BasicBlock *PredBB : predecessors(BB)) {
 558     // We didn't manage to get a state for one of these predecessors,
 559     // conservatively report this basic block as overdefined.
 560     auto PredEndState = FinalStates.find(PredBB);
 561     if (PredEndState == FinalStates.end())
 562       return OverdefinedState;
 563
 564     // This code is reachable via exceptional control flow,
 565     // conservatively report this basic block as overdefined.
 566     if (isa<CatchReturnInst>(PredBB->getTerminator()))
 567       return OverdefinedState;
 568
 569     int PredState = PredEndState->second;
 570     assert(PredState != OverdefinedState &&
 571            "overdefined BBs shouldn't be in FinalStates");
 572     if (CommonState == OverdefinedState)
 573       CommonState = PredState;
 574
 575     // At least two predecessors have different FinalStates,
 576     // conservatively report this basic block as overdefined.
 577     if (CommonState != PredState)
 578       return OverdefinedState;
 579   }
 580
 581   return CommonState;
 582 }
 583
 584 // Calculate the intersection of all the InitialStates for a BasicBlock's
 585 // successors.
 586 static int getSuccState(DenseMap<BasicBlock *, int> &InitialStates, Function &F,
 587                         int ParentBaseState, BasicBlock *BB) {
 588   // This block rejoins normal control flow,
 589   // conservatively report this basic block as overdefined.
 590   if (isa<CatchReturnInst>(BB->getTerminator()))
 591     return OverdefinedState;
 592
 593   int CommonState = OverdefinedState;
 594   for (BasicBlock *SuccBB : successors(BB)) {
 595     // We didn't manage to get a state for one of these predecessors,
 596     // conservatively report this basic block as overdefined.
 597     auto SuccStartState = InitialStates.find(SuccBB);
 598     if (SuccStartState == InitialStates.end())
 599       return OverdefinedState;
 600
 601     // This is an EH Pad, conservatively report this basic block as overdefined.
 602     if (SuccBB->isEHPad())
 603       return OverdefinedState;
 604
 605     int SuccState = SuccStartState->second;
 606     assert(SuccState != OverdefinedState &&
 607            "overdefined BBs shouldn't be in FinalStates");
 608     if (CommonState == OverdefinedState)
 609       CommonState = SuccState;
 610
 611     // At least two successors have different InitialStates,
 612     // conservatively report this basic block as overdefined.
 613     if (CommonState != SuccState)
 614       return OverdefinedState;
 615   }
 616
 617   return CommonState;
 618 }
 619
 620 bool WinEHStatePass::isStateStoreNeeded(EHPersonality Personality,
 621                                         CallSite CS) {
 622   if (!CS)
 623     return false;
 624
 625   // If the function touches memory, it needs a state store.
 626   if (isAsynchronousEHPersonality(Personality))
 627     return !CS.doesNotAccessMemory();
 628
 629   // If the function throws, it needs a state store.
 630   return !CS.doesNotThrow();
 631 }
 632
 633 void WinEHStatePass::addStateStores(Function &F, WinEHFuncInfo &FuncInfo) {
 634   // Mark the registration node. The backend needs to know which alloca it is so
 635   // that it can recover the original frame pointer.
 636   IRBuilder<> Builder(RegNode->getNextNode());
 637   Value *RegNodeI8 = Builder.CreateBitCast(RegNode, Builder.getInt8PtrTy());
 638   Builder.CreateCall(
 639       Intrinsic::getDeclaration(TheModule, Intrinsic::x86_seh_ehregnode),
 640       {RegNodeI8});
 641
 642   if (EHGuardNode) {
 643     IRBuilder<> Builder(EHGuardNode->getNextNode());
 644     Value *EHGuardNodeI8 =
 645         Builder.CreateBitCast(EHGuardNode, Builder.getInt8PtrTy());
 646     Builder.CreateCall(
 647         Intrinsic::getDeclaration(TheModule, Intrinsic::x86_seh_ehguard),
 648         {EHGuardNodeI8});
 649   }
 650
 651   // Calculate state numbers.
 652   if (isAsynchronousEHPersonality(Personality))
 653     calculateSEHStateNumbers(&F, FuncInfo);
 654   else
 655     calculateWinCXXEHStateNumbers(&F, FuncInfo);
 656
 657   // Iterate all the instructions and emit state number stores.
 658   DenseMap<BasicBlock *, ColorVector> BlockColors = colorEHFunclets(F);
 659   ReversePostOrderTraversal<Function *> RPOT(&F);
 660
 661   // InitialStates yields the state of the first call-site for a BasicBlock.
 662   DenseMap<BasicBlock *, int> InitialStates;
 663   // FinalStates yields the state of the last call-site for a BasicBlock.
 664   DenseMap<BasicBlock *, int> FinalStates;
 665   // Worklist used to revisit BasicBlocks with indeterminate
 666   // Initial/Final-States.
 667   std::deque<BasicBlock *> Worklist;
 668   // Fill in InitialStates and FinalStates for BasicBlocks with call-sites.
 669   for (BasicBlock *BB : RPOT) {
 670     int InitialState = OverdefinedState;
 671     int FinalState;
 672     if (&F.getEntryBlock() == BB)
 673       InitialState = FinalState = ParentBaseState;
 674     for (Instruction &I : *BB) {
 675       CallSite CS(&I);
 676       if (!isStateStoreNeeded(Personality, CS))
 677         continue;
 678
 679       int State = getStateForCallSite(BlockColors, FuncInfo, CS);
 680       if (InitialState == OverdefinedState)
 681         InitialState = State;
 682       FinalState = State;
 683     }
 684     // No call-sites in this basic block? That's OK, we will come back to these
 685     // in a later pass.
 686     if (InitialState == OverdefinedState) {
 687       Worklist.push_back(BB);
 688       continue;
 689     }
 690     DEBUG(dbgs() << "X86WinEHState: " << BB->getName()
 691                  << " InitialState=" << InitialState << '\n');
 692     DEBUG(dbgs() << "X86WinEHState: " << BB->getName()
 693                  << " FinalState=" << FinalState << '\n');
 694     InitialStates.insert({BB, InitialState});
 695     FinalStates.insert({BB, FinalState});
 696   }
 697
 698   // Try to fill-in InitialStates and FinalStates which have no call-sites.
 699   while (!Worklist.empty()) {
 700     BasicBlock *BB = Worklist.front();
 701     Worklist.pop_front();
 702     // This BasicBlock has already been figured out, nothing more we can do.
 703     if (InitialStates.count(BB) != 0)
 704       continue;
 705
 706     int PredState = getPredState(FinalStates, F, ParentBaseState, BB);
 707     if (PredState == OverdefinedState)
 708       continue;
 709
 710     // We successfully inferred this BasicBlock's state via it's predecessors;
 711     // enqueue it's successors to see if we can infer their states.
 712     InitialStates.insert({BB, PredState});
 713     FinalStates.insert({BB, PredState});
 714     for (BasicBlock *SuccBB : successors(BB))
 715       Worklist.push_back(SuccBB);
 716   }
 717
 718   // Try to hoist stores from successors.
 719   for (BasicBlock *BB : RPOT) {
 720     int SuccState = getSuccState(InitialStates, F, ParentBaseState, BB);
 721     if (SuccState == OverdefinedState)
 722       continue;
 723
 724     // Update our FinalState to reflect the common InitialState of our
 725     // successors.
 726     FinalStates.insert({BB, SuccState});
 727   }
 728
 729   // Finally, insert state stores before call-sites which transition us to a new
 730   // state.
 731   for (BasicBlock *BB : RPOT) {
 732     auto &BBColors = BlockColors[BB];
 733     BasicBlock *FuncletEntryBB = BBColors.front();
 734     if (isa<CleanupPadInst>(FuncletEntryBB->getFirstNonPHI()))
 735       continue;
 736
 737     int PrevState = getPredState(FinalStates, F, ParentBaseState, BB);
 738     DEBUG(dbgs() << "X86WinEHState: " << BB->getName()
 739                  << " PrevState=" << PrevState << '\n');
 740
 741     for (Instruction &I : *BB) {
 742       CallSite CS(&I);
 743       if (!isStateStoreNeeded(Personality, CS))
 744         continue;
 745
 746       int State = getStateForCallSite(BlockColors, FuncInfo, CS);
 747       if (State != PrevState)
 748         insertStateNumberStore(&I, State);
 749       PrevState = State;
 750     }
 751
 752     // We might have hoisted a state store into this block, emit it now.
 753     auto EndState = FinalStates.find(BB);
 754     if (EndState != FinalStates.end())
 755       if (EndState->second != PrevState)
 756         insertStateNumberStore(BB->getTerminator(), EndState->second);
 757   }
 758
 759   SmallVector<CallSite, 1> SetJmp3CallSites;
 760   for (BasicBlock *BB : RPOT) {
 761     for (Instruction &I : *BB) {
 762       CallSite CS(&I);
 763       if (!CS)
 764         continue;
 765       if (CS.getCalledValue()->stripPointerCasts() !=
 766           SetJmp3->stripPointerCasts())
 767         continue;
 768
 769       SetJmp3CallSites.push_back(CS);
 770     }
 771   }
 772
 773   for (CallSite CS : SetJmp3CallSites) {
 774     auto &BBColors = BlockColors[CS->getParent()];
 775     BasicBlock *FuncletEntryBB = BBColors.front();
 776     bool InCleanup = isa<CleanupPadInst>(FuncletEntryBB->getFirstNonPHI());
 777
 778     IRBuilder<> Builder(CS.getInstruction());
 779     Value *State;
 780     if (InCleanup) {
 781       Value *StateField =
 782           Builder.CreateStructGEP(nullptr, RegNode, StateFieldIndex);
 783       State = Builder.CreateLoad(StateField);
 784     } else {
 785       State = Builder.getInt32(getStateForCallSite(BlockColors, FuncInfo, CS));
 786     }
 787     rewriteSetJmpCallSite(Builder, F, CS, State);
 788   }
 789 }
 790
 791 void WinEHStatePass::insertStateNumberStore(Instruction *IP, int State) {
 792   IRBuilder<> Builder(IP);
 793   Value *StateField =
 794       Builder.CreateStructGEP(nullptr, RegNode, StateFieldIndex);
 795   Builder.CreateStore(Builder.getInt32(State), StateField);
 796 }