blob: 0f201b5601c69cd8a7264b793f7e7d0f3222f6a1 [file] [log] [blame]
Anders Carlsson4b08db72009-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
Mike Stump58ef18b2009-11-20 23:44:51 +000014#include "clang/AST/StmtCXX.h"
15
16#include "llvm/Intrinsics.h"
17
Anders Carlsson4b08db72009-10-30 01:42:31 +000018#include "CodeGenFunction.h"
19using namespace clang;
20using namespace CodeGen;
21
Anders Carlsson32e1b1c2009-10-30 02:27:02 +000022static llvm::Constant *getAllocateExceptionFn(CodeGenFunction &CGF) {
23 // void *__cxa_allocate_exception(size_t thrown_size);
24 const llvm::Type *SizeTy = CGF.ConvertType(CGF.getContext().getSizeType());
25 std::vector<const llvm::Type*> Args(1, SizeTy);
Mike Stump75546b82009-12-10 00:06:18 +000026
27 const llvm::FunctionType *FTy =
Anders Carlsson32e1b1c2009-10-30 02:27:02 +000028 llvm::FunctionType::get(llvm::Type::getInt8PtrTy(CGF.getLLVMContext()),
29 Args, false);
Mike Stump75546b82009-12-10 00:06:18 +000030
Anders Carlsson32e1b1c2009-10-30 02:27:02 +000031 return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_allocate_exception");
32}
33
Mike Stump33270212009-12-02 07:41:41 +000034static llvm::Constant *getFreeExceptionFn(CodeGenFunction &CGF) {
35 // void __cxa_free_exception(void *thrown_exception);
36 const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGF.getLLVMContext());
37 std::vector<const llvm::Type*> Args(1, Int8PtrTy);
Mike Stump75546b82009-12-10 00:06:18 +000038
39 const llvm::FunctionType *FTy =
Mike Stump33270212009-12-02 07:41:41 +000040 llvm::FunctionType::get(llvm::Type::getVoidTy(CGF.getLLVMContext()),
41 Args, false);
Mike Stump75546b82009-12-10 00:06:18 +000042
Mike Stump33270212009-12-02 07:41:41 +000043 return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_free_exception");
44}
45
Anders Carlsson32e1b1c2009-10-30 02:27:02 +000046static llvm::Constant *getThrowFn(CodeGenFunction &CGF) {
Mike Stump75546b82009-12-10 00:06:18 +000047 // void __cxa_throw(void *thrown_exception, std::type_info *tinfo,
Mike Stump33270212009-12-02 07:41:41 +000048 // void (*dest) (void *));
Anders Carlsson32e1b1c2009-10-30 02:27:02 +000049
50 const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGF.getLLVMContext());
51 std::vector<const llvm::Type*> Args(3, Int8PtrTy);
Mike Stump75546b82009-12-10 00:06:18 +000052
53 const llvm::FunctionType *FTy =
Mike Stumpd1782cc2009-11-20 00:56:31 +000054 llvm::FunctionType::get(llvm::Type::getVoidTy(CGF.getLLVMContext()),
55 Args, false);
Mike Stump75546b82009-12-10 00:06:18 +000056
Anders Carlsson32e1b1c2009-10-30 02:27:02 +000057 return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_throw");
58}
59
Mike Stumpd1782cc2009-11-20 00:56:31 +000060static llvm::Constant *getReThrowFn(CodeGenFunction &CGF) {
Mike Stump33270212009-12-02 07:41:41 +000061 // void __cxa_rethrow();
Mike Stumpd1782cc2009-11-20 00:56:31 +000062
Mike Stump75546b82009-12-10 00:06:18 +000063 const llvm::FunctionType *FTy =
Mike Stumpd1782cc2009-11-20 00:56:31 +000064 llvm::FunctionType::get(llvm::Type::getVoidTy(CGF.getLLVMContext()), false);
Mike Stump75546b82009-12-10 00:06:18 +000065
Mike Stumpd1782cc2009-11-20 00:56:31 +000066 return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_rethrow");
67}
68
Mike Stump58ef18b2009-11-20 23:44:51 +000069static llvm::Constant *getBeginCatchFn(CodeGenFunction &CGF) {
Mike Stump33270212009-12-02 07:41:41 +000070 // void* __cxa_begin_catch();
Mike Stump58ef18b2009-11-20 23:44:51 +000071
72 const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGF.getLLVMContext());
73 std::vector<const llvm::Type*> Args(1, Int8PtrTy);
Mike Stump75546b82009-12-10 00:06:18 +000074
75 const llvm::FunctionType *FTy =
Mike Stump54066142009-12-01 03:41:18 +000076 llvm::FunctionType::get(Int8PtrTy, Args, false);
Mike Stump75546b82009-12-10 00:06:18 +000077
Mike Stump58ef18b2009-11-20 23:44:51 +000078 return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_begin_catch");
79}
80
81static llvm::Constant *getEndCatchFn(CodeGenFunction &CGF) {
Mike Stump33270212009-12-02 07:41:41 +000082 // void __cxa_end_catch();
Mike Stump58ef18b2009-11-20 23:44:51 +000083
Mike Stump75546b82009-12-10 00:06:18 +000084 const llvm::FunctionType *FTy =
Mike Stump58ef18b2009-11-20 23:44:51 +000085 llvm::FunctionType::get(llvm::Type::getVoidTy(CGF.getLLVMContext()), false);
Mike Stump75546b82009-12-10 00:06:18 +000086
Mike Stump58ef18b2009-11-20 23:44:51 +000087 return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_end_catch");
88}
89
Mike Stump1d849212009-12-07 23:38:24 +000090static llvm::Constant *getUnexpectedFn(CodeGenFunction &CGF) {
91 // void __cxa_call_unexepcted(void *thrown_exception);
92
93 const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGF.getLLVMContext());
94 std::vector<const llvm::Type*> Args(1, Int8PtrTy);
Mike Stump75546b82009-12-10 00:06:18 +000095
96 const llvm::FunctionType *FTy =
Mike Stump1d849212009-12-07 23:38:24 +000097 llvm::FunctionType::get(llvm::Type::getVoidTy(CGF.getLLVMContext()),
98 Args, false);
Mike Stump75546b82009-12-10 00:06:18 +000099
Mike Stump1d849212009-12-07 23:38:24 +0000100 return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_call_unexpected");
101}
102
Mike Stump54066142009-12-01 03:41:18 +0000103// FIXME: Eventually this will all go into the backend. Set from the target for
104// now.
105static int using_sjlj_exceptions = 0;
106
107static llvm::Constant *getUnwindResumeOrRethrowFn(CodeGenFunction &CGF) {
108 const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGF.getLLVMContext());
109 std::vector<const llvm::Type*> Args(1, Int8PtrTy);
Mike Stump75546b82009-12-10 00:06:18 +0000110
111 const llvm::FunctionType *FTy =
Mike Stump54066142009-12-01 03:41:18 +0000112 llvm::FunctionType::get(llvm::Type::getVoidTy(CGF.getLLVMContext()), Args,
113 false);
Mike Stump75546b82009-12-10 00:06:18 +0000114
Mike Stump54066142009-12-01 03:41:18 +0000115 if (using_sjlj_exceptions)
116 return CGF.CGM.CreateRuntimeFunction(FTy, "_Unwind_SjLj_Resume");
117 return CGF.CGM.CreateRuntimeFunction(FTy, "_Unwind_Resume_or_Rethrow");
118}
119
Mike Stump33270212009-12-02 07:41:41 +0000120static llvm::Constant *getTerminateFn(CodeGenFunction &CGF) {
121 // void __terminate();
122
Mike Stump75546b82009-12-10 00:06:18 +0000123 const llvm::FunctionType *FTy =
Mike Stump33270212009-12-02 07:41:41 +0000124 llvm::FunctionType::get(llvm::Type::getVoidTy(CGF.getLLVMContext()), false);
Mike Stump75546b82009-12-10 00:06:18 +0000125
Mike Stump33270212009-12-02 07:41:41 +0000126 return CGF.CGM.CreateRuntimeFunction(FTy, "_ZSt9terminatev");
127}
128
Mike Stump54066142009-12-01 03:41:18 +0000129// CopyObject - Utility to copy an object. Calls copy constructor as necessary.
Anders Carlssonafd1edb2009-12-11 00:32:37 +0000130// DestPtr is casted to the right type.
131static void CopyObject(CodeGenFunction &CGF, const Expr *E,
132 llvm::Value *DestPtr, llvm::Value *ExceptionPtrPtr) {
Mike Stump54066142009-12-01 03:41:18 +0000133 QualType ObjectType = E->getType();
134
135 // Store the throw exception in the exception object.
136 if (!CGF.hasAggregateLLVMType(ObjectType)) {
137 llvm::Value *Value = CGF.EmitScalarExpr(E);
Anders Carlssonafd1edb2009-12-11 00:32:37 +0000138 const llvm::Type *ValuePtrTy = Value->getType()->getPointerTo();
Mike Stump75546b82009-12-10 00:06:18 +0000139
Anders Carlssonafd1edb2009-12-11 00:32:37 +0000140 CGF.Builder.CreateStore(Value,
141 CGF.Builder.CreateBitCast(DestPtr, ValuePtrTy));
Mike Stump54066142009-12-01 03:41:18 +0000142 } else {
Anders Carlssonafd1edb2009-12-11 00:32:37 +0000143 const llvm::Type *Ty = CGF.ConvertType(ObjectType)->getPointerTo();
144 const CXXRecordDecl *RD =
145 cast<CXXRecordDecl>(ObjectType->getAs<RecordType>()->getDecl());
146
147 llvm::Value *This = CGF.Builder.CreateBitCast(DestPtr, Ty);
Mike Stump54066142009-12-01 03:41:18 +0000148 if (RD->hasTrivialCopyConstructor()) {
149 CGF.EmitAggExpr(E, This, false);
150 } else if (CXXConstructorDecl *CopyCtor
151 = RD->getCopyConstructor(CGF.getContext(), 0)) {
Mike Stump3c6a12c2009-12-10 01:52:30 +0000152 llvm::BasicBlock *PrevLandingPad = CGF.getInvokeDest();
153 if (CGF.Exceptions) {
154 CodeGenFunction::EHCleanupBlock Cleanup(CGF);
Mike Stump33270212009-12-02 07:41:41 +0000155 llvm::Constant *FreeExceptionFn = getFreeExceptionFn(CGF);
Anders Carlssonafd1edb2009-12-11 00:32:37 +0000156
157 // Load the exception pointer.
158 llvm::Value *ExceptionPtr = CGF.Builder.CreateLoad(ExceptionPtrPtr);
Mike Stump33270212009-12-02 07:41:41 +0000159 CGF.Builder.CreateCall(FreeExceptionFn, ExceptionPtr);
160 }
Mike Stump37077bf2009-12-11 00:02:10 +0000161
Mike Stump54066142009-12-01 03:41:18 +0000162 llvm::Value *Src = CGF.EmitLValue(E).getAddress();
Mike Stump3c6a12c2009-12-10 01:52:30 +0000163 CGF.setInvokeDest(PrevLandingPad);
Mike Stump54066142009-12-01 03:41:18 +0000164
Mike Stump25b20fc2009-12-09 23:31:35 +0000165 llvm::BasicBlock *TerminateHandler = CGF.getTerminateHandler();
Mike Stump3c6a12c2009-12-10 01:52:30 +0000166 PrevLandingPad = CGF.getInvokeDest();
Mike Stump25b20fc2009-12-09 23:31:35 +0000167 CGF.setInvokeDest(TerminateHandler);
168
Mike Stump54066142009-12-01 03:41:18 +0000169 // Stolen from EmitClassAggrMemberwiseCopy
170 llvm::Value *Callee = CGF.CGM.GetAddrOfCXXConstructor(CopyCtor,
171 Ctor_Complete);
172 CallArgList CallArgs;
173 CallArgs.push_back(std::make_pair(RValue::get(This),
174 CopyCtor->getThisType(CGF.getContext())));
175
176 // Push the Src ptr.
177 CallArgs.push_back(std::make_pair(RValue::get(Src),
178 CopyCtor->getParamDecl(0)->getType()));
179 QualType ResultType =
180 CopyCtor->getType()->getAs<FunctionType>()->getResultType();
181 CGF.EmitCall(CGF.CGM.getTypes().getFunctionInfo(ResultType, CallArgs),
182 Callee, CallArgs, CopyCtor);
Mike Stump25b20fc2009-12-09 23:31:35 +0000183 CGF.setInvokeDest(PrevLandingPad);
Mike Stump54066142009-12-01 03:41:18 +0000184 } else
Jeffrey Yasskin1615d452009-12-12 05:05:38 +0000185 llvm_unreachable("uncopyable object");
Mike Stump54066142009-12-01 03:41:18 +0000186 }
187}
188
189// CopyObject - Utility to copy an object. Calls copy constructor as necessary.
190// N is casted to the right type.
191static void CopyObject(CodeGenFunction &CGF, QualType ObjectType,
Mike Stump7398ff02009-12-03 22:38:15 +0000192 bool WasPointer, llvm::Value *E, llvm::Value *N) {
Mike Stump54066142009-12-01 03:41:18 +0000193 // Store the throw exception in the exception object.
Mike Stump02c23d62009-12-08 01:29:31 +0000194 if (WasPointer || !CGF.hasAggregateLLVMType(ObjectType)) {
Mike Stump54066142009-12-01 03:41:18 +0000195 llvm::Value *Value = E;
Mike Stump7398ff02009-12-03 22:38:15 +0000196 if (!WasPointer)
197 Value = CGF.Builder.CreateLoad(Value);
Mike Stump54066142009-12-01 03:41:18 +0000198 const llvm::Type *ValuePtrTy = Value->getType()->getPointerTo(0);
Mike Stump54066142009-12-01 03:41:18 +0000199 CGF.Builder.CreateStore(Value, CGF.Builder.CreateBitCast(N, ValuePtrTy));
200 } else {
201 const llvm::Type *Ty = CGF.ConvertType(ObjectType)->getPointerTo(0);
202 const CXXRecordDecl *RD;
203 RD = cast<CXXRecordDecl>(ObjectType->getAs<RecordType>()->getDecl());
204 llvm::Value *This = CGF.Builder.CreateBitCast(N, Ty);
205 if (RD->hasTrivialCopyConstructor()) {
206 CGF.EmitAggregateCopy(This, E, ObjectType);
207 } else if (CXXConstructorDecl *CopyCtor
208 = RD->getCopyConstructor(CGF.getContext(), 0)) {
Mike Stump54066142009-12-01 03:41:18 +0000209 llvm::Value *Src = E;
210
211 // Stolen from EmitClassAggrMemberwiseCopy
212 llvm::Value *Callee = CGF.CGM.GetAddrOfCXXConstructor(CopyCtor,
213 Ctor_Complete);
214 CallArgList CallArgs;
215 CallArgs.push_back(std::make_pair(RValue::get(This),
216 CopyCtor->getThisType(CGF.getContext())));
217
218 // Push the Src ptr.
219 CallArgs.push_back(std::make_pair(RValue::get(Src),
220 CopyCtor->getParamDecl(0)->getType()));
221 QualType ResultType =
222 CopyCtor->getType()->getAs<FunctionType>()->getResultType();
223 CGF.EmitCall(CGF.CGM.getTypes().getFunctionInfo(ResultType, CallArgs),
224 Callee, CallArgs, CopyCtor);
Mike Stump54066142009-12-01 03:41:18 +0000225 } else
Jeffrey Yasskin1615d452009-12-12 05:05:38 +0000226 llvm_unreachable("uncopyable object");
Mike Stump54066142009-12-01 03:41:18 +0000227 }
228}
229
Anders Carlsson4b08db72009-10-30 01:42:31 +0000230void CodeGenFunction::EmitCXXThrowExpr(const CXXThrowExpr *E) {
Anders Carlsson32e1b1c2009-10-30 02:27:02 +0000231 if (!E->getSubExpr()) {
Mike Stump114ab9f2009-12-04 01:51:45 +0000232 if (getInvokeDest()) {
233 llvm::BasicBlock *Cont = createBasicBlock("invoke.cont");
234 Builder.CreateInvoke(getReThrowFn(*this), Cont, getInvokeDest())
235 ->setDoesNotReturn();
236 EmitBlock(Cont);
237 } else
238 Builder.CreateCall(getReThrowFn(*this))->setDoesNotReturn();
Mike Stumpd1782cc2009-11-20 00:56:31 +0000239 Builder.CreateUnreachable();
240
241 // Clear the insertion point to indicate we are in unreachable code.
242 Builder.ClearInsertionPoint();
Anders Carlsson32e1b1c2009-10-30 02:27:02 +0000243 return;
244 }
Mike Stump75546b82009-12-10 00:06:18 +0000245
Anders Carlsson32e1b1c2009-10-30 02:27:02 +0000246 QualType ThrowType = E->getSubExpr()->getType();
Mike Stump75546b82009-12-10 00:06:18 +0000247
Anders Carlsson32e1b1c2009-10-30 02:27:02 +0000248 // Now allocate the exception object.
249 const llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
250 uint64_t TypeSize = getContext().getTypeSize(ThrowType) / 8;
Mike Stump75546b82009-12-10 00:06:18 +0000251
Anders Carlsson32e1b1c2009-10-30 02:27:02 +0000252 llvm::Constant *AllocExceptionFn = getAllocateExceptionFn(*this);
Mike Stump75546b82009-12-10 00:06:18 +0000253 llvm::Value *ExceptionPtr =
254 Builder.CreateCall(AllocExceptionFn,
Anders Carlsson32e1b1c2009-10-30 02:27:02 +0000255 llvm::ConstantInt::get(SizeTy, TypeSize),
256 "exception");
Anders Carlssonafd1edb2009-12-11 00:32:37 +0000257
258 llvm::Value *ExceptionPtrPtr =
259 CreateTempAlloca(ExceptionPtr->getType(), "exception.ptr");
260 Builder.CreateStore(ExceptionPtr, ExceptionPtrPtr);
Anders Carlsson32e1b1c2009-10-30 02:27:02 +0000261
Anders Carlssonafd1edb2009-12-11 00:32:37 +0000262
263 CopyObject(*this, E->getSubExpr(), ExceptionPtr, ExceptionPtrPtr);
Mike Stump75546b82009-12-10 00:06:18 +0000264
Anders Carlsson32e1b1c2009-10-30 02:27:02 +0000265 // Now throw the exception.
266 const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(getLLVMContext());
Mike Stumpc01c2b82009-12-02 18:57:08 +0000267 llvm::Constant *TypeInfo = CGM.GenerateRTTI(ThrowType);
Anders Carlsson32e1b1c2009-10-30 02:27:02 +0000268 llvm::Constant *Dtor = llvm::Constant::getNullValue(Int8PtrTy);
Mike Stump75546b82009-12-10 00:06:18 +0000269
Mike Stump114ab9f2009-12-04 01:51:45 +0000270 if (getInvokeDest()) {
271 llvm::BasicBlock *Cont = createBasicBlock("invoke.cont");
Mike Stump75546b82009-12-10 00:06:18 +0000272 llvm::InvokeInst *ThrowCall =
Mike Stump114ab9f2009-12-04 01:51:45 +0000273 Builder.CreateInvoke3(getThrowFn(*this), Cont, getInvokeDest(),
274 ExceptionPtr, TypeInfo, Dtor);
275 ThrowCall->setDoesNotReturn();
276 EmitBlock(Cont);
277 } else {
Mike Stump75546b82009-12-10 00:06:18 +0000278 llvm::CallInst *ThrowCall =
Mike Stump114ab9f2009-12-04 01:51:45 +0000279 Builder.CreateCall3(getThrowFn(*this), ExceptionPtr, TypeInfo, Dtor);
280 ThrowCall->setDoesNotReturn();
281 }
Anders Carlsson32e1b1c2009-10-30 02:27:02 +0000282 Builder.CreateUnreachable();
Mike Stump75546b82009-12-10 00:06:18 +0000283
Anders Carlsson32e1b1c2009-10-30 02:27:02 +0000284 // Clear the insertion point to indicate we are in unreachable code.
285 Builder.ClearInsertionPoint();
Mike Stump62afe992009-12-07 20:12:14 +0000286
287 // FIXME: For now, emit a dummy basic block because expr emitters in generally
288 // are not ready to handle emitting expressions at unreachable points.
289 EnsureInsertPoint();
Anders Carlsson4b08db72009-10-30 01:42:31 +0000290}
Mike Stump58ef18b2009-11-20 23:44:51 +0000291
Mike Stump1d849212009-12-07 23:38:24 +0000292void CodeGenFunction::EmitStartEHSpec(const Decl *D) {
293 const FunctionDecl* FD = dyn_cast_or_null<FunctionDecl>(D);
294 if (FD == 0)
295 return;
296 const FunctionProtoType *Proto = FD->getType()->getAs<FunctionProtoType>();
297 if (Proto == 0)
298 return;
299
300 assert(!Proto->hasAnyExceptionSpec() && "function with parameter pack");
301
302 if (!Proto->hasExceptionSpec())
303 return;
304
305 llvm::Constant *Personality =
306 CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::getInt32Ty
307 (VMContext),
308 true),
309 "__gxx_personality_v0");
310 Personality = llvm::ConstantExpr::getBitCast(Personality, PtrToInt8Ty);
311 llvm::Value *llvm_eh_exception =
312 CGM.getIntrinsic(llvm::Intrinsic::eh_exception);
313 llvm::Value *llvm_eh_selector =
314 CGM.getIntrinsic(llvm::Intrinsic::eh_selector);
315 const llvm::IntegerType *Int8Ty;
316 const llvm::PointerType *PtrToInt8Ty;
317 Int8Ty = llvm::Type::getInt8Ty(VMContext);
318 // C string type. Used in lots of places.
319 PtrToInt8Ty = llvm::PointerType::getUnqual(Int8Ty);
320 llvm::Constant *Null = llvm::ConstantPointerNull::get(PtrToInt8Ty);
321 llvm::SmallVector<llvm::Value*, 8> SelectorArgs;
322
323 llvm::BasicBlock *PrevLandingPad = getInvokeDest();
324 llvm::BasicBlock *EHSpecHandler = createBasicBlock("ehspec.handler");
325 llvm::BasicBlock *Match = createBasicBlock("match");
326 llvm::BasicBlock *Unwind = 0;
327
328 assert(PrevLandingPad == 0 && "EHSpec has invoke context");
329
330 llvm::BasicBlock *Cont = createBasicBlock("cont");
331
332 EmitBranchThroughCleanup(Cont);
333
334 // Emit the statements in the try {} block
335 setInvokeDest(EHSpecHandler);
336
337 EmitBlock(EHSpecHandler);
338 // Exception object
339 llvm::Value *Exc = Builder.CreateCall(llvm_eh_exception, "exc");
340 llvm::Value *RethrowPtr = CreateTempAlloca(Exc->getType(), "_rethrow");
341
342 SelectorArgs.push_back(Exc);
343 SelectorArgs.push_back(Personality);
344 SelectorArgs.push_back(llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext),
345 Proto->getNumExceptions()+1));
346
347 for (unsigned i = 0; i < Proto->getNumExceptions(); ++i) {
348 QualType Ty = Proto->getExceptionType(i);
349 llvm::Value *EHType
350 = CGM.GenerateRTTI(Ty.getNonReferenceType());
351 SelectorArgs.push_back(EHType);
352 }
353 if (Proto->getNumExceptions())
354 SelectorArgs.push_back(Null);
355
356 // Find which handler was matched.
357 llvm::Value *Selector
358 = Builder.CreateCall(llvm_eh_selector, SelectorArgs.begin(),
359 SelectorArgs.end(), "selector");
360 if (Proto->getNumExceptions()) {
361 Unwind = createBasicBlock("Unwind");
362
363 Builder.CreateStore(Exc, RethrowPtr);
364 Builder.CreateCondBr(Builder.CreateICmpSLT(Selector,
365 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext),
366 0)),
367 Match, Unwind);
368
369 EmitBlock(Match);
370 }
371 Builder.CreateCall(getUnexpectedFn(*this), Exc)->setDoesNotReturn();
372 Builder.CreateUnreachable();
373
374 if (Proto->getNumExceptions()) {
375 EmitBlock(Unwind);
376 Builder.CreateCall(getUnwindResumeOrRethrowFn(*this),
377 Builder.CreateLoad(RethrowPtr));
378 Builder.CreateUnreachable();
379 }
380
381 EmitBlock(Cont);
382}
383
384void CodeGenFunction::EmitEndEHSpec(const Decl *D) {
385 const FunctionDecl* FD = dyn_cast_or_null<FunctionDecl>(D);
386 if (FD == 0)
387 return;
388 const FunctionProtoType *Proto = FD->getType()->getAs<FunctionProtoType>();
389 if (Proto == 0)
390 return;
391
392 if (!Proto->hasExceptionSpec())
393 return;
394
395 setInvokeDest(0);
396}
397
Mike Stump58ef18b2009-11-20 23:44:51 +0000398void CodeGenFunction::EmitCXXTryStmt(const CXXTryStmt &S) {
Mike Stump58ef18b2009-11-20 23:44:51 +0000399 // Pointer to the personality function
400 llvm::Constant *Personality =
401 CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::getInt32Ty
402 (VMContext),
403 true),
404 "__gxx_personality_v0");
405 Personality = llvm::ConstantExpr::getBitCast(Personality, PtrToInt8Ty);
Mike Stump97329152009-12-02 19:53:57 +0000406 llvm::Value *llvm_eh_exception =
407 CGM.getIntrinsic(llvm::Intrinsic::eh_exception);
408 llvm::Value *llvm_eh_selector =
409 CGM.getIntrinsic(llvm::Intrinsic::eh_selector);
Mike Stump58ef18b2009-11-20 23:44:51 +0000410
Mike Stump58ef18b2009-11-20 23:44:51 +0000411 llvm::BasicBlock *PrevLandingPad = getInvokeDest();
412 llvm::BasicBlock *TryHandler = createBasicBlock("try.handler");
Mike Stump58ef18b2009-11-20 23:44:51 +0000413 llvm::BasicBlock *FinallyBlock = createBasicBlock("finally");
Mike Stump54066142009-12-01 03:41:18 +0000414 llvm::BasicBlock *FinallyRethrow = createBasicBlock("finally.throw");
Mike Stump58ef18b2009-11-20 23:44:51 +0000415 llvm::BasicBlock *FinallyEnd = createBasicBlock("finally.end");
416
417 // Push an EH context entry, used for handling rethrows.
418 PushCleanupBlock(FinallyBlock);
419
420 // Emit the statements in the try {} block
421 setInvokeDest(TryHandler);
422
Mike Stumpbee78dd2009-12-04 23:26:17 +0000423 // FIXME: We should not have to do this here. The AST should have the member
424 // initializers under the CXXTryStmt's TryBlock.
425 if (OuterTryBlock == &S) {
426 GlobalDecl GD = CurGD;
427 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
428
429 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD)) {
430 size_t OldCleanupStackSize = CleanupEntries.size();
431 EmitCtorPrologue(CD, CurGD.getCtorType());
432 EmitStmt(S.getTryBlock());
433
434 // If any of the member initializers are temporaries bound to references
435 // make sure to emit their destructors.
436 EmitCleanupBlocks(OldCleanupStackSize);
437 } else if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(FD)) {
438 llvm::BasicBlock *DtorEpilogue = createBasicBlock("dtor.epilogue");
439 PushCleanupBlock(DtorEpilogue);
440
441 EmitStmt(S.getTryBlock());
Mike Stump75546b82009-12-10 00:06:18 +0000442
Mike Stumpbee78dd2009-12-04 23:26:17 +0000443 CleanupBlockInfo Info = PopCleanupBlock();
444
445 assert(Info.CleanupBlock == DtorEpilogue && "Block mismatch!");
446 EmitBlock(DtorEpilogue);
447 EmitDtorEpilogue(DD, GD.getDtorType());
Mike Stump75546b82009-12-10 00:06:18 +0000448
Mike Stumpbee78dd2009-12-04 23:26:17 +0000449 if (Info.SwitchBlock)
450 EmitBlock(Info.SwitchBlock);
451 if (Info.EndBlock)
452 EmitBlock(Info.EndBlock);
Mike Stump75546b82009-12-10 00:06:18 +0000453 } else
Mike Stumpbee78dd2009-12-04 23:26:17 +0000454 EmitStmt(S.getTryBlock());
455 } else
456 EmitStmt(S.getTryBlock());
Mike Stump58ef18b2009-11-20 23:44:51 +0000457
458 // Jump to end if there is no exception
459 EmitBranchThroughCleanup(FinallyEnd);
460
Mike Stump2b488872009-12-09 22:59:31 +0000461 llvm::BasicBlock *TerminateHandler = getTerminateHandler();
Mike Stump97329152009-12-02 19:53:57 +0000462
Mike Stump58ef18b2009-11-20 23:44:51 +0000463 // Emit the handlers
464 EmitBlock(TryHandler);
Mike Stump75546b82009-12-10 00:06:18 +0000465
Mike Stump58ef18b2009-11-20 23:44:51 +0000466 const llvm::IntegerType *Int8Ty;
467 const llvm::PointerType *PtrToInt8Ty;
468 Int8Ty = llvm::Type::getInt8Ty(VMContext);
469 // C string type. Used in lots of places.
470 PtrToInt8Ty = llvm::PointerType::getUnqual(Int8Ty);
Mike Stump54066142009-12-01 03:41:18 +0000471 llvm::Constant *Null = llvm::ConstantPointerNull::get(PtrToInt8Ty);
472 llvm::SmallVector<llvm::Value*, 8> SelectorArgs;
Mike Stump54066142009-12-01 03:41:18 +0000473 llvm::Value *llvm_eh_typeid_for =
474 CGM.getIntrinsic(llvm::Intrinsic::eh_typeid_for);
Mike Stump58ef18b2009-11-20 23:44:51 +0000475 // Exception object
Mike Stump2b488872009-12-09 22:59:31 +0000476 llvm::Value *Exc = Builder.CreateCall(llvm_eh_exception, "exc");
Mike Stump54066142009-12-01 03:41:18 +0000477 llvm::Value *RethrowPtr = CreateTempAlloca(Exc->getType(), "_rethrow");
Mike Stump58ef18b2009-11-20 23:44:51 +0000478
Mike Stump2b488872009-12-09 22:59:31 +0000479 llvm::SmallVector<llvm::Value*, 8> Args;
Mike Stump97329152009-12-02 19:53:57 +0000480 Args.clear();
Mike Stump54066142009-12-01 03:41:18 +0000481 SelectorArgs.push_back(Exc);
482 SelectorArgs.push_back(Personality);
Mike Stump58ef18b2009-11-20 23:44:51 +0000483
Mike Stump54066142009-12-01 03:41:18 +0000484 bool HasCatchAll = false;
Mike Stump58ef18b2009-11-20 23:44:51 +0000485 for (unsigned i = 0; i<S.getNumHandlers(); ++i) {
486 const CXXCatchStmt *C = S.getHandler(i);
Mike Stump54066142009-12-01 03:41:18 +0000487 VarDecl *CatchParam = C->getExceptionDecl();
488 if (CatchParam) {
Mike Stumpc01c2b82009-12-02 18:57:08 +0000489 llvm::Value *EHType
490 = CGM.GenerateRTTI(C->getCaughtType().getNonReferenceType());
Mike Stump54066142009-12-01 03:41:18 +0000491 SelectorArgs.push_back(EHType);
Mike Stump58ef18b2009-11-20 23:44:51 +0000492 } else {
493 // null indicates catch all
Mike Stump54066142009-12-01 03:41:18 +0000494 SelectorArgs.push_back(Null);
495 HasCatchAll = true;
Mike Stump58ef18b2009-11-20 23:44:51 +0000496 }
497 }
498
Mike Stump54066142009-12-01 03:41:18 +0000499 // We use a cleanup unless there was already a catch all.
500 if (!HasCatchAll) {
501 SelectorArgs.push_back(Null);
502 }
Mike Stump58ef18b2009-11-20 23:44:51 +0000503
Mike Stump54066142009-12-01 03:41:18 +0000504 // Find which handler was matched.
505 llvm::Value *Selector
506 = Builder.CreateCall(llvm_eh_selector, SelectorArgs.begin(),
507 SelectorArgs.end(), "selector");
Mike Stump58ef18b2009-11-20 23:44:51 +0000508 for (unsigned i = 0; i<S.getNumHandlers(); ++i) {
509 const CXXCatchStmt *C = S.getHandler(i);
Mike Stump54066142009-12-01 03:41:18 +0000510 VarDecl *CatchParam = C->getExceptionDecl();
511 Stmt *CatchBody = C->getHandlerBlock();
512
513 llvm::BasicBlock *Next = 0;
514
515 if (SelectorArgs[i+2] != Null) {
516 llvm::BasicBlock *Match = createBasicBlock("match");
517 Next = createBasicBlock("catch.next");
518 const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(getLLVMContext());
519 llvm::Value *Id
520 = Builder.CreateCall(llvm_eh_typeid_for,
521 Builder.CreateBitCast(SelectorArgs[i+2],
522 Int8PtrTy));
523 Builder.CreateCondBr(Builder.CreateICmpEQ(Selector, Id),
524 Match, Next);
525 EmitBlock(Match);
526 }
527
528 llvm::BasicBlock *MatchEnd = createBasicBlock("match.end");
529 llvm::BasicBlock *MatchHandler = createBasicBlock("match.handler");
530
531 PushCleanupBlock(MatchEnd);
532 setInvokeDest(MatchHandler);
533
534 llvm::Value *ExcObject = Builder.CreateCall(getBeginCatchFn(*this), Exc);
535
Mike Stump90990962009-12-02 23:37:16 +0000536 {
537 CleanupScope CatchScope(*this);
538 // Bind the catch parameter if it exists.
539 if (CatchParam) {
540 QualType CatchType = CatchParam->getType().getNonReferenceType();
541 setInvokeDest(TerminateHandler);
Mike Stump7398ff02009-12-03 22:38:15 +0000542 bool WasPointer = true;
543 if (!CatchType.getTypePtr()->isPointerType()) {
Mike Stump114ab9f2009-12-04 01:51:45 +0000544 if (!isa<ReferenceType>(CatchParam->getType()))
545 WasPointer = false;
Mike Stump90990962009-12-02 23:37:16 +0000546 CatchType = getContext().getPointerType(CatchType);
Mike Stump7398ff02009-12-03 22:38:15 +0000547 }
Mike Stump90990962009-12-02 23:37:16 +0000548 ExcObject = Builder.CreateBitCast(ExcObject, ConvertType(CatchType));
Mike Stump90990962009-12-02 23:37:16 +0000549 EmitLocalBlockVarDecl(*CatchParam);
Mike Stump2842b4c2009-12-03 03:40:14 +0000550 // FIXME: we need to do this sooner so that the EH region for the
551 // cleanup doesn't start until after the ctor completes, use a decl
552 // init?
Mike Stump90990962009-12-02 23:37:16 +0000553 CopyObject(*this, CatchParam->getType().getNonReferenceType(),
Mike Stump7398ff02009-12-03 22:38:15 +0000554 WasPointer, ExcObject, GetAddrOfLocalVar(CatchParam));
Mike Stump90990962009-12-02 23:37:16 +0000555 setInvokeDest(MatchHandler);
556 }
557
558 EmitStmt(CatchBody);
Mike Stump54066142009-12-01 03:41:18 +0000559 }
560
Mike Stump54066142009-12-01 03:41:18 +0000561 EmitBranchThroughCleanup(FinallyEnd);
562
563 EmitBlock(MatchHandler);
564
565 llvm::Value *Exc = Builder.CreateCall(llvm_eh_exception, "exc");
566 // We are required to emit this call to satisfy LLVM, even
567 // though we don't use the result.
Mike Stump97329152009-12-02 19:53:57 +0000568 Args.clear();
Mike Stump54066142009-12-01 03:41:18 +0000569 Args.push_back(Exc);
570 Args.push_back(Personality);
571 Args.push_back(llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext),
572 0));
573 Builder.CreateCall(llvm_eh_selector, Args.begin(), Args.end());
574 Builder.CreateStore(Exc, RethrowPtr);
575 EmitBranchThroughCleanup(FinallyRethrow);
576
577 CodeGenFunction::CleanupBlockInfo Info = PopCleanupBlock();
578
579 EmitBlock(MatchEnd);
580
Mike Stump33270212009-12-02 07:41:41 +0000581 llvm::BasicBlock *Cont = createBasicBlock("invoke.cont");
Mike Stump54066142009-12-01 03:41:18 +0000582 Builder.CreateInvoke(getEndCatchFn(*this),
Mike Stump33270212009-12-02 07:41:41 +0000583 Cont, TerminateHandler,
Mike Stump54066142009-12-01 03:41:18 +0000584 Args.begin(), Args.begin());
Mike Stump54066142009-12-01 03:41:18 +0000585 EmitBlock(Cont);
586 if (Info.SwitchBlock)
587 EmitBlock(Info.SwitchBlock);
588 if (Info.EndBlock)
589 EmitBlock(Info.EndBlock);
590
Mike Stump54066142009-12-01 03:41:18 +0000591 Exc = Builder.CreateCall(llvm_eh_exception, "exc");
Mike Stump54066142009-12-01 03:41:18 +0000592 Builder.CreateStore(Exc, RethrowPtr);
593 EmitBranchThroughCleanup(FinallyRethrow);
594
595 if (Next)
596 EmitBlock(Next);
597 }
Mike Stump5c820752009-12-04 19:03:47 +0000598 if (!HasCatchAll) {
599 Builder.CreateStore(Exc, RethrowPtr);
Mike Stump54066142009-12-01 03:41:18 +0000600 EmitBranchThroughCleanup(FinallyRethrow);
Mike Stump5c820752009-12-04 19:03:47 +0000601 }
Mike Stump58ef18b2009-11-20 23:44:51 +0000602
603 CodeGenFunction::CleanupBlockInfo Info = PopCleanupBlock();
604
605 setInvokeDest(PrevLandingPad);
606
607 EmitBlock(FinallyBlock);
608
Mike Stump54066142009-12-01 03:41:18 +0000609 if (Info.SwitchBlock)
610 EmitBlock(Info.SwitchBlock);
611 if (Info.EndBlock)
612 EmitBlock(Info.EndBlock);
613
Mike Stump58ef18b2009-11-20 23:44:51 +0000614 // Branch around the rethrow code.
615 EmitBranch(FinallyEnd);
616
617 EmitBlock(FinallyRethrow);
Mike Stump875912a2009-12-04 19:21:57 +0000618 // FIXME: Eventually we can chain the handlers together and just do a call
619 // here.
620 if (getInvokeDest()) {
621 llvm::BasicBlock *Cont = createBasicBlock("invoke.cont");
622 Builder.CreateInvoke(getUnwindResumeOrRethrowFn(*this), Cont,
623 getInvokeDest(),
624 Builder.CreateLoad(RethrowPtr));
625 EmitBlock(Cont);
626 } else
627 Builder.CreateCall(getUnwindResumeOrRethrowFn(*this),
628 Builder.CreateLoad(RethrowPtr));
629
Mike Stump58ef18b2009-11-20 23:44:51 +0000630 Builder.CreateUnreachable();
Mike Stump58ef18b2009-11-20 23:44:51 +0000631
632 EmitBlock(FinallyEnd);
Mike Stump58ef18b2009-11-20 23:44:51 +0000633}
Mike Stumpaff69af2009-12-09 03:35:49 +0000634
635CodeGenFunction::EHCleanupBlock::~EHCleanupBlock() {
636 llvm::BasicBlock *Cont1 = CGF.createBasicBlock("cont");
637 CGF.EmitBranch(Cont1);
638 CGF.setInvokeDest(PreviousInvokeDest);
639
640
641 CGF.EmitBlock(CleanupHandler);
642
643 llvm::Constant *Personality =
644 CGF.CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::getInt32Ty
645 (CGF.VMContext),
646 true),
647 "__gxx_personality_v0");
648 Personality = llvm::ConstantExpr::getBitCast(Personality, CGF.PtrToInt8Ty);
649 llvm::Value *llvm_eh_exception =
650 CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_exception);
651 llvm::Value *llvm_eh_selector =
652 CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_selector);
653
654 llvm::Value *Exc = CGF.Builder.CreateCall(llvm_eh_exception, "exc");
655 const llvm::IntegerType *Int8Ty;
656 const llvm::PointerType *PtrToInt8Ty;
657 Int8Ty = llvm::Type::getInt8Ty(CGF.VMContext);
658 // C string type. Used in lots of places.
659 PtrToInt8Ty = llvm::PointerType::getUnqual(Int8Ty);
660 llvm::Constant *Null = llvm::ConstantPointerNull::get(PtrToInt8Ty);
661 llvm::SmallVector<llvm::Value*, 8> Args;
662 Args.clear();
663 Args.push_back(Exc);
664 Args.push_back(Personality);
665 Args.push_back(Null);
666 CGF.Builder.CreateCall(llvm_eh_selector, Args.begin(), Args.end());
667
668 CGF.EmitBlock(CleanupEntryBB);
669
670 CGF.EmitBlock(Cont1);
671
672 if (CGF.getInvokeDest()) {
673 llvm::BasicBlock *Cont = CGF.createBasicBlock("invoke.cont");
674 CGF.Builder.CreateInvoke(getUnwindResumeOrRethrowFn(CGF), Cont,
675 CGF.getInvokeDest(), Exc);
676 CGF.EmitBlock(Cont);
677 } else
678 CGF.Builder.CreateCall(getUnwindResumeOrRethrowFn(CGF), Exc);
679
680 CGF.Builder.CreateUnreachable();
681
682 CGF.EmitBlock(Cont);
683 if (CGF.Exceptions)
684 CGF.setInvokeDest(CleanupHandler);
685}
Mike Stump2b488872009-12-09 22:59:31 +0000686
687llvm::BasicBlock *CodeGenFunction::getTerminateHandler() {
Mike Stumpf5cbb082009-12-10 00:02:42 +0000688 if (TerminateHandler)
689 return TerminateHandler;
690
Mike Stump25b20fc2009-12-09 23:31:35 +0000691 llvm::BasicBlock *Cont = 0;
692
693 if (HaveInsertPoint()) {
694 Cont = createBasicBlock("cont");
695 EmitBranch(Cont);
696 }
697
Mike Stump2b488872009-12-09 22:59:31 +0000698 llvm::Constant *Personality =
699 CGM.CreateRuntimeFunction(llvm::FunctionType::get(llvm::Type::getInt32Ty
700 (VMContext),
701 true),
702 "__gxx_personality_v0");
703 Personality = llvm::ConstantExpr::getBitCast(Personality, PtrToInt8Ty);
704 llvm::Value *llvm_eh_exception =
705 CGM.getIntrinsic(llvm::Intrinsic::eh_exception);
706 llvm::Value *llvm_eh_selector =
707 CGM.getIntrinsic(llvm::Intrinsic::eh_selector);
708
709 // Set up terminate handler
Mike Stumpf5cbb082009-12-10 00:02:42 +0000710 TerminateHandler = createBasicBlock("terminate.handler");
Mike Stump2b488872009-12-09 22:59:31 +0000711 EmitBlock(TerminateHandler);
712 llvm::Value *Exc = Builder.CreateCall(llvm_eh_exception, "exc");
713 // We are required to emit this call to satisfy LLVM, even
714 // though we don't use the result.
715 llvm::SmallVector<llvm::Value*, 8> Args;
716 Args.push_back(Exc);
717 Args.push_back(Personality);
718 Args.push_back(llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext),
Mike Stump25b20fc2009-12-09 23:31:35 +0000719 1));
Mike Stump2b488872009-12-09 22:59:31 +0000720 Builder.CreateCall(llvm_eh_selector, Args.begin(), Args.end());
Mike Stump75546b82009-12-10 00:06:18 +0000721 llvm::CallInst *TerminateCall =
Mike Stump2b488872009-12-09 22:59:31 +0000722 Builder.CreateCall(getTerminateFn(*this));
723 TerminateCall->setDoesNotReturn();
724 TerminateCall->setDoesNotThrow();
725 Builder.CreateUnreachable();
726
727 // Clear the insertion point to indicate we are in unreachable code.
728 Builder.ClearInsertionPoint();
729
Mike Stump25b20fc2009-12-09 23:31:35 +0000730 if (Cont)
731 EmitBlock(Cont);
732
Mike Stump2b488872009-12-09 22:59:31 +0000733 return TerminateHandler;
734}