blob: d4e4c402b70abeb5176db57b4407176724f06833 [file] [log] [blame]
Chris Lattnere47e4402007-06-01 18:02:12 +00001//===--- CGExpr.cpp - Emit LLVM Code from Expressions ---------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner5b12ab82007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattnere47e4402007-06-01 18:02:12 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This contains code to emit Expr nodes as LLVM code.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CodeGenFunction.h"
Chris Lattnerb6984c42007-06-20 04:44:43 +000015#include "CodeGenModule.h"
Daniel Dunbar3d7c90b2008-09-08 21:33:45 +000016#include "CGCall.h"
John McCall5d865c322010-08-31 07:33:07 +000017#include "CGCXXABI.h"
Devang Pateld3a6b0f2011-03-04 18:54:42 +000018#include "CGDebugInfo.h"
Daniel Dunbar034299e2010-03-31 01:09:11 +000019#include "CGRecordLayout.h"
Daniel Dunbar89da6ad2008-08-13 00:59:25 +000020#include "CGObjCRuntime.h"
John McCallcbc038a2011-09-21 08:08:30 +000021#include "TargetInfo.h"
Daniel Dunbarad319a72008-08-11 05:00:27 +000022#include "clang/AST/ASTContext.h"
Daniel Dunbar6e8aa532008-08-11 05:35:13 +000023#include "clang/AST/DeclObjC.h"
Chandler Carruth85098242010-06-15 23:19:56 +000024#include "clang/Frontend/CodeGenOptions.h"
Nick Lewycky7c6c6cc2011-07-07 03:54:51 +000025#include "llvm/Intrinsics.h"
Peter Collingbourne95fd2ca2011-10-27 19:19:51 +000026#include "llvm/LLVMContext.h"
Duncan Sandsc720e782012-04-15 18:04:54 +000027#include "llvm/Support/MDBuilder.h"
Eli Friedmanf2442dc2008-05-17 20:03:47 +000028#include "llvm/Target/TargetData.h"
Chris Lattnere47e4402007-06-01 18:02:12 +000029using namespace clang;
30using namespace CodeGen;
31
Chris Lattnerd7f58862007-06-02 05:24:33 +000032//===--------------------------------------------------------------------===//
Chris Lattnerf0106d22007-06-02 19:33:17 +000033// Miscellaneous Helper Methods
34//===--------------------------------------------------------------------===//
35
John McCallad7c5c12011-02-08 08:22:06 +000036llvm::Value *CodeGenFunction::EmitCastToVoidPtr(llvm::Value *value) {
37 unsigned addressSpace =
38 cast<llvm::PointerType>(value->getType())->getAddressSpace();
39
Chris Lattner2192fe52011-07-18 04:24:23 +000040 llvm::PointerType *destType = Int8PtrTy;
John McCallad7c5c12011-02-08 08:22:06 +000041 if (addressSpace)
42 destType = llvm::Type::getInt8PtrTy(getLLVMContext(), addressSpace);
43
44 if (value->getType() == destType) return value;
45 return Builder.CreateBitCast(value, destType);
46}
47
Chris Lattnere9a64532007-06-22 21:44:33 +000048/// CreateTempAlloca - This creates a alloca and inserts it into the entry
49/// block.
Chris Lattner2192fe52011-07-18 04:24:23 +000050llvm::AllocaInst *CodeGenFunction::CreateTempAlloca(llvm::Type *Ty,
Chris Lattner0e62c1c2011-07-23 10:55:15 +000051 const Twine &Name) {
Chris Lattner47640222009-03-22 00:24:14 +000052 if (!Builder.isNamePreserving())
Daniel Dunbarb5aacc22009-10-19 01:21:05 +000053 return new llvm::AllocaInst(Ty, 0, "", AllocaInsertPt);
Devang Pateldac79de2009-10-12 22:29:02 +000054 return new llvm::AllocaInst(Ty, 0, Name, AllocaInsertPt);
Chris Lattnere9a64532007-06-22 21:44:33 +000055}
Chris Lattner8394d792007-06-05 20:53:16 +000056
John McCall2e6567a2010-04-22 01:10:34 +000057void CodeGenFunction::InitTempAlloca(llvm::AllocaInst *Var,
58 llvm::Value *Init) {
59 llvm::StoreInst *Store = new llvm::StoreInst(Init, Var);
60 llvm::BasicBlock *Block = AllocaInsertPt->getParent();
61 Block->getInstList().insertAfter(&*AllocaInsertPt, Store);
62}
63
Chris Lattnerc401de92010-07-05 20:21:00 +000064llvm::AllocaInst *CodeGenFunction::CreateIRTemp(QualType Ty,
Chris Lattner0e62c1c2011-07-23 10:55:15 +000065 const Twine &Name) {
Daniel Dunbard0049182010-02-16 19:44:13 +000066 llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertType(Ty), Name);
67 // FIXME: Should we prefer the preferred type alignment here?
68 CharUnits Align = getContext().getTypeAlignInChars(Ty);
69 Alloc->setAlignment(Align.getQuantity());
70 return Alloc;
71}
72
Chris Lattnerc401de92010-07-05 20:21:00 +000073llvm::AllocaInst *CodeGenFunction::CreateMemTemp(QualType Ty,
Chris Lattner0e62c1c2011-07-23 10:55:15 +000074 const Twine &Name) {
Daniel Dunbara7566f12010-02-09 02:48:28 +000075 llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertTypeForMem(Ty), Name);
76 // FIXME: Should we prefer the preferred type alignment here?
77 CharUnits Align = getContext().getTypeAlignInChars(Ty);
78 Alloc->setAlignment(Align.getQuantity());
79 return Alloc;
80}
81
Chris Lattner8394d792007-06-05 20:53:16 +000082/// EvaluateExprAsBool - Perform the usual unary conversions on the specified
83/// expression and compare the result against zero, returning an Int1Ty value.
Chris Lattner23b7eb62007-06-15 23:05:46 +000084llvm::Value *CodeGenFunction::EvaluateExprAsBool(const Expr *E) {
John McCall7a9aac22010-08-23 01:21:21 +000085 if (const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>()) {
John McCalla1dee5302010-08-22 10:59:02 +000086 llvm::Value *MemPtr = EmitScalarExpr(E);
John McCallad7c5c12011-02-08 08:22:06 +000087 return CGM.getCXXABI().EmitMemberPointerIsNotNull(*this, MemPtr, MPT);
Eli Friedman68396b12009-12-11 09:26:29 +000088 }
John McCall7a9aac22010-08-23 01:21:21 +000089
90 QualType BoolTy = getContext().BoolTy;
Chris Lattnerf3bc75a2008-04-04 16:54:41 +000091 if (!E->getType()->isAnyComplexType())
Chris Lattner268fcce2007-08-26 16:46:58 +000092 return EmitScalarConversion(EmitScalarExpr(E), E->getType(), BoolTy);
Chris Lattner8394d792007-06-05 20:53:16 +000093
Chris Lattner268fcce2007-08-26 16:46:58 +000094 return EmitComplexToScalarConversion(EmitComplexExpr(E), E->getType(),BoolTy);
Chris Lattnerf0106d22007-06-02 19:33:17 +000095}
96
John McCalla2342eb2010-12-05 02:00:02 +000097/// EmitIgnoredExpr - Emit code to compute the specified expression,
98/// ignoring the result.
99void CodeGenFunction::EmitIgnoredExpr(const Expr *E) {
100 if (E->isRValue())
101 return (void) EmitAnyExpr(E, AggValueSlot::ignored(), true);
102
103 // Just emit it as an l-value and drop the result.
104 EmitLValue(E);
105}
106
John McCall7a626f62010-09-15 10:14:12 +0000107/// EmitAnyExpr - Emit code to compute the specified expression which
108/// can have any type. The result is returned as an RValue struct.
109/// If this is an aggregate expression, AggSlot indicates where the
Mike Stump4a3999f2009-09-09 13:00:44 +0000110/// result should be returned.
John McCall7a626f62010-09-15 10:14:12 +0000111RValue CodeGenFunction::EmitAnyExpr(const Expr *E, AggValueSlot AggSlot,
112 bool IgnoreResult) {
Chris Lattner4647a212007-08-31 22:49:20 +0000113 if (!hasAggregateLLVMType(E->getType()))
Mike Stumpdf0fe272009-05-29 15:46:01 +0000114 return RValue::get(EmitScalarExpr(E, IgnoreResult));
Chris Lattnerf3bc75a2008-04-04 16:54:41 +0000115 else if (E->getType()->isAnyComplexType())
John McCall07bb1962010-11-16 10:08:07 +0000116 return RValue::getComplex(EmitComplexExpr(E, IgnoreResult, IgnoreResult));
Mike Stump4a3999f2009-09-09 13:00:44 +0000117
John McCall7a626f62010-09-15 10:14:12 +0000118 EmitAggExpr(E, AggSlot, IgnoreResult);
119 return AggSlot.asRValue();
Chris Lattner4647a212007-08-31 22:49:20 +0000120}
121
Mike Stump4a3999f2009-09-09 13:00:44 +0000122/// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result will
123/// always be accessible even if no aggregate location is provided.
John McCall7a626f62010-09-15 10:14:12 +0000124RValue CodeGenFunction::EmitAnyExprToTemp(const Expr *E) {
125 AggValueSlot AggSlot = AggValueSlot::ignored();
Mike Stump4a3999f2009-09-09 13:00:44 +0000126
127 if (hasAggregateLLVMType(E->getType()) &&
Daniel Dunbar41cf9de2008-09-09 01:06:48 +0000128 !E->getType()->isAnyComplexType())
John McCall7a626f62010-09-15 10:14:12 +0000129 AggSlot = CreateAggTemp(E->getType(), "agg.tmp");
130 return EmitAnyExpr(E, AggSlot);
Daniel Dunbar41cf9de2008-09-09 01:06:48 +0000131}
132
John McCall21886962010-04-21 10:05:39 +0000133/// EmitAnyExprToMem - Evaluate an expression into a given memory
134/// location.
135void CodeGenFunction::EmitAnyExprToMem(const Expr *E,
136 llvm::Value *Location,
Chad Rosier615ed1a2012-03-29 17:37:10 +0000137 Qualifiers Quals,
138 bool IsInit) {
Eli Friedmanc1d85b92011-12-03 00:54:26 +0000139 // FIXME: This function should take an LValue as an argument.
140 if (E->getType()->isAnyComplexType()) {
John McCall31168b02011-06-15 23:02:42 +0000141 EmitComplexExprIntoAddr(E, Location, Quals.hasVolatile());
Eli Friedmanc1d85b92011-12-03 00:54:26 +0000142 } else if (hasAggregateLLVMType(E->getType())) {
Eli Friedman38cd36d2011-12-03 02:13:40 +0000143 CharUnits Alignment = getContext().getTypeAlignInChars(E->getType());
Eli Friedmanc1d85b92011-12-03 00:54:26 +0000144 EmitAggExpr(E, AggValueSlot::forAddr(Location, Alignment, Quals,
Chad Rosier615ed1a2012-03-29 17:37:10 +0000145 AggValueSlot::IsDestructed_t(IsInit),
John McCalla8a39bc2011-08-26 05:38:08 +0000146 AggValueSlot::DoesNotNeedGCBarriers,
Chad Rosier615ed1a2012-03-29 17:37:10 +0000147 AggValueSlot::IsAliased_t(!IsInit)));
Eli Friedmanc1d85b92011-12-03 00:54:26 +0000148 } else {
John McCall21886962010-04-21 10:05:39 +0000149 RValue RV = RValue::get(EmitScalarExpr(E, /*Ignore*/ false));
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +0000150 LValue LV = MakeAddrLValue(Location, E->getType());
John McCall55e1fbc2011-06-25 02:11:03 +0000151 EmitStoreThroughLValue(RV, LV);
John McCall21886962010-04-21 10:05:39 +0000152 }
153}
154
Benjamin Kramer90b5b682010-11-25 18:29:30 +0000155namespace {
Douglas Gregor7c38f152010-05-20 08:36:28 +0000156/// \brief An adjustment to be made to the temporary created when emitting a
157/// reference binding, which accesses a particular subobject of that temporary.
Benjamin Kramer90b5b682010-11-25 18:29:30 +0000158 struct SubobjectAdjustment {
159 enum { DerivedToBaseAdjustment, FieldAdjustment } Kind;
160
161 union {
162 struct {
163 const CastExpr *BasePath;
164 const CXXRecordDecl *DerivedClass;
165 } DerivedToBase;
166
167 FieldDecl *Field;
168 };
169
170 SubobjectAdjustment(const CastExpr *BasePath,
171 const CXXRecordDecl *DerivedClass)
172 : Kind(DerivedToBaseAdjustment) {
173 DerivedToBase.BasePath = BasePath;
174 DerivedToBase.DerivedClass = DerivedClass;
175 }
176
177 SubobjectAdjustment(FieldDecl *Field)
178 : Kind(FieldAdjustment) {
179 this->Field = Field;
180 }
Douglas Gregor7c38f152010-05-20 08:36:28 +0000181 };
Benjamin Kramer90b5b682010-11-25 18:29:30 +0000182}
Douglas Gregor7c38f152010-05-20 08:36:28 +0000183
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000184static llvm::Value *
Chris Lattner24516962011-07-20 04:59:57 +0000185CreateReferenceTemporary(CodeGenFunction &CGF, QualType Type,
Anders Carlsson18c205e2010-06-27 17:23:46 +0000186 const NamedDecl *InitializedDecl) {
187 if (const VarDecl *VD = dyn_cast_or_null<VarDecl>(InitializedDecl)) {
188 if (VD->hasGlobalStorage()) {
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000189 SmallString<256> Name;
Rafael Espindola3968cd02011-02-11 02:52:17 +0000190 llvm::raw_svector_ostream Out(Name);
191 CGF.CGM.getCXXABI().getMangleContext().mangleReferenceTemporary(VD, Out);
192 Out.flush();
193
Chris Lattner2192fe52011-07-18 04:24:23 +0000194 llvm::Type *RefTempTy = CGF.ConvertTypeForMem(Type);
Anders Carlsson18c205e2010-06-27 17:23:46 +0000195
196 // Create the reference temporary.
197 llvm::GlobalValue *RefTemp =
198 new llvm::GlobalVariable(CGF.CGM.getModule(),
199 RefTempTy, /*isConstant=*/false,
200 llvm::GlobalValue::InternalLinkage,
201 llvm::Constant::getNullValue(RefTempTy),
202 Name.str());
203 return RefTemp;
204 }
205 }
206
207 return CGF.CreateMemTemp(Type, "ref.tmp");
208}
209
210static llvm::Value *
Chris Lattnerf53c0962010-09-06 00:11:41 +0000211EmitExprForReferenceBinding(CodeGenFunction &CGF, const Expr *E,
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000212 llvm::Value *&ReferenceTemporary,
213 const CXXDestructorDecl *&ReferenceTemporaryDtor,
John McCall31168b02011-06-15 23:02:42 +0000214 QualType &ObjCARCReferenceLifetimeType,
Anders Carlsson18c205e2010-06-27 17:23:46 +0000215 const NamedDecl *InitializedDecl) {
Sebastian Redl29526f02011-11-27 16:50:07 +0000216 // Look through single-element init lists that claim to be lvalues. They're
217 // just syntactic wrappers in this case.
218 if (const InitListExpr *ILE = dyn_cast<InitListExpr>(E)) {
219 if (ILE->getNumInits() == 1 && ILE->isGLValue())
220 E = ILE->getInit(0);
221 }
222
Douglas Gregorfe314812011-06-21 17:03:29 +0000223 // Look through expressions for materialized temporaries (for now).
Douglas Gregor58df5092011-06-22 16:12:01 +0000224 if (const MaterializeTemporaryExpr *M
225 = dyn_cast<MaterializeTemporaryExpr>(E)) {
226 // Objective-C++ ARC:
227 // If we are binding a reference to a temporary that has ownership, we
228 // need to perform retain/release operations on the temporary.
David Blaikiebbafb8a2012-03-11 07:00:24 +0000229 if (CGF.getContext().getLangOpts().ObjCAutoRefCount &&
Douglas Gregor58df5092011-06-22 16:12:01 +0000230 E->getType()->isObjCLifetimeType() &&
231 (E->getType().getObjCLifetime() == Qualifiers::OCL_Strong ||
232 E->getType().getObjCLifetime() == Qualifiers::OCL_Weak ||
233 E->getType().getObjCLifetime() == Qualifiers::OCL_Autoreleasing))
234 ObjCARCReferenceLifetimeType = E->getType();
235
236 E = M->GetTemporaryExpr();
237 }
Douglas Gregorfe314812011-06-21 17:03:29 +0000238
Eli Friedman357e8c92009-12-19 00:20:10 +0000239 if (const CXXDefaultArgExpr *DAE = dyn_cast<CXXDefaultArgExpr>(E))
240 E = DAE->getExpr();
Anders Carlsson66413c22009-10-15 00:51:46 +0000241
John McCall08ef4662011-11-10 08:15:53 +0000242 if (const ExprWithCleanups *EWC = dyn_cast<ExprWithCleanups>(E)) {
243 CGF.enterFullExpression(EWC);
John McCallbd309292010-07-06 01:34:17 +0000244 CodeGenFunction::RunCleanupsScope Scope(CGF);
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000245
John McCall08ef4662011-11-10 08:15:53 +0000246 return EmitExprForReferenceBinding(CGF, EWC->getSubExpr(),
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000247 ReferenceTemporary,
248 ReferenceTemporaryDtor,
John McCall31168b02011-06-15 23:02:42 +0000249 ObjCARCReferenceLifetimeType,
Anders Carlsson18c205e2010-06-27 17:23:46 +0000250 InitializedDecl);
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000251 }
252
253 RValue RV;
Douglas Gregor9c399a22011-01-22 02:44:21 +0000254 if (E->isGLValue()) {
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000255 // Emit the expression as an lvalue.
256 LValue LV = CGF.EmitLValue(E);
Chris Lattner13ee4f42011-07-10 05:34:54 +0000257
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000258 if (LV.isSimple())
259 return LV.getAddress();
Anders Carlsson824e0612010-02-04 17:32:58 +0000260
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000261 // We have to load the lvalue.
John McCall55e1fbc2011-06-25 02:11:03 +0000262 RV = CGF.EmitLoadOfLValue(LV);
Eli Friedmanc21cb442009-05-20 02:31:19 +0000263 } else {
Douglas Gregor58df5092011-06-22 16:12:01 +0000264 if (!ObjCARCReferenceLifetimeType.isNull()) {
265 ReferenceTemporary = CreateReferenceTemporary(CGF,
266 ObjCARCReferenceLifetimeType,
267 InitializedDecl);
268
269
270 LValue RefTempDst = CGF.MakeAddrLValue(ReferenceTemporary,
271 ObjCARCReferenceLifetimeType);
272
273 CGF.EmitScalarInit(E, dyn_cast_or_null<ValueDecl>(InitializedDecl),
274 RefTempDst, false);
275
276 bool ExtendsLifeOfTemporary = false;
277 if (const VarDecl *Var = dyn_cast_or_null<VarDecl>(InitializedDecl)) {
278 if (Var->extendsLifetimeOfTemporary())
279 ExtendsLifeOfTemporary = true;
280 } else if (InitializedDecl && isa<FieldDecl>(InitializedDecl)) {
281 ExtendsLifeOfTemporary = true;
282 }
283
284 if (!ExtendsLifeOfTemporary) {
285 // Since the lifetime of this temporary isn't going to be extended,
286 // we need to clean it up ourselves at the end of the full expression.
287 switch (ObjCARCReferenceLifetimeType.getObjCLifetime()) {
288 case Qualifiers::OCL_None:
289 case Qualifiers::OCL_ExplicitNone:
290 case Qualifiers::OCL_Autoreleasing:
291 break;
292
John McCall4bd0fb12011-07-12 16:41:08 +0000293 case Qualifiers::OCL_Strong: {
294 assert(!ObjCARCReferenceLifetimeType->isArrayType());
295 CleanupKind cleanupKind = CGF.getARCCleanupKind();
296 CGF.pushDestroy(cleanupKind,
297 ReferenceTemporary,
298 ObjCARCReferenceLifetimeType,
299 CodeGenFunction::destroyARCStrongImprecise,
300 cleanupKind & EHCleanup);
Douglas Gregor58df5092011-06-22 16:12:01 +0000301 break;
John McCall4bd0fb12011-07-12 16:41:08 +0000302 }
Douglas Gregor58df5092011-06-22 16:12:01 +0000303
304 case Qualifiers::OCL_Weak:
John McCall4bd0fb12011-07-12 16:41:08 +0000305 assert(!ObjCARCReferenceLifetimeType->isArrayType());
306 CGF.pushDestroy(NormalAndEHCleanup,
307 ReferenceTemporary,
308 ObjCARCReferenceLifetimeType,
309 CodeGenFunction::destroyARCWeak,
310 /*useEHCleanupForArray*/ true);
Douglas Gregor58df5092011-06-22 16:12:01 +0000311 break;
312 }
313
314 ObjCARCReferenceLifetimeType = QualType();
315 }
316
317 return ReferenceTemporary;
318 }
319
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000320 SmallVector<SubobjectAdjustment, 2> Adjustments;
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000321 while (true) {
Peter Collingbourne91147592011-04-15 00:35:48 +0000322 E = E->IgnoreParens();
Douglas Gregoraae38d62010-05-22 05:17:18 +0000323
324 if (const CastExpr *CE = dyn_cast<CastExpr>(E)) {
John McCalle3027922010-08-25 11:45:40 +0000325 if ((CE->getCastKind() == CK_DerivedToBase ||
326 CE->getCastKind() == CK_UncheckedDerivedToBase) &&
Douglas Gregoraae38d62010-05-22 05:17:18 +0000327 E->getType()->isRecordType()) {
Douglas Gregor7c38f152010-05-20 08:36:28 +0000328 E = CE->getSubExpr();
329 CXXRecordDecl *Derived
330 = cast<CXXRecordDecl>(E->getType()->getAs<RecordType>()->getDecl());
John McCallcf142162010-08-07 06:22:56 +0000331 Adjustments.push_back(SubobjectAdjustment(CE, Derived));
Douglas Gregor7c38f152010-05-20 08:36:28 +0000332 continue;
333 }
Douglas Gregoraae38d62010-05-22 05:17:18 +0000334
John McCalle3027922010-08-25 11:45:40 +0000335 if (CE->getCastKind() == CK_NoOp) {
Douglas Gregoraae38d62010-05-22 05:17:18 +0000336 E = CE->getSubExpr();
337 continue;
338 }
339 } else if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
John McCall086a4642010-11-24 05:12:34 +0000340 if (!ME->isArrow() && ME->getBase()->isRValue()) {
341 assert(ME->getBase()->getType()->isRecordType());
Douglas Gregor7c38f152010-05-20 08:36:28 +0000342 if (FieldDecl *Field = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
343 E = ME->getBase();
Daniel Dunbare8b6cda2010-08-21 03:37:02 +0000344 Adjustments.push_back(SubobjectAdjustment(Field));
Douglas Gregor7c38f152010-05-20 08:36:28 +0000345 continue;
346 }
347 }
Anders Carlsson66413c22009-10-15 00:51:46 +0000348 }
Douglas Gregoraae38d62010-05-22 05:17:18 +0000349
John McCalle9dab632011-02-21 05:25:38 +0000350 if (const OpaqueValueExpr *opaque = dyn_cast<OpaqueValueExpr>(E))
351 if (opaque->getType()->isRecordType())
352 return CGF.EmitOpaqueValueLValue(opaque).getAddress();
353
Douglas Gregoraae38d62010-05-22 05:17:18 +0000354 // Nothing changed.
355 break;
Anders Carlssonb80760b2009-08-16 17:50:25 +0000356 }
Anders Carlsson66413c22009-10-15 00:51:46 +0000357
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000358 // Create a reference temporary if necessary.
John McCall7a626f62010-09-15 10:14:12 +0000359 AggValueSlot AggSlot = AggValueSlot::ignored();
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000360 if (CGF.hasAggregateLLVMType(E->getType()) &&
John McCall7a626f62010-09-15 10:14:12 +0000361 !E->getType()->isAnyComplexType()) {
Anders Carlsson18c205e2010-06-27 17:23:46 +0000362 ReferenceTemporary = CreateReferenceTemporary(CGF, E->getType(),
363 InitializedDecl);
Eli Friedman38cd36d2011-12-03 02:13:40 +0000364 CharUnits Alignment = CGF.getContext().getTypeAlignInChars(E->getType());
John McCall8d6fc952011-08-25 20:40:09 +0000365 AggValueSlot::IsDestructed_t isDestructed
366 = AggValueSlot::IsDestructed_t(InitializedDecl != 0);
Eli Friedmanc1d85b92011-12-03 00:54:26 +0000367 AggSlot = AggValueSlot::forAddr(ReferenceTemporary, Alignment,
368 Qualifiers(), isDestructed,
John McCalla5efa732011-08-25 23:04:34 +0000369 AggValueSlot::DoesNotNeedGCBarriers,
Chad Rosier615ed1a2012-03-29 17:37:10 +0000370 AggValueSlot::IsNotAliased);
John McCall7a626f62010-09-15 10:14:12 +0000371 }
John McCall31168b02011-06-15 23:02:42 +0000372
Anders Carlsson18c205e2010-06-27 17:23:46 +0000373 if (InitializedDecl) {
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000374 // Get the destructor for the reference temporary.
375 if (const RecordType *RT = E->getType()->getAs<RecordType>()) {
376 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(RT->getDecl());
377 if (!ClassDecl->hasTrivialDestructor())
Douglas Gregorbac74902010-07-01 14:13:13 +0000378 ReferenceTemporaryDtor = ClassDecl->getDestructor();
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000379 }
380 }
381
John McCall31168b02011-06-15 23:02:42 +0000382 RV = CGF.EmitAnyExpr(E, AggSlot);
383
Douglas Gregor7c38f152010-05-20 08:36:28 +0000384 // Check if need to perform derived-to-base casts and/or field accesses, to
385 // get from the temporary object we created (and, potentially, for which we
386 // extended the lifetime) to the subobject we're binding the reference to.
387 if (!Adjustments.empty()) {
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000388 llvm::Value *Object = RV.getAggregateAddr();
Douglas Gregor7c38f152010-05-20 08:36:28 +0000389 for (unsigned I = Adjustments.size(); I != 0; --I) {
390 SubobjectAdjustment &Adjustment = Adjustments[I-1];
391 switch (Adjustment.Kind) {
392 case SubobjectAdjustment::DerivedToBaseAdjustment:
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000393 Object =
394 CGF.GetAddressOfBaseClass(Object,
395 Adjustment.DerivedToBase.DerivedClass,
John McCallcf142162010-08-07 06:22:56 +0000396 Adjustment.DerivedToBase.BasePath->path_begin(),
397 Adjustment.DerivedToBase.BasePath->path_end(),
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000398 /*NullCheckValue=*/false);
Douglas Gregor7c38f152010-05-20 08:36:28 +0000399 break;
400
401 case SubobjectAdjustment::FieldAdjustment: {
Eli Friedman7f1ff602012-04-16 03:54:45 +0000402 LValue LV = CGF.MakeAddrLValue(Object, E->getType());
403 LV = CGF.EmitLValueForField(LV, Adjustment.Field);
Douglas Gregor7c38f152010-05-20 08:36:28 +0000404 if (LV.isSimple()) {
405 Object = LV.getAddress();
406 break;
407 }
408
409 // For non-simple lvalues, we actually have to create a copy of
410 // the object we're binding to.
Daniel Dunbare8b6cda2010-08-21 03:37:02 +0000411 QualType T = Adjustment.Field->getType().getNonReferenceType()
412 .getUnqualifiedType();
Anders Carlsson3f48c602010-06-27 17:52:15 +0000413 Object = CreateReferenceTemporary(CGF, T, InitializedDecl);
Daniel Dunbare8b6cda2010-08-21 03:37:02 +0000414 LValue TempLV = CGF.MakeAddrLValue(Object,
415 Adjustment.Field->getType());
John McCall55e1fbc2011-06-25 02:11:03 +0000416 CGF.EmitStoreThroughLValue(CGF.EmitLoadOfLValue(LV), TempLV);
Douglas Gregor7c38f152010-05-20 08:36:28 +0000417 break;
418 }
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000419
Douglas Gregor7c38f152010-05-20 08:36:28 +0000420 }
421 }
Eli Friedmanb6069252011-03-16 22:34:09 +0000422
423 return Object;
Anders Carlsson66413c22009-10-15 00:51:46 +0000424 }
Anders Carlsson7d4c0832009-05-20 00:36:58 +0000425 }
Eli Friedmanc21cb442009-05-20 02:31:19 +0000426
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000427 if (RV.isAggregate())
428 return RV.getAggregateAddr();
Eli Friedmanc21cb442009-05-20 02:31:19 +0000429
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000430 // Create a temporary variable that we can bind the reference to.
Anders Carlsson18c205e2010-06-27 17:23:46 +0000431 ReferenceTemporary = CreateReferenceTemporary(CGF, E->getType(),
432 InitializedDecl);
433
Daniel Dunbar03816342010-08-21 02:24:36 +0000434
435 unsigned Alignment =
436 CGF.getContext().getTypeAlignInChars(E->getType()).getQuantity();
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000437 if (RV.isScalar())
438 CGF.EmitStoreOfScalar(RV.getScalarVal(), ReferenceTemporary,
Daniel Dunbar03816342010-08-21 02:24:36 +0000439 /*Volatile=*/false, Alignment, E->getType());
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000440 else
441 CGF.StoreComplexToAddr(RV.getComplexVal(), ReferenceTemporary,
442 /*Volatile=*/false);
443 return ReferenceTemporary;
444}
445
446RValue
Chris Lattnerf53c0962010-09-06 00:11:41 +0000447CodeGenFunction::EmitReferenceBindingToExpr(const Expr *E,
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000448 const NamedDecl *InitializedDecl) {
449 llvm::Value *ReferenceTemporary = 0;
450 const CXXDestructorDecl *ReferenceTemporaryDtor = 0;
John McCall31168b02011-06-15 23:02:42 +0000451 QualType ObjCARCReferenceLifetimeType;
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000452 llvm::Value *Value = EmitExprForReferenceBinding(*this, E, ReferenceTemporary,
453 ReferenceTemporaryDtor,
John McCall31168b02011-06-15 23:02:42 +0000454 ObjCARCReferenceLifetimeType,
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000455 InitializedDecl);
John McCall31168b02011-06-15 23:02:42 +0000456 if (!ReferenceTemporaryDtor && ObjCARCReferenceLifetimeType.isNull())
Anders Carlsson3f48c602010-06-27 17:52:15 +0000457 return RValue::get(Value);
458
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000459 // Make sure to call the destructor for the reference temporary.
John McCall31168b02011-06-15 23:02:42 +0000460 const VarDecl *VD = dyn_cast_or_null<VarDecl>(InitializedDecl);
461 if (VD && VD->hasGlobalStorage()) {
462 if (ReferenceTemporaryDtor) {
Anders Carlsson3f48c602010-06-27 17:52:15 +0000463 llvm::Constant *DtorFn =
464 CGM.GetAddrOfCXXDestructor(ReferenceTemporaryDtor, Dtor_Complete);
John McCallc84ed6a2012-05-01 06:13:13 +0000465 CGM.getCXXABI().registerGlobalDtor(*this, DtorFn,
John McCallad7c5c12011-02-08 08:22:06 +0000466 cast<llvm::Constant>(ReferenceTemporary));
John McCall31168b02011-06-15 23:02:42 +0000467 } else {
468 assert(!ObjCARCReferenceLifetimeType.isNull());
469 // Note: We intentionally do not register a global "destructor" to
470 // release the object.
Anders Carlsson3f48c602010-06-27 17:52:15 +0000471 }
John McCall31168b02011-06-15 23:02:42 +0000472
473 return RValue::get(Value);
Anders Carlsson3f48c602010-06-27 17:52:15 +0000474 }
John McCall8680f872010-07-21 06:29:51 +0000475
John McCall31168b02011-06-15 23:02:42 +0000476 if (ReferenceTemporaryDtor)
477 PushDestructorCleanup(ReferenceTemporaryDtor, ReferenceTemporary);
478 else {
479 switch (ObjCARCReferenceLifetimeType.getObjCLifetime()) {
480 case Qualifiers::OCL_None:
David Blaikie83d382b2011-09-23 05:06:16 +0000481 llvm_unreachable(
482 "Not a reference temporary that needs to be deallocated");
John McCall31168b02011-06-15 23:02:42 +0000483 case Qualifiers::OCL_ExplicitNone:
484 case Qualifiers::OCL_Autoreleasing:
485 // Nothing to do.
486 break;
487
John McCall4bd0fb12011-07-12 16:41:08 +0000488 case Qualifiers::OCL_Strong: {
489 bool precise = VD && VD->hasAttr<ObjCPreciseLifetimeAttr>();
490 CleanupKind cleanupKind = getARCCleanupKind();
Benjamin Kramerae2d3442011-07-12 18:37:23 +0000491 pushDestroy(cleanupKind, ReferenceTemporary, ObjCARCReferenceLifetimeType,
Peter Collingbourne1425b452012-01-26 03:33:36 +0000492 precise ? destroyARCStrongPrecise : destroyARCStrongImprecise,
493 cleanupKind & EHCleanup);
John McCall31168b02011-06-15 23:02:42 +0000494 break;
John McCall4bd0fb12011-07-12 16:41:08 +0000495 }
John McCall31168b02011-06-15 23:02:42 +0000496
Benjamin Kramerae2d3442011-07-12 18:37:23 +0000497 case Qualifiers::OCL_Weak: {
John McCall31168b02011-06-15 23:02:42 +0000498 // __weak objects always get EH cleanups; otherwise, exceptions
499 // could cause really nasty crashes instead of mere leaks.
John McCall4bd0fb12011-07-12 16:41:08 +0000500 pushDestroy(NormalAndEHCleanup, ReferenceTemporary,
Peter Collingbourne1425b452012-01-26 03:33:36 +0000501 ObjCARCReferenceLifetimeType, destroyARCWeak, true);
John McCall31168b02011-06-15 23:02:42 +0000502 break;
503 }
Benjamin Kramerae2d3442011-07-12 18:37:23 +0000504 }
John McCall31168b02011-06-15 23:02:42 +0000505 }
506
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000507 return RValue::get(Value);
Anders Carlsson6f5a0152009-05-20 00:24:07 +0000508}
509
510
Mike Stump4a3999f2009-09-09 13:00:44 +0000511/// getAccessedFieldNo - Given an encoded value and a result number, return the
512/// input field number being accessed.
513unsigned CodeGenFunction::getAccessedFieldNo(unsigned Idx,
Dan Gohman75d69da2008-05-22 00:50:06 +0000514 const llvm::Constant *Elts) {
Chris Lattner595ba3a2012-01-30 06:20:36 +0000515 return cast<llvm::ConstantInt>(Elts->getAggregateElement(Idx))
516 ->getZExtValue();
Dan Gohman75d69da2008-05-22 00:50:06 +0000517}
518
Mike Stump3f6f9fe2009-12-16 02:57:00 +0000519void CodeGenFunction::EmitCheck(llvm::Value *Address, unsigned Size) {
Nuno Lopes3d6311d2012-05-08 22:10:46 +0000520 if (BoundsChecking <= 0)
Mike Stump3f6f9fe2009-12-16 02:57:00 +0000521 return;
522
John McCallad7c5c12011-02-08 08:22:06 +0000523 // This needs to be to the standard address space.
524 Address = Builder.CreateBitCast(Address, Int8PtrTy);
Mike Stump3f6f9fe2009-12-16 02:57:00 +0000525
Benjamin Kramer8d375ce2011-07-14 17:45:50 +0000526 llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::objectsize, IntPtrTy);
Chris Lattnerbc3be652010-04-10 18:34:14 +0000527
Nuno Lopesddcce0b2012-05-09 15:53:34 +0000528 llvm::Value *Min = Builder.getFalse();
529 llvm::Value *Runtime = Builder.getInt32(BoundsChecking);
530 llvm::Value *C = Builder.CreateCall3(F, Address, Min, Runtime);
Mike Stump3f6f9fe2009-12-16 02:57:00 +0000531 llvm::BasicBlock *Cont = createBasicBlock();
Mike Stump3f6f9fe2009-12-16 02:57:00 +0000532 Builder.CreateCondBr(Builder.CreateICmpUGE(C,
Chris Lattner5e016ae2010-06-27 07:15:29 +0000533 llvm::ConstantInt::get(IntPtrTy, Size)),
Mike Stump3f6f9fe2009-12-16 02:57:00 +0000534 Cont, getTrapBB());
535 EmitBlock(Cont);
536}
Chris Lattner4647a212007-08-31 22:49:20 +0000537
Chris Lattner116ce8f2010-01-09 21:40:03 +0000538
Chris Lattner116ce8f2010-01-09 21:40:03 +0000539CodeGenFunction::ComplexPairTy CodeGenFunction::
540EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV,
541 bool isInc, bool isPre) {
542 ComplexPairTy InVal = LoadComplexFromAddr(LV.getAddress(),
543 LV.isVolatileQualified());
544
545 llvm::Value *NextVal;
546 if (isa<llvm::IntegerType>(InVal.first->getType())) {
547 uint64_t AmountVal = isInc ? 1 : -1;
548 NextVal = llvm::ConstantInt::get(InVal.first->getType(), AmountVal, true);
549
550 // Add the inc/dec to the real part.
551 NextVal = Builder.CreateAdd(InVal.first, NextVal, isInc ? "inc" : "dec");
552 } else {
553 QualType ElemTy = E->getType()->getAs<ComplexType>()->getElementType();
554 llvm::APFloat FVal(getContext().getFloatTypeSemantics(ElemTy), 1);
555 if (!isInc)
556 FVal.changeSign();
557 NextVal = llvm::ConstantFP::get(getLLVMContext(), FVal);
558
559 // Add the inc/dec to the real part.
560 NextVal = Builder.CreateFAdd(InVal.first, NextVal, isInc ? "inc" : "dec");
561 }
562
563 ComplexPairTy IncVal(NextVal, InVal.second);
564
565 // Store the updated result through the lvalue.
566 StoreComplexToAddr(IncVal, LV.getAddress(), LV.isVolatileQualified());
567
568 // If this is a postinc, return the value read from memory, otherwise use the
569 // updated value.
570 return isPre ? IncVal : InVal;
571}
572
573
Chris Lattnera45c5af2007-06-02 19:47:04 +0000574//===----------------------------------------------------------------------===//
Chris Lattnerd7f58862007-06-02 05:24:33 +0000575// LValue Expression Emission
Chris Lattnera45c5af2007-06-02 19:47:04 +0000576//===----------------------------------------------------------------------===//
Chris Lattnerd7f58862007-06-02 05:24:33 +0000577
Daniel Dunbarc79407f2009-02-05 07:09:07 +0000578RValue CodeGenFunction::GetUndefRValue(QualType Ty) {
Chris Lattnerab5e0af2009-10-28 17:39:19 +0000579 if (Ty->isVoidType())
Daniel Dunbarc79407f2009-02-05 07:09:07 +0000580 return RValue::get(0);
Chris Lattnerab5e0af2009-10-28 17:39:19 +0000581
582 if (const ComplexType *CTy = Ty->getAs<ComplexType>()) {
Chris Lattner2192fe52011-07-18 04:24:23 +0000583 llvm::Type *EltTy = ConvertType(CTy->getElementType());
Owen Anderson7ec07a52009-07-30 23:11:26 +0000584 llvm::Value *U = llvm::UndefValue::get(EltTy);
Daniel Dunbar8429dbc2009-01-09 20:09:28 +0000585 return RValue::getComplex(std::make_pair(U, U));
Chris Lattnerab5e0af2009-10-28 17:39:19 +0000586 }
587
Chris Lattner65526f02010-08-23 05:26:13 +0000588 // If this is a use of an undefined aggregate type, the aggregate must have an
589 // identifiable address. Just because the contents of the value are undefined
590 // doesn't mean that the address can't be taken and compared.
Chris Lattnerab5e0af2009-10-28 17:39:19 +0000591 if (hasAggregateLLVMType(Ty)) {
Chris Lattner65526f02010-08-23 05:26:13 +0000592 llvm::Value *DestPtr = CreateMemTemp(Ty, "undef.agg.tmp");
593 return RValue::getAggregate(DestPtr);
Daniel Dunbar8429dbc2009-01-09 20:09:28 +0000594 }
Chris Lattnerab5e0af2009-10-28 17:39:19 +0000595
596 return RValue::get(llvm::UndefValue::get(ConvertType(Ty)));
Daniel Dunbarbb197e42009-01-09 16:50:52 +0000597}
598
Daniel Dunbarc79407f2009-02-05 07:09:07 +0000599RValue CodeGenFunction::EmitUnsupportedRValue(const Expr *E,
600 const char *Name) {
601 ErrorUnsupported(E, Name);
602 return GetUndefRValue(E->getType());
603}
604
Daniel Dunbarf2e69882008-08-25 20:45:57 +0000605LValue CodeGenFunction::EmitUnsupportedLValue(const Expr *E,
606 const char *Name) {
607 ErrorUnsupported(E, Name);
Owen Anderson9793f0e2009-07-29 22:16:19 +0000608 llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType()));
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +0000609 return MakeAddrLValue(llvm::UndefValue::get(Ty), E->getType());
Daniel Dunbarf2e69882008-08-25 20:45:57 +0000610}
611
Mike Stump3f6f9fe2009-12-16 02:57:00 +0000612LValue CodeGenFunction::EmitCheckedLValue(const Expr *E) {
613 LValue LV = EmitLValue(E);
Daniel Dunbardc406b82010-04-05 21:36:35 +0000614 if (!isa<DeclRefExpr>(E) && !LV.isBitField() && LV.isSimple())
Ken Dyck705ba072011-01-19 01:58:38 +0000615 EmitCheck(LV.getAddress(),
616 getContext().getTypeSizeInChars(E->getType()).getQuantity());
Mike Stump3f6f9fe2009-12-16 02:57:00 +0000617 return LV;
618}
619
Chris Lattner8394d792007-06-05 20:53:16 +0000620/// EmitLValue - Emit code to compute a designator that specifies the location
621/// of the expression.
622///
Mike Stump4a3999f2009-09-09 13:00:44 +0000623/// This can return one of two things: a simple address or a bitfield reference.
624/// In either case, the LLVM Value* in the LValue structure is guaranteed to be
625/// an LLVM pointer type.
Chris Lattner8394d792007-06-05 20:53:16 +0000626///
Mike Stump4a3999f2009-09-09 13:00:44 +0000627/// If this returns a bitfield reference, nothing about the pointee type of the
628/// LLVM value is known: For example, it may not be a pointer to an integer.
Chris Lattner8394d792007-06-05 20:53:16 +0000629///
Mike Stump4a3999f2009-09-09 13:00:44 +0000630/// If this returns a normal address, and if the lvalue's C type is fixed size,
631/// this method guarantees that the returned pointer type will point to an LLVM
632/// type of the same size of the lvalue's type. If the lvalue has a variable
633/// length type, this is not possible.
Chris Lattner8394d792007-06-05 20:53:16 +0000634///
Chris Lattnerd7f58862007-06-02 05:24:33 +0000635LValue CodeGenFunction::EmitLValue(const Expr *E) {
636 switch (E->getStmtClass()) {
Daniel Dunbarf2e69882008-08-25 20:45:57 +0000637 default: return EmitUnsupportedLValue(E, "l-value expression");
Chris Lattnerd7f58862007-06-02 05:24:33 +0000638
John McCallc109a252011-11-07 03:59:57 +0000639 case Expr::ObjCPropertyRefExprClass:
640 llvm_unreachable("cannot emit a property reference directly");
641
Fariborz Jahanian9240f3d2010-06-17 19:56:20 +0000642 case Expr::ObjCSelectorExprClass:
643 return EmitObjCSelectorLValue(cast<ObjCSelectorExpr>(E));
Fariborz Jahanian531c16f2009-12-09 23:35:29 +0000644 case Expr::ObjCIsaExprClass:
645 return EmitObjCIsaExpr(cast<ObjCIsaExpr>(E));
Mike Stump4a3999f2009-09-09 13:00:44 +0000646 case Expr::BinaryOperatorClass:
Daniel Dunbar8cde00a2008-09-04 03:20:13 +0000647 return EmitBinaryOperatorLValue(cast<BinaryOperator>(E));
Douglas Gregor914af212010-04-23 04:16:32 +0000648 case Expr::CompoundAssignOperatorClass:
John McCalla2342eb2010-12-05 02:00:02 +0000649 if (!E->getType()->isAnyComplexType())
650 return EmitCompoundAssignmentLValue(cast<CompoundAssignOperator>(E));
651 return EmitComplexCompoundAssignmentLValue(cast<CompoundAssignOperator>(E));
Mike Stump4a3999f2009-09-09 13:00:44 +0000652 case Expr::CallExprClass:
Anders Carlssonc82555f2009-09-01 21:18:52 +0000653 case Expr::CXXMemberCallExprClass:
Douglas Gregor993603d2008-11-14 16:09:21 +0000654 case Expr::CXXOperatorCallExprClass:
Richard Smithc67fdd42012-03-07 08:35:16 +0000655 case Expr::UserDefinedLiteralClass:
Douglas Gregor993603d2008-11-14 16:09:21 +0000656 return EmitCallExprLValue(cast<CallExpr>(E));
Daniel Dunbar8d9dc4a2009-02-11 20:59:32 +0000657 case Expr::VAArgExprClass:
658 return EmitVAArgExprLValue(cast<VAArgExpr>(E));
Mike Stump4a3999f2009-09-09 13:00:44 +0000659 case Expr::DeclRefExprClass:
Douglas Gregorc7acfdf2009-01-06 05:10:23 +0000660 return EmitDeclRefLValue(cast<DeclRefExpr>(E));
Eric Christopherd98e4242011-09-08 17:15:04 +0000661 case Expr::ParenExprClass:
662 return EmitLValue(cast<ParenExpr>(E)->getSubExpr());
Peter Collingbourne91147592011-04-15 00:35:48 +0000663 case Expr::GenericSelectionExprClass:
664 return EmitLValue(cast<GenericSelectionExpr>(E)->getResultExpr());
Chris Lattner6307f192008-08-10 01:53:14 +0000665 case Expr::PredefinedExprClass:
666 return EmitPredefinedLValue(cast<PredefinedExpr>(E));
Chris Lattner4347e3692007-06-06 04:54:52 +0000667 case Expr::StringLiteralClass:
668 return EmitStringLiteralLValue(cast<StringLiteral>(E));
Chris Lattnerd7e7b8e2009-02-24 22:18:39 +0000669 case Expr::ObjCEncodeExprClass:
670 return EmitObjCEncodeExprLValue(cast<ObjCEncodeExpr>(E));
John McCallfe96e0b2011-11-06 09:01:30 +0000671 case Expr::PseudoObjectExprClass:
672 return EmitPseudoObjectLValue(cast<PseudoObjectExpr>(E));
Sebastian Redl29526f02011-11-27 16:50:07 +0000673 case Expr::InitListExprClass:
Richard Smithbb653bd2012-05-14 21:57:21 +0000674 return EmitInitListLValue(cast<InitListExpr>(E));
Anders Carlsson3be22e22009-05-30 23:23:33 +0000675 case Expr::CXXTemporaryObjectExprClass:
676 case Expr::CXXConstructExprClass:
Anders Carlssonfd2af0c2009-05-30 23:30:54 +0000677 return EmitCXXConstructLValue(cast<CXXConstructExpr>(E));
678 case Expr::CXXBindTemporaryExprClass:
679 return EmitCXXBindTemporaryLValue(cast<CXXBindTemporaryExpr>(E));
Eli Friedman5bc17122012-02-08 05:34:55 +0000680 case Expr::LambdaExprClass:
681 return EmitLambdaLValue(cast<LambdaExpr>(E));
John McCall08ef4662011-11-10 08:15:53 +0000682
683 case Expr::ExprWithCleanupsClass: {
684 const ExprWithCleanups *cleanups = cast<ExprWithCleanups>(E);
685 enterFullExpression(cleanups);
686 RunCleanupsScope Scope(*this);
687 return EmitLValue(cleanups->getSubExpr());
688 }
689
Douglas Gregor747eb782010-07-08 06:14:04 +0000690 case Expr::CXXScalarValueInitExprClass:
691 return EmitNullInitializationLValue(cast<CXXScalarValueInitExpr>(E));
Anders Carlsson52ce3bb2009-11-14 01:51:50 +0000692 case Expr::CXXDefaultArgExprClass:
693 return EmitLValue(cast<CXXDefaultArgExpr>(E)->getExpr());
Mike Stumpc9b231c2009-11-15 08:09:41 +0000694 case Expr::CXXTypeidExprClass:
695 return EmitCXXTypeidLValue(cast<CXXTypeidExpr>(E));
Anders Carlssonfd2af0c2009-05-30 23:30:54 +0000696
Daniel Dunbarc8317a42008-08-23 10:51:21 +0000697 case Expr::ObjCMessageExprClass:
698 return EmitObjCMessageExprLValue(cast<ObjCMessageExpr>(E));
Mike Stump4a3999f2009-09-09 13:00:44 +0000699 case Expr::ObjCIvarRefExprClass:
Chris Lattner4bd55962008-03-30 23:03:07 +0000700 return EmitObjCIvarRefLValue(cast<ObjCIvarRefExpr>(E));
Chris Lattnera4185c52009-04-25 19:35:26 +0000701 case Expr::StmtExprClass:
702 return EmitStmtExprLValue(cast<StmtExpr>(E));
Mike Stump4a3999f2009-09-09 13:00:44 +0000703 case Expr::UnaryOperatorClass:
Chris Lattner8394d792007-06-05 20:53:16 +0000704 return EmitUnaryOpLValue(cast<UnaryOperator>(E));
Chris Lattnerd9d2fb12007-06-08 23:31:14 +0000705 case Expr::ArraySubscriptExprClass:
706 return EmitArraySubscriptExpr(cast<ArraySubscriptExpr>(E));
Nate Begemance4d7fc2008-04-18 23:10:10 +0000707 case Expr::ExtVectorElementExprClass:
708 return EmitExtVectorElementExpr(cast<ExtVectorElementExpr>(E));
Mike Stump4a3999f2009-09-09 13:00:44 +0000709 case Expr::MemberExprClass:
Douglas Gregorc1905232009-08-26 22:36:53 +0000710 return EmitMemberExpr(cast<MemberExpr>(E));
Eli Friedman9fd8b682008-05-13 23:18:27 +0000711 case Expr::CompoundLiteralExprClass:
712 return EmitCompoundLiteralLValue(cast<CompoundLiteralExpr>(E));
Daniel Dunbarbf1fe8c2009-03-24 02:38:23 +0000713 case Expr::ConditionalOperatorClass:
Anders Carlsson1450adb2009-09-15 16:35:24 +0000714 return EmitConditionalOperatorLValue(cast<ConditionalOperator>(E));
John McCallc07a0c72011-02-17 10:25:35 +0000715 case Expr::BinaryConditionalOperatorClass:
716 return EmitConditionalOperatorLValue(cast<BinaryConditionalOperator>(E));
Chris Lattner053441f2008-12-12 05:35:08 +0000717 case Expr::ChooseExprClass:
Eli Friedmane0a5b8b2009-03-04 05:52:32 +0000718 return EmitLValue(cast<ChooseExpr>(E)->getChosenSubExpr(getContext()));
John McCall1bf58462011-02-16 08:02:54 +0000719 case Expr::OpaqueValueExprClass:
720 return EmitOpaqueValueLValue(cast<OpaqueValueExpr>(E));
John McCall7c454bb2011-07-15 05:09:51 +0000721 case Expr::SubstNonTypeTemplateParmExprClass:
722 return EmitLValue(cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement());
Chris Lattner63d06ab2009-03-18 04:02:57 +0000723 case Expr::ImplicitCastExprClass:
724 case Expr::CStyleCastExprClass:
725 case Expr::CXXFunctionalCastExprClass:
726 case Expr::CXXStaticCastExprClass:
727 case Expr::CXXDynamicCastExprClass:
728 case Expr::CXXReinterpretCastExprClass:
729 case Expr::CXXConstCastExprClass:
John McCall31168b02011-06-15 23:02:42 +0000730 case Expr::ObjCBridgedCastExprClass:
Chris Lattner28bcf1a2009-03-18 18:28:57 +0000731 return EmitCastLValue(cast<CastExpr>(E));
Sebastian Redl29526f02011-11-27 16:50:07 +0000732
Douglas Gregorfe314812011-06-21 17:03:29 +0000733 case Expr::MaterializeTemporaryExprClass:
734 return EmitMaterializeTemporaryExpr(cast<MaterializeTemporaryExpr>(E));
Chris Lattnerd7f58862007-06-02 05:24:33 +0000735 }
736}
737
John McCall71335052012-03-10 03:05:10 +0000738/// Given an object of the given canonical type, can we safely copy a
739/// value out of it based on its initializer?
740static bool isConstantEmittableObjectType(QualType type) {
741 assert(type.isCanonical());
742 assert(!type->isReferenceType());
743
744 // Must be const-qualified but non-volatile.
745 Qualifiers qs = type.getLocalQualifiers();
746 if (!qs.hasConst() || qs.hasVolatile()) return false;
747
748 // Otherwise, all object types satisfy this except C++ classes with
749 // mutable subobjects or non-trivial copy/destroy behavior.
750 if (const RecordType *RT = dyn_cast<RecordType>(type))
751 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl()))
752 if (RD->hasMutableFields() || !RD->isTrivial())
753 return false;
754
755 return true;
756}
757
758/// Can we constant-emit a load of a reference to a variable of the
759/// given type? This is different from predicates like
760/// Decl::isUsableInConstantExpressions because we do want it to apply
761/// in situations that don't necessarily satisfy the language's rules
762/// for this (e.g. C++'s ODR-use rules). For example, we want to able
763/// to do this with const float variables even if those variables
764/// aren't marked 'constexpr'.
765enum ConstantEmissionKind {
766 CEK_None,
767 CEK_AsReferenceOnly,
768 CEK_AsValueOrReference,
769 CEK_AsValueOnly
770};
771static ConstantEmissionKind checkVarTypeForConstantEmission(QualType type) {
772 type = type.getCanonicalType();
773 if (const ReferenceType *ref = dyn_cast<ReferenceType>(type)) {
774 if (isConstantEmittableObjectType(ref->getPointeeType()))
775 return CEK_AsValueOrReference;
776 return CEK_AsReferenceOnly;
777 }
778 if (isConstantEmittableObjectType(type))
779 return CEK_AsValueOnly;
780 return CEK_None;
781}
782
783/// Try to emit a reference to the given value without producing it as
784/// an l-value. This is actually more than an optimization: we can't
785/// produce an l-value for variables that we never actually captured
786/// in a block or lambda, which means const int variables or constexpr
787/// literals or similar.
788CodeGenFunction::ConstantEmission
John McCall113bee02012-03-10 09:33:50 +0000789CodeGenFunction::tryEmitAsConstant(DeclRefExpr *refExpr) {
790 ValueDecl *value = refExpr->getDecl();
791
John McCall71335052012-03-10 03:05:10 +0000792 // The value needs to be an enum constant or a constant variable.
793 ConstantEmissionKind CEK;
794 if (isa<ParmVarDecl>(value)) {
795 CEK = CEK_None;
796 } else if (VarDecl *var = dyn_cast<VarDecl>(value)) {
797 CEK = checkVarTypeForConstantEmission(var->getType());
798 } else if (isa<EnumConstantDecl>(value)) {
799 CEK = CEK_AsValueOnly;
800 } else {
801 CEK = CEK_None;
802 }
803 if (CEK == CEK_None) return ConstantEmission();
804
John McCall71335052012-03-10 03:05:10 +0000805 Expr::EvalResult result;
806 bool resultIsReference;
807 QualType resultType;
808
809 // It's best to evaluate all the way as an r-value if that's permitted.
810 if (CEK != CEK_AsReferenceOnly &&
John McCall113bee02012-03-10 09:33:50 +0000811 refExpr->EvaluateAsRValue(result, getContext())) {
John McCall71335052012-03-10 03:05:10 +0000812 resultIsReference = false;
813 resultType = refExpr->getType();
814
815 // Otherwise, try to evaluate as an l-value.
816 } else if (CEK != CEK_AsValueOnly &&
John McCall113bee02012-03-10 09:33:50 +0000817 refExpr->EvaluateAsLValue(result, getContext())) {
John McCall71335052012-03-10 03:05:10 +0000818 resultIsReference = true;
819 resultType = value->getType();
820
821 // Failure.
822 } else {
823 return ConstantEmission();
824 }
825
826 // In any case, if the initializer has side-effects, abandon ship.
827 if (result.HasSideEffects)
828 return ConstantEmission();
829
830 // Emit as a constant.
831 llvm::Constant *C = CGM.EmitConstantValue(result.Val, resultType, this);
832
833 // Make sure we emit a debug reference to the global variable.
834 // This should probably fire even for
835 if (isa<VarDecl>(value)) {
836 if (!getContext().DeclMustBeEmitted(cast<VarDecl>(value)))
John McCall113bee02012-03-10 09:33:50 +0000837 EmitDeclRefExprDbgValue(refExpr, C);
John McCall71335052012-03-10 03:05:10 +0000838 } else {
839 assert(isa<EnumConstantDecl>(value));
John McCall113bee02012-03-10 09:33:50 +0000840 EmitDeclRefExprDbgValue(refExpr, C);
John McCall71335052012-03-10 03:05:10 +0000841 }
842
843 // If we emitted a reference constant, we need to dereference that.
844 if (resultIsReference)
845 return ConstantEmission::forReference(C);
846
847 return ConstantEmission::forValue(C);
848}
849
John McCall1553b192011-06-16 04:16:24 +0000850llvm::Value *CodeGenFunction::EmitLoadOfScalar(LValue lvalue) {
851 return EmitLoadOfScalar(lvalue.getAddress(), lvalue.isVolatile(),
Eli Friedmana0544d62011-12-03 04:14:32 +0000852 lvalue.getAlignment().getQuantity(),
853 lvalue.getType(), lvalue.getTBAAInfo());
John McCall1553b192011-06-16 04:16:24 +0000854}
855
Rafael Espindola5c0034a2012-03-24 16:50:34 +0000856static bool hasBooleanRepresentation(QualType Ty) {
857 if (Ty->isBooleanType())
858 return true;
859
860 if (const EnumType *ET = Ty->getAs<EnumType>())
861 return ET->getDecl()->getIntegerType()->isBooleanType();
862
Douglas Gregor298f43d2012-04-12 20:42:30 +0000863 if (const AtomicType *AT = Ty->getAs<AtomicType>())
864 return hasBooleanRepresentation(AT->getValueType());
865
Rafael Espindola5c0034a2012-03-24 16:50:34 +0000866 return false;
867}
868
869llvm::MDNode *CodeGenFunction::getRangeForLoadFromType(QualType Ty) {
870 const EnumType *ET = Ty->getAs<EnumType>();
Chandler Carruth8b4140d2012-03-27 23:58:37 +0000871 bool IsRegularCPlusPlusEnum = (getLangOpts().CPlusPlus && ET &&
872 CGM.getCodeGenOpts().StrictEnums &&
873 !ET->getDecl()->isFixed());
Rafael Espindola5c0034a2012-03-24 16:50:34 +0000874 bool IsBool = hasBooleanRepresentation(Ty);
Rafael Espindola5c0034a2012-03-24 16:50:34 +0000875 if (!IsBool && !IsRegularCPlusPlusEnum)
876 return NULL;
877
878 llvm::APInt Min;
879 llvm::APInt End;
880 if (IsBool) {
881 Min = llvm::APInt(8, 0);
882 End = llvm::APInt(8, 2);
Rafael Espindola5c0034a2012-03-24 16:50:34 +0000883 } else {
884 const EnumDecl *ED = ET->getDecl();
Ted Kremenekdb74d0b2012-05-01 17:56:53 +0000885 llvm::Type *LTy = ConvertTypeForMem(ED->getIntegerType());
Rafael Espindola5c0034a2012-03-24 16:50:34 +0000886 unsigned Bitwidth = LTy->getScalarSizeInBits();
887 unsigned NumNegativeBits = ED->getNumNegativeBits();
888 unsigned NumPositiveBits = ED->getNumPositiveBits();
889
890 if (NumNegativeBits) {
891 unsigned NumBits = std::max(NumNegativeBits, NumPositiveBits + 1);
892 assert(NumBits <= Bitwidth);
893 End = llvm::APInt(Bitwidth, 1) << (NumBits - 1);
894 Min = -End;
895 } else {
896 assert(NumPositiveBits <= Bitwidth);
897 End = llvm::APInt(Bitwidth, 1) << NumPositiveBits;
898 Min = llvm::APInt(Bitwidth, 0);
899 }
900 }
901
Duncan Sandsc720e782012-04-15 18:04:54 +0000902 llvm::MDBuilder MDHelper(getLLVMContext());
Duncan Sands65229ed2012-04-16 16:29:47 +0000903 return MDHelper.createRange(Min, End);
Rafael Espindola5c0034a2012-03-24 16:50:34 +0000904}
905
Daniel Dunbar1d425462009-02-10 00:57:50 +0000906llvm::Value *CodeGenFunction::EmitLoadOfScalar(llvm::Value *Addr, bool Volatile,
Dan Gohman947c9af2010-10-14 23:06:10 +0000907 unsigned Alignment, QualType Ty,
908 llvm::MDNode *TBAAInfo) {
Benjamin Kramer76399eb2011-09-27 21:06:10 +0000909 llvm::LoadInst *Load = Builder.CreateLoad(Addr);
Daniel Dunbarc76493a2009-11-29 21:23:36 +0000910 if (Volatile)
911 Load->setVolatile(true);
Daniel Dunbar03816342010-08-21 02:24:36 +0000912 if (Alignment)
913 Load->setAlignment(Alignment);
Dan Gohman947c9af2010-10-14 23:06:10 +0000914 if (TBAAInfo)
915 CGM.DecorateInstruction(Load, TBAAInfo);
David Chisnallfa35df62012-01-16 17:27:18 +0000916 // If this is an atomic type, all normal reads must be atomic
917 if (Ty->isAtomicType())
918 Load->setAtomic(llvm::SequentiallyConsistent);
Daniel Dunbar1d425462009-02-10 00:57:50 +0000919
Rafael Espindola5c0034a2012-03-24 16:50:34 +0000920 if (CGM.getCodeGenOpts().OptimizationLevel > 0)
921 if (llvm::MDNode *RangeInfo = getRangeForLoadFromType(Ty))
922 Load->setMetadata(llvm::LLVMContext::MD_range, RangeInfo);
Douglas Gregor0bf31402010-10-08 23:50:27 +0000923
Rafael Espindola5c0034a2012-03-24 16:50:34 +0000924 return EmitFromMemory(Load, Ty);
NAKAMURA Takumi2681efc2012-03-24 14:43:42 +0000925}
926
John McCall3a7f6922010-10-27 20:58:56 +0000927llvm::Value *CodeGenFunction::EmitToMemory(llvm::Value *Value, QualType Ty) {
928 // Bool has a different representation in memory than in registers.
Rafael Espindola5c0034a2012-03-24 16:50:34 +0000929 if (hasBooleanRepresentation(Ty)) {
John McCall3a7f6922010-10-27 20:58:56 +0000930 // This should really always be an i1, but sometimes it's already
931 // an i8, and it's awkward to track those cases down.
932 if (Value->getType()->isIntegerTy(1))
933 return Builder.CreateZExt(Value, Builder.getInt8Ty(), "frombool");
934 assert(Value->getType()->isIntegerTy(8) && "value rep of bool not i1/i8");
935 }
936
937 return Value;
938}
939
940llvm::Value *CodeGenFunction::EmitFromMemory(llvm::Value *Value, QualType Ty) {
941 // Bool has a different representation in memory than in registers.
Rafael Espindola5c0034a2012-03-24 16:50:34 +0000942 if (hasBooleanRepresentation(Ty)) {
John McCall3a7f6922010-10-27 20:58:56 +0000943 assert(Value->getType()->isIntegerTy(8) && "memory rep of bool not i8");
944 return Builder.CreateTrunc(Value, Builder.getInt1Ty(), "tobool");
945 }
946
947 return Value;
948}
949
Daniel Dunbar1d425462009-02-10 00:57:50 +0000950void CodeGenFunction::EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr,
Daniel Dunbar03816342010-08-21 02:24:36 +0000951 bool Volatile, unsigned Alignment,
Dan Gohman947c9af2010-10-14 23:06:10 +0000952 QualType Ty,
David Chisnallfa35df62012-01-16 17:27:18 +0000953 llvm::MDNode *TBAAInfo,
954 bool isInit) {
John McCall3a7f6922010-10-27 20:58:56 +0000955 Value = EmitToMemory(Value, Ty);
Chris Lattner1a5f8972011-07-10 03:38:35 +0000956
Daniel Dunbar03816342010-08-21 02:24:36 +0000957 llvm::StoreInst *Store = Builder.CreateStore(Value, Addr, Volatile);
958 if (Alignment)
959 Store->setAlignment(Alignment);
Dan Gohman947c9af2010-10-14 23:06:10 +0000960 if (TBAAInfo)
961 CGM.DecorateInstruction(Store, TBAAInfo);
David Chisnallfa35df62012-01-16 17:27:18 +0000962 if (!isInit && Ty->isAtomicType())
963 Store->setAtomic(llvm::SequentiallyConsistent);
Daniel Dunbar1d425462009-02-10 00:57:50 +0000964}
965
David Chisnallfa35df62012-01-16 17:27:18 +0000966void CodeGenFunction::EmitStoreOfScalar(llvm::Value *value, LValue lvalue,
967 bool isInit) {
John McCall1553b192011-06-16 04:16:24 +0000968 EmitStoreOfScalar(value, lvalue.getAddress(), lvalue.isVolatile(),
Eli Friedmana0544d62011-12-03 04:14:32 +0000969 lvalue.getAlignment().getQuantity(), lvalue.getType(),
David Chisnallfa35df62012-01-16 17:27:18 +0000970 lvalue.getTBAAInfo(), isInit);
John McCall1553b192011-06-16 04:16:24 +0000971}
972
Mike Stump4a3999f2009-09-09 13:00:44 +0000973/// EmitLoadOfLValue - Given an expression that represents a value lvalue, this
974/// method emits the address of the lvalue, then loads the result as an rvalue,
975/// returning the rvalue.
John McCall55e1fbc2011-06-25 02:11:03 +0000976RValue CodeGenFunction::EmitLoadOfLValue(LValue LV) {
Fariborz Jahanian50a12702008-11-19 17:34:06 +0000977 if (LV.isObjCWeak()) {
Mike Stump4a3999f2009-09-09 13:00:44 +0000978 // load of a __weak object.
Fariborz Jahanianf5125d12008-11-18 21:45:40 +0000979 llvm::Value *AddrWeakObj = LV.getAddress();
Chris Lattnerab5e0af2009-10-28 17:39:19 +0000980 return RValue::get(CGM.getObjCRuntime().EmitObjCWeakRead(*this,
981 AddrWeakObj));
Fariborz Jahanianf5125d12008-11-18 21:45:40 +0000982 }
John McCall31168b02011-06-15 23:02:42 +0000983 if (LV.getQuals().getObjCLifetime() == Qualifiers::OCL_Weak)
984 return RValue::get(EmitARCLoadWeak(LV.getAddress()));
Mike Stump4a3999f2009-09-09 13:00:44 +0000985
Chris Lattner08c4b9f2007-07-10 21:17:59 +0000986 if (LV.isSimple()) {
John McCalld68b2d02011-06-27 21:24:11 +0000987 assert(!LV.getType()->isFunctionType());
Mike Stump4a3999f2009-09-09 13:00:44 +0000988
John McCalla1dee5302010-08-22 10:59:02 +0000989 // Everything needs a load.
John McCall55e1fbc2011-06-25 02:11:03 +0000990 return RValue::get(EmitLoadOfScalar(LV));
Chris Lattner08c4b9f2007-07-10 21:17:59 +0000991 }
Mike Stump4a3999f2009-09-09 13:00:44 +0000992
Chris Lattner08c4b9f2007-07-10 21:17:59 +0000993 if (LV.isVectorElt()) {
Eli Friedman610bb872012-03-22 22:36:39 +0000994 llvm::LoadInst *Load = Builder.CreateLoad(LV.getVectorAddr(),
995 LV.isVolatileQualified());
996 Load->setAlignment(LV.getAlignment().getQuantity());
997 return RValue::get(Builder.CreateExtractElement(Load, LV.getVectorIdx(),
Chris Lattner08c4b9f2007-07-10 21:17:59 +0000998 "vecext"));
999 }
Chris Lattner73ab9b32007-08-03 00:16:29 +00001000
1001 // If this is a reference to a subset of the elements of a vector, either
1002 // shuffle the input or extract/insert them as appropriate.
Nate Begemance4d7fc2008-04-18 23:10:10 +00001003 if (LV.isExtVectorElt())
John McCall55e1fbc2011-06-25 02:11:03 +00001004 return EmitLoadOfExtVectorElementLValue(LV);
Lauro Ramos Venancio2ddcb25a32008-01-22 20:17:04 +00001005
John McCallc109a252011-11-07 03:59:57 +00001006 assert(LV.isBitField() && "Unknown LValue type!");
1007 return EmitLoadOfBitfieldLValue(LV);
Chris Lattner8394d792007-06-05 20:53:16 +00001008}
1009
John McCall55e1fbc2011-06-25 02:11:03 +00001010RValue CodeGenFunction::EmitLoadOfBitfieldLValue(LValue LV) {
Daniel Dunbar196ea442010-04-06 01:07:44 +00001011 const CGBitFieldInfo &Info = LV.getBitFieldInfo();
Daniel Dunbaread7c912008-08-06 05:08:45 +00001012
Daniel Dunbar3447a022010-04-13 23:34:15 +00001013 // Get the output type.
Chris Lattner2192fe52011-07-18 04:24:23 +00001014 llvm::Type *ResLTy = ConvertType(LV.getType());
Daniel Dunbar3447a022010-04-13 23:34:15 +00001015 unsigned ResSizeInBits = CGM.getTargetData().getTypeSizeInBits(ResLTy);
Lauro Ramos Venancio2ddcb25a32008-01-22 20:17:04 +00001016
Daniel Dunbar3447a022010-04-13 23:34:15 +00001017 // Compute the result as an OR of all of the individual component accesses.
1018 llvm::Value *Res = 0;
1019 for (unsigned i = 0, e = Info.getNumComponents(); i != e; ++i) {
1020 const CGBitFieldInfo::AccessInfo &AI = Info.getComponent(i);
Mike Stump4a3999f2009-09-09 13:00:44 +00001021
Daniel Dunbar3447a022010-04-13 23:34:15 +00001022 // Get the field pointer.
1023 llvm::Value *Ptr = LV.getBitFieldBaseAddr();
Mike Stump4a3999f2009-09-09 13:00:44 +00001024
Daniel Dunbar3447a022010-04-13 23:34:15 +00001025 // Only offset by the field index if used, so that incoming values are not
1026 // required to be structures.
1027 if (AI.FieldIndex)
1028 Ptr = Builder.CreateStructGEP(Ptr, AI.FieldIndex, "bf.field");
Mike Stump4a3999f2009-09-09 13:00:44 +00001029
Daniel Dunbar3447a022010-04-13 23:34:15 +00001030 // Offset by the byte offset, if used.
Ken Dyckf76759c2011-04-24 10:04:59 +00001031 if (!AI.FieldByteOffset.isZero()) {
John McCallad7c5c12011-02-08 08:22:06 +00001032 Ptr = EmitCastToVoidPtr(Ptr);
Ken Dyckf76759c2011-04-24 10:04:59 +00001033 Ptr = Builder.CreateConstGEP1_32(Ptr, AI.FieldByteOffset.getQuantity(),
1034 "bf.field.offs");
Daniel Dunbar3447a022010-04-13 23:34:15 +00001035 }
Mike Stump4a3999f2009-09-09 13:00:44 +00001036
Daniel Dunbar3447a022010-04-13 23:34:15 +00001037 // Cast to the access type.
Chris Lattnerece04092012-02-07 00:39:47 +00001038 llvm::Type *PTy = llvm::Type::getIntNPtrTy(getLLVMContext(), AI.AccessWidth,
John McCall55e1fbc2011-06-25 02:11:03 +00001039 CGM.getContext().getTargetAddressSpace(LV.getType()));
Daniel Dunbar3447a022010-04-13 23:34:15 +00001040 Ptr = Builder.CreateBitCast(Ptr, PTy);
Lauro Ramos Venancio2ddcb25a32008-01-22 20:17:04 +00001041
Daniel Dunbar3447a022010-04-13 23:34:15 +00001042 // Perform the load.
1043 llvm::LoadInst *Load = Builder.CreateLoad(Ptr, LV.isVolatileQualified());
Ken Dyck27337a82011-04-24 10:13:17 +00001044 if (!AI.AccessAlignment.isZero())
1045 Load->setAlignment(AI.AccessAlignment.getQuantity());
Daniel Dunbar3447a022010-04-13 23:34:15 +00001046
1047 // Shift out unused low bits and mask out unused high bits.
1048 llvm::Value *Val = Load;
1049 if (AI.FieldBitStart)
Daniel Dunbar67aba792010-04-15 03:47:33 +00001050 Val = Builder.CreateLShr(Load, AI.FieldBitStart);
Daniel Dunbar3447a022010-04-13 23:34:15 +00001051 Val = Builder.CreateAnd(Val, llvm::APInt::getLowBitsSet(AI.AccessWidth,
1052 AI.TargetBitWidth),
1053 "bf.clear");
1054
1055 // Extend or truncate to the target size.
1056 if (AI.AccessWidth < ResSizeInBits)
1057 Val = Builder.CreateZExt(Val, ResLTy);
1058 else if (AI.AccessWidth > ResSizeInBits)
1059 Val = Builder.CreateTrunc(Val, ResLTy);
1060
1061 // Shift into place, and OR into the result.
1062 if (AI.TargetBitOffset)
1063 Val = Builder.CreateShl(Val, AI.TargetBitOffset);
1064 Res = Res ? Builder.CreateOr(Res, Val) : Val;
Daniel Dunbaread7c912008-08-06 05:08:45 +00001065 }
Lauro Ramos Venancio2ddcb25a32008-01-22 20:17:04 +00001066
Daniel Dunbar3447a022010-04-13 23:34:15 +00001067 // If the bit-field is signed, perform the sign-extension.
1068 //
1069 // FIXME: This can easily be folded into the load of the high bits, which
1070 // could also eliminate the mask of high bits in some situations.
1071 if (Info.isSigned()) {
Daniel Dunbar67aba792010-04-15 03:47:33 +00001072 unsigned ExtraBits = ResSizeInBits - Info.getSize();
Daniel Dunbar3447a022010-04-13 23:34:15 +00001073 if (ExtraBits)
1074 Res = Builder.CreateAShr(Builder.CreateShl(Res, ExtraBits),
1075 ExtraBits, "bf.val.sext");
Daniel Dunbaread7c912008-08-06 05:08:45 +00001076 }
Eli Friedmanf2442dc2008-05-17 20:03:47 +00001077
Daniel Dunbar3447a022010-04-13 23:34:15 +00001078 return RValue::get(Res);
Lauro Ramos Venancio2ddcb25a32008-01-22 20:17:04 +00001079}
1080
Nate Begemanb699c9b2009-01-18 06:42:49 +00001081// If this is a reference to a subset of the elements of a vector, create an
1082// appropriate shufflevector.
John McCall55e1fbc2011-06-25 02:11:03 +00001083RValue CodeGenFunction::EmitLoadOfExtVectorElementLValue(LValue LV) {
Eli Friedman610bb872012-03-22 22:36:39 +00001084 llvm::LoadInst *Load = Builder.CreateLoad(LV.getExtVectorAddr(),
1085 LV.isVolatileQualified());
1086 Load->setAlignment(LV.getAlignment().getQuantity());
1087 llvm::Value *Vec = Load;
Mike Stump4a3999f2009-09-09 13:00:44 +00001088
Nate Begemanf322eab2008-05-09 06:41:27 +00001089 const llvm::Constant *Elts = LV.getExtVectorElts();
Mike Stump4a3999f2009-09-09 13:00:44 +00001090
1091 // If the result of the expression is a non-vector type, we must be extracting
1092 // a single element. Just codegen as an extractelement.
John McCall55e1fbc2011-06-25 02:11:03 +00001093 const VectorType *ExprVT = LV.getType()->getAs<VectorType>();
Chris Lattner8eab8ff2007-08-10 17:10:08 +00001094 if (!ExprVT) {
Dan Gohman75d69da2008-05-22 00:50:06 +00001095 unsigned InIdx = getAccessedFieldNo(0, Elts);
Chris Lattner5e016ae2010-06-27 07:15:29 +00001096 llvm::Value *Elt = llvm::ConstantInt::get(Int32Ty, InIdx);
Benjamin Kramer76399eb2011-09-27 21:06:10 +00001097 return RValue::get(Builder.CreateExtractElement(Vec, Elt));
Chris Lattner40ff7012007-08-03 16:18:34 +00001098 }
Nate Begemanb699c9b2009-01-18 06:42:49 +00001099
1100 // Always use shuffle vector to try to retain the original program structure
Chris Lattner8eab8ff2007-08-10 17:10:08 +00001101 unsigned NumResultElts = ExprVT->getNumElements();
Mike Stump4a3999f2009-09-09 13:00:44 +00001102
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001103 SmallVector<llvm::Constant*, 4> Mask;
Chris Lattner2d6b7b92012-01-25 05:34:41 +00001104 for (unsigned i = 0; i != NumResultElts; ++i)
1105 Mask.push_back(Builder.getInt32(getAccessedFieldNo(i, Elts)));
Mike Stump4a3999f2009-09-09 13:00:44 +00001106
Chris Lattner91c08ad2011-02-15 00:14:06 +00001107 llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
1108 Vec = Builder.CreateShuffleVector(Vec, llvm::UndefValue::get(Vec->getType()),
Benjamin Kramer76399eb2011-09-27 21:06:10 +00001109 MaskV);
Nate Begemanb699c9b2009-01-18 06:42:49 +00001110 return RValue::get(Vec);
Chris Lattner40ff7012007-08-03 16:18:34 +00001111}
1112
1113
Chris Lattner9369a562007-06-29 16:31:29 +00001114
Chris Lattner8394d792007-06-05 20:53:16 +00001115/// EmitStoreThroughLValue - Store the specified rvalue into the specified
1116/// lvalue, where both are guaranteed to the have the same type, and that type
1117/// is 'Ty'.
David Chisnallfa35df62012-01-16 17:27:18 +00001118void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit) {
Chris Lattner41d480e2007-08-03 16:28:33 +00001119 if (!Dst.isSimple()) {
1120 if (Dst.isVectorElt()) {
1121 // Read/modify/write the vector, inserting the new element.
Eli Friedman610bb872012-03-22 22:36:39 +00001122 llvm::LoadInst *Load = Builder.CreateLoad(Dst.getVectorAddr(),
1123 Dst.isVolatileQualified());
1124 Load->setAlignment(Dst.getAlignment().getQuantity());
1125 llvm::Value *Vec = Load;
Chris Lattner4647a212007-08-31 22:49:20 +00001126 Vec = Builder.CreateInsertElement(Vec, Src.getScalarVal(),
Chris Lattner41d480e2007-08-03 16:28:33 +00001127 Dst.getVectorIdx(), "vecins");
Eli Friedman610bb872012-03-22 22:36:39 +00001128 llvm::StoreInst *Store = Builder.CreateStore(Vec, Dst.getVectorAddr(),
1129 Dst.isVolatileQualified());
1130 Store->setAlignment(Dst.getAlignment().getQuantity());
Chris Lattner41d480e2007-08-03 16:28:33 +00001131 return;
1132 }
Mike Stump4a3999f2009-09-09 13:00:44 +00001133
Nate Begemance4d7fc2008-04-18 23:10:10 +00001134 // If this is an update of extended vector elements, insert them as
1135 // appropriate.
1136 if (Dst.isExtVectorElt())
John McCall55e1fbc2011-06-25 02:11:03 +00001137 return EmitStoreThroughExtVectorComponentLValue(Src, Dst);
Lauro Ramos Venancio09af71c2008-01-22 22:36:45 +00001138
John McCallc109a252011-11-07 03:59:57 +00001139 assert(Dst.isBitField() && "Unknown LValue type");
1140 return EmitStoreThroughBitfieldLValue(Src, Dst);
Chris Lattner41d480e2007-08-03 16:28:33 +00001141 }
Mike Stump4a3999f2009-09-09 13:00:44 +00001142
John McCall31168b02011-06-15 23:02:42 +00001143 // There's special magic for assigning into an ARC-qualified l-value.
1144 if (Qualifiers::ObjCLifetime Lifetime = Dst.getQuals().getObjCLifetime()) {
1145 switch (Lifetime) {
1146 case Qualifiers::OCL_None:
1147 llvm_unreachable("present but none");
1148
1149 case Qualifiers::OCL_ExplicitNone:
1150 // nothing special
1151 break;
1152
1153 case Qualifiers::OCL_Strong:
John McCall55e1fbc2011-06-25 02:11:03 +00001154 EmitARCStoreStrong(Dst, Src.getScalarVal(), /*ignore*/ true);
John McCall31168b02011-06-15 23:02:42 +00001155 return;
1156
1157 case Qualifiers::OCL_Weak:
1158 EmitARCStoreWeak(Dst.getAddress(), Src.getScalarVal(), /*ignore*/ true);
1159 return;
1160
1161 case Qualifiers::OCL_Autoreleasing:
John McCall55e1fbc2011-06-25 02:11:03 +00001162 Src = RValue::get(EmitObjCExtendObjectLifetime(Dst.getType(),
1163 Src.getScalarVal()));
John McCall31168b02011-06-15 23:02:42 +00001164 // fall into the normal path
1165 break;
1166 }
1167 }
1168
Fariborz Jahanian10bec102009-02-21 00:30:43 +00001169 if (Dst.isObjCWeak() && !Dst.isNonGC()) {
Mike Stump4a3999f2009-09-09 13:00:44 +00001170 // load of a __weak object.
Fariborz Jahanian50a12702008-11-19 17:34:06 +00001171 llvm::Value *LvalueDst = Dst.getAddress();
1172 llvm::Value *src = Src.getScalarVal();
Mike Stumpca5ae662009-04-14 00:57:29 +00001173 CGM.getObjCRuntime().EmitObjCWeakAssign(*this, src, LvalueDst);
Fariborz Jahanian50a12702008-11-19 17:34:06 +00001174 return;
1175 }
Mike Stump4a3999f2009-09-09 13:00:44 +00001176
Fariborz Jahanian10bec102009-02-21 00:30:43 +00001177 if (Dst.isObjCStrong() && !Dst.isNonGC()) {
Mike Stump4a3999f2009-09-09 13:00:44 +00001178 // load of a __strong object.
Fariborz Jahanian50a12702008-11-19 17:34:06 +00001179 llvm::Value *LvalueDst = Dst.getAddress();
1180 llvm::Value *src = Src.getScalarVal();
Fariborz Jahanian7a95d722009-09-24 22:25:38 +00001181 if (Dst.isObjCIvar()) {
1182 assert(Dst.getBaseIvarExp() && "BaseIvarExp is NULL");
Chris Lattner2192fe52011-07-18 04:24:23 +00001183 llvm::Type *ResultType = ConvertType(getContext().LongTy);
Fariborz Jahanian7a95d722009-09-24 22:25:38 +00001184 llvm::Value *RHS = EmitScalarExpr(Dst.getBaseIvarExp());
Fariborz Jahanian1f9ed582009-09-25 00:00:20 +00001185 llvm::Value *dst = RHS;
Fariborz Jahanian7a95d722009-09-24 22:25:38 +00001186 RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast");
1187 llvm::Value *LHS =
1188 Builder.CreatePtrToInt(LvalueDst, ResultType, "sub.ptr.lhs.cast");
1189 llvm::Value *BytesBetween = Builder.CreateSub(LHS, RHS, "ivar.offset");
Fariborz Jahanian1f9ed582009-09-25 00:00:20 +00001190 CGM.getObjCRuntime().EmitObjCIvarAssign(*this, src, dst,
Fariborz Jahanian7a95d722009-09-24 22:25:38 +00001191 BytesBetween);
Fariborz Jahanian217af242010-07-20 20:30:03 +00001192 } else if (Dst.isGlobalObjCRef()) {
1193 CGM.getObjCRuntime().EmitObjCGlobalAssign(*this, src, LvalueDst,
1194 Dst.isThreadLocalRef());
1195 }
Fariborz Jahanian32ff7ae2009-05-04 23:27:20 +00001196 else
1197 CGM.getObjCRuntime().EmitObjCStrongCastAssign(*this, src, LvalueDst);
Fariborz Jahanian50a12702008-11-19 17:34:06 +00001198 return;
1199 }
Mike Stump4a3999f2009-09-09 13:00:44 +00001200
Chris Lattner6278e6a2007-08-11 00:04:45 +00001201 assert(Src.isScalar() && "Can't emit an agg store with this method");
David Chisnallfa35df62012-01-16 17:27:18 +00001202 EmitStoreOfScalar(Src.getScalarVal(), Dst, isInit);
Chris Lattner8394d792007-06-05 20:53:16 +00001203}
1204
Lauro Ramos Venancio09af71c2008-01-22 22:36:45 +00001205void CodeGenFunction::EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst,
Daniel Dunbar9b1335e2008-11-19 09:36:46 +00001206 llvm::Value **Result) {
Daniel Dunbar196ea442010-04-06 01:07:44 +00001207 const CGBitFieldInfo &Info = Dst.getBitFieldInfo();
Lauro Ramos Venancio09af71c2008-01-22 22:36:45 +00001208
Daniel Dunbar67aba792010-04-15 03:47:33 +00001209 // Get the output type.
Chris Lattner2192fe52011-07-18 04:24:23 +00001210 llvm::Type *ResLTy = ConvertTypeForMem(Dst.getType());
Daniel Dunbar67aba792010-04-15 03:47:33 +00001211 unsigned ResSizeInBits = CGM.getTargetData().getTypeSizeInBits(ResLTy);
Daniel Dunbaread7c912008-08-06 05:08:45 +00001212
Daniel Dunbar67aba792010-04-15 03:47:33 +00001213 // Get the source value, truncated to the width of the bit-field.
Daniel Dunbar9b1335e2008-11-19 09:36:46 +00001214 llvm::Value *SrcVal = Src.getScalarVal();
Anders Carlsson8345a702010-04-17 21:52:22 +00001215
Douglas Gregor298f43d2012-04-12 20:42:30 +00001216 if (hasBooleanRepresentation(Dst.getType()))
Anders Carlsson8345a702010-04-17 21:52:22 +00001217 SrcVal = Builder.CreateIntCast(SrcVal, ResLTy, /*IsSigned=*/false);
1218
Daniel Dunbar67aba792010-04-15 03:47:33 +00001219 SrcVal = Builder.CreateAnd(SrcVal, llvm::APInt::getLowBitsSet(ResSizeInBits,
1220 Info.getSize()),
1221 "bf.value");
Lauro Ramos Venancio09af71c2008-01-22 22:36:45 +00001222
Daniel Dunbar9b1335e2008-11-19 09:36:46 +00001223 // Return the new value of the bit-field, if requested.
1224 if (Result) {
1225 // Cast back to the proper type for result.
Chris Lattner2192fe52011-07-18 04:24:23 +00001226 llvm::Type *SrcTy = Src.getScalarVal()->getType();
Daniel Dunbar67aba792010-04-15 03:47:33 +00001227 llvm::Value *ReloadVal = Builder.CreateIntCast(SrcVal, SrcTy, false,
1228 "bf.reload.val");
Daniel Dunbar9b1335e2008-11-19 09:36:46 +00001229
1230 // Sign extend if necessary.
Daniel Dunbar67aba792010-04-15 03:47:33 +00001231 if (Info.isSigned()) {
1232 unsigned ExtraBits = ResSizeInBits - Info.getSize();
1233 if (ExtraBits)
1234 ReloadVal = Builder.CreateAShr(Builder.CreateShl(ReloadVal, ExtraBits),
1235 ExtraBits, "bf.reload.sext");
Daniel Dunbar9b1335e2008-11-19 09:36:46 +00001236 }
1237
Daniel Dunbar67aba792010-04-15 03:47:33 +00001238 *Result = ReloadVal;
Daniel Dunbar9b1335e2008-11-19 09:36:46 +00001239 }
1240
Daniel Dunbar67aba792010-04-15 03:47:33 +00001241 // Iterate over the components, writing each piece to memory.
1242 for (unsigned i = 0, e = Info.getNumComponents(); i != e; ++i) {
1243 const CGBitFieldInfo::AccessInfo &AI = Info.getComponent(i);
Eli Friedmanf2442dc2008-05-17 20:03:47 +00001244
Daniel Dunbar67aba792010-04-15 03:47:33 +00001245 // Get the field pointer.
1246 llvm::Value *Ptr = Dst.getBitFieldBaseAddr();
John McCallad7c5c12011-02-08 08:22:06 +00001247 unsigned addressSpace =
1248 cast<llvm::PointerType>(Ptr->getType())->getAddressSpace();
Mike Stump4a3999f2009-09-09 13:00:44 +00001249
Daniel Dunbar67aba792010-04-15 03:47:33 +00001250 // Only offset by the field index if used, so that incoming values are not
1251 // required to be structures.
1252 if (AI.FieldIndex)
1253 Ptr = Builder.CreateStructGEP(Ptr, AI.FieldIndex, "bf.field");
Mike Stump4a3999f2009-09-09 13:00:44 +00001254
Daniel Dunbar67aba792010-04-15 03:47:33 +00001255 // Offset by the byte offset, if used.
Ken Dyckf76759c2011-04-24 10:04:59 +00001256 if (!AI.FieldByteOffset.isZero()) {
John McCallad7c5c12011-02-08 08:22:06 +00001257 Ptr = EmitCastToVoidPtr(Ptr);
Ken Dyckf76759c2011-04-24 10:04:59 +00001258 Ptr = Builder.CreateConstGEP1_32(Ptr, AI.FieldByteOffset.getQuantity(),
1259 "bf.field.offs");
Daniel Dunbar67aba792010-04-15 03:47:33 +00001260 }
Eli Friedmanf2442dc2008-05-17 20:03:47 +00001261
Daniel Dunbar67aba792010-04-15 03:47:33 +00001262 // Cast to the access type.
Chris Lattner2192fe52011-07-18 04:24:23 +00001263 llvm::Type *AccessLTy =
John McCallad7c5c12011-02-08 08:22:06 +00001264 llvm::Type::getIntNTy(getLLVMContext(), AI.AccessWidth);
1265
Chris Lattner2192fe52011-07-18 04:24:23 +00001266 llvm::Type *PTy = AccessLTy->getPointerTo(addressSpace);
Daniel Dunbar67aba792010-04-15 03:47:33 +00001267 Ptr = Builder.CreateBitCast(Ptr, PTy);
Mike Stump4a3999f2009-09-09 13:00:44 +00001268
Daniel Dunbar67aba792010-04-15 03:47:33 +00001269 // Extract the piece of the bit-field value to write in this access, limited
1270 // to the values that are part of this access.
1271 llvm::Value *Val = SrcVal;
1272 if (AI.TargetBitOffset)
1273 Val = Builder.CreateLShr(Val, AI.TargetBitOffset);
1274 Val = Builder.CreateAnd(Val, llvm::APInt::getLowBitsSet(ResSizeInBits,
1275 AI.TargetBitWidth));
Mike Stump4a3999f2009-09-09 13:00:44 +00001276
Daniel Dunbar67aba792010-04-15 03:47:33 +00001277 // Extend or truncate to the access size.
Daniel Dunbar67aba792010-04-15 03:47:33 +00001278 if (ResSizeInBits < AI.AccessWidth)
1279 Val = Builder.CreateZExt(Val, AccessLTy);
1280 else if (ResSizeInBits > AI.AccessWidth)
1281 Val = Builder.CreateTrunc(Val, AccessLTy);
Mike Stump4a3999f2009-09-09 13:00:44 +00001282
Daniel Dunbar67aba792010-04-15 03:47:33 +00001283 // Shift into the position in memory.
1284 if (AI.FieldBitStart)
1285 Val = Builder.CreateShl(Val, AI.FieldBitStart);
1286
1287 // If necessary, load and OR in bits that are outside of the bit-field.
1288 if (AI.TargetBitWidth != AI.AccessWidth) {
1289 llvm::LoadInst *Load = Builder.CreateLoad(Ptr, Dst.isVolatileQualified());
Ken Dyck27337a82011-04-24 10:13:17 +00001290 if (!AI.AccessAlignment.isZero())
1291 Load->setAlignment(AI.AccessAlignment.getQuantity());
Daniel Dunbar67aba792010-04-15 03:47:33 +00001292
1293 // Compute the mask for zeroing the bits that are part of the bit-field.
1294 llvm::APInt InvMask =
1295 ~llvm::APInt::getBitsSet(AI.AccessWidth, AI.FieldBitStart,
1296 AI.FieldBitStart + AI.TargetBitWidth);
1297
1298 // Apply the mask and OR in to the value to write.
1299 Val = Builder.CreateOr(Builder.CreateAnd(Load, InvMask), Val);
1300 }
1301
1302 // Write the value.
1303 llvm::StoreInst *Store = Builder.CreateStore(Val, Ptr,
1304 Dst.isVolatileQualified());
Ken Dyck27337a82011-04-24 10:13:17 +00001305 if (!AI.AccessAlignment.isZero())
1306 Store->setAlignment(AI.AccessAlignment.getQuantity());
Daniel Dunbaread7c912008-08-06 05:08:45 +00001307 }
Lauro Ramos Venancio09af71c2008-01-22 22:36:45 +00001308}
1309
Nate Begemance4d7fc2008-04-18 23:10:10 +00001310void CodeGenFunction::EmitStoreThroughExtVectorComponentLValue(RValue Src,
John McCall55e1fbc2011-06-25 02:11:03 +00001311 LValue Dst) {
Chris Lattner41d480e2007-08-03 16:28:33 +00001312 // This access turns into a read/modify/write of the vector. Load the input
1313 // value now.
Eli Friedman610bb872012-03-22 22:36:39 +00001314 llvm::LoadInst *Load = Builder.CreateLoad(Dst.getExtVectorAddr(),
1315 Dst.isVolatileQualified());
1316 Load->setAlignment(Dst.getAlignment().getQuantity());
1317 llvm::Value *Vec = Load;
Nate Begemanf322eab2008-05-09 06:41:27 +00001318 const llvm::Constant *Elts = Dst.getExtVectorElts();
Mike Stump4a3999f2009-09-09 13:00:44 +00001319
Chris Lattner4647a212007-08-31 22:49:20 +00001320 llvm::Value *SrcVal = Src.getScalarVal();
Mike Stump4a3999f2009-09-09 13:00:44 +00001321
John McCall55e1fbc2011-06-25 02:11:03 +00001322 if (const VectorType *VTy = Dst.getType()->getAs<VectorType>()) {
Chris Lattner3a44aa72007-08-03 16:37:04 +00001323 unsigned NumSrcElts = VTy->getNumElements();
Nate Begemanb699c9b2009-01-18 06:42:49 +00001324 unsigned NumDstElts =
1325 cast<llvm::VectorType>(Vec->getType())->getNumElements();
1326 if (NumDstElts == NumSrcElts) {
Mike Stump4a3999f2009-09-09 13:00:44 +00001327 // Use shuffle vector is the src and destination are the same number of
1328 // elements and restore the vector mask since it is on the side it will be
1329 // stored.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001330 SmallVector<llvm::Constant*, 4> Mask(NumDstElts);
Chris Lattner2d6b7b92012-01-25 05:34:41 +00001331 for (unsigned i = 0; i != NumSrcElts; ++i)
1332 Mask[getAccessedFieldNo(i, Elts)] = Builder.getInt32(i);
Mike Stump4a3999f2009-09-09 13:00:44 +00001333
Chris Lattner91c08ad2011-02-15 00:14:06 +00001334 llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
Nate Begemanb699c9b2009-01-18 06:42:49 +00001335 Vec = Builder.CreateShuffleVector(SrcVal,
Owen Anderson7ec07a52009-07-30 23:11:26 +00001336 llvm::UndefValue::get(Vec->getType()),
Benjamin Kramer76399eb2011-09-27 21:06:10 +00001337 MaskV);
Mike Stump658fe022009-07-30 22:28:39 +00001338 } else if (NumDstElts > NumSrcElts) {
Nate Begemanb699c9b2009-01-18 06:42:49 +00001339 // Extended the source vector to the same length and then shuffle it
1340 // into the destination.
1341 // FIXME: since we're shuffling with undef, can we just use the indices
1342 // into that? This could be simpler.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001343 SmallVector<llvm::Constant*, 4> ExtMask;
Benjamin Kramer8001f742012-02-14 12:06:21 +00001344 for (unsigned i = 0; i != NumSrcElts; ++i)
Chris Lattner2d6b7b92012-01-25 05:34:41 +00001345 ExtMask.push_back(Builder.getInt32(i));
Benjamin Kramer8001f742012-02-14 12:06:21 +00001346 ExtMask.resize(NumDstElts, llvm::UndefValue::get(Int32Ty));
Chris Lattner91c08ad2011-02-15 00:14:06 +00001347 llvm::Value *ExtMaskV = llvm::ConstantVector::get(ExtMask);
Mike Stump4a3999f2009-09-09 13:00:44 +00001348 llvm::Value *ExtSrcVal =
Daniel Dunbar3d926cb2009-02-17 18:31:04 +00001349 Builder.CreateShuffleVector(SrcVal,
Owen Anderson7ec07a52009-07-30 23:11:26 +00001350 llvm::UndefValue::get(SrcVal->getType()),
Benjamin Kramer76399eb2011-09-27 21:06:10 +00001351 ExtMaskV);
Nate Begemanb699c9b2009-01-18 06:42:49 +00001352 // build identity
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001353 SmallVector<llvm::Constant*, 4> Mask;
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001354 for (unsigned i = 0; i != NumDstElts; ++i)
Chris Lattner2d6b7b92012-01-25 05:34:41 +00001355 Mask.push_back(Builder.getInt32(i));
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001356
Nate Begemanb699c9b2009-01-18 06:42:49 +00001357 // modify when what gets shuffled in
Chris Lattner2d6b7b92012-01-25 05:34:41 +00001358 for (unsigned i = 0; i != NumSrcElts; ++i)
1359 Mask[getAccessedFieldNo(i, Elts)] = Builder.getInt32(i+NumDstElts);
Chris Lattner91c08ad2011-02-15 00:14:06 +00001360 llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
Benjamin Kramer76399eb2011-09-27 21:06:10 +00001361 Vec = Builder.CreateShuffleVector(Vec, ExtSrcVal, MaskV);
Mike Stump658fe022009-07-30 22:28:39 +00001362 } else {
Nate Begemanb699c9b2009-01-18 06:42:49 +00001363 // We should never shorten the vector
David Blaikie83d382b2011-09-23 05:06:16 +00001364 llvm_unreachable("unexpected shorten vector length");
Chris Lattner3a44aa72007-08-03 16:37:04 +00001365 }
1366 } else {
1367 // If the Src is a scalar (not a vector) it must be updating one element.
Dan Gohman75d69da2008-05-22 00:50:06 +00001368 unsigned InIdx = getAccessedFieldNo(0, Elts);
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001369 llvm::Value *Elt = llvm::ConstantInt::get(Int32Ty, InIdx);
Benjamin Kramer76399eb2011-09-27 21:06:10 +00001370 Vec = Builder.CreateInsertElement(Vec, SrcVal, Elt);
Chris Lattner41d480e2007-08-03 16:28:33 +00001371 }
Mike Stump4a3999f2009-09-09 13:00:44 +00001372
Eli Friedman610bb872012-03-22 22:36:39 +00001373 llvm::StoreInst *Store = Builder.CreateStore(Vec, Dst.getExtVectorAddr(),
1374 Dst.isVolatileQualified());
1375 Store->setAlignment(Dst.getAlignment().getQuantity());
Chris Lattner41d480e2007-08-03 16:28:33 +00001376}
1377
Fariborz Jahaniana7fa6be2009-09-16 21:37:16 +00001378// setObjCGCLValueClass - sets class of he lvalue for the purpose of
1379// generating write-barries API. It is currently a global, ivar,
1380// or neither.
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001381static void setObjCGCLValueClass(const ASTContext &Ctx, const Expr *E,
Fariborz Jahanian0c784272011-09-30 18:23:36 +00001382 LValue &LV,
1383 bool IsMemberAccess=false) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00001384 if (Ctx.getLangOpts().getGC() == LangOptions::NonGC)
Fariborz Jahaniana7fa6be2009-09-16 21:37:16 +00001385 return;
1386
Fariborz Jahaniande1d3242009-09-16 23:11:23 +00001387 if (isa<ObjCIvarRefExpr>(E)) {
Fariborz Jahanian0c784272011-09-30 18:23:36 +00001388 QualType ExpTy = E->getType();
1389 if (IsMemberAccess && ExpTy->isPointerType()) {
1390 // If ivar is a structure pointer, assigning to field of
1391 // this struct follows gcc's behavior and makes it a non-ivar
1392 // writer-barrier conservatively.
1393 ExpTy = ExpTy->getAs<PointerType>()->getPointeeType();
1394 if (ExpTy->isRecordType()) {
1395 LV.setObjCIvar(false);
1396 return;
1397 }
1398 }
Daniel Dunbar4bb04ce2010-08-21 03:51:29 +00001399 LV.setObjCIvar(true);
Fariborz Jahanian7a95d722009-09-24 22:25:38 +00001400 ObjCIvarRefExpr *Exp = cast<ObjCIvarRefExpr>(const_cast<Expr*>(E));
1401 LV.setBaseIvarExp(Exp->getBase());
Daniel Dunbar4bb04ce2010-08-21 03:51:29 +00001402 LV.setObjCArray(E->getType()->isArrayType());
Fariborz Jahaniande1d3242009-09-16 23:11:23 +00001403 return;
1404 }
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001405
Fariborz Jahaniana7fa6be2009-09-16 21:37:16 +00001406 if (const DeclRefExpr *Exp = dyn_cast<DeclRefExpr>(E)) {
1407 if (const VarDecl *VD = dyn_cast<VarDecl>(Exp->getDecl())) {
John McCall1c9c3fd2010-10-15 04:57:14 +00001408 if (VD->hasGlobalStorage()) {
Daniel Dunbar4bb04ce2010-08-21 03:51:29 +00001409 LV.setGlobalObjCRef(true);
1410 LV.setThreadLocalRef(VD->isThreadSpecified());
Fariborz Jahanian217af242010-07-20 20:30:03 +00001411 }
Fariborz Jahaniana7fa6be2009-09-16 21:37:16 +00001412 }
Daniel Dunbar4bb04ce2010-08-21 03:51:29 +00001413 LV.setObjCArray(E->getType()->isArrayType());
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001414 return;
Fariborz Jahaniana7fa6be2009-09-16 21:37:16 +00001415 }
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001416
1417 if (const UnaryOperator *Exp = dyn_cast<UnaryOperator>(E)) {
Fariborz Jahanian0c784272011-09-30 18:23:36 +00001418 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess);
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001419 return;
1420 }
1421
1422 if (const ParenExpr *Exp = dyn_cast<ParenExpr>(E)) {
Fariborz Jahanian0c784272011-09-30 18:23:36 +00001423 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess);
Fariborz Jahaniane01e4342009-09-30 17:10:29 +00001424 if (LV.isObjCIvar()) {
1425 // If cast is to a structure pointer, follow gcc's behavior and make it
1426 // a non-ivar write-barrier.
1427 QualType ExpTy = E->getType();
1428 if (ExpTy->isPointerType())
1429 ExpTy = ExpTy->getAs<PointerType>()->getPointeeType();
1430 if (ExpTy->isRecordType())
Daniel Dunbar4bb04ce2010-08-21 03:51:29 +00001431 LV.setObjCIvar(false);
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001432 }
1433 return;
Fariborz Jahaniane01e4342009-09-30 17:10:29 +00001434 }
Peter Collingbourne91147592011-04-15 00:35:48 +00001435
1436 if (const GenericSelectionExpr *Exp = dyn_cast<GenericSelectionExpr>(E)) {
1437 setObjCGCLValueClass(Ctx, Exp->getResultExpr(), LV);
1438 return;
1439 }
1440
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001441 if (const ImplicitCastExpr *Exp = dyn_cast<ImplicitCastExpr>(E)) {
Fariborz Jahanian0c784272011-09-30 18:23:36 +00001442 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess);
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001443 return;
1444 }
1445
1446 if (const CStyleCastExpr *Exp = dyn_cast<CStyleCastExpr>(E)) {
Fariborz Jahanian0c784272011-09-30 18:23:36 +00001447 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess);
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001448 return;
1449 }
John McCall31168b02011-06-15 23:02:42 +00001450
1451 if (const ObjCBridgedCastExpr *Exp = dyn_cast<ObjCBridgedCastExpr>(E)) {
Fariborz Jahanian0c784272011-09-30 18:23:36 +00001452 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess);
John McCall31168b02011-06-15 23:02:42 +00001453 return;
1454 }
1455
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001456 if (const ArraySubscriptExpr *Exp = dyn_cast<ArraySubscriptExpr>(E)) {
Fariborz Jahaniana7fa6be2009-09-16 21:37:16 +00001457 setObjCGCLValueClass(Ctx, Exp->getBase(), LV);
Fariborz Jahanian38c3ae92009-09-21 18:54:29 +00001458 if (LV.isObjCIvar() && !LV.isObjCArray())
Fariborz Jahanian2e32ddc2009-09-18 00:04:00 +00001459 // Using array syntax to assigning to what an ivar points to is not
1460 // same as assigning to the ivar itself. {id *Names;} Names[i] = 0;
Daniel Dunbar4bb04ce2010-08-21 03:51:29 +00001461 LV.setObjCIvar(false);
Fariborz Jahanian38c3ae92009-09-21 18:54:29 +00001462 else if (LV.isGlobalObjCRef() && !LV.isObjCArray())
1463 // Using array syntax to assigning to what global points to is not
1464 // same as assigning to the global itself. {id *G;} G[i] = 0;
Daniel Dunbar4bb04ce2010-08-21 03:51:29 +00001465 LV.setGlobalObjCRef(false);
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001466 return;
Fariborz Jahanian2e32ddc2009-09-18 00:04:00 +00001467 }
Fariborz Jahanian0c784272011-09-30 18:23:36 +00001468
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001469 if (const MemberExpr *Exp = dyn_cast<MemberExpr>(E)) {
Fariborz Jahanian0c784272011-09-30 18:23:36 +00001470 setObjCGCLValueClass(Ctx, Exp->getBase(), LV, true);
Fariborz Jahanian2e32ddc2009-09-18 00:04:00 +00001471 // We don't know if member is an 'ivar', but this flag is looked at
1472 // only in the context of LV.isObjCIvar().
Daniel Dunbar4bb04ce2010-08-21 03:51:29 +00001473 LV.setObjCArray(E->getType()->isArrayType());
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001474 return;
Fariborz Jahaniana7fa6be2009-09-16 21:37:16 +00001475 }
1476}
1477
Chris Lattner3f32d692011-07-12 06:52:18 +00001478static llvm::Value *
Chandler Carruth4678f672011-07-12 08:58:26 +00001479EmitBitCastOfLValueToProperType(CodeGenFunction &CGF,
Chris Lattner3f32d692011-07-12 06:52:18 +00001480 llvm::Value *V, llvm::Type *IRType,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001481 StringRef Name = StringRef()) {
Chris Lattner3f32d692011-07-12 06:52:18 +00001482 unsigned AS = cast<llvm::PointerType>(V->getType())->getAddressSpace();
Chandler Carruth4678f672011-07-12 08:58:26 +00001483 return CGF.Builder.CreateBitCast(V, IRType->getPointerTo(AS), Name);
Chris Lattner3f32d692011-07-12 06:52:18 +00001484}
1485
Anders Carlssonea4c30b2009-11-07 23:06:58 +00001486static LValue EmitGlobalVarDeclLValue(CodeGenFunction &CGF,
1487 const Expr *E, const VarDecl *VD) {
Daniel Dunbar7e215ea2009-11-08 09:46:46 +00001488 assert((VD->hasExternalStorage() || VD->isFileVarDecl()) &&
Anders Carlssonea4c30b2009-11-07 23:06:58 +00001489 "Var decl must have external storage or be a file var decl!");
1490
1491 llvm::Value *V = CGF.CGM.GetAddrOfGlobalVar(VD);
Eli Friedmand20adbd2011-11-16 00:42:57 +00001492 llvm::Type *RealVarTy = CGF.getTypes().ConvertTypeForMem(VD->getType());
1493 V = EmitBitCastOfLValueToProperType(CGF, V, RealVarTy);
Eli Friedmana0544d62011-12-03 04:14:32 +00001494 CharUnits Alignment = CGF.getContext().getDeclAlign(VD);
Eli Friedmand20adbd2011-11-16 00:42:57 +00001495 QualType T = E->getType();
1496 LValue LV;
1497 if (VD->getType()->isReferenceType()) {
1498 llvm::LoadInst *LI = CGF.Builder.CreateLoad(V);
Eli Friedmana0544d62011-12-03 04:14:32 +00001499 LI->setAlignment(Alignment.getQuantity());
Eli Friedmand20adbd2011-11-16 00:42:57 +00001500 V = LI;
1501 LV = CGF.MakeNaturalAlignAddrLValue(V, T);
1502 } else {
1503 LV = CGF.MakeAddrLValue(V, E->getType(), Alignment);
1504 }
Anders Carlssonea4c30b2009-11-07 23:06:58 +00001505 setObjCGCLValueClass(CGF.getContext(), E, LV);
1506 return LV;
1507}
1508
Eli Friedmand15eb34d2009-11-26 06:08:14 +00001509static LValue EmitFunctionDeclLValue(CodeGenFunction &CGF,
Chris Lattner13ee4f42011-07-10 05:34:54 +00001510 const Expr *E, const FunctionDecl *FD) {
Chris Lattnerf53c0962010-09-06 00:11:41 +00001511 llvm::Value *V = CGF.CGM.GetAddrOfFunction(FD);
Eli Friedmand15eb34d2009-11-26 06:08:14 +00001512 if (!FD->hasPrototype()) {
1513 if (const FunctionProtoType *Proto =
1514 FD->getType()->getAs<FunctionProtoType>()) {
1515 // Ugly case: for a K&R-style definition, the type of the definition
1516 // isn't the same as the type of a use. Correct for this with a
1517 // bitcast.
1518 QualType NoProtoType =
1519 CGF.getContext().getFunctionNoProtoType(Proto->getResultType());
1520 NoProtoType = CGF.getContext().getPointerType(NoProtoType);
Benjamin Kramer76399eb2011-09-27 21:06:10 +00001521 V = CGF.Builder.CreateBitCast(V, CGF.ConvertType(NoProtoType));
Eli Friedmand15eb34d2009-11-26 06:08:14 +00001522 }
1523 }
Eli Friedmana0544d62011-12-03 04:14:32 +00001524 CharUnits Alignment = CGF.getContext().getDeclAlign(FD);
Daniel Dunbar5c816372010-08-21 04:20:22 +00001525 return CGF.MakeAddrLValue(V, E->getType(), Alignment);
Eli Friedmand15eb34d2009-11-26 06:08:14 +00001526}
1527
Chris Lattnerd7f58862007-06-02 05:24:33 +00001528LValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) {
Anders Carlsson2ff6395d2009-11-07 22:53:10 +00001529 const NamedDecl *ND = E->getDecl();
Eli Friedmana0544d62011-12-03 04:14:32 +00001530 CharUnits Alignment = getContext().getDeclAlign(ND);
Eli Friedmand20adbd2011-11-16 00:42:57 +00001531 QualType T = E->getType();
Mike Stump4a3999f2009-09-09 13:00:44 +00001532
Eli Friedman5720e342012-01-21 04:52:58 +00001533 // FIXME: We should be able to assert this for FunctionDecls as well!
1534 // FIXME: We should be able to assert this for all DeclRefExprs, not just
1535 // those with a valid source location.
1536 assert((ND->isUsed(false) || !isa<VarDecl>(ND) ||
1537 !E->getLocation().isValid()) &&
1538 "Should not use decl without marking it used!");
1539
Rafael Espindola2e42fec2010-03-04 18:17:24 +00001540 if (ND->hasAttr<WeakRefAttr>()) {
Chris Lattnerf53c0962010-09-06 00:11:41 +00001541 const ValueDecl *VD = cast<ValueDecl>(ND);
Rafael Espindola2e42fec2010-03-04 18:17:24 +00001542 llvm::Constant *Aliasee = CGM.GetWeakRefReference(VD);
Daniel Dunbar5c816372010-08-21 04:20:22 +00001543 return MakeAddrLValue(Aliasee, E->getType(), Alignment);
Rafael Espindola2e42fec2010-03-04 18:17:24 +00001544 }
1545
Anders Carlsson2ff6395d2009-11-07 22:53:10 +00001546 if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) {
Anders Carlsson2ff6395d2009-11-07 22:53:10 +00001547 // Check if this is a global variable.
Anders Carlssonea4c30b2009-11-07 23:06:58 +00001548 if (VD->hasExternalStorage() || VD->isFileVarDecl())
1549 return EmitGlobalVarDeclLValue(*this, E, VD);
Anders Carlsson6eee9722009-11-07 22:46:42 +00001550
John McCall113bee02012-03-10 09:33:50 +00001551 bool isBlockVariable = VD->hasAttr<BlocksAttr>();
1552
Fariborz Jahanian44a41d12010-11-19 18:17:09 +00001553 bool NonGCable = VD->hasLocalStorage() &&
1554 !VD->getType()->isReferenceType() &&
John McCall113bee02012-03-10 09:33:50 +00001555 !isBlockVariable;
Anders Carlsson6eee9722009-11-07 22:46:42 +00001556
1557 llvm::Value *V = LocalDeclMap[VD];
Fariborz Jahanian366a9482010-09-07 23:26:17 +00001558 if (!V && VD->isStaticLocal())
Fariborz Jahanian4d55b2d2010-04-19 18:15:02 +00001559 V = CGM.getStaticLocalDeclAddress(VD);
Eli Friedman9fbeba02012-02-11 02:57:39 +00001560
1561 // Use special handling for lambdas.
John McCall113bee02012-03-10 09:33:50 +00001562 if (!V) {
Eli Friedman7f1ff602012-04-16 03:54:45 +00001563 if (FieldDecl *FD = LambdaCaptureFields.lookup(VD)) {
1564 QualType LambdaTagType = getContext().getTagDeclType(FD->getParent());
1565 LValue LambdaLV = MakeNaturalAlignAddrLValue(CXXABIThisValue,
1566 LambdaTagType);
1567 return EmitLValueForField(LambdaLV, FD);
1568 }
Eli Friedman9fbeba02012-02-11 02:57:39 +00001569
John McCall113bee02012-03-10 09:33:50 +00001570 assert(isa<BlockDecl>(CurCodeDecl) && E->refersToEnclosingLocal());
1571 CharUnits alignment = getContext().getDeclAlign(VD);
1572 return MakeAddrLValue(GetAddrOfBlockDecl(VD, isBlockVariable),
1573 E->getType(), alignment);
1574 }
1575
Anders Carlsson6eee9722009-11-07 22:46:42 +00001576 assert(V && "DeclRefExpr not entered in LocalDeclMap?");
1577
John McCall113bee02012-03-10 09:33:50 +00001578 if (isBlockVariable)
Fariborz Jahanian2f2fa722011-01-26 23:08:27 +00001579 V = BuildBlockByrefAddress(V, VD);
Daniel Dunbarf166a522010-08-21 03:44:13 +00001580
Eli Friedmand20adbd2011-11-16 00:42:57 +00001581 LValue LV;
1582 if (VD->getType()->isReferenceType()) {
1583 llvm::LoadInst *LI = Builder.CreateLoad(V);
Eli Friedmana0544d62011-12-03 04:14:32 +00001584 LI->setAlignment(Alignment.getQuantity());
Eli Friedmand20adbd2011-11-16 00:42:57 +00001585 V = LI;
1586 LV = MakeNaturalAlignAddrLValue(V, T);
1587 } else {
1588 LV = MakeAddrLValue(V, T, Alignment);
1589 }
Chris Lattner3f32d692011-07-12 06:52:18 +00001590
Fariborz Jahanian44a41d12010-11-19 18:17:09 +00001591 if (NonGCable) {
Daniel Dunbarf166a522010-08-21 03:44:13 +00001592 LV.getQuals().removeObjCGCAttr();
Daniel Dunbare50dda92010-08-21 03:22:38 +00001593 LV.setNonGC(true);
1594 }
Fariborz Jahaniana7fa6be2009-09-16 21:37:16 +00001595 setObjCGCLValueClass(getContext(), E, LV);
Fariborz Jahanian003e8302008-11-20 00:15:42 +00001596 return LV;
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001597 }
John McCallf3a88602011-02-03 08:15:49 +00001598
1599 if (const FunctionDecl *fn = dyn_cast<FunctionDecl>(ND))
1600 return EmitFunctionDeclLValue(*this, E, fn);
1601
David Blaikie83d382b2011-09-23 05:06:16 +00001602 llvm_unreachable("Unhandled DeclRefExpr");
Chris Lattnerd7f58862007-06-02 05:24:33 +00001603}
Chris Lattnere47e4402007-06-01 18:02:12 +00001604
Chris Lattner8394d792007-06-05 20:53:16 +00001605LValue CodeGenFunction::EmitUnaryOpLValue(const UnaryOperator *E) {
1606 // __extension__ doesn't affect lvalue-ness.
John McCalle3027922010-08-25 11:45:40 +00001607 if (E->getOpcode() == UO_Extension)
Chris Lattner8394d792007-06-05 20:53:16 +00001608 return EmitLValue(E->getSubExpr());
Mike Stump4a3999f2009-09-09 13:00:44 +00001609
Chris Lattner0f398c42008-07-26 22:37:01 +00001610 QualType ExprTy = getContext().getCanonicalType(E->getSubExpr()->getType());
Chris Lattner595db862007-10-30 22:53:42 +00001611 switch (E->getOpcode()) {
David Blaikie83d382b2011-09-23 05:06:16 +00001612 default: llvm_unreachable("Unknown unary operator lvalue!");
John McCalle3027922010-08-25 11:45:40 +00001613 case UO_Deref: {
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001614 QualType T = E->getSubExpr()->getType()->getPointeeType();
1615 assert(!T.isNull() && "CodeGenFunction::EmitUnaryOpLValue: Illegal type");
Mike Stump4a3999f2009-09-09 13:00:44 +00001616
Chris Lattner2415357a2011-12-19 21:16:08 +00001617 LValue LV = MakeNaturalAlignAddrLValue(EmitScalarExpr(E->getSubExpr()), T);
Daniel Dunbarf166a522010-08-21 03:44:13 +00001618 LV.getQuals().setAddressSpace(ExprTy.getAddressSpace());
John McCall8ccfcb52009-09-24 19:53:00 +00001619
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001620 // We should not generate __weak write barrier on indirect reference
1621 // of a pointer to object; as in void foo (__weak id *param); *param = 0;
1622 // But, we continue to generate __strong write barrier on indirect write
1623 // into a pointer to object.
David Blaikiebbafb8a2012-03-11 07:00:24 +00001624 if (getContext().getLangOpts().ObjC1 &&
1625 getContext().getLangOpts().getGC() != LangOptions::NonGC &&
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001626 LV.isObjCWeak())
Daniel Dunbare50dda92010-08-21 03:22:38 +00001627 LV.setNonGC(!E->isOBJCGCCandidate(getContext()));
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001628 return LV;
1629 }
John McCalle3027922010-08-25 11:45:40 +00001630 case UO_Real:
1631 case UO_Imag: {
Chris Lattner595db862007-10-30 22:53:42 +00001632 LValue LV = EmitLValue(E->getSubExpr());
John McCalla2342eb2010-12-05 02:00:02 +00001633 assert(LV.isSimple() && "real/imag on non-ordinary l-value");
1634 llvm::Value *Addr = LV.getAddress();
1635
Richard Smith0b6b8e42012-02-18 20:53:32 +00001636 // __real is valid on scalars. This is a faster way of testing that.
1637 // __imag can only produce an rvalue on scalars.
1638 if (E->getOpcode() == UO_Real &&
1639 !cast<llvm::PointerType>(Addr->getType())
John McCalla2342eb2010-12-05 02:00:02 +00001640 ->getElementType()->isStructTy()) {
1641 assert(E->getSubExpr()->getType()->isArithmeticType());
1642 return LV;
1643 }
1644
1645 assert(E->getSubExpr()->getType()->isAnyComplexType());
1646
John McCalle3027922010-08-25 11:45:40 +00001647 unsigned Idx = E->getOpcode() == UO_Imag;
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00001648 return MakeAddrLValue(Builder.CreateStructGEP(LV.getAddress(),
John McCalla2342eb2010-12-05 02:00:02 +00001649 Idx, "idx"),
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00001650 ExprTy);
Chris Lattner595db862007-10-30 22:53:42 +00001651 }
John McCalle3027922010-08-25 11:45:40 +00001652 case UO_PreInc:
1653 case UO_PreDec: {
Chris Lattnerbb8976e2010-01-09 21:44:40 +00001654 LValue LV = EmitLValue(E->getSubExpr());
John McCalle3027922010-08-25 11:45:40 +00001655 bool isInc = E->getOpcode() == UO_PreInc;
Chris Lattnerbb8976e2010-01-09 21:44:40 +00001656
1657 if (E->getType()->isAnyComplexType())
1658 EmitComplexPrePostIncDec(E, LV, isInc, true/*isPre*/);
1659 else
1660 EmitScalarPrePostIncDec(E, LV, isInc, true/*isPre*/);
1661 return LV;
1662 }
Eli Friedmana72bf0f2009-11-09 04:20:47 +00001663 }
Chris Lattner8394d792007-06-05 20:53:16 +00001664}
1665
Chris Lattner4347e3692007-06-06 04:54:52 +00001666LValue CodeGenFunction::EmitStringLiteralLValue(const StringLiteral *E) {
Daniel Dunbar2e442a02010-08-21 03:15:20 +00001667 return MakeAddrLValue(CGM.GetAddrOfConstantStringFromLiteral(E),
1668 E->getType());
Chris Lattner4347e3692007-06-06 04:54:52 +00001669}
1670
Chris Lattnerd7e7b8e2009-02-24 22:18:39 +00001671LValue CodeGenFunction::EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E) {
Daniel Dunbar2e442a02010-08-21 03:15:20 +00001672 return MakeAddrLValue(CGM.GetAddrOfConstantStringFromObjCEncode(E),
1673 E->getType());
Chris Lattnerd7e7b8e2009-02-24 22:18:39 +00001674}
1675
1676
Mike Stump4a3999f2009-09-09 13:00:44 +00001677LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) {
Daniel Dunbarb3517472008-10-17 21:58:32 +00001678 switch (E->getIdentType()) {
1679 default:
1680 return EmitUnsupportedLValue(E, "predefined expression");
Daniel Dunbarb1d94a92010-08-21 03:01:12 +00001681
Daniel Dunbarb3517472008-10-17 21:58:32 +00001682 case PredefinedExpr::Func:
1683 case PredefinedExpr::Function:
Daniel Dunbarb1d94a92010-08-21 03:01:12 +00001684 case PredefinedExpr::PrettyFunction: {
1685 unsigned Type = E->getIdentType();
1686 std::string GlobalVarName;
1687
1688 switch (Type) {
David Blaikie83d382b2011-09-23 05:06:16 +00001689 default: llvm_unreachable("Invalid type");
Daniel Dunbarb1d94a92010-08-21 03:01:12 +00001690 case PredefinedExpr::Func:
1691 GlobalVarName = "__func__.";
1692 break;
1693 case PredefinedExpr::Function:
1694 GlobalVarName = "__FUNCTION__.";
1695 break;
1696 case PredefinedExpr::PrettyFunction:
1697 GlobalVarName = "__PRETTY_FUNCTION__.";
1698 break;
1699 }
1700
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001701 StringRef FnName = CurFn->getName();
Daniel Dunbarb1d94a92010-08-21 03:01:12 +00001702 if (FnName.startswith("\01"))
1703 FnName = FnName.substr(1);
1704 GlobalVarName += FnName;
1705
1706 const Decl *CurDecl = CurCodeDecl;
1707 if (CurDecl == 0)
1708 CurDecl = getContext().getTranslationUnitDecl();
1709
1710 std::string FunctionName =
John McCall351762c2011-02-07 10:33:21 +00001711 (isa<BlockDecl>(CurDecl)
1712 ? FnName.str()
1713 : PredefinedExpr::ComputeName((PredefinedExpr::IdentType)Type, CurDecl));
Daniel Dunbarb1d94a92010-08-21 03:01:12 +00001714
1715 llvm::Constant *C =
1716 CGM.GetAddrOfConstantCString(FunctionName, GlobalVarName.c_str());
Daniel Dunbar2e442a02010-08-21 03:15:20 +00001717 return MakeAddrLValue(C, E->getType());
Daniel Dunbarb1d94a92010-08-21 03:01:12 +00001718 }
Daniel Dunbarb3517472008-10-17 21:58:32 +00001719 }
Anders Carlsson625bfc82007-07-21 05:21:51 +00001720}
1721
Mike Stumpcf16d2c2009-12-15 01:22:35 +00001722llvm::BasicBlock *CodeGenFunction::getTrapBB() {
Mike Stump9a4e0122009-12-15 00:59:40 +00001723 const CodeGenOptions &GCO = CGM.getCodeGenOpts();
1724
1725 // If we are not optimzing, don't collapse all calls to trap in the function
1726 // to the same call, that way, in the debugger they can see which operation
Chris Lattner26008e02010-07-20 20:19:24 +00001727 // did in fact fail. If we are optimizing, we collapse all calls to trap down
Mike Stump9a4e0122009-12-15 00:59:40 +00001728 // to just one per function to save on codesize.
Chris Lattner26008e02010-07-20 20:19:24 +00001729 if (GCO.OptimizationLevel && TrapBB)
Mike Stumpe8c3b3e2009-12-15 00:35:12 +00001730 return TrapBB;
Mike Stumpd9546382009-12-12 01:27:46 +00001731
1732 llvm::BasicBlock *Cont = 0;
1733 if (HaveInsertPoint()) {
1734 Cont = createBasicBlock("cont");
1735 EmitBranch(Cont);
1736 }
Mike Stumpe8c3b3e2009-12-15 00:35:12 +00001737 TrapBB = createBasicBlock("trap");
1738 EmitBlock(TrapBB);
1739
Benjamin Kramer8d375ce2011-07-14 17:45:50 +00001740 llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::trap);
Mike Stumpe8c3b3e2009-12-15 00:35:12 +00001741 llvm::CallInst *TrapCall = Builder.CreateCall(F);
1742 TrapCall->setDoesNotReturn();
1743 TrapCall->setDoesNotThrow();
Mike Stumpd9546382009-12-12 01:27:46 +00001744 Builder.CreateUnreachable();
1745
1746 if (Cont)
1747 EmitBlock(Cont);
Mike Stumpe8c3b3e2009-12-15 00:35:12 +00001748 return TrapBB;
Mike Stumpd9546382009-12-12 01:27:46 +00001749}
1750
Chris Lattner6c5abe82010-06-26 23:03:20 +00001751/// isSimpleArrayDecayOperand - If the specified expr is a simple decay from an
1752/// array to pointer, return the array subexpression.
1753static const Expr *isSimpleArrayDecayOperand(const Expr *E) {
1754 // If this isn't just an array->pointer decay, bail out.
1755 const CastExpr *CE = dyn_cast<CastExpr>(E);
John McCalle3027922010-08-25 11:45:40 +00001756 if (CE == 0 || CE->getCastKind() != CK_ArrayToPointerDecay)
Chris Lattner6c5abe82010-06-26 23:03:20 +00001757 return 0;
1758
1759 // If this is a decay from variable width array, bail out.
1760 const Expr *SubExpr = CE->getSubExpr();
1761 if (SubExpr->getType()->isVariableArrayType())
1762 return 0;
1763
1764 return SubExpr;
1765}
1766
Chris Lattnerd9d2fb12007-06-08 23:31:14 +00001767LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) {
Ted Kremenekc81614d2007-08-20 16:18:38 +00001768 // The index must always be an integer, which is not an aggregate. Emit it.
Chris Lattner2da04b32007-08-24 05:35:26 +00001769 llvm::Value *Idx = EmitScalarExpr(E->getIdx());
Eli Friedman07bbeca2009-06-06 19:09:26 +00001770 QualType IdxTy = E->getIdx()->getType();
Douglas Gregor6ab2fa82011-05-20 16:38:50 +00001771 bool IdxSigned = IdxTy->isSignedIntegerOrEnumerationType();
Eli Friedman07bbeca2009-06-06 19:09:26 +00001772
Chris Lattner08c4b9f2007-07-10 21:17:59 +00001773 // If the base is a vector type, then we are forming a vector element lvalue
1774 // with this subscript.
Eli Friedman327944b2008-06-13 23:01:12 +00001775 if (E->getBase()->getType()->isVectorType()) {
Chris Lattner08c4b9f2007-07-10 21:17:59 +00001776 // Emit the vector as an lvalue to get its address.
Eli Friedman327944b2008-06-13 23:01:12 +00001777 LValue LHS = EmitLValue(E->getBase());
Ted Kremenekc81614d2007-08-20 16:18:38 +00001778 assert(LHS.isSimple() && "Can only subscript lvalue vectors here!");
John McCallad7c5c12011-02-08 08:22:06 +00001779 Idx = Builder.CreateIntCast(Idx, Int32Ty, IdxSigned, "vidx");
Eli Friedman327944b2008-06-13 23:01:12 +00001780 return LValue::MakeVectorElt(LHS.getAddress(), Idx,
Eli Friedman610bb872012-03-22 22:36:39 +00001781 E->getBase()->getType(), LHS.getAlignment());
Chris Lattner08c4b9f2007-07-10 21:17:59 +00001782 }
Mike Stump4a3999f2009-09-09 13:00:44 +00001783
Ted Kremenekc81614d2007-08-20 16:18:38 +00001784 // Extend or truncate the index type to 32 or 64-bits.
John McCalle3dc1702011-02-15 09:22:45 +00001785 if (Idx->getType() != IntPtrTy)
1786 Idx = Builder.CreateIntCast(Idx, IntPtrTy, IdxSigned, "idxprom");
Mike Stumpd9546382009-12-12 01:27:46 +00001787
Mike Stump4a3999f2009-09-09 13:00:44 +00001788 // We know that the pointer points to a type of the correct size, unless the
1789 // size is a VLA or Objective-C interface.
Daniel Dunbaref2ffbc2009-04-25 05:08:32 +00001790 llvm::Value *Address = 0;
Eli Friedmana0544d62011-12-03 04:14:32 +00001791 CharUnits ArrayAlignment;
John McCall23c29fe2011-06-24 21:55:10 +00001792 if (const VariableArrayType *vla =
Anders Carlsson3d312f82008-12-21 00:11:23 +00001793 getContext().getAsVariableArrayType(E->getType())) {
John McCall23c29fe2011-06-24 21:55:10 +00001794 // The base must be a pointer, which is not an aggregate. Emit
1795 // it. It needs to be emitted first in case it's what captures
1796 // the VLA bounds.
1797 Address = EmitScalarExpr(E->getBase());
Mike Stump4a3999f2009-09-09 13:00:44 +00001798
John McCall23c29fe2011-06-24 21:55:10 +00001799 // The element count here is the total number of non-VLA elements.
1800 llvm::Value *numElements = getVLASize(vla).first;
Mike Stump4a3999f2009-09-09 13:00:44 +00001801
John McCall77527a82011-06-25 01:32:37 +00001802 // Effectively, the multiply by the VLA size is part of the GEP.
1803 // GEP indexes are signed, and scaling an index isn't permitted to
1804 // signed-overflow, so we use the same semantics for our explicit
1805 // multiply. We suppress this if overflow is not undefined behavior.
David Blaikiebbafb8a2012-03-11 07:00:24 +00001806 if (getLangOpts().isSignedOverflowDefined()) {
John McCall77527a82011-06-25 01:32:37 +00001807 Idx = Builder.CreateMul(Idx, numElements);
Chris Lattner2e72da942011-03-01 00:03:48 +00001808 Address = Builder.CreateGEP(Address, Idx, "arrayidx");
John McCall77527a82011-06-25 01:32:37 +00001809 } else {
1810 Idx = Builder.CreateNSWMul(Idx, numElements);
Chris Lattner2e72da942011-03-01 00:03:48 +00001811 Address = Builder.CreateInBoundsGEP(Address, Idx, "arrayidx");
John McCall77527a82011-06-25 01:32:37 +00001812 }
Chris Lattner6c5abe82010-06-26 23:03:20 +00001813 } else if (const ObjCObjectType *OIT = E->getType()->getAs<ObjCObjectType>()){
1814 // Indexing over an interface, as in "NSString *P; P[4];"
Mike Stump4a3999f2009-09-09 13:00:44 +00001815 llvm::Value *InterfaceSize =
Owen Andersonb7a2fe62009-07-24 23:12:58 +00001816 llvm::ConstantInt::get(Idx->getType(),
Ken Dyck40775002010-01-11 17:06:35 +00001817 getContext().getTypeSizeInChars(OIT).getQuantity());
Mike Stump4a3999f2009-09-09 13:00:44 +00001818
Daniel Dunbaref2ffbc2009-04-25 05:08:32 +00001819 Idx = Builder.CreateMul(Idx, InterfaceSize);
1820
Chris Lattner6c5abe82010-06-26 23:03:20 +00001821 // The base must be a pointer, which is not an aggregate. Emit it.
1822 llvm::Value *Base = EmitScalarExpr(E->getBase());
John McCallad7c5c12011-02-08 08:22:06 +00001823 Address = EmitCastToVoidPtr(Base);
1824 Address = Builder.CreateGEP(Address, Idx, "arrayidx");
Daniel Dunbaref2ffbc2009-04-25 05:08:32 +00001825 Address = Builder.CreateBitCast(Address, Base->getType());
Chris Lattner6c5abe82010-06-26 23:03:20 +00001826 } else if (const Expr *Array = isSimpleArrayDecayOperand(E->getBase())) {
1827 // If this is A[i] where A is an array, the frontend will have decayed the
1828 // base to be a ArrayToPointerDecay implicit cast. While correct, it is
1829 // inefficient at -O0 to emit a "gep A, 0, 0" when codegen'ing it, then a
1830 // "gep x, i" here. Emit one "gep A, 0, i".
1831 assert(Array->getType()->isArrayType() &&
1832 "Array to pointer decay must have array source type!");
Daniel Dunbar82634272011-04-01 00:49:43 +00001833 LValue ArrayLV = EmitLValue(Array);
1834 llvm::Value *ArrayPtr = ArrayLV.getAddress();
Chris Lattner6c5abe82010-06-26 23:03:20 +00001835 llvm::Value *Zero = llvm::ConstantInt::get(Int32Ty, 0);
1836 llvm::Value *Args[] = { Zero, Idx };
1837
Daniel Dunbar82634272011-04-01 00:49:43 +00001838 // Propagate the alignment from the array itself to the result.
1839 ArrayAlignment = ArrayLV.getAlignment();
1840
David Blaikiebbafb8a2012-03-11 07:00:24 +00001841 if (getContext().getLangOpts().isSignedOverflowDefined())
Jay Foad040dd822011-07-22 08:16:57 +00001842 Address = Builder.CreateGEP(ArrayPtr, Args, "arrayidx");
Chris Lattner2e72da942011-03-01 00:03:48 +00001843 else
Jay Foad040dd822011-07-22 08:16:57 +00001844 Address = Builder.CreateInBoundsGEP(ArrayPtr, Args, "arrayidx");
Daniel Dunbaref2ffbc2009-04-25 05:08:32 +00001845 } else {
Chris Lattner6c5abe82010-06-26 23:03:20 +00001846 // The base must be a pointer, which is not an aggregate. Emit it.
1847 llvm::Value *Base = EmitScalarExpr(E->getBase());
David Blaikiebbafb8a2012-03-11 07:00:24 +00001848 if (getContext().getLangOpts().isSignedOverflowDefined())
Chris Lattner2e72da942011-03-01 00:03:48 +00001849 Address = Builder.CreateGEP(Base, Idx, "arrayidx");
1850 else
1851 Address = Builder.CreateInBoundsGEP(Base, Idx, "arrayidx");
Anders Carlsson3d312f82008-12-21 00:11:23 +00001852 }
Mike Stump4a3999f2009-09-09 13:00:44 +00001853
Steve Naroff7cae42b2009-07-10 23:34:53 +00001854 QualType T = E->getBase()->getType()->getPointeeType();
Mike Stump4a3999f2009-09-09 13:00:44 +00001855 assert(!T.isNull() &&
Steve Naroff7cae42b2009-07-10 23:34:53 +00001856 "CodeGenFunction::EmitArraySubscriptExpr(): Illegal base type");
Mike Stump4a3999f2009-09-09 13:00:44 +00001857
Chris Lattner36bc4f42012-01-04 22:35:55 +00001858
Daniel Dunbar82634272011-04-01 00:49:43 +00001859 // Limit the alignment to that of the result type.
Chris Lattner36bc4f42012-01-04 22:35:55 +00001860 LValue LV;
Eli Friedmana0544d62011-12-03 04:14:32 +00001861 if (!ArrayAlignment.isZero()) {
1862 CharUnits Align = getContext().getTypeAlignInChars(T);
Daniel Dunbar82634272011-04-01 00:49:43 +00001863 ArrayAlignment = std::min(Align, ArrayAlignment);
Chris Lattner36bc4f42012-01-04 22:35:55 +00001864 LV = MakeAddrLValue(Address, T, ArrayAlignment);
1865 } else {
1866 LV = MakeNaturalAlignAddrLValue(Address, T);
Daniel Dunbar82634272011-04-01 00:49:43 +00001867 }
1868
Daniel Dunbarf166a522010-08-21 03:44:13 +00001869 LV.getQuals().setAddressSpace(E->getBase()->getType().getAddressSpace());
John McCall8ccfcb52009-09-24 19:53:00 +00001870
David Blaikiebbafb8a2012-03-11 07:00:24 +00001871 if (getContext().getLangOpts().ObjC1 &&
1872 getContext().getLangOpts().getGC() != LangOptions::NonGC) {
Daniel Dunbare50dda92010-08-21 03:22:38 +00001873 LV.setNonGC(!E->isOBJCGCCandidate(getContext()));
Fariborz Jahaniana7fa6be2009-09-16 21:37:16 +00001874 setObjCGCLValueClass(getContext(), E, LV);
1875 }
Fariborz Jahaniana9fecf32009-02-21 23:37:19 +00001876 return LV;
Chris Lattnerd9d2fb12007-06-08 23:31:14 +00001877}
1878
Mike Stump4a3999f2009-09-09 13:00:44 +00001879static
NAKAMURA Takumiccca11a2012-01-25 08:58:21 +00001880llvm::Constant *GenerateConstantVector(CGBuilderTy &Builder,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001881 SmallVector<unsigned, 4> &Elts) {
1882 SmallVector<llvm::Constant*, 4> CElts;
Nate Begemand3862152008-05-13 21:03:02 +00001883 for (unsigned i = 0, e = Elts.size(); i != e; ++i)
Chris Lattner2d6b7b92012-01-25 05:34:41 +00001884 CElts.push_back(Builder.getInt32(Elts[i]));
Nate Begemand3862152008-05-13 21:03:02 +00001885
Chris Lattner91c08ad2011-02-15 00:14:06 +00001886 return llvm::ConstantVector::get(CElts);
Nate Begemand3862152008-05-13 21:03:02 +00001887}
1888
Chris Lattner9e751ca2007-08-02 23:37:31 +00001889LValue CodeGenFunction::
Nate Begemance4d7fc2008-04-18 23:10:10 +00001890EmitExtVectorElementExpr(const ExtVectorElementExpr *E) {
Chris Lattner9e751ca2007-08-02 23:37:31 +00001891 // Emit the base vector as an l-value.
Chris Lattner6c7ce102009-02-16 21:11:58 +00001892 LValue Base;
1893
1894 // ExtVectorElementExpr's base can either be a vector or pointer to vector.
Chris Lattner4e1a3232009-12-23 21:31:11 +00001895 if (E->isArrow()) {
1896 // If it is a pointer to a vector, emit the address and form an lvalue with
1897 // it.
Chris Lattnerb8211f62009-02-16 22:14:05 +00001898 llvm::Value *Ptr = EmitScalarExpr(E->getBase());
Chris Lattner4e1a3232009-12-23 21:31:11 +00001899 const PointerType *PT = E->getBase()->getType()->getAs<PointerType>();
Daniel Dunbarf166a522010-08-21 03:44:13 +00001900 Base = MakeAddrLValue(Ptr, PT->getPointeeType());
1901 Base.getQuals().removeObjCGCAttr();
John McCall086a4642010-11-24 05:12:34 +00001902 } else if (E->getBase()->isGLValue()) {
Chris Lattner4e1a3232009-12-23 21:31:11 +00001903 // Otherwise, if the base is an lvalue ( as in the case of foo.x.x),
1904 // emit the base as an lvalue.
1905 assert(E->getBase()->getType()->isVectorType());
1906 Base = EmitLValue(E->getBase());
1907 } else {
1908 // Otherwise, the base is a normal rvalue (as in (V+V).x), emit it as such.
John McCall1553b192011-06-16 04:16:24 +00001909 assert(E->getBase()->getType()->isVectorType() &&
Daniel Dunbar5b901952010-01-04 18:02:28 +00001910 "Result must be a vector");
Chris Lattner4e1a3232009-12-23 21:31:11 +00001911 llvm::Value *Vec = EmitScalarExpr(E->getBase());
1912
Chris Lattnerf0a9ba32009-12-23 21:33:41 +00001913 // Store the vector to memory (because LValue wants an address).
Daniel Dunbara7566f12010-02-09 02:48:28 +00001914 llvm::Value *VecMem = CreateMemTemp(E->getBase()->getType());
Chris Lattner4e1a3232009-12-23 21:31:11 +00001915 Builder.CreateStore(Vec, VecMem);
Daniel Dunbarf166a522010-08-21 03:44:13 +00001916 Base = MakeAddrLValue(VecMem, E->getBase()->getType());
Chris Lattner4e1a3232009-12-23 21:31:11 +00001917 }
John McCall1553b192011-06-16 04:16:24 +00001918
1919 QualType type =
1920 E->getType().withCVRQualifiers(Base.getQuals().getCVRQualifiers());
Chris Lattner4e1a3232009-12-23 21:31:11 +00001921
Nate Begemand3862152008-05-13 21:03:02 +00001922 // Encode the element access list into a vector of unsigned indices.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001923 SmallVector<unsigned, 4> Indices;
Nate Begemand3862152008-05-13 21:03:02 +00001924 E->getEncodedElementAccess(Indices);
1925
1926 if (Base.isSimple()) {
Chris Lattner2d6b7b92012-01-25 05:34:41 +00001927 llvm::Constant *CV = GenerateConstantVector(Builder, Indices);
Eli Friedman610bb872012-03-22 22:36:39 +00001928 return LValue::MakeExtVectorElt(Base.getAddress(), CV, type,
1929 Base.getAlignment());
Nate Begemand3862152008-05-13 21:03:02 +00001930 }
1931 assert(Base.isExtVectorElt() && "Can only subscript lvalue vec elts here!");
1932
1933 llvm::Constant *BaseElts = Base.getExtVectorElts();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001934 SmallVector<llvm::Constant *, 4> CElts;
Nate Begemand3862152008-05-13 21:03:02 +00001935
Chris Lattner595ba3a2012-01-30 06:20:36 +00001936 for (unsigned i = 0, e = Indices.size(); i != e; ++i)
1937 CElts.push_back(BaseElts->getAggregateElement(Indices[i]));
Chris Lattner91c08ad2011-02-15 00:14:06 +00001938 llvm::Constant *CV = llvm::ConstantVector::get(CElts);
Eli Friedman610bb872012-03-22 22:36:39 +00001939 return LValue::MakeExtVectorElt(Base.getExtVectorAddr(), CV, type,
1940 Base.getAlignment());
Chris Lattner9e751ca2007-08-02 23:37:31 +00001941}
1942
Devang Patel30efa2e2007-10-23 20:28:39 +00001943LValue CodeGenFunction::EmitMemberExpr(const MemberExpr *E) {
Devang Pateld68df202007-10-24 22:26:28 +00001944 Expr *BaseExpr = E->getBase();
Eli Friedman327944b2008-06-13 23:01:12 +00001945
Chris Lattner4e4186b2007-12-02 18:52:07 +00001946 // If this is s.x, emit s as an lvalue. If it is s->x, emit s as a scalar.
Eli Friedman7f1ff602012-04-16 03:54:45 +00001947 LValue BaseLV;
1948 if (E->isArrow())
1949 BaseLV = MakeNaturalAlignAddrLValue(EmitScalarExpr(BaseExpr),
1950 BaseExpr->getType()->getPointeeType());
1951 else
1952 BaseLV = EmitLValue(BaseExpr);
Devang Patel30efa2e2007-10-23 20:28:39 +00001953
Anders Carlssonea4c30b2009-11-07 23:06:58 +00001954 NamedDecl *ND = E->getMemberDecl();
1955 if (FieldDecl *Field = dyn_cast<FieldDecl>(ND)) {
Eli Friedman7f1ff602012-04-16 03:54:45 +00001956 LValue LV = EmitLValueForField(BaseLV, Field);
Anders Carlssonea4c30b2009-11-07 23:06:58 +00001957 setObjCGCLValueClass(getContext(), E, LV);
1958 return LV;
1959 }
1960
Anders Carlsson5bbdc9f2009-11-07 23:16:50 +00001961 if (VarDecl *VD = dyn_cast<VarDecl>(ND))
1962 return EmitGlobalVarDeclLValue(*this, E, VD);
Eli Friedmand15eb34d2009-11-26 06:08:14 +00001963
1964 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND))
1965 return EmitFunctionDeclLValue(*this, E, FD);
1966
David Blaikie83d382b2011-09-23 05:06:16 +00001967 llvm_unreachable("Unhandled member declaration!");
Eli Friedmana62f3e12008-02-09 08:50:58 +00001968}
Devang Patel30efa2e2007-10-23 20:28:39 +00001969
Chris Lattnerf53c0962010-09-06 00:11:41 +00001970LValue CodeGenFunction::EmitLValueForBitfield(llvm::Value *BaseValue,
1971 const FieldDecl *Field,
Fariborz Jahanian712bfa62009-02-03 19:03:09 +00001972 unsigned CVRQualifiers) {
Daniel Dunbar034299e2010-03-31 01:09:11 +00001973 const CGRecordLayout &RL =
1974 CGM.getTypes().getCGRecordLayout(Field->getParent());
Daniel Dunbarcd3d5e72010-04-05 16:20:44 +00001975 const CGBitFieldInfo &Info = RL.getBitFieldInfo(Field);
Daniel Dunbarc75c8bd2010-04-08 02:59:45 +00001976 return LValue::MakeBitfield(BaseValue, Info,
John McCall1553b192011-06-16 04:16:24 +00001977 Field->getType().withCVRQualifiers(CVRQualifiers));
Fariborz Jahanianb517e902008-12-15 20:35:07 +00001978}
1979
John McCallc4094932010-05-21 01:18:57 +00001980/// EmitLValueForAnonRecordField - Given that the field is a member of
1981/// an anonymous struct or union buried inside a record, and given
1982/// that the base value is a pointer to the enclosing record, derive
1983/// an lvalue for the ultimate field.
1984LValue CodeGenFunction::EmitLValueForAnonRecordField(llvm::Value *BaseValue,
Francois Pichetd583da02010-12-04 09:14:42 +00001985 const IndirectFieldDecl *Field,
John McCallc4094932010-05-21 01:18:57 +00001986 unsigned CVRQualifiers) {
Francois Pichetd583da02010-12-04 09:14:42 +00001987 IndirectFieldDecl::chain_iterator I = Field->chain_begin(),
1988 IEnd = Field->chain_end();
John McCallc4094932010-05-21 01:18:57 +00001989 while (true) {
Eli Friedman7f1ff602012-04-16 03:54:45 +00001990 QualType RecordTy =
1991 getContext().getTypeDeclType(cast<FieldDecl>(*I)->getParent());
1992 LValue LV = EmitLValueForField(MakeAddrLValue(BaseValue, RecordTy),
1993 cast<FieldDecl>(*I));
Francois Pichetd583da02010-12-04 09:14:42 +00001994 if (++I == IEnd) return LV;
John McCallc4094932010-05-21 01:18:57 +00001995
1996 assert(LV.isSimple());
1997 BaseValue = LV.getAddress();
1998 CVRQualifiers |= LV.getVRQualifiers();
1999 }
2000}
2001
Eli Friedman7f1ff602012-04-16 03:54:45 +00002002LValue CodeGenFunction::EmitLValueForField(LValue base,
2003 const FieldDecl *field) {
John McCall53fcbd22011-02-26 08:07:02 +00002004 if (field->isBitField())
Eli Friedman7f1ff602012-04-16 03:54:45 +00002005 return EmitLValueForBitfield(base.getAddress(), field,
2006 base.getVRQualifiers());
Mike Stump4a3999f2009-09-09 13:00:44 +00002007
John McCall53fcbd22011-02-26 08:07:02 +00002008 const RecordDecl *rec = field->getParent();
2009 QualType type = field->getType();
Eli Friedmana0544d62011-12-03 04:14:32 +00002010 CharUnits alignment = getContext().getDeclAlign(field);
Eli Friedman133e8042008-05-29 11:33:25 +00002011
Eli Friedman7f1ff602012-04-16 03:54:45 +00002012 // FIXME: It should be impossible to have an LValue without alignment for a
2013 // complete type.
2014 if (!base.getAlignment().isZero())
2015 alignment = std::min(alignment, base.getAlignment());
2016
John McCall53fcbd22011-02-26 08:07:02 +00002017 bool mayAlias = rec->hasAttr<MayAliasAttr>();
2018
Eli Friedman7f1ff602012-04-16 03:54:45 +00002019 llvm::Value *addr = base.getAddress();
2020 unsigned cvr = base.getVRQualifiers();
John McCall53fcbd22011-02-26 08:07:02 +00002021 if (rec->isUnion()) {
Chris Lattner13ee4f42011-07-10 05:34:54 +00002022 // For unions, there is no pointer adjustment.
John McCall53fcbd22011-02-26 08:07:02 +00002023 assert(!type->isReferenceType() && "union has reference member");
John McCall53fcbd22011-02-26 08:07:02 +00002024 } else {
2025 // For structs, we GEP to the field that the record layout suggests.
2026 unsigned idx = CGM.getTypes().getCGRecordLayout(rec).getLLVMFieldNo(field);
Chris Lattner13ee4f42011-07-10 05:34:54 +00002027 addr = Builder.CreateStructGEP(addr, idx, field->getName());
John McCall53fcbd22011-02-26 08:07:02 +00002028
2029 // If this is a reference field, load the reference right now.
2030 if (const ReferenceType *refType = type->getAs<ReferenceType>()) {
2031 llvm::LoadInst *load = Builder.CreateLoad(addr, "ref");
2032 if (cvr & Qualifiers::Volatile) load->setVolatile(true);
Eli Friedmana0544d62011-12-03 04:14:32 +00002033 load->setAlignment(alignment.getQuantity());
John McCall53fcbd22011-02-26 08:07:02 +00002034
2035 if (CGM.shouldUseTBAA()) {
2036 llvm::MDNode *tbaa;
2037 if (mayAlias)
2038 tbaa = CGM.getTBAAInfo(getContext().CharTy);
2039 else
2040 tbaa = CGM.getTBAAInfo(type);
2041 CGM.DecorateInstruction(load, tbaa);
2042 }
2043
2044 addr = load;
2045 mayAlias = false;
2046 type = refType->getPointeeType();
Eli Friedmand20adbd2011-11-16 00:42:57 +00002047 if (type->isIncompleteType())
Eli Friedmana0544d62011-12-03 04:14:32 +00002048 alignment = CharUnits();
Eli Friedmand20adbd2011-11-16 00:42:57 +00002049 else
Eli Friedmana0544d62011-12-03 04:14:32 +00002050 alignment = getContext().getTypeAlignInChars(type);
John McCall53fcbd22011-02-26 08:07:02 +00002051 cvr = 0; // qualifiers don't recursively apply to referencee
2052 }
Devang Pateled93c3c2007-10-26 19:42:18 +00002053 }
Chris Lattner13ee4f42011-07-10 05:34:54 +00002054
2055 // Make sure that the address is pointing to the right type. This is critical
2056 // for both unions and structs. A union needs a bitcast, a struct element
2057 // will need a bitcast if the LLVM type laid out doesn't match the desired
2058 // type.
Chandler Carruth4678f672011-07-12 08:58:26 +00002059 addr = EmitBitCastOfLValueToProperType(*this, addr,
Chris Lattner3f32d692011-07-12 06:52:18 +00002060 CGM.getTypes().ConvertTypeForMem(type),
2061 field->getName());
John McCall8ccfcb52009-09-24 19:53:00 +00002062
Julien Lerouge5a6b6982011-09-09 22:41:49 +00002063 if (field->hasAttr<AnnotateAttr>())
2064 addr = EmitFieldAnnotations(field, addr);
2065
John McCall53fcbd22011-02-26 08:07:02 +00002066 LValue LV = MakeAddrLValue(addr, type, alignment);
2067 LV.getQuals().addCVRQualifiers(cvr);
Daniel Dunbarf166a522010-08-21 03:44:13 +00002068
Fariborz Jahanian38c3ae92009-09-21 18:54:29 +00002069 // __weak attribute on a field is ignored.
Daniel Dunbarf166a522010-08-21 03:44:13 +00002070 if (LV.getQuals().getObjCGCAttr() == Qualifiers::Weak)
2071 LV.getQuals().removeObjCGCAttr();
John McCall53fcbd22011-02-26 08:07:02 +00002072
2073 // Fields of may_alias structs act like 'char' for TBAA purposes.
2074 // FIXME: this should get propagated down through anonymous structs
2075 // and unions.
2076 if (mayAlias && LV.getTBAAInfo())
2077 LV.setTBAAInfo(CGM.getTBAAInfo(getContext().CharTy));
2078
Daniel Dunbarf166a522010-08-21 03:44:13 +00002079 return LV;
Devang Patel30efa2e2007-10-23 20:28:39 +00002080}
2081
Anders Carlssondb78f0a2010-01-29 05:24:29 +00002082LValue
Eli Friedman7f1ff602012-04-16 03:54:45 +00002083CodeGenFunction::EmitLValueForFieldInitialization(LValue Base,
2084 const FieldDecl *Field) {
Anders Carlssondb78f0a2010-01-29 05:24:29 +00002085 QualType FieldType = Field->getType();
2086
2087 if (!FieldType->isReferenceType())
Eli Friedman7f1ff602012-04-16 03:54:45 +00002088 return EmitLValueForField(Base, Field);
Anders Carlssondb78f0a2010-01-29 05:24:29 +00002089
Daniel Dunbar034299e2010-03-31 01:09:11 +00002090 const CGRecordLayout &RL =
2091 CGM.getTypes().getCGRecordLayout(Field->getParent());
2092 unsigned idx = RL.getLLVMFieldNo(Field);
Eli Friedman7f1ff602012-04-16 03:54:45 +00002093 llvm::Value *V = Builder.CreateStructGEP(Base.getAddress(), idx);
Anders Carlssondb78f0a2010-01-29 05:24:29 +00002094 assert(!FieldType.getObjCGCAttr() && "fields cannot have GC attrs");
2095
Chris Lattnerd7c59352011-07-10 05:53:24 +00002096 // Make sure that the address is pointing to the right type. This is critical
2097 // for both unions and structs. A union needs a bitcast, a struct element
2098 // will need a bitcast if the LLVM type laid out doesn't match the desired
2099 // type.
Chris Lattner2192fe52011-07-18 04:24:23 +00002100 llvm::Type *llvmType = ConvertTypeForMem(FieldType);
Eli Friedman7f1ff602012-04-16 03:54:45 +00002101 V = EmitBitCastOfLValueToProperType(*this, V, llvmType, Field->getName());
2102
Eli Friedmana0544d62011-12-03 04:14:32 +00002103 CharUnits Alignment = getContext().getDeclAlign(Field);
Eli Friedman7f1ff602012-04-16 03:54:45 +00002104
2105 // FIXME: It should be impossible to have an LValue without alignment for a
2106 // complete type.
2107 if (!Base.getAlignment().isZero())
2108 Alignment = std::min(Alignment, Base.getAlignment());
2109
Daniel Dunbar5c816372010-08-21 04:20:22 +00002110 return MakeAddrLValue(V, FieldType, Alignment);
Anders Carlssondb78f0a2010-01-29 05:24:29 +00002111}
2112
Chris Lattnerf53c0962010-09-06 00:11:41 +00002113LValue CodeGenFunction::EmitCompoundLiteralLValue(const CompoundLiteralExpr *E){
Richard Smith2d988f02011-11-22 22:48:32 +00002114 if (E->isFileScope()) {
2115 llvm::Value *GlobalPtr = CGM.GetAddrOfConstantCompoundLiteral(E);
2116 return MakeAddrLValue(GlobalPtr, E->getType());
2117 }
2118
Daniel Dunbar27bacaf2010-02-16 19:43:39 +00002119 llvm::Value *DeclPtr = CreateMemTemp(E->getType(), ".compoundliteral");
Chris Lattnerf53c0962010-09-06 00:11:41 +00002120 const Expr *InitExpr = E->getInitializer();
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002121 LValue Result = MakeAddrLValue(DeclPtr, E->getType());
Eli Friedman9fd8b682008-05-13 23:18:27 +00002122
Chad Rosier615ed1a2012-03-29 17:37:10 +00002123 EmitAnyExprToMem(InitExpr, DeclPtr, E->getType().getQualifiers(),
2124 /*Init*/ true);
Eli Friedman9fd8b682008-05-13 23:18:27 +00002125
2126 return Result;
2127}
2128
Richard Smithbb653bd2012-05-14 21:57:21 +00002129LValue CodeGenFunction::EmitInitListLValue(const InitListExpr *E) {
2130 if (!E->isGLValue())
2131 // Initializing an aggregate temporary in C++11: T{...}.
2132 return EmitAggExprToLValue(E);
2133
2134 // An lvalue initializer list must be initializing a reference.
2135 assert(E->getNumInits() == 1 && "reference init with multiple values");
2136 return EmitLValue(E->getInit(0));
2137}
2138
John McCallc07a0c72011-02-17 10:25:35 +00002139LValue CodeGenFunction::
2140EmitConditionalOperatorLValue(const AbstractConditionalOperator *expr) {
2141 if (!expr->isGLValue()) {
John McCall0a6bf2e2011-01-26 19:21:13 +00002142 // ?: here should be an aggregate.
John McCallc07a0c72011-02-17 10:25:35 +00002143 assert((hasAggregateLLVMType(expr->getType()) &&
2144 !expr->getType()->isAnyComplexType()) &&
John McCall0a6bf2e2011-01-26 19:21:13 +00002145 "Unexpected conditional operator!");
John McCallc07a0c72011-02-17 10:25:35 +00002146 return EmitAggExprToLValue(expr);
Anders Carlsson1450adb2009-09-15 16:35:24 +00002147 }
Daniel Dunbarbf1fe8c2009-03-24 02:38:23 +00002148
Eli Friedman59954892012-01-25 05:04:17 +00002149 OpaqueValueMapping binding(*this, expr);
2150
John McCallc07a0c72011-02-17 10:25:35 +00002151 const Expr *condExpr = expr->getCond();
Chris Lattner41c6ab52011-02-27 23:02:32 +00002152 bool CondExprBool;
2153 if (ConstantFoldsToSimpleInteger(condExpr, CondExprBool)) {
John McCallc07a0c72011-02-17 10:25:35 +00002154 const Expr *live = expr->getTrueExpr(), *dead = expr->getFalseExpr();
Chris Lattner41c6ab52011-02-27 23:02:32 +00002155 if (!CondExprBool) std::swap(live, dead);
John McCallc07a0c72011-02-17 10:25:35 +00002156
2157 if (!ContainsLabel(dead))
2158 return EmitLValue(live);
John McCall0a6bf2e2011-01-26 19:21:13 +00002159 }
2160
John McCallc07a0c72011-02-17 10:25:35 +00002161 llvm::BasicBlock *lhsBlock = createBasicBlock("cond.true");
2162 llvm::BasicBlock *rhsBlock = createBasicBlock("cond.false");
2163 llvm::BasicBlock *contBlock = createBasicBlock("cond.end");
John McCall0a6bf2e2011-01-26 19:21:13 +00002164
2165 ConditionalEvaluation eval(*this);
John McCallc07a0c72011-02-17 10:25:35 +00002166 EmitBranchOnBoolExpr(condExpr, lhsBlock, rhsBlock);
John McCall0a6bf2e2011-01-26 19:21:13 +00002167
2168 // Any temporaries created here are conditional.
John McCallc07a0c72011-02-17 10:25:35 +00002169 EmitBlock(lhsBlock);
John McCall0a6bf2e2011-01-26 19:21:13 +00002170 eval.begin(*this);
John McCallc07a0c72011-02-17 10:25:35 +00002171 LValue lhs = EmitLValue(expr->getTrueExpr());
John McCall0a6bf2e2011-01-26 19:21:13 +00002172 eval.end(*this);
2173
John McCallc07a0c72011-02-17 10:25:35 +00002174 if (!lhs.isSimple())
2175 return EmitUnsupportedLValue(expr, "conditional operator");
John McCall0a6bf2e2011-01-26 19:21:13 +00002176
John McCallc07a0c72011-02-17 10:25:35 +00002177 lhsBlock = Builder.GetInsertBlock();
2178 Builder.CreateBr(contBlock);
John McCall0a6bf2e2011-01-26 19:21:13 +00002179
2180 // Any temporaries created here are conditional.
John McCallc07a0c72011-02-17 10:25:35 +00002181 EmitBlock(rhsBlock);
John McCall0a6bf2e2011-01-26 19:21:13 +00002182 eval.begin(*this);
John McCallc07a0c72011-02-17 10:25:35 +00002183 LValue rhs = EmitLValue(expr->getFalseExpr());
John McCall0a6bf2e2011-01-26 19:21:13 +00002184 eval.end(*this);
John McCallc07a0c72011-02-17 10:25:35 +00002185 if (!rhs.isSimple())
2186 return EmitUnsupportedLValue(expr, "conditional operator");
2187 rhsBlock = Builder.GetInsertBlock();
John McCall0a6bf2e2011-01-26 19:21:13 +00002188
John McCallc07a0c72011-02-17 10:25:35 +00002189 EmitBlock(contBlock);
John McCall0a6bf2e2011-01-26 19:21:13 +00002190
Jay Foad20c0f022011-03-30 11:28:58 +00002191 llvm::PHINode *phi = Builder.CreatePHI(lhs.getAddress()->getType(), 2,
John McCall0a6bf2e2011-01-26 19:21:13 +00002192 "cond-lvalue");
John McCallc07a0c72011-02-17 10:25:35 +00002193 phi->addIncoming(lhs.getAddress(), lhsBlock);
2194 phi->addIncoming(rhs.getAddress(), rhsBlock);
2195 return MakeAddrLValue(phi, expr->getType());
Daniel Dunbarbf1fe8c2009-03-24 02:38:23 +00002196}
2197
Richard Smithbb653bd2012-05-14 21:57:21 +00002198/// EmitCastLValue - Casts are never lvalues unless that cast is to a reference
2199/// type. If the cast is to a reference, we can have the usual lvalue result,
Mike Stump65511702009-11-16 06:50:58 +00002200/// otherwise if a cast is needed by the code generator in an lvalue context,
2201/// then it must mean that we need the address of an aggregate in order to
Richard Smithbb653bd2012-05-14 21:57:21 +00002202/// access one of its members. This can happen for all the reasons that casts
Mike Stump65511702009-11-16 06:50:58 +00002203/// are permitted with aggregate result, including noop aggregate casts, and
2204/// cast from scalar to union.
Chris Lattner28bcf1a2009-03-18 18:28:57 +00002205LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) {
Anders Carlssond95f9602009-09-12 16:16:49 +00002206 switch (E->getCastKind()) {
John McCalle3027922010-08-25 11:45:40 +00002207 case CK_ToVoid:
Eli Friedman8c98dff2009-11-16 05:48:01 +00002208 return EmitUnsupportedLValue(E, "unexpected cast lvalue");
John McCall8cb679e2010-11-15 09:13:47 +00002209
2210 case CK_Dependent:
2211 llvm_unreachable("dependent cast kind in IR gen!");
David Chisnallfa35df62012-01-16 17:27:18 +00002212
2213 // These two casts are currently treated as no-ops, although they could
2214 // potentially be real operations depending on the target's ABI.
2215 case CK_NonAtomicToAtomic:
2216 case CK_AtomicToNonAtomic:
John McCall8cb679e2010-11-15 09:13:47 +00002217
John McCalle3027922010-08-25 11:45:40 +00002218 case CK_NoOp:
Douglas Gregor21d3fca2011-01-27 23:22:05 +00002219 case CK_LValueToRValue:
2220 if (!E->getSubExpr()->Classify(getContext()).isPRValue()
2221 || E->getType()->isRecordType())
John McCalle26a8722010-12-04 08:14:53 +00002222 return EmitLValue(E->getSubExpr());
Douglas Gregorcdb466e2010-07-15 18:58:16 +00002223 // Fall through to synthesize a temporary.
John McCall8cb679e2010-11-15 09:13:47 +00002224
John McCalle3027922010-08-25 11:45:40 +00002225 case CK_BitCast:
2226 case CK_ArrayToPointerDecay:
2227 case CK_FunctionToPointerDecay:
2228 case CK_NullToMemberPointer:
John McCalle84af4e2010-11-13 01:35:44 +00002229 case CK_NullToPointer:
John McCalle3027922010-08-25 11:45:40 +00002230 case CK_IntegralToPointer:
2231 case CK_PointerToIntegral:
John McCall8cb679e2010-11-15 09:13:47 +00002232 case CK_PointerToBoolean:
John McCalle3027922010-08-25 11:45:40 +00002233 case CK_VectorSplat:
2234 case CK_IntegralCast:
John McCall8cb679e2010-11-15 09:13:47 +00002235 case CK_IntegralToBoolean:
John McCalle3027922010-08-25 11:45:40 +00002236 case CK_IntegralToFloating:
2237 case CK_FloatingToIntegral:
John McCall8cb679e2010-11-15 09:13:47 +00002238 case CK_FloatingToBoolean:
John McCalle3027922010-08-25 11:45:40 +00002239 case CK_FloatingCast:
John McCallc5e62b42010-11-13 09:02:35 +00002240 case CK_FloatingRealToComplex:
John McCalld7646252010-11-14 08:17:51 +00002241 case CK_FloatingComplexToReal:
2242 case CK_FloatingComplexToBoolean:
John McCallc5e62b42010-11-13 09:02:35 +00002243 case CK_FloatingComplexCast:
John McCalld7646252010-11-14 08:17:51 +00002244 case CK_FloatingComplexToIntegralComplex:
John McCallc5e62b42010-11-13 09:02:35 +00002245 case CK_IntegralRealToComplex:
John McCalld7646252010-11-14 08:17:51 +00002246 case CK_IntegralComplexToReal:
2247 case CK_IntegralComplexToBoolean:
John McCallc5e62b42010-11-13 09:02:35 +00002248 case CK_IntegralComplexCast:
John McCalld7646252010-11-14 08:17:51 +00002249 case CK_IntegralComplexToFloatingComplex:
John McCalle3027922010-08-25 11:45:40 +00002250 case CK_DerivedToBaseMemberPointer:
2251 case CK_BaseToDerivedMemberPointer:
2252 case CK_MemberPointerToBoolean:
John McCallc62bb392012-02-15 01:22:51 +00002253 case CK_ReinterpretMemberPointer:
John McCall31168b02011-06-15 23:02:42 +00002254 case CK_AnyPointerToBlockPointerCast:
John McCall2d637d22011-09-10 06:18:15 +00002255 case CK_ARCProduceObject:
2256 case CK_ARCConsumeObject:
2257 case CK_ARCReclaimReturnedObject:
Douglas Gregored90df32012-02-22 05:02:47 +00002258 case CK_ARCExtendBlockObject:
2259 case CK_CopyAndAutoreleaseBlockObject: {
Douglas Gregorcdb466e2010-07-15 18:58:16 +00002260 // These casts only produce lvalues when we're binding a reference to a
2261 // temporary realized from a (converted) pure rvalue. Emit the expression
2262 // as a value, copy it into a temporary, and return an lvalue referring to
2263 // that temporary.
2264 llvm::Value *V = CreateMemTemp(E->getType(), "ref.temp");
Chad Rosier615ed1a2012-03-29 17:37:10 +00002265 EmitAnyExprToMem(E, V, E->getType().getQualifiers(), false);
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002266 return MakeAddrLValue(V, E->getType());
Douglas Gregorcdb466e2010-07-15 18:58:16 +00002267 }
Eli Friedman8c98dff2009-11-16 05:48:01 +00002268
Anders Carlsson8a01a752011-04-11 02:03:26 +00002269 case CK_Dynamic: {
Mike Stump65511702009-11-16 06:50:58 +00002270 LValue LV = EmitLValue(E->getSubExpr());
2271 llvm::Value *V = LV.getAddress();
2272 const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(E);
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002273 return MakeAddrLValue(EmitDynamicCast(V, DCE), E->getType());
Mike Stump65511702009-11-16 06:50:58 +00002274 }
2275
John McCalle3027922010-08-25 11:45:40 +00002276 case CK_ConstructorConversion:
2277 case CK_UserDefinedConversion:
John McCall9320b872011-09-09 05:25:32 +00002278 case CK_CPointerToObjCPointerCast:
2279 case CK_BlockPointerToObjCPointerCast:
Chris Lattner28bcf1a2009-03-18 18:28:57 +00002280 return EmitLValue(E->getSubExpr());
Anders Carlssond95f9602009-09-12 16:16:49 +00002281
John McCalle3027922010-08-25 11:45:40 +00002282 case CK_UncheckedDerivedToBase:
2283 case CK_DerivedToBase: {
Anders Carlssond95f9602009-09-12 16:16:49 +00002284 const RecordType *DerivedClassTy =
2285 E->getSubExpr()->getType()->getAs<RecordType>();
2286 CXXRecordDecl *DerivedClassDecl =
2287 cast<CXXRecordDecl>(DerivedClassTy->getDecl());
Anders Carlssond95f9602009-09-12 16:16:49 +00002288
2289 LValue LV = EmitLValue(E->getSubExpr());
John McCalle26a8722010-12-04 08:14:53 +00002290 llvm::Value *This = LV.getAddress();
Anders Carlssond95f9602009-09-12 16:16:49 +00002291
2292 // Perform the derived-to-base conversion
2293 llvm::Value *Base =
Fariborz Jahanian64cda8b2010-06-17 23:00:29 +00002294 GetAddressOfBaseClass(This, DerivedClassDecl,
John McCallcf142162010-08-07 06:22:56 +00002295 E->path_begin(), E->path_end(),
2296 /*NullCheckValue=*/false);
Anders Carlssond95f9602009-09-12 16:16:49 +00002297
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002298 return MakeAddrLValue(Base, E->getType());
Anders Carlssond95f9602009-09-12 16:16:49 +00002299 }
John McCalle3027922010-08-25 11:45:40 +00002300 case CK_ToUnion:
Daniel Dunbar9c4e4652010-02-05 20:02:42 +00002301 return EmitAggExprToLValue(E);
John McCalle3027922010-08-25 11:45:40 +00002302 case CK_BaseToDerived: {
Anders Carlsson8c793172009-11-23 17:57:54 +00002303 const RecordType *DerivedClassTy = E->getType()->getAs<RecordType>();
2304 CXXRecordDecl *DerivedClassDecl =
2305 cast<CXXRecordDecl>(DerivedClassTy->getDecl());
2306
2307 LValue LV = EmitLValue(E->getSubExpr());
2308
2309 // Perform the base-to-derived conversion
2310 llvm::Value *Derived =
Anders Carlsson8a64c1c2010-04-24 21:23:59 +00002311 GetAddressOfDerivedClass(LV.getAddress(), DerivedClassDecl,
John McCallcf142162010-08-07 06:22:56 +00002312 E->path_begin(), E->path_end(),
2313 /*NullCheckValue=*/false);
Anders Carlsson8c793172009-11-23 17:57:54 +00002314
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002315 return MakeAddrLValue(Derived, E->getType());
Eli Friedman8c98dff2009-11-16 05:48:01 +00002316 }
John McCalle3027922010-08-25 11:45:40 +00002317 case CK_LValueBitCast: {
Eli Friedman8c98dff2009-11-16 05:48:01 +00002318 // This must be a reinterpret_cast (or c-style equivalent).
2319 const ExplicitCastExpr *CE = cast<ExplicitCastExpr>(E);
Anders Carlsson50cb3212009-11-14 21:21:42 +00002320
2321 LValue LV = EmitLValue(E->getSubExpr());
2322 llvm::Value *V = Builder.CreateBitCast(LV.getAddress(),
2323 ConvertType(CE->getTypeAsWritten()));
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002324 return MakeAddrLValue(V, E->getType());
Anders Carlsson50cb3212009-11-14 21:21:42 +00002325 }
John McCalle3027922010-08-25 11:45:40 +00002326 case CK_ObjCObjectLValueCast: {
Douglas Gregor8b2d2fe2010-08-07 11:51:51 +00002327 LValue LV = EmitLValue(E->getSubExpr());
2328 QualType ToType = getContext().getLValueReferenceType(E->getType());
2329 llvm::Value *V = Builder.CreateBitCast(LV.getAddress(),
2330 ConvertType(ToType));
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002331 return MakeAddrLValue(V, E->getType());
Douglas Gregor8b2d2fe2010-08-07 11:51:51 +00002332 }
Anders Carlssond95f9602009-09-12 16:16:49 +00002333 }
Douglas Gregorcdb466e2010-07-15 18:58:16 +00002334
2335 llvm_unreachable("Unhandled lvalue cast kind?");
Chris Lattner28bcf1a2009-03-18 18:28:57 +00002336}
2337
Fariborz Jahaniane4d94ce2009-10-20 23:29:04 +00002338LValue CodeGenFunction::EmitNullInitializationLValue(
Douglas Gregor747eb782010-07-08 06:14:04 +00002339 const CXXScalarValueInitExpr *E) {
Fariborz Jahaniane4d94ce2009-10-20 23:29:04 +00002340 QualType Ty = E->getType();
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002341 LValue LV = MakeAddrLValue(CreateMemTemp(Ty), Ty);
Anders Carlssonc0964b62010-05-22 17:35:42 +00002342 EmitNullInitialization(LV.getAddress(), Ty);
Daniel Dunbara7566f12010-02-09 02:48:28 +00002343 return LV;
Fariborz Jahaniane4d94ce2009-10-20 23:29:04 +00002344}
2345
John McCall1bf58462011-02-16 08:02:54 +00002346LValue CodeGenFunction::EmitOpaqueValueLValue(const OpaqueValueExpr *e) {
John McCall9a549612011-11-08 22:54:08 +00002347 assert(OpaqueValueMappingData::shouldBindAsLValue(e));
John McCallc07a0c72011-02-17 10:25:35 +00002348 return getOpaqueLValueMapping(e);
John McCall1bf58462011-02-16 08:02:54 +00002349}
2350
Douglas Gregorfe314812011-06-21 17:03:29 +00002351LValue CodeGenFunction::EmitMaterializeTemporaryExpr(
2352 const MaterializeTemporaryExpr *E) {
John McCall17054bd62011-08-26 21:08:13 +00002353 RValue RV = EmitReferenceBindingToExpr(E, /*InitializedDecl=*/0);
Douglas Gregord410c082011-06-21 18:20:46 +00002354 return MakeAddrLValue(RV.getScalarVal(), E->getType());
Douglas Gregorfe314812011-06-21 17:03:29 +00002355}
2356
Eli Friedman7f1ff602012-04-16 03:54:45 +00002357RValue CodeGenFunction::EmitRValueForField(LValue LV,
Anton Korobeynikov4215ca72012-04-13 11:22:00 +00002358 const FieldDecl *FD) {
2359 QualType FT = FD->getType();
Eli Friedman7f1ff602012-04-16 03:54:45 +00002360 LValue FieldLV = EmitLValueForField(LV, FD);
Anton Korobeynikov4215ca72012-04-13 11:22:00 +00002361 if (FT->isAnyComplexType())
Eli Friedman7f1ff602012-04-16 03:54:45 +00002362 return RValue::getComplex(
2363 LoadComplexFromAddr(FieldLV.getAddress(),
2364 FieldLV.isVolatileQualified()));
Anton Korobeynikov4215ca72012-04-13 11:22:00 +00002365 else if (CodeGenFunction::hasAggregateLLVMType(FT))
Eli Friedman7f1ff602012-04-16 03:54:45 +00002366 return FieldLV.asAggregateRValue();
Anton Korobeynikov4215ca72012-04-13 11:22:00 +00002367
Eli Friedman7f1ff602012-04-16 03:54:45 +00002368 return EmitLoadOfLValue(FieldLV);
Anton Korobeynikov4215ca72012-04-13 11:22:00 +00002369}
Douglas Gregorfe314812011-06-21 17:03:29 +00002370
Chris Lattnere47e4402007-06-01 18:02:12 +00002371//===--------------------------------------------------------------------===//
2372// Expression Emission
2373//===--------------------------------------------------------------------===//
2374
Anders Carlsson17490832009-12-24 20:40:36 +00002375RValue CodeGenFunction::EmitCallExpr(const CallExpr *E,
2376 ReturnValueSlot ReturnValue) {
Eric Christopher7cdf9482011-10-13 21:45:18 +00002377 if (CGDebugInfo *DI = getDebugInfo())
2378 DI->EmitLocation(Builder, E->getLocStart());
Devang Pateld3a6b0f2011-03-04 18:54:42 +00002379
Daniel Dunbarcdbb5e32009-02-20 18:06:48 +00002380 // Builtins never have block type.
Daniel Dunbarbb197e42009-01-09 16:50:52 +00002381 if (E->getCallee()->getType()->isBlockPointerType())
Anders Carlssonbfb36712009-12-24 21:13:40 +00002382 return EmitBlockCallExpr(E, ReturnValue);
Daniel Dunbarbb197e42009-01-09 16:50:52 +00002383
Anders Carlssone5fd6f22009-04-03 22:50:24 +00002384 if (const CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(E))
Anders Carlssonbfb36712009-12-24 21:13:40 +00002385 return EmitCXXMemberCallExpr(CE, ReturnValue);
Mike Stump4a3999f2009-09-09 13:00:44 +00002386
Peter Collingbournefe883422011-10-06 18:29:37 +00002387 if (const CUDAKernelCallExpr *CE = dyn_cast<CUDAKernelCallExpr>(E))
2388 return EmitCUDAKernelCallExpr(CE, ReturnValue);
2389
Douglas Gregore0e96302011-09-06 21:41:04 +00002390 const Decl *TargetDecl = E->getCalleeDecl();
2391 if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(TargetDecl)) {
2392 if (unsigned builtinID = FD->getBuiltinID())
2393 return EmitBuiltinExpr(FD, builtinID, E);
Daniel Dunbarcdbb5e32009-02-20 18:06:48 +00002394 }
2395
Chris Lattner4ca97c32009-06-13 00:26:38 +00002396 if (const CXXOperatorCallExpr *CE = dyn_cast<CXXOperatorCallExpr>(E))
Anders Carlsson4034a952009-05-27 04:18:27 +00002397 if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(TargetDecl))
Anders Carlssonbfb36712009-12-24 21:13:40 +00002398 return EmitCXXOperatorMemberCallExpr(CE, MD, ReturnValue);
Mike Stump4a3999f2009-09-09 13:00:44 +00002399
John McCall31168b02011-06-15 23:02:42 +00002400 if (const CXXPseudoDestructorExpr *PseudoDtor
2401 = dyn_cast<CXXPseudoDestructorExpr>(E->getCallee()->IgnoreParens())) {
2402 QualType DestroyedType = PseudoDtor->getDestroyedType();
David Blaikiebbafb8a2012-03-11 07:00:24 +00002403 if (getContext().getLangOpts().ObjCAutoRefCount &&
John McCall31168b02011-06-15 23:02:42 +00002404 DestroyedType->isObjCLifetimeType() &&
2405 (DestroyedType.getObjCLifetime() == Qualifiers::OCL_Strong ||
2406 DestroyedType.getObjCLifetime() == Qualifiers::OCL_Weak)) {
Benjamin Kramerdd19c012011-06-18 10:34:00 +00002407 // Automatic Reference Counting:
2408 // If the pseudo-expression names a retainable object with weak or
2409 // strong lifetime, the object shall be released.
John McCall31168b02011-06-15 23:02:42 +00002410 Expr *BaseExpr = PseudoDtor->getBase();
2411 llvm::Value *BaseValue = NULL;
2412 Qualifiers BaseQuals;
2413
Benjamin Kramerdd19c012011-06-18 10:34:00 +00002414 // If this is s.x, emit s as an lvalue. If it is s->x, emit s as a scalar.
John McCall31168b02011-06-15 23:02:42 +00002415 if (PseudoDtor->isArrow()) {
2416 BaseValue = EmitScalarExpr(BaseExpr);
2417 const PointerType *PTy = BaseExpr->getType()->getAs<PointerType>();
2418 BaseQuals = PTy->getPointeeType().getQualifiers();
2419 } else {
2420 LValue BaseLV = EmitLValue(BaseExpr);
John McCall31168b02011-06-15 23:02:42 +00002421 BaseValue = BaseLV.getAddress();
2422 QualType BaseTy = BaseExpr->getType();
2423 BaseQuals = BaseTy.getQualifiers();
2424 }
2425
2426 switch (PseudoDtor->getDestroyedType().getObjCLifetime()) {
2427 case Qualifiers::OCL_None:
2428 case Qualifiers::OCL_ExplicitNone:
2429 case Qualifiers::OCL_Autoreleasing:
2430 break;
2431
2432 case Qualifiers::OCL_Strong:
2433 EmitARCRelease(Builder.CreateLoad(BaseValue,
Benjamin Kramerdd19c012011-06-18 10:34:00 +00002434 PseudoDtor->getDestroyedType().isVolatileQualified()),
John McCall31168b02011-06-15 23:02:42 +00002435 /*precise*/ true);
2436 break;
2437
2438 case Qualifiers::OCL_Weak:
2439 EmitARCDestroyWeak(BaseValue);
2440 break;
2441 }
2442 } else {
2443 // C++ [expr.pseudo]p1:
2444 // The result shall only be used as the operand for the function call
2445 // operator (), and the result of such a call has type void. The only
2446 // effect is the evaluation of the postfix-expression before the dot or
2447 // arrow.
2448 EmitScalarExpr(E->getCallee());
2449 }
2450
Douglas Gregorad8a3362009-09-04 17:36:40 +00002451 return RValue::get(0);
2452 }
Mike Stump4a3999f2009-09-09 13:00:44 +00002453
Chris Lattner2da04b32007-08-24 05:35:26 +00002454 llvm::Value *Callee = EmitScalarExpr(E->getCallee());
Anders Carlsson17490832009-12-24 20:40:36 +00002455 return EmitCall(E->getCallee()->getType(), Callee, ReturnValue,
Anders Carlsson3a9463b2009-05-27 01:22:39 +00002456 E->arg_begin(), E->arg_end(), TargetDecl);
Chris Lattner9e47ead2007-08-31 04:44:06 +00002457}
2458
Daniel Dunbar8cde00a2008-09-04 03:20:13 +00002459LValue CodeGenFunction::EmitBinaryOperatorLValue(const BinaryOperator *E) {
Chris Lattnere541ea32009-05-12 21:28:12 +00002460 // Comma expressions just emit their LHS then their RHS as an l-value.
John McCalle3027922010-08-25 11:45:40 +00002461 if (E->getOpcode() == BO_Comma) {
John McCalla2342eb2010-12-05 02:00:02 +00002462 EmitIgnoredExpr(E->getLHS());
Eli Friedman5445f6e2009-12-07 20:18:11 +00002463 EnsureInsertPoint();
Chris Lattnere541ea32009-05-12 21:28:12 +00002464 return EmitLValue(E->getRHS());
2465 }
Mike Stump4a3999f2009-09-09 13:00:44 +00002466
John McCalle3027922010-08-25 11:45:40 +00002467 if (E->getOpcode() == BO_PtrMemD ||
2468 E->getOpcode() == BO_PtrMemI)
Fariborz Jahanianffba6622009-10-22 22:57:31 +00002469 return EmitPointerToDataMemberBinaryExpr(E);
Daniel Dunbar8cde00a2008-09-04 03:20:13 +00002470
John McCalla2342eb2010-12-05 02:00:02 +00002471 assert(E->getOpcode() == BO_Assign && "unexpected binary l-value");
John McCall31168b02011-06-15 23:02:42 +00002472
2473 // Note that in all of these cases, __block variables need the RHS
2474 // evaluated first just in case the variable gets moved by the RHS.
John McCall4f29b492010-11-16 23:07:28 +00002475
Anders Carlsson0999aaf2009-10-19 18:28:22 +00002476 if (!hasAggregateLLVMType(E->getType())) {
John McCall31168b02011-06-15 23:02:42 +00002477 switch (E->getLHS()->getType().getObjCLifetime()) {
2478 case Qualifiers::OCL_Strong:
2479 return EmitARCStoreStrong(E, /*ignored*/ false).first;
2480
2481 case Qualifiers::OCL_Autoreleasing:
2482 return EmitARCStoreAutoreleasing(E).first;
2483
2484 // No reason to do any of these differently.
2485 case Qualifiers::OCL_None:
2486 case Qualifiers::OCL_ExplicitNone:
2487 case Qualifiers::OCL_Weak:
2488 break;
2489 }
2490
John McCalld0a30012010-12-06 06:10:02 +00002491 RValue RV = EmitAnyExpr(E->getRHS());
Anders Carlsson0999aaf2009-10-19 18:28:22 +00002492 LValue LV = EmitLValue(E->getLHS());
John McCall55e1fbc2011-06-25 02:11:03 +00002493 EmitStoreThroughLValue(RV, LV);
Anders Carlsson0999aaf2009-10-19 18:28:22 +00002494 return LV;
2495 }
John McCall4f29b492010-11-16 23:07:28 +00002496
2497 if (E->getType()->isAnyComplexType())
2498 return EmitComplexAssignmentLValue(E);
2499
Daniel Dunbard0bc7b92010-02-05 19:38:31 +00002500 return EmitAggExprToLValue(E);
Daniel Dunbar8cde00a2008-09-04 03:20:13 +00002501}
2502
Christopher Lambd91c3d42007-12-29 05:02:41 +00002503LValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) {
Christopher Lambd91c3d42007-12-29 05:02:41 +00002504 RValue RV = EmitCallExpr(E);
Anders Carlsson4ae70ff2009-05-27 01:45:47 +00002505
Chris Lattnerab5e0af2009-10-28 17:39:19 +00002506 if (!RV.isScalar())
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002507 return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
Chris Lattnerab5e0af2009-10-28 17:39:19 +00002508
2509 assert(E->getCallReturnType()->isReferenceType() &&
2510 "Can't have a scalar return unless the return type is a "
2511 "reference type!");
Mike Stump4a3999f2009-09-09 13:00:44 +00002512
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002513 return MakeAddrLValue(RV.getScalarVal(), E->getType());
Christopher Lambd91c3d42007-12-29 05:02:41 +00002514}
2515
Daniel Dunbar8d9dc4a2009-02-11 20:59:32 +00002516LValue CodeGenFunction::EmitVAArgExprLValue(const VAArgExpr *E) {
2517 // FIXME: This shouldn't require another copy.
Daniel Dunbard0bc7b92010-02-05 19:38:31 +00002518 return EmitAggExprToLValue(E);
Daniel Dunbar8d9dc4a2009-02-11 20:59:32 +00002519}
2520
Anders Carlsson3be22e22009-05-30 23:23:33 +00002521LValue CodeGenFunction::EmitCXXConstructLValue(const CXXConstructExpr *E) {
John McCall8ea46b62010-09-18 00:58:34 +00002522 assert(E->getType()->getAsCXXRecordDecl()->hasTrivialDestructor()
2523 && "binding l-value to type which needs a temporary");
Benjamin Kramer76399eb2011-09-27 21:06:10 +00002524 AggValueSlot Slot = CreateAggTemp(E->getType());
John McCall7a626f62010-09-15 10:14:12 +00002525 EmitCXXConstructExpr(E, Slot);
2526 return MakeAddrLValue(Slot.getAddr(), E->getType());
Anders Carlsson3be22e22009-05-30 23:23:33 +00002527}
2528
Anders Carlssonfd2af0c2009-05-30 23:30:54 +00002529LValue
Mike Stumpc9b231c2009-11-15 08:09:41 +00002530CodeGenFunction::EmitCXXTypeidLValue(const CXXTypeidExpr *E) {
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002531 return MakeAddrLValue(EmitCXXTypeidExpr(E), E->getType());
Mike Stumpc9b231c2009-11-15 08:09:41 +00002532}
2533
2534LValue
Anders Carlssonfd2af0c2009-05-30 23:30:54 +00002535CodeGenFunction::EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E) {
John McCall8ea46b62010-09-18 00:58:34 +00002536 AggValueSlot Slot = CreateAggTemp(E->getType(), "temp.lvalue");
John McCallcac93852011-08-26 08:02:37 +00002537 Slot.setExternallyDestructed();
John McCall8ea46b62010-09-18 00:58:34 +00002538 EmitAggExpr(E->getSubExpr(), Slot);
Peter Collingbourne702b2842011-11-27 22:09:22 +00002539 EmitCXXTemporary(E->getTemporary(), E->getType(), Slot.getAddr());
John McCall8ea46b62010-09-18 00:58:34 +00002540 return MakeAddrLValue(Slot.getAddr(), E->getType());
Anders Carlssonfd2af0c2009-05-30 23:30:54 +00002541}
2542
Eli Friedman5bc17122012-02-08 05:34:55 +00002543LValue
2544CodeGenFunction::EmitLambdaLValue(const LambdaExpr *E) {
Eli Friedman5bc17122012-02-08 05:34:55 +00002545 AggValueSlot Slot = CreateAggTemp(E->getType(), "temp.lvalue");
Eli Friedmanc370a7e2012-02-09 03:32:31 +00002546 EmitLambdaExpr(E, Slot);
Eli Friedman5bc17122012-02-08 05:34:55 +00002547 return MakeAddrLValue(Slot.getAddr(), E->getType());
2548}
2549
Daniel Dunbarc8317a42008-08-23 10:51:21 +00002550LValue CodeGenFunction::EmitObjCMessageExprLValue(const ObjCMessageExpr *E) {
Daniel Dunbarc8317a42008-08-23 10:51:21 +00002551 RValue RV = EmitObjCMessageExpr(E);
Anders Carlsson280e61f12010-06-21 20:59:55 +00002552
2553 if (!RV.isScalar())
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002554 return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
Anders Carlsson280e61f12010-06-21 20:59:55 +00002555
2556 assert(E->getMethodDecl()->getResultType()->isReferenceType() &&
2557 "Can't have a scalar return unless the return type is a "
2558 "reference type!");
2559
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002560 return MakeAddrLValue(RV.getScalarVal(), E->getType());
Daniel Dunbarc8317a42008-08-23 10:51:21 +00002561}
2562
Fariborz Jahanian9240f3d2010-06-17 19:56:20 +00002563LValue CodeGenFunction::EmitObjCSelectorLValue(const ObjCSelectorExpr *E) {
2564 llvm::Value *V =
2565 CGM.getObjCRuntime().GetSelector(Builder, E->getSelector(), true);
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002566 return MakeAddrLValue(V, E->getType());
Fariborz Jahanian9240f3d2010-06-17 19:56:20 +00002567}
2568
Daniel Dunbar722f4242009-04-22 05:08:15 +00002569llvm::Value *CodeGenFunction::EmitIvarOffset(const ObjCInterfaceDecl *Interface,
Daniel Dunbar1c64e5d2008-09-24 04:00:38 +00002570 const ObjCIvarDecl *Ivar) {
Fariborz Jahanian21fc74c2009-02-10 19:02:04 +00002571 return CGM.getObjCRuntime().EmitIvarOffset(*this, Interface, Ivar);
Daniel Dunbar1c64e5d2008-09-24 04:00:38 +00002572}
2573
Fariborz Jahanianc88a70d2009-02-03 00:09:52 +00002574LValue CodeGenFunction::EmitLValueForIvar(QualType ObjectTy,
2575 llvm::Value *BaseValue,
Daniel Dunbar1c64e5d2008-09-24 04:00:38 +00002576 const ObjCIvarDecl *Ivar,
2577 unsigned CVRQualifiers) {
Chris Lattnerc4688d22009-04-17 17:44:48 +00002578 return CGM.getObjCRuntime().EmitObjCValueForIvar(*this, ObjectTy, BaseValue,
Daniel Dunbar9ebf9512009-04-21 01:19:28 +00002579 Ivar, CVRQualifiers);
Daniel Dunbar1c64e5d2008-09-24 04:00:38 +00002580}
2581
2582LValue CodeGenFunction::EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E) {
Anders Carlssonc13b85a2008-08-25 01:53:23 +00002583 // FIXME: A lot of the code below could be shared with EmitMemberExpr.
2584 llvm::Value *BaseValue = 0;
2585 const Expr *BaseExpr = E->getBase();
John McCall8ccfcb52009-09-24 19:53:00 +00002586 Qualifiers BaseQuals;
Fariborz Jahanianc88a70d2009-02-03 00:09:52 +00002587 QualType ObjectTy;
Anders Carlssonc13b85a2008-08-25 01:53:23 +00002588 if (E->isArrow()) {
2589 BaseValue = EmitScalarExpr(BaseExpr);
Steve Naroff7cae42b2009-07-10 23:34:53 +00002590 ObjectTy = BaseExpr->getType()->getPointeeType();
John McCall8ccfcb52009-09-24 19:53:00 +00002591 BaseQuals = ObjectTy.getQualifiers();
Anders Carlssonc13b85a2008-08-25 01:53:23 +00002592 } else {
2593 LValue BaseLV = EmitLValue(BaseExpr);
2594 // FIXME: this isn't right for bitfields.
2595 BaseValue = BaseLV.getAddress();
Fariborz Jahanianc88a70d2009-02-03 00:09:52 +00002596 ObjectTy = BaseExpr->getType();
John McCall8ccfcb52009-09-24 19:53:00 +00002597 BaseQuals = ObjectTy.getQualifiers();
Anders Carlssonc13b85a2008-08-25 01:53:23 +00002598 }
Daniel Dunbar1c64e5d2008-09-24 04:00:38 +00002599
Fariborz Jahaniande1d3242009-09-16 23:11:23 +00002600 LValue LV =
John McCall8ccfcb52009-09-24 19:53:00 +00002601 EmitLValueForIvar(ObjectTy, BaseValue, E->getDecl(),
2602 BaseQuals.getCVRQualifiers());
Fariborz Jahaniande1d3242009-09-16 23:11:23 +00002603 setObjCGCLValueClass(getContext(), E, LV);
2604 return LV;
Chris Lattner4bd55962008-03-30 23:03:07 +00002605}
2606
Chris Lattnera4185c52009-04-25 19:35:26 +00002607LValue CodeGenFunction::EmitStmtExprLValue(const StmtExpr *E) {
Chris Lattnera4185c52009-04-25 19:35:26 +00002608 // Can only get l-value for message expression returning aggregate type
2609 RValue RV = EmitAnyExprToTemp(E);
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002610 return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
Chris Lattnera4185c52009-04-25 19:35:26 +00002611}
2612
Anders Carlsson0435ed52009-12-24 19:08:58 +00002613RValue CodeGenFunction::EmitCall(QualType CalleeType, llvm::Value *Callee,
Anders Carlsson17490832009-12-24 20:40:36 +00002614 ReturnValueSlot ReturnValue,
Anders Carlsson3a9463b2009-05-27 01:22:39 +00002615 CallExpr::const_arg_iterator ArgBeg,
2616 CallExpr::const_arg_iterator ArgEnd,
2617 const Decl *TargetDecl) {
Mike Stump4a3999f2009-09-09 13:00:44 +00002618 // Get the actual function type. The callee type will always be a pointer to
2619 // function type or a block pointer type.
2620 assert(CalleeType->isFunctionPointerType() &&
Anders Carlssond8db8532009-04-07 18:53:02 +00002621 "Call must have function pointer type!");
2622
John McCall6fd4c232009-10-23 08:22:42 +00002623 CalleeType = getContext().getCanonicalType(CalleeType);
2624
John McCallab26cfa2010-02-05 21:31:56 +00002625 const FunctionType *FnType
2626 = cast<FunctionType>(cast<PointerType>(CalleeType)->getPointeeType());
Daniel Dunbarc722b852008-08-30 03:02:31 +00002627
2628 CallArgList Args;
John McCall6fd4c232009-10-23 08:22:42 +00002629 EmitCallArgs(Args, dyn_cast<FunctionProtoType>(FnType), ArgBeg, ArgEnd);
Daniel Dunbarc722b852008-08-30 03:02:31 +00002630
John McCalla729c622012-02-17 03:33:10 +00002631 const CGFunctionInfo &FnInfo =
2632 CGM.getTypes().arrangeFunctionCall(Args, FnType);
John McCallcbc038a2011-09-21 08:08:30 +00002633
2634 // C99 6.5.2.2p6:
2635 // If the expression that denotes the called function has a type
2636 // that does not include a prototype, [the default argument
2637 // promotions are performed]. If the number of arguments does not
2638 // equal the number of parameters, the behavior is undefined. If
2639 // the function is defined with a type that includes a prototype,
2640 // and either the prototype ends with an ellipsis (, ...) or the
2641 // types of the arguments after promotion are not compatible with
2642 // the types of the parameters, the behavior is undefined. If the
2643 // function is defined with a type that does not include a
2644 // prototype, and the types of the arguments after promotion are
2645 // not compatible with those of the parameters after promotion,
2646 // the behavior is undefined [except in some trivial cases].
2647 // That is, in the general case, we should assume that a call
2648 // through an unprototyped function type works like a *non-variadic*
2649 // call. The way we make this work is to cast to the exact type
2650 // of the promoted arguments.
John McCalla729c622012-02-17 03:33:10 +00002651 if (isa<FunctionNoProtoType>(FnType) && !FnInfo.isVariadic()) {
2652 llvm::Type *CalleeTy = getTypes().GetFunctionType(FnInfo);
John McCallcbc038a2011-09-21 08:08:30 +00002653 CalleeTy = CalleeTy->getPointerTo();
2654 Callee = Builder.CreateBitCast(Callee, CalleeTy, "callee.knr.cast");
2655 }
2656
2657 return EmitCall(FnInfo, Callee, ReturnValue, Args, TargetDecl);
Daniel Dunbar97db84c2008-08-23 03:46:30 +00002658}
Fariborz Jahanianffba6622009-10-22 22:57:31 +00002659
Chris Lattnerab5e0af2009-10-28 17:39:19 +00002660LValue CodeGenFunction::
2661EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E) {
Eli Friedman928a5672009-11-18 05:01:17 +00002662 llvm::Value *BaseV;
John McCalle3027922010-08-25 11:45:40 +00002663 if (E->getOpcode() == BO_PtrMemI)
Eli Friedman928a5672009-11-18 05:01:17 +00002664 BaseV = EmitScalarExpr(E->getLHS());
2665 else
2666 BaseV = EmitLValue(E->getLHS()).getAddress();
Chris Lattnerab5e0af2009-10-28 17:39:19 +00002667
John McCallc134eb52010-08-31 21:07:20 +00002668 llvm::Value *OffsetV = EmitScalarExpr(E->getRHS());
2669
2670 const MemberPointerType *MPT
2671 = E->getRHS()->getType()->getAs<MemberPointerType>();
2672
2673 llvm::Value *AddV =
2674 CGM.getCXXABI().EmitMemberDataPointerAddress(*this, BaseV, OffsetV, MPT);
2675
2676 return MakeAddrLValue(AddV, MPT->getPointeeType());
Fariborz Jahanianffba6622009-10-22 22:57:31 +00002677}
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002678
2679static void
2680EmitAtomicOp(CodeGenFunction &CGF, AtomicExpr *E, llvm::Value *Dest,
2681 llvm::Value *Ptr, llvm::Value *Val1, llvm::Value *Val2,
2682 uint64_t Size, unsigned Align, llvm::AtomicOrdering Order) {
Richard Smithfeea8832012-04-12 05:08:17 +00002683 llvm::AtomicRMWInst::BinOp Op = llvm::AtomicRMWInst::Add;
2684 llvm::Instruction::BinaryOps PostOp = (llvm::Instruction::BinaryOps)0;
2685
2686 switch (E->getOp()) {
2687 case AtomicExpr::AO__c11_atomic_init:
2688 llvm_unreachable("Already handled!");
2689
2690 case AtomicExpr::AO__c11_atomic_compare_exchange_strong:
2691 case AtomicExpr::AO__c11_atomic_compare_exchange_weak:
2692 case AtomicExpr::AO__atomic_compare_exchange:
2693 case AtomicExpr::AO__atomic_compare_exchange_n: {
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002694 // Note that cmpxchg only supports specifying one ordering and
2695 // doesn't support weak cmpxchg, at least at the moment.
2696 llvm::LoadInst *LoadVal1 = CGF.Builder.CreateLoad(Val1);
2697 LoadVal1->setAlignment(Align);
2698 llvm::LoadInst *LoadVal2 = CGF.Builder.CreateLoad(Val2);
2699 LoadVal2->setAlignment(Align);
2700 llvm::AtomicCmpXchgInst *CXI =
2701 CGF.Builder.CreateAtomicCmpXchg(Ptr, LoadVal1, LoadVal2, Order);
2702 CXI->setVolatile(E->isVolatile());
2703 llvm::StoreInst *StoreVal1 = CGF.Builder.CreateStore(CXI, Val1);
2704 StoreVal1->setAlignment(Align);
2705 llvm::Value *Cmp = CGF.Builder.CreateICmpEQ(CXI, LoadVal1);
2706 CGF.EmitStoreOfScalar(Cmp, CGF.MakeAddrLValue(Dest, E->getType()));
2707 return;
2708 }
2709
Richard Smithfeea8832012-04-12 05:08:17 +00002710 case AtomicExpr::AO__c11_atomic_load:
2711 case AtomicExpr::AO__atomic_load_n:
2712 case AtomicExpr::AO__atomic_load: {
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002713 llvm::LoadInst *Load = CGF.Builder.CreateLoad(Ptr);
2714 Load->setAtomic(Order);
2715 Load->setAlignment(Size);
2716 Load->setVolatile(E->isVolatile());
2717 llvm::StoreInst *StoreDest = CGF.Builder.CreateStore(Load, Dest);
2718 StoreDest->setAlignment(Align);
2719 return;
2720 }
2721
Richard Smithfeea8832012-04-12 05:08:17 +00002722 case AtomicExpr::AO__c11_atomic_store:
2723 case AtomicExpr::AO__atomic_store:
2724 case AtomicExpr::AO__atomic_store_n: {
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002725 assert(!Dest && "Store does not return a value");
2726 llvm::LoadInst *LoadVal1 = CGF.Builder.CreateLoad(Val1);
2727 LoadVal1->setAlignment(Align);
2728 llvm::StoreInst *Store = CGF.Builder.CreateStore(LoadVal1, Ptr);
2729 Store->setAtomic(Order);
2730 Store->setAlignment(Size);
2731 Store->setVolatile(E->isVolatile());
2732 return;
2733 }
2734
Richard Smithfeea8832012-04-12 05:08:17 +00002735 case AtomicExpr::AO__c11_atomic_exchange:
2736 case AtomicExpr::AO__atomic_exchange_n:
2737 case AtomicExpr::AO__atomic_exchange:
2738 Op = llvm::AtomicRMWInst::Xchg;
2739 break;
2740
2741 case AtomicExpr::AO__atomic_add_fetch:
2742 PostOp = llvm::Instruction::Add;
2743 // Fall through.
2744 case AtomicExpr::AO__c11_atomic_fetch_add:
2745 case AtomicExpr::AO__atomic_fetch_add:
2746 Op = llvm::AtomicRMWInst::Add;
2747 break;
2748
2749 case AtomicExpr::AO__atomic_sub_fetch:
2750 PostOp = llvm::Instruction::Sub;
2751 // Fall through.
2752 case AtomicExpr::AO__c11_atomic_fetch_sub:
2753 case AtomicExpr::AO__atomic_fetch_sub:
2754 Op = llvm::AtomicRMWInst::Sub;
2755 break;
2756
2757 case AtomicExpr::AO__atomic_and_fetch:
2758 PostOp = llvm::Instruction::And;
2759 // Fall through.
2760 case AtomicExpr::AO__c11_atomic_fetch_and:
2761 case AtomicExpr::AO__atomic_fetch_and:
2762 Op = llvm::AtomicRMWInst::And;
2763 break;
2764
2765 case AtomicExpr::AO__atomic_or_fetch:
2766 PostOp = llvm::Instruction::Or;
2767 // Fall through.
2768 case AtomicExpr::AO__c11_atomic_fetch_or:
2769 case AtomicExpr::AO__atomic_fetch_or:
2770 Op = llvm::AtomicRMWInst::Or;
2771 break;
2772
2773 case AtomicExpr::AO__atomic_xor_fetch:
2774 PostOp = llvm::Instruction::Xor;
2775 // Fall through.
2776 case AtomicExpr::AO__c11_atomic_fetch_xor:
2777 case AtomicExpr::AO__atomic_fetch_xor:
2778 Op = llvm::AtomicRMWInst::Xor;
2779 break;
Richard Smithd65cee92012-04-13 06:31:38 +00002780
2781 case AtomicExpr::AO__atomic_nand_fetch:
2782 PostOp = llvm::Instruction::And;
2783 // Fall through.
2784 case AtomicExpr::AO__atomic_fetch_nand:
2785 Op = llvm::AtomicRMWInst::Nand;
2786 break;
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002787 }
Richard Smithfeea8832012-04-12 05:08:17 +00002788
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002789 llvm::LoadInst *LoadVal1 = CGF.Builder.CreateLoad(Val1);
2790 LoadVal1->setAlignment(Align);
2791 llvm::AtomicRMWInst *RMWI =
2792 CGF.Builder.CreateAtomicRMW(Op, Ptr, LoadVal1, Order);
2793 RMWI->setVolatile(E->isVolatile());
Richard Smithfeea8832012-04-12 05:08:17 +00002794
2795 // For __atomic_*_fetch operations, perform the operation again to
2796 // determine the value which was written.
2797 llvm::Value *Result = RMWI;
2798 if (PostOp)
2799 Result = CGF.Builder.CreateBinOp(PostOp, RMWI, LoadVal1);
Richard Smithd65cee92012-04-13 06:31:38 +00002800 if (E->getOp() == AtomicExpr::AO__atomic_nand_fetch)
2801 Result = CGF.Builder.CreateNot(Result);
Richard Smithfeea8832012-04-12 05:08:17 +00002802 llvm::StoreInst *StoreDest = CGF.Builder.CreateStore(Result, Dest);
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002803 StoreDest->setAlignment(Align);
2804}
2805
2806// This function emits any expression (scalar, complex, or aggregate)
2807// into a temporary alloca.
2808static llvm::Value *
2809EmitValToTemp(CodeGenFunction &CGF, Expr *E) {
2810 llvm::Value *DeclPtr = CGF.CreateMemTemp(E->getType(), ".atomictmp");
Chad Rosier615ed1a2012-03-29 17:37:10 +00002811 CGF.EmitAnyExprToMem(E, DeclPtr, E->getType().getQualifiers(),
2812 /*Init*/ true);
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002813 return DeclPtr;
2814}
2815
2816static RValue ConvertTempToRValue(CodeGenFunction &CGF, QualType Ty,
2817 llvm::Value *Dest) {
2818 if (Ty->isAnyComplexType())
2819 return RValue::getComplex(CGF.LoadComplexFromAddr(Dest, false));
2820 if (CGF.hasAggregateLLVMType(Ty))
2821 return RValue::getAggregate(Dest);
2822 return RValue::get(CGF.EmitLoadOfScalar(CGF.MakeAddrLValue(Dest, Ty)));
2823}
2824
2825RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E, llvm::Value *Dest) {
2826 QualType AtomicTy = E->getPtr()->getType()->getPointeeType();
Richard Smithfeea8832012-04-12 05:08:17 +00002827 QualType MemTy = AtomicTy;
2828 if (const AtomicType *AT = AtomicTy->getAs<AtomicType>())
2829 MemTy = AT->getValueType();
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002830 CharUnits sizeChars = getContext().getTypeSizeInChars(AtomicTy);
2831 uint64_t Size = sizeChars.getQuantity();
2832 CharUnits alignChars = getContext().getTypeAlignInChars(AtomicTy);
2833 unsigned Align = alignChars.getQuantity();
Eli Friedman4b72fdd2011-10-14 20:59:01 +00002834 unsigned MaxInlineWidth =
2835 getContext().getTargetInfo().getMaxAtomicInlineWidth();
2836 bool UseLibcall = (Size != Align || Size > MaxInlineWidth);
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002837
David Chisnallfa35df62012-01-16 17:27:18 +00002838
2839
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002840 llvm::Value *Ptr, *Order, *OrderFail = 0, *Val1 = 0, *Val2 = 0;
2841 Ptr = EmitScalarExpr(E->getPtr());
David Chisnallfa35df62012-01-16 17:27:18 +00002842
Richard Smithfeea8832012-04-12 05:08:17 +00002843 if (E->getOp() == AtomicExpr::AO__c11_atomic_init) {
David Chisnallfa35df62012-01-16 17:27:18 +00002844 assert(!Dest && "Init does not return a value");
David Chisnalleb9496e2012-04-11 17:24:05 +00002845 if (!hasAggregateLLVMType(E->getVal1()->getType())) {
Douglas Gregor298f43d2012-04-12 20:42:30 +00002846 QualType PointeeType
2847 = E->getPtr()->getType()->getAs<PointerType>()->getPointeeType();
2848 EmitScalarInit(EmitScalarExpr(E->getVal1()),
2849 LValue::MakeAddr(Ptr, PointeeType, alignChars,
2850 getContext()));
David Chisnalleb9496e2012-04-11 17:24:05 +00002851 } else if (E->getType()->isAnyComplexType()) {
2852 EmitComplexExprIntoAddr(E->getVal1(), Ptr, E->isVolatile());
2853 } else {
2854 AggValueSlot Slot = AggValueSlot::forAddr(Ptr, alignChars,
2855 AtomicTy.getQualifiers(),
2856 AggValueSlot::IsNotDestructed,
2857 AggValueSlot::DoesNotNeedGCBarriers,
2858 AggValueSlot::IsNotAliased);
2859 EmitAggExpr(E->getVal1(), Slot);
2860 }
David Chisnallfa35df62012-01-16 17:27:18 +00002861 return RValue::get(0);
2862 }
2863
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002864 Order = EmitScalarExpr(E->getOrder());
Richard Smithfeea8832012-04-12 05:08:17 +00002865
2866 switch (E->getOp()) {
2867 case AtomicExpr::AO__c11_atomic_init:
2868 llvm_unreachable("Already handled!");
2869
2870 case AtomicExpr::AO__c11_atomic_load:
2871 case AtomicExpr::AO__atomic_load_n:
2872 break;
2873
2874 case AtomicExpr::AO__atomic_load:
2875 Dest = EmitScalarExpr(E->getVal1());
2876 break;
2877
2878 case AtomicExpr::AO__atomic_store:
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002879 Val1 = EmitScalarExpr(E->getVal1());
Richard Smithfeea8832012-04-12 05:08:17 +00002880 break;
2881
2882 case AtomicExpr::AO__atomic_exchange:
2883 Val1 = EmitScalarExpr(E->getVal1());
2884 Dest = EmitScalarExpr(E->getVal2());
2885 break;
2886
2887 case AtomicExpr::AO__c11_atomic_compare_exchange_strong:
2888 case AtomicExpr::AO__c11_atomic_compare_exchange_weak:
2889 case AtomicExpr::AO__atomic_compare_exchange_n:
2890 case AtomicExpr::AO__atomic_compare_exchange:
2891 Val1 = EmitScalarExpr(E->getVal1());
2892 if (E->getOp() == AtomicExpr::AO__atomic_compare_exchange)
2893 Val2 = EmitScalarExpr(E->getVal2());
2894 else
2895 Val2 = EmitValToTemp(*this, E->getVal2());
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002896 OrderFail = EmitScalarExpr(E->getOrderFail());
Richard Smithfeea8832012-04-12 05:08:17 +00002897 // Evaluate and discard the 'weak' argument.
2898 if (E->getNumSubExprs() == 6)
2899 EmitScalarExpr(E->getWeak());
2900 break;
2901
2902 case AtomicExpr::AO__c11_atomic_fetch_add:
2903 case AtomicExpr::AO__c11_atomic_fetch_sub:
Richard Smithfeea8832012-04-12 05:08:17 +00002904 if (MemTy->isPointerType()) {
2905 // For pointer arithmetic, we're required to do a bit of math:
2906 // adding 1 to an int* is not the same as adding 1 to a uintptr_t.
Richard Smith01ba47d2012-04-13 00:45:38 +00002907 // ... but only for the C11 builtins. The GNU builtins expect the
2908 // user to multiply by sizeof(T).
Richard Smithfeea8832012-04-12 05:08:17 +00002909 QualType Val1Ty = E->getVal1()->getType();
2910 llvm::Value *Val1Scalar = EmitScalarExpr(E->getVal1());
2911 CharUnits PointeeIncAmt =
2912 getContext().getTypeSizeInChars(MemTy->getPointeeType());
2913 Val1Scalar = Builder.CreateMul(Val1Scalar, CGM.getSize(PointeeIncAmt));
2914 Val1 = CreateMemTemp(Val1Ty, ".atomictmp");
2915 EmitStoreOfScalar(Val1Scalar, MakeAddrLValue(Val1, Val1Ty));
2916 break;
2917 }
2918 // Fall through.
Richard Smith01ba47d2012-04-13 00:45:38 +00002919 case AtomicExpr::AO__atomic_fetch_add:
2920 case AtomicExpr::AO__atomic_fetch_sub:
2921 case AtomicExpr::AO__atomic_add_fetch:
2922 case AtomicExpr::AO__atomic_sub_fetch:
Richard Smithfeea8832012-04-12 05:08:17 +00002923 case AtomicExpr::AO__c11_atomic_store:
2924 case AtomicExpr::AO__c11_atomic_exchange:
2925 case AtomicExpr::AO__atomic_store_n:
2926 case AtomicExpr::AO__atomic_exchange_n:
2927 case AtomicExpr::AO__c11_atomic_fetch_and:
2928 case AtomicExpr::AO__c11_atomic_fetch_or:
2929 case AtomicExpr::AO__c11_atomic_fetch_xor:
2930 case AtomicExpr::AO__atomic_fetch_and:
2931 case AtomicExpr::AO__atomic_fetch_or:
2932 case AtomicExpr::AO__atomic_fetch_xor:
Richard Smithd65cee92012-04-13 06:31:38 +00002933 case AtomicExpr::AO__atomic_fetch_nand:
Richard Smithfeea8832012-04-12 05:08:17 +00002934 case AtomicExpr::AO__atomic_and_fetch:
2935 case AtomicExpr::AO__atomic_or_fetch:
2936 case AtomicExpr::AO__atomic_xor_fetch:
Richard Smithd65cee92012-04-13 06:31:38 +00002937 case AtomicExpr::AO__atomic_nand_fetch:
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002938 Val1 = EmitValToTemp(*this, E->getVal1());
Richard Smithfeea8832012-04-12 05:08:17 +00002939 break;
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002940 }
2941
Richard Smithfeea8832012-04-12 05:08:17 +00002942 if (!E->getType()->isVoidType() && !Dest)
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002943 Dest = CreateMemTemp(E->getType(), ".atomicdst");
2944
David Chisnalldb365f32012-03-29 18:01:11 +00002945 // Use a library call. See: http://gcc.gnu.org/wiki/Atomic/GCCMM/LIbrary .
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002946 if (UseLibcall) {
David Chisnalldb365f32012-03-29 18:01:11 +00002947
2948 llvm::SmallVector<QualType, 5> Params;
2949 CallArgList Args;
2950 // Size is always the first parameter
2951 Args.add(RValue::get(llvm::ConstantInt::get(SizeTy, Size)),
2952 getContext().getSizeType());
2953 // Atomic address is always the second parameter
2954 Args.add(RValue::get(EmitCastToVoidPtr(Ptr)),
2955 getContext().VoidPtrTy);
2956
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002957 const char* LibCallName;
David Chisnalldb365f32012-03-29 18:01:11 +00002958 QualType RetTy = getContext().VoidTy;
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002959 switch (E->getOp()) {
David Chisnalldb365f32012-03-29 18:01:11 +00002960 // There is only one libcall for compare an exchange, because there is no
2961 // optimisation benefit possible from a libcall version of a weak compare
2962 // and exchange.
2963 // bool __atomic_compare_exchange(size_t size, void *obj, void *expected,
Richard Smithfeea8832012-04-12 05:08:17 +00002964 // void *desired, int success, int failure)
2965 case AtomicExpr::AO__c11_atomic_compare_exchange_weak:
2966 case AtomicExpr::AO__c11_atomic_compare_exchange_strong:
2967 case AtomicExpr::AO__atomic_compare_exchange:
2968 case AtomicExpr::AO__atomic_compare_exchange_n:
David Chisnalldb365f32012-03-29 18:01:11 +00002969 LibCallName = "__atomic_compare_exchange";
2970 RetTy = getContext().BoolTy;
2971 Args.add(RValue::get(EmitCastToVoidPtr(Val1)),
2972 getContext().VoidPtrTy);
2973 Args.add(RValue::get(EmitCastToVoidPtr(Val2)),
2974 getContext().VoidPtrTy);
2975 Args.add(RValue::get(Order),
2976 getContext().IntTy);
2977 Order = OrderFail;
2978 break;
2979 // void __atomic_exchange(size_t size, void *mem, void *val, void *return,
2980 // int order)
Richard Smithfeea8832012-04-12 05:08:17 +00002981 case AtomicExpr::AO__c11_atomic_exchange:
2982 case AtomicExpr::AO__atomic_exchange_n:
2983 case AtomicExpr::AO__atomic_exchange:
David Chisnalldb365f32012-03-29 18:01:11 +00002984 LibCallName = "__atomic_exchange";
2985 Args.add(RValue::get(EmitCastToVoidPtr(Val1)),
2986 getContext().VoidPtrTy);
2987 Args.add(RValue::get(EmitCastToVoidPtr(Dest)),
2988 getContext().VoidPtrTy);
2989 break;
2990 // void __atomic_store(size_t size, void *mem, void *val, int order)
Richard Smithfeea8832012-04-12 05:08:17 +00002991 case AtomicExpr::AO__c11_atomic_store:
2992 case AtomicExpr::AO__atomic_store:
2993 case AtomicExpr::AO__atomic_store_n:
David Chisnalldb365f32012-03-29 18:01:11 +00002994 LibCallName = "__atomic_store";
2995 Args.add(RValue::get(EmitCastToVoidPtr(Val1)),
2996 getContext().VoidPtrTy);
2997 break;
2998 // void __atomic_load(size_t size, void *mem, void *return, int order)
Richard Smithfeea8832012-04-12 05:08:17 +00002999 case AtomicExpr::AO__c11_atomic_load:
3000 case AtomicExpr::AO__atomic_load:
3001 case AtomicExpr::AO__atomic_load_n:
David Chisnalldb365f32012-03-29 18:01:11 +00003002 LibCallName = "__atomic_load";
3003 Args.add(RValue::get(EmitCastToVoidPtr(Dest)),
3004 getContext().VoidPtrTy);
3005 break;
3006#if 0
3007 // These are only defined for 1-16 byte integers. It is not clear what
3008 // their semantics would be on anything else...
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003009 case AtomicExpr::Add: LibCallName = "__atomic_fetch_add_generic"; break;
3010 case AtomicExpr::Sub: LibCallName = "__atomic_fetch_sub_generic"; break;
3011 case AtomicExpr::And: LibCallName = "__atomic_fetch_and_generic"; break;
3012 case AtomicExpr::Or: LibCallName = "__atomic_fetch_or_generic"; break;
3013 case AtomicExpr::Xor: LibCallName = "__atomic_fetch_xor_generic"; break;
David Chisnalldb365f32012-03-29 18:01:11 +00003014#endif
3015 default: return EmitUnsupportedRValue(E, "atomic library call");
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003016 }
David Chisnalldb365f32012-03-29 18:01:11 +00003017 // order is always the last parameter
3018 Args.add(RValue::get(Order),
3019 getContext().IntTy);
3020
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003021 const CGFunctionInfo &FuncInfo =
David Chisnalldb365f32012-03-29 18:01:11 +00003022 CGM.getTypes().arrangeFunctionCall(RetTy, Args,
3023 FunctionType::ExtInfo(), RequiredArgs::All);
3024 llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FuncInfo);
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003025 llvm::Constant *Func = CGM.CreateRuntimeFunction(FTy, LibCallName);
3026 RValue Res = EmitCall(FuncInfo, Func, ReturnValueSlot(), Args);
3027 if (E->isCmpXChg())
3028 return Res;
Richard Smithfeea8832012-04-12 05:08:17 +00003029 if (E->getType()->isVoidType())
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003030 return RValue::get(0);
3031 return ConvertTempToRValue(*this, E->getType(), Dest);
3032 }
David Chisnalldb365f32012-03-29 18:01:11 +00003033
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003034 llvm::Type *IPtrTy =
3035 llvm::IntegerType::get(getLLVMContext(), Size * 8)->getPointerTo();
3036 llvm::Value *OrigDest = Dest;
3037 Ptr = Builder.CreateBitCast(Ptr, IPtrTy);
3038 if (Val1) Val1 = Builder.CreateBitCast(Val1, IPtrTy);
3039 if (Val2) Val2 = Builder.CreateBitCast(Val2, IPtrTy);
3040 if (Dest && !E->isCmpXChg()) Dest = Builder.CreateBitCast(Dest, IPtrTy);
3041
3042 if (isa<llvm::ConstantInt>(Order)) {
3043 int ord = cast<llvm::ConstantInt>(Order)->getZExtValue();
3044 switch (ord) {
3045 case 0: // memory_order_relaxed
3046 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3047 llvm::Monotonic);
3048 break;
3049 case 1: // memory_order_consume
3050 case 2: // memory_order_acquire
3051 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3052 llvm::Acquire);
3053 break;
3054 case 3: // memory_order_release
3055 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3056 llvm::Release);
3057 break;
3058 case 4: // memory_order_acq_rel
3059 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3060 llvm::AcquireRelease);
3061 break;
3062 case 5: // memory_order_seq_cst
3063 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3064 llvm::SequentiallyConsistent);
3065 break;
3066 default: // invalid order
3067 // We should not ever get here normally, but it's hard to
3068 // enforce that in general.
Richard Smithfeea8832012-04-12 05:08:17 +00003069 break;
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003070 }
Richard Smithfeea8832012-04-12 05:08:17 +00003071 if (E->getType()->isVoidType())
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003072 return RValue::get(0);
3073 return ConvertTempToRValue(*this, E->getType(), OrigDest);
3074 }
3075
3076 // Long case, when Order isn't obviously constant.
3077
Richard Smithfeea8832012-04-12 05:08:17 +00003078 bool IsStore = E->getOp() == AtomicExpr::AO__c11_atomic_store ||
3079 E->getOp() == AtomicExpr::AO__atomic_store ||
3080 E->getOp() == AtomicExpr::AO__atomic_store_n;
3081 bool IsLoad = E->getOp() == AtomicExpr::AO__c11_atomic_load ||
3082 E->getOp() == AtomicExpr::AO__atomic_load ||
3083 E->getOp() == AtomicExpr::AO__atomic_load_n;
3084
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003085 // Create all the relevant BB's
Eli Friedmanc2025562011-10-11 20:00:47 +00003086 llvm::BasicBlock *MonotonicBB = 0, *AcquireBB = 0, *ReleaseBB = 0,
3087 *AcqRelBB = 0, *SeqCstBB = 0;
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003088 MonotonicBB = createBasicBlock("monotonic", CurFn);
Richard Smithfeea8832012-04-12 05:08:17 +00003089 if (!IsStore)
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003090 AcquireBB = createBasicBlock("acquire", CurFn);
Richard Smithfeea8832012-04-12 05:08:17 +00003091 if (!IsLoad)
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003092 ReleaseBB = createBasicBlock("release", CurFn);
Richard Smithfeea8832012-04-12 05:08:17 +00003093 if (!IsLoad && !IsStore)
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003094 AcqRelBB = createBasicBlock("acqrel", CurFn);
3095 SeqCstBB = createBasicBlock("seqcst", CurFn);
3096 llvm::BasicBlock *ContBB = createBasicBlock("atomic.continue", CurFn);
3097
3098 // Create the switch for the split
3099 // MonotonicBB is arbitrarily chosen as the default case; in practice, this
3100 // doesn't matter unless someone is crazy enough to use something that
3101 // doesn't fold to a constant for the ordering.
3102 Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
3103 llvm::SwitchInst *SI = Builder.CreateSwitch(Order, MonotonicBB);
3104
3105 // Emit all the different atomics
3106 Builder.SetInsertPoint(MonotonicBB);
3107 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3108 llvm::Monotonic);
3109 Builder.CreateBr(ContBB);
Richard Smithfeea8832012-04-12 05:08:17 +00003110 if (!IsStore) {
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003111 Builder.SetInsertPoint(AcquireBB);
3112 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3113 llvm::Acquire);
3114 Builder.CreateBr(ContBB);
3115 SI->addCase(Builder.getInt32(1), AcquireBB);
3116 SI->addCase(Builder.getInt32(2), AcquireBB);
3117 }
Richard Smithfeea8832012-04-12 05:08:17 +00003118 if (!IsLoad) {
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003119 Builder.SetInsertPoint(ReleaseBB);
3120 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3121 llvm::Release);
3122 Builder.CreateBr(ContBB);
3123 SI->addCase(Builder.getInt32(3), ReleaseBB);
3124 }
Richard Smithfeea8832012-04-12 05:08:17 +00003125 if (!IsLoad && !IsStore) {
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003126 Builder.SetInsertPoint(AcqRelBB);
3127 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3128 llvm::AcquireRelease);
3129 Builder.CreateBr(ContBB);
3130 SI->addCase(Builder.getInt32(4), AcqRelBB);
3131 }
3132 Builder.SetInsertPoint(SeqCstBB);
3133 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3134 llvm::SequentiallyConsistent);
3135 Builder.CreateBr(ContBB);
3136 SI->addCase(Builder.getInt32(5), SeqCstBB);
3137
3138 // Cleanup and return
3139 Builder.SetInsertPoint(ContBB);
Richard Smithfeea8832012-04-12 05:08:17 +00003140 if (E->getType()->isVoidType())
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003141 return RValue::get(0);
3142 return ConvertTempToRValue(*this, E->getType(), OrigDest);
3143}
Peter Collingbourne95fd2ca2011-10-27 19:19:51 +00003144
Duncan Sandse81111c2012-04-10 08:23:07 +00003145void CodeGenFunction::SetFPAccuracy(llvm::Value *Val, float Accuracy) {
Peter Collingbourne95fd2ca2011-10-27 19:19:51 +00003146 assert(Val->getType()->isFPOrFPVectorTy());
Duncan Sandse81111c2012-04-10 08:23:07 +00003147 if (Accuracy == 0.0 || !isa<llvm::Instruction>(Val))
Peter Collingbourne95fd2ca2011-10-27 19:19:51 +00003148 return;
3149
Duncan Sands65229ed2012-04-16 16:29:47 +00003150 llvm::MDBuilder MDHelper(getLLVMContext());
3151 llvm::MDNode *Node = MDHelper.createFPMath(Accuracy);
Peter Collingbourne95fd2ca2011-10-27 19:19:51 +00003152
Duncan Sands6fc46192012-04-14 12:37:26 +00003153 cast<llvm::Instruction>(Val)->setMetadata(llvm::LLVMContext::MD_fpmath, Node);
Peter Collingbourne95fd2ca2011-10-27 19:19:51 +00003154}
John McCallfe96e0b2011-11-06 09:01:30 +00003155
3156namespace {
3157 struct LValueOrRValue {
3158 LValue LV;
3159 RValue RV;
3160 };
3161}
3162
3163static LValueOrRValue emitPseudoObjectExpr(CodeGenFunction &CGF,
3164 const PseudoObjectExpr *E,
3165 bool forLValue,
3166 AggValueSlot slot) {
3167 llvm::SmallVector<CodeGenFunction::OpaqueValueMappingData, 4> opaques;
3168
3169 // Find the result expression, if any.
3170 const Expr *resultExpr = E->getResultExpr();
3171 LValueOrRValue result;
3172
3173 for (PseudoObjectExpr::const_semantics_iterator
3174 i = E->semantics_begin(), e = E->semantics_end(); i != e; ++i) {
3175 const Expr *semantic = *i;
3176
3177 // If this semantic expression is an opaque value, bind it
3178 // to the result of its source expression.
3179 if (const OpaqueValueExpr *ov = dyn_cast<OpaqueValueExpr>(semantic)) {
3180
3181 // If this is the result expression, we may need to evaluate
3182 // directly into the slot.
3183 typedef CodeGenFunction::OpaqueValueMappingData OVMA;
3184 OVMA opaqueData;
3185 if (ov == resultExpr && ov->isRValue() && !forLValue &&
3186 CodeGenFunction::hasAggregateLLVMType(ov->getType()) &&
3187 !ov->getType()->isAnyComplexType()) {
3188 CGF.EmitAggExpr(ov->getSourceExpr(), slot);
3189
3190 LValue LV = CGF.MakeAddrLValue(slot.getAddr(), ov->getType());
3191 opaqueData = OVMA::bind(CGF, ov, LV);
3192 result.RV = slot.asRValue();
3193
3194 // Otherwise, emit as normal.
3195 } else {
3196 opaqueData = OVMA::bind(CGF, ov, ov->getSourceExpr());
3197
3198 // If this is the result, also evaluate the result now.
3199 if (ov == resultExpr) {
3200 if (forLValue)
3201 result.LV = CGF.EmitLValue(ov);
3202 else
3203 result.RV = CGF.EmitAnyExpr(ov, slot);
3204 }
3205 }
3206
3207 opaques.push_back(opaqueData);
3208
3209 // Otherwise, if the expression is the result, evaluate it
3210 // and remember the result.
3211 } else if (semantic == resultExpr) {
3212 if (forLValue)
3213 result.LV = CGF.EmitLValue(semantic);
3214 else
3215 result.RV = CGF.EmitAnyExpr(semantic, slot);
3216
3217 // Otherwise, evaluate the expression in an ignored context.
3218 } else {
3219 CGF.EmitIgnoredExpr(semantic);
3220 }
3221 }
3222
3223 // Unbind all the opaques now.
3224 for (unsigned i = 0, e = opaques.size(); i != e; ++i)
3225 opaques[i].unbind(CGF);
3226
3227 return result;
3228}
3229
3230RValue CodeGenFunction::EmitPseudoObjectRValue(const PseudoObjectExpr *E,
3231 AggValueSlot slot) {
3232 return emitPseudoObjectExpr(*this, E, false, slot).RV;
3233}
3234
3235LValue CodeGenFunction::EmitPseudoObjectLValue(const PseudoObjectExpr *E) {
3236 return emitPseudoObjectExpr(*this, E, true, AggValueSlot::ignored()).LV;
3237}