CodeGenFunction.h revision 263508
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 "CGBuilder.h" 18#include "CGDebugInfo.h" 19#include "CGValue.h" 20#include "EHScopeStack.h" 21#include "CodeGenModule.h" 22#include "clang/AST/CharUnits.h" 23#include "clang/AST/ExprCXX.h" 24#include "clang/AST/ExprObjC.h" 25#include "clang/AST/Type.h" 26#include "clang/Basic/ABI.h" 27#include "clang/Basic/CapturedStmt.h" 28#include "clang/Basic/TargetInfo.h" 29#include "clang/Frontend/CodeGenOptions.h" 30#include "llvm/ADT/ArrayRef.h" 31#include "llvm/ADT/DenseMap.h" 32#include "llvm/ADT/SmallVector.h" 33#include "llvm/Support/Debug.h" 34#include "llvm/Support/ValueHandle.h" 35 36namespace llvm { 37 class BasicBlock; 38 class LLVMContext; 39 class MDNode; 40 class Module; 41 class SwitchInst; 42 class Twine; 43 class Value; 44 class CallSite; 45} 46 47namespace clang { 48 class ASTContext; 49 class BlockDecl; 50 class CXXDestructorDecl; 51 class CXXForRangeStmt; 52 class CXXTryStmt; 53 class Decl; 54 class LabelDecl; 55 class EnumConstantDecl; 56 class FunctionDecl; 57 class FunctionProtoType; 58 class LabelStmt; 59 class ObjCContainerDecl; 60 class ObjCInterfaceDecl; 61 class ObjCIvarDecl; 62 class ObjCMethodDecl; 63 class ObjCImplementationDecl; 64 class ObjCPropertyImplDecl; 65 class TargetInfo; 66 class TargetCodeGenInfo; 67 class VarDecl; 68 class ObjCForCollectionStmt; 69 class ObjCAtTryStmt; 70 class ObjCAtThrowStmt; 71 class ObjCAtSynchronizedStmt; 72 class ObjCAutoreleasePoolStmt; 73 74namespace CodeGen { 75 class CodeGenTypes; 76 class CGFunctionInfo; 77 class CGRecordLayout; 78 class CGBlockInfo; 79 class CGCXXABI; 80 class BlockFlags; 81 class BlockFieldFlags; 82 83/// The kind of evaluation to perform on values of a particular 84/// type. Basically, is the code in CGExprScalar, CGExprComplex, or 85/// CGExprAgg? 86/// 87/// TODO: should vectors maybe be split out into their own thing? 88enum TypeEvaluationKind { 89 TEK_Scalar, 90 TEK_Complex, 91 TEK_Aggregate 92}; 93 94/// CodeGenFunction - This class organizes the per-function state that is used 95/// while generating LLVM code. 96class CodeGenFunction : public CodeGenTypeCache { 97 CodeGenFunction(const CodeGenFunction &) LLVM_DELETED_FUNCTION; 98 void operator=(const CodeGenFunction &) LLVM_DELETED_FUNCTION; 99 100 friend class CGCXXABI; 101public: 102 /// A jump destination is an abstract label, branching to which may 103 /// require a jump out through normal cleanups. 104 struct JumpDest { 105 JumpDest() : Block(0), ScopeDepth(), Index(0) {} 106 JumpDest(llvm::BasicBlock *Block, 107 EHScopeStack::stable_iterator Depth, 108 unsigned Index) 109 : Block(Block), ScopeDepth(Depth), Index(Index) {} 110 111 bool isValid() const { return Block != 0; } 112 llvm::BasicBlock *getBlock() const { return Block; } 113 EHScopeStack::stable_iterator getScopeDepth() const { return ScopeDepth; } 114 unsigned getDestIndex() const { return Index; } 115 116 // This should be used cautiously. 117 void setScopeDepth(EHScopeStack::stable_iterator depth) { 118 ScopeDepth = depth; 119 } 120 121 private: 122 llvm::BasicBlock *Block; 123 EHScopeStack::stable_iterator ScopeDepth; 124 unsigned Index; 125 }; 126 127 CodeGenModule &CGM; // Per-module state. 128 const TargetInfo &Target; 129 130 typedef std::pair<llvm::Value *, llvm::Value *> ComplexPairTy; 131 CGBuilderTy Builder; 132 133 /// CurFuncDecl - Holds the Decl for the current outermost 134 /// non-closure context. 135 const Decl *CurFuncDecl; 136 /// CurCodeDecl - This is the inner-most code context, which includes blocks. 137 const Decl *CurCodeDecl; 138 const CGFunctionInfo *CurFnInfo; 139 QualType FnRetTy; 140 llvm::Function *CurFn; 141 142 /// CurGD - The GlobalDecl for the current function being compiled. 143 GlobalDecl CurGD; 144 145 /// PrologueCleanupDepth - The cleanup depth enclosing all the 146 /// cleanups associated with the parameters. 147 EHScopeStack::stable_iterator PrologueCleanupDepth; 148 149 /// ReturnBlock - Unified return block. 150 JumpDest ReturnBlock; 151 152 /// ReturnValue - The temporary alloca to hold the return value. This is null 153 /// iff the function has no return value. 154 llvm::Value *ReturnValue; 155 156 /// AllocaInsertPoint - This is an instruction in the entry block before which 157 /// we prefer to insert allocas. 158 llvm::AssertingVH<llvm::Instruction> AllocaInsertPt; 159 160 /// \brief API for captured statement code generation. 161 class CGCapturedStmtInfo { 162 public: 163 explicit CGCapturedStmtInfo(const CapturedStmt &S, 164 CapturedRegionKind K = CR_Default) 165 : Kind(K), ThisValue(0), CXXThisFieldDecl(0) { 166 167 RecordDecl::field_iterator Field = 168 S.getCapturedRecordDecl()->field_begin(); 169 for (CapturedStmt::const_capture_iterator I = S.capture_begin(), 170 E = S.capture_end(); 171 I != E; ++I, ++Field) { 172 if (I->capturesThis()) 173 CXXThisFieldDecl = *Field; 174 else 175 CaptureFields[I->getCapturedVar()] = *Field; 176 } 177 } 178 179 virtual ~CGCapturedStmtInfo(); 180 181 CapturedRegionKind getKind() const { return Kind; } 182 183 void setContextValue(llvm::Value *V) { ThisValue = V; } 184 // \brief Retrieve the value of the context parameter. 185 llvm::Value *getContextValue() const { return ThisValue; } 186 187 /// \brief Lookup the captured field decl for a variable. 188 const FieldDecl *lookup(const VarDecl *VD) const { 189 return CaptureFields.lookup(VD); 190 } 191 192 bool isCXXThisExprCaptured() const { return CXXThisFieldDecl != 0; } 193 FieldDecl *getThisFieldDecl() const { return CXXThisFieldDecl; } 194 195 /// \brief Emit the captured statement body. 196 virtual void EmitBody(CodeGenFunction &CGF, Stmt *S) { 197 CGF.EmitStmt(S); 198 } 199 200 /// \brief Get the name of the capture helper. 201 virtual StringRef getHelperName() const { return "__captured_stmt"; } 202 203 private: 204 /// \brief The kind of captured statement being generated. 205 CapturedRegionKind Kind; 206 207 /// \brief Keep the map between VarDecl and FieldDecl. 208 llvm::SmallDenseMap<const VarDecl *, FieldDecl *> CaptureFields; 209 210 /// \brief The base address of the captured record, passed in as the first 211 /// argument of the parallel region function. 212 llvm::Value *ThisValue; 213 214 /// \brief Captured 'this' type. 215 FieldDecl *CXXThisFieldDecl; 216 }; 217 CGCapturedStmtInfo *CapturedStmtInfo; 218 219 /// BoundsChecking - Emit run-time bounds checks. Higher values mean 220 /// potentially higher performance penalties. 221 unsigned char BoundsChecking; 222 223 /// \brief Whether any type-checking sanitizers are enabled. If \c false, 224 /// calls to EmitTypeCheck can be skipped. 225 bool SanitizePerformTypeCheck; 226 227 /// \brief Sanitizer options to use for this function. 228 const SanitizerOptions *SanOpts; 229 230 /// In ARC, whether we should autorelease the return value. 231 bool AutoreleaseResult; 232 233 const CodeGen::CGBlockInfo *BlockInfo; 234 llvm::Value *BlockPointer; 235 236 llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields; 237 FieldDecl *LambdaThisCaptureField; 238 239 /// \brief A mapping from NRVO variables to the flags used to indicate 240 /// when the NRVO has been applied to this variable. 241 llvm::DenseMap<const VarDecl *, llvm::Value *> NRVOFlags; 242 243 EHScopeStack EHStack; 244 llvm::SmallVector<char, 256> LifetimeExtendedCleanupStack; 245 246 /// Header for data within LifetimeExtendedCleanupStack. 247 struct LifetimeExtendedCleanupHeader { 248 /// The size of the following cleanup object. 249 size_t Size : 29; 250 /// The kind of cleanup to push: a value from the CleanupKind enumeration. 251 unsigned Kind : 3; 252 253 size_t getSize() const { return Size; } 254 CleanupKind getKind() const { return static_cast<CleanupKind>(Kind); } 255 }; 256 257 /// i32s containing the indexes of the cleanup destinations. 258 llvm::AllocaInst *NormalCleanupDest; 259 260 unsigned NextCleanupDestIndex; 261 262 /// FirstBlockInfo - The head of a singly-linked-list of block layouts. 263 CGBlockInfo *FirstBlockInfo; 264 265 /// EHResumeBlock - Unified block containing a call to llvm.eh.resume. 266 llvm::BasicBlock *EHResumeBlock; 267 268 /// The exception slot. All landing pads write the current exception pointer 269 /// into this alloca. 270 llvm::Value *ExceptionSlot; 271 272 /// The selector slot. Under the MandatoryCleanup model, all landing pads 273 /// write the current selector value into this alloca. 274 llvm::AllocaInst *EHSelectorSlot; 275 276 /// Emits a landing pad for the current EH stack. 277 llvm::BasicBlock *EmitLandingPad(); 278 279 llvm::BasicBlock *getInvokeDestImpl(); 280 281 template <class T> 282 typename DominatingValue<T>::saved_type saveValueInCond(T value) { 283 return DominatingValue<T>::save(*this, value); 284 } 285 286public: 287 /// ObjCEHValueStack - Stack of Objective-C exception values, used for 288 /// rethrows. 289 SmallVector<llvm::Value*, 8> ObjCEHValueStack; 290 291 /// A class controlling the emission of a finally block. 292 class FinallyInfo { 293 /// Where the catchall's edge through the cleanup should go. 294 JumpDest RethrowDest; 295 296 /// A function to call to enter the catch. 297 llvm::Constant *BeginCatchFn; 298 299 /// An i1 variable indicating whether or not the @finally is 300 /// running for an exception. 301 llvm::AllocaInst *ForEHVar; 302 303 /// An i8* variable into which the exception pointer to rethrow 304 /// has been saved. 305 llvm::AllocaInst *SavedExnVar; 306 307 public: 308 void enter(CodeGenFunction &CGF, const Stmt *Finally, 309 llvm::Constant *beginCatchFn, llvm::Constant *endCatchFn, 310 llvm::Constant *rethrowFn); 311 void exit(CodeGenFunction &CGF); 312 }; 313 314 /// pushFullExprCleanup - Push a cleanup to be run at the end of the 315 /// current full-expression. Safe against the possibility that 316 /// we're currently inside a conditionally-evaluated expression. 317 template <class T, class A0> 318 void pushFullExprCleanup(CleanupKind kind, A0 a0) { 319 // If we're not in a conditional branch, or if none of the 320 // arguments requires saving, then use the unconditional cleanup. 321 if (!isInConditionalBranch()) 322 return EHStack.pushCleanup<T>(kind, a0); 323 324 typename DominatingValue<A0>::saved_type a0_saved = saveValueInCond(a0); 325 326 typedef EHScopeStack::ConditionalCleanup1<T, A0> CleanupType; 327 EHStack.pushCleanup<CleanupType>(kind, a0_saved); 328 initFullExprCleanup(); 329 } 330 331 /// pushFullExprCleanup - Push a cleanup to be run at the end of the 332 /// current full-expression. Safe against the possibility that 333 /// we're currently inside a conditionally-evaluated expression. 334 template <class T, class A0, class A1> 335 void pushFullExprCleanup(CleanupKind kind, A0 a0, A1 a1) { 336 // If we're not in a conditional branch, or if none of the 337 // arguments requires saving, then use the unconditional cleanup. 338 if (!isInConditionalBranch()) 339 return EHStack.pushCleanup<T>(kind, a0, a1); 340 341 typename DominatingValue<A0>::saved_type a0_saved = saveValueInCond(a0); 342 typename DominatingValue<A1>::saved_type a1_saved = saveValueInCond(a1); 343 344 typedef EHScopeStack::ConditionalCleanup2<T, A0, A1> CleanupType; 345 EHStack.pushCleanup<CleanupType>(kind, a0_saved, a1_saved); 346 initFullExprCleanup(); 347 } 348 349 /// pushFullExprCleanup - Push a cleanup to be run at the end of the 350 /// current full-expression. Safe against the possibility that 351 /// we're currently inside a conditionally-evaluated expression. 352 template <class T, class A0, class A1, class A2> 353 void pushFullExprCleanup(CleanupKind kind, A0 a0, A1 a1, A2 a2) { 354 // If we're not in a conditional branch, or if none of the 355 // arguments requires saving, then use the unconditional cleanup. 356 if (!isInConditionalBranch()) { 357 return EHStack.pushCleanup<T>(kind, a0, a1, a2); 358 } 359 360 typename DominatingValue<A0>::saved_type a0_saved = saveValueInCond(a0); 361 typename DominatingValue<A1>::saved_type a1_saved = saveValueInCond(a1); 362 typename DominatingValue<A2>::saved_type a2_saved = saveValueInCond(a2); 363 364 typedef EHScopeStack::ConditionalCleanup3<T, A0, A1, A2> CleanupType; 365 EHStack.pushCleanup<CleanupType>(kind, a0_saved, a1_saved, a2_saved); 366 initFullExprCleanup(); 367 } 368 369 /// pushFullExprCleanup - Push a cleanup to be run at the end of the 370 /// current full-expression. Safe against the possibility that 371 /// we're currently inside a conditionally-evaluated expression. 372 template <class T, class A0, class A1, class A2, class A3> 373 void pushFullExprCleanup(CleanupKind kind, A0 a0, A1 a1, A2 a2, A3 a3) { 374 // If we're not in a conditional branch, or if none of the 375 // arguments requires saving, then use the unconditional cleanup. 376 if (!isInConditionalBranch()) { 377 return EHStack.pushCleanup<T>(kind, a0, a1, a2, a3); 378 } 379 380 typename DominatingValue<A0>::saved_type a0_saved = saveValueInCond(a0); 381 typename DominatingValue<A1>::saved_type a1_saved = saveValueInCond(a1); 382 typename DominatingValue<A2>::saved_type a2_saved = saveValueInCond(a2); 383 typename DominatingValue<A3>::saved_type a3_saved = saveValueInCond(a3); 384 385 typedef EHScopeStack::ConditionalCleanup4<T, A0, A1, A2, A3> CleanupType; 386 EHStack.pushCleanup<CleanupType>(kind, a0_saved, a1_saved, 387 a2_saved, a3_saved); 388 initFullExprCleanup(); 389 } 390 391 /// \brief Queue a cleanup to be pushed after finishing the current 392 /// full-expression. 393 template <class T, class A0, class A1, class A2, class A3> 394 void pushCleanupAfterFullExpr(CleanupKind Kind, A0 a0, A1 a1, A2 a2, A3 a3) { 395 assert(!isInConditionalBranch() && "can't defer conditional cleanup"); 396 397 LifetimeExtendedCleanupHeader Header = { sizeof(T), Kind }; 398 399 size_t OldSize = LifetimeExtendedCleanupStack.size(); 400 LifetimeExtendedCleanupStack.resize( 401 LifetimeExtendedCleanupStack.size() + sizeof(Header) + Header.Size); 402 403 char *Buffer = &LifetimeExtendedCleanupStack[OldSize]; 404 new (Buffer) LifetimeExtendedCleanupHeader(Header); 405 new (Buffer + sizeof(Header)) T(a0, a1, a2, a3); 406 } 407 408 /// Set up the last cleaup that was pushed as a conditional 409 /// full-expression cleanup. 410 void initFullExprCleanup(); 411 412 /// PushDestructorCleanup - Push a cleanup to call the 413 /// complete-object destructor of an object of the given type at the 414 /// given address. Does nothing if T is not a C++ class type with a 415 /// non-trivial destructor. 416 void PushDestructorCleanup(QualType T, llvm::Value *Addr); 417 418 /// PushDestructorCleanup - Push a cleanup to call the 419 /// complete-object variant of the given destructor on the object at 420 /// the given address. 421 void PushDestructorCleanup(const CXXDestructorDecl *Dtor, 422 llvm::Value *Addr); 423 424 /// PopCleanupBlock - Will pop the cleanup entry on the stack and 425 /// process all branch fixups. 426 void PopCleanupBlock(bool FallThroughIsBranchThrough = false); 427 428 /// DeactivateCleanupBlock - Deactivates the given cleanup block. 429 /// The block cannot be reactivated. Pops it if it's the top of the 430 /// stack. 431 /// 432 /// \param DominatingIP - An instruction which is known to 433 /// dominate the current IP (if set) and which lies along 434 /// all paths of execution between the current IP and the 435 /// the point at which the cleanup comes into scope. 436 void DeactivateCleanupBlock(EHScopeStack::stable_iterator Cleanup, 437 llvm::Instruction *DominatingIP); 438 439 /// ActivateCleanupBlock - Activates an initially-inactive cleanup. 440 /// Cannot be used to resurrect a deactivated cleanup. 441 /// 442 /// \param DominatingIP - An instruction which is known to 443 /// dominate the current IP (if set) and which lies along 444 /// all paths of execution between the current IP and the 445 /// the point at which the cleanup comes into scope. 446 void ActivateCleanupBlock(EHScopeStack::stable_iterator Cleanup, 447 llvm::Instruction *DominatingIP); 448 449 /// \brief Enters a new scope for capturing cleanups, all of which 450 /// will be executed once the scope is exited. 451 class RunCleanupsScope { 452 EHScopeStack::stable_iterator CleanupStackDepth; 453 size_t LifetimeExtendedCleanupStackSize; 454 bool OldDidCallStackSave; 455 protected: 456 bool PerformCleanup; 457 private: 458 459 RunCleanupsScope(const RunCleanupsScope &) LLVM_DELETED_FUNCTION; 460 void operator=(const RunCleanupsScope &) LLVM_DELETED_FUNCTION; 461 462 protected: 463 CodeGenFunction& CGF; 464 465 public: 466 /// \brief Enter a new cleanup scope. 467 explicit RunCleanupsScope(CodeGenFunction &CGF) 468 : PerformCleanup(true), CGF(CGF) 469 { 470 CleanupStackDepth = CGF.EHStack.stable_begin(); 471 LifetimeExtendedCleanupStackSize = 472 CGF.LifetimeExtendedCleanupStack.size(); 473 OldDidCallStackSave = CGF.DidCallStackSave; 474 CGF.DidCallStackSave = false; 475 } 476 477 /// \brief Exit this cleanup scope, emitting any accumulated 478 /// cleanups. 479 ~RunCleanupsScope() { 480 if (PerformCleanup) { 481 CGF.DidCallStackSave = OldDidCallStackSave; 482 CGF.PopCleanupBlocks(CleanupStackDepth, 483 LifetimeExtendedCleanupStackSize); 484 } 485 } 486 487 /// \brief Determine whether this scope requires any cleanups. 488 bool requiresCleanups() const { 489 return CGF.EHStack.stable_begin() != CleanupStackDepth; 490 } 491 492 /// \brief Force the emission of cleanups now, instead of waiting 493 /// until this object is destroyed. 494 void ForceCleanup() { 495 assert(PerformCleanup && "Already forced cleanup"); 496 CGF.DidCallStackSave = OldDidCallStackSave; 497 CGF.PopCleanupBlocks(CleanupStackDepth, 498 LifetimeExtendedCleanupStackSize); 499 PerformCleanup = false; 500 } 501 }; 502 503 class LexicalScope: protected RunCleanupsScope { 504 SourceRange Range; 505 SmallVector<const LabelDecl*, 4> Labels; 506 LexicalScope *ParentScope; 507 508 LexicalScope(const LexicalScope &) LLVM_DELETED_FUNCTION; 509 void operator=(const LexicalScope &) LLVM_DELETED_FUNCTION; 510 511 public: 512 /// \brief Enter a new cleanup scope. 513 explicit LexicalScope(CodeGenFunction &CGF, SourceRange Range) 514 : RunCleanupsScope(CGF), Range(Range), ParentScope(CGF.CurLexicalScope) { 515 CGF.CurLexicalScope = this; 516 if (CGDebugInfo *DI = CGF.getDebugInfo()) 517 DI->EmitLexicalBlockStart(CGF.Builder, Range.getBegin()); 518 } 519 520 void addLabel(const LabelDecl *label) { 521 assert(PerformCleanup && "adding label to dead scope?"); 522 Labels.push_back(label); 523 } 524 525 /// \brief Exit this cleanup scope, emitting any accumulated 526 /// cleanups. 527 ~LexicalScope() { 528 if (CGDebugInfo *DI = CGF.getDebugInfo()) 529 DI->EmitLexicalBlockEnd(CGF.Builder, Range.getEnd()); 530 531 // If we should perform a cleanup, force them now. Note that 532 // this ends the cleanup scope before rescoping any labels. 533 if (PerformCleanup) ForceCleanup(); 534 } 535 536 /// \brief Force the emission of cleanups now, instead of waiting 537 /// until this object is destroyed. 538 void ForceCleanup() { 539 CGF.CurLexicalScope = ParentScope; 540 RunCleanupsScope::ForceCleanup(); 541 542 if (!Labels.empty()) 543 rescopeLabels(); 544 } 545 546 void rescopeLabels(); 547 }; 548 549 550 /// \brief Takes the old cleanup stack size and emits the cleanup blocks 551 /// that have been added. 552 void PopCleanupBlocks(EHScopeStack::stable_iterator OldCleanupStackSize); 553 554 /// \brief Takes the old cleanup stack size and emits the cleanup blocks 555 /// that have been added, then adds all lifetime-extended cleanups from 556 /// the given position to the stack. 557 void PopCleanupBlocks(EHScopeStack::stable_iterator OldCleanupStackSize, 558 size_t OldLifetimeExtendedStackSize); 559 560 void ResolveBranchFixups(llvm::BasicBlock *Target); 561 562 /// The given basic block lies in the current EH scope, but may be a 563 /// target of a potentially scope-crossing jump; get a stable handle 564 /// to which we can perform this jump later. 565 JumpDest getJumpDestInCurrentScope(llvm::BasicBlock *Target) { 566 return JumpDest(Target, 567 EHStack.getInnermostNormalCleanup(), 568 NextCleanupDestIndex++); 569 } 570 571 /// The given basic block lies in the current EH scope, but may be a 572 /// target of a potentially scope-crossing jump; get a stable handle 573 /// to which we can perform this jump later. 574 JumpDest getJumpDestInCurrentScope(StringRef Name = StringRef()) { 575 return getJumpDestInCurrentScope(createBasicBlock(Name)); 576 } 577 578 /// EmitBranchThroughCleanup - Emit a branch from the current insert 579 /// block through the normal cleanup handling code (if any) and then 580 /// on to \arg Dest. 581 void EmitBranchThroughCleanup(JumpDest Dest); 582 583 /// isObviouslyBranchWithoutCleanups - Return true if a branch to the 584 /// specified destination obviously has no cleanups to run. 'false' is always 585 /// a conservatively correct answer for this method. 586 bool isObviouslyBranchWithoutCleanups(JumpDest Dest) const; 587 588 /// popCatchScope - Pops the catch scope at the top of the EHScope 589 /// stack, emitting any required code (other than the catch handlers 590 /// themselves). 591 void popCatchScope(); 592 593 llvm::BasicBlock *getEHResumeBlock(bool isCleanup); 594 llvm::BasicBlock *getEHDispatchBlock(EHScopeStack::stable_iterator scope); 595 596 /// An object to manage conditionally-evaluated expressions. 597 class ConditionalEvaluation { 598 llvm::BasicBlock *StartBB; 599 600 public: 601 ConditionalEvaluation(CodeGenFunction &CGF) 602 : StartBB(CGF.Builder.GetInsertBlock()) {} 603 604 void begin(CodeGenFunction &CGF) { 605 assert(CGF.OutermostConditional != this); 606 if (!CGF.OutermostConditional) 607 CGF.OutermostConditional = this; 608 } 609 610 void end(CodeGenFunction &CGF) { 611 assert(CGF.OutermostConditional != 0); 612 if (CGF.OutermostConditional == this) 613 CGF.OutermostConditional = 0; 614 } 615 616 /// Returns a block which will be executed prior to each 617 /// evaluation of the conditional code. 618 llvm::BasicBlock *getStartingBlock() const { 619 return StartBB; 620 } 621 }; 622 623 /// isInConditionalBranch - Return true if we're currently emitting 624 /// one branch or the other of a conditional expression. 625 bool isInConditionalBranch() const { return OutermostConditional != 0; } 626 627 void setBeforeOutermostConditional(llvm::Value *value, llvm::Value *addr) { 628 assert(isInConditionalBranch()); 629 llvm::BasicBlock *block = OutermostConditional->getStartingBlock(); 630 new llvm::StoreInst(value, addr, &block->back()); 631 } 632 633 /// An RAII object to record that we're evaluating a statement 634 /// expression. 635 class StmtExprEvaluation { 636 CodeGenFunction &CGF; 637 638 /// We have to save the outermost conditional: cleanups in a 639 /// statement expression aren't conditional just because the 640 /// StmtExpr is. 641 ConditionalEvaluation *SavedOutermostConditional; 642 643 public: 644 StmtExprEvaluation(CodeGenFunction &CGF) 645 : CGF(CGF), SavedOutermostConditional(CGF.OutermostConditional) { 646 CGF.OutermostConditional = 0; 647 } 648 649 ~StmtExprEvaluation() { 650 CGF.OutermostConditional = SavedOutermostConditional; 651 CGF.EnsureInsertPoint(); 652 } 653 }; 654 655 /// An object which temporarily prevents a value from being 656 /// destroyed by aggressive peephole optimizations that assume that 657 /// all uses of a value have been realized in the IR. 658 class PeepholeProtection { 659 llvm::Instruction *Inst; 660 friend class CodeGenFunction; 661 662 public: 663 PeepholeProtection() : Inst(0) {} 664 }; 665 666 /// A non-RAII class containing all the information about a bound 667 /// opaque value. OpaqueValueMapping, below, is a RAII wrapper for 668 /// this which makes individual mappings very simple; using this 669 /// class directly is useful when you have a variable number of 670 /// opaque values or don't want the RAII functionality for some 671 /// reason. 672 class OpaqueValueMappingData { 673 const OpaqueValueExpr *OpaqueValue; 674 bool BoundLValue; 675 CodeGenFunction::PeepholeProtection Protection; 676 677 OpaqueValueMappingData(const OpaqueValueExpr *ov, 678 bool boundLValue) 679 : OpaqueValue(ov), BoundLValue(boundLValue) {} 680 public: 681 OpaqueValueMappingData() : OpaqueValue(0) {} 682 683 static bool shouldBindAsLValue(const Expr *expr) { 684 // gl-values should be bound as l-values for obvious reasons. 685 // Records should be bound as l-values because IR generation 686 // always keeps them in memory. Expressions of function type 687 // act exactly like l-values but are formally required to be 688 // r-values in C. 689 return expr->isGLValue() || 690 expr->getType()->isRecordType() || 691 expr->getType()->isFunctionType(); 692 } 693 694 static OpaqueValueMappingData bind(CodeGenFunction &CGF, 695 const OpaqueValueExpr *ov, 696 const Expr *e) { 697 if (shouldBindAsLValue(ov)) 698 return bind(CGF, ov, CGF.EmitLValue(e)); 699 return bind(CGF, ov, CGF.EmitAnyExpr(e)); 700 } 701 702 static OpaqueValueMappingData bind(CodeGenFunction &CGF, 703 const OpaqueValueExpr *ov, 704 const LValue &lv) { 705 assert(shouldBindAsLValue(ov)); 706 CGF.OpaqueLValues.insert(std::make_pair(ov, lv)); 707 return OpaqueValueMappingData(ov, true); 708 } 709 710 static OpaqueValueMappingData bind(CodeGenFunction &CGF, 711 const OpaqueValueExpr *ov, 712 const RValue &rv) { 713 assert(!shouldBindAsLValue(ov)); 714 CGF.OpaqueRValues.insert(std::make_pair(ov, rv)); 715 716 OpaqueValueMappingData data(ov, false); 717 718 // Work around an extremely aggressive peephole optimization in 719 // EmitScalarConversion which assumes that all other uses of a 720 // value are extant. 721 data.Protection = CGF.protectFromPeepholes(rv); 722 723 return data; 724 } 725 726 bool isValid() const { return OpaqueValue != 0; } 727 void clear() { OpaqueValue = 0; } 728 729 void unbind(CodeGenFunction &CGF) { 730 assert(OpaqueValue && "no data to unbind!"); 731 732 if (BoundLValue) { 733 CGF.OpaqueLValues.erase(OpaqueValue); 734 } else { 735 CGF.OpaqueRValues.erase(OpaqueValue); 736 CGF.unprotectFromPeepholes(Protection); 737 } 738 } 739 }; 740 741 /// An RAII object to set (and then clear) a mapping for an OpaqueValueExpr. 742 class OpaqueValueMapping { 743 CodeGenFunction &CGF; 744 OpaqueValueMappingData Data; 745 746 public: 747 static bool shouldBindAsLValue(const Expr *expr) { 748 return OpaqueValueMappingData::shouldBindAsLValue(expr); 749 } 750 751 /// Build the opaque value mapping for the given conditional 752 /// operator if it's the GNU ?: extension. This is a common 753 /// enough pattern that the convenience operator is really 754 /// helpful. 755 /// 756 OpaqueValueMapping(CodeGenFunction &CGF, 757 const AbstractConditionalOperator *op) : CGF(CGF) { 758 if (isa<ConditionalOperator>(op)) 759 // Leave Data empty. 760 return; 761 762 const BinaryConditionalOperator *e = cast<BinaryConditionalOperator>(op); 763 Data = OpaqueValueMappingData::bind(CGF, e->getOpaqueValue(), 764 e->getCommon()); 765 } 766 767 OpaqueValueMapping(CodeGenFunction &CGF, 768 const OpaqueValueExpr *opaqueValue, 769 LValue lvalue) 770 : CGF(CGF), Data(OpaqueValueMappingData::bind(CGF, opaqueValue, lvalue)) { 771 } 772 773 OpaqueValueMapping(CodeGenFunction &CGF, 774 const OpaqueValueExpr *opaqueValue, 775 RValue rvalue) 776 : CGF(CGF), Data(OpaqueValueMappingData::bind(CGF, opaqueValue, rvalue)) { 777 } 778 779 void pop() { 780 Data.unbind(CGF); 781 Data.clear(); 782 } 783 784 ~OpaqueValueMapping() { 785 if (Data.isValid()) Data.unbind(CGF); 786 } 787 }; 788 789 /// getByrefValueFieldNumber - Given a declaration, returns the LLVM field 790 /// number that holds the value. 791 unsigned getByRefValueLLVMField(const ValueDecl *VD) const; 792 793 /// BuildBlockByrefAddress - Computes address location of the 794 /// variable which is declared as __block. 795 llvm::Value *BuildBlockByrefAddress(llvm::Value *BaseAddr, 796 const VarDecl *V); 797private: 798 CGDebugInfo *DebugInfo; 799 bool DisableDebugInfo; 800 801 /// DidCallStackSave - Whether llvm.stacksave has been called. Used to avoid 802 /// calling llvm.stacksave for multiple VLAs in the same scope. 803 bool DidCallStackSave; 804 805 /// IndirectBranch - The first time an indirect goto is seen we create a block 806 /// with an indirect branch. Every time we see the address of a label taken, 807 /// we add the label to the indirect goto. Every subsequent indirect goto is 808 /// codegen'd as a jump to the IndirectBranch's basic block. 809 llvm::IndirectBrInst *IndirectBranch; 810 811 /// LocalDeclMap - This keeps track of the LLVM allocas or globals for local C 812 /// decls. 813 typedef llvm::DenseMap<const Decl*, llvm::Value*> DeclMapTy; 814 DeclMapTy LocalDeclMap; 815 816 /// LabelMap - This keeps track of the LLVM basic block for each C label. 817 llvm::DenseMap<const LabelDecl*, JumpDest> LabelMap; 818 819 // BreakContinueStack - This keeps track of where break and continue 820 // statements should jump to. 821 struct BreakContinue { 822 BreakContinue(JumpDest Break, JumpDest Continue) 823 : BreakBlock(Break), ContinueBlock(Continue) {} 824 825 JumpDest BreakBlock; 826 JumpDest ContinueBlock; 827 }; 828 SmallVector<BreakContinue, 8> BreakContinueStack; 829 830 /// SwitchInsn - This is nearest current switch instruction. It is null if 831 /// current context is not in a switch. 832 llvm::SwitchInst *SwitchInsn; 833 834 /// CaseRangeBlock - This block holds if condition check for last case 835 /// statement range in current switch instruction. 836 llvm::BasicBlock *CaseRangeBlock; 837 838 /// OpaqueLValues - Keeps track of the current set of opaque value 839 /// expressions. 840 llvm::DenseMap<const OpaqueValueExpr *, LValue> OpaqueLValues; 841 llvm::DenseMap<const OpaqueValueExpr *, RValue> OpaqueRValues; 842 843 // VLASizeMap - This keeps track of the associated size for each VLA type. 844 // We track this by the size expression rather than the type itself because 845 // in certain situations, like a const qualifier applied to an VLA typedef, 846 // multiple VLA types can share the same size expression. 847 // FIXME: Maybe this could be a stack of maps that is pushed/popped as we 848 // enter/leave scopes. 849 llvm::DenseMap<const Expr*, llvm::Value*> VLASizeMap; 850 851 /// A block containing a single 'unreachable' instruction. Created 852 /// lazily by getUnreachableBlock(). 853 llvm::BasicBlock *UnreachableBlock; 854 855 /// Counts of the number return expressions in the function. 856 unsigned NumReturnExprs; 857 858 /// Count the number of simple (constant) return expressions in the function. 859 unsigned NumSimpleReturnExprs; 860 861 /// The last regular (non-return) debug location (breakpoint) in the function. 862 SourceLocation LastStopPoint; 863 864public: 865 /// A scope within which we are constructing the fields of an object which 866 /// might use a CXXDefaultInitExpr. This stashes away a 'this' value to use 867 /// if we need to evaluate a CXXDefaultInitExpr within the evaluation. 868 class FieldConstructionScope { 869 public: 870 FieldConstructionScope(CodeGenFunction &CGF, llvm::Value *This) 871 : CGF(CGF), OldCXXDefaultInitExprThis(CGF.CXXDefaultInitExprThis) { 872 CGF.CXXDefaultInitExprThis = This; 873 } 874 ~FieldConstructionScope() { 875 CGF.CXXDefaultInitExprThis = OldCXXDefaultInitExprThis; 876 } 877 878 private: 879 CodeGenFunction &CGF; 880 llvm::Value *OldCXXDefaultInitExprThis; 881 }; 882 883 /// The scope of a CXXDefaultInitExpr. Within this scope, the value of 'this' 884 /// is overridden to be the object under construction. 885 class CXXDefaultInitExprScope { 886 public: 887 CXXDefaultInitExprScope(CodeGenFunction &CGF) 888 : CGF(CGF), OldCXXThisValue(CGF.CXXThisValue) { 889 CGF.CXXThisValue = CGF.CXXDefaultInitExprThis; 890 } 891 ~CXXDefaultInitExprScope() { 892 CGF.CXXThisValue = OldCXXThisValue; 893 } 894 895 public: 896 CodeGenFunction &CGF; 897 llvm::Value *OldCXXThisValue; 898 }; 899 900private: 901 /// CXXThisDecl - When generating code for a C++ member function, 902 /// this will hold the implicit 'this' declaration. 903 ImplicitParamDecl *CXXABIThisDecl; 904 llvm::Value *CXXABIThisValue; 905 llvm::Value *CXXThisValue; 906 907 /// The value of 'this' to use when evaluating CXXDefaultInitExprs within 908 /// this expression. 909 llvm::Value *CXXDefaultInitExprThis; 910 911 /// CXXStructorImplicitParamDecl - When generating code for a constructor or 912 /// destructor, this will hold the implicit argument (e.g. VTT). 913 ImplicitParamDecl *CXXStructorImplicitParamDecl; 914 llvm::Value *CXXStructorImplicitParamValue; 915 916 /// OutermostConditional - Points to the outermost active 917 /// conditional control. This is used so that we know if a 918 /// temporary should be destroyed conditionally. 919 ConditionalEvaluation *OutermostConditional; 920 921 /// The current lexical scope. 922 LexicalScope *CurLexicalScope; 923 924 /// The current source location that should be used for exception 925 /// handling code. 926 SourceLocation CurEHLocation; 927 928 /// ByrefValueInfoMap - For each __block variable, contains a pair of the LLVM 929 /// type as well as the field number that contains the actual data. 930 llvm::DenseMap<const ValueDecl *, std::pair<llvm::Type *, 931 unsigned> > ByRefValueInfo; 932 933 llvm::BasicBlock *TerminateLandingPad; 934 llvm::BasicBlock *TerminateHandler; 935 llvm::BasicBlock *TrapBB; 936 937 /// Add a kernel metadata node to the named metadata node 'opencl.kernels'. 938 /// In the kernel metadata node, reference the kernel function and metadata 939 /// nodes for its optional attribute qualifiers (OpenCL 1.1 6.7.2): 940 /// - A node for the vec_type_hint(<type>) qualifier contains string 941 /// "vec_type_hint", an undefined value of the <type> data type, 942 /// and a Boolean that is true if the <type> is integer and signed. 943 /// - A node for the work_group_size_hint(X,Y,Z) qualifier contains string 944 /// "work_group_size_hint", and three 32-bit integers X, Y and Z. 945 /// - A node for the reqd_work_group_size(X,Y,Z) qualifier contains string 946 /// "reqd_work_group_size", and three 32-bit integers X, Y and Z. 947 void EmitOpenCLKernelMetadata(const FunctionDecl *FD, 948 llvm::Function *Fn); 949 950public: 951 CodeGenFunction(CodeGenModule &cgm, bool suppressNewContext=false); 952 ~CodeGenFunction(); 953 954 CodeGenTypes &getTypes() const { return CGM.getTypes(); } 955 ASTContext &getContext() const { return CGM.getContext(); } 956 CGDebugInfo *getDebugInfo() { 957 if (DisableDebugInfo) 958 return NULL; 959 return DebugInfo; 960 } 961 void disableDebugInfo() { DisableDebugInfo = true; } 962 void enableDebugInfo() { DisableDebugInfo = false; } 963 964 bool shouldUseFusedARCCalls() { 965 return CGM.getCodeGenOpts().OptimizationLevel == 0; 966 } 967 968 const LangOptions &getLangOpts() const { return CGM.getLangOpts(); } 969 970 /// Returns a pointer to the function's exception object and selector slot, 971 /// which is assigned in every landing pad. 972 llvm::Value *getExceptionSlot(); 973 llvm::Value *getEHSelectorSlot(); 974 975 /// Returns the contents of the function's exception object and selector 976 /// slots. 977 llvm::Value *getExceptionFromSlot(); 978 llvm::Value *getSelectorFromSlot(); 979 980 llvm::Value *getNormalCleanupDestSlot(); 981 982 llvm::BasicBlock *getUnreachableBlock() { 983 if (!UnreachableBlock) { 984 UnreachableBlock = createBasicBlock("unreachable"); 985 new llvm::UnreachableInst(getLLVMContext(), UnreachableBlock); 986 } 987 return UnreachableBlock; 988 } 989 990 llvm::BasicBlock *getInvokeDest() { 991 if (!EHStack.requiresLandingPad()) return 0; 992 return getInvokeDestImpl(); 993 } 994 995 const TargetInfo &getTarget() const { return Target; } 996 llvm::LLVMContext &getLLVMContext() { return CGM.getLLVMContext(); } 997 998 //===--------------------------------------------------------------------===// 999 // Cleanups 1000 //===--------------------------------------------------------------------===// 1001 1002 typedef void Destroyer(CodeGenFunction &CGF, llvm::Value *addr, QualType ty); 1003 1004 void pushIrregularPartialArrayCleanup(llvm::Value *arrayBegin, 1005 llvm::Value *arrayEndPointer, 1006 QualType elementType, 1007 Destroyer *destroyer); 1008 void pushRegularPartialArrayCleanup(llvm::Value *arrayBegin, 1009 llvm::Value *arrayEnd, 1010 QualType elementType, 1011 Destroyer *destroyer); 1012 1013 void pushDestroy(QualType::DestructionKind dtorKind, 1014 llvm::Value *addr, QualType type); 1015 void pushEHDestroy(QualType::DestructionKind dtorKind, 1016 llvm::Value *addr, QualType type); 1017 void pushDestroy(CleanupKind kind, llvm::Value *addr, QualType type, 1018 Destroyer *destroyer, bool useEHCleanupForArray); 1019 void pushLifetimeExtendedDestroy(CleanupKind kind, llvm::Value *addr, 1020 QualType type, Destroyer *destroyer, 1021 bool useEHCleanupForArray); 1022 void emitDestroy(llvm::Value *addr, QualType type, Destroyer *destroyer, 1023 bool useEHCleanupForArray); 1024 llvm::Function *generateDestroyHelper(llvm::Constant *addr, QualType type, 1025 Destroyer *destroyer, 1026 bool useEHCleanupForArray, 1027 const VarDecl *VD); 1028 void emitArrayDestroy(llvm::Value *begin, llvm::Value *end, 1029 QualType type, Destroyer *destroyer, 1030 bool checkZeroLength, bool useEHCleanup); 1031 1032 Destroyer *getDestroyer(QualType::DestructionKind destructionKind); 1033 1034 /// Determines whether an EH cleanup is required to destroy a type 1035 /// with the given destruction kind. 1036 bool needsEHCleanup(QualType::DestructionKind kind) { 1037 switch (kind) { 1038 case QualType::DK_none: 1039 return false; 1040 case QualType::DK_cxx_destructor: 1041 case QualType::DK_objc_weak_lifetime: 1042 return getLangOpts().Exceptions; 1043 case QualType::DK_objc_strong_lifetime: 1044 return getLangOpts().Exceptions && 1045 CGM.getCodeGenOpts().ObjCAutoRefCountExceptions; 1046 } 1047 llvm_unreachable("bad destruction kind"); 1048 } 1049 1050 CleanupKind getCleanupKind(QualType::DestructionKind kind) { 1051 return (needsEHCleanup(kind) ? NormalAndEHCleanup : NormalCleanup); 1052 } 1053 1054 //===--------------------------------------------------------------------===// 1055 // Objective-C 1056 //===--------------------------------------------------------------------===// 1057 1058 void GenerateObjCMethod(const ObjCMethodDecl *OMD); 1059 1060 void StartObjCMethod(const ObjCMethodDecl *MD, 1061 const ObjCContainerDecl *CD, 1062 SourceLocation StartLoc); 1063 1064 /// GenerateObjCGetter - Synthesize an Objective-C property getter function. 1065 void GenerateObjCGetter(ObjCImplementationDecl *IMP, 1066 const ObjCPropertyImplDecl *PID); 1067 void generateObjCGetterBody(const ObjCImplementationDecl *classImpl, 1068 const ObjCPropertyImplDecl *propImpl, 1069 const ObjCMethodDecl *GetterMothodDecl, 1070 llvm::Constant *AtomicHelperFn); 1071 1072 void GenerateObjCCtorDtorMethod(ObjCImplementationDecl *IMP, 1073 ObjCMethodDecl *MD, bool ctor); 1074 1075 /// GenerateObjCSetter - Synthesize an Objective-C property setter function 1076 /// for the given property. 1077 void GenerateObjCSetter(ObjCImplementationDecl *IMP, 1078 const ObjCPropertyImplDecl *PID); 1079 void generateObjCSetterBody(const ObjCImplementationDecl *classImpl, 1080 const ObjCPropertyImplDecl *propImpl, 1081 llvm::Constant *AtomicHelperFn); 1082 bool IndirectObjCSetterArg(const CGFunctionInfo &FI); 1083 bool IvarTypeWithAggrGCObjects(QualType Ty); 1084 1085 //===--------------------------------------------------------------------===// 1086 // Block Bits 1087 //===--------------------------------------------------------------------===// 1088 1089 llvm::Value *EmitBlockLiteral(const BlockExpr *); 1090 llvm::Value *EmitBlockLiteral(const CGBlockInfo &Info); 1091 static void destroyBlockInfos(CGBlockInfo *info); 1092 llvm::Constant *BuildDescriptorBlockDecl(const BlockExpr *, 1093 const CGBlockInfo &Info, 1094 llvm::StructType *, 1095 llvm::Constant *BlockVarLayout); 1096 1097 llvm::Function *GenerateBlockFunction(GlobalDecl GD, 1098 const CGBlockInfo &Info, 1099 const DeclMapTy &ldm, 1100 bool IsLambdaConversionToBlock); 1101 1102 llvm::Constant *GenerateCopyHelperFunction(const CGBlockInfo &blockInfo); 1103 llvm::Constant *GenerateDestroyHelperFunction(const CGBlockInfo &blockInfo); 1104 llvm::Constant *GenerateObjCAtomicSetterCopyHelperFunction( 1105 const ObjCPropertyImplDecl *PID); 1106 llvm::Constant *GenerateObjCAtomicGetterCopyHelperFunction( 1107 const ObjCPropertyImplDecl *PID); 1108 llvm::Value *EmitBlockCopyAndAutorelease(llvm::Value *Block, QualType Ty); 1109 1110 void BuildBlockRelease(llvm::Value *DeclPtr, BlockFieldFlags flags); 1111 1112 class AutoVarEmission; 1113 1114 void emitByrefStructureInit(const AutoVarEmission &emission); 1115 void enterByrefCleanup(const AutoVarEmission &emission); 1116 1117 llvm::Value *LoadBlockStruct() { 1118 assert(BlockPointer && "no block pointer set!"); 1119 return BlockPointer; 1120 } 1121 1122 void AllocateBlockCXXThisPointer(const CXXThisExpr *E); 1123 void AllocateBlockDecl(const DeclRefExpr *E); 1124 llvm::Value *GetAddrOfBlockDecl(const VarDecl *var, bool ByRef); 1125 llvm::Type *BuildByRefType(const VarDecl *var); 1126 1127 void GenerateCode(GlobalDecl GD, llvm::Function *Fn, 1128 const CGFunctionInfo &FnInfo); 1129 void StartFunction(GlobalDecl GD, 1130 QualType RetTy, 1131 llvm::Function *Fn, 1132 const CGFunctionInfo &FnInfo, 1133 const FunctionArgList &Args, 1134 SourceLocation StartLoc); 1135 1136 void EmitConstructorBody(FunctionArgList &Args); 1137 void EmitDestructorBody(FunctionArgList &Args); 1138 void emitImplicitAssignmentOperatorBody(FunctionArgList &Args); 1139 void EmitFunctionBody(FunctionArgList &Args, const Stmt *Body); 1140 1141 void EmitForwardingCallToLambda(const CXXMethodDecl *LambdaCallOperator, 1142 CallArgList &CallArgs); 1143 void EmitLambdaToBlockPointerBody(FunctionArgList &Args); 1144 void EmitLambdaBlockInvokeBody(); 1145 void EmitLambdaDelegatingInvokeBody(const CXXMethodDecl *MD); 1146 void EmitLambdaStaticInvokeFunction(const CXXMethodDecl *MD); 1147 1148 /// EmitReturnBlock - Emit the unified return block, trying to avoid its 1149 /// emission when possible. 1150 void EmitReturnBlock(); 1151 1152 /// FinishFunction - Complete IR generation of the current function. It is 1153 /// legal to call this function even if there is no current insertion point. 1154 void FinishFunction(SourceLocation EndLoc=SourceLocation()); 1155 1156 void StartThunk(llvm::Function *Fn, GlobalDecl GD, const CGFunctionInfo &FnInfo); 1157 1158 void EmitCallAndReturnForThunk(GlobalDecl GD, llvm::Value *Callee, 1159 const ThunkInfo *Thunk); 1160 1161 /// GenerateThunk - Generate a thunk for the given method. 1162 void GenerateThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo, 1163 GlobalDecl GD, const ThunkInfo &Thunk); 1164 1165 void GenerateVarArgsThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo, 1166 GlobalDecl GD, const ThunkInfo &Thunk); 1167 1168 void EmitCtorPrologue(const CXXConstructorDecl *CD, CXXCtorType Type, 1169 FunctionArgList &Args); 1170 1171 void EmitInitializerForField(FieldDecl *Field, LValue LHS, Expr *Init, 1172 ArrayRef<VarDecl *> ArrayIndexes); 1173 1174 /// InitializeVTablePointer - Initialize the vtable pointer of the given 1175 /// subobject. 1176 /// 1177 void InitializeVTablePointer(BaseSubobject Base, 1178 const CXXRecordDecl *NearestVBase, 1179 CharUnits OffsetFromNearestVBase, 1180 const CXXRecordDecl *VTableClass); 1181 1182 typedef llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBasesSetTy; 1183 void InitializeVTablePointers(BaseSubobject Base, 1184 const CXXRecordDecl *NearestVBase, 1185 CharUnits OffsetFromNearestVBase, 1186 bool BaseIsNonVirtualPrimaryBase, 1187 const CXXRecordDecl *VTableClass, 1188 VisitedVirtualBasesSetTy& VBases); 1189 1190 void InitializeVTablePointers(const CXXRecordDecl *ClassDecl); 1191 1192 /// GetVTablePtr - Return the Value of the vtable pointer member pointed 1193 /// to by This. 1194 llvm::Value *GetVTablePtr(llvm::Value *This, llvm::Type *Ty); 1195 1196 1197 /// CanDevirtualizeMemberFunctionCalls - Checks whether virtual calls on given 1198 /// expr can be devirtualized. 1199 bool CanDevirtualizeMemberFunctionCall(const Expr *Base, 1200 const CXXMethodDecl *MD); 1201 1202 /// EnterDtorCleanups - Enter the cleanups necessary to complete the 1203 /// given phase of destruction for a destructor. The end result 1204 /// should call destructors on members and base classes in reverse 1205 /// order of their construction. 1206 void EnterDtorCleanups(const CXXDestructorDecl *Dtor, CXXDtorType Type); 1207 1208 /// ShouldInstrumentFunction - Return true if the current function should be 1209 /// instrumented with __cyg_profile_func_* calls 1210 bool ShouldInstrumentFunction(); 1211 1212 /// EmitFunctionInstrumentation - Emit LLVM code to call the specified 1213 /// instrumentation function with the current function and the call site, if 1214 /// function instrumentation is enabled. 1215 void EmitFunctionInstrumentation(const char *Fn); 1216 1217 /// EmitMCountInstrumentation - Emit call to .mcount. 1218 void EmitMCountInstrumentation(); 1219 1220 /// EmitFunctionProlog - Emit the target specific LLVM code to load the 1221 /// arguments for the given function. This is also responsible for naming the 1222 /// LLVM function arguments. 1223 void EmitFunctionProlog(const CGFunctionInfo &FI, 1224 llvm::Function *Fn, 1225 const FunctionArgList &Args); 1226 1227 /// EmitFunctionEpilog - Emit the target specific LLVM code to return the 1228 /// given temporary. 1229 void EmitFunctionEpilog(const CGFunctionInfo &FI, bool EmitRetDbgLoc, 1230 SourceLocation EndLoc); 1231 1232 /// EmitStartEHSpec - Emit the start of the exception spec. 1233 void EmitStartEHSpec(const Decl *D); 1234 1235 /// EmitEndEHSpec - Emit the end of the exception spec. 1236 void EmitEndEHSpec(const Decl *D); 1237 1238 /// getTerminateLandingPad - Return a landing pad that just calls terminate. 1239 llvm::BasicBlock *getTerminateLandingPad(); 1240 1241 /// getTerminateHandler - Return a handler (not a landing pad, just 1242 /// a catch handler) that just calls terminate. This is used when 1243 /// a terminate scope encloses a try. 1244 llvm::BasicBlock *getTerminateHandler(); 1245 1246 llvm::Type *ConvertTypeForMem(QualType T); 1247 llvm::Type *ConvertType(QualType T); 1248 llvm::Type *ConvertType(const TypeDecl *T) { 1249 return ConvertType(getContext().getTypeDeclType(T)); 1250 } 1251 1252 /// LoadObjCSelf - Load the value of self. This function is only valid while 1253 /// generating code for an Objective-C method. 1254 llvm::Value *LoadObjCSelf(); 1255 1256 /// TypeOfSelfObject - Return type of object that this self represents. 1257 QualType TypeOfSelfObject(); 1258 1259 /// hasAggregateLLVMType - Return true if the specified AST type will map into 1260 /// an aggregate LLVM type or is void. 1261 static TypeEvaluationKind getEvaluationKind(QualType T); 1262 1263 static bool hasScalarEvaluationKind(QualType T) { 1264 return getEvaluationKind(T) == TEK_Scalar; 1265 } 1266 1267 static bool hasAggregateEvaluationKind(QualType T) { 1268 return getEvaluationKind(T) == TEK_Aggregate; 1269 } 1270 1271 /// createBasicBlock - Create an LLVM basic block. 1272 llvm::BasicBlock *createBasicBlock(const Twine &name = "", 1273 llvm::Function *parent = 0, 1274 llvm::BasicBlock *before = 0) { 1275#ifdef NDEBUG 1276 return llvm::BasicBlock::Create(getLLVMContext(), "", parent, before); 1277#else 1278 return llvm::BasicBlock::Create(getLLVMContext(), name, parent, before); 1279#endif 1280 } 1281 1282 /// getBasicBlockForLabel - Return the LLVM basicblock that the specified 1283 /// label maps to. 1284 JumpDest getJumpDestForLabel(const LabelDecl *S); 1285 1286 /// SimplifyForwardingBlocks - If the given basic block is only a branch to 1287 /// another basic block, simplify it. This assumes that no other code could 1288 /// potentially reference the basic block. 1289 void SimplifyForwardingBlocks(llvm::BasicBlock *BB); 1290 1291 /// EmitBlock - Emit the given block \arg BB and set it as the insert point, 1292 /// adding a fall-through branch from the current insert block if 1293 /// necessary. It is legal to call this function even if there is no current 1294 /// insertion point. 1295 /// 1296 /// IsFinished - If true, indicates that the caller has finished emitting 1297 /// branches to the given block and does not expect to emit code into it. This 1298 /// means the block can be ignored if it is unreachable. 1299 void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false); 1300 1301 /// EmitBlockAfterUses - Emit the given block somewhere hopefully 1302 /// near its uses, and leave the insertion point in it. 1303 void EmitBlockAfterUses(llvm::BasicBlock *BB); 1304 1305 /// EmitBranch - Emit a branch to the specified basic block from the current 1306 /// insert block, taking care to avoid creation of branches from dummy 1307 /// blocks. It is legal to call this function even if there is no current 1308 /// insertion point. 1309 /// 1310 /// This function clears the current insertion point. The caller should follow 1311 /// calls to this function with calls to Emit*Block prior to generation new 1312 /// code. 1313 void EmitBranch(llvm::BasicBlock *Block); 1314 1315 /// HaveInsertPoint - True if an insertion point is defined. If not, this 1316 /// indicates that the current code being emitted is unreachable. 1317 bool HaveInsertPoint() const { 1318 return Builder.GetInsertBlock() != 0; 1319 } 1320 1321 /// EnsureInsertPoint - Ensure that an insertion point is defined so that 1322 /// emitted IR has a place to go. Note that by definition, if this function 1323 /// creates a block then that block is unreachable; callers may do better to 1324 /// detect when no insertion point is defined and simply skip IR generation. 1325 void EnsureInsertPoint() { 1326 if (!HaveInsertPoint()) 1327 EmitBlock(createBasicBlock()); 1328 } 1329 1330 /// ErrorUnsupported - Print out an error that codegen doesn't support the 1331 /// specified stmt yet. 1332 void ErrorUnsupported(const Stmt *S, const char *Type); 1333 1334 //===--------------------------------------------------------------------===// 1335 // Helpers 1336 //===--------------------------------------------------------------------===// 1337 1338 LValue MakeAddrLValue(llvm::Value *V, QualType T, 1339 CharUnits Alignment = CharUnits()) { 1340 return LValue::MakeAddr(V, T, Alignment, getContext(), 1341 CGM.getTBAAInfo(T)); 1342 } 1343 1344 LValue MakeNaturalAlignAddrLValue(llvm::Value *V, QualType T) { 1345 CharUnits Alignment; 1346 if (!T->isIncompleteType()) 1347 Alignment = getContext().getTypeAlignInChars(T); 1348 return LValue::MakeAddr(V, T, Alignment, getContext(), 1349 CGM.getTBAAInfo(T)); 1350 } 1351 1352 /// CreateTempAlloca - This creates a alloca and inserts it into the entry 1353 /// block. The caller is responsible for setting an appropriate alignment on 1354 /// the alloca. 1355 llvm::AllocaInst *CreateTempAlloca(llvm::Type *Ty, 1356 const Twine &Name = "tmp"); 1357 1358 /// InitTempAlloca - Provide an initial value for the given alloca. 1359 void InitTempAlloca(llvm::AllocaInst *Alloca, llvm::Value *Value); 1360 1361 /// CreateIRTemp - Create a temporary IR object of the given type, with 1362 /// appropriate alignment. This routine should only be used when an temporary 1363 /// value needs to be stored into an alloca (for example, to avoid explicit 1364 /// PHI construction), but the type is the IR type, not the type appropriate 1365 /// for storing in memory. 1366 llvm::AllocaInst *CreateIRTemp(QualType T, const Twine &Name = "tmp"); 1367 1368 /// CreateMemTemp - Create a temporary memory object of the given type, with 1369 /// appropriate alignment. 1370 llvm::AllocaInst *CreateMemTemp(QualType T, const Twine &Name = "tmp"); 1371 1372 /// CreateAggTemp - Create a temporary memory object for the given 1373 /// aggregate type. 1374 AggValueSlot CreateAggTemp(QualType T, const Twine &Name = "tmp") { 1375 CharUnits Alignment = getContext().getTypeAlignInChars(T); 1376 return AggValueSlot::forAddr(CreateMemTemp(T, Name), Alignment, 1377 T.getQualifiers(), 1378 AggValueSlot::IsNotDestructed, 1379 AggValueSlot::DoesNotNeedGCBarriers, 1380 AggValueSlot::IsNotAliased); 1381 } 1382 1383 /// Emit a cast to void* in the appropriate address space. 1384 llvm::Value *EmitCastToVoidPtr(llvm::Value *value); 1385 1386 /// EvaluateExprAsBool - Perform the usual unary conversions on the specified 1387 /// expression and compare the result against zero, returning an Int1Ty value. 1388 llvm::Value *EvaluateExprAsBool(const Expr *E); 1389 1390 /// EmitIgnoredExpr - Emit an expression in a context which ignores the result. 1391 void EmitIgnoredExpr(const Expr *E); 1392 1393 /// EmitAnyExpr - Emit code to compute the specified expression which can have 1394 /// any type. The result is returned as an RValue struct. If this is an 1395 /// aggregate expression, the aggloc/agglocvolatile arguments indicate where 1396 /// the result should be returned. 1397 /// 1398 /// \param ignoreResult True if the resulting value isn't used. 1399 RValue EmitAnyExpr(const Expr *E, 1400 AggValueSlot aggSlot = AggValueSlot::ignored(), 1401 bool ignoreResult = false); 1402 1403 // EmitVAListRef - Emit a "reference" to a va_list; this is either the address 1404 // or the value of the expression, depending on how va_list is defined. 1405 llvm::Value *EmitVAListRef(const Expr *E); 1406 1407 /// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result will 1408 /// always be accessible even if no aggregate location is provided. 1409 RValue EmitAnyExprToTemp(const Expr *E); 1410 1411 /// EmitAnyExprToMem - Emits the code necessary to evaluate an 1412 /// arbitrary expression into the given memory location. 1413 void EmitAnyExprToMem(const Expr *E, llvm::Value *Location, 1414 Qualifiers Quals, bool IsInitializer); 1415 1416 /// EmitExprAsInit - Emits the code necessary to initialize a 1417 /// location in memory with the given initializer. 1418 void EmitExprAsInit(const Expr *init, const ValueDecl *D, 1419 LValue lvalue, bool capturedByInit); 1420 1421 /// hasVolatileMember - returns true if aggregate type has a volatile 1422 /// member. 1423 bool hasVolatileMember(QualType T) { 1424 if (const RecordType *RT = T->getAs<RecordType>()) { 1425 const RecordDecl *RD = cast<RecordDecl>(RT->getDecl()); 1426 return RD->hasVolatileMember(); 1427 } 1428 return false; 1429 } 1430 /// EmitAggregateCopy - Emit an aggregate assignment. 1431 /// 1432 /// The difference to EmitAggregateCopy is that tail padding is not copied. 1433 /// This is required for correctness when assigning non-POD structures in C++. 1434 void EmitAggregateAssign(llvm::Value *DestPtr, llvm::Value *SrcPtr, 1435 QualType EltTy) { 1436 bool IsVolatile = hasVolatileMember(EltTy); 1437 EmitAggregateCopy(DestPtr, SrcPtr, EltTy, IsVolatile, CharUnits::Zero(), 1438 true); 1439 } 1440 1441 /// EmitAggregateCopy - Emit an aggregate copy. 1442 /// 1443 /// \param isVolatile - True iff either the source or the destination is 1444 /// volatile. 1445 /// \param isAssignment - If false, allow padding to be copied. This often 1446 /// yields more efficient. 1447 void EmitAggregateCopy(llvm::Value *DestPtr, llvm::Value *SrcPtr, 1448 QualType EltTy, bool isVolatile=false, 1449 CharUnits Alignment = CharUnits::Zero(), 1450 bool isAssignment = false); 1451 1452 /// StartBlock - Start new block named N. If insert block is a dummy block 1453 /// then reuse it. 1454 void StartBlock(const char *N); 1455 1456 /// GetAddrOfLocalVar - Return the address of a local variable. 1457 llvm::Value *GetAddrOfLocalVar(const VarDecl *VD) { 1458 llvm::Value *Res = LocalDeclMap[VD]; 1459 assert(Res && "Invalid argument to GetAddrOfLocalVar(), no decl!"); 1460 return Res; 1461 } 1462 1463 /// getOpaqueLValueMapping - Given an opaque value expression (which 1464 /// must be mapped to an l-value), return its mapping. 1465 const LValue &getOpaqueLValueMapping(const OpaqueValueExpr *e) { 1466 assert(OpaqueValueMapping::shouldBindAsLValue(e)); 1467 1468 llvm::DenseMap<const OpaqueValueExpr*,LValue>::iterator 1469 it = OpaqueLValues.find(e); 1470 assert(it != OpaqueLValues.end() && "no mapping for opaque value!"); 1471 return it->second; 1472 } 1473 1474 /// getOpaqueRValueMapping - Given an opaque value expression (which 1475 /// must be mapped to an r-value), return its mapping. 1476 const RValue &getOpaqueRValueMapping(const OpaqueValueExpr *e) { 1477 assert(!OpaqueValueMapping::shouldBindAsLValue(e)); 1478 1479 llvm::DenseMap<const OpaqueValueExpr*,RValue>::iterator 1480 it = OpaqueRValues.find(e); 1481 assert(it != OpaqueRValues.end() && "no mapping for opaque value!"); 1482 return it->second; 1483 } 1484 1485 /// getAccessedFieldNo - Given an encoded value and a result number, return 1486 /// the input field number being accessed. 1487 static unsigned getAccessedFieldNo(unsigned Idx, const llvm::Constant *Elts); 1488 1489 llvm::BlockAddress *GetAddrOfLabel(const LabelDecl *L); 1490 llvm::BasicBlock *GetIndirectGotoBlock(); 1491 1492 /// EmitNullInitialization - Generate code to set a value of the given type to 1493 /// null, If the type contains data member pointers, they will be initialized 1494 /// to -1 in accordance with the Itanium C++ ABI. 1495 void EmitNullInitialization(llvm::Value *DestPtr, QualType Ty); 1496 1497 // EmitVAArg - Generate code to get an argument from the passed in pointer 1498 // and update it accordingly. The return value is a pointer to the argument. 1499 // FIXME: We should be able to get rid of this method and use the va_arg 1500 // instruction in LLVM instead once it works well enough. 1501 llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty); 1502 1503 /// emitArrayLength - Compute the length of an array, even if it's a 1504 /// VLA, and drill down to the base element type. 1505 llvm::Value *emitArrayLength(const ArrayType *arrayType, 1506 QualType &baseType, 1507 llvm::Value *&addr); 1508 1509 /// EmitVLASize - Capture all the sizes for the VLA expressions in 1510 /// the given variably-modified type and store them in the VLASizeMap. 1511 /// 1512 /// This function can be called with a null (unreachable) insert point. 1513 void EmitVariablyModifiedType(QualType Ty); 1514 1515 /// getVLASize - Returns an LLVM value that corresponds to the size, 1516 /// in non-variably-sized elements, of a variable length array type, 1517 /// plus that largest non-variably-sized element type. Assumes that 1518 /// the type has already been emitted with EmitVariablyModifiedType. 1519 std::pair<llvm::Value*,QualType> getVLASize(const VariableArrayType *vla); 1520 std::pair<llvm::Value*,QualType> getVLASize(QualType vla); 1521 1522 /// LoadCXXThis - Load the value of 'this'. This function is only valid while 1523 /// generating code for an C++ member function. 1524 llvm::Value *LoadCXXThis() { 1525 assert(CXXThisValue && "no 'this' value for this function"); 1526 return CXXThisValue; 1527 } 1528 1529 /// LoadCXXVTT - Load the VTT parameter to base constructors/destructors have 1530 /// virtual bases. 1531 // FIXME: Every place that calls LoadCXXVTT is something 1532 // that needs to be abstracted properly. 1533 llvm::Value *LoadCXXVTT() { 1534 assert(CXXStructorImplicitParamValue && "no VTT value for this function"); 1535 return CXXStructorImplicitParamValue; 1536 } 1537 1538 /// LoadCXXStructorImplicitParam - Load the implicit parameter 1539 /// for a constructor/destructor. 1540 llvm::Value *LoadCXXStructorImplicitParam() { 1541 assert(CXXStructorImplicitParamValue && 1542 "no implicit argument value for this function"); 1543 return CXXStructorImplicitParamValue; 1544 } 1545 1546 /// GetAddressOfBaseOfCompleteClass - Convert the given pointer to a 1547 /// complete class to the given direct base. 1548 llvm::Value * 1549 GetAddressOfDirectBaseInCompleteClass(llvm::Value *Value, 1550 const CXXRecordDecl *Derived, 1551 const CXXRecordDecl *Base, 1552 bool BaseIsVirtual); 1553 1554 /// GetAddressOfBaseClass - This function will add the necessary delta to the 1555 /// load of 'this' and returns address of the base class. 1556 llvm::Value *GetAddressOfBaseClass(llvm::Value *Value, 1557 const CXXRecordDecl *Derived, 1558 CastExpr::path_const_iterator PathBegin, 1559 CastExpr::path_const_iterator PathEnd, 1560 bool NullCheckValue); 1561 1562 llvm::Value *GetAddressOfDerivedClass(llvm::Value *Value, 1563 const CXXRecordDecl *Derived, 1564 CastExpr::path_const_iterator PathBegin, 1565 CastExpr::path_const_iterator PathEnd, 1566 bool NullCheckValue); 1567 1568 /// GetVTTParameter - Return the VTT parameter that should be passed to a 1569 /// base constructor/destructor with virtual bases. 1570 /// FIXME: VTTs are Itanium ABI-specific, so the definition should move 1571 /// to ItaniumCXXABI.cpp together with all the references to VTT. 1572 llvm::Value *GetVTTParameter(GlobalDecl GD, bool ForVirtualBase, 1573 bool Delegating); 1574 1575 void EmitDelegateCXXConstructorCall(const CXXConstructorDecl *Ctor, 1576 CXXCtorType CtorType, 1577 const FunctionArgList &Args, 1578 SourceLocation Loc); 1579 // It's important not to confuse this and the previous function. Delegating 1580 // constructors are the C++0x feature. The constructor delegate optimization 1581 // is used to reduce duplication in the base and complete consturctors where 1582 // they are substantially the same. 1583 void EmitDelegatingCXXConstructorCall(const CXXConstructorDecl *Ctor, 1584 const FunctionArgList &Args); 1585 void EmitCXXConstructorCall(const CXXConstructorDecl *D, CXXCtorType Type, 1586 bool ForVirtualBase, bool Delegating, 1587 llvm::Value *This, 1588 CallExpr::const_arg_iterator ArgBeg, 1589 CallExpr::const_arg_iterator ArgEnd); 1590 1591 void EmitSynthesizedCXXCopyCtorCall(const CXXConstructorDecl *D, 1592 llvm::Value *This, llvm::Value *Src, 1593 CallExpr::const_arg_iterator ArgBeg, 1594 CallExpr::const_arg_iterator ArgEnd); 1595 1596 void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D, 1597 const ConstantArrayType *ArrayTy, 1598 llvm::Value *ArrayPtr, 1599 CallExpr::const_arg_iterator ArgBeg, 1600 CallExpr::const_arg_iterator ArgEnd, 1601 bool ZeroInitialization = false); 1602 1603 void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D, 1604 llvm::Value *NumElements, 1605 llvm::Value *ArrayPtr, 1606 CallExpr::const_arg_iterator ArgBeg, 1607 CallExpr::const_arg_iterator ArgEnd, 1608 bool ZeroInitialization = false); 1609 1610 static Destroyer destroyCXXObject; 1611 1612 void EmitCXXDestructorCall(const CXXDestructorDecl *D, CXXDtorType Type, 1613 bool ForVirtualBase, bool Delegating, 1614 llvm::Value *This); 1615 1616 void EmitNewArrayInitializer(const CXXNewExpr *E, QualType elementType, 1617 llvm::Value *NewPtr, llvm::Value *NumElements); 1618 1619 void EmitCXXTemporary(const CXXTemporary *Temporary, QualType TempType, 1620 llvm::Value *Ptr); 1621 1622 llvm::Value *EmitCXXNewExpr(const CXXNewExpr *E); 1623 void EmitCXXDeleteExpr(const CXXDeleteExpr *E); 1624 1625 void EmitDeleteCall(const FunctionDecl *DeleteFD, llvm::Value *Ptr, 1626 QualType DeleteTy); 1627 1628 llvm::Value* EmitCXXTypeidExpr(const CXXTypeidExpr *E); 1629 llvm::Value *EmitDynamicCast(llvm::Value *V, const CXXDynamicCastExpr *DCE); 1630 llvm::Value* EmitCXXUuidofExpr(const CXXUuidofExpr *E); 1631 1632 /// \brief Situations in which we might emit a check for the suitability of a 1633 /// pointer or glvalue. 1634 enum TypeCheckKind { 1635 /// Checking the operand of a load. Must be suitably sized and aligned. 1636 TCK_Load, 1637 /// Checking the destination of a store. Must be suitably sized and aligned. 1638 TCK_Store, 1639 /// Checking the bound value in a reference binding. Must be suitably sized 1640 /// and aligned, but is not required to refer to an object (until the 1641 /// reference is used), per core issue 453. 1642 TCK_ReferenceBinding, 1643 /// Checking the object expression in a non-static data member access. Must 1644 /// be an object within its lifetime. 1645 TCK_MemberAccess, 1646 /// Checking the 'this' pointer for a call to a non-static member function. 1647 /// Must be an object within its lifetime. 1648 TCK_MemberCall, 1649 /// Checking the 'this' pointer for a constructor call. 1650 TCK_ConstructorCall, 1651 /// Checking the operand of a static_cast to a derived pointer type. Must be 1652 /// null or an object within its lifetime. 1653 TCK_DowncastPointer, 1654 /// Checking the operand of a static_cast to a derived reference type. Must 1655 /// be an object within its lifetime. 1656 TCK_DowncastReference 1657 }; 1658 1659 /// \brief Emit a check that \p V is the address of storage of the 1660 /// appropriate size and alignment for an object of type \p Type. 1661 void EmitTypeCheck(TypeCheckKind TCK, SourceLocation Loc, llvm::Value *V, 1662 QualType Type, CharUnits Alignment = CharUnits::Zero()); 1663 1664 /// \brief Emit a check that \p Base points into an array object, which 1665 /// we can access at index \p Index. \p Accessed should be \c false if we 1666 /// this expression is used as an lvalue, for instance in "&Arr[Idx]". 1667 void EmitBoundsCheck(const Expr *E, const Expr *Base, llvm::Value *Index, 1668 QualType IndexType, bool Accessed); 1669 1670 llvm::Value *EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 1671 bool isInc, bool isPre); 1672 ComplexPairTy EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV, 1673 bool isInc, bool isPre); 1674 //===--------------------------------------------------------------------===// 1675 // Declaration Emission 1676 //===--------------------------------------------------------------------===// 1677 1678 /// EmitDecl - Emit a declaration. 1679 /// 1680 /// This function can be called with a null (unreachable) insert point. 1681 void EmitDecl(const Decl &D); 1682 1683 /// EmitVarDecl - Emit a local variable declaration. 1684 /// 1685 /// This function can be called with a null (unreachable) insert point. 1686 void EmitVarDecl(const VarDecl &D); 1687 1688 void EmitScalarInit(const Expr *init, const ValueDecl *D, 1689 LValue lvalue, bool capturedByInit); 1690 void EmitScalarInit(llvm::Value *init, LValue lvalue); 1691 1692 typedef void SpecialInitFn(CodeGenFunction &Init, const VarDecl &D, 1693 llvm::Value *Address); 1694 1695 /// EmitAutoVarDecl - Emit an auto variable declaration. 1696 /// 1697 /// This function can be called with a null (unreachable) insert point. 1698 void EmitAutoVarDecl(const VarDecl &D); 1699 1700 class AutoVarEmission { 1701 friend class CodeGenFunction; 1702 1703 const VarDecl *Variable; 1704 1705 /// The alignment of the variable. 1706 CharUnits Alignment; 1707 1708 /// The address of the alloca. Null if the variable was emitted 1709 /// as a global constant. 1710 llvm::Value *Address; 1711 1712 llvm::Value *NRVOFlag; 1713 1714 /// True if the variable is a __block variable. 1715 bool IsByRef; 1716 1717 /// True if the variable is of aggregate type and has a constant 1718 /// initializer. 1719 bool IsConstantAggregate; 1720 1721 /// Non-null if we should use lifetime annotations. 1722 llvm::Value *SizeForLifetimeMarkers; 1723 1724 struct Invalid {}; 1725 AutoVarEmission(Invalid) : Variable(0) {} 1726 1727 AutoVarEmission(const VarDecl &variable) 1728 : Variable(&variable), Address(0), NRVOFlag(0), 1729 IsByRef(false), IsConstantAggregate(false), 1730 SizeForLifetimeMarkers(0) {} 1731 1732 bool wasEmittedAsGlobal() const { return Address == 0; } 1733 1734 public: 1735 static AutoVarEmission invalid() { return AutoVarEmission(Invalid()); } 1736 1737 bool useLifetimeMarkers() const { return SizeForLifetimeMarkers != 0; } 1738 llvm::Value *getSizeForLifetimeMarkers() const { 1739 assert(useLifetimeMarkers()); 1740 return SizeForLifetimeMarkers; 1741 } 1742 1743 /// Returns the raw, allocated address, which is not necessarily 1744 /// the address of the object itself. 1745 llvm::Value *getAllocatedAddress() const { 1746 return Address; 1747 } 1748 1749 /// Returns the address of the object within this declaration. 1750 /// Note that this does not chase the forwarding pointer for 1751 /// __block decls. 1752 llvm::Value *getObjectAddress(CodeGenFunction &CGF) const { 1753 if (!IsByRef) return Address; 1754 1755 return CGF.Builder.CreateStructGEP(Address, 1756 CGF.getByRefValueLLVMField(Variable), 1757 Variable->getNameAsString()); 1758 } 1759 }; 1760 AutoVarEmission EmitAutoVarAlloca(const VarDecl &var); 1761 void EmitAutoVarInit(const AutoVarEmission &emission); 1762 void EmitAutoVarCleanups(const AutoVarEmission &emission); 1763 void emitAutoVarTypeCleanup(const AutoVarEmission &emission, 1764 QualType::DestructionKind dtorKind); 1765 1766 void EmitStaticVarDecl(const VarDecl &D, 1767 llvm::GlobalValue::LinkageTypes Linkage); 1768 1769 /// EmitParmDecl - Emit a ParmVarDecl or an ImplicitParamDecl. 1770 void EmitParmDecl(const VarDecl &D, llvm::Value *Arg, unsigned ArgNo); 1771 1772 /// protectFromPeepholes - Protect a value that we're intending to 1773 /// store to the side, but which will probably be used later, from 1774 /// aggressive peepholing optimizations that might delete it. 1775 /// 1776 /// Pass the result to unprotectFromPeepholes to declare that 1777 /// protection is no longer required. 1778 /// 1779 /// There's no particular reason why this shouldn't apply to 1780 /// l-values, it's just that no existing peepholes work on pointers. 1781 PeepholeProtection protectFromPeepholes(RValue rvalue); 1782 void unprotectFromPeepholes(PeepholeProtection protection); 1783 1784 //===--------------------------------------------------------------------===// 1785 // Statement Emission 1786 //===--------------------------------------------------------------------===// 1787 1788 /// EmitStopPoint - Emit a debug stoppoint if we are emitting debug info. 1789 void EmitStopPoint(const Stmt *S); 1790 1791 /// EmitStmt - Emit the code for the statement \arg S. It is legal to call 1792 /// this function even if there is no current insertion point. 1793 /// 1794 /// This function may clear the current insertion point; callers should use 1795 /// EnsureInsertPoint if they wish to subsequently generate code without first 1796 /// calling EmitBlock, EmitBranch, or EmitStmt. 1797 void EmitStmt(const Stmt *S); 1798 1799 /// EmitSimpleStmt - Try to emit a "simple" statement which does not 1800 /// necessarily require an insertion point or debug information; typically 1801 /// because the statement amounts to a jump or a container of other 1802 /// statements. 1803 /// 1804 /// \return True if the statement was handled. 1805 bool EmitSimpleStmt(const Stmt *S); 1806 1807 llvm::Value *EmitCompoundStmt(const CompoundStmt &S, bool GetLast = false, 1808 AggValueSlot AVS = AggValueSlot::ignored()); 1809 llvm::Value *EmitCompoundStmtWithoutScope(const CompoundStmt &S, 1810 bool GetLast = false, 1811 AggValueSlot AVS = 1812 AggValueSlot::ignored()); 1813 1814 /// EmitLabel - Emit the block for the given label. It is legal to call this 1815 /// function even if there is no current insertion point. 1816 void EmitLabel(const LabelDecl *D); // helper for EmitLabelStmt. 1817 1818 void EmitLabelStmt(const LabelStmt &S); 1819 void EmitAttributedStmt(const AttributedStmt &S); 1820 void EmitGotoStmt(const GotoStmt &S); 1821 void EmitIndirectGotoStmt(const IndirectGotoStmt &S); 1822 void EmitIfStmt(const IfStmt &S); 1823 void EmitWhileStmt(const WhileStmt &S); 1824 void EmitDoStmt(const DoStmt &S); 1825 void EmitForStmt(const ForStmt &S); 1826 void EmitReturnStmt(const ReturnStmt &S); 1827 void EmitDeclStmt(const DeclStmt &S); 1828 void EmitBreakStmt(const BreakStmt &S); 1829 void EmitContinueStmt(const ContinueStmt &S); 1830 void EmitSwitchStmt(const SwitchStmt &S); 1831 void EmitDefaultStmt(const DefaultStmt &S); 1832 void EmitCaseStmt(const CaseStmt &S); 1833 void EmitCaseStmtRange(const CaseStmt &S); 1834 void EmitAsmStmt(const AsmStmt &S); 1835 1836 void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S); 1837 void EmitObjCAtTryStmt(const ObjCAtTryStmt &S); 1838 void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S); 1839 void EmitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt &S); 1840 void EmitObjCAutoreleasePoolStmt(const ObjCAutoreleasePoolStmt &S); 1841 1842 llvm::Constant *getUnwindResumeFn(); 1843 llvm::Constant *getUnwindResumeOrRethrowFn(); 1844 void EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock = false); 1845 void ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock = false); 1846 1847 void EmitCXXTryStmt(const CXXTryStmt &S); 1848 void EmitSEHTryStmt(const SEHTryStmt &S); 1849 void EmitCXXForRangeStmt(const CXXForRangeStmt &S); 1850 1851 llvm::Function *EmitCapturedStmt(const CapturedStmt &S, CapturedRegionKind K); 1852 llvm::Function *GenerateCapturedStmtFunction(const CapturedDecl *CD, 1853 const RecordDecl *RD, 1854 SourceLocation Loc); 1855 1856 //===--------------------------------------------------------------------===// 1857 // LValue Expression Emission 1858 //===--------------------------------------------------------------------===// 1859 1860 /// GetUndefRValue - Get an appropriate 'undef' rvalue for the given type. 1861 RValue GetUndefRValue(QualType Ty); 1862 1863 /// EmitUnsupportedRValue - Emit a dummy r-value using the type of E 1864 /// and issue an ErrorUnsupported style diagnostic (using the 1865 /// provided Name). 1866 RValue EmitUnsupportedRValue(const Expr *E, 1867 const char *Name); 1868 1869 /// EmitUnsupportedLValue - Emit a dummy l-value using the type of E and issue 1870 /// an ErrorUnsupported style diagnostic (using the provided Name). 1871 LValue EmitUnsupportedLValue(const Expr *E, 1872 const char *Name); 1873 1874 /// EmitLValue - Emit code to compute a designator that specifies the location 1875 /// of the expression. 1876 /// 1877 /// This can return one of two things: a simple address or a bitfield 1878 /// reference. In either case, the LLVM Value* in the LValue structure is 1879 /// guaranteed to be an LLVM pointer type. 1880 /// 1881 /// If this returns a bitfield reference, nothing about the pointee type of 1882 /// the LLVM value is known: For example, it may not be a pointer to an 1883 /// integer. 1884 /// 1885 /// If this returns a normal address, and if the lvalue's C type is fixed 1886 /// size, this method guarantees that the returned pointer type will point to 1887 /// an LLVM type of the same size of the lvalue's type. If the lvalue has a 1888 /// variable length type, this is not possible. 1889 /// 1890 LValue EmitLValue(const Expr *E); 1891 1892 /// \brief Same as EmitLValue but additionally we generate checking code to 1893 /// guard against undefined behavior. This is only suitable when we know 1894 /// that the address will be used to access the object. 1895 LValue EmitCheckedLValue(const Expr *E, TypeCheckKind TCK); 1896 1897 RValue convertTempToRValue(llvm::Value *addr, QualType type, 1898 SourceLocation Loc); 1899 1900 void EmitAtomicInit(Expr *E, LValue lvalue); 1901 1902 RValue EmitAtomicLoad(LValue lvalue, SourceLocation loc, 1903 AggValueSlot slot = AggValueSlot::ignored()); 1904 1905 void EmitAtomicStore(RValue rvalue, LValue lvalue, bool isInit); 1906 1907 /// EmitToMemory - Change a scalar value from its value 1908 /// representation to its in-memory representation. 1909 llvm::Value *EmitToMemory(llvm::Value *Value, QualType Ty); 1910 1911 /// EmitFromMemory - Change a scalar value from its memory 1912 /// representation to its value representation. 1913 llvm::Value *EmitFromMemory(llvm::Value *Value, QualType Ty); 1914 1915 /// EmitLoadOfScalar - Load a scalar value from an address, taking 1916 /// care to appropriately convert from the memory representation to 1917 /// the LLVM value representation. 1918 llvm::Value *EmitLoadOfScalar(llvm::Value *Addr, bool Volatile, 1919 unsigned Alignment, QualType Ty, 1920 SourceLocation Loc, 1921 llvm::MDNode *TBAAInfo = 0, 1922 QualType TBAABaseTy = QualType(), 1923 uint64_t TBAAOffset = 0); 1924 1925 /// EmitLoadOfScalar - Load a scalar value from an address, taking 1926 /// care to appropriately convert from the memory representation to 1927 /// the LLVM value representation. The l-value must be a simple 1928 /// l-value. 1929 llvm::Value *EmitLoadOfScalar(LValue lvalue, SourceLocation Loc); 1930 1931 /// EmitStoreOfScalar - Store a scalar value to an address, taking 1932 /// care to appropriately convert from the memory representation to 1933 /// the LLVM value representation. 1934 void EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr, 1935 bool Volatile, unsigned Alignment, QualType Ty, 1936 llvm::MDNode *TBAAInfo = 0, bool isInit = false, 1937 QualType TBAABaseTy = QualType(), 1938 uint64_t TBAAOffset = 0); 1939 1940 /// EmitStoreOfScalar - Store a scalar value to an address, taking 1941 /// care to appropriately convert from the memory representation to 1942 /// the LLVM value representation. The l-value must be a simple 1943 /// l-value. The isInit flag indicates whether this is an initialization. 1944 /// If so, atomic qualifiers are ignored and the store is always non-atomic. 1945 void EmitStoreOfScalar(llvm::Value *value, LValue lvalue, bool isInit=false); 1946 1947 /// EmitLoadOfLValue - Given an expression that represents a value lvalue, 1948 /// this method emits the address of the lvalue, then loads the result as an 1949 /// rvalue, returning the rvalue. 1950 RValue EmitLoadOfLValue(LValue V, SourceLocation Loc); 1951 RValue EmitLoadOfExtVectorElementLValue(LValue V); 1952 RValue EmitLoadOfBitfieldLValue(LValue LV); 1953 1954 /// EmitStoreThroughLValue - Store the specified rvalue into the specified 1955 /// lvalue, where both are guaranteed to the have the same type, and that type 1956 /// is 'Ty'. 1957 void EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit=false); 1958 void EmitStoreThroughExtVectorComponentLValue(RValue Src, LValue Dst); 1959 1960 /// EmitStoreThroughBitfieldLValue - Store Src into Dst with same constraints 1961 /// as EmitStoreThroughLValue. 1962 /// 1963 /// \param Result [out] - If non-null, this will be set to a Value* for the 1964 /// bit-field contents after the store, appropriate for use as the result of 1965 /// an assignment to the bit-field. 1966 void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, 1967 llvm::Value **Result=0); 1968 1969 /// Emit an l-value for an assignment (simple or compound) of complex type. 1970 LValue EmitComplexAssignmentLValue(const BinaryOperator *E); 1971 LValue EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E); 1972 LValue EmitScalarCompooundAssignWithComplex(const CompoundAssignOperator *E, 1973 llvm::Value *&Result); 1974 1975 // Note: only available for agg return types 1976 LValue EmitBinaryOperatorLValue(const BinaryOperator *E); 1977 LValue EmitCompoundAssignmentLValue(const CompoundAssignOperator *E); 1978 // Note: only available for agg return types 1979 LValue EmitCallExprLValue(const CallExpr *E); 1980 // Note: only available for agg return types 1981 LValue EmitVAArgExprLValue(const VAArgExpr *E); 1982 LValue EmitDeclRefLValue(const DeclRefExpr *E); 1983 LValue EmitStringLiteralLValue(const StringLiteral *E); 1984 LValue EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E); 1985 LValue EmitPredefinedLValue(const PredefinedExpr *E); 1986 LValue EmitUnaryOpLValue(const UnaryOperator *E); 1987 LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E, 1988 bool Accessed = false); 1989 LValue EmitExtVectorElementExpr(const ExtVectorElementExpr *E); 1990 LValue EmitMemberExpr(const MemberExpr *E); 1991 LValue EmitObjCIsaExpr(const ObjCIsaExpr *E); 1992 LValue EmitCompoundLiteralLValue(const CompoundLiteralExpr *E); 1993 LValue EmitInitListLValue(const InitListExpr *E); 1994 LValue EmitConditionalOperatorLValue(const AbstractConditionalOperator *E); 1995 LValue EmitCastLValue(const CastExpr *E); 1996 LValue EmitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E); 1997 LValue EmitOpaqueValueLValue(const OpaqueValueExpr *e); 1998 1999 RValue EmitRValueForField(LValue LV, const FieldDecl *FD, SourceLocation Loc); 2000 2001 class ConstantEmission { 2002 llvm::PointerIntPair<llvm::Constant*, 1, bool> ValueAndIsReference; 2003 ConstantEmission(llvm::Constant *C, bool isReference) 2004 : ValueAndIsReference(C, isReference) {} 2005 public: 2006 ConstantEmission() {} 2007 static ConstantEmission forReference(llvm::Constant *C) { 2008 return ConstantEmission(C, true); 2009 } 2010 static ConstantEmission forValue(llvm::Constant *C) { 2011 return ConstantEmission(C, false); 2012 } 2013 2014 LLVM_EXPLICIT operator bool() const { return ValueAndIsReference.getOpaqueValue() != 0; } 2015 2016 bool isReference() const { return ValueAndIsReference.getInt(); } 2017 LValue getReferenceLValue(CodeGenFunction &CGF, Expr *refExpr) const { 2018 assert(isReference()); 2019 return CGF.MakeNaturalAlignAddrLValue(ValueAndIsReference.getPointer(), 2020 refExpr->getType()); 2021 } 2022 2023 llvm::Constant *getValue() const { 2024 assert(!isReference()); 2025 return ValueAndIsReference.getPointer(); 2026 } 2027 }; 2028 2029 ConstantEmission tryEmitAsConstant(DeclRefExpr *refExpr); 2030 2031 RValue EmitPseudoObjectRValue(const PseudoObjectExpr *e, 2032 AggValueSlot slot = AggValueSlot::ignored()); 2033 LValue EmitPseudoObjectLValue(const PseudoObjectExpr *e); 2034 2035 llvm::Value *EmitIvarOffset(const ObjCInterfaceDecl *Interface, 2036 const ObjCIvarDecl *Ivar); 2037 LValue EmitLValueForField(LValue Base, const FieldDecl* Field); 2038 LValue EmitLValueForLambdaField(const FieldDecl *Field); 2039 2040 /// EmitLValueForFieldInitialization - Like EmitLValueForField, except that 2041 /// if the Field is a reference, this will return the address of the reference 2042 /// and not the address of the value stored in the reference. 2043 LValue EmitLValueForFieldInitialization(LValue Base, 2044 const FieldDecl* Field); 2045 2046 LValue EmitLValueForIvar(QualType ObjectTy, 2047 llvm::Value* Base, const ObjCIvarDecl *Ivar, 2048 unsigned CVRQualifiers); 2049 2050 LValue EmitCXXConstructLValue(const CXXConstructExpr *E); 2051 LValue EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E); 2052 LValue EmitLambdaLValue(const LambdaExpr *E); 2053 LValue EmitCXXTypeidLValue(const CXXTypeidExpr *E); 2054 LValue EmitCXXUuidofLValue(const CXXUuidofExpr *E); 2055 2056 LValue EmitObjCMessageExprLValue(const ObjCMessageExpr *E); 2057 LValue EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E); 2058 LValue EmitStmtExprLValue(const StmtExpr *E); 2059 LValue EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E); 2060 LValue EmitObjCSelectorLValue(const ObjCSelectorExpr *E); 2061 void EmitDeclRefExprDbgValue(const DeclRefExpr *E, llvm::Constant *Init); 2062 2063 //===--------------------------------------------------------------------===// 2064 // Scalar Expression Emission 2065 //===--------------------------------------------------------------------===// 2066 2067 /// EmitCall - Generate a call of the given function, expecting the given 2068 /// result type, and using the given argument list which specifies both the 2069 /// LLVM arguments and the types they were derived from. 2070 /// 2071 /// \param TargetDecl - If given, the decl of the function in a direct call; 2072 /// used to set attributes on the call (noreturn, etc.). 2073 RValue EmitCall(const CGFunctionInfo &FnInfo, 2074 llvm::Value *Callee, 2075 ReturnValueSlot ReturnValue, 2076 const CallArgList &Args, 2077 const Decl *TargetDecl = 0, 2078 llvm::Instruction **callOrInvoke = 0); 2079 2080 RValue EmitCall(QualType FnType, llvm::Value *Callee, 2081 SourceLocation CallLoc, 2082 ReturnValueSlot ReturnValue, 2083 CallExpr::const_arg_iterator ArgBeg, 2084 CallExpr::const_arg_iterator ArgEnd, 2085 const Decl *TargetDecl = 0); 2086 RValue EmitCallExpr(const CallExpr *E, 2087 ReturnValueSlot ReturnValue = ReturnValueSlot()); 2088 2089 llvm::CallInst *EmitRuntimeCall(llvm::Value *callee, 2090 const Twine &name = ""); 2091 llvm::CallInst *EmitRuntimeCall(llvm::Value *callee, 2092 ArrayRef<llvm::Value*> args, 2093 const Twine &name = ""); 2094 llvm::CallInst *EmitNounwindRuntimeCall(llvm::Value *callee, 2095 const Twine &name = ""); 2096 llvm::CallInst *EmitNounwindRuntimeCall(llvm::Value *callee, 2097 ArrayRef<llvm::Value*> args, 2098 const Twine &name = ""); 2099 2100 llvm::CallSite EmitCallOrInvoke(llvm::Value *Callee, 2101 ArrayRef<llvm::Value *> Args, 2102 const Twine &Name = ""); 2103 llvm::CallSite EmitCallOrInvoke(llvm::Value *Callee, 2104 const Twine &Name = ""); 2105 llvm::CallSite EmitRuntimeCallOrInvoke(llvm::Value *callee, 2106 ArrayRef<llvm::Value*> args, 2107 const Twine &name = ""); 2108 llvm::CallSite EmitRuntimeCallOrInvoke(llvm::Value *callee, 2109 const Twine &name = ""); 2110 void EmitNoreturnRuntimeCallOrInvoke(llvm::Value *callee, 2111 ArrayRef<llvm::Value*> args); 2112 2113 llvm::Value *BuildAppleKextVirtualCall(const CXXMethodDecl *MD, 2114 NestedNameSpecifier *Qual, 2115 llvm::Type *Ty); 2116 2117 llvm::Value *BuildAppleKextVirtualDestructorCall(const CXXDestructorDecl *DD, 2118 CXXDtorType Type, 2119 const CXXRecordDecl *RD); 2120 2121 RValue EmitCXXMemberCall(const CXXMethodDecl *MD, 2122 SourceLocation CallLoc, 2123 llvm::Value *Callee, 2124 ReturnValueSlot ReturnValue, 2125 llvm::Value *This, 2126 llvm::Value *ImplicitParam, 2127 QualType ImplicitParamTy, 2128 CallExpr::const_arg_iterator ArgBeg, 2129 CallExpr::const_arg_iterator ArgEnd); 2130 RValue EmitCXXMemberCallExpr(const CXXMemberCallExpr *E, 2131 ReturnValueSlot ReturnValue); 2132 RValue EmitCXXMemberPointerCallExpr(const CXXMemberCallExpr *E, 2133 ReturnValueSlot ReturnValue); 2134 2135 llvm::Value *EmitCXXOperatorMemberCallee(const CXXOperatorCallExpr *E, 2136 const CXXMethodDecl *MD, 2137 llvm::Value *This); 2138 RValue EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E, 2139 const CXXMethodDecl *MD, 2140 ReturnValueSlot ReturnValue); 2141 2142 RValue EmitCUDAKernelCallExpr(const CUDAKernelCallExpr *E, 2143 ReturnValueSlot ReturnValue); 2144 2145 2146 RValue EmitBuiltinExpr(const FunctionDecl *FD, 2147 unsigned BuiltinID, const CallExpr *E); 2148 2149 RValue EmitBlockCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue); 2150 2151 /// EmitTargetBuiltinExpr - Emit the given builtin call. Returns 0 if the call 2152 /// is unhandled by the current target. 2153 llvm::Value *EmitTargetBuiltinExpr(unsigned BuiltinID, const CallExpr *E); 2154 2155 llvm::Value *EmitAArch64CompareBuiltinExpr(llvm::Value *Op, llvm::Type *Ty, 2156 const llvm::CmpInst::Predicate Fp, 2157 const llvm::CmpInst::Predicate Ip, 2158 const llvm::Twine &Name = ""); 2159 llvm::Value *EmitAArch64CompareBuiltinExpr(llvm::Value *Op, llvm::Type *Ty); 2160 llvm::Value *EmitAArch64BuiltinExpr(unsigned BuiltinID, const CallExpr *E); 2161 llvm::Value *EmitARMBuiltinExpr(unsigned BuiltinID, const CallExpr *E); 2162 llvm::Value *EmitNeonCall(llvm::Function *F, 2163 SmallVectorImpl<llvm::Value*> &O, 2164 const char *name, 2165 unsigned shift = 0, bool rightshift = false); 2166 llvm::Value *EmitNeonSplat(llvm::Value *V, llvm::Constant *Idx); 2167 llvm::Value *EmitNeonShiftVector(llvm::Value *V, llvm::Type *Ty, 2168 bool negateForRightShift); 2169 llvm::Value *EmitNeonRShiftImm(llvm::Value *Vec, llvm::Value *Amt, 2170 llvm::Type *Ty, bool usgn, const char *name); 2171 2172 llvm::Value *BuildVector(ArrayRef<llvm::Value*> Ops); 2173 llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E); 2174 llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E); 2175 2176 llvm::Value *EmitObjCProtocolExpr(const ObjCProtocolExpr *E); 2177 llvm::Value *EmitObjCStringLiteral(const ObjCStringLiteral *E); 2178 llvm::Value *EmitObjCBoxedExpr(const ObjCBoxedExpr *E); 2179 llvm::Value *EmitObjCArrayLiteral(const ObjCArrayLiteral *E); 2180 llvm::Value *EmitObjCDictionaryLiteral(const ObjCDictionaryLiteral *E); 2181 llvm::Value *EmitObjCCollectionLiteral(const Expr *E, 2182 const ObjCMethodDecl *MethodWithObjects); 2183 llvm::Value *EmitObjCSelectorExpr(const ObjCSelectorExpr *E); 2184 RValue EmitObjCMessageExpr(const ObjCMessageExpr *E, 2185 ReturnValueSlot Return = ReturnValueSlot()); 2186 2187 /// Retrieves the default cleanup kind for an ARC cleanup. 2188 /// Except under -fobjc-arc-eh, ARC cleanups are normal-only. 2189 CleanupKind getARCCleanupKind() { 2190 return CGM.getCodeGenOpts().ObjCAutoRefCountExceptions 2191 ? NormalAndEHCleanup : NormalCleanup; 2192 } 2193 2194 // ARC primitives. 2195 void EmitARCInitWeak(llvm::Value *value, llvm::Value *addr); 2196 void EmitARCDestroyWeak(llvm::Value *addr); 2197 llvm::Value *EmitARCLoadWeak(llvm::Value *addr); 2198 llvm::Value *EmitARCLoadWeakRetained(llvm::Value *addr); 2199 llvm::Value *EmitARCStoreWeak(llvm::Value *value, llvm::Value *addr, 2200 bool ignored); 2201 void EmitARCCopyWeak(llvm::Value *dst, llvm::Value *src); 2202 void EmitARCMoveWeak(llvm::Value *dst, llvm::Value *src); 2203 llvm::Value *EmitARCRetainAutorelease(QualType type, llvm::Value *value); 2204 llvm::Value *EmitARCRetainAutoreleaseNonBlock(llvm::Value *value); 2205 llvm::Value *EmitARCStoreStrong(LValue lvalue, llvm::Value *value, 2206 bool resultIgnored); 2207 llvm::Value *EmitARCStoreStrongCall(llvm::Value *addr, llvm::Value *value, 2208 bool resultIgnored); 2209 llvm::Value *EmitARCRetain(QualType type, llvm::Value *value); 2210 llvm::Value *EmitARCRetainNonBlock(llvm::Value *value); 2211 llvm::Value *EmitARCRetainBlock(llvm::Value *value, bool mandatory); 2212 void EmitARCDestroyStrong(llvm::Value *addr, ARCPreciseLifetime_t precise); 2213 void EmitARCRelease(llvm::Value *value, ARCPreciseLifetime_t precise); 2214 llvm::Value *EmitARCAutorelease(llvm::Value *value); 2215 llvm::Value *EmitARCAutoreleaseReturnValue(llvm::Value *value); 2216 llvm::Value *EmitARCRetainAutoreleaseReturnValue(llvm::Value *value); 2217 llvm::Value *EmitARCRetainAutoreleasedReturnValue(llvm::Value *value); 2218 2219 std::pair<LValue,llvm::Value*> 2220 EmitARCStoreAutoreleasing(const BinaryOperator *e); 2221 std::pair<LValue,llvm::Value*> 2222 EmitARCStoreStrong(const BinaryOperator *e, bool ignored); 2223 2224 llvm::Value *EmitObjCThrowOperand(const Expr *expr); 2225 2226 llvm::Value *EmitObjCProduceObject(QualType T, llvm::Value *Ptr); 2227 llvm::Value *EmitObjCConsumeObject(QualType T, llvm::Value *Ptr); 2228 llvm::Value *EmitObjCExtendObjectLifetime(QualType T, llvm::Value *Ptr); 2229 2230 llvm::Value *EmitARCExtendBlockObject(const Expr *expr); 2231 llvm::Value *EmitARCRetainScalarExpr(const Expr *expr); 2232 llvm::Value *EmitARCRetainAutoreleaseScalarExpr(const Expr *expr); 2233 2234 void EmitARCIntrinsicUse(llvm::ArrayRef<llvm::Value*> values); 2235 2236 static Destroyer destroyARCStrongImprecise; 2237 static Destroyer destroyARCStrongPrecise; 2238 static Destroyer destroyARCWeak; 2239 2240 void EmitObjCAutoreleasePoolPop(llvm::Value *Ptr); 2241 llvm::Value *EmitObjCAutoreleasePoolPush(); 2242 llvm::Value *EmitObjCMRRAutoreleasePoolPush(); 2243 void EmitObjCAutoreleasePoolCleanup(llvm::Value *Ptr); 2244 void EmitObjCMRRAutoreleasePoolPop(llvm::Value *Ptr); 2245 2246 /// \brief Emits a reference binding to the passed in expression. 2247 RValue EmitReferenceBindingToExpr(const Expr *E); 2248 2249 //===--------------------------------------------------------------------===// 2250 // Expression Emission 2251 //===--------------------------------------------------------------------===// 2252 2253 // Expressions are broken into three classes: scalar, complex, aggregate. 2254 2255 /// EmitScalarExpr - Emit the computation of the specified expression of LLVM 2256 /// scalar type, returning the result. 2257 llvm::Value *EmitScalarExpr(const Expr *E , bool IgnoreResultAssign = false); 2258 2259 /// EmitScalarConversion - Emit a conversion from the specified type to the 2260 /// specified destination type, both of which are LLVM scalar types. 2261 llvm::Value *EmitScalarConversion(llvm::Value *Src, QualType SrcTy, 2262 QualType DstTy); 2263 2264 /// EmitComplexToScalarConversion - Emit a conversion from the specified 2265 /// complex type to the specified destination type, where the destination type 2266 /// is an LLVM scalar type. 2267 llvm::Value *EmitComplexToScalarConversion(ComplexPairTy Src, QualType SrcTy, 2268 QualType DstTy); 2269 2270 2271 /// EmitAggExpr - Emit the computation of the specified expression 2272 /// of aggregate type. The result is computed into the given slot, 2273 /// which may be null to indicate that the value is not needed. 2274 void EmitAggExpr(const Expr *E, AggValueSlot AS); 2275 2276 /// EmitAggExprToLValue - Emit the computation of the specified expression of 2277 /// aggregate type into a temporary LValue. 2278 LValue EmitAggExprToLValue(const Expr *E); 2279 2280 /// EmitGCMemmoveCollectable - Emit special API for structs with object 2281 /// pointers. 2282 void EmitGCMemmoveCollectable(llvm::Value *DestPtr, llvm::Value *SrcPtr, 2283 QualType Ty); 2284 2285 /// EmitExtendGCLifetime - Given a pointer to an Objective-C object, 2286 /// make sure it survives garbage collection until this point. 2287 void EmitExtendGCLifetime(llvm::Value *object); 2288 2289 /// EmitComplexExpr - Emit the computation of the specified expression of 2290 /// complex type, returning the result. 2291 ComplexPairTy EmitComplexExpr(const Expr *E, 2292 bool IgnoreReal = false, 2293 bool IgnoreImag = false); 2294 2295 /// EmitComplexExprIntoLValue - Emit the given expression of complex 2296 /// type and place its result into the specified l-value. 2297 void EmitComplexExprIntoLValue(const Expr *E, LValue dest, bool isInit); 2298 2299 /// EmitStoreOfComplex - Store a complex number into the specified l-value. 2300 void EmitStoreOfComplex(ComplexPairTy V, LValue dest, bool isInit); 2301 2302 /// EmitLoadOfComplex - Load a complex number from the specified l-value. 2303 ComplexPairTy EmitLoadOfComplex(LValue src, SourceLocation loc); 2304 2305 /// CreateStaticVarDecl - Create a zero-initialized LLVM global for 2306 /// a static local variable. 2307 llvm::GlobalVariable *CreateStaticVarDecl(const VarDecl &D, 2308 const char *Separator, 2309 llvm::GlobalValue::LinkageTypes Linkage); 2310 2311 /// AddInitializerToStaticVarDecl - Add the initializer for 'D' to the 2312 /// global variable that has already been created for it. If the initializer 2313 /// has a different type than GV does, this may free GV and return a different 2314 /// one. Otherwise it just returns GV. 2315 llvm::GlobalVariable * 2316 AddInitializerToStaticVarDecl(const VarDecl &D, 2317 llvm::GlobalVariable *GV); 2318 2319 2320 /// EmitCXXGlobalVarDeclInit - Create the initializer for a C++ 2321 /// variable with global storage. 2322 void EmitCXXGlobalVarDeclInit(const VarDecl &D, llvm::Constant *DeclPtr, 2323 bool PerformInit); 2324 2325 /// Call atexit() with a function that passes the given argument to 2326 /// the given function. 2327 void registerGlobalDtorWithAtExit(const VarDecl &D, llvm::Constant *fn, 2328 llvm::Constant *addr); 2329 2330 /// Emit code in this function to perform a guarded variable 2331 /// initialization. Guarded initializations are used when it's not 2332 /// possible to prove that an initialization will be done exactly 2333 /// once, e.g. with a static local variable or a static data member 2334 /// of a class template. 2335 void EmitCXXGuardedInit(const VarDecl &D, llvm::GlobalVariable *DeclPtr, 2336 bool PerformInit); 2337 2338 /// GenerateCXXGlobalInitFunc - Generates code for initializing global 2339 /// variables. 2340 void GenerateCXXGlobalInitFunc(llvm::Function *Fn, 2341 ArrayRef<llvm::Constant *> Decls, 2342 llvm::GlobalVariable *Guard = 0); 2343 2344 /// GenerateCXXGlobalDtorsFunc - Generates code for destroying global 2345 /// variables. 2346 void GenerateCXXGlobalDtorsFunc(llvm::Function *Fn, 2347 const std::vector<std::pair<llvm::WeakVH, 2348 llvm::Constant*> > &DtorsAndObjects); 2349 2350 void GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn, 2351 const VarDecl *D, 2352 llvm::GlobalVariable *Addr, 2353 bool PerformInit); 2354 2355 void EmitCXXConstructExpr(const CXXConstructExpr *E, AggValueSlot Dest); 2356 2357 void EmitSynthesizedCXXCopyCtor(llvm::Value *Dest, llvm::Value *Src, 2358 const Expr *Exp); 2359 2360 void enterFullExpression(const ExprWithCleanups *E) { 2361 if (E->getNumObjects() == 0) return; 2362 enterNonTrivialFullExpression(E); 2363 } 2364 void enterNonTrivialFullExpression(const ExprWithCleanups *E); 2365 2366 void EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint = true); 2367 2368 void EmitLambdaExpr(const LambdaExpr *E, AggValueSlot Dest); 2369 2370 RValue EmitAtomicExpr(AtomicExpr *E, llvm::Value *Dest = 0); 2371 2372 //===--------------------------------------------------------------------===// 2373 // Annotations Emission 2374 //===--------------------------------------------------------------------===// 2375 2376 /// Emit an annotation call (intrinsic or builtin). 2377 llvm::Value *EmitAnnotationCall(llvm::Value *AnnotationFn, 2378 llvm::Value *AnnotatedVal, 2379 StringRef AnnotationStr, 2380 SourceLocation Location); 2381 2382 /// Emit local annotations for the local variable V, declared by D. 2383 void EmitVarAnnotations(const VarDecl *D, llvm::Value *V); 2384 2385 /// Emit field annotations for the given field & value. Returns the 2386 /// annotation result. 2387 llvm::Value *EmitFieldAnnotations(const FieldDecl *D, llvm::Value *V); 2388 2389 //===--------------------------------------------------------------------===// 2390 // Internal Helpers 2391 //===--------------------------------------------------------------------===// 2392 2393 /// ContainsLabel - Return true if the statement contains a label in it. If 2394 /// this statement is not executed normally, it not containing a label means 2395 /// that we can just remove the code. 2396 static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts = false); 2397 2398 /// containsBreak - Return true if the statement contains a break out of it. 2399 /// If the statement (recursively) contains a switch or loop with a break 2400 /// inside of it, this is fine. 2401 static bool containsBreak(const Stmt *S); 2402 2403 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold 2404 /// to a constant, or if it does but contains a label, return false. If it 2405 /// constant folds return true and set the boolean result in Result. 2406 bool ConstantFoldsToSimpleInteger(const Expr *Cond, bool &Result); 2407 2408 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold 2409 /// to a constant, or if it does but contains a label, return false. If it 2410 /// constant folds return true and set the folded value. 2411 bool ConstantFoldsToSimpleInteger(const Expr *Cond, llvm::APSInt &Result); 2412 2413 /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an 2414 /// if statement) to the specified blocks. Based on the condition, this might 2415 /// try to simplify the codegen of the conditional based on the branch. 2416 void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock, 2417 llvm::BasicBlock *FalseBlock); 2418 2419 /// \brief Emit a description of a type in a format suitable for passing to 2420 /// a runtime sanitizer handler. 2421 llvm::Constant *EmitCheckTypeDescriptor(QualType T); 2422 2423 /// \brief Convert a value into a format suitable for passing to a runtime 2424 /// sanitizer handler. 2425 llvm::Value *EmitCheckValue(llvm::Value *V); 2426 2427 /// \brief Emit a description of a source location in a format suitable for 2428 /// passing to a runtime sanitizer handler. 2429 llvm::Constant *EmitCheckSourceLocation(SourceLocation Loc); 2430 2431 /// \brief Specify under what conditions this check can be recovered 2432 enum CheckRecoverableKind { 2433 /// Always terminate program execution if this check fails 2434 CRK_Unrecoverable, 2435 /// Check supports recovering, allows user to specify which 2436 CRK_Recoverable, 2437 /// Runtime conditionally aborts, always need to support recovery. 2438 CRK_AlwaysRecoverable 2439 }; 2440 2441 /// \brief Create a basic block that will call a handler function in a 2442 /// sanitizer runtime with the provided arguments, and create a conditional 2443 /// branch to it. 2444 void EmitCheck(llvm::Value *Checked, StringRef CheckName, 2445 ArrayRef<llvm::Constant *> StaticArgs, 2446 ArrayRef<llvm::Value *> DynamicArgs, 2447 CheckRecoverableKind Recoverable); 2448 2449 /// \brief Create a basic block that will call the trap intrinsic, and emit a 2450 /// conditional branch to it, for the -ftrapv checks. 2451 void EmitTrapCheck(llvm::Value *Checked); 2452 2453 /// EmitCallArg - Emit a single call argument. 2454 void EmitCallArg(CallArgList &args, const Expr *E, QualType ArgType); 2455 2456 /// EmitDelegateCallArg - We are performing a delegate call; that 2457 /// is, the current function is delegating to another one. Produce 2458 /// a r-value suitable for passing the given parameter. 2459 void EmitDelegateCallArg(CallArgList &args, const VarDecl *param, 2460 SourceLocation loc); 2461 2462 /// SetFPAccuracy - Set the minimum required accuracy of the given floating 2463 /// point operation, expressed as the maximum relative error in ulp. 2464 void SetFPAccuracy(llvm::Value *Val, float Accuracy); 2465 2466private: 2467 llvm::MDNode *getRangeForLoadFromType(QualType Ty); 2468 void EmitReturnOfRValue(RValue RV, QualType Ty); 2469 2470 /// ExpandTypeFromArgs - Reconstruct a structure of type \arg Ty 2471 /// from function arguments into \arg Dst. See ABIArgInfo::Expand. 2472 /// 2473 /// \param AI - The first function argument of the expansion. 2474 /// \return The argument following the last expanded function 2475 /// argument. 2476 llvm::Function::arg_iterator 2477 ExpandTypeFromArgs(QualType Ty, LValue Dst, 2478 llvm::Function::arg_iterator AI); 2479 2480 /// ExpandTypeToArgs - Expand an RValue \arg Src, with the LLVM type for \arg 2481 /// Ty, into individual arguments on the provided vector \arg Args. See 2482 /// ABIArgInfo::Expand. 2483 void ExpandTypeToArgs(QualType Ty, RValue Src, 2484 SmallVectorImpl<llvm::Value *> &Args, 2485 llvm::FunctionType *IRFuncTy); 2486 2487 llvm::Value* EmitAsmInput(const TargetInfo::ConstraintInfo &Info, 2488 const Expr *InputExpr, std::string &ConstraintStr); 2489 2490 llvm::Value* EmitAsmInputLValue(const TargetInfo::ConstraintInfo &Info, 2491 LValue InputValue, QualType InputType, 2492 std::string &ConstraintStr, 2493 SourceLocation Loc); 2494 2495 /// EmitCallArgs - Emit call arguments for a function. 2496 /// The CallArgTypeInfo parameter is used for iterating over the known 2497 /// argument types of the function being called. 2498 template<typename T> 2499 void EmitCallArgs(CallArgList& Args, const T* CallArgTypeInfo, 2500 CallExpr::const_arg_iterator ArgBeg, 2501 CallExpr::const_arg_iterator ArgEnd, 2502 bool ForceColumnInfo = false) { 2503 CGDebugInfo *DI = getDebugInfo(); 2504 SourceLocation CallLoc; 2505 if (DI) CallLoc = DI->getLocation(); 2506 2507 CallExpr::const_arg_iterator Arg = ArgBeg; 2508 2509 // First, use the argument types that the type info knows about 2510 if (CallArgTypeInfo) { 2511 for (typename T::arg_type_iterator I = CallArgTypeInfo->arg_type_begin(), 2512 E = CallArgTypeInfo->arg_type_end(); I != E; ++I, ++Arg) { 2513 assert(Arg != ArgEnd && "Running over edge of argument list!"); 2514 QualType ArgType = *I; 2515#ifndef NDEBUG 2516 QualType ActualArgType = Arg->getType(); 2517 if (ArgType->isPointerType() && ActualArgType->isPointerType()) { 2518 QualType ActualBaseType = 2519 ActualArgType->getAs<PointerType>()->getPointeeType(); 2520 QualType ArgBaseType = 2521 ArgType->getAs<PointerType>()->getPointeeType(); 2522 if (ArgBaseType->isVariableArrayType()) { 2523 if (const VariableArrayType *VAT = 2524 getContext().getAsVariableArrayType(ActualBaseType)) { 2525 if (!VAT->getSizeExpr()) 2526 ActualArgType = ArgType; 2527 } 2528 } 2529 } 2530 assert(getContext().getCanonicalType(ArgType.getNonReferenceType()). 2531 getTypePtr() == 2532 getContext().getCanonicalType(ActualArgType).getTypePtr() && 2533 "type mismatch in call argument!"); 2534#endif 2535 EmitCallArg(Args, *Arg, ArgType); 2536 2537 // Each argument expression could modify the debug 2538 // location. Restore it. 2539 if (DI) DI->EmitLocation(Builder, CallLoc, ForceColumnInfo); 2540 } 2541 2542 // Either we've emitted all the call args, or we have a call to a 2543 // variadic function. 2544 assert((Arg == ArgEnd || CallArgTypeInfo->isVariadic()) && 2545 "Extra arguments in non-variadic function!"); 2546 2547 } 2548 2549 // If we still have any arguments, emit them using the type of the argument. 2550 for (; Arg != ArgEnd; ++Arg) { 2551 EmitCallArg(Args, *Arg, Arg->getType()); 2552 2553 // Restore the debug location. 2554 if (DI) DI->EmitLocation(Builder, CallLoc, ForceColumnInfo); 2555 } 2556 } 2557 2558 const TargetCodeGenInfo &getTargetHooks() const { 2559 return CGM.getTargetCodeGenInfo(); 2560 } 2561 2562 void EmitDeclMetadata(); 2563 2564 CodeGenModule::ByrefHelpers * 2565 buildByrefHelpers(llvm::StructType &byrefType, 2566 const AutoVarEmission &emission); 2567 2568 void AddObjCARCExceptionMetadata(llvm::Instruction *Inst); 2569 2570 /// GetPointeeAlignment - Given an expression with a pointer type, emit the 2571 /// value and compute our best estimate of the alignment of the pointee. 2572 std::pair<llvm::Value*, unsigned> EmitPointerWithAlignment(const Expr *Addr); 2573}; 2574 2575/// Helper class with most of the code for saving a value for a 2576/// conditional expression cleanup. 2577struct DominatingLLVMValue { 2578 typedef llvm::PointerIntPair<llvm::Value*, 1, bool> saved_type; 2579 2580 /// Answer whether the given value needs extra work to be saved. 2581 static bool needsSaving(llvm::Value *value) { 2582 // If it's not an instruction, we don't need to save. 2583 if (!isa<llvm::Instruction>(value)) return false; 2584 2585 // If it's an instruction in the entry block, we don't need to save. 2586 llvm::BasicBlock *block = cast<llvm::Instruction>(value)->getParent(); 2587 return (block != &block->getParent()->getEntryBlock()); 2588 } 2589 2590 /// Try to save the given value. 2591 static saved_type save(CodeGenFunction &CGF, llvm::Value *value) { 2592 if (!needsSaving(value)) return saved_type(value, false); 2593 2594 // Otherwise we need an alloca. 2595 llvm::Value *alloca = 2596 CGF.CreateTempAlloca(value->getType(), "cond-cleanup.save"); 2597 CGF.Builder.CreateStore(value, alloca); 2598 2599 return saved_type(alloca, true); 2600 } 2601 2602 static llvm::Value *restore(CodeGenFunction &CGF, saved_type value) { 2603 if (!value.getInt()) return value.getPointer(); 2604 return CGF.Builder.CreateLoad(value.getPointer()); 2605 } 2606}; 2607 2608/// A partial specialization of DominatingValue for llvm::Values that 2609/// might be llvm::Instructions. 2610template <class T> struct DominatingPointer<T,true> : DominatingLLVMValue { 2611 typedef T *type; 2612 static type restore(CodeGenFunction &CGF, saved_type value) { 2613 return static_cast<T*>(DominatingLLVMValue::restore(CGF, value)); 2614 } 2615}; 2616 2617/// A specialization of DominatingValue for RValue. 2618template <> struct DominatingValue<RValue> { 2619 typedef RValue type; 2620 class saved_type { 2621 enum Kind { ScalarLiteral, ScalarAddress, AggregateLiteral, 2622 AggregateAddress, ComplexAddress }; 2623 2624 llvm::Value *Value; 2625 Kind K; 2626 saved_type(llvm::Value *v, Kind k) : Value(v), K(k) {} 2627 2628 public: 2629 static bool needsSaving(RValue value); 2630 static saved_type save(CodeGenFunction &CGF, RValue value); 2631 RValue restore(CodeGenFunction &CGF); 2632 2633 // implementations in CGExprCXX.cpp 2634 }; 2635 2636 static bool needsSaving(type value) { 2637 return saved_type::needsSaving(value); 2638 } 2639 static saved_type save(CodeGenFunction &CGF, type value) { 2640 return saved_type::save(CGF, value); 2641 } 2642 static type restore(CodeGenFunction &CGF, saved_type value) { 2643 return value.restore(CGF); 2644 } 2645}; 2646 2647} // end namespace CodeGen 2648} // end namespace clang 2649 2650#endif 2651