blob: 61122666a18fbcf576097acf1c22fff9c11fb63d [file] [log] [blame]
Daniel Dunbar9c426522008-07-29 23:18:29 +00001//===-- CodeGenFunction.h - Per-Function state for LLVM CodeGen -*- C++ -*-===//
Chris Lattnerbed31442007-05-28 01:07:47 +00002//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner5b12ab82007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattnerbed31442007-05-28 01:07:47 +00007//
8//===----------------------------------------------------------------------===//
9//
Mike Stumpfc496822009-02-08 23:14:22 +000010// This is the internal per-function state used for llvm translation.
Chris Lattnerbed31442007-05-28 01:07:47 +000011//
12//===----------------------------------------------------------------------===//
13
Chris Lattnerc18bfbb2008-02-29 17:10:38 +000014#ifndef CLANG_CODEGEN_CODEGENFUNCTION_H
15#define CLANG_CODEGEN_CODEGENFUNCTION_H
Chris Lattnerbed31442007-05-28 01:07:47 +000016
Daniel Dunbarcb463852008-11-01 01:53:16 +000017#include "CGBuilder.h"
Eric Christophera9d34972011-10-19 00:43:52 +000018#include "CGDebugInfo.h"
Daniel Dunbar97db84c2008-08-23 03:46:30 +000019#include "CGValue.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000020#include "CodeGenModule.h"
21#include "clang/AST/CharUnits.h"
22#include "clang/AST/ExprCXX.h"
23#include "clang/AST/ExprObjC.h"
24#include "clang/AST/Type.h"
25#include "clang/Basic/ABI.h"
26#include "clang/Basic/TargetInfo.h"
27#include "clang/Frontend/CodeGenOptions.h"
28#include "llvm/ADT/ArrayRef.h"
29#include "llvm/ADT/DenseMap.h"
30#include "llvm/ADT/SmallVector.h"
31#include "llvm/Support/Debug.h"
32#include "llvm/Support/ValueHandle.h"
Daniel Dunbar97db84c2008-08-23 03:46:30 +000033
Chris Lattnerbed31442007-05-28 01:07:47 +000034namespace llvm {
Daniel Dunbar6e8aa532008-08-11 05:35:13 +000035 class BasicBlock;
Benjamin Kramer9cd050a2009-08-11 17:46:57 +000036 class LLVMContext;
David Chisnall9eecafa2010-05-01 11:15:56 +000037 class MDNode;
Chris Lattnerbed31442007-05-28 01:07:47 +000038 class Module;
Daniel Dunbar2efd5382008-09-30 01:06:03 +000039 class SwitchInst;
Daniel Dunbarb5aacc22009-10-19 01:21:05 +000040 class Twine;
Daniel Dunbar9b1335e2008-11-19 09:36:46 +000041 class Value;
John McCallbd309292010-07-06 01:34:17 +000042 class CallSite;
Chris Lattner23b7eb62007-06-15 23:05:46 +000043}
44
Chris Lattnerbed31442007-05-28 01:07:47 +000045namespace clang {
46 class ASTContext;
John McCall08ef4662011-11-10 08:15:53 +000047 class BlockDecl;
Anders Carlsson0a637412009-05-29 21:03:38 +000048 class CXXDestructorDecl;
Richard Smith02e85f32011-04-14 22:09:26 +000049 class CXXForRangeStmt;
Anders Carlsson52d78a52009-09-27 18:58:34 +000050 class CXXTryStmt;
Chris Lattner84915fa2007-06-02 04:16:21 +000051 class Decl;
Chris Lattnerc8e630e2011-02-17 07:39:24 +000052 class LabelDecl;
Daniel Dunbar6e8aa532008-08-11 05:35:13 +000053 class EnumConstantDecl;
Chris Lattnerbed31442007-05-28 01:07:47 +000054 class FunctionDecl;
Douglas Gregordeaad8c2009-02-26 23:50:07 +000055 class FunctionProtoType;
Daniel Dunbar6e8aa532008-08-11 05:35:13 +000056 class LabelStmt;
Fariborz Jahanian0196a1c2009-01-10 21:06:09 +000057 class ObjCContainerDecl;
Daniel Dunbar1c64e5d2008-09-24 04:00:38 +000058 class ObjCInterfaceDecl;
59 class ObjCIvarDecl;
Chris Lattner4bd55962008-03-30 23:03:07 +000060 class ObjCMethodDecl;
Fariborz Jahanian3d8552a2008-12-09 20:23:04 +000061 class ObjCImplementationDecl;
Daniel Dunbar89654ee2008-08-26 08:29:31 +000062 class ObjCPropertyImplDecl;
Chris Lattner2ccb73b2007-06-16 00:16:26 +000063 class TargetInfo;
John McCalld4f4b7f2010-03-03 04:15:11 +000064 class TargetCodeGenInfo;
Daniel Dunbar6e8aa532008-08-11 05:35:13 +000065 class VarDecl;
Chris Lattnerf0b64d72009-04-26 01:32:48 +000066 class ObjCForCollectionStmt;
67 class ObjCAtTryStmt;
68 class ObjCAtThrowStmt;
69 class ObjCAtSynchronizedStmt;
John McCall31168b02011-06-15 23:02:42 +000070 class ObjCAutoreleasePoolStmt;
Devang Patel3e11cce2007-10-23 02:10:49 +000071
Chris Lattnerbed31442007-05-28 01:07:47 +000072namespace CodeGen {
Devang Patel3e11cce2007-10-23 02:10:49 +000073 class CodeGenTypes;
Daniel Dunbar7633cbf2009-02-02 21:43:58 +000074 class CGFunctionInfo;
Mike Stumpfc496822009-02-08 23:14:22 +000075 class CGRecordLayout;
John McCall9d42f0f2010-05-21 04:11:14 +000076 class CGBlockInfo;
John McCall5d865c322010-08-31 07:33:07 +000077 class CGCXXABI;
John McCallad7c5c12011-02-08 08:22:06 +000078 class BlockFlags;
79 class BlockFieldFlags;
Mike Stumpfc496822009-02-08 23:14:22 +000080
John McCallbd309292010-07-06 01:34:17 +000081/// A branch fixup. These are required when emitting a goto to a
82/// label which hasn't been emitted yet. The goto is optimistically
83/// emitted as a branch to the basic block for the label, and (if it
84/// occurs in a scope with non-trivial cleanups) a fixup is added to
85/// the innermost cleanup. When a (normal) cleanup is popped, any
86/// unresolved fixups in that scope are threaded through the cleanup.
87struct BranchFixup {
John McCallad5d61e2010-07-23 21:56:41 +000088 /// The block containing the terminator which needs to be modified
89 /// into a switch if this fixup is resolved into the current scope.
90 /// If null, LatestBranch points directly to the destination.
91 llvm::BasicBlock *OptimisticBranchBlock;
John McCallbd309292010-07-06 01:34:17 +000092
John McCallad5d61e2010-07-23 21:56:41 +000093 /// The ultimate destination of the branch.
John McCallbd309292010-07-06 01:34:17 +000094 ///
95 /// This can be set to null to indicate that this fixup was
96 /// successfully resolved.
97 llvm::BasicBlock *Destination;
98
John McCallad5d61e2010-07-23 21:56:41 +000099 /// The destination index value.
100 unsigned DestinationIndex;
101
102 /// The initial branch of the fixup.
103 llvm::BranchInst *InitialBranch;
John McCallbd309292010-07-06 01:34:17 +0000104};
105
John McCallcb5f77f2011-01-28 10:53:53 +0000106template <class T> struct InvariantValue {
John McCallce1de612011-01-26 04:00:11 +0000107 typedef T type;
108 typedef T saved_type;
109 static bool needsSaving(type value) { return false; }
110 static saved_type save(CodeGenFunction &CGF, type value) { return value; }
111 static type restore(CodeGenFunction &CGF, saved_type value) { return value; }
112};
John McCallcb5f77f2011-01-28 10:53:53 +0000113
114/// A metaprogramming class for ensuring that a value will dominate an
115/// arbitrary position in a function.
116template <class T> struct DominatingValue : InvariantValue<T> {};
117
118template <class T, bool mightBeInstruction =
119 llvm::is_base_of<llvm::Value, T>::value &&
120 !llvm::is_base_of<llvm::Constant, T>::value &&
121 !llvm::is_base_of<llvm::BasicBlock, T>::value>
122struct DominatingPointer;
123template <class T> struct DominatingPointer<T,false> : InvariantValue<T*> {};
124// template <class T> struct DominatingPointer<T,true> at end of file
125
126template <class T> struct DominatingValue<T*> : DominatingPointer<T> {};
John McCallce1de612011-01-26 04:00:11 +0000127
John McCall612942d2010-08-13 21:20:51 +0000128enum CleanupKind {
129 EHCleanup = 0x1,
130 NormalCleanup = 0x2,
131 NormalAndEHCleanup = EHCleanup | NormalCleanup,
132
133 InactiveCleanup = 0x4,
134 InactiveEHCleanup = EHCleanup | InactiveCleanup,
135 InactiveNormalCleanup = NormalCleanup | InactiveCleanup,
136 InactiveNormalAndEHCleanup = NormalAndEHCleanup | InactiveCleanup
137};
John McCall2b7fc382010-07-13 20:32:21 +0000138
John McCallbd309292010-07-06 01:34:17 +0000139/// A stack of scopes which respond to exceptions, including cleanups
140/// and catch blocks.
141class EHScopeStack {
142public:
143 /// A saved depth on the scope stack. This is necessary because
144 /// pushing scopes onto the stack invalidates iterators.
145 class stable_iterator {
146 friend class EHScopeStack;
147
148 /// Offset from StartOfData to EndOfBuffer.
149 ptrdiff_t Size;
150
151 stable_iterator(ptrdiff_t Size) : Size(Size) {}
152
153 public:
154 static stable_iterator invalid() { return stable_iterator(-1); }
155 stable_iterator() : Size(-1) {}
156
157 bool isValid() const { return Size >= 0; }
158
John McCall324277852010-08-14 07:46:19 +0000159 /// Returns true if this scope encloses I.
160 /// Returns false if I is invalid.
161 /// This scope must be valid.
John McCallad5d61e2010-07-23 21:56:41 +0000162 bool encloses(stable_iterator I) const { return Size <= I.Size; }
John McCall324277852010-08-14 07:46:19 +0000163
164 /// Returns true if this scope strictly encloses I: that is,
165 /// if it encloses I and is not I.
166 /// Returns false is I is invalid.
167 /// This scope must be valid.
John McCallad5d61e2010-07-23 21:56:41 +0000168 bool strictlyEncloses(stable_iterator I) const { return Size < I.Size; }
John McCall8f510412010-07-21 00:40:03 +0000169
John McCallbd309292010-07-06 01:34:17 +0000170 friend bool operator==(stable_iterator A, stable_iterator B) {
171 return A.Size == B.Size;
172 }
173 friend bool operator!=(stable_iterator A, stable_iterator B) {
174 return A.Size != B.Size;
175 }
176 };
177
John McCallcda666c2010-07-21 07:22:38 +0000178 /// Information for lazily generating a cleanup. Subclasses must be
179 /// POD-like: cleanups will not be destructed, and they will be
180 /// allocated on the cleanup stack and freely copied and moved
181 /// around.
John McCall2b7fc382010-07-13 20:32:21 +0000182 ///
John McCallcda666c2010-07-21 07:22:38 +0000183 /// Cleanup implementations should generally be declared in an
John McCall2b7fc382010-07-13 20:32:21 +0000184 /// anonymous namespace.
John McCallcda666c2010-07-21 07:22:38 +0000185 class Cleanup {
John McCall5fcf8da2011-07-12 00:15:30 +0000186 // Anchor the construction vtable.
187 virtual void anchor();
John McCall2b7fc382010-07-13 20:32:21 +0000188 public:
John McCall30317fd2011-07-12 20:27:29 +0000189 /// Generation flags.
190 class Flags {
191 enum {
192 F_IsForEH = 0x1,
193 F_IsNormalCleanupKind = 0x2,
194 F_IsEHCleanupKind = 0x4
195 };
196 unsigned flags;
197
198 public:
199 Flags() : flags(0) {}
200
201 /// isForEH - true if the current emission is for an EH cleanup.
202 bool isForEHCleanup() const { return flags & F_IsForEH; }
203 bool isForNormalCleanup() const { return !isForEHCleanup(); }
204 void setIsForEHCleanup() { flags |= F_IsForEH; }
205
206 bool isNormalCleanupKind() const { return flags & F_IsNormalCleanupKind; }
207 void setIsNormalCleanupKind() { flags |= F_IsNormalCleanupKind; }
208
209 /// isEHCleanupKind - true if the cleanup was pushed as an EH
210 /// cleanup.
211 bool isEHCleanupKind() const { return flags & F_IsEHCleanupKind; }
212 void setIsEHCleanupKind() { flags |= F_IsEHCleanupKind; }
213 };
214
John McCall5fcf8da2011-07-12 00:15:30 +0000215 // Provide a virtual destructor to suppress a very common warning
216 // that unfortunately cannot be suppressed without this. Cleanups
217 // should not rely on this destructor ever being called.
218 virtual ~Cleanup() {}
John McCall11e577b2010-07-13 23:19:49 +0000219
John McCall2b7fc382010-07-13 20:32:21 +0000220 /// Emit the cleanup. For normal cleanups, this is run in the
221 /// same EH context as when the cleanup was pushed, i.e. the
222 /// immediately-enclosing context of the cleanup scope. For
223 /// EH cleanups, this is run in a terminate context.
224 ///
Dmitri Gribenkoadba9be2012-08-23 17:58:28 +0000225 // \param flags cleanup kind.
John McCall30317fd2011-07-12 20:27:29 +0000226 virtual void Emit(CodeGenFunction &CGF, Flags flags) = 0;
John McCall2b7fc382010-07-13 20:32:21 +0000227 };
228
John McCallce1de612011-01-26 04:00:11 +0000229 /// ConditionalCleanupN stores the saved form of its N parameters,
230 /// then restores them and performs the cleanup.
John McCalle4df6c82011-01-28 08:37:24 +0000231 template <class T, class A0>
232 class ConditionalCleanup1 : public Cleanup {
John McCallcb5f77f2011-01-28 10:53:53 +0000233 typedef typename DominatingValue<A0>::saved_type A0_saved;
John McCalle4df6c82011-01-28 08:37:24 +0000234 A0_saved a0_saved;
235
John McCall30317fd2011-07-12 20:27:29 +0000236 void Emit(CodeGenFunction &CGF, Flags flags) {
John McCallcb5f77f2011-01-28 10:53:53 +0000237 A0 a0 = DominatingValue<A0>::restore(CGF, a0_saved);
John McCall30317fd2011-07-12 20:27:29 +0000238 T(a0).Emit(CGF, flags);
John McCalle4df6c82011-01-28 08:37:24 +0000239 }
240
241 public:
242 ConditionalCleanup1(A0_saved a0)
243 : a0_saved(a0) {}
244 };
245
John McCallce1de612011-01-26 04:00:11 +0000246 template <class T, class A0, class A1>
John McCalle4df6c82011-01-28 08:37:24 +0000247 class ConditionalCleanup2 : public Cleanup {
John McCallcb5f77f2011-01-28 10:53:53 +0000248 typedef typename DominatingValue<A0>::saved_type A0_saved;
249 typedef typename DominatingValue<A1>::saved_type A1_saved;
John McCallf256eb52011-01-26 19:15:39 +0000250 A0_saved a0_saved;
251 A1_saved a1_saved;
John McCallce1de612011-01-26 04:00:11 +0000252
John McCall30317fd2011-07-12 20:27:29 +0000253 void Emit(CodeGenFunction &CGF, Flags flags) {
John McCallcb5f77f2011-01-28 10:53:53 +0000254 A0 a0 = DominatingValue<A0>::restore(CGF, a0_saved);
255 A1 a1 = DominatingValue<A1>::restore(CGF, a1_saved);
John McCall30317fd2011-07-12 20:27:29 +0000256 T(a0, a1).Emit(CGF, flags);
John McCallce1de612011-01-26 04:00:11 +0000257 }
258
259 public:
John McCalle4df6c82011-01-28 08:37:24 +0000260 ConditionalCleanup2(A0_saved a0, A1_saved a1)
261 : a0_saved(a0), a1_saved(a1) {}
John McCallce1de612011-01-26 04:00:11 +0000262 };
263
Douglas Gregor58df5092011-06-22 16:12:01 +0000264 template <class T, class A0, class A1, class A2>
265 class ConditionalCleanup3 : public Cleanup {
266 typedef typename DominatingValue<A0>::saved_type A0_saved;
267 typedef typename DominatingValue<A1>::saved_type A1_saved;
268 typedef typename DominatingValue<A2>::saved_type A2_saved;
269 A0_saved a0_saved;
270 A1_saved a1_saved;
271 A2_saved a2_saved;
272
John McCall30317fd2011-07-12 20:27:29 +0000273 void Emit(CodeGenFunction &CGF, Flags flags) {
Douglas Gregor58df5092011-06-22 16:12:01 +0000274 A0 a0 = DominatingValue<A0>::restore(CGF, a0_saved);
275 A1 a1 = DominatingValue<A1>::restore(CGF, a1_saved);
276 A2 a2 = DominatingValue<A2>::restore(CGF, a2_saved);
John McCall30317fd2011-07-12 20:27:29 +0000277 T(a0, a1, a2).Emit(CGF, flags);
Douglas Gregor58df5092011-06-22 16:12:01 +0000278 }
279
280 public:
281 ConditionalCleanup3(A0_saved a0, A1_saved a1, A2_saved a2)
John McCall5fcf8da2011-07-12 00:15:30 +0000282 : a0_saved(a0), a1_saved(a1), a2_saved(a2) {}
Douglas Gregor58df5092011-06-22 16:12:01 +0000283 };
284
John McCall4bd0fb12011-07-12 16:41:08 +0000285 template <class T, class A0, class A1, class A2, class A3>
286 class ConditionalCleanup4 : public Cleanup {
287 typedef typename DominatingValue<A0>::saved_type A0_saved;
288 typedef typename DominatingValue<A1>::saved_type A1_saved;
289 typedef typename DominatingValue<A2>::saved_type A2_saved;
290 typedef typename DominatingValue<A3>::saved_type A3_saved;
291 A0_saved a0_saved;
292 A1_saved a1_saved;
293 A2_saved a2_saved;
294 A3_saved a3_saved;
295
John McCall30317fd2011-07-12 20:27:29 +0000296 void Emit(CodeGenFunction &CGF, Flags flags) {
John McCall4bd0fb12011-07-12 16:41:08 +0000297 A0 a0 = DominatingValue<A0>::restore(CGF, a0_saved);
298 A1 a1 = DominatingValue<A1>::restore(CGF, a1_saved);
299 A2 a2 = DominatingValue<A2>::restore(CGF, a2_saved);
300 A3 a3 = DominatingValue<A3>::restore(CGF, a3_saved);
John McCall30317fd2011-07-12 20:27:29 +0000301 T(a0, a1, a2, a3).Emit(CGF, flags);
John McCall4bd0fb12011-07-12 16:41:08 +0000302 }
303
304 public:
305 ConditionalCleanup4(A0_saved a0, A1_saved a1, A2_saved a2, A3_saved a3)
306 : a0_saved(a0), a1_saved(a1), a2_saved(a2), a3_saved(a3) {}
307 };
308
John McCallbd309292010-07-06 01:34:17 +0000309private:
310 // The implementation for this class is in CGException.h and
311 // CGException.cpp; the definition is here because it's used as a
312 // member of CodeGenFunction.
313
314 /// The start of the scope-stack buffer, i.e. the allocated pointer
315 /// for the buffer. All of these pointers are either simultaneously
316 /// null or simultaneously valid.
317 char *StartOfBuffer;
318
319 /// The end of the buffer.
320 char *EndOfBuffer;
321
322 /// The first valid entry in the buffer.
323 char *StartOfData;
324
325 /// The innermost normal cleanup on the stack.
326 stable_iterator InnermostNormalCleanup;
327
John McCall8e4c74b2011-08-11 02:22:43 +0000328 /// The innermost EH scope on the stack.
329 stable_iterator InnermostEHScope;
John McCallad5d61e2010-07-23 21:56:41 +0000330
John McCallbd309292010-07-06 01:34:17 +0000331 /// The current set of branch fixups. A branch fixup is a jump to
332 /// an as-yet unemitted label, i.e. a label for which we don't yet
333 /// know the EH stack depth. Whenever we pop a cleanup, we have
334 /// to thread all the current branch fixups through it.
335 ///
336 /// Fixups are recorded as the Use of the respective branch or
337 /// switch statement. The use points to the final destination.
338 /// When popping out of a cleanup, these uses are threaded through
339 /// the cleanup and adjusted to point to the new cleanup.
340 ///
341 /// Note that branches are allowed to jump into protected scopes
342 /// in certain situations; e.g. the following code is legal:
343 /// struct A { ~A(); }; // trivial ctor, non-trivial dtor
344 /// goto foo;
345 /// A a;
346 /// foo:
347 /// bar();
Chris Lattner01cf8db2011-07-20 06:58:45 +0000348 SmallVector<BranchFixup, 8> BranchFixups;
John McCallbd309292010-07-06 01:34:17 +0000349
350 char *allocate(size_t Size);
351
John McCallcda666c2010-07-21 07:22:38 +0000352 void *pushCleanup(CleanupKind K, size_t DataSize);
John McCall2b7fc382010-07-13 20:32:21 +0000353
John McCallbd309292010-07-06 01:34:17 +0000354public:
355 EHScopeStack() : StartOfBuffer(0), EndOfBuffer(0), StartOfData(0),
356 InnermostNormalCleanup(stable_end()),
John McCall8e4c74b2011-08-11 02:22:43 +0000357 InnermostEHScope(stable_end()) {}
John McCallbd309292010-07-06 01:34:17 +0000358 ~EHScopeStack() { delete[] StartOfBuffer; }
359
John McCall2b7fc382010-07-13 20:32:21 +0000360 // Variadic templates would make this not terrible.
361
362 /// Push a lazily-created cleanup on the stack.
John McCall5c08ab92010-07-13 22:12:14 +0000363 template <class T>
John McCallcda666c2010-07-21 07:22:38 +0000364 void pushCleanup(CleanupKind Kind) {
365 void *Buffer = pushCleanup(Kind, sizeof(T));
366 Cleanup *Obj = new(Buffer) T();
John McCall5c08ab92010-07-13 22:12:14 +0000367 (void) Obj;
368 }
369
370 /// Push a lazily-created cleanup on the stack.
371 template <class T, class A0>
John McCallcda666c2010-07-21 07:22:38 +0000372 void pushCleanup(CleanupKind Kind, A0 a0) {
373 void *Buffer = pushCleanup(Kind, sizeof(T));
374 Cleanup *Obj = new(Buffer) T(a0);
John McCall5c08ab92010-07-13 22:12:14 +0000375 (void) Obj;
376 }
377
378 /// Push a lazily-created cleanup on the stack.
John McCall2b7fc382010-07-13 20:32:21 +0000379 template <class T, class A0, class A1>
John McCallcda666c2010-07-21 07:22:38 +0000380 void pushCleanup(CleanupKind Kind, A0 a0, A1 a1) {
381 void *Buffer = pushCleanup(Kind, sizeof(T));
382 Cleanup *Obj = new(Buffer) T(a0, a1);
John McCall2b7fc382010-07-13 20:32:21 +0000383 (void) Obj;
384 }
385
386 /// Push a lazily-created cleanup on the stack.
387 template <class T, class A0, class A1, class A2>
John McCallcda666c2010-07-21 07:22:38 +0000388 void pushCleanup(CleanupKind Kind, A0 a0, A1 a1, A2 a2) {
389 void *Buffer = pushCleanup(Kind, sizeof(T));
390 Cleanup *Obj = new(Buffer) T(a0, a1, a2);
John McCall2b7fc382010-07-13 20:32:21 +0000391 (void) Obj;
392 }
393
394 /// Push a lazily-created cleanup on the stack.
395 template <class T, class A0, class A1, class A2, class A3>
John McCallcda666c2010-07-21 07:22:38 +0000396 void pushCleanup(CleanupKind Kind, A0 a0, A1 a1, A2 a2, A3 a3) {
397 void *Buffer = pushCleanup(Kind, sizeof(T));
398 Cleanup *Obj = new(Buffer) T(a0, a1, a2, a3);
John McCall2b7fc382010-07-13 20:32:21 +0000399 (void) Obj;
400 }
401
John McCall906da4b2010-07-21 05:47:49 +0000402 /// Push a lazily-created cleanup on the stack.
403 template <class T, class A0, class A1, class A2, class A3, class A4>
John McCallcda666c2010-07-21 07:22:38 +0000404 void pushCleanup(CleanupKind Kind, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
405 void *Buffer = pushCleanup(Kind, sizeof(T));
406 Cleanup *Obj = new(Buffer) T(a0, a1, a2, a3, a4);
John McCall906da4b2010-07-21 05:47:49 +0000407 (void) Obj;
408 }
409
John McCall824c2f52010-09-14 07:57:04 +0000410 // Feel free to add more variants of the following:
411
412 /// Push a cleanup with non-constant storage requirements on the
413 /// stack. The cleanup type must provide an additional static method:
414 /// static size_t getExtraSize(size_t);
415 /// The argument to this method will be the value N, which will also
416 /// be passed as the first argument to the constructor.
417 ///
418 /// The data stored in the extra storage must obey the same
419 /// restrictions as normal cleanup member data.
420 ///
421 /// The pointer returned from this method is valid until the cleanup
422 /// stack is modified.
423 template <class T, class A0, class A1, class A2>
424 T *pushCleanupWithExtra(CleanupKind Kind, size_t N, A0 a0, A1 a1, A2 a2) {
425 void *Buffer = pushCleanup(Kind, sizeof(T) + T::getExtraSize(N));
426 return new (Buffer) T(N, a0, a1, a2);
427 }
428
John McCall8e4c74b2011-08-11 02:22:43 +0000429 /// Pops a cleanup scope off the stack. This is private to CGCleanup.cpp.
John McCallbd309292010-07-06 01:34:17 +0000430 void popCleanup();
431
432 /// Push a set of catch handlers on the stack. The catch is
433 /// uninitialized and will need to have the given number of handlers
434 /// set on it.
435 class EHCatchScope *pushCatch(unsigned NumHandlers);
436
John McCall8e4c74b2011-08-11 02:22:43 +0000437 /// Pops a catch scope off the stack. This is private to CGException.cpp.
John McCallbd309292010-07-06 01:34:17 +0000438 void popCatch();
439
440 /// Push an exceptions filter on the stack.
441 class EHFilterScope *pushFilter(unsigned NumFilters);
442
443 /// Pops an exceptions filter off the stack.
444 void popFilter();
445
446 /// Push a terminate handler on the stack.
447 void pushTerminate();
448
449 /// Pops a terminate handler off the stack.
450 void popTerminate();
451
452 /// Determines whether the exception-scopes stack is empty.
453 bool empty() const { return StartOfData == EndOfBuffer; }
454
455 bool requiresLandingPad() const {
John McCall8e4c74b2011-08-11 02:22:43 +0000456 return InnermostEHScope != stable_end();
John McCallbd309292010-07-06 01:34:17 +0000457 }
458
459 /// Determines whether there are any normal cleanups on the stack.
460 bool hasNormalCleanups() const {
461 return InnermostNormalCleanup != stable_end();
462 }
463
464 /// Returns the innermost normal cleanup on the stack, or
465 /// stable_end() if there are no normal cleanups.
466 stable_iterator getInnermostNormalCleanup() const {
467 return InnermostNormalCleanup;
468 }
John McCall8e4c74b2011-08-11 02:22:43 +0000469 stable_iterator getInnermostActiveNormalCleanup() const;
John McCallbd309292010-07-06 01:34:17 +0000470
John McCall8e4c74b2011-08-11 02:22:43 +0000471 stable_iterator getInnermostEHScope() const {
472 return InnermostEHScope;
John McCallbd309292010-07-06 01:34:17 +0000473 }
474
John McCall8e4c74b2011-08-11 02:22:43 +0000475 stable_iterator getInnermostActiveEHScope() const;
John McCallbd309292010-07-06 01:34:17 +0000476
477 /// An unstable reference to a scope-stack depth. Invalidated by
478 /// pushes but not pops.
479 class iterator;
480
481 /// Returns an iterator pointing to the innermost EH scope.
482 iterator begin() const;
483
484 /// Returns an iterator pointing to the outermost EH scope.
485 iterator end() const;
486
487 /// Create a stable reference to the top of the EH stack. The
488 /// returned reference is valid until that scope is popped off the
489 /// stack.
490 stable_iterator stable_begin() const {
491 return stable_iterator(EndOfBuffer - StartOfData);
492 }
493
494 /// Create a stable reference to the bottom of the EH stack.
495 static stable_iterator stable_end() {
496 return stable_iterator(0);
497 }
498
499 /// Translates an iterator into a stable_iterator.
500 stable_iterator stabilize(iterator it) const;
501
John McCallbd309292010-07-06 01:34:17 +0000502 /// Turn a stable reference to a scope depth into a unstable pointer
503 /// to the EH stack.
504 iterator find(stable_iterator save) const;
505
506 /// Removes the cleanup pointed to by the given stable_iterator.
507 void removeCleanup(stable_iterator save);
508
509 /// Add a branch fixup to the current cleanup scope.
510 BranchFixup &addBranchFixup() {
511 assert(hasNormalCleanups() && "adding fixup in scope without cleanups");
512 BranchFixups.push_back(BranchFixup());
513 return BranchFixups.back();
514 }
515
516 unsigned getNumBranchFixups() const { return BranchFixups.size(); }
517 BranchFixup &getBranchFixup(unsigned I) {
518 assert(I < getNumBranchFixups());
519 return BranchFixups[I];
520 }
521
John McCallad5d61e2010-07-23 21:56:41 +0000522 /// Pops lazily-removed fixups from the end of the list. This
523 /// should only be called by procedures which have just popped a
524 /// cleanup or resolved one or more fixups.
525 void popNullFixups();
526
527 /// Clears the branch-fixups list. This should only be called by
John McCallf09d96f2010-09-18 02:24:39 +0000528 /// ResolveAllBranchFixups.
John McCallad5d61e2010-07-23 21:56:41 +0000529 void clearFixups() { BranchFixups.clear(); }
John McCallbd309292010-07-06 01:34:17 +0000530};
531
Chris Lattnerbed31442007-05-28 01:07:47 +0000532/// CodeGenFunction - This class organizes the per-function state that is used
533/// while generating LLVM code.
John McCalle3dc1702011-02-15 09:22:45 +0000534class CodeGenFunction : public CodeGenTypeCache {
Dmitri Gribenkoa664e5b2012-09-15 20:20:27 +0000535 CodeGenFunction(const CodeGenFunction &) LLVM_DELETED_FUNCTION;
536 void operator=(const CodeGenFunction &) LLVM_DELETED_FUNCTION;
John McCall5d865c322010-08-31 07:33:07 +0000537
538 friend class CGCXXABI;
Chris Lattnerbda69f82007-08-26 23:13:56 +0000539public:
John McCallad5d61e2010-07-23 21:56:41 +0000540 /// A jump destination is an abstract label, branching to which may
541 /// require a jump out through normal cleanups.
John McCallbd309292010-07-06 01:34:17 +0000542 struct JumpDest {
John McCallad5d61e2010-07-23 21:56:41 +0000543 JumpDest() : Block(0), ScopeDepth(), Index(0) {}
544 JumpDest(llvm::BasicBlock *Block,
545 EHScopeStack::stable_iterator Depth,
546 unsigned Index)
547 : Block(Block), ScopeDepth(Depth), Index(Index) {}
548
549 bool isValid() const { return Block != 0; }
550 llvm::BasicBlock *getBlock() const { return Block; }
551 EHScopeStack::stable_iterator getScopeDepth() const { return ScopeDepth; }
552 unsigned getDestIndex() const { return Index; }
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +0000553
John McCallad5d61e2010-07-23 21:56:41 +0000554 private:
John McCallbd309292010-07-06 01:34:17 +0000555 llvm::BasicBlock *Block;
556 EHScopeStack::stable_iterator ScopeDepth;
John McCallad5d61e2010-07-23 21:56:41 +0000557 unsigned Index;
558 };
559
Chris Lattnerbed31442007-05-28 01:07:47 +0000560 CodeGenModule &CGM; // Per-module state.
Daniel Dunbar1b444192009-11-13 05:51:54 +0000561 const TargetInfo &Target;
Mike Stumpfc496822009-02-08 23:14:22 +0000562
Chris Lattner96d72562007-08-21 16:57:55 +0000563 typedef std::pair<llvm::Value *, llvm::Value *> ComplexPairTy;
Daniel Dunbarcb463852008-11-01 01:53:16 +0000564 CGBuilderTy Builder;
Mike Stumpfc496822009-02-08 23:14:22 +0000565
Chris Lattner28ec0cf2009-04-23 05:30:27 +0000566 /// CurFuncDecl - Holds the Decl for the current function or ObjC method.
567 /// This excludes BlockDecls.
Chris Lattner5696e7b2008-06-17 18:05:57 +0000568 const Decl *CurFuncDecl;
Chris Lattner28ec0cf2009-04-23 05:30:27 +0000569 /// CurCodeDecl - This is the inner-most code context, which includes blocks.
570 const Decl *CurCodeDecl;
Daniel Dunbard931a872009-02-02 22:03:45 +0000571 const CGFunctionInfo *CurFnInfo;
Chris Lattner4bd55962008-03-30 23:03:07 +0000572 QualType FnRetTy;
Chris Lattnerac248202007-05-30 00:13:02 +0000573 llvm::Function *CurFn;
574
Mike Stumpbee78dd2009-12-04 23:26:17 +0000575 /// CurGD - The GlobalDecl for the current function being compiled.
576 GlobalDecl CurGD;
Mike Stumpbee78dd2009-12-04 23:26:17 +0000577
John McCall31168b02011-06-15 23:02:42 +0000578 /// PrologueCleanupDepth - The cleanup depth enclosing all the
579 /// cleanups associated with the parameters.
580 EHScopeStack::stable_iterator PrologueCleanupDepth;
581
Daniel Dunbar54bb1932008-09-09 21:00:17 +0000582 /// ReturnBlock - Unified return block.
John McCallbd309292010-07-06 01:34:17 +0000583 JumpDest ReturnBlock;
584
Mike Stumpfc496822009-02-08 23:14:22 +0000585 /// ReturnValue - The temporary alloca to hold the return value. This is null
Sylvestre Ledru33b5baf2012-09-27 10:16:10 +0000586 /// iff the function has no return value.
Eli Friedman4b1942c2009-12-04 02:43:40 +0000587 llvm::Value *ReturnValue;
Mike Stumpfc496822009-02-08 23:14:22 +0000588
Chris Lattner03df1222007-06-02 04:53:11 +0000589 /// AllocaInsertPoint - This is an instruction in the entry block before which
590 /// we prefer to insert allocas.
Chris Lattner2739d2b2009-03-31 22:17:44 +0000591 llvm::AssertingVH<llvm::Instruction> AllocaInsertPt;
Daniel Dunbar88402ce2008-08-04 16:51:22 +0000592
Nuno Lopes3d6311d2012-05-08 22:10:46 +0000593 /// BoundsChecking - Emit run-time bounds checks. Higher values mean
594 /// potentially higher performance penalties.
595 unsigned char BoundsChecking;
596
Richard Smithb1b0ab42012-11-05 22:21:05 +0000597 /// \brief Whether any type-checking sanitizers are enabled. If \c false,
598 /// calls to EmitTypeCheck can be skipped.
599 bool SanitizePerformTypeCheck;
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +0000600
John McCall31168b02011-06-15 23:02:42 +0000601 /// In ARC, whether we should autorelease the return value.
602 bool AutoreleaseResult;
603
John McCallad7c5c12011-02-08 08:22:06 +0000604 const CodeGen::CGBlockInfo *BlockInfo;
605 llvm::Value *BlockPointer;
606
Eli Friedman9fbeba02012-02-11 02:57:39 +0000607 llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields;
608 FieldDecl *LambdaThisCaptureField;
609
Douglas Gregor9154b5d2010-05-17 15:52:46 +0000610 /// \brief A mapping from NRVO variables to the flags used to indicate
611 /// when the NRVO has been applied to this variable.
612 llvm::DenseMap<const VarDecl *, llvm::Value *> NRVOFlags;
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +0000613
John McCallbd309292010-07-06 01:34:17 +0000614 EHScopeStack EHStack;
615
John McCallad5d61e2010-07-23 21:56:41 +0000616 /// i32s containing the indexes of the cleanup destinations.
617 llvm::AllocaInst *NormalCleanupDest;
John McCallad5d61e2010-07-23 21:56:41 +0000618
619 unsigned NextCleanupDestIndex;
620
John McCall08ef4662011-11-10 08:15:53 +0000621 /// FirstBlockInfo - The head of a singly-linked-list of block layouts.
622 CGBlockInfo *FirstBlockInfo;
623
John McCall8e4c74b2011-08-11 02:22:43 +0000624 /// EHResumeBlock - Unified block containing a call to llvm.eh.resume.
625 llvm::BasicBlock *EHResumeBlock;
626
Bill Wendlingf0724e82011-09-19 20:31:14 +0000627 /// The exception slot. All landing pads write the current exception pointer
628 /// into this alloca.
John McCallbd309292010-07-06 01:34:17 +0000629 llvm::Value *ExceptionSlot;
630
Bill Wendlingf0724e82011-09-19 20:31:14 +0000631 /// The selector slot. Under the MandatoryCleanup model, all landing pads
632 /// write the current selector value into this alloca.
John McCall9b382dd2011-05-28 21:13:02 +0000633 llvm::AllocaInst *EHSelectorSlot;
634
John McCallbd309292010-07-06 01:34:17 +0000635 /// Emits a landing pad for the current EH stack.
636 llvm::BasicBlock *EmitLandingPad();
637
638 llvm::BasicBlock *getInvokeDestImpl();
639
John McCallce1de612011-01-26 04:00:11 +0000640 template <class T>
John McCallcb5f77f2011-01-28 10:53:53 +0000641 typename DominatingValue<T>::saved_type saveValueInCond(T value) {
642 return DominatingValue<T>::save(*this, value);
John McCallce1de612011-01-26 04:00:11 +0000643 }
644
Daniel Dunbard3dcb4f82008-09-28 01:03:14 +0000645public:
Anders Carlsson33c1b652009-02-10 06:07:49 +0000646 /// ObjCEHValueStack - Stack of Objective-C exception values, used for
647 /// rethrows.
Chris Lattner01cf8db2011-07-20 06:58:45 +0000648 SmallVector<llvm::Value*, 8> ObjCEHValueStack;
Mike Stumpfc496822009-02-08 23:14:22 +0000649
John McCall6b0feb72011-06-22 02:32:12 +0000650 /// A class controlling the emission of a finally block.
651 class FinallyInfo {
652 /// Where the catchall's edge through the cleanup should go.
653 JumpDest RethrowDest;
Anders Carlsson66c384a2009-02-08 07:46:24 +0000654
John McCall6b0feb72011-06-22 02:32:12 +0000655 /// A function to call to enter the catch.
656 llvm::Constant *BeginCatchFn;
657
658 /// An i1 variable indicating whether or not the @finally is
659 /// running for an exception.
660 llvm::AllocaInst *ForEHVar;
661
662 /// An i8* variable into which the exception pointer to rethrow
663 /// has been saved.
664 llvm::AllocaInst *SavedExnVar;
665
666 public:
667 void enter(CodeGenFunction &CGF, const Stmt *Finally,
668 llvm::Constant *beginCatchFn, llvm::Constant *endCatchFn,
669 llvm::Constant *rethrowFn);
670 void exit(CodeGenFunction &CGF);
671 };
Mike Stumpaff69af2009-12-09 03:35:49 +0000672
John McCallce1de612011-01-26 04:00:11 +0000673 /// pushFullExprCleanup - Push a cleanup to be run at the end of the
674 /// current full-expression. Safe against the possibility that
675 /// we're currently inside a conditionally-evaluated expression.
John McCalle4df6c82011-01-28 08:37:24 +0000676 template <class T, class A0>
677 void pushFullExprCleanup(CleanupKind kind, A0 a0) {
678 // If we're not in a conditional branch, or if none of the
679 // arguments requires saving, then use the unconditional cleanup.
John McCall5fcf8da2011-07-12 00:15:30 +0000680 if (!isInConditionalBranch())
681 return EHStack.pushCleanup<T>(kind, a0);
John McCalle4df6c82011-01-28 08:37:24 +0000682
John McCallcb5f77f2011-01-28 10:53:53 +0000683 typename DominatingValue<A0>::saved_type a0_saved = saveValueInCond(a0);
John McCalle4df6c82011-01-28 08:37:24 +0000684
685 typedef EHScopeStack::ConditionalCleanup1<T, A0> CleanupType;
686 EHStack.pushCleanup<CleanupType>(kind, a0_saved);
687 initFullExprCleanup();
688 }
689
690 /// pushFullExprCleanup - Push a cleanup to be run at the end of the
691 /// current full-expression. Safe against the possibility that
692 /// we're currently inside a conditionally-evaluated expression.
John McCallce1de612011-01-26 04:00:11 +0000693 template <class T, class A0, class A1>
694 void pushFullExprCleanup(CleanupKind kind, A0 a0, A1 a1) {
695 // If we're not in a conditional branch, or if none of the
696 // arguments requires saving, then use the unconditional cleanup.
John McCall5fcf8da2011-07-12 00:15:30 +0000697 if (!isInConditionalBranch())
698 return EHStack.pushCleanup<T>(kind, a0, a1);
John McCallce1de612011-01-26 04:00:11 +0000699
John McCallcb5f77f2011-01-28 10:53:53 +0000700 typename DominatingValue<A0>::saved_type a0_saved = saveValueInCond(a0);
701 typename DominatingValue<A1>::saved_type a1_saved = saveValueInCond(a1);
John McCallce1de612011-01-26 04:00:11 +0000702
703 typedef EHScopeStack::ConditionalCleanup2<T, A0, A1> CleanupType;
John McCalle4df6c82011-01-28 08:37:24 +0000704 EHStack.pushCleanup<CleanupType>(kind, a0_saved, a1_saved);
705 initFullExprCleanup();
John McCallce1de612011-01-26 04:00:11 +0000706 }
707
Douglas Gregor58df5092011-06-22 16:12:01 +0000708 /// pushFullExprCleanup - Push a cleanup to be run at the end of the
709 /// current full-expression. Safe against the possibility that
710 /// we're currently inside a conditionally-evaluated expression.
711 template <class T, class A0, class A1, class A2>
712 void pushFullExprCleanup(CleanupKind kind, A0 a0, A1 a1, A2 a2) {
713 // If we're not in a conditional branch, or if none of the
714 // arguments requires saving, then use the unconditional cleanup.
715 if (!isInConditionalBranch()) {
John McCall5fcf8da2011-07-12 00:15:30 +0000716 return EHStack.pushCleanup<T>(kind, a0, a1, a2);
Douglas Gregor58df5092011-06-22 16:12:01 +0000717 }
718
719 typename DominatingValue<A0>::saved_type a0_saved = saveValueInCond(a0);
720 typename DominatingValue<A1>::saved_type a1_saved = saveValueInCond(a1);
721 typename DominatingValue<A2>::saved_type a2_saved = saveValueInCond(a2);
722
723 typedef EHScopeStack::ConditionalCleanup3<T, A0, A1, A2> CleanupType;
724 EHStack.pushCleanup<CleanupType>(kind, a0_saved, a1_saved, a2_saved);
725 initFullExprCleanup();
726 }
727
John McCall4bd0fb12011-07-12 16:41:08 +0000728 /// pushFullExprCleanup - Push a cleanup to be run at the end of the
729 /// current full-expression. Safe against the possibility that
730 /// we're currently inside a conditionally-evaluated expression.
731 template <class T, class A0, class A1, class A2, class A3>
732 void pushFullExprCleanup(CleanupKind kind, A0 a0, A1 a1, A2 a2, A3 a3) {
733 // If we're not in a conditional branch, or if none of the
734 // arguments requires saving, then use the unconditional cleanup.
735 if (!isInConditionalBranch()) {
736 return EHStack.pushCleanup<T>(kind, a0, a1, a2, a3);
737 }
738
739 typename DominatingValue<A0>::saved_type a0_saved = saveValueInCond(a0);
740 typename DominatingValue<A1>::saved_type a1_saved = saveValueInCond(a1);
741 typename DominatingValue<A2>::saved_type a2_saved = saveValueInCond(a2);
742 typename DominatingValue<A3>::saved_type a3_saved = saveValueInCond(a3);
743
744 typedef EHScopeStack::ConditionalCleanup4<T, A0, A1, A2, A3> CleanupType;
745 EHStack.pushCleanup<CleanupType>(kind, a0_saved, a1_saved,
746 a2_saved, a3_saved);
747 initFullExprCleanup();
748 }
749
John McCallf4beacd2011-11-10 10:43:54 +0000750 /// Set up the last cleaup that was pushed as a conditional
751 /// full-expression cleanup.
752 void initFullExprCleanup();
753
John McCallbd309292010-07-06 01:34:17 +0000754 /// PushDestructorCleanup - Push a cleanup to call the
755 /// complete-object destructor of an object of the given type at the
756 /// given address. Does nothing if T is not a C++ class type with a
757 /// non-trivial destructor.
758 void PushDestructorCleanup(QualType T, llvm::Value *Addr);
759
John McCall8680f872010-07-21 06:29:51 +0000760 /// PushDestructorCleanup - Push a cleanup to call the
761 /// complete-object variant of the given destructor on the object at
762 /// the given address.
763 void PushDestructorCleanup(const CXXDestructorDecl *Dtor,
764 llvm::Value *Addr);
765
John McCallbd309292010-07-06 01:34:17 +0000766 /// PopCleanupBlock - Will pop the cleanup entry on the stack and
767 /// process all branch fixups.
John McCallad5d61e2010-07-23 21:56:41 +0000768 void PopCleanupBlock(bool FallThroughIsBranchThrough = false);
John McCallbd309292010-07-06 01:34:17 +0000769
John McCall824c2f52010-09-14 07:57:04 +0000770 /// DeactivateCleanupBlock - Deactivates the given cleanup block.
771 /// The block cannot be reactivated. Pops it if it's the top of the
772 /// stack.
John McCallf4beacd2011-11-10 10:43:54 +0000773 ///
774 /// \param DominatingIP - An instruction which is known to
775 /// dominate the current IP (if set) and which lies along
776 /// all paths of execution between the current IP and the
777 /// the point at which the cleanup comes into scope.
778 void DeactivateCleanupBlock(EHScopeStack::stable_iterator Cleanup,
779 llvm::Instruction *DominatingIP);
John McCall824c2f52010-09-14 07:57:04 +0000780
781 /// ActivateCleanupBlock - Activates an initially-inactive cleanup.
782 /// Cannot be used to resurrect a deactivated cleanup.
John McCallf4beacd2011-11-10 10:43:54 +0000783 ///
784 /// \param DominatingIP - An instruction which is known to
785 /// dominate the current IP (if set) and which lies along
786 /// all paths of execution between the current IP and the
787 /// the point at which the cleanup comes into scope.
788 void ActivateCleanupBlock(EHScopeStack::stable_iterator Cleanup,
789 llvm::Instruction *DominatingIP);
John McCall612942d2010-08-13 21:20:51 +0000790
John McCallbd309292010-07-06 01:34:17 +0000791 /// \brief Enters a new scope for capturing cleanups, all of which
792 /// will be executed once the scope is exited.
793 class RunCleanupsScope {
John McCallbd309292010-07-06 01:34:17 +0000794 EHScopeStack::stable_iterator CleanupStackDepth;
Douglas Gregor965f4502009-11-24 16:43:22 +0000795 bool OldDidCallStackSave;
Douglas Gregor680f8612009-11-24 21:15:44 +0000796 bool PerformCleanup;
Douglas Gregor965f4502009-11-24 16:43:22 +0000797
Dmitri Gribenkoa664e5b2012-09-15 20:20:27 +0000798 RunCleanupsScope(const RunCleanupsScope &) LLVM_DELETED_FUNCTION;
799 void operator=(const RunCleanupsScope &) LLVM_DELETED_FUNCTION;
Douglas Gregor965f4502009-11-24 16:43:22 +0000800
Eric Christophera9d34972011-10-19 00:43:52 +0000801 protected:
802 CodeGenFunction& CGF;
803
Douglas Gregor965f4502009-11-24 16:43:22 +0000804 public:
805 /// \brief Enter a new cleanup scope.
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +0000806 explicit RunCleanupsScope(CodeGenFunction &CGF)
Eric Christophera9d34972011-10-19 00:43:52 +0000807 : PerformCleanup(true), CGF(CGF)
Douglas Gregor680f8612009-11-24 21:15:44 +0000808 {
John McCallbd309292010-07-06 01:34:17 +0000809 CleanupStackDepth = CGF.EHStack.stable_begin();
Douglas Gregor965f4502009-11-24 16:43:22 +0000810 OldDidCallStackSave = CGF.DidCallStackSave;
Argyrios Kyrtzidis9efa1ce2010-09-14 00:42:34 +0000811 CGF.DidCallStackSave = false;
Douglas Gregor965f4502009-11-24 16:43:22 +0000812 }
813
814 /// \brief Exit this cleanup scope, emitting any accumulated
815 /// cleanups.
John McCallbd309292010-07-06 01:34:17 +0000816 ~RunCleanupsScope() {
Douglas Gregor680f8612009-11-24 21:15:44 +0000817 if (PerformCleanup) {
818 CGF.DidCallStackSave = OldDidCallStackSave;
John McCallbd309292010-07-06 01:34:17 +0000819 CGF.PopCleanupBlocks(CleanupStackDepth);
Douglas Gregor680f8612009-11-24 21:15:44 +0000820 }
821 }
822
823 /// \brief Determine whether this scope requires any cleanups.
824 bool requiresCleanups() const {
John McCallbd309292010-07-06 01:34:17 +0000825 return CGF.EHStack.stable_begin() != CleanupStackDepth;
Douglas Gregor680f8612009-11-24 21:15:44 +0000826 }
827
828 /// \brief Force the emission of cleanups now, instead of waiting
829 /// until this object is destroyed.
830 void ForceCleanup() {
831 assert(PerformCleanup && "Already forced cleanup");
Douglas Gregor965f4502009-11-24 16:43:22 +0000832 CGF.DidCallStackSave = OldDidCallStackSave;
John McCallbd309292010-07-06 01:34:17 +0000833 CGF.PopCleanupBlocks(CleanupStackDepth);
Douglas Gregor680f8612009-11-24 21:15:44 +0000834 PerformCleanup = false;
Douglas Gregor965f4502009-11-24 16:43:22 +0000835 }
836 };
837
Eric Christophera9d34972011-10-19 00:43:52 +0000838 class LexicalScope: protected RunCleanupsScope {
839 SourceRange Range;
840 bool PopDebugStack;
841
Dmitri Gribenkoa664e5b2012-09-15 20:20:27 +0000842 LexicalScope(const LexicalScope &) LLVM_DELETED_FUNCTION;
843 void operator=(const LexicalScope &) LLVM_DELETED_FUNCTION;
Eric Christophera9d34972011-10-19 00:43:52 +0000844
845 public:
846 /// \brief Enter a new cleanup scope.
847 explicit LexicalScope(CodeGenFunction &CGF, SourceRange Range)
848 : RunCleanupsScope(CGF), Range(Range), PopDebugStack(true) {
849 if (CGDebugInfo *DI = CGF.getDebugInfo())
850 DI->EmitLexicalBlockStart(CGF.Builder, Range.getBegin());
851 }
852
853 /// \brief Exit this cleanup scope, emitting any accumulated
854 /// cleanups.
855 ~LexicalScope() {
856 if (PopDebugStack) {
Eric Christopherf8b98092012-07-11 15:32:13 +0000857 CGDebugInfo *DI = CGF.getDebugInfo();
858 if (DI) DI->EmitLexicalBlockEnd(CGF.Builder, Range.getEnd());
Eric Christophera9d34972011-10-19 00:43:52 +0000859 }
860 }
861
862 /// \brief Force the emission of cleanups now, instead of waiting
863 /// until this object is destroyed.
864 void ForceCleanup() {
865 RunCleanupsScope::ForceCleanup();
866 if (CGDebugInfo *DI = CGF.getDebugInfo()) {
867 DI->EmitLexicalBlockEnd(CGF.Builder, Range.getEnd());
868 PopDebugStack = false;
869 }
870 }
871 };
872
Anders Carlssonb9fd57f2010-03-30 03:14:41 +0000873
John McCallbd309292010-07-06 01:34:17 +0000874 /// PopCleanupBlocks - Takes the old cleanup stack size and emits
875 /// the cleanup blocks that have been added.
876 void PopCleanupBlocks(EHScopeStack::stable_iterator OldCleanupStackSize);
Anders Carlssonb9fd57f2010-03-30 03:14:41 +0000877
John McCallad5d61e2010-07-23 21:56:41 +0000878 void ResolveBranchFixups(llvm::BasicBlock *Target);
879
John McCallbd309292010-07-06 01:34:17 +0000880 /// The given basic block lies in the current EH scope, but may be a
881 /// target of a potentially scope-crossing jump; get a stable handle
882 /// to which we can perform this jump later.
John McCallad5d61e2010-07-23 21:56:41 +0000883 JumpDest getJumpDestInCurrentScope(llvm::BasicBlock *Target) {
John McCallba803902010-07-28 01:07:35 +0000884 return JumpDest(Target,
885 EHStack.getInnermostNormalCleanup(),
886 NextCleanupDestIndex++);
John McCallbd309292010-07-06 01:34:17 +0000887 }
Anders Carlssonbe0f76a2009-02-07 23:50:39 +0000888
John McCallbd309292010-07-06 01:34:17 +0000889 /// The given basic block lies in the current EH scope, but may be a
890 /// target of a potentially scope-crossing jump; get a stable handle
891 /// to which we can perform this jump later.
Chris Lattner01cf8db2011-07-20 06:58:45 +0000892 JumpDest getJumpDestInCurrentScope(StringRef Name = StringRef()) {
John McCallad5d61e2010-07-23 21:56:41 +0000893 return getJumpDestInCurrentScope(createBasicBlock(Name));
John McCallbd309292010-07-06 01:34:17 +0000894 }
895
896 /// EmitBranchThroughCleanup - Emit a branch from the current insert
897 /// block through the normal cleanup handling code (if any) and then
898 /// on to \arg Dest.
899 void EmitBranchThroughCleanup(JumpDest Dest);
Chris Lattnerbc204c82011-04-17 00:54:30 +0000900
901 /// isObviouslyBranchWithoutCleanups - Return true if a branch to the
902 /// specified destination obviously has no cleanups to run. 'false' is always
903 /// a conservatively correct answer for this method.
904 bool isObviouslyBranchWithoutCleanups(JumpDest Dest) const;
John McCallbd309292010-07-06 01:34:17 +0000905
John McCall8e4c74b2011-08-11 02:22:43 +0000906 /// popCatchScope - Pops the catch scope at the top of the EHScope
907 /// stack, emitting any required code (other than the catch handlers
908 /// themselves).
909 void popCatchScope();
John McCallad5d61e2010-07-23 21:56:41 +0000910
David Chisnall9a837be2012-11-07 16:50:40 +0000911 llvm::BasicBlock *getEHResumeBlock(bool isCleanup);
John McCall8e4c74b2011-08-11 02:22:43 +0000912 llvm::BasicBlock *getEHDispatchBlock(EHScopeStack::stable_iterator scope);
Mike Stumpfc496822009-02-08 23:14:22 +0000913
John McCallce1de612011-01-26 04:00:11 +0000914 /// An object to manage conditionally-evaluated expressions.
915 class ConditionalEvaluation {
916 llvm::BasicBlock *StartBB;
Mike Stump11289f42009-09-09 15:08:12 +0000917
John McCallce1de612011-01-26 04:00:11 +0000918 public:
919 ConditionalEvaluation(CodeGenFunction &CGF)
920 : StartBB(CGF.Builder.GetInsertBlock()) {}
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +0000921
John McCallce1de612011-01-26 04:00:11 +0000922 void begin(CodeGenFunction &CGF) {
923 assert(CGF.OutermostConditional != this);
924 if (!CGF.OutermostConditional)
925 CGF.OutermostConditional = this;
926 }
927
928 void end(CodeGenFunction &CGF) {
929 assert(CGF.OutermostConditional != 0);
930 if (CGF.OutermostConditional == this)
931 CGF.OutermostConditional = 0;
932 }
933
934 /// Returns a block which will be executed prior to each
935 /// evaluation of the conditional code.
936 llvm::BasicBlock *getStartingBlock() const {
937 return StartBB;
938 }
939 };
Mike Stump11289f42009-09-09 15:08:12 +0000940
John McCall7f9c92a2010-09-17 00:50:28 +0000941 /// isInConditionalBranch - Return true if we're currently emitting
942 /// one branch or the other of a conditional expression.
John McCallce1de612011-01-26 04:00:11 +0000943 bool isInConditionalBranch() const { return OutermostConditional != 0; }
944
John McCallf4beacd2011-11-10 10:43:54 +0000945 void setBeforeOutermostConditional(llvm::Value *value, llvm::Value *addr) {
946 assert(isInConditionalBranch());
947 llvm::BasicBlock *block = OutermostConditional->getStartingBlock();
948 new llvm::StoreInst(value, addr, &block->back());
949 }
950
John McCallce1de612011-01-26 04:00:11 +0000951 /// An RAII object to record that we're evaluating a statement
952 /// expression.
953 class StmtExprEvaluation {
954 CodeGenFunction &CGF;
955
956 /// We have to save the outermost conditional: cleanups in a
957 /// statement expression aren't conditional just because the
958 /// StmtExpr is.
959 ConditionalEvaluation *SavedOutermostConditional;
960
961 public:
962 StmtExprEvaluation(CodeGenFunction &CGF)
963 : CGF(CGF), SavedOutermostConditional(CGF.OutermostConditional) {
964 CGF.OutermostConditional = 0;
965 }
966
967 ~StmtExprEvaluation() {
968 CGF.OutermostConditional = SavedOutermostConditional;
969 CGF.EnsureInsertPoint();
970 }
971 };
John McCall1bf58462011-02-16 08:02:54 +0000972
John McCallc07a0c72011-02-17 10:25:35 +0000973 /// An object which temporarily prevents a value from being
974 /// destroyed by aggressive peephole optimizations that assume that
975 /// all uses of a value have been realized in the IR.
976 class PeepholeProtection {
977 llvm::Instruction *Inst;
978 friend class CodeGenFunction;
979
980 public:
981 PeepholeProtection() : Inst(0) {}
John McCallfe96e0b2011-11-06 09:01:30 +0000982 };
John McCallc07a0c72011-02-17 10:25:35 +0000983
John McCallfe96e0b2011-11-06 09:01:30 +0000984 /// A non-RAII class containing all the information about a bound
985 /// opaque value. OpaqueValueMapping, below, is a RAII wrapper for
986 /// this which makes individual mappings very simple; using this
987 /// class directly is useful when you have a variable number of
988 /// opaque values or don't want the RAII functionality for some
989 /// reason.
990 class OpaqueValueMappingData {
John McCall1bf58462011-02-16 08:02:54 +0000991 const OpaqueValueExpr *OpaqueValue;
John McCallc07a0c72011-02-17 10:25:35 +0000992 bool BoundLValue;
993 CodeGenFunction::PeepholeProtection Protection;
John McCall1bf58462011-02-16 08:02:54 +0000994
John McCallfe96e0b2011-11-06 09:01:30 +0000995 OpaqueValueMappingData(const OpaqueValueExpr *ov,
996 bool boundLValue)
997 : OpaqueValue(ov), BoundLValue(boundLValue) {}
John McCall1bf58462011-02-16 08:02:54 +0000998 public:
John McCallfe96e0b2011-11-06 09:01:30 +0000999 OpaqueValueMappingData() : OpaqueValue(0) {}
1000
John McCallc07a0c72011-02-17 10:25:35 +00001001 static bool shouldBindAsLValue(const Expr *expr) {
John McCall9a549612011-11-08 22:54:08 +00001002 // gl-values should be bound as l-values for obvious reasons.
1003 // Records should be bound as l-values because IR generation
1004 // always keeps them in memory. Expressions of function type
1005 // act exactly like l-values but are formally required to be
1006 // r-values in C.
1007 return expr->isGLValue() ||
1008 expr->getType()->isRecordType() ||
1009 expr->getType()->isFunctionType();
John McCallc07a0c72011-02-17 10:25:35 +00001010 }
1011
John McCallfe96e0b2011-11-06 09:01:30 +00001012 static OpaqueValueMappingData bind(CodeGenFunction &CGF,
1013 const OpaqueValueExpr *ov,
1014 const Expr *e) {
1015 if (shouldBindAsLValue(ov))
1016 return bind(CGF, ov, CGF.EmitLValue(e));
1017 return bind(CGF, ov, CGF.EmitAnyExpr(e));
1018 }
1019
1020 static OpaqueValueMappingData bind(CodeGenFunction &CGF,
1021 const OpaqueValueExpr *ov,
1022 const LValue &lv) {
1023 assert(shouldBindAsLValue(ov));
1024 CGF.OpaqueLValues.insert(std::make_pair(ov, lv));
1025 return OpaqueValueMappingData(ov, true);
1026 }
1027
1028 static OpaqueValueMappingData bind(CodeGenFunction &CGF,
1029 const OpaqueValueExpr *ov,
1030 const RValue &rv) {
1031 assert(!shouldBindAsLValue(ov));
1032 CGF.OpaqueRValues.insert(std::make_pair(ov, rv));
1033
1034 OpaqueValueMappingData data(ov, false);
1035
1036 // Work around an extremely aggressive peephole optimization in
1037 // EmitScalarConversion which assumes that all other uses of a
1038 // value are extant.
1039 data.Protection = CGF.protectFromPeepholes(rv);
1040
1041 return data;
1042 }
1043
1044 bool isValid() const { return OpaqueValue != 0; }
1045 void clear() { OpaqueValue = 0; }
1046
1047 void unbind(CodeGenFunction &CGF) {
1048 assert(OpaqueValue && "no data to unbind!");
1049
1050 if (BoundLValue) {
1051 CGF.OpaqueLValues.erase(OpaqueValue);
1052 } else {
1053 CGF.OpaqueRValues.erase(OpaqueValue);
1054 CGF.unprotectFromPeepholes(Protection);
1055 }
1056 }
1057 };
1058
1059 /// An RAII object to set (and then clear) a mapping for an OpaqueValueExpr.
1060 class OpaqueValueMapping {
1061 CodeGenFunction &CGF;
1062 OpaqueValueMappingData Data;
1063
1064 public:
1065 static bool shouldBindAsLValue(const Expr *expr) {
1066 return OpaqueValueMappingData::shouldBindAsLValue(expr);
1067 }
1068
John McCallc07a0c72011-02-17 10:25:35 +00001069 /// Build the opaque value mapping for the given conditional
1070 /// operator if it's the GNU ?: extension. This is a common
1071 /// enough pattern that the convenience operator is really
1072 /// helpful.
1073 ///
1074 OpaqueValueMapping(CodeGenFunction &CGF,
1075 const AbstractConditionalOperator *op) : CGF(CGF) {
John McCallfe96e0b2011-11-06 09:01:30 +00001076 if (isa<ConditionalOperator>(op))
1077 // Leave Data empty.
John McCallc07a0c72011-02-17 10:25:35 +00001078 return;
John McCallc07a0c72011-02-17 10:25:35 +00001079
1080 const BinaryConditionalOperator *e = cast<BinaryConditionalOperator>(op);
John McCallfe96e0b2011-11-06 09:01:30 +00001081 Data = OpaqueValueMappingData::bind(CGF, e->getOpaqueValue(),
1082 e->getCommon());
John McCallc07a0c72011-02-17 10:25:35 +00001083 }
1084
John McCall1bf58462011-02-16 08:02:54 +00001085 OpaqueValueMapping(CodeGenFunction &CGF,
1086 const OpaqueValueExpr *opaqueValue,
John McCallc07a0c72011-02-17 10:25:35 +00001087 LValue lvalue)
John McCallfe96e0b2011-11-06 09:01:30 +00001088 : CGF(CGF), Data(OpaqueValueMappingData::bind(CGF, opaqueValue, lvalue)) {
John McCallc07a0c72011-02-17 10:25:35 +00001089 }
1090
1091 OpaqueValueMapping(CodeGenFunction &CGF,
1092 const OpaqueValueExpr *opaqueValue,
1093 RValue rvalue)
John McCallfe96e0b2011-11-06 09:01:30 +00001094 : CGF(CGF), Data(OpaqueValueMappingData::bind(CGF, opaqueValue, rvalue)) {
John McCall1bf58462011-02-16 08:02:54 +00001095 }
1096
1097 void pop() {
John McCallfe96e0b2011-11-06 09:01:30 +00001098 Data.unbind(CGF);
1099 Data.clear();
John McCall1bf58462011-02-16 08:02:54 +00001100 }
1101
1102 ~OpaqueValueMapping() {
John McCallfe96e0b2011-11-06 09:01:30 +00001103 if (Data.isValid()) Data.unbind(CGF);
John McCall1bf58462011-02-16 08:02:54 +00001104 }
1105 };
Fariborz Jahaniana3e54bd2010-11-16 19:29:39 +00001106
1107 /// getByrefValueFieldNumber - Given a declaration, returns the LLVM field
1108 /// number that holds the value.
1109 unsigned getByRefValueLLVMField(const ValueDecl *VD) const;
Fariborz Jahanian2f2fa722011-01-26 23:08:27 +00001110
1111 /// BuildBlockByrefAddress - Computes address location of the
1112 /// variable which is declared as __block.
1113 llvm::Value *BuildBlockByrefAddress(llvm::Value *BaseAddr,
1114 const VarDecl *V);
Chris Lattner2da04b32007-08-24 05:35:26 +00001115private:
Chris Lattner6c4d2552009-10-28 23:59:40 +00001116 CGDebugInfo *DebugInfo;
Devang Pateld6ffebb2011-03-07 18:45:56 +00001117 bool DisableDebugInfo;
Mike Stumpc6ea7c12009-02-17 17:00:02 +00001118
John McCall9b382dd2011-05-28 21:13:02 +00001119 /// DidCallStackSave - Whether llvm.stacksave has been called. Used to avoid
1120 /// calling llvm.stacksave for multiple VLAs in the same scope.
1121 bool DidCallStackSave;
1122
Mike Stumpe5311b02009-11-30 20:08:49 +00001123 /// IndirectBranch - The first time an indirect goto is seen we create a block
1124 /// with an indirect branch. Every time we see the address of a label taken,
1125 /// we add the label to the indirect goto. Every subsequent indirect goto is
1126 /// codegen'd as a jump to the IndirectBranch's basic block.
Chris Lattner6c4d2552009-10-28 23:59:40 +00001127 llvm::IndirectBrInst *IndirectBranch;
Daniel Dunbar88402ce2008-08-04 16:51:22 +00001128
Mike Stumpfc496822009-02-08 23:14:22 +00001129 /// LocalDeclMap - This keeps track of the LLVM allocas or globals for local C
1130 /// decls.
John McCall351762c2011-02-07 10:33:21 +00001131 typedef llvm::DenseMap<const Decl*, llvm::Value*> DeclMapTy;
1132 DeclMapTy LocalDeclMap;
Chris Lattner84915fa2007-06-02 04:16:21 +00001133
Chris Lattnerac248202007-05-30 00:13:02 +00001134 /// LabelMap - This keeps track of the LLVM basic block for each C label.
Chris Lattnerc8e630e2011-02-17 07:39:24 +00001135 llvm::DenseMap<const LabelDecl*, JumpDest> LabelMap;
Mike Stumpfc496822009-02-08 23:14:22 +00001136
Mike Stumpfc496822009-02-08 23:14:22 +00001137 // BreakContinueStack - This keeps track of where break and continue
Anders Carlsson33747b62009-02-10 05:52:02 +00001138 // statements should jump to.
Chris Lattnere73e4322007-07-16 21:28:45 +00001139 struct BreakContinue {
John McCallbd309292010-07-06 01:34:17 +00001140 BreakContinue(JumpDest Break, JumpDest Continue)
1141 : BreakBlock(Break), ContinueBlock(Continue) {}
Mike Stumpfc496822009-02-08 23:14:22 +00001142
John McCallbd309292010-07-06 01:34:17 +00001143 JumpDest BreakBlock;
1144 JumpDest ContinueBlock;
Mike Stumpfc496822009-02-08 23:14:22 +00001145 };
Chris Lattner01cf8db2011-07-20 06:58:45 +00001146 SmallVector<BreakContinue, 8> BreakContinueStack;
Daniel Dunbard3dcb4f82008-09-28 01:03:14 +00001147
Zhongxing Xu82846ea2012-01-14 09:08:15 +00001148 /// SwitchInsn - This is nearest current switch instruction. It is null if
Mike Stumpfc496822009-02-08 23:14:22 +00001149 /// current context is not in a switch.
Devang Patelda5d6bb2007-10-04 23:45:31 +00001150 llvm::SwitchInst *SwitchInsn;
1151
Mike Stumpfc496822009-02-08 23:14:22 +00001152 /// CaseRangeBlock - This block holds if condition check for last case
Devang Patel49a44f32007-10-09 17:08:50 +00001153 /// statement range in current switch instruction.
Devang Patel11663122007-10-08 20:57:48 +00001154 llvm::BasicBlock *CaseRangeBlock;
1155
John McCallc07a0c72011-02-17 10:25:35 +00001156 /// OpaqueLValues - Keeps track of the current set of opaque value
John McCall1bf58462011-02-16 08:02:54 +00001157 /// expressions.
John McCallc07a0c72011-02-17 10:25:35 +00001158 llvm::DenseMap<const OpaqueValueExpr *, LValue> OpaqueLValues;
1159 llvm::DenseMap<const OpaqueValueExpr *, RValue> OpaqueRValues;
John McCall1bf58462011-02-16 08:02:54 +00001160
Mike Stumpfc496822009-02-08 23:14:22 +00001161 // VLASizeMap - This keeps track of the associated size for each VLA type.
Eli Friedman04fddf02009-08-15 02:50:32 +00001162 // We track this by the size expression rather than the type itself because
1163 // in certain situations, like a const qualifier applied to an VLA typedef,
1164 // multiple VLA types can share the same size expression.
Mike Stumpfc496822009-02-08 23:14:22 +00001165 // FIXME: Maybe this could be a stack of maps that is pushed/popped as we
1166 // enter/leave scopes.
Eli Friedman04fddf02009-08-15 02:50:32 +00001167 llvm::DenseMap<const Expr*, llvm::Value*> VLASizeMap;
Mike Stumpfc496822009-02-08 23:14:22 +00001168
John McCallbd309292010-07-06 01:34:17 +00001169 /// A block containing a single 'unreachable' instruction. Created
1170 /// lazily by getUnreachableBlock().
1171 llvm::BasicBlock *UnreachableBlock;
Mike Stumpfc496822009-02-08 23:14:22 +00001172
Anders Carlsson82ba57c2009-11-25 03:15:49 +00001173 /// CXXThisDecl - When generating code for a C++ member function,
1174 /// this will hold the implicit 'this' declaration.
Eli Friedman9fbeba02012-02-11 02:57:39 +00001175 ImplicitParamDecl *CXXABIThisDecl;
1176 llvm::Value *CXXABIThisValue;
John McCall347132b2010-02-16 22:04:33 +00001177 llvm::Value *CXXThisValue;
Mike Stump11289f42009-09-09 15:08:12 +00001178
Anders Carlsson82ba57c2009-11-25 03:15:49 +00001179 /// CXXVTTDecl - When generating code for a base object constructor or
1180 /// base object destructor with virtual bases, this will hold the implicit
1181 /// VTT parameter.
1182 ImplicitParamDecl *CXXVTTDecl;
John McCall347132b2010-02-16 22:04:33 +00001183 llvm::Value *CXXVTTValue;
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001184
John McCallce1de612011-01-26 04:00:11 +00001185 /// OutermostConditional - Points to the outermost active
1186 /// conditional control. This is used so that we know if a
1187 /// temporary should be destroyed conditionally.
1188 ConditionalEvaluation *OutermostConditional;
Mike Stump11289f42009-09-09 15:08:12 +00001189
Anders Carlsson0168f4b2009-09-12 02:14:24 +00001190
1191 /// ByrefValueInfoMap - For each __block variable, contains a pair of the LLVM
1192 /// type as well as the field number that contains the actual data.
Chris Lattner2192fe52011-07-18 04:24:23 +00001193 llvm::DenseMap<const ValueDecl *, std::pair<llvm::Type *,
Anders Carlsson0168f4b2009-09-12 02:14:24 +00001194 unsigned> > ByRefValueInfo;
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001195
John McCallbd309292010-07-06 01:34:17 +00001196 llvm::BasicBlock *TerminateLandingPad;
Mike Stumpf5cbb082009-12-10 00:02:42 +00001197 llvm::BasicBlock *TerminateHandler;
Chris Lattnerf2f38702010-07-20 21:07:09 +00001198 llvm::BasicBlock *TrapBB;
Eli Friedmand5bc94e2009-12-10 02:21:21 +00001199
Tanya Lattnerbcffcdf2012-07-09 22:06:01 +00001200 /// Add a kernel metadata node to the named metadata node 'opencl.kernels'.
1201 /// In the kernel metadata node, reference the kernel function and metadata
1202 /// nodes for its optional attribute qualifiers (OpenCL 1.1 6.7.2):
1203 /// - A node for the work_group_size_hint(X,Y,Z) qualifier contains string
1204 /// "work_group_size_hint", and three 32-bit integers X, Y and Z.
1205 /// - A node for the reqd_work_group_size(X,Y,Z) qualifier contains string
1206 /// "reqd_work_group_size", and three 32-bit integers X, Y and Z.
1207 void EmitOpenCLKernelMetadata(const FunctionDecl *FD,
1208 llvm::Function *Fn);
1209
Chris Lattnerbed31442007-05-28 01:07:47 +00001210public:
Fariborz Jahanian63628032012-06-26 16:06:38 +00001211 CodeGenFunction(CodeGenModule &cgm, bool suppressNewContext=false);
John McCall08ef4662011-11-10 08:15:53 +00001212 ~CodeGenFunction();
Mike Stumpfc496822009-02-08 23:14:22 +00001213
John McCall8ed55a52010-09-02 09:58:18 +00001214 CodeGenTypes &getTypes() const { return CGM.getTypes(); }
John McCall745ae282011-05-15 02:34:36 +00001215 ASTContext &getContext() const { return CGM.getContext(); }
Alexey Samsonov38e24962012-10-16 07:22:28 +00001216 /// Returns true if DebugInfo is actually initialized.
1217 bool maybeInitializeDebugInfo() {
1218 if (CGM.getModuleDebugInfo()) {
1219 DebugInfo = CGM.getModuleDebugInfo();
1220 return true;
1221 }
1222 return false;
1223 }
Devang Pateld6ffebb2011-03-07 18:45:56 +00001224 CGDebugInfo *getDebugInfo() {
1225 if (DisableDebugInfo)
1226 return NULL;
1227 return DebugInfo;
1228 }
1229 void disableDebugInfo() { DisableDebugInfo = true; }
1230 void enableDebugInfo() { DisableDebugInfo = false; }
1231
John McCall31168b02011-06-15 23:02:42 +00001232 bool shouldUseFusedARCCalls() {
1233 return CGM.getCodeGenOpts().OptimizationLevel == 0;
1234 }
Chris Lattner6db1fb82007-06-02 22:49:07 +00001235
David Blaikiebbafb8a2012-03-11 07:00:24 +00001236 const LangOptions &getLangOpts() const { return CGM.getLangOpts(); }
John McCallad7c5c12011-02-08 08:22:06 +00001237
Bill Wendlingf0724e82011-09-19 20:31:14 +00001238 /// Returns a pointer to the function's exception object and selector slot,
1239 /// which is assigned in every landing pad.
John McCallbd309292010-07-06 01:34:17 +00001240 llvm::Value *getExceptionSlot();
John McCall9b382dd2011-05-28 21:13:02 +00001241 llvm::Value *getEHSelectorSlot();
John McCallbd309292010-07-06 01:34:17 +00001242
Bill Wendling79a70e42011-09-15 18:57:19 +00001243 /// Returns the contents of the function's exception object and selector
1244 /// slots.
1245 llvm::Value *getExceptionFromSlot();
1246 llvm::Value *getSelectorFromSlot();
1247
John McCallad5d61e2010-07-23 21:56:41 +00001248 llvm::Value *getNormalCleanupDestSlot();
John McCallad5d61e2010-07-23 21:56:41 +00001249
John McCallbd309292010-07-06 01:34:17 +00001250 llvm::BasicBlock *getUnreachableBlock() {
1251 if (!UnreachableBlock) {
1252 UnreachableBlock = createBasicBlock("unreachable");
1253 new llvm::UnreachableInst(getLLVMContext(), UnreachableBlock);
1254 }
1255 return UnreachableBlock;
1256 }
1257
1258 llvm::BasicBlock *getInvokeDest() {
1259 if (!EHStack.requiresLandingPad()) return 0;
1260 return getInvokeDestImpl();
1261 }
Daniel Dunbar12347492009-02-23 17:26:39 +00001262
John McCallad7c5c12011-02-08 08:22:06 +00001263 llvm::LLVMContext &getLLVMContext() { return CGM.getLLVMContext(); }
Owen Andersonae86c192009-07-13 04:10:07 +00001264
Daniel Dunbar12347492009-02-23 17:26:39 +00001265 //===--------------------------------------------------------------------===//
John McCall82fe67b2011-07-09 01:37:26 +00001266 // Cleanups
1267 //===--------------------------------------------------------------------===//
1268
1269 typedef void Destroyer(CodeGenFunction &CGF, llvm::Value *addr, QualType ty);
1270
John McCall178360e2011-07-11 08:38:19 +00001271 void pushIrregularPartialArrayCleanup(llvm::Value *arrayBegin,
1272 llvm::Value *arrayEndPointer,
1273 QualType elementType,
Peter Collingbourne1425b452012-01-26 03:33:36 +00001274 Destroyer *destroyer);
John McCall178360e2011-07-11 08:38:19 +00001275 void pushRegularPartialArrayCleanup(llvm::Value *arrayBegin,
1276 llvm::Value *arrayEnd,
1277 QualType elementType,
Peter Collingbourne1425b452012-01-26 03:33:36 +00001278 Destroyer *destroyer);
John McCall82fe67b2011-07-09 01:37:26 +00001279
John McCall4bd0fb12011-07-12 16:41:08 +00001280 void pushDestroy(QualType::DestructionKind dtorKind,
1281 llvm::Value *addr, QualType type);
John McCall82fe67b2011-07-09 01:37:26 +00001282 void pushDestroy(CleanupKind kind, llvm::Value *addr, QualType type,
Peter Collingbourne1425b452012-01-26 03:33:36 +00001283 Destroyer *destroyer, bool useEHCleanupForArray);
1284 void emitDestroy(llvm::Value *addr, QualType type, Destroyer *destroyer,
John McCall178360e2011-07-11 08:38:19 +00001285 bool useEHCleanupForArray);
John McCall98de3d72011-07-13 03:01:35 +00001286 llvm::Function *generateDestroyHelper(llvm::Constant *addr,
1287 QualType type,
Peter Collingbourne1425b452012-01-26 03:33:36 +00001288 Destroyer *destroyer,
John McCall98de3d72011-07-13 03:01:35 +00001289 bool useEHCleanupForArray);
John McCall82fe67b2011-07-09 01:37:26 +00001290 void emitArrayDestroy(llvm::Value *begin, llvm::Value *end,
Peter Collingbourne1425b452012-01-26 03:33:36 +00001291 QualType type, Destroyer *destroyer,
John McCall97eab0a2011-07-13 08:09:46 +00001292 bool checkZeroLength, bool useEHCleanup);
John McCall82fe67b2011-07-09 01:37:26 +00001293
Peter Collingbourne1425b452012-01-26 03:33:36 +00001294 Destroyer *getDestroyer(QualType::DestructionKind destructionKind);
John McCall4bd0fb12011-07-12 16:41:08 +00001295
John McCall82fe67b2011-07-09 01:37:26 +00001296 /// Determines whether an EH cleanup is required to destroy a type
1297 /// with the given destruction kind.
1298 bool needsEHCleanup(QualType::DestructionKind kind) {
1299 switch (kind) {
1300 case QualType::DK_none:
1301 return false;
1302 case QualType::DK_cxx_destructor:
1303 case QualType::DK_objc_weak_lifetime:
David Blaikiebbafb8a2012-03-11 07:00:24 +00001304 return getLangOpts().Exceptions;
John McCall82fe67b2011-07-09 01:37:26 +00001305 case QualType::DK_objc_strong_lifetime:
David Blaikiebbafb8a2012-03-11 07:00:24 +00001306 return getLangOpts().Exceptions &&
John McCall82fe67b2011-07-09 01:37:26 +00001307 CGM.getCodeGenOpts().ObjCAutoRefCountExceptions;
1308 }
1309 llvm_unreachable("bad destruction kind");
1310 }
1311
John McCall4bd0fb12011-07-12 16:41:08 +00001312 CleanupKind getCleanupKind(QualType::DestructionKind kind) {
1313 return (needsEHCleanup(kind) ? NormalAndEHCleanup : NormalCleanup);
1314 }
1315
John McCall82fe67b2011-07-09 01:37:26 +00001316 //===--------------------------------------------------------------------===//
Daniel Dunbar12347492009-02-23 17:26:39 +00001317 // Objective-C
1318 //===--------------------------------------------------------------------===//
1319
Chris Lattner4bd55962008-03-30 23:03:07 +00001320 void GenerateObjCMethod(const ObjCMethodDecl *OMD);
Daniel Dunbar89654ee2008-08-26 08:29:31 +00001321
Mike Stumpfc496822009-02-08 23:14:22 +00001322 void StartObjCMethod(const ObjCMethodDecl *MD,
Devang Patele7ce5402011-05-19 23:37:41 +00001323 const ObjCContainerDecl *CD,
1324 SourceLocation StartLoc);
Daniel Dunbar89654ee2008-08-26 08:29:31 +00001325
Mike Stumpfc496822009-02-08 23:14:22 +00001326 /// GenerateObjCGetter - Synthesize an Objective-C property getter function.
Fariborz Jahanian3d8552a2008-12-09 20:23:04 +00001327 void GenerateObjCGetter(ObjCImplementationDecl *IMP,
1328 const ObjCPropertyImplDecl *PID);
John McCallf4528ae2011-09-13 03:34:09 +00001329 void generateObjCGetterBody(const ObjCImplementationDecl *classImpl,
Fariborz Jahanian4b501a22012-01-07 18:56:22 +00001330 const ObjCPropertyImplDecl *propImpl,
Fariborz Jahanianb5dd2cb2012-05-29 19:56:01 +00001331 const ObjCMethodDecl *GetterMothodDecl,
Fariborz Jahanian4b501a22012-01-07 18:56:22 +00001332 llvm::Constant *AtomicHelperFn);
Fariborz Jahanian302a3d42011-02-18 19:15:13 +00001333
Fariborz Jahanian0dec1e02010-04-28 21:28:56 +00001334 void GenerateObjCCtorDtorMethod(ObjCImplementationDecl *IMP,
1335 ObjCMethodDecl *MD, bool ctor);
Daniel Dunbar89654ee2008-08-26 08:29:31 +00001336
Mike Stumpfc496822009-02-08 23:14:22 +00001337 /// GenerateObjCSetter - Synthesize an Objective-C property setter function
1338 /// for the given property.
Fariborz Jahanian3d8552a2008-12-09 20:23:04 +00001339 void GenerateObjCSetter(ObjCImplementationDecl *IMP,
1340 const ObjCPropertyImplDecl *PID);
John McCall7f16c422011-09-10 09:17:20 +00001341 void generateObjCSetterBody(const ObjCImplementationDecl *classImpl,
Fariborz Jahanian7ff610b2012-01-06 22:33:54 +00001342 const ObjCPropertyImplDecl *propImpl,
1343 llvm::Constant *AtomicHelperFn);
Fariborz Jahanian08b0f662010-04-13 00:38:05 +00001344 bool IndirectObjCSetterArg(const CGFunctionInfo &FI);
Fariborz Jahanian7e9d52a2010-04-13 18:32:24 +00001345 bool IvarTypeWithAggrGCObjects(QualType Ty);
Daniel Dunbar89654ee2008-08-26 08:29:31 +00001346
Mike Stumpcb2fbcb2009-02-21 20:00:35 +00001347 //===--------------------------------------------------------------------===//
1348 // Block Bits
1349 //===--------------------------------------------------------------------===//
1350
John McCall351762c2011-02-07 10:33:21 +00001351 llvm::Value *EmitBlockLiteral(const BlockExpr *);
John McCall08ef4662011-11-10 08:15:53 +00001352 llvm::Value *EmitBlockLiteral(const CGBlockInfo &Info);
1353 static void destroyBlockInfos(CGBlockInfo *info);
Blaine Garstfc83aa02010-02-23 21:51:17 +00001354 llvm::Constant *BuildDescriptorBlockDecl(const BlockExpr *,
Fariborz Jahanianc05349e2010-08-04 16:57:49 +00001355 const CGBlockInfo &Info,
Chris Lattner2192fe52011-07-18 04:24:23 +00001356 llvm::StructType *,
John McCallad7c5c12011-02-08 08:22:06 +00001357 llvm::Constant *BlockVarLayout);
Mike Stumpcb2fbcb2009-02-21 20:00:35 +00001358
Fariborz Jahanian9b5528d2010-06-24 00:08:06 +00001359 llvm::Function *GenerateBlockFunction(GlobalDecl GD,
John McCall351762c2011-02-07 10:33:21 +00001360 const CGBlockInfo &Info,
Mike Stump692c6e32009-03-20 21:53:12 +00001361 const Decl *OuterFuncDecl,
Eli Friedman2495ab02012-02-25 02:48:22 +00001362 const DeclMapTy &ldm,
1363 bool IsLambdaConversionToBlock);
Mike Stumpcb2fbcb2009-02-21 20:00:35 +00001364
John McCallad7c5c12011-02-08 08:22:06 +00001365 llvm::Constant *GenerateCopyHelperFunction(const CGBlockInfo &blockInfo);
1366 llvm::Constant *GenerateDestroyHelperFunction(const CGBlockInfo &blockInfo);
Fariborz Jahaniana08a7472012-01-10 00:37:01 +00001367 llvm::Constant *GenerateObjCAtomicSetterCopyHelperFunction(
1368 const ObjCPropertyImplDecl *PID);
1369 llvm::Constant *GenerateObjCAtomicGetterCopyHelperFunction(
1370 const ObjCPropertyImplDecl *PID);
Eli Friedmanec75fec2012-02-28 01:08:45 +00001371 llvm::Value *EmitBlockCopyAndAutorelease(llvm::Value *Block, QualType Ty);
John McCallad7c5c12011-02-08 08:22:06 +00001372
John McCallad7c5c12011-02-08 08:22:06 +00001373 void BuildBlockRelease(llvm::Value *DeclPtr, BlockFieldFlags flags);
1374
John McCall73064872011-03-31 01:59:53 +00001375 class AutoVarEmission;
1376
1377 void emitByrefStructureInit(const AutoVarEmission &emission);
1378 void enterByrefCleanup(const AutoVarEmission &emission);
1379
John McCall351762c2011-02-07 10:33:21 +00001380 llvm::Value *LoadBlockStruct() {
1381 assert(BlockPointer && "no block pointer set!");
1382 return BlockPointer;
1383 }
Mike Stumpcb2fbcb2009-02-21 20:00:35 +00001384
John McCall87fe5d52010-05-20 01:18:31 +00001385 void AllocateBlockCXXThisPointer(const CXXThisExpr *E);
John McCall113bee02012-03-10 09:33:50 +00001386 void AllocateBlockDecl(const DeclRefExpr *E);
John McCall351762c2011-02-07 10:33:21 +00001387 llvm::Value *GetAddrOfBlockDecl(const VarDecl *var, bool ByRef);
Chris Lattner2192fe52011-07-18 04:24:23 +00001388 llvm::Type *BuildByRefType(const VarDecl *var);
Mike Stump97d01d52009-03-04 03:23:46 +00001389
John McCalla738c252011-03-09 04:27:21 +00001390 void GenerateCode(GlobalDecl GD, llvm::Function *Fn,
1391 const CGFunctionInfo &FnInfo);
Anders Carlsson73fcc952009-09-11 00:07:24 +00001392 void StartFunction(GlobalDecl GD, QualType RetTy,
Daniel Dunbarbc915f42008-09-09 23:14:03 +00001393 llvm::Function *Fn,
John McCalla738c252011-03-09 04:27:21 +00001394 const CGFunctionInfo &FnInfo,
Daniel Dunbar354d2782008-10-18 18:22:23 +00001395 const FunctionArgList &Args,
Tilmann Scheller99cc30c2011-03-02 21:36:49 +00001396 SourceLocation StartLoc);
Daniel Dunbar5c7e3932008-11-11 23:11:34 +00001397
John McCallb81884d2010-02-19 09:25:03 +00001398 void EmitConstructorBody(FunctionArgList &Args);
1399 void EmitDestructorBody(FunctionArgList &Args);
1400 void EmitFunctionBody(FunctionArgList &Args);
John McCall89b12b32010-02-18 03:17:58 +00001401
Eli Friedman2495ab02012-02-25 02:48:22 +00001402 void EmitForwardingCallToLambda(const CXXRecordDecl *Lambda,
1403 CallArgList &CallArgs);
Eli Friedman5a6d5072012-02-16 01:37:33 +00001404 void EmitLambdaToBlockPointerBody(FunctionArgList &Args);
Eli Friedman2495ab02012-02-25 02:48:22 +00001405 void EmitLambdaBlockInvokeBody();
Douglas Gregor355efbb2012-02-17 03:02:34 +00001406 void EmitLambdaDelegatingInvokeBody(const CXXMethodDecl *MD);
1407 void EmitLambdaStaticInvokeFunction(const CXXMethodDecl *MD);
Eli Friedman5a6d5072012-02-16 01:37:33 +00001408
Mike Stumpfc496822009-02-08 23:14:22 +00001409 /// EmitReturnBlock - Emit the unified return block, trying to avoid its
1410 /// emission when possible.
Daniel Dunbarfd346a32009-01-26 23:27:52 +00001411 void EmitReturnBlock();
1412
Mike Stumpfc496822009-02-08 23:14:22 +00001413 /// FinishFunction - Complete IR generation of the current function. It is
1414 /// legal to call this function even if there is no current insertion point.
Daniel Dunbar89654ee2008-08-26 08:29:31 +00001415 void FinishFunction(SourceLocation EndLoc=SourceLocation());
Daniel Dunbar613855c2008-09-09 23:27:19 +00001416
Anders Carlssonbad991d2010-03-24 00:39:18 +00001417 /// GenerateThunk - Generate a thunk for the given method.
John McCalla738c252011-03-09 04:27:21 +00001418 void GenerateThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo,
1419 GlobalDecl GD, const ThunkInfo &Thunk);
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001420
Eli Friedman49a94b12011-05-06 17:27:27 +00001421 void GenerateVarArgsThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo,
1422 GlobalDecl GD, const ThunkInfo &Thunk);
1423
Douglas Gregor94f9a482010-05-05 05:51:00 +00001424 void EmitCtorPrologue(const CXXConstructorDecl *CD, CXXCtorType Type,
1425 FunctionArgList &Args);
Mike Stump11289f42009-09-09 15:08:12 +00001426
Eli Friedman5f1a04f2012-02-14 02:31:03 +00001427 void EmitInitializerForField(FieldDecl *Field, LValue LHS, Expr *Init,
1428 ArrayRef<VarDecl *> ArrayIndexes);
1429
Anders Carlssone87fae92010-03-28 19:40:00 +00001430 /// InitializeVTablePointer - Initialize the vtable pointer of the given
1431 /// subobject.
1432 ///
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001433 void InitializeVTablePointer(BaseSubobject Base,
Anders Carlsson652758c2010-04-20 05:22:15 +00001434 const CXXRecordDecl *NearestVBase,
Ken Dyck3fb4c892011-03-23 01:04:18 +00001435 CharUnits OffsetFromNearestVBase,
Anders Carlssone87fae92010-03-28 19:40:00 +00001436 llvm::Constant *VTable,
1437 const CXXRecordDecl *VTableClass);
1438
1439 typedef llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBasesSetTy;
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001440 void InitializeVTablePointers(BaseSubobject Base,
Anders Carlsson652758c2010-04-20 05:22:15 +00001441 const CXXRecordDecl *NearestVBase,
Ken Dyck3fb4c892011-03-23 01:04:18 +00001442 CharUnits OffsetFromNearestVBase,
Anders Carlssond5895932010-03-28 21:07:49 +00001443 bool BaseIsNonVirtualPrimaryBase,
1444 llvm::Constant *VTable,
1445 const CXXRecordDecl *VTableClass,
1446 VisitedVirtualBasesSetTy& VBases);
Eli Friedmanbb5008a2009-12-08 06:46:18 +00001447
Anders Carlssond5895932010-03-28 21:07:49 +00001448 void InitializeVTablePointers(const CXXRecordDecl *ClassDecl);
Anders Carlssone87fae92010-03-28 19:40:00 +00001449
Dan Gohman8fc50c22010-10-26 18:44:08 +00001450 /// GetVTablePtr - Return the Value of the vtable pointer member pointed
1451 /// to by This.
Chris Lattner2192fe52011-07-18 04:24:23 +00001452 llvm::Value *GetVTablePtr(llvm::Value *This, llvm::Type *Ty);
Anders Carlssone87fae92010-03-28 19:40:00 +00001453
John McCallf99a6312010-07-21 05:30:47 +00001454 /// EnterDtorCleanups - Enter the cleanups necessary to complete the
1455 /// given phase of destruction for a destructor. The end result
1456 /// should call destructors on members and base classes in reverse
1457 /// order of their construction.
1458 void EnterDtorCleanups(const CXXDestructorDecl *Dtor, CXXDtorType Type);
Mike Stump11289f42009-09-09 15:08:12 +00001459
Chris Lattner3c77a352010-06-22 00:03:40 +00001460 /// ShouldInstrumentFunction - Return true if the current function should be
1461 /// instrumented with __cyg_profile_func_* calls
1462 bool ShouldInstrumentFunction();
1463
1464 /// EmitFunctionInstrumentation - Emit LLVM code to call the specified
1465 /// instrumentation function with the current function and the call site, if
1466 /// function instrumentation is enabled.
1467 void EmitFunctionInstrumentation(const char *Fn);
1468
Roman Divacky178e01602011-02-10 16:52:03 +00001469 /// EmitMCountInstrumentation - Emit call to .mcount.
1470 void EmitMCountInstrumentation();
1471
Mike Stumpfc496822009-02-08 23:14:22 +00001472 /// EmitFunctionProlog - Emit the target specific LLVM code to load the
1473 /// arguments for the given function. This is also responsible for naming the
1474 /// LLVM function arguments.
Daniel Dunbard931a872009-02-02 22:03:45 +00001475 void EmitFunctionProlog(const CGFunctionInfo &FI,
1476 llvm::Function *Fn,
Daniel Dunbar613855c2008-09-09 23:27:19 +00001477 const FunctionArgList &Args);
1478
Mike Stumpfc496822009-02-08 23:14:22 +00001479 /// EmitFunctionEpilog - Emit the target specific LLVM code to return the
1480 /// given temporary.
Chris Lattner3fcc7902010-06-27 01:06:27 +00001481 void EmitFunctionEpilog(const CGFunctionInfo &FI);
Daniel Dunbar613855c2008-09-09 23:27:19 +00001482
Mike Stump1d849212009-12-07 23:38:24 +00001483 /// EmitStartEHSpec - Emit the start of the exception spec.
1484 void EmitStartEHSpec(const Decl *D);
1485
1486 /// EmitEndEHSpec - Emit the end of the exception spec.
1487 void EmitEndEHSpec(const Decl *D);
1488
John McCallbd309292010-07-06 01:34:17 +00001489 /// getTerminateLandingPad - Return a landing pad that just calls terminate.
1490 llvm::BasicBlock *getTerminateLandingPad();
1491
1492 /// getTerminateHandler - Return a handler (not a landing pad, just
1493 /// a catch handler) that just calls terminate. This is used when
1494 /// a terminate scope encloses a try.
Mike Stump2b488872009-12-09 22:59:31 +00001495 llvm::BasicBlock *getTerminateHandler();
1496
Chris Lattnera5f58b02011-07-09 17:41:47 +00001497 llvm::Type *ConvertTypeForMem(QualType T);
1498 llvm::Type *ConvertType(QualType T);
1499 llvm::Type *ConvertType(const TypeDecl *T) {
John McCall6ce74722010-02-16 04:15:37 +00001500 return ConvertType(getContext().getTypeDeclType(T));
1501 }
Chris Lattner5506f8c2008-04-04 04:07:35 +00001502
Mike Stumpfc496822009-02-08 23:14:22 +00001503 /// LoadObjCSelf - Load the value of self. This function is only valid while
1504 /// generating code for an Objective-C method.
Chris Lattner5506f8c2008-04-04 04:07:35 +00001505 llvm::Value *LoadObjCSelf();
Mike Stumpfc496822009-02-08 23:14:22 +00001506
1507 /// TypeOfSelfObject - Return type of object that this self represents.
Fariborz Jahanianc88a70d2009-02-03 00:09:52 +00001508 QualType TypeOfSelfObject();
Chris Lattner5696e7b2008-06-17 18:05:57 +00001509
Chris Lattner54fb19e2007-06-22 22:02:34 +00001510 /// hasAggregateLLVMType - Return true if the specified AST type will map into
1511 /// an aggregate LLVM type or is void.
1512 static bool hasAggregateLLVMType(QualType T);
Daniel Dunbar75283ff2008-11-11 02:29:29 +00001513
1514 /// createBasicBlock - Create an LLVM basic block.
Richard Smithe30752c2012-10-09 19:52:38 +00001515 llvm::BasicBlock *createBasicBlock(const Twine &name = "",
John McCallad7c5c12011-02-08 08:22:06 +00001516 llvm::Function *parent = 0,
1517 llvm::BasicBlock *before = 0) {
Daniel Dunbar851eec12008-11-12 00:01:12 +00001518#ifdef NDEBUG
John McCallad7c5c12011-02-08 08:22:06 +00001519 return llvm::BasicBlock::Create(getLLVMContext(), "", parent, before);
Daniel Dunbar851eec12008-11-12 00:01:12 +00001520#else
John McCallad7c5c12011-02-08 08:22:06 +00001521 return llvm::BasicBlock::Create(getLLVMContext(), name, parent, before);
Daniel Dunbar851eec12008-11-12 00:01:12 +00001522#endif
Daniel Dunbar75283ff2008-11-11 02:29:29 +00001523 }
Mike Stumpfc496822009-02-08 23:14:22 +00001524
Chris Lattnerac248202007-05-30 00:13:02 +00001525 /// getBasicBlockForLabel - Return the LLVM basicblock that the specified
1526 /// label maps to.
Chris Lattnerc8e630e2011-02-17 07:39:24 +00001527 JumpDest getJumpDestForLabel(const LabelDecl *S);
Mike Stumpfc496822009-02-08 23:14:22 +00001528
Mike Stumpe5311b02009-11-30 20:08:49 +00001529 /// SimplifyForwardingBlocks - If the given basic block is only a branch to
1530 /// another basic block, simplify it. This assumes that no other code could
1531 /// potentially reference the basic block.
Daniel Dunbarf77e2922009-04-01 04:37:47 +00001532 void SimplifyForwardingBlocks(llvm::BasicBlock *BB);
1533
Mike Stumpfc496822009-02-08 23:14:22 +00001534 /// EmitBlock - Emit the given block \arg BB and set it as the insert point,
1535 /// adding a fall-through branch from the current insert block if
1536 /// necessary. It is legal to call this function even if there is no current
1537 /// insertion point.
Daniel Dunbarfcac22e2008-11-13 01:24:05 +00001538 ///
Mike Stumpfc496822009-02-08 23:14:22 +00001539 /// IsFinished - If true, indicates that the caller has finished emitting
1540 /// branches to the given block and does not expect to emit code into it. This
1541 /// means the block can be ignored if it is unreachable.
Daniel Dunbarfcac22e2008-11-13 01:24:05 +00001542 void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false);
Daniel Dunbar29ac59f2008-11-11 04:34:23 +00001543
John McCall8e4c74b2011-08-11 02:22:43 +00001544 /// EmitBlockAfterUses - Emit the given block somewhere hopefully
1545 /// near its uses, and leave the insertion point in it.
1546 void EmitBlockAfterUses(llvm::BasicBlock *BB);
1547
Mike Stumpfc496822009-02-08 23:14:22 +00001548 /// EmitBranch - Emit a branch to the specified basic block from the current
1549 /// insert block, taking care to avoid creation of branches from dummy
1550 /// blocks. It is legal to call this function even if there is no current
1551 /// insertion point.
Daniel Dunbarab197eb2008-11-11 22:06:59 +00001552 ///
Mike Stumpfc496822009-02-08 23:14:22 +00001553 /// This function clears the current insertion point. The caller should follow
1554 /// calls to this function with calls to Emit*Block prior to generation new
1555 /// code.
Daniel Dunbarc56e6762008-11-11 09:41:28 +00001556 void EmitBranch(llvm::BasicBlock *Block);
1557
Mike Stumpfc496822009-02-08 23:14:22 +00001558 /// HaveInsertPoint - True if an insertion point is defined. If not, this
1559 /// indicates that the current code being emitted is unreachable.
1560 bool HaveInsertPoint() const {
Daniel Dunbar5c7e3932008-11-11 23:11:34 +00001561 return Builder.GetInsertBlock() != 0;
1562 }
1563
Mike Stumpfc496822009-02-08 23:14:22 +00001564 /// EnsureInsertPoint - Ensure that an insertion point is defined so that
1565 /// emitted IR has a place to go. Note that by definition, if this function
1566 /// creates a block then that block is unreachable; callers may do better to
1567 /// detect when no insertion point is defined and simply skip IR generation.
Daniel Dunbar5c7e3932008-11-11 23:11:34 +00001568 void EnsureInsertPoint() {
1569 if (!HaveInsertPoint())
1570 EmitBlock(createBasicBlock());
1571 }
Mike Stumpfc496822009-02-08 23:14:22 +00001572
Daniel Dunbara7c8cf62008-08-16 00:56:44 +00001573 /// ErrorUnsupported - Print out an error that codegen doesn't support the
Chris Lattnerfc944342007-12-02 01:43:38 +00001574 /// specified stmt yet.
Daniel Dunbarf2cf6d12008-09-04 03:43:08 +00001575 void ErrorUnsupported(const Stmt *S, const char *Type,
1576 bool OmitOnError=false);
Chris Lattner84915fa2007-06-02 04:16:21 +00001577
Chris Lattnere9a64532007-06-22 21:44:33 +00001578 //===--------------------------------------------------------------------===//
1579 // Helpers
1580 //===--------------------------------------------------------------------===//
Mike Stumpfc496822009-02-08 23:14:22 +00001581
Eli Friedmana0544d62011-12-03 04:14:32 +00001582 LValue MakeAddrLValue(llvm::Value *V, QualType T,
1583 CharUnits Alignment = CharUnits()) {
Dan Gohman947c9af2010-10-14 23:06:10 +00001584 return LValue::MakeAddr(V, T, Alignment, getContext(),
1585 CGM.getTBAAInfo(T));
Daniel Dunbar93b00a92010-08-21 02:53:44 +00001586 }
John McCall4e8ca4f2012-07-02 23:58:38 +00001587
Eli Friedmand20adbd2011-11-16 00:42:57 +00001588 LValue MakeNaturalAlignAddrLValue(llvm::Value *V, QualType T) {
Eli Friedmana0544d62011-12-03 04:14:32 +00001589 CharUnits Alignment;
1590 if (!T->isIncompleteType())
1591 Alignment = getContext().getTypeAlignInChars(T);
Eli Friedmand20adbd2011-11-16 00:42:57 +00001592 return LValue::MakeAddr(V, T, Alignment, getContext(),
1593 CGM.getTBAAInfo(T));
1594 }
Daniel Dunbar93b00a92010-08-21 02:53:44 +00001595
Chris Lattnere9a64532007-06-22 21:44:33 +00001596 /// CreateTempAlloca - This creates a alloca and inserts it into the entry
Daniel Dunbara7566f12010-02-09 02:48:28 +00001597 /// block. The caller is responsible for setting an appropriate alignment on
1598 /// the alloca.
Chris Lattner2192fe52011-07-18 04:24:23 +00001599 llvm::AllocaInst *CreateTempAlloca(llvm::Type *Ty,
Chris Lattner62ff6e82011-07-20 07:06:53 +00001600 const Twine &Name = "tmp");
Mike Stumpfc496822009-02-08 23:14:22 +00001601
John McCall2e6567a2010-04-22 01:10:34 +00001602 /// InitTempAlloca - Provide an initial value for the given alloca.
1603 void InitTempAlloca(llvm::AllocaInst *Alloca, llvm::Value *Value);
1604
Daniel Dunbard0049182010-02-16 19:44:13 +00001605 /// CreateIRTemp - Create a temporary IR object of the given type, with
1606 /// appropriate alignment. This routine should only be used when an temporary
1607 /// value needs to be stored into an alloca (for example, to avoid explicit
1608 /// PHI construction), but the type is the IR type, not the type appropriate
1609 /// for storing in memory.
Chris Lattner62ff6e82011-07-20 07:06:53 +00001610 llvm::AllocaInst *CreateIRTemp(QualType T, const Twine &Name = "tmp");
Daniel Dunbard0049182010-02-16 19:44:13 +00001611
Daniel Dunbara7566f12010-02-09 02:48:28 +00001612 /// CreateMemTemp - Create a temporary memory object of the given type, with
1613 /// appropriate alignment.
Chris Lattner62ff6e82011-07-20 07:06:53 +00001614 llvm::AllocaInst *CreateMemTemp(QualType T, const Twine &Name = "tmp");
Daniel Dunbara7566f12010-02-09 02:48:28 +00001615
John McCall7a626f62010-09-15 10:14:12 +00001616 /// CreateAggTemp - Create a temporary memory object for the given
1617 /// aggregate type.
Chris Lattner62ff6e82011-07-20 07:06:53 +00001618 AggValueSlot CreateAggTemp(QualType T, const Twine &Name = "tmp") {
Eli Friedman38cd36d2011-12-03 02:13:40 +00001619 CharUnits Alignment = getContext().getTypeAlignInChars(T);
Eli Friedmanc1d85b92011-12-03 00:54:26 +00001620 return AggValueSlot::forAddr(CreateMemTemp(T, Name), Alignment,
1621 T.getQualifiers(),
John McCall8d6fc952011-08-25 20:40:09 +00001622 AggValueSlot::IsNotDestructed,
John McCalla5efa732011-08-25 23:04:34 +00001623 AggValueSlot::DoesNotNeedGCBarriers,
Chad Rosier615ed1a2012-03-29 17:37:10 +00001624 AggValueSlot::IsNotAliased);
John McCall7a626f62010-09-15 10:14:12 +00001625 }
1626
John McCallad7c5c12011-02-08 08:22:06 +00001627 /// Emit a cast to void* in the appropriate address space.
1628 llvm::Value *EmitCastToVoidPtr(llvm::Value *value);
1629
Chris Lattner8394d792007-06-05 20:53:16 +00001630 /// EvaluateExprAsBool - Perform the usual unary conversions on the specified
1631 /// expression and compare the result against zero, returning an Int1Ty value.
Chris Lattner23b7eb62007-06-15 23:05:46 +00001632 llvm::Value *EvaluateExprAsBool(const Expr *E);
Chris Lattnere9a64532007-06-22 21:44:33 +00001633
John McCalla2342eb2010-12-05 02:00:02 +00001634 /// EmitIgnoredExpr - Emit an expression in a context which ignores the result.
1635 void EmitIgnoredExpr(const Expr *E);
1636
Chris Lattner4647a212007-08-31 22:49:20 +00001637 /// EmitAnyExpr - Emit code to compute the specified expression which can have
1638 /// any type. The result is returned as an RValue struct. If this is an
1639 /// aggregate expression, the aggloc/agglocvolatile arguments indicate where
1640 /// the result should be returned.
Mike Stumpec3cbfe2009-05-26 22:03:21 +00001641 ///
Dmitri Gribenkoadba9be2012-08-23 17:58:28 +00001642 /// \param ignoreResult True if the resulting value isn't used.
John McCall7a626f62010-09-15 10:14:12 +00001643 RValue EmitAnyExpr(const Expr *E,
John McCall4e8ca4f2012-07-02 23:58:38 +00001644 AggValueSlot aggSlot = AggValueSlot::ignored(),
1645 bool ignoreResult = false);
Devang Patel8ec4f832007-09-28 21:49:18 +00001646
Mike Stumpfc496822009-02-08 23:14:22 +00001647 // EmitVAListRef - Emit a "reference" to a va_list; this is either the address
1648 // or the value of the expression, depending on how va_list is defined.
Eli Friedmanddea0ad2009-01-20 17:46:04 +00001649 llvm::Value *EmitVAListRef(const Expr *E);
1650
Mike Stumpfc496822009-02-08 23:14:22 +00001651 /// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result will
1652 /// always be accessible even if no aggregate location is provided.
John McCall7a626f62010-09-15 10:14:12 +00001653 RValue EmitAnyExprToTemp(const Expr *E);
Daniel Dunbar41cf9de2008-09-09 01:06:48 +00001654
John McCall91ca10f2011-03-08 09:11:50 +00001655 /// EmitAnyExprToMem - Emits the code necessary to evaluate an
Chad Rosier615ed1a2012-03-29 17:37:10 +00001656 /// arbitrary expression into the given memory location.
John McCall21886962010-04-21 10:05:39 +00001657 void EmitAnyExprToMem(const Expr *E, llvm::Value *Location,
Chad Rosier615ed1a2012-03-29 17:37:10 +00001658 Qualifiers Quals, bool IsInitializer);
John McCall21886962010-04-21 10:05:39 +00001659
John McCall91ca10f2011-03-08 09:11:50 +00001660 /// EmitExprAsInit - Emits the code necessary to initialize a
1661 /// location in memory with the given initializer.
John McCall31168b02011-06-15 23:02:42 +00001662 void EmitExprAsInit(const Expr *init, const ValueDecl *D,
John McCall1553b192011-06-16 04:16:24 +00001663 LValue lvalue, bool capturedByInit);
John McCall91ca10f2011-03-08 09:11:50 +00001664
Benjamin Kramer1ca66912012-09-30 12:43:37 +00001665 /// EmitAggregateCopy - Emit an aggrate assignment.
1666 ///
1667 /// The difference to EmitAggregateCopy is that tail padding is not copied.
1668 /// This is required for correctness when assigning non-POD structures in C++.
1669 void EmitAggregateAssign(llvm::Value *DestPtr, llvm::Value *SrcPtr,
1670 QualType EltTy, bool isVolatile=false,
1671 CharUnits Alignment = CharUnits::Zero()) {
1672 EmitAggregateCopy(DestPtr, SrcPtr, EltTy, isVolatile, Alignment, true);
1673 }
1674
Mike Stump5e9e61b2009-05-23 22:29:41 +00001675 /// EmitAggregateCopy - Emit an aggrate copy.
1676 ///
Sylvestre Ledru33b5baf2012-09-27 10:16:10 +00001677 /// \param isVolatile - True iff either the source or the destination is
Mike Stump5e9e61b2009-05-23 22:29:41 +00001678 /// volatile.
Benjamin Kramer1ca66912012-09-30 12:43:37 +00001679 /// \param isAssignment - If false, allow padding to be copied. This often
1680 /// yields more efficient.
Daniel Dunbar0bc8e862008-09-09 20:49:46 +00001681 void EmitAggregateCopy(llvm::Value *DestPtr, llvm::Value *SrcPtr,
Eli Friedman6d694a32011-12-05 22:23:28 +00001682 QualType EltTy, bool isVolatile=false,
Benjamin Kramer1ca66912012-09-30 12:43:37 +00001683 CharUnits Alignment = CharUnits::Zero(),
1684 bool isAssignment = false);
Daniel Dunbar0bc8e862008-09-09 20:49:46 +00001685
Devang Patelda5d6bb2007-10-04 23:45:31 +00001686 /// StartBlock - Start new block named N. If insert block is a dummy block
1687 /// then reuse it.
1688 void StartBlock(const char *N);
1689
Anders Carlsson9396a892008-09-11 09:15:33 +00001690 /// GetAddrOfLocalVar - Return the address of a local variable.
John McCall5d865c322010-08-31 07:33:07 +00001691 llvm::Value *GetAddrOfLocalVar(const VarDecl *VD) {
1692 llvm::Value *Res = LocalDeclMap[VD];
1693 assert(Res && "Invalid argument to GetAddrOfLocalVar(), no decl!");
1694 return Res;
1695 }
Mike Stumpfc496822009-02-08 23:14:22 +00001696
John McCallc07a0c72011-02-17 10:25:35 +00001697 /// getOpaqueLValueMapping - Given an opaque value expression (which
1698 /// must be mapped to an l-value), return its mapping.
1699 const LValue &getOpaqueLValueMapping(const OpaqueValueExpr *e) {
1700 assert(OpaqueValueMapping::shouldBindAsLValue(e));
1701
1702 llvm::DenseMap<const OpaqueValueExpr*,LValue>::iterator
1703 it = OpaqueLValues.find(e);
1704 assert(it != OpaqueLValues.end() && "no mapping for opaque value!");
1705 return it->second;
1706 }
1707
1708 /// getOpaqueRValueMapping - Given an opaque value expression (which
1709 /// must be mapped to an r-value), return its mapping.
1710 const RValue &getOpaqueRValueMapping(const OpaqueValueExpr *e) {
1711 assert(!OpaqueValueMapping::shouldBindAsLValue(e));
1712
1713 llvm::DenseMap<const OpaqueValueExpr*,RValue>::iterator
1714 it = OpaqueRValues.find(e);
1715 assert(it != OpaqueRValues.end() && "no mapping for opaque value!");
John McCall1bf58462011-02-16 08:02:54 +00001716 return it->second;
1717 }
1718
Dan Gohman75d69da2008-05-22 00:50:06 +00001719 /// getAccessedFieldNo - Given an encoded value and a result number, return
1720 /// the input field number being accessed.
1721 static unsigned getAccessedFieldNo(unsigned Idx, const llvm::Constant *Elts);
1722
Chris Lattnerc8e630e2011-02-17 07:39:24 +00001723 llvm::BlockAddress *GetAddrOfLabel(const LabelDecl *L);
Chris Lattner2bb5cb42009-10-13 06:55:33 +00001724 llvm::BasicBlock *GetIndirectGotoBlock();
Daniel Dunbar88402ce2008-08-04 16:51:22 +00001725
Anders Carlssonc0964b62010-05-22 17:35:42 +00001726 /// EmitNullInitialization - Generate code to set a value of the given type to
1727 /// null, If the type contains data member pointers, they will be initialized
1728 /// to -1 in accordance with the Itanium C++ ABI.
1729 void EmitNullInitialization(llvm::Value *DestPtr, QualType Ty);
Anders Carlsson13abd7e2008-11-04 05:30:00 +00001730
1731 // EmitVAArg - Generate code to get an argument from the passed in pointer
1732 // and update it accordingly. The return value is a pointer to the argument.
1733 // FIXME: We should be able to get rid of this method and use the va_arg
Mike Stumpfc496822009-02-08 23:14:22 +00001734 // instruction in LLVM instead once it works well enough.
Anders Carlsson13abd7e2008-11-04 05:30:00 +00001735 llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty);
Anders Carlssone388a5b2008-12-20 20:27:15 +00001736
John McCall82fe67b2011-07-09 01:37:26 +00001737 /// emitArrayLength - Compute the length of an array, even if it's a
1738 /// VLA, and drill down to the base element type.
1739 llvm::Value *emitArrayLength(const ArrayType *arrayType,
1740 QualType &baseType,
1741 llvm::Value *&addr);
1742
John McCall23c29fe2011-06-24 21:55:10 +00001743 /// EmitVLASize - Capture all the sizes for the VLA expressions in
1744 /// the given variably-modified type and store them in the VLASizeMap.
Daniel Dunbarb6adc432009-07-19 06:58:07 +00001745 ///
1746 /// This function can be called with a null (unreachable) insert point.
John McCall23c29fe2011-06-24 21:55:10 +00001747 void EmitVariablyModifiedType(QualType Ty);
Mike Stumpfc496822009-02-08 23:14:22 +00001748
John McCall23c29fe2011-06-24 21:55:10 +00001749 /// getVLASize - Returns an LLVM value that corresponds to the size,
1750 /// in non-variably-sized elements, of a variable length array type,
1751 /// plus that largest non-variably-sized element type. Assumes that
1752 /// the type has already been emitted with EmitVariablyModifiedType.
1753 std::pair<llvm::Value*,QualType> getVLASize(const VariableArrayType *vla);
1754 std::pair<llvm::Value*,QualType> getVLASize(QualType vla);
Anders Carlssonccbe9202008-12-12 07:19:02 +00001755
Anders Carlssona5d077d2009-04-14 16:58:56 +00001756 /// LoadCXXThis - Load the value of 'this'. This function is only valid while
1757 /// generating code for an C++ member function.
John McCall347132b2010-02-16 22:04:33 +00001758 llvm::Value *LoadCXXThis() {
1759 assert(CXXThisValue && "no 'this' value for this function");
1760 return CXXThisValue;
1761 }
Mike Stump11289f42009-09-09 15:08:12 +00001762
Anders Carlssone36a6b32010-01-02 01:01:18 +00001763 /// LoadCXXVTT - Load the VTT parameter to base constructors/destructors have
1764 /// virtual bases.
John McCall347132b2010-02-16 22:04:33 +00001765 llvm::Value *LoadCXXVTT() {
1766 assert(CXXVTTValue && "no VTT value for this function");
1767 return CXXVTTValue;
1768 }
John McCall6ce74722010-02-16 04:15:37 +00001769
1770 /// GetAddressOfBaseOfCompleteClass - Convert the given pointer to a
Anders Carlssonc4ba0cd2010-04-24 23:01:49 +00001771 /// complete class to the given direct base.
1772 llvm::Value *
1773 GetAddressOfDirectBaseInCompleteClass(llvm::Value *Value,
1774 const CXXRecordDecl *Derived,
1775 const CXXRecordDecl *Base,
1776 bool BaseIsVirtual);
Anders Carlssonbea9e742010-04-24 21:51:08 +00001777
Mike Stumpe5311b02009-11-30 20:08:49 +00001778 /// GetAddressOfBaseClass - This function will add the necessary delta to the
1779 /// load of 'this' and returns address of the base class.
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001780 llvm::Value *GetAddressOfBaseClass(llvm::Value *Value,
Anders Carlssonc4ba0cd2010-04-24 23:01:49 +00001781 const CXXRecordDecl *Derived,
John McCallcf142162010-08-07 06:22:56 +00001782 CastExpr::path_const_iterator PathBegin,
1783 CastExpr::path_const_iterator PathEnd,
Anders Carlssond829a022010-04-24 21:06:20 +00001784 bool NullCheckValue);
1785
Anders Carlsson8c793172009-11-23 17:57:54 +00001786 llvm::Value *GetAddressOfDerivedClass(llvm::Value *Value,
Anders Carlssonc4ba0cd2010-04-24 23:01:49 +00001787 const CXXRecordDecl *Derived,
John McCallcf142162010-08-07 06:22:56 +00001788 CastExpr::path_const_iterator PathBegin,
1789 CastExpr::path_const_iterator PathEnd,
Anders Carlsson8c793172009-11-23 17:57:54 +00001790 bool NullCheckValue);
1791
Anders Carlsson84673e22010-01-31 01:36:53 +00001792 llvm::Value *GetVirtualBaseClassOffset(llvm::Value *This,
1793 const CXXRecordDecl *ClassDecl,
1794 const CXXRecordDecl *BaseClassDecl);
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001795
John McCallf8ff7b92010-02-23 00:48:20 +00001796 void EmitDelegateCXXConstructorCall(const CXXConstructorDecl *Ctor,
1797 CXXCtorType CtorType,
1798 const FunctionArgList &Args);
Alexis Hunt61bc1732011-05-01 07:04:31 +00001799 // It's important not to confuse this and the previous function. Delegating
1800 // constructors are the C++0x feature. The constructor delegate optimization
1801 // is used to reduce duplication in the base and complete consturctors where
1802 // they are substantially the same.
1803 void EmitDelegatingCXXConstructorCall(const CXXConstructorDecl *Ctor,
1804 const FunctionArgList &Args);
Anders Carlssone11f9ce2010-05-02 23:20:53 +00001805 void EmitCXXConstructorCall(const CXXConstructorDecl *D, CXXCtorType Type,
1806 bool ForVirtualBase, llvm::Value *This,
Anders Carlssonb7f8f592009-04-17 00:06:03 +00001807 CallExpr::const_arg_iterator ArgBeg,
1808 CallExpr::const_arg_iterator ArgEnd);
Fariborz Jahaniane988bda2010-11-13 21:53:34 +00001809
1810 void EmitSynthesizedCXXCopyCtorCall(const CXXConstructorDecl *D,
1811 llvm::Value *This, llvm::Value *Src,
1812 CallExpr::const_arg_iterator ArgBeg,
1813 CallExpr::const_arg_iterator ArgEnd);
Mike Stump11289f42009-09-09 15:08:12 +00001814
Fariborz Jahanian431c8832009-08-19 20:55:16 +00001815 void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D,
Anders Carlssond49844b2009-09-23 02:45:36 +00001816 const ConstantArrayType *ArrayTy,
Anders Carlsson3a202f62009-11-24 18:43:52 +00001817 llvm::Value *ArrayPtr,
1818 CallExpr::const_arg_iterator ArgBeg,
Douglas Gregor05fc5be2010-07-21 01:10:17 +00001819 CallExpr::const_arg_iterator ArgEnd,
1820 bool ZeroInitialization = false);
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001821
Anders Carlssond49844b2009-09-23 02:45:36 +00001822 void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D,
1823 llvm::Value *NumElements,
Anders Carlsson3a202f62009-11-24 18:43:52 +00001824 llvm::Value *ArrayPtr,
1825 CallExpr::const_arg_iterator ArgBeg,
Douglas Gregor05fc5be2010-07-21 01:10:17 +00001826 CallExpr::const_arg_iterator ArgEnd,
1827 bool ZeroInitialization = false);
Anders Carlssonb7f8f592009-04-17 00:06:03 +00001828
John McCall82fe67b2011-07-09 01:37:26 +00001829 static Destroyer destroyCXXObject;
1830
Anders Carlsson0a637412009-05-29 21:03:38 +00001831 void EmitCXXDestructorCall(const CXXDestructorDecl *D, CXXDtorType Type,
Anders Carlssonf8a71f02010-05-02 23:29:11 +00001832 bool ForVirtualBase, llvm::Value *This);
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00001833
John McCall99210dc2011-09-15 06:49:18 +00001834 void EmitNewArrayInitializer(const CXXNewExpr *E, QualType elementType,
1835 llvm::Value *NewPtr, llvm::Value *NumElements);
Mike Stump11289f42009-09-09 15:08:12 +00001836
Peter Collingbourne702b2842011-11-27 22:09:22 +00001837 void EmitCXXTemporary(const CXXTemporary *Temporary, QualType TempType,
1838 llvm::Value *Ptr);
Mike Stump11289f42009-09-09 15:08:12 +00001839
Anders Carlsson4a7b49b2009-05-31 01:40:14 +00001840 llvm::Value *EmitCXXNewExpr(const CXXNewExpr *E);
Anders Carlsson81f0df92009-08-16 21:13:42 +00001841 void EmitCXXDeleteExpr(const CXXDeleteExpr *E);
Mike Stump11289f42009-09-09 15:08:12 +00001842
Eli Friedman24f55432009-11-18 00:57:03 +00001843 void EmitDeleteCall(const FunctionDecl *DeleteFD, llvm::Value *Ptr,
1844 QualType DeleteTy);
1845
Mike Stumpc9b231c2009-11-15 08:09:41 +00001846 llvm::Value* EmitCXXTypeidExpr(const CXXTypeidExpr *E);
Mike Stump65511702009-11-16 06:50:58 +00001847 llvm::Value *EmitDynamicCast(llvm::Value *V, const CXXDynamicCastExpr *DCE);
Nico Webercf4ff5862012-10-11 10:13:44 +00001848 llvm::Value* EmitCXXUuidofExpr(const CXXUuidofExpr *E);
Mike Stumpc9b231c2009-11-15 08:09:41 +00001849
Sebastian Redld026dc42012-02-19 16:03:09 +00001850 void MaybeEmitStdInitializerListCleanup(llvm::Value *loc, const Expr *init);
Sebastian Redl8eb351d2012-02-19 12:28:02 +00001851 void EmitStdInitializerListCleanup(llvm::Value *loc,
1852 const InitListExpr *init);
Sebastian Redlc83ed822012-02-17 08:42:25 +00001853
Richard Smith69d0d262012-08-24 00:54:33 +00001854 /// \brief Situations in which we might emit a check for the suitability of a
1855 /// pointer or glvalue.
Richard Smith4d1458e2012-09-08 02:08:36 +00001856 enum TypeCheckKind {
Richard Smith69d0d262012-08-24 00:54:33 +00001857 /// Checking the operand of a load. Must be suitably sized and aligned.
Richard Smith4d1458e2012-09-08 02:08:36 +00001858 TCK_Load,
Richard Smith69d0d262012-08-24 00:54:33 +00001859 /// Checking the destination of a store. Must be suitably sized and aligned.
Richard Smith4d1458e2012-09-08 02:08:36 +00001860 TCK_Store,
Richard Smith69d0d262012-08-24 00:54:33 +00001861 /// Checking the bound value in a reference binding. Must be suitably sized
1862 /// and aligned, but is not required to refer to an object (until the
1863 /// reference is used), per core issue 453.
Richard Smith4d1458e2012-09-08 02:08:36 +00001864 TCK_ReferenceBinding,
Richard Smith69d0d262012-08-24 00:54:33 +00001865 /// Checking the object expression in a non-static data member access. Must
1866 /// be an object within its lifetime.
Richard Smith4d1458e2012-09-08 02:08:36 +00001867 TCK_MemberAccess,
Richard Smith69d0d262012-08-24 00:54:33 +00001868 /// Checking the 'this' pointer for a call to a non-static member function.
1869 /// Must be an object within its lifetime.
Richard Smith4d3110a2012-10-25 02:14:12 +00001870 TCK_MemberCall,
1871 /// Checking the 'this' pointer for a constructor call.
1872 TCK_ConstructorCall
Richard Smith69d0d262012-08-24 00:54:33 +00001873 };
1874
Richard Smith4d1458e2012-09-08 02:08:36 +00001875 /// \brief Emit a check that \p V is the address of storage of the
Richard Smith69d0d262012-08-24 00:54:33 +00001876 /// appropriate size and alignment for an object of type \p Type.
Richard Smithe30752c2012-10-09 19:52:38 +00001877 void EmitTypeCheck(TypeCheckKind TCK, SourceLocation Loc, llvm::Value *V,
Richard Smith4d1458e2012-09-08 02:08:36 +00001878 QualType Type, CharUnits Alignment = CharUnits::Zero());
Mike Stump3f6f9fe2009-12-16 02:57:00 +00001879
Chris Lattner116ce8f2010-01-09 21:40:03 +00001880 llvm::Value *EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV,
1881 bool isInc, bool isPre);
1882 ComplexPairTy EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV,
1883 bool isInc, bool isPre);
Chris Lattner8394d792007-06-05 20:53:16 +00001884 //===--------------------------------------------------------------------===//
Chris Lattner53621a52007-06-13 20:44:40 +00001885 // Declaration Emission
Chris Lattner84915fa2007-06-02 04:16:21 +00001886 //===--------------------------------------------------------------------===//
Mike Stumpfc496822009-02-08 23:14:22 +00001887
Daniel Dunbarb6adc432009-07-19 06:58:07 +00001888 /// EmitDecl - Emit a declaration.
1889 ///
1890 /// This function can be called with a null (unreachable) insert point.
Chris Lattner1ad38f82007-06-09 01:20:56 +00001891 void EmitDecl(const Decl &D);
Daniel Dunbarb6adc432009-07-19 06:58:07 +00001892
John McCall1c9c3fd2010-10-15 04:57:14 +00001893 /// EmitVarDecl - Emit a local variable declaration.
Daniel Dunbarb6adc432009-07-19 06:58:07 +00001894 ///
1895 /// This function can be called with a null (unreachable) insert point.
John McCall1c9c3fd2010-10-15 04:57:14 +00001896 void EmitVarDecl(const VarDecl &D);
Daniel Dunbarb6adc432009-07-19 06:58:07 +00001897
John McCall31168b02011-06-15 23:02:42 +00001898 void EmitScalarInit(const Expr *init, const ValueDecl *D,
John McCall1553b192011-06-16 04:16:24 +00001899 LValue lvalue, bool capturedByInit);
John McCalld4631322011-06-17 06:42:21 +00001900 void EmitScalarInit(llvm::Value *init, LValue lvalue);
John McCall31168b02011-06-15 23:02:42 +00001901
John McCallbd309292010-07-06 01:34:17 +00001902 typedef void SpecialInitFn(CodeGenFunction &Init, const VarDecl &D,
1903 llvm::Value *Address);
1904
John McCall1c9c3fd2010-10-15 04:57:14 +00001905 /// EmitAutoVarDecl - Emit an auto variable declaration.
Daniel Dunbarb6adc432009-07-19 06:58:07 +00001906 ///
1907 /// This function can be called with a null (unreachable) insert point.
John McCallc533cb72011-02-22 06:44:22 +00001908 void EmitAutoVarDecl(const VarDecl &D);
1909
1910 class AutoVarEmission {
1911 friend class CodeGenFunction;
1912
John McCall9e2e22f2011-02-22 07:16:58 +00001913 const VarDecl *Variable;
John McCallc533cb72011-02-22 06:44:22 +00001914
1915 /// The alignment of the variable.
1916 CharUnits Alignment;
1917
1918 /// The address of the alloca. Null if the variable was emitted
1919 /// as a global constant.
1920 llvm::Value *Address;
1921
1922 llvm::Value *NRVOFlag;
1923
1924 /// True if the variable is a __block variable.
1925 bool IsByRef;
1926
1927 /// True if the variable is of aggregate type and has a constant
1928 /// initializer.
1929 bool IsConstantAggregate;
1930
John McCall9e2e22f2011-02-22 07:16:58 +00001931 struct Invalid {};
1932 AutoVarEmission(Invalid) : Variable(0) {}
1933
John McCallc533cb72011-02-22 06:44:22 +00001934 AutoVarEmission(const VarDecl &variable)
John McCall9e2e22f2011-02-22 07:16:58 +00001935 : Variable(&variable), Address(0), NRVOFlag(0),
John McCallc533cb72011-02-22 06:44:22 +00001936 IsByRef(false), IsConstantAggregate(false) {}
1937
1938 bool wasEmittedAsGlobal() const { return Address == 0; }
1939
1940 public:
John McCall9e2e22f2011-02-22 07:16:58 +00001941 static AutoVarEmission invalid() { return AutoVarEmission(Invalid()); }
1942
John McCallc533cb72011-02-22 06:44:22 +00001943 /// Returns the address of the object within this declaration.
1944 /// Note that this does not chase the forwarding pointer for
1945 /// __block decls.
1946 llvm::Value *getObjectAddress(CodeGenFunction &CGF) const {
1947 if (!IsByRef) return Address;
1948
1949 return CGF.Builder.CreateStructGEP(Address,
John McCall9e2e22f2011-02-22 07:16:58 +00001950 CGF.getByRefValueLLVMField(Variable),
1951 Variable->getNameAsString());
John McCallc533cb72011-02-22 06:44:22 +00001952 }
1953 };
1954 AutoVarEmission EmitAutoVarAlloca(const VarDecl &var);
1955 void EmitAutoVarInit(const AutoVarEmission &emission);
1956 void EmitAutoVarCleanups(const AutoVarEmission &emission);
John McCall82fe67b2011-07-09 01:37:26 +00001957 void emitAutoVarTypeCleanup(const AutoVarEmission &emission,
1958 QualType::DestructionKind dtorKind);
Daniel Dunbarb6adc432009-07-19 06:58:07 +00001959
John McCall1c9c3fd2010-10-15 04:57:14 +00001960 void EmitStaticVarDecl(const VarDecl &D,
1961 llvm::GlobalValue::LinkageTypes Linkage);
Daniel Dunbara94ecd22008-08-16 03:19:19 +00001962
1963 /// EmitParmDecl - Emit a ParmVarDecl or an ImplicitParamDecl.
Devang Patel68a15252011-03-03 20:13:15 +00001964 void EmitParmDecl(const VarDecl &D, llvm::Value *Arg, unsigned ArgNo);
Mike Stumpfc496822009-02-08 23:14:22 +00001965
John McCallc07a0c72011-02-17 10:25:35 +00001966 /// protectFromPeepholes - Protect a value that we're intending to
1967 /// store to the side, but which will probably be used later, from
1968 /// aggressive peepholing optimizations that might delete it.
1969 ///
1970 /// Pass the result to unprotectFromPeepholes to declare that
1971 /// protection is no longer required.
1972 ///
1973 /// There's no particular reason why this shouldn't apply to
1974 /// l-values, it's just that no existing peepholes work on pointers.
1975 PeepholeProtection protectFromPeepholes(RValue rvalue);
1976 void unprotectFromPeepholes(PeepholeProtection protection);
1977
Chris Lattner84915fa2007-06-02 04:16:21 +00001978 //===--------------------------------------------------------------------===//
Chris Lattner308f4312007-05-29 23:50:05 +00001979 // Statement Emission
1980 //===--------------------------------------------------------------------===//
1981
Mike Stumpfc496822009-02-08 23:14:22 +00001982 /// EmitStopPoint - Emit a debug stoppoint if we are emitting debug info.
Daniel Dunbar5fc28712008-11-12 08:21:33 +00001983 void EmitStopPoint(const Stmt *S);
1984
Mike Stumpfc496822009-02-08 23:14:22 +00001985 /// EmitStmt - Emit the code for the statement \arg S. It is legal to call
1986 /// this function even if there is no current insertion point.
1987 ///
1988 /// This function may clear the current insertion point; callers should use
1989 /// EnsureInsertPoint if they wish to subsequently generate code without first
1990 /// calling EmitBlock, EmitBranch, or EmitStmt.
Chris Lattner308f4312007-05-29 23:50:05 +00001991 void EmitStmt(const Stmt *S);
Daniel Dunbar5c7e3932008-11-11 23:11:34 +00001992
Daniel Dunbar5fc28712008-11-12 08:21:33 +00001993 /// EmitSimpleStmt - Try to emit a "simple" statement which does not
Mike Stumpfc496822009-02-08 23:14:22 +00001994 /// necessarily require an insertion point or debug information; typically
1995 /// because the statement amounts to a jump or a container of other
1996 /// statements.
Daniel Dunbar5fc28712008-11-12 08:21:33 +00001997 ///
1998 /// \return True if the statement was handled.
1999 bool EmitSimpleStmt(const Stmt *S);
2000
Chris Lattner4647a212007-08-31 22:49:20 +00002001 RValue EmitCompoundStmt(const CompoundStmt &S, bool GetLast = false,
John McCall7a626f62010-09-15 10:14:12 +00002002 AggValueSlot AVS = AggValueSlot::ignored());
Daniel Dunbar5c7e3932008-11-11 23:11:34 +00002003
Mike Stumpfc496822009-02-08 23:14:22 +00002004 /// EmitLabel - Emit the block for the given label. It is legal to call this
2005 /// function even if there is no current insertion point.
Chris Lattnerc8e630e2011-02-17 07:39:24 +00002006 void EmitLabel(const LabelDecl *D); // helper for EmitLabelStmt.
Daniel Dunbar5c7e3932008-11-11 23:11:34 +00002007
Chris Lattnerac248202007-05-30 00:13:02 +00002008 void EmitLabelStmt(const LabelStmt &S);
Richard Smithc202b282012-04-14 00:33:13 +00002009 void EmitAttributedStmt(const AttributedStmt &S);
Chris Lattnerac248202007-05-30 00:13:02 +00002010 void EmitGotoStmt(const GotoStmt &S);
Daniel Dunbar88402ce2008-08-04 16:51:22 +00002011 void EmitIndirectGotoStmt(const IndirectGotoStmt &S);
Chris Lattner5269c032007-05-30 21:03:58 +00002012 void EmitIfStmt(const IfStmt &S);
Chris Lattner946aa312007-06-05 03:59:43 +00002013 void EmitWhileStmt(const WhileStmt &S);
Chris Lattner8394d792007-06-05 20:53:16 +00002014 void EmitDoStmt(const DoStmt &S);
2015 void EmitForStmt(const ForStmt &S);
Chris Lattner3f3dbee2007-06-02 03:19:07 +00002016 void EmitReturnStmt(const ReturnStmt &S);
Chris Lattner1ad38f82007-06-09 01:20:56 +00002017 void EmitDeclStmt(const DeclStmt &S);
Daniel Dunbar5fc28712008-11-12 08:21:33 +00002018 void EmitBreakStmt(const BreakStmt &S);
2019 void EmitContinueStmt(const ContinueStmt &S);
Devang Patelda5d6bb2007-10-04 23:45:31 +00002020 void EmitSwitchStmt(const SwitchStmt &S);
2021 void EmitDefaultStmt(const DefaultStmt &S);
2022 void EmitCaseStmt(const CaseStmt &S);
Devang Patel11663122007-10-08 20:57:48 +00002023 void EmitCaseStmtRange(const CaseStmt &S);
Chad Rosier6051bb92012-08-28 18:54:39 +00002024 void EmitAsmStmt(const AsmStmt &S);
Mike Stumpfc496822009-02-08 23:14:22 +00002025
Anders Carlsson2e744e82008-08-30 19:51:14 +00002026 void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S);
Anders Carlsson1963b0c2008-09-09 10:04:29 +00002027 void EmitObjCAtTryStmt(const ObjCAtTryStmt &S);
2028 void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S);
Chris Lattnere132e242008-11-15 21:26:17 +00002029 void EmitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt &S);
John McCall31168b02011-06-15 23:02:42 +00002030 void EmitObjCAutoreleasePoolStmt(const ObjCAutoreleasePoolStmt &S);
Mike Stumpfc496822009-02-08 23:14:22 +00002031
John McCall9b382dd2011-05-28 21:13:02 +00002032 llvm::Constant *getUnwindResumeFn();
Douglas Gregor51150ab2010-05-16 01:24:12 +00002033 llvm::Constant *getUnwindResumeOrRethrowFn();
John McCallb609d3f2010-07-07 06:56:46 +00002034 void EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock = false);
2035 void ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock = false);
John McCallb81884d2010-02-19 09:25:03 +00002036
Anders Carlsson52d78a52009-09-27 18:58:34 +00002037 void EmitCXXTryStmt(const CXXTryStmt &S);
Richard Smith02e85f32011-04-14 22:09:26 +00002038 void EmitCXXForRangeStmt(const CXXForRangeStmt &S);
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00002039
Chris Lattner208ae962007-05-30 17:57:17 +00002040 //===--------------------------------------------------------------------===//
Chris Lattnerd7f58862007-06-02 05:24:33 +00002041 // LValue Expression Emission
2042 //===--------------------------------------------------------------------===//
Chris Lattner8394d792007-06-05 20:53:16 +00002043
Daniel Dunbarc79407f2009-02-05 07:09:07 +00002044 /// GetUndefRValue - Get an appropriate 'undef' rvalue for the given type.
2045 RValue GetUndefRValue(QualType Ty);
2046
Daniel Dunbarbb197e42009-01-09 16:50:52 +00002047 /// EmitUnsupportedRValue - Emit a dummy r-value using the type of E
2048 /// and issue an ErrorUnsupported style diagnostic (using the
2049 /// provided Name).
2050 RValue EmitUnsupportedRValue(const Expr *E,
2051 const char *Name);
2052
Mike Stumpfc496822009-02-08 23:14:22 +00002053 /// EmitUnsupportedLValue - Emit a dummy l-value using the type of E and issue
2054 /// an ErrorUnsupported style diagnostic (using the provided Name).
Daniel Dunbarf2e69882008-08-25 20:45:57 +00002055 LValue EmitUnsupportedLValue(const Expr *E,
2056 const char *Name);
2057
Chris Lattner8394d792007-06-05 20:53:16 +00002058 /// EmitLValue - Emit code to compute a designator that specifies the location
2059 /// of the expression.
2060 ///
2061 /// This can return one of two things: a simple address or a bitfield
2062 /// reference. In either case, the LLVM Value* in the LValue structure is
2063 /// guaranteed to be an LLVM pointer type.
2064 ///
2065 /// If this returns a bitfield reference, nothing about the pointee type of
2066 /// the LLVM value is known: For example, it may not be a pointer to an
2067 /// integer.
2068 ///
2069 /// If this returns a normal address, and if the lvalue's C type is fixed
2070 /// size, this method guarantees that the returned pointer type will point to
2071 /// an LLVM type of the same size of the lvalue's type. If the lvalue has a
2072 /// variable length type, this is not possible.
2073 ///
Chris Lattnerd7f58862007-06-02 05:24:33 +00002074 LValue EmitLValue(const Expr *E);
Mike Stumpfc496822009-02-08 23:14:22 +00002075
Richard Smith4d1458e2012-09-08 02:08:36 +00002076 /// \brief Same as EmitLValue but additionally we generate checking code to
2077 /// guard against undefined behavior. This is only suitable when we know
2078 /// that the address will be used to access the object.
2079 LValue EmitCheckedLValue(const Expr *E, TypeCheckKind TCK);
Mike Stump3f6f9fe2009-12-16 02:57:00 +00002080
John McCall3a7f6922010-10-27 20:58:56 +00002081 /// EmitToMemory - Change a scalar value from its value
2082 /// representation to its in-memory representation.
2083 llvm::Value *EmitToMemory(llvm::Value *Value, QualType Ty);
2084
2085 /// EmitFromMemory - Change a scalar value from its memory
2086 /// representation to its value representation.
2087 llvm::Value *EmitFromMemory(llvm::Value *Value, QualType Ty);
2088
Daniel Dunbar1d425462009-02-10 00:57:50 +00002089 /// EmitLoadOfScalar - Load a scalar value from an address, taking
2090 /// care to appropriately convert from the memory representation to
2091 /// the LLVM value representation.
Mike Stumpc6ea7c12009-02-17 17:00:02 +00002092 llvm::Value *EmitLoadOfScalar(llvm::Value *Addr, bool Volatile,
Dan Gohman947c9af2010-10-14 23:06:10 +00002093 unsigned Alignment, QualType Ty,
2094 llvm::MDNode *TBAAInfo = 0);
John McCall55e1fbc2011-06-25 02:11:03 +00002095
2096 /// EmitLoadOfScalar - Load a scalar value from an address, taking
2097 /// care to appropriately convert from the memory representation to
2098 /// the LLVM value representation. The l-value must be a simple
2099 /// l-value.
John McCall1553b192011-06-16 04:16:24 +00002100 llvm::Value *EmitLoadOfScalar(LValue lvalue);
Daniel Dunbar1d425462009-02-10 00:57:50 +00002101
2102 /// EmitStoreOfScalar - Store a scalar value to an address, taking
2103 /// care to appropriately convert from the memory representation to
2104 /// the LLVM value representation.
Mike Stumpc6ea7c12009-02-17 17:00:02 +00002105 void EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr,
Dan Gohman947c9af2010-10-14 23:06:10 +00002106 bool Volatile, unsigned Alignment, QualType Ty,
David Chisnallfa35df62012-01-16 17:27:18 +00002107 llvm::MDNode *TBAAInfo = 0, bool isInit=false);
John McCall55e1fbc2011-06-25 02:11:03 +00002108
2109 /// EmitStoreOfScalar - Store a scalar value to an address, taking
2110 /// care to appropriately convert from the memory representation to
2111 /// the LLVM value representation. The l-value must be a simple
David Chisnallfa35df62012-01-16 17:27:18 +00002112 /// l-value. The isInit flag indicates whether this is an initialization.
2113 /// If so, atomic qualifiers are ignored and the store is always non-atomic.
2114 void EmitStoreOfScalar(llvm::Value *value, LValue lvalue, bool isInit=false);
Daniel Dunbar1d425462009-02-10 00:57:50 +00002115
Chris Lattner8394d792007-06-05 20:53:16 +00002116 /// EmitLoadOfLValue - Given an expression that represents a value lvalue,
2117 /// this method emits the address of the lvalue, then loads the result as an
2118 /// rvalue, returning the rvalue.
John McCall55e1fbc2011-06-25 02:11:03 +00002119 RValue EmitLoadOfLValue(LValue V);
2120 RValue EmitLoadOfExtVectorElementLValue(LValue V);
2121 RValue EmitLoadOfBitfieldLValue(LValue LV);
Mike Stumpfc496822009-02-08 23:14:22 +00002122
Chris Lattner8394d792007-06-05 20:53:16 +00002123 /// EmitStoreThroughLValue - Store the specified rvalue into the specified
2124 /// lvalue, where both are guaranteed to the have the same type, and that type
2125 /// is 'Ty'.
David Chisnallfa35df62012-01-16 17:27:18 +00002126 void EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit=false);
John McCall55e1fbc2011-06-25 02:11:03 +00002127 void EmitStoreThroughExtVectorComponentLValue(RValue Src, LValue Dst);
Daniel Dunbar9b1335e2008-11-19 09:36:46 +00002128
Mike Stumpfc496822009-02-08 23:14:22 +00002129 /// EmitStoreThroughLValue - Store Src into Dst with same constraints as
2130 /// EmitStoreThroughLValue.
Daniel Dunbar9b1335e2008-11-19 09:36:46 +00002131 ///
Mike Stumpfc496822009-02-08 23:14:22 +00002132 /// \param Result [out] - If non-null, this will be set to a Value* for the
2133 /// bit-field contents after the store, appropriate for use as the result of
2134 /// an assignment to the bit-field.
John McCall55e1fbc2011-06-25 02:11:03 +00002135 void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst,
Daniel Dunbar9b1335e2008-11-19 09:36:46 +00002136 llvm::Value **Result=0);
Mike Stumpfc496822009-02-08 23:14:22 +00002137
John McCall4f29b492010-11-16 23:07:28 +00002138 /// Emit an l-value for an assignment (simple or compound) of complex type.
2139 LValue EmitComplexAssignmentLValue(const BinaryOperator *E);
John McCalla2342eb2010-12-05 02:00:02 +00002140 LValue EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E);
John McCall4f29b492010-11-16 23:07:28 +00002141
Chris Lattner57540c52011-04-15 05:22:18 +00002142 // Note: only available for agg return types
Daniel Dunbar8cde00a2008-09-04 03:20:13 +00002143 LValue EmitBinaryOperatorLValue(const BinaryOperator *E);
John McCalla2342eb2010-12-05 02:00:02 +00002144 LValue EmitCompoundAssignmentLValue(const CompoundAssignOperator *E);
Daniel Dunbar8d9dc4a2009-02-11 20:59:32 +00002145 // Note: only available for agg return types
Christopher Lambd91c3d42007-12-29 05:02:41 +00002146 LValue EmitCallExprLValue(const CallExpr *E);
Daniel Dunbar8d9dc4a2009-02-11 20:59:32 +00002147 // Note: only available for agg return types
2148 LValue EmitVAArgExprLValue(const VAArgExpr *E);
Chris Lattnerd7f58862007-06-02 05:24:33 +00002149 LValue EmitDeclRefLValue(const DeclRefExpr *E);
Chris Lattner4347e3692007-06-06 04:54:52 +00002150 LValue EmitStringLiteralLValue(const StringLiteral *E);
Chris Lattnerd7e7b8e2009-02-24 22:18:39 +00002151 LValue EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E);
Chris Lattner6307f192008-08-10 01:53:14 +00002152 LValue EmitPredefinedLValue(const PredefinedExpr *E);
Chris Lattner8394d792007-06-05 20:53:16 +00002153 LValue EmitUnaryOpLValue(const UnaryOperator *E);
Chris Lattnerd9d2fb12007-06-08 23:31:14 +00002154 LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E);
Nate Begemance4d7fc2008-04-18 23:10:10 +00002155 LValue EmitExtVectorElementExpr(const ExtVectorElementExpr *E);
Devang Patel3e11cce2007-10-23 02:10:49 +00002156 LValue EmitMemberExpr(const MemberExpr *E);
Fariborz Jahanian531c16f2009-12-09 23:35:29 +00002157 LValue EmitObjCIsaExpr(const ObjCIsaExpr *E);
Eli Friedman9fd8b682008-05-13 23:18:27 +00002158 LValue EmitCompoundLiteralLValue(const CompoundLiteralExpr *E);
Richard Smithbb653bd2012-05-14 21:57:21 +00002159 LValue EmitInitListLValue(const InitListExpr *E);
John McCallc07a0c72011-02-17 10:25:35 +00002160 LValue EmitConditionalOperatorLValue(const AbstractConditionalOperator *E);
Chris Lattner28bcf1a2009-03-18 18:28:57 +00002161 LValue EmitCastLValue(const CastExpr *E);
Douglas Gregor747eb782010-07-08 06:14:04 +00002162 LValue EmitNullInitializationLValue(const CXXScalarValueInitExpr *E);
Douglas Gregorfe314812011-06-21 17:03:29 +00002163 LValue EmitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E);
John McCall1bf58462011-02-16 08:02:54 +00002164 LValue EmitOpaqueValueLValue(const OpaqueValueExpr *e);
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00002165
Eli Friedman7f1ff602012-04-16 03:54:45 +00002166 RValue EmitRValueForField(LValue LV, const FieldDecl *FD);
Anton Korobeynikov4215ca72012-04-13 11:22:00 +00002167
John McCall71335052012-03-10 03:05:10 +00002168 class ConstantEmission {
2169 llvm::PointerIntPair<llvm::Constant*, 1, bool> ValueAndIsReference;
2170 ConstantEmission(llvm::Constant *C, bool isReference)
2171 : ValueAndIsReference(C, isReference) {}
2172 public:
2173 ConstantEmission() {}
2174 static ConstantEmission forReference(llvm::Constant *C) {
2175 return ConstantEmission(C, true);
2176 }
2177 static ConstantEmission forValue(llvm::Constant *C) {
2178 return ConstantEmission(C, false);
2179 }
2180
2181 operator bool() const { return ValueAndIsReference.getOpaqueValue() != 0; }
2182
2183 bool isReference() const { return ValueAndIsReference.getInt(); }
2184 LValue getReferenceLValue(CodeGenFunction &CGF, Expr *refExpr) const {
2185 assert(isReference());
2186 return CGF.MakeNaturalAlignAddrLValue(ValueAndIsReference.getPointer(),
2187 refExpr->getType());
2188 }
2189
2190 llvm::Constant *getValue() const {
2191 assert(!isReference());
2192 return ValueAndIsReference.getPointer();
2193 }
2194 };
2195
John McCall113bee02012-03-10 09:33:50 +00002196 ConstantEmission tryEmitAsConstant(DeclRefExpr *refExpr);
John McCall71335052012-03-10 03:05:10 +00002197
John McCallfe96e0b2011-11-06 09:01:30 +00002198 RValue EmitPseudoObjectRValue(const PseudoObjectExpr *e,
2199 AggValueSlot slot = AggValueSlot::ignored());
2200 LValue EmitPseudoObjectLValue(const PseudoObjectExpr *e);
2201
Daniel Dunbar722f4242009-04-22 05:08:15 +00002202 llvm::Value *EmitIvarOffset(const ObjCInterfaceDecl *Interface,
Daniel Dunbar1c64e5d2008-09-24 04:00:38 +00002203 const ObjCIvarDecl *Ivar);
Eli Friedman7f1ff602012-04-16 03:54:45 +00002204 LValue EmitLValueForField(LValue Base, const FieldDecl* Field);
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00002205
Anders Carlssondb78f0a2010-01-29 05:24:29 +00002206 /// EmitLValueForFieldInitialization - Like EmitLValueForField, except that
2207 /// if the Field is a reference, this will return the address of the reference
2208 /// and not the address of the value stored in the reference.
Eli Friedman7f1ff602012-04-16 03:54:45 +00002209 LValue EmitLValueForFieldInitialization(LValue Base,
2210 const FieldDecl* Field);
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00002211
Fariborz Jahanianc88a70d2009-02-03 00:09:52 +00002212 LValue EmitLValueForIvar(QualType ObjectTy,
2213 llvm::Value* Base, const ObjCIvarDecl *Ivar,
Daniel Dunbar1c64e5d2008-09-24 04:00:38 +00002214 unsigned CVRQualifiers);
2215
Anders Carlsson3be22e22009-05-30 23:23:33 +00002216 LValue EmitCXXConstructLValue(const CXXConstructExpr *E);
Anders Carlssonfd2af0c2009-05-30 23:30:54 +00002217 LValue EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E);
Eli Friedman5bc17122012-02-08 05:34:55 +00002218 LValue EmitLambdaLValue(const LambdaExpr *E);
Mike Stumpc9b231c2009-11-15 08:09:41 +00002219 LValue EmitCXXTypeidLValue(const CXXTypeidExpr *E);
Nico Webercf4ff5862012-10-11 10:13:44 +00002220 LValue EmitCXXUuidofLValue(const CXXUuidofExpr *E);
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00002221
Daniel Dunbarc8317a42008-08-23 10:51:21 +00002222 LValue EmitObjCMessageExprLValue(const ObjCMessageExpr *E);
Chris Lattner4bd55962008-03-30 23:03:07 +00002223 LValue EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E);
Chris Lattnera4185c52009-04-25 19:35:26 +00002224 LValue EmitStmtExprLValue(const StmtExpr *E);
Fariborz Jahanianffba6622009-10-22 22:57:31 +00002225 LValue EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E);
Fariborz Jahanian9240f3d2010-06-17 19:56:20 +00002226 LValue EmitObjCSelectorLValue(const ObjCSelectorExpr *E);
John McCalla2fabff2010-10-09 01:34:31 +00002227 void EmitDeclRefExprDbgValue(const DeclRefExpr *E, llvm::Constant *Init);
John McCallc07a0c72011-02-17 10:25:35 +00002228
Chris Lattnerd7f58862007-06-02 05:24:33 +00002229 //===--------------------------------------------------------------------===//
Chris Lattner6278e6a2007-08-11 00:04:45 +00002230 // Scalar Expression Emission
Chris Lattner208ae962007-05-30 17:57:17 +00002231 //===--------------------------------------------------------------------===//
2232
Mike Stumpfc496822009-02-08 23:14:22 +00002233 /// EmitCall - Generate a call of the given function, expecting the given
2234 /// result type, and using the given argument list which specifies both the
2235 /// LLVM arguments and the types they were derived from.
Daniel Dunbarcdbb5e32009-02-20 18:06:48 +00002236 ///
Mike Stumpe5311b02009-11-30 20:08:49 +00002237 /// \param TargetDecl - If given, the decl of the function in a direct call;
2238 /// used to set attributes on the call (noreturn, etc.).
Daniel Dunbard931a872009-02-02 22:03:45 +00002239 RValue EmitCall(const CGFunctionInfo &FnInfo,
2240 llvm::Value *Callee,
Anders Carlsson61a401c2009-12-24 19:25:24 +00002241 ReturnValueSlot ReturnValue,
Daniel Dunbarcdbb5e32009-02-20 18:06:48 +00002242 const CallArgList &Args,
David Chisnall9eecafa2010-05-01 11:15:56 +00002243 const Decl *TargetDecl = 0,
David Chisnallff5f88c2010-05-02 13:41:58 +00002244 llvm::Instruction **callOrInvoke = 0);
Mike Stump11289f42009-09-09 15:08:12 +00002245
Anders Carlsson0435ed52009-12-24 19:08:58 +00002246 RValue EmitCall(QualType FnType, llvm::Value *Callee,
Anders Carlsson17490832009-12-24 20:40:36 +00002247 ReturnValueSlot ReturnValue,
Anders Carlsson3a9463b2009-05-27 01:22:39 +00002248 CallExpr::const_arg_iterator ArgBeg,
2249 CallExpr::const_arg_iterator ArgEnd,
2250 const Decl *TargetDecl = 0);
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00002251 RValue EmitCallExpr(const CallExpr *E,
Anders Carlsson17490832009-12-24 20:40:36 +00002252 ReturnValueSlot ReturnValue = ReturnValueSlot());
Mike Stump11289f42009-09-09 15:08:12 +00002253
John McCallbd309292010-07-06 01:34:17 +00002254 llvm::CallSite EmitCallOrInvoke(llvm::Value *Callee,
Chris Lattner54b16772011-07-23 17:14:25 +00002255 ArrayRef<llvm::Value *> Args,
Chris Lattner62ff6e82011-07-20 07:06:53 +00002256 const Twine &Name = "");
Jay Foad5bd375a2011-07-15 08:37:34 +00002257 llvm::CallSite EmitCallOrInvoke(llvm::Value *Callee,
Chris Lattner62ff6e82011-07-20 07:06:53 +00002258 const Twine &Name = "");
John McCallbd309292010-07-06 01:34:17 +00002259
Anders Carlssone828c362009-11-13 04:45:41 +00002260 llvm::Value *BuildVirtualCall(const CXXMethodDecl *MD, llvm::Value *This,
Chris Lattner2192fe52011-07-18 04:24:23 +00002261 llvm::Type *Ty);
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00002262 llvm::Value *BuildVirtualCall(const CXXDestructorDecl *DD, CXXDtorType Type,
Chris Lattner2192fe52011-07-18 04:24:23 +00002263 llvm::Value *This, llvm::Type *Ty);
Fariborz Jahanian47609b02011-01-20 17:19:02 +00002264 llvm::Value *BuildAppleKextVirtualCall(const CXXMethodDecl *MD,
2265 NestedNameSpecifier *Qual,
Chris Lattner2192fe52011-07-18 04:24:23 +00002266 llvm::Type *Ty);
Fariborz Jahanian265c3252011-02-01 23:22:34 +00002267
2268 llvm::Value *BuildAppleKextVirtualDestructorCall(const CXXDestructorDecl *DD,
2269 CXXDtorType Type,
Fariborz Jahanian7f6f81b2011-02-03 19:27:17 +00002270 const CXXRecordDecl *RD);
Anders Carlssone828c362009-11-13 04:45:41 +00002271
Anders Carlssonbd7d11f2009-05-11 23:37:08 +00002272 RValue EmitCXXMemberCall(const CXXMethodDecl *MD,
Richard Smithe30752c2012-10-09 19:52:38 +00002273 SourceLocation CallLoc,
Anders Carlssonbd7d11f2009-05-11 23:37:08 +00002274 llvm::Value *Callee,
Anders Carlssonbfb36712009-12-24 21:13:40 +00002275 ReturnValueSlot ReturnValue,
Anders Carlssonbd7d11f2009-05-11 23:37:08 +00002276 llvm::Value *This,
Anders Carlssone36a6b32010-01-02 01:01:18 +00002277 llvm::Value *VTT,
Anders Carlssonbd7d11f2009-05-11 23:37:08 +00002278 CallExpr::const_arg_iterator ArgBeg,
2279 CallExpr::const_arg_iterator ArgEnd);
Anders Carlssonbfb36712009-12-24 21:13:40 +00002280 RValue EmitCXXMemberCallExpr(const CXXMemberCallExpr *E,
2281 ReturnValueSlot ReturnValue);
2282 RValue EmitCXXMemberPointerCallExpr(const CXXMemberCallExpr *E,
2283 ReturnValueSlot ReturnValue);
Ted Kremenek08e17112008-06-17 02:43:46 +00002284
Anders Carlssonc36783e2011-05-08 20:32:23 +00002285 llvm::Value *EmitCXXOperatorMemberCallee(const CXXOperatorCallExpr *E,
2286 const CXXMethodDecl *MD,
2287 llvm::Value *This);
Anders Carlsson4034a952009-05-27 04:18:27 +00002288 RValue EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E,
Anders Carlssonbfb36712009-12-24 21:13:40 +00002289 const CXXMethodDecl *MD,
2290 ReturnValueSlot ReturnValue);
Mike Stump11289f42009-09-09 15:08:12 +00002291
Peter Collingbournefe883422011-10-06 18:29:37 +00002292 RValue EmitCUDAKernelCallExpr(const CUDAKernelCallExpr *E,
2293 ReturnValueSlot ReturnValue);
2294
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00002295
Mike Stump11289f42009-09-09 15:08:12 +00002296 RValue EmitBuiltinExpr(const FunctionDecl *FD,
Daniel Dunbar8eb018a2009-02-16 22:43:43 +00002297 unsigned BuiltinID, const CallExpr *E);
Chris Lattner8394d792007-06-05 20:53:16 +00002298
Anders Carlssonbfb36712009-12-24 21:13:40 +00002299 RValue EmitBlockCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue);
Mike Stumpc6ea7c12009-02-17 17:00:02 +00002300
Mike Stumpfc496822009-02-08 23:14:22 +00002301 /// EmitTargetBuiltinExpr - Emit the given builtin call. Returns 0 if the call
2302 /// is unhandled by the current target.
Daniel Dunbareca513d2008-10-10 00:24:54 +00002303 llvm::Value *EmitTargetBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
2304
Chris Lattner5cc15e02010-03-03 19:03:45 +00002305 llvm::Value *EmitARMBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00002306 llvm::Value *EmitNeonCall(llvm::Function *F,
Chris Lattner01cf8db2011-07-20 06:58:45 +00002307 SmallVectorImpl<llvm::Value*> &O,
Bob Wilson482afae2010-12-08 22:37:56 +00002308 const char *name,
Nate Begeman91e1fea2010-06-14 05:21:25 +00002309 unsigned shift = 0, bool rightshift = false);
Bob Wilson210f6dd2010-12-07 22:40:02 +00002310 llvm::Value *EmitNeonSplat(llvm::Value *V, llvm::Constant *Idx);
Chris Lattner2192fe52011-07-18 04:24:23 +00002311 llvm::Value *EmitNeonShiftVector(llvm::Value *V, llvm::Type *Ty,
Nate Begeman91e1fea2010-06-14 05:21:25 +00002312 bool negateForRightShift);
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00002313
Bill Wendlingf1a3fca2012-02-22 09:30:11 +00002314 llvm::Value *BuildVector(ArrayRef<llvm::Value*> Ops);
Anders Carlsson895af082007-12-09 23:17:02 +00002315 llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E);
2316 llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
Mike Stumpfc496822009-02-08 23:14:22 +00002317
Daniel Dunbar66912a12008-08-20 00:28:19 +00002318 llvm::Value *EmitObjCProtocolExpr(const ObjCProtocolExpr *E);
Chris Lattner2da04b32007-08-24 05:35:26 +00002319 llvm::Value *EmitObjCStringLiteral(const ObjCStringLiteral *E);
Patrick Beard0caa3942012-04-19 00:25:12 +00002320 llvm::Value *EmitObjCBoxedExpr(const ObjCBoxedExpr *E);
Ted Kremeneke65b0862012-03-06 20:05:56 +00002321 llvm::Value *EmitObjCArrayLiteral(const ObjCArrayLiteral *E);
2322 llvm::Value *EmitObjCDictionaryLiteral(const ObjCDictionaryLiteral *E);
2323 llvm::Value *EmitObjCCollectionLiteral(const Expr *E,
2324 const ObjCMethodDecl *MethodWithObjects);
Chris Lattnerb1d329d2008-06-24 17:04:18 +00002325 llvm::Value *EmitObjCSelectorExpr(const ObjCSelectorExpr *E);
John McCall78a15112010-05-22 01:48:05 +00002326 RValue EmitObjCMessageExpr(const ObjCMessageExpr *E,
2327 ReturnValueSlot Return = ReturnValueSlot());
Chris Lattnerb1d329d2008-06-24 17:04:18 +00002328
John McCall31168b02011-06-15 23:02:42 +00002329 /// Retrieves the default cleanup kind for an ARC cleanup.
2330 /// Except under -fobjc-arc-eh, ARC cleanups are normal-only.
2331 CleanupKind getARCCleanupKind() {
2332 return CGM.getCodeGenOpts().ObjCAutoRefCountExceptions
2333 ? NormalAndEHCleanup : NormalCleanup;
2334 }
2335
2336 // ARC primitives.
2337 void EmitARCInitWeak(llvm::Value *value, llvm::Value *addr);
2338 void EmitARCDestroyWeak(llvm::Value *addr);
2339 llvm::Value *EmitARCLoadWeak(llvm::Value *addr);
2340 llvm::Value *EmitARCLoadWeakRetained(llvm::Value *addr);
2341 llvm::Value *EmitARCStoreWeak(llvm::Value *value, llvm::Value *addr,
2342 bool ignored);
2343 void EmitARCCopyWeak(llvm::Value *dst, llvm::Value *src);
2344 void EmitARCMoveWeak(llvm::Value *dst, llvm::Value *src);
2345 llvm::Value *EmitARCRetainAutorelease(QualType type, llvm::Value *value);
2346 llvm::Value *EmitARCRetainAutoreleaseNonBlock(llvm::Value *value);
John McCall55e1fbc2011-06-25 02:11:03 +00002347 llvm::Value *EmitARCStoreStrong(LValue lvalue, llvm::Value *value,
2348 bool ignored);
John McCall31168b02011-06-15 23:02:42 +00002349 llvm::Value *EmitARCStoreStrongCall(llvm::Value *addr, llvm::Value *value,
2350 bool ignored);
2351 llvm::Value *EmitARCRetain(QualType type, llvm::Value *value);
2352 llvm::Value *EmitARCRetainNonBlock(llvm::Value *value);
John McCallff613032011-10-04 06:23:45 +00002353 llvm::Value *EmitARCRetainBlock(llvm::Value *value, bool mandatory);
John McCalle68b8f42012-10-17 02:28:37 +00002354 void EmitARCDestroyStrong(llvm::Value *addr, bool precise);
John McCall31168b02011-06-15 23:02:42 +00002355 void EmitARCRelease(llvm::Value *value, bool precise);
2356 llvm::Value *EmitARCAutorelease(llvm::Value *value);
2357 llvm::Value *EmitARCAutoreleaseReturnValue(llvm::Value *value);
2358 llvm::Value *EmitARCRetainAutoreleaseReturnValue(llvm::Value *value);
2359 llvm::Value *EmitARCRetainAutoreleasedReturnValue(llvm::Value *value);
2360
2361 std::pair<LValue,llvm::Value*>
2362 EmitARCStoreAutoreleasing(const BinaryOperator *e);
2363 std::pair<LValue,llvm::Value*>
2364 EmitARCStoreStrong(const BinaryOperator *e, bool ignored);
2365
John McCall248512a2011-10-01 10:32:24 +00002366 llvm::Value *EmitObjCThrowOperand(const Expr *expr);
2367
John McCall31168b02011-06-15 23:02:42 +00002368 llvm::Value *EmitObjCProduceObject(QualType T, llvm::Value *Ptr);
2369 llvm::Value *EmitObjCConsumeObject(QualType T, llvm::Value *Ptr);
2370 llvm::Value *EmitObjCExtendObjectLifetime(QualType T, llvm::Value *Ptr);
2371
John McCallff613032011-10-04 06:23:45 +00002372 llvm::Value *EmitARCExtendBlockObject(const Expr *expr);
John McCall31168b02011-06-15 23:02:42 +00002373 llvm::Value *EmitARCRetainScalarExpr(const Expr *expr);
2374 llvm::Value *EmitARCRetainAutoreleaseScalarExpr(const Expr *expr);
2375
John McCall82fe67b2011-07-09 01:37:26 +00002376 static Destroyer destroyARCStrongImprecise;
2377 static Destroyer destroyARCStrongPrecise;
2378 static Destroyer destroyARCWeak;
2379
John McCall31168b02011-06-15 23:02:42 +00002380 void EmitObjCAutoreleasePoolPop(llvm::Value *Ptr);
2381 llvm::Value *EmitObjCAutoreleasePoolPush();
2382 llvm::Value *EmitObjCMRRAutoreleasePoolPush();
2383 void EmitObjCAutoreleasePoolCleanup(llvm::Value *Ptr);
2384 void EmitObjCMRRAutoreleasePoolPop(llvm::Value *Ptr);
2385
Anders Carlsson6f5a0152009-05-20 00:24:07 +00002386 /// EmitReferenceBindingToExpr - Emits a reference binding to the passed in
2387 /// expression. Will emit a temporary variable if E is not an LValue.
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00002388 RValue EmitReferenceBindingToExpr(const Expr* E,
Anders Carlsson04775f82010-06-26 16:35:32 +00002389 const NamedDecl *InitializedDecl);
Anders Carlssonab0ddb52010-01-31 18:34:51 +00002390
Chris Lattner6278e6a2007-08-11 00:04:45 +00002391 //===--------------------------------------------------------------------===//
Chris Lattnerbda69f82007-08-26 23:13:56 +00002392 // Expression Emission
Chris Lattner6278e6a2007-08-11 00:04:45 +00002393 //===--------------------------------------------------------------------===//
Chris Lattnerbda69f82007-08-26 23:13:56 +00002394
2395 // Expressions are broken into three classes: scalar, complex, aggregate.
Mike Stumpfc496822009-02-08 23:14:22 +00002396
2397 /// EmitScalarExpr - Emit the computation of the specified expression of LLVM
2398 /// scalar type, returning the result.
Anders Carlsson5b106a72009-08-16 07:36:22 +00002399 llvm::Value *EmitScalarExpr(const Expr *E , bool IgnoreResultAssign = false);
Mike Stumpfc496822009-02-08 23:14:22 +00002400
Chris Lattner3474c202007-08-26 06:48:56 +00002401 /// EmitScalarConversion - Emit a conversion from the specified type to the
2402 /// specified destination type, both of which are LLVM scalar types.
2403 llvm::Value *EmitScalarConversion(llvm::Value *Src, QualType SrcTy,
2404 QualType DstTy);
Mike Stumpfc496822009-02-08 23:14:22 +00002405
Chris Lattner42e6b812007-08-26 16:34:22 +00002406 /// EmitComplexToScalarConversion - Emit a conversion from the specified
Mike Stumpfc496822009-02-08 23:14:22 +00002407 /// complex type to the specified destination type, where the destination type
2408 /// is an LLVM scalar type.
Chris Lattner42e6b812007-08-26 16:34:22 +00002409 llvm::Value *EmitComplexToScalarConversion(ComplexPairTy Src, QualType SrcTy,
2410 QualType DstTy);
Mike Stumpfc496822009-02-08 23:14:22 +00002411
2412
John McCall7a626f62010-09-15 10:14:12 +00002413 /// EmitAggExpr - Emit the computation of the specified expression
2414 /// of aggregate type. The result is computed into the given slot,
2415 /// which may be null to indicate that the value is not needed.
John McCall4e8ca4f2012-07-02 23:58:38 +00002416 void EmitAggExpr(const Expr *E, AggValueSlot AS);
Mike Stumpfc496822009-02-08 23:14:22 +00002417
Daniel Dunbard0bc7b92010-02-05 19:38:31 +00002418 /// EmitAggExprToLValue - Emit the computation of the specified expression of
2419 /// aggregate type into a temporary LValue.
2420 LValue EmitAggExprToLValue(const Expr *E);
2421
Fariborz Jahanian5f21d2f2009-07-08 01:18:33 +00002422 /// EmitGCMemmoveCollectable - Emit special API for structs with object
2423 /// pointers.
2424 void EmitGCMemmoveCollectable(llvm::Value *DestPtr, llvm::Value *SrcPtr,
Fariborz Jahanian879d7262009-08-31 19:33:16 +00002425 QualType Ty);
Fariborz Jahanian5f21d2f2009-07-08 01:18:33 +00002426
John McCall1bd25562011-06-24 23:21:27 +00002427 /// EmitExtendGCLifetime - Given a pointer to an Objective-C object,
2428 /// make sure it survives garbage collection until this point.
2429 void EmitExtendGCLifetime(llvm::Value *object);
2430
Chris Lattnercbfc73b2007-08-21 05:54:00 +00002431 /// EmitComplexExpr - Emit the computation of the specified expression of
Chris Lattner08b15df2007-08-23 23:43:33 +00002432 /// complex type, returning the result.
John McCall07bb1962010-11-16 10:08:07 +00002433 ComplexPairTy EmitComplexExpr(const Expr *E,
2434 bool IgnoreReal = false,
2435 bool IgnoreImag = false);
Mike Stumpfc496822009-02-08 23:14:22 +00002436
Chris Lattner08b15df2007-08-23 23:43:33 +00002437 /// EmitComplexExprIntoAddr - Emit the computation of the specified expression
2438 /// of complex type, storing into the specified Value*.
Chris Lattnerb84bb952007-08-26 16:22:13 +00002439 void EmitComplexExprIntoAddr(const Expr *E, llvm::Value *DestAddr,
2440 bool DestIsVolatile);
Daniel Dunbar4b8c6db2008-08-30 05:35:15 +00002441
2442 /// StoreComplexToAddr - Store a complex number into the specified address.
2443 void StoreComplexToAddr(ComplexPairTy V, llvm::Value *DestAddr,
2444 bool DestIsVolatile);
Chris Lattner4647a212007-08-31 22:49:20 +00002445 /// LoadComplexFromAddr - Load a complex number from the specified address.
2446 ComplexPairTy LoadComplexFromAddr(llvm::Value *SrcAddr, bool SrcIsVolatile);
Chris Lattnerb781dc792008-05-08 05:58:21 +00002447
John McCall1c9c3fd2010-10-15 04:57:14 +00002448 /// CreateStaticVarDecl - Create a zero-initialized LLVM global for
2449 /// a static local variable.
Chandler Carruth84537952012-03-30 19:44:53 +00002450 llvm::GlobalVariable *CreateStaticVarDecl(const VarDecl &D,
2451 const char *Separator,
2452 llvm::GlobalValue::LinkageTypes Linkage);
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00002453
Chandler Carruth84537952012-03-30 19:44:53 +00002454 /// AddInitializerToStaticVarDecl - Add the initializer for 'D' to the
2455 /// global variable that has already been created for it. If the initializer
2456 /// has a different type than GV does, this may free GV and return a different
2457 /// one. Otherwise it just returns GV.
2458 llvm::GlobalVariable *
2459 AddInitializerToStaticVarDecl(const VarDecl &D,
2460 llvm::GlobalVariable *GV);
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00002461
Daniel Dunbar22a87f92009-02-25 19:24:29 +00002462
Anders Carlssonf40886a2009-08-08 21:45:14 +00002463 /// EmitCXXGlobalVarDeclInit - Create the initializer for a C++
2464 /// variable with global storage.
Richard Smith6331c402012-02-13 22:16:19 +00002465 void EmitCXXGlobalVarDeclInit(const VarDecl &D, llvm::Constant *DeclPtr,
2466 bool PerformInit);
Anders Carlssonf40886a2009-08-08 21:45:14 +00002467
John McCallc84ed6a2012-05-01 06:13:13 +00002468 /// Call atexit() with a function that passes the given argument to
2469 /// the given function.
2470 void registerGlobalDtorWithAtExit(llvm::Constant *fn, llvm::Constant *addr);
Mike Stump11289f42009-09-09 15:08:12 +00002471
John McCallcdf7ef52010-11-06 09:44:32 +00002472 /// Emit code in this function to perform a guarded variable
2473 /// initialization. Guarded initializations are used when it's not
2474 /// possible to prove that an initialization will be done exactly
2475 /// once, e.g. with a static local variable or a static data member
2476 /// of a class template.
Chandler Carruth84537952012-03-30 19:44:53 +00002477 void EmitCXXGuardedInit(const VarDecl &D, llvm::GlobalVariable *DeclPtr,
Richard Smith6331c402012-02-13 22:16:19 +00002478 bool PerformInit);
John McCall68ff0372010-09-08 01:44:27 +00002479
Daniel Dunbarfe06df42010-03-20 04:15:41 +00002480 /// GenerateCXXGlobalInitFunc - Generates code for initializing global
2481 /// variables.
2482 void GenerateCXXGlobalInitFunc(llvm::Function *Fn,
2483 llvm::Constant **Decls,
2484 unsigned NumDecls);
2485
John McCallee08c532012-04-06 18:21:03 +00002486 /// GenerateCXXGlobalDtorsFunc - Generates code for destroying global
Daniel Dunbarfe06df42010-03-20 04:15:41 +00002487 /// variables.
John McCallee08c532012-04-06 18:21:03 +00002488 void GenerateCXXGlobalDtorsFunc(llvm::Function *Fn,
2489 const std::vector<std::pair<llvm::WeakVH,
2490 llvm::Constant*> > &DtorsAndObjects);
Daniel Dunbarfe06df42010-03-20 04:15:41 +00002491
John McCalla738c252011-03-09 04:27:21 +00002492 void GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn,
2493 const VarDecl *D,
Richard Smith6331c402012-02-13 22:16:19 +00002494 llvm::GlobalVariable *Addr,
2495 bool PerformInit);
Daniel Dunbarfe06df42010-03-20 04:15:41 +00002496
John McCall7a626f62010-09-15 10:14:12 +00002497 void EmitCXXConstructExpr(const CXXConstructExpr *E, AggValueSlot Dest);
Fariborz Jahaniane988bda2010-11-13 21:53:34 +00002498
2499 void EmitSynthesizedCXXCopyCtor(llvm::Value *Dest, llvm::Value *Src,
Fariborz Jahanian50198092010-12-02 17:02:11 +00002500 const Expr *Exp);
Mike Stump11289f42009-09-09 15:08:12 +00002501
John McCall08ef4662011-11-10 08:15:53 +00002502 void enterFullExpression(const ExprWithCleanups *E) {
2503 if (E->getNumObjects() == 0) return;
2504 enterNonTrivialFullExpression(E);
2505 }
2506 void enterNonTrivialFullExpression(const ExprWithCleanups *E);
Mike Stump11289f42009-09-09 15:08:12 +00002507
Anders Carlsson4b08db72009-10-30 01:42:31 +00002508 void EmitCXXThrowExpr(const CXXThrowExpr *E);
Douglas Gregorc278d1b2010-05-16 00:44:00 +00002509
Eli Friedmanc370a7e2012-02-09 03:32:31 +00002510 void EmitLambdaExpr(const LambdaExpr *E, AggValueSlot Dest);
2511
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002512 RValue EmitAtomicExpr(AtomicExpr *E, llvm::Value *Dest = 0);
2513
Daniel Dunbar88402ce2008-08-04 16:51:22 +00002514 //===--------------------------------------------------------------------===//
Julien Lerouge5a6b6982011-09-09 22:41:49 +00002515 // Annotations Emission
2516 //===--------------------------------------------------------------------===//
2517
2518 /// Emit an annotation call (intrinsic or builtin).
2519 llvm::Value *EmitAnnotationCall(llvm::Value *AnnotationFn,
2520 llvm::Value *AnnotatedVal,
Dmitri Gribenkof8579502013-01-12 19:30:44 +00002521 StringRef AnnotationStr,
Julien Lerouge5a6b6982011-09-09 22:41:49 +00002522 SourceLocation Location);
2523
2524 /// Emit local annotations for the local variable V, declared by D.
2525 void EmitVarAnnotations(const VarDecl *D, llvm::Value *V);
2526
2527 /// Emit field annotations for the given field & value. Returns the
2528 /// annotation result.
2529 llvm::Value *EmitFieldAnnotations(const FieldDecl *D, llvm::Value *V);
2530
2531 //===--------------------------------------------------------------------===//
Daniel Dunbar88402ce2008-08-04 16:51:22 +00002532 // Internal Helpers
2533 //===--------------------------------------------------------------------===//
Mike Stumpfc496822009-02-08 23:14:22 +00002534
Chris Lattner5b1964b2008-11-11 07:41:27 +00002535 /// ContainsLabel - Return true if the statement contains a label in it. If
2536 /// this statement is not executed normally, it not containing a label means
2537 /// that we can just remove the code.
2538 static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts = false);
Mike Stumpfc496822009-02-08 23:14:22 +00002539
Chris Lattner29911cc2011-02-28 00:18:40 +00002540 /// containsBreak - Return true if the statement contains a break out of it.
2541 /// If the statement (recursively) contains a switch or loop with a break
2542 /// inside of it, this is fine.
2543 static bool containsBreak(const Stmt *S);
2544
Daniel Dunbar682712c2008-11-12 10:12:14 +00002545 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
Chris Lattner41c6ab52011-02-27 23:02:32 +00002546 /// to a constant, or if it does but contains a label, return false. If it
2547 /// constant folds return true and set the boolean result in Result.
2548 bool ConstantFoldsToSimpleInteger(const Expr *Cond, bool &Result);
Mike Stumpfc496822009-02-08 23:14:22 +00002549
Chris Lattner29911cc2011-02-28 00:18:40 +00002550 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
2551 /// to a constant, or if it does but contains a label, return false. If it
2552 /// constant folds return true and set the folded value.
Richard Trieuc320c742012-07-23 20:21:35 +00002553 bool ConstantFoldsToSimpleInteger(const Expr *Cond, llvm::APSInt &Result);
Chris Lattner29911cc2011-02-28 00:18:40 +00002554
Chris Lattnercd439292008-11-12 08:04:58 +00002555 /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an
2556 /// if statement) to the specified blocks. Based on the condition, this might
2557 /// try to simplify the codegen of the conditional based on the branch.
Chris Lattnerb7a9e162008-11-12 07:46:33 +00002558 void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock,
Daniel Dunbar682712c2008-11-12 10:12:14 +00002559 llvm::BasicBlock *FalseBlock);
Mike Stumpba6a0c42009-12-14 21:58:14 +00002560
Richard Smithe30752c2012-10-09 19:52:38 +00002561 /// \brief Emit a description of a type in a format suitable for passing to
2562 /// a runtime sanitizer handler.
2563 llvm::Constant *EmitCheckTypeDescriptor(QualType T);
2564
2565 /// \brief Convert a value into a format suitable for passing to a runtime
2566 /// sanitizer handler.
2567 llvm::Value *EmitCheckValue(llvm::Value *V);
2568
2569 /// \brief Emit a description of a source location in a format suitable for
2570 /// passing to a runtime sanitizer handler.
2571 llvm::Constant *EmitCheckSourceLocation(SourceLocation Loc);
2572
Will Dietz88e02332012-12-02 19:50:33 +00002573 /// \brief Specify under what conditions this check can be recovered
2574 enum CheckRecoverableKind {
2575 /// Always terminate program execution if this check fails
2576 CRK_Unrecoverable,
2577 /// Check supports recovering, allows user to specify which
2578 CRK_Recoverable,
2579 /// Runtime conditionally aborts, always need to support recovery.
2580 CRK_AlwaysRecoverable
2581 };
2582
Richard Smithde670682012-11-01 22:15:34 +00002583 /// \brief Create a basic block that will call a handler function in a
2584 /// sanitizer runtime with the provided arguments, and create a conditional
2585 /// branch to it.
Richard Smithe30752c2012-10-09 19:52:38 +00002586 void EmitCheck(llvm::Value *Checked, StringRef CheckName,
Dmitri Gribenkof8579502013-01-12 19:30:44 +00002587 ArrayRef<llvm::Constant *> StaticArgs,
2588 ArrayRef<llvm::Value *> DynamicArgs,
Will Dietz88e02332012-12-02 19:50:33 +00002589 CheckRecoverableKind Recoverable);
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00002590
Richard Smithde670682012-11-01 22:15:34 +00002591 /// \brief Create a basic block that will call the trap intrinsic, and emit a
2592 /// conditional branch to it, for the -ftrapv checks.
2593 void EmitTrapvCheck(llvm::Value *Checked);
2594
Anders Carlsson093bdff2010-03-30 03:27:09 +00002595 /// EmitCallArg - Emit a single call argument.
John McCall32ea9692011-03-11 20:59:21 +00002596 void EmitCallArg(CallArgList &args, const Expr *E, QualType ArgType);
Anders Carlsson093bdff2010-03-30 03:27:09 +00002597
John McCall23f66262010-05-26 22:34:26 +00002598 /// EmitDelegateCallArg - We are performing a delegate call; that
2599 /// is, the current function is delegating to another one. Produce
2600 /// a r-value suitable for passing the given parameter.
John McCall32ea9692011-03-11 20:59:21 +00002601 void EmitDelegateCallArg(CallArgList &args, const VarDecl *param);
John McCall23f66262010-05-26 22:34:26 +00002602
Peter Collingbourne95fd2ca2011-10-27 19:19:51 +00002603 /// SetFPAccuracy - Set the minimum required accuracy of the given floating
2604 /// point operation, expressed as the maximum relative error in ulp.
Duncan Sandse81111c2012-04-10 08:23:07 +00002605 void SetFPAccuracy(llvm::Value *Val, float Accuracy);
Peter Collingbourne95fd2ca2011-10-27 19:19:51 +00002606
Chris Lattnercd439292008-11-12 08:04:58 +00002607private:
Rafael Espindola5c0034a2012-03-24 16:50:34 +00002608 llvm::MDNode *getRangeForLoadFromType(QualType Ty);
Daniel Dunbar1c64e5d2008-09-24 04:00:38 +00002609 void EmitReturnOfRValue(RValue RV, QualType Ty);
2610
Daniel Dunbar8fc81b02008-09-17 00:51:38 +00002611 /// ExpandTypeFromArgs - Reconstruct a structure of type \arg Ty
2612 /// from function arguments into \arg Dst. See ABIArgInfo::Expand.
2613 ///
2614 /// \param AI - The first function argument of the expansion.
2615 /// \return The argument following the last expanded function
2616 /// argument.
Mike Stumpfc496822009-02-08 23:14:22 +00002617 llvm::Function::arg_iterator
Daniel Dunbar8fc81b02008-09-17 00:51:38 +00002618 ExpandTypeFromArgs(QualType Ty, LValue Dst,
2619 llvm::Function::arg_iterator AI);
2620
Mike Stumpfc496822009-02-08 23:14:22 +00002621 /// ExpandTypeToArgs - Expand an RValue \arg Src, with the LLVM type for \arg
2622 /// Ty, into individual arguments on the provided vector \arg Args. See
2623 /// ABIArgInfo::Expand.
2624 void ExpandTypeToArgs(QualType Ty, RValue Src,
Chris Lattner01cf8db2011-07-20 06:58:45 +00002625 SmallVector<llvm::Value*, 16> &Args,
Chris Lattnerd59d8672011-07-12 06:29:11 +00002626 llvm::FunctionType *IRFuncTy);
Anders Carlsson03aaf112009-01-11 19:40:10 +00002627
Chad Rosier59df25b2012-08-23 20:00:18 +00002628 llvm::Value* EmitAsmInput(const TargetInfo::ConstraintInfo &Info,
Anders Carlsson03aaf112009-01-11 19:40:10 +00002629 const Expr *InputExpr, std::string &ConstraintStr);
Mike Stumpfc496822009-02-08 23:14:22 +00002630
Chad Rosier59df25b2012-08-23 20:00:18 +00002631 llvm::Value* EmitAsmInputLValue(const TargetInfo::ConstraintInfo &Info,
Eli Friedmaneca55af2010-07-16 00:55:21 +00002632 LValue InputValue, QualType InputType,
2633 std::string &ConstraintStr);
2634
Anders Carlsson60ce3fe2009-04-08 20:47:54 +00002635 /// EmitCallArgs - Emit call arguments for a function.
Mike Stump11289f42009-09-09 15:08:12 +00002636 /// The CallArgTypeInfo parameter is used for iterating over the known
Anders Carlsson603d6af2009-04-18 20:20:22 +00002637 /// argument types of the function being called.
2638 template<typename T>
2639 void EmitCallArgs(CallArgList& Args, const T* CallArgTypeInfo,
Anders Carlsson60ce3fe2009-04-08 20:47:54 +00002640 CallExpr::const_arg_iterator ArgBeg,
Anders Carlsson603d6af2009-04-18 20:20:22 +00002641 CallExpr::const_arg_iterator ArgEnd) {
2642 CallExpr::const_arg_iterator Arg = ArgBeg;
Anders Carlsson60ce3fe2009-04-08 20:47:54 +00002643
Anders Carlsson603d6af2009-04-18 20:20:22 +00002644 // First, use the argument types that the type info knows about
2645 if (CallArgTypeInfo) {
2646 for (typename T::arg_type_iterator I = CallArgTypeInfo->arg_type_begin(),
2647 E = CallArgTypeInfo->arg_type_end(); I != E; ++I, ++Arg) {
Eli Friedman794290c2009-11-18 03:42:04 +00002648 assert(Arg != ArgEnd && "Running over edge of argument list!");
Anders Carlsson603d6af2009-04-18 20:20:22 +00002649 QualType ArgType = *I;
Fariborz Jahanian8fb87ae2010-09-24 17:30:16 +00002650#ifndef NDEBUG
2651 QualType ActualArgType = Arg->getType();
2652 if (ArgType->isPointerType() && ActualArgType->isPointerType()) {
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00002653 QualType ActualBaseType =
Fariborz Jahanian8fb87ae2010-09-24 17:30:16 +00002654 ActualArgType->getAs<PointerType>()->getPointeeType();
Michael J. Spencerf5a1fbc2010-10-19 06:39:39 +00002655 QualType ArgBaseType =
Fariborz Jahanian8fb87ae2010-09-24 17:30:16 +00002656 ArgType->getAs<PointerType>()->getPointeeType();
2657 if (ArgBaseType->isVariableArrayType()) {
2658 if (const VariableArrayType *VAT =
2659 getContext().getAsVariableArrayType(ActualBaseType)) {
2660 if (!VAT->getSizeExpr())
2661 ActualArgType = ArgType;
2662 }
2663 }
2664 }
Anders Carlsson603d6af2009-04-18 20:20:22 +00002665 assert(getContext().getCanonicalType(ArgType.getNonReferenceType()).
Mike Stump11289f42009-09-09 15:08:12 +00002666 getTypePtr() ==
Fariborz Jahanian8fb87ae2010-09-24 17:30:16 +00002667 getContext().getCanonicalType(ActualArgType).getTypePtr() &&
Anders Carlsson603d6af2009-04-18 20:20:22 +00002668 "type mismatch in call argument!");
Fariborz Jahanian8fb87ae2010-09-24 17:30:16 +00002669#endif
John McCall32ea9692011-03-11 20:59:21 +00002670 EmitCallArg(Args, *Arg, ArgType);
Anders Carlsson603d6af2009-04-18 20:20:22 +00002671 }
Mike Stump11289f42009-09-09 15:08:12 +00002672
2673 // Either we've emitted all the call args, or we have a call to a
Anders Carlsson603d6af2009-04-18 20:20:22 +00002674 // variadic function.
Mike Stump11289f42009-09-09 15:08:12 +00002675 assert((Arg == ArgEnd || CallArgTypeInfo->isVariadic()) &&
Anders Carlsson603d6af2009-04-18 20:20:22 +00002676 "Extra arguments in non-variadic function!");
Mike Stump11289f42009-09-09 15:08:12 +00002677
Anders Carlsson603d6af2009-04-18 20:20:22 +00002678 }
Mike Stump11289f42009-09-09 15:08:12 +00002679
Anders Carlsson603d6af2009-04-18 20:20:22 +00002680 // If we still have any arguments, emit them using the type of the argument.
John McCall32ea9692011-03-11 20:59:21 +00002681 for (; Arg != ArgEnd; ++Arg)
2682 EmitCallArg(Args, *Arg, Arg->getType());
Anders Carlsson603d6af2009-04-18 20:20:22 +00002683 }
John McCalld4f4b7f2010-03-03 04:15:11 +00002684
2685 const TargetCodeGenInfo &getTargetHooks() const {
2686 return CGM.getTargetCodeGenInfo();
2687 }
John McCall09ae0322010-07-06 23:57:41 +00002688
2689 void EmitDeclMetadata();
John McCallf9b056b2011-03-31 08:03:29 +00002690
2691 CodeGenModule::ByrefHelpers *
Chris Lattner2192fe52011-07-18 04:24:23 +00002692 buildByrefHelpers(llvm::StructType &byrefType,
John McCallf9b056b2011-03-31 08:03:29 +00002693 const AutoVarEmission &emission);
Dan Gohman515a60d2012-02-16 00:57:37 +00002694
2695 void AddObjCARCExceptionMetadata(llvm::Instruction *Inst);
Jay Foadb0f33442012-03-02 18:34:30 +00002696
Eli Friedmana5dd5682012-08-23 03:10:17 +00002697 /// GetPointeeAlignment - Given an expression with a pointer type, emit the
2698 /// value and compute our best estimate of the alignment of the pointee.
2699 std::pair<llvm::Value*, unsigned> EmitPointerWithAlignment(const Expr *Addr);
Chris Lattnerbed31442007-05-28 01:07:47 +00002700};
Mike Stump11289f42009-09-09 15:08:12 +00002701
John McCallce1de612011-01-26 04:00:11 +00002702/// Helper class with most of the code for saving a value for a
2703/// conditional expression cleanup.
John McCallcb5f77f2011-01-28 10:53:53 +00002704struct DominatingLLVMValue {
John McCallce1de612011-01-26 04:00:11 +00002705 typedef llvm::PointerIntPair<llvm::Value*, 1, bool> saved_type;
2706
2707 /// Answer whether the given value needs extra work to be saved.
2708 static bool needsSaving(llvm::Value *value) {
2709 // If it's not an instruction, we don't need to save.
2710 if (!isa<llvm::Instruction>(value)) return false;
2711
2712 // If it's an instruction in the entry block, we don't need to save.
2713 llvm::BasicBlock *block = cast<llvm::Instruction>(value)->getParent();
2714 return (block != &block->getParent()->getEntryBlock());
2715 }
2716
2717 /// Try to save the given value.
2718 static saved_type save(CodeGenFunction &CGF, llvm::Value *value) {
2719 if (!needsSaving(value)) return saved_type(value, false);
2720
2721 // Otherwise we need an alloca.
2722 llvm::Value *alloca =
2723 CGF.CreateTempAlloca(value->getType(), "cond-cleanup.save");
2724 CGF.Builder.CreateStore(value, alloca);
2725
2726 return saved_type(alloca, true);
2727 }
2728
2729 static llvm::Value *restore(CodeGenFunction &CGF, saved_type value) {
2730 if (!value.getInt()) return value.getPointer();
2731 return CGF.Builder.CreateLoad(value.getPointer());
2732 }
2733};
2734
John McCallcb5f77f2011-01-28 10:53:53 +00002735/// A partial specialization of DominatingValue for llvm::Values that
2736/// might be llvm::Instructions.
2737template <class T> struct DominatingPointer<T,true> : DominatingLLVMValue {
2738 typedef T *type;
John McCallce1de612011-01-26 04:00:11 +00002739 static type restore(CodeGenFunction &CGF, saved_type value) {
John McCallcb5f77f2011-01-28 10:53:53 +00002740 return static_cast<T*>(DominatingLLVMValue::restore(CGF, value));
2741 }
2742};
2743
2744/// A specialization of DominatingValue for RValue.
2745template <> struct DominatingValue<RValue> {
2746 typedef RValue type;
2747 class saved_type {
2748 enum Kind { ScalarLiteral, ScalarAddress, AggregateLiteral,
2749 AggregateAddress, ComplexAddress };
2750
2751 llvm::Value *Value;
2752 Kind K;
2753 saved_type(llvm::Value *v, Kind k) : Value(v), K(k) {}
2754
2755 public:
2756 static bool needsSaving(RValue value);
2757 static saved_type save(CodeGenFunction &CGF, RValue value);
2758 RValue restore(CodeGenFunction &CGF);
2759
2760 // implementations in CGExprCXX.cpp
2761 };
2762
2763 static bool needsSaving(type value) {
2764 return saved_type::needsSaving(value);
2765 }
2766 static saved_type save(CodeGenFunction &CGF, type value) {
2767 return saved_type::save(CGF, value);
2768 }
2769 static type restore(CodeGenFunction &CGF, saved_type value) {
2770 return value.restore(CGF);
John McCallce1de612011-01-26 04:00:11 +00002771 }
2772};
2773
Chris Lattnerbed31442007-05-28 01:07:47 +00002774} // end namespace CodeGen
2775} // end namespace clang
Fariborz Jahanian715fdd52012-01-29 20:27:13 +00002776
Chris Lattnerbed31442007-05-28 01:07:47 +00002777#endif