clang  11.0.0git
CGException.cpp
Go to the documentation of this file.
1 //===--- CGException.cpp - Emit LLVM Code for C++ exceptions ----*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This contains code dealing with C++ exception related code generation.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "CGCXXABI.h"
14 #include "CGCleanup.h"
15 #include "CGObjCRuntime.h"
16 #include "CodeGenFunction.h"
17 #include "ConstantEmitter.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"
25 #include "llvm/IR/IntrinsicInst.h"
26 #include "llvm/IR/Intrinsics.h"
27 #include "llvm/IR/IntrinsicsWebAssembly.h"
28 #include "llvm/Support/SaveAndRestore.h"
29 
30 using namespace clang;
31 using namespace CodeGen;
32 
33 static llvm::FunctionCallee getFreeExceptionFn(CodeGenModule &CGM) {
34  // void __cxa_free_exception(void *thrown_exception);
35 
36  llvm::FunctionType *FTy =
37  llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*isVarArg=*/false);
38 
39  return CGM.CreateRuntimeFunction(FTy, "__cxa_free_exception");
40 }
41 
42 static llvm::FunctionCallee getUnexpectedFn(CodeGenModule &CGM) {
43  // void __cxa_call_unexpected(void *thrown_exception);
44 
45  llvm::FunctionType *FTy =
46  llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*isVarArg=*/false);
47 
48  return CGM.CreateRuntimeFunction(FTy, "__cxa_call_unexpected");
49 }
50 
51 llvm::FunctionCallee CodeGenModule::getTerminateFn() {
52  // void __terminate();
53 
54  llvm::FunctionType *FTy =
55  llvm::FunctionType::get(VoidTy, /*isVarArg=*/false);
56 
57  StringRef name;
58 
59  // In C++, use std::terminate().
60  if (getLangOpts().CPlusPlus &&
61  getTarget().getCXXABI().isItaniumFamily()) {
62  name = "_ZSt9terminatev";
63  } else if (getLangOpts().CPlusPlus &&
64  getTarget().getCXXABI().isMicrosoft()) {
65  if (getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015))
66  name = "__std_terminate";
67  else
68  name = "?terminate@@YAXXZ";
69  } else if (getLangOpts().ObjC &&
71  name = "objc_terminate";
72  else
73  name = "abort";
74  return CreateRuntimeFunction(FTy, name);
75 }
76 
77 static llvm::FunctionCallee getCatchallRethrowFn(CodeGenModule &CGM,
78  StringRef Name) {
79  llvm::FunctionType *FTy =
80  llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*isVarArg=*/false);
81 
82  return CGM.CreateRuntimeFunction(FTy, Name);
83 }
84 
85 const EHPersonality EHPersonality::GNU_C = { "__gcc_personality_v0", nullptr };
86 const EHPersonality
87 EHPersonality::GNU_C_SJLJ = { "__gcc_personality_sj0", nullptr };
88 const EHPersonality
89 EHPersonality::GNU_C_SEH = { "__gcc_personality_seh0", nullptr };
90 const EHPersonality
91 EHPersonality::NeXT_ObjC = { "__objc_personality_v0", nullptr };
92 const EHPersonality
93 EHPersonality::GNU_CPlusPlus = { "__gxx_personality_v0", nullptr };
94 const EHPersonality
95 EHPersonality::GNU_CPlusPlus_SJLJ = { "__gxx_personality_sj0", nullptr };
96 const EHPersonality
97 EHPersonality::GNU_CPlusPlus_SEH = { "__gxx_personality_seh0", nullptr };
98 const EHPersonality
99 EHPersonality::GNU_ObjC = {"__gnu_objc_personality_v0", "objc_exception_throw"};
100 const EHPersonality
101 EHPersonality::GNU_ObjC_SJLJ = {"__gnu_objc_personality_sj0", "objc_exception_throw"};
102 const EHPersonality
103 EHPersonality::GNU_ObjC_SEH = {"__gnu_objc_personality_seh0", "objc_exception_throw"};
104 const EHPersonality
105 EHPersonality::GNU_ObjCXX = { "__gnustep_objcxx_personality_v0", nullptr };
106 const EHPersonality
107 EHPersonality::GNUstep_ObjC = { "__gnustep_objc_personality_v0", nullptr };
108 const EHPersonality
109 EHPersonality::MSVC_except_handler = { "_except_handler3", nullptr };
110 const EHPersonality
111 EHPersonality::MSVC_C_specific_handler = { "__C_specific_handler", nullptr };
112 const EHPersonality
113 EHPersonality::MSVC_CxxFrameHandler3 = { "__CxxFrameHandler3", nullptr };
114 const EHPersonality
115 EHPersonality::GNU_Wasm_CPlusPlus = { "__gxx_wasm_personality_v0", nullptr };
116 
117 static const EHPersonality &getCPersonality(const TargetInfo &Target,
118  const LangOptions &L) {
119  const llvm::Triple &T = Target.getTriple();
120  if (T.isWindowsMSVCEnvironment())
121  return EHPersonality::MSVC_CxxFrameHandler3;
122  if (L.SjLjExceptions)
124  if (L.DWARFExceptions)
125  return EHPersonality::GNU_C;
126  if (L.SEHExceptions)
128  return EHPersonality::GNU_C;
129 }
130 
131 static const EHPersonality &getObjCPersonality(const TargetInfo &Target,
132  const LangOptions &L) {
133  const llvm::Triple &T = Target.getTriple();
134  if (T.isWindowsMSVCEnvironment())
135  return EHPersonality::MSVC_CxxFrameHandler3;
136 
137  switch (L.ObjCRuntime.getKind()) {
139  return getCPersonality(Target, L);
140  case ObjCRuntime::MacOSX:
141  case ObjCRuntime::iOS:
145  if (L.ObjCRuntime.getVersion() >= VersionTuple(1, 7))
146  return EHPersonality::GNUstep_ObjC;
147  LLVM_FALLTHROUGH;
148  case ObjCRuntime::GCC:
149  case ObjCRuntime::ObjFW:
150  if (L.SjLjExceptions)
152  if (L.SEHExceptions)
155  }
156  llvm_unreachable("bad runtime kind");
157 }
158 
159 static const EHPersonality &getCXXPersonality(const TargetInfo &Target,
160  const LangOptions &L) {
161  const llvm::Triple &T = Target.getTriple();
162  if (T.isWindowsMSVCEnvironment())
163  return EHPersonality::MSVC_CxxFrameHandler3;
164  if (L.SjLjExceptions)
166  if (L.DWARFExceptions)
168  if (L.SEHExceptions)
170  if (L.WasmExceptions)
173 }
174 
175 /// Determines the personality function to use when both C++
176 /// and Objective-C exceptions are being caught.
177 static const EHPersonality &getObjCXXPersonality(const TargetInfo &Target,
178  const LangOptions &L) {
179  if (Target.getTriple().isWindowsMSVCEnvironment())
180  return EHPersonality::MSVC_CxxFrameHandler3;
181 
182  switch (L.ObjCRuntime.getKind()) {
183  // In the fragile ABI, just use C++ exception handling and hope
184  // they're not doing crazy exception mixing.
186  return getCXXPersonality(Target, L);
187 
188  // The ObjC personality defers to the C++ personality for non-ObjC
189  // handlers. Unlike the C++ case, we use the same personality
190  // function on targets using (backend-driven) SJLJ EH.
191  case ObjCRuntime::MacOSX:
192  case ObjCRuntime::iOS:
194  return getObjCPersonality(Target, L);
195 
198 
199  // The GCC runtime's personality function inherently doesn't support
200  // mixed EH. Use the ObjC personality just to avoid returning null.
201  case ObjCRuntime::GCC:
202  case ObjCRuntime::ObjFW:
203  return getObjCPersonality(Target, L);
204  }
205  llvm_unreachable("bad runtime kind");
206 }
207 
208 static const EHPersonality &getSEHPersonalityMSVC(const llvm::Triple &T) {
209  if (T.getArch() == llvm::Triple::x86)
210  return EHPersonality::MSVC_except_handler;
212 }
213 
215  const FunctionDecl *FD) {
216  const llvm::Triple &T = CGM.getTarget().getTriple();
217  const LangOptions &L = CGM.getLangOpts();
218  const TargetInfo &Target = CGM.getTarget();
219 
220  // Functions using SEH get an SEH personality.
221  if (FD && FD->usesSEHTry())
222  return getSEHPersonalityMSVC(T);
223 
224  if (L.ObjC)
225  return L.CPlusPlus ? getObjCXXPersonality(Target, L)
226  : getObjCPersonality(Target, L);
227  return L.CPlusPlus ? getCXXPersonality(Target, L)
228  : getCPersonality(Target, L);
229 }
230 
232  const auto *FD = CGF.CurCodeDecl;
233  // For outlined finallys and filters, use the SEH personality in case they
234  // contain more SEH. This mostly only affects finallys. Filters could
235  // hypothetically use gnu statement expressions to sneak in nested SEH.
236  FD = FD ? FD : CGF.CurSEHParent;
237  return get(CGF.CGM, dyn_cast_or_null<FunctionDecl>(FD));
238 }
239 
240 static llvm::FunctionCallee getPersonalityFn(CodeGenModule &CGM,
241  const EHPersonality &Personality) {
242  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.Int32Ty, true),
243  Personality.PersonalityFn,
244  llvm::AttributeList(), /*Local=*/true);
245 }
246 
247 static llvm::Constant *getOpaquePersonalityFn(CodeGenModule &CGM,
248  const EHPersonality &Personality) {
249  llvm::FunctionCallee Fn = getPersonalityFn(CGM, Personality);
250  llvm::PointerType* Int8PtrTy = llvm::PointerType::get(
251  llvm::Type::getInt8Ty(CGM.getLLVMContext()),
252  CGM.getDataLayout().getProgramAddressSpace());
253 
254  return llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(Fn.getCallee()),
255  Int8PtrTy);
256 }
257 
258 /// Check whether a landingpad instruction only uses C++ features.
259 static bool LandingPadHasOnlyCXXUses(llvm::LandingPadInst *LPI) {
260  for (unsigned I = 0, E = LPI->getNumClauses(); I != E; ++I) {
261  // Look for something that would've been returned by the ObjC
262  // runtime's GetEHType() method.
263  llvm::Value *Val = LPI->getClause(I)->stripPointerCasts();
264  if (LPI->isCatch(I)) {
265  // Check if the catch value has the ObjC prefix.
266  if (llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Val))
267  // ObjC EH selector entries are always global variables with
268  // names starting like this.
269  if (GV->getName().startswith("OBJC_EHTYPE"))
270  return false;
271  } else {
272  // Check if any of the filter values have the ObjC prefix.
273  llvm::Constant *CVal = cast<llvm::Constant>(Val);
274  for (llvm::User::op_iterator
275  II = CVal->op_begin(), IE = CVal->op_end(); II != IE; ++II) {
276  if (llvm::GlobalVariable *GV =
277  cast<llvm::GlobalVariable>((*II)->stripPointerCasts()))
278  // ObjC EH selector entries are always global variables with
279  // names starting like this.
280  if (GV->getName().startswith("OBJC_EHTYPE"))
281  return false;
282  }
283  }
284  }
285  return true;
286 }
287 
288 /// Check whether a personality function could reasonably be swapped
289 /// for a C++ personality function.
290 static bool PersonalityHasOnlyCXXUses(llvm::Constant *Fn) {
291  for (llvm::User *U : Fn->users()) {
292  // Conditionally white-list bitcasts.
293  if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(U)) {
294  if (CE->getOpcode() != llvm::Instruction::BitCast) return false;
295  if (!PersonalityHasOnlyCXXUses(CE))
296  return false;
297  continue;
298  }
299 
300  // Otherwise it must be a function.
301  llvm::Function *F = dyn_cast<llvm::Function>(U);
302  if (!F) return false;
303 
304  for (auto BB = F->begin(), E = F->end(); BB != E; ++BB) {
305  if (BB->isLandingPad())
306  if (!LandingPadHasOnlyCXXUses(BB->getLandingPadInst()))
307  return false;
308  }
309  }
310 
311  return true;
312 }
313 
314 /// Try to use the C++ personality function in ObjC++. Not doing this
315 /// can cause some incompatibilities with gcc, which is more
316 /// aggressive about only using the ObjC++ personality in a function
317 /// when it really needs it.
318 void CodeGenModule::SimplifyPersonality() {
319  // If we're not in ObjC++ -fexceptions, there's nothing to do.
320  if (!LangOpts.CPlusPlus || !LangOpts.ObjC || !LangOpts.Exceptions)
321  return;
322 
323  // Both the problem this endeavors to fix and the way the logic
324  // above works is specific to the NeXT runtime.
325  if (!LangOpts.ObjCRuntime.isNeXTFamily())
326  return;
327 
328  const EHPersonality &ObjCXX = EHPersonality::get(*this, /*FD=*/nullptr);
329  const EHPersonality &CXX = getCXXPersonality(getTarget(), LangOpts);
330  if (&ObjCXX == &CXX)
331  return;
332 
333  assert(std::strcmp(ObjCXX.PersonalityFn, CXX.PersonalityFn) != 0 &&
334  "Different EHPersonalities using the same personality function.");
335 
336  llvm::Function *Fn = getModule().getFunction(ObjCXX.PersonalityFn);
337 
338  // Nothing to do if it's unused.
339  if (!Fn || Fn->use_empty()) return;
340 
341  // Can't do the optimization if it has non-C++ uses.
342  if (!PersonalityHasOnlyCXXUses(Fn)) return;
343 
344  // Create the C++ personality function and kill off the old
345  // function.
346  llvm::FunctionCallee CXXFn = getPersonalityFn(*this, CXX);
347 
348  // This can happen if the user is screwing with us.
349  if (Fn->getType() != CXXFn.getCallee()->getType())
350  return;
351 
352  Fn->replaceAllUsesWith(CXXFn.getCallee());
353  Fn->eraseFromParent();
354 }
355 
356 /// Returns the value to inject into a selector to indicate the
357 /// presence of a catch-all.
358 static llvm::Constant *getCatchAllValue(CodeGenFunction &CGF) {
359  // Possibly we should use @llvm.eh.catch.all.value here.
360  return llvm::ConstantPointerNull::get(CGF.Int8PtrTy);
361 }
362 
363 namespace {
364  /// A cleanup to free the exception object if its initialization
365  /// throws.
366  struct FreeException final : EHScopeStack::Cleanup {
367  llvm::Value *exn;
368  FreeException(llvm::Value *exn) : exn(exn) {}
369  void Emit(CodeGenFunction &CGF, Flags flags) override {
371  }
372  };
373 } // end anonymous namespace
374 
375 // Emits an exception expression into the given location. This
376 // differs from EmitAnyExprToMem only in that, if a final copy-ctor
377 // call is required, an exception within that copy ctor causes
378 // std::terminate to be invoked.
380  // Make sure the exception object is cleaned up if there's an
381  // exception during initialization.
382  pushFullExprCleanup<FreeException>(EHCleanup, addr.getPointer());
383  EHScopeStack::stable_iterator cleanup = EHStack.stable_begin();
384 
385  // __cxa_allocate_exception returns a void*; we need to cast this
386  // to the appropriate type for the object.
387  llvm::Type *ty = ConvertTypeForMem(e->getType())->getPointerTo();
388  Address typedAddr = Builder.CreateBitCast(addr, ty);
389 
390  // FIXME: this isn't quite right! If there's a final unelided call
391  // to a copy constructor, then according to [except.terminate]p1 we
392  // must call std::terminate() if that constructor throws, because
393  // technically that copy occurs after the exception expression is
394  // evaluated but before the exception is caught. But the best way
395  // to handle that is to teach EmitAggExpr to do the final copy
396  // differently if it can't be elided.
397  EmitAnyExprToMem(e, typedAddr, e->getType().getQualifiers(),
398  /*IsInit*/ true);
399 
400  // Deactivate the cleanup block.
401  DeactivateCleanupBlock(cleanup,
402  cast<llvm::Instruction>(typedAddr.getPointer()));
403 }
404 
406  if (!ExceptionSlot)
407  ExceptionSlot = CreateTempAlloca(Int8PtrTy, "exn.slot");
408  return Address(ExceptionSlot, getPointerAlign());
409 }
410 
412  if (!EHSelectorSlot)
413  EHSelectorSlot = CreateTempAlloca(Int32Ty, "ehselector.slot");
414  return Address(EHSelectorSlot, CharUnits::fromQuantity(4));
415 }
416 
418  return Builder.CreateLoad(getExceptionSlot(), "exn");
419 }
420 
422  return Builder.CreateLoad(getEHSelectorSlot(), "sel");
423 }
424 
426  bool KeepInsertionPoint) {
427  if (const Expr *SubExpr = E->getSubExpr()) {
428  QualType ThrowType = SubExpr->getType();
429  if (ThrowType->isObjCObjectPointerType()) {
430  const Stmt *ThrowStmt = E->getSubExpr();
431  const ObjCAtThrowStmt S(E->getExprLoc(), const_cast<Stmt *>(ThrowStmt));
432  CGM.getObjCRuntime().EmitThrowStmt(*this, S, false);
433  } else {
434  CGM.getCXXABI().emitThrow(*this, E);
435  }
436  } else {
437  CGM.getCXXABI().emitRethrow(*this, /*isNoReturn=*/true);
438  }
439 
440  // throw is an expression, and the expression emitters expect us
441  // to leave ourselves at a valid insertion point.
442  if (KeepInsertionPoint)
443  EmitBlock(createBasicBlock("throw.cont"));
444 }
445 
447  if (!CGM.getLangOpts().CXXExceptions)
448  return;
449 
450  const FunctionDecl* FD = dyn_cast_or_null<FunctionDecl>(D);
451  if (!FD) {
452  // Check if CapturedDecl is nothrow and create terminate scope for it.
453  if (const CapturedDecl* CD = dyn_cast_or_null<CapturedDecl>(D)) {
454  if (CD->isNothrow())
455  EHStack.pushTerminate();
456  }
457  return;
458  }
459  const FunctionProtoType *Proto = FD->getType()->getAs<FunctionProtoType>();
460  if (!Proto)
461  return;
462 
464  if (isNoexceptExceptionSpec(EST) && Proto->canThrow() == CT_Cannot) {
465  // noexcept functions are simple terminate scopes.
466  EHStack.pushTerminate();
467  } else if (EST == EST_Dynamic || EST == EST_DynamicNone) {
468  // TODO: Revisit exception specifications for the MS ABI. There is a way to
469  // encode these in an object file but MSVC doesn't do anything with it.
470  if (getTarget().getCXXABI().isMicrosoft())
471  return;
472  // In wasm we currently treat 'throw()' in the same way as 'noexcept'. In
473  // case of throw with types, we ignore it and print a warning for now.
474  // TODO Correctly handle exception specification in wasm
475  if (CGM.getLangOpts().WasmExceptions) {
476  if (EST == EST_DynamicNone)
477  EHStack.pushTerminate();
478  else
479  CGM.getDiags().Report(D->getLocation(),
480  diag::warn_wasm_dynamic_exception_spec_ignored)
482  return;
483  }
484  unsigned NumExceptions = Proto->getNumExceptions();
485  EHFilterScope *Filter = EHStack.pushFilter(NumExceptions);
486 
487  for (unsigned I = 0; I != NumExceptions; ++I) {
488  QualType Ty = Proto->getExceptionType(I);
489  QualType ExceptType = Ty.getNonReferenceType().getUnqualifiedType();
490  llvm::Value *EHType = CGM.GetAddrOfRTTIDescriptor(ExceptType,
491  /*ForEH=*/true);
492  Filter->setFilter(I, EHType);
493  }
494  }
495 }
496 
497 /// Emit the dispatch block for a filter scope if necessary.
499  EHFilterScope &filterScope) {
500  llvm::BasicBlock *dispatchBlock = filterScope.getCachedEHDispatchBlock();
501  if (!dispatchBlock) return;
502  if (dispatchBlock->use_empty()) {
503  delete dispatchBlock;
504  return;
505  }
506 
507  CGF.EmitBlockAfterUses(dispatchBlock);
508 
509  // If this isn't a catch-all filter, we need to check whether we got
510  // here because the filter triggered.
511  if (filterScope.getNumFilters()) {
512  // Load the selector value.
513  llvm::Value *selector = CGF.getSelectorFromSlot();
514  llvm::BasicBlock *unexpectedBB = CGF.createBasicBlock("ehspec.unexpected");
515 
516  llvm::Value *zero = CGF.Builder.getInt32(0);
517  llvm::Value *failsFilter =
518  CGF.Builder.CreateICmpSLT(selector, zero, "ehspec.fails");
519  CGF.Builder.CreateCondBr(failsFilter, unexpectedBB,
520  CGF.getEHResumeBlock(false));
521 
522  CGF.EmitBlock(unexpectedBB);
523  }
524 
525  // Call __cxa_call_unexpected. This doesn't need to be an invoke
526  // because __cxa_call_unexpected magically filters exceptions
527  // according to the last landing pad the exception was thrown
528  // into. Seriously.
529  llvm::Value *exn = CGF.getExceptionFromSlot();
530  CGF.EmitRuntimeCall(getUnexpectedFn(CGF.CGM), exn)
531  ->setDoesNotReturn();
532  CGF.Builder.CreateUnreachable();
533 }
534 
536  if (!CGM.getLangOpts().CXXExceptions)
537  return;
538 
539  const FunctionDecl* FD = dyn_cast_or_null<FunctionDecl>(D);
540  if (!FD) {
541  // Check if CapturedDecl is nothrow and pop terminate scope for it.
542  if (const CapturedDecl* CD = dyn_cast_or_null<CapturedDecl>(D)) {
543  if (CD->isNothrow())
544  EHStack.popTerminate();
545  }
546  return;
547  }
548  const FunctionProtoType *Proto = FD->getType()->getAs<FunctionProtoType>();
549  if (!Proto)
550  return;
551 
553  if (isNoexceptExceptionSpec(EST) && Proto->canThrow() == CT_Cannot) {
554  EHStack.popTerminate();
555  } else if (EST == EST_Dynamic || EST == EST_DynamicNone) {
556  // TODO: Revisit exception specifications for the MS ABI. There is a way to
557  // encode these in an object file but MSVC doesn't do anything with it.
558  if (getTarget().getCXXABI().isMicrosoft())
559  return;
560  // In wasm we currently treat 'throw()' in the same way as 'noexcept'. In
561  // case of throw with types, we ignore it and print a warning for now.
562  // TODO Correctly handle exception specification in wasm
563  if (CGM.getLangOpts().WasmExceptions) {
564  if (EST == EST_DynamicNone)
565  EHStack.popTerminate();
566  return;
567  }
568  EHFilterScope &filterScope = cast<EHFilterScope>(*EHStack.begin());
569  emitFilterDispatchBlock(*this, filterScope);
570  EHStack.popFilter();
571  }
572 }
573 
575  EnterCXXTryStmt(S);
576  EmitStmt(S.getTryBlock());
577  ExitCXXTryStmt(S);
578 }
579 
580 void CodeGenFunction::EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock) {
581  unsigned NumHandlers = S.getNumHandlers();
582  EHCatchScope *CatchScope = EHStack.pushCatch(NumHandlers);
583 
584  for (unsigned I = 0; I != NumHandlers; ++I) {
585  const CXXCatchStmt *C = S.getHandler(I);
586 
587  llvm::BasicBlock *Handler = createBasicBlock("catch");
588  if (C->getExceptionDecl()) {
589  // FIXME: Dropping the reference type on the type into makes it
590  // impossible to correctly implement catch-by-reference
591  // semantics for pointers. Unfortunately, this is what all
592  // existing compilers do, and it's not clear that the standard
593  // personality routine is capable of doing this right. See C++ DR 388:
594  // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#388
595  Qualifiers CaughtTypeQuals;
596  QualType CaughtType = CGM.getContext().getUnqualifiedArrayType(
597  C->getCaughtType().getNonReferenceType(), CaughtTypeQuals);
598 
599  CatchTypeInfo TypeInfo{nullptr, 0};
600  if (CaughtType->isObjCObjectPointerType())
601  TypeInfo.RTTI = CGM.getObjCRuntime().GetEHType(CaughtType);
602  else
603  TypeInfo = CGM.getCXXABI().getAddrOfCXXCatchHandlerType(
604  CaughtType, C->getCaughtType());
605  CatchScope->setHandler(I, TypeInfo, Handler);
606  } else {
607  // No exception decl indicates '...', a catch-all.
608  CatchScope->setHandler(I, CGM.getCXXABI().getCatchAllTypeInfo(), Handler);
609  }
610  }
611 }
612 
613 llvm::BasicBlock *
615  if (EHPersonality::get(*this).usesFuncletPads())
616  return getFuncletEHDispatchBlock(si);
617 
618  // The dispatch block for the end of the scope chain is a block that
619  // just resumes unwinding.
620  if (si == EHStack.stable_end())
621  return getEHResumeBlock(true);
622 
623  // Otherwise, we should look at the actual scope.
624  EHScope &scope = *EHStack.find(si);
625 
626  llvm::BasicBlock *dispatchBlock = scope.getCachedEHDispatchBlock();
627  if (!dispatchBlock) {
628  switch (scope.getKind()) {
629  case EHScope::Catch: {
630  // Apply a special case to a single catch-all.
631  EHCatchScope &catchScope = cast<EHCatchScope>(scope);
632  if (catchScope.getNumHandlers() == 1 &&
633  catchScope.getHandler(0).isCatchAll()) {
634  dispatchBlock = catchScope.getHandler(0).Block;
635 
636  // Otherwise, make a dispatch block.
637  } else {
638  dispatchBlock = createBasicBlock("catch.dispatch");
639  }
640  break;
641  }
642 
643  case EHScope::Cleanup:
644  dispatchBlock = createBasicBlock("ehcleanup");
645  break;
646 
647  case EHScope::Filter:
648  dispatchBlock = createBasicBlock("filter.dispatch");
649  break;
650 
651  case EHScope::Terminate:
652  dispatchBlock = getTerminateHandler();
653  break;
654  }
655  scope.setCachedEHDispatchBlock(dispatchBlock);
656  }
657  return dispatchBlock;
658 }
659 
660 llvm::BasicBlock *
662  // Returning nullptr indicates that the previous dispatch block should unwind
663  // to caller.
664  if (SI == EHStack.stable_end())
665  return nullptr;
666 
667  // Otherwise, we should look at the actual scope.
668  EHScope &EHS = *EHStack.find(SI);
669 
670  llvm::BasicBlock *DispatchBlock = EHS.getCachedEHDispatchBlock();
671  if (DispatchBlock)
672  return DispatchBlock;
673 
674  if (EHS.getKind() == EHScope::Terminate)
675  DispatchBlock = getTerminateFunclet();
676  else
677  DispatchBlock = createBasicBlock();
678  CGBuilderTy Builder(*this, DispatchBlock);
679 
680  switch (EHS.getKind()) {
681  case EHScope::Catch:
682  DispatchBlock->setName("catch.dispatch");
683  break;
684 
685  case EHScope::Cleanup:
686  DispatchBlock->setName("ehcleanup");
687  break;
688 
689  case EHScope::Filter:
690  llvm_unreachable("exception specifications not handled yet!");
691 
692  case EHScope::Terminate:
693  DispatchBlock->setName("terminate");
694  break;
695  }
696  EHS.setCachedEHDispatchBlock(DispatchBlock);
697  return DispatchBlock;
698 }
699 
700 /// Check whether this is a non-EH scope, i.e. a scope which doesn't
701 /// affect exception handling. Currently, the only non-EH scopes are
702 /// normal-only cleanup scopes.
703 static bool isNonEHScope(const EHScope &S) {
704  switch (S.getKind()) {
705  case EHScope::Cleanup:
706  return !cast<EHCleanupScope>(S).isEHCleanup();
707  case EHScope::Filter:
708  case EHScope::Catch:
709  case EHScope::Terminate:
710  return false;
711  }
712 
713  llvm_unreachable("Invalid EHScope Kind!");
714 }
715 
717  assert(EHStack.requiresLandingPad());
718  assert(!EHStack.empty());
719 
720  // If exceptions are disabled/ignored and SEH is not in use, then there is no
721  // invoke destination. SEH "works" even if exceptions are off. In practice,
722  // this means that C++ destructors and other EH cleanups don't run, which is
723  // consistent with MSVC's behavior.
724  const LangOptions &LO = CGM.getLangOpts();
725  if (!LO.Exceptions || LO.IgnoreExceptions) {
726  if (!LO.Borland && !LO.MicrosoftExt)
727  return nullptr;
728  if (!currentFunctionUsesSEHTry())
729  return nullptr;
730  }
731 
732  // CUDA device code doesn't have exceptions.
733  if (LO.CUDA && LO.CUDAIsDevice)
734  return nullptr;
735 
736  // Check the innermost scope for a cached landing pad. If this is
737  // a non-EH cleanup, we'll check enclosing scopes in EmitLandingPad.
738  llvm::BasicBlock *LP = EHStack.begin()->getCachedLandingPad();
739  if (LP) return LP;
740 
741  const EHPersonality &Personality = EHPersonality::get(*this);
742 
743  if (!CurFn->hasPersonalityFn())
744  CurFn->setPersonalityFn(getOpaquePersonalityFn(CGM, Personality));
745 
746  if (Personality.usesFuncletPads()) {
747  // We don't need separate landing pads in the funclet model.
748  LP = getEHDispatchBlock(EHStack.getInnermostEHScope());
749  } else {
750  // Build the landing pad for this scope.
751  LP = EmitLandingPad();
752  }
753 
754  assert(LP);
755 
756  // Cache the landing pad on the innermost scope. If this is a
757  // non-EH scope, cache the landing pad on the enclosing scope, too.
758  for (EHScopeStack::iterator ir = EHStack.begin(); true; ++ir) {
759  ir->setCachedLandingPad(LP);
760  if (!isNonEHScope(*ir)) break;
761  }
762 
763  return LP;
764 }
765 
766 llvm::BasicBlock *CodeGenFunction::EmitLandingPad() {
767  assert(EHStack.requiresLandingPad());
768  assert(!CGM.getLangOpts().IgnoreExceptions &&
769  "LandingPad should not be emitted when -fignore-exceptions are in "
770  "effect.");
771  EHScope &innermostEHScope = *EHStack.find(EHStack.getInnermostEHScope());
772  switch (innermostEHScope.getKind()) {
773  case EHScope::Terminate:
774  return getTerminateLandingPad();
775 
776  case EHScope::Catch:
777  case EHScope::Cleanup:
778  case EHScope::Filter:
779  if (llvm::BasicBlock *lpad = innermostEHScope.getCachedLandingPad())
780  return lpad;
781  }
782 
783  // Save the current IR generation state.
784  CGBuilderTy::InsertPoint savedIP = Builder.saveAndClearIP();
785  auto DL = ApplyDebugLocation::CreateDefaultArtificial(*this, CurEHLocation);
786 
787  // Create and configure the landing pad.
788  llvm::BasicBlock *lpad = createBasicBlock("lpad");
789  EmitBlock(lpad);
790 
791  llvm::LandingPadInst *LPadInst =
792  Builder.CreateLandingPad(llvm::StructType::get(Int8PtrTy, Int32Ty), 0);
793 
794  llvm::Value *LPadExn = Builder.CreateExtractValue(LPadInst, 0);
795  Builder.CreateStore(LPadExn, getExceptionSlot());
796  llvm::Value *LPadSel = Builder.CreateExtractValue(LPadInst, 1);
797  Builder.CreateStore(LPadSel, getEHSelectorSlot());
798 
799  // Save the exception pointer. It's safe to use a single exception
800  // pointer per function because EH cleanups can never have nested
801  // try/catches.
802  // Build the landingpad instruction.
803 
804  // Accumulate all the handlers in scope.
805  bool hasCatchAll = false;
806  bool hasCleanup = false;
807  bool hasFilter = false;
808  SmallVector<llvm::Value*, 4> filterTypes;
810  for (EHScopeStack::iterator I = EHStack.begin(), E = EHStack.end(); I != E;
811  ++I) {
812 
813  switch (I->getKind()) {
814  case EHScope::Cleanup:
815  // If we have a cleanup, remember that.
816  hasCleanup = (hasCleanup || cast<EHCleanupScope>(*I).isEHCleanup());
817  continue;
818 
819  case EHScope::Filter: {
820  assert(I.next() == EHStack.end() && "EH filter is not end of EH stack");
821  assert(!hasCatchAll && "EH filter reached after catch-all");
822 
823  // Filter scopes get added to the landingpad in weird ways.
824  EHFilterScope &filter = cast<EHFilterScope>(*I);
825  hasFilter = true;
826 
827  // Add all the filter values.
828  for (unsigned i = 0, e = filter.getNumFilters(); i != e; ++i)
829  filterTypes.push_back(filter.getFilter(i));
830  goto done;
831  }
832 
833  case EHScope::Terminate:
834  // Terminate scopes are basically catch-alls.
835  assert(!hasCatchAll);
836  hasCatchAll = true;
837  goto done;
838 
839  case EHScope::Catch:
840  break;
841  }
842 
843  EHCatchScope &catchScope = cast<EHCatchScope>(*I);
844  for (unsigned hi = 0, he = catchScope.getNumHandlers(); hi != he; ++hi) {
845  EHCatchScope::Handler handler = catchScope.getHandler(hi);
846  assert(handler.Type.Flags == 0 &&
847  "landingpads do not support catch handler flags");
848 
849  // If this is a catch-all, register that and abort.
850  if (!handler.Type.RTTI) {
851  assert(!hasCatchAll);
852  hasCatchAll = true;
853  goto done;
854  }
855 
856  // Check whether we already have a handler for this type.
857  if (catchTypes.insert(handler.Type.RTTI).second)
858  // If not, add it directly to the landingpad.
859  LPadInst->addClause(handler.Type.RTTI);
860  }
861  }
862 
863  done:
864  // If we have a catch-all, add null to the landingpad.
865  assert(!(hasCatchAll && hasFilter));
866  if (hasCatchAll) {
867  LPadInst->addClause(getCatchAllValue(*this));
868 
869  // If we have an EH filter, we need to add those handlers in the
870  // right place in the landingpad, which is to say, at the end.
871  } else if (hasFilter) {
872  // Create a filter expression: a constant array indicating which filter
873  // types there are. The personality routine only lands here if the filter
874  // doesn't match.
876  llvm::ArrayType *AType =
877  llvm::ArrayType::get(!filterTypes.empty() ?
878  filterTypes[0]->getType() : Int8PtrTy,
879  filterTypes.size());
880 
881  for (unsigned i = 0, e = filterTypes.size(); i != e; ++i)
882  Filters.push_back(cast<llvm::Constant>(filterTypes[i]));
883  llvm::Constant *FilterArray = llvm::ConstantArray::get(AType, Filters);
884  LPadInst->addClause(FilterArray);
885 
886  // Also check whether we need a cleanup.
887  if (hasCleanup)
888  LPadInst->setCleanup(true);
889 
890  // Otherwise, signal that we at least have cleanups.
891  } else if (hasCleanup) {
892  LPadInst->setCleanup(true);
893  }
894 
895  assert((LPadInst->getNumClauses() > 0 || LPadInst->isCleanup()) &&
896  "landingpad instruction has no clauses!");
897 
898  // Tell the backend how to generate the landing pad.
899  Builder.CreateBr(getEHDispatchBlock(EHStack.getInnermostEHScope()));
900 
901  // Restore the old IR generation state.
902  Builder.restoreIP(savedIP);
903 
904  return lpad;
905 }
906 
907 static void emitCatchPadBlock(CodeGenFunction &CGF, EHCatchScope &CatchScope) {
908  llvm::BasicBlock *DispatchBlock = CatchScope.getCachedEHDispatchBlock();
909  assert(DispatchBlock);
910 
911  CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveIP();
912  CGF.EmitBlockAfterUses(DispatchBlock);
913 
914  llvm::Value *ParentPad = CGF.CurrentFuncletPad;
915  if (!ParentPad)
916  ParentPad = llvm::ConstantTokenNone::get(CGF.getLLVMContext());
917  llvm::BasicBlock *UnwindBB =
918  CGF.getEHDispatchBlock(CatchScope.getEnclosingEHScope());
919 
920  unsigned NumHandlers = CatchScope.getNumHandlers();
921  llvm::CatchSwitchInst *CatchSwitch =
922  CGF.Builder.CreateCatchSwitch(ParentPad, UnwindBB, NumHandlers);
923 
924  // Test against each of the exception types we claim to catch.
925  for (unsigned I = 0; I < NumHandlers; ++I) {
926  const EHCatchScope::Handler &Handler = CatchScope.getHandler(I);
927 
928  CatchTypeInfo TypeInfo = Handler.Type;
929  if (!TypeInfo.RTTI)
930  TypeInfo.RTTI = llvm::Constant::getNullValue(CGF.VoidPtrTy);
931 
932  CGF.Builder.SetInsertPoint(Handler.Block);
933 
934  if (EHPersonality::get(CGF).isMSVCXXPersonality()) {
935  CGF.Builder.CreateCatchPad(
936  CatchSwitch, {TypeInfo.RTTI, CGF.Builder.getInt32(TypeInfo.Flags),
937  llvm::Constant::getNullValue(CGF.VoidPtrTy)});
938  } else {
939  CGF.Builder.CreateCatchPad(CatchSwitch, {TypeInfo.RTTI});
940  }
941 
942  CatchSwitch->addHandler(Handler.Block);
943  }
944  CGF.Builder.restoreIP(SavedIP);
945 }
946 
947 // Wasm uses Windows-style EH instructions, but it merges all catch clauses into
948 // one big catchpad, within which we use Itanium's landingpad-style selector
949 // comparison instructions.
951  EHCatchScope &CatchScope) {
952  llvm::BasicBlock *DispatchBlock = CatchScope.getCachedEHDispatchBlock();
953  assert(DispatchBlock);
954 
955  CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveIP();
956  CGF.EmitBlockAfterUses(DispatchBlock);
957 
958  llvm::Value *ParentPad = CGF.CurrentFuncletPad;
959  if (!ParentPad)
960  ParentPad = llvm::ConstantTokenNone::get(CGF.getLLVMContext());
961  llvm::BasicBlock *UnwindBB =
962  CGF.getEHDispatchBlock(CatchScope.getEnclosingEHScope());
963 
964  unsigned NumHandlers = CatchScope.getNumHandlers();
965  llvm::CatchSwitchInst *CatchSwitch =
966  CGF.Builder.CreateCatchSwitch(ParentPad, UnwindBB, NumHandlers);
967 
968  // We don't use a landingpad instruction, so generate intrinsic calls to
969  // provide exception and selector values.
970  llvm::BasicBlock *WasmCatchStartBlock = CGF.createBasicBlock("catch.start");
971  CatchSwitch->addHandler(WasmCatchStartBlock);
972  CGF.EmitBlockAfterUses(WasmCatchStartBlock);
973 
974  // Create a catchpad instruction.
976  for (unsigned I = 0, E = NumHandlers; I < E; ++I) {
977  const EHCatchScope::Handler &Handler = CatchScope.getHandler(I);
978  CatchTypeInfo TypeInfo = Handler.Type;
979  if (!TypeInfo.RTTI)
980  TypeInfo.RTTI = llvm::Constant::getNullValue(CGF.VoidPtrTy);
981  CatchTypes.push_back(TypeInfo.RTTI);
982  }
983  auto *CPI = CGF.Builder.CreateCatchPad(CatchSwitch, CatchTypes);
984 
985  // Create calls to wasm.get.exception and wasm.get.ehselector intrinsics.
986  // Before they are lowered appropriately later, they provide values for the
987  // exception and selector.
988  llvm::Function *GetExnFn =
989  CGF.CGM.getIntrinsic(llvm::Intrinsic::wasm_get_exception);
990  llvm::Function *GetSelectorFn =
991  CGF.CGM.getIntrinsic(llvm::Intrinsic::wasm_get_ehselector);
992  llvm::CallInst *Exn = CGF.Builder.CreateCall(GetExnFn, CPI);
993  CGF.Builder.CreateStore(Exn, CGF.getExceptionSlot());
994  llvm::CallInst *Selector = CGF.Builder.CreateCall(GetSelectorFn, CPI);
995 
996  llvm::Function *TypeIDFn = CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_typeid_for);
997 
998  // If there's only a single catch-all, branch directly to its handler.
999  if (CatchScope.getNumHandlers() == 1 &&
1000  CatchScope.getHandler(0).isCatchAll()) {
1001  CGF.Builder.CreateBr(CatchScope.getHandler(0).Block);
1002  CGF.Builder.restoreIP(SavedIP);
1003  return;
1004  }
1005 
1006  // Test against each of the exception types we claim to catch.
1007  for (unsigned I = 0, E = NumHandlers;; ++I) {
1008  assert(I < E && "ran off end of handlers!");
1009  const EHCatchScope::Handler &Handler = CatchScope.getHandler(I);
1010  CatchTypeInfo TypeInfo = Handler.Type;
1011  if (!TypeInfo.RTTI)
1012  TypeInfo.RTTI = llvm::Constant::getNullValue(CGF.VoidPtrTy);
1013 
1014  // Figure out the next block.
1015  llvm::BasicBlock *NextBlock;
1016 
1017  bool EmitNextBlock = false, NextIsEnd = false;
1018 
1019  // If this is the last handler, we're at the end, and the next block is a
1020  // block that contains a call to the rethrow function, so we can unwind to
1021  // the enclosing EH scope. The call itself will be generated later.
1022  if (I + 1 == E) {
1023  NextBlock = CGF.createBasicBlock("rethrow");
1024  EmitNextBlock = true;
1025  NextIsEnd = true;
1026 
1027  // If the next handler is a catch-all, we're at the end, and the
1028  // next block is that handler.
1029  } else if (CatchScope.getHandler(I + 1).isCatchAll()) {
1030  NextBlock = CatchScope.getHandler(I + 1).Block;
1031  NextIsEnd = true;
1032 
1033  // Otherwise, we're not at the end and we need a new block.
1034  } else {
1035  NextBlock = CGF.createBasicBlock("catch.fallthrough");
1036  EmitNextBlock = true;
1037  }
1038 
1039  // Figure out the catch type's index in the LSDA's type table.
1040  llvm::CallInst *TypeIndex = CGF.Builder.CreateCall(TypeIDFn, TypeInfo.RTTI);
1041  TypeIndex->setDoesNotThrow();
1042 
1043  llvm::Value *MatchesTypeIndex =
1044  CGF.Builder.CreateICmpEQ(Selector, TypeIndex, "matches");
1045  CGF.Builder.CreateCondBr(MatchesTypeIndex, Handler.Block, NextBlock);
1046 
1047  if (EmitNextBlock)
1048  CGF.EmitBlock(NextBlock);
1049  if (NextIsEnd)
1050  break;
1051  }
1052 
1053  CGF.Builder.restoreIP(SavedIP);
1054 }
1055 
1056 /// Emit the structure of the dispatch block for the given catch scope.
1057 /// It is an invariant that the dispatch block already exists.
1059  EHCatchScope &catchScope) {
1060  if (EHPersonality::get(CGF).isWasmPersonality())
1061  return emitWasmCatchPadBlock(CGF, catchScope);
1062  if (EHPersonality::get(CGF).usesFuncletPads())
1063  return emitCatchPadBlock(CGF, catchScope);
1064 
1065  llvm::BasicBlock *dispatchBlock = catchScope.getCachedEHDispatchBlock();
1066  assert(dispatchBlock);
1067 
1068  // If there's only a single catch-all, getEHDispatchBlock returned
1069  // that catch-all as the dispatch block.
1070  if (catchScope.getNumHandlers() == 1 &&
1071  catchScope.getHandler(0).isCatchAll()) {
1072  assert(dispatchBlock == catchScope.getHandler(0).Block);
1073  return;
1074  }
1075 
1076  CGBuilderTy::InsertPoint savedIP = CGF.Builder.saveIP();
1077  CGF.EmitBlockAfterUses(dispatchBlock);
1078 
1079  // Select the right handler.
1080  llvm::Function *llvm_eh_typeid_for =
1081  CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_typeid_for);
1082 
1083  // Load the selector value.
1084  llvm::Value *selector = CGF.getSelectorFromSlot();
1085 
1086  // Test against each of the exception types we claim to catch.
1087  for (unsigned i = 0, e = catchScope.getNumHandlers(); ; ++i) {
1088  assert(i < e && "ran off end of handlers!");
1089  const EHCatchScope::Handler &handler = catchScope.getHandler(i);
1090 
1091  llvm::Value *typeValue = handler.Type.RTTI;
1092  assert(handler.Type.Flags == 0 &&
1093  "landingpads do not support catch handler flags");
1094  assert(typeValue && "fell into catch-all case!");
1095  typeValue = CGF.Builder.CreateBitCast(typeValue, CGF.Int8PtrTy);
1096 
1097  // Figure out the next block.
1098  bool nextIsEnd;
1099  llvm::BasicBlock *nextBlock;
1100 
1101  // If this is the last handler, we're at the end, and the next
1102  // block is the block for the enclosing EH scope.
1103  if (i + 1 == e) {
1104  nextBlock = CGF.getEHDispatchBlock(catchScope.getEnclosingEHScope());
1105  nextIsEnd = true;
1106 
1107  // If the next handler is a catch-all, we're at the end, and the
1108  // next block is that handler.
1109  } else if (catchScope.getHandler(i+1).isCatchAll()) {
1110  nextBlock = catchScope.getHandler(i+1).Block;
1111  nextIsEnd = true;
1112 
1113  // Otherwise, we're not at the end and we need a new block.
1114  } else {
1115  nextBlock = CGF.createBasicBlock("catch.fallthrough");
1116  nextIsEnd = false;
1117  }
1118 
1119  // Figure out the catch type's index in the LSDA's type table.
1120  llvm::CallInst *typeIndex =
1121  CGF.Builder.CreateCall(llvm_eh_typeid_for, typeValue);
1122  typeIndex->setDoesNotThrow();
1123 
1124  llvm::Value *matchesTypeIndex =
1125  CGF.Builder.CreateICmpEQ(selector, typeIndex, "matches");
1126  CGF.Builder.CreateCondBr(matchesTypeIndex, handler.Block, nextBlock);
1127 
1128  // If the next handler is a catch-all, we're completely done.
1129  if (nextIsEnd) {
1130  CGF.Builder.restoreIP(savedIP);
1131  return;
1132  }
1133  // Otherwise we need to emit and continue at that block.
1134  CGF.EmitBlock(nextBlock);
1135  }
1136 }
1137 
1139  EHCatchScope &catchScope = cast<EHCatchScope>(*EHStack.begin());
1140  if (catchScope.hasEHBranches())
1141  emitCatchDispatchBlock(*this, catchScope);
1142  EHStack.popCatch();
1143 }
1144 
1145 void CodeGenFunction::ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock) {
1146  unsigned NumHandlers = S.getNumHandlers();
1147  EHCatchScope &CatchScope = cast<EHCatchScope>(*EHStack.begin());
1148  assert(CatchScope.getNumHandlers() == NumHandlers);
1149  llvm::BasicBlock *DispatchBlock = CatchScope.getCachedEHDispatchBlock();
1150 
1151  // If the catch was not required, bail out now.
1152  if (!CatchScope.hasEHBranches()) {
1153  CatchScope.clearHandlerBlocks();
1154  EHStack.popCatch();
1155  return;
1156  }
1157 
1158  // Emit the structure of the EH dispatch for this catch.
1159  emitCatchDispatchBlock(*this, CatchScope);
1160 
1161  // Copy the handler blocks off before we pop the EH stack. Emitting
1162  // the handlers might scribble on this memory.
1164  CatchScope.begin(), CatchScope.begin() + NumHandlers);
1165 
1166  EHStack.popCatch();
1167 
1168  // The fall-through block.
1169  llvm::BasicBlock *ContBB = createBasicBlock("try.cont");
1170 
1171  // We just emitted the body of the try; jump to the continue block.
1172  if (HaveInsertPoint())
1173  Builder.CreateBr(ContBB);
1174 
1175  // Determine if we need an implicit rethrow for all these catch handlers;
1176  // see the comment below.
1177  bool doImplicitRethrow = false;
1178  if (IsFnTryBlock)
1179  doImplicitRethrow = isa<CXXDestructorDecl>(CurCodeDecl) ||
1180  isa<CXXConstructorDecl>(CurCodeDecl);
1181 
1182  // Wasm uses Windows-style EH instructions, but merges all catch clauses into
1183  // one big catchpad. So we save the old funclet pad here before we traverse
1184  // each catch handler.
1185  SaveAndRestore<llvm::Instruction *> RestoreCurrentFuncletPad(
1186  CurrentFuncletPad);
1187  llvm::BasicBlock *WasmCatchStartBlock = nullptr;
1188  if (EHPersonality::get(*this).isWasmPersonality()) {
1189  auto *CatchSwitch =
1190  cast<llvm::CatchSwitchInst>(DispatchBlock->getFirstNonPHI());
1191  WasmCatchStartBlock = CatchSwitch->hasUnwindDest()
1192  ? CatchSwitch->getSuccessor(1)
1193  : CatchSwitch->getSuccessor(0);
1194  auto *CPI = cast<llvm::CatchPadInst>(WasmCatchStartBlock->getFirstNonPHI());
1195  CurrentFuncletPad = CPI;
1196  }
1197 
1198  // Perversely, we emit the handlers backwards precisely because we
1199  // want them to appear in source order. In all of these cases, the
1200  // catch block will have exactly one predecessor, which will be a
1201  // particular block in the catch dispatch. However, in the case of
1202  // a catch-all, one of the dispatch blocks will branch to two
1203  // different handlers, and EmitBlockAfterUses will cause the second
1204  // handler to be moved before the first.
1205  bool HasCatchAll = false;
1206  for (unsigned I = NumHandlers; I != 0; --I) {
1207  HasCatchAll |= Handlers[I - 1].isCatchAll();
1208  llvm::BasicBlock *CatchBlock = Handlers[I-1].Block;
1209  EmitBlockAfterUses(CatchBlock);
1210 
1211  // Catch the exception if this isn't a catch-all.
1212  const CXXCatchStmt *C = S.getHandler(I-1);
1213 
1214  // Enter a cleanup scope, including the catch variable and the
1215  // end-catch.
1216  RunCleanupsScope CatchScope(*this);
1217 
1218  // Initialize the catch variable and set up the cleanups.
1219  SaveAndRestore<llvm::Instruction *> RestoreCurrentFuncletPad(
1220  CurrentFuncletPad);
1221  CGM.getCXXABI().emitBeginCatch(*this, C);
1222 
1223  // Emit the PGO counter increment.
1224  incrementProfileCounter(C);
1225 
1226  // Perform the body of the catch.
1227  EmitStmt(C->getHandlerBlock());
1228 
1229  // [except.handle]p11:
1230  // The currently handled exception is rethrown if control
1231  // reaches the end of a handler of the function-try-block of a
1232  // constructor or destructor.
1233 
1234  // It is important that we only do this on fallthrough and not on
1235  // return. Note that it's illegal to put a return in a
1236  // constructor function-try-block's catch handler (p14), so this
1237  // really only applies to destructors.
1238  if (doImplicitRethrow && HaveInsertPoint()) {
1239  CGM.getCXXABI().emitRethrow(*this, /*isNoReturn*/false);
1240  Builder.CreateUnreachable();
1241  Builder.ClearInsertionPoint();
1242  }
1243 
1244  // Fall out through the catch cleanups.
1245  CatchScope.ForceCleanup();
1246 
1247  // Branch out of the try.
1248  if (HaveInsertPoint())
1249  Builder.CreateBr(ContBB);
1250  }
1251 
1252  // Because in wasm we merge all catch clauses into one big catchpad, in case
1253  // none of the types in catch handlers matches after we test against each of
1254  // them, we should unwind to the next EH enclosing scope. We generate a call
1255  // to rethrow function here to do that.
1256  if (EHPersonality::get(*this).isWasmPersonality() && !HasCatchAll) {
1257  assert(WasmCatchStartBlock);
1258  // Navigate for the "rethrow" block we created in emitWasmCatchPadBlock().
1259  // Wasm uses landingpad-style conditional branches to compare selectors, so
1260  // we follow the false destination for each of the cond branches to reach
1261  // the rethrow block.
1262  llvm::BasicBlock *RethrowBlock = WasmCatchStartBlock;
1263  while (llvm::Instruction *TI = RethrowBlock->getTerminator()) {
1264  auto *BI = cast<llvm::BranchInst>(TI);
1265  assert(BI->isConditional());
1266  RethrowBlock = BI->getSuccessor(1);
1267  }
1268  assert(RethrowBlock != WasmCatchStartBlock && RethrowBlock->empty());
1269  Builder.SetInsertPoint(RethrowBlock);
1270  llvm::Function *RethrowInCatchFn =
1271  CGM.getIntrinsic(llvm::Intrinsic::wasm_rethrow_in_catch);
1272  EmitNoreturnRuntimeCallOrInvoke(RethrowInCatchFn, {});
1273  }
1274 
1275  EmitBlock(ContBB);
1276  incrementProfileCounter(&S);
1277 }
1278 
1279 namespace {
1280  struct CallEndCatchForFinally final : EHScopeStack::Cleanup {
1281  llvm::Value *ForEHVar;
1282  llvm::FunctionCallee EndCatchFn;
1283  CallEndCatchForFinally(llvm::Value *ForEHVar,
1284  llvm::FunctionCallee EndCatchFn)
1285  : ForEHVar(ForEHVar), EndCatchFn(EndCatchFn) {}
1286 
1287  void Emit(CodeGenFunction &CGF, Flags flags) override {
1288  llvm::BasicBlock *EndCatchBB = CGF.createBasicBlock("finally.endcatch");
1289  llvm::BasicBlock *CleanupContBB =
1290  CGF.createBasicBlock("finally.cleanup.cont");
1291 
1292  llvm::Value *ShouldEndCatch =
1293  CGF.Builder.CreateFlagLoad(ForEHVar, "finally.endcatch");
1294  CGF.Builder.CreateCondBr(ShouldEndCatch, EndCatchBB, CleanupContBB);
1295  CGF.EmitBlock(EndCatchBB);
1296  CGF.EmitRuntimeCallOrInvoke(EndCatchFn); // catch-all, so might throw
1297  CGF.EmitBlock(CleanupContBB);
1298  }
1299  };
1300 
1301  struct PerformFinally final : EHScopeStack::Cleanup {
1302  const Stmt *Body;
1303  llvm::Value *ForEHVar;
1304  llvm::FunctionCallee EndCatchFn;
1305  llvm::FunctionCallee RethrowFn;
1306  llvm::Value *SavedExnVar;
1307 
1308  PerformFinally(const Stmt *Body, llvm::Value *ForEHVar,
1309  llvm::FunctionCallee EndCatchFn,
1310  llvm::FunctionCallee RethrowFn, llvm::Value *SavedExnVar)
1311  : Body(Body), ForEHVar(ForEHVar), EndCatchFn(EndCatchFn),
1312  RethrowFn(RethrowFn), SavedExnVar(SavedExnVar) {}
1313 
1314  void Emit(CodeGenFunction &CGF, Flags flags) override {
1315  // Enter a cleanup to call the end-catch function if one was provided.
1316  if (EndCatchFn)
1317  CGF.EHStack.pushCleanup<CallEndCatchForFinally>(NormalAndEHCleanup,
1318  ForEHVar, EndCatchFn);
1319 
1320  // Save the current cleanup destination in case there are
1321  // cleanups in the finally block.
1322  llvm::Value *SavedCleanupDest =
1324  "cleanup.dest.saved");
1325 
1326  // Emit the finally block.
1327  CGF.EmitStmt(Body);
1328 
1329  // If the end of the finally is reachable, check whether this was
1330  // for EH. If so, rethrow.
1331  if (CGF.HaveInsertPoint()) {
1332  llvm::BasicBlock *RethrowBB = CGF.createBasicBlock("finally.rethrow");
1333  llvm::BasicBlock *ContBB = CGF.createBasicBlock("finally.cont");
1334 
1335  llvm::Value *ShouldRethrow =
1336  CGF.Builder.CreateFlagLoad(ForEHVar, "finally.shouldthrow");
1337  CGF.Builder.CreateCondBr(ShouldRethrow, RethrowBB, ContBB);
1338 
1339  CGF.EmitBlock(RethrowBB);
1340  if (SavedExnVar) {
1341  CGF.EmitRuntimeCallOrInvoke(RethrowFn,
1342  CGF.Builder.CreateAlignedLoad(SavedExnVar, CGF.getPointerAlign()));
1343  } else {
1344  CGF.EmitRuntimeCallOrInvoke(RethrowFn);
1345  }
1346  CGF.Builder.CreateUnreachable();
1347 
1348  CGF.EmitBlock(ContBB);
1349 
1350  // Restore the cleanup destination.
1351  CGF.Builder.CreateStore(SavedCleanupDest,
1352  CGF.getNormalCleanupDestSlot());
1353  }
1354 
1355  // Leave the end-catch cleanup. As an optimization, pretend that
1356  // the fallthrough path was inaccessible; we've dynamically proven
1357  // that we're not in the EH case along that path.
1358  if (EndCatchFn) {
1359  CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
1360  CGF.PopCleanupBlock();
1361  CGF.Builder.restoreIP(SavedIP);
1362  }
1363 
1364  // Now make sure we actually have an insertion point or the
1365  // cleanup gods will hate us.
1366  CGF.EnsureInsertPoint();
1367  }
1368  };
1369 } // end anonymous namespace
1370 
1371 /// Enters a finally block for an implementation using zero-cost
1372 /// exceptions. This is mostly general, but hard-codes some
1373 /// language/ABI-specific behavior in the catch-all sections.
1375  llvm::FunctionCallee beginCatchFn,
1376  llvm::FunctionCallee endCatchFn,
1377  llvm::FunctionCallee rethrowFn) {
1378  assert((!!beginCatchFn) == (!!endCatchFn) &&
1379  "begin/end catch functions not paired");
1380  assert(rethrowFn && "rethrow function is required");
1381 
1382  BeginCatchFn = beginCatchFn;
1383 
1384  // The rethrow function has one of the following two types:
1385  // void (*)()
1386  // void (*)(void*)
1387  // In the latter case we need to pass it the exception object.
1388  // But we can't use the exception slot because the @finally might
1389  // have a landing pad (which would overwrite the exception slot).
1390  llvm::FunctionType *rethrowFnTy = rethrowFn.getFunctionType();
1391  SavedExnVar = nullptr;
1392  if (rethrowFnTy->getNumParams())
1393  SavedExnVar = CGF.CreateTempAlloca(CGF.Int8PtrTy, "finally.exn");
1394 
1395  // A finally block is a statement which must be executed on any edge
1396  // out of a given scope. Unlike a cleanup, the finally block may
1397  // contain arbitrary control flow leading out of itself. In
1398  // addition, finally blocks should always be executed, even if there
1399  // are no catch handlers higher on the stack. Therefore, we
1400  // surround the protected scope with a combination of a normal
1401  // cleanup (to catch attempts to break out of the block via normal
1402  // control flow) and an EH catch-all (semantically "outside" any try
1403  // statement to which the finally block might have been attached).
1404  // The finally block itself is generated in the context of a cleanup
1405  // which conditionally leaves the catch-all.
1406 
1407  // Jump destination for performing the finally block on an exception
1408  // edge. We'll never actually reach this block, so unreachable is
1409  // fine.
1410  RethrowDest = CGF.getJumpDestInCurrentScope(CGF.getUnreachableBlock());
1411 
1412  // Whether the finally block is being executed for EH purposes.
1413  ForEHVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(), "finally.for-eh");
1414  CGF.Builder.CreateFlagStore(false, ForEHVar);
1415 
1416  // Enter a normal cleanup which will perform the @finally block.
1417  CGF.EHStack.pushCleanup<PerformFinally>(NormalCleanup, body,
1418  ForEHVar, endCatchFn,
1419  rethrowFn, SavedExnVar);
1420 
1421  // Enter a catch-all scope.
1422  llvm::BasicBlock *catchBB = CGF.createBasicBlock("finally.catchall");
1423  EHCatchScope *catchScope = CGF.EHStack.pushCatch(1);
1424  catchScope->setCatchAllHandler(0, catchBB);
1425 }
1426 
1428  // Leave the finally catch-all.
1429  EHCatchScope &catchScope = cast<EHCatchScope>(*CGF.EHStack.begin());
1430  llvm::BasicBlock *catchBB = catchScope.getHandler(0).Block;
1431 
1432  CGF.popCatchScope();
1433 
1434  // If there are any references to the catch-all block, emit it.
1435  if (catchBB->use_empty()) {
1436  delete catchBB;
1437  } else {
1438  CGBuilderTy::InsertPoint savedIP = CGF.Builder.saveAndClearIP();
1439  CGF.EmitBlock(catchBB);
1440 
1441  llvm::Value *exn = nullptr;
1442 
1443  // If there's a begin-catch function, call it.
1444  if (BeginCatchFn) {
1445  exn = CGF.getExceptionFromSlot();
1446  CGF.EmitNounwindRuntimeCall(BeginCatchFn, exn);
1447  }
1448 
1449  // If we need to remember the exception pointer to rethrow later, do so.
1450  if (SavedExnVar) {
1451  if (!exn) exn = CGF.getExceptionFromSlot();
1452  CGF.Builder.CreateAlignedStore(exn, SavedExnVar, CGF.getPointerAlign());
1453  }
1454 
1455  // Tell the cleanups in the finally block that we're do this for EH.
1456  CGF.Builder.CreateFlagStore(true, ForEHVar);
1457 
1458  // Thread a jump through the finally cleanup.
1459  CGF.EmitBranchThroughCleanup(RethrowDest);
1460 
1461  CGF.Builder.restoreIP(savedIP);
1462  }
1463 
1464  // Finally, leave the @finally cleanup.
1465  CGF.PopCleanupBlock();
1466 }
1467 
1469  if (TerminateLandingPad)
1470  return TerminateLandingPad;
1471 
1472  CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
1473 
1474  // This will get inserted at the end of the function.
1475  TerminateLandingPad = createBasicBlock("terminate.lpad");
1476  Builder.SetInsertPoint(TerminateLandingPad);
1477 
1478  // Tell the backend that this is a landing pad.
1479  const EHPersonality &Personality = EHPersonality::get(*this);
1480 
1481  if (!CurFn->hasPersonalityFn())
1482  CurFn->setPersonalityFn(getOpaquePersonalityFn(CGM, Personality));
1483 
1484  llvm::LandingPadInst *LPadInst =
1485  Builder.CreateLandingPad(llvm::StructType::get(Int8PtrTy, Int32Ty), 0);
1486  LPadInst->addClause(getCatchAllValue(*this));
1487 
1488  llvm::Value *Exn = nullptr;
1489  if (getLangOpts().CPlusPlus)
1490  Exn = Builder.CreateExtractValue(LPadInst, 0);
1491  llvm::CallInst *terminateCall =
1492  CGM.getCXXABI().emitTerminateForUnexpectedException(*this, Exn);
1493  terminateCall->setDoesNotReturn();
1494  Builder.CreateUnreachable();
1495 
1496  // Restore the saved insertion state.
1497  Builder.restoreIP(SavedIP);
1498 
1499  return TerminateLandingPad;
1500 }
1501 
1503  if (TerminateHandler)
1504  return TerminateHandler;
1505 
1506  // Set up the terminate handler. This block is inserted at the very
1507  // end of the function by FinishFunction.
1508  TerminateHandler = createBasicBlock("terminate.handler");
1509  CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
1510  Builder.SetInsertPoint(TerminateHandler);
1511 
1512  llvm::Value *Exn = nullptr;
1513  if (getLangOpts().CPlusPlus)
1514  Exn = getExceptionFromSlot();
1515  llvm::CallInst *terminateCall =
1516  CGM.getCXXABI().emitTerminateForUnexpectedException(*this, Exn);
1517  terminateCall->setDoesNotReturn();
1518  Builder.CreateUnreachable();
1519 
1520  // Restore the saved insertion state.
1521  Builder.restoreIP(SavedIP);
1522 
1523  return TerminateHandler;
1524 }
1525 
1527  assert(EHPersonality::get(*this).usesFuncletPads() &&
1528  "use getTerminateLandingPad for non-funclet EH");
1529 
1530  llvm::BasicBlock *&TerminateFunclet = TerminateFunclets[CurrentFuncletPad];
1531  if (TerminateFunclet)
1532  return TerminateFunclet;
1533 
1534  CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
1535 
1536  // Set up the terminate handler. This block is inserted at the very
1537  // end of the function by FinishFunction.
1538  TerminateFunclet = createBasicBlock("terminate.handler");
1539  Builder.SetInsertPoint(TerminateFunclet);
1540 
1541  // Create the cleanuppad using the current parent pad as its token. Use 'none'
1542  // if this is a top-level terminate scope, which is the common case.
1543  SaveAndRestore<llvm::Instruction *> RestoreCurrentFuncletPad(
1544  CurrentFuncletPad);
1545  llvm::Value *ParentPad = CurrentFuncletPad;
1546  if (!ParentPad)
1547  ParentPad = llvm::ConstantTokenNone::get(CGM.getLLVMContext());
1548  CurrentFuncletPad = Builder.CreateCleanupPad(ParentPad);
1549 
1550  // Emit the __std_terminate call.
1551  llvm::Value *Exn = nullptr;
1552  // In case of wasm personality, we need to pass the exception value to
1553  // __clang_call_terminate function.
1554  if (getLangOpts().CPlusPlus &&
1556  llvm::Function *GetExnFn =
1557  CGM.getIntrinsic(llvm::Intrinsic::wasm_get_exception);
1558  Exn = Builder.CreateCall(GetExnFn, CurrentFuncletPad);
1559  }
1560  llvm::CallInst *terminateCall =
1561  CGM.getCXXABI().emitTerminateForUnexpectedException(*this, Exn);
1562  terminateCall->setDoesNotReturn();
1563  Builder.CreateUnreachable();
1564 
1565  // Restore the saved insertion state.
1566  Builder.restoreIP(SavedIP);
1567 
1568  return TerminateFunclet;
1569 }
1570 
1571 llvm::BasicBlock *CodeGenFunction::getEHResumeBlock(bool isCleanup) {
1572  if (EHResumeBlock) return EHResumeBlock;
1573 
1574  CGBuilderTy::InsertPoint SavedIP = Builder.saveIP();
1575 
1576  // We emit a jump to a notional label at the outermost unwind state.
1577  EHResumeBlock = createBasicBlock("eh.resume");
1578  Builder.SetInsertPoint(EHResumeBlock);
1579 
1580  const EHPersonality &Personality = EHPersonality::get(*this);
1581 
1582  // This can always be a call because we necessarily didn't find
1583  // anything on the EH stack which needs our help.
1584  const char *RethrowName = Personality.CatchallRethrowFn;
1585  if (RethrowName != nullptr && !isCleanup) {
1586  EmitRuntimeCall(getCatchallRethrowFn(CGM, RethrowName),
1587  getExceptionFromSlot())->setDoesNotReturn();
1588  Builder.CreateUnreachable();
1589  Builder.restoreIP(SavedIP);
1590  return EHResumeBlock;
1591  }
1592 
1593  // Recreate the landingpad's return value for the 'resume' instruction.
1594  llvm::Value *Exn = getExceptionFromSlot();
1595  llvm::Value *Sel = getSelectorFromSlot();
1596 
1597  llvm::Type *LPadType = llvm::StructType::get(Exn->getType(), Sel->getType());
1598  llvm::Value *LPadVal = llvm::UndefValue::get(LPadType);
1599  LPadVal = Builder.CreateInsertValue(LPadVal, Exn, 0, "lpad.val");
1600  LPadVal = Builder.CreateInsertValue(LPadVal, Sel, 1, "lpad.val");
1601 
1602  Builder.CreateResume(LPadVal);
1603  Builder.restoreIP(SavedIP);
1604  return EHResumeBlock;
1605 }
1606 
1608  EnterSEHTryStmt(S);
1609  {
1610  JumpDest TryExit = getJumpDestInCurrentScope("__try.__leave");
1611 
1612  SEHTryEpilogueStack.push_back(&TryExit);
1613  EmitStmt(S.getTryBlock());
1614  SEHTryEpilogueStack.pop_back();
1615 
1616  if (!TryExit.getBlock()->use_empty())
1617  EmitBlock(TryExit.getBlock(), /*IsFinished=*/true);
1618  else
1619  delete TryExit.getBlock();
1620  }
1621  ExitSEHTryStmt(S);
1622 }
1623 
1624 namespace {
1625 struct PerformSEHFinally final : EHScopeStack::Cleanup {
1626  llvm::Function *OutlinedFinally;
1627  PerformSEHFinally(llvm::Function *OutlinedFinally)
1628  : OutlinedFinally(OutlinedFinally) {}
1629 
1630  void Emit(CodeGenFunction &CGF, Flags F) override {
1631  ASTContext &Context = CGF.getContext();
1632  CodeGenModule &CGM = CGF.CGM;
1633 
1634  CallArgList Args;
1635 
1636  // Compute the two argument values.
1637  QualType ArgTys[2] = {Context.UnsignedCharTy, Context.VoidPtrTy};
1638  llvm::Value *FP = nullptr;
1639  // If CFG.IsOutlinedSEHHelper is true, then we are within a finally block.
1640  if (CGF.IsOutlinedSEHHelper) {
1641  FP = &CGF.CurFn->arg_begin()[1];
1642  } else {
1643  llvm::Function *LocalAddrFn =
1644  CGM.getIntrinsic(llvm::Intrinsic::localaddress);
1645  FP = CGF.Builder.CreateCall(LocalAddrFn);
1646  }
1647 
1648  llvm::Value *IsForEH =
1649  llvm::ConstantInt::get(CGF.ConvertType(ArgTys[0]), F.isForEHCleanup());
1650 
1651  // Except _leave and fall-through at the end, all other exits in a _try
1652  // (return/goto/continue/break) are considered as abnormal terminations
1653  // since _leave/fall-through is always Indexed 0,
1654  // just use NormalCleanupDestSlot (>= 1 for goto/return/..),
1655  // as 1st Arg to indicate abnormal termination
1656  if (!F.isForEHCleanup() && F.hasExitSwitch()) {
1657  Address Addr = CGF.getNormalCleanupDestSlot();
1658  llvm::Value *Load = CGF.Builder.CreateLoad(Addr, "cleanup.dest");
1659  llvm::Value *Zero = llvm::Constant::getNullValue(CGM.Int32Ty);
1660  IsForEH = CGF.Builder.CreateICmpNE(Load, Zero);
1661  }
1662 
1663  Args.add(RValue::get(IsForEH), ArgTys[0]);
1664  Args.add(RValue::get(FP), ArgTys[1]);
1665 
1666  // Arrange a two-arg function info and type.
1667  const CGFunctionInfo &FnInfo =
1668  CGM.getTypes().arrangeBuiltinFunctionCall(Context.VoidTy, Args);
1669 
1670  auto Callee = CGCallee::forDirect(OutlinedFinally);
1671  CGF.EmitCall(FnInfo, Callee, ReturnValueSlot(), Args);
1672  }
1673 };
1674 } // end anonymous namespace
1675 
1676 namespace {
1677 /// Find all local variable captures in the statement.
1678 struct CaptureFinder : ConstStmtVisitor<CaptureFinder> {
1679  CodeGenFunction &ParentCGF;
1680  const VarDecl *ParentThis;
1682  Address SEHCodeSlot = Address::invalid();
1683  CaptureFinder(CodeGenFunction &ParentCGF, const VarDecl *ParentThis)
1684  : ParentCGF(ParentCGF), ParentThis(ParentThis) {}
1685 
1686  // Return true if we need to do any capturing work.
1687  bool foundCaptures() {
1688  return !Captures.empty() || SEHCodeSlot.isValid();
1689  }
1690 
1691  void Visit(const Stmt *S) {
1692  // See if this is a capture, then recurse.
1694  for (const Stmt *Child : S->children())
1695  if (Child)
1696  Visit(Child);
1697  }
1698 
1699  void VisitDeclRefExpr(const DeclRefExpr *E) {
1700  // If this is already a capture, just make sure we capture 'this'.
1702  Captures.insert(ParentThis);
1703  return;
1704  }
1705 
1706  const auto *D = dyn_cast<VarDecl>(E->getDecl());
1707  if (D && D->isLocalVarDeclOrParm() && D->hasLocalStorage())
1708  Captures.insert(D);
1709  }
1710 
1711  void VisitCXXThisExpr(const CXXThisExpr *E) {
1712  Captures.insert(ParentThis);
1713  }
1714 
1715  void VisitCallExpr(const CallExpr *E) {
1716  // We only need to add parent frame allocations for these builtins in x86.
1717  if (ParentCGF.getTarget().getTriple().getArch() != llvm::Triple::x86)
1718  return;
1719 
1720  unsigned ID = E->getBuiltinCallee();
1721  switch (ID) {
1722  case Builtin::BI__exception_code:
1723  case Builtin::BI_exception_code:
1724  // This is the simple case where we are the outermost finally. All we
1725  // have to do here is make sure we escape this and recover it in the
1726  // outlined handler.
1727  if (!SEHCodeSlot.isValid())
1728  SEHCodeSlot = ParentCGF.SEHCodeSlotStack.back();
1729  break;
1730  }
1731  }
1732 };
1733 } // end anonymous namespace
1734 
1736  Address ParentVar,
1737  llvm::Value *ParentFP) {
1738  llvm::CallInst *RecoverCall = nullptr;
1739  CGBuilderTy Builder(*this, AllocaInsertPt);
1740  if (auto *ParentAlloca = dyn_cast<llvm::AllocaInst>(ParentVar.getPointer())) {
1741  // Mark the variable escaped if nobody else referenced it and compute the
1742  // localescape index.
1743  auto InsertPair = ParentCGF.EscapedLocals.insert(
1744  std::make_pair(ParentAlloca, ParentCGF.EscapedLocals.size()));
1745  int FrameEscapeIdx = InsertPair.first->second;
1746  // call i8* @llvm.localrecover(i8* bitcast(@parentFn), i8* %fp, i32 N)
1747  llvm::Function *FrameRecoverFn = llvm::Intrinsic::getDeclaration(
1748  &CGM.getModule(), llvm::Intrinsic::localrecover);
1749  llvm::Constant *ParentI8Fn =
1750  llvm::ConstantExpr::getBitCast(ParentCGF.CurFn, Int8PtrTy);
1751  RecoverCall = Builder.CreateCall(
1752  FrameRecoverFn, {ParentI8Fn, ParentFP,
1753  llvm::ConstantInt::get(Int32Ty, FrameEscapeIdx)});
1754 
1755  } else {
1756  // If the parent didn't have an alloca, we're doing some nested outlining.
1757  // Just clone the existing localrecover call, but tweak the FP argument to
1758  // use our FP value. All other arguments are constants.
1759  auto *ParentRecover =
1760  cast<llvm::IntrinsicInst>(ParentVar.getPointer()->stripPointerCasts());
1761  assert(ParentRecover->getIntrinsicID() == llvm::Intrinsic::localrecover &&
1762  "expected alloca or localrecover in parent LocalDeclMap");
1763  RecoverCall = cast<llvm::CallInst>(ParentRecover->clone());
1764  RecoverCall->setArgOperand(1, ParentFP);
1765  RecoverCall->insertBefore(AllocaInsertPt);
1766  }
1767 
1768  // Bitcast the variable, rename it, and insert it in the local decl map.
1769  llvm::Value *ChildVar =
1770  Builder.CreateBitCast(RecoverCall, ParentVar.getType());
1771  ChildVar->setName(ParentVar.getName());
1772  return Address(ChildVar, ParentVar.getAlignment());
1773 }
1774 
1776  const Stmt *OutlinedStmt,
1777  bool IsFilter) {
1778  // Find all captures in the Stmt.
1779  CaptureFinder Finder(ParentCGF, ParentCGF.CXXABIThisDecl);
1780  Finder.Visit(OutlinedStmt);
1781 
1782  // We can exit early on x86_64 when there are no captures. We just have to
1783  // save the exception code in filters so that __exception_code() works.
1784  if (!Finder.foundCaptures() &&
1785  CGM.getTarget().getTriple().getArch() != llvm::Triple::x86) {
1786  if (IsFilter)
1787  EmitSEHExceptionCodeSave(ParentCGF, nullptr, nullptr);
1788  return;
1789  }
1790 
1791  llvm::Value *EntryFP = nullptr;
1792  CGBuilderTy Builder(CGM, AllocaInsertPt);
1793  if (IsFilter && CGM.getTarget().getTriple().getArch() == llvm::Triple::x86) {
1794  // 32-bit SEH filters need to be careful about FP recovery. The end of the
1795  // EH registration is passed in as the EBP physical register. We can
1796  // recover that with llvm.frameaddress(1).
1797  EntryFP = Builder.CreateCall(
1798  CGM.getIntrinsic(llvm::Intrinsic::frameaddress, AllocaInt8PtrTy),
1799  {Builder.getInt32(1)});
1800  } else {
1801  // Otherwise, for x64 and 32-bit finally functions, the parent FP is the
1802  // second parameter.
1803  auto AI = CurFn->arg_begin();
1804  ++AI;
1805  EntryFP = &*AI;
1806  }
1807 
1808  llvm::Value *ParentFP = EntryFP;
1809  if (IsFilter) {
1810  // Given whatever FP the runtime provided us in EntryFP, recover the true
1811  // frame pointer of the parent function. We only need to do this in filters,
1812  // since finally funclets recover the parent FP for us.
1813  llvm::Function *RecoverFPIntrin =
1814  CGM.getIntrinsic(llvm::Intrinsic::eh_recoverfp);
1815  llvm::Constant *ParentI8Fn =
1816  llvm::ConstantExpr::getBitCast(ParentCGF.CurFn, Int8PtrTy);
1817  ParentFP = Builder.CreateCall(RecoverFPIntrin, {ParentI8Fn, EntryFP});
1818  }
1819 
1820  // Create llvm.localrecover calls for all captures.
1821  for (const VarDecl *VD : Finder.Captures) {
1822  if (isa<ImplicitParamDecl>(VD)) {
1823  CGM.ErrorUnsupported(VD, "'this' captured by SEH");
1824  CXXThisValue = llvm::UndefValue::get(ConvertTypeForMem(VD->getType()));
1825  continue;
1826  }
1827  if (VD->getType()->isVariablyModifiedType()) {
1828  CGM.ErrorUnsupported(VD, "VLA captured by SEH");
1829  continue;
1830  }
1831  assert((isa<ImplicitParamDecl>(VD) || VD->isLocalVarDeclOrParm()) &&
1832  "captured non-local variable");
1833 
1834  // If this decl hasn't been declared yet, it will be declared in the
1835  // OutlinedStmt.
1836  auto I = ParentCGF.LocalDeclMap.find(VD);
1837  if (I == ParentCGF.LocalDeclMap.end())
1838  continue;
1839 
1840  Address ParentVar = I->second;
1841  setAddrOfLocalVar(
1842  VD, recoverAddrOfEscapedLocal(ParentCGF, ParentVar, ParentFP));
1843  }
1844 
1845  if (Finder.SEHCodeSlot.isValid()) {
1846  SEHCodeSlotStack.push_back(
1847  recoverAddrOfEscapedLocal(ParentCGF, Finder.SEHCodeSlot, ParentFP));
1848  }
1849 
1850  if (IsFilter)
1851  EmitSEHExceptionCodeSave(ParentCGF, ParentFP, EntryFP);
1852 }
1853 
1854 /// Arrange a function prototype that can be called by Windows exception
1855 /// handling personalities. On Win64, the prototype looks like:
1856 /// RetTy func(void *EHPtrs, void *ParentFP);
1858  bool IsFilter,
1859  const Stmt *OutlinedStmt) {
1860  SourceLocation StartLoc = OutlinedStmt->getBeginLoc();
1861 
1862  // Get the mangled function name.
1863  SmallString<128> Name;
1864  {
1865  llvm::raw_svector_ostream OS(Name);
1866  const NamedDecl *ParentSEHFn = ParentCGF.CurSEHParent;
1867  assert(ParentSEHFn && "No CurSEHParent!");
1868  MangleContext &Mangler = CGM.getCXXABI().getMangleContext();
1869  if (IsFilter)
1870  Mangler.mangleSEHFilterExpression(ParentSEHFn, OS);
1871  else
1872  Mangler.mangleSEHFinallyBlock(ParentSEHFn, OS);
1873  }
1874 
1875  FunctionArgList Args;
1876  if (CGM.getTarget().getTriple().getArch() != llvm::Triple::x86 || !IsFilter) {
1877  // All SEH finally functions take two parameters. Win64 filters take two
1878  // parameters. Win32 filters take no parameters.
1879  if (IsFilter) {
1880  Args.push_back(ImplicitParamDecl::Create(
1881  getContext(), /*DC=*/nullptr, StartLoc,
1882  &getContext().Idents.get("exception_pointers"),
1884  } else {
1885  Args.push_back(ImplicitParamDecl::Create(
1886  getContext(), /*DC=*/nullptr, StartLoc,
1887  &getContext().Idents.get("abnormal_termination"),
1889  }
1890  Args.push_back(ImplicitParamDecl::Create(
1891  getContext(), /*DC=*/nullptr, StartLoc,
1892  &getContext().Idents.get("frame_pointer"), getContext().VoidPtrTy,
1894  }
1895 
1896  QualType RetTy = IsFilter ? getContext().LongTy : getContext().VoidTy;
1897 
1898  const CGFunctionInfo &FnInfo =
1899  CGM.getTypes().arrangeBuiltinFunctionDeclaration(RetTy, Args);
1900 
1901  llvm::FunctionType *FnTy = CGM.getTypes().GetFunctionType(FnInfo);
1902  llvm::Function *Fn = llvm::Function::Create(
1903  FnTy, llvm::GlobalValue::InternalLinkage, Name.str(), &CGM.getModule());
1904 
1905  IsOutlinedSEHHelper = true;
1906 
1907  StartFunction(GlobalDecl(), RetTy, Fn, FnInfo, Args,
1908  OutlinedStmt->getBeginLoc(), OutlinedStmt->getBeginLoc());
1909  CurSEHParent = ParentCGF.CurSEHParent;
1910 
1911  CGM.SetInternalFunctionAttributes(GlobalDecl(), CurFn, FnInfo);
1912  EmitCapturedLocals(ParentCGF, OutlinedStmt, IsFilter);
1913 }
1914 
1915 /// Create a stub filter function that will ultimately hold the code of the
1916 /// filter expression. The EH preparation passes in LLVM will outline the code
1917 /// from the main function body into this stub.
1918 llvm::Function *
1920  const SEHExceptStmt &Except) {
1921  const Expr *FilterExpr = Except.getFilterExpr();
1922  startOutlinedSEHHelper(ParentCGF, true, FilterExpr);
1923 
1924  // Emit the original filter expression, convert to i32, and return.
1925  llvm::Value *R = EmitScalarExpr(FilterExpr);
1926  R = Builder.CreateIntCast(R, ConvertType(getContext().LongTy),
1927  FilterExpr->getType()->isSignedIntegerType());
1928  Builder.CreateStore(R, ReturnValue);
1929 
1930  FinishFunction(FilterExpr->getEndLoc());
1931 
1932  return CurFn;
1933 }
1934 
1935 llvm::Function *
1937  const SEHFinallyStmt &Finally) {
1938  const Stmt *FinallyBlock = Finally.getBlock();
1939  startOutlinedSEHHelper(ParentCGF, false, FinallyBlock);
1940 
1941  // Emit the original filter expression, convert to i32, and return.
1942  EmitStmt(FinallyBlock);
1943 
1944  FinishFunction(FinallyBlock->getEndLoc());
1945 
1946  return CurFn;
1947 }
1948 
1950  llvm::Value *ParentFP,
1951  llvm::Value *EntryFP) {
1952  // Get the pointer to the EXCEPTION_POINTERS struct. This is returned by the
1953  // __exception_info intrinsic.
1954  if (CGM.getTarget().getTriple().getArch() != llvm::Triple::x86) {
1955  // On Win64, the info is passed as the first parameter to the filter.
1956  SEHInfo = &*CurFn->arg_begin();
1957  SEHCodeSlotStack.push_back(
1958  CreateMemTemp(getContext().IntTy, "__exception_code"));
1959  } else {
1960  // On Win32, the EBP on entry to the filter points to the end of an
1961  // exception registration object. It contains 6 32-bit fields, and the info
1962  // pointer is stored in the second field. So, GEP 20 bytes backwards and
1963  // load the pointer.
1964  SEHInfo = Builder.CreateConstInBoundsGEP1_32(Int8Ty, EntryFP, -20);
1965  SEHInfo = Builder.CreateBitCast(SEHInfo, Int8PtrTy->getPointerTo());
1966  SEHInfo = Builder.CreateAlignedLoad(Int8PtrTy, SEHInfo, getPointerAlign());
1967  SEHCodeSlotStack.push_back(recoverAddrOfEscapedLocal(
1968  ParentCGF, ParentCGF.SEHCodeSlotStack.back(), ParentFP));
1969  }
1970 
1971  // Save the exception code in the exception slot to unify exception access in
1972  // the filter function and the landing pad.
1973  // struct EXCEPTION_POINTERS {
1974  // EXCEPTION_RECORD *ExceptionRecord;
1975  // CONTEXT *ContextRecord;
1976  // };
1977  // int exceptioncode = exception_pointers->ExceptionRecord->ExceptionCode;
1978  llvm::Type *RecordTy = CGM.Int32Ty->getPointerTo();
1979  llvm::Type *PtrsTy = llvm::StructType::get(RecordTy, CGM.VoidPtrTy);
1980  llvm::Value *Ptrs = Builder.CreateBitCast(SEHInfo, PtrsTy->getPointerTo());
1981  llvm::Value *Rec = Builder.CreateStructGEP(PtrsTy, Ptrs, 0);
1982  Rec = Builder.CreateAlignedLoad(Rec, getPointerAlign());
1983  llvm::Value *Code = Builder.CreateAlignedLoad(Rec, getIntAlign());
1984  assert(!SEHCodeSlotStack.empty() && "emitting EH code outside of __except");
1985  Builder.CreateStore(Code, SEHCodeSlotStack.back());
1986 }
1987 
1989  // Sema should diagnose calling this builtin outside of a filter context, but
1990  // don't crash if we screw up.
1991  if (!SEHInfo)
1992  return llvm::UndefValue::get(Int8PtrTy);
1993  assert(SEHInfo->getType() == Int8PtrTy);
1994  return SEHInfo;
1995 }
1996 
1998  assert(!SEHCodeSlotStack.empty() && "emitting EH code outside of __except");
1999  return Builder.CreateLoad(SEHCodeSlotStack.back());
2000 }
2001 
2003  // Abnormal termination is just the first parameter to the outlined finally
2004  // helper.
2005  auto AI = CurFn->arg_begin();
2006  return Builder.CreateZExt(&*AI, Int32Ty);
2007 }
2008 
2010  llvm::Function *FinallyFunc) {
2011  EHStack.pushCleanup<PerformSEHFinally>(Kind, FinallyFunc);
2012 }
2013 
2015  CodeGenFunction HelperCGF(CGM, /*suppressNewContext=*/true);
2016  if (const SEHFinallyStmt *Finally = S.getFinallyHandler()) {
2017  // Outline the finally block.
2018  llvm::Function *FinallyFunc =
2019  HelperCGF.GenerateSEHFinallyFunction(*this, *Finally);
2020 
2021  // Push a cleanup for __finally blocks.
2022  EHStack.pushCleanup<PerformSEHFinally>(NormalAndEHCleanup, FinallyFunc);
2023  return;
2024  }
2025 
2026  // Otherwise, we must have an __except block.
2027  const SEHExceptStmt *Except = S.getExceptHandler();
2028  assert(Except);
2029  EHCatchScope *CatchScope = EHStack.pushCatch(1);
2030  SEHCodeSlotStack.push_back(
2031  CreateMemTemp(getContext().IntTy, "__exception_code"));
2032 
2033  // If the filter is known to evaluate to 1, then we can use the clause
2034  // "catch i8* null". We can't do this on x86 because the filter has to save
2035  // the exception code.
2036  llvm::Constant *C =
2038  getContext().IntTy);
2039  if (CGM.getTarget().getTriple().getArch() != llvm::Triple::x86 && C &&
2040  C->isOneValue()) {
2041  CatchScope->setCatchAllHandler(0, createBasicBlock("__except"));
2042  return;
2043  }
2044 
2045  // In general, we have to emit an outlined filter function. Use the function
2046  // in place of the RTTI typeinfo global that C++ EH uses.
2047  llvm::Function *FilterFunc =
2048  HelperCGF.GenerateSEHFilterFunction(*this, *Except);
2049  llvm::Constant *OpaqueFunc =
2050  llvm::ConstantExpr::getBitCast(FilterFunc, Int8PtrTy);
2051  CatchScope->setHandler(0, OpaqueFunc, createBasicBlock("__except.ret"));
2052 }
2053 
2055  // Just pop the cleanup if it's a __finally block.
2056  if (S.getFinallyHandler()) {
2057  PopCleanupBlock();
2058  return;
2059  }
2060 
2061  // Otherwise, we must have an __except block.
2062  const SEHExceptStmt *Except = S.getExceptHandler();
2063  assert(Except && "__try must have __finally xor __except");
2064  EHCatchScope &CatchScope = cast<EHCatchScope>(*EHStack.begin());
2065 
2066  // Don't emit the __except block if the __try block lacked invokes.
2067  // TODO: Model unwind edges from instructions, either with iload / istore or
2068  // a try body function.
2069  if (!CatchScope.hasEHBranches()) {
2070  CatchScope.clearHandlerBlocks();
2071  EHStack.popCatch();
2072  SEHCodeSlotStack.pop_back();
2073  return;
2074  }
2075 
2076  // The fall-through block.
2077  llvm::BasicBlock *ContBB = createBasicBlock("__try.cont");
2078 
2079  // We just emitted the body of the __try; jump to the continue block.
2080  if (HaveInsertPoint())
2081  Builder.CreateBr(ContBB);
2082 
2083  // Check if our filter function returned true.
2084  emitCatchDispatchBlock(*this, CatchScope);
2085 
2086  // Grab the block before we pop the handler.
2087  llvm::BasicBlock *CatchPadBB = CatchScope.getHandler(0).Block;
2088  EHStack.popCatch();
2089 
2090  EmitBlockAfterUses(CatchPadBB);
2091 
2092  // __except blocks don't get outlined into funclets, so immediately do a
2093  // catchret.
2094  llvm::CatchPadInst *CPI =
2095  cast<llvm::CatchPadInst>(CatchPadBB->getFirstNonPHI());
2096  llvm::BasicBlock *ExceptBB = createBasicBlock("__except");
2097  Builder.CreateCatchRet(CPI, ExceptBB);
2098  EmitBlock(ExceptBB);
2099 
2100  // On Win64, the exception code is returned in EAX. Copy it into the slot.
2101  if (CGM.getTarget().getTriple().getArch() != llvm::Triple::x86) {
2102  llvm::Function *SEHCodeIntrin =
2103  CGM.getIntrinsic(llvm::Intrinsic::eh_exceptioncode);
2104  llvm::Value *Code = Builder.CreateCall(SEHCodeIntrin, {CPI});
2105  Builder.CreateStore(Code, SEHCodeSlotStack.back());
2106  }
2107 
2108  // Emit the __except body.
2109  EmitStmt(Except->getBlock());
2110 
2111  // End the lifetime of the exception code.
2112  SEHCodeSlotStack.pop_back();
2113 
2114  if (HaveInsertPoint())
2115  Builder.CreateBr(ContBB);
2116 
2117  EmitBlock(ContBB);
2118 }
2119 
2121  // If this code is reachable then emit a stop point (if generating
2122  // debug info). We have to do this ourselves because we are on the
2123  // "simple" statement path.
2124  if (HaveInsertPoint())
2125  EmitStopPoint(&S);
2126 
2127  // This must be a __leave from a __finally block, which we warn on and is UB.
2128  // Just emit unreachable.
2129  if (!isSEHTryScope()) {
2130  Builder.CreateUnreachable();
2131  Builder.ClearInsertionPoint();
2132  return;
2133  }
2134 
2135  EmitBranchThroughCleanup(*SEHTryEpilogueStack.back());
2136 }
virtual void mangleSEHFilterExpression(const NamedDecl *EnclosingDecl, raw_ostream &Out)=0
const llvm::DataLayout & getDataLayout() const
ReturnValueSlot - Contains the address where the return value of a function can be stored...
Definition: CGCall.h:360
static llvm::FunctionCallee getFreeExceptionFn(CodeGenModule &CGM)
Definition: CGException.cpp:33
Represents a function declaration or definition.
Definition: Decl.h:1783
llvm::IntegerType * IntTy
int
EHScopeStack::stable_iterator getEnclosingEHScope() const
Definition: CGCleanup.h:137
Other implicit parameter.
Definition: Decl.h:1555
CompoundStmt * getBlock() const
Definition: Stmt.h:3310
Smart pointer class that efficiently represents Objective-C method names.
void setCatchAllHandler(unsigned I, llvm::BasicBlock *Block)
Definition: CGCleanup.h:192
CanQualType VoidPtrTy
Definition: ASTContext.h:971
A (possibly-)qualified type.
Definition: Type.h:655
void EmitSEHLeaveStmt(const SEHLeaveStmt &S)
bool usesFuncletPads() const
Does this personality use landingpads or the family of pad instructions designed to form funclets...
Definition: CGCleanup.h:618
unsigned getNumExceptions() const
Return the number of types in the exception specification.
Definition: Type.h:4164
const Expr * getSubExpr() const
Definition: ExprCXX.h:1167
ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:193
llvm::BasicBlock * getCachedEHDispatchBlock() const
Definition: CGCleanup.h:123
bool HaveInsertPoint() const
HaveInsertPoint - True if an insertion point is defined.
llvm::LLVMContext & getLLVMContext()
static const EHPersonality GNU_C_SJLJ
Definition: CGCleanup.h:600
void enter(CodeGenFunction &CGF, const Stmt *Finally, llvm::FunctionCallee beginCatchFn, llvm::FunctionCallee endCatchFn, llvm::FunctionCallee rethrowFn)
Enters a finally block for an implementation using zero-cost exceptions.
void EmitCXXTryStmt(const CXXTryStmt &S)
Stmt - This represents one statement.
Definition: Stmt.h:68
CXXCatchStmt * getHandler(unsigned i)
Definition: StmtCXX.h:107
static const EHPersonality MSVC_C_specific_handler
Definition: CGCleanup.h:612
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:1060
static const EHPersonality MSVC_CxxFrameHandler3
Definition: CGCleanup.h:613
tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code, ArrayRef< tooling::Range > Ranges, StringRef FileName="<stdin>")
Clean up any erroneous/redundant code in the given Ranges in Code.
Definition: Format.cpp:2670
bool hasEHBranches() const
Definition: CGCleanup.h:131
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:89
Stmt * getHandlerBlock() const
Definition: StmtCXX.h:51
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
static const EHPersonality GNU_C
Definition: CGCleanup.h:599
virtual void mangleSEHFinallyBlock(const NamedDecl *EnclosingDecl, raw_ostream &Out)=0
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
Definition: Type.h:6598
Represents Objective-C&#39;s @throw statement.
Definition: StmtObjC.h:332
CanQualType LongTy
Definition: ASTContext.h:951
void EmitSEHExceptionCodeSave(CodeGenFunction &ParentCGF, llvm::Value *ParentFP, llvm::Value *EntryEBP)
bool usesSEHTry() const
Indicates the function uses __try.
Definition: Decl.h:2231
static const EHPersonality & getObjCXXPersonality(const TargetInfo &Target, const LangOptions &L)
Determines the personality function to use when both C++ and Objective-C exceptions are being caught...
unsigned getNumFilters() const
Definition: CGCleanup.h:460
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
&#39;gcc&#39; is the Objective-C runtime shipped with GCC, implementing a fragile Objective-C ABI ...
Definition: ObjCRuntime.h:52
bool ReturnValue(const T &V, APValue &R)
Convers a value to an APValue.
Definition: Interp.h:41
Represents a variable declaration or definition.
Definition: Decl.h:820
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:7153
llvm::FunctionCallee getTerminateFn()
Get the declaration of std::terminate for the platform.
Definition: CGException.cpp:51
unsigned getNumHandlers() const
Definition: CGCleanup.h:188
llvm::Value * getPointer() const
Definition: Address.h:37
iterator begin() const
Returns an iterator pointing to the innermost EH scope.
Definition: CGCleanup.h:551
llvm::BasicBlock * EmitLandingPad()
Emits a landing pad for the current EH stack.
A protected scope for zero-cost EH handling.
Definition: CGCleanup.h:43
Defines the Objective-C statement AST node classes.
A C++ throw-expression (C++ [except.throw]).
Definition: ExprCXX.h:1147
static const EHPersonality & getObjCPersonality(const TargetInfo &Target, const LangOptions &L)
A scope which attempts to handle some, possibly all, types of exceptions.
Definition: CGCleanup.h:147
The collection of all-type qualifiers we support.
Definition: Type.h:144
void add(RValue rvalue, QualType type)
Definition: CGCall.h:286
A jump destination is an abstract label, branching to which may require a jump out through normal cle...
bool isNoexceptExceptionSpec(ExceptionSpecificationType ESpecType)
void popCatchScope()
popCatchScope - Pops the catch scope at the top of the EHScope stack, emitting any required code (oth...
const TargetInfo & getTarget() const
llvm::BasicBlock * getTerminateHandler()
getTerminateHandler - Return a handler (not a landing pad, just a catch handler) that just calls term...
&#39;macosx-fragile&#39; is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...
Definition: ObjCRuntime.h:39
const char * CatchallRethrowFn
Definition: CGCleanup.h:594
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:174
QualType getCaughtType() const
Definition: StmtCXX.cpp:19
SmallVector< Address, 1 > SEHCodeSlotStack
A stack of exception code slots.
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:275
static const EHPersonality GNU_CPlusPlus_SJLJ
Definition: CGCleanup.h:609
bool Zero(InterpState &S, CodePtr OpPC)
Definition: Interp.h:812
Denotes a cleanup that should run when a scope is exited using exceptional control flow (a throw stat...
Definition: EHScopeStack.h:80
static const EHPersonality & get(CodeGenModule &CGM, const FunctionDecl *FD)
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:54
Address getExceptionSlot()
Returns a pointer to the function&#39;s exception object and selector slot, which is assigned in every la...
void setFilter(unsigned i, llvm::Value *filterValue)
Definition: CGCleanup.h:462
class EHCatchScope * pushCatch(unsigned NumHandlers)
Push a set of catch handlers on the stack.
Definition: CGCleanup.cpp:242
bool isNeXTFamily() const
Is this runtime basically of the NeXT family of runtimes?
Definition: ObjCRuntime.h:134
static llvm::Constant * getCatchAllValue(CodeGenFunction &CGF)
Returns the value to inject into a selector to indicate the presence of a catch-all.
void ExitSEHTryStmt(const SEHTryStmt &S)
llvm::CallInst * EmitRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
QualType getExceptionType(unsigned i) const
Return the ith exception type, where 0 <= i < getNumExceptions().
Definition: Type.h:4172
iterator begin() const
Definition: CGCleanup.h:223
CharUnits getAlignment() const
Return the alignment of this pointer.
Definition: Address.h:66
child_range children()
Definition: Stmt.cpp:224
const Handler & getHandler(unsigned I) const
Definition: CGCleanup.h:208
static llvm::FunctionCallee getUnexpectedFn(CodeGenModule &CGM)
Definition: CGException.cpp:42
static const EHPersonality GNUstep_ObjC
Definition: CGCleanup.h:605
RangeSelector name(std::string ID)
Given a node with a "name", (like NamedDecl, DeclRefExpr or CxxCtorInitializer) selects the name&#39;s to...
bool IsOutlinedSEHHelper
True if the current function is an outlined SEH helper.
llvm::BasicBlock * getInvokeDestImpl()
llvm::Function * GenerateSEHFinallyFunction(CodeGenFunction &ParentCGF, const SEHFinallyStmt &Finally)
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
Denotes a cleanup that should run when a scope is exited using normal control flow (falling off the e...
Definition: EHScopeStack.h:84
void ForceCleanup(std::initializer_list< llvm::Value **> ValuesToReload={})
Force the emission of cleanups now, instead of waiting until this object is destroyed.
SourceRange getExceptionSpecSourceRange() const
Attempt to compute an informative source range covering the function exception specification, if any.
Definition: Decl.cpp:3441
Represents the body of a CapturedStmt, and serves as its DeclContext.
Definition: Decl.h:4253
llvm::AllocaInst * CreateTempAlloca(llvm::Type *Ty, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr)
CreateTempAlloca - This creates an alloca and inserts it into the entry block if ArraySize is nullptr...
Definition: CGExpr.cpp:107
CanQualType UnsignedCharTy
Definition: ASTContext.h:952
Represents the this expression in C++.
Definition: ExprCXX.h:1108
static ImplicitParamDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, ImplicitParamKind ParamKind)
Create implicit parameter.
Definition: Decl.cpp:4717
&#39;watchos&#39; is a variant of iOS for Apple&#39;s watchOS.
Definition: ObjCRuntime.h:48
bool isValid() const
Definition: Address.h:35
static const EHPersonality & getCPersonality(const TargetInfo &Target, const LangOptions &L)
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3886
static const EHPersonality MSVC_except_handler
Definition: CGCleanup.h:611
static llvm::Constant * getOpaquePersonalityFn(CodeGenModule &CGM, const EHPersonality &Personality)
Exposes information about the current target.
Definition: TargetInfo.h:179
CatchTypeInfo Type
A type info value, or null (C++ null, not an LLVM null pointer) for a catch-all.
Definition: CGCleanup.h:157
void EmitCapturedLocals(CodeGenFunction &ParentCGF, const Stmt *OutlinedStmt, bool IsFilter)
Scan the outlined statement for captures from the parent function.
This represents one expression.
Definition: Expr.h:110
static bool PersonalityHasOnlyCXXUses(llvm::Constant *Fn)
Check whether a personality function could reasonably be swapped for a C++ personality function...
static llvm::FunctionCallee getPersonalityFn(CodeGenModule &CGM, const EHPersonality &Personality)
&#39;macosx&#39; is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the non-fragile AB...
Definition: ObjCRuntime.h:34
static Address invalid()
Definition: Address.h:34
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)
Create a stub filter function that will ultimately hold the code of the filter expression.
static CGCallee forDirect(llvm::Constant *functionPtr, const CGCalleeInfo &abstractInfo=CGCalleeInfo())
Definition: CGCall.h:134
VarDecl * getExceptionDecl() const
Definition: StmtCXX.h:49
llvm::PointerType * getType() const
Return the type of the pointer value.
Definition: Address.h:43
void EmitSEHTryStmt(const SEHTryStmt &S)
void pushSEHCleanup(CleanupKind kind, llvm::Function *FinallyFunc)
llvm::BasicBlock * Block
The catch handler for this type.
Definition: CGCleanup.h:160
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition: CharUnits.h:63
CXXTryStmt - A C++ try block, including all handlers.
Definition: StmtCXX.h:68
bool refersToEnclosingVariableOrCapture() const
Does this DeclRefExpr refer to an enclosing local or a captured variable?
Definition: Expr.h:1380
llvm::Value * getExceptionFromSlot()
Returns the contents of the function&#39;s exception object and selector slots.
static void emitCatchDispatchBlock(CodeGenFunction &CGF, EHCatchScope &catchScope)
Emit the structure of the dispatch block for the given catch scope.
llvm::LLVMContext & getLLVMContext()
const CGFunctionInfo & arrangeBuiltinFunctionCall(QualType resultType, const CallArgList &args)
Definition: CGCall.cpp:641
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], or an enum decl which has a signed representation.
Definition: Type.cpp:2008
QualType getType() const
Definition: Expr.h:142
static const EHPersonality GNU_ObjCXX
Definition: CGCleanup.h:606
bool hasTerminate() const
Does this runtime provide an objc_terminate function?
Definition: ObjCRuntime.h:347
clang::ObjCRuntime ObjCRuntime
Definition: LangOptions.h:254
llvm::PointerType * AllocaInt8PtrTy
static const EHPersonality GNU_ObjC_SEH
Definition: CGCleanup.h:604
const TargetInfo & getTarget() const
ValueDecl * getDecl()
Definition: Expr.h:1250
&#39;gnustep&#39; is the modern non-fragile GNUstep runtime.
Definition: ObjCRuntime.h:55
const LangOptions & getLangOpts() const
ASTContext & getContext() const
llvm::StoreInst * CreateFlagStore(bool Value, llvm::Value *Addr)
Emit a store to an i1 flag variable.
Definition: CGBuilder.h:130
static llvm::FunctionCallee getCatchallRethrowFn(CodeGenModule &CGM, StringRef Name)
Definition: CGException.cpp:77
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:54
SourceLocation getEndLoc() const LLVM_READONLY
Definition: Stmt.cpp:287
unsigned getBuiltinCallee() const
getBuiltinCallee - If this is a call to a builtin, return the builtin ID of the callee.
Definition: Expr.cpp:1429
llvm::BasicBlock * getEHDispatchBlock(EHScopeStack::stable_iterator scope)
The l-value was considered opaque, so the alignment was determined from a type.
static void emitFilterDispatchBlock(CodeGenFunction &CGF, EHFilterScope &filterScope)
Emit the dispatch block for a filter scope if necessary.
Address recoverAddrOfEscapedLocal(CodeGenFunction &ParentCGF, Address ParentVar, llvm::Value *ParentFP)
Recovers the address of a local in a parent function.
Enumerates target-specific builtins in their own namespaces within namespace clang.
Address CreateBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Definition: CGBuilder.h:136
llvm::cl::opt< std::string > Filter
Kind
Encodes a location in the source.
void EnsureInsertPoint()
EnsureInsertPoint - Ensure that an insertion point is defined so that emitted IR has a place to go...
A saved depth on the scope stack.
Definition: EHScopeStack.h:101
unsigned getNumHandlers() const
Definition: StmtCXX.h:106
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: Type.h:2203
&#39;objfw&#39; is the Objective-C runtime included in ObjFW
Definition: ObjCRuntime.h:58
llvm::BasicBlock * getUnreachableBlock()
RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, llvm::CallBase **callOrInvoke, SourceLocation Loc)
EmitCall - Generate a call of the given function, expecting the given result type, and using the given argument list which specifies both the LLVM arguments and the types they were derived from.
Definition: CGCall.cpp:4232
Kind getKind() const
Definition: ObjCRuntime.h:76
static const EHPersonality & getCXXPersonality(const TargetInfo &Target, const LangOptions &L)
MangleContext - Context for tracking state which persists across multiple calls to the C++ name mangl...
Definition: Mangle.h:44
void EmitStmt(const Stmt *S, ArrayRef< const Attr *> Attrs=None)
EmitStmt - Emit the code for the statement.
Definition: CGStmt.cpp:48
CanQualType VoidTy
Definition: ASTContext.h:942
bool isObjCObjectPointerType() const
Definition: Type.h:6772
An aligned address.
Definition: Address.h:24
bool isWasmPersonality() const
Definition: CGCleanup.h:627
llvm::BasicBlock * getEHResumeBlock(bool isCleanup)
void setCachedEHDispatchBlock(llvm::BasicBlock *block)
Definition: CGCleanup.h:127
llvm::Instruction * CurrentFuncletPad
llvm::Value * getFilter(unsigned i) const
Definition: CGCleanup.h:467
JumpDest getJumpDestInCurrentScope(llvm::BasicBlock *Target)
The given basic block lies in the current EH scope, but may be a target of a potentially scope-crossi...
const VersionTuple & getVersion() const
Definition: ObjCRuntime.h:77
void EmitStartEHSpec(const Decl *D)
EmitStartEHSpec - Emit the start of the exception spec.
The MS C++ ABI needs a pointer to RTTI data plus some flags to describe the type of a catch handler...
Definition: CGCleanup.h:37
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
Definition: Type.h:4121
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:226
static const EHPersonality NeXT_ObjC
Definition: CGCleanup.h:607
llvm::BasicBlock * getFuncletEHDispatchBlock(EHScopeStack::stable_iterator scope)
FunctionArgList - Type for representing both the decl and type of parameters to a function...
Definition: CGCall.h:356
CGFunctionInfo - Class to encapsulate the information about a function definition.
Kind getKind() const
Definition: CGCleanup.h:113
This class organizes the cross-function state that is used while generating LLVM code.
Dataflow Directional Tag Classes.
static ApplyDebugLocation CreateDefaultArtificial(CodeGenFunction &CGF, SourceLocation TemporaryLocation)
Apply TemporaryLocation if it is valid.
Definition: CGDebugInfo.h:778
static bool LandingPadHasOnlyCXXUses(llvm::LandingPadInst *LPI)
Check whether a landingpad instruction only uses C++ features.
static const EHPersonality GNU_CPlusPlus_SEH
Definition: CGCleanup.h:610
The basic abstraction for the target Objective-C runtime.
Definition: ObjCRuntime.h:27
static const EHPersonality GNU_ObjC
Definition: CGCleanup.h:602
static bool isNonEHScope(const EHScope &S)
Check whether this is a non-EH scope, i.e.
void EmitAnyExprToExn(const Expr *E, Address Addr)
llvm::LoadInst * CreateAlignedLoad(llvm::Value *Addr, CharUnits Align, const llvm::Twine &Name="")
Definition: CGBuilder.h:85
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
Definition: CGBuilder.h:68
SEHExceptStmt * getExceptHandler() const
Returns 0 if not defined.
Definition: Stmt.cpp:1146
llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type *> Tys=None)
llvm::FunctionCallee CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeList ExtraAttrs=llvm::AttributeList(), bool Local=false, bool AssumeConvergent=false)
Create or return a runtime function declaration with the specified type and name. ...
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
Definition: CGBuilder.h:102
llvm::Module & getModule() const
Represents a __leave statement.
Definition: Stmt.h:3378
&#39;ios&#39; is the Apple-provided NeXT-derived runtime on iOS or the iOS simulator; it is always non-fragil...
Definition: ObjCRuntime.h:44
llvm::BasicBlock * getTerminateFunclet()
getTerminateLandingPad - Return a cleanup funclet that just calls terminate.
CanThrowResult canThrow() const
Determine whether this function type has a non-throwing exception specification.
Definition: Type.cpp:3221
static const EHPersonality GNU_CPlusPlus
Definition: CGCleanup.h:608
llvm::LoadInst * CreateFlagLoad(llvm::Value *Addr, const llvm::Twine &Name="")
Emit a load from an i1 flag variable.
Definition: CGBuilder.h:123
llvm::StringRef getName() const
Return the IR name of the pointer value.
Definition: Address.h:61
static const EHPersonality GNU_ObjC_SJLJ
Definition: CGCleanup.h:603
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition: Linkage.h:31
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
Definition: CGStmt.cpp:482
void EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock=false)
SEHFinallyStmt * getFinallyHandler() const
Definition: Stmt.cpp:1150
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:6482
Expr * getFilterExpr() const
Definition: Stmt.h:3269
llvm::BasicBlock * getTerminateLandingPad()
getTerminateLandingPad - Return a landing pad that just calls terminate.
CXXCatchStmt - This represents a C++ catch block.
Definition: StmtCXX.h:28
llvm::Type * ConvertType(QualType T)
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:6429
static const EHPersonality GNU_C_SEH
Definition: CGCleanup.h:601
The exceptions personality for a function.
Definition: CGCleanup.h:588
llvm::Constant * RTTI
Definition: CGCleanup.h:38
CompoundStmt * getTryBlock()
Definition: StmtCXX.h:99
llvm::Value * EmitSEHAbnormalTermination()
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2756
llvm::Constant * tryEmitAbstract(const Expr *E, QualType T)
Try to emit the result of the given expression as an abstract constant.
void EnterSEHTryStmt(const SEHTryStmt &S)
void startOutlinedSEHHelper(CodeGenFunction &ParentCGF, bool IsFilter, const Stmt *OutlinedStmt)
Arrange a function prototype that can be called by Windows exception handling personalities.
CGCXXABI & getCXXABI() const
CanQualType IntTy
Definition: ASTContext.h:951
An exceptions scope which filters exceptions thrown through it.
Definition: CGCleanup.h:437
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1178
static RValue get(llvm::Value *V)
Definition: CGValue.h:86
void ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock=false)
void EmitBranchThroughCleanup(JumpDest Dest)
EmitBranchThroughCleanup - Emit a branch from the current insert block through the normal cleanup han...
Definition: CGCleanup.cpp:1045
void EmitEndEHSpec(const Decl *D)
EmitEndEHSpec - Emit the end of the exception spec.
llvm::StoreInst * CreateAlignedStore(llvm::Value *Val, llvm::Value *Addr, CharUnits Align, bool IsVolatile=false)
Definition: CGBuilder.h:109
static const EHPersonality GNU_Wasm_CPlusPlus
Definition: CGCleanup.h:614
QualType getType() const
Definition: Decl.h:630
bool Load(InterpState &S, CodePtr OpPC)
Definition: Interp.h:616
Information for lazily generating a cleanup.
Definition: EHScopeStack.h:141
This represents a decl that may have a name.
Definition: Decl.h:223
A non-stable pointer into the scope stack.
Definition: CGCleanup.h:491
void EmitBlockAfterUses(llvm::BasicBlock *BB)
EmitBlockAfterUses - Emit the given block somewhere hopefully near its uses, and leave the insertion ...
Definition: CGStmt.cpp:519
static void emitCatchPadBlock(CodeGenFunction &CGF, EHCatchScope &CatchScope)
llvm::CallInst * EmitNounwindRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
llvm::CallBase * EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee, ArrayRef< llvm::Value *> args, const Twine &name="")
Emits a call or invoke instruction to the given runtime function.
Definition: CGCall.cpp:4088
CallArgList - Type for representing both the value and type of arguments in a call.
Definition: CGCall.h:262
void PopCleanupBlock(bool FallThroughIsBranchThrough=false)
PopCleanupBlock - Will pop the cleanup entry on the stack and process all branch fixups.
Definition: CGCleanup.cpp:642
void setHandler(unsigned I, llvm::Constant *Type, llvm::BasicBlock *Block)
Definition: CGCleanup.h:196
CompoundStmt * getTryBlock() const
Definition: Stmt.h:3354
CompoundStmt * getBlock() const
Definition: Stmt.h:3273
void EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint=true)
bool isLocalVarDeclOrParm() const
Similar to isLocalVarDecl but also includes parameters.
Definition: Decl.h:1123
SourceLocation getLocation() const
Definition: DeclBase.h:430
static OMPLinearClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr *> VL, ArrayRef< Expr *> PL, ArrayRef< Expr *> IL, Expr *Step, Expr *CalcStep, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL and a linear step Step.
static void emitWasmCatchPadBlock(CodeGenFunction &CGF, EHCatchScope &CatchScope)