CodeGenFunction.cpp revision 7c086516f3cc9fba2733b1919973206c6ba4b171
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/ASTContext.h" 19#include "clang/AST/Decl.h" 20#include "llvm/Analysis/Verifier.h" 21#include "llvm/Support/CFG.h" 22using namespace clang; 23using namespace CodeGen; 24 25CodeGenFunction::CodeGenFunction(CodeGenModule &cgm) 26 : CGM(cgm), Target(CGM.getContext().Target), SwitchInsn(NULL), 27 CaseRangeBlock(NULL) { 28 LLVMIntTy = ConvertType(getContext().IntTy); 29 LLVMPointerWidth = Target.getPointerWidth(0); 30} 31 32ASTContext &CodeGenFunction::getContext() const { 33 return CGM.getContext(); 34} 35 36 37llvm::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 45llvm::Constant * 46CodeGenFunction::GetAddrOfStaticLocalVar(const VarDecl *BVD) { 47 return cast<llvm::Constant>(LocalDeclMap[BVD]); 48} 49 50const llvm::Type *CodeGenFunction::ConvertType(QualType T) { 51 return CGM.getTypes().ConvertType(T); 52} 53 54bool CodeGenFunction::isObjCPointerType(QualType T) { 55 // All Objective-C types are pointers. 56 return T->isObjCInterfaceType() || 57 T->isObjCQualifiedInterfaceType() || T->isObjCQualifiedIdType(); 58} 59 60bool CodeGenFunction::hasAggregateLLVMType(QualType T) { 61 return !isObjCPointerType(T) &&!T->isRealType() && !T->isPointerLikeType() && 62 !T->isVoidType() && !T->isVectorType() && !T->isFunctionType(); 63} 64 65void CodeGenFunction::FinishFunction(SourceLocation EndLoc) { 66 // Finish emission of indirect switches. 67 EmitIndirectSwitches(); 68 69 // Emit debug descriptor for function end. 70 if (CGDebugInfo *DI = CGM.getDebugInfo()) { 71 if (EndLoc.isValid()) { 72 DI->setLocation(EndLoc); 73 } 74 DI->EmitRegionEnd(CurFn, Builder); 75 } 76 77 // Emit a return for code that falls off the end. If insert point 78 // is a dummy block with no predecessors then remove the block itself. 79 llvm::BasicBlock *BB = Builder.GetInsertBlock(); 80 if (isDummyBlock(BB)) { 81 BB->eraseFromParent(); 82 } else { 83 // Just transfer to return 84 Builder.CreateBr(ReturnBlock); 85 } 86 assert(BreakContinueStack.empty() && 87 "mismatched push/pop in break/continue stack!"); 88 89 // Emit code to actually return. 90 Builder.SetInsertPoint(ReturnBlock); 91 if (!ReturnValue) { 92 Builder.CreateRetVoid(); 93 } else { 94 if (!hasAggregateLLVMType(FnRetTy)) { 95 Builder.CreateRet(Builder.CreateLoad(ReturnValue)); 96 } else if (FnRetTy->isAnyComplexType()) { 97 EmitAggregateCopy(CurFn->arg_begin(), ReturnValue, FnRetTy); 98 Builder.CreateRetVoid(); 99 } else { 100 EmitAggregateCopy(CurFn->arg_begin(), ReturnValue, FnRetTy); 101 Builder.CreateRetVoid(); 102 } 103 } 104 105 // Remove the AllocaInsertPt instruction, which is just a convenience for us. 106 AllocaInsertPt->eraseFromParent(); 107 AllocaInsertPt = 0; 108 109 // Verify that the function is well formed. 110 assert(!verifyFunction(*CurFn) && "Generated function is not well formed."); 111} 112 113void CodeGenFunction::StartFunction(const Decl *D, QualType RetTy, 114 llvm::Function *Fn, 115 const FunctionArgList &Args) { 116 CurFuncDecl = D; 117 FnRetTy = RetTy; 118 CurFn = Fn; 119 assert(CurFn->isDeclaration() && "Function already has body?"); 120 121 llvm::BasicBlock *EntryBB = llvm::BasicBlock::Create("entry", CurFn); 122 123 // Create a marker to make it easy to insert allocas into the entryblock 124 // later. Don't create this with the builder, because we don't want it 125 // folded. 126 llvm::Value *Undef = llvm::UndefValue::get(llvm::Type::Int32Ty); 127 AllocaInsertPt = new llvm::BitCastInst(Undef, llvm::Type::Int32Ty, "allocapt", 128 EntryBB); 129 130 ReturnBlock = llvm::BasicBlock::Create("return", CurFn); 131 ReturnValue = 0; 132 if (!RetTy->isVoidType()) 133 ReturnValue = CreateTempAlloca(ConvertType(RetTy), "retval"); 134 135 Builder.SetInsertPoint(EntryBB); 136 137 // Emit subprogram debug descriptor. 138 // FIXME: The cast here is a huge hack. 139 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 140 if (CGDebugInfo *DI = CGM.getDebugInfo()) { 141 CompoundStmt* body = dyn_cast<CompoundStmt>(FD->getBody()); 142 if (body && body->getLBracLoc().isValid()) { 143 DI->setLocation(body->getLBracLoc()); 144 } 145 DI->EmitFunctionStart(FD, CurFn, Builder); 146 } 147 } 148 149 // Emit allocs for param decls. Give the LLVM Argument nodes names. 150 llvm::Function::arg_iterator AI = CurFn->arg_begin(); 151 152 // Name the struct return argument. 153 if (hasAggregateLLVMType(FnRetTy)) { 154 AI->setName("agg.result"); 155 ++AI; 156 } 157 158 for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end(); 159 i != e; ++i, ++AI) { 160 const VarDecl *Arg = i->first; 161 QualType T = i->second; 162 assert(AI != CurFn->arg_end() && "Argument mismatch!"); 163 llvm::Value* V = AI; 164 if (!getContext().typesAreCompatible(T, Arg->getType())) { 165 // This must be a promotion, for something like 166 // "void a(x) short x; {..." 167 V = EmitScalarConversion(V, T, Arg->getType()); 168 } 169 EmitParmDecl(*Arg, V); 170 } 171 assert(AI == CurFn->arg_end() && "Argument mismatch!"); 172} 173 174void CodeGenFunction::GenerateCode(const FunctionDecl *FD, 175 llvm::Function *Fn) { 176 FunctionArgList Args; 177 if (FD->getNumParams()) { 178 const FunctionTypeProto* FProto = FD->getType()->getAsFunctionTypeProto(); 179 assert(FProto && "Function def must have prototype!"); 180 181 for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) 182 Args.push_back(std::make_pair(FD->getParamDecl(i), 183 FProto->getArgType(i))); 184 } 185 186 StartFunction(FD, FD->getResultType(), Fn, Args); 187 188 EmitStmt(FD->getBody()); 189 190 const CompoundStmt *S = dyn_cast<CompoundStmt>(FD->getBody()); 191 if (S) { 192 FinishFunction(S->getRBracLoc()); 193 } else { 194 FinishFunction(); 195 } 196} 197 198/// isDummyBlock - Return true if BB is an empty basic block 199/// with no predecessors. 200bool CodeGenFunction::isDummyBlock(const llvm::BasicBlock *BB) { 201 if (BB->empty() && pred_begin(BB) == pred_end(BB) && !BB->hasName()) 202 return true; 203 return false; 204} 205 206/// StartBlock - Start new block named N. If insert block is a dummy block 207/// then reuse it. 208void CodeGenFunction::StartBlock(const char *N) { 209 llvm::BasicBlock *BB = Builder.GetInsertBlock(); 210 if (!isDummyBlock(BB)) 211 EmitBlock(llvm::BasicBlock::Create(N)); 212 else 213 BB->setName(N); 214} 215 216/// getCGRecordLayout - Return record layout info. 217const CGRecordLayout *CodeGenFunction::getCGRecordLayout(CodeGenTypes &CGT, 218 QualType Ty) { 219 const RecordType *RTy = Ty->getAsRecordType(); 220 assert (RTy && "Unexpected type. RecordType expected here."); 221 222 return CGT.getCGRecordLayout(RTy->getDecl()); 223} 224 225/// ErrorUnsupported - Print out an error that codegen doesn't support the 226/// specified stmt yet. 227void CodeGenFunction::ErrorUnsupported(const Stmt *S, const char *Type, 228 bool OmitOnError) { 229 CGM.ErrorUnsupported(S, Type, OmitOnError); 230} 231 232unsigned CodeGenFunction::GetIDForAddrOfLabel(const LabelStmt *L) { 233 // Use LabelIDs.size() as the new ID if one hasn't been assigned. 234 return LabelIDs.insert(std::make_pair(L, LabelIDs.size())).first->second; 235} 236 237void CodeGenFunction::EmitMemSetToZero(llvm::Value *DestPtr, QualType Ty) 238{ 239 const llvm::Type *BP = llvm::PointerType::getUnqual(llvm::Type::Int8Ty); 240 if (DestPtr->getType() != BP) 241 DestPtr = Builder.CreateBitCast(DestPtr, BP, "tmp"); 242 243 // Get size and alignment info for this aggregate. 244 std::pair<uint64_t, unsigned> TypeInfo = getContext().getTypeInfo(Ty); 245 246 // FIXME: Handle variable sized types. 247 const llvm::Type *IntPtr = llvm::IntegerType::get(LLVMPointerWidth); 248 249 Builder.CreateCall4(CGM.getMemSetFn(), DestPtr, 250 llvm::ConstantInt::getNullValue(llvm::Type::Int8Ty), 251 // TypeInfo.first describes size in bits. 252 llvm::ConstantInt::get(IntPtr, TypeInfo.first/8), 253 llvm::ConstantInt::get(llvm::Type::Int32Ty, 254 TypeInfo.second/8)); 255} 256 257void CodeGenFunction::EmitIndirectSwitches() { 258 llvm::BasicBlock *Default; 259 260 if (IndirectSwitches.empty()) 261 return; 262 263 if (!LabelIDs.empty()) { 264 Default = getBasicBlockForLabel(LabelIDs.begin()->first); 265 } else { 266 // No possible targets for indirect goto, just emit an infinite 267 // loop. 268 Default = llvm::BasicBlock::Create("indirectgoto.loop", CurFn); 269 llvm::BranchInst::Create(Default, Default); 270 } 271 272 for (std::vector<llvm::SwitchInst*>::iterator i = IndirectSwitches.begin(), 273 e = IndirectSwitches.end(); i != e; ++i) { 274 llvm::SwitchInst *I = *i; 275 276 I->setSuccessor(0, Default); 277 for (std::map<const LabelStmt*,unsigned>::iterator LI = LabelIDs.begin(), 278 LE = LabelIDs.end(); LI != LE; ++LI) { 279 I->addCase(llvm::ConstantInt::get(llvm::Type::Int32Ty, 280 LI->second), 281 getBasicBlockForLabel(LI->first)); 282 } 283 } 284} 285