LLVM  6.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  // Check the personality. Do nothing if this personality doesn't use funclets.
153  if (!F.hasPersonalityFn())
154  return false;
155  PersonalityFn =
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 =
401  Twine("__ehhandler$") + GlobalValue::dropLLVMManglingEscape(
402  ParentFunc->getName()),
403  TheModule);
404  if (auto *C = ParentFunc->getComdat())
405  Trampoline->setComdat(C);
406  BasicBlock *EntryBB = BasicBlock::Create(Context, "entry", Trampoline);
407  IRBuilder<> Builder(EntryBB);
408  Value *LSDA = emitEHLSDA(Builder, ParentFunc);
409  Value *CastPersonality =
410  Builder.CreateBitCast(PersonalityFn, TargetFuncTy->getPointerTo());
411  auto AI = Trampoline->arg_begin();
412  Value *Args[5] = {LSDA, &*AI++, &*AI++, &*AI++, &*AI++};
413  CallInst *Call = Builder.CreateCall(CastPersonality, Args);
414  // Can't use musttail due to prototype mismatch, but we can use tail.
415  Call->setTailCall(true);
416  // Set inreg so we pass it in EAX.
417  Call->addParamAttr(0, Attribute::InReg);
418  Builder.CreateRet(Call);
419  return Trampoline;
420 }
421 
422 void WinEHStatePass::linkExceptionRegistration(IRBuilder<> &Builder,
423  Function *Handler) {
424  // Emit the .safeseh directive for this function.
425  Handler->addFnAttr("safeseh");
426 
427  Type *LinkTy = getEHLinkRegistrationType();
428  // Handler = Handler
429  Value *HandlerI8 = Builder.CreateBitCast(Handler, Builder.getInt8PtrTy());
430  Builder.CreateStore(HandlerI8, Builder.CreateStructGEP(LinkTy, Link, 1));
431  // Next = [fs:00]
432  Constant *FSZero =
434  Value *Next = Builder.CreateLoad(FSZero);
435  Builder.CreateStore(Next, Builder.CreateStructGEP(LinkTy, Link, 0));
436  // [fs:00] = Link
437  Builder.CreateStore(Link, FSZero);
438 }
439 
440 void WinEHStatePass::unlinkExceptionRegistration(IRBuilder<> &Builder) {
441  // Clone Link into the current BB for better address mode folding.
442  if (auto *GEP = dyn_cast<GetElementPtrInst>(Link)) {
443  GEP = cast<GetElementPtrInst>(GEP->clone());
444  Builder.Insert(GEP);
445  Link = GEP;
446  }
447  Type *LinkTy = getEHLinkRegistrationType();
448  // [fs:00] = Link->Next
449  Value *Next =
450  Builder.CreateLoad(Builder.CreateStructGEP(LinkTy, Link, 0));
451  Constant *FSZero =
453  Builder.CreateStore(Next, FSZero);
454 }
455 
456 // Calls to setjmp(p) are lowered to _setjmp3(p, 0) by the frontend.
457 // The idea behind _setjmp3 is that it takes an optional number of personality
458 // specific parameters to indicate how to restore the personality-specific frame
459 // state when longjmp is initiated. Typically, the current TryLevel is saved.
460 void WinEHStatePass::rewriteSetJmpCallSite(IRBuilder<> &Builder, Function &F,
461  CallSite CS, Value *State) {
462  // Don't rewrite calls with a weird number of arguments.
463  if (CS.getNumArgOperands() != 2)
464  return;
465 
466  Instruction *Inst = CS.getInstruction();
467 
469  CS.getOperandBundlesAsDefs(OpBundles);
470 
471  SmallVector<Value *, 3> OptionalArgs;
472  if (Personality == EHPersonality::MSVC_CXX) {
473  OptionalArgs.push_back(CxxLongjmpUnwind);
474  OptionalArgs.push_back(State);
475  OptionalArgs.push_back(emitEHLSDA(Builder, &F));
476  } else if (Personality == EHPersonality::MSVC_X86SEH) {
477  OptionalArgs.push_back(SehLongjmpUnwind);
478  OptionalArgs.push_back(State);
479  if (UseStackGuard)
480  OptionalArgs.push_back(Cookie);
481  } else {
482  llvm_unreachable("unhandled personality!");
483  }
484 
486  Args.push_back(
487  Builder.CreateBitCast(CS.getArgOperand(0), Builder.getInt8PtrTy()));
488  Args.push_back(Builder.getInt32(OptionalArgs.size()));
489  Args.append(OptionalArgs.begin(), OptionalArgs.end());
490 
491  CallSite NewCS;
492  if (CS.isCall()) {
493  auto *CI = cast<CallInst>(Inst);
494  CallInst *NewCI = Builder.CreateCall(SetJmp3, Args, OpBundles);
495  NewCI->setTailCallKind(CI->getTailCallKind());
496  NewCS = NewCI;
497  } else {
498  auto *II = cast<InvokeInst>(Inst);
499  NewCS = Builder.CreateInvoke(
500  SetJmp3, II->getNormalDest(), II->getUnwindDest(), Args, OpBundles);
501  }
502  NewCS.setCallingConv(CS.getCallingConv());
503  NewCS.setAttributes(CS.getAttributes());
504  NewCS->setDebugLoc(CS->getDebugLoc());
505 
506  Instruction *NewInst = NewCS.getInstruction();
507  NewInst->takeName(Inst);
508  Inst->replaceAllUsesWith(NewInst);
509  Inst->eraseFromParent();
510 }
511 
512 // Figure out what state we should assign calls in this block.
513 int WinEHStatePass::getBaseStateForBB(
514  DenseMap<BasicBlock *, ColorVector> &BlockColors, WinEHFuncInfo &FuncInfo,
515  BasicBlock *BB) {
516  int BaseState = ParentBaseState;
517  auto &BBColors = BlockColors[BB];
518 
519  assert(BBColors.size() == 1 && "multi-color BB not removed by preparation");
520  BasicBlock *FuncletEntryBB = BBColors.front();
521  if (auto *FuncletPad =
522  dyn_cast<FuncletPadInst>(FuncletEntryBB->getFirstNonPHI())) {
523  auto BaseStateI = FuncInfo.FuncletBaseStateMap.find(FuncletPad);
524  if (BaseStateI != FuncInfo.FuncletBaseStateMap.end())
525  BaseState = BaseStateI->second;
526  }
527 
528  return BaseState;
529 }
530 
531 // Calculate the state a call-site is in.
532 int WinEHStatePass::getStateForCallSite(
533  DenseMap<BasicBlock *, ColorVector> &BlockColors, WinEHFuncInfo &FuncInfo,
534  CallSite CS) {
535  if (auto *II = dyn_cast<InvokeInst>(CS.getInstruction())) {
536  // Look up the state number of the EH pad this unwinds to.
537  assert(FuncInfo.InvokeStateMap.count(II) && "invoke has no state!");
538  return FuncInfo.InvokeStateMap[II];
539  }
540  // Possibly throwing call instructions have no actions to take after
541  // an unwind. Ensure they are in the -1 state.
542  return getBaseStateForBB(BlockColors, FuncInfo, CS.getParent());
543 }
544 
545 // Calculate the intersection of all the FinalStates for a BasicBlock's
546 // predecessors.
548  int ParentBaseState, BasicBlock *BB) {
549  // The entry block has no predecessors but we know that the prologue always
550  // sets us up with a fixed state.
551  if (&F.getEntryBlock() == BB)
552  return ParentBaseState;
553 
554  // This is an EH Pad, conservatively report this basic block as overdefined.
555  if (BB->isEHPad())
556  return OverdefinedState;
557 
558  int CommonState = OverdefinedState;
559  for (BasicBlock *PredBB : predecessors(BB)) {
560  // We didn't manage to get a state for one of these predecessors,
561  // conservatively report this basic block as overdefined.
562  auto PredEndState = FinalStates.find(PredBB);
563  if (PredEndState == FinalStates.end())
564  return OverdefinedState;
565 
566  // This code is reachable via exceptional control flow,
567  // conservatively report this basic block as overdefined.
568  if (isa<CatchReturnInst>(PredBB->getTerminator()))
569  return OverdefinedState;
570 
571  int PredState = PredEndState->second;
572  assert(PredState != OverdefinedState &&
573  "overdefined BBs shouldn't be in FinalStates");
574  if (CommonState == OverdefinedState)
575  CommonState = PredState;
576 
577  // At least two predecessors have different FinalStates,
578  // conservatively report this basic block as overdefined.
579  if (CommonState != PredState)
580  return OverdefinedState;
581  }
582 
583  return CommonState;
584 }
585 
586 // Calculate the intersection of all the InitialStates for a BasicBlock's
587 // successors.
588 static int getSuccState(DenseMap<BasicBlock *, int> &InitialStates, Function &F,
589  int ParentBaseState, BasicBlock *BB) {
590  // This block rejoins normal control flow,
591  // conservatively report this basic block as overdefined.
592  if (isa<CatchReturnInst>(BB->getTerminator()))
593  return OverdefinedState;
594 
595  int CommonState = OverdefinedState;
596  for (BasicBlock *SuccBB : successors(BB)) {
597  // We didn't manage to get a state for one of these predecessors,
598  // conservatively report this basic block as overdefined.
599  auto SuccStartState = InitialStates.find(SuccBB);
600  if (SuccStartState == InitialStates.end())
601  return OverdefinedState;
602 
603  // This is an EH Pad, conservatively report this basic block as overdefined.
604  if (SuccBB->isEHPad())
605  return OverdefinedState;
606 
607  int SuccState = SuccStartState->second;
608  assert(SuccState != OverdefinedState &&
609  "overdefined BBs shouldn't be in FinalStates");
610  if (CommonState == OverdefinedState)
611  CommonState = SuccState;
612 
613  // At least two successors have different InitialStates,
614  // conservatively report this basic block as overdefined.
615  if (CommonState != SuccState)
616  return OverdefinedState;
617  }
618 
619  return CommonState;
620 }
621 
622 bool WinEHStatePass::isStateStoreNeeded(EHPersonality Personality,
623  CallSite CS) {
624  if (!CS)
625  return false;
626 
627  // If the function touches memory, it needs a state store.
628  if (isAsynchronousEHPersonality(Personality))
629  return !CS.doesNotAccessMemory();
630 
631  // If the function throws, it needs a state store.
632  return !CS.doesNotThrow();
633 }
634 
635 void WinEHStatePass::addStateStores(Function &F, WinEHFuncInfo &FuncInfo) {
636  // Mark the registration node. The backend needs to know which alloca it is so
637  // that it can recover the original frame pointer.
638  IRBuilder<> Builder(RegNode->getNextNode());
639  Value *RegNodeI8 = Builder.CreateBitCast(RegNode, Builder.getInt8PtrTy());
640  Builder.CreateCall(
641  Intrinsic::getDeclaration(TheModule, Intrinsic::x86_seh_ehregnode),
642  {RegNodeI8});
643 
644  if (EHGuardNode) {
645  IRBuilder<> Builder(EHGuardNode->getNextNode());
646  Value *EHGuardNodeI8 =
647  Builder.CreateBitCast(EHGuardNode, Builder.getInt8PtrTy());
648  Builder.CreateCall(
649  Intrinsic::getDeclaration(TheModule, Intrinsic::x86_seh_ehguard),
650  {EHGuardNodeI8});
651  }
652 
653  // Calculate state numbers.
654  if (isAsynchronousEHPersonality(Personality))
655  calculateSEHStateNumbers(&F, FuncInfo);
656  else
657  calculateWinCXXEHStateNumbers(&F, FuncInfo);
658 
659  // Iterate all the instructions and emit state number stores.
662 
663  // InitialStates yields the state of the first call-site for a BasicBlock.
664  DenseMap<BasicBlock *, int> InitialStates;
665  // FinalStates yields the state of the last call-site for a BasicBlock.
666  DenseMap<BasicBlock *, int> FinalStates;
667  // Worklist used to revisit BasicBlocks with indeterminate
668  // Initial/Final-States.
669  std::deque<BasicBlock *> Worklist;
670  // Fill in InitialStates and FinalStates for BasicBlocks with call-sites.
671  for (BasicBlock *BB : RPOT) {
672  int InitialState = OverdefinedState;
673  int FinalState;
674  if (&F.getEntryBlock() == BB)
675  InitialState = FinalState = ParentBaseState;
676  for (Instruction &I : *BB) {
677  CallSite CS(&I);
678  if (!isStateStoreNeeded(Personality, CS))
679  continue;
680 
681  int State = getStateForCallSite(BlockColors, FuncInfo, CS);
682  if (InitialState == OverdefinedState)
683  InitialState = State;
684  FinalState = State;
685  }
686  // No call-sites in this basic block? That's OK, we will come back to these
687  // in a later pass.
688  if (InitialState == OverdefinedState) {
689  Worklist.push_back(BB);
690  continue;
691  }
692  DEBUG(dbgs() << "X86WinEHState: " << BB->getName()
693  << " InitialState=" << InitialState << '\n');
694  DEBUG(dbgs() << "X86WinEHState: " << BB->getName()
695  << " FinalState=" << FinalState << '\n');
696  InitialStates.insert({BB, InitialState});
697  FinalStates.insert({BB, FinalState});
698  }
699 
700  // Try to fill-in InitialStates and FinalStates which have no call-sites.
701  while (!Worklist.empty()) {
702  BasicBlock *BB = Worklist.front();
703  Worklist.pop_front();
704  // This BasicBlock has already been figured out, nothing more we can do.
705  if (InitialStates.count(BB) != 0)
706  continue;
707 
708  int PredState = getPredState(FinalStates, F, ParentBaseState, BB);
709  if (PredState == OverdefinedState)
710  continue;
711 
712  // We successfully inferred this BasicBlock's state via it's predecessors;
713  // enqueue it's successors to see if we can infer their states.
714  InitialStates.insert({BB, PredState});
715  FinalStates.insert({BB, PredState});
716  for (BasicBlock *SuccBB : successors(BB))
717  Worklist.push_back(SuccBB);
718  }
719 
720  // Try to hoist stores from successors.
721  for (BasicBlock *BB : RPOT) {
722  int SuccState = getSuccState(InitialStates, F, ParentBaseState, BB);
723  if (SuccState == OverdefinedState)
724  continue;
725 
726  // Update our FinalState to reflect the common InitialState of our
727  // successors.
728  FinalStates.insert({BB, SuccState});
729  }
730 
731  // Finally, insert state stores before call-sites which transition us to a new
732  // state.
733  for (BasicBlock *BB : RPOT) {
734  auto &BBColors = BlockColors[BB];
735  BasicBlock *FuncletEntryBB = BBColors.front();
736  if (isa<CleanupPadInst>(FuncletEntryBB->getFirstNonPHI()))
737  continue;
738 
739  int PrevState = getPredState(FinalStates, F, ParentBaseState, BB);
740  DEBUG(dbgs() << "X86WinEHState: " << BB->getName()
741  << " PrevState=" << PrevState << '\n');
742 
743  for (Instruction &I : *BB) {
744  CallSite CS(&I);
745  if (!isStateStoreNeeded(Personality, CS))
746  continue;
747 
748  int State = getStateForCallSite(BlockColors, FuncInfo, CS);
749  if (State != PrevState)
750  insertStateNumberStore(&I, State);
751  PrevState = State;
752  }
753 
754  // We might have hoisted a state store into this block, emit it now.
755  auto EndState = FinalStates.find(BB);
756  if (EndState != FinalStates.end())
757  if (EndState->second != PrevState)
758  insertStateNumberStore(BB->getTerminator(), EndState->second);
759  }
760 
761  SmallVector<CallSite, 1> SetJmp3CallSites;
762  for (BasicBlock *BB : RPOT) {
763  for (Instruction &I : *BB) {
764  CallSite CS(&I);
765  if (!CS)
766  continue;
767  if (CS.getCalledValue()->stripPointerCasts() !=
768  SetJmp3->stripPointerCasts())
769  continue;
770 
771  SetJmp3CallSites.push_back(CS);
772  }
773  }
774 
775  for (CallSite CS : SetJmp3CallSites) {
776  auto &BBColors = BlockColors[CS->getParent()];
777  BasicBlock *FuncletEntryBB = BBColors.front();
778  bool InCleanup = isa<CleanupPadInst>(FuncletEntryBB->getFirstNonPHI());
779 
780  IRBuilder<> Builder(CS.getInstruction());
781  Value *State;
782  if (InCleanup) {
783  Value *StateField =
784  Builder.CreateStructGEP(nullptr, RegNode, StateFieldIndex);
785  State = Builder.CreateLoad(StateField);
786  } else {
787  State = Builder.getInt32(getStateForCallSite(BlockColors, FuncInfo, CS));
788  }
789  rewriteSetJmpCallSite(Builder, F, CS, State);
790  }
791 }
792 
793 void WinEHStatePass::insertStateNumberStore(Instruction *IP, int State) {
794  IRBuilder<> Builder(IP);
795  Value *StateField =
796  Builder.CreateStructGEP(nullptr, RegNode, StateFieldIndex);
797  Builder.CreateStore(Builder.getInt32(State), StateField);
798 }
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:69
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:136
X86_StdCall - stdcall is the calling conventions mostly used by the Win32 API.
Definition: CallingConv.h:87
DenseMap< const FuncletPadInst *, int > FuncletBaseStateMap
Definition: WinEHFuncInfo.h:93
This class represents a function call, abstracting a target machine&#39;s calling convention.
F(f)
Hexagon Common GEP
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:207
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:252
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:754
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:668
InstrTy * getInstruction() const
Definition: CallSite.h:92
StoreInst * CreateStore(Value *Val, Value *Ptr, bool isVolatile=false)
Definition: IRBuilder.h:1180
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:1448
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:634
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:430
void takeName(Value *V)
Transfer the name from V to this value.
Definition: Value.cpp:292
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:980
bool isCall() const
Return true if a CallInst is enclosed.
Definition: CallSite.h:87
const BasicBlock & getEntryBlock() const
Definition: Function.h:572
LoadInst * CreateLoad(Value *Ptr, const char *Name)
Definition: IRBuilder.h:1168
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:171
Subclasses of this class are all able to terminate a basic block.
Definition: InstrTypes.h:54
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:116
const Instruction & front() const
Definition: BasicBlock.h:264
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:603
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:153
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs, and aliases.
Definition: Value.cpp:558
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:386
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:864
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:308
pred_range predecessors(BasicBlock *BB)
Definition: CFG.h:110
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:285
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:132
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:462
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:398
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:120
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:220
#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:719
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:383
LLVM Value Representation.
Definition: Value.h:73
Constant * getPersonalityFn() const
Get the personality function associated with this function.
Definition: Function.cpp:1260
succ_range successors(BasicBlock *BB)
Definition: CFG.h:143
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:1365
#define DEBUG(X)
Definition: Debug.h:118
void addFnAttr(Attribute::AttrKind Kind)
Add function attributes to this function.
Definition: Function.h:211
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:120
DenseMap< BasicBlock *, ColorVector > colorEHFunclets(Function &F)
If an EH funclet personality is in use (see isFuncletEHPersonality), this will recompute which blocks...
InvokeInst * CreateInvoke(Value *Callee, BasicBlock *NormalDest, BasicBlock *UnwindDest, ArrayRef< Value *> Args=None, const Twine &Name="")
Create an invoke instruction.
Definition: IRBuilder.h:817
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:1663
void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
Adds the attribute to the indicated argument.