CodeGenFunction.h revision 193576
1//===-- CodeGenFunction.h - Per-Function state for LLVM CodeGen -*- C++ -*-===// 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 is the internal per-function state used for llvm translation. 11// 12//===----------------------------------------------------------------------===// 13 14#ifndef CLANG_CODEGEN_CODEGENFUNCTION_H 15#define CLANG_CODEGEN_CODEGENFUNCTION_H 16 17#include "clang/AST/Type.h" 18#include "clang/AST/ExprCXX.h" 19#include "clang/AST/ExprObjC.h" 20#include "clang/Basic/TargetInfo.h" 21#include "llvm/ADT/DenseMap.h" 22#include "llvm/ADT/SmallVector.h" 23#include "llvm/Support/ValueHandle.h" 24#include <map> 25#include "CGBlocks.h" 26#include "CGBuilder.h" 27#include "CGCall.h" 28#include "CGCXX.h" 29#include "CGValue.h" 30 31namespace llvm { 32 class BasicBlock; 33 class Module; 34 class SwitchInst; 35 class Value; 36} 37 38namespace clang { 39 class ASTContext; 40 class CXXDestructorDecl; 41 class Decl; 42 class EnumConstantDecl; 43 class FunctionDecl; 44 class FunctionProtoType; 45 class LabelStmt; 46 class ObjCContainerDecl; 47 class ObjCInterfaceDecl; 48 class ObjCIvarDecl; 49 class ObjCMethodDecl; 50 class ObjCImplementationDecl; 51 class ObjCPropertyImplDecl; 52 class TargetInfo; 53 class VarDecl; 54 class ObjCForCollectionStmt; 55 class ObjCAtTryStmt; 56 class ObjCAtThrowStmt; 57 class ObjCAtSynchronizedStmt; 58 59namespace CodeGen { 60 class CodeGenModule; 61 class CodeGenTypes; 62 class CGDebugInfo; 63 class CGFunctionInfo; 64 class CGRecordLayout; 65 66/// CodeGenFunction - This class organizes the per-function state that is used 67/// while generating LLVM code. 68class CodeGenFunction : public BlockFunction { 69 CodeGenFunction(const CodeGenFunction&); // DO NOT IMPLEMENT 70 void operator=(const CodeGenFunction&); // DO NOT IMPLEMENT 71public: 72 CodeGenModule &CGM; // Per-module state. 73 TargetInfo &Target; 74 75 typedef std::pair<llvm::Value *, llvm::Value *> ComplexPairTy; 76 CGBuilderTy Builder; 77 78 /// CurFuncDecl - Holds the Decl for the current function or ObjC method. 79 /// This excludes BlockDecls. 80 const Decl *CurFuncDecl; 81 /// CurCodeDecl - This is the inner-most code context, which includes blocks. 82 const Decl *CurCodeDecl; 83 const CGFunctionInfo *CurFnInfo; 84 QualType FnRetTy; 85 llvm::Function *CurFn; 86 87 /// ReturnBlock - Unified return block. 88 llvm::BasicBlock *ReturnBlock; 89 /// ReturnValue - The temporary alloca to hold the return value. This is null 90 /// iff the function has no return value. 91 llvm::Instruction *ReturnValue; 92 93 /// AllocaInsertPoint - This is an instruction in the entry block before which 94 /// we prefer to insert allocas. 95 llvm::AssertingVH<llvm::Instruction> AllocaInsertPt; 96 97 const llvm::Type *LLVMIntTy; 98 uint32_t LLVMPointerWidth; 99 100public: 101 /// ObjCEHValueStack - Stack of Objective-C exception values, used for 102 /// rethrows. 103 llvm::SmallVector<llvm::Value*, 8> ObjCEHValueStack; 104 105 /// PushCleanupBlock - Push a new cleanup entry on the stack and set the 106 /// passed in block as the cleanup block. 107 void PushCleanupBlock(llvm::BasicBlock *CleanupBlock); 108 109 /// CleanupBlockInfo - A struct representing a popped cleanup block. 110 struct CleanupBlockInfo { 111 /// CleanupBlock - the cleanup block 112 llvm::BasicBlock *CleanupBlock; 113 114 /// SwitchBlock - the block (if any) containing the switch instruction used 115 /// for jumping to the final destination. 116 llvm::BasicBlock *SwitchBlock; 117 118 /// EndBlock - the default destination for the switch instruction. 119 llvm::BasicBlock *EndBlock; 120 121 CleanupBlockInfo(llvm::BasicBlock *cb, llvm::BasicBlock *sb, 122 llvm::BasicBlock *eb) 123 : CleanupBlock(cb), SwitchBlock(sb), EndBlock(eb) {} 124 }; 125 126 /// PopCleanupBlock - Will pop the cleanup entry on the stack, process all 127 /// branch fixups and return a block info struct with the switch block and end 128 /// block. 129 CleanupBlockInfo PopCleanupBlock(); 130 131 /// CleanupScope - RAII object that will create a cleanup block and set the 132 /// insert point to that block. When destructed, it sets the insert point to 133 /// the previous block and pushes a new cleanup entry on the stack. 134 class CleanupScope { 135 CodeGenFunction& CGF; 136 llvm::BasicBlock *CurBB; 137 llvm::BasicBlock *CleanupBB; 138 139 public: 140 CleanupScope(CodeGenFunction &cgf) 141 : CGF(cgf), CurBB(CGF.Builder.GetInsertBlock()) { 142 CleanupBB = CGF.createBasicBlock("cleanup"); 143 CGF.Builder.SetInsertPoint(CleanupBB); 144 } 145 146 ~CleanupScope() { 147 CGF.PushCleanupBlock(CleanupBB); 148 CGF.Builder.SetInsertPoint(CurBB); 149 } 150 }; 151 152 /// EmitCleanupBlocks - Takes the old cleanup stack size and emits the cleanup 153 /// blocks that have been added. 154 void EmitCleanupBlocks(size_t OldCleanupStackSize); 155 156 /// EmitBranchThroughCleanup - Emit a branch from the current insert block 157 /// through the cleanup handling code (if any) and then on to \arg Dest. 158 /// 159 /// FIXME: Maybe this should really be in EmitBranch? Don't we always want 160 /// this behavior for branches? 161 void EmitBranchThroughCleanup(llvm::BasicBlock *Dest); 162 163 /// PushConditionalTempDestruction - Should be called before a conditional 164 /// part of an expression is emitted. For example, before the RHS of the 165 /// expression below is emitted: 166 /// 167 /// b && f(T()); 168 /// 169 /// This is used to make sure that any temporaryes created in the conditional 170 /// branch are only destroyed if the branch is taken. 171 void PushConditionalTempDestruction(); 172 173 /// PopConditionalTempDestruction - Should be called after a conditional 174 /// part of an expression has been emitted. 175 void PopConditionalTempDestruction(); 176 177private: 178 CGDebugInfo* DebugInfo; 179 180 /// LabelIDs - Track arbitrary ids assigned to labels for use in implementing 181 /// the GCC address-of-label extension and indirect goto. IDs are assigned to 182 /// labels inside getIDForAddrOfLabel(). 183 std::map<const LabelStmt*, unsigned> LabelIDs; 184 185 /// IndirectSwitches - Record the list of switches for indirect 186 /// gotos. Emission of the actual switching code needs to be delayed until all 187 /// AddrLabelExprs have been seen. 188 std::vector<llvm::SwitchInst*> IndirectSwitches; 189 190 /// LocalDeclMap - This keeps track of the LLVM allocas or globals for local C 191 /// decls. 192 llvm::DenseMap<const Decl*, llvm::Value*> LocalDeclMap; 193 194 /// LabelMap - This keeps track of the LLVM basic block for each C label. 195 llvm::DenseMap<const LabelStmt*, llvm::BasicBlock*> LabelMap; 196 197 // BreakContinueStack - This keeps track of where break and continue 198 // statements should jump to. 199 struct BreakContinue { 200 BreakContinue(llvm::BasicBlock *bb, llvm::BasicBlock *cb) 201 : BreakBlock(bb), ContinueBlock(cb) {} 202 203 llvm::BasicBlock *BreakBlock; 204 llvm::BasicBlock *ContinueBlock; 205 }; 206 llvm::SmallVector<BreakContinue, 8> BreakContinueStack; 207 208 /// SwitchInsn - This is nearest current switch instruction. It is null if if 209 /// current context is not in a switch. 210 llvm::SwitchInst *SwitchInsn; 211 212 /// CaseRangeBlock - This block holds if condition check for last case 213 /// statement range in current switch instruction. 214 llvm::BasicBlock *CaseRangeBlock; 215 216 /// InvokeDest - This is the nearest exception target for calls 217 /// which can unwind, when exceptions are being used. 218 llvm::BasicBlock *InvokeDest; 219 220 // VLASizeMap - This keeps track of the associated size for each VLA type. 221 // FIXME: Maybe this could be a stack of maps that is pushed/popped as we 222 // enter/leave scopes. 223 llvm::DenseMap<const VariableArrayType*, llvm::Value*> VLASizeMap; 224 225 /// DidCallStackSave - Whether llvm.stacksave has been called. Used to avoid 226 /// calling llvm.stacksave for multiple VLAs in the same scope. 227 bool DidCallStackSave; 228 229 struct CleanupEntry { 230 /// CleanupBlock - The block of code that does the actual cleanup. 231 llvm::BasicBlock *CleanupBlock; 232 233 /// Blocks - Basic blocks that were emitted in the current cleanup scope. 234 std::vector<llvm::BasicBlock *> Blocks; 235 236 /// BranchFixups - Branch instructions to basic blocks that haven't been 237 /// inserted into the current function yet. 238 std::vector<llvm::BranchInst *> BranchFixups; 239 240 explicit CleanupEntry(llvm::BasicBlock *cb) 241 : CleanupBlock(cb) {} 242 }; 243 244 /// CleanupEntries - Stack of cleanup entries. 245 llvm::SmallVector<CleanupEntry, 8> CleanupEntries; 246 247 typedef llvm::DenseMap<llvm::BasicBlock*, size_t> BlockScopeMap; 248 249 /// BlockScopes - Map of which "cleanup scope" scope basic blocks have. 250 BlockScopeMap BlockScopes; 251 252 /// CXXThisDecl - When parsing an C++ function, this will hold the implicit 253 /// 'this' declaration. 254 ImplicitParamDecl *CXXThisDecl; 255 256 /// CXXLiveTemporaryInfo - Holds information about a live C++ temporary. 257 struct CXXLiveTemporaryInfo { 258 /// Temporary - The live temporary. 259 const CXXTemporary *Temporary; 260 261 /// ThisPtr - The pointer to the temporary. 262 llvm::Value *ThisPtr; 263 264 /// DtorBlock - The destructor block. 265 llvm::BasicBlock *DtorBlock; 266 267 /// CondPtr - If this is a conditional temporary, this is the pointer to 268 /// the condition variable that states whether the destructor should be 269 /// called or not. 270 llvm::Value *CondPtr; 271 272 CXXLiveTemporaryInfo(const CXXTemporary *temporary, 273 llvm::Value *thisptr, llvm::BasicBlock *dtorblock, 274 llvm::Value *condptr) 275 : Temporary(temporary), ThisPtr(thisptr), DtorBlock(dtorblock), 276 CondPtr(condptr) { } 277 }; 278 279 llvm::SmallVector<CXXLiveTemporaryInfo, 4> LiveTemporaries; 280 281 /// ConditionalTempDestructionStack - Contains the number of live temporaries 282 /// when PushConditionalTempDestruction was called. This is used so that 283 /// we know how many temporaries were created by a certain expression. 284 llvm::SmallVector<size_t, 4> ConditionalTempDestructionStack; 285 286public: 287 CodeGenFunction(CodeGenModule &cgm); 288 289 ASTContext &getContext() const; 290 CGDebugInfo *getDebugInfo() { return DebugInfo; } 291 292 llvm::BasicBlock *getInvokeDest() { return InvokeDest; } 293 void setInvokeDest(llvm::BasicBlock *B) { InvokeDest = B; } 294 295 //===--------------------------------------------------------------------===// 296 // Objective-C 297 //===--------------------------------------------------------------------===// 298 299 void GenerateObjCMethod(const ObjCMethodDecl *OMD); 300 301 void StartObjCMethod(const ObjCMethodDecl *MD, 302 const ObjCContainerDecl *CD); 303 304 /// GenerateObjCGetter - Synthesize an Objective-C property getter function. 305 void GenerateObjCGetter(ObjCImplementationDecl *IMP, 306 const ObjCPropertyImplDecl *PID); 307 308 /// GenerateObjCSetter - Synthesize an Objective-C property setter function 309 /// for the given property. 310 void GenerateObjCSetter(ObjCImplementationDecl *IMP, 311 const ObjCPropertyImplDecl *PID); 312 313 //===--------------------------------------------------------------------===// 314 // Block Bits 315 //===--------------------------------------------------------------------===// 316 317 llvm::Value *BuildBlockLiteralTmp(const BlockExpr *); 318 llvm::Constant *BuildDescriptorBlockDecl(bool BlockHasCopyDispose, 319 uint64_t Size, 320 const llvm::StructType *, 321 std::vector<HelperInfo> *); 322 323 llvm::Function *GenerateBlockFunction(const BlockExpr *BExpr, 324 const BlockInfo& Info, 325 const Decl *OuterFuncDecl, 326 llvm::DenseMap<const Decl*, llvm::Value*> ldm, 327 uint64_t &Size, uint64_t &Align, 328 llvm::SmallVector<const Expr *, 8> &subBlockDeclRefDecls, 329 bool &subBlockHasCopyDispose); 330 331 void BlockForwardSelf(); 332 llvm::Value *LoadBlockStruct(); 333 334 llvm::Value *GetAddrOfBlockDecl(const BlockDeclRefExpr *E); 335 336 const llvm::Type *BuildByRefType(QualType Ty, uint64_t Align); 337 338 void GenerateCode(const FunctionDecl *FD, 339 llvm::Function *Fn); 340 void StartFunction(const Decl *D, QualType RetTy, 341 llvm::Function *Fn, 342 const FunctionArgList &Args, 343 SourceLocation StartLoc); 344 345 /// EmitReturnBlock - Emit the unified return block, trying to avoid its 346 /// emission when possible. 347 void EmitReturnBlock(); 348 349 /// FinishFunction - Complete IR generation of the current function. It is 350 /// legal to call this function even if there is no current insertion point. 351 void FinishFunction(SourceLocation EndLoc=SourceLocation()); 352 353 /// EmitFunctionProlog - Emit the target specific LLVM code to load the 354 /// arguments for the given function. This is also responsible for naming the 355 /// LLVM function arguments. 356 void EmitFunctionProlog(const CGFunctionInfo &FI, 357 llvm::Function *Fn, 358 const FunctionArgList &Args); 359 360 /// EmitFunctionEpilog - Emit the target specific LLVM code to return the 361 /// given temporary. 362 void EmitFunctionEpilog(const CGFunctionInfo &FI, llvm::Value *ReturnValue); 363 364 const llvm::Type *ConvertTypeForMem(QualType T); 365 const llvm::Type *ConvertType(QualType T); 366 367 /// LoadObjCSelf - Load the value of self. This function is only valid while 368 /// generating code for an Objective-C method. 369 llvm::Value *LoadObjCSelf(); 370 371 /// TypeOfSelfObject - Return type of object that this self represents. 372 QualType TypeOfSelfObject(); 373 374 /// hasAggregateLLVMType - Return true if the specified AST type will map into 375 /// an aggregate LLVM type or is void. 376 static bool hasAggregateLLVMType(QualType T); 377 378 /// createBasicBlock - Create an LLVM basic block. 379 llvm::BasicBlock *createBasicBlock(const char *Name="", 380 llvm::Function *Parent=0, 381 llvm::BasicBlock *InsertBefore=0) { 382#ifdef NDEBUG 383 return llvm::BasicBlock::Create("", Parent, InsertBefore); 384#else 385 return llvm::BasicBlock::Create(Name, Parent, InsertBefore); 386#endif 387 } 388 389 /// getBasicBlockForLabel - Return the LLVM basicblock that the specified 390 /// label maps to. 391 llvm::BasicBlock *getBasicBlockForLabel(const LabelStmt *S); 392 393 /// SimplifyForwardingBlocks - If the given basic block is only a 394 /// branch to another basic block, simplify it. This assumes that no 395 /// other code could potentially reference the basic block. 396 void SimplifyForwardingBlocks(llvm::BasicBlock *BB); 397 398 /// EmitBlock - Emit the given block \arg BB and set it as the insert point, 399 /// adding a fall-through branch from the current insert block if 400 /// necessary. It is legal to call this function even if there is no current 401 /// insertion point. 402 /// 403 /// IsFinished - If true, indicates that the caller has finished emitting 404 /// branches to the given block and does not expect to emit code into it. This 405 /// means the block can be ignored if it is unreachable. 406 void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false); 407 408 /// EmitBranch - Emit a branch to the specified basic block from the current 409 /// insert block, taking care to avoid creation of branches from dummy 410 /// blocks. It is legal to call this function even if there is no current 411 /// insertion point. 412 /// 413 /// This function clears the current insertion point. The caller should follow 414 /// calls to this function with calls to Emit*Block prior to generation new 415 /// code. 416 void EmitBranch(llvm::BasicBlock *Block); 417 418 /// HaveInsertPoint - True if an insertion point is defined. If not, this 419 /// indicates that the current code being emitted is unreachable. 420 bool HaveInsertPoint() const { 421 return Builder.GetInsertBlock() != 0; 422 } 423 424 /// EnsureInsertPoint - Ensure that an insertion point is defined so that 425 /// emitted IR has a place to go. Note that by definition, if this function 426 /// creates a block then that block is unreachable; callers may do better to 427 /// detect when no insertion point is defined and simply skip IR generation. 428 void EnsureInsertPoint() { 429 if (!HaveInsertPoint()) 430 EmitBlock(createBasicBlock()); 431 } 432 433 /// ErrorUnsupported - Print out an error that codegen doesn't support the 434 /// specified stmt yet. 435 void ErrorUnsupported(const Stmt *S, const char *Type, 436 bool OmitOnError=false); 437 438 //===--------------------------------------------------------------------===// 439 // Helpers 440 //===--------------------------------------------------------------------===// 441 442 /// CreateTempAlloca - This creates a alloca and inserts it into the entry 443 /// block. 444 llvm::AllocaInst *CreateTempAlloca(const llvm::Type *Ty, 445 const char *Name = "tmp"); 446 447 /// EvaluateExprAsBool - Perform the usual unary conversions on the specified 448 /// expression and compare the result against zero, returning an Int1Ty value. 449 llvm::Value *EvaluateExprAsBool(const Expr *E); 450 451 /// EmitAnyExpr - Emit code to compute the specified expression which can have 452 /// any type. The result is returned as an RValue struct. If this is an 453 /// aggregate expression, the aggloc/agglocvolatile arguments indicate where 454 /// the result should be returned. 455 /// 456 /// \param IgnoreResult - True if the resulting value isn't used. 457 RValue EmitAnyExpr(const Expr *E, llvm::Value *AggLoc = 0, 458 bool isAggLocVolatile = false, bool IgnoreResult = false); 459 460 // EmitVAListRef - Emit a "reference" to a va_list; this is either the address 461 // or the value of the expression, depending on how va_list is defined. 462 llvm::Value *EmitVAListRef(const Expr *E); 463 464 /// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result will 465 /// always be accessible even if no aggregate location is provided. 466 RValue EmitAnyExprToTemp(const Expr *E, llvm::Value *AggLoc = 0, 467 bool isAggLocVolatile = false); 468 469 /// EmitAggregateCopy - Emit an aggrate copy. 470 /// 471 /// \param isVolatile - True iff either the source or the destination is 472 /// volatile. 473 void EmitAggregateCopy(llvm::Value *DestPtr, llvm::Value *SrcPtr, 474 QualType EltTy, bool isVolatile=false); 475 476 void EmitAggregateClear(llvm::Value *DestPtr, QualType Ty); 477 478 /// StartBlock - Start new block named N. If insert block is a dummy block 479 /// then reuse it. 480 void StartBlock(const char *N); 481 482 /// getCGRecordLayout - Return record layout info. 483 const CGRecordLayout *getCGRecordLayout(CodeGenTypes &CGT, QualType RTy); 484 485 /// GetAddrOfStaticLocalVar - Return the address of a static local variable. 486 llvm::Constant *GetAddrOfStaticLocalVar(const VarDecl *BVD); 487 488 /// GetAddrOfLocalVar - Return the address of a local variable. 489 llvm::Value *GetAddrOfLocalVar(const VarDecl *VD); 490 491 /// getAccessedFieldNo - Given an encoded value and a result number, return 492 /// the input field number being accessed. 493 static unsigned getAccessedFieldNo(unsigned Idx, const llvm::Constant *Elts); 494 495 unsigned GetIDForAddrOfLabel(const LabelStmt *L); 496 497 /// EmitMemSetToZero - Generate code to memset a value of the given type to 0. 498 void EmitMemSetToZero(llvm::Value *DestPtr, QualType Ty); 499 500 // EmitVAArg - Generate code to get an argument from the passed in pointer 501 // and update it accordingly. The return value is a pointer to the argument. 502 // FIXME: We should be able to get rid of this method and use the va_arg 503 // instruction in LLVM instead once it works well enough. 504 llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty); 505 506 // EmitVLASize - Generate code for any VLA size expressions that might occur 507 // in a variably modified type. If Ty is a VLA, will return the value that 508 // corresponds to the size in bytes of the VLA type. Will return 0 otherwise. 509 llvm::Value *EmitVLASize(QualType Ty); 510 511 // GetVLASize - Returns an LLVM value that corresponds to the size in bytes 512 // of a variable length array type. 513 llvm::Value *GetVLASize(const VariableArrayType *); 514 515 /// LoadCXXThis - Load the value of 'this'. This function is only valid while 516 /// generating code for an C++ member function. 517 llvm::Value *LoadCXXThis(); 518 519 void EmitCXXConstructorCall(const CXXConstructorDecl *D, CXXCtorType Type, 520 llvm::Value *This, 521 CallExpr::const_arg_iterator ArgBeg, 522 CallExpr::const_arg_iterator ArgEnd); 523 524 void EmitCXXDestructorCall(const CXXDestructorDecl *D, CXXDtorType Type, 525 llvm::Value *This); 526 527 void PushCXXTemporary(const CXXTemporary *Temporary, llvm::Value *Ptr); 528 void PopCXXTemporary(); 529 530 llvm::Value *EmitCXXNewExpr(const CXXNewExpr *E); 531 532 //===--------------------------------------------------------------------===// 533 // Declaration Emission 534 //===--------------------------------------------------------------------===// 535 536 void EmitDecl(const Decl &D); 537 void EmitBlockVarDecl(const VarDecl &D); 538 void EmitLocalBlockVarDecl(const VarDecl &D); 539 void EmitStaticBlockVarDecl(const VarDecl &D); 540 541 /// EmitParmDecl - Emit a ParmVarDecl or an ImplicitParamDecl. 542 void EmitParmDecl(const VarDecl &D, llvm::Value *Arg); 543 544 //===--------------------------------------------------------------------===// 545 // Statement Emission 546 //===--------------------------------------------------------------------===// 547 548 /// EmitStopPoint - Emit a debug stoppoint if we are emitting debug info. 549 void EmitStopPoint(const Stmt *S); 550 551 /// EmitStmt - Emit the code for the statement \arg S. It is legal to call 552 /// this function even if there is no current insertion point. 553 /// 554 /// This function may clear the current insertion point; callers should use 555 /// EnsureInsertPoint if they wish to subsequently generate code without first 556 /// calling EmitBlock, EmitBranch, or EmitStmt. 557 void EmitStmt(const Stmt *S); 558 559 /// EmitSimpleStmt - Try to emit a "simple" statement which does not 560 /// necessarily require an insertion point or debug information; typically 561 /// because the statement amounts to a jump or a container of other 562 /// statements. 563 /// 564 /// \return True if the statement was handled. 565 bool EmitSimpleStmt(const Stmt *S); 566 567 RValue EmitCompoundStmt(const CompoundStmt &S, bool GetLast = false, 568 llvm::Value *AggLoc = 0, bool isAggVol = false); 569 570 /// EmitLabel - Emit the block for the given label. It is legal to call this 571 /// function even if there is no current insertion point. 572 void EmitLabel(const LabelStmt &S); // helper for EmitLabelStmt. 573 574 void EmitLabelStmt(const LabelStmt &S); 575 void EmitGotoStmt(const GotoStmt &S); 576 void EmitIndirectGotoStmt(const IndirectGotoStmt &S); 577 void EmitIfStmt(const IfStmt &S); 578 void EmitWhileStmt(const WhileStmt &S); 579 void EmitDoStmt(const DoStmt &S); 580 void EmitForStmt(const ForStmt &S); 581 void EmitReturnStmt(const ReturnStmt &S); 582 void EmitDeclStmt(const DeclStmt &S); 583 void EmitBreakStmt(const BreakStmt &S); 584 void EmitContinueStmt(const ContinueStmt &S); 585 void EmitSwitchStmt(const SwitchStmt &S); 586 void EmitDefaultStmt(const DefaultStmt &S); 587 void EmitCaseStmt(const CaseStmt &S); 588 void EmitCaseStmtRange(const CaseStmt &S); 589 void EmitAsmStmt(const AsmStmt &S); 590 591 void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S); 592 void EmitObjCAtTryStmt(const ObjCAtTryStmt &S); 593 void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S); 594 void EmitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt &S); 595 596 //===--------------------------------------------------------------------===// 597 // LValue Expression Emission 598 //===--------------------------------------------------------------------===// 599 600 /// GetUndefRValue - Get an appropriate 'undef' rvalue for the given type. 601 RValue GetUndefRValue(QualType Ty); 602 603 /// EmitUnsupportedRValue - Emit a dummy r-value using the type of E 604 /// and issue an ErrorUnsupported style diagnostic (using the 605 /// provided Name). 606 RValue EmitUnsupportedRValue(const Expr *E, 607 const char *Name); 608 609 /// EmitUnsupportedLValue - Emit a dummy l-value using the type of E and issue 610 /// an ErrorUnsupported style diagnostic (using the provided Name). 611 LValue EmitUnsupportedLValue(const Expr *E, 612 const char *Name); 613 614 /// EmitLValue - Emit code to compute a designator that specifies the location 615 /// of the expression. 616 /// 617 /// This can return one of two things: a simple address or a bitfield 618 /// reference. In either case, the LLVM Value* in the LValue structure is 619 /// guaranteed to be an LLVM pointer type. 620 /// 621 /// If this returns a bitfield reference, nothing about the pointee type of 622 /// the LLVM value is known: For example, it may not be a pointer to an 623 /// integer. 624 /// 625 /// If this returns a normal address, and if the lvalue's C type is fixed 626 /// size, this method guarantees that the returned pointer type will point to 627 /// an LLVM type of the same size of the lvalue's type. If the lvalue has a 628 /// variable length type, this is not possible. 629 /// 630 LValue EmitLValue(const Expr *E); 631 632 /// EmitLoadOfScalar - Load a scalar value from an address, taking 633 /// care to appropriately convert from the memory representation to 634 /// the LLVM value representation. 635 llvm::Value *EmitLoadOfScalar(llvm::Value *Addr, bool Volatile, 636 QualType Ty); 637 638 /// EmitStoreOfScalar - Store a scalar value to an address, taking 639 /// care to appropriately convert from the memory representation to 640 /// the LLVM value representation. 641 void EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr, 642 bool Volatile, QualType Ty); 643 644 /// EmitLoadOfLValue - Given an expression that represents a value lvalue, 645 /// this method emits the address of the lvalue, then loads the result as an 646 /// rvalue, returning the rvalue. 647 RValue EmitLoadOfLValue(LValue V, QualType LVType); 648 RValue EmitLoadOfExtVectorElementLValue(LValue V, QualType LVType); 649 RValue EmitLoadOfBitfieldLValue(LValue LV, QualType ExprType); 650 RValue EmitLoadOfPropertyRefLValue(LValue LV, QualType ExprType); 651 RValue EmitLoadOfKVCRefLValue(LValue LV, QualType ExprType); 652 653 654 /// EmitStoreThroughLValue - Store the specified rvalue into the specified 655 /// lvalue, where both are guaranteed to the have the same type, and that type 656 /// is 'Ty'. 657 void EmitStoreThroughLValue(RValue Src, LValue Dst, QualType Ty); 658 void EmitStoreThroughExtVectorComponentLValue(RValue Src, LValue Dst, 659 QualType Ty); 660 void EmitStoreThroughPropertyRefLValue(RValue Src, LValue Dst, QualType Ty); 661 void EmitStoreThroughKVCRefLValue(RValue Src, LValue Dst, QualType Ty); 662 663 /// EmitStoreThroughLValue - Store Src into Dst with same constraints as 664 /// EmitStoreThroughLValue. 665 /// 666 /// \param Result [out] - If non-null, this will be set to a Value* for the 667 /// bit-field contents after the store, appropriate for use as the result of 668 /// an assignment to the bit-field. 669 void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, QualType Ty, 670 llvm::Value **Result=0); 671 672 // Note: only availabe for agg return types 673 LValue EmitBinaryOperatorLValue(const BinaryOperator *E); 674 // Note: only available for agg return types 675 LValue EmitCallExprLValue(const CallExpr *E); 676 // Note: only available for agg return types 677 LValue EmitVAArgExprLValue(const VAArgExpr *E); 678 LValue EmitDeclRefLValue(const DeclRefExpr *E); 679 LValue EmitStringLiteralLValue(const StringLiteral *E); 680 LValue EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E); 681 LValue EmitPredefinedFunctionName(unsigned Type); 682 LValue EmitPredefinedLValue(const PredefinedExpr *E); 683 LValue EmitUnaryOpLValue(const UnaryOperator *E); 684 LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E); 685 LValue EmitExtVectorElementExpr(const ExtVectorElementExpr *E); 686 LValue EmitMemberExpr(const MemberExpr *E); 687 LValue EmitCompoundLiteralLValue(const CompoundLiteralExpr *E); 688 LValue EmitConditionalOperator(const ConditionalOperator *E); 689 LValue EmitCastLValue(const CastExpr *E); 690 691 llvm::Value *EmitIvarOffset(const ObjCInterfaceDecl *Interface, 692 const ObjCIvarDecl *Ivar); 693 LValue EmitLValueForField(llvm::Value* Base, FieldDecl* Field, 694 bool isUnion, unsigned CVRQualifiers); 695 LValue EmitLValueForIvar(QualType ObjectTy, 696 llvm::Value* Base, const ObjCIvarDecl *Ivar, 697 unsigned CVRQualifiers); 698 699 LValue EmitLValueForBitfield(llvm::Value* Base, FieldDecl* Field, 700 unsigned CVRQualifiers); 701 702 LValue EmitBlockDeclRefLValue(const BlockDeclRefExpr *E); 703 704 LValue EmitCXXConditionDeclLValue(const CXXConditionDeclExpr *E); 705 LValue EmitCXXConstructLValue(const CXXConstructExpr *E); 706 LValue EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E); 707 708 LValue EmitObjCMessageExprLValue(const ObjCMessageExpr *E); 709 LValue EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E); 710 LValue EmitObjCPropertyRefLValue(const ObjCPropertyRefExpr *E); 711 LValue EmitObjCKVCRefLValue(const ObjCKVCRefExpr *E); 712 LValue EmitObjCSuperExprLValue(const ObjCSuperExpr *E); 713 LValue EmitStmtExprLValue(const StmtExpr *E); 714 715 //===--------------------------------------------------------------------===// 716 // Scalar Expression Emission 717 //===--------------------------------------------------------------------===// 718 719 /// EmitCall - Generate a call of the given function, expecting the given 720 /// result type, and using the given argument list which specifies both the 721 /// LLVM arguments and the types they were derived from. 722 /// 723 /// \param TargetDecl - If given, the decl of the function in a 724 /// direct call; used to set attributes on the call (noreturn, 725 /// etc.). 726 RValue EmitCall(const CGFunctionInfo &FnInfo, 727 llvm::Value *Callee, 728 const CallArgList &Args, 729 const Decl *TargetDecl = 0); 730 731 RValue EmitCall(llvm::Value *Callee, QualType FnType, 732 CallExpr::const_arg_iterator ArgBeg, 733 CallExpr::const_arg_iterator ArgEnd, 734 const Decl *TargetDecl = 0); 735 RValue EmitCallExpr(const CallExpr *E); 736 737 RValue EmitCXXMemberCall(const CXXMethodDecl *MD, 738 llvm::Value *Callee, 739 llvm::Value *This, 740 CallExpr::const_arg_iterator ArgBeg, 741 CallExpr::const_arg_iterator ArgEnd); 742 RValue EmitCXXMemberCallExpr(const CXXMemberCallExpr *E); 743 744 RValue EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E, 745 const CXXMethodDecl *MD); 746 747 RValue EmitBuiltinExpr(const FunctionDecl *FD, 748 unsigned BuiltinID, const CallExpr *E); 749 750 RValue EmitBlockCallExpr(const CallExpr *E); 751 752 /// EmitTargetBuiltinExpr - Emit the given builtin call. Returns 0 if the call 753 /// is unhandled by the current target. 754 llvm::Value *EmitTargetBuiltinExpr(unsigned BuiltinID, const CallExpr *E); 755 756 llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E); 757 llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E); 758 759 llvm::Value *EmitShuffleVector(llvm::Value* V1, llvm::Value *V2, ...); 760 llvm::Value *EmitVector(llvm::Value * const *Vals, unsigned NumVals, 761 bool isSplat = false); 762 763 llvm::Value *EmitObjCProtocolExpr(const ObjCProtocolExpr *E); 764 llvm::Value *EmitObjCStringLiteral(const ObjCStringLiteral *E); 765 llvm::Value *EmitObjCSelectorExpr(const ObjCSelectorExpr *E); 766 RValue EmitObjCMessageExpr(const ObjCMessageExpr *E); 767 RValue EmitObjCPropertyGet(const Expr *E); 768 RValue EmitObjCSuperPropertyGet(const Expr *Exp, const Selector &S); 769 void EmitObjCPropertySet(const Expr *E, RValue Src); 770 void EmitObjCSuperPropertySet(const Expr *E, const Selector &S, RValue Src); 771 772 773 /// EmitReferenceBindingToExpr - Emits a reference binding to the passed in 774 /// expression. Will emit a temporary variable if E is not an LValue. 775 RValue EmitReferenceBindingToExpr(const Expr* E, QualType DestType); 776 777 //===--------------------------------------------------------------------===// 778 // Expression Emission 779 //===--------------------------------------------------------------------===// 780 781 // Expressions are broken into three classes: scalar, complex, aggregate. 782 783 /// EmitScalarExpr - Emit the computation of the specified expression of LLVM 784 /// scalar type, returning the result. 785 llvm::Value *EmitScalarExpr(const Expr *E , bool IgnoreResultAssign=false); 786 787 /// EmitScalarConversion - Emit a conversion from the specified type to the 788 /// specified destination type, both of which are LLVM scalar types. 789 llvm::Value *EmitScalarConversion(llvm::Value *Src, QualType SrcTy, 790 QualType DstTy); 791 792 /// EmitComplexToScalarConversion - Emit a conversion from the specified 793 /// complex type to the specified destination type, where the destination type 794 /// is an LLVM scalar type. 795 llvm::Value *EmitComplexToScalarConversion(ComplexPairTy Src, QualType SrcTy, 796 QualType DstTy); 797 798 799 /// EmitAggExpr - Emit the computation of the specified expression of 800 /// aggregate type. The result is computed into DestPtr. Note that if 801 /// DestPtr is null, the value of the aggregate expression is not needed. 802 void EmitAggExpr(const Expr *E, llvm::Value *DestPtr, bool VolatileDest, 803 bool IgnoreResult = false); 804 805 /// EmitComplexExpr - Emit the computation of the specified expression of 806 /// complex type, returning the result. 807 ComplexPairTy EmitComplexExpr(const Expr *E, bool IgnoreReal = false, 808 bool IgnoreImag = false, 809 bool IgnoreRealAssign = false, 810 bool IgnoreImagAssign = false); 811 812 /// EmitComplexExprIntoAddr - Emit the computation of the specified expression 813 /// of complex type, storing into the specified Value*. 814 void EmitComplexExprIntoAddr(const Expr *E, llvm::Value *DestAddr, 815 bool DestIsVolatile); 816 817 /// StoreComplexToAddr - Store a complex number into the specified address. 818 void StoreComplexToAddr(ComplexPairTy V, llvm::Value *DestAddr, 819 bool DestIsVolatile); 820 /// LoadComplexFromAddr - Load a complex number from the specified address. 821 ComplexPairTy LoadComplexFromAddr(llvm::Value *SrcAddr, bool SrcIsVolatile); 822 823 /// CreateStaticBlockVarDecl - Create a zero-initialized LLVM global 824 /// for a static block var decl. 825 llvm::GlobalVariable * CreateStaticBlockVarDecl(const VarDecl &D, 826 const char *Separator, 827 llvm::GlobalValue::LinkageTypes 828 Linkage); 829 830 /// GenerateStaticCXXBlockVarDecl - Create the initializer for a C++ 831 /// runtime initialized static block var decl. 832 void GenerateStaticCXXBlockVarDeclInit(const VarDecl &D, 833 llvm::GlobalVariable *GV); 834 835 void EmitCXXConstructExpr(llvm::Value *Dest, const CXXConstructExpr *E); 836 837 RValue EmitCXXExprWithTemporaries(const CXXExprWithTemporaries *E, 838 llvm::Value *AggLoc = 0, 839 bool isAggLocVolatile = false); 840 841 //===--------------------------------------------------------------------===// 842 // Internal Helpers 843 //===--------------------------------------------------------------------===// 844 845 /// ContainsLabel - Return true if the statement contains a label in it. If 846 /// this statement is not executed normally, it not containing a label means 847 /// that we can just remove the code. 848 static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts = false); 849 850 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold 851 /// to a constant, or if it does but contains a label, return 0. If it 852 /// constant folds to 'true' and does not contain a label, return 1, if it 853 /// constant folds to 'false' and does not contain a label, return -1. 854 int ConstantFoldsToSimpleInteger(const Expr *Cond); 855 856 /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an 857 /// if statement) to the specified blocks. Based on the condition, this might 858 /// try to simplify the codegen of the conditional based on the branch. 859 void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock, 860 llvm::BasicBlock *FalseBlock); 861private: 862 863 /// EmitIndirectSwitches - Emit code for all of the switch 864 /// instructions in IndirectSwitches. 865 void EmitIndirectSwitches(); 866 867 void EmitReturnOfRValue(RValue RV, QualType Ty); 868 869 /// ExpandTypeFromArgs - Reconstruct a structure of type \arg Ty 870 /// from function arguments into \arg Dst. See ABIArgInfo::Expand. 871 /// 872 /// \param AI - The first function argument of the expansion. 873 /// \return The argument following the last expanded function 874 /// argument. 875 llvm::Function::arg_iterator 876 ExpandTypeFromArgs(QualType Ty, LValue Dst, 877 llvm::Function::arg_iterator AI); 878 879 /// ExpandTypeToArgs - Expand an RValue \arg Src, with the LLVM type for \arg 880 /// Ty, into individual arguments on the provided vector \arg Args. See 881 /// ABIArgInfo::Expand. 882 void ExpandTypeToArgs(QualType Ty, RValue Src, 883 llvm::SmallVector<llvm::Value*, 16> &Args); 884 885 llvm::Value* EmitAsmInput(const AsmStmt &S, 886 const TargetInfo::ConstraintInfo &Info, 887 const Expr *InputExpr, std::string &ConstraintStr); 888 889 /// EmitCleanupBlock - emits a single cleanup block. 890 void EmitCleanupBlock(); 891 892 /// AddBranchFixup - adds a branch instruction to the list of fixups for the 893 /// current cleanup scope. 894 void AddBranchFixup(llvm::BranchInst *BI); 895 896 /// EmitCallArg - Emit a single call argument. 897 RValue EmitCallArg(const Expr *E, QualType ArgType); 898 899 /// EmitCallArgs - Emit call arguments for a function. 900 /// The CallArgTypeInfo parameter is used for iterating over the known 901 /// argument types of the function being called. 902 template<typename T> 903 void EmitCallArgs(CallArgList& Args, const T* CallArgTypeInfo, 904 CallExpr::const_arg_iterator ArgBeg, 905 CallExpr::const_arg_iterator ArgEnd) { 906 CallExpr::const_arg_iterator Arg = ArgBeg; 907 908 // First, use the argument types that the type info knows about 909 if (CallArgTypeInfo) { 910 for (typename T::arg_type_iterator I = CallArgTypeInfo->arg_type_begin(), 911 E = CallArgTypeInfo->arg_type_end(); I != E; ++I, ++Arg) { 912 QualType ArgType = *I; 913 914 assert(getContext().getCanonicalType(ArgType.getNonReferenceType()). 915 getTypePtr() == 916 getContext().getCanonicalType(Arg->getType()).getTypePtr() && 917 "type mismatch in call argument!"); 918 919 Args.push_back(std::make_pair(EmitCallArg(*Arg, ArgType), 920 ArgType)); 921 } 922 923 // Either we've emitted all the call args, or we have a call to a 924 // variadic function. 925 assert((Arg == ArgEnd || CallArgTypeInfo->isVariadic()) && 926 "Extra arguments in non-variadic function!"); 927 928 } 929 930 // If we still have any arguments, emit them using the type of the argument. 931 for (; Arg != ArgEnd; ++Arg) { 932 QualType ArgType = Arg->getType(); 933 Args.push_back(std::make_pair(EmitCallArg(*Arg, ArgType), 934 ArgType)); 935 } 936 } 937}; 938 939 940} // end namespace CodeGen 941} // end namespace clang 942 943#endif 944