blob: c4a332456161301370e976d739c3be3c514f6858 [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- CodeGenFunction.cpp - Emit LLVM Code from ASTs for a Function ----===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This coordinates the per-function state used while generating code.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CodeGenFunction.h"
15#include "CodeGenModule.h"
Eli Friedman3f2af102008-05-22 01:40:10 +000016#include "CGDebugInfo.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000017#include "clang/Basic/TargetInfo.h"
Daniel Dunbarde7fb842008-08-11 05:00:27 +000018#include "clang/AST/ASTContext.h"
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000019#include "clang/AST/Decl.h"
Devang Pateld9363c32007-09-28 21:49:18 +000020#include "llvm/Support/CFG.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000021using namespace clang;
22using namespace CodeGen;
23
24CodeGenFunction::CodeGenFunction(CodeGenModule &cgm)
Devang Patelc049e4f2007-10-08 20:57:48 +000025 : CGM(cgm), Target(CGM.getContext().Target), SwitchInsn(NULL),
Chris Lattner41110242008-06-17 18:05:57 +000026 CaseRangeBlock(NULL) {
27 LLVMIntTy = ConvertType(getContext().IntTy);
28 LLVMPointerWidth = Target.getPointerWidth(0);
29}
Reid Spencer5f016e22007-07-11 17:01:13 +000030
31ASTContext &CodeGenFunction::getContext() const {
32 return CGM.getContext();
33}
34
35
36llvm::BasicBlock *CodeGenFunction::getBasicBlockForLabel(const LabelStmt *S) {
37 llvm::BasicBlock *&BB = LabelMap[S];
38 if (BB) return BB;
39
40 // Create, but don't insert, the new block.
Gabor Greif984d0b42008-04-06 20:42:52 +000041 return BB = llvm::BasicBlock::Create(S->getName());
Reid Spencer5f016e22007-07-11 17:01:13 +000042}
43
Lauro Ramos Venancio81373352008-02-26 21:41:45 +000044llvm::Constant *
Steve Naroff248a7532008-04-15 22:42:06 +000045CodeGenFunction::GetAddrOfStaticLocalVar(const VarDecl *BVD) {
Lauro Ramos Venancio81373352008-02-26 21:41:45 +000046 return cast<llvm::Constant>(LocalDeclMap[BVD]);
47}
Reid Spencer5f016e22007-07-11 17:01:13 +000048
Anders Carlssondde0a942008-09-11 09:15:33 +000049llvm::Value *CodeGenFunction::GetAddrOfLocalVar(const VarDecl *VD)
50{
51 return LocalDeclMap[VD];
52}
53
Reid Spencer5f016e22007-07-11 17:01:13 +000054const llvm::Type *CodeGenFunction::ConvertType(QualType T) {
55 return CGM.getTypes().ConvertType(T);
56}
57
Chris Lattner41110242008-06-17 18:05:57 +000058bool CodeGenFunction::isObjCPointerType(QualType T) {
59 // All Objective-C types are pointers.
60 return T->isObjCInterfaceType() ||
61 T->isObjCQualifiedInterfaceType() || T->isObjCQualifiedIdType();
62}
63
Reid Spencer5f016e22007-07-11 17:01:13 +000064bool CodeGenFunction::hasAggregateLLVMType(QualType T) {
Chris Lattner41110242008-06-17 18:05:57 +000065 return !isObjCPointerType(T) &&!T->isRealType() && !T->isPointerLikeType() &&
66 !T->isVoidType() && !T->isVectorType() && !T->isFunctionType();
Reid Spencer5f016e22007-07-11 17:01:13 +000067}
68
Daniel Dunbaraf05bb92008-08-26 08:29:31 +000069void CodeGenFunction::FinishFunction(SourceLocation EndLoc) {
Daniel Dunbar0ffb1252008-08-04 16:51:22 +000070 // Finish emission of indirect switches.
71 EmitIndirectSwitches();
72
Sanjiv Guptaaf994172008-07-04 11:04:26 +000073 // Emit debug descriptor for function end.
Daniel Dunbar5ca20842008-09-09 21:00:17 +000074 if (CGDebugInfo *DI = CGM.getDebugInfo()) {
Daniel Dunbar66031a52008-10-17 16:15:48 +000075 DI->setLocation(EndLoc);
Sanjiv Guptaaf994172008-07-04 11:04:26 +000076 DI->EmitRegionEnd(CurFn, Builder);
77 }
78
Chris Lattnerda138702007-07-16 21:28:45 +000079 assert(BreakContinueStack.empty() &&
80 "mismatched push/pop in break/continue stack!");
Daniel Dunbar5ca20842008-09-09 21:00:17 +000081
Daniel Dunbarb01d1912008-09-27 07:15:59 +000082 // Emit function epilog (to return). This has the nice side effect
83 // of also automatically handling code that falls off the end.
84 EmitBlock(ReturnBlock);
Daniel Dunbar17b708d2008-09-09 23:27:19 +000085 EmitFunctionEpilog(FnRetTy, ReturnValue);
Daniel Dunbar5ca20842008-09-09 21:00:17 +000086
Chris Lattner5a2fa142007-12-02 06:32:24 +000087 // Remove the AllocaInsertPt instruction, which is just a convenience for us.
88 AllocaInsertPt->eraseFromParent();
89 AllocaInsertPt = 0;
Reid Spencer5f016e22007-07-11 17:01:13 +000090}
91
Daniel Dunbar7c086512008-09-09 23:14:03 +000092void CodeGenFunction::StartFunction(const Decl *D, QualType RetTy,
93 llvm::Function *Fn,
Daniel Dunbar2284ac92008-10-18 18:22:23 +000094 const FunctionArgList &Args,
95 SourceLocation StartLoc) {
Daniel Dunbar7c086512008-09-09 23:14:03 +000096 CurFuncDecl = D;
97 FnRetTy = RetTy;
Daniel Dunbarbd012ff2008-07-29 23:18:29 +000098 CurFn = Fn;
Chris Lattner41110242008-06-17 18:05:57 +000099 assert(CurFn->isDeclaration() && "Function already has body?");
100
101 llvm::BasicBlock *EntryBB = llvm::BasicBlock::Create("entry", CurFn);
Daniel Dunbar5ca20842008-09-09 21:00:17 +0000102
Chris Lattner41110242008-06-17 18:05:57 +0000103 // Create a marker to make it easy to insert allocas into the entryblock
104 // later. Don't create this with the builder, because we don't want it
105 // folded.
106 llvm::Value *Undef = llvm::UndefValue::get(llvm::Type::Int32Ty);
107 AllocaInsertPt = new llvm::BitCastInst(Undef, llvm::Type::Int32Ty, "allocapt",
108 EntryBB);
Daniel Dunbar5ca20842008-09-09 21:00:17 +0000109
Daniel Dunbarb01d1912008-09-27 07:15:59 +0000110 ReturnBlock = llvm::BasicBlock::Create("return");
Daniel Dunbar5ca20842008-09-09 21:00:17 +0000111 ReturnValue = 0;
Daniel Dunbar7c086512008-09-09 23:14:03 +0000112 if (!RetTy->isVoidType())
113 ReturnValue = CreateTempAlloca(ConvertType(RetTy), "retval");
Daniel Dunbar5ca20842008-09-09 21:00:17 +0000114
Chris Lattner41110242008-06-17 18:05:57 +0000115 Builder.SetInsertPoint(EntryBB);
116
Sanjiv Guptaaf994172008-07-04 11:04:26 +0000117 // Emit subprogram debug descriptor.
Daniel Dunbar7c086512008-09-09 23:14:03 +0000118 // FIXME: The cast here is a huge hack.
Daniel Dunbar2284ac92008-10-18 18:22:23 +0000119 if (CGDebugInfo *DI = CGM.getDebugInfo()) {
120 DI->setLocation(StartLoc);
121 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
122 DI->EmitFunctionStart(FD->getName(), RetTy, CurFn, Builder);
123 } else {
124 // Just use LLVM function name.
125 DI->EmitFunctionStart(Fn->getName().c_str(),
126 RetTy, CurFn, Builder);
Sanjiv Guptaaf994172008-07-04 11:04:26 +0000127 }
Sanjiv Guptaaf994172008-07-04 11:04:26 +0000128 }
129
Daniel Dunbar17b708d2008-09-09 23:27:19 +0000130 EmitFunctionProlog(CurFn, FnRetTy, Args);
Daniel Dunbar7c086512008-09-09 23:14:03 +0000131}
Eli Friedmaneb4b7052008-08-25 21:31:01 +0000132
Daniel Dunbar7c086512008-09-09 23:14:03 +0000133void CodeGenFunction::GenerateCode(const FunctionDecl *FD,
134 llvm::Function *Fn) {
135 FunctionArgList Args;
Eli Friedmaneb4b7052008-08-25 21:31:01 +0000136 if (FD->getNumParams()) {
137 const FunctionTypeProto* FProto = FD->getType()->getAsFunctionTypeProto();
138 assert(FProto && "Function def must have prototype!");
Daniel Dunbar7c086512008-09-09 23:14:03 +0000139
140 for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i)
141 Args.push_back(std::make_pair(FD->getParamDecl(i),
142 FProto->getArgType(i)));
Chris Lattner41110242008-06-17 18:05:57 +0000143 }
Daniel Dunbaraf05bb92008-08-26 08:29:31 +0000144
Daniel Dunbar2284ac92008-10-18 18:22:23 +0000145 StartFunction(FD, FD->getResultType(), Fn, Args,
146 cast<CompoundStmt>(FD->getBody())->getLBracLoc());
Daniel Dunbar7c086512008-09-09 23:14:03 +0000147
Daniel Dunbaraf05bb92008-08-26 08:29:31 +0000148 EmitStmt(FD->getBody());
149
150 const CompoundStmt *S = dyn_cast<CompoundStmt>(FD->getBody());
151 if (S) {
152 FinishFunction(S->getRBracLoc());
153 } else {
154 FinishFunction();
155 }
Chris Lattner41110242008-06-17 18:05:57 +0000156}
157
Devang Pateld9363c32007-09-28 21:49:18 +0000158/// isDummyBlock - Return true if BB is an empty basic block
159/// with no predecessors.
160bool CodeGenFunction::isDummyBlock(const llvm::BasicBlock *BB) {
Chris Lattner1e9660e2008-07-25 23:40:10 +0000161 if (BB->empty() && pred_begin(BB) == pred_end(BB) && !BB->hasName())
Devang Pateld9363c32007-09-28 21:49:18 +0000162 return true;
163 return false;
164}
165
Devang Patel51b09f22007-10-04 23:45:31 +0000166/// StartBlock - Start new block named N. If insert block is a dummy block
167/// then reuse it.
168void CodeGenFunction::StartBlock(const char *N) {
169 llvm::BasicBlock *BB = Builder.GetInsertBlock();
170 if (!isDummyBlock(BB))
Gabor Greif984d0b42008-04-06 20:42:52 +0000171 EmitBlock(llvm::BasicBlock::Create(N));
Devang Patel51b09f22007-10-04 23:45:31 +0000172 else
173 BB->setName(N);
174}
175
Devang Patel88a981b2007-11-01 19:11:01 +0000176/// getCGRecordLayout - Return record layout info.
177const CGRecordLayout *CodeGenFunction::getCGRecordLayout(CodeGenTypes &CGT,
Chris Lattneraf319132008-02-05 06:55:31 +0000178 QualType Ty) {
179 const RecordType *RTy = Ty->getAsRecordType();
180 assert (RTy && "Unexpected type. RecordType expected here.");
Devang Patelb84a06e2007-10-23 02:10:49 +0000181
Chris Lattneraf319132008-02-05 06:55:31 +0000182 return CGT.getCGRecordLayout(RTy->getDecl());
Devang Patelb84a06e2007-10-23 02:10:49 +0000183}
Chris Lattnerdc5e8262007-12-02 01:43:38 +0000184
Daniel Dunbar488e9932008-08-16 00:56:44 +0000185/// ErrorUnsupported - Print out an error that codegen doesn't support the
Chris Lattnerdc5e8262007-12-02 01:43:38 +0000186/// specified stmt yet.
Daniel Dunbar90df4b62008-09-04 03:43:08 +0000187void CodeGenFunction::ErrorUnsupported(const Stmt *S, const char *Type,
188 bool OmitOnError) {
189 CGM.ErrorUnsupported(S, Type, OmitOnError);
Chris Lattnerdc5e8262007-12-02 01:43:38 +0000190}
191
Daniel Dunbar0ffb1252008-08-04 16:51:22 +0000192unsigned CodeGenFunction::GetIDForAddrOfLabel(const LabelStmt *L) {
193 // Use LabelIDs.size() as the new ID if one hasn't been assigned.
194 return LabelIDs.insert(std::make_pair(L, LabelIDs.size())).first->second;
195}
196
Anders Carlsson3d8400d2008-08-30 19:51:14 +0000197void CodeGenFunction::EmitMemSetToZero(llvm::Value *DestPtr, QualType Ty)
198{
199 const llvm::Type *BP = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
200 if (DestPtr->getType() != BP)
201 DestPtr = Builder.CreateBitCast(DestPtr, BP, "tmp");
202
203 // Get size and alignment info for this aggregate.
204 std::pair<uint64_t, unsigned> TypeInfo = getContext().getTypeInfo(Ty);
205
206 // FIXME: Handle variable sized types.
207 const llvm::Type *IntPtr = llvm::IntegerType::get(LLVMPointerWidth);
208
209 Builder.CreateCall4(CGM.getMemSetFn(), DestPtr,
210 llvm::ConstantInt::getNullValue(llvm::Type::Int8Ty),
211 // TypeInfo.first describes size in bits.
212 llvm::ConstantInt::get(IntPtr, TypeInfo.first/8),
213 llvm::ConstantInt::get(llvm::Type::Int32Ty,
214 TypeInfo.second/8));
215}
216
Daniel Dunbar0ffb1252008-08-04 16:51:22 +0000217void CodeGenFunction::EmitIndirectSwitches() {
218 llvm::BasicBlock *Default;
219
Daniel Dunbar76526a52008-08-04 17:24:44 +0000220 if (IndirectSwitches.empty())
221 return;
222
Daniel Dunbar0ffb1252008-08-04 16:51:22 +0000223 if (!LabelIDs.empty()) {
224 Default = getBasicBlockForLabel(LabelIDs.begin()->first);
225 } else {
226 // No possible targets for indirect goto, just emit an infinite
227 // loop.
228 Default = llvm::BasicBlock::Create("indirectgoto.loop", CurFn);
229 llvm::BranchInst::Create(Default, Default);
230 }
231
232 for (std::vector<llvm::SwitchInst*>::iterator i = IndirectSwitches.begin(),
233 e = IndirectSwitches.end(); i != e; ++i) {
234 llvm::SwitchInst *I = *i;
235
236 I->setSuccessor(0, Default);
237 for (std::map<const LabelStmt*,unsigned>::iterator LI = LabelIDs.begin(),
238 LE = LabelIDs.end(); LI != LE; ++LI) {
239 I->addCase(llvm::ConstantInt::get(llvm::Type::Int32Ty,
240 LI->second),
241 getBasicBlockForLabel(LI->first));
242 }
243 }
244}
Anders Carlssonddf7cac2008-11-04 05:30:00 +0000245
246llvm::Value *CodeGenFunction::EmitVAArg(llvm::Value *VAListAddr, QualType Ty)
247{
248 // FIXME: This entire method is hardcoded for 32-bit X86.
249
250 const char *TargetPrefix = getContext().Target.getTargetPrefix();
251
252 if (strcmp(TargetPrefix, "x86") != 0 ||
253 getContext().Target.getPointerWidth(0) != 32)
254 return 0;
255
256 const llvm::Type *BP = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
257 const llvm::Type *BPP = llvm::PointerType::getUnqual(BP);
258
259 llvm::Value *VAListAddrAsBPP = Builder.CreateBitCast(VAListAddr, BPP,
260 "ap");
261 llvm::Value *Addr = Builder.CreateLoad(VAListAddrAsBPP, "ap.cur");
262 llvm::Value *AddrTyped =
263 Builder.CreateBitCast(Addr,
264 llvm::PointerType::getUnqual(ConvertType(Ty)));
265
266 uint64_t SizeInBytes = getContext().getTypeSize(Ty) / 8;
267 const unsigned ArgumentSizeInBytes = 4;
268 if (SizeInBytes < ArgumentSizeInBytes)
269 SizeInBytes = ArgumentSizeInBytes;
270
271 llvm::Value *NextAddr =
272 Builder.CreateGEP(Addr,
273 llvm::ConstantInt::get(llvm::Type::Int32Ty, SizeInBytes),
274 "ap.next");
275 Builder.CreateStore(NextAddr, VAListAddrAsBPP);
276
277 return AddrTyped;
278}
279