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

source code of clang/lib/CodeGen/CGException.cpp