1 //===-- CodeGenFunction.h - Per-Function state for LLVM CodeGen -*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This is the internal per-function state used for llvm translation.
12 //===----------------------------------------------------------------------===//
14 #ifndef CLANG_CODEGEN_CODEGENFUNCTION_H
15 #define CLANG_CODEGEN_CODEGENFUNCTION_H
17 #include "CGBuilder.h"
18 #include "CGDebugInfo.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"
48 class CXXDestructorDecl;
49 class CXXForRangeStmt;
53 class EnumConstantDecl;
55 class FunctionProtoType;
57 class ObjCContainerDecl;
58 class ObjCInterfaceDecl;
61 class ObjCImplementationDecl;
62 class ObjCPropertyImplDecl;
64 class TargetCodeGenInfo;
66 class ObjCForCollectionStmt;
68 class ObjCAtThrowStmt;
69 class ObjCAtSynchronizedStmt;
70 class ObjCAutoreleasePoolStmt;
79 class BlockFieldFlags;
81 /// The kind of evaluation to perform on values of a particular
82 /// type. Basically, is the code in CGExprScalar, CGExprComplex, or
85 /// TODO: should vectors maybe be split out into their own thing?
86 enum TypeEvaluationKind {
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.
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;
104 /// The ultimate destination of the branch.
106 /// This can be set to null to indicate that this fixup was
107 /// successfully resolved.
108 llvm::BasicBlock *Destination;
110 /// The destination index value.
111 unsigned DestinationIndex;
113 /// The initial branch of the fixup.
114 llvm::BranchInst *InitialBranch;
117 template <class T> struct InvariantValue {
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; }
125 /// A metaprogramming class for ensuring that a value will dominate an
126 /// arbitrary position in a function.
127 template <class T> struct DominatingValue : InvariantValue<T> {};
129 template <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>
133 struct DominatingPointer;
134 template <class T> struct DominatingPointer<T,false> : InvariantValue<T*> {};
135 // template <class T> struct DominatingPointer<T,true> at end of file
137 template <class T> struct DominatingValue<T*> : DominatingPointer<T> {};
142 NormalAndEHCleanup = EHCleanup | NormalCleanup,
144 InactiveCleanup = 0x4,
145 InactiveEHCleanup = EHCleanup | InactiveCleanup,
146 InactiveNormalCleanup = NormalCleanup | InactiveCleanup,
147 InactiveNormalAndEHCleanup = NormalAndEHCleanup | InactiveCleanup
150 /// A stack of scopes which respond to exceptions, including cleanups
151 /// and catch blocks.
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;
159 /// Offset from StartOfData to EndOfBuffer.
162 stable_iterator(ptrdiff_t Size) : Size(Size) {}
165 static stable_iterator invalid() { return stable_iterator(-1); }
166 stable_iterator() : Size(-1) {}
168 bool isValid() const { return Size >= 0; }
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; }
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; }
181 friend bool operator==(stable_iterator A, stable_iterator B) {
182 return A.Size == B.Size;
184 friend bool operator!=(stable_iterator A, stable_iterator B) {
185 return A.Size != B.Size;
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
194 /// Cleanup implementations should generally be declared in an
195 /// anonymous namespace.
197 // Anchor the construction vtable.
198 virtual void anchor();
200 /// Generation flags.
204 F_IsNormalCleanupKind = 0x2,
205 F_IsEHCleanupKind = 0x4
210 Flags() : flags(0) {}
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; }
217 bool isNormalCleanupKind() const { return flags & F_IsNormalCleanupKind; }
218 void setIsNormalCleanupKind() { flags |= F_IsNormalCleanupKind; }
220 /// isEHCleanupKind - true if the cleanup was pushed as an EH
222 bool isEHCleanupKind() const { return flags & F_IsEHCleanupKind; }
223 void setIsEHCleanupKind() { flags |= F_IsEHCleanupKind; }
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() {}
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.
236 // \param flags cleanup kind.
237 virtual void Emit(CodeGenFunction &CGF, Flags flags) = 0;
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;
247 void Emit(CodeGenFunction &CGF, Flags flags) {
248 A0 a0 = DominatingValue<A0>::restore(CGF, a0_saved);
249 T(a0).Emit(CGF, flags);
253 ConditionalCleanup1(A0_saved a0)
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;
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);
271 ConditionalCleanup2(A0_saved a0, A1_saved a1)
272 : a0_saved(a0), a1_saved(a1) {}
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;
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);
292 ConditionalCleanup3(A0_saved a0, A1_saved a1, A2_saved a2)
293 : a0_saved(a0), a1_saved(a1), a2_saved(a2) {}
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;
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);
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) {}
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.
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.
330 /// The end of the buffer.
333 /// The first valid entry in the buffer.
336 /// The innermost normal cleanup on the stack.
337 stable_iterator InnermostNormalCleanup;
339 /// The innermost EH scope on the stack.
340 stable_iterator InnermostEHScope;
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.
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.
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
359 SmallVector<BranchFixup, 8> BranchFixups;
361 char *allocate(size_t Size);
363 void *pushCleanup(CleanupKind K, size_t DataSize);
366 EHScopeStack() : StartOfBuffer(0), EndOfBuffer(0), StartOfData(0),
367 InnermostNormalCleanup(stable_end()),
368 InnermostEHScope(stable_end()) {}
369 ~EHScopeStack() { delete[] StartOfBuffer; }
371 // Variadic templates would make this not terrible.
373 /// Push a lazily-created cleanup on the stack.
375 void pushCleanup(CleanupKind Kind) {
376 void *Buffer = pushCleanup(Kind, sizeof(T));
377 Cleanup *Obj = new(Buffer) T();
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);
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);
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);
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);
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);
421 // Feel free to add more variants of the following:
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.
429 /// The data stored in the extra storage must obey the same
430 /// restrictions as normal cleanup member data.
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);
440 /// Pops a cleanup scope off the stack. This is private to CGCleanup.cpp.
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
446 class EHCatchScope *pushCatch(unsigned NumHandlers);
448 /// Pops a catch scope off the stack. This is private to CGException.cpp.
451 /// Push an exceptions filter on the stack.
452 class EHFilterScope *pushFilter(unsigned NumFilters);
454 /// Pops an exceptions filter off the stack.
457 /// Push a terminate handler on the stack.
458 void pushTerminate();
460 /// Pops a terminate handler off the stack.
463 /// Determines whether the exception-scopes stack is empty.
464 bool empty() const { return StartOfData == EndOfBuffer; }
466 bool requiresLandingPad() const {
467 return InnermostEHScope != stable_end();
470 /// Determines whether there are any normal cleanups on the stack.
471 bool hasNormalCleanups() const {
472 return InnermostNormalCleanup != stable_end();
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;
480 stable_iterator getInnermostActiveNormalCleanup() const;
482 stable_iterator getInnermostEHScope() const {
483 return InnermostEHScope;
486 stable_iterator getInnermostActiveEHScope() const;
488 /// An unstable reference to a scope-stack depth. Invalidated by
489 /// pushes but not pops.
492 /// Returns an iterator pointing to the innermost EH scope.
493 iterator begin() const;
495 /// Returns an iterator pointing to the outermost EH scope.
496 iterator end() const;
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
501 stable_iterator stable_begin() const {
502 return stable_iterator(EndOfBuffer - StartOfData);
505 /// Create a stable reference to the bottom of the EH stack.
506 static stable_iterator stable_end() {
507 return stable_iterator(0);
510 /// Translates an iterator into a stable_iterator.
511 stable_iterator stabilize(iterator it) const;
513 /// Turn a stable reference to a scope depth into a unstable pointer
515 iterator find(stable_iterator save) const;
517 /// Removes the cleanup pointed to by the given stable_iterator.
518 void removeCleanup(stable_iterator save);
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();
527 unsigned getNumBranchFixups() const { return BranchFixups.size(); }
528 BranchFixup &getBranchFixup(unsigned I) {
529 assert(I < getNumBranchFixups());
530 return BranchFixups[I];
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();
538 /// Clears the branch-fixups list. This should only be called by
539 /// ResolveAllBranchFixups.
540 void clearFixups() { BranchFixups.clear(); }
543 /// CodeGenFunction - This class organizes the per-function state that is used
544 /// while generating LLVM code.
545 class CodeGenFunction : public CodeGenTypeCache {
546 CodeGenFunction(const CodeGenFunction &) LLVM_DELETED_FUNCTION;
547 void operator=(const CodeGenFunction &) LLVM_DELETED_FUNCTION;
549 friend class CGCXXABI;
551 /// A jump destination is an abstract label, branching to which may
552 /// require a jump out through normal cleanups.
554 JumpDest() : Block(0), ScopeDepth(), Index(0) {}
555 JumpDest(llvm::BasicBlock *Block,
556 EHScopeStack::stable_iterator Depth,
558 : Block(Block), ScopeDepth(Depth), Index(Index) {}
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; }
565 // This should be used cautiously.
566 void setScopeDepth(EHScopeStack::stable_iterator depth) {
571 llvm::BasicBlock *Block;
572 EHScopeStack::stable_iterator ScopeDepth;
576 CodeGenModule &CGM; // Per-module state.
577 const TargetInfo &Target;
579 typedef std::pair<llvm::Value *, llvm::Value *> ComplexPairTy;
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;
589 llvm::Function *CurFn;
591 /// CurGD - The GlobalDecl for the current function being compiled.
594 /// PrologueCleanupDepth - The cleanup depth enclosing all the
595 /// cleanups associated with the parameters.
596 EHScopeStack::stable_iterator PrologueCleanupDepth;
598 /// ReturnBlock - Unified return block.
599 JumpDest ReturnBlock;
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;
605 /// AllocaInsertPoint - This is an instruction in the entry block before which
606 /// we prefer to insert allocas.
607 llvm::AssertingVH<llvm::Instruction> AllocaInsertPt;
609 /// BoundsChecking - Emit run-time bounds checks. Higher values mean
610 /// potentially higher performance penalties.
611 unsigned char BoundsChecking;
613 /// \brief Whether any type-checking sanitizers are enabled. If \c false,
614 /// calls to EmitTypeCheck can be skipped.
615 bool SanitizePerformTypeCheck;
617 /// \brief Sanitizer options to use for this function.
618 const SanitizerOptions *SanOpts;
620 /// In ARC, whether we should autorelease the return value.
621 bool AutoreleaseResult;
623 const CodeGen::CGBlockInfo *BlockInfo;
624 llvm::Value *BlockPointer;
626 llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields;
627 FieldDecl *LambdaThisCaptureField;
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;
633 EHScopeStack EHStack;
635 /// i32s containing the indexes of the cleanup destinations.
636 llvm::AllocaInst *NormalCleanupDest;
638 unsigned NextCleanupDestIndex;
640 /// FirstBlockInfo - The head of a singly-linked-list of block layouts.
641 CGBlockInfo *FirstBlockInfo;
643 /// EHResumeBlock - Unified block containing a call to llvm.eh.resume.
644 llvm::BasicBlock *EHResumeBlock;
646 /// The exception slot. All landing pads write the current exception pointer
647 /// into this alloca.
648 llvm::Value *ExceptionSlot;
650 /// The selector slot. Under the MandatoryCleanup model, all landing pads
651 /// write the current selector value into this alloca.
652 llvm::AllocaInst *EHSelectorSlot;
654 /// Emits a landing pad for the current EH stack.
655 llvm::BasicBlock *EmitLandingPad();
657 llvm::BasicBlock *getInvokeDestImpl();
660 typename DominatingValue<T>::saved_type saveValueInCond(T value) {
661 return DominatingValue<T>::save(*this, value);
665 /// ObjCEHValueStack - Stack of Objective-C exception values, used for
667 SmallVector<llvm::Value*, 8> ObjCEHValueStack;
669 /// A class controlling the emission of a finally block.
671 /// Where the catchall's edge through the cleanup should go.
672 JumpDest RethrowDest;
674 /// A function to call to enter the catch.
675 llvm::Constant *BeginCatchFn;
677 /// An i1 variable indicating whether or not the @finally is
678 /// running for an exception.
679 llvm::AllocaInst *ForEHVar;
681 /// An i8* variable into which the exception pointer to rethrow
683 llvm::AllocaInst *SavedExnVar;
686 void enter(CodeGenFunction &CGF, const Stmt *Finally,
687 llvm::Constant *beginCatchFn, llvm::Constant *endCatchFn,
688 llvm::Constant *rethrowFn);
689 void exit(CodeGenFunction &CGF);
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);
702 typename DominatingValue<A0>::saved_type a0_saved = saveValueInCond(a0);
704 typedef EHScopeStack::ConditionalCleanup1<T, A0> CleanupType;
705 EHStack.pushCleanup<CleanupType>(kind, a0_saved);
706 initFullExprCleanup();
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);
719 typename DominatingValue<A0>::saved_type a0_saved = saveValueInCond(a0);
720 typename DominatingValue<A1>::saved_type a1_saved = saveValueInCond(a1);
722 typedef EHScopeStack::ConditionalCleanup2<T, A0, A1> CleanupType;
723 EHStack.pushCleanup<CleanupType>(kind, a0_saved, a1_saved);
724 initFullExprCleanup();
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);
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);
742 typedef EHScopeStack::ConditionalCleanup3<T, A0, A1, A2> CleanupType;
743 EHStack.pushCleanup<CleanupType>(kind, a0_saved, a1_saved, a2_saved);
744 initFullExprCleanup();
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);
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);
763 typedef EHScopeStack::ConditionalCleanup4<T, A0, A1, A2, A3> CleanupType;
764 EHStack.pushCleanup<CleanupType>(kind, a0_saved, a1_saved,
766 initFullExprCleanup();
769 /// Set up the last cleaup that was pushed as a conditional
770 /// full-expression cleanup.
771 void initFullExprCleanup();
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);
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,
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());
791 /// DeactivateCleanupBlock - Deactivates the given cleanup block.
792 /// The block cannot be reactivated. Pops it if it's the top of the
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);
802 /// ActivateCleanupBlock - Activates an initially-inactive cleanup.
803 /// Cannot be used to resurrect a deactivated cleanup.
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);
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;
821 RunCleanupsScope(const RunCleanupsScope &) LLVM_DELETED_FUNCTION;
822 void operator=(const RunCleanupsScope &) LLVM_DELETED_FUNCTION;
825 CodeGenFunction& CGF;
828 /// \brief Enter a new cleanup scope.
829 explicit RunCleanupsScope(CodeGenFunction &CGF)
830 : PerformCleanup(true), CGF(CGF)
832 CleanupStackDepth = CGF.EHStack.stable_begin();
833 OldDidCallStackSave = CGF.DidCallStackSave;
834 CGF.DidCallStackSave = false;
837 /// \brief Exit this cleanup scope, emitting any accumulated
839 ~RunCleanupsScope() {
840 if (PerformCleanup) {
841 CGF.DidCallStackSave = OldDidCallStackSave;
842 CGF.PopCleanupBlocks(CleanupStackDepth);
846 /// \brief Determine whether this scope requires any cleanups.
847 bool requiresCleanups() const {
848 return CGF.EHStack.stable_begin() != CleanupStackDepth;
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;
861 class LexicalScope: protected RunCleanupsScope {
863 SmallVector<const LabelDecl*, 4> Labels;
864 LexicalScope *ParentScope;
866 LexicalScope(const LexicalScope &) LLVM_DELETED_FUNCTION;
867 void operator=(const LexicalScope &) LLVM_DELETED_FUNCTION;
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());
878 void addLabel(const LabelDecl *label) {
879 assert(PerformCleanup && "adding label to dead scope?");
880 Labels.push_back(label);
883 /// \brief Exit this cleanup scope, emitting any accumulated
886 if (CGDebugInfo *DI = CGF.getDebugInfo())
887 DI->EmitLexicalBlockEnd(CGF.Builder, Range.getEnd());
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();
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();
904 void rescopeLabels();
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());
914 void ResolveBranchFixups(llvm::BasicBlock *Target);
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++);
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));
932 /// EmitBranchThroughCleanup - Emit a branch from the current insert
933 /// block through the normal cleanup handling code (if any) and then
935 void EmitBranchThroughCleanup(JumpDest Dest);
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;
942 /// popCatchScope - Pops the catch scope at the top of the EHScope
943 /// stack, emitting any required code (other than the catch handlers
945 void popCatchScope();
947 llvm::BasicBlock *getEHResumeBlock(bool isCleanup);
948 llvm::BasicBlock *getEHDispatchBlock(EHScopeStack::stable_iterator scope);
950 /// An object to manage conditionally-evaluated expressions.
951 class ConditionalEvaluation {
952 llvm::BasicBlock *StartBB;
955 ConditionalEvaluation(CodeGenFunction &CGF)
956 : StartBB(CGF.Builder.GetInsertBlock()) {}
958 void begin(CodeGenFunction &CGF) {
959 assert(CGF.OutermostConditional != this);
960 if (!CGF.OutermostConditional)
961 CGF.OutermostConditional = this;
964 void end(CodeGenFunction &CGF) {
965 assert(CGF.OutermostConditional != 0);
966 if (CGF.OutermostConditional == this)
967 CGF.OutermostConditional = 0;
970 /// Returns a block which will be executed prior to each
971 /// evaluation of the conditional code.
972 llvm::BasicBlock *getStartingBlock() const {
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; }
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());
987 /// An RAII object to record that we're evaluating a statement
989 class StmtExprEvaluation {
990 CodeGenFunction &CGF;
992 /// We have to save the outermost conditional: cleanups in a
993 /// statement expression aren't conditional just because the
995 ConditionalEvaluation *SavedOutermostConditional;
998 StmtExprEvaluation(CodeGenFunction &CGF)
999 : CGF(CGF), SavedOutermostConditional(CGF.OutermostConditional) {
1000 CGF.OutermostConditional = 0;
1003 ~StmtExprEvaluation() {
1004 CGF.OutermostConditional = SavedOutermostConditional;
1005 CGF.EnsureInsertPoint();
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;
1017 PeepholeProtection() : Inst(0) {}
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
1026 class OpaqueValueMappingData {
1027 const OpaqueValueExpr *OpaqueValue;
1029 CodeGenFunction::PeepholeProtection Protection;
1031 OpaqueValueMappingData(const OpaqueValueExpr *ov,
1033 : OpaqueValue(ov), BoundLValue(boundLValue) {}
1035 OpaqueValueMappingData() : OpaqueValue(0) {}
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
1043 return expr->isGLValue() ||
1044 expr->getType()->isRecordType() ||
1045 expr->getType()->isFunctionType();
1048 static OpaqueValueMappingData bind(CodeGenFunction &CGF,
1049 const OpaqueValueExpr *ov,
1051 if (shouldBindAsLValue(ov))
1052 return bind(CGF, ov, CGF.EmitLValue(e));
1053 return bind(CGF, ov, CGF.EmitAnyExpr(e));
1056 static OpaqueValueMappingData bind(CodeGenFunction &CGF,
1057 const OpaqueValueExpr *ov,
1059 assert(shouldBindAsLValue(ov));
1060 CGF.OpaqueLValues.insert(std::make_pair(ov, lv));
1061 return OpaqueValueMappingData(ov, true);
1064 static OpaqueValueMappingData bind(CodeGenFunction &CGF,
1065 const OpaqueValueExpr *ov,
1067 assert(!shouldBindAsLValue(ov));
1068 CGF.OpaqueRValues.insert(std::make_pair(ov, rv));
1070 OpaqueValueMappingData data(ov, false);
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);
1080 bool isValid() const { return OpaqueValue != 0; }
1081 void clear() { OpaqueValue = 0; }
1083 void unbind(CodeGenFunction &CGF) {
1084 assert(OpaqueValue && "no data to unbind!");
1087 CGF.OpaqueLValues.erase(OpaqueValue);
1089 CGF.OpaqueRValues.erase(OpaqueValue);
1090 CGF.unprotectFromPeepholes(Protection);
1095 /// An RAII object to set (and then clear) a mapping for an OpaqueValueExpr.
1096 class OpaqueValueMapping {
1097 CodeGenFunction &CGF;
1098 OpaqueValueMappingData Data;
1101 static bool shouldBindAsLValue(const Expr *expr) {
1102 return OpaqueValueMappingData::shouldBindAsLValue(expr);
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
1110 OpaqueValueMapping(CodeGenFunction &CGF,
1111 const AbstractConditionalOperator *op) : CGF(CGF) {
1112 if (isa<ConditionalOperator>(op))
1113 // Leave Data empty.
1116 const BinaryConditionalOperator *e = cast<BinaryConditionalOperator>(op);
1117 Data = OpaqueValueMappingData::bind(CGF, e->getOpaqueValue(),
1121 OpaqueValueMapping(CodeGenFunction &CGF,
1122 const OpaqueValueExpr *opaqueValue,
1124 : CGF(CGF), Data(OpaqueValueMappingData::bind(CGF, opaqueValue, lvalue)) {
1127 OpaqueValueMapping(CodeGenFunction &CGF,
1128 const OpaqueValueExpr *opaqueValue,
1130 : CGF(CGF), Data(OpaqueValueMappingData::bind(CGF, opaqueValue, rvalue)) {
1138 ~OpaqueValueMapping() {
1139 if (Data.isValid()) Data.unbind(CGF);
1143 /// getByrefValueFieldNumber - Given a declaration, returns the LLVM field
1144 /// number that holds the value.
1145 unsigned getByRefValueLLVMField(const ValueDecl *VD) const;
1147 /// BuildBlockByrefAddress - Computes address location of the
1148 /// variable which is declared as __block.
1149 llvm::Value *BuildBlockByrefAddress(llvm::Value *BaseAddr,
1152 CGDebugInfo *DebugInfo;
1153 bool DisableDebugInfo;
1155 /// If the current function returns 'this', use the field to keep track of
1156 /// the callee that returns 'this'.
1157 llvm::Value *CalleeWithThisReturn;
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;
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;
1169 /// LocalDeclMap - This keeps track of the LLVM allocas or globals for local C
1171 typedef llvm::DenseMap<const Decl*, llvm::Value*> DeclMapTy;
1172 DeclMapTy LocalDeclMap;
1174 /// LabelMap - This keeps track of the LLVM basic block for each C label.
1175 llvm::DenseMap<const LabelDecl*, JumpDest> LabelMap;
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) {}
1183 JumpDest BreakBlock;
1184 JumpDest ContinueBlock;
1186 SmallVector<BreakContinue, 8> BreakContinueStack;
1188 /// SwitchInsn - This is nearest current switch instruction. It is null if
1189 /// current context is not in a switch.
1190 llvm::SwitchInst *SwitchInsn;
1192 /// CaseRangeBlock - This block holds if condition check for last case
1193 /// statement range in current switch instruction.
1194 llvm::BasicBlock *CaseRangeBlock;
1196 /// OpaqueLValues - Keeps track of the current set of opaque value
1198 llvm::DenseMap<const OpaqueValueExpr *, LValue> OpaqueLValues;
1199 llvm::DenseMap<const OpaqueValueExpr *, RValue> OpaqueRValues;
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;
1209 /// A block containing a single 'unreachable' instruction. Created
1210 /// lazily by getUnreachableBlock().
1211 llvm::BasicBlock *UnreachableBlock;
1213 /// Counts of the number return expressions in the function.
1214 unsigned NumReturnExprs;
1216 /// Count the number of simple (constant) return expressions in the function.
1217 unsigned NumSimpleReturnExprs;
1219 /// The last regular (non-return) debug location (breakpoint) in the function.
1220 SourceLocation LastStopPoint;
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 {
1228 FieldConstructionScope(CodeGenFunction &CGF, llvm::Value *This)
1229 : CGF(CGF), OldCXXDefaultInitExprThis(CGF.CXXDefaultInitExprThis) {
1230 CGF.CXXDefaultInitExprThis = This;
1232 ~FieldConstructionScope() {
1233 CGF.CXXDefaultInitExprThis = OldCXXDefaultInitExprThis;
1237 CodeGenFunction &CGF;
1238 llvm::Value *OldCXXDefaultInitExprThis;
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 {
1245 CXXDefaultInitExprScope(CodeGenFunction &CGF)
1246 : CGF(CGF), OldCXXThisValue(CGF.CXXThisValue) {
1247 CGF.CXXThisValue = CGF.CXXDefaultInitExprThis;
1249 ~CXXDefaultInitExprScope() {
1250 CGF.CXXThisValue = OldCXXThisValue;
1254 CodeGenFunction &CGF;
1255 llvm::Value *OldCXXThisValue;
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;
1265 /// The value of 'this' to use when evaluating CXXDefaultInitExprs within
1266 /// this expression.
1267 llvm::Value *CXXDefaultInitExprThis;
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;
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;
1279 /// The current lexical scope.
1280 LexicalScope *CurLexicalScope;
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;
1287 llvm::BasicBlock *TerminateLandingPad;
1288 llvm::BasicBlock *TerminateHandler;
1289 llvm::BasicBlock *TrapBB;
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);
1305 CodeGenFunction(CodeGenModule &cgm, bool suppressNewContext=false);
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();
1318 CGDebugInfo *getDebugInfo() {
1319 if (DisableDebugInfo)
1323 void disableDebugInfo() { DisableDebugInfo = true; }
1324 void enableDebugInfo() { DisableDebugInfo = false; }
1326 bool shouldUseFusedARCCalls() {
1327 return CGM.getCodeGenOpts().OptimizationLevel == 0;
1330 const LangOptions &getLangOpts() const { return CGM.getLangOpts(); }
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();
1337 /// Returns the contents of the function's exception object and selector
1339 llvm::Value *getExceptionFromSlot();
1340 llvm::Value *getSelectorFromSlot();
1342 llvm::Value *getNormalCleanupDestSlot();
1344 llvm::BasicBlock *getUnreachableBlock() {
1345 if (!UnreachableBlock) {
1346 UnreachableBlock = createBasicBlock("unreachable");
1347 new llvm::UnreachableInst(getLLVMContext(), UnreachableBlock);
1349 return UnreachableBlock;
1352 llvm::BasicBlock *getInvokeDest() {
1353 if (!EHStack.requiresLandingPad()) return 0;
1354 return getInvokeDestImpl();
1357 const TargetInfo &getTarget() const { return Target; }
1358 llvm::LLVMContext &getLLVMContext() { return CGM.getLLVMContext(); }
1360 //===--------------------------------------------------------------------===//
1362 //===--------------------------------------------------------------------===//
1364 typedef void Destroyer(CodeGenFunction &CGF, llvm::Value *addr, QualType ty);
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);
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,
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);
1391 Destroyer *getDestroyer(QualType::DestructionKind destructionKind);
1393 /// Determines whether an EH cleanup is required to destroy a type
1394 /// with the given destruction kind.
1395 bool needsEHCleanup(QualType::DestructionKind kind) {
1397 case QualType::DK_none:
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;
1406 llvm_unreachable("bad destruction kind");
1409 CleanupKind getCleanupKind(QualType::DestructionKind kind) {
1410 return (needsEHCleanup(kind) ? NormalAndEHCleanup : NormalCleanup);
1413 //===--------------------------------------------------------------------===//
1415 //===--------------------------------------------------------------------===//
1417 void GenerateObjCMethod(const ObjCMethodDecl *OMD);
1419 void StartObjCMethod(const ObjCMethodDecl *MD,
1420 const ObjCContainerDecl *CD,
1421 SourceLocation StartLoc);
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);
1431 void GenerateObjCCtorDtorMethod(ObjCImplementationDecl *IMP,
1432 ObjCMethodDecl *MD, bool ctor);
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);
1444 //===--------------------------------------------------------------------===//
1446 //===--------------------------------------------------------------------===//
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,
1454 llvm::Constant *BlockVarLayout);
1456 llvm::Function *GenerateBlockFunction(GlobalDecl GD,
1457 const CGBlockInfo &Info,
1458 const DeclMapTy &ldm,
1459 bool IsLambdaConversionToBlock);
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);
1469 void BuildBlockRelease(llvm::Value *DeclPtr, BlockFieldFlags flags);
1471 class AutoVarEmission;
1473 void emitByrefStructureInit(const AutoVarEmission &emission);
1474 void enterByrefCleanup(const AutoVarEmission &emission);
1476 llvm::Value *LoadBlockStruct() {
1477 assert(BlockPointer && "no block pointer set!");
1478 return BlockPointer;
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);
1486 void GenerateCode(GlobalDecl GD, llvm::Function *Fn,
1487 const CGFunctionInfo &FnInfo);
1488 void StartFunction(GlobalDecl GD,
1491 const CGFunctionInfo &FnInfo,
1492 const FunctionArgList &Args,
1493 SourceLocation StartLoc);
1495 void EmitConstructorBody(FunctionArgList &Args);
1496 void EmitDestructorBody(FunctionArgList &Args);
1497 void emitImplicitAssignmentOperatorBody(FunctionArgList &Args);
1498 void EmitFunctionBody(FunctionArgList &Args);
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);
1507 /// EmitReturnBlock - Emit the unified return block, trying to avoid its
1508 /// emission when possible.
1509 void EmitReturnBlock();
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());
1515 /// GenerateThunk - Generate a thunk for the given method.
1516 void GenerateThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo,
1517 GlobalDecl GD, const ThunkInfo &Thunk);
1519 void GenerateVarArgsThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo,
1520 GlobalDecl GD, const ThunkInfo &Thunk);
1522 void EmitCtorPrologue(const CXXConstructorDecl *CD, CXXCtorType Type,
1523 FunctionArgList &Args);
1525 void EmitInitializerForField(FieldDecl *Field, LValue LHS, Expr *Init,
1526 ArrayRef<VarDecl *> ArrayIndexes);
1528 /// InitializeVTablePointer - Initialize the vtable pointer of the given
1531 void InitializeVTablePointer(BaseSubobject Base,
1532 const CXXRecordDecl *NearestVBase,
1533 CharUnits OffsetFromNearestVBase,
1534 llvm::Constant *VTable,
1535 const CXXRecordDecl *VTableClass);
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);
1546 void InitializeVTablePointers(const CXXRecordDecl *ClassDecl);
1548 /// GetVTablePtr - Return the Value of the vtable pointer member pointed
1550 llvm::Value *GetVTablePtr(llvm::Value *This, llvm::Type *Ty);
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);
1558 /// ShouldInstrumentFunction - Return true if the current function should be
1559 /// instrumented with __cyg_profile_func_* calls
1560 bool ShouldInstrumentFunction();
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);
1567 /// EmitMCountInstrumentation - Emit call to .mcount.
1568 void EmitMCountInstrumentation();
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,
1575 const FunctionArgList &Args);
1577 /// EmitFunctionEpilog - Emit the target specific LLVM code to return the
1578 /// given temporary.
1579 void EmitFunctionEpilog(const CGFunctionInfo &FI, bool EmitRetDbgLoc);
1581 /// EmitStartEHSpec - Emit the start of the exception spec.
1582 void EmitStartEHSpec(const Decl *D);
1584 /// EmitEndEHSpec - Emit the end of the exception spec.
1585 void EmitEndEHSpec(const Decl *D);
1587 /// getTerminateLandingPad - Return a landing pad that just calls terminate.
1588 llvm::BasicBlock *getTerminateLandingPad();
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();
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));
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();
1605 /// TypeOfSelfObject - Return type of object that this self represents.
1606 QualType TypeOfSelfObject();
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);
1612 static bool hasScalarEvaluationKind(QualType T) {
1613 return getEvaluationKind(T) == TEK_Scalar;
1616 static bool hasAggregateEvaluationKind(QualType T) {
1617 return getEvaluationKind(T) == TEK_Aggregate;
1620 /// createBasicBlock - Create an LLVM basic block.
1621 llvm::BasicBlock *createBasicBlock(const Twine &name = "",
1622 llvm::Function *parent = 0,
1623 llvm::BasicBlock *before = 0) {
1625 return llvm::BasicBlock::Create(getLLVMContext(), "", parent, before);
1627 return llvm::BasicBlock::Create(getLLVMContext(), name, parent, before);
1631 /// getBasicBlockForLabel - Return the LLVM basicblock that the specified
1633 JumpDest getJumpDestForLabel(const LabelDecl *S);
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);
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.
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);
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);
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.
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
1662 void EmitBranch(llvm::BasicBlock *Block);
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;
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());
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);
1684 //===--------------------------------------------------------------------===//
1686 //===--------------------------------------------------------------------===//
1688 LValue MakeAddrLValue(llvm::Value *V, QualType T,
1689 CharUnits Alignment = CharUnits()) {
1690 return LValue::MakeAddr(V, T, Alignment, getContext(),
1691 CGM.getTBAAInfo(T));
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));
1702 /// CreateTempAlloca - This creates a alloca and inserts it into the entry
1703 /// block. The caller is responsible for setting an appropriate alignment on
1705 llvm::AllocaInst *CreateTempAlloca(llvm::Type *Ty,
1706 const Twine &Name = "tmp");
1708 /// InitTempAlloca - Provide an initial value for the given alloca.
1709 void InitTempAlloca(llvm::AllocaInst *Alloca, llvm::Value *Value);
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");
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");
1722 /// CreateAggTemp - Create a temporary memory object for the given
1724 AggValueSlot CreateAggTemp(QualType T, const Twine &Name = "tmp") {
1725 CharUnits Alignment = getContext().getTypeAlignInChars(T);
1726 return AggValueSlot::forAddr(CreateMemTemp(T, Name), Alignment,
1728 AggValueSlot::IsNotDestructed,
1729 AggValueSlot::DoesNotNeedGCBarriers,
1730 AggValueSlot::IsNotAliased);
1733 /// Emit a cast to void* in the appropriate address space.
1734 llvm::Value *EmitCastToVoidPtr(llvm::Value *value);
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);
1740 /// EmitIgnoredExpr - Emit an expression in a context which ignores the result.
1741 void EmitIgnoredExpr(const Expr *E);
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.
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);
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);
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);
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);
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);
1771 /// hasVolatileMember - returns true if aggregate type has a volatile
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();
1780 /// EmitAggregateCopy - Emit an aggregate assignment.
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,
1786 bool IsVolatile = hasVolatileMember(EltTy);
1787 EmitAggregateCopy(DestPtr, SrcPtr, EltTy, IsVolatile, CharUnits::Zero(),
1791 /// EmitAggregateCopy - Emit an aggregate copy.
1793 /// \param isVolatile - True iff either the source or the destination is
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);
1802 /// StartBlock - Start new block named N. If insert block is a dummy block
1804 void StartBlock(const char *N);
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!");
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));
1818 llvm::DenseMap<const OpaqueValueExpr*,LValue>::iterator
1819 it = OpaqueLValues.find(e);
1820 assert(it != OpaqueLValues.end() && "no mapping for opaque value!");
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));
1829 llvm::DenseMap<const OpaqueValueExpr*,RValue>::iterator
1830 it = OpaqueRValues.find(e);
1831 assert(it != OpaqueRValues.end() && "no mapping for opaque value!");
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);
1839 llvm::BlockAddress *GetAddrOfLabel(const LabelDecl *L);
1840 llvm::BasicBlock *GetIndirectGotoBlock();
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);
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);
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,
1857 llvm::Value *&addr);
1859 /// EmitVLASize - Capture all the sizes for the VLA expressions in
1860 /// the given variably-modified type and store them in the VLASizeMap.
1862 /// This function can be called with a null (unreachable) insert point.
1863 void EmitVariablyModifiedType(QualType Ty);
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);
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;
1879 /// LoadCXXVTT - Load the VTT parameter to base constructors/destructors have
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;
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;
1896 /// GetAddressOfBaseOfCompleteClass - Convert the given pointer to a
1897 /// complete class to the given direct base.
1899 GetAddressOfDirectBaseInCompleteClass(llvm::Value *Value,
1900 const CXXRecordDecl *Derived,
1901 const CXXRecordDecl *Base,
1902 bool BaseIsVirtual);
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);
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);
1918 llvm::Value *GetVirtualBaseClassOffset(llvm::Value *This,
1919 const CXXRecordDecl *ClassDecl,
1920 const CXXRecordDecl *BaseClassDecl);
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,
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,
1941 CallExpr::const_arg_iterator ArgBeg,
1942 CallExpr::const_arg_iterator ArgEnd);
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);
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);
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);
1963 static Destroyer destroyCXXObject;
1965 void EmitCXXDestructorCall(const CXXDestructorDecl *D, CXXDtorType Type,
1966 bool ForVirtualBase, bool Delegating,
1969 void EmitNewArrayInitializer(const CXXNewExpr *E, QualType elementType,
1970 llvm::Value *NewPtr, llvm::Value *NumElements);
1972 void EmitCXXTemporary(const CXXTemporary *Temporary, QualType TempType,
1975 llvm::Value *EmitCXXNewExpr(const CXXNewExpr *E);
1976 void EmitCXXDeleteExpr(const CXXDeleteExpr *E);
1978 void EmitDeleteCall(const FunctionDecl *DeleteFD, llvm::Value *Ptr,
1981 llvm::Value* EmitCXXTypeidExpr(const CXXTypeidExpr *E);
1982 llvm::Value *EmitDynamicCast(llvm::Value *V, const CXXDynamicCastExpr *DCE);
1983 llvm::Value* EmitCXXUuidofExpr(const CXXUuidofExpr *E);
1985 void MaybeEmitStdInitializerListCleanup(llvm::Value *loc, const Expr *init);
1986 void EmitStdInitializerListCleanup(llvm::Value *loc,
1987 const InitListExpr *init);
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.
1994 /// Checking the destination of a store. Must be suitably sized and aligned.
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.
2003 /// Checking the 'this' pointer for a call to a non-static member function.
2004 /// Must be an object within its lifetime.
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
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());
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);
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 //===--------------------------------------------------------------------===//
2035 /// EmitDecl - Emit a declaration.
2037 /// This function can be called with a null (unreachable) insert point.
2038 void EmitDecl(const Decl &D);
2040 /// EmitVarDecl - Emit a local variable declaration.
2042 /// This function can be called with a null (unreachable) insert point.
2043 void EmitVarDecl(const VarDecl &D);
2045 void EmitScalarInit(const Expr *init, const ValueDecl *D,
2046 LValue lvalue, bool capturedByInit);
2047 void EmitScalarInit(llvm::Value *init, LValue lvalue);
2049 typedef void SpecialInitFn(CodeGenFunction &Init, const VarDecl &D,
2050 llvm::Value *Address);
2052 /// EmitAutoVarDecl - Emit an auto variable declaration.
2054 /// This function can be called with a null (unreachable) insert point.
2055 void EmitAutoVarDecl(const VarDecl &D);
2057 class AutoVarEmission {
2058 friend class CodeGenFunction;
2060 const VarDecl *Variable;
2062 /// The alignment of the variable.
2063 CharUnits Alignment;
2065 /// The address of the alloca. Null if the variable was emitted
2066 /// as a global constant.
2067 llvm::Value *Address;
2069 llvm::Value *NRVOFlag;
2071 /// True if the variable is a __block variable.
2074 /// True if the variable is of aggregate type and has a constant
2076 bool IsConstantAggregate;
2078 /// Non-null if we should use lifetime annotations.
2079 llvm::Value *SizeForLifetimeMarkers;
2082 AutoVarEmission(Invalid) : Variable(0) {}
2084 AutoVarEmission(const VarDecl &variable)
2085 : Variable(&variable), Address(0), NRVOFlag(0),
2086 IsByRef(false), IsConstantAggregate(false),
2087 SizeForLifetimeMarkers(0) {}
2089 bool wasEmittedAsGlobal() const { return Address == 0; }
2092 static AutoVarEmission invalid() { return AutoVarEmission(Invalid()); }
2094 bool useLifetimeMarkers() const { return SizeForLifetimeMarkers != 0; }
2095 llvm::Value *getSizeForLifetimeMarkers() const {
2096 assert(useLifetimeMarkers());
2097 return SizeForLifetimeMarkers;
2100 /// Returns the raw, allocated address, which is not necessarily
2101 /// the address of the object itself.
2102 llvm::Value *getAllocatedAddress() const {
2106 /// Returns the address of the object within this declaration.
2107 /// Note that this does not chase the forwarding pointer for
2109 llvm::Value *getObjectAddress(CodeGenFunction &CGF) const {
2110 if (!IsByRef) return Address;
2112 return CGF.Builder.CreateStructGEP(Address,
2113 CGF.getByRefValueLLVMField(Variable),
2114 Variable->getNameAsString());
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);
2123 void EmitStaticVarDecl(const VarDecl &D,
2124 llvm::GlobalValue::LinkageTypes Linkage);
2126 /// EmitParmDecl - Emit a ParmVarDecl or an ImplicitParamDecl.
2127 void EmitParmDecl(const VarDecl &D, llvm::Value *Arg, unsigned ArgNo);
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.
2133 /// Pass the result to unprotectFromPeepholes to declare that
2134 /// protection is no longer required.
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);
2141 //===--------------------------------------------------------------------===//
2142 // Statement Emission
2143 //===--------------------------------------------------------------------===//
2145 /// EmitStopPoint - Emit a debug stoppoint if we are emitting debug info.
2146 void EmitStopPoint(const Stmt *S);
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.
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);
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
2161 /// \return True if the statement was handled.
2162 bool EmitSimpleStmt(const Stmt *S);
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());
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.
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);
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);
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);
2204 void EmitCXXTryStmt(const CXXTryStmt &S);
2205 void EmitCXXForRangeStmt(const CXXForRangeStmt &S);
2207 //===--------------------------------------------------------------------===//
2208 // LValue Expression Emission
2209 //===--------------------------------------------------------------------===//
2211 /// GetUndefRValue - Get an appropriate 'undef' rvalue for the given type.
2212 RValue GetUndefRValue(QualType Ty);
2214 /// EmitUnsupportedRValue - Emit a dummy r-value using the type of E
2215 /// and issue an ErrorUnsupported style diagnostic (using the
2217 RValue EmitUnsupportedRValue(const Expr *E,
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,
2225 /// EmitLValue - Emit code to compute a designator that specifies the location
2226 /// of the expression.
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.
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
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.
2241 LValue EmitLValue(const Expr *E);
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);
2248 RValue convertTempToRValue(llvm::Value *addr, QualType type);
2250 void EmitAtomicInit(Expr *E, LValue lvalue);
2252 RValue EmitAtomicLoad(LValue lvalue,
2253 AggValueSlot slot = AggValueSlot::ignored());
2255 void EmitAtomicStore(RValue rvalue, LValue lvalue, bool isInit);
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);
2261 /// EmitFromMemory - Change a scalar value from its memory
2262 /// representation to its value representation.
2263 llvm::Value *EmitFromMemory(llvm::Value *Value, QualType Ty);
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);
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
2278 llvm::Value *EmitLoadOfScalar(LValue lvalue);
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);
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);
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);
2303 /// EmitStoreThroughLValue - Store the specified rvalue into the specified
2304 /// lvalue, where both are guaranteed to the have the same type, and that type
2306 void EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit=false);
2307 void EmitStoreThroughExtVectorComponentLValue(RValue Src, LValue Dst);
2309 /// EmitStoreThroughLValue - Store Src into Dst with same constraints as
2310 /// EmitStoreThroughLValue.
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);
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);
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);
2347 RValue EmitRValueForField(LValue LV, const FieldDecl *FD);
2349 class ConstantEmission {
2350 llvm::PointerIntPair<llvm::Constant*, 1, bool> ValueAndIsReference;
2351 ConstantEmission(llvm::Constant *C, bool isReference)
2352 : ValueAndIsReference(C, isReference) {}
2354 ConstantEmission() {}
2355 static ConstantEmission forReference(llvm::Constant *C) {
2356 return ConstantEmission(C, true);
2358 static ConstantEmission forValue(llvm::Constant *C) {
2359 return ConstantEmission(C, false);
2362 operator bool() const { return ValueAndIsReference.getOpaqueValue() != 0; }
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());
2371 llvm::Constant *getValue() const {
2372 assert(!isReference());
2373 return ValueAndIsReference.getPointer();
2377 ConstantEmission tryEmitAsConstant(DeclRefExpr *refExpr);
2379 RValue EmitPseudoObjectRValue(const PseudoObjectExpr *e,
2380 AggValueSlot slot = AggValueSlot::ignored());
2381 LValue EmitPseudoObjectLValue(const PseudoObjectExpr *e);
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);
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);
2394 LValue EmitLValueForIvar(QualType ObjectTy,
2395 llvm::Value* Base, const ObjCIvarDecl *Ivar,
2396 unsigned CVRQualifiers);
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);
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);
2411 //===--------------------------------------------------------------------===//
2412 // Scalar Expression Emission
2413 //===--------------------------------------------------------------------===//
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.
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);
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());
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 = "");
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);
2460 llvm::Value *BuildVirtualCall(const CXXMethodDecl *MD, llvm::Value *This,
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,
2468 llvm::Value *BuildAppleKextVirtualDestructorCall(const CXXDestructorDecl *DD,
2470 const CXXRecordDecl *RD);
2472 RValue EmitCXXMemberCall(const CXXMethodDecl *MD,
2473 SourceLocation CallLoc,
2474 llvm::Value *Callee,
2475 ReturnValueSlot ReturnValue,
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);
2486 llvm::Value *EmitCXXOperatorMemberCallee(const CXXOperatorCallExpr *E,
2487 const CXXMethodDecl *MD,
2489 RValue EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E,
2490 const CXXMethodDecl *MD,
2491 ReturnValueSlot ReturnValue);
2493 RValue EmitCUDAKernelCallExpr(const CUDAKernelCallExpr *E,
2494 ReturnValueSlot ReturnValue);
2497 RValue EmitBuiltinExpr(const FunctionDecl *FD,
2498 unsigned BuiltinID, const CallExpr *E);
2500 RValue EmitBlockCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue);
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);
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,
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);
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);
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());
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;
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,
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);
2563 std::pair<LValue,llvm::Value*>
2564 EmitARCStoreAutoreleasing(const BinaryOperator *e);
2565 std::pair<LValue,llvm::Value*>
2566 EmitARCStoreStrong(const BinaryOperator *e, bool ignored);
2568 llvm::Value *EmitObjCThrowOperand(const Expr *expr);
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);
2574 llvm::Value *EmitARCExtendBlockObject(const Expr *expr);
2575 llvm::Value *EmitARCRetainScalarExpr(const Expr *expr);
2576 llvm::Value *EmitARCRetainAutoreleaseScalarExpr(const Expr *expr);
2578 void EmitARCIntrinsicUse(llvm::ArrayRef<llvm::Value*> values);
2580 static Destroyer destroyARCStrongImprecise;
2581 static Destroyer destroyARCStrongPrecise;
2582 static Destroyer destroyARCWeak;
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);
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);
2595 //===--------------------------------------------------------------------===//
2596 // Expression Emission
2597 //===--------------------------------------------------------------------===//
2599 // Expressions are broken into three classes: scalar, complex, aggregate.
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);
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,
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,
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);
2622 /// EmitAggExprToLValue - Emit the computation of the specified expression of
2623 /// aggregate type into a temporary LValue.
2624 LValue EmitAggExprToLValue(const Expr *E);
2626 /// EmitGCMemmoveCollectable - Emit special API for structs with object
2628 void EmitGCMemmoveCollectable(llvm::Value *DestPtr, llvm::Value *SrcPtr,
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);
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);
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);
2645 /// EmitStoreOfComplex - Store a complex number into the specified l-value.
2646 void EmitStoreOfComplex(ComplexPairTy V, LValue dest, bool isInit);
2648 /// EmitLoadOfComplex - Load a complex number from the specified l-value.
2649 ComplexPairTy EmitLoadOfComplex(LValue src);
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);
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);
2666 /// EmitCXXGlobalVarDeclInit - Create the initializer for a C++
2667 /// variable with global storage.
2668 void EmitCXXGlobalVarDeclInit(const VarDecl &D, llvm::Constant *DeclPtr,
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);
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,
2683 /// GenerateCXXGlobalInitFunc - Generates code for initializing global
2685 void GenerateCXXGlobalInitFunc(llvm::Function *Fn,
2686 ArrayRef<llvm::Constant *> Decls,
2687 llvm::GlobalVariable *Guard = 0);
2689 /// GenerateCXXGlobalDtorsFunc - Generates code for destroying global
2691 void GenerateCXXGlobalDtorsFunc(llvm::Function *Fn,
2692 const std::vector<std::pair<llvm::WeakVH,
2693 llvm::Constant*> > &DtorsAndObjects);
2695 void GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn,
2697 llvm::GlobalVariable *Addr,
2700 void EmitCXXConstructExpr(const CXXConstructExpr *E, AggValueSlot Dest);
2702 void EmitSynthesizedCXXCopyCtor(llvm::Value *Dest, llvm::Value *Src,
2705 void enterFullExpression(const ExprWithCleanups *E) {
2706 if (E->getNumObjects() == 0) return;
2707 enterNonTrivialFullExpression(E);
2709 void enterNonTrivialFullExpression(const ExprWithCleanups *E);
2711 void EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint = true);
2713 void EmitLambdaExpr(const LambdaExpr *E, AggValueSlot Dest);
2715 RValue EmitAtomicExpr(AtomicExpr *E, llvm::Value *Dest = 0);
2717 //===--------------------------------------------------------------------===//
2718 // Annotations Emission
2719 //===--------------------------------------------------------------------===//
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);
2727 /// Emit local annotations for the local variable V, declared by D.
2728 void EmitVarAnnotations(const VarDecl *D, llvm::Value *V);
2730 /// Emit field annotations for the given field & value. Returns the
2731 /// annotation result.
2732 llvm::Value *EmitFieldAnnotations(const FieldDecl *D, llvm::Value *V);
2734 //===--------------------------------------------------------------------===//
2736 //===--------------------------------------------------------------------===//
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);
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);
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);
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);
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);
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);
2768 /// \brief Convert a value into a format suitable for passing to a runtime
2769 /// sanitizer handler.
2770 llvm::Value *EmitCheckValue(llvm::Value *V);
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);
2776 /// \brief Specify under what conditions this check can be recovered
2777 enum CheckRecoverableKind {
2778 /// Always terminate program execution if this check fails
2780 /// Check supports recovering, allows user to specify which
2782 /// Runtime conditionally aborts, always need to support recovery.
2783 CRK_AlwaysRecoverable
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
2789 void EmitCheck(llvm::Value *Checked, StringRef CheckName,
2790 ArrayRef<llvm::Constant *> StaticArgs,
2791 ArrayRef<llvm::Value *> DynamicArgs,
2792 CheckRecoverableKind Recoverable);
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);
2798 /// EmitCallArg - Emit a single call argument.
2799 void EmitCallArg(CallArgList &args, const Expr *E, QualType ArgType);
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);
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);
2811 llvm::MDNode *getRangeForLoadFromType(QualType Ty);
2812 void EmitReturnOfRValue(RValue RV, QualType Ty);
2814 /// ExpandTypeFromArgs - Reconstruct a structure of type \arg Ty
2815 /// from function arguments into \arg Dst. See ABIArgInfo::Expand.
2817 /// \param AI - The first function argument of the expansion.
2818 /// \return The argument following the last expanded function
2820 llvm::Function::arg_iterator
2821 ExpandTypeFromArgs(QualType Ty, LValue Dst,
2822 llvm::Function::arg_iterator AI);
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);
2831 llvm::Value* EmitAsmInput(const TargetInfo::ConstraintInfo &Info,
2832 const Expr *InputExpr, std::string &ConstraintStr);
2834 llvm::Value* EmitAsmInputLValue(const TargetInfo::ConstraintInfo &Info,
2835 LValue InputValue, QualType InputType,
2836 std::string &ConstraintStr);
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;
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;
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;
2868 assert(getContext().getCanonicalType(ArgType.getNonReferenceType()).
2870 getContext().getCanonicalType(ActualArgType).getTypePtr() &&
2871 "type mismatch in call argument!");
2873 EmitCallArg(Args, *Arg, ArgType);
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!");
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());
2888 const TargetCodeGenInfo &getTargetHooks() const {
2889 return CGM.getTargetCodeGenInfo();
2892 void EmitDeclMetadata();
2894 CodeGenModule::ByrefHelpers *
2895 buildByrefHelpers(llvm::StructType &byrefType,
2896 const AutoVarEmission &emission);
2898 void AddObjCARCExceptionMetadata(llvm::Instruction *Inst);
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);
2905 /// Helper class with most of the code for saving a value for a
2906 /// conditional expression cleanup.
2907 struct DominatingLLVMValue {
2908 typedef llvm::PointerIntPair<llvm::Value*, 1, bool> saved_type;
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;
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());
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);
2924 // Otherwise we need an alloca.
2925 llvm::Value *alloca =
2926 CGF.CreateTempAlloca(value->getType(), "cond-cleanup.save");
2927 CGF.Builder.CreateStore(value, alloca);
2929 return saved_type(alloca, true);
2932 static llvm::Value *restore(CodeGenFunction &CGF, saved_type value) {
2933 if (!value.getInt()) return value.getPointer();
2934 return CGF.Builder.CreateLoad(value.getPointer());
2938 /// A partial specialization of DominatingValue for llvm::Values that
2939 /// might be llvm::Instructions.
2940 template <class T> struct DominatingPointer<T,true> : DominatingLLVMValue {
2942 static type restore(CodeGenFunction &CGF, saved_type value) {
2943 return static_cast<T*>(DominatingLLVMValue::restore(CGF, value));
2947 /// A specialization of DominatingValue for RValue.
2948 template <> struct DominatingValue<RValue> {
2949 typedef RValue type;
2951 enum Kind { ScalarLiteral, ScalarAddress, AggregateLiteral,
2952 AggregateAddress, ComplexAddress };
2956 saved_type(llvm::Value *v, Kind k) : Value(v), K(k) {}
2959 static bool needsSaving(RValue value);
2960 static saved_type save(CodeGenFunction &CGF, RValue value);
2961 RValue restore(CodeGenFunction &CGF);
2963 // implementations in CGExprCXX.cpp
2966 static bool needsSaving(type value) {
2967 return saved_type::needsSaving(value);
2969 static saved_type save(CodeGenFunction &CGF, type value) {
2970 return saved_type::save(CGF, value);
2972 static type restore(CodeGenFunction &CGF, saved_type value) {
2973 return value.restore(CGF);
2977 } // end namespace CodeGen
2978 } // end namespace clang