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 "clang/AST/Type.h"
18 #include "clang/AST/ExprCXX.h"
19 #include "clang/AST/ExprObjC.h"
20 #include "clang/AST/CharUnits.h"
21 #include "clang/Basic/TargetInfo.h"
22 #include "llvm/ADT/DenseMap.h"
23 #include "llvm/ADT/SmallVector.h"
24 #include "llvm/Support/ValueHandle.h"
25 #include "CodeGenModule.h"
27 #include "CGBuilder.h"
45 class CXXDestructorDecl;
48 class EnumConstantDecl;
50 class FunctionProtoType;
52 class ObjCContainerDecl;
53 class ObjCInterfaceDecl;
56 class ObjCImplementationDecl;
57 class ObjCPropertyImplDecl;
59 class TargetCodeGenInfo;
61 class ObjCForCollectionStmt;
63 class ObjCAtThrowStmt;
64 class ObjCAtSynchronizedStmt;
73 /// A branch fixup. These are required when emitting a goto to a
74 /// label which hasn't been emitted yet. The goto is optimistically
75 /// emitted as a branch to the basic block for the label, and (if it
76 /// occurs in a scope with non-trivial cleanups) a fixup is added to
77 /// the innermost cleanup. When a (normal) cleanup is popped, any
78 /// unresolved fixups in that scope are threaded through the cleanup.
80 /// The origin of the branch. Any switch-index stores required by
81 /// cleanup threading are added before this instruction.
82 llvm::Instruction *Origin;
84 /// The destination of the branch.
86 /// This can be set to null to indicate that this fixup was
87 /// successfully resolved.
88 llvm::BasicBlock *Destination;
90 /// The last branch of the fixup. It is an invariant that
91 /// LatestBranch->getSuccessor(LatestBranchIndex) == Destination.
93 /// The branch is always either a BranchInst or a SwitchInst.
94 llvm::TerminatorInst *LatestBranch;
95 unsigned LatestBranchIndex;
98 enum CleanupKind { NormalAndEHCleanup, EHCleanup, NormalCleanup };
100 /// A stack of scopes which respond to exceptions, including cleanups
101 /// and catch blocks.
104 /// A saved depth on the scope stack. This is necessary because
105 /// pushing scopes onto the stack invalidates iterators.
106 class stable_iterator {
107 friend class EHScopeStack;
109 /// Offset from StartOfData to EndOfBuffer.
112 stable_iterator(ptrdiff_t Size) : Size(Size) {}
115 static stable_iterator invalid() { return stable_iterator(-1); }
116 stable_iterator() : Size(-1) {}
118 bool isValid() const { return Size >= 0; }
120 friend bool operator==(stable_iterator A, stable_iterator B) {
121 return A.Size == B.Size;
123 friend bool operator!=(stable_iterator A, stable_iterator B) {
124 return A.Size != B.Size;
128 /// A lazy cleanup. Subclasses must be POD-like: cleanups will
129 /// not be destructed, and they will be allocated on the cleanup
130 /// stack and freely copied and moved around.
132 /// LazyCleanup implementations should generally be declared in an
133 /// anonymous namespace.
136 // Anchor the construction vtable. We use the destructor because
137 // gcc gives an obnoxious warning if there are virtual methods
138 // with an accessible non-virtual destructor. Unfortunately,
139 // declaring this destructor makes it non-trivial, but there
140 // doesn't seem to be any other way around this warning.
142 // This destructor will never be called.
143 virtual ~LazyCleanup();
145 /// Emit the cleanup. For normal cleanups, this is run in the
146 /// same EH context as when the cleanup was pushed, i.e. the
147 /// immediately-enclosing context of the cleanup scope. For
148 /// EH cleanups, this is run in a terminate context.
150 // \param IsForEHCleanup true if this is for an EH cleanup, false
151 /// if for a normal cleanup.
152 virtual void Emit(CodeGenFunction &CGF, bool IsForEHCleanup) = 0;
156 // The implementation for this class is in CGException.h and
157 // CGException.cpp; the definition is here because it's used as a
158 // member of CodeGenFunction.
160 /// The start of the scope-stack buffer, i.e. the allocated pointer
161 /// for the buffer. All of these pointers are either simultaneously
162 /// null or simultaneously valid.
165 /// The end of the buffer.
168 /// The first valid entry in the buffer.
171 /// The innermost normal cleanup on the stack.
172 stable_iterator InnermostNormalCleanup;
174 /// The innermost EH cleanup on the stack.
175 stable_iterator InnermostEHCleanup;
177 /// The number of catches on the stack.
180 /// The current set of branch fixups. A branch fixup is a jump to
181 /// an as-yet unemitted label, i.e. a label for which we don't yet
182 /// know the EH stack depth. Whenever we pop a cleanup, we have
183 /// to thread all the current branch fixups through it.
185 /// Fixups are recorded as the Use of the respective branch or
186 /// switch statement. The use points to the final destination.
187 /// When popping out of a cleanup, these uses are threaded through
188 /// the cleanup and adjusted to point to the new cleanup.
190 /// Note that branches are allowed to jump into protected scopes
191 /// in certain situations; e.g. the following code is legal:
192 /// struct A { ~A(); }; // trivial ctor, non-trivial dtor
197 llvm::SmallVector<BranchFixup, 8> BranchFixups;
199 char *allocate(size_t Size);
201 void popNullFixups();
203 void *pushLazyCleanup(CleanupKind K, size_t DataSize);
206 EHScopeStack() : StartOfBuffer(0), EndOfBuffer(0), StartOfData(0),
207 InnermostNormalCleanup(stable_end()),
208 InnermostEHCleanup(stable_end()),
210 ~EHScopeStack() { delete[] StartOfBuffer; }
212 // Variadic templates would make this not terrible.
214 /// Push a lazily-created cleanup on the stack.
216 void pushLazyCleanup(CleanupKind Kind) {
217 void *Buffer = pushLazyCleanup(Kind, sizeof(T));
218 LazyCleanup *Obj = new(Buffer) T();
222 /// Push a lazily-created cleanup on the stack.
223 template <class T, class A0>
224 void pushLazyCleanup(CleanupKind Kind, A0 a0) {
225 void *Buffer = pushLazyCleanup(Kind, sizeof(T));
226 LazyCleanup *Obj = new(Buffer) T(a0);
230 /// Push a lazily-created cleanup on the stack.
231 template <class T, class A0, class A1>
232 void pushLazyCleanup(CleanupKind Kind, A0 a0, A1 a1) {
233 void *Buffer = pushLazyCleanup(Kind, sizeof(T));
234 LazyCleanup *Obj = new(Buffer) T(a0, a1);
238 /// Push a lazily-created cleanup on the stack.
239 template <class T, class A0, class A1, class A2>
240 void pushLazyCleanup(CleanupKind Kind, A0 a0, A1 a1, A2 a2) {
241 void *Buffer = pushLazyCleanup(Kind, sizeof(T));
242 LazyCleanup *Obj = new(Buffer) T(a0, a1, a2);
246 /// Push a lazily-created cleanup on the stack.
247 template <class T, class A0, class A1, class A2, class A3>
248 void pushLazyCleanup(CleanupKind Kind, A0 a0, A1 a1, A2 a2, A3 a3) {
249 void *Buffer = pushLazyCleanup(Kind, sizeof(T));
250 LazyCleanup *Obj = new(Buffer) T(a0, a1, a2, a3);
254 /// Push a cleanup on the stack.
255 void pushCleanup(llvm::BasicBlock *NormalEntry,
256 llvm::BasicBlock *NormalExit,
257 llvm::BasicBlock *EHEntry,
258 llvm::BasicBlock *EHExit);
260 /// Pops a cleanup scope off the stack. This should only be called
261 /// by CodeGenFunction::PopCleanupBlock.
264 /// Push a set of catch handlers on the stack. The catch is
265 /// uninitialized and will need to have the given number of handlers
267 class EHCatchScope *pushCatch(unsigned NumHandlers);
269 /// Pops a catch scope off the stack.
272 /// Push an exceptions filter on the stack.
273 class EHFilterScope *pushFilter(unsigned NumFilters);
275 /// Pops an exceptions filter off the stack.
278 /// Push a terminate handler on the stack.
279 void pushTerminate();
281 /// Pops a terminate handler off the stack.
284 /// Determines whether the exception-scopes stack is empty.
285 bool empty() const { return StartOfData == EndOfBuffer; }
287 bool requiresLandingPad() const {
288 return (CatchDepth || hasEHCleanups());
291 /// Determines whether there are any normal cleanups on the stack.
292 bool hasNormalCleanups() const {
293 return InnermostNormalCleanup != stable_end();
296 /// Returns the innermost normal cleanup on the stack, or
297 /// stable_end() if there are no normal cleanups.
298 stable_iterator getInnermostNormalCleanup() const {
299 return InnermostNormalCleanup;
302 /// Determines whether there are any EH cleanups on the stack.
303 bool hasEHCleanups() const {
304 return InnermostEHCleanup != stable_end();
307 /// Returns the innermost EH cleanup on the stack, or stable_end()
308 /// if there are no EH cleanups.
309 stable_iterator getInnermostEHCleanup() const {
310 return InnermostEHCleanup;
313 /// An unstable reference to a scope-stack depth. Invalidated by
314 /// pushes but not pops.
317 /// Returns an iterator pointing to the innermost EH scope.
318 iterator begin() const;
320 /// Returns an iterator pointing to the outermost EH scope.
321 iterator end() const;
323 /// Create a stable reference to the top of the EH stack. The
324 /// returned reference is valid until that scope is popped off the
326 stable_iterator stable_begin() const {
327 return stable_iterator(EndOfBuffer - StartOfData);
330 /// Create a stable reference to the bottom of the EH stack.
331 static stable_iterator stable_end() {
332 return stable_iterator(0);
335 /// Translates an iterator into a stable_iterator.
336 stable_iterator stabilize(iterator it) const;
338 /// Finds the nearest cleanup enclosing the given iterator.
339 /// Returns stable_iterator::invalid() if there are no such cleanups.
340 stable_iterator getEnclosingEHCleanup(iterator it) const;
342 /// Turn a stable reference to a scope depth into a unstable pointer
344 iterator find(stable_iterator save) const;
346 /// Removes the cleanup pointed to by the given stable_iterator.
347 void removeCleanup(stable_iterator save);
349 /// Add a branch fixup to the current cleanup scope.
350 BranchFixup &addBranchFixup() {
351 assert(hasNormalCleanups() && "adding fixup in scope without cleanups");
352 BranchFixups.push_back(BranchFixup());
353 return BranchFixups.back();
356 unsigned getNumBranchFixups() const { return BranchFixups.size(); }
357 BranchFixup &getBranchFixup(unsigned I) {
358 assert(I < getNumBranchFixups());
359 return BranchFixups[I];
362 /// Mark any branch fixups leading to the given block as resolved.
363 void resolveBranchFixups(llvm::BasicBlock *Dest);
366 /// CodeGenFunction - This class organizes the per-function state that is used
367 /// while generating LLVM code.
368 class CodeGenFunction : public BlockFunction {
369 CodeGenFunction(const CodeGenFunction&); // DO NOT IMPLEMENT
370 void operator=(const CodeGenFunction&); // DO NOT IMPLEMENT
372 /// A jump destination is a pair of a basic block and a cleanup
373 /// depth. They are used to implement direct jumps across cleanup
374 /// scopes, e.g. goto, break, continue, and return.
376 JumpDest() : Block(0), ScopeDepth() {}
377 JumpDest(llvm::BasicBlock *Block, EHScopeStack::stable_iterator Depth)
378 : Block(Block), ScopeDepth(Depth) {}
380 llvm::BasicBlock *Block;
381 EHScopeStack::stable_iterator ScopeDepth;
384 CodeGenModule &CGM; // Per-module state.
385 const TargetInfo &Target;
387 typedef std::pair<llvm::Value *, llvm::Value *> ComplexPairTy;
390 /// CurFuncDecl - Holds the Decl for the current function or ObjC method.
391 /// This excludes BlockDecls.
392 const Decl *CurFuncDecl;
393 /// CurCodeDecl - This is the inner-most code context, which includes blocks.
394 const Decl *CurCodeDecl;
395 const CGFunctionInfo *CurFnInfo;
397 llvm::Function *CurFn;
399 /// CurGD - The GlobalDecl for the current function being compiled.
402 /// ReturnBlock - Unified return block.
403 JumpDest ReturnBlock;
405 /// ReturnValue - The temporary alloca to hold the return value. This is null
406 /// iff the function has no return value.
407 llvm::Value *ReturnValue;
409 /// AllocaInsertPoint - This is an instruction in the entry block before which
410 /// we prefer to insert allocas.
411 llvm::AssertingVH<llvm::Instruction> AllocaInsertPt;
413 // intptr_t, i32, i64
414 const llvm::IntegerType *IntPtrTy, *Int32Ty, *Int64Ty;
415 uint32_t LLVMPointerWidth;
420 /// \brief A mapping from NRVO variables to the flags used to indicate
421 /// when the NRVO has been applied to this variable.
422 llvm::DenseMap<const VarDecl *, llvm::Value *> NRVOFlags;
424 EHScopeStack EHStack;
426 /// The exception slot. All landing pads write the current
427 /// exception pointer into this alloca.
428 llvm::Value *ExceptionSlot;
430 /// Emits a landing pad for the current EH stack.
431 llvm::BasicBlock *EmitLandingPad();
433 llvm::BasicBlock *getInvokeDestImpl();
436 /// ObjCEHValueStack - Stack of Objective-C exception values, used for
438 llvm::SmallVector<llvm::Value*, 8> ObjCEHValueStack;
440 // A struct holding information about a finally block's IR
441 // generation. For now, doesn't actually hold anything.
445 FinallyInfo EnterFinallyBlock(const Stmt *Stmt,
446 llvm::Constant *BeginCatchFn,
447 llvm::Constant *EndCatchFn,
448 llvm::Constant *RethrowFn);
449 void ExitFinallyBlock(FinallyInfo &FinallyInfo);
451 /// PushDestructorCleanup - Push a cleanup to call the
452 /// complete-object destructor of an object of the given type at the
453 /// given address. Does nothing if T is not a C++ class type with a
454 /// non-trivial destructor.
455 void PushDestructorCleanup(QualType T, llvm::Value *Addr);
457 /// PopCleanupBlock - Will pop the cleanup entry on the stack and
458 /// process all branch fixups.
459 void PopCleanupBlock();
461 /// CleanupBlock - RAII object that will create a cleanup block and
462 /// set the insert point to that block. When destructed, it sets the
463 /// insert point to the previous block and pushes a new cleanup
464 /// entry on the stack.
466 CodeGenFunction &CGF;
467 CGBuilderTy::InsertPoint SavedIP;
468 llvm::BasicBlock *NormalCleanupEntryBB;
469 llvm::BasicBlock *NormalCleanupExitBB;
470 llvm::BasicBlock *EHCleanupEntryBB;
473 CleanupBlock(CodeGenFunction &CGF, CleanupKind Kind);
475 /// If we're currently writing a normal cleanup, tie that off and
476 /// start writing an EH cleanup.
477 void beginEHCleanup();
482 /// \brief Enters a new scope for capturing cleanups, all of which
483 /// will be executed once the scope is exited.
484 class RunCleanupsScope {
485 CodeGenFunction& CGF;
486 EHScopeStack::stable_iterator CleanupStackDepth;
487 bool OldDidCallStackSave;
490 RunCleanupsScope(const RunCleanupsScope &); // DO NOT IMPLEMENT
491 RunCleanupsScope &operator=(const RunCleanupsScope &); // DO NOT IMPLEMENT
494 /// \brief Enter a new cleanup scope.
495 explicit RunCleanupsScope(CodeGenFunction &CGF)
496 : CGF(CGF), PerformCleanup(true)
498 CleanupStackDepth = CGF.EHStack.stable_begin();
499 OldDidCallStackSave = CGF.DidCallStackSave;
502 /// \brief Exit this cleanup scope, emitting any accumulated
504 ~RunCleanupsScope() {
505 if (PerformCleanup) {
506 CGF.DidCallStackSave = OldDidCallStackSave;
507 CGF.PopCleanupBlocks(CleanupStackDepth);
511 /// \brief Determine whether this scope requires any cleanups.
512 bool requiresCleanups() const {
513 return CGF.EHStack.stable_begin() != CleanupStackDepth;
516 /// \brief Force the emission of cleanups now, instead of waiting
517 /// until this object is destroyed.
518 void ForceCleanup() {
519 assert(PerformCleanup && "Already forced cleanup");
520 CGF.DidCallStackSave = OldDidCallStackSave;
521 CGF.PopCleanupBlocks(CleanupStackDepth);
522 PerformCleanup = false;
527 /// PopCleanupBlocks - Takes the old cleanup stack size and emits
528 /// the cleanup blocks that have been added.
529 void PopCleanupBlocks(EHScopeStack::stable_iterator OldCleanupStackSize);
531 /// The given basic block lies in the current EH scope, but may be a
532 /// target of a potentially scope-crossing jump; get a stable handle
533 /// to which we can perform this jump later.
534 JumpDest getJumpDestInCurrentScope(llvm::BasicBlock *Target) const {
535 return JumpDest(Target, EHStack.stable_begin());
538 /// The given basic block lies in the current EH scope, but may be a
539 /// target of a potentially scope-crossing jump; get a stable handle
540 /// to which we can perform this jump later.
541 JumpDest getJumpDestInCurrentScope(const char *Name = 0) {
542 return JumpDest(createBasicBlock(Name), EHStack.stable_begin());
545 /// EmitBranchThroughCleanup - Emit a branch from the current insert
546 /// block through the normal cleanup handling code (if any) and then
548 void EmitBranchThroughCleanup(JumpDest Dest);
550 /// EmitBranchThroughEHCleanup - Emit a branch from the current
551 /// insert block through the EH cleanup handling code (if any) and
552 /// then on to \arg Dest.
553 void EmitBranchThroughEHCleanup(JumpDest Dest);
555 /// BeginConditionalBranch - Should be called before a conditional part of an
556 /// expression is emitted. For example, before the RHS of the expression below
561 /// This is used to make sure that any temporaries created in the conditional
562 /// branch are only destroyed if the branch is taken.
563 void BeginConditionalBranch() {
564 ++ConditionalBranchLevel;
567 /// EndConditionalBranch - Should be called after a conditional part of an
568 /// expression has been emitted.
569 void EndConditionalBranch() {
570 assert(ConditionalBranchLevel != 0 &&
571 "Conditional branch mismatch!");
573 --ConditionalBranchLevel;
577 CGDebugInfo *DebugInfo;
579 /// IndirectBranch - The first time an indirect goto is seen we create a block
580 /// with an indirect branch. Every time we see the address of a label taken,
581 /// we add the label to the indirect goto. Every subsequent indirect goto is
582 /// codegen'd as a jump to the IndirectBranch's basic block.
583 llvm::IndirectBrInst *IndirectBranch;
585 /// LocalDeclMap - This keeps track of the LLVM allocas or globals for local C
587 llvm::DenseMap<const Decl*, llvm::Value*> LocalDeclMap;
589 /// LabelMap - This keeps track of the LLVM basic block for each C label.
590 llvm::DenseMap<const LabelStmt*, JumpDest> LabelMap;
592 // BreakContinueStack - This keeps track of where break and continue
593 // statements should jump to.
594 struct BreakContinue {
595 BreakContinue(JumpDest Break, JumpDest Continue)
596 : BreakBlock(Break), ContinueBlock(Continue) {}
599 JumpDest ContinueBlock;
601 llvm::SmallVector<BreakContinue, 8> BreakContinueStack;
603 /// SwitchInsn - This is nearest current switch instruction. It is null if if
604 /// current context is not in a switch.
605 llvm::SwitchInst *SwitchInsn;
607 /// CaseRangeBlock - This block holds if condition check for last case
608 /// statement range in current switch instruction.
609 llvm::BasicBlock *CaseRangeBlock;
611 /// InvokeDest - This is the nearest exception target for calls
612 /// which can unwind, when exceptions are being used.
613 llvm::BasicBlock *InvokeDest;
615 // VLASizeMap - This keeps track of the associated size for each VLA type.
616 // We track this by the size expression rather than the type itself because
617 // in certain situations, like a const qualifier applied to an VLA typedef,
618 // multiple VLA types can share the same size expression.
619 // FIXME: Maybe this could be a stack of maps that is pushed/popped as we
620 // enter/leave scopes.
621 llvm::DenseMap<const Expr*, llvm::Value*> VLASizeMap;
623 /// DidCallStackSave - Whether llvm.stacksave has been called. Used to avoid
624 /// calling llvm.stacksave for multiple VLAs in the same scope.
625 bool DidCallStackSave;
627 /// A block containing a single 'unreachable' instruction. Created
628 /// lazily by getUnreachableBlock().
629 llvm::BasicBlock *UnreachableBlock;
631 /// CXXThisDecl - When generating code for a C++ member function,
632 /// this will hold the implicit 'this' declaration.
633 ImplicitParamDecl *CXXThisDecl;
634 llvm::Value *CXXThisValue;
636 /// CXXVTTDecl - When generating code for a base object constructor or
637 /// base object destructor with virtual bases, this will hold the implicit
639 ImplicitParamDecl *CXXVTTDecl;
640 llvm::Value *CXXVTTValue;
642 /// ConditionalBranchLevel - Contains the nesting level of the current
643 /// conditional branch. This is used so that we know if a temporary should be
644 /// destroyed conditionally.
645 unsigned ConditionalBranchLevel;
648 /// ByrefValueInfoMap - For each __block variable, contains a pair of the LLVM
649 /// type as well as the field number that contains the actual data.
650 llvm::DenseMap<const ValueDecl *, std::pair<const llvm::Type *,
651 unsigned> > ByRefValueInfo;
653 /// getByrefValueFieldNumber - Given a declaration, returns the LLVM field
654 /// number that holds the value.
655 unsigned getByRefValueLLVMField(const ValueDecl *VD) const;
657 llvm::BasicBlock *TerminateLandingPad;
658 llvm::BasicBlock *TerminateHandler;
659 llvm::BasicBlock *TrapBB;
662 CodeGenFunction(CodeGenModule &cgm);
664 ASTContext &getContext() const;
665 CGDebugInfo *getDebugInfo() { return DebugInfo; }
667 /// Returns a pointer to the function's exception object slot, which
668 /// is assigned in every landing pad.
669 llvm::Value *getExceptionSlot();
671 llvm::BasicBlock *getUnreachableBlock() {
672 if (!UnreachableBlock) {
673 UnreachableBlock = createBasicBlock("unreachable");
674 new llvm::UnreachableInst(getLLVMContext(), UnreachableBlock);
676 return UnreachableBlock;
679 llvm::BasicBlock *getInvokeDest() {
680 if (!EHStack.requiresLandingPad()) return 0;
681 return getInvokeDestImpl();
684 llvm::LLVMContext &getLLVMContext() { return VMContext; }
686 //===--------------------------------------------------------------------===//
688 //===--------------------------------------------------------------------===//
690 void GenerateObjCMethod(const ObjCMethodDecl *OMD);
692 void StartObjCMethod(const ObjCMethodDecl *MD,
693 const ObjCContainerDecl *CD);
695 /// GenerateObjCGetter - Synthesize an Objective-C property getter function.
696 void GenerateObjCGetter(ObjCImplementationDecl *IMP,
697 const ObjCPropertyImplDecl *PID);
698 void GenerateObjCCtorDtorMethod(ObjCImplementationDecl *IMP,
699 ObjCMethodDecl *MD, bool ctor);
701 /// GenerateObjCSetter - Synthesize an Objective-C property setter function
702 /// for the given property.
703 void GenerateObjCSetter(ObjCImplementationDecl *IMP,
704 const ObjCPropertyImplDecl *PID);
705 bool IndirectObjCSetterArg(const CGFunctionInfo &FI);
706 bool IvarTypeWithAggrGCObjects(QualType Ty);
708 //===--------------------------------------------------------------------===//
710 //===--------------------------------------------------------------------===//
712 llvm::Value *BuildBlockLiteralTmp(const BlockExpr *);
713 llvm::Constant *BuildDescriptorBlockDecl(const BlockExpr *,
714 bool BlockHasCopyDispose,
716 const llvm::StructType *,
717 std::vector<HelperInfo> *);
719 llvm::Function *GenerateBlockFunction(GlobalDecl GD,
720 const BlockExpr *BExpr,
722 const Decl *OuterFuncDecl,
723 llvm::DenseMap<const Decl*, llvm::Value*> ldm);
725 llvm::Value *LoadBlockStruct();
727 void AllocateBlockCXXThisPointer(const CXXThisExpr *E);
728 void AllocateBlockDecl(const BlockDeclRefExpr *E);
729 llvm::Value *GetAddrOfBlockDecl(const BlockDeclRefExpr *E) {
730 return GetAddrOfBlockDecl(E->getDecl(), E->isByRef());
732 llvm::Value *GetAddrOfBlockDecl(const ValueDecl *D, bool ByRef);
733 const llvm::Type *BuildByRefType(const ValueDecl *D);
735 void GenerateCode(GlobalDecl GD, llvm::Function *Fn);
736 void StartFunction(GlobalDecl GD, QualType RetTy,
738 const FunctionArgList &Args,
739 SourceLocation StartLoc);
741 void EmitConstructorBody(FunctionArgList &Args);
742 void EmitDestructorBody(FunctionArgList &Args);
743 void EmitFunctionBody(FunctionArgList &Args);
745 /// EmitReturnBlock - Emit the unified return block, trying to avoid its
746 /// emission when possible.
747 void EmitReturnBlock();
749 /// FinishFunction - Complete IR generation of the current function. It is
750 /// legal to call this function even if there is no current insertion point.
751 void FinishFunction(SourceLocation EndLoc=SourceLocation());
753 /// GenerateThunk - Generate a thunk for the given method.
754 void GenerateThunk(llvm::Function *Fn, GlobalDecl GD, const ThunkInfo &Thunk);
756 void EmitCtorPrologue(const CXXConstructorDecl *CD, CXXCtorType Type,
757 FunctionArgList &Args);
759 /// InitializeVTablePointer - Initialize the vtable pointer of the given
762 void InitializeVTablePointer(BaseSubobject Base,
763 const CXXRecordDecl *NearestVBase,
764 uint64_t OffsetFromNearestVBase,
765 llvm::Constant *VTable,
766 const CXXRecordDecl *VTableClass);
768 typedef llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBasesSetTy;
769 void InitializeVTablePointers(BaseSubobject Base,
770 const CXXRecordDecl *NearestVBase,
771 uint64_t OffsetFromNearestVBase,
772 bool BaseIsNonVirtualPrimaryBase,
773 llvm::Constant *VTable,
774 const CXXRecordDecl *VTableClass,
775 VisitedVirtualBasesSetTy& VBases);
777 void InitializeVTablePointers(const CXXRecordDecl *ClassDecl);
780 /// EmitDtorEpilogue - Emit all code that comes at the end of class's
781 /// destructor. This is to call destructors on members and base classes in
782 /// reverse order of their construction.
783 void EmitDtorEpilogue(const CXXDestructorDecl *Dtor,
786 /// ShouldInstrumentFunction - Return true if the current function should be
787 /// instrumented with __cyg_profile_func_* calls
788 bool ShouldInstrumentFunction();
790 /// EmitFunctionInstrumentation - Emit LLVM code to call the specified
791 /// instrumentation function with the current function and the call site, if
792 /// function instrumentation is enabled.
793 void EmitFunctionInstrumentation(const char *Fn);
795 /// EmitFunctionProlog - Emit the target specific LLVM code to load the
796 /// arguments for the given function. This is also responsible for naming the
797 /// LLVM function arguments.
798 void EmitFunctionProlog(const CGFunctionInfo &FI,
800 const FunctionArgList &Args);
802 /// EmitFunctionEpilog - Emit the target specific LLVM code to return the
804 void EmitFunctionEpilog(const CGFunctionInfo &FI);
806 /// EmitStartEHSpec - Emit the start of the exception spec.
807 void EmitStartEHSpec(const Decl *D);
809 /// EmitEndEHSpec - Emit the end of the exception spec.
810 void EmitEndEHSpec(const Decl *D);
812 /// getTerminateLandingPad - Return a landing pad that just calls terminate.
813 llvm::BasicBlock *getTerminateLandingPad();
815 /// getTerminateHandler - Return a handler (not a landing pad, just
816 /// a catch handler) that just calls terminate. This is used when
817 /// a terminate scope encloses a try.
818 llvm::BasicBlock *getTerminateHandler();
820 const llvm::Type *ConvertTypeForMem(QualType T);
821 const llvm::Type *ConvertType(QualType T);
822 const llvm::Type *ConvertType(const TypeDecl *T) {
823 return ConvertType(getContext().getTypeDeclType(T));
826 /// LoadObjCSelf - Load the value of self. This function is only valid while
827 /// generating code for an Objective-C method.
828 llvm::Value *LoadObjCSelf();
830 /// TypeOfSelfObject - Return type of object that this self represents.
831 QualType TypeOfSelfObject();
833 /// hasAggregateLLVMType - Return true if the specified AST type will map into
834 /// an aggregate LLVM type or is void.
835 static bool hasAggregateLLVMType(QualType T);
837 /// createBasicBlock - Create an LLVM basic block.
838 llvm::BasicBlock *createBasicBlock(const char *Name="",
839 llvm::Function *Parent=0,
840 llvm::BasicBlock *InsertBefore=0) {
842 return llvm::BasicBlock::Create(VMContext, "", Parent, InsertBefore);
844 return llvm::BasicBlock::Create(VMContext, Name, Parent, InsertBefore);
848 /// getBasicBlockForLabel - Return the LLVM basicblock that the specified
850 JumpDest getJumpDestForLabel(const LabelStmt *S);
852 /// SimplifyForwardingBlocks - If the given basic block is only a branch to
853 /// another basic block, simplify it. This assumes that no other code could
854 /// potentially reference the basic block.
855 void SimplifyForwardingBlocks(llvm::BasicBlock *BB);
857 /// EmitBlock - Emit the given block \arg BB and set it as the insert point,
858 /// adding a fall-through branch from the current insert block if
859 /// necessary. It is legal to call this function even if there is no current
862 /// IsFinished - If true, indicates that the caller has finished emitting
863 /// branches to the given block and does not expect to emit code into it. This
864 /// means the block can be ignored if it is unreachable.
865 void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false);
867 /// EmitBranch - Emit a branch to the specified basic block from the current
868 /// insert block, taking care to avoid creation of branches from dummy
869 /// blocks. It is legal to call this function even if there is no current
872 /// This function clears the current insertion point. The caller should follow
873 /// calls to this function with calls to Emit*Block prior to generation new
875 void EmitBranch(llvm::BasicBlock *Block);
877 /// HaveInsertPoint - True if an insertion point is defined. If not, this
878 /// indicates that the current code being emitted is unreachable.
879 bool HaveInsertPoint() const {
880 return Builder.GetInsertBlock() != 0;
883 /// EnsureInsertPoint - Ensure that an insertion point is defined so that
884 /// emitted IR has a place to go. Note that by definition, if this function
885 /// creates a block then that block is unreachable; callers may do better to
886 /// detect when no insertion point is defined and simply skip IR generation.
887 void EnsureInsertPoint() {
888 if (!HaveInsertPoint())
889 EmitBlock(createBasicBlock());
892 /// ErrorUnsupported - Print out an error that codegen doesn't support the
893 /// specified stmt yet.
894 void ErrorUnsupported(const Stmt *S, const char *Type,
895 bool OmitOnError=false);
897 //===--------------------------------------------------------------------===//
899 //===--------------------------------------------------------------------===//
901 Qualifiers MakeQualifiers(QualType T) {
902 Qualifiers Quals = getContext().getCanonicalType(T).getQualifiers();
903 Quals.setObjCGCAttr(getContext().getObjCGCAttrKind(T));
907 /// CreateTempAlloca - This creates a alloca and inserts it into the entry
908 /// block. The caller is responsible for setting an appropriate alignment on
910 llvm::AllocaInst *CreateTempAlloca(const llvm::Type *Ty,
911 const llvm::Twine &Name = "tmp");
913 /// InitTempAlloca - Provide an initial value for the given alloca.
914 void InitTempAlloca(llvm::AllocaInst *Alloca, llvm::Value *Value);
916 /// CreateIRTemp - Create a temporary IR object of the given type, with
917 /// appropriate alignment. This routine should only be used when an temporary
918 /// value needs to be stored into an alloca (for example, to avoid explicit
919 /// PHI construction), but the type is the IR type, not the type appropriate
920 /// for storing in memory.
921 llvm::AllocaInst *CreateIRTemp(QualType T, const llvm::Twine &Name = "tmp");
923 /// CreateMemTemp - Create a temporary memory object of the given type, with
924 /// appropriate alignment.
925 llvm::AllocaInst *CreateMemTemp(QualType T, const llvm::Twine &Name = "tmp");
927 /// EvaluateExprAsBool - Perform the usual unary conversions on the specified
928 /// expression and compare the result against zero, returning an Int1Ty value.
929 llvm::Value *EvaluateExprAsBool(const Expr *E);
931 /// EmitAnyExpr - Emit code to compute the specified expression which can have
932 /// any type. The result is returned as an RValue struct. If this is an
933 /// aggregate expression, the aggloc/agglocvolatile arguments indicate where
934 /// the result should be returned.
936 /// \param IgnoreResult - True if the resulting value isn't used.
937 RValue EmitAnyExpr(const Expr *E, llvm::Value *AggLoc = 0,
938 bool IsAggLocVolatile = false, bool IgnoreResult = false,
939 bool IsInitializer = false);
941 // EmitVAListRef - Emit a "reference" to a va_list; this is either the address
942 // or the value of the expression, depending on how va_list is defined.
943 llvm::Value *EmitVAListRef(const Expr *E);
945 /// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result will
946 /// always be accessible even if no aggregate location is provided.
947 RValue EmitAnyExprToTemp(const Expr *E, bool IsAggLocVolatile = false,
948 bool IsInitializer = false);
950 /// EmitsAnyExprToMem - Emits the code necessary to evaluate an
951 /// arbitrary expression into the given memory location.
952 void EmitAnyExprToMem(const Expr *E, llvm::Value *Location,
953 bool IsLocationVolatile = false,
954 bool IsInitializer = false);
956 /// EmitAggregateCopy - Emit an aggrate copy.
958 /// \param isVolatile - True iff either the source or the destination is
960 void EmitAggregateCopy(llvm::Value *DestPtr, llvm::Value *SrcPtr,
961 QualType EltTy, bool isVolatile=false);
963 /// StartBlock - Start new block named N. If insert block is a dummy block
965 void StartBlock(const char *N);
967 /// GetAddrOfStaticLocalVar - Return the address of a static local variable.
968 llvm::Constant *GetAddrOfStaticLocalVar(const VarDecl *BVD);
970 /// GetAddrOfLocalVar - Return the address of a local variable.
971 llvm::Value *GetAddrOfLocalVar(const VarDecl *VD);
973 /// getAccessedFieldNo - Given an encoded value and a result number, return
974 /// the input field number being accessed.
975 static unsigned getAccessedFieldNo(unsigned Idx, const llvm::Constant *Elts);
977 llvm::BlockAddress *GetAddrOfLabel(const LabelStmt *L);
978 llvm::BasicBlock *GetIndirectGotoBlock();
980 /// EmitNullInitialization - Generate code to set a value of the given type to
981 /// null, If the type contains data member pointers, they will be initialized
982 /// to -1 in accordance with the Itanium C++ ABI.
983 void EmitNullInitialization(llvm::Value *DestPtr, QualType Ty);
985 // EmitVAArg - Generate code to get an argument from the passed in pointer
986 // and update it accordingly. The return value is a pointer to the argument.
987 // FIXME: We should be able to get rid of this method and use the va_arg
988 // instruction in LLVM instead once it works well enough.
989 llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty);
991 /// EmitVLASize - Generate code for any VLA size expressions that might occur
992 /// in a variably modified type. If Ty is a VLA, will return the value that
993 /// corresponds to the size in bytes of the VLA type. Will return 0 otherwise.
995 /// This function can be called with a null (unreachable) insert point.
996 llvm::Value *EmitVLASize(QualType Ty);
998 // GetVLASize - Returns an LLVM value that corresponds to the size in bytes
999 // of a variable length array type.
1000 llvm::Value *GetVLASize(const VariableArrayType *);
1002 /// LoadCXXThis - Load the value of 'this'. This function is only valid while
1003 /// generating code for an C++ member function.
1004 llvm::Value *LoadCXXThis() {
1005 assert(CXXThisValue && "no 'this' value for this function");
1006 return CXXThisValue;
1009 /// LoadCXXVTT - Load the VTT parameter to base constructors/destructors have
1011 llvm::Value *LoadCXXVTT() {
1012 assert(CXXVTTValue && "no VTT value for this function");
1016 /// GetAddressOfBaseOfCompleteClass - Convert the given pointer to a
1017 /// complete class to the given direct base.
1019 GetAddressOfDirectBaseInCompleteClass(llvm::Value *Value,
1020 const CXXRecordDecl *Derived,
1021 const CXXRecordDecl *Base,
1022 bool BaseIsVirtual);
1024 /// GetAddressOfBaseClass - This function will add the necessary delta to the
1025 /// load of 'this' and returns address of the base class.
1026 llvm::Value *GetAddressOfBaseClass(llvm::Value *Value,
1027 const CXXRecordDecl *Derived,
1028 const CXXBaseSpecifierArray &BasePath,
1029 bool NullCheckValue);
1031 llvm::Value *GetAddressOfDerivedClass(llvm::Value *Value,
1032 const CXXRecordDecl *Derived,
1033 const CXXBaseSpecifierArray &BasePath,
1034 bool NullCheckValue);
1036 llvm::Value *GetVirtualBaseClassOffset(llvm::Value *This,
1037 const CXXRecordDecl *ClassDecl,
1038 const CXXRecordDecl *BaseClassDecl);
1040 void EmitDelegateCXXConstructorCall(const CXXConstructorDecl *Ctor,
1041 CXXCtorType CtorType,
1042 const FunctionArgList &Args);
1043 void EmitCXXConstructorCall(const CXXConstructorDecl *D, CXXCtorType Type,
1044 bool ForVirtualBase, llvm::Value *This,
1045 CallExpr::const_arg_iterator ArgBeg,
1046 CallExpr::const_arg_iterator ArgEnd);
1048 void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D,
1049 const ConstantArrayType *ArrayTy,
1050 llvm::Value *ArrayPtr,
1051 CallExpr::const_arg_iterator ArgBeg,
1052 CallExpr::const_arg_iterator ArgEnd);
1054 void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D,
1055 llvm::Value *NumElements,
1056 llvm::Value *ArrayPtr,
1057 CallExpr::const_arg_iterator ArgBeg,
1058 CallExpr::const_arg_iterator ArgEnd);
1060 void EmitCXXAggrDestructorCall(const CXXDestructorDecl *D,
1061 const ArrayType *Array,
1064 void EmitCXXAggrDestructorCall(const CXXDestructorDecl *D,
1065 llvm::Value *NumElements,
1068 llvm::Function *GenerateCXXAggrDestructorHelper(const CXXDestructorDecl *D,
1069 const ArrayType *Array,
1072 void EmitCXXDestructorCall(const CXXDestructorDecl *D, CXXDtorType Type,
1073 bool ForVirtualBase, llvm::Value *This);
1075 void EmitNewArrayInitializer(const CXXNewExpr *E, llvm::Value *NewPtr,
1076 llvm::Value *NumElements);
1078 void EmitCXXTemporary(const CXXTemporary *Temporary, llvm::Value *Ptr);
1080 llvm::Value *EmitCXXNewExpr(const CXXNewExpr *E);
1081 void EmitCXXDeleteExpr(const CXXDeleteExpr *E);
1083 void EmitDeleteCall(const FunctionDecl *DeleteFD, llvm::Value *Ptr,
1086 llvm::Value* EmitCXXTypeidExpr(const CXXTypeidExpr *E);
1087 llvm::Value *EmitDynamicCast(llvm::Value *V, const CXXDynamicCastExpr *DCE);
1089 void EmitCheck(llvm::Value *, unsigned Size);
1091 llvm::Value *EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV,
1092 bool isInc, bool isPre);
1093 ComplexPairTy EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV,
1094 bool isInc, bool isPre);
1095 //===--------------------------------------------------------------------===//
1096 // Declaration Emission
1097 //===--------------------------------------------------------------------===//
1099 /// EmitDecl - Emit a declaration.
1101 /// This function can be called with a null (unreachable) insert point.
1102 void EmitDecl(const Decl &D);
1104 /// EmitBlockVarDecl - Emit a block variable declaration.
1106 /// This function can be called with a null (unreachable) insert point.
1107 void EmitBlockVarDecl(const VarDecl &D);
1109 typedef void SpecialInitFn(CodeGenFunction &Init, const VarDecl &D,
1110 llvm::Value *Address);
1112 /// EmitLocalBlockVarDecl - Emit a local block variable declaration.
1114 /// This function can be called with a null (unreachable) insert point.
1115 void EmitLocalBlockVarDecl(const VarDecl &D, SpecialInitFn *SpecialInit = 0);
1117 void EmitStaticBlockVarDecl(const VarDecl &D,
1118 llvm::GlobalValue::LinkageTypes Linkage);
1120 /// EmitParmDecl - Emit a ParmVarDecl or an ImplicitParamDecl.
1121 void EmitParmDecl(const VarDecl &D, llvm::Value *Arg);
1123 //===--------------------------------------------------------------------===//
1124 // Statement Emission
1125 //===--------------------------------------------------------------------===//
1127 /// EmitStopPoint - Emit a debug stoppoint if we are emitting debug info.
1128 void EmitStopPoint(const Stmt *S);
1130 /// EmitStmt - Emit the code for the statement \arg S. It is legal to call
1131 /// this function even if there is no current insertion point.
1133 /// This function may clear the current insertion point; callers should use
1134 /// EnsureInsertPoint if they wish to subsequently generate code without first
1135 /// calling EmitBlock, EmitBranch, or EmitStmt.
1136 void EmitStmt(const Stmt *S);
1138 /// EmitSimpleStmt - Try to emit a "simple" statement which does not
1139 /// necessarily require an insertion point or debug information; typically
1140 /// because the statement amounts to a jump or a container of other
1143 /// \return True if the statement was handled.
1144 bool EmitSimpleStmt(const Stmt *S);
1146 RValue EmitCompoundStmt(const CompoundStmt &S, bool GetLast = false,
1147 llvm::Value *AggLoc = 0, bool isAggVol = false);
1149 /// EmitLabel - Emit the block for the given label. It is legal to call this
1150 /// function even if there is no current insertion point.
1151 void EmitLabel(const LabelStmt &S); // helper for EmitLabelStmt.
1153 void EmitLabelStmt(const LabelStmt &S);
1154 void EmitGotoStmt(const GotoStmt &S);
1155 void EmitIndirectGotoStmt(const IndirectGotoStmt &S);
1156 void EmitIfStmt(const IfStmt &S);
1157 void EmitWhileStmt(const WhileStmt &S);
1158 void EmitDoStmt(const DoStmt &S);
1159 void EmitForStmt(const ForStmt &S);
1160 void EmitReturnStmt(const ReturnStmt &S);
1161 void EmitDeclStmt(const DeclStmt &S);
1162 void EmitBreakStmt(const BreakStmt &S);
1163 void EmitContinueStmt(const ContinueStmt &S);
1164 void EmitSwitchStmt(const SwitchStmt &S);
1165 void EmitDefaultStmt(const DefaultStmt &S);
1166 void EmitCaseStmt(const CaseStmt &S);
1167 void EmitCaseStmtRange(const CaseStmt &S);
1168 void EmitAsmStmt(const AsmStmt &S);
1170 void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S);
1171 void EmitObjCAtTryStmt(const ObjCAtTryStmt &S);
1172 void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S);
1173 void EmitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt &S);
1175 llvm::Constant *getUnwindResumeOrRethrowFn();
1176 void EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock = false);
1177 void ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock = false);
1179 void EmitCXXTryStmt(const CXXTryStmt &S);
1181 //===--------------------------------------------------------------------===//
1182 // LValue Expression Emission
1183 //===--------------------------------------------------------------------===//
1185 /// GetUndefRValue - Get an appropriate 'undef' rvalue for the given type.
1186 RValue GetUndefRValue(QualType Ty);
1188 /// EmitUnsupportedRValue - Emit a dummy r-value using the type of E
1189 /// and issue an ErrorUnsupported style diagnostic (using the
1191 RValue EmitUnsupportedRValue(const Expr *E,
1194 /// EmitUnsupportedLValue - Emit a dummy l-value using the type of E and issue
1195 /// an ErrorUnsupported style diagnostic (using the provided Name).
1196 LValue EmitUnsupportedLValue(const Expr *E,
1199 /// EmitLValue - Emit code to compute a designator that specifies the location
1200 /// of the expression.
1202 /// This can return one of two things: a simple address or a bitfield
1203 /// reference. In either case, the LLVM Value* in the LValue structure is
1204 /// guaranteed to be an LLVM pointer type.
1206 /// If this returns a bitfield reference, nothing about the pointee type of
1207 /// the LLVM value is known: For example, it may not be a pointer to an
1210 /// If this returns a normal address, and if the lvalue's C type is fixed
1211 /// size, this method guarantees that the returned pointer type will point to
1212 /// an LLVM type of the same size of the lvalue's type. If the lvalue has a
1213 /// variable length type, this is not possible.
1215 LValue EmitLValue(const Expr *E);
1217 /// EmitCheckedLValue - Same as EmitLValue but additionally we generate
1218 /// checking code to guard against undefined behavior. This is only
1219 /// suitable when we know that the address will be used to access the
1221 LValue EmitCheckedLValue(const Expr *E);
1223 /// EmitLoadOfScalar - Load a scalar value from an address, taking
1224 /// care to appropriately convert from the memory representation to
1225 /// the LLVM value representation.
1226 llvm::Value *EmitLoadOfScalar(llvm::Value *Addr, bool Volatile,
1229 /// EmitStoreOfScalar - Store a scalar value to an address, taking
1230 /// care to appropriately convert from the memory representation to
1231 /// the LLVM value representation.
1232 void EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr,
1233 bool Volatile, QualType Ty);
1235 /// EmitLoadOfLValue - Given an expression that represents a value lvalue,
1236 /// this method emits the address of the lvalue, then loads the result as an
1237 /// rvalue, returning the rvalue.
1238 RValue EmitLoadOfLValue(LValue V, QualType LVType);
1239 RValue EmitLoadOfExtVectorElementLValue(LValue V, QualType LVType);
1240 RValue EmitLoadOfBitfieldLValue(LValue LV, QualType ExprType);
1241 RValue EmitLoadOfPropertyRefLValue(LValue LV, QualType ExprType);
1242 RValue EmitLoadOfKVCRefLValue(LValue LV, QualType ExprType);
1245 /// EmitStoreThroughLValue - Store the specified rvalue into the specified
1246 /// lvalue, where both are guaranteed to the have the same type, and that type
1248 void EmitStoreThroughLValue(RValue Src, LValue Dst, QualType Ty);
1249 void EmitStoreThroughExtVectorComponentLValue(RValue Src, LValue Dst,
1251 void EmitStoreThroughPropertyRefLValue(RValue Src, LValue Dst, QualType Ty);
1252 void EmitStoreThroughKVCRefLValue(RValue Src, LValue Dst, QualType Ty);
1254 /// EmitStoreThroughLValue - Store Src into Dst with same constraints as
1255 /// EmitStoreThroughLValue.
1257 /// \param Result [out] - If non-null, this will be set to a Value* for the
1258 /// bit-field contents after the store, appropriate for use as the result of
1259 /// an assignment to the bit-field.
1260 void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, QualType Ty,
1261 llvm::Value **Result=0);
1263 // Note: only availabe for agg return types
1264 LValue EmitBinaryOperatorLValue(const BinaryOperator *E);
1265 LValue EmitCompoundAssignOperatorLValue(const CompoundAssignOperator *E);
1266 // Note: only available for agg return types
1267 LValue EmitCallExprLValue(const CallExpr *E);
1268 // Note: only available for agg return types
1269 LValue EmitVAArgExprLValue(const VAArgExpr *E);
1270 LValue EmitDeclRefLValue(const DeclRefExpr *E);
1271 LValue EmitStringLiteralLValue(const StringLiteral *E);
1272 LValue EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E);
1273 LValue EmitPredefinedFunctionName(unsigned Type);
1274 LValue EmitPredefinedLValue(const PredefinedExpr *E);
1275 LValue EmitUnaryOpLValue(const UnaryOperator *E);
1276 LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E);
1277 LValue EmitExtVectorElementExpr(const ExtVectorElementExpr *E);
1278 LValue EmitMemberExpr(const MemberExpr *E);
1279 LValue EmitObjCIsaExpr(const ObjCIsaExpr *E);
1280 LValue EmitCompoundLiteralLValue(const CompoundLiteralExpr *E);
1281 LValue EmitConditionalOperatorLValue(const ConditionalOperator *E);
1282 LValue EmitCastLValue(const CastExpr *E);
1283 LValue EmitNullInitializationLValue(const CXXScalarValueInitExpr *E);
1285 llvm::Value *EmitIvarOffset(const ObjCInterfaceDecl *Interface,
1286 const ObjCIvarDecl *Ivar);
1287 LValue EmitLValueForAnonRecordField(llvm::Value* Base,
1288 const FieldDecl* Field,
1289 unsigned CVRQualifiers);
1290 LValue EmitLValueForField(llvm::Value* Base, const FieldDecl* Field,
1291 unsigned CVRQualifiers);
1293 /// EmitLValueForFieldInitialization - Like EmitLValueForField, except that
1294 /// if the Field is a reference, this will return the address of the reference
1295 /// and not the address of the value stored in the reference.
1296 LValue EmitLValueForFieldInitialization(llvm::Value* Base,
1297 const FieldDecl* Field,
1298 unsigned CVRQualifiers);
1300 LValue EmitLValueForIvar(QualType ObjectTy,
1301 llvm::Value* Base, const ObjCIvarDecl *Ivar,
1302 unsigned CVRQualifiers);
1304 LValue EmitLValueForBitfield(llvm::Value* Base, const FieldDecl* Field,
1305 unsigned CVRQualifiers);
1307 LValue EmitBlockDeclRefLValue(const BlockDeclRefExpr *E);
1309 LValue EmitCXXConstructLValue(const CXXConstructExpr *E);
1310 LValue EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E);
1311 LValue EmitCXXExprWithTemporariesLValue(const CXXExprWithTemporaries *E);
1312 LValue EmitCXXTypeidLValue(const CXXTypeidExpr *E);
1314 LValue EmitObjCMessageExprLValue(const ObjCMessageExpr *E);
1315 LValue EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E);
1316 LValue EmitObjCPropertyRefLValue(const ObjCPropertyRefExpr *E);
1317 LValue EmitObjCKVCRefLValue(const ObjCImplicitSetterGetterRefExpr *E);
1318 LValue EmitObjCSuperExprLValue(const ObjCSuperExpr *E);
1319 LValue EmitStmtExprLValue(const StmtExpr *E);
1320 LValue EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E);
1321 LValue EmitObjCSelectorLValue(const ObjCSelectorExpr *E);
1323 //===--------------------------------------------------------------------===//
1324 // Scalar Expression Emission
1325 //===--------------------------------------------------------------------===//
1327 /// EmitCall - Generate a call of the given function, expecting the given
1328 /// result type, and using the given argument list which specifies both the
1329 /// LLVM arguments and the types they were derived from.
1331 /// \param TargetDecl - If given, the decl of the function in a direct call;
1332 /// used to set attributes on the call (noreturn, etc.).
1333 RValue EmitCall(const CGFunctionInfo &FnInfo,
1334 llvm::Value *Callee,
1335 ReturnValueSlot ReturnValue,
1336 const CallArgList &Args,
1337 const Decl *TargetDecl = 0,
1338 llvm::Instruction **callOrInvoke = 0);
1340 RValue EmitCall(QualType FnType, llvm::Value *Callee,
1341 ReturnValueSlot ReturnValue,
1342 CallExpr::const_arg_iterator ArgBeg,
1343 CallExpr::const_arg_iterator ArgEnd,
1344 const Decl *TargetDecl = 0);
1345 RValue EmitCallExpr(const CallExpr *E,
1346 ReturnValueSlot ReturnValue = ReturnValueSlot());
1348 llvm::CallSite EmitCallOrInvoke(llvm::Value *Callee,
1349 llvm::Value * const *ArgBegin,
1350 llvm::Value * const *ArgEnd,
1351 const llvm::Twine &Name = "");
1353 llvm::Value *BuildVirtualCall(const CXXMethodDecl *MD, llvm::Value *This,
1354 const llvm::Type *Ty);
1355 llvm::Value *BuildVirtualCall(const CXXDestructorDecl *DD, CXXDtorType Type,
1356 llvm::Value *&This, const llvm::Type *Ty);
1358 RValue EmitCXXMemberCall(const CXXMethodDecl *MD,
1359 llvm::Value *Callee,
1360 ReturnValueSlot ReturnValue,
1363 CallExpr::const_arg_iterator ArgBeg,
1364 CallExpr::const_arg_iterator ArgEnd);
1365 RValue EmitCXXMemberCallExpr(const CXXMemberCallExpr *E,
1366 ReturnValueSlot ReturnValue);
1367 RValue EmitCXXMemberPointerCallExpr(const CXXMemberCallExpr *E,
1368 ReturnValueSlot ReturnValue);
1370 RValue EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E,
1371 const CXXMethodDecl *MD,
1372 ReturnValueSlot ReturnValue);
1375 RValue EmitBuiltinExpr(const FunctionDecl *FD,
1376 unsigned BuiltinID, const CallExpr *E);
1378 RValue EmitBlockCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue);
1380 /// EmitTargetBuiltinExpr - Emit the given builtin call. Returns 0 if the call
1381 /// is unhandled by the current target.
1382 llvm::Value *EmitTargetBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
1384 llvm::Value *EmitARMBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
1385 llvm::Value *EmitNeonCall(llvm::Function *F,
1386 llvm::SmallVectorImpl<llvm::Value*> &O,
1387 const char *name, bool splat = false,
1388 unsigned shift = 0, bool rightshift = false);
1389 llvm::Value *EmitNeonSplat(llvm::Value *V, llvm::Constant *Idx);
1390 llvm::Value *EmitNeonShiftVector(llvm::Value *V, const llvm::Type *Ty,
1391 bool negateForRightShift);
1393 llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E);
1394 llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
1396 llvm::Value *EmitObjCProtocolExpr(const ObjCProtocolExpr *E);
1397 llvm::Value *EmitObjCStringLiteral(const ObjCStringLiteral *E);
1398 llvm::Value *EmitObjCSelectorExpr(const ObjCSelectorExpr *E);
1399 RValue EmitObjCMessageExpr(const ObjCMessageExpr *E,
1400 ReturnValueSlot Return = ReturnValueSlot());
1401 RValue EmitObjCPropertyGet(const Expr *E,
1402 ReturnValueSlot Return = ReturnValueSlot());
1403 RValue EmitObjCSuperPropertyGet(const Expr *Exp, const Selector &S,
1404 ReturnValueSlot Return = ReturnValueSlot());
1405 void EmitObjCPropertySet(const Expr *E, RValue Src);
1406 void EmitObjCSuperPropertySet(const Expr *E, const Selector &S, RValue Src);
1409 /// EmitReferenceBindingToExpr - Emits a reference binding to the passed in
1410 /// expression. Will emit a temporary variable if E is not an LValue.
1411 RValue EmitReferenceBindingToExpr(const Expr* E,
1412 const NamedDecl *InitializedDecl);
1414 //===--------------------------------------------------------------------===//
1415 // Expression Emission
1416 //===--------------------------------------------------------------------===//
1418 // Expressions are broken into three classes: scalar, complex, aggregate.
1420 /// EmitScalarExpr - Emit the computation of the specified expression of LLVM
1421 /// scalar type, returning the result.
1422 llvm::Value *EmitScalarExpr(const Expr *E , bool IgnoreResultAssign = false);
1424 /// EmitScalarConversion - Emit a conversion from the specified type to the
1425 /// specified destination type, both of which are LLVM scalar types.
1426 llvm::Value *EmitScalarConversion(llvm::Value *Src, QualType SrcTy,
1429 /// EmitComplexToScalarConversion - Emit a conversion from the specified
1430 /// complex type to the specified destination type, where the destination type
1431 /// is an LLVM scalar type.
1432 llvm::Value *EmitComplexToScalarConversion(ComplexPairTy Src, QualType SrcTy,
1436 /// EmitAggExpr - Emit the computation of the specified expression of
1437 /// aggregate type. The result is computed into DestPtr. Note that if
1438 /// DestPtr is null, the value of the aggregate expression is not needed.
1439 void EmitAggExpr(const Expr *E, llvm::Value *DestPtr, bool VolatileDest,
1440 bool IgnoreResult = false, bool IsInitializer = false,
1441 bool RequiresGCollection = false);
1443 /// EmitAggExprToLValue - Emit the computation of the specified expression of
1444 /// aggregate type into a temporary LValue.
1445 LValue EmitAggExprToLValue(const Expr *E);
1447 /// EmitGCMemmoveCollectable - Emit special API for structs with object
1449 void EmitGCMemmoveCollectable(llvm::Value *DestPtr, llvm::Value *SrcPtr,
1452 /// EmitComplexExpr - Emit the computation of the specified expression of
1453 /// complex type, returning the result.
1454 ComplexPairTy EmitComplexExpr(const Expr *E, bool IgnoreReal = false,
1455 bool IgnoreImag = false,
1456 bool IgnoreRealAssign = false,
1457 bool IgnoreImagAssign = false);
1459 /// EmitComplexExprIntoAddr - Emit the computation of the specified expression
1460 /// of complex type, storing into the specified Value*.
1461 void EmitComplexExprIntoAddr(const Expr *E, llvm::Value *DestAddr,
1462 bool DestIsVolatile);
1464 /// StoreComplexToAddr - Store a complex number into the specified address.
1465 void StoreComplexToAddr(ComplexPairTy V, llvm::Value *DestAddr,
1466 bool DestIsVolatile);
1467 /// LoadComplexFromAddr - Load a complex number from the specified address.
1468 ComplexPairTy LoadComplexFromAddr(llvm::Value *SrcAddr, bool SrcIsVolatile);
1470 /// CreateStaticBlockVarDecl - Create a zero-initialized LLVM global for a
1471 /// static block var decl.
1472 llvm::GlobalVariable *CreateStaticBlockVarDecl(const VarDecl &D,
1473 const char *Separator,
1474 llvm::GlobalValue::LinkageTypes Linkage);
1476 /// AddInitializerToGlobalBlockVarDecl - Add the initializer for 'D' to the
1477 /// global variable that has already been created for it. If the initializer
1478 /// has a different type than GV does, this may free GV and return a different
1479 /// one. Otherwise it just returns GV.
1480 llvm::GlobalVariable *
1481 AddInitializerToGlobalBlockVarDecl(const VarDecl &D,
1482 llvm::GlobalVariable *GV);
1485 /// EmitStaticCXXBlockVarDeclInit - Create the initializer for a C++ runtime
1486 /// initialized static block var decl.
1487 void EmitStaticCXXBlockVarDeclInit(const VarDecl &D,
1488 llvm::GlobalVariable *GV);
1490 /// EmitCXXGlobalVarDeclInit - Create the initializer for a C++
1491 /// variable with global storage.
1492 void EmitCXXGlobalVarDeclInit(const VarDecl &D, llvm::Constant *DeclPtr);
1494 /// EmitCXXGlobalDtorRegistration - Emits a call to register the global ptr
1495 /// with the C++ runtime so that its destructor will be called at exit.
1496 void EmitCXXGlobalDtorRegistration(llvm::Constant *DtorFn,
1497 llvm::Constant *DeclPtr);
1499 /// GenerateCXXGlobalInitFunc - Generates code for initializing global
1501 void GenerateCXXGlobalInitFunc(llvm::Function *Fn,
1502 llvm::Constant **Decls,
1505 /// GenerateCXXGlobalDtorFunc - Generates code for destroying global
1507 void GenerateCXXGlobalDtorFunc(llvm::Function *Fn,
1508 const std::vector<std::pair<llvm::WeakVH,
1509 llvm::Constant*> > &DtorsAndObjects);
1511 void GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn, const VarDecl *D);
1513 void EmitCXXConstructExpr(llvm::Value *Dest, const CXXConstructExpr *E);
1515 RValue EmitCXXExprWithTemporaries(const CXXExprWithTemporaries *E,
1516 llvm::Value *AggLoc = 0,
1517 bool IsAggLocVolatile = false,
1518 bool IsInitializer = false);
1520 void EmitCXXThrowExpr(const CXXThrowExpr *E);
1522 //===--------------------------------------------------------------------===//
1524 //===--------------------------------------------------------------------===//
1526 /// ContainsLabel - Return true if the statement contains a label in it. If
1527 /// this statement is not executed normally, it not containing a label means
1528 /// that we can just remove the code.
1529 static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts = false);
1531 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
1532 /// to a constant, or if it does but contains a label, return 0. If it
1533 /// constant folds to 'true' and does not contain a label, return 1, if it
1534 /// constant folds to 'false' and does not contain a label, return -1.
1535 int ConstantFoldsToSimpleInteger(const Expr *Cond);
1537 /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an
1538 /// if statement) to the specified blocks. Based on the condition, this might
1539 /// try to simplify the codegen of the conditional based on the branch.
1540 void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock,
1541 llvm::BasicBlock *FalseBlock);
1543 /// getTrapBB - Create a basic block that will call the trap intrinsic. We'll
1544 /// generate a branch around the created basic block as necessary.
1545 llvm::BasicBlock* getTrapBB();
1547 /// EmitCallArg - Emit a single call argument.
1548 RValue EmitCallArg(const Expr *E, QualType ArgType);
1550 /// EmitDelegateCallArg - We are performing a delegate call; that
1551 /// is, the current function is delegating to another one. Produce
1552 /// a r-value suitable for passing the given parameter.
1553 RValue EmitDelegateCallArg(const VarDecl *Param);
1556 void EmitReturnOfRValue(RValue RV, QualType Ty);
1558 /// ExpandTypeFromArgs - Reconstruct a structure of type \arg Ty
1559 /// from function arguments into \arg Dst. See ABIArgInfo::Expand.
1561 /// \param AI - The first function argument of the expansion.
1562 /// \return The argument following the last expanded function
1564 llvm::Function::arg_iterator
1565 ExpandTypeFromArgs(QualType Ty, LValue Dst,
1566 llvm::Function::arg_iterator AI);
1568 /// ExpandTypeToArgs - Expand an RValue \arg Src, with the LLVM type for \arg
1569 /// Ty, into individual arguments on the provided vector \arg Args. See
1570 /// ABIArgInfo::Expand.
1571 void ExpandTypeToArgs(QualType Ty, RValue Src,
1572 llvm::SmallVector<llvm::Value*, 16> &Args);
1574 llvm::Value* EmitAsmInput(const AsmStmt &S,
1575 const TargetInfo::ConstraintInfo &Info,
1576 const Expr *InputExpr, std::string &ConstraintStr);
1578 /// EmitCallArgs - Emit call arguments for a function.
1579 /// The CallArgTypeInfo parameter is used for iterating over the known
1580 /// argument types of the function being called.
1581 template<typename T>
1582 void EmitCallArgs(CallArgList& Args, const T* CallArgTypeInfo,
1583 CallExpr::const_arg_iterator ArgBeg,
1584 CallExpr::const_arg_iterator ArgEnd) {
1585 CallExpr::const_arg_iterator Arg = ArgBeg;
1587 // First, use the argument types that the type info knows about
1588 if (CallArgTypeInfo) {
1589 for (typename T::arg_type_iterator I = CallArgTypeInfo->arg_type_begin(),
1590 E = CallArgTypeInfo->arg_type_end(); I != E; ++I, ++Arg) {
1591 assert(Arg != ArgEnd && "Running over edge of argument list!");
1592 QualType ArgType = *I;
1594 assert(getContext().getCanonicalType(ArgType.getNonReferenceType()).
1596 getContext().getCanonicalType(Arg->getType()).getTypePtr() &&
1597 "type mismatch in call argument!");
1599 Args.push_back(std::make_pair(EmitCallArg(*Arg, ArgType),
1603 // Either we've emitted all the call args, or we have a call to a
1604 // variadic function.
1605 assert((Arg == ArgEnd || CallArgTypeInfo->isVariadic()) &&
1606 "Extra arguments in non-variadic function!");
1610 // If we still have any arguments, emit them using the type of the argument.
1611 for (; Arg != ArgEnd; ++Arg) {
1612 QualType ArgType = Arg->getType();
1613 Args.push_back(std::make_pair(EmitCallArg(*Arg, ArgType),
1618 const TargetCodeGenInfo &getTargetHooks() const {
1619 return CGM.getTargetCodeGenInfo();
1622 void EmitDeclMetadata();
1626 } // end namespace CodeGen
1627 } // end namespace clang