LLVM  7.0.0svn
X86WinEHState.cpp
Go to the documentation of this file.
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"
19 #include "llvm/Analysis/CFG.h"
23 #include "llvm/IR/CallSite.h"
24 #include "llvm/IR/Function.h"
25 #include "llvm/IR/IRBuilder.h"
26 #include "llvm/IR/Instructions.h"
27 #include "llvm/IR/IntrinsicInst.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 {
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) {
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
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 
152  // Don't insert state stores or exception handler thunks for
153  // available_externally functions. The handler needs to reference the LSDA,
154  // which will not be emitted in this case.
156  return false;
157 
158  // Check the personality. Do nothing if this personality doesn't use funclets.
159  if (!F.hasPersonalityFn())
160  return false;
161  PersonalityFn =
163  if (!PersonalityFn)
164  return false;
165  Personality = classifyEHPersonality(PersonalityFn);
166  if (!isFuncletEHPersonality(Personality))
167  return false;
168 
169  // Skip this function if there are no EH pads and we aren't using IR-level
170  // outlining.
171  bool HasPads = false;
172  for (BasicBlock &BB : F) {
173  if (BB.isEHPad()) {
174  HasPads = true;
175  break;
176  }
177  }
178  if (!HasPads)
179  return false;
180 
181  Type *Int8PtrType = Type::getInt8PtrTy(TheModule->getContext());
182  SetJmp3 = TheModule->getOrInsertFunction(
183  "_setjmp3", FunctionType::get(
184  Type::getInt32Ty(TheModule->getContext()),
185  {Int8PtrType, Type::getInt32Ty(TheModule->getContext())},
186  /*isVarArg=*/true));
187 
188  // Disable frame pointer elimination in this function.
189  // FIXME: Do the nested handlers need to keep the parent ebp in ebp, or can we
190  // use an arbitrary register?
191  F.addFnAttr("no-frame-pointer-elim", "true");
192 
193  emitExceptionRegistrationRecord(&F);
194 
195  // The state numbers calculated here in IR must agree with what we calculate
196  // later on for the MachineFunction. In particular, if an IR pass deletes an
197  // unreachable EH pad after this point before machine CFG construction, we
198  // will be in trouble. If this assumption is ever broken, we should turn the
199  // numbers into an immutable analysis pass.
200  WinEHFuncInfo FuncInfo;
201  addStateStores(F, FuncInfo);
202 
203  // Reset per-function state.
204  PersonalityFn = nullptr;
205  Personality = EHPersonality::Unknown;
206  UseStackGuard = false;
207  RegNode = nullptr;
208  EHGuardNode = nullptr;
209 
210  return true;
211 }
212 
213 /// Get the common EH registration subobject:
214 /// typedef _EXCEPTION_DISPOSITION (*PEXCEPTION_ROUTINE)(
215 /// _EXCEPTION_RECORD *, void *, _CONTEXT *, void *);
216 /// struct EHRegistrationNode {
217 /// EHRegistrationNode *Next;
218 /// PEXCEPTION_ROUTINE Handler;
219 /// };
220 Type *WinEHStatePass::getEHLinkRegistrationType() {
221  if (EHLinkRegistrationTy)
222  return EHLinkRegistrationTy;
223  LLVMContext &Context = TheModule->getContext();
224  EHLinkRegistrationTy = StructType::create(Context, "EHRegistrationNode");
225  Type *FieldTys[] = {
226  EHLinkRegistrationTy->getPointerTo(0), // EHRegistrationNode *Next
227  Type::getInt8PtrTy(Context) // EXCEPTION_DISPOSITION (*Handler)(...)
228  };
229  EHLinkRegistrationTy->setBody(FieldTys, false);
230  return EHLinkRegistrationTy;
231 }
232 
233 /// The __CxxFrameHandler3 registration node:
234 /// struct CXXExceptionRegistration {
235 /// void *SavedESP;
236 /// EHRegistrationNode SubRecord;
237 /// int32_t TryLevel;
238 /// };
239 Type *WinEHStatePass::getCXXEHRegistrationType() {
240  if (CXXEHRegistrationTy)
241  return CXXEHRegistrationTy;
242  LLVMContext &Context = TheModule->getContext();
243  Type *FieldTys[] = {
244  Type::getInt8PtrTy(Context), // void *SavedESP
245  getEHLinkRegistrationType(), // EHRegistrationNode SubRecord
246  Type::getInt32Ty(Context) // int32_t TryLevel
247  };
248  CXXEHRegistrationTy =
249  StructType::create(FieldTys, "CXXExceptionRegistration");
250  return CXXEHRegistrationTy;
251 }
252 
253 /// The _except_handler3/4 registration node:
254 /// struct EH4ExceptionRegistration {
255 /// void *SavedESP;
256 /// _EXCEPTION_POINTERS *ExceptionPointers;
257 /// EHRegistrationNode SubRecord;
258 /// int32_t EncodedScopeTable;
259 /// int32_t TryLevel;
260 /// };
261 Type *WinEHStatePass::getSEHRegistrationType() {
262  if (SEHRegistrationTy)
263  return SEHRegistrationTy;
264  LLVMContext &Context = TheModule->getContext();
265  Type *FieldTys[] = {
266  Type::getInt8PtrTy(Context), // void *SavedESP
267  Type::getInt8PtrTy(Context), // void *ExceptionPointers
268  getEHLinkRegistrationType(), // EHRegistrationNode SubRecord
269  Type::getInt32Ty(Context), // int32_t EncodedScopeTable
270  Type::getInt32Ty(Context) // int32_t TryLevel
271  };
272  SEHRegistrationTy = StructType::create(FieldTys, "SEHExceptionRegistration");
273  return SEHRegistrationTy;
274 }
275 
276 // Emit an exception registration record. These are stack allocations with the
277 // common subobject of two pointers: the previous registration record (the old
278 // fs:00) and the personality function for the current frame. The data before
279 // and after that is personality function specific.
280 void WinEHStatePass::emitExceptionRegistrationRecord(Function *F) {
281  assert(Personality == EHPersonality::MSVC_CXX ||
282  Personality == EHPersonality::MSVC_X86SEH);
283 
284  // Struct type of RegNode. Used for GEPing.
285  Type *RegNodeTy;
286 
287  IRBuilder<> Builder(&F->getEntryBlock(), F->getEntryBlock().begin());
288  Type *Int8PtrType = Builder.getInt8PtrTy();
289  Type *Int32Ty = Builder.getInt32Ty();
290  Type *VoidTy = Builder.getVoidTy();
291 
292  if (Personality == EHPersonality::MSVC_CXX) {
293  RegNodeTy = getCXXEHRegistrationType();
294  RegNode = Builder.CreateAlloca(RegNodeTy);
295  // SavedESP = llvm.stacksave()
296  Value *SP = Builder.CreateCall(
297  Intrinsic::getDeclaration(TheModule, Intrinsic::stacksave), {});
298  Builder.CreateStore(SP, Builder.CreateStructGEP(RegNodeTy, RegNode, 0));
299  // TryLevel = -1
300  StateFieldIndex = 2;
301  ParentBaseState = -1;
302  insertStateNumberStore(&*Builder.GetInsertPoint(), ParentBaseState);
303  // Handler = __ehhandler$F
304  Function *Trampoline = generateLSDAInEAXThunk(F);
305  Link = Builder.CreateStructGEP(RegNodeTy, RegNode, 1);
306  linkExceptionRegistration(Builder, Trampoline);
307 
308  CxxLongjmpUnwind = TheModule->getOrInsertFunction(
309  "__CxxLongjmpUnwind",
310  FunctionType::get(VoidTy, Int8PtrType, /*isVarArg=*/false));
311  cast<Function>(CxxLongjmpUnwind->stripPointerCasts())
312  ->setCallingConv(CallingConv::X86_StdCall);
313  } else if (Personality == EHPersonality::MSVC_X86SEH) {
314  // If _except_handler4 is in use, some additional guard checks and prologue
315  // stuff is required.
316  StringRef PersonalityName = PersonalityFn->getName();
317  UseStackGuard = (PersonalityName == "_except_handler4");
318 
319  // Allocate local structures.
320  RegNodeTy = getSEHRegistrationType();
321  RegNode = Builder.CreateAlloca(RegNodeTy);
322  if (UseStackGuard)
323  EHGuardNode = Builder.CreateAlloca(Int32Ty);
324 
325  // SavedESP = llvm.stacksave()
326  Value *SP = Builder.CreateCall(
327  Intrinsic::getDeclaration(TheModule, Intrinsic::stacksave), {});
328  Builder.CreateStore(SP, Builder.CreateStructGEP(RegNodeTy, RegNode, 0));
329  // TryLevel = -2 / -1
330  StateFieldIndex = 4;
331  ParentBaseState = UseStackGuard ? -2 : -1;
332  insertStateNumberStore(&*Builder.GetInsertPoint(), ParentBaseState);
333  // ScopeTable = llvm.x86.seh.lsda(F)
334  Value *LSDA = emitEHLSDA(Builder, F);
335  LSDA = Builder.CreatePtrToInt(LSDA, Int32Ty);
336  // If using _except_handler4, xor the address of the table with
337  // __security_cookie.
338  if (UseStackGuard) {
339  Cookie = TheModule->getOrInsertGlobal("__security_cookie", Int32Ty);
340  Value *Val = Builder.CreateLoad(Int32Ty, Cookie, "cookie");
341  LSDA = Builder.CreateXor(LSDA, Val);
342  }
343  Builder.CreateStore(LSDA, Builder.CreateStructGEP(RegNodeTy, RegNode, 3));
344 
345  // If using _except_handler4, the EHGuard contains: FramePtr xor Cookie.
346  if (UseStackGuard) {
347  Value *Val = Builder.CreateLoad(Int32Ty, Cookie);
348  Value *FrameAddr = Builder.CreateCall(
349  Intrinsic::getDeclaration(TheModule, Intrinsic::frameaddress),
350  Builder.getInt32(0), "frameaddr");
351  Value *FrameAddrI32 = Builder.CreatePtrToInt(FrameAddr, Int32Ty);
352  FrameAddrI32 = Builder.CreateXor(FrameAddrI32, Val);
353  Builder.CreateStore(FrameAddrI32, EHGuardNode);
354  }
355 
356  // Register the exception handler.
357  Link = Builder.CreateStructGEP(RegNodeTy, RegNode, 2);
358  linkExceptionRegistration(Builder, PersonalityFn);
359 
360  SehLongjmpUnwind = TheModule->getOrInsertFunction(
361  UseStackGuard ? "_seh_longjmp_unwind4" : "_seh_longjmp_unwind",
362  FunctionType::get(Type::getVoidTy(TheModule->getContext()), Int8PtrType,
363  /*isVarArg=*/false));
364  cast<Function>(SehLongjmpUnwind->stripPointerCasts())
365  ->setCallingConv(CallingConv::X86_StdCall);
366  } else {
367  llvm_unreachable("unexpected personality function");
368  }
369 
370  // Insert an unlink before all returns.
371  for (BasicBlock &BB : *F) {
372  TerminatorInst *T = BB.getTerminator();
373  if (!isa<ReturnInst>(T))
374  continue;
375  Builder.SetInsertPoint(T);
376  unlinkExceptionRegistration(Builder);
377  }
378 }
379 
380 Value *WinEHStatePass::emitEHLSDA(IRBuilder<> &Builder, Function *F) {
381  Value *FI8 = Builder.CreateBitCast(F, Type::getInt8PtrTy(F->getContext()));
382  return Builder.CreateCall(
383  Intrinsic::getDeclaration(TheModule, Intrinsic::x86_seh_lsda), FI8);
384 }
385 
386 /// Generate a thunk that puts the LSDA of ParentFunc in EAX and then calls
387 /// PersonalityFn, forwarding the parameters passed to PEXCEPTION_ROUTINE:
388 /// typedef _EXCEPTION_DISPOSITION (*PEXCEPTION_ROUTINE)(
389 /// _EXCEPTION_RECORD *, void *, _CONTEXT *, void *);
390 /// We essentially want this code:
391 /// movl $lsda, %eax
392 /// jmpl ___CxxFrameHandler3
393 Function *WinEHStatePass::generateLSDAInEAXThunk(Function *ParentFunc) {
394  LLVMContext &Context = ParentFunc->getContext();
395  Type *Int32Ty = Type::getInt32Ty(Context);
396  Type *Int8PtrType = Type::getInt8PtrTy(Context);
397  Type *ArgTys[5] = {Int8PtrType, Int8PtrType, Int8PtrType, Int8PtrType,
398  Int8PtrType};
399  FunctionType *TrampolineTy =
400  FunctionType::get(Int32Ty, makeArrayRef(&ArgTys[0], 4),
401  /*isVarArg=*/false);
402  FunctionType *TargetFuncTy =
403  FunctionType::get(Int32Ty, makeArrayRef(&ArgTys[0], 5),
404  /*isVarArg=*/false);
405  Function *Trampoline =
407  Twine("__ehhandler$") + GlobalValue::dropLLVMManglingEscape(
408  ParentFunc->getName()),
409  TheModule);
410  if (auto *C = ParentFunc->getComdat())
411  Trampoline->setComdat(C);
412  BasicBlock *EntryBB = BasicBlock::Create(Context, "entry", Trampoline);
413  IRBuilder<> Builder(EntryBB);
414  Value *LSDA = emitEHLSDA(Builder, ParentFunc);
415  Value *CastPersonality =
416  Builder.CreateBitCast(PersonalityFn, TargetFuncTy->getPointerTo());
417  auto AI = Trampoline->arg_begin();
418  Value *Args[5] = {LSDA, &*AI++, &*AI++, &*AI++, &*AI++};
419  CallInst *Call = Builder.CreateCall(CastPersonality, Args);
420  // Can't use musttail due to prototype mismatch, but we can use tail.
421  Call->setTailCall(true);
422  // Set inreg so we pass it in EAX.
423  Call->addParamAttr(0, Attribute::InReg);
424  Builder.CreateRet(Call);
425  return Trampoline;
426 }
427 
428 void WinEHStatePass::linkExceptionRegistration(IRBuilder<> &Builder,
429  Function *Handler) {
430  // Emit the .safeseh directive for this function.
431  Handler->addFnAttr("safeseh");
432 
433  Type *LinkTy = getEHLinkRegistrationType();
434  // Handler = Handler
435  Value *HandlerI8 = Builder.CreateBitCast(Handler, Builder.getInt8PtrTy());
436  Builder.CreateStore(HandlerI8, Builder.CreateStructGEP(LinkTy, Link, 1));
437  // Next = [fs:00]
438  Constant *FSZero =
440  Value *Next = Builder.CreateLoad(FSZero);
441  Builder.CreateStore(Next, Builder.CreateStructGEP(LinkTy, Link, 0));
442  // [fs:00] = Link
443  Builder.CreateStore(Link, FSZero);
444 }
445 
446 void WinEHStatePass::unlinkExceptionRegistration(IRBuilder<> &Builder) {
447  // Clone Link into the current BB for better address mode folding.
448  if (auto *GEP = dyn_cast<GetElementPtrInst>(Link)) {
449  GEP = cast<GetElementPtrInst>(GEP->clone());
450  Builder.Insert(GEP);
451  Link = GEP;
452  }
453  Type *LinkTy = getEHLinkRegistrationType();
454  // [fs:00] = Link->Next
455  Value *Next =
456  Builder.CreateLoad(Builder.CreateStructGEP(LinkTy, Link, 0));
457  Constant *FSZero =
459  Builder.CreateStore(Next, FSZero);
460 }
461 
462 // Calls to setjmp(p) are lowered to _setjmp3(p, 0) by the frontend.
463 // The idea behind _setjmp3 is that it takes an optional number of personality
464 // specific parameters to indicate how to restore the personality-specific frame
465 // state when longjmp is initiated. Typically, the current TryLevel is saved.
466 void WinEHStatePass::rewriteSetJmpCallSite(IRBuilder<> &Builder, Function &F,
467  CallSite CS, Value *State) {
468  // Don't rewrite calls with a weird number of arguments.
469  if (CS.getNumArgOperands() != 2)
470  return;
471 
472  Instruction *Inst = CS.getInstruction();
473 
475  CS.getOperandBundlesAsDefs(OpBundles);
476 
477  SmallVector<Value *, 3> OptionalArgs;
478  if (Personality == EHPersonality::MSVC_CXX) {
479  OptionalArgs.push_back(CxxLongjmpUnwind);
480  OptionalArgs.push_back(State);
481  OptionalArgs.push_back(emitEHLSDA(Builder, &F));
482  } else if (Personality == EHPersonality::MSVC_X86SEH) {
483  OptionalArgs.push_back(SehLongjmpUnwind);
484  OptionalArgs.push_back(State);
485  if (UseStackGuard)
486  OptionalArgs.push_back(Cookie);
487  } else {
488  llvm_unreachable("unhandled personality!");
489  }
490 
492  Args.push_back(
493  Builder.CreateBitCast(CS.getArgOperand(0), Builder.getInt8PtrTy()));
494  Args.push_back(Builder.getInt32(OptionalArgs.size()));
495  Args.append(OptionalArgs.begin(), OptionalArgs.end());
496 
497  CallSite NewCS;
498  if (CS.isCall()) {
499  auto *CI = cast<CallInst>(Inst);
500  CallInst *NewCI = Builder.CreateCall(SetJmp3, Args, OpBundles);
501  NewCI->setTailCallKind(CI->getTailCallKind());
502  NewCS = NewCI;
503  } else {
504  auto *II = cast<InvokeInst>(Inst);
505  NewCS = Builder.CreateInvoke(
506  SetJmp3, II->getNormalDest(), II->getUnwindDest(), Args, OpBundles);
507  }
508  NewCS.setCallingConv(CS.getCallingConv());
509  NewCS.setAttributes(CS.getAttributes());
510  NewCS->setDebugLoc(CS->getDebugLoc());
511 
512  Instruction *NewInst = NewCS.getInstruction();
513  NewInst->takeName(Inst);
514  Inst->replaceAllUsesWith(NewInst);
515  Inst->eraseFromParent();
516 }
517 
518 // Figure out what state we should assign calls in this block.
519 int WinEHStatePass::getBaseStateForBB(
520  DenseMap<BasicBlock *, ColorVector> &BlockColors, WinEHFuncInfo &FuncInfo,
521  BasicBlock *BB) {
522  int BaseState = ParentBaseState;
523  auto &BBColors = BlockColors[BB];
524 
525  assert(BBColors.size() == 1 && "multi-color BB not removed by preparation");
526  BasicBlock *FuncletEntryBB = BBColors.front();
527  if (auto *FuncletPad =
528  dyn_cast<FuncletPadInst>(FuncletEntryBB->getFirstNonPHI())) {
529  auto BaseStateI = FuncInfo.FuncletBaseStateMap.find(FuncletPad);
530  if (BaseStateI != FuncInfo.FuncletBaseStateMap.end())
531  BaseState = BaseStateI->second;
532  }
533 
534  return BaseState;
535 }
536 
537 // Calculate the state a call-site is in.
538 int WinEHStatePass::getStateForCallSite(
539  DenseMap<BasicBlock *, ColorVector> &BlockColors, WinEHFuncInfo &FuncInfo,
540  CallSite CS) {
541  if (auto *II = dyn_cast<InvokeInst>(CS.getInstruction())) {
542  // Look up the state number of the EH pad this unwinds to.
543  assert(FuncInfo.InvokeStateMap.count(II) && "invoke has no state!");
544  return FuncInfo.InvokeStateMap[II];
545  }
546  // Possibly throwing call instructions have no actions to take after
547  // an unwind. Ensure they are in the -1 state.
548  return getBaseStateForBB(BlockColors, FuncInfo, CS.getParent());
549 }
550 
551 // Calculate the intersection of all the FinalStates for a BasicBlock's
552 // predecessors.
554  int ParentBaseState, BasicBlock *BB) {
555  // The entry block has no predecessors but we know that the prologue always
556  // sets us up with a fixed state.
557  if (&F.getEntryBlock() == BB)
558  return ParentBaseState;
559 
560  // This is an EH Pad, conservatively report this basic block as overdefined.
561  if (BB->isEHPad())
562  return OverdefinedState;
563 
564  int CommonState = OverdefinedState;
565  for (BasicBlock *PredBB : predecessors(BB)) {
566  // We didn't manage to get a state for one of these predecessors,
567  // conservatively report this basic block as overdefined.
568  auto PredEndState = FinalStates.find(PredBB);
569  if (PredEndState == FinalStates.end())
570  return OverdefinedState;
571 
572  // This code is reachable via exceptional control flow,
573  // conservatively report this basic block as overdefined.
574  if (isa<CatchReturnInst>(PredBB->getTerminator()))
575  return OverdefinedState;
576 
577  int PredState = PredEndState->second;
578  assert(PredState != OverdefinedState &&
579  "overdefined BBs shouldn't be in FinalStates");
580  if (CommonState == OverdefinedState)
581  CommonState = PredState;
582 
583  // At least two predecessors have different FinalStates,
584  // conservatively report this basic block as overdefined.
585  if (CommonState != PredState)
586  return OverdefinedState;
587  }
588 
589  return CommonState;
590 }
591 
592 // Calculate the intersection of all the InitialStates for a BasicBlock's
593 // successors.
594 static int getSuccState(DenseMap<BasicBlock *, int> &InitialStates, Function &F,
595  int ParentBaseState, BasicBlock *BB) {
596  // This block rejoins normal control flow,
597  // conservatively report this basic block as overdefined.
598  if (isa<CatchReturnInst>(BB->getTerminator()))
599  return OverdefinedState;
600 
601  int CommonState = OverdefinedState;
602  for (BasicBlock *SuccBB : successors(BB)) {
603  // We didn't manage to get a state for one of these predecessors,
604  // conservatively report this basic block as overdefined.
605  auto SuccStartState = InitialStates.find(SuccBB);
606  if (SuccStartState == InitialStates.end())
607  return OverdefinedState;
608 
609  // This is an EH Pad, conservatively report this basic block as overdefined.
610  if (SuccBB->isEHPad())
611  return OverdefinedState;
612 
613  int SuccState = SuccStartState->second;
614  assert(SuccState != OverdefinedState &&
615  "overdefined BBs shouldn't be in FinalStates");
616  if (CommonState == OverdefinedState)
617  CommonState = SuccState;
618 
619  // At least two successors have different InitialStates,
620  // conservatively report this basic block as overdefined.
621  if (CommonState != SuccState)
622  return OverdefinedState;
623  }
624 
625  return CommonState;
626 }
627 
628 bool WinEHStatePass::isStateStoreNeeded(EHPersonality Personality,
629  CallSite CS) {
630  if (!CS)
631  return false;
632 
633  // If the function touches memory, it needs a state store.
634  if (isAsynchronousEHPersonality(Personality))
635  return !CS.doesNotAccessMemory();
636 
637  // If the function throws, it needs a state store.
638  return !CS.doesNotThrow();
639 }
640 
641 void WinEHStatePass::addStateStores(Function &F, WinEHFuncInfo &FuncInfo) {
642  // Mark the registration node. The backend needs to know which alloca it is so
643  // that it can recover the original frame pointer.
644  IRBuilder<> Builder(RegNode->getNextNode());
645  Value *RegNodeI8 = Builder.CreateBitCast(RegNode, Builder.getInt8PtrTy());
646  Builder.CreateCall(
647  Intrinsic::getDeclaration(TheModule, Intrinsic::x86_seh_ehregnode),
648  {RegNodeI8});
649 
650  if (EHGuardNode) {
651  IRBuilder<> Builder(EHGuardNode->getNextNode());
652  Value *EHGuardNodeI8 =
653  Builder.CreateBitCast(EHGuardNode, Builder.getInt8PtrTy());
654  Builder.CreateCall(
655  Intrinsic::getDeclaration(TheModule, Intrinsic::x86_seh_ehguard),
656  {EHGuardNodeI8});
657  }
658 
659  // Calculate state numbers.
660  if (isAsynchronousEHPersonality(Personality))
661  calculateSEHStateNumbers(&F, FuncInfo);
662  else
663  calculateWinCXXEHStateNumbers(&F, FuncInfo);
664 
665  // Iterate all the instructions and emit state number stores.
668 
669  // InitialStates yields the state of the first call-site for a BasicBlock.
670  DenseMap<BasicBlock *, int> InitialStates;
671  // FinalStates yields the state of the last call-site for a BasicBlock.
672  DenseMap<BasicBlock *, int> FinalStates;
673  // Worklist used to revisit BasicBlocks with indeterminate
674  // Initial/Final-States.
675  std::deque<BasicBlock *> Worklist;
676  // Fill in InitialStates and FinalStates for BasicBlocks with call-sites.
677  for (BasicBlock *BB : RPOT) {
678  int InitialState = OverdefinedState;
679  int FinalState;
680  if (&F.getEntryBlock() == BB)
681  InitialState = FinalState = ParentBaseState;
682  for (Instruction &I : *BB) {
683  CallSite CS(&I);
684  if (!isStateStoreNeeded(Personality, CS))
685  continue;
686 
687  int State = getStateForCallSite(BlockColors, FuncInfo, CS);
688  if (InitialState == OverdefinedState)
689  InitialState = State;
690  FinalState = State;
691  }
692  // No call-sites in this basic block? That's OK, we will come back to these
693  // in a later pass.
694  if (InitialState == OverdefinedState) {
695  Worklist.push_back(BB);
696  continue;
697  }
698  LLVM_DEBUG(dbgs() << "X86WinEHState: " << BB->getName()
699  << " InitialState=" << InitialState << '\n');
700  LLVM_DEBUG(dbgs() << "X86WinEHState: " << BB->getName()
701  << " FinalState=" << FinalState << '\n');
702  InitialStates.insert({BB, InitialState});
703  FinalStates.insert({BB, FinalState});
704  }
705 
706  // Try to fill-in InitialStates and FinalStates which have no call-sites.
707  while (!Worklist.empty()) {
708  BasicBlock *BB = Worklist.front();
709  Worklist.pop_front();
710  // This BasicBlock has already been figured out, nothing more we can do.
711  if (InitialStates.count(BB) != 0)
712  continue;
713 
714  int PredState = getPredState(FinalStates, F, ParentBaseState, BB);
715  if (PredState == OverdefinedState)
716  continue;
717 
718  // We successfully inferred this BasicBlock's state via it's predecessors;
719  // enqueue it's successors to see if we can infer their states.
720  InitialStates.insert({BB, PredState});
721  FinalStates.insert({BB, PredState});
722  for (BasicBlock *SuccBB : successors(BB))
723  Worklist.push_back(SuccBB);
724  }
725 
726  // Try to hoist stores from successors.
727  for (BasicBlock *BB : RPOT) {
728  int SuccState = getSuccState(InitialStates, F, ParentBaseState, BB);
729  if (SuccState == OverdefinedState)
730  continue;
731 
732  // Update our FinalState to reflect the common InitialState of our
733  // successors.
734  FinalStates.insert({BB, SuccState});
735  }
736 
737  // Finally, insert state stores before call-sites which transition us to a new
738  // state.
739  for (BasicBlock *BB : RPOT) {
740  auto &BBColors = BlockColors[BB];
741  BasicBlock *FuncletEntryBB = BBColors.front();
742  if (isa<CleanupPadInst>(FuncletEntryBB->getFirstNonPHI()))
743  continue;
744 
745  int PrevState = getPredState(FinalStates, F, ParentBaseState, BB);
746  LLVM_DEBUG(dbgs() << "X86WinEHState: " << BB->getName()
747  << " PrevState=" << PrevState << '\n');
748 
749  for (Instruction &I : *BB) {
750  CallSite CS(&I);
751  if (!isStateStoreNeeded(Personality, CS))
752  continue;
753 
754  int State = getStateForCallSite(BlockColors, FuncInfo, CS);
755  if (State != PrevState)
756  insertStateNumberStore(&I, State);
757  PrevState = State;
758  }
759 
760  // We might have hoisted a state store into this block, emit it now.
761  auto EndState = FinalStates.find(BB);
762  if (EndState != FinalStates.end())
763  if (EndState->second != PrevState)
764  insertStateNumberStore(BB->getTerminator(), EndState->second);
765  }
766 
767  SmallVector<CallSite, 1> SetJmp3CallSites;
768  for (BasicBlock *BB : RPOT) {
769  for (Instruction &I : *BB) {
770  CallSite CS(&I);
771  if (!CS)
772  continue;
773  if (CS.getCalledValue()->stripPointerCasts() !=
774  SetJmp3->stripPointerCasts())
775  continue;
776 
777  SetJmp3CallSites.push_back(CS);
778  }
779  }
780 
781  for (CallSite CS : SetJmp3CallSites) {
782  auto &BBColors = BlockColors[CS->getParent()];
783  BasicBlock *FuncletEntryBB = BBColors.front();
784  bool InCleanup = isa<CleanupPadInst>(FuncletEntryBB->getFirstNonPHI());
785 
786  IRBuilder<> Builder(CS.getInstruction());
787  Value *State;
788  if (InCleanup) {
789  Value *StateField =
790  Builder.CreateStructGEP(nullptr, RegNode, StateFieldIndex);
791  State = Builder.CreateLoad(StateField);
792  } else {
793  State = Builder.getInt32(getStateForCallSite(BlockColors, FuncInfo, CS));
794  }
795  rewriteSetJmpCallSite(Builder, F, CS, State);
796  }
797 }
798 
799 void WinEHStatePass::insertStateNumberStore(Instruction *IP, int State) {
800  IRBuilder<> Builder(IP);
801  Value *StateField =
802  Builder.CreateStructGEP(nullptr, RegNode, StateFieldIndex);
803  Builder.CreateStore(Builder.getInt32(State), StateField);
804 }
uint64_t CallInst * C
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks &#39;this&#39; from the containing basic block and deletes it.
Definition: Instruction.cpp:68
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
LLVMContext & Context
CallingConv::ID getCallingConv() const
Get the calling convention of the call.
Definition: CallSite.h:312
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:63
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:137
DenseMap< const FuncletPadInst *, int > FuncletBaseStateMap
Definition: WinEHFuncInfo.h:93
This class represents a function call, abstracting a target machine&#39;s calling convention.
bool hasAvailableExternallyLinkage() const
Definition: GlobalValue.h:422
F(f)
Hexagon Common GEP
void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
Adds the attribute to the indicated argument.
X86_StdCall - stdcall is the calling conventions mostly used by the Win32 API.
Definition: CallingConv.h:87
static int getPredState(DenseMap< BasicBlock *, int > &FinalStates, Function &F, int ParentBaseState, BasicBlock *BB)
static Constant * getNullValue(Type *Ty)
Constructor to create a &#39;0&#39; constant of arbitrary type.
Definition: Constants.cpp:268
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:264
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:191
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
void calculateSEHStateNumbers(const Function *ParentFn, WinEHFuncInfo &FuncInfo)
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:451
Class to represent struct types.
Definition: DerivedTypes.h:201
PointerType * getPointerTo(unsigned AddrSpace=0) const
Return a pointer to the current type.
Definition: Type.cpp:639
ReturnInst * CreateRet(Value *V)
Create a &#39;ret <val>&#39; instruction.
Definition: IRBuilder.h:817
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:731
InstrTy * getInstruction() const
Definition: CallSite.h:92
StoreInst * CreateStore(Value *Val, Value *Ptr, bool isVolatile=false)
Definition: IRBuilder.h:1321
ValTy * getCalledValue() const
Return the pointer to function that is being called.
Definition: CallSite.h:100
Class to represent function types.
Definition: DerivedTypes.h:103
Value * CreateBitCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:1629
ValTy * getArgOperand(unsigned i) const
Definition: CallSite.h:297
void setComdat(Comdat *C)
Definition: GlobalObject.h:103
bool hasPersonalityFn() const
Check whether this function has a personality function.
Definition: Function.h:688
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:439
void takeName(Value *V)
Transfer the name from V to this value.
Definition: Value.cpp:301
Function * getDeclaration(Module *M, ID id, ArrayRef< Type *> Tys=None)
Create or insert an LLVM Function declaration for an intrinsic, and return it.
Definition: Function.cpp:1007
bool isCall() const
Return true if a CallInst is enclosed.
Definition: CallSite.h:87
const BasicBlock & getEntryBlock() const
Definition: Function.h:626
LoadInst * CreateLoad(Value *Ptr, const char *Name)
Provided to resolve &#39;CreateLoad(Ptr, "...")&#39; correctly, instead of converting the string to &#39;bool&#39; fo...
Definition: IRBuilder.h:1305
void setAttributes(AttributeList PAL)
Set the parameter attributes of the call.
Definition: CallSite.h:333
static bool runOnFunction(Function &F, bool PostInlining)
const Instruction * getFirstNonPHI() const
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
Definition: BasicBlock.cpp:189
Subclasses of this class are all able to terminate a basic block.
Definition: InstrTypes.h:55
LLVM Basic Block Representation.
Definition: BasicBlock.h:59
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:69
This is an important base class in LLVM.
Definition: Constant.h:42
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator begin()
Definition: SmallVector.h:117
const Instruction & front() const
Definition: BasicBlock.h:276
EHPersonality classifyEHPersonality(const Value *Pers)
See if the given exception handling personality function is one that we understand.
Represent the analysis usage information of a pass.
static Type * getVoidTy(LLVMContext &C)
Definition: Type.cpp:161
void setCallingConv(CallingConv::ID CC)
Set the calling convention of the call.
Definition: CallSite.h:316
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:285
static FunctionType * get(Type *Result, ArrayRef< Type *> Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
Definition: Type.cpp:297
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
Definition: BasicBlock.h:101
arg_iterator arg_begin()
Definition: Function.h:657
DenseMap< const InvokeInst *, int > InvokeStateMap
Definition: WinEHFuncInfo.h:94
void setTailCallKind(TailCallKind TCK)
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function. ...
Definition: Function.cpp:194
void setTailCall(bool isTC=true)
const Constant * stripPointerCasts() const
Definition: Constant.h:173
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs, and aliases.
Definition: Value.cpp:539
unsigned getNumArgOperands() const
Definition: CallSite.h:293
PointerType * getInt8PtrTy(unsigned AddrSpace=0)
Fetch the type representing a pointer to an 8-bit integer value.
Definition: IRBuilder.h:385
static PointerType * getInt8PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:220
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
void calculateWinCXXEHStateNumbers(const Function *ParentFn, WinEHFuncInfo &FuncInfo)
Analyze the IR in ParentFn and it&#39;s handlers to build WinEHFuncInfo, which describes the state number...
bool isFuncletEHPersonality(EHPersonality Pers)
Returns true if this is a personality function that invokes handler funclets (which must return to it...
static int getSuccState(DenseMap< BasicBlock *, int > &InitialStates, Function &F, int ParentBaseState, BasicBlock *BB)
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
Module.h This file contains the declarations for the Module class.
ConstantInt * getInt32(uint32_t C)
Get a constant 32-bit value.
Definition: IRBuilder.h:307
pred_range predecessors(BasicBlock *BB)
Definition: CFG.h:113
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:286
BBTy * getParent() const
Get the basic block containing the call site.
Definition: CallSite.h:97
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:133
static StringRef dropLLVMManglingEscape(StringRef Name)
If the given string begins with the GlobalValue name mangling escape character &#39;\1&#39;, drop it.
Definition: GlobalValue.h:471
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:395
bool doesNotAccessMemory() const
Determine if the call does not access memory.
Definition: CallSite.h:446
const Comdat * getComdat() const
Definition: GlobalObject.h:101
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:121
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:176
void getOperandBundlesAsDefs(SmallVectorImpl< OperandBundleDef > &Defs) const
Definition: CallSite.h:582
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:224
#define I(x, y, z)
Definition: MD5.cpp:58
bool doesNotThrow() const
Determine if the call cannot unwind.
Definition: CallSite.h:505
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:323
Rename collisions when linking (static functions).
Definition: GlobalValue.h:56
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Definition: DenseMap.h:141
INITIALIZE_PASS(WinEHStatePass, "x86-winehstate", "Insert stores for EH state numbers", false, false) bool WinEHStatePass
void initializeWinEHStatePassPass(PassRegistry &)
InstTy * Insert(InstTy *I, const Twine &Name="") const
Insert and return the specified instruction.
Definition: IRBuilder.h:782
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
bool isAsynchronousEHPersonality(EHPersonality Pers)
Returns true if this personality function catches asynchronous exceptions.
bool isEHPad() const
Return true if this basic block is an exception handling block.
Definition: BasicBlock.h:394
LLVM Value Representation.
Definition: Value.h:73
Constant * getPersonalityFn() const
Get the personality function associated with this function.
Definition: Function.cpp:1288
succ_range successors(BasicBlock *BB)
Definition: CFG.h:149
static StructType * create(LLVMContext &Context, StringRef Name)
This creates an identified struct.
Definition: Type.cpp:424
Value * CreateStructGEP(Type *Ty, Value *Ptr, unsigned Idx, const Twine &Name="")
Definition: IRBuilder.h:1528
void addFnAttr(Attribute::AttrKind Kind)
Add function attributes to this function.
Definition: Function.h:216
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
PassRegistry - This class manages the registration and intitialization of the pass subsystem as appli...
Definition: PassRegistry.h:39
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, const Twine &N="", Module *M=nullptr)
Definition: Function.h:136
AttributeList getAttributes() const
Get the parameter attributes of the call.
Definition: CallSite.h:329
FunctionPass * createX86WinEHStatePass()
Return an IR pass that inserts EH registration stack objects and explicit EH state updates...
const TerminatorInst * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition: BasicBlock.cpp:138
DenseMap< BasicBlock *, ColorVector > colorEHFunclets(Function &F)
If an EH funclet personality is in use (see isFuncletEHPersonality), this will recompute which blocks...
#define LLVM_DEBUG(X)
Definition: Debug.h:119
InvokeInst * CreateInvoke(Value *Callee, BasicBlock *NormalDest, BasicBlock *UnwindDest, ArrayRef< Value *> Args=None, const Twine &Name="")
Create an invoke instruction.
Definition: IRBuilder.h:880
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
IntegerType * Int32Ty
an instruction to allocate memory on the stack
Definition: Instructions.h:60
CallInst * CreateCall(Value *Callee, ArrayRef< Value *> Args=None, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:1871