clang  3.7.0
CGException.cpp
Go to the documentation of this file.
1 //===--- CGException.cpp - Emit LLVM Code for C++ 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 // This contains code dealing with C++ exception related code generation.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "CodeGenFunction.h"
15 #include "CGCXXABI.h"
16 #include "CGCleanup.h"
17 #include "CGObjCRuntime.h"
18 #include "TargetInfo.h"
19 #include "clang/AST/Mangle.h"
20 #include "clang/AST/StmtCXX.h"
21 #include "clang/AST/StmtObjC.h"
22 #include "clang/AST/StmtVisitor.h"
24 #include "llvm/IR/CallSite.h"
25 #include "llvm/IR/Intrinsics.h"
26 #include "llvm/IR/IntrinsicInst.h"
27 #include "llvm/Support/SaveAndRestore.h"
28 
29 using namespace clang;
30 using namespace CodeGen;
31 
32 static llvm::Constant *getFreeExceptionFn(CodeGenModule &CGM) {
33  // void __cxa_free_exception(void *thrown_exception);
34 
35  llvm::FunctionType *FTy =
36  llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*IsVarArgs=*/false);
37 
38  return CGM.CreateRuntimeFunction(FTy, "__cxa_free_exception");
39 }
40 
41 static llvm::Constant *getUnexpectedFn(CodeGenModule &CGM) {
42  // void __cxa_call_unexpected(void *thrown_exception);
43 
44  llvm::FunctionType *FTy =
45  llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*IsVarArgs=*/false);
46 
47  return CGM.CreateRuntimeFunction(FTy, "__cxa_call_unexpected");
48 }
49 
50 llvm::Constant *CodeGenModule::getTerminateFn() {
51  // void __terminate();
52 
53  llvm::FunctionType *FTy =
54  llvm::FunctionType::get(VoidTy, /*IsVarArgs=*/false);
55 
56  StringRef name;
57 
58  // In C++, use std::terminate().
59  if (getLangOpts().CPlusPlus &&
60  getTarget().getCXXABI().isItaniumFamily()) {
61  name = "_ZSt9terminatev";
62  } else if (getLangOpts().CPlusPlus &&
63  getTarget().getCXXABI().isMicrosoft()) {
64  if (getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015))
65  name = "__std_terminate";
66  else
67  name = "\01?terminate@@YAXXZ";
68  } else if (getLangOpts().ObjC1 &&
70  name = "objc_terminate";
71  else
72  name = "abort";
73  return CreateRuntimeFunction(FTy, name);
74 }
75 
76 static llvm::Constant *getCatchallRethrowFn(CodeGenModule &CGM,
77  StringRef Name) {
78  llvm::FunctionType *FTy =
79  llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*IsVarArgs=*/false);
80 
81  return CGM.CreateRuntimeFunction(FTy, Name);
82 }
83 
84 namespace {
85  /// The exceptions personality for a function.
86  struct EHPersonality {
87  const char *PersonalityFn;
88 
89  // If this is non-null, this personality requires a non-standard
90  // function for rethrowing an exception after a catchall cleanup.
91  // This function must have prototype void(void*).
92  const char *CatchallRethrowFn;
93 
94  static const EHPersonality &get(CodeGenModule &CGM,
95  const FunctionDecl *FD);
96  static const EHPersonality &get(CodeGenFunction &CGF) {
97  return get(CGF.CGM, dyn_cast_or_null<FunctionDecl>(CGF.CurCodeDecl));
98  }
99 
100  static const EHPersonality GNU_C;
101  static const EHPersonality GNU_C_SJLJ;
102  static const EHPersonality GNU_C_SEH;
103  static const EHPersonality GNU_ObjC;
104  static const EHPersonality GNUstep_ObjC;
105  static const EHPersonality GNU_ObjCXX;
106  static const EHPersonality NeXT_ObjC;
107  static const EHPersonality GNU_CPlusPlus;
108  static const EHPersonality GNU_CPlusPlus_SJLJ;
109  static const EHPersonality GNU_CPlusPlus_SEH;
110  static const EHPersonality MSVC_except_handler;
111  static const EHPersonality MSVC_C_specific_handler;
112  static const EHPersonality MSVC_CxxFrameHandler3;
113  };
114 }
115 
116 const EHPersonality EHPersonality::GNU_C = { "__gcc_personality_v0", nullptr };
117 const EHPersonality
118 EHPersonality::GNU_C_SJLJ = { "__gcc_personality_sj0", nullptr };
119 const EHPersonality
120 EHPersonality::GNU_C_SEH = { "__gcc_personality_seh0", nullptr };
121 const EHPersonality
122 EHPersonality::NeXT_ObjC = { "__objc_personality_v0", nullptr };
123 const EHPersonality
124 EHPersonality::GNU_CPlusPlus = { "__gxx_personality_v0", nullptr };
125 const EHPersonality
126 EHPersonality::GNU_CPlusPlus_SJLJ = { "__gxx_personality_sj0", nullptr };
127 const EHPersonality
128 EHPersonality::GNU_CPlusPlus_SEH = { "__gxx_personality_seh0", nullptr };
129 const EHPersonality
130 EHPersonality::GNU_ObjC = {"__gnu_objc_personality_v0", "objc_exception_throw"};
131 const EHPersonality
132 EHPersonality::GNU_ObjCXX = { "__gnustep_objcxx_personality_v0", nullptr };
133 const EHPersonality
134 EHPersonality::GNUstep_ObjC = { "__gnustep_objc_personality_v0", nullptr };
135 const EHPersonality
136 EHPersonality::MSVC_except_handler = { "_except_handler3", nullptr };
137 const EHPersonality
138 EHPersonality::MSVC_C_specific_handler = { "__C_specific_handler", nullptr };
139 const EHPersonality
140 EHPersonality::MSVC_CxxFrameHandler3 = { "__CxxFrameHandler3", nullptr };
141 
142 /// On Win64, use libgcc's SEH personality function. We fall back to dwarf on
143 /// other platforms, unless the user asked for SjLj exceptions.
144 static bool useLibGCCSEHPersonality(const llvm::Triple &T) {
145  return T.isOSWindows() && T.getArch() == llvm::Triple::x86_64;
146 }
147 
148 static const EHPersonality &getCPersonality(const llvm::Triple &T,
149  const LangOptions &L) {
150  if (L.SjLjExceptions)
151  return EHPersonality::GNU_C_SJLJ;
152  else if (useLibGCCSEHPersonality(T))
153  return EHPersonality::GNU_C_SEH;
154  return EHPersonality::GNU_C;
155 }
156 
157 static const EHPersonality &getObjCPersonality(const llvm::Triple &T,
158  const LangOptions &L) {
159  switch (L.ObjCRuntime.getKind()) {
161  return getCPersonality(T, L);
162  case ObjCRuntime::MacOSX:
163  case ObjCRuntime::iOS:
164  return EHPersonality::NeXT_ObjC;
166  if (L.ObjCRuntime.getVersion() >= VersionTuple(1, 7))
167  return EHPersonality::GNUstep_ObjC;
168  // fallthrough
169  case ObjCRuntime::GCC:
170  case ObjCRuntime::ObjFW:
171  return EHPersonality::GNU_ObjC;
172  }
173  llvm_unreachable("bad runtime kind");
174 }
175 
176 static const EHPersonality &getCXXPersonality(const llvm::Triple &T,
177  const LangOptions &L) {
178  if (L.SjLjExceptions)
179  return EHPersonality::GNU_CPlusPlus_SJLJ;
180  else if (useLibGCCSEHPersonality(T))
181  return EHPersonality::GNU_CPlusPlus_SEH;
182  return EHPersonality::GNU_CPlusPlus;
183 }
184 
185 /// Determines the personality function to use when both C++
186 /// and Objective-C exceptions are being caught.
187 static const EHPersonality &getObjCXXPersonality(const llvm::Triple &T,
188  const LangOptions &L) {
189  switch (L.ObjCRuntime.getKind()) {
190  // The ObjC personality defers to the C++ personality for non-ObjC
191  // handlers. Unlike the C++ case, we use the same personality
192  // function on targets using (backend-driven) SJLJ EH.
193  case ObjCRuntime::MacOSX:
194  case ObjCRuntime::iOS:
195  return EHPersonality::NeXT_ObjC;
196 
197  // In the fragile ABI, just use C++ exception handling and hope
198  // they're not doing crazy exception mixing.
200  return getCXXPersonality(T, L);
201 
202  // The GCC runtime's personality function inherently doesn't support
203  // mixed EH. Use the C++ personality just to avoid returning null.
204  case ObjCRuntime::GCC:
205  case ObjCRuntime::ObjFW: // XXX: this will change soon
206  return EHPersonality::GNU_ObjC;
208  return EHPersonality::GNU_ObjCXX;
209  }
210  llvm_unreachable("bad runtime kind");
211 }
212 
213 static const EHPersonality &getSEHPersonalityMSVC(const llvm::Triple &T) {
214  if (T.getArch() == llvm::Triple::x86)
215  return EHPersonality::MSVC_except_handler;
216  return EHPersonality::MSVC_C_specific_handler;
217 }
218 
219 const EHPersonality &EHPersonality::get(CodeGenModule &CGM,
220  const FunctionDecl *FD) {
221  const llvm::Triple &T = CGM.getTarget().getTriple();
222  const LangOptions &L = CGM.getLangOpts();
223 
224  // Try to pick a personality function that is compatible with MSVC if we're
225  // not compiling Obj-C. Obj-C users better have an Obj-C runtime that supports
226  // the GCC-style personality function.
227  if (T.isWindowsMSVCEnvironment() && !L.ObjC1) {
228  if (L.SjLjExceptions)
229  return EHPersonality::GNU_CPlusPlus_SJLJ;
230  else if (FD && FD->usesSEHTry())
231  return getSEHPersonalityMSVC(T);
232  else
233  return EHPersonality::MSVC_CxxFrameHandler3;
234  }
235 
236  if (L.CPlusPlus && L.ObjC1)
237  return getObjCXXPersonality(T, L);
238  else if (L.CPlusPlus)
239  return getCXXPersonality(T, L);
240  else if (L.ObjC1)
241  return getObjCPersonality(T, L);
242  else
243  return getCPersonality(T, L);
244 }
245 
246 static llvm::Constant *getPersonalityFn(CodeGenModule &CGM,
247  const EHPersonality &Personality) {
248  llvm::Constant *Fn =
249  CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.Int32Ty, true),
250  Personality.PersonalityFn);
251  return Fn;
252 }
253 
254 static llvm::Constant *getOpaquePersonalityFn(CodeGenModule &CGM,
255  const EHPersonality &Personality) {
256  llvm::Constant *Fn = getPersonalityFn(CGM, Personality);
257  return llvm::ConstantExpr::getBitCast(Fn, CGM.Int8PtrTy);
258 }
259 
260 /// Check whether a personality function could reasonably be swapped
261 /// for a C++ personality function.
262 static bool PersonalityHasOnlyCXXUses(llvm::Constant *Fn) {
263  for (llvm::User *U : Fn->users()) {
264  // Conditionally white-list bitcasts.
265  if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(U)) {
266  if (CE->getOpcode() != llvm::Instruction::BitCast) return false;
267  if (!PersonalityHasOnlyCXXUses(CE))
268  return false;
269  continue;
270  }
271 
272  // Otherwise, it has to be a landingpad instruction.
273  llvm::LandingPadInst *LPI = dyn_cast<llvm::LandingPadInst>(U);
274  if (!LPI) return false;
275 
276  for (unsigned I = 0, E = LPI->getNumClauses(); I != E; ++I) {
277  // Look for something that would've been returned by the ObjC
278  // runtime's GetEHType() method.
279  llvm::Value *Val = LPI->getClause(I)->stripPointerCasts();
280  if (LPI->isCatch(I)) {
281  // Check if the catch value has the ObjC prefix.
282  if (llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Val))
283  // ObjC EH selector entries are always global variables with
284  // names starting like this.
285  if (GV->getName().startswith("OBJC_EHTYPE"))
286  return false;
287  } else {
288  // Check if any of the filter values have the ObjC prefix.
289  llvm::Constant *CVal = cast<llvm::Constant>(Val);
290  for (llvm::User::op_iterator
291  II = CVal->op_begin(), IE = CVal->op_end(); II != IE; ++II) {
292  if (llvm::GlobalVariable *GV =
293  cast<llvm::GlobalVariable>((*II)->stripPointerCasts()))
294  // ObjC EH selector entries are always global variables with
295  // names starting like this.
296  if (GV->getName().startswith("OBJC_EHTYPE"))
297  return false;
298  }
299  }
300  }
301  }
302 
303  return true;
304 }
305 
306 /// Try to use the C++ personality function in ObjC++. Not doing this
307 /// can cause some incompatibilities with gcc, which is more
308 /// aggressive about only using the ObjC++ personality in a function
309 /// when it really needs it.
310 void CodeGenModule::SimplifyPersonality() {
311  // If we're not in ObjC++ -fexceptions, there's nothing to do.
312  if (!LangOpts.CPlusPlus || !LangOpts.ObjC1 || !LangOpts.Exceptions)
313  return;
314 
315  // Both the problem this endeavors to fix and the way the logic
316  // above works is specific to the NeXT runtime.
317  if (!LangOpts.ObjCRuntime.isNeXTFamily())
318  return;
319 
320  const EHPersonality &ObjCXX = EHPersonality::get(*this, /*FD=*/nullptr);
321  const EHPersonality &CXX =
322  getCXXPersonality(getTarget().getTriple(), LangOpts);
323  if (&ObjCXX == &CXX)
324  return;
325 
326  assert(std::strcmp(ObjCXX.PersonalityFn, CXX.PersonalityFn) != 0 &&
327  "Different EHPersonalities using the same personality function.");
328 
329  llvm::Function *Fn = getModule().getFunction(ObjCXX.PersonalityFn);
330 
331  // Nothing to do if it's unused.
332  if (!Fn || Fn->use_empty()) return;
333 
334  // Can't do the optimization if it has non-C++ uses.
335  if (!PersonalityHasOnlyCXXUses(Fn)) return;
336 
337  // Create the C++ personality function and kill off the old
338  // function.
339  llvm::Constant *CXXFn = getPersonalityFn(*this, CXX);
340 
341  // This can happen if the user is screwing with us.
342  if (Fn->getType() != CXXFn->getType()) return;
343 
344  Fn->replaceAllUsesWith(CXXFn);
345  Fn->eraseFromParent();
346 }
347 
348 /// Returns the value to inject into a selector to indicate the
349 /// presence of a catch-all.
350 static llvm::Constant *getCatchAllValue(CodeGenFunction &CGF) {
351  // Possibly we should use @llvm.eh.catch.all.value here.
352  return llvm::ConstantPointerNull::get(CGF.Int8PtrTy);
353 }
354 
355 namespace {
356  /// A cleanup to free the exception object if its initialization
357  /// throws.
358  struct FreeException : EHScopeStack::Cleanup {
359  llvm::Value *exn;
360  FreeException(llvm::Value *exn) : exn(exn) {}
361  void Emit(CodeGenFunction &CGF, Flags flags) override {
363  }
364  };
365 }
366 
367 // Emits an exception expression into the given location. This
368 // differs from EmitAnyExprToMem only in that, if a final copy-ctor
369 // call is required, an exception within that copy ctor causes
370 // std::terminate to be invoked.
372  // Make sure the exception object is cleaned up if there's an
373  // exception during initialization.
374  pushFullExprCleanup<FreeException>(EHCleanup, addr);
376 
377  // __cxa_allocate_exception returns a void*; we need to cast this
378  // to the appropriate type for the object.
379  llvm::Type *ty = ConvertTypeForMem(e->getType())->getPointerTo();
380  llvm::Value *typedAddr = Builder.CreateBitCast(addr, ty);
381 
382  // FIXME: this isn't quite right! If there's a final unelided call
383  // to a copy constructor, then according to [except.terminate]p1 we
384  // must call std::terminate() if that constructor throws, because
385  // technically that copy occurs after the exception expression is
386  // evaluated but before the exception is caught. But the best way
387  // to handle that is to teach EmitAggExpr to do the final copy
388  // differently if it can't be elided.
389  EmitAnyExprToMem(e, typedAddr, e->getType().getQualifiers(),
390  /*IsInit*/ true);
391 
392  // Deactivate the cleanup block.
393  DeactivateCleanupBlock(cleanup, cast<llvm::Instruction>(typedAddr));
394 }
395 
397  if (!ExceptionSlot)
399  return ExceptionSlot;
400 }
401 
403  if (!EHSelectorSlot)
404  EHSelectorSlot = CreateTempAlloca(Int32Ty, "ehselector.slot");
405  return EHSelectorSlot;
406 }
407 
409  return Builder.CreateLoad(getExceptionSlot(), "exn");
410 }
411 
413  return Builder.CreateLoad(getEHSelectorSlot(), "sel");
414 }
415 
417  bool KeepInsertionPoint) {
418  if (const Expr *SubExpr = E->getSubExpr()) {
419  QualType ThrowType = SubExpr->getType();
420  if (ThrowType->isObjCObjectPointerType()) {
421  const Stmt *ThrowStmt = E->getSubExpr();
422  const ObjCAtThrowStmt S(E->getExprLoc(), const_cast<Stmt *>(ThrowStmt));
423  CGM.getObjCRuntime().EmitThrowStmt(*this, S, false);
424  } else {
425  CGM.getCXXABI().emitThrow(*this, E);
426  }
427  } else {
428  CGM.getCXXABI().emitRethrow(*this, /*isNoReturn=*/true);
429  }
430 
431  // throw is an expression, and the expression emitters expect us
432  // to leave ourselves at a valid insertion point.
433  if (KeepInsertionPoint)
434  EmitBlock(createBasicBlock("throw.cont"));
435 }
436 
438  if (!CGM.getLangOpts().CXXExceptions)
439  return;
440 
441  const FunctionDecl* FD = dyn_cast_or_null<FunctionDecl>(D);
442  if (!FD) {
443  // Check if CapturedDecl is nothrow and create terminate scope for it.
444  if (const CapturedDecl* CD = dyn_cast_or_null<CapturedDecl>(D)) {
445  if (CD->isNothrow())
447  }
448  return;
449  }
450  const FunctionProtoType *Proto = FD->getType()->getAs<FunctionProtoType>();
451  if (!Proto)
452  return;
453 
455  if (isNoexceptExceptionSpec(EST)) {
457  // noexcept functions are simple terminate scopes.
459  }
460  } else if (EST == EST_Dynamic || EST == EST_DynamicNone) {
461  // TODO: Revisit exception specifications for the MS ABI. There is a way to
462  // encode these in an object file but MSVC doesn't do anything with it.
463  if (getTarget().getCXXABI().isMicrosoft())
464  return;
465  unsigned NumExceptions = Proto->getNumExceptions();
466  EHFilterScope *Filter = EHStack.pushFilter(NumExceptions);
467 
468  for (unsigned I = 0; I != NumExceptions; ++I) {
469  QualType Ty = Proto->getExceptionType(I);
470  QualType ExceptType = Ty.getNonReferenceType().getUnqualifiedType();
471  llvm::Value *EHType = CGM.GetAddrOfRTTIDescriptor(ExceptType,
472  /*ForEH=*/true);
473  Filter->setFilter(I, EHType);
474  }
475  }
476 }
477 
478 /// Emit the dispatch block for a filter scope if necessary.
480  EHFilterScope &filterScope) {
481  llvm::BasicBlock *dispatchBlock = filterScope.getCachedEHDispatchBlock();
482  if (!dispatchBlock) return;
483  if (dispatchBlock->use_empty()) {
484  delete dispatchBlock;
485  return;
486  }
487 
488  CGF.EmitBlockAfterUses(dispatchBlock);
489 
490  // If this isn't a catch-all filter, we need to check whether we got
491  // here because the filter triggered.
492  if (filterScope.getNumFilters()) {
493  // Load the selector value.
494  llvm::Value *selector = CGF.getSelectorFromSlot();
495  llvm::BasicBlock *unexpectedBB = CGF.createBasicBlock("ehspec.unexpected");
496 
497  llvm::Value *zero = CGF.Builder.getInt32(0);
498  llvm::Value *failsFilter =
499  CGF.Builder.CreateICmpSLT(selector, zero, "ehspec.fails");
500  CGF.Builder.CreateCondBr(failsFilter, unexpectedBB,
501  CGF.getEHResumeBlock(false));
502 
503  CGF.EmitBlock(unexpectedBB);
504  }
505 
506  // Call __cxa_call_unexpected. This doesn't need to be an invoke
507  // because __cxa_call_unexpected magically filters exceptions
508  // according to the last landing pad the exception was thrown
509  // into. Seriously.
510  llvm::Value *exn = CGF.getExceptionFromSlot();
511  CGF.EmitRuntimeCall(getUnexpectedFn(CGF.CGM), exn)
512  ->setDoesNotReturn();
513  CGF.Builder.CreateUnreachable();
514 }
515 
517  if (!CGM.getLangOpts().CXXExceptions)
518  return;
519 
520  const FunctionDecl* FD = dyn_cast_or_null<FunctionDecl>(D);
521  if (!FD) {
522  // Check if CapturedDecl is nothrow and pop terminate scope for it.
523  if (const CapturedDecl* CD = dyn_cast_or_null<CapturedDecl>(D)) {
524  if (CD->isNothrow())
526  }
527  return;
528  }
529  const FunctionProtoType *Proto = FD->getType()->getAs<FunctionProtoType>();
530  if (!Proto)
531  return;
532 
534  if (isNoexceptExceptionSpec(EST)) {
537  }
538  } else if (EST == EST_Dynamic || EST == EST_DynamicNone) {
539  // TODO: Revisit exception specifications for the MS ABI. There is a way to
540  // encode these in an object file but MSVC doesn't do anything with it.
541  if (getTarget().getCXXABI().isMicrosoft())
542  return;
543  EHFilterScope &filterScope = cast<EHFilterScope>(*EHStack.begin());
544  emitFilterDispatchBlock(*this, filterScope);
545  EHStack.popFilter();
546  }
547 }
548 
550  EnterCXXTryStmt(S);
551  EmitStmt(S.getTryBlock());
552  ExitCXXTryStmt(S);
553 }
554 
555 void CodeGenFunction::EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock) {
556  unsigned NumHandlers = S.getNumHandlers();
557  EHCatchScope *CatchScope = EHStack.pushCatch(NumHandlers);
558 
559  for (unsigned I = 0; I != NumHandlers; ++I) {
560  const CXXCatchStmt *C = S.getHandler(I);
561 
562  llvm::BasicBlock *Handler = createBasicBlock("catch");
563  if (C->getExceptionDecl()) {
564  // FIXME: Dropping the reference type on the type into makes it
565  // impossible to correctly implement catch-by-reference
566  // semantics for pointers. Unfortunately, this is what all
567  // existing compilers do, and it's not clear that the standard
568  // personality routine is capable of doing this right. See C++ DR 388:
569  // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#388
570  Qualifiers CaughtTypeQuals;
571  QualType CaughtType = CGM.getContext().getUnqualifiedArrayType(
572  C->getCaughtType().getNonReferenceType(), CaughtTypeQuals);
573 
574  llvm::Constant *TypeInfo = nullptr;
575  if (CaughtType->isObjCObjectPointerType())
576  TypeInfo = CGM.getObjCRuntime().GetEHType(CaughtType);
577  else
578  TypeInfo =
579  CGM.getAddrOfCXXCatchHandlerType(CaughtType, C->getCaughtType());
580  CatchScope->setHandler(I, TypeInfo, Handler);
581  } else {
582  // No exception decl indicates '...', a catch-all.
583  CatchScope->setCatchAllHandler(I, Handler);
584  }
585  }
586 }
587 
588 llvm::BasicBlock *
590  // The dispatch block for the end of the scope chain is a block that
591  // just resumes unwinding.
592  if (si == EHStack.stable_end())
593  return getEHResumeBlock(true);
594 
595  // Otherwise, we should look at the actual scope.
596  EHScope &scope = *EHStack.find(si);
597 
598  llvm::BasicBlock *dispatchBlock = scope.getCachedEHDispatchBlock();
599  if (!dispatchBlock) {
600  switch (scope.getKind()) {
601  case EHScope::Catch: {
602  // Apply a special case to a single catch-all.
603  EHCatchScope &catchScope = cast<EHCatchScope>(scope);
604  if (catchScope.getNumHandlers() == 1 &&
605  catchScope.getHandler(0).isCatchAll()) {
606  dispatchBlock = catchScope.getHandler(0).Block;
607 
608  // Otherwise, make a dispatch block.
609  } else {
610  dispatchBlock = createBasicBlock("catch.dispatch");
611  }
612  break;
613  }
614 
615  case EHScope::Cleanup:
616  dispatchBlock = createBasicBlock("ehcleanup");
617  break;
618 
619  case EHScope::Filter:
620  dispatchBlock = createBasicBlock("filter.dispatch");
621  break;
622 
623  case EHScope::Terminate:
624  dispatchBlock = getTerminateHandler();
625  break;
626  }
627  scope.setCachedEHDispatchBlock(dispatchBlock);
628  }
629  return dispatchBlock;
630 }
631 
632 /// Check whether this is a non-EH scope, i.e. a scope which doesn't
633 /// affect exception handling. Currently, the only non-EH scopes are
634 /// normal-only cleanup scopes.
635 static bool isNonEHScope(const EHScope &S) {
636  switch (S.getKind()) {
637  case EHScope::Cleanup:
638  return !cast<EHCleanupScope>(S).isEHCleanup();
639  case EHScope::Filter:
640  case EHScope::Catch:
641  case EHScope::Terminate:
642  return false;
643  }
644 
645  llvm_unreachable("Invalid EHScope Kind!");
646 }
647 
649  assert(EHStack.requiresLandingPad());
650  assert(!EHStack.empty());
651 
652  // If exceptions are disabled, there are usually no landingpads. However, when
653  // SEH is enabled, functions using SEH still get landingpads.
654  const LangOptions &LO = CGM.getLangOpts();
655  if (!LO.Exceptions) {
656  if (!LO.Borland && !LO.MicrosoftExt)
657  return nullptr;
659  return nullptr;
660  }
661 
662  // Check the innermost scope for a cached landing pad. If this is
663  // a non-EH cleanup, we'll check enclosing scopes in EmitLandingPad.
664  llvm::BasicBlock *LP = EHStack.begin()->getCachedLandingPad();
665  if (LP) return LP;
666 
667  // Build the landing pad for this scope.
668  LP = EmitLandingPad();
669  assert(LP);
670 
671  // Cache the landing pad on the innermost scope. If this is a
672  // non-EH scope, cache the landing pad on the enclosing scope, too.
673  for (EHScopeStack::iterator ir = EHStack.begin(); true; ++ir) {
674  ir->setCachedLandingPad(LP);
675  if (!isNonEHScope(*ir)) break;
676  }
677 
678  return LP;
679 }
680 
681 llvm::BasicBlock *CodeGenFunction::EmitLandingPad() {
682  assert(EHStack.requiresLandingPad());
683 
684  EHScope &innermostEHScope = *EHStack.find(EHStack.getInnermostEHScope());
685  switch (innermostEHScope.getKind()) {
686  case EHScope::Terminate:
687  return getTerminateLandingPad();
688 
689  case EHScope::Catch:
690  case EHScope::Cleanup:
691  case EHScope::Filter:
692  if (llvm::BasicBlock *lpad = innermostEHScope.getCachedLandingPad())
693  return lpad;
694  }
695 
696  // Save the current IR generation state.
697  CGBuilderTy::InsertPoint savedIP = Builder.saveAndClearIP();
698  auto DL = ApplyDebugLocation::CreateDefaultArtificial(*this, CurEHLocation);
699 
700  const EHPersonality &personality = EHPersonality::get(*this);
701 
702  if (!CurFn->hasPersonalityFn())
703  CurFn->setPersonalityFn(getOpaquePersonalityFn(CGM, personality));
704 
705  // Create and configure the landing pad.
706  llvm::BasicBlock *lpad = createBasicBlock("lpad");
707  EmitBlock(lpad);
708 
709  llvm::LandingPadInst *LPadInst = Builder.CreateLandingPad(
710  llvm::StructType::get(Int8PtrTy, Int32Ty, nullptr), 0);
711 
712  llvm::Value *LPadExn = Builder.CreateExtractValue(LPadInst, 0);
713  Builder.CreateStore(LPadExn, getExceptionSlot());
714  llvm::Value *LPadSel = Builder.CreateExtractValue(LPadInst, 1);
715  Builder.CreateStore(LPadSel, getEHSelectorSlot());
716 
717  // Save the exception pointer. It's safe to use a single exception
718  // pointer per function because EH cleanups can never have nested
719  // try/catches.
720  // Build the landingpad instruction.
721 
722  // Accumulate all the handlers in scope.
723  bool hasCatchAll = false;
724  bool hasCleanup = false;
725  bool hasFilter = false;
726  SmallVector<llvm::Value*, 4> filterTypes;
727  llvm::SmallPtrSet<llvm::Value*, 4> catchTypes;
728  for (EHScopeStack::iterator I = EHStack.begin(), E = EHStack.end(); I != E;
729  ++I) {
730 
731  switch (I->getKind()) {
732  case EHScope::Cleanup:
733  // If we have a cleanup, remember that.
734  hasCleanup = (hasCleanup || cast<EHCleanupScope>(*I).isEHCleanup());
735  continue;
736 
737  case EHScope::Filter: {
738  assert(I.next() == EHStack.end() && "EH filter is not end of EH stack");
739  assert(!hasCatchAll && "EH filter reached after catch-all");
740 
741  // Filter scopes get added to the landingpad in weird ways.
742  EHFilterScope &filter = cast<EHFilterScope>(*I);
743  hasFilter = true;
744 
745  // Add all the filter values.
746  for (unsigned i = 0, e = filter.getNumFilters(); i != e; ++i)
747  filterTypes.push_back(filter.getFilter(i));
748  goto done;
749  }
750 
751  case EHScope::Terminate:
752  // Terminate scopes are basically catch-alls.
753  assert(!hasCatchAll);
754  hasCatchAll = true;
755  goto done;
756 
757  case EHScope::Catch:
758  break;
759  }
760 
761  EHCatchScope &catchScope = cast<EHCatchScope>(*I);
762  for (unsigned hi = 0, he = catchScope.getNumHandlers(); hi != he; ++hi) {
763  EHCatchScope::Handler handler = catchScope.getHandler(hi);
764 
765  // If this is a catch-all, register that and abort.
766  if (!handler.Type) {
767  assert(!hasCatchAll);
768  hasCatchAll = true;
769  goto done;
770  }
771 
772  // Check whether we already have a handler for this type.
773  if (catchTypes.insert(handler.Type).second)
774  // If not, add it directly to the landingpad.
775  LPadInst->addClause(handler.Type);
776  }
777  }
778 
779  done:
780  // If we have a catch-all, add null to the landingpad.
781  assert(!(hasCatchAll && hasFilter));
782  if (hasCatchAll) {
783  LPadInst->addClause(getCatchAllValue(*this));
784 
785  // If we have an EH filter, we need to add those handlers in the
786  // right place in the landingpad, which is to say, at the end.
787  } else if (hasFilter) {
788  // Create a filter expression: a constant array indicating which filter
789  // types there are. The personality routine only lands here if the filter
790  // doesn't match.
792  llvm::ArrayType *AType =
793  llvm::ArrayType::get(!filterTypes.empty() ?
794  filterTypes[0]->getType() : Int8PtrTy,
795  filterTypes.size());
796 
797  for (unsigned i = 0, e = filterTypes.size(); i != e; ++i)
798  Filters.push_back(cast<llvm::Constant>(filterTypes[i]));
799  llvm::Constant *FilterArray = llvm::ConstantArray::get(AType, Filters);
800  LPadInst->addClause(FilterArray);
801 
802  // Also check whether we need a cleanup.
803  if (hasCleanup)
804  LPadInst->setCleanup(true);
805 
806  // Otherwise, signal that we at least have cleanups.
807  } else if (hasCleanup) {
808  LPadInst->setCleanup(true);
809  }
810 
811  assert((LPadInst->getNumClauses() > 0 || LPadInst->isCleanup()) &&
812  "landingpad instruction has no clauses!");
813 
814  // Tell the backend how to generate the landing pad.
816 
817  // Restore the old IR generation state.
818  Builder.restoreIP(savedIP);
819 
820  return lpad;
821 }
822 
823 /// Emit the structure of the dispatch block for the given catch scope.
824 /// It is an invariant that the dispatch block already exists.
826  EHCatchScope &catchScope) {
827  llvm::BasicBlock *dispatchBlock = catchScope.getCachedEHDispatchBlock();
828  assert(dispatchBlock);
829 
830  // If there's only a single catch-all, getEHDispatchBlock returned
831  // that catch-all as the dispatch block.
832  if (catchScope.getNumHandlers() == 1 &&
833  catchScope.getHandler(0).isCatchAll()) {
834  assert(dispatchBlock == catchScope.getHandler(0).Block);
835  return;
836  }
837 
838  CGBuilderTy::InsertPoint savedIP = CGF.Builder.saveIP();
839  CGF.EmitBlockAfterUses(dispatchBlock);
840 
841  // Select the right handler.
842  llvm::Value *llvm_eh_typeid_for =
843  CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_typeid_for);
844 
845  // Load the selector value.
846  llvm::Value *selector = CGF.getSelectorFromSlot();
847 
848  // Test against each of the exception types we claim to catch.
849  for (unsigned i = 0, e = catchScope.getNumHandlers(); ; ++i) {
850  assert(i < e && "ran off end of handlers!");
851  const EHCatchScope::Handler &handler = catchScope.getHandler(i);
852 
853  llvm::Value *typeValue = handler.Type;
854  assert(typeValue && "fell into catch-all case!");
855  typeValue = CGF.Builder.CreateBitCast(typeValue, CGF.Int8PtrTy);
856 
857  // Figure out the next block.
858  bool nextIsEnd;
859  llvm::BasicBlock *nextBlock;
860 
861  // If this is the last handler, we're at the end, and the next
862  // block is the block for the enclosing EH scope.
863  if (i + 1 == e) {
864  nextBlock = CGF.getEHDispatchBlock(catchScope.getEnclosingEHScope());
865  nextIsEnd = true;
866 
867  // If the next handler is a catch-all, we're at the end, and the
868  // next block is that handler.
869  } else if (catchScope.getHandler(i+1).isCatchAll()) {
870  nextBlock = catchScope.getHandler(i+1).Block;
871  nextIsEnd = true;
872 
873  // Otherwise, we're not at the end and we need a new block.
874  } else {
875  nextBlock = CGF.createBasicBlock("catch.fallthrough");
876  nextIsEnd = false;
877  }
878 
879  // Figure out the catch type's index in the LSDA's type table.
880  llvm::CallInst *typeIndex =
881  CGF.Builder.CreateCall(llvm_eh_typeid_for, typeValue);
882  typeIndex->setDoesNotThrow();
883 
884  llvm::Value *matchesTypeIndex =
885  CGF.Builder.CreateICmpEQ(selector, typeIndex, "matches");
886  CGF.Builder.CreateCondBr(matchesTypeIndex, handler.Block, nextBlock);
887 
888  // If the next handler is a catch-all, we're completely done.
889  if (nextIsEnd) {
890  CGF.Builder.restoreIP(savedIP);
891  return;
892  }
893  // Otherwise we need to emit and continue at that block.
894  CGF.EmitBlock(nextBlock);
895  }
896 }
897 
899  EHCatchScope &catchScope = cast<EHCatchScope>(*EHStack.begin());
900  if (catchScope.hasEHBranches())
901  emitCatchDispatchBlock(*this, catchScope);
902  EHStack.popCatch();
903 }
904 
905 void CodeGenFunction::ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock) {
906  unsigned NumHandlers = S.getNumHandlers();
907  EHCatchScope &CatchScope = cast<EHCatchScope>(*EHStack.begin());
908  assert(CatchScope.getNumHandlers() == NumHandlers);
909 
910  // If the catch was not required, bail out now.
911  if (!CatchScope.hasEHBranches()) {
912  CatchScope.clearHandlerBlocks();
913  EHStack.popCatch();
914  return;
915  }
916 
917  // Emit the structure of the EH dispatch for this catch.
918  emitCatchDispatchBlock(*this, CatchScope);
919 
920  // Copy the handler blocks off before we pop the EH stack. Emitting
921  // the handlers might scribble on this memory.
922  SmallVector<EHCatchScope::Handler, 8> Handlers(NumHandlers);
923  memcpy(Handlers.data(), CatchScope.begin(),
924  NumHandlers * sizeof(EHCatchScope::Handler));
925 
926  EHStack.popCatch();
927 
928  // The fall-through block.
929  llvm::BasicBlock *ContBB = createBasicBlock("try.cont");
930 
931  // We just emitted the body of the try; jump to the continue block.
932  if (HaveInsertPoint())
933  Builder.CreateBr(ContBB);
934 
935  // Determine if we need an implicit rethrow for all these catch handlers;
936  // see the comment below.
937  bool doImplicitRethrow = false;
938  if (IsFnTryBlock)
939  doImplicitRethrow = isa<CXXDestructorDecl>(CurCodeDecl) ||
940  isa<CXXConstructorDecl>(CurCodeDecl);
941 
942  // Perversely, we emit the handlers backwards precisely because we
943  // want them to appear in source order. In all of these cases, the
944  // catch block will have exactly one predecessor, which will be a
945  // particular block in the catch dispatch. However, in the case of
946  // a catch-all, one of the dispatch blocks will branch to two
947  // different handlers, and EmitBlockAfterUses will cause the second
948  // handler to be moved before the first.
949  for (unsigned I = NumHandlers; I != 0; --I) {
950  llvm::BasicBlock *CatchBlock = Handlers[I-1].Block;
951  EmitBlockAfterUses(CatchBlock);
952 
953  // Catch the exception if this isn't a catch-all.
954  const CXXCatchStmt *C = S.getHandler(I-1);
955 
956  // Enter a cleanup scope, including the catch variable and the
957  // end-catch.
958  RunCleanupsScope CatchScope(*this);
959 
960  // Initialize the catch variable and set up the cleanups.
961  CGM.getCXXABI().emitBeginCatch(*this, C);
962 
963  // Emit the PGO counter increment.
965 
966  // Perform the body of the catch.
968 
969  // [except.handle]p11:
970  // The currently handled exception is rethrown if control
971  // reaches the end of a handler of the function-try-block of a
972  // constructor or destructor.
973 
974  // It is important that we only do this on fallthrough and not on
975  // return. Note that it's illegal to put a return in a
976  // constructor function-try-block's catch handler (p14), so this
977  // really only applies to destructors.
978  if (doImplicitRethrow && HaveInsertPoint()) {
979  CGM.getCXXABI().emitRethrow(*this, /*isNoReturn*/false);
980  Builder.CreateUnreachable();
981  Builder.ClearInsertionPoint();
982  }
983 
984  // Fall out through the catch cleanups.
985  CatchScope.ForceCleanup();
986 
987  // Branch out of the try.
988  if (HaveInsertPoint())
989  Builder.CreateBr(ContBB);
990  }
991 
992  EmitBlock(ContBB);
994 }
995 
996 namespace {
997  struct CallEndCatchForFinally : EHScopeStack::Cleanup {
998  llvm::Value *ForEHVar;
999  llvm::Value *EndCatchFn;
1000  CallEndCatchForFinally(llvm::Value *ForEHVar, llvm::Value *EndCatchFn)
1001  : ForEHVar(ForEHVar), EndCatchFn(EndCatchFn) {}
1002 
1003  void Emit(CodeGenFunction &CGF, Flags flags) override {
1004  llvm::BasicBlock *EndCatchBB = CGF.createBasicBlock("finally.endcatch");
1005  llvm::BasicBlock *CleanupContBB =
1006  CGF.createBasicBlock("finally.cleanup.cont");
1007 
1008  llvm::Value *ShouldEndCatch =
1009  CGF.Builder.CreateLoad(ForEHVar, "finally.endcatch");
1010  CGF.Builder.CreateCondBr(ShouldEndCatch, EndCatchBB, CleanupContBB);
1011  CGF.EmitBlock(EndCatchBB);
1012  CGF.EmitRuntimeCallOrInvoke(EndCatchFn); // catch-all, so might throw
1013  CGF.EmitBlock(CleanupContBB);
1014  }
1015  };
1016 
1017  struct PerformFinally : EHScopeStack::Cleanup {
1018  const Stmt *Body;
1019  llvm::Value *ForEHVar;
1020  llvm::Value *EndCatchFn;
1021  llvm::Value *RethrowFn;
1022  llvm::Value *SavedExnVar;
1023 
1024  PerformFinally(const Stmt *Body, llvm::Value *ForEHVar,
1025  llvm::Value *EndCatchFn,
1026  llvm::Value *RethrowFn, llvm::Value *SavedExnVar)
1027  : Body(Body), ForEHVar(ForEHVar), EndCatchFn(EndCatchFn),
1028  RethrowFn(RethrowFn), SavedExnVar(SavedExnVar) {}
1029 
1030  void Emit(CodeGenFunction &CGF, Flags flags) override {
1031  // Enter a cleanup to call the end-catch function if one was provided.
1032  if (EndCatchFn)
1033  CGF.EHStack.pushCleanup<CallEndCatchForFinally>(NormalAndEHCleanup,
1034  ForEHVar, EndCatchFn);
1035 
1036  // Save the current cleanup destination in case there are
1037  // cleanups in the finally block.
1038  llvm::Value *SavedCleanupDest =
1039  CGF.Builder.CreateLoad(CGF.getNormalCleanupDestSlot(),
1040  "cleanup.dest.saved");
1041 
1042  // Emit the finally block.
1043  CGF.EmitStmt(Body);
1044 
1045  // If the end of the finally is reachable, check whether this was
1046  // for EH. If so, rethrow.
1047  if (CGF.HaveInsertPoint()) {
1048  llvm::BasicBlock *RethrowBB = CGF.createBasicBlock("finally.rethrow");
1049  llvm::BasicBlock *ContBB = CGF.createBasicBlock("finally.cont");
1050 
1051  llvm::Value *ShouldRethrow =
1052  CGF.Builder.CreateLoad(ForEHVar, "finally.shouldthrow");
1053  CGF.Builder.CreateCondBr(ShouldRethrow, RethrowBB, ContBB);
1054 
1055  CGF.EmitBlock(RethrowBB);
1056  if (SavedExnVar) {
1057  CGF.EmitRuntimeCallOrInvoke(RethrowFn,
1058  CGF.Builder.CreateLoad(SavedExnVar));
1059  } else {
1060  CGF.EmitRuntimeCallOrInvoke(RethrowFn);
1061  }
1062  CGF.Builder.CreateUnreachable();
1063 
1064  CGF.EmitBlock(ContBB);
1065 
1066  // Restore the cleanup destination.
1067  CGF.Builder.CreateStore(SavedCleanupDest,
1068  CGF.getNormalCleanupDestSlot());
1069  }
1070 
1071  // Leave the end-catch cleanup. As an optimization, pretend that
1072  // the fallthrough path was inaccessible; we've dynamically proven
1073  // that we're not in the EH case along that path.
1074  if (EndCatchFn) {
1075  CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
1076  CGF.PopCleanupBlock();
1077  CGF.Builder.restoreIP(SavedIP);
1078  }
1079 
1080  // Now make sure we actually have an insertion point or the
1081  // cleanup gods will hate us.
1082  CGF.EnsureInsertPoint();
1083  }
1084  };
1085 }
1086 
1087 /// Enters a finally block for an implementation using zero-cost
1088 /// exceptions. This is mostly general, but hard-codes some
1089 /// language/ABI-specific behavior in the catch-all sections.
1091  const Stmt *body,
1092  llvm::Constant *beginCatchFn,
1093  llvm::Constant *endCatchFn,
1094  llvm::Constant *rethrowFn) {
1095  assert((beginCatchFn != nullptr) == (endCatchFn != nullptr) &&
1096  "begin/end catch functions not paired");
1097  assert(rethrowFn && "rethrow function is required");
1098 
1099  BeginCatchFn = beginCatchFn;
1100 
1101  // The rethrow function has one of the following two types:
1102  // void (*)()
1103  // void (*)(void*)
1104  // In the latter case we need to pass it the exception object.
1105  // But we can't use the exception slot because the @finally might
1106  // have a landing pad (which would overwrite the exception slot).
1107  llvm::FunctionType *rethrowFnTy =
1108  cast<llvm::FunctionType>(
1109  cast<llvm::PointerType>(rethrowFn->getType())->getElementType());
1110  SavedExnVar = nullptr;
1111  if (rethrowFnTy->getNumParams())
1112  SavedExnVar = CGF.CreateTempAlloca(CGF.Int8PtrTy, "finally.exn");
1113 
1114  // A finally block is a statement which must be executed on any edge
1115  // out of a given scope. Unlike a cleanup, the finally block may
1116  // contain arbitrary control flow leading out of itself. In
1117  // addition, finally blocks should always be executed, even if there
1118  // are no catch handlers higher on the stack. Therefore, we
1119  // surround the protected scope with a combination of a normal
1120  // cleanup (to catch attempts to break out of the block via normal
1121  // control flow) and an EH catch-all (semantically "outside" any try
1122  // statement to which the finally block might have been attached).
1123  // The finally block itself is generated in the context of a cleanup
1124  // which conditionally leaves the catch-all.
1125 
1126  // Jump destination for performing the finally block on an exception
1127  // edge. We'll never actually reach this block, so unreachable is
1128  // fine.
1129  RethrowDest = CGF.getJumpDestInCurrentScope(CGF.getUnreachableBlock());
1130 
1131  // Whether the finally block is being executed for EH purposes.
1132  ForEHVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(), "finally.for-eh");
1133  CGF.Builder.CreateStore(CGF.Builder.getFalse(), ForEHVar);
1134 
1135  // Enter a normal cleanup which will perform the @finally block.
1136  CGF.EHStack.pushCleanup<PerformFinally>(NormalCleanup, body,
1137  ForEHVar, endCatchFn,
1138  rethrowFn, SavedExnVar);
1139 
1140  // Enter a catch-all scope.
1141  llvm::BasicBlock *catchBB = CGF.createBasicBlock("finally.catchall");
1142  EHCatchScope *catchScope = CGF.EHStack.pushCatch(1);
1143  catchScope->setCatchAllHandler(0, catchBB);
1144 }
1145 
1147  // Leave the finally catch-all.
1148  EHCatchScope &catchScope = cast<EHCatchScope>(*CGF.EHStack.begin());
1149  llvm::BasicBlock *catchBB = catchScope.getHandler(0).Block;
1150 
1151  CGF.popCatchScope();
1152 
1153  // If there are any references to the catch-all block, emit it.
1154  if (catchBB->use_empty()) {
1155  delete catchBB;
1156  } else {
1157  CGBuilderTy::InsertPoint savedIP = CGF.Builder.saveAndClearIP();
1158  CGF.EmitBlock(catchBB);
1159 
1160  llvm::Value *exn = nullptr;
1161 
1162  // If there's a begin-catch function, call it.
1163  if (BeginCatchFn) {
1164  exn = CGF.getExceptionFromSlot();
1165  CGF.EmitNounwindRuntimeCall(BeginCatchFn, exn);
1166  }
1167 
1168  // If we need to remember the exception pointer to rethrow later, do so.
1169  if (SavedExnVar) {
1170  if (!exn) exn = CGF.getExceptionFromSlot();
1171  CGF.Builder.CreateStore(exn, SavedExnVar);
1172  }
1173 
1174  // Tell the cleanups in the finally block that we're do this for EH.
1175  CGF.Builder.CreateStore(CGF.Builder.getTrue(), ForEHVar);
1176 
1177  // Thread a jump through the finally cleanup.
1178  CGF.EmitBranchThroughCleanup(RethrowDest);
1179 
1180  CGF.Builder.restoreIP(savedIP);
1181  }
1182 
1183  // Finally, leave the @finally cleanup.
1184  CGF.PopCleanupBlock();
1185 }
1186 
1188  if (TerminateLandingPad)
1189  return TerminateLandingPad;
1190 
1191  CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
1192 
1193  // This will get inserted at the end of the function.
1194  TerminateLandingPad = createBasicBlock("terminate.lpad");
1195  Builder.SetInsertPoint(TerminateLandingPad);
1196 
1197  // Tell the backend that this is a landing pad.
1198  const EHPersonality &Personality = EHPersonality::get(*this);
1199 
1200  if (!CurFn->hasPersonalityFn())
1201  CurFn->setPersonalityFn(getOpaquePersonalityFn(CGM, Personality));
1202 
1203  llvm::LandingPadInst *LPadInst = Builder.CreateLandingPad(
1204  llvm::StructType::get(Int8PtrTy, Int32Ty, nullptr), 0);
1205  LPadInst->addClause(getCatchAllValue(*this));
1206 
1207  llvm::Value *Exn = 0;
1208  if (getLangOpts().CPlusPlus)
1209  Exn = Builder.CreateExtractValue(LPadInst, 0);
1210  llvm::CallInst *terminateCall =
1212  terminateCall->setDoesNotReturn();
1213  Builder.CreateUnreachable();
1214 
1215  // Restore the saved insertion state.
1216  Builder.restoreIP(SavedIP);
1217 
1218  return TerminateLandingPad;
1219 }
1220 
1222  if (TerminateHandler)
1223  return TerminateHandler;
1224 
1225  CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
1226 
1227  // Set up the terminate handler. This block is inserted at the very
1228  // end of the function by FinishFunction.
1229  TerminateHandler = createBasicBlock("terminate.handler");
1230  Builder.SetInsertPoint(TerminateHandler);
1231  llvm::Value *Exn = 0;
1232  if (getLangOpts().CPlusPlus)
1233  Exn = getExceptionFromSlot();
1234  llvm::CallInst *terminateCall =
1236  terminateCall->setDoesNotReturn();
1237  Builder.CreateUnreachable();
1238 
1239  // Restore the saved insertion state.
1240  Builder.restoreIP(SavedIP);
1241 
1242  return TerminateHandler;
1243 }
1244 
1245 llvm::BasicBlock *CodeGenFunction::getEHResumeBlock(bool isCleanup) {
1246  if (EHResumeBlock) return EHResumeBlock;
1247 
1248  CGBuilderTy::InsertPoint SavedIP = Builder.saveIP();
1249 
1250  // We emit a jump to a notional label at the outermost unwind state.
1251  EHResumeBlock = createBasicBlock("eh.resume");
1252  Builder.SetInsertPoint(EHResumeBlock);
1253 
1254  const EHPersonality &Personality = EHPersonality::get(*this);
1255 
1256  // This can always be a call because we necessarily didn't find
1257  // anything on the EH stack which needs our help.
1258  const char *RethrowName = Personality.CatchallRethrowFn;
1259  if (RethrowName != nullptr && !isCleanup) {
1260  EmitRuntimeCall(getCatchallRethrowFn(CGM, RethrowName),
1261  getExceptionFromSlot())->setDoesNotReturn();
1262  Builder.CreateUnreachable();
1263  Builder.restoreIP(SavedIP);
1264  return EHResumeBlock;
1265  }
1266 
1267  // Recreate the landingpad's return value for the 'resume' instruction.
1270 
1271  llvm::Type *LPadType = llvm::StructType::get(Exn->getType(),
1272  Sel->getType(), nullptr);
1273  llvm::Value *LPadVal = llvm::UndefValue::get(LPadType);
1274  LPadVal = Builder.CreateInsertValue(LPadVal, Exn, 0, "lpad.val");
1275  LPadVal = Builder.CreateInsertValue(LPadVal, Sel, 1, "lpad.val");
1276 
1277  Builder.CreateResume(LPadVal);
1278  Builder.restoreIP(SavedIP);
1279  return EHResumeBlock;
1280 }
1281 
1283  EnterSEHTryStmt(S);
1284  {
1285  JumpDest TryExit = getJumpDestInCurrentScope("__try.__leave");
1286 
1287  SEHTryEpilogueStack.push_back(&TryExit);
1288  EmitStmt(S.getTryBlock());
1289  SEHTryEpilogueStack.pop_back();
1290 
1291  if (!TryExit.getBlock()->use_empty())
1292  EmitBlock(TryExit.getBlock(), /*IsFinished=*/true);
1293  else
1294  delete TryExit.getBlock();
1295  }
1296  ExitSEHTryStmt(S);
1297 }
1298 
1299 namespace {
1300 struct PerformSEHFinally : EHScopeStack::Cleanup {
1301  llvm::Function *OutlinedFinally;
1302  PerformSEHFinally(llvm::Function *OutlinedFinally)
1303  : OutlinedFinally(OutlinedFinally) {}
1304 
1305  void Emit(CodeGenFunction &CGF, Flags F) override {
1306  ASTContext &Context = CGF.getContext();
1307  CodeGenModule &CGM = CGF.CGM;
1308 
1309  CallArgList Args;
1310 
1311  // Compute the two argument values.
1312  QualType ArgTys[2] = {Context.UnsignedCharTy, Context.VoidPtrTy};
1313  llvm::Value *LocalAddrFn = CGM.getIntrinsic(llvm::Intrinsic::localaddress);
1314  llvm::Value *FP = CGF.Builder.CreateCall(LocalAddrFn);
1315  llvm::Value *IsForEH =
1316  llvm::ConstantInt::get(CGF.ConvertType(ArgTys[0]), F.isForEHCleanup());
1317  Args.add(RValue::get(IsForEH), ArgTys[0]);
1318  Args.add(RValue::get(FP), ArgTys[1]);
1319 
1320  // Arrange a two-arg function info and type.
1322  const auto *FPT = cast<FunctionProtoType>(
1323  Context.getFunctionType(Context.VoidTy, ArgTys, EPI));
1324  const CGFunctionInfo &FnInfo =
1325  CGM.getTypes().arrangeFreeFunctionCall(Args, FPT,
1326  /*chainCall=*/false);
1327 
1328  CGF.EmitCall(FnInfo, OutlinedFinally, ReturnValueSlot(), Args);
1329  }
1330 };
1331 }
1332 
1333 namespace {
1334 /// Find all local variable captures in the statement.
1335 struct CaptureFinder : ConstStmtVisitor<CaptureFinder> {
1336  CodeGenFunction &ParentCGF;
1337  const VarDecl *ParentThis;
1339  llvm::Value *SEHCodeSlot = nullptr;
1340  CaptureFinder(CodeGenFunction &ParentCGF, const VarDecl *ParentThis)
1341  : ParentCGF(ParentCGF), ParentThis(ParentThis) {}
1342 
1343  // Return true if we need to do any capturing work.
1344  bool foundCaptures() {
1345  return !Captures.empty() || SEHCodeSlot;
1346  }
1347 
1348  void Visit(const Stmt *S) {
1349  // See if this is a capture, then recurse.
1351  for (const Stmt *Child : S->children())
1352  if (Child)
1353  Visit(Child);
1354  }
1355 
1356  void VisitDeclRefExpr(const DeclRefExpr *E) {
1357  // If this is already a capture, just make sure we capture 'this'.
1359  Captures.push_back(ParentThis);
1360  return;
1361  }
1362 
1363  const auto *D = dyn_cast<VarDecl>(E->getDecl());
1364  if (D && D->isLocalVarDeclOrParm() && D->hasLocalStorage())
1365  Captures.push_back(D);
1366  }
1367 
1368  void VisitCXXThisExpr(const CXXThisExpr *E) {
1369  Captures.push_back(ParentThis);
1370  }
1371 
1372  void VisitCallExpr(const CallExpr *E) {
1373  // We only need to add parent frame allocations for these builtins in x86.
1374  if (ParentCGF.getTarget().getTriple().getArch() != llvm::Triple::x86)
1375  return;
1376 
1377  unsigned ID = E->getBuiltinCallee();
1378  switch (ID) {
1379  case Builtin::BI__exception_code:
1380  case Builtin::BI_exception_code:
1381  // This is the simple case where we are the outermost finally. All we
1382  // have to do here is make sure we escape this and recover it in the
1383  // outlined handler.
1384  if (!SEHCodeSlot)
1385  SEHCodeSlot = ParentCGF.SEHCodeSlotStack.back();
1386  break;
1387  }
1388  }
1389 };
1390 }
1391 
1393  CodeGenFunction &ParentCGF, llvm::Value *ParentVar, llvm::Value *ParentFP) {
1394  llvm::CallInst *RecoverCall = nullptr;
1396  if (auto *ParentAlloca = dyn_cast<llvm::AllocaInst>(ParentVar)) {
1397  // Mark the variable escaped if nobody else referenced it and compute the
1398  // localescape index.
1399  auto InsertPair = ParentCGF.EscapedLocals.insert(
1400  std::make_pair(ParentAlloca, ParentCGF.EscapedLocals.size()));
1401  int FrameEscapeIdx = InsertPair.first->second;
1402  // call i8* @llvm.localrecover(i8* bitcast(@parentFn), i8* %fp, i32 N)
1403  llvm::Function *FrameRecoverFn = llvm::Intrinsic::getDeclaration(
1404  &CGM.getModule(), llvm::Intrinsic::localrecover);
1405  llvm::Constant *ParentI8Fn =
1406  llvm::ConstantExpr::getBitCast(ParentCGF.CurFn, Int8PtrTy);
1407  RecoverCall = Builder.CreateCall(
1408  FrameRecoverFn, {ParentI8Fn, ParentFP,
1409  llvm::ConstantInt::get(Int32Ty, FrameEscapeIdx)});
1410 
1411  } else {
1412  // If the parent didn't have an alloca, we're doing some nested outlining.
1413  // Just clone the existing localrecover call, but tweak the FP argument to
1414  // use our FP value. All other arguments are constants.
1415  auto *ParentRecover =
1416  cast<llvm::IntrinsicInst>(ParentVar->stripPointerCasts());
1417  assert(ParentRecover->getIntrinsicID() == llvm::Intrinsic::localrecover &&
1418  "expected alloca or localrecover in parent LocalDeclMap");
1419  RecoverCall = cast<llvm::CallInst>(ParentRecover->clone());
1420  RecoverCall->setArgOperand(1, ParentFP);
1421  RecoverCall->insertBefore(AllocaInsertPt);
1422  }
1423 
1424  // Bitcast the variable, rename it, and insert it in the local decl map.
1425  llvm::Value *ChildVar =
1426  Builder.CreateBitCast(RecoverCall, ParentVar->getType());
1427  ChildVar->setName(ParentVar->getName());
1428  return ChildVar;
1429 }
1430 
1432  const Stmt *OutlinedStmt,
1433  bool IsFilter) {
1434  // Find all captures in the Stmt.
1435  CaptureFinder Finder(ParentCGF, ParentCGF.CXXABIThisDecl);
1436  Finder.Visit(OutlinedStmt);
1437 
1438  // We can exit early on x86_64 when there are no captures. We just have to
1439  // save the exception code in filters so that __exception_code() works.
1440  if (!Finder.foundCaptures() &&
1441  CGM.getTarget().getTriple().getArch() != llvm::Triple::x86) {
1442  if (IsFilter)
1443  EmitSEHExceptionCodeSave(ParentCGF, nullptr, nullptr);
1444  return;
1445  }
1446 
1447  llvm::Value *EntryEBP = nullptr;
1448  llvm::Value *ParentFP;
1449  if (IsFilter && CGM.getTarget().getTriple().getArch() == llvm::Triple::x86) {
1450  // 32-bit SEH filters need to be careful about FP recovery. The end of the
1451  // EH registration is passed in as the EBP physical register. We can
1452  // recover that with llvm.frameaddress(1), and adjust that to recover the
1453  // parent's true frame pointer.
1455  EntryEBP = Builder.CreateCall(
1456  CGM.getIntrinsic(llvm::Intrinsic::frameaddress), {Builder.getInt32(1)});
1457  llvm::Function *RecoverFPIntrin =
1458  CGM.getIntrinsic(llvm::Intrinsic::x86_seh_recoverfp);
1459  llvm::Constant *ParentI8Fn =
1460  llvm::ConstantExpr::getBitCast(ParentCGF.CurFn, Int8PtrTy);
1461  ParentFP = Builder.CreateCall(RecoverFPIntrin, {ParentI8Fn, EntryEBP});
1462  } else {
1463  // Otherwise, for x64 and 32-bit finally functions, the parent FP is the
1464  // second parameter.
1465  auto AI = CurFn->arg_begin();
1466  ++AI;
1467  ParentFP = AI;
1468  }
1469 
1470  // Create llvm.localrecover calls for all captures.
1471  for (const VarDecl *VD : Finder.Captures) {
1472  if (isa<ImplicitParamDecl>(VD)) {
1473  CGM.ErrorUnsupported(VD, "'this' captured by SEH");
1474  CXXThisValue = llvm::UndefValue::get(ConvertTypeForMem(VD->getType()));
1475  continue;
1476  }
1477  if (VD->getType()->isVariablyModifiedType()) {
1478  CGM.ErrorUnsupported(VD, "VLA captured by SEH");
1479  continue;
1480  }
1481  assert((isa<ImplicitParamDecl>(VD) || VD->isLocalVarDeclOrParm()) &&
1482  "captured non-local variable");
1483 
1484  // If this decl hasn't been declared yet, it will be declared in the
1485  // OutlinedStmt.
1486  auto I = ParentCGF.LocalDeclMap.find(VD);
1487  if (I == ParentCGF.LocalDeclMap.end())
1488  continue;
1489  llvm::Value *ParentVar = I->second;
1490 
1491  LocalDeclMap[VD] =
1492  recoverAddrOfEscapedLocal(ParentCGF, ParentVar, ParentFP);
1493  }
1494 
1495  if (Finder.SEHCodeSlot) {
1496  SEHCodeSlotStack.push_back(
1497  recoverAddrOfEscapedLocal(ParentCGF, Finder.SEHCodeSlot, ParentFP));
1498  }
1499 
1500  if (IsFilter)
1501  EmitSEHExceptionCodeSave(ParentCGF, ParentFP, EntryEBP);
1502 }
1503 
1504 /// Arrange a function prototype that can be called by Windows exception
1505 /// handling personalities. On Win64, the prototype looks like:
1506 /// RetTy func(void *EHPtrs, void *ParentFP);
1508  bool IsFilter,
1509  const Stmt *OutlinedStmt) {
1510  SourceLocation StartLoc = OutlinedStmt->getLocStart();
1511 
1512  // Get the mangled function name.
1513  SmallString<128> Name;
1514  {
1515  llvm::raw_svector_ostream OS(Name);
1516  const Decl *ParentCodeDecl = ParentCGF.CurCodeDecl;
1517  const NamedDecl *Parent = dyn_cast_or_null<NamedDecl>(ParentCodeDecl);
1518  assert(Parent && "FIXME: handle unnamed decls (lambdas, blocks) with SEH");
1519  MangleContext &Mangler = CGM.getCXXABI().getMangleContext();
1520  if (IsFilter)
1521  Mangler.mangleSEHFilterExpression(Parent, OS);
1522  else
1523  Mangler.mangleSEHFinallyBlock(Parent, OS);
1524  }
1525 
1526  FunctionArgList Args;
1527  if (CGM.getTarget().getTriple().getArch() != llvm::Triple::x86 || !IsFilter) {
1528  // All SEH finally functions take two parameters. Win64 filters take two
1529  // parameters. Win32 filters take no parameters.
1530  if (IsFilter) {
1531  Args.push_back(ImplicitParamDecl::Create(
1532  getContext(), nullptr, StartLoc,
1533  &getContext().Idents.get("exception_pointers"),
1534  getContext().VoidPtrTy));
1535  } else {
1536  Args.push_back(ImplicitParamDecl::Create(
1537  getContext(), nullptr, StartLoc,
1538  &getContext().Idents.get("abnormal_termination"),
1540  }
1541  Args.push_back(ImplicitParamDecl::Create(
1542  getContext(), nullptr, StartLoc,
1543  &getContext().Idents.get("frame_pointer"), getContext().VoidPtrTy));
1544  }
1545 
1546  QualType RetTy = IsFilter ? getContext().LongTy : getContext().VoidTy;
1547 
1548  llvm::Function *ParentFn = ParentCGF.CurFn;
1550  RetTy, Args, FunctionType::ExtInfo(), /*isVariadic=*/false);
1551 
1552  llvm::FunctionType *FnTy = CGM.getTypes().GetFunctionType(FnInfo);
1553  llvm::Function *Fn = llvm::Function::Create(
1554  FnTy, llvm::GlobalValue::InternalLinkage, Name.str(), &CGM.getModule());
1555  // The filter is either in the same comdat as the function, or it's internal.
1556  if (llvm::Comdat *C = ParentFn->getComdat()) {
1557  Fn->setComdat(C);
1558  } else if (ParentFn->hasWeakLinkage() || ParentFn->hasLinkOnceLinkage()) {
1559  llvm::Comdat *C = CGM.getModule().getOrInsertComdat(ParentFn->getName());
1560  ParentFn->setComdat(C);
1561  Fn->setComdat(C);
1562  } else {
1563  Fn->setLinkage(llvm::GlobalValue::InternalLinkage);
1564  }
1565 
1566  IsOutlinedSEHHelper = true;
1567 
1568  StartFunction(GlobalDecl(), RetTy, Fn, FnInfo, Args,
1569  OutlinedStmt->getLocStart(), OutlinedStmt->getLocStart());
1570 
1571  CGM.SetLLVMFunctionAttributes(nullptr, FnInfo, CurFn);
1572  EmitCapturedLocals(ParentCGF, OutlinedStmt, IsFilter);
1573 }
1574 
1575 /// Create a stub filter function that will ultimately hold the code of the
1576 /// filter expression. The EH preparation passes in LLVM will outline the code
1577 /// from the main function body into this stub.
1578 llvm::Function *
1580  const SEHExceptStmt &Except) {
1581  const Expr *FilterExpr = Except.getFilterExpr();
1582  startOutlinedSEHHelper(ParentCGF, true, FilterExpr);
1583 
1584  // Emit the original filter expression, convert to i32, and return.
1585  llvm::Value *R = EmitScalarExpr(FilterExpr);
1586  R = Builder.CreateIntCast(R, ConvertType(getContext().LongTy),
1587  FilterExpr->getType()->isSignedIntegerType());
1588  Builder.CreateStore(R, ReturnValue);
1589 
1590  FinishFunction(FilterExpr->getLocEnd());
1591 
1592  return CurFn;
1593 }
1594 
1595 llvm::Function *
1597  const SEHFinallyStmt &Finally) {
1598  const Stmt *FinallyBlock = Finally.getBlock();
1599  startOutlinedSEHHelper(ParentCGF, false, FinallyBlock);
1600 
1601  // Mark finally block calls as nounwind and noinline to make LLVM's job a
1602  // little easier.
1603  // FIXME: Remove these restrictions in the future.
1604  CurFn->addFnAttr(llvm::Attribute::NoUnwind);
1605  CurFn->addFnAttr(llvm::Attribute::NoInline);
1606 
1607  // Emit the original filter expression, convert to i32, and return.
1608  EmitStmt(FinallyBlock);
1609 
1610  FinishFunction(FinallyBlock->getLocEnd());
1611 
1612  return CurFn;
1613 }
1614 
1616  llvm::Value *ParentFP,
1617  llvm::Value *EntryEBP) {
1618  // Get the pointer to the EXCEPTION_POINTERS struct. This is returned by the
1619  // __exception_info intrinsic.
1620  if (CGM.getTarget().getTriple().getArch() != llvm::Triple::x86) {
1621  // On Win64, the info is passed as the first parameter to the filter.
1622  auto AI = CurFn->arg_begin();
1623  SEHInfo = AI;
1624  SEHCodeSlotStack.push_back(
1625  CreateMemTemp(getContext().IntTy, "__exception_code"));
1626  } else {
1627  // On Win32, the EBP on entry to the filter points to the end of an
1628  // exception registration object. It contains 6 32-bit fields, and the info
1629  // pointer is stored in the second field. So, GEP 20 bytes backwards and
1630  // load the pointer.
1631  SEHInfo = Builder.CreateConstInBoundsGEP1_32(Int8Ty, EntryEBP, -20);
1632  SEHInfo = Builder.CreateBitCast(SEHInfo, Int8PtrTy->getPointerTo());
1633  SEHInfo = Builder.CreateLoad(Int8PtrTy, SEHInfo);
1635  ParentCGF, ParentCGF.SEHCodeSlotStack.back(), ParentFP));
1636  }
1637 
1638  // Save the exception code in the exception slot to unify exception access in
1639  // the filter function and the landing pad.
1640  // struct EXCEPTION_POINTERS {
1641  // EXCEPTION_RECORD *ExceptionRecord;
1642  // CONTEXT *ContextRecord;
1643  // };
1644  // int exceptioncode = exception_pointers->ExceptionRecord->ExceptionCode;
1645  llvm::Type *RecordTy = CGM.Int32Ty->getPointerTo();
1646  llvm::Type *PtrsTy = llvm::StructType::get(RecordTy, CGM.VoidPtrTy, nullptr);
1647  llvm::Value *Ptrs = Builder.CreateBitCast(SEHInfo, PtrsTy->getPointerTo());
1648  llvm::Value *Rec = Builder.CreateStructGEP(PtrsTy, Ptrs, 0);
1649  Rec = Builder.CreateLoad(Rec);
1650  llvm::Value *Code = Builder.CreateLoad(Rec);
1651  assert(!SEHCodeSlotStack.empty() && "emitting EH code outside of __except");
1652  Builder.CreateStore(Code, SEHCodeSlotStack.back());
1653 }
1654 
1656  // Sema should diagnose calling this builtin outside of a filter context, but
1657  // don't crash if we screw up.
1658  if (!SEHInfo)
1659  return llvm::UndefValue::get(Int8PtrTy);
1660  assert(SEHInfo->getType() == Int8PtrTy);
1661  return SEHInfo;
1662 }
1663 
1665  assert(!SEHCodeSlotStack.empty() && "emitting EH code outside of __except");
1666  return Builder.CreateLoad(Int32Ty, SEHCodeSlotStack.back());
1667 }
1668 
1670  // Abnormal termination is just the first parameter to the outlined finally
1671  // helper.
1672  auto AI = CurFn->arg_begin();
1673  return Builder.CreateZExt(&*AI, Int32Ty);
1674 }
1675 
1677  CodeGenFunction HelperCGF(CGM, /*suppressNewContext=*/true);
1678  if (const SEHFinallyStmt *Finally = S.getFinallyHandler()) {
1679  // Outline the finally block.
1680  llvm::Function *FinallyFunc =
1681  HelperCGF.GenerateSEHFinallyFunction(*this, *Finally);
1682 
1683  // Push a cleanup for __finally blocks.
1684  EHStack.pushCleanup<PerformSEHFinally>(NormalAndEHCleanup, FinallyFunc);
1685  return;
1686  }
1687 
1688  // Otherwise, we must have an __except block.
1689  const SEHExceptStmt *Except = S.getExceptHandler();
1690  assert(Except);
1691  EHCatchScope *CatchScope = EHStack.pushCatch(1);
1692  SEHCodeSlotStack.push_back(
1693  CreateMemTemp(getContext().IntTy, "__exception_code"));
1694 
1695  // If the filter is known to evaluate to 1, then we can use the clause
1696  // "catch i8* null". We can't do this on x86 because the filter has to save
1697  // the exception code.
1698  llvm::Constant *C =
1699  CGM.EmitConstantExpr(Except->getFilterExpr(), getContext().IntTy, this);
1700  if (CGM.getTarget().getTriple().getArch() != llvm::Triple::x86 && C &&
1701  C->isOneValue()) {
1702  CatchScope->setCatchAllHandler(0, createBasicBlock("__except"));
1703  return;
1704  }
1705 
1706  // In general, we have to emit an outlined filter function. Use the function
1707  // in place of the RTTI typeinfo global that C++ EH uses.
1708  llvm::Function *FilterFunc =
1709  HelperCGF.GenerateSEHFilterFunction(*this, *Except);
1710  llvm::Constant *OpaqueFunc =
1711  llvm::ConstantExpr::getBitCast(FilterFunc, Int8PtrTy);
1712  CatchScope->setHandler(0, OpaqueFunc, createBasicBlock("__except"));
1713 }
1714 
1716  // Just pop the cleanup if it's a __finally block.
1717  if (S.getFinallyHandler()) {
1718  PopCleanupBlock();
1719  return;
1720  }
1721 
1722  // Otherwise, we must have an __except block.
1723  const SEHExceptStmt *Except = S.getExceptHandler();
1724  assert(Except && "__try must have __finally xor __except");
1725  EHCatchScope &CatchScope = cast<EHCatchScope>(*EHStack.begin());
1726 
1727  // Don't emit the __except block if the __try block lacked invokes.
1728  // TODO: Model unwind edges from instructions, either with iload / istore or
1729  // a try body function.
1730  if (!CatchScope.hasEHBranches()) {
1731  CatchScope.clearHandlerBlocks();
1732  EHStack.popCatch();
1733  SEHCodeSlotStack.pop_back();
1734  return;
1735  }
1736 
1737  // The fall-through block.
1738  llvm::BasicBlock *ContBB = createBasicBlock("__try.cont");
1739 
1740  // We just emitted the body of the __try; jump to the continue block.
1741  if (HaveInsertPoint())
1742  Builder.CreateBr(ContBB);
1743 
1744  // Check if our filter function returned true.
1745  emitCatchDispatchBlock(*this, CatchScope);
1746 
1747  // Grab the block before we pop the handler.
1748  llvm::BasicBlock *ExceptBB = CatchScope.getHandler(0).Block;
1749  EHStack.popCatch();
1750 
1751  EmitBlockAfterUses(ExceptBB);
1752 
1753  // On Win64, the exception pointer is the exception code. Copy it to the slot.
1754  if (CGM.getTarget().getTriple().getArch() != llvm::Triple::x86) {
1755  llvm::Value *Code =
1756  Builder.CreatePtrToInt(getExceptionFromSlot(), IntPtrTy);
1757  Code = Builder.CreateTrunc(Code, Int32Ty);
1758  Builder.CreateStore(Code, SEHCodeSlotStack.back());
1759  }
1760 
1761  // Emit the __except body.
1762  EmitStmt(Except->getBlock());
1763 
1764  // End the lifetime of the exception code.
1765  SEHCodeSlotStack.pop_back();
1766 
1767  if (HaveInsertPoint())
1768  Builder.CreateBr(ContBB);
1769 
1770  EmitBlock(ContBB);
1771 }
1772 
1774  // If this code is reachable then emit a stop point (if generating
1775  // debug info). We have to do this ourselves because we are on the
1776  // "simple" statement path.
1777  if (HaveInsertPoint())
1778  EmitStopPoint(&S);
1779 
1780  // This must be a __leave from a __finally block, which we warn on and is UB.
1781  // Just emit unreachable.
1782  if (!isSEHTryScope()) {
1783  Builder.CreateUnreachable();
1784  Builder.ClearInsertionPoint();
1785  return;
1786  }
1787 
1789 }
virtual void mangleSEHFilterExpression(const NamedDecl *EnclosingDecl, raw_ostream &Out)=0
void pushTerminate()
Push a terminate handler on the stack.
Definition: CGCleanup.cpp:240
QualType getExceptionType(unsigned i) const
Definition: Type.h:3194
iterator end() const
Returns an iterator pointing to the outermost EH scope.
Definition: CGCleanup.h:522
llvm::IntegerType * IntTy
int
virtual void emitThrow(CodeGenFunction &CGF, const CXXThrowExpr *E)=0
void setCatchAllHandler(unsigned I, llvm::BasicBlock *Block)
Definition: CGCleanup.h:185
CanQualType VoidPtrTy
Definition: ASTContext.h:831
void EmitSEHLeaveStmt(const SEHLeaveStmt &S)
llvm::Type * ConvertTypeForMem(QualType T)
Represents a version number in the form major[.minor[.subminor[.build]]].
Definition: VersionTuple.h:26
void EmitAnyExprToExn(const Expr *E, llvm::Value *Addr)
llvm::Module & getModule() const
void EmitCXXTryStmt(const CXXTryStmt &S)
CXXCatchStmt * getHandler(unsigned i)
Definition: StmtCXX.h:104
const TargetInfo & getTarget() const
llvm::Value * getFilter(unsigned i) const
Definition: CGCleanup.h:434
static stable_iterator stable_end()
Create a stable reference to the bottom of the EH stack.
Definition: EHScopeStack.h:369
llvm::AllocaInst * CreateTempAlloca(llvm::Type *Ty, const Twine &Name="tmp")
Definition: CGExpr.cpp:57
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
virtual void mangleSEHFinallyBlock(const NamedDecl *EnclosingDecl, raw_ostream &Out)=0
Represents Objective-C's @throw statement.
Definition: StmtObjC.h:313
CanQualType LongTy
Definition: ASTContext.h:825
static llvm::Constant * getUnexpectedFn(CodeGenModule &CGM)
Definition: CGException.cpp:41
void EmitSEHExceptionCodeSave(CodeGenFunction &ParentCGF, llvm::Value *ParentFP, llvm::Value *EntryEBP)
static llvm::Constant * getPersonalityFn(CodeGenModule &CGM, const EHPersonality &Personality)
const LangOptions & getLangOpts() const
const CGFunctionInfo & arrangeFreeFunctionDeclaration(QualType ResTy, const FunctionArgList &Args, const FunctionType::ExtInfo &Info, bool isVariadic)
Definition: CGCall.cpp:460
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
CompoundStmt * getBlock() const
Definition: Stmt.h:1895
ExtProtoInfo - Extra information about a function prototype.
Definition: Type.h:3042
llvm::BasicBlock * EmitLandingPad()
Emits a landing pad for the current EH stack.
A protected scope for zero-cost EH handling.
Definition: CGCleanup.h:32
Defines the Objective-C statement AST node classes.
llvm::BasicBlock * getCachedEHDispatchBlock() const
Definition: CGCleanup.h:117
A C++ throw-expression (C++ [except.throw]).
Definition: ExprCXX.h:808
llvm::Constant * getAddrOfCXXCatchHandlerType(QualType Ty, QualType CatchHandlerType)
static bool useLibGCCSEHPersonality(const llvm::Triple &T)
bool isNoexceptExceptionSpec(ExceptionSpecificationType ESpecType)
llvm::Value * getNormalCleanupDestSlot()
Definition: CGCleanup.cpp:1157
llvm::BasicBlock * getTerminateHandler()
Kind getKind() const
Definition: CGCleanup.h:107
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: Type.h:1742
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:89
llvm::CallInst * EmitRuntimeCall(llvm::Value *callee, const Twine &name="")
llvm::Value * SEHInfo
Value returned by __exception_info intrinsic.
bool hasEHBranches() const
Definition: CGCleanup.h:125
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:48
Expr * getFilterExpr() const
Definition: Stmt.h:1855
void setFilter(unsigned i, llvm::Value *filterValue)
Definition: CGCleanup.h:429
class EHCatchScope * pushCatch(unsigned NumHandlers)
Definition: CGCleanup.cpp:232
const Handler & getHandler(unsigned I) const
Definition: CGCleanup.h:195
iterator begin() const
Returns an iterator pointing to the innermost EH scope.
Definition: CGCleanup.h:518
RValue EmitCall(const CGFunctionInfo &FnInfo, llvm::Value *Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, const Decl *TargetDecl=nullptr, llvm::Instruction **callOrInvoke=nullptr)
Definition: CGCall.cpp:3106
static llvm::Constant * getFreeExceptionFn(CodeGenModule &CGM)
Definition: CGException.cpp:32
bool isLocalVarDeclOrParm() const
Similar to isLocalVarDecl but also includes parameters.
Definition: Decl.h:960
static llvm::Constant * getCatchAllValue(CodeGenFunction &CGF)
void ExitSEHTryStmt(const SEHTryStmt &S)
Stmt * getHandlerBlock() const
Definition: StmtCXX.h:52
llvm::Constant * getTerminateFn()
Get the declaration of std::terminate for the platform.
Definition: CGException.cpp:50
static OMPLinearClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr * > VL, ArrayRef< Expr * > IL, Expr *Step, Expr *CalcStep)
Creates clause with a list of variables VL and a linear step Step.
void incrementProfileCounter(const Stmt *S)
Increment the profiler's counter for the given statement.
llvm::BasicBlock * getInvokeDestImpl()
llvm::Function * GenerateSEHFinallyFunction(CodeGenFunction &ParentCGF, const SEHFinallyStmt &Finally)
void EmitStmt(const Stmt *S)
Definition: CGStmt.cpp:45
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
void popFilter()
Pops an exceptions filter off the stack.
Definition: CGCleanup.cpp:223
unsigned getBuiltinCallee() const
Definition: Expr.cpp:1219
This represents the body of a CapturedStmt, and serves as its DeclContext.
Definition: Decl.h:3616
CanQualType UnsignedCharTy
Definition: ASTContext.h:826
QualType getType() const
Definition: Decl.h:538
Represents the this expression in C++.
Definition: ExprCXX.h:770
iterator find(stable_iterator save) const
Definition: CGCleanup.h:542
llvm::CallSite EmitRuntimeCallOrInvoke(llvm::Value *callee, ArrayRef< llvm::Value * > args, const Twine &name="")
Emits a call or invoke instruction to the given runtime function.
Definition: CGCall.cpp:3052
bool hasTerminate() const
Does this runtime provide an objc_terminate function?
Definition: ObjCRuntime.h:243
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
Definition: Type.h:3166
llvm::CallInst * EmitNounwindRuntimeCall(llvm::Value *callee, const Twine &name="")
static llvm::Constant * getOpaquePersonalityFn(CodeGenModule &CGM, const EHPersonality &Personality)
const TargetInfo & getTarget() const
ASTContext * Context
bool usesSEHTry() const
Whether this is a (C++11) constexpr function or constexpr constructor.
Definition: Decl.h:1839
ID
Defines the set of possible language-specific address spaces.
Definition: AddressSpaces.h:27
iterator begin() const
Definition: CGCleanup.h:210
CGObjCRuntime & getObjCRuntime()
Return a reference to the configured Objective-C runtime.
void SetLLVMFunctionAttributes(const Decl *D, const CGFunctionInfo &Info, llvm::Function *F)
Set the LLVM function attributes (sext, zext, etc).
bool isNeXTFamily() const
Is this runtime basically of the NeXT family of runtimes?
Definition: ObjCRuntime.h:127
llvm::BasicBlock * EHResumeBlock
EHResumeBlock - Unified block containing a call to llvm.eh.resume.
bool empty() const
Determines whether the exception-scopes stack is empty.
Definition: EHScopeStack.h:327
void EmitCapturedLocals(CodeGenFunction &ParentCGF, const Stmt *OutlinedStmt, bool IsFilter)
void enter(CodeGenFunction &CGF, const Stmt *Finally, llvm::Constant *beginCatchFn, llvm::Constant *endCatchFn, llvm::Constant *rethrowFn)
static bool PersonalityHasOnlyCXXUses(llvm::Constant *Fn)
CGCXXABI & getCXXABI() const
Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited...
llvm::Function * GenerateSEHFilterFunction(CodeGenFunction &ParentCGF, const SEHExceptStmt &Except)
virtual void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S, bool ClearInsertionPoint=true)=0
void EmitSEHTryStmt(const SEHTryStmt &S)
ASTContext & getContext() const
llvm::BasicBlock * getBlock() const
llvm::BasicBlock * Block
The catch handler for this type.
Definition: CGCleanup.h:154
void add(RValue rvalue, QualType type, bool needscopy=false)
Definition: CGCall.h:81
llvm::Value * getExceptionFromSlot()
static void emitCatchDispatchBlock(CodeGenFunction &CGF, EHCatchScope &catchScope)
EHScopeStack::stable_iterator getEnclosingEHScope() const
Definition: CGCleanup.h:131
stable_iterator stable_begin() const
Definition: EHScopeStack.h:364
llvm::BasicBlock * getCachedLandingPad() const
Definition: CGCleanup.h:109
static const EHPersonality & getObjCXXPersonality(const llvm::Triple &T, const LangOptions &L)
clang::ObjCRuntime ObjCRuntime
Definition: LangOptions.h:85
llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type * > Tys=None)
SmallVector< llvm::Value *, 1 > SEHCodeSlotStack
ValueDecl * getDecl()
Definition: Expr.h:994
'gnustep' is the modern non-fragile GNUstep runtime.
Definition: ObjCRuntime.h:49
llvm::IRBuilder< PreserveNames, llvm::ConstantFolder, CGBuilderInserterTy > CGBuilderTy
Definition: CGBuilder.h:49
void popCatch()
Pops a catch scope off the stack. This is private to CGException.cpp.
Definition: CGCleanup.h:526
void EmitAnyExprToMem(const Expr *E, llvm::Value *Location, Qualifiers Quals, bool IsInitializer)
Definition: CGExpr.cpp:148
llvm::BasicBlock * getEHDispatchBlock(EHScopeStack::stable_iterator scope)
static void emitFilterDispatchBlock(CodeGenFunction &CGF, EHFilterScope &filterScope)
Emit the dispatch block for a filter scope if necessary.
ASTMatchFinder *const Finder
Enumerates target-specific builtins in their own namespaces within namespace clang.
virtual void emitRethrow(CodeGenFunction &CGF, bool isNoReturn)=0
llvm::Constant * CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeSet ExtraAttrs=llvm::AttributeSet())
Create a new runtime function with the specified type and name.
static const EHPersonality & getObjCPersonality(const llvm::Triple &T, const LangOptions &L)
llvm::Constant * EmitConstantExpr(const Expr *E, QualType DestType, CodeGenFunction *CGF=nullptr)
ASTContext & getContext() const
Encodes a location in the source. The SourceManager can decode this to get at the full include stack...
'objfw' is the Objective-C runtime included in ObjFW
Definition: ObjCRuntime.h:52
llvm::BasicBlock * getUnreachableBlock()
bool refersToEnclosingVariableOrCapture() const
Does this DeclRefExpr refer to an enclosing local or a captured variable?
Definition: Expr.h:1158
void DeactivateCleanupBlock(EHScopeStack::stable_iterator Cleanup, llvm::Instruction *DominatingIP)
Deactive a cleanup that was created in an active state.
Definition: CGCleanup.cpp:1135
CompoundStmt * getBlock() const
Definition: Stmt.h:1859
The noexcept specifier evaluates to true.
Definition: Type.h:3189
llvm::Constant * GetAddrOfRTTIDescriptor(QualType Ty, bool ForEH=false)
Get the address of the RTTI descriptor for the given type.
CanQualType VoidTy
Definition: ASTContext.h:817
void StartFunction(GlobalDecl GD, QualType RetTy, llvm::Function *Fn, const CGFunctionInfo &FnInfo, const FunctionArgList &Args, SourceLocation Loc=SourceLocation(), SourceLocation StartLoc=SourceLocation())
Emit code for the start of a function.
const LangOptions & getLangOpts() const
llvm::BasicBlock * getEHResumeBlock(bool isCleanup)
llvm::AllocaInst * CreateMemTemp(QualType T, const Twine &Name="tmp")
Definition: CGExpr.cpp:80
SEHExceptStmt * getExceptHandler() const
Returns 0 if not defined.
Definition: Stmt.cpp:1038
const VersionTuple & getVersion() const
Definition: ObjCRuntime.h:72
NoexceptResult getNoexceptSpec(const ASTContext &Ctx) const
Get the meaning of the noexcept spec on this function, if any.
Definition: Type.cpp:2657
void setCachedEHDispatchBlock(llvm::BasicBlock *block)
Definition: CGCleanup.h:121
MangleContext & getMangleContext()
Gets the mangle context.
Definition: CGCXXABI.h:85
JumpDest getJumpDestInCurrentScope(llvm::BasicBlock *Target)
void EmitStartEHSpec(const Decl *D)
EmitStartEHSpec - Emit the start of the exception spec.
unsigned getNumHandlers() const
Definition: CGCleanup.h:181
llvm::Value * recoverAddrOfEscapedLocal(CodeGenFunction &ParentCGF, llvm::Value *ParentVar, llvm::Value *ParentFP)
void FinishFunction(SourceLocation EndLoc=SourceLocation())
static const EHPersonality & getCXXPersonality(const llvm::Triple &T, const LangOptions &L)
SourceLocation getExprLoc() const LLVM_READONLY
Definition: Expr.cpp:193
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
QualType getType() const
Definition: Expr.h:125
void ErrorUnsupported(const Stmt *S, const char *Type)
Print out an error that codegen doesn't support the specified stmt yet.
class EHFilterScope * pushFilter(unsigned NumFilters)
Push an exceptions filter on the stack.
Definition: CGCleanup.cpp:215
const Expr * getSubExpr() const
Definition: ExprCXX.h:828
static const Type * getElementType(const Expr *BaseExpr)
static ApplyDebugLocation CreateDefaultArtificial(CodeGenFunction &CGF, SourceLocation TemporaryLocation)
Apply TemporaryLocation if it is valid. Otherwise switch to an artificial debug location that has a v...
Definition: CGDebugInfo.h:532
The basic abstraction for the target Objective-C runtime.
Definition: ObjCRuntime.h:25
static bool isNonEHScope(const EHScope &S)
unsigned getNumHandlers() const
Definition: StmtCXX.h:103
QualType getCaughtType() const
Definition: Stmt.cpp:678
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
bool isSEHTryScope() const
Returns true inside SEH __try blocks.
const llvm::Triple & getTriple() const
QualType getNonReferenceType() const
Definition: Type.h:5182
const T * getAs() const
Definition: Type.h:5555
static ImplicitParamDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id, QualType T)
Definition: Decl.cpp:3850
llvm::AssertingVH< llvm::Instruction > AllocaInsertPt
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition: Linkage.h:33
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
Definition: CGStmt.cpp:348
void EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock=false)
void EmitStopPoint(const Stmt *S)
EmitStopPoint - Emit a debug stoppoint if we are emitting debug info.
Definition: CGStmt.cpp:35
Kind getKind() const
Definition: ObjCRuntime.h:71
static const EHPersonality & getSEHPersonalityMSVC(const llvm::Triple &T)
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:5096
bool isObjCObjectPointerType() const
Definition: Type.h:5304
llvm::BasicBlock * getTerminateLandingPad()
getTerminateLandingPad - Return a landing pad that just calls terminate.
llvm::Type * ConvertType(QualType T)
static const EHPersonality & getCPersonality(const llvm::Triple &T, const LangOptions &L)
void popTerminate()
Pops a terminate handler off the stack.
Definition: CGCleanup.h:534
CompoundStmt * getTryBlock()
Definition: StmtCXX.h:96
llvm::Value * EmitSEHAbnormalTermination()
virtual llvm::CallInst * emitTerminateForUnexpectedException(CodeGenFunction &CGF, llvm::Value *Exn)
Definition: CGCXXABI.cpp:306
void ForceCleanup()
Force the emission of cleanups now, instead of waiting until this object is destroyed.
void EnterSEHTryStmt(const SEHTryStmt &S)
void startOutlinedSEHHelper(CodeGenFunction &ParentCGF, bool IsFilter, const Stmt *OutlinedStmt)
unsigned getNumFilters() const
Definition: CGCleanup.h:427
stable_iterator getInnermostEHScope() const
Definition: EHScopeStack.h:345
CanQualType IntTy
Definition: ASTContext.h:825
VarDecl * getExceptionDecl() const
Definition: StmtCXX.h:50
A reference to a declared variable, function, enum, etc. [C99 6.5.1p2].
Definition: Expr.h:899
static RValue get(llvm::Value *V)
Definition: CGValue.h:71
void ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock=false)
const CGFunctionInfo & arrangeFreeFunctionCall(const CallArgList &Args, const FunctionType *Ty, bool ChainCall)
Definition: CGCall.cpp:414
void EmitBranchThroughCleanup(JumpDest Dest)
Definition: CGCleanup.cpp:940
void EmitEndEHSpec(const Decl *D)
EmitEndEHSpec - Emit the end of the exception spec.
virtual void emitBeginCatch(CodeGenFunction &CGF, const CXXCatchStmt *C)=0
static llvm::Constant * getCatchallRethrowFn(CodeGenModule &CGM, StringRef Name)
Definition: CGException.cpp:76
CompoundStmt * getTryBlock() const
Definition: Stmt.h:1936
A non-stable pointer into the scope stack.
Definition: CGCleanup.h:458
bool isSignedIntegerType() const
Definition: Type.cpp:1683
void EmitBlockAfterUses(llvm::BasicBlock *BB)
Definition: CGStmt.cpp:385
virtual llvm::Constant * GetEHType(QualType T)=0
bool requiresLandingPad() const
Definition: EHScopeStack.h:329
void PopCleanupBlock(bool FallThroughIsBranchThrough=false)
Definition: CGCleanup.cpp:583
void setHandler(unsigned I, llvm::Constant *Type, llvm::BasicBlock *Block)
Definition: CGCleanup.h:189
void EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint=true)
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals)
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals...
llvm::SmallVector< const JumpDest *, 2 > SEHTryEpilogueStack
SEHFinallyStmt * getFinallyHandler() const
Definition: Stmt.cpp:1042
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5043
unsigned getNumExceptions() const
Definition: Type.h:3193
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
Definition: CGCall.cpp:1253