blob: fa86f056adf8da5f2ab4de8df2b3fd80d13af223 [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 Dunbar8f2926b2008-08-23 03:46:30 +000028#include "CGValue.h"
29
Reid Spencer5f016e22007-07-11 17:01:13 +000030namespace llvm {
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000031 class BasicBlock;
Benjamin Kramerf21efe92009-08-11 17:46:57 +000032 class LLVMContext;
David Chisnalldd5c98f2010-05-01 11:15:56 +000033 class MDNode;
Reid Spencer5f016e22007-07-11 17:01:13 +000034 class Module;
Daniel Dunbar898d5082008-09-30 01:06:03 +000035 class SwitchInst;
Daniel Dunbar259e9cc2009-10-19 01:21:05 +000036 class Twine;
Daniel Dunbared3849b2008-11-19 09:36:46 +000037 class Value;
John McCallf1549f62010-07-06 01:34:17 +000038 class CallSite;
Reid Spencer5f016e22007-07-11 17:01:13 +000039}
40
41namespace clang {
Devang Patel8d308382010-08-10 07:24:25 +000042 class APValue;
Reid Spencer5f016e22007-07-11 17:01:13 +000043 class ASTContext;
Anders Carlsson7267c162009-05-29 21:03:38 +000044 class CXXDestructorDecl;
Richard Smithad762fc2011-04-14 22:09:26 +000045 class CXXForRangeStmt;
Anders Carlsson6815e942009-09-27 18:58:34 +000046 class CXXTryStmt;
Reid Spencer5f016e22007-07-11 17:01:13 +000047 class Decl;
Chris Lattnerad8dcf42011-02-17 07:39:24 +000048 class LabelDecl;
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000049 class EnumConstantDecl;
Reid Spencer5f016e22007-07-11 17:01:13 +000050 class FunctionDecl;
Douglas Gregor72564e72009-02-26 23:50:07 +000051 class FunctionProtoType;
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000052 class LabelStmt;
Fariborz Jahanian679a5022009-01-10 21:06:09 +000053 class ObjCContainerDecl;
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +000054 class ObjCInterfaceDecl;
55 class ObjCIvarDecl;
Chris Lattner391d77a2008-03-30 23:03:07 +000056 class ObjCMethodDecl;
Fariborz Jahanianfef30b52008-12-09 20:23:04 +000057 class ObjCImplementationDecl;
Daniel Dunbaraf05bb92008-08-26 08:29:31 +000058 class ObjCPropertyImplDecl;
Reid Spencer5f016e22007-07-11 17:01:13 +000059 class TargetInfo;
John McCall492c4f92010-03-03 04:15:11 +000060 class TargetCodeGenInfo;
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000061 class VarDecl;
Chris Lattner16f00492009-04-26 01:32:48 +000062 class ObjCForCollectionStmt;
63 class ObjCAtTryStmt;
64 class ObjCAtThrowStmt;
65 class ObjCAtSynchronizedStmt;
Devang Patelb84a06e2007-10-23 02:10:49 +000066
Reid Spencer5f016e22007-07-11 17:01:13 +000067namespace CodeGen {
Devang Patelb84a06e2007-10-23 02:10:49 +000068 class CodeGenTypes;
Anders Carlssone896d982009-02-13 08:11:52 +000069 class CGDebugInfo;
Daniel Dunbarbb36d332009-02-02 21:43:58 +000070 class CGFunctionInfo;
Mike Stump0dd9e882009-02-08 23:14:22 +000071 class CGRecordLayout;
John McCallee504292010-05-21 04:11:14 +000072 class CGBlockInfo;
John McCall4c40d982010-08-31 07:33:07 +000073 class CGCXXABI;
John McCalld16c2cf2011-02-08 08:22:06 +000074 class BlockFlags;
75 class BlockFieldFlags;
Mike Stump0dd9e882009-02-08 23:14:22 +000076
John McCallf1549f62010-07-06 01:34:17 +000077/// A branch fixup. These are required when emitting a goto to a
78/// label which hasn't been emitted yet. The goto is optimistically
79/// emitted as a branch to the basic block for the label, and (if it
80/// occurs in a scope with non-trivial cleanups) a fixup is added to
81/// the innermost cleanup. When a (normal) cleanup is popped, any
82/// unresolved fixups in that scope are threaded through the cleanup.
83struct BranchFixup {
John McCallff8e1152010-07-23 21:56:41 +000084 /// The block containing the terminator which needs to be modified
85 /// into a switch if this fixup is resolved into the current scope.
86 /// If null, LatestBranch points directly to the destination.
87 llvm::BasicBlock *OptimisticBranchBlock;
John McCallf1549f62010-07-06 01:34:17 +000088
John McCallff8e1152010-07-23 21:56:41 +000089 /// The ultimate destination of the branch.
John McCallf1549f62010-07-06 01:34:17 +000090 ///
91 /// This can be set to null to indicate that this fixup was
92 /// successfully resolved.
93 llvm::BasicBlock *Destination;
94
John McCallff8e1152010-07-23 21:56:41 +000095 /// The destination index value.
96 unsigned DestinationIndex;
97
98 /// The initial branch of the fixup.
99 llvm::BranchInst *InitialBranch;
John McCallf1549f62010-07-06 01:34:17 +0000100};
101
John McCall804b8072011-01-28 10:53:53 +0000102template <class T> struct InvariantValue {
John McCall150b4622011-01-26 04:00:11 +0000103 typedef T type;
104 typedef T saved_type;
105 static bool needsSaving(type value) { return false; }
106 static saved_type save(CodeGenFunction &CGF, type value) { return value; }
107 static type restore(CodeGenFunction &CGF, saved_type value) { return value; }
108};
John McCall804b8072011-01-28 10:53:53 +0000109
110/// A metaprogramming class for ensuring that a value will dominate an
111/// arbitrary position in a function.
112template <class T> struct DominatingValue : InvariantValue<T> {};
113
114template <class T, bool mightBeInstruction =
115 llvm::is_base_of<llvm::Value, T>::value &&
116 !llvm::is_base_of<llvm::Constant, T>::value &&
117 !llvm::is_base_of<llvm::BasicBlock, T>::value>
118struct DominatingPointer;
119template <class T> struct DominatingPointer<T,false> : InvariantValue<T*> {};
120// template <class T> struct DominatingPointer<T,true> at end of file
121
122template <class T> struct DominatingValue<T*> : DominatingPointer<T> {};
John McCall150b4622011-01-26 04:00:11 +0000123
John McCallcd2d2b72010-08-13 21:20:51 +0000124enum CleanupKind {
125 EHCleanup = 0x1,
126 NormalCleanup = 0x2,
127 NormalAndEHCleanup = EHCleanup | NormalCleanup,
128
129 InactiveCleanup = 0x4,
130 InactiveEHCleanup = EHCleanup | InactiveCleanup,
131 InactiveNormalCleanup = NormalCleanup | InactiveCleanup,
132 InactiveNormalAndEHCleanup = NormalAndEHCleanup | InactiveCleanup
133};
John McCallda65ea82010-07-13 20:32:21 +0000134
John McCallf1549f62010-07-06 01:34:17 +0000135/// A stack of scopes which respond to exceptions, including cleanups
136/// and catch blocks.
137class EHScopeStack {
138public:
139 /// A saved depth on the scope stack. This is necessary because
140 /// pushing scopes onto the stack invalidates iterators.
141 class stable_iterator {
142 friend class EHScopeStack;
143
144 /// Offset from StartOfData to EndOfBuffer.
145 ptrdiff_t Size;
146
147 stable_iterator(ptrdiff_t Size) : Size(Size) {}
148
149 public:
150 static stable_iterator invalid() { return stable_iterator(-1); }
151 stable_iterator() : Size(-1) {}
152
153 bool isValid() const { return Size >= 0; }
154
John McCall838d7962010-08-14 07:46:19 +0000155 /// Returns true if this scope encloses I.
156 /// Returns false if I is invalid.
157 /// This scope must be valid.
John McCallff8e1152010-07-23 21:56:41 +0000158 bool encloses(stable_iterator I) const { return Size <= I.Size; }
John McCall838d7962010-08-14 07:46:19 +0000159
160 /// Returns true if this scope strictly encloses I: that is,
161 /// if it encloses I and is not I.
162 /// Returns false is I is invalid.
163 /// This scope must be valid.
John McCallff8e1152010-07-23 21:56:41 +0000164 bool strictlyEncloses(stable_iterator I) const { return Size < I.Size; }
John McCall1bda6622010-07-21 00:40:03 +0000165
John McCallf1549f62010-07-06 01:34:17 +0000166 friend bool operator==(stable_iterator A, stable_iterator B) {
167 return A.Size == B.Size;
168 }
169 friend bool operator!=(stable_iterator A, stable_iterator B) {
170 return A.Size != B.Size;
171 }
172 };
173
John McCall1f0fca52010-07-21 07:22:38 +0000174 /// Information for lazily generating a cleanup. Subclasses must be
175 /// POD-like: cleanups will not be destructed, and they will be
176 /// allocated on the cleanup stack and freely copied and moved
177 /// around.
John McCallda65ea82010-07-13 20:32:21 +0000178 ///
John McCall1f0fca52010-07-21 07:22:38 +0000179 /// Cleanup implementations should generally be declared in an
John McCallda65ea82010-07-13 20:32:21 +0000180 /// anonymous namespace.
John McCall1f0fca52010-07-21 07:22:38 +0000181 class Cleanup {
John McCallda65ea82010-07-13 20:32:21 +0000182 public:
John McCall3e29f962010-07-13 23:19:49 +0000183 // Anchor the construction vtable. We use the destructor because
184 // gcc gives an obnoxious warning if there are virtual methods
185 // with an accessible non-virtual destructor. Unfortunately,
186 // declaring this destructor makes it non-trivial, but there
187 // doesn't seem to be any other way around this warning.
188 //
189 // This destructor will never be called.
John McCall1f0fca52010-07-21 07:22:38 +0000190 virtual ~Cleanup();
John McCall3e29f962010-07-13 23:19:49 +0000191
John McCallda65ea82010-07-13 20:32:21 +0000192 /// Emit the cleanup. For normal cleanups, this is run in the
193 /// same EH context as when the cleanup was pushed, i.e. the
194 /// immediately-enclosing context of the cleanup scope. For
195 /// EH cleanups, this is run in a terminate context.
196 ///
197 // \param IsForEHCleanup true if this is for an EH cleanup, false
198 /// if for a normal cleanup.
199 virtual void Emit(CodeGenFunction &CGF, bool IsForEHCleanup) = 0;
200 };
201
John McCall150b4622011-01-26 04:00:11 +0000202 /// UnconditionalCleanupN stores its N parameters and just passes
203 /// them to the real cleanup function.
John McCall3ad32c82011-01-28 08:37:24 +0000204 template <class T, class A0>
205 class UnconditionalCleanup1 : public Cleanup {
206 A0 a0;
207 public:
208 UnconditionalCleanup1(A0 a0) : a0(a0) {}
209 void Emit(CodeGenFunction &CGF, bool IsForEHCleanup) {
210 T::Emit(CGF, IsForEHCleanup, a0);
211 }
212 };
213
John McCall150b4622011-01-26 04:00:11 +0000214 template <class T, class A0, class A1>
215 class UnconditionalCleanup2 : public Cleanup {
216 A0 a0; A1 a1;
John McCall4bbcbda2011-01-26 19:15:39 +0000217 public:
John McCall150b4622011-01-26 04:00:11 +0000218 UnconditionalCleanup2(A0 a0, A1 a1) : a0(a0), a1(a1) {}
219 void Emit(CodeGenFunction &CGF, bool IsForEHCleanup) {
220 T::Emit(CGF, IsForEHCleanup, a0, a1);
221 }
222 };
223
224 /// ConditionalCleanupN stores the saved form of its N parameters,
225 /// then restores them and performs the cleanup.
John McCall3ad32c82011-01-28 08:37:24 +0000226 template <class T, class A0>
227 class ConditionalCleanup1 : public Cleanup {
John McCall804b8072011-01-28 10:53:53 +0000228 typedef typename DominatingValue<A0>::saved_type A0_saved;
John McCall3ad32c82011-01-28 08:37:24 +0000229 A0_saved a0_saved;
230
231 void Emit(CodeGenFunction &CGF, bool IsForEHCleanup) {
John McCall804b8072011-01-28 10:53:53 +0000232 A0 a0 = DominatingValue<A0>::restore(CGF, a0_saved);
John McCall3ad32c82011-01-28 08:37:24 +0000233 T::Emit(CGF, IsForEHCleanup, a0);
234 }
235
236 public:
237 ConditionalCleanup1(A0_saved a0)
238 : a0_saved(a0) {}
239 };
240
John McCall150b4622011-01-26 04:00:11 +0000241 template <class T, class A0, class A1>
John McCall3ad32c82011-01-28 08:37:24 +0000242 class ConditionalCleanup2 : public Cleanup {
John McCall804b8072011-01-28 10:53:53 +0000243 typedef typename DominatingValue<A0>::saved_type A0_saved;
244 typedef typename DominatingValue<A1>::saved_type A1_saved;
John McCall4bbcbda2011-01-26 19:15:39 +0000245 A0_saved a0_saved;
246 A1_saved a1_saved;
John McCall150b4622011-01-26 04:00:11 +0000247
John McCall3ad32c82011-01-28 08:37:24 +0000248 void Emit(CodeGenFunction &CGF, bool IsForEHCleanup) {
John McCall804b8072011-01-28 10:53:53 +0000249 A0 a0 = DominatingValue<A0>::restore(CGF, a0_saved);
250 A1 a1 = DominatingValue<A1>::restore(CGF, a1_saved);
John McCall150b4622011-01-26 04:00:11 +0000251 T::Emit(CGF, IsForEHCleanup, a0, a1);
252 }
253
254 public:
John McCall3ad32c82011-01-28 08:37:24 +0000255 ConditionalCleanup2(A0_saved a0, A1_saved a1)
256 : a0_saved(a0), a1_saved(a1) {}
John McCall150b4622011-01-26 04:00:11 +0000257 };
258
John McCallf1549f62010-07-06 01:34:17 +0000259private:
260 // The implementation for this class is in CGException.h and
261 // CGException.cpp; the definition is here because it's used as a
262 // member of CodeGenFunction.
263
264 /// The start of the scope-stack buffer, i.e. the allocated pointer
265 /// for the buffer. All of these pointers are either simultaneously
266 /// null or simultaneously valid.
267 char *StartOfBuffer;
268
269 /// The end of the buffer.
270 char *EndOfBuffer;
271
272 /// The first valid entry in the buffer.
273 char *StartOfData;
274
275 /// The innermost normal cleanup on the stack.
276 stable_iterator InnermostNormalCleanup;
277
278 /// The innermost EH cleanup on the stack.
279 stable_iterator InnermostEHCleanup;
280
281 /// The number of catches on the stack.
282 unsigned CatchDepth;
283
John McCallff8e1152010-07-23 21:56:41 +0000284 /// The current EH destination index. Reset to FirstCatchIndex
285 /// whenever the last EH cleanup is popped.
286 unsigned NextEHDestIndex;
287 enum { FirstEHDestIndex = 1 };
288
John McCallf1549f62010-07-06 01:34:17 +0000289 /// The current set of branch fixups. A branch fixup is a jump to
290 /// an as-yet unemitted label, i.e. a label for which we don't yet
291 /// know the EH stack depth. Whenever we pop a cleanup, we have
292 /// to thread all the current branch fixups through it.
293 ///
294 /// Fixups are recorded as the Use of the respective branch or
295 /// switch statement. The use points to the final destination.
296 /// When popping out of a cleanup, these uses are threaded through
297 /// the cleanup and adjusted to point to the new cleanup.
298 ///
299 /// Note that branches are allowed to jump into protected scopes
300 /// in certain situations; e.g. the following code is legal:
301 /// struct A { ~A(); }; // trivial ctor, non-trivial dtor
302 /// goto foo;
303 /// A a;
304 /// foo:
305 /// bar();
306 llvm::SmallVector<BranchFixup, 8> BranchFixups;
307
308 char *allocate(size_t Size);
309
John McCall1f0fca52010-07-21 07:22:38 +0000310 void *pushCleanup(CleanupKind K, size_t DataSize);
John McCallda65ea82010-07-13 20:32:21 +0000311
John McCallf1549f62010-07-06 01:34:17 +0000312public:
313 EHScopeStack() : StartOfBuffer(0), EndOfBuffer(0), StartOfData(0),
314 InnermostNormalCleanup(stable_end()),
315 InnermostEHCleanup(stable_end()),
John McCallff8e1152010-07-23 21:56:41 +0000316 CatchDepth(0), NextEHDestIndex(FirstEHDestIndex) {}
John McCallf1549f62010-07-06 01:34:17 +0000317 ~EHScopeStack() { delete[] StartOfBuffer; }
318
John McCallda65ea82010-07-13 20:32:21 +0000319 // Variadic templates would make this not terrible.
320
321 /// Push a lazily-created cleanup on the stack.
John McCall8e3f8612010-07-13 22:12:14 +0000322 template <class T>
John McCall1f0fca52010-07-21 07:22:38 +0000323 void pushCleanup(CleanupKind Kind) {
324 void *Buffer = pushCleanup(Kind, sizeof(T));
325 Cleanup *Obj = new(Buffer) T();
John McCall8e3f8612010-07-13 22:12:14 +0000326 (void) Obj;
327 }
328
329 /// Push a lazily-created cleanup on the stack.
330 template <class T, class A0>
John McCall1f0fca52010-07-21 07:22:38 +0000331 void pushCleanup(CleanupKind Kind, A0 a0) {
332 void *Buffer = pushCleanup(Kind, sizeof(T));
333 Cleanup *Obj = new(Buffer) T(a0);
John McCall8e3f8612010-07-13 22:12:14 +0000334 (void) Obj;
335 }
336
337 /// Push a lazily-created cleanup on the stack.
John McCallda65ea82010-07-13 20:32:21 +0000338 template <class T, class A0, class A1>
John McCall1f0fca52010-07-21 07:22:38 +0000339 void pushCleanup(CleanupKind Kind, A0 a0, A1 a1) {
340 void *Buffer = pushCleanup(Kind, sizeof(T));
341 Cleanup *Obj = new(Buffer) T(a0, a1);
John McCallda65ea82010-07-13 20:32:21 +0000342 (void) Obj;
343 }
344
345 /// Push a lazily-created cleanup on the stack.
346 template <class T, class A0, class A1, class A2>
John McCall1f0fca52010-07-21 07:22:38 +0000347 void pushCleanup(CleanupKind Kind, A0 a0, A1 a1, A2 a2) {
348 void *Buffer = pushCleanup(Kind, sizeof(T));
349 Cleanup *Obj = new(Buffer) T(a0, a1, a2);
John McCallda65ea82010-07-13 20:32:21 +0000350 (void) Obj;
351 }
352
353 /// Push a lazily-created cleanup on the stack.
354 template <class T, class A0, class A1, class A2, class A3>
John McCall1f0fca52010-07-21 07:22:38 +0000355 void pushCleanup(CleanupKind Kind, A0 a0, A1 a1, A2 a2, A3 a3) {
356 void *Buffer = pushCleanup(Kind, sizeof(T));
357 Cleanup *Obj = new(Buffer) T(a0, a1, a2, a3);
John McCallda65ea82010-07-13 20:32:21 +0000358 (void) Obj;
359 }
360
John McCall77199712010-07-21 05:47:49 +0000361 /// Push a lazily-created cleanup on the stack.
362 template <class T, class A0, class A1, class A2, class A3, class A4>
John McCall1f0fca52010-07-21 07:22:38 +0000363 void pushCleanup(CleanupKind Kind, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
364 void *Buffer = pushCleanup(Kind, sizeof(T));
365 Cleanup *Obj = new(Buffer) T(a0, a1, a2, a3, a4);
John McCall77199712010-07-21 05:47:49 +0000366 (void) Obj;
367 }
368
John McCall7d8647f2010-09-14 07:57:04 +0000369 // Feel free to add more variants of the following:
370
371 /// Push a cleanup with non-constant storage requirements on the
372 /// stack. The cleanup type must provide an additional static method:
373 /// static size_t getExtraSize(size_t);
374 /// The argument to this method will be the value N, which will also
375 /// be passed as the first argument to the constructor.
376 ///
377 /// The data stored in the extra storage must obey the same
378 /// restrictions as normal cleanup member data.
379 ///
380 /// The pointer returned from this method is valid until the cleanup
381 /// stack is modified.
382 template <class T, class A0, class A1, class A2>
383 T *pushCleanupWithExtra(CleanupKind Kind, size_t N, A0 a0, A1 a1, A2 a2) {
384 void *Buffer = pushCleanup(Kind, sizeof(T) + T::getExtraSize(N));
385 return new (Buffer) T(N, a0, a1, a2);
386 }
387
John McCallf1549f62010-07-06 01:34:17 +0000388 /// Pops a cleanup scope off the stack. This should only be called
389 /// by CodeGenFunction::PopCleanupBlock.
390 void popCleanup();
391
392 /// Push a set of catch handlers on the stack. The catch is
393 /// uninitialized and will need to have the given number of handlers
394 /// set on it.
395 class EHCatchScope *pushCatch(unsigned NumHandlers);
396
397 /// Pops a catch scope off the stack.
398 void popCatch();
399
400 /// Push an exceptions filter on the stack.
401 class EHFilterScope *pushFilter(unsigned NumFilters);
402
403 /// Pops an exceptions filter off the stack.
404 void popFilter();
405
406 /// Push a terminate handler on the stack.
407 void pushTerminate();
408
409 /// Pops a terminate handler off the stack.
410 void popTerminate();
411
412 /// Determines whether the exception-scopes stack is empty.
413 bool empty() const { return StartOfData == EndOfBuffer; }
414
415 bool requiresLandingPad() const {
416 return (CatchDepth || hasEHCleanups());
417 }
418
419 /// Determines whether there are any normal cleanups on the stack.
420 bool hasNormalCleanups() const {
421 return InnermostNormalCleanup != stable_end();
422 }
423
424 /// Returns the innermost normal cleanup on the stack, or
425 /// stable_end() if there are no normal cleanups.
426 stable_iterator getInnermostNormalCleanup() const {
427 return InnermostNormalCleanup;
428 }
John McCall838d7962010-08-14 07:46:19 +0000429 stable_iterator getInnermostActiveNormalCleanup() const; // CGException.h
John McCallf1549f62010-07-06 01:34:17 +0000430
431 /// Determines whether there are any EH cleanups on the stack.
432 bool hasEHCleanups() const {
433 return InnermostEHCleanup != stable_end();
434 }
435
436 /// Returns the innermost EH cleanup on the stack, or stable_end()
437 /// if there are no EH cleanups.
438 stable_iterator getInnermostEHCleanup() const {
439 return InnermostEHCleanup;
440 }
John McCall838d7962010-08-14 07:46:19 +0000441 stable_iterator getInnermostActiveEHCleanup() const; // CGException.h
John McCallf1549f62010-07-06 01:34:17 +0000442
443 /// An unstable reference to a scope-stack depth. Invalidated by
444 /// pushes but not pops.
445 class iterator;
446
447 /// Returns an iterator pointing to the innermost EH scope.
448 iterator begin() const;
449
450 /// Returns an iterator pointing to the outermost EH scope.
451 iterator end() const;
452
453 /// Create a stable reference to the top of the EH stack. The
454 /// returned reference is valid until that scope is popped off the
455 /// stack.
456 stable_iterator stable_begin() const {
457 return stable_iterator(EndOfBuffer - StartOfData);
458 }
459
460 /// Create a stable reference to the bottom of the EH stack.
461 static stable_iterator stable_end() {
462 return stable_iterator(0);
463 }
464
465 /// Translates an iterator into a stable_iterator.
466 stable_iterator stabilize(iterator it) const;
467
468 /// Finds the nearest cleanup enclosing the given iterator.
469 /// Returns stable_iterator::invalid() if there are no such cleanups.
470 stable_iterator getEnclosingEHCleanup(iterator it) const;
471
472 /// Turn a stable reference to a scope depth into a unstable pointer
473 /// to the EH stack.
474 iterator find(stable_iterator save) const;
475
476 /// Removes the cleanup pointed to by the given stable_iterator.
477 void removeCleanup(stable_iterator save);
478
479 /// Add a branch fixup to the current cleanup scope.
480 BranchFixup &addBranchFixup() {
481 assert(hasNormalCleanups() && "adding fixup in scope without cleanups");
482 BranchFixups.push_back(BranchFixup());
483 return BranchFixups.back();
484 }
485
486 unsigned getNumBranchFixups() const { return BranchFixups.size(); }
487 BranchFixup &getBranchFixup(unsigned I) {
488 assert(I < getNumBranchFixups());
489 return BranchFixups[I];
490 }
491
John McCallff8e1152010-07-23 21:56:41 +0000492 /// Pops lazily-removed fixups from the end of the list. This
493 /// should only be called by procedures which have just popped a
494 /// cleanup or resolved one or more fixups.
495 void popNullFixups();
496
497 /// Clears the branch-fixups list. This should only be called by
John McCall8abdbd82010-09-18 02:24:39 +0000498 /// ResolveAllBranchFixups.
John McCallff8e1152010-07-23 21:56:41 +0000499 void clearFixups() { BranchFixups.clear(); }
500
501 /// Gets the next EH destination index.
502 unsigned getNextEHDestIndex() { return NextEHDestIndex++; }
John McCallf1549f62010-07-06 01:34:17 +0000503};
504
Reid Spencer5f016e22007-07-11 17:01:13 +0000505/// CodeGenFunction - This class organizes the per-function state that is used
506/// while generating LLVM code.
John McCall5936e332011-02-15 09:22:45 +0000507class CodeGenFunction : public CodeGenTypeCache {
Anders Carlsson8a219ce2009-02-24 04:21:31 +0000508 CodeGenFunction(const CodeGenFunction&); // DO NOT IMPLEMENT
509 void operator=(const CodeGenFunction&); // DO NOT IMPLEMENT
John McCall4c40d982010-08-31 07:33:07 +0000510
511 friend class CGCXXABI;
Chris Lattnerbfc0c1a2007-08-26 23:13:56 +0000512public:
John McCallff8e1152010-07-23 21:56:41 +0000513 /// A jump destination is an abstract label, branching to which may
514 /// require a jump out through normal cleanups.
John McCallf1549f62010-07-06 01:34:17 +0000515 struct JumpDest {
John McCallff8e1152010-07-23 21:56:41 +0000516 JumpDest() : Block(0), ScopeDepth(), Index(0) {}
517 JumpDest(llvm::BasicBlock *Block,
518 EHScopeStack::stable_iterator Depth,
519 unsigned Index)
520 : Block(Block), ScopeDepth(Depth), Index(Index) {}
521
522 bool isValid() const { return Block != 0; }
523 llvm::BasicBlock *getBlock() const { return Block; }
524 EHScopeStack::stable_iterator getScopeDepth() const { return ScopeDepth; }
525 unsigned getDestIndex() const { return Index; }
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000526
John McCallff8e1152010-07-23 21:56:41 +0000527 private:
John McCallf1549f62010-07-06 01:34:17 +0000528 llvm::BasicBlock *Block;
529 EHScopeStack::stable_iterator ScopeDepth;
John McCallff8e1152010-07-23 21:56:41 +0000530 unsigned Index;
531 };
532
533 /// An unwind destination is an abstract label, branching to which
534 /// may require a jump out through EH cleanups.
535 struct UnwindDest {
536 UnwindDest() : Block(0), ScopeDepth(), Index(0) {}
537 UnwindDest(llvm::BasicBlock *Block,
538 EHScopeStack::stable_iterator Depth,
539 unsigned Index)
540 : Block(Block), ScopeDepth(Depth), Index(Index) {}
541
542 bool isValid() const { return Block != 0; }
543 llvm::BasicBlock *getBlock() const { return Block; }
544 EHScopeStack::stable_iterator getScopeDepth() const { return ScopeDepth; }
545 unsigned getDestIndex() const { return Index; }
546
547 private:
548 llvm::BasicBlock *Block;
549 EHScopeStack::stable_iterator ScopeDepth;
550 unsigned Index;
John McCallf1549f62010-07-06 01:34:17 +0000551 };
552
Reid Spencer5f016e22007-07-11 17:01:13 +0000553 CodeGenModule &CGM; // Per-module state.
Daniel Dunbar444be732009-11-13 05:51:54 +0000554 const TargetInfo &Target;
Mike Stump0dd9e882009-02-08 23:14:22 +0000555
Chris Lattner58dee102007-08-21 16:57:55 +0000556 typedef std::pair<llvm::Value *, llvm::Value *> ComplexPairTy;
Daniel Dunbar45d196b2008-11-01 01:53:16 +0000557 CGBuilderTy Builder;
Mike Stump0dd9e882009-02-08 23:14:22 +0000558
Chris Lattnerb5437d22009-04-23 05:30:27 +0000559 /// CurFuncDecl - Holds the Decl for the current function or ObjC method.
560 /// This excludes BlockDecls.
Chris Lattner41110242008-06-17 18:05:57 +0000561 const Decl *CurFuncDecl;
Chris Lattnerb5437d22009-04-23 05:30:27 +0000562 /// CurCodeDecl - This is the inner-most code context, which includes blocks.
563 const Decl *CurCodeDecl;
Daniel Dunbar88b53962009-02-02 22:03:45 +0000564 const CGFunctionInfo *CurFnInfo;
Chris Lattner391d77a2008-03-30 23:03:07 +0000565 QualType FnRetTy;
Reid Spencer5f016e22007-07-11 17:01:13 +0000566 llvm::Function *CurFn;
567
Mike Stump6a1e0eb2009-12-04 23:26:17 +0000568 /// CurGD - The GlobalDecl for the current function being compiled.
569 GlobalDecl CurGD;
Mike Stump6a1e0eb2009-12-04 23:26:17 +0000570
Daniel Dunbar5ca20842008-09-09 21:00:17 +0000571 /// ReturnBlock - Unified return block.
John McCallf1549f62010-07-06 01:34:17 +0000572 JumpDest ReturnBlock;
573
Mike Stump0dd9e882009-02-08 23:14:22 +0000574 /// ReturnValue - The temporary alloca to hold the return value. This is null
575 /// iff the function has no return value.
Eli Friedmanb17daf92009-12-04 02:43:40 +0000576 llvm::Value *ReturnValue;
Mike Stump0dd9e882009-02-08 23:14:22 +0000577
John McCallff8e1152010-07-23 21:56:41 +0000578 /// RethrowBlock - Unified rethrow block.
579 UnwindDest RethrowBlock;
580
Reid Spencer5f016e22007-07-11 17:01:13 +0000581 /// AllocaInsertPoint - This is an instruction in the entry block before which
582 /// we prefer to insert allocas.
Chris Lattner481769b2009-03-31 22:17:44 +0000583 llvm::AssertingVH<llvm::Instruction> AllocaInsertPt;
Daniel Dunbar0ffb1252008-08-04 16:51:22 +0000584
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
John McCallf1549f62010-07-06 01:34:17 +0000594 EHScopeStack EHStack;
595
John McCallff8e1152010-07-23 21:56:41 +0000596 /// i32s containing the indexes of the cleanup destinations.
597 llvm::AllocaInst *NormalCleanupDest;
598 llvm::AllocaInst *EHCleanupDest;
599
600 unsigned NextCleanupDestIndex;
601
John McCallf1549f62010-07-06 01:34:17 +0000602 /// The exception slot. All landing pads write the current
603 /// exception pointer into this alloca.
604 llvm::Value *ExceptionSlot;
605
606 /// Emits a landing pad for the current EH stack.
607 llvm::BasicBlock *EmitLandingPad();
608
609 llvm::BasicBlock *getInvokeDestImpl();
610
John McCall3ad32c82011-01-28 08:37:24 +0000611 /// Set up the last cleaup that was pushed as a conditional
612 /// full-expression cleanup.
613 void initFullExprCleanup();
John McCall150b4622011-01-26 04:00:11 +0000614
615 template <class T>
John McCall804b8072011-01-28 10:53:53 +0000616 typename DominatingValue<T>::saved_type saveValueInCond(T value) {
617 return DominatingValue<T>::save(*this, value);
John McCall150b4622011-01-26 04:00:11 +0000618 }
619
Daniel Dunbar18ccc772008-09-28 01:03:14 +0000620public:
Anders Carlssonfa1f7562009-02-10 06:07:49 +0000621 /// ObjCEHValueStack - Stack of Objective-C exception values, used for
622 /// rethrows.
Anders Carlsson273558f2009-02-07 21:37:21 +0000623 llvm::SmallVector<llvm::Value*, 8> ObjCEHValueStack;
Mike Stump0dd9e882009-02-08 23:14:22 +0000624
John McCallf1549f62010-07-06 01:34:17 +0000625 // A struct holding information about a finally block's IR
626 // generation. For now, doesn't actually hold anything.
627 struct FinallyInfo {
Anders Carlssonbb66f9f2009-02-08 07:46:24 +0000628 };
629
John McCallf1549f62010-07-06 01:34:17 +0000630 FinallyInfo EnterFinallyBlock(const Stmt *Stmt,
631 llvm::Constant *BeginCatchFn,
632 llvm::Constant *EndCatchFn,
633 llvm::Constant *RethrowFn);
634 void ExitFinallyBlock(FinallyInfo &FinallyInfo);
Mike Stumpd88ea562009-12-09 03:35:49 +0000635
John McCall150b4622011-01-26 04:00:11 +0000636 /// pushFullExprCleanup - Push a cleanup to be run at the end of the
637 /// current full-expression. Safe against the possibility that
638 /// we're currently inside a conditionally-evaluated expression.
John McCall3ad32c82011-01-28 08:37:24 +0000639 template <class T, class A0>
640 void pushFullExprCleanup(CleanupKind kind, A0 a0) {
641 // If we're not in a conditional branch, or if none of the
642 // arguments requires saving, then use the unconditional cleanup.
643 if (!isInConditionalBranch()) {
644 typedef EHScopeStack::UnconditionalCleanup1<T, A0> CleanupType;
645 return EHStack.pushCleanup<CleanupType>(kind, a0);
646 }
647
John McCall804b8072011-01-28 10:53:53 +0000648 typename DominatingValue<A0>::saved_type a0_saved = saveValueInCond(a0);
John McCall3ad32c82011-01-28 08:37:24 +0000649
650 typedef EHScopeStack::ConditionalCleanup1<T, A0> CleanupType;
651 EHStack.pushCleanup<CleanupType>(kind, a0_saved);
652 initFullExprCleanup();
653 }
654
655 /// pushFullExprCleanup - Push a cleanup to be run at the end of the
656 /// current full-expression. Safe against the possibility that
657 /// we're currently inside a conditionally-evaluated expression.
John McCall150b4622011-01-26 04:00:11 +0000658 template <class T, class A0, class A1>
659 void pushFullExprCleanup(CleanupKind kind, A0 a0, A1 a1) {
660 // If we're not in a conditional branch, or if none of the
661 // arguments requires saving, then use the unconditional cleanup.
John McCall3ad32c82011-01-28 08:37:24 +0000662 if (!isInConditionalBranch()) {
John McCall150b4622011-01-26 04:00:11 +0000663 typedef EHScopeStack::UnconditionalCleanup2<T, A0, A1> CleanupType;
664 return EHStack.pushCleanup<CleanupType>(kind, a0, a1);
665 }
666
John McCall804b8072011-01-28 10:53:53 +0000667 typename DominatingValue<A0>::saved_type a0_saved = saveValueInCond(a0);
668 typename DominatingValue<A1>::saved_type a1_saved = saveValueInCond(a1);
John McCall150b4622011-01-26 04:00:11 +0000669
670 typedef EHScopeStack::ConditionalCleanup2<T, A0, A1> CleanupType;
John McCall3ad32c82011-01-28 08:37:24 +0000671 EHStack.pushCleanup<CleanupType>(kind, a0_saved, a1_saved);
672 initFullExprCleanup();
John McCall150b4622011-01-26 04:00:11 +0000673 }
674
John McCallf1549f62010-07-06 01:34:17 +0000675 /// PushDestructorCleanup - Push a cleanup to call the
676 /// complete-object destructor of an object of the given type at the
677 /// given address. Does nothing if T is not a C++ class type with a
678 /// non-trivial destructor.
679 void PushDestructorCleanup(QualType T, llvm::Value *Addr);
680
John McCall81407d42010-07-21 06:29:51 +0000681 /// PushDestructorCleanup - Push a cleanup to call the
682 /// complete-object variant of the given destructor on the object at
683 /// the given address.
684 void PushDestructorCleanup(const CXXDestructorDecl *Dtor,
685 llvm::Value *Addr);
686
John McCallf1549f62010-07-06 01:34:17 +0000687 /// PopCleanupBlock - Will pop the cleanup entry on the stack and
688 /// process all branch fixups.
John McCallff8e1152010-07-23 21:56:41 +0000689 void PopCleanupBlock(bool FallThroughIsBranchThrough = false);
John McCallf1549f62010-07-06 01:34:17 +0000690
John McCall7d8647f2010-09-14 07:57:04 +0000691 /// DeactivateCleanupBlock - Deactivates the given cleanup block.
692 /// The block cannot be reactivated. Pops it if it's the top of the
693 /// stack.
694 void DeactivateCleanupBlock(EHScopeStack::stable_iterator Cleanup);
695
696 /// ActivateCleanupBlock - Activates an initially-inactive cleanup.
697 /// Cannot be used to resurrect a deactivated cleanup.
698 void ActivateCleanupBlock(EHScopeStack::stable_iterator Cleanup);
John McCallcd2d2b72010-08-13 21:20:51 +0000699
John McCallf1549f62010-07-06 01:34:17 +0000700 /// \brief Enters a new scope for capturing cleanups, all of which
701 /// will be executed once the scope is exited.
702 class RunCleanupsScope {
Douglas Gregor01234bb2009-11-24 16:43:22 +0000703 CodeGenFunction& CGF;
John McCallf1549f62010-07-06 01:34:17 +0000704 EHScopeStack::stable_iterator CleanupStackDepth;
Douglas Gregor01234bb2009-11-24 16:43:22 +0000705 bool OldDidCallStackSave;
Douglas Gregor5656e142009-11-24 21:15:44 +0000706 bool PerformCleanup;
Douglas Gregor01234bb2009-11-24 16:43:22 +0000707
John McCallf1549f62010-07-06 01:34:17 +0000708 RunCleanupsScope(const RunCleanupsScope &); // DO NOT IMPLEMENT
709 RunCleanupsScope &operator=(const RunCleanupsScope &); // DO NOT IMPLEMENT
Douglas Gregor01234bb2009-11-24 16:43:22 +0000710
711 public:
712 /// \brief Enter a new cleanup scope.
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000713 explicit RunCleanupsScope(CodeGenFunction &CGF)
714 : CGF(CGF), PerformCleanup(true)
Douglas Gregor5656e142009-11-24 21:15:44 +0000715 {
John McCallf1549f62010-07-06 01:34:17 +0000716 CleanupStackDepth = CGF.EHStack.stable_begin();
Douglas Gregor01234bb2009-11-24 16:43:22 +0000717 OldDidCallStackSave = CGF.DidCallStackSave;
Argyrios Kyrtzidis4ada2ca2010-09-14 00:42:34 +0000718 CGF.DidCallStackSave = false;
Douglas Gregor01234bb2009-11-24 16:43:22 +0000719 }
720
721 /// \brief Exit this cleanup scope, emitting any accumulated
722 /// cleanups.
John McCallf1549f62010-07-06 01:34:17 +0000723 ~RunCleanupsScope() {
Douglas Gregor5656e142009-11-24 21:15:44 +0000724 if (PerformCleanup) {
725 CGF.DidCallStackSave = OldDidCallStackSave;
John McCallf1549f62010-07-06 01:34:17 +0000726 CGF.PopCleanupBlocks(CleanupStackDepth);
Douglas Gregor5656e142009-11-24 21:15:44 +0000727 }
728 }
729
730 /// \brief Determine whether this scope requires any cleanups.
731 bool requiresCleanups() const {
John McCallf1549f62010-07-06 01:34:17 +0000732 return CGF.EHStack.stable_begin() != CleanupStackDepth;
Douglas Gregor5656e142009-11-24 21:15:44 +0000733 }
734
735 /// \brief Force the emission of cleanups now, instead of waiting
736 /// until this object is destroyed.
737 void ForceCleanup() {
738 assert(PerformCleanup && "Already forced cleanup");
Douglas Gregor01234bb2009-11-24 16:43:22 +0000739 CGF.DidCallStackSave = OldDidCallStackSave;
John McCallf1549f62010-07-06 01:34:17 +0000740 CGF.PopCleanupBlocks(CleanupStackDepth);
Douglas Gregor5656e142009-11-24 21:15:44 +0000741 PerformCleanup = false;
Douglas Gregor01234bb2009-11-24 16:43:22 +0000742 }
743 };
744
Anders Carlsson44ec82b2010-03-30 03:14:41 +0000745
John McCallf1549f62010-07-06 01:34:17 +0000746 /// PopCleanupBlocks - Takes the old cleanup stack size and emits
747 /// the cleanup blocks that have been added.
748 void PopCleanupBlocks(EHScopeStack::stable_iterator OldCleanupStackSize);
Anders Carlsson44ec82b2010-03-30 03:14:41 +0000749
John McCallff8e1152010-07-23 21:56:41 +0000750 void ResolveBranchFixups(llvm::BasicBlock *Target);
751
John McCallf1549f62010-07-06 01:34:17 +0000752 /// The given basic block lies in the current EH scope, but may be a
753 /// target of a potentially scope-crossing jump; get a stable handle
754 /// to which we can perform this jump later.
John McCallff8e1152010-07-23 21:56:41 +0000755 JumpDest getJumpDestInCurrentScope(llvm::BasicBlock *Target) {
John McCall413e6772010-07-28 01:07:35 +0000756 return JumpDest(Target,
757 EHStack.getInnermostNormalCleanup(),
758 NextCleanupDestIndex++);
John McCallf1549f62010-07-06 01:34:17 +0000759 }
Anders Carlssonc71c8452009-02-07 23:50:39 +0000760
John McCallf1549f62010-07-06 01:34:17 +0000761 /// The given basic block lies in the current EH scope, but may be a
762 /// target of a potentially scope-crossing jump; get a stable handle
763 /// to which we can perform this jump later.
Chris Lattnerad8dcf42011-02-17 07:39:24 +0000764 JumpDest getJumpDestInCurrentScope(llvm::StringRef Name = llvm::StringRef()) {
John McCallff8e1152010-07-23 21:56:41 +0000765 return getJumpDestInCurrentScope(createBasicBlock(Name));
John McCallf1549f62010-07-06 01:34:17 +0000766 }
767
768 /// EmitBranchThroughCleanup - Emit a branch from the current insert
769 /// block through the normal cleanup handling code (if any) and then
770 /// on to \arg Dest.
771 void EmitBranchThroughCleanup(JumpDest Dest);
772
773 /// EmitBranchThroughEHCleanup - Emit a branch from the current
774 /// insert block through the EH cleanup handling code (if any) and
775 /// then on to \arg Dest.
John McCallff8e1152010-07-23 21:56:41 +0000776 void EmitBranchThroughEHCleanup(UnwindDest Dest);
777
778 /// getRethrowDest - Returns the unified outermost-scope rethrow
779 /// destination.
780 UnwindDest getRethrowDest();
Mike Stump0dd9e882009-02-08 23:14:22 +0000781
John McCall150b4622011-01-26 04:00:11 +0000782 /// An object to manage conditionally-evaluated expressions.
783 class ConditionalEvaluation {
784 llvm::BasicBlock *StartBB;
Mike Stump1eb44332009-09-09 15:08:12 +0000785
John McCall150b4622011-01-26 04:00:11 +0000786 public:
787 ConditionalEvaluation(CodeGenFunction &CGF)
788 : StartBB(CGF.Builder.GetInsertBlock()) {}
Michael J. Spencer9cac4942010-10-19 06:39:39 +0000789
John McCall150b4622011-01-26 04:00:11 +0000790 void begin(CodeGenFunction &CGF) {
791 assert(CGF.OutermostConditional != this);
792 if (!CGF.OutermostConditional)
793 CGF.OutermostConditional = this;
794 }
795
796 void end(CodeGenFunction &CGF) {
797 assert(CGF.OutermostConditional != 0);
798 if (CGF.OutermostConditional == this)
799 CGF.OutermostConditional = 0;
800 }
801
802 /// Returns a block which will be executed prior to each
803 /// evaluation of the conditional code.
804 llvm::BasicBlock *getStartingBlock() const {
805 return StartBB;
806 }
807 };
Mike Stump1eb44332009-09-09 15:08:12 +0000808
John McCall3019c442010-09-17 00:50:28 +0000809 /// isInConditionalBranch - Return true if we're currently emitting
810 /// one branch or the other of a conditional expression.
John McCall150b4622011-01-26 04:00:11 +0000811 bool isInConditionalBranch() const { return OutermostConditional != 0; }
812
813 /// An RAII object to record that we're evaluating a statement
814 /// expression.
815 class StmtExprEvaluation {
816 CodeGenFunction &CGF;
817
818 /// We have to save the outermost conditional: cleanups in a
819 /// statement expression aren't conditional just because the
820 /// StmtExpr is.
821 ConditionalEvaluation *SavedOutermostConditional;
822
823 public:
824 StmtExprEvaluation(CodeGenFunction &CGF)
825 : CGF(CGF), SavedOutermostConditional(CGF.OutermostConditional) {
826 CGF.OutermostConditional = 0;
827 }
828
829 ~StmtExprEvaluation() {
830 CGF.OutermostConditional = SavedOutermostConditional;
831 CGF.EnsureInsertPoint();
832 }
833 };
John McCalle996ffd2011-02-16 08:02:54 +0000834
John McCall56ca35d2011-02-17 10:25:35 +0000835 /// An object which temporarily prevents a value from being
836 /// destroyed by aggressive peephole optimizations that assume that
837 /// all uses of a value have been realized in the IR.
838 class PeepholeProtection {
839 llvm::Instruction *Inst;
840 friend class CodeGenFunction;
841
842 public:
843 PeepholeProtection() : Inst(0) {}
844 };
845
John McCalle996ffd2011-02-16 08:02:54 +0000846 /// An RAII object to set (and then clear) a mapping for an OpaqueValueExpr.
847 class OpaqueValueMapping {
848 CodeGenFunction &CGF;
849 const OpaqueValueExpr *OpaqueValue;
John McCall56ca35d2011-02-17 10:25:35 +0000850 bool BoundLValue;
851 CodeGenFunction::PeepholeProtection Protection;
John McCalle996ffd2011-02-16 08:02:54 +0000852
853 public:
John McCall56ca35d2011-02-17 10:25:35 +0000854 static bool shouldBindAsLValue(const Expr *expr) {
855 return expr->isGLValue() || expr->getType()->isRecordType();
856 }
857
858 /// Build the opaque value mapping for the given conditional
859 /// operator if it's the GNU ?: extension. This is a common
860 /// enough pattern that the convenience operator is really
861 /// helpful.
862 ///
863 OpaqueValueMapping(CodeGenFunction &CGF,
864 const AbstractConditionalOperator *op) : CGF(CGF) {
865 if (isa<ConditionalOperator>(op)) {
866 OpaqueValue = 0;
867 BoundLValue = false;
868 return;
869 }
870
871 const BinaryConditionalOperator *e = cast<BinaryConditionalOperator>(op);
872 init(e->getOpaqueValue(), e->getCommon());
873 }
874
John McCalle996ffd2011-02-16 08:02:54 +0000875 OpaqueValueMapping(CodeGenFunction &CGF,
876 const OpaqueValueExpr *opaqueValue,
John McCall56ca35d2011-02-17 10:25:35 +0000877 LValue lvalue)
878 : CGF(CGF), OpaqueValue(opaqueValue), BoundLValue(true) {
John McCalle996ffd2011-02-16 08:02:54 +0000879 assert(opaqueValue && "no opaque value expression!");
John McCall56ca35d2011-02-17 10:25:35 +0000880 assert(shouldBindAsLValue(opaqueValue));
881 initLValue(lvalue);
882 }
883
884 OpaqueValueMapping(CodeGenFunction &CGF,
885 const OpaqueValueExpr *opaqueValue,
886 RValue rvalue)
887 : CGF(CGF), OpaqueValue(opaqueValue), BoundLValue(false) {
888 assert(opaqueValue && "no opaque value expression!");
889 assert(!shouldBindAsLValue(opaqueValue));
890 initRValue(rvalue);
John McCalle996ffd2011-02-16 08:02:54 +0000891 }
892
893 void pop() {
894 assert(OpaqueValue && "mapping already popped!");
John McCall56ca35d2011-02-17 10:25:35 +0000895 popImpl();
John McCalle996ffd2011-02-16 08:02:54 +0000896 OpaqueValue = 0;
897 }
898
899 ~OpaqueValueMapping() {
John McCall56ca35d2011-02-17 10:25:35 +0000900 if (OpaqueValue) popImpl();
901 }
902
903 private:
904 void popImpl() {
905 if (BoundLValue)
906 CGF.OpaqueLValues.erase(OpaqueValue);
907 else {
908 CGF.OpaqueRValues.erase(OpaqueValue);
909 CGF.unprotectFromPeepholes(Protection);
910 }
911 }
912
913 void init(const OpaqueValueExpr *ov, const Expr *e) {
914 OpaqueValue = ov;
915 BoundLValue = shouldBindAsLValue(ov);
916 assert(BoundLValue == shouldBindAsLValue(e)
917 && "inconsistent expression value kinds!");
918 if (BoundLValue)
919 initLValue(CGF.EmitLValue(e));
920 else
921 initRValue(CGF.EmitAnyExpr(e));
922 }
923
924 void initLValue(const LValue &lv) {
925 CGF.OpaqueLValues.insert(std::make_pair(OpaqueValue, lv));
926 }
927
928 void initRValue(const RValue &rv) {
929 // Work around an extremely aggressive peephole optimization in
930 // EmitScalarConversion which assumes that all other uses of a
931 // value are extant.
932 Protection = CGF.protectFromPeepholes(rv);
933 CGF.OpaqueRValues.insert(std::make_pair(OpaqueValue, rv));
John McCalle996ffd2011-02-16 08:02:54 +0000934 }
935 };
Fariborz Jahaniane2204552010-11-16 19:29:39 +0000936
937 /// getByrefValueFieldNumber - Given a declaration, returns the LLVM field
938 /// number that holds the value.
939 unsigned getByRefValueLLVMField(const ValueDecl *VD) const;
Fariborz Jahanian52a80e12011-01-26 23:08:27 +0000940
941 /// BuildBlockByrefAddress - Computes address location of the
942 /// variable which is declared as __block.
943 llvm::Value *BuildBlockByrefAddress(llvm::Value *BaseAddr,
944 const VarDecl *V);
Chris Lattner7f02f722007-08-24 05:35:26 +0000945private:
Chris Lattnerd9becd12009-10-28 23:59:40 +0000946 CGDebugInfo *DebugInfo;
Devang Patelaa112892011-03-07 18:45:56 +0000947 bool DisableDebugInfo;
Mike Stump09429b92009-02-17 17:00:02 +0000948
Mike Stumpf71d2322009-11-30 20:08:49 +0000949 /// IndirectBranch - The first time an indirect goto is seen we create a block
950 /// with an indirect branch. Every time we see the address of a label taken,
951 /// we add the label to the indirect goto. Every subsequent indirect goto is
952 /// codegen'd as a jump to the IndirectBranch's basic block.
Chris Lattnerd9becd12009-10-28 23:59:40 +0000953 llvm::IndirectBrInst *IndirectBranch;
Daniel Dunbar0ffb1252008-08-04 16:51:22 +0000954
Mike Stump0dd9e882009-02-08 23:14:22 +0000955 /// LocalDeclMap - This keeps track of the LLVM allocas or globals for local C
956 /// decls.
John McCall6b5a61b2011-02-07 10:33:21 +0000957 typedef llvm::DenseMap<const Decl*, llvm::Value*> DeclMapTy;
958 DeclMapTy LocalDeclMap;
Reid Spencer5f016e22007-07-11 17:01:13 +0000959
960 /// LabelMap - This keeps track of the LLVM basic block for each C label.
Chris Lattnerad8dcf42011-02-17 07:39:24 +0000961 llvm::DenseMap<const LabelDecl*, JumpDest> LabelMap;
Mike Stump0dd9e882009-02-08 23:14:22 +0000962
Mike Stump0dd9e882009-02-08 23:14:22 +0000963 // BreakContinueStack - This keeps track of where break and continue
Anders Carlssone4b6d342009-02-10 05:52:02 +0000964 // statements should jump to.
Chris Lattnerda138702007-07-16 21:28:45 +0000965 struct BreakContinue {
John McCallf1549f62010-07-06 01:34:17 +0000966 BreakContinue(JumpDest Break, JumpDest Continue)
967 : BreakBlock(Break), ContinueBlock(Continue) {}
Mike Stump0dd9e882009-02-08 23:14:22 +0000968
John McCallf1549f62010-07-06 01:34:17 +0000969 JumpDest BreakBlock;
970 JumpDest ContinueBlock;
Mike Stump0dd9e882009-02-08 23:14:22 +0000971 };
Chris Lattnerda138702007-07-16 21:28:45 +0000972 llvm::SmallVector<BreakContinue, 8> BreakContinueStack;
Daniel Dunbar18ccc772008-09-28 01:03:14 +0000973
Mike Stump0dd9e882009-02-08 23:14:22 +0000974 /// SwitchInsn - This is nearest current switch instruction. It is null if if
975 /// current context is not in a switch.
Devang Patel51b09f22007-10-04 23:45:31 +0000976 llvm::SwitchInst *SwitchInsn;
977
Mike Stump0dd9e882009-02-08 23:14:22 +0000978 /// CaseRangeBlock - This block holds if condition check for last case
Devang Patel80fd5f92007-10-09 17:08:50 +0000979 /// statement range in current switch instruction.
Devang Patelc049e4f2007-10-08 20:57:48 +0000980 llvm::BasicBlock *CaseRangeBlock;
981
John McCall56ca35d2011-02-17 10:25:35 +0000982 /// OpaqueLValues - Keeps track of the current set of opaque value
John McCalle996ffd2011-02-16 08:02:54 +0000983 /// expressions.
John McCall56ca35d2011-02-17 10:25:35 +0000984 llvm::DenseMap<const OpaqueValueExpr *, LValue> OpaqueLValues;
985 llvm::DenseMap<const OpaqueValueExpr *, RValue> OpaqueRValues;
John McCalle996ffd2011-02-16 08:02:54 +0000986
Mike Stump0dd9e882009-02-08 23:14:22 +0000987 // VLASizeMap - This keeps track of the associated size for each VLA type.
Eli Friedmanbbed6b92009-08-15 02:50:32 +0000988 // We track this by the size expression rather than the type itself because
989 // in certain situations, like a const qualifier applied to an VLA typedef,
990 // multiple VLA types can share the same size expression.
Mike Stump0dd9e882009-02-08 23:14:22 +0000991 // FIXME: Maybe this could be a stack of maps that is pushed/popped as we
992 // enter/leave scopes.
Eli Friedmanbbed6b92009-08-15 02:50:32 +0000993 llvm::DenseMap<const Expr*, llvm::Value*> VLASizeMap;
Mike Stump0dd9e882009-02-08 23:14:22 +0000994
Anders Carlsson4cc1a472009-02-09 20:20:56 +0000995 /// DidCallStackSave - Whether llvm.stacksave has been called. Used to avoid
996 /// calling llvm.stacksave for multiple VLAs in the same scope.
997 bool DidCallStackSave;
Mike Stump09429b92009-02-17 17:00:02 +0000998
John McCallf1549f62010-07-06 01:34:17 +0000999 /// A block containing a single 'unreachable' instruction. Created
1000 /// lazily by getUnreachableBlock().
1001 llvm::BasicBlock *UnreachableBlock;
Mike Stump0dd9e882009-02-08 23:14:22 +00001002
Anders Carlssonf6c56e22009-11-25 03:15:49 +00001003 /// CXXThisDecl - When generating code for a C++ member function,
1004 /// this will hold the implicit 'this' declaration.
Anders Carlsson2b77ba82009-04-04 20:47:02 +00001005 ImplicitParamDecl *CXXThisDecl;
John McCall25049412010-02-16 22:04:33 +00001006 llvm::Value *CXXThisValue;
Mike Stump1eb44332009-09-09 15:08:12 +00001007
Anders Carlssonf6c56e22009-11-25 03:15:49 +00001008 /// CXXVTTDecl - When generating code for a base object constructor or
1009 /// base object destructor with virtual bases, this will hold the implicit
1010 /// VTT parameter.
1011 ImplicitParamDecl *CXXVTTDecl;
John McCall25049412010-02-16 22:04:33 +00001012 llvm::Value *CXXVTTValue;
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001013
John McCall150b4622011-01-26 04:00:11 +00001014 /// OutermostConditional - Points to the outermost active
1015 /// conditional control. This is used so that we know if a
1016 /// temporary should be destroyed conditionally.
1017 ConditionalEvaluation *OutermostConditional;
Mike Stump1eb44332009-09-09 15:08:12 +00001018
Anders Carlsson7dfa4072009-09-12 02:14:24 +00001019
1020 /// ByrefValueInfoMap - For each __block variable, contains a pair of the LLVM
1021 /// type as well as the field number that contains the actual data.
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001022 llvm::DenseMap<const ValueDecl *, std::pair<const llvm::Type *,
Anders Carlsson7dfa4072009-09-12 02:14:24 +00001023 unsigned> > ByRefValueInfo;
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001024
John McCallf1549f62010-07-06 01:34:17 +00001025 llvm::BasicBlock *TerminateLandingPad;
Mike Stump182f3832009-12-10 00:02:42 +00001026 llvm::BasicBlock *TerminateHandler;
Chris Lattner83252dc2010-07-20 21:07:09 +00001027 llvm::BasicBlock *TrapBB;
Eli Friedman94067052009-12-10 02:21:21 +00001028
Reid Spencer5f016e22007-07-11 17:01:13 +00001029public:
1030 CodeGenFunction(CodeGenModule &cgm);
Mike Stump0dd9e882009-02-08 23:14:22 +00001031
John McCall1e7fe752010-09-02 09:58:18 +00001032 CodeGenTypes &getTypes() const { return CGM.getTypes(); }
Reid Spencer5f016e22007-07-11 17:01:13 +00001033 ASTContext &getContext() const;
Devang Patelaa112892011-03-07 18:45:56 +00001034 CGDebugInfo *getDebugInfo() {
1035 if (DisableDebugInfo)
1036 return NULL;
1037 return DebugInfo;
1038 }
1039 void disableDebugInfo() { DisableDebugInfo = true; }
1040 void enableDebugInfo() { DisableDebugInfo = false; }
1041
Reid Spencer5f016e22007-07-11 17:01:13 +00001042
John McCalld16c2cf2011-02-08 08:22:06 +00001043 const LangOptions &getLangOptions() const { return CGM.getLangOptions(); }
1044
John McCallf1549f62010-07-06 01:34:17 +00001045 /// Returns a pointer to the function's exception object slot, which
1046 /// is assigned in every landing pad.
1047 llvm::Value *getExceptionSlot();
1048
John McCallff8e1152010-07-23 21:56:41 +00001049 llvm::Value *getNormalCleanupDestSlot();
1050 llvm::Value *getEHCleanupDestSlot();
1051
John McCallf1549f62010-07-06 01:34:17 +00001052 llvm::BasicBlock *getUnreachableBlock() {
1053 if (!UnreachableBlock) {
1054 UnreachableBlock = createBasicBlock("unreachable");
1055 new llvm::UnreachableInst(getLLVMContext(), UnreachableBlock);
1056 }
1057 return UnreachableBlock;
1058 }
1059
1060 llvm::BasicBlock *getInvokeDest() {
1061 if (!EHStack.requiresLandingPad()) return 0;
1062 return getInvokeDestImpl();
1063 }
Daniel Dunbar9834ffb2009-02-23 17:26:39 +00001064
John McCalld16c2cf2011-02-08 08:22:06 +00001065 llvm::LLVMContext &getLLVMContext() { return CGM.getLLVMContext(); }
Owen Anderson69243822009-07-13 04:10:07 +00001066
Daniel Dunbar9834ffb2009-02-23 17:26:39 +00001067 //===--------------------------------------------------------------------===//
1068 // Objective-C
1069 //===--------------------------------------------------------------------===//
1070
Chris Lattner391d77a2008-03-30 23:03:07 +00001071 void GenerateObjCMethod(const ObjCMethodDecl *OMD);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00001072
Mike Stump0dd9e882009-02-08 23:14:22 +00001073 void StartObjCMethod(const ObjCMethodDecl *MD,
Fariborz Jahanian679a5022009-01-10 21:06:09 +00001074 const ObjCContainerDecl *CD);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00001075
Mike Stump0dd9e882009-02-08 23:14:22 +00001076 /// GenerateObjCGetter - Synthesize an Objective-C property getter function.
Fariborz Jahanianfef30b52008-12-09 20:23:04 +00001077 void GenerateObjCGetter(ObjCImplementationDecl *IMP,
1078 const ObjCPropertyImplDecl *PID);
Fariborz Jahanian2846b972011-02-18 19:15:13 +00001079 void GenerateObjCGetterBody(ObjCIvarDecl *Ivar, bool IsAtomic, bool IsStrong);
1080 void GenerateObjCAtomicSetterBody(ObjCMethodDecl *OMD,
1081 ObjCIvarDecl *Ivar);
1082
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00001083 void GenerateObjCCtorDtorMethod(ObjCImplementationDecl *IMP,
1084 ObjCMethodDecl *MD, bool ctor);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00001085
Mike Stump0dd9e882009-02-08 23:14:22 +00001086 /// GenerateObjCSetter - Synthesize an Objective-C property setter function
1087 /// for the given property.
Fariborz Jahanianfef30b52008-12-09 20:23:04 +00001088 void GenerateObjCSetter(ObjCImplementationDecl *IMP,
1089 const ObjCPropertyImplDecl *PID);
Fariborz Jahanian0b2bd472010-04-13 00:38:05 +00001090 bool IndirectObjCSetterArg(const CGFunctionInfo &FI);
Fariborz Jahanian15bd5882010-04-13 18:32:24 +00001091 bool IvarTypeWithAggrGCObjects(QualType Ty);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00001092
Mike Stump4e7a1f72009-02-21 20:00:35 +00001093 //===--------------------------------------------------------------------===//
1094 // Block Bits
1095 //===--------------------------------------------------------------------===//
1096
John McCall6b5a61b2011-02-07 10:33:21 +00001097 llvm::Value *EmitBlockLiteral(const BlockExpr *);
Blaine Garst2a7eb282010-02-23 21:51:17 +00001098 llvm::Constant *BuildDescriptorBlockDecl(const BlockExpr *,
Fariborz Jahanian89ecd412010-08-04 16:57:49 +00001099 const CGBlockInfo &Info,
Mike Stump08920992009-03-07 02:35:30 +00001100 const llvm::StructType *,
John McCalld16c2cf2011-02-08 08:22:06 +00001101 llvm::Constant *BlockVarLayout);
Mike Stump4e7a1f72009-02-21 20:00:35 +00001102
Fariborz Jahanian564360b2010-06-24 00:08:06 +00001103 llvm::Function *GenerateBlockFunction(GlobalDecl GD,
John McCall6b5a61b2011-02-07 10:33:21 +00001104 const CGBlockInfo &Info,
Mike Stump6cc88f72009-03-20 21:53:12 +00001105 const Decl *OuterFuncDecl,
John McCall6b5a61b2011-02-07 10:33:21 +00001106 const DeclMapTy &ldm);
Mike Stump4e7a1f72009-02-21 20:00:35 +00001107
John McCalld16c2cf2011-02-08 08:22:06 +00001108 llvm::Constant *GenerateCopyHelperFunction(const CGBlockInfo &blockInfo);
1109 llvm::Constant *GenerateDestroyHelperFunction(const CGBlockInfo &blockInfo);
1110
John McCalld16c2cf2011-02-08 08:22:06 +00001111 void BuildBlockRelease(llvm::Value *DeclPtr, BlockFieldFlags flags);
1112
John McCall5af02db2011-03-31 01:59:53 +00001113 class AutoVarEmission;
1114
1115 void emitByrefStructureInit(const AutoVarEmission &emission);
1116 void enterByrefCleanup(const AutoVarEmission &emission);
1117
John McCall6b5a61b2011-02-07 10:33:21 +00001118 llvm::Value *LoadBlockStruct() {
1119 assert(BlockPointer && "no block pointer set!");
1120 return BlockPointer;
1121 }
Mike Stump4e7a1f72009-02-21 20:00:35 +00001122
John McCallea1471e2010-05-20 01:18:31 +00001123 void AllocateBlockCXXThisPointer(const CXXThisExpr *E);
1124 void AllocateBlockDecl(const BlockDeclRefExpr *E);
John McCallee504292010-05-21 04:11:14 +00001125 llvm::Value *GetAddrOfBlockDecl(const BlockDeclRefExpr *E) {
1126 return GetAddrOfBlockDecl(E->getDecl(), E->isByRef());
1127 }
John McCall6b5a61b2011-02-07 10:33:21 +00001128 llvm::Value *GetAddrOfBlockDecl(const VarDecl *var, bool ByRef);
1129 const llvm::Type *BuildByRefType(const VarDecl *var);
Mike Stumpdab514f2009-03-04 03:23:46 +00001130
John McCalld26bc762011-03-09 04:27:21 +00001131 void GenerateCode(GlobalDecl GD, llvm::Function *Fn,
1132 const CGFunctionInfo &FnInfo);
Anders Carlsson0ff8baf2009-09-11 00:07:24 +00001133 void StartFunction(GlobalDecl GD, QualType RetTy,
Daniel Dunbar7c086512008-09-09 23:14:03 +00001134 llvm::Function *Fn,
John McCalld26bc762011-03-09 04:27:21 +00001135 const CGFunctionInfo &FnInfo,
Daniel Dunbar2284ac92008-10-18 18:22:23 +00001136 const FunctionArgList &Args,
Tilmann Scheller9c6082f2011-03-02 21:36:49 +00001137 SourceLocation StartLoc);
Daniel Dunbara448fb22008-11-11 23:11:34 +00001138
John McCall9fc6a772010-02-19 09:25:03 +00001139 void EmitConstructorBody(FunctionArgList &Args);
1140 void EmitDestructorBody(FunctionArgList &Args);
1141 void EmitFunctionBody(FunctionArgList &Args);
John McCalla355e072010-02-18 03:17:58 +00001142
Mike Stump0dd9e882009-02-08 23:14:22 +00001143 /// EmitReturnBlock - Emit the unified return block, trying to avoid its
1144 /// emission when possible.
Daniel Dunbar1c1d6072009-01-26 23:27:52 +00001145 void EmitReturnBlock();
1146
Mike Stump0dd9e882009-02-08 23:14:22 +00001147 /// FinishFunction - Complete IR generation of the current function. It is
1148 /// legal to call this function even if there is no current insertion point.
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00001149 void FinishFunction(SourceLocation EndLoc=SourceLocation());
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001150
Anders Carlsson519c3282010-03-24 00:39:18 +00001151 /// GenerateThunk - Generate a thunk for the given method.
John McCalld26bc762011-03-09 04:27:21 +00001152 void GenerateThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo,
1153 GlobalDecl GD, const ThunkInfo &Thunk);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001154
Douglas Gregorfb8cc252010-05-05 05:51:00 +00001155 void EmitCtorPrologue(const CXXConstructorDecl *CD, CXXCtorType Type,
1156 FunctionArgList &Args);
Mike Stump1eb44332009-09-09 15:08:12 +00001157
Anders Carlssond103f9f2010-03-28 19:40:00 +00001158 /// InitializeVTablePointer - Initialize the vtable pointer of the given
1159 /// subobject.
1160 ///
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001161 void InitializeVTablePointer(BaseSubobject Base,
Anders Carlssonb3b772e2010-04-20 05:22:15 +00001162 const CXXRecordDecl *NearestVBase,
Ken Dyckd6fb21f2011-03-23 01:04:18 +00001163 CharUnits OffsetFromNearestVBase,
Anders Carlssond103f9f2010-03-28 19:40:00 +00001164 llvm::Constant *VTable,
1165 const CXXRecordDecl *VTableClass);
1166
1167 typedef llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBasesSetTy;
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001168 void InitializeVTablePointers(BaseSubobject Base,
Anders Carlssonb3b772e2010-04-20 05:22:15 +00001169 const CXXRecordDecl *NearestVBase,
Ken Dyckd6fb21f2011-03-23 01:04:18 +00001170 CharUnits OffsetFromNearestVBase,
Anders Carlsson603d6d12010-03-28 21:07:49 +00001171 bool BaseIsNonVirtualPrimaryBase,
1172 llvm::Constant *VTable,
1173 const CXXRecordDecl *VTableClass,
1174 VisitedVirtualBasesSetTy& VBases);
Eli Friedman77a259c2009-12-08 06:46:18 +00001175
Anders Carlsson603d6d12010-03-28 21:07:49 +00001176 void InitializeVTablePointers(const CXXRecordDecl *ClassDecl);
Anders Carlssond103f9f2010-03-28 19:40:00 +00001177
Dan Gohman043fb9a2010-10-26 18:44:08 +00001178 /// GetVTablePtr - Return the Value of the vtable pointer member pointed
1179 /// to by This.
1180 llvm::Value *GetVTablePtr(llvm::Value *This, const llvm::Type *Ty);
Anders Carlssond103f9f2010-03-28 19:40:00 +00001181
John McCall50da2ca2010-07-21 05:30:47 +00001182 /// EnterDtorCleanups - Enter the cleanups necessary to complete the
1183 /// given phase of destruction for a destructor. The end result
1184 /// should call destructors on members and base classes in reverse
1185 /// order of their construction.
1186 void EnterDtorCleanups(const CXXDestructorDecl *Dtor, CXXDtorType Type);
Mike Stump1eb44332009-09-09 15:08:12 +00001187
Chris Lattner7255a2d2010-06-22 00:03:40 +00001188 /// ShouldInstrumentFunction - Return true if the current function should be
1189 /// instrumented with __cyg_profile_func_* calls
1190 bool ShouldInstrumentFunction();
1191
1192 /// EmitFunctionInstrumentation - Emit LLVM code to call the specified
1193 /// instrumentation function with the current function and the call site, if
1194 /// function instrumentation is enabled.
1195 void EmitFunctionInstrumentation(const char *Fn);
1196
Roman Divackybe4c8702011-02-10 16:52:03 +00001197 /// EmitMCountInstrumentation - Emit call to .mcount.
1198 void EmitMCountInstrumentation();
1199
Mike Stump0dd9e882009-02-08 23:14:22 +00001200 /// EmitFunctionProlog - Emit the target specific LLVM code to load the
1201 /// arguments for the given function. This is also responsible for naming the
1202 /// LLVM function arguments.
Daniel Dunbar88b53962009-02-02 22:03:45 +00001203 void EmitFunctionProlog(const CGFunctionInfo &FI,
1204 llvm::Function *Fn,
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001205 const FunctionArgList &Args);
1206
Mike Stump0dd9e882009-02-08 23:14:22 +00001207 /// EmitFunctionEpilog - Emit the target specific LLVM code to return the
1208 /// given temporary.
Chris Lattner35b21b82010-06-27 01:06:27 +00001209 void EmitFunctionEpilog(const CGFunctionInfo &FI);
Daniel Dunbar17b708d2008-09-09 23:27:19 +00001210
Mike Stumpcce3d4f2009-12-07 23:38:24 +00001211 /// EmitStartEHSpec - Emit the start of the exception spec.
1212 void EmitStartEHSpec(const Decl *D);
1213
1214 /// EmitEndEHSpec - Emit the end of the exception spec.
1215 void EmitEndEHSpec(const Decl *D);
1216
John McCallf1549f62010-07-06 01:34:17 +00001217 /// getTerminateLandingPad - Return a landing pad that just calls terminate.
1218 llvm::BasicBlock *getTerminateLandingPad();
1219
1220 /// getTerminateHandler - Return a handler (not a landing pad, just
1221 /// a catch handler) that just calls terminate. This is used when
1222 /// a terminate scope encloses a try.
Mike Stump9b39c512009-12-09 22:59:31 +00001223 llvm::BasicBlock *getTerminateHandler();
1224
Daniel Dunbar8b1a3432009-02-03 23:03:55 +00001225 const llvm::Type *ConvertTypeForMem(QualType T);
Reid Spencer5f016e22007-07-11 17:01:13 +00001226 const llvm::Type *ConvertType(QualType T);
John McCallbff225e2010-02-16 04:15:37 +00001227 const llvm::Type *ConvertType(const TypeDecl *T) {
1228 return ConvertType(getContext().getTypeDeclType(T));
1229 }
Chris Lattnerc8aa5f12008-04-04 04:07:35 +00001230
Mike Stump0dd9e882009-02-08 23:14:22 +00001231 /// LoadObjCSelf - Load the value of self. This function is only valid while
1232 /// generating code for an Objective-C method.
Chris Lattnerc8aa5f12008-04-04 04:07:35 +00001233 llvm::Value *LoadObjCSelf();
Mike Stump0dd9e882009-02-08 23:14:22 +00001234
1235 /// TypeOfSelfObject - Return type of object that this self represents.
Fariborz Jahanian45012a72009-02-03 00:09:52 +00001236 QualType TypeOfSelfObject();
Chris Lattner41110242008-06-17 18:05:57 +00001237
Reid Spencer5f016e22007-07-11 17:01:13 +00001238 /// hasAggregateLLVMType - Return true if the specified AST type will map into
1239 /// an aggregate LLVM type or is void.
1240 static bool hasAggregateLLVMType(QualType T);
Daniel Dunbar55e87422008-11-11 02:29:29 +00001241
1242 /// createBasicBlock - Create an LLVM basic block.
John McCalld16c2cf2011-02-08 08:22:06 +00001243 llvm::BasicBlock *createBasicBlock(llvm::StringRef name = "",
1244 llvm::Function *parent = 0,
1245 llvm::BasicBlock *before = 0) {
Daniel Dunbar29ea6722008-11-12 00:01:12 +00001246#ifdef NDEBUG
John McCalld16c2cf2011-02-08 08:22:06 +00001247 return llvm::BasicBlock::Create(getLLVMContext(), "", parent, before);
Daniel Dunbar29ea6722008-11-12 00:01:12 +00001248#else
John McCalld16c2cf2011-02-08 08:22:06 +00001249 return llvm::BasicBlock::Create(getLLVMContext(), name, parent, before);
Daniel Dunbar29ea6722008-11-12 00:01:12 +00001250#endif
Daniel Dunbar55e87422008-11-11 02:29:29 +00001251 }
Mike Stump0dd9e882009-02-08 23:14:22 +00001252
Reid Spencer5f016e22007-07-11 17:01:13 +00001253 /// getBasicBlockForLabel - Return the LLVM basicblock that the specified
1254 /// label maps to.
Chris Lattnerad8dcf42011-02-17 07:39:24 +00001255 JumpDest getJumpDestForLabel(const LabelDecl *S);
Mike Stump0dd9e882009-02-08 23:14:22 +00001256
Mike Stumpf71d2322009-11-30 20:08:49 +00001257 /// SimplifyForwardingBlocks - If the given basic block is only a branch to
1258 /// another basic block, simplify it. This assumes that no other code could
1259 /// potentially reference the basic block.
Daniel Dunbaraa5bd872009-04-01 04:37:47 +00001260 void SimplifyForwardingBlocks(llvm::BasicBlock *BB);
1261
Mike Stump0dd9e882009-02-08 23:14:22 +00001262 /// EmitBlock - Emit the given block \arg BB and set it as the insert point,
1263 /// adding a fall-through branch from the current insert block if
1264 /// necessary. It is legal to call this function even if there is no current
1265 /// insertion point.
Daniel Dunbara0c21a82008-11-13 01:24:05 +00001266 ///
Mike Stump0dd9e882009-02-08 23:14:22 +00001267 /// IsFinished - If true, indicates that the caller has finished emitting
1268 /// branches to the given block and does not expect to emit code into it. This
1269 /// means the block can be ignored if it is unreachable.
Daniel Dunbara0c21a82008-11-13 01:24:05 +00001270 void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false);
Daniel Dunbar824e3bd2008-11-11 04:34:23 +00001271
Mike Stump0dd9e882009-02-08 23:14:22 +00001272 /// EmitBranch - Emit a branch to the specified basic block from the current
1273 /// insert block, taking care to avoid creation of branches from dummy
1274 /// blocks. It is legal to call this function even if there is no current
1275 /// insertion point.
Daniel Dunbar5e08ad32008-11-11 22:06:59 +00001276 ///
Mike Stump0dd9e882009-02-08 23:14:22 +00001277 /// This function clears the current insertion point. The caller should follow
1278 /// calls to this function with calls to Emit*Block prior to generation new
1279 /// code.
Daniel Dunbard57a8712008-11-11 09:41:28 +00001280 void EmitBranch(llvm::BasicBlock *Block);
1281
Mike Stump0dd9e882009-02-08 23:14:22 +00001282 /// HaveInsertPoint - True if an insertion point is defined. If not, this
1283 /// indicates that the current code being emitted is unreachable.
1284 bool HaveInsertPoint() const {
Daniel Dunbara448fb22008-11-11 23:11:34 +00001285 return Builder.GetInsertBlock() != 0;
1286 }
1287
Mike Stump0dd9e882009-02-08 23:14:22 +00001288 /// EnsureInsertPoint - Ensure that an insertion point is defined so that
1289 /// emitted IR has a place to go. Note that by definition, if this function
1290 /// creates a block then that block is unreachable; callers may do better to
1291 /// detect when no insertion point is defined and simply skip IR generation.
Daniel Dunbara448fb22008-11-11 23:11:34 +00001292 void EnsureInsertPoint() {
1293 if (!HaveInsertPoint())
1294 EmitBlock(createBasicBlock());
1295 }
Mike Stump0dd9e882009-02-08 23:14:22 +00001296
Daniel Dunbar488e9932008-08-16 00:56:44 +00001297 /// ErrorUnsupported - Print out an error that codegen doesn't support the
Chris Lattnerdc5e8262007-12-02 01:43:38 +00001298 /// specified stmt yet.
Daniel Dunbar90df4b62008-09-04 03:43:08 +00001299 void ErrorUnsupported(const Stmt *S, const char *Type,
1300 bool OmitOnError=false);
Reid Spencer5f016e22007-07-11 17:01:13 +00001301
1302 //===--------------------------------------------------------------------===//
1303 // Helpers
1304 //===--------------------------------------------------------------------===//
Mike Stump0dd9e882009-02-08 23:14:22 +00001305
Daniel Dunbar983e3d72010-08-21 04:20:22 +00001306 LValue MakeAddrLValue(llvm::Value *V, QualType T, unsigned Alignment = 0) {
Dan Gohman3d5aff52010-10-14 23:06:10 +00001307 return LValue::MakeAddr(V, T, Alignment, getContext(),
1308 CGM.getTBAAInfo(T));
Daniel Dunbar5cf8bfe2010-08-21 02:53:44 +00001309 }
1310
Reid Spencer5f016e22007-07-11 17:01:13 +00001311 /// CreateTempAlloca - This creates a alloca and inserts it into the entry
Daniel Dunbar195337d2010-02-09 02:48:28 +00001312 /// block. The caller is responsible for setting an appropriate alignment on
1313 /// the alloca.
Reid Spencer5f016e22007-07-11 17:01:13 +00001314 llvm::AllocaInst *CreateTempAlloca(const llvm::Type *Ty,
Daniel Dunbar259e9cc2009-10-19 01:21:05 +00001315 const llvm::Twine &Name = "tmp");
Mike Stump0dd9e882009-02-08 23:14:22 +00001316
John McCallac418162010-04-22 01:10:34 +00001317 /// InitTempAlloca - Provide an initial value for the given alloca.
1318 void InitTempAlloca(llvm::AllocaInst *Alloca, llvm::Value *Value);
1319
Daniel Dunbar9bd4da22010-02-16 19:44:13 +00001320 /// CreateIRTemp - Create a temporary IR object of the given type, with
1321 /// appropriate alignment. This routine should only be used when an temporary
1322 /// value needs to be stored into an alloca (for example, to avoid explicit
1323 /// PHI construction), but the type is the IR type, not the type appropriate
1324 /// for storing in memory.
Chris Lattner121b3fa2010-07-05 20:21:00 +00001325 llvm::AllocaInst *CreateIRTemp(QualType T, const llvm::Twine &Name = "tmp");
Daniel Dunbar9bd4da22010-02-16 19:44:13 +00001326
Daniel Dunbar195337d2010-02-09 02:48:28 +00001327 /// CreateMemTemp - Create a temporary memory object of the given type, with
1328 /// appropriate alignment.
Chris Lattner121b3fa2010-07-05 20:21:00 +00001329 llvm::AllocaInst *CreateMemTemp(QualType T, const llvm::Twine &Name = "tmp");
Daniel Dunbar195337d2010-02-09 02:48:28 +00001330
John McCall558d2ab2010-09-15 10:14:12 +00001331 /// CreateAggTemp - Create a temporary memory object for the given
1332 /// aggregate type.
1333 AggValueSlot CreateAggTemp(QualType T, const llvm::Twine &Name = "tmp") {
1334 return AggValueSlot::forAddr(CreateMemTemp(T, Name), false, false);
1335 }
1336
John McCalld16c2cf2011-02-08 08:22:06 +00001337 /// Emit a cast to void* in the appropriate address space.
1338 llvm::Value *EmitCastToVoidPtr(llvm::Value *value);
1339
Reid Spencer5f016e22007-07-11 17:01:13 +00001340 /// EvaluateExprAsBool - Perform the usual unary conversions on the specified
1341 /// expression and compare the result against zero, returning an Int1Ty value.
1342 llvm::Value *EvaluateExprAsBool(const Expr *E);
1343
John McCall2a416372010-12-05 02:00:02 +00001344 /// EmitIgnoredExpr - Emit an expression in a context which ignores the result.
1345 void EmitIgnoredExpr(const Expr *E);
1346
Chris Lattner9b655512007-08-31 22:49:20 +00001347 /// EmitAnyExpr - Emit code to compute the specified expression which can have
1348 /// any type. The result is returned as an RValue struct. If this is an
1349 /// aggregate expression, the aggloc/agglocvolatile arguments indicate where
1350 /// the result should be returned.
Mike Stump49d1cd52009-05-26 22:03:21 +00001351 ///
1352 /// \param IgnoreResult - True if the resulting value isn't used.
John McCall558d2ab2010-09-15 10:14:12 +00001353 RValue EmitAnyExpr(const Expr *E,
1354 AggValueSlot AggSlot = AggValueSlot::ignored(),
1355 bool IgnoreResult = false);
Devang Pateld9363c32007-09-28 21:49:18 +00001356
Mike Stump0dd9e882009-02-08 23:14:22 +00001357 // EmitVAListRef - Emit a "reference" to a va_list; this is either the address
1358 // or the value of the expression, depending on how va_list is defined.
Eli Friedman4fd0aa52009-01-20 17:46:04 +00001359 llvm::Value *EmitVAListRef(const Expr *E);
1360
Mike Stump0dd9e882009-02-08 23:14:22 +00001361 /// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result will
1362 /// always be accessible even if no aggregate location is provided.
John McCall558d2ab2010-09-15 10:14:12 +00001363 RValue EmitAnyExprToTemp(const Expr *E);
Daniel Dunbar46f45b92008-09-09 01:06:48 +00001364
John McCall60d33652011-03-08 09:11:50 +00001365 /// EmitAnyExprToMem - Emits the code necessary to evaluate an
John McCall3d3ec1c2010-04-21 10:05:39 +00001366 /// arbitrary expression into the given memory location.
1367 void EmitAnyExprToMem(const Expr *E, llvm::Value *Location,
John McCall558d2ab2010-09-15 10:14:12 +00001368 bool IsLocationVolatile,
1369 bool IsInitializer);
John McCall3d3ec1c2010-04-21 10:05:39 +00001370
John McCall60d33652011-03-08 09:11:50 +00001371 /// EmitExprAsInit - Emits the code necessary to initialize a
1372 /// location in memory with the given initializer.
1373 void EmitExprAsInit(const Expr *init, const VarDecl *var,
1374 llvm::Value *loc, CharUnits alignment,
1375 bool capturedByInit);
1376
Mike Stump27fe2e62009-05-23 22:29:41 +00001377 /// EmitAggregateCopy - Emit an aggrate copy.
1378 ///
1379 /// \param isVolatile - True iff either the source or the destination is
1380 /// volatile.
Daniel Dunbar7482d122008-09-09 20:49:46 +00001381 void EmitAggregateCopy(llvm::Value *DestPtr, llvm::Value *SrcPtr,
Mike Stump27fe2e62009-05-23 22:29:41 +00001382 QualType EltTy, bool isVolatile=false);
Daniel Dunbar7482d122008-09-09 20:49:46 +00001383
Devang Patel51b09f22007-10-04 23:45:31 +00001384 /// StartBlock - Start new block named N. If insert block is a dummy block
1385 /// then reuse it.
1386 void StartBlock(const char *N);
1387
Lauro Ramos Venancio81373352008-02-26 21:41:45 +00001388 /// GetAddrOfStaticLocalVar - Return the address of a static local variable.
John McCall4c40d982010-08-31 07:33:07 +00001389 llvm::Constant *GetAddrOfStaticLocalVar(const VarDecl *BVD) {
1390 return cast<llvm::Constant>(GetAddrOfLocalVar(BVD));
1391 }
Dan Gohman4f8d1232008-05-22 00:50:06 +00001392
Anders Carlssondde0a942008-09-11 09:15:33 +00001393 /// GetAddrOfLocalVar - Return the address of a local variable.
John McCall4c40d982010-08-31 07:33:07 +00001394 llvm::Value *GetAddrOfLocalVar(const VarDecl *VD) {
1395 llvm::Value *Res = LocalDeclMap[VD];
1396 assert(Res && "Invalid argument to GetAddrOfLocalVar(), no decl!");
1397 return Res;
1398 }
Mike Stump0dd9e882009-02-08 23:14:22 +00001399
John McCall56ca35d2011-02-17 10:25:35 +00001400 /// getOpaqueLValueMapping - Given an opaque value expression (which
1401 /// must be mapped to an l-value), return its mapping.
1402 const LValue &getOpaqueLValueMapping(const OpaqueValueExpr *e) {
1403 assert(OpaqueValueMapping::shouldBindAsLValue(e));
1404
1405 llvm::DenseMap<const OpaqueValueExpr*,LValue>::iterator
1406 it = OpaqueLValues.find(e);
1407 assert(it != OpaqueLValues.end() && "no mapping for opaque value!");
1408 return it->second;
1409 }
1410
1411 /// getOpaqueRValueMapping - Given an opaque value expression (which
1412 /// must be mapped to an r-value), return its mapping.
1413 const RValue &getOpaqueRValueMapping(const OpaqueValueExpr *e) {
1414 assert(!OpaqueValueMapping::shouldBindAsLValue(e));
1415
1416 llvm::DenseMap<const OpaqueValueExpr*,RValue>::iterator
1417 it = OpaqueRValues.find(e);
1418 assert(it != OpaqueRValues.end() && "no mapping for opaque value!");
John McCalle996ffd2011-02-16 08:02:54 +00001419 return it->second;
1420 }
1421
Dan Gohman4f8d1232008-05-22 00:50:06 +00001422 /// getAccessedFieldNo - Given an encoded value and a result number, return
1423 /// the input field number being accessed.
1424 static unsigned getAccessedFieldNo(unsigned Idx, const llvm::Constant *Elts);
1425
Chris Lattnerad8dcf42011-02-17 07:39:24 +00001426 llvm::BlockAddress *GetAddrOfLabel(const LabelDecl *L);
Chris Lattner3d00fdc2009-10-13 06:55:33 +00001427 llvm::BasicBlock *GetIndirectGotoBlock();
Daniel Dunbar0ffb1252008-08-04 16:51:22 +00001428
Anders Carlsson1884eb02010-05-22 17:35:42 +00001429 /// EmitNullInitialization - Generate code to set a value of the given type to
1430 /// null, If the type contains data member pointers, they will be initialized
1431 /// to -1 in accordance with the Itanium C++ ABI.
1432 void EmitNullInitialization(llvm::Value *DestPtr, QualType Ty);
Anders Carlssonddf7cac2008-11-04 05:30:00 +00001433
1434 // EmitVAArg - Generate code to get an argument from the passed in pointer
1435 // and update it accordingly. The return value is a pointer to the argument.
1436 // FIXME: We should be able to get rid of this method and use the va_arg
Mike Stump0dd9e882009-02-08 23:14:22 +00001437 // instruction in LLVM instead once it works well enough.
Anders Carlssonddf7cac2008-11-04 05:30:00 +00001438 llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty);
Anders Carlssonf666b772008-12-20 20:27:15 +00001439
Mike Stumpf71d2322009-11-30 20:08:49 +00001440 /// EmitVLASize - Generate code for any VLA size expressions that might occur
1441 /// in a variably modified type. If Ty is a VLA, will return the value that
1442 /// corresponds to the size in bytes of the VLA type. Will return 0 otherwise.
Daniel Dunbard286f052009-07-19 06:58:07 +00001443 ///
1444 /// This function can be called with a null (unreachable) insert point.
Anders Carlsson60d35412008-12-20 20:46:34 +00001445 llvm::Value *EmitVLASize(QualType Ty);
Mike Stump0dd9e882009-02-08 23:14:22 +00001446
Anders Carlssondcc90d82008-12-12 07:19:02 +00001447 // GetVLASize - Returns an LLVM value that corresponds to the size in bytes
1448 // of a variable length array type.
1449 llvm::Value *GetVLASize(const VariableArrayType *);
1450
Anders Carlsson5f4307b2009-04-14 16:58:56 +00001451 /// LoadCXXThis - Load the value of 'this'. This function is only valid while
1452 /// generating code for an C++ member function.
John McCall25049412010-02-16 22:04:33 +00001453 llvm::Value *LoadCXXThis() {
1454 assert(CXXThisValue && "no 'this' value for this function");
1455 return CXXThisValue;
1456 }
Mike Stump1eb44332009-09-09 15:08:12 +00001457
Anders Carlssonc997d422010-01-02 01:01:18 +00001458 /// LoadCXXVTT - Load the VTT parameter to base constructors/destructors have
1459 /// virtual bases.
John McCall25049412010-02-16 22:04:33 +00001460 llvm::Value *LoadCXXVTT() {
1461 assert(CXXVTTValue && "no VTT value for this function");
1462 return CXXVTTValue;
1463 }
John McCallbff225e2010-02-16 04:15:37 +00001464
1465 /// GetAddressOfBaseOfCompleteClass - Convert the given pointer to a
Anders Carlsson8561a862010-04-24 23:01:49 +00001466 /// complete class to the given direct base.
1467 llvm::Value *
1468 GetAddressOfDirectBaseInCompleteClass(llvm::Value *Value,
1469 const CXXRecordDecl *Derived,
1470 const CXXRecordDecl *Base,
1471 bool BaseIsVirtual);
Anders Carlssona88ad562010-04-24 21:51:08 +00001472
Mike Stumpf71d2322009-11-30 20:08:49 +00001473 /// GetAddressOfBaseClass - This function will add the necessary delta to the
1474 /// load of 'this' and returns address of the base class.
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001475 llvm::Value *GetAddressOfBaseClass(llvm::Value *Value,
Anders Carlsson8561a862010-04-24 23:01:49 +00001476 const CXXRecordDecl *Derived,
John McCallf871d0c2010-08-07 06:22:56 +00001477 CastExpr::path_const_iterator PathBegin,
1478 CastExpr::path_const_iterator PathEnd,
Anders Carlsson34a2d382010-04-24 21:06:20 +00001479 bool NullCheckValue);
1480
Anders Carlssona3697c92009-11-23 17:57:54 +00001481 llvm::Value *GetAddressOfDerivedClass(llvm::Value *Value,
Anders Carlsson8561a862010-04-24 23:01:49 +00001482 const CXXRecordDecl *Derived,
John McCallf871d0c2010-08-07 06:22:56 +00001483 CastExpr::path_const_iterator PathBegin,
1484 CastExpr::path_const_iterator PathEnd,
Anders Carlssona3697c92009-11-23 17:57:54 +00001485 bool NullCheckValue);
1486
Anders Carlssonbb7e17b2010-01-31 01:36:53 +00001487 llvm::Value *GetVirtualBaseClassOffset(llvm::Value *This,
1488 const CXXRecordDecl *ClassDecl,
1489 const CXXRecordDecl *BaseClassDecl);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001490
John McCallc0bf4622010-02-23 00:48:20 +00001491 void EmitDelegateCXXConstructorCall(const CXXConstructorDecl *Ctor,
1492 CXXCtorType CtorType,
1493 const FunctionArgList &Args);
Anders Carlsson155ed4a2010-05-02 23:20:53 +00001494 void EmitCXXConstructorCall(const CXXConstructorDecl *D, CXXCtorType Type,
1495 bool ForVirtualBase, llvm::Value *This,
Anders Carlssonb14095a2009-04-17 00:06:03 +00001496 CallExpr::const_arg_iterator ArgBeg,
1497 CallExpr::const_arg_iterator ArgEnd);
Fariborz Jahanian34999872010-11-13 21:53:34 +00001498
1499 void EmitSynthesizedCXXCopyCtorCall(const CXXConstructorDecl *D,
1500 llvm::Value *This, llvm::Value *Src,
1501 CallExpr::const_arg_iterator ArgBeg,
1502 CallExpr::const_arg_iterator ArgEnd);
Mike Stump1eb44332009-09-09 15:08:12 +00001503
Fariborz Jahanian288dcaf2009-08-19 20:55:16 +00001504 void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D,
Anders Carlsson569c1f42009-09-23 02:45:36 +00001505 const ConstantArrayType *ArrayTy,
Anders Carlsson5d4d9462009-11-24 18:43:52 +00001506 llvm::Value *ArrayPtr,
1507 CallExpr::const_arg_iterator ArgBeg,
Douglas Gregor59174c02010-07-21 01:10:17 +00001508 CallExpr::const_arg_iterator ArgEnd,
1509 bool ZeroInitialization = false);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001510
Anders Carlsson569c1f42009-09-23 02:45:36 +00001511 void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D,
1512 llvm::Value *NumElements,
Anders Carlsson5d4d9462009-11-24 18:43:52 +00001513 llvm::Value *ArrayPtr,
1514 CallExpr::const_arg_iterator ArgBeg,
Douglas Gregor59174c02010-07-21 01:10:17 +00001515 CallExpr::const_arg_iterator ArgEnd,
1516 bool ZeroInitialization = false);
Anders Carlssonb14095a2009-04-17 00:06:03 +00001517
Fariborz Jahanianf800f6c2009-08-20 20:54:15 +00001518 void EmitCXXAggrDestructorCall(const CXXDestructorDecl *D,
1519 const ArrayType *Array,
1520 llvm::Value *This);
Mike Stump1eb44332009-09-09 15:08:12 +00001521
Fariborz Jahanian72c21532009-11-13 19:27:47 +00001522 void EmitCXXAggrDestructorCall(const CXXDestructorDecl *D,
1523 llvm::Value *NumElements,
1524 llvm::Value *This);
1525
Anders Carlsson02e370a2010-06-08 22:14:59 +00001526 llvm::Function *GenerateCXXAggrDestructorHelper(const CXXDestructorDecl *D,
1527 const ArrayType *Array,
1528 llvm::Value *This);
Fariborz Jahanian88f42802009-11-10 19:24:06 +00001529
Anders Carlsson7267c162009-05-29 21:03:38 +00001530 void EmitCXXDestructorCall(const CXXDestructorDecl *D, CXXDtorType Type,
Anders Carlsson8e6404c2010-05-02 23:29:11 +00001531 bool ForVirtualBase, llvm::Value *This);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001532
Fariborz Jahanianef668722010-06-25 18:26:07 +00001533 void EmitNewArrayInitializer(const CXXNewExpr *E, llvm::Value *NewPtr,
1534 llvm::Value *NumElements);
Mike Stump1eb44332009-09-09 15:08:12 +00001535
John McCallf1549f62010-07-06 01:34:17 +00001536 void EmitCXXTemporary(const CXXTemporary *Temporary, llvm::Value *Ptr);
Mike Stump1eb44332009-09-09 15:08:12 +00001537
Anders Carlssona00703d2009-05-31 01:40:14 +00001538 llvm::Value *EmitCXXNewExpr(const CXXNewExpr *E);
Anders Carlsson60e282c2009-08-16 21:13:42 +00001539 void EmitCXXDeleteExpr(const CXXDeleteExpr *E);
Mike Stump1eb44332009-09-09 15:08:12 +00001540
Eli Friedman4bf81522009-11-18 00:57:03 +00001541 void EmitDeleteCall(const FunctionDecl *DeleteFD, llvm::Value *Ptr,
1542 QualType DeleteTy);
1543
Mike Stumpc2e84ae2009-11-15 08:09:41 +00001544 llvm::Value* EmitCXXTypeidExpr(const CXXTypeidExpr *E);
Mike Stumpc849c052009-11-16 06:50:58 +00001545 llvm::Value *EmitDynamicCast(llvm::Value *V, const CXXDynamicCastExpr *DCE);
Mike Stumpc2e84ae2009-11-15 08:09:41 +00001546
Mike Stumpb14e62d2009-12-16 02:57:00 +00001547 void EmitCheck(llvm::Value *, unsigned Size);
1548
Chris Lattnerdd36d322010-01-09 21:40:03 +00001549 llvm::Value *EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV,
1550 bool isInc, bool isPre);
1551 ComplexPairTy EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV,
1552 bool isInc, bool isPre);
Reid Spencer5f016e22007-07-11 17:01:13 +00001553 //===--------------------------------------------------------------------===//
Reid Spencer5f016e22007-07-11 17:01:13 +00001554 // Declaration Emission
1555 //===--------------------------------------------------------------------===//
Mike Stump0dd9e882009-02-08 23:14:22 +00001556
Daniel Dunbard286f052009-07-19 06:58:07 +00001557 /// EmitDecl - Emit a declaration.
1558 ///
1559 /// This function can be called with a null (unreachable) insert point.
Reid Spencer5f016e22007-07-11 17:01:13 +00001560 void EmitDecl(const Decl &D);
Daniel Dunbard286f052009-07-19 06:58:07 +00001561
John McCallb6bbcc92010-10-15 04:57:14 +00001562 /// EmitVarDecl - Emit a local variable declaration.
Daniel Dunbard286f052009-07-19 06:58:07 +00001563 ///
1564 /// This function can be called with a null (unreachable) insert point.
John McCallb6bbcc92010-10-15 04:57:14 +00001565 void EmitVarDecl(const VarDecl &D);
Daniel Dunbard286f052009-07-19 06:58:07 +00001566
John McCallf1549f62010-07-06 01:34:17 +00001567 typedef void SpecialInitFn(CodeGenFunction &Init, const VarDecl &D,
1568 llvm::Value *Address);
1569
John McCallb6bbcc92010-10-15 04:57:14 +00001570 /// EmitAutoVarDecl - Emit an auto variable declaration.
Daniel Dunbard286f052009-07-19 06:58:07 +00001571 ///
1572 /// This function can be called with a null (unreachable) insert point.
John McCall34695852011-02-22 06:44:22 +00001573 void EmitAutoVarDecl(const VarDecl &D);
1574
1575 class AutoVarEmission {
1576 friend class CodeGenFunction;
1577
John McCall57b3b6a2011-02-22 07:16:58 +00001578 const VarDecl *Variable;
John McCall34695852011-02-22 06:44:22 +00001579
1580 /// The alignment of the variable.
1581 CharUnits Alignment;
1582
1583 /// The address of the alloca. Null if the variable was emitted
1584 /// as a global constant.
1585 llvm::Value *Address;
1586
1587 llvm::Value *NRVOFlag;
1588
1589 /// True if the variable is a __block variable.
1590 bool IsByRef;
1591
1592 /// True if the variable is of aggregate type and has a constant
1593 /// initializer.
1594 bool IsConstantAggregate;
1595
John McCall57b3b6a2011-02-22 07:16:58 +00001596 struct Invalid {};
1597 AutoVarEmission(Invalid) : Variable(0) {}
1598
John McCall34695852011-02-22 06:44:22 +00001599 AutoVarEmission(const VarDecl &variable)
John McCall57b3b6a2011-02-22 07:16:58 +00001600 : Variable(&variable), Address(0), NRVOFlag(0),
John McCall34695852011-02-22 06:44:22 +00001601 IsByRef(false), IsConstantAggregate(false) {}
1602
1603 bool wasEmittedAsGlobal() const { return Address == 0; }
1604
1605 public:
John McCall57b3b6a2011-02-22 07:16:58 +00001606 static AutoVarEmission invalid() { return AutoVarEmission(Invalid()); }
1607
John McCall34695852011-02-22 06:44:22 +00001608 /// Returns the address of the object within this declaration.
1609 /// Note that this does not chase the forwarding pointer for
1610 /// __block decls.
1611 llvm::Value *getObjectAddress(CodeGenFunction &CGF) const {
1612 if (!IsByRef) return Address;
1613
1614 return CGF.Builder.CreateStructGEP(Address,
John McCall57b3b6a2011-02-22 07:16:58 +00001615 CGF.getByRefValueLLVMField(Variable),
1616 Variable->getNameAsString());
John McCall34695852011-02-22 06:44:22 +00001617 }
1618 };
1619 AutoVarEmission EmitAutoVarAlloca(const VarDecl &var);
1620 void EmitAutoVarInit(const AutoVarEmission &emission);
1621 void EmitAutoVarCleanups(const AutoVarEmission &emission);
Daniel Dunbard286f052009-07-19 06:58:07 +00001622
John McCallb6bbcc92010-10-15 04:57:14 +00001623 void EmitStaticVarDecl(const VarDecl &D,
1624 llvm::GlobalValue::LinkageTypes Linkage);
Daniel Dunbarb7ec2462008-08-16 03:19:19 +00001625
1626 /// EmitParmDecl - Emit a ParmVarDecl or an ImplicitParamDecl.
Devang Patel093ac462011-03-03 20:13:15 +00001627 void EmitParmDecl(const VarDecl &D, llvm::Value *Arg, unsigned ArgNo);
Mike Stump0dd9e882009-02-08 23:14:22 +00001628
John McCall56ca35d2011-02-17 10:25:35 +00001629 /// protectFromPeepholes - Protect a value that we're intending to
1630 /// store to the side, but which will probably be used later, from
1631 /// aggressive peepholing optimizations that might delete it.
1632 ///
1633 /// Pass the result to unprotectFromPeepholes to declare that
1634 /// protection is no longer required.
1635 ///
1636 /// There's no particular reason why this shouldn't apply to
1637 /// l-values, it's just that no existing peepholes work on pointers.
1638 PeepholeProtection protectFromPeepholes(RValue rvalue);
1639 void unprotectFromPeepholes(PeepholeProtection protection);
1640
Reid Spencer5f016e22007-07-11 17:01:13 +00001641 //===--------------------------------------------------------------------===//
1642 // Statement Emission
1643 //===--------------------------------------------------------------------===//
1644
Mike Stump0dd9e882009-02-08 23:14:22 +00001645 /// EmitStopPoint - Emit a debug stoppoint if we are emitting debug info.
Daniel Dunbar09124252008-11-12 08:21:33 +00001646 void EmitStopPoint(const Stmt *S);
1647
Mike Stump0dd9e882009-02-08 23:14:22 +00001648 /// EmitStmt - Emit the code for the statement \arg S. It is legal to call
1649 /// this function even if there is no current insertion point.
1650 ///
1651 /// This function may clear the current insertion point; callers should use
1652 /// EnsureInsertPoint if they wish to subsequently generate code without first
1653 /// calling EmitBlock, EmitBranch, or EmitStmt.
Reid Spencer5f016e22007-07-11 17:01:13 +00001654 void EmitStmt(const Stmt *S);
Daniel Dunbara448fb22008-11-11 23:11:34 +00001655
Daniel Dunbar09124252008-11-12 08:21:33 +00001656 /// EmitSimpleStmt - Try to emit a "simple" statement which does not
Mike Stump0dd9e882009-02-08 23:14:22 +00001657 /// necessarily require an insertion point or debug information; typically
1658 /// because the statement amounts to a jump or a container of other
1659 /// statements.
Daniel Dunbar09124252008-11-12 08:21:33 +00001660 ///
1661 /// \return True if the statement was handled.
1662 bool EmitSimpleStmt(const Stmt *S);
1663
Chris Lattner9b655512007-08-31 22:49:20 +00001664 RValue EmitCompoundStmt(const CompoundStmt &S, bool GetLast = false,
John McCall558d2ab2010-09-15 10:14:12 +00001665 AggValueSlot AVS = AggValueSlot::ignored());
Daniel Dunbara448fb22008-11-11 23:11:34 +00001666
Mike Stump0dd9e882009-02-08 23:14:22 +00001667 /// EmitLabel - Emit the block for the given label. It is legal to call this
1668 /// function even if there is no current insertion point.
Chris Lattnerad8dcf42011-02-17 07:39:24 +00001669 void EmitLabel(const LabelDecl *D); // helper for EmitLabelStmt.
Daniel Dunbara448fb22008-11-11 23:11:34 +00001670
Reid Spencer5f016e22007-07-11 17:01:13 +00001671 void EmitLabelStmt(const LabelStmt &S);
1672 void EmitGotoStmt(const GotoStmt &S);
Daniel Dunbar0ffb1252008-08-04 16:51:22 +00001673 void EmitIndirectGotoStmt(const IndirectGotoStmt &S);
Reid Spencer5f016e22007-07-11 17:01:13 +00001674 void EmitIfStmt(const IfStmt &S);
1675 void EmitWhileStmt(const WhileStmt &S);
1676 void EmitDoStmt(const DoStmt &S);
1677 void EmitForStmt(const ForStmt &S);
1678 void EmitReturnStmt(const ReturnStmt &S);
1679 void EmitDeclStmt(const DeclStmt &S);
Daniel Dunbar09124252008-11-12 08:21:33 +00001680 void EmitBreakStmt(const BreakStmt &S);
1681 void EmitContinueStmt(const ContinueStmt &S);
Devang Patel51b09f22007-10-04 23:45:31 +00001682 void EmitSwitchStmt(const SwitchStmt &S);
1683 void EmitDefaultStmt(const DefaultStmt &S);
1684 void EmitCaseStmt(const CaseStmt &S);
Devang Patelc049e4f2007-10-08 20:57:48 +00001685 void EmitCaseStmtRange(const CaseStmt &S);
Anders Carlssonfb1aeb82008-02-05 16:35:33 +00001686 void EmitAsmStmt(const AsmStmt &S);
Mike Stump0dd9e882009-02-08 23:14:22 +00001687
Anders Carlsson3d8400d2008-08-30 19:51:14 +00001688 void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S);
Anders Carlsson64d5d6c2008-09-09 10:04:29 +00001689 void EmitObjCAtTryStmt(const ObjCAtTryStmt &S);
1690 void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S);
Chris Lattner10cac6f2008-11-15 21:26:17 +00001691 void EmitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt &S);
Mike Stump0dd9e882009-02-08 23:14:22 +00001692
Douglas Gregor86a3a032010-05-16 01:24:12 +00001693 llvm::Constant *getUnwindResumeOrRethrowFn();
John McCall59a70002010-07-07 06:56:46 +00001694 void EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock = false);
1695 void ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock = false);
John McCall9fc6a772010-02-19 09:25:03 +00001696
Anders Carlsson6815e942009-09-27 18:58:34 +00001697 void EmitCXXTryStmt(const CXXTryStmt &S);
Richard Smithad762fc2011-04-14 22:09:26 +00001698 void EmitCXXForRangeStmt(const CXXForRangeStmt &S);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001699
Reid Spencer5f016e22007-07-11 17:01:13 +00001700 //===--------------------------------------------------------------------===//
1701 // LValue Expression Emission
1702 //===--------------------------------------------------------------------===//
1703
Daniel Dunbar13e81732009-02-05 07:09:07 +00001704 /// GetUndefRValue - Get an appropriate 'undef' rvalue for the given type.
1705 RValue GetUndefRValue(QualType Ty);
1706
Daniel Dunbarce1d38b2009-01-09 16:50:52 +00001707 /// EmitUnsupportedRValue - Emit a dummy r-value using the type of E
1708 /// and issue an ErrorUnsupported style diagnostic (using the
1709 /// provided Name).
1710 RValue EmitUnsupportedRValue(const Expr *E,
1711 const char *Name);
1712
Mike Stump0dd9e882009-02-08 23:14:22 +00001713 /// EmitUnsupportedLValue - Emit a dummy l-value using the type of E and issue
1714 /// an ErrorUnsupported style diagnostic (using the provided Name).
Daniel Dunbar6ba82a42008-08-25 20:45:57 +00001715 LValue EmitUnsupportedLValue(const Expr *E,
1716 const char *Name);
1717
Reid Spencer5f016e22007-07-11 17:01:13 +00001718 /// EmitLValue - Emit code to compute a designator that specifies the location
1719 /// of the expression.
1720 ///
1721 /// This can return one of two things: a simple address or a bitfield
1722 /// reference. In either case, the LLVM Value* in the LValue structure is
1723 /// guaranteed to be an LLVM pointer type.
1724 ///
1725 /// If this returns a bitfield reference, nothing about the pointee type of
1726 /// the LLVM value is known: For example, it may not be a pointer to an
1727 /// integer.
1728 ///
1729 /// If this returns a normal address, and if the lvalue's C type is fixed
1730 /// size, this method guarantees that the returned pointer type will point to
1731 /// an LLVM type of the same size of the lvalue's type. If the lvalue has a
1732 /// variable length type, this is not possible.
1733 ///
1734 LValue EmitLValue(const Expr *E);
Mike Stump0dd9e882009-02-08 23:14:22 +00001735
Mike Stumpb14e62d2009-12-16 02:57:00 +00001736 /// EmitCheckedLValue - Same as EmitLValue but additionally we generate
1737 /// checking code to guard against undefined behavior. This is only
1738 /// suitable when we know that the address will be used to access the
1739 /// object.
1740 LValue EmitCheckedLValue(const Expr *E);
1741
John McCall26815d92010-10-27 20:58:56 +00001742 /// EmitToMemory - Change a scalar value from its value
1743 /// representation to its in-memory representation.
1744 llvm::Value *EmitToMemory(llvm::Value *Value, QualType Ty);
1745
1746 /// EmitFromMemory - Change a scalar value from its memory
1747 /// representation to its value representation.
1748 llvm::Value *EmitFromMemory(llvm::Value *Value, QualType Ty);
1749
Daniel Dunbar9d9cc872009-02-10 00:57:50 +00001750 /// EmitLoadOfScalar - Load a scalar value from an address, taking
1751 /// care to appropriately convert from the memory representation to
1752 /// the LLVM value representation.
Mike Stump09429b92009-02-17 17:00:02 +00001753 llvm::Value *EmitLoadOfScalar(llvm::Value *Addr, bool Volatile,
Dan Gohman3d5aff52010-10-14 23:06:10 +00001754 unsigned Alignment, QualType Ty,
1755 llvm::MDNode *TBAAInfo = 0);
Daniel Dunbar9d9cc872009-02-10 00:57:50 +00001756
1757 /// EmitStoreOfScalar - Store a scalar value to an address, taking
1758 /// care to appropriately convert from the memory representation to
1759 /// the LLVM value representation.
Mike Stump09429b92009-02-17 17:00:02 +00001760 void EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr,
Dan Gohman3d5aff52010-10-14 23:06:10 +00001761 bool Volatile, unsigned Alignment, QualType Ty,
1762 llvm::MDNode *TBAAInfo = 0);
Daniel Dunbar9d9cc872009-02-10 00:57:50 +00001763
Reid Spencer5f016e22007-07-11 17:01:13 +00001764 /// EmitLoadOfLValue - Given an expression that represents a value lvalue,
1765 /// this method emits the address of the lvalue, then loads the result as an
1766 /// rvalue, returning the rvalue.
Reid Spencer5f016e22007-07-11 17:01:13 +00001767 RValue EmitLoadOfLValue(LValue V, QualType LVType);
Nate Begeman213541a2008-04-18 23:10:10 +00001768 RValue EmitLoadOfExtVectorElementLValue(LValue V, QualType LVType);
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +00001769 RValue EmitLoadOfBitfieldLValue(LValue LV, QualType ExprType);
John McCall119a1c62010-12-04 02:32:38 +00001770 RValue EmitLoadOfPropertyRefLValue(LValue LV,
1771 ReturnValueSlot Return = ReturnValueSlot());
Mike Stump0dd9e882009-02-08 23:14:22 +00001772
Reid Spencer5f016e22007-07-11 17:01:13 +00001773 /// EmitStoreThroughLValue - Store the specified rvalue into the specified
1774 /// lvalue, where both are guaranteed to the have the same type, and that type
1775 /// is 'Ty'.
1776 void EmitStoreThroughLValue(RValue Src, LValue Dst, QualType Ty);
Nate Begeman213541a2008-04-18 23:10:10 +00001777 void EmitStoreThroughExtVectorComponentLValue(RValue Src, LValue Dst,
1778 QualType Ty);
John McCall119a1c62010-12-04 02:32:38 +00001779 void EmitStoreThroughPropertyRefLValue(RValue Src, LValue Dst);
Daniel Dunbared3849b2008-11-19 09:36:46 +00001780
Mike Stump0dd9e882009-02-08 23:14:22 +00001781 /// EmitStoreThroughLValue - Store Src into Dst with same constraints as
1782 /// EmitStoreThroughLValue.
Daniel Dunbared3849b2008-11-19 09:36:46 +00001783 ///
Mike Stump0dd9e882009-02-08 23:14:22 +00001784 /// \param Result [out] - If non-null, this will be set to a Value* for the
1785 /// bit-field contents after the store, appropriate for use as the result of
1786 /// an assignment to the bit-field.
Daniel Dunbared3849b2008-11-19 09:36:46 +00001787 void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, QualType Ty,
1788 llvm::Value **Result=0);
Mike Stump0dd9e882009-02-08 23:14:22 +00001789
John McCall83ce9d42010-11-16 23:07:28 +00001790 /// Emit an l-value for an assignment (simple or compound) of complex type.
1791 LValue EmitComplexAssignmentLValue(const BinaryOperator *E);
John McCall2a416372010-12-05 02:00:02 +00001792 LValue EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E);
John McCall83ce9d42010-11-16 23:07:28 +00001793
Chris Lattnerfc8f0e12011-04-15 05:22:18 +00001794 // Note: only available for agg return types
Daniel Dunbar80e62c22008-09-04 03:20:13 +00001795 LValue EmitBinaryOperatorLValue(const BinaryOperator *E);
John McCall2a416372010-12-05 02:00:02 +00001796 LValue EmitCompoundAssignmentLValue(const CompoundAssignOperator *E);
Daniel Dunbar5b5c9ef2009-02-11 20:59:32 +00001797 // Note: only available for agg return types
Christopher Lamb22c940e2007-12-29 05:02:41 +00001798 LValue EmitCallExprLValue(const CallExpr *E);
Daniel Dunbar5b5c9ef2009-02-11 20:59:32 +00001799 // Note: only available for agg return types
1800 LValue EmitVAArgExprLValue(const VAArgExpr *E);
Reid Spencer5f016e22007-07-11 17:01:13 +00001801 LValue EmitDeclRefLValue(const DeclRefExpr *E);
1802 LValue EmitStringLiteralLValue(const StringLiteral *E);
Chris Lattnereaf2bb82009-02-24 22:18:39 +00001803 LValue EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E);
Chris Lattnerd9f69102008-08-10 01:53:14 +00001804 LValue EmitPredefinedLValue(const PredefinedExpr *E);
Reid Spencer5f016e22007-07-11 17:01:13 +00001805 LValue EmitUnaryOpLValue(const UnaryOperator *E);
1806 LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E);
Nate Begeman213541a2008-04-18 23:10:10 +00001807 LValue EmitExtVectorElementExpr(const ExtVectorElementExpr *E);
Devang Patelb84a06e2007-10-23 02:10:49 +00001808 LValue EmitMemberExpr(const MemberExpr *E);
Fariborz Jahanian820bca42009-12-09 23:35:29 +00001809 LValue EmitObjCIsaExpr(const ObjCIsaExpr *E);
Eli Friedman06e863f2008-05-13 23:18:27 +00001810 LValue EmitCompoundLiteralLValue(const CompoundLiteralExpr *E);
John McCall56ca35d2011-02-17 10:25:35 +00001811 LValue EmitConditionalOperatorLValue(const AbstractConditionalOperator *E);
Chris Lattner75dfeda2009-03-18 18:28:57 +00001812 LValue EmitCastLValue(const CastExpr *E);
Douglas Gregored8abf12010-07-08 06:14:04 +00001813 LValue EmitNullInitializationLValue(const CXXScalarValueInitExpr *E);
John McCalle996ffd2011-02-16 08:02:54 +00001814 LValue EmitOpaqueValueLValue(const OpaqueValueExpr *e);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001815
Daniel Dunbar2a031922009-04-22 05:08:15 +00001816 llvm::Value *EmitIvarOffset(const ObjCInterfaceDecl *Interface,
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00001817 const ObjCIvarDecl *Ivar);
John McCalla9976d32010-05-21 01:18:57 +00001818 LValue EmitLValueForAnonRecordField(llvm::Value* Base,
Francois Pichet00eb3f92010-12-04 09:14:42 +00001819 const IndirectFieldDecl* Field,
John McCalla9976d32010-05-21 01:18:57 +00001820 unsigned CVRQualifiers);
Anders Carlsson0ed303c2009-11-17 03:57:07 +00001821 LValue EmitLValueForField(llvm::Value* Base, const FieldDecl* Field,
Anders Carlssone6d2a532010-01-29 05:05:36 +00001822 unsigned CVRQualifiers);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001823
Anders Carlsson06a29702010-01-29 05:24:29 +00001824 /// EmitLValueForFieldInitialization - Like EmitLValueForField, except that
1825 /// if the Field is a reference, this will return the address of the reference
1826 /// and not the address of the value stored in the reference.
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001827 LValue EmitLValueForFieldInitialization(llvm::Value* Base,
Anders Carlsson06a29702010-01-29 05:24:29 +00001828 const FieldDecl* Field,
1829 unsigned CVRQualifiers);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001830
Fariborz Jahanian45012a72009-02-03 00:09:52 +00001831 LValue EmitLValueForIvar(QualType ObjectTy,
1832 llvm::Value* Base, const ObjCIvarDecl *Ivar,
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00001833 unsigned CVRQualifiers);
1834
Anders Carlsson0ed303c2009-11-17 03:57:07 +00001835 LValue EmitLValueForBitfield(llvm::Value* Base, const FieldDecl* Field,
Fariborz Jahanian598d3f62009-02-03 19:03:09 +00001836 unsigned CVRQualifiers);
Fariborz Jahanianfd64bb62008-12-15 20:35:07 +00001837
Mike Stumpa99038c2009-02-28 09:07:16 +00001838 LValue EmitBlockDeclRefLValue(const BlockDeclRefExpr *E);
1839
Anders Carlssonb58d0172009-05-30 23:23:33 +00001840 LValue EmitCXXConstructLValue(const CXXConstructExpr *E);
Anders Carlssone61c9e82009-05-30 23:30:54 +00001841 LValue EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E);
John McCall4765fa02010-12-06 08:20:24 +00001842 LValue EmitExprWithCleanupsLValue(const ExprWithCleanups *E);
Mike Stumpc2e84ae2009-11-15 08:09:41 +00001843 LValue EmitCXXTypeidLValue(const CXXTypeidExpr *E);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001844
Daniel Dunbar0a04d772008-08-23 10:51:21 +00001845 LValue EmitObjCMessageExprLValue(const ObjCMessageExpr *E);
Chris Lattner391d77a2008-03-30 23:03:07 +00001846 LValue EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E);
Daniel Dunbar85c59ed2008-08-29 08:11:39 +00001847 LValue EmitObjCPropertyRefLValue(const ObjCPropertyRefExpr *E);
Chris Lattner65459942009-04-25 19:35:26 +00001848 LValue EmitStmtExprLValue(const StmtExpr *E);
Fariborz Jahanian8bfd31f2009-10-22 22:57:31 +00001849 LValue EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E);
Fariborz Jahanian03b29602010-06-17 19:56:20 +00001850 LValue EmitObjCSelectorLValue(const ObjCSelectorExpr *E);
John McCall189d6ef2010-10-09 01:34:31 +00001851 void EmitDeclRefExprDbgValue(const DeclRefExpr *E, llvm::Constant *Init);
John McCall56ca35d2011-02-17 10:25:35 +00001852
Reid Spencer5f016e22007-07-11 17:01:13 +00001853 //===--------------------------------------------------------------------===//
Chris Lattner883f6a72007-08-11 00:04:45 +00001854 // Scalar Expression Emission
Reid Spencer5f016e22007-07-11 17:01:13 +00001855 //===--------------------------------------------------------------------===//
1856
Mike Stump0dd9e882009-02-08 23:14:22 +00001857 /// EmitCall - Generate a call of the given function, expecting the given
1858 /// result type, and using the given argument list which specifies both the
1859 /// LLVM arguments and the types they were derived from.
Daniel Dunbarc0ef9f52009-02-20 18:06:48 +00001860 ///
Mike Stumpf71d2322009-11-30 20:08:49 +00001861 /// \param TargetDecl - If given, the decl of the function in a direct call;
1862 /// used to set attributes on the call (noreturn, etc.).
Daniel Dunbar88b53962009-02-02 22:03:45 +00001863 RValue EmitCall(const CGFunctionInfo &FnInfo,
1864 llvm::Value *Callee,
Anders Carlssonf3c47c92009-12-24 19:25:24 +00001865 ReturnValueSlot ReturnValue,
Daniel Dunbarc0ef9f52009-02-20 18:06:48 +00001866 const CallArgList &Args,
David Chisnalldd5c98f2010-05-01 11:15:56 +00001867 const Decl *TargetDecl = 0,
David Chisnall4b02afc2010-05-02 13:41:58 +00001868 llvm::Instruction **callOrInvoke = 0);
Mike Stump1eb44332009-09-09 15:08:12 +00001869
Anders Carlsson31777a22009-12-24 19:08:58 +00001870 RValue EmitCall(QualType FnType, llvm::Value *Callee,
Anders Carlssond2490a92009-12-24 20:40:36 +00001871 ReturnValueSlot ReturnValue,
Anders Carlsson98647712009-05-27 01:22:39 +00001872 CallExpr::const_arg_iterator ArgBeg,
1873 CallExpr::const_arg_iterator ArgEnd,
1874 const Decl *TargetDecl = 0);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001875 RValue EmitCallExpr(const CallExpr *E,
Anders Carlssond2490a92009-12-24 20:40:36 +00001876 ReturnValueSlot ReturnValue = ReturnValueSlot());
Mike Stump1eb44332009-09-09 15:08:12 +00001877
John McCallf1549f62010-07-06 01:34:17 +00001878 llvm::CallSite EmitCallOrInvoke(llvm::Value *Callee,
1879 llvm::Value * const *ArgBegin,
1880 llvm::Value * const *ArgEnd,
1881 const llvm::Twine &Name = "");
1882
Anders Carlsson566abee2009-11-13 04:45:41 +00001883 llvm::Value *BuildVirtualCall(const CXXMethodDecl *MD, llvm::Value *This,
Mike Stumpf0070db2009-08-26 20:46:33 +00001884 const llvm::Type *Ty);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001885 llvm::Value *BuildVirtualCall(const CXXDestructorDecl *DD, CXXDtorType Type,
Anders Carlsson83eedd92010-11-28 17:53:32 +00001886 llvm::Value *This, const llvm::Type *Ty);
Fariborz Jahanian27262672011-01-20 17:19:02 +00001887 llvm::Value *BuildAppleKextVirtualCall(const CXXMethodDecl *MD,
1888 NestedNameSpecifier *Qual,
Fariborz Jahanian27262672011-01-20 17:19:02 +00001889 const llvm::Type *Ty);
Fariborz Jahanianccd52592011-02-01 23:22:34 +00001890
1891 llvm::Value *BuildAppleKextVirtualDestructorCall(const CXXDestructorDecl *DD,
1892 CXXDtorType Type,
Fariborz Jahanian771c6782011-02-03 19:27:17 +00001893 const CXXRecordDecl *RD);
Anders Carlsson566abee2009-11-13 04:45:41 +00001894
Anders Carlssonb9de2c52009-05-11 23:37:08 +00001895 RValue EmitCXXMemberCall(const CXXMethodDecl *MD,
1896 llvm::Value *Callee,
Anders Carlssona1736c02009-12-24 21:13:40 +00001897 ReturnValueSlot ReturnValue,
Anders Carlssonb9de2c52009-05-11 23:37:08 +00001898 llvm::Value *This,
Anders Carlssonc997d422010-01-02 01:01:18 +00001899 llvm::Value *VTT,
Anders Carlssonb9de2c52009-05-11 23:37:08 +00001900 CallExpr::const_arg_iterator ArgBeg,
1901 CallExpr::const_arg_iterator ArgEnd);
Anders Carlssona1736c02009-12-24 21:13:40 +00001902 RValue EmitCXXMemberCallExpr(const CXXMemberCallExpr *E,
1903 ReturnValueSlot ReturnValue);
1904 RValue EmitCXXMemberPointerCallExpr(const CXXMemberCallExpr *E,
1905 ReturnValueSlot ReturnValue);
Ted Kremenek55499762008-06-17 02:43:46 +00001906
Anders Carlsson0f294632009-05-27 04:18:27 +00001907 RValue EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E,
Anders Carlssona1736c02009-12-24 21:13:40 +00001908 const CXXMethodDecl *MD,
1909 ReturnValueSlot ReturnValue);
Mike Stump1eb44332009-09-09 15:08:12 +00001910
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001911
Mike Stump1eb44332009-09-09 15:08:12 +00001912 RValue EmitBuiltinExpr(const FunctionDecl *FD,
Daniel Dunbaref2abfe2009-02-16 22:43:43 +00001913 unsigned BuiltinID, const CallExpr *E);
Reid Spencer5f016e22007-07-11 17:01:13 +00001914
Anders Carlssona1736c02009-12-24 21:13:40 +00001915 RValue EmitBlockCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue);
Mike Stump09429b92009-02-17 17:00:02 +00001916
Mike Stump0dd9e882009-02-08 23:14:22 +00001917 /// EmitTargetBuiltinExpr - Emit the given builtin call. Returns 0 if the call
1918 /// is unhandled by the current target.
Daniel Dunbarf02e9dd2008-10-10 00:24:54 +00001919 llvm::Value *EmitTargetBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
1920
Chris Lattner2752c012010-03-03 19:03:45 +00001921 llvm::Value *EmitARMBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001922 llvm::Value *EmitNeonCall(llvm::Function *F,
Nate Begeman30d91712010-06-08 06:03:01 +00001923 llvm::SmallVectorImpl<llvm::Value*> &O,
Bob Wilsondb3d4d02010-12-08 22:37:56 +00001924 const char *name,
Nate Begeman61eecf52010-06-14 05:21:25 +00001925 unsigned shift = 0, bool rightshift = false);
Bob Wilsoncf556522010-12-07 22:40:02 +00001926 llvm::Value *EmitNeonSplat(llvm::Value *V, llvm::Constant *Idx);
Nate Begeman464ccb62010-06-11 22:57:12 +00001927 llvm::Value *EmitNeonShiftVector(llvm::Value *V, const llvm::Type *Ty,
Nate Begeman61eecf52010-06-14 05:21:25 +00001928 bool negateForRightShift);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001929
Bill Wendlingaa51e512010-10-09 08:47:25 +00001930 llvm::Value *BuildVector(const llvm::SmallVectorImpl<llvm::Value*> &Ops);
Anders Carlsson564f1de2007-12-09 23:17:02 +00001931 llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E);
1932 llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
Mike Stump0dd9e882009-02-08 23:14:22 +00001933
Daniel Dunbared7c6182008-08-20 00:28:19 +00001934 llvm::Value *EmitObjCProtocolExpr(const ObjCProtocolExpr *E);
Chris Lattner7f02f722007-08-24 05:35:26 +00001935 llvm::Value *EmitObjCStringLiteral(const ObjCStringLiteral *E);
Chris Lattner8fdf3282008-06-24 17:04:18 +00001936 llvm::Value *EmitObjCSelectorExpr(const ObjCSelectorExpr *E);
John McCallef072fd2010-05-22 01:48:05 +00001937 RValue EmitObjCMessageExpr(const ObjCMessageExpr *E,
1938 ReturnValueSlot Return = ReturnValueSlot());
Chris Lattner8fdf3282008-06-24 17:04:18 +00001939
Anders Carlsson4029ca72009-05-20 00:24:07 +00001940 /// EmitReferenceBindingToExpr - Emits a reference binding to the passed in
1941 /// expression. Will emit a temporary variable if E is not an LValue.
Michael J. Spencer9cac4942010-10-19 06:39:39 +00001942 RValue EmitReferenceBindingToExpr(const Expr* E,
Anders Carlsson32f36ba2010-06-26 16:35:32 +00001943 const NamedDecl *InitializedDecl);
Anders Carlsson3aba0932010-01-31 18:34:51 +00001944
Chris Lattner883f6a72007-08-11 00:04:45 +00001945 //===--------------------------------------------------------------------===//
Chris Lattnerbfc0c1a2007-08-26 23:13:56 +00001946 // Expression Emission
Chris Lattner883f6a72007-08-11 00:04:45 +00001947 //===--------------------------------------------------------------------===//
Chris Lattnerbfc0c1a2007-08-26 23:13:56 +00001948
1949 // Expressions are broken into three classes: scalar, complex, aggregate.
Mike Stump0dd9e882009-02-08 23:14:22 +00001950
1951 /// EmitScalarExpr - Emit the computation of the specified expression of LLVM
1952 /// scalar type, returning the result.
Anders Carlsson14c5cbf2009-08-16 07:36:22 +00001953 llvm::Value *EmitScalarExpr(const Expr *E , bool IgnoreResultAssign = false);
Mike Stump0dd9e882009-02-08 23:14:22 +00001954
Chris Lattner3707b252007-08-26 06:48:56 +00001955 /// EmitScalarConversion - Emit a conversion from the specified type to the
1956 /// specified destination type, both of which are LLVM scalar types.
1957 llvm::Value *EmitScalarConversion(llvm::Value *Src, QualType SrcTy,
1958 QualType DstTy);
Mike Stump0dd9e882009-02-08 23:14:22 +00001959
Chris Lattner4f1a7b32007-08-26 16:34:22 +00001960 /// EmitComplexToScalarConversion - Emit a conversion from the specified
Mike Stump0dd9e882009-02-08 23:14:22 +00001961 /// complex type to the specified destination type, where the destination type
1962 /// is an LLVM scalar type.
Chris Lattner4f1a7b32007-08-26 16:34:22 +00001963 llvm::Value *EmitComplexToScalarConversion(ComplexPairTy Src, QualType SrcTy,
1964 QualType DstTy);
Mike Stump0dd9e882009-02-08 23:14:22 +00001965
1966
John McCall558d2ab2010-09-15 10:14:12 +00001967 /// EmitAggExpr - Emit the computation of the specified expression
1968 /// of aggregate type. The result is computed into the given slot,
1969 /// which may be null to indicate that the value is not needed.
Fariborz Jahanian474e2fe2010-09-16 00:20:07 +00001970 void EmitAggExpr(const Expr *E, AggValueSlot AS, bool IgnoreResult = false);
Mike Stump0dd9e882009-02-08 23:14:22 +00001971
Daniel Dunbar18aba0d2010-02-05 19:38:31 +00001972 /// EmitAggExprToLValue - Emit the computation of the specified expression of
1973 /// aggregate type into a temporary LValue.
1974 LValue EmitAggExprToLValue(const Expr *E);
1975
Fariborz Jahanian082b02e2009-07-08 01:18:33 +00001976 /// EmitGCMemmoveCollectable - Emit special API for structs with object
1977 /// pointers.
1978 void EmitGCMemmoveCollectable(llvm::Value *DestPtr, llvm::Value *SrcPtr,
Fariborz Jahanian08c32132009-08-31 19:33:16 +00001979 QualType Ty);
Fariborz Jahanian082b02e2009-07-08 01:18:33 +00001980
Chris Lattnerb6ef18a2007-08-21 05:54:00 +00001981 /// EmitComplexExpr - Emit the computation of the specified expression of
Chris Lattner23b1cdb2007-08-23 23:43:33 +00001982 /// complex type, returning the result.
John McCallb418d742010-11-16 10:08:07 +00001983 ComplexPairTy EmitComplexExpr(const Expr *E,
1984 bool IgnoreReal = false,
1985 bool IgnoreImag = false);
Mike Stump0dd9e882009-02-08 23:14:22 +00001986
Chris Lattner23b1cdb2007-08-23 23:43:33 +00001987 /// EmitComplexExprIntoAddr - Emit the computation of the specified expression
1988 /// of complex type, storing into the specified Value*.
Chris Lattner190dbe22007-08-26 16:22:13 +00001989 void EmitComplexExprIntoAddr(const Expr *E, llvm::Value *DestAddr,
1990 bool DestIsVolatile);
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +00001991
1992 /// StoreComplexToAddr - Store a complex number into the specified address.
1993 void StoreComplexToAddr(ComplexPairTy V, llvm::Value *DestAddr,
1994 bool DestIsVolatile);
Chris Lattner9b655512007-08-31 22:49:20 +00001995 /// LoadComplexFromAddr - Load a complex number from the specified address.
1996 ComplexPairTy LoadComplexFromAddr(llvm::Value *SrcAddr, bool SrcIsVolatile);
Chris Lattner2621fd12008-05-08 05:58:21 +00001997
John McCallb6bbcc92010-10-15 04:57:14 +00001998 /// CreateStaticVarDecl - Create a zero-initialized LLVM global for
1999 /// a static local variable.
2000 llvm::GlobalVariable *CreateStaticVarDecl(const VarDecl &D,
2001 const char *Separator,
Mike Stumpf71d2322009-11-30 20:08:49 +00002002 llvm::GlobalValue::LinkageTypes Linkage);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002003
John McCallb6bbcc92010-10-15 04:57:14 +00002004 /// AddInitializerToStaticVarDecl - Add the initializer for 'D' to the
Chris Lattner761acc12009-12-05 08:22:11 +00002005 /// global variable that has already been created for it. If the initializer
2006 /// has a different type than GV does, this may free GV and return a different
2007 /// one. Otherwise it just returns GV.
2008 llvm::GlobalVariable *
John McCallb6bbcc92010-10-15 04:57:14 +00002009 AddInitializerToStaticVarDecl(const VarDecl &D,
2010 llvm::GlobalVariable *GV);
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002011
Daniel Dunbar0096acf2009-02-25 19:24:29 +00002012
Anders Carlsson3b2e16b2009-08-08 21:45:14 +00002013 /// EmitCXXGlobalVarDeclInit - Create the initializer for a C++
2014 /// variable with global storage.
2015 void EmitCXXGlobalVarDeclInit(const VarDecl &D, llvm::Constant *DeclPtr);
2016
2017 /// EmitCXXGlobalDtorRegistration - Emits a call to register the global ptr
2018 /// with the C++ runtime so that its destructor will be called at exit.
Fariborz Jahanian88f42802009-11-10 19:24:06 +00002019 void EmitCXXGlobalDtorRegistration(llvm::Constant *DtorFn,
Anders Carlsson3b2e16b2009-08-08 21:45:14 +00002020 llvm::Constant *DeclPtr);
Mike Stump1eb44332009-09-09 15:08:12 +00002021
John McCall3030eb82010-11-06 09:44:32 +00002022 /// Emit code in this function to perform a guarded variable
2023 /// initialization. Guarded initializations are used when it's not
2024 /// possible to prove that an initialization will be done exactly
2025 /// once, e.g. with a static local variable or a static data member
2026 /// of a class template.
2027 void EmitCXXGuardedInit(const VarDecl &D, llvm::GlobalVariable *DeclPtr);
John McCall5cd91b52010-09-08 01:44:27 +00002028
Daniel Dunbarefb0fa92010-03-20 04:15:41 +00002029 /// GenerateCXXGlobalInitFunc - Generates code for initializing global
2030 /// variables.
2031 void GenerateCXXGlobalInitFunc(llvm::Function *Fn,
2032 llvm::Constant **Decls,
2033 unsigned NumDecls);
2034
2035 /// GenerateCXXGlobalDtorFunc - Generates code for destroying global
2036 /// variables.
2037 void GenerateCXXGlobalDtorFunc(llvm::Function *Fn,
Chris Lattner810112e2010-06-19 05:52:45 +00002038 const std::vector<std::pair<llvm::WeakVH,
Daniel Dunbarefb0fa92010-03-20 04:15:41 +00002039 llvm::Constant*> > &DtorsAndObjects);
2040
John McCalld26bc762011-03-09 04:27:21 +00002041 void GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn,
2042 const VarDecl *D,
John McCall3030eb82010-11-06 09:44:32 +00002043 llvm::GlobalVariable *Addr);
Daniel Dunbarefb0fa92010-03-20 04:15:41 +00002044
John McCall558d2ab2010-09-15 10:14:12 +00002045 void EmitCXXConstructExpr(const CXXConstructExpr *E, AggValueSlot Dest);
Fariborz Jahanian34999872010-11-13 21:53:34 +00002046
2047 void EmitSynthesizedCXXCopyCtor(llvm::Value *Dest, llvm::Value *Src,
Fariborz Jahanian830937b2010-12-02 17:02:11 +00002048 const Expr *Exp);
Mike Stump1eb44332009-09-09 15:08:12 +00002049
John McCall4765fa02010-12-06 08:20:24 +00002050 RValue EmitExprWithCleanups(const ExprWithCleanups *E,
2051 AggValueSlot Slot =AggValueSlot::ignored());
Mike Stump1eb44332009-09-09 15:08:12 +00002052
Anders Carlsson756b5c42009-10-30 01:42:31 +00002053 void EmitCXXThrowExpr(const CXXThrowExpr *E);
Douglas Gregor1eb2e592010-05-16 00:44:00 +00002054
Daniel Dunbar0ffb1252008-08-04 16:51:22 +00002055 //===--------------------------------------------------------------------===//
2056 // Internal Helpers
2057 //===--------------------------------------------------------------------===//
Mike Stump0dd9e882009-02-08 23:14:22 +00002058
Chris Lattner0946ccd2008-11-11 07:41:27 +00002059 /// ContainsLabel - Return true if the statement contains a label in it. If
2060 /// this statement is not executed normally, it not containing a label means
2061 /// that we can just remove the code.
2062 static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts = false);
Mike Stump0dd9e882009-02-08 23:14:22 +00002063
Chris Lattneref425a62011-02-28 00:18:40 +00002064 /// containsBreak - Return true if the statement contains a break out of it.
2065 /// If the statement (recursively) contains a switch or loop with a break
2066 /// inside of it, this is fine.
2067 static bool containsBreak(const Stmt *S);
2068
Daniel Dunbar4bc04552008-11-12 10:12:14 +00002069 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
Chris Lattnerc2c90012011-02-27 23:02:32 +00002070 /// to a constant, or if it does but contains a label, return false. If it
2071 /// constant folds return true and set the boolean result in Result.
2072 bool ConstantFoldsToSimpleInteger(const Expr *Cond, bool &Result);
Mike Stump0dd9e882009-02-08 23:14:22 +00002073
Chris Lattneref425a62011-02-28 00:18:40 +00002074 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
2075 /// to a constant, or if it does but contains a label, return false. If it
2076 /// constant folds return true and set the folded value.
2077 bool ConstantFoldsToSimpleInteger(const Expr *Cond, llvm::APInt &Result);
2078
Chris Lattner31a09842008-11-12 08:04:58 +00002079 /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an
2080 /// if statement) to the specified blocks. Based on the condition, this might
2081 /// try to simplify the codegen of the conditional based on the branch.
Chris Lattner9bc47e22008-11-12 07:46:33 +00002082 void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock,
Daniel Dunbar4bc04552008-11-12 10:12:14 +00002083 llvm::BasicBlock *FalseBlock);
Mike Stumpbe07f602009-12-14 21:58:14 +00002084
Mike Stump15037ca2009-12-15 00:35:12 +00002085 /// getTrapBB - Create a basic block that will call the trap intrinsic. We'll
2086 /// generate a branch around the created basic block as necessary.
Chris Lattner6c552c12010-07-20 20:19:24 +00002087 llvm::BasicBlock *getTrapBB();
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002088
Anders Carlsson21c9ad92010-03-30 03:27:09 +00002089 /// EmitCallArg - Emit a single call argument.
John McCall413ebdb2011-03-11 20:59:21 +00002090 void EmitCallArg(CallArgList &args, const Expr *E, QualType ArgType);
Anders Carlsson21c9ad92010-03-30 03:27:09 +00002091
John McCall27360712010-05-26 22:34:26 +00002092 /// EmitDelegateCallArg - We are performing a delegate call; that
2093 /// is, the current function is delegating to another one. Produce
2094 /// a r-value suitable for passing the given parameter.
John McCall413ebdb2011-03-11 20:59:21 +00002095 void EmitDelegateCallArg(CallArgList &args, const VarDecl *param);
John McCall27360712010-05-26 22:34:26 +00002096
Chris Lattner31a09842008-11-12 08:04:58 +00002097private:
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00002098 void EmitReturnOfRValue(RValue RV, QualType Ty);
2099
Daniel Dunbar56273772008-09-17 00:51:38 +00002100 /// ExpandTypeFromArgs - Reconstruct a structure of type \arg Ty
2101 /// from function arguments into \arg Dst. See ABIArgInfo::Expand.
2102 ///
2103 /// \param AI - The first function argument of the expansion.
2104 /// \return The argument following the last expanded function
2105 /// argument.
Mike Stump0dd9e882009-02-08 23:14:22 +00002106 llvm::Function::arg_iterator
Daniel Dunbar56273772008-09-17 00:51:38 +00002107 ExpandTypeFromArgs(QualType Ty, LValue Dst,
2108 llvm::Function::arg_iterator AI);
2109
Mike Stump0dd9e882009-02-08 23:14:22 +00002110 /// ExpandTypeToArgs - Expand an RValue \arg Src, with the LLVM type for \arg
2111 /// Ty, into individual arguments on the provided vector \arg Args. See
2112 /// ABIArgInfo::Expand.
2113 void ExpandTypeToArgs(QualType Ty, RValue Src,
Daniel Dunbar56273772008-09-17 00:51:38 +00002114 llvm::SmallVector<llvm::Value*, 16> &Args);
Anders Carlssonc8c7b182009-01-11 19:40:10 +00002115
Mike Stump1eb44332009-09-09 15:08:12 +00002116 llvm::Value* EmitAsmInput(const AsmStmt &S,
Daniel Dunbarb84e8a62009-05-04 06:56:16 +00002117 const TargetInfo::ConstraintInfo &Info,
Anders Carlssonc8c7b182009-01-11 19:40:10 +00002118 const Expr *InputExpr, std::string &ConstraintStr);
Mike Stump0dd9e882009-02-08 23:14:22 +00002119
Eli Friedman6d7cfd72010-07-16 00:55:21 +00002120 llvm::Value* EmitAsmInputLValue(const AsmStmt &S,
2121 const TargetInfo::ConstraintInfo &Info,
2122 LValue InputValue, QualType InputType,
2123 std::string &ConstraintStr);
2124
Anders Carlsson0139bb92009-04-08 20:47:54 +00002125 /// EmitCallArgs - Emit call arguments for a function.
Mike Stump1eb44332009-09-09 15:08:12 +00002126 /// The CallArgTypeInfo parameter is used for iterating over the known
Anders Carlssonaf23f692009-04-18 20:20:22 +00002127 /// argument types of the function being called.
2128 template<typename T>
2129 void EmitCallArgs(CallArgList& Args, const T* CallArgTypeInfo,
Anders Carlsson0139bb92009-04-08 20:47:54 +00002130 CallExpr::const_arg_iterator ArgBeg,
Anders Carlssonaf23f692009-04-18 20:20:22 +00002131 CallExpr::const_arg_iterator ArgEnd) {
2132 CallExpr::const_arg_iterator Arg = ArgBeg;
Anders Carlsson0139bb92009-04-08 20:47:54 +00002133
Anders Carlssonaf23f692009-04-18 20:20:22 +00002134 // First, use the argument types that the type info knows about
2135 if (CallArgTypeInfo) {
2136 for (typename T::arg_type_iterator I = CallArgTypeInfo->arg_type_begin(),
2137 E = CallArgTypeInfo->arg_type_end(); I != E; ++I, ++Arg) {
Eli Friedman44b0a3e2009-11-18 03:42:04 +00002138 assert(Arg != ArgEnd && "Running over edge of argument list!");
Anders Carlssonaf23f692009-04-18 20:20:22 +00002139 QualType ArgType = *I;
Fariborz Jahanian745da3a2010-09-24 17:30:16 +00002140#ifndef NDEBUG
2141 QualType ActualArgType = Arg->getType();
2142 if (ArgType->isPointerType() && ActualArgType->isPointerType()) {
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002143 QualType ActualBaseType =
Fariborz Jahanian745da3a2010-09-24 17:30:16 +00002144 ActualArgType->getAs<PointerType>()->getPointeeType();
Michael J. Spencer9cac4942010-10-19 06:39:39 +00002145 QualType ArgBaseType =
Fariborz Jahanian745da3a2010-09-24 17:30:16 +00002146 ArgType->getAs<PointerType>()->getPointeeType();
2147 if (ArgBaseType->isVariableArrayType()) {
2148 if (const VariableArrayType *VAT =
2149 getContext().getAsVariableArrayType(ActualBaseType)) {
2150 if (!VAT->getSizeExpr())
2151 ActualArgType = ArgType;
2152 }
2153 }
2154 }
Anders Carlssonaf23f692009-04-18 20:20:22 +00002155 assert(getContext().getCanonicalType(ArgType.getNonReferenceType()).
Mike Stump1eb44332009-09-09 15:08:12 +00002156 getTypePtr() ==
Fariborz Jahanian745da3a2010-09-24 17:30:16 +00002157 getContext().getCanonicalType(ActualArgType).getTypePtr() &&
Anders Carlssonaf23f692009-04-18 20:20:22 +00002158 "type mismatch in call argument!");
Fariborz Jahanian745da3a2010-09-24 17:30:16 +00002159#endif
John McCall413ebdb2011-03-11 20:59:21 +00002160 EmitCallArg(Args, *Arg, ArgType);
Anders Carlssonaf23f692009-04-18 20:20:22 +00002161 }
Mike Stump1eb44332009-09-09 15:08:12 +00002162
2163 // Either we've emitted all the call args, or we have a call to a
Anders Carlssonaf23f692009-04-18 20:20:22 +00002164 // variadic function.
Mike Stump1eb44332009-09-09 15:08:12 +00002165 assert((Arg == ArgEnd || CallArgTypeInfo->isVariadic()) &&
Anders Carlssonaf23f692009-04-18 20:20:22 +00002166 "Extra arguments in non-variadic function!");
Mike Stump1eb44332009-09-09 15:08:12 +00002167
Anders Carlssonaf23f692009-04-18 20:20:22 +00002168 }
Mike Stump1eb44332009-09-09 15:08:12 +00002169
Anders Carlssonaf23f692009-04-18 20:20:22 +00002170 // If we still have any arguments, emit them using the type of the argument.
John McCall413ebdb2011-03-11 20:59:21 +00002171 for (; Arg != ArgEnd; ++Arg)
2172 EmitCallArg(Args, *Arg, Arg->getType());
Anders Carlssonaf23f692009-04-18 20:20:22 +00002173 }
John McCall492c4f92010-03-03 04:15:11 +00002174
2175 const TargetCodeGenInfo &getTargetHooks() const {
2176 return CGM.getTargetCodeGenInfo();
2177 }
John McCall744016d2010-07-06 23:57:41 +00002178
2179 void EmitDeclMetadata();
John McCallf0c11f72011-03-31 08:03:29 +00002180
2181 CodeGenModule::ByrefHelpers *
2182 buildByrefHelpers(const llvm::StructType &byrefType,
2183 const AutoVarEmission &emission);
Reid Spencer5f016e22007-07-11 17:01:13 +00002184};
Mike Stump1eb44332009-09-09 15:08:12 +00002185
John McCall150b4622011-01-26 04:00:11 +00002186/// Helper class with most of the code for saving a value for a
2187/// conditional expression cleanup.
John McCall804b8072011-01-28 10:53:53 +00002188struct DominatingLLVMValue {
John McCall150b4622011-01-26 04:00:11 +00002189 typedef llvm::PointerIntPair<llvm::Value*, 1, bool> saved_type;
2190
2191 /// Answer whether the given value needs extra work to be saved.
2192 static bool needsSaving(llvm::Value *value) {
2193 // If it's not an instruction, we don't need to save.
2194 if (!isa<llvm::Instruction>(value)) return false;
2195
2196 // If it's an instruction in the entry block, we don't need to save.
2197 llvm::BasicBlock *block = cast<llvm::Instruction>(value)->getParent();
2198 return (block != &block->getParent()->getEntryBlock());
2199 }
2200
2201 /// Try to save the given value.
2202 static saved_type save(CodeGenFunction &CGF, llvm::Value *value) {
2203 if (!needsSaving(value)) return saved_type(value, false);
2204
2205 // Otherwise we need an alloca.
2206 llvm::Value *alloca =
2207 CGF.CreateTempAlloca(value->getType(), "cond-cleanup.save");
2208 CGF.Builder.CreateStore(value, alloca);
2209
2210 return saved_type(alloca, true);
2211 }
2212
2213 static llvm::Value *restore(CodeGenFunction &CGF, saved_type value) {
2214 if (!value.getInt()) return value.getPointer();
2215 return CGF.Builder.CreateLoad(value.getPointer());
2216 }
2217};
2218
John McCall804b8072011-01-28 10:53:53 +00002219/// A partial specialization of DominatingValue for llvm::Values that
2220/// might be llvm::Instructions.
2221template <class T> struct DominatingPointer<T,true> : DominatingLLVMValue {
2222 typedef T *type;
John McCall150b4622011-01-26 04:00:11 +00002223 static type restore(CodeGenFunction &CGF, saved_type value) {
John McCall804b8072011-01-28 10:53:53 +00002224 return static_cast<T*>(DominatingLLVMValue::restore(CGF, value));
2225 }
2226};
2227
2228/// A specialization of DominatingValue for RValue.
2229template <> struct DominatingValue<RValue> {
2230 typedef RValue type;
2231 class saved_type {
2232 enum Kind { ScalarLiteral, ScalarAddress, AggregateLiteral,
2233 AggregateAddress, ComplexAddress };
2234
2235 llvm::Value *Value;
2236 Kind K;
2237 saved_type(llvm::Value *v, Kind k) : Value(v), K(k) {}
2238
2239 public:
2240 static bool needsSaving(RValue value);
2241 static saved_type save(CodeGenFunction &CGF, RValue value);
2242 RValue restore(CodeGenFunction &CGF);
2243
2244 // implementations in CGExprCXX.cpp
2245 };
2246
2247 static bool needsSaving(type value) {
2248 return saved_type::needsSaving(value);
2249 }
2250 static saved_type save(CodeGenFunction &CGF, type value) {
2251 return saved_type::save(CGF, value);
2252 }
2253 static type restore(CodeGenFunction &CGF, saved_type value) {
2254 return value.restore(CGF);
John McCall150b4622011-01-26 04:00:11 +00002255 }
2256};
2257
Reid Spencer5f016e22007-07-11 17:01:13 +00002258} // end namespace CodeGen
2259} // end namespace clang
2260
2261#endif