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