blob: fc741f8ef02516347ee31799606a908da8baf521 [file] [log] [blame]
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001//===-- CodeGenFunction.h - Per-Function state for LLVM CodeGen -*- C++ -*-===//
Reid Spencer5f016e22007-07-11 17:01:13 +00002//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
Mike Stump0dd9e882009-02-08 23:14:22 +000010// This is the internal per-function state used for llvm translation.
Reid Spencer5f016e22007-07-11 17:01:13 +000011//
12//===----------------------------------------------------------------------===//
13
Chris Lattneref52a2f2008-02-29 17:10:38 +000014#ifndef CLANG_CODEGEN_CODEGENFUNCTION_H
15#define CLANG_CODEGEN_CODEGENFUNCTION_H
Reid Spencer5f016e22007-07-11 17:01:13 +000016
Chris Lattner391d77a2008-03-30 23:03:07 +000017#include "clang/AST/Type.h"
Argyrios Kyrtzidise3a09e62008-09-10 02:36:38 +000018#include "clang/AST/ExprCXX.h"
Ted Kremenek55499762008-06-17 02:43:46 +000019#include "clang/AST/ExprObjC.h"
Ken Dyck199c3d62010-01-11 17:06:35 +000020#include "clang/AST/CharUnits.h"
Chris Lattner481769b2009-03-31 22:17:44 +000021#include "clang/Basic/TargetInfo.h"
22#include "llvm/ADT/DenseMap.h"
23#include "llvm/ADT/SmallVector.h"
24#include "llvm/Support/ValueHandle.h"
Owen Anderson69243822009-07-13 04:10:07 +000025#include "CodeGenModule.h"
Mike Stump96bd13a2009-03-04 15:32:52 +000026#include "CGBlocks.h"
Daniel Dunbar45d196b2008-11-01 01:53:16 +000027#include "CGBuilder.h"
Daniel Dunbar0dbe2272008-09-08 21:33:45 +000028#include "CGCall.h"
Anders Carlssonb14095a2009-04-17 00:06:03 +000029#include "CGCXX.h"
Daniel Dunbar8f2926b2008-08-23 03:46:30 +000030#include "CGValue.h"
31
Reid Spencer5f016e22007-07-11 17:01:13 +000032namespace llvm {
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000033 class BasicBlock;
Benjamin Kramerf21efe92009-08-11 17:46:57 +000034 class LLVMContext;
David Chisnalldd5c98f2010-05-01 11:15:56 +000035 class MDNode;
Reid Spencer5f016e22007-07-11 17:01:13 +000036 class Module;
Daniel Dunbar898d5082008-09-30 01:06:03 +000037 class SwitchInst;
Daniel Dunbar259e9cc2009-10-19 01:21:05 +000038 class Twine;
Daniel Dunbared3849b2008-11-19 09:36:46 +000039 class Value;
John McCallf1549f62010-07-06 01:34:17 +000040 class CallSite;
Reid Spencer5f016e22007-07-11 17:01:13 +000041}
42
43namespace clang {
Devang Patel8d308382010-08-10 07:24:25 +000044 class APValue;
Reid Spencer5f016e22007-07-11 17:01:13 +000045 class ASTContext;
Anders Carlsson7267c162009-05-29 21:03:38 +000046 class CXXDestructorDecl;
Anders Carlsson6815e942009-09-27 18:58:34 +000047 class CXXTryStmt;
Reid Spencer5f016e22007-07-11 17:01:13 +000048 class Decl;
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000049 class EnumConstantDecl;
Reid Spencer5f016e22007-07-11 17:01:13 +000050 class FunctionDecl;
Douglas Gregor72564e72009-02-26 23:50:07 +000051 class FunctionProtoType;
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000052 class LabelStmt;
Fariborz Jahanian679a5022009-01-10 21:06:09 +000053 class ObjCContainerDecl;
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +000054 class ObjCInterfaceDecl;
55 class ObjCIvarDecl;
Chris Lattner391d77a2008-03-30 23:03:07 +000056 class ObjCMethodDecl;
Fariborz Jahanianfef30b52008-12-09 20:23:04 +000057 class ObjCImplementationDecl;
Daniel Dunbaraf05bb92008-08-26 08:29:31 +000058 class ObjCPropertyImplDecl;
Reid Spencer5f016e22007-07-11 17:01:13 +000059 class TargetInfo;
John McCall492c4f92010-03-03 04:15:11 +000060 class TargetCodeGenInfo;
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000061 class VarDecl;
Chris Lattner16f00492009-04-26 01:32:48 +000062 class ObjCForCollectionStmt;
63 class ObjCAtTryStmt;
64 class ObjCAtThrowStmt;
65 class ObjCAtSynchronizedStmt;
Devang Patelb84a06e2007-10-23 02:10:49 +000066
Reid Spencer5f016e22007-07-11 17:01:13 +000067namespace CodeGen {
Devang Patelb84a06e2007-10-23 02:10:49 +000068 class CodeGenTypes;
Anders Carlssone896d982009-02-13 08:11:52 +000069 class CGDebugInfo;
Daniel Dunbarbb36d332009-02-02 21:43:58 +000070 class CGFunctionInfo;
Mike Stump0dd9e882009-02-08 23:14:22 +000071 class CGRecordLayout;
John McCallee504292010-05-21 04:11:14 +000072 class CGBlockInfo;
John McCall4c40d982010-08-31 07:33:07 +000073 class CGCXXABI;
Mike Stump0dd9e882009-02-08 23:14:22 +000074
John McCallf1549f62010-07-06 01:34:17 +000075/// A branch fixup. These are required when emitting a goto to a
76/// label which hasn't been emitted yet. The goto is optimistically
77/// emitted as a branch to the basic block for the label, and (if it
78/// occurs in a scope with non-trivial cleanups) a fixup is added to
79/// the innermost cleanup. When a (normal) cleanup is popped, any
80/// unresolved fixups in that scope are threaded through the cleanup.
81struct BranchFixup {
John McCallff8e1152010-07-23 21:56:41 +000082 /// The block containing the terminator which needs to be modified
83 /// into a switch if this fixup is resolved into the current scope.
84 /// If null, LatestBranch points directly to the destination.
85 llvm::BasicBlock *OptimisticBranchBlock;
John McCallf1549f62010-07-06 01:34:17 +000086
John McCallff8e1152010-07-23 21:56:41 +000087 /// The ultimate destination of the branch.
John McCallf1549f62010-07-06 01:34:17 +000088 ///
89 /// This can be set to null to indicate that this fixup was
90 /// successfully resolved.
91 llvm::BasicBlock *Destination;
92
John McCallff8e1152010-07-23 21:56:41 +000093 /// The destination index value.
94 unsigned DestinationIndex;
95
96 /// The initial branch of the fixup.
97 llvm::BranchInst *InitialBranch;
John McCallf1549f62010-07-06 01:34:17 +000098};
99
John McCallcd2d2b72010-08-13 21:20:51 +0000100enum CleanupKind {
101 EHCleanup = 0x1,
102 NormalCleanup = 0x2,
103 NormalAndEHCleanup = EHCleanup | NormalCleanup,
104
105 InactiveCleanup = 0x4,
106 InactiveEHCleanup = EHCleanup | InactiveCleanup,
107 InactiveNormalCleanup = NormalCleanup | InactiveCleanup,
108 InactiveNormalAndEHCleanup = NormalAndEHCleanup | InactiveCleanup
109};
John McCallda65ea82010-07-13 20:32:21 +0000110
John McCallf1549f62010-07-06 01:34:17 +0000111/// A stack of scopes which respond to exceptions, including cleanups
112/// and catch blocks.
113class EHScopeStack {
114public:
115 /// A saved depth on the scope stack. This is necessary because
116 /// pushing scopes onto the stack invalidates iterators.
117 class stable_iterator {
118 friend class EHScopeStack;
119
120 /// Offset from StartOfData to EndOfBuffer.
121 ptrdiff_t Size;
122
123 stable_iterator(ptrdiff_t Size) : Size(Size) {}
124
125 public:
126 static stable_iterator invalid() { return stable_iterator(-1); }
127 stable_iterator() : Size(-1) {}
128
129 bool isValid() const { return Size >= 0; }
130
John McCall838d7962010-08-14 07:46:19 +0000131 /// Returns true if this scope encloses I.
132 /// Returns false if I is invalid.
133 /// This scope must be valid.
John McCallff8e1152010-07-23 21:56:41 +0000134 bool encloses(stable_iterator I) const { return Size <= I.Size; }
John McCall838d7962010-08-14 07:46:19 +0000135
136 /// Returns true if this scope strictly encloses I: that is,
137 /// if it encloses I and is not I.
138 /// Returns false is I is invalid.
139 /// This scope must be valid.
John McCallff8e1152010-07-23 21:56:41 +0000140 bool strictlyEncloses(stable_iterator I) const { return Size < I.Size; }
John McCall1bda6622010-07-21 00:40:03 +0000141
John McCallf1549f62010-07-06 01:34:17 +0000142 friend bool operator==(stable_iterator A, stable_iterator B) {
143 return A.Size == B.Size;
144 }
145 friend bool operator!=(stable_iterator A, stable_iterator B) {
146 return A.Size != B.Size;
147 }
148 };
149
John McCall1f0fca52010-07-21 07:22:38 +0000150 /// Information for lazily generating a cleanup. Subclasses must be
151 /// POD-like: cleanups will not be destructed, and they will be
152 /// allocated on the cleanup stack and freely copied and moved
153 /// around.
John McCallda65ea82010-07-13 20:32:21 +0000154 ///
John McCall1f0fca52010-07-21 07:22:38 +0000155 /// Cleanup implementations should generally be declared in an
John McCallda65ea82010-07-13 20:32:21 +0000156 /// anonymous namespace.
John McCall1f0fca52010-07-21 07:22:38 +0000157 class Cleanup {
John McCallda65ea82010-07-13 20:32:21 +0000158 public:
John McCall3e29f962010-07-13 23:19:49 +0000159 // Anchor the construction vtable. We use the destructor because
160 // gcc gives an obnoxious warning if there are virtual methods
161 // with an accessible non-virtual destructor. Unfortunately,
162 // declaring this destructor makes it non-trivial, but there
163 // doesn't seem to be any other way around this warning.
164 //
165 // This destructor will never be called.
John McCall1f0fca52010-07-21 07:22:38 +0000166 virtual ~Cleanup();
John McCall3e29f962010-07-13 23:19:49 +0000167
John McCallda65ea82010-07-13 20:32:21 +0000168 /// Emit the cleanup. For normal cleanups, this is run in the
169 /// same EH context as when the cleanup was pushed, i.e. the
170 /// immediately-enclosing context of the cleanup scope. For
171 /// EH cleanups, this is run in a terminate context.
172 ///
173 // \param IsForEHCleanup true if this is for an EH cleanup, false
174 /// if for a normal cleanup.
175 virtual void Emit(CodeGenFunction &CGF, bool IsForEHCleanup) = 0;
176 };
177
John McCallf1549f62010-07-06 01:34:17 +0000178private:
179 // The implementation for this class is in CGException.h and
180 // CGException.cpp; the definition is here because it's used as a
181 // member of CodeGenFunction.
182
183 /// The start of the scope-stack buffer, i.e. the allocated pointer
184 /// for the buffer. All of these pointers are either simultaneously
185 /// null or simultaneously valid.
186 char *StartOfBuffer;
187
188 /// The end of the buffer.
189 char *EndOfBuffer;
190
191 /// The first valid entry in the buffer.
192 char *StartOfData;
193
194 /// The innermost normal cleanup on the stack.
195 stable_iterator InnermostNormalCleanup;
196
197 /// The innermost EH cleanup on the stack.
198 stable_iterator InnermostEHCleanup;
199
200 /// The number of catches on the stack.
201 unsigned CatchDepth;
202
John McCallff8e1152010-07-23 21:56:41 +0000203 /// The current EH destination index. Reset to FirstCatchIndex
204 /// whenever the last EH cleanup is popped.
205 unsigned NextEHDestIndex;
206 enum { FirstEHDestIndex = 1 };
207
John McCallf1549f62010-07-06 01:34:17 +0000208 /// The current set of branch fixups. A branch fixup is a jump to
209 /// an as-yet unemitted label, i.e. a label for which we don't yet
210 /// know the EH stack depth. Whenever we pop a cleanup, we have
211 /// to thread all the current branch fixups through it.
212 ///
213 /// Fixups are recorded as the Use of the respective branch or
214 /// switch statement. The use points to the final destination.
215 /// When popping out of a cleanup, these uses are threaded through
216 /// the cleanup and adjusted to point to the new cleanup.
217 ///
218 /// Note that branches are allowed to jump into protected scopes
219 /// in certain situations; e.g. the following code is legal:
220 /// struct A { ~A(); }; // trivial ctor, non-trivial dtor
221 /// goto foo;
222 /// A a;
223 /// foo:
224 /// bar();
225 llvm::SmallVector<BranchFixup, 8> BranchFixups;
226
227 char *allocate(size_t Size);
228
John McCall1f0fca52010-07-21 07:22:38 +0000229 void *pushCleanup(CleanupKind K, size_t DataSize);
John McCallda65ea82010-07-13 20:32:21 +0000230
John McCallf1549f62010-07-06 01:34:17 +0000231public:
232 EHScopeStack() : StartOfBuffer(0), EndOfBuffer(0), StartOfData(0),
233 InnermostNormalCleanup(stable_end()),
234 InnermostEHCleanup(stable_end()),
John McCallff8e1152010-07-23 21:56:41 +0000235 CatchDepth(0), NextEHDestIndex(FirstEHDestIndex) {}
John McCallf1549f62010-07-06 01:34:17 +0000236 ~EHScopeStack() { delete[] StartOfBuffer; }
237
John McCallda65ea82010-07-13 20:32:21 +0000238 // Variadic templates would make this not terrible.
239
240 /// Push a lazily-created cleanup on the stack.
John McCall8e3f8612010-07-13 22:12:14 +0000241 template <class T>
John McCall1f0fca52010-07-21 07:22:38 +0000242 void pushCleanup(CleanupKind Kind) {
243 void *Buffer = pushCleanup(Kind, sizeof(T));
244 Cleanup *Obj = new(Buffer) T();
John McCall8e3f8612010-07-13 22:12:14 +0000245 (void) Obj;
246 }
247
248 /// Push a lazily-created cleanup on the stack.
249 template <class T, class A0>
John McCall1f0fca52010-07-21 07:22:38 +0000250 void pushCleanup(CleanupKind Kind, A0 a0) {
251 void *Buffer = pushCleanup(Kind, sizeof(T));
252 Cleanup *Obj = new(Buffer) T(a0);
John McCall8e3f8612010-07-13 22:12:14 +0000253 (void) Obj;
254 }
255
256 /// Push a lazily-created cleanup on the stack.
John McCallda65ea82010-07-13 20:32:21 +0000257 template <class T, class A0, class A1>
John McCall1f0fca52010-07-21 07:22:38 +0000258 void pushCleanup(CleanupKind Kind, A0 a0, A1 a1) {
259 void *Buffer = pushCleanup(Kind, sizeof(T));
260 Cleanup *Obj = new(Buffer) T(a0, a1);
John McCallda65ea82010-07-13 20:32:21 +0000261 (void) Obj;
262 }
263
264 /// Push a lazily-created cleanup on the stack.
265 template <class T, class A0, class A1, class A2>
John McCall1f0fca52010-07-21 07:22:38 +0000266 void pushCleanup(CleanupKind Kind, A0 a0, A1 a1, A2 a2) {
267 void *Buffer = pushCleanup(Kind, sizeof(T));
268 Cleanup *Obj = new(Buffer) T(a0, a1, a2);
John McCallda65ea82010-07-13 20:32:21 +0000269 (void) Obj;
270 }
271
272 /// Push a lazily-created cleanup on the stack.
273 template <class T, class A0, class A1, class A2, class A3>
John McCall1f0fca52010-07-21 07:22:38 +0000274 void pushCleanup(CleanupKind Kind, A0 a0, A1 a1, A2 a2, A3 a3) {
275 void *Buffer = pushCleanup(Kind, sizeof(T));
276 Cleanup *Obj = new(Buffer) T(a0, a1, a2, a3);
John McCallda65ea82010-07-13 20:32:21 +0000277 (void) Obj;
278 }
279
John McCall77199712010-07-21 05:47:49 +0000280 /// Push a lazily-created cleanup on the stack.
281 template <class T, class A0, class A1, class A2, class A3, class A4>
John McCall1f0fca52010-07-21 07:22:38 +0000282 void pushCleanup(CleanupKind Kind, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
283 void *Buffer = pushCleanup(Kind, sizeof(T));
284 Cleanup *Obj = new(Buffer) T(a0, a1, a2, a3, a4);
John McCall77199712010-07-21 05:47:49 +0000285 (void) Obj;
286 }
287
John McCallf1549f62010-07-06 01:34:17 +0000288 /// Pops a cleanup scope off the stack. This should only be called
289 /// by CodeGenFunction::PopCleanupBlock.
290 void popCleanup();
291
292 /// Push a set of catch handlers on the stack. The catch is
293 /// uninitialized and will need to have the given number of handlers
294 /// set on it.
295 class EHCatchScope *pushCatch(unsigned NumHandlers);
296
297 /// Pops a catch scope off the stack.
298 void popCatch();
299
300 /// Push an exceptions filter on the stack.
301 class EHFilterScope *pushFilter(unsigned NumFilters);
302
303 /// Pops an exceptions filter off the stack.
304 void popFilter();
305
306 /// Push a terminate handler on the stack.
307 void pushTerminate();
308
309 /// Pops a terminate handler off the stack.
310 void popTerminate();
311
312 /// Determines whether the exception-scopes stack is empty.
313 bool empty() const { return StartOfData == EndOfBuffer; }
314
315 bool requiresLandingPad() const {
316 return (CatchDepth || hasEHCleanups());
317 }
318
319 /// Determines whether there are any normal cleanups on the stack.
320 bool hasNormalCleanups() const {
321 return InnermostNormalCleanup != stable_end();
322 }
323
324 /// Returns the innermost normal cleanup on the stack, or
325 /// stable_end() if there are no normal cleanups.
326 stable_iterator getInnermostNormalCleanup() const {
327 return InnermostNormalCleanup;
328 }
John McCall838d7962010-08-14 07:46:19 +0000329 stable_iterator getInnermostActiveNormalCleanup() const; // CGException.h
John McCallf1549f62010-07-06 01:34:17 +0000330
331 /// Determines whether there are any EH cleanups on the stack.
332 bool hasEHCleanups() const {
333 return InnermostEHCleanup != stable_end();
334 }
335
336 /// Returns the innermost EH cleanup on the stack, or stable_end()
337 /// if there are no EH cleanups.
338 stable_iterator getInnermostEHCleanup() const {
339 return InnermostEHCleanup;
340 }
John McCall838d7962010-08-14 07:46:19 +0000341 stable_iterator getInnermostActiveEHCleanup() const; // CGException.h
John McCallf1549f62010-07-06 01:34:17 +0000342
343 /// An unstable reference to a scope-stack depth. Invalidated by
344 /// pushes but not pops.
345 class iterator;
346
347 /// Returns an iterator pointing to the innermost EH scope.
348 iterator begin() const;
349
350 /// Returns an iterator pointing to the outermost EH scope.
351 iterator end() const;
352
353 /// Create a stable reference to the top of the EH stack. The
354 /// returned reference is valid until that scope is popped off the
355 /// stack.
356 stable_iterator stable_begin() const {
357 return stable_iterator(EndOfBuffer - StartOfData);
358 }
359
360 /// Create a stable reference to the bottom of the EH stack.
361 static stable_iterator stable_end() {
362 return stable_iterator(0);
363 }
364
365 /// Translates an iterator into a stable_iterator.
366 stable_iterator stabilize(iterator it) const;
367
368 /// Finds the nearest cleanup enclosing the given iterator.
369 /// Returns stable_iterator::invalid() if there are no such cleanups.
370 stable_iterator getEnclosingEHCleanup(iterator it) const;
371
372 /// Turn a stable reference to a scope depth into a unstable pointer
373 /// to the EH stack.
374 iterator find(stable_iterator save) const;
375
376 /// Removes the cleanup pointed to by the given stable_iterator.
377 void removeCleanup(stable_iterator save);
378
379 /// Add a branch fixup to the current cleanup scope.
380 BranchFixup &addBranchFixup() {
381 assert(hasNormalCleanups() && "adding fixup in scope without cleanups");
382 BranchFixups.push_back(BranchFixup());
383 return BranchFixups.back();
384 }
385
386 unsigned getNumBranchFixups() const { return BranchFixups.size(); }
387 BranchFixup &getBranchFixup(unsigned I) {
388 assert(I < getNumBranchFixups());
389 return BranchFixups[I];
390 }
391
John McCallff8e1152010-07-23 21:56:41 +0000392 /// Pops lazily-removed fixups from the end of the list. This
393 /// should only be called by procedures which have just popped a
394 /// cleanup or resolved one or more fixups.
395 void popNullFixups();
396
397 /// Clears the branch-fixups list. This should only be called by
398 /// CodeGenFunction::ResolveAllBranchFixups.
399 void clearFixups() { BranchFixups.clear(); }
400
401 /// Gets the next EH destination index.
402 unsigned getNextEHDestIndex() { return NextEHDestIndex++; }
John McCallf1549f62010-07-06 01:34:17 +0000403};
404
Reid Spencer5f016e22007-07-11 17:01:13 +0000405/// CodeGenFunction - This class organizes the per-function state that is used
406/// while generating LLVM code.
Mike Stump2a998142009-03-04 18:17:45 +0000407class CodeGenFunction : public BlockFunction {
Anders Carlsson8a219ce2009-02-24 04:21:31 +0000408 CodeGenFunction(const CodeGenFunction&); // DO NOT IMPLEMENT
409 void operator=(const CodeGenFunction&); // DO NOT IMPLEMENT
John McCall4c40d982010-08-31 07:33:07 +0000410
411 friend class CGCXXABI;
Chris Lattnerbfc0c1a2007-08-26 23:13:56 +0000412public:
John McCallff8e1152010-07-23 21:56:41 +0000413 /// A jump destination is an abstract label, branching to which may
414 /// require a jump out through normal cleanups.
John McCallf1549f62010-07-06 01:34:17 +0000415 struct JumpDest {
John McCallff8e1152010-07-23 21:56:41 +0000416 JumpDest() : Block(0), ScopeDepth(), Index(0) {}
417 JumpDest(llvm::BasicBlock *Block,
418 EHScopeStack::stable_iterator Depth,
419 unsigned Index)
420 : Block(Block), ScopeDepth(Depth), Index(Index) {}
421
422 bool isValid() const { return Block != 0; }
423 llvm::BasicBlock *getBlock() const { return Block; }
424 EHScopeStack::stable_iterator getScopeDepth() const { return ScopeDepth; }
425 unsigned getDestIndex() const { return Index; }
John McCallf1549f62010-07-06 01:34:17 +0000426
John McCallff8e1152010-07-23 21:56:41 +0000427 private:
John McCallf1549f62010-07-06 01:34:17 +0000428 llvm::BasicBlock *Block;
429 EHScopeStack::stable_iterator ScopeDepth;
John McCallff8e1152010-07-23 21:56:41 +0000430 unsigned Index;
431 };
432
433 /// An unwind destination is an abstract label, branching to which
434 /// may require a jump out through EH cleanups.
435 struct UnwindDest {
436 UnwindDest() : Block(0), ScopeDepth(), Index(0) {}
437 UnwindDest(llvm::BasicBlock *Block,
438 EHScopeStack::stable_iterator Depth,
439 unsigned Index)
440 : Block(Block), ScopeDepth(Depth), Index(Index) {}
441
442 bool isValid() const { return Block != 0; }
443 llvm::BasicBlock *getBlock() const { return Block; }
444 EHScopeStack::stable_iterator getScopeDepth() const { return ScopeDepth; }
445 unsigned getDestIndex() const { return Index; }
446
447 private:
448 llvm::BasicBlock *Block;
449 EHScopeStack::stable_iterator ScopeDepth;
450 unsigned Index;
John McCallf1549f62010-07-06 01:34:17 +0000451 };
452
Reid Spencer5f016e22007-07-11 17:01:13 +0000453 CodeGenModule &CGM; // Per-module state.
Daniel Dunbar444be732009-11-13 05:51:54 +0000454 const TargetInfo &Target;
Mike Stump0dd9e882009-02-08 23:14:22 +0000455
Chris Lattner58dee102007-08-21 16:57:55 +0000456 typedef std::pair<llvm::Value *, llvm::Value *> ComplexPairTy;
Daniel Dunbar45d196b2008-11-01 01:53:16 +0000457 CGBuilderTy Builder;
Mike Stump0dd9e882009-02-08 23:14:22 +0000458
Chris Lattnerb5437d22009-04-23 05:30:27 +0000459 /// CurFuncDecl - Holds the Decl for the current function or ObjC method.
460 /// This excludes BlockDecls.
Chris Lattner41110242008-06-17 18:05:57 +0000461 const Decl *CurFuncDecl;
Chris Lattnerb5437d22009-04-23 05:30:27 +0000462 /// CurCodeDecl - This is the inner-most code context, which includes blocks.
463 const Decl *CurCodeDecl;
Daniel Dunbar88b53962009-02-02 22:03:45 +0000464 const CGFunctionInfo *CurFnInfo;
Chris Lattner391d77a2008-03-30 23:03:07 +0000465 QualType FnRetTy;
Reid Spencer5f016e22007-07-11 17:01:13 +0000466 llvm::Function *CurFn;
467
Mike Stump6a1e0eb2009-12-04 23:26:17 +0000468 /// CurGD - The GlobalDecl for the current function being compiled.
469 GlobalDecl CurGD;
Mike Stump6a1e0eb2009-12-04 23:26:17 +0000470
Daniel Dunbar5ca20842008-09-09 21:00:17 +0000471 /// ReturnBlock - Unified return block.
John McCallf1549f62010-07-06 01:34:17 +0000472 JumpDest ReturnBlock;
473
Mike Stump0dd9e882009-02-08 23:14:22 +0000474 /// ReturnValue - The temporary alloca to hold the return value. This is null
475 /// iff the function has no return value.
Eli Friedmanb17daf92009-12-04 02:43:40 +0000476 llvm::Value *ReturnValue;
Mike Stump0dd9e882009-02-08 23:14:22 +0000477
John McCallff8e1152010-07-23 21:56:41 +0000478 /// RethrowBlock - Unified rethrow block.
479 UnwindDest RethrowBlock;
480
Reid Spencer5f016e22007-07-11 17:01:13 +0000481 /// AllocaInsertPoint - This is an instruction in the entry block before which
482 /// we prefer to insert allocas.
Chris Lattner481769b2009-03-31 22:17:44 +0000483 llvm::AssertingVH<llvm::Instruction> AllocaInsertPt;
Daniel Dunbar0ffb1252008-08-04 16:51:22 +0000484
Chris Lattner77b89b82010-06-27 07:15:29 +0000485 // intptr_t, i32, i64
486 const llvm::IntegerType *IntPtrTy, *Int32Ty, *Int64Ty;
Hartmut Kaiser7b660002007-10-17 15:00:17 +0000487 uint32_t LLVMPointerWidth;
Daniel Dunbar18ccc772008-09-28 01:03:14 +0000488
Mike Stumpd88ea562009-12-09 03:35:49 +0000489 bool Exceptions;
Mike Stump9c276ae2009-12-12 01:27:46 +0000490 bool CatchUndefined;
Douglas Gregor3d91bbc2010-05-17 15:52:46 +0000491
492 /// \brief A mapping from NRVO variables to the flags used to indicate
493 /// when the NRVO has been applied to this variable.
494 llvm::DenseMap<const VarDecl *, llvm::Value *> NRVOFlags;
John McCallf1549f62010-07-06 01:34:17 +0000495
496 EHScopeStack EHStack;
497
John McCallff8e1152010-07-23 21:56:41 +0000498 /// i32s containing the indexes of the cleanup destinations.
499 llvm::AllocaInst *NormalCleanupDest;
500 llvm::AllocaInst *EHCleanupDest;
501
502 unsigned NextCleanupDestIndex;
503
John McCallf1549f62010-07-06 01:34:17 +0000504 /// The exception slot. All landing pads write the current
505 /// exception pointer into this alloca.
506 llvm::Value *ExceptionSlot;
507
508 /// Emits a landing pad for the current EH stack.
509 llvm::BasicBlock *EmitLandingPad();
510
511 llvm::BasicBlock *getInvokeDestImpl();
512
Daniel Dunbar18ccc772008-09-28 01:03:14 +0000513public:
Anders Carlssonfa1f7562009-02-10 06:07:49 +0000514 /// ObjCEHValueStack - Stack of Objective-C exception values, used for
515 /// rethrows.
Anders Carlsson273558f2009-02-07 21:37:21 +0000516 llvm::SmallVector<llvm::Value*, 8> ObjCEHValueStack;
Mike Stump0dd9e882009-02-08 23:14:22 +0000517
John McCallf1549f62010-07-06 01:34:17 +0000518 // A struct holding information about a finally block's IR
519 // generation. For now, doesn't actually hold anything.
520 struct FinallyInfo {
Anders Carlssonbb66f9f2009-02-08 07:46:24 +0000521 };
522
John McCallf1549f62010-07-06 01:34:17 +0000523 FinallyInfo EnterFinallyBlock(const Stmt *Stmt,
524 llvm::Constant *BeginCatchFn,
525 llvm::Constant *EndCatchFn,
526 llvm::Constant *RethrowFn);
527 void ExitFinallyBlock(FinallyInfo &FinallyInfo);
Mike Stumpd88ea562009-12-09 03:35:49 +0000528
John McCallf1549f62010-07-06 01:34:17 +0000529 /// PushDestructorCleanup - Push a cleanup to call the
530 /// complete-object destructor of an object of the given type at the
531 /// given address. Does nothing if T is not a C++ class type with a
532 /// non-trivial destructor.
533 void PushDestructorCleanup(QualType T, llvm::Value *Addr);
534
John McCall81407d42010-07-21 06:29:51 +0000535 /// PushDestructorCleanup - Push a cleanup to call the
536 /// complete-object variant of the given destructor on the object at
537 /// the given address.
538 void PushDestructorCleanup(const CXXDestructorDecl *Dtor,
539 llvm::Value *Addr);
540
John McCallf1549f62010-07-06 01:34:17 +0000541 /// PopCleanupBlock - Will pop the cleanup entry on the stack and
542 /// process all branch fixups.
John McCallff8e1152010-07-23 21:56:41 +0000543 void PopCleanupBlock(bool FallThroughIsBranchThrough = false);
John McCallf1549f62010-07-06 01:34:17 +0000544
John McCallcd2d2b72010-08-13 21:20:51 +0000545 void ActivateCleanup(EHScopeStack::stable_iterator Cleanup);
546
John McCallf1549f62010-07-06 01:34:17 +0000547 /// \brief Enters a new scope for capturing cleanups, all of which
548 /// will be executed once the scope is exited.
549 class RunCleanupsScope {
Douglas Gregor01234bb2009-11-24 16:43:22 +0000550 CodeGenFunction& CGF;
John McCallf1549f62010-07-06 01:34:17 +0000551 EHScopeStack::stable_iterator CleanupStackDepth;
Douglas Gregor01234bb2009-11-24 16:43:22 +0000552 bool OldDidCallStackSave;
Douglas Gregor5656e142009-11-24 21:15:44 +0000553 bool PerformCleanup;
Douglas Gregor01234bb2009-11-24 16:43:22 +0000554
John McCallf1549f62010-07-06 01:34:17 +0000555 RunCleanupsScope(const RunCleanupsScope &); // DO NOT IMPLEMENT
556 RunCleanupsScope &operator=(const RunCleanupsScope &); // DO NOT IMPLEMENT
Douglas Gregor01234bb2009-11-24 16:43:22 +0000557
558 public:
559 /// \brief Enter a new cleanup scope.
John McCallf1549f62010-07-06 01:34:17 +0000560 explicit RunCleanupsScope(CodeGenFunction &CGF)
Douglas Gregor5656e142009-11-24 21:15:44 +0000561 : CGF(CGF), PerformCleanup(true)
562 {
John McCallf1549f62010-07-06 01:34:17 +0000563 CleanupStackDepth = CGF.EHStack.stable_begin();
Douglas Gregor01234bb2009-11-24 16:43:22 +0000564 OldDidCallStackSave = CGF.DidCallStackSave;
565 }
566
567 /// \brief Exit this cleanup scope, emitting any accumulated
568 /// cleanups.
John McCallf1549f62010-07-06 01:34:17 +0000569 ~RunCleanupsScope() {
Douglas Gregor5656e142009-11-24 21:15:44 +0000570 if (PerformCleanup) {
571 CGF.DidCallStackSave = OldDidCallStackSave;
John McCallf1549f62010-07-06 01:34:17 +0000572 CGF.PopCleanupBlocks(CleanupStackDepth);
Douglas Gregor5656e142009-11-24 21:15:44 +0000573 }
574 }
575
576 /// \brief Determine whether this scope requires any cleanups.
577 bool requiresCleanups() const {
John McCallf1549f62010-07-06 01:34:17 +0000578 return CGF.EHStack.stable_begin() != CleanupStackDepth;
Douglas Gregor5656e142009-11-24 21:15:44 +0000579 }
580
581 /// \brief Force the emission of cleanups now, instead of waiting
582 /// until this object is destroyed.
583 void ForceCleanup() {
584 assert(PerformCleanup && "Already forced cleanup");
Douglas Gregor01234bb2009-11-24 16:43:22 +0000585 CGF.DidCallStackSave = OldDidCallStackSave;
John McCallf1549f62010-07-06 01:34:17 +0000586 CGF.PopCleanupBlocks(CleanupStackDepth);
Douglas Gregor5656e142009-11-24 21:15:44 +0000587 PerformCleanup = false;
Douglas Gregor01234bb2009-11-24 16:43:22 +0000588 }
589 };
590
Anders Carlsson44ec82b2010-03-30 03:14:41 +0000591
John McCallf1549f62010-07-06 01:34:17 +0000592 /// PopCleanupBlocks - Takes the old cleanup stack size and emits
593 /// the cleanup blocks that have been added.
594 void PopCleanupBlocks(EHScopeStack::stable_iterator OldCleanupStackSize);
Anders Carlsson44ec82b2010-03-30 03:14:41 +0000595
John McCallff8e1152010-07-23 21:56:41 +0000596 void ResolveAllBranchFixups(llvm::SwitchInst *Switch);
597 void ResolveBranchFixups(llvm::BasicBlock *Target);
598
John McCallf1549f62010-07-06 01:34:17 +0000599 /// The given basic block lies in the current EH scope, but may be a
600 /// target of a potentially scope-crossing jump; get a stable handle
601 /// to which we can perform this jump later.
John McCallff8e1152010-07-23 21:56:41 +0000602 JumpDest getJumpDestInCurrentScope(llvm::BasicBlock *Target) {
John McCall413e6772010-07-28 01:07:35 +0000603 return JumpDest(Target,
604 EHStack.getInnermostNormalCleanup(),
605 NextCleanupDestIndex++);
John McCallf1549f62010-07-06 01:34:17 +0000606 }
Anders Carlssonc71c8452009-02-07 23:50:39 +0000607
John McCallf1549f62010-07-06 01:34:17 +0000608 /// The given basic block lies in the current EH scope, but may be a
609 /// target of a potentially scope-crossing jump; get a stable handle
610 /// to which we can perform this jump later.
611 JumpDest getJumpDestInCurrentScope(const char *Name = 0) {
John McCallff8e1152010-07-23 21:56:41 +0000612 return getJumpDestInCurrentScope(createBasicBlock(Name));
John McCallf1549f62010-07-06 01:34:17 +0000613 }
614
615 /// EmitBranchThroughCleanup - Emit a branch from the current insert
616 /// block through the normal cleanup handling code (if any) and then
617 /// on to \arg Dest.
618 void EmitBranchThroughCleanup(JumpDest Dest);
619
620 /// EmitBranchThroughEHCleanup - Emit a branch from the current
621 /// insert block through the EH cleanup handling code (if any) and
622 /// then on to \arg Dest.
John McCallff8e1152010-07-23 21:56:41 +0000623 void EmitBranchThroughEHCleanup(UnwindDest Dest);
624
625 /// getRethrowDest - Returns the unified outermost-scope rethrow
626 /// destination.
627 UnwindDest getRethrowDest();
Mike Stump0dd9e882009-02-08 23:14:22 +0000628
Anders Carlsson72119a82010-02-04 17:18:07 +0000629 /// BeginConditionalBranch - Should be called before a conditional part of an
Anders Carlssona36bf8f2009-11-20 17:27:56 +0000630 /// expression is emitted. For example, before the RHS of the expression below
631 /// is emitted:
Mike Stump1eb44332009-09-09 15:08:12 +0000632 ///
Anders Carlsson1d847502009-06-04 02:22:12 +0000633 /// b && f(T());
634 ///
Anders Carlssona36bf8f2009-11-20 17:27:56 +0000635 /// This is used to make sure that any temporaries created in the conditional
Anders Carlsson1d847502009-06-04 02:22:12 +0000636 /// branch are only destroyed if the branch is taken.
Anders Carlsson72119a82010-02-04 17:18:07 +0000637 void BeginConditionalBranch() {
Anders Carlssona36bf8f2009-11-20 17:27:56 +0000638 ++ConditionalBranchLevel;
639 }
Mike Stump1eb44332009-09-09 15:08:12 +0000640
Anders Carlsson72119a82010-02-04 17:18:07 +0000641 /// EndConditionalBranch - Should be called after a conditional part of an
Anders Carlssona36bf8f2009-11-20 17:27:56 +0000642 /// expression has been emitted.
Anders Carlsson72119a82010-02-04 17:18:07 +0000643 void EndConditionalBranch() {
Anders Carlsson08e9e452010-01-24 00:20:05 +0000644 assert(ConditionalBranchLevel != 0 &&
645 "Conditional branch mismatch!");
646
Anders Carlssona36bf8f2009-11-20 17:27:56 +0000647 --ConditionalBranchLevel;
648 }
Mike Stump1eb44332009-09-09 15:08:12 +0000649
Chris Lattner7f02f722007-08-24 05:35:26 +0000650private:
Chris Lattnerd9becd12009-10-28 23:59:40 +0000651 CGDebugInfo *DebugInfo;
Mike Stump09429b92009-02-17 17:00:02 +0000652
Mike Stumpf71d2322009-11-30 20:08:49 +0000653 /// IndirectBranch - The first time an indirect goto is seen we create a block
654 /// with an indirect branch. Every time we see the address of a label taken,
655 /// we add the label to the indirect goto. Every subsequent indirect goto is
656 /// codegen'd as a jump to the IndirectBranch's basic block.
Chris Lattnerd9becd12009-10-28 23:59:40 +0000657 llvm::IndirectBrInst *IndirectBranch;
Daniel Dunbar0ffb1252008-08-04 16:51:22 +0000658
Mike Stump0dd9e882009-02-08 23:14:22 +0000659 /// LocalDeclMap - This keeps track of the LLVM allocas or globals for local C
660 /// decls.
Reid Spencer5f016e22007-07-11 17:01:13 +0000661 llvm::DenseMap<const Decl*, llvm::Value*> LocalDeclMap;
662
663 /// LabelMap - This keeps track of the LLVM basic block for each C label.
John McCallf1549f62010-07-06 01:34:17 +0000664 llvm::DenseMap<const LabelStmt*, JumpDest> LabelMap;
Mike Stump0dd9e882009-02-08 23:14:22 +0000665
Mike Stump0dd9e882009-02-08 23:14:22 +0000666 // BreakContinueStack - This keeps track of where break and continue
Anders Carlssone4b6d342009-02-10 05:52:02 +0000667 // statements should jump to.
Chris Lattnerda138702007-07-16 21:28:45 +0000668 struct BreakContinue {
John McCallf1549f62010-07-06 01:34:17 +0000669 BreakContinue(JumpDest Break, JumpDest Continue)
670 : BreakBlock(Break), ContinueBlock(Continue) {}
Mike Stump0dd9e882009-02-08 23:14:22 +0000671
John McCallf1549f62010-07-06 01:34:17 +0000672 JumpDest BreakBlock;
673 JumpDest ContinueBlock;
Mike Stump0dd9e882009-02-08 23:14:22 +0000674 };
Chris Lattnerda138702007-07-16 21:28:45 +0000675 llvm::SmallVector<BreakContinue, 8> BreakContinueStack;
Daniel Dunbar18ccc772008-09-28 01:03:14 +0000676
Mike Stump0dd9e882009-02-08 23:14:22 +0000677 /// SwitchInsn - This is nearest current switch instruction. It is null if if
678 /// current context is not in a switch.
Devang Patel51b09f22007-10-04 23:45:31 +0000679 llvm::SwitchInst *SwitchInsn;
680
Mike Stump0dd9e882009-02-08 23:14:22 +0000681 /// CaseRangeBlock - This block holds if condition check for last case
Devang Patel80fd5f92007-10-09 17:08:50 +0000682 /// statement range in current switch instruction.
Devang Patelc049e4f2007-10-08 20:57:48 +0000683 llvm::BasicBlock *CaseRangeBlock;
684
Mike Stump0dd9e882009-02-08 23:14:22 +0000685 // VLASizeMap - This keeps track of the associated size for each VLA type.
Eli Friedmanbbed6b92009-08-15 02:50:32 +0000686 // We track this by the size expression rather than the type itself because
687 // in certain situations, like a const qualifier applied to an VLA typedef,
688 // multiple VLA types can share the same size expression.
Mike Stump0dd9e882009-02-08 23:14:22 +0000689 // FIXME: Maybe this could be a stack of maps that is pushed/popped as we
690 // enter/leave scopes.
Eli Friedmanbbed6b92009-08-15 02:50:32 +0000691 llvm::DenseMap<const Expr*, llvm::Value*> VLASizeMap;
Mike Stump0dd9e882009-02-08 23:14:22 +0000692
Anders Carlsson4cc1a472009-02-09 20:20:56 +0000693 /// DidCallStackSave - Whether llvm.stacksave has been called. Used to avoid
694 /// calling llvm.stacksave for multiple VLAs in the same scope.
695 bool DidCallStackSave;
Mike Stump09429b92009-02-17 17:00:02 +0000696
John McCallf1549f62010-07-06 01:34:17 +0000697 /// A block containing a single 'unreachable' instruction. Created
698 /// lazily by getUnreachableBlock().
699 llvm::BasicBlock *UnreachableBlock;
Mike Stump0dd9e882009-02-08 23:14:22 +0000700
Anders Carlssonf6c56e22009-11-25 03:15:49 +0000701 /// CXXThisDecl - When generating code for a C++ member function,
702 /// this will hold the implicit 'this' declaration.
Anders Carlsson2b77ba82009-04-04 20:47:02 +0000703 ImplicitParamDecl *CXXThisDecl;
John McCall25049412010-02-16 22:04:33 +0000704 llvm::Value *CXXThisValue;
Mike Stump1eb44332009-09-09 15:08:12 +0000705
Anders Carlssonf6c56e22009-11-25 03:15:49 +0000706 /// CXXVTTDecl - When generating code for a base object constructor or
707 /// base object destructor with virtual bases, this will hold the implicit
708 /// VTT parameter.
709 ImplicitParamDecl *CXXVTTDecl;
John McCall25049412010-02-16 22:04:33 +0000710 llvm::Value *CXXVTTValue;
Anders Carlssonf6c56e22009-11-25 03:15:49 +0000711
Anders Carlssona36bf8f2009-11-20 17:27:56 +0000712 /// ConditionalBranchLevel - Contains the nesting level of the current
713 /// conditional branch. This is used so that we know if a temporary should be
714 /// destroyed conditionally.
715 unsigned ConditionalBranchLevel;
Mike Stump1eb44332009-09-09 15:08:12 +0000716
Anders Carlsson7dfa4072009-09-12 02:14:24 +0000717
718 /// ByrefValueInfoMap - For each __block variable, contains a pair of the LLVM
719 /// type as well as the field number that contains the actual data.
720 llvm::DenseMap<const ValueDecl *, std::pair<const llvm::Type *,
721 unsigned> > ByRefValueInfo;
722
723 /// getByrefValueFieldNumber - Given a declaration, returns the LLVM field
724 /// number that holds the value.
725 unsigned getByRefValueLLVMField(const ValueDecl *VD) const;
Mike Stump182f3832009-12-10 00:02:42 +0000726
John McCallf1549f62010-07-06 01:34:17 +0000727 llvm::BasicBlock *TerminateLandingPad;
Mike Stump182f3832009-12-10 00:02:42 +0000728 llvm::BasicBlock *TerminateHandler;
Chris Lattner83252dc2010-07-20 21:07:09 +0000729 llvm::BasicBlock *TrapBB;
Eli Friedman94067052009-12-10 02:21:21 +0000730
Reid Spencer5f016e22007-07-11 17:01:13 +0000731public:
732 CodeGenFunction(CodeGenModule &cgm);
Mike Stump0dd9e882009-02-08 23:14:22 +0000733
Reid Spencer5f016e22007-07-11 17:01:13 +0000734 ASTContext &getContext() const;
Anders Carlssone896d982009-02-13 08:11:52 +0000735 CGDebugInfo *getDebugInfo() { return DebugInfo; }
Reid Spencer5f016e22007-07-11 17:01:13 +0000736
John McCallf1549f62010-07-06 01:34:17 +0000737 /// Returns a pointer to the function's exception object slot, which
738 /// is assigned in every landing pad.
739 llvm::Value *getExceptionSlot();
740
John McCallff8e1152010-07-23 21:56:41 +0000741 llvm::Value *getNormalCleanupDestSlot();
742 llvm::Value *getEHCleanupDestSlot();
743
John McCallf1549f62010-07-06 01:34:17 +0000744 llvm::BasicBlock *getUnreachableBlock() {
745 if (!UnreachableBlock) {
746 UnreachableBlock = createBasicBlock("unreachable");
747 new llvm::UnreachableInst(getLLVMContext(), UnreachableBlock);
748 }
749 return UnreachableBlock;
750 }
751
752 llvm::BasicBlock *getInvokeDest() {
753 if (!EHStack.requiresLandingPad()) return 0;
754 return getInvokeDestImpl();
755 }
Daniel Dunbar9834ffb2009-02-23 17:26:39 +0000756
Owen Andersona1cf15f2009-07-14 23:10:40 +0000757 llvm::LLVMContext &getLLVMContext() { return VMContext; }
Owen Anderson69243822009-07-13 04:10:07 +0000758
Daniel Dunbar9834ffb2009-02-23 17:26:39 +0000759 //===--------------------------------------------------------------------===//
760 // Objective-C
761 //===--------------------------------------------------------------------===//
762
Chris Lattner391d77a2008-03-30 23:03:07 +0000763 void GenerateObjCMethod(const ObjCMethodDecl *OMD);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +0000764
Mike Stump0dd9e882009-02-08 23:14:22 +0000765 void StartObjCMethod(const ObjCMethodDecl *MD,
Fariborz Jahanian679a5022009-01-10 21:06:09 +0000766 const ObjCContainerDecl *CD);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +0000767
Mike Stump0dd9e882009-02-08 23:14:22 +0000768 /// GenerateObjCGetter - Synthesize an Objective-C property getter function.
Fariborz Jahanianfef30b52008-12-09 20:23:04 +0000769 void GenerateObjCGetter(ObjCImplementationDecl *IMP,
770 const ObjCPropertyImplDecl *PID);
Fariborz Jahanian109dfc62010-04-28 21:28:56 +0000771 void GenerateObjCCtorDtorMethod(ObjCImplementationDecl *IMP,
772 ObjCMethodDecl *MD, bool ctor);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +0000773
Mike Stump0dd9e882009-02-08 23:14:22 +0000774 /// GenerateObjCSetter - Synthesize an Objective-C property setter function
775 /// for the given property.
Fariborz Jahanianfef30b52008-12-09 20:23:04 +0000776 void GenerateObjCSetter(ObjCImplementationDecl *IMP,
777 const ObjCPropertyImplDecl *PID);
Fariborz Jahanian0b2bd472010-04-13 00:38:05 +0000778 bool IndirectObjCSetterArg(const CGFunctionInfo &FI);
Fariborz Jahanian15bd5882010-04-13 18:32:24 +0000779 bool IvarTypeWithAggrGCObjects(QualType Ty);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +0000780
Mike Stump4e7a1f72009-02-21 20:00:35 +0000781 //===--------------------------------------------------------------------===//
782 // Block Bits
783 //===--------------------------------------------------------------------===//
784
Mike Stump8a2b4b12009-02-25 23:33:13 +0000785 llvm::Value *BuildBlockLiteralTmp(const BlockExpr *);
Blaine Garst2a7eb282010-02-23 21:51:17 +0000786 llvm::Constant *BuildDescriptorBlockDecl(const BlockExpr *,
Fariborz Jahanian89ecd412010-08-04 16:57:49 +0000787 const CGBlockInfo &Info,
Mike Stump08920992009-03-07 02:35:30 +0000788 const llvm::StructType *,
Fariborz Jahanian44034db2010-08-04 18:44:59 +0000789 llvm::Constant *BlockVarLayout,
Mike Stump08920992009-03-07 02:35:30 +0000790 std::vector<HelperInfo> *);
Mike Stump4e7a1f72009-02-21 20:00:35 +0000791
Fariborz Jahanian564360b2010-06-24 00:08:06 +0000792 llvm::Function *GenerateBlockFunction(GlobalDecl GD,
793 const BlockExpr *BExpr,
John McCallee504292010-05-21 04:11:14 +0000794 CGBlockInfo &Info,
Mike Stump6cc88f72009-03-20 21:53:12 +0000795 const Decl *OuterFuncDecl,
Fariborz Jahanian44034db2010-08-04 18:44:59 +0000796 llvm::Constant *& BlockVarLayout,
John McCallee504292010-05-21 04:11:14 +0000797 llvm::DenseMap<const Decl*, llvm::Value*> ldm);
Mike Stump4e7a1f72009-02-21 20:00:35 +0000798
799 llvm::Value *LoadBlockStruct();
800
John McCallea1471e2010-05-20 01:18:31 +0000801 void AllocateBlockCXXThisPointer(const CXXThisExpr *E);
802 void AllocateBlockDecl(const BlockDeclRefExpr *E);
John McCallee504292010-05-21 04:11:14 +0000803 llvm::Value *GetAddrOfBlockDecl(const BlockDeclRefExpr *E) {
804 return GetAddrOfBlockDecl(E->getDecl(), E->isByRef());
805 }
806 llvm::Value *GetAddrOfBlockDecl(const ValueDecl *D, bool ByRef);
Anders Carlsson9ad55132009-09-09 02:51:03 +0000807 const llvm::Type *BuildByRefType(const ValueDecl *D);
Mike Stumpdab514f2009-03-04 03:23:46 +0000808
Anders Carlsson0ff8baf2009-09-11 00:07:24 +0000809 void GenerateCode(GlobalDecl GD, llvm::Function *Fn);
810 void StartFunction(GlobalDecl GD, QualType RetTy,
Daniel Dunbar7c086512008-09-09 23:14:03 +0000811 llvm::Function *Fn,
Daniel Dunbar2284ac92008-10-18 18:22:23 +0000812 const FunctionArgList &Args,
813 SourceLocation StartLoc);
Daniel Dunbara448fb22008-11-11 23:11:34 +0000814
John McCall9fc6a772010-02-19 09:25:03 +0000815 void EmitConstructorBody(FunctionArgList &Args);
816 void EmitDestructorBody(FunctionArgList &Args);
817 void EmitFunctionBody(FunctionArgList &Args);
John McCalla355e072010-02-18 03:17:58 +0000818
Mike Stump0dd9e882009-02-08 23:14:22 +0000819 /// EmitReturnBlock - Emit the unified return block, trying to avoid its
820 /// emission when possible.
Daniel Dunbar1c1d6072009-01-26 23:27:52 +0000821 void EmitReturnBlock();
822
Mike Stump0dd9e882009-02-08 23:14:22 +0000823 /// FinishFunction - Complete IR generation of the current function. It is
824 /// legal to call this function even if there is no current insertion point.
Daniel Dunbaraf05bb92008-08-26 08:29:31 +0000825 void FinishFunction(SourceLocation EndLoc=SourceLocation());
Daniel Dunbar17b708d2008-09-09 23:27:19 +0000826
Anders Carlsson519c3282010-03-24 00:39:18 +0000827 /// GenerateThunk - Generate a thunk for the given method.
828 void GenerateThunk(llvm::Function *Fn, GlobalDecl GD, const ThunkInfo &Thunk);
829
Douglas Gregorfb8cc252010-05-05 05:51:00 +0000830 void EmitCtorPrologue(const CXXConstructorDecl *CD, CXXCtorType Type,
831 FunctionArgList &Args);
Mike Stump1eb44332009-09-09 15:08:12 +0000832
Anders Carlssond103f9f2010-03-28 19:40:00 +0000833 /// InitializeVTablePointer - Initialize the vtable pointer of the given
834 /// subobject.
835 ///
Anders Carlssonb3b772e2010-04-20 05:22:15 +0000836 void InitializeVTablePointer(BaseSubobject Base,
837 const CXXRecordDecl *NearestVBase,
Anders Carlsson42358402010-05-03 00:07:07 +0000838 uint64_t OffsetFromNearestVBase,
Anders Carlssond103f9f2010-03-28 19:40:00 +0000839 llvm::Constant *VTable,
840 const CXXRecordDecl *VTableClass);
841
842 typedef llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBasesSetTy;
Anders Carlssonb3b772e2010-04-20 05:22:15 +0000843 void InitializeVTablePointers(BaseSubobject Base,
844 const CXXRecordDecl *NearestVBase,
Anders Carlsson42358402010-05-03 00:07:07 +0000845 uint64_t OffsetFromNearestVBase,
Anders Carlsson603d6d12010-03-28 21:07:49 +0000846 bool BaseIsNonVirtualPrimaryBase,
847 llvm::Constant *VTable,
848 const CXXRecordDecl *VTableClass,
849 VisitedVirtualBasesSetTy& VBases);
Eli Friedman77a259c2009-12-08 06:46:18 +0000850
Anders Carlsson603d6d12010-03-28 21:07:49 +0000851 void InitializeVTablePointers(const CXXRecordDecl *ClassDecl);
Anders Carlssond103f9f2010-03-28 19:40:00 +0000852
853
John McCall50da2ca2010-07-21 05:30:47 +0000854 /// EnterDtorCleanups - Enter the cleanups necessary to complete the
855 /// given phase of destruction for a destructor. The end result
856 /// should call destructors on members and base classes in reverse
857 /// order of their construction.
858 void EnterDtorCleanups(const CXXDestructorDecl *Dtor, CXXDtorType Type);
Mike Stump1eb44332009-09-09 15:08:12 +0000859
Chris Lattner7255a2d2010-06-22 00:03:40 +0000860 /// ShouldInstrumentFunction - Return true if the current function should be
861 /// instrumented with __cyg_profile_func_* calls
862 bool ShouldInstrumentFunction();
863
864 /// EmitFunctionInstrumentation - Emit LLVM code to call the specified
865 /// instrumentation function with the current function and the call site, if
866 /// function instrumentation is enabled.
867 void EmitFunctionInstrumentation(const char *Fn);
868
Mike Stump0dd9e882009-02-08 23:14:22 +0000869 /// EmitFunctionProlog - Emit the target specific LLVM code to load the
870 /// arguments for the given function. This is also responsible for naming the
871 /// LLVM function arguments.
Daniel Dunbar88b53962009-02-02 22:03:45 +0000872 void EmitFunctionProlog(const CGFunctionInfo &FI,
873 llvm::Function *Fn,
Daniel Dunbar17b708d2008-09-09 23:27:19 +0000874 const FunctionArgList &Args);
875
Mike Stump0dd9e882009-02-08 23:14:22 +0000876 /// EmitFunctionEpilog - Emit the target specific LLVM code to return the
877 /// given temporary.
Chris Lattner35b21b82010-06-27 01:06:27 +0000878 void EmitFunctionEpilog(const CGFunctionInfo &FI);
Daniel Dunbar17b708d2008-09-09 23:27:19 +0000879
Mike Stumpcce3d4f2009-12-07 23:38:24 +0000880 /// EmitStartEHSpec - Emit the start of the exception spec.
881 void EmitStartEHSpec(const Decl *D);
882
883 /// EmitEndEHSpec - Emit the end of the exception spec.
884 void EmitEndEHSpec(const Decl *D);
885
John McCallf1549f62010-07-06 01:34:17 +0000886 /// getTerminateLandingPad - Return a landing pad that just calls terminate.
887 llvm::BasicBlock *getTerminateLandingPad();
888
889 /// getTerminateHandler - Return a handler (not a landing pad, just
890 /// a catch handler) that just calls terminate. This is used when
891 /// a terminate scope encloses a try.
Mike Stump9b39c512009-12-09 22:59:31 +0000892 llvm::BasicBlock *getTerminateHandler();
893
Daniel Dunbar8b1a3432009-02-03 23:03:55 +0000894 const llvm::Type *ConvertTypeForMem(QualType T);
Reid Spencer5f016e22007-07-11 17:01:13 +0000895 const llvm::Type *ConvertType(QualType T);
John McCallbff225e2010-02-16 04:15:37 +0000896 const llvm::Type *ConvertType(const TypeDecl *T) {
897 return ConvertType(getContext().getTypeDeclType(T));
898 }
Chris Lattnerc8aa5f12008-04-04 04:07:35 +0000899
Mike Stump0dd9e882009-02-08 23:14:22 +0000900 /// LoadObjCSelf - Load the value of self. This function is only valid while
901 /// generating code for an Objective-C method.
Chris Lattnerc8aa5f12008-04-04 04:07:35 +0000902 llvm::Value *LoadObjCSelf();
Mike Stump0dd9e882009-02-08 23:14:22 +0000903
904 /// TypeOfSelfObject - Return type of object that this self represents.
Fariborz Jahanian45012a72009-02-03 00:09:52 +0000905 QualType TypeOfSelfObject();
Chris Lattner41110242008-06-17 18:05:57 +0000906
Reid Spencer5f016e22007-07-11 17:01:13 +0000907 /// hasAggregateLLVMType - Return true if the specified AST type will map into
908 /// an aggregate LLVM type or is void.
909 static bool hasAggregateLLVMType(QualType T);
Daniel Dunbar55e87422008-11-11 02:29:29 +0000910
911 /// createBasicBlock - Create an LLVM basic block.
Mike Stump0dd9e882009-02-08 23:14:22 +0000912 llvm::BasicBlock *createBasicBlock(const char *Name="",
Daniel Dunbar55e87422008-11-11 02:29:29 +0000913 llvm::Function *Parent=0,
914 llvm::BasicBlock *InsertBefore=0) {
Daniel Dunbar29ea6722008-11-12 00:01:12 +0000915#ifdef NDEBUG
Owen Anderson0032b272009-08-13 21:57:51 +0000916 return llvm::BasicBlock::Create(VMContext, "", Parent, InsertBefore);
Daniel Dunbar29ea6722008-11-12 00:01:12 +0000917#else
Owen Anderson0032b272009-08-13 21:57:51 +0000918 return llvm::BasicBlock::Create(VMContext, Name, Parent, InsertBefore);
Daniel Dunbar29ea6722008-11-12 00:01:12 +0000919#endif
Daniel Dunbar55e87422008-11-11 02:29:29 +0000920 }
Mike Stump0dd9e882009-02-08 23:14:22 +0000921
Reid Spencer5f016e22007-07-11 17:01:13 +0000922 /// getBasicBlockForLabel - Return the LLVM basicblock that the specified
923 /// label maps to.
John McCallf1549f62010-07-06 01:34:17 +0000924 JumpDest getJumpDestForLabel(const LabelStmt *S);
Mike Stump0dd9e882009-02-08 23:14:22 +0000925
Mike Stumpf71d2322009-11-30 20:08:49 +0000926 /// SimplifyForwardingBlocks - If the given basic block is only a branch to
927 /// another basic block, simplify it. This assumes that no other code could
928 /// potentially reference the basic block.
Daniel Dunbaraa5bd872009-04-01 04:37:47 +0000929 void SimplifyForwardingBlocks(llvm::BasicBlock *BB);
930
Mike Stump0dd9e882009-02-08 23:14:22 +0000931 /// EmitBlock - Emit the given block \arg BB and set it as the insert point,
932 /// adding a fall-through branch from the current insert block if
933 /// necessary. It is legal to call this function even if there is no current
934 /// insertion point.
Daniel Dunbara0c21a82008-11-13 01:24:05 +0000935 ///
Mike Stump0dd9e882009-02-08 23:14:22 +0000936 /// IsFinished - If true, indicates that the caller has finished emitting
937 /// branches to the given block and does not expect to emit code into it. This
938 /// means the block can be ignored if it is unreachable.
Daniel Dunbara0c21a82008-11-13 01:24:05 +0000939 void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false);
Daniel Dunbar824e3bd2008-11-11 04:34:23 +0000940
Mike Stump0dd9e882009-02-08 23:14:22 +0000941 /// EmitBranch - Emit a branch to the specified basic block from the current
942 /// insert block, taking care to avoid creation of branches from dummy
943 /// blocks. It is legal to call this function even if there is no current
944 /// insertion point.
Daniel Dunbar5e08ad32008-11-11 22:06:59 +0000945 ///
Mike Stump0dd9e882009-02-08 23:14:22 +0000946 /// This function clears the current insertion point. The caller should follow
947 /// calls to this function with calls to Emit*Block prior to generation new
948 /// code.
Daniel Dunbard57a8712008-11-11 09:41:28 +0000949 void EmitBranch(llvm::BasicBlock *Block);
950
Mike Stump0dd9e882009-02-08 23:14:22 +0000951 /// HaveInsertPoint - True if an insertion point is defined. If not, this
952 /// indicates that the current code being emitted is unreachable.
953 bool HaveInsertPoint() const {
Daniel Dunbara448fb22008-11-11 23:11:34 +0000954 return Builder.GetInsertBlock() != 0;
955 }
956
Mike Stump0dd9e882009-02-08 23:14:22 +0000957 /// EnsureInsertPoint - Ensure that an insertion point is defined so that
958 /// emitted IR has a place to go. Note that by definition, if this function
959 /// creates a block then that block is unreachable; callers may do better to
960 /// detect when no insertion point is defined and simply skip IR generation.
Daniel Dunbara448fb22008-11-11 23:11:34 +0000961 void EnsureInsertPoint() {
962 if (!HaveInsertPoint())
963 EmitBlock(createBasicBlock());
964 }
Mike Stump0dd9e882009-02-08 23:14:22 +0000965
Daniel Dunbar488e9932008-08-16 00:56:44 +0000966 /// ErrorUnsupported - Print out an error that codegen doesn't support the
Chris Lattnerdc5e8262007-12-02 01:43:38 +0000967 /// specified stmt yet.
Daniel Dunbar90df4b62008-09-04 03:43:08 +0000968 void ErrorUnsupported(const Stmt *S, const char *Type,
969 bool OmitOnError=false);
Reid Spencer5f016e22007-07-11 17:01:13 +0000970
971 //===--------------------------------------------------------------------===//
972 // Helpers
973 //===--------------------------------------------------------------------===//
Mike Stump0dd9e882009-02-08 23:14:22 +0000974
Daniel Dunbar983e3d72010-08-21 04:20:22 +0000975 LValue MakeAddrLValue(llvm::Value *V, QualType T, unsigned Alignment = 0) {
976 return LValue::MakeAddr(V, T, Alignment, getContext());
Daniel Dunbar5cf8bfe2010-08-21 02:53:44 +0000977 }
978
Reid Spencer5f016e22007-07-11 17:01:13 +0000979 /// CreateTempAlloca - This creates a alloca and inserts it into the entry
Daniel Dunbar195337d2010-02-09 02:48:28 +0000980 /// block. The caller is responsible for setting an appropriate alignment on
981 /// the alloca.
Reid Spencer5f016e22007-07-11 17:01:13 +0000982 llvm::AllocaInst *CreateTempAlloca(const llvm::Type *Ty,
Daniel Dunbar259e9cc2009-10-19 01:21:05 +0000983 const llvm::Twine &Name = "tmp");
Mike Stump0dd9e882009-02-08 23:14:22 +0000984
John McCallac418162010-04-22 01:10:34 +0000985 /// InitTempAlloca - Provide an initial value for the given alloca.
986 void InitTempAlloca(llvm::AllocaInst *Alloca, llvm::Value *Value);
987
Daniel Dunbar9bd4da22010-02-16 19:44:13 +0000988 /// CreateIRTemp - Create a temporary IR object of the given type, with
989 /// appropriate alignment. This routine should only be used when an temporary
990 /// value needs to be stored into an alloca (for example, to avoid explicit
991 /// PHI construction), but the type is the IR type, not the type appropriate
992 /// for storing in memory.
Chris Lattner121b3fa2010-07-05 20:21:00 +0000993 llvm::AllocaInst *CreateIRTemp(QualType T, const llvm::Twine &Name = "tmp");
Daniel Dunbar9bd4da22010-02-16 19:44:13 +0000994
Daniel Dunbar195337d2010-02-09 02:48:28 +0000995 /// CreateMemTemp - Create a temporary memory object of the given type, with
996 /// appropriate alignment.
Chris Lattner121b3fa2010-07-05 20:21:00 +0000997 llvm::AllocaInst *CreateMemTemp(QualType T, const llvm::Twine &Name = "tmp");
Daniel Dunbar195337d2010-02-09 02:48:28 +0000998
Reid Spencer5f016e22007-07-11 17:01:13 +0000999 /// EvaluateExprAsBool - Perform the usual unary conversions on the specified
1000 /// expression and compare the result against zero, returning an Int1Ty value.
1001 llvm::Value *EvaluateExprAsBool(const Expr *E);
1002
Chris Lattner9b655512007-08-31 22:49:20 +00001003 /// EmitAnyExpr - Emit code to compute the specified expression which can have
1004 /// any type. The result is returned as an RValue struct. If this is an
1005 /// aggregate expression, the aggloc/agglocvolatile arguments indicate where
1006 /// the result should be returned.
Mike Stump49d1cd52009-05-26 22:03:21 +00001007 ///
1008 /// \param IgnoreResult - True if the resulting value isn't used.
Mike Stump0dd9e882009-02-08 23:14:22 +00001009 RValue EmitAnyExpr(const Expr *E, llvm::Value *AggLoc = 0,
Anders Carlsson14c5cbf2009-08-16 07:36:22 +00001010 bool IsAggLocVolatile = false, bool IgnoreResult = false,
1011 bool IsInitializer = false);
Devang Pateld9363c32007-09-28 21:49:18 +00001012
Mike Stump0dd9e882009-02-08 23:14:22 +00001013 // EmitVAListRef - Emit a "reference" to a va_list; this is either the address
1014 // or the value of the expression, depending on how va_list is defined.
Eli Friedman4fd0aa52009-01-20 17:46:04 +00001015 llvm::Value *EmitVAListRef(const Expr *E);
1016
Mike Stump0dd9e882009-02-08 23:14:22 +00001017 /// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result will
1018 /// always be accessible even if no aggregate location is provided.
Anders Carlsson14c5cbf2009-08-16 07:36:22 +00001019 RValue EmitAnyExprToTemp(const Expr *E, bool IsAggLocVolatile = false,
1020 bool IsInitializer = false);
Daniel Dunbar46f45b92008-09-09 01:06:48 +00001021
John McCall3d3ec1c2010-04-21 10:05:39 +00001022 /// EmitsAnyExprToMem - Emits the code necessary to evaluate an
1023 /// arbitrary expression into the given memory location.
1024 void EmitAnyExprToMem(const Expr *E, llvm::Value *Location,
1025 bool IsLocationVolatile = false,
1026 bool IsInitializer = false);
1027
Mike Stump27fe2e62009-05-23 22:29:41 +00001028 /// EmitAggregateCopy - Emit an aggrate copy.
1029 ///
1030 /// \param isVolatile - True iff either the source or the destination is
1031 /// volatile.
Daniel Dunbar7482d122008-09-09 20:49:46 +00001032 void EmitAggregateCopy(llvm::Value *DestPtr, llvm::Value *SrcPtr,
Mike Stump27fe2e62009-05-23 22:29:41 +00001033 QualType EltTy, bool isVolatile=false);
Daniel Dunbar7482d122008-09-09 20:49:46 +00001034
Devang Patel51b09f22007-10-04 23:45:31 +00001035 /// StartBlock - Start new block named N. If insert block is a dummy block
1036 /// then reuse it.
1037 void StartBlock(const char *N);
1038
Lauro Ramos Venancio81373352008-02-26 21:41:45 +00001039 /// GetAddrOfStaticLocalVar - Return the address of a static local variable.
John McCall4c40d982010-08-31 07:33:07 +00001040 llvm::Constant *GetAddrOfStaticLocalVar(const VarDecl *BVD) {
1041 return cast<llvm::Constant>(GetAddrOfLocalVar(BVD));
1042 }
Dan Gohman4f8d1232008-05-22 00:50:06 +00001043
Anders Carlssondde0a942008-09-11 09:15:33 +00001044 /// GetAddrOfLocalVar - Return the address of a local variable.
John McCall4c40d982010-08-31 07:33:07 +00001045 llvm::Value *GetAddrOfLocalVar(const VarDecl *VD) {
1046 llvm::Value *Res = LocalDeclMap[VD];
1047 assert(Res && "Invalid argument to GetAddrOfLocalVar(), no decl!");
1048 return Res;
1049 }
Mike Stump0dd9e882009-02-08 23:14:22 +00001050
Dan Gohman4f8d1232008-05-22 00:50:06 +00001051 /// getAccessedFieldNo - Given an encoded value and a result number, return
1052 /// the input field number being accessed.
1053 static unsigned getAccessedFieldNo(unsigned Idx, const llvm::Constant *Elts);
1054
Chris Lattnerd9becd12009-10-28 23:59:40 +00001055 llvm::BlockAddress *GetAddrOfLabel(const LabelStmt *L);
Chris Lattner3d00fdc2009-10-13 06:55:33 +00001056 llvm::BasicBlock *GetIndirectGotoBlock();
Daniel Dunbar0ffb1252008-08-04 16:51:22 +00001057
Anders Carlsson1884eb02010-05-22 17:35:42 +00001058 /// EmitNullInitialization - Generate code to set a value of the given type to
1059 /// null, If the type contains data member pointers, they will be initialized
1060 /// to -1 in accordance with the Itanium C++ ABI.
1061 void EmitNullInitialization(llvm::Value *DestPtr, QualType Ty);
Anders Carlssonddf7cac2008-11-04 05:30:00 +00001062
1063 // EmitVAArg - Generate code to get an argument from the passed in pointer
1064 // and update it accordingly. The return value is a pointer to the argument.
1065 // FIXME: We should be able to get rid of this method and use the va_arg
Mike Stump0dd9e882009-02-08 23:14:22 +00001066 // instruction in LLVM instead once it works well enough.
Anders Carlssonddf7cac2008-11-04 05:30:00 +00001067 llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty);
Anders Carlssonf666b772008-12-20 20:27:15 +00001068
Mike Stumpf71d2322009-11-30 20:08:49 +00001069 /// EmitVLASize - Generate code for any VLA size expressions that might occur
1070 /// in a variably modified type. If Ty is a VLA, will return the value that
1071 /// corresponds to the size in bytes of the VLA type. Will return 0 otherwise.
Daniel Dunbard286f052009-07-19 06:58:07 +00001072 ///
1073 /// This function can be called with a null (unreachable) insert point.
Anders Carlsson60d35412008-12-20 20:46:34 +00001074 llvm::Value *EmitVLASize(QualType Ty);
Mike Stump0dd9e882009-02-08 23:14:22 +00001075
Anders Carlssondcc90d82008-12-12 07:19:02 +00001076 // GetVLASize - Returns an LLVM value that corresponds to the size in bytes
1077 // of a variable length array type.
1078 llvm::Value *GetVLASize(const VariableArrayType *);
1079
Anders Carlsson5f4307b2009-04-14 16:58:56 +00001080 /// LoadCXXThis - Load the value of 'this'. This function is only valid while
1081 /// generating code for an C++ member function.
John McCall25049412010-02-16 22:04:33 +00001082 llvm::Value *LoadCXXThis() {
1083 assert(CXXThisValue && "no 'this' value for this function");
1084 return CXXThisValue;
1085 }
Mike Stump1eb44332009-09-09 15:08:12 +00001086
Anders Carlssonc997d422010-01-02 01:01:18 +00001087 /// LoadCXXVTT - Load the VTT parameter to base constructors/destructors have
1088 /// virtual bases.
John McCall25049412010-02-16 22:04:33 +00001089 llvm::Value *LoadCXXVTT() {
1090 assert(CXXVTTValue && "no VTT value for this function");
1091 return CXXVTTValue;
1092 }
John McCallbff225e2010-02-16 04:15:37 +00001093
1094 /// GetAddressOfBaseOfCompleteClass - Convert the given pointer to a
Anders Carlsson8561a862010-04-24 23:01:49 +00001095 /// complete class to the given direct base.
1096 llvm::Value *
1097 GetAddressOfDirectBaseInCompleteClass(llvm::Value *Value,
1098 const CXXRecordDecl *Derived,
1099 const CXXRecordDecl *Base,
1100 bool BaseIsVirtual);
Anders Carlssona88ad562010-04-24 21:51:08 +00001101
Mike Stumpf71d2322009-11-30 20:08:49 +00001102 /// GetAddressOfBaseClass - This function will add the necessary delta to the
1103 /// load of 'this' and returns address of the base class.
Anders Carlsson34a2d382010-04-24 21:06:20 +00001104 llvm::Value *GetAddressOfBaseClass(llvm::Value *Value,
Anders Carlsson8561a862010-04-24 23:01:49 +00001105 const CXXRecordDecl *Derived,
John McCallf871d0c2010-08-07 06:22:56 +00001106 CastExpr::path_const_iterator PathBegin,
1107 CastExpr::path_const_iterator PathEnd,
Anders Carlsson34a2d382010-04-24 21:06:20 +00001108 bool NullCheckValue);
1109
Anders Carlssona3697c92009-11-23 17:57:54 +00001110 llvm::Value *GetAddressOfDerivedClass(llvm::Value *Value,
Anders Carlsson8561a862010-04-24 23:01:49 +00001111 const CXXRecordDecl *Derived,
John McCallf871d0c2010-08-07 06:22:56 +00001112 CastExpr::path_const_iterator PathBegin,
1113 CastExpr::path_const_iterator PathEnd,
Anders Carlssona3697c92009-11-23 17:57:54 +00001114 bool NullCheckValue);
1115
Anders Carlssonbb7e17b2010-01-31 01:36:53 +00001116 llvm::Value *GetVirtualBaseClassOffset(llvm::Value *This,
1117 const CXXRecordDecl *ClassDecl,
1118 const CXXRecordDecl *BaseClassDecl);
Anders Carlsson2f1986b2009-10-06 22:43:30 +00001119
John McCallc0bf4622010-02-23 00:48:20 +00001120 void EmitDelegateCXXConstructorCall(const CXXConstructorDecl *Ctor,
1121 CXXCtorType CtorType,
1122 const FunctionArgList &Args);
Anders Carlsson155ed4a2010-05-02 23:20:53 +00001123 void EmitCXXConstructorCall(const CXXConstructorDecl *D, CXXCtorType Type,
1124 bool ForVirtualBase, llvm::Value *This,
Anders Carlssonb14095a2009-04-17 00:06:03 +00001125 CallExpr::const_arg_iterator ArgBeg,
1126 CallExpr::const_arg_iterator ArgEnd);
Mike Stump1eb44332009-09-09 15:08:12 +00001127
Fariborz Jahanian288dcaf2009-08-19 20:55:16 +00001128 void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D,
Anders Carlsson569c1f42009-09-23 02:45:36 +00001129 const ConstantArrayType *ArrayTy,
Anders Carlsson5d4d9462009-11-24 18:43:52 +00001130 llvm::Value *ArrayPtr,
1131 CallExpr::const_arg_iterator ArgBeg,
Douglas Gregor59174c02010-07-21 01:10:17 +00001132 CallExpr::const_arg_iterator ArgEnd,
1133 bool ZeroInitialization = false);
Anders Carlsson5d4d9462009-11-24 18:43:52 +00001134
Anders Carlsson569c1f42009-09-23 02:45:36 +00001135 void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D,
1136 llvm::Value *NumElements,
Anders Carlsson5d4d9462009-11-24 18:43:52 +00001137 llvm::Value *ArrayPtr,
1138 CallExpr::const_arg_iterator ArgBeg,
Douglas Gregor59174c02010-07-21 01:10:17 +00001139 CallExpr::const_arg_iterator ArgEnd,
1140 bool ZeroInitialization = false);
Anders Carlssonb14095a2009-04-17 00:06:03 +00001141
Fariborz Jahanianf800f6c2009-08-20 20:54:15 +00001142 void EmitCXXAggrDestructorCall(const CXXDestructorDecl *D,
1143 const ArrayType *Array,
1144 llvm::Value *This);
Mike Stump1eb44332009-09-09 15:08:12 +00001145
Fariborz Jahanian72c21532009-11-13 19:27:47 +00001146 void EmitCXXAggrDestructorCall(const CXXDestructorDecl *D,
1147 llvm::Value *NumElements,
1148 llvm::Value *This);
1149
Anders Carlsson02e370a2010-06-08 22:14:59 +00001150 llvm::Function *GenerateCXXAggrDestructorHelper(const CXXDestructorDecl *D,
1151 const ArrayType *Array,
1152 llvm::Value *This);
Fariborz Jahanian88f42802009-11-10 19:24:06 +00001153
Anders Carlsson7267c162009-05-29 21:03:38 +00001154 void EmitCXXDestructorCall(const CXXDestructorDecl *D, CXXDtorType Type,
Anders Carlsson8e6404c2010-05-02 23:29:11 +00001155 bool ForVirtualBase, llvm::Value *This);
Fariborz Jahanianef668722010-06-25 18:26:07 +00001156
1157 void EmitNewArrayInitializer(const CXXNewExpr *E, llvm::Value *NewPtr,
1158 llvm::Value *NumElements);
Mike Stump1eb44332009-09-09 15:08:12 +00001159
John McCallf1549f62010-07-06 01:34:17 +00001160 void EmitCXXTemporary(const CXXTemporary *Temporary, llvm::Value *Ptr);
Mike Stump1eb44332009-09-09 15:08:12 +00001161
Anders Carlssona00703d2009-05-31 01:40:14 +00001162 llvm::Value *EmitCXXNewExpr(const CXXNewExpr *E);
Anders Carlsson60e282c2009-08-16 21:13:42 +00001163 void EmitCXXDeleteExpr(const CXXDeleteExpr *E);
Mike Stump1eb44332009-09-09 15:08:12 +00001164
Eli Friedman4bf81522009-11-18 00:57:03 +00001165 void EmitDeleteCall(const FunctionDecl *DeleteFD, llvm::Value *Ptr,
1166 QualType DeleteTy);
1167
Mike Stumpc2e84ae2009-11-15 08:09:41 +00001168 llvm::Value* EmitCXXTypeidExpr(const CXXTypeidExpr *E);
Mike Stumpc849c052009-11-16 06:50:58 +00001169 llvm::Value *EmitDynamicCast(llvm::Value *V, const CXXDynamicCastExpr *DCE);
Mike Stumpc2e84ae2009-11-15 08:09:41 +00001170
Mike Stumpb14e62d2009-12-16 02:57:00 +00001171 void EmitCheck(llvm::Value *, unsigned Size);
1172
Chris Lattnerdd36d322010-01-09 21:40:03 +00001173 llvm::Value *EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV,
1174 bool isInc, bool isPre);
1175 ComplexPairTy EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV,
1176 bool isInc, bool isPre);
Reid Spencer5f016e22007-07-11 17:01:13 +00001177 //===--------------------------------------------------------------------===//
Reid Spencer5f016e22007-07-11 17:01:13 +00001178 // Declaration Emission
1179 //===--------------------------------------------------------------------===//
Mike Stump0dd9e882009-02-08 23:14:22 +00001180
Daniel Dunbard286f052009-07-19 06:58:07 +00001181 /// EmitDecl - Emit a declaration.
1182 ///
1183 /// This function can be called with a null (unreachable) insert point.
Reid Spencer5f016e22007-07-11 17:01:13 +00001184 void EmitDecl(const Decl &D);
Daniel Dunbard286f052009-07-19 06:58:07 +00001185
Mike Stump1eb44332009-09-09 15:08:12 +00001186 /// EmitBlockVarDecl - Emit a block variable declaration.
Daniel Dunbard286f052009-07-19 06:58:07 +00001187 ///
1188 /// This function can be called with a null (unreachable) insert point.
Steve Naroff248a7532008-04-15 22:42:06 +00001189 void EmitBlockVarDecl(const VarDecl &D);
Daniel Dunbard286f052009-07-19 06:58:07 +00001190
John McCallf1549f62010-07-06 01:34:17 +00001191 typedef void SpecialInitFn(CodeGenFunction &Init, const VarDecl &D,
1192 llvm::Value *Address);
1193
Daniel Dunbard286f052009-07-19 06:58:07 +00001194 /// EmitLocalBlockVarDecl - Emit a local block variable declaration.
1195 ///
1196 /// This function can be called with a null (unreachable) insert point.
John McCallf1549f62010-07-06 01:34:17 +00001197 void EmitLocalBlockVarDecl(const VarDecl &D, SpecialInitFn *SpecialInit = 0);
Daniel Dunbard286f052009-07-19 06:58:07 +00001198
Anders Carlssonf6b89a12010-02-07 02:03:08 +00001199 void EmitStaticBlockVarDecl(const VarDecl &D,
1200 llvm::GlobalValue::LinkageTypes Linkage);
Daniel Dunbarb7ec2462008-08-16 03:19:19 +00001201
1202 /// EmitParmDecl - Emit a ParmVarDecl or an ImplicitParamDecl.
1203 void EmitParmDecl(const VarDecl &D, llvm::Value *Arg);
Mike Stump0dd9e882009-02-08 23:14:22 +00001204
Reid Spencer5f016e22007-07-11 17:01:13 +00001205 //===--------------------------------------------------------------------===//
1206 // Statement Emission
1207 //===--------------------------------------------------------------------===//
1208
Mike Stump0dd9e882009-02-08 23:14:22 +00001209 /// EmitStopPoint - Emit a debug stoppoint if we are emitting debug info.
Daniel Dunbar09124252008-11-12 08:21:33 +00001210 void EmitStopPoint(const Stmt *S);
1211
Mike Stump0dd9e882009-02-08 23:14:22 +00001212 /// EmitStmt - Emit the code for the statement \arg S. It is legal to call
1213 /// this function even if there is no current insertion point.
1214 ///
1215 /// This function may clear the current insertion point; callers should use
1216 /// EnsureInsertPoint if they wish to subsequently generate code without first
1217 /// calling EmitBlock, EmitBranch, or EmitStmt.
Reid Spencer5f016e22007-07-11 17:01:13 +00001218 void EmitStmt(const Stmt *S);
Daniel Dunbara448fb22008-11-11 23:11:34 +00001219
Daniel Dunbar09124252008-11-12 08:21:33 +00001220 /// EmitSimpleStmt - Try to emit a "simple" statement which does not
Mike Stump0dd9e882009-02-08 23:14:22 +00001221 /// necessarily require an insertion point or debug information; typically
1222 /// because the statement amounts to a jump or a container of other
1223 /// statements.
Daniel Dunbar09124252008-11-12 08:21:33 +00001224 ///
1225 /// \return True if the statement was handled.
1226 bool EmitSimpleStmt(const Stmt *S);
1227
Chris Lattner9b655512007-08-31 22:49:20 +00001228 RValue EmitCompoundStmt(const CompoundStmt &S, bool GetLast = false,
1229 llvm::Value *AggLoc = 0, bool isAggVol = false);
Daniel Dunbara448fb22008-11-11 23:11:34 +00001230
Mike Stump0dd9e882009-02-08 23:14:22 +00001231 /// EmitLabel - Emit the block for the given label. It is legal to call this
1232 /// function even if there is no current insertion point.
Chris Lattner91d723d2008-07-26 20:23:23 +00001233 void EmitLabel(const LabelStmt &S); // helper for EmitLabelStmt.
Daniel Dunbara448fb22008-11-11 23:11:34 +00001234
Reid Spencer5f016e22007-07-11 17:01:13 +00001235 void EmitLabelStmt(const LabelStmt &S);
1236 void EmitGotoStmt(const GotoStmt &S);
Daniel Dunbar0ffb1252008-08-04 16:51:22 +00001237 void EmitIndirectGotoStmt(const IndirectGotoStmt &S);
Reid Spencer5f016e22007-07-11 17:01:13 +00001238 void EmitIfStmt(const IfStmt &S);
1239 void EmitWhileStmt(const WhileStmt &S);
1240 void EmitDoStmt(const DoStmt &S);
1241 void EmitForStmt(const ForStmt &S);
1242 void EmitReturnStmt(const ReturnStmt &S);
1243 void EmitDeclStmt(const DeclStmt &S);
Daniel Dunbar09124252008-11-12 08:21:33 +00001244 void EmitBreakStmt(const BreakStmt &S);
1245 void EmitContinueStmt(const ContinueStmt &S);
Devang Patel51b09f22007-10-04 23:45:31 +00001246 void EmitSwitchStmt(const SwitchStmt &S);
1247 void EmitDefaultStmt(const DefaultStmt &S);
1248 void EmitCaseStmt(const CaseStmt &S);
Devang Patelc049e4f2007-10-08 20:57:48 +00001249 void EmitCaseStmtRange(const CaseStmt &S);
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001250 void EmitAsmStmt(const AsmStmt &S);
Mike Stump0dd9e882009-02-08 23:14:22 +00001251
Anders Carlsson3d8400d2008-08-30 19:51:14 +00001252 void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S);
Anders Carlsson64d5d6c2008-09-09 10:04:29 +00001253 void EmitObjCAtTryStmt(const ObjCAtTryStmt &S);
1254 void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S);
Chris Lattner10cac6f2008-11-15 21:26:17 +00001255 void EmitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt &S);
Mike Stump0dd9e882009-02-08 23:14:22 +00001256
Douglas Gregor86a3a032010-05-16 01:24:12 +00001257 llvm::Constant *getUnwindResumeOrRethrowFn();
John McCall59a70002010-07-07 06:56:46 +00001258 void EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock = false);
1259 void ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock = false);
John McCall9fc6a772010-02-19 09:25:03 +00001260
Anders Carlsson6815e942009-09-27 18:58:34 +00001261 void EmitCXXTryStmt(const CXXTryStmt &S);
1262
Reid Spencer5f016e22007-07-11 17:01:13 +00001263 //===--------------------------------------------------------------------===//
1264 // LValue Expression Emission
1265 //===--------------------------------------------------------------------===//
1266
Daniel Dunbar13e81732009-02-05 07:09:07 +00001267 /// GetUndefRValue - Get an appropriate 'undef' rvalue for the given type.
1268 RValue GetUndefRValue(QualType Ty);
1269
Daniel Dunbarce1d38b2009-01-09 16:50:52 +00001270 /// EmitUnsupportedRValue - Emit a dummy r-value using the type of E
1271 /// and issue an ErrorUnsupported style diagnostic (using the
1272 /// provided Name).
1273 RValue EmitUnsupportedRValue(const Expr *E,
1274 const char *Name);
1275
Mike Stump0dd9e882009-02-08 23:14:22 +00001276 /// EmitUnsupportedLValue - Emit a dummy l-value using the type of E and issue
1277 /// an ErrorUnsupported style diagnostic (using the provided Name).
Daniel Dunbar6ba82a42008-08-25 20:45:57 +00001278 LValue EmitUnsupportedLValue(const Expr *E,
1279 const char *Name);
1280
Reid Spencer5f016e22007-07-11 17:01:13 +00001281 /// EmitLValue - Emit code to compute a designator that specifies the location
1282 /// of the expression.
1283 ///
1284 /// This can return one of two things: a simple address or a bitfield
1285 /// reference. In either case, the LLVM Value* in the LValue structure is
1286 /// guaranteed to be an LLVM pointer type.
1287 ///
1288 /// If this returns a bitfield reference, nothing about the pointee type of
1289 /// the LLVM value is known: For example, it may not be a pointer to an
1290 /// integer.
1291 ///
1292 /// If this returns a normal address, and if the lvalue's C type is fixed
1293 /// size, this method guarantees that the returned pointer type will point to
1294 /// an LLVM type of the same size of the lvalue's type. If the lvalue has a
1295 /// variable length type, this is not possible.
1296 ///
1297 LValue EmitLValue(const Expr *E);
Mike Stump0dd9e882009-02-08 23:14:22 +00001298
Mike Stumpb14e62d2009-12-16 02:57:00 +00001299 /// EmitCheckedLValue - Same as EmitLValue but additionally we generate
1300 /// checking code to guard against undefined behavior. This is only
1301 /// suitable when we know that the address will be used to access the
1302 /// object.
1303 LValue EmitCheckedLValue(const Expr *E);
1304
Daniel Dunbar9d9cc872009-02-10 00:57:50 +00001305 /// EmitLoadOfScalar - Load a scalar value from an address, taking
1306 /// care to appropriately convert from the memory representation to
1307 /// the LLVM value representation.
Mike Stump09429b92009-02-17 17:00:02 +00001308 llvm::Value *EmitLoadOfScalar(llvm::Value *Addr, bool Volatile,
Daniel Dunbar91a16fa2010-08-21 02:24:36 +00001309 unsigned Alignment, QualType Ty);
Daniel Dunbar9d9cc872009-02-10 00:57:50 +00001310
1311 /// EmitStoreOfScalar - Store a scalar value to an address, taking
1312 /// care to appropriately convert from the memory representation to
1313 /// the LLVM value representation.
Mike Stump09429b92009-02-17 17:00:02 +00001314 void EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr,
Daniel Dunbar91a16fa2010-08-21 02:24:36 +00001315 bool Volatile, unsigned Alignment, QualType Ty);
Daniel Dunbar9d9cc872009-02-10 00:57:50 +00001316
Reid Spencer5f016e22007-07-11 17:01:13 +00001317 /// EmitLoadOfLValue - Given an expression that represents a value lvalue,
1318 /// this method emits the address of the lvalue, then loads the result as an
1319 /// rvalue, returning the rvalue.
Reid Spencer5f016e22007-07-11 17:01:13 +00001320 RValue EmitLoadOfLValue(LValue V, QualType LVType);
Nate Begeman213541a2008-04-18 23:10:10 +00001321 RValue EmitLoadOfExtVectorElementLValue(LValue V, QualType LVType);
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +00001322 RValue EmitLoadOfBitfieldLValue(LValue LV, QualType ExprType);
Daniel Dunbar85c59ed2008-08-29 08:11:39 +00001323 RValue EmitLoadOfPropertyRefLValue(LValue LV, QualType ExprType);
Fariborz Jahanian43f44702008-11-22 22:30:21 +00001324 RValue EmitLoadOfKVCRefLValue(LValue LV, QualType ExprType);
Reid Spencer5f016e22007-07-11 17:01:13 +00001325
Mike Stump0dd9e882009-02-08 23:14:22 +00001326
Reid Spencer5f016e22007-07-11 17:01:13 +00001327 /// EmitStoreThroughLValue - Store the specified rvalue into the specified
1328 /// lvalue, where both are guaranteed to the have the same type, and that type
1329 /// is 'Ty'.
1330 void EmitStoreThroughLValue(RValue Src, LValue Dst, QualType Ty);
Nate Begeman213541a2008-04-18 23:10:10 +00001331 void EmitStoreThroughExtVectorComponentLValue(RValue Src, LValue Dst,
1332 QualType Ty);
Daniel Dunbar85c59ed2008-08-29 08:11:39 +00001333 void EmitStoreThroughPropertyRefLValue(RValue Src, LValue Dst, QualType Ty);
Fariborz Jahanian43f44702008-11-22 22:30:21 +00001334 void EmitStoreThroughKVCRefLValue(RValue Src, LValue Dst, QualType Ty);
Daniel Dunbared3849b2008-11-19 09:36:46 +00001335
Mike Stump0dd9e882009-02-08 23:14:22 +00001336 /// EmitStoreThroughLValue - Store Src into Dst with same constraints as
1337 /// EmitStoreThroughLValue.
Daniel Dunbared3849b2008-11-19 09:36:46 +00001338 ///
Mike Stump0dd9e882009-02-08 23:14:22 +00001339 /// \param Result [out] - If non-null, this will be set to a Value* for the
1340 /// bit-field contents after the store, appropriate for use as the result of
1341 /// an assignment to the bit-field.
Daniel Dunbared3849b2008-11-19 09:36:46 +00001342 void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, QualType Ty,
1343 llvm::Value **Result=0);
Mike Stump0dd9e882009-02-08 23:14:22 +00001344
Christopher Lamb22c940e2007-12-29 05:02:41 +00001345 // Note: only availabe for agg return types
Daniel Dunbar80e62c22008-09-04 03:20:13 +00001346 LValue EmitBinaryOperatorLValue(const BinaryOperator *E);
Douglas Gregor6a03e342010-04-23 04:16:32 +00001347 LValue EmitCompoundAssignOperatorLValue(const CompoundAssignOperator *E);
Daniel Dunbar5b5c9ef2009-02-11 20:59:32 +00001348 // Note: only available for agg return types
Christopher Lamb22c940e2007-12-29 05:02:41 +00001349 LValue EmitCallExprLValue(const CallExpr *E);
Daniel Dunbar5b5c9ef2009-02-11 20:59:32 +00001350 // Note: only available for agg return types
1351 LValue EmitVAArgExprLValue(const VAArgExpr *E);
Reid Spencer5f016e22007-07-11 17:01:13 +00001352 LValue EmitDeclRefLValue(const DeclRefExpr *E);
1353 LValue EmitStringLiteralLValue(const StringLiteral *E);
Chris Lattnereaf2bb82009-02-24 22:18:39 +00001354 LValue EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E);
Chris Lattnerd9f69102008-08-10 01:53:14 +00001355 LValue EmitPredefinedLValue(const PredefinedExpr *E);
Reid Spencer5f016e22007-07-11 17:01:13 +00001356 LValue EmitUnaryOpLValue(const UnaryOperator *E);
1357 LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E);
Nate Begeman213541a2008-04-18 23:10:10 +00001358 LValue EmitExtVectorElementExpr(const ExtVectorElementExpr *E);
Devang Patelb84a06e2007-10-23 02:10:49 +00001359 LValue EmitMemberExpr(const MemberExpr *E);
Fariborz Jahanian820bca42009-12-09 23:35:29 +00001360 LValue EmitObjCIsaExpr(const ObjCIsaExpr *E);
Eli Friedman06e863f2008-05-13 23:18:27 +00001361 LValue EmitCompoundLiteralLValue(const CompoundLiteralExpr *E);
Anders Carlsson6fcec8b2009-09-15 16:35:24 +00001362 LValue EmitConditionalOperatorLValue(const ConditionalOperator *E);
Chris Lattner75dfeda2009-03-18 18:28:57 +00001363 LValue EmitCastLValue(const CastExpr *E);
Douglas Gregored8abf12010-07-08 06:14:04 +00001364 LValue EmitNullInitializationLValue(const CXXScalarValueInitExpr *E);
Anders Carlsson909fbf72009-11-07 22:00:15 +00001365
Daniel Dunbar2a031922009-04-22 05:08:15 +00001366 llvm::Value *EmitIvarOffset(const ObjCInterfaceDecl *Interface,
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00001367 const ObjCIvarDecl *Ivar);
John McCalla9976d32010-05-21 01:18:57 +00001368 LValue EmitLValueForAnonRecordField(llvm::Value* Base,
1369 const FieldDecl* Field,
1370 unsigned CVRQualifiers);
Anders Carlsson0ed303c2009-11-17 03:57:07 +00001371 LValue EmitLValueForField(llvm::Value* Base, const FieldDecl* Field,
Anders Carlssone6d2a532010-01-29 05:05:36 +00001372 unsigned CVRQualifiers);
Anders Carlsson06a29702010-01-29 05:24:29 +00001373
1374 /// EmitLValueForFieldInitialization - Like EmitLValueForField, except that
1375 /// if the Field is a reference, this will return the address of the reference
1376 /// and not the address of the value stored in the reference.
1377 LValue EmitLValueForFieldInitialization(llvm::Value* Base,
1378 const FieldDecl* Field,
1379 unsigned CVRQualifiers);
1380
Fariborz Jahanian45012a72009-02-03 00:09:52 +00001381 LValue EmitLValueForIvar(QualType ObjectTy,
1382 llvm::Value* Base, const ObjCIvarDecl *Ivar,
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00001383 unsigned CVRQualifiers);
1384
Anders Carlsson0ed303c2009-11-17 03:57:07 +00001385 LValue EmitLValueForBitfield(llvm::Value* Base, const FieldDecl* Field,
Fariborz Jahanian598d3f62009-02-03 19:03:09 +00001386 unsigned CVRQualifiers);
Fariborz Jahanianfd64bb62008-12-15 20:35:07 +00001387
Mike Stumpa99038c2009-02-28 09:07:16 +00001388 LValue EmitBlockDeclRefLValue(const BlockDeclRefExpr *E);
1389
Anders Carlssonb58d0172009-05-30 23:23:33 +00001390 LValue EmitCXXConstructLValue(const CXXConstructExpr *E);
Anders Carlssone61c9e82009-05-30 23:30:54 +00001391 LValue EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E);
Anders Carlssonb9ea0b52009-09-14 01:10:45 +00001392 LValue EmitCXXExprWithTemporariesLValue(const CXXExprWithTemporaries *E);
Mike Stumpc2e84ae2009-11-15 08:09:41 +00001393 LValue EmitCXXTypeidLValue(const CXXTypeidExpr *E);
Anders Carlssonb9ea0b52009-09-14 01:10:45 +00001394
Daniel Dunbar0a04d772008-08-23 10:51:21 +00001395 LValue EmitObjCMessageExprLValue(const ObjCMessageExpr *E);
Chris Lattner391d77a2008-03-30 23:03:07 +00001396 LValue EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E);
Daniel Dunbar85c59ed2008-08-29 08:11:39 +00001397 LValue EmitObjCPropertyRefLValue(const ObjCPropertyRefExpr *E);
Fariborz Jahanian09105f52009-08-20 17:02:02 +00001398 LValue EmitObjCKVCRefLValue(const ObjCImplicitSetterGetterRefExpr *E);
Chris Lattner65459942009-04-25 19:35:26 +00001399 LValue EmitObjCSuperExprLValue(const ObjCSuperExpr *E);
1400 LValue EmitStmtExprLValue(const StmtExpr *E);
Fariborz Jahanian8bfd31f2009-10-22 22:57:31 +00001401 LValue EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E);
Fariborz Jahanian03b29602010-06-17 19:56:20 +00001402 LValue EmitObjCSelectorLValue(const ObjCSelectorExpr *E);
Devang Patel25c2c8f2010-08-10 17:53:33 +00001403 void EmitDeclRefExprDbgValue(const DeclRefExpr *E, llvm::ConstantInt *Init);
Reid Spencer5f016e22007-07-11 17:01:13 +00001404 //===--------------------------------------------------------------------===//
Chris Lattner883f6a72007-08-11 00:04:45 +00001405 // Scalar Expression Emission
Reid Spencer5f016e22007-07-11 17:01:13 +00001406 //===--------------------------------------------------------------------===//
1407
Mike Stump0dd9e882009-02-08 23:14:22 +00001408 /// EmitCall - Generate a call of the given function, expecting the given
1409 /// result type, and using the given argument list which specifies both the
1410 /// LLVM arguments and the types they were derived from.
Daniel Dunbarc0ef9f52009-02-20 18:06:48 +00001411 ///
Mike Stumpf71d2322009-11-30 20:08:49 +00001412 /// \param TargetDecl - If given, the decl of the function in a direct call;
1413 /// used to set attributes on the call (noreturn, etc.).
Daniel Dunbar88b53962009-02-02 22:03:45 +00001414 RValue EmitCall(const CGFunctionInfo &FnInfo,
1415 llvm::Value *Callee,
Anders Carlssonf3c47c92009-12-24 19:25:24 +00001416 ReturnValueSlot ReturnValue,
Daniel Dunbarc0ef9f52009-02-20 18:06:48 +00001417 const CallArgList &Args,
David Chisnalldd5c98f2010-05-01 11:15:56 +00001418 const Decl *TargetDecl = 0,
David Chisnall4b02afc2010-05-02 13:41:58 +00001419 llvm::Instruction **callOrInvoke = 0);
Mike Stump1eb44332009-09-09 15:08:12 +00001420
Anders Carlsson31777a22009-12-24 19:08:58 +00001421 RValue EmitCall(QualType FnType, llvm::Value *Callee,
Anders Carlssond2490a92009-12-24 20:40:36 +00001422 ReturnValueSlot ReturnValue,
Anders Carlsson98647712009-05-27 01:22:39 +00001423 CallExpr::const_arg_iterator ArgBeg,
1424 CallExpr::const_arg_iterator ArgEnd,
1425 const Decl *TargetDecl = 0);
Anders Carlssond2490a92009-12-24 20:40:36 +00001426 RValue EmitCallExpr(const CallExpr *E,
1427 ReturnValueSlot ReturnValue = ReturnValueSlot());
Mike Stump1eb44332009-09-09 15:08:12 +00001428
John McCallf1549f62010-07-06 01:34:17 +00001429 llvm::CallSite EmitCallOrInvoke(llvm::Value *Callee,
1430 llvm::Value * const *ArgBegin,
1431 llvm::Value * const *ArgEnd,
1432 const llvm::Twine &Name = "");
1433
Anders Carlsson566abee2009-11-13 04:45:41 +00001434 llvm::Value *BuildVirtualCall(const CXXMethodDecl *MD, llvm::Value *This,
Mike Stumpf0070db2009-08-26 20:46:33 +00001435 const llvm::Type *Ty);
Anders Carlsson566abee2009-11-13 04:45:41 +00001436 llvm::Value *BuildVirtualCall(const CXXDestructorDecl *DD, CXXDtorType Type,
1437 llvm::Value *&This, const llvm::Type *Ty);
1438
Anders Carlssonb9de2c52009-05-11 23:37:08 +00001439 RValue EmitCXXMemberCall(const CXXMethodDecl *MD,
1440 llvm::Value *Callee,
Anders Carlssona1736c02009-12-24 21:13:40 +00001441 ReturnValueSlot ReturnValue,
Anders Carlssonb9de2c52009-05-11 23:37:08 +00001442 llvm::Value *This,
Anders Carlssonc997d422010-01-02 01:01:18 +00001443 llvm::Value *VTT,
Anders Carlssonb9de2c52009-05-11 23:37:08 +00001444 CallExpr::const_arg_iterator ArgBeg,
1445 CallExpr::const_arg_iterator ArgEnd);
Anders Carlssona1736c02009-12-24 21:13:40 +00001446 RValue EmitCXXMemberCallExpr(const CXXMemberCallExpr *E,
1447 ReturnValueSlot ReturnValue);
1448 RValue EmitCXXMemberPointerCallExpr(const CXXMemberCallExpr *E,
1449 ReturnValueSlot ReturnValue);
Ted Kremenek55499762008-06-17 02:43:46 +00001450
Anders Carlsson0f294632009-05-27 04:18:27 +00001451 RValue EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E,
Anders Carlssona1736c02009-12-24 21:13:40 +00001452 const CXXMethodDecl *MD,
1453 ReturnValueSlot ReturnValue);
Mike Stump1eb44332009-09-09 15:08:12 +00001454
Anders Carlsson375c31c2009-10-03 19:43:08 +00001455
Mike Stump1eb44332009-09-09 15:08:12 +00001456 RValue EmitBuiltinExpr(const FunctionDecl *FD,
Daniel Dunbaref2abfe2009-02-16 22:43:43 +00001457 unsigned BuiltinID, const CallExpr *E);
Reid Spencer5f016e22007-07-11 17:01:13 +00001458
Anders Carlssona1736c02009-12-24 21:13:40 +00001459 RValue EmitBlockCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue);
Mike Stump09429b92009-02-17 17:00:02 +00001460
Mike Stump0dd9e882009-02-08 23:14:22 +00001461 /// EmitTargetBuiltinExpr - Emit the given builtin call. Returns 0 if the call
1462 /// is unhandled by the current target.
Daniel Dunbarf02e9dd2008-10-10 00:24:54 +00001463 llvm::Value *EmitTargetBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
1464
Chris Lattner2752c012010-03-03 19:03:45 +00001465 llvm::Value *EmitARMBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
Nate Begeman30d91712010-06-08 06:03:01 +00001466 llvm::Value *EmitNeonCall(llvm::Function *F,
1467 llvm::SmallVectorImpl<llvm::Value*> &O,
Nate Begeman61eecf52010-06-14 05:21:25 +00001468 const char *name, bool splat = false,
1469 unsigned shift = 0, bool rightshift = false);
Nate Begemancd480ad2010-08-06 01:24:57 +00001470 llvm::Value *EmitNeonSplat(llvm::Value *V, llvm::Constant *Idx,
1471 bool widen = false);
Nate Begeman464ccb62010-06-11 22:57:12 +00001472 llvm::Value *EmitNeonShiftVector(llvm::Value *V, const llvm::Type *Ty,
Nate Begeman61eecf52010-06-14 05:21:25 +00001473 bool negateForRightShift);
Nate Begeman30d91712010-06-08 06:03:01 +00001474
Anders Carlsson564f1de2007-12-09 23:17:02 +00001475 llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E);
1476 llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
Mike Stump0dd9e882009-02-08 23:14:22 +00001477
Daniel Dunbared7c6182008-08-20 00:28:19 +00001478 llvm::Value *EmitObjCProtocolExpr(const ObjCProtocolExpr *E);
Chris Lattner7f02f722007-08-24 05:35:26 +00001479 llvm::Value *EmitObjCStringLiteral(const ObjCStringLiteral *E);
Chris Lattner8fdf3282008-06-24 17:04:18 +00001480 llvm::Value *EmitObjCSelectorExpr(const ObjCSelectorExpr *E);
John McCallef072fd2010-05-22 01:48:05 +00001481 RValue EmitObjCMessageExpr(const ObjCMessageExpr *E,
1482 ReturnValueSlot Return = ReturnValueSlot());
1483 RValue EmitObjCPropertyGet(const Expr *E,
1484 ReturnValueSlot Return = ReturnValueSlot());
1485 RValue EmitObjCSuperPropertyGet(const Expr *Exp, const Selector &S,
1486 ReturnValueSlot Return = ReturnValueSlot());
Fariborz Jahanian43f44702008-11-22 22:30:21 +00001487 void EmitObjCPropertySet(const Expr *E, RValue Src);
Fariborz Jahanianf4695572009-03-20 19:18:21 +00001488 void EmitObjCSuperPropertySet(const Expr *E, const Selector &S, RValue Src);
Chris Lattner8fdf3282008-06-24 17:04:18 +00001489
1490
Anders Carlsson4029ca72009-05-20 00:24:07 +00001491 /// EmitReferenceBindingToExpr - Emits a reference binding to the passed in
1492 /// expression. Will emit a temporary variable if E is not an LValue.
Anders Carlsson32f36ba2010-06-26 16:35:32 +00001493 RValue EmitReferenceBindingToExpr(const Expr* E,
1494 const NamedDecl *InitializedDecl);
Anders Carlsson3aba0932010-01-31 18:34:51 +00001495
Chris Lattner883f6a72007-08-11 00:04:45 +00001496 //===--------------------------------------------------------------------===//
Chris Lattnerbfc0c1a2007-08-26 23:13:56 +00001497 // Expression Emission
Chris Lattner883f6a72007-08-11 00:04:45 +00001498 //===--------------------------------------------------------------------===//
Chris Lattnerbfc0c1a2007-08-26 23:13:56 +00001499
1500 // Expressions are broken into three classes: scalar, complex, aggregate.
Mike Stump0dd9e882009-02-08 23:14:22 +00001501
1502 /// EmitScalarExpr - Emit the computation of the specified expression of LLVM
1503 /// scalar type, returning the result.
Anders Carlsson14c5cbf2009-08-16 07:36:22 +00001504 llvm::Value *EmitScalarExpr(const Expr *E , bool IgnoreResultAssign = false);
Mike Stump0dd9e882009-02-08 23:14:22 +00001505
Chris Lattner3707b252007-08-26 06:48:56 +00001506 /// EmitScalarConversion - Emit a conversion from the specified type to the
1507 /// specified destination type, both of which are LLVM scalar types.
1508 llvm::Value *EmitScalarConversion(llvm::Value *Src, QualType SrcTy,
1509 QualType DstTy);
Mike Stump0dd9e882009-02-08 23:14:22 +00001510
Chris Lattner4f1a7b32007-08-26 16:34:22 +00001511 /// EmitComplexToScalarConversion - Emit a conversion from the specified
Mike Stump0dd9e882009-02-08 23:14:22 +00001512 /// complex type to the specified destination type, where the destination type
1513 /// is an LLVM scalar type.
Chris Lattner4f1a7b32007-08-26 16:34:22 +00001514 llvm::Value *EmitComplexToScalarConversion(ComplexPairTy Src, QualType SrcTy,
1515 QualType DstTy);
Mike Stump0dd9e882009-02-08 23:14:22 +00001516
1517
Chris Lattner883f6a72007-08-11 00:04:45 +00001518 /// EmitAggExpr - Emit the computation of the specified expression of
1519 /// aggregate type. The result is computed into DestPtr. Note that if
1520 /// DestPtr is null, the value of the aggregate expression is not needed.
Mike Stump49d1cd52009-05-26 22:03:21 +00001521 void EmitAggExpr(const Expr *E, llvm::Value *DestPtr, bool VolatileDest,
Fariborz Jahanian08c32132009-08-31 19:33:16 +00001522 bool IgnoreResult = false, bool IsInitializer = false,
1523 bool RequiresGCollection = false);
Mike Stump0dd9e882009-02-08 23:14:22 +00001524
Daniel Dunbar18aba0d2010-02-05 19:38:31 +00001525 /// EmitAggExprToLValue - Emit the computation of the specified expression of
1526 /// aggregate type into a temporary LValue.
1527 LValue EmitAggExprToLValue(const Expr *E);
1528
Fariborz Jahanian082b02e2009-07-08 01:18:33 +00001529 /// EmitGCMemmoveCollectable - Emit special API for structs with object
1530 /// pointers.
1531 void EmitGCMemmoveCollectable(llvm::Value *DestPtr, llvm::Value *SrcPtr,
Fariborz Jahanian08c32132009-08-31 19:33:16 +00001532 QualType Ty);
Fariborz Jahanian082b02e2009-07-08 01:18:33 +00001533
Chris Lattnerb6ef18a2007-08-21 05:54:00 +00001534 /// EmitComplexExpr - Emit the computation of the specified expression of
Chris Lattner23b1cdb2007-08-23 23:43:33 +00001535 /// complex type, returning the result.
Mike Stump7f79f9b2009-05-29 15:46:01 +00001536 ComplexPairTy EmitComplexExpr(const Expr *E, bool IgnoreReal = false,
1537 bool IgnoreImag = false,
1538 bool IgnoreRealAssign = false,
1539 bool IgnoreImagAssign = false);
Mike Stump0dd9e882009-02-08 23:14:22 +00001540
Chris Lattner23b1cdb2007-08-23 23:43:33 +00001541 /// EmitComplexExprIntoAddr - Emit the computation of the specified expression
1542 /// of complex type, storing into the specified Value*.
Chris Lattner190dbe22007-08-26 16:22:13 +00001543 void EmitComplexExprIntoAddr(const Expr *E, llvm::Value *DestAddr,
1544 bool DestIsVolatile);
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +00001545
1546 /// StoreComplexToAddr - Store a complex number into the specified address.
1547 void StoreComplexToAddr(ComplexPairTy V, llvm::Value *DestAddr,
1548 bool DestIsVolatile);
Chris Lattner9b655512007-08-31 22:49:20 +00001549 /// LoadComplexFromAddr - Load a complex number from the specified address.
1550 ComplexPairTy LoadComplexFromAddr(llvm::Value *SrcAddr, bool SrcIsVolatile);
Chris Lattner2621fd12008-05-08 05:58:21 +00001551
Mike Stumpf71d2322009-11-30 20:08:49 +00001552 /// CreateStaticBlockVarDecl - Create a zero-initialized LLVM global for a
1553 /// static block var decl.
Chris Lattner761acc12009-12-05 08:22:11 +00001554 llvm::GlobalVariable *CreateStaticBlockVarDecl(const VarDecl &D,
1555 const char *Separator,
Mike Stumpf71d2322009-11-30 20:08:49 +00001556 llvm::GlobalValue::LinkageTypes Linkage);
Chris Lattner761acc12009-12-05 08:22:11 +00001557
1558 /// AddInitializerToGlobalBlockVarDecl - Add the initializer for 'D' to the
1559 /// global variable that has already been created for it. If the initializer
1560 /// has a different type than GV does, this may free GV and return a different
1561 /// one. Otherwise it just returns GV.
1562 llvm::GlobalVariable *
1563 AddInitializerToGlobalBlockVarDecl(const VarDecl &D,
1564 llvm::GlobalVariable *GV);
1565
Daniel Dunbar0096acf2009-02-25 19:24:29 +00001566
Mike Stumpf71d2322009-11-30 20:08:49 +00001567 /// EmitStaticCXXBlockVarDeclInit - Create the initializer for a C++ runtime
1568 /// initialized static block var decl.
Anders Carlsson3b2e16b2009-08-08 21:45:14 +00001569 void EmitStaticCXXBlockVarDeclInit(const VarDecl &D,
1570 llvm::GlobalVariable *GV);
Anders Carlssone1b29ef2008-08-22 16:00:37 +00001571
Anders Carlsson3b2e16b2009-08-08 21:45:14 +00001572 /// EmitCXXGlobalVarDeclInit - Create the initializer for a C++
1573 /// variable with global storage.
1574 void EmitCXXGlobalVarDeclInit(const VarDecl &D, llvm::Constant *DeclPtr);
1575
1576 /// EmitCXXGlobalDtorRegistration - Emits a call to register the global ptr
1577 /// with the C++ runtime so that its destructor will be called at exit.
Fariborz Jahanian88f42802009-11-10 19:24:06 +00001578 void EmitCXXGlobalDtorRegistration(llvm::Constant *DtorFn,
Anders Carlsson3b2e16b2009-08-08 21:45:14 +00001579 llvm::Constant *DeclPtr);
Mike Stump1eb44332009-09-09 15:08:12 +00001580
Daniel Dunbarefb0fa92010-03-20 04:15:41 +00001581 /// GenerateCXXGlobalInitFunc - Generates code for initializing global
1582 /// variables.
1583 void GenerateCXXGlobalInitFunc(llvm::Function *Fn,
1584 llvm::Constant **Decls,
1585 unsigned NumDecls);
1586
1587 /// GenerateCXXGlobalDtorFunc - Generates code for destroying global
1588 /// variables.
1589 void GenerateCXXGlobalDtorFunc(llvm::Function *Fn,
Chris Lattner810112e2010-06-19 05:52:45 +00001590 const std::vector<std::pair<llvm::WeakVH,
Daniel Dunbarefb0fa92010-03-20 04:15:41 +00001591 llvm::Constant*> > &DtorsAndObjects);
1592
1593 void GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn, const VarDecl *D);
1594
Anders Carlsson31ccf372009-05-03 17:47:16 +00001595 void EmitCXXConstructExpr(llvm::Value *Dest, const CXXConstructExpr *E);
Mike Stump1eb44332009-09-09 15:08:12 +00001596
Anders Carlssonb58d0172009-05-30 23:23:33 +00001597 RValue EmitCXXExprWithTemporaries(const CXXExprWithTemporaries *E,
Mike Stump1eb44332009-09-09 15:08:12 +00001598 llvm::Value *AggLoc = 0,
Anders Carlsson14c5cbf2009-08-16 07:36:22 +00001599 bool IsAggLocVolatile = false,
1600 bool IsInitializer = false);
Mike Stump1eb44332009-09-09 15:08:12 +00001601
Anders Carlsson756b5c42009-10-30 01:42:31 +00001602 void EmitCXXThrowExpr(const CXXThrowExpr *E);
Douglas Gregor1eb2e592010-05-16 00:44:00 +00001603
Daniel Dunbar0ffb1252008-08-04 16:51:22 +00001604 //===--------------------------------------------------------------------===//
1605 // Internal Helpers
1606 //===--------------------------------------------------------------------===//
Mike Stump0dd9e882009-02-08 23:14:22 +00001607
Chris Lattner0946ccd2008-11-11 07:41:27 +00001608 /// ContainsLabel - Return true if the statement contains a label in it. If
1609 /// this statement is not executed normally, it not containing a label means
1610 /// that we can just remove the code.
1611 static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts = false);
Mike Stump0dd9e882009-02-08 23:14:22 +00001612
Daniel Dunbar4bc04552008-11-12 10:12:14 +00001613 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
Chris Lattner31a09842008-11-12 08:04:58 +00001614 /// to a constant, or if it does but contains a label, return 0. If it
1615 /// constant folds to 'true' and does not contain a label, return 1, if it
1616 /// constant folds to 'false' and does not contain a label, return -1.
1617 int ConstantFoldsToSimpleInteger(const Expr *Cond);
Mike Stump0dd9e882009-02-08 23:14:22 +00001618
Chris Lattner31a09842008-11-12 08:04:58 +00001619 /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an
1620 /// if statement) to the specified blocks. Based on the condition, this might
1621 /// try to simplify the codegen of the conditional based on the branch.
Chris Lattner9bc47e22008-11-12 07:46:33 +00001622 void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock,
Daniel Dunbar4bc04552008-11-12 10:12:14 +00001623 llvm::BasicBlock *FalseBlock);
Mike Stumpbe07f602009-12-14 21:58:14 +00001624
Mike Stump15037ca2009-12-15 00:35:12 +00001625 /// getTrapBB - Create a basic block that will call the trap intrinsic. We'll
1626 /// generate a branch around the created basic block as necessary.
Chris Lattner6c552c12010-07-20 20:19:24 +00001627 llvm::BasicBlock *getTrapBB();
1628
Anders Carlsson21c9ad92010-03-30 03:27:09 +00001629 /// EmitCallArg - Emit a single call argument.
1630 RValue EmitCallArg(const Expr *E, QualType ArgType);
1631
John McCall27360712010-05-26 22:34:26 +00001632 /// EmitDelegateCallArg - We are performing a delegate call; that
1633 /// is, the current function is delegating to another one. Produce
1634 /// a r-value suitable for passing the given parameter.
1635 RValue EmitDelegateCallArg(const VarDecl *Param);
1636
Chris Lattner31a09842008-11-12 08:04:58 +00001637private:
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00001638 void EmitReturnOfRValue(RValue RV, QualType Ty);
1639
Daniel Dunbar56273772008-09-17 00:51:38 +00001640 /// ExpandTypeFromArgs - Reconstruct a structure of type \arg Ty
1641 /// from function arguments into \arg Dst. See ABIArgInfo::Expand.
1642 ///
1643 /// \param AI - The first function argument of the expansion.
1644 /// \return The argument following the last expanded function
1645 /// argument.
Mike Stump0dd9e882009-02-08 23:14:22 +00001646 llvm::Function::arg_iterator
Daniel Dunbar56273772008-09-17 00:51:38 +00001647 ExpandTypeFromArgs(QualType Ty, LValue Dst,
1648 llvm::Function::arg_iterator AI);
1649
Mike Stump0dd9e882009-02-08 23:14:22 +00001650 /// ExpandTypeToArgs - Expand an RValue \arg Src, with the LLVM type for \arg
1651 /// Ty, into individual arguments on the provided vector \arg Args. See
1652 /// ABIArgInfo::Expand.
1653 void ExpandTypeToArgs(QualType Ty, RValue Src,
Daniel Dunbar56273772008-09-17 00:51:38 +00001654 llvm::SmallVector<llvm::Value*, 16> &Args);
Anders Carlssonc8c7b182009-01-11 19:40:10 +00001655
Mike Stump1eb44332009-09-09 15:08:12 +00001656 llvm::Value* EmitAsmInput(const AsmStmt &S,
Daniel Dunbarb84e8a62009-05-04 06:56:16 +00001657 const TargetInfo::ConstraintInfo &Info,
Anders Carlssonc8c7b182009-01-11 19:40:10 +00001658 const Expr *InputExpr, std::string &ConstraintStr);
Mike Stump0dd9e882009-02-08 23:14:22 +00001659
Eli Friedman6d7cfd72010-07-16 00:55:21 +00001660 llvm::Value* EmitAsmInputLValue(const AsmStmt &S,
1661 const TargetInfo::ConstraintInfo &Info,
1662 LValue InputValue, QualType InputType,
1663 std::string &ConstraintStr);
1664
Anders Carlsson0139bb92009-04-08 20:47:54 +00001665 /// EmitCallArgs - Emit call arguments for a function.
Mike Stump1eb44332009-09-09 15:08:12 +00001666 /// The CallArgTypeInfo parameter is used for iterating over the known
Anders Carlssonaf23f692009-04-18 20:20:22 +00001667 /// argument types of the function being called.
1668 template<typename T>
1669 void EmitCallArgs(CallArgList& Args, const T* CallArgTypeInfo,
Anders Carlsson0139bb92009-04-08 20:47:54 +00001670 CallExpr::const_arg_iterator ArgBeg,
Anders Carlssonaf23f692009-04-18 20:20:22 +00001671 CallExpr::const_arg_iterator ArgEnd) {
1672 CallExpr::const_arg_iterator Arg = ArgBeg;
Anders Carlsson0139bb92009-04-08 20:47:54 +00001673
Anders Carlssonaf23f692009-04-18 20:20:22 +00001674 // First, use the argument types that the type info knows about
1675 if (CallArgTypeInfo) {
1676 for (typename T::arg_type_iterator I = CallArgTypeInfo->arg_type_begin(),
1677 E = CallArgTypeInfo->arg_type_end(); I != E; ++I, ++Arg) {
Eli Friedman44b0a3e2009-11-18 03:42:04 +00001678 assert(Arg != ArgEnd && "Running over edge of argument list!");
Anders Carlssonaf23f692009-04-18 20:20:22 +00001679 QualType ArgType = *I;
1680
1681 assert(getContext().getCanonicalType(ArgType.getNonReferenceType()).
Mike Stump1eb44332009-09-09 15:08:12 +00001682 getTypePtr() ==
1683 getContext().getCanonicalType(Arg->getType()).getTypePtr() &&
Anders Carlssonaf23f692009-04-18 20:20:22 +00001684 "type mismatch in call argument!");
Mike Stump1eb44332009-09-09 15:08:12 +00001685
1686 Args.push_back(std::make_pair(EmitCallArg(*Arg, ArgType),
Anders Carlssonaf23f692009-04-18 20:20:22 +00001687 ArgType));
1688 }
Mike Stump1eb44332009-09-09 15:08:12 +00001689
1690 // Either we've emitted all the call args, or we have a call to a
Anders Carlssonaf23f692009-04-18 20:20:22 +00001691 // variadic function.
Mike Stump1eb44332009-09-09 15:08:12 +00001692 assert((Arg == ArgEnd || CallArgTypeInfo->isVariadic()) &&
Anders Carlssonaf23f692009-04-18 20:20:22 +00001693 "Extra arguments in non-variadic function!");
Mike Stump1eb44332009-09-09 15:08:12 +00001694
Anders Carlssonaf23f692009-04-18 20:20:22 +00001695 }
Mike Stump1eb44332009-09-09 15:08:12 +00001696
Anders Carlssonaf23f692009-04-18 20:20:22 +00001697 // If we still have any arguments, emit them using the type of the argument.
1698 for (; Arg != ArgEnd; ++Arg) {
1699 QualType ArgType = Arg->getType();
1700 Args.push_back(std::make_pair(EmitCallArg(*Arg, ArgType),
1701 ArgType));
1702 }
1703 }
John McCall492c4f92010-03-03 04:15:11 +00001704
1705 const TargetCodeGenInfo &getTargetHooks() const {
1706 return CGM.getTargetCodeGenInfo();
1707 }
John McCall744016d2010-07-06 23:57:41 +00001708
1709 void EmitDeclMetadata();
Reid Spencer5f016e22007-07-11 17:01:13 +00001710};
Mike Stump1eb44332009-09-09 15:08:12 +00001711
Fariborz Jahanian89ecd412010-08-04 16:57:49 +00001712/// CGBlockInfo - Information to generate a block literal.
1713class CGBlockInfo {
1714public:
1715 /// Name - The name of the block, kindof.
1716 const char *Name;
1717
1718 /// DeclRefs - Variables from parent scopes that have been
1719 /// imported into this block.
1720 llvm::SmallVector<const BlockDeclRefExpr *, 8> DeclRefs;
1721
1722 /// InnerBlocks - This block and the blocks it encloses.
1723 llvm::SmallPtrSet<const DeclContext *, 4> InnerBlocks;
1724
1725 /// CXXThisRef - Non-null if 'this' was required somewhere, in
1726 /// which case this is that expression.
1727 const CXXThisExpr *CXXThisRef;
1728
1729 /// NeedsObjCSelf - True if something in this block has an implicit
1730 /// reference to 'self'.
1731 bool NeedsObjCSelf;
1732
1733 /// These are initialized by GenerateBlockFunction.
1734 bool BlockHasCopyDispose;
1735 CharUnits BlockSize;
1736 CharUnits BlockAlign;
1737 llvm::SmallVector<const Expr*, 8> BlockLayout;
1738
1739 CGBlockInfo(const char *Name);
1740};
1741
Reid Spencer5f016e22007-07-11 17:01:13 +00001742} // end namespace CodeGen
1743} // end namespace clang
1744
1745#endif