blob: 67e63cd346bf418e0fe4f8f10a84e9edbc527b52 [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"
John McCallf85e1932011-06-15 23:02:42 +000021#include "clang/Frontend/CodeGenOptions.h"
Peter Collingbourne14110472011-01-13 18:57:25 +000022#include "clang/Basic/ABI.h"
Chris Lattner481769b2009-03-31 22:17:44 +000023#include "clang/Basic/TargetInfo.h"
24#include "llvm/ADT/DenseMap.h"
25#include "llvm/ADT/SmallVector.h"
26#include "llvm/Support/ValueHandle.h"
Owen Anderson69243822009-07-13 04:10:07 +000027#include "CodeGenModule.h"
Daniel Dunbar45d196b2008-11-01 01:53:16 +000028#include "CGBuilder.h"
Daniel Dunbar8f2926b2008-08-23 03:46:30 +000029#include "CGValue.h"
30
Reid Spencer5f016e22007-07-11 17:01:13 +000031namespace llvm {
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000032 class BasicBlock;
Benjamin Kramerf21efe92009-08-11 17:46:57 +000033 class LLVMContext;
David Chisnalldd5c98f2010-05-01 11:15:56 +000034 class MDNode;
Reid Spencer5f016e22007-07-11 17:01:13 +000035 class Module;
Daniel Dunbar898d5082008-09-30 01:06:03 +000036 class SwitchInst;
Daniel Dunbar259e9cc2009-10-19 01:21:05 +000037 class Twine;
Daniel Dunbared3849b2008-11-19 09:36:46 +000038 class Value;
John McCallf1549f62010-07-06 01:34:17 +000039 class CallSite;
Reid Spencer5f016e22007-07-11 17:01:13 +000040}
41
42namespace clang {
Devang Patel8d308382010-08-10 07:24:25 +000043 class APValue;
Reid Spencer5f016e22007-07-11 17:01:13 +000044 class ASTContext;
Anders Carlsson7267c162009-05-29 21:03:38 +000045 class CXXDestructorDecl;
Richard Smithad762fc2011-04-14 22:09:26 +000046 class CXXForRangeStmt;
Anders Carlsson6815e942009-09-27 18:58:34 +000047 class CXXTryStmt;
Reid Spencer5f016e22007-07-11 17:01:13 +000048 class Decl;
Chris Lattnerad8dcf42011-02-17 07:39:24 +000049 class LabelDecl;
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000050 class EnumConstantDecl;
Reid Spencer5f016e22007-07-11 17:01:13 +000051 class FunctionDecl;
Douglas Gregor72564e72009-02-26 23:50:07 +000052 class FunctionProtoType;
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000053 class LabelStmt;
Fariborz Jahanian679a5022009-01-10 21:06:09 +000054 class ObjCContainerDecl;
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +000055 class ObjCInterfaceDecl;
56 class ObjCIvarDecl;
Chris Lattner391d77a2008-03-30 23:03:07 +000057 class ObjCMethodDecl;
Fariborz Jahanianfef30b52008-12-09 20:23:04 +000058 class ObjCImplementationDecl;
Daniel Dunbaraf05bb92008-08-26 08:29:31 +000059 class ObjCPropertyImplDecl;
Reid Spencer5f016e22007-07-11 17:01:13 +000060 class TargetInfo;
John McCall492c4f92010-03-03 04:15:11 +000061 class TargetCodeGenInfo;
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000062 class VarDecl;
Chris Lattner16f00492009-04-26 01:32:48 +000063 class ObjCForCollectionStmt;
64 class ObjCAtTryStmt;
65 class ObjCAtThrowStmt;
66 class ObjCAtSynchronizedStmt;
John McCallf85e1932011-06-15 23:02:42 +000067 class ObjCAutoreleasePoolStmt;
Devang Patelb84a06e2007-10-23 02:10:49 +000068
Reid Spencer5f016e22007-07-11 17:01:13 +000069namespace CodeGen {
Devang Patelb84a06e2007-10-23 02:10:49 +000070 class CodeGenTypes;
Anders Carlssone896d982009-02-13 08:11:52 +000071 class CGDebugInfo;
Daniel Dunbarbb36d332009-02-02 21:43:58 +000072 class CGFunctionInfo;
Mike Stump0dd9e882009-02-08 23:14:22 +000073 class CGRecordLayout;
John McCallee504292010-05-21 04:11:14 +000074 class CGBlockInfo;
John McCall4c40d982010-08-31 07:33:07 +000075 class CGCXXABI;
John McCalld16c2cf2011-02-08 08:22:06 +000076 class BlockFlags;
77 class BlockFieldFlags;
Mike Stump0dd9e882009-02-08 23:14:22 +000078
John McCallf1549f62010-07-06 01:34:17 +000079/// A branch fixup. These are required when emitting a goto to a
80/// label which hasn't been emitted yet. The goto is optimistically
81/// emitted as a branch to the basic block for the label, and (if it
82/// occurs in a scope with non-trivial cleanups) a fixup is added to
83/// the innermost cleanup. When a (normal) cleanup is popped, any
84/// unresolved fixups in that scope are threaded through the cleanup.
85struct BranchFixup {
John McCallff8e1152010-07-23 21:56:41 +000086 /// The block containing the terminator which needs to be modified
87 /// into a switch if this fixup is resolved into the current scope.
88 /// If null, LatestBranch points directly to the destination.
89 llvm::BasicBlock *OptimisticBranchBlock;
John McCallf1549f62010-07-06 01:34:17 +000090
John McCallff8e1152010-07-23 21:56:41 +000091 /// The ultimate destination of the branch.
John McCallf1549f62010-07-06 01:34:17 +000092 ///
93 /// This can be set to null to indicate that this fixup was
94 /// successfully resolved.
95 llvm::BasicBlock *Destination;
96
John McCallff8e1152010-07-23 21:56:41 +000097 /// The destination index value.
98 unsigned DestinationIndex;
99
100 /// The initial branch of the fixup.
101 llvm::BranchInst *InitialBranch;
John McCallf1549f62010-07-06 01:34:17 +0000102};
103
John McCall804b8072011-01-28 10:53:53 +0000104template <class T> struct InvariantValue {
John McCall150b4622011-01-26 04:00:11 +0000105 typedef T type;
106 typedef T saved_type;
107 static bool needsSaving(type value) { return false; }
108 static saved_type save(CodeGenFunction &CGF, type value) { return value; }
109 static type restore(CodeGenFunction &CGF, saved_type value) { return value; }
110};
John McCall804b8072011-01-28 10:53:53 +0000111
112/// A metaprogramming class for ensuring that a value will dominate an
113/// arbitrary position in a function.
114template <class T> struct DominatingValue : InvariantValue<T> {};
115
116template <class T, bool mightBeInstruction =
117 llvm::is_base_of<llvm::Value, T>::value &&
118 !llvm::is_base_of<llvm::Constant, T>::value &&
119 !llvm::is_base_of<llvm::BasicBlock, T>::value>
120struct DominatingPointer;
121template <class T> struct DominatingPointer<T,false> : InvariantValue<T*> {};
122// template <class T> struct DominatingPointer<T,true> at end of file
123
124template <class T> struct DominatingValue<T*> : DominatingPointer<T> {};
John McCall150b4622011-01-26 04:00:11 +0000125
John McCallcd2d2b72010-08-13 21:20:51 +0000126enum CleanupKind {
127 EHCleanup = 0x1,
128 NormalCleanup = 0x2,
129 NormalAndEHCleanup = EHCleanup | NormalCleanup,
130
131 InactiveCleanup = 0x4,
132 InactiveEHCleanup = EHCleanup | InactiveCleanup,
133 InactiveNormalCleanup = NormalCleanup | InactiveCleanup,
134 InactiveNormalAndEHCleanup = NormalAndEHCleanup | InactiveCleanup
135};
John McCallda65ea82010-07-13 20:32:21 +0000136
John McCallf1549f62010-07-06 01:34:17 +0000137/// A stack of scopes which respond to exceptions, including cleanups
138/// and catch blocks.
139class EHScopeStack {
140public:
141 /// A saved depth on the scope stack. This is necessary because
142 /// pushing scopes onto the stack invalidates iterators.
143 class stable_iterator {
144 friend class EHScopeStack;
145
146 /// Offset from StartOfData to EndOfBuffer.
147 ptrdiff_t Size;
148
149 stable_iterator(ptrdiff_t Size) : Size(Size) {}
150
151 public:
152 static stable_iterator invalid() { return stable_iterator(-1); }
153 stable_iterator() : Size(-1) {}
154
155 bool isValid() const { return Size >= 0; }
156
John McCall838d7962010-08-14 07:46:19 +0000157 /// Returns true if this scope encloses I.
158 /// Returns false if I is invalid.
159 /// This scope must be valid.
John McCallff8e1152010-07-23 21:56:41 +0000160 bool encloses(stable_iterator I) const { return Size <= I.Size; }
John McCall838d7962010-08-14 07:46:19 +0000161
162 /// Returns true if this scope strictly encloses I: that is,
163 /// if it encloses I and is not I.
164 /// Returns false is I is invalid.
165 /// This scope must be valid.
John McCallff8e1152010-07-23 21:56:41 +0000166 bool strictlyEncloses(stable_iterator I) const { return Size < I.Size; }
John McCall1bda6622010-07-21 00:40:03 +0000167
John McCallf1549f62010-07-06 01:34:17 +0000168 friend bool operator==(stable_iterator A, stable_iterator B) {
169 return A.Size == B.Size;
170 }
171 friend bool operator!=(stable_iterator A, stable_iterator B) {
172 return A.Size != B.Size;
173 }
174 };
175
John McCall1f0fca52010-07-21 07:22:38 +0000176 /// Information for lazily generating a cleanup. Subclasses must be
177 /// POD-like: cleanups will not be destructed, and they will be
178 /// allocated on the cleanup stack and freely copied and moved
179 /// around.
John McCallda65ea82010-07-13 20:32:21 +0000180 ///
John McCall1f0fca52010-07-21 07:22:38 +0000181 /// Cleanup implementations should generally be declared in an
John McCallda65ea82010-07-13 20:32:21 +0000182 /// anonymous namespace.
John McCall1f0fca52010-07-21 07:22:38 +0000183 class Cleanup {
John McCallc4a1a842011-07-12 00:15:30 +0000184 // Anchor the construction vtable.
185 virtual void anchor();
John McCallda65ea82010-07-13 20:32:21 +0000186 public:
John McCallc4a1a842011-07-12 00:15:30 +0000187 // Provide a virtual destructor to suppress a very common warning
188 // that unfortunately cannot be suppressed without this. Cleanups
189 // should not rely on this destructor ever being called.
190 virtual ~Cleanup() {}
John McCall3e29f962010-07-13 23:19:49 +0000191
John McCallda65ea82010-07-13 20:32:21 +0000192 /// Emit the cleanup. For normal cleanups, this is run in the
193 /// same EH context as when the cleanup was pushed, i.e. the
194 /// immediately-enclosing context of the cleanup scope. For
195 /// EH cleanups, this is run in a terminate context.
196 ///
197 // \param IsForEHCleanup true if this is for an EH cleanup, false
198 /// if for a normal cleanup.
199 virtual void Emit(CodeGenFunction &CGF, bool IsForEHCleanup) = 0;
200 };
201
John McCall150b4622011-01-26 04:00:11 +0000202 /// ConditionalCleanupN stores the saved form of its N parameters,
203 /// then restores them and performs the cleanup.
John McCall3ad32c82011-01-28 08:37:24 +0000204 template <class T, class A0>
205 class ConditionalCleanup1 : public Cleanup {
John McCall804b8072011-01-28 10:53:53 +0000206 typedef typename DominatingValue<A0>::saved_type A0_saved;
John McCall3ad32c82011-01-28 08:37:24 +0000207 A0_saved a0_saved;
208
209 void Emit(CodeGenFunction &CGF, bool IsForEHCleanup) {
John McCall804b8072011-01-28 10:53:53 +0000210 A0 a0 = DominatingValue<A0>::restore(CGF, a0_saved);
John McCallc4a1a842011-07-12 00:15:30 +0000211 T(a0).Emit(CGF, IsForEHCleanup);
John McCall3ad32c82011-01-28 08:37:24 +0000212 }
213
214 public:
215 ConditionalCleanup1(A0_saved a0)
216 : a0_saved(a0) {}
217 };
218
John McCall150b4622011-01-26 04:00:11 +0000219 template <class T, class A0, class A1>
John McCall3ad32c82011-01-28 08:37:24 +0000220 class ConditionalCleanup2 : public Cleanup {
John McCall804b8072011-01-28 10:53:53 +0000221 typedef typename DominatingValue<A0>::saved_type A0_saved;
222 typedef typename DominatingValue<A1>::saved_type A1_saved;
John McCall4bbcbda2011-01-26 19:15:39 +0000223 A0_saved a0_saved;
224 A1_saved a1_saved;
John McCall150b4622011-01-26 04:00:11 +0000225
John McCall3ad32c82011-01-28 08:37:24 +0000226 void Emit(CodeGenFunction &CGF, bool IsForEHCleanup) {
John McCall804b8072011-01-28 10:53:53 +0000227 A0 a0 = DominatingValue<A0>::restore(CGF, a0_saved);
228 A1 a1 = DominatingValue<A1>::restore(CGF, a1_saved);
John McCallc4a1a842011-07-12 00:15:30 +0000229 T(a0, a1).Emit(CGF, IsForEHCleanup);
John McCall150b4622011-01-26 04:00:11 +0000230 }
231
232 public:
John McCall3ad32c82011-01-28 08:37:24 +0000233 ConditionalCleanup2(A0_saved a0, A1_saved a1)
234 : a0_saved(a0), a1_saved(a1) {}
John McCall150b4622011-01-26 04:00:11 +0000235 };
236
Douglas Gregord7b23162011-06-22 16:12:01 +0000237 template <class T, class A0, class A1, class A2>
238 class ConditionalCleanup3 : public Cleanup {
239 typedef typename DominatingValue<A0>::saved_type A0_saved;
240 typedef typename DominatingValue<A1>::saved_type A1_saved;
241 typedef typename DominatingValue<A2>::saved_type A2_saved;
242 A0_saved a0_saved;
243 A1_saved a1_saved;
244 A2_saved a2_saved;
245
246 void Emit(CodeGenFunction &CGF, bool IsForEHCleanup) {
247 A0 a0 = DominatingValue<A0>::restore(CGF, a0_saved);
248 A1 a1 = DominatingValue<A1>::restore(CGF, a1_saved);
249 A2 a2 = DominatingValue<A2>::restore(CGF, a2_saved);
John McCallc4a1a842011-07-12 00:15:30 +0000250 T(a0, a1, a2).Emit(CGF, IsForEHCleanup);
Douglas Gregord7b23162011-06-22 16:12:01 +0000251 }
252
253 public:
254 ConditionalCleanup3(A0_saved a0, A1_saved a1, A2_saved a2)
John McCallc4a1a842011-07-12 00:15:30 +0000255 : a0_saved(a0), a1_saved(a1), a2_saved(a2) {}
Douglas Gregord7b23162011-06-22 16:12:01 +0000256 };
257
John McCallf1549f62010-07-06 01:34:17 +0000258private:
259 // The implementation for this class is in CGException.h and
260 // CGException.cpp; the definition is here because it's used as a
261 // member of CodeGenFunction.
262
263 /// The start of the scope-stack buffer, i.e. the allocated pointer
264 /// for the buffer. All of these pointers are either simultaneously
265 /// null or simultaneously valid.
266 char *StartOfBuffer;
267
268 /// The end of the buffer.
269 char *EndOfBuffer;
270
271 /// The first valid entry in the buffer.
272 char *StartOfData;
273
274 /// The innermost normal cleanup on the stack.
275 stable_iterator InnermostNormalCleanup;
276
277 /// The innermost EH cleanup on the stack.
278 stable_iterator InnermostEHCleanup;
279
280 /// The number of catches on the stack.
281 unsigned CatchDepth;
282
John McCallff8e1152010-07-23 21:56:41 +0000283 /// The current EH destination index. Reset to FirstCatchIndex
284 /// whenever the last EH cleanup is popped.
285 unsigned NextEHDestIndex;
286 enum { FirstEHDestIndex = 1 };
287
John McCallf1549f62010-07-06 01:34:17 +0000288 /// The current set of branch fixups. A branch fixup is a jump to
289 /// an as-yet unemitted label, i.e. a label for which we don't yet
290 /// know the EH stack depth. Whenever we pop a cleanup, we have
291 /// to thread all the current branch fixups through it.
292 ///
293 /// Fixups are recorded as the Use of the respective branch or
294 /// switch statement. The use points to the final destination.
295 /// When popping out of a cleanup, these uses are threaded through
296 /// the cleanup and adjusted to point to the new cleanup.
297 ///
298 /// Note that branches are allowed to jump into protected scopes
299 /// in certain situations; e.g. the following code is legal:
300 /// struct A { ~A(); }; // trivial ctor, non-trivial dtor
301 /// goto foo;
302 /// A a;
303 /// foo:
304 /// bar();
305 llvm::SmallVector<BranchFixup, 8> BranchFixups;
306
307 char *allocate(size_t Size);
308
John McCall1f0fca52010-07-21 07:22:38 +0000309 void *pushCleanup(CleanupKind K, size_t DataSize);
John McCallda65ea82010-07-13 20:32:21 +0000310
John McCallf1549f62010-07-06 01:34:17 +0000311public:
312 EHScopeStack() : StartOfBuffer(0), EndOfBuffer(0), StartOfData(0),
313 InnermostNormalCleanup(stable_end()),
314 InnermostEHCleanup(stable_end()),
John McCallff8e1152010-07-23 21:56:41 +0000315 CatchDepth(0), NextEHDestIndex(FirstEHDestIndex) {}
John McCallf1549f62010-07-06 01:34:17 +0000316 ~EHScopeStack() { delete[] StartOfBuffer; }
317
John McCallda65ea82010-07-13 20:32:21 +0000318 // Variadic templates would make this not terrible.
319
320 /// Push a lazily-created cleanup on the stack.
John McCall8e3f8612010-07-13 22:12:14 +0000321 template <class T>
John McCall1f0fca52010-07-21 07:22:38 +0000322 void pushCleanup(CleanupKind Kind) {
323 void *Buffer = pushCleanup(Kind, sizeof(T));
324 Cleanup *Obj = new(Buffer) T();
John McCall8e3f8612010-07-13 22:12:14 +0000325 (void) Obj;
326 }
327
328 /// Push a lazily-created cleanup on the stack.
329 template <class T, class A0>
John McCall1f0fca52010-07-21 07:22:38 +0000330 void pushCleanup(CleanupKind Kind, A0 a0) {
331 void *Buffer = pushCleanup(Kind, sizeof(T));
332 Cleanup *Obj = new(Buffer) T(a0);
John McCall8e3f8612010-07-13 22:12:14 +0000333 (void) Obj;
334 }
335
336 /// Push a lazily-created cleanup on the stack.
John McCallda65ea82010-07-13 20:32:21 +0000337 template <class T, class A0, class A1>
John McCall1f0fca52010-07-21 07:22:38 +0000338 void pushCleanup(CleanupKind Kind, A0 a0, A1 a1) {
339 void *Buffer = pushCleanup(Kind, sizeof(T));
340 Cleanup *Obj = new(Buffer) T(a0, a1);
John McCallda65ea82010-07-13 20:32:21 +0000341 (void) Obj;
342 }
343
344 /// Push a lazily-created cleanup on the stack.
345 template <class T, class A0, class A1, class A2>
John McCall1f0fca52010-07-21 07:22:38 +0000346 void pushCleanup(CleanupKind Kind, A0 a0, A1 a1, A2 a2) {
347 void *Buffer = pushCleanup(Kind, sizeof(T));
348 Cleanup *Obj = new(Buffer) T(a0, a1, a2);
John McCallda65ea82010-07-13 20:32:21 +0000349 (void) Obj;
350 }
351
352 /// Push a lazily-created cleanup on the stack.
353 template <class T, class A0, class A1, class A2, class A3>
John McCall1f0fca52010-07-21 07:22:38 +0000354 void pushCleanup(CleanupKind Kind, A0 a0, A1 a1, A2 a2, A3 a3) {
355 void *Buffer = pushCleanup(Kind, sizeof(T));
356 Cleanup *Obj = new(Buffer) T(a0, a1, a2, a3);
John McCallda65ea82010-07-13 20:32:21 +0000357 (void) Obj;
358 }
359
John McCall77199712010-07-21 05:47:49 +0000360 /// Push a lazily-created cleanup on the stack.
361 template <class T, class A0, class A1, class A2, class A3, class A4>
John McCall1f0fca52010-07-21 07:22:38 +0000362 void pushCleanup(CleanupKind Kind, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
363 void *Buffer = pushCleanup(Kind, sizeof(T));
364 Cleanup *Obj = new(Buffer) T(a0, a1, a2, a3, a4);
John McCall77199712010-07-21 05:47:49 +0000365 (void) Obj;
366 }
367
John McCall7d8647f2010-09-14 07:57:04 +0000368 // Feel free to add more variants of the following:
369
370 /// Push a cleanup with non-constant storage requirements on the
371 /// stack. The cleanup type must provide an additional static method:
372 /// static size_t getExtraSize(size_t);
373 /// The argument to this method will be the value N, which will also
374 /// be passed as the first argument to the constructor.
375 ///
376 /// The data stored in the extra storage must obey the same
377 /// restrictions as normal cleanup member data.
378 ///
379 /// The pointer returned from this method is valid until the cleanup
380 /// stack is modified.
381 template <class T, class A0, class A1, class A2>
382 T *pushCleanupWithExtra(CleanupKind Kind, size_t N, A0 a0, A1 a1, A2 a2) {
383 void *Buffer = pushCleanup(Kind, sizeof(T) + T::getExtraSize(N));
384 return new (Buffer) T(N, a0, a1, a2);
385 }
386
John McCallf1549f62010-07-06 01:34:17 +0000387 /// Pops a cleanup scope off the stack. This should only be called
388 /// by CodeGenFunction::PopCleanupBlock.
389 void popCleanup();
390
391 /// Push a set of catch handlers on the stack. The catch is
392 /// uninitialized and will need to have the given number of handlers
393 /// set on it.
394 class EHCatchScope *pushCatch(unsigned NumHandlers);
395
396 /// Pops a catch scope off the stack.
397 void popCatch();
398
399 /// Push an exceptions filter on the stack.
400 class EHFilterScope *pushFilter(unsigned NumFilters);
401
402 /// Pops an exceptions filter off the stack.
403 void popFilter();
404
405 /// Push a terminate handler on the stack.
406 void pushTerminate();
407
408 /// Pops a terminate handler off the stack.
409 void popTerminate();
410
411 /// Determines whether the exception-scopes stack is empty.
412 bool empty() const { return StartOfData == EndOfBuffer; }
413
414 bool requiresLandingPad() const {
415 return (CatchDepth || hasEHCleanups());
416 }
417
418 /// Determines whether there are any normal cleanups on the stack.
419 bool hasNormalCleanups() const {
420 return InnermostNormalCleanup != stable_end();
421 }
422
423 /// Returns the innermost normal cleanup on the stack, or
424 /// stable_end() if there are no normal cleanups.
425 stable_iterator getInnermostNormalCleanup() const {
426 return InnermostNormalCleanup;
427 }
John McCall838d7962010-08-14 07:46:19 +0000428 stable_iterator getInnermostActiveNormalCleanup() const; // CGException.h
John McCallf1549f62010-07-06 01:34:17 +0000429
430 /// Determines whether there are any EH cleanups on the stack.
431 bool hasEHCleanups() const {
432 return InnermostEHCleanup != stable_end();
433 }
434
435 /// Returns the innermost EH cleanup on the stack, or stable_end()
436 /// if there are no EH cleanups.
437 stable_iterator getInnermostEHCleanup() const {
438 return InnermostEHCleanup;
439 }
John McCall838d7962010-08-14 07:46:19 +0000440 stable_iterator getInnermostActiveEHCleanup() const; // CGException.h
John McCallf1549f62010-07-06 01:34:17 +0000441
442 /// An unstable reference to a scope-stack depth. Invalidated by
443 /// pushes but not pops.
444 class iterator;
445
446 /// Returns an iterator pointing to the innermost EH scope.
447 iterator begin() const;
448
449 /// Returns an iterator pointing to the outermost EH scope.
450 iterator end() const;
451
452 /// Create a stable reference to the top of the EH stack. The
453 /// returned reference is valid until that scope is popped off the
454 /// stack.
455 stable_iterator stable_begin() const {
456 return stable_iterator(EndOfBuffer - StartOfData);
457 }
458
459 /// Create a stable reference to the bottom of the EH stack.
460 static stable_iterator stable_end() {
461 return stable_iterator(0);
462 }
463
464 /// Translates an iterator into a stable_iterator.
465 stable_iterator stabilize(iterator it) const;
466
467 /// Finds the nearest cleanup enclosing the given iterator.
468 /// Returns stable_iterator::invalid() if there are no such cleanups.
469 stable_iterator getEnclosingEHCleanup(iterator it) const;
470
471 /// Turn a stable reference to a scope depth into a unstable pointer
472 /// to the EH stack.
473 iterator find(stable_iterator save) const;
474
475 /// Removes the cleanup pointed to by the given stable_iterator.
476 void removeCleanup(stable_iterator save);
477
478 /// Add a branch fixup to the current cleanup scope.
479 BranchFixup &addBranchFixup() {
480 assert(hasNormalCleanups() && "adding fixup in scope without cleanups");
481 BranchFixups.push_back(BranchFixup());
482 return BranchFixups.back();
483 }
484
485 unsigned getNumBranchFixups() const { return BranchFixups.size(); }
486 BranchFixup &getBranchFixup(unsigned I) {
487 assert(I < getNumBranchFixups());
488 return BranchFixups[I];
489 }
490
John McCallff8e1152010-07-23 21:56:41 +0000491 /// Pops lazily-removed fixups from the end of the list. This
492 /// should only be called by procedures which have just popped a
493 /// cleanup or resolved one or more fixups.
494 void popNullFixups();
495
496 /// Clears the branch-fixups list. This should only be called by
John McCall8abdbd82010-09-18 02:24:39 +0000497 /// ResolveAllBranchFixups.
John McCallff8e1152010-07-23 21:56:41 +0000498 void clearFixups() { BranchFixups.clear(); }
499
500 /// Gets the next EH destination index.
501 unsigned getNextEHDestIndex() { return NextEHDestIndex++; }
John McCallf1549f62010-07-06 01:34:17 +0000502};
503
Reid Spencer5f016e22007-07-11 17:01:13 +0000504/// CodeGenFunction - This class organizes the per-function state that is used
505/// while generating LLVM code.
John McCall5936e332011-02-15 09:22:45 +0000506class CodeGenFunction : public CodeGenTypeCache {
Anders Carlsson8a219ce2009-02-24 04:21:31 +0000507 CodeGenFunction(const CodeGenFunction&); // DO NOT IMPLEMENT
508 void operator=(const CodeGenFunction&); // DO NOT IMPLEMENT
John McCall4c40d982010-08-31 07:33:07 +0000509
510 friend class CGCXXABI;
Chris Lattnerbfc0c1a2007-08-26 23:13:56 +0000511public:
John McCallff8e1152010-07-23 21:56:41 +0000512 /// A jump destination is an abstract label, branching to which may
513 /// require a jump out through normal cleanups.
John McCallf1549f62010-07-06 01:34:17 +0000514 struct JumpDest {
John McCallff8e1152010-07-23 21:56:41 +0000515 JumpDest() : Block(0), ScopeDepth(), Index(0) {}
516 JumpDest(llvm::BasicBlock *Block,
517 EHScopeStack::stable_iterator Depth,
518 unsigned Index)
519 : Block(Block), ScopeDepth(Depth), Index(Index) {}
520
521 bool isValid() const { return Block != 0; }
522 llvm::BasicBlock *getBlock() const { return Block; }
523 EHScopeStack::stable_iterator getScopeDepth() const { return ScopeDepth; }
524 unsigned getDestIndex() const { return Index; }
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000525
John McCallff8e1152010-07-23 21:56:41 +0000526 private:
John McCallf1549f62010-07-06 01:34:17 +0000527 llvm::BasicBlock *Block;
528 EHScopeStack::stable_iterator ScopeDepth;
John McCallff8e1152010-07-23 21:56:41 +0000529 unsigned Index;
530 };
531
532 /// An unwind destination is an abstract label, branching to which
533 /// may require a jump out through EH cleanups.
534 struct UnwindDest {
535 UnwindDest() : Block(0), ScopeDepth(), Index(0) {}
536 UnwindDest(llvm::BasicBlock *Block,
537 EHScopeStack::stable_iterator Depth,
538 unsigned Index)
539 : Block(Block), ScopeDepth(Depth), Index(Index) {}
540
541 bool isValid() const { return Block != 0; }
542 llvm::BasicBlock *getBlock() const { return Block; }
543 EHScopeStack::stable_iterator getScopeDepth() const { return ScopeDepth; }
544 unsigned getDestIndex() const { return Index; }
545
546 private:
547 llvm::BasicBlock *Block;
548 EHScopeStack::stable_iterator ScopeDepth;
549 unsigned Index;
John McCallf1549f62010-07-06 01:34:17 +0000550 };
551
Reid Spencer5f016e22007-07-11 17:01:13 +0000552 CodeGenModule &CGM; // Per-module state.
Daniel Dunbar444be732009-11-13 05:51:54 +0000553 const TargetInfo &Target;
Mike Stump0dd9e882009-02-08 23:14:22 +0000554
Chris Lattner58dee102007-08-21 16:57:55 +0000555 typedef std::pair<llvm::Value *, llvm::Value *> ComplexPairTy;
Daniel Dunbar45d196b2008-11-01 01:53:16 +0000556 CGBuilderTy Builder;
Mike Stump0dd9e882009-02-08 23:14:22 +0000557
Chris Lattnerb5437d22009-04-23 05:30:27 +0000558 /// CurFuncDecl - Holds the Decl for the current function or ObjC method.
559 /// This excludes BlockDecls.
Chris Lattner41110242008-06-17 18:05:57 +0000560 const Decl *CurFuncDecl;
Chris Lattnerb5437d22009-04-23 05:30:27 +0000561 /// CurCodeDecl - This is the inner-most code context, which includes blocks.
562 const Decl *CurCodeDecl;
Daniel Dunbar88b53962009-02-02 22:03:45 +0000563 const CGFunctionInfo *CurFnInfo;
Chris Lattner391d77a2008-03-30 23:03:07 +0000564 QualType FnRetTy;
Reid Spencer5f016e22007-07-11 17:01:13 +0000565 llvm::Function *CurFn;
566
Mike Stump6a1e0eb2009-12-04 23:26:17 +0000567 /// CurGD - The GlobalDecl for the current function being compiled.
568 GlobalDecl CurGD;
Mike Stump6a1e0eb2009-12-04 23:26:17 +0000569
John McCallf85e1932011-06-15 23:02:42 +0000570 /// PrologueCleanupDepth - The cleanup depth enclosing all the
571 /// cleanups associated with the parameters.
572 EHScopeStack::stable_iterator PrologueCleanupDepth;
573
Daniel Dunbar5ca20842008-09-09 21:00:17 +0000574 /// ReturnBlock - Unified return block.
John McCallf1549f62010-07-06 01:34:17 +0000575 JumpDest ReturnBlock;
576
Mike Stump0dd9e882009-02-08 23:14:22 +0000577 /// ReturnValue - The temporary alloca to hold the return value. This is null
578 /// iff the function has no return value.
Eli Friedmanb17daf92009-12-04 02:43:40 +0000579 llvm::Value *ReturnValue;
Mike Stump0dd9e882009-02-08 23:14:22 +0000580
John McCallff8e1152010-07-23 21:56:41 +0000581 /// RethrowBlock - Unified rethrow block.
582 UnwindDest RethrowBlock;
583
Reid Spencer5f016e22007-07-11 17:01:13 +0000584 /// AllocaInsertPoint - This is an instruction in the entry block before which
585 /// we prefer to insert allocas.
Chris Lattner481769b2009-03-31 22:17:44 +0000586 llvm::AssertingVH<llvm::Instruction> AllocaInsertPt;
Daniel Dunbar0ffb1252008-08-04 16:51:22 +0000587
Mike Stump9c276ae2009-12-12 01:27:46 +0000588 bool CatchUndefined;
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000589
John McCallf85e1932011-06-15 23:02:42 +0000590 /// In ARC, whether we should autorelease the return value.
591 bool AutoreleaseResult;
592
John McCalld16c2cf2011-02-08 08:22:06 +0000593 const CodeGen::CGBlockInfo *BlockInfo;
594 llvm::Value *BlockPointer;
595
Douglas Gregor3d91bbc2010-05-17 15:52:46 +0000596 /// \brief A mapping from NRVO variables to the flags used to indicate
597 /// when the NRVO has been applied to this variable.
598 llvm::DenseMap<const VarDecl *, llvm::Value *> NRVOFlags;
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000599
John McCallf1549f62010-07-06 01:34:17 +0000600 EHScopeStack EHStack;
601
John McCallff8e1152010-07-23 21:56:41 +0000602 /// i32s containing the indexes of the cleanup destinations.
603 llvm::AllocaInst *NormalCleanupDest;
604 llvm::AllocaInst *EHCleanupDest;
605
606 unsigned NextCleanupDestIndex;
607
John McCallf1549f62010-07-06 01:34:17 +0000608 /// The exception slot. All landing pads write the current
609 /// exception pointer into this alloca.
610 llvm::Value *ExceptionSlot;
611
John McCall93c332a2011-05-28 21:13:02 +0000612 /// The selector slot. Under the MandatoryCleanup model, all
613 /// landing pads write the current selector value into this alloca.
614 llvm::AllocaInst *EHSelectorSlot;
615
John McCallf1549f62010-07-06 01:34:17 +0000616 /// Emits a landing pad for the current EH stack.
617 llvm::BasicBlock *EmitLandingPad();
618
619 llvm::BasicBlock *getInvokeDestImpl();
620
John McCall3ad32c82011-01-28 08:37:24 +0000621 /// Set up the last cleaup that was pushed as a conditional
622 /// full-expression cleanup.
623 void initFullExprCleanup();
John McCall150b4622011-01-26 04:00:11 +0000624
625 template <class T>
John McCall804b8072011-01-28 10:53:53 +0000626 typename DominatingValue<T>::saved_type saveValueInCond(T value) {
627 return DominatingValue<T>::save(*this, value);
John McCall150b4622011-01-26 04:00:11 +0000628 }
629
Daniel Dunbar18ccc772008-09-28 01:03:14 +0000630public:
Anders Carlssonfa1f7562009-02-10 06:07:49 +0000631 /// ObjCEHValueStack - Stack of Objective-C exception values, used for
632 /// rethrows.
Anders Carlsson273558f2009-02-07 21:37:21 +0000633 llvm::SmallVector<llvm::Value*, 8> ObjCEHValueStack;
Mike Stump0dd9e882009-02-08 23:14:22 +0000634
John McCalld768e9d2011-06-22 02:32:12 +0000635 /// A class controlling the emission of a finally block.
636 class FinallyInfo {
637 /// Where the catchall's edge through the cleanup should go.
638 JumpDest RethrowDest;
Anders Carlssonbb66f9f2009-02-08 07:46:24 +0000639
John McCalld768e9d2011-06-22 02:32:12 +0000640 /// A function to call to enter the catch.
641 llvm::Constant *BeginCatchFn;
642
643 /// An i1 variable indicating whether or not the @finally is
644 /// running for an exception.
645 llvm::AllocaInst *ForEHVar;
646
647 /// An i8* variable into which the exception pointer to rethrow
648 /// has been saved.
649 llvm::AllocaInst *SavedExnVar;
650
651 public:
652 void enter(CodeGenFunction &CGF, const Stmt *Finally,
653 llvm::Constant *beginCatchFn, llvm::Constant *endCatchFn,
654 llvm::Constant *rethrowFn);
655 void exit(CodeGenFunction &CGF);
656 };
Mike Stumpd88ea562009-12-09 03:35:49 +0000657
John McCall150b4622011-01-26 04:00:11 +0000658 /// pushFullExprCleanup - Push a cleanup to be run at the end of the
659 /// current full-expression. Safe against the possibility that
660 /// we're currently inside a conditionally-evaluated expression.
John McCall3ad32c82011-01-28 08:37:24 +0000661 template <class T, class A0>
662 void pushFullExprCleanup(CleanupKind kind, A0 a0) {
663 // If we're not in a conditional branch, or if none of the
664 // arguments requires saving, then use the unconditional cleanup.
John McCallc4a1a842011-07-12 00:15:30 +0000665 if (!isInConditionalBranch())
666 return EHStack.pushCleanup<T>(kind, a0);
John McCall3ad32c82011-01-28 08:37:24 +0000667
John McCall804b8072011-01-28 10:53:53 +0000668 typename DominatingValue<A0>::saved_type a0_saved = saveValueInCond(a0);
John McCall3ad32c82011-01-28 08:37:24 +0000669
670 typedef EHScopeStack::ConditionalCleanup1<T, A0> CleanupType;
671 EHStack.pushCleanup<CleanupType>(kind, a0_saved);
672 initFullExprCleanup();
673 }
674
675 /// pushFullExprCleanup - Push a cleanup to be run at the end of the
676 /// current full-expression. Safe against the possibility that
677 /// we're currently inside a conditionally-evaluated expression.
John McCall150b4622011-01-26 04:00:11 +0000678 template <class T, class A0, class A1>
679 void pushFullExprCleanup(CleanupKind kind, A0 a0, A1 a1) {
680 // If we're not in a conditional branch, or if none of the
681 // arguments requires saving, then use the unconditional cleanup.
John McCallc4a1a842011-07-12 00:15:30 +0000682 if (!isInConditionalBranch())
683 return EHStack.pushCleanup<T>(kind, a0, a1);
John McCall150b4622011-01-26 04:00:11 +0000684
John McCall804b8072011-01-28 10:53:53 +0000685 typename DominatingValue<A0>::saved_type a0_saved = saveValueInCond(a0);
686 typename DominatingValue<A1>::saved_type a1_saved = saveValueInCond(a1);
John McCall150b4622011-01-26 04:00:11 +0000687
688 typedef EHScopeStack::ConditionalCleanup2<T, A0, A1> CleanupType;
John McCall3ad32c82011-01-28 08:37:24 +0000689 EHStack.pushCleanup<CleanupType>(kind, a0_saved, a1_saved);
690 initFullExprCleanup();
John McCall150b4622011-01-26 04:00:11 +0000691 }
692
Douglas Gregord7b23162011-06-22 16:12:01 +0000693 /// pushFullExprCleanup - Push a cleanup to be run at the end of the
694 /// current full-expression. Safe against the possibility that
695 /// we're currently inside a conditionally-evaluated expression.
696 template <class T, class A0, class A1, class A2>
697 void pushFullExprCleanup(CleanupKind kind, A0 a0, A1 a1, A2 a2) {
698 // If we're not in a conditional branch, or if none of the
699 // arguments requires saving, then use the unconditional cleanup.
700 if (!isInConditionalBranch()) {
John McCallc4a1a842011-07-12 00:15:30 +0000701 return EHStack.pushCleanup<T>(kind, a0, a1, a2);
Douglas Gregord7b23162011-06-22 16:12:01 +0000702 }
703
704 typename DominatingValue<A0>::saved_type a0_saved = saveValueInCond(a0);
705 typename DominatingValue<A1>::saved_type a1_saved = saveValueInCond(a1);
706 typename DominatingValue<A2>::saved_type a2_saved = saveValueInCond(a2);
707
708 typedef EHScopeStack::ConditionalCleanup3<T, A0, A1, A2> CleanupType;
709 EHStack.pushCleanup<CleanupType>(kind, a0_saved, a1_saved, a2_saved);
710 initFullExprCleanup();
711 }
712
John McCallf1549f62010-07-06 01:34:17 +0000713 /// PushDestructorCleanup - Push a cleanup to call the
714 /// complete-object destructor of an object of the given type at the
715 /// given address. Does nothing if T is not a C++ class type with a
716 /// non-trivial destructor.
717 void PushDestructorCleanup(QualType T, llvm::Value *Addr);
718
John McCall81407d42010-07-21 06:29:51 +0000719 /// PushDestructorCleanup - Push a cleanup to call the
720 /// complete-object variant of the given destructor on the object at
721 /// the given address.
722 void PushDestructorCleanup(const CXXDestructorDecl *Dtor,
723 llvm::Value *Addr);
724
John McCallf1549f62010-07-06 01:34:17 +0000725 /// PopCleanupBlock - Will pop the cleanup entry on the stack and
726 /// process all branch fixups.
John McCallff8e1152010-07-23 21:56:41 +0000727 void PopCleanupBlock(bool FallThroughIsBranchThrough = false);
John McCallf1549f62010-07-06 01:34:17 +0000728
John McCall7d8647f2010-09-14 07:57:04 +0000729 /// DeactivateCleanupBlock - Deactivates the given cleanup block.
730 /// The block cannot be reactivated. Pops it if it's the top of the
731 /// stack.
732 void DeactivateCleanupBlock(EHScopeStack::stable_iterator Cleanup);
733
734 /// ActivateCleanupBlock - Activates an initially-inactive cleanup.
735 /// Cannot be used to resurrect a deactivated cleanup.
736 void ActivateCleanupBlock(EHScopeStack::stable_iterator Cleanup);
John McCallcd2d2b72010-08-13 21:20:51 +0000737
John McCallf1549f62010-07-06 01:34:17 +0000738 /// \brief Enters a new scope for capturing cleanups, all of which
739 /// will be executed once the scope is exited.
740 class RunCleanupsScope {
Douglas Gregor01234bb2009-11-24 16:43:22 +0000741 CodeGenFunction& CGF;
John McCallf1549f62010-07-06 01:34:17 +0000742 EHScopeStack::stable_iterator CleanupStackDepth;
Douglas Gregor01234bb2009-11-24 16:43:22 +0000743 bool OldDidCallStackSave;
Douglas Gregor5656e142009-11-24 21:15:44 +0000744 bool PerformCleanup;
Douglas Gregor01234bb2009-11-24 16:43:22 +0000745
John McCallf1549f62010-07-06 01:34:17 +0000746 RunCleanupsScope(const RunCleanupsScope &); // DO NOT IMPLEMENT
747 RunCleanupsScope &operator=(const RunCleanupsScope &); // DO NOT IMPLEMENT
Douglas Gregor01234bb2009-11-24 16:43:22 +0000748
749 public:
750 /// \brief Enter a new cleanup scope.
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000751 explicit RunCleanupsScope(CodeGenFunction &CGF)
752 : CGF(CGF), PerformCleanup(true)
Douglas Gregor5656e142009-11-24 21:15:44 +0000753 {
John McCallf1549f62010-07-06 01:34:17 +0000754 CleanupStackDepth = CGF.EHStack.stable_begin();
Douglas Gregor01234bb2009-11-24 16:43:22 +0000755 OldDidCallStackSave = CGF.DidCallStackSave;
Argyrios Kyrtzidis4ada2ca2010-09-14 00:42:34 +0000756 CGF.DidCallStackSave = false;
Douglas Gregor01234bb2009-11-24 16:43:22 +0000757 }
758
759 /// \brief Exit this cleanup scope, emitting any accumulated
760 /// cleanups.
John McCallf1549f62010-07-06 01:34:17 +0000761 ~RunCleanupsScope() {
Douglas Gregor5656e142009-11-24 21:15:44 +0000762 if (PerformCleanup) {
763 CGF.DidCallStackSave = OldDidCallStackSave;
John McCallf1549f62010-07-06 01:34:17 +0000764 CGF.PopCleanupBlocks(CleanupStackDepth);
Douglas Gregor5656e142009-11-24 21:15:44 +0000765 }
766 }
767
768 /// \brief Determine whether this scope requires any cleanups.
769 bool requiresCleanups() const {
John McCallf1549f62010-07-06 01:34:17 +0000770 return CGF.EHStack.stable_begin() != CleanupStackDepth;
Douglas Gregor5656e142009-11-24 21:15:44 +0000771 }
772
773 /// \brief Force the emission of cleanups now, instead of waiting
774 /// until this object is destroyed.
775 void ForceCleanup() {
776 assert(PerformCleanup && "Already forced cleanup");
Douglas Gregor01234bb2009-11-24 16:43:22 +0000777 CGF.DidCallStackSave = OldDidCallStackSave;
John McCallf1549f62010-07-06 01:34:17 +0000778 CGF.PopCleanupBlocks(CleanupStackDepth);
Douglas Gregor5656e142009-11-24 21:15:44 +0000779 PerformCleanup = false;
Douglas Gregor01234bb2009-11-24 16:43:22 +0000780 }
781 };
782
Anders Carlsson44ec82b2010-03-30 03:14:41 +0000783
John McCallf1549f62010-07-06 01:34:17 +0000784 /// PopCleanupBlocks - Takes the old cleanup stack size and emits
785 /// the cleanup blocks that have been added.
786 void PopCleanupBlocks(EHScopeStack::stable_iterator OldCleanupStackSize);
Anders Carlsson44ec82b2010-03-30 03:14:41 +0000787
John McCallff8e1152010-07-23 21:56:41 +0000788 void ResolveBranchFixups(llvm::BasicBlock *Target);
789
John McCallf1549f62010-07-06 01:34:17 +0000790 /// The given basic block lies in the current EH scope, but may be a
791 /// target of a potentially scope-crossing jump; get a stable handle
792 /// to which we can perform this jump later.
John McCallff8e1152010-07-23 21:56:41 +0000793 JumpDest getJumpDestInCurrentScope(llvm::BasicBlock *Target) {
John McCall413e6772010-07-28 01:07:35 +0000794 return JumpDest(Target,
795 EHStack.getInnermostNormalCleanup(),
796 NextCleanupDestIndex++);
John McCallf1549f62010-07-06 01:34:17 +0000797 }
Anders Carlssonc71c8452009-02-07 23:50:39 +0000798
John McCallf1549f62010-07-06 01:34:17 +0000799 /// The given basic block lies in the current EH scope, but may be a
800 /// target of a potentially scope-crossing jump; get a stable handle
801 /// to which we can perform this jump later.
Chris Lattnerad8dcf42011-02-17 07:39:24 +0000802 JumpDest getJumpDestInCurrentScope(llvm::StringRef Name = llvm::StringRef()) {
John McCallff8e1152010-07-23 21:56:41 +0000803 return getJumpDestInCurrentScope(createBasicBlock(Name));
John McCallf1549f62010-07-06 01:34:17 +0000804 }
805
806 /// EmitBranchThroughCleanup - Emit a branch from the current insert
807 /// block through the normal cleanup handling code (if any) and then
808 /// on to \arg Dest.
809 void EmitBranchThroughCleanup(JumpDest Dest);
Chris Lattnerb11f9192011-04-17 00:54:30 +0000810
811 /// isObviouslyBranchWithoutCleanups - Return true if a branch to the
812 /// specified destination obviously has no cleanups to run. 'false' is always
813 /// a conservatively correct answer for this method.
814 bool isObviouslyBranchWithoutCleanups(JumpDest Dest) const;
John McCallf1549f62010-07-06 01:34:17 +0000815
816 /// EmitBranchThroughEHCleanup - Emit a branch from the current
817 /// insert block through the EH cleanup handling code (if any) and
818 /// then on to \arg Dest.
John McCallff8e1152010-07-23 21:56:41 +0000819 void EmitBranchThroughEHCleanup(UnwindDest Dest);
820
821 /// getRethrowDest - Returns the unified outermost-scope rethrow
822 /// destination.
823 UnwindDest getRethrowDest();
Mike Stump0dd9e882009-02-08 23:14:22 +0000824
John McCall150b4622011-01-26 04:00:11 +0000825 /// An object to manage conditionally-evaluated expressions.
826 class ConditionalEvaluation {
827 llvm::BasicBlock *StartBB;
Mike Stump1eb44332009-09-09 15:08:12 +0000828
John McCall150b4622011-01-26 04:00:11 +0000829 public:
830 ConditionalEvaluation(CodeGenFunction &CGF)
831 : StartBB(CGF.Builder.GetInsertBlock()) {}
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000832
John McCall150b4622011-01-26 04:00:11 +0000833 void begin(CodeGenFunction &CGF) {
834 assert(CGF.OutermostConditional != this);
835 if (!CGF.OutermostConditional)
836 CGF.OutermostConditional = this;
837 }
838
839 void end(CodeGenFunction &CGF) {
840 assert(CGF.OutermostConditional != 0);
841 if (CGF.OutermostConditional == this)
842 CGF.OutermostConditional = 0;
843 }
844
845 /// Returns a block which will be executed prior to each
846 /// evaluation of the conditional code.
847 llvm::BasicBlock *getStartingBlock() const {
848 return StartBB;
849 }
850 };
Mike Stump1eb44332009-09-09 15:08:12 +0000851
John McCall3019c442010-09-17 00:50:28 +0000852 /// isInConditionalBranch - Return true if we're currently emitting
853 /// one branch or the other of a conditional expression.
John McCall150b4622011-01-26 04:00:11 +0000854 bool isInConditionalBranch() const { return OutermostConditional != 0; }
855
856 /// An RAII object to record that we're evaluating a statement
857 /// expression.
858 class StmtExprEvaluation {
859 CodeGenFunction &CGF;
860
861 /// We have to save the outermost conditional: cleanups in a
862 /// statement expression aren't conditional just because the
863 /// StmtExpr is.
864 ConditionalEvaluation *SavedOutermostConditional;
865
866 public:
867 StmtExprEvaluation(CodeGenFunction &CGF)
868 : CGF(CGF), SavedOutermostConditional(CGF.OutermostConditional) {
869 CGF.OutermostConditional = 0;
870 }
871
872 ~StmtExprEvaluation() {
873 CGF.OutermostConditional = SavedOutermostConditional;
874 CGF.EnsureInsertPoint();
875 }
876 };
John McCalle996ffd2011-02-16 08:02:54 +0000877
John McCall56ca35d2011-02-17 10:25:35 +0000878 /// An object which temporarily prevents a value from being
879 /// destroyed by aggressive peephole optimizations that assume that
880 /// all uses of a value have been realized in the IR.
881 class PeepholeProtection {
882 llvm::Instruction *Inst;
883 friend class CodeGenFunction;
884
885 public:
886 PeepholeProtection() : Inst(0) {}
887 };
888
John McCalle996ffd2011-02-16 08:02:54 +0000889 /// An RAII object to set (and then clear) a mapping for an OpaqueValueExpr.
890 class OpaqueValueMapping {
891 CodeGenFunction &CGF;
892 const OpaqueValueExpr *OpaqueValue;
John McCall56ca35d2011-02-17 10:25:35 +0000893 bool BoundLValue;
894 CodeGenFunction::PeepholeProtection Protection;
John McCalle996ffd2011-02-16 08:02:54 +0000895
896 public:
John McCall56ca35d2011-02-17 10:25:35 +0000897 static bool shouldBindAsLValue(const Expr *expr) {
898 return expr->isGLValue() || expr->getType()->isRecordType();
899 }
900
901 /// Build the opaque value mapping for the given conditional
902 /// operator if it's the GNU ?: extension. This is a common
903 /// enough pattern that the convenience operator is really
904 /// helpful.
905 ///
906 OpaqueValueMapping(CodeGenFunction &CGF,
907 const AbstractConditionalOperator *op) : CGF(CGF) {
908 if (isa<ConditionalOperator>(op)) {
909 OpaqueValue = 0;
910 BoundLValue = false;
911 return;
912 }
913
914 const BinaryConditionalOperator *e = cast<BinaryConditionalOperator>(op);
915 init(e->getOpaqueValue(), e->getCommon());
916 }
917
John McCalle996ffd2011-02-16 08:02:54 +0000918 OpaqueValueMapping(CodeGenFunction &CGF,
919 const OpaqueValueExpr *opaqueValue,
John McCall56ca35d2011-02-17 10:25:35 +0000920 LValue lvalue)
921 : CGF(CGF), OpaqueValue(opaqueValue), BoundLValue(true) {
John McCalle996ffd2011-02-16 08:02:54 +0000922 assert(opaqueValue && "no opaque value expression!");
John McCall56ca35d2011-02-17 10:25:35 +0000923 assert(shouldBindAsLValue(opaqueValue));
924 initLValue(lvalue);
925 }
926
927 OpaqueValueMapping(CodeGenFunction &CGF,
928 const OpaqueValueExpr *opaqueValue,
929 RValue rvalue)
930 : CGF(CGF), OpaqueValue(opaqueValue), BoundLValue(false) {
931 assert(opaqueValue && "no opaque value expression!");
932 assert(!shouldBindAsLValue(opaqueValue));
933 initRValue(rvalue);
John McCalle996ffd2011-02-16 08:02:54 +0000934 }
935
936 void pop() {
937 assert(OpaqueValue && "mapping already popped!");
John McCall56ca35d2011-02-17 10:25:35 +0000938 popImpl();
John McCalle996ffd2011-02-16 08:02:54 +0000939 OpaqueValue = 0;
940 }
941
942 ~OpaqueValueMapping() {
John McCall56ca35d2011-02-17 10:25:35 +0000943 if (OpaqueValue) popImpl();
944 }
945
946 private:
947 void popImpl() {
948 if (BoundLValue)
949 CGF.OpaqueLValues.erase(OpaqueValue);
950 else {
951 CGF.OpaqueRValues.erase(OpaqueValue);
952 CGF.unprotectFromPeepholes(Protection);
953 }
954 }
955
956 void init(const OpaqueValueExpr *ov, const Expr *e) {
957 OpaqueValue = ov;
958 BoundLValue = shouldBindAsLValue(ov);
959 assert(BoundLValue == shouldBindAsLValue(e)
960 && "inconsistent expression value kinds!");
961 if (BoundLValue)
962 initLValue(CGF.EmitLValue(e));
963 else
964 initRValue(CGF.EmitAnyExpr(e));
965 }
966
967 void initLValue(const LValue &lv) {
968 CGF.OpaqueLValues.insert(std::make_pair(OpaqueValue, lv));
969 }
970
971 void initRValue(const RValue &rv) {
972 // Work around an extremely aggressive peephole optimization in
973 // EmitScalarConversion which assumes that all other uses of a
974 // value are extant.
975 Protection = CGF.protectFromPeepholes(rv);
976 CGF.OpaqueRValues.insert(std::make_pair(OpaqueValue, rv));
John McCalle996ffd2011-02-16 08:02:54 +0000977 }
978 };
Fariborz Jahaniane2204552010-11-16 19:29:39 +0000979
980 /// getByrefValueFieldNumber - Given a declaration, returns the LLVM field
981 /// number that holds the value.
982 unsigned getByRefValueLLVMField(const ValueDecl *VD) const;
Fariborz Jahanian52a80e12011-01-26 23:08:27 +0000983
984 /// BuildBlockByrefAddress - Computes address location of the
985 /// variable which is declared as __block.
986 llvm::Value *BuildBlockByrefAddress(llvm::Value *BaseAddr,
987 const VarDecl *V);
Chris Lattner7f02f722007-08-24 05:35:26 +0000988private:
Chris Lattnerd9becd12009-10-28 23:59:40 +0000989 CGDebugInfo *DebugInfo;
Devang Patelaa112892011-03-07 18:45:56 +0000990 bool DisableDebugInfo;
Mike Stump09429b92009-02-17 17:00:02 +0000991
John McCall93c332a2011-05-28 21:13:02 +0000992 /// DidCallStackSave - Whether llvm.stacksave has been called. Used to avoid
993 /// calling llvm.stacksave for multiple VLAs in the same scope.
994 bool DidCallStackSave;
995
Mike Stumpf71d2322009-11-30 20:08:49 +0000996 /// IndirectBranch - The first time an indirect goto is seen we create a block
997 /// with an indirect branch. Every time we see the address of a label taken,
998 /// we add the label to the indirect goto. Every subsequent indirect goto is
999 /// codegen'd as a jump to the IndirectBranch's basic block.
Chris Lattnerd9becd12009-10-28 23:59:40 +00001000 llvm::IndirectBrInst *IndirectBranch;
Daniel Dunbar0ffb1252008-08-04 16:51:22 +00001001
Mike Stump0dd9e882009-02-08 23:14:22 +00001002 /// LocalDeclMap - This keeps track of the LLVM allocas or globals for local C
1003 /// decls.
John McCall6b5a61b2011-02-07 10:33:21 +00001004 typedef llvm::DenseMap<const Decl*, llvm::Value*> DeclMapTy;
1005 DeclMapTy LocalDeclMap;
Reid Spencer5f016e22007-07-11 17:01:13 +00001006
1007 /// LabelMap - This keeps track of the LLVM basic block for each C label.
Chris Lattnerad8dcf42011-02-17 07:39:24 +00001008 llvm::DenseMap<const LabelDecl*, JumpDest> LabelMap;
Mike Stump0dd9e882009-02-08 23:14:22 +00001009
Mike Stump0dd9e882009-02-08 23:14:22 +00001010 // BreakContinueStack - This keeps track of where break and continue
Anders Carlssone4b6d342009-02-10 05:52:02 +00001011 // statements should jump to.
Chris Lattnerda138702007-07-16 21:28:45 +00001012 struct BreakContinue {
John McCallf1549f62010-07-06 01:34:17 +00001013 BreakContinue(JumpDest Break, JumpDest Continue)
1014 : BreakBlock(Break), ContinueBlock(Continue) {}
Mike Stump0dd9e882009-02-08 23:14:22 +00001015
John McCallf1549f62010-07-06 01:34:17 +00001016 JumpDest BreakBlock;
1017 JumpDest ContinueBlock;
Mike Stump0dd9e882009-02-08 23:14:22 +00001018 };
Chris Lattnerda138702007-07-16 21:28:45 +00001019 llvm::SmallVector<BreakContinue, 8> BreakContinueStack;
Daniel Dunbar18ccc772008-09-28 01:03:14 +00001020
Mike Stump0dd9e882009-02-08 23:14:22 +00001021 /// SwitchInsn - This is nearest current switch instruction. It is null if if
1022 /// current context is not in a switch.
Devang Patel51b09f22007-10-04 23:45:31 +00001023 llvm::SwitchInst *SwitchInsn;
1024
Mike Stump0dd9e882009-02-08 23:14:22 +00001025 /// CaseRangeBlock - This block holds if condition check for last case
Devang Patel80fd5f92007-10-09 17:08:50 +00001026 /// statement range in current switch instruction.
Devang Patelc049e4f2007-10-08 20:57:48 +00001027 llvm::BasicBlock *CaseRangeBlock;
1028
John McCall56ca35d2011-02-17 10:25:35 +00001029 /// OpaqueLValues - Keeps track of the current set of opaque value
John McCalle996ffd2011-02-16 08:02:54 +00001030 /// expressions.
John McCall56ca35d2011-02-17 10:25:35 +00001031 llvm::DenseMap<const OpaqueValueExpr *, LValue> OpaqueLValues;
1032 llvm::DenseMap<const OpaqueValueExpr *, RValue> OpaqueRValues;
John McCalle996ffd2011-02-16 08:02:54 +00001033
Mike Stump0dd9e882009-02-08 23:14:22 +00001034 // VLASizeMap - This keeps track of the associated size for each VLA type.
Eli Friedmanbbed6b92009-08-15 02:50:32 +00001035 // We track this by the size expression rather than the type itself because
1036 // in certain situations, like a const qualifier applied to an VLA typedef,
1037 // multiple VLA types can share the same size expression.
Mike Stump0dd9e882009-02-08 23:14:22 +00001038 // FIXME: Maybe this could be a stack of maps that is pushed/popped as we
1039 // enter/leave scopes.
Eli Friedmanbbed6b92009-08-15 02:50:32 +00001040 llvm::DenseMap<const Expr*, llvm::Value*> VLASizeMap;
Mike Stump0dd9e882009-02-08 23:14:22 +00001041
John McCallf1549f62010-07-06 01:34:17 +00001042 /// A block containing a single 'unreachable' instruction. Created
1043 /// lazily by getUnreachableBlock().
1044 llvm::BasicBlock *UnreachableBlock;
Mike Stump0dd9e882009-02-08 23:14:22 +00001045
Anders Carlssonf6c56e22009-11-25 03:15:49 +00001046 /// CXXThisDecl - When generating code for a C++ member function,
1047 /// this will hold the implicit 'this' declaration.
Anders Carlsson2b77ba82009-04-04 20:47:02 +00001048 ImplicitParamDecl *CXXThisDecl;
John McCall25049412010-02-16 22:04:33 +00001049 llvm::Value *CXXThisValue;
Mike Stump1eb44332009-09-09 15:08:12 +00001050
Anders Carlssonf6c56e22009-11-25 03:15:49 +00001051 /// CXXVTTDecl - When generating code for a base object constructor or
1052 /// base object destructor with virtual bases, this will hold the implicit
1053 /// VTT parameter.
1054 ImplicitParamDecl *CXXVTTDecl;
John McCall25049412010-02-16 22:04:33 +00001055 llvm::Value *CXXVTTValue;
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001056
John McCall150b4622011-01-26 04:00:11 +00001057 /// OutermostConditional - Points to the outermost active
1058 /// conditional control. This is used so that we know if a
1059 /// temporary should be destroyed conditionally.
1060 ConditionalEvaluation *OutermostConditional;
Mike Stump1eb44332009-09-09 15:08:12 +00001061
Anders Carlsson7dfa4072009-09-12 02:14:24 +00001062
1063 /// ByrefValueInfoMap - For each __block variable, contains a pair of the LLVM
1064 /// type as well as the field number that contains the actual data.
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001065 llvm::DenseMap<const ValueDecl *, std::pair<const llvm::Type *,
Anders Carlsson7dfa4072009-09-12 02:14:24 +00001066 unsigned> > ByRefValueInfo;
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001067
John McCallf1549f62010-07-06 01:34:17 +00001068 llvm::BasicBlock *TerminateLandingPad;
Mike Stump182f3832009-12-10 00:02:42 +00001069 llvm::BasicBlock *TerminateHandler;
Chris Lattner83252dc2010-07-20 21:07:09 +00001070 llvm::BasicBlock *TrapBB;
Eli Friedman94067052009-12-10 02:21:21 +00001071
Reid Spencer5f016e22007-07-11 17:01:13 +00001072public:
1073 CodeGenFunction(CodeGenModule &cgm);
Mike Stump0dd9e882009-02-08 23:14:22 +00001074
John McCall1e7fe752010-09-02 09:58:18 +00001075 CodeGenTypes &getTypes() const { return CGM.getTypes(); }
John McCallf2aac842011-05-15 02:34:36 +00001076 ASTContext &getContext() const { return CGM.getContext(); }
Devang Patelaa112892011-03-07 18:45:56 +00001077 CGDebugInfo *getDebugInfo() {
1078 if (DisableDebugInfo)
1079 return NULL;
1080 return DebugInfo;
1081 }
1082 void disableDebugInfo() { DisableDebugInfo = true; }
1083 void enableDebugInfo() { DisableDebugInfo = false; }
1084
John McCallf85e1932011-06-15 23:02:42 +00001085 bool shouldUseFusedARCCalls() {
1086 return CGM.getCodeGenOpts().OptimizationLevel == 0;
1087 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001088
John McCalld16c2cf2011-02-08 08:22:06 +00001089 const LangOptions &getLangOptions() const { return CGM.getLangOptions(); }
1090
John McCallf1549f62010-07-06 01:34:17 +00001091 /// Returns a pointer to the function's exception object slot, which
1092 /// is assigned in every landing pad.
1093 llvm::Value *getExceptionSlot();
John McCall93c332a2011-05-28 21:13:02 +00001094 llvm::Value *getEHSelectorSlot();
John McCallf1549f62010-07-06 01:34:17 +00001095
John McCallff8e1152010-07-23 21:56:41 +00001096 llvm::Value *getNormalCleanupDestSlot();
1097 llvm::Value *getEHCleanupDestSlot();
1098
John McCallf1549f62010-07-06 01:34:17 +00001099 llvm::BasicBlock *getUnreachableBlock() {
1100 if (!UnreachableBlock) {
1101 UnreachableBlock = createBasicBlock("unreachable");
1102 new llvm::UnreachableInst(getLLVMContext(), UnreachableBlock);
1103 }
1104 return UnreachableBlock;
1105 }
1106
1107 llvm::BasicBlock *getInvokeDest() {
1108 if (!EHStack.requiresLandingPad()) return 0;
1109 return getInvokeDestImpl();
1110 }
Daniel Dunbar9834ffb2009-02-23 17:26:39 +00001111
John McCalld16c2cf2011-02-08 08:22:06 +00001112 llvm::LLVMContext &getLLVMContext() { return CGM.getLLVMContext(); }
Owen Anderson69243822009-07-13 04:10:07 +00001113
Daniel Dunbar9834ffb2009-02-23 17:26:39 +00001114 //===--------------------------------------------------------------------===//
John McCallbdc4d802011-07-09 01:37:26 +00001115 // Cleanups
1116 //===--------------------------------------------------------------------===//
1117
1118 typedef void Destroyer(CodeGenFunction &CGF, llvm::Value *addr, QualType ty);
1119
John McCall2673c682011-07-11 08:38:19 +00001120 void pushIrregularPartialArrayCleanup(llvm::Value *arrayBegin,
1121 llvm::Value *arrayEndPointer,
1122 QualType elementType,
1123 Destroyer &destroyer);
1124 void pushRegularPartialArrayCleanup(llvm::Value *arrayBegin,
1125 llvm::Value *arrayEnd,
1126 QualType elementType,
1127 Destroyer &destroyer);
John McCallbdc4d802011-07-09 01:37:26 +00001128
1129 Destroyer &getDestroyer(QualType::DestructionKind destructionKind);
1130 void pushDestroy(CleanupKind kind, llvm::Value *addr, QualType type,
John McCall2673c682011-07-11 08:38:19 +00001131 Destroyer &destroyer, bool useEHCleanupForArray);
1132 void emitDestroy(llvm::Value *addr, QualType type, Destroyer &destroyer,
1133 bool useEHCleanupForArray);
John McCallbdc4d802011-07-09 01:37:26 +00001134 void emitArrayDestroy(llvm::Value *begin, llvm::Value *end,
John McCall2673c682011-07-11 08:38:19 +00001135 QualType type, Destroyer &destroyer,
1136 bool useEHCleanup);
John McCallbdc4d802011-07-09 01:37:26 +00001137
1138 /// Determines whether an EH cleanup is required to destroy a type
1139 /// with the given destruction kind.
1140 bool needsEHCleanup(QualType::DestructionKind kind) {
1141 switch (kind) {
1142 case QualType::DK_none:
1143 return false;
1144 case QualType::DK_cxx_destructor:
1145 case QualType::DK_objc_weak_lifetime:
1146 return getLangOptions().Exceptions;
1147 case QualType::DK_objc_strong_lifetime:
1148 return getLangOptions().Exceptions &&
1149 CGM.getCodeGenOpts().ObjCAutoRefCountExceptions;
1150 }
1151 llvm_unreachable("bad destruction kind");
1152 }
1153
1154 //===--------------------------------------------------------------------===//
Daniel Dunbar9834ffb2009-02-23 17:26:39 +00001155 // Objective-C
1156 //===--------------------------------------------------------------------===//
1157
Chris Lattner391d77a2008-03-30 23:03:07 +00001158 void GenerateObjCMethod(const ObjCMethodDecl *OMD);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00001159
Mike Stump0dd9e882009-02-08 23:14:22 +00001160 void StartObjCMethod(const ObjCMethodDecl *MD,
Devang Patel8d3f8972011-05-19 23:37:41 +00001161 const ObjCContainerDecl *CD,
1162 SourceLocation StartLoc);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00001163
Mike Stump0dd9e882009-02-08 23:14:22 +00001164 /// GenerateObjCGetter - Synthesize an Objective-C property getter function.
Fariborz Jahanianfef30b52008-12-09 20:23:04 +00001165 void GenerateObjCGetter(ObjCImplementationDecl *IMP,
1166 const ObjCPropertyImplDecl *PID);
Fariborz Jahanian2846b972011-02-18 19:15:13 +00001167 void GenerateObjCGetterBody(ObjCIvarDecl *Ivar, bool IsAtomic, bool IsStrong);
1168 void GenerateObjCAtomicSetterBody(ObjCMethodDecl *OMD,
1169 ObjCIvarDecl *Ivar);
1170
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00001171 void GenerateObjCCtorDtorMethod(ObjCImplementationDecl *IMP,
1172 ObjCMethodDecl *MD, bool ctor);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00001173
Mike Stump0dd9e882009-02-08 23:14:22 +00001174 /// GenerateObjCSetter - Synthesize an Objective-C property setter function
1175 /// for the given property.
Fariborz Jahanianfef30b52008-12-09 20:23:04 +00001176 void GenerateObjCSetter(ObjCImplementationDecl *IMP,
1177 const ObjCPropertyImplDecl *PID);
Fariborz Jahanian0b2bd472010-04-13 00:38:05 +00001178 bool IndirectObjCSetterArg(const CGFunctionInfo &FI);
Fariborz Jahanian15bd5882010-04-13 18:32:24 +00001179 bool IvarTypeWithAggrGCObjects(QualType Ty);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00001180
Mike Stump4e7a1f72009-02-21 20:00:35 +00001181 //===--------------------------------------------------------------------===//
1182 // Block Bits
1183 //===--------------------------------------------------------------------===//
1184
John McCall6b5a61b2011-02-07 10:33:21 +00001185 llvm::Value *EmitBlockLiteral(const BlockExpr *);
Blaine Garst2a7eb282010-02-23 21:51:17 +00001186 llvm::Constant *BuildDescriptorBlockDecl(const BlockExpr *,
Fariborz Jahanian89ecd412010-08-04 16:57:49 +00001187 const CGBlockInfo &Info,
Mike Stump08920992009-03-07 02:35:30 +00001188 const llvm::StructType *,
John McCalld16c2cf2011-02-08 08:22:06 +00001189 llvm::Constant *BlockVarLayout);
Mike Stump4e7a1f72009-02-21 20:00:35 +00001190
Fariborz Jahanian564360b2010-06-24 00:08:06 +00001191 llvm::Function *GenerateBlockFunction(GlobalDecl GD,
John McCall6b5a61b2011-02-07 10:33:21 +00001192 const CGBlockInfo &Info,
Mike Stump6cc88f72009-03-20 21:53:12 +00001193 const Decl *OuterFuncDecl,
John McCall6b5a61b2011-02-07 10:33:21 +00001194 const DeclMapTy &ldm);
Mike Stump4e7a1f72009-02-21 20:00:35 +00001195
John McCalld16c2cf2011-02-08 08:22:06 +00001196 llvm::Constant *GenerateCopyHelperFunction(const CGBlockInfo &blockInfo);
1197 llvm::Constant *GenerateDestroyHelperFunction(const CGBlockInfo &blockInfo);
1198
John McCalld16c2cf2011-02-08 08:22:06 +00001199 void BuildBlockRelease(llvm::Value *DeclPtr, BlockFieldFlags flags);
1200
John McCall5af02db2011-03-31 01:59:53 +00001201 class AutoVarEmission;
1202
1203 void emitByrefStructureInit(const AutoVarEmission &emission);
1204 void enterByrefCleanup(const AutoVarEmission &emission);
1205
John McCall6b5a61b2011-02-07 10:33:21 +00001206 llvm::Value *LoadBlockStruct() {
1207 assert(BlockPointer && "no block pointer set!");
1208 return BlockPointer;
1209 }
Mike Stump4e7a1f72009-02-21 20:00:35 +00001210
John McCallea1471e2010-05-20 01:18:31 +00001211 void AllocateBlockCXXThisPointer(const CXXThisExpr *E);
1212 void AllocateBlockDecl(const BlockDeclRefExpr *E);
John McCallee504292010-05-21 04:11:14 +00001213 llvm::Value *GetAddrOfBlockDecl(const BlockDeclRefExpr *E) {
1214 return GetAddrOfBlockDecl(E->getDecl(), E->isByRef());
1215 }
John McCall6b5a61b2011-02-07 10:33:21 +00001216 llvm::Value *GetAddrOfBlockDecl(const VarDecl *var, bool ByRef);
1217 const llvm::Type *BuildByRefType(const VarDecl *var);
Mike Stumpdab514f2009-03-04 03:23:46 +00001218
John McCalld26bc762011-03-09 04:27:21 +00001219 void GenerateCode(GlobalDecl GD, llvm::Function *Fn,
1220 const CGFunctionInfo &FnInfo);
Anders Carlsson0ff8baf2009-09-11 00:07:24 +00001221 void StartFunction(GlobalDecl GD, QualType RetTy,
Daniel Dunbar7c086512008-09-09 23:14:03 +00001222 llvm::Function *Fn,
John McCalld26bc762011-03-09 04:27:21 +00001223 const CGFunctionInfo &FnInfo,
Daniel Dunbar2284ac92008-10-18 18:22:23 +00001224 const FunctionArgList &Args,
Tilmann Scheller9c6082f2011-03-02 21:36:49 +00001225 SourceLocation StartLoc);
Daniel Dunbara448fb22008-11-11 23:11:34 +00001226
John McCall9fc6a772010-02-19 09:25:03 +00001227 void EmitConstructorBody(FunctionArgList &Args);
1228 void EmitDestructorBody(FunctionArgList &Args);
1229 void EmitFunctionBody(FunctionArgList &Args);
John McCalla355e072010-02-18 03:17:58 +00001230
Mike Stump0dd9e882009-02-08 23:14:22 +00001231 /// EmitReturnBlock - Emit the unified return block, trying to avoid its
1232 /// emission when possible.
Daniel Dunbar1c1d6072009-01-26 23:27:52 +00001233 void EmitReturnBlock();
1234
Mike Stump0dd9e882009-02-08 23:14:22 +00001235 /// FinishFunction - Complete IR generation of the current function. It is
1236 /// legal to call this function even if there is no current insertion point.
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00001237 void FinishFunction(SourceLocation EndLoc=SourceLocation());
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001238
Anders Carlsson519c3282010-03-24 00:39:18 +00001239 /// GenerateThunk - Generate a thunk for the given method.
John McCalld26bc762011-03-09 04:27:21 +00001240 void GenerateThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo,
1241 GlobalDecl GD, const ThunkInfo &Thunk);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001242
Eli Friedman7dcdf5b2011-05-06 17:27:27 +00001243 void GenerateVarArgsThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo,
1244 GlobalDecl GD, const ThunkInfo &Thunk);
1245
Douglas Gregorfb8cc252010-05-05 05:51:00 +00001246 void EmitCtorPrologue(const CXXConstructorDecl *CD, CXXCtorType Type,
1247 FunctionArgList &Args);
Mike Stump1eb44332009-09-09 15:08:12 +00001248
Anders Carlssond103f9f2010-03-28 19:40:00 +00001249 /// InitializeVTablePointer - Initialize the vtable pointer of the given
1250 /// subobject.
1251 ///
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001252 void InitializeVTablePointer(BaseSubobject Base,
Anders Carlssonb3b772e2010-04-20 05:22:15 +00001253 const CXXRecordDecl *NearestVBase,
Ken Dyckd6fb21f2011-03-23 01:04:18 +00001254 CharUnits OffsetFromNearestVBase,
Anders Carlssond103f9f2010-03-28 19:40:00 +00001255 llvm::Constant *VTable,
1256 const CXXRecordDecl *VTableClass);
1257
1258 typedef llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBasesSetTy;
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001259 void InitializeVTablePointers(BaseSubobject Base,
Anders Carlssonb3b772e2010-04-20 05:22:15 +00001260 const CXXRecordDecl *NearestVBase,
Ken Dyckd6fb21f2011-03-23 01:04:18 +00001261 CharUnits OffsetFromNearestVBase,
Anders Carlsson603d6d12010-03-28 21:07:49 +00001262 bool BaseIsNonVirtualPrimaryBase,
1263 llvm::Constant *VTable,
1264 const CXXRecordDecl *VTableClass,
1265 VisitedVirtualBasesSetTy& VBases);
Eli Friedman77a259c2009-12-08 06:46:18 +00001266
Anders Carlsson603d6d12010-03-28 21:07:49 +00001267 void InitializeVTablePointers(const CXXRecordDecl *ClassDecl);
Anders Carlssond103f9f2010-03-28 19:40:00 +00001268
Dan Gohman043fb9a2010-10-26 18:44:08 +00001269 /// GetVTablePtr - Return the Value of the vtable pointer member pointed
1270 /// to by This.
1271 llvm::Value *GetVTablePtr(llvm::Value *This, const llvm::Type *Ty);
Anders Carlssond103f9f2010-03-28 19:40:00 +00001272
John McCall50da2ca2010-07-21 05:30:47 +00001273 /// EnterDtorCleanups - Enter the cleanups necessary to complete the
1274 /// given phase of destruction for a destructor. The end result
1275 /// should call destructors on members and base classes in reverse
1276 /// order of their construction.
1277 void EnterDtorCleanups(const CXXDestructorDecl *Dtor, CXXDtorType Type);
Mike Stump1eb44332009-09-09 15:08:12 +00001278
Chris Lattner7255a2d2010-06-22 00:03:40 +00001279 /// ShouldInstrumentFunction - Return true if the current function should be
1280 /// instrumented with __cyg_profile_func_* calls
1281 bool ShouldInstrumentFunction();
1282
1283 /// EmitFunctionInstrumentation - Emit LLVM code to call the specified
1284 /// instrumentation function with the current function and the call site, if
1285 /// function instrumentation is enabled.
1286 void EmitFunctionInstrumentation(const char *Fn);
1287
Roman Divackybe4c8702011-02-10 16:52:03 +00001288 /// EmitMCountInstrumentation - Emit call to .mcount.
1289 void EmitMCountInstrumentation();
1290
Mike Stump0dd9e882009-02-08 23:14:22 +00001291 /// EmitFunctionProlog - Emit the target specific LLVM code to load the
1292 /// arguments for the given function. This is also responsible for naming the
1293 /// LLVM function arguments.
Daniel Dunbar88b53962009-02-02 22:03:45 +00001294 void EmitFunctionProlog(const CGFunctionInfo &FI,
1295 llvm::Function *Fn,
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001296 const FunctionArgList &Args);
1297
Mike Stump0dd9e882009-02-08 23:14:22 +00001298 /// EmitFunctionEpilog - Emit the target specific LLVM code to return the
1299 /// given temporary.
Chris Lattner35b21b82010-06-27 01:06:27 +00001300 void EmitFunctionEpilog(const CGFunctionInfo &FI);
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001301
Mike Stumpcce3d4f2009-12-07 23:38:24 +00001302 /// EmitStartEHSpec - Emit the start of the exception spec.
1303 void EmitStartEHSpec(const Decl *D);
1304
1305 /// EmitEndEHSpec - Emit the end of the exception spec.
1306 void EmitEndEHSpec(const Decl *D);
1307
John McCallf1549f62010-07-06 01:34:17 +00001308 /// getTerminateLandingPad - Return a landing pad that just calls terminate.
1309 llvm::BasicBlock *getTerminateLandingPad();
1310
1311 /// getTerminateHandler - Return a handler (not a landing pad, just
1312 /// a catch handler) that just calls terminate. This is used when
1313 /// a terminate scope encloses a try.
Mike Stump9b39c512009-12-09 22:59:31 +00001314 llvm::BasicBlock *getTerminateHandler();
1315
Chris Lattner9cbe4f02011-07-09 17:41:47 +00001316 llvm::Type *ConvertTypeForMem(QualType T);
1317 llvm::Type *ConvertType(QualType T);
1318 llvm::Type *ConvertType(const TypeDecl *T) {
John McCallbff225e2010-02-16 04:15:37 +00001319 return ConvertType(getContext().getTypeDeclType(T));
1320 }
Chris Lattnerc8aa5f12008-04-04 04:07:35 +00001321
Mike Stump0dd9e882009-02-08 23:14:22 +00001322 /// LoadObjCSelf - Load the value of self. This function is only valid while
1323 /// generating code for an Objective-C method.
Chris Lattnerc8aa5f12008-04-04 04:07:35 +00001324 llvm::Value *LoadObjCSelf();
Mike Stump0dd9e882009-02-08 23:14:22 +00001325
1326 /// TypeOfSelfObject - Return type of object that this self represents.
Fariborz Jahanian45012a72009-02-03 00:09:52 +00001327 QualType TypeOfSelfObject();
Chris Lattner41110242008-06-17 18:05:57 +00001328
Reid Spencer5f016e22007-07-11 17:01:13 +00001329 /// hasAggregateLLVMType - Return true if the specified AST type will map into
1330 /// an aggregate LLVM type or is void.
1331 static bool hasAggregateLLVMType(QualType T);
Daniel Dunbar55e87422008-11-11 02:29:29 +00001332
1333 /// createBasicBlock - Create an LLVM basic block.
John McCalld16c2cf2011-02-08 08:22:06 +00001334 llvm::BasicBlock *createBasicBlock(llvm::StringRef name = "",
1335 llvm::Function *parent = 0,
1336 llvm::BasicBlock *before = 0) {
Daniel Dunbar29ea6722008-11-12 00:01:12 +00001337#ifdef NDEBUG
John McCalld16c2cf2011-02-08 08:22:06 +00001338 return llvm::BasicBlock::Create(getLLVMContext(), "", parent, before);
Daniel Dunbar29ea6722008-11-12 00:01:12 +00001339#else
John McCalld16c2cf2011-02-08 08:22:06 +00001340 return llvm::BasicBlock::Create(getLLVMContext(), name, parent, before);
Daniel Dunbar29ea6722008-11-12 00:01:12 +00001341#endif
Daniel Dunbar55e87422008-11-11 02:29:29 +00001342 }
Mike Stump0dd9e882009-02-08 23:14:22 +00001343
Reid Spencer5f016e22007-07-11 17:01:13 +00001344 /// getBasicBlockForLabel - Return the LLVM basicblock that the specified
1345 /// label maps to.
Chris Lattnerad8dcf42011-02-17 07:39:24 +00001346 JumpDest getJumpDestForLabel(const LabelDecl *S);
Mike Stump0dd9e882009-02-08 23:14:22 +00001347
Mike Stumpf71d2322009-11-30 20:08:49 +00001348 /// SimplifyForwardingBlocks - If the given basic block is only a branch to
1349 /// another basic block, simplify it. This assumes that no other code could
1350 /// potentially reference the basic block.
Daniel Dunbaraa5bd872009-04-01 04:37:47 +00001351 void SimplifyForwardingBlocks(llvm::BasicBlock *BB);
1352
Mike Stump0dd9e882009-02-08 23:14:22 +00001353 /// EmitBlock - Emit the given block \arg BB and set it as the insert point,
1354 /// adding a fall-through branch from the current insert block if
1355 /// necessary. It is legal to call this function even if there is no current
1356 /// insertion point.
Daniel Dunbara0c21a82008-11-13 01:24:05 +00001357 ///
Mike Stump0dd9e882009-02-08 23:14:22 +00001358 /// IsFinished - If true, indicates that the caller has finished emitting
1359 /// branches to the given block and does not expect to emit code into it. This
1360 /// means the block can be ignored if it is unreachable.
Daniel Dunbara0c21a82008-11-13 01:24:05 +00001361 void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false);
Daniel Dunbar824e3bd2008-11-11 04:34:23 +00001362
Mike Stump0dd9e882009-02-08 23:14:22 +00001363 /// EmitBranch - Emit a branch to the specified basic block from the current
1364 /// insert block, taking care to avoid creation of branches from dummy
1365 /// blocks. It is legal to call this function even if there is no current
1366 /// insertion point.
Daniel Dunbar5e08ad32008-11-11 22:06:59 +00001367 ///
Mike Stump0dd9e882009-02-08 23:14:22 +00001368 /// This function clears the current insertion point. The caller should follow
1369 /// calls to this function with calls to Emit*Block prior to generation new
1370 /// code.
Daniel Dunbard57a8712008-11-11 09:41:28 +00001371 void EmitBranch(llvm::BasicBlock *Block);
1372
Mike Stump0dd9e882009-02-08 23:14:22 +00001373 /// HaveInsertPoint - True if an insertion point is defined. If not, this
1374 /// indicates that the current code being emitted is unreachable.
1375 bool HaveInsertPoint() const {
Daniel Dunbara448fb22008-11-11 23:11:34 +00001376 return Builder.GetInsertBlock() != 0;
1377 }
1378
Mike Stump0dd9e882009-02-08 23:14:22 +00001379 /// EnsureInsertPoint - Ensure that an insertion point is defined so that
1380 /// emitted IR has a place to go. Note that by definition, if this function
1381 /// creates a block then that block is unreachable; callers may do better to
1382 /// detect when no insertion point is defined and simply skip IR generation.
Daniel Dunbara448fb22008-11-11 23:11:34 +00001383 void EnsureInsertPoint() {
1384 if (!HaveInsertPoint())
1385 EmitBlock(createBasicBlock());
1386 }
Mike Stump0dd9e882009-02-08 23:14:22 +00001387
Daniel Dunbar488e9932008-08-16 00:56:44 +00001388 /// ErrorUnsupported - Print out an error that codegen doesn't support the
Chris Lattnerdc5e8262007-12-02 01:43:38 +00001389 /// specified stmt yet.
Daniel Dunbar90df4b62008-09-04 03:43:08 +00001390 void ErrorUnsupported(const Stmt *S, const char *Type,
1391 bool OmitOnError=false);
Reid Spencer5f016e22007-07-11 17:01:13 +00001392
1393 //===--------------------------------------------------------------------===//
1394 // Helpers
1395 //===--------------------------------------------------------------------===//
Mike Stump0dd9e882009-02-08 23:14:22 +00001396
Daniel Dunbar983e3d72010-08-21 04:20:22 +00001397 LValue MakeAddrLValue(llvm::Value *V, QualType T, unsigned Alignment = 0) {
Dan Gohman3d5aff52010-10-14 23:06:10 +00001398 return LValue::MakeAddr(V, T, Alignment, getContext(),
1399 CGM.getTBAAInfo(T));
Daniel Dunbar5cf8bfe2010-08-21 02:53:44 +00001400 }
1401
Reid Spencer5f016e22007-07-11 17:01:13 +00001402 /// CreateTempAlloca - This creates a alloca and inserts it into the entry
Daniel Dunbar195337d2010-02-09 02:48:28 +00001403 /// block. The caller is responsible for setting an appropriate alignment on
1404 /// the alloca.
Reid Spencer5f016e22007-07-11 17:01:13 +00001405 llvm::AllocaInst *CreateTempAlloca(const llvm::Type *Ty,
Daniel Dunbar259e9cc2009-10-19 01:21:05 +00001406 const llvm::Twine &Name = "tmp");
Mike Stump0dd9e882009-02-08 23:14:22 +00001407
John McCallac418162010-04-22 01:10:34 +00001408 /// InitTempAlloca - Provide an initial value for the given alloca.
1409 void InitTempAlloca(llvm::AllocaInst *Alloca, llvm::Value *Value);
1410
Daniel Dunbar9bd4da22010-02-16 19:44:13 +00001411 /// CreateIRTemp - Create a temporary IR object of the given type, with
1412 /// appropriate alignment. This routine should only be used when an temporary
1413 /// value needs to be stored into an alloca (for example, to avoid explicit
1414 /// PHI construction), but the type is the IR type, not the type appropriate
1415 /// for storing in memory.
Chris Lattner121b3fa2010-07-05 20:21:00 +00001416 llvm::AllocaInst *CreateIRTemp(QualType T, const llvm::Twine &Name = "tmp");
Daniel Dunbar9bd4da22010-02-16 19:44:13 +00001417
Daniel Dunbar195337d2010-02-09 02:48:28 +00001418 /// CreateMemTemp - Create a temporary memory object of the given type, with
1419 /// appropriate alignment.
Chris Lattner121b3fa2010-07-05 20:21:00 +00001420 llvm::AllocaInst *CreateMemTemp(QualType T, const llvm::Twine &Name = "tmp");
Daniel Dunbar195337d2010-02-09 02:48:28 +00001421
John McCall558d2ab2010-09-15 10:14:12 +00001422 /// CreateAggTemp - Create a temporary memory object for the given
1423 /// aggregate type.
1424 AggValueSlot CreateAggTemp(QualType T, const llvm::Twine &Name = "tmp") {
John McCallf85e1932011-06-15 23:02:42 +00001425 return AggValueSlot::forAddr(CreateMemTemp(T, Name), T.getQualifiers(),
1426 false);
John McCall558d2ab2010-09-15 10:14:12 +00001427 }
1428
John McCalld16c2cf2011-02-08 08:22:06 +00001429 /// Emit a cast to void* in the appropriate address space.
1430 llvm::Value *EmitCastToVoidPtr(llvm::Value *value);
1431
Reid Spencer5f016e22007-07-11 17:01:13 +00001432 /// EvaluateExprAsBool - Perform the usual unary conversions on the specified
1433 /// expression and compare the result against zero, returning an Int1Ty value.
1434 llvm::Value *EvaluateExprAsBool(const Expr *E);
1435
John McCall2a416372010-12-05 02:00:02 +00001436 /// EmitIgnoredExpr - Emit an expression in a context which ignores the result.
1437 void EmitIgnoredExpr(const Expr *E);
1438
Chris Lattner9b655512007-08-31 22:49:20 +00001439 /// EmitAnyExpr - Emit code to compute the specified expression which can have
1440 /// any type. The result is returned as an RValue struct. If this is an
1441 /// aggregate expression, the aggloc/agglocvolatile arguments indicate where
1442 /// the result should be returned.
Mike Stump49d1cd52009-05-26 22:03:21 +00001443 ///
1444 /// \param IgnoreResult - True if the resulting value isn't used.
John McCall558d2ab2010-09-15 10:14:12 +00001445 RValue EmitAnyExpr(const Expr *E,
1446 AggValueSlot AggSlot = AggValueSlot::ignored(),
1447 bool IgnoreResult = false);
Devang Pateld9363c32007-09-28 21:49:18 +00001448
Mike Stump0dd9e882009-02-08 23:14:22 +00001449 // EmitVAListRef - Emit a "reference" to a va_list; this is either the address
1450 // or the value of the expression, depending on how va_list is defined.
Eli Friedman4fd0aa52009-01-20 17:46:04 +00001451 llvm::Value *EmitVAListRef(const Expr *E);
1452
Mike Stump0dd9e882009-02-08 23:14:22 +00001453 /// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result will
1454 /// always be accessible even if no aggregate location is provided.
John McCall558d2ab2010-09-15 10:14:12 +00001455 RValue EmitAnyExprToTemp(const Expr *E);
Daniel Dunbar46f45b92008-09-09 01:06:48 +00001456
John McCall60d33652011-03-08 09:11:50 +00001457 /// EmitAnyExprToMem - Emits the code necessary to evaluate an
John McCall3d3ec1c2010-04-21 10:05:39 +00001458 /// arbitrary expression into the given memory location.
1459 void EmitAnyExprToMem(const Expr *E, llvm::Value *Location,
John McCallf85e1932011-06-15 23:02:42 +00001460 Qualifiers Quals, bool IsInitializer);
John McCall3d3ec1c2010-04-21 10:05:39 +00001461
John McCall60d33652011-03-08 09:11:50 +00001462 /// EmitExprAsInit - Emits the code necessary to initialize a
1463 /// location in memory with the given initializer.
John McCallf85e1932011-06-15 23:02:42 +00001464 void EmitExprAsInit(const Expr *init, const ValueDecl *D,
John McCalla07398e2011-06-16 04:16:24 +00001465 LValue lvalue, bool capturedByInit);
John McCall60d33652011-03-08 09:11:50 +00001466
Mike Stump27fe2e62009-05-23 22:29:41 +00001467 /// EmitAggregateCopy - Emit an aggrate copy.
1468 ///
1469 /// \param isVolatile - True iff either the source or the destination is
1470 /// volatile.
Daniel Dunbar7482d122008-09-09 20:49:46 +00001471 void EmitAggregateCopy(llvm::Value *DestPtr, llvm::Value *SrcPtr,
Mike Stump27fe2e62009-05-23 22:29:41 +00001472 QualType EltTy, bool isVolatile=false);
Daniel Dunbar7482d122008-09-09 20:49:46 +00001473
Devang Patel51b09f22007-10-04 23:45:31 +00001474 /// StartBlock - Start new block named N. If insert block is a dummy block
1475 /// then reuse it.
1476 void StartBlock(const char *N);
1477
Lauro Ramos Venancio81373352008-02-26 21:41:45 +00001478 /// GetAddrOfStaticLocalVar - Return the address of a static local variable.
John McCall4c40d982010-08-31 07:33:07 +00001479 llvm::Constant *GetAddrOfStaticLocalVar(const VarDecl *BVD) {
1480 return cast<llvm::Constant>(GetAddrOfLocalVar(BVD));
1481 }
Dan Gohman4f8d1232008-05-22 00:50:06 +00001482
Anders Carlssondde0a942008-09-11 09:15:33 +00001483 /// GetAddrOfLocalVar - Return the address of a local variable.
John McCall4c40d982010-08-31 07:33:07 +00001484 llvm::Value *GetAddrOfLocalVar(const VarDecl *VD) {
1485 llvm::Value *Res = LocalDeclMap[VD];
1486 assert(Res && "Invalid argument to GetAddrOfLocalVar(), no decl!");
1487 return Res;
1488 }
Mike Stump0dd9e882009-02-08 23:14:22 +00001489
John McCall56ca35d2011-02-17 10:25:35 +00001490 /// getOpaqueLValueMapping - Given an opaque value expression (which
1491 /// must be mapped to an l-value), return its mapping.
1492 const LValue &getOpaqueLValueMapping(const OpaqueValueExpr *e) {
1493 assert(OpaqueValueMapping::shouldBindAsLValue(e));
1494
1495 llvm::DenseMap<const OpaqueValueExpr*,LValue>::iterator
1496 it = OpaqueLValues.find(e);
1497 assert(it != OpaqueLValues.end() && "no mapping for opaque value!");
1498 return it->second;
1499 }
1500
1501 /// getOpaqueRValueMapping - Given an opaque value expression (which
1502 /// must be mapped to an r-value), return its mapping.
1503 const RValue &getOpaqueRValueMapping(const OpaqueValueExpr *e) {
1504 assert(!OpaqueValueMapping::shouldBindAsLValue(e));
1505
1506 llvm::DenseMap<const OpaqueValueExpr*,RValue>::iterator
1507 it = OpaqueRValues.find(e);
1508 assert(it != OpaqueRValues.end() && "no mapping for opaque value!");
John McCalle996ffd2011-02-16 08:02:54 +00001509 return it->second;
1510 }
1511
Dan Gohman4f8d1232008-05-22 00:50:06 +00001512 /// getAccessedFieldNo - Given an encoded value and a result number, return
1513 /// the input field number being accessed.
1514 static unsigned getAccessedFieldNo(unsigned Idx, const llvm::Constant *Elts);
1515
Chris Lattnerad8dcf42011-02-17 07:39:24 +00001516 llvm::BlockAddress *GetAddrOfLabel(const LabelDecl *L);
Chris Lattner3d00fdc2009-10-13 06:55:33 +00001517 llvm::BasicBlock *GetIndirectGotoBlock();
Daniel Dunbar0ffb1252008-08-04 16:51:22 +00001518
Anders Carlsson1884eb02010-05-22 17:35:42 +00001519 /// EmitNullInitialization - Generate code to set a value of the given type to
1520 /// null, If the type contains data member pointers, they will be initialized
1521 /// to -1 in accordance with the Itanium C++ ABI.
1522 void EmitNullInitialization(llvm::Value *DestPtr, QualType Ty);
Anders Carlssonddf7cac2008-11-04 05:30:00 +00001523
1524 // EmitVAArg - Generate code to get an argument from the passed in pointer
1525 // and update it accordingly. The return value is a pointer to the argument.
1526 // FIXME: We should be able to get rid of this method and use the va_arg
Mike Stump0dd9e882009-02-08 23:14:22 +00001527 // instruction in LLVM instead once it works well enough.
Anders Carlssonddf7cac2008-11-04 05:30:00 +00001528 llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty);
Anders Carlssonf666b772008-12-20 20:27:15 +00001529
John McCallbdc4d802011-07-09 01:37:26 +00001530 /// emitArrayLength - Compute the length of an array, even if it's a
1531 /// VLA, and drill down to the base element type.
1532 llvm::Value *emitArrayLength(const ArrayType *arrayType,
1533 QualType &baseType,
1534 llvm::Value *&addr);
1535
John McCallbc8d40d2011-06-24 21:55:10 +00001536 /// EmitVLASize - Capture all the sizes for the VLA expressions in
1537 /// the given variably-modified type and store them in the VLASizeMap.
Daniel Dunbard286f052009-07-19 06:58:07 +00001538 ///
1539 /// This function can be called with a null (unreachable) insert point.
John McCallbc8d40d2011-06-24 21:55:10 +00001540 void EmitVariablyModifiedType(QualType Ty);
Mike Stump0dd9e882009-02-08 23:14:22 +00001541
John McCallbc8d40d2011-06-24 21:55:10 +00001542 /// getVLASize - Returns an LLVM value that corresponds to the size,
1543 /// in non-variably-sized elements, of a variable length array type,
1544 /// plus that largest non-variably-sized element type. Assumes that
1545 /// the type has already been emitted with EmitVariablyModifiedType.
1546 std::pair<llvm::Value*,QualType> getVLASize(const VariableArrayType *vla);
1547 std::pair<llvm::Value*,QualType> getVLASize(QualType vla);
Anders Carlssondcc90d82008-12-12 07:19:02 +00001548
Anders Carlsson5f4307b2009-04-14 16:58:56 +00001549 /// LoadCXXThis - Load the value of 'this'. This function is only valid while
1550 /// generating code for an C++ member function.
John McCall25049412010-02-16 22:04:33 +00001551 llvm::Value *LoadCXXThis() {
1552 assert(CXXThisValue && "no 'this' value for this function");
1553 return CXXThisValue;
1554 }
Mike Stump1eb44332009-09-09 15:08:12 +00001555
Anders Carlssonc997d422010-01-02 01:01:18 +00001556 /// LoadCXXVTT - Load the VTT parameter to base constructors/destructors have
1557 /// virtual bases.
John McCall25049412010-02-16 22:04:33 +00001558 llvm::Value *LoadCXXVTT() {
1559 assert(CXXVTTValue && "no VTT value for this function");
1560 return CXXVTTValue;
1561 }
John McCallbff225e2010-02-16 04:15:37 +00001562
1563 /// GetAddressOfBaseOfCompleteClass - Convert the given pointer to a
Anders Carlsson8561a862010-04-24 23:01:49 +00001564 /// complete class to the given direct base.
1565 llvm::Value *
1566 GetAddressOfDirectBaseInCompleteClass(llvm::Value *Value,
1567 const CXXRecordDecl *Derived,
1568 const CXXRecordDecl *Base,
1569 bool BaseIsVirtual);
Anders Carlssona88ad562010-04-24 21:51:08 +00001570
Mike Stumpf71d2322009-11-30 20:08:49 +00001571 /// GetAddressOfBaseClass - This function will add the necessary delta to the
1572 /// load of 'this' and returns address of the base class.
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001573 llvm::Value *GetAddressOfBaseClass(llvm::Value *Value,
Anders Carlsson8561a862010-04-24 23:01:49 +00001574 const CXXRecordDecl *Derived,
John McCallf871d0c2010-08-07 06:22:56 +00001575 CastExpr::path_const_iterator PathBegin,
1576 CastExpr::path_const_iterator PathEnd,
Anders Carlsson34a2d382010-04-24 21:06:20 +00001577 bool NullCheckValue);
1578
Anders Carlssona3697c92009-11-23 17:57:54 +00001579 llvm::Value *GetAddressOfDerivedClass(llvm::Value *Value,
Anders Carlsson8561a862010-04-24 23:01:49 +00001580 const CXXRecordDecl *Derived,
John McCallf871d0c2010-08-07 06:22:56 +00001581 CastExpr::path_const_iterator PathBegin,
1582 CastExpr::path_const_iterator PathEnd,
Anders Carlssona3697c92009-11-23 17:57:54 +00001583 bool NullCheckValue);
1584
Anders Carlssonbb7e17b2010-01-31 01:36:53 +00001585 llvm::Value *GetVirtualBaseClassOffset(llvm::Value *This,
1586 const CXXRecordDecl *ClassDecl,
1587 const CXXRecordDecl *BaseClassDecl);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001588
John McCallc0bf4622010-02-23 00:48:20 +00001589 void EmitDelegateCXXConstructorCall(const CXXConstructorDecl *Ctor,
1590 CXXCtorType CtorType,
1591 const FunctionArgList &Args);
Sean Hunt059ce0d2011-05-01 07:04:31 +00001592 // It's important not to confuse this and the previous function. Delegating
1593 // constructors are the C++0x feature. The constructor delegate optimization
1594 // is used to reduce duplication in the base and complete consturctors where
1595 // they are substantially the same.
1596 void EmitDelegatingCXXConstructorCall(const CXXConstructorDecl *Ctor,
1597 const FunctionArgList &Args);
Anders Carlsson155ed4a2010-05-02 23:20:53 +00001598 void EmitCXXConstructorCall(const CXXConstructorDecl *D, CXXCtorType Type,
1599 bool ForVirtualBase, llvm::Value *This,
Anders Carlssonb14095a2009-04-17 00:06:03 +00001600 CallExpr::const_arg_iterator ArgBeg,
1601 CallExpr::const_arg_iterator ArgEnd);
Fariborz Jahanian34999872010-11-13 21:53:34 +00001602
1603 void EmitSynthesizedCXXCopyCtorCall(const CXXConstructorDecl *D,
1604 llvm::Value *This, llvm::Value *Src,
1605 CallExpr::const_arg_iterator ArgBeg,
1606 CallExpr::const_arg_iterator ArgEnd);
Mike Stump1eb44332009-09-09 15:08:12 +00001607
Fariborz Jahanian288dcaf2009-08-19 20:55:16 +00001608 void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D,
Anders Carlsson569c1f42009-09-23 02:45:36 +00001609 const ConstantArrayType *ArrayTy,
Anders Carlsson5d4d9462009-11-24 18:43:52 +00001610 llvm::Value *ArrayPtr,
1611 CallExpr::const_arg_iterator ArgBeg,
Douglas Gregor59174c02010-07-21 01:10:17 +00001612 CallExpr::const_arg_iterator ArgEnd,
1613 bool ZeroInitialization = false);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001614
Anders Carlsson569c1f42009-09-23 02:45:36 +00001615 void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D,
1616 llvm::Value *NumElements,
Anders Carlsson5d4d9462009-11-24 18:43:52 +00001617 llvm::Value *ArrayPtr,
1618 CallExpr::const_arg_iterator ArgBeg,
Douglas Gregor59174c02010-07-21 01:10:17 +00001619 CallExpr::const_arg_iterator ArgEnd,
1620 bool ZeroInitialization = false);
Anders Carlssonb14095a2009-04-17 00:06:03 +00001621
Fariborz Jahanianf800f6c2009-08-20 20:54:15 +00001622 void EmitCXXAggrDestructorCall(const CXXDestructorDecl *D,
1623 const ArrayType *Array,
1624 llvm::Value *This);
Mike Stump1eb44332009-09-09 15:08:12 +00001625
John McCallbdc4d802011-07-09 01:37:26 +00001626 static Destroyer destroyCXXObject;
1627
Fariborz Jahanian72c21532009-11-13 19:27:47 +00001628 void EmitCXXAggrDestructorCall(const CXXDestructorDecl *D,
1629 llvm::Value *NumElements,
1630 llvm::Value *This);
1631
Anders Carlsson02e370a2010-06-08 22:14:59 +00001632 llvm::Function *GenerateCXXAggrDestructorHelper(const CXXDestructorDecl *D,
1633 const ArrayType *Array,
1634 llvm::Value *This);
Fariborz Jahanian88f42802009-11-10 19:24:06 +00001635
Anders Carlsson7267c162009-05-29 21:03:38 +00001636 void EmitCXXDestructorCall(const CXXDestructorDecl *D, CXXDtorType Type,
Anders Carlsson8e6404c2010-05-02 23:29:11 +00001637 bool ForVirtualBase, llvm::Value *This);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001638
Fariborz Jahanianef668722010-06-25 18:26:07 +00001639 void EmitNewArrayInitializer(const CXXNewExpr *E, llvm::Value *NewPtr,
1640 llvm::Value *NumElements);
Mike Stump1eb44332009-09-09 15:08:12 +00001641
John McCallf1549f62010-07-06 01:34:17 +00001642 void EmitCXXTemporary(const CXXTemporary *Temporary, llvm::Value *Ptr);
Mike Stump1eb44332009-09-09 15:08:12 +00001643
Anders Carlssona00703d2009-05-31 01:40:14 +00001644 llvm::Value *EmitCXXNewExpr(const CXXNewExpr *E);
Anders Carlsson60e282c2009-08-16 21:13:42 +00001645 void EmitCXXDeleteExpr(const CXXDeleteExpr *E);
Mike Stump1eb44332009-09-09 15:08:12 +00001646
Eli Friedman4bf81522009-11-18 00:57:03 +00001647 void EmitDeleteCall(const FunctionDecl *DeleteFD, llvm::Value *Ptr,
1648 QualType DeleteTy);
1649
Mike Stumpc2e84ae2009-11-15 08:09:41 +00001650 llvm::Value* EmitCXXTypeidExpr(const CXXTypeidExpr *E);
Mike Stumpc849c052009-11-16 06:50:58 +00001651 llvm::Value *EmitDynamicCast(llvm::Value *V, const CXXDynamicCastExpr *DCE);
Mike Stumpc2e84ae2009-11-15 08:09:41 +00001652
Mike Stumpb14e62d2009-12-16 02:57:00 +00001653 void EmitCheck(llvm::Value *, unsigned Size);
1654
Chris Lattnerdd36d322010-01-09 21:40:03 +00001655 llvm::Value *EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV,
1656 bool isInc, bool isPre);
1657 ComplexPairTy EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV,
1658 bool isInc, bool isPre);
Reid Spencer5f016e22007-07-11 17:01:13 +00001659 //===--------------------------------------------------------------------===//
Reid Spencer5f016e22007-07-11 17:01:13 +00001660 // Declaration Emission
1661 //===--------------------------------------------------------------------===//
Mike Stump0dd9e882009-02-08 23:14:22 +00001662
Daniel Dunbard286f052009-07-19 06:58:07 +00001663 /// EmitDecl - Emit a declaration.
1664 ///
1665 /// This function can be called with a null (unreachable) insert point.
Reid Spencer5f016e22007-07-11 17:01:13 +00001666 void EmitDecl(const Decl &D);
Daniel Dunbard286f052009-07-19 06:58:07 +00001667
John McCallb6bbcc92010-10-15 04:57:14 +00001668 /// EmitVarDecl - Emit a local variable declaration.
Daniel Dunbard286f052009-07-19 06:58:07 +00001669 ///
1670 /// This function can be called with a null (unreachable) insert point.
John McCallb6bbcc92010-10-15 04:57:14 +00001671 void EmitVarDecl(const VarDecl &D);
Daniel Dunbard286f052009-07-19 06:58:07 +00001672
John McCallf85e1932011-06-15 23:02:42 +00001673 void EmitScalarInit(const Expr *init, const ValueDecl *D,
John McCalla07398e2011-06-16 04:16:24 +00001674 LValue lvalue, bool capturedByInit);
John McCall7acddac2011-06-17 06:42:21 +00001675 void EmitScalarInit(llvm::Value *init, LValue lvalue);
John McCallf85e1932011-06-15 23:02:42 +00001676
John McCallf1549f62010-07-06 01:34:17 +00001677 typedef void SpecialInitFn(CodeGenFunction &Init, const VarDecl &D,
1678 llvm::Value *Address);
1679
John McCallb6bbcc92010-10-15 04:57:14 +00001680 /// EmitAutoVarDecl - Emit an auto variable declaration.
Daniel Dunbard286f052009-07-19 06:58:07 +00001681 ///
1682 /// This function can be called with a null (unreachable) insert point.
John McCall34695852011-02-22 06:44:22 +00001683 void EmitAutoVarDecl(const VarDecl &D);
1684
1685 class AutoVarEmission {
1686 friend class CodeGenFunction;
1687
John McCall57b3b6a2011-02-22 07:16:58 +00001688 const VarDecl *Variable;
John McCall34695852011-02-22 06:44:22 +00001689
1690 /// The alignment of the variable.
1691 CharUnits Alignment;
1692
1693 /// The address of the alloca. Null if the variable was emitted
1694 /// as a global constant.
1695 llvm::Value *Address;
1696
1697 llvm::Value *NRVOFlag;
1698
1699 /// True if the variable is a __block variable.
1700 bool IsByRef;
1701
1702 /// True if the variable is of aggregate type and has a constant
1703 /// initializer.
1704 bool IsConstantAggregate;
1705
John McCall57b3b6a2011-02-22 07:16:58 +00001706 struct Invalid {};
1707 AutoVarEmission(Invalid) : Variable(0) {}
1708
John McCall34695852011-02-22 06:44:22 +00001709 AutoVarEmission(const VarDecl &variable)
John McCall57b3b6a2011-02-22 07:16:58 +00001710 : Variable(&variable), Address(0), NRVOFlag(0),
John McCall34695852011-02-22 06:44:22 +00001711 IsByRef(false), IsConstantAggregate(false) {}
1712
1713 bool wasEmittedAsGlobal() const { return Address == 0; }
1714
1715 public:
John McCall57b3b6a2011-02-22 07:16:58 +00001716 static AutoVarEmission invalid() { return AutoVarEmission(Invalid()); }
1717
John McCall34695852011-02-22 06:44:22 +00001718 /// Returns the address of the object within this declaration.
1719 /// Note that this does not chase the forwarding pointer for
1720 /// __block decls.
1721 llvm::Value *getObjectAddress(CodeGenFunction &CGF) const {
1722 if (!IsByRef) return Address;
1723
1724 return CGF.Builder.CreateStructGEP(Address,
John McCall57b3b6a2011-02-22 07:16:58 +00001725 CGF.getByRefValueLLVMField(Variable),
1726 Variable->getNameAsString());
John McCall34695852011-02-22 06:44:22 +00001727 }
1728 };
1729 AutoVarEmission EmitAutoVarAlloca(const VarDecl &var);
1730 void EmitAutoVarInit(const AutoVarEmission &emission);
1731 void EmitAutoVarCleanups(const AutoVarEmission &emission);
John McCallbdc4d802011-07-09 01:37:26 +00001732 void emitAutoVarTypeCleanup(const AutoVarEmission &emission,
1733 QualType::DestructionKind dtorKind);
Daniel Dunbard286f052009-07-19 06:58:07 +00001734
John McCallb6bbcc92010-10-15 04:57:14 +00001735 void EmitStaticVarDecl(const VarDecl &D,
1736 llvm::GlobalValue::LinkageTypes Linkage);
Daniel Dunbarb7ec2462008-08-16 03:19:19 +00001737
1738 /// EmitParmDecl - Emit a ParmVarDecl or an ImplicitParamDecl.
Devang Patel093ac462011-03-03 20:13:15 +00001739 void EmitParmDecl(const VarDecl &D, llvm::Value *Arg, unsigned ArgNo);
Mike Stump0dd9e882009-02-08 23:14:22 +00001740
John McCall56ca35d2011-02-17 10:25:35 +00001741 /// protectFromPeepholes - Protect a value that we're intending to
1742 /// store to the side, but which will probably be used later, from
1743 /// aggressive peepholing optimizations that might delete it.
1744 ///
1745 /// Pass the result to unprotectFromPeepholes to declare that
1746 /// protection is no longer required.
1747 ///
1748 /// There's no particular reason why this shouldn't apply to
1749 /// l-values, it's just that no existing peepholes work on pointers.
1750 PeepholeProtection protectFromPeepholes(RValue rvalue);
1751 void unprotectFromPeepholes(PeepholeProtection protection);
1752
Reid Spencer5f016e22007-07-11 17:01:13 +00001753 //===--------------------------------------------------------------------===//
1754 // Statement Emission
1755 //===--------------------------------------------------------------------===//
1756
Mike Stump0dd9e882009-02-08 23:14:22 +00001757 /// EmitStopPoint - Emit a debug stoppoint if we are emitting debug info.
Daniel Dunbar09124252008-11-12 08:21:33 +00001758 void EmitStopPoint(const Stmt *S);
1759
Mike Stump0dd9e882009-02-08 23:14:22 +00001760 /// EmitStmt - Emit the code for the statement \arg S. It is legal to call
1761 /// this function even if there is no current insertion point.
1762 ///
1763 /// This function may clear the current insertion point; callers should use
1764 /// EnsureInsertPoint if they wish to subsequently generate code without first
1765 /// calling EmitBlock, EmitBranch, or EmitStmt.
Reid Spencer5f016e22007-07-11 17:01:13 +00001766 void EmitStmt(const Stmt *S);
Daniel Dunbara448fb22008-11-11 23:11:34 +00001767
Daniel Dunbar09124252008-11-12 08:21:33 +00001768 /// EmitSimpleStmt - Try to emit a "simple" statement which does not
Mike Stump0dd9e882009-02-08 23:14:22 +00001769 /// necessarily require an insertion point or debug information; typically
1770 /// because the statement amounts to a jump or a container of other
1771 /// statements.
Daniel Dunbar09124252008-11-12 08:21:33 +00001772 ///
1773 /// \return True if the statement was handled.
1774 bool EmitSimpleStmt(const Stmt *S);
1775
Chris Lattner9b655512007-08-31 22:49:20 +00001776 RValue EmitCompoundStmt(const CompoundStmt &S, bool GetLast = false,
John McCall558d2ab2010-09-15 10:14:12 +00001777 AggValueSlot AVS = AggValueSlot::ignored());
Daniel Dunbara448fb22008-11-11 23:11:34 +00001778
Mike Stump0dd9e882009-02-08 23:14:22 +00001779 /// EmitLabel - Emit the block for the given label. It is legal to call this
1780 /// function even if there is no current insertion point.
Chris Lattnerad8dcf42011-02-17 07:39:24 +00001781 void EmitLabel(const LabelDecl *D); // helper for EmitLabelStmt.
Daniel Dunbara448fb22008-11-11 23:11:34 +00001782
Reid Spencer5f016e22007-07-11 17:01:13 +00001783 void EmitLabelStmt(const LabelStmt &S);
1784 void EmitGotoStmt(const GotoStmt &S);
Daniel Dunbar0ffb1252008-08-04 16:51:22 +00001785 void EmitIndirectGotoStmt(const IndirectGotoStmt &S);
Reid Spencer5f016e22007-07-11 17:01:13 +00001786 void EmitIfStmt(const IfStmt &S);
1787 void EmitWhileStmt(const WhileStmt &S);
1788 void EmitDoStmt(const DoStmt &S);
1789 void EmitForStmt(const ForStmt &S);
1790 void EmitReturnStmt(const ReturnStmt &S);
1791 void EmitDeclStmt(const DeclStmt &S);
Daniel Dunbar09124252008-11-12 08:21:33 +00001792 void EmitBreakStmt(const BreakStmt &S);
1793 void EmitContinueStmt(const ContinueStmt &S);
Devang Patel51b09f22007-10-04 23:45:31 +00001794 void EmitSwitchStmt(const SwitchStmt &S);
1795 void EmitDefaultStmt(const DefaultStmt &S);
1796 void EmitCaseStmt(const CaseStmt &S);
Devang Patelc049e4f2007-10-08 20:57:48 +00001797 void EmitCaseStmtRange(const CaseStmt &S);
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001798 void EmitAsmStmt(const AsmStmt &S);
Mike Stump0dd9e882009-02-08 23:14:22 +00001799
Anders Carlsson3d8400d2008-08-30 19:51:14 +00001800 void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S);
Anders Carlsson64d5d6c2008-09-09 10:04:29 +00001801 void EmitObjCAtTryStmt(const ObjCAtTryStmt &S);
1802 void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S);
Chris Lattner10cac6f2008-11-15 21:26:17 +00001803 void EmitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt &S);
John McCallf85e1932011-06-15 23:02:42 +00001804 void EmitObjCAutoreleasePoolStmt(const ObjCAutoreleasePoolStmt &S);
Mike Stump0dd9e882009-02-08 23:14:22 +00001805
John McCall93c332a2011-05-28 21:13:02 +00001806 llvm::Constant *getUnwindResumeFn();
Douglas Gregor86a3a032010-05-16 01:24:12 +00001807 llvm::Constant *getUnwindResumeOrRethrowFn();
John McCall59a70002010-07-07 06:56:46 +00001808 void EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock = false);
1809 void ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock = false);
John McCall9fc6a772010-02-19 09:25:03 +00001810
Anders Carlsson6815e942009-09-27 18:58:34 +00001811 void EmitCXXTryStmt(const CXXTryStmt &S);
Richard Smithad762fc2011-04-14 22:09:26 +00001812 void EmitCXXForRangeStmt(const CXXForRangeStmt &S);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001813
Reid Spencer5f016e22007-07-11 17:01:13 +00001814 //===--------------------------------------------------------------------===//
1815 // LValue Expression Emission
1816 //===--------------------------------------------------------------------===//
1817
Daniel Dunbar13e81732009-02-05 07:09:07 +00001818 /// GetUndefRValue - Get an appropriate 'undef' rvalue for the given type.
1819 RValue GetUndefRValue(QualType Ty);
1820
Daniel Dunbarce1d38b2009-01-09 16:50:52 +00001821 /// EmitUnsupportedRValue - Emit a dummy r-value using the type of E
1822 /// and issue an ErrorUnsupported style diagnostic (using the
1823 /// provided Name).
1824 RValue EmitUnsupportedRValue(const Expr *E,
1825 const char *Name);
1826
Mike Stump0dd9e882009-02-08 23:14:22 +00001827 /// EmitUnsupportedLValue - Emit a dummy l-value using the type of E and issue
1828 /// an ErrorUnsupported style diagnostic (using the provided Name).
Daniel Dunbar6ba82a42008-08-25 20:45:57 +00001829 LValue EmitUnsupportedLValue(const Expr *E,
1830 const char *Name);
1831
Reid Spencer5f016e22007-07-11 17:01:13 +00001832 /// EmitLValue - Emit code to compute a designator that specifies the location
1833 /// of the expression.
1834 ///
1835 /// This can return one of two things: a simple address or a bitfield
1836 /// reference. In either case, the LLVM Value* in the LValue structure is
1837 /// guaranteed to be an LLVM pointer type.
1838 ///
1839 /// If this returns a bitfield reference, nothing about the pointee type of
1840 /// the LLVM value is known: For example, it may not be a pointer to an
1841 /// integer.
1842 ///
1843 /// If this returns a normal address, and if the lvalue's C type is fixed
1844 /// size, this method guarantees that the returned pointer type will point to
1845 /// an LLVM type of the same size of the lvalue's type. If the lvalue has a
1846 /// variable length type, this is not possible.
1847 ///
1848 LValue EmitLValue(const Expr *E);
Mike Stump0dd9e882009-02-08 23:14:22 +00001849
Mike Stumpb14e62d2009-12-16 02:57:00 +00001850 /// EmitCheckedLValue - Same as EmitLValue but additionally we generate
1851 /// checking code to guard against undefined behavior. This is only
1852 /// suitable when we know that the address will be used to access the
1853 /// object.
1854 LValue EmitCheckedLValue(const Expr *E);
1855
John McCall26815d92010-10-27 20:58:56 +00001856 /// EmitToMemory - Change a scalar value from its value
1857 /// representation to its in-memory representation.
1858 llvm::Value *EmitToMemory(llvm::Value *Value, QualType Ty);
1859
1860 /// EmitFromMemory - Change a scalar value from its memory
1861 /// representation to its value representation.
1862 llvm::Value *EmitFromMemory(llvm::Value *Value, QualType Ty);
1863
Daniel Dunbar9d9cc872009-02-10 00:57:50 +00001864 /// EmitLoadOfScalar - Load a scalar value from an address, taking
1865 /// care to appropriately convert from the memory representation to
1866 /// the LLVM value representation.
Mike Stump09429b92009-02-17 17:00:02 +00001867 llvm::Value *EmitLoadOfScalar(llvm::Value *Addr, bool Volatile,
Dan Gohman3d5aff52010-10-14 23:06:10 +00001868 unsigned Alignment, QualType Ty,
1869 llvm::MDNode *TBAAInfo = 0);
John McCall545d9962011-06-25 02:11:03 +00001870
1871 /// EmitLoadOfScalar - Load a scalar value from an address, taking
1872 /// care to appropriately convert from the memory representation to
1873 /// the LLVM value representation. The l-value must be a simple
1874 /// l-value.
John McCalla07398e2011-06-16 04:16:24 +00001875 llvm::Value *EmitLoadOfScalar(LValue lvalue);
Daniel Dunbar9d9cc872009-02-10 00:57:50 +00001876
1877 /// EmitStoreOfScalar - Store a scalar value to an address, taking
1878 /// care to appropriately convert from the memory representation to
1879 /// the LLVM value representation.
Mike Stump09429b92009-02-17 17:00:02 +00001880 void EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr,
Dan Gohman3d5aff52010-10-14 23:06:10 +00001881 bool Volatile, unsigned Alignment, QualType Ty,
1882 llvm::MDNode *TBAAInfo = 0);
John McCall545d9962011-06-25 02:11:03 +00001883
1884 /// EmitStoreOfScalar - Store a scalar value to an address, taking
1885 /// care to appropriately convert from the memory representation to
1886 /// the LLVM value representation. The l-value must be a simple
1887 /// l-value.
John McCalla07398e2011-06-16 04:16:24 +00001888 void EmitStoreOfScalar(llvm::Value *value, LValue lvalue);
Daniel Dunbar9d9cc872009-02-10 00:57:50 +00001889
Reid Spencer5f016e22007-07-11 17:01:13 +00001890 /// EmitLoadOfLValue - Given an expression that represents a value lvalue,
1891 /// this method emits the address of the lvalue, then loads the result as an
1892 /// rvalue, returning the rvalue.
John McCall545d9962011-06-25 02:11:03 +00001893 RValue EmitLoadOfLValue(LValue V);
1894 RValue EmitLoadOfExtVectorElementLValue(LValue V);
1895 RValue EmitLoadOfBitfieldLValue(LValue LV);
John McCall119a1c62010-12-04 02:32:38 +00001896 RValue EmitLoadOfPropertyRefLValue(LValue LV,
1897 ReturnValueSlot Return = ReturnValueSlot());
Mike Stump0dd9e882009-02-08 23:14:22 +00001898
Reid Spencer5f016e22007-07-11 17:01:13 +00001899 /// EmitStoreThroughLValue - Store the specified rvalue into the specified
1900 /// lvalue, where both are guaranteed to the have the same type, and that type
1901 /// is 'Ty'.
John McCall545d9962011-06-25 02:11:03 +00001902 void EmitStoreThroughLValue(RValue Src, LValue Dst);
1903 void EmitStoreThroughExtVectorComponentLValue(RValue Src, LValue Dst);
John McCall119a1c62010-12-04 02:32:38 +00001904 void EmitStoreThroughPropertyRefLValue(RValue Src, LValue Dst);
Daniel Dunbared3849b2008-11-19 09:36:46 +00001905
Mike Stump0dd9e882009-02-08 23:14:22 +00001906 /// EmitStoreThroughLValue - Store Src into Dst with same constraints as
1907 /// EmitStoreThroughLValue.
Daniel Dunbared3849b2008-11-19 09:36:46 +00001908 ///
Mike Stump0dd9e882009-02-08 23:14:22 +00001909 /// \param Result [out] - If non-null, this will be set to a Value* for the
1910 /// bit-field contents after the store, appropriate for use as the result of
1911 /// an assignment to the bit-field.
John McCall545d9962011-06-25 02:11:03 +00001912 void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst,
Daniel Dunbared3849b2008-11-19 09:36:46 +00001913 llvm::Value **Result=0);
Mike Stump0dd9e882009-02-08 23:14:22 +00001914
John McCall83ce9d42010-11-16 23:07:28 +00001915 /// Emit an l-value for an assignment (simple or compound) of complex type.
1916 LValue EmitComplexAssignmentLValue(const BinaryOperator *E);
John McCall2a416372010-12-05 02:00:02 +00001917 LValue EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E);
John McCall83ce9d42010-11-16 23:07:28 +00001918
Chris Lattnerfc8f0e12011-04-15 05:22:18 +00001919 // Note: only available for agg return types
Daniel Dunbar80e62c22008-09-04 03:20:13 +00001920 LValue EmitBinaryOperatorLValue(const BinaryOperator *E);
John McCall2a416372010-12-05 02:00:02 +00001921 LValue EmitCompoundAssignmentLValue(const CompoundAssignOperator *E);
Daniel Dunbar5b5c9ef2009-02-11 20:59:32 +00001922 // Note: only available for agg return types
Christopher Lamb22c940e2007-12-29 05:02:41 +00001923 LValue EmitCallExprLValue(const CallExpr *E);
Daniel Dunbar5b5c9ef2009-02-11 20:59:32 +00001924 // Note: only available for agg return types
1925 LValue EmitVAArgExprLValue(const VAArgExpr *E);
Reid Spencer5f016e22007-07-11 17:01:13 +00001926 LValue EmitDeclRefLValue(const DeclRefExpr *E);
1927 LValue EmitStringLiteralLValue(const StringLiteral *E);
Chris Lattnereaf2bb82009-02-24 22:18:39 +00001928 LValue EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E);
Chris Lattnerd9f69102008-08-10 01:53:14 +00001929 LValue EmitPredefinedLValue(const PredefinedExpr *E);
Reid Spencer5f016e22007-07-11 17:01:13 +00001930 LValue EmitUnaryOpLValue(const UnaryOperator *E);
1931 LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E);
Nate Begeman213541a2008-04-18 23:10:10 +00001932 LValue EmitExtVectorElementExpr(const ExtVectorElementExpr *E);
Devang Patelb84a06e2007-10-23 02:10:49 +00001933 LValue EmitMemberExpr(const MemberExpr *E);
Fariborz Jahanian820bca42009-12-09 23:35:29 +00001934 LValue EmitObjCIsaExpr(const ObjCIsaExpr *E);
Eli Friedman06e863f2008-05-13 23:18:27 +00001935 LValue EmitCompoundLiteralLValue(const CompoundLiteralExpr *E);
John McCall56ca35d2011-02-17 10:25:35 +00001936 LValue EmitConditionalOperatorLValue(const AbstractConditionalOperator *E);
Chris Lattner75dfeda2009-03-18 18:28:57 +00001937 LValue EmitCastLValue(const CastExpr *E);
Douglas Gregored8abf12010-07-08 06:14:04 +00001938 LValue EmitNullInitializationLValue(const CXXScalarValueInitExpr *E);
Douglas Gregor03e80032011-06-21 17:03:29 +00001939 LValue EmitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E);
John McCalle996ffd2011-02-16 08:02:54 +00001940 LValue EmitOpaqueValueLValue(const OpaqueValueExpr *e);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001941
Daniel Dunbar2a031922009-04-22 05:08:15 +00001942 llvm::Value *EmitIvarOffset(const ObjCInterfaceDecl *Interface,
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00001943 const ObjCIvarDecl *Ivar);
John McCalla9976d32010-05-21 01:18:57 +00001944 LValue EmitLValueForAnonRecordField(llvm::Value* Base,
Francois Pichet00eb3f92010-12-04 09:14:42 +00001945 const IndirectFieldDecl* Field,
John McCalla9976d32010-05-21 01:18:57 +00001946 unsigned CVRQualifiers);
Anders Carlsson0ed303c2009-11-17 03:57:07 +00001947 LValue EmitLValueForField(llvm::Value* Base, const FieldDecl* Field,
Anders Carlssone6d2a532010-01-29 05:05:36 +00001948 unsigned CVRQualifiers);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001949
Anders Carlsson06a29702010-01-29 05:24:29 +00001950 /// EmitLValueForFieldInitialization - Like EmitLValueForField, except that
1951 /// if the Field is a reference, this will return the address of the reference
1952 /// and not the address of the value stored in the reference.
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001953 LValue EmitLValueForFieldInitialization(llvm::Value* Base,
Anders Carlsson06a29702010-01-29 05:24:29 +00001954 const FieldDecl* Field,
1955 unsigned CVRQualifiers);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001956
Fariborz Jahanian45012a72009-02-03 00:09:52 +00001957 LValue EmitLValueForIvar(QualType ObjectTy,
1958 llvm::Value* Base, const ObjCIvarDecl *Ivar,
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00001959 unsigned CVRQualifiers);
1960
Anders Carlsson0ed303c2009-11-17 03:57:07 +00001961 LValue EmitLValueForBitfield(llvm::Value* Base, const FieldDecl* Field,
Fariborz Jahanian598d3f62009-02-03 19:03:09 +00001962 unsigned CVRQualifiers);
Fariborz Jahanianfd64bb62008-12-15 20:35:07 +00001963
Mike Stumpa99038c2009-02-28 09:07:16 +00001964 LValue EmitBlockDeclRefLValue(const BlockDeclRefExpr *E);
1965
Anders Carlssonb58d0172009-05-30 23:23:33 +00001966 LValue EmitCXXConstructLValue(const CXXConstructExpr *E);
Anders Carlssone61c9e82009-05-30 23:30:54 +00001967 LValue EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E);
John McCall4765fa02010-12-06 08:20:24 +00001968 LValue EmitExprWithCleanupsLValue(const ExprWithCleanups *E);
Mike Stumpc2e84ae2009-11-15 08:09:41 +00001969 LValue EmitCXXTypeidLValue(const CXXTypeidExpr *E);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001970
Daniel Dunbar0a04d772008-08-23 10:51:21 +00001971 LValue EmitObjCMessageExprLValue(const ObjCMessageExpr *E);
Chris Lattner391d77a2008-03-30 23:03:07 +00001972 LValue EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E);
Daniel Dunbar85c59ed2008-08-29 08:11:39 +00001973 LValue EmitObjCPropertyRefLValue(const ObjCPropertyRefExpr *E);
Chris Lattner65459942009-04-25 19:35:26 +00001974 LValue EmitStmtExprLValue(const StmtExpr *E);
Fariborz Jahanian8bfd31f2009-10-22 22:57:31 +00001975 LValue EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E);
Fariborz Jahanian03b29602010-06-17 19:56:20 +00001976 LValue EmitObjCSelectorLValue(const ObjCSelectorExpr *E);
John McCall189d6ef2010-10-09 01:34:31 +00001977 void EmitDeclRefExprDbgValue(const DeclRefExpr *E, llvm::Constant *Init);
John McCall56ca35d2011-02-17 10:25:35 +00001978
Reid Spencer5f016e22007-07-11 17:01:13 +00001979 //===--------------------------------------------------------------------===//
Chris Lattner883f6a72007-08-11 00:04:45 +00001980 // Scalar Expression Emission
Reid Spencer5f016e22007-07-11 17:01:13 +00001981 //===--------------------------------------------------------------------===//
1982
Mike Stump0dd9e882009-02-08 23:14:22 +00001983 /// EmitCall - Generate a call of the given function, expecting the given
1984 /// result type, and using the given argument list which specifies both the
1985 /// LLVM arguments and the types they were derived from.
Daniel Dunbarc0ef9f52009-02-20 18:06:48 +00001986 ///
Mike Stumpf71d2322009-11-30 20:08:49 +00001987 /// \param TargetDecl - If given, the decl of the function in a direct call;
1988 /// used to set attributes on the call (noreturn, etc.).
Daniel Dunbar88b53962009-02-02 22:03:45 +00001989 RValue EmitCall(const CGFunctionInfo &FnInfo,
1990 llvm::Value *Callee,
Anders Carlssonf3c47c92009-12-24 19:25:24 +00001991 ReturnValueSlot ReturnValue,
Daniel Dunbarc0ef9f52009-02-20 18:06:48 +00001992 const CallArgList &Args,
David Chisnalldd5c98f2010-05-01 11:15:56 +00001993 const Decl *TargetDecl = 0,
David Chisnall4b02afc2010-05-02 13:41:58 +00001994 llvm::Instruction **callOrInvoke = 0);
Mike Stump1eb44332009-09-09 15:08:12 +00001995
Anders Carlsson31777a22009-12-24 19:08:58 +00001996 RValue EmitCall(QualType FnType, llvm::Value *Callee,
Anders Carlssond2490a92009-12-24 20:40:36 +00001997 ReturnValueSlot ReturnValue,
Anders Carlsson98647712009-05-27 01:22:39 +00001998 CallExpr::const_arg_iterator ArgBeg,
1999 CallExpr::const_arg_iterator ArgEnd,
2000 const Decl *TargetDecl = 0);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002001 RValue EmitCallExpr(const CallExpr *E,
Anders Carlssond2490a92009-12-24 20:40:36 +00002002 ReturnValueSlot ReturnValue = ReturnValueSlot());
Mike Stump1eb44332009-09-09 15:08:12 +00002003
John McCallf1549f62010-07-06 01:34:17 +00002004 llvm::CallSite EmitCallOrInvoke(llvm::Value *Callee,
2005 llvm::Value * const *ArgBegin,
2006 llvm::Value * const *ArgEnd,
2007 const llvm::Twine &Name = "");
2008
Anders Carlsson566abee2009-11-13 04:45:41 +00002009 llvm::Value *BuildVirtualCall(const CXXMethodDecl *MD, llvm::Value *This,
Mike Stumpf0070db2009-08-26 20:46:33 +00002010 const llvm::Type *Ty);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002011 llvm::Value *BuildVirtualCall(const CXXDestructorDecl *DD, CXXDtorType Type,
Anders Carlsson83eedd92010-11-28 17:53:32 +00002012 llvm::Value *This, const llvm::Type *Ty);
Fariborz Jahanian27262672011-01-20 17:19:02 +00002013 llvm::Value *BuildAppleKextVirtualCall(const CXXMethodDecl *MD,
2014 NestedNameSpecifier *Qual,
Fariborz Jahanian27262672011-01-20 17:19:02 +00002015 const llvm::Type *Ty);
Fariborz Jahanianccd52592011-02-01 23:22:34 +00002016
2017 llvm::Value *BuildAppleKextVirtualDestructorCall(const CXXDestructorDecl *DD,
2018 CXXDtorType Type,
Fariborz Jahanian771c6782011-02-03 19:27:17 +00002019 const CXXRecordDecl *RD);
Anders Carlsson566abee2009-11-13 04:45:41 +00002020
Anders Carlssonb9de2c52009-05-11 23:37:08 +00002021 RValue EmitCXXMemberCall(const CXXMethodDecl *MD,
2022 llvm::Value *Callee,
Anders Carlssona1736c02009-12-24 21:13:40 +00002023 ReturnValueSlot ReturnValue,
Anders Carlssonb9de2c52009-05-11 23:37:08 +00002024 llvm::Value *This,
Anders Carlssonc997d422010-01-02 01:01:18 +00002025 llvm::Value *VTT,
Anders Carlssonb9de2c52009-05-11 23:37:08 +00002026 CallExpr::const_arg_iterator ArgBeg,
2027 CallExpr::const_arg_iterator ArgEnd);
Anders Carlssona1736c02009-12-24 21:13:40 +00002028 RValue EmitCXXMemberCallExpr(const CXXMemberCallExpr *E,
2029 ReturnValueSlot ReturnValue);
2030 RValue EmitCXXMemberPointerCallExpr(const CXXMemberCallExpr *E,
2031 ReturnValueSlot ReturnValue);
Ted Kremenek55499762008-06-17 02:43:46 +00002032
Anders Carlssona2447e02011-05-08 20:32:23 +00002033 llvm::Value *EmitCXXOperatorMemberCallee(const CXXOperatorCallExpr *E,
2034 const CXXMethodDecl *MD,
2035 llvm::Value *This);
Anders Carlsson0f294632009-05-27 04:18:27 +00002036 RValue EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E,
Anders Carlssona1736c02009-12-24 21:13:40 +00002037 const CXXMethodDecl *MD,
2038 ReturnValueSlot ReturnValue);
Mike Stump1eb44332009-09-09 15:08:12 +00002039
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002040
Mike Stump1eb44332009-09-09 15:08:12 +00002041 RValue EmitBuiltinExpr(const FunctionDecl *FD,
Daniel Dunbaref2abfe2009-02-16 22:43:43 +00002042 unsigned BuiltinID, const CallExpr *E);
Reid Spencer5f016e22007-07-11 17:01:13 +00002043
Anders Carlssona1736c02009-12-24 21:13:40 +00002044 RValue EmitBlockCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue);
Mike Stump09429b92009-02-17 17:00:02 +00002045
Mike Stump0dd9e882009-02-08 23:14:22 +00002046 /// EmitTargetBuiltinExpr - Emit the given builtin call. Returns 0 if the call
2047 /// is unhandled by the current target.
Daniel Dunbarf02e9dd2008-10-10 00:24:54 +00002048 llvm::Value *EmitTargetBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
2049
Chris Lattner2752c012010-03-03 19:03:45 +00002050 llvm::Value *EmitARMBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002051 llvm::Value *EmitNeonCall(llvm::Function *F,
Nate Begeman30d91712010-06-08 06:03:01 +00002052 llvm::SmallVectorImpl<llvm::Value*> &O,
Bob Wilsondb3d4d02010-12-08 22:37:56 +00002053 const char *name,
Nate Begeman61eecf52010-06-14 05:21:25 +00002054 unsigned shift = 0, bool rightshift = false);
Bob Wilsoncf556522010-12-07 22:40:02 +00002055 llvm::Value *EmitNeonSplat(llvm::Value *V, llvm::Constant *Idx);
Nate Begeman464ccb62010-06-11 22:57:12 +00002056 llvm::Value *EmitNeonShiftVector(llvm::Value *V, const llvm::Type *Ty,
Nate Begeman61eecf52010-06-14 05:21:25 +00002057 bool negateForRightShift);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002058
Bill Wendlingaa51e512010-10-09 08:47:25 +00002059 llvm::Value *BuildVector(const llvm::SmallVectorImpl<llvm::Value*> &Ops);
Anders Carlsson564f1de2007-12-09 23:17:02 +00002060 llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E);
2061 llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
Mike Stump0dd9e882009-02-08 23:14:22 +00002062
Daniel Dunbared7c6182008-08-20 00:28:19 +00002063 llvm::Value *EmitObjCProtocolExpr(const ObjCProtocolExpr *E);
Chris Lattner7f02f722007-08-24 05:35:26 +00002064 llvm::Value *EmitObjCStringLiteral(const ObjCStringLiteral *E);
Chris Lattner8fdf3282008-06-24 17:04:18 +00002065 llvm::Value *EmitObjCSelectorExpr(const ObjCSelectorExpr *E);
John McCallef072fd2010-05-22 01:48:05 +00002066 RValue EmitObjCMessageExpr(const ObjCMessageExpr *E,
2067 ReturnValueSlot Return = ReturnValueSlot());
Chris Lattner8fdf3282008-06-24 17:04:18 +00002068
John McCallf85e1932011-06-15 23:02:42 +00002069 /// Retrieves the default cleanup kind for an ARC cleanup.
2070 /// Except under -fobjc-arc-eh, ARC cleanups are normal-only.
2071 CleanupKind getARCCleanupKind() {
2072 return CGM.getCodeGenOpts().ObjCAutoRefCountExceptions
2073 ? NormalAndEHCleanup : NormalCleanup;
2074 }
2075
2076 // ARC primitives.
2077 void EmitARCInitWeak(llvm::Value *value, llvm::Value *addr);
2078 void EmitARCDestroyWeak(llvm::Value *addr);
2079 llvm::Value *EmitARCLoadWeak(llvm::Value *addr);
2080 llvm::Value *EmitARCLoadWeakRetained(llvm::Value *addr);
2081 llvm::Value *EmitARCStoreWeak(llvm::Value *value, llvm::Value *addr,
2082 bool ignored);
2083 void EmitARCCopyWeak(llvm::Value *dst, llvm::Value *src);
2084 void EmitARCMoveWeak(llvm::Value *dst, llvm::Value *src);
2085 llvm::Value *EmitARCRetainAutorelease(QualType type, llvm::Value *value);
2086 llvm::Value *EmitARCRetainAutoreleaseNonBlock(llvm::Value *value);
John McCall545d9962011-06-25 02:11:03 +00002087 llvm::Value *EmitARCStoreStrong(LValue lvalue, llvm::Value *value,
2088 bool ignored);
John McCallf85e1932011-06-15 23:02:42 +00002089 llvm::Value *EmitARCStoreStrongCall(llvm::Value *addr, llvm::Value *value,
2090 bool ignored);
2091 llvm::Value *EmitARCRetain(QualType type, llvm::Value *value);
2092 llvm::Value *EmitARCRetainNonBlock(llvm::Value *value);
2093 llvm::Value *EmitARCRetainBlock(llvm::Value *value);
2094 void EmitARCRelease(llvm::Value *value, bool precise);
2095 llvm::Value *EmitARCAutorelease(llvm::Value *value);
2096 llvm::Value *EmitARCAutoreleaseReturnValue(llvm::Value *value);
2097 llvm::Value *EmitARCRetainAutoreleaseReturnValue(llvm::Value *value);
2098 llvm::Value *EmitARCRetainAutoreleasedReturnValue(llvm::Value *value);
2099
2100 std::pair<LValue,llvm::Value*>
2101 EmitARCStoreAutoreleasing(const BinaryOperator *e);
2102 std::pair<LValue,llvm::Value*>
2103 EmitARCStoreStrong(const BinaryOperator *e, bool ignored);
2104
2105 llvm::Value *EmitObjCProduceObject(QualType T, llvm::Value *Ptr);
2106 llvm::Value *EmitObjCConsumeObject(QualType T, llvm::Value *Ptr);
2107 llvm::Value *EmitObjCExtendObjectLifetime(QualType T, llvm::Value *Ptr);
2108
2109 llvm::Value *EmitARCRetainScalarExpr(const Expr *expr);
2110 llvm::Value *EmitARCRetainAutoreleaseScalarExpr(const Expr *expr);
2111
2112 void PushARCReleaseCleanup(CleanupKind kind, QualType type,
Douglas Gregord7b23162011-06-22 16:12:01 +00002113 llvm::Value *addr, bool precise,
2114 bool forFullExpr = false);
John McCallbdc4d802011-07-09 01:37:26 +00002115 void PushARCArrayReleaseCleanup(CleanupKind kind, QualType elementType,
2116 llvm::Value *addr,
2117 llvm::Value *countOrCountPtr,
2118 bool precise, bool forFullExpr = false);
John McCallf85e1932011-06-15 23:02:42 +00002119 void PushARCWeakReleaseCleanup(CleanupKind kind, QualType type,
Douglas Gregord7b23162011-06-22 16:12:01 +00002120 llvm::Value *addr, bool forFullExpr = false);
John McCallbdc4d802011-07-09 01:37:26 +00002121 void PushARCArrayWeakReleaseCleanup(CleanupKind kind, QualType elementType,
2122 llvm::Value *addr,
2123 llvm::Value *countOrCountPtr,
2124 bool forFullExpr = false);
2125 static Destroyer destroyARCStrongImprecise;
2126 static Destroyer destroyARCStrongPrecise;
2127 static Destroyer destroyARCWeak;
2128
John McCallf85e1932011-06-15 23:02:42 +00002129 void PushARCFieldReleaseCleanup(CleanupKind cleanupKind,
2130 const FieldDecl *Field);
2131 void PushARCFieldWeakReleaseCleanup(CleanupKind cleanupKind,
2132 const FieldDecl *Field);
2133
2134 void EmitObjCAutoreleasePoolPop(llvm::Value *Ptr);
2135 llvm::Value *EmitObjCAutoreleasePoolPush();
2136 llvm::Value *EmitObjCMRRAutoreleasePoolPush();
2137 void EmitObjCAutoreleasePoolCleanup(llvm::Value *Ptr);
2138 void EmitObjCMRRAutoreleasePoolPop(llvm::Value *Ptr);
2139
Anders Carlsson4029ca72009-05-20 00:24:07 +00002140 /// EmitReferenceBindingToExpr - Emits a reference binding to the passed in
2141 /// expression. Will emit a temporary variable if E is not an LValue.
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002142 RValue EmitReferenceBindingToExpr(const Expr* E,
Anders Carlsson32f36ba2010-06-26 16:35:32 +00002143 const NamedDecl *InitializedDecl);
Anders Carlsson3aba0932010-01-31 18:34:51 +00002144
Chris Lattner883f6a72007-08-11 00:04:45 +00002145 //===--------------------------------------------------------------------===//
Chris Lattnerbfc0c1a2007-08-26 23:13:56 +00002146 // Expression Emission
Chris Lattner883f6a72007-08-11 00:04:45 +00002147 //===--------------------------------------------------------------------===//
Chris Lattnerbfc0c1a2007-08-26 23:13:56 +00002148
2149 // Expressions are broken into three classes: scalar, complex, aggregate.
Mike Stump0dd9e882009-02-08 23:14:22 +00002150
2151 /// EmitScalarExpr - Emit the computation of the specified expression of LLVM
2152 /// scalar type, returning the result.
Anders Carlsson14c5cbf2009-08-16 07:36:22 +00002153 llvm::Value *EmitScalarExpr(const Expr *E , bool IgnoreResultAssign = false);
Mike Stump0dd9e882009-02-08 23:14:22 +00002154
Chris Lattner3707b252007-08-26 06:48:56 +00002155 /// EmitScalarConversion - Emit a conversion from the specified type to the
2156 /// specified destination type, both of which are LLVM scalar types.
2157 llvm::Value *EmitScalarConversion(llvm::Value *Src, QualType SrcTy,
2158 QualType DstTy);
Mike Stump0dd9e882009-02-08 23:14:22 +00002159
Chris Lattner4f1a7b32007-08-26 16:34:22 +00002160 /// EmitComplexToScalarConversion - Emit a conversion from the specified
Mike Stump0dd9e882009-02-08 23:14:22 +00002161 /// complex type to the specified destination type, where the destination type
2162 /// is an LLVM scalar type.
Chris Lattner4f1a7b32007-08-26 16:34:22 +00002163 llvm::Value *EmitComplexToScalarConversion(ComplexPairTy Src, QualType SrcTy,
2164 QualType DstTy);
Mike Stump0dd9e882009-02-08 23:14:22 +00002165
2166
John McCall558d2ab2010-09-15 10:14:12 +00002167 /// EmitAggExpr - Emit the computation of the specified expression
2168 /// of aggregate type. The result is computed into the given slot,
2169 /// which may be null to indicate that the value is not needed.
Fariborz Jahanian474e2fe2010-09-16 00:20:07 +00002170 void EmitAggExpr(const Expr *E, AggValueSlot AS, bool IgnoreResult = false);
Mike Stump0dd9e882009-02-08 23:14:22 +00002171
Daniel Dunbar18aba0d2010-02-05 19:38:31 +00002172 /// EmitAggExprToLValue - Emit the computation of the specified expression of
2173 /// aggregate type into a temporary LValue.
2174 LValue EmitAggExprToLValue(const Expr *E);
2175
Fariborz Jahanian082b02e2009-07-08 01:18:33 +00002176 /// EmitGCMemmoveCollectable - Emit special API for structs with object
2177 /// pointers.
2178 void EmitGCMemmoveCollectable(llvm::Value *DestPtr, llvm::Value *SrcPtr,
Fariborz Jahanian08c32132009-08-31 19:33:16 +00002179 QualType Ty);
Fariborz Jahanian082b02e2009-07-08 01:18:33 +00002180
John McCall0c24c802011-06-24 23:21:27 +00002181 /// EmitExtendGCLifetime - Given a pointer to an Objective-C object,
2182 /// make sure it survives garbage collection until this point.
2183 void EmitExtendGCLifetime(llvm::Value *object);
2184
Chris Lattnerb6ef18a2007-08-21 05:54:00 +00002185 /// EmitComplexExpr - Emit the computation of the specified expression of
Chris Lattner23b1cdb2007-08-23 23:43:33 +00002186 /// complex type, returning the result.
John McCallb418d742010-11-16 10:08:07 +00002187 ComplexPairTy EmitComplexExpr(const Expr *E,
2188 bool IgnoreReal = false,
2189 bool IgnoreImag = false);
Mike Stump0dd9e882009-02-08 23:14:22 +00002190
Chris Lattner23b1cdb2007-08-23 23:43:33 +00002191 /// EmitComplexExprIntoAddr - Emit the computation of the specified expression
2192 /// of complex type, storing into the specified Value*.
Chris Lattner190dbe22007-08-26 16:22:13 +00002193 void EmitComplexExprIntoAddr(const Expr *E, llvm::Value *DestAddr,
2194 bool DestIsVolatile);
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +00002195
2196 /// StoreComplexToAddr - Store a complex number into the specified address.
2197 void StoreComplexToAddr(ComplexPairTy V, llvm::Value *DestAddr,
2198 bool DestIsVolatile);
Chris Lattner9b655512007-08-31 22:49:20 +00002199 /// LoadComplexFromAddr - Load a complex number from the specified address.
2200 ComplexPairTy LoadComplexFromAddr(llvm::Value *SrcAddr, bool SrcIsVolatile);
Chris Lattner2621fd12008-05-08 05:58:21 +00002201
John McCallb6bbcc92010-10-15 04:57:14 +00002202 /// CreateStaticVarDecl - Create a zero-initialized LLVM global for
2203 /// a static local variable.
2204 llvm::GlobalVariable *CreateStaticVarDecl(const VarDecl &D,
2205 const char *Separator,
Mike Stumpf71d2322009-11-30 20:08:49 +00002206 llvm::GlobalValue::LinkageTypes Linkage);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002207
John McCallb6bbcc92010-10-15 04:57:14 +00002208 /// AddInitializerToStaticVarDecl - Add the initializer for 'D' to the
Chris Lattner761acc12009-12-05 08:22:11 +00002209 /// global variable that has already been created for it. If the initializer
2210 /// has a different type than GV does, this may free GV and return a different
2211 /// one. Otherwise it just returns GV.
2212 llvm::GlobalVariable *
John McCallb6bbcc92010-10-15 04:57:14 +00002213 AddInitializerToStaticVarDecl(const VarDecl &D,
2214 llvm::GlobalVariable *GV);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002215
Daniel Dunbar0096acf2009-02-25 19:24:29 +00002216
Anders Carlsson3b2e16b2009-08-08 21:45:14 +00002217 /// EmitCXXGlobalVarDeclInit - Create the initializer for a C++
2218 /// variable with global storage.
2219 void EmitCXXGlobalVarDeclInit(const VarDecl &D, llvm::Constant *DeclPtr);
2220
2221 /// EmitCXXGlobalDtorRegistration - Emits a call to register the global ptr
2222 /// with the C++ runtime so that its destructor will be called at exit.
Fariborz Jahanian88f42802009-11-10 19:24:06 +00002223 void EmitCXXGlobalDtorRegistration(llvm::Constant *DtorFn,
Anders Carlsson3b2e16b2009-08-08 21:45:14 +00002224 llvm::Constant *DeclPtr);
Mike Stump1eb44332009-09-09 15:08:12 +00002225
John McCall3030eb82010-11-06 09:44:32 +00002226 /// Emit code in this function to perform a guarded variable
2227 /// initialization. Guarded initializations are used when it's not
2228 /// possible to prove that an initialization will be done exactly
2229 /// once, e.g. with a static local variable or a static data member
2230 /// of a class template.
2231 void EmitCXXGuardedInit(const VarDecl &D, llvm::GlobalVariable *DeclPtr);
John McCall5cd91b52010-09-08 01:44:27 +00002232
Daniel Dunbarefb0fa92010-03-20 04:15:41 +00002233 /// GenerateCXXGlobalInitFunc - Generates code for initializing global
2234 /// variables.
2235 void GenerateCXXGlobalInitFunc(llvm::Function *Fn,
2236 llvm::Constant **Decls,
2237 unsigned NumDecls);
2238
2239 /// GenerateCXXGlobalDtorFunc - Generates code for destroying global
2240 /// variables.
2241 void GenerateCXXGlobalDtorFunc(llvm::Function *Fn,
Chris Lattner810112e2010-06-19 05:52:45 +00002242 const std::vector<std::pair<llvm::WeakVH,
Daniel Dunbarefb0fa92010-03-20 04:15:41 +00002243 llvm::Constant*> > &DtorsAndObjects);
2244
John McCalld26bc762011-03-09 04:27:21 +00002245 void GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn,
2246 const VarDecl *D,
John McCall3030eb82010-11-06 09:44:32 +00002247 llvm::GlobalVariable *Addr);
Daniel Dunbarefb0fa92010-03-20 04:15:41 +00002248
John McCall558d2ab2010-09-15 10:14:12 +00002249 void EmitCXXConstructExpr(const CXXConstructExpr *E, AggValueSlot Dest);
Fariborz Jahanian34999872010-11-13 21:53:34 +00002250
2251 void EmitSynthesizedCXXCopyCtor(llvm::Value *Dest, llvm::Value *Src,
Fariborz Jahanian830937b2010-12-02 17:02:11 +00002252 const Expr *Exp);
Mike Stump1eb44332009-09-09 15:08:12 +00002253
John McCall4765fa02010-12-06 08:20:24 +00002254 RValue EmitExprWithCleanups(const ExprWithCleanups *E,
2255 AggValueSlot Slot =AggValueSlot::ignored());
Mike Stump1eb44332009-09-09 15:08:12 +00002256
Anders Carlsson756b5c42009-10-30 01:42:31 +00002257 void EmitCXXThrowExpr(const CXXThrowExpr *E);
Douglas Gregor1eb2e592010-05-16 00:44:00 +00002258
Daniel Dunbar0ffb1252008-08-04 16:51:22 +00002259 //===--------------------------------------------------------------------===//
2260 // Internal Helpers
2261 //===--------------------------------------------------------------------===//
Mike Stump0dd9e882009-02-08 23:14:22 +00002262
Chris Lattner0946ccd2008-11-11 07:41:27 +00002263 /// ContainsLabel - Return true if the statement contains a label in it. If
2264 /// this statement is not executed normally, it not containing a label means
2265 /// that we can just remove the code.
2266 static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts = false);
Mike Stump0dd9e882009-02-08 23:14:22 +00002267
Chris Lattneref425a62011-02-28 00:18:40 +00002268 /// containsBreak - Return true if the statement contains a break out of it.
2269 /// If the statement (recursively) contains a switch or loop with a break
2270 /// inside of it, this is fine.
2271 static bool containsBreak(const Stmt *S);
2272
Daniel Dunbar4bc04552008-11-12 10:12:14 +00002273 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
Chris Lattnerc2c90012011-02-27 23:02:32 +00002274 /// to a constant, or if it does but contains a label, return false. If it
2275 /// constant folds return true and set the boolean result in Result.
2276 bool ConstantFoldsToSimpleInteger(const Expr *Cond, bool &Result);
Mike Stump0dd9e882009-02-08 23:14:22 +00002277
Chris Lattneref425a62011-02-28 00:18:40 +00002278 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
2279 /// to a constant, or if it does but contains a label, return false. If it
2280 /// constant folds return true and set the folded value.
2281 bool ConstantFoldsToSimpleInteger(const Expr *Cond, llvm::APInt &Result);
2282
Chris Lattner31a09842008-11-12 08:04:58 +00002283 /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an
2284 /// if statement) to the specified blocks. Based on the condition, this might
2285 /// try to simplify the codegen of the conditional based on the branch.
Chris Lattner9bc47e22008-11-12 07:46:33 +00002286 void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock,
Daniel Dunbar4bc04552008-11-12 10:12:14 +00002287 llvm::BasicBlock *FalseBlock);
Mike Stumpbe07f602009-12-14 21:58:14 +00002288
Mike Stump15037ca2009-12-15 00:35:12 +00002289 /// getTrapBB - Create a basic block that will call the trap intrinsic. We'll
2290 /// generate a branch around the created basic block as necessary.
Chris Lattner6c552c12010-07-20 20:19:24 +00002291 llvm::BasicBlock *getTrapBB();
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002292
Anders Carlsson21c9ad92010-03-30 03:27:09 +00002293 /// EmitCallArg - Emit a single call argument.
John McCall413ebdb2011-03-11 20:59:21 +00002294 void EmitCallArg(CallArgList &args, const Expr *E, QualType ArgType);
Anders Carlsson21c9ad92010-03-30 03:27:09 +00002295
John McCall27360712010-05-26 22:34:26 +00002296 /// EmitDelegateCallArg - We are performing a delegate call; that
2297 /// is, the current function is delegating to another one. Produce
2298 /// a r-value suitable for passing the given parameter.
John McCall413ebdb2011-03-11 20:59:21 +00002299 void EmitDelegateCallArg(CallArgList &args, const VarDecl *param);
John McCall27360712010-05-26 22:34:26 +00002300
Chris Lattner31a09842008-11-12 08:04:58 +00002301private:
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00002302 void EmitReturnOfRValue(RValue RV, QualType Ty);
2303
Daniel Dunbar56273772008-09-17 00:51:38 +00002304 /// ExpandTypeFromArgs - Reconstruct a structure of type \arg Ty
2305 /// from function arguments into \arg Dst. See ABIArgInfo::Expand.
2306 ///
2307 /// \param AI - The first function argument of the expansion.
2308 /// \return The argument following the last expanded function
2309 /// argument.
Mike Stump0dd9e882009-02-08 23:14:22 +00002310 llvm::Function::arg_iterator
Daniel Dunbar56273772008-09-17 00:51:38 +00002311 ExpandTypeFromArgs(QualType Ty, LValue Dst,
2312 llvm::Function::arg_iterator AI);
2313
Mike Stump0dd9e882009-02-08 23:14:22 +00002314 /// ExpandTypeToArgs - Expand an RValue \arg Src, with the LLVM type for \arg
2315 /// Ty, into individual arguments on the provided vector \arg Args. See
2316 /// ABIArgInfo::Expand.
2317 void ExpandTypeToArgs(QualType Ty, RValue Src,
Chris Lattner811bf362011-07-12 06:29:11 +00002318 llvm::SmallVector<llvm::Value*, 16> &Args,
2319 llvm::FunctionType *IRFuncTy);
Anders Carlssonc8c7b182009-01-11 19:40:10 +00002320
Mike Stump1eb44332009-09-09 15:08:12 +00002321 llvm::Value* EmitAsmInput(const AsmStmt &S,
Daniel Dunbarb84e8a62009-05-04 06:56:16 +00002322 const TargetInfo::ConstraintInfo &Info,
Anders Carlssonc8c7b182009-01-11 19:40:10 +00002323 const Expr *InputExpr, std::string &ConstraintStr);
Mike Stump0dd9e882009-02-08 23:14:22 +00002324
Eli Friedman6d7cfd72010-07-16 00:55:21 +00002325 llvm::Value* EmitAsmInputLValue(const AsmStmt &S,
2326 const TargetInfo::ConstraintInfo &Info,
2327 LValue InputValue, QualType InputType,
2328 std::string &ConstraintStr);
2329
Anders Carlsson0139bb92009-04-08 20:47:54 +00002330 /// EmitCallArgs - Emit call arguments for a function.
Mike Stump1eb44332009-09-09 15:08:12 +00002331 /// The CallArgTypeInfo parameter is used for iterating over the known
Anders Carlssonaf23f692009-04-18 20:20:22 +00002332 /// argument types of the function being called.
2333 template<typename T>
2334 void EmitCallArgs(CallArgList& Args, const T* CallArgTypeInfo,
Anders Carlsson0139bb92009-04-08 20:47:54 +00002335 CallExpr::const_arg_iterator ArgBeg,
Anders Carlssonaf23f692009-04-18 20:20:22 +00002336 CallExpr::const_arg_iterator ArgEnd) {
2337 CallExpr::const_arg_iterator Arg = ArgBeg;
Anders Carlsson0139bb92009-04-08 20:47:54 +00002338
Anders Carlssonaf23f692009-04-18 20:20:22 +00002339 // First, use the argument types that the type info knows about
2340 if (CallArgTypeInfo) {
2341 for (typename T::arg_type_iterator I = CallArgTypeInfo->arg_type_begin(),
2342 E = CallArgTypeInfo->arg_type_end(); I != E; ++I, ++Arg) {
Eli Friedman44b0a3e2009-11-18 03:42:04 +00002343 assert(Arg != ArgEnd && "Running over edge of argument list!");
Anders Carlssonaf23f692009-04-18 20:20:22 +00002344 QualType ArgType = *I;
Fariborz Jahanian745da3a2010-09-24 17:30:16 +00002345#ifndef NDEBUG
2346 QualType ActualArgType = Arg->getType();
2347 if (ArgType->isPointerType() && ActualArgType->isPointerType()) {
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002348 QualType ActualBaseType =
Fariborz Jahanian745da3a2010-09-24 17:30:16 +00002349 ActualArgType->getAs<PointerType>()->getPointeeType();
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002350 QualType ArgBaseType =
Fariborz Jahanian745da3a2010-09-24 17:30:16 +00002351 ArgType->getAs<PointerType>()->getPointeeType();
2352 if (ArgBaseType->isVariableArrayType()) {
2353 if (const VariableArrayType *VAT =
2354 getContext().getAsVariableArrayType(ActualBaseType)) {
2355 if (!VAT->getSizeExpr())
2356 ActualArgType = ArgType;
2357 }
2358 }
2359 }
Anders Carlssonaf23f692009-04-18 20:20:22 +00002360 assert(getContext().getCanonicalType(ArgType.getNonReferenceType()).
Mike Stump1eb44332009-09-09 15:08:12 +00002361 getTypePtr() ==
Fariborz Jahanian745da3a2010-09-24 17:30:16 +00002362 getContext().getCanonicalType(ActualArgType).getTypePtr() &&
Anders Carlssonaf23f692009-04-18 20:20:22 +00002363 "type mismatch in call argument!");
Fariborz Jahanian745da3a2010-09-24 17:30:16 +00002364#endif
John McCall413ebdb2011-03-11 20:59:21 +00002365 EmitCallArg(Args, *Arg, ArgType);
Anders Carlssonaf23f692009-04-18 20:20:22 +00002366 }
Mike Stump1eb44332009-09-09 15:08:12 +00002367
2368 // Either we've emitted all the call args, or we have a call to a
Anders Carlssonaf23f692009-04-18 20:20:22 +00002369 // variadic function.
Mike Stump1eb44332009-09-09 15:08:12 +00002370 assert((Arg == ArgEnd || CallArgTypeInfo->isVariadic()) &&
Anders Carlssonaf23f692009-04-18 20:20:22 +00002371 "Extra arguments in non-variadic function!");
Mike Stump1eb44332009-09-09 15:08:12 +00002372
Anders Carlssonaf23f692009-04-18 20:20:22 +00002373 }
Mike Stump1eb44332009-09-09 15:08:12 +00002374
Anders Carlssonaf23f692009-04-18 20:20:22 +00002375 // If we still have any arguments, emit them using the type of the argument.
John McCall413ebdb2011-03-11 20:59:21 +00002376 for (; Arg != ArgEnd; ++Arg)
2377 EmitCallArg(Args, *Arg, Arg->getType());
Anders Carlssonaf23f692009-04-18 20:20:22 +00002378 }
John McCall492c4f92010-03-03 04:15:11 +00002379
2380 const TargetCodeGenInfo &getTargetHooks() const {
2381 return CGM.getTargetCodeGenInfo();
2382 }
John McCall744016d2010-07-06 23:57:41 +00002383
2384 void EmitDeclMetadata();
John McCallf0c11f72011-03-31 08:03:29 +00002385
2386 CodeGenModule::ByrefHelpers *
2387 buildByrefHelpers(const llvm::StructType &byrefType,
2388 const AutoVarEmission &emission);
Reid Spencer5f016e22007-07-11 17:01:13 +00002389};
Mike Stump1eb44332009-09-09 15:08:12 +00002390
John McCall150b4622011-01-26 04:00:11 +00002391/// Helper class with most of the code for saving a value for a
2392/// conditional expression cleanup.
John McCall804b8072011-01-28 10:53:53 +00002393struct DominatingLLVMValue {
John McCall150b4622011-01-26 04:00:11 +00002394 typedef llvm::PointerIntPair<llvm::Value*, 1, bool> saved_type;
2395
2396 /// Answer whether the given value needs extra work to be saved.
2397 static bool needsSaving(llvm::Value *value) {
2398 // If it's not an instruction, we don't need to save.
2399 if (!isa<llvm::Instruction>(value)) return false;
2400
2401 // If it's an instruction in the entry block, we don't need to save.
2402 llvm::BasicBlock *block = cast<llvm::Instruction>(value)->getParent();
2403 return (block != &block->getParent()->getEntryBlock());
2404 }
2405
2406 /// Try to save the given value.
2407 static saved_type save(CodeGenFunction &CGF, llvm::Value *value) {
2408 if (!needsSaving(value)) return saved_type(value, false);
2409
2410 // Otherwise we need an alloca.
2411 llvm::Value *alloca =
2412 CGF.CreateTempAlloca(value->getType(), "cond-cleanup.save");
2413 CGF.Builder.CreateStore(value, alloca);
2414
2415 return saved_type(alloca, true);
2416 }
2417
2418 static llvm::Value *restore(CodeGenFunction &CGF, saved_type value) {
2419 if (!value.getInt()) return value.getPointer();
2420 return CGF.Builder.CreateLoad(value.getPointer());
2421 }
2422};
2423
John McCall804b8072011-01-28 10:53:53 +00002424/// A partial specialization of DominatingValue for llvm::Values that
2425/// might be llvm::Instructions.
2426template <class T> struct DominatingPointer<T,true> : DominatingLLVMValue {
2427 typedef T *type;
John McCall150b4622011-01-26 04:00:11 +00002428 static type restore(CodeGenFunction &CGF, saved_type value) {
John McCall804b8072011-01-28 10:53:53 +00002429 return static_cast<T*>(DominatingLLVMValue::restore(CGF, value));
2430 }
2431};
2432
2433/// A specialization of DominatingValue for RValue.
2434template <> struct DominatingValue<RValue> {
2435 typedef RValue type;
2436 class saved_type {
2437 enum Kind { ScalarLiteral, ScalarAddress, AggregateLiteral,
2438 AggregateAddress, ComplexAddress };
2439
2440 llvm::Value *Value;
2441 Kind K;
2442 saved_type(llvm::Value *v, Kind k) : Value(v), K(k) {}
2443
2444 public:
2445 static bool needsSaving(RValue value);
2446 static saved_type save(CodeGenFunction &CGF, RValue value);
2447 RValue restore(CodeGenFunction &CGF);
2448
2449 // implementations in CGExprCXX.cpp
2450 };
2451
2452 static bool needsSaving(type value) {
2453 return saved_type::needsSaving(value);
2454 }
2455 static saved_type save(CodeGenFunction &CGF, type value) {
2456 return saved_type::save(CGF, value);
2457 }
2458 static type restore(CodeGenFunction &CGF, saved_type value) {
2459 return value.restore(CGF);
John McCall150b4622011-01-26 04:00:11 +00002460 }
2461};
2462
Reid Spencer5f016e22007-07-11 17:01:13 +00002463} // end namespace CodeGen
2464} // end namespace clang
2465
2466#endif