1 //===--- CodeGenFunction.cpp - Emit LLVM Code from ASTs for a Function ----===//
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 coordinates the per-function state used while generating code.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "CodeGenFunction.h"
15 #include "CodeGenModule.h"
16 #include "CGDebugInfo.h"
17 #include "clang/Basic/TargetInfo.h"
18 #include "clang/AST/AST.h"
19 #include "llvm/CallingConv.h"
20 #include "llvm/Constants.h"
21 #include "llvm/DerivedTypes.h"
22 #include "llvm/Function.h"
23 #include "llvm/Analysis/Verifier.h"
24 #include "llvm/Support/CFG.h"
25 using namespace clang;
26 using namespace CodeGen;
27 
28 CodeGenFunction::CodeGenFunction(CodeGenModule &cgm)
29   : CGM(cgm), Target(CGM.getContext().Target), SwitchInsn(NULL),
30     CaseRangeBlock(NULL) {}
31 
32 ASTContext &CodeGenFunction::getContext() const {
33   return CGM.getContext();
34 }
35 
36 
37 llvm::BasicBlock *CodeGenFunction::getBasicBlockForLabel(const LabelStmt *S) {
38   llvm::BasicBlock *&BB = LabelMap[S];
39   if (BB) return BB;
40 
41   // Create, but don't insert, the new block.
42   return BB = llvm::BasicBlock::Create(S->getName());
43 }
44 
45 llvm::Constant *
46 CodeGenFunction::GetAddrOfStaticLocalVar(const VarDecl *BVD) {
47   return cast<llvm::Constant>(LocalDeclMap[BVD]);
48 }
49 
50 const llvm::Type *CodeGenFunction::ConvertType(QualType T) {
51   return CGM.getTypes().ConvertType(T);
52 }
53 
54 bool CodeGenFunction::hasAggregateLLVMType(QualType T) {
55   return !T->isRealType() && !T->isPointerLikeType() &&
56          !T->isVoidType() && !T->isVectorType() && !T->isFunctionType();
57 }
58 
59 /// Generate an Objective-C method.  An Objective-C method is a C function with
60 /// its pointer, name, and types registered in the class struture.
61 // FIXME: This method contains a lot of code copied and pasted from
62 // GenerateCode.  This should be factored out.
63 void CodeGenFunction::GenerateObjCMethod(const ObjCMethodDecl *OMD) {
64   llvm::SmallVector<const llvm::Type *, 16> ParamTypes;
65   for (unsigned i=0 ; i<OMD->param_size() ; i++) {
66     ParamTypes.push_back(ConvertType(OMD->getParamDecl(i)->getType()));
67   }
68   std::string CategoryName = "";
69   if (ObjCCategoryImplDecl *OCD =
70     dyn_cast<ObjCCategoryImplDecl>(OMD->getMethodContext())) {
71     CategoryName = OCD->getName();
72   }
73 
74   CurFn =CGM.getObjCRuntime()->MethodPreamble(
75                             OMD->getClassInterface()->getName(),
76                             CategoryName,
77                             OMD->getSelector().getName(),
78                             ConvertType(OMD->getResultType()),
79                             llvm::PointerType::getUnqual(llvm::Type::Int32Ty),
80                             ParamTypes.begin(),
81                             OMD->param_size(),
82                             !OMD->isInstance(),
83                             OMD->isVariadic());
84   llvm::BasicBlock *EntryBB = llvm::BasicBlock::Create("entry", CurFn);
85 
86   // Create a marker to make it easy to insert allocas into the entryblock
87   // later.  Don't create this with the builder, because we don't want it
88   // folded.
89   llvm::Value *Undef = llvm::UndefValue::get(llvm::Type::Int32Ty);
90   AllocaInsertPt = new llvm::BitCastInst(Undef, llvm::Type::Int32Ty, "allocapt",
91                                          EntryBB);
92 
93   FnRetTy = OMD->getResultType();
94 
95   Builder.SetInsertPoint(EntryBB);
96 
97   // Emit allocs for param decls.  Give the LLVM Argument nodes names.
98   llvm::Function::arg_iterator AI = CurFn->arg_begin();
99 
100   // Name the struct return argument.
101   // FIXME: Probably should be in the runtime, or it will trample the other
102   // hidden arguments.
103   if (hasAggregateLLVMType(OMD->getResultType())) {
104     AI->setName("agg.result");
105     ++AI;
106   }
107 
108   // Add implicit parameters to the decl map.
109   // TODO: Add something to AST to let the runtime specify the names and types
110   // of these.
111   llvm::Value *&DMEntry = LocalDeclMap[&(*OMD->getSelfDecl())];
112   const llvm::Type *SelfTy = AI->getType();
113   llvm::Value *DeclPtr = new llvm::AllocaInst(SelfTy, 0, "self.addr",
114                                    AllocaInsertPt);
115 
116   // Store the initial value into the alloca.
117   Builder.CreateStore(AI, DeclPtr);
118   DMEntry = DeclPtr;
119   ++AI; ++AI;
120 
121 
122   for (unsigned i = 0, e = OMD->getNumParams(); i != e; ++i, ++AI) {
123     assert(AI != CurFn->arg_end() && "Argument mismatch!");
124     EmitParmDecl(*OMD->getParamDecl(i), AI);
125   }
126 
127   // Emit the function body.
128   EmitStmt(OMD->getBody());
129 
130   // Emit a return for code that falls off the end. If insert point
131   // is a dummy block with no predecessors then remove the block itself.
132   llvm::BasicBlock *BB = Builder.GetInsertBlock();
133   if (isDummyBlock(BB))
134     BB->eraseFromParent();
135   else {
136     if (CurFn->getReturnType() == llvm::Type::VoidTy)
137       Builder.CreateRetVoid();
138     else
139       Builder.CreateRet(llvm::UndefValue::get(CurFn->getReturnType()));
140   }
141   assert(BreakContinueStack.empty() &&
142          "mismatched push/pop in break/continue stack!");
143 
144   // Remove the AllocaInsertPt instruction, which is just a convenience for us.
145   AllocaInsertPt->eraseFromParent();
146   AllocaInsertPt = 0;
147   // Verify that the function is well formed.
148   assert(!verifyFunction(*CurFn) && "Generated method is not well formed.");
149 }
150 
151 llvm::Value *CodeGenFunction::LoadObjCSelf(void)
152 {
153   if(const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(CurFuncDecl)) {
154     llvm::Value *SelfPtr = LocalDeclMap[&(*OMD->getSelfDecl())];
155     return Builder.CreateLoad(SelfPtr, "self");
156   }
157   return NULL;
158 }
159 
160 void CodeGenFunction::GenerateCode(const FunctionDecl *FD) {
161   LLVMIntTy = ConvertType(getContext().IntTy);
162   LLVMPointerWidth = static_cast<unsigned>(
163     getContext().getTypeSize(getContext().getPointerType(getContext().VoidTy)));
164 
165   CurFuncDecl = FD;
166   FnRetTy = FD->getType()->getAsFunctionType()->getResultType();
167 
168   CurFn = cast<llvm::Function>(CGM.GetAddrOfFunctionDecl(FD, true));
169   assert(CurFn->isDeclaration() && "Function already has body?");
170 
171   // TODO: Set up linkage and many other things.  Note, this is a simple
172   // approximation of what we really want.
173   if (FD->getStorageClass() == FunctionDecl::Static)
174     CurFn->setLinkage(llvm::Function::InternalLinkage);
175   else if (FD->getAttr<DLLImportAttr>())
176     CurFn->setLinkage(llvm::Function::DLLImportLinkage);
177   else if (FD->getAttr<DLLExportAttr>())
178     CurFn->setLinkage(llvm::Function::DLLExportLinkage);
179   else if (FD->getAttr<WeakAttr>() || FD->isInline())
180     CurFn->setLinkage(llvm::Function::WeakLinkage);
181 
182   if (FD->getAttr<FastCallAttr>())
183     CurFn->setCallingConv(llvm::CallingConv::Fast);
184 
185   if (const VisibilityAttr *attr = FD->getAttr<VisibilityAttr>())
186     CodeGenModule::setVisibility(CurFn, attr->getVisibility());
187   // FIXME: else handle -fvisibility
188 
189 
190   unsigned FuncAttrs = 0;
191   if (FD->getAttr<NoThrowAttr>())
192     FuncAttrs |= llvm::ParamAttr::NoUnwind;
193   if (FD->getAttr<NoReturnAttr>())
194     FuncAttrs |= llvm::ParamAttr::NoReturn;
195 
196   if (FuncAttrs) {
197     llvm::ParamAttrsWithIndex PAWI =
198       llvm::ParamAttrsWithIndex::get(0, FuncAttrs);
199     CurFn->setParamAttrs(llvm::PAListPtr::get(&PAWI, 1));
200   }
201 
202   llvm::BasicBlock *EntryBB = llvm::BasicBlock::Create("entry", CurFn);
203 
204   // Create a marker to make it easy to insert allocas into the entryblock
205   // later.  Don't create this with the builder, because we don't want it
206   // folded.
207   llvm::Value *Undef = llvm::UndefValue::get(llvm::Type::Int32Ty);
208   AllocaInsertPt = new llvm::BitCastInst(Undef, llvm::Type::Int32Ty, "allocapt",
209                                          EntryBB);
210 
211   Builder.SetInsertPoint(EntryBB);
212 
213   CGDebugInfo *DI = CGM.getDebugInfo();
214   if (DI) {
215     CompoundStmt* body = cast<CompoundStmt>(CurFuncDecl->getBody());
216     if (body->getLBracLoc().isValid()) {
217       DI->setLocation(body->getLBracLoc());
218     }
219     DI->EmitFunctionStart(FD, CurFn, Builder);
220   }
221 
222   // Emit allocs for param decls.  Give the LLVM Argument nodes names.
223   llvm::Function::arg_iterator AI = CurFn->arg_begin();
224 
225   // Name the struct return argument.
226   if (hasAggregateLLVMType(FD->getResultType())) {
227     AI->setName("agg.result");
228     ++AI;
229   }
230 
231   for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i, ++AI) {
232     assert(AI != CurFn->arg_end() && "Argument mismatch!");
233     EmitParmDecl(*FD->getParamDecl(i), AI);
234   }
235 
236   // Emit the function body.
237   EmitStmt(FD->getBody());
238 
239   if (DI) {
240     CompoundStmt* body = cast<CompoundStmt>(CurFuncDecl->getBody());
241     if (body->getRBracLoc().isValid()) {
242       DI->setLocation(body->getRBracLoc());
243     }
244     DI->EmitRegionEnd(CurFn, Builder);
245   }
246 
247   // Emit a return for code that falls off the end. If insert point
248   // is a dummy block with no predecessors then remove the block itself.
249   llvm::BasicBlock *BB = Builder.GetInsertBlock();
250   if (isDummyBlock(BB))
251     BB->eraseFromParent();
252   else {
253     // FIXME: if this is C++ main, this should return 0.
254     if (CurFn->getReturnType() == llvm::Type::VoidTy)
255       Builder.CreateRetVoid();
256     else
257       Builder.CreateRet(llvm::UndefValue::get(CurFn->getReturnType()));
258   }
259   assert(BreakContinueStack.empty() &&
260          "mismatched push/pop in break/continue stack!");
261 
262   // Remove the AllocaInsertPt instruction, which is just a convenience for us.
263   AllocaInsertPt->eraseFromParent();
264   AllocaInsertPt = 0;
265 
266   // Verify that the function is well formed.
267   assert(!verifyFunction(*CurFn) && "Generated function is not well formed.");
268 }
269 
270 /// isDummyBlock - Return true if BB is an empty basic block
271 /// with no predecessors.
272 bool CodeGenFunction::isDummyBlock(const llvm::BasicBlock *BB) {
273   if (BB->empty() && pred_begin(BB) == pred_end(BB))
274     return true;
275   return false;
276 }
277 
278 /// StartBlock - Start new block named N. If insert block is a dummy block
279 /// then reuse it.
280 void CodeGenFunction::StartBlock(const char *N) {
281   llvm::BasicBlock *BB = Builder.GetInsertBlock();
282   if (!isDummyBlock(BB))
283     EmitBlock(llvm::BasicBlock::Create(N));
284   else
285     BB->setName(N);
286 }
287 
288 /// getCGRecordLayout - Return record layout info.
289 const CGRecordLayout *CodeGenFunction::getCGRecordLayout(CodeGenTypes &CGT,
290                                                          QualType Ty) {
291   const RecordType *RTy = Ty->getAsRecordType();
292   assert (RTy && "Unexpected type. RecordType expected here.");
293 
294   return CGT.getCGRecordLayout(RTy->getDecl());
295 }
296 
297 /// WarnUnsupported - Print out a warning that codegen doesn't support the
298 /// specified stmt yet.
299 void CodeGenFunction::WarnUnsupported(const Stmt *S, const char *Type) {
300   CGM.WarnUnsupported(S, Type);
301 }
302 
303