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/APValue.h" 19 #include "clang/AST/ASTContext.h" 20 #include "clang/AST/Decl.h" 21 #include "llvm/Support/CFG.h" 22 using namespace clang; 23 using namespace CodeGen; 24 25 CodeGenFunction::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 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 = createBasicBlock(S->getName()); 43 } 44 45 llvm::Constant * 46 CodeGenFunction::GetAddrOfStaticLocalVar(const VarDecl *BVD) { 47 return cast<llvm::Constant>(LocalDeclMap[BVD]); 48 } 49 50 llvm::Value *CodeGenFunction::GetAddrOfLocalVar(const VarDecl *VD) 51 { 52 return LocalDeclMap[VD]; 53 } 54 55 const llvm::Type *CodeGenFunction::ConvertType(QualType T) { 56 return CGM.getTypes().ConvertType(T); 57 } 58 59 bool CodeGenFunction::isObjCPointerType(QualType T) { 60 // All Objective-C types are pointers. 61 return T->isObjCInterfaceType() || 62 T->isObjCQualifiedInterfaceType() || T->isObjCQualifiedIdType(); 63 } 64 65 bool CodeGenFunction::hasAggregateLLVMType(QualType T) { 66 return !isObjCPointerType(T) &&!T->isRealType() && !T->isPointerLikeType() && 67 !T->isVoidType() && !T->isVectorType() && !T->isFunctionType(); 68 } 69 70 void CodeGenFunction::FinishFunction(SourceLocation EndLoc) { 71 // Finish emission of indirect switches. 72 EmitIndirectSwitches(); 73 74 assert(BreakContinueStack.empty() && 75 "mismatched push/pop in break/continue stack!"); 76 77 // Emit function epilog (to return). This has the nice side effect 78 // of also automatically handling code that falls off the end. 79 EmitBlock(ReturnBlock); 80 81 // Emit debug descriptor for function end. 82 if (CGDebugInfo *DI = CGM.getDebugInfo()) { 83 DI->setLocation(EndLoc); 84 DI->EmitRegionEnd(CurFn, Builder); 85 } 86 87 EmitFunctionEpilog(FnRetTy, ReturnValue); 88 89 // Remove the AllocaInsertPt instruction, which is just a convenience for us. 90 AllocaInsertPt->eraseFromParent(); 91 AllocaInsertPt = 0; 92 } 93 94 void CodeGenFunction::StartFunction(const Decl *D, QualType RetTy, 95 llvm::Function *Fn, 96 const FunctionArgList &Args, 97 SourceLocation StartLoc) { 98 CurFuncDecl = D; 99 FnRetTy = RetTy; 100 CurFn = Fn; 101 assert(CurFn->isDeclaration() && "Function already has body?"); 102 103 llvm::BasicBlock *EntryBB = createBasicBlock("entry", CurFn); 104 105 // Create a marker to make it easy to insert allocas into the entryblock 106 // later. Don't create this with the builder, because we don't want it 107 // folded. 108 llvm::Value *Undef = llvm::UndefValue::get(llvm::Type::Int32Ty); 109 AllocaInsertPt = new llvm::BitCastInst(Undef, llvm::Type::Int32Ty, "allocapt", 110 EntryBB); 111 112 ReturnBlock = createBasicBlock("return"); 113 ReturnValue = 0; 114 if (!RetTy->isVoidType()) 115 ReturnValue = CreateTempAlloca(ConvertType(RetTy), "retval"); 116 117 Builder.SetInsertPoint(EntryBB); 118 119 // Emit subprogram debug descriptor. 120 // FIXME: The cast here is a huge hack. 121 if (CGDebugInfo *DI = CGM.getDebugInfo()) { 122 DI->setLocation(StartLoc); 123 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 124 DI->EmitFunctionStart(FD->getName(), RetTy, CurFn, Builder); 125 } else { 126 // Just use LLVM function name. 127 DI->EmitFunctionStart(Fn->getName().c_str(), 128 RetTy, CurFn, Builder); 129 } 130 } 131 132 EmitFunctionProlog(CurFn, FnRetTy, Args); 133 } 134 135 void CodeGenFunction::GenerateCode(const FunctionDecl *FD, 136 llvm::Function *Fn) { 137 FunctionArgList Args; 138 if (FD->getNumParams()) { 139 const FunctionTypeProto* FProto = FD->getType()->getAsFunctionTypeProto(); 140 assert(FProto && "Function def must have prototype!"); 141 142 for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) 143 Args.push_back(std::make_pair(FD->getParamDecl(i), 144 FProto->getArgType(i))); 145 } 146 147 StartFunction(FD, FD->getResultType(), Fn, Args, 148 cast<CompoundStmt>(FD->getBody())->getLBracLoc()); 149 150 EmitStmt(FD->getBody()); 151 152 const CompoundStmt *S = dyn_cast<CompoundStmt>(FD->getBody()); 153 if (S) { 154 FinishFunction(S->getRBracLoc()); 155 } else { 156 FinishFunction(); 157 } 158 } 159 160 /// ContainsLabel - Return true if the statement contains a label in it. If 161 /// this statement is not executed normally, it not containing a label means 162 /// that we can just remove the code. 163 bool CodeGenFunction::ContainsLabel(const Stmt *S, bool IgnoreCaseStmts) { 164 // Null statement, not a label! 165 if (S == 0) return false; 166 167 // If this is a label, we have to emit the code, consider something like: 168 // if (0) { ... foo: bar(); } goto foo; 169 if (isa<LabelStmt>(S)) 170 return true; 171 172 // If this is a case/default statement, and we haven't seen a switch, we have 173 // to emit the code. 174 if (isa<SwitchCase>(S) && !IgnoreCaseStmts) 175 return true; 176 177 // If this is a switch statement, we want to ignore cases below it. 178 if (isa<SwitchStmt>(S)) 179 IgnoreCaseStmts = true; 180 181 // Scan subexpressions for verboten labels. 182 for (Stmt::const_child_iterator I = S->child_begin(), E = S->child_end(); 183 I != E; ++I) 184 if (ContainsLabel(*I, IgnoreCaseStmts)) 185 return true; 186 187 return false; 188 } 189 190 191 /// ConstantFoldsToSimpleInteger - If the sepcified expression does not fold to 192 /// a constant, or if it does but contains a label, return 0. If it constant 193 /// folds to 'true' and does not contain a label, return 1, if it constant folds 194 /// to 'false' and does not contain a label, return -1. 195 int CodeGenFunction::ConstantFoldsToSimpleInteger(const Expr *Cond) { 196 APValue V; 197 if (!Cond->tryEvaluate(V, getContext())) 198 return 0; // Not foldable. 199 200 if (CodeGenFunction::ContainsLabel(Cond)) 201 return 0; // Contains a label. 202 203 return V.getInt().getBoolValue() ? 1 : -1; 204 } 205 206 207 /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an if 208 /// statement) to the specified blocks. Based on the condition, this might try 209 /// to simplify the codegen of the conditional based on the branch. 210 /// 211 void CodeGenFunction::EmitBranchOnBoolExpr(const Expr *Cond, 212 llvm::BasicBlock *TrueBlock, 213 llvm::BasicBlock *FalseBlock) { 214 if (const ParenExpr *PE = dyn_cast<ParenExpr>(Cond)) 215 return EmitBranchOnBoolExpr(PE->getSubExpr(), TrueBlock, FalseBlock); 216 217 if (const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) { 218 // Handle X && Y in a condition. 219 if (CondBOp->getOpcode() == BinaryOperator::LAnd) { 220 // If we have "1 && X", simplify the code. "0 && X" would have constant 221 // folded if the case was simple enough. 222 if (ConstantFoldsToSimpleInteger(CondBOp->getLHS()) == 1) { 223 // br(1 && X) -> br(X). 224 return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 225 } 226 227 // If we have "X && 1", simplify the code to use an uncond branch. 228 // "X && 0" would have been constant folded to 0. 229 if (ConstantFoldsToSimpleInteger(CondBOp->getRHS()) == 1) { 230 // br(X && 1) -> br(X). 231 return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock); 232 } 233 234 // Emit the LHS as a conditional. If the LHS conditional is false, we 235 // want to jump to the FalseBlock. 236 llvm::BasicBlock *LHSTrue = createBasicBlock("land_lhs_true"); 237 EmitBranchOnBoolExpr(CondBOp->getLHS(), LHSTrue, FalseBlock); 238 EmitBlock(LHSTrue); 239 240 EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 241 return; 242 } else if (CondBOp->getOpcode() == BinaryOperator::LOr) { 243 // If we have "0 || X", simplify the code. "1 || X" would have constant 244 // folded if the case was simple enough. 245 if (ConstantFoldsToSimpleInteger(CondBOp->getLHS()) == -1) { 246 // br(0 || X) -> br(X). 247 return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 248 } 249 250 // If we have "X || 0", simplify the code to use an uncond branch. 251 // "X || 1" would have been constant folded to 1. 252 if (ConstantFoldsToSimpleInteger(CondBOp->getRHS()) == -1) { 253 // br(X || 0) -> br(X). 254 return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock); 255 } 256 257 // Emit the LHS as a conditional. If the LHS conditional is true, we 258 // want to jump to the TrueBlock. 259 llvm::BasicBlock *LHSFalse = createBasicBlock("lor_lhs_false"); 260 EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, LHSFalse); 261 EmitBlock(LHSFalse); 262 263 EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 264 return; 265 } 266 } 267 268 if (const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(Cond)) { 269 // br(!x, t, f) -> br(x, f, t) 270 if (CondUOp->getOpcode() == UnaryOperator::LNot) 271 return EmitBranchOnBoolExpr(CondUOp->getSubExpr(), FalseBlock, TrueBlock); 272 } 273 274 // Emit the code with the fully general case. 275 llvm::Value *CondV = EvaluateExprAsBool(Cond); 276 Builder.CreateCondBr(CondV, TrueBlock, FalseBlock); 277 } 278 279 /// getCGRecordLayout - Return record layout info. 280 const CGRecordLayout *CodeGenFunction::getCGRecordLayout(CodeGenTypes &CGT, 281 QualType Ty) { 282 const RecordType *RTy = Ty->getAsRecordType(); 283 assert (RTy && "Unexpected type. RecordType expected here."); 284 285 return CGT.getCGRecordLayout(RTy->getDecl()); 286 } 287 288 /// ErrorUnsupported - Print out an error that codegen doesn't support the 289 /// specified stmt yet. 290 void CodeGenFunction::ErrorUnsupported(const Stmt *S, const char *Type, 291 bool OmitOnError) { 292 CGM.ErrorUnsupported(S, Type, OmitOnError); 293 } 294 295 unsigned CodeGenFunction::GetIDForAddrOfLabel(const LabelStmt *L) { 296 // Use LabelIDs.size() as the new ID if one hasn't been assigned. 297 return LabelIDs.insert(std::make_pair(L, LabelIDs.size())).first->second; 298 } 299 300 void CodeGenFunction::EmitMemSetToZero(llvm::Value *DestPtr, QualType Ty) 301 { 302 const llvm::Type *BP = llvm::PointerType::getUnqual(llvm::Type::Int8Ty); 303 if (DestPtr->getType() != BP) 304 DestPtr = Builder.CreateBitCast(DestPtr, BP, "tmp"); 305 306 // Get size and alignment info for this aggregate. 307 std::pair<uint64_t, unsigned> TypeInfo = getContext().getTypeInfo(Ty); 308 309 // FIXME: Handle variable sized types. 310 const llvm::Type *IntPtr = llvm::IntegerType::get(LLVMPointerWidth); 311 312 Builder.CreateCall4(CGM.getMemSetFn(), DestPtr, 313 llvm::ConstantInt::getNullValue(llvm::Type::Int8Ty), 314 // TypeInfo.first describes size in bits. 315 llvm::ConstantInt::get(IntPtr, TypeInfo.first/8), 316 llvm::ConstantInt::get(llvm::Type::Int32Ty, 317 TypeInfo.second/8)); 318 } 319 320 void CodeGenFunction::EmitIndirectSwitches() { 321 llvm::BasicBlock *Default; 322 323 if (IndirectSwitches.empty()) 324 return; 325 326 if (!LabelIDs.empty()) { 327 Default = getBasicBlockForLabel(LabelIDs.begin()->first); 328 } else { 329 // No possible targets for indirect goto, just emit an infinite 330 // loop. 331 Default = createBasicBlock("indirectgoto.loop", CurFn); 332 llvm::BranchInst::Create(Default, Default); 333 } 334 335 for (std::vector<llvm::SwitchInst*>::iterator i = IndirectSwitches.begin(), 336 e = IndirectSwitches.end(); i != e; ++i) { 337 llvm::SwitchInst *I = *i; 338 339 I->setSuccessor(0, Default); 340 for (std::map<const LabelStmt*,unsigned>::iterator LI = LabelIDs.begin(), 341 LE = LabelIDs.end(); LI != LE; ++LI) { 342 I->addCase(llvm::ConstantInt::get(llvm::Type::Int32Ty, 343 LI->second), 344 getBasicBlockForLabel(LI->first)); 345 } 346 } 347 } 348 349 llvm::Value *CodeGenFunction::EmitVAArg(llvm::Value *VAListAddr, QualType Ty) 350 { 351 // FIXME: This entire method is hardcoded for 32-bit X86. 352 353 const char *TargetPrefix = getContext().Target.getTargetPrefix(); 354 355 if (strcmp(TargetPrefix, "x86") != 0 || 356 getContext().Target.getPointerWidth(0) != 32) 357 return 0; 358 359 const llvm::Type *BP = llvm::PointerType::getUnqual(llvm::Type::Int8Ty); 360 const llvm::Type *BPP = llvm::PointerType::getUnqual(BP); 361 362 llvm::Value *VAListAddrAsBPP = Builder.CreateBitCast(VAListAddr, BPP, 363 "ap"); 364 llvm::Value *Addr = Builder.CreateLoad(VAListAddrAsBPP, "ap.cur"); 365 llvm::Value *AddrTyped = 366 Builder.CreateBitCast(Addr, 367 llvm::PointerType::getUnqual(ConvertType(Ty))); 368 369 uint64_t SizeInBytes = getContext().getTypeSize(Ty) / 8; 370 const unsigned ArgumentSizeInBytes = 4; 371 if (SizeInBytes < ArgumentSizeInBytes) 372 SizeInBytes = ArgumentSizeInBytes; 373 374 llvm::Value *NextAddr = 375 Builder.CreateGEP(Addr, 376 llvm::ConstantInt::get(llvm::Type::Int32Ty, SizeInBytes), 377 "ap.next"); 378 Builder.CreateStore(NextAddr, VAListAddrAsBPP); 379 380 return AddrTyped; 381 } 382 383