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 "CGDebugInfo.h"
16#include "CGObjCRuntime.h"
17#include "CodeGenFunction.h"
18#include "ConstantEmitter.h"
19#include "TargetInfo.h"
20#include "clang/AST/Mangle.h"
21#include "clang/AST/StmtCXX.h"
22#include "clang/AST/StmtObjC.h"
23#include "clang/AST/StmtVisitor.h"
24#include "clang/Basic/DiagnosticSema.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 (llvm::BasicBlock &BB : *F) {
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(IntrID: 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(Loc: D->getLocation(),
508 DiagID: 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(Loc: D->getLocation(),
522 DiagID: 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: 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 (llvm::Value *filterType : filterTypes)
941 Filters.push_back(Elt: cast<llvm::Constant>(Val: filterType));
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(IID: llvm::Intrinsic::wasm_get_exception);
1049 llvm::Function *GetSelectorFn =
1050 CGF.CGM.getIntrinsic(IID: 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 =
1056 CGF.CGM.getIntrinsic(IID: llvm::Intrinsic::eh_typeid_for, Tys: {CGF.VoidPtrTy});
1057
1058 // If there's only a single catch-all, branch directly to its handler.
1059 if (CatchScope.getNumHandlers() == 1 &&
1060 CatchScope.getHandler(I: 0).isCatchAll()) {
1061 CGF.Builder.CreateBr(Dest: CatchScope.getHandler(I: 0).Block);
1062 CGF.Builder.restoreIP(IP: SavedIP);
1063 return;
1064 }
1065
1066 // Test against each of the exception types we claim to catch.
1067 for (unsigned I = 0, E = NumHandlers;; ++I) {
1068 assert(I < E && "ran off end of handlers!");
1069 const EHCatchScope::Handler &Handler = CatchScope.getHandler(I);
1070 CatchTypeInfo TypeInfo = Handler.Type;
1071 if (!TypeInfo.RTTI)
1072 TypeInfo.RTTI = llvm::Constant::getNullValue(Ty: CGF.VoidPtrTy);
1073
1074 // Figure out the next block.
1075 llvm::BasicBlock *NextBlock;
1076
1077 bool EmitNextBlock = false, NextIsEnd = false;
1078
1079 // If this is the last handler, we're at the end, and the next block is a
1080 // block that contains a call to the rethrow function, so we can unwind to
1081 // the enclosing EH scope. The call itself will be generated later.
1082 if (I + 1 == E) {
1083 NextBlock = CGF.createBasicBlock(name: "rethrow");
1084 EmitNextBlock = true;
1085 NextIsEnd = true;
1086
1087 // If the next handler is a catch-all, we're at the end, and the
1088 // next block is that handler.
1089 } else if (CatchScope.getHandler(I: I + 1).isCatchAll()) {
1090 NextBlock = CatchScope.getHandler(I: I + 1).Block;
1091 NextIsEnd = true;
1092
1093 // Otherwise, we're not at the end and we need a new block.
1094 } else {
1095 NextBlock = CGF.createBasicBlock(name: "catch.fallthrough");
1096 EmitNextBlock = true;
1097 }
1098
1099 // Figure out the catch type's index in the LSDA's type table.
1100 llvm::CallInst *TypeIndex = CGF.Builder.CreateCall(Callee: TypeIDFn, Args: TypeInfo.RTTI);
1101 TypeIndex->setDoesNotThrow();
1102
1103 llvm::Value *MatchesTypeIndex =
1104 CGF.Builder.CreateICmpEQ(LHS: Selector, RHS: TypeIndex, Name: "matches");
1105 CGF.Builder.CreateCondBr(Cond: MatchesTypeIndex, True: Handler.Block, False: NextBlock);
1106
1107 if (EmitNextBlock)
1108 CGF.EmitBlock(BB: NextBlock);
1109 if (NextIsEnd)
1110 break;
1111 }
1112
1113 CGF.Builder.restoreIP(IP: SavedIP);
1114}
1115
1116/// Emit the structure of the dispatch block for the given catch scope.
1117/// It is an invariant that the dispatch block already exists.
1118static void emitCatchDispatchBlock(CodeGenFunction &CGF,
1119 EHCatchScope &catchScope) {
1120 if (EHPersonality::get(CGF).isWasmPersonality())
1121 return emitWasmCatchPadBlock(CGF, CatchScope&: catchScope);
1122 if (EHPersonality::get(CGF).usesFuncletPads())
1123 return emitCatchPadBlock(CGF, CatchScope&: catchScope);
1124
1125 llvm::BasicBlock *dispatchBlock = catchScope.getCachedEHDispatchBlock();
1126 assert(dispatchBlock);
1127
1128 // If there's only a single catch-all, getEHDispatchBlock returned
1129 // that catch-all as the dispatch block.
1130 if (catchScope.getNumHandlers() == 1 &&
1131 catchScope.getHandler(I: 0).isCatchAll()) {
1132 assert(dispatchBlock == catchScope.getHandler(0).Block);
1133 return;
1134 }
1135
1136 CGBuilderTy::InsertPoint savedIP = CGF.Builder.saveIP();
1137 CGF.EmitBlockAfterUses(BB: dispatchBlock);
1138
1139 // Select the right handler.
1140 llvm::Function *llvm_eh_typeid_for =
1141 CGF.CGM.getIntrinsic(IID: llvm::Intrinsic::eh_typeid_for, Tys: {CGF.VoidPtrTy});
1142 llvm::Type *argTy = llvm_eh_typeid_for->getArg(i: 0)->getType();
1143 LangAS globAS = CGF.CGM.GetGlobalVarAddressSpace(D: nullptr);
1144
1145 // Load the selector value.
1146 llvm::Value *selector = CGF.getSelectorFromSlot();
1147
1148 // Test against each of the exception types we claim to catch.
1149 for (unsigned i = 0, e = catchScope.getNumHandlers(); ; ++i) {
1150 assert(i < e && "ran off end of handlers!");
1151 const EHCatchScope::Handler &handler = catchScope.getHandler(I: i);
1152
1153 llvm::Value *typeValue = handler.Type.RTTI;
1154 assert(handler.Type.Flags == 0 &&
1155 "landingpads do not support catch handler flags");
1156 assert(typeValue && "fell into catch-all case!");
1157 // With opaque ptrs, only the address space can be a mismatch.
1158 if (typeValue->getType() != argTy)
1159 typeValue = CGF.getTargetHooks().performAddrSpaceCast(CGF, V: typeValue,
1160 SrcAddr: globAS, 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->getFirstNonPHIIt());
1255 WasmCatchStartBlock = CatchSwitch->hasUnwindDest()
1256 ? CatchSwitch->getSuccessor(Idx: 1)
1257 : CatchSwitch->getSuccessor(Idx: 0);
1258 auto *CPI =
1259 cast<llvm::CatchPadInst>(Val: WasmCatchStartBlock->getFirstNonPHIIt());
1260 CurrentFuncletPad = CPI;
1261 }
1262
1263 // Perversely, we emit the handlers backwards precisely because we
1264 // want them to appear in source order. In all of these cases, the
1265 // catch block will have exactly one predecessor, which will be a
1266 // particular block in the catch dispatch. However, in the case of
1267 // a catch-all, one of the dispatch blocks will branch to two
1268 // different handlers, and EmitBlockAfterUses will cause the second
1269 // handler to be moved before the first.
1270 bool HasCatchAll = false;
1271 for (unsigned I = NumHandlers; I != 0; --I) {
1272 HasCatchAll |= Handlers[I - 1].isCatchAll();
1273 llvm::BasicBlock *CatchBlock = Handlers[I-1].Block;
1274 EmitBlockAfterUses(BB: CatchBlock);
1275
1276 // Catch the exception if this isn't a catch-all.
1277 const CXXCatchStmt *C = S.getHandler(i: I-1);
1278
1279 // Enter a cleanup scope, including the catch variable and the
1280 // end-catch.
1281 RunCleanupsScope CatchScope(*this);
1282
1283 // Initialize the catch variable and set up the cleanups.
1284 SaveAndRestore RestoreCurrentFuncletPad(CurrentFuncletPad);
1285 CGM.getCXXABI().emitBeginCatch(CGF&: *this, C);
1286
1287 // Emit the PGO counter increment.
1288 incrementProfileCounter(S: C);
1289
1290 // Perform the body of the catch.
1291 EmitStmt(S: C->getHandlerBlock());
1292
1293 // [except.handle]p11:
1294 // The currently handled exception is rethrown if control
1295 // reaches the end of a handler of the function-try-block of a
1296 // constructor or destructor.
1297
1298 // It is important that we only do this on fallthrough and not on
1299 // return. Note that it's illegal to put a return in a
1300 // constructor function-try-block's catch handler (p14), so this
1301 // really only applies to destructors.
1302 if (doImplicitRethrow && HaveInsertPoint()) {
1303 CGM.getCXXABI().emitRethrow(CGF&: *this, /*isNoReturn*/false);
1304 Builder.CreateUnreachable();
1305 Builder.ClearInsertionPoint();
1306 }
1307
1308 // Fall out through the catch cleanups.
1309 CatchScope.ForceCleanup();
1310
1311 // Branch out of the try.
1312 if (HaveInsertPoint())
1313 Builder.CreateBr(Dest: ContBB);
1314 }
1315
1316 // Because in wasm we merge all catch clauses into one big catchpad, in case
1317 // none of the types in catch handlers matches after we test against each of
1318 // them, we should unwind to the next EH enclosing scope. We generate a call
1319 // to rethrow function here to do that.
1320 if (EHPersonality::get(CGF&: *this).isWasmPersonality() && !HasCatchAll) {
1321 assert(WasmCatchStartBlock);
1322 // Navigate for the "rethrow" block we created in emitWasmCatchPadBlock().
1323 // Wasm uses landingpad-style conditional branches to compare selectors, so
1324 // we follow the false destination for each of the cond branches to reach
1325 // the rethrow block.
1326 llvm::BasicBlock *RethrowBlock = WasmCatchStartBlock;
1327 while (llvm::Instruction *TI = RethrowBlock->getTerminator()) {
1328 auto *BI = cast<llvm::BranchInst>(Val: TI);
1329 assert(BI->isConditional());
1330 RethrowBlock = BI->getSuccessor(i: 1);
1331 }
1332 assert(RethrowBlock != WasmCatchStartBlock && RethrowBlock->empty());
1333 Builder.SetInsertPoint(RethrowBlock);
1334 llvm::Function *RethrowInCatchFn =
1335 CGM.getIntrinsic(IID: llvm::Intrinsic::wasm_rethrow);
1336 EmitNoreturnRuntimeCallOrInvoke(callee: RethrowInCatchFn, args: {});
1337 }
1338
1339 EmitBlock(BB: ContBB);
1340 incrementProfileCounter(S: &S);
1341}
1342
1343namespace {
1344 struct CallEndCatchForFinally final : EHScopeStack::Cleanup {
1345 llvm::Value *ForEHVar;
1346 llvm::FunctionCallee EndCatchFn;
1347 CallEndCatchForFinally(llvm::Value *ForEHVar,
1348 llvm::FunctionCallee EndCatchFn)
1349 : ForEHVar(ForEHVar), EndCatchFn(EndCatchFn) {}
1350
1351 void Emit(CodeGenFunction &CGF, Flags flags) override {
1352 llvm::BasicBlock *EndCatchBB = CGF.createBasicBlock(name: "finally.endcatch");
1353 llvm::BasicBlock *CleanupContBB =
1354 CGF.createBasicBlock(name: "finally.cleanup.cont");
1355
1356 llvm::Value *ShouldEndCatch =
1357 CGF.Builder.CreateFlagLoad(Addr: ForEHVar, Name: "finally.endcatch");
1358 CGF.Builder.CreateCondBr(Cond: ShouldEndCatch, True: EndCatchBB, False: CleanupContBB);
1359 CGF.EmitBlock(BB: EndCatchBB);
1360 CGF.EmitRuntimeCallOrInvoke(callee: EndCatchFn); // catch-all, so might throw
1361 CGF.EmitBlock(BB: CleanupContBB);
1362 }
1363 };
1364
1365 struct PerformFinally final : EHScopeStack::Cleanup {
1366 const Stmt *Body;
1367 llvm::Value *ForEHVar;
1368 llvm::FunctionCallee EndCatchFn;
1369 llvm::FunctionCallee RethrowFn;
1370 llvm::Value *SavedExnVar;
1371
1372 PerformFinally(const Stmt *Body, llvm::Value *ForEHVar,
1373 llvm::FunctionCallee EndCatchFn,
1374 llvm::FunctionCallee RethrowFn, llvm::Value *SavedExnVar)
1375 : Body(Body), ForEHVar(ForEHVar), EndCatchFn(EndCatchFn),
1376 RethrowFn(RethrowFn), SavedExnVar(SavedExnVar) {}
1377
1378 void Emit(CodeGenFunction &CGF, Flags flags) override {
1379 // Enter a cleanup to call the end-catch function if one was provided.
1380 if (EndCatchFn)
1381 CGF.EHStack.pushCleanup<CallEndCatchForFinally>(Kind: NormalAndEHCleanup,
1382 A: ForEHVar, A: EndCatchFn);
1383
1384 // Save the current cleanup destination in case there are
1385 // cleanups in the finally block.
1386 llvm::Value *SavedCleanupDest =
1387 CGF.Builder.CreateLoad(Addr: CGF.getNormalCleanupDestSlot(),
1388 Name: "cleanup.dest.saved");
1389
1390 // Emit the finally block.
1391 CGF.EmitStmt(S: Body);
1392
1393 // If the end of the finally is reachable, check whether this was
1394 // for EH. If so, rethrow.
1395 if (CGF.HaveInsertPoint()) {
1396 llvm::BasicBlock *RethrowBB = CGF.createBasicBlock(name: "finally.rethrow");
1397 llvm::BasicBlock *ContBB = CGF.createBasicBlock(name: "finally.cont");
1398
1399 llvm::Value *ShouldRethrow =
1400 CGF.Builder.CreateFlagLoad(Addr: ForEHVar, Name: "finally.shouldthrow");
1401 CGF.Builder.CreateCondBr(Cond: ShouldRethrow, True: RethrowBB, False: ContBB);
1402
1403 CGF.EmitBlock(BB: RethrowBB);
1404 if (SavedExnVar) {
1405 CGF.EmitRuntimeCallOrInvoke(callee: RethrowFn,
1406 args: CGF.Builder.CreateAlignedLoad(Ty: CGF.Int8PtrTy, Addr: SavedExnVar,
1407 Align: CGF.getPointerAlign()));
1408 } else {
1409 CGF.EmitRuntimeCallOrInvoke(callee: RethrowFn);
1410 }
1411 CGF.Builder.CreateUnreachable();
1412
1413 CGF.EmitBlock(BB: ContBB);
1414
1415 // Restore the cleanup destination.
1416 CGF.Builder.CreateStore(Val: SavedCleanupDest,
1417 Addr: CGF.getNormalCleanupDestSlot());
1418 }
1419
1420 // Leave the end-catch cleanup. As an optimization, pretend that
1421 // the fallthrough path was inaccessible; we've dynamically proven
1422 // that we're not in the EH case along that path.
1423 if (EndCatchFn) {
1424 CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
1425 CGF.PopCleanupBlock();
1426 CGF.Builder.restoreIP(IP: SavedIP);
1427 }
1428
1429 // Now make sure we actually have an insertion point or the
1430 // cleanup gods will hate us.
1431 CGF.EnsureInsertPoint();
1432 }
1433 };
1434} // end anonymous namespace
1435
1436/// Enters a finally block for an implementation using zero-cost
1437/// exceptions. This is mostly general, but hard-codes some
1438/// language/ABI-specific behavior in the catch-all sections.
1439void CodeGenFunction::FinallyInfo::enter(CodeGenFunction &CGF, const Stmt *body,
1440 llvm::FunctionCallee beginCatchFn,
1441 llvm::FunctionCallee endCatchFn,
1442 llvm::FunctionCallee rethrowFn) {
1443 assert((!!beginCatchFn) == (!!endCatchFn) &&
1444 "begin/end catch functions not paired");
1445 assert(rethrowFn && "rethrow function is required");
1446
1447 BeginCatchFn = beginCatchFn;
1448
1449 // The rethrow function has one of the following two types:
1450 // void (*)()
1451 // void (*)(void*)
1452 // In the latter case we need to pass it the exception object.
1453 // But we can't use the exception slot because the @finally might
1454 // have a landing pad (which would overwrite the exception slot).
1455 llvm::FunctionType *rethrowFnTy = rethrowFn.getFunctionType();
1456 SavedExnVar = nullptr;
1457 if (rethrowFnTy->getNumParams())
1458 SavedExnVar = CGF.CreateTempAlloca(Ty: CGF.Int8PtrTy, Name: "finally.exn");
1459
1460 // A finally block is a statement which must be executed on any edge
1461 // out of a given scope. Unlike a cleanup, the finally block may
1462 // contain arbitrary control flow leading out of itself. In
1463 // addition, finally blocks should always be executed, even if there
1464 // are no catch handlers higher on the stack. Therefore, we
1465 // surround the protected scope with a combination of a normal
1466 // cleanup (to catch attempts to break out of the block via normal
1467 // control flow) and an EH catch-all (semantically "outside" any try
1468 // statement to which the finally block might have been attached).
1469 // The finally block itself is generated in the context of a cleanup
1470 // which conditionally leaves the catch-all.
1471
1472 // Jump destination for performing the finally block on an exception
1473 // edge. We'll never actually reach this block, so unreachable is
1474 // fine.
1475 RethrowDest = CGF.getJumpDestInCurrentScope(Target: CGF.getUnreachableBlock());
1476
1477 // Whether the finally block is being executed for EH purposes.
1478 ForEHVar = CGF.CreateTempAlloca(Ty: CGF.Builder.getInt1Ty(), Name: "finally.for-eh");
1479 CGF.Builder.CreateFlagStore(Value: false, Addr: ForEHVar);
1480
1481 // Enter a normal cleanup which will perform the @finally block.
1482 CGF.EHStack.pushCleanup<PerformFinally>(Kind: NormalCleanup, A: body,
1483 A: ForEHVar, A: endCatchFn,
1484 A: rethrowFn, A: SavedExnVar);
1485
1486 // Enter a catch-all scope.
1487 llvm::BasicBlock *catchBB = CGF.createBasicBlock(name: "finally.catchall");
1488 EHCatchScope *catchScope = CGF.EHStack.pushCatch(NumHandlers: 1);
1489 catchScope->setCatchAllHandler(I: 0, Block: catchBB);
1490}
1491
1492void CodeGenFunction::FinallyInfo::exit(CodeGenFunction &CGF) {
1493 // Leave the finally catch-all.
1494 EHCatchScope &catchScope = cast<EHCatchScope>(Val&: *CGF.EHStack.begin());
1495 llvm::BasicBlock *catchBB = catchScope.getHandler(I: 0).Block;
1496
1497 CGF.popCatchScope();
1498
1499 // If there are any references to the catch-all block, emit it.
1500 if (catchBB->use_empty()) {
1501 delete catchBB;
1502 } else {
1503 CGBuilderTy::InsertPoint savedIP = CGF.Builder.saveAndClearIP();
1504 CGF.EmitBlock(BB: catchBB);
1505
1506 llvm::Value *exn = nullptr;
1507
1508 // If there's a begin-catch function, call it.
1509 if (BeginCatchFn) {
1510 exn = CGF.getExceptionFromSlot();
1511 CGF.EmitNounwindRuntimeCall(callee: BeginCatchFn, args: exn);
1512 }
1513
1514 // If we need to remember the exception pointer to rethrow later, do so.
1515 if (SavedExnVar) {
1516 if (!exn) exn = CGF.getExceptionFromSlot();
1517 CGF.Builder.CreateAlignedStore(Val: exn, Addr: SavedExnVar, Align: CGF.getPointerAlign());
1518 }
1519
1520 // Tell the cleanups in the finally block that we're do this for EH.
1521 CGF.Builder.CreateFlagStore(Value: true, Addr: ForEHVar);
1522
1523 // Thread a jump through the finally cleanup.
1524 CGF.EmitBranchThroughCleanup(Dest: RethrowDest);
1525
1526 CGF.Builder.restoreIP(IP: savedIP);
1527 }
1528
1529 // Finally, leave the @finally cleanup.
1530 CGF.PopCleanupBlock();
1531}
1532
1533llvm::BasicBlock *CodeGenFunction::getTerminateLandingPad() {
1534 if (TerminateLandingPad)
1535 return TerminateLandingPad;
1536
1537 CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
1538
1539 // This will get inserted at the end of the function.
1540 TerminateLandingPad = createBasicBlock(name: "terminate.lpad");
1541 Builder.SetInsertPoint(TerminateLandingPad);
1542
1543 // Tell the backend that this is a landing pad.
1544 const EHPersonality &Personality = EHPersonality::get(CGF&: *this);
1545
1546 if (!CurFn->hasPersonalityFn())
1547 CurFn->setPersonalityFn(getOpaquePersonalityFn(CGM, Personality));
1548
1549 llvm::LandingPadInst *LPadInst =
1550 Builder.CreateLandingPad(Ty: llvm::StructType::get(elt1: Int8PtrTy, elts: Int32Ty), NumClauses: 0);
1551 LPadInst->addClause(ClauseVal: getCatchAllValue(CGF&: *this));
1552
1553 llvm::Value *Exn = nullptr;
1554 if (getLangOpts().CPlusPlus)
1555 Exn = Builder.CreateExtractValue(Agg: LPadInst, Idxs: 0);
1556 llvm::CallInst *terminateCall =
1557 CGM.getCXXABI().emitTerminateForUnexpectedException(CGF&: *this, Exn);
1558 terminateCall->setDoesNotReturn();
1559 Builder.CreateUnreachable();
1560
1561 // Restore the saved insertion state.
1562 Builder.restoreIP(IP: SavedIP);
1563
1564 return TerminateLandingPad;
1565}
1566
1567llvm::BasicBlock *CodeGenFunction::getTerminateHandler() {
1568 if (TerminateHandler)
1569 return TerminateHandler;
1570
1571 // Set up the terminate handler. This block is inserted at the very
1572 // end of the function by FinishFunction.
1573 TerminateHandler = createBasicBlock(name: "terminate.handler");
1574 CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
1575 Builder.SetInsertPoint(TerminateHandler);
1576
1577 llvm::Value *Exn = nullptr;
1578 if (getLangOpts().CPlusPlus)
1579 Exn = getExceptionFromSlot();
1580 llvm::CallInst *terminateCall =
1581 CGM.getCXXABI().emitTerminateForUnexpectedException(CGF&: *this, Exn);
1582 terminateCall->setDoesNotReturn();
1583 Builder.CreateUnreachable();
1584
1585 // Restore the saved insertion state.
1586 Builder.restoreIP(IP: SavedIP);
1587
1588 return TerminateHandler;
1589}
1590
1591llvm::BasicBlock *CodeGenFunction::getTerminateFunclet() {
1592 assert(EHPersonality::get(*this).usesFuncletPads() &&
1593 "use getTerminateLandingPad for non-funclet EH");
1594
1595 llvm::BasicBlock *&TerminateFunclet = TerminateFunclets[CurrentFuncletPad];
1596 if (TerminateFunclet)
1597 return TerminateFunclet;
1598
1599 CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
1600
1601 // Set up the terminate handler. This block is inserted at the very
1602 // end of the function by FinishFunction.
1603 TerminateFunclet = createBasicBlock(name: "terminate.handler");
1604 Builder.SetInsertPoint(TerminateFunclet);
1605
1606 // Create the cleanuppad using the current parent pad as its token. Use 'none'
1607 // if this is a top-level terminate scope, which is the common case.
1608 SaveAndRestore RestoreCurrentFuncletPad(CurrentFuncletPad);
1609 llvm::Value *ParentPad = CurrentFuncletPad;
1610 if (!ParentPad)
1611 ParentPad = llvm::ConstantTokenNone::get(Context&: CGM.getLLVMContext());
1612 CurrentFuncletPad = Builder.CreateCleanupPad(ParentPad);
1613
1614 // Emit the __std_terminate call.
1615 llvm::CallInst *terminateCall =
1616 CGM.getCXXABI().emitTerminateForUnexpectedException(CGF&: *this, Exn: nullptr);
1617 terminateCall->setDoesNotReturn();
1618 Builder.CreateUnreachable();
1619
1620 // Restore the saved insertion state.
1621 Builder.restoreIP(IP: SavedIP);
1622
1623 return TerminateFunclet;
1624}
1625
1626llvm::BasicBlock *CodeGenFunction::getEHResumeBlock(bool isCleanup) {
1627 if (EHResumeBlock) return EHResumeBlock;
1628
1629 CGBuilderTy::InsertPoint SavedIP = Builder.saveIP();
1630
1631 // We emit a jump to a notional label at the outermost unwind state.
1632 EHResumeBlock = createBasicBlock(name: "eh.resume");
1633 Builder.SetInsertPoint(EHResumeBlock);
1634
1635 const EHPersonality &Personality = EHPersonality::get(CGF&: *this);
1636
1637 // This can always be a call because we necessarily didn't find
1638 // anything on the EH stack which needs our help.
1639 const char *RethrowName = Personality.CatchallRethrowFn;
1640 if (RethrowName != nullptr && !isCleanup) {
1641 EmitRuntimeCall(callee: getCatchallRethrowFn(CGM, Name: RethrowName),
1642 args: getExceptionFromSlot())->setDoesNotReturn();
1643 Builder.CreateUnreachable();
1644 Builder.restoreIP(IP: SavedIP);
1645 return EHResumeBlock;
1646 }
1647
1648 // Recreate the landingpad's return value for the 'resume' instruction.
1649 llvm::Value *Exn = getExceptionFromSlot();
1650 llvm::Value *Sel = getSelectorFromSlot();
1651
1652 llvm::Type *LPadType = llvm::StructType::get(elt1: Exn->getType(), elts: Sel->getType());
1653 llvm::Value *LPadVal = llvm::PoisonValue::get(T: LPadType);
1654 LPadVal = Builder.CreateInsertValue(Agg: LPadVal, Val: Exn, Idxs: 0, Name: "lpad.val");
1655 LPadVal = Builder.CreateInsertValue(Agg: LPadVal, Val: Sel, Idxs: 1, Name: "lpad.val");
1656
1657 Builder.CreateResume(Exn: LPadVal);
1658 Builder.restoreIP(IP: SavedIP);
1659 return EHResumeBlock;
1660}
1661
1662void CodeGenFunction::EmitSEHTryStmt(const SEHTryStmt &S) {
1663 EnterSEHTryStmt(S);
1664 {
1665 JumpDest TryExit = getJumpDestInCurrentScope(Name: "__try.__leave");
1666
1667 SEHTryEpilogueStack.push_back(Elt: &TryExit);
1668
1669 llvm::BasicBlock *TryBB = nullptr;
1670 // IsEHa: emit an invoke to _seh_try_begin() runtime for -EHa
1671 if (getLangOpts().EHAsynch) {
1672 EmitRuntimeCallOrInvoke(callee: getSehTryBeginFn(CGM));
1673 if (SEHTryEpilogueStack.size() == 1) // outermost only
1674 TryBB = Builder.GetInsertBlock();
1675 }
1676
1677 EmitStmt(S: S.getTryBlock());
1678
1679 // Volatilize all blocks in Try, till current insert point
1680 if (TryBB) {
1681 llvm::SmallPtrSet<llvm::BasicBlock *, 10> Visited;
1682 VolatilizeTryBlocks(BB: TryBB, V&: Visited);
1683 }
1684
1685 SEHTryEpilogueStack.pop_back();
1686
1687 if (!TryExit.getBlock()->use_empty())
1688 EmitBlock(BB: TryExit.getBlock(), /*IsFinished=*/true);
1689 else
1690 delete TryExit.getBlock();
1691 }
1692 ExitSEHTryStmt(S);
1693}
1694
1695// Recursively walk through blocks in a _try
1696// and make all memory instructions volatile
1697void CodeGenFunction::VolatilizeTryBlocks(
1698 llvm::BasicBlock *BB, llvm::SmallPtrSet<llvm::BasicBlock *, 10> &V) {
1699 if (BB == SEHTryEpilogueStack.back()->getBlock() /* end of Try */ ||
1700 !V.insert(Ptr: BB).second /* already visited */ ||
1701 !BB->getParent() /* not emitted */ || BB->empty())
1702 return;
1703
1704 if (!BB->isEHPad()) {
1705 for (llvm::BasicBlock::iterator J = BB->begin(), JE = BB->end(); J != JE;
1706 ++J) {
1707 if (auto LI = dyn_cast<llvm::LoadInst>(Val&: J)) {
1708 LI->setVolatile(true);
1709 } else if (auto SI = dyn_cast<llvm::StoreInst>(Val&: J)) {
1710 SI->setVolatile(true);
1711 } else if (auto* MCI = dyn_cast<llvm::MemIntrinsic>(Val&: J)) {
1712 MCI->setVolatile(llvm::ConstantInt::get(Ty: Builder.getInt1Ty(), V: 1));
1713 }
1714 }
1715 }
1716 const llvm::Instruction *TI = BB->getTerminator();
1717 if (TI) {
1718 unsigned N = TI->getNumSuccessors();
1719 for (unsigned I = 0; I < N; I++)
1720 VolatilizeTryBlocks(BB: TI->getSuccessor(Idx: I), V);
1721 }
1722}
1723
1724namespace {
1725struct PerformSEHFinally final : EHScopeStack::Cleanup {
1726 llvm::Function *OutlinedFinally;
1727 PerformSEHFinally(llvm::Function *OutlinedFinally)
1728 : OutlinedFinally(OutlinedFinally) {}
1729
1730 void Emit(CodeGenFunction &CGF, Flags F) override {
1731 ASTContext &Context = CGF.getContext();
1732 CodeGenModule &CGM = CGF.CGM;
1733
1734 CallArgList Args;
1735
1736 // Compute the two argument values.
1737 QualType ArgTys[2] = {Context.UnsignedCharTy, Context.VoidPtrTy};
1738 llvm::Value *FP = nullptr;
1739 // If CFG.IsOutlinedSEHHelper is true, then we are within a finally block.
1740 if (CGF.IsOutlinedSEHHelper) {
1741 FP = &CGF.CurFn->arg_begin()[1];
1742 } else {
1743 llvm::Function *LocalAddrFn =
1744 CGM.getIntrinsic(IID: llvm::Intrinsic::localaddress);
1745 FP = CGF.Builder.CreateCall(Callee: LocalAddrFn);
1746 }
1747
1748 llvm::Value *IsForEH =
1749 llvm::ConstantInt::get(Ty: CGF.ConvertType(T: ArgTys[0]), V: F.isForEHCleanup());
1750
1751 // Except _leave and fall-through at the end, all other exits in a _try
1752 // (return/goto/continue/break) are considered as abnormal terminations
1753 // since _leave/fall-through is always Indexed 0,
1754 // just use NormalCleanupDestSlot (>= 1 for goto/return/..),
1755 // as 1st Arg to indicate abnormal termination
1756 if (!F.isForEHCleanup() && F.hasExitSwitch()) {
1757 Address Addr = CGF.getNormalCleanupDestSlot();
1758 llvm::Value *Load = CGF.Builder.CreateLoad(Addr, Name: "cleanup.dest");
1759 llvm::Value *Zero = llvm::Constant::getNullValue(Ty: CGM.Int32Ty);
1760 IsForEH = CGF.Builder.CreateICmpNE(LHS: Load, RHS: Zero);
1761 }
1762
1763 Args.add(rvalue: RValue::get(V: IsForEH), type: ArgTys[0]);
1764 Args.add(rvalue: RValue::get(V: FP), type: ArgTys[1]);
1765
1766 // Arrange a two-arg function info and type.
1767 const CGFunctionInfo &FnInfo =
1768 CGM.getTypes().arrangeBuiltinFunctionCall(resultType: Context.VoidTy, args: Args);
1769
1770 auto Callee = CGCallee::forDirect(functionPtr: OutlinedFinally);
1771 CGF.EmitCall(CallInfo: FnInfo, Callee, ReturnValue: ReturnValueSlot(), Args);
1772 }
1773};
1774} // end anonymous namespace
1775
1776namespace {
1777/// Find all local variable captures in the statement.
1778struct CaptureFinder : ConstStmtVisitor<CaptureFinder> {
1779 CodeGenFunction &ParentCGF;
1780 const VarDecl *ParentThis;
1781 llvm::SmallSetVector<const VarDecl *, 4> Captures;
1782 Address SEHCodeSlot = Address::invalid();
1783 CaptureFinder(CodeGenFunction &ParentCGF, const VarDecl *ParentThis)
1784 : ParentCGF(ParentCGF), ParentThis(ParentThis) {}
1785
1786 // Return true if we need to do any capturing work.
1787 bool foundCaptures() {
1788 return !Captures.empty() || SEHCodeSlot.isValid();
1789 }
1790
1791 void Visit(const Stmt *S) {
1792 // See if this is a capture, then recurse.
1793 ConstStmtVisitor<CaptureFinder>::Visit(S);
1794 for (const Stmt *Child : S->children())
1795 if (Child)
1796 Visit(S: Child);
1797 }
1798
1799 void VisitDeclRefExpr(const DeclRefExpr *E) {
1800 // If this is already a capture, just make sure we capture 'this'.
1801 if (E->refersToEnclosingVariableOrCapture())
1802 Captures.insert(X: ParentThis);
1803
1804 const auto *D = dyn_cast<VarDecl>(Val: E->getDecl());
1805 if (D && D->isLocalVarDeclOrParm() && D->hasLocalStorage())
1806 Captures.insert(X: D);
1807 }
1808
1809 void VisitCXXThisExpr(const CXXThisExpr *E) {
1810 Captures.insert(X: ParentThis);
1811 }
1812
1813 void VisitCallExpr(const CallExpr *E) {
1814 // We only need to add parent frame allocations for these builtins in x86.
1815 if (ParentCGF.getTarget().getTriple().getArch() != llvm::Triple::x86)
1816 return;
1817
1818 unsigned ID = E->getBuiltinCallee();
1819 switch (ID) {
1820 case Builtin::BI__exception_code:
1821 case Builtin::BI_exception_code:
1822 // This is the simple case where we are the outermost finally. All we
1823 // have to do here is make sure we escape this and recover it in the
1824 // outlined handler.
1825 if (!SEHCodeSlot.isValid())
1826 SEHCodeSlot = ParentCGF.SEHCodeSlotStack.back();
1827 break;
1828 }
1829 }
1830};
1831} // end anonymous namespace
1832
1833Address CodeGenFunction::recoverAddrOfEscapedLocal(CodeGenFunction &ParentCGF,
1834 Address ParentVar,
1835 llvm::Value *ParentFP) {
1836 llvm::CallInst *RecoverCall = nullptr;
1837 CGBuilderTy Builder(*this, AllocaInsertPt);
1838 if (auto *ParentAlloca =
1839 dyn_cast_or_null<llvm::AllocaInst>(Val: ParentVar.getBasePointer())) {
1840 // Mark the variable escaped if nobody else referenced it and compute the
1841 // localescape index.
1842 auto InsertPair = ParentCGF.EscapedLocals.insert(
1843 KV: std::make_pair(x&: ParentAlloca, y: ParentCGF.EscapedLocals.size()));
1844 int FrameEscapeIdx = InsertPair.first->second;
1845 // call ptr @llvm.localrecover(ptr @parentFn, ptr %fp, i32 N)
1846 llvm::Function *FrameRecoverFn = llvm::Intrinsic::getOrInsertDeclaration(
1847 M: &CGM.getModule(), id: llvm::Intrinsic::localrecover);
1848 RecoverCall = Builder.CreateCall(
1849 Callee: FrameRecoverFn, Args: {ParentCGF.CurFn, ParentFP,
1850 llvm::ConstantInt::get(Ty: Int32Ty, V: FrameEscapeIdx)});
1851
1852 } else {
1853 // If the parent didn't have an alloca, we're doing some nested outlining.
1854 // Just clone the existing localrecover call, but tweak the FP argument to
1855 // use our FP value. All other arguments are constants.
1856 auto *ParentRecover = cast<llvm::IntrinsicInst>(
1857 Val: ParentVar.emitRawPointer(CGF&: *this)->stripPointerCasts());
1858 assert(ParentRecover->getIntrinsicID() == llvm::Intrinsic::localrecover &&
1859 "expected alloca or localrecover in parent LocalDeclMap");
1860 RecoverCall = cast<llvm::CallInst>(Val: ParentRecover->clone());
1861 RecoverCall->setArgOperand(i: 1, v: ParentFP);
1862 RecoverCall->insertBefore(InsertPos: AllocaInsertPt->getIterator());
1863 }
1864
1865 // Bitcast the variable, rename it, and insert it in the local decl map.
1866 llvm::Value *ChildVar =
1867 Builder.CreateBitCast(V: RecoverCall, DestTy: ParentVar.getType());
1868 ChildVar->setName(ParentVar.getName());
1869 return ParentVar.withPointer(NewPointer: ChildVar, IsKnownNonNull: KnownNonNull);
1870}
1871
1872void CodeGenFunction::EmitCapturedLocals(CodeGenFunction &ParentCGF,
1873 const Stmt *OutlinedStmt,
1874 bool IsFilter) {
1875 // Find all captures in the Stmt.
1876 CaptureFinder Finder(ParentCGF, ParentCGF.CXXABIThisDecl);
1877 Finder.Visit(S: OutlinedStmt);
1878
1879 // We can exit early on x86_64 when there are no captures. We just have to
1880 // save the exception code in filters so that __exception_code() works.
1881 if (!Finder.foundCaptures() &&
1882 CGM.getTarget().getTriple().getArch() != llvm::Triple::x86) {
1883 if (IsFilter)
1884 EmitSEHExceptionCodeSave(ParentCGF, ParentFP: nullptr, EntryEBP: nullptr);
1885 return;
1886 }
1887
1888 llvm::Value *EntryFP = nullptr;
1889 CGBuilderTy Builder(CGM, AllocaInsertPt);
1890 if (IsFilter && CGM.getTarget().getTriple().getArch() == llvm::Triple::x86) {
1891 // 32-bit SEH filters need to be careful about FP recovery. The end of the
1892 // EH registration is passed in as the EBP physical register. We can
1893 // recover that with llvm.frameaddress(1).
1894 EntryFP = Builder.CreateCall(
1895 Callee: CGM.getIntrinsic(IID: llvm::Intrinsic::frameaddress, Tys: AllocaInt8PtrTy),
1896 Args: {Builder.getInt32(C: 1)});
1897 } else {
1898 // Otherwise, for x64 and 32-bit finally functions, the parent FP is the
1899 // second parameter.
1900 auto AI = CurFn->arg_begin();
1901 ++AI;
1902 EntryFP = &*AI;
1903 }
1904
1905 llvm::Value *ParentFP = EntryFP;
1906 if (IsFilter) {
1907 // Given whatever FP the runtime provided us in EntryFP, recover the true
1908 // frame pointer of the parent function. We only need to do this in filters,
1909 // since finally funclets recover the parent FP for us.
1910 llvm::Function *RecoverFPIntrin =
1911 CGM.getIntrinsic(IID: llvm::Intrinsic::eh_recoverfp);
1912 ParentFP = Builder.CreateCall(Callee: RecoverFPIntrin, Args: {ParentCGF.CurFn, EntryFP});
1913
1914 // if the parent is a _finally, the passed-in ParentFP is the FP
1915 // of parent _finally, not Establisher's FP (FP of outermost function).
1916 // Establkisher FP is 2nd paramenter passed into parent _finally.
1917 // Fortunately, it's always saved in parent's frame. The following
1918 // code retrieves it, and escapes it so that spill instruction won't be
1919 // optimized away.
1920 if (ParentCGF.ParentCGF != nullptr) {
1921 // Locate and escape Parent's frame_pointer.addr alloca
1922 // Depending on target, should be 1st/2nd one in LocalDeclMap.
1923 // Let's just scan for ImplicitParamDecl with VoidPtrTy.
1924 llvm::AllocaInst *FramePtrAddrAlloca = nullptr;
1925 for (auto &I : ParentCGF.LocalDeclMap) {
1926 const VarDecl *D = cast<VarDecl>(Val: I.first);
1927 if (isa<ImplicitParamDecl>(Val: D) &&
1928 D->getType() == getContext().VoidPtrTy) {
1929 assert(D->getName().starts_with("frame_pointer"));
1930 FramePtrAddrAlloca =
1931 cast<llvm::AllocaInst>(Val: I.second.getBasePointer());
1932 break;
1933 }
1934 }
1935 assert(FramePtrAddrAlloca);
1936 auto InsertPair = ParentCGF.EscapedLocals.insert(
1937 KV: std::make_pair(x&: FramePtrAddrAlloca, y: ParentCGF.EscapedLocals.size()));
1938 int FrameEscapeIdx = InsertPair.first->second;
1939
1940 // an example of a filter's prolog::
1941 // %0 = call ptr @llvm.eh.recoverfp(@"?fin$0@0@main@@",..)
1942 // %1 = call ptr @llvm.localrecover(@"?fin$0@0@main@@",..)
1943 // %2 = load ptr, ptr %1, align 8
1944 // ==> %2 is the frame-pointer of outermost host function
1945 llvm::Function *FrameRecoverFn = llvm::Intrinsic::getOrInsertDeclaration(
1946 M: &CGM.getModule(), id: llvm::Intrinsic::localrecover);
1947 ParentFP = Builder.CreateCall(
1948 Callee: FrameRecoverFn, Args: {ParentCGF.CurFn, ParentFP,
1949 llvm::ConstantInt::get(Ty: Int32Ty, V: FrameEscapeIdx)});
1950 ParentFP = Builder.CreateLoad(
1951 Addr: Address(ParentFP, CGM.VoidPtrTy, getPointerAlign()));
1952 }
1953 }
1954
1955 // Create llvm.localrecover calls for all captures.
1956 for (const VarDecl *VD : Finder.Captures) {
1957 if (VD->getType()->isVariablyModifiedType()) {
1958 CGM.ErrorUnsupported(D: VD, Type: "VLA captured by SEH");
1959 continue;
1960 }
1961 assert((isa<ImplicitParamDecl>(VD) || VD->isLocalVarDeclOrParm()) &&
1962 "captured non-local variable");
1963
1964 auto L = ParentCGF.LambdaCaptureFields.find(Val: VD);
1965 if (L != ParentCGF.LambdaCaptureFields.end()) {
1966 LambdaCaptureFields[VD] = L->second;
1967 continue;
1968 }
1969
1970 // If this decl hasn't been declared yet, it will be declared in the
1971 // OutlinedStmt.
1972 auto I = ParentCGF.LocalDeclMap.find(Val: VD);
1973 if (I == ParentCGF.LocalDeclMap.end())
1974 continue;
1975
1976 Address ParentVar = I->second;
1977 Address Recovered =
1978 recoverAddrOfEscapedLocal(ParentCGF, ParentVar, ParentFP);
1979 setAddrOfLocalVar(VD, Addr: Recovered);
1980
1981 if (isa<ImplicitParamDecl>(Val: VD)) {
1982 CXXABIThisAlignment = ParentCGF.CXXABIThisAlignment;
1983 CXXThisAlignment = ParentCGF.CXXThisAlignment;
1984 CXXABIThisValue = Builder.CreateLoad(Addr: Recovered, Name: "this");
1985 if (ParentCGF.LambdaThisCaptureField) {
1986 LambdaThisCaptureField = ParentCGF.LambdaThisCaptureField;
1987 // We are in a lambda function where "this" is captured so the
1988 // CXXThisValue need to be loaded from the lambda capture
1989 LValue ThisFieldLValue =
1990 EmitLValueForLambdaField(Field: LambdaThisCaptureField);
1991 if (!LambdaThisCaptureField->getType()->isPointerType()) {
1992 CXXThisValue = ThisFieldLValue.getAddress().emitRawPointer(CGF&: *this);
1993 } else {
1994 CXXThisValue = EmitLoadOfLValue(V: ThisFieldLValue, Loc: 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 C&: getContext(), /*DC=*/nullptr, IdLoc: StartLoc,
2040 Id: &getContext().Idents.get(Name: "exception_pointers"),
2041 T: getContext().VoidPtrTy, ParamKind: ImplicitParamKind::Other));
2042 } else {
2043 Args.push_back(Elt: ImplicitParamDecl::Create(
2044 C&: getContext(), /*DC=*/nullptr, IdLoc: StartLoc,
2045 Id: &getContext().Idents.get(Name: "abnormal_termination"),
2046 T: getContext().UnsignedCharTy, ParamKind: ImplicitParamKind::Other));
2047 }
2048 Args.push_back(Elt: ImplicitParamDecl::Create(
2049 C&: getContext(), /*DC=*/nullptr, IdLoc: StartLoc,
2050 Id: &getContext().Idents.get(Name: "frame_pointer"), T: getContext().VoidPtrTy,
2051 ParamKind: 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, IsFilter: true, OutlinedStmt: FilterExpr);
2081
2082 // Emit the original filter expression, convert to i32, and return.
2083 llvm::Value *R = EmitScalarExpr(E: FilterExpr);
2084 R = Builder.CreateIntCast(V: R, DestTy: ConvertType(T: getContext().LongTy),
2085 isSigned: 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(T: getContext().IntTy, Name: "__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(Ty: Int8PtrTy, Addr: SEHInfo, Align: 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(Ty: RecordTy, Addr: Rec, Align: getPointerAlign());
2139 llvm::Value *Code = Builder.CreateAlignedLoad(Ty: Int32Ty, Addr: Rec, Align: 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::PoisonValue::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(T: getContext().IntTy, Name: "__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(E: Except->getFilterExpr(),
2195 T: 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->getFirstNonPHIIt());
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(IID: 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(S: 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