1	//===--- CGException.cpp - Emit LLVM Code for C++ exceptions ----*- C++ -*-===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8	//
9	// This contains code dealing with C++ exception related code generation.
10	//
11	//===----------------------------------------------------------------------===//
12
13	#include "CGCXXABI.h"
14	#include "CGCleanup.h"
15	#include "CGObjCRuntime.h"
16	#include "CodeGenFunction.h"
17	#include "ConstantEmitter.h"
18	#include "TargetInfo.h"
19	#include "clang/AST/Mangle.h"
20	#include "clang/AST/StmtCXX.h"
21	#include "clang/AST/StmtObjC.h"
22	#include "clang/AST/StmtVisitor.h"
23	#include "clang/Basic/DiagnosticSema.h"
24	#include "clang/Basic/TargetBuiltins.h"
25	#include "llvm/IR/IntrinsicInst.h"
26	#include "llvm/IR/Intrinsics.h"
27	#include "llvm/IR/IntrinsicsWebAssembly.h"
28	#include "llvm/Support/SaveAndRestore.h"
29
30	using namespace clang;
31	using namespace CodeGen;
32
33	static llvm::FunctionCallee getFreeExceptionFn(CodeGenModule &CGM) {
34	// void __cxa_free_exception(void *thrown_exception);
35
36	llvm::FunctionType *FTy =
37	llvm::FunctionType::get(Result: CGM.VoidTy, Params: CGM.Int8PtrTy, /*isVarArg=*/false);
38
39	return CGM.CreateRuntimeFunction(Ty: FTy, Name: "__cxa_free_exception");
40	}
41
42	static 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
48	static 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
54	static 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
63	llvm::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
89	static 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
97	const EHPersonality EHPersonality::GNU_C = { .PersonalityFn: "__gcc_personality_v0", .CatchallRethrowFn: nullptr };
98	const EHPersonality
99	EHPersonality::GNU_C_SJLJ = { .PersonalityFn: "__gcc_personality_sj0", .CatchallRethrowFn: nullptr };
100	const EHPersonality
101	EHPersonality::GNU_C_SEH = { .PersonalityFn: "__gcc_personality_seh0", .CatchallRethrowFn: nullptr };
102	const EHPersonality
103	EHPersonality::NeXT_ObjC = { .PersonalityFn: "__objc_personality_v0", .CatchallRethrowFn: nullptr };
104	const EHPersonality
105	EHPersonality::GNU_CPlusPlus = { .PersonalityFn: "__gxx_personality_v0", .CatchallRethrowFn: nullptr };
106	const EHPersonality
107	EHPersonality::GNU_CPlusPlus_SJLJ = { .PersonalityFn: "__gxx_personality_sj0", .CatchallRethrowFn: nullptr };
108	const EHPersonality
109	EHPersonality::GNU_CPlusPlus_SEH = { .PersonalityFn: "__gxx_personality_seh0", .CatchallRethrowFn: nullptr };
110	const EHPersonality
111	EHPersonality::GNU_ObjC = {.PersonalityFn: "__gnu_objc_personality_v0", .CatchallRethrowFn: "objc_exception_throw"};
112	const EHPersonality
113	EHPersonality::GNU_ObjC_SJLJ = {.PersonalityFn: "__gnu_objc_personality_sj0", .CatchallRethrowFn: "objc_exception_throw"};
114	const EHPersonality
115	EHPersonality::GNU_ObjC_SEH = {.PersonalityFn: "__gnu_objc_personality_seh0", .CatchallRethrowFn: "objc_exception_throw"};
116	const EHPersonality
117	EHPersonality::GNU_ObjCXX = { .PersonalityFn: "__gnustep_objcxx_personality_v0", .CatchallRethrowFn: nullptr };
118	const EHPersonality
119	EHPersonality::GNUstep_ObjC = { .PersonalityFn: "__gnustep_objc_personality_v0", .CatchallRethrowFn: nullptr };
120	const EHPersonality
121	EHPersonality::MSVC_except_handler = { .PersonalityFn: "_except_handler3", .CatchallRethrowFn: nullptr };
122	const EHPersonality
123	EHPersonality::MSVC_C_specific_handler = { .PersonalityFn: "__C_specific_handler", .CatchallRethrowFn: nullptr };
124	const EHPersonality
125	EHPersonality::MSVC_CxxFrameHandler3 = { .PersonalityFn: "__CxxFrameHandler3", .CatchallRethrowFn: nullptr };
126	const EHPersonality
127	EHPersonality::GNU_Wasm_CPlusPlus = { .PersonalityFn: "__gxx_wasm_personality_v0", .CatchallRethrowFn: nullptr };
128	const EHPersonality EHPersonality::XL_CPlusPlus = {.PersonalityFn: "__xlcxx_personality_v1",
129	.CatchallRethrowFn: nullptr};
130	const EHPersonality EHPersonality::ZOS_CPlusPlus = {.PersonalityFn: "__zos_cxx_personality_v2",
131	.CatchallRethrowFn: nullptr};
132
133	static 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
147	static 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
177	static 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.
199	static 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
231	static 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
237	const 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
254	const 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
263	static 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
270	static 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.
277	static 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.
308	static bool PersonalityHasOnlyCXXUses(llvm::Constant *Fn) {
309	for (llvm::User *U : Fn->users()) {
310	// Conditionally white-list bitcasts.
311	if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Val: U)) {
312	if (CE->getOpcode() != llvm::Instruction::BitCast) return false;
313	if (!PersonalityHasOnlyCXXUses(Fn: CE))
314	return false;
315	continue;
316	}
317
318	// Otherwise it must be a function.
319	llvm::Function *F = dyn_cast<llvm::Function>(Val: U);
320	if (!F) return false;
321
322	for (auto BB = F->begin(), E = F->end(); BB != E; ++BB) {
323	if (BB->isLandingPad())
324	if (!LandingPadHasOnlyCXXUses(LPI: BB->getLandingPadInst()))
325	return false;
326	}
327	}
328
329	return true;
330	}
331
332	/// Try to use the C++ personality function in ObjC++. Not doing this
333	/// can cause some incompatibilities with gcc, which is more
334	/// aggressive about only using the ObjC++ personality in a function
335	/// when it really needs it.
336	void 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.
376	static 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
381	namespace {
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.
397	void 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
423	Address CodeGenFunction::getExceptionSlot() {
424	if (!ExceptionSlot)
425	ExceptionSlot = CreateTempAlloca(Ty: Int8PtrTy, Name: "exn.slot");
426	return Address(ExceptionSlot, Int8PtrTy, getPointerAlign());
427	}
428
429	Address CodeGenFunction::getEHSelectorSlot() {
430	if (!EHSelectorSlot)
431	EHSelectorSlot = CreateTempAlloca(Ty: Int32Ty, Name: "ehselector.slot");
432	return Address(EHSelectorSlot, Int32Ty, CharUnits::fromQuantity(Quantity: 4));
433	}
434
435	llvm::Value *CodeGenFunction::getExceptionFromSlot() {
436	return Builder.CreateLoad(Addr: getExceptionSlot(), Name: "exn");
437	}
438
439	llvm::Value *CodeGenFunction::getSelectorFromSlot() {
440	return Builder.CreateLoad(Addr: getEHSelectorSlot(), Name: "sel");
441	}
442
443	void CodeGenFunction::EmitCXXThrowExpr(const CXXThrowExpr *E,
444	bool KeepInsertionPoint) {
445	// If the exception is being emitted in an OpenMP target region,
446	// and the target is a GPU, we do not support exception handling.
447	// Therefore, we emit a trap which will abort the program, and
448	// prompt a warning indicating that a trap will be emitted.
449	const llvm::Triple &T = Target.getTriple();
450	if (CGM.getLangOpts().OpenMPIsTargetDevice && (T.isNVPTX() || T.isAMDGCN())) {
451	EmitTrapCall(llvm::Intrinsic::trap);
452	return;
453	}
454	if (const Expr *SubExpr = E->getSubExpr()) {
455	QualType ThrowType = SubExpr->getType();
456	if (ThrowType->isObjCObjectPointerType()) {
457	const Stmt *ThrowStmt = E->getSubExpr();
458	const ObjCAtThrowStmt S(E->getExprLoc(), const_cast<Stmt *>(ThrowStmt));
459	CGM.getObjCRuntime().EmitThrowStmt(CGF&: *this, S, ClearInsertionPoint: false);
460	} else {
461	CGM.getCXXABI().emitThrow(CGF&: *this, E);
462	}
463	} else {
464	CGM.getCXXABI().emitRethrow(CGF&: *this, /*isNoReturn=*/true);
465	}
466
467	// throw is an expression, and the expression emitters expect us
468	// to leave ourselves at a valid insertion point.
469	if (KeepInsertionPoint)
470	EmitBlock(BB: createBasicBlock(name: "throw.cont"));
471	}
472
473	void CodeGenFunction::EmitStartEHSpec(const Decl *D) {
474	if (!CGM.getLangOpts().CXXExceptions)
475	return;
476
477	const FunctionDecl* FD = dyn_cast_or_null<FunctionDecl>(Val: D);
478	if (!FD) {
479	// Check if CapturedDecl is nothrow and create terminate scope for it.
480	if (const CapturedDecl* CD = dyn_cast_or_null<CapturedDecl>(Val: D)) {
481	if (CD->isNothrow())
482	EHStack.pushTerminate();
483	}
484	return;
485	}
486	const FunctionProtoType *Proto = FD->getType()->getAs<FunctionProtoType>();
487	if (!Proto)
488	return;
489
490	ExceptionSpecificationType EST = Proto->getExceptionSpecType();
491	// In C++17 and later, 'throw()' aka EST_DynamicNone is treated the same way
492	// as noexcept. In earlier standards, it is handled in this block, along with
493	// 'throw(X...)'.
494	if (EST == EST_Dynamic ||
495	(EST == EST_DynamicNone && !getLangOpts().CPlusPlus17)) {
496	// TODO: Revisit exception specifications for the MS ABI. There is a way to
497	// encode these in an object file but MSVC doesn't do anything with it.
498	if (getTarget().getCXXABI().isMicrosoft())
499	return;
500	// In Wasm EH we currently treat 'throw()' in the same way as 'noexcept'. In
501	// case of throw with types, we ignore it and print a warning for now.
502	// TODO Correctly handle exception specification in Wasm EH
503	if (CGM.getLangOpts().hasWasmExceptions()) {
504	if (EST == EST_DynamicNone)
505	EHStack.pushTerminate();
506	else
507	CGM.getDiags().Report(D->getLocation(),
508	diag::warn_wasm_dynamic_exception_spec_ignored)
509	<< FD->getExceptionSpecSourceRange();
510	return;
511	}
512	// Currently Emscripten EH only handles 'throw()' but not 'throw' with
513	// types. 'throw()' handling will be done in JS glue code so we don't need
514	// to do anything in that case. Just print a warning message in case of
515	// throw with types.
516	// TODO Correctly handle exception specification in Emscripten EH
517	if (getTarget().getCXXABI() == TargetCXXABI::WebAssembly &&
518	CGM.getLangOpts().getExceptionHandling() ==
519	LangOptions::ExceptionHandlingKind::None &&
520	EST == EST_Dynamic)
521	CGM.getDiags().Report(D->getLocation(),
522	diag::warn_wasm_dynamic_exception_spec_ignored)
523	<< FD->getExceptionSpecSourceRange();
524
525	unsigned NumExceptions = Proto->getNumExceptions();
526	EHFilterScope *Filter = EHStack.pushFilter(NumFilters: NumExceptions);
527
528	for (unsigned I = 0; I != NumExceptions; ++I) {
529	QualType Ty = Proto->getExceptionType(i: I);
530	QualType ExceptType = Ty.getNonReferenceType().getUnqualifiedType();
531	llvm::Value *EHType = CGM.GetAddrOfRTTIDescriptor(Ty: ExceptType,
532	/*ForEH=*/true);
533	Filter->setFilter(i: I, filterValue: EHType);
534	}
535	} else if (Proto->canThrow() == CT_Cannot) {
536	// noexcept functions are simple terminate scopes.
537	if (!getLangOpts().EHAsynch) // -EHa: HW exception still can occur
538	EHStack.pushTerminate();
539	}
540	}
541
542	/// Emit the dispatch block for a filter scope if necessary.
543	static 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
580	void 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
622	void CodeGenFunction::EmitCXXTryStmt(const CXXTryStmt &S) {
623	const llvm::Triple &T = Target.getTriple();
624	// If we encounter a try statement on in an OpenMP target region offloaded to
625	// a GPU, we treat it as a basic block.
626	const bool IsTargetDevice =
627	(CGM.getLangOpts().OpenMPIsTargetDevice && (T.isNVPTX() || T.isAMDGCN()));
628	if (!IsTargetDevice)
629	EnterCXXTryStmt(S);
630	EmitStmt(S.getTryBlock());
631	if (!IsTargetDevice)
632	ExitCXXTryStmt(S);
633	}
634
635	void 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
672	llvm::BasicBlock *
673	CodeGenFunction::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
719	llvm::BasicBlock *
720	CodeGenFunction::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.
762	static 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
775	llvm::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
825	llvm::BasicBlock *CodeGenFunction::EmitLandingPad() {
826	assert(EHStack.requiresLandingPad());
827	assert(!CGM.getLangOpts().IgnoreExceptions &&
828	"LandingPad should not be emitted when -fignore-exceptions are in "
829	"effect.");
830	EHScope &innermostEHScope = *EHStack.find(sp: EHStack.getInnermostEHScope());
831	switch (innermostEHScope.getKind()) {
832	case EHScope::Terminate:
833	return getTerminateLandingPad();
834
835	case EHScope::Catch:
836	case EHScope::Cleanup:
837	case EHScope::Filter:
838	if (llvm::BasicBlock *lpad = innermostEHScope.getCachedLandingPad())
839	return lpad;
840	}
841
842	// Save the current IR generation state.
843	CGBuilderTy::InsertPoint savedIP = Builder.saveAndClearIP();
844	auto DL = ApplyDebugLocation::CreateDefaultArtificial(CGF&: *this, TemporaryLocation: CurEHLocation);
845
846	// Create and configure the landing pad.
847	llvm::BasicBlock *lpad = createBasicBlock(name: "lpad");
848	EmitBlock(BB: lpad);
849
850	llvm::LandingPadInst *LPadInst =
851	Builder.CreateLandingPad(Ty: llvm::StructType::get(elt1: Int8PtrTy, elts: Int32Ty), NumClauses: 0);
852
853	llvm::Value *LPadExn = Builder.CreateExtractValue(Agg: LPadInst, Idxs: 0);
854	Builder.CreateStore(Val: LPadExn, Addr: getExceptionSlot());
855	llvm::Value *LPadSel = Builder.CreateExtractValue(Agg: LPadInst, Idxs: 1);
856	Builder.CreateStore(Val: LPadSel, Addr: getEHSelectorSlot());
857
858	// Save the exception pointer. It's safe to use a single exception
859	// pointer per function because EH cleanups can never have nested
860	// try/catches.
861	// Build the landingpad instruction.
862
863	// Accumulate all the handlers in scope.
864	bool hasCatchAll = false;
865	bool hasCleanup = false;
866	bool hasFilter = false;
867	SmallVector<llvm::Value*, 4> filterTypes;
868	llvm::SmallPtrSet<llvm::Value*, 4> catchTypes;
869	for (EHScopeStack::iterator I = EHStack.begin(), E = EHStack.end(); I != E;
870	++I) {
871
872	switch (I->getKind()) {
873	case EHScope::Cleanup:
874	// If we have a cleanup, remember that.
875	hasCleanup = (hasCleanup || cast<EHCleanupScope>(Val&: *I).isEHCleanup());
876	continue;
877
878	case EHScope::Filter: {
879	assert(I.next() == EHStack.end() && "EH filter is not end of EH stack");
880	assert(!hasCatchAll && "EH filter reached after catch-all");
881
882	// Filter scopes get added to the landingpad in weird ways.
883	EHFilterScope &filter = cast<EHFilterScope>(Val&: *I);
884	hasFilter = true;
885
886	// Add all the filter values.
887	for (unsigned i = 0, e = filter.getNumFilters(); i != e; ++i)
888	filterTypes.push_back(Elt: filter.getFilter(i));
889	goto done;
890	}
891
892	case EHScope::Terminate:
893	// Terminate scopes are basically catch-alls.
894	assert(!hasCatchAll);
895	hasCatchAll = true;
896	goto done;
897
898	case EHScope::Catch:
899	break;
900	}
901
902	EHCatchScope &catchScope = cast<EHCatchScope>(Val&: *I);
903	for (unsigned hi = 0, he = catchScope.getNumHandlers(); hi != he; ++hi) {
904	EHCatchScope::Handler handler = catchScope.getHandler(I: hi);
905	assert(handler.Type.Flags == 0 &&
906	"landingpads do not support catch handler flags");
907
908	// If this is a catch-all, register that and abort.
909	if (!handler.Type.RTTI) {
910	assert(!hasCatchAll);
911	hasCatchAll = true;
912	goto done;
913	}
914
915	// Check whether we already have a handler for this type.
916	if (catchTypes.insert(Ptr: handler.Type.RTTI).second)
917	// If not, add it directly to the landingpad.
918	LPadInst->addClause(ClauseVal: handler.Type.RTTI);
919	}
920	}
921
922	done:
923	// If we have a catch-all, add null to the landingpad.
924	assert(!(hasCatchAll && hasFilter));
925	if (hasCatchAll) {
926	LPadInst->addClause(ClauseVal: getCatchAllValue(CGF&: *this));
927
928	// If we have an EH filter, we need to add those handlers in the
929	// right place in the landingpad, which is to say, at the end.
930	} else if (hasFilter) {
931	// Create a filter expression: a constant array indicating which filter
932	// types there are. The personality routine only lands here if the filter
933	// doesn't match.
934	SmallVector<llvm::Constant*, 8> Filters;
935	llvm::ArrayType *AType =
936	llvm::ArrayType::get(ElementType: !filterTypes.empty() ?
937	filterTypes[0]->getType() : Int8PtrTy,
938	NumElements: filterTypes.size());
939
940	for (unsigned i = 0, e = filterTypes.size(); i != e; ++i)
941	Filters.push_back(Elt: cast<llvm::Constant>(Val: filterTypes[i]));
942	llvm::Constant *FilterArray = llvm::ConstantArray::get(T: AType, V: Filters);
943	LPadInst->addClause(ClauseVal: FilterArray);
944
945	// Also check whether we need a cleanup.
946	if (hasCleanup)
947	LPadInst->setCleanup(true);
948
949	// Otherwise, signal that we at least have cleanups.
950	} else if (hasCleanup) {
951	LPadInst->setCleanup(true);
952	}
953
954	assert((LPadInst->getNumClauses() > 0 || LPadInst->isCleanup()) &&
955	"landingpad instruction has no clauses!");
956
957	// Tell the backend how to generate the landing pad.
958	Builder.CreateBr(Dest: getEHDispatchBlock(si: EHStack.getInnermostEHScope()));
959
960	// Restore the old IR generation state.
961	Builder.restoreIP(IP: savedIP);
962
963	return lpad;
964	}
965
966	static 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.
1009	static void emitWasmCatchPadBlock(CodeGenFunction &CGF,
1010	EHCatchScope &CatchScope) {
1011	llvm::BasicBlock *DispatchBlock = CatchScope.getCachedEHDispatchBlock();
1012	assert(DispatchBlock);
1013
1014	CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveIP();
1015	CGF.EmitBlockAfterUses(BB: DispatchBlock);
1016
1017	llvm::Value *ParentPad = CGF.CurrentFuncletPad;
1018	if (!ParentPad)
1019	ParentPad = llvm::ConstantTokenNone::get(Context&: CGF.getLLVMContext());
1020	llvm::BasicBlock *UnwindBB =
1021	CGF.getEHDispatchBlock(si: CatchScope.getEnclosingEHScope());
1022
1023	unsigned NumHandlers = CatchScope.getNumHandlers();
1024	llvm::CatchSwitchInst *CatchSwitch =
1025	CGF.Builder.CreateCatchSwitch(ParentPad, UnwindBB, NumHandlers);
1026
1027	// We don't use a landingpad instruction, so generate intrinsic calls to
1028	// provide exception and selector values.
1029	llvm::BasicBlock *WasmCatchStartBlock = CGF.createBasicBlock(name: "catch.start");
1030	CatchSwitch->addHandler(Dest: WasmCatchStartBlock);
1031	CGF.EmitBlockAfterUses(BB: WasmCatchStartBlock);
1032
1033	// Create a catchpad instruction.
1034	SmallVector<llvm::Value *, 4> CatchTypes;
1035	for (unsigned I = 0, E = NumHandlers; I < E; ++I) {
1036	const EHCatchScope::Handler &Handler = CatchScope.getHandler(I);
1037	CatchTypeInfo TypeInfo = Handler.Type;
1038	if (!TypeInfo.RTTI)
1039	TypeInfo.RTTI = llvm::Constant::getNullValue(Ty: CGF.VoidPtrTy);
1040	CatchTypes.push_back(Elt: TypeInfo.RTTI);
1041	}
1042	auto *CPI = CGF.Builder.CreateCatchPad(ParentPad: CatchSwitch, Args: CatchTypes);
1043
1044	// Create calls to wasm.get.exception and wasm.get.ehselector intrinsics.
1045	// Before they are lowered appropriately later, they provide values for the
1046	// exception and selector.
1047	llvm::Function *GetExnFn =
1048	CGF.CGM.getIntrinsic(llvm::Intrinsic::wasm_get_exception);
1049	llvm::Function *GetSelectorFn =
1050	CGF.CGM.getIntrinsic(llvm::Intrinsic::wasm_get_ehselector);
1051	llvm::CallInst *Exn = CGF.Builder.CreateCall(Callee: GetExnFn, Args: CPI);
1052	CGF.Builder.CreateStore(Val: Exn, Addr: CGF.getExceptionSlot());
1053	llvm::CallInst *Selector = CGF.Builder.CreateCall(Callee: GetSelectorFn, Args: CPI);
1054
1055	llvm::Function *TypeIDFn = CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_typeid_for);
1056
1057	// If there's only a single catch-all, branch directly to its handler.
1058	if (CatchScope.getNumHandlers() == 1 &&
1059	CatchScope.getHandler(I: 0).isCatchAll()) {
1060	CGF.Builder.CreateBr(Dest: CatchScope.getHandler(I: 0).Block);
1061	CGF.Builder.restoreIP(IP: SavedIP);
1062	return;
1063	}
1064
1065	// Test against each of the exception types we claim to catch.
1066	for (unsigned I = 0, E = NumHandlers;; ++I) {
1067	assert(I < E && "ran off end of handlers!");
1068	const EHCatchScope::Handler &Handler = CatchScope.getHandler(I);
1069	CatchTypeInfo TypeInfo = Handler.Type;
1070	if (!TypeInfo.RTTI)
1071	TypeInfo.RTTI = llvm::Constant::getNullValue(Ty: CGF.VoidPtrTy);
1072
1073	// Figure out the next block.
1074	llvm::BasicBlock *NextBlock;
1075
1076	bool EmitNextBlock = false, NextIsEnd = false;
1077
1078	// If this is the last handler, we're at the end, and the next block is a
1079	// block that contains a call to the rethrow function, so we can unwind to
1080	// the enclosing EH scope. The call itself will be generated later.
1081	if (I + 1 == E) {
1082	NextBlock = CGF.createBasicBlock(name: "rethrow");
1083	EmitNextBlock = true;
1084	NextIsEnd = true;
1085
1086	// If the next handler is a catch-all, we're at the end, and the
1087	// next block is that handler.
1088	} else if (CatchScope.getHandler(I: I + 1).isCatchAll()) {
1089	NextBlock = CatchScope.getHandler(I: I + 1).Block;
1090	NextIsEnd = true;
1091
1092	// Otherwise, we're not at the end and we need a new block.
1093	} else {
1094	NextBlock = CGF.createBasicBlock(name: "catch.fallthrough");
1095	EmitNextBlock = true;
1096	}
1097
1098	// Figure out the catch type's index in the LSDA's type table.
1099	llvm::CallInst *TypeIndex = CGF.Builder.CreateCall(Callee: TypeIDFn, Args: TypeInfo.RTTI);
1100	TypeIndex->setDoesNotThrow();
1101
1102	llvm::Value *MatchesTypeIndex =
1103	CGF.Builder.CreateICmpEQ(LHS: Selector, RHS: TypeIndex, Name: "matches");
1104	CGF.Builder.CreateCondBr(Cond: MatchesTypeIndex, True: Handler.Block, False: NextBlock);
1105
1106	if (EmitNextBlock)
1107	CGF.EmitBlock(BB: NextBlock);
1108	if (NextIsEnd)
1109	break;
1110	}
1111
1112	CGF.Builder.restoreIP(IP: SavedIP);
1113	}
1114
1115	/// Emit the structure of the dispatch block for the given catch scope.
1116	/// It is an invariant that the dispatch block already exists.
1117	static void emitCatchDispatchBlock(CodeGenFunction &CGF,
1118	EHCatchScope &catchScope) {
1119	if (EHPersonality::get(CGF).isWasmPersonality())
1120	return emitWasmCatchPadBlock(CGF, CatchScope&: catchScope);
1121	if (EHPersonality::get(CGF).usesFuncletPads())
1122	return emitCatchPadBlock(CGF, CatchScope&: catchScope);
1123
1124	llvm::BasicBlock *dispatchBlock = catchScope.getCachedEHDispatchBlock();
1125	assert(dispatchBlock);
1126
1127	// If there's only a single catch-all, getEHDispatchBlock returned
1128	// that catch-all as the dispatch block.
1129	if (catchScope.getNumHandlers() == 1 &&
1130	catchScope.getHandler(I: 0).isCatchAll()) {
1131	assert(dispatchBlock == catchScope.getHandler(0).Block);
1132	return;
1133	}
1134
1135	CGBuilderTy::InsertPoint savedIP = CGF.Builder.saveIP();
1136	CGF.EmitBlockAfterUses(BB: dispatchBlock);
1137
1138	// Select the right handler.
1139	llvm::Function *llvm_eh_typeid_for =
1140	CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_typeid_for);
1141	llvm::Type *argTy = llvm_eh_typeid_for->getArg(i: 0)->getType();
1142	LangAS globAS = CGF.CGM.GetGlobalVarAddressSpace(D: nullptr);
1143
1144	// Load the selector value.
1145	llvm::Value *selector = CGF.getSelectorFromSlot();
1146
1147	// Test against each of the exception types we claim to catch.
1148	for (unsigned i = 0, e = catchScope.getNumHandlers(); ; ++i) {
1149	assert(i < e && "ran off end of handlers!");
1150	const EHCatchScope::Handler &handler = catchScope.getHandler(I: i);
1151
1152	llvm::Value *typeValue = handler.Type.RTTI;
1153	assert(handler.Type.Flags == 0 &&
1154	"landingpads do not support catch handler flags");
1155	assert(typeValue && "fell into catch-all case!");
1156	// With opaque ptrs, only the address space can be a mismatch.
1157	if (typeValue->getType() != argTy)
1158	typeValue =
1159	CGF.getTargetHooks().performAddrSpaceCast(CGF, V: typeValue, SrcAddr: globAS,
1160	DestAddr: LangAS::Default, DestTy: argTy);
1161
1162	// Figure out the next block.
1163	bool nextIsEnd;
1164	llvm::BasicBlock *nextBlock;
1165
1166	// If this is the last handler, we're at the end, and the next
1167	// block is the block for the enclosing EH scope.
1168	if (i + 1 == e) {
1169	nextBlock = CGF.getEHDispatchBlock(si: catchScope.getEnclosingEHScope());
1170	nextIsEnd = true;
1171
1172	// If the next handler is a catch-all, we're at the end, and the
1173	// next block is that handler.
1174	} else if (catchScope.getHandler(I: i+1).isCatchAll()) {
1175	nextBlock = catchScope.getHandler(I: i+1).Block;
1176	nextIsEnd = true;
1177
1178	// Otherwise, we're not at the end and we need a new block.
1179	} else {
1180	nextBlock = CGF.createBasicBlock(name: "catch.fallthrough");
1181	nextIsEnd = false;
1182	}
1183
1184	// Figure out the catch type's index in the LSDA's type table.
1185	llvm::CallInst *typeIndex =
1186	CGF.Builder.CreateCall(Callee: llvm_eh_typeid_for, Args: typeValue);
1187	typeIndex->setDoesNotThrow();
1188
1189	llvm::Value *matchesTypeIndex =
1190	CGF.Builder.CreateICmpEQ(LHS: selector, RHS: typeIndex, Name: "matches");
1191	CGF.Builder.CreateCondBr(Cond: matchesTypeIndex, True: handler.Block, False: nextBlock);
1192
1193	// If the next handler is a catch-all, we're completely done.
1194	if (nextIsEnd) {
1195	CGF.Builder.restoreIP(IP: savedIP);
1196	return;
1197	}
1198	// Otherwise we need to emit and continue at that block.
1199	CGF.EmitBlock(BB: nextBlock);
1200	}
1201	}
1202
1203	void CodeGenFunction::popCatchScope() {
1204	EHCatchScope &catchScope = cast<EHCatchScope>(Val&: *EHStack.begin());
1205	if (catchScope.hasEHBranches())
1206	emitCatchDispatchBlock(CGF&: *this, catchScope);
1207	EHStack.popCatch();
1208	}
1209
1210	void CodeGenFunction::ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock) {
1211	unsigned NumHandlers = S.getNumHandlers();
1212	EHCatchScope &CatchScope = cast<EHCatchScope>(Val&: *EHStack.begin());
1213	assert(CatchScope.getNumHandlers() == NumHandlers);
1214	llvm::BasicBlock *DispatchBlock = CatchScope.getCachedEHDispatchBlock();
1215
1216	// If the catch was not required, bail out now.
1217	if (!CatchScope.hasEHBranches()) {
1218	CatchScope.clearHandlerBlocks();
1219	EHStack.popCatch();
1220	return;
1221	}
1222
1223	// Emit the structure of the EH dispatch for this catch.
1224	emitCatchDispatchBlock(CGF&: *this, catchScope&: CatchScope);
1225
1226	// Copy the handler blocks off before we pop the EH stack. Emitting
1227	// the handlers might scribble on this memory.
1228	SmallVector<EHCatchScope::Handler, 8> Handlers(
1229	CatchScope.begin(), CatchScope.begin() + NumHandlers);
1230
1231	EHStack.popCatch();
1232
1233	// The fall-through block.
1234	llvm::BasicBlock *ContBB = createBasicBlock(name: "try.cont");
1235
1236	// We just emitted the body of the try; jump to the continue block.
1237	if (HaveInsertPoint())
1238	Builder.CreateBr(Dest: ContBB);
1239
1240	// Determine if we need an implicit rethrow for all these catch handlers;
1241	// see the comment below.
1242	bool doImplicitRethrow = false;
1243	if (IsFnTryBlock)
1244	doImplicitRethrow = isa<CXXDestructorDecl>(Val: CurCodeDecl) ||
1245	isa<CXXConstructorDecl>(Val: CurCodeDecl);
1246
1247	// Wasm uses Windows-style EH instructions, but merges all catch clauses into
1248	// one big catchpad. So we save the old funclet pad here before we traverse
1249	// each catch handler.
1250	SaveAndRestore RestoreCurrentFuncletPad(CurrentFuncletPad);
1251	llvm::BasicBlock *WasmCatchStartBlock = nullptr;
1252	if (EHPersonality::get(CGF&: *this).isWasmPersonality()) {
1253	auto *CatchSwitch =
1254	cast<llvm::CatchSwitchInst>(Val: DispatchBlock->getFirstNonPHI());
1255	WasmCatchStartBlock = CatchSwitch->hasUnwindDest()
1256	? CatchSwitch->getSuccessor(Idx: 1)
1257	: CatchSwitch->getSuccessor(Idx: 0);
1258	auto *CPI = cast<llvm::CatchPadInst>(Val: WasmCatchStartBlock->getFirstNonPHI());
1259	CurrentFuncletPad = CPI;
1260	}
1261
1262	// Perversely, we emit the handlers backwards precisely because we
1263	// want them to appear in source order. In all of these cases, the
1264	// catch block will have exactly one predecessor, which will be a
1265	// particular block in the catch dispatch. However, in the case of
1266	// a catch-all, one of the dispatch blocks will branch to two
1267	// different handlers, and EmitBlockAfterUses will cause the second
1268	// handler to be moved before the first.
1269	bool HasCatchAll = false;
1270	for (unsigned I = NumHandlers; I != 0; --I) {
1271	HasCatchAll |= Handlers[I - 1].isCatchAll();
1272	llvm::BasicBlock *CatchBlock = Handlers[I-1].Block;
1273	EmitBlockAfterUses(BB: CatchBlock);
1274
1275	// Catch the exception if this isn't a catch-all.
1276	const CXXCatchStmt *C = S.getHandler(i: I-1);
1277
1278	// Enter a cleanup scope, including the catch variable and the
1279	// end-catch.
1280	RunCleanupsScope CatchScope(*this);
1281
1282	// Initialize the catch variable and set up the cleanups.
1283	SaveAndRestore RestoreCurrentFuncletPad(CurrentFuncletPad);
1284	CGM.getCXXABI().emitBeginCatch(CGF&: *this, C);
1285
1286	// Emit the PGO counter increment.
1287	incrementProfileCounter(S: C);
1288
1289	// Perform the body of the catch.
1290	EmitStmt(S: C->getHandlerBlock());
1291
1292	// [except.handle]p11:
1293	// The currently handled exception is rethrown if control
1294	// reaches the end of a handler of the function-try-block of a
1295	// constructor or destructor.
1296
1297	// It is important that we only do this on fallthrough and not on
1298	// return. Note that it's illegal to put a return in a
1299	// constructor function-try-block's catch handler (p14), so this
1300	// really only applies to destructors.
1301	if (doImplicitRethrow && HaveInsertPoint()) {
1302	CGM.getCXXABI().emitRethrow(CGF&: *this, /*isNoReturn*/false);
1303	Builder.CreateUnreachable();
1304	Builder.ClearInsertionPoint();
1305	}
1306
1307	// Fall out through the catch cleanups.
1308	CatchScope.ForceCleanup();
1309
1310	// Branch out of the try.
1311	if (HaveInsertPoint())
1312	Builder.CreateBr(Dest: ContBB);
1313	}
1314
1315	// Because in wasm we merge all catch clauses into one big catchpad, in case
1316	// none of the types in catch handlers matches after we test against each of
1317	// them, we should unwind to the next EH enclosing scope. We generate a call
1318	// to rethrow function here to do that.
1319	if (EHPersonality::get(CGF&: *this).isWasmPersonality() && !HasCatchAll) {
1320	assert(WasmCatchStartBlock);
1321	// Navigate for the "rethrow" block we created in emitWasmCatchPadBlock().
1322	// Wasm uses landingpad-style conditional branches to compare selectors, so
1323	// we follow the false destination for each of the cond branches to reach
1324	// the rethrow block.
1325	llvm::BasicBlock *RethrowBlock = WasmCatchStartBlock;
1326	while (llvm::Instruction *TI = RethrowBlock->getTerminator()) {
1327	auto *BI = cast<llvm::BranchInst>(Val: TI);
1328	assert(BI->isConditional());
1329	RethrowBlock = BI->getSuccessor(i: 1);
1330	}
1331	assert(RethrowBlock != WasmCatchStartBlock && RethrowBlock->empty());
1332	Builder.SetInsertPoint(RethrowBlock);
1333	llvm::Function *RethrowInCatchFn =
1334	CGM.getIntrinsic(llvm::Intrinsic::wasm_rethrow);
1335	EmitNoreturnRuntimeCallOrInvoke(callee: RethrowInCatchFn, args: {});
1336	}
1337
1338	EmitBlock(BB: ContBB);
1339	incrementProfileCounter(S: &S);
1340	}
1341
1342	namespace {
1343	struct CallEndCatchForFinally final : EHScopeStack::Cleanup {
1344	llvm::Value *ForEHVar;
1345	llvm::FunctionCallee EndCatchFn;
1346	CallEndCatchForFinally(llvm::Value *ForEHVar,
1347	llvm::FunctionCallee EndCatchFn)
1348	: ForEHVar(ForEHVar), EndCatchFn(EndCatchFn) {}
1349
1350	void Emit(CodeGenFunction &CGF, Flags flags) override {
1351	llvm::BasicBlock *EndCatchBB = CGF.createBasicBlock(name: "finally.endcatch");
1352	llvm::BasicBlock *CleanupContBB =
1353	CGF.createBasicBlock(name: "finally.cleanup.cont");
1354
1355	llvm::Value *ShouldEndCatch =
1356	CGF.Builder.CreateFlagLoad(Addr: ForEHVar, Name: "finally.endcatch");
1357	CGF.Builder.CreateCondBr(Cond: ShouldEndCatch, True: EndCatchBB, False: CleanupContBB);
1358	CGF.EmitBlock(BB: EndCatchBB);
1359	CGF.EmitRuntimeCallOrInvoke(callee: EndCatchFn); // catch-all, so might throw
1360	CGF.EmitBlock(BB: CleanupContBB);
1361	}
1362	};
1363
1364	struct PerformFinally final : EHScopeStack::Cleanup {
1365	const Stmt *Body;
1366	llvm::Value *ForEHVar;
1367	llvm::FunctionCallee EndCatchFn;
1368	llvm::FunctionCallee RethrowFn;
1369	llvm::Value *SavedExnVar;
1370
1371	PerformFinally(const Stmt *Body, llvm::Value *ForEHVar,
1372	llvm::FunctionCallee EndCatchFn,
1373	llvm::FunctionCallee RethrowFn, llvm::Value *SavedExnVar)
1374	: Body(Body), ForEHVar(ForEHVar), EndCatchFn(EndCatchFn),
1375	RethrowFn(RethrowFn), SavedExnVar(SavedExnVar) {}
1376
1377	void Emit(CodeGenFunction &CGF, Flags flags) override {
1378	// Enter a cleanup to call the end-catch function if one was provided.
1379	if (EndCatchFn)
1380	CGF.EHStack.pushCleanup<CallEndCatchForFinally>(Kind: NormalAndEHCleanup,
1381	A: ForEHVar, A: EndCatchFn);
1382
1383	// Save the current cleanup destination in case there are
1384	// cleanups in the finally block.
1385	llvm::Value *SavedCleanupDest =
1386	CGF.Builder.CreateLoad(Addr: CGF.getNormalCleanupDestSlot(),
1387	Name: "cleanup.dest.saved");
1388
1389	// Emit the finally block.
1390	CGF.EmitStmt(S: Body);
1391
1392	// If the end of the finally is reachable, check whether this was
1393	// for EH. If so, rethrow.
1394	if (CGF.HaveInsertPoint()) {
1395	llvm::BasicBlock *RethrowBB = CGF.createBasicBlock(name: "finally.rethrow");
1396	llvm::BasicBlock *ContBB = CGF.createBasicBlock(name: "finally.cont");
1397
1398	llvm::Value *ShouldRethrow =
1399	CGF.Builder.CreateFlagLoad(Addr: ForEHVar, Name: "finally.shouldthrow");
1400	CGF.Builder.CreateCondBr(Cond: ShouldRethrow, True: RethrowBB, False: ContBB);
1401
1402	CGF.EmitBlock(BB: RethrowBB);
1403	if (SavedExnVar) {
1404	CGF.EmitRuntimeCallOrInvoke(RethrowFn,
1405	CGF.Builder.CreateAlignedLoad(CGF.Int8PtrTy, SavedExnVar,
1406	CGF.getPointerAlign()));
1407	} else {
1408	CGF.EmitRuntimeCallOrInvoke(callee: RethrowFn);
1409	}
1410	CGF.Builder.CreateUnreachable();
1411
1412	CGF.EmitBlock(BB: ContBB);
1413
1414	// Restore the cleanup destination.
1415	CGF.Builder.CreateStore(Val: SavedCleanupDest,
1416	Addr: CGF.getNormalCleanupDestSlot());
1417	}
1418
1419	// Leave the end-catch cleanup. As an optimization, pretend that
1420	// the fallthrough path was inaccessible; we've dynamically proven
1421	// that we're not in the EH case along that path.
1422	if (EndCatchFn) {
1423	CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
1424	CGF.PopCleanupBlock();
1425	CGF.Builder.restoreIP(IP: SavedIP);
1426	}
1427
1428	// Now make sure we actually have an insertion point or the
1429	// cleanup gods will hate us.
1430	CGF.EnsureInsertPoint();
1431	}
1432	};
1433	} // end anonymous namespace
1434
1435	/// Enters a finally block for an implementation using zero-cost
1436	/// exceptions. This is mostly general, but hard-codes some
1437	/// language/ABI-specific behavior in the catch-all sections.
1438	void CodeGenFunction::FinallyInfo::enter(CodeGenFunction &CGF, const Stmt *body,
1439	llvm::FunctionCallee beginCatchFn,
1440	llvm::FunctionCallee endCatchFn,
1441	llvm::FunctionCallee rethrowFn) {
1442	assert((!!beginCatchFn) == (!!endCatchFn) &&
1443	"begin/end catch functions not paired");
1444	assert(rethrowFn && "rethrow function is required");
1445
1446	BeginCatchFn = beginCatchFn;
1447
1448	// The rethrow function has one of the following two types:
1449	// void (*)()
1450	// void (*)(void*)
1451	// In the latter case we need to pass it the exception object.
1452	// But we can't use the exception slot because the @finally might
1453	// have a landing pad (which would overwrite the exception slot).
1454	llvm::FunctionType *rethrowFnTy = rethrowFn.getFunctionType();
1455	SavedExnVar = nullptr;
1456	if (rethrowFnTy->getNumParams())
1457	SavedExnVar = CGF.CreateTempAlloca(Ty: CGF.Int8PtrTy, Name: "finally.exn");
1458
1459	// A finally block is a statement which must be executed on any edge
1460	// out of a given scope. Unlike a cleanup, the finally block may
1461	// contain arbitrary control flow leading out of itself. In
1462	// addition, finally blocks should always be executed, even if there
1463	// are no catch handlers higher on the stack. Therefore, we
1464	// surround the protected scope with a combination of a normal
1465	// cleanup (to catch attempts to break out of the block via normal
1466	// control flow) and an EH catch-all (semantically "outside" any try
1467	// statement to which the finally block might have been attached).
1468	// The finally block itself is generated in the context of a cleanup
1469	// which conditionally leaves the catch-all.
1470
1471	// Jump destination for performing the finally block on an exception
1472	// edge. We'll never actually reach this block, so unreachable is
1473	// fine.
1474	RethrowDest = CGF.getJumpDestInCurrentScope(Target: CGF.getUnreachableBlock());
1475
1476	// Whether the finally block is being executed for EH purposes.
1477	ForEHVar = CGF.CreateTempAlloca(Ty: CGF.Builder.getInt1Ty(), Name: "finally.for-eh");
1478	CGF.Builder.CreateFlagStore(Value: false, Addr: ForEHVar);
1479
1480	// Enter a normal cleanup which will perform the @finally block.
1481	CGF.EHStack.pushCleanup<PerformFinally>(Kind: NormalCleanup, A: body,
1482	A: ForEHVar, A: endCatchFn,
1483	A: rethrowFn, A: SavedExnVar);
1484
1485	// Enter a catch-all scope.
1486	llvm::BasicBlock *catchBB = CGF.createBasicBlock(name: "finally.catchall");
1487	EHCatchScope *catchScope = CGF.EHStack.pushCatch(NumHandlers: 1);
1488	catchScope->setCatchAllHandler(I: 0, Block: catchBB);
1489	}
1490
1491	void CodeGenFunction::FinallyInfo::exit(CodeGenFunction &CGF) {
1492	// Leave the finally catch-all.
1493	EHCatchScope &catchScope = cast<EHCatchScope>(Val&: *CGF.EHStack.begin());
1494	llvm::BasicBlock *catchBB = catchScope.getHandler(I: 0).Block;
1495
1496	CGF.popCatchScope();
1497
1498	// If there are any references to the catch-all block, emit it.
1499	if (catchBB->use_empty()) {
1500	delete catchBB;
1501	} else {
1502	CGBuilderTy::InsertPoint savedIP = CGF.Builder.saveAndClearIP();
1503	CGF.EmitBlock(BB: catchBB);
1504
1505	llvm::Value *exn = nullptr;
1506
1507	// If there's a begin-catch function, call it.
1508	if (BeginCatchFn) {
1509	exn = CGF.getExceptionFromSlot();
1510	CGF.EmitNounwindRuntimeCall(callee: BeginCatchFn, args: exn);
1511	}
1512
1513	// If we need to remember the exception pointer to rethrow later, do so.
1514	if (SavedExnVar) {
1515	if (!exn) exn = CGF.getExceptionFromSlot();
1516	CGF.Builder.CreateAlignedStore(exn, SavedExnVar, CGF.getPointerAlign());
1517	}
1518
1519	// Tell the cleanups in the finally block that we're do this for EH.
1520	CGF.Builder.CreateFlagStore(Value: true, Addr: ForEHVar);
1521
1522	// Thread a jump through the finally cleanup.
1523	CGF.EmitBranchThroughCleanup(Dest: RethrowDest);
1524
1525	CGF.Builder.restoreIP(IP: savedIP);
1526	}
1527
1528	// Finally, leave the @finally cleanup.
1529	CGF.PopCleanupBlock();
1530	}
1531
1532	llvm::BasicBlock *CodeGenFunction::getTerminateLandingPad() {
1533	if (TerminateLandingPad)
1534	return TerminateLandingPad;
1535
1536	CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
1537
1538	// This will get inserted at the end of the function.
1539	TerminateLandingPad = createBasicBlock(name: "terminate.lpad");
1540	Builder.SetInsertPoint(TerminateLandingPad);
1541
1542	// Tell the backend that this is a landing pad.
1543	const EHPersonality &Personality = EHPersonality::get(CGF&: *this);
1544
1545	if (!CurFn->hasPersonalityFn())
1546	CurFn->setPersonalityFn(getOpaquePersonalityFn(CGM, Personality));
1547
1548	llvm::LandingPadInst *LPadInst =
1549	Builder.CreateLandingPad(Ty: llvm::StructType::get(elt1: Int8PtrTy, elts: Int32Ty), NumClauses: 0);
1550	LPadInst->addClause(ClauseVal: getCatchAllValue(CGF&: *this));
1551
1552	llvm::Value *Exn = nullptr;
1553	if (getLangOpts().CPlusPlus)
1554	Exn = Builder.CreateExtractValue(Agg: LPadInst, Idxs: 0);
1555	llvm::CallInst *terminateCall =
1556	CGM.getCXXABI().emitTerminateForUnexpectedException(CGF&: *this, Exn);
1557	terminateCall->setDoesNotReturn();
1558	Builder.CreateUnreachable();
1559
1560	// Restore the saved insertion state.
1561	Builder.restoreIP(IP: SavedIP);
1562
1563	return TerminateLandingPad;
1564	}
1565
1566	llvm::BasicBlock *CodeGenFunction::getTerminateHandler() {
1567	if (TerminateHandler)
1568	return TerminateHandler;
1569
1570	// Set up the terminate handler. This block is inserted at the very
1571	// end of the function by FinishFunction.
1572	TerminateHandler = createBasicBlock(name: "terminate.handler");
1573	CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
1574	Builder.SetInsertPoint(TerminateHandler);
1575
1576	llvm::Value *Exn = nullptr;
1577	if (getLangOpts().CPlusPlus)
1578	Exn = getExceptionFromSlot();
1579	llvm::CallInst *terminateCall =
1580	CGM.getCXXABI().emitTerminateForUnexpectedException(CGF&: *this, Exn);
1581	terminateCall->setDoesNotReturn();
1582	Builder.CreateUnreachable();
1583
1584	// Restore the saved insertion state.
1585	Builder.restoreIP(IP: SavedIP);
1586
1587	return TerminateHandler;
1588	}
1589
1590	llvm::BasicBlock *CodeGenFunction::getTerminateFunclet() {
1591	assert(EHPersonality::get(*this).usesFuncletPads() &&
1592	"use getTerminateLandingPad for non-funclet EH");
1593
1594	llvm::BasicBlock *&TerminateFunclet = TerminateFunclets[CurrentFuncletPad];
1595	if (TerminateFunclet)
1596	return TerminateFunclet;
1597
1598	CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
1599
1600	// Set up the terminate handler. This block is inserted at the very
1601	// end of the function by FinishFunction.
1602	TerminateFunclet = createBasicBlock(name: "terminate.handler");
1603	Builder.SetInsertPoint(TerminateFunclet);
1604
1605	// Create the cleanuppad using the current parent pad as its token. Use 'none'
1606	// if this is a top-level terminate scope, which is the common case.
1607	SaveAndRestore RestoreCurrentFuncletPad(CurrentFuncletPad);
1608	llvm::Value *ParentPad = CurrentFuncletPad;
1609	if (!ParentPad)
1610	ParentPad = llvm::ConstantTokenNone::get(Context&: CGM.getLLVMContext());
1611	CurrentFuncletPad = Builder.CreateCleanupPad(ParentPad);
1612
1613	// Emit the __std_terminate call.
1614	llvm::CallInst *terminateCall =
1615	CGM.getCXXABI().emitTerminateForUnexpectedException(CGF&: *this, Exn: nullptr);
1616	terminateCall->setDoesNotReturn();
1617	Builder.CreateUnreachable();
1618
1619	// Restore the saved insertion state.
1620	Builder.restoreIP(IP: SavedIP);
1621
1622	return TerminateFunclet;
1623	}
1624
1625	llvm::BasicBlock *CodeGenFunction::getEHResumeBlock(bool isCleanup) {
1626	if (EHResumeBlock) return EHResumeBlock;
1627
1628	CGBuilderTy::InsertPoint SavedIP = Builder.saveIP();
1629
1630	// We emit a jump to a notional label at the outermost unwind state.
1631	EHResumeBlock = createBasicBlock(name: "eh.resume");
1632	Builder.SetInsertPoint(EHResumeBlock);
1633
1634	const EHPersonality &Personality = EHPersonality::get(CGF&: *this);
1635
1636	// This can always be a call because we necessarily didn't find
1637	// anything on the EH stack which needs our help.
1638	const char *RethrowName = Personality.CatchallRethrowFn;
1639	if (RethrowName != nullptr && !isCleanup) {
1640	EmitRuntimeCall(callee: getCatchallRethrowFn(CGM, Name: RethrowName),
1641	args: getExceptionFromSlot())->setDoesNotReturn();
1642	Builder.CreateUnreachable();
1643	Builder.restoreIP(IP: SavedIP);
1644	return EHResumeBlock;
1645	}
1646
1647	// Recreate the landingpad's return value for the 'resume' instruction.
1648	llvm::Value *Exn = getExceptionFromSlot();
1649	llvm::Value *Sel = getSelectorFromSlot();
1650
1651	llvm::Type *LPadType = llvm::StructType::get(elt1: Exn->getType(), elts: Sel->getType());
1652	llvm::Value *LPadVal = llvm::PoisonValue::get(T: LPadType);
1653	LPadVal = Builder.CreateInsertValue(Agg: LPadVal, Val: Exn, Idxs: 0, Name: "lpad.val");
1654	LPadVal = Builder.CreateInsertValue(Agg: LPadVal, Val: Sel, Idxs: 1, Name: "lpad.val");
1655
1656	Builder.CreateResume(Exn: LPadVal);
1657	Builder.restoreIP(IP: SavedIP);
1658	return EHResumeBlock;
1659	}
1660
1661	void CodeGenFunction::EmitSEHTryStmt(const SEHTryStmt &S) {
1662	EnterSEHTryStmt(S);
1663	{
1664	JumpDest TryExit = getJumpDestInCurrentScope(Name: "__try.__leave");
1665
1666	SEHTryEpilogueStack.push_back(Elt: &TryExit);
1667
1668	llvm::BasicBlock *TryBB = nullptr;
1669	// IsEHa: emit an invoke to _seh_try_begin() runtime for -EHa
1670	if (getLangOpts().EHAsynch) {
1671	EmitRuntimeCallOrInvoke(callee: getSehTryBeginFn(CGM));
1672	if (SEHTryEpilogueStack.size() == 1) // outermost only
1673	TryBB = Builder.GetInsertBlock();
1674	}
1675
1676	EmitStmt(S.getTryBlock());
1677
1678	// Volatilize all blocks in Try, till current insert point
1679	if (TryBB) {
1680	llvm::SmallPtrSet<llvm::BasicBlock *, 10> Visited;
1681	VolatilizeTryBlocks(BB: TryBB, V&: Visited);
1682	}
1683
1684	SEHTryEpilogueStack.pop_back();
1685
1686	if (!TryExit.getBlock()->use_empty())
1687	EmitBlock(BB: TryExit.getBlock(), /*IsFinished=*/true);
1688	else
1689	delete TryExit.getBlock();
1690	}
1691	ExitSEHTryStmt(S);
1692	}
1693
1694	// Recursively walk through blocks in a _try
1695	// and make all memory instructions volatile
1696	void CodeGenFunction::VolatilizeTryBlocks(
1697	llvm::BasicBlock *BB, llvm::SmallPtrSet<llvm::BasicBlock *, 10> &V) {
1698	if (BB == SEHTryEpilogueStack.back()->getBlock() /* end of Try */ ||
1699	!V.insert(Ptr: BB).second /* already visited */ ||
1700	!BB->getParent() /* not emitted */ || BB->empty())
1701	return;
1702
1703	if (!BB->isEHPad()) {
1704	for (llvm::BasicBlock::iterator J = BB->begin(), JE = BB->end(); J != JE;
1705	++J) {
1706	if (auto LI = dyn_cast<llvm::LoadInst>(Val&: J)) {
1707	LI->setVolatile(true);
1708	} else if (auto SI = dyn_cast<llvm::StoreInst>(Val&: J)) {
1709	SI->setVolatile(true);
1710	} else if (auto* MCI = dyn_cast<llvm::MemIntrinsic>(Val&: J)) {
1711	MCI->setVolatile(llvm::ConstantInt::get(Ty: Builder.getInt1Ty(), V: 1));
1712	}
1713	}
1714	}
1715	const llvm::Instruction *TI = BB->getTerminator();
1716	if (TI) {
1717	unsigned N = TI->getNumSuccessors();
1718	for (unsigned I = 0; I < N; I++)
1719	VolatilizeTryBlocks(BB: TI->getSuccessor(Idx: I), V);
1720	}
1721	}
1722
1723	namespace {
1724	struct PerformSEHFinally final : EHScopeStack::Cleanup {
1725	llvm::Function *OutlinedFinally;
1726	PerformSEHFinally(llvm::Function *OutlinedFinally)
1727	: OutlinedFinally(OutlinedFinally) {}
1728
1729	void Emit(CodeGenFunction &CGF, Flags F) override {
1730	ASTContext &Context = CGF.getContext();
1731	CodeGenModule &CGM = CGF.CGM;
1732
1733	CallArgList Args;
1734
1735	// Compute the two argument values.
1736	QualType ArgTys[2] = {Context.UnsignedCharTy, Context.VoidPtrTy};
1737	llvm::Value *FP = nullptr;
1738	// If CFG.IsOutlinedSEHHelper is true, then we are within a finally block.
1739	if (CGF.IsOutlinedSEHHelper) {
1740	FP = &CGF.CurFn->arg_begin()[1];
1741	} else {
1742	llvm::Function *LocalAddrFn =
1743	CGM.getIntrinsic(llvm::Intrinsic::localaddress);
1744	FP = CGF.Builder.CreateCall(Callee: LocalAddrFn);
1745	}
1746
1747	llvm::Value *IsForEH =
1748	llvm::ConstantInt::get(Ty: CGF.ConvertType(T: ArgTys[0]), V: F.isForEHCleanup());
1749
1750	// Except _leave and fall-through at the end, all other exits in a _try
1751	// (return/goto/continue/break) are considered as abnormal terminations
1752	// since _leave/fall-through is always Indexed 0,
1753	// just use NormalCleanupDestSlot (>= 1 for goto/return/..),
1754	// as 1st Arg to indicate abnormal termination
1755	if (!F.isForEHCleanup() && F.hasExitSwitch()) {
1756	Address Addr = CGF.getNormalCleanupDestSlot();
1757	llvm::Value *Load = CGF.Builder.CreateLoad(Addr, Name: "cleanup.dest");
1758	llvm::Value *Zero = llvm::Constant::getNullValue(Ty: CGM.Int32Ty);
1759	IsForEH = CGF.Builder.CreateICmpNE(LHS: Load, RHS: Zero);
1760	}
1761
1762	Args.add(rvalue: RValue::get(V: IsForEH), type: ArgTys[0]);
1763	Args.add(rvalue: RValue::get(V: FP), type: ArgTys[1]);
1764
1765	// Arrange a two-arg function info and type.
1766	const CGFunctionInfo &FnInfo =
1767	CGM.getTypes().arrangeBuiltinFunctionCall(resultType: Context.VoidTy, args: Args);
1768
1769	auto Callee = CGCallee::forDirect(functionPtr: OutlinedFinally);
1770	CGF.EmitCall(CallInfo: FnInfo, Callee, ReturnValue: ReturnValueSlot(), Args);
1771	}
1772	};
1773	} // end anonymous namespace
1774
1775	namespace {
1776	/// Find all local variable captures in the statement.
1777	struct CaptureFinder : ConstStmtVisitor<CaptureFinder> {
1778	CodeGenFunction &ParentCGF;
1779	const VarDecl *ParentThis;
1780	llvm::SmallSetVector<const VarDecl *, 4> Captures;
1781	Address SEHCodeSlot = Address::invalid();
1782	CaptureFinder(CodeGenFunction &ParentCGF, const VarDecl *ParentThis)
1783	: ParentCGF(ParentCGF), ParentThis(ParentThis) {}
1784
1785	// Return true if we need to do any capturing work.
1786	bool foundCaptures() {
1787	return !Captures.empty() || SEHCodeSlot.isValid();
1788	}
1789
1790	void Visit(const Stmt *S) {
1791	// See if this is a capture, then recurse.
1792	ConstStmtVisitor<CaptureFinder>::Visit(S);
1793	for (const Stmt *Child : S->children())
1794	if (Child)
1795	Visit(S: Child);
1796	}
1797
1798	void VisitDeclRefExpr(const DeclRefExpr *E) {
1799	// If this is already a capture, just make sure we capture 'this'.
1800	if (E->refersToEnclosingVariableOrCapture())
1801	Captures.insert(X: ParentThis);
1802
1803	const auto *D = dyn_cast<VarDecl>(Val: E->getDecl());
1804	if (D && D->isLocalVarDeclOrParm() && D->hasLocalStorage())
1805	Captures.insert(X: D);
1806	}
1807
1808	void VisitCXXThisExpr(const CXXThisExpr *E) {
1809	Captures.insert(X: ParentThis);
1810	}
1811
1812	void VisitCallExpr(const CallExpr *E) {
1813	// We only need to add parent frame allocations for these builtins in x86.
1814	if (ParentCGF.getTarget().getTriple().getArch() != llvm::Triple::x86)
1815	return;
1816
1817	unsigned ID = E->getBuiltinCallee();
1818	switch (ID) {
1819	case Builtin::BI__exception_code:
1820	case Builtin::BI_exception_code:
1821	// This is the simple case where we are the outermost finally. All we
1822	// have to do here is make sure we escape this and recover it in the
1823	// outlined handler.
1824	if (!SEHCodeSlot.isValid())
1825	SEHCodeSlot = ParentCGF.SEHCodeSlotStack.back();
1826	break;
1827	}
1828	}
1829	};
1830	} // end anonymous namespace
1831
1832	Address CodeGenFunction::recoverAddrOfEscapedLocal(CodeGenFunction &ParentCGF,
1833	Address ParentVar,
1834	llvm::Value *ParentFP) {
1835	llvm::CallInst *RecoverCall = nullptr;
1836	CGBuilderTy Builder(*this, AllocaInsertPt);
1837	if (auto *ParentAlloca =
1838	dyn_cast_or_null<llvm::AllocaInst>(Val: ParentVar.getBasePointer())) {
1839	// Mark the variable escaped if nobody else referenced it and compute the
1840	// localescape index.
1841	auto InsertPair = ParentCGF.EscapedLocals.insert(
1842	KV: std::make_pair(x&: ParentAlloca, y: ParentCGF.EscapedLocals.size()));
1843	int FrameEscapeIdx = InsertPair.first->second;
1844	// call ptr @llvm.localrecover(ptr @parentFn, ptr %fp, i32 N)
1845	llvm::Function *FrameRecoverFn = llvm::Intrinsic::getDeclaration(
1846	&CGM.getModule(), llvm::Intrinsic::localrecover);
1847	RecoverCall = Builder.CreateCall(
1848	Callee: FrameRecoverFn, Args: {ParentCGF.CurFn, ParentFP,
1849	llvm::ConstantInt::get(Ty: Int32Ty, V: FrameEscapeIdx)});
1850
1851	} else {
1852	// If the parent didn't have an alloca, we're doing some nested outlining.
1853	// Just clone the existing localrecover call, but tweak the FP argument to
1854	// use our FP value. All other arguments are constants.
1855	auto *ParentRecover = cast<llvm::IntrinsicInst>(
1856	Val: ParentVar.emitRawPointer(CGF&: *this)->stripPointerCasts());
1857	assert(ParentRecover->getIntrinsicID() == llvm::Intrinsic::localrecover &&
1858	"expected alloca or localrecover in parent LocalDeclMap");
1859	RecoverCall = cast<llvm::CallInst>(Val: ParentRecover->clone());
1860	RecoverCall->setArgOperand(i: 1, v: ParentFP);
1861	RecoverCall->insertBefore(InsertPos: AllocaInsertPt);
1862	}
1863
1864	// Bitcast the variable, rename it, and insert it in the local decl map.
1865	llvm::Value *ChildVar =
1866	Builder.CreateBitCast(V: RecoverCall, DestTy: ParentVar.getType());
1867	ChildVar->setName(ParentVar.getName());
1868	return ParentVar.withPointer(NewPointer: ChildVar, IsKnownNonNull: KnownNonNull);
1869	}
1870
1871	void CodeGenFunction::EmitCapturedLocals(CodeGenFunction &ParentCGF,
1872	const Stmt *OutlinedStmt,
1873	bool IsFilter) {
1874	// Find all captures in the Stmt.
1875	CaptureFinder Finder(ParentCGF, ParentCGF.CXXABIThisDecl);
1876	Finder.Visit(S: OutlinedStmt);
1877
1878	// We can exit early on x86_64 when there are no captures. We just have to
1879	// save the exception code in filters so that __exception_code() works.
1880	if (!Finder.foundCaptures() &&
1881	CGM.getTarget().getTriple().getArch() != llvm::Triple::x86) {
1882	if (IsFilter)
1883	EmitSEHExceptionCodeSave(ParentCGF, ParentFP: nullptr, EntryEBP: nullptr);
1884	return;
1885	}
1886
1887	llvm::Value *EntryFP = nullptr;
1888	CGBuilderTy Builder(CGM, AllocaInsertPt);
1889	if (IsFilter && CGM.getTarget().getTriple().getArch() == llvm::Triple::x86) {
1890	// 32-bit SEH filters need to be careful about FP recovery. The end of the
1891	// EH registration is passed in as the EBP physical register. We can
1892	// recover that with llvm.frameaddress(1).
1893	EntryFP = Builder.CreateCall(
1894	CGM.getIntrinsic(llvm::Intrinsic::frameaddress, AllocaInt8PtrTy),
1895	{Builder.getInt32(1)});
1896	} else {
1897	// Otherwise, for x64 and 32-bit finally functions, the parent FP is the
1898	// second parameter.
1899	auto AI = CurFn->arg_begin();
1900	++AI;
1901	EntryFP = &*AI;
1902	}
1903
1904	llvm::Value *ParentFP = EntryFP;
1905	if (IsFilter) {
1906	// Given whatever FP the runtime provided us in EntryFP, recover the true
1907	// frame pointer of the parent function. We only need to do this in filters,
1908	// since finally funclets recover the parent FP for us.
1909	llvm::Function *RecoverFPIntrin =
1910	CGM.getIntrinsic(llvm::Intrinsic::eh_recoverfp);
1911	ParentFP = Builder.CreateCall(Callee: RecoverFPIntrin, Args: {ParentCGF.CurFn, EntryFP});
1912
1913	// if the parent is a _finally, the passed-in ParentFP is the FP
1914	// of parent _finally, not Establisher's FP (FP of outermost function).
1915	// Establkisher FP is 2nd paramenter passed into parent _finally.
1916	// Fortunately, it's always saved in parent's frame. The following
1917	// code retrieves it, and escapes it so that spill instruction won't be
1918	// optimized away.
1919	if (ParentCGF.ParentCGF != nullptr) {
1920	// Locate and escape Parent's frame_pointer.addr alloca
1921	// Depending on target, should be 1st/2nd one in LocalDeclMap.
1922	// Let's just scan for ImplicitParamDecl with VoidPtrTy.
1923	llvm::AllocaInst *FramePtrAddrAlloca = nullptr;
1924	for (auto &I : ParentCGF.LocalDeclMap) {
1925	const VarDecl *D = cast<VarDecl>(Val: I.first);
1926	if (isa<ImplicitParamDecl>(Val: D) &&
1927	D->getType() == getContext().VoidPtrTy) {
1928	assert(D->getName().starts_with("frame_pointer"));
1929	FramePtrAddrAlloca =
1930	cast<llvm::AllocaInst>(Val: I.second.getBasePointer());
1931	break;
1932	}
1933	}
1934	assert(FramePtrAddrAlloca);
1935	auto InsertPair = ParentCGF.EscapedLocals.insert(
1936	KV: std::make_pair(x&: FramePtrAddrAlloca, y: ParentCGF.EscapedLocals.size()));
1937	int FrameEscapeIdx = InsertPair.first->second;
1938
1939	// an example of a filter's prolog::
1940	// %0 = call ptr @llvm.eh.recoverfp(@"?fin$0@0@main@@",..)
1941	// %1 = call ptr @llvm.localrecover(@"?fin$0@0@main@@",..)
1942	// %2 = load ptr, ptr %1, align 8
1943	// ==> %2 is the frame-pointer of outermost host function
1944	llvm::Function *FrameRecoverFn = llvm::Intrinsic::getDeclaration(
1945	&CGM.getModule(), llvm::Intrinsic::localrecover);
1946	ParentFP = Builder.CreateCall(
1947	Callee: FrameRecoverFn, Args: {ParentCGF.CurFn, ParentFP,
1948	llvm::ConstantInt::get(Ty: Int32Ty, V: FrameEscapeIdx)});
1949	ParentFP = Builder.CreateLoad(
1950	Addr: Address(ParentFP, CGM.VoidPtrTy, getPointerAlign()));
1951	}
1952	}
1953
1954	// Create llvm.localrecover calls for all captures.
1955	for (const VarDecl *VD : Finder.Captures) {
1956	if (VD->getType()->isVariablyModifiedType()) {
1957	CGM.ErrorUnsupported(VD, "VLA captured by SEH");
1958	continue;
1959	}
1960	assert((isa<ImplicitParamDecl>(VD) || VD->isLocalVarDeclOrParm()) &&
1961	"captured non-local variable");
1962
1963	auto L = ParentCGF.LambdaCaptureFields.find(VD);
1964	if (L != ParentCGF.LambdaCaptureFields.end()) {
1965	LambdaCaptureFields[VD] = L->second;
1966	continue;
1967	}
1968
1969	// If this decl hasn't been declared yet, it will be declared in the
1970	// OutlinedStmt.
1971	auto I = ParentCGF.LocalDeclMap.find(VD);
1972	if (I == ParentCGF.LocalDeclMap.end())
1973	continue;
1974
1975	Address ParentVar = I->second;
1976	Address Recovered =
1977	recoverAddrOfEscapedLocal(ParentCGF, ParentVar, ParentFP);
1978	setAddrOfLocalVar(VD, Recovered);
1979
1980	if (isa<ImplicitParamDecl>(VD)) {
1981	CXXABIThisAlignment = ParentCGF.CXXABIThisAlignment;
1982	CXXThisAlignment = ParentCGF.CXXThisAlignment;
1983	CXXABIThisValue = Builder.CreateLoad(Recovered, "this");
1984	if (ParentCGF.LambdaThisCaptureField) {
1985	LambdaThisCaptureField = ParentCGF.LambdaThisCaptureField;
1986	// We are in a lambda function where "this" is captured so the
1987	// CXXThisValue need to be loaded from the lambda capture
1988	LValue ThisFieldLValue =
1989	EmitLValueForLambdaField(LambdaThisCaptureField);
1990	if (!LambdaThisCaptureField->getType()->isPointerType()) {
1991	CXXThisValue =
1992	ThisFieldLValue.getAddress(*this).emitRawPointer(*this);
1993	} else {
1994	CXXThisValue = EmitLoadOfLValue(ThisFieldLValue, SourceLocation())
1995	.getScalarVal();
1996	}
1997	} else {
1998	CXXThisValue = CXXABIThisValue;
1999	}
2000	}
2001	}
2002
2003	if (Finder.SEHCodeSlot.isValid()) {
2004	SEHCodeSlotStack.push_back(
2005	Elt: recoverAddrOfEscapedLocal(ParentCGF, ParentVar: Finder.SEHCodeSlot, ParentFP));
2006	}
2007
2008	if (IsFilter)
2009	EmitSEHExceptionCodeSave(ParentCGF, ParentFP, EntryEBP: EntryFP);
2010	}
2011
2012	/// Arrange a function prototype that can be called by Windows exception
2013	/// handling personalities. On Win64, the prototype looks like:
2014	/// RetTy func(void *EHPtrs, void *ParentFP);
2015	void CodeGenFunction::startOutlinedSEHHelper(CodeGenFunction &ParentCGF,
2016	bool IsFilter,
2017	const Stmt *OutlinedStmt) {
2018	SourceLocation StartLoc = OutlinedStmt->getBeginLoc();
2019
2020	// Get the mangled function name.
2021	SmallString<128> Name;
2022	{
2023	llvm::raw_svector_ostream OS(Name);
2024	GlobalDecl ParentSEHFn = ParentCGF.CurSEHParent;
2025	assert(ParentSEHFn && "No CurSEHParent!");
2026	MangleContext &Mangler = CGM.getCXXABI().getMangleContext();
2027	if (IsFilter)
2028	Mangler.mangleSEHFilterExpression(EnclosingDecl: ParentSEHFn, Out&: OS);
2029	else
2030	Mangler.mangleSEHFinallyBlock(EnclosingDecl: ParentSEHFn, Out&: OS);
2031	}
2032
2033	FunctionArgList Args;
2034	if (CGM.getTarget().getTriple().getArch() != llvm::Triple::x86 || !IsFilter) {
2035	// All SEH finally functions take two parameters. Win64 filters take two
2036	// parameters. Win32 filters take no parameters.
2037	if (IsFilter) {
2038	Args.push_back(Elt: ImplicitParamDecl::Create(
2039	getContext(), /*DC=*/nullptr, StartLoc,
2040	&getContext().Idents.get(Name: "exception_pointers"),
2041	getContext().VoidPtrTy, ImplicitParamKind::Other));
2042	} else {
2043	Args.push_back(Elt: ImplicitParamDecl::Create(
2044	getContext(), /*DC=*/nullptr, StartLoc,
2045	&getContext().Idents.get(Name: "abnormal_termination"),
2046	getContext().UnsignedCharTy, ImplicitParamKind::Other));
2047	}
2048	Args.push_back(Elt: ImplicitParamDecl::Create(
2049	getContext(), /*DC=*/nullptr, StartLoc,
2050	&getContext().Idents.get(Name: "frame_pointer"), getContext().VoidPtrTy,
2051	ImplicitParamKind::Other));
2052	}
2053
2054	QualType RetTy = IsFilter ? getContext().LongTy : getContext().VoidTy;
2055
2056	const CGFunctionInfo &FnInfo =
2057	CGM.getTypes().arrangeBuiltinFunctionDeclaration(resultType: RetTy, args: Args);
2058
2059	llvm::FunctionType *FnTy = CGM.getTypes().GetFunctionType(Info: FnInfo);
2060	llvm::Function *Fn = llvm::Function::Create(
2061	Ty: FnTy, Linkage: llvm::GlobalValue::InternalLinkage, N: Name.str(), M: &CGM.getModule());
2062
2063	IsOutlinedSEHHelper = true;
2064
2065	StartFunction(GD: GlobalDecl(), RetTy, Fn, FnInfo, Args,
2066	Loc: OutlinedStmt->getBeginLoc(), StartLoc: OutlinedStmt->getBeginLoc());
2067	CurSEHParent = ParentCGF.CurSEHParent;
2068
2069	CGM.SetInternalFunctionAttributes(GD: GlobalDecl(), F: CurFn, FI: FnInfo);
2070	EmitCapturedLocals(ParentCGF, OutlinedStmt, IsFilter);
2071	}
2072
2073	/// Create a stub filter function that will ultimately hold the code of the
2074	/// filter expression. The EH preparation passes in LLVM will outline the code
2075	/// from the main function body into this stub.
2076	llvm::Function *
2077	CodeGenFunction::GenerateSEHFilterFunction(CodeGenFunction &ParentCGF,
2078	const SEHExceptStmt &Except) {
2079	const Expr *FilterExpr = Except.getFilterExpr();
2080	startOutlinedSEHHelper(ParentCGF, true, FilterExpr);
2081
2082	// Emit the original filter expression, convert to i32, and return.
2083	llvm::Value *R = EmitScalarExpr(E: FilterExpr);
2084	R = Builder.CreateIntCast(R, ConvertType(getContext().LongTy),
2085	FilterExpr->getType()->isSignedIntegerType());
2086	Builder.CreateStore(Val: R, Addr: ReturnValue);
2087
2088	FinishFunction(EndLoc: FilterExpr->getEndLoc());
2089
2090	return CurFn;
2091	}
2092
2093	llvm::Function *
2094	CodeGenFunction::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
2107	void CodeGenFunction::EmitSEHExceptionCodeSave(CodeGenFunction &ParentCGF,
2108	llvm::Value *ParentFP,
2109	llvm::Value *EntryFP) {
2110	// Get the pointer to the EXCEPTION_POINTERS struct. This is returned by the
2111	// __exception_info intrinsic.
2112	if (CGM.getTarget().getTriple().getArch() != llvm::Triple::x86) {
2113	// On Win64, the info is passed as the first parameter to the filter.
2114	SEHInfo = &*CurFn->arg_begin();
2115	SEHCodeSlotStack.push_back(
2116	Elt: CreateMemTemp(getContext().IntTy, "__exception_code"));
2117	} else {
2118	// On Win32, the EBP on entry to the filter points to the end of an
2119	// exception registration object. It contains 6 32-bit fields, and the info
2120	// pointer is stored in the second field. So, GEP 20 bytes backwards and
2121	// load the pointer.
2122	SEHInfo = Builder.CreateConstInBoundsGEP1_32(Ty: Int8Ty, Ptr: EntryFP, Idx0: -20);
2123	SEHInfo = Builder.CreateAlignedLoad(Int8PtrTy, SEHInfo, getPointerAlign());
2124	SEHCodeSlotStack.push_back(Elt: recoverAddrOfEscapedLocal(
2125	ParentCGF, ParentVar: ParentCGF.SEHCodeSlotStack.back(), ParentFP));
2126	}
2127
2128	// Save the exception code in the exception slot to unify exception access in
2129	// the filter function and the landing pad.
2130	// struct EXCEPTION_POINTERS {
2131	// EXCEPTION_RECORD *ExceptionRecord;
2132	// CONTEXT *ContextRecord;
2133	// };
2134	// int exceptioncode = exception_pointers->ExceptionRecord->ExceptionCode;
2135	llvm::Type *RecordTy = llvm::PointerType::getUnqual(C&: getLLVMContext());
2136	llvm::Type *PtrsTy = llvm::StructType::get(elt1: RecordTy, elts: CGM.VoidPtrTy);
2137	llvm::Value *Rec = Builder.CreateStructGEP(Ty: PtrsTy, Ptr: SEHInfo, Idx: 0);
2138	Rec = Builder.CreateAlignedLoad(RecordTy, Rec, getPointerAlign());
2139	llvm::Value *Code = Builder.CreateAlignedLoad(Int32Ty, Rec, getIntAlign());
2140	assert(!SEHCodeSlotStack.empty() && "emitting EH code outside of __except");
2141	Builder.CreateStore(Val: Code, Addr: SEHCodeSlotStack.back());
2142	}
2143
2144	llvm::Value *CodeGenFunction::EmitSEHExceptionInfo() {
2145	// Sema should diagnose calling this builtin outside of a filter context, but
2146	// don't crash if we screw up.
2147	if (!SEHInfo)
2148	return llvm::UndefValue::get(T: Int8PtrTy);
2149	assert(SEHInfo->getType() == Int8PtrTy);
2150	return SEHInfo;
2151	}
2152
2153	llvm::Value *CodeGenFunction::EmitSEHExceptionCode() {
2154	assert(!SEHCodeSlotStack.empty() && "emitting EH code outside of __except");
2155	return Builder.CreateLoad(Addr: SEHCodeSlotStack.back());
2156	}
2157
2158	llvm::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
2165	void CodeGenFunction::pushSEHCleanup(CleanupKind Kind,
2166	llvm::Function *FinallyFunc) {
2167	EHStack.pushCleanup<PerformSEHFinally>(Kind, A: FinallyFunc);
2168	}
2169
2170	void CodeGenFunction::EnterSEHTryStmt(const SEHTryStmt &S) {
2171	CodeGenFunction HelperCGF(CGM, /*suppressNewContext=*/true);
2172	HelperCGF.ParentCGF = this;
2173	if (const SEHFinallyStmt *Finally = S.getFinallyHandler()) {
2174	// Outline the finally block.
2175	llvm::Function *FinallyFunc =
2176	HelperCGF.GenerateSEHFinallyFunction(ParentCGF&: *this, Finally: *Finally);
2177
2178	// Push a cleanup for __finally blocks.
2179	EHStack.pushCleanup<PerformSEHFinally>(Kind: NormalAndEHCleanup, A: FinallyFunc);
2180	return;
2181	}
2182
2183	// Otherwise, we must have an __except block.
2184	const SEHExceptStmt *Except = S.getExceptHandler();
2185	assert(Except);
2186	EHCatchScope *CatchScope = EHStack.pushCatch(NumHandlers: 1);
2187	SEHCodeSlotStack.push_back(
2188	Elt: CreateMemTemp(getContext().IntTy, "__exception_code"));
2189
2190	// If the filter is known to evaluate to 1, then we can use the clause
2191	// "catch i8* null". We can't do this on x86 because the filter has to save
2192	// the exception code.
2193	llvm::Constant *C =
2194	ConstantEmitter(*this).tryEmitAbstract(Except->getFilterExpr(),
2195	getContext().IntTy);
2196	if (CGM.getTarget().getTriple().getArch() != llvm::Triple::x86 && C &&
2197	C->isOneValue()) {
2198	CatchScope->setCatchAllHandler(I: 0, Block: createBasicBlock(name: "__except"));
2199	return;
2200	}
2201
2202	// In general, we have to emit an outlined filter function. Use the function
2203	// in place of the RTTI typeinfo global that C++ EH uses.
2204	llvm::Function *FilterFunc =
2205	HelperCGF.GenerateSEHFilterFunction(ParentCGF&: *this, Except: *Except);
2206	CatchScope->setHandler(I: 0, Type: FilterFunc, Block: createBasicBlock(name: "__except.ret"));
2207	}
2208
2209	void CodeGenFunction::ExitSEHTryStmt(const SEHTryStmt &S) {
2210	// Just pop the cleanup if it's a __finally block.
2211	if (S.getFinallyHandler()) {
2212	PopCleanupBlock();
2213	return;
2214	}
2215
2216	// IsEHa: emit an invoke _seh_try_end() to mark end of FT flow
2217	if (getLangOpts().EHAsynch && Builder.GetInsertBlock()) {
2218	llvm::FunctionCallee SehTryEnd = getSehTryEndFn(CGM);
2219	EmitRuntimeCallOrInvoke(callee: SehTryEnd);
2220	}
2221
2222	// Otherwise, we must have an __except block.
2223	const SEHExceptStmt *Except = S.getExceptHandler();
2224	assert(Except && "__try must have __finally xor __except");
2225	EHCatchScope &CatchScope = cast<EHCatchScope>(Val&: *EHStack.begin());
2226
2227	// Don't emit the __except block if the __try block lacked invokes.
2228	// TODO: Model unwind edges from instructions, either with iload / istore or
2229	// a try body function.
2230	if (!CatchScope.hasEHBranches()) {
2231	CatchScope.clearHandlerBlocks();
2232	EHStack.popCatch();
2233	SEHCodeSlotStack.pop_back();
2234	return;
2235	}
2236
2237	// The fall-through block.
2238	llvm::BasicBlock *ContBB = createBasicBlock(name: "__try.cont");
2239
2240	// We just emitted the body of the __try; jump to the continue block.
2241	if (HaveInsertPoint())
2242	Builder.CreateBr(Dest: ContBB);
2243
2244	// Check if our filter function returned true.
2245	emitCatchDispatchBlock(CGF&: *this, catchScope&: CatchScope);
2246
2247	// Grab the block before we pop the handler.
2248	llvm::BasicBlock *CatchPadBB = CatchScope.getHandler(I: 0).Block;
2249	EHStack.popCatch();
2250
2251	EmitBlockAfterUses(BB: CatchPadBB);
2252
2253	// __except blocks don't get outlined into funclets, so immediately do a
2254	// catchret.
2255	llvm::CatchPadInst *CPI =
2256	cast<llvm::CatchPadInst>(Val: CatchPadBB->getFirstNonPHI());
2257	llvm::BasicBlock *ExceptBB = createBasicBlock(name: "__except");
2258	Builder.CreateCatchRet(CatchPad: CPI, BB: ExceptBB);
2259	EmitBlock(BB: ExceptBB);
2260
2261	// On Win64, the exception code is returned in EAX. Copy it into the slot.
2262	if (CGM.getTarget().getTriple().getArch() != llvm::Triple::x86) {
2263	llvm::Function *SEHCodeIntrin =
2264	CGM.getIntrinsic(llvm::Intrinsic::eh_exceptioncode);
2265	llvm::Value *Code = Builder.CreateCall(Callee: SEHCodeIntrin, Args: {CPI});
2266	Builder.CreateStore(Val: Code, Addr: SEHCodeSlotStack.back());
2267	}
2268
2269	// Emit the __except body.
2270	EmitStmt(Except->getBlock());
2271
2272	// End the lifetime of the exception code.
2273	SEHCodeSlotStack.pop_back();
2274
2275	if (HaveInsertPoint())
2276	Builder.CreateBr(Dest: ContBB);
2277
2278	EmitBlock(BB: ContBB);
2279	}
2280
2281	void 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