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