blob: 36642bcc48ffee023dd4a4659f9b18d37945168c [file] [log] [blame]
Anders Carlsson756b5c42009-10-30 01:42:31 +00001//===--- CGException.cpp - Emit LLVM Code for C++ exceptions --------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This contains code dealing with C++ exception related code generation.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CodeGenFunction.h"
John McCall36f893c2011-01-28 11:13:47 +000015#include "CGCleanup.h"
Benjamin Krameraf2771b2012-02-08 12:41:24 +000016#include "CGObjCRuntime.h"
John McCall204b0752010-07-20 22:17:55 +000017#include "TargetInfo.h"
Benjamin Krameraf2771b2012-02-08 12:41:24 +000018#include "clang/AST/StmtCXX.h"
Chandler Carruthb1ba0ef2013-01-19 08:09:44 +000019#include "clang/AST/StmtObjC.h"
Chandler Carruth3b844ba2013-01-02 11:45:17 +000020#include "llvm/IR/Intrinsics.h"
Benjamin Krameraf2771b2012-02-08 12:41:24 +000021#include "llvm/Support/CallSite.h"
John McCallf1549f62010-07-06 01:34:17 +000022
Anders Carlsson756b5c42009-10-30 01:42:31 +000023using namespace clang;
24using namespace CodeGen;
25
John McCall629df012013-02-12 03:51:38 +000026static llvm::Constant *getAllocateExceptionFn(CodeGenModule &CGM) {
Anders Carlssond3379292009-10-30 02:27:02 +000027 // void *__cxa_allocate_exception(size_t thrown_size);
Mike Stump8755ec32009-12-10 00:06:18 +000028
Chris Lattner2acc6e32011-07-18 04:24:23 +000029 llvm::FunctionType *FTy =
John McCall629df012013-02-12 03:51:38 +000030 llvm::FunctionType::get(CGM.Int8PtrTy, CGM.SizeTy, /*IsVarArgs=*/false);
Mike Stump8755ec32009-12-10 00:06:18 +000031
John McCall629df012013-02-12 03:51:38 +000032 return CGM.CreateRuntimeFunction(FTy, "__cxa_allocate_exception");
Anders Carlssond3379292009-10-30 02:27:02 +000033}
34
John McCall629df012013-02-12 03:51:38 +000035static llvm::Constant *getFreeExceptionFn(CodeGenModule &CGM) {
Mike Stump99533832009-12-02 07:41:41 +000036 // void __cxa_free_exception(void *thrown_exception);
Mike Stump8755ec32009-12-10 00:06:18 +000037
Chris Lattner2acc6e32011-07-18 04:24:23 +000038 llvm::FunctionType *FTy =
John McCall629df012013-02-12 03:51:38 +000039 llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*IsVarArgs=*/false);
Mike Stump8755ec32009-12-10 00:06:18 +000040
John McCall629df012013-02-12 03:51:38 +000041 return CGM.CreateRuntimeFunction(FTy, "__cxa_free_exception");
Mike Stump99533832009-12-02 07:41:41 +000042}
43
John McCall629df012013-02-12 03:51:38 +000044static llvm::Constant *getThrowFn(CodeGenModule &CGM) {
Mike Stump8755ec32009-12-10 00:06:18 +000045 // void __cxa_throw(void *thrown_exception, std::type_info *tinfo,
Mike Stump99533832009-12-02 07:41:41 +000046 // void (*dest) (void *));
Anders Carlssond3379292009-10-30 02:27:02 +000047
John McCall629df012013-02-12 03:51:38 +000048 llvm::Type *Args[3] = { CGM.Int8PtrTy, CGM.Int8PtrTy, CGM.Int8PtrTy };
Chris Lattner2acc6e32011-07-18 04:24:23 +000049 llvm::FunctionType *FTy =
John McCall629df012013-02-12 03:51:38 +000050 llvm::FunctionType::get(CGM.VoidTy, Args, /*IsVarArgs=*/false);
Mike Stump8755ec32009-12-10 00:06:18 +000051
John McCall629df012013-02-12 03:51:38 +000052 return CGM.CreateRuntimeFunction(FTy, "__cxa_throw");
Anders Carlssond3379292009-10-30 02:27:02 +000053}
54
John McCall629df012013-02-12 03:51:38 +000055static llvm::Constant *getReThrowFn(CodeGenModule &CGM) {
Mike Stump99533832009-12-02 07:41:41 +000056 // void __cxa_rethrow();
Mike Stumpb4eea692009-11-20 00:56:31 +000057
Chris Lattner2acc6e32011-07-18 04:24:23 +000058 llvm::FunctionType *FTy =
John McCall629df012013-02-12 03:51:38 +000059 llvm::FunctionType::get(CGM.VoidTy, /*IsVarArgs=*/false);
Mike Stump8755ec32009-12-10 00:06:18 +000060
John McCall629df012013-02-12 03:51:38 +000061 return CGM.CreateRuntimeFunction(FTy, "__cxa_rethrow");
Mike Stumpb4eea692009-11-20 00:56:31 +000062}
63
John McCall629df012013-02-12 03:51:38 +000064static llvm::Constant *getGetExceptionPtrFn(CodeGenModule &CGM) {
John McCallf1549f62010-07-06 01:34:17 +000065 // void *__cxa_get_exception_ptr(void*);
John McCallf1549f62010-07-06 01:34:17 +000066
Chris Lattner2acc6e32011-07-18 04:24:23 +000067 llvm::FunctionType *FTy =
John McCall629df012013-02-12 03:51:38 +000068 llvm::FunctionType::get(CGM.Int8PtrTy, CGM.Int8PtrTy, /*IsVarArgs=*/false);
John McCallf1549f62010-07-06 01:34:17 +000069
John McCall629df012013-02-12 03:51:38 +000070 return CGM.CreateRuntimeFunction(FTy, "__cxa_get_exception_ptr");
John McCallf1549f62010-07-06 01:34:17 +000071}
72
John McCall629df012013-02-12 03:51:38 +000073static llvm::Constant *getBeginCatchFn(CodeGenModule &CGM) {
John McCallf1549f62010-07-06 01:34:17 +000074 // void *__cxa_begin_catch(void*);
Mike Stump2bf701e2009-11-20 23:44:51 +000075
Chris Lattner2acc6e32011-07-18 04:24:23 +000076 llvm::FunctionType *FTy =
John McCall629df012013-02-12 03:51:38 +000077 llvm::FunctionType::get(CGM.Int8PtrTy, CGM.Int8PtrTy, /*IsVarArgs=*/false);
Mike Stump8755ec32009-12-10 00:06:18 +000078
John McCall629df012013-02-12 03:51:38 +000079 return CGM.CreateRuntimeFunction(FTy, "__cxa_begin_catch");
Mike Stump2bf701e2009-11-20 23:44:51 +000080}
81
John McCall629df012013-02-12 03:51:38 +000082static llvm::Constant *getEndCatchFn(CodeGenModule &CGM) {
Mike Stump99533832009-12-02 07:41:41 +000083 // void __cxa_end_catch();
Mike Stump2bf701e2009-11-20 23:44:51 +000084
Chris Lattner2acc6e32011-07-18 04:24:23 +000085 llvm::FunctionType *FTy =
John McCall629df012013-02-12 03:51:38 +000086 llvm::FunctionType::get(CGM.VoidTy, /*IsVarArgs=*/false);
Mike Stump8755ec32009-12-10 00:06:18 +000087
John McCall629df012013-02-12 03:51:38 +000088 return CGM.CreateRuntimeFunction(FTy, "__cxa_end_catch");
Mike Stump2bf701e2009-11-20 23:44:51 +000089}
90
John McCall629df012013-02-12 03:51:38 +000091static llvm::Constant *getUnexpectedFn(CodeGenModule &CGM) {
Mike Stumpcce3d4f2009-12-07 23:38:24 +000092 // void __cxa_call_unexepcted(void *thrown_exception);
93
Chris Lattner2acc6e32011-07-18 04:24:23 +000094 llvm::FunctionType *FTy =
John McCall629df012013-02-12 03:51:38 +000095 llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*IsVarArgs=*/false);
Mike Stump8755ec32009-12-10 00:06:18 +000096
John McCall629df012013-02-12 03:51:38 +000097 return CGM.CreateRuntimeFunction(FTy, "__cxa_call_unexpected");
Mike Stumpcce3d4f2009-12-07 23:38:24 +000098}
99
John McCall93c332a2011-05-28 21:13:02 +0000100llvm::Constant *CodeGenFunction::getUnwindResumeFn() {
Chris Lattner2acc6e32011-07-18 04:24:23 +0000101 llvm::FunctionType *FTy =
Jay Foadda549e82011-07-29 13:56:53 +0000102 llvm::FunctionType::get(VoidTy, Int8PtrTy, /*IsVarArgs=*/false);
John McCall93c332a2011-05-28 21:13:02 +0000103
David Blaikie4e4d0842012-03-11 07:00:24 +0000104 if (CGM.getLangOpts().SjLjExceptions)
John McCall93c332a2011-05-28 21:13:02 +0000105 return CGM.CreateRuntimeFunction(FTy, "_Unwind_SjLj_Resume");
106 return CGM.CreateRuntimeFunction(FTy, "_Unwind_Resume");
107}
108
109llvm::Constant *CodeGenFunction::getUnwindResumeOrRethrowFn() {
Chris Lattner2acc6e32011-07-18 04:24:23 +0000110 llvm::FunctionType *FTy =
Jay Foadda549e82011-07-29 13:56:53 +0000111 llvm::FunctionType::get(VoidTy, Int8PtrTy, /*IsVarArgs=*/false);
Mike Stump8755ec32009-12-10 00:06:18 +0000112
David Blaikie4e4d0842012-03-11 07:00:24 +0000113 if (CGM.getLangOpts().SjLjExceptions)
John McCalla5f2de22010-08-11 20:59:53 +0000114 return CGM.CreateRuntimeFunction(FTy, "_Unwind_SjLj_Resume_or_Rethrow");
Douglas Gregor86a3a032010-05-16 01:24:12 +0000115 return CGM.CreateRuntimeFunction(FTy, "_Unwind_Resume_or_Rethrow");
Mike Stump0f590be2009-12-01 03:41:18 +0000116}
117
John McCall629df012013-02-12 03:51:38 +0000118static llvm::Constant *getTerminateFn(CodeGenModule &CGM) {
Mike Stump99533832009-12-02 07:41:41 +0000119 // void __terminate();
120
Chris Lattner2acc6e32011-07-18 04:24:23 +0000121 llvm::FunctionType *FTy =
John McCall629df012013-02-12 03:51:38 +0000122 llvm::FunctionType::get(CGM.VoidTy, /*IsVarArgs=*/false);
Mike Stump8755ec32009-12-10 00:06:18 +0000123
Chris Lattner5f9e2722011-07-23 10:55:15 +0000124 StringRef name;
John McCall256a76e2011-07-06 01:22:26 +0000125
126 // In C++, use std::terminate().
John McCall629df012013-02-12 03:51:38 +0000127 if (CGM.getLangOpts().CPlusPlus)
John McCall256a76e2011-07-06 01:22:26 +0000128 name = "_ZSt9terminatev"; // FIXME: mangling!
John McCall629df012013-02-12 03:51:38 +0000129 else if (CGM.getLangOpts().ObjC1 &&
130 CGM.getLangOpts().ObjCRuntime.hasTerminate())
John McCall256a76e2011-07-06 01:22:26 +0000131 name = "objc_terminate";
132 else
133 name = "abort";
John McCall629df012013-02-12 03:51:38 +0000134 return CGM.CreateRuntimeFunction(FTy, name);
David Chisnall79a9ad82010-05-17 13:49:20 +0000135}
136
John McCall629df012013-02-12 03:51:38 +0000137static llvm::Constant *getCatchallRethrowFn(CodeGenModule &CGM,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000138 StringRef Name) {
Chris Lattner2acc6e32011-07-18 04:24:23 +0000139 llvm::FunctionType *FTy =
John McCall629df012013-02-12 03:51:38 +0000140 llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*IsVarArgs=*/false);
John McCall8262b6a2010-07-17 00:43:08 +0000141
John McCall629df012013-02-12 03:51:38 +0000142 return CGM.CreateRuntimeFunction(FTy, Name);
John McCallf1549f62010-07-06 01:34:17 +0000143}
144
Benjamin Krameraf2771b2012-02-08 12:41:24 +0000145namespace {
146 /// The exceptions personality for a function.
147 struct EHPersonality {
148 const char *PersonalityFn;
149
150 // If this is non-null, this personality requires a non-standard
151 // function for rethrowing an exception after a catchall cleanup.
152 // This function must have prototype void(void*).
153 const char *CatchallRethrowFn;
154
155 static const EHPersonality &get(const LangOptions &Lang);
156 static const EHPersonality GNU_C;
157 static const EHPersonality GNU_C_SJLJ;
158 static const EHPersonality GNU_ObjC;
David Chisnall65bd4ac2013-01-11 15:33:01 +0000159 static const EHPersonality GNUstep_ObjC;
Benjamin Krameraf2771b2012-02-08 12:41:24 +0000160 static const EHPersonality GNU_ObjCXX;
161 static const EHPersonality NeXT_ObjC;
162 static const EHPersonality GNU_CPlusPlus;
163 static const EHPersonality GNU_CPlusPlus_SJLJ;
164 };
165}
166
167const EHPersonality EHPersonality::GNU_C = { "__gcc_personality_v0", 0 };
168const EHPersonality EHPersonality::GNU_C_SJLJ = { "__gcc_personality_sj0", 0 };
169const EHPersonality EHPersonality::NeXT_ObjC = { "__objc_personality_v0", 0 };
170const EHPersonality EHPersonality::GNU_CPlusPlus = { "__gxx_personality_v0", 0};
171const EHPersonality
172EHPersonality::GNU_CPlusPlus_SJLJ = { "__gxx_personality_sj0", 0 };
173const EHPersonality
174EHPersonality::GNU_ObjC = {"__gnu_objc_personality_v0", "objc_exception_throw"};
175const EHPersonality
176EHPersonality::GNU_ObjCXX = { "__gnustep_objcxx_personality_v0", 0 };
David Chisnall65bd4ac2013-01-11 15:33:01 +0000177const EHPersonality
178EHPersonality::GNUstep_ObjC = { "__gnustep_objc_personality_v0", 0 };
John McCall8262b6a2010-07-17 00:43:08 +0000179
180static const EHPersonality &getCPersonality(const LangOptions &L) {
John McCall44680782010-11-07 02:35:25 +0000181 if (L.SjLjExceptions)
182 return EHPersonality::GNU_C_SJLJ;
John McCall8262b6a2010-07-17 00:43:08 +0000183 return EHPersonality::GNU_C;
184}
185
186static const EHPersonality &getObjCPersonality(const LangOptions &L) {
John McCall260611a2012-06-20 06:18:46 +0000187 switch (L.ObjCRuntime.getKind()) {
188 case ObjCRuntime::FragileMacOSX:
189 return getCPersonality(L);
190 case ObjCRuntime::MacOSX:
191 case ObjCRuntime::iOS:
192 return EHPersonality::NeXT_ObjC;
David Chisnall11d3f4c2012-07-03 20:49:52 +0000193 case ObjCRuntime::GNUstep:
David Chisnall65bd4ac2013-01-11 15:33:01 +0000194 if (L.ObjCRuntime.getVersion() >= VersionTuple(1, 7))
195 return EHPersonality::GNUstep_ObjC;
196 // fallthrough
David Chisnall11d3f4c2012-07-03 20:49:52 +0000197 case ObjCRuntime::GCC:
John McCallf7226fb2012-07-12 02:07:58 +0000198 case ObjCRuntime::ObjFW:
John McCall8262b6a2010-07-17 00:43:08 +0000199 return EHPersonality::GNU_ObjC;
John McCallf1549f62010-07-06 01:34:17 +0000200 }
John McCall260611a2012-06-20 06:18:46 +0000201 llvm_unreachable("bad runtime kind");
John McCallf1549f62010-07-06 01:34:17 +0000202}
203
John McCall8262b6a2010-07-17 00:43:08 +0000204static const EHPersonality &getCXXPersonality(const LangOptions &L) {
205 if (L.SjLjExceptions)
206 return EHPersonality::GNU_CPlusPlus_SJLJ;
John McCallf1549f62010-07-06 01:34:17 +0000207 else
John McCall8262b6a2010-07-17 00:43:08 +0000208 return EHPersonality::GNU_CPlusPlus;
John McCallf1549f62010-07-06 01:34:17 +0000209}
210
211/// Determines the personality function to use when both C++
212/// and Objective-C exceptions are being caught.
John McCall8262b6a2010-07-17 00:43:08 +0000213static const EHPersonality &getObjCXXPersonality(const LangOptions &L) {
John McCall260611a2012-06-20 06:18:46 +0000214 switch (L.ObjCRuntime.getKind()) {
John McCallf1549f62010-07-06 01:34:17 +0000215 // The ObjC personality defers to the C++ personality for non-ObjC
216 // handlers. Unlike the C++ case, we use the same personality
217 // function on targets using (backend-driven) SJLJ EH.
John McCall260611a2012-06-20 06:18:46 +0000218 case ObjCRuntime::MacOSX:
219 case ObjCRuntime::iOS:
220 return EHPersonality::NeXT_ObjC;
John McCallf1549f62010-07-06 01:34:17 +0000221
John McCall260611a2012-06-20 06:18:46 +0000222 // In the fragile ABI, just use C++ exception handling and hope
223 // they're not doing crazy exception mixing.
224 case ObjCRuntime::FragileMacOSX:
225 return getCXXPersonality(L);
David Chisnall79a9ad82010-05-17 13:49:20 +0000226
David Chisnall11d3f4c2012-07-03 20:49:52 +0000227 // The GCC runtime's personality function inherently doesn't support
John McCall8262b6a2010-07-17 00:43:08 +0000228 // mixed EH. Use the C++ personality just to avoid returning null.
David Chisnall11d3f4c2012-07-03 20:49:52 +0000229 case ObjCRuntime::GCC:
John McCallf7226fb2012-07-12 02:07:58 +0000230 case ObjCRuntime::ObjFW: // XXX: this will change soon
David Chisnall11d3f4c2012-07-03 20:49:52 +0000231 return EHPersonality::GNU_ObjC;
232 case ObjCRuntime::GNUstep:
John McCall260611a2012-06-20 06:18:46 +0000233 return EHPersonality::GNU_ObjCXX;
234 }
235 llvm_unreachable("bad runtime kind");
John McCallf1549f62010-07-06 01:34:17 +0000236}
237
John McCall8262b6a2010-07-17 00:43:08 +0000238const EHPersonality &EHPersonality::get(const LangOptions &L) {
239 if (L.CPlusPlus && L.ObjC1)
240 return getObjCXXPersonality(L);
241 else if (L.CPlusPlus)
242 return getCXXPersonality(L);
243 else if (L.ObjC1)
244 return getObjCPersonality(L);
John McCallf1549f62010-07-06 01:34:17 +0000245 else
John McCall8262b6a2010-07-17 00:43:08 +0000246 return getCPersonality(L);
247}
John McCallf1549f62010-07-06 01:34:17 +0000248
John McCallb2593832010-09-16 06:16:50 +0000249static llvm::Constant *getPersonalityFn(CodeGenModule &CGM,
John McCall8262b6a2010-07-17 00:43:08 +0000250 const EHPersonality &Personality) {
John McCall8262b6a2010-07-17 00:43:08 +0000251 llvm::Constant *Fn =
Chris Lattner8b418682012-02-07 00:39:47 +0000252 CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.Int32Ty, true),
Benjamin Krameraf2771b2012-02-08 12:41:24 +0000253 Personality.PersonalityFn);
John McCallb2593832010-09-16 06:16:50 +0000254 return Fn;
255}
256
257static llvm::Constant *getOpaquePersonalityFn(CodeGenModule &CGM,
258 const EHPersonality &Personality) {
259 llvm::Constant *Fn = getPersonalityFn(CGM, Personality);
John McCalld16c2cf2011-02-08 08:22:06 +0000260 return llvm::ConstantExpr::getBitCast(Fn, CGM.Int8PtrTy);
John McCallb2593832010-09-16 06:16:50 +0000261}
262
263/// Check whether a personality function could reasonably be swapped
264/// for a C++ personality function.
265static bool PersonalityHasOnlyCXXUses(llvm::Constant *Fn) {
266 for (llvm::Constant::use_iterator
267 I = Fn->use_begin(), E = Fn->use_end(); I != E; ++I) {
268 llvm::User *User = *I;
269
270 // Conditionally white-list bitcasts.
271 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(User)) {
272 if (CE->getOpcode() != llvm::Instruction::BitCast) return false;
273 if (!PersonalityHasOnlyCXXUses(CE))
274 return false;
275 continue;
276 }
277
Bill Wendling40ccacc2011-09-19 22:08:36 +0000278 // Otherwise, it has to be a landingpad instruction.
279 llvm::LandingPadInst *LPI = dyn_cast<llvm::LandingPadInst>(User);
280 if (!LPI) return false;
John McCallb2593832010-09-16 06:16:50 +0000281
Bill Wendling40ccacc2011-09-19 22:08:36 +0000282 for (unsigned I = 0, E = LPI->getNumClauses(); I != E; ++I) {
John McCallb2593832010-09-16 06:16:50 +0000283 // Look for something that would've been returned by the ObjC
284 // runtime's GetEHType() method.
Bill Wendling40ccacc2011-09-19 22:08:36 +0000285 llvm::Value *Val = LPI->getClause(I)->stripPointerCasts();
286 if (LPI->isCatch(I)) {
287 // Check if the catch value has the ObjC prefix.
Bill Wendlingeecb6a12011-09-20 00:40:19 +0000288 if (llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Val))
289 // ObjC EH selector entries are always global variables with
290 // names starting like this.
291 if (GV->getName().startswith("OBJC_EHTYPE"))
292 return false;
Bill Wendling40ccacc2011-09-19 22:08:36 +0000293 } else {
294 // Check if any of the filter values have the ObjC prefix.
295 llvm::Constant *CVal = cast<llvm::Constant>(Val);
296 for (llvm::User::op_iterator
297 II = CVal->op_begin(), IE = CVal->op_end(); II != IE; ++II) {
Bill Wendlingeecb6a12011-09-20 00:40:19 +0000298 if (llvm::GlobalVariable *GV =
299 cast<llvm::GlobalVariable>((*II)->stripPointerCasts()))
300 // ObjC EH selector entries are always global variables with
301 // names starting like this.
302 if (GV->getName().startswith("OBJC_EHTYPE"))
303 return false;
Bill Wendling40ccacc2011-09-19 22:08:36 +0000304 }
305 }
John McCallb2593832010-09-16 06:16:50 +0000306 }
307 }
308
309 return true;
310}
311
312/// Try to use the C++ personality function in ObjC++. Not doing this
313/// can cause some incompatibilities with gcc, which is more
314/// aggressive about only using the ObjC++ personality in a function
315/// when it really needs it.
316void CodeGenModule::SimplifyPersonality() {
John McCallb2593832010-09-16 06:16:50 +0000317 // If we're not in ObjC++ -fexceptions, there's nothing to do.
David Blaikie4e4d0842012-03-11 07:00:24 +0000318 if (!LangOpts.CPlusPlus || !LangOpts.ObjC1 || !LangOpts.Exceptions)
John McCallb2593832010-09-16 06:16:50 +0000319 return;
320
John McCall70cd6192012-11-14 17:48:31 +0000321 // Both the problem this endeavors to fix and the way the logic
322 // above works is specific to the NeXT runtime.
323 if (!LangOpts.ObjCRuntime.isNeXTFamily())
324 return;
325
David Blaikie4e4d0842012-03-11 07:00:24 +0000326 const EHPersonality &ObjCXX = EHPersonality::get(LangOpts);
327 const EHPersonality &CXX = getCXXPersonality(LangOpts);
Benjamin Krameraf2771b2012-02-08 12:41:24 +0000328 if (&ObjCXX == &CXX)
John McCallb2593832010-09-16 06:16:50 +0000329 return;
330
Benjamin Krameraf2771b2012-02-08 12:41:24 +0000331 assert(std::strcmp(ObjCXX.PersonalityFn, CXX.PersonalityFn) != 0 &&
332 "Different EHPersonalities using the same personality function.");
333
334 llvm::Function *Fn = getModule().getFunction(ObjCXX.PersonalityFn);
John McCallb2593832010-09-16 06:16:50 +0000335
336 // Nothing to do if it's unused.
337 if (!Fn || Fn->use_empty()) return;
338
339 // Can't do the optimization if it has non-C++ uses.
340 if (!PersonalityHasOnlyCXXUses(Fn)) return;
341
342 // Create the C++ personality function and kill off the old
343 // function.
344 llvm::Constant *CXXFn = getPersonalityFn(*this, CXX);
345
346 // This can happen if the user is screwing with us.
347 if (Fn->getType() != CXXFn->getType()) return;
348
349 Fn->replaceAllUsesWith(CXXFn);
350 Fn->eraseFromParent();
John McCallf1549f62010-07-06 01:34:17 +0000351}
352
353/// Returns the value to inject into a selector to indicate the
354/// presence of a catch-all.
355static llvm::Constant *getCatchAllValue(CodeGenFunction &CGF) {
356 // Possibly we should use @llvm.eh.catch.all.value here.
John McCalld16c2cf2011-02-08 08:22:06 +0000357 return llvm::ConstantPointerNull::get(CGF.Int8PtrTy);
John McCallf1549f62010-07-06 01:34:17 +0000358}
359
John McCall09faeab2010-07-13 21:17:51 +0000360namespace {
361 /// A cleanup to free the exception object if its initialization
362 /// throws.
John McCallc4a1a842011-07-12 00:15:30 +0000363 struct FreeException : EHScopeStack::Cleanup {
364 llvm::Value *exn;
365 FreeException(llvm::Value *exn) : exn(exn) {}
John McCallad346f42011-07-12 20:27:29 +0000366 void Emit(CodeGenFunction &CGF, Flags flags) {
John McCallbd7370a2013-02-28 19:01:20 +0000367 CGF.EmitNounwindRuntimeCall(getFreeExceptionFn(CGF.CGM), exn);
John McCall09faeab2010-07-13 21:17:51 +0000368 }
369 };
370}
371
John McCallac418162010-04-22 01:10:34 +0000372// Emits an exception expression into the given location. This
373// differs from EmitAnyExprToMem only in that, if a final copy-ctor
374// call is required, an exception within that copy ctor causes
375// std::terminate to be invoked.
John McCall3ad32c82011-01-28 08:37:24 +0000376static void EmitAnyExprToExn(CodeGenFunction &CGF, const Expr *e,
377 llvm::Value *addr) {
John McCallf1549f62010-07-06 01:34:17 +0000378 // Make sure the exception object is cleaned up if there's an
379 // exception during initialization.
John McCall3ad32c82011-01-28 08:37:24 +0000380 CGF.pushFullExprCleanup<FreeException>(EHCleanup, addr);
381 EHScopeStack::stable_iterator cleanup = CGF.EHStack.stable_begin();
John McCallac418162010-04-22 01:10:34 +0000382
383 // __cxa_allocate_exception returns a void*; we need to cast this
384 // to the appropriate type for the object.
Chris Lattner2acc6e32011-07-18 04:24:23 +0000385 llvm::Type *ty = CGF.ConvertTypeForMem(e->getType())->getPointerTo();
John McCall3ad32c82011-01-28 08:37:24 +0000386 llvm::Value *typedAddr = CGF.Builder.CreateBitCast(addr, ty);
John McCallac418162010-04-22 01:10:34 +0000387
388 // FIXME: this isn't quite right! If there's a final unelided call
389 // to a copy constructor, then according to [except.terminate]p1 we
390 // must call std::terminate() if that constructor throws, because
391 // technically that copy occurs after the exception expression is
392 // evaluated but before the exception is caught. But the best way
393 // to handle that is to teach EmitAggExpr to do the final copy
394 // differently if it can't be elided.
Chad Rosier649b4a12012-03-29 17:37:10 +0000395 CGF.EmitAnyExprToMem(e, typedAddr, e->getType().getQualifiers(),
396 /*IsInit*/ true);
John McCallac418162010-04-22 01:10:34 +0000397
John McCall3ad32c82011-01-28 08:37:24 +0000398 // Deactivate the cleanup block.
John McCall6f103ba2011-11-10 10:43:54 +0000399 CGF.DeactivateCleanupBlock(cleanup, cast<llvm::Instruction>(typedAddr));
Mike Stump0f590be2009-12-01 03:41:18 +0000400}
401
John McCallf1549f62010-07-06 01:34:17 +0000402llvm::Value *CodeGenFunction::getExceptionSlot() {
John McCall93c332a2011-05-28 21:13:02 +0000403 if (!ExceptionSlot)
404 ExceptionSlot = CreateTempAlloca(Int8PtrTy, "exn.slot");
John McCallf1549f62010-07-06 01:34:17 +0000405 return ExceptionSlot;
Mike Stump0f590be2009-12-01 03:41:18 +0000406}
407
John McCall93c332a2011-05-28 21:13:02 +0000408llvm::Value *CodeGenFunction::getEHSelectorSlot() {
409 if (!EHSelectorSlot)
410 EHSelectorSlot = CreateTempAlloca(Int32Ty, "ehselector.slot");
411 return EHSelectorSlot;
412}
413
Bill Wendlingae270592011-09-15 18:57:19 +0000414llvm::Value *CodeGenFunction::getExceptionFromSlot() {
415 return Builder.CreateLoad(getExceptionSlot(), "exn");
416}
417
418llvm::Value *CodeGenFunction::getSelectorFromSlot() {
419 return Builder.CreateLoad(getEHSelectorSlot(), "sel");
420}
421
Anders Carlsson756b5c42009-10-30 01:42:31 +0000422void CodeGenFunction::EmitCXXThrowExpr(const CXXThrowExpr *E) {
Anders Carlssond3379292009-10-30 02:27:02 +0000423 if (!E->getSubExpr()) {
John McCallbd7370a2013-02-28 19:01:20 +0000424 EmitNoreturnRuntimeCallOrInvoke(getReThrowFn(CGM),
425 ArrayRef<llvm::Value*>());
Douglas Gregor1eb2e592010-05-16 00:44:00 +0000426
John McCallcd5b22e2011-01-12 03:41:02 +0000427 // throw is an expression, and the expression emitters expect us
428 // to leave ourselves at a valid insertion point.
429 EmitBlock(createBasicBlock("throw.cont"));
430
Anders Carlssond3379292009-10-30 02:27:02 +0000431 return;
432 }
Mike Stump8755ec32009-12-10 00:06:18 +0000433
Anders Carlssond3379292009-10-30 02:27:02 +0000434 QualType ThrowType = E->getSubExpr()->getType();
Mike Stump8755ec32009-12-10 00:06:18 +0000435
Fariborz Jahanian6a3c70e2013-01-10 19:02:56 +0000436 if (ThrowType->isObjCObjectPointerType()) {
437 const Stmt *ThrowStmt = E->getSubExpr();
438 const ObjCAtThrowStmt S(E->getExprLoc(),
439 const_cast<Stmt *>(ThrowStmt));
440 CGM.getObjCRuntime().EmitThrowStmt(*this, S, false);
441 // This will clear insertion point which was not cleared in
442 // call to EmitThrowStmt.
443 EmitBlock(createBasicBlock("throw.cont"));
444 return;
445 }
446
Anders Carlssond3379292009-10-30 02:27:02 +0000447 // Now allocate the exception object.
Chris Lattner2acc6e32011-07-18 04:24:23 +0000448 llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
John McCall3d3ec1c2010-04-21 10:05:39 +0000449 uint64_t TypeSize = getContext().getTypeSizeInChars(ThrowType).getQuantity();
Mike Stump8755ec32009-12-10 00:06:18 +0000450
John McCall629df012013-02-12 03:51:38 +0000451 llvm::Constant *AllocExceptionFn = getAllocateExceptionFn(CGM);
John McCallf1549f62010-07-06 01:34:17 +0000452 llvm::CallInst *ExceptionPtr =
John McCallbd7370a2013-02-28 19:01:20 +0000453 EmitNounwindRuntimeCall(AllocExceptionFn,
454 llvm::ConstantInt::get(SizeTy, TypeSize),
455 "exception");
Anders Carlsson8370c582009-12-11 00:32:37 +0000456
John McCallac418162010-04-22 01:10:34 +0000457 EmitAnyExprToExn(*this, E->getSubExpr(), ExceptionPtr);
Mike Stump8755ec32009-12-10 00:06:18 +0000458
Anders Carlssond3379292009-10-30 02:27:02 +0000459 // Now throw the exception.
Anders Carlsson82a113a2011-01-24 01:59:49 +0000460 llvm::Constant *TypeInfo = CGM.GetAddrOfRTTIDescriptor(ThrowType,
461 /*ForEH=*/true);
John McCallac418162010-04-22 01:10:34 +0000462
463 // The address of the destructor. If the exception type has a
464 // trivial destructor (or isn't a record), we just pass null.
465 llvm::Constant *Dtor = 0;
466 if (const RecordType *RecordTy = ThrowType->getAs<RecordType>()) {
467 CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordTy->getDecl());
468 if (!Record->hasTrivialDestructor()) {
Douglas Gregor1d110e02010-07-01 14:13:13 +0000469 CXXDestructorDecl *DtorD = Record->getDestructor();
John McCallac418162010-04-22 01:10:34 +0000470 Dtor = CGM.GetAddrOfCXXDestructor(DtorD, Dtor_Complete);
471 Dtor = llvm::ConstantExpr::getBitCast(Dtor, Int8PtrTy);
472 }
473 }
474 if (!Dtor) Dtor = llvm::Constant::getNullValue(Int8PtrTy);
Mike Stump8755ec32009-12-10 00:06:18 +0000475
John McCallbd7370a2013-02-28 19:01:20 +0000476 llvm::Value *args[] = { ExceptionPtr, TypeInfo, Dtor };
477 EmitNoreturnRuntimeCallOrInvoke(getThrowFn(CGM), args);
Mike Stump8755ec32009-12-10 00:06:18 +0000478
John McCallcd5b22e2011-01-12 03:41:02 +0000479 // throw is an expression, and the expression emitters expect us
480 // to leave ourselves at a valid insertion point.
481 EmitBlock(createBasicBlock("throw.cont"));
Anders Carlsson756b5c42009-10-30 01:42:31 +0000482}
Mike Stump2bf701e2009-11-20 23:44:51 +0000483
Mike Stumpcce3d4f2009-12-07 23:38:24 +0000484void CodeGenFunction::EmitStartEHSpec(const Decl *D) {
David Blaikie4e4d0842012-03-11 07:00:24 +0000485 if (!CGM.getLangOpts().CXXExceptions)
Anders Carlssona994ee42010-02-06 23:59:05 +0000486 return;
487
Mike Stumpcce3d4f2009-12-07 23:38:24 +0000488 const FunctionDecl* FD = dyn_cast_or_null<FunctionDecl>(D);
489 if (FD == 0)
490 return;
491 const FunctionProtoType *Proto = FD->getType()->getAs<FunctionProtoType>();
492 if (Proto == 0)
493 return;
494
Sebastian Redla968e972011-03-15 18:42:48 +0000495 ExceptionSpecificationType EST = Proto->getExceptionSpecType();
496 if (isNoexceptExceptionSpec(EST)) {
497 if (Proto->getNoexceptSpec(getContext()) == FunctionProtoType::NR_Nothrow) {
498 // noexcept functions are simple terminate scopes.
499 EHStack.pushTerminate();
500 }
501 } else if (EST == EST_Dynamic || EST == EST_DynamicNone) {
502 unsigned NumExceptions = Proto->getNumExceptions();
503 EHFilterScope *Filter = EHStack.pushFilter(NumExceptions);
Mike Stumpcce3d4f2009-12-07 23:38:24 +0000504
Sebastian Redla968e972011-03-15 18:42:48 +0000505 for (unsigned I = 0; I != NumExceptions; ++I) {
506 QualType Ty = Proto->getExceptionType(I);
507 QualType ExceptType = Ty.getNonReferenceType().getUnqualifiedType();
508 llvm::Value *EHType = CGM.GetAddrOfRTTIDescriptor(ExceptType,
509 /*ForEH=*/true);
510 Filter->setFilter(I, EHType);
511 }
Mike Stumpcce3d4f2009-12-07 23:38:24 +0000512 }
Mike Stumpcce3d4f2009-12-07 23:38:24 +0000513}
514
John McCall777d6e52011-08-11 02:22:43 +0000515/// Emit the dispatch block for a filter scope if necessary.
516static void emitFilterDispatchBlock(CodeGenFunction &CGF,
517 EHFilterScope &filterScope) {
518 llvm::BasicBlock *dispatchBlock = filterScope.getCachedEHDispatchBlock();
519 if (!dispatchBlock) return;
520 if (dispatchBlock->use_empty()) {
521 delete dispatchBlock;
522 return;
523 }
524
John McCall777d6e52011-08-11 02:22:43 +0000525 CGF.EmitBlockAfterUses(dispatchBlock);
526
527 // If this isn't a catch-all filter, we need to check whether we got
528 // here because the filter triggered.
529 if (filterScope.getNumFilters()) {
530 // Load the selector value.
Bill Wendlingae270592011-09-15 18:57:19 +0000531 llvm::Value *selector = CGF.getSelectorFromSlot();
John McCall777d6e52011-08-11 02:22:43 +0000532 llvm::BasicBlock *unexpectedBB = CGF.createBasicBlock("ehspec.unexpected");
533
534 llvm::Value *zero = CGF.Builder.getInt32(0);
535 llvm::Value *failsFilter =
536 CGF.Builder.CreateICmpSLT(selector, zero, "ehspec.fails");
David Chisnallc6860042012-11-07 16:50:40 +0000537 CGF.Builder.CreateCondBr(failsFilter, unexpectedBB, CGF.getEHResumeBlock(false));
John McCall777d6e52011-08-11 02:22:43 +0000538
539 CGF.EmitBlock(unexpectedBB);
540 }
541
542 // Call __cxa_call_unexpected. This doesn't need to be an invoke
543 // because __cxa_call_unexpected magically filters exceptions
544 // according to the last landing pad the exception was thrown
545 // into. Seriously.
Bill Wendlingae270592011-09-15 18:57:19 +0000546 llvm::Value *exn = CGF.getExceptionFromSlot();
John McCallbd7370a2013-02-28 19:01:20 +0000547 CGF.EmitRuntimeCall(getUnexpectedFn(CGF.CGM), exn)
John McCall777d6e52011-08-11 02:22:43 +0000548 ->setDoesNotReturn();
549 CGF.Builder.CreateUnreachable();
550}
551
Mike Stumpcce3d4f2009-12-07 23:38:24 +0000552void CodeGenFunction::EmitEndEHSpec(const Decl *D) {
David Blaikie4e4d0842012-03-11 07:00:24 +0000553 if (!CGM.getLangOpts().CXXExceptions)
Anders Carlssona994ee42010-02-06 23:59:05 +0000554 return;
555
Mike Stumpcce3d4f2009-12-07 23:38:24 +0000556 const FunctionDecl* FD = dyn_cast_or_null<FunctionDecl>(D);
557 if (FD == 0)
558 return;
559 const FunctionProtoType *Proto = FD->getType()->getAs<FunctionProtoType>();
560 if (Proto == 0)
561 return;
562
Sebastian Redla968e972011-03-15 18:42:48 +0000563 ExceptionSpecificationType EST = Proto->getExceptionSpecType();
564 if (isNoexceptExceptionSpec(EST)) {
565 if (Proto->getNoexceptSpec(getContext()) == FunctionProtoType::NR_Nothrow) {
566 EHStack.popTerminate();
567 }
568 } else if (EST == EST_Dynamic || EST == EST_DynamicNone) {
John McCall777d6e52011-08-11 02:22:43 +0000569 EHFilterScope &filterScope = cast<EHFilterScope>(*EHStack.begin());
570 emitFilterDispatchBlock(*this, filterScope);
Sebastian Redla968e972011-03-15 18:42:48 +0000571 EHStack.popFilter();
572 }
Mike Stumpcce3d4f2009-12-07 23:38:24 +0000573}
574
Mike Stump2bf701e2009-11-20 23:44:51 +0000575void CodeGenFunction::EmitCXXTryStmt(const CXXTryStmt &S) {
John McCall59a70002010-07-07 06:56:46 +0000576 EnterCXXTryStmt(S);
John McCall9fc6a772010-02-19 09:25:03 +0000577 EmitStmt(S.getTryBlock());
John McCall59a70002010-07-07 06:56:46 +0000578 ExitCXXTryStmt(S);
John McCall9fc6a772010-02-19 09:25:03 +0000579}
580
John McCall59a70002010-07-07 06:56:46 +0000581void CodeGenFunction::EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock) {
John McCallf1549f62010-07-06 01:34:17 +0000582 unsigned NumHandlers = S.getNumHandlers();
583 EHCatchScope *CatchScope = EHStack.pushCatch(NumHandlers);
John McCall9fc6a772010-02-19 09:25:03 +0000584
John McCallf1549f62010-07-06 01:34:17 +0000585 for (unsigned I = 0; I != NumHandlers; ++I) {
586 const CXXCatchStmt *C = S.getHandler(I);
John McCall9fc6a772010-02-19 09:25:03 +0000587
John McCallf1549f62010-07-06 01:34:17 +0000588 llvm::BasicBlock *Handler = createBasicBlock("catch");
589 if (C->getExceptionDecl()) {
590 // FIXME: Dropping the reference type on the type into makes it
591 // impossible to correctly implement catch-by-reference
592 // semantics for pointers. Unfortunately, this is what all
593 // existing compilers do, and it's not clear that the standard
594 // personality routine is capable of doing this right. See C++ DR 388:
595 // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#388
596 QualType CaughtType = C->getCaughtType();
597 CaughtType = CaughtType.getNonReferenceType().getUnqualifiedType();
John McCall5a180392010-07-24 00:37:23 +0000598
599 llvm::Value *TypeInfo = 0;
600 if (CaughtType->isObjCObjectPointerType())
Fariborz Jahaniancf5abc72011-06-23 19:00:08 +0000601 TypeInfo = CGM.getObjCRuntime().GetEHType(CaughtType);
John McCall5a180392010-07-24 00:37:23 +0000602 else
Anders Carlsson82a113a2011-01-24 01:59:49 +0000603 TypeInfo = CGM.GetAddrOfRTTIDescriptor(CaughtType, /*ForEH=*/true);
John McCallf1549f62010-07-06 01:34:17 +0000604 CatchScope->setHandler(I, TypeInfo, Handler);
605 } else {
606 // No exception decl indicates '...', a catch-all.
607 CatchScope->setCatchAllHandler(I, Handler);
608 }
609 }
John McCallf1549f62010-07-06 01:34:17 +0000610}
611
John McCall777d6e52011-08-11 02:22:43 +0000612llvm::BasicBlock *
613CodeGenFunction::getEHDispatchBlock(EHScopeStack::stable_iterator si) {
614 // The dispatch block for the end of the scope chain is a block that
615 // just resumes unwinding.
616 if (si == EHStack.stable_end())
David Chisnallc6860042012-11-07 16:50:40 +0000617 return getEHResumeBlock(true);
John McCall777d6e52011-08-11 02:22:43 +0000618
619 // Otherwise, we should look at the actual scope.
620 EHScope &scope = *EHStack.find(si);
621
622 llvm::BasicBlock *dispatchBlock = scope.getCachedEHDispatchBlock();
623 if (!dispatchBlock) {
624 switch (scope.getKind()) {
625 case EHScope::Catch: {
626 // Apply a special case to a single catch-all.
627 EHCatchScope &catchScope = cast<EHCatchScope>(scope);
628 if (catchScope.getNumHandlers() == 1 &&
629 catchScope.getHandler(0).isCatchAll()) {
630 dispatchBlock = catchScope.getHandler(0).Block;
631
632 // Otherwise, make a dispatch block.
633 } else {
634 dispatchBlock = createBasicBlock("catch.dispatch");
635 }
636 break;
637 }
638
639 case EHScope::Cleanup:
640 dispatchBlock = createBasicBlock("ehcleanup");
641 break;
642
643 case EHScope::Filter:
644 dispatchBlock = createBasicBlock("filter.dispatch");
645 break;
646
647 case EHScope::Terminate:
648 dispatchBlock = getTerminateHandler();
649 break;
650 }
651 scope.setCachedEHDispatchBlock(dispatchBlock);
652 }
653 return dispatchBlock;
654}
655
John McCallf1549f62010-07-06 01:34:17 +0000656/// Check whether this is a non-EH scope, i.e. a scope which doesn't
657/// affect exception handling. Currently, the only non-EH scopes are
658/// normal-only cleanup scopes.
659static bool isNonEHScope(const EHScope &S) {
John McCallda65ea82010-07-13 20:32:21 +0000660 switch (S.getKind()) {
John McCall1f0fca52010-07-21 07:22:38 +0000661 case EHScope::Cleanup:
662 return !cast<EHCleanupScope>(S).isEHCleanup();
John McCallda65ea82010-07-13 20:32:21 +0000663 case EHScope::Filter:
664 case EHScope::Catch:
665 case EHScope::Terminate:
666 return false;
667 }
668
David Blaikie30263482012-01-20 21:50:17 +0000669 llvm_unreachable("Invalid EHScope Kind!");
John McCallf1549f62010-07-06 01:34:17 +0000670}
671
672llvm::BasicBlock *CodeGenFunction::getInvokeDestImpl() {
673 assert(EHStack.requiresLandingPad());
674 assert(!EHStack.empty());
675
David Blaikie4e4d0842012-03-11 07:00:24 +0000676 if (!CGM.getLangOpts().Exceptions)
John McCallda65ea82010-07-13 20:32:21 +0000677 return 0;
678
John McCallf1549f62010-07-06 01:34:17 +0000679 // Check the innermost scope for a cached landing pad. If this is
680 // a non-EH cleanup, we'll check enclosing scopes in EmitLandingPad.
681 llvm::BasicBlock *LP = EHStack.begin()->getCachedLandingPad();
682 if (LP) return LP;
683
684 // Build the landing pad for this scope.
685 LP = EmitLandingPad();
686 assert(LP);
687
688 // Cache the landing pad on the innermost scope. If this is a
689 // non-EH scope, cache the landing pad on the enclosing scope, too.
690 for (EHScopeStack::iterator ir = EHStack.begin(); true; ++ir) {
691 ir->setCachedLandingPad(LP);
692 if (!isNonEHScope(*ir)) break;
693 }
694
695 return LP;
696}
697
John McCall93c332a2011-05-28 21:13:02 +0000698// This code contains a hack to work around a design flaw in
699// LLVM's EH IR which breaks semantics after inlining. This same
700// hack is implemented in llvm-gcc.
701//
702// The LLVM EH abstraction is basically a thin veneer over the
703// traditional GCC zero-cost design: for each range of instructions
704// in the function, there is (at most) one "landing pad" with an
705// associated chain of EH actions. A language-specific personality
706// function interprets this chain of actions and (1) decides whether
707// or not to resume execution at the landing pad and (2) if so,
708// provides an integer indicating why it's stopping. In LLVM IR,
709// the association of a landing pad with a range of instructions is
710// achieved via an invoke instruction, the chain of actions becomes
711// the arguments to the @llvm.eh.selector call, and the selector
712// call returns the integer indicator. Other than the required
713// presence of two intrinsic function calls in the landing pad,
714// the IR exactly describes the layout of the output code.
715//
716// A principal advantage of this design is that it is completely
717// language-agnostic; in theory, the LLVM optimizers can treat
718// landing pads neutrally, and targets need only know how to lower
719// the intrinsics to have a functioning exceptions system (assuming
720// that platform exceptions follow something approximately like the
721// GCC design). Unfortunately, landing pads cannot be combined in a
722// language-agnostic way: given selectors A and B, there is no way
723// to make a single landing pad which faithfully represents the
724// semantics of propagating an exception first through A, then
725// through B, without knowing how the personality will interpret the
726// (lowered form of the) selectors. This means that inlining has no
727// choice but to crudely chain invokes (i.e., to ignore invokes in
728// the inlined function, but to turn all unwindable calls into
729// invokes), which is only semantically valid if every unwind stops
730// at every landing pad.
731//
732// Therefore, the invoke-inline hack is to guarantee that every
733// landing pad has a catch-all.
734enum CleanupHackLevel_t {
735 /// A level of hack that requires that all landing pads have
736 /// catch-alls.
737 CHL_MandatoryCatchall,
738
739 /// A level of hack that requires that all landing pads handle
740 /// cleanups.
741 CHL_MandatoryCleanup,
742
743 /// No hacks at all; ideal IR generation.
744 CHL_Ideal
745};
746const CleanupHackLevel_t CleanupHackLevel = CHL_MandatoryCleanup;
747
John McCallf1549f62010-07-06 01:34:17 +0000748llvm::BasicBlock *CodeGenFunction::EmitLandingPad() {
749 assert(EHStack.requiresLandingPad());
750
John McCall777d6e52011-08-11 02:22:43 +0000751 EHScope &innermostEHScope = *EHStack.find(EHStack.getInnermostEHScope());
752 switch (innermostEHScope.getKind()) {
753 case EHScope::Terminate:
754 return getTerminateLandingPad();
John McCallf1549f62010-07-06 01:34:17 +0000755
John McCall777d6e52011-08-11 02:22:43 +0000756 case EHScope::Catch:
757 case EHScope::Cleanup:
758 case EHScope::Filter:
759 if (llvm::BasicBlock *lpad = innermostEHScope.getCachedLandingPad())
760 return lpad;
John McCallf1549f62010-07-06 01:34:17 +0000761 }
762
763 // Save the current IR generation state.
John McCall777d6e52011-08-11 02:22:43 +0000764 CGBuilderTy::InsertPoint savedIP = Builder.saveAndClearIP();
John McCallf1549f62010-07-06 01:34:17 +0000765
David Blaikie4e4d0842012-03-11 07:00:24 +0000766 const EHPersonality &personality = EHPersonality::get(getLangOpts());
John McCall8262b6a2010-07-17 00:43:08 +0000767
John McCallf1549f62010-07-06 01:34:17 +0000768 // Create and configure the landing pad.
John McCall777d6e52011-08-11 02:22:43 +0000769 llvm::BasicBlock *lpad = createBasicBlock("lpad");
770 EmitBlock(lpad);
John McCallf1549f62010-07-06 01:34:17 +0000771
Bill Wendling285cfd82011-09-19 20:31:14 +0000772 llvm::LandingPadInst *LPadInst =
773 Builder.CreateLandingPad(llvm::StructType::get(Int8PtrTy, Int32Ty, NULL),
774 getOpaquePersonalityFn(CGM, personality), 0);
775
776 llvm::Value *LPadExn = Builder.CreateExtractValue(LPadInst, 0);
777 Builder.CreateStore(LPadExn, getExceptionSlot());
778 llvm::Value *LPadSel = Builder.CreateExtractValue(LPadInst, 1);
779 Builder.CreateStore(LPadSel, getEHSelectorSlot());
780
John McCallf1549f62010-07-06 01:34:17 +0000781 // Save the exception pointer. It's safe to use a single exception
782 // pointer per function because EH cleanups can never have nested
783 // try/catches.
Bill Wendling285cfd82011-09-19 20:31:14 +0000784 // Build the landingpad instruction.
John McCallf1549f62010-07-06 01:34:17 +0000785
786 // Accumulate all the handlers in scope.
John McCall777d6e52011-08-11 02:22:43 +0000787 bool hasCatchAll = false;
788 bool hasCleanup = false;
789 bool hasFilter = false;
790 SmallVector<llvm::Value*, 4> filterTypes;
791 llvm::SmallPtrSet<llvm::Value*, 4> catchTypes;
John McCallf1549f62010-07-06 01:34:17 +0000792 for (EHScopeStack::iterator I = EHStack.begin(), E = EHStack.end();
793 I != E; ++I) {
794
795 switch (I->getKind()) {
John McCall1f0fca52010-07-21 07:22:38 +0000796 case EHScope::Cleanup:
John McCall777d6e52011-08-11 02:22:43 +0000797 // If we have a cleanup, remember that.
798 hasCleanup = (hasCleanup || cast<EHCleanupScope>(*I).isEHCleanup());
John McCallda65ea82010-07-13 20:32:21 +0000799 continue;
800
John McCallf1549f62010-07-06 01:34:17 +0000801 case EHScope::Filter: {
802 assert(I.next() == EHStack.end() && "EH filter is not end of EH stack");
John McCall777d6e52011-08-11 02:22:43 +0000803 assert(!hasCatchAll && "EH filter reached after catch-all");
John McCallf1549f62010-07-06 01:34:17 +0000804
Bill Wendling285cfd82011-09-19 20:31:14 +0000805 // Filter scopes get added to the landingpad in weird ways.
John McCall777d6e52011-08-11 02:22:43 +0000806 EHFilterScope &filter = cast<EHFilterScope>(*I);
807 hasFilter = true;
John McCallf1549f62010-07-06 01:34:17 +0000808
Bill Wendling8990daf2011-09-22 20:32:54 +0000809 // Add all the filter values.
810 for (unsigned i = 0, e = filter.getNumFilters(); i != e; ++i)
811 filterTypes.push_back(filter.getFilter(i));
John McCallf1549f62010-07-06 01:34:17 +0000812 goto done;
813 }
814
815 case EHScope::Terminate:
816 // Terminate scopes are basically catch-alls.
John McCall777d6e52011-08-11 02:22:43 +0000817 assert(!hasCatchAll);
818 hasCatchAll = true;
John McCallf1549f62010-07-06 01:34:17 +0000819 goto done;
820
821 case EHScope::Catch:
822 break;
823 }
824
John McCall777d6e52011-08-11 02:22:43 +0000825 EHCatchScope &catchScope = cast<EHCatchScope>(*I);
826 for (unsigned hi = 0, he = catchScope.getNumHandlers(); hi != he; ++hi) {
827 EHCatchScope::Handler handler = catchScope.getHandler(hi);
John McCallf1549f62010-07-06 01:34:17 +0000828
John McCall777d6e52011-08-11 02:22:43 +0000829 // If this is a catch-all, register that and abort.
830 if (!handler.Type) {
831 assert(!hasCatchAll);
832 hasCatchAll = true;
833 goto done;
John McCallf1549f62010-07-06 01:34:17 +0000834 }
835
836 // Check whether we already have a handler for this type.
Bill Wendling285cfd82011-09-19 20:31:14 +0000837 if (catchTypes.insert(handler.Type))
838 // If not, add it directly to the landingpad.
839 LPadInst->addClause(handler.Type);
John McCallf1549f62010-07-06 01:34:17 +0000840 }
John McCallf1549f62010-07-06 01:34:17 +0000841 }
842
843 done:
Bill Wendling285cfd82011-09-19 20:31:14 +0000844 // If we have a catch-all, add null to the landingpad.
John McCall777d6e52011-08-11 02:22:43 +0000845 assert(!(hasCatchAll && hasFilter));
846 if (hasCatchAll) {
Bill Wendling285cfd82011-09-19 20:31:14 +0000847 LPadInst->addClause(getCatchAllValue(*this));
John McCallf1549f62010-07-06 01:34:17 +0000848
849 // If we have an EH filter, we need to add those handlers in the
Bill Wendling285cfd82011-09-19 20:31:14 +0000850 // right place in the landingpad, which is to say, at the end.
John McCall777d6e52011-08-11 02:22:43 +0000851 } else if (hasFilter) {
Bill Wendling40ccacc2011-09-19 22:08:36 +0000852 // Create a filter expression: a constant array indicating which filter
853 // types there are. The personality routine only lands here if the filter
854 // doesn't match.
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +0000855 SmallVector<llvm::Constant*, 8> Filters;
Bill Wendling285cfd82011-09-19 20:31:14 +0000856 llvm::ArrayType *AType =
857 llvm::ArrayType::get(!filterTypes.empty() ?
858 filterTypes[0]->getType() : Int8PtrTy,
859 filterTypes.size());
860
861 for (unsigned i = 0, e = filterTypes.size(); i != e; ++i)
862 Filters.push_back(cast<llvm::Constant>(filterTypes[i]));
863 llvm::Constant *FilterArray = llvm::ConstantArray::get(AType, Filters);
864 LPadInst->addClause(FilterArray);
John McCallf1549f62010-07-06 01:34:17 +0000865
866 // Also check whether we need a cleanup.
Bill Wendling285cfd82011-09-19 20:31:14 +0000867 if (hasCleanup)
868 LPadInst->setCleanup(true);
John McCallf1549f62010-07-06 01:34:17 +0000869
870 // Otherwise, signal that we at least have cleanups.
John McCall777d6e52011-08-11 02:22:43 +0000871 } else if (CleanupHackLevel == CHL_MandatoryCatchall || hasCleanup) {
Bill Wendling285cfd82011-09-19 20:31:14 +0000872 if (CleanupHackLevel == CHL_MandatoryCatchall)
873 LPadInst->addClause(getCatchAllValue(*this));
874 else
875 LPadInst->setCleanup(true);
John McCallf1549f62010-07-06 01:34:17 +0000876 }
877
Bill Wendling285cfd82011-09-19 20:31:14 +0000878 assert((LPadInst->getNumClauses() > 0 || LPadInst->isCleanup()) &&
879 "landingpad instruction has no clauses!");
John McCallf1549f62010-07-06 01:34:17 +0000880
881 // Tell the backend how to generate the landing pad.
John McCall777d6e52011-08-11 02:22:43 +0000882 Builder.CreateBr(getEHDispatchBlock(EHStack.getInnermostEHScope()));
John McCallf1549f62010-07-06 01:34:17 +0000883
884 // Restore the old IR generation state.
John McCall777d6e52011-08-11 02:22:43 +0000885 Builder.restoreIP(savedIP);
John McCallf1549f62010-07-06 01:34:17 +0000886
John McCall777d6e52011-08-11 02:22:43 +0000887 return lpad;
John McCallf1549f62010-07-06 01:34:17 +0000888}
889
John McCall8e3f8612010-07-13 22:12:14 +0000890namespace {
891 /// A cleanup to call __cxa_end_catch. In many cases, the caught
892 /// exception type lets us state definitively that the thrown exception
893 /// type does not have a destructor. In particular:
894 /// - Catch-alls tell us nothing, so we have to conservatively
895 /// assume that the thrown exception might have a destructor.
896 /// - Catches by reference behave according to their base types.
897 /// - Catches of non-record types will only trigger for exceptions
898 /// of non-record types, which never have destructors.
899 /// - Catches of record types can trigger for arbitrary subclasses
900 /// of the caught type, so we have to assume the actual thrown
901 /// exception type might have a throwing destructor, even if the
902 /// caught type's destructor is trivial or nothrow.
John McCall1f0fca52010-07-21 07:22:38 +0000903 struct CallEndCatch : EHScopeStack::Cleanup {
John McCall8e3f8612010-07-13 22:12:14 +0000904 CallEndCatch(bool MightThrow) : MightThrow(MightThrow) {}
905 bool MightThrow;
906
John McCallad346f42011-07-12 20:27:29 +0000907 void Emit(CodeGenFunction &CGF, Flags flags) {
John McCall8e3f8612010-07-13 22:12:14 +0000908 if (!MightThrow) {
John McCallbd7370a2013-02-28 19:01:20 +0000909 CGF.EmitNounwindRuntimeCall(getEndCatchFn(CGF.CGM));
John McCall8e3f8612010-07-13 22:12:14 +0000910 return;
911 }
912
John McCallbd7370a2013-02-28 19:01:20 +0000913 CGF.EmitRuntimeCallOrInvoke(getEndCatchFn(CGF.CGM));
John McCall8e3f8612010-07-13 22:12:14 +0000914 }
915 };
916}
917
John McCallf1549f62010-07-06 01:34:17 +0000918/// Emits a call to __cxa_begin_catch and enters a cleanup to call
919/// __cxa_end_catch.
John McCall8e3f8612010-07-13 22:12:14 +0000920///
921/// \param EndMightThrow - true if __cxa_end_catch might throw
922static llvm::Value *CallBeginCatch(CodeGenFunction &CGF,
923 llvm::Value *Exn,
924 bool EndMightThrow) {
John McCallbd7370a2013-02-28 19:01:20 +0000925 llvm::CallInst *call =
926 CGF.EmitNounwindRuntimeCall(getBeginCatchFn(CGF.CGM), Exn);
John McCallf1549f62010-07-06 01:34:17 +0000927
John McCall1f0fca52010-07-21 07:22:38 +0000928 CGF.EHStack.pushCleanup<CallEndCatch>(NormalAndEHCleanup, EndMightThrow);
John McCallf1549f62010-07-06 01:34:17 +0000929
John McCallbd7370a2013-02-28 19:01:20 +0000930 return call;
John McCallf1549f62010-07-06 01:34:17 +0000931}
932
933/// A "special initializer" callback for initializing a catch
934/// parameter during catch initialization.
935static void InitCatchParam(CodeGenFunction &CGF,
936 const VarDecl &CatchParam,
937 llvm::Value *ParamAddr) {
938 // Load the exception from where the landing pad saved it.
Bill Wendlingae270592011-09-15 18:57:19 +0000939 llvm::Value *Exn = CGF.getExceptionFromSlot();
John McCallf1549f62010-07-06 01:34:17 +0000940
941 CanQualType CatchType =
942 CGF.CGM.getContext().getCanonicalType(CatchParam.getType());
Chris Lattner2acc6e32011-07-18 04:24:23 +0000943 llvm::Type *LLVMCatchTy = CGF.ConvertTypeForMem(CatchType);
John McCallf1549f62010-07-06 01:34:17 +0000944
945 // If we're catching by reference, we can just cast the object
946 // pointer to the appropriate pointer.
947 if (isa<ReferenceType>(CatchType)) {
John McCall204b0752010-07-20 22:17:55 +0000948 QualType CaughtType = cast<ReferenceType>(CatchType)->getPointeeType();
949 bool EndCatchMightThrow = CaughtType->isRecordType();
John McCall8e3f8612010-07-13 22:12:14 +0000950
John McCallf1549f62010-07-06 01:34:17 +0000951 // __cxa_begin_catch returns the adjusted object pointer.
John McCall8e3f8612010-07-13 22:12:14 +0000952 llvm::Value *AdjustedExn = CallBeginCatch(CGF, Exn, EndCatchMightThrow);
John McCall204b0752010-07-20 22:17:55 +0000953
954 // We have no way to tell the personality function that we're
955 // catching by reference, so if we're catching a pointer,
956 // __cxa_begin_catch will actually return that pointer by value.
957 if (const PointerType *PT = dyn_cast<PointerType>(CaughtType)) {
958 QualType PointeeType = PT->getPointeeType();
959
960 // When catching by reference, generally we should just ignore
961 // this by-value pointer and use the exception object instead.
962 if (!PointeeType->isRecordType()) {
963
964 // Exn points to the struct _Unwind_Exception header, which
965 // we have to skip past in order to reach the exception data.
966 unsigned HeaderSize =
967 CGF.CGM.getTargetCodeGenInfo().getSizeOfUnwindException();
968 AdjustedExn = CGF.Builder.CreateConstGEP1_32(Exn, HeaderSize);
969
970 // However, if we're catching a pointer-to-record type that won't
971 // work, because the personality function might have adjusted
972 // the pointer. There's actually no way for us to fully satisfy
973 // the language/ABI contract here: we can't use Exn because it
974 // might have the wrong adjustment, but we can't use the by-value
975 // pointer because it's off by a level of abstraction.
976 //
977 // The current solution is to dump the adjusted pointer into an
978 // alloca, which breaks language semantics (because changing the
979 // pointer doesn't change the exception) but at least works.
980 // The better solution would be to filter out non-exact matches
981 // and rethrow them, but this is tricky because the rethrow
982 // really needs to be catchable by other sites at this landing
983 // pad. The best solution is to fix the personality function.
984 } else {
985 // Pull the pointer for the reference type off.
Chris Lattner2acc6e32011-07-18 04:24:23 +0000986 llvm::Type *PtrTy =
John McCall204b0752010-07-20 22:17:55 +0000987 cast<llvm::PointerType>(LLVMCatchTy)->getElementType();
988
989 // Create the temporary and write the adjusted pointer into it.
990 llvm::Value *ExnPtrTmp = CGF.CreateTempAlloca(PtrTy, "exn.byref.tmp");
991 llvm::Value *Casted = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy);
992 CGF.Builder.CreateStore(Casted, ExnPtrTmp);
993
994 // Bind the reference to the temporary.
995 AdjustedExn = ExnPtrTmp;
996 }
997 }
998
John McCallf1549f62010-07-06 01:34:17 +0000999 llvm::Value *ExnCast =
1000 CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.byref");
1001 CGF.Builder.CreateStore(ExnCast, ParamAddr);
1002 return;
1003 }
1004
John McCall9d232c82013-03-07 21:37:08 +00001005 // Scalars and complexes.
1006 TypeEvaluationKind TEK = CGF.getEvaluationKind(CatchType);
1007 if (TEK != TEK_Aggregate) {
John McCall8e3f8612010-07-13 22:12:14 +00001008 llvm::Value *AdjustedExn = CallBeginCatch(CGF, Exn, false);
John McCallf1549f62010-07-06 01:34:17 +00001009
1010 // If the catch type is a pointer type, __cxa_begin_catch returns
1011 // the pointer by value.
1012 if (CatchType->hasPointerRepresentation()) {
1013 llvm::Value *CastExn =
1014 CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.casted");
John McCallb29b12d2012-01-17 20:16:56 +00001015
1016 switch (CatchType.getQualifiers().getObjCLifetime()) {
1017 case Qualifiers::OCL_Strong:
1018 CastExn = CGF.EmitARCRetainNonBlock(CastExn);
1019 // fallthrough
1020
1021 case Qualifiers::OCL_None:
1022 case Qualifiers::OCL_ExplicitNone:
1023 case Qualifiers::OCL_Autoreleasing:
1024 CGF.Builder.CreateStore(CastExn, ParamAddr);
1025 return;
1026
1027 case Qualifiers::OCL_Weak:
1028 CGF.EmitARCInitWeak(ParamAddr, CastExn);
1029 return;
1030 }
1031 llvm_unreachable("bad ownership qualifier!");
John McCallf1549f62010-07-06 01:34:17 +00001032 }
1033
1034 // Otherwise, it returns a pointer into the exception object.
1035
Chris Lattner2acc6e32011-07-18 04:24:23 +00001036 llvm::Type *PtrTy = LLVMCatchTy->getPointerTo(0); // addrspace 0 ok
John McCallf1549f62010-07-06 01:34:17 +00001037 llvm::Value *Cast = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy);
1038
John McCall9d232c82013-03-07 21:37:08 +00001039 LValue srcLV = CGF.MakeNaturalAlignAddrLValue(Cast, CatchType);
1040 LValue destLV = CGF.MakeAddrLValue(ParamAddr, CatchType,
1041 CGF.getContext().getDeclAlign(&CatchParam));
1042 switch (TEK) {
1043 case TEK_Complex:
1044 CGF.EmitStoreOfComplex(CGF.EmitLoadOfComplex(srcLV), destLV,
1045 /*init*/ true);
1046 return;
1047 case TEK_Scalar: {
1048 llvm::Value *ExnLoad = CGF.EmitLoadOfScalar(srcLV);
1049 CGF.EmitStoreOfScalar(ExnLoad, destLV, /*init*/ true);
1050 return;
John McCallf1549f62010-07-06 01:34:17 +00001051 }
John McCall9d232c82013-03-07 21:37:08 +00001052 case TEK_Aggregate:
1053 llvm_unreachable("evaluation kind filtered out!");
1054 }
1055 llvm_unreachable("bad evaluation kind");
John McCallf1549f62010-07-06 01:34:17 +00001056 }
1057
John McCallacff6962011-02-16 08:39:19 +00001058 assert(isa<RecordType>(CatchType) && "unexpected catch type!");
John McCallf1549f62010-07-06 01:34:17 +00001059
Chris Lattner2acc6e32011-07-18 04:24:23 +00001060 llvm::Type *PtrTy = LLVMCatchTy->getPointerTo(0); // addrspace 0 ok
John McCallf1549f62010-07-06 01:34:17 +00001061
John McCallacff6962011-02-16 08:39:19 +00001062 // Check for a copy expression. If we don't have a copy expression,
1063 // that means a trivial copy is okay.
John McCalle996ffd2011-02-16 08:02:54 +00001064 const Expr *copyExpr = CatchParam.getInit();
1065 if (!copyExpr) {
John McCallacff6962011-02-16 08:39:19 +00001066 llvm::Value *rawAdjustedExn = CallBeginCatch(CGF, Exn, true);
1067 llvm::Value *adjustedExn = CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy);
Chad Rosier649b4a12012-03-29 17:37:10 +00001068 CGF.EmitAggregateCopy(ParamAddr, adjustedExn, CatchType);
John McCallf1549f62010-07-06 01:34:17 +00001069 return;
1070 }
1071
1072 // We have to call __cxa_get_exception_ptr to get the adjusted
1073 // pointer before copying.
John McCalle996ffd2011-02-16 08:02:54 +00001074 llvm::CallInst *rawAdjustedExn =
John McCallbd7370a2013-02-28 19:01:20 +00001075 CGF.EmitNounwindRuntimeCall(getGetExceptionPtrFn(CGF.CGM), Exn);
John McCallf1549f62010-07-06 01:34:17 +00001076
John McCalle996ffd2011-02-16 08:02:54 +00001077 // Cast that to the appropriate type.
1078 llvm::Value *adjustedExn = CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy);
John McCallf1549f62010-07-06 01:34:17 +00001079
John McCalle996ffd2011-02-16 08:02:54 +00001080 // The copy expression is defined in terms of an OpaqueValueExpr.
1081 // Find it and map it to the adjusted expression.
1082 CodeGenFunction::OpaqueValueMapping
John McCall56ca35d2011-02-17 10:25:35 +00001083 opaque(CGF, OpaqueValueExpr::findInCopyConstruct(copyExpr),
1084 CGF.MakeAddrLValue(adjustedExn, CatchParam.getType()));
John McCallf1549f62010-07-06 01:34:17 +00001085
1086 // Call the copy ctor in a terminate scope.
1087 CGF.EHStack.pushTerminate();
John McCalle996ffd2011-02-16 08:02:54 +00001088
1089 // Perform the copy construction.
Eli Friedmand7722d92011-12-03 02:13:40 +00001090 CharUnits Alignment = CGF.getContext().getDeclAlign(&CatchParam);
Eli Friedmanf3940782011-12-03 00:54:26 +00001091 CGF.EmitAggExpr(copyExpr,
1092 AggValueSlot::forAddr(ParamAddr, Alignment, Qualifiers(),
1093 AggValueSlot::IsNotDestructed,
1094 AggValueSlot::DoesNotNeedGCBarriers,
Chad Rosier649b4a12012-03-29 17:37:10 +00001095 AggValueSlot::IsNotAliased));
John McCalle996ffd2011-02-16 08:02:54 +00001096
1097 // Leave the terminate scope.
John McCallf1549f62010-07-06 01:34:17 +00001098 CGF.EHStack.popTerminate();
1099
John McCalle996ffd2011-02-16 08:02:54 +00001100 // Undo the opaque value mapping.
1101 opaque.pop();
1102
John McCallf1549f62010-07-06 01:34:17 +00001103 // Finally we can call __cxa_begin_catch.
John McCall8e3f8612010-07-13 22:12:14 +00001104 CallBeginCatch(CGF, Exn, true);
John McCallf1549f62010-07-06 01:34:17 +00001105}
1106
1107/// Begins a catch statement by initializing the catch variable and
1108/// calling __cxa_begin_catch.
John McCalle996ffd2011-02-16 08:02:54 +00001109static void BeginCatch(CodeGenFunction &CGF, const CXXCatchStmt *S) {
John McCallf1549f62010-07-06 01:34:17 +00001110 // We have to be very careful with the ordering of cleanups here:
1111 // C++ [except.throw]p4:
1112 // The destruction [of the exception temporary] occurs
1113 // immediately after the destruction of the object declared in
1114 // the exception-declaration in the handler.
1115 //
1116 // So the precise ordering is:
1117 // 1. Construct catch variable.
1118 // 2. __cxa_begin_catch
1119 // 3. Enter __cxa_end_catch cleanup
1120 // 4. Enter dtor cleanup
1121 //
John McCall34695852011-02-22 06:44:22 +00001122 // We do this by using a slightly abnormal initialization process.
1123 // Delegation sequence:
John McCallf1549f62010-07-06 01:34:17 +00001124 // - ExitCXXTryStmt opens a RunCleanupsScope
John McCall34695852011-02-22 06:44:22 +00001125 // - EmitAutoVarAlloca creates the variable and debug info
John McCallf1549f62010-07-06 01:34:17 +00001126 // - InitCatchParam initializes the variable from the exception
John McCall34695852011-02-22 06:44:22 +00001127 // - CallBeginCatch calls __cxa_begin_catch
1128 // - CallBeginCatch enters the __cxa_end_catch cleanup
1129 // - EmitAutoVarCleanups enters the variable destructor cleanup
John McCallf1549f62010-07-06 01:34:17 +00001130 // - EmitCXXTryStmt emits the code for the catch body
1131 // - EmitCXXTryStmt close the RunCleanupsScope
1132
1133 VarDecl *CatchParam = S->getExceptionDecl();
1134 if (!CatchParam) {
Bill Wendlingae270592011-09-15 18:57:19 +00001135 llvm::Value *Exn = CGF.getExceptionFromSlot();
John McCall8e3f8612010-07-13 22:12:14 +00001136 CallBeginCatch(CGF, Exn, true);
John McCallf1549f62010-07-06 01:34:17 +00001137 return;
1138 }
1139
1140 // Emit the local.
John McCall34695852011-02-22 06:44:22 +00001141 CodeGenFunction::AutoVarEmission var = CGF.EmitAutoVarAlloca(*CatchParam);
1142 InitCatchParam(CGF, *CatchParam, var.getObjectAddress(CGF));
1143 CGF.EmitAutoVarCleanups(var);
John McCall9fc6a772010-02-19 09:25:03 +00001144}
1145
John McCall777d6e52011-08-11 02:22:43 +00001146/// Emit the structure of the dispatch block for the given catch scope.
1147/// It is an invariant that the dispatch block already exists.
1148static void emitCatchDispatchBlock(CodeGenFunction &CGF,
1149 EHCatchScope &catchScope) {
1150 llvm::BasicBlock *dispatchBlock = catchScope.getCachedEHDispatchBlock();
1151 assert(dispatchBlock);
1152
1153 // If there's only a single catch-all, getEHDispatchBlock returned
1154 // that catch-all as the dispatch block.
1155 if (catchScope.getNumHandlers() == 1 &&
1156 catchScope.getHandler(0).isCatchAll()) {
1157 assert(dispatchBlock == catchScope.getHandler(0).Block);
1158 return;
1159 }
1160
1161 CGBuilderTy::InsertPoint savedIP = CGF.Builder.saveIP();
1162 CGF.EmitBlockAfterUses(dispatchBlock);
1163
1164 // Select the right handler.
1165 llvm::Value *llvm_eh_typeid_for =
1166 CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_typeid_for);
1167
1168 // Load the selector value.
Bill Wendlingae270592011-09-15 18:57:19 +00001169 llvm::Value *selector = CGF.getSelectorFromSlot();
John McCall777d6e52011-08-11 02:22:43 +00001170
1171 // Test against each of the exception types we claim to catch.
1172 for (unsigned i = 0, e = catchScope.getNumHandlers(); ; ++i) {
1173 assert(i < e && "ran off end of handlers!");
1174 const EHCatchScope::Handler &handler = catchScope.getHandler(i);
1175
1176 llvm::Value *typeValue = handler.Type;
1177 assert(typeValue && "fell into catch-all case!");
1178 typeValue = CGF.Builder.CreateBitCast(typeValue, CGF.Int8PtrTy);
1179
1180 // Figure out the next block.
1181 bool nextIsEnd;
1182 llvm::BasicBlock *nextBlock;
1183
1184 // If this is the last handler, we're at the end, and the next
1185 // block is the block for the enclosing EH scope.
1186 if (i + 1 == e) {
1187 nextBlock = CGF.getEHDispatchBlock(catchScope.getEnclosingEHScope());
1188 nextIsEnd = true;
1189
1190 // If the next handler is a catch-all, we're at the end, and the
1191 // next block is that handler.
1192 } else if (catchScope.getHandler(i+1).isCatchAll()) {
1193 nextBlock = catchScope.getHandler(i+1).Block;
1194 nextIsEnd = true;
1195
1196 // Otherwise, we're not at the end and we need a new block.
1197 } else {
1198 nextBlock = CGF.createBasicBlock("catch.fallthrough");
1199 nextIsEnd = false;
1200 }
1201
1202 // Figure out the catch type's index in the LSDA's type table.
1203 llvm::CallInst *typeIndex =
1204 CGF.Builder.CreateCall(llvm_eh_typeid_for, typeValue);
1205 typeIndex->setDoesNotThrow();
1206
1207 llvm::Value *matchesTypeIndex =
1208 CGF.Builder.CreateICmpEQ(selector, typeIndex, "matches");
1209 CGF.Builder.CreateCondBr(matchesTypeIndex, handler.Block, nextBlock);
1210
1211 // If the next handler is a catch-all, we're completely done.
1212 if (nextIsEnd) {
1213 CGF.Builder.restoreIP(savedIP);
1214 return;
John McCall777d6e52011-08-11 02:22:43 +00001215 }
Ahmed Charlese8e92b92012-02-19 11:57:29 +00001216 // Otherwise we need to emit and continue at that block.
1217 CGF.EmitBlock(nextBlock);
John McCall777d6e52011-08-11 02:22:43 +00001218 }
John McCall777d6e52011-08-11 02:22:43 +00001219}
1220
1221void CodeGenFunction::popCatchScope() {
1222 EHCatchScope &catchScope = cast<EHCatchScope>(*EHStack.begin());
1223 if (catchScope.hasEHBranches())
1224 emitCatchDispatchBlock(*this, catchScope);
1225 EHStack.popCatch();
1226}
1227
John McCall59a70002010-07-07 06:56:46 +00001228void CodeGenFunction::ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock) {
John McCallf1549f62010-07-06 01:34:17 +00001229 unsigned NumHandlers = S.getNumHandlers();
1230 EHCatchScope &CatchScope = cast<EHCatchScope>(*EHStack.begin());
1231 assert(CatchScope.getNumHandlers() == NumHandlers);
Mike Stump2bf701e2009-11-20 23:44:51 +00001232
John McCall777d6e52011-08-11 02:22:43 +00001233 // If the catch was not required, bail out now.
1234 if (!CatchScope.hasEHBranches()) {
1235 EHStack.popCatch();
1236 return;
1237 }
1238
1239 // Emit the structure of the EH dispatch for this catch.
1240 emitCatchDispatchBlock(*this, CatchScope);
1241
John McCallf1549f62010-07-06 01:34:17 +00001242 // Copy the handler blocks off before we pop the EH stack. Emitting
1243 // the handlers might scribble on this memory.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001244 SmallVector<EHCatchScope::Handler, 8> Handlers(NumHandlers);
John McCallf1549f62010-07-06 01:34:17 +00001245 memcpy(Handlers.data(), CatchScope.begin(),
1246 NumHandlers * sizeof(EHCatchScope::Handler));
John McCall777d6e52011-08-11 02:22:43 +00001247
John McCallf1549f62010-07-06 01:34:17 +00001248 EHStack.popCatch();
Mike Stump2bf701e2009-11-20 23:44:51 +00001249
John McCallf1549f62010-07-06 01:34:17 +00001250 // The fall-through block.
1251 llvm::BasicBlock *ContBB = createBasicBlock("try.cont");
Mike Stump2bf701e2009-11-20 23:44:51 +00001252
John McCallf1549f62010-07-06 01:34:17 +00001253 // We just emitted the body of the try; jump to the continue block.
1254 if (HaveInsertPoint())
1255 Builder.CreateBr(ContBB);
Mike Stump639787c2009-12-02 19:53:57 +00001256
John McCallf5533012012-06-15 05:27:05 +00001257 // Determine if we need an implicit rethrow for all these catch handlers;
1258 // see the comment below.
1259 bool doImplicitRethrow = false;
John McCall59a70002010-07-07 06:56:46 +00001260 if (IsFnTryBlock)
John McCallf5533012012-06-15 05:27:05 +00001261 doImplicitRethrow = isa<CXXDestructorDecl>(CurCodeDecl) ||
1262 isa<CXXConstructorDecl>(CurCodeDecl);
John McCall59a70002010-07-07 06:56:46 +00001263
John McCall777d6e52011-08-11 02:22:43 +00001264 // Perversely, we emit the handlers backwards precisely because we
1265 // want them to appear in source order. In all of these cases, the
1266 // catch block will have exactly one predecessor, which will be a
1267 // particular block in the catch dispatch. However, in the case of
1268 // a catch-all, one of the dispatch blocks will branch to two
1269 // different handlers, and EmitBlockAfterUses will cause the second
1270 // handler to be moved before the first.
1271 for (unsigned I = NumHandlers; I != 0; --I) {
1272 llvm::BasicBlock *CatchBlock = Handlers[I-1].Block;
1273 EmitBlockAfterUses(CatchBlock);
Mike Stump8755ec32009-12-10 00:06:18 +00001274
John McCallf1549f62010-07-06 01:34:17 +00001275 // Catch the exception if this isn't a catch-all.
John McCall777d6e52011-08-11 02:22:43 +00001276 const CXXCatchStmt *C = S.getHandler(I-1);
Mike Stump2bf701e2009-11-20 23:44:51 +00001277
John McCallf1549f62010-07-06 01:34:17 +00001278 // Enter a cleanup scope, including the catch variable and the
1279 // end-catch.
1280 RunCleanupsScope CatchScope(*this);
Mike Stump2bf701e2009-11-20 23:44:51 +00001281
John McCallf1549f62010-07-06 01:34:17 +00001282 // Initialize the catch variable and set up the cleanups.
1283 BeginCatch(*this, C);
1284
1285 // Perform the body of the catch.
1286 EmitStmt(C->getHandlerBlock());
1287
John McCallf5533012012-06-15 05:27:05 +00001288 // [except.handle]p11:
1289 // The currently handled exception is rethrown if control
1290 // reaches the end of a handler of the function-try-block of a
1291 // constructor or destructor.
1292
1293 // It is important that we only do this on fallthrough and not on
1294 // return. Note that it's illegal to put a return in a
1295 // constructor function-try-block's catch handler (p14), so this
1296 // really only applies to destructors.
1297 if (doImplicitRethrow && HaveInsertPoint()) {
John McCallbd7370a2013-02-28 19:01:20 +00001298 EmitRuntimeCallOrInvoke(getReThrowFn(CGM));
John McCallf5533012012-06-15 05:27:05 +00001299 Builder.CreateUnreachable();
1300 Builder.ClearInsertionPoint();
1301 }
1302
John McCallf1549f62010-07-06 01:34:17 +00001303 // Fall out through the catch cleanups.
1304 CatchScope.ForceCleanup();
1305
1306 // Branch out of the try.
1307 if (HaveInsertPoint())
1308 Builder.CreateBr(ContBB);
Mike Stump2bf701e2009-11-20 23:44:51 +00001309 }
1310
John McCallf1549f62010-07-06 01:34:17 +00001311 EmitBlock(ContBB);
Mike Stump2bf701e2009-11-20 23:44:51 +00001312}
Mike Stumpd88ea562009-12-09 03:35:49 +00001313
John McCall55b20fc2010-07-21 00:52:03 +00001314namespace {
John McCall1f0fca52010-07-21 07:22:38 +00001315 struct CallEndCatchForFinally : EHScopeStack::Cleanup {
John McCall55b20fc2010-07-21 00:52:03 +00001316 llvm::Value *ForEHVar;
1317 llvm::Value *EndCatchFn;
1318 CallEndCatchForFinally(llvm::Value *ForEHVar, llvm::Value *EndCatchFn)
1319 : ForEHVar(ForEHVar), EndCatchFn(EndCatchFn) {}
1320
John McCallad346f42011-07-12 20:27:29 +00001321 void Emit(CodeGenFunction &CGF, Flags flags) {
John McCall55b20fc2010-07-21 00:52:03 +00001322 llvm::BasicBlock *EndCatchBB = CGF.createBasicBlock("finally.endcatch");
1323 llvm::BasicBlock *CleanupContBB =
1324 CGF.createBasicBlock("finally.cleanup.cont");
1325
1326 llvm::Value *ShouldEndCatch =
1327 CGF.Builder.CreateLoad(ForEHVar, "finally.endcatch");
1328 CGF.Builder.CreateCondBr(ShouldEndCatch, EndCatchBB, CleanupContBB);
1329 CGF.EmitBlock(EndCatchBB);
John McCallbd7370a2013-02-28 19:01:20 +00001330 CGF.EmitRuntimeCallOrInvoke(EndCatchFn); // catch-all, so might throw
John McCall55b20fc2010-07-21 00:52:03 +00001331 CGF.EmitBlock(CleanupContBB);
1332 }
1333 };
John McCall77199712010-07-21 05:47:49 +00001334
John McCall1f0fca52010-07-21 07:22:38 +00001335 struct PerformFinally : EHScopeStack::Cleanup {
John McCall77199712010-07-21 05:47:49 +00001336 const Stmt *Body;
1337 llvm::Value *ForEHVar;
1338 llvm::Value *EndCatchFn;
1339 llvm::Value *RethrowFn;
1340 llvm::Value *SavedExnVar;
1341
1342 PerformFinally(const Stmt *Body, llvm::Value *ForEHVar,
1343 llvm::Value *EndCatchFn,
1344 llvm::Value *RethrowFn, llvm::Value *SavedExnVar)
1345 : Body(Body), ForEHVar(ForEHVar), EndCatchFn(EndCatchFn),
1346 RethrowFn(RethrowFn), SavedExnVar(SavedExnVar) {}
1347
John McCallad346f42011-07-12 20:27:29 +00001348 void Emit(CodeGenFunction &CGF, Flags flags) {
John McCall77199712010-07-21 05:47:49 +00001349 // Enter a cleanup to call the end-catch function if one was provided.
1350 if (EndCatchFn)
John McCall1f0fca52010-07-21 07:22:38 +00001351 CGF.EHStack.pushCleanup<CallEndCatchForFinally>(NormalAndEHCleanup,
1352 ForEHVar, EndCatchFn);
John McCall77199712010-07-21 05:47:49 +00001353
John McCalld96a8e72010-08-11 00:16:14 +00001354 // Save the current cleanup destination in case there are
1355 // cleanups in the finally block.
1356 llvm::Value *SavedCleanupDest =
1357 CGF.Builder.CreateLoad(CGF.getNormalCleanupDestSlot(),
1358 "cleanup.dest.saved");
1359
John McCall77199712010-07-21 05:47:49 +00001360 // Emit the finally block.
1361 CGF.EmitStmt(Body);
1362
1363 // If the end of the finally is reachable, check whether this was
1364 // for EH. If so, rethrow.
1365 if (CGF.HaveInsertPoint()) {
1366 llvm::BasicBlock *RethrowBB = CGF.createBasicBlock("finally.rethrow");
1367 llvm::BasicBlock *ContBB = CGF.createBasicBlock("finally.cont");
1368
1369 llvm::Value *ShouldRethrow =
1370 CGF.Builder.CreateLoad(ForEHVar, "finally.shouldthrow");
1371 CGF.Builder.CreateCondBr(ShouldRethrow, RethrowBB, ContBB);
1372
1373 CGF.EmitBlock(RethrowBB);
1374 if (SavedExnVar) {
John McCallbd7370a2013-02-28 19:01:20 +00001375 CGF.EmitRuntimeCallOrInvoke(RethrowFn,
1376 CGF.Builder.CreateLoad(SavedExnVar));
John McCall77199712010-07-21 05:47:49 +00001377 } else {
John McCallbd7370a2013-02-28 19:01:20 +00001378 CGF.EmitRuntimeCallOrInvoke(RethrowFn);
John McCall77199712010-07-21 05:47:49 +00001379 }
1380 CGF.Builder.CreateUnreachable();
1381
1382 CGF.EmitBlock(ContBB);
John McCalld96a8e72010-08-11 00:16:14 +00001383
1384 // Restore the cleanup destination.
1385 CGF.Builder.CreateStore(SavedCleanupDest,
1386 CGF.getNormalCleanupDestSlot());
John McCall77199712010-07-21 05:47:49 +00001387 }
1388
1389 // Leave the end-catch cleanup. As an optimization, pretend that
1390 // the fallthrough path was inaccessible; we've dynamically proven
1391 // that we're not in the EH case along that path.
1392 if (EndCatchFn) {
1393 CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
1394 CGF.PopCleanupBlock();
1395 CGF.Builder.restoreIP(SavedIP);
1396 }
1397
1398 // Now make sure we actually have an insertion point or the
1399 // cleanup gods will hate us.
1400 CGF.EnsureInsertPoint();
1401 }
1402 };
John McCall55b20fc2010-07-21 00:52:03 +00001403}
1404
John McCallf1549f62010-07-06 01:34:17 +00001405/// Enters a finally block for an implementation using zero-cost
1406/// exceptions. This is mostly general, but hard-codes some
1407/// language/ABI-specific behavior in the catch-all sections.
John McCalld768e9d2011-06-22 02:32:12 +00001408void CodeGenFunction::FinallyInfo::enter(CodeGenFunction &CGF,
1409 const Stmt *body,
1410 llvm::Constant *beginCatchFn,
1411 llvm::Constant *endCatchFn,
1412 llvm::Constant *rethrowFn) {
1413 assert((beginCatchFn != 0) == (endCatchFn != 0) &&
John McCallf1549f62010-07-06 01:34:17 +00001414 "begin/end catch functions not paired");
John McCalld768e9d2011-06-22 02:32:12 +00001415 assert(rethrowFn && "rethrow function is required");
1416
1417 BeginCatchFn = beginCatchFn;
Mike Stumpd88ea562009-12-09 03:35:49 +00001418
John McCallf1549f62010-07-06 01:34:17 +00001419 // The rethrow function has one of the following two types:
1420 // void (*)()
1421 // void (*)(void*)
1422 // In the latter case we need to pass it the exception object.
1423 // But we can't use the exception slot because the @finally might
1424 // have a landing pad (which would overwrite the exception slot).
Chris Lattner2acc6e32011-07-18 04:24:23 +00001425 llvm::FunctionType *rethrowFnTy =
John McCallf1549f62010-07-06 01:34:17 +00001426 cast<llvm::FunctionType>(
John McCalld768e9d2011-06-22 02:32:12 +00001427 cast<llvm::PointerType>(rethrowFn->getType())->getElementType());
1428 SavedExnVar = 0;
1429 if (rethrowFnTy->getNumParams())
1430 SavedExnVar = CGF.CreateTempAlloca(CGF.Int8PtrTy, "finally.exn");
Mike Stumpd88ea562009-12-09 03:35:49 +00001431
John McCallf1549f62010-07-06 01:34:17 +00001432 // A finally block is a statement which must be executed on any edge
1433 // out of a given scope. Unlike a cleanup, the finally block may
1434 // contain arbitrary control flow leading out of itself. In
1435 // addition, finally blocks should always be executed, even if there
1436 // are no catch handlers higher on the stack. Therefore, we
1437 // surround the protected scope with a combination of a normal
1438 // cleanup (to catch attempts to break out of the block via normal
1439 // control flow) and an EH catch-all (semantically "outside" any try
1440 // statement to which the finally block might have been attached).
1441 // The finally block itself is generated in the context of a cleanup
1442 // which conditionally leaves the catch-all.
John McCall3d3ec1c2010-04-21 10:05:39 +00001443
John McCallf1549f62010-07-06 01:34:17 +00001444 // Jump destination for performing the finally block on an exception
1445 // edge. We'll never actually reach this block, so unreachable is
1446 // fine.
John McCalld768e9d2011-06-22 02:32:12 +00001447 RethrowDest = CGF.getJumpDestInCurrentScope(CGF.getUnreachableBlock());
John McCall3d3ec1c2010-04-21 10:05:39 +00001448
John McCallf1549f62010-07-06 01:34:17 +00001449 // Whether the finally block is being executed for EH purposes.
John McCalld768e9d2011-06-22 02:32:12 +00001450 ForEHVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(), "finally.for-eh");
1451 CGF.Builder.CreateStore(CGF.Builder.getFalse(), ForEHVar);
Mike Stumpd88ea562009-12-09 03:35:49 +00001452
John McCallf1549f62010-07-06 01:34:17 +00001453 // Enter a normal cleanup which will perform the @finally block.
John McCalld768e9d2011-06-22 02:32:12 +00001454 CGF.EHStack.pushCleanup<PerformFinally>(NormalCleanup, body,
1455 ForEHVar, endCatchFn,
1456 rethrowFn, SavedExnVar);
John McCallf1549f62010-07-06 01:34:17 +00001457
1458 // Enter a catch-all scope.
John McCalld768e9d2011-06-22 02:32:12 +00001459 llvm::BasicBlock *catchBB = CGF.createBasicBlock("finally.catchall");
1460 EHCatchScope *catchScope = CGF.EHStack.pushCatch(1);
1461 catchScope->setCatchAllHandler(0, catchBB);
John McCallf1549f62010-07-06 01:34:17 +00001462}
1463
John McCalld768e9d2011-06-22 02:32:12 +00001464void CodeGenFunction::FinallyInfo::exit(CodeGenFunction &CGF) {
John McCallf1549f62010-07-06 01:34:17 +00001465 // Leave the finally catch-all.
John McCalld768e9d2011-06-22 02:32:12 +00001466 EHCatchScope &catchScope = cast<EHCatchScope>(*CGF.EHStack.begin());
1467 llvm::BasicBlock *catchBB = catchScope.getHandler(0).Block;
John McCall777d6e52011-08-11 02:22:43 +00001468
1469 CGF.popCatchScope();
John McCallf1549f62010-07-06 01:34:17 +00001470
John McCalld768e9d2011-06-22 02:32:12 +00001471 // If there are any references to the catch-all block, emit it.
1472 if (catchBB->use_empty()) {
1473 delete catchBB;
1474 } else {
1475 CGBuilderTy::InsertPoint savedIP = CGF.Builder.saveAndClearIP();
1476 CGF.EmitBlock(catchBB);
John McCallf1549f62010-07-06 01:34:17 +00001477
John McCalld768e9d2011-06-22 02:32:12 +00001478 llvm::Value *exn = 0;
John McCallf1549f62010-07-06 01:34:17 +00001479
John McCalld768e9d2011-06-22 02:32:12 +00001480 // If there's a begin-catch function, call it.
1481 if (BeginCatchFn) {
Bill Wendlingae270592011-09-15 18:57:19 +00001482 exn = CGF.getExceptionFromSlot();
John McCallbd7370a2013-02-28 19:01:20 +00001483 CGF.EmitNounwindRuntimeCall(BeginCatchFn, exn);
John McCalld768e9d2011-06-22 02:32:12 +00001484 }
1485
1486 // If we need to remember the exception pointer to rethrow later, do so.
1487 if (SavedExnVar) {
Bill Wendlingae270592011-09-15 18:57:19 +00001488 if (!exn) exn = CGF.getExceptionFromSlot();
John McCalld768e9d2011-06-22 02:32:12 +00001489 CGF.Builder.CreateStore(exn, SavedExnVar);
1490 }
1491
1492 // Tell the cleanups in the finally block that we're do this for EH.
1493 CGF.Builder.CreateStore(CGF.Builder.getTrue(), ForEHVar);
1494
1495 // Thread a jump through the finally cleanup.
1496 CGF.EmitBranchThroughCleanup(RethrowDest);
1497
1498 CGF.Builder.restoreIP(savedIP);
1499 }
1500
1501 // Finally, leave the @finally cleanup.
1502 CGF.PopCleanupBlock();
John McCallf1549f62010-07-06 01:34:17 +00001503}
1504
John McCall66b22772013-02-12 03:51:46 +00001505/// In a terminate landing pad, should we use __clang__call_terminate
1506/// or just a naked call to std::terminate?
1507///
1508/// __clang_call_terminate calls __cxa_begin_catch, which then allows
1509/// std::terminate to usefully report something about the
1510/// violating exception.
1511static bool useClangCallTerminate(CodeGenModule &CGM) {
1512 // Only do this for Itanium-family ABIs in C++ mode.
1513 return (CGM.getLangOpts().CPlusPlus &&
1514 CGM.getTarget().getCXXABI().isItaniumFamily());
1515}
1516
1517/// Get or define the following function:
1518/// void @__clang_call_terminate(i8* %exn) nounwind noreturn
1519/// This code is used only in C++.
1520static llvm::Constant *getClangCallTerminateFn(CodeGenModule &CGM) {
1521 llvm::FunctionType *fnTy =
1522 llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*IsVarArgs=*/false);
1523 llvm::Constant *fnRef =
1524 CGM.CreateRuntimeFunction(fnTy, "__clang_call_terminate");
1525
1526 llvm::Function *fn = dyn_cast<llvm::Function>(fnRef);
1527 if (fn && fn->empty()) {
1528 fn->setDoesNotThrow();
1529 fn->setDoesNotReturn();
1530
1531 // What we really want is to massively penalize inlining without
1532 // forbidding it completely. The difference between that and
1533 // 'noinline' is negligible.
1534 fn->addFnAttr(llvm::Attribute::NoInline);
1535
1536 // Allow this function to be shared across translation units, but
1537 // we don't want it to turn into an exported symbol.
1538 fn->setLinkage(llvm::Function::LinkOnceODRLinkage);
1539 fn->setVisibility(llvm::Function::HiddenVisibility);
1540
1541 // Set up the function.
1542 llvm::BasicBlock *entry =
1543 llvm::BasicBlock::Create(CGM.getLLVMContext(), "", fn);
1544 CGBuilderTy builder(entry);
1545
1546 // Pull the exception pointer out of the parameter list.
1547 llvm::Value *exn = &*fn->arg_begin();
1548
1549 // Call __cxa_begin_catch(exn).
John McCallbd7370a2013-02-28 19:01:20 +00001550 llvm::CallInst *catchCall = builder.CreateCall(getBeginCatchFn(CGM), exn);
1551 catchCall->setDoesNotThrow();
1552 catchCall->setCallingConv(CGM.getRuntimeCC());
John McCall66b22772013-02-12 03:51:46 +00001553
1554 // Call std::terminate().
1555 llvm::CallInst *termCall = builder.CreateCall(getTerminateFn(CGM));
1556 termCall->setDoesNotThrow();
1557 termCall->setDoesNotReturn();
John McCallbd7370a2013-02-28 19:01:20 +00001558 termCall->setCallingConv(CGM.getRuntimeCC());
John McCall66b22772013-02-12 03:51:46 +00001559
1560 // std::terminate cannot return.
1561 builder.CreateUnreachable();
1562 }
1563
1564 return fnRef;
1565}
1566
John McCallf1549f62010-07-06 01:34:17 +00001567llvm::BasicBlock *CodeGenFunction::getTerminateLandingPad() {
1568 if (TerminateLandingPad)
1569 return TerminateLandingPad;
1570
1571 CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
1572
1573 // This will get inserted at the end of the function.
1574 TerminateLandingPad = createBasicBlock("terminate.lpad");
1575 Builder.SetInsertPoint(TerminateLandingPad);
1576
1577 // Tell the backend that this is a landing pad.
David Blaikie4e4d0842012-03-11 07:00:24 +00001578 const EHPersonality &Personality = EHPersonality::get(CGM.getLangOpts());
Bill Wendling285cfd82011-09-19 20:31:14 +00001579 llvm::LandingPadInst *LPadInst =
1580 Builder.CreateLandingPad(llvm::StructType::get(Int8PtrTy, Int32Ty, NULL),
1581 getOpaquePersonalityFn(CGM, Personality), 0);
1582 LPadInst->addClause(getCatchAllValue(*this));
John McCallf1549f62010-07-06 01:34:17 +00001583
John McCall66b22772013-02-12 03:51:46 +00001584 llvm::CallInst *terminateCall;
1585 if (useClangCallTerminate(CGM)) {
1586 // Extract out the exception pointer.
1587 llvm::Value *exn = Builder.CreateExtractValue(LPadInst, 0);
John McCallbd7370a2013-02-28 19:01:20 +00001588 terminateCall = EmitNounwindRuntimeCall(getClangCallTerminateFn(CGM), exn);
John McCall66b22772013-02-12 03:51:46 +00001589 } else {
John McCallbd7370a2013-02-28 19:01:20 +00001590 terminateCall = EmitNounwindRuntimeCall(getTerminateFn(CGM));
John McCall66b22772013-02-12 03:51:46 +00001591 }
1592 terminateCall->setDoesNotReturn();
John McCalld16c2cf2011-02-08 08:22:06 +00001593 Builder.CreateUnreachable();
Mike Stumpd88ea562009-12-09 03:35:49 +00001594
John McCallf1549f62010-07-06 01:34:17 +00001595 // Restore the saved insertion state.
1596 Builder.restoreIP(SavedIP);
John McCall891f80e2010-04-30 00:06:43 +00001597
John McCallf1549f62010-07-06 01:34:17 +00001598 return TerminateLandingPad;
Mike Stumpd88ea562009-12-09 03:35:49 +00001599}
Mike Stump9b39c512009-12-09 22:59:31 +00001600
1601llvm::BasicBlock *CodeGenFunction::getTerminateHandler() {
Mike Stump182f3832009-12-10 00:02:42 +00001602 if (TerminateHandler)
1603 return TerminateHandler;
1604
John McCallf1549f62010-07-06 01:34:17 +00001605 CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
Mike Stump76958092009-12-09 23:31:35 +00001606
John McCallf1549f62010-07-06 01:34:17 +00001607 // Set up the terminate handler. This block is inserted at the very
1608 // end of the function by FinishFunction.
Mike Stump182f3832009-12-10 00:02:42 +00001609 TerminateHandler = createBasicBlock("terminate.handler");
John McCallf1549f62010-07-06 01:34:17 +00001610 Builder.SetInsertPoint(TerminateHandler);
John McCallbd7370a2013-02-28 19:01:20 +00001611 llvm::CallInst *TerminateCall = EmitNounwindRuntimeCall(getTerminateFn(CGM));
Mike Stump9b39c512009-12-09 22:59:31 +00001612 TerminateCall->setDoesNotReturn();
Mike Stump9b39c512009-12-09 22:59:31 +00001613 Builder.CreateUnreachable();
1614
John McCall3d3ec1c2010-04-21 10:05:39 +00001615 // Restore the saved insertion state.
John McCallf1549f62010-07-06 01:34:17 +00001616 Builder.restoreIP(SavedIP);
Mike Stump76958092009-12-09 23:31:35 +00001617
Mike Stump9b39c512009-12-09 22:59:31 +00001618 return TerminateHandler;
1619}
John McCallf1549f62010-07-06 01:34:17 +00001620
David Chisnallc6860042012-11-07 16:50:40 +00001621llvm::BasicBlock *CodeGenFunction::getEHResumeBlock(bool isCleanup) {
John McCall777d6e52011-08-11 02:22:43 +00001622 if (EHResumeBlock) return EHResumeBlock;
John McCallff8e1152010-07-23 21:56:41 +00001623
1624 CGBuilderTy::InsertPoint SavedIP = Builder.saveIP();
1625
1626 // We emit a jump to a notional label at the outermost unwind state.
John McCall777d6e52011-08-11 02:22:43 +00001627 EHResumeBlock = createBasicBlock("eh.resume");
1628 Builder.SetInsertPoint(EHResumeBlock);
John McCallff8e1152010-07-23 21:56:41 +00001629
David Blaikie4e4d0842012-03-11 07:00:24 +00001630 const EHPersonality &Personality = EHPersonality::get(CGM.getLangOpts());
John McCallff8e1152010-07-23 21:56:41 +00001631
1632 // This can always be a call because we necessarily didn't find
1633 // anything on the EH stack which needs our help.
Benjamin Krameraf2771b2012-02-08 12:41:24 +00001634 const char *RethrowName = Personality.CatchallRethrowFn;
David Chisnallc6860042012-11-07 16:50:40 +00001635 if (RethrowName != 0 && !isCleanup) {
John McCallbd7370a2013-02-28 19:01:20 +00001636 EmitRuntimeCall(getCatchallRethrowFn(CGM, RethrowName),
1637 getExceptionFromSlot())
John McCall93c332a2011-05-28 21:13:02 +00001638 ->setDoesNotReturn();
1639 } else {
John McCall93c332a2011-05-28 21:13:02 +00001640 switch (CleanupHackLevel) {
1641 case CHL_MandatoryCatchall:
1642 // In mandatory-catchall mode, we need to use
1643 // _Unwind_Resume_or_Rethrow, or whatever the personality's
1644 // equivalent is.
John McCallbd7370a2013-02-28 19:01:20 +00001645 EmitRuntimeCall(getUnwindResumeOrRethrowFn(),
1646 getExceptionFromSlot())
John McCall93c332a2011-05-28 21:13:02 +00001647 ->setDoesNotReturn();
1648 break;
1649 case CHL_MandatoryCleanup: {
Bill Wendling285cfd82011-09-19 20:31:14 +00001650 // In mandatory-cleanup mode, we should use 'resume'.
1651
1652 // Recreate the landingpad's return value for the 'resume' instruction.
1653 llvm::Value *Exn = getExceptionFromSlot();
1654 llvm::Value *Sel = getSelectorFromSlot();
1655
1656 llvm::Type *LPadType = llvm::StructType::get(Exn->getType(),
1657 Sel->getType(), NULL);
1658 llvm::Value *LPadVal = llvm::UndefValue::get(LPadType);
1659 LPadVal = Builder.CreateInsertValue(LPadVal, Exn, 0, "lpad.val");
1660 LPadVal = Builder.CreateInsertValue(LPadVal, Sel, 1, "lpad.val");
1661
1662 Builder.CreateResume(LPadVal);
1663 Builder.restoreIP(SavedIP);
1664 return EHResumeBlock;
John McCall93c332a2011-05-28 21:13:02 +00001665 }
1666 case CHL_Ideal:
1667 // In an idealized mode where we don't have to worry about the
1668 // optimizer combining landing pads, we should just use
1669 // _Unwind_Resume (or the personality's equivalent).
John McCallbd7370a2013-02-28 19:01:20 +00001670 EmitRuntimeCall(getUnwindResumeFn(), getExceptionFromSlot())
John McCall93c332a2011-05-28 21:13:02 +00001671 ->setDoesNotReturn();
1672 break;
1673 }
1674 }
1675
John McCallff8e1152010-07-23 21:56:41 +00001676 Builder.CreateUnreachable();
1677
1678 Builder.restoreIP(SavedIP);
1679
John McCall777d6e52011-08-11 02:22:43 +00001680 return EHResumeBlock;
John McCallff8e1152010-07-23 21:56:41 +00001681}