CodeGenFunction.h revision bd6fa3d032acd7eafc6c10827c41103df45beab7
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 "llvm/ADT/DenseMap.h" 19#include "llvm/ADT/SmallVector.h" 20#include "clang/Basic/TargetInfo.h" 21#include "clang/AST/Expr.h" 22#include "clang/AST/ExprCXX.h" 23#include "clang/AST/ExprObjC.h" 24 25#include <vector> 26#include <map> 27 28#include "CGBuilder.h" 29#include "CGCall.h" 30#include "CGValue.h" 31 32namespace llvm { 33 class BasicBlock; 34 class Module; 35 class SwitchInst; 36 class Value; 37} 38 39namespace clang { 40 class ASTContext; 41 class Decl; 42 class EnumConstantDecl; 43 class FunctionDecl; 44 class FunctionTypeProto; 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 55namespace CodeGen { 56 class CodeGenModule; 57 class CodeGenTypes; 58 class CGFunctionInfo; 59 class CGRecordLayout; 60 61/// CodeGenFunction - This class organizes the per-function state that is used 62/// while generating LLVM code. 63class CodeGenFunction { 64public: 65 CodeGenModule &CGM; // Per-module state. 66 TargetInfo &Target; 67 68 typedef std::pair<llvm::Value *, llvm::Value *> ComplexPairTy; 69 CGBuilderTy Builder; 70 71 // Holds the Decl for the current function or method 72 const Decl *CurFuncDecl; 73 const CGFunctionInfo *CurFnInfo; 74 QualType FnRetTy; 75 llvm::Function *CurFn; 76 77 /// ReturnBlock - Unified return block. 78 llvm::BasicBlock *ReturnBlock; 79 /// ReturnValue - The temporary alloca to hold the return value. This 80 /// is null iff the function has no return value. 81 llvm::Instruction *ReturnValue; 82 83 /// AllocaInsertPoint - This is an instruction in the entry block before which 84 /// we prefer to insert allocas. 85 llvm::Instruction *AllocaInsertPt; 86 87 const llvm::Type *LLVMIntTy; 88 uint32_t LLVMPointerWidth; 89 90public: 91 // FIXME: The following should be private once EH code is moved out 92 // of NeXT runtime. 93 94 // ObjCEHStack - This keeps track of which object to rethrow from 95 // inside @catch blocks and which @finally block exits from an EH 96 // scope should be chained through. 97 struct ObjCEHEntry { 98 ObjCEHEntry(llvm::BasicBlock *fb, llvm::SwitchInst *fs, llvm::Value *dc) 99 : FinallyBlock(fb), FinallySwitch(fs), 100 DestCode(dc) {} 101 102 /// Entry point to the finally block. 103 llvm::BasicBlock *FinallyBlock; 104 105 /// Switch instruction which runs at the end of the finally block 106 /// to forward jumps through the finally block. 107 llvm::SwitchInst *FinallySwitch; 108 109 /// Variable holding the code for the destination of a jump 110 /// through the @finally block. 111 llvm::Value *DestCode; 112 }; 113 114 /// ObjCEHValueStack - Stack of exception objects being handled, 115 /// during IR generation for a @catch block. 116 llvm::SmallVector<llvm::Value*, 8> ObjCEHValueStack; 117 118 typedef llvm::SmallVector<ObjCEHEntry*, 8> ObjCEHStackType; 119 ObjCEHStackType ObjCEHStack; 120 121 /// EmitJumpThroughFinally - Emit a branch from the current insert 122 /// point through the finally handling code for \arg Entry and then 123 /// on to \arg Dest. It is legal to call this function even if there 124 /// is no current insertion point. 125 /// 126 /// \param ExecuteTryExit - When true, the try_exit runtime function 127 /// should be called prior to executing the finally code. 128 void EmitJumpThroughFinally(ObjCEHEntry *Entry, llvm::BasicBlock *Dest, 129 bool ExecuteTryExit=true); 130 131 /// CreateCleanupBlock - Will push a new cleanup entry on the stack 132 /// and return a BasicBlock where cleanup instructions can be added 133 llvm::BasicBlock *CreateCleanupBlock(); 134 135 /// CleanupScope - RAII object that will create a cleanup block and 136 /// set the insert point to that block. When destructed, it sets the insert 137 /// point to the previous block. 138 class CleanupScope { 139 CodeGenFunction& CGF; 140 llvm::BasicBlock *CurBB; 141 142 public: 143 CleanupScope(CodeGenFunction &cgf) 144 : CGF(cgf), CurBB(CGF.Builder.GetInsertBlock()) { 145 llvm::BasicBlock *FinallyBB = CGF.CreateCleanupBlock(); 146 CGF.Builder.SetInsertPoint(FinallyBB); 147 } 148 149 ~CleanupScope() { 150 CGF.Builder.SetInsertPoint(CurBB); 151 } 152 }; 153 154 /// EmitCleanupBlocks - Takes the old cleanup stack size and emits the cleanup 155 /// blocks that have been added. 156 void EmitCleanupBlocks(size_t OldCleanupStackSize); 157 158private: 159 /// LabelIDs - Track arbitrary ids assigned to labels for use in 160 /// implementing the GCC address-of-label extension and indirect 161 /// goto. IDs are assigned to labels inside getIDForAddrOfLabel(). 162 std::map<const LabelStmt*, unsigned> LabelIDs; 163 164 /// IndirectSwitches - Record the list of switches for indirect 165 /// gotos. Emission of the actual switching code needs to be delayed 166 /// until all AddrLabelExprs have been seen. 167 std::vector<llvm::SwitchInst*> IndirectSwitches; 168 169 /// LocalDeclMap - This keeps track of the LLVM allocas or globals for local 170 /// C decls. 171 llvm::DenseMap<const Decl*, llvm::Value*> LocalDeclMap; 172 173 /// LabelMap - This keeps track of the LLVM basic block for each C label. 174 llvm::DenseMap<const LabelStmt*, llvm::BasicBlock*> LabelMap; 175 176 /// BreakContinuePush - Note a new break and continue level. This 177 /// must be called at the stack depth of the continue block. In 178 /// particular, this must not be called after the controlling 179 /// condition has possibly started a vla. 180 void BreakContinuePush(llvm::BasicBlock *bb, llvm::BasicBlock *cb) { 181 BreakContinueStack.push_back(BreakContinue(bb, cb, StackDepth, 182 StackDepth, 183 ObjCEHStack.size())); 184 } 185 void BreakContinuePush(llvm::BasicBlock *bb, llvm::BasicBlock *cb, 186 llvm::Value *bsd, llvm::Value *csd) { 187 BreakContinueStack.push_back(BreakContinue(bb, cb, bsd, csd, 188 ObjCEHStack.size())); 189 } 190 191 /// BreakContinuePop - Note end of previous break and continue level. 192 void BreakContinuePop() { 193 BreakContinueStack.pop_back(); 194 } 195 196 // BreakContinueStack - This keeps track of where break and continue 197 // statements should jump to, as well as the depth of the stack and the size 198 // of the eh stack. 199 struct BreakContinue { 200 BreakContinue(llvm::BasicBlock *bb, llvm::BasicBlock *cb, 201 llvm::Value *bsd, llvm::Value *csd, size_t ehss) 202 : BreakBlock(bb), ContinueBlock(cb), SaveBreakStackDepth(bsd), 203 SaveContinueStackDepth(csd), EHStackSize(ehss) {} 204 205 llvm::BasicBlock *BreakBlock; 206 llvm::BasicBlock *ContinueBlock; 207 llvm::Value *SaveBreakStackDepth; 208 llvm::Value *SaveContinueStackDepth; 209 size_t EHStackSize; 210 }; 211 llvm::SmallVector<BreakContinue, 8> BreakContinueStack; 212 213 /// SwitchInsn - This is nearest current switch instruction. It is null if 214 /// if current context is not in a switch. 215 llvm::SwitchInst *SwitchInsn; 216 217 /// CaseRangeBlock - This block holds if condition check for last case 218 /// statement range in current switch instruction. 219 llvm::BasicBlock *CaseRangeBlock; 220 221 // VLASizeMap - This keeps track of the associated size for each VLA type 222 // FIXME: Maybe this could be a stack of maps that is pushed/popped as 223 // we enter/leave scopes. 224 llvm::DenseMap<const VariableArrayType*, llvm::Value*> VLASizeMap; 225 226 /// StackDepth - This keeps track of the stack depth. It is used to 227 /// notice when control flow results in a change in stack depth and 228 /// to arrange for the appropriate stack depth to be restored. 229 llvm::Value *StackDepth; 230 231 /// StackSaveValues - A stack(!) of stack save values. When a new scope is 232 /// entered, a null is pushed on this stack. If a VLA is emitted, then 233 /// the return value of llvm.stacksave() is stored at the top of this stack. 234 llvm::SmallVector<llvm::Value*, 8> StackSaveValues; 235 236 llvm::DenseMap<const LabelStmt*, llvm::Value *> StackDepthMap; 237 238 /// EmitStackUpdate - Routine to adjust the stack to the depth the 239 /// stack should be at by the time we transfer control flow to the 240 /// label. 241 void EmitStackUpdate(const LabelStmt &S); 242 243 struct CleanupEntry { 244 /// CleanupBlock - The block of code that does the actual cleanup. 245 llvm::BasicBlock *CleanupBlock; 246 247 /// Blocks - Basic blocks that were emitted in the current cleanup scope. 248 std::vector<llvm::BasicBlock *> Blocks; 249 250 /// BranchFixups - Branch instructions to basic blocks that haven't been 251 /// inserted into the current function yet. 252 std::vector<llvm::BranchInst*> BranchFixups; 253 254 explicit CleanupEntry(llvm::BasicBlock *cb) 255 : CleanupBlock(cb) {} 256 257 ~CleanupEntry() { 258 assert(Blocks.empty() && "Did not empty blocks!"); 259 assert(BranchFixups.empty() && "Did not empty branch fixups!"); 260 } 261 262 }; 263 264 /// CleanupEntries - Stack of cleanup entries. 265 llvm::SmallVector<CleanupEntry, 8> CleanupEntries; 266 267 typedef llvm::DenseMap<llvm::BasicBlock*, size_t> BlockScopeMap; 268 269 /// BlockScopes - Map of which "cleanup scope" scope basic blocks have. 270 BlockScopeMap BlockScopes; 271 272public: 273 CodeGenFunction(CodeGenModule &cgm); 274 275 ASTContext &getContext() const; 276 277 void GenerateObjCMethod(const ObjCMethodDecl *OMD); 278 279 void StartObjCMethod(const ObjCMethodDecl *MD, 280 const ObjCContainerDecl *CD); 281 282 /// GenerateObjCGetter - Synthesize an Objective-C property getter 283 /// function. 284 void GenerateObjCGetter(ObjCImplementationDecl *IMP, 285 const ObjCPropertyImplDecl *PID); 286 287 /// GenerateObjCSetter - Synthesize an Objective-C property setter 288 /// function for the given property. 289 void GenerateObjCSetter(ObjCImplementationDecl *IMP, 290 const ObjCPropertyImplDecl *PID); 291 292 void GenerateCode(const FunctionDecl *FD, 293 llvm::Function *Fn); 294 void StartFunction(const Decl *D, QualType RetTy, 295 llvm::Function *Fn, 296 const FunctionArgList &Args, 297 SourceLocation StartLoc); 298 299 /// EmitReturnBlock - Emit the unified return block, trying to avoid 300 /// its emission when possible. 301 void EmitReturnBlock(); 302 303 /// FinishFunction - Complete IR generation of the current 304 /// function. It is legal to call this function even if there is no 305 /// current insertion point. 306 void FinishFunction(SourceLocation EndLoc=SourceLocation()); 307 308 /// EmitFunctionProlog - Emit the target specific LLVM code to load 309 /// the arguments for the given function. This is also responsible 310 /// for naming the LLVM function arguments. 311 void EmitFunctionProlog(const CGFunctionInfo &FI, 312 llvm::Function *Fn, 313 const FunctionArgList &Args); 314 315 /// EmitFunctionEpilog - Emit the target specific LLVM code to 316 /// return the given temporary. 317 void EmitFunctionEpilog(const CGFunctionInfo &FI, llvm::Value *ReturnValue); 318 319 const llvm::Type *ConvertTypeForMem(QualType T); 320 const llvm::Type *ConvertType(QualType T); 321 322 /// LoadObjCSelf - Load the value of self. This function is only 323 /// valid while generating code for an Objective-C method. 324 llvm::Value *LoadObjCSelf(); 325 326 /// TypeOfSelfObject 327 /// Return type of object that this self represents. 328 QualType TypeOfSelfObject(); 329 330 /// isObjCPointerType - Return true if the specificed AST type will map onto 331 /// some Objective-C pointer type. 332 static bool isObjCPointerType(QualType T); 333 334 /// hasAggregateLLVMType - Return true if the specified AST type will map into 335 /// an aggregate LLVM type or is void. 336 static bool hasAggregateLLVMType(QualType T); 337 338 /// createBasicBlock - Create an LLVM basic block. 339 llvm::BasicBlock *createBasicBlock(const char *Name="", 340 llvm::Function *Parent=0, 341 llvm::BasicBlock *InsertBefore=0) { 342#ifdef NDEBUG 343 return llvm::BasicBlock::Create("", Parent, InsertBefore); 344#else 345 return llvm::BasicBlock::Create(Name, Parent, InsertBefore); 346#endif 347 } 348 349 /// getBasicBlockForLabel - Return the LLVM basicblock that the specified 350 /// label maps to. 351 llvm::BasicBlock *getBasicBlockForLabel(const LabelStmt *S); 352 353 /// EmitBlock - Emit the given block \arg BB and set it as the 354 /// insert point, adding a fall-through branch from the current 355 /// insert block if necessary. It is legal to call this function 356 /// even if there is no current insertion point. 357 /// 358 /// IsFinished - If true, indicates that the caller has finished 359 /// emitting branches to the given block and does not expect to emit 360 /// code into it. This means the block can be ignored if it is 361 /// unreachable. 362 void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false); 363 364 /// EmitBranch - Emit a branch to the specified basic block from the 365 /// current insert block, taking care to avoid creation of branches 366 /// from dummy blocks. It is legal to call this function even if 367 /// there is no current insertion point. 368 /// 369 /// This function clears the current insertion point. The caller 370 /// should follow calls to this function with calls to Emit*Block 371 /// prior to generation new code. 372 void EmitBranch(llvm::BasicBlock *Block); 373 374 /// HaveInsertPoint - True if an insertion point is defined. If not, 375 /// this indicates that the current code being emitted is 376 /// unreachable. 377 bool HaveInsertPoint() const { 378 return Builder.GetInsertBlock() != 0; 379 } 380 381 /// EnsureInsertPoint - Ensure that an insertion point is defined so 382 /// that emitted IR has a place to go. Note that by definition, if 383 /// this function creates a block then that block is unreachable; 384 /// callers may do better to detect when no insertion point is 385 /// defined and simply skip IR generation. 386 void EnsureInsertPoint() { 387 if (!HaveInsertPoint()) 388 EmitBlock(createBasicBlock()); 389 } 390 391 /// ErrorUnsupported - Print out an error that codegen doesn't support the 392 /// specified stmt yet. 393 void ErrorUnsupported(const Stmt *S, const char *Type, 394 bool OmitOnError=false); 395 396 //===--------------------------------------------------------------------===// 397 // Helpers 398 //===--------------------------------------------------------------------===// 399 400 /// CreateTempAlloca - This creates a alloca and inserts it into the entry 401 /// block. 402 llvm::AllocaInst *CreateTempAlloca(const llvm::Type *Ty, 403 const char *Name = "tmp"); 404 405 /// EvaluateExprAsBool - Perform the usual unary conversions on the specified 406 /// expression and compare the result against zero, returning an Int1Ty value. 407 llvm::Value *EvaluateExprAsBool(const Expr *E); 408 409 /// EmitAnyExpr - Emit code to compute the specified expression which can have 410 /// any type. The result is returned as an RValue struct. If this is an 411 /// aggregate expression, the aggloc/agglocvolatile arguments indicate where 412 /// the result should be returned. 413 RValue EmitAnyExpr(const Expr *E, llvm::Value *AggLoc = 0, 414 bool isAggLocVolatile = false); 415 416 // EmitVAListRef - Emit a "reference" to a va_list; this is either the 417 // address or the value of the expression, depending on how va_list is 418 // defined. 419 llvm::Value *EmitVAListRef(const Expr *E); 420 421 /// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result 422 /// will always be accessible even if no aggregate location is 423 /// provided. 424 RValue EmitAnyExprToTemp(const Expr *E, llvm::Value *AggLoc = 0, 425 bool isAggLocVolatile = false); 426 427 void EmitAggregateCopy(llvm::Value *DestPtr, llvm::Value *SrcPtr, 428 QualType EltTy); 429 430 void EmitAggregateClear(llvm::Value *DestPtr, QualType Ty); 431 432 /// StartBlock - Start new block named N. If insert block is a dummy block 433 /// then reuse it. 434 void StartBlock(const char *N); 435 436 /// getCGRecordLayout - Return record layout info. 437 const CGRecordLayout *getCGRecordLayout(CodeGenTypes &CGT, QualType RTy); 438 439 /// GetAddrOfStaticLocalVar - Return the address of a static local variable. 440 llvm::Constant *GetAddrOfStaticLocalVar(const VarDecl *BVD); 441 442 /// GetAddrOfLocalVar - Return the address of a local variable. 443 llvm::Value *GetAddrOfLocalVar(const VarDecl *VD); 444 445 /// getAccessedFieldNo - Given an encoded value and a result number, return 446 /// the input field number being accessed. 447 static unsigned getAccessedFieldNo(unsigned Idx, const llvm::Constant *Elts); 448 449 unsigned GetIDForAddrOfLabel(const LabelStmt *L); 450 451 /// EmitMemSetToZero - Generate code to memset a value of the given type to 0; 452 void EmitMemSetToZero(llvm::Value *DestPtr, QualType Ty); 453 454 // EmitVAArg - Generate code to get an argument from the passed in pointer 455 // and update it accordingly. The return value is a pointer to the argument. 456 // FIXME: We should be able to get rid of this method and use the va_arg 457 // instruction in LLVM instead once it works well enough. 458 llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty); 459 460 // EmitVLASize - Generate code for any VLA size expressions that might occur 461 // in a variably modified type. If Ty is a VLA, will return the value that 462 // corresponds to the size in bytes of the VLA type. Will return 0 otherwise. 463 llvm::Value *EmitVLASize(QualType Ty); 464 465 // GetVLASize - Returns an LLVM value that corresponds to the size in bytes 466 // of a variable length array type. 467 llvm::Value *GetVLASize(const VariableArrayType *); 468 469 //===--------------------------------------------------------------------===// 470 // Declaration Emission 471 //===--------------------------------------------------------------------===// 472 473 void EmitDecl(const Decl &D); 474 void EmitBlockVarDecl(const VarDecl &D); 475 void EmitLocalBlockVarDecl(const VarDecl &D); 476 void EmitStaticBlockVarDecl(const VarDecl &D); 477 478 /// EmitParmDecl - Emit a ParmVarDecl or an ImplicitParamDecl. 479 void EmitParmDecl(const VarDecl &D, llvm::Value *Arg); 480 481 //===--------------------------------------------------------------------===// 482 // Statement Emission 483 //===--------------------------------------------------------------------===// 484 485 /// EmitStopPoint - Emit a debug stoppoint if we are emitting debug 486 /// info. 487 void EmitStopPoint(const Stmt *S); 488 489 /// EmitStmt - Emit the code for the statement \arg S. It is legal 490 /// to call this function even if there is no current insertion 491 /// point. 492 /// 493 /// This function may clear the current insertion point; callers 494 /// should use EnsureInsertPoint if they wish to subsequently 495 /// generate code without first calling EmitBlock, EmitBranch, or 496 /// EmitStmt. 497 void EmitStmt(const Stmt *S); 498 499 /// EmitSimpleStmt - Try to emit a "simple" statement which does not 500 /// necessarily require an insertion point or debug information; 501 /// typically because the statement amounts to a jump or a container 502 /// of other statements. 503 /// 504 /// \return True if the statement was handled. 505 bool EmitSimpleStmt(const Stmt *S); 506 507 RValue EmitCompoundStmt(const CompoundStmt &S, bool GetLast = false, 508 llvm::Value *AggLoc = 0, bool isAggVol = false); 509 510 /// EmitLabel - Emit the block for the given label. It is legal 511 /// to call this function even if there is no current insertion 512 /// point. 513 void EmitLabel(const LabelStmt &S); // helper for EmitLabelStmt. 514 515 void EmitLabelStmt(const LabelStmt &S); 516 void EmitGotoStmt(const GotoStmt &S); 517 void EmitIndirectGotoStmt(const IndirectGotoStmt &S); 518 void EmitIfStmt(const IfStmt &S); 519 void EmitWhileStmt(const WhileStmt &S); 520 void EmitDoStmt(const DoStmt &S); 521 void EmitForStmt(const ForStmt &S); 522 void EmitReturnStmt(const ReturnStmt &S); 523 void EmitDeclStmt(const DeclStmt &S); 524 void EmitBreakStmt(const BreakStmt &S); 525 void EmitContinueStmt(const ContinueStmt &S); 526 void EmitSwitchStmt(const SwitchStmt &S); 527 void EmitDefaultStmt(const DefaultStmt &S); 528 void EmitCaseStmt(const CaseStmt &S); 529 void EmitCaseStmtRange(const CaseStmt &S); 530 void EmitAsmStmt(const AsmStmt &S); 531 532 void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S); 533 void EmitObjCAtTryStmt(const ObjCAtTryStmt &S); 534 void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S); 535 void EmitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt &S); 536 537 //===--------------------------------------------------------------------===// 538 // LValue Expression Emission 539 //===--------------------------------------------------------------------===// 540 541 /// GetUndefRValue - Get an appropriate 'undef' rvalue for the given type. 542 RValue GetUndefRValue(QualType Ty); 543 544 /// EmitUnsupportedRValue - Emit a dummy r-value using the type of E 545 /// and issue an ErrorUnsupported style diagnostic (using the 546 /// provided Name). 547 RValue EmitUnsupportedRValue(const Expr *E, 548 const char *Name); 549 550 /// EmitUnsupportedLValue - Emit a dummy l-value using the type of E 551 /// and issue an ErrorUnsupported style diagnostic (using the 552 /// provided Name). 553 LValue EmitUnsupportedLValue(const Expr *E, 554 const char *Name); 555 556 /// EmitLValue - Emit code to compute a designator that specifies the location 557 /// of the expression. 558 /// 559 /// This can return one of two things: a simple address or a bitfield 560 /// reference. In either case, the LLVM Value* in the LValue structure is 561 /// guaranteed to be an LLVM pointer type. 562 /// 563 /// If this returns a bitfield reference, nothing about the pointee type of 564 /// the LLVM value is known: For example, it may not be a pointer to an 565 /// integer. 566 /// 567 /// If this returns a normal address, and if the lvalue's C type is fixed 568 /// size, this method guarantees that the returned pointer type will point to 569 /// an LLVM type of the same size of the lvalue's type. If the lvalue has a 570 /// variable length type, this is not possible. 571 /// 572 LValue EmitLValue(const Expr *E); 573 574 /// EmitLoadOfLValue - Given an expression that represents a value lvalue, 575 /// this method emits the address of the lvalue, then loads the result as an 576 /// rvalue, returning the rvalue. 577 RValue EmitLoadOfLValue(LValue V, QualType LVType); 578 RValue EmitLoadOfExtVectorElementLValue(LValue V, QualType LVType); 579 RValue EmitLoadOfBitfieldLValue(LValue LV, QualType ExprType); 580 RValue EmitLoadOfPropertyRefLValue(LValue LV, QualType ExprType); 581 RValue EmitLoadOfKVCRefLValue(LValue LV, QualType ExprType); 582 583 584 /// EmitStoreThroughLValue - Store the specified rvalue into the specified 585 /// lvalue, where both are guaranteed to the have the same type, and that type 586 /// is 'Ty'. 587 void EmitStoreThroughLValue(RValue Src, LValue Dst, QualType Ty); 588 void EmitStoreThroughExtVectorComponentLValue(RValue Src, LValue Dst, 589 QualType Ty); 590 void EmitStoreThroughPropertyRefLValue(RValue Src, LValue Dst, QualType Ty); 591 void EmitStoreThroughKVCRefLValue(RValue Src, LValue Dst, QualType Ty); 592 593 /// EmitStoreThroughLValue - Store Src into Dst with same 594 /// constraints as EmitStoreThroughLValue. 595 /// 596 /// \param Result [out] - If non-null, this will be set to a Value* 597 /// for the bit-field contents after the store, appropriate for use 598 /// as the result of an assignment to the bit-field. 599 void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, QualType Ty, 600 llvm::Value **Result=0); 601 602 // Note: only availabe for agg return types 603 LValue EmitBinaryOperatorLValue(const BinaryOperator *E); 604 // Note: only availabe for agg return types 605 LValue EmitCallExprLValue(const CallExpr *E); 606 LValue EmitDeclRefLValue(const DeclRefExpr *E); 607 LValue EmitStringLiteralLValue(const StringLiteral *E); 608 LValue EmitPredefinedFunctionName(unsigned Type); 609 LValue EmitPredefinedLValue(const PredefinedExpr *E); 610 LValue EmitUnaryOpLValue(const UnaryOperator *E); 611 LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E); 612 LValue EmitExtVectorElementExpr(const ExtVectorElementExpr *E); 613 LValue EmitMemberExpr(const MemberExpr *E); 614 LValue EmitCompoundLiteralLValue(const CompoundLiteralExpr *E); 615 616 llvm::Value *EmitIvarOffset(ObjCInterfaceDecl *Interface, 617 const ObjCIvarDecl *Ivar); 618 LValue EmitLValueForField(llvm::Value* Base, FieldDecl* Field, 619 bool isUnion, unsigned CVRQualifiers); 620 LValue EmitLValueForIvar(QualType ObjectTy, 621 llvm::Value* Base, const ObjCIvarDecl *Ivar, 622 const FieldDecl *Field, 623 unsigned CVRQualifiers); 624 625 LValue EmitLValueForBitfield(llvm::Value* Base, FieldDecl* Field, 626 unsigned CVRQualifiers); 627 628 LValue EmitCXXConditionDeclLValue(const CXXConditionDeclExpr *E); 629 630 LValue EmitObjCMessageExprLValue(const ObjCMessageExpr *E); 631 LValue EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E); 632 LValue EmitObjCPropertyRefLValue(const ObjCPropertyRefExpr *E); 633 LValue EmitObjCKVCRefLValue(const ObjCKVCRefExpr *E); 634 LValue EmitObjCSuperExpr(const ObjCSuperExpr *E); 635 636 //===--------------------------------------------------------------------===// 637 // Scalar Expression Emission 638 //===--------------------------------------------------------------------===// 639 640 /// EmitCall - Generate a call of the given function, expecting the 641 /// given result type, and using the given argument list which 642 /// specifies both the LLVM arguments and the types they were 643 /// derived from. 644 RValue EmitCall(const CGFunctionInfo &FnInfo, 645 llvm::Value *Callee, 646 const CallArgList &Args); 647 648 RValue EmitCallExpr(const CallExpr *E); 649 650 RValue EmitCallExpr(Expr *FnExpr, CallExpr::const_arg_iterator ArgBeg, 651 CallExpr::const_arg_iterator ArgEnd); 652 653 RValue EmitCallExpr(llvm::Value *Callee, QualType FnType, 654 CallExpr::const_arg_iterator ArgBeg, 655 CallExpr::const_arg_iterator ArgEnd); 656 657 RValue EmitBuiltinExpr(unsigned BuiltinID, const CallExpr *E); 658 659 /// EmitTargetBuiltinExpr - Emit the given builtin call. Returns 0 660 /// if the call is unhandled by the current target. 661 llvm::Value *EmitTargetBuiltinExpr(unsigned BuiltinID, const CallExpr *E); 662 663 llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E); 664 llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E); 665 666 llvm::Value *EmitShuffleVector(llvm::Value* V1, llvm::Value *V2, ...); 667 llvm::Value *EmitVector(llvm::Value * const *Vals, unsigned NumVals, 668 bool isSplat = false); 669 670 llvm::Value *EmitObjCProtocolExpr(const ObjCProtocolExpr *E); 671 llvm::Value *EmitObjCStringLiteral(const ObjCStringLiteral *E); 672 llvm::Value *EmitObjCSelectorExpr(const ObjCSelectorExpr *E); 673 RValue EmitObjCMessageExpr(const ObjCMessageExpr *E); 674 RValue EmitObjCPropertyGet(const Expr *E); 675 void EmitObjCPropertySet(const Expr *E, RValue Src); 676 677 678 //===--------------------------------------------------------------------===// 679 // Expression Emission 680 //===--------------------------------------------------------------------===// 681 682 // Expressions are broken into three classes: scalar, complex, aggregate. 683 684 /// EmitScalarExpr - Emit the computation of the specified expression of 685 /// LLVM scalar type, returning the result. 686 llvm::Value *EmitScalarExpr(const Expr *E); 687 688 /// EmitScalarConversion - Emit a conversion from the specified type to the 689 /// specified destination type, both of which are LLVM scalar types. 690 llvm::Value *EmitScalarConversion(llvm::Value *Src, QualType SrcTy, 691 QualType DstTy); 692 693 /// EmitComplexToScalarConversion - Emit a conversion from the specified 694 /// complex type to the specified destination type, where the destination 695 /// type is an LLVM scalar type. 696 llvm::Value *EmitComplexToScalarConversion(ComplexPairTy Src, QualType SrcTy, 697 QualType DstTy); 698 699 700 /// EmitAggExpr - Emit the computation of the specified expression of 701 /// aggregate type. The result is computed into DestPtr. Note that if 702 /// DestPtr is null, the value of the aggregate expression is not needed. 703 void EmitAggExpr(const Expr *E, llvm::Value *DestPtr, bool VolatileDest); 704 705 /// EmitComplexExpr - Emit the computation of the specified expression of 706 /// complex type, returning the result. 707 ComplexPairTy EmitComplexExpr(const Expr *E); 708 709 /// EmitComplexExprIntoAddr - Emit the computation of the specified expression 710 /// of complex type, storing into the specified Value*. 711 void EmitComplexExprIntoAddr(const Expr *E, llvm::Value *DestAddr, 712 bool DestIsVolatile); 713 714 /// StoreComplexToAddr - Store a complex number into the specified address. 715 void StoreComplexToAddr(ComplexPairTy V, llvm::Value *DestAddr, 716 bool DestIsVolatile); 717 /// LoadComplexFromAddr - Load a complex number from the specified address. 718 ComplexPairTy LoadComplexFromAddr(llvm::Value *SrcAddr, bool SrcIsVolatile); 719 720 /// GenerateStaticBlockVarDecl - return the the static 721 /// declaration of local variable. 722 llvm::GlobalValue * GenerateStaticBlockVarDecl(const VarDecl &D, 723 bool NoInit, 724 const char *Separator, 725 llvm::GlobalValue 726 ::LinkageTypes Linkage); 727 728 // GenerateStaticCXXBlockVarDecl - return the static declaration of 729 // a local variable. Performs initialization of the variable if necessary. 730 llvm::GlobalValue *GenerateStaticCXXBlockVarDecl(const VarDecl &D); 731 732 //===--------------------------------------------------------------------===// 733 // Internal Helpers 734 //===--------------------------------------------------------------------===// 735 736 /// ContainsLabel - Return true if the statement contains a label in it. If 737 /// this statement is not executed normally, it not containing a label means 738 /// that we can just remove the code. 739 static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts = false); 740 741 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold 742 /// to a constant, or if it does but contains a label, return 0. If it 743 /// constant folds to 'true' and does not contain a label, return 1, if it 744 /// constant folds to 'false' and does not contain a label, return -1. 745 int ConstantFoldsToSimpleInteger(const Expr *Cond); 746 747 /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an 748 /// if statement) to the specified blocks. Based on the condition, this might 749 /// try to simplify the codegen of the conditional based on the branch. 750 /// 751 void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock, 752 llvm::BasicBlock *FalseBlock); 753private: 754 755 /// EmitIndirectSwitches - Emit code for all of the switch 756 /// instructions in IndirectSwitches. 757 void EmitIndirectSwitches(); 758 759 void EmitReturnOfRValue(RValue RV, QualType Ty); 760 761 /// ExpandTypeFromArgs - Reconstruct a structure of type \arg Ty 762 /// from function arguments into \arg Dst. See ABIArgInfo::Expand. 763 /// 764 /// \param AI - The first function argument of the expansion. 765 /// \return The argument following the last expanded function 766 /// argument. 767 llvm::Function::arg_iterator 768 ExpandTypeFromArgs(QualType Ty, LValue Dst, 769 llvm::Function::arg_iterator AI); 770 771 /// ExpandTypeToArgs - Expand an RValue \arg Src, with the LLVM type 772 /// for \arg Ty, into individual arguments on the provided vector 773 /// \arg Args. See ABIArgInfo::Expand. 774 void ExpandTypeToArgs(QualType Ty, RValue Src, 775 llvm::SmallVector<llvm::Value*, 16> &Args); 776 777 llvm::Value* EmitAsmInput(const AsmStmt &S, TargetInfo::ConstraintInfo Info, 778 const Expr *InputExpr, std::string &ConstraintStr); 779 780 /// EmitCleanupBlock - emits a single cleanup block. 781 void EmitCleanupBlock(); 782 783}; 784} // end namespace CodeGen 785} // end namespace clang 786 787#endif 788