blob: d52a4812690a0626931efa066ed89032ff4098b1 [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"
Peter Collingbourne14110472011-01-13 18:57:25 +000021#include "clang/Basic/ABI.h"
Chris Lattner481769b2009-03-31 22:17:44 +000022#include "clang/Basic/TargetInfo.h"
23#include "llvm/ADT/DenseMap.h"
24#include "llvm/ADT/SmallVector.h"
25#include "llvm/Support/ValueHandle.h"
Owen Anderson69243822009-07-13 04:10:07 +000026#include "CodeGenModule.h"
Daniel Dunbar45d196b2008-11-01 01:53:16 +000027#include "CGBuilder.h"
Daniel Dunbar0dbe2272008-09-08 21:33:45 +000028#include "CGCall.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;
Anders Carlsson6815e942009-09-27 18:58:34 +000046 class CXXTryStmt;
Reid Spencer5f016e22007-07-11 17:01:13 +000047 class Decl;
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000048 class EnumConstantDecl;
Reid Spencer5f016e22007-07-11 17:01:13 +000049 class FunctionDecl;
Douglas Gregor72564e72009-02-26 23:50:07 +000050 class FunctionProtoType;
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000051 class LabelStmt;
Fariborz Jahanian679a5022009-01-10 21:06:09 +000052 class ObjCContainerDecl;
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +000053 class ObjCInterfaceDecl;
54 class ObjCIvarDecl;
Chris Lattner391d77a2008-03-30 23:03:07 +000055 class ObjCMethodDecl;
Fariborz Jahanianfef30b52008-12-09 20:23:04 +000056 class ObjCImplementationDecl;
Daniel Dunbaraf05bb92008-08-26 08:29:31 +000057 class ObjCPropertyImplDecl;
Reid Spencer5f016e22007-07-11 17:01:13 +000058 class TargetInfo;
John McCall492c4f92010-03-03 04:15:11 +000059 class TargetCodeGenInfo;
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000060 class VarDecl;
Chris Lattner16f00492009-04-26 01:32:48 +000061 class ObjCForCollectionStmt;
62 class ObjCAtTryStmt;
63 class ObjCAtThrowStmt;
64 class ObjCAtSynchronizedStmt;
Devang Patelb84a06e2007-10-23 02:10:49 +000065
Reid Spencer5f016e22007-07-11 17:01:13 +000066namespace CodeGen {
Devang Patelb84a06e2007-10-23 02:10:49 +000067 class CodeGenTypes;
Anders Carlssone896d982009-02-13 08:11:52 +000068 class CGDebugInfo;
Daniel Dunbarbb36d332009-02-02 21:43:58 +000069 class CGFunctionInfo;
Mike Stump0dd9e882009-02-08 23:14:22 +000070 class CGRecordLayout;
John McCallee504292010-05-21 04:11:14 +000071 class CGBlockInfo;
John McCall4c40d982010-08-31 07:33:07 +000072 class CGCXXABI;
John McCalld16c2cf2011-02-08 08:22:06 +000073 class BlockFlags;
74 class BlockFieldFlags;
Mike Stump0dd9e882009-02-08 23:14:22 +000075
John McCallf1549f62010-07-06 01:34:17 +000076/// A branch fixup. These are required when emitting a goto to a
77/// label which hasn't been emitted yet. The goto is optimistically
78/// emitted as a branch to the basic block for the label, and (if it
79/// occurs in a scope with non-trivial cleanups) a fixup is added to
80/// the innermost cleanup. When a (normal) cleanup is popped, any
81/// unresolved fixups in that scope are threaded through the cleanup.
82struct BranchFixup {
John McCallff8e1152010-07-23 21:56:41 +000083 /// The block containing the terminator which needs to be modified
84 /// into a switch if this fixup is resolved into the current scope.
85 /// If null, LatestBranch points directly to the destination.
86 llvm::BasicBlock *OptimisticBranchBlock;
John McCallf1549f62010-07-06 01:34:17 +000087
John McCallff8e1152010-07-23 21:56:41 +000088 /// The ultimate destination of the branch.
John McCallf1549f62010-07-06 01:34:17 +000089 ///
90 /// This can be set to null to indicate that this fixup was
91 /// successfully resolved.
92 llvm::BasicBlock *Destination;
93
John McCallff8e1152010-07-23 21:56:41 +000094 /// The destination index value.
95 unsigned DestinationIndex;
96
97 /// The initial branch of the fixup.
98 llvm::BranchInst *InitialBranch;
John McCallf1549f62010-07-06 01:34:17 +000099};
100
John McCall804b8072011-01-28 10:53:53 +0000101template <class T> struct InvariantValue {
John McCall150b4622011-01-26 04:00:11 +0000102 typedef T type;
103 typedef T saved_type;
104 static bool needsSaving(type value) { return false; }
105 static saved_type save(CodeGenFunction &CGF, type value) { return value; }
106 static type restore(CodeGenFunction &CGF, saved_type value) { return value; }
107};
John McCall804b8072011-01-28 10:53:53 +0000108
109/// A metaprogramming class for ensuring that a value will dominate an
110/// arbitrary position in a function.
111template <class T> struct DominatingValue : InvariantValue<T> {};
112
113template <class T, bool mightBeInstruction =
114 llvm::is_base_of<llvm::Value, T>::value &&
115 !llvm::is_base_of<llvm::Constant, T>::value &&
116 !llvm::is_base_of<llvm::BasicBlock, T>::value>
117struct DominatingPointer;
118template <class T> struct DominatingPointer<T,false> : InvariantValue<T*> {};
119// template <class T> struct DominatingPointer<T,true> at end of file
120
121template <class T> struct DominatingValue<T*> : DominatingPointer<T> {};
John McCall150b4622011-01-26 04:00:11 +0000122
John McCallcd2d2b72010-08-13 21:20:51 +0000123enum CleanupKind {
124 EHCleanup = 0x1,
125 NormalCleanup = 0x2,
126 NormalAndEHCleanup = EHCleanup | NormalCleanup,
127
128 InactiveCleanup = 0x4,
129 InactiveEHCleanup = EHCleanup | InactiveCleanup,
130 InactiveNormalCleanup = NormalCleanup | InactiveCleanup,
131 InactiveNormalAndEHCleanup = NormalAndEHCleanup | InactiveCleanup
132};
John McCallda65ea82010-07-13 20:32:21 +0000133
John McCallf1549f62010-07-06 01:34:17 +0000134/// A stack of scopes which respond to exceptions, including cleanups
135/// and catch blocks.
136class EHScopeStack {
137public:
138 /// A saved depth on the scope stack. This is necessary because
139 /// pushing scopes onto the stack invalidates iterators.
140 class stable_iterator {
141 friend class EHScopeStack;
142
143 /// Offset from StartOfData to EndOfBuffer.
144 ptrdiff_t Size;
145
146 stable_iterator(ptrdiff_t Size) : Size(Size) {}
147
148 public:
149 static stable_iterator invalid() { return stable_iterator(-1); }
150 stable_iterator() : Size(-1) {}
151
152 bool isValid() const { return Size >= 0; }
153
John McCall838d7962010-08-14 07:46:19 +0000154 /// Returns true if this scope encloses I.
155 /// Returns false if I is invalid.
156 /// This scope must be valid.
John McCallff8e1152010-07-23 21:56:41 +0000157 bool encloses(stable_iterator I) const { return Size <= I.Size; }
John McCall838d7962010-08-14 07:46:19 +0000158
159 /// Returns true if this scope strictly encloses I: that is,
160 /// if it encloses I and is not I.
161 /// Returns false is I is invalid.
162 /// This scope must be valid.
John McCallff8e1152010-07-23 21:56:41 +0000163 bool strictlyEncloses(stable_iterator I) const { return Size < I.Size; }
John McCall1bda6622010-07-21 00:40:03 +0000164
John McCallf1549f62010-07-06 01:34:17 +0000165 friend bool operator==(stable_iterator A, stable_iterator B) {
166 return A.Size == B.Size;
167 }
168 friend bool operator!=(stable_iterator A, stable_iterator B) {
169 return A.Size != B.Size;
170 }
171 };
172
John McCall1f0fca52010-07-21 07:22:38 +0000173 /// Information for lazily generating a cleanup. Subclasses must be
174 /// POD-like: cleanups will not be destructed, and they will be
175 /// allocated on the cleanup stack and freely copied and moved
176 /// around.
John McCallda65ea82010-07-13 20:32:21 +0000177 ///
John McCall1f0fca52010-07-21 07:22:38 +0000178 /// Cleanup implementations should generally be declared in an
John McCallda65ea82010-07-13 20:32:21 +0000179 /// anonymous namespace.
John McCall1f0fca52010-07-21 07:22:38 +0000180 class Cleanup {
John McCallda65ea82010-07-13 20:32:21 +0000181 public:
John McCall3e29f962010-07-13 23:19:49 +0000182 // Anchor the construction vtable. We use the destructor because
183 // gcc gives an obnoxious warning if there are virtual methods
184 // with an accessible non-virtual destructor. Unfortunately,
185 // declaring this destructor makes it non-trivial, but there
186 // doesn't seem to be any other way around this warning.
187 //
188 // This destructor will never be called.
John McCall1f0fca52010-07-21 07:22:38 +0000189 virtual ~Cleanup();
John McCall3e29f962010-07-13 23:19:49 +0000190
John McCallda65ea82010-07-13 20:32:21 +0000191 /// Emit the cleanup. For normal cleanups, this is run in the
192 /// same EH context as when the cleanup was pushed, i.e. the
193 /// immediately-enclosing context of the cleanup scope. For
194 /// EH cleanups, this is run in a terminate context.
195 ///
196 // \param IsForEHCleanup true if this is for an EH cleanup, false
197 /// if for a normal cleanup.
198 virtual void Emit(CodeGenFunction &CGF, bool IsForEHCleanup) = 0;
199 };
200
John McCall150b4622011-01-26 04:00:11 +0000201 /// UnconditionalCleanupN stores its N parameters and just passes
202 /// them to the real cleanup function.
John McCall3ad32c82011-01-28 08:37:24 +0000203 template <class T, class A0>
204 class UnconditionalCleanup1 : public Cleanup {
205 A0 a0;
206 public:
207 UnconditionalCleanup1(A0 a0) : a0(a0) {}
208 void Emit(CodeGenFunction &CGF, bool IsForEHCleanup) {
209 T::Emit(CGF, IsForEHCleanup, a0);
210 }
211 };
212
John McCall150b4622011-01-26 04:00:11 +0000213 template <class T, class A0, class A1>
214 class UnconditionalCleanup2 : public Cleanup {
215 A0 a0; A1 a1;
John McCall4bbcbda2011-01-26 19:15:39 +0000216 public:
John McCall150b4622011-01-26 04:00:11 +0000217 UnconditionalCleanup2(A0 a0, A1 a1) : a0(a0), a1(a1) {}
218 void Emit(CodeGenFunction &CGF, bool IsForEHCleanup) {
219 T::Emit(CGF, IsForEHCleanup, a0, a1);
220 }
221 };
222
223 /// ConditionalCleanupN stores the saved form of its N parameters,
224 /// then restores them and performs the cleanup.
John McCall3ad32c82011-01-28 08:37:24 +0000225 template <class T, class A0>
226 class ConditionalCleanup1 : public Cleanup {
John McCall804b8072011-01-28 10:53:53 +0000227 typedef typename DominatingValue<A0>::saved_type A0_saved;
John McCall3ad32c82011-01-28 08:37:24 +0000228 A0_saved a0_saved;
229
230 void Emit(CodeGenFunction &CGF, bool IsForEHCleanup) {
John McCall804b8072011-01-28 10:53:53 +0000231 A0 a0 = DominatingValue<A0>::restore(CGF, a0_saved);
John McCall3ad32c82011-01-28 08:37:24 +0000232 T::Emit(CGF, IsForEHCleanup, a0);
233 }
234
235 public:
236 ConditionalCleanup1(A0_saved a0)
237 : a0_saved(a0) {}
238 };
239
John McCall150b4622011-01-26 04:00:11 +0000240 template <class T, class A0, class A1>
John McCall3ad32c82011-01-28 08:37:24 +0000241 class ConditionalCleanup2 : public Cleanup {
John McCall804b8072011-01-28 10:53:53 +0000242 typedef typename DominatingValue<A0>::saved_type A0_saved;
243 typedef typename DominatingValue<A1>::saved_type A1_saved;
John McCall4bbcbda2011-01-26 19:15:39 +0000244 A0_saved a0_saved;
245 A1_saved a1_saved;
John McCall150b4622011-01-26 04:00:11 +0000246
John McCall3ad32c82011-01-28 08:37:24 +0000247 void Emit(CodeGenFunction &CGF, bool IsForEHCleanup) {
John McCall804b8072011-01-28 10:53:53 +0000248 A0 a0 = DominatingValue<A0>::restore(CGF, a0_saved);
249 A1 a1 = DominatingValue<A1>::restore(CGF, a1_saved);
John McCall150b4622011-01-26 04:00:11 +0000250 T::Emit(CGF, IsForEHCleanup, a0, a1);
251 }
252
253 public:
John McCall3ad32c82011-01-28 08:37:24 +0000254 ConditionalCleanup2(A0_saved a0, A1_saved a1)
255 : a0_saved(a0), a1_saved(a1) {}
John McCall150b4622011-01-26 04:00:11 +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
Daniel Dunbar5ca20842008-09-09 21:00:17 +0000570 /// ReturnBlock - Unified return block.
John McCallf1549f62010-07-06 01:34:17 +0000571 JumpDest ReturnBlock;
572
Mike Stump0dd9e882009-02-08 23:14:22 +0000573 /// ReturnValue - The temporary alloca to hold the return value. This is null
574 /// iff the function has no return value.
Eli Friedmanb17daf92009-12-04 02:43:40 +0000575 llvm::Value *ReturnValue;
Mike Stump0dd9e882009-02-08 23:14:22 +0000576
John McCallff8e1152010-07-23 21:56:41 +0000577 /// RethrowBlock - Unified rethrow block.
578 UnwindDest RethrowBlock;
579
Reid Spencer5f016e22007-07-11 17:01:13 +0000580 /// AllocaInsertPoint - This is an instruction in the entry block before which
581 /// we prefer to insert allocas.
Chris Lattner481769b2009-03-31 22:17:44 +0000582 llvm::AssertingVH<llvm::Instruction> AllocaInsertPt;
Daniel Dunbar0ffb1252008-08-04 16:51:22 +0000583
Mike Stumpd88ea562009-12-09 03:35:49 +0000584 bool Exceptions;
Mike Stump9c276ae2009-12-12 01:27:46 +0000585 bool CatchUndefined;
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000586
John McCalld16c2cf2011-02-08 08:22:06 +0000587 const CodeGen::CGBlockInfo *BlockInfo;
588 llvm::Value *BlockPointer;
589
Douglas Gregor3d91bbc2010-05-17 15:52:46 +0000590 /// \brief A mapping from NRVO variables to the flags used to indicate
591 /// when the NRVO has been applied to this variable.
592 llvm::DenseMap<const VarDecl *, llvm::Value *> NRVOFlags;
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000593
Fariborz Jahanianaf9b9682010-09-17 15:51:28 +0000594 /// \brief A mapping from 'Save' expression in a conditional expression
595 /// to the IR for this expression. Used to implement IR gen. for Gnu
596 /// extension's missing LHS expression in a conditional operator expression.
597 llvm::DenseMap<const Expr *, llvm::Value *> ConditionalSaveExprs;
Fariborz Jahanianaa3b57e2010-09-20 23:50:22 +0000598 llvm::DenseMap<const Expr *, ComplexPairTy> ConditionalSaveComplexExprs;
Fariborz Jahanian0b787102010-09-21 18:32:21 +0000599 llvm::DenseMap<const Expr *, LValue> ConditionalSaveLValueExprs;
John McCallf1549f62010-07-06 01:34:17 +0000600
601 EHScopeStack EHStack;
602
John McCallff8e1152010-07-23 21:56:41 +0000603 /// i32s containing the indexes of the cleanup destinations.
604 llvm::AllocaInst *NormalCleanupDest;
605 llvm::AllocaInst *EHCleanupDest;
606
607 unsigned NextCleanupDestIndex;
608
John McCallf1549f62010-07-06 01:34:17 +0000609 /// The exception slot. All landing pads write the current
610 /// exception pointer into this alloca.
611 llvm::Value *ExceptionSlot;
612
613 /// Emits a landing pad for the current EH stack.
614 llvm::BasicBlock *EmitLandingPad();
615
616 llvm::BasicBlock *getInvokeDestImpl();
617
John McCall3ad32c82011-01-28 08:37:24 +0000618 /// Set up the last cleaup that was pushed as a conditional
619 /// full-expression cleanup.
620 void initFullExprCleanup();
John McCall150b4622011-01-26 04:00:11 +0000621
622 template <class T>
John McCall804b8072011-01-28 10:53:53 +0000623 typename DominatingValue<T>::saved_type saveValueInCond(T value) {
624 return DominatingValue<T>::save(*this, value);
John McCall150b4622011-01-26 04:00:11 +0000625 }
626
Daniel Dunbar18ccc772008-09-28 01:03:14 +0000627public:
Anders Carlssonfa1f7562009-02-10 06:07:49 +0000628 /// ObjCEHValueStack - Stack of Objective-C exception values, used for
629 /// rethrows.
Anders Carlsson273558f2009-02-07 21:37:21 +0000630 llvm::SmallVector<llvm::Value*, 8> ObjCEHValueStack;
Mike Stump0dd9e882009-02-08 23:14:22 +0000631
John McCallf1549f62010-07-06 01:34:17 +0000632 // A struct holding information about a finally block's IR
633 // generation. For now, doesn't actually hold anything.
634 struct FinallyInfo {
Anders Carlssonbb66f9f2009-02-08 07:46:24 +0000635 };
636
John McCallf1549f62010-07-06 01:34:17 +0000637 FinallyInfo EnterFinallyBlock(const Stmt *Stmt,
638 llvm::Constant *BeginCatchFn,
639 llvm::Constant *EndCatchFn,
640 llvm::Constant *RethrowFn);
641 void ExitFinallyBlock(FinallyInfo &FinallyInfo);
Mike Stumpd88ea562009-12-09 03:35:49 +0000642
John McCall150b4622011-01-26 04:00:11 +0000643 /// pushFullExprCleanup - Push a cleanup to be run at the end of the
644 /// current full-expression. Safe against the possibility that
645 /// we're currently inside a conditionally-evaluated expression.
John McCall3ad32c82011-01-28 08:37:24 +0000646 template <class T, class A0>
647 void pushFullExprCleanup(CleanupKind kind, A0 a0) {
648 // If we're not in a conditional branch, or if none of the
649 // arguments requires saving, then use the unconditional cleanup.
650 if (!isInConditionalBranch()) {
651 typedef EHScopeStack::UnconditionalCleanup1<T, A0> CleanupType;
652 return EHStack.pushCleanup<CleanupType>(kind, a0);
653 }
654
John McCall804b8072011-01-28 10:53:53 +0000655 typename DominatingValue<A0>::saved_type a0_saved = saveValueInCond(a0);
John McCall3ad32c82011-01-28 08:37:24 +0000656
657 typedef EHScopeStack::ConditionalCleanup1<T, A0> CleanupType;
658 EHStack.pushCleanup<CleanupType>(kind, a0_saved);
659 initFullExprCleanup();
660 }
661
662 /// pushFullExprCleanup - Push a cleanup to be run at the end of the
663 /// current full-expression. Safe against the possibility that
664 /// we're currently inside a conditionally-evaluated expression.
John McCall150b4622011-01-26 04:00:11 +0000665 template <class T, class A0, class A1>
666 void pushFullExprCleanup(CleanupKind kind, A0 a0, A1 a1) {
667 // If we're not in a conditional branch, or if none of the
668 // arguments requires saving, then use the unconditional cleanup.
John McCall3ad32c82011-01-28 08:37:24 +0000669 if (!isInConditionalBranch()) {
John McCall150b4622011-01-26 04:00:11 +0000670 typedef EHScopeStack::UnconditionalCleanup2<T, A0, A1> CleanupType;
671 return EHStack.pushCleanup<CleanupType>(kind, a0, a1);
672 }
673
John McCall804b8072011-01-28 10:53:53 +0000674 typename DominatingValue<A0>::saved_type a0_saved = saveValueInCond(a0);
675 typename DominatingValue<A1>::saved_type a1_saved = saveValueInCond(a1);
John McCall150b4622011-01-26 04:00:11 +0000676
677 typedef EHScopeStack::ConditionalCleanup2<T, A0, A1> CleanupType;
John McCall3ad32c82011-01-28 08:37:24 +0000678 EHStack.pushCleanup<CleanupType>(kind, a0_saved, a1_saved);
679 initFullExprCleanup();
John McCall150b4622011-01-26 04:00:11 +0000680 }
681
John McCallf1549f62010-07-06 01:34:17 +0000682 /// PushDestructorCleanup - Push a cleanup to call the
683 /// complete-object destructor of an object of the given type at the
684 /// given address. Does nothing if T is not a C++ class type with a
685 /// non-trivial destructor.
686 void PushDestructorCleanup(QualType T, llvm::Value *Addr);
687
John McCall81407d42010-07-21 06:29:51 +0000688 /// PushDestructorCleanup - Push a cleanup to call the
689 /// complete-object variant of the given destructor on the object at
690 /// the given address.
691 void PushDestructorCleanup(const CXXDestructorDecl *Dtor,
692 llvm::Value *Addr);
693
John McCallf1549f62010-07-06 01:34:17 +0000694 /// PopCleanupBlock - Will pop the cleanup entry on the stack and
695 /// process all branch fixups.
John McCallff8e1152010-07-23 21:56:41 +0000696 void PopCleanupBlock(bool FallThroughIsBranchThrough = false);
John McCallf1549f62010-07-06 01:34:17 +0000697
John McCall7d8647f2010-09-14 07:57:04 +0000698 /// DeactivateCleanupBlock - Deactivates the given cleanup block.
699 /// The block cannot be reactivated. Pops it if it's the top of the
700 /// stack.
701 void DeactivateCleanupBlock(EHScopeStack::stable_iterator Cleanup);
702
703 /// ActivateCleanupBlock - Activates an initially-inactive cleanup.
704 /// Cannot be used to resurrect a deactivated cleanup.
705 void ActivateCleanupBlock(EHScopeStack::stable_iterator Cleanup);
John McCallcd2d2b72010-08-13 21:20:51 +0000706
John McCallf1549f62010-07-06 01:34:17 +0000707 /// \brief Enters a new scope for capturing cleanups, all of which
708 /// will be executed once the scope is exited.
709 class RunCleanupsScope {
Douglas Gregor01234bb2009-11-24 16:43:22 +0000710 CodeGenFunction& CGF;
John McCallf1549f62010-07-06 01:34:17 +0000711 EHScopeStack::stable_iterator CleanupStackDepth;
Douglas Gregor01234bb2009-11-24 16:43:22 +0000712 bool OldDidCallStackSave;
Douglas Gregor5656e142009-11-24 21:15:44 +0000713 bool PerformCleanup;
Douglas Gregor01234bb2009-11-24 16:43:22 +0000714
John McCallf1549f62010-07-06 01:34:17 +0000715 RunCleanupsScope(const RunCleanupsScope &); // DO NOT IMPLEMENT
716 RunCleanupsScope &operator=(const RunCleanupsScope &); // DO NOT IMPLEMENT
Douglas Gregor01234bb2009-11-24 16:43:22 +0000717
718 public:
719 /// \brief Enter a new cleanup scope.
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000720 explicit RunCleanupsScope(CodeGenFunction &CGF)
721 : CGF(CGF), PerformCleanup(true)
Douglas Gregor5656e142009-11-24 21:15:44 +0000722 {
John McCallf1549f62010-07-06 01:34:17 +0000723 CleanupStackDepth = CGF.EHStack.stable_begin();
Douglas Gregor01234bb2009-11-24 16:43:22 +0000724 OldDidCallStackSave = CGF.DidCallStackSave;
Argyrios Kyrtzidis4ada2ca2010-09-14 00:42:34 +0000725 CGF.DidCallStackSave = false;
Douglas Gregor01234bb2009-11-24 16:43:22 +0000726 }
727
728 /// \brief Exit this cleanup scope, emitting any accumulated
729 /// cleanups.
John McCallf1549f62010-07-06 01:34:17 +0000730 ~RunCleanupsScope() {
Douglas Gregor5656e142009-11-24 21:15:44 +0000731 if (PerformCleanup) {
732 CGF.DidCallStackSave = OldDidCallStackSave;
John McCallf1549f62010-07-06 01:34:17 +0000733 CGF.PopCleanupBlocks(CleanupStackDepth);
Douglas Gregor5656e142009-11-24 21:15:44 +0000734 }
735 }
736
737 /// \brief Determine whether this scope requires any cleanups.
738 bool requiresCleanups() const {
John McCallf1549f62010-07-06 01:34:17 +0000739 return CGF.EHStack.stable_begin() != CleanupStackDepth;
Douglas Gregor5656e142009-11-24 21:15:44 +0000740 }
741
742 /// \brief Force the emission of cleanups now, instead of waiting
743 /// until this object is destroyed.
744 void ForceCleanup() {
745 assert(PerformCleanup && "Already forced cleanup");
Douglas Gregor01234bb2009-11-24 16:43:22 +0000746 CGF.DidCallStackSave = OldDidCallStackSave;
John McCallf1549f62010-07-06 01:34:17 +0000747 CGF.PopCleanupBlocks(CleanupStackDepth);
Douglas Gregor5656e142009-11-24 21:15:44 +0000748 PerformCleanup = false;
Douglas Gregor01234bb2009-11-24 16:43:22 +0000749 }
750 };
751
Anders Carlsson44ec82b2010-03-30 03:14:41 +0000752
John McCallf1549f62010-07-06 01:34:17 +0000753 /// PopCleanupBlocks - Takes the old cleanup stack size and emits
754 /// the cleanup blocks that have been added.
755 void PopCleanupBlocks(EHScopeStack::stable_iterator OldCleanupStackSize);
Anders Carlsson44ec82b2010-03-30 03:14:41 +0000756
John McCallff8e1152010-07-23 21:56:41 +0000757 void ResolveBranchFixups(llvm::BasicBlock *Target);
758
John McCallf1549f62010-07-06 01:34:17 +0000759 /// The given basic block lies in the current EH scope, but may be a
760 /// target of a potentially scope-crossing jump; get a stable handle
761 /// to which we can perform this jump later.
John McCallff8e1152010-07-23 21:56:41 +0000762 JumpDest getJumpDestInCurrentScope(llvm::BasicBlock *Target) {
John McCall413e6772010-07-28 01:07:35 +0000763 return JumpDest(Target,
764 EHStack.getInnermostNormalCleanup(),
765 NextCleanupDestIndex++);
John McCallf1549f62010-07-06 01:34:17 +0000766 }
Anders Carlssonc71c8452009-02-07 23:50:39 +0000767
John McCallf1549f62010-07-06 01:34:17 +0000768 /// The given basic block lies in the current EH scope, but may be a
769 /// target of a potentially scope-crossing jump; get a stable handle
770 /// to which we can perform this jump later.
771 JumpDest getJumpDestInCurrentScope(const char *Name = 0) {
John McCallff8e1152010-07-23 21:56:41 +0000772 return getJumpDestInCurrentScope(createBasicBlock(Name));
John McCallf1549f62010-07-06 01:34:17 +0000773 }
774
775 /// EmitBranchThroughCleanup - Emit a branch from the current insert
776 /// block through the normal cleanup handling code (if any) and then
777 /// on to \arg Dest.
778 void EmitBranchThroughCleanup(JumpDest Dest);
779
780 /// EmitBranchThroughEHCleanup - Emit a branch from the current
781 /// insert block through the EH cleanup handling code (if any) and
782 /// then on to \arg Dest.
John McCallff8e1152010-07-23 21:56:41 +0000783 void EmitBranchThroughEHCleanup(UnwindDest Dest);
784
785 /// getRethrowDest - Returns the unified outermost-scope rethrow
786 /// destination.
787 UnwindDest getRethrowDest();
Mike Stump0dd9e882009-02-08 23:14:22 +0000788
John McCall150b4622011-01-26 04:00:11 +0000789 /// An object to manage conditionally-evaluated expressions.
790 class ConditionalEvaluation {
791 llvm::BasicBlock *StartBB;
Mike Stump1eb44332009-09-09 15:08:12 +0000792
John McCall150b4622011-01-26 04:00:11 +0000793 public:
794 ConditionalEvaluation(CodeGenFunction &CGF)
795 : StartBB(CGF.Builder.GetInsertBlock()) {}
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000796
John McCall150b4622011-01-26 04:00:11 +0000797 void begin(CodeGenFunction &CGF) {
798 assert(CGF.OutermostConditional != this);
799 if (!CGF.OutermostConditional)
800 CGF.OutermostConditional = this;
801 }
802
803 void end(CodeGenFunction &CGF) {
804 assert(CGF.OutermostConditional != 0);
805 if (CGF.OutermostConditional == this)
806 CGF.OutermostConditional = 0;
807 }
808
809 /// Returns a block which will be executed prior to each
810 /// evaluation of the conditional code.
811 llvm::BasicBlock *getStartingBlock() const {
812 return StartBB;
813 }
814 };
Mike Stump1eb44332009-09-09 15:08:12 +0000815
John McCall3019c442010-09-17 00:50:28 +0000816 /// isInConditionalBranch - Return true if we're currently emitting
817 /// one branch or the other of a conditional expression.
John McCall150b4622011-01-26 04:00:11 +0000818 bool isInConditionalBranch() const { return OutermostConditional != 0; }
819
820 /// An RAII object to record that we're evaluating a statement
821 /// expression.
822 class StmtExprEvaluation {
823 CodeGenFunction &CGF;
824
825 /// We have to save the outermost conditional: cleanups in a
826 /// statement expression aren't conditional just because the
827 /// StmtExpr is.
828 ConditionalEvaluation *SavedOutermostConditional;
829
830 public:
831 StmtExprEvaluation(CodeGenFunction &CGF)
832 : CGF(CGF), SavedOutermostConditional(CGF.OutermostConditional) {
833 CGF.OutermostConditional = 0;
834 }
835
836 ~StmtExprEvaluation() {
837 CGF.OutermostConditional = SavedOutermostConditional;
838 CGF.EnsureInsertPoint();
839 }
840 };
Fariborz Jahaniane2204552010-11-16 19:29:39 +0000841
842 /// getByrefValueFieldNumber - Given a declaration, returns the LLVM field
843 /// number that holds the value.
844 unsigned getByRefValueLLVMField(const ValueDecl *VD) const;
Fariborz Jahanian52a80e12011-01-26 23:08:27 +0000845
846 /// BuildBlockByrefAddress - Computes address location of the
847 /// variable which is declared as __block.
848 llvm::Value *BuildBlockByrefAddress(llvm::Value *BaseAddr,
849 const VarDecl *V);
Chris Lattner7f02f722007-08-24 05:35:26 +0000850private:
Chris Lattnerd9becd12009-10-28 23:59:40 +0000851 CGDebugInfo *DebugInfo;
Mike Stump09429b92009-02-17 17:00:02 +0000852
Mike Stumpf71d2322009-11-30 20:08:49 +0000853 /// IndirectBranch - The first time an indirect goto is seen we create a block
854 /// with an indirect branch. Every time we see the address of a label taken,
855 /// we add the label to the indirect goto. Every subsequent indirect goto is
856 /// codegen'd as a jump to the IndirectBranch's basic block.
Chris Lattnerd9becd12009-10-28 23:59:40 +0000857 llvm::IndirectBrInst *IndirectBranch;
Daniel Dunbar0ffb1252008-08-04 16:51:22 +0000858
Mike Stump0dd9e882009-02-08 23:14:22 +0000859 /// LocalDeclMap - This keeps track of the LLVM allocas or globals for local C
860 /// decls.
John McCall6b5a61b2011-02-07 10:33:21 +0000861 typedef llvm::DenseMap<const Decl*, llvm::Value*> DeclMapTy;
862 DeclMapTy LocalDeclMap;
Reid Spencer5f016e22007-07-11 17:01:13 +0000863
864 /// LabelMap - This keeps track of the LLVM basic block for each C label.
John McCallf1549f62010-07-06 01:34:17 +0000865 llvm::DenseMap<const LabelStmt*, JumpDest> LabelMap;
Mike Stump0dd9e882009-02-08 23:14:22 +0000866
Mike Stump0dd9e882009-02-08 23:14:22 +0000867 // BreakContinueStack - This keeps track of where break and continue
Anders Carlssone4b6d342009-02-10 05:52:02 +0000868 // statements should jump to.
Chris Lattnerda138702007-07-16 21:28:45 +0000869 struct BreakContinue {
John McCallf1549f62010-07-06 01:34:17 +0000870 BreakContinue(JumpDest Break, JumpDest Continue)
871 : BreakBlock(Break), ContinueBlock(Continue) {}
Mike Stump0dd9e882009-02-08 23:14:22 +0000872
John McCallf1549f62010-07-06 01:34:17 +0000873 JumpDest BreakBlock;
874 JumpDest ContinueBlock;
Mike Stump0dd9e882009-02-08 23:14:22 +0000875 };
Chris Lattnerda138702007-07-16 21:28:45 +0000876 llvm::SmallVector<BreakContinue, 8> BreakContinueStack;
Daniel Dunbar18ccc772008-09-28 01:03:14 +0000877
Mike Stump0dd9e882009-02-08 23:14:22 +0000878 /// SwitchInsn - This is nearest current switch instruction. It is null if if
879 /// current context is not in a switch.
Devang Patel51b09f22007-10-04 23:45:31 +0000880 llvm::SwitchInst *SwitchInsn;
881
Mike Stump0dd9e882009-02-08 23:14:22 +0000882 /// CaseRangeBlock - This block holds if condition check for last case
Devang Patel80fd5f92007-10-09 17:08:50 +0000883 /// statement range in current switch instruction.
Devang Patelc049e4f2007-10-08 20:57:48 +0000884 llvm::BasicBlock *CaseRangeBlock;
885
Mike Stump0dd9e882009-02-08 23:14:22 +0000886 // VLASizeMap - This keeps track of the associated size for each VLA type.
Eli Friedmanbbed6b92009-08-15 02:50:32 +0000887 // We track this by the size expression rather than the type itself because
888 // in certain situations, like a const qualifier applied to an VLA typedef,
889 // multiple VLA types can share the same size expression.
Mike Stump0dd9e882009-02-08 23:14:22 +0000890 // FIXME: Maybe this could be a stack of maps that is pushed/popped as we
891 // enter/leave scopes.
Eli Friedmanbbed6b92009-08-15 02:50:32 +0000892 llvm::DenseMap<const Expr*, llvm::Value*> VLASizeMap;
Mike Stump0dd9e882009-02-08 23:14:22 +0000893
Anders Carlsson4cc1a472009-02-09 20:20:56 +0000894 /// DidCallStackSave - Whether llvm.stacksave has been called. Used to avoid
895 /// calling llvm.stacksave for multiple VLAs in the same scope.
896 bool DidCallStackSave;
Mike Stump09429b92009-02-17 17:00:02 +0000897
John McCallf1549f62010-07-06 01:34:17 +0000898 /// A block containing a single 'unreachable' instruction. Created
899 /// lazily by getUnreachableBlock().
900 llvm::BasicBlock *UnreachableBlock;
Mike Stump0dd9e882009-02-08 23:14:22 +0000901
Anders Carlssonf6c56e22009-11-25 03:15:49 +0000902 /// CXXThisDecl - When generating code for a C++ member function,
903 /// this will hold the implicit 'this' declaration.
Anders Carlsson2b77ba82009-04-04 20:47:02 +0000904 ImplicitParamDecl *CXXThisDecl;
John McCall25049412010-02-16 22:04:33 +0000905 llvm::Value *CXXThisValue;
Mike Stump1eb44332009-09-09 15:08:12 +0000906
Anders Carlssonf6c56e22009-11-25 03:15:49 +0000907 /// CXXVTTDecl - When generating code for a base object constructor or
908 /// base object destructor with virtual bases, this will hold the implicit
909 /// VTT parameter.
910 ImplicitParamDecl *CXXVTTDecl;
John McCall25049412010-02-16 22:04:33 +0000911 llvm::Value *CXXVTTValue;
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000912
John McCall150b4622011-01-26 04:00:11 +0000913 /// OutermostConditional - Points to the outermost active
914 /// conditional control. This is used so that we know if a
915 /// temporary should be destroyed conditionally.
916 ConditionalEvaluation *OutermostConditional;
Mike Stump1eb44332009-09-09 15:08:12 +0000917
Anders Carlsson7dfa4072009-09-12 02:14:24 +0000918
919 /// ByrefValueInfoMap - For each __block variable, contains a pair of the LLVM
920 /// type as well as the field number that contains the actual data.
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000921 llvm::DenseMap<const ValueDecl *, std::pair<const llvm::Type *,
Anders Carlsson7dfa4072009-09-12 02:14:24 +0000922 unsigned> > ByRefValueInfo;
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000923
John McCallf1549f62010-07-06 01:34:17 +0000924 llvm::BasicBlock *TerminateLandingPad;
Mike Stump182f3832009-12-10 00:02:42 +0000925 llvm::BasicBlock *TerminateHandler;
Chris Lattner83252dc2010-07-20 21:07:09 +0000926 llvm::BasicBlock *TrapBB;
Eli Friedman94067052009-12-10 02:21:21 +0000927
Reid Spencer5f016e22007-07-11 17:01:13 +0000928public:
929 CodeGenFunction(CodeGenModule &cgm);
Mike Stump0dd9e882009-02-08 23:14:22 +0000930
John McCall1e7fe752010-09-02 09:58:18 +0000931 CodeGenTypes &getTypes() const { return CGM.getTypes(); }
Reid Spencer5f016e22007-07-11 17:01:13 +0000932 ASTContext &getContext() const;
Anders Carlssone896d982009-02-13 08:11:52 +0000933 CGDebugInfo *getDebugInfo() { return DebugInfo; }
Reid Spencer5f016e22007-07-11 17:01:13 +0000934
John McCalld16c2cf2011-02-08 08:22:06 +0000935 const LangOptions &getLangOptions() const { return CGM.getLangOptions(); }
936
John McCallf1549f62010-07-06 01:34:17 +0000937 /// Returns a pointer to the function's exception object slot, which
938 /// is assigned in every landing pad.
939 llvm::Value *getExceptionSlot();
940
John McCallff8e1152010-07-23 21:56:41 +0000941 llvm::Value *getNormalCleanupDestSlot();
942 llvm::Value *getEHCleanupDestSlot();
943
John McCallf1549f62010-07-06 01:34:17 +0000944 llvm::BasicBlock *getUnreachableBlock() {
945 if (!UnreachableBlock) {
946 UnreachableBlock = createBasicBlock("unreachable");
947 new llvm::UnreachableInst(getLLVMContext(), UnreachableBlock);
948 }
949 return UnreachableBlock;
950 }
951
952 llvm::BasicBlock *getInvokeDest() {
953 if (!EHStack.requiresLandingPad()) return 0;
954 return getInvokeDestImpl();
955 }
Daniel Dunbar9834ffb2009-02-23 17:26:39 +0000956
John McCalld16c2cf2011-02-08 08:22:06 +0000957 llvm::LLVMContext &getLLVMContext() { return CGM.getLLVMContext(); }
Owen Anderson69243822009-07-13 04:10:07 +0000958
Daniel Dunbar9834ffb2009-02-23 17:26:39 +0000959 //===--------------------------------------------------------------------===//
960 // Objective-C
961 //===--------------------------------------------------------------------===//
962
Chris Lattner391d77a2008-03-30 23:03:07 +0000963 void GenerateObjCMethod(const ObjCMethodDecl *OMD);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +0000964
Mike Stump0dd9e882009-02-08 23:14:22 +0000965 void StartObjCMethod(const ObjCMethodDecl *MD,
Fariborz Jahanian679a5022009-01-10 21:06:09 +0000966 const ObjCContainerDecl *CD);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +0000967
Mike Stump0dd9e882009-02-08 23:14:22 +0000968 /// GenerateObjCGetter - Synthesize an Objective-C property getter function.
Fariborz Jahanianfef30b52008-12-09 20:23:04 +0000969 void GenerateObjCGetter(ObjCImplementationDecl *IMP,
970 const ObjCPropertyImplDecl *PID);
Fariborz Jahanian109dfc62010-04-28 21:28:56 +0000971 void GenerateObjCCtorDtorMethod(ObjCImplementationDecl *IMP,
972 ObjCMethodDecl *MD, bool ctor);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +0000973
Mike Stump0dd9e882009-02-08 23:14:22 +0000974 /// GenerateObjCSetter - Synthesize an Objective-C property setter function
975 /// for the given property.
Fariborz Jahanianfef30b52008-12-09 20:23:04 +0000976 void GenerateObjCSetter(ObjCImplementationDecl *IMP,
977 const ObjCPropertyImplDecl *PID);
Fariborz Jahanian0b2bd472010-04-13 00:38:05 +0000978 bool IndirectObjCSetterArg(const CGFunctionInfo &FI);
Fariborz Jahanian15bd5882010-04-13 18:32:24 +0000979 bool IvarTypeWithAggrGCObjects(QualType Ty);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +0000980
Mike Stump4e7a1f72009-02-21 20:00:35 +0000981 //===--------------------------------------------------------------------===//
982 // Block Bits
983 //===--------------------------------------------------------------------===//
984
John McCall6b5a61b2011-02-07 10:33:21 +0000985 llvm::Value *EmitBlockLiteral(const BlockExpr *);
Blaine Garst2a7eb282010-02-23 21:51:17 +0000986 llvm::Constant *BuildDescriptorBlockDecl(const BlockExpr *,
Fariborz Jahanian89ecd412010-08-04 16:57:49 +0000987 const CGBlockInfo &Info,
Mike Stump08920992009-03-07 02:35:30 +0000988 const llvm::StructType *,
John McCalld16c2cf2011-02-08 08:22:06 +0000989 llvm::Constant *BlockVarLayout);
Mike Stump4e7a1f72009-02-21 20:00:35 +0000990
Fariborz Jahanian564360b2010-06-24 00:08:06 +0000991 llvm::Function *GenerateBlockFunction(GlobalDecl GD,
John McCall6b5a61b2011-02-07 10:33:21 +0000992 const CGBlockInfo &Info,
Mike Stump6cc88f72009-03-20 21:53:12 +0000993 const Decl *OuterFuncDecl,
John McCall6b5a61b2011-02-07 10:33:21 +0000994 const DeclMapTy &ldm);
Mike Stump4e7a1f72009-02-21 20:00:35 +0000995
John McCalld16c2cf2011-02-08 08:22:06 +0000996 llvm::Constant *GenerateCopyHelperFunction(const CGBlockInfo &blockInfo);
997 llvm::Constant *GenerateDestroyHelperFunction(const CGBlockInfo &blockInfo);
998
999 llvm::Constant *GeneratebyrefCopyHelperFunction(const llvm::Type *,
1000 BlockFieldFlags flags,
1001 const VarDecl *BD);
1002 llvm::Constant *GeneratebyrefDestroyHelperFunction(const llvm::Type *T,
1003 BlockFieldFlags flags,
1004 const VarDecl *BD);
1005
1006 void BuildBlockRelease(llvm::Value *DeclPtr, BlockFieldFlags flags);
1007
John McCall6b5a61b2011-02-07 10:33:21 +00001008 llvm::Value *LoadBlockStruct() {
1009 assert(BlockPointer && "no block pointer set!");
1010 return BlockPointer;
1011 }
Mike Stump4e7a1f72009-02-21 20:00:35 +00001012
John McCallea1471e2010-05-20 01:18:31 +00001013 void AllocateBlockCXXThisPointer(const CXXThisExpr *E);
1014 void AllocateBlockDecl(const BlockDeclRefExpr *E);
John McCallee504292010-05-21 04:11:14 +00001015 llvm::Value *GetAddrOfBlockDecl(const BlockDeclRefExpr *E) {
1016 return GetAddrOfBlockDecl(E->getDecl(), E->isByRef());
1017 }
John McCall6b5a61b2011-02-07 10:33:21 +00001018 llvm::Value *GetAddrOfBlockDecl(const VarDecl *var, bool ByRef);
1019 const llvm::Type *BuildByRefType(const VarDecl *var);
Mike Stumpdab514f2009-03-04 03:23:46 +00001020
Anders Carlsson0ff8baf2009-09-11 00:07:24 +00001021 void GenerateCode(GlobalDecl GD, llvm::Function *Fn);
1022 void StartFunction(GlobalDecl GD, QualType RetTy,
Daniel Dunbar7c086512008-09-09 23:14:03 +00001023 llvm::Function *Fn,
Daniel Dunbar2284ac92008-10-18 18:22:23 +00001024 const FunctionArgList &Args,
1025 SourceLocation StartLoc);
Daniel Dunbara448fb22008-11-11 23:11:34 +00001026
John McCall9fc6a772010-02-19 09:25:03 +00001027 void EmitConstructorBody(FunctionArgList &Args);
1028 void EmitDestructorBody(FunctionArgList &Args);
1029 void EmitFunctionBody(FunctionArgList &Args);
John McCalla355e072010-02-18 03:17:58 +00001030
Mike Stump0dd9e882009-02-08 23:14:22 +00001031 /// EmitReturnBlock - Emit the unified return block, trying to avoid its
1032 /// emission when possible.
Daniel Dunbar1c1d6072009-01-26 23:27:52 +00001033 void EmitReturnBlock();
1034
Mike Stump0dd9e882009-02-08 23:14:22 +00001035 /// FinishFunction - Complete IR generation of the current function. It is
1036 /// legal to call this function even if there is no current insertion point.
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00001037 void FinishFunction(SourceLocation EndLoc=SourceLocation());
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001038
Anders Carlsson519c3282010-03-24 00:39:18 +00001039 /// GenerateThunk - Generate a thunk for the given method.
1040 void GenerateThunk(llvm::Function *Fn, GlobalDecl GD, const ThunkInfo &Thunk);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001041
Douglas Gregorfb8cc252010-05-05 05:51:00 +00001042 void EmitCtorPrologue(const CXXConstructorDecl *CD, CXXCtorType Type,
1043 FunctionArgList &Args);
Mike Stump1eb44332009-09-09 15:08:12 +00001044
Anders Carlssond103f9f2010-03-28 19:40:00 +00001045 /// InitializeVTablePointer - Initialize the vtable pointer of the given
1046 /// subobject.
1047 ///
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001048 void InitializeVTablePointer(BaseSubobject Base,
Anders Carlssonb3b772e2010-04-20 05:22:15 +00001049 const CXXRecordDecl *NearestVBase,
Anders Carlsson42358402010-05-03 00:07:07 +00001050 uint64_t OffsetFromNearestVBase,
Anders Carlssond103f9f2010-03-28 19:40:00 +00001051 llvm::Constant *VTable,
1052 const CXXRecordDecl *VTableClass);
1053
1054 typedef llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBasesSetTy;
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001055 void InitializeVTablePointers(BaseSubobject Base,
Anders Carlssonb3b772e2010-04-20 05:22:15 +00001056 const CXXRecordDecl *NearestVBase,
Anders Carlsson42358402010-05-03 00:07:07 +00001057 uint64_t OffsetFromNearestVBase,
Anders Carlsson603d6d12010-03-28 21:07:49 +00001058 bool BaseIsNonVirtualPrimaryBase,
1059 llvm::Constant *VTable,
1060 const CXXRecordDecl *VTableClass,
1061 VisitedVirtualBasesSetTy& VBases);
Eli Friedman77a259c2009-12-08 06:46:18 +00001062
Anders Carlsson603d6d12010-03-28 21:07:49 +00001063 void InitializeVTablePointers(const CXXRecordDecl *ClassDecl);
Anders Carlssond103f9f2010-03-28 19:40:00 +00001064
Dan Gohman043fb9a2010-10-26 18:44:08 +00001065 /// GetVTablePtr - Return the Value of the vtable pointer member pointed
1066 /// to by This.
1067 llvm::Value *GetVTablePtr(llvm::Value *This, const llvm::Type *Ty);
Anders Carlssond103f9f2010-03-28 19:40:00 +00001068
John McCall50da2ca2010-07-21 05:30:47 +00001069 /// EnterDtorCleanups - Enter the cleanups necessary to complete the
1070 /// given phase of destruction for a destructor. The end result
1071 /// should call destructors on members and base classes in reverse
1072 /// order of their construction.
1073 void EnterDtorCleanups(const CXXDestructorDecl *Dtor, CXXDtorType Type);
Mike Stump1eb44332009-09-09 15:08:12 +00001074
Chris Lattner7255a2d2010-06-22 00:03:40 +00001075 /// ShouldInstrumentFunction - Return true if the current function should be
1076 /// instrumented with __cyg_profile_func_* calls
1077 bool ShouldInstrumentFunction();
1078
1079 /// EmitFunctionInstrumentation - Emit LLVM code to call the specified
1080 /// instrumentation function with the current function and the call site, if
1081 /// function instrumentation is enabled.
1082 void EmitFunctionInstrumentation(const char *Fn);
1083
Roman Divackybe4c8702011-02-10 16:52:03 +00001084 /// EmitMCountInstrumentation - Emit call to .mcount.
1085 void EmitMCountInstrumentation();
1086
Mike Stump0dd9e882009-02-08 23:14:22 +00001087 /// EmitFunctionProlog - Emit the target specific LLVM code to load the
1088 /// arguments for the given function. This is also responsible for naming the
1089 /// LLVM function arguments.
Daniel Dunbar88b53962009-02-02 22:03:45 +00001090 void EmitFunctionProlog(const CGFunctionInfo &FI,
1091 llvm::Function *Fn,
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001092 const FunctionArgList &Args);
1093
Mike Stump0dd9e882009-02-08 23:14:22 +00001094 /// EmitFunctionEpilog - Emit the target specific LLVM code to return the
1095 /// given temporary.
Chris Lattner35b21b82010-06-27 01:06:27 +00001096 void EmitFunctionEpilog(const CGFunctionInfo &FI);
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001097
Mike Stumpcce3d4f2009-12-07 23:38:24 +00001098 /// EmitStartEHSpec - Emit the start of the exception spec.
1099 void EmitStartEHSpec(const Decl *D);
1100
1101 /// EmitEndEHSpec - Emit the end of the exception spec.
1102 void EmitEndEHSpec(const Decl *D);
1103
John McCallf1549f62010-07-06 01:34:17 +00001104 /// getTerminateLandingPad - Return a landing pad that just calls terminate.
1105 llvm::BasicBlock *getTerminateLandingPad();
1106
1107 /// getTerminateHandler - Return a handler (not a landing pad, just
1108 /// a catch handler) that just calls terminate. This is used when
1109 /// a terminate scope encloses a try.
Mike Stump9b39c512009-12-09 22:59:31 +00001110 llvm::BasicBlock *getTerminateHandler();
1111
Daniel Dunbar8b1a3432009-02-03 23:03:55 +00001112 const llvm::Type *ConvertTypeForMem(QualType T);
Reid Spencer5f016e22007-07-11 17:01:13 +00001113 const llvm::Type *ConvertType(QualType T);
John McCallbff225e2010-02-16 04:15:37 +00001114 const llvm::Type *ConvertType(const TypeDecl *T) {
1115 return ConvertType(getContext().getTypeDeclType(T));
1116 }
Chris Lattnerc8aa5f12008-04-04 04:07:35 +00001117
Mike Stump0dd9e882009-02-08 23:14:22 +00001118 /// LoadObjCSelf - Load the value of self. This function is only valid while
1119 /// generating code for an Objective-C method.
Chris Lattnerc8aa5f12008-04-04 04:07:35 +00001120 llvm::Value *LoadObjCSelf();
Mike Stump0dd9e882009-02-08 23:14:22 +00001121
1122 /// TypeOfSelfObject - Return type of object that this self represents.
Fariborz Jahanian45012a72009-02-03 00:09:52 +00001123 QualType TypeOfSelfObject();
Chris Lattner41110242008-06-17 18:05:57 +00001124
Reid Spencer5f016e22007-07-11 17:01:13 +00001125 /// hasAggregateLLVMType - Return true if the specified AST type will map into
1126 /// an aggregate LLVM type or is void.
1127 static bool hasAggregateLLVMType(QualType T);
Daniel Dunbar55e87422008-11-11 02:29:29 +00001128
1129 /// createBasicBlock - Create an LLVM basic block.
John McCalld16c2cf2011-02-08 08:22:06 +00001130 llvm::BasicBlock *createBasicBlock(llvm::StringRef name = "",
1131 llvm::Function *parent = 0,
1132 llvm::BasicBlock *before = 0) {
Daniel Dunbar29ea6722008-11-12 00:01:12 +00001133#ifdef NDEBUG
John McCalld16c2cf2011-02-08 08:22:06 +00001134 return llvm::BasicBlock::Create(getLLVMContext(), "", parent, before);
Daniel Dunbar29ea6722008-11-12 00:01:12 +00001135#else
John McCalld16c2cf2011-02-08 08:22:06 +00001136 return llvm::BasicBlock::Create(getLLVMContext(), name, parent, before);
Daniel Dunbar29ea6722008-11-12 00:01:12 +00001137#endif
Daniel Dunbar55e87422008-11-11 02:29:29 +00001138 }
Mike Stump0dd9e882009-02-08 23:14:22 +00001139
Reid Spencer5f016e22007-07-11 17:01:13 +00001140 /// getBasicBlockForLabel - Return the LLVM basicblock that the specified
1141 /// label maps to.
John McCallf1549f62010-07-06 01:34:17 +00001142 JumpDest getJumpDestForLabel(const LabelStmt *S);
Mike Stump0dd9e882009-02-08 23:14:22 +00001143
Mike Stumpf71d2322009-11-30 20:08:49 +00001144 /// SimplifyForwardingBlocks - If the given basic block is only a branch to
1145 /// another basic block, simplify it. This assumes that no other code could
1146 /// potentially reference the basic block.
Daniel Dunbaraa5bd872009-04-01 04:37:47 +00001147 void SimplifyForwardingBlocks(llvm::BasicBlock *BB);
1148
Mike Stump0dd9e882009-02-08 23:14:22 +00001149 /// EmitBlock - Emit the given block \arg BB and set it as the insert point,
1150 /// adding a fall-through branch from the current insert block if
1151 /// necessary. It is legal to call this function even if there is no current
1152 /// insertion point.
Daniel Dunbara0c21a82008-11-13 01:24:05 +00001153 ///
Mike Stump0dd9e882009-02-08 23:14:22 +00001154 /// IsFinished - If true, indicates that the caller has finished emitting
1155 /// branches to the given block and does not expect to emit code into it. This
1156 /// means the block can be ignored if it is unreachable.
Daniel Dunbara0c21a82008-11-13 01:24:05 +00001157 void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false);
Daniel Dunbar824e3bd2008-11-11 04:34:23 +00001158
Mike Stump0dd9e882009-02-08 23:14:22 +00001159 /// EmitBranch - Emit a branch to the specified basic block from the current
1160 /// insert block, taking care to avoid creation of branches from dummy
1161 /// blocks. It is legal to call this function even if there is no current
1162 /// insertion point.
Daniel Dunbar5e08ad32008-11-11 22:06:59 +00001163 ///
Mike Stump0dd9e882009-02-08 23:14:22 +00001164 /// This function clears the current insertion point. The caller should follow
1165 /// calls to this function with calls to Emit*Block prior to generation new
1166 /// code.
Daniel Dunbard57a8712008-11-11 09:41:28 +00001167 void EmitBranch(llvm::BasicBlock *Block);
1168
Mike Stump0dd9e882009-02-08 23:14:22 +00001169 /// HaveInsertPoint - True if an insertion point is defined. If not, this
1170 /// indicates that the current code being emitted is unreachable.
1171 bool HaveInsertPoint() const {
Daniel Dunbara448fb22008-11-11 23:11:34 +00001172 return Builder.GetInsertBlock() != 0;
1173 }
1174
Mike Stump0dd9e882009-02-08 23:14:22 +00001175 /// EnsureInsertPoint - Ensure that an insertion point is defined so that
1176 /// emitted IR has a place to go. Note that by definition, if this function
1177 /// creates a block then that block is unreachable; callers may do better to
1178 /// detect when no insertion point is defined and simply skip IR generation.
Daniel Dunbara448fb22008-11-11 23:11:34 +00001179 void EnsureInsertPoint() {
1180 if (!HaveInsertPoint())
1181 EmitBlock(createBasicBlock());
1182 }
Mike Stump0dd9e882009-02-08 23:14:22 +00001183
Daniel Dunbar488e9932008-08-16 00:56:44 +00001184 /// ErrorUnsupported - Print out an error that codegen doesn't support the
Chris Lattnerdc5e8262007-12-02 01:43:38 +00001185 /// specified stmt yet.
Daniel Dunbar90df4b62008-09-04 03:43:08 +00001186 void ErrorUnsupported(const Stmt *S, const char *Type,
1187 bool OmitOnError=false);
Reid Spencer5f016e22007-07-11 17:01:13 +00001188
1189 //===--------------------------------------------------------------------===//
1190 // Helpers
1191 //===--------------------------------------------------------------------===//
Mike Stump0dd9e882009-02-08 23:14:22 +00001192
Daniel Dunbar983e3d72010-08-21 04:20:22 +00001193 LValue MakeAddrLValue(llvm::Value *V, QualType T, unsigned Alignment = 0) {
Dan Gohman3d5aff52010-10-14 23:06:10 +00001194 return LValue::MakeAddr(V, T, Alignment, getContext(),
1195 CGM.getTBAAInfo(T));
Daniel Dunbar5cf8bfe2010-08-21 02:53:44 +00001196 }
1197
Reid Spencer5f016e22007-07-11 17:01:13 +00001198 /// CreateTempAlloca - This creates a alloca and inserts it into the entry
Daniel Dunbar195337d2010-02-09 02:48:28 +00001199 /// block. The caller is responsible for setting an appropriate alignment on
1200 /// the alloca.
Reid Spencer5f016e22007-07-11 17:01:13 +00001201 llvm::AllocaInst *CreateTempAlloca(const llvm::Type *Ty,
Daniel Dunbar259e9cc2009-10-19 01:21:05 +00001202 const llvm::Twine &Name = "tmp");
Mike Stump0dd9e882009-02-08 23:14:22 +00001203
John McCallac418162010-04-22 01:10:34 +00001204 /// InitTempAlloca - Provide an initial value for the given alloca.
1205 void InitTempAlloca(llvm::AllocaInst *Alloca, llvm::Value *Value);
1206
Daniel Dunbar9bd4da22010-02-16 19:44:13 +00001207 /// CreateIRTemp - Create a temporary IR object of the given type, with
1208 /// appropriate alignment. This routine should only be used when an temporary
1209 /// value needs to be stored into an alloca (for example, to avoid explicit
1210 /// PHI construction), but the type is the IR type, not the type appropriate
1211 /// for storing in memory.
Chris Lattner121b3fa2010-07-05 20:21:00 +00001212 llvm::AllocaInst *CreateIRTemp(QualType T, const llvm::Twine &Name = "tmp");
Daniel Dunbar9bd4da22010-02-16 19:44:13 +00001213
Daniel Dunbar195337d2010-02-09 02:48:28 +00001214 /// CreateMemTemp - Create a temporary memory object of the given type, with
1215 /// appropriate alignment.
Chris Lattner121b3fa2010-07-05 20:21:00 +00001216 llvm::AllocaInst *CreateMemTemp(QualType T, const llvm::Twine &Name = "tmp");
Daniel Dunbar195337d2010-02-09 02:48:28 +00001217
John McCall558d2ab2010-09-15 10:14:12 +00001218 /// CreateAggTemp - Create a temporary memory object for the given
1219 /// aggregate type.
1220 AggValueSlot CreateAggTemp(QualType T, const llvm::Twine &Name = "tmp") {
1221 return AggValueSlot::forAddr(CreateMemTemp(T, Name), false, false);
1222 }
1223
John McCalld16c2cf2011-02-08 08:22:06 +00001224 /// Emit a cast to void* in the appropriate address space.
1225 llvm::Value *EmitCastToVoidPtr(llvm::Value *value);
1226
Reid Spencer5f016e22007-07-11 17:01:13 +00001227 /// EvaluateExprAsBool - Perform the usual unary conversions on the specified
1228 /// expression and compare the result against zero, returning an Int1Ty value.
1229 llvm::Value *EvaluateExprAsBool(const Expr *E);
1230
John McCall2a416372010-12-05 02:00:02 +00001231 /// EmitIgnoredExpr - Emit an expression in a context which ignores the result.
1232 void EmitIgnoredExpr(const Expr *E);
1233
Chris Lattner9b655512007-08-31 22:49:20 +00001234 /// EmitAnyExpr - Emit code to compute the specified expression which can have
1235 /// any type. The result is returned as an RValue struct. If this is an
1236 /// aggregate expression, the aggloc/agglocvolatile arguments indicate where
1237 /// the result should be returned.
Mike Stump49d1cd52009-05-26 22:03:21 +00001238 ///
1239 /// \param IgnoreResult - True if the resulting value isn't used.
John McCall558d2ab2010-09-15 10:14:12 +00001240 RValue EmitAnyExpr(const Expr *E,
1241 AggValueSlot AggSlot = AggValueSlot::ignored(),
1242 bool IgnoreResult = false);
Devang Pateld9363c32007-09-28 21:49:18 +00001243
Mike Stump0dd9e882009-02-08 23:14:22 +00001244 // EmitVAListRef - Emit a "reference" to a va_list; this is either the address
1245 // or the value of the expression, depending on how va_list is defined.
Eli Friedman4fd0aa52009-01-20 17:46:04 +00001246 llvm::Value *EmitVAListRef(const Expr *E);
1247
Mike Stump0dd9e882009-02-08 23:14:22 +00001248 /// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result will
1249 /// always be accessible even if no aggregate location is provided.
John McCall558d2ab2010-09-15 10:14:12 +00001250 RValue EmitAnyExprToTemp(const Expr *E);
Daniel Dunbar46f45b92008-09-09 01:06:48 +00001251
John McCall3d3ec1c2010-04-21 10:05:39 +00001252 /// EmitsAnyExprToMem - Emits the code necessary to evaluate an
1253 /// arbitrary expression into the given memory location.
1254 void EmitAnyExprToMem(const Expr *E, llvm::Value *Location,
John McCall558d2ab2010-09-15 10:14:12 +00001255 bool IsLocationVolatile,
1256 bool IsInitializer);
John McCall3d3ec1c2010-04-21 10:05:39 +00001257
Mike Stump27fe2e62009-05-23 22:29:41 +00001258 /// EmitAggregateCopy - Emit an aggrate copy.
1259 ///
1260 /// \param isVolatile - True iff either the source or the destination is
1261 /// volatile.
Daniel Dunbar7482d122008-09-09 20:49:46 +00001262 void EmitAggregateCopy(llvm::Value *DestPtr, llvm::Value *SrcPtr,
Mike Stump27fe2e62009-05-23 22:29:41 +00001263 QualType EltTy, bool isVolatile=false);
Daniel Dunbar7482d122008-09-09 20:49:46 +00001264
Devang Patel51b09f22007-10-04 23:45:31 +00001265 /// StartBlock - Start new block named N. If insert block is a dummy block
1266 /// then reuse it.
1267 void StartBlock(const char *N);
1268
Lauro Ramos Venancio81373352008-02-26 21:41:45 +00001269 /// GetAddrOfStaticLocalVar - Return the address of a static local variable.
John McCall4c40d982010-08-31 07:33:07 +00001270 llvm::Constant *GetAddrOfStaticLocalVar(const VarDecl *BVD) {
1271 return cast<llvm::Constant>(GetAddrOfLocalVar(BVD));
1272 }
Dan Gohman4f8d1232008-05-22 00:50:06 +00001273
Anders Carlssondde0a942008-09-11 09:15:33 +00001274 /// GetAddrOfLocalVar - Return the address of a local variable.
John McCall4c40d982010-08-31 07:33:07 +00001275 llvm::Value *GetAddrOfLocalVar(const VarDecl *VD) {
1276 llvm::Value *Res = LocalDeclMap[VD];
1277 assert(Res && "Invalid argument to GetAddrOfLocalVar(), no decl!");
1278 return Res;
1279 }
Mike Stump0dd9e882009-02-08 23:14:22 +00001280
Dan Gohman4f8d1232008-05-22 00:50:06 +00001281 /// getAccessedFieldNo - Given an encoded value and a result number, return
1282 /// the input field number being accessed.
1283 static unsigned getAccessedFieldNo(unsigned Idx, const llvm::Constant *Elts);
1284
Chris Lattnerd9becd12009-10-28 23:59:40 +00001285 llvm::BlockAddress *GetAddrOfLabel(const LabelStmt *L);
Chris Lattner3d00fdc2009-10-13 06:55:33 +00001286 llvm::BasicBlock *GetIndirectGotoBlock();
Daniel Dunbar0ffb1252008-08-04 16:51:22 +00001287
Anders Carlsson1884eb02010-05-22 17:35:42 +00001288 /// EmitNullInitialization - Generate code to set a value of the given type to
1289 /// null, If the type contains data member pointers, they will be initialized
1290 /// to -1 in accordance with the Itanium C++ ABI.
1291 void EmitNullInitialization(llvm::Value *DestPtr, QualType Ty);
Anders Carlssonddf7cac2008-11-04 05:30:00 +00001292
1293 // EmitVAArg - Generate code to get an argument from the passed in pointer
1294 // and update it accordingly. The return value is a pointer to the argument.
1295 // FIXME: We should be able to get rid of this method and use the va_arg
Mike Stump0dd9e882009-02-08 23:14:22 +00001296 // instruction in LLVM instead once it works well enough.
Anders Carlssonddf7cac2008-11-04 05:30:00 +00001297 llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty);
Anders Carlssonf666b772008-12-20 20:27:15 +00001298
Mike Stumpf71d2322009-11-30 20:08:49 +00001299 /// EmitVLASize - Generate code for any VLA size expressions that might occur
1300 /// in a variably modified type. If Ty is a VLA, will return the value that
1301 /// corresponds to the size in bytes of the VLA type. Will return 0 otherwise.
Daniel Dunbard286f052009-07-19 06:58:07 +00001302 ///
1303 /// This function can be called with a null (unreachable) insert point.
Anders Carlsson60d35412008-12-20 20:46:34 +00001304 llvm::Value *EmitVLASize(QualType Ty);
Mike Stump0dd9e882009-02-08 23:14:22 +00001305
Anders Carlssondcc90d82008-12-12 07:19:02 +00001306 // GetVLASize - Returns an LLVM value that corresponds to the size in bytes
1307 // of a variable length array type.
1308 llvm::Value *GetVLASize(const VariableArrayType *);
1309
Anders Carlsson5f4307b2009-04-14 16:58:56 +00001310 /// LoadCXXThis - Load the value of 'this'. This function is only valid while
1311 /// generating code for an C++ member function.
John McCall25049412010-02-16 22:04:33 +00001312 llvm::Value *LoadCXXThis() {
1313 assert(CXXThisValue && "no 'this' value for this function");
1314 return CXXThisValue;
1315 }
Mike Stump1eb44332009-09-09 15:08:12 +00001316
Anders Carlssonc997d422010-01-02 01:01:18 +00001317 /// LoadCXXVTT - Load the VTT parameter to base constructors/destructors have
1318 /// virtual bases.
John McCall25049412010-02-16 22:04:33 +00001319 llvm::Value *LoadCXXVTT() {
1320 assert(CXXVTTValue && "no VTT value for this function");
1321 return CXXVTTValue;
1322 }
John McCallbff225e2010-02-16 04:15:37 +00001323
1324 /// GetAddressOfBaseOfCompleteClass - Convert the given pointer to a
Anders Carlsson8561a862010-04-24 23:01:49 +00001325 /// complete class to the given direct base.
1326 llvm::Value *
1327 GetAddressOfDirectBaseInCompleteClass(llvm::Value *Value,
1328 const CXXRecordDecl *Derived,
1329 const CXXRecordDecl *Base,
1330 bool BaseIsVirtual);
Anders Carlssona88ad562010-04-24 21:51:08 +00001331
Mike Stumpf71d2322009-11-30 20:08:49 +00001332 /// GetAddressOfBaseClass - This function will add the necessary delta to the
1333 /// load of 'this' and returns address of the base class.
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001334 llvm::Value *GetAddressOfBaseClass(llvm::Value *Value,
Anders Carlsson8561a862010-04-24 23:01:49 +00001335 const CXXRecordDecl *Derived,
John McCallf871d0c2010-08-07 06:22:56 +00001336 CastExpr::path_const_iterator PathBegin,
1337 CastExpr::path_const_iterator PathEnd,
Anders Carlsson34a2d382010-04-24 21:06:20 +00001338 bool NullCheckValue);
1339
Anders Carlssona3697c92009-11-23 17:57:54 +00001340 llvm::Value *GetAddressOfDerivedClass(llvm::Value *Value,
Anders Carlsson8561a862010-04-24 23:01:49 +00001341 const CXXRecordDecl *Derived,
John McCallf871d0c2010-08-07 06:22:56 +00001342 CastExpr::path_const_iterator PathBegin,
1343 CastExpr::path_const_iterator PathEnd,
Anders Carlssona3697c92009-11-23 17:57:54 +00001344 bool NullCheckValue);
1345
Anders Carlssonbb7e17b2010-01-31 01:36:53 +00001346 llvm::Value *GetVirtualBaseClassOffset(llvm::Value *This,
1347 const CXXRecordDecl *ClassDecl,
1348 const CXXRecordDecl *BaseClassDecl);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001349
John McCallc0bf4622010-02-23 00:48:20 +00001350 void EmitDelegateCXXConstructorCall(const CXXConstructorDecl *Ctor,
1351 CXXCtorType CtorType,
1352 const FunctionArgList &Args);
Anders Carlsson155ed4a2010-05-02 23:20:53 +00001353 void EmitCXXConstructorCall(const CXXConstructorDecl *D, CXXCtorType Type,
1354 bool ForVirtualBase, llvm::Value *This,
Anders Carlssonb14095a2009-04-17 00:06:03 +00001355 CallExpr::const_arg_iterator ArgBeg,
1356 CallExpr::const_arg_iterator ArgEnd);
Fariborz Jahanian34999872010-11-13 21:53:34 +00001357
1358 void EmitSynthesizedCXXCopyCtorCall(const CXXConstructorDecl *D,
1359 llvm::Value *This, llvm::Value *Src,
1360 CallExpr::const_arg_iterator ArgBeg,
1361 CallExpr::const_arg_iterator ArgEnd);
Mike Stump1eb44332009-09-09 15:08:12 +00001362
Fariborz Jahanian288dcaf2009-08-19 20:55:16 +00001363 void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D,
Anders Carlsson569c1f42009-09-23 02:45:36 +00001364 const ConstantArrayType *ArrayTy,
Anders Carlsson5d4d9462009-11-24 18:43:52 +00001365 llvm::Value *ArrayPtr,
1366 CallExpr::const_arg_iterator ArgBeg,
Douglas Gregor59174c02010-07-21 01:10:17 +00001367 CallExpr::const_arg_iterator ArgEnd,
1368 bool ZeroInitialization = false);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001369
Anders Carlsson569c1f42009-09-23 02:45:36 +00001370 void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D,
1371 llvm::Value *NumElements,
Anders Carlsson5d4d9462009-11-24 18:43:52 +00001372 llvm::Value *ArrayPtr,
1373 CallExpr::const_arg_iterator ArgBeg,
Douglas Gregor59174c02010-07-21 01:10:17 +00001374 CallExpr::const_arg_iterator ArgEnd,
1375 bool ZeroInitialization = false);
Anders Carlssonb14095a2009-04-17 00:06:03 +00001376
Fariborz Jahanianf800f6c2009-08-20 20:54:15 +00001377 void EmitCXXAggrDestructorCall(const CXXDestructorDecl *D,
1378 const ArrayType *Array,
1379 llvm::Value *This);
Mike Stump1eb44332009-09-09 15:08:12 +00001380
Fariborz Jahanian72c21532009-11-13 19:27:47 +00001381 void EmitCXXAggrDestructorCall(const CXXDestructorDecl *D,
1382 llvm::Value *NumElements,
1383 llvm::Value *This);
1384
Anders Carlsson02e370a2010-06-08 22:14:59 +00001385 llvm::Function *GenerateCXXAggrDestructorHelper(const CXXDestructorDecl *D,
1386 const ArrayType *Array,
1387 llvm::Value *This);
Fariborz Jahanian88f42802009-11-10 19:24:06 +00001388
Anders Carlsson7267c162009-05-29 21:03:38 +00001389 void EmitCXXDestructorCall(const CXXDestructorDecl *D, CXXDtorType Type,
Anders Carlsson8e6404c2010-05-02 23:29:11 +00001390 bool ForVirtualBase, llvm::Value *This);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001391
Fariborz Jahanianef668722010-06-25 18:26:07 +00001392 void EmitNewArrayInitializer(const CXXNewExpr *E, llvm::Value *NewPtr,
1393 llvm::Value *NumElements);
Mike Stump1eb44332009-09-09 15:08:12 +00001394
John McCallf1549f62010-07-06 01:34:17 +00001395 void EmitCXXTemporary(const CXXTemporary *Temporary, llvm::Value *Ptr);
Mike Stump1eb44332009-09-09 15:08:12 +00001396
Anders Carlssona00703d2009-05-31 01:40:14 +00001397 llvm::Value *EmitCXXNewExpr(const CXXNewExpr *E);
Anders Carlsson60e282c2009-08-16 21:13:42 +00001398 void EmitCXXDeleteExpr(const CXXDeleteExpr *E);
Mike Stump1eb44332009-09-09 15:08:12 +00001399
Eli Friedman4bf81522009-11-18 00:57:03 +00001400 void EmitDeleteCall(const FunctionDecl *DeleteFD, llvm::Value *Ptr,
1401 QualType DeleteTy);
1402
Mike Stumpc2e84ae2009-11-15 08:09:41 +00001403 llvm::Value* EmitCXXTypeidExpr(const CXXTypeidExpr *E);
Mike Stumpc849c052009-11-16 06:50:58 +00001404 llvm::Value *EmitDynamicCast(llvm::Value *V, const CXXDynamicCastExpr *DCE);
Mike Stumpc2e84ae2009-11-15 08:09:41 +00001405
Mike Stumpb14e62d2009-12-16 02:57:00 +00001406 void EmitCheck(llvm::Value *, unsigned Size);
1407
Chris Lattnerdd36d322010-01-09 21:40:03 +00001408 llvm::Value *EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV,
1409 bool isInc, bool isPre);
1410 ComplexPairTy EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV,
1411 bool isInc, bool isPre);
Reid Spencer5f016e22007-07-11 17:01:13 +00001412 //===--------------------------------------------------------------------===//
Reid Spencer5f016e22007-07-11 17:01:13 +00001413 // Declaration Emission
1414 //===--------------------------------------------------------------------===//
Mike Stump0dd9e882009-02-08 23:14:22 +00001415
Daniel Dunbard286f052009-07-19 06:58:07 +00001416 /// EmitDecl - Emit a declaration.
1417 ///
1418 /// This function can be called with a null (unreachable) insert point.
Reid Spencer5f016e22007-07-11 17:01:13 +00001419 void EmitDecl(const Decl &D);
Daniel Dunbard286f052009-07-19 06:58:07 +00001420
John McCallb6bbcc92010-10-15 04:57:14 +00001421 /// EmitVarDecl - Emit a local variable declaration.
Daniel Dunbard286f052009-07-19 06:58:07 +00001422 ///
1423 /// This function can be called with a null (unreachable) insert point.
John McCallb6bbcc92010-10-15 04:57:14 +00001424 void EmitVarDecl(const VarDecl &D);
Daniel Dunbard286f052009-07-19 06:58:07 +00001425
John McCallf1549f62010-07-06 01:34:17 +00001426 typedef void SpecialInitFn(CodeGenFunction &Init, const VarDecl &D,
1427 llvm::Value *Address);
1428
John McCallb6bbcc92010-10-15 04:57:14 +00001429 /// EmitAutoVarDecl - Emit an auto variable declaration.
Daniel Dunbard286f052009-07-19 06:58:07 +00001430 ///
1431 /// This function can be called with a null (unreachable) insert point.
John McCallb6bbcc92010-10-15 04:57:14 +00001432 void EmitAutoVarDecl(const VarDecl &D, SpecialInitFn *SpecialInit = 0);
Daniel Dunbard286f052009-07-19 06:58:07 +00001433
John McCallb6bbcc92010-10-15 04:57:14 +00001434 void EmitStaticVarDecl(const VarDecl &D,
1435 llvm::GlobalValue::LinkageTypes Linkage);
Daniel Dunbarb7ec2462008-08-16 03:19:19 +00001436
1437 /// EmitParmDecl - Emit a ParmVarDecl or an ImplicitParamDecl.
Devang Patel570729e2011-02-09 00:37:30 +00001438 void EmitParmDecl(const VarDecl &D, llvm::Value *Arg,
1439 bool IndirectArgument = false);
Mike Stump0dd9e882009-02-08 23:14:22 +00001440
Reid Spencer5f016e22007-07-11 17:01:13 +00001441 //===--------------------------------------------------------------------===//
1442 // Statement Emission
1443 //===--------------------------------------------------------------------===//
1444
Mike Stump0dd9e882009-02-08 23:14:22 +00001445 /// EmitStopPoint - Emit a debug stoppoint if we are emitting debug info.
Daniel Dunbar09124252008-11-12 08:21:33 +00001446 void EmitStopPoint(const Stmt *S);
1447
Mike Stump0dd9e882009-02-08 23:14:22 +00001448 /// EmitStmt - Emit the code for the statement \arg S. It is legal to call
1449 /// this function even if there is no current insertion point.
1450 ///
1451 /// This function may clear the current insertion point; callers should use
1452 /// EnsureInsertPoint if they wish to subsequently generate code without first
1453 /// calling EmitBlock, EmitBranch, or EmitStmt.
Reid Spencer5f016e22007-07-11 17:01:13 +00001454 void EmitStmt(const Stmt *S);
Daniel Dunbara448fb22008-11-11 23:11:34 +00001455
Daniel Dunbar09124252008-11-12 08:21:33 +00001456 /// EmitSimpleStmt - Try to emit a "simple" statement which does not
Mike Stump0dd9e882009-02-08 23:14:22 +00001457 /// necessarily require an insertion point or debug information; typically
1458 /// because the statement amounts to a jump or a container of other
1459 /// statements.
Daniel Dunbar09124252008-11-12 08:21:33 +00001460 ///
1461 /// \return True if the statement was handled.
1462 bool EmitSimpleStmt(const Stmt *S);
1463
Chris Lattner9b655512007-08-31 22:49:20 +00001464 RValue EmitCompoundStmt(const CompoundStmt &S, bool GetLast = false,
John McCall558d2ab2010-09-15 10:14:12 +00001465 AggValueSlot AVS = AggValueSlot::ignored());
Daniel Dunbara448fb22008-11-11 23:11:34 +00001466
Mike Stump0dd9e882009-02-08 23:14:22 +00001467 /// EmitLabel - Emit the block for the given label. It is legal to call this
1468 /// function even if there is no current insertion point.
Chris Lattner91d723d2008-07-26 20:23:23 +00001469 void EmitLabel(const LabelStmt &S); // helper for EmitLabelStmt.
Daniel Dunbara448fb22008-11-11 23:11:34 +00001470
Reid Spencer5f016e22007-07-11 17:01:13 +00001471 void EmitLabelStmt(const LabelStmt &S);
1472 void EmitGotoStmt(const GotoStmt &S);
Daniel Dunbar0ffb1252008-08-04 16:51:22 +00001473 void EmitIndirectGotoStmt(const IndirectGotoStmt &S);
Reid Spencer5f016e22007-07-11 17:01:13 +00001474 void EmitIfStmt(const IfStmt &S);
1475 void EmitWhileStmt(const WhileStmt &S);
1476 void EmitDoStmt(const DoStmt &S);
1477 void EmitForStmt(const ForStmt &S);
1478 void EmitReturnStmt(const ReturnStmt &S);
1479 void EmitDeclStmt(const DeclStmt &S);
Daniel Dunbar09124252008-11-12 08:21:33 +00001480 void EmitBreakStmt(const BreakStmt &S);
1481 void EmitContinueStmt(const ContinueStmt &S);
Devang Patel51b09f22007-10-04 23:45:31 +00001482 void EmitSwitchStmt(const SwitchStmt &S);
1483 void EmitDefaultStmt(const DefaultStmt &S);
1484 void EmitCaseStmt(const CaseStmt &S);
Devang Patelc049e4f2007-10-08 20:57:48 +00001485 void EmitCaseStmtRange(const CaseStmt &S);
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001486 void EmitAsmStmt(const AsmStmt &S);
Mike Stump0dd9e882009-02-08 23:14:22 +00001487
Anders Carlsson3d8400d2008-08-30 19:51:14 +00001488 void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S);
Anders Carlsson64d5d6c2008-09-09 10:04:29 +00001489 void EmitObjCAtTryStmt(const ObjCAtTryStmt &S);
1490 void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S);
Chris Lattner10cac6f2008-11-15 21:26:17 +00001491 void EmitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt &S);
Mike Stump0dd9e882009-02-08 23:14:22 +00001492
Douglas Gregor86a3a032010-05-16 01:24:12 +00001493 llvm::Constant *getUnwindResumeOrRethrowFn();
John McCall59a70002010-07-07 06:56:46 +00001494 void EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock = false);
1495 void ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock = false);
John McCall9fc6a772010-02-19 09:25:03 +00001496
Anders Carlsson6815e942009-09-27 18:58:34 +00001497 void EmitCXXTryStmt(const CXXTryStmt &S);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001498
Reid Spencer5f016e22007-07-11 17:01:13 +00001499 //===--------------------------------------------------------------------===//
1500 // LValue Expression Emission
1501 //===--------------------------------------------------------------------===//
1502
Daniel Dunbar13e81732009-02-05 07:09:07 +00001503 /// GetUndefRValue - Get an appropriate 'undef' rvalue for the given type.
1504 RValue GetUndefRValue(QualType Ty);
1505
Daniel Dunbarce1d38b2009-01-09 16:50:52 +00001506 /// EmitUnsupportedRValue - Emit a dummy r-value using the type of E
1507 /// and issue an ErrorUnsupported style diagnostic (using the
1508 /// provided Name).
1509 RValue EmitUnsupportedRValue(const Expr *E,
1510 const char *Name);
1511
Mike Stump0dd9e882009-02-08 23:14:22 +00001512 /// EmitUnsupportedLValue - Emit a dummy l-value using the type of E and issue
1513 /// an ErrorUnsupported style diagnostic (using the provided Name).
Daniel Dunbar6ba82a42008-08-25 20:45:57 +00001514 LValue EmitUnsupportedLValue(const Expr *E,
1515 const char *Name);
1516
Reid Spencer5f016e22007-07-11 17:01:13 +00001517 /// EmitLValue - Emit code to compute a designator that specifies the location
1518 /// of the expression.
1519 ///
1520 /// This can return one of two things: a simple address or a bitfield
1521 /// reference. In either case, the LLVM Value* in the LValue structure is
1522 /// guaranteed to be an LLVM pointer type.
1523 ///
1524 /// If this returns a bitfield reference, nothing about the pointee type of
1525 /// the LLVM value is known: For example, it may not be a pointer to an
1526 /// integer.
1527 ///
1528 /// If this returns a normal address, and if the lvalue's C type is fixed
1529 /// size, this method guarantees that the returned pointer type will point to
1530 /// an LLVM type of the same size of the lvalue's type. If the lvalue has a
1531 /// variable length type, this is not possible.
1532 ///
1533 LValue EmitLValue(const Expr *E);
Mike Stump0dd9e882009-02-08 23:14:22 +00001534
Mike Stumpb14e62d2009-12-16 02:57:00 +00001535 /// EmitCheckedLValue - Same as EmitLValue but additionally we generate
1536 /// checking code to guard against undefined behavior. This is only
1537 /// suitable when we know that the address will be used to access the
1538 /// object.
1539 LValue EmitCheckedLValue(const Expr *E);
1540
John McCall26815d92010-10-27 20:58:56 +00001541 /// EmitToMemory - Change a scalar value from its value
1542 /// representation to its in-memory representation.
1543 llvm::Value *EmitToMemory(llvm::Value *Value, QualType Ty);
1544
1545 /// EmitFromMemory - Change a scalar value from its memory
1546 /// representation to its value representation.
1547 llvm::Value *EmitFromMemory(llvm::Value *Value, QualType Ty);
1548
Daniel Dunbar9d9cc872009-02-10 00:57:50 +00001549 /// EmitLoadOfScalar - Load a scalar value from an address, taking
1550 /// care to appropriately convert from the memory representation to
1551 /// the LLVM value representation.
Mike Stump09429b92009-02-17 17:00:02 +00001552 llvm::Value *EmitLoadOfScalar(llvm::Value *Addr, bool Volatile,
Dan Gohman3d5aff52010-10-14 23:06:10 +00001553 unsigned Alignment, QualType Ty,
1554 llvm::MDNode *TBAAInfo = 0);
Daniel Dunbar9d9cc872009-02-10 00:57:50 +00001555
1556 /// EmitStoreOfScalar - Store a scalar value to an address, taking
1557 /// care to appropriately convert from the memory representation to
1558 /// the LLVM value representation.
Mike Stump09429b92009-02-17 17:00:02 +00001559 void EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr,
Dan Gohman3d5aff52010-10-14 23:06:10 +00001560 bool Volatile, unsigned Alignment, QualType Ty,
1561 llvm::MDNode *TBAAInfo = 0);
Daniel Dunbar9d9cc872009-02-10 00:57:50 +00001562
Reid Spencer5f016e22007-07-11 17:01:13 +00001563 /// EmitLoadOfLValue - Given an expression that represents a value lvalue,
1564 /// this method emits the address of the lvalue, then loads the result as an
1565 /// rvalue, returning the rvalue.
Reid Spencer5f016e22007-07-11 17:01:13 +00001566 RValue EmitLoadOfLValue(LValue V, QualType LVType);
Nate Begeman213541a2008-04-18 23:10:10 +00001567 RValue EmitLoadOfExtVectorElementLValue(LValue V, QualType LVType);
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +00001568 RValue EmitLoadOfBitfieldLValue(LValue LV, QualType ExprType);
John McCall119a1c62010-12-04 02:32:38 +00001569 RValue EmitLoadOfPropertyRefLValue(LValue LV,
1570 ReturnValueSlot Return = ReturnValueSlot());
Mike Stump0dd9e882009-02-08 23:14:22 +00001571
Reid Spencer5f016e22007-07-11 17:01:13 +00001572 /// EmitStoreThroughLValue - Store the specified rvalue into the specified
1573 /// lvalue, where both are guaranteed to the have the same type, and that type
1574 /// is 'Ty'.
1575 void EmitStoreThroughLValue(RValue Src, LValue Dst, QualType Ty);
Nate Begeman213541a2008-04-18 23:10:10 +00001576 void EmitStoreThroughExtVectorComponentLValue(RValue Src, LValue Dst,
1577 QualType Ty);
John McCall119a1c62010-12-04 02:32:38 +00001578 void EmitStoreThroughPropertyRefLValue(RValue Src, LValue Dst);
Daniel Dunbared3849b2008-11-19 09:36:46 +00001579
Mike Stump0dd9e882009-02-08 23:14:22 +00001580 /// EmitStoreThroughLValue - Store Src into Dst with same constraints as
1581 /// EmitStoreThroughLValue.
Daniel Dunbared3849b2008-11-19 09:36:46 +00001582 ///
Mike Stump0dd9e882009-02-08 23:14:22 +00001583 /// \param Result [out] - If non-null, this will be set to a Value* for the
1584 /// bit-field contents after the store, appropriate for use as the result of
1585 /// an assignment to the bit-field.
Daniel Dunbared3849b2008-11-19 09:36:46 +00001586 void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, QualType Ty,
1587 llvm::Value **Result=0);
Mike Stump0dd9e882009-02-08 23:14:22 +00001588
John McCall83ce9d42010-11-16 23:07:28 +00001589 /// Emit an l-value for an assignment (simple or compound) of complex type.
1590 LValue EmitComplexAssignmentLValue(const BinaryOperator *E);
John McCall2a416372010-12-05 02:00:02 +00001591 LValue EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E);
John McCall83ce9d42010-11-16 23:07:28 +00001592
Christopher Lamb22c940e2007-12-29 05:02:41 +00001593 // Note: only availabe for agg return types
Daniel Dunbar80e62c22008-09-04 03:20:13 +00001594 LValue EmitBinaryOperatorLValue(const BinaryOperator *E);
John McCall2a416372010-12-05 02:00:02 +00001595 LValue EmitCompoundAssignmentLValue(const CompoundAssignOperator *E);
Daniel Dunbar5b5c9ef2009-02-11 20:59:32 +00001596 // Note: only available for agg return types
Christopher Lamb22c940e2007-12-29 05:02:41 +00001597 LValue EmitCallExprLValue(const CallExpr *E);
Daniel Dunbar5b5c9ef2009-02-11 20:59:32 +00001598 // Note: only available for agg return types
1599 LValue EmitVAArgExprLValue(const VAArgExpr *E);
Reid Spencer5f016e22007-07-11 17:01:13 +00001600 LValue EmitDeclRefLValue(const DeclRefExpr *E);
1601 LValue EmitStringLiteralLValue(const StringLiteral *E);
Chris Lattnereaf2bb82009-02-24 22:18:39 +00001602 LValue EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E);
Chris Lattnerd9f69102008-08-10 01:53:14 +00001603 LValue EmitPredefinedLValue(const PredefinedExpr *E);
Reid Spencer5f016e22007-07-11 17:01:13 +00001604 LValue EmitUnaryOpLValue(const UnaryOperator *E);
1605 LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E);
Nate Begeman213541a2008-04-18 23:10:10 +00001606 LValue EmitExtVectorElementExpr(const ExtVectorElementExpr *E);
Devang Patelb84a06e2007-10-23 02:10:49 +00001607 LValue EmitMemberExpr(const MemberExpr *E);
Fariborz Jahanian820bca42009-12-09 23:35:29 +00001608 LValue EmitObjCIsaExpr(const ObjCIsaExpr *E);
Eli Friedman06e863f2008-05-13 23:18:27 +00001609 LValue EmitCompoundLiteralLValue(const CompoundLiteralExpr *E);
Anders Carlsson6fcec8b2009-09-15 16:35:24 +00001610 LValue EmitConditionalOperatorLValue(const ConditionalOperator *E);
Chris Lattner75dfeda2009-03-18 18:28:57 +00001611 LValue EmitCastLValue(const CastExpr *E);
Douglas Gregored8abf12010-07-08 06:14:04 +00001612 LValue EmitNullInitializationLValue(const CXXScalarValueInitExpr *E);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001613
Daniel Dunbar2a031922009-04-22 05:08:15 +00001614 llvm::Value *EmitIvarOffset(const ObjCInterfaceDecl *Interface,
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00001615 const ObjCIvarDecl *Ivar);
John McCalla9976d32010-05-21 01:18:57 +00001616 LValue EmitLValueForAnonRecordField(llvm::Value* Base,
Francois Pichet00eb3f92010-12-04 09:14:42 +00001617 const IndirectFieldDecl* Field,
John McCalla9976d32010-05-21 01:18:57 +00001618 unsigned CVRQualifiers);
Anders Carlsson0ed303c2009-11-17 03:57:07 +00001619 LValue EmitLValueForField(llvm::Value* Base, const FieldDecl* Field,
Anders Carlssone6d2a532010-01-29 05:05:36 +00001620 unsigned CVRQualifiers);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001621
Anders Carlsson06a29702010-01-29 05:24:29 +00001622 /// EmitLValueForFieldInitialization - Like EmitLValueForField, except that
1623 /// if the Field is a reference, this will return the address of the reference
1624 /// and not the address of the value stored in the reference.
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001625 LValue EmitLValueForFieldInitialization(llvm::Value* Base,
Anders Carlsson06a29702010-01-29 05:24:29 +00001626 const FieldDecl* Field,
1627 unsigned CVRQualifiers);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001628
Fariborz Jahanian45012a72009-02-03 00:09:52 +00001629 LValue EmitLValueForIvar(QualType ObjectTy,
1630 llvm::Value* Base, const ObjCIvarDecl *Ivar,
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00001631 unsigned CVRQualifiers);
1632
Anders Carlsson0ed303c2009-11-17 03:57:07 +00001633 LValue EmitLValueForBitfield(llvm::Value* Base, const FieldDecl* Field,
Fariborz Jahanian598d3f62009-02-03 19:03:09 +00001634 unsigned CVRQualifiers);
Fariborz Jahanianfd64bb62008-12-15 20:35:07 +00001635
Mike Stumpa99038c2009-02-28 09:07:16 +00001636 LValue EmitBlockDeclRefLValue(const BlockDeclRefExpr *E);
1637
Anders Carlssonb58d0172009-05-30 23:23:33 +00001638 LValue EmitCXXConstructLValue(const CXXConstructExpr *E);
Anders Carlssone61c9e82009-05-30 23:30:54 +00001639 LValue EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E);
John McCall4765fa02010-12-06 08:20:24 +00001640 LValue EmitExprWithCleanupsLValue(const ExprWithCleanups *E);
Mike Stumpc2e84ae2009-11-15 08:09:41 +00001641 LValue EmitCXXTypeidLValue(const CXXTypeidExpr *E);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001642
Daniel Dunbar0a04d772008-08-23 10:51:21 +00001643 LValue EmitObjCMessageExprLValue(const ObjCMessageExpr *E);
Chris Lattner391d77a2008-03-30 23:03:07 +00001644 LValue EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E);
Daniel Dunbar85c59ed2008-08-29 08:11:39 +00001645 LValue EmitObjCPropertyRefLValue(const ObjCPropertyRefExpr *E);
Chris Lattner65459942009-04-25 19:35:26 +00001646 LValue EmitStmtExprLValue(const StmtExpr *E);
Fariborz Jahanian8bfd31f2009-10-22 22:57:31 +00001647 LValue EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E);
Fariborz Jahanian03b29602010-06-17 19:56:20 +00001648 LValue EmitObjCSelectorLValue(const ObjCSelectorExpr *E);
John McCall189d6ef2010-10-09 01:34:31 +00001649 void EmitDeclRefExprDbgValue(const DeclRefExpr *E, llvm::Constant *Init);
Reid Spencer5f016e22007-07-11 17:01:13 +00001650 //===--------------------------------------------------------------------===//
Chris Lattner883f6a72007-08-11 00:04:45 +00001651 // Scalar Expression Emission
Reid Spencer5f016e22007-07-11 17:01:13 +00001652 //===--------------------------------------------------------------------===//
1653
Mike Stump0dd9e882009-02-08 23:14:22 +00001654 /// EmitCall - Generate a call of the given function, expecting the given
1655 /// result type, and using the given argument list which specifies both the
1656 /// LLVM arguments and the types they were derived from.
Daniel Dunbarc0ef9f52009-02-20 18:06:48 +00001657 ///
Mike Stumpf71d2322009-11-30 20:08:49 +00001658 /// \param TargetDecl - If given, the decl of the function in a direct call;
1659 /// used to set attributes on the call (noreturn, etc.).
Daniel Dunbar88b53962009-02-02 22:03:45 +00001660 RValue EmitCall(const CGFunctionInfo &FnInfo,
1661 llvm::Value *Callee,
Anders Carlssonf3c47c92009-12-24 19:25:24 +00001662 ReturnValueSlot ReturnValue,
Daniel Dunbarc0ef9f52009-02-20 18:06:48 +00001663 const CallArgList &Args,
David Chisnalldd5c98f2010-05-01 11:15:56 +00001664 const Decl *TargetDecl = 0,
David Chisnall4b02afc2010-05-02 13:41:58 +00001665 llvm::Instruction **callOrInvoke = 0);
Mike Stump1eb44332009-09-09 15:08:12 +00001666
Anders Carlsson31777a22009-12-24 19:08:58 +00001667 RValue EmitCall(QualType FnType, llvm::Value *Callee,
Anders Carlssond2490a92009-12-24 20:40:36 +00001668 ReturnValueSlot ReturnValue,
Anders Carlsson98647712009-05-27 01:22:39 +00001669 CallExpr::const_arg_iterator ArgBeg,
1670 CallExpr::const_arg_iterator ArgEnd,
1671 const Decl *TargetDecl = 0);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001672 RValue EmitCallExpr(const CallExpr *E,
Anders Carlssond2490a92009-12-24 20:40:36 +00001673 ReturnValueSlot ReturnValue = ReturnValueSlot());
Mike Stump1eb44332009-09-09 15:08:12 +00001674
John McCallf1549f62010-07-06 01:34:17 +00001675 llvm::CallSite EmitCallOrInvoke(llvm::Value *Callee,
1676 llvm::Value * const *ArgBegin,
1677 llvm::Value * const *ArgEnd,
1678 const llvm::Twine &Name = "");
1679
Anders Carlsson566abee2009-11-13 04:45:41 +00001680 llvm::Value *BuildVirtualCall(const CXXMethodDecl *MD, llvm::Value *This,
Mike Stumpf0070db2009-08-26 20:46:33 +00001681 const llvm::Type *Ty);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001682 llvm::Value *BuildVirtualCall(const CXXDestructorDecl *DD, CXXDtorType Type,
Anders Carlsson83eedd92010-11-28 17:53:32 +00001683 llvm::Value *This, const llvm::Type *Ty);
Fariborz Jahanian27262672011-01-20 17:19:02 +00001684 llvm::Value *BuildAppleKextVirtualCall(const CXXMethodDecl *MD,
1685 NestedNameSpecifier *Qual,
Fariborz Jahanian27262672011-01-20 17:19:02 +00001686 const llvm::Type *Ty);
Fariborz Jahanianccd52592011-02-01 23:22:34 +00001687
1688 llvm::Value *BuildAppleKextVirtualDestructorCall(const CXXDestructorDecl *DD,
1689 CXXDtorType Type,
Fariborz Jahanian771c6782011-02-03 19:27:17 +00001690 const CXXRecordDecl *RD);
Anders Carlsson566abee2009-11-13 04:45:41 +00001691
Anders Carlssonb9de2c52009-05-11 23:37:08 +00001692 RValue EmitCXXMemberCall(const CXXMethodDecl *MD,
1693 llvm::Value *Callee,
Anders Carlssona1736c02009-12-24 21:13:40 +00001694 ReturnValueSlot ReturnValue,
Anders Carlssonb9de2c52009-05-11 23:37:08 +00001695 llvm::Value *This,
Anders Carlssonc997d422010-01-02 01:01:18 +00001696 llvm::Value *VTT,
Anders Carlssonb9de2c52009-05-11 23:37:08 +00001697 CallExpr::const_arg_iterator ArgBeg,
1698 CallExpr::const_arg_iterator ArgEnd);
Anders Carlssona1736c02009-12-24 21:13:40 +00001699 RValue EmitCXXMemberCallExpr(const CXXMemberCallExpr *E,
1700 ReturnValueSlot ReturnValue);
1701 RValue EmitCXXMemberPointerCallExpr(const CXXMemberCallExpr *E,
1702 ReturnValueSlot ReturnValue);
Ted Kremenek55499762008-06-17 02:43:46 +00001703
Anders Carlsson0f294632009-05-27 04:18:27 +00001704 RValue EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E,
Anders Carlssona1736c02009-12-24 21:13:40 +00001705 const CXXMethodDecl *MD,
1706 ReturnValueSlot ReturnValue);
Mike Stump1eb44332009-09-09 15:08:12 +00001707
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001708
Mike Stump1eb44332009-09-09 15:08:12 +00001709 RValue EmitBuiltinExpr(const FunctionDecl *FD,
Daniel Dunbaref2abfe2009-02-16 22:43:43 +00001710 unsigned BuiltinID, const CallExpr *E);
Reid Spencer5f016e22007-07-11 17:01:13 +00001711
Anders Carlssona1736c02009-12-24 21:13:40 +00001712 RValue EmitBlockCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue);
Mike Stump09429b92009-02-17 17:00:02 +00001713
Mike Stump0dd9e882009-02-08 23:14:22 +00001714 /// EmitTargetBuiltinExpr - Emit the given builtin call. Returns 0 if the call
1715 /// is unhandled by the current target.
Daniel Dunbarf02e9dd2008-10-10 00:24:54 +00001716 llvm::Value *EmitTargetBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
1717
Chris Lattner2752c012010-03-03 19:03:45 +00001718 llvm::Value *EmitARMBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001719 llvm::Value *EmitNeonCall(llvm::Function *F,
Nate Begeman30d91712010-06-08 06:03:01 +00001720 llvm::SmallVectorImpl<llvm::Value*> &O,
Bob Wilsondb3d4d02010-12-08 22:37:56 +00001721 const char *name,
Nate Begeman61eecf52010-06-14 05:21:25 +00001722 unsigned shift = 0, bool rightshift = false);
Bob Wilsoncf556522010-12-07 22:40:02 +00001723 llvm::Value *EmitNeonSplat(llvm::Value *V, llvm::Constant *Idx);
Nate Begeman464ccb62010-06-11 22:57:12 +00001724 llvm::Value *EmitNeonShiftVector(llvm::Value *V, const llvm::Type *Ty,
Nate Begeman61eecf52010-06-14 05:21:25 +00001725 bool negateForRightShift);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001726
Bill Wendlingaa51e512010-10-09 08:47:25 +00001727 llvm::Value *BuildVector(const llvm::SmallVectorImpl<llvm::Value*> &Ops);
Anders Carlsson564f1de2007-12-09 23:17:02 +00001728 llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E);
1729 llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
Mike Stump0dd9e882009-02-08 23:14:22 +00001730
Daniel Dunbared7c6182008-08-20 00:28:19 +00001731 llvm::Value *EmitObjCProtocolExpr(const ObjCProtocolExpr *E);
Chris Lattner7f02f722007-08-24 05:35:26 +00001732 llvm::Value *EmitObjCStringLiteral(const ObjCStringLiteral *E);
Chris Lattner8fdf3282008-06-24 17:04:18 +00001733 llvm::Value *EmitObjCSelectorExpr(const ObjCSelectorExpr *E);
John McCallef072fd2010-05-22 01:48:05 +00001734 RValue EmitObjCMessageExpr(const ObjCMessageExpr *E,
1735 ReturnValueSlot Return = ReturnValueSlot());
Chris Lattner8fdf3282008-06-24 17:04:18 +00001736
Anders Carlsson4029ca72009-05-20 00:24:07 +00001737 /// EmitReferenceBindingToExpr - Emits a reference binding to the passed in
1738 /// expression. Will emit a temporary variable if E is not an LValue.
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001739 RValue EmitReferenceBindingToExpr(const Expr* E,
Anders Carlsson32f36ba2010-06-26 16:35:32 +00001740 const NamedDecl *InitializedDecl);
Anders Carlsson3aba0932010-01-31 18:34:51 +00001741
Chris Lattner883f6a72007-08-11 00:04:45 +00001742 //===--------------------------------------------------------------------===//
Chris Lattnerbfc0c1a2007-08-26 23:13:56 +00001743 // Expression Emission
Chris Lattner883f6a72007-08-11 00:04:45 +00001744 //===--------------------------------------------------------------------===//
Chris Lattnerbfc0c1a2007-08-26 23:13:56 +00001745
1746 // Expressions are broken into three classes: scalar, complex, aggregate.
Mike Stump0dd9e882009-02-08 23:14:22 +00001747
1748 /// EmitScalarExpr - Emit the computation of the specified expression of LLVM
1749 /// scalar type, returning the result.
Anders Carlsson14c5cbf2009-08-16 07:36:22 +00001750 llvm::Value *EmitScalarExpr(const Expr *E , bool IgnoreResultAssign = false);
Mike Stump0dd9e882009-02-08 23:14:22 +00001751
Chris Lattner3707b252007-08-26 06:48:56 +00001752 /// EmitScalarConversion - Emit a conversion from the specified type to the
1753 /// specified destination type, both of which are LLVM scalar types.
1754 llvm::Value *EmitScalarConversion(llvm::Value *Src, QualType SrcTy,
1755 QualType DstTy);
Mike Stump0dd9e882009-02-08 23:14:22 +00001756
Chris Lattner4f1a7b32007-08-26 16:34:22 +00001757 /// EmitComplexToScalarConversion - Emit a conversion from the specified
Mike Stump0dd9e882009-02-08 23:14:22 +00001758 /// complex type to the specified destination type, where the destination type
1759 /// is an LLVM scalar type.
Chris Lattner4f1a7b32007-08-26 16:34:22 +00001760 llvm::Value *EmitComplexToScalarConversion(ComplexPairTy Src, QualType SrcTy,
1761 QualType DstTy);
Mike Stump0dd9e882009-02-08 23:14:22 +00001762
1763
John McCall558d2ab2010-09-15 10:14:12 +00001764 /// EmitAggExpr - Emit the computation of the specified expression
1765 /// of aggregate type. The result is computed into the given slot,
1766 /// which may be null to indicate that the value is not needed.
Fariborz Jahanian474e2fe2010-09-16 00:20:07 +00001767 void EmitAggExpr(const Expr *E, AggValueSlot AS, bool IgnoreResult = false);
Mike Stump0dd9e882009-02-08 23:14:22 +00001768
Daniel Dunbar18aba0d2010-02-05 19:38:31 +00001769 /// EmitAggExprToLValue - Emit the computation of the specified expression of
1770 /// aggregate type into a temporary LValue.
1771 LValue EmitAggExprToLValue(const Expr *E);
1772
Fariborz Jahanian082b02e2009-07-08 01:18:33 +00001773 /// EmitGCMemmoveCollectable - Emit special API for structs with object
1774 /// pointers.
1775 void EmitGCMemmoveCollectable(llvm::Value *DestPtr, llvm::Value *SrcPtr,
Fariborz Jahanian08c32132009-08-31 19:33:16 +00001776 QualType Ty);
Fariborz Jahanian082b02e2009-07-08 01:18:33 +00001777
Chris Lattnerb6ef18a2007-08-21 05:54:00 +00001778 /// EmitComplexExpr - Emit the computation of the specified expression of
Chris Lattner23b1cdb2007-08-23 23:43:33 +00001779 /// complex type, returning the result.
John McCallb418d742010-11-16 10:08:07 +00001780 ComplexPairTy EmitComplexExpr(const Expr *E,
1781 bool IgnoreReal = false,
1782 bool IgnoreImag = false);
Mike Stump0dd9e882009-02-08 23:14:22 +00001783
Chris Lattner23b1cdb2007-08-23 23:43:33 +00001784 /// EmitComplexExprIntoAddr - Emit the computation of the specified expression
1785 /// of complex type, storing into the specified Value*.
Chris Lattner190dbe22007-08-26 16:22:13 +00001786 void EmitComplexExprIntoAddr(const Expr *E, llvm::Value *DestAddr,
1787 bool DestIsVolatile);
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +00001788
1789 /// StoreComplexToAddr - Store a complex number into the specified address.
1790 void StoreComplexToAddr(ComplexPairTy V, llvm::Value *DestAddr,
1791 bool DestIsVolatile);
Chris Lattner9b655512007-08-31 22:49:20 +00001792 /// LoadComplexFromAddr - Load a complex number from the specified address.
1793 ComplexPairTy LoadComplexFromAddr(llvm::Value *SrcAddr, bool SrcIsVolatile);
Chris Lattner2621fd12008-05-08 05:58:21 +00001794
John McCallb6bbcc92010-10-15 04:57:14 +00001795 /// CreateStaticVarDecl - Create a zero-initialized LLVM global for
1796 /// a static local variable.
1797 llvm::GlobalVariable *CreateStaticVarDecl(const VarDecl &D,
1798 const char *Separator,
Mike Stumpf71d2322009-11-30 20:08:49 +00001799 llvm::GlobalValue::LinkageTypes Linkage);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001800
John McCallb6bbcc92010-10-15 04:57:14 +00001801 /// AddInitializerToStaticVarDecl - Add the initializer for 'D' to the
Chris Lattner761acc12009-12-05 08:22:11 +00001802 /// global variable that has already been created for it. If the initializer
1803 /// has a different type than GV does, this may free GV and return a different
1804 /// one. Otherwise it just returns GV.
1805 llvm::GlobalVariable *
John McCallb6bbcc92010-10-15 04:57:14 +00001806 AddInitializerToStaticVarDecl(const VarDecl &D,
1807 llvm::GlobalVariable *GV);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001808
Daniel Dunbar0096acf2009-02-25 19:24:29 +00001809
Anders Carlsson3b2e16b2009-08-08 21:45:14 +00001810 /// EmitCXXGlobalVarDeclInit - Create the initializer for a C++
1811 /// variable with global storage.
1812 void EmitCXXGlobalVarDeclInit(const VarDecl &D, llvm::Constant *DeclPtr);
1813
1814 /// EmitCXXGlobalDtorRegistration - Emits a call to register the global ptr
1815 /// with the C++ runtime so that its destructor will be called at exit.
Fariborz Jahanian88f42802009-11-10 19:24:06 +00001816 void EmitCXXGlobalDtorRegistration(llvm::Constant *DtorFn,
Anders Carlsson3b2e16b2009-08-08 21:45:14 +00001817 llvm::Constant *DeclPtr);
Mike Stump1eb44332009-09-09 15:08:12 +00001818
John McCall3030eb82010-11-06 09:44:32 +00001819 /// Emit code in this function to perform a guarded variable
1820 /// initialization. Guarded initializations are used when it's not
1821 /// possible to prove that an initialization will be done exactly
1822 /// once, e.g. with a static local variable or a static data member
1823 /// of a class template.
1824 void EmitCXXGuardedInit(const VarDecl &D, llvm::GlobalVariable *DeclPtr);
John McCall5cd91b52010-09-08 01:44:27 +00001825
Daniel Dunbarefb0fa92010-03-20 04:15:41 +00001826 /// GenerateCXXGlobalInitFunc - Generates code for initializing global
1827 /// variables.
1828 void GenerateCXXGlobalInitFunc(llvm::Function *Fn,
1829 llvm::Constant **Decls,
1830 unsigned NumDecls);
1831
1832 /// GenerateCXXGlobalDtorFunc - Generates code for destroying global
1833 /// variables.
1834 void GenerateCXXGlobalDtorFunc(llvm::Function *Fn,
Chris Lattner810112e2010-06-19 05:52:45 +00001835 const std::vector<std::pair<llvm::WeakVH,
Daniel Dunbarefb0fa92010-03-20 04:15:41 +00001836 llvm::Constant*> > &DtorsAndObjects);
1837
John McCall3030eb82010-11-06 09:44:32 +00001838 void GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn, const VarDecl *D,
1839 llvm::GlobalVariable *Addr);
Daniel Dunbarefb0fa92010-03-20 04:15:41 +00001840
John McCall558d2ab2010-09-15 10:14:12 +00001841 void EmitCXXConstructExpr(const CXXConstructExpr *E, AggValueSlot Dest);
Fariborz Jahanian34999872010-11-13 21:53:34 +00001842
1843 void EmitSynthesizedCXXCopyCtor(llvm::Value *Dest, llvm::Value *Src,
Fariborz Jahanian830937b2010-12-02 17:02:11 +00001844 const Expr *Exp);
Mike Stump1eb44332009-09-09 15:08:12 +00001845
John McCall4765fa02010-12-06 08:20:24 +00001846 RValue EmitExprWithCleanups(const ExprWithCleanups *E,
1847 AggValueSlot Slot =AggValueSlot::ignored());
Mike Stump1eb44332009-09-09 15:08:12 +00001848
Anders Carlsson756b5c42009-10-30 01:42:31 +00001849 void EmitCXXThrowExpr(const CXXThrowExpr *E);
Douglas Gregor1eb2e592010-05-16 00:44:00 +00001850
Daniel Dunbar0ffb1252008-08-04 16:51:22 +00001851 //===--------------------------------------------------------------------===//
1852 // Internal Helpers
1853 //===--------------------------------------------------------------------===//
Mike Stump0dd9e882009-02-08 23:14:22 +00001854
Chris Lattner0946ccd2008-11-11 07:41:27 +00001855 /// ContainsLabel - Return true if the statement contains a label in it. If
1856 /// this statement is not executed normally, it not containing a label means
1857 /// that we can just remove the code.
1858 static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts = false);
Mike Stump0dd9e882009-02-08 23:14:22 +00001859
Daniel Dunbar4bc04552008-11-12 10:12:14 +00001860 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
Chris Lattner31a09842008-11-12 08:04:58 +00001861 /// to a constant, or if it does but contains a label, return 0. If it
1862 /// constant folds to 'true' and does not contain a label, return 1, if it
1863 /// constant folds to 'false' and does not contain a label, return -1.
1864 int ConstantFoldsToSimpleInteger(const Expr *Cond);
Mike Stump0dd9e882009-02-08 23:14:22 +00001865
Chris Lattner31a09842008-11-12 08:04:58 +00001866 /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an
1867 /// if statement) to the specified blocks. Based on the condition, this might
1868 /// try to simplify the codegen of the conditional based on the branch.
Chris Lattner9bc47e22008-11-12 07:46:33 +00001869 void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock,
Daniel Dunbar4bc04552008-11-12 10:12:14 +00001870 llvm::BasicBlock *FalseBlock);
Mike Stumpbe07f602009-12-14 21:58:14 +00001871
Mike Stump15037ca2009-12-15 00:35:12 +00001872 /// getTrapBB - Create a basic block that will call the trap intrinsic. We'll
1873 /// generate a branch around the created basic block as necessary.
Chris Lattner6c552c12010-07-20 20:19:24 +00001874 llvm::BasicBlock *getTrapBB();
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001875
Anders Carlsson21c9ad92010-03-30 03:27:09 +00001876 /// EmitCallArg - Emit a single call argument.
1877 RValue EmitCallArg(const Expr *E, QualType ArgType);
1878
John McCall27360712010-05-26 22:34:26 +00001879 /// EmitDelegateCallArg - We are performing a delegate call; that
1880 /// is, the current function is delegating to another one. Produce
1881 /// a r-value suitable for passing the given parameter.
1882 RValue EmitDelegateCallArg(const VarDecl *Param);
1883
Chris Lattner31a09842008-11-12 08:04:58 +00001884private:
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00001885 void EmitReturnOfRValue(RValue RV, QualType Ty);
1886
Daniel Dunbar56273772008-09-17 00:51:38 +00001887 /// ExpandTypeFromArgs - Reconstruct a structure of type \arg Ty
1888 /// from function arguments into \arg Dst. See ABIArgInfo::Expand.
1889 ///
1890 /// \param AI - The first function argument of the expansion.
1891 /// \return The argument following the last expanded function
1892 /// argument.
Mike Stump0dd9e882009-02-08 23:14:22 +00001893 llvm::Function::arg_iterator
Daniel Dunbar56273772008-09-17 00:51:38 +00001894 ExpandTypeFromArgs(QualType Ty, LValue Dst,
1895 llvm::Function::arg_iterator AI);
1896
Mike Stump0dd9e882009-02-08 23:14:22 +00001897 /// ExpandTypeToArgs - Expand an RValue \arg Src, with the LLVM type for \arg
1898 /// Ty, into individual arguments on the provided vector \arg Args. See
1899 /// ABIArgInfo::Expand.
1900 void ExpandTypeToArgs(QualType Ty, RValue Src,
Daniel Dunbar56273772008-09-17 00:51:38 +00001901 llvm::SmallVector<llvm::Value*, 16> &Args);
Anders Carlssonc8c7b182009-01-11 19:40:10 +00001902
Mike Stump1eb44332009-09-09 15:08:12 +00001903 llvm::Value* EmitAsmInput(const AsmStmt &S,
Daniel Dunbarb84e8a62009-05-04 06:56:16 +00001904 const TargetInfo::ConstraintInfo &Info,
Anders Carlssonc8c7b182009-01-11 19:40:10 +00001905 const Expr *InputExpr, std::string &ConstraintStr);
Mike Stump0dd9e882009-02-08 23:14:22 +00001906
Eli Friedman6d7cfd72010-07-16 00:55:21 +00001907 llvm::Value* EmitAsmInputLValue(const AsmStmt &S,
1908 const TargetInfo::ConstraintInfo &Info,
1909 LValue InputValue, QualType InputType,
1910 std::string &ConstraintStr);
1911
Anders Carlsson0139bb92009-04-08 20:47:54 +00001912 /// EmitCallArgs - Emit call arguments for a function.
Mike Stump1eb44332009-09-09 15:08:12 +00001913 /// The CallArgTypeInfo parameter is used for iterating over the known
Anders Carlssonaf23f692009-04-18 20:20:22 +00001914 /// argument types of the function being called.
1915 template<typename T>
1916 void EmitCallArgs(CallArgList& Args, const T* CallArgTypeInfo,
Anders Carlsson0139bb92009-04-08 20:47:54 +00001917 CallExpr::const_arg_iterator ArgBeg,
Anders Carlssonaf23f692009-04-18 20:20:22 +00001918 CallExpr::const_arg_iterator ArgEnd) {
1919 CallExpr::const_arg_iterator Arg = ArgBeg;
Anders Carlsson0139bb92009-04-08 20:47:54 +00001920
Anders Carlssonaf23f692009-04-18 20:20:22 +00001921 // First, use the argument types that the type info knows about
1922 if (CallArgTypeInfo) {
1923 for (typename T::arg_type_iterator I = CallArgTypeInfo->arg_type_begin(),
1924 E = CallArgTypeInfo->arg_type_end(); I != E; ++I, ++Arg) {
Eli Friedman44b0a3e2009-11-18 03:42:04 +00001925 assert(Arg != ArgEnd && "Running over edge of argument list!");
Anders Carlssonaf23f692009-04-18 20:20:22 +00001926 QualType ArgType = *I;
Fariborz Jahanian745da3a2010-09-24 17:30:16 +00001927#ifndef NDEBUG
1928 QualType ActualArgType = Arg->getType();
1929 if (ArgType->isPointerType() && ActualArgType->isPointerType()) {
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001930 QualType ActualBaseType =
Fariborz Jahanian745da3a2010-09-24 17:30:16 +00001931 ActualArgType->getAs<PointerType>()->getPointeeType();
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001932 QualType ArgBaseType =
Fariborz Jahanian745da3a2010-09-24 17:30:16 +00001933 ArgType->getAs<PointerType>()->getPointeeType();
1934 if (ArgBaseType->isVariableArrayType()) {
1935 if (const VariableArrayType *VAT =
1936 getContext().getAsVariableArrayType(ActualBaseType)) {
1937 if (!VAT->getSizeExpr())
1938 ActualArgType = ArgType;
1939 }
1940 }
1941 }
Anders Carlssonaf23f692009-04-18 20:20:22 +00001942 assert(getContext().getCanonicalType(ArgType.getNonReferenceType()).
Mike Stump1eb44332009-09-09 15:08:12 +00001943 getTypePtr() ==
Fariborz Jahanian745da3a2010-09-24 17:30:16 +00001944 getContext().getCanonicalType(ActualArgType).getTypePtr() &&
Anders Carlssonaf23f692009-04-18 20:20:22 +00001945 "type mismatch in call argument!");
Fariborz Jahanian745da3a2010-09-24 17:30:16 +00001946#endif
Mike Stump1eb44332009-09-09 15:08:12 +00001947 Args.push_back(std::make_pair(EmitCallArg(*Arg, ArgType),
Anders Carlssonaf23f692009-04-18 20:20:22 +00001948 ArgType));
1949 }
Mike Stump1eb44332009-09-09 15:08:12 +00001950
1951 // Either we've emitted all the call args, or we have a call to a
Anders Carlssonaf23f692009-04-18 20:20:22 +00001952 // variadic function.
Mike Stump1eb44332009-09-09 15:08:12 +00001953 assert((Arg == ArgEnd || CallArgTypeInfo->isVariadic()) &&
Anders Carlssonaf23f692009-04-18 20:20:22 +00001954 "Extra arguments in non-variadic function!");
Mike Stump1eb44332009-09-09 15:08:12 +00001955
Anders Carlssonaf23f692009-04-18 20:20:22 +00001956 }
Mike Stump1eb44332009-09-09 15:08:12 +00001957
Anders Carlssonaf23f692009-04-18 20:20:22 +00001958 // If we still have any arguments, emit them using the type of the argument.
1959 for (; Arg != ArgEnd; ++Arg) {
1960 QualType ArgType = Arg->getType();
1961 Args.push_back(std::make_pair(EmitCallArg(*Arg, ArgType),
1962 ArgType));
1963 }
1964 }
John McCall492c4f92010-03-03 04:15:11 +00001965
1966 const TargetCodeGenInfo &getTargetHooks() const {
1967 return CGM.getTargetCodeGenInfo();
1968 }
John McCall744016d2010-07-06 23:57:41 +00001969
1970 void EmitDeclMetadata();
Reid Spencer5f016e22007-07-11 17:01:13 +00001971};
Mike Stump1eb44332009-09-09 15:08:12 +00001972
John McCall150b4622011-01-26 04:00:11 +00001973/// Helper class with most of the code for saving a value for a
1974/// conditional expression cleanup.
John McCall804b8072011-01-28 10:53:53 +00001975struct DominatingLLVMValue {
John McCall150b4622011-01-26 04:00:11 +00001976 typedef llvm::PointerIntPair<llvm::Value*, 1, bool> saved_type;
1977
1978 /// Answer whether the given value needs extra work to be saved.
1979 static bool needsSaving(llvm::Value *value) {
1980 // If it's not an instruction, we don't need to save.
1981 if (!isa<llvm::Instruction>(value)) return false;
1982
1983 // If it's an instruction in the entry block, we don't need to save.
1984 llvm::BasicBlock *block = cast<llvm::Instruction>(value)->getParent();
1985 return (block != &block->getParent()->getEntryBlock());
1986 }
1987
1988 /// Try to save the given value.
1989 static saved_type save(CodeGenFunction &CGF, llvm::Value *value) {
1990 if (!needsSaving(value)) return saved_type(value, false);
1991
1992 // Otherwise we need an alloca.
1993 llvm::Value *alloca =
1994 CGF.CreateTempAlloca(value->getType(), "cond-cleanup.save");
1995 CGF.Builder.CreateStore(value, alloca);
1996
1997 return saved_type(alloca, true);
1998 }
1999
2000 static llvm::Value *restore(CodeGenFunction &CGF, saved_type value) {
2001 if (!value.getInt()) return value.getPointer();
2002 return CGF.Builder.CreateLoad(value.getPointer());
2003 }
2004};
2005
John McCall804b8072011-01-28 10:53:53 +00002006/// A partial specialization of DominatingValue for llvm::Values that
2007/// might be llvm::Instructions.
2008template <class T> struct DominatingPointer<T,true> : DominatingLLVMValue {
2009 typedef T *type;
John McCall150b4622011-01-26 04:00:11 +00002010 static type restore(CodeGenFunction &CGF, saved_type value) {
John McCall804b8072011-01-28 10:53:53 +00002011 return static_cast<T*>(DominatingLLVMValue::restore(CGF, value));
2012 }
2013};
2014
2015/// A specialization of DominatingValue for RValue.
2016template <> struct DominatingValue<RValue> {
2017 typedef RValue type;
2018 class saved_type {
2019 enum Kind { ScalarLiteral, ScalarAddress, AggregateLiteral,
2020 AggregateAddress, ComplexAddress };
2021
2022 llvm::Value *Value;
2023 Kind K;
2024 saved_type(llvm::Value *v, Kind k) : Value(v), K(k) {}
2025
2026 public:
2027 static bool needsSaving(RValue value);
2028 static saved_type save(CodeGenFunction &CGF, RValue value);
2029 RValue restore(CodeGenFunction &CGF);
2030
2031 // implementations in CGExprCXX.cpp
2032 };
2033
2034 static bool needsSaving(type value) {
2035 return saved_type::needsSaving(value);
2036 }
2037 static saved_type save(CodeGenFunction &CGF, type value) {
2038 return saved_type::save(CGF, value);
2039 }
2040 static type restore(CodeGenFunction &CGF, saved_type value) {
2041 return value.restore(CGF);
John McCall150b4622011-01-26 04:00:11 +00002042 }
2043};
2044
Reid Spencer5f016e22007-07-11 17:01:13 +00002045} // end namespace CodeGen
2046} // end namespace clang
2047
2048#endif