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