blob: 4fb81eb43ce6a847e32cd5a408f9d6e6437fa052 [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- CGExpr.cpp - Emit LLVM Code from Expressions ---------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This contains code to emit Expr nodes as LLVM code.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CodeGenFunction.h"
15#include "CodeGenModule.h"
Daniel Dunbar0dbe2272008-09-08 21:33:45 +000016#include "CGCall.h"
John McCall4c40d982010-08-31 07:33:07 +000017#include "CGCXXABI.h"
Devang Patel79bfb4b2011-03-04 18:54:42 +000018#include "CGDebugInfo.h"
Daniel Dunbar198bcb42010-03-31 01:09:11 +000019#include "CGRecordLayout.h"
Daniel Dunbaraf2f62c2008-08-13 00:59:25 +000020#include "CGObjCRuntime.h"
John McCall01f151e2011-09-21 08:08:30 +000021#include "TargetInfo.h"
Daniel Dunbarde7fb842008-08-11 05:00:27 +000022#include "clang/AST/ASTContext.h"
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000023#include "clang/AST/DeclObjC.h"
Nico Weber28ad0632012-06-23 02:07:59 +000024#include "clang/Basic/ConvertUTF.h"
Chandler Carruth06057ce2010-06-15 23:19:56 +000025#include "clang/Frontend/CodeGenOptions.h"
Nick Lewyckye4330722011-07-07 03:54:51 +000026#include "llvm/Intrinsics.h"
Peter Collingbournec5096cb2011-10-27 19:19:51 +000027#include "llvm/LLVMContext.h"
Chandler Carruth6bebe5a2012-07-15 23:28:01 +000028#include "llvm/MDBuilder.h"
Eli Friedman316bb1b2008-05-17 20:03:47 +000029#include "llvm/Target/TargetData.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000030using namespace clang;
31using namespace CodeGen;
32
33//===--------------------------------------------------------------------===//
34// Miscellaneous Helper Methods
35//===--------------------------------------------------------------------===//
36
John McCalld16c2cf2011-02-08 08:22:06 +000037llvm::Value *CodeGenFunction::EmitCastToVoidPtr(llvm::Value *value) {
38 unsigned addressSpace =
39 cast<llvm::PointerType>(value->getType())->getAddressSpace();
40
Chris Lattner2acc6e32011-07-18 04:24:23 +000041 llvm::PointerType *destType = Int8PtrTy;
John McCalld16c2cf2011-02-08 08:22:06 +000042 if (addressSpace)
43 destType = llvm::Type::getInt8PtrTy(getLLVMContext(), addressSpace);
44
45 if (value->getType() == destType) return value;
46 return Builder.CreateBitCast(value, destType);
47}
48
Reid Spencer5f016e22007-07-11 17:01:13 +000049/// CreateTempAlloca - This creates a alloca and inserts it into the entry
50/// block.
Chris Lattner2acc6e32011-07-18 04:24:23 +000051llvm::AllocaInst *CodeGenFunction::CreateTempAlloca(llvm::Type *Ty,
Chris Lattner5f9e2722011-07-23 10:55:15 +000052 const Twine &Name) {
Chris Lattnerf1466842009-03-22 00:24:14 +000053 if (!Builder.isNamePreserving())
Daniel Dunbar259e9cc2009-10-19 01:21:05 +000054 return new llvm::AllocaInst(Ty, 0, "", AllocaInsertPt);
Devang Pateld35e2e02009-10-12 22:29:02 +000055 return new llvm::AllocaInst(Ty, 0, Name, AllocaInsertPt);
Reid Spencer5f016e22007-07-11 17:01:13 +000056}
57
John McCallac418162010-04-22 01:10:34 +000058void CodeGenFunction::InitTempAlloca(llvm::AllocaInst *Var,
59 llvm::Value *Init) {
60 llvm::StoreInst *Store = new llvm::StoreInst(Init, Var);
61 llvm::BasicBlock *Block = AllocaInsertPt->getParent();
62 Block->getInstList().insertAfter(&*AllocaInsertPt, Store);
63}
64
Chris Lattner121b3fa2010-07-05 20:21:00 +000065llvm::AllocaInst *CodeGenFunction::CreateIRTemp(QualType Ty,
Chris Lattner5f9e2722011-07-23 10:55:15 +000066 const Twine &Name) {
Daniel Dunbar9bd4da22010-02-16 19:44:13 +000067 llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertType(Ty), Name);
68 // FIXME: Should we prefer the preferred type alignment here?
69 CharUnits Align = getContext().getTypeAlignInChars(Ty);
70 Alloc->setAlignment(Align.getQuantity());
71 return Alloc;
72}
73
Chris Lattner121b3fa2010-07-05 20:21:00 +000074llvm::AllocaInst *CodeGenFunction::CreateMemTemp(QualType Ty,
Chris Lattner5f9e2722011-07-23 10:55:15 +000075 const Twine &Name) {
Daniel Dunbar195337d2010-02-09 02:48:28 +000076 llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertTypeForMem(Ty), Name);
77 // FIXME: Should we prefer the preferred type alignment here?
78 CharUnits Align = getContext().getTypeAlignInChars(Ty);
79 Alloc->setAlignment(Align.getQuantity());
80 return Alloc;
81}
82
Reid Spencer5f016e22007-07-11 17:01:13 +000083/// EvaluateExprAsBool - Perform the usual unary conversions on the specified
84/// expression and compare the result against zero, returning an Int1Ty value.
85llvm::Value *CodeGenFunction::EvaluateExprAsBool(const Expr *E) {
John McCall0bab0cd2010-08-23 01:21:21 +000086 if (const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>()) {
John McCalld608cdb2010-08-22 10:59:02 +000087 llvm::Value *MemPtr = EmitScalarExpr(E);
John McCalld16c2cf2011-02-08 08:22:06 +000088 return CGM.getCXXABI().EmitMemberPointerIsNotNull(*this, MemPtr, MPT);
Eli Friedman3a173702009-12-11 09:26:29 +000089 }
John McCall0bab0cd2010-08-23 01:21:21 +000090
91 QualType BoolTy = getContext().BoolTy;
Chris Lattner9b2dc282008-04-04 16:54:41 +000092 if (!E->getType()->isAnyComplexType())
Chris Lattner9069fa22007-08-26 16:46:58 +000093 return EmitScalarConversion(EmitScalarExpr(E), E->getType(), BoolTy);
Reid Spencer5f016e22007-07-11 17:01:13 +000094
Chris Lattner9069fa22007-08-26 16:46:58 +000095 return EmitComplexToScalarConversion(EmitComplexExpr(E), E->getType(),BoolTy);
Reid Spencer5f016e22007-07-11 17:01:13 +000096}
97
John McCall2a416372010-12-05 02:00:02 +000098/// EmitIgnoredExpr - Emit code to compute the specified expression,
99/// ignoring the result.
100void CodeGenFunction::EmitIgnoredExpr(const Expr *E) {
101 if (E->isRValue())
102 return (void) EmitAnyExpr(E, AggValueSlot::ignored(), true);
103
104 // Just emit it as an l-value and drop the result.
105 EmitLValue(E);
106}
107
John McCall558d2ab2010-09-15 10:14:12 +0000108/// EmitAnyExpr - Emit code to compute the specified expression which
109/// can have any type. The result is returned as an RValue struct.
110/// If this is an aggregate expression, AggSlot indicates where the
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000111/// result should be returned.
John McCalle0c11682012-07-02 23:58:38 +0000112RValue CodeGenFunction::EmitAnyExpr(const Expr *E,
113 AggValueSlot aggSlot,
114 bool ignoreResult) {
Chris Lattner9b655512007-08-31 22:49:20 +0000115 if (!hasAggregateLLVMType(E->getType()))
John McCalle0c11682012-07-02 23:58:38 +0000116 return RValue::get(EmitScalarExpr(E, ignoreResult));
Chris Lattner9b2dc282008-04-04 16:54:41 +0000117 else if (E->getType()->isAnyComplexType())
John McCalle0c11682012-07-02 23:58:38 +0000118 return RValue::getComplex(EmitComplexExpr(E, ignoreResult, ignoreResult));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000119
John McCalle0c11682012-07-02 23:58:38 +0000120 if (!ignoreResult && aggSlot.isIgnored())
121 aggSlot = CreateAggTemp(E->getType(), "agg-temp");
122 EmitAggExpr(E, aggSlot);
123 return aggSlot.asRValue();
Chris Lattner9b655512007-08-31 22:49:20 +0000124}
125
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000126/// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result will
127/// always be accessible even if no aggregate location is provided.
John McCall558d2ab2010-09-15 10:14:12 +0000128RValue CodeGenFunction::EmitAnyExprToTemp(const Expr *E) {
129 AggValueSlot AggSlot = AggValueSlot::ignored();
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000130
131 if (hasAggregateLLVMType(E->getType()) &&
Daniel Dunbar46f45b92008-09-09 01:06:48 +0000132 !E->getType()->isAnyComplexType())
John McCall558d2ab2010-09-15 10:14:12 +0000133 AggSlot = CreateAggTemp(E->getType(), "agg.tmp");
134 return EmitAnyExpr(E, AggSlot);
Daniel Dunbar46f45b92008-09-09 01:06:48 +0000135}
136
John McCall3d3ec1c2010-04-21 10:05:39 +0000137/// EmitAnyExprToMem - Evaluate an expression into a given memory
138/// location.
139void CodeGenFunction::EmitAnyExprToMem(const Expr *E,
140 llvm::Value *Location,
Chad Rosier649b4a12012-03-29 17:37:10 +0000141 Qualifiers Quals,
142 bool IsInit) {
Eli Friedmanf3940782011-12-03 00:54:26 +0000143 // FIXME: This function should take an LValue as an argument.
144 if (E->getType()->isAnyComplexType()) {
John McCallf85e1932011-06-15 23:02:42 +0000145 EmitComplexExprIntoAddr(E, Location, Quals.hasVolatile());
Eli Friedmanf3940782011-12-03 00:54:26 +0000146 } else if (hasAggregateLLVMType(E->getType())) {
Eli Friedmand7722d92011-12-03 02:13:40 +0000147 CharUnits Alignment = getContext().getTypeAlignInChars(E->getType());
Eli Friedmanf3940782011-12-03 00:54:26 +0000148 EmitAggExpr(E, AggValueSlot::forAddr(Location, Alignment, Quals,
Chad Rosier649b4a12012-03-29 17:37:10 +0000149 AggValueSlot::IsDestructed_t(IsInit),
John McCall90b2bdf2011-08-26 05:38:08 +0000150 AggValueSlot::DoesNotNeedGCBarriers,
Chad Rosier649b4a12012-03-29 17:37:10 +0000151 AggValueSlot::IsAliased_t(!IsInit)));
Eli Friedmanf3940782011-12-03 00:54:26 +0000152 } else {
John McCall3d3ec1c2010-04-21 10:05:39 +0000153 RValue RV = RValue::get(EmitScalarExpr(E, /*Ignore*/ false));
Daniel Dunbar9f553f52010-08-21 03:08:16 +0000154 LValue LV = MakeAddrLValue(Location, E->getType());
John McCall545d9962011-06-25 02:11:03 +0000155 EmitStoreThroughLValue(RV, LV);
John McCall3d3ec1c2010-04-21 10:05:39 +0000156 }
157}
158
Benjamin Kramer54353f42010-11-25 18:29:30 +0000159namespace {
Douglas Gregor60dcb842010-05-20 08:36:28 +0000160/// \brief An adjustment to be made to the temporary created when emitting a
161/// reference binding, which accesses a particular subobject of that temporary.
Benjamin Kramer54353f42010-11-25 18:29:30 +0000162 struct SubobjectAdjustment {
Eli Friedman32f498a2012-06-15 23:51:06 +0000163 enum {
164 DerivedToBaseAdjustment,
165 FieldAdjustment,
166 MemberPointerAdjustment
167 } Kind;
Benjamin Kramer54353f42010-11-25 18:29:30 +0000168
169 union {
170 struct {
171 const CastExpr *BasePath;
172 const CXXRecordDecl *DerivedClass;
173 } DerivedToBase;
174
175 FieldDecl *Field;
Eli Friedman32f498a2012-06-15 23:51:06 +0000176
177 struct {
178 const MemberPointerType *MPT;
179 llvm::Value *Ptr;
180 } Ptr;
Benjamin Kramer54353f42010-11-25 18:29:30 +0000181 };
182
183 SubobjectAdjustment(const CastExpr *BasePath,
184 const CXXRecordDecl *DerivedClass)
185 : Kind(DerivedToBaseAdjustment) {
186 DerivedToBase.BasePath = BasePath;
187 DerivedToBase.DerivedClass = DerivedClass;
188 }
189
190 SubobjectAdjustment(FieldDecl *Field)
191 : Kind(FieldAdjustment) {
192 this->Field = Field;
193 }
Eli Friedman32f498a2012-06-15 23:51:06 +0000194
195 SubobjectAdjustment(const MemberPointerType *MPT, llvm::Value *Ptr)
196 : Kind(MemberPointerAdjustment) {
197 this->Ptr.MPT = MPT;
198 this->Ptr.Ptr = Ptr;
199 }
Douglas Gregor60dcb842010-05-20 08:36:28 +0000200 };
Benjamin Kramer54353f42010-11-25 18:29:30 +0000201}
Douglas Gregor60dcb842010-05-20 08:36:28 +0000202
Anders Carlssondca7ab22010-06-27 16:56:04 +0000203static llvm::Value *
Chris Lattnercb8095f2011-07-20 04:59:57 +0000204CreateReferenceTemporary(CodeGenFunction &CGF, QualType Type,
Anders Carlsson656746c2010-06-27 17:23:46 +0000205 const NamedDecl *InitializedDecl) {
206 if (const VarDecl *VD = dyn_cast_or_null<VarDecl>(InitializedDecl)) {
207 if (VD->hasGlobalStorage()) {
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000208 SmallString<256> Name;
Rafael Espindolaf0be9792011-02-11 02:52:17 +0000209 llvm::raw_svector_ostream Out(Name);
210 CGF.CGM.getCXXABI().getMangleContext().mangleReferenceTemporary(VD, Out);
211 Out.flush();
212
Chris Lattner2acc6e32011-07-18 04:24:23 +0000213 llvm::Type *RefTempTy = CGF.ConvertTypeForMem(Type);
Anders Carlsson656746c2010-06-27 17:23:46 +0000214
215 // Create the reference temporary.
216 llvm::GlobalValue *RefTemp =
217 new llvm::GlobalVariable(CGF.CGM.getModule(),
218 RefTempTy, /*isConstant=*/false,
219 llvm::GlobalValue::InternalLinkage,
220 llvm::Constant::getNullValue(RefTempTy),
221 Name.str());
222 return RefTemp;
223 }
224 }
225
226 return CGF.CreateMemTemp(Type, "ref.tmp");
227}
228
229static llvm::Value *
Chris Lattnerd0db03a2010-09-06 00:11:41 +0000230EmitExprForReferenceBinding(CodeGenFunction &CGF, const Expr *E,
Anders Carlssondca7ab22010-06-27 16:56:04 +0000231 llvm::Value *&ReferenceTemporary,
232 const CXXDestructorDecl *&ReferenceTemporaryDtor,
John McCallf85e1932011-06-15 23:02:42 +0000233 QualType &ObjCARCReferenceLifetimeType,
Anders Carlsson656746c2010-06-27 17:23:46 +0000234 const NamedDecl *InitializedDecl) {
Sebastian Redl13dc8f92011-11-27 16:50:07 +0000235 // Look through single-element init lists that claim to be lvalues. They're
236 // just syntactic wrappers in this case.
237 if (const InitListExpr *ILE = dyn_cast<InitListExpr>(E)) {
238 if (ILE->getNumInits() == 1 && ILE->isGLValue())
239 E = ILE->getInit(0);
240 }
241
Douglas Gregor03e80032011-06-21 17:03:29 +0000242 // Look through expressions for materialized temporaries (for now).
Douglas Gregord7b23162011-06-22 16:12:01 +0000243 if (const MaterializeTemporaryExpr *M
244 = dyn_cast<MaterializeTemporaryExpr>(E)) {
245 // Objective-C++ ARC:
246 // If we are binding a reference to a temporary that has ownership, we
247 // need to perform retain/release operations on the temporary.
David Blaikie4e4d0842012-03-11 07:00:24 +0000248 if (CGF.getContext().getLangOpts().ObjCAutoRefCount &&
Douglas Gregord7b23162011-06-22 16:12:01 +0000249 E->getType()->isObjCLifetimeType() &&
250 (E->getType().getObjCLifetime() == Qualifiers::OCL_Strong ||
251 E->getType().getObjCLifetime() == Qualifiers::OCL_Weak ||
252 E->getType().getObjCLifetime() == Qualifiers::OCL_Autoreleasing))
253 ObjCARCReferenceLifetimeType = E->getType();
254
255 E = M->GetTemporaryExpr();
256 }
Douglas Gregor03e80032011-06-21 17:03:29 +0000257
Eli Friedman27a9b722009-12-19 00:20:10 +0000258 if (const CXXDefaultArgExpr *DAE = dyn_cast<CXXDefaultArgExpr>(E))
259 E = DAE->getExpr();
Anders Carlssonb3f74422009-10-15 00:51:46 +0000260
John McCall1a343eb2011-11-10 08:15:53 +0000261 if (const ExprWithCleanups *EWC = dyn_cast<ExprWithCleanups>(E)) {
262 CGF.enterFullExpression(EWC);
John McCallf1549f62010-07-06 01:34:17 +0000263 CodeGenFunction::RunCleanupsScope Scope(CGF);
Anders Carlssondca7ab22010-06-27 16:56:04 +0000264
John McCall1a343eb2011-11-10 08:15:53 +0000265 return EmitExprForReferenceBinding(CGF, EWC->getSubExpr(),
Anders Carlssondca7ab22010-06-27 16:56:04 +0000266 ReferenceTemporary,
267 ReferenceTemporaryDtor,
John McCallf85e1932011-06-15 23:02:42 +0000268 ObjCARCReferenceLifetimeType,
Anders Carlsson656746c2010-06-27 17:23:46 +0000269 InitializedDecl);
Anders Carlssondca7ab22010-06-27 16:56:04 +0000270 }
271
272 RValue RV;
Douglas Gregorda29e092011-01-22 02:44:21 +0000273 if (E->isGLValue()) {
Anders Carlssondca7ab22010-06-27 16:56:04 +0000274 // Emit the expression as an lvalue.
275 LValue LV = CGF.EmitLValue(E);
Chris Lattner74339df2011-07-10 05:34:54 +0000276
Anders Carlssondca7ab22010-06-27 16:56:04 +0000277 if (LV.isSimple())
278 return LV.getAddress();
Anders Carlsson0dc73662010-02-04 17:32:58 +0000279
Anders Carlssondca7ab22010-06-27 16:56:04 +0000280 // We have to load the lvalue.
John McCall545d9962011-06-25 02:11:03 +0000281 RV = CGF.EmitLoadOfLValue(LV);
Eli Friedman5df0d422009-05-20 02:31:19 +0000282 } else {
Douglas Gregord7b23162011-06-22 16:12:01 +0000283 if (!ObjCARCReferenceLifetimeType.isNull()) {
284 ReferenceTemporary = CreateReferenceTemporary(CGF,
285 ObjCARCReferenceLifetimeType,
286 InitializedDecl);
287
288
289 LValue RefTempDst = CGF.MakeAddrLValue(ReferenceTemporary,
290 ObjCARCReferenceLifetimeType);
291
292 CGF.EmitScalarInit(E, dyn_cast_or_null<ValueDecl>(InitializedDecl),
293 RefTempDst, false);
294
295 bool ExtendsLifeOfTemporary = false;
296 if (const VarDecl *Var = dyn_cast_or_null<VarDecl>(InitializedDecl)) {
297 if (Var->extendsLifetimeOfTemporary())
298 ExtendsLifeOfTemporary = true;
299 } else if (InitializedDecl && isa<FieldDecl>(InitializedDecl)) {
300 ExtendsLifeOfTemporary = true;
301 }
302
303 if (!ExtendsLifeOfTemporary) {
304 // Since the lifetime of this temporary isn't going to be extended,
305 // we need to clean it up ourselves at the end of the full expression.
306 switch (ObjCARCReferenceLifetimeType.getObjCLifetime()) {
307 case Qualifiers::OCL_None:
308 case Qualifiers::OCL_ExplicitNone:
309 case Qualifiers::OCL_Autoreleasing:
310 break;
311
John McCall9928c482011-07-12 16:41:08 +0000312 case Qualifiers::OCL_Strong: {
313 assert(!ObjCARCReferenceLifetimeType->isArrayType());
314 CleanupKind cleanupKind = CGF.getARCCleanupKind();
315 CGF.pushDestroy(cleanupKind,
316 ReferenceTemporary,
317 ObjCARCReferenceLifetimeType,
318 CodeGenFunction::destroyARCStrongImprecise,
319 cleanupKind & EHCleanup);
Douglas Gregord7b23162011-06-22 16:12:01 +0000320 break;
John McCall9928c482011-07-12 16:41:08 +0000321 }
Douglas Gregord7b23162011-06-22 16:12:01 +0000322
323 case Qualifiers::OCL_Weak:
John McCall9928c482011-07-12 16:41:08 +0000324 assert(!ObjCARCReferenceLifetimeType->isArrayType());
325 CGF.pushDestroy(NormalAndEHCleanup,
326 ReferenceTemporary,
327 ObjCARCReferenceLifetimeType,
328 CodeGenFunction::destroyARCWeak,
329 /*useEHCleanupForArray*/ true);
Douglas Gregord7b23162011-06-22 16:12:01 +0000330 break;
331 }
332
333 ObjCARCReferenceLifetimeType = QualType();
334 }
335
336 return ReferenceTemporary;
337 }
338
Chris Lattner5f9e2722011-07-23 10:55:15 +0000339 SmallVector<SubobjectAdjustment, 2> Adjustments;
Anders Carlssondca7ab22010-06-27 16:56:04 +0000340 while (true) {
Peter Collingbournef111d932011-04-15 00:35:48 +0000341 E = E->IgnoreParens();
Douglas Gregor2d6b0e92010-05-22 05:17:18 +0000342
343 if (const CastExpr *CE = dyn_cast<CastExpr>(E)) {
John McCall2de56d12010-08-25 11:45:40 +0000344 if ((CE->getCastKind() == CK_DerivedToBase ||
345 CE->getCastKind() == CK_UncheckedDerivedToBase) &&
Douglas Gregor2d6b0e92010-05-22 05:17:18 +0000346 E->getType()->isRecordType()) {
Douglas Gregor60dcb842010-05-20 08:36:28 +0000347 E = CE->getSubExpr();
348 CXXRecordDecl *Derived
349 = cast<CXXRecordDecl>(E->getType()->getAs<RecordType>()->getDecl());
John McCallf871d0c2010-08-07 06:22:56 +0000350 Adjustments.push_back(SubobjectAdjustment(CE, Derived));
Douglas Gregor60dcb842010-05-20 08:36:28 +0000351 continue;
352 }
Douglas Gregor2d6b0e92010-05-22 05:17:18 +0000353
John McCall2de56d12010-08-25 11:45:40 +0000354 if (CE->getCastKind() == CK_NoOp) {
Douglas Gregor2d6b0e92010-05-22 05:17:18 +0000355 E = CE->getSubExpr();
356 continue;
357 }
358 } else if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
John McCall7eb0a9e2010-11-24 05:12:34 +0000359 if (!ME->isArrow() && ME->getBase()->isRValue()) {
360 assert(ME->getBase()->getType()->isRecordType());
Douglas Gregor60dcb842010-05-20 08:36:28 +0000361 if (FieldDecl *Field = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
362 E = ME->getBase();
Daniel Dunbar333d42d2010-08-21 03:37:02 +0000363 Adjustments.push_back(SubobjectAdjustment(Field));
Douglas Gregor60dcb842010-05-20 08:36:28 +0000364 continue;
365 }
366 }
Eli Friedman32f498a2012-06-15 23:51:06 +0000367 } else if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
368 if (BO->isPtrMemOp()) {
369 assert(BO->getLHS()->isRValue());
370 E = BO->getLHS();
371 const MemberPointerType *MPT =
372 BO->getRHS()->getType()->getAs<MemberPointerType>();
373 llvm::Value *Ptr = CGF.EmitScalarExpr(BO->getRHS());
374 Adjustments.push_back(SubobjectAdjustment(MPT, Ptr));
375 }
Anders Carlssonb3f74422009-10-15 00:51:46 +0000376 }
Douglas Gregor2d6b0e92010-05-22 05:17:18 +0000377
John McCall7cc25fe2011-02-21 05:25:38 +0000378 if (const OpaqueValueExpr *opaque = dyn_cast<OpaqueValueExpr>(E))
379 if (opaque->getType()->isRecordType())
380 return CGF.EmitOpaqueValueLValue(opaque).getAddress();
381
Douglas Gregor2d6b0e92010-05-22 05:17:18 +0000382 // Nothing changed.
383 break;
Anders Carlsson8478ce62009-08-16 17:50:25 +0000384 }
Anders Carlssonb3f74422009-10-15 00:51:46 +0000385
Anders Carlssondca7ab22010-06-27 16:56:04 +0000386 // Create a reference temporary if necessary.
John McCall558d2ab2010-09-15 10:14:12 +0000387 AggValueSlot AggSlot = AggValueSlot::ignored();
Anders Carlssondca7ab22010-06-27 16:56:04 +0000388 if (CGF.hasAggregateLLVMType(E->getType()) &&
John McCall558d2ab2010-09-15 10:14:12 +0000389 !E->getType()->isAnyComplexType()) {
Anders Carlsson656746c2010-06-27 17:23:46 +0000390 ReferenceTemporary = CreateReferenceTemporary(CGF, E->getType(),
391 InitializedDecl);
Eli Friedmand7722d92011-12-03 02:13:40 +0000392 CharUnits Alignment = CGF.getContext().getTypeAlignInChars(E->getType());
John McCall7c2349b2011-08-25 20:40:09 +0000393 AggValueSlot::IsDestructed_t isDestructed
394 = AggValueSlot::IsDestructed_t(InitializedDecl != 0);
Eli Friedmanf3940782011-12-03 00:54:26 +0000395 AggSlot = AggValueSlot::forAddr(ReferenceTemporary, Alignment,
396 Qualifiers(), isDestructed,
John McCall410ffb22011-08-25 23:04:34 +0000397 AggValueSlot::DoesNotNeedGCBarriers,
Chad Rosier649b4a12012-03-29 17:37:10 +0000398 AggValueSlot::IsNotAliased);
John McCall558d2ab2010-09-15 10:14:12 +0000399 }
John McCallf85e1932011-06-15 23:02:42 +0000400
Anders Carlsson656746c2010-06-27 17:23:46 +0000401 if (InitializedDecl) {
Anders Carlssondca7ab22010-06-27 16:56:04 +0000402 // Get the destructor for the reference temporary.
403 if (const RecordType *RT = E->getType()->getAs<RecordType>()) {
404 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(RT->getDecl());
405 if (!ClassDecl->hasTrivialDestructor())
Douglas Gregor1d110e02010-07-01 14:13:13 +0000406 ReferenceTemporaryDtor = ClassDecl->getDestructor();
Anders Carlssondca7ab22010-06-27 16:56:04 +0000407 }
408 }
409
John McCallf85e1932011-06-15 23:02:42 +0000410 RV = CGF.EmitAnyExpr(E, AggSlot);
411
Douglas Gregor60dcb842010-05-20 08:36:28 +0000412 // Check if need to perform derived-to-base casts and/or field accesses, to
413 // get from the temporary object we created (and, potentially, for which we
414 // extended the lifetime) to the subobject we're binding the reference to.
415 if (!Adjustments.empty()) {
Anders Carlssondca7ab22010-06-27 16:56:04 +0000416 llvm::Value *Object = RV.getAggregateAddr();
Douglas Gregor60dcb842010-05-20 08:36:28 +0000417 for (unsigned I = Adjustments.size(); I != 0; --I) {
418 SubobjectAdjustment &Adjustment = Adjustments[I-1];
419 switch (Adjustment.Kind) {
420 case SubobjectAdjustment::DerivedToBaseAdjustment:
Anders Carlssondca7ab22010-06-27 16:56:04 +0000421 Object =
422 CGF.GetAddressOfBaseClass(Object,
423 Adjustment.DerivedToBase.DerivedClass,
John McCallf871d0c2010-08-07 06:22:56 +0000424 Adjustment.DerivedToBase.BasePath->path_begin(),
425 Adjustment.DerivedToBase.BasePath->path_end(),
Anders Carlssondca7ab22010-06-27 16:56:04 +0000426 /*NullCheckValue=*/false);
Douglas Gregor60dcb842010-05-20 08:36:28 +0000427 break;
428
429 case SubobjectAdjustment::FieldAdjustment: {
Eli Friedman377ecc72012-04-16 03:54:45 +0000430 LValue LV = CGF.MakeAddrLValue(Object, E->getType());
431 LV = CGF.EmitLValueForField(LV, Adjustment.Field);
Douglas Gregor60dcb842010-05-20 08:36:28 +0000432 if (LV.isSimple()) {
433 Object = LV.getAddress();
434 break;
435 }
436
437 // For non-simple lvalues, we actually have to create a copy of
438 // the object we're binding to.
Daniel Dunbar333d42d2010-08-21 03:37:02 +0000439 QualType T = Adjustment.Field->getType().getNonReferenceType()
440 .getUnqualifiedType();
Anders Carlsson045a6d82010-06-27 17:52:15 +0000441 Object = CreateReferenceTemporary(CGF, T, InitializedDecl);
Daniel Dunbar333d42d2010-08-21 03:37:02 +0000442 LValue TempLV = CGF.MakeAddrLValue(Object,
443 Adjustment.Field->getType());
John McCall545d9962011-06-25 02:11:03 +0000444 CGF.EmitStoreThroughLValue(CGF.EmitLoadOfLValue(LV), TempLV);
Douglas Gregor60dcb842010-05-20 08:36:28 +0000445 break;
446 }
Anders Carlssondca7ab22010-06-27 16:56:04 +0000447
Eli Friedman32f498a2012-06-15 23:51:06 +0000448 case SubobjectAdjustment::MemberPointerAdjustment: {
449 Object = CGF.CGM.getCXXABI().EmitMemberDataPointerAddress(
450 CGF, Object, Adjustment.Ptr.Ptr, Adjustment.Ptr.MPT);
451 break;
452 }
Douglas Gregor60dcb842010-05-20 08:36:28 +0000453 }
454 }
Eli Friedman545aa7a2011-03-16 22:34:09 +0000455
456 return Object;
Anders Carlssonb3f74422009-10-15 00:51:46 +0000457 }
Anders Carlsson4bbab922009-05-20 00:36:58 +0000458 }
Eli Friedman5df0d422009-05-20 02:31:19 +0000459
Anders Carlssondca7ab22010-06-27 16:56:04 +0000460 if (RV.isAggregate())
461 return RV.getAggregateAddr();
Eli Friedman5df0d422009-05-20 02:31:19 +0000462
Anders Carlssondca7ab22010-06-27 16:56:04 +0000463 // Create a temporary variable that we can bind the reference to.
Anders Carlsson656746c2010-06-27 17:23:46 +0000464 ReferenceTemporary = CreateReferenceTemporary(CGF, E->getType(),
465 InitializedDecl);
466
Daniel Dunbar91a16fa2010-08-21 02:24:36 +0000467
468 unsigned Alignment =
469 CGF.getContext().getTypeAlignInChars(E->getType()).getQuantity();
Anders Carlssondca7ab22010-06-27 16:56:04 +0000470 if (RV.isScalar())
471 CGF.EmitStoreOfScalar(RV.getScalarVal(), ReferenceTemporary,
Daniel Dunbar91a16fa2010-08-21 02:24:36 +0000472 /*Volatile=*/false, Alignment, E->getType());
Anders Carlssondca7ab22010-06-27 16:56:04 +0000473 else
474 CGF.StoreComplexToAddr(RV.getComplexVal(), ReferenceTemporary,
475 /*Volatile=*/false);
476 return ReferenceTemporary;
477}
478
479RValue
Chris Lattnerd0db03a2010-09-06 00:11:41 +0000480CodeGenFunction::EmitReferenceBindingToExpr(const Expr *E,
Anders Carlssondca7ab22010-06-27 16:56:04 +0000481 const NamedDecl *InitializedDecl) {
482 llvm::Value *ReferenceTemporary = 0;
483 const CXXDestructorDecl *ReferenceTemporaryDtor = 0;
John McCallf85e1932011-06-15 23:02:42 +0000484 QualType ObjCARCReferenceLifetimeType;
Anders Carlssondca7ab22010-06-27 16:56:04 +0000485 llvm::Value *Value = EmitExprForReferenceBinding(*this, E, ReferenceTemporary,
486 ReferenceTemporaryDtor,
John McCallf85e1932011-06-15 23:02:42 +0000487 ObjCARCReferenceLifetimeType,
Anders Carlssondca7ab22010-06-27 16:56:04 +0000488 InitializedDecl);
Richard Smith2c9f87c2012-08-24 00:54:33 +0000489 if (CatchUndefined && !E->getType()->isFunctionType()) {
490 // C++11 [dcl.ref]p5 (as amended by core issue 453):
491 // If a glvalue to which a reference is directly bound designates neither
492 // an existing object or function of an appropriate type nor a region of
493 // storage of suitable size and alignment to contain an object of the
494 // reference's type, the behavior is undefined.
495 QualType Ty = E->getType();
Richard Smith7ac9ef12012-09-08 02:08:36 +0000496 EmitTypeCheck(TCK_ReferenceBinding, Value, Ty);
Richard Smith2c9f87c2012-08-24 00:54:33 +0000497 }
John McCallf85e1932011-06-15 23:02:42 +0000498 if (!ReferenceTemporaryDtor && ObjCARCReferenceLifetimeType.isNull())
Anders Carlsson045a6d82010-06-27 17:52:15 +0000499 return RValue::get(Value);
500
Anders Carlssondca7ab22010-06-27 16:56:04 +0000501 // Make sure to call the destructor for the reference temporary.
John McCallf85e1932011-06-15 23:02:42 +0000502 const VarDecl *VD = dyn_cast_or_null<VarDecl>(InitializedDecl);
503 if (VD && VD->hasGlobalStorage()) {
504 if (ReferenceTemporaryDtor) {
Anders Carlsson045a6d82010-06-27 17:52:15 +0000505 llvm::Constant *DtorFn =
506 CGM.GetAddrOfCXXDestructor(ReferenceTemporaryDtor, Dtor_Complete);
John McCall20bb1752012-05-01 06:13:13 +0000507 CGM.getCXXABI().registerGlobalDtor(*this, DtorFn,
John McCalld16c2cf2011-02-08 08:22:06 +0000508 cast<llvm::Constant>(ReferenceTemporary));
John McCallf85e1932011-06-15 23:02:42 +0000509 } else {
510 assert(!ObjCARCReferenceLifetimeType.isNull());
511 // Note: We intentionally do not register a global "destructor" to
512 // release the object.
Anders Carlsson045a6d82010-06-27 17:52:15 +0000513 }
John McCallf85e1932011-06-15 23:02:42 +0000514
515 return RValue::get(Value);
Anders Carlsson045a6d82010-06-27 17:52:15 +0000516 }
John McCall81407d42010-07-21 06:29:51 +0000517
John McCallf85e1932011-06-15 23:02:42 +0000518 if (ReferenceTemporaryDtor)
519 PushDestructorCleanup(ReferenceTemporaryDtor, ReferenceTemporary);
520 else {
521 switch (ObjCARCReferenceLifetimeType.getObjCLifetime()) {
522 case Qualifiers::OCL_None:
David Blaikieb219cfc2011-09-23 05:06:16 +0000523 llvm_unreachable(
524 "Not a reference temporary that needs to be deallocated");
John McCallf85e1932011-06-15 23:02:42 +0000525 case Qualifiers::OCL_ExplicitNone:
526 case Qualifiers::OCL_Autoreleasing:
527 // Nothing to do.
528 break;
529
John McCall9928c482011-07-12 16:41:08 +0000530 case Qualifiers::OCL_Strong: {
531 bool precise = VD && VD->hasAttr<ObjCPreciseLifetimeAttr>();
532 CleanupKind cleanupKind = getARCCleanupKind();
Benjamin Kramer0d516762011-07-12 18:37:23 +0000533 pushDestroy(cleanupKind, ReferenceTemporary, ObjCARCReferenceLifetimeType,
Peter Collingbourne516bbd42012-01-26 03:33:36 +0000534 precise ? destroyARCStrongPrecise : destroyARCStrongImprecise,
535 cleanupKind & EHCleanup);
John McCallf85e1932011-06-15 23:02:42 +0000536 break;
John McCall9928c482011-07-12 16:41:08 +0000537 }
John McCallf85e1932011-06-15 23:02:42 +0000538
Benjamin Kramer0d516762011-07-12 18:37:23 +0000539 case Qualifiers::OCL_Weak: {
John McCallf85e1932011-06-15 23:02:42 +0000540 // __weak objects always get EH cleanups; otherwise, exceptions
541 // could cause really nasty crashes instead of mere leaks.
John McCall9928c482011-07-12 16:41:08 +0000542 pushDestroy(NormalAndEHCleanup, ReferenceTemporary,
Peter Collingbourne516bbd42012-01-26 03:33:36 +0000543 ObjCARCReferenceLifetimeType, destroyARCWeak, true);
John McCallf85e1932011-06-15 23:02:42 +0000544 break;
545 }
Benjamin Kramer0d516762011-07-12 18:37:23 +0000546 }
John McCallf85e1932011-06-15 23:02:42 +0000547 }
548
Anders Carlssondca7ab22010-06-27 16:56:04 +0000549 return RValue::get(Value);
Anders Carlsson4029ca72009-05-20 00:24:07 +0000550}
551
552
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000553/// getAccessedFieldNo - Given an encoded value and a result number, return the
554/// input field number being accessed.
555unsigned CodeGenFunction::getAccessedFieldNo(unsigned Idx,
Dan Gohman4f8d1232008-05-22 00:50:06 +0000556 const llvm::Constant *Elts) {
Chris Lattner89f42832012-01-30 06:20:36 +0000557 return cast<llvm::ConstantInt>(Elts->getAggregateElement(Idx))
558 ->getZExtValue();
Dan Gohman4f8d1232008-05-22 00:50:06 +0000559}
560
Richard Smith7ac9ef12012-09-08 02:08:36 +0000561void CodeGenFunction::EmitTypeCheck(TypeCheckKind TCK, llvm::Value *Address,
562 QualType Ty, CharUnits Alignment) {
Nuno Lopesdef18492012-05-22 17:19:45 +0000563 if (!CatchUndefined)
Mike Stumpb14e62d2009-12-16 02:57:00 +0000564 return;
565
Richard Smith2c9f87c2012-08-24 00:54:33 +0000566 llvm::Value *Cond = 0;
Mike Stumpb14e62d2009-12-16 02:57:00 +0000567
Richard Smith7ac9ef12012-09-08 02:08:36 +0000568 if (TCK != TCK_Load && TCK != TCK_Store) {
Richard Smith2c9f87c2012-08-24 00:54:33 +0000569 // The glvalue must not be an empty glvalue. Don't bother checking this for
570 // loads and stores, because we will get a segfault anyway (if the operation
571 // isn't optimized out).
572 Cond = Builder.CreateICmpNE(
573 Address, llvm::Constant::getNullValue(Address->getType()));
574 }
Chris Lattnerc24b9c42010-04-10 18:34:14 +0000575
Richard Smith2c9f87c2012-08-24 00:54:33 +0000576 if (!Ty->isIncompleteType()) {
577 uint64_t Size = getContext().getTypeSizeInChars(Ty).getQuantity();
578 uint64_t AlignVal = Alignment.getQuantity();
579 if (!AlignVal)
580 AlignVal = getContext().getTypeAlignInChars(Ty).getQuantity();
581
582 // This needs to be to the standard address space.
583 Address = Builder.CreateBitCast(Address, Int8PtrTy);
584
585 // The glvalue must refer to a large enough storage region.
586 // FIXME: If -faddress-sanitizer is enabled, insert dynamic instrumentation
587 // to check this.
588 llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::objectsize, IntPtrTy);
589 llvm::Value *Min = Builder.getFalse();
590 llvm::Value *LargeEnough =
591 Builder.CreateICmpUGE(Builder.CreateCall2(F, Address, Min),
592 llvm::ConstantInt::get(IntPtrTy, Size));
593 Cond = Cond ? Builder.CreateAnd(Cond, LargeEnough) : LargeEnough;
594
595 // The glvalue must be suitably aligned.
596 llvm::Value *Align =
597 Builder.CreateAnd(Builder.CreatePtrToInt(Address, IntPtrTy),
598 llvm::ConstantInt::get(IntPtrTy, AlignVal - 1));
599 Cond = Builder.CreateAnd(Cond,
600 Builder.CreateICmpEQ(Align, llvm::ConstantInt::get(IntPtrTy, 0)));
601 }
602
Richard Smith7ac9ef12012-09-08 02:08:36 +0000603 if (Cond)
604 EmitCheck(Cond);
Mike Stumpb14e62d2009-12-16 02:57:00 +0000605}
Chris Lattner9b655512007-08-31 22:49:20 +0000606
Chris Lattnerdd36d322010-01-09 21:40:03 +0000607
Chris Lattnerdd36d322010-01-09 21:40:03 +0000608CodeGenFunction::ComplexPairTy CodeGenFunction::
609EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV,
610 bool isInc, bool isPre) {
611 ComplexPairTy InVal = LoadComplexFromAddr(LV.getAddress(),
612 LV.isVolatileQualified());
613
614 llvm::Value *NextVal;
615 if (isa<llvm::IntegerType>(InVal.first->getType())) {
616 uint64_t AmountVal = isInc ? 1 : -1;
617 NextVal = llvm::ConstantInt::get(InVal.first->getType(), AmountVal, true);
618
619 // Add the inc/dec to the real part.
620 NextVal = Builder.CreateAdd(InVal.first, NextVal, isInc ? "inc" : "dec");
621 } else {
622 QualType ElemTy = E->getType()->getAs<ComplexType>()->getElementType();
623 llvm::APFloat FVal(getContext().getFloatTypeSemantics(ElemTy), 1);
624 if (!isInc)
625 FVal.changeSign();
626 NextVal = llvm::ConstantFP::get(getLLVMContext(), FVal);
627
628 // Add the inc/dec to the real part.
629 NextVal = Builder.CreateFAdd(InVal.first, NextVal, isInc ? "inc" : "dec");
630 }
631
632 ComplexPairTy IncVal(NextVal, InVal.second);
633
634 // Store the updated result through the lvalue.
635 StoreComplexToAddr(IncVal, LV.getAddress(), LV.isVolatileQualified());
636
637 // If this is a postinc, return the value read from memory, otherwise use the
638 // updated value.
639 return isPre ? IncVal : InVal;
640}
641
642
Reid Spencer5f016e22007-07-11 17:01:13 +0000643//===----------------------------------------------------------------------===//
644// LValue Expression Emission
645//===----------------------------------------------------------------------===//
646
Daniel Dunbar13e81732009-02-05 07:09:07 +0000647RValue CodeGenFunction::GetUndefRValue(QualType Ty) {
Chris Lattnereb99b012009-10-28 17:39:19 +0000648 if (Ty->isVoidType())
Daniel Dunbar13e81732009-02-05 07:09:07 +0000649 return RValue::get(0);
Chris Lattnereb99b012009-10-28 17:39:19 +0000650
651 if (const ComplexType *CTy = Ty->getAs<ComplexType>()) {
Chris Lattner2acc6e32011-07-18 04:24:23 +0000652 llvm::Type *EltTy = ConvertType(CTy->getElementType());
Owen Anderson03e20502009-07-30 23:11:26 +0000653 llvm::Value *U = llvm::UndefValue::get(EltTy);
Daniel Dunbar8fa73ed2009-01-09 20:09:28 +0000654 return RValue::getComplex(std::make_pair(U, U));
Chris Lattnereb99b012009-10-28 17:39:19 +0000655 }
656
Chris Lattnerb6c504b2010-08-23 05:26:13 +0000657 // If this is a use of an undefined aggregate type, the aggregate must have an
658 // identifiable address. Just because the contents of the value are undefined
659 // doesn't mean that the address can't be taken and compared.
Chris Lattnereb99b012009-10-28 17:39:19 +0000660 if (hasAggregateLLVMType(Ty)) {
Chris Lattnerb6c504b2010-08-23 05:26:13 +0000661 llvm::Value *DestPtr = CreateMemTemp(Ty, "undef.agg.tmp");
662 return RValue::getAggregate(DestPtr);
Daniel Dunbar8fa73ed2009-01-09 20:09:28 +0000663 }
Chris Lattnereb99b012009-10-28 17:39:19 +0000664
665 return RValue::get(llvm::UndefValue::get(ConvertType(Ty)));
Daniel Dunbarce1d38b2009-01-09 16:50:52 +0000666}
667
Daniel Dunbar13e81732009-02-05 07:09:07 +0000668RValue CodeGenFunction::EmitUnsupportedRValue(const Expr *E,
669 const char *Name) {
670 ErrorUnsupported(E, Name);
671 return GetUndefRValue(E->getType());
672}
673
Daniel Dunbar6ba82a42008-08-25 20:45:57 +0000674LValue CodeGenFunction::EmitUnsupportedLValue(const Expr *E,
675 const char *Name) {
676 ErrorUnsupported(E, Name);
Owen Anderson96e0fc72009-07-29 22:16:19 +0000677 llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType()));
Daniel Dunbar9f553f52010-08-21 03:08:16 +0000678 return MakeAddrLValue(llvm::UndefValue::get(Ty), E->getType());
Daniel Dunbar6ba82a42008-08-25 20:45:57 +0000679}
680
Richard Smith7ac9ef12012-09-08 02:08:36 +0000681LValue CodeGenFunction::EmitCheckedLValue(const Expr *E, TypeCheckKind TCK) {
Mike Stumpb14e62d2009-12-16 02:57:00 +0000682 LValue LV = EmitLValue(E);
Daniel Dunbarf0fe5bc2010-04-05 21:36:35 +0000683 if (!isa<DeclRefExpr>(E) && !LV.isBitField() && LV.isSimple())
Richard Smith7ac9ef12012-09-08 02:08:36 +0000684 EmitTypeCheck(TCK, LV.getAddress(), E->getType(), LV.getAlignment());
Mike Stumpb14e62d2009-12-16 02:57:00 +0000685 return LV;
686}
687
Reid Spencer5f016e22007-07-11 17:01:13 +0000688/// EmitLValue - Emit code to compute a designator that specifies the location
689/// of the expression.
690///
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000691/// This can return one of two things: a simple address or a bitfield reference.
692/// In either case, the LLVM Value* in the LValue structure is guaranteed to be
693/// an LLVM pointer type.
Reid Spencer5f016e22007-07-11 17:01:13 +0000694///
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000695/// If this returns a bitfield reference, nothing about the pointee type of the
696/// LLVM value is known: For example, it may not be a pointer to an integer.
Reid Spencer5f016e22007-07-11 17:01:13 +0000697///
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000698/// If this returns a normal address, and if the lvalue's C type is fixed size,
699/// this method guarantees that the returned pointer type will point to an LLVM
700/// type of the same size of the lvalue's type. If the lvalue has a variable
701/// length type, this is not possible.
Reid Spencer5f016e22007-07-11 17:01:13 +0000702///
703LValue CodeGenFunction::EmitLValue(const Expr *E) {
704 switch (E->getStmtClass()) {
Daniel Dunbar6ba82a42008-08-25 20:45:57 +0000705 default: return EmitUnsupportedLValue(E, "l-value expression");
Reid Spencer5f016e22007-07-11 17:01:13 +0000706
John McCalldb458062011-11-07 03:59:57 +0000707 case Expr::ObjCPropertyRefExprClass:
708 llvm_unreachable("cannot emit a property reference directly");
709
Fariborz Jahanian03b29602010-06-17 19:56:20 +0000710 case Expr::ObjCSelectorExprClass:
711 return EmitObjCSelectorLValue(cast<ObjCSelectorExpr>(E));
Fariborz Jahanian820bca42009-12-09 23:35:29 +0000712 case Expr::ObjCIsaExprClass:
713 return EmitObjCIsaExpr(cast<ObjCIsaExpr>(E));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000714 case Expr::BinaryOperatorClass:
Daniel Dunbar80e62c22008-09-04 03:20:13 +0000715 return EmitBinaryOperatorLValue(cast<BinaryOperator>(E));
Douglas Gregor6a03e342010-04-23 04:16:32 +0000716 case Expr::CompoundAssignOperatorClass:
John McCall2a416372010-12-05 02:00:02 +0000717 if (!E->getType()->isAnyComplexType())
718 return EmitCompoundAssignmentLValue(cast<CompoundAssignOperator>(E));
719 return EmitComplexCompoundAssignmentLValue(cast<CompoundAssignOperator>(E));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000720 case Expr::CallExprClass:
Anders Carlssonfaf86642009-09-01 21:18:52 +0000721 case Expr::CXXMemberCallExprClass:
Douglas Gregorb4609802008-11-14 16:09:21 +0000722 case Expr::CXXOperatorCallExprClass:
Richard Smith9fcce652012-03-07 08:35:16 +0000723 case Expr::UserDefinedLiteralClass:
Douglas Gregorb4609802008-11-14 16:09:21 +0000724 return EmitCallExprLValue(cast<CallExpr>(E));
Daniel Dunbar5b5c9ef2009-02-11 20:59:32 +0000725 case Expr::VAArgExprClass:
726 return EmitVAArgExprLValue(cast<VAArgExpr>(E));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000727 case Expr::DeclRefExprClass:
Douglas Gregor1a49af92009-01-06 05:10:23 +0000728 return EmitDeclRefLValue(cast<DeclRefExpr>(E));
Eric Christopher6aff47d2011-09-08 17:15:04 +0000729 case Expr::ParenExprClass:
730 return EmitLValue(cast<ParenExpr>(E)->getSubExpr());
Peter Collingbournef111d932011-04-15 00:35:48 +0000731 case Expr::GenericSelectionExprClass:
732 return EmitLValue(cast<GenericSelectionExpr>(E)->getResultExpr());
Chris Lattnerd9f69102008-08-10 01:53:14 +0000733 case Expr::PredefinedExprClass:
734 return EmitPredefinedLValue(cast<PredefinedExpr>(E));
Reid Spencer5f016e22007-07-11 17:01:13 +0000735 case Expr::StringLiteralClass:
736 return EmitStringLiteralLValue(cast<StringLiteral>(E));
Chris Lattnereaf2bb82009-02-24 22:18:39 +0000737 case Expr::ObjCEncodeExprClass:
738 return EmitObjCEncodeExprLValue(cast<ObjCEncodeExpr>(E));
John McCall4b9c2d22011-11-06 09:01:30 +0000739 case Expr::PseudoObjectExprClass:
740 return EmitPseudoObjectLValue(cast<PseudoObjectExpr>(E));
Sebastian Redl13dc8f92011-11-27 16:50:07 +0000741 case Expr::InitListExprClass:
Richard Smith13ec9102012-05-14 21:57:21 +0000742 return EmitInitListLValue(cast<InitListExpr>(E));
Anders Carlssonb58d0172009-05-30 23:23:33 +0000743 case Expr::CXXTemporaryObjectExprClass:
744 case Expr::CXXConstructExprClass:
Anders Carlssone61c9e82009-05-30 23:30:54 +0000745 return EmitCXXConstructLValue(cast<CXXConstructExpr>(E));
746 case Expr::CXXBindTemporaryExprClass:
747 return EmitCXXBindTemporaryLValue(cast<CXXBindTemporaryExpr>(E));
Eli Friedman31a37022012-02-08 05:34:55 +0000748 case Expr::LambdaExprClass:
749 return EmitLambdaLValue(cast<LambdaExpr>(E));
John McCall1a343eb2011-11-10 08:15:53 +0000750
751 case Expr::ExprWithCleanupsClass: {
752 const ExprWithCleanups *cleanups = cast<ExprWithCleanups>(E);
753 enterFullExpression(cleanups);
754 RunCleanupsScope Scope(*this);
755 return EmitLValue(cleanups->getSubExpr());
756 }
757
Douglas Gregored8abf12010-07-08 06:14:04 +0000758 case Expr::CXXScalarValueInitExprClass:
759 return EmitNullInitializationLValue(cast<CXXScalarValueInitExpr>(E));
Anders Carlsson370e5382009-11-14 01:51:50 +0000760 case Expr::CXXDefaultArgExprClass:
761 return EmitLValue(cast<CXXDefaultArgExpr>(E)->getExpr());
Mike Stumpc2e84ae2009-11-15 08:09:41 +0000762 case Expr::CXXTypeidExprClass:
763 return EmitCXXTypeidLValue(cast<CXXTypeidExpr>(E));
Anders Carlssone61c9e82009-05-30 23:30:54 +0000764
Daniel Dunbar0a04d772008-08-23 10:51:21 +0000765 case Expr::ObjCMessageExprClass:
766 return EmitObjCMessageExprLValue(cast<ObjCMessageExpr>(E));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000767 case Expr::ObjCIvarRefExprClass:
Chris Lattner391d77a2008-03-30 23:03:07 +0000768 return EmitObjCIvarRefLValue(cast<ObjCIvarRefExpr>(E));
Chris Lattner65459942009-04-25 19:35:26 +0000769 case Expr::StmtExprClass:
770 return EmitStmtExprLValue(cast<StmtExpr>(E));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000771 case Expr::UnaryOperatorClass:
Reid Spencer5f016e22007-07-11 17:01:13 +0000772 return EmitUnaryOpLValue(cast<UnaryOperator>(E));
773 case Expr::ArraySubscriptExprClass:
774 return EmitArraySubscriptExpr(cast<ArraySubscriptExpr>(E));
Nate Begeman213541a2008-04-18 23:10:10 +0000775 case Expr::ExtVectorElementExprClass:
776 return EmitExtVectorElementExpr(cast<ExtVectorElementExpr>(E));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000777 case Expr::MemberExprClass:
Douglas Gregorbd4c4ae2009-08-26 22:36:53 +0000778 return EmitMemberExpr(cast<MemberExpr>(E));
Eli Friedman06e863f2008-05-13 23:18:27 +0000779 case Expr::CompoundLiteralExprClass:
780 return EmitCompoundLiteralLValue(cast<CompoundLiteralExpr>(E));
Daniel Dunbar90345582009-03-24 02:38:23 +0000781 case Expr::ConditionalOperatorClass:
Anders Carlsson6fcec8b2009-09-15 16:35:24 +0000782 return EmitConditionalOperatorLValue(cast<ConditionalOperator>(E));
John McCall56ca35d2011-02-17 10:25:35 +0000783 case Expr::BinaryConditionalOperatorClass:
784 return EmitConditionalOperatorLValue(cast<BinaryConditionalOperator>(E));
Chris Lattner670a62c2008-12-12 05:35:08 +0000785 case Expr::ChooseExprClass:
Eli Friedman79769322009-03-04 05:52:32 +0000786 return EmitLValue(cast<ChooseExpr>(E)->getChosenSubExpr(getContext()));
John McCalle996ffd2011-02-16 08:02:54 +0000787 case Expr::OpaqueValueExprClass:
788 return EmitOpaqueValueLValue(cast<OpaqueValueExpr>(E));
John McCall91a57552011-07-15 05:09:51 +0000789 case Expr::SubstNonTypeTemplateParmExprClass:
790 return EmitLValue(cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement());
Chris Lattnerc3953a62009-03-18 04:02:57 +0000791 case Expr::ImplicitCastExprClass:
792 case Expr::CStyleCastExprClass:
793 case Expr::CXXFunctionalCastExprClass:
794 case Expr::CXXStaticCastExprClass:
795 case Expr::CXXDynamicCastExprClass:
796 case Expr::CXXReinterpretCastExprClass:
797 case Expr::CXXConstCastExprClass:
John McCallf85e1932011-06-15 23:02:42 +0000798 case Expr::ObjCBridgedCastExprClass:
Chris Lattner75dfeda2009-03-18 18:28:57 +0000799 return EmitCastLValue(cast<CastExpr>(E));
Sebastian Redl13dc8f92011-11-27 16:50:07 +0000800
Douglas Gregor03e80032011-06-21 17:03:29 +0000801 case Expr::MaterializeTemporaryExprClass:
802 return EmitMaterializeTemporaryExpr(cast<MaterializeTemporaryExpr>(E));
Reid Spencer5f016e22007-07-11 17:01:13 +0000803 }
804}
805
John McCalldd2ecee2012-03-10 03:05:10 +0000806/// Given an object of the given canonical type, can we safely copy a
807/// value out of it based on its initializer?
808static bool isConstantEmittableObjectType(QualType type) {
809 assert(type.isCanonical());
810 assert(!type->isReferenceType());
811
812 // Must be const-qualified but non-volatile.
813 Qualifiers qs = type.getLocalQualifiers();
814 if (!qs.hasConst() || qs.hasVolatile()) return false;
815
816 // Otherwise, all object types satisfy this except C++ classes with
817 // mutable subobjects or non-trivial copy/destroy behavior.
818 if (const RecordType *RT = dyn_cast<RecordType>(type))
819 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl()))
820 if (RD->hasMutableFields() || !RD->isTrivial())
821 return false;
822
823 return true;
824}
825
826/// Can we constant-emit a load of a reference to a variable of the
827/// given type? This is different from predicates like
828/// Decl::isUsableInConstantExpressions because we do want it to apply
829/// in situations that don't necessarily satisfy the language's rules
830/// for this (e.g. C++'s ODR-use rules). For example, we want to able
831/// to do this with const float variables even if those variables
832/// aren't marked 'constexpr'.
833enum ConstantEmissionKind {
834 CEK_None,
835 CEK_AsReferenceOnly,
836 CEK_AsValueOrReference,
837 CEK_AsValueOnly
838};
839static ConstantEmissionKind checkVarTypeForConstantEmission(QualType type) {
840 type = type.getCanonicalType();
841 if (const ReferenceType *ref = dyn_cast<ReferenceType>(type)) {
842 if (isConstantEmittableObjectType(ref->getPointeeType()))
843 return CEK_AsValueOrReference;
844 return CEK_AsReferenceOnly;
845 }
846 if (isConstantEmittableObjectType(type))
847 return CEK_AsValueOnly;
848 return CEK_None;
849}
850
851/// Try to emit a reference to the given value without producing it as
852/// an l-value. This is actually more than an optimization: we can't
853/// produce an l-value for variables that we never actually captured
854/// in a block or lambda, which means const int variables or constexpr
855/// literals or similar.
856CodeGenFunction::ConstantEmission
John McCallf4b88a42012-03-10 09:33:50 +0000857CodeGenFunction::tryEmitAsConstant(DeclRefExpr *refExpr) {
858 ValueDecl *value = refExpr->getDecl();
859
John McCalldd2ecee2012-03-10 03:05:10 +0000860 // The value needs to be an enum constant or a constant variable.
861 ConstantEmissionKind CEK;
862 if (isa<ParmVarDecl>(value)) {
863 CEK = CEK_None;
864 } else if (VarDecl *var = dyn_cast<VarDecl>(value)) {
865 CEK = checkVarTypeForConstantEmission(var->getType());
866 } else if (isa<EnumConstantDecl>(value)) {
867 CEK = CEK_AsValueOnly;
868 } else {
869 CEK = CEK_None;
870 }
871 if (CEK == CEK_None) return ConstantEmission();
872
John McCalldd2ecee2012-03-10 03:05:10 +0000873 Expr::EvalResult result;
874 bool resultIsReference;
875 QualType resultType;
876
877 // It's best to evaluate all the way as an r-value if that's permitted.
878 if (CEK != CEK_AsReferenceOnly &&
John McCallf4b88a42012-03-10 09:33:50 +0000879 refExpr->EvaluateAsRValue(result, getContext())) {
John McCalldd2ecee2012-03-10 03:05:10 +0000880 resultIsReference = false;
881 resultType = refExpr->getType();
882
883 // Otherwise, try to evaluate as an l-value.
884 } else if (CEK != CEK_AsValueOnly &&
John McCallf4b88a42012-03-10 09:33:50 +0000885 refExpr->EvaluateAsLValue(result, getContext())) {
John McCalldd2ecee2012-03-10 03:05:10 +0000886 resultIsReference = true;
887 resultType = value->getType();
888
889 // Failure.
890 } else {
891 return ConstantEmission();
892 }
893
894 // In any case, if the initializer has side-effects, abandon ship.
895 if (result.HasSideEffects)
896 return ConstantEmission();
897
898 // Emit as a constant.
899 llvm::Constant *C = CGM.EmitConstantValue(result.Val, resultType, this);
900
901 // Make sure we emit a debug reference to the global variable.
902 // This should probably fire even for
903 if (isa<VarDecl>(value)) {
904 if (!getContext().DeclMustBeEmitted(cast<VarDecl>(value)))
John McCallf4b88a42012-03-10 09:33:50 +0000905 EmitDeclRefExprDbgValue(refExpr, C);
John McCalldd2ecee2012-03-10 03:05:10 +0000906 } else {
907 assert(isa<EnumConstantDecl>(value));
John McCallf4b88a42012-03-10 09:33:50 +0000908 EmitDeclRefExprDbgValue(refExpr, C);
John McCalldd2ecee2012-03-10 03:05:10 +0000909 }
910
911 // If we emitted a reference constant, we need to dereference that.
912 if (resultIsReference)
913 return ConstantEmission::forReference(C);
914
915 return ConstantEmission::forValue(C);
916}
917
John McCalla07398e2011-06-16 04:16:24 +0000918llvm::Value *CodeGenFunction::EmitLoadOfScalar(LValue lvalue) {
919 return EmitLoadOfScalar(lvalue.getAddress(), lvalue.isVolatile(),
Eli Friedman6da2c712011-12-03 04:14:32 +0000920 lvalue.getAlignment().getQuantity(),
921 lvalue.getType(), lvalue.getTBAAInfo());
John McCalla07398e2011-06-16 04:16:24 +0000922}
923
Rafael Espindolac3f89552012-03-24 16:50:34 +0000924static bool hasBooleanRepresentation(QualType Ty) {
925 if (Ty->isBooleanType())
926 return true;
927
928 if (const EnumType *ET = Ty->getAs<EnumType>())
929 return ET->getDecl()->getIntegerType()->isBooleanType();
930
Douglas Gregor47bfcca2012-04-12 20:42:30 +0000931 if (const AtomicType *AT = Ty->getAs<AtomicType>())
932 return hasBooleanRepresentation(AT->getValueType());
933
Rafael Espindolac3f89552012-03-24 16:50:34 +0000934 return false;
935}
936
937llvm::MDNode *CodeGenFunction::getRangeForLoadFromType(QualType Ty) {
938 const EnumType *ET = Ty->getAs<EnumType>();
Chandler Carruth82fe6ae2012-03-27 23:58:37 +0000939 bool IsRegularCPlusPlusEnum = (getLangOpts().CPlusPlus && ET &&
940 CGM.getCodeGenOpts().StrictEnums &&
941 !ET->getDecl()->isFixed());
Rafael Espindolac3f89552012-03-24 16:50:34 +0000942 bool IsBool = hasBooleanRepresentation(Ty);
Rafael Espindolac3f89552012-03-24 16:50:34 +0000943 if (!IsBool && !IsRegularCPlusPlusEnum)
944 return NULL;
945
946 llvm::APInt Min;
947 llvm::APInt End;
948 if (IsBool) {
949 Min = llvm::APInt(8, 0);
950 End = llvm::APInt(8, 2);
Rafael Espindolac3f89552012-03-24 16:50:34 +0000951 } else {
952 const EnumDecl *ED = ET->getDecl();
Ted Kremenekcf18ae52012-05-01 17:56:53 +0000953 llvm::Type *LTy = ConvertTypeForMem(ED->getIntegerType());
Rafael Espindolac3f89552012-03-24 16:50:34 +0000954 unsigned Bitwidth = LTy->getScalarSizeInBits();
955 unsigned NumNegativeBits = ED->getNumNegativeBits();
956 unsigned NumPositiveBits = ED->getNumPositiveBits();
957
958 if (NumNegativeBits) {
959 unsigned NumBits = std::max(NumNegativeBits, NumPositiveBits + 1);
960 assert(NumBits <= Bitwidth);
961 End = llvm::APInt(Bitwidth, 1) << (NumBits - 1);
962 Min = -End;
963 } else {
964 assert(NumPositiveBits <= Bitwidth);
965 End = llvm::APInt(Bitwidth, 1) << NumPositiveBits;
966 Min = llvm::APInt(Bitwidth, 0);
967 }
968 }
969
Duncan Sands2d7cb062012-04-15 18:04:54 +0000970 llvm::MDBuilder MDHelper(getLLVMContext());
Duncan Sands60c77072012-04-16 16:29:47 +0000971 return MDHelper.createRange(Min, End);
Rafael Espindolac3f89552012-03-24 16:50:34 +0000972}
973
Daniel Dunbar9d9cc872009-02-10 00:57:50 +0000974llvm::Value *CodeGenFunction::EmitLoadOfScalar(llvm::Value *Addr, bool Volatile,
Dan Gohman3d5aff52010-10-14 23:06:10 +0000975 unsigned Alignment, QualType Ty,
976 llvm::MDNode *TBAAInfo) {
Tanya Lattnerc58dcdc2012-08-16 00:10:13 +0000977
978 // For better performance, handle vector loads differently.
979 if (Ty->isVectorType()) {
980 llvm::Value *V;
981 const llvm::Type *EltTy =
982 cast<llvm::PointerType>(Addr->getType())->getElementType();
983
984 const llvm::VectorType *VTy = cast<llvm::VectorType>(EltTy);
985
986 // Handle vectors of size 3, like size 4 for better performance.
987 if (VTy->getNumElements() == 3) {
988
989 // Bitcast to vec4 type.
990 llvm::VectorType *vec4Ty = llvm::VectorType::get(VTy->getElementType(),
991 4);
992 llvm::PointerType *ptVec4Ty =
993 llvm::PointerType::get(vec4Ty,
994 (cast<llvm::PointerType>(
995 Addr->getType()))->getAddressSpace());
996 llvm::Value *Cast = Builder.CreateBitCast(Addr, ptVec4Ty,
997 "castToVec4");
998 // Now load value.
999 llvm::Value *LoadVal = Builder.CreateLoad(Cast, Volatile, "loadVec4");
1000
1001 // Shuffle vector to get vec3.
1002 llvm::SmallVector<llvm::Constant*, 3> Mask;
1003 Mask.push_back(llvm::ConstantInt::get(
1004 llvm::Type::getInt32Ty(getLLVMContext()),
1005 0));
1006 Mask.push_back(llvm::ConstantInt::get(
1007 llvm::Type::getInt32Ty(getLLVMContext()),
1008 1));
1009 Mask.push_back(llvm::ConstantInt::get(
1010 llvm::Type::getInt32Ty(getLLVMContext()),
1011 2));
1012
1013 llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
1014 V = Builder.CreateShuffleVector(LoadVal,
1015 llvm::UndefValue::get(vec4Ty),
1016 MaskV, "extractVec");
1017 return EmitFromMemory(V, Ty);
1018 }
1019 }
1020
Benjamin Kramer578faa82011-09-27 21:06:10 +00001021 llvm::LoadInst *Load = Builder.CreateLoad(Addr);
Daniel Dunbar2da84ff2009-11-29 21:23:36 +00001022 if (Volatile)
1023 Load->setVolatile(true);
Daniel Dunbar91a16fa2010-08-21 02:24:36 +00001024 if (Alignment)
1025 Load->setAlignment(Alignment);
Dan Gohman3d5aff52010-10-14 23:06:10 +00001026 if (TBAAInfo)
1027 CGM.DecorateInstruction(Load, TBAAInfo);
David Chisnall7a7ee302012-01-16 17:27:18 +00001028 // If this is an atomic type, all normal reads must be atomic
1029 if (Ty->isAtomicType())
1030 Load->setAtomic(llvm::SequentiallyConsistent);
Daniel Dunbar9d9cc872009-02-10 00:57:50 +00001031
Rafael Espindolac3f89552012-03-24 16:50:34 +00001032 if (CGM.getCodeGenOpts().OptimizationLevel > 0)
1033 if (llvm::MDNode *RangeInfo = getRangeForLoadFromType(Ty))
1034 Load->setMetadata(llvm::LLVMContext::MD_range, RangeInfo);
Douglas Gregor1274ccd2010-10-08 23:50:27 +00001035
Rafael Espindolac3f89552012-03-24 16:50:34 +00001036 return EmitFromMemory(Load, Ty);
NAKAMURA Takumi88a569a2012-03-24 14:43:42 +00001037}
1038
John McCall26815d92010-10-27 20:58:56 +00001039llvm::Value *CodeGenFunction::EmitToMemory(llvm::Value *Value, QualType Ty) {
1040 // Bool has a different representation in memory than in registers.
Rafael Espindolac3f89552012-03-24 16:50:34 +00001041 if (hasBooleanRepresentation(Ty)) {
John McCall26815d92010-10-27 20:58:56 +00001042 // This should really always be an i1, but sometimes it's already
1043 // an i8, and it's awkward to track those cases down.
1044 if (Value->getType()->isIntegerTy(1))
1045 return Builder.CreateZExt(Value, Builder.getInt8Ty(), "frombool");
1046 assert(Value->getType()->isIntegerTy(8) && "value rep of bool not i1/i8");
1047 }
1048
1049 return Value;
1050}
1051
1052llvm::Value *CodeGenFunction::EmitFromMemory(llvm::Value *Value, QualType Ty) {
1053 // Bool has a different representation in memory than in registers.
Rafael Espindolac3f89552012-03-24 16:50:34 +00001054 if (hasBooleanRepresentation(Ty)) {
John McCall26815d92010-10-27 20:58:56 +00001055 assert(Value->getType()->isIntegerTy(8) && "memory rep of bool not i8");
1056 return Builder.CreateTrunc(Value, Builder.getInt1Ty(), "tobool");
1057 }
1058
1059 return Value;
1060}
1061
Daniel Dunbar9d9cc872009-02-10 00:57:50 +00001062void CodeGenFunction::EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr,
Daniel Dunbar91a16fa2010-08-21 02:24:36 +00001063 bool Volatile, unsigned Alignment,
Dan Gohman3d5aff52010-10-14 23:06:10 +00001064 QualType Ty,
David Chisnall7a7ee302012-01-16 17:27:18 +00001065 llvm::MDNode *TBAAInfo,
1066 bool isInit) {
Tanya Lattnerc58dcdc2012-08-16 00:10:13 +00001067
1068 // Handle vectors differently to get better performance.
1069 if (Ty->isVectorType()) {
1070 llvm::Type *SrcTy = Value->getType();
1071 llvm::VectorType *VecTy = cast<llvm::VectorType>(SrcTy);
1072 // Handle vec3 special.
1073 if (VecTy->getNumElements() == 3) {
1074 llvm::LLVMContext &VMContext = getLLVMContext();
1075
1076 // Our source is a vec3, do a shuffle vector to make it a vec4.
1077 llvm::SmallVector<llvm::Constant*, 4> Mask;
1078 Mask.push_back(llvm::ConstantInt::get(
1079 llvm::Type::getInt32Ty(VMContext),
1080 0));
1081 Mask.push_back(llvm::ConstantInt::get(
1082 llvm::Type::getInt32Ty(VMContext),
1083 1));
1084 Mask.push_back(llvm::ConstantInt::get(
1085 llvm::Type::getInt32Ty(VMContext),
1086 2));
1087 Mask.push_back(llvm::UndefValue::get(llvm::Type::getInt32Ty(VMContext)));
1088
1089 llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
1090 Value = Builder.CreateShuffleVector(Value,
1091 llvm::UndefValue::get(VecTy),
1092 MaskV, "extractVec");
1093 SrcTy = llvm::VectorType::get(VecTy->getElementType(), 4);
1094 }
1095 llvm::PointerType *DstPtr = cast<llvm::PointerType>(Addr->getType());
1096 if (DstPtr->getElementType() != SrcTy) {
1097 llvm::Type *MemTy =
1098 llvm::PointerType::get(SrcTy, DstPtr->getAddressSpace());
1099 Addr = Builder.CreateBitCast(Addr, MemTy, "storetmp");
1100 }
1101 }
1102
John McCall26815d92010-10-27 20:58:56 +00001103 Value = EmitToMemory(Value, Ty);
Chris Lattner12569fb2011-07-10 03:38:35 +00001104
Daniel Dunbar91a16fa2010-08-21 02:24:36 +00001105 llvm::StoreInst *Store = Builder.CreateStore(Value, Addr, Volatile);
1106 if (Alignment)
1107 Store->setAlignment(Alignment);
Dan Gohman3d5aff52010-10-14 23:06:10 +00001108 if (TBAAInfo)
1109 CGM.DecorateInstruction(Store, TBAAInfo);
David Chisnall7a7ee302012-01-16 17:27:18 +00001110 if (!isInit && Ty->isAtomicType())
1111 Store->setAtomic(llvm::SequentiallyConsistent);
Daniel Dunbar9d9cc872009-02-10 00:57:50 +00001112}
1113
David Chisnall7a7ee302012-01-16 17:27:18 +00001114void CodeGenFunction::EmitStoreOfScalar(llvm::Value *value, LValue lvalue,
1115 bool isInit) {
John McCalla07398e2011-06-16 04:16:24 +00001116 EmitStoreOfScalar(value, lvalue.getAddress(), lvalue.isVolatile(),
Eli Friedman6da2c712011-12-03 04:14:32 +00001117 lvalue.getAlignment().getQuantity(), lvalue.getType(),
David Chisnall7a7ee302012-01-16 17:27:18 +00001118 lvalue.getTBAAInfo(), isInit);
John McCalla07398e2011-06-16 04:16:24 +00001119}
1120
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001121/// EmitLoadOfLValue - Given an expression that represents a value lvalue, this
1122/// method emits the address of the lvalue, then loads the result as an rvalue,
1123/// returning the rvalue.
John McCall545d9962011-06-25 02:11:03 +00001124RValue CodeGenFunction::EmitLoadOfLValue(LValue LV) {
Fariborz Jahaniandbd32c22008-11-19 17:34:06 +00001125 if (LV.isObjCWeak()) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001126 // load of a __weak object.
Fariborz Jahanian6dc23172008-11-18 21:45:40 +00001127 llvm::Value *AddrWeakObj = LV.getAddress();
Chris Lattnereb99b012009-10-28 17:39:19 +00001128 return RValue::get(CGM.getObjCRuntime().EmitObjCWeakRead(*this,
1129 AddrWeakObj));
Fariborz Jahanian6dc23172008-11-18 21:45:40 +00001130 }
John McCallf85e1932011-06-15 23:02:42 +00001131 if (LV.getQuals().getObjCLifetime() == Qualifiers::OCL_Weak)
1132 return RValue::get(EmitARCLoadWeak(LV.getAddress()));
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001133
Reid Spencer5f016e22007-07-11 17:01:13 +00001134 if (LV.isSimple()) {
John McCalle6d134b2011-06-27 21:24:11 +00001135 assert(!LV.getType()->isFunctionType());
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001136
John McCalld608cdb2010-08-22 10:59:02 +00001137 // Everything needs a load.
John McCall545d9962011-06-25 02:11:03 +00001138 return RValue::get(EmitLoadOfScalar(LV));
Reid Spencer5f016e22007-07-11 17:01:13 +00001139 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001140
Reid Spencer5f016e22007-07-11 17:01:13 +00001141 if (LV.isVectorElt()) {
Eli Friedmane5a8aeb2012-03-22 22:36:39 +00001142 llvm::LoadInst *Load = Builder.CreateLoad(LV.getVectorAddr(),
1143 LV.isVolatileQualified());
1144 Load->setAlignment(LV.getAlignment().getQuantity());
1145 return RValue::get(Builder.CreateExtractElement(Load, LV.getVectorIdx(),
Reid Spencer5f016e22007-07-11 17:01:13 +00001146 "vecext"));
1147 }
Chris Lattner46ea8eb2007-08-03 00:16:29 +00001148
1149 // If this is a reference to a subset of the elements of a vector, either
1150 // shuffle the input or extract/insert them as appropriate.
Nate Begeman213541a2008-04-18 23:10:10 +00001151 if (LV.isExtVectorElt())
John McCall545d9962011-06-25 02:11:03 +00001152 return EmitLoadOfExtVectorElementLValue(LV);
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +00001153
John McCalldb458062011-11-07 03:59:57 +00001154 assert(LV.isBitField() && "Unknown LValue type!");
1155 return EmitLoadOfBitfieldLValue(LV);
Reid Spencer5f016e22007-07-11 17:01:13 +00001156}
1157
John McCall545d9962011-06-25 02:11:03 +00001158RValue CodeGenFunction::EmitLoadOfBitfieldLValue(LValue LV) {
Daniel Dunbarefbf4872010-04-06 01:07:44 +00001159 const CGBitFieldInfo &Info = LV.getBitFieldInfo();
Daniel Dunbar10e3ded2008-08-06 05:08:45 +00001160
Daniel Dunbarecdb41e2010-04-13 23:34:15 +00001161 // Get the output type.
Chris Lattner2acc6e32011-07-18 04:24:23 +00001162 llvm::Type *ResLTy = ConvertType(LV.getType());
Daniel Dunbarecdb41e2010-04-13 23:34:15 +00001163 unsigned ResSizeInBits = CGM.getTargetData().getTypeSizeInBits(ResLTy);
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +00001164
Daniel Dunbarecdb41e2010-04-13 23:34:15 +00001165 // Compute the result as an OR of all of the individual component accesses.
1166 llvm::Value *Res = 0;
1167 for (unsigned i = 0, e = Info.getNumComponents(); i != e; ++i) {
1168 const CGBitFieldInfo::AccessInfo &AI = Info.getComponent(i);
Eli Friedmanf4bcfa12012-06-27 21:19:48 +00001169 CharUnits AccessAlignment = AI.AccessAlignment;
1170 if (!LV.getAlignment().isZero())
1171 AccessAlignment = std::min(AccessAlignment, LV.getAlignment());
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001172
Daniel Dunbarecdb41e2010-04-13 23:34:15 +00001173 // Get the field pointer.
1174 llvm::Value *Ptr = LV.getBitFieldBaseAddr();
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001175
Daniel Dunbarecdb41e2010-04-13 23:34:15 +00001176 // Only offset by the field index if used, so that incoming values are not
1177 // required to be structures.
1178 if (AI.FieldIndex)
1179 Ptr = Builder.CreateStructGEP(Ptr, AI.FieldIndex, "bf.field");
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001180
Daniel Dunbarecdb41e2010-04-13 23:34:15 +00001181 // Offset by the byte offset, if used.
Ken Dyck28ebde52011-04-24 10:04:59 +00001182 if (!AI.FieldByteOffset.isZero()) {
John McCalld16c2cf2011-02-08 08:22:06 +00001183 Ptr = EmitCastToVoidPtr(Ptr);
Ken Dyck28ebde52011-04-24 10:04:59 +00001184 Ptr = Builder.CreateConstGEP1_32(Ptr, AI.FieldByteOffset.getQuantity(),
1185 "bf.field.offs");
Daniel Dunbarecdb41e2010-04-13 23:34:15 +00001186 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001187
Daniel Dunbarecdb41e2010-04-13 23:34:15 +00001188 // Cast to the access type.
Chris Lattner8b418682012-02-07 00:39:47 +00001189 llvm::Type *PTy = llvm::Type::getIntNPtrTy(getLLVMContext(), AI.AccessWidth,
John McCall545d9962011-06-25 02:11:03 +00001190 CGM.getContext().getTargetAddressSpace(LV.getType()));
Daniel Dunbarecdb41e2010-04-13 23:34:15 +00001191 Ptr = Builder.CreateBitCast(Ptr, PTy);
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +00001192
Daniel Dunbarecdb41e2010-04-13 23:34:15 +00001193 // Perform the load.
1194 llvm::LoadInst *Load = Builder.CreateLoad(Ptr, LV.isVolatileQualified());
Eli Friedmanf4bcfa12012-06-27 21:19:48 +00001195 Load->setAlignment(AccessAlignment.getQuantity());
Daniel Dunbarecdb41e2010-04-13 23:34:15 +00001196
1197 // Shift out unused low bits and mask out unused high bits.
1198 llvm::Value *Val = Load;
1199 if (AI.FieldBitStart)
Daniel Dunbar26772612010-04-15 03:47:33 +00001200 Val = Builder.CreateLShr(Load, AI.FieldBitStart);
Daniel Dunbarecdb41e2010-04-13 23:34:15 +00001201 Val = Builder.CreateAnd(Val, llvm::APInt::getLowBitsSet(AI.AccessWidth,
1202 AI.TargetBitWidth),
1203 "bf.clear");
1204
1205 // Extend or truncate to the target size.
1206 if (AI.AccessWidth < ResSizeInBits)
1207 Val = Builder.CreateZExt(Val, ResLTy);
1208 else if (AI.AccessWidth > ResSizeInBits)
1209 Val = Builder.CreateTrunc(Val, ResLTy);
1210
1211 // Shift into place, and OR into the result.
1212 if (AI.TargetBitOffset)
1213 Val = Builder.CreateShl(Val, AI.TargetBitOffset);
1214 Res = Res ? Builder.CreateOr(Res, Val) : Val;
Daniel Dunbar10e3ded2008-08-06 05:08:45 +00001215 }
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +00001216
Daniel Dunbarecdb41e2010-04-13 23:34:15 +00001217 // If the bit-field is signed, perform the sign-extension.
1218 //
1219 // FIXME: This can easily be folded into the load of the high bits, which
1220 // could also eliminate the mask of high bits in some situations.
1221 if (Info.isSigned()) {
Daniel Dunbar26772612010-04-15 03:47:33 +00001222 unsigned ExtraBits = ResSizeInBits - Info.getSize();
Daniel Dunbarecdb41e2010-04-13 23:34:15 +00001223 if (ExtraBits)
1224 Res = Builder.CreateAShr(Builder.CreateShl(Res, ExtraBits),
1225 ExtraBits, "bf.val.sext");
Daniel Dunbar10e3ded2008-08-06 05:08:45 +00001226 }
Eli Friedman316bb1b2008-05-17 20:03:47 +00001227
Daniel Dunbarecdb41e2010-04-13 23:34:15 +00001228 return RValue::get(Res);
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +00001229}
1230
Nate Begeman6fe7c8a2009-01-18 06:42:49 +00001231// If this is a reference to a subset of the elements of a vector, create an
1232// appropriate shufflevector.
John McCall545d9962011-06-25 02:11:03 +00001233RValue CodeGenFunction::EmitLoadOfExtVectorElementLValue(LValue LV) {
Eli Friedmane5a8aeb2012-03-22 22:36:39 +00001234 llvm::LoadInst *Load = Builder.CreateLoad(LV.getExtVectorAddr(),
1235 LV.isVolatileQualified());
1236 Load->setAlignment(LV.getAlignment().getQuantity());
1237 llvm::Value *Vec = Load;
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001238
Nate Begeman8a997642008-05-09 06:41:27 +00001239 const llvm::Constant *Elts = LV.getExtVectorElts();
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001240
1241 // If the result of the expression is a non-vector type, we must be extracting
1242 // a single element. Just codegen as an extractelement.
John McCall545d9962011-06-25 02:11:03 +00001243 const VectorType *ExprVT = LV.getType()->getAs<VectorType>();
Chris Lattnercf60cd22007-08-10 17:10:08 +00001244 if (!ExprVT) {
Dan Gohman4f8d1232008-05-22 00:50:06 +00001245 unsigned InIdx = getAccessedFieldNo(0, Elts);
Chris Lattner77b89b82010-06-27 07:15:29 +00001246 llvm::Value *Elt = llvm::ConstantInt::get(Int32Ty, InIdx);
Benjamin Kramer578faa82011-09-27 21:06:10 +00001247 return RValue::get(Builder.CreateExtractElement(Vec, Elt));
Chris Lattner34cdc862007-08-03 16:18:34 +00001248 }
Nate Begeman6fe7c8a2009-01-18 06:42:49 +00001249
1250 // Always use shuffle vector to try to retain the original program structure
Chris Lattnercf60cd22007-08-10 17:10:08 +00001251 unsigned NumResultElts = ExprVT->getNumElements();
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001252
Chris Lattner5f9e2722011-07-23 10:55:15 +00001253 SmallVector<llvm::Constant*, 4> Mask;
Chris Lattner2ce88422012-01-25 05:34:41 +00001254 for (unsigned i = 0; i != NumResultElts; ++i)
1255 Mask.push_back(Builder.getInt32(getAccessedFieldNo(i, Elts)));
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001256
Chris Lattnerfb018d12011-02-15 00:14:06 +00001257 llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
1258 Vec = Builder.CreateShuffleVector(Vec, llvm::UndefValue::get(Vec->getType()),
Benjamin Kramer578faa82011-09-27 21:06:10 +00001259 MaskV);
Nate Begeman6fe7c8a2009-01-18 06:42:49 +00001260 return RValue::get(Vec);
Chris Lattner34cdc862007-08-03 16:18:34 +00001261}
1262
1263
Reid Spencer5f016e22007-07-11 17:01:13 +00001264
1265/// EmitStoreThroughLValue - Store the specified rvalue into the specified
1266/// lvalue, where both are guaranteed to the have the same type, and that type
1267/// is 'Ty'.
David Chisnall7a7ee302012-01-16 17:27:18 +00001268void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit) {
Chris Lattner017d6aa2007-08-03 16:28:33 +00001269 if (!Dst.isSimple()) {
1270 if (Dst.isVectorElt()) {
1271 // Read/modify/write the vector, inserting the new element.
Eli Friedmane5a8aeb2012-03-22 22:36:39 +00001272 llvm::LoadInst *Load = Builder.CreateLoad(Dst.getVectorAddr(),
1273 Dst.isVolatileQualified());
1274 Load->setAlignment(Dst.getAlignment().getQuantity());
1275 llvm::Value *Vec = Load;
Chris Lattner9b655512007-08-31 22:49:20 +00001276 Vec = Builder.CreateInsertElement(Vec, Src.getScalarVal(),
Chris Lattner017d6aa2007-08-03 16:28:33 +00001277 Dst.getVectorIdx(), "vecins");
Eli Friedmane5a8aeb2012-03-22 22:36:39 +00001278 llvm::StoreInst *Store = Builder.CreateStore(Vec, Dst.getVectorAddr(),
1279 Dst.isVolatileQualified());
1280 Store->setAlignment(Dst.getAlignment().getQuantity());
Chris Lattner017d6aa2007-08-03 16:28:33 +00001281 return;
1282 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001283
Nate Begeman213541a2008-04-18 23:10:10 +00001284 // If this is an update of extended vector elements, insert them as
1285 // appropriate.
1286 if (Dst.isExtVectorElt())
John McCall545d9962011-06-25 02:11:03 +00001287 return EmitStoreThroughExtVectorComponentLValue(Src, Dst);
Lauro Ramos Venancioa0c5d0e2008-01-22 22:36:45 +00001288
John McCalldb458062011-11-07 03:59:57 +00001289 assert(Dst.isBitField() && "Unknown LValue type");
1290 return EmitStoreThroughBitfieldLValue(Src, Dst);
Chris Lattner017d6aa2007-08-03 16:28:33 +00001291 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001292
John McCallf85e1932011-06-15 23:02:42 +00001293 // There's special magic for assigning into an ARC-qualified l-value.
1294 if (Qualifiers::ObjCLifetime Lifetime = Dst.getQuals().getObjCLifetime()) {
1295 switch (Lifetime) {
1296 case Qualifiers::OCL_None:
1297 llvm_unreachable("present but none");
1298
1299 case Qualifiers::OCL_ExplicitNone:
1300 // nothing special
1301 break;
1302
1303 case Qualifiers::OCL_Strong:
John McCall545d9962011-06-25 02:11:03 +00001304 EmitARCStoreStrong(Dst, Src.getScalarVal(), /*ignore*/ true);
John McCallf85e1932011-06-15 23:02:42 +00001305 return;
1306
1307 case Qualifiers::OCL_Weak:
1308 EmitARCStoreWeak(Dst.getAddress(), Src.getScalarVal(), /*ignore*/ true);
1309 return;
1310
1311 case Qualifiers::OCL_Autoreleasing:
John McCall545d9962011-06-25 02:11:03 +00001312 Src = RValue::get(EmitObjCExtendObjectLifetime(Dst.getType(),
1313 Src.getScalarVal()));
John McCallf85e1932011-06-15 23:02:42 +00001314 // fall into the normal path
1315 break;
1316 }
1317 }
1318
Fariborz Jahanian4f676ed2009-02-21 00:30:43 +00001319 if (Dst.isObjCWeak() && !Dst.isNonGC()) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001320 // load of a __weak object.
Fariborz Jahaniandbd32c22008-11-19 17:34:06 +00001321 llvm::Value *LvalueDst = Dst.getAddress();
1322 llvm::Value *src = Src.getScalarVal();
Mike Stumpf33651c2009-04-14 00:57:29 +00001323 CGM.getObjCRuntime().EmitObjCWeakAssign(*this, src, LvalueDst);
Fariborz Jahaniandbd32c22008-11-19 17:34:06 +00001324 return;
1325 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001326
Fariborz Jahanian4f676ed2009-02-21 00:30:43 +00001327 if (Dst.isObjCStrong() && !Dst.isNonGC()) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001328 // load of a __strong object.
Fariborz Jahaniandbd32c22008-11-19 17:34:06 +00001329 llvm::Value *LvalueDst = Dst.getAddress();
1330 llvm::Value *src = Src.getScalarVal();
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +00001331 if (Dst.isObjCIvar()) {
1332 assert(Dst.getBaseIvarExp() && "BaseIvarExp is NULL");
Chris Lattner2acc6e32011-07-18 04:24:23 +00001333 llvm::Type *ResultType = ConvertType(getContext().LongTy);
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +00001334 llvm::Value *RHS = EmitScalarExpr(Dst.getBaseIvarExp());
Fariborz Jahanian76368e82009-09-25 00:00:20 +00001335 llvm::Value *dst = RHS;
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +00001336 RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast");
1337 llvm::Value *LHS =
1338 Builder.CreatePtrToInt(LvalueDst, ResultType, "sub.ptr.lhs.cast");
1339 llvm::Value *BytesBetween = Builder.CreateSub(LHS, RHS, "ivar.offset");
Fariborz Jahanian76368e82009-09-25 00:00:20 +00001340 CGM.getObjCRuntime().EmitObjCIvarAssign(*this, src, dst,
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +00001341 BytesBetween);
Fariborz Jahanian021a7a62010-07-20 20:30:03 +00001342 } else if (Dst.isGlobalObjCRef()) {
1343 CGM.getObjCRuntime().EmitObjCGlobalAssign(*this, src, LvalueDst,
1344 Dst.isThreadLocalRef());
1345 }
Fariborz Jahanianbf63b872009-05-04 23:27:20 +00001346 else
1347 CGM.getObjCRuntime().EmitObjCStrongCastAssign(*this, src, LvalueDst);
Fariborz Jahaniandbd32c22008-11-19 17:34:06 +00001348 return;
1349 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001350
Chris Lattner883f6a72007-08-11 00:04:45 +00001351 assert(Src.isScalar() && "Can't emit an agg store with this method");
David Chisnall7a7ee302012-01-16 17:27:18 +00001352 EmitStoreOfScalar(Src.getScalarVal(), Dst, isInit);
Reid Spencer5f016e22007-07-11 17:01:13 +00001353}
1354
Lauro Ramos Venancioa0c5d0e2008-01-22 22:36:45 +00001355void CodeGenFunction::EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst,
Daniel Dunbared3849b2008-11-19 09:36:46 +00001356 llvm::Value **Result) {
Daniel Dunbarefbf4872010-04-06 01:07:44 +00001357 const CGBitFieldInfo &Info = Dst.getBitFieldInfo();
Lauro Ramos Venancioa0c5d0e2008-01-22 22:36:45 +00001358
Daniel Dunbar26772612010-04-15 03:47:33 +00001359 // Get the output type.
Chris Lattner2acc6e32011-07-18 04:24:23 +00001360 llvm::Type *ResLTy = ConvertTypeForMem(Dst.getType());
Daniel Dunbar26772612010-04-15 03:47:33 +00001361 unsigned ResSizeInBits = CGM.getTargetData().getTypeSizeInBits(ResLTy);
Daniel Dunbar10e3ded2008-08-06 05:08:45 +00001362
Daniel Dunbar26772612010-04-15 03:47:33 +00001363 // Get the source value, truncated to the width of the bit-field.
Daniel Dunbared3849b2008-11-19 09:36:46 +00001364 llvm::Value *SrcVal = Src.getScalarVal();
Anders Carlsson48035352010-04-17 21:52:22 +00001365
Douglas Gregor47bfcca2012-04-12 20:42:30 +00001366 if (hasBooleanRepresentation(Dst.getType()))
Anders Carlsson48035352010-04-17 21:52:22 +00001367 SrcVal = Builder.CreateIntCast(SrcVal, ResLTy, /*IsSigned=*/false);
1368
Daniel Dunbar26772612010-04-15 03:47:33 +00001369 SrcVal = Builder.CreateAnd(SrcVal, llvm::APInt::getLowBitsSet(ResSizeInBits,
1370 Info.getSize()),
1371 "bf.value");
Lauro Ramos Venancioa0c5d0e2008-01-22 22:36:45 +00001372
Daniel Dunbared3849b2008-11-19 09:36:46 +00001373 // Return the new value of the bit-field, if requested.
1374 if (Result) {
1375 // Cast back to the proper type for result.
Chris Lattner2acc6e32011-07-18 04:24:23 +00001376 llvm::Type *SrcTy = Src.getScalarVal()->getType();
Daniel Dunbar26772612010-04-15 03:47:33 +00001377 llvm::Value *ReloadVal = Builder.CreateIntCast(SrcVal, SrcTy, false,
1378 "bf.reload.val");
Daniel Dunbared3849b2008-11-19 09:36:46 +00001379
1380 // Sign extend if necessary.
Daniel Dunbar26772612010-04-15 03:47:33 +00001381 if (Info.isSigned()) {
1382 unsigned ExtraBits = ResSizeInBits - Info.getSize();
1383 if (ExtraBits)
1384 ReloadVal = Builder.CreateAShr(Builder.CreateShl(ReloadVal, ExtraBits),
1385 ExtraBits, "bf.reload.sext");
Daniel Dunbared3849b2008-11-19 09:36:46 +00001386 }
1387
Daniel Dunbar26772612010-04-15 03:47:33 +00001388 *Result = ReloadVal;
Daniel Dunbared3849b2008-11-19 09:36:46 +00001389 }
1390
Daniel Dunbar26772612010-04-15 03:47:33 +00001391 // Iterate over the components, writing each piece to memory.
1392 for (unsigned i = 0, e = Info.getNumComponents(); i != e; ++i) {
1393 const CGBitFieldInfo::AccessInfo &AI = Info.getComponent(i);
Eli Friedmanf4bcfa12012-06-27 21:19:48 +00001394 CharUnits AccessAlignment = AI.AccessAlignment;
1395 if (!Dst.getAlignment().isZero())
1396 AccessAlignment = std::min(AccessAlignment, Dst.getAlignment());
Eli Friedman316bb1b2008-05-17 20:03:47 +00001397
Daniel Dunbar26772612010-04-15 03:47:33 +00001398 // Get the field pointer.
1399 llvm::Value *Ptr = Dst.getBitFieldBaseAddr();
John McCalld16c2cf2011-02-08 08:22:06 +00001400 unsigned addressSpace =
1401 cast<llvm::PointerType>(Ptr->getType())->getAddressSpace();
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001402
Daniel Dunbar26772612010-04-15 03:47:33 +00001403 // Only offset by the field index if used, so that incoming values are not
1404 // required to be structures.
1405 if (AI.FieldIndex)
1406 Ptr = Builder.CreateStructGEP(Ptr, AI.FieldIndex, "bf.field");
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001407
Daniel Dunbar26772612010-04-15 03:47:33 +00001408 // Offset by the byte offset, if used.
Ken Dyck28ebde52011-04-24 10:04:59 +00001409 if (!AI.FieldByteOffset.isZero()) {
John McCalld16c2cf2011-02-08 08:22:06 +00001410 Ptr = EmitCastToVoidPtr(Ptr);
Ken Dyck28ebde52011-04-24 10:04:59 +00001411 Ptr = Builder.CreateConstGEP1_32(Ptr, AI.FieldByteOffset.getQuantity(),
1412 "bf.field.offs");
Daniel Dunbar26772612010-04-15 03:47:33 +00001413 }
Eli Friedman316bb1b2008-05-17 20:03:47 +00001414
Daniel Dunbar26772612010-04-15 03:47:33 +00001415 // Cast to the access type.
Chris Lattner2acc6e32011-07-18 04:24:23 +00001416 llvm::Type *AccessLTy =
John McCalld16c2cf2011-02-08 08:22:06 +00001417 llvm::Type::getIntNTy(getLLVMContext(), AI.AccessWidth);
1418
Chris Lattner2acc6e32011-07-18 04:24:23 +00001419 llvm::Type *PTy = AccessLTy->getPointerTo(addressSpace);
Daniel Dunbar26772612010-04-15 03:47:33 +00001420 Ptr = Builder.CreateBitCast(Ptr, PTy);
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001421
Daniel Dunbar26772612010-04-15 03:47:33 +00001422 // Extract the piece of the bit-field value to write in this access, limited
1423 // to the values that are part of this access.
1424 llvm::Value *Val = SrcVal;
1425 if (AI.TargetBitOffset)
1426 Val = Builder.CreateLShr(Val, AI.TargetBitOffset);
1427 Val = Builder.CreateAnd(Val, llvm::APInt::getLowBitsSet(ResSizeInBits,
1428 AI.TargetBitWidth));
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001429
Daniel Dunbar26772612010-04-15 03:47:33 +00001430 // Extend or truncate to the access size.
Daniel Dunbar26772612010-04-15 03:47:33 +00001431 if (ResSizeInBits < AI.AccessWidth)
1432 Val = Builder.CreateZExt(Val, AccessLTy);
1433 else if (ResSizeInBits > AI.AccessWidth)
1434 Val = Builder.CreateTrunc(Val, AccessLTy);
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001435
Daniel Dunbar26772612010-04-15 03:47:33 +00001436 // Shift into the position in memory.
1437 if (AI.FieldBitStart)
1438 Val = Builder.CreateShl(Val, AI.FieldBitStart);
1439
1440 // If necessary, load and OR in bits that are outside of the bit-field.
1441 if (AI.TargetBitWidth != AI.AccessWidth) {
1442 llvm::LoadInst *Load = Builder.CreateLoad(Ptr, Dst.isVolatileQualified());
Eli Friedmanf4bcfa12012-06-27 21:19:48 +00001443 Load->setAlignment(AccessAlignment.getQuantity());
Daniel Dunbar26772612010-04-15 03:47:33 +00001444
1445 // Compute the mask for zeroing the bits that are part of the bit-field.
1446 llvm::APInt InvMask =
1447 ~llvm::APInt::getBitsSet(AI.AccessWidth, AI.FieldBitStart,
1448 AI.FieldBitStart + AI.TargetBitWidth);
1449
1450 // Apply the mask and OR in to the value to write.
1451 Val = Builder.CreateOr(Builder.CreateAnd(Load, InvMask), Val);
1452 }
1453
1454 // Write the value.
1455 llvm::StoreInst *Store = Builder.CreateStore(Val, Ptr,
1456 Dst.isVolatileQualified());
Eli Friedmanf4bcfa12012-06-27 21:19:48 +00001457 Store->setAlignment(AccessAlignment.getQuantity());
Daniel Dunbar10e3ded2008-08-06 05:08:45 +00001458 }
Lauro Ramos Venancioa0c5d0e2008-01-22 22:36:45 +00001459}
1460
Nate Begeman213541a2008-04-18 23:10:10 +00001461void CodeGenFunction::EmitStoreThroughExtVectorComponentLValue(RValue Src,
John McCall545d9962011-06-25 02:11:03 +00001462 LValue Dst) {
Chris Lattner017d6aa2007-08-03 16:28:33 +00001463 // This access turns into a read/modify/write of the vector. Load the input
1464 // value now.
Eli Friedmane5a8aeb2012-03-22 22:36:39 +00001465 llvm::LoadInst *Load = Builder.CreateLoad(Dst.getExtVectorAddr(),
1466 Dst.isVolatileQualified());
1467 Load->setAlignment(Dst.getAlignment().getQuantity());
1468 llvm::Value *Vec = Load;
Nate Begeman8a997642008-05-09 06:41:27 +00001469 const llvm::Constant *Elts = Dst.getExtVectorElts();
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001470
Chris Lattner9b655512007-08-31 22:49:20 +00001471 llvm::Value *SrcVal = Src.getScalarVal();
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001472
John McCall545d9962011-06-25 02:11:03 +00001473 if (const VectorType *VTy = Dst.getType()->getAs<VectorType>()) {
Chris Lattner7e6b51b2007-08-03 16:37:04 +00001474 unsigned NumSrcElts = VTy->getNumElements();
Nate Begeman6fe7c8a2009-01-18 06:42:49 +00001475 unsigned NumDstElts =
1476 cast<llvm::VectorType>(Vec->getType())->getNumElements();
1477 if (NumDstElts == NumSrcElts) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001478 // Use shuffle vector is the src and destination are the same number of
1479 // elements and restore the vector mask since it is on the side it will be
1480 // stored.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001481 SmallVector<llvm::Constant*, 4> Mask(NumDstElts);
Chris Lattner2ce88422012-01-25 05:34:41 +00001482 for (unsigned i = 0; i != NumSrcElts; ++i)
1483 Mask[getAccessedFieldNo(i, Elts)] = Builder.getInt32(i);
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001484
Chris Lattnerfb018d12011-02-15 00:14:06 +00001485 llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
Nate Begeman6fe7c8a2009-01-18 06:42:49 +00001486 Vec = Builder.CreateShuffleVector(SrcVal,
Owen Anderson03e20502009-07-30 23:11:26 +00001487 llvm::UndefValue::get(Vec->getType()),
Benjamin Kramer578faa82011-09-27 21:06:10 +00001488 MaskV);
Mike Stumpb3589f42009-07-30 22:28:39 +00001489 } else if (NumDstElts > NumSrcElts) {
Nate Begeman6fe7c8a2009-01-18 06:42:49 +00001490 // Extended the source vector to the same length and then shuffle it
1491 // into the destination.
1492 // FIXME: since we're shuffling with undef, can we just use the indices
1493 // into that? This could be simpler.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001494 SmallVector<llvm::Constant*, 4> ExtMask;
Benjamin Kramer14c59822012-02-14 12:06:21 +00001495 for (unsigned i = 0; i != NumSrcElts; ++i)
Chris Lattner2ce88422012-01-25 05:34:41 +00001496 ExtMask.push_back(Builder.getInt32(i));
Benjamin Kramer14c59822012-02-14 12:06:21 +00001497 ExtMask.resize(NumDstElts, llvm::UndefValue::get(Int32Ty));
Chris Lattnerfb018d12011-02-15 00:14:06 +00001498 llvm::Value *ExtMaskV = llvm::ConstantVector::get(ExtMask);
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001499 llvm::Value *ExtSrcVal =
Daniel Dunbarbb767732009-02-17 18:31:04 +00001500 Builder.CreateShuffleVector(SrcVal,
Owen Anderson03e20502009-07-30 23:11:26 +00001501 llvm::UndefValue::get(SrcVal->getType()),
Benjamin Kramer578faa82011-09-27 21:06:10 +00001502 ExtMaskV);
Nate Begeman6fe7c8a2009-01-18 06:42:49 +00001503 // build identity
Chris Lattner5f9e2722011-07-23 10:55:15 +00001504 SmallVector<llvm::Constant*, 4> Mask;
Chris Lattnereb99b012009-10-28 17:39:19 +00001505 for (unsigned i = 0; i != NumDstElts; ++i)
Chris Lattner2ce88422012-01-25 05:34:41 +00001506 Mask.push_back(Builder.getInt32(i));
Chris Lattnereb99b012009-10-28 17:39:19 +00001507
Nate Begeman6fe7c8a2009-01-18 06:42:49 +00001508 // modify when what gets shuffled in
Chris Lattner2ce88422012-01-25 05:34:41 +00001509 for (unsigned i = 0; i != NumSrcElts; ++i)
1510 Mask[getAccessedFieldNo(i, Elts)] = Builder.getInt32(i+NumDstElts);
Chris Lattnerfb018d12011-02-15 00:14:06 +00001511 llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
Benjamin Kramer578faa82011-09-27 21:06:10 +00001512 Vec = Builder.CreateShuffleVector(Vec, ExtSrcVal, MaskV);
Mike Stumpb3589f42009-07-30 22:28:39 +00001513 } else {
Nate Begeman6fe7c8a2009-01-18 06:42:49 +00001514 // We should never shorten the vector
David Blaikieb219cfc2011-09-23 05:06:16 +00001515 llvm_unreachable("unexpected shorten vector length");
Chris Lattner7e6b51b2007-08-03 16:37:04 +00001516 }
1517 } else {
1518 // If the Src is a scalar (not a vector) it must be updating one element.
Dan Gohman4f8d1232008-05-22 00:50:06 +00001519 unsigned InIdx = getAccessedFieldNo(0, Elts);
Chris Lattnereb99b012009-10-28 17:39:19 +00001520 llvm::Value *Elt = llvm::ConstantInt::get(Int32Ty, InIdx);
Benjamin Kramer578faa82011-09-27 21:06:10 +00001521 Vec = Builder.CreateInsertElement(Vec, SrcVal, Elt);
Chris Lattner017d6aa2007-08-03 16:28:33 +00001522 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001523
Eli Friedmane5a8aeb2012-03-22 22:36:39 +00001524 llvm::StoreInst *Store = Builder.CreateStore(Vec, Dst.getExtVectorAddr(),
1525 Dst.isVolatileQualified());
1526 Store->setAlignment(Dst.getAlignment().getQuantity());
Chris Lattner017d6aa2007-08-03 16:28:33 +00001527}
1528
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001529// setObjCGCLValueClass - sets class of he lvalue for the purpose of
1530// generating write-barries API. It is currently a global, ivar,
1531// or neither.
Chris Lattnereb99b012009-10-28 17:39:19 +00001532static void setObjCGCLValueClass(const ASTContext &Ctx, const Expr *E,
Fariborz Jahanianccae76c2011-09-30 18:23:36 +00001533 LValue &LV,
1534 bool IsMemberAccess=false) {
David Blaikie4e4d0842012-03-11 07:00:24 +00001535 if (Ctx.getLangOpts().getGC() == LangOptions::NonGC)
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001536 return;
1537
Fariborz Jahaniandbf3cfd2009-09-16 23:11:23 +00001538 if (isa<ObjCIvarRefExpr>(E)) {
Fariborz Jahanianccae76c2011-09-30 18:23:36 +00001539 QualType ExpTy = E->getType();
1540 if (IsMemberAccess && ExpTy->isPointerType()) {
1541 // If ivar is a structure pointer, assigning to field of
1542 // this struct follows gcc's behavior and makes it a non-ivar
1543 // writer-barrier conservatively.
1544 ExpTy = ExpTy->getAs<PointerType>()->getPointeeType();
1545 if (ExpTy->isRecordType()) {
1546 LV.setObjCIvar(false);
1547 return;
1548 }
1549 }
Daniel Dunbar3491b3d2010-08-21 03:51:29 +00001550 LV.setObjCIvar(true);
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +00001551 ObjCIvarRefExpr *Exp = cast<ObjCIvarRefExpr>(const_cast<Expr*>(E));
1552 LV.setBaseIvarExp(Exp->getBase());
Daniel Dunbar3491b3d2010-08-21 03:51:29 +00001553 LV.setObjCArray(E->getType()->isArrayType());
Fariborz Jahaniandbf3cfd2009-09-16 23:11:23 +00001554 return;
1555 }
Chris Lattnereb99b012009-10-28 17:39:19 +00001556
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001557 if (const DeclRefExpr *Exp = dyn_cast<DeclRefExpr>(E)) {
1558 if (const VarDecl *VD = dyn_cast<VarDecl>(Exp->getDecl())) {
John McCallb6bbcc92010-10-15 04:57:14 +00001559 if (VD->hasGlobalStorage()) {
Daniel Dunbar3491b3d2010-08-21 03:51:29 +00001560 LV.setGlobalObjCRef(true);
1561 LV.setThreadLocalRef(VD->isThreadSpecified());
Fariborz Jahanian021a7a62010-07-20 20:30:03 +00001562 }
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001563 }
Daniel Dunbar3491b3d2010-08-21 03:51:29 +00001564 LV.setObjCArray(E->getType()->isArrayType());
Chris Lattnereb99b012009-10-28 17:39:19 +00001565 return;
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001566 }
Chris Lattnereb99b012009-10-28 17:39:19 +00001567
1568 if (const UnaryOperator *Exp = dyn_cast<UnaryOperator>(E)) {
Fariborz Jahanianccae76c2011-09-30 18:23:36 +00001569 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess);
Chris Lattnereb99b012009-10-28 17:39:19 +00001570 return;
1571 }
1572
1573 if (const ParenExpr *Exp = dyn_cast<ParenExpr>(E)) {
Fariborz Jahanianccae76c2011-09-30 18:23:36 +00001574 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess);
Fariborz Jahanian75b08f12009-09-30 17:10:29 +00001575 if (LV.isObjCIvar()) {
1576 // If cast is to a structure pointer, follow gcc's behavior and make it
1577 // a non-ivar write-barrier.
1578 QualType ExpTy = E->getType();
1579 if (ExpTy->isPointerType())
1580 ExpTy = ExpTy->getAs<PointerType>()->getPointeeType();
1581 if (ExpTy->isRecordType())
Daniel Dunbar3491b3d2010-08-21 03:51:29 +00001582 LV.setObjCIvar(false);
Chris Lattnereb99b012009-10-28 17:39:19 +00001583 }
1584 return;
Fariborz Jahanian75b08f12009-09-30 17:10:29 +00001585 }
Peter Collingbournef111d932011-04-15 00:35:48 +00001586
1587 if (const GenericSelectionExpr *Exp = dyn_cast<GenericSelectionExpr>(E)) {
1588 setObjCGCLValueClass(Ctx, Exp->getResultExpr(), LV);
1589 return;
1590 }
1591
Chris Lattnereb99b012009-10-28 17:39:19 +00001592 if (const ImplicitCastExpr *Exp = dyn_cast<ImplicitCastExpr>(E)) {
Fariborz Jahanianccae76c2011-09-30 18:23:36 +00001593 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess);
Chris Lattnereb99b012009-10-28 17:39:19 +00001594 return;
1595 }
1596
1597 if (const CStyleCastExpr *Exp = dyn_cast<CStyleCastExpr>(E)) {
Fariborz Jahanianccae76c2011-09-30 18:23:36 +00001598 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess);
Chris Lattnereb99b012009-10-28 17:39:19 +00001599 return;
1600 }
John McCallf85e1932011-06-15 23:02:42 +00001601
1602 if (const ObjCBridgedCastExpr *Exp = dyn_cast<ObjCBridgedCastExpr>(E)) {
Fariborz Jahanianccae76c2011-09-30 18:23:36 +00001603 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess);
John McCallf85e1932011-06-15 23:02:42 +00001604 return;
1605 }
1606
Chris Lattnereb99b012009-10-28 17:39:19 +00001607 if (const ArraySubscriptExpr *Exp = dyn_cast<ArraySubscriptExpr>(E)) {
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001608 setObjCGCLValueClass(Ctx, Exp->getBase(), LV);
Fariborz Jahanianfd02ed72009-09-21 18:54:29 +00001609 if (LV.isObjCIvar() && !LV.isObjCArray())
Fariborz Jahanian1c1afc42009-09-18 00:04:00 +00001610 // Using array syntax to assigning to what an ivar points to is not
1611 // same as assigning to the ivar itself. {id *Names;} Names[i] = 0;
Daniel Dunbar3491b3d2010-08-21 03:51:29 +00001612 LV.setObjCIvar(false);
Fariborz Jahanianfd02ed72009-09-21 18:54:29 +00001613 else if (LV.isGlobalObjCRef() && !LV.isObjCArray())
1614 // Using array syntax to assigning to what global points to is not
1615 // same as assigning to the global itself. {id *G;} G[i] = 0;
Daniel Dunbar3491b3d2010-08-21 03:51:29 +00001616 LV.setGlobalObjCRef(false);
Chris Lattnereb99b012009-10-28 17:39:19 +00001617 return;
Fariborz Jahanian1c1afc42009-09-18 00:04:00 +00001618 }
Fariborz Jahanianccae76c2011-09-30 18:23:36 +00001619
Chris Lattnereb99b012009-10-28 17:39:19 +00001620 if (const MemberExpr *Exp = dyn_cast<MemberExpr>(E)) {
Fariborz Jahanianccae76c2011-09-30 18:23:36 +00001621 setObjCGCLValueClass(Ctx, Exp->getBase(), LV, true);
Fariborz Jahanian1c1afc42009-09-18 00:04:00 +00001622 // We don't know if member is an 'ivar', but this flag is looked at
1623 // only in the context of LV.isObjCIvar().
Daniel Dunbar3491b3d2010-08-21 03:51:29 +00001624 LV.setObjCArray(E->getType()->isArrayType());
Chris Lattnereb99b012009-10-28 17:39:19 +00001625 return;
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001626 }
1627}
1628
Chris Lattner3a2b6572011-07-12 06:52:18 +00001629static llvm::Value *
Chandler Carrutha98742c2011-07-12 08:58:26 +00001630EmitBitCastOfLValueToProperType(CodeGenFunction &CGF,
Chris Lattner3a2b6572011-07-12 06:52:18 +00001631 llvm::Value *V, llvm::Type *IRType,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001632 StringRef Name = StringRef()) {
Chris Lattner3a2b6572011-07-12 06:52:18 +00001633 unsigned AS = cast<llvm::PointerType>(V->getType())->getAddressSpace();
Chandler Carrutha98742c2011-07-12 08:58:26 +00001634 return CGF.Builder.CreateBitCast(V, IRType->getPointerTo(AS), Name);
Chris Lattner3a2b6572011-07-12 06:52:18 +00001635}
1636
Anders Carlssonce53f7d2009-11-07 23:06:58 +00001637static LValue EmitGlobalVarDeclLValue(CodeGenFunction &CGF,
1638 const Expr *E, const VarDecl *VD) {
Daniel Dunbard2113f22009-11-08 09:46:46 +00001639 assert((VD->hasExternalStorage() || VD->isFileVarDecl()) &&
Anders Carlssonce53f7d2009-11-07 23:06:58 +00001640 "Var decl must have external storage or be a file var decl!");
1641
1642 llvm::Value *V = CGF.CGM.GetAddrOfGlobalVar(VD);
Eli Friedman2f77b3d2011-11-16 00:42:57 +00001643 llvm::Type *RealVarTy = CGF.getTypes().ConvertTypeForMem(VD->getType());
1644 V = EmitBitCastOfLValueToProperType(CGF, V, RealVarTy);
Eli Friedman6da2c712011-12-03 04:14:32 +00001645 CharUnits Alignment = CGF.getContext().getDeclAlign(VD);
Eli Friedman2f77b3d2011-11-16 00:42:57 +00001646 QualType T = E->getType();
1647 LValue LV;
1648 if (VD->getType()->isReferenceType()) {
1649 llvm::LoadInst *LI = CGF.Builder.CreateLoad(V);
Eli Friedman6da2c712011-12-03 04:14:32 +00001650 LI->setAlignment(Alignment.getQuantity());
Eli Friedman2f77b3d2011-11-16 00:42:57 +00001651 V = LI;
1652 LV = CGF.MakeNaturalAlignAddrLValue(V, T);
1653 } else {
1654 LV = CGF.MakeAddrLValue(V, E->getType(), Alignment);
1655 }
Anders Carlssonce53f7d2009-11-07 23:06:58 +00001656 setObjCGCLValueClass(CGF.getContext(), E, LV);
1657 return LV;
1658}
1659
Eli Friedman9a146302009-11-26 06:08:14 +00001660static LValue EmitFunctionDeclLValue(CodeGenFunction &CGF,
Chris Lattner74339df2011-07-10 05:34:54 +00001661 const Expr *E, const FunctionDecl *FD) {
Chris Lattnerd0db03a2010-09-06 00:11:41 +00001662 llvm::Value *V = CGF.CGM.GetAddrOfFunction(FD);
Eli Friedman9a146302009-11-26 06:08:14 +00001663 if (!FD->hasPrototype()) {
1664 if (const FunctionProtoType *Proto =
1665 FD->getType()->getAs<FunctionProtoType>()) {
1666 // Ugly case: for a K&R-style definition, the type of the definition
1667 // isn't the same as the type of a use. Correct for this with a
1668 // bitcast.
1669 QualType NoProtoType =
1670 CGF.getContext().getFunctionNoProtoType(Proto->getResultType());
1671 NoProtoType = CGF.getContext().getPointerType(NoProtoType);
Benjamin Kramer578faa82011-09-27 21:06:10 +00001672 V = CGF.Builder.CreateBitCast(V, CGF.ConvertType(NoProtoType));
Eli Friedman9a146302009-11-26 06:08:14 +00001673 }
1674 }
Eli Friedman6da2c712011-12-03 04:14:32 +00001675 CharUnits Alignment = CGF.getContext().getDeclAlign(FD);
Daniel Dunbar983e3d72010-08-21 04:20:22 +00001676 return CGF.MakeAddrLValue(V, E->getType(), Alignment);
Eli Friedman9a146302009-11-26 06:08:14 +00001677}
1678
Reid Spencer5f016e22007-07-11 17:01:13 +00001679LValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) {
Anders Carlsson1e74c4f2009-11-07 22:53:10 +00001680 const NamedDecl *ND = E->getDecl();
Eli Friedman6da2c712011-12-03 04:14:32 +00001681 CharUnits Alignment = getContext().getDeclAlign(ND);
Eli Friedman2f77b3d2011-11-16 00:42:57 +00001682 QualType T = E->getType();
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001683
Eli Friedman416de512012-01-21 04:52:58 +00001684 // FIXME: We should be able to assert this for FunctionDecls as well!
1685 // FIXME: We should be able to assert this for all DeclRefExprs, not just
1686 // those with a valid source location.
1687 assert((ND->isUsed(false) || !isa<VarDecl>(ND) ||
1688 !E->getLocation().isValid()) &&
1689 "Should not use decl without marking it used!");
1690
Rafael Espindola6a836702010-03-04 18:17:24 +00001691 if (ND->hasAttr<WeakRefAttr>()) {
Chris Lattnerd0db03a2010-09-06 00:11:41 +00001692 const ValueDecl *VD = cast<ValueDecl>(ND);
Rafael Espindola6a836702010-03-04 18:17:24 +00001693 llvm::Constant *Aliasee = CGM.GetWeakRefReference(VD);
Daniel Dunbar983e3d72010-08-21 04:20:22 +00001694 return MakeAddrLValue(Aliasee, E->getType(), Alignment);
Rafael Espindola6a836702010-03-04 18:17:24 +00001695 }
1696
Anders Carlsson1e74c4f2009-11-07 22:53:10 +00001697 if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) {
Anders Carlsson1e74c4f2009-11-07 22:53:10 +00001698 // Check if this is a global variable.
Anders Carlssonce53f7d2009-11-07 23:06:58 +00001699 if (VD->hasExternalStorage() || VD->isFileVarDecl())
1700 return EmitGlobalVarDeclLValue(*this, E, VD);
Anders Carlsson0bc70492009-11-07 22:46:42 +00001701
John McCallf4b88a42012-03-10 09:33:50 +00001702 bool isBlockVariable = VD->hasAttr<BlocksAttr>();
1703
Fariborz Jahanian75f91d62010-11-19 18:17:09 +00001704 bool NonGCable = VD->hasLocalStorage() &&
1705 !VD->getType()->isReferenceType() &&
John McCallf4b88a42012-03-10 09:33:50 +00001706 !isBlockVariable;
Anders Carlsson0bc70492009-11-07 22:46:42 +00001707
1708 llvm::Value *V = LocalDeclMap[VD];
Fariborz Jahanian09349142010-09-07 23:26:17 +00001709 if (!V && VD->isStaticLocal())
Fariborz Jahanian63326a52010-04-19 18:15:02 +00001710 V = CGM.getStaticLocalDeclAddress(VD);
Eli Friedmancec5ebd2012-02-11 02:57:39 +00001711
1712 // Use special handling for lambdas.
John McCallf4b88a42012-03-10 09:33:50 +00001713 if (!V) {
Eli Friedman377ecc72012-04-16 03:54:45 +00001714 if (FieldDecl *FD = LambdaCaptureFields.lookup(VD)) {
1715 QualType LambdaTagType = getContext().getTagDeclType(FD->getParent());
1716 LValue LambdaLV = MakeNaturalAlignAddrLValue(CXXABIThisValue,
1717 LambdaTagType);
1718 return EmitLValueForField(LambdaLV, FD);
1719 }
Eli Friedmancec5ebd2012-02-11 02:57:39 +00001720
John McCallf4b88a42012-03-10 09:33:50 +00001721 assert(isa<BlockDecl>(CurCodeDecl) && E->refersToEnclosingLocal());
1722 CharUnits alignment = getContext().getDeclAlign(VD);
1723 return MakeAddrLValue(GetAddrOfBlockDecl(VD, isBlockVariable),
1724 E->getType(), alignment);
1725 }
1726
Anders Carlsson0bc70492009-11-07 22:46:42 +00001727 assert(V && "DeclRefExpr not entered in LocalDeclMap?");
1728
John McCallf4b88a42012-03-10 09:33:50 +00001729 if (isBlockVariable)
Fariborz Jahanian52a80e12011-01-26 23:08:27 +00001730 V = BuildBlockByrefAddress(V, VD);
Daniel Dunbar6d5eb762010-08-21 03:44:13 +00001731
Eli Friedman2f77b3d2011-11-16 00:42:57 +00001732 LValue LV;
1733 if (VD->getType()->isReferenceType()) {
1734 llvm::LoadInst *LI = Builder.CreateLoad(V);
Eli Friedman6da2c712011-12-03 04:14:32 +00001735 LI->setAlignment(Alignment.getQuantity());
Eli Friedman2f77b3d2011-11-16 00:42:57 +00001736 V = LI;
1737 LV = MakeNaturalAlignAddrLValue(V, T);
1738 } else {
1739 LV = MakeAddrLValue(V, T, Alignment);
1740 }
Chris Lattner3a2b6572011-07-12 06:52:18 +00001741
Fariborz Jahanian75f91d62010-11-19 18:17:09 +00001742 if (NonGCable) {
Daniel Dunbar6d5eb762010-08-21 03:44:13 +00001743 LV.getQuals().removeObjCGCAttr();
Daniel Dunbarea619172010-08-21 03:22:38 +00001744 LV.setNonGC(true);
1745 }
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001746 setObjCGCLValueClass(getContext(), E, LV);
Fariborz Jahanian2682d8b2008-11-20 00:15:42 +00001747 return LV;
Chris Lattnereb99b012009-10-28 17:39:19 +00001748 }
John McCall5808ce42011-02-03 08:15:49 +00001749
1750 if (const FunctionDecl *fn = dyn_cast<FunctionDecl>(ND))
1751 return EmitFunctionDeclLValue(*this, E, fn);
1752
David Blaikieb219cfc2011-09-23 05:06:16 +00001753 llvm_unreachable("Unhandled DeclRefExpr");
Reid Spencer5f016e22007-07-11 17:01:13 +00001754}
1755
1756LValue CodeGenFunction::EmitUnaryOpLValue(const UnaryOperator *E) {
1757 // __extension__ doesn't affect lvalue-ness.
John McCall2de56d12010-08-25 11:45:40 +00001758 if (E->getOpcode() == UO_Extension)
Reid Spencer5f016e22007-07-11 17:01:13 +00001759 return EmitLValue(E->getSubExpr());
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001760
Chris Lattner96196622008-07-26 22:37:01 +00001761 QualType ExprTy = getContext().getCanonicalType(E->getSubExpr()->getType());
Chris Lattner7da36f62007-10-30 22:53:42 +00001762 switch (E->getOpcode()) {
David Blaikieb219cfc2011-09-23 05:06:16 +00001763 default: llvm_unreachable("Unknown unary operator lvalue!");
John McCall2de56d12010-08-25 11:45:40 +00001764 case UO_Deref: {
Chris Lattnereb99b012009-10-28 17:39:19 +00001765 QualType T = E->getSubExpr()->getType()->getPointeeType();
1766 assert(!T.isNull() && "CodeGenFunction::EmitUnaryOpLValue: Illegal type");
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001767
Chris Lattner4cac9e12011-12-19 21:16:08 +00001768 LValue LV = MakeNaturalAlignAddrLValue(EmitScalarExpr(E->getSubExpr()), T);
Daniel Dunbar6d5eb762010-08-21 03:44:13 +00001769 LV.getQuals().setAddressSpace(ExprTy.getAddressSpace());
John McCall0953e762009-09-24 19:53:00 +00001770
Chris Lattnereb99b012009-10-28 17:39:19 +00001771 // We should not generate __weak write barrier on indirect reference
1772 // of a pointer to object; as in void foo (__weak id *param); *param = 0;
1773 // But, we continue to generate __strong write barrier on indirect write
1774 // into a pointer to object.
David Blaikie4e4d0842012-03-11 07:00:24 +00001775 if (getContext().getLangOpts().ObjC1 &&
1776 getContext().getLangOpts().getGC() != LangOptions::NonGC &&
Chris Lattnereb99b012009-10-28 17:39:19 +00001777 LV.isObjCWeak())
Daniel Dunbarea619172010-08-21 03:22:38 +00001778 LV.setNonGC(!E->isOBJCGCCandidate(getContext()));
Chris Lattnereb99b012009-10-28 17:39:19 +00001779 return LV;
1780 }
John McCall2de56d12010-08-25 11:45:40 +00001781 case UO_Real:
1782 case UO_Imag: {
Chris Lattner7da36f62007-10-30 22:53:42 +00001783 LValue LV = EmitLValue(E->getSubExpr());
John McCall2a416372010-12-05 02:00:02 +00001784 assert(LV.isSimple() && "real/imag on non-ordinary l-value");
1785 llvm::Value *Addr = LV.getAddress();
1786
Richard Smithdfb80de2012-02-18 20:53:32 +00001787 // __real is valid on scalars. This is a faster way of testing that.
1788 // __imag can only produce an rvalue on scalars.
1789 if (E->getOpcode() == UO_Real &&
1790 !cast<llvm::PointerType>(Addr->getType())
John McCall2a416372010-12-05 02:00:02 +00001791 ->getElementType()->isStructTy()) {
1792 assert(E->getSubExpr()->getType()->isArithmeticType());
1793 return LV;
1794 }
1795
1796 assert(E->getSubExpr()->getType()->isAnyComplexType());
1797
John McCall2de56d12010-08-25 11:45:40 +00001798 unsigned Idx = E->getOpcode() == UO_Imag;
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001799 return MakeAddrLValue(Builder.CreateStructGEP(LV.getAddress(),
John McCall2a416372010-12-05 02:00:02 +00001800 Idx, "idx"),
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001801 ExprTy);
Chris Lattner7da36f62007-10-30 22:53:42 +00001802 }
John McCall2de56d12010-08-25 11:45:40 +00001803 case UO_PreInc:
1804 case UO_PreDec: {
Chris Lattner197a3382010-01-09 21:44:40 +00001805 LValue LV = EmitLValue(E->getSubExpr());
John McCall2de56d12010-08-25 11:45:40 +00001806 bool isInc = E->getOpcode() == UO_PreInc;
Chris Lattner197a3382010-01-09 21:44:40 +00001807
1808 if (E->getType()->isAnyComplexType())
1809 EmitComplexPrePostIncDec(E, LV, isInc, true/*isPre*/);
1810 else
1811 EmitScalarPrePostIncDec(E, LV, isInc, true/*isPre*/);
1812 return LV;
1813 }
Eli Friedmane401cd52009-11-09 04:20:47 +00001814 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001815}
1816
1817LValue CodeGenFunction::EmitStringLiteralLValue(const StringLiteral *E) {
Daniel Dunbar79c39282010-08-21 03:15:20 +00001818 return MakeAddrLValue(CGM.GetAddrOfConstantStringFromLiteral(E),
1819 E->getType());
Reid Spencer5f016e22007-07-11 17:01:13 +00001820}
1821
Chris Lattnereaf2bb82009-02-24 22:18:39 +00001822LValue CodeGenFunction::EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E) {
Daniel Dunbar79c39282010-08-21 03:15:20 +00001823 return MakeAddrLValue(CGM.GetAddrOfConstantStringFromObjCEncode(E),
1824 E->getType());
Chris Lattnereaf2bb82009-02-24 22:18:39 +00001825}
1826
Nico Weber28ad0632012-06-23 02:07:59 +00001827static llvm::Constant*
1828GetAddrOfConstantWideString(StringRef Str,
1829 const char *GlobalName,
1830 ASTContext &Context,
1831 QualType Ty, SourceLocation Loc,
1832 CodeGenModule &CGM) {
1833
1834 StringLiteral *SL = StringLiteral::Create(Context,
1835 Str,
1836 StringLiteral::Wide,
1837 /*Pascal = */false,
1838 Ty, Loc);
1839 llvm::Constant *C = CGM.GetConstantArrayFromStringLiteral(SL);
1840 llvm::GlobalVariable *GV =
1841 new llvm::GlobalVariable(CGM.getModule(), C->getType(),
1842 !CGM.getLangOpts().WritableStrings,
1843 llvm::GlobalValue::PrivateLinkage,
1844 C, GlobalName);
1845 const unsigned WideAlignment =
1846 Context.getTypeAlignInChars(Ty).getQuantity();
1847 GV->setAlignment(WideAlignment);
1848 return GV;
1849}
1850
Nico Weber28ad0632012-06-23 02:07:59 +00001851static void ConvertUTF8ToWideString(unsigned CharByteWidth, StringRef Source,
1852 SmallString<32>& Target) {
1853 Target.resize(CharByteWidth * (Source.size() + 1));
1854 char* ResultPtr = &Target[0];
Nico Weber941e47c2012-07-03 02:24:52 +00001855 bool success = ConvertUTF8toWide(CharByteWidth, Source, ResultPtr);
Matt Beaumont-Gay402a6d52012-07-03 03:55:58 +00001856 (void)success;
Nico Weber941e47c2012-07-03 02:24:52 +00001857 assert(success);
Nico Weber28ad0632012-06-23 02:07:59 +00001858 Target.resize(ResultPtr - &Target[0]);
1859}
Chris Lattnereaf2bb82009-02-24 22:18:39 +00001860
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001861LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) {
Daniel Dunbar662b71e2008-10-17 21:58:32 +00001862 switch (E->getIdentType()) {
1863 default:
1864 return EmitUnsupportedLValue(E, "predefined expression");
Daniel Dunbar3ec0baf2010-08-21 03:01:12 +00001865
Daniel Dunbar662b71e2008-10-17 21:58:32 +00001866 case PredefinedExpr::Func:
1867 case PredefinedExpr::Function:
Nico Weber28ad0632012-06-23 02:07:59 +00001868 case PredefinedExpr::LFunction:
Daniel Dunbar3ec0baf2010-08-21 03:01:12 +00001869 case PredefinedExpr::PrettyFunction: {
Nico Weber28ad0632012-06-23 02:07:59 +00001870 unsigned IdentType = E->getIdentType();
Daniel Dunbar3ec0baf2010-08-21 03:01:12 +00001871 std::string GlobalVarName;
1872
Nico Weber28ad0632012-06-23 02:07:59 +00001873 switch (IdentType) {
David Blaikieb219cfc2011-09-23 05:06:16 +00001874 default: llvm_unreachable("Invalid type");
Daniel Dunbar3ec0baf2010-08-21 03:01:12 +00001875 case PredefinedExpr::Func:
1876 GlobalVarName = "__func__.";
1877 break;
1878 case PredefinedExpr::Function:
1879 GlobalVarName = "__FUNCTION__.";
1880 break;
Nico Weber28ad0632012-06-23 02:07:59 +00001881 case PredefinedExpr::LFunction:
1882 GlobalVarName = "L__FUNCTION__.";
1883 break;
Daniel Dunbar3ec0baf2010-08-21 03:01:12 +00001884 case PredefinedExpr::PrettyFunction:
1885 GlobalVarName = "__PRETTY_FUNCTION__.";
1886 break;
1887 }
1888
Chris Lattner5f9e2722011-07-23 10:55:15 +00001889 StringRef FnName = CurFn->getName();
Daniel Dunbar3ec0baf2010-08-21 03:01:12 +00001890 if (FnName.startswith("\01"))
1891 FnName = FnName.substr(1);
1892 GlobalVarName += FnName;
1893
1894 const Decl *CurDecl = CurCodeDecl;
1895 if (CurDecl == 0)
1896 CurDecl = getContext().getTranslationUnitDecl();
1897
1898 std::string FunctionName =
John McCall6b5a61b2011-02-07 10:33:21 +00001899 (isa<BlockDecl>(CurDecl)
1900 ? FnName.str()
Nico Weber28ad0632012-06-23 02:07:59 +00001901 : PredefinedExpr::ComputeName((PredefinedExpr::IdentType)IdentType,
1902 CurDecl));
Daniel Dunbar3ec0baf2010-08-21 03:01:12 +00001903
Nico Weber28ad0632012-06-23 02:07:59 +00001904 const Type* ElemType = E->getType()->getArrayElementTypeNoTypeQual();
1905 llvm::Constant *C;
1906 if (ElemType->isWideCharType()) {
1907 SmallString<32> RawChars;
1908 ConvertUTF8ToWideString(
1909 getContext().getTypeSizeInChars(ElemType).getQuantity(),
1910 FunctionName, RawChars);
1911 C = GetAddrOfConstantWideString(RawChars,
1912 GlobalVarName.c_str(),
1913 getContext(),
1914 E->getType(),
1915 E->getLocation(),
1916 CGM);
1917 } else {
1918 C = CGM.GetAddrOfConstantCString(FunctionName,
1919 GlobalVarName.c_str(),
1920 1);
1921 }
Daniel Dunbar79c39282010-08-21 03:15:20 +00001922 return MakeAddrLValue(C, E->getType());
Daniel Dunbar3ec0baf2010-08-21 03:01:12 +00001923 }
Daniel Dunbar662b71e2008-10-17 21:58:32 +00001924 }
Anders Carlsson22742662007-07-21 05:21:51 +00001925}
1926
Richard Smith7ac9ef12012-09-08 02:08:36 +00001927void CodeGenFunction::EmitCheck(llvm::Value *Checked) {
Mike Stump41513442009-12-15 00:59:40 +00001928 const CodeGenOptions &GCO = CGM.getCodeGenOpts();
1929
Richard Smith7ac9ef12012-09-08 02:08:36 +00001930 llvm::BasicBlock *Cont = createBasicBlock("cont");
1931
Mike Stump41513442009-12-15 00:59:40 +00001932 // If we are not optimzing, don't collapse all calls to trap in the function
1933 // to the same call, that way, in the debugger they can see which operation
Chris Lattner6c552c12010-07-20 20:19:24 +00001934 // did in fact fail. If we are optimizing, we collapse all calls to trap down
Mike Stump41513442009-12-15 00:59:40 +00001935 // to just one per function to save on codesize.
Richard Smith7ac9ef12012-09-08 02:08:36 +00001936 bool NeedNewTrapBB = !GCO.OptimizationLevel || !TrapBB;
Mike Stump9c276ae2009-12-12 01:27:46 +00001937
Richard Smith7ac9ef12012-09-08 02:08:36 +00001938 if (NeedNewTrapBB)
1939 TrapBB = createBasicBlock("trap");
1940
1941 Builder.CreateCondBr(Checked, Cont, TrapBB);
1942
1943 if (NeedNewTrapBB) {
1944 EmitBlock(TrapBB);
1945
1946 llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::trap);
1947 llvm::CallInst *TrapCall = Builder.CreateCall(F);
1948 TrapCall->setDoesNotReturn();
1949 TrapCall->setDoesNotThrow();
1950 Builder.CreateUnreachable();
Mike Stump9c276ae2009-12-12 01:27:46 +00001951 }
Mike Stump15037ca2009-12-15 00:35:12 +00001952
Richard Smith7ac9ef12012-09-08 02:08:36 +00001953 EmitBlock(Cont);
Mike Stump9c276ae2009-12-12 01:27:46 +00001954}
1955
Chris Lattner9269d5c2010-06-26 23:03:20 +00001956/// isSimpleArrayDecayOperand - If the specified expr is a simple decay from an
1957/// array to pointer, return the array subexpression.
1958static const Expr *isSimpleArrayDecayOperand(const Expr *E) {
1959 // If this isn't just an array->pointer decay, bail out.
1960 const CastExpr *CE = dyn_cast<CastExpr>(E);
John McCall2de56d12010-08-25 11:45:40 +00001961 if (CE == 0 || CE->getCastKind() != CK_ArrayToPointerDecay)
Chris Lattner9269d5c2010-06-26 23:03:20 +00001962 return 0;
1963
1964 // If this is a decay from variable width array, bail out.
1965 const Expr *SubExpr = CE->getSubExpr();
1966 if (SubExpr->getType()->isVariableArrayType())
1967 return 0;
1968
1969 return SubExpr;
1970}
1971
Reid Spencer5f016e22007-07-11 17:01:13 +00001972LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) {
Ted Kremenek23245122007-08-20 16:18:38 +00001973 // The index must always be an integer, which is not an aggregate. Emit it.
Chris Lattner7f02f722007-08-24 05:35:26 +00001974 llvm::Value *Idx = EmitScalarExpr(E->getIdx());
Eli Friedman61d004a2009-06-06 19:09:26 +00001975 QualType IdxTy = E->getIdx()->getType();
Douglas Gregor575a1c92011-05-20 16:38:50 +00001976 bool IdxSigned = IdxTy->isSignedIntegerOrEnumerationType();
Eli Friedman61d004a2009-06-06 19:09:26 +00001977
Reid Spencer5f016e22007-07-11 17:01:13 +00001978 // If the base is a vector type, then we are forming a vector element lvalue
1979 // with this subscript.
Eli Friedman1e692ac2008-06-13 23:01:12 +00001980 if (E->getBase()->getType()->isVectorType()) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001981 // Emit the vector as an lvalue to get its address.
Eli Friedman1e692ac2008-06-13 23:01:12 +00001982 LValue LHS = EmitLValue(E->getBase());
Ted Kremenek23245122007-08-20 16:18:38 +00001983 assert(LHS.isSimple() && "Can only subscript lvalue vectors here!");
John McCalld16c2cf2011-02-08 08:22:06 +00001984 Idx = Builder.CreateIntCast(Idx, Int32Ty, IdxSigned, "vidx");
Eli Friedman1e692ac2008-06-13 23:01:12 +00001985 return LValue::MakeVectorElt(LHS.getAddress(), Idx,
Eli Friedmane5a8aeb2012-03-22 22:36:39 +00001986 E->getBase()->getType(), LHS.getAlignment());
Reid Spencer5f016e22007-07-11 17:01:13 +00001987 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001988
Ted Kremenek23245122007-08-20 16:18:38 +00001989 // Extend or truncate the index type to 32 or 64-bits.
John McCall5936e332011-02-15 09:22:45 +00001990 if (Idx->getType() != IntPtrTy)
1991 Idx = Builder.CreateIntCast(Idx, IntPtrTy, IdxSigned, "idxprom");
Mike Stump9c276ae2009-12-12 01:27:46 +00001992
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001993 // We know that the pointer points to a type of the correct size, unless the
1994 // size is a VLA or Objective-C interface.
Daniel Dunbar2a866252009-04-25 05:08:32 +00001995 llvm::Value *Address = 0;
Eli Friedman6da2c712011-12-03 04:14:32 +00001996 CharUnits ArrayAlignment;
John McCallbc8d40d2011-06-24 21:55:10 +00001997 if (const VariableArrayType *vla =
Anders Carlsson8b33c082008-12-21 00:11:23 +00001998 getContext().getAsVariableArrayType(E->getType())) {
John McCallbc8d40d2011-06-24 21:55:10 +00001999 // The base must be a pointer, which is not an aggregate. Emit
2000 // it. It needs to be emitted first in case it's what captures
2001 // the VLA bounds.
2002 Address = EmitScalarExpr(E->getBase());
Mike Stumpdb52dcd2009-09-09 13:00:44 +00002003
John McCallbc8d40d2011-06-24 21:55:10 +00002004 // The element count here is the total number of non-VLA elements.
2005 llvm::Value *numElements = getVLASize(vla).first;
Mike Stumpdb52dcd2009-09-09 13:00:44 +00002006
John McCall913dab22011-06-25 01:32:37 +00002007 // Effectively, the multiply by the VLA size is part of the GEP.
2008 // GEP indexes are signed, and scaling an index isn't permitted to
2009 // signed-overflow, so we use the same semantics for our explicit
2010 // multiply. We suppress this if overflow is not undefined behavior.
David Blaikie4e4d0842012-03-11 07:00:24 +00002011 if (getLangOpts().isSignedOverflowDefined()) {
John McCall913dab22011-06-25 01:32:37 +00002012 Idx = Builder.CreateMul(Idx, numElements);
Chris Lattner2cb42222011-03-01 00:03:48 +00002013 Address = Builder.CreateGEP(Address, Idx, "arrayidx");
John McCall913dab22011-06-25 01:32:37 +00002014 } else {
2015 Idx = Builder.CreateNSWMul(Idx, numElements);
Chris Lattner2cb42222011-03-01 00:03:48 +00002016 Address = Builder.CreateInBoundsGEP(Address, Idx, "arrayidx");
John McCall913dab22011-06-25 01:32:37 +00002017 }
Chris Lattner9269d5c2010-06-26 23:03:20 +00002018 } else if (const ObjCObjectType *OIT = E->getType()->getAs<ObjCObjectType>()){
2019 // Indexing over an interface, as in "NSString *P; P[4];"
Mike Stumpdb52dcd2009-09-09 13:00:44 +00002020 llvm::Value *InterfaceSize =
Owen Anderson4a28d5d2009-07-24 23:12:58 +00002021 llvm::ConstantInt::get(Idx->getType(),
Ken Dyck199c3d62010-01-11 17:06:35 +00002022 getContext().getTypeSizeInChars(OIT).getQuantity());
Mike Stumpdb52dcd2009-09-09 13:00:44 +00002023
Daniel Dunbar2a866252009-04-25 05:08:32 +00002024 Idx = Builder.CreateMul(Idx, InterfaceSize);
2025
Chris Lattner9269d5c2010-06-26 23:03:20 +00002026 // The base must be a pointer, which is not an aggregate. Emit it.
2027 llvm::Value *Base = EmitScalarExpr(E->getBase());
John McCalld16c2cf2011-02-08 08:22:06 +00002028 Address = EmitCastToVoidPtr(Base);
2029 Address = Builder.CreateGEP(Address, Idx, "arrayidx");
Daniel Dunbar2a866252009-04-25 05:08:32 +00002030 Address = Builder.CreateBitCast(Address, Base->getType());
Chris Lattner9269d5c2010-06-26 23:03:20 +00002031 } else if (const Expr *Array = isSimpleArrayDecayOperand(E->getBase())) {
2032 // If this is A[i] where A is an array, the frontend will have decayed the
2033 // base to be a ArrayToPointerDecay implicit cast. While correct, it is
2034 // inefficient at -O0 to emit a "gep A, 0, 0" when codegen'ing it, then a
2035 // "gep x, i" here. Emit one "gep A, 0, i".
2036 assert(Array->getType()->isArrayType() &&
2037 "Array to pointer decay must have array source type!");
Daniel Dunbard5534082011-04-01 00:49:43 +00002038 LValue ArrayLV = EmitLValue(Array);
2039 llvm::Value *ArrayPtr = ArrayLV.getAddress();
Chris Lattner9269d5c2010-06-26 23:03:20 +00002040 llvm::Value *Zero = llvm::ConstantInt::get(Int32Ty, 0);
2041 llvm::Value *Args[] = { Zero, Idx };
2042
Daniel Dunbard5534082011-04-01 00:49:43 +00002043 // Propagate the alignment from the array itself to the result.
2044 ArrayAlignment = ArrayLV.getAlignment();
2045
David Blaikie4e4d0842012-03-11 07:00:24 +00002046 if (getContext().getLangOpts().isSignedOverflowDefined())
Jay Foad0f6ac7c2011-07-22 08:16:57 +00002047 Address = Builder.CreateGEP(ArrayPtr, Args, "arrayidx");
Chris Lattner2cb42222011-03-01 00:03:48 +00002048 else
Jay Foad0f6ac7c2011-07-22 08:16:57 +00002049 Address = Builder.CreateInBoundsGEP(ArrayPtr, Args, "arrayidx");
Daniel Dunbar2a866252009-04-25 05:08:32 +00002050 } else {
Chris Lattner9269d5c2010-06-26 23:03:20 +00002051 // The base must be a pointer, which is not an aggregate. Emit it.
2052 llvm::Value *Base = EmitScalarExpr(E->getBase());
David Blaikie4e4d0842012-03-11 07:00:24 +00002053 if (getContext().getLangOpts().isSignedOverflowDefined())
Chris Lattner2cb42222011-03-01 00:03:48 +00002054 Address = Builder.CreateGEP(Base, Idx, "arrayidx");
2055 else
2056 Address = Builder.CreateInBoundsGEP(Base, Idx, "arrayidx");
Anders Carlsson8b33c082008-12-21 00:11:23 +00002057 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +00002058
Steve Naroff14108da2009-07-10 23:34:53 +00002059 QualType T = E->getBase()->getType()->getPointeeType();
Mike Stumpdb52dcd2009-09-09 13:00:44 +00002060 assert(!T.isNull() &&
Steve Naroff14108da2009-07-10 23:34:53 +00002061 "CodeGenFunction::EmitArraySubscriptExpr(): Illegal base type");
Mike Stumpdb52dcd2009-09-09 13:00:44 +00002062
Chris Lattner44a23992012-01-04 22:35:55 +00002063
Daniel Dunbard5534082011-04-01 00:49:43 +00002064 // Limit the alignment to that of the result type.
Chris Lattner44a23992012-01-04 22:35:55 +00002065 LValue LV;
Eli Friedman6da2c712011-12-03 04:14:32 +00002066 if (!ArrayAlignment.isZero()) {
2067 CharUnits Align = getContext().getTypeAlignInChars(T);
Daniel Dunbard5534082011-04-01 00:49:43 +00002068 ArrayAlignment = std::min(Align, ArrayAlignment);
Chris Lattner44a23992012-01-04 22:35:55 +00002069 LV = MakeAddrLValue(Address, T, ArrayAlignment);
2070 } else {
2071 LV = MakeNaturalAlignAddrLValue(Address, T);
Daniel Dunbard5534082011-04-01 00:49:43 +00002072 }
2073
Daniel Dunbar6d5eb762010-08-21 03:44:13 +00002074 LV.getQuals().setAddressSpace(E->getBase()->getType().getAddressSpace());
John McCall0953e762009-09-24 19:53:00 +00002075
David Blaikie4e4d0842012-03-11 07:00:24 +00002076 if (getContext().getLangOpts().ObjC1 &&
2077 getContext().getLangOpts().getGC() != LangOptions::NonGC) {
Daniel Dunbarea619172010-08-21 03:22:38 +00002078 LV.setNonGC(!E->isOBJCGCCandidate(getContext()));
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00002079 setObjCGCLValueClass(getContext(), E, LV);
2080 }
Fariborz Jahanian643887a2009-02-21 23:37:19 +00002081 return LV;
Reid Spencer5f016e22007-07-11 17:01:13 +00002082}
2083
Mike Stumpdb52dcd2009-09-09 13:00:44 +00002084static
NAKAMURA Takumiedf5a7b2012-01-25 08:58:21 +00002085llvm::Constant *GenerateConstantVector(CGBuilderTy &Builder,
Chris Lattner5f9e2722011-07-23 10:55:15 +00002086 SmallVector<unsigned, 4> &Elts) {
2087 SmallVector<llvm::Constant*, 4> CElts;
Nate Begeman3b8d1162008-05-13 21:03:02 +00002088 for (unsigned i = 0, e = Elts.size(); i != e; ++i)
Chris Lattner2ce88422012-01-25 05:34:41 +00002089 CElts.push_back(Builder.getInt32(Elts[i]));
Nate Begeman3b8d1162008-05-13 21:03:02 +00002090
Chris Lattnerfb018d12011-02-15 00:14:06 +00002091 return llvm::ConstantVector::get(CElts);
Nate Begeman3b8d1162008-05-13 21:03:02 +00002092}
2093
Chris Lattner349aaec2007-08-02 23:37:31 +00002094LValue CodeGenFunction::
Nate Begeman213541a2008-04-18 23:10:10 +00002095EmitExtVectorElementExpr(const ExtVectorElementExpr *E) {
Chris Lattner349aaec2007-08-02 23:37:31 +00002096 // Emit the base vector as an l-value.
Chris Lattner73525de2009-02-16 21:11:58 +00002097 LValue Base;
2098
2099 // ExtVectorElementExpr's base can either be a vector or pointer to vector.
Chris Lattner998eab12009-12-23 21:31:11 +00002100 if (E->isArrow()) {
2101 // If it is a pointer to a vector, emit the address and form an lvalue with
2102 // it.
Chris Lattner2140e902009-02-16 22:14:05 +00002103 llvm::Value *Ptr = EmitScalarExpr(E->getBase());
Chris Lattner998eab12009-12-23 21:31:11 +00002104 const PointerType *PT = E->getBase()->getType()->getAs<PointerType>();
Daniel Dunbar6d5eb762010-08-21 03:44:13 +00002105 Base = MakeAddrLValue(Ptr, PT->getPointeeType());
2106 Base.getQuals().removeObjCGCAttr();
John McCall7eb0a9e2010-11-24 05:12:34 +00002107 } else if (E->getBase()->isGLValue()) {
Chris Lattner998eab12009-12-23 21:31:11 +00002108 // Otherwise, if the base is an lvalue ( as in the case of foo.x.x),
2109 // emit the base as an lvalue.
2110 assert(E->getBase()->getType()->isVectorType());
2111 Base = EmitLValue(E->getBase());
2112 } else {
2113 // Otherwise, the base is a normal rvalue (as in (V+V).x), emit it as such.
John McCalla07398e2011-06-16 04:16:24 +00002114 assert(E->getBase()->getType()->isVectorType() &&
Daniel Dunbar302c3c22010-01-04 18:02:28 +00002115 "Result must be a vector");
Chris Lattner998eab12009-12-23 21:31:11 +00002116 llvm::Value *Vec = EmitScalarExpr(E->getBase());
2117
Chris Lattner0ad57fb2009-12-23 21:33:41 +00002118 // Store the vector to memory (because LValue wants an address).
Daniel Dunbar195337d2010-02-09 02:48:28 +00002119 llvm::Value *VecMem = CreateMemTemp(E->getBase()->getType());
Chris Lattner998eab12009-12-23 21:31:11 +00002120 Builder.CreateStore(Vec, VecMem);
Daniel Dunbar6d5eb762010-08-21 03:44:13 +00002121 Base = MakeAddrLValue(VecMem, E->getBase()->getType());
Chris Lattner998eab12009-12-23 21:31:11 +00002122 }
John McCalla07398e2011-06-16 04:16:24 +00002123
2124 QualType type =
2125 E->getType().withCVRQualifiers(Base.getQuals().getCVRQualifiers());
Chris Lattner998eab12009-12-23 21:31:11 +00002126
Nate Begeman3b8d1162008-05-13 21:03:02 +00002127 // Encode the element access list into a vector of unsigned indices.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002128 SmallVector<unsigned, 4> Indices;
Nate Begeman3b8d1162008-05-13 21:03:02 +00002129 E->getEncodedElementAccess(Indices);
2130
2131 if (Base.isSimple()) {
Chris Lattner2ce88422012-01-25 05:34:41 +00002132 llvm::Constant *CV = GenerateConstantVector(Builder, Indices);
Eli Friedmane5a8aeb2012-03-22 22:36:39 +00002133 return LValue::MakeExtVectorElt(Base.getAddress(), CV, type,
2134 Base.getAlignment());
Nate Begeman3b8d1162008-05-13 21:03:02 +00002135 }
2136 assert(Base.isExtVectorElt() && "Can only subscript lvalue vec elts here!");
2137
2138 llvm::Constant *BaseElts = Base.getExtVectorElts();
Chris Lattner5f9e2722011-07-23 10:55:15 +00002139 SmallVector<llvm::Constant *, 4> CElts;
Nate Begeman3b8d1162008-05-13 21:03:02 +00002140
Chris Lattner89f42832012-01-30 06:20:36 +00002141 for (unsigned i = 0, e = Indices.size(); i != e; ++i)
2142 CElts.push_back(BaseElts->getAggregateElement(Indices[i]));
Chris Lattnerfb018d12011-02-15 00:14:06 +00002143 llvm::Constant *CV = llvm::ConstantVector::get(CElts);
Eli Friedmane5a8aeb2012-03-22 22:36:39 +00002144 return LValue::MakeExtVectorElt(Base.getExtVectorAddr(), CV, type,
2145 Base.getAlignment());
Chris Lattner349aaec2007-08-02 23:37:31 +00002146}
2147
Devang Patelb9b00ad2007-10-23 20:28:39 +00002148LValue CodeGenFunction::EmitMemberExpr(const MemberExpr *E) {
Devang Patel126a8562007-10-24 22:26:28 +00002149 Expr *BaseExpr = E->getBase();
Eli Friedman1e692ac2008-06-13 23:01:12 +00002150
Chris Lattner12f65f62007-12-02 18:52:07 +00002151 // If this is s.x, emit s as an lvalue. If it is s->x, emit s as a scalar.
Eli Friedman377ecc72012-04-16 03:54:45 +00002152 LValue BaseLV;
Richard Smith2c9f87c2012-08-24 00:54:33 +00002153 if (E->isArrow()) {
2154 llvm::Value *Ptr = EmitScalarExpr(BaseExpr);
2155 QualType PtrTy = BaseExpr->getType()->getPointeeType();
Richard Smith7ac9ef12012-09-08 02:08:36 +00002156 EmitTypeCheck(TCK_MemberAccess, Ptr, PtrTy);
Richard Smith2c9f87c2012-08-24 00:54:33 +00002157 BaseLV = MakeNaturalAlignAddrLValue(Ptr, PtrTy);
2158 } else
Richard Smith7ac9ef12012-09-08 02:08:36 +00002159 BaseLV = EmitCheckedLValue(BaseExpr, TCK_MemberAccess);
Devang Patelb9b00ad2007-10-23 20:28:39 +00002160
Anders Carlssonce53f7d2009-11-07 23:06:58 +00002161 NamedDecl *ND = E->getMemberDecl();
2162 if (FieldDecl *Field = dyn_cast<FieldDecl>(ND)) {
Eli Friedman377ecc72012-04-16 03:54:45 +00002163 LValue LV = EmitLValueForField(BaseLV, Field);
Anders Carlssonce53f7d2009-11-07 23:06:58 +00002164 setObjCGCLValueClass(getContext(), E, LV);
2165 return LV;
2166 }
2167
Anders Carlsson589f9e32009-11-07 23:16:50 +00002168 if (VarDecl *VD = dyn_cast<VarDecl>(ND))
2169 return EmitGlobalVarDeclLValue(*this, E, VD);
Eli Friedman9a146302009-11-26 06:08:14 +00002170
2171 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND))
2172 return EmitFunctionDeclLValue(*this, E, FD);
2173
David Blaikieb219cfc2011-09-23 05:06:16 +00002174 llvm_unreachable("Unhandled member declaration!");
Eli Friedman472778e2008-02-09 08:50:58 +00002175}
Devang Patelb9b00ad2007-10-23 20:28:39 +00002176
Eli Friedman377ecc72012-04-16 03:54:45 +00002177LValue CodeGenFunction::EmitLValueForField(LValue base,
2178 const FieldDecl *field) {
Eli Friedmanf4bcfa12012-06-27 21:19:48 +00002179 if (field->isBitField()) {
2180 const CGRecordLayout &RL =
2181 CGM.getTypes().getCGRecordLayout(field->getParent());
2182 const CGBitFieldInfo &Info = RL.getBitFieldInfo(field);
2183 QualType fieldType =
2184 field->getType().withCVRQualifiers(base.getVRQualifiers());
2185 return LValue::MakeBitfield(base.getAddress(), Info, fieldType,
2186 base.getAlignment());
2187 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +00002188
John McCallbc7fbf02011-02-26 08:07:02 +00002189 const RecordDecl *rec = field->getParent();
2190 QualType type = field->getType();
Eli Friedman6da2c712011-12-03 04:14:32 +00002191 CharUnits alignment = getContext().getDeclAlign(field);
Eli Friedman1e86b342008-05-29 11:33:25 +00002192
Eli Friedman377ecc72012-04-16 03:54:45 +00002193 // FIXME: It should be impossible to have an LValue without alignment for a
2194 // complete type.
2195 if (!base.getAlignment().isZero())
2196 alignment = std::min(alignment, base.getAlignment());
2197
John McCallbc7fbf02011-02-26 08:07:02 +00002198 bool mayAlias = rec->hasAttr<MayAliasAttr>();
2199
Eli Friedman377ecc72012-04-16 03:54:45 +00002200 llvm::Value *addr = base.getAddress();
2201 unsigned cvr = base.getVRQualifiers();
John McCallbc7fbf02011-02-26 08:07:02 +00002202 if (rec->isUnion()) {
Chris Lattner74339df2011-07-10 05:34:54 +00002203 // For unions, there is no pointer adjustment.
John McCallbc7fbf02011-02-26 08:07:02 +00002204 assert(!type->isReferenceType() && "union has reference member");
John McCallbc7fbf02011-02-26 08:07:02 +00002205 } else {
2206 // For structs, we GEP to the field that the record layout suggests.
2207 unsigned idx = CGM.getTypes().getCGRecordLayout(rec).getLLVMFieldNo(field);
Chris Lattner74339df2011-07-10 05:34:54 +00002208 addr = Builder.CreateStructGEP(addr, idx, field->getName());
John McCallbc7fbf02011-02-26 08:07:02 +00002209
2210 // If this is a reference field, load the reference right now.
2211 if (const ReferenceType *refType = type->getAs<ReferenceType>()) {
2212 llvm::LoadInst *load = Builder.CreateLoad(addr, "ref");
2213 if (cvr & Qualifiers::Volatile) load->setVolatile(true);
Eli Friedman6da2c712011-12-03 04:14:32 +00002214 load->setAlignment(alignment.getQuantity());
John McCallbc7fbf02011-02-26 08:07:02 +00002215
2216 if (CGM.shouldUseTBAA()) {
2217 llvm::MDNode *tbaa;
2218 if (mayAlias)
2219 tbaa = CGM.getTBAAInfo(getContext().CharTy);
2220 else
2221 tbaa = CGM.getTBAAInfo(type);
2222 CGM.DecorateInstruction(load, tbaa);
2223 }
2224
2225 addr = load;
2226 mayAlias = false;
2227 type = refType->getPointeeType();
Eli Friedman2f77b3d2011-11-16 00:42:57 +00002228 if (type->isIncompleteType())
Eli Friedman6da2c712011-12-03 04:14:32 +00002229 alignment = CharUnits();
Eli Friedman2f77b3d2011-11-16 00:42:57 +00002230 else
Eli Friedman6da2c712011-12-03 04:14:32 +00002231 alignment = getContext().getTypeAlignInChars(type);
John McCallbc7fbf02011-02-26 08:07:02 +00002232 cvr = 0; // qualifiers don't recursively apply to referencee
2233 }
Devang Patelabad06c2007-10-26 19:42:18 +00002234 }
Chris Lattner74339df2011-07-10 05:34:54 +00002235
2236 // Make sure that the address is pointing to the right type. This is critical
2237 // for both unions and structs. A union needs a bitcast, a struct element
2238 // will need a bitcast if the LLVM type laid out doesn't match the desired
2239 // type.
Chandler Carrutha98742c2011-07-12 08:58:26 +00002240 addr = EmitBitCastOfLValueToProperType(*this, addr,
Chris Lattner3a2b6572011-07-12 06:52:18 +00002241 CGM.getTypes().ConvertTypeForMem(type),
2242 field->getName());
John McCall0953e762009-09-24 19:53:00 +00002243
Julien Lerouge77f68bb2011-09-09 22:41:49 +00002244 if (field->hasAttr<AnnotateAttr>())
2245 addr = EmitFieldAnnotations(field, addr);
2246
John McCallbc7fbf02011-02-26 08:07:02 +00002247 LValue LV = MakeAddrLValue(addr, type, alignment);
2248 LV.getQuals().addCVRQualifiers(cvr);
Daniel Dunbar6d5eb762010-08-21 03:44:13 +00002249
Fariborz Jahanianfd02ed72009-09-21 18:54:29 +00002250 // __weak attribute on a field is ignored.
Daniel Dunbar6d5eb762010-08-21 03:44:13 +00002251 if (LV.getQuals().getObjCGCAttr() == Qualifiers::Weak)
2252 LV.getQuals().removeObjCGCAttr();
John McCallbc7fbf02011-02-26 08:07:02 +00002253
2254 // Fields of may_alias structs act like 'char' for TBAA purposes.
2255 // FIXME: this should get propagated down through anonymous structs
2256 // and unions.
2257 if (mayAlias && LV.getTBAAInfo())
2258 LV.setTBAAInfo(CGM.getTBAAInfo(getContext().CharTy));
2259
Daniel Dunbar6d5eb762010-08-21 03:44:13 +00002260 return LV;
Devang Patelb9b00ad2007-10-23 20:28:39 +00002261}
2262
Anders Carlsson06a29702010-01-29 05:24:29 +00002263LValue
Eli Friedman377ecc72012-04-16 03:54:45 +00002264CodeGenFunction::EmitLValueForFieldInitialization(LValue Base,
2265 const FieldDecl *Field) {
Anders Carlsson06a29702010-01-29 05:24:29 +00002266 QualType FieldType = Field->getType();
2267
2268 if (!FieldType->isReferenceType())
Eli Friedman377ecc72012-04-16 03:54:45 +00002269 return EmitLValueForField(Base, Field);
Anders Carlsson06a29702010-01-29 05:24:29 +00002270
Daniel Dunbar198bcb42010-03-31 01:09:11 +00002271 const CGRecordLayout &RL =
2272 CGM.getTypes().getCGRecordLayout(Field->getParent());
2273 unsigned idx = RL.getLLVMFieldNo(Field);
Eli Friedman377ecc72012-04-16 03:54:45 +00002274 llvm::Value *V = Builder.CreateStructGEP(Base.getAddress(), idx);
Anders Carlsson06a29702010-01-29 05:24:29 +00002275 assert(!FieldType.getObjCGCAttr() && "fields cannot have GC attrs");
2276
Chris Lattner1b5ba852011-07-10 05:53:24 +00002277 // Make sure that the address is pointing to the right type. This is critical
2278 // for both unions and structs. A union needs a bitcast, a struct element
2279 // will need a bitcast if the LLVM type laid out doesn't match the desired
2280 // type.
Chris Lattner2acc6e32011-07-18 04:24:23 +00002281 llvm::Type *llvmType = ConvertTypeForMem(FieldType);
Eli Friedman377ecc72012-04-16 03:54:45 +00002282 V = EmitBitCastOfLValueToProperType(*this, V, llvmType, Field->getName());
2283
Eli Friedman6da2c712011-12-03 04:14:32 +00002284 CharUnits Alignment = getContext().getDeclAlign(Field);
Eli Friedman377ecc72012-04-16 03:54:45 +00002285
2286 // FIXME: It should be impossible to have an LValue without alignment for a
2287 // complete type.
2288 if (!Base.getAlignment().isZero())
2289 Alignment = std::min(Alignment, Base.getAlignment());
2290
Daniel Dunbar983e3d72010-08-21 04:20:22 +00002291 return MakeAddrLValue(V, FieldType, Alignment);
Anders Carlsson06a29702010-01-29 05:24:29 +00002292}
2293
Chris Lattnerd0db03a2010-09-06 00:11:41 +00002294LValue CodeGenFunction::EmitCompoundLiteralLValue(const CompoundLiteralExpr *E){
Richard Smith7401cf52011-11-22 22:48:32 +00002295 if (E->isFileScope()) {
2296 llvm::Value *GlobalPtr = CGM.GetAddrOfConstantCompoundLiteral(E);
2297 return MakeAddrLValue(GlobalPtr, E->getType());
2298 }
Fariborz Jahanianec22f562012-06-07 18:15:55 +00002299 if (E->getType()->isVariablyModifiedType())
2300 // make sure to emit the VLA size.
2301 EmitVariablyModifiedType(E->getType());
Fariborz Jahanian2ccc0f92012-06-07 17:07:15 +00002302
Daniel Dunbar15006572010-02-16 19:43:39 +00002303 llvm::Value *DeclPtr = CreateMemTemp(E->getType(), ".compoundliteral");
Chris Lattnerd0db03a2010-09-06 00:11:41 +00002304 const Expr *InitExpr = E->getInitializer();
Daniel Dunbar9f553f52010-08-21 03:08:16 +00002305 LValue Result = MakeAddrLValue(DeclPtr, E->getType());
Eli Friedman06e863f2008-05-13 23:18:27 +00002306
Chad Rosier649b4a12012-03-29 17:37:10 +00002307 EmitAnyExprToMem(InitExpr, DeclPtr, E->getType().getQualifiers(),
2308 /*Init*/ true);
Eli Friedman06e863f2008-05-13 23:18:27 +00002309
2310 return Result;
2311}
2312
Richard Smith13ec9102012-05-14 21:57:21 +00002313LValue CodeGenFunction::EmitInitListLValue(const InitListExpr *E) {
2314 if (!E->isGLValue())
2315 // Initializing an aggregate temporary in C++11: T{...}.
2316 return EmitAggExprToLValue(E);
2317
2318 // An lvalue initializer list must be initializing a reference.
2319 assert(E->getNumInits() == 1 && "reference init with multiple values");
2320 return EmitLValue(E->getInit(0));
2321}
2322
John McCall56ca35d2011-02-17 10:25:35 +00002323LValue CodeGenFunction::
2324EmitConditionalOperatorLValue(const AbstractConditionalOperator *expr) {
2325 if (!expr->isGLValue()) {
John McCallf99a3912011-01-26 19:21:13 +00002326 // ?: here should be an aggregate.
John McCall56ca35d2011-02-17 10:25:35 +00002327 assert((hasAggregateLLVMType(expr->getType()) &&
2328 !expr->getType()->isAnyComplexType()) &&
John McCallf99a3912011-01-26 19:21:13 +00002329 "Unexpected conditional operator!");
John McCall56ca35d2011-02-17 10:25:35 +00002330 return EmitAggExprToLValue(expr);
Anders Carlsson6fcec8b2009-09-15 16:35:24 +00002331 }
Daniel Dunbar90345582009-03-24 02:38:23 +00002332
Eli Friedman2c0c7452012-01-25 05:04:17 +00002333 OpaqueValueMapping binding(*this, expr);
2334
John McCall56ca35d2011-02-17 10:25:35 +00002335 const Expr *condExpr = expr->getCond();
Chris Lattnerc2c90012011-02-27 23:02:32 +00002336 bool CondExprBool;
2337 if (ConstantFoldsToSimpleInteger(condExpr, CondExprBool)) {
John McCall56ca35d2011-02-17 10:25:35 +00002338 const Expr *live = expr->getTrueExpr(), *dead = expr->getFalseExpr();
Chris Lattnerc2c90012011-02-27 23:02:32 +00002339 if (!CondExprBool) std::swap(live, dead);
John McCall56ca35d2011-02-17 10:25:35 +00002340
2341 if (!ContainsLabel(dead))
2342 return EmitLValue(live);
John McCallf99a3912011-01-26 19:21:13 +00002343 }
2344
John McCall56ca35d2011-02-17 10:25:35 +00002345 llvm::BasicBlock *lhsBlock = createBasicBlock("cond.true");
2346 llvm::BasicBlock *rhsBlock = createBasicBlock("cond.false");
2347 llvm::BasicBlock *contBlock = createBasicBlock("cond.end");
John McCallf99a3912011-01-26 19:21:13 +00002348
2349 ConditionalEvaluation eval(*this);
John McCall56ca35d2011-02-17 10:25:35 +00002350 EmitBranchOnBoolExpr(condExpr, lhsBlock, rhsBlock);
John McCallf99a3912011-01-26 19:21:13 +00002351
2352 // Any temporaries created here are conditional.
John McCall56ca35d2011-02-17 10:25:35 +00002353 EmitBlock(lhsBlock);
John McCallf99a3912011-01-26 19:21:13 +00002354 eval.begin(*this);
John McCall56ca35d2011-02-17 10:25:35 +00002355 LValue lhs = EmitLValue(expr->getTrueExpr());
John McCallf99a3912011-01-26 19:21:13 +00002356 eval.end(*this);
2357
John McCall56ca35d2011-02-17 10:25:35 +00002358 if (!lhs.isSimple())
2359 return EmitUnsupportedLValue(expr, "conditional operator");
John McCallf99a3912011-01-26 19:21:13 +00002360
John McCall56ca35d2011-02-17 10:25:35 +00002361 lhsBlock = Builder.GetInsertBlock();
2362 Builder.CreateBr(contBlock);
John McCallf99a3912011-01-26 19:21:13 +00002363
2364 // Any temporaries created here are conditional.
John McCall56ca35d2011-02-17 10:25:35 +00002365 EmitBlock(rhsBlock);
John McCallf99a3912011-01-26 19:21:13 +00002366 eval.begin(*this);
John McCall56ca35d2011-02-17 10:25:35 +00002367 LValue rhs = EmitLValue(expr->getFalseExpr());
John McCallf99a3912011-01-26 19:21:13 +00002368 eval.end(*this);
John McCall56ca35d2011-02-17 10:25:35 +00002369 if (!rhs.isSimple())
2370 return EmitUnsupportedLValue(expr, "conditional operator");
2371 rhsBlock = Builder.GetInsertBlock();
John McCallf99a3912011-01-26 19:21:13 +00002372
John McCall56ca35d2011-02-17 10:25:35 +00002373 EmitBlock(contBlock);
John McCallf99a3912011-01-26 19:21:13 +00002374
Jay Foadbbf3bac2011-03-30 11:28:58 +00002375 llvm::PHINode *phi = Builder.CreatePHI(lhs.getAddress()->getType(), 2,
John McCallf99a3912011-01-26 19:21:13 +00002376 "cond-lvalue");
John McCall56ca35d2011-02-17 10:25:35 +00002377 phi->addIncoming(lhs.getAddress(), lhsBlock);
2378 phi->addIncoming(rhs.getAddress(), rhsBlock);
2379 return MakeAddrLValue(phi, expr->getType());
Daniel Dunbar90345582009-03-24 02:38:23 +00002380}
2381
Richard Smith13ec9102012-05-14 21:57:21 +00002382/// EmitCastLValue - Casts are never lvalues unless that cast is to a reference
2383/// type. If the cast is to a reference, we can have the usual lvalue result,
Mike Stumpc849c052009-11-16 06:50:58 +00002384/// otherwise if a cast is needed by the code generator in an lvalue context,
2385/// then it must mean that we need the address of an aggregate in order to
Richard Smith13ec9102012-05-14 21:57:21 +00002386/// access one of its members. This can happen for all the reasons that casts
Mike Stumpc849c052009-11-16 06:50:58 +00002387/// are permitted with aggregate result, including noop aggregate casts, and
2388/// cast from scalar to union.
Chris Lattner75dfeda2009-03-18 18:28:57 +00002389LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) {
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00002390 switch (E->getCastKind()) {
John McCall2de56d12010-08-25 11:45:40 +00002391 case CK_ToVoid:
Eli Friedmaneaae78a2009-11-16 05:48:01 +00002392 return EmitUnsupportedLValue(E, "unexpected cast lvalue");
John McCalldaa8e4e2010-11-15 09:13:47 +00002393
2394 case CK_Dependent:
2395 llvm_unreachable("dependent cast kind in IR gen!");
Eli Friedmana6c66ce2012-08-31 00:14:07 +00002396
2397 case CK_BuiltinFnToFnPtr:
2398 llvm_unreachable("builtin functions are handled elsewhere");
2399
David Chisnall7a7ee302012-01-16 17:27:18 +00002400 // These two casts are currently treated as no-ops, although they could
2401 // potentially be real operations depending on the target's ABI.
2402 case CK_NonAtomicToAtomic:
2403 case CK_AtomicToNonAtomic:
John McCalldaa8e4e2010-11-15 09:13:47 +00002404
John McCall2de56d12010-08-25 11:45:40 +00002405 case CK_NoOp:
Douglas Gregorb3d5e2f2011-01-27 23:22:05 +00002406 case CK_LValueToRValue:
2407 if (!E->getSubExpr()->Classify(getContext()).isPRValue()
2408 || E->getType()->isRecordType())
John McCall0e800c92010-12-04 08:14:53 +00002409 return EmitLValue(E->getSubExpr());
Douglas Gregor7c7a7932010-07-15 18:58:16 +00002410 // Fall through to synthesize a temporary.
John McCalldaa8e4e2010-11-15 09:13:47 +00002411
John McCall2de56d12010-08-25 11:45:40 +00002412 case CK_BitCast:
2413 case CK_ArrayToPointerDecay:
2414 case CK_FunctionToPointerDecay:
2415 case CK_NullToMemberPointer:
John McCall404cd162010-11-13 01:35:44 +00002416 case CK_NullToPointer:
John McCall2de56d12010-08-25 11:45:40 +00002417 case CK_IntegralToPointer:
2418 case CK_PointerToIntegral:
John McCalldaa8e4e2010-11-15 09:13:47 +00002419 case CK_PointerToBoolean:
John McCall2de56d12010-08-25 11:45:40 +00002420 case CK_VectorSplat:
2421 case CK_IntegralCast:
John McCalldaa8e4e2010-11-15 09:13:47 +00002422 case CK_IntegralToBoolean:
John McCall2de56d12010-08-25 11:45:40 +00002423 case CK_IntegralToFloating:
2424 case CK_FloatingToIntegral:
John McCalldaa8e4e2010-11-15 09:13:47 +00002425 case CK_FloatingToBoolean:
John McCall2de56d12010-08-25 11:45:40 +00002426 case CK_FloatingCast:
John McCall2bb5d002010-11-13 09:02:35 +00002427 case CK_FloatingRealToComplex:
John McCallf3ea8cf2010-11-14 08:17:51 +00002428 case CK_FloatingComplexToReal:
2429 case CK_FloatingComplexToBoolean:
John McCall2bb5d002010-11-13 09:02:35 +00002430 case CK_FloatingComplexCast:
John McCallf3ea8cf2010-11-14 08:17:51 +00002431 case CK_FloatingComplexToIntegralComplex:
John McCall2bb5d002010-11-13 09:02:35 +00002432 case CK_IntegralRealToComplex:
John McCallf3ea8cf2010-11-14 08:17:51 +00002433 case CK_IntegralComplexToReal:
2434 case CK_IntegralComplexToBoolean:
John McCall2bb5d002010-11-13 09:02:35 +00002435 case CK_IntegralComplexCast:
John McCallf3ea8cf2010-11-14 08:17:51 +00002436 case CK_IntegralComplexToFloatingComplex:
John McCall2de56d12010-08-25 11:45:40 +00002437 case CK_DerivedToBaseMemberPointer:
2438 case CK_BaseToDerivedMemberPointer:
2439 case CK_MemberPointerToBoolean:
John McCall4d4e5c12012-02-15 01:22:51 +00002440 case CK_ReinterpretMemberPointer:
John McCallf85e1932011-06-15 23:02:42 +00002441 case CK_AnyPointerToBlockPointerCast:
John McCall33e56f32011-09-10 06:18:15 +00002442 case CK_ARCProduceObject:
2443 case CK_ARCConsumeObject:
2444 case CK_ARCReclaimReturnedObject:
Douglas Gregorac1303e2012-02-22 05:02:47 +00002445 case CK_ARCExtendBlockObject:
2446 case CK_CopyAndAutoreleaseBlockObject: {
Douglas Gregor7c7a7932010-07-15 18:58:16 +00002447 // These casts only produce lvalues when we're binding a reference to a
2448 // temporary realized from a (converted) pure rvalue. Emit the expression
2449 // as a value, copy it into a temporary, and return an lvalue referring to
2450 // that temporary.
2451 llvm::Value *V = CreateMemTemp(E->getType(), "ref.temp");
Chad Rosier649b4a12012-03-29 17:37:10 +00002452 EmitAnyExprToMem(E, V, E->getType().getQualifiers(), false);
Daniel Dunbar9f553f52010-08-21 03:08:16 +00002453 return MakeAddrLValue(V, E->getType());
Douglas Gregor7c7a7932010-07-15 18:58:16 +00002454 }
Eli Friedmaneaae78a2009-11-16 05:48:01 +00002455
Anders Carlsson575b3742011-04-11 02:03:26 +00002456 case CK_Dynamic: {
Mike Stumpc849c052009-11-16 06:50:58 +00002457 LValue LV = EmitLValue(E->getSubExpr());
2458 llvm::Value *V = LV.getAddress();
2459 const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(E);
Daniel Dunbar9f553f52010-08-21 03:08:16 +00002460 return MakeAddrLValue(EmitDynamicCast(V, DCE), E->getType());
Mike Stumpc849c052009-11-16 06:50:58 +00002461 }
2462
John McCall2de56d12010-08-25 11:45:40 +00002463 case CK_ConstructorConversion:
2464 case CK_UserDefinedConversion:
John McCall1d9b3b22011-09-09 05:25:32 +00002465 case CK_CPointerToObjCPointerCast:
2466 case CK_BlockPointerToObjCPointerCast:
Chris Lattner75dfeda2009-03-18 18:28:57 +00002467 return EmitLValue(E->getSubExpr());
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00002468
John McCall2de56d12010-08-25 11:45:40 +00002469 case CK_UncheckedDerivedToBase:
2470 case CK_DerivedToBase: {
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00002471 const RecordType *DerivedClassTy =
2472 E->getSubExpr()->getType()->getAs<RecordType>();
2473 CXXRecordDecl *DerivedClassDecl =
2474 cast<CXXRecordDecl>(DerivedClassTy->getDecl());
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00002475
2476 LValue LV = EmitLValue(E->getSubExpr());
John McCall0e800c92010-12-04 08:14:53 +00002477 llvm::Value *This = LV.getAddress();
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00002478
2479 // Perform the derived-to-base conversion
2480 llvm::Value *Base =
Fariborz Jahanian353b33b2010-06-17 23:00:29 +00002481 GetAddressOfBaseClass(This, DerivedClassDecl,
John McCallf871d0c2010-08-07 06:22:56 +00002482 E->path_begin(), E->path_end(),
2483 /*NullCheckValue=*/false);
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00002484
Daniel Dunbar9f553f52010-08-21 03:08:16 +00002485 return MakeAddrLValue(Base, E->getType());
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00002486 }
John McCall2de56d12010-08-25 11:45:40 +00002487 case CK_ToUnion:
Daniel Dunbarb2cd7772010-02-05 20:02:42 +00002488 return EmitAggExprToLValue(E);
John McCall2de56d12010-08-25 11:45:40 +00002489 case CK_BaseToDerived: {
Anders Carlssona3697c92009-11-23 17:57:54 +00002490 const RecordType *DerivedClassTy = E->getType()->getAs<RecordType>();
2491 CXXRecordDecl *DerivedClassDecl =
2492 cast<CXXRecordDecl>(DerivedClassTy->getDecl());
2493
2494 LValue LV = EmitLValue(E->getSubExpr());
2495
2496 // Perform the base-to-derived conversion
2497 llvm::Value *Derived =
Anders Carlssona04efdf2010-04-24 21:23:59 +00002498 GetAddressOfDerivedClass(LV.getAddress(), DerivedClassDecl,
John McCallf871d0c2010-08-07 06:22:56 +00002499 E->path_begin(), E->path_end(),
2500 /*NullCheckValue=*/false);
Anders Carlssona3697c92009-11-23 17:57:54 +00002501
Daniel Dunbar9f553f52010-08-21 03:08:16 +00002502 return MakeAddrLValue(Derived, E->getType());
Eli Friedmaneaae78a2009-11-16 05:48:01 +00002503 }
John McCall2de56d12010-08-25 11:45:40 +00002504 case CK_LValueBitCast: {
Eli Friedmaneaae78a2009-11-16 05:48:01 +00002505 // This must be a reinterpret_cast (or c-style equivalent).
2506 const ExplicitCastExpr *CE = cast<ExplicitCastExpr>(E);
Anders Carlsson658e8122009-11-14 21:21:42 +00002507
2508 LValue LV = EmitLValue(E->getSubExpr());
2509 llvm::Value *V = Builder.CreateBitCast(LV.getAddress(),
2510 ConvertType(CE->getTypeAsWritten()));
Daniel Dunbar9f553f52010-08-21 03:08:16 +00002511 return MakeAddrLValue(V, E->getType());
Anders Carlsson658e8122009-11-14 21:21:42 +00002512 }
John McCall2de56d12010-08-25 11:45:40 +00002513 case CK_ObjCObjectLValueCast: {
Douglas Gregor569c3162010-08-07 11:51:51 +00002514 LValue LV = EmitLValue(E->getSubExpr());
2515 QualType ToType = getContext().getLValueReferenceType(E->getType());
2516 llvm::Value *V = Builder.CreateBitCast(LV.getAddress(),
2517 ConvertType(ToType));
Daniel Dunbar9f553f52010-08-21 03:08:16 +00002518 return MakeAddrLValue(V, E->getType());
Douglas Gregor569c3162010-08-07 11:51:51 +00002519 }
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00002520 }
Douglas Gregor7c7a7932010-07-15 18:58:16 +00002521
2522 llvm_unreachable("Unhandled lvalue cast kind?");
Chris Lattner75dfeda2009-03-18 18:28:57 +00002523}
2524
Fariborz Jahanian48620ba2009-10-20 23:29:04 +00002525LValue CodeGenFunction::EmitNullInitializationLValue(
Douglas Gregored8abf12010-07-08 06:14:04 +00002526 const CXXScalarValueInitExpr *E) {
Fariborz Jahanian48620ba2009-10-20 23:29:04 +00002527 QualType Ty = E->getType();
Daniel Dunbar9f553f52010-08-21 03:08:16 +00002528 LValue LV = MakeAddrLValue(CreateMemTemp(Ty), Ty);
Anders Carlsson1884eb02010-05-22 17:35:42 +00002529 EmitNullInitialization(LV.getAddress(), Ty);
Daniel Dunbar195337d2010-02-09 02:48:28 +00002530 return LV;
Fariborz Jahanian48620ba2009-10-20 23:29:04 +00002531}
2532
John McCalle996ffd2011-02-16 08:02:54 +00002533LValue CodeGenFunction::EmitOpaqueValueLValue(const OpaqueValueExpr *e) {
John McCalla5493f82011-11-08 22:54:08 +00002534 assert(OpaqueValueMappingData::shouldBindAsLValue(e));
John McCall56ca35d2011-02-17 10:25:35 +00002535 return getOpaqueLValueMapping(e);
John McCalle996ffd2011-02-16 08:02:54 +00002536}
2537
Douglas Gregor03e80032011-06-21 17:03:29 +00002538LValue CodeGenFunction::EmitMaterializeTemporaryExpr(
2539 const MaterializeTemporaryExpr *E) {
John McCallcec52f02011-08-26 21:08:13 +00002540 RValue RV = EmitReferenceBindingToExpr(E, /*InitializedDecl=*/0);
Douglas Gregor0b581082011-06-21 18:20:46 +00002541 return MakeAddrLValue(RV.getScalarVal(), E->getType());
Douglas Gregor03e80032011-06-21 17:03:29 +00002542}
2543
Eli Friedman377ecc72012-04-16 03:54:45 +00002544RValue CodeGenFunction::EmitRValueForField(LValue LV,
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00002545 const FieldDecl *FD) {
2546 QualType FT = FD->getType();
Eli Friedman377ecc72012-04-16 03:54:45 +00002547 LValue FieldLV = EmitLValueForField(LV, FD);
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00002548 if (FT->isAnyComplexType())
Eli Friedman377ecc72012-04-16 03:54:45 +00002549 return RValue::getComplex(
2550 LoadComplexFromAddr(FieldLV.getAddress(),
2551 FieldLV.isVolatileQualified()));
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00002552 else if (CodeGenFunction::hasAggregateLLVMType(FT))
Eli Friedman377ecc72012-04-16 03:54:45 +00002553 return FieldLV.asAggregateRValue();
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00002554
Eli Friedman377ecc72012-04-16 03:54:45 +00002555 return EmitLoadOfLValue(FieldLV);
Anton Korobeynikoveaf856d2012-04-13 11:22:00 +00002556}
Douglas Gregor03e80032011-06-21 17:03:29 +00002557
Reid Spencer5f016e22007-07-11 17:01:13 +00002558//===--------------------------------------------------------------------===//
2559// Expression Emission
2560//===--------------------------------------------------------------------===//
2561
Anders Carlssond2490a92009-12-24 20:40:36 +00002562RValue CodeGenFunction::EmitCallExpr(const CallExpr *E,
2563 ReturnValueSlot ReturnValue) {
Eric Christopher73fb3502011-10-13 21:45:18 +00002564 if (CGDebugInfo *DI = getDebugInfo())
2565 DI->EmitLocation(Builder, E->getLocStart());
Devang Patel79bfb4b2011-03-04 18:54:42 +00002566
Daniel Dunbarc0ef9f52009-02-20 18:06:48 +00002567 // Builtins never have block type.
Daniel Dunbarce1d38b2009-01-09 16:50:52 +00002568 if (E->getCallee()->getType()->isBlockPointerType())
Anders Carlssona1736c02009-12-24 21:13:40 +00002569 return EmitBlockCallExpr(E, ReturnValue);
Daniel Dunbarce1d38b2009-01-09 16:50:52 +00002570
Anders Carlsson774e7c62009-04-03 22:50:24 +00002571 if (const CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(E))
Anders Carlssona1736c02009-12-24 21:13:40 +00002572 return EmitCXXMemberCallExpr(CE, ReturnValue);
Mike Stumpdb52dcd2009-09-09 13:00:44 +00002573
Peter Collingbourne6c0aa5f2011-10-06 18:29:37 +00002574 if (const CUDAKernelCallExpr *CE = dyn_cast<CUDAKernelCallExpr>(E))
2575 return EmitCUDAKernelCallExpr(CE, ReturnValue);
2576
Douglas Gregor1ddc9c42011-09-06 21:41:04 +00002577 const Decl *TargetDecl = E->getCalleeDecl();
2578 if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(TargetDecl)) {
2579 if (unsigned builtinID = FD->getBuiltinID())
2580 return EmitBuiltinExpr(FD, builtinID, E);
Daniel Dunbarc0ef9f52009-02-20 18:06:48 +00002581 }
2582
Chris Lattner5db7ae52009-06-13 00:26:38 +00002583 if (const CXXOperatorCallExpr *CE = dyn_cast<CXXOperatorCallExpr>(E))
Anders Carlsson0f294632009-05-27 04:18:27 +00002584 if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(TargetDecl))
Anders Carlssona1736c02009-12-24 21:13:40 +00002585 return EmitCXXOperatorMemberCallExpr(CE, MD, ReturnValue);
Mike Stumpdb52dcd2009-09-09 13:00:44 +00002586
John McCallf85e1932011-06-15 23:02:42 +00002587 if (const CXXPseudoDestructorExpr *PseudoDtor
2588 = dyn_cast<CXXPseudoDestructorExpr>(E->getCallee()->IgnoreParens())) {
2589 QualType DestroyedType = PseudoDtor->getDestroyedType();
David Blaikie4e4d0842012-03-11 07:00:24 +00002590 if (getContext().getLangOpts().ObjCAutoRefCount &&
John McCallf85e1932011-06-15 23:02:42 +00002591 DestroyedType->isObjCLifetimeType() &&
2592 (DestroyedType.getObjCLifetime() == Qualifiers::OCL_Strong ||
2593 DestroyedType.getObjCLifetime() == Qualifiers::OCL_Weak)) {
Benjamin Kramerd510fd22011-06-18 10:34:00 +00002594 // Automatic Reference Counting:
2595 // If the pseudo-expression names a retainable object with weak or
2596 // strong lifetime, the object shall be released.
John McCallf85e1932011-06-15 23:02:42 +00002597 Expr *BaseExpr = PseudoDtor->getBase();
2598 llvm::Value *BaseValue = NULL;
2599 Qualifiers BaseQuals;
2600
Benjamin Kramerd510fd22011-06-18 10:34:00 +00002601 // If this is s.x, emit s as an lvalue. If it is s->x, emit s as a scalar.
John McCallf85e1932011-06-15 23:02:42 +00002602 if (PseudoDtor->isArrow()) {
2603 BaseValue = EmitScalarExpr(BaseExpr);
2604 const PointerType *PTy = BaseExpr->getType()->getAs<PointerType>();
2605 BaseQuals = PTy->getPointeeType().getQualifiers();
2606 } else {
2607 LValue BaseLV = EmitLValue(BaseExpr);
John McCallf85e1932011-06-15 23:02:42 +00002608 BaseValue = BaseLV.getAddress();
2609 QualType BaseTy = BaseExpr->getType();
2610 BaseQuals = BaseTy.getQualifiers();
2611 }
2612
2613 switch (PseudoDtor->getDestroyedType().getObjCLifetime()) {
2614 case Qualifiers::OCL_None:
2615 case Qualifiers::OCL_ExplicitNone:
2616 case Qualifiers::OCL_Autoreleasing:
2617 break;
2618
2619 case Qualifiers::OCL_Strong:
2620 EmitARCRelease(Builder.CreateLoad(BaseValue,
Benjamin Kramerd510fd22011-06-18 10:34:00 +00002621 PseudoDtor->getDestroyedType().isVolatileQualified()),
John McCallf85e1932011-06-15 23:02:42 +00002622 /*precise*/ true);
2623 break;
2624
2625 case Qualifiers::OCL_Weak:
2626 EmitARCDestroyWeak(BaseValue);
2627 break;
2628 }
2629 } else {
2630 // C++ [expr.pseudo]p1:
2631 // The result shall only be used as the operand for the function call
2632 // operator (), and the result of such a call has type void. The only
2633 // effect is the evaluation of the postfix-expression before the dot or
2634 // arrow.
2635 EmitScalarExpr(E->getCallee());
2636 }
2637
Douglas Gregora71d8192009-09-04 17:36:40 +00002638 return RValue::get(0);
2639 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +00002640
Chris Lattner7f02f722007-08-24 05:35:26 +00002641 llvm::Value *Callee = EmitScalarExpr(E->getCallee());
Anders Carlssond2490a92009-12-24 20:40:36 +00002642 return EmitCall(E->getCallee()->getType(), Callee, ReturnValue,
Anders Carlsson98647712009-05-27 01:22:39 +00002643 E->arg_begin(), E->arg_end(), TargetDecl);
Chris Lattnerc5e940f2007-08-31 04:44:06 +00002644}
2645
Daniel Dunbar80e62c22008-09-04 03:20:13 +00002646LValue CodeGenFunction::EmitBinaryOperatorLValue(const BinaryOperator *E) {
Chris Lattner7a574cc2009-05-12 21:28:12 +00002647 // Comma expressions just emit their LHS then their RHS as an l-value.
John McCall2de56d12010-08-25 11:45:40 +00002648 if (E->getOpcode() == BO_Comma) {
John McCall2a416372010-12-05 02:00:02 +00002649 EmitIgnoredExpr(E->getLHS());
Eli Friedman130c69e2009-12-07 20:18:11 +00002650 EnsureInsertPoint();
Chris Lattner7a574cc2009-05-12 21:28:12 +00002651 return EmitLValue(E->getRHS());
2652 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +00002653
John McCall2de56d12010-08-25 11:45:40 +00002654 if (E->getOpcode() == BO_PtrMemD ||
2655 E->getOpcode() == BO_PtrMemI)
Fariborz Jahanian8bfd31f2009-10-22 22:57:31 +00002656 return EmitPointerToDataMemberBinaryExpr(E);
Daniel Dunbar80e62c22008-09-04 03:20:13 +00002657
John McCall2a416372010-12-05 02:00:02 +00002658 assert(E->getOpcode() == BO_Assign && "unexpected binary l-value");
John McCallf85e1932011-06-15 23:02:42 +00002659
2660 // Note that in all of these cases, __block variables need the RHS
2661 // evaluated first just in case the variable gets moved by the RHS.
John McCall83ce9d42010-11-16 23:07:28 +00002662
Anders Carlsson86aa0cd2009-10-19 18:28:22 +00002663 if (!hasAggregateLLVMType(E->getType())) {
John McCallf85e1932011-06-15 23:02:42 +00002664 switch (E->getLHS()->getType().getObjCLifetime()) {
2665 case Qualifiers::OCL_Strong:
2666 return EmitARCStoreStrong(E, /*ignored*/ false).first;
2667
2668 case Qualifiers::OCL_Autoreleasing:
2669 return EmitARCStoreAutoreleasing(E).first;
2670
2671 // No reason to do any of these differently.
2672 case Qualifiers::OCL_None:
2673 case Qualifiers::OCL_ExplicitNone:
2674 case Qualifiers::OCL_Weak:
2675 break;
2676 }
2677
John McCallcd940a12010-12-06 06:10:02 +00002678 RValue RV = EmitAnyExpr(E->getRHS());
Anders Carlsson86aa0cd2009-10-19 18:28:22 +00002679 LValue LV = EmitLValue(E->getLHS());
John McCall545d9962011-06-25 02:11:03 +00002680 EmitStoreThroughLValue(RV, LV);
Anders Carlsson86aa0cd2009-10-19 18:28:22 +00002681 return LV;
2682 }
John McCall83ce9d42010-11-16 23:07:28 +00002683
2684 if (E->getType()->isAnyComplexType())
2685 return EmitComplexAssignmentLValue(E);
2686
Daniel Dunbar18aba0d2010-02-05 19:38:31 +00002687 return EmitAggExprToLValue(E);
Daniel Dunbar80e62c22008-09-04 03:20:13 +00002688}
2689
Christopher Lamb22c940e2007-12-29 05:02:41 +00002690LValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) {
Christopher Lamb22c940e2007-12-29 05:02:41 +00002691 RValue RV = EmitCallExpr(E);
Anders Carlsson48265682009-05-27 01:45:47 +00002692
Chris Lattnereb99b012009-10-28 17:39:19 +00002693 if (!RV.isScalar())
Daniel Dunbar9f553f52010-08-21 03:08:16 +00002694 return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
Chris Lattnereb99b012009-10-28 17:39:19 +00002695
2696 assert(E->getCallReturnType()->isReferenceType() &&
2697 "Can't have a scalar return unless the return type is a "
2698 "reference type!");
Mike Stumpdb52dcd2009-09-09 13:00:44 +00002699
Daniel Dunbar9f553f52010-08-21 03:08:16 +00002700 return MakeAddrLValue(RV.getScalarVal(), E->getType());
Christopher Lamb22c940e2007-12-29 05:02:41 +00002701}
2702
Daniel Dunbar5b5c9ef2009-02-11 20:59:32 +00002703LValue CodeGenFunction::EmitVAArgExprLValue(const VAArgExpr *E) {
2704 // FIXME: This shouldn't require another copy.
Daniel Dunbar18aba0d2010-02-05 19:38:31 +00002705 return EmitAggExprToLValue(E);
Daniel Dunbar5b5c9ef2009-02-11 20:59:32 +00002706}
2707
Anders Carlssonb58d0172009-05-30 23:23:33 +00002708LValue CodeGenFunction::EmitCXXConstructLValue(const CXXConstructExpr *E) {
John McCallfc1e6c72010-09-18 00:58:34 +00002709 assert(E->getType()->getAsCXXRecordDecl()->hasTrivialDestructor()
2710 && "binding l-value to type which needs a temporary");
Benjamin Kramer578faa82011-09-27 21:06:10 +00002711 AggValueSlot Slot = CreateAggTemp(E->getType());
John McCall558d2ab2010-09-15 10:14:12 +00002712 EmitCXXConstructExpr(E, Slot);
2713 return MakeAddrLValue(Slot.getAddr(), E->getType());
Anders Carlssonb58d0172009-05-30 23:23:33 +00002714}
2715
Anders Carlssone61c9e82009-05-30 23:30:54 +00002716LValue
Mike Stumpc2e84ae2009-11-15 08:09:41 +00002717CodeGenFunction::EmitCXXTypeidLValue(const CXXTypeidExpr *E) {
Daniel Dunbar9f553f52010-08-21 03:08:16 +00002718 return MakeAddrLValue(EmitCXXTypeidExpr(E), E->getType());
Mike Stumpc2e84ae2009-11-15 08:09:41 +00002719}
2720
2721LValue
Anders Carlssone61c9e82009-05-30 23:30:54 +00002722CodeGenFunction::EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E) {
John McCallfc1e6c72010-09-18 00:58:34 +00002723 AggValueSlot Slot = CreateAggTemp(E->getType(), "temp.lvalue");
John McCallfd71fb82011-08-26 08:02:37 +00002724 Slot.setExternallyDestructed();
John McCallfc1e6c72010-09-18 00:58:34 +00002725 EmitAggExpr(E->getSubExpr(), Slot);
Peter Collingbourne86811602011-11-27 22:09:22 +00002726 EmitCXXTemporary(E->getTemporary(), E->getType(), Slot.getAddr());
John McCallfc1e6c72010-09-18 00:58:34 +00002727 return MakeAddrLValue(Slot.getAddr(), E->getType());
Anders Carlssone61c9e82009-05-30 23:30:54 +00002728}
2729
Eli Friedman31a37022012-02-08 05:34:55 +00002730LValue
2731CodeGenFunction::EmitLambdaLValue(const LambdaExpr *E) {
Eli Friedman31a37022012-02-08 05:34:55 +00002732 AggValueSlot Slot = CreateAggTemp(E->getType(), "temp.lvalue");
Eli Friedman4c5d8af2012-02-09 03:32:31 +00002733 EmitLambdaExpr(E, Slot);
Eli Friedman31a37022012-02-08 05:34:55 +00002734 return MakeAddrLValue(Slot.getAddr(), E->getType());
2735}
2736
Daniel Dunbar0a04d772008-08-23 10:51:21 +00002737LValue CodeGenFunction::EmitObjCMessageExprLValue(const ObjCMessageExpr *E) {
Daniel Dunbar0a04d772008-08-23 10:51:21 +00002738 RValue RV = EmitObjCMessageExpr(E);
Anders Carlsson7e70fb22010-06-21 20:59:55 +00002739
2740 if (!RV.isScalar())
Daniel Dunbar9f553f52010-08-21 03:08:16 +00002741 return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
Anders Carlsson7e70fb22010-06-21 20:59:55 +00002742
2743 assert(E->getMethodDecl()->getResultType()->isReferenceType() &&
2744 "Can't have a scalar return unless the return type is a "
2745 "reference type!");
2746
Daniel Dunbar9f553f52010-08-21 03:08:16 +00002747 return MakeAddrLValue(RV.getScalarVal(), E->getType());
Daniel Dunbar0a04d772008-08-23 10:51:21 +00002748}
2749
Fariborz Jahanian03b29602010-06-17 19:56:20 +00002750LValue CodeGenFunction::EmitObjCSelectorLValue(const ObjCSelectorExpr *E) {
2751 llvm::Value *V =
2752 CGM.getObjCRuntime().GetSelector(Builder, E->getSelector(), true);
Daniel Dunbar9f553f52010-08-21 03:08:16 +00002753 return MakeAddrLValue(V, E->getType());
Fariborz Jahanian03b29602010-06-17 19:56:20 +00002754}
2755
Daniel Dunbar2a031922009-04-22 05:08:15 +00002756llvm::Value *CodeGenFunction::EmitIvarOffset(const ObjCInterfaceDecl *Interface,
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00002757 const ObjCIvarDecl *Ivar) {
Fariborz Jahanianf63aa3f2009-02-10 19:02:04 +00002758 return CGM.getObjCRuntime().EmitIvarOffset(*this, Interface, Ivar);
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00002759}
2760
Fariborz Jahanian45012a72009-02-03 00:09:52 +00002761LValue CodeGenFunction::EmitLValueForIvar(QualType ObjectTy,
2762 llvm::Value *BaseValue,
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00002763 const ObjCIvarDecl *Ivar,
2764 unsigned CVRQualifiers) {
Chris Lattner26f074b2009-04-17 17:44:48 +00002765 return CGM.getObjCRuntime().EmitObjCValueForIvar(*this, ObjectTy, BaseValue,
Daniel Dunbar525c9b72009-04-21 01:19:28 +00002766 Ivar, CVRQualifiers);
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00002767}
2768
2769LValue CodeGenFunction::EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E) {
Anders Carlsson29b7e502008-08-25 01:53:23 +00002770 // FIXME: A lot of the code below could be shared with EmitMemberExpr.
2771 llvm::Value *BaseValue = 0;
2772 const Expr *BaseExpr = E->getBase();
John McCall0953e762009-09-24 19:53:00 +00002773 Qualifiers BaseQuals;
Fariborz Jahanian45012a72009-02-03 00:09:52 +00002774 QualType ObjectTy;
Anders Carlsson29b7e502008-08-25 01:53:23 +00002775 if (E->isArrow()) {
2776 BaseValue = EmitScalarExpr(BaseExpr);
Steve Naroff14108da2009-07-10 23:34:53 +00002777 ObjectTy = BaseExpr->getType()->getPointeeType();
John McCall0953e762009-09-24 19:53:00 +00002778 BaseQuals = ObjectTy.getQualifiers();
Anders Carlsson29b7e502008-08-25 01:53:23 +00002779 } else {
2780 LValue BaseLV = EmitLValue(BaseExpr);
2781 // FIXME: this isn't right for bitfields.
2782 BaseValue = BaseLV.getAddress();
Fariborz Jahanian45012a72009-02-03 00:09:52 +00002783 ObjectTy = BaseExpr->getType();
John McCall0953e762009-09-24 19:53:00 +00002784 BaseQuals = ObjectTy.getQualifiers();
Anders Carlsson29b7e502008-08-25 01:53:23 +00002785 }
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00002786
Fariborz Jahaniandbf3cfd2009-09-16 23:11:23 +00002787 LValue LV =
John McCall0953e762009-09-24 19:53:00 +00002788 EmitLValueForIvar(ObjectTy, BaseValue, E->getDecl(),
2789 BaseQuals.getCVRQualifiers());
Fariborz Jahaniandbf3cfd2009-09-16 23:11:23 +00002790 setObjCGCLValueClass(getContext(), E, LV);
2791 return LV;
Chris Lattner391d77a2008-03-30 23:03:07 +00002792}
2793
Chris Lattner65459942009-04-25 19:35:26 +00002794LValue CodeGenFunction::EmitStmtExprLValue(const StmtExpr *E) {
Chris Lattner65459942009-04-25 19:35:26 +00002795 // Can only get l-value for message expression returning aggregate type
2796 RValue RV = EmitAnyExprToTemp(E);
Daniel Dunbar9f553f52010-08-21 03:08:16 +00002797 return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
Chris Lattner65459942009-04-25 19:35:26 +00002798}
2799
Anders Carlsson31777a22009-12-24 19:08:58 +00002800RValue CodeGenFunction::EmitCall(QualType CalleeType, llvm::Value *Callee,
Anders Carlssond2490a92009-12-24 20:40:36 +00002801 ReturnValueSlot ReturnValue,
Anders Carlsson98647712009-05-27 01:22:39 +00002802 CallExpr::const_arg_iterator ArgBeg,
2803 CallExpr::const_arg_iterator ArgEnd,
2804 const Decl *TargetDecl) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +00002805 // Get the actual function type. The callee type will always be a pointer to
2806 // function type or a block pointer type.
2807 assert(CalleeType->isFunctionPointerType() &&
Anders Carlsson8ac67a72009-04-07 18:53:02 +00002808 "Call must have function pointer type!");
2809
John McCall00a1ad92009-10-23 08:22:42 +00002810 CalleeType = getContext().getCanonicalType(CalleeType);
2811
John McCall04a67a62010-02-05 21:31:56 +00002812 const FunctionType *FnType
2813 = cast<FunctionType>(cast<PointerType>(CalleeType)->getPointeeType());
Daniel Dunbar19cd87e2008-08-30 03:02:31 +00002814
2815 CallArgList Args;
John McCall00a1ad92009-10-23 08:22:42 +00002816 EmitCallArgs(Args, dyn_cast<FunctionProtoType>(FnType), ArgBeg, ArgEnd);
Daniel Dunbar19cd87e2008-08-30 03:02:31 +00002817
John McCallde5d3c72012-02-17 03:33:10 +00002818 const CGFunctionInfo &FnInfo =
John McCall0f3d0972012-07-07 06:41:13 +00002819 CGM.getTypes().arrangeFreeFunctionCall(Args, FnType);
John McCall01f151e2011-09-21 08:08:30 +00002820
2821 // C99 6.5.2.2p6:
2822 // If the expression that denotes the called function has a type
2823 // that does not include a prototype, [the default argument
2824 // promotions are performed]. If the number of arguments does not
2825 // equal the number of parameters, the behavior is undefined. If
2826 // the function is defined with a type that includes a prototype,
2827 // and either the prototype ends with an ellipsis (, ...) or the
2828 // types of the arguments after promotion are not compatible with
2829 // the types of the parameters, the behavior is undefined. If the
2830 // function is defined with a type that does not include a
2831 // prototype, and the types of the arguments after promotion are
2832 // not compatible with those of the parameters after promotion,
2833 // the behavior is undefined [except in some trivial cases].
2834 // That is, in the general case, we should assume that a call
2835 // through an unprototyped function type works like a *non-variadic*
2836 // call. The way we make this work is to cast to the exact type
2837 // of the promoted arguments.
John McCallde5d3c72012-02-17 03:33:10 +00002838 if (isa<FunctionNoProtoType>(FnType) && !FnInfo.isVariadic()) {
2839 llvm::Type *CalleeTy = getTypes().GetFunctionType(FnInfo);
John McCall01f151e2011-09-21 08:08:30 +00002840 CalleeTy = CalleeTy->getPointerTo();
2841 Callee = Builder.CreateBitCast(Callee, CalleeTy, "callee.knr.cast");
2842 }
2843
2844 return EmitCall(FnInfo, Callee, ReturnValue, Args, TargetDecl);
Daniel Dunbar8f2926b2008-08-23 03:46:30 +00002845}
Fariborz Jahanian8bfd31f2009-10-22 22:57:31 +00002846
Chris Lattnereb99b012009-10-28 17:39:19 +00002847LValue CodeGenFunction::
2848EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E) {
Eli Friedman1c5c1a02009-11-18 05:01:17 +00002849 llvm::Value *BaseV;
John McCall2de56d12010-08-25 11:45:40 +00002850 if (E->getOpcode() == BO_PtrMemI)
Eli Friedman1c5c1a02009-11-18 05:01:17 +00002851 BaseV = EmitScalarExpr(E->getLHS());
2852 else
2853 BaseV = EmitLValue(E->getLHS()).getAddress();
Chris Lattnereb99b012009-10-28 17:39:19 +00002854
John McCall6c2ab1d2010-08-31 21:07:20 +00002855 llvm::Value *OffsetV = EmitScalarExpr(E->getRHS());
2856
2857 const MemberPointerType *MPT
2858 = E->getRHS()->getType()->getAs<MemberPointerType>();
2859
2860 llvm::Value *AddV =
2861 CGM.getCXXABI().EmitMemberDataPointerAddress(*this, BaseV, OffsetV, MPT);
2862
2863 return MakeAddrLValue(AddV, MPT->getPointeeType());
Fariborz Jahanian8bfd31f2009-10-22 22:57:31 +00002864}
Eli Friedman276b0612011-10-11 02:20:01 +00002865
2866static void
2867EmitAtomicOp(CodeGenFunction &CGF, AtomicExpr *E, llvm::Value *Dest,
2868 llvm::Value *Ptr, llvm::Value *Val1, llvm::Value *Val2,
2869 uint64_t Size, unsigned Align, llvm::AtomicOrdering Order) {
Richard Smithff34d402012-04-12 05:08:17 +00002870 llvm::AtomicRMWInst::BinOp Op = llvm::AtomicRMWInst::Add;
2871 llvm::Instruction::BinaryOps PostOp = (llvm::Instruction::BinaryOps)0;
2872
2873 switch (E->getOp()) {
2874 case AtomicExpr::AO__c11_atomic_init:
2875 llvm_unreachable("Already handled!");
2876
2877 case AtomicExpr::AO__c11_atomic_compare_exchange_strong:
2878 case AtomicExpr::AO__c11_atomic_compare_exchange_weak:
2879 case AtomicExpr::AO__atomic_compare_exchange:
2880 case AtomicExpr::AO__atomic_compare_exchange_n: {
Eli Friedman276b0612011-10-11 02:20:01 +00002881 // Note that cmpxchg only supports specifying one ordering and
2882 // doesn't support weak cmpxchg, at least at the moment.
2883 llvm::LoadInst *LoadVal1 = CGF.Builder.CreateLoad(Val1);
2884 LoadVal1->setAlignment(Align);
2885 llvm::LoadInst *LoadVal2 = CGF.Builder.CreateLoad(Val2);
2886 LoadVal2->setAlignment(Align);
2887 llvm::AtomicCmpXchgInst *CXI =
2888 CGF.Builder.CreateAtomicCmpXchg(Ptr, LoadVal1, LoadVal2, Order);
2889 CXI->setVolatile(E->isVolatile());
2890 llvm::StoreInst *StoreVal1 = CGF.Builder.CreateStore(CXI, Val1);
2891 StoreVal1->setAlignment(Align);
2892 llvm::Value *Cmp = CGF.Builder.CreateICmpEQ(CXI, LoadVal1);
2893 CGF.EmitStoreOfScalar(Cmp, CGF.MakeAddrLValue(Dest, E->getType()));
2894 return;
2895 }
2896
Richard Smithff34d402012-04-12 05:08:17 +00002897 case AtomicExpr::AO__c11_atomic_load:
2898 case AtomicExpr::AO__atomic_load_n:
2899 case AtomicExpr::AO__atomic_load: {
Eli Friedman276b0612011-10-11 02:20:01 +00002900 llvm::LoadInst *Load = CGF.Builder.CreateLoad(Ptr);
2901 Load->setAtomic(Order);
2902 Load->setAlignment(Size);
2903 Load->setVolatile(E->isVolatile());
2904 llvm::StoreInst *StoreDest = CGF.Builder.CreateStore(Load, Dest);
2905 StoreDest->setAlignment(Align);
2906 return;
2907 }
2908
Richard Smithff34d402012-04-12 05:08:17 +00002909 case AtomicExpr::AO__c11_atomic_store:
2910 case AtomicExpr::AO__atomic_store:
2911 case AtomicExpr::AO__atomic_store_n: {
Eli Friedman276b0612011-10-11 02:20:01 +00002912 assert(!Dest && "Store does not return a value");
2913 llvm::LoadInst *LoadVal1 = CGF.Builder.CreateLoad(Val1);
2914 LoadVal1->setAlignment(Align);
2915 llvm::StoreInst *Store = CGF.Builder.CreateStore(LoadVal1, Ptr);
2916 Store->setAtomic(Order);
2917 Store->setAlignment(Size);
2918 Store->setVolatile(E->isVolatile());
2919 return;
2920 }
2921
Richard Smithff34d402012-04-12 05:08:17 +00002922 case AtomicExpr::AO__c11_atomic_exchange:
2923 case AtomicExpr::AO__atomic_exchange_n:
2924 case AtomicExpr::AO__atomic_exchange:
2925 Op = llvm::AtomicRMWInst::Xchg;
2926 break;
2927
2928 case AtomicExpr::AO__atomic_add_fetch:
2929 PostOp = llvm::Instruction::Add;
2930 // Fall through.
2931 case AtomicExpr::AO__c11_atomic_fetch_add:
2932 case AtomicExpr::AO__atomic_fetch_add:
2933 Op = llvm::AtomicRMWInst::Add;
2934 break;
2935
2936 case AtomicExpr::AO__atomic_sub_fetch:
2937 PostOp = llvm::Instruction::Sub;
2938 // Fall through.
2939 case AtomicExpr::AO__c11_atomic_fetch_sub:
2940 case AtomicExpr::AO__atomic_fetch_sub:
2941 Op = llvm::AtomicRMWInst::Sub;
2942 break;
2943
2944 case AtomicExpr::AO__atomic_and_fetch:
2945 PostOp = llvm::Instruction::And;
2946 // Fall through.
2947 case AtomicExpr::AO__c11_atomic_fetch_and:
2948 case AtomicExpr::AO__atomic_fetch_and:
2949 Op = llvm::AtomicRMWInst::And;
2950 break;
2951
2952 case AtomicExpr::AO__atomic_or_fetch:
2953 PostOp = llvm::Instruction::Or;
2954 // Fall through.
2955 case AtomicExpr::AO__c11_atomic_fetch_or:
2956 case AtomicExpr::AO__atomic_fetch_or:
2957 Op = llvm::AtomicRMWInst::Or;
2958 break;
2959
2960 case AtomicExpr::AO__atomic_xor_fetch:
2961 PostOp = llvm::Instruction::Xor;
2962 // Fall through.
2963 case AtomicExpr::AO__c11_atomic_fetch_xor:
2964 case AtomicExpr::AO__atomic_fetch_xor:
2965 Op = llvm::AtomicRMWInst::Xor;
2966 break;
Richard Smith51b92402012-04-13 06:31:38 +00002967
2968 case AtomicExpr::AO__atomic_nand_fetch:
2969 PostOp = llvm::Instruction::And;
2970 // Fall through.
2971 case AtomicExpr::AO__atomic_fetch_nand:
2972 Op = llvm::AtomicRMWInst::Nand;
2973 break;
Eli Friedman276b0612011-10-11 02:20:01 +00002974 }
Richard Smithff34d402012-04-12 05:08:17 +00002975
Eli Friedman276b0612011-10-11 02:20:01 +00002976 llvm::LoadInst *LoadVal1 = CGF.Builder.CreateLoad(Val1);
2977 LoadVal1->setAlignment(Align);
2978 llvm::AtomicRMWInst *RMWI =
2979 CGF.Builder.CreateAtomicRMW(Op, Ptr, LoadVal1, Order);
2980 RMWI->setVolatile(E->isVolatile());
Richard Smithff34d402012-04-12 05:08:17 +00002981
2982 // For __atomic_*_fetch operations, perform the operation again to
2983 // determine the value which was written.
2984 llvm::Value *Result = RMWI;
2985 if (PostOp)
2986 Result = CGF.Builder.CreateBinOp(PostOp, RMWI, LoadVal1);
Richard Smith51b92402012-04-13 06:31:38 +00002987 if (E->getOp() == AtomicExpr::AO__atomic_nand_fetch)
2988 Result = CGF.Builder.CreateNot(Result);
Richard Smithff34d402012-04-12 05:08:17 +00002989 llvm::StoreInst *StoreDest = CGF.Builder.CreateStore(Result, Dest);
Eli Friedman276b0612011-10-11 02:20:01 +00002990 StoreDest->setAlignment(Align);
2991}
2992
2993// This function emits any expression (scalar, complex, or aggregate)
2994// into a temporary alloca.
2995static llvm::Value *
2996EmitValToTemp(CodeGenFunction &CGF, Expr *E) {
2997 llvm::Value *DeclPtr = CGF.CreateMemTemp(E->getType(), ".atomictmp");
Chad Rosier649b4a12012-03-29 17:37:10 +00002998 CGF.EmitAnyExprToMem(E, DeclPtr, E->getType().getQualifiers(),
2999 /*Init*/ true);
Eli Friedman276b0612011-10-11 02:20:01 +00003000 return DeclPtr;
3001}
3002
3003static RValue ConvertTempToRValue(CodeGenFunction &CGF, QualType Ty,
3004 llvm::Value *Dest) {
3005 if (Ty->isAnyComplexType())
3006 return RValue::getComplex(CGF.LoadComplexFromAddr(Dest, false));
3007 if (CGF.hasAggregateLLVMType(Ty))
3008 return RValue::getAggregate(Dest);
3009 return RValue::get(CGF.EmitLoadOfScalar(CGF.MakeAddrLValue(Dest, Ty)));
3010}
3011
3012RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E, llvm::Value *Dest) {
3013 QualType AtomicTy = E->getPtr()->getType()->getPointeeType();
Richard Smithff34d402012-04-12 05:08:17 +00003014 QualType MemTy = AtomicTy;
3015 if (const AtomicType *AT = AtomicTy->getAs<AtomicType>())
3016 MemTy = AT->getValueType();
Eli Friedman276b0612011-10-11 02:20:01 +00003017 CharUnits sizeChars = getContext().getTypeSizeInChars(AtomicTy);
3018 uint64_t Size = sizeChars.getQuantity();
3019 CharUnits alignChars = getContext().getTypeAlignInChars(AtomicTy);
3020 unsigned Align = alignChars.getQuantity();
Eli Friedman2be46072011-10-14 20:59:01 +00003021 unsigned MaxInlineWidth =
3022 getContext().getTargetInfo().getMaxAtomicInlineWidth();
3023 bool UseLibcall = (Size != Align || Size > MaxInlineWidth);
Eli Friedman276b0612011-10-11 02:20:01 +00003024
David Chisnall7a7ee302012-01-16 17:27:18 +00003025
3026
Eli Friedman276b0612011-10-11 02:20:01 +00003027 llvm::Value *Ptr, *Order, *OrderFail = 0, *Val1 = 0, *Val2 = 0;
3028 Ptr = EmitScalarExpr(E->getPtr());
David Chisnall7a7ee302012-01-16 17:27:18 +00003029
Richard Smithff34d402012-04-12 05:08:17 +00003030 if (E->getOp() == AtomicExpr::AO__c11_atomic_init) {
David Chisnall7a7ee302012-01-16 17:27:18 +00003031 assert(!Dest && "Init does not return a value");
David Chisnall5d70cfd2012-04-11 17:24:05 +00003032 if (!hasAggregateLLVMType(E->getVal1()->getType())) {
Douglas Gregor47bfcca2012-04-12 20:42:30 +00003033 QualType PointeeType
3034 = E->getPtr()->getType()->getAs<PointerType>()->getPointeeType();
3035 EmitScalarInit(EmitScalarExpr(E->getVal1()),
3036 LValue::MakeAddr(Ptr, PointeeType, alignChars,
3037 getContext()));
David Chisnall5d70cfd2012-04-11 17:24:05 +00003038 } else if (E->getType()->isAnyComplexType()) {
3039 EmitComplexExprIntoAddr(E->getVal1(), Ptr, E->isVolatile());
3040 } else {
3041 AggValueSlot Slot = AggValueSlot::forAddr(Ptr, alignChars,
3042 AtomicTy.getQualifiers(),
3043 AggValueSlot::IsNotDestructed,
3044 AggValueSlot::DoesNotNeedGCBarriers,
3045 AggValueSlot::IsNotAliased);
3046 EmitAggExpr(E->getVal1(), Slot);
3047 }
David Chisnall7a7ee302012-01-16 17:27:18 +00003048 return RValue::get(0);
3049 }
3050
Eli Friedman276b0612011-10-11 02:20:01 +00003051 Order = EmitScalarExpr(E->getOrder());
Richard Smithff34d402012-04-12 05:08:17 +00003052
3053 switch (E->getOp()) {
3054 case AtomicExpr::AO__c11_atomic_init:
3055 llvm_unreachable("Already handled!");
3056
3057 case AtomicExpr::AO__c11_atomic_load:
3058 case AtomicExpr::AO__atomic_load_n:
3059 break;
3060
3061 case AtomicExpr::AO__atomic_load:
3062 Dest = EmitScalarExpr(E->getVal1());
3063 break;
3064
3065 case AtomicExpr::AO__atomic_store:
Eli Friedman276b0612011-10-11 02:20:01 +00003066 Val1 = EmitScalarExpr(E->getVal1());
Richard Smithff34d402012-04-12 05:08:17 +00003067 break;
3068
3069 case AtomicExpr::AO__atomic_exchange:
3070 Val1 = EmitScalarExpr(E->getVal1());
3071 Dest = EmitScalarExpr(E->getVal2());
3072 break;
3073
3074 case AtomicExpr::AO__c11_atomic_compare_exchange_strong:
3075 case AtomicExpr::AO__c11_atomic_compare_exchange_weak:
3076 case AtomicExpr::AO__atomic_compare_exchange_n:
3077 case AtomicExpr::AO__atomic_compare_exchange:
3078 Val1 = EmitScalarExpr(E->getVal1());
3079 if (E->getOp() == AtomicExpr::AO__atomic_compare_exchange)
3080 Val2 = EmitScalarExpr(E->getVal2());
3081 else
3082 Val2 = EmitValToTemp(*this, E->getVal2());
Eli Friedman276b0612011-10-11 02:20:01 +00003083 OrderFail = EmitScalarExpr(E->getOrderFail());
Richard Smithff34d402012-04-12 05:08:17 +00003084 // Evaluate and discard the 'weak' argument.
3085 if (E->getNumSubExprs() == 6)
3086 EmitScalarExpr(E->getWeak());
3087 break;
3088
3089 case AtomicExpr::AO__c11_atomic_fetch_add:
3090 case AtomicExpr::AO__c11_atomic_fetch_sub:
Richard Smithff34d402012-04-12 05:08:17 +00003091 if (MemTy->isPointerType()) {
3092 // For pointer arithmetic, we're required to do a bit of math:
3093 // adding 1 to an int* is not the same as adding 1 to a uintptr_t.
Richard Smith2c39d712012-04-13 00:45:38 +00003094 // ... but only for the C11 builtins. The GNU builtins expect the
3095 // user to multiply by sizeof(T).
Richard Smithff34d402012-04-12 05:08:17 +00003096 QualType Val1Ty = E->getVal1()->getType();
3097 llvm::Value *Val1Scalar = EmitScalarExpr(E->getVal1());
3098 CharUnits PointeeIncAmt =
3099 getContext().getTypeSizeInChars(MemTy->getPointeeType());
3100 Val1Scalar = Builder.CreateMul(Val1Scalar, CGM.getSize(PointeeIncAmt));
3101 Val1 = CreateMemTemp(Val1Ty, ".atomictmp");
3102 EmitStoreOfScalar(Val1Scalar, MakeAddrLValue(Val1, Val1Ty));
3103 break;
3104 }
3105 // Fall through.
Richard Smith2c39d712012-04-13 00:45:38 +00003106 case AtomicExpr::AO__atomic_fetch_add:
3107 case AtomicExpr::AO__atomic_fetch_sub:
3108 case AtomicExpr::AO__atomic_add_fetch:
3109 case AtomicExpr::AO__atomic_sub_fetch:
Richard Smithff34d402012-04-12 05:08:17 +00003110 case AtomicExpr::AO__c11_atomic_store:
3111 case AtomicExpr::AO__c11_atomic_exchange:
3112 case AtomicExpr::AO__atomic_store_n:
3113 case AtomicExpr::AO__atomic_exchange_n:
3114 case AtomicExpr::AO__c11_atomic_fetch_and:
3115 case AtomicExpr::AO__c11_atomic_fetch_or:
3116 case AtomicExpr::AO__c11_atomic_fetch_xor:
3117 case AtomicExpr::AO__atomic_fetch_and:
3118 case AtomicExpr::AO__atomic_fetch_or:
3119 case AtomicExpr::AO__atomic_fetch_xor:
Richard Smith51b92402012-04-13 06:31:38 +00003120 case AtomicExpr::AO__atomic_fetch_nand:
Richard Smithff34d402012-04-12 05:08:17 +00003121 case AtomicExpr::AO__atomic_and_fetch:
3122 case AtomicExpr::AO__atomic_or_fetch:
3123 case AtomicExpr::AO__atomic_xor_fetch:
Richard Smith51b92402012-04-13 06:31:38 +00003124 case AtomicExpr::AO__atomic_nand_fetch:
Eli Friedman276b0612011-10-11 02:20:01 +00003125 Val1 = EmitValToTemp(*this, E->getVal1());
Richard Smithff34d402012-04-12 05:08:17 +00003126 break;
Eli Friedman276b0612011-10-11 02:20:01 +00003127 }
3128
Richard Smithff34d402012-04-12 05:08:17 +00003129 if (!E->getType()->isVoidType() && !Dest)
Eli Friedman276b0612011-10-11 02:20:01 +00003130 Dest = CreateMemTemp(E->getType(), ".atomicdst");
3131
David Chisnall3a7d69b2012-03-29 18:01:11 +00003132 // Use a library call. See: http://gcc.gnu.org/wiki/Atomic/GCCMM/LIbrary .
Eli Friedman276b0612011-10-11 02:20:01 +00003133 if (UseLibcall) {
David Chisnall3a7d69b2012-03-29 18:01:11 +00003134
3135 llvm::SmallVector<QualType, 5> Params;
3136 CallArgList Args;
3137 // Size is always the first parameter
3138 Args.add(RValue::get(llvm::ConstantInt::get(SizeTy, Size)),
3139 getContext().getSizeType());
3140 // Atomic address is always the second parameter
3141 Args.add(RValue::get(EmitCastToVoidPtr(Ptr)),
3142 getContext().VoidPtrTy);
3143
Eli Friedman276b0612011-10-11 02:20:01 +00003144 const char* LibCallName;
David Chisnall3a7d69b2012-03-29 18:01:11 +00003145 QualType RetTy = getContext().VoidTy;
Eli Friedman276b0612011-10-11 02:20:01 +00003146 switch (E->getOp()) {
David Chisnall3a7d69b2012-03-29 18:01:11 +00003147 // There is only one libcall for compare an exchange, because there is no
3148 // optimisation benefit possible from a libcall version of a weak compare
3149 // and exchange.
3150 // bool __atomic_compare_exchange(size_t size, void *obj, void *expected,
Richard Smithff34d402012-04-12 05:08:17 +00003151 // void *desired, int success, int failure)
3152 case AtomicExpr::AO__c11_atomic_compare_exchange_weak:
3153 case AtomicExpr::AO__c11_atomic_compare_exchange_strong:
3154 case AtomicExpr::AO__atomic_compare_exchange:
3155 case AtomicExpr::AO__atomic_compare_exchange_n:
David Chisnall3a7d69b2012-03-29 18:01:11 +00003156 LibCallName = "__atomic_compare_exchange";
3157 RetTy = getContext().BoolTy;
3158 Args.add(RValue::get(EmitCastToVoidPtr(Val1)),
3159 getContext().VoidPtrTy);
3160 Args.add(RValue::get(EmitCastToVoidPtr(Val2)),
3161 getContext().VoidPtrTy);
3162 Args.add(RValue::get(Order),
3163 getContext().IntTy);
3164 Order = OrderFail;
3165 break;
3166 // void __atomic_exchange(size_t size, void *mem, void *val, void *return,
3167 // int order)
Richard Smithff34d402012-04-12 05:08:17 +00003168 case AtomicExpr::AO__c11_atomic_exchange:
3169 case AtomicExpr::AO__atomic_exchange_n:
3170 case AtomicExpr::AO__atomic_exchange:
David Chisnall3a7d69b2012-03-29 18:01:11 +00003171 LibCallName = "__atomic_exchange";
3172 Args.add(RValue::get(EmitCastToVoidPtr(Val1)),
3173 getContext().VoidPtrTy);
3174 Args.add(RValue::get(EmitCastToVoidPtr(Dest)),
3175 getContext().VoidPtrTy);
3176 break;
3177 // void __atomic_store(size_t size, void *mem, void *val, int order)
Richard Smithff34d402012-04-12 05:08:17 +00003178 case AtomicExpr::AO__c11_atomic_store:
3179 case AtomicExpr::AO__atomic_store:
3180 case AtomicExpr::AO__atomic_store_n:
David Chisnall3a7d69b2012-03-29 18:01:11 +00003181 LibCallName = "__atomic_store";
3182 Args.add(RValue::get(EmitCastToVoidPtr(Val1)),
3183 getContext().VoidPtrTy);
3184 break;
3185 // void __atomic_load(size_t size, void *mem, void *return, int order)
Richard Smithff34d402012-04-12 05:08:17 +00003186 case AtomicExpr::AO__c11_atomic_load:
3187 case AtomicExpr::AO__atomic_load:
3188 case AtomicExpr::AO__atomic_load_n:
David Chisnall3a7d69b2012-03-29 18:01:11 +00003189 LibCallName = "__atomic_load";
3190 Args.add(RValue::get(EmitCastToVoidPtr(Dest)),
3191 getContext().VoidPtrTy);
3192 break;
3193#if 0
3194 // These are only defined for 1-16 byte integers. It is not clear what
3195 // their semantics would be on anything else...
Eli Friedman276b0612011-10-11 02:20:01 +00003196 case AtomicExpr::Add: LibCallName = "__atomic_fetch_add_generic"; break;
3197 case AtomicExpr::Sub: LibCallName = "__atomic_fetch_sub_generic"; break;
3198 case AtomicExpr::And: LibCallName = "__atomic_fetch_and_generic"; break;
3199 case AtomicExpr::Or: LibCallName = "__atomic_fetch_or_generic"; break;
3200 case AtomicExpr::Xor: LibCallName = "__atomic_fetch_xor_generic"; break;
David Chisnall3a7d69b2012-03-29 18:01:11 +00003201#endif
3202 default: return EmitUnsupportedRValue(E, "atomic library call");
Eli Friedman276b0612011-10-11 02:20:01 +00003203 }
David Chisnall3a7d69b2012-03-29 18:01:11 +00003204 // order is always the last parameter
3205 Args.add(RValue::get(Order),
3206 getContext().IntTy);
3207
Eli Friedman276b0612011-10-11 02:20:01 +00003208 const CGFunctionInfo &FuncInfo =
John McCall0f3d0972012-07-07 06:41:13 +00003209 CGM.getTypes().arrangeFreeFunctionCall(RetTy, Args,
David Chisnall3a7d69b2012-03-29 18:01:11 +00003210 FunctionType::ExtInfo(), RequiredArgs::All);
3211 llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FuncInfo);
Eli Friedman276b0612011-10-11 02:20:01 +00003212 llvm::Constant *Func = CGM.CreateRuntimeFunction(FTy, LibCallName);
3213 RValue Res = EmitCall(FuncInfo, Func, ReturnValueSlot(), Args);
3214 if (E->isCmpXChg())
3215 return Res;
Richard Smithff34d402012-04-12 05:08:17 +00003216 if (E->getType()->isVoidType())
Eli Friedman276b0612011-10-11 02:20:01 +00003217 return RValue::get(0);
3218 return ConvertTempToRValue(*this, E->getType(), Dest);
3219 }
David Chisnall3a7d69b2012-03-29 18:01:11 +00003220
Eli Friedman276b0612011-10-11 02:20:01 +00003221 llvm::Type *IPtrTy =
3222 llvm::IntegerType::get(getLLVMContext(), Size * 8)->getPointerTo();
3223 llvm::Value *OrigDest = Dest;
3224 Ptr = Builder.CreateBitCast(Ptr, IPtrTy);
3225 if (Val1) Val1 = Builder.CreateBitCast(Val1, IPtrTy);
3226 if (Val2) Val2 = Builder.CreateBitCast(Val2, IPtrTy);
3227 if (Dest && !E->isCmpXChg()) Dest = Builder.CreateBitCast(Dest, IPtrTy);
3228
3229 if (isa<llvm::ConstantInt>(Order)) {
3230 int ord = cast<llvm::ConstantInt>(Order)->getZExtValue();
3231 switch (ord) {
3232 case 0: // memory_order_relaxed
3233 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3234 llvm::Monotonic);
3235 break;
3236 case 1: // memory_order_consume
3237 case 2: // memory_order_acquire
3238 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3239 llvm::Acquire);
3240 break;
3241 case 3: // memory_order_release
3242 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3243 llvm::Release);
3244 break;
3245 case 4: // memory_order_acq_rel
3246 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3247 llvm::AcquireRelease);
3248 break;
3249 case 5: // memory_order_seq_cst
3250 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3251 llvm::SequentiallyConsistent);
3252 break;
3253 default: // invalid order
3254 // We should not ever get here normally, but it's hard to
3255 // enforce that in general.
Richard Smithff34d402012-04-12 05:08:17 +00003256 break;
Eli Friedman276b0612011-10-11 02:20:01 +00003257 }
Richard Smithff34d402012-04-12 05:08:17 +00003258 if (E->getType()->isVoidType())
Eli Friedman276b0612011-10-11 02:20:01 +00003259 return RValue::get(0);
3260 return ConvertTempToRValue(*this, E->getType(), OrigDest);
3261 }
3262
3263 // Long case, when Order isn't obviously constant.
3264
Richard Smithff34d402012-04-12 05:08:17 +00003265 bool IsStore = E->getOp() == AtomicExpr::AO__c11_atomic_store ||
3266 E->getOp() == AtomicExpr::AO__atomic_store ||
3267 E->getOp() == AtomicExpr::AO__atomic_store_n;
3268 bool IsLoad = E->getOp() == AtomicExpr::AO__c11_atomic_load ||
3269 E->getOp() == AtomicExpr::AO__atomic_load ||
3270 E->getOp() == AtomicExpr::AO__atomic_load_n;
3271
Eli Friedman276b0612011-10-11 02:20:01 +00003272 // Create all the relevant BB's
Eli Friedman9e3c20b2011-10-11 20:00:47 +00003273 llvm::BasicBlock *MonotonicBB = 0, *AcquireBB = 0, *ReleaseBB = 0,
3274 *AcqRelBB = 0, *SeqCstBB = 0;
Eli Friedman276b0612011-10-11 02:20:01 +00003275 MonotonicBB = createBasicBlock("monotonic", CurFn);
Richard Smithff34d402012-04-12 05:08:17 +00003276 if (!IsStore)
Eli Friedman276b0612011-10-11 02:20:01 +00003277 AcquireBB = createBasicBlock("acquire", CurFn);
Richard Smithff34d402012-04-12 05:08:17 +00003278 if (!IsLoad)
Eli Friedman276b0612011-10-11 02:20:01 +00003279 ReleaseBB = createBasicBlock("release", CurFn);
Richard Smithff34d402012-04-12 05:08:17 +00003280 if (!IsLoad && !IsStore)
Eli Friedman276b0612011-10-11 02:20:01 +00003281 AcqRelBB = createBasicBlock("acqrel", CurFn);
3282 SeqCstBB = createBasicBlock("seqcst", CurFn);
3283 llvm::BasicBlock *ContBB = createBasicBlock("atomic.continue", CurFn);
3284
3285 // Create the switch for the split
3286 // MonotonicBB is arbitrarily chosen as the default case; in practice, this
3287 // doesn't matter unless someone is crazy enough to use something that
3288 // doesn't fold to a constant for the ordering.
3289 Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
3290 llvm::SwitchInst *SI = Builder.CreateSwitch(Order, MonotonicBB);
3291
3292 // Emit all the different atomics
3293 Builder.SetInsertPoint(MonotonicBB);
3294 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3295 llvm::Monotonic);
3296 Builder.CreateBr(ContBB);
Richard Smithff34d402012-04-12 05:08:17 +00003297 if (!IsStore) {
Eli Friedman276b0612011-10-11 02:20:01 +00003298 Builder.SetInsertPoint(AcquireBB);
3299 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3300 llvm::Acquire);
3301 Builder.CreateBr(ContBB);
3302 SI->addCase(Builder.getInt32(1), AcquireBB);
3303 SI->addCase(Builder.getInt32(2), AcquireBB);
3304 }
Richard Smithff34d402012-04-12 05:08:17 +00003305 if (!IsLoad) {
Eli Friedman276b0612011-10-11 02:20:01 +00003306 Builder.SetInsertPoint(ReleaseBB);
3307 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3308 llvm::Release);
3309 Builder.CreateBr(ContBB);
3310 SI->addCase(Builder.getInt32(3), ReleaseBB);
3311 }
Richard Smithff34d402012-04-12 05:08:17 +00003312 if (!IsLoad && !IsStore) {
Eli Friedman276b0612011-10-11 02:20:01 +00003313 Builder.SetInsertPoint(AcqRelBB);
3314 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3315 llvm::AcquireRelease);
3316 Builder.CreateBr(ContBB);
3317 SI->addCase(Builder.getInt32(4), AcqRelBB);
3318 }
3319 Builder.SetInsertPoint(SeqCstBB);
3320 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3321 llvm::SequentiallyConsistent);
3322 Builder.CreateBr(ContBB);
3323 SI->addCase(Builder.getInt32(5), SeqCstBB);
3324
3325 // Cleanup and return
3326 Builder.SetInsertPoint(ContBB);
Richard Smithff34d402012-04-12 05:08:17 +00003327 if (E->getType()->isVoidType())
Eli Friedman276b0612011-10-11 02:20:01 +00003328 return RValue::get(0);
3329 return ConvertTempToRValue(*this, E->getType(), OrigDest);
3330}
Peter Collingbournec5096cb2011-10-27 19:19:51 +00003331
Duncan Sands82500162012-04-10 08:23:07 +00003332void CodeGenFunction::SetFPAccuracy(llvm::Value *Val, float Accuracy) {
Peter Collingbournec5096cb2011-10-27 19:19:51 +00003333 assert(Val->getType()->isFPOrFPVectorTy());
Duncan Sands82500162012-04-10 08:23:07 +00003334 if (Accuracy == 0.0 || !isa<llvm::Instruction>(Val))
Peter Collingbournec5096cb2011-10-27 19:19:51 +00003335 return;
3336
Duncan Sands60c77072012-04-16 16:29:47 +00003337 llvm::MDBuilder MDHelper(getLLVMContext());
3338 llvm::MDNode *Node = MDHelper.createFPMath(Accuracy);
Peter Collingbournec5096cb2011-10-27 19:19:51 +00003339
Duncan Sands9bb1d342012-04-14 12:37:26 +00003340 cast<llvm::Instruction>(Val)->setMetadata(llvm::LLVMContext::MD_fpmath, Node);
Peter Collingbournec5096cb2011-10-27 19:19:51 +00003341}
John McCall4b9c2d22011-11-06 09:01:30 +00003342
3343namespace {
3344 struct LValueOrRValue {
3345 LValue LV;
3346 RValue RV;
3347 };
3348}
3349
3350static LValueOrRValue emitPseudoObjectExpr(CodeGenFunction &CGF,
3351 const PseudoObjectExpr *E,
3352 bool forLValue,
3353 AggValueSlot slot) {
3354 llvm::SmallVector<CodeGenFunction::OpaqueValueMappingData, 4> opaques;
3355
3356 // Find the result expression, if any.
3357 const Expr *resultExpr = E->getResultExpr();
3358 LValueOrRValue result;
3359
3360 for (PseudoObjectExpr::const_semantics_iterator
3361 i = E->semantics_begin(), e = E->semantics_end(); i != e; ++i) {
3362 const Expr *semantic = *i;
3363
3364 // If this semantic expression is an opaque value, bind it
3365 // to the result of its source expression.
3366 if (const OpaqueValueExpr *ov = dyn_cast<OpaqueValueExpr>(semantic)) {
3367
3368 // If this is the result expression, we may need to evaluate
3369 // directly into the slot.
3370 typedef CodeGenFunction::OpaqueValueMappingData OVMA;
3371 OVMA opaqueData;
3372 if (ov == resultExpr && ov->isRValue() && !forLValue &&
3373 CodeGenFunction::hasAggregateLLVMType(ov->getType()) &&
3374 !ov->getType()->isAnyComplexType()) {
3375 CGF.EmitAggExpr(ov->getSourceExpr(), slot);
3376
3377 LValue LV = CGF.MakeAddrLValue(slot.getAddr(), ov->getType());
3378 opaqueData = OVMA::bind(CGF, ov, LV);
3379 result.RV = slot.asRValue();
3380
3381 // Otherwise, emit as normal.
3382 } else {
3383 opaqueData = OVMA::bind(CGF, ov, ov->getSourceExpr());
3384
3385 // If this is the result, also evaluate the result now.
3386 if (ov == resultExpr) {
3387 if (forLValue)
3388 result.LV = CGF.EmitLValue(ov);
3389 else
3390 result.RV = CGF.EmitAnyExpr(ov, slot);
3391 }
3392 }
3393
3394 opaques.push_back(opaqueData);
3395
3396 // Otherwise, if the expression is the result, evaluate it
3397 // and remember the result.
3398 } else if (semantic == resultExpr) {
3399 if (forLValue)
3400 result.LV = CGF.EmitLValue(semantic);
3401 else
3402 result.RV = CGF.EmitAnyExpr(semantic, slot);
3403
3404 // Otherwise, evaluate the expression in an ignored context.
3405 } else {
3406 CGF.EmitIgnoredExpr(semantic);
3407 }
3408 }
3409
3410 // Unbind all the opaques now.
3411 for (unsigned i = 0, e = opaques.size(); i != e; ++i)
3412 opaques[i].unbind(CGF);
3413
3414 return result;
3415}
3416
3417RValue CodeGenFunction::EmitPseudoObjectRValue(const PseudoObjectExpr *E,
3418 AggValueSlot slot) {
3419 return emitPseudoObjectExpr(*this, E, false, slot).RV;
3420}
3421
3422LValue CodeGenFunction::EmitPseudoObjectLValue(const PseudoObjectExpr *E) {
3423 return emitPseudoObjectExpr(*this, E, true, AggValueSlot::ignored()).LV;
3424}