blob: fac6e370020b573b6f5846b2971ec97855c87363 [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"
Nico Weber3a691a32012-06-23 02:07:59 +000024#include "clang/Basic/ConvertUTF.h"
Chandler Carruth85098242010-06-15 23:19:56 +000025#include "clang/Frontend/CodeGenOptions.h"
Nick Lewycky7c6c6cc2011-07-07 03:54:51 +000026#include "llvm/Intrinsics.h"
Peter Collingbourne95fd2ca2011-10-27 19:19:51 +000027#include "llvm/LLVMContext.h"
Chandler Carruthcc8f2a62012-07-15 23:28:01 +000028#include "llvm/MDBuilder.h"
Micah Villmowdd31ca12012-10-08 16:25:52 +000029#include "llvm/DataLayout.h"
Chris Lattnere47e4402007-06-01 18:02:12 +000030using namespace clang;
31using namespace CodeGen;
32
Chris Lattnerd7f58862007-06-02 05:24:33 +000033//===--------------------------------------------------------------------===//
Chris Lattnerf0106d22007-06-02 19:33:17 +000034// Miscellaneous Helper Methods
35//===--------------------------------------------------------------------===//
36
John McCallad7c5c12011-02-08 08:22:06 +000037llvm::Value *CodeGenFunction::EmitCastToVoidPtr(llvm::Value *value) {
38 unsigned addressSpace =
39 cast<llvm::PointerType>(value->getType())->getAddressSpace();
40
Chris Lattner2192fe52011-07-18 04:24:23 +000041 llvm::PointerType *destType = Int8PtrTy;
John McCallad7c5c12011-02-08 08:22:06 +000042 if (addressSpace)
43 destType = llvm::Type::getInt8PtrTy(getLLVMContext(), addressSpace);
44
45 if (value->getType() == destType) return value;
46 return Builder.CreateBitCast(value, destType);
47}
48
Chris Lattnere9a64532007-06-22 21:44:33 +000049/// CreateTempAlloca - This creates a alloca and inserts it into the entry
50/// block.
Chris Lattner2192fe52011-07-18 04:24:23 +000051llvm::AllocaInst *CodeGenFunction::CreateTempAlloca(llvm::Type *Ty,
Chris Lattner0e62c1c2011-07-23 10:55:15 +000052 const Twine &Name) {
Chris Lattner47640222009-03-22 00:24:14 +000053 if (!Builder.isNamePreserving())
Daniel Dunbarb5aacc22009-10-19 01:21:05 +000054 return new llvm::AllocaInst(Ty, 0, "", AllocaInsertPt);
Devang Pateldac79de2009-10-12 22:29:02 +000055 return new llvm::AllocaInst(Ty, 0, Name, AllocaInsertPt);
Chris Lattnere9a64532007-06-22 21:44:33 +000056}
Chris Lattner8394d792007-06-05 20:53:16 +000057
John McCall2e6567a2010-04-22 01:10:34 +000058void CodeGenFunction::InitTempAlloca(llvm::AllocaInst *Var,
59 llvm::Value *Init) {
60 llvm::StoreInst *Store = new llvm::StoreInst(Init, Var);
61 llvm::BasicBlock *Block = AllocaInsertPt->getParent();
62 Block->getInstList().insertAfter(&*AllocaInsertPt, Store);
63}
64
Chris Lattnerc401de92010-07-05 20:21:00 +000065llvm::AllocaInst *CodeGenFunction::CreateIRTemp(QualType Ty,
Chris Lattner0e62c1c2011-07-23 10:55:15 +000066 const Twine &Name) {
Daniel Dunbard0049182010-02-16 19:44:13 +000067 llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertType(Ty), Name);
68 // FIXME: Should we prefer the preferred type alignment here?
69 CharUnits Align = getContext().getTypeAlignInChars(Ty);
70 Alloc->setAlignment(Align.getQuantity());
71 return Alloc;
72}
73
Chris Lattnerc401de92010-07-05 20:21:00 +000074llvm::AllocaInst *CodeGenFunction::CreateMemTemp(QualType Ty,
Chris Lattner0e62c1c2011-07-23 10:55:15 +000075 const Twine &Name) {
Daniel Dunbara7566f12010-02-09 02:48:28 +000076 llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertTypeForMem(Ty), Name);
77 // FIXME: Should we prefer the preferred type alignment here?
78 CharUnits Align = getContext().getTypeAlignInChars(Ty);
79 Alloc->setAlignment(Align.getQuantity());
80 return Alloc;
81}
82
Chris Lattner8394d792007-06-05 20:53:16 +000083/// EvaluateExprAsBool - Perform the usual unary conversions on the specified
84/// expression and compare the result against zero, returning an Int1Ty value.
Chris Lattner23b7eb62007-06-15 23:05:46 +000085llvm::Value *CodeGenFunction::EvaluateExprAsBool(const Expr *E) {
John McCall7a9aac22010-08-23 01:21:21 +000086 if (const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>()) {
John McCalla1dee5302010-08-22 10:59:02 +000087 llvm::Value *MemPtr = EmitScalarExpr(E);
John McCallad7c5c12011-02-08 08:22:06 +000088 return CGM.getCXXABI().EmitMemberPointerIsNotNull(*this, MemPtr, MPT);
Eli Friedman68396b12009-12-11 09:26:29 +000089 }
John McCall7a9aac22010-08-23 01:21:21 +000090
91 QualType BoolTy = getContext().BoolTy;
Chris Lattnerf3bc75a2008-04-04 16:54:41 +000092 if (!E->getType()->isAnyComplexType())
Chris Lattner268fcce2007-08-26 16:46:58 +000093 return EmitScalarConversion(EmitScalarExpr(E), E->getType(), BoolTy);
Chris Lattner8394d792007-06-05 20:53:16 +000094
Chris Lattner268fcce2007-08-26 16:46:58 +000095 return EmitComplexToScalarConversion(EmitComplexExpr(E), E->getType(),BoolTy);
Chris Lattnerf0106d22007-06-02 19:33:17 +000096}
97
John McCalla2342eb2010-12-05 02:00:02 +000098/// EmitIgnoredExpr - Emit code to compute the specified expression,
99/// ignoring the result.
100void CodeGenFunction::EmitIgnoredExpr(const Expr *E) {
101 if (E->isRValue())
102 return (void) EmitAnyExpr(E, AggValueSlot::ignored(), true);
103
104 // Just emit it as an l-value and drop the result.
105 EmitLValue(E);
106}
107
John McCall7a626f62010-09-15 10:14:12 +0000108/// EmitAnyExpr - Emit code to compute the specified expression which
109/// can have any type. The result is returned as an RValue struct.
110/// If this is an aggregate expression, AggSlot indicates where the
Mike Stump4a3999f2009-09-09 13:00:44 +0000111/// result should be returned.
John McCall4e8ca4f2012-07-02 23:58:38 +0000112RValue CodeGenFunction::EmitAnyExpr(const Expr *E,
113 AggValueSlot aggSlot,
114 bool ignoreResult) {
Chris Lattner4647a212007-08-31 22:49:20 +0000115 if (!hasAggregateLLVMType(E->getType()))
John McCall4e8ca4f2012-07-02 23:58:38 +0000116 return RValue::get(EmitScalarExpr(E, ignoreResult));
Chris Lattnerf3bc75a2008-04-04 16:54:41 +0000117 else if (E->getType()->isAnyComplexType())
John McCall4e8ca4f2012-07-02 23:58:38 +0000118 return RValue::getComplex(EmitComplexExpr(E, ignoreResult, ignoreResult));
Mike Stump4a3999f2009-09-09 13:00:44 +0000119
John McCall4e8ca4f2012-07-02 23:58:38 +0000120 if (!ignoreResult && aggSlot.isIgnored())
121 aggSlot = CreateAggTemp(E->getType(), "agg-temp");
122 EmitAggExpr(E, aggSlot);
123 return aggSlot.asRValue();
Chris Lattner4647a212007-08-31 22:49:20 +0000124}
125
Mike Stump4a3999f2009-09-09 13:00:44 +0000126/// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result will
127/// always be accessible even if no aggregate location is provided.
John McCall7a626f62010-09-15 10:14:12 +0000128RValue CodeGenFunction::EmitAnyExprToTemp(const Expr *E) {
129 AggValueSlot AggSlot = AggValueSlot::ignored();
Mike Stump4a3999f2009-09-09 13:00:44 +0000130
131 if (hasAggregateLLVMType(E->getType()) &&
Daniel Dunbar41cf9de2008-09-09 01:06:48 +0000132 !E->getType()->isAnyComplexType())
John McCall7a626f62010-09-15 10:14:12 +0000133 AggSlot = CreateAggTemp(E->getType(), "agg.tmp");
134 return EmitAnyExpr(E, AggSlot);
Daniel Dunbar41cf9de2008-09-09 01:06:48 +0000135}
136
John McCall21886962010-04-21 10:05:39 +0000137/// EmitAnyExprToMem - Evaluate an expression into a given memory
138/// location.
139void CodeGenFunction::EmitAnyExprToMem(const Expr *E,
140 llvm::Value *Location,
Chad Rosier615ed1a2012-03-29 17:37:10 +0000141 Qualifiers Quals,
142 bool IsInit) {
Eli Friedmanc1d85b92011-12-03 00:54:26 +0000143 // FIXME: This function should take an LValue as an argument.
144 if (E->getType()->isAnyComplexType()) {
John McCall31168b02011-06-15 23:02:42 +0000145 EmitComplexExprIntoAddr(E, Location, Quals.hasVolatile());
Eli Friedmanc1d85b92011-12-03 00:54:26 +0000146 } else if (hasAggregateLLVMType(E->getType())) {
Eli Friedman38cd36d2011-12-03 02:13:40 +0000147 CharUnits Alignment = getContext().getTypeAlignInChars(E->getType());
Eli Friedmanc1d85b92011-12-03 00:54:26 +0000148 EmitAggExpr(E, AggValueSlot::forAddr(Location, Alignment, Quals,
Chad Rosier615ed1a2012-03-29 17:37:10 +0000149 AggValueSlot::IsDestructed_t(IsInit),
John McCalla8a39bc2011-08-26 05:38:08 +0000150 AggValueSlot::DoesNotNeedGCBarriers,
Chad Rosier615ed1a2012-03-29 17:37:10 +0000151 AggValueSlot::IsAliased_t(!IsInit)));
Eli Friedmanc1d85b92011-12-03 00:54:26 +0000152 } else {
John McCall21886962010-04-21 10:05:39 +0000153 RValue RV = RValue::get(EmitScalarExpr(E, /*Ignore*/ false));
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +0000154 LValue LV = MakeAddrLValue(Location, E->getType());
John McCall55e1fbc2011-06-25 02:11:03 +0000155 EmitStoreThroughLValue(RV, LV);
John McCall21886962010-04-21 10:05:39 +0000156 }
157}
158
Benjamin Kramer90b5b682010-11-25 18:29:30 +0000159namespace {
Douglas Gregor7c38f152010-05-20 08:36:28 +0000160/// \brief An adjustment to be made to the temporary created when emitting a
161/// reference binding, which accesses a particular subobject of that temporary.
Benjamin Kramer90b5b682010-11-25 18:29:30 +0000162 struct SubobjectAdjustment {
Eli Friedman13ffdd82012-06-15 23:51:06 +0000163 enum {
164 DerivedToBaseAdjustment,
165 FieldAdjustment,
166 MemberPointerAdjustment
167 } Kind;
Benjamin Kramer90b5b682010-11-25 18:29:30 +0000168
169 union {
170 struct {
171 const CastExpr *BasePath;
172 const CXXRecordDecl *DerivedClass;
173 } DerivedToBase;
174
175 FieldDecl *Field;
Eli Friedman13ffdd82012-06-15 23:51:06 +0000176
177 struct {
178 const MemberPointerType *MPT;
179 llvm::Value *Ptr;
180 } Ptr;
Benjamin Kramer90b5b682010-11-25 18:29:30 +0000181 };
182
183 SubobjectAdjustment(const CastExpr *BasePath,
184 const CXXRecordDecl *DerivedClass)
185 : Kind(DerivedToBaseAdjustment) {
186 DerivedToBase.BasePath = BasePath;
187 DerivedToBase.DerivedClass = DerivedClass;
188 }
189
190 SubobjectAdjustment(FieldDecl *Field)
191 : Kind(FieldAdjustment) {
192 this->Field = Field;
193 }
Eli Friedman13ffdd82012-06-15 23:51:06 +0000194
195 SubobjectAdjustment(const MemberPointerType *MPT, llvm::Value *Ptr)
196 : Kind(MemberPointerAdjustment) {
197 this->Ptr.MPT = MPT;
198 this->Ptr.Ptr = Ptr;
199 }
Douglas Gregor7c38f152010-05-20 08:36:28 +0000200 };
Benjamin Kramer90b5b682010-11-25 18:29:30 +0000201}
Douglas Gregor7c38f152010-05-20 08:36:28 +0000202
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000203static llvm::Value *
Chris Lattner24516962011-07-20 04:59:57 +0000204CreateReferenceTemporary(CodeGenFunction &CGF, QualType Type,
Anders Carlsson18c205e2010-06-27 17:23:46 +0000205 const NamedDecl *InitializedDecl) {
206 if (const VarDecl *VD = dyn_cast_or_null<VarDecl>(InitializedDecl)) {
207 if (VD->hasGlobalStorage()) {
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000208 SmallString<256> Name;
Rafael Espindola3968cd02011-02-11 02:52:17 +0000209 llvm::raw_svector_ostream Out(Name);
210 CGF.CGM.getCXXABI().getMangleContext().mangleReferenceTemporary(VD, Out);
211 Out.flush();
212
Chris Lattner2192fe52011-07-18 04:24:23 +0000213 llvm::Type *RefTempTy = CGF.ConvertTypeForMem(Type);
Anders Carlsson18c205e2010-06-27 17:23:46 +0000214
215 // Create the reference temporary.
216 llvm::GlobalValue *RefTemp =
217 new llvm::GlobalVariable(CGF.CGM.getModule(),
218 RefTempTy, /*isConstant=*/false,
219 llvm::GlobalValue::InternalLinkage,
220 llvm::Constant::getNullValue(RefTempTy),
221 Name.str());
222 return RefTemp;
223 }
224 }
225
226 return CGF.CreateMemTemp(Type, "ref.tmp");
227}
228
229static llvm::Value *
Chris Lattnerf53c0962010-09-06 00:11:41 +0000230EmitExprForReferenceBinding(CodeGenFunction &CGF, const Expr *E,
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000231 llvm::Value *&ReferenceTemporary,
232 const CXXDestructorDecl *&ReferenceTemporaryDtor,
John McCall31168b02011-06-15 23:02:42 +0000233 QualType &ObjCARCReferenceLifetimeType,
Anders Carlsson18c205e2010-06-27 17:23:46 +0000234 const NamedDecl *InitializedDecl) {
Sebastian Redl29526f02011-11-27 16:50:07 +0000235 // Look through single-element init lists that claim to be lvalues. They're
236 // just syntactic wrappers in this case.
237 if (const InitListExpr *ILE = dyn_cast<InitListExpr>(E)) {
238 if (ILE->getNumInits() == 1 && ILE->isGLValue())
239 E = ILE->getInit(0);
240 }
241
Douglas Gregorfe314812011-06-21 17:03:29 +0000242 // Look through expressions for materialized temporaries (for now).
Douglas Gregor58df5092011-06-22 16:12:01 +0000243 if (const MaterializeTemporaryExpr *M
244 = dyn_cast<MaterializeTemporaryExpr>(E)) {
245 // Objective-C++ ARC:
246 // If we are binding a reference to a temporary that has ownership, we
247 // need to perform retain/release operations on the temporary.
David Blaikiebbafb8a2012-03-11 07:00:24 +0000248 if (CGF.getContext().getLangOpts().ObjCAutoRefCount &&
Douglas Gregor58df5092011-06-22 16:12:01 +0000249 E->getType()->isObjCLifetimeType() &&
250 (E->getType().getObjCLifetime() == Qualifiers::OCL_Strong ||
251 E->getType().getObjCLifetime() == Qualifiers::OCL_Weak ||
252 E->getType().getObjCLifetime() == Qualifiers::OCL_Autoreleasing))
253 ObjCARCReferenceLifetimeType = E->getType();
254
255 E = M->GetTemporaryExpr();
256 }
Douglas Gregorfe314812011-06-21 17:03:29 +0000257
Eli Friedman357e8c92009-12-19 00:20:10 +0000258 if (const CXXDefaultArgExpr *DAE = dyn_cast<CXXDefaultArgExpr>(E))
259 E = DAE->getExpr();
Anders Carlsson66413c22009-10-15 00:51:46 +0000260
John McCall08ef4662011-11-10 08:15:53 +0000261 if (const ExprWithCleanups *EWC = dyn_cast<ExprWithCleanups>(E)) {
262 CGF.enterFullExpression(EWC);
John McCallbd309292010-07-06 01:34:17 +0000263 CodeGenFunction::RunCleanupsScope Scope(CGF);
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000264
John McCall08ef4662011-11-10 08:15:53 +0000265 return EmitExprForReferenceBinding(CGF, EWC->getSubExpr(),
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000266 ReferenceTemporary,
267 ReferenceTemporaryDtor,
John McCall31168b02011-06-15 23:02:42 +0000268 ObjCARCReferenceLifetimeType,
Anders Carlsson18c205e2010-06-27 17:23:46 +0000269 InitializedDecl);
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000270 }
271
272 RValue RV;
Douglas Gregor9c399a22011-01-22 02:44:21 +0000273 if (E->isGLValue()) {
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000274 // Emit the expression as an lvalue.
275 LValue LV = CGF.EmitLValue(E);
Chris Lattner13ee4f42011-07-10 05:34:54 +0000276
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000277 if (LV.isSimple())
278 return LV.getAddress();
Anders Carlsson824e0612010-02-04 17:32:58 +0000279
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000280 // We have to load the lvalue.
John McCall55e1fbc2011-06-25 02:11:03 +0000281 RV = CGF.EmitLoadOfLValue(LV);
Eli Friedmanc21cb442009-05-20 02:31:19 +0000282 } else {
Douglas Gregor58df5092011-06-22 16:12:01 +0000283 if (!ObjCARCReferenceLifetimeType.isNull()) {
284 ReferenceTemporary = CreateReferenceTemporary(CGF,
285 ObjCARCReferenceLifetimeType,
286 InitializedDecl);
287
288
289 LValue RefTempDst = CGF.MakeAddrLValue(ReferenceTemporary,
290 ObjCARCReferenceLifetimeType);
291
292 CGF.EmitScalarInit(E, dyn_cast_or_null<ValueDecl>(InitializedDecl),
293 RefTempDst, false);
294
295 bool ExtendsLifeOfTemporary = false;
296 if (const VarDecl *Var = dyn_cast_or_null<VarDecl>(InitializedDecl)) {
297 if (Var->extendsLifetimeOfTemporary())
298 ExtendsLifeOfTemporary = true;
299 } else if (InitializedDecl && isa<FieldDecl>(InitializedDecl)) {
300 ExtendsLifeOfTemporary = true;
301 }
302
303 if (!ExtendsLifeOfTemporary) {
304 // Since the lifetime of this temporary isn't going to be extended,
305 // we need to clean it up ourselves at the end of the full expression.
306 switch (ObjCARCReferenceLifetimeType.getObjCLifetime()) {
307 case Qualifiers::OCL_None:
308 case Qualifiers::OCL_ExplicitNone:
309 case Qualifiers::OCL_Autoreleasing:
310 break;
311
John McCall4bd0fb12011-07-12 16:41:08 +0000312 case Qualifiers::OCL_Strong: {
313 assert(!ObjCARCReferenceLifetimeType->isArrayType());
314 CleanupKind cleanupKind = CGF.getARCCleanupKind();
315 CGF.pushDestroy(cleanupKind,
316 ReferenceTemporary,
317 ObjCARCReferenceLifetimeType,
318 CodeGenFunction::destroyARCStrongImprecise,
319 cleanupKind & EHCleanup);
Douglas Gregor58df5092011-06-22 16:12:01 +0000320 break;
John McCall4bd0fb12011-07-12 16:41:08 +0000321 }
Douglas Gregor58df5092011-06-22 16:12:01 +0000322
323 case Qualifiers::OCL_Weak:
John McCall4bd0fb12011-07-12 16:41:08 +0000324 assert(!ObjCARCReferenceLifetimeType->isArrayType());
325 CGF.pushDestroy(NormalAndEHCleanup,
326 ReferenceTemporary,
327 ObjCARCReferenceLifetimeType,
328 CodeGenFunction::destroyARCWeak,
329 /*useEHCleanupForArray*/ true);
Douglas Gregor58df5092011-06-22 16:12:01 +0000330 break;
331 }
332
333 ObjCARCReferenceLifetimeType = QualType();
334 }
335
336 return ReferenceTemporary;
337 }
338
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000339 SmallVector<SubobjectAdjustment, 2> Adjustments;
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000340 while (true) {
Peter Collingbourne91147592011-04-15 00:35:48 +0000341 E = E->IgnoreParens();
Douglas Gregoraae38d62010-05-22 05:17:18 +0000342
343 if (const CastExpr *CE = dyn_cast<CastExpr>(E)) {
John McCalle3027922010-08-25 11:45:40 +0000344 if ((CE->getCastKind() == CK_DerivedToBase ||
345 CE->getCastKind() == CK_UncheckedDerivedToBase) &&
Douglas Gregoraae38d62010-05-22 05:17:18 +0000346 E->getType()->isRecordType()) {
Douglas Gregor7c38f152010-05-20 08:36:28 +0000347 E = CE->getSubExpr();
348 CXXRecordDecl *Derived
349 = cast<CXXRecordDecl>(E->getType()->getAs<RecordType>()->getDecl());
John McCallcf142162010-08-07 06:22:56 +0000350 Adjustments.push_back(SubobjectAdjustment(CE, Derived));
Douglas Gregor7c38f152010-05-20 08:36:28 +0000351 continue;
352 }
Douglas Gregoraae38d62010-05-22 05:17:18 +0000353
John McCalle3027922010-08-25 11:45:40 +0000354 if (CE->getCastKind() == CK_NoOp) {
Douglas Gregoraae38d62010-05-22 05:17:18 +0000355 E = CE->getSubExpr();
356 continue;
357 }
358 } else if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
John McCall086a4642010-11-24 05:12:34 +0000359 if (!ME->isArrow() && ME->getBase()->isRValue()) {
360 assert(ME->getBase()->getType()->isRecordType());
Douglas Gregor7c38f152010-05-20 08:36:28 +0000361 if (FieldDecl *Field = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
362 E = ME->getBase();
Daniel Dunbare8b6cda2010-08-21 03:37:02 +0000363 Adjustments.push_back(SubobjectAdjustment(Field));
Douglas Gregor7c38f152010-05-20 08:36:28 +0000364 continue;
365 }
366 }
Eli Friedman13ffdd82012-06-15 23:51:06 +0000367 } else if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
368 if (BO->isPtrMemOp()) {
369 assert(BO->getLHS()->isRValue());
370 E = BO->getLHS();
371 const MemberPointerType *MPT =
372 BO->getRHS()->getType()->getAs<MemberPointerType>();
373 llvm::Value *Ptr = CGF.EmitScalarExpr(BO->getRHS());
374 Adjustments.push_back(SubobjectAdjustment(MPT, Ptr));
375 }
Anders Carlsson66413c22009-10-15 00:51:46 +0000376 }
Douglas Gregoraae38d62010-05-22 05:17:18 +0000377
John McCalle9dab632011-02-21 05:25:38 +0000378 if (const OpaqueValueExpr *opaque = dyn_cast<OpaqueValueExpr>(E))
379 if (opaque->getType()->isRecordType())
380 return CGF.EmitOpaqueValueLValue(opaque).getAddress();
381
Douglas Gregoraae38d62010-05-22 05:17:18 +0000382 // Nothing changed.
383 break;
Anders Carlssonb80760b2009-08-16 17:50:25 +0000384 }
Anders Carlsson66413c22009-10-15 00:51:46 +0000385
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000386 // Create a reference temporary if necessary.
John McCall7a626f62010-09-15 10:14:12 +0000387 AggValueSlot AggSlot = AggValueSlot::ignored();
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000388 if (CGF.hasAggregateLLVMType(E->getType()) &&
John McCall7a626f62010-09-15 10:14:12 +0000389 !E->getType()->isAnyComplexType()) {
Anders Carlsson18c205e2010-06-27 17:23:46 +0000390 ReferenceTemporary = CreateReferenceTemporary(CGF, E->getType(),
391 InitializedDecl);
Eli Friedman38cd36d2011-12-03 02:13:40 +0000392 CharUnits Alignment = CGF.getContext().getTypeAlignInChars(E->getType());
John McCall8d6fc952011-08-25 20:40:09 +0000393 AggValueSlot::IsDestructed_t isDestructed
394 = AggValueSlot::IsDestructed_t(InitializedDecl != 0);
Eli Friedmanc1d85b92011-12-03 00:54:26 +0000395 AggSlot = AggValueSlot::forAddr(ReferenceTemporary, Alignment,
396 Qualifiers(), isDestructed,
John McCalla5efa732011-08-25 23:04:34 +0000397 AggValueSlot::DoesNotNeedGCBarriers,
Chad Rosier615ed1a2012-03-29 17:37:10 +0000398 AggValueSlot::IsNotAliased);
John McCall7a626f62010-09-15 10:14:12 +0000399 }
John McCall31168b02011-06-15 23:02:42 +0000400
Anders Carlsson18c205e2010-06-27 17:23:46 +0000401 if (InitializedDecl) {
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000402 // Get the destructor for the reference temporary.
403 if (const RecordType *RT = E->getType()->getAs<RecordType>()) {
404 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(RT->getDecl());
405 if (!ClassDecl->hasTrivialDestructor())
Douglas Gregorbac74902010-07-01 14:13:13 +0000406 ReferenceTemporaryDtor = ClassDecl->getDestructor();
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000407 }
408 }
409
John McCall31168b02011-06-15 23:02:42 +0000410 RV = CGF.EmitAnyExpr(E, AggSlot);
411
Douglas Gregor7c38f152010-05-20 08:36:28 +0000412 // Check if need to perform derived-to-base casts and/or field accesses, to
413 // get from the temporary object we created (and, potentially, for which we
414 // extended the lifetime) to the subobject we're binding the reference to.
415 if (!Adjustments.empty()) {
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000416 llvm::Value *Object = RV.getAggregateAddr();
Douglas Gregor7c38f152010-05-20 08:36:28 +0000417 for (unsigned I = Adjustments.size(); I != 0; --I) {
418 SubobjectAdjustment &Adjustment = Adjustments[I-1];
419 switch (Adjustment.Kind) {
420 case SubobjectAdjustment::DerivedToBaseAdjustment:
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000421 Object =
422 CGF.GetAddressOfBaseClass(Object,
423 Adjustment.DerivedToBase.DerivedClass,
John McCallcf142162010-08-07 06:22:56 +0000424 Adjustment.DerivedToBase.BasePath->path_begin(),
425 Adjustment.DerivedToBase.BasePath->path_end(),
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000426 /*NullCheckValue=*/false);
Douglas Gregor7c38f152010-05-20 08:36:28 +0000427 break;
428
429 case SubobjectAdjustment::FieldAdjustment: {
Eli Friedman7f1ff602012-04-16 03:54:45 +0000430 LValue LV = CGF.MakeAddrLValue(Object, E->getType());
431 LV = CGF.EmitLValueForField(LV, Adjustment.Field);
Douglas Gregor7c38f152010-05-20 08:36:28 +0000432 if (LV.isSimple()) {
433 Object = LV.getAddress();
434 break;
435 }
436
437 // For non-simple lvalues, we actually have to create a copy of
438 // the object we're binding to.
Daniel Dunbare8b6cda2010-08-21 03:37:02 +0000439 QualType T = Adjustment.Field->getType().getNonReferenceType()
440 .getUnqualifiedType();
Anders Carlsson3f48c602010-06-27 17:52:15 +0000441 Object = CreateReferenceTemporary(CGF, T, InitializedDecl);
Daniel Dunbare8b6cda2010-08-21 03:37:02 +0000442 LValue TempLV = CGF.MakeAddrLValue(Object,
443 Adjustment.Field->getType());
John McCall55e1fbc2011-06-25 02:11:03 +0000444 CGF.EmitStoreThroughLValue(CGF.EmitLoadOfLValue(LV), TempLV);
Douglas Gregor7c38f152010-05-20 08:36:28 +0000445 break;
446 }
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000447
Eli Friedman13ffdd82012-06-15 23:51:06 +0000448 case SubobjectAdjustment::MemberPointerAdjustment: {
449 Object = CGF.CGM.getCXXABI().EmitMemberDataPointerAddress(
450 CGF, Object, Adjustment.Ptr.Ptr, Adjustment.Ptr.MPT);
451 break;
452 }
Douglas Gregor7c38f152010-05-20 08:36:28 +0000453 }
454 }
Eli Friedmanb6069252011-03-16 22:34:09 +0000455
456 return Object;
Anders Carlsson66413c22009-10-15 00:51:46 +0000457 }
Anders Carlsson7d4c0832009-05-20 00:36:58 +0000458 }
Eli Friedmanc21cb442009-05-20 02:31:19 +0000459
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000460 if (RV.isAggregate())
461 return RV.getAggregateAddr();
Eli Friedmanc21cb442009-05-20 02:31:19 +0000462
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000463 // Create a temporary variable that we can bind the reference to.
Anders Carlsson18c205e2010-06-27 17:23:46 +0000464 ReferenceTemporary = CreateReferenceTemporary(CGF, E->getType(),
465 InitializedDecl);
466
Daniel Dunbar03816342010-08-21 02:24:36 +0000467
468 unsigned Alignment =
469 CGF.getContext().getTypeAlignInChars(E->getType()).getQuantity();
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000470 if (RV.isScalar())
471 CGF.EmitStoreOfScalar(RV.getScalarVal(), ReferenceTemporary,
Daniel Dunbar03816342010-08-21 02:24:36 +0000472 /*Volatile=*/false, Alignment, E->getType());
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000473 else
474 CGF.StoreComplexToAddr(RV.getComplexVal(), ReferenceTemporary,
475 /*Volatile=*/false);
476 return ReferenceTemporary;
477}
478
479RValue
Chris Lattnerf53c0962010-09-06 00:11:41 +0000480CodeGenFunction::EmitReferenceBindingToExpr(const Expr *E,
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000481 const NamedDecl *InitializedDecl) {
482 llvm::Value *ReferenceTemporary = 0;
483 const CXXDestructorDecl *ReferenceTemporaryDtor = 0;
John McCall31168b02011-06-15 23:02:42 +0000484 QualType ObjCARCReferenceLifetimeType;
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000485 llvm::Value *Value = EmitExprForReferenceBinding(*this, E, ReferenceTemporary,
486 ReferenceTemporaryDtor,
John McCall31168b02011-06-15 23:02:42 +0000487 ObjCARCReferenceLifetimeType,
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000488 InitializedDecl);
Richard Smith69d0d262012-08-24 00:54:33 +0000489 if (CatchUndefined && !E->getType()->isFunctionType()) {
490 // C++11 [dcl.ref]p5 (as amended by core issue 453):
491 // If a glvalue to which a reference is directly bound designates neither
492 // an existing object or function of an appropriate type nor a region of
493 // storage of suitable size and alignment to contain an object of the
494 // reference's type, the behavior is undefined.
495 QualType Ty = E->getType();
Richard Smith4d1458e2012-09-08 02:08:36 +0000496 EmitTypeCheck(TCK_ReferenceBinding, Value, Ty);
Richard Smith69d0d262012-08-24 00:54:33 +0000497 }
John McCall31168b02011-06-15 23:02:42 +0000498 if (!ReferenceTemporaryDtor && ObjCARCReferenceLifetimeType.isNull())
Anders Carlsson3f48c602010-06-27 17:52:15 +0000499 return RValue::get(Value);
500
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000501 // Make sure to call the destructor for the reference temporary.
John McCall31168b02011-06-15 23:02:42 +0000502 const VarDecl *VD = dyn_cast_or_null<VarDecl>(InitializedDecl);
503 if (VD && VD->hasGlobalStorage()) {
504 if (ReferenceTemporaryDtor) {
Anders Carlsson3f48c602010-06-27 17:52:15 +0000505 llvm::Constant *DtorFn =
506 CGM.GetAddrOfCXXDestructor(ReferenceTemporaryDtor, Dtor_Complete);
John McCallc84ed6a2012-05-01 06:13:13 +0000507 CGM.getCXXABI().registerGlobalDtor(*this, DtorFn,
John McCallad7c5c12011-02-08 08:22:06 +0000508 cast<llvm::Constant>(ReferenceTemporary));
John McCall31168b02011-06-15 23:02:42 +0000509 } else {
510 assert(!ObjCARCReferenceLifetimeType.isNull());
511 // Note: We intentionally do not register a global "destructor" to
512 // release the object.
Anders Carlsson3f48c602010-06-27 17:52:15 +0000513 }
John McCall31168b02011-06-15 23:02:42 +0000514
515 return RValue::get(Value);
Anders Carlsson3f48c602010-06-27 17:52:15 +0000516 }
John McCall8680f872010-07-21 06:29:51 +0000517
John McCall31168b02011-06-15 23:02:42 +0000518 if (ReferenceTemporaryDtor)
519 PushDestructorCleanup(ReferenceTemporaryDtor, ReferenceTemporary);
520 else {
521 switch (ObjCARCReferenceLifetimeType.getObjCLifetime()) {
522 case Qualifiers::OCL_None:
David Blaikie83d382b2011-09-23 05:06:16 +0000523 llvm_unreachable(
524 "Not a reference temporary that needs to be deallocated");
John McCall31168b02011-06-15 23:02:42 +0000525 case Qualifiers::OCL_ExplicitNone:
526 case Qualifiers::OCL_Autoreleasing:
527 // Nothing to do.
528 break;
529
John McCall4bd0fb12011-07-12 16:41:08 +0000530 case Qualifiers::OCL_Strong: {
531 bool precise = VD && VD->hasAttr<ObjCPreciseLifetimeAttr>();
532 CleanupKind cleanupKind = getARCCleanupKind();
Benjamin Kramerae2d3442011-07-12 18:37:23 +0000533 pushDestroy(cleanupKind, ReferenceTemporary, ObjCARCReferenceLifetimeType,
Peter Collingbourne1425b452012-01-26 03:33:36 +0000534 precise ? destroyARCStrongPrecise : destroyARCStrongImprecise,
535 cleanupKind & EHCleanup);
John McCall31168b02011-06-15 23:02:42 +0000536 break;
John McCall4bd0fb12011-07-12 16:41:08 +0000537 }
John McCall31168b02011-06-15 23:02:42 +0000538
Benjamin Kramerae2d3442011-07-12 18:37:23 +0000539 case Qualifiers::OCL_Weak: {
John McCall31168b02011-06-15 23:02:42 +0000540 // __weak objects always get EH cleanups; otherwise, exceptions
541 // could cause really nasty crashes instead of mere leaks.
John McCall4bd0fb12011-07-12 16:41:08 +0000542 pushDestroy(NormalAndEHCleanup, ReferenceTemporary,
Peter Collingbourne1425b452012-01-26 03:33:36 +0000543 ObjCARCReferenceLifetimeType, destroyARCWeak, true);
John McCall31168b02011-06-15 23:02:42 +0000544 break;
545 }
Benjamin Kramerae2d3442011-07-12 18:37:23 +0000546 }
John McCall31168b02011-06-15 23:02:42 +0000547 }
548
Anders Carlsson2969c8c62010-06-27 16:56:04 +0000549 return RValue::get(Value);
Anders Carlsson6f5a0152009-05-20 00:24:07 +0000550}
551
552
Mike Stump4a3999f2009-09-09 13:00:44 +0000553/// getAccessedFieldNo - Given an encoded value and a result number, return the
554/// input field number being accessed.
555unsigned CodeGenFunction::getAccessedFieldNo(unsigned Idx,
Dan Gohman75d69da2008-05-22 00:50:06 +0000556 const llvm::Constant *Elts) {
Chris Lattner595ba3a2012-01-30 06:20:36 +0000557 return cast<llvm::ConstantInt>(Elts->getAggregateElement(Idx))
558 ->getZExtValue();
Dan Gohman75d69da2008-05-22 00:50:06 +0000559}
560
Richard Smith4d1458e2012-09-08 02:08:36 +0000561void CodeGenFunction::EmitTypeCheck(TypeCheckKind TCK, llvm::Value *Address,
562 QualType Ty, CharUnits Alignment) {
Nuno Lopesa4255892012-05-22 17:19:45 +0000563 if (!CatchUndefined)
Mike Stump3f6f9fe2009-12-16 02:57:00 +0000564 return;
565
Richard Smith69d0d262012-08-24 00:54:33 +0000566 llvm::Value *Cond = 0;
Mike Stump3f6f9fe2009-12-16 02:57:00 +0000567
Richard Smith4d1458e2012-09-08 02:08:36 +0000568 if (TCK != TCK_Load && TCK != TCK_Store) {
Richard Smith69d0d262012-08-24 00:54:33 +0000569 // The glvalue must not be an empty glvalue. Don't bother checking this for
570 // loads and stores, because we will get a segfault anyway (if the operation
571 // isn't optimized out).
572 Cond = Builder.CreateICmpNE(
573 Address, llvm::Constant::getNullValue(Address->getType()));
574 }
Chris Lattnerbc3be652010-04-10 18:34:14 +0000575
Richard Smith69d0d262012-08-24 00:54:33 +0000576 if (!Ty->isIncompleteType()) {
577 uint64_t Size = getContext().getTypeSizeInChars(Ty).getQuantity();
578 uint64_t AlignVal = Alignment.getQuantity();
579 if (!AlignVal)
580 AlignVal = getContext().getTypeAlignInChars(Ty).getQuantity();
581
582 // This needs to be to the standard address space.
583 Address = Builder.CreateBitCast(Address, Int8PtrTy);
584
585 // The glvalue must refer to a large enough storage region.
586 // FIXME: If -faddress-sanitizer is enabled, insert dynamic instrumentation
587 // to check this.
588 llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::objectsize, IntPtrTy);
589 llvm::Value *Min = Builder.getFalse();
590 llvm::Value *LargeEnough =
591 Builder.CreateICmpUGE(Builder.CreateCall2(F, Address, Min),
592 llvm::ConstantInt::get(IntPtrTy, Size));
593 Cond = Cond ? Builder.CreateAnd(Cond, LargeEnough) : LargeEnough;
594
595 // The glvalue must be suitably aligned.
596 llvm::Value *Align =
597 Builder.CreateAnd(Builder.CreatePtrToInt(Address, IntPtrTy),
598 llvm::ConstantInt::get(IntPtrTy, AlignVal - 1));
599 Cond = Builder.CreateAnd(Cond,
600 Builder.CreateICmpEQ(Align, llvm::ConstantInt::get(IntPtrTy, 0)));
601 }
602
Richard Smith4d1458e2012-09-08 02:08:36 +0000603 if (Cond)
604 EmitCheck(Cond);
Mike Stump3f6f9fe2009-12-16 02:57:00 +0000605}
Chris Lattner4647a212007-08-31 22:49:20 +0000606
Chris Lattner116ce8f2010-01-09 21:40:03 +0000607
Chris Lattner116ce8f2010-01-09 21:40:03 +0000608CodeGenFunction::ComplexPairTy CodeGenFunction::
609EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV,
610 bool isInc, bool isPre) {
611 ComplexPairTy InVal = LoadComplexFromAddr(LV.getAddress(),
612 LV.isVolatileQualified());
613
614 llvm::Value *NextVal;
615 if (isa<llvm::IntegerType>(InVal.first->getType())) {
616 uint64_t AmountVal = isInc ? 1 : -1;
617 NextVal = llvm::ConstantInt::get(InVal.first->getType(), AmountVal, true);
618
619 // Add the inc/dec to the real part.
620 NextVal = Builder.CreateAdd(InVal.first, NextVal, isInc ? "inc" : "dec");
621 } else {
622 QualType ElemTy = E->getType()->getAs<ComplexType>()->getElementType();
623 llvm::APFloat FVal(getContext().getFloatTypeSemantics(ElemTy), 1);
624 if (!isInc)
625 FVal.changeSign();
626 NextVal = llvm::ConstantFP::get(getLLVMContext(), FVal);
627
628 // Add the inc/dec to the real part.
629 NextVal = Builder.CreateFAdd(InVal.first, NextVal, isInc ? "inc" : "dec");
630 }
631
632 ComplexPairTy IncVal(NextVal, InVal.second);
633
634 // Store the updated result through the lvalue.
635 StoreComplexToAddr(IncVal, LV.getAddress(), LV.isVolatileQualified());
636
637 // If this is a postinc, return the value read from memory, otherwise use the
638 // updated value.
639 return isPre ? IncVal : InVal;
640}
641
642
Chris Lattnera45c5af2007-06-02 19:47:04 +0000643//===----------------------------------------------------------------------===//
Chris Lattnerd7f58862007-06-02 05:24:33 +0000644// LValue Expression Emission
Chris Lattnera45c5af2007-06-02 19:47:04 +0000645//===----------------------------------------------------------------------===//
Chris Lattnerd7f58862007-06-02 05:24:33 +0000646
Daniel Dunbarc79407f2009-02-05 07:09:07 +0000647RValue CodeGenFunction::GetUndefRValue(QualType Ty) {
Chris Lattnerab5e0af2009-10-28 17:39:19 +0000648 if (Ty->isVoidType())
Daniel Dunbarc79407f2009-02-05 07:09:07 +0000649 return RValue::get(0);
Chris Lattnerab5e0af2009-10-28 17:39:19 +0000650
651 if (const ComplexType *CTy = Ty->getAs<ComplexType>()) {
Chris Lattner2192fe52011-07-18 04:24:23 +0000652 llvm::Type *EltTy = ConvertType(CTy->getElementType());
Owen Anderson7ec07a52009-07-30 23:11:26 +0000653 llvm::Value *U = llvm::UndefValue::get(EltTy);
Daniel Dunbar8429dbc2009-01-09 20:09:28 +0000654 return RValue::getComplex(std::make_pair(U, U));
Chris Lattnerab5e0af2009-10-28 17:39:19 +0000655 }
656
Chris Lattner65526f02010-08-23 05:26:13 +0000657 // If this is a use of an undefined aggregate type, the aggregate must have an
658 // identifiable address. Just because the contents of the value are undefined
659 // doesn't mean that the address can't be taken and compared.
Chris Lattnerab5e0af2009-10-28 17:39:19 +0000660 if (hasAggregateLLVMType(Ty)) {
Chris Lattner65526f02010-08-23 05:26:13 +0000661 llvm::Value *DestPtr = CreateMemTemp(Ty, "undef.agg.tmp");
662 return RValue::getAggregate(DestPtr);
Daniel Dunbar8429dbc2009-01-09 20:09:28 +0000663 }
Chris Lattnerab5e0af2009-10-28 17:39:19 +0000664
665 return RValue::get(llvm::UndefValue::get(ConvertType(Ty)));
Daniel Dunbarbb197e42009-01-09 16:50:52 +0000666}
667
Daniel Dunbarc79407f2009-02-05 07:09:07 +0000668RValue CodeGenFunction::EmitUnsupportedRValue(const Expr *E,
669 const char *Name) {
670 ErrorUnsupported(E, Name);
671 return GetUndefRValue(E->getType());
672}
673
Daniel Dunbarf2e69882008-08-25 20:45:57 +0000674LValue CodeGenFunction::EmitUnsupportedLValue(const Expr *E,
675 const char *Name) {
676 ErrorUnsupported(E, Name);
Owen Anderson9793f0e2009-07-29 22:16:19 +0000677 llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType()));
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +0000678 return MakeAddrLValue(llvm::UndefValue::get(Ty), E->getType());
Daniel Dunbarf2e69882008-08-25 20:45:57 +0000679}
680
Richard Smith4d1458e2012-09-08 02:08:36 +0000681LValue CodeGenFunction::EmitCheckedLValue(const Expr *E, TypeCheckKind TCK) {
Mike Stump3f6f9fe2009-12-16 02:57:00 +0000682 LValue LV = EmitLValue(E);
Daniel Dunbardc406b82010-04-05 21:36:35 +0000683 if (!isa<DeclRefExpr>(E) && !LV.isBitField() && LV.isSimple())
Richard Smith4d1458e2012-09-08 02:08:36 +0000684 EmitTypeCheck(TCK, LV.getAddress(), E->getType(), LV.getAlignment());
Mike Stump3f6f9fe2009-12-16 02:57:00 +0000685 return LV;
686}
687
Chris Lattner8394d792007-06-05 20:53:16 +0000688/// EmitLValue - Emit code to compute a designator that specifies the location
689/// of the expression.
690///
Mike Stump4a3999f2009-09-09 13:00:44 +0000691/// This can return one of two things: a simple address or a bitfield reference.
692/// In either case, the LLVM Value* in the LValue structure is guaranteed to be
693/// an LLVM pointer type.
Chris Lattner8394d792007-06-05 20:53:16 +0000694///
Mike Stump4a3999f2009-09-09 13:00:44 +0000695/// If this returns a bitfield reference, nothing about the pointee type of the
696/// LLVM value is known: For example, it may not be a pointer to an integer.
Chris Lattner8394d792007-06-05 20:53:16 +0000697///
Mike Stump4a3999f2009-09-09 13:00:44 +0000698/// If this returns a normal address, and if the lvalue's C type is fixed size,
699/// this method guarantees that the returned pointer type will point to an LLVM
700/// type of the same size of the lvalue's type. If the lvalue has a variable
701/// length type, this is not possible.
Chris Lattner8394d792007-06-05 20:53:16 +0000702///
Chris Lattnerd7f58862007-06-02 05:24:33 +0000703LValue CodeGenFunction::EmitLValue(const Expr *E) {
704 switch (E->getStmtClass()) {
Daniel Dunbarf2e69882008-08-25 20:45:57 +0000705 default: return EmitUnsupportedLValue(E, "l-value expression");
Chris Lattnerd7f58862007-06-02 05:24:33 +0000706
John McCallc109a252011-11-07 03:59:57 +0000707 case Expr::ObjCPropertyRefExprClass:
708 llvm_unreachable("cannot emit a property reference directly");
709
Fariborz Jahanian9240f3d2010-06-17 19:56:20 +0000710 case Expr::ObjCSelectorExprClass:
711 return EmitObjCSelectorLValue(cast<ObjCSelectorExpr>(E));
Fariborz Jahanian531c16f2009-12-09 23:35:29 +0000712 case Expr::ObjCIsaExprClass:
713 return EmitObjCIsaExpr(cast<ObjCIsaExpr>(E));
Mike Stump4a3999f2009-09-09 13:00:44 +0000714 case Expr::BinaryOperatorClass:
Daniel Dunbar8cde00a2008-09-04 03:20:13 +0000715 return EmitBinaryOperatorLValue(cast<BinaryOperator>(E));
Douglas Gregor914af212010-04-23 04:16:32 +0000716 case Expr::CompoundAssignOperatorClass:
John McCalla2342eb2010-12-05 02:00:02 +0000717 if (!E->getType()->isAnyComplexType())
718 return EmitCompoundAssignmentLValue(cast<CompoundAssignOperator>(E));
719 return EmitComplexCompoundAssignmentLValue(cast<CompoundAssignOperator>(E));
Mike Stump4a3999f2009-09-09 13:00:44 +0000720 case Expr::CallExprClass:
Anders Carlssonc82555f2009-09-01 21:18:52 +0000721 case Expr::CXXMemberCallExprClass:
Douglas Gregor993603d2008-11-14 16:09:21 +0000722 case Expr::CXXOperatorCallExprClass:
Richard Smithc67fdd42012-03-07 08:35:16 +0000723 case Expr::UserDefinedLiteralClass:
Douglas Gregor993603d2008-11-14 16:09:21 +0000724 return EmitCallExprLValue(cast<CallExpr>(E));
Daniel Dunbar8d9dc4a2009-02-11 20:59:32 +0000725 case Expr::VAArgExprClass:
726 return EmitVAArgExprLValue(cast<VAArgExpr>(E));
Mike Stump4a3999f2009-09-09 13:00:44 +0000727 case Expr::DeclRefExprClass:
Douglas Gregorc7acfdf2009-01-06 05:10:23 +0000728 return EmitDeclRefLValue(cast<DeclRefExpr>(E));
Eric Christopherd98e4242011-09-08 17:15:04 +0000729 case Expr::ParenExprClass:
730 return EmitLValue(cast<ParenExpr>(E)->getSubExpr());
Peter Collingbourne91147592011-04-15 00:35:48 +0000731 case Expr::GenericSelectionExprClass:
732 return EmitLValue(cast<GenericSelectionExpr>(E)->getResultExpr());
Chris Lattner6307f192008-08-10 01:53:14 +0000733 case Expr::PredefinedExprClass:
734 return EmitPredefinedLValue(cast<PredefinedExpr>(E));
Chris Lattner4347e3692007-06-06 04:54:52 +0000735 case Expr::StringLiteralClass:
736 return EmitStringLiteralLValue(cast<StringLiteral>(E));
Chris Lattnerd7e7b8e2009-02-24 22:18:39 +0000737 case Expr::ObjCEncodeExprClass:
738 return EmitObjCEncodeExprLValue(cast<ObjCEncodeExpr>(E));
John McCallfe96e0b2011-11-06 09:01:30 +0000739 case Expr::PseudoObjectExprClass:
740 return EmitPseudoObjectLValue(cast<PseudoObjectExpr>(E));
Sebastian Redl29526f02011-11-27 16:50:07 +0000741 case Expr::InitListExprClass:
Richard Smithbb653bd2012-05-14 21:57:21 +0000742 return EmitInitListLValue(cast<InitListExpr>(E));
Anders Carlsson3be22e22009-05-30 23:23:33 +0000743 case Expr::CXXTemporaryObjectExprClass:
744 case Expr::CXXConstructExprClass:
Anders Carlssonfd2af0c2009-05-30 23:30:54 +0000745 return EmitCXXConstructLValue(cast<CXXConstructExpr>(E));
746 case Expr::CXXBindTemporaryExprClass:
747 return EmitCXXBindTemporaryLValue(cast<CXXBindTemporaryExpr>(E));
Eli Friedman5bc17122012-02-08 05:34:55 +0000748 case Expr::LambdaExprClass:
749 return EmitLambdaLValue(cast<LambdaExpr>(E));
John McCall08ef4662011-11-10 08:15:53 +0000750
751 case Expr::ExprWithCleanupsClass: {
752 const ExprWithCleanups *cleanups = cast<ExprWithCleanups>(E);
753 enterFullExpression(cleanups);
754 RunCleanupsScope Scope(*this);
755 return EmitLValue(cleanups->getSubExpr());
756 }
757
Douglas Gregor747eb782010-07-08 06:14:04 +0000758 case Expr::CXXScalarValueInitExprClass:
759 return EmitNullInitializationLValue(cast<CXXScalarValueInitExpr>(E));
Anders Carlsson52ce3bb2009-11-14 01:51:50 +0000760 case Expr::CXXDefaultArgExprClass:
761 return EmitLValue(cast<CXXDefaultArgExpr>(E)->getExpr());
Mike Stumpc9b231c2009-11-15 08:09:41 +0000762 case Expr::CXXTypeidExprClass:
763 return EmitCXXTypeidLValue(cast<CXXTypeidExpr>(E));
Anders Carlssonfd2af0c2009-05-30 23:30:54 +0000764
Daniel Dunbarc8317a42008-08-23 10:51:21 +0000765 case Expr::ObjCMessageExprClass:
766 return EmitObjCMessageExprLValue(cast<ObjCMessageExpr>(E));
Mike Stump4a3999f2009-09-09 13:00:44 +0000767 case Expr::ObjCIvarRefExprClass:
Chris Lattner4bd55962008-03-30 23:03:07 +0000768 return EmitObjCIvarRefLValue(cast<ObjCIvarRefExpr>(E));
Chris Lattnera4185c52009-04-25 19:35:26 +0000769 case Expr::StmtExprClass:
770 return EmitStmtExprLValue(cast<StmtExpr>(E));
Mike Stump4a3999f2009-09-09 13:00:44 +0000771 case Expr::UnaryOperatorClass:
Chris Lattner8394d792007-06-05 20:53:16 +0000772 return EmitUnaryOpLValue(cast<UnaryOperator>(E));
Chris Lattnerd9d2fb12007-06-08 23:31:14 +0000773 case Expr::ArraySubscriptExprClass:
774 return EmitArraySubscriptExpr(cast<ArraySubscriptExpr>(E));
Nate Begemance4d7fc2008-04-18 23:10:10 +0000775 case Expr::ExtVectorElementExprClass:
776 return EmitExtVectorElementExpr(cast<ExtVectorElementExpr>(E));
Mike Stump4a3999f2009-09-09 13:00:44 +0000777 case Expr::MemberExprClass:
Douglas Gregorc1905232009-08-26 22:36:53 +0000778 return EmitMemberExpr(cast<MemberExpr>(E));
Eli Friedman9fd8b682008-05-13 23:18:27 +0000779 case Expr::CompoundLiteralExprClass:
780 return EmitCompoundLiteralLValue(cast<CompoundLiteralExpr>(E));
Daniel Dunbarbf1fe8c2009-03-24 02:38:23 +0000781 case Expr::ConditionalOperatorClass:
Anders Carlsson1450adb2009-09-15 16:35:24 +0000782 return EmitConditionalOperatorLValue(cast<ConditionalOperator>(E));
John McCallc07a0c72011-02-17 10:25:35 +0000783 case Expr::BinaryConditionalOperatorClass:
784 return EmitConditionalOperatorLValue(cast<BinaryConditionalOperator>(E));
Chris Lattner053441f2008-12-12 05:35:08 +0000785 case Expr::ChooseExprClass:
Eli Friedmane0a5b8b2009-03-04 05:52:32 +0000786 return EmitLValue(cast<ChooseExpr>(E)->getChosenSubExpr(getContext()));
John McCall1bf58462011-02-16 08:02:54 +0000787 case Expr::OpaqueValueExprClass:
788 return EmitOpaqueValueLValue(cast<OpaqueValueExpr>(E));
John McCall7c454bb2011-07-15 05:09:51 +0000789 case Expr::SubstNonTypeTemplateParmExprClass:
790 return EmitLValue(cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement());
Chris Lattner63d06ab2009-03-18 04:02:57 +0000791 case Expr::ImplicitCastExprClass:
792 case Expr::CStyleCastExprClass:
793 case Expr::CXXFunctionalCastExprClass:
794 case Expr::CXXStaticCastExprClass:
795 case Expr::CXXDynamicCastExprClass:
796 case Expr::CXXReinterpretCastExprClass:
797 case Expr::CXXConstCastExprClass:
John McCall31168b02011-06-15 23:02:42 +0000798 case Expr::ObjCBridgedCastExprClass:
Chris Lattner28bcf1a2009-03-18 18:28:57 +0000799 return EmitCastLValue(cast<CastExpr>(E));
Sebastian Redl29526f02011-11-27 16:50:07 +0000800
Douglas Gregorfe314812011-06-21 17:03:29 +0000801 case Expr::MaterializeTemporaryExprClass:
802 return EmitMaterializeTemporaryExpr(cast<MaterializeTemporaryExpr>(E));
Chris Lattnerd7f58862007-06-02 05:24:33 +0000803 }
804}
805
John McCall71335052012-03-10 03:05:10 +0000806/// Given an object of the given canonical type, can we safely copy a
807/// value out of it based on its initializer?
808static bool isConstantEmittableObjectType(QualType type) {
809 assert(type.isCanonical());
810 assert(!type->isReferenceType());
811
812 // Must be const-qualified but non-volatile.
813 Qualifiers qs = type.getLocalQualifiers();
814 if (!qs.hasConst() || qs.hasVolatile()) return false;
815
816 // Otherwise, all object types satisfy this except C++ classes with
817 // mutable subobjects or non-trivial copy/destroy behavior.
818 if (const RecordType *RT = dyn_cast<RecordType>(type))
819 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl()))
820 if (RD->hasMutableFields() || !RD->isTrivial())
821 return false;
822
823 return true;
824}
825
826/// Can we constant-emit a load of a reference to a variable of the
827/// given type? This is different from predicates like
828/// Decl::isUsableInConstantExpressions because we do want it to apply
829/// in situations that don't necessarily satisfy the language's rules
830/// for this (e.g. C++'s ODR-use rules). For example, we want to able
831/// to do this with const float variables even if those variables
832/// aren't marked 'constexpr'.
833enum ConstantEmissionKind {
834 CEK_None,
835 CEK_AsReferenceOnly,
836 CEK_AsValueOrReference,
837 CEK_AsValueOnly
838};
839static ConstantEmissionKind checkVarTypeForConstantEmission(QualType type) {
840 type = type.getCanonicalType();
841 if (const ReferenceType *ref = dyn_cast<ReferenceType>(type)) {
842 if (isConstantEmittableObjectType(ref->getPointeeType()))
843 return CEK_AsValueOrReference;
844 return CEK_AsReferenceOnly;
845 }
846 if (isConstantEmittableObjectType(type))
847 return CEK_AsValueOnly;
848 return CEK_None;
849}
850
851/// Try to emit a reference to the given value without producing it as
852/// an l-value. This is actually more than an optimization: we can't
853/// produce an l-value for variables that we never actually captured
854/// in a block or lambda, which means const int variables or constexpr
855/// literals or similar.
856CodeGenFunction::ConstantEmission
John McCall113bee02012-03-10 09:33:50 +0000857CodeGenFunction::tryEmitAsConstant(DeclRefExpr *refExpr) {
858 ValueDecl *value = refExpr->getDecl();
859
John McCall71335052012-03-10 03:05:10 +0000860 // The value needs to be an enum constant or a constant variable.
861 ConstantEmissionKind CEK;
862 if (isa<ParmVarDecl>(value)) {
863 CEK = CEK_None;
864 } else if (VarDecl *var = dyn_cast<VarDecl>(value)) {
865 CEK = checkVarTypeForConstantEmission(var->getType());
866 } else if (isa<EnumConstantDecl>(value)) {
867 CEK = CEK_AsValueOnly;
868 } else {
869 CEK = CEK_None;
870 }
871 if (CEK == CEK_None) return ConstantEmission();
872
John McCall71335052012-03-10 03:05:10 +0000873 Expr::EvalResult result;
874 bool resultIsReference;
875 QualType resultType;
876
877 // It's best to evaluate all the way as an r-value if that's permitted.
878 if (CEK != CEK_AsReferenceOnly &&
John McCall113bee02012-03-10 09:33:50 +0000879 refExpr->EvaluateAsRValue(result, getContext())) {
John McCall71335052012-03-10 03:05:10 +0000880 resultIsReference = false;
881 resultType = refExpr->getType();
882
883 // Otherwise, try to evaluate as an l-value.
884 } else if (CEK != CEK_AsValueOnly &&
John McCall113bee02012-03-10 09:33:50 +0000885 refExpr->EvaluateAsLValue(result, getContext())) {
John McCall71335052012-03-10 03:05:10 +0000886 resultIsReference = true;
887 resultType = value->getType();
888
889 // Failure.
890 } else {
891 return ConstantEmission();
892 }
893
894 // In any case, if the initializer has side-effects, abandon ship.
895 if (result.HasSideEffects)
896 return ConstantEmission();
897
898 // Emit as a constant.
899 llvm::Constant *C = CGM.EmitConstantValue(result.Val, resultType, this);
900
901 // Make sure we emit a debug reference to the global variable.
902 // This should probably fire even for
903 if (isa<VarDecl>(value)) {
904 if (!getContext().DeclMustBeEmitted(cast<VarDecl>(value)))
John McCall113bee02012-03-10 09:33:50 +0000905 EmitDeclRefExprDbgValue(refExpr, C);
John McCall71335052012-03-10 03:05:10 +0000906 } else {
907 assert(isa<EnumConstantDecl>(value));
John McCall113bee02012-03-10 09:33:50 +0000908 EmitDeclRefExprDbgValue(refExpr, C);
John McCall71335052012-03-10 03:05:10 +0000909 }
910
911 // If we emitted a reference constant, we need to dereference that.
912 if (resultIsReference)
913 return ConstantEmission::forReference(C);
914
915 return ConstantEmission::forValue(C);
916}
917
John McCall1553b192011-06-16 04:16:24 +0000918llvm::Value *CodeGenFunction::EmitLoadOfScalar(LValue lvalue) {
919 return EmitLoadOfScalar(lvalue.getAddress(), lvalue.isVolatile(),
Eli Friedmana0544d62011-12-03 04:14:32 +0000920 lvalue.getAlignment().getQuantity(),
921 lvalue.getType(), lvalue.getTBAAInfo());
John McCall1553b192011-06-16 04:16:24 +0000922}
923
Rafael Espindola5c0034a2012-03-24 16:50:34 +0000924static bool hasBooleanRepresentation(QualType Ty) {
925 if (Ty->isBooleanType())
926 return true;
927
928 if (const EnumType *ET = Ty->getAs<EnumType>())
929 return ET->getDecl()->getIntegerType()->isBooleanType();
930
Douglas Gregor298f43d2012-04-12 20:42:30 +0000931 if (const AtomicType *AT = Ty->getAs<AtomicType>())
932 return hasBooleanRepresentation(AT->getValueType());
933
Rafael Espindola5c0034a2012-03-24 16:50:34 +0000934 return false;
935}
936
937llvm::MDNode *CodeGenFunction::getRangeForLoadFromType(QualType Ty) {
938 const EnumType *ET = Ty->getAs<EnumType>();
Chandler Carruth8b4140d2012-03-27 23:58:37 +0000939 bool IsRegularCPlusPlusEnum = (getLangOpts().CPlusPlus && ET &&
940 CGM.getCodeGenOpts().StrictEnums &&
941 !ET->getDecl()->isFixed());
Rafael Espindola5c0034a2012-03-24 16:50:34 +0000942 bool IsBool = hasBooleanRepresentation(Ty);
Rafael Espindola5c0034a2012-03-24 16:50:34 +0000943 if (!IsBool && !IsRegularCPlusPlusEnum)
944 return NULL;
945
946 llvm::APInt Min;
947 llvm::APInt End;
948 if (IsBool) {
949 Min = llvm::APInt(8, 0);
950 End = llvm::APInt(8, 2);
Rafael Espindola5c0034a2012-03-24 16:50:34 +0000951 } else {
952 const EnumDecl *ED = ET->getDecl();
Ted Kremenekdb74d0b2012-05-01 17:56:53 +0000953 llvm::Type *LTy = ConvertTypeForMem(ED->getIntegerType());
Rafael Espindola5c0034a2012-03-24 16:50:34 +0000954 unsigned Bitwidth = LTy->getScalarSizeInBits();
955 unsigned NumNegativeBits = ED->getNumNegativeBits();
956 unsigned NumPositiveBits = ED->getNumPositiveBits();
957
958 if (NumNegativeBits) {
959 unsigned NumBits = std::max(NumNegativeBits, NumPositiveBits + 1);
960 assert(NumBits <= Bitwidth);
961 End = llvm::APInt(Bitwidth, 1) << (NumBits - 1);
962 Min = -End;
963 } else {
964 assert(NumPositiveBits <= Bitwidth);
965 End = llvm::APInt(Bitwidth, 1) << NumPositiveBits;
966 Min = llvm::APInt(Bitwidth, 0);
967 }
968 }
969
Duncan Sandsc720e782012-04-15 18:04:54 +0000970 llvm::MDBuilder MDHelper(getLLVMContext());
Duncan Sands65229ed2012-04-16 16:29:47 +0000971 return MDHelper.createRange(Min, End);
Rafael Espindola5c0034a2012-03-24 16:50:34 +0000972}
973
Daniel Dunbar1d425462009-02-10 00:57:50 +0000974llvm::Value *CodeGenFunction::EmitLoadOfScalar(llvm::Value *Addr, bool Volatile,
Dan Gohman947c9af2010-10-14 23:06:10 +0000975 unsigned Alignment, QualType Ty,
976 llvm::MDNode *TBAAInfo) {
Tanya Lattnera9dd49f2012-08-16 00:10:13 +0000977
978 // For better performance, handle vector loads differently.
979 if (Ty->isVectorType()) {
980 llvm::Value *V;
981 const llvm::Type *EltTy =
982 cast<llvm::PointerType>(Addr->getType())->getElementType();
983
984 const llvm::VectorType *VTy = cast<llvm::VectorType>(EltTy);
985
986 // Handle vectors of size 3, like size 4 for better performance.
987 if (VTy->getNumElements() == 3) {
988
989 // Bitcast to vec4 type.
990 llvm::VectorType *vec4Ty = llvm::VectorType::get(VTy->getElementType(),
991 4);
992 llvm::PointerType *ptVec4Ty =
993 llvm::PointerType::get(vec4Ty,
994 (cast<llvm::PointerType>(
995 Addr->getType()))->getAddressSpace());
996 llvm::Value *Cast = Builder.CreateBitCast(Addr, ptVec4Ty,
997 "castToVec4");
998 // Now load value.
999 llvm::Value *LoadVal = Builder.CreateLoad(Cast, Volatile, "loadVec4");
1000
1001 // Shuffle vector to get vec3.
1002 llvm::SmallVector<llvm::Constant*, 3> Mask;
1003 Mask.push_back(llvm::ConstantInt::get(
1004 llvm::Type::getInt32Ty(getLLVMContext()),
1005 0));
1006 Mask.push_back(llvm::ConstantInt::get(
1007 llvm::Type::getInt32Ty(getLLVMContext()),
1008 1));
1009 Mask.push_back(llvm::ConstantInt::get(
1010 llvm::Type::getInt32Ty(getLLVMContext()),
1011 2));
1012
1013 llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
1014 V = Builder.CreateShuffleVector(LoadVal,
1015 llvm::UndefValue::get(vec4Ty),
1016 MaskV, "extractVec");
1017 return EmitFromMemory(V, Ty);
1018 }
1019 }
1020
Benjamin Kramer76399eb2011-09-27 21:06:10 +00001021 llvm::LoadInst *Load = Builder.CreateLoad(Addr);
Daniel Dunbarc76493a2009-11-29 21:23:36 +00001022 if (Volatile)
1023 Load->setVolatile(true);
Daniel Dunbar03816342010-08-21 02:24:36 +00001024 if (Alignment)
1025 Load->setAlignment(Alignment);
Dan Gohman947c9af2010-10-14 23:06:10 +00001026 if (TBAAInfo)
1027 CGM.DecorateInstruction(Load, TBAAInfo);
David Chisnallfa35df62012-01-16 17:27:18 +00001028 // If this is an atomic type, all normal reads must be atomic
1029 if (Ty->isAtomicType())
1030 Load->setAtomic(llvm::SequentiallyConsistent);
Daniel Dunbar1d425462009-02-10 00:57:50 +00001031
Rafael Espindola5c0034a2012-03-24 16:50:34 +00001032 if (CGM.getCodeGenOpts().OptimizationLevel > 0)
1033 if (llvm::MDNode *RangeInfo = getRangeForLoadFromType(Ty))
1034 Load->setMetadata(llvm::LLVMContext::MD_range, RangeInfo);
Douglas Gregor0bf31402010-10-08 23:50:27 +00001035
Rafael Espindola5c0034a2012-03-24 16:50:34 +00001036 return EmitFromMemory(Load, Ty);
NAKAMURA Takumi2681efc2012-03-24 14:43:42 +00001037}
1038
John McCall3a7f6922010-10-27 20:58:56 +00001039llvm::Value *CodeGenFunction::EmitToMemory(llvm::Value *Value, QualType Ty) {
1040 // Bool has a different representation in memory than in registers.
Rafael Espindola5c0034a2012-03-24 16:50:34 +00001041 if (hasBooleanRepresentation(Ty)) {
John McCall3a7f6922010-10-27 20:58:56 +00001042 // This should really always be an i1, but sometimes it's already
1043 // an i8, and it's awkward to track those cases down.
1044 if (Value->getType()->isIntegerTy(1))
1045 return Builder.CreateZExt(Value, Builder.getInt8Ty(), "frombool");
1046 assert(Value->getType()->isIntegerTy(8) && "value rep of bool not i1/i8");
1047 }
1048
1049 return Value;
1050}
1051
1052llvm::Value *CodeGenFunction::EmitFromMemory(llvm::Value *Value, QualType Ty) {
1053 // Bool has a different representation in memory than in registers.
Rafael Espindola5c0034a2012-03-24 16:50:34 +00001054 if (hasBooleanRepresentation(Ty)) {
John McCall3a7f6922010-10-27 20:58:56 +00001055 assert(Value->getType()->isIntegerTy(8) && "memory rep of bool not i8");
1056 return Builder.CreateTrunc(Value, Builder.getInt1Ty(), "tobool");
1057 }
1058
1059 return Value;
1060}
1061
Daniel Dunbar1d425462009-02-10 00:57:50 +00001062void CodeGenFunction::EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr,
Daniel Dunbar03816342010-08-21 02:24:36 +00001063 bool Volatile, unsigned Alignment,
Dan Gohman947c9af2010-10-14 23:06:10 +00001064 QualType Ty,
David Chisnallfa35df62012-01-16 17:27:18 +00001065 llvm::MDNode *TBAAInfo,
1066 bool isInit) {
Tanya Lattnera9dd49f2012-08-16 00:10:13 +00001067
1068 // Handle vectors differently to get better performance.
1069 if (Ty->isVectorType()) {
1070 llvm::Type *SrcTy = Value->getType();
1071 llvm::VectorType *VecTy = cast<llvm::VectorType>(SrcTy);
1072 // Handle vec3 special.
1073 if (VecTy->getNumElements() == 3) {
1074 llvm::LLVMContext &VMContext = getLLVMContext();
1075
1076 // Our source is a vec3, do a shuffle vector to make it a vec4.
1077 llvm::SmallVector<llvm::Constant*, 4> Mask;
1078 Mask.push_back(llvm::ConstantInt::get(
1079 llvm::Type::getInt32Ty(VMContext),
1080 0));
1081 Mask.push_back(llvm::ConstantInt::get(
1082 llvm::Type::getInt32Ty(VMContext),
1083 1));
1084 Mask.push_back(llvm::ConstantInt::get(
1085 llvm::Type::getInt32Ty(VMContext),
1086 2));
1087 Mask.push_back(llvm::UndefValue::get(llvm::Type::getInt32Ty(VMContext)));
1088
1089 llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
1090 Value = Builder.CreateShuffleVector(Value,
1091 llvm::UndefValue::get(VecTy),
1092 MaskV, "extractVec");
1093 SrcTy = llvm::VectorType::get(VecTy->getElementType(), 4);
1094 }
1095 llvm::PointerType *DstPtr = cast<llvm::PointerType>(Addr->getType());
1096 if (DstPtr->getElementType() != SrcTy) {
1097 llvm::Type *MemTy =
1098 llvm::PointerType::get(SrcTy, DstPtr->getAddressSpace());
1099 Addr = Builder.CreateBitCast(Addr, MemTy, "storetmp");
1100 }
1101 }
1102
John McCall3a7f6922010-10-27 20:58:56 +00001103 Value = EmitToMemory(Value, Ty);
Chris Lattner1a5f8972011-07-10 03:38:35 +00001104
Daniel Dunbar03816342010-08-21 02:24:36 +00001105 llvm::StoreInst *Store = Builder.CreateStore(Value, Addr, Volatile);
1106 if (Alignment)
1107 Store->setAlignment(Alignment);
Dan Gohman947c9af2010-10-14 23:06:10 +00001108 if (TBAAInfo)
1109 CGM.DecorateInstruction(Store, TBAAInfo);
David Chisnallfa35df62012-01-16 17:27:18 +00001110 if (!isInit && Ty->isAtomicType())
1111 Store->setAtomic(llvm::SequentiallyConsistent);
Daniel Dunbar1d425462009-02-10 00:57:50 +00001112}
1113
David Chisnallfa35df62012-01-16 17:27:18 +00001114void CodeGenFunction::EmitStoreOfScalar(llvm::Value *value, LValue lvalue,
1115 bool isInit) {
John McCall1553b192011-06-16 04:16:24 +00001116 EmitStoreOfScalar(value, lvalue.getAddress(), lvalue.isVolatile(),
Eli Friedmana0544d62011-12-03 04:14:32 +00001117 lvalue.getAlignment().getQuantity(), lvalue.getType(),
David Chisnallfa35df62012-01-16 17:27:18 +00001118 lvalue.getTBAAInfo(), isInit);
John McCall1553b192011-06-16 04:16:24 +00001119}
1120
Mike Stump4a3999f2009-09-09 13:00:44 +00001121/// EmitLoadOfLValue - Given an expression that represents a value lvalue, this
1122/// method emits the address of the lvalue, then loads the result as an rvalue,
1123/// returning the rvalue.
John McCall55e1fbc2011-06-25 02:11:03 +00001124RValue CodeGenFunction::EmitLoadOfLValue(LValue LV) {
Fariborz Jahanian50a12702008-11-19 17:34:06 +00001125 if (LV.isObjCWeak()) {
Mike Stump4a3999f2009-09-09 13:00:44 +00001126 // load of a __weak object.
Fariborz Jahanianf5125d12008-11-18 21:45:40 +00001127 llvm::Value *AddrWeakObj = LV.getAddress();
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001128 return RValue::get(CGM.getObjCRuntime().EmitObjCWeakRead(*this,
1129 AddrWeakObj));
Fariborz Jahanianf5125d12008-11-18 21:45:40 +00001130 }
John McCall31168b02011-06-15 23:02:42 +00001131 if (LV.getQuals().getObjCLifetime() == Qualifiers::OCL_Weak)
1132 return RValue::get(EmitARCLoadWeak(LV.getAddress()));
Mike Stump4a3999f2009-09-09 13:00:44 +00001133
Chris Lattner08c4b9f2007-07-10 21:17:59 +00001134 if (LV.isSimple()) {
John McCalld68b2d02011-06-27 21:24:11 +00001135 assert(!LV.getType()->isFunctionType());
Mike Stump4a3999f2009-09-09 13:00:44 +00001136
John McCalla1dee5302010-08-22 10:59:02 +00001137 // Everything needs a load.
John McCall55e1fbc2011-06-25 02:11:03 +00001138 return RValue::get(EmitLoadOfScalar(LV));
Chris Lattner08c4b9f2007-07-10 21:17:59 +00001139 }
Mike Stump4a3999f2009-09-09 13:00:44 +00001140
Chris Lattner08c4b9f2007-07-10 21:17:59 +00001141 if (LV.isVectorElt()) {
Eli Friedman610bb872012-03-22 22:36:39 +00001142 llvm::LoadInst *Load = Builder.CreateLoad(LV.getVectorAddr(),
1143 LV.isVolatileQualified());
1144 Load->setAlignment(LV.getAlignment().getQuantity());
1145 return RValue::get(Builder.CreateExtractElement(Load, LV.getVectorIdx(),
Chris Lattner08c4b9f2007-07-10 21:17:59 +00001146 "vecext"));
1147 }
Chris Lattner73ab9b32007-08-03 00:16:29 +00001148
1149 // If this is a reference to a subset of the elements of a vector, either
1150 // shuffle the input or extract/insert them as appropriate.
Nate Begemance4d7fc2008-04-18 23:10:10 +00001151 if (LV.isExtVectorElt())
John McCall55e1fbc2011-06-25 02:11:03 +00001152 return EmitLoadOfExtVectorElementLValue(LV);
Lauro Ramos Venancio2ddcb25a32008-01-22 20:17:04 +00001153
John McCallc109a252011-11-07 03:59:57 +00001154 assert(LV.isBitField() && "Unknown LValue type!");
1155 return EmitLoadOfBitfieldLValue(LV);
Chris Lattner8394d792007-06-05 20:53:16 +00001156}
1157
John McCall55e1fbc2011-06-25 02:11:03 +00001158RValue CodeGenFunction::EmitLoadOfBitfieldLValue(LValue LV) {
Daniel Dunbar196ea442010-04-06 01:07:44 +00001159 const CGBitFieldInfo &Info = LV.getBitFieldInfo();
Daniel Dunbaread7c912008-08-06 05:08:45 +00001160
Daniel Dunbar3447a022010-04-13 23:34:15 +00001161 // Get the output type.
Chris Lattner2192fe52011-07-18 04:24:23 +00001162 llvm::Type *ResLTy = ConvertType(LV.getType());
Micah Villmowdd31ca12012-10-08 16:25:52 +00001163 unsigned ResSizeInBits = CGM.getDataLayout().getTypeSizeInBits(ResLTy);
Lauro Ramos Venancio2ddcb25a32008-01-22 20:17:04 +00001164
Daniel Dunbar3447a022010-04-13 23:34:15 +00001165 // Compute the result as an OR of all of the individual component accesses.
1166 llvm::Value *Res = 0;
1167 for (unsigned i = 0, e = Info.getNumComponents(); i != e; ++i) {
1168 const CGBitFieldInfo::AccessInfo &AI = Info.getComponent(i);
Eli Friedmanc24e2fb2012-06-27 21:19:48 +00001169 CharUnits AccessAlignment = AI.AccessAlignment;
1170 if (!LV.getAlignment().isZero())
1171 AccessAlignment = std::min(AccessAlignment, LV.getAlignment());
Mike Stump4a3999f2009-09-09 13:00:44 +00001172
Daniel Dunbar3447a022010-04-13 23:34:15 +00001173 // Get the field pointer.
1174 llvm::Value *Ptr = LV.getBitFieldBaseAddr();
Mike Stump4a3999f2009-09-09 13:00:44 +00001175
Daniel Dunbar3447a022010-04-13 23:34:15 +00001176 // Only offset by the field index if used, so that incoming values are not
1177 // required to be structures.
1178 if (AI.FieldIndex)
1179 Ptr = Builder.CreateStructGEP(Ptr, AI.FieldIndex, "bf.field");
Mike Stump4a3999f2009-09-09 13:00:44 +00001180
Daniel Dunbar3447a022010-04-13 23:34:15 +00001181 // Offset by the byte offset, if used.
Ken Dyckf76759c2011-04-24 10:04:59 +00001182 if (!AI.FieldByteOffset.isZero()) {
John McCallad7c5c12011-02-08 08:22:06 +00001183 Ptr = EmitCastToVoidPtr(Ptr);
Ken Dyckf76759c2011-04-24 10:04:59 +00001184 Ptr = Builder.CreateConstGEP1_32(Ptr, AI.FieldByteOffset.getQuantity(),
1185 "bf.field.offs");
Daniel Dunbar3447a022010-04-13 23:34:15 +00001186 }
Mike Stump4a3999f2009-09-09 13:00:44 +00001187
Daniel Dunbar3447a022010-04-13 23:34:15 +00001188 // Cast to the access type.
Chris Lattnerece04092012-02-07 00:39:47 +00001189 llvm::Type *PTy = llvm::Type::getIntNPtrTy(getLLVMContext(), AI.AccessWidth,
John McCall55e1fbc2011-06-25 02:11:03 +00001190 CGM.getContext().getTargetAddressSpace(LV.getType()));
Daniel Dunbar3447a022010-04-13 23:34:15 +00001191 Ptr = Builder.CreateBitCast(Ptr, PTy);
Lauro Ramos Venancio2ddcb25a32008-01-22 20:17:04 +00001192
Daniel Dunbar3447a022010-04-13 23:34:15 +00001193 // Perform the load.
1194 llvm::LoadInst *Load = Builder.CreateLoad(Ptr, LV.isVolatileQualified());
Eli Friedmanc24e2fb2012-06-27 21:19:48 +00001195 Load->setAlignment(AccessAlignment.getQuantity());
Daniel Dunbar3447a022010-04-13 23:34:15 +00001196
1197 // Shift out unused low bits and mask out unused high bits.
1198 llvm::Value *Val = Load;
1199 if (AI.FieldBitStart)
Daniel Dunbar67aba792010-04-15 03:47:33 +00001200 Val = Builder.CreateLShr(Load, AI.FieldBitStart);
Daniel Dunbar3447a022010-04-13 23:34:15 +00001201 Val = Builder.CreateAnd(Val, llvm::APInt::getLowBitsSet(AI.AccessWidth,
1202 AI.TargetBitWidth),
1203 "bf.clear");
1204
1205 // Extend or truncate to the target size.
1206 if (AI.AccessWidth < ResSizeInBits)
1207 Val = Builder.CreateZExt(Val, ResLTy);
1208 else if (AI.AccessWidth > ResSizeInBits)
1209 Val = Builder.CreateTrunc(Val, ResLTy);
1210
1211 // Shift into place, and OR into the result.
1212 if (AI.TargetBitOffset)
1213 Val = Builder.CreateShl(Val, AI.TargetBitOffset);
1214 Res = Res ? Builder.CreateOr(Res, Val) : Val;
Daniel Dunbaread7c912008-08-06 05:08:45 +00001215 }
Lauro Ramos Venancio2ddcb25a32008-01-22 20:17:04 +00001216
Daniel Dunbar3447a022010-04-13 23:34:15 +00001217 // If the bit-field is signed, perform the sign-extension.
1218 //
1219 // FIXME: This can easily be folded into the load of the high bits, which
1220 // could also eliminate the mask of high bits in some situations.
1221 if (Info.isSigned()) {
Daniel Dunbar67aba792010-04-15 03:47:33 +00001222 unsigned ExtraBits = ResSizeInBits - Info.getSize();
Daniel Dunbar3447a022010-04-13 23:34:15 +00001223 if (ExtraBits)
1224 Res = Builder.CreateAShr(Builder.CreateShl(Res, ExtraBits),
1225 ExtraBits, "bf.val.sext");
Daniel Dunbaread7c912008-08-06 05:08:45 +00001226 }
Eli Friedmanf2442dc2008-05-17 20:03:47 +00001227
Daniel Dunbar3447a022010-04-13 23:34:15 +00001228 return RValue::get(Res);
Lauro Ramos Venancio2ddcb25a32008-01-22 20:17:04 +00001229}
1230
Nate Begemanb699c9b2009-01-18 06:42:49 +00001231// If this is a reference to a subset of the elements of a vector, create an
1232// appropriate shufflevector.
John McCall55e1fbc2011-06-25 02:11:03 +00001233RValue CodeGenFunction::EmitLoadOfExtVectorElementLValue(LValue LV) {
Eli Friedman610bb872012-03-22 22:36:39 +00001234 llvm::LoadInst *Load = Builder.CreateLoad(LV.getExtVectorAddr(),
1235 LV.isVolatileQualified());
1236 Load->setAlignment(LV.getAlignment().getQuantity());
1237 llvm::Value *Vec = Load;
Mike Stump4a3999f2009-09-09 13:00:44 +00001238
Nate Begemanf322eab2008-05-09 06:41:27 +00001239 const llvm::Constant *Elts = LV.getExtVectorElts();
Mike Stump4a3999f2009-09-09 13:00:44 +00001240
1241 // If the result of the expression is a non-vector type, we must be extracting
1242 // a single element. Just codegen as an extractelement.
John McCall55e1fbc2011-06-25 02:11:03 +00001243 const VectorType *ExprVT = LV.getType()->getAs<VectorType>();
Chris Lattner8eab8ff2007-08-10 17:10:08 +00001244 if (!ExprVT) {
Dan Gohman75d69da2008-05-22 00:50:06 +00001245 unsigned InIdx = getAccessedFieldNo(0, Elts);
Chris Lattner5e016ae2010-06-27 07:15:29 +00001246 llvm::Value *Elt = llvm::ConstantInt::get(Int32Ty, InIdx);
Benjamin Kramer76399eb2011-09-27 21:06:10 +00001247 return RValue::get(Builder.CreateExtractElement(Vec, Elt));
Chris Lattner40ff7012007-08-03 16:18:34 +00001248 }
Nate Begemanb699c9b2009-01-18 06:42:49 +00001249
1250 // Always use shuffle vector to try to retain the original program structure
Chris Lattner8eab8ff2007-08-10 17:10:08 +00001251 unsigned NumResultElts = ExprVT->getNumElements();
Mike Stump4a3999f2009-09-09 13:00:44 +00001252
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001253 SmallVector<llvm::Constant*, 4> Mask;
Chris Lattner2d6b7b92012-01-25 05:34:41 +00001254 for (unsigned i = 0; i != NumResultElts; ++i)
1255 Mask.push_back(Builder.getInt32(getAccessedFieldNo(i, Elts)));
Mike Stump4a3999f2009-09-09 13:00:44 +00001256
Chris Lattner91c08ad2011-02-15 00:14:06 +00001257 llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
1258 Vec = Builder.CreateShuffleVector(Vec, llvm::UndefValue::get(Vec->getType()),
Benjamin Kramer76399eb2011-09-27 21:06:10 +00001259 MaskV);
Nate Begemanb699c9b2009-01-18 06:42:49 +00001260 return RValue::get(Vec);
Chris Lattner40ff7012007-08-03 16:18:34 +00001261}
1262
1263
Chris Lattner9369a562007-06-29 16:31:29 +00001264
Chris Lattner8394d792007-06-05 20:53:16 +00001265/// EmitStoreThroughLValue - Store the specified rvalue into the specified
1266/// lvalue, where both are guaranteed to the have the same type, and that type
1267/// is 'Ty'.
David Chisnallfa35df62012-01-16 17:27:18 +00001268void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit) {
Chris Lattner41d480e2007-08-03 16:28:33 +00001269 if (!Dst.isSimple()) {
1270 if (Dst.isVectorElt()) {
1271 // Read/modify/write the vector, inserting the new element.
Eli Friedman610bb872012-03-22 22:36:39 +00001272 llvm::LoadInst *Load = Builder.CreateLoad(Dst.getVectorAddr(),
1273 Dst.isVolatileQualified());
1274 Load->setAlignment(Dst.getAlignment().getQuantity());
1275 llvm::Value *Vec = Load;
Chris Lattner4647a212007-08-31 22:49:20 +00001276 Vec = Builder.CreateInsertElement(Vec, Src.getScalarVal(),
Chris Lattner41d480e2007-08-03 16:28:33 +00001277 Dst.getVectorIdx(), "vecins");
Eli Friedman610bb872012-03-22 22:36:39 +00001278 llvm::StoreInst *Store = Builder.CreateStore(Vec, Dst.getVectorAddr(),
1279 Dst.isVolatileQualified());
1280 Store->setAlignment(Dst.getAlignment().getQuantity());
Chris Lattner41d480e2007-08-03 16:28:33 +00001281 return;
1282 }
Mike Stump4a3999f2009-09-09 13:00:44 +00001283
Nate Begemance4d7fc2008-04-18 23:10:10 +00001284 // If this is an update of extended vector elements, insert them as
1285 // appropriate.
1286 if (Dst.isExtVectorElt())
John McCall55e1fbc2011-06-25 02:11:03 +00001287 return EmitStoreThroughExtVectorComponentLValue(Src, Dst);
Lauro Ramos Venancio09af71c2008-01-22 22:36:45 +00001288
John McCallc109a252011-11-07 03:59:57 +00001289 assert(Dst.isBitField() && "Unknown LValue type");
1290 return EmitStoreThroughBitfieldLValue(Src, Dst);
Chris Lattner41d480e2007-08-03 16:28:33 +00001291 }
Mike Stump4a3999f2009-09-09 13:00:44 +00001292
John McCall31168b02011-06-15 23:02:42 +00001293 // There's special magic for assigning into an ARC-qualified l-value.
1294 if (Qualifiers::ObjCLifetime Lifetime = Dst.getQuals().getObjCLifetime()) {
1295 switch (Lifetime) {
1296 case Qualifiers::OCL_None:
1297 llvm_unreachable("present but none");
1298
1299 case Qualifiers::OCL_ExplicitNone:
1300 // nothing special
1301 break;
1302
1303 case Qualifiers::OCL_Strong:
John McCall55e1fbc2011-06-25 02:11:03 +00001304 EmitARCStoreStrong(Dst, Src.getScalarVal(), /*ignore*/ true);
John McCall31168b02011-06-15 23:02:42 +00001305 return;
1306
1307 case Qualifiers::OCL_Weak:
1308 EmitARCStoreWeak(Dst.getAddress(), Src.getScalarVal(), /*ignore*/ true);
1309 return;
1310
1311 case Qualifiers::OCL_Autoreleasing:
John McCall55e1fbc2011-06-25 02:11:03 +00001312 Src = RValue::get(EmitObjCExtendObjectLifetime(Dst.getType(),
1313 Src.getScalarVal()));
John McCall31168b02011-06-15 23:02:42 +00001314 // fall into the normal path
1315 break;
1316 }
1317 }
1318
Fariborz Jahanian10bec102009-02-21 00:30:43 +00001319 if (Dst.isObjCWeak() && !Dst.isNonGC()) {
Mike Stump4a3999f2009-09-09 13:00:44 +00001320 // load of a __weak object.
Fariborz Jahanian50a12702008-11-19 17:34:06 +00001321 llvm::Value *LvalueDst = Dst.getAddress();
1322 llvm::Value *src = Src.getScalarVal();
Mike Stumpca5ae662009-04-14 00:57:29 +00001323 CGM.getObjCRuntime().EmitObjCWeakAssign(*this, src, LvalueDst);
Fariborz Jahanian50a12702008-11-19 17:34:06 +00001324 return;
1325 }
Mike Stump4a3999f2009-09-09 13:00:44 +00001326
Fariborz Jahanian10bec102009-02-21 00:30:43 +00001327 if (Dst.isObjCStrong() && !Dst.isNonGC()) {
Mike Stump4a3999f2009-09-09 13:00:44 +00001328 // load of a __strong object.
Fariborz Jahanian50a12702008-11-19 17:34:06 +00001329 llvm::Value *LvalueDst = Dst.getAddress();
1330 llvm::Value *src = Src.getScalarVal();
Fariborz Jahanian7a95d722009-09-24 22:25:38 +00001331 if (Dst.isObjCIvar()) {
1332 assert(Dst.getBaseIvarExp() && "BaseIvarExp is NULL");
Chris Lattner2192fe52011-07-18 04:24:23 +00001333 llvm::Type *ResultType = ConvertType(getContext().LongTy);
Fariborz Jahanian7a95d722009-09-24 22:25:38 +00001334 llvm::Value *RHS = EmitScalarExpr(Dst.getBaseIvarExp());
Fariborz Jahanian1f9ed582009-09-25 00:00:20 +00001335 llvm::Value *dst = RHS;
Fariborz Jahanian7a95d722009-09-24 22:25:38 +00001336 RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast");
1337 llvm::Value *LHS =
1338 Builder.CreatePtrToInt(LvalueDst, ResultType, "sub.ptr.lhs.cast");
1339 llvm::Value *BytesBetween = Builder.CreateSub(LHS, RHS, "ivar.offset");
Fariborz Jahanian1f9ed582009-09-25 00:00:20 +00001340 CGM.getObjCRuntime().EmitObjCIvarAssign(*this, src, dst,
Fariborz Jahanian7a95d722009-09-24 22:25:38 +00001341 BytesBetween);
Fariborz Jahanian217af242010-07-20 20:30:03 +00001342 } else if (Dst.isGlobalObjCRef()) {
1343 CGM.getObjCRuntime().EmitObjCGlobalAssign(*this, src, LvalueDst,
1344 Dst.isThreadLocalRef());
1345 }
Fariborz Jahanian32ff7ae2009-05-04 23:27:20 +00001346 else
1347 CGM.getObjCRuntime().EmitObjCStrongCastAssign(*this, src, LvalueDst);
Fariborz Jahanian50a12702008-11-19 17:34:06 +00001348 return;
1349 }
Mike Stump4a3999f2009-09-09 13:00:44 +00001350
Chris Lattner6278e6a2007-08-11 00:04:45 +00001351 assert(Src.isScalar() && "Can't emit an agg store with this method");
David Chisnallfa35df62012-01-16 17:27:18 +00001352 EmitStoreOfScalar(Src.getScalarVal(), Dst, isInit);
Chris Lattner8394d792007-06-05 20:53:16 +00001353}
1354
Lauro Ramos Venancio09af71c2008-01-22 22:36:45 +00001355void CodeGenFunction::EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst,
Daniel Dunbar9b1335e2008-11-19 09:36:46 +00001356 llvm::Value **Result) {
Daniel Dunbar196ea442010-04-06 01:07:44 +00001357 const CGBitFieldInfo &Info = Dst.getBitFieldInfo();
Lauro Ramos Venancio09af71c2008-01-22 22:36:45 +00001358
Daniel Dunbar67aba792010-04-15 03:47:33 +00001359 // Get the output type.
Chris Lattner2192fe52011-07-18 04:24:23 +00001360 llvm::Type *ResLTy = ConvertTypeForMem(Dst.getType());
Micah Villmowdd31ca12012-10-08 16:25:52 +00001361 unsigned ResSizeInBits = CGM.getDataLayout().getTypeSizeInBits(ResLTy);
Daniel Dunbaread7c912008-08-06 05:08:45 +00001362
Daniel Dunbar67aba792010-04-15 03:47:33 +00001363 // Get the source value, truncated to the width of the bit-field.
Daniel Dunbar9b1335e2008-11-19 09:36:46 +00001364 llvm::Value *SrcVal = Src.getScalarVal();
Anders Carlsson8345a702010-04-17 21:52:22 +00001365
Douglas Gregor298f43d2012-04-12 20:42:30 +00001366 if (hasBooleanRepresentation(Dst.getType()))
Anders Carlsson8345a702010-04-17 21:52:22 +00001367 SrcVal = Builder.CreateIntCast(SrcVal, ResLTy, /*IsSigned=*/false);
1368
Daniel Dunbar67aba792010-04-15 03:47:33 +00001369 SrcVal = Builder.CreateAnd(SrcVal, llvm::APInt::getLowBitsSet(ResSizeInBits,
1370 Info.getSize()),
1371 "bf.value");
Lauro Ramos Venancio09af71c2008-01-22 22:36:45 +00001372
Daniel Dunbar9b1335e2008-11-19 09:36:46 +00001373 // Return the new value of the bit-field, if requested.
1374 if (Result) {
1375 // Cast back to the proper type for result.
Chris Lattner2192fe52011-07-18 04:24:23 +00001376 llvm::Type *SrcTy = Src.getScalarVal()->getType();
Daniel Dunbar67aba792010-04-15 03:47:33 +00001377 llvm::Value *ReloadVal = Builder.CreateIntCast(SrcVal, SrcTy, false,
1378 "bf.reload.val");
Daniel Dunbar9b1335e2008-11-19 09:36:46 +00001379
1380 // Sign extend if necessary.
Daniel Dunbar67aba792010-04-15 03:47:33 +00001381 if (Info.isSigned()) {
1382 unsigned ExtraBits = ResSizeInBits - Info.getSize();
1383 if (ExtraBits)
1384 ReloadVal = Builder.CreateAShr(Builder.CreateShl(ReloadVal, ExtraBits),
1385 ExtraBits, "bf.reload.sext");
Daniel Dunbar9b1335e2008-11-19 09:36:46 +00001386 }
1387
Daniel Dunbar67aba792010-04-15 03:47:33 +00001388 *Result = ReloadVal;
Daniel Dunbar9b1335e2008-11-19 09:36:46 +00001389 }
1390
Daniel Dunbar67aba792010-04-15 03:47:33 +00001391 // Iterate over the components, writing each piece to memory.
1392 for (unsigned i = 0, e = Info.getNumComponents(); i != e; ++i) {
1393 const CGBitFieldInfo::AccessInfo &AI = Info.getComponent(i);
Eli Friedmanc24e2fb2012-06-27 21:19:48 +00001394 CharUnits AccessAlignment = AI.AccessAlignment;
1395 if (!Dst.getAlignment().isZero())
1396 AccessAlignment = std::min(AccessAlignment, Dst.getAlignment());
Eli Friedmanf2442dc2008-05-17 20:03:47 +00001397
Daniel Dunbar67aba792010-04-15 03:47:33 +00001398 // Get the field pointer.
1399 llvm::Value *Ptr = Dst.getBitFieldBaseAddr();
John McCallad7c5c12011-02-08 08:22:06 +00001400 unsigned addressSpace =
1401 cast<llvm::PointerType>(Ptr->getType())->getAddressSpace();
Mike Stump4a3999f2009-09-09 13:00:44 +00001402
Daniel Dunbar67aba792010-04-15 03:47:33 +00001403 // Only offset by the field index if used, so that incoming values are not
1404 // required to be structures.
1405 if (AI.FieldIndex)
1406 Ptr = Builder.CreateStructGEP(Ptr, AI.FieldIndex, "bf.field");
Mike Stump4a3999f2009-09-09 13:00:44 +00001407
Daniel Dunbar67aba792010-04-15 03:47:33 +00001408 // Offset by the byte offset, if used.
Ken Dyckf76759c2011-04-24 10:04:59 +00001409 if (!AI.FieldByteOffset.isZero()) {
John McCallad7c5c12011-02-08 08:22:06 +00001410 Ptr = EmitCastToVoidPtr(Ptr);
Ken Dyckf76759c2011-04-24 10:04:59 +00001411 Ptr = Builder.CreateConstGEP1_32(Ptr, AI.FieldByteOffset.getQuantity(),
1412 "bf.field.offs");
Daniel Dunbar67aba792010-04-15 03:47:33 +00001413 }
Eli Friedmanf2442dc2008-05-17 20:03:47 +00001414
Daniel Dunbar67aba792010-04-15 03:47:33 +00001415 // Cast to the access type.
Chris Lattner2192fe52011-07-18 04:24:23 +00001416 llvm::Type *AccessLTy =
John McCallad7c5c12011-02-08 08:22:06 +00001417 llvm::Type::getIntNTy(getLLVMContext(), AI.AccessWidth);
1418
Chris Lattner2192fe52011-07-18 04:24:23 +00001419 llvm::Type *PTy = AccessLTy->getPointerTo(addressSpace);
Daniel Dunbar67aba792010-04-15 03:47:33 +00001420 Ptr = Builder.CreateBitCast(Ptr, PTy);
Mike Stump4a3999f2009-09-09 13:00:44 +00001421
Daniel Dunbar67aba792010-04-15 03:47:33 +00001422 // Extract the piece of the bit-field value to write in this access, limited
1423 // to the values that are part of this access.
1424 llvm::Value *Val = SrcVal;
1425 if (AI.TargetBitOffset)
1426 Val = Builder.CreateLShr(Val, AI.TargetBitOffset);
1427 Val = Builder.CreateAnd(Val, llvm::APInt::getLowBitsSet(ResSizeInBits,
1428 AI.TargetBitWidth));
Mike Stump4a3999f2009-09-09 13:00:44 +00001429
Daniel Dunbar67aba792010-04-15 03:47:33 +00001430 // Extend or truncate to the access size.
Daniel Dunbar67aba792010-04-15 03:47:33 +00001431 if (ResSizeInBits < AI.AccessWidth)
1432 Val = Builder.CreateZExt(Val, AccessLTy);
1433 else if (ResSizeInBits > AI.AccessWidth)
1434 Val = Builder.CreateTrunc(Val, AccessLTy);
Mike Stump4a3999f2009-09-09 13:00:44 +00001435
Daniel Dunbar67aba792010-04-15 03:47:33 +00001436 // Shift into the position in memory.
1437 if (AI.FieldBitStart)
1438 Val = Builder.CreateShl(Val, AI.FieldBitStart);
1439
1440 // If necessary, load and OR in bits that are outside of the bit-field.
1441 if (AI.TargetBitWidth != AI.AccessWidth) {
1442 llvm::LoadInst *Load = Builder.CreateLoad(Ptr, Dst.isVolatileQualified());
Eli Friedmanc24e2fb2012-06-27 21:19:48 +00001443 Load->setAlignment(AccessAlignment.getQuantity());
Daniel Dunbar67aba792010-04-15 03:47:33 +00001444
1445 // Compute the mask for zeroing the bits that are part of the bit-field.
1446 llvm::APInt InvMask =
1447 ~llvm::APInt::getBitsSet(AI.AccessWidth, AI.FieldBitStart,
1448 AI.FieldBitStart + AI.TargetBitWidth);
1449
1450 // Apply the mask and OR in to the value to write.
1451 Val = Builder.CreateOr(Builder.CreateAnd(Load, InvMask), Val);
1452 }
1453
1454 // Write the value.
1455 llvm::StoreInst *Store = Builder.CreateStore(Val, Ptr,
1456 Dst.isVolatileQualified());
Eli Friedmanc24e2fb2012-06-27 21:19:48 +00001457 Store->setAlignment(AccessAlignment.getQuantity());
Daniel Dunbaread7c912008-08-06 05:08:45 +00001458 }
Lauro Ramos Venancio09af71c2008-01-22 22:36:45 +00001459}
1460
Nate Begemance4d7fc2008-04-18 23:10:10 +00001461void CodeGenFunction::EmitStoreThroughExtVectorComponentLValue(RValue Src,
John McCall55e1fbc2011-06-25 02:11:03 +00001462 LValue Dst) {
Chris Lattner41d480e2007-08-03 16:28:33 +00001463 // This access turns into a read/modify/write of the vector. Load the input
1464 // value now.
Eli Friedman610bb872012-03-22 22:36:39 +00001465 llvm::LoadInst *Load = Builder.CreateLoad(Dst.getExtVectorAddr(),
1466 Dst.isVolatileQualified());
1467 Load->setAlignment(Dst.getAlignment().getQuantity());
1468 llvm::Value *Vec = Load;
Nate Begemanf322eab2008-05-09 06:41:27 +00001469 const llvm::Constant *Elts = Dst.getExtVectorElts();
Mike Stump4a3999f2009-09-09 13:00:44 +00001470
Chris Lattner4647a212007-08-31 22:49:20 +00001471 llvm::Value *SrcVal = Src.getScalarVal();
Mike Stump4a3999f2009-09-09 13:00:44 +00001472
John McCall55e1fbc2011-06-25 02:11:03 +00001473 if (const VectorType *VTy = Dst.getType()->getAs<VectorType>()) {
Chris Lattner3a44aa72007-08-03 16:37:04 +00001474 unsigned NumSrcElts = VTy->getNumElements();
Nate Begemanb699c9b2009-01-18 06:42:49 +00001475 unsigned NumDstElts =
1476 cast<llvm::VectorType>(Vec->getType())->getNumElements();
1477 if (NumDstElts == NumSrcElts) {
Mike Stump4a3999f2009-09-09 13:00:44 +00001478 // Use shuffle vector is the src and destination are the same number of
1479 // elements and restore the vector mask since it is on the side it will be
1480 // stored.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001481 SmallVector<llvm::Constant*, 4> Mask(NumDstElts);
Chris Lattner2d6b7b92012-01-25 05:34:41 +00001482 for (unsigned i = 0; i != NumSrcElts; ++i)
1483 Mask[getAccessedFieldNo(i, Elts)] = Builder.getInt32(i);
Mike Stump4a3999f2009-09-09 13:00:44 +00001484
Chris Lattner91c08ad2011-02-15 00:14:06 +00001485 llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
Nate Begemanb699c9b2009-01-18 06:42:49 +00001486 Vec = Builder.CreateShuffleVector(SrcVal,
Owen Anderson7ec07a52009-07-30 23:11:26 +00001487 llvm::UndefValue::get(Vec->getType()),
Benjamin Kramer76399eb2011-09-27 21:06:10 +00001488 MaskV);
Mike Stump658fe022009-07-30 22:28:39 +00001489 } else if (NumDstElts > NumSrcElts) {
Nate Begemanb699c9b2009-01-18 06:42:49 +00001490 // Extended the source vector to the same length and then shuffle it
1491 // into the destination.
1492 // FIXME: since we're shuffling with undef, can we just use the indices
1493 // into that? This could be simpler.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001494 SmallVector<llvm::Constant*, 4> ExtMask;
Benjamin Kramer8001f742012-02-14 12:06:21 +00001495 for (unsigned i = 0; i != NumSrcElts; ++i)
Chris Lattner2d6b7b92012-01-25 05:34:41 +00001496 ExtMask.push_back(Builder.getInt32(i));
Benjamin Kramer8001f742012-02-14 12:06:21 +00001497 ExtMask.resize(NumDstElts, llvm::UndefValue::get(Int32Ty));
Chris Lattner91c08ad2011-02-15 00:14:06 +00001498 llvm::Value *ExtMaskV = llvm::ConstantVector::get(ExtMask);
Mike Stump4a3999f2009-09-09 13:00:44 +00001499 llvm::Value *ExtSrcVal =
Daniel Dunbar3d926cb2009-02-17 18:31:04 +00001500 Builder.CreateShuffleVector(SrcVal,
Owen Anderson7ec07a52009-07-30 23:11:26 +00001501 llvm::UndefValue::get(SrcVal->getType()),
Benjamin Kramer76399eb2011-09-27 21:06:10 +00001502 ExtMaskV);
Nate Begemanb699c9b2009-01-18 06:42:49 +00001503 // build identity
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001504 SmallVector<llvm::Constant*, 4> Mask;
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001505 for (unsigned i = 0; i != NumDstElts; ++i)
Chris Lattner2d6b7b92012-01-25 05:34:41 +00001506 Mask.push_back(Builder.getInt32(i));
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001507
Nate Begemanb699c9b2009-01-18 06:42:49 +00001508 // modify when what gets shuffled in
Chris Lattner2d6b7b92012-01-25 05:34:41 +00001509 for (unsigned i = 0; i != NumSrcElts; ++i)
1510 Mask[getAccessedFieldNo(i, Elts)] = Builder.getInt32(i+NumDstElts);
Chris Lattner91c08ad2011-02-15 00:14:06 +00001511 llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
Benjamin Kramer76399eb2011-09-27 21:06:10 +00001512 Vec = Builder.CreateShuffleVector(Vec, ExtSrcVal, MaskV);
Mike Stump658fe022009-07-30 22:28:39 +00001513 } else {
Nate Begemanb699c9b2009-01-18 06:42:49 +00001514 // We should never shorten the vector
David Blaikie83d382b2011-09-23 05:06:16 +00001515 llvm_unreachable("unexpected shorten vector length");
Chris Lattner3a44aa72007-08-03 16:37:04 +00001516 }
1517 } else {
1518 // If the Src is a scalar (not a vector) it must be updating one element.
Dan Gohman75d69da2008-05-22 00:50:06 +00001519 unsigned InIdx = getAccessedFieldNo(0, Elts);
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001520 llvm::Value *Elt = llvm::ConstantInt::get(Int32Ty, InIdx);
Benjamin Kramer76399eb2011-09-27 21:06:10 +00001521 Vec = Builder.CreateInsertElement(Vec, SrcVal, Elt);
Chris Lattner41d480e2007-08-03 16:28:33 +00001522 }
Mike Stump4a3999f2009-09-09 13:00:44 +00001523
Eli Friedman610bb872012-03-22 22:36:39 +00001524 llvm::StoreInst *Store = Builder.CreateStore(Vec, Dst.getExtVectorAddr(),
1525 Dst.isVolatileQualified());
1526 Store->setAlignment(Dst.getAlignment().getQuantity());
Chris Lattner41d480e2007-08-03 16:28:33 +00001527}
1528
Fariborz Jahaniana7fa6be2009-09-16 21:37:16 +00001529// setObjCGCLValueClass - sets class of he lvalue for the purpose of
1530// generating write-barries API. It is currently a global, ivar,
1531// or neither.
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001532static void setObjCGCLValueClass(const ASTContext &Ctx, const Expr *E,
Fariborz Jahanian0c784272011-09-30 18:23:36 +00001533 LValue &LV,
1534 bool IsMemberAccess=false) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00001535 if (Ctx.getLangOpts().getGC() == LangOptions::NonGC)
Fariborz Jahaniana7fa6be2009-09-16 21:37:16 +00001536 return;
1537
Fariborz Jahaniande1d3242009-09-16 23:11:23 +00001538 if (isa<ObjCIvarRefExpr>(E)) {
Fariborz Jahanian0c784272011-09-30 18:23:36 +00001539 QualType ExpTy = E->getType();
1540 if (IsMemberAccess && ExpTy->isPointerType()) {
1541 // If ivar is a structure pointer, assigning to field of
1542 // this struct follows gcc's behavior and makes it a non-ivar
1543 // writer-barrier conservatively.
1544 ExpTy = ExpTy->getAs<PointerType>()->getPointeeType();
1545 if (ExpTy->isRecordType()) {
1546 LV.setObjCIvar(false);
1547 return;
1548 }
1549 }
Daniel Dunbar4bb04ce2010-08-21 03:51:29 +00001550 LV.setObjCIvar(true);
Fariborz Jahanian7a95d722009-09-24 22:25:38 +00001551 ObjCIvarRefExpr *Exp = cast<ObjCIvarRefExpr>(const_cast<Expr*>(E));
1552 LV.setBaseIvarExp(Exp->getBase());
Daniel Dunbar4bb04ce2010-08-21 03:51:29 +00001553 LV.setObjCArray(E->getType()->isArrayType());
Fariborz Jahaniande1d3242009-09-16 23:11:23 +00001554 return;
1555 }
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001556
Fariborz Jahaniana7fa6be2009-09-16 21:37:16 +00001557 if (const DeclRefExpr *Exp = dyn_cast<DeclRefExpr>(E)) {
1558 if (const VarDecl *VD = dyn_cast<VarDecl>(Exp->getDecl())) {
John McCall1c9c3fd2010-10-15 04:57:14 +00001559 if (VD->hasGlobalStorage()) {
Daniel Dunbar4bb04ce2010-08-21 03:51:29 +00001560 LV.setGlobalObjCRef(true);
1561 LV.setThreadLocalRef(VD->isThreadSpecified());
Fariborz Jahanian217af242010-07-20 20:30:03 +00001562 }
Fariborz Jahaniana7fa6be2009-09-16 21:37:16 +00001563 }
Daniel Dunbar4bb04ce2010-08-21 03:51:29 +00001564 LV.setObjCArray(E->getType()->isArrayType());
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001565 return;
Fariborz Jahaniana7fa6be2009-09-16 21:37:16 +00001566 }
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001567
1568 if (const UnaryOperator *Exp = dyn_cast<UnaryOperator>(E)) {
Fariborz Jahanian0c784272011-09-30 18:23:36 +00001569 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess);
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001570 return;
1571 }
1572
1573 if (const ParenExpr *Exp = dyn_cast<ParenExpr>(E)) {
Fariborz Jahanian0c784272011-09-30 18:23:36 +00001574 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess);
Fariborz Jahaniane01e4342009-09-30 17:10:29 +00001575 if (LV.isObjCIvar()) {
1576 // If cast is to a structure pointer, follow gcc's behavior and make it
1577 // a non-ivar write-barrier.
1578 QualType ExpTy = E->getType();
1579 if (ExpTy->isPointerType())
1580 ExpTy = ExpTy->getAs<PointerType>()->getPointeeType();
1581 if (ExpTy->isRecordType())
Daniel Dunbar4bb04ce2010-08-21 03:51:29 +00001582 LV.setObjCIvar(false);
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001583 }
1584 return;
Fariborz Jahaniane01e4342009-09-30 17:10:29 +00001585 }
Peter Collingbourne91147592011-04-15 00:35:48 +00001586
1587 if (const GenericSelectionExpr *Exp = dyn_cast<GenericSelectionExpr>(E)) {
1588 setObjCGCLValueClass(Ctx, Exp->getResultExpr(), LV);
1589 return;
1590 }
1591
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001592 if (const ImplicitCastExpr *Exp = dyn_cast<ImplicitCastExpr>(E)) {
Fariborz Jahanian0c784272011-09-30 18:23:36 +00001593 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess);
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001594 return;
1595 }
1596
1597 if (const CStyleCastExpr *Exp = dyn_cast<CStyleCastExpr>(E)) {
Fariborz Jahanian0c784272011-09-30 18:23:36 +00001598 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess);
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001599 return;
1600 }
John McCall31168b02011-06-15 23:02:42 +00001601
1602 if (const ObjCBridgedCastExpr *Exp = dyn_cast<ObjCBridgedCastExpr>(E)) {
Fariborz Jahanian0c784272011-09-30 18:23:36 +00001603 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess);
John McCall31168b02011-06-15 23:02:42 +00001604 return;
1605 }
1606
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001607 if (const ArraySubscriptExpr *Exp = dyn_cast<ArraySubscriptExpr>(E)) {
Fariborz Jahaniana7fa6be2009-09-16 21:37:16 +00001608 setObjCGCLValueClass(Ctx, Exp->getBase(), LV);
Fariborz Jahanian38c3ae92009-09-21 18:54:29 +00001609 if (LV.isObjCIvar() && !LV.isObjCArray())
Fariborz Jahanian2e32ddc2009-09-18 00:04:00 +00001610 // Using array syntax to assigning to what an ivar points to is not
1611 // same as assigning to the ivar itself. {id *Names;} Names[i] = 0;
Daniel Dunbar4bb04ce2010-08-21 03:51:29 +00001612 LV.setObjCIvar(false);
Fariborz Jahanian38c3ae92009-09-21 18:54:29 +00001613 else if (LV.isGlobalObjCRef() && !LV.isObjCArray())
1614 // Using array syntax to assigning to what global points to is not
1615 // same as assigning to the global itself. {id *G;} G[i] = 0;
Daniel Dunbar4bb04ce2010-08-21 03:51:29 +00001616 LV.setGlobalObjCRef(false);
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001617 return;
Fariborz Jahanian2e32ddc2009-09-18 00:04:00 +00001618 }
Fariborz Jahanian0c784272011-09-30 18:23:36 +00001619
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001620 if (const MemberExpr *Exp = dyn_cast<MemberExpr>(E)) {
Fariborz Jahanian0c784272011-09-30 18:23:36 +00001621 setObjCGCLValueClass(Ctx, Exp->getBase(), LV, true);
Fariborz Jahanian2e32ddc2009-09-18 00:04:00 +00001622 // We don't know if member is an 'ivar', but this flag is looked at
1623 // only in the context of LV.isObjCIvar().
Daniel Dunbar4bb04ce2010-08-21 03:51:29 +00001624 LV.setObjCArray(E->getType()->isArrayType());
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001625 return;
Fariborz Jahaniana7fa6be2009-09-16 21:37:16 +00001626 }
1627}
1628
Chris Lattner3f32d692011-07-12 06:52:18 +00001629static llvm::Value *
Chandler Carruth4678f672011-07-12 08:58:26 +00001630EmitBitCastOfLValueToProperType(CodeGenFunction &CGF,
Chris Lattner3f32d692011-07-12 06:52:18 +00001631 llvm::Value *V, llvm::Type *IRType,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001632 StringRef Name = StringRef()) {
Chris Lattner3f32d692011-07-12 06:52:18 +00001633 unsigned AS = cast<llvm::PointerType>(V->getType())->getAddressSpace();
Chandler Carruth4678f672011-07-12 08:58:26 +00001634 return CGF.Builder.CreateBitCast(V, IRType->getPointerTo(AS), Name);
Chris Lattner3f32d692011-07-12 06:52:18 +00001635}
1636
Anders Carlssonea4c30b2009-11-07 23:06:58 +00001637static LValue EmitGlobalVarDeclLValue(CodeGenFunction &CGF,
1638 const Expr *E, const VarDecl *VD) {
Daniel Dunbar7e215ea2009-11-08 09:46:46 +00001639 assert((VD->hasExternalStorage() || VD->isFileVarDecl()) &&
Anders Carlssonea4c30b2009-11-07 23:06:58 +00001640 "Var decl must have external storage or be a file var decl!");
1641
1642 llvm::Value *V = CGF.CGM.GetAddrOfGlobalVar(VD);
Eli Friedmand20adbd2011-11-16 00:42:57 +00001643 llvm::Type *RealVarTy = CGF.getTypes().ConvertTypeForMem(VD->getType());
1644 V = EmitBitCastOfLValueToProperType(CGF, V, RealVarTy);
Eli Friedmana0544d62011-12-03 04:14:32 +00001645 CharUnits Alignment = CGF.getContext().getDeclAlign(VD);
Eli Friedmand20adbd2011-11-16 00:42:57 +00001646 QualType T = E->getType();
1647 LValue LV;
1648 if (VD->getType()->isReferenceType()) {
1649 llvm::LoadInst *LI = CGF.Builder.CreateLoad(V);
Eli Friedmana0544d62011-12-03 04:14:32 +00001650 LI->setAlignment(Alignment.getQuantity());
Eli Friedmand20adbd2011-11-16 00:42:57 +00001651 V = LI;
1652 LV = CGF.MakeNaturalAlignAddrLValue(V, T);
1653 } else {
1654 LV = CGF.MakeAddrLValue(V, E->getType(), Alignment);
1655 }
Anders Carlssonea4c30b2009-11-07 23:06:58 +00001656 setObjCGCLValueClass(CGF.getContext(), E, LV);
1657 return LV;
1658}
1659
Eli Friedmand15eb34d2009-11-26 06:08:14 +00001660static LValue EmitFunctionDeclLValue(CodeGenFunction &CGF,
Chris Lattner13ee4f42011-07-10 05:34:54 +00001661 const Expr *E, const FunctionDecl *FD) {
Chris Lattnerf53c0962010-09-06 00:11:41 +00001662 llvm::Value *V = CGF.CGM.GetAddrOfFunction(FD);
Eli Friedmand15eb34d2009-11-26 06:08:14 +00001663 if (!FD->hasPrototype()) {
1664 if (const FunctionProtoType *Proto =
1665 FD->getType()->getAs<FunctionProtoType>()) {
1666 // Ugly case: for a K&R-style definition, the type of the definition
1667 // isn't the same as the type of a use. Correct for this with a
1668 // bitcast.
1669 QualType NoProtoType =
1670 CGF.getContext().getFunctionNoProtoType(Proto->getResultType());
1671 NoProtoType = CGF.getContext().getPointerType(NoProtoType);
Benjamin Kramer76399eb2011-09-27 21:06:10 +00001672 V = CGF.Builder.CreateBitCast(V, CGF.ConvertType(NoProtoType));
Eli Friedmand15eb34d2009-11-26 06:08:14 +00001673 }
1674 }
Eli Friedmana0544d62011-12-03 04:14:32 +00001675 CharUnits Alignment = CGF.getContext().getDeclAlign(FD);
Daniel Dunbar5c816372010-08-21 04:20:22 +00001676 return CGF.MakeAddrLValue(V, E->getType(), Alignment);
Eli Friedmand15eb34d2009-11-26 06:08:14 +00001677}
1678
Chris Lattnerd7f58862007-06-02 05:24:33 +00001679LValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) {
Anders Carlsson2ff6395d2009-11-07 22:53:10 +00001680 const NamedDecl *ND = E->getDecl();
Eli Friedmana0544d62011-12-03 04:14:32 +00001681 CharUnits Alignment = getContext().getDeclAlign(ND);
Eli Friedmand20adbd2011-11-16 00:42:57 +00001682 QualType T = E->getType();
Mike Stump4a3999f2009-09-09 13:00:44 +00001683
Eli Friedman5720e342012-01-21 04:52:58 +00001684 // FIXME: We should be able to assert this for FunctionDecls as well!
1685 // FIXME: We should be able to assert this for all DeclRefExprs, not just
1686 // those with a valid source location.
1687 assert((ND->isUsed(false) || !isa<VarDecl>(ND) ||
1688 !E->getLocation().isValid()) &&
1689 "Should not use decl without marking it used!");
1690
Rafael Espindola2e42fec2010-03-04 18:17:24 +00001691 if (ND->hasAttr<WeakRefAttr>()) {
Chris Lattnerf53c0962010-09-06 00:11:41 +00001692 const ValueDecl *VD = cast<ValueDecl>(ND);
Rafael Espindola2e42fec2010-03-04 18:17:24 +00001693 llvm::Constant *Aliasee = CGM.GetWeakRefReference(VD);
Daniel Dunbar5c816372010-08-21 04:20:22 +00001694 return MakeAddrLValue(Aliasee, E->getType(), Alignment);
Rafael Espindola2e42fec2010-03-04 18:17:24 +00001695 }
1696
Anders Carlsson2ff6395d2009-11-07 22:53:10 +00001697 if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) {
Anders Carlsson2ff6395d2009-11-07 22:53:10 +00001698 // Check if this is a global variable.
Anders Carlssonea4c30b2009-11-07 23:06:58 +00001699 if (VD->hasExternalStorage() || VD->isFileVarDecl())
1700 return EmitGlobalVarDeclLValue(*this, E, VD);
Anders Carlsson6eee9722009-11-07 22:46:42 +00001701
John McCall113bee02012-03-10 09:33:50 +00001702 bool isBlockVariable = VD->hasAttr<BlocksAttr>();
1703
Fariborz Jahanian44a41d12010-11-19 18:17:09 +00001704 bool NonGCable = VD->hasLocalStorage() &&
1705 !VD->getType()->isReferenceType() &&
John McCall113bee02012-03-10 09:33:50 +00001706 !isBlockVariable;
Anders Carlsson6eee9722009-11-07 22:46:42 +00001707
1708 llvm::Value *V = LocalDeclMap[VD];
Fariborz Jahanian366a9482010-09-07 23:26:17 +00001709 if (!V && VD->isStaticLocal())
Fariborz Jahanian4d55b2d2010-04-19 18:15:02 +00001710 V = CGM.getStaticLocalDeclAddress(VD);
Eli Friedman9fbeba02012-02-11 02:57:39 +00001711
1712 // Use special handling for lambdas.
John McCall113bee02012-03-10 09:33:50 +00001713 if (!V) {
Eli Friedman7f1ff602012-04-16 03:54:45 +00001714 if (FieldDecl *FD = LambdaCaptureFields.lookup(VD)) {
1715 QualType LambdaTagType = getContext().getTagDeclType(FD->getParent());
1716 LValue LambdaLV = MakeNaturalAlignAddrLValue(CXXABIThisValue,
1717 LambdaTagType);
1718 return EmitLValueForField(LambdaLV, FD);
1719 }
Eli Friedman9fbeba02012-02-11 02:57:39 +00001720
John McCall113bee02012-03-10 09:33:50 +00001721 assert(isa<BlockDecl>(CurCodeDecl) && E->refersToEnclosingLocal());
1722 CharUnits alignment = getContext().getDeclAlign(VD);
1723 return MakeAddrLValue(GetAddrOfBlockDecl(VD, isBlockVariable),
1724 E->getType(), alignment);
1725 }
1726
Anders Carlsson6eee9722009-11-07 22:46:42 +00001727 assert(V && "DeclRefExpr not entered in LocalDeclMap?");
1728
John McCall113bee02012-03-10 09:33:50 +00001729 if (isBlockVariable)
Fariborz Jahanian2f2fa722011-01-26 23:08:27 +00001730 V = BuildBlockByrefAddress(V, VD);
Daniel Dunbarf166a522010-08-21 03:44:13 +00001731
Eli Friedmand20adbd2011-11-16 00:42:57 +00001732 LValue LV;
1733 if (VD->getType()->isReferenceType()) {
1734 llvm::LoadInst *LI = Builder.CreateLoad(V);
Eli Friedmana0544d62011-12-03 04:14:32 +00001735 LI->setAlignment(Alignment.getQuantity());
Eli Friedmand20adbd2011-11-16 00:42:57 +00001736 V = LI;
1737 LV = MakeNaturalAlignAddrLValue(V, T);
1738 } else {
1739 LV = MakeAddrLValue(V, T, Alignment);
1740 }
Chris Lattner3f32d692011-07-12 06:52:18 +00001741
Fariborz Jahanian44a41d12010-11-19 18:17:09 +00001742 if (NonGCable) {
Daniel Dunbarf166a522010-08-21 03:44:13 +00001743 LV.getQuals().removeObjCGCAttr();
Daniel Dunbare50dda92010-08-21 03:22:38 +00001744 LV.setNonGC(true);
1745 }
Fariborz Jahaniana7fa6be2009-09-16 21:37:16 +00001746 setObjCGCLValueClass(getContext(), E, LV);
Fariborz Jahanian003e8302008-11-20 00:15:42 +00001747 return LV;
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001748 }
John McCallf3a88602011-02-03 08:15:49 +00001749
1750 if (const FunctionDecl *fn = dyn_cast<FunctionDecl>(ND))
1751 return EmitFunctionDeclLValue(*this, E, fn);
1752
David Blaikie83d382b2011-09-23 05:06:16 +00001753 llvm_unreachable("Unhandled DeclRefExpr");
Chris Lattnerd7f58862007-06-02 05:24:33 +00001754}
Chris Lattnere47e4402007-06-01 18:02:12 +00001755
Chris Lattner8394d792007-06-05 20:53:16 +00001756LValue CodeGenFunction::EmitUnaryOpLValue(const UnaryOperator *E) {
1757 // __extension__ doesn't affect lvalue-ness.
John McCalle3027922010-08-25 11:45:40 +00001758 if (E->getOpcode() == UO_Extension)
Chris Lattner8394d792007-06-05 20:53:16 +00001759 return EmitLValue(E->getSubExpr());
Mike Stump4a3999f2009-09-09 13:00:44 +00001760
Chris Lattner0f398c42008-07-26 22:37:01 +00001761 QualType ExprTy = getContext().getCanonicalType(E->getSubExpr()->getType());
Chris Lattner595db862007-10-30 22:53:42 +00001762 switch (E->getOpcode()) {
David Blaikie83d382b2011-09-23 05:06:16 +00001763 default: llvm_unreachable("Unknown unary operator lvalue!");
John McCalle3027922010-08-25 11:45:40 +00001764 case UO_Deref: {
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001765 QualType T = E->getSubExpr()->getType()->getPointeeType();
1766 assert(!T.isNull() && "CodeGenFunction::EmitUnaryOpLValue: Illegal type");
Mike Stump4a3999f2009-09-09 13:00:44 +00001767
Chris Lattner2415357a2011-12-19 21:16:08 +00001768 LValue LV = MakeNaturalAlignAddrLValue(EmitScalarExpr(E->getSubExpr()), T);
Daniel Dunbarf166a522010-08-21 03:44:13 +00001769 LV.getQuals().setAddressSpace(ExprTy.getAddressSpace());
John McCall8ccfcb52009-09-24 19:53:00 +00001770
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001771 // We should not generate __weak write barrier on indirect reference
1772 // of a pointer to object; as in void foo (__weak id *param); *param = 0;
1773 // But, we continue to generate __strong write barrier on indirect write
1774 // into a pointer to object.
David Blaikiebbafb8a2012-03-11 07:00:24 +00001775 if (getContext().getLangOpts().ObjC1 &&
1776 getContext().getLangOpts().getGC() != LangOptions::NonGC &&
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001777 LV.isObjCWeak())
Daniel Dunbare50dda92010-08-21 03:22:38 +00001778 LV.setNonGC(!E->isOBJCGCCandidate(getContext()));
Chris Lattnerab5e0af2009-10-28 17:39:19 +00001779 return LV;
1780 }
John McCalle3027922010-08-25 11:45:40 +00001781 case UO_Real:
1782 case UO_Imag: {
Chris Lattner595db862007-10-30 22:53:42 +00001783 LValue LV = EmitLValue(E->getSubExpr());
John McCalla2342eb2010-12-05 02:00:02 +00001784 assert(LV.isSimple() && "real/imag on non-ordinary l-value");
1785 llvm::Value *Addr = LV.getAddress();
1786
Richard Smith0b6b8e42012-02-18 20:53:32 +00001787 // __real is valid on scalars. This is a faster way of testing that.
1788 // __imag can only produce an rvalue on scalars.
1789 if (E->getOpcode() == UO_Real &&
1790 !cast<llvm::PointerType>(Addr->getType())
John McCalla2342eb2010-12-05 02:00:02 +00001791 ->getElementType()->isStructTy()) {
1792 assert(E->getSubExpr()->getType()->isArithmeticType());
1793 return LV;
1794 }
1795
1796 assert(E->getSubExpr()->getType()->isAnyComplexType());
1797
John McCalle3027922010-08-25 11:45:40 +00001798 unsigned Idx = E->getOpcode() == UO_Imag;
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00001799 return MakeAddrLValue(Builder.CreateStructGEP(LV.getAddress(),
John McCalla2342eb2010-12-05 02:00:02 +00001800 Idx, "idx"),
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00001801 ExprTy);
Chris Lattner595db862007-10-30 22:53:42 +00001802 }
John McCalle3027922010-08-25 11:45:40 +00001803 case UO_PreInc:
1804 case UO_PreDec: {
Chris Lattnerbb8976e2010-01-09 21:44:40 +00001805 LValue LV = EmitLValue(E->getSubExpr());
John McCalle3027922010-08-25 11:45:40 +00001806 bool isInc = E->getOpcode() == UO_PreInc;
Chris Lattnerbb8976e2010-01-09 21:44:40 +00001807
1808 if (E->getType()->isAnyComplexType())
1809 EmitComplexPrePostIncDec(E, LV, isInc, true/*isPre*/);
1810 else
1811 EmitScalarPrePostIncDec(E, LV, isInc, true/*isPre*/);
1812 return LV;
1813 }
Eli Friedmana72bf0f2009-11-09 04:20:47 +00001814 }
Chris Lattner8394d792007-06-05 20:53:16 +00001815}
1816
Chris Lattner4347e3692007-06-06 04:54:52 +00001817LValue CodeGenFunction::EmitStringLiteralLValue(const StringLiteral *E) {
Daniel Dunbar2e442a02010-08-21 03:15:20 +00001818 return MakeAddrLValue(CGM.GetAddrOfConstantStringFromLiteral(E),
1819 E->getType());
Chris Lattner4347e3692007-06-06 04:54:52 +00001820}
1821
Chris Lattnerd7e7b8e2009-02-24 22:18:39 +00001822LValue CodeGenFunction::EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E) {
Daniel Dunbar2e442a02010-08-21 03:15:20 +00001823 return MakeAddrLValue(CGM.GetAddrOfConstantStringFromObjCEncode(E),
1824 E->getType());
Chris Lattnerd7e7b8e2009-02-24 22:18:39 +00001825}
1826
Nico Weber3a691a32012-06-23 02:07:59 +00001827static llvm::Constant*
1828GetAddrOfConstantWideString(StringRef Str,
1829 const char *GlobalName,
1830 ASTContext &Context,
1831 QualType Ty, SourceLocation Loc,
1832 CodeGenModule &CGM) {
1833
1834 StringLiteral *SL = StringLiteral::Create(Context,
1835 Str,
1836 StringLiteral::Wide,
1837 /*Pascal = */false,
1838 Ty, Loc);
1839 llvm::Constant *C = CGM.GetConstantArrayFromStringLiteral(SL);
1840 llvm::GlobalVariable *GV =
1841 new llvm::GlobalVariable(CGM.getModule(), C->getType(),
1842 !CGM.getLangOpts().WritableStrings,
1843 llvm::GlobalValue::PrivateLinkage,
1844 C, GlobalName);
1845 const unsigned WideAlignment =
1846 Context.getTypeAlignInChars(Ty).getQuantity();
1847 GV->setAlignment(WideAlignment);
1848 return GV;
1849}
1850
Nico Weber3a691a32012-06-23 02:07:59 +00001851static void ConvertUTF8ToWideString(unsigned CharByteWidth, StringRef Source,
1852 SmallString<32>& Target) {
1853 Target.resize(CharByteWidth * (Source.size() + 1));
Richard Smith639b8d02012-09-08 07:16:20 +00001854 char *ResultPtr = &Target[0];
1855 const UTF8 *ErrorPtr;
1856 bool success = ConvertUTF8toWide(CharByteWidth, Source, ResultPtr, ErrorPtr);
Matt Beaumont-Gay36af16af2012-07-03 03:55:58 +00001857 (void)success;
Nico Weber4b18c3f2012-07-03 02:24:52 +00001858 assert(success);
Nico Weber3a691a32012-06-23 02:07:59 +00001859 Target.resize(ResultPtr - &Target[0]);
1860}
Chris Lattnerd7e7b8e2009-02-24 22:18:39 +00001861
Mike Stump4a3999f2009-09-09 13:00:44 +00001862LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) {
Daniel Dunbarb3517472008-10-17 21:58:32 +00001863 switch (E->getIdentType()) {
1864 default:
1865 return EmitUnsupportedLValue(E, "predefined expression");
Daniel Dunbarb1d94a92010-08-21 03:01:12 +00001866
Daniel Dunbarb3517472008-10-17 21:58:32 +00001867 case PredefinedExpr::Func:
1868 case PredefinedExpr::Function:
Nico Weber3a691a32012-06-23 02:07:59 +00001869 case PredefinedExpr::LFunction:
Daniel Dunbarb1d94a92010-08-21 03:01:12 +00001870 case PredefinedExpr::PrettyFunction: {
Nico Weber3a691a32012-06-23 02:07:59 +00001871 unsigned IdentType = E->getIdentType();
Daniel Dunbarb1d94a92010-08-21 03:01:12 +00001872 std::string GlobalVarName;
1873
Nico Weber3a691a32012-06-23 02:07:59 +00001874 switch (IdentType) {
David Blaikie83d382b2011-09-23 05:06:16 +00001875 default: llvm_unreachable("Invalid type");
Daniel Dunbarb1d94a92010-08-21 03:01:12 +00001876 case PredefinedExpr::Func:
1877 GlobalVarName = "__func__.";
1878 break;
1879 case PredefinedExpr::Function:
1880 GlobalVarName = "__FUNCTION__.";
1881 break;
Nico Weber3a691a32012-06-23 02:07:59 +00001882 case PredefinedExpr::LFunction:
1883 GlobalVarName = "L__FUNCTION__.";
1884 break;
Daniel Dunbarb1d94a92010-08-21 03:01:12 +00001885 case PredefinedExpr::PrettyFunction:
1886 GlobalVarName = "__PRETTY_FUNCTION__.";
1887 break;
1888 }
1889
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001890 StringRef FnName = CurFn->getName();
Daniel Dunbarb1d94a92010-08-21 03:01:12 +00001891 if (FnName.startswith("\01"))
1892 FnName = FnName.substr(1);
1893 GlobalVarName += FnName;
1894
1895 const Decl *CurDecl = CurCodeDecl;
1896 if (CurDecl == 0)
1897 CurDecl = getContext().getTranslationUnitDecl();
1898
1899 std::string FunctionName =
John McCall351762c2011-02-07 10:33:21 +00001900 (isa<BlockDecl>(CurDecl)
1901 ? FnName.str()
Nico Weber3a691a32012-06-23 02:07:59 +00001902 : PredefinedExpr::ComputeName((PredefinedExpr::IdentType)IdentType,
1903 CurDecl));
Daniel Dunbarb1d94a92010-08-21 03:01:12 +00001904
Nico Weber3a691a32012-06-23 02:07:59 +00001905 const Type* ElemType = E->getType()->getArrayElementTypeNoTypeQual();
1906 llvm::Constant *C;
1907 if (ElemType->isWideCharType()) {
1908 SmallString<32> RawChars;
1909 ConvertUTF8ToWideString(
1910 getContext().getTypeSizeInChars(ElemType).getQuantity(),
1911 FunctionName, RawChars);
1912 C = GetAddrOfConstantWideString(RawChars,
1913 GlobalVarName.c_str(),
1914 getContext(),
1915 E->getType(),
1916 E->getLocation(),
1917 CGM);
1918 } else {
1919 C = CGM.GetAddrOfConstantCString(FunctionName,
1920 GlobalVarName.c_str(),
1921 1);
1922 }
Daniel Dunbar2e442a02010-08-21 03:15:20 +00001923 return MakeAddrLValue(C, E->getType());
Daniel Dunbarb1d94a92010-08-21 03:01:12 +00001924 }
Daniel Dunbarb3517472008-10-17 21:58:32 +00001925 }
Anders Carlsson625bfc82007-07-21 05:21:51 +00001926}
1927
Richard Smith4d1458e2012-09-08 02:08:36 +00001928void CodeGenFunction::EmitCheck(llvm::Value *Checked) {
Mike Stump9a4e0122009-12-15 00:59:40 +00001929 const CodeGenOptions &GCO = CGM.getCodeGenOpts();
1930
Richard Smith4d1458e2012-09-08 02:08:36 +00001931 llvm::BasicBlock *Cont = createBasicBlock("cont");
1932
Mike Stump9a4e0122009-12-15 00:59:40 +00001933 // If we are not optimzing, don't collapse all calls to trap in the function
1934 // to the same call, that way, in the debugger they can see which operation
Chris Lattner26008e02010-07-20 20:19:24 +00001935 // did in fact fail. If we are optimizing, we collapse all calls to trap down
Mike Stump9a4e0122009-12-15 00:59:40 +00001936 // to just one per function to save on codesize.
Richard Smith4d1458e2012-09-08 02:08:36 +00001937 bool NeedNewTrapBB = !GCO.OptimizationLevel || !TrapBB;
Mike Stumpd9546382009-12-12 01:27:46 +00001938
Richard Smith4d1458e2012-09-08 02:08:36 +00001939 if (NeedNewTrapBB)
1940 TrapBB = createBasicBlock("trap");
1941
1942 Builder.CreateCondBr(Checked, Cont, TrapBB);
1943
1944 if (NeedNewTrapBB) {
1945 EmitBlock(TrapBB);
1946
1947 llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::trap);
1948 llvm::CallInst *TrapCall = Builder.CreateCall(F);
1949 TrapCall->setDoesNotReturn();
1950 TrapCall->setDoesNotThrow();
1951 Builder.CreateUnreachable();
Mike Stumpd9546382009-12-12 01:27:46 +00001952 }
Mike Stumpe8c3b3e2009-12-15 00:35:12 +00001953
Richard Smith4d1458e2012-09-08 02:08:36 +00001954 EmitBlock(Cont);
Mike Stumpd9546382009-12-12 01:27:46 +00001955}
1956
Chris Lattner6c5abe82010-06-26 23:03:20 +00001957/// isSimpleArrayDecayOperand - If the specified expr is a simple decay from an
1958/// array to pointer, return the array subexpression.
1959static const Expr *isSimpleArrayDecayOperand(const Expr *E) {
1960 // If this isn't just an array->pointer decay, bail out.
1961 const CastExpr *CE = dyn_cast<CastExpr>(E);
John McCalle3027922010-08-25 11:45:40 +00001962 if (CE == 0 || CE->getCastKind() != CK_ArrayToPointerDecay)
Chris Lattner6c5abe82010-06-26 23:03:20 +00001963 return 0;
1964
1965 // If this is a decay from variable width array, bail out.
1966 const Expr *SubExpr = CE->getSubExpr();
1967 if (SubExpr->getType()->isVariableArrayType())
1968 return 0;
1969
1970 return SubExpr;
1971}
1972
Chris Lattnerd9d2fb12007-06-08 23:31:14 +00001973LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) {
Ted Kremenekc81614d2007-08-20 16:18:38 +00001974 // The index must always be an integer, which is not an aggregate. Emit it.
Chris Lattner2da04b32007-08-24 05:35:26 +00001975 llvm::Value *Idx = EmitScalarExpr(E->getIdx());
Eli Friedman07bbeca2009-06-06 19:09:26 +00001976 QualType IdxTy = E->getIdx()->getType();
Douglas Gregor6ab2fa82011-05-20 16:38:50 +00001977 bool IdxSigned = IdxTy->isSignedIntegerOrEnumerationType();
Eli Friedman07bbeca2009-06-06 19:09:26 +00001978
Chris Lattner08c4b9f2007-07-10 21:17:59 +00001979 // If the base is a vector type, then we are forming a vector element lvalue
1980 // with this subscript.
Eli Friedman327944b2008-06-13 23:01:12 +00001981 if (E->getBase()->getType()->isVectorType()) {
Chris Lattner08c4b9f2007-07-10 21:17:59 +00001982 // Emit the vector as an lvalue to get its address.
Eli Friedman327944b2008-06-13 23:01:12 +00001983 LValue LHS = EmitLValue(E->getBase());
Ted Kremenekc81614d2007-08-20 16:18:38 +00001984 assert(LHS.isSimple() && "Can only subscript lvalue vectors here!");
John McCallad7c5c12011-02-08 08:22:06 +00001985 Idx = Builder.CreateIntCast(Idx, Int32Ty, IdxSigned, "vidx");
Eli Friedman327944b2008-06-13 23:01:12 +00001986 return LValue::MakeVectorElt(LHS.getAddress(), Idx,
Eli Friedman610bb872012-03-22 22:36:39 +00001987 E->getBase()->getType(), LHS.getAlignment());
Chris Lattner08c4b9f2007-07-10 21:17:59 +00001988 }
Mike Stump4a3999f2009-09-09 13:00:44 +00001989
Ted Kremenekc81614d2007-08-20 16:18:38 +00001990 // Extend or truncate the index type to 32 or 64-bits.
John McCalle3dc1702011-02-15 09:22:45 +00001991 if (Idx->getType() != IntPtrTy)
1992 Idx = Builder.CreateIntCast(Idx, IntPtrTy, IdxSigned, "idxprom");
Mike Stumpd9546382009-12-12 01:27:46 +00001993
Mike Stump4a3999f2009-09-09 13:00:44 +00001994 // We know that the pointer points to a type of the correct size, unless the
1995 // size is a VLA or Objective-C interface.
Daniel Dunbaref2ffbc2009-04-25 05:08:32 +00001996 llvm::Value *Address = 0;
Eli Friedmana0544d62011-12-03 04:14:32 +00001997 CharUnits ArrayAlignment;
John McCall23c29fe2011-06-24 21:55:10 +00001998 if (const VariableArrayType *vla =
Anders Carlsson3d312f82008-12-21 00:11:23 +00001999 getContext().getAsVariableArrayType(E->getType())) {
John McCall23c29fe2011-06-24 21:55:10 +00002000 // The base must be a pointer, which is not an aggregate. Emit
2001 // it. It needs to be emitted first in case it's what captures
2002 // the VLA bounds.
2003 Address = EmitScalarExpr(E->getBase());
Mike Stump4a3999f2009-09-09 13:00:44 +00002004
John McCall23c29fe2011-06-24 21:55:10 +00002005 // The element count here is the total number of non-VLA elements.
2006 llvm::Value *numElements = getVLASize(vla).first;
Mike Stump4a3999f2009-09-09 13:00:44 +00002007
John McCall77527a82011-06-25 01:32:37 +00002008 // Effectively, the multiply by the VLA size is part of the GEP.
2009 // GEP indexes are signed, and scaling an index isn't permitted to
2010 // signed-overflow, so we use the same semantics for our explicit
2011 // multiply. We suppress this if overflow is not undefined behavior.
David Blaikiebbafb8a2012-03-11 07:00:24 +00002012 if (getLangOpts().isSignedOverflowDefined()) {
John McCall77527a82011-06-25 01:32:37 +00002013 Idx = Builder.CreateMul(Idx, numElements);
Chris Lattner2e72da942011-03-01 00:03:48 +00002014 Address = Builder.CreateGEP(Address, Idx, "arrayidx");
John McCall77527a82011-06-25 01:32:37 +00002015 } else {
2016 Idx = Builder.CreateNSWMul(Idx, numElements);
Chris Lattner2e72da942011-03-01 00:03:48 +00002017 Address = Builder.CreateInBoundsGEP(Address, Idx, "arrayidx");
John McCall77527a82011-06-25 01:32:37 +00002018 }
Chris Lattner6c5abe82010-06-26 23:03:20 +00002019 } else if (const ObjCObjectType *OIT = E->getType()->getAs<ObjCObjectType>()){
2020 // Indexing over an interface, as in "NSString *P; P[4];"
Mike Stump4a3999f2009-09-09 13:00:44 +00002021 llvm::Value *InterfaceSize =
Owen Andersonb7a2fe62009-07-24 23:12:58 +00002022 llvm::ConstantInt::get(Idx->getType(),
Ken Dyck40775002010-01-11 17:06:35 +00002023 getContext().getTypeSizeInChars(OIT).getQuantity());
Mike Stump4a3999f2009-09-09 13:00:44 +00002024
Daniel Dunbaref2ffbc2009-04-25 05:08:32 +00002025 Idx = Builder.CreateMul(Idx, InterfaceSize);
2026
Chris Lattner6c5abe82010-06-26 23:03:20 +00002027 // The base must be a pointer, which is not an aggregate. Emit it.
2028 llvm::Value *Base = EmitScalarExpr(E->getBase());
John McCallad7c5c12011-02-08 08:22:06 +00002029 Address = EmitCastToVoidPtr(Base);
2030 Address = Builder.CreateGEP(Address, Idx, "arrayidx");
Daniel Dunbaref2ffbc2009-04-25 05:08:32 +00002031 Address = Builder.CreateBitCast(Address, Base->getType());
Chris Lattner6c5abe82010-06-26 23:03:20 +00002032 } else if (const Expr *Array = isSimpleArrayDecayOperand(E->getBase())) {
2033 // If this is A[i] where A is an array, the frontend will have decayed the
2034 // base to be a ArrayToPointerDecay implicit cast. While correct, it is
2035 // inefficient at -O0 to emit a "gep A, 0, 0" when codegen'ing it, then a
2036 // "gep x, i" here. Emit one "gep A, 0, i".
2037 assert(Array->getType()->isArrayType() &&
2038 "Array to pointer decay must have array source type!");
Daniel Dunbar82634272011-04-01 00:49:43 +00002039 LValue ArrayLV = EmitLValue(Array);
2040 llvm::Value *ArrayPtr = ArrayLV.getAddress();
Chris Lattner6c5abe82010-06-26 23:03:20 +00002041 llvm::Value *Zero = llvm::ConstantInt::get(Int32Ty, 0);
2042 llvm::Value *Args[] = { Zero, Idx };
2043
Daniel Dunbar82634272011-04-01 00:49:43 +00002044 // Propagate the alignment from the array itself to the result.
2045 ArrayAlignment = ArrayLV.getAlignment();
2046
David Blaikiebbafb8a2012-03-11 07:00:24 +00002047 if (getContext().getLangOpts().isSignedOverflowDefined())
Jay Foad040dd822011-07-22 08:16:57 +00002048 Address = Builder.CreateGEP(ArrayPtr, Args, "arrayidx");
Chris Lattner2e72da942011-03-01 00:03:48 +00002049 else
Jay Foad040dd822011-07-22 08:16:57 +00002050 Address = Builder.CreateInBoundsGEP(ArrayPtr, Args, "arrayidx");
Daniel Dunbaref2ffbc2009-04-25 05:08:32 +00002051 } else {
Chris Lattner6c5abe82010-06-26 23:03:20 +00002052 // The base must be a pointer, which is not an aggregate. Emit it.
2053 llvm::Value *Base = EmitScalarExpr(E->getBase());
David Blaikiebbafb8a2012-03-11 07:00:24 +00002054 if (getContext().getLangOpts().isSignedOverflowDefined())
Chris Lattner2e72da942011-03-01 00:03:48 +00002055 Address = Builder.CreateGEP(Base, Idx, "arrayidx");
2056 else
2057 Address = Builder.CreateInBoundsGEP(Base, Idx, "arrayidx");
Anders Carlsson3d312f82008-12-21 00:11:23 +00002058 }
Mike Stump4a3999f2009-09-09 13:00:44 +00002059
Steve Naroff7cae42b2009-07-10 23:34:53 +00002060 QualType T = E->getBase()->getType()->getPointeeType();
Mike Stump4a3999f2009-09-09 13:00:44 +00002061 assert(!T.isNull() &&
Steve Naroff7cae42b2009-07-10 23:34:53 +00002062 "CodeGenFunction::EmitArraySubscriptExpr(): Illegal base type");
Mike Stump4a3999f2009-09-09 13:00:44 +00002063
Chris Lattner36bc4f42012-01-04 22:35:55 +00002064
Daniel Dunbar82634272011-04-01 00:49:43 +00002065 // Limit the alignment to that of the result type.
Chris Lattner36bc4f42012-01-04 22:35:55 +00002066 LValue LV;
Eli Friedmana0544d62011-12-03 04:14:32 +00002067 if (!ArrayAlignment.isZero()) {
2068 CharUnits Align = getContext().getTypeAlignInChars(T);
Daniel Dunbar82634272011-04-01 00:49:43 +00002069 ArrayAlignment = std::min(Align, ArrayAlignment);
Chris Lattner36bc4f42012-01-04 22:35:55 +00002070 LV = MakeAddrLValue(Address, T, ArrayAlignment);
2071 } else {
2072 LV = MakeNaturalAlignAddrLValue(Address, T);
Daniel Dunbar82634272011-04-01 00:49:43 +00002073 }
2074
Daniel Dunbarf166a522010-08-21 03:44:13 +00002075 LV.getQuals().setAddressSpace(E->getBase()->getType().getAddressSpace());
John McCall8ccfcb52009-09-24 19:53:00 +00002076
David Blaikiebbafb8a2012-03-11 07:00:24 +00002077 if (getContext().getLangOpts().ObjC1 &&
2078 getContext().getLangOpts().getGC() != LangOptions::NonGC) {
Daniel Dunbare50dda92010-08-21 03:22:38 +00002079 LV.setNonGC(!E->isOBJCGCCandidate(getContext()));
Fariborz Jahaniana7fa6be2009-09-16 21:37:16 +00002080 setObjCGCLValueClass(getContext(), E, LV);
2081 }
Fariborz Jahaniana9fecf32009-02-21 23:37:19 +00002082 return LV;
Chris Lattnerd9d2fb12007-06-08 23:31:14 +00002083}
2084
Mike Stump4a3999f2009-09-09 13:00:44 +00002085static
NAKAMURA Takumiccca11a2012-01-25 08:58:21 +00002086llvm::Constant *GenerateConstantVector(CGBuilderTy &Builder,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002087 SmallVector<unsigned, 4> &Elts) {
2088 SmallVector<llvm::Constant*, 4> CElts;
Nate Begemand3862152008-05-13 21:03:02 +00002089 for (unsigned i = 0, e = Elts.size(); i != e; ++i)
Chris Lattner2d6b7b92012-01-25 05:34:41 +00002090 CElts.push_back(Builder.getInt32(Elts[i]));
Nate Begemand3862152008-05-13 21:03:02 +00002091
Chris Lattner91c08ad2011-02-15 00:14:06 +00002092 return llvm::ConstantVector::get(CElts);
Nate Begemand3862152008-05-13 21:03:02 +00002093}
2094
Chris Lattner9e751ca2007-08-02 23:37:31 +00002095LValue CodeGenFunction::
Nate Begemance4d7fc2008-04-18 23:10:10 +00002096EmitExtVectorElementExpr(const ExtVectorElementExpr *E) {
Chris Lattner9e751ca2007-08-02 23:37:31 +00002097 // Emit the base vector as an l-value.
Chris Lattner6c7ce102009-02-16 21:11:58 +00002098 LValue Base;
2099
2100 // ExtVectorElementExpr's base can either be a vector or pointer to vector.
Chris Lattner4e1a3232009-12-23 21:31:11 +00002101 if (E->isArrow()) {
2102 // If it is a pointer to a vector, emit the address and form an lvalue with
2103 // it.
Chris Lattnerb8211f62009-02-16 22:14:05 +00002104 llvm::Value *Ptr = EmitScalarExpr(E->getBase());
Chris Lattner4e1a3232009-12-23 21:31:11 +00002105 const PointerType *PT = E->getBase()->getType()->getAs<PointerType>();
Daniel Dunbarf166a522010-08-21 03:44:13 +00002106 Base = MakeAddrLValue(Ptr, PT->getPointeeType());
2107 Base.getQuals().removeObjCGCAttr();
John McCall086a4642010-11-24 05:12:34 +00002108 } else if (E->getBase()->isGLValue()) {
Chris Lattner4e1a3232009-12-23 21:31:11 +00002109 // Otherwise, if the base is an lvalue ( as in the case of foo.x.x),
2110 // emit the base as an lvalue.
2111 assert(E->getBase()->getType()->isVectorType());
2112 Base = EmitLValue(E->getBase());
2113 } else {
2114 // Otherwise, the base is a normal rvalue (as in (V+V).x), emit it as such.
John McCall1553b192011-06-16 04:16:24 +00002115 assert(E->getBase()->getType()->isVectorType() &&
Daniel Dunbar5b901952010-01-04 18:02:28 +00002116 "Result must be a vector");
Chris Lattner4e1a3232009-12-23 21:31:11 +00002117 llvm::Value *Vec = EmitScalarExpr(E->getBase());
2118
Chris Lattnerf0a9ba32009-12-23 21:33:41 +00002119 // Store the vector to memory (because LValue wants an address).
Daniel Dunbara7566f12010-02-09 02:48:28 +00002120 llvm::Value *VecMem = CreateMemTemp(E->getBase()->getType());
Chris Lattner4e1a3232009-12-23 21:31:11 +00002121 Builder.CreateStore(Vec, VecMem);
Daniel Dunbarf166a522010-08-21 03:44:13 +00002122 Base = MakeAddrLValue(VecMem, E->getBase()->getType());
Chris Lattner4e1a3232009-12-23 21:31:11 +00002123 }
John McCall1553b192011-06-16 04:16:24 +00002124
2125 QualType type =
2126 E->getType().withCVRQualifiers(Base.getQuals().getCVRQualifiers());
Chris Lattner4e1a3232009-12-23 21:31:11 +00002127
Nate Begemand3862152008-05-13 21:03:02 +00002128 // Encode the element access list into a vector of unsigned indices.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002129 SmallVector<unsigned, 4> Indices;
Nate Begemand3862152008-05-13 21:03:02 +00002130 E->getEncodedElementAccess(Indices);
2131
2132 if (Base.isSimple()) {
Chris Lattner2d6b7b92012-01-25 05:34:41 +00002133 llvm::Constant *CV = GenerateConstantVector(Builder, Indices);
Eli Friedman610bb872012-03-22 22:36:39 +00002134 return LValue::MakeExtVectorElt(Base.getAddress(), CV, type,
2135 Base.getAlignment());
Nate Begemand3862152008-05-13 21:03:02 +00002136 }
2137 assert(Base.isExtVectorElt() && "Can only subscript lvalue vec elts here!");
2138
2139 llvm::Constant *BaseElts = Base.getExtVectorElts();
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002140 SmallVector<llvm::Constant *, 4> CElts;
Nate Begemand3862152008-05-13 21:03:02 +00002141
Chris Lattner595ba3a2012-01-30 06:20:36 +00002142 for (unsigned i = 0, e = Indices.size(); i != e; ++i)
2143 CElts.push_back(BaseElts->getAggregateElement(Indices[i]));
Chris Lattner91c08ad2011-02-15 00:14:06 +00002144 llvm::Constant *CV = llvm::ConstantVector::get(CElts);
Eli Friedman610bb872012-03-22 22:36:39 +00002145 return LValue::MakeExtVectorElt(Base.getExtVectorAddr(), CV, type,
2146 Base.getAlignment());
Chris Lattner9e751ca2007-08-02 23:37:31 +00002147}
2148
Devang Patel30efa2e2007-10-23 20:28:39 +00002149LValue CodeGenFunction::EmitMemberExpr(const MemberExpr *E) {
Devang Pateld68df202007-10-24 22:26:28 +00002150 Expr *BaseExpr = E->getBase();
Eli Friedman327944b2008-06-13 23:01:12 +00002151
Chris Lattner4e4186b2007-12-02 18:52:07 +00002152 // 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 +00002153 LValue BaseLV;
Richard Smith69d0d262012-08-24 00:54:33 +00002154 if (E->isArrow()) {
2155 llvm::Value *Ptr = EmitScalarExpr(BaseExpr);
2156 QualType PtrTy = BaseExpr->getType()->getPointeeType();
Richard Smith4d1458e2012-09-08 02:08:36 +00002157 EmitTypeCheck(TCK_MemberAccess, Ptr, PtrTy);
Richard Smith69d0d262012-08-24 00:54:33 +00002158 BaseLV = MakeNaturalAlignAddrLValue(Ptr, PtrTy);
2159 } else
Richard Smith4d1458e2012-09-08 02:08:36 +00002160 BaseLV = EmitCheckedLValue(BaseExpr, TCK_MemberAccess);
Devang Patel30efa2e2007-10-23 20:28:39 +00002161
Anders Carlssonea4c30b2009-11-07 23:06:58 +00002162 NamedDecl *ND = E->getMemberDecl();
2163 if (FieldDecl *Field = dyn_cast<FieldDecl>(ND)) {
Eli Friedman7f1ff602012-04-16 03:54:45 +00002164 LValue LV = EmitLValueForField(BaseLV, Field);
Anders Carlssonea4c30b2009-11-07 23:06:58 +00002165 setObjCGCLValueClass(getContext(), E, LV);
2166 return LV;
2167 }
2168
Anders Carlsson5bbdc9f2009-11-07 23:16:50 +00002169 if (VarDecl *VD = dyn_cast<VarDecl>(ND))
2170 return EmitGlobalVarDeclLValue(*this, E, VD);
Eli Friedmand15eb34d2009-11-26 06:08:14 +00002171
2172 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND))
2173 return EmitFunctionDeclLValue(*this, E, FD);
2174
David Blaikie83d382b2011-09-23 05:06:16 +00002175 llvm_unreachable("Unhandled member declaration!");
Eli Friedmana62f3e12008-02-09 08:50:58 +00002176}
Devang Patel30efa2e2007-10-23 20:28:39 +00002177
Eli Friedman7f1ff602012-04-16 03:54:45 +00002178LValue CodeGenFunction::EmitLValueForField(LValue base,
2179 const FieldDecl *field) {
Eli Friedmanc24e2fb2012-06-27 21:19:48 +00002180 if (field->isBitField()) {
2181 const CGRecordLayout &RL =
2182 CGM.getTypes().getCGRecordLayout(field->getParent());
2183 const CGBitFieldInfo &Info = RL.getBitFieldInfo(field);
2184 QualType fieldType =
2185 field->getType().withCVRQualifiers(base.getVRQualifiers());
2186 return LValue::MakeBitfield(base.getAddress(), Info, fieldType,
2187 base.getAlignment());
2188 }
Mike Stump4a3999f2009-09-09 13:00:44 +00002189
John McCall53fcbd22011-02-26 08:07:02 +00002190 const RecordDecl *rec = field->getParent();
2191 QualType type = field->getType();
Eli Friedmana0544d62011-12-03 04:14:32 +00002192 CharUnits alignment = getContext().getDeclAlign(field);
Eli Friedman133e8042008-05-29 11:33:25 +00002193
Eli Friedman7f1ff602012-04-16 03:54:45 +00002194 // FIXME: It should be impossible to have an LValue without alignment for a
2195 // complete type.
2196 if (!base.getAlignment().isZero())
2197 alignment = std::min(alignment, base.getAlignment());
2198
John McCall53fcbd22011-02-26 08:07:02 +00002199 bool mayAlias = rec->hasAttr<MayAliasAttr>();
2200
Eli Friedman7f1ff602012-04-16 03:54:45 +00002201 llvm::Value *addr = base.getAddress();
2202 unsigned cvr = base.getVRQualifiers();
John McCall53fcbd22011-02-26 08:07:02 +00002203 if (rec->isUnion()) {
Chris Lattner13ee4f42011-07-10 05:34:54 +00002204 // For unions, there is no pointer adjustment.
John McCall53fcbd22011-02-26 08:07:02 +00002205 assert(!type->isReferenceType() && "union has reference member");
John McCall53fcbd22011-02-26 08:07:02 +00002206 } else {
2207 // For structs, we GEP to the field that the record layout suggests.
2208 unsigned idx = CGM.getTypes().getCGRecordLayout(rec).getLLVMFieldNo(field);
Chris Lattner13ee4f42011-07-10 05:34:54 +00002209 addr = Builder.CreateStructGEP(addr, idx, field->getName());
John McCall53fcbd22011-02-26 08:07:02 +00002210
2211 // If this is a reference field, load the reference right now.
2212 if (const ReferenceType *refType = type->getAs<ReferenceType>()) {
2213 llvm::LoadInst *load = Builder.CreateLoad(addr, "ref");
2214 if (cvr & Qualifiers::Volatile) load->setVolatile(true);
Eli Friedmana0544d62011-12-03 04:14:32 +00002215 load->setAlignment(alignment.getQuantity());
John McCall53fcbd22011-02-26 08:07:02 +00002216
2217 if (CGM.shouldUseTBAA()) {
2218 llvm::MDNode *tbaa;
2219 if (mayAlias)
2220 tbaa = CGM.getTBAAInfo(getContext().CharTy);
2221 else
2222 tbaa = CGM.getTBAAInfo(type);
2223 CGM.DecorateInstruction(load, tbaa);
2224 }
2225
2226 addr = load;
2227 mayAlias = false;
2228 type = refType->getPointeeType();
Eli Friedmand20adbd2011-11-16 00:42:57 +00002229 if (type->isIncompleteType())
Eli Friedmana0544d62011-12-03 04:14:32 +00002230 alignment = CharUnits();
Eli Friedmand20adbd2011-11-16 00:42:57 +00002231 else
Eli Friedmana0544d62011-12-03 04:14:32 +00002232 alignment = getContext().getTypeAlignInChars(type);
John McCall53fcbd22011-02-26 08:07:02 +00002233 cvr = 0; // qualifiers don't recursively apply to referencee
2234 }
Devang Pateled93c3c2007-10-26 19:42:18 +00002235 }
Chris Lattner13ee4f42011-07-10 05:34:54 +00002236
2237 // Make sure that the address is pointing to the right type. This is critical
2238 // for both unions and structs. A union needs a bitcast, a struct element
2239 // will need a bitcast if the LLVM type laid out doesn't match the desired
2240 // type.
Chandler Carruth4678f672011-07-12 08:58:26 +00002241 addr = EmitBitCastOfLValueToProperType(*this, addr,
Chris Lattner3f32d692011-07-12 06:52:18 +00002242 CGM.getTypes().ConvertTypeForMem(type),
2243 field->getName());
John McCall8ccfcb52009-09-24 19:53:00 +00002244
Julien Lerouge5a6b6982011-09-09 22:41:49 +00002245 if (field->hasAttr<AnnotateAttr>())
2246 addr = EmitFieldAnnotations(field, addr);
2247
John McCall53fcbd22011-02-26 08:07:02 +00002248 LValue LV = MakeAddrLValue(addr, type, alignment);
2249 LV.getQuals().addCVRQualifiers(cvr);
Daniel Dunbarf166a522010-08-21 03:44:13 +00002250
Fariborz Jahanian38c3ae92009-09-21 18:54:29 +00002251 // __weak attribute on a field is ignored.
Daniel Dunbarf166a522010-08-21 03:44:13 +00002252 if (LV.getQuals().getObjCGCAttr() == Qualifiers::Weak)
2253 LV.getQuals().removeObjCGCAttr();
John McCall53fcbd22011-02-26 08:07:02 +00002254
2255 // Fields of may_alias structs act like 'char' for TBAA purposes.
2256 // FIXME: this should get propagated down through anonymous structs
2257 // and unions.
2258 if (mayAlias && LV.getTBAAInfo())
2259 LV.setTBAAInfo(CGM.getTBAAInfo(getContext().CharTy));
2260
Daniel Dunbarf166a522010-08-21 03:44:13 +00002261 return LV;
Devang Patel30efa2e2007-10-23 20:28:39 +00002262}
2263
Anders Carlssondb78f0a2010-01-29 05:24:29 +00002264LValue
Eli Friedman7f1ff602012-04-16 03:54:45 +00002265CodeGenFunction::EmitLValueForFieldInitialization(LValue Base,
2266 const FieldDecl *Field) {
Anders Carlssondb78f0a2010-01-29 05:24:29 +00002267 QualType FieldType = Field->getType();
2268
2269 if (!FieldType->isReferenceType())
Eli Friedman7f1ff602012-04-16 03:54:45 +00002270 return EmitLValueForField(Base, Field);
Anders Carlssondb78f0a2010-01-29 05:24:29 +00002271
Daniel Dunbar034299e2010-03-31 01:09:11 +00002272 const CGRecordLayout &RL =
2273 CGM.getTypes().getCGRecordLayout(Field->getParent());
2274 unsigned idx = RL.getLLVMFieldNo(Field);
Eli Friedman7f1ff602012-04-16 03:54:45 +00002275 llvm::Value *V = Builder.CreateStructGEP(Base.getAddress(), idx);
Anders Carlssondb78f0a2010-01-29 05:24:29 +00002276 assert(!FieldType.getObjCGCAttr() && "fields cannot have GC attrs");
2277
Chris Lattnerd7c59352011-07-10 05:53:24 +00002278 // Make sure that the address is pointing to the right type. This is critical
2279 // for both unions and structs. A union needs a bitcast, a struct element
2280 // will need a bitcast if the LLVM type laid out doesn't match the desired
2281 // type.
Chris Lattner2192fe52011-07-18 04:24:23 +00002282 llvm::Type *llvmType = ConvertTypeForMem(FieldType);
Eli Friedman7f1ff602012-04-16 03:54:45 +00002283 V = EmitBitCastOfLValueToProperType(*this, V, llvmType, Field->getName());
2284
Eli Friedmana0544d62011-12-03 04:14:32 +00002285 CharUnits Alignment = getContext().getDeclAlign(Field);
Eli Friedman7f1ff602012-04-16 03:54:45 +00002286
2287 // FIXME: It should be impossible to have an LValue without alignment for a
2288 // complete type.
2289 if (!Base.getAlignment().isZero())
2290 Alignment = std::min(Alignment, Base.getAlignment());
2291
Daniel Dunbar5c816372010-08-21 04:20:22 +00002292 return MakeAddrLValue(V, FieldType, Alignment);
Anders Carlssondb78f0a2010-01-29 05:24:29 +00002293}
2294
Chris Lattnerf53c0962010-09-06 00:11:41 +00002295LValue CodeGenFunction::EmitCompoundLiteralLValue(const CompoundLiteralExpr *E){
Richard Smith2d988f02011-11-22 22:48:32 +00002296 if (E->isFileScope()) {
2297 llvm::Value *GlobalPtr = CGM.GetAddrOfConstantCompoundLiteral(E);
2298 return MakeAddrLValue(GlobalPtr, E->getType());
2299 }
Fariborz Jahanian5d53fcd2012-06-07 18:15:55 +00002300 if (E->getType()->isVariablyModifiedType())
2301 // make sure to emit the VLA size.
2302 EmitVariablyModifiedType(E->getType());
Fariborz Jahanianbbc5bbf2012-06-07 17:07:15 +00002303
Daniel Dunbar27bacaf2010-02-16 19:43:39 +00002304 llvm::Value *DeclPtr = CreateMemTemp(E->getType(), ".compoundliteral");
Chris Lattnerf53c0962010-09-06 00:11:41 +00002305 const Expr *InitExpr = E->getInitializer();
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002306 LValue Result = MakeAddrLValue(DeclPtr, E->getType());
Eli Friedman9fd8b682008-05-13 23:18:27 +00002307
Chad Rosier615ed1a2012-03-29 17:37:10 +00002308 EmitAnyExprToMem(InitExpr, DeclPtr, E->getType().getQualifiers(),
2309 /*Init*/ true);
Eli Friedman9fd8b682008-05-13 23:18:27 +00002310
2311 return Result;
2312}
2313
Richard Smithbb653bd2012-05-14 21:57:21 +00002314LValue CodeGenFunction::EmitInitListLValue(const InitListExpr *E) {
2315 if (!E->isGLValue())
2316 // Initializing an aggregate temporary in C++11: T{...}.
2317 return EmitAggExprToLValue(E);
2318
2319 // An lvalue initializer list must be initializing a reference.
2320 assert(E->getNumInits() == 1 && "reference init with multiple values");
2321 return EmitLValue(E->getInit(0));
2322}
2323
John McCallc07a0c72011-02-17 10:25:35 +00002324LValue CodeGenFunction::
2325EmitConditionalOperatorLValue(const AbstractConditionalOperator *expr) {
2326 if (!expr->isGLValue()) {
John McCall0a6bf2e2011-01-26 19:21:13 +00002327 // ?: here should be an aggregate.
John McCallc07a0c72011-02-17 10:25:35 +00002328 assert((hasAggregateLLVMType(expr->getType()) &&
2329 !expr->getType()->isAnyComplexType()) &&
John McCall0a6bf2e2011-01-26 19:21:13 +00002330 "Unexpected conditional operator!");
John McCallc07a0c72011-02-17 10:25:35 +00002331 return EmitAggExprToLValue(expr);
Anders Carlsson1450adb2009-09-15 16:35:24 +00002332 }
Daniel Dunbarbf1fe8c2009-03-24 02:38:23 +00002333
Eli Friedman59954892012-01-25 05:04:17 +00002334 OpaqueValueMapping binding(*this, expr);
2335
John McCallc07a0c72011-02-17 10:25:35 +00002336 const Expr *condExpr = expr->getCond();
Chris Lattner41c6ab52011-02-27 23:02:32 +00002337 bool CondExprBool;
2338 if (ConstantFoldsToSimpleInteger(condExpr, CondExprBool)) {
John McCallc07a0c72011-02-17 10:25:35 +00002339 const Expr *live = expr->getTrueExpr(), *dead = expr->getFalseExpr();
Chris Lattner41c6ab52011-02-27 23:02:32 +00002340 if (!CondExprBool) std::swap(live, dead);
John McCallc07a0c72011-02-17 10:25:35 +00002341
2342 if (!ContainsLabel(dead))
2343 return EmitLValue(live);
John McCall0a6bf2e2011-01-26 19:21:13 +00002344 }
2345
John McCallc07a0c72011-02-17 10:25:35 +00002346 llvm::BasicBlock *lhsBlock = createBasicBlock("cond.true");
2347 llvm::BasicBlock *rhsBlock = createBasicBlock("cond.false");
2348 llvm::BasicBlock *contBlock = createBasicBlock("cond.end");
John McCall0a6bf2e2011-01-26 19:21:13 +00002349
2350 ConditionalEvaluation eval(*this);
John McCallc07a0c72011-02-17 10:25:35 +00002351 EmitBranchOnBoolExpr(condExpr, lhsBlock, rhsBlock);
John McCall0a6bf2e2011-01-26 19:21:13 +00002352
2353 // Any temporaries created here are conditional.
John McCallc07a0c72011-02-17 10:25:35 +00002354 EmitBlock(lhsBlock);
John McCall0a6bf2e2011-01-26 19:21:13 +00002355 eval.begin(*this);
John McCallc07a0c72011-02-17 10:25:35 +00002356 LValue lhs = EmitLValue(expr->getTrueExpr());
John McCall0a6bf2e2011-01-26 19:21:13 +00002357 eval.end(*this);
2358
John McCallc07a0c72011-02-17 10:25:35 +00002359 if (!lhs.isSimple())
2360 return EmitUnsupportedLValue(expr, "conditional operator");
John McCall0a6bf2e2011-01-26 19:21:13 +00002361
John McCallc07a0c72011-02-17 10:25:35 +00002362 lhsBlock = Builder.GetInsertBlock();
2363 Builder.CreateBr(contBlock);
John McCall0a6bf2e2011-01-26 19:21:13 +00002364
2365 // Any temporaries created here are conditional.
John McCallc07a0c72011-02-17 10:25:35 +00002366 EmitBlock(rhsBlock);
John McCall0a6bf2e2011-01-26 19:21:13 +00002367 eval.begin(*this);
John McCallc07a0c72011-02-17 10:25:35 +00002368 LValue rhs = EmitLValue(expr->getFalseExpr());
John McCall0a6bf2e2011-01-26 19:21:13 +00002369 eval.end(*this);
John McCallc07a0c72011-02-17 10:25:35 +00002370 if (!rhs.isSimple())
2371 return EmitUnsupportedLValue(expr, "conditional operator");
2372 rhsBlock = Builder.GetInsertBlock();
John McCall0a6bf2e2011-01-26 19:21:13 +00002373
John McCallc07a0c72011-02-17 10:25:35 +00002374 EmitBlock(contBlock);
John McCall0a6bf2e2011-01-26 19:21:13 +00002375
Jay Foad20c0f022011-03-30 11:28:58 +00002376 llvm::PHINode *phi = Builder.CreatePHI(lhs.getAddress()->getType(), 2,
John McCall0a6bf2e2011-01-26 19:21:13 +00002377 "cond-lvalue");
John McCallc07a0c72011-02-17 10:25:35 +00002378 phi->addIncoming(lhs.getAddress(), lhsBlock);
2379 phi->addIncoming(rhs.getAddress(), rhsBlock);
2380 return MakeAddrLValue(phi, expr->getType());
Daniel Dunbarbf1fe8c2009-03-24 02:38:23 +00002381}
2382
Richard Smithbb653bd2012-05-14 21:57:21 +00002383/// EmitCastLValue - Casts are never lvalues unless that cast is to a reference
2384/// type. If the cast is to a reference, we can have the usual lvalue result,
Mike Stump65511702009-11-16 06:50:58 +00002385/// otherwise if a cast is needed by the code generator in an lvalue context,
2386/// then it must mean that we need the address of an aggregate in order to
Richard Smithbb653bd2012-05-14 21:57:21 +00002387/// access one of its members. This can happen for all the reasons that casts
Mike Stump65511702009-11-16 06:50:58 +00002388/// are permitted with aggregate result, including noop aggregate casts, and
2389/// cast from scalar to union.
Chris Lattner28bcf1a2009-03-18 18:28:57 +00002390LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) {
Anders Carlssond95f9602009-09-12 16:16:49 +00002391 switch (E->getCastKind()) {
John McCalle3027922010-08-25 11:45:40 +00002392 case CK_ToVoid:
Eli Friedman8c98dff2009-11-16 05:48:01 +00002393 return EmitUnsupportedLValue(E, "unexpected cast lvalue");
John McCall8cb679e2010-11-15 09:13:47 +00002394
2395 case CK_Dependent:
2396 llvm_unreachable("dependent cast kind in IR gen!");
Eli Friedman34866c72012-08-31 00:14:07 +00002397
2398 case CK_BuiltinFnToFnPtr:
2399 llvm_unreachable("builtin functions are handled elsewhere");
2400
David Chisnallfa35df62012-01-16 17:27:18 +00002401 // These two casts are currently treated as no-ops, although they could
2402 // potentially be real operations depending on the target's ABI.
2403 case CK_NonAtomicToAtomic:
2404 case CK_AtomicToNonAtomic:
John McCall8cb679e2010-11-15 09:13:47 +00002405
John McCalle3027922010-08-25 11:45:40 +00002406 case CK_NoOp:
Douglas Gregor21d3fca2011-01-27 23:22:05 +00002407 case CK_LValueToRValue:
2408 if (!E->getSubExpr()->Classify(getContext()).isPRValue()
2409 || E->getType()->isRecordType())
John McCalle26a8722010-12-04 08:14:53 +00002410 return EmitLValue(E->getSubExpr());
Douglas Gregorcdb466e2010-07-15 18:58:16 +00002411 // Fall through to synthesize a temporary.
John McCall8cb679e2010-11-15 09:13:47 +00002412
John McCalle3027922010-08-25 11:45:40 +00002413 case CK_BitCast:
2414 case CK_ArrayToPointerDecay:
2415 case CK_FunctionToPointerDecay:
2416 case CK_NullToMemberPointer:
John McCalle84af4e2010-11-13 01:35:44 +00002417 case CK_NullToPointer:
John McCalle3027922010-08-25 11:45:40 +00002418 case CK_IntegralToPointer:
2419 case CK_PointerToIntegral:
John McCall8cb679e2010-11-15 09:13:47 +00002420 case CK_PointerToBoolean:
John McCalle3027922010-08-25 11:45:40 +00002421 case CK_VectorSplat:
2422 case CK_IntegralCast:
John McCall8cb679e2010-11-15 09:13:47 +00002423 case CK_IntegralToBoolean:
John McCalle3027922010-08-25 11:45:40 +00002424 case CK_IntegralToFloating:
2425 case CK_FloatingToIntegral:
John McCall8cb679e2010-11-15 09:13:47 +00002426 case CK_FloatingToBoolean:
John McCalle3027922010-08-25 11:45:40 +00002427 case CK_FloatingCast:
John McCallc5e62b42010-11-13 09:02:35 +00002428 case CK_FloatingRealToComplex:
John McCalld7646252010-11-14 08:17:51 +00002429 case CK_FloatingComplexToReal:
2430 case CK_FloatingComplexToBoolean:
John McCallc5e62b42010-11-13 09:02:35 +00002431 case CK_FloatingComplexCast:
John McCalld7646252010-11-14 08:17:51 +00002432 case CK_FloatingComplexToIntegralComplex:
John McCallc5e62b42010-11-13 09:02:35 +00002433 case CK_IntegralRealToComplex:
John McCalld7646252010-11-14 08:17:51 +00002434 case CK_IntegralComplexToReal:
2435 case CK_IntegralComplexToBoolean:
John McCallc5e62b42010-11-13 09:02:35 +00002436 case CK_IntegralComplexCast:
John McCalld7646252010-11-14 08:17:51 +00002437 case CK_IntegralComplexToFloatingComplex:
John McCalle3027922010-08-25 11:45:40 +00002438 case CK_DerivedToBaseMemberPointer:
2439 case CK_BaseToDerivedMemberPointer:
2440 case CK_MemberPointerToBoolean:
John McCallc62bb392012-02-15 01:22:51 +00002441 case CK_ReinterpretMemberPointer:
John McCall31168b02011-06-15 23:02:42 +00002442 case CK_AnyPointerToBlockPointerCast:
John McCall2d637d22011-09-10 06:18:15 +00002443 case CK_ARCProduceObject:
2444 case CK_ARCConsumeObject:
2445 case CK_ARCReclaimReturnedObject:
Douglas Gregored90df32012-02-22 05:02:47 +00002446 case CK_ARCExtendBlockObject:
2447 case CK_CopyAndAutoreleaseBlockObject: {
Douglas Gregorcdb466e2010-07-15 18:58:16 +00002448 // These casts only produce lvalues when we're binding a reference to a
2449 // temporary realized from a (converted) pure rvalue. Emit the expression
2450 // as a value, copy it into a temporary, and return an lvalue referring to
2451 // that temporary.
2452 llvm::Value *V = CreateMemTemp(E->getType(), "ref.temp");
Chad Rosier615ed1a2012-03-29 17:37:10 +00002453 EmitAnyExprToMem(E, V, E->getType().getQualifiers(), false);
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002454 return MakeAddrLValue(V, E->getType());
Douglas Gregorcdb466e2010-07-15 18:58:16 +00002455 }
Eli Friedman8c98dff2009-11-16 05:48:01 +00002456
Anders Carlsson8a01a752011-04-11 02:03:26 +00002457 case CK_Dynamic: {
Mike Stump65511702009-11-16 06:50:58 +00002458 LValue LV = EmitLValue(E->getSubExpr());
2459 llvm::Value *V = LV.getAddress();
2460 const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(E);
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002461 return MakeAddrLValue(EmitDynamicCast(V, DCE), E->getType());
Mike Stump65511702009-11-16 06:50:58 +00002462 }
2463
John McCalle3027922010-08-25 11:45:40 +00002464 case CK_ConstructorConversion:
2465 case CK_UserDefinedConversion:
John McCall9320b872011-09-09 05:25:32 +00002466 case CK_CPointerToObjCPointerCast:
2467 case CK_BlockPointerToObjCPointerCast:
Chris Lattner28bcf1a2009-03-18 18:28:57 +00002468 return EmitLValue(E->getSubExpr());
Anders Carlssond95f9602009-09-12 16:16:49 +00002469
John McCalle3027922010-08-25 11:45:40 +00002470 case CK_UncheckedDerivedToBase:
2471 case CK_DerivedToBase: {
Anders Carlssond95f9602009-09-12 16:16:49 +00002472 const RecordType *DerivedClassTy =
2473 E->getSubExpr()->getType()->getAs<RecordType>();
2474 CXXRecordDecl *DerivedClassDecl =
2475 cast<CXXRecordDecl>(DerivedClassTy->getDecl());
Anders Carlssond95f9602009-09-12 16:16:49 +00002476
2477 LValue LV = EmitLValue(E->getSubExpr());
John McCalle26a8722010-12-04 08:14:53 +00002478 llvm::Value *This = LV.getAddress();
Anders Carlssond95f9602009-09-12 16:16:49 +00002479
2480 // Perform the derived-to-base conversion
2481 llvm::Value *Base =
Fariborz Jahanian64cda8b2010-06-17 23:00:29 +00002482 GetAddressOfBaseClass(This, DerivedClassDecl,
John McCallcf142162010-08-07 06:22:56 +00002483 E->path_begin(), E->path_end(),
2484 /*NullCheckValue=*/false);
Anders Carlssond95f9602009-09-12 16:16:49 +00002485
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002486 return MakeAddrLValue(Base, E->getType());
Anders Carlssond95f9602009-09-12 16:16:49 +00002487 }
John McCalle3027922010-08-25 11:45:40 +00002488 case CK_ToUnion:
Daniel Dunbar9c4e4652010-02-05 20:02:42 +00002489 return EmitAggExprToLValue(E);
John McCalle3027922010-08-25 11:45:40 +00002490 case CK_BaseToDerived: {
Anders Carlsson8c793172009-11-23 17:57:54 +00002491 const RecordType *DerivedClassTy = E->getType()->getAs<RecordType>();
2492 CXXRecordDecl *DerivedClassDecl =
2493 cast<CXXRecordDecl>(DerivedClassTy->getDecl());
2494
2495 LValue LV = EmitLValue(E->getSubExpr());
2496
2497 // Perform the base-to-derived conversion
2498 llvm::Value *Derived =
Anders Carlsson8a64c1c2010-04-24 21:23:59 +00002499 GetAddressOfDerivedClass(LV.getAddress(), DerivedClassDecl,
John McCallcf142162010-08-07 06:22:56 +00002500 E->path_begin(), E->path_end(),
2501 /*NullCheckValue=*/false);
Anders Carlsson8c793172009-11-23 17:57:54 +00002502
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002503 return MakeAddrLValue(Derived, E->getType());
Eli Friedman8c98dff2009-11-16 05:48:01 +00002504 }
John McCalle3027922010-08-25 11:45:40 +00002505 case CK_LValueBitCast: {
Eli Friedman8c98dff2009-11-16 05:48:01 +00002506 // This must be a reinterpret_cast (or c-style equivalent).
2507 const ExplicitCastExpr *CE = cast<ExplicitCastExpr>(E);
Anders Carlsson50cb3212009-11-14 21:21:42 +00002508
2509 LValue LV = EmitLValue(E->getSubExpr());
2510 llvm::Value *V = Builder.CreateBitCast(LV.getAddress(),
2511 ConvertType(CE->getTypeAsWritten()));
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002512 return MakeAddrLValue(V, E->getType());
Anders Carlsson50cb3212009-11-14 21:21:42 +00002513 }
John McCalle3027922010-08-25 11:45:40 +00002514 case CK_ObjCObjectLValueCast: {
Douglas Gregor8b2d2fe2010-08-07 11:51:51 +00002515 LValue LV = EmitLValue(E->getSubExpr());
2516 QualType ToType = getContext().getLValueReferenceType(E->getType());
2517 llvm::Value *V = Builder.CreateBitCast(LV.getAddress(),
2518 ConvertType(ToType));
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002519 return MakeAddrLValue(V, E->getType());
Douglas Gregor8b2d2fe2010-08-07 11:51:51 +00002520 }
Anders Carlssond95f9602009-09-12 16:16:49 +00002521 }
Douglas Gregorcdb466e2010-07-15 18:58:16 +00002522
2523 llvm_unreachable("Unhandled lvalue cast kind?");
Chris Lattner28bcf1a2009-03-18 18:28:57 +00002524}
2525
Fariborz Jahaniane4d94ce2009-10-20 23:29:04 +00002526LValue CodeGenFunction::EmitNullInitializationLValue(
Douglas Gregor747eb782010-07-08 06:14:04 +00002527 const CXXScalarValueInitExpr *E) {
Fariborz Jahaniane4d94ce2009-10-20 23:29:04 +00002528 QualType Ty = E->getType();
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002529 LValue LV = MakeAddrLValue(CreateMemTemp(Ty), Ty);
Anders Carlssonc0964b62010-05-22 17:35:42 +00002530 EmitNullInitialization(LV.getAddress(), Ty);
Daniel Dunbara7566f12010-02-09 02:48:28 +00002531 return LV;
Fariborz Jahaniane4d94ce2009-10-20 23:29:04 +00002532}
2533
John McCall1bf58462011-02-16 08:02:54 +00002534LValue CodeGenFunction::EmitOpaqueValueLValue(const OpaqueValueExpr *e) {
John McCall9a549612011-11-08 22:54:08 +00002535 assert(OpaqueValueMappingData::shouldBindAsLValue(e));
John McCallc07a0c72011-02-17 10:25:35 +00002536 return getOpaqueLValueMapping(e);
John McCall1bf58462011-02-16 08:02:54 +00002537}
2538
Douglas Gregorfe314812011-06-21 17:03:29 +00002539LValue CodeGenFunction::EmitMaterializeTemporaryExpr(
2540 const MaterializeTemporaryExpr *E) {
John McCall17054bd62011-08-26 21:08:13 +00002541 RValue RV = EmitReferenceBindingToExpr(E, /*InitializedDecl=*/0);
Douglas Gregord410c082011-06-21 18:20:46 +00002542 return MakeAddrLValue(RV.getScalarVal(), E->getType());
Douglas Gregorfe314812011-06-21 17:03:29 +00002543}
2544
Eli Friedman7f1ff602012-04-16 03:54:45 +00002545RValue CodeGenFunction::EmitRValueForField(LValue LV,
Anton Korobeynikov4215ca72012-04-13 11:22:00 +00002546 const FieldDecl *FD) {
2547 QualType FT = FD->getType();
Eli Friedman7f1ff602012-04-16 03:54:45 +00002548 LValue FieldLV = EmitLValueForField(LV, FD);
Anton Korobeynikov4215ca72012-04-13 11:22:00 +00002549 if (FT->isAnyComplexType())
Eli Friedman7f1ff602012-04-16 03:54:45 +00002550 return RValue::getComplex(
2551 LoadComplexFromAddr(FieldLV.getAddress(),
2552 FieldLV.isVolatileQualified()));
Anton Korobeynikov4215ca72012-04-13 11:22:00 +00002553 else if (CodeGenFunction::hasAggregateLLVMType(FT))
Eli Friedman7f1ff602012-04-16 03:54:45 +00002554 return FieldLV.asAggregateRValue();
Anton Korobeynikov4215ca72012-04-13 11:22:00 +00002555
Eli Friedman7f1ff602012-04-16 03:54:45 +00002556 return EmitLoadOfLValue(FieldLV);
Anton Korobeynikov4215ca72012-04-13 11:22:00 +00002557}
Douglas Gregorfe314812011-06-21 17:03:29 +00002558
Chris Lattnere47e4402007-06-01 18:02:12 +00002559//===--------------------------------------------------------------------===//
2560// Expression Emission
2561//===--------------------------------------------------------------------===//
2562
Anders Carlsson17490832009-12-24 20:40:36 +00002563RValue CodeGenFunction::EmitCallExpr(const CallExpr *E,
2564 ReturnValueSlot ReturnValue) {
Eric Christopher7cdf9482011-10-13 21:45:18 +00002565 if (CGDebugInfo *DI = getDebugInfo())
2566 DI->EmitLocation(Builder, E->getLocStart());
Devang Pateld3a6b0f2011-03-04 18:54:42 +00002567
Daniel Dunbarcdbb5e32009-02-20 18:06:48 +00002568 // Builtins never have block type.
Daniel Dunbarbb197e42009-01-09 16:50:52 +00002569 if (E->getCallee()->getType()->isBlockPointerType())
Anders Carlssonbfb36712009-12-24 21:13:40 +00002570 return EmitBlockCallExpr(E, ReturnValue);
Daniel Dunbarbb197e42009-01-09 16:50:52 +00002571
Anders Carlssone5fd6f22009-04-03 22:50:24 +00002572 if (const CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(E))
Anders Carlssonbfb36712009-12-24 21:13:40 +00002573 return EmitCXXMemberCallExpr(CE, ReturnValue);
Mike Stump4a3999f2009-09-09 13:00:44 +00002574
Peter Collingbournefe883422011-10-06 18:29:37 +00002575 if (const CUDAKernelCallExpr *CE = dyn_cast<CUDAKernelCallExpr>(E))
2576 return EmitCUDAKernelCallExpr(CE, ReturnValue);
2577
Douglas Gregore0e96302011-09-06 21:41:04 +00002578 const Decl *TargetDecl = E->getCalleeDecl();
2579 if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(TargetDecl)) {
2580 if (unsigned builtinID = FD->getBuiltinID())
2581 return EmitBuiltinExpr(FD, builtinID, E);
Daniel Dunbarcdbb5e32009-02-20 18:06:48 +00002582 }
2583
Chris Lattner4ca97c32009-06-13 00:26:38 +00002584 if (const CXXOperatorCallExpr *CE = dyn_cast<CXXOperatorCallExpr>(E))
Anders Carlsson4034a952009-05-27 04:18:27 +00002585 if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(TargetDecl))
Anders Carlssonbfb36712009-12-24 21:13:40 +00002586 return EmitCXXOperatorMemberCallExpr(CE, MD, ReturnValue);
Mike Stump4a3999f2009-09-09 13:00:44 +00002587
John McCall31168b02011-06-15 23:02:42 +00002588 if (const CXXPseudoDestructorExpr *PseudoDtor
2589 = dyn_cast<CXXPseudoDestructorExpr>(E->getCallee()->IgnoreParens())) {
2590 QualType DestroyedType = PseudoDtor->getDestroyedType();
David Blaikiebbafb8a2012-03-11 07:00:24 +00002591 if (getContext().getLangOpts().ObjCAutoRefCount &&
John McCall31168b02011-06-15 23:02:42 +00002592 DestroyedType->isObjCLifetimeType() &&
2593 (DestroyedType.getObjCLifetime() == Qualifiers::OCL_Strong ||
2594 DestroyedType.getObjCLifetime() == Qualifiers::OCL_Weak)) {
Benjamin Kramerdd19c012011-06-18 10:34:00 +00002595 // Automatic Reference Counting:
2596 // If the pseudo-expression names a retainable object with weak or
2597 // strong lifetime, the object shall be released.
John McCall31168b02011-06-15 23:02:42 +00002598 Expr *BaseExpr = PseudoDtor->getBase();
2599 llvm::Value *BaseValue = NULL;
2600 Qualifiers BaseQuals;
2601
Benjamin Kramerdd19c012011-06-18 10:34:00 +00002602 // 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 +00002603 if (PseudoDtor->isArrow()) {
2604 BaseValue = EmitScalarExpr(BaseExpr);
2605 const PointerType *PTy = BaseExpr->getType()->getAs<PointerType>();
2606 BaseQuals = PTy->getPointeeType().getQualifiers();
2607 } else {
2608 LValue BaseLV = EmitLValue(BaseExpr);
John McCall31168b02011-06-15 23:02:42 +00002609 BaseValue = BaseLV.getAddress();
2610 QualType BaseTy = BaseExpr->getType();
2611 BaseQuals = BaseTy.getQualifiers();
2612 }
2613
2614 switch (PseudoDtor->getDestroyedType().getObjCLifetime()) {
2615 case Qualifiers::OCL_None:
2616 case Qualifiers::OCL_ExplicitNone:
2617 case Qualifiers::OCL_Autoreleasing:
2618 break;
2619
2620 case Qualifiers::OCL_Strong:
2621 EmitARCRelease(Builder.CreateLoad(BaseValue,
Benjamin Kramerdd19c012011-06-18 10:34:00 +00002622 PseudoDtor->getDestroyedType().isVolatileQualified()),
John McCall31168b02011-06-15 23:02:42 +00002623 /*precise*/ true);
2624 break;
2625
2626 case Qualifiers::OCL_Weak:
2627 EmitARCDestroyWeak(BaseValue);
2628 break;
2629 }
2630 } else {
2631 // C++ [expr.pseudo]p1:
2632 // The result shall only be used as the operand for the function call
2633 // operator (), and the result of such a call has type void. The only
2634 // effect is the evaluation of the postfix-expression before the dot or
2635 // arrow.
2636 EmitScalarExpr(E->getCallee());
2637 }
2638
Douglas Gregorad8a3362009-09-04 17:36:40 +00002639 return RValue::get(0);
2640 }
Mike Stump4a3999f2009-09-09 13:00:44 +00002641
Chris Lattner2da04b32007-08-24 05:35:26 +00002642 llvm::Value *Callee = EmitScalarExpr(E->getCallee());
Anders Carlsson17490832009-12-24 20:40:36 +00002643 return EmitCall(E->getCallee()->getType(), Callee, ReturnValue,
Anders Carlsson3a9463b2009-05-27 01:22:39 +00002644 E->arg_begin(), E->arg_end(), TargetDecl);
Chris Lattner9e47ead2007-08-31 04:44:06 +00002645}
2646
Daniel Dunbar8cde00a2008-09-04 03:20:13 +00002647LValue CodeGenFunction::EmitBinaryOperatorLValue(const BinaryOperator *E) {
Chris Lattnere541ea32009-05-12 21:28:12 +00002648 // Comma expressions just emit their LHS then their RHS as an l-value.
John McCalle3027922010-08-25 11:45:40 +00002649 if (E->getOpcode() == BO_Comma) {
John McCalla2342eb2010-12-05 02:00:02 +00002650 EmitIgnoredExpr(E->getLHS());
Eli Friedman5445f6e2009-12-07 20:18:11 +00002651 EnsureInsertPoint();
Chris Lattnere541ea32009-05-12 21:28:12 +00002652 return EmitLValue(E->getRHS());
2653 }
Mike Stump4a3999f2009-09-09 13:00:44 +00002654
John McCalle3027922010-08-25 11:45:40 +00002655 if (E->getOpcode() == BO_PtrMemD ||
2656 E->getOpcode() == BO_PtrMemI)
Fariborz Jahanianffba6622009-10-22 22:57:31 +00002657 return EmitPointerToDataMemberBinaryExpr(E);
Daniel Dunbar8cde00a2008-09-04 03:20:13 +00002658
John McCalla2342eb2010-12-05 02:00:02 +00002659 assert(E->getOpcode() == BO_Assign && "unexpected binary l-value");
John McCall31168b02011-06-15 23:02:42 +00002660
2661 // Note that in all of these cases, __block variables need the RHS
2662 // evaluated first just in case the variable gets moved by the RHS.
John McCall4f29b492010-11-16 23:07:28 +00002663
Anders Carlsson0999aaf2009-10-19 18:28:22 +00002664 if (!hasAggregateLLVMType(E->getType())) {
John McCall31168b02011-06-15 23:02:42 +00002665 switch (E->getLHS()->getType().getObjCLifetime()) {
2666 case Qualifiers::OCL_Strong:
2667 return EmitARCStoreStrong(E, /*ignored*/ false).first;
2668
2669 case Qualifiers::OCL_Autoreleasing:
2670 return EmitARCStoreAutoreleasing(E).first;
2671
2672 // No reason to do any of these differently.
2673 case Qualifiers::OCL_None:
2674 case Qualifiers::OCL_ExplicitNone:
2675 case Qualifiers::OCL_Weak:
2676 break;
2677 }
2678
John McCalld0a30012010-12-06 06:10:02 +00002679 RValue RV = EmitAnyExpr(E->getRHS());
Anders Carlsson0999aaf2009-10-19 18:28:22 +00002680 LValue LV = EmitLValue(E->getLHS());
John McCall55e1fbc2011-06-25 02:11:03 +00002681 EmitStoreThroughLValue(RV, LV);
Anders Carlsson0999aaf2009-10-19 18:28:22 +00002682 return LV;
2683 }
John McCall4f29b492010-11-16 23:07:28 +00002684
2685 if (E->getType()->isAnyComplexType())
2686 return EmitComplexAssignmentLValue(E);
2687
Daniel Dunbard0bc7b92010-02-05 19:38:31 +00002688 return EmitAggExprToLValue(E);
Daniel Dunbar8cde00a2008-09-04 03:20:13 +00002689}
2690
Christopher Lambd91c3d42007-12-29 05:02:41 +00002691LValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) {
Christopher Lambd91c3d42007-12-29 05:02:41 +00002692 RValue RV = EmitCallExpr(E);
Anders Carlsson4ae70ff2009-05-27 01:45:47 +00002693
Chris Lattnerab5e0af2009-10-28 17:39:19 +00002694 if (!RV.isScalar())
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002695 return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
Chris Lattnerab5e0af2009-10-28 17:39:19 +00002696
2697 assert(E->getCallReturnType()->isReferenceType() &&
2698 "Can't have a scalar return unless the return type is a "
2699 "reference type!");
Mike Stump4a3999f2009-09-09 13:00:44 +00002700
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002701 return MakeAddrLValue(RV.getScalarVal(), E->getType());
Christopher Lambd91c3d42007-12-29 05:02:41 +00002702}
2703
Daniel Dunbar8d9dc4a2009-02-11 20:59:32 +00002704LValue CodeGenFunction::EmitVAArgExprLValue(const VAArgExpr *E) {
2705 // FIXME: This shouldn't require another copy.
Daniel Dunbard0bc7b92010-02-05 19:38:31 +00002706 return EmitAggExprToLValue(E);
Daniel Dunbar8d9dc4a2009-02-11 20:59:32 +00002707}
2708
Anders Carlsson3be22e22009-05-30 23:23:33 +00002709LValue CodeGenFunction::EmitCXXConstructLValue(const CXXConstructExpr *E) {
John McCall8ea46b62010-09-18 00:58:34 +00002710 assert(E->getType()->getAsCXXRecordDecl()->hasTrivialDestructor()
2711 && "binding l-value to type which needs a temporary");
Benjamin Kramer76399eb2011-09-27 21:06:10 +00002712 AggValueSlot Slot = CreateAggTemp(E->getType());
John McCall7a626f62010-09-15 10:14:12 +00002713 EmitCXXConstructExpr(E, Slot);
2714 return MakeAddrLValue(Slot.getAddr(), E->getType());
Anders Carlsson3be22e22009-05-30 23:23:33 +00002715}
2716
Anders Carlssonfd2af0c2009-05-30 23:30:54 +00002717LValue
Mike Stumpc9b231c2009-11-15 08:09:41 +00002718CodeGenFunction::EmitCXXTypeidLValue(const CXXTypeidExpr *E) {
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002719 return MakeAddrLValue(EmitCXXTypeidExpr(E), E->getType());
Mike Stumpc9b231c2009-11-15 08:09:41 +00002720}
2721
2722LValue
Anders Carlssonfd2af0c2009-05-30 23:30:54 +00002723CodeGenFunction::EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E) {
John McCall8ea46b62010-09-18 00:58:34 +00002724 AggValueSlot Slot = CreateAggTemp(E->getType(), "temp.lvalue");
John McCallcac93852011-08-26 08:02:37 +00002725 Slot.setExternallyDestructed();
John McCall8ea46b62010-09-18 00:58:34 +00002726 EmitAggExpr(E->getSubExpr(), Slot);
Peter Collingbourne702b2842011-11-27 22:09:22 +00002727 EmitCXXTemporary(E->getTemporary(), E->getType(), Slot.getAddr());
John McCall8ea46b62010-09-18 00:58:34 +00002728 return MakeAddrLValue(Slot.getAddr(), E->getType());
Anders Carlssonfd2af0c2009-05-30 23:30:54 +00002729}
2730
Eli Friedman5bc17122012-02-08 05:34:55 +00002731LValue
2732CodeGenFunction::EmitLambdaLValue(const LambdaExpr *E) {
Eli Friedman5bc17122012-02-08 05:34:55 +00002733 AggValueSlot Slot = CreateAggTemp(E->getType(), "temp.lvalue");
Eli Friedmanc370a7e2012-02-09 03:32:31 +00002734 EmitLambdaExpr(E, Slot);
Eli Friedman5bc17122012-02-08 05:34:55 +00002735 return MakeAddrLValue(Slot.getAddr(), E->getType());
2736}
2737
Daniel Dunbarc8317a42008-08-23 10:51:21 +00002738LValue CodeGenFunction::EmitObjCMessageExprLValue(const ObjCMessageExpr *E) {
Daniel Dunbarc8317a42008-08-23 10:51:21 +00002739 RValue RV = EmitObjCMessageExpr(E);
Anders Carlsson280e61f12010-06-21 20:59:55 +00002740
2741 if (!RV.isScalar())
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002742 return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
Anders Carlsson280e61f12010-06-21 20:59:55 +00002743
2744 assert(E->getMethodDecl()->getResultType()->isReferenceType() &&
2745 "Can't have a scalar return unless the return type is a "
2746 "reference type!");
2747
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002748 return MakeAddrLValue(RV.getScalarVal(), E->getType());
Daniel Dunbarc8317a42008-08-23 10:51:21 +00002749}
2750
Fariborz Jahanian9240f3d2010-06-17 19:56:20 +00002751LValue CodeGenFunction::EmitObjCSelectorLValue(const ObjCSelectorExpr *E) {
2752 llvm::Value *V =
2753 CGM.getObjCRuntime().GetSelector(Builder, E->getSelector(), true);
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002754 return MakeAddrLValue(V, E->getType());
Fariborz Jahanian9240f3d2010-06-17 19:56:20 +00002755}
2756
Daniel Dunbar722f4242009-04-22 05:08:15 +00002757llvm::Value *CodeGenFunction::EmitIvarOffset(const ObjCInterfaceDecl *Interface,
Daniel Dunbar1c64e5d2008-09-24 04:00:38 +00002758 const ObjCIvarDecl *Ivar) {
Fariborz Jahanian21fc74c2009-02-10 19:02:04 +00002759 return CGM.getObjCRuntime().EmitIvarOffset(*this, Interface, Ivar);
Daniel Dunbar1c64e5d2008-09-24 04:00:38 +00002760}
2761
Fariborz Jahanianc88a70d2009-02-03 00:09:52 +00002762LValue CodeGenFunction::EmitLValueForIvar(QualType ObjectTy,
2763 llvm::Value *BaseValue,
Daniel Dunbar1c64e5d2008-09-24 04:00:38 +00002764 const ObjCIvarDecl *Ivar,
2765 unsigned CVRQualifiers) {
Chris Lattnerc4688d22009-04-17 17:44:48 +00002766 return CGM.getObjCRuntime().EmitObjCValueForIvar(*this, ObjectTy, BaseValue,
Daniel Dunbar9ebf9512009-04-21 01:19:28 +00002767 Ivar, CVRQualifiers);
Daniel Dunbar1c64e5d2008-09-24 04:00:38 +00002768}
2769
2770LValue CodeGenFunction::EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E) {
Anders Carlssonc13b85a2008-08-25 01:53:23 +00002771 // FIXME: A lot of the code below could be shared with EmitMemberExpr.
2772 llvm::Value *BaseValue = 0;
2773 const Expr *BaseExpr = E->getBase();
John McCall8ccfcb52009-09-24 19:53:00 +00002774 Qualifiers BaseQuals;
Fariborz Jahanianc88a70d2009-02-03 00:09:52 +00002775 QualType ObjectTy;
Anders Carlssonc13b85a2008-08-25 01:53:23 +00002776 if (E->isArrow()) {
2777 BaseValue = EmitScalarExpr(BaseExpr);
Steve Naroff7cae42b2009-07-10 23:34:53 +00002778 ObjectTy = BaseExpr->getType()->getPointeeType();
John McCall8ccfcb52009-09-24 19:53:00 +00002779 BaseQuals = ObjectTy.getQualifiers();
Anders Carlssonc13b85a2008-08-25 01:53:23 +00002780 } else {
2781 LValue BaseLV = EmitLValue(BaseExpr);
2782 // FIXME: this isn't right for bitfields.
2783 BaseValue = BaseLV.getAddress();
Fariborz Jahanianc88a70d2009-02-03 00:09:52 +00002784 ObjectTy = BaseExpr->getType();
John McCall8ccfcb52009-09-24 19:53:00 +00002785 BaseQuals = ObjectTy.getQualifiers();
Anders Carlssonc13b85a2008-08-25 01:53:23 +00002786 }
Daniel Dunbar1c64e5d2008-09-24 04:00:38 +00002787
Fariborz Jahaniande1d3242009-09-16 23:11:23 +00002788 LValue LV =
John McCall8ccfcb52009-09-24 19:53:00 +00002789 EmitLValueForIvar(ObjectTy, BaseValue, E->getDecl(),
2790 BaseQuals.getCVRQualifiers());
Fariborz Jahaniande1d3242009-09-16 23:11:23 +00002791 setObjCGCLValueClass(getContext(), E, LV);
2792 return LV;
Chris Lattner4bd55962008-03-30 23:03:07 +00002793}
2794
Chris Lattnera4185c52009-04-25 19:35:26 +00002795LValue CodeGenFunction::EmitStmtExprLValue(const StmtExpr *E) {
Chris Lattnera4185c52009-04-25 19:35:26 +00002796 // Can only get l-value for message expression returning aggregate type
2797 RValue RV = EmitAnyExprToTemp(E);
Daniel Dunbarf6fb7e22010-08-21 03:08:16 +00002798 return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
Chris Lattnera4185c52009-04-25 19:35:26 +00002799}
2800
Anders Carlsson0435ed52009-12-24 19:08:58 +00002801RValue CodeGenFunction::EmitCall(QualType CalleeType, llvm::Value *Callee,
Anders Carlsson17490832009-12-24 20:40:36 +00002802 ReturnValueSlot ReturnValue,
Anders Carlsson3a9463b2009-05-27 01:22:39 +00002803 CallExpr::const_arg_iterator ArgBeg,
2804 CallExpr::const_arg_iterator ArgEnd,
2805 const Decl *TargetDecl) {
Mike Stump4a3999f2009-09-09 13:00:44 +00002806 // Get the actual function type. The callee type will always be a pointer to
2807 // function type or a block pointer type.
2808 assert(CalleeType->isFunctionPointerType() &&
Anders Carlssond8db8532009-04-07 18:53:02 +00002809 "Call must have function pointer type!");
2810
John McCall6fd4c232009-10-23 08:22:42 +00002811 CalleeType = getContext().getCanonicalType(CalleeType);
2812
John McCallab26cfa2010-02-05 21:31:56 +00002813 const FunctionType *FnType
2814 = cast<FunctionType>(cast<PointerType>(CalleeType)->getPointeeType());
Daniel Dunbarc722b852008-08-30 03:02:31 +00002815
2816 CallArgList Args;
John McCall6fd4c232009-10-23 08:22:42 +00002817 EmitCallArgs(Args, dyn_cast<FunctionProtoType>(FnType), ArgBeg, ArgEnd);
Daniel Dunbarc722b852008-08-30 03:02:31 +00002818
John McCalla729c622012-02-17 03:33:10 +00002819 const CGFunctionInfo &FnInfo =
John McCall8dda7b22012-07-07 06:41:13 +00002820 CGM.getTypes().arrangeFreeFunctionCall(Args, FnType);
John McCallcbc038a2011-09-21 08:08:30 +00002821
2822 // C99 6.5.2.2p6:
2823 // If the expression that denotes the called function has a type
2824 // that does not include a prototype, [the default argument
2825 // promotions are performed]. If the number of arguments does not
2826 // equal the number of parameters, the behavior is undefined. If
2827 // the function is defined with a type that includes a prototype,
2828 // and either the prototype ends with an ellipsis (, ...) or the
2829 // types of the arguments after promotion are not compatible with
2830 // the types of the parameters, the behavior is undefined. If the
2831 // function is defined with a type that does not include a
2832 // prototype, and the types of the arguments after promotion are
2833 // not compatible with those of the parameters after promotion,
2834 // the behavior is undefined [except in some trivial cases].
2835 // That is, in the general case, we should assume that a call
2836 // through an unprototyped function type works like a *non-variadic*
2837 // call. The way we make this work is to cast to the exact type
2838 // of the promoted arguments.
John McCalla729c622012-02-17 03:33:10 +00002839 if (isa<FunctionNoProtoType>(FnType) && !FnInfo.isVariadic()) {
2840 llvm::Type *CalleeTy = getTypes().GetFunctionType(FnInfo);
John McCallcbc038a2011-09-21 08:08:30 +00002841 CalleeTy = CalleeTy->getPointerTo();
2842 Callee = Builder.CreateBitCast(Callee, CalleeTy, "callee.knr.cast");
2843 }
2844
2845 return EmitCall(FnInfo, Callee, ReturnValue, Args, TargetDecl);
Daniel Dunbar97db84c2008-08-23 03:46:30 +00002846}
Fariborz Jahanianffba6622009-10-22 22:57:31 +00002847
Chris Lattnerab5e0af2009-10-28 17:39:19 +00002848LValue CodeGenFunction::
2849EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E) {
Eli Friedman928a5672009-11-18 05:01:17 +00002850 llvm::Value *BaseV;
John McCalle3027922010-08-25 11:45:40 +00002851 if (E->getOpcode() == BO_PtrMemI)
Eli Friedman928a5672009-11-18 05:01:17 +00002852 BaseV = EmitScalarExpr(E->getLHS());
2853 else
2854 BaseV = EmitLValue(E->getLHS()).getAddress();
Chris Lattnerab5e0af2009-10-28 17:39:19 +00002855
John McCallc134eb52010-08-31 21:07:20 +00002856 llvm::Value *OffsetV = EmitScalarExpr(E->getRHS());
2857
2858 const MemberPointerType *MPT
2859 = E->getRHS()->getType()->getAs<MemberPointerType>();
2860
2861 llvm::Value *AddV =
2862 CGM.getCXXABI().EmitMemberDataPointerAddress(*this, BaseV, OffsetV, MPT);
2863
2864 return MakeAddrLValue(AddV, MPT->getPointeeType());
Fariborz Jahanianffba6622009-10-22 22:57:31 +00002865}
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002866
2867static void
2868EmitAtomicOp(CodeGenFunction &CGF, AtomicExpr *E, llvm::Value *Dest,
2869 llvm::Value *Ptr, llvm::Value *Val1, llvm::Value *Val2,
2870 uint64_t Size, unsigned Align, llvm::AtomicOrdering Order) {
Richard Smithfeea8832012-04-12 05:08:17 +00002871 llvm::AtomicRMWInst::BinOp Op = llvm::AtomicRMWInst::Add;
2872 llvm::Instruction::BinaryOps PostOp = (llvm::Instruction::BinaryOps)0;
2873
2874 switch (E->getOp()) {
2875 case AtomicExpr::AO__c11_atomic_init:
2876 llvm_unreachable("Already handled!");
2877
2878 case AtomicExpr::AO__c11_atomic_compare_exchange_strong:
2879 case AtomicExpr::AO__c11_atomic_compare_exchange_weak:
2880 case AtomicExpr::AO__atomic_compare_exchange:
2881 case AtomicExpr::AO__atomic_compare_exchange_n: {
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002882 // Note that cmpxchg only supports specifying one ordering and
2883 // doesn't support weak cmpxchg, at least at the moment.
2884 llvm::LoadInst *LoadVal1 = CGF.Builder.CreateLoad(Val1);
2885 LoadVal1->setAlignment(Align);
2886 llvm::LoadInst *LoadVal2 = CGF.Builder.CreateLoad(Val2);
2887 LoadVal2->setAlignment(Align);
2888 llvm::AtomicCmpXchgInst *CXI =
2889 CGF.Builder.CreateAtomicCmpXchg(Ptr, LoadVal1, LoadVal2, Order);
2890 CXI->setVolatile(E->isVolatile());
2891 llvm::StoreInst *StoreVal1 = CGF.Builder.CreateStore(CXI, Val1);
2892 StoreVal1->setAlignment(Align);
2893 llvm::Value *Cmp = CGF.Builder.CreateICmpEQ(CXI, LoadVal1);
2894 CGF.EmitStoreOfScalar(Cmp, CGF.MakeAddrLValue(Dest, E->getType()));
2895 return;
2896 }
2897
Richard Smithfeea8832012-04-12 05:08:17 +00002898 case AtomicExpr::AO__c11_atomic_load:
2899 case AtomicExpr::AO__atomic_load_n:
2900 case AtomicExpr::AO__atomic_load: {
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002901 llvm::LoadInst *Load = CGF.Builder.CreateLoad(Ptr);
2902 Load->setAtomic(Order);
2903 Load->setAlignment(Size);
2904 Load->setVolatile(E->isVolatile());
2905 llvm::StoreInst *StoreDest = CGF.Builder.CreateStore(Load, Dest);
2906 StoreDest->setAlignment(Align);
2907 return;
2908 }
2909
Richard Smithfeea8832012-04-12 05:08:17 +00002910 case AtomicExpr::AO__c11_atomic_store:
2911 case AtomicExpr::AO__atomic_store:
2912 case AtomicExpr::AO__atomic_store_n: {
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002913 assert(!Dest && "Store does not return a value");
2914 llvm::LoadInst *LoadVal1 = CGF.Builder.CreateLoad(Val1);
2915 LoadVal1->setAlignment(Align);
2916 llvm::StoreInst *Store = CGF.Builder.CreateStore(LoadVal1, Ptr);
2917 Store->setAtomic(Order);
2918 Store->setAlignment(Size);
2919 Store->setVolatile(E->isVolatile());
2920 return;
2921 }
2922
Richard Smithfeea8832012-04-12 05:08:17 +00002923 case AtomicExpr::AO__c11_atomic_exchange:
2924 case AtomicExpr::AO__atomic_exchange_n:
2925 case AtomicExpr::AO__atomic_exchange:
2926 Op = llvm::AtomicRMWInst::Xchg;
2927 break;
2928
2929 case AtomicExpr::AO__atomic_add_fetch:
2930 PostOp = llvm::Instruction::Add;
2931 // Fall through.
2932 case AtomicExpr::AO__c11_atomic_fetch_add:
2933 case AtomicExpr::AO__atomic_fetch_add:
2934 Op = llvm::AtomicRMWInst::Add;
2935 break;
2936
2937 case AtomicExpr::AO__atomic_sub_fetch:
2938 PostOp = llvm::Instruction::Sub;
2939 // Fall through.
2940 case AtomicExpr::AO__c11_atomic_fetch_sub:
2941 case AtomicExpr::AO__atomic_fetch_sub:
2942 Op = llvm::AtomicRMWInst::Sub;
2943 break;
2944
2945 case AtomicExpr::AO__atomic_and_fetch:
2946 PostOp = llvm::Instruction::And;
2947 // Fall through.
2948 case AtomicExpr::AO__c11_atomic_fetch_and:
2949 case AtomicExpr::AO__atomic_fetch_and:
2950 Op = llvm::AtomicRMWInst::And;
2951 break;
2952
2953 case AtomicExpr::AO__atomic_or_fetch:
2954 PostOp = llvm::Instruction::Or;
2955 // Fall through.
2956 case AtomicExpr::AO__c11_atomic_fetch_or:
2957 case AtomicExpr::AO__atomic_fetch_or:
2958 Op = llvm::AtomicRMWInst::Or;
2959 break;
2960
2961 case AtomicExpr::AO__atomic_xor_fetch:
2962 PostOp = llvm::Instruction::Xor;
2963 // Fall through.
2964 case AtomicExpr::AO__c11_atomic_fetch_xor:
2965 case AtomicExpr::AO__atomic_fetch_xor:
2966 Op = llvm::AtomicRMWInst::Xor;
2967 break;
Richard Smithd65cee92012-04-13 06:31:38 +00002968
2969 case AtomicExpr::AO__atomic_nand_fetch:
2970 PostOp = llvm::Instruction::And;
2971 // Fall through.
2972 case AtomicExpr::AO__atomic_fetch_nand:
2973 Op = llvm::AtomicRMWInst::Nand;
2974 break;
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002975 }
Richard Smithfeea8832012-04-12 05:08:17 +00002976
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002977 llvm::LoadInst *LoadVal1 = CGF.Builder.CreateLoad(Val1);
2978 LoadVal1->setAlignment(Align);
2979 llvm::AtomicRMWInst *RMWI =
2980 CGF.Builder.CreateAtomicRMW(Op, Ptr, LoadVal1, Order);
2981 RMWI->setVolatile(E->isVolatile());
Richard Smithfeea8832012-04-12 05:08:17 +00002982
2983 // For __atomic_*_fetch operations, perform the operation again to
2984 // determine the value which was written.
2985 llvm::Value *Result = RMWI;
2986 if (PostOp)
2987 Result = CGF.Builder.CreateBinOp(PostOp, RMWI, LoadVal1);
Richard Smithd65cee92012-04-13 06:31:38 +00002988 if (E->getOp() == AtomicExpr::AO__atomic_nand_fetch)
2989 Result = CGF.Builder.CreateNot(Result);
Richard Smithfeea8832012-04-12 05:08:17 +00002990 llvm::StoreInst *StoreDest = CGF.Builder.CreateStore(Result, Dest);
Eli Friedmandf14b3a2011-10-11 02:20:01 +00002991 StoreDest->setAlignment(Align);
2992}
2993
2994// This function emits any expression (scalar, complex, or aggregate)
2995// into a temporary alloca.
2996static llvm::Value *
2997EmitValToTemp(CodeGenFunction &CGF, Expr *E) {
2998 llvm::Value *DeclPtr = CGF.CreateMemTemp(E->getType(), ".atomictmp");
Chad Rosier615ed1a2012-03-29 17:37:10 +00002999 CGF.EmitAnyExprToMem(E, DeclPtr, E->getType().getQualifiers(),
3000 /*Init*/ true);
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003001 return DeclPtr;
3002}
3003
3004static RValue ConvertTempToRValue(CodeGenFunction &CGF, QualType Ty,
3005 llvm::Value *Dest) {
3006 if (Ty->isAnyComplexType())
3007 return RValue::getComplex(CGF.LoadComplexFromAddr(Dest, false));
3008 if (CGF.hasAggregateLLVMType(Ty))
3009 return RValue::getAggregate(Dest);
3010 return RValue::get(CGF.EmitLoadOfScalar(CGF.MakeAddrLValue(Dest, Ty)));
3011}
3012
3013RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E, llvm::Value *Dest) {
3014 QualType AtomicTy = E->getPtr()->getType()->getPointeeType();
Richard Smithfeea8832012-04-12 05:08:17 +00003015 QualType MemTy = AtomicTy;
3016 if (const AtomicType *AT = AtomicTy->getAs<AtomicType>())
3017 MemTy = AT->getValueType();
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003018 CharUnits sizeChars = getContext().getTypeSizeInChars(AtomicTy);
3019 uint64_t Size = sizeChars.getQuantity();
3020 CharUnits alignChars = getContext().getTypeAlignInChars(AtomicTy);
3021 unsigned Align = alignChars.getQuantity();
Eli Friedman4b72fdd2011-10-14 20:59:01 +00003022 unsigned MaxInlineWidth =
3023 getContext().getTargetInfo().getMaxAtomicInlineWidth();
3024 bool UseLibcall = (Size != Align || Size > MaxInlineWidth);
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003025
David Chisnallfa35df62012-01-16 17:27:18 +00003026
3027
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003028 llvm::Value *Ptr, *Order, *OrderFail = 0, *Val1 = 0, *Val2 = 0;
3029 Ptr = EmitScalarExpr(E->getPtr());
David Chisnallfa35df62012-01-16 17:27:18 +00003030
Richard Smithfeea8832012-04-12 05:08:17 +00003031 if (E->getOp() == AtomicExpr::AO__c11_atomic_init) {
David Chisnallfa35df62012-01-16 17:27:18 +00003032 assert(!Dest && "Init does not return a value");
David Chisnalleb9496e2012-04-11 17:24:05 +00003033 if (!hasAggregateLLVMType(E->getVal1()->getType())) {
Douglas Gregor298f43d2012-04-12 20:42:30 +00003034 QualType PointeeType
3035 = E->getPtr()->getType()->getAs<PointerType>()->getPointeeType();
3036 EmitScalarInit(EmitScalarExpr(E->getVal1()),
3037 LValue::MakeAddr(Ptr, PointeeType, alignChars,
3038 getContext()));
David Chisnalleb9496e2012-04-11 17:24:05 +00003039 } else if (E->getType()->isAnyComplexType()) {
3040 EmitComplexExprIntoAddr(E->getVal1(), Ptr, E->isVolatile());
3041 } else {
3042 AggValueSlot Slot = AggValueSlot::forAddr(Ptr, alignChars,
3043 AtomicTy.getQualifiers(),
3044 AggValueSlot::IsNotDestructed,
3045 AggValueSlot::DoesNotNeedGCBarriers,
3046 AggValueSlot::IsNotAliased);
3047 EmitAggExpr(E->getVal1(), Slot);
3048 }
David Chisnallfa35df62012-01-16 17:27:18 +00003049 return RValue::get(0);
3050 }
3051
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003052 Order = EmitScalarExpr(E->getOrder());
Richard Smithfeea8832012-04-12 05:08:17 +00003053
3054 switch (E->getOp()) {
3055 case AtomicExpr::AO__c11_atomic_init:
3056 llvm_unreachable("Already handled!");
3057
3058 case AtomicExpr::AO__c11_atomic_load:
3059 case AtomicExpr::AO__atomic_load_n:
3060 break;
3061
3062 case AtomicExpr::AO__atomic_load:
3063 Dest = EmitScalarExpr(E->getVal1());
3064 break;
3065
3066 case AtomicExpr::AO__atomic_store:
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003067 Val1 = EmitScalarExpr(E->getVal1());
Richard Smithfeea8832012-04-12 05:08:17 +00003068 break;
3069
3070 case AtomicExpr::AO__atomic_exchange:
3071 Val1 = EmitScalarExpr(E->getVal1());
3072 Dest = EmitScalarExpr(E->getVal2());
3073 break;
3074
3075 case AtomicExpr::AO__c11_atomic_compare_exchange_strong:
3076 case AtomicExpr::AO__c11_atomic_compare_exchange_weak:
3077 case AtomicExpr::AO__atomic_compare_exchange_n:
3078 case AtomicExpr::AO__atomic_compare_exchange:
3079 Val1 = EmitScalarExpr(E->getVal1());
3080 if (E->getOp() == AtomicExpr::AO__atomic_compare_exchange)
3081 Val2 = EmitScalarExpr(E->getVal2());
3082 else
3083 Val2 = EmitValToTemp(*this, E->getVal2());
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003084 OrderFail = EmitScalarExpr(E->getOrderFail());
Richard Smithfeea8832012-04-12 05:08:17 +00003085 // Evaluate and discard the 'weak' argument.
3086 if (E->getNumSubExprs() == 6)
3087 EmitScalarExpr(E->getWeak());
3088 break;
3089
3090 case AtomicExpr::AO__c11_atomic_fetch_add:
3091 case AtomicExpr::AO__c11_atomic_fetch_sub:
Richard Smithfeea8832012-04-12 05:08:17 +00003092 if (MemTy->isPointerType()) {
3093 // For pointer arithmetic, we're required to do a bit of math:
3094 // adding 1 to an int* is not the same as adding 1 to a uintptr_t.
Richard Smith01ba47d2012-04-13 00:45:38 +00003095 // ... but only for the C11 builtins. The GNU builtins expect the
3096 // user to multiply by sizeof(T).
Richard Smithfeea8832012-04-12 05:08:17 +00003097 QualType Val1Ty = E->getVal1()->getType();
3098 llvm::Value *Val1Scalar = EmitScalarExpr(E->getVal1());
3099 CharUnits PointeeIncAmt =
3100 getContext().getTypeSizeInChars(MemTy->getPointeeType());
3101 Val1Scalar = Builder.CreateMul(Val1Scalar, CGM.getSize(PointeeIncAmt));
3102 Val1 = CreateMemTemp(Val1Ty, ".atomictmp");
3103 EmitStoreOfScalar(Val1Scalar, MakeAddrLValue(Val1, Val1Ty));
3104 break;
3105 }
3106 // Fall through.
Richard Smith01ba47d2012-04-13 00:45:38 +00003107 case AtomicExpr::AO__atomic_fetch_add:
3108 case AtomicExpr::AO__atomic_fetch_sub:
3109 case AtomicExpr::AO__atomic_add_fetch:
3110 case AtomicExpr::AO__atomic_sub_fetch:
Richard Smithfeea8832012-04-12 05:08:17 +00003111 case AtomicExpr::AO__c11_atomic_store:
3112 case AtomicExpr::AO__c11_atomic_exchange:
3113 case AtomicExpr::AO__atomic_store_n:
3114 case AtomicExpr::AO__atomic_exchange_n:
3115 case AtomicExpr::AO__c11_atomic_fetch_and:
3116 case AtomicExpr::AO__c11_atomic_fetch_or:
3117 case AtomicExpr::AO__c11_atomic_fetch_xor:
3118 case AtomicExpr::AO__atomic_fetch_and:
3119 case AtomicExpr::AO__atomic_fetch_or:
3120 case AtomicExpr::AO__atomic_fetch_xor:
Richard Smithd65cee92012-04-13 06:31:38 +00003121 case AtomicExpr::AO__atomic_fetch_nand:
Richard Smithfeea8832012-04-12 05:08:17 +00003122 case AtomicExpr::AO__atomic_and_fetch:
3123 case AtomicExpr::AO__atomic_or_fetch:
3124 case AtomicExpr::AO__atomic_xor_fetch:
Richard Smithd65cee92012-04-13 06:31:38 +00003125 case AtomicExpr::AO__atomic_nand_fetch:
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003126 Val1 = EmitValToTemp(*this, E->getVal1());
Richard Smithfeea8832012-04-12 05:08:17 +00003127 break;
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003128 }
3129
Richard Smithfeea8832012-04-12 05:08:17 +00003130 if (!E->getType()->isVoidType() && !Dest)
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003131 Dest = CreateMemTemp(E->getType(), ".atomicdst");
3132
David Chisnalldb365f32012-03-29 18:01:11 +00003133 // Use a library call. See: http://gcc.gnu.org/wiki/Atomic/GCCMM/LIbrary .
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003134 if (UseLibcall) {
David Chisnalldb365f32012-03-29 18:01:11 +00003135
3136 llvm::SmallVector<QualType, 5> Params;
3137 CallArgList Args;
3138 // Size is always the first parameter
3139 Args.add(RValue::get(llvm::ConstantInt::get(SizeTy, Size)),
3140 getContext().getSizeType());
3141 // Atomic address is always the second parameter
3142 Args.add(RValue::get(EmitCastToVoidPtr(Ptr)),
3143 getContext().VoidPtrTy);
3144
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003145 const char* LibCallName;
David Chisnalldb365f32012-03-29 18:01:11 +00003146 QualType RetTy = getContext().VoidTy;
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003147 switch (E->getOp()) {
David Chisnalldb365f32012-03-29 18:01:11 +00003148 // There is only one libcall for compare an exchange, because there is no
3149 // optimisation benefit possible from a libcall version of a weak compare
3150 // and exchange.
3151 // bool __atomic_compare_exchange(size_t size, void *obj, void *expected,
Richard Smithfeea8832012-04-12 05:08:17 +00003152 // void *desired, int success, int failure)
3153 case AtomicExpr::AO__c11_atomic_compare_exchange_weak:
3154 case AtomicExpr::AO__c11_atomic_compare_exchange_strong:
3155 case AtomicExpr::AO__atomic_compare_exchange:
3156 case AtomicExpr::AO__atomic_compare_exchange_n:
David Chisnalldb365f32012-03-29 18:01:11 +00003157 LibCallName = "__atomic_compare_exchange";
3158 RetTy = getContext().BoolTy;
3159 Args.add(RValue::get(EmitCastToVoidPtr(Val1)),
3160 getContext().VoidPtrTy);
3161 Args.add(RValue::get(EmitCastToVoidPtr(Val2)),
3162 getContext().VoidPtrTy);
3163 Args.add(RValue::get(Order),
3164 getContext().IntTy);
3165 Order = OrderFail;
3166 break;
3167 // void __atomic_exchange(size_t size, void *mem, void *val, void *return,
3168 // int order)
Richard Smithfeea8832012-04-12 05:08:17 +00003169 case AtomicExpr::AO__c11_atomic_exchange:
3170 case AtomicExpr::AO__atomic_exchange_n:
3171 case AtomicExpr::AO__atomic_exchange:
David Chisnalldb365f32012-03-29 18:01:11 +00003172 LibCallName = "__atomic_exchange";
3173 Args.add(RValue::get(EmitCastToVoidPtr(Val1)),
3174 getContext().VoidPtrTy);
3175 Args.add(RValue::get(EmitCastToVoidPtr(Dest)),
3176 getContext().VoidPtrTy);
3177 break;
3178 // void __atomic_store(size_t size, void *mem, void *val, int order)
Richard Smithfeea8832012-04-12 05:08:17 +00003179 case AtomicExpr::AO__c11_atomic_store:
3180 case AtomicExpr::AO__atomic_store:
3181 case AtomicExpr::AO__atomic_store_n:
David Chisnalldb365f32012-03-29 18:01:11 +00003182 LibCallName = "__atomic_store";
3183 Args.add(RValue::get(EmitCastToVoidPtr(Val1)),
3184 getContext().VoidPtrTy);
3185 break;
3186 // void __atomic_load(size_t size, void *mem, void *return, int order)
Richard Smithfeea8832012-04-12 05:08:17 +00003187 case AtomicExpr::AO__c11_atomic_load:
3188 case AtomicExpr::AO__atomic_load:
3189 case AtomicExpr::AO__atomic_load_n:
David Chisnalldb365f32012-03-29 18:01:11 +00003190 LibCallName = "__atomic_load";
3191 Args.add(RValue::get(EmitCastToVoidPtr(Dest)),
3192 getContext().VoidPtrTy);
3193 break;
3194#if 0
3195 // These are only defined for 1-16 byte integers. It is not clear what
3196 // their semantics would be on anything else...
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003197 case AtomicExpr::Add: LibCallName = "__atomic_fetch_add_generic"; break;
3198 case AtomicExpr::Sub: LibCallName = "__atomic_fetch_sub_generic"; break;
3199 case AtomicExpr::And: LibCallName = "__atomic_fetch_and_generic"; break;
3200 case AtomicExpr::Or: LibCallName = "__atomic_fetch_or_generic"; break;
3201 case AtomicExpr::Xor: LibCallName = "__atomic_fetch_xor_generic"; break;
David Chisnalldb365f32012-03-29 18:01:11 +00003202#endif
3203 default: return EmitUnsupportedRValue(E, "atomic library call");
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003204 }
David Chisnalldb365f32012-03-29 18:01:11 +00003205 // order is always the last parameter
3206 Args.add(RValue::get(Order),
3207 getContext().IntTy);
3208
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003209 const CGFunctionInfo &FuncInfo =
John McCall8dda7b22012-07-07 06:41:13 +00003210 CGM.getTypes().arrangeFreeFunctionCall(RetTy, Args,
David Chisnalldb365f32012-03-29 18:01:11 +00003211 FunctionType::ExtInfo(), RequiredArgs::All);
3212 llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FuncInfo);
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003213 llvm::Constant *Func = CGM.CreateRuntimeFunction(FTy, LibCallName);
3214 RValue Res = EmitCall(FuncInfo, Func, ReturnValueSlot(), Args);
3215 if (E->isCmpXChg())
3216 return Res;
Richard Smithfeea8832012-04-12 05:08:17 +00003217 if (E->getType()->isVoidType())
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003218 return RValue::get(0);
3219 return ConvertTempToRValue(*this, E->getType(), Dest);
3220 }
David Chisnalldb365f32012-03-29 18:01:11 +00003221
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003222 llvm::Type *IPtrTy =
3223 llvm::IntegerType::get(getLLVMContext(), Size * 8)->getPointerTo();
3224 llvm::Value *OrigDest = Dest;
3225 Ptr = Builder.CreateBitCast(Ptr, IPtrTy);
3226 if (Val1) Val1 = Builder.CreateBitCast(Val1, IPtrTy);
3227 if (Val2) Val2 = Builder.CreateBitCast(Val2, IPtrTy);
3228 if (Dest && !E->isCmpXChg()) Dest = Builder.CreateBitCast(Dest, IPtrTy);
3229
3230 if (isa<llvm::ConstantInt>(Order)) {
3231 int ord = cast<llvm::ConstantInt>(Order)->getZExtValue();
3232 switch (ord) {
3233 case 0: // memory_order_relaxed
3234 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3235 llvm::Monotonic);
3236 break;
3237 case 1: // memory_order_consume
3238 case 2: // memory_order_acquire
3239 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3240 llvm::Acquire);
3241 break;
3242 case 3: // memory_order_release
3243 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3244 llvm::Release);
3245 break;
3246 case 4: // memory_order_acq_rel
3247 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3248 llvm::AcquireRelease);
3249 break;
3250 case 5: // memory_order_seq_cst
3251 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3252 llvm::SequentiallyConsistent);
3253 break;
3254 default: // invalid order
3255 // We should not ever get here normally, but it's hard to
3256 // enforce that in general.
Richard Smithfeea8832012-04-12 05:08:17 +00003257 break;
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003258 }
Richard Smithfeea8832012-04-12 05:08:17 +00003259 if (E->getType()->isVoidType())
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003260 return RValue::get(0);
3261 return ConvertTempToRValue(*this, E->getType(), OrigDest);
3262 }
3263
3264 // Long case, when Order isn't obviously constant.
3265
Richard Smithfeea8832012-04-12 05:08:17 +00003266 bool IsStore = E->getOp() == AtomicExpr::AO__c11_atomic_store ||
3267 E->getOp() == AtomicExpr::AO__atomic_store ||
3268 E->getOp() == AtomicExpr::AO__atomic_store_n;
3269 bool IsLoad = E->getOp() == AtomicExpr::AO__c11_atomic_load ||
3270 E->getOp() == AtomicExpr::AO__atomic_load ||
3271 E->getOp() == AtomicExpr::AO__atomic_load_n;
3272
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003273 // Create all the relevant BB's
Eli Friedmanc2025562011-10-11 20:00:47 +00003274 llvm::BasicBlock *MonotonicBB = 0, *AcquireBB = 0, *ReleaseBB = 0,
3275 *AcqRelBB = 0, *SeqCstBB = 0;
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003276 MonotonicBB = createBasicBlock("monotonic", CurFn);
Richard Smithfeea8832012-04-12 05:08:17 +00003277 if (!IsStore)
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003278 AcquireBB = createBasicBlock("acquire", CurFn);
Richard Smithfeea8832012-04-12 05:08:17 +00003279 if (!IsLoad)
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003280 ReleaseBB = createBasicBlock("release", CurFn);
Richard Smithfeea8832012-04-12 05:08:17 +00003281 if (!IsLoad && !IsStore)
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003282 AcqRelBB = createBasicBlock("acqrel", CurFn);
3283 SeqCstBB = createBasicBlock("seqcst", CurFn);
3284 llvm::BasicBlock *ContBB = createBasicBlock("atomic.continue", CurFn);
3285
3286 // Create the switch for the split
3287 // MonotonicBB is arbitrarily chosen as the default case; in practice, this
3288 // doesn't matter unless someone is crazy enough to use something that
3289 // doesn't fold to a constant for the ordering.
3290 Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
3291 llvm::SwitchInst *SI = Builder.CreateSwitch(Order, MonotonicBB);
3292
3293 // Emit all the different atomics
3294 Builder.SetInsertPoint(MonotonicBB);
3295 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3296 llvm::Monotonic);
3297 Builder.CreateBr(ContBB);
Richard Smithfeea8832012-04-12 05:08:17 +00003298 if (!IsStore) {
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003299 Builder.SetInsertPoint(AcquireBB);
3300 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3301 llvm::Acquire);
3302 Builder.CreateBr(ContBB);
3303 SI->addCase(Builder.getInt32(1), AcquireBB);
3304 SI->addCase(Builder.getInt32(2), AcquireBB);
3305 }
Richard Smithfeea8832012-04-12 05:08:17 +00003306 if (!IsLoad) {
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003307 Builder.SetInsertPoint(ReleaseBB);
3308 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3309 llvm::Release);
3310 Builder.CreateBr(ContBB);
3311 SI->addCase(Builder.getInt32(3), ReleaseBB);
3312 }
Richard Smithfeea8832012-04-12 05:08:17 +00003313 if (!IsLoad && !IsStore) {
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003314 Builder.SetInsertPoint(AcqRelBB);
3315 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3316 llvm::AcquireRelease);
3317 Builder.CreateBr(ContBB);
3318 SI->addCase(Builder.getInt32(4), AcqRelBB);
3319 }
3320 Builder.SetInsertPoint(SeqCstBB);
3321 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3322 llvm::SequentiallyConsistent);
3323 Builder.CreateBr(ContBB);
3324 SI->addCase(Builder.getInt32(5), SeqCstBB);
3325
3326 // Cleanup and return
3327 Builder.SetInsertPoint(ContBB);
Richard Smithfeea8832012-04-12 05:08:17 +00003328 if (E->getType()->isVoidType())
Eli Friedmandf14b3a2011-10-11 02:20:01 +00003329 return RValue::get(0);
3330 return ConvertTempToRValue(*this, E->getType(), OrigDest);
3331}
Peter Collingbourne95fd2ca2011-10-27 19:19:51 +00003332
Duncan Sandse81111c2012-04-10 08:23:07 +00003333void CodeGenFunction::SetFPAccuracy(llvm::Value *Val, float Accuracy) {
Peter Collingbourne95fd2ca2011-10-27 19:19:51 +00003334 assert(Val->getType()->isFPOrFPVectorTy());
Duncan Sandse81111c2012-04-10 08:23:07 +00003335 if (Accuracy == 0.0 || !isa<llvm::Instruction>(Val))
Peter Collingbourne95fd2ca2011-10-27 19:19:51 +00003336 return;
3337
Duncan Sands65229ed2012-04-16 16:29:47 +00003338 llvm::MDBuilder MDHelper(getLLVMContext());
3339 llvm::MDNode *Node = MDHelper.createFPMath(Accuracy);
Peter Collingbourne95fd2ca2011-10-27 19:19:51 +00003340
Duncan Sands6fc46192012-04-14 12:37:26 +00003341 cast<llvm::Instruction>(Val)->setMetadata(llvm::LLVMContext::MD_fpmath, Node);
Peter Collingbourne95fd2ca2011-10-27 19:19:51 +00003342}
John McCallfe96e0b2011-11-06 09:01:30 +00003343
3344namespace {
3345 struct LValueOrRValue {
3346 LValue LV;
3347 RValue RV;
3348 };
3349}
3350
3351static LValueOrRValue emitPseudoObjectExpr(CodeGenFunction &CGF,
3352 const PseudoObjectExpr *E,
3353 bool forLValue,
3354 AggValueSlot slot) {
3355 llvm::SmallVector<CodeGenFunction::OpaqueValueMappingData, 4> opaques;
3356
3357 // Find the result expression, if any.
3358 const Expr *resultExpr = E->getResultExpr();
3359 LValueOrRValue result;
3360
3361 for (PseudoObjectExpr::const_semantics_iterator
3362 i = E->semantics_begin(), e = E->semantics_end(); i != e; ++i) {
3363 const Expr *semantic = *i;
3364
3365 // If this semantic expression is an opaque value, bind it
3366 // to the result of its source expression.
3367 if (const OpaqueValueExpr *ov = dyn_cast<OpaqueValueExpr>(semantic)) {
3368
3369 // If this is the result expression, we may need to evaluate
3370 // directly into the slot.
3371 typedef CodeGenFunction::OpaqueValueMappingData OVMA;
3372 OVMA opaqueData;
3373 if (ov == resultExpr && ov->isRValue() && !forLValue &&
3374 CodeGenFunction::hasAggregateLLVMType(ov->getType()) &&
3375 !ov->getType()->isAnyComplexType()) {
3376 CGF.EmitAggExpr(ov->getSourceExpr(), slot);
3377
3378 LValue LV = CGF.MakeAddrLValue(slot.getAddr(), ov->getType());
3379 opaqueData = OVMA::bind(CGF, ov, LV);
3380 result.RV = slot.asRValue();
3381
3382 // Otherwise, emit as normal.
3383 } else {
3384 opaqueData = OVMA::bind(CGF, ov, ov->getSourceExpr());
3385
3386 // If this is the result, also evaluate the result now.
3387 if (ov == resultExpr) {
3388 if (forLValue)
3389 result.LV = CGF.EmitLValue(ov);
3390 else
3391 result.RV = CGF.EmitAnyExpr(ov, slot);
3392 }
3393 }
3394
3395 opaques.push_back(opaqueData);
3396
3397 // Otherwise, if the expression is the result, evaluate it
3398 // and remember the result.
3399 } else if (semantic == resultExpr) {
3400 if (forLValue)
3401 result.LV = CGF.EmitLValue(semantic);
3402 else
3403 result.RV = CGF.EmitAnyExpr(semantic, slot);
3404
3405 // Otherwise, evaluate the expression in an ignored context.
3406 } else {
3407 CGF.EmitIgnoredExpr(semantic);
3408 }
3409 }
3410
3411 // Unbind all the opaques now.
3412 for (unsigned i = 0, e = opaques.size(); i != e; ++i)
3413 opaques[i].unbind(CGF);
3414
3415 return result;
3416}
3417
3418RValue CodeGenFunction::EmitPseudoObjectRValue(const PseudoObjectExpr *E,
3419 AggValueSlot slot) {
3420 return emitPseudoObjectExpr(*this, E, false, slot).RV;
3421}
3422
3423LValue CodeGenFunction::EmitPseudoObjectLValue(const PseudoObjectExpr *E) {
3424 return emitPseudoObjectExpr(*this, E, true, AggValueSlot::ignored()).LV;
3425}