blob: b4d0e1399304a81b24a74d69f4432697c4ea1c0d [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- CGExpr.cpp - Emit LLVM Code from Expressions ---------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This contains code to emit Expr nodes as LLVM code.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CodeGenFunction.h"
15#include "CodeGenModule.h"
Daniel Dunbar0dbe2272008-09-08 21:33:45 +000016#include "CGCall.h"
John McCall4c40d982010-08-31 07:33:07 +000017#include "CGCXXABI.h"
Daniel Dunbar198bcb42010-03-31 01:09:11 +000018#include "CGRecordLayout.h"
Daniel Dunbaraf2f62c2008-08-13 00:59:25 +000019#include "CGObjCRuntime.h"
Daniel Dunbarde7fb842008-08-11 05:00:27 +000020#include "clang/AST/ASTContext.h"
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000021#include "clang/AST/DeclObjC.h"
Mike Stump15037ca2009-12-15 00:35:12 +000022#include "llvm/Intrinsics.h"
Chandler Carruth06057ce2010-06-15 23:19:56 +000023#include "clang/Frontend/CodeGenOptions.h"
Eli Friedman316bb1b2008-05-17 20:03:47 +000024#include "llvm/Target/TargetData.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000025using namespace clang;
26using namespace CodeGen;
27
28//===--------------------------------------------------------------------===//
29// Miscellaneous Helper Methods
30//===--------------------------------------------------------------------===//
31
32/// CreateTempAlloca - This creates a alloca and inserts it into the entry
33/// block.
34llvm::AllocaInst *CodeGenFunction::CreateTempAlloca(const llvm::Type *Ty,
Daniel Dunbar259e9cc2009-10-19 01:21:05 +000035 const llvm::Twine &Name) {
Chris Lattnerf1466842009-03-22 00:24:14 +000036 if (!Builder.isNamePreserving())
Daniel Dunbar259e9cc2009-10-19 01:21:05 +000037 return new llvm::AllocaInst(Ty, 0, "", AllocaInsertPt);
Devang Pateld35e2e02009-10-12 22:29:02 +000038 return new llvm::AllocaInst(Ty, 0, Name, AllocaInsertPt);
Reid Spencer5f016e22007-07-11 17:01:13 +000039}
40
John McCallac418162010-04-22 01:10:34 +000041void CodeGenFunction::InitTempAlloca(llvm::AllocaInst *Var,
42 llvm::Value *Init) {
43 llvm::StoreInst *Store = new llvm::StoreInst(Init, Var);
44 llvm::BasicBlock *Block = AllocaInsertPt->getParent();
45 Block->getInstList().insertAfter(&*AllocaInsertPt, Store);
46}
47
Chris Lattner121b3fa2010-07-05 20:21:00 +000048llvm::AllocaInst *CodeGenFunction::CreateIRTemp(QualType Ty,
49 const llvm::Twine &Name) {
Daniel Dunbar9bd4da22010-02-16 19:44:13 +000050 llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertType(Ty), Name);
51 // FIXME: Should we prefer the preferred type alignment here?
52 CharUnits Align = getContext().getTypeAlignInChars(Ty);
53 Alloc->setAlignment(Align.getQuantity());
54 return Alloc;
55}
56
Chris Lattner121b3fa2010-07-05 20:21:00 +000057llvm::AllocaInst *CodeGenFunction::CreateMemTemp(QualType Ty,
58 const llvm::Twine &Name) {
Daniel Dunbar195337d2010-02-09 02:48:28 +000059 llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertTypeForMem(Ty), Name);
60 // FIXME: Should we prefer the preferred type alignment here?
61 CharUnits Align = getContext().getTypeAlignInChars(Ty);
62 Alloc->setAlignment(Align.getQuantity());
63 return Alloc;
64}
65
Reid Spencer5f016e22007-07-11 17:01:13 +000066/// EvaluateExprAsBool - Perform the usual unary conversions on the specified
67/// expression and compare the result against zero, returning an Int1Ty value.
68llvm::Value *CodeGenFunction::EvaluateExprAsBool(const Expr *E) {
John McCall0bab0cd2010-08-23 01:21:21 +000069 if (const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>()) {
John McCalld608cdb2010-08-22 10:59:02 +000070 llvm::Value *MemPtr = EmitScalarExpr(E);
John McCall0bab0cd2010-08-23 01:21:21 +000071 return CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, MemPtr, MPT);
Eli Friedman3a173702009-12-11 09:26:29 +000072 }
John McCall0bab0cd2010-08-23 01:21:21 +000073
74 QualType BoolTy = getContext().BoolTy;
Chris Lattner9b2dc282008-04-04 16:54:41 +000075 if (!E->getType()->isAnyComplexType())
Chris Lattner9069fa22007-08-26 16:46:58 +000076 return EmitScalarConversion(EmitScalarExpr(E), E->getType(), BoolTy);
Reid Spencer5f016e22007-07-11 17:01:13 +000077
Chris Lattner9069fa22007-08-26 16:46:58 +000078 return EmitComplexToScalarConversion(EmitComplexExpr(E), E->getType(),BoolTy);
Reid Spencer5f016e22007-07-11 17:01:13 +000079}
80
Chris Lattner9b655512007-08-31 22:49:20 +000081/// EmitAnyExpr - Emit code to compute the specified expression which can have
82/// any type. The result is returned as an RValue struct. If this is an
Mike Stumpdb52dcd2009-09-09 13:00:44 +000083/// aggregate expression, the aggloc/agglocvolatile arguments indicate where the
84/// result should be returned.
85RValue CodeGenFunction::EmitAnyExpr(const Expr *E, llvm::Value *AggLoc,
Anders Carlsson14c5cbf2009-08-16 07:36:22 +000086 bool IsAggLocVolatile, bool IgnoreResult,
87 bool IsInitializer) {
Chris Lattner9b655512007-08-31 22:49:20 +000088 if (!hasAggregateLLVMType(E->getType()))
Mike Stump7f79f9b2009-05-29 15:46:01 +000089 return RValue::get(EmitScalarExpr(E, IgnoreResult));
Chris Lattner9b2dc282008-04-04 16:54:41 +000090 else if (E->getType()->isAnyComplexType())
Mike Stump7f79f9b2009-05-29 15:46:01 +000091 return RValue::getComplex(EmitComplexExpr(E, false, false,
92 IgnoreResult, IgnoreResult));
Mike Stumpdb52dcd2009-09-09 13:00:44 +000093
Anders Carlsson14c5cbf2009-08-16 07:36:22 +000094 EmitAggExpr(E, AggLoc, IsAggLocVolatile, IgnoreResult, IsInitializer);
95 return RValue::getAggregate(AggLoc, IsAggLocVolatile);
Chris Lattner9b655512007-08-31 22:49:20 +000096}
97
Mike Stumpdb52dcd2009-09-09 13:00:44 +000098/// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result will
99/// always be accessible even if no aggregate location is provided.
100RValue CodeGenFunction::EmitAnyExprToTemp(const Expr *E,
Anders Carlsson14c5cbf2009-08-16 07:36:22 +0000101 bool IsAggLocVolatile,
102 bool IsInitializer) {
103 llvm::Value *AggLoc = 0;
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000104
105 if (hasAggregateLLVMType(E->getType()) &&
Daniel Dunbar46f45b92008-09-09 01:06:48 +0000106 !E->getType()->isAnyComplexType())
John McCall63efd332010-02-15 01:23:36 +0000107 AggLoc = CreateMemTemp(E->getType(), "agg.tmp");
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000108 return EmitAnyExpr(E, AggLoc, IsAggLocVolatile, /*IgnoreResult=*/false,
Anders Carlsson14c5cbf2009-08-16 07:36:22 +0000109 IsInitializer);
Daniel Dunbar46f45b92008-09-09 01:06:48 +0000110}
111
John McCall3d3ec1c2010-04-21 10:05:39 +0000112/// EmitAnyExprToMem - Evaluate an expression into a given memory
113/// location.
114void CodeGenFunction::EmitAnyExprToMem(const Expr *E,
115 llvm::Value *Location,
116 bool IsLocationVolatile,
117 bool IsInit) {
118 if (E->getType()->isComplexType())
119 EmitComplexExprIntoAddr(E, Location, IsLocationVolatile);
120 else if (hasAggregateLLVMType(E->getType()))
121 EmitAggExpr(E, Location, IsLocationVolatile, /*Ignore*/ false, IsInit);
122 else {
123 RValue RV = RValue::get(EmitScalarExpr(E, /*Ignore*/ false));
Daniel Dunbar9f553f52010-08-21 03:08:16 +0000124 LValue LV = MakeAddrLValue(Location, E->getType());
John McCall3d3ec1c2010-04-21 10:05:39 +0000125 EmitStoreThroughLValue(RV, LV, E->getType());
126 }
127}
128
Douglas Gregor60dcb842010-05-20 08:36:28 +0000129/// \brief An adjustment to be made to the temporary created when emitting a
130/// reference binding, which accesses a particular subobject of that temporary.
131struct SubobjectAdjustment {
132 enum { DerivedToBaseAdjustment, FieldAdjustment } Kind;
133
134 union {
135 struct {
John McCallf871d0c2010-08-07 06:22:56 +0000136 const CastExpr *BasePath;
Douglas Gregor60dcb842010-05-20 08:36:28 +0000137 const CXXRecordDecl *DerivedClass;
138 } DerivedToBase;
139
Daniel Dunbar333d42d2010-08-21 03:37:02 +0000140 FieldDecl *Field;
Douglas Gregor60dcb842010-05-20 08:36:28 +0000141 };
142
John McCallf871d0c2010-08-07 06:22:56 +0000143 SubobjectAdjustment(const CastExpr *BasePath,
Douglas Gregor60dcb842010-05-20 08:36:28 +0000144 const CXXRecordDecl *DerivedClass)
145 : Kind(DerivedToBaseAdjustment)
146 {
147 DerivedToBase.BasePath = BasePath;
148 DerivedToBase.DerivedClass = DerivedClass;
149 }
150
Daniel Dunbar333d42d2010-08-21 03:37:02 +0000151 SubobjectAdjustment(FieldDecl *Field)
152 : Kind(FieldAdjustment)
Douglas Gregor60dcb842010-05-20 08:36:28 +0000153 {
Daniel Dunbar333d42d2010-08-21 03:37:02 +0000154 this->Field = Field;
Douglas Gregor60dcb842010-05-20 08:36:28 +0000155 }
156};
157
Anders Carlssondca7ab22010-06-27 16:56:04 +0000158static llvm::Value *
Anders Carlsson656746c2010-06-27 17:23:46 +0000159CreateReferenceTemporary(CodeGenFunction& CGF, QualType Type,
160 const NamedDecl *InitializedDecl) {
161 if (const VarDecl *VD = dyn_cast_or_null<VarDecl>(InitializedDecl)) {
162 if (VD->hasGlobalStorage()) {
163 llvm::SmallString<256> Name;
John McCall4c40d982010-08-31 07:33:07 +0000164 CGF.CGM.getCXXABI().getMangleContext().mangleReferenceTemporary(VD, Name);
Anders Carlsson656746c2010-06-27 17:23:46 +0000165
166 const llvm::Type *RefTempTy = CGF.ConvertTypeForMem(Type);
167
168 // Create the reference temporary.
169 llvm::GlobalValue *RefTemp =
170 new llvm::GlobalVariable(CGF.CGM.getModule(),
171 RefTempTy, /*isConstant=*/false,
172 llvm::GlobalValue::InternalLinkage,
173 llvm::Constant::getNullValue(RefTempTy),
174 Name.str());
175 return RefTemp;
176 }
177 }
178
179 return CGF.CreateMemTemp(Type, "ref.tmp");
180}
181
182static llvm::Value *
Anders Carlssondca7ab22010-06-27 16:56:04 +0000183EmitExprForReferenceBinding(CodeGenFunction& CGF, const Expr* E,
184 llvm::Value *&ReferenceTemporary,
185 const CXXDestructorDecl *&ReferenceTemporaryDtor,
Anders Carlsson656746c2010-06-27 17:23:46 +0000186 const NamedDecl *InitializedDecl) {
Eli Friedman27a9b722009-12-19 00:20:10 +0000187 if (const CXXDefaultArgExpr *DAE = dyn_cast<CXXDefaultArgExpr>(E))
188 E = DAE->getExpr();
Anders Carlssonb3f74422009-10-15 00:51:46 +0000189
Anders Carlssondca7ab22010-06-27 16:56:04 +0000190 if (const CXXExprWithTemporaries *TE = dyn_cast<CXXExprWithTemporaries>(E)) {
John McCallf1549f62010-07-06 01:34:17 +0000191 CodeGenFunction::RunCleanupsScope Scope(CGF);
Anders Carlssondca7ab22010-06-27 16:56:04 +0000192
193 return EmitExprForReferenceBinding(CGF, TE->getSubExpr(),
194 ReferenceTemporary,
195 ReferenceTemporaryDtor,
Anders Carlsson656746c2010-06-27 17:23:46 +0000196 InitializedDecl);
Anders Carlssondca7ab22010-06-27 16:56:04 +0000197 }
198
199 RValue RV;
200 if (E->isLvalue(CGF.getContext()) == Expr::LV_Valid) {
201 // Emit the expression as an lvalue.
202 LValue LV = CGF.EmitLValue(E);
203
204 if (LV.isSimple())
205 return LV.getAddress();
Anders Carlsson0dc73662010-02-04 17:32:58 +0000206
Anders Carlssondca7ab22010-06-27 16:56:04 +0000207 // We have to load the lvalue.
208 RV = CGF.EmitLoadOfLValue(LV, E->getType());
Eli Friedman5df0d422009-05-20 02:31:19 +0000209 } else {
Douglas Gregor60dcb842010-05-20 08:36:28 +0000210 QualType ResultTy = E->getType();
Anders Carlssondca7ab22010-06-27 16:56:04 +0000211
Douglas Gregor60dcb842010-05-20 08:36:28 +0000212 llvm::SmallVector<SubobjectAdjustment, 2> Adjustments;
Anders Carlssondca7ab22010-06-27 16:56:04 +0000213 while (true) {
Douglas Gregor2d6b0e92010-05-22 05:17:18 +0000214 if (const ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
215 E = PE->getSubExpr();
216 continue;
217 }
218
219 if (const CastExpr *CE = dyn_cast<CastExpr>(E)) {
John McCall2de56d12010-08-25 11:45:40 +0000220 if ((CE->getCastKind() == CK_DerivedToBase ||
221 CE->getCastKind() == CK_UncheckedDerivedToBase) &&
Douglas Gregor2d6b0e92010-05-22 05:17:18 +0000222 E->getType()->isRecordType()) {
Douglas Gregor60dcb842010-05-20 08:36:28 +0000223 E = CE->getSubExpr();
224 CXXRecordDecl *Derived
225 = cast<CXXRecordDecl>(E->getType()->getAs<RecordType>()->getDecl());
John McCallf871d0c2010-08-07 06:22:56 +0000226 Adjustments.push_back(SubobjectAdjustment(CE, Derived));
Douglas Gregor60dcb842010-05-20 08:36:28 +0000227 continue;
228 }
Douglas Gregor2d6b0e92010-05-22 05:17:18 +0000229
John McCall2de56d12010-08-25 11:45:40 +0000230 if (CE->getCastKind() == CK_NoOp) {
Douglas Gregor2d6b0e92010-05-22 05:17:18 +0000231 E = CE->getSubExpr();
232 continue;
233 }
234 } else if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
Anders Carlssondca7ab22010-06-27 16:56:04 +0000235 if (ME->getBase()->isLvalue(CGF.getContext()) != Expr::LV_Valid &&
Douglas Gregor60dcb842010-05-20 08:36:28 +0000236 ME->getBase()->getType()->isRecordType()) {
237 if (FieldDecl *Field = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
238 E = ME->getBase();
Daniel Dunbar333d42d2010-08-21 03:37:02 +0000239 Adjustments.push_back(SubobjectAdjustment(Field));
Douglas Gregor60dcb842010-05-20 08:36:28 +0000240 continue;
241 }
242 }
Anders Carlssonb3f74422009-10-15 00:51:46 +0000243 }
Douglas Gregor2d6b0e92010-05-22 05:17:18 +0000244
245 // Nothing changed.
246 break;
Anders Carlsson8478ce62009-08-16 17:50:25 +0000247 }
Anders Carlssonb3f74422009-10-15 00:51:46 +0000248
Anders Carlssondca7ab22010-06-27 16:56:04 +0000249 // Create a reference temporary if necessary.
250 if (CGF.hasAggregateLLVMType(E->getType()) &&
251 !E->getType()->isAnyComplexType())
Anders Carlsson656746c2010-06-27 17:23:46 +0000252 ReferenceTemporary = CreateReferenceTemporary(CGF, E->getType(),
253 InitializedDecl);
254
Anders Carlssondca7ab22010-06-27 16:56:04 +0000255 RV = CGF.EmitAnyExpr(E, ReferenceTemporary, /*IsAggLocVolatile=*/false,
Anders Carlsson656746c2010-06-27 17:23:46 +0000256 /*IgnoreResult=*/false, InitializedDecl);
Anders Carlssondca7ab22010-06-27 16:56:04 +0000257
Anders Carlsson656746c2010-06-27 17:23:46 +0000258 if (InitializedDecl) {
Anders Carlssondca7ab22010-06-27 16:56:04 +0000259 // Get the destructor for the reference temporary.
260 if (const RecordType *RT = E->getType()->getAs<RecordType>()) {
261 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(RT->getDecl());
262 if (!ClassDecl->hasTrivialDestructor())
Douglas Gregor1d110e02010-07-01 14:13:13 +0000263 ReferenceTemporaryDtor = ClassDecl->getDestructor();
Anders Carlssondca7ab22010-06-27 16:56:04 +0000264 }
265 }
266
Douglas Gregor60dcb842010-05-20 08:36:28 +0000267 // Check if need to perform derived-to-base casts and/or field accesses, to
268 // get from the temporary object we created (and, potentially, for which we
269 // extended the lifetime) to the subobject we're binding the reference to.
270 if (!Adjustments.empty()) {
Anders Carlssondca7ab22010-06-27 16:56:04 +0000271 llvm::Value *Object = RV.getAggregateAddr();
Douglas Gregor60dcb842010-05-20 08:36:28 +0000272 for (unsigned I = Adjustments.size(); I != 0; --I) {
273 SubobjectAdjustment &Adjustment = Adjustments[I-1];
274 switch (Adjustment.Kind) {
275 case SubobjectAdjustment::DerivedToBaseAdjustment:
Anders Carlssondca7ab22010-06-27 16:56:04 +0000276 Object =
277 CGF.GetAddressOfBaseClass(Object,
278 Adjustment.DerivedToBase.DerivedClass,
John McCallf871d0c2010-08-07 06:22:56 +0000279 Adjustment.DerivedToBase.BasePath->path_begin(),
280 Adjustment.DerivedToBase.BasePath->path_end(),
Anders Carlssondca7ab22010-06-27 16:56:04 +0000281 /*NullCheckValue=*/false);
Douglas Gregor60dcb842010-05-20 08:36:28 +0000282 break;
283
284 case SubobjectAdjustment::FieldAdjustment: {
Anders Carlssondca7ab22010-06-27 16:56:04 +0000285 LValue LV =
Daniel Dunbar333d42d2010-08-21 03:37:02 +0000286 CGF.EmitLValueForField(Object, Adjustment.Field, 0);
Douglas Gregor60dcb842010-05-20 08:36:28 +0000287 if (LV.isSimple()) {
288 Object = LV.getAddress();
289 break;
290 }
291
292 // For non-simple lvalues, we actually have to create a copy of
293 // the object we're binding to.
Daniel Dunbar333d42d2010-08-21 03:37:02 +0000294 QualType T = Adjustment.Field->getType().getNonReferenceType()
295 .getUnqualifiedType();
Anders Carlsson045a6d82010-06-27 17:52:15 +0000296 Object = CreateReferenceTemporary(CGF, T, InitializedDecl);
Daniel Dunbar333d42d2010-08-21 03:37:02 +0000297 LValue TempLV = CGF.MakeAddrLValue(Object,
298 Adjustment.Field->getType());
Anders Carlssondca7ab22010-06-27 16:56:04 +0000299 CGF.EmitStoreThroughLValue(CGF.EmitLoadOfLValue(LV, T), TempLV, T);
Douglas Gregor60dcb842010-05-20 08:36:28 +0000300 break;
301 }
Anders Carlssondca7ab22010-06-27 16:56:04 +0000302
Douglas Gregor60dcb842010-05-20 08:36:28 +0000303 }
304 }
305
Anders Carlssondca7ab22010-06-27 16:56:04 +0000306 const llvm::Type *ResultPtrTy = CGF.ConvertType(ResultTy)->getPointerTo();
307 return CGF.Builder.CreateBitCast(Object, ResultPtrTy, "temp");
Anders Carlssonb3f74422009-10-15 00:51:46 +0000308 }
Anders Carlsson4bbab922009-05-20 00:36:58 +0000309 }
Eli Friedman5df0d422009-05-20 02:31:19 +0000310
Anders Carlssondca7ab22010-06-27 16:56:04 +0000311 if (RV.isAggregate())
312 return RV.getAggregateAddr();
Eli Friedman5df0d422009-05-20 02:31:19 +0000313
Anders Carlssondca7ab22010-06-27 16:56:04 +0000314 // Create a temporary variable that we can bind the reference to.
Anders Carlsson656746c2010-06-27 17:23:46 +0000315 ReferenceTemporary = CreateReferenceTemporary(CGF, E->getType(),
316 InitializedDecl);
317
Daniel Dunbar91a16fa2010-08-21 02:24:36 +0000318
319 unsigned Alignment =
320 CGF.getContext().getTypeAlignInChars(E->getType()).getQuantity();
Anders Carlssondca7ab22010-06-27 16:56:04 +0000321 if (RV.isScalar())
322 CGF.EmitStoreOfScalar(RV.getScalarVal(), ReferenceTemporary,
Daniel Dunbar91a16fa2010-08-21 02:24:36 +0000323 /*Volatile=*/false, Alignment, E->getType());
Anders Carlssondca7ab22010-06-27 16:56:04 +0000324 else
325 CGF.StoreComplexToAddr(RV.getComplexVal(), ReferenceTemporary,
326 /*Volatile=*/false);
327 return ReferenceTemporary;
328}
329
330RValue
331CodeGenFunction::EmitReferenceBindingToExpr(const Expr* E,
332 const NamedDecl *InitializedDecl) {
333 llvm::Value *ReferenceTemporary = 0;
334 const CXXDestructorDecl *ReferenceTemporaryDtor = 0;
335 llvm::Value *Value = EmitExprForReferenceBinding(*this, E, ReferenceTemporary,
336 ReferenceTemporaryDtor,
337 InitializedDecl);
Fariborz Jahanian79255612010-09-03 21:36:02 +0000338 if (E->getType()->isBooleanType()) {
339 // special handling for __block variable of bool type bound to
340 // a reference type.
341 bool block_byref_var = false;
342 if (const BlockDeclRefExpr *BE = dyn_cast<BlockDeclRefExpr>(E))
343 block_byref_var = BE->isByRef();
344 else if (const DeclRefExpr *BD = dyn_cast<DeclRefExpr>(E)) {
345 const NamedDecl *ND = BD->getDecl();
346 if (const VarDecl *VD = dyn_cast<VarDecl>(ND))
347 block_byref_var = VD->hasAttr<BlocksAttr>();
348 }
349 if (block_byref_var) {
350 const llvm::Type *T = ConvertTypeForMem(E->getType());
351 T = llvm::PointerType::getUnqual(T);
352 Value = Builder.CreateBitCast(Value, T);
353 }
354 }
Anders Carlssondca7ab22010-06-27 16:56:04 +0000355
Anders Carlsson045a6d82010-06-27 17:52:15 +0000356 if (!ReferenceTemporaryDtor)
357 return RValue::get(Value);
358
Anders Carlssondca7ab22010-06-27 16:56:04 +0000359 // Make sure to call the destructor for the reference temporary.
Anders Carlsson045a6d82010-06-27 17:52:15 +0000360 if (const VarDecl *VD = dyn_cast_or_null<VarDecl>(InitializedDecl)) {
361 if (VD->hasGlobalStorage()) {
362 llvm::Constant *DtorFn =
363 CGM.GetAddrOfCXXDestructor(ReferenceTemporaryDtor, Dtor_Complete);
364 CGF.EmitCXXGlobalDtorRegistration(DtorFn,
365 cast<llvm::Constant>(ReferenceTemporary));
366
367 return RValue::get(Value);
368 }
369 }
John McCall81407d42010-07-21 06:29:51 +0000370
371 PushDestructorCleanup(ReferenceTemporaryDtor, ReferenceTemporary);
Anders Carlssondca7ab22010-06-27 16:56:04 +0000372
373 return RValue::get(Value);
Anders Carlsson4029ca72009-05-20 00:24:07 +0000374}
375
376
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000377/// getAccessedFieldNo - Given an encoded value and a result number, return the
378/// input field number being accessed.
379unsigned CodeGenFunction::getAccessedFieldNo(unsigned Idx,
Dan Gohman4f8d1232008-05-22 00:50:06 +0000380 const llvm::Constant *Elts) {
381 if (isa<llvm::ConstantAggregateZero>(Elts))
382 return 0;
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000383
Dan Gohman4f8d1232008-05-22 00:50:06 +0000384 return cast<llvm::ConstantInt>(Elts->getOperand(Idx))->getZExtValue();
385}
386
Mike Stumpb14e62d2009-12-16 02:57:00 +0000387void CodeGenFunction::EmitCheck(llvm::Value *Address, unsigned Size) {
388 if (!CatchUndefined)
389 return;
390
Mike Stumpb14e62d2009-12-16 02:57:00 +0000391 Address = Builder.CreateBitCast(Address, PtrToInt8Ty);
392
Chris Lattner77b89b82010-06-27 07:15:29 +0000393 const llvm::Type *IntPtrT = IntPtrTy;
394 llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::objectsize, &IntPtrT, 1);
395 const llvm::IntegerType *Int1Ty = llvm::Type::getInt1Ty(VMContext);
Chris Lattnerc24b9c42010-04-10 18:34:14 +0000396
Mike Stumpb14e62d2009-12-16 02:57:00 +0000397 // In time, people may want to control this and use a 1 here.
Chris Lattnerc24b9c42010-04-10 18:34:14 +0000398 llvm::Value *Arg = llvm::ConstantInt::get(Int1Ty, 0);
Mike Stumpb14e62d2009-12-16 02:57:00 +0000399 llvm::Value *C = Builder.CreateCall2(F, Address, Arg);
400 llvm::BasicBlock *Cont = createBasicBlock();
401 llvm::BasicBlock *Check = createBasicBlock();
Chris Lattner77b89b82010-06-27 07:15:29 +0000402 llvm::Value *NegativeOne = llvm::ConstantInt::get(IntPtrTy, -1ULL);
Mike Stumpb14e62d2009-12-16 02:57:00 +0000403 Builder.CreateCondBr(Builder.CreateICmpEQ(C, NegativeOne), Cont, Check);
404
405 EmitBlock(Check);
406 Builder.CreateCondBr(Builder.CreateICmpUGE(C,
Chris Lattner77b89b82010-06-27 07:15:29 +0000407 llvm::ConstantInt::get(IntPtrTy, Size)),
Mike Stumpb14e62d2009-12-16 02:57:00 +0000408 Cont, getTrapBB());
409 EmitBlock(Cont);
410}
Chris Lattner9b655512007-08-31 22:49:20 +0000411
Chris Lattnerdd36d322010-01-09 21:40:03 +0000412
Chris Lattnerdd36d322010-01-09 21:40:03 +0000413CodeGenFunction::ComplexPairTy CodeGenFunction::
414EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV,
415 bool isInc, bool isPre) {
416 ComplexPairTy InVal = LoadComplexFromAddr(LV.getAddress(),
417 LV.isVolatileQualified());
418
419 llvm::Value *NextVal;
420 if (isa<llvm::IntegerType>(InVal.first->getType())) {
421 uint64_t AmountVal = isInc ? 1 : -1;
422 NextVal = llvm::ConstantInt::get(InVal.first->getType(), AmountVal, true);
423
424 // Add the inc/dec to the real part.
425 NextVal = Builder.CreateAdd(InVal.first, NextVal, isInc ? "inc" : "dec");
426 } else {
427 QualType ElemTy = E->getType()->getAs<ComplexType>()->getElementType();
428 llvm::APFloat FVal(getContext().getFloatTypeSemantics(ElemTy), 1);
429 if (!isInc)
430 FVal.changeSign();
431 NextVal = llvm::ConstantFP::get(getLLVMContext(), FVal);
432
433 // Add the inc/dec to the real part.
434 NextVal = Builder.CreateFAdd(InVal.first, NextVal, isInc ? "inc" : "dec");
435 }
436
437 ComplexPairTy IncVal(NextVal, InVal.second);
438
439 // Store the updated result through the lvalue.
440 StoreComplexToAddr(IncVal, LV.getAddress(), LV.isVolatileQualified());
441
442 // If this is a postinc, return the value read from memory, otherwise use the
443 // updated value.
444 return isPre ? IncVal : InVal;
445}
446
447
Reid Spencer5f016e22007-07-11 17:01:13 +0000448//===----------------------------------------------------------------------===//
449// LValue Expression Emission
450//===----------------------------------------------------------------------===//
451
Daniel Dunbar13e81732009-02-05 07:09:07 +0000452RValue CodeGenFunction::GetUndefRValue(QualType Ty) {
Chris Lattnereb99b012009-10-28 17:39:19 +0000453 if (Ty->isVoidType())
Daniel Dunbar13e81732009-02-05 07:09:07 +0000454 return RValue::get(0);
Chris Lattnereb99b012009-10-28 17:39:19 +0000455
456 if (const ComplexType *CTy = Ty->getAs<ComplexType>()) {
Daniel Dunbar8fa73ed2009-01-09 20:09:28 +0000457 const llvm::Type *EltTy = ConvertType(CTy->getElementType());
Owen Anderson03e20502009-07-30 23:11:26 +0000458 llvm::Value *U = llvm::UndefValue::get(EltTy);
Daniel Dunbar8fa73ed2009-01-09 20:09:28 +0000459 return RValue::getComplex(std::make_pair(U, U));
Chris Lattnereb99b012009-10-28 17:39:19 +0000460 }
461
Chris Lattnerb6c504b2010-08-23 05:26:13 +0000462 // If this is a use of an undefined aggregate type, the aggregate must have an
463 // identifiable address. Just because the contents of the value are undefined
464 // doesn't mean that the address can't be taken and compared.
Chris Lattnereb99b012009-10-28 17:39:19 +0000465 if (hasAggregateLLVMType(Ty)) {
Chris Lattnerb6c504b2010-08-23 05:26:13 +0000466 llvm::Value *DestPtr = CreateMemTemp(Ty, "undef.agg.tmp");
467 return RValue::getAggregate(DestPtr);
Daniel Dunbar8fa73ed2009-01-09 20:09:28 +0000468 }
Chris Lattnereb99b012009-10-28 17:39:19 +0000469
470 return RValue::get(llvm::UndefValue::get(ConvertType(Ty)));
Daniel Dunbarce1d38b2009-01-09 16:50:52 +0000471}
472
Daniel Dunbar13e81732009-02-05 07:09:07 +0000473RValue CodeGenFunction::EmitUnsupportedRValue(const Expr *E,
474 const char *Name) {
475 ErrorUnsupported(E, Name);
476 return GetUndefRValue(E->getType());
477}
478
Daniel Dunbar6ba82a42008-08-25 20:45:57 +0000479LValue CodeGenFunction::EmitUnsupportedLValue(const Expr *E,
480 const char *Name) {
481 ErrorUnsupported(E, Name);
Owen Anderson96e0fc72009-07-29 22:16:19 +0000482 llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType()));
Daniel Dunbar9f553f52010-08-21 03:08:16 +0000483 return MakeAddrLValue(llvm::UndefValue::get(Ty), E->getType());
Daniel Dunbar6ba82a42008-08-25 20:45:57 +0000484}
485
Mike Stumpb14e62d2009-12-16 02:57:00 +0000486LValue CodeGenFunction::EmitCheckedLValue(const Expr *E) {
487 LValue LV = EmitLValue(E);
Daniel Dunbarf0fe5bc2010-04-05 21:36:35 +0000488 if (!isa<DeclRefExpr>(E) && !LV.isBitField() && LV.isSimple())
Mike Stumpb14e62d2009-12-16 02:57:00 +0000489 EmitCheck(LV.getAddress(), getContext().getTypeSize(E->getType()) / 8);
490 return LV;
491}
492
Reid Spencer5f016e22007-07-11 17:01:13 +0000493/// EmitLValue - Emit code to compute a designator that specifies the location
494/// of the expression.
495///
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000496/// This can return one of two things: a simple address or a bitfield reference.
497/// In either case, the LLVM Value* in the LValue structure is guaranteed to be
498/// an LLVM pointer type.
Reid Spencer5f016e22007-07-11 17:01:13 +0000499///
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000500/// If this returns a bitfield reference, nothing about the pointee type of the
501/// LLVM value is known: For example, it may not be a pointer to an integer.
Reid Spencer5f016e22007-07-11 17:01:13 +0000502///
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000503/// If this returns a normal address, and if the lvalue's C type is fixed size,
504/// this method guarantees that the returned pointer type will point to an LLVM
505/// type of the same size of the lvalue's type. If the lvalue has a variable
506/// length type, this is not possible.
Reid Spencer5f016e22007-07-11 17:01:13 +0000507///
508LValue CodeGenFunction::EmitLValue(const Expr *E) {
509 switch (E->getStmtClass()) {
Daniel Dunbar6ba82a42008-08-25 20:45:57 +0000510 default: return EmitUnsupportedLValue(E, "l-value expression");
Reid Spencer5f016e22007-07-11 17:01:13 +0000511
Fariborz Jahanian03b29602010-06-17 19:56:20 +0000512 case Expr::ObjCSelectorExprClass:
513 return EmitObjCSelectorLValue(cast<ObjCSelectorExpr>(E));
Fariborz Jahanian820bca42009-12-09 23:35:29 +0000514 case Expr::ObjCIsaExprClass:
515 return EmitObjCIsaExpr(cast<ObjCIsaExpr>(E));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000516 case Expr::BinaryOperatorClass:
Daniel Dunbar80e62c22008-09-04 03:20:13 +0000517 return EmitBinaryOperatorLValue(cast<BinaryOperator>(E));
Douglas Gregor6a03e342010-04-23 04:16:32 +0000518 case Expr::CompoundAssignOperatorClass:
519 return EmitCompoundAssignOperatorLValue(cast<CompoundAssignOperator>(E));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000520 case Expr::CallExprClass:
Anders Carlssonfaf86642009-09-01 21:18:52 +0000521 case Expr::CXXMemberCallExprClass:
Douglas Gregorb4609802008-11-14 16:09:21 +0000522 case Expr::CXXOperatorCallExprClass:
523 return EmitCallExprLValue(cast<CallExpr>(E));
Daniel Dunbar5b5c9ef2009-02-11 20:59:32 +0000524 case Expr::VAArgExprClass:
525 return EmitVAArgExprLValue(cast<VAArgExpr>(E));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000526 case Expr::DeclRefExprClass:
Douglas Gregor1a49af92009-01-06 05:10:23 +0000527 return EmitDeclRefLValue(cast<DeclRefExpr>(E));
Reid Spencer5f016e22007-07-11 17:01:13 +0000528 case Expr::ParenExprClass:return EmitLValue(cast<ParenExpr>(E)->getSubExpr());
Chris Lattnerd9f69102008-08-10 01:53:14 +0000529 case Expr::PredefinedExprClass:
530 return EmitPredefinedLValue(cast<PredefinedExpr>(E));
Reid Spencer5f016e22007-07-11 17:01:13 +0000531 case Expr::StringLiteralClass:
532 return EmitStringLiteralLValue(cast<StringLiteral>(E));
Chris Lattnereaf2bb82009-02-24 22:18:39 +0000533 case Expr::ObjCEncodeExprClass:
534 return EmitObjCEncodeExprLValue(cast<ObjCEncodeExpr>(E));
Chris Lattner391d77a2008-03-30 23:03:07 +0000535
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000536 case Expr::BlockDeclRefExprClass:
Mike Stumpa99038c2009-02-28 09:07:16 +0000537 return EmitBlockDeclRefLValue(cast<BlockDeclRefExpr>(E));
538
Anders Carlssonb58d0172009-05-30 23:23:33 +0000539 case Expr::CXXTemporaryObjectExprClass:
540 case Expr::CXXConstructExprClass:
Anders Carlssone61c9e82009-05-30 23:30:54 +0000541 return EmitCXXConstructLValue(cast<CXXConstructExpr>(E));
542 case Expr::CXXBindTemporaryExprClass:
543 return EmitCXXBindTemporaryLValue(cast<CXXBindTemporaryExpr>(E));
Anders Carlssonb9ea0b52009-09-14 01:10:45 +0000544 case Expr::CXXExprWithTemporariesClass:
545 return EmitCXXExprWithTemporariesLValue(cast<CXXExprWithTemporaries>(E));
Douglas Gregored8abf12010-07-08 06:14:04 +0000546 case Expr::CXXScalarValueInitExprClass:
547 return EmitNullInitializationLValue(cast<CXXScalarValueInitExpr>(E));
Anders Carlsson370e5382009-11-14 01:51:50 +0000548 case Expr::CXXDefaultArgExprClass:
549 return EmitLValue(cast<CXXDefaultArgExpr>(E)->getExpr());
Mike Stumpc2e84ae2009-11-15 08:09:41 +0000550 case Expr::CXXTypeidExprClass:
551 return EmitCXXTypeidLValue(cast<CXXTypeidExpr>(E));
Anders Carlssone61c9e82009-05-30 23:30:54 +0000552
Daniel Dunbar0a04d772008-08-23 10:51:21 +0000553 case Expr::ObjCMessageExprClass:
554 return EmitObjCMessageExprLValue(cast<ObjCMessageExpr>(E));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000555 case Expr::ObjCIvarRefExprClass:
Chris Lattner391d77a2008-03-30 23:03:07 +0000556 return EmitObjCIvarRefLValue(cast<ObjCIvarRefExpr>(E));
Daniel Dunbar6ba82a42008-08-25 20:45:57 +0000557 case Expr::ObjCPropertyRefExprClass:
Daniel Dunbar85c59ed2008-08-29 08:11:39 +0000558 return EmitObjCPropertyRefLValue(cast<ObjCPropertyRefExpr>(E));
Fariborz Jahanian09105f52009-08-20 17:02:02 +0000559 case Expr::ObjCImplicitSetterGetterRefExprClass:
560 return EmitObjCKVCRefLValue(cast<ObjCImplicitSetterGetterRefExpr>(E));
Douglas Gregorcd9b46e2008-11-04 14:56:14 +0000561 case Expr::ObjCSuperExprClass:
Chris Lattner65459942009-04-25 19:35:26 +0000562 return EmitObjCSuperExprLValue(cast<ObjCSuperExpr>(E));
Douglas Gregorcd9b46e2008-11-04 14:56:14 +0000563
Chris Lattner65459942009-04-25 19:35:26 +0000564 case Expr::StmtExprClass:
565 return EmitStmtExprLValue(cast<StmtExpr>(E));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000566 case Expr::UnaryOperatorClass:
Reid Spencer5f016e22007-07-11 17:01:13 +0000567 return EmitUnaryOpLValue(cast<UnaryOperator>(E));
568 case Expr::ArraySubscriptExprClass:
569 return EmitArraySubscriptExpr(cast<ArraySubscriptExpr>(E));
Nate Begeman213541a2008-04-18 23:10:10 +0000570 case Expr::ExtVectorElementExprClass:
571 return EmitExtVectorElementExpr(cast<ExtVectorElementExpr>(E));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000572 case Expr::MemberExprClass:
Douglas Gregorbd4c4ae2009-08-26 22:36:53 +0000573 return EmitMemberExpr(cast<MemberExpr>(E));
Eli Friedman06e863f2008-05-13 23:18:27 +0000574 case Expr::CompoundLiteralExprClass:
575 return EmitCompoundLiteralLValue(cast<CompoundLiteralExpr>(E));
Daniel Dunbar90345582009-03-24 02:38:23 +0000576 case Expr::ConditionalOperatorClass:
Anders Carlsson6fcec8b2009-09-15 16:35:24 +0000577 return EmitConditionalOperatorLValue(cast<ConditionalOperator>(E));
Chris Lattner670a62c2008-12-12 05:35:08 +0000578 case Expr::ChooseExprClass:
Eli Friedman79769322009-03-04 05:52:32 +0000579 return EmitLValue(cast<ChooseExpr>(E)->getChosenSubExpr(getContext()));
Chris Lattnerc3953a62009-03-18 04:02:57 +0000580 case Expr::ImplicitCastExprClass:
581 case Expr::CStyleCastExprClass:
582 case Expr::CXXFunctionalCastExprClass:
583 case Expr::CXXStaticCastExprClass:
584 case Expr::CXXDynamicCastExprClass:
585 case Expr::CXXReinterpretCastExprClass:
586 case Expr::CXXConstCastExprClass:
Chris Lattner75dfeda2009-03-18 18:28:57 +0000587 return EmitCastLValue(cast<CastExpr>(E));
Reid Spencer5f016e22007-07-11 17:01:13 +0000588 }
589}
590
Daniel Dunbar9d9cc872009-02-10 00:57:50 +0000591llvm::Value *CodeGenFunction::EmitLoadOfScalar(llvm::Value *Addr, bool Volatile,
Daniel Dunbar91a16fa2010-08-21 02:24:36 +0000592 unsigned Alignment, QualType Ty) {
Daniel Dunbar2da84ff2009-11-29 21:23:36 +0000593 llvm::LoadInst *Load = Builder.CreateLoad(Addr, "tmp");
594 if (Volatile)
595 Load->setVolatile(true);
Daniel Dunbar91a16fa2010-08-21 02:24:36 +0000596 if (Alignment)
597 Load->setAlignment(Alignment);
Daniel Dunbar9d9cc872009-02-10 00:57:50 +0000598
Anders Carlsson3bb423b2009-05-19 19:36:19 +0000599 // Bool can have different representation in memory than in registers.
Daniel Dunbar2da84ff2009-11-29 21:23:36 +0000600 llvm::Value *V = Load;
Daniel Dunbar9d9cc872009-02-10 00:57:50 +0000601 if (Ty->isBooleanType())
Owen Anderson0032b272009-08-13 21:57:51 +0000602 if (V->getType() != llvm::Type::getInt1Ty(VMContext))
603 V = Builder.CreateTrunc(V, llvm::Type::getInt1Ty(VMContext), "tobool");
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000604
Daniel Dunbar9d9cc872009-02-10 00:57:50 +0000605 return V;
606}
607
608void CodeGenFunction::EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr,
Daniel Dunbar91a16fa2010-08-21 02:24:36 +0000609 bool Volatile, unsigned Alignment,
610 QualType Ty) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000611
Anders Carlsson3bb423b2009-05-19 19:36:19 +0000612 if (Ty->isBooleanType()) {
613 // Bool can have different representation in memory than in registers.
Anders Carlsson3bb423b2009-05-19 19:36:19 +0000614 const llvm::PointerType *DstPtr = cast<llvm::PointerType>(Addr->getType());
Eli Friedman2b06d342009-12-01 22:31:51 +0000615 Value = Builder.CreateIntCast(Value, DstPtr->getElementType(), false);
Daniel Dunbar9d9cc872009-02-10 00:57:50 +0000616 }
Daniel Dunbar91a16fa2010-08-21 02:24:36 +0000617
618 llvm::StoreInst *Store = Builder.CreateStore(Value, Addr, Volatile);
619 if (Alignment)
620 Store->setAlignment(Alignment);
Daniel Dunbar9d9cc872009-02-10 00:57:50 +0000621}
622
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000623/// EmitLoadOfLValue - Given an expression that represents a value lvalue, this
624/// method emits the address of the lvalue, then loads the result as an rvalue,
625/// returning the rvalue.
Reid Spencer5f016e22007-07-11 17:01:13 +0000626RValue CodeGenFunction::EmitLoadOfLValue(LValue LV, QualType ExprType) {
Fariborz Jahaniandbd32c22008-11-19 17:34:06 +0000627 if (LV.isObjCWeak()) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000628 // load of a __weak object.
Fariborz Jahanian6dc23172008-11-18 21:45:40 +0000629 llvm::Value *AddrWeakObj = LV.getAddress();
Chris Lattnereb99b012009-10-28 17:39:19 +0000630 return RValue::get(CGM.getObjCRuntime().EmitObjCWeakRead(*this,
631 AddrWeakObj));
Fariborz Jahanian6dc23172008-11-18 21:45:40 +0000632 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000633
Reid Spencer5f016e22007-07-11 17:01:13 +0000634 if (LV.isSimple()) {
635 llvm::Value *Ptr = LV.getAddress();
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000636
John McCalld608cdb2010-08-22 10:59:02 +0000637 // Functions are l-values that don't require loading.
638 if (ExprType->isFunctionType())
639 return RValue::get(Ptr);
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000640
John McCalld608cdb2010-08-22 10:59:02 +0000641 // Everything needs a load.
642 return RValue::get(EmitLoadOfScalar(Ptr, LV.isVolatileQualified(),
643 LV.getAlignment(), ExprType));
644
Reid Spencer5f016e22007-07-11 17:01:13 +0000645 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000646
Reid Spencer5f016e22007-07-11 17:01:13 +0000647 if (LV.isVectorElt()) {
Eli Friedman1e692ac2008-06-13 23:01:12 +0000648 llvm::Value *Vec = Builder.CreateLoad(LV.getVectorAddr(),
649 LV.isVolatileQualified(), "tmp");
Reid Spencer5f016e22007-07-11 17:01:13 +0000650 return RValue::get(Builder.CreateExtractElement(Vec, LV.getVectorIdx(),
651 "vecext"));
652 }
Chris Lattner46ea8eb2007-08-03 00:16:29 +0000653
654 // If this is a reference to a subset of the elements of a vector, either
655 // shuffle the input or extract/insert them as appropriate.
Nate Begeman213541a2008-04-18 23:10:10 +0000656 if (LV.isExtVectorElt())
657 return EmitLoadOfExtVectorElementLValue(LV, ExprType);
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +0000658
Daniel Dunbarf0fe5bc2010-04-05 21:36:35 +0000659 if (LV.isBitField())
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +0000660 return EmitLoadOfBitfieldLValue(LV, ExprType);
661
Daniel Dunbar85c59ed2008-08-29 08:11:39 +0000662 if (LV.isPropertyRef())
663 return EmitLoadOfPropertyRefLValue(LV, ExprType);
664
Chris Lattner73525de2009-02-16 21:11:58 +0000665 assert(LV.isKVCRef() && "Unknown LValue type!");
666 return EmitLoadOfKVCRefLValue(LV, ExprType);
Reid Spencer5f016e22007-07-11 17:01:13 +0000667}
668
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +0000669RValue CodeGenFunction::EmitLoadOfBitfieldLValue(LValue LV,
670 QualType ExprType) {
Daniel Dunbarefbf4872010-04-06 01:07:44 +0000671 const CGBitFieldInfo &Info = LV.getBitFieldInfo();
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000672
Daniel Dunbarecdb41e2010-04-13 23:34:15 +0000673 // Get the output type.
674 const llvm::Type *ResLTy = ConvertType(ExprType);
675 unsigned ResSizeInBits = CGM.getTargetData().getTypeSizeInBits(ResLTy);
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +0000676
Daniel Dunbarecdb41e2010-04-13 23:34:15 +0000677 // Compute the result as an OR of all of the individual component accesses.
678 llvm::Value *Res = 0;
679 for (unsigned i = 0, e = Info.getNumComponents(); i != e; ++i) {
680 const CGBitFieldInfo::AccessInfo &AI = Info.getComponent(i);
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000681
Daniel Dunbarecdb41e2010-04-13 23:34:15 +0000682 // Get the field pointer.
683 llvm::Value *Ptr = LV.getBitFieldBaseAddr();
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000684
Daniel Dunbarecdb41e2010-04-13 23:34:15 +0000685 // Only offset by the field index if used, so that incoming values are not
686 // required to be structures.
687 if (AI.FieldIndex)
688 Ptr = Builder.CreateStructGEP(Ptr, AI.FieldIndex, "bf.field");
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000689
Daniel Dunbarecdb41e2010-04-13 23:34:15 +0000690 // Offset by the byte offset, if used.
691 if (AI.FieldByteOffset) {
692 const llvm::Type *i8PTy = llvm::Type::getInt8PtrTy(VMContext);
693 Ptr = Builder.CreateBitCast(Ptr, i8PTy);
694 Ptr = Builder.CreateConstGEP1_32(Ptr, AI.FieldByteOffset,"bf.field.offs");
695 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000696
Daniel Dunbarecdb41e2010-04-13 23:34:15 +0000697 // Cast to the access type.
698 const llvm::Type *PTy = llvm::Type::getIntNPtrTy(VMContext, AI.AccessWidth,
699 ExprType.getAddressSpace());
700 Ptr = Builder.CreateBitCast(Ptr, PTy);
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +0000701
Daniel Dunbarecdb41e2010-04-13 23:34:15 +0000702 // Perform the load.
703 llvm::LoadInst *Load = Builder.CreateLoad(Ptr, LV.isVolatileQualified());
704 if (AI.AccessAlignment)
705 Load->setAlignment(AI.AccessAlignment);
706
707 // Shift out unused low bits and mask out unused high bits.
708 llvm::Value *Val = Load;
709 if (AI.FieldBitStart)
Daniel Dunbar26772612010-04-15 03:47:33 +0000710 Val = Builder.CreateLShr(Load, AI.FieldBitStart);
Daniel Dunbarecdb41e2010-04-13 23:34:15 +0000711 Val = Builder.CreateAnd(Val, llvm::APInt::getLowBitsSet(AI.AccessWidth,
712 AI.TargetBitWidth),
713 "bf.clear");
714
715 // Extend or truncate to the target size.
716 if (AI.AccessWidth < ResSizeInBits)
717 Val = Builder.CreateZExt(Val, ResLTy);
718 else if (AI.AccessWidth > ResSizeInBits)
719 Val = Builder.CreateTrunc(Val, ResLTy);
720
721 // Shift into place, and OR into the result.
722 if (AI.TargetBitOffset)
723 Val = Builder.CreateShl(Val, AI.TargetBitOffset);
724 Res = Res ? Builder.CreateOr(Res, Val) : Val;
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000725 }
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +0000726
Daniel Dunbarecdb41e2010-04-13 23:34:15 +0000727 // If the bit-field is signed, perform the sign-extension.
728 //
729 // FIXME: This can easily be folded into the load of the high bits, which
730 // could also eliminate the mask of high bits in some situations.
731 if (Info.isSigned()) {
Daniel Dunbar26772612010-04-15 03:47:33 +0000732 unsigned ExtraBits = ResSizeInBits - Info.getSize();
Daniel Dunbarecdb41e2010-04-13 23:34:15 +0000733 if (ExtraBits)
734 Res = Builder.CreateAShr(Builder.CreateShl(Res, ExtraBits),
735 ExtraBits, "bf.val.sext");
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000736 }
Eli Friedman316bb1b2008-05-17 20:03:47 +0000737
Daniel Dunbarecdb41e2010-04-13 23:34:15 +0000738 return RValue::get(Res);
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +0000739}
740
Daniel Dunbar85c59ed2008-08-29 08:11:39 +0000741RValue CodeGenFunction::EmitLoadOfPropertyRefLValue(LValue LV,
742 QualType ExprType) {
743 return EmitObjCPropertyGet(LV.getPropertyRefExpr());
744}
745
Fariborz Jahanian43f44702008-11-22 22:30:21 +0000746RValue CodeGenFunction::EmitLoadOfKVCRefLValue(LValue LV,
747 QualType ExprType) {
748 return EmitObjCPropertyGet(LV.getKVCRefExpr());
749}
750
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000751// If this is a reference to a subset of the elements of a vector, create an
752// appropriate shufflevector.
Nate Begeman213541a2008-04-18 23:10:10 +0000753RValue CodeGenFunction::EmitLoadOfExtVectorElementLValue(LValue LV,
754 QualType ExprType) {
Eli Friedman1e692ac2008-06-13 23:01:12 +0000755 llvm::Value *Vec = Builder.CreateLoad(LV.getExtVectorAddr(),
756 LV.isVolatileQualified(), "tmp");
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000757
Nate Begeman8a997642008-05-09 06:41:27 +0000758 const llvm::Constant *Elts = LV.getExtVectorElts();
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000759
760 // If the result of the expression is a non-vector type, we must be extracting
761 // a single element. Just codegen as an extractelement.
John McCall183700f2009-09-21 23:43:11 +0000762 const VectorType *ExprVT = ExprType->getAs<VectorType>();
Chris Lattnercf60cd22007-08-10 17:10:08 +0000763 if (!ExprVT) {
Dan Gohman4f8d1232008-05-22 00:50:06 +0000764 unsigned InIdx = getAccessedFieldNo(0, Elts);
Chris Lattner77b89b82010-06-27 07:15:29 +0000765 llvm::Value *Elt = llvm::ConstantInt::get(Int32Ty, InIdx);
Chris Lattner34cdc862007-08-03 16:18:34 +0000766 return RValue::get(Builder.CreateExtractElement(Vec, Elt, "tmp"));
767 }
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000768
769 // Always use shuffle vector to try to retain the original program structure
Chris Lattnercf60cd22007-08-10 17:10:08 +0000770 unsigned NumResultElts = ExprVT->getNumElements();
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000771
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000772 llvm::SmallVector<llvm::Constant*, 4> Mask;
Chris Lattner34cdc862007-08-03 16:18:34 +0000773 for (unsigned i = 0; i != NumResultElts; ++i) {
Dan Gohman4f8d1232008-05-22 00:50:06 +0000774 unsigned InIdx = getAccessedFieldNo(i, Elts);
Chris Lattner77b89b82010-06-27 07:15:29 +0000775 Mask.push_back(llvm::ConstantInt::get(Int32Ty, InIdx));
Chris Lattner34cdc862007-08-03 16:18:34 +0000776 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000777
Owen Anderson4a289322009-07-28 21:22:35 +0000778 llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size());
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000779 Vec = Builder.CreateShuffleVector(Vec,
Owen Anderson03e20502009-07-30 23:11:26 +0000780 llvm::UndefValue::get(Vec->getType()),
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000781 MaskV, "tmp");
782 return RValue::get(Vec);
Chris Lattner34cdc862007-08-03 16:18:34 +0000783}
784
785
Reid Spencer5f016e22007-07-11 17:01:13 +0000786
787/// EmitStoreThroughLValue - Store the specified rvalue into the specified
788/// lvalue, where both are guaranteed to the have the same type, and that type
789/// is 'Ty'.
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000790void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst,
Reid Spencer5f016e22007-07-11 17:01:13 +0000791 QualType Ty) {
Chris Lattner017d6aa2007-08-03 16:28:33 +0000792 if (!Dst.isSimple()) {
793 if (Dst.isVectorElt()) {
794 // Read/modify/write the vector, inserting the new element.
Eli Friedman1e692ac2008-06-13 23:01:12 +0000795 llvm::Value *Vec = Builder.CreateLoad(Dst.getVectorAddr(),
796 Dst.isVolatileQualified(), "tmp");
Chris Lattner9b655512007-08-31 22:49:20 +0000797 Vec = Builder.CreateInsertElement(Vec, Src.getScalarVal(),
Chris Lattner017d6aa2007-08-03 16:28:33 +0000798 Dst.getVectorIdx(), "vecins");
Eli Friedman1e692ac2008-06-13 23:01:12 +0000799 Builder.CreateStore(Vec, Dst.getVectorAddr(),Dst.isVolatileQualified());
Chris Lattner017d6aa2007-08-03 16:28:33 +0000800 return;
801 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000802
Nate Begeman213541a2008-04-18 23:10:10 +0000803 // If this is an update of extended vector elements, insert them as
804 // appropriate.
805 if (Dst.isExtVectorElt())
806 return EmitStoreThroughExtVectorComponentLValue(Src, Dst, Ty);
Lauro Ramos Venancioa0c5d0e2008-01-22 22:36:45 +0000807
Daniel Dunbarf0fe5bc2010-04-05 21:36:35 +0000808 if (Dst.isBitField())
Lauro Ramos Venancioa0c5d0e2008-01-22 22:36:45 +0000809 return EmitStoreThroughBitfieldLValue(Src, Dst, Ty);
810
Daniel Dunbar85c59ed2008-08-29 08:11:39 +0000811 if (Dst.isPropertyRef())
812 return EmitStoreThroughPropertyRefLValue(Src, Dst, Ty);
813
Chris Lattnereb99b012009-10-28 17:39:19 +0000814 assert(Dst.isKVCRef() && "Unknown LValue type");
815 return EmitStoreThroughKVCRefLValue(Src, Dst, Ty);
Chris Lattner017d6aa2007-08-03 16:28:33 +0000816 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000817
Fariborz Jahanian4f676ed2009-02-21 00:30:43 +0000818 if (Dst.isObjCWeak() && !Dst.isNonGC()) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000819 // load of a __weak object.
Fariborz Jahaniandbd32c22008-11-19 17:34:06 +0000820 llvm::Value *LvalueDst = Dst.getAddress();
821 llvm::Value *src = Src.getScalarVal();
Mike Stumpf33651c2009-04-14 00:57:29 +0000822 CGM.getObjCRuntime().EmitObjCWeakAssign(*this, src, LvalueDst);
Fariborz Jahaniandbd32c22008-11-19 17:34:06 +0000823 return;
824 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000825
Fariborz Jahanian4f676ed2009-02-21 00:30:43 +0000826 if (Dst.isObjCStrong() && !Dst.isNonGC()) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000827 // load of a __strong object.
Fariborz Jahaniandbd32c22008-11-19 17:34:06 +0000828 llvm::Value *LvalueDst = Dst.getAddress();
829 llvm::Value *src = Src.getScalarVal();
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +0000830 if (Dst.isObjCIvar()) {
831 assert(Dst.getBaseIvarExp() && "BaseIvarExp is NULL");
832 const llvm::Type *ResultType = ConvertType(getContext().LongTy);
833 llvm::Value *RHS = EmitScalarExpr(Dst.getBaseIvarExp());
Fariborz Jahanian76368e82009-09-25 00:00:20 +0000834 llvm::Value *dst = RHS;
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +0000835 RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast");
836 llvm::Value *LHS =
837 Builder.CreatePtrToInt(LvalueDst, ResultType, "sub.ptr.lhs.cast");
838 llvm::Value *BytesBetween = Builder.CreateSub(LHS, RHS, "ivar.offset");
Fariborz Jahanian76368e82009-09-25 00:00:20 +0000839 CGM.getObjCRuntime().EmitObjCIvarAssign(*this, src, dst,
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +0000840 BytesBetween);
Fariborz Jahanian021a7a62010-07-20 20:30:03 +0000841 } else if (Dst.isGlobalObjCRef()) {
842 CGM.getObjCRuntime().EmitObjCGlobalAssign(*this, src, LvalueDst,
843 Dst.isThreadLocalRef());
844 }
Fariborz Jahanianbf63b872009-05-04 23:27:20 +0000845 else
846 CGM.getObjCRuntime().EmitObjCStrongCastAssign(*this, src, LvalueDst);
Fariborz Jahaniandbd32c22008-11-19 17:34:06 +0000847 return;
848 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000849
Chris Lattner883f6a72007-08-11 00:04:45 +0000850 assert(Src.isScalar() && "Can't emit an agg store with this method");
Anders Carlssonb4aa4662009-05-19 18:50:41 +0000851 EmitStoreOfScalar(Src.getScalarVal(), Dst.getAddress(),
Daniel Dunbar9f4f7cf2010-08-21 02:39:23 +0000852 Dst.isVolatileQualified(), Dst.getAlignment(), Ty);
Reid Spencer5f016e22007-07-11 17:01:13 +0000853}
854
Lauro Ramos Venancioa0c5d0e2008-01-22 22:36:45 +0000855void CodeGenFunction::EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst,
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000856 QualType Ty,
Daniel Dunbared3849b2008-11-19 09:36:46 +0000857 llvm::Value **Result) {
Daniel Dunbarefbf4872010-04-06 01:07:44 +0000858 const CGBitFieldInfo &Info = Dst.getBitFieldInfo();
Lauro Ramos Venancioa0c5d0e2008-01-22 22:36:45 +0000859
Daniel Dunbar26772612010-04-15 03:47:33 +0000860 // Get the output type.
Anders Carlsson48035352010-04-17 21:52:22 +0000861 const llvm::Type *ResLTy = ConvertTypeForMem(Ty);
Daniel Dunbar26772612010-04-15 03:47:33 +0000862 unsigned ResSizeInBits = CGM.getTargetData().getTypeSizeInBits(ResLTy);
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000863
Daniel Dunbar26772612010-04-15 03:47:33 +0000864 // Get the source value, truncated to the width of the bit-field.
Daniel Dunbared3849b2008-11-19 09:36:46 +0000865 llvm::Value *SrcVal = Src.getScalarVal();
Anders Carlsson48035352010-04-17 21:52:22 +0000866
867 if (Ty->isBooleanType())
868 SrcVal = Builder.CreateIntCast(SrcVal, ResLTy, /*IsSigned=*/false);
869
Daniel Dunbar26772612010-04-15 03:47:33 +0000870 SrcVal = Builder.CreateAnd(SrcVal, llvm::APInt::getLowBitsSet(ResSizeInBits,
871 Info.getSize()),
872 "bf.value");
Lauro Ramos Venancioa0c5d0e2008-01-22 22:36:45 +0000873
Daniel Dunbared3849b2008-11-19 09:36:46 +0000874 // Return the new value of the bit-field, if requested.
875 if (Result) {
876 // Cast back to the proper type for result.
Daniel Dunbar26772612010-04-15 03:47:33 +0000877 const llvm::Type *SrcTy = Src.getScalarVal()->getType();
878 llvm::Value *ReloadVal = Builder.CreateIntCast(SrcVal, SrcTy, false,
879 "bf.reload.val");
Daniel Dunbared3849b2008-11-19 09:36:46 +0000880
881 // Sign extend if necessary.
Daniel Dunbar26772612010-04-15 03:47:33 +0000882 if (Info.isSigned()) {
883 unsigned ExtraBits = ResSizeInBits - Info.getSize();
884 if (ExtraBits)
885 ReloadVal = Builder.CreateAShr(Builder.CreateShl(ReloadVal, ExtraBits),
886 ExtraBits, "bf.reload.sext");
Daniel Dunbared3849b2008-11-19 09:36:46 +0000887 }
888
Daniel Dunbar26772612010-04-15 03:47:33 +0000889 *Result = ReloadVal;
Daniel Dunbared3849b2008-11-19 09:36:46 +0000890 }
891
Daniel Dunbar26772612010-04-15 03:47:33 +0000892 // Iterate over the components, writing each piece to memory.
893 for (unsigned i = 0, e = Info.getNumComponents(); i != e; ++i) {
894 const CGBitFieldInfo::AccessInfo &AI = Info.getComponent(i);
Eli Friedman316bb1b2008-05-17 20:03:47 +0000895
Daniel Dunbar26772612010-04-15 03:47:33 +0000896 // Get the field pointer.
897 llvm::Value *Ptr = Dst.getBitFieldBaseAddr();
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000898
Daniel Dunbar26772612010-04-15 03:47:33 +0000899 // Only offset by the field index if used, so that incoming values are not
900 // required to be structures.
901 if (AI.FieldIndex)
902 Ptr = Builder.CreateStructGEP(Ptr, AI.FieldIndex, "bf.field");
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000903
Daniel Dunbar26772612010-04-15 03:47:33 +0000904 // Offset by the byte offset, if used.
905 if (AI.FieldByteOffset) {
906 const llvm::Type *i8PTy = llvm::Type::getInt8PtrTy(VMContext);
907 Ptr = Builder.CreateBitCast(Ptr, i8PTy);
908 Ptr = Builder.CreateConstGEP1_32(Ptr, AI.FieldByteOffset,"bf.field.offs");
909 }
Eli Friedman316bb1b2008-05-17 20:03:47 +0000910
Daniel Dunbar26772612010-04-15 03:47:33 +0000911 // Cast to the access type.
912 const llvm::Type *PTy = llvm::Type::getIntNPtrTy(VMContext, AI.AccessWidth,
913 Ty.getAddressSpace());
914 Ptr = Builder.CreateBitCast(Ptr, PTy);
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000915
Daniel Dunbar26772612010-04-15 03:47:33 +0000916 // Extract the piece of the bit-field value to write in this access, limited
917 // to the values that are part of this access.
918 llvm::Value *Val = SrcVal;
919 if (AI.TargetBitOffset)
920 Val = Builder.CreateLShr(Val, AI.TargetBitOffset);
921 Val = Builder.CreateAnd(Val, llvm::APInt::getLowBitsSet(ResSizeInBits,
922 AI.TargetBitWidth));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000923
Daniel Dunbar26772612010-04-15 03:47:33 +0000924 // Extend or truncate to the access size.
925 const llvm::Type *AccessLTy =
926 llvm::Type::getIntNTy(VMContext, AI.AccessWidth);
927 if (ResSizeInBits < AI.AccessWidth)
928 Val = Builder.CreateZExt(Val, AccessLTy);
929 else if (ResSizeInBits > AI.AccessWidth)
930 Val = Builder.CreateTrunc(Val, AccessLTy);
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000931
Daniel Dunbar26772612010-04-15 03:47:33 +0000932 // Shift into the position in memory.
933 if (AI.FieldBitStart)
934 Val = Builder.CreateShl(Val, AI.FieldBitStart);
935
936 // If necessary, load and OR in bits that are outside of the bit-field.
937 if (AI.TargetBitWidth != AI.AccessWidth) {
938 llvm::LoadInst *Load = Builder.CreateLoad(Ptr, Dst.isVolatileQualified());
939 if (AI.AccessAlignment)
940 Load->setAlignment(AI.AccessAlignment);
941
942 // Compute the mask for zeroing the bits that are part of the bit-field.
943 llvm::APInt InvMask =
944 ~llvm::APInt::getBitsSet(AI.AccessWidth, AI.FieldBitStart,
945 AI.FieldBitStart + AI.TargetBitWidth);
946
947 // Apply the mask and OR in to the value to write.
948 Val = Builder.CreateOr(Builder.CreateAnd(Load, InvMask), Val);
949 }
950
951 // Write the value.
952 llvm::StoreInst *Store = Builder.CreateStore(Val, Ptr,
953 Dst.isVolatileQualified());
954 if (AI.AccessAlignment)
955 Store->setAlignment(AI.AccessAlignment);
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000956 }
Lauro Ramos Venancioa0c5d0e2008-01-22 22:36:45 +0000957}
958
Daniel Dunbar85c59ed2008-08-29 08:11:39 +0000959void CodeGenFunction::EmitStoreThroughPropertyRefLValue(RValue Src,
960 LValue Dst,
961 QualType Ty) {
962 EmitObjCPropertySet(Dst.getPropertyRefExpr(), Src);
963}
964
Fariborz Jahanian43f44702008-11-22 22:30:21 +0000965void CodeGenFunction::EmitStoreThroughKVCRefLValue(RValue Src,
966 LValue Dst,
967 QualType Ty) {
968 EmitObjCPropertySet(Dst.getKVCRefExpr(), Src);
969}
970
Nate Begeman213541a2008-04-18 23:10:10 +0000971void CodeGenFunction::EmitStoreThroughExtVectorComponentLValue(RValue Src,
972 LValue Dst,
973 QualType Ty) {
Chris Lattner017d6aa2007-08-03 16:28:33 +0000974 // This access turns into a read/modify/write of the vector. Load the input
975 // value now.
Eli Friedman1e692ac2008-06-13 23:01:12 +0000976 llvm::Value *Vec = Builder.CreateLoad(Dst.getExtVectorAddr(),
977 Dst.isVolatileQualified(), "tmp");
Nate Begeman8a997642008-05-09 06:41:27 +0000978 const llvm::Constant *Elts = Dst.getExtVectorElts();
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000979
Chris Lattner9b655512007-08-31 22:49:20 +0000980 llvm::Value *SrcVal = Src.getScalarVal();
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000981
John McCall183700f2009-09-21 23:43:11 +0000982 if (const VectorType *VTy = Ty->getAs<VectorType>()) {
Chris Lattner7e6b51b2007-08-03 16:37:04 +0000983 unsigned NumSrcElts = VTy->getNumElements();
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000984 unsigned NumDstElts =
985 cast<llvm::VectorType>(Vec->getType())->getNumElements();
986 if (NumDstElts == NumSrcElts) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000987 // Use shuffle vector is the src and destination are the same number of
988 // elements and restore the vector mask since it is on the side it will be
989 // stored.
Nate Begeman6e5dd862009-06-26 21:12:50 +0000990 llvm::SmallVector<llvm::Constant*, 4> Mask(NumDstElts);
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000991 for (unsigned i = 0; i != NumSrcElts; ++i) {
992 unsigned InIdx = getAccessedFieldNo(i, Elts);
Chris Lattner77b89b82010-06-27 07:15:29 +0000993 Mask[InIdx] = llvm::ConstantInt::get(Int32Ty, i);
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000994 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000995
Owen Anderson4a289322009-07-28 21:22:35 +0000996 llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size());
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000997 Vec = Builder.CreateShuffleVector(SrcVal,
Owen Anderson03e20502009-07-30 23:11:26 +0000998 llvm::UndefValue::get(Vec->getType()),
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000999 MaskV, "tmp");
Mike Stumpb3589f42009-07-30 22:28:39 +00001000 } else if (NumDstElts > NumSrcElts) {
Nate Begeman6fe7c8a2009-01-18 06:42:49 +00001001 // Extended the source vector to the same length and then shuffle it
1002 // into the destination.
1003 // FIXME: since we're shuffling with undef, can we just use the indices
1004 // into that? This could be simpler.
1005 llvm::SmallVector<llvm::Constant*, 4> ExtMask;
1006 unsigned i;
1007 for (i = 0; i != NumSrcElts; ++i)
Chris Lattnereb99b012009-10-28 17:39:19 +00001008 ExtMask.push_back(llvm::ConstantInt::get(Int32Ty, i));
Nate Begeman6fe7c8a2009-01-18 06:42:49 +00001009 for (; i != NumDstElts; ++i)
Chris Lattnereb99b012009-10-28 17:39:19 +00001010 ExtMask.push_back(llvm::UndefValue::get(Int32Ty));
Owen Anderson4a289322009-07-28 21:22:35 +00001011 llvm::Value *ExtMaskV = llvm::ConstantVector::get(&ExtMask[0],
Nate Begeman6fe7c8a2009-01-18 06:42:49 +00001012 ExtMask.size());
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001013 llvm::Value *ExtSrcVal =
Daniel Dunbarbb767732009-02-17 18:31:04 +00001014 Builder.CreateShuffleVector(SrcVal,
Owen Anderson03e20502009-07-30 23:11:26 +00001015 llvm::UndefValue::get(SrcVal->getType()),
Daniel Dunbarbb767732009-02-17 18:31:04 +00001016 ExtMaskV, "tmp");
Nate Begeman6fe7c8a2009-01-18 06:42:49 +00001017 // build identity
1018 llvm::SmallVector<llvm::Constant*, 4> Mask;
Chris Lattnereb99b012009-10-28 17:39:19 +00001019 for (unsigned i = 0; i != NumDstElts; ++i)
1020 Mask.push_back(llvm::ConstantInt::get(Int32Ty, i));
1021
Nate Begeman6fe7c8a2009-01-18 06:42:49 +00001022 // modify when what gets shuffled in
1023 for (unsigned i = 0; i != NumSrcElts; ++i) {
1024 unsigned Idx = getAccessedFieldNo(i, Elts);
Chris Lattnereb99b012009-10-28 17:39:19 +00001025 Mask[Idx] = llvm::ConstantInt::get(Int32Ty, i+NumDstElts);
Nate Begeman6fe7c8a2009-01-18 06:42:49 +00001026 }
Owen Anderson4a289322009-07-28 21:22:35 +00001027 llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size());
Nate Begeman6fe7c8a2009-01-18 06:42:49 +00001028 Vec = Builder.CreateShuffleVector(Vec, ExtSrcVal, MaskV, "tmp");
Mike Stumpb3589f42009-07-30 22:28:39 +00001029 } else {
Nate Begeman6fe7c8a2009-01-18 06:42:49 +00001030 // We should never shorten the vector
1031 assert(0 && "unexpected shorten vector length");
Chris Lattner7e6b51b2007-08-03 16:37:04 +00001032 }
1033 } else {
1034 // If the Src is a scalar (not a vector) it must be updating one element.
Dan Gohman4f8d1232008-05-22 00:50:06 +00001035 unsigned InIdx = getAccessedFieldNo(0, Elts);
Chris Lattnereb99b012009-10-28 17:39:19 +00001036 llvm::Value *Elt = llvm::ConstantInt::get(Int32Ty, InIdx);
Chris Lattner017d6aa2007-08-03 16:28:33 +00001037 Vec = Builder.CreateInsertElement(Vec, SrcVal, Elt, "tmp");
Chris Lattner017d6aa2007-08-03 16:28:33 +00001038 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001039
Eli Friedman1e692ac2008-06-13 23:01:12 +00001040 Builder.CreateStore(Vec, Dst.getExtVectorAddr(), Dst.isVolatileQualified());
Chris Lattner017d6aa2007-08-03 16:28:33 +00001041}
1042
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001043// setObjCGCLValueClass - sets class of he lvalue for the purpose of
1044// generating write-barries API. It is currently a global, ivar,
1045// or neither.
Chris Lattnereb99b012009-10-28 17:39:19 +00001046static void setObjCGCLValueClass(const ASTContext &Ctx, const Expr *E,
1047 LValue &LV) {
Fariborz Jahanianb9242592009-09-21 23:03:37 +00001048 if (Ctx.getLangOptions().getGCMode() == LangOptions::NonGC)
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001049 return;
1050
Fariborz Jahaniandbf3cfd2009-09-16 23:11:23 +00001051 if (isa<ObjCIvarRefExpr>(E)) {
Daniel Dunbar3491b3d2010-08-21 03:51:29 +00001052 LV.setObjCIvar(true);
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +00001053 ObjCIvarRefExpr *Exp = cast<ObjCIvarRefExpr>(const_cast<Expr*>(E));
1054 LV.setBaseIvarExp(Exp->getBase());
Daniel Dunbar3491b3d2010-08-21 03:51:29 +00001055 LV.setObjCArray(E->getType()->isArrayType());
Fariborz Jahaniandbf3cfd2009-09-16 23:11:23 +00001056 return;
1057 }
Chris Lattnereb99b012009-10-28 17:39:19 +00001058
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001059 if (const DeclRefExpr *Exp = dyn_cast<DeclRefExpr>(E)) {
1060 if (const VarDecl *VD = dyn_cast<VarDecl>(Exp->getDecl())) {
1061 if ((VD->isBlockVarDecl() && !VD->hasLocalStorage()) ||
Fariborz Jahanian021a7a62010-07-20 20:30:03 +00001062 VD->isFileVarDecl()) {
Daniel Dunbar3491b3d2010-08-21 03:51:29 +00001063 LV.setGlobalObjCRef(true);
1064 LV.setThreadLocalRef(VD->isThreadSpecified());
Fariborz Jahanian021a7a62010-07-20 20:30:03 +00001065 }
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001066 }
Daniel Dunbar3491b3d2010-08-21 03:51:29 +00001067 LV.setObjCArray(E->getType()->isArrayType());
Chris Lattnereb99b012009-10-28 17:39:19 +00001068 return;
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001069 }
Chris Lattnereb99b012009-10-28 17:39:19 +00001070
1071 if (const UnaryOperator *Exp = dyn_cast<UnaryOperator>(E)) {
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001072 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV);
Chris Lattnereb99b012009-10-28 17:39:19 +00001073 return;
1074 }
1075
1076 if (const ParenExpr *Exp = dyn_cast<ParenExpr>(E)) {
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001077 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV);
Fariborz Jahanian75b08f12009-09-30 17:10:29 +00001078 if (LV.isObjCIvar()) {
1079 // If cast is to a structure pointer, follow gcc's behavior and make it
1080 // a non-ivar write-barrier.
1081 QualType ExpTy = E->getType();
1082 if (ExpTy->isPointerType())
1083 ExpTy = ExpTy->getAs<PointerType>()->getPointeeType();
1084 if (ExpTy->isRecordType())
Daniel Dunbar3491b3d2010-08-21 03:51:29 +00001085 LV.setObjCIvar(false);
Chris Lattnereb99b012009-10-28 17:39:19 +00001086 }
1087 return;
Fariborz Jahanian75b08f12009-09-30 17:10:29 +00001088 }
Chris Lattnereb99b012009-10-28 17:39:19 +00001089 if (const ImplicitCastExpr *Exp = dyn_cast<ImplicitCastExpr>(E)) {
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001090 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV);
Chris Lattnereb99b012009-10-28 17:39:19 +00001091 return;
1092 }
1093
1094 if (const CStyleCastExpr *Exp = dyn_cast<CStyleCastExpr>(E)) {
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001095 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV);
Chris Lattnereb99b012009-10-28 17:39:19 +00001096 return;
1097 }
1098
1099 if (const ArraySubscriptExpr *Exp = dyn_cast<ArraySubscriptExpr>(E)) {
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001100 setObjCGCLValueClass(Ctx, Exp->getBase(), LV);
Fariborz Jahanianfd02ed72009-09-21 18:54:29 +00001101 if (LV.isObjCIvar() && !LV.isObjCArray())
Fariborz Jahanian1c1afc42009-09-18 00:04:00 +00001102 // Using array syntax to assigning to what an ivar points to is not
1103 // same as assigning to the ivar itself. {id *Names;} Names[i] = 0;
Daniel Dunbar3491b3d2010-08-21 03:51:29 +00001104 LV.setObjCIvar(false);
Fariborz Jahanianfd02ed72009-09-21 18:54:29 +00001105 else if (LV.isGlobalObjCRef() && !LV.isObjCArray())
1106 // Using array syntax to assigning to what global points to is not
1107 // same as assigning to the global itself. {id *G;} G[i] = 0;
Daniel Dunbar3491b3d2010-08-21 03:51:29 +00001108 LV.setGlobalObjCRef(false);
Chris Lattnereb99b012009-10-28 17:39:19 +00001109 return;
Fariborz Jahanian1c1afc42009-09-18 00:04:00 +00001110 }
Chris Lattnereb99b012009-10-28 17:39:19 +00001111
1112 if (const MemberExpr *Exp = dyn_cast<MemberExpr>(E)) {
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001113 setObjCGCLValueClass(Ctx, Exp->getBase(), LV);
Fariborz Jahanian1c1afc42009-09-18 00:04:00 +00001114 // We don't know if member is an 'ivar', but this flag is looked at
1115 // only in the context of LV.isObjCIvar().
Daniel Dunbar3491b3d2010-08-21 03:51:29 +00001116 LV.setObjCArray(E->getType()->isArrayType());
Chris Lattnereb99b012009-10-28 17:39:19 +00001117 return;
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001118 }
1119}
1120
Anders Carlssonce53f7d2009-11-07 23:06:58 +00001121static LValue EmitGlobalVarDeclLValue(CodeGenFunction &CGF,
1122 const Expr *E, const VarDecl *VD) {
Daniel Dunbard2113f22009-11-08 09:46:46 +00001123 assert((VD->hasExternalStorage() || VD->isFileVarDecl()) &&
Anders Carlssonce53f7d2009-11-07 23:06:58 +00001124 "Var decl must have external storage or be a file var decl!");
1125
1126 llvm::Value *V = CGF.CGM.GetAddrOfGlobalVar(VD);
1127 if (VD->getType()->isReferenceType())
1128 V = CGF.Builder.CreateLoad(V, "tmp");
Daniel Dunbar983e3d72010-08-21 04:20:22 +00001129 unsigned Alignment = CGF.getContext().getDeclAlign(VD).getQuantity();
1130 LValue LV = CGF.MakeAddrLValue(V, E->getType(), Alignment);
Anders Carlssonce53f7d2009-11-07 23:06:58 +00001131 setObjCGCLValueClass(CGF.getContext(), E, LV);
1132 return LV;
1133}
1134
Eli Friedman9a146302009-11-26 06:08:14 +00001135static LValue EmitFunctionDeclLValue(CodeGenFunction &CGF,
1136 const Expr *E, const FunctionDecl *FD) {
1137 llvm::Value* V = CGF.CGM.GetAddrOfFunction(FD);
1138 if (!FD->hasPrototype()) {
1139 if (const FunctionProtoType *Proto =
1140 FD->getType()->getAs<FunctionProtoType>()) {
1141 // Ugly case: for a K&R-style definition, the type of the definition
1142 // isn't the same as the type of a use. Correct for this with a
1143 // bitcast.
1144 QualType NoProtoType =
1145 CGF.getContext().getFunctionNoProtoType(Proto->getResultType());
1146 NoProtoType = CGF.getContext().getPointerType(NoProtoType);
1147 V = CGF.Builder.CreateBitCast(V, CGF.ConvertType(NoProtoType), "tmp");
1148 }
1149 }
Daniel Dunbar983e3d72010-08-21 04:20:22 +00001150 unsigned Alignment = CGF.getContext().getDeclAlign(FD).getQuantity();
1151 return CGF.MakeAddrLValue(V, E->getType(), Alignment);
Eli Friedman9a146302009-11-26 06:08:14 +00001152}
1153
Reid Spencer5f016e22007-07-11 17:01:13 +00001154LValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) {
Anders Carlsson1e74c4f2009-11-07 22:53:10 +00001155 const NamedDecl *ND = E->getDecl();
Daniel Dunbar983e3d72010-08-21 04:20:22 +00001156 unsigned Alignment = CGF.getContext().getDeclAlign(ND).getQuantity();
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001157
Rafael Espindola6a836702010-03-04 18:17:24 +00001158 if (ND->hasAttr<WeakRefAttr>()) {
1159 const ValueDecl* VD = cast<ValueDecl>(ND);
1160 llvm::Constant *Aliasee = CGM.GetWeakRefReference(VD);
Daniel Dunbar983e3d72010-08-21 04:20:22 +00001161 return MakeAddrLValue(Aliasee, E->getType(), Alignment);
Rafael Espindola6a836702010-03-04 18:17:24 +00001162 }
1163
Anders Carlsson1e74c4f2009-11-07 22:53:10 +00001164 if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) {
Anders Carlsson1e74c4f2009-11-07 22:53:10 +00001165
1166 // Check if this is a global variable.
Anders Carlssonce53f7d2009-11-07 23:06:58 +00001167 if (VD->hasExternalStorage() || VD->isFileVarDecl())
1168 return EmitGlobalVarDeclLValue(*this, E, VD);
Anders Carlsson0bc70492009-11-07 22:46:42 +00001169
1170 bool NonGCable = VD->hasLocalStorage() && !VD->hasAttr<BlocksAttr>();
1171
1172 llvm::Value *V = LocalDeclMap[VD];
Fariborz Jahanian63326a52010-04-19 18:15:02 +00001173 if (!V && getContext().getLangOptions().CPlusPlus &&
1174 VD->isStaticLocal())
1175 V = CGM.getStaticLocalDeclAddress(VD);
Anders Carlsson0bc70492009-11-07 22:46:42 +00001176 assert(V && "DeclRefExpr not entered in LocalDeclMap?");
1177
Anders Carlsson0bc70492009-11-07 22:46:42 +00001178 if (VD->hasAttr<BlocksAttr>()) {
1179 V = Builder.CreateStructGEP(V, 1, "forwarding");
Daniel Dunbar2da84ff2009-11-29 21:23:36 +00001180 V = Builder.CreateLoad(V);
Anders Carlsson0bc70492009-11-07 22:46:42 +00001181 V = Builder.CreateStructGEP(V, getByRefValueLLVMField(VD),
1182 VD->getNameAsString());
1183 }
1184 if (VD->getType()->isReferenceType())
1185 V = Builder.CreateLoad(V, "tmp");
Daniel Dunbar6d5eb762010-08-21 03:44:13 +00001186
Daniel Dunbar983e3d72010-08-21 04:20:22 +00001187 LValue LV = MakeAddrLValue(V, E->getType(), Alignment);
Daniel Dunbarea619172010-08-21 03:22:38 +00001188 if (NonGCable) {
Daniel Dunbar6d5eb762010-08-21 03:44:13 +00001189 LV.getQuals().removeObjCGCAttr();
Daniel Dunbarea619172010-08-21 03:22:38 +00001190 LV.setNonGC(true);
1191 }
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001192 setObjCGCLValueClass(getContext(), E, LV);
Fariborz Jahanian2682d8b2008-11-20 00:15:42 +00001193 return LV;
Chris Lattnereb99b012009-10-28 17:39:19 +00001194 }
1195
John McCalld608cdb2010-08-22 10:59:02 +00001196 // If we're emitting an instance method as an independent lvalue,
1197 // we're actually emitting a member pointer.
1198 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(ND))
1199 if (MD->isInstance()) {
John McCall0bab0cd2010-08-23 01:21:21 +00001200 llvm::Value *V = CGM.getCXXABI().EmitMemberPointer(MD);
John McCalld608cdb2010-08-22 10:59:02 +00001201 return MakeAddrLValue(V, MD->getType(), Alignment);
1202 }
Eli Friedman9a146302009-11-26 06:08:14 +00001203 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND))
1204 return EmitFunctionDeclLValue(*this, E, FD);
Chris Lattnereb99b012009-10-28 17:39:19 +00001205
John McCalld608cdb2010-08-22 10:59:02 +00001206 // If we're emitting a field as an independent lvalue, we're
1207 // actually emitting a member pointer.
1208 if (const FieldDecl *FD = dyn_cast<FieldDecl>(ND)) {
John McCall0bab0cd2010-08-23 01:21:21 +00001209 llvm::Value *V = CGM.getCXXABI().EmitMemberPointer(FD);
Daniel Dunbar983e3d72010-08-21 04:20:22 +00001210 return MakeAddrLValue(V, FD->getType(), Alignment);
Chris Lattner41110242008-06-17 18:05:57 +00001211 }
Chris Lattnereb99b012009-10-28 17:39:19 +00001212
Anders Carlsson1e74c4f2009-11-07 22:53:10 +00001213 assert(false && "Unhandled DeclRefExpr");
1214
1215 // an invalid LValue, but the assert will
1216 // ensure that this point is never reached.
Chris Lattnerb1776cb2007-09-16 19:23:47 +00001217 return LValue();
Reid Spencer5f016e22007-07-11 17:01:13 +00001218}
1219
Mike Stumpa99038c2009-02-28 09:07:16 +00001220LValue CodeGenFunction::EmitBlockDeclRefLValue(const BlockDeclRefExpr *E) {
Daniel Dunbar983e3d72010-08-21 04:20:22 +00001221 unsigned Alignment =
1222 CGF.getContext().getDeclAlign(E->getDecl()).getQuantity();
1223 return MakeAddrLValue(GetAddrOfBlockDecl(E), E->getType(), Alignment);
Mike Stumpa99038c2009-02-28 09:07:16 +00001224}
1225
Reid Spencer5f016e22007-07-11 17:01:13 +00001226LValue CodeGenFunction::EmitUnaryOpLValue(const UnaryOperator *E) {
1227 // __extension__ doesn't affect lvalue-ness.
John McCall2de56d12010-08-25 11:45:40 +00001228 if (E->getOpcode() == UO_Extension)
Reid Spencer5f016e22007-07-11 17:01:13 +00001229 return EmitLValue(E->getSubExpr());
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001230
Chris Lattner96196622008-07-26 22:37:01 +00001231 QualType ExprTy = getContext().getCanonicalType(E->getSubExpr()->getType());
Chris Lattner7da36f62007-10-30 22:53:42 +00001232 switch (E->getOpcode()) {
1233 default: assert(0 && "Unknown unary operator lvalue!");
John McCall2de56d12010-08-25 11:45:40 +00001234 case UO_Deref: {
Chris Lattnereb99b012009-10-28 17:39:19 +00001235 QualType T = E->getSubExpr()->getType()->getPointeeType();
1236 assert(!T.isNull() && "CodeGenFunction::EmitUnaryOpLValue: Illegal type");
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001237
Daniel Dunbar6d5eb762010-08-21 03:44:13 +00001238 LValue LV = MakeAddrLValue(EmitScalarExpr(E->getSubExpr()), T);
1239 LV.getQuals().setAddressSpace(ExprTy.getAddressSpace());
John McCall0953e762009-09-24 19:53:00 +00001240
Chris Lattnereb99b012009-10-28 17:39:19 +00001241 // We should not generate __weak write barrier on indirect reference
1242 // of a pointer to object; as in void foo (__weak id *param); *param = 0;
1243 // But, we continue to generate __strong write barrier on indirect write
1244 // into a pointer to object.
1245 if (getContext().getLangOptions().ObjC1 &&
1246 getContext().getLangOptions().getGCMode() != LangOptions::NonGC &&
1247 LV.isObjCWeak())
Daniel Dunbarea619172010-08-21 03:22:38 +00001248 LV.setNonGC(!E->isOBJCGCCandidate(getContext()));
Chris Lattnereb99b012009-10-28 17:39:19 +00001249 return LV;
1250 }
John McCall2de56d12010-08-25 11:45:40 +00001251 case UO_Real:
1252 case UO_Imag: {
Chris Lattner7da36f62007-10-30 22:53:42 +00001253 LValue LV = EmitLValue(E->getSubExpr());
John McCall2de56d12010-08-25 11:45:40 +00001254 unsigned Idx = E->getOpcode() == UO_Imag;
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001255 return MakeAddrLValue(Builder.CreateStructGEP(LV.getAddress(),
Chris Lattnerb77792e2008-07-26 22:17:49 +00001256 Idx, "idx"),
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001257 ExprTy);
Chris Lattner7da36f62007-10-30 22:53:42 +00001258 }
John McCall2de56d12010-08-25 11:45:40 +00001259 case UO_PreInc:
1260 case UO_PreDec: {
Chris Lattner197a3382010-01-09 21:44:40 +00001261 LValue LV = EmitLValue(E->getSubExpr());
John McCall2de56d12010-08-25 11:45:40 +00001262 bool isInc = E->getOpcode() == UO_PreInc;
Chris Lattner197a3382010-01-09 21:44:40 +00001263
1264 if (E->getType()->isAnyComplexType())
1265 EmitComplexPrePostIncDec(E, LV, isInc, true/*isPre*/);
1266 else
1267 EmitScalarPrePostIncDec(E, LV, isInc, true/*isPre*/);
1268 return LV;
1269 }
Eli Friedmane401cd52009-11-09 04:20:47 +00001270 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001271}
1272
1273LValue CodeGenFunction::EmitStringLiteralLValue(const StringLiteral *E) {
Daniel Dunbar79c39282010-08-21 03:15:20 +00001274 return MakeAddrLValue(CGM.GetAddrOfConstantStringFromLiteral(E),
1275 E->getType());
Reid Spencer5f016e22007-07-11 17:01:13 +00001276}
1277
Chris Lattnereaf2bb82009-02-24 22:18:39 +00001278LValue CodeGenFunction::EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E) {
Daniel Dunbar79c39282010-08-21 03:15:20 +00001279 return MakeAddrLValue(CGM.GetAddrOfConstantStringFromObjCEncode(E),
1280 E->getType());
Chris Lattnereaf2bb82009-02-24 22:18:39 +00001281}
1282
1283
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001284LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) {
Daniel Dunbar662b71e2008-10-17 21:58:32 +00001285 switch (E->getIdentType()) {
1286 default:
1287 return EmitUnsupportedLValue(E, "predefined expression");
Daniel Dunbar3ec0baf2010-08-21 03:01:12 +00001288
Daniel Dunbar662b71e2008-10-17 21:58:32 +00001289 case PredefinedExpr::Func:
1290 case PredefinedExpr::Function:
Daniel Dunbar3ec0baf2010-08-21 03:01:12 +00001291 case PredefinedExpr::PrettyFunction: {
1292 unsigned Type = E->getIdentType();
1293 std::string GlobalVarName;
1294
1295 switch (Type) {
1296 default: assert(0 && "Invalid type");
1297 case PredefinedExpr::Func:
1298 GlobalVarName = "__func__.";
1299 break;
1300 case PredefinedExpr::Function:
1301 GlobalVarName = "__FUNCTION__.";
1302 break;
1303 case PredefinedExpr::PrettyFunction:
1304 GlobalVarName = "__PRETTY_FUNCTION__.";
1305 break;
1306 }
1307
1308 llvm::StringRef FnName = CurFn->getName();
1309 if (FnName.startswith("\01"))
1310 FnName = FnName.substr(1);
1311 GlobalVarName += FnName;
1312
1313 const Decl *CurDecl = CurCodeDecl;
1314 if (CurDecl == 0)
1315 CurDecl = getContext().getTranslationUnitDecl();
1316
1317 std::string FunctionName =
1318 PredefinedExpr::ComputeName((PredefinedExpr::IdentType)Type, CurDecl);
1319
1320 llvm::Constant *C =
1321 CGM.GetAddrOfConstantCString(FunctionName, GlobalVarName.c_str());
Daniel Dunbar79c39282010-08-21 03:15:20 +00001322 return MakeAddrLValue(C, E->getType());
Daniel Dunbar3ec0baf2010-08-21 03:01:12 +00001323 }
Daniel Dunbar662b71e2008-10-17 21:58:32 +00001324 }
Anders Carlsson22742662007-07-21 05:21:51 +00001325}
1326
Mike Stumpd8af3602009-12-15 01:22:35 +00001327llvm::BasicBlock *CodeGenFunction::getTrapBB() {
Mike Stump41513442009-12-15 00:59:40 +00001328 const CodeGenOptions &GCO = CGM.getCodeGenOpts();
1329
1330 // If we are not optimzing, don't collapse all calls to trap in the function
1331 // to the same call, that way, in the debugger they can see which operation
Chris Lattner6c552c12010-07-20 20:19:24 +00001332 // did in fact fail. If we are optimizing, we collapse all calls to trap down
Mike Stump41513442009-12-15 00:59:40 +00001333 // to just one per function to save on codesize.
Chris Lattner6c552c12010-07-20 20:19:24 +00001334 if (GCO.OptimizationLevel && TrapBB)
Mike Stump15037ca2009-12-15 00:35:12 +00001335 return TrapBB;
Mike Stump9c276ae2009-12-12 01:27:46 +00001336
1337 llvm::BasicBlock *Cont = 0;
1338 if (HaveInsertPoint()) {
1339 Cont = createBasicBlock("cont");
1340 EmitBranch(Cont);
1341 }
Mike Stump15037ca2009-12-15 00:35:12 +00001342 TrapBB = createBasicBlock("trap");
1343 EmitBlock(TrapBB);
1344
1345 llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::trap, 0, 0);
1346 llvm::CallInst *TrapCall = Builder.CreateCall(F);
1347 TrapCall->setDoesNotReturn();
1348 TrapCall->setDoesNotThrow();
Mike Stump9c276ae2009-12-12 01:27:46 +00001349 Builder.CreateUnreachable();
1350
1351 if (Cont)
1352 EmitBlock(Cont);
Mike Stump15037ca2009-12-15 00:35:12 +00001353 return TrapBB;
Mike Stump9c276ae2009-12-12 01:27:46 +00001354}
1355
Chris Lattner9269d5c2010-06-26 23:03:20 +00001356/// isSimpleArrayDecayOperand - If the specified expr is a simple decay from an
1357/// array to pointer, return the array subexpression.
1358static const Expr *isSimpleArrayDecayOperand(const Expr *E) {
1359 // If this isn't just an array->pointer decay, bail out.
1360 const CastExpr *CE = dyn_cast<CastExpr>(E);
John McCall2de56d12010-08-25 11:45:40 +00001361 if (CE == 0 || CE->getCastKind() != CK_ArrayToPointerDecay)
Chris Lattner9269d5c2010-06-26 23:03:20 +00001362 return 0;
1363
1364 // If this is a decay from variable width array, bail out.
1365 const Expr *SubExpr = CE->getSubExpr();
1366 if (SubExpr->getType()->isVariableArrayType())
1367 return 0;
1368
1369 return SubExpr;
1370}
1371
Reid Spencer5f016e22007-07-11 17:01:13 +00001372LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) {
Ted Kremenek23245122007-08-20 16:18:38 +00001373 // The index must always be an integer, which is not an aggregate. Emit it.
Chris Lattner7f02f722007-08-24 05:35:26 +00001374 llvm::Value *Idx = EmitScalarExpr(E->getIdx());
Eli Friedman61d004a2009-06-06 19:09:26 +00001375 QualType IdxTy = E->getIdx()->getType();
1376 bool IdxSigned = IdxTy->isSignedIntegerType();
1377
Reid Spencer5f016e22007-07-11 17:01:13 +00001378 // If the base is a vector type, then we are forming a vector element lvalue
1379 // with this subscript.
Eli Friedman1e692ac2008-06-13 23:01:12 +00001380 if (E->getBase()->getType()->isVectorType()) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001381 // Emit the vector as an lvalue to get its address.
Eli Friedman1e692ac2008-06-13 23:01:12 +00001382 LValue LHS = EmitLValue(E->getBase());
Ted Kremenek23245122007-08-20 16:18:38 +00001383 assert(LHS.isSimple() && "Can only subscript lvalue vectors here!");
Chris Lattner77b89b82010-06-27 07:15:29 +00001384 Idx = Builder.CreateIntCast(Idx, CGF.Int32Ty, IdxSigned, "vidx");
Eli Friedman1e692ac2008-06-13 23:01:12 +00001385 return LValue::MakeVectorElt(LHS.getAddress(), Idx,
John McCall0953e762009-09-24 19:53:00 +00001386 E->getBase()->getType().getCVRQualifiers());
Reid Spencer5f016e22007-07-11 17:01:13 +00001387 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001388
Ted Kremenek23245122007-08-20 16:18:38 +00001389 // Extend or truncate the index type to 32 or 64-bits.
Chris Lattnera4d94ab2010-06-26 22:40:46 +00001390 if (!Idx->getType()->isIntegerTy(LLVMPointerWidth))
Chris Lattner77b89b82010-06-27 07:15:29 +00001391 Idx = Builder.CreateIntCast(Idx, IntPtrTy,
Reid Spencer5f016e22007-07-11 17:01:13 +00001392 IdxSigned, "idxprom");
Chris Lattnera4d94ab2010-06-26 22:40:46 +00001393
Mike Stumpb14e62d2009-12-16 02:57:00 +00001394 // FIXME: As llvm implements the object size checking, this can come out.
Mike Stump9c276ae2009-12-12 01:27:46 +00001395 if (CatchUndefined) {
Chris Lattnera4d94ab2010-06-26 22:40:46 +00001396 if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E->getBase())){
Mike Stump9c276ae2009-12-12 01:27:46 +00001397 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr())) {
John McCall2de56d12010-08-25 11:45:40 +00001398 if (ICE->getCastKind() == CK_ArrayToPointerDecay) {
Mike Stump9c276ae2009-12-12 01:27:46 +00001399 if (const ConstantArrayType *CAT
1400 = getContext().getAsConstantArrayType(DRE->getType())) {
1401 llvm::APInt Size = CAT->getSize();
1402 llvm::BasicBlock *Cont = createBasicBlock("cont");
Mike Stump750c85e2009-12-14 22:14:31 +00001403 Builder.CreateCondBr(Builder.CreateICmpULE(Idx,
Mike Stump9c276ae2009-12-12 01:27:46 +00001404 llvm::ConstantInt::get(Idx->getType(), Size)),
Mike Stump15037ca2009-12-15 00:35:12 +00001405 Cont, getTrapBB());
Mike Stump96a063a2009-12-14 20:52:00 +00001406 EmitBlock(Cont);
Mike Stump9c276ae2009-12-12 01:27:46 +00001407 }
1408 }
1409 }
1410 }
1411 }
1412
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001413 // We know that the pointer points to a type of the correct size, unless the
1414 // size is a VLA or Objective-C interface.
Daniel Dunbar2a866252009-04-25 05:08:32 +00001415 llvm::Value *Address = 0;
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001416 if (const VariableArrayType *VAT =
Anders Carlsson8b33c082008-12-21 00:11:23 +00001417 getContext().getAsVariableArrayType(E->getType())) {
Chris Lattner881eb9c2009-08-14 23:43:22 +00001418 llvm::Value *VLASize = GetVLASize(VAT);
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001419
Anders Carlsson8b33c082008-12-21 00:11:23 +00001420 Idx = Builder.CreateMul(Idx, VLASize);
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001421
Anders Carlsson6183a992008-12-21 03:44:36 +00001422 QualType BaseType = getContext().getBaseElementType(VAT);
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001423
Ken Dyck199c3d62010-01-11 17:06:35 +00001424 CharUnits BaseTypeSize = getContext().getTypeSizeInChars(BaseType);
Anders Carlsson8b33c082008-12-21 00:11:23 +00001425 Idx = Builder.CreateUDiv(Idx,
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001426 llvm::ConstantInt::get(Idx->getType(),
Ken Dyck199c3d62010-01-11 17:06:35 +00001427 BaseTypeSize.getQuantity()));
Chris Lattner9269d5c2010-06-26 23:03:20 +00001428
1429 // The base must be a pointer, which is not an aggregate. Emit it.
1430 llvm::Value *Base = EmitScalarExpr(E->getBase());
1431
Dan Gohman664f8932009-08-12 00:33:55 +00001432 Address = Builder.CreateInBoundsGEP(Base, Idx, "arrayidx");
Chris Lattner9269d5c2010-06-26 23:03:20 +00001433 } else if (const ObjCObjectType *OIT = E->getType()->getAs<ObjCObjectType>()){
1434 // Indexing over an interface, as in "NSString *P; P[4];"
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001435 llvm::Value *InterfaceSize =
Owen Anderson4a28d5d2009-07-24 23:12:58 +00001436 llvm::ConstantInt::get(Idx->getType(),
Ken Dyck199c3d62010-01-11 17:06:35 +00001437 getContext().getTypeSizeInChars(OIT).getQuantity());
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001438
Daniel Dunbar2a866252009-04-25 05:08:32 +00001439 Idx = Builder.CreateMul(Idx, InterfaceSize);
1440
Benjamin Kramer3c0ef8c2009-10-13 10:07:13 +00001441 const llvm::Type *i8PTy = llvm::Type::getInt8PtrTy(VMContext);
Chris Lattner9269d5c2010-06-26 23:03:20 +00001442
1443 // The base must be a pointer, which is not an aggregate. Emit it.
1444 llvm::Value *Base = EmitScalarExpr(E->getBase());
Dan Gohman664f8932009-08-12 00:33:55 +00001445 Address = Builder.CreateGEP(Builder.CreateBitCast(Base, i8PTy),
Daniel Dunbar2a866252009-04-25 05:08:32 +00001446 Idx, "arrayidx");
1447 Address = Builder.CreateBitCast(Address, Base->getType());
Chris Lattner9269d5c2010-06-26 23:03:20 +00001448 } else if (const Expr *Array = isSimpleArrayDecayOperand(E->getBase())) {
1449 // If this is A[i] where A is an array, the frontend will have decayed the
1450 // base to be a ArrayToPointerDecay implicit cast. While correct, it is
1451 // inefficient at -O0 to emit a "gep A, 0, 0" when codegen'ing it, then a
1452 // "gep x, i" here. Emit one "gep A, 0, i".
1453 assert(Array->getType()->isArrayType() &&
1454 "Array to pointer decay must have array source type!");
1455 llvm::Value *ArrayPtr = EmitLValue(Array).getAddress();
Chris Lattner9269d5c2010-06-26 23:03:20 +00001456 llvm::Value *Zero = llvm::ConstantInt::get(Int32Ty, 0);
1457 llvm::Value *Args[] = { Zero, Idx };
1458
1459 Address = Builder.CreateInBoundsGEP(ArrayPtr, Args, Args+2, "arrayidx");
Daniel Dunbar2a866252009-04-25 05:08:32 +00001460 } else {
Chris Lattner9269d5c2010-06-26 23:03:20 +00001461 // The base must be a pointer, which is not an aggregate. Emit it.
1462 llvm::Value *Base = EmitScalarExpr(E->getBase());
Dan Gohman664f8932009-08-12 00:33:55 +00001463 Address = Builder.CreateInBoundsGEP(Base, Idx, "arrayidx");
Anders Carlsson8b33c082008-12-21 00:11:23 +00001464 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001465
Steve Naroff14108da2009-07-10 23:34:53 +00001466 QualType T = E->getBase()->getType()->getPointeeType();
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001467 assert(!T.isNull() &&
Steve Naroff14108da2009-07-10 23:34:53 +00001468 "CodeGenFunction::EmitArraySubscriptExpr(): Illegal base type");
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001469
Daniel Dunbar6d5eb762010-08-21 03:44:13 +00001470 LValue LV = MakeAddrLValue(Address, T);
1471 LV.getQuals().setAddressSpace(E->getBase()->getType().getAddressSpace());
John McCall0953e762009-09-24 19:53:00 +00001472
Fariborz Jahanian643887a2009-02-21 23:37:19 +00001473 if (getContext().getLangOptions().ObjC1 &&
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001474 getContext().getLangOptions().getGCMode() != LangOptions::NonGC) {
Daniel Dunbarea619172010-08-21 03:22:38 +00001475 LV.setNonGC(!E->isOBJCGCCandidate(getContext()));
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001476 setObjCGCLValueClass(getContext(), E, LV);
1477 }
Fariborz Jahanian643887a2009-02-21 23:37:19 +00001478 return LV;
Reid Spencer5f016e22007-07-11 17:01:13 +00001479}
1480
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001481static
Owen Andersona1cf15f2009-07-14 23:10:40 +00001482llvm::Constant *GenerateConstantVector(llvm::LLVMContext &VMContext,
1483 llvm::SmallVector<unsigned, 4> &Elts) {
Chris Lattner998eab12009-12-23 21:31:11 +00001484 llvm::SmallVector<llvm::Constant*, 4> CElts;
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001485
Chris Lattner77b89b82010-06-27 07:15:29 +00001486 const llvm::Type *Int32Ty = llvm::Type::getInt32Ty(VMContext);
Nate Begeman3b8d1162008-05-13 21:03:02 +00001487 for (unsigned i = 0, e = Elts.size(); i != e; ++i)
Chris Lattner77b89b82010-06-27 07:15:29 +00001488 CElts.push_back(llvm::ConstantInt::get(Int32Ty, Elts[i]));
Nate Begeman3b8d1162008-05-13 21:03:02 +00001489
Owen Anderson4a289322009-07-28 21:22:35 +00001490 return llvm::ConstantVector::get(&CElts[0], CElts.size());
Nate Begeman3b8d1162008-05-13 21:03:02 +00001491}
1492
Chris Lattner349aaec2007-08-02 23:37:31 +00001493LValue CodeGenFunction::
Nate Begeman213541a2008-04-18 23:10:10 +00001494EmitExtVectorElementExpr(const ExtVectorElementExpr *E) {
Chris Lattner349aaec2007-08-02 23:37:31 +00001495 // Emit the base vector as an l-value.
Chris Lattner73525de2009-02-16 21:11:58 +00001496 LValue Base;
1497
1498 // ExtVectorElementExpr's base can either be a vector or pointer to vector.
Chris Lattner998eab12009-12-23 21:31:11 +00001499 if (E->isArrow()) {
1500 // If it is a pointer to a vector, emit the address and form an lvalue with
1501 // it.
Chris Lattner2140e902009-02-16 22:14:05 +00001502 llvm::Value *Ptr = EmitScalarExpr(E->getBase());
Chris Lattner998eab12009-12-23 21:31:11 +00001503 const PointerType *PT = E->getBase()->getType()->getAs<PointerType>();
Daniel Dunbar6d5eb762010-08-21 03:44:13 +00001504 Base = MakeAddrLValue(Ptr, PT->getPointeeType());
1505 Base.getQuals().removeObjCGCAttr();
Chris Lattner998eab12009-12-23 21:31:11 +00001506 } else if (E->getBase()->isLvalue(getContext()) == Expr::LV_Valid) {
1507 // Otherwise, if the base is an lvalue ( as in the case of foo.x.x),
1508 // emit the base as an lvalue.
1509 assert(E->getBase()->getType()->isVectorType());
1510 Base = EmitLValue(E->getBase());
1511 } else {
1512 // Otherwise, the base is a normal rvalue (as in (V+V).x), emit it as such.
Daniel Dunbar302c3c22010-01-04 18:02:28 +00001513 assert(E->getBase()->getType()->getAs<VectorType>() &&
1514 "Result must be a vector");
Chris Lattner998eab12009-12-23 21:31:11 +00001515 llvm::Value *Vec = EmitScalarExpr(E->getBase());
1516
Chris Lattner0ad57fb2009-12-23 21:33:41 +00001517 // Store the vector to memory (because LValue wants an address).
Daniel Dunbar195337d2010-02-09 02:48:28 +00001518 llvm::Value *VecMem = CreateMemTemp(E->getBase()->getType());
Chris Lattner998eab12009-12-23 21:31:11 +00001519 Builder.CreateStore(Vec, VecMem);
Daniel Dunbar6d5eb762010-08-21 03:44:13 +00001520 Base = MakeAddrLValue(VecMem, E->getBase()->getType());
Chris Lattner998eab12009-12-23 21:31:11 +00001521 }
1522
Nate Begeman3b8d1162008-05-13 21:03:02 +00001523 // Encode the element access list into a vector of unsigned indices.
1524 llvm::SmallVector<unsigned, 4> Indices;
1525 E->getEncodedElementAccess(Indices);
1526
1527 if (Base.isSimple()) {
Owen Andersona1cf15f2009-07-14 23:10:40 +00001528 llvm::Constant *CV = GenerateConstantVector(VMContext, Indices);
Eli Friedman1e692ac2008-06-13 23:01:12 +00001529 return LValue::MakeExtVectorElt(Base.getAddress(), CV,
John McCall0953e762009-09-24 19:53:00 +00001530 Base.getVRQualifiers());
Nate Begeman3b8d1162008-05-13 21:03:02 +00001531 }
1532 assert(Base.isExtVectorElt() && "Can only subscript lvalue vec elts here!");
1533
1534 llvm::Constant *BaseElts = Base.getExtVectorElts();
1535 llvm::SmallVector<llvm::Constant *, 4> CElts;
1536
1537 for (unsigned i = 0, e = Indices.size(); i != e; ++i) {
1538 if (isa<llvm::ConstantAggregateZero>(BaseElts))
Chris Lattner67665862009-10-28 05:12:07 +00001539 CElts.push_back(llvm::ConstantInt::get(Int32Ty, 0));
Nate Begeman3b8d1162008-05-13 21:03:02 +00001540 else
Chris Lattner67665862009-10-28 05:12:07 +00001541 CElts.push_back(cast<llvm::Constant>(BaseElts->getOperand(Indices[i])));
Nate Begeman3b8d1162008-05-13 21:03:02 +00001542 }
Owen Anderson4a289322009-07-28 21:22:35 +00001543 llvm::Constant *CV = llvm::ConstantVector::get(&CElts[0], CElts.size());
Eli Friedman1e692ac2008-06-13 23:01:12 +00001544 return LValue::MakeExtVectorElt(Base.getExtVectorAddr(), CV,
John McCall0953e762009-09-24 19:53:00 +00001545 Base.getVRQualifiers());
Chris Lattner349aaec2007-08-02 23:37:31 +00001546}
1547
Devang Patelb9b00ad2007-10-23 20:28:39 +00001548LValue CodeGenFunction::EmitMemberExpr(const MemberExpr *E) {
Fariborz Jahanian4f676ed2009-02-21 00:30:43 +00001549 bool isNonGC = false;
Devang Patel126a8562007-10-24 22:26:28 +00001550 Expr *BaseExpr = E->getBase();
Devang Patel126a8562007-10-24 22:26:28 +00001551 llvm::Value *BaseValue = NULL;
John McCall0953e762009-09-24 19:53:00 +00001552 Qualifiers BaseQuals;
Eli Friedman1e692ac2008-06-13 23:01:12 +00001553
Chris Lattner12f65f62007-12-02 18:52:07 +00001554 // If this is s.x, emit s as an lvalue. If it is s->x, emit s as a scalar.
Devang Patelfe2419a2007-12-11 21:33:16 +00001555 if (E->isArrow()) {
Devang Patel0a961182007-10-26 18:15:21 +00001556 BaseValue = EmitScalarExpr(BaseExpr);
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001557 const PointerType *PTy =
Ted Kremenek6217b802009-07-29 21:53:49 +00001558 BaseExpr->getType()->getAs<PointerType>();
John McCall0953e762009-09-24 19:53:00 +00001559 BaseQuals = PTy->getPointeeType().getQualifiers();
Fariborz Jahaniand2e1eb02009-09-01 17:02:21 +00001560 } else if (isa<ObjCPropertyRefExpr>(BaseExpr->IgnoreParens()) ||
1561 isa<ObjCImplicitSetterGetterRefExpr>(
1562 BaseExpr->IgnoreParens())) {
Fariborz Jahanian35c33292009-01-12 23:27:26 +00001563 RValue RV = EmitObjCPropertyGet(BaseExpr);
1564 BaseValue = RV.getAggregateAddr();
John McCall0953e762009-09-24 19:53:00 +00001565 BaseQuals = BaseExpr->getType().getQualifiers();
Chris Lattner1bd885e2009-02-16 22:25:49 +00001566 } else {
Chris Lattner12f65f62007-12-02 18:52:07 +00001567 LValue BaseLV = EmitLValue(BaseExpr);
Fariborz Jahanian4f676ed2009-02-21 00:30:43 +00001568 if (BaseLV.isNonGC())
1569 isNonGC = true;
Chris Lattner12f65f62007-12-02 18:52:07 +00001570 // FIXME: this isn't right for bitfields.
1571 BaseValue = BaseLV.getAddress();
Fariborz Jahaniana91d6a62009-07-29 00:44:13 +00001572 QualType BaseTy = BaseExpr->getType();
John McCall0953e762009-09-24 19:53:00 +00001573 BaseQuals = BaseTy.getQualifiers();
Chris Lattner12f65f62007-12-02 18:52:07 +00001574 }
Devang Patelb9b00ad2007-10-23 20:28:39 +00001575
Anders Carlssonce53f7d2009-11-07 23:06:58 +00001576 NamedDecl *ND = E->getMemberDecl();
1577 if (FieldDecl *Field = dyn_cast<FieldDecl>(ND)) {
Anders Carlssone6d2a532010-01-29 05:05:36 +00001578 LValue LV = EmitLValueForField(BaseValue, Field,
Anders Carlssonce53f7d2009-11-07 23:06:58 +00001579 BaseQuals.getCVRQualifiers());
Daniel Dunbarea619172010-08-21 03:22:38 +00001580 LV.setNonGC(isNonGC);
Anders Carlssonce53f7d2009-11-07 23:06:58 +00001581 setObjCGCLValueClass(getContext(), E, LV);
1582 return LV;
1583 }
1584
Anders Carlsson589f9e32009-11-07 23:16:50 +00001585 if (VarDecl *VD = dyn_cast<VarDecl>(ND))
1586 return EmitGlobalVarDeclLValue(*this, E, VD);
Eli Friedman9a146302009-11-26 06:08:14 +00001587
1588 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND))
1589 return EmitFunctionDeclLValue(*this, E, FD);
1590
Anders Carlssonce53f7d2009-11-07 23:06:58 +00001591 assert(false && "Unhandled member declaration!");
1592 return LValue();
Eli Friedman472778e2008-02-09 08:50:58 +00001593}
Devang Patelb9b00ad2007-10-23 20:28:39 +00001594
Fariborz Jahanianfd64bb62008-12-15 20:35:07 +00001595LValue CodeGenFunction::EmitLValueForBitfield(llvm::Value* BaseValue,
Anders Carlsson0ed303c2009-11-17 03:57:07 +00001596 const FieldDecl* Field,
Fariborz Jahanian598d3f62009-02-03 19:03:09 +00001597 unsigned CVRQualifiers) {
Daniel Dunbar198bcb42010-03-31 01:09:11 +00001598 const CGRecordLayout &RL =
1599 CGM.getTypes().getCGRecordLayout(Field->getParent());
Daniel Dunbar2eec0b22010-04-05 16:20:44 +00001600 const CGBitFieldInfo &Info = RL.getBitFieldInfo(Field);
Daniel Dunbar7f289642010-04-08 02:59:45 +00001601 return LValue::MakeBitfield(BaseValue, Info,
Daniel Dunbarf0fe5bc2010-04-05 21:36:35 +00001602 Field->getType().getCVRQualifiers()|CVRQualifiers);
Fariborz Jahanianfd64bb62008-12-15 20:35:07 +00001603}
1604
John McCalla9976d32010-05-21 01:18:57 +00001605/// EmitLValueForAnonRecordField - Given that the field is a member of
1606/// an anonymous struct or union buried inside a record, and given
1607/// that the base value is a pointer to the enclosing record, derive
1608/// an lvalue for the ultimate field.
1609LValue CodeGenFunction::EmitLValueForAnonRecordField(llvm::Value *BaseValue,
1610 const FieldDecl *Field,
1611 unsigned CVRQualifiers) {
1612 llvm::SmallVector<const FieldDecl *, 8> Path;
1613 Path.push_back(Field);
1614
1615 while (Field->getParent()->isAnonymousStructOrUnion()) {
1616 const ValueDecl *VD = Field->getParent()->getAnonymousStructOrUnionObject();
1617 if (!isa<FieldDecl>(VD)) break;
1618 Field = cast<FieldDecl>(VD);
1619 Path.push_back(Field);
1620 }
1621
1622 llvm::SmallVectorImpl<const FieldDecl*>::reverse_iterator
1623 I = Path.rbegin(), E = Path.rend();
1624 while (true) {
1625 LValue LV = EmitLValueForField(BaseValue, *I, CVRQualifiers);
1626 if (++I == E) return LV;
1627
1628 assert(LV.isSimple());
1629 BaseValue = LV.getAddress();
1630 CVRQualifiers |= LV.getVRQualifiers();
1631 }
1632}
1633
Eli Friedman472778e2008-02-09 08:50:58 +00001634LValue CodeGenFunction::EmitLValueForField(llvm::Value* BaseValue,
Anders Carlsson0ed303c2009-11-17 03:57:07 +00001635 const FieldDecl* Field,
Mike Stump1eb44332009-09-09 15:08:12 +00001636 unsigned CVRQualifiers) {
Fariborz Jahanianfd64bb62008-12-15 20:35:07 +00001637 if (Field->isBitField())
Fariborz Jahanian598d3f62009-02-03 19:03:09 +00001638 return EmitLValueForBitfield(BaseValue, Field, CVRQualifiers);
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001639
Daniel Dunbar198bcb42010-03-31 01:09:11 +00001640 const CGRecordLayout &RL =
1641 CGM.getTypes().getCGRecordLayout(Field->getParent());
1642 unsigned idx = RL.getLLVMFieldNo(Field);
Fariborz Jahanianfd64bb62008-12-15 20:35:07 +00001643 llvm::Value *V = Builder.CreateStructGEP(BaseValue, idx, "tmp");
Eli Friedman1e86b342008-05-29 11:33:25 +00001644
Devang Patelabad06c2007-10-26 19:42:18 +00001645 // Match union field type.
Anders Carlssone6d2a532010-01-29 05:05:36 +00001646 if (Field->getParent()->isUnion()) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001647 const llvm::Type *FieldTy =
Eli Friedman1e692ac2008-06-13 23:01:12 +00001648 CGM.getTypes().ConvertTypeForMem(Field->getType());
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001649 const llvm::PointerType * BaseTy =
Devang Patele9b8c0a2007-10-30 20:59:40 +00001650 cast<llvm::PointerType>(BaseValue->getType());
Eli Friedman788d5712008-05-21 13:24:44 +00001651 unsigned AS = BaseTy->getAddressSpace();
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001652 V = Builder.CreateBitCast(V,
1653 llvm::PointerType::get(FieldTy, AS),
Eli Friedman788d5712008-05-21 13:24:44 +00001654 "tmp");
Devang Patelabad06c2007-10-26 19:42:18 +00001655 }
Eli Friedman2be58612009-05-30 21:09:44 +00001656 if (Field->getType()->isReferenceType())
1657 V = Builder.CreateLoad(V, "tmp");
John McCall0953e762009-09-24 19:53:00 +00001658
Daniel Dunbar983e3d72010-08-21 04:20:22 +00001659 unsigned Alignment = getContext().getDeclAlign(Field).getQuantity();
1660 LValue LV = MakeAddrLValue(V, Field->getType(), Alignment);
Daniel Dunbar6d5eb762010-08-21 03:44:13 +00001661 LV.getQuals().addCVRQualifiers(CVRQualifiers);
1662
Fariborz Jahanianfd02ed72009-09-21 18:54:29 +00001663 // __weak attribute on a field is ignored.
Daniel Dunbar6d5eb762010-08-21 03:44:13 +00001664 if (LV.getQuals().getObjCGCAttr() == Qualifiers::Weak)
1665 LV.getQuals().removeObjCGCAttr();
Fariborz Jahanianfd02ed72009-09-21 18:54:29 +00001666
Daniel Dunbar6d5eb762010-08-21 03:44:13 +00001667 return LV;
Devang Patelb9b00ad2007-10-23 20:28:39 +00001668}
1669
Anders Carlsson06a29702010-01-29 05:24:29 +00001670LValue
1671CodeGenFunction::EmitLValueForFieldInitialization(llvm::Value* BaseValue,
1672 const FieldDecl* Field,
1673 unsigned CVRQualifiers) {
1674 QualType FieldType = Field->getType();
1675
1676 if (!FieldType->isReferenceType())
1677 return EmitLValueForField(BaseValue, Field, CVRQualifiers);
1678
Daniel Dunbar198bcb42010-03-31 01:09:11 +00001679 const CGRecordLayout &RL =
1680 CGM.getTypes().getCGRecordLayout(Field->getParent());
1681 unsigned idx = RL.getLLVMFieldNo(Field);
Anders Carlsson06a29702010-01-29 05:24:29 +00001682 llvm::Value *V = Builder.CreateStructGEP(BaseValue, idx, "tmp");
1683
1684 assert(!FieldType.getObjCGCAttr() && "fields cannot have GC attrs");
1685
Daniel Dunbar983e3d72010-08-21 04:20:22 +00001686 unsigned Alignment = getContext().getDeclAlign(Field).getQuantity();
1687 return MakeAddrLValue(V, FieldType, Alignment);
Anders Carlsson06a29702010-01-29 05:24:29 +00001688}
1689
Chris Lattner75dfeda2009-03-18 18:28:57 +00001690LValue CodeGenFunction::EmitCompoundLiteralLValue(const CompoundLiteralExpr* E){
Daniel Dunbar15006572010-02-16 19:43:39 +00001691 llvm::Value *DeclPtr = CreateMemTemp(E->getType(), ".compoundliteral");
Eli Friedman06e863f2008-05-13 23:18:27 +00001692 const Expr* InitExpr = E->getInitializer();
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001693 LValue Result = MakeAddrLValue(DeclPtr, E->getType());
Eli Friedman06e863f2008-05-13 23:18:27 +00001694
John McCall3d3ec1c2010-04-21 10:05:39 +00001695 EmitAnyExprToMem(InitExpr, DeclPtr, /*Volatile*/ false);
Eli Friedman06e863f2008-05-13 23:18:27 +00001696
1697 return Result;
1698}
1699
Anders Carlsson6fcec8b2009-09-15 16:35:24 +00001700LValue
1701CodeGenFunction::EmitConditionalOperatorLValue(const ConditionalOperator* E) {
1702 if (E->isLvalue(getContext()) == Expr::LV_Valid) {
Eli Friedmanab189952009-12-25 05:29:40 +00001703 if (int Cond = ConstantFoldsToSimpleInteger(E->getCond())) {
1704 Expr *Live = Cond == 1 ? E->getLHS() : E->getRHS();
1705 if (Live)
1706 return EmitLValue(Live);
1707 }
1708
1709 if (!E->getLHS())
1710 return EmitUnsupportedLValue(E, "conditional operator with missing LHS");
1711
Anders Carlsson6fcec8b2009-09-15 16:35:24 +00001712 llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true");
1713 llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false");
1714 llvm::BasicBlock *ContBlock = createBasicBlock("cond.end");
1715
Eli Friedman8e274bd2009-12-25 06:17:05 +00001716 EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock);
Anders Carlsson6fcec8b2009-09-15 16:35:24 +00001717
Anders Carlssonc1b32f62010-02-04 17:26:01 +00001718 // Any temporaries created here are conditional.
1719 BeginConditionalBranch();
Anders Carlsson6fcec8b2009-09-15 16:35:24 +00001720 EmitBlock(LHSBlock);
Anders Carlsson6fcec8b2009-09-15 16:35:24 +00001721 LValue LHS = EmitLValue(E->getLHS());
Anders Carlssonc1b32f62010-02-04 17:26:01 +00001722 EndConditionalBranch();
1723
Anders Carlsson6fcec8b2009-09-15 16:35:24 +00001724 if (!LHS.isSimple())
1725 return EmitUnsupportedLValue(E, "conditional operator");
1726
Daniel Dunbar195337d2010-02-09 02:48:28 +00001727 // FIXME: We shouldn't need an alloca for this.
Chris Lattnereb99b012009-10-28 17:39:19 +00001728 llvm::Value *Temp = CreateTempAlloca(LHS.getAddress()->getType(),"condtmp");
Anders Carlsson6fcec8b2009-09-15 16:35:24 +00001729 Builder.CreateStore(LHS.getAddress(), Temp);
1730 EmitBranch(ContBlock);
1731
Anders Carlssonc1b32f62010-02-04 17:26:01 +00001732 // Any temporaries created here are conditional.
1733 BeginConditionalBranch();
Anders Carlsson6fcec8b2009-09-15 16:35:24 +00001734 EmitBlock(RHSBlock);
1735 LValue RHS = EmitLValue(E->getRHS());
Anders Carlssonc1b32f62010-02-04 17:26:01 +00001736 EndConditionalBranch();
Anders Carlsson6fcec8b2009-09-15 16:35:24 +00001737 if (!RHS.isSimple())
1738 return EmitUnsupportedLValue(E, "conditional operator");
1739
1740 Builder.CreateStore(RHS.getAddress(), Temp);
1741 EmitBranch(ContBlock);
1742
1743 EmitBlock(ContBlock);
1744
1745 Temp = Builder.CreateLoad(Temp, "lv");
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001746 return MakeAddrLValue(Temp, E->getType());
Anders Carlsson6fcec8b2009-09-15 16:35:24 +00001747 }
1748
Daniel Dunbar90345582009-03-24 02:38:23 +00001749 // ?: here should be an aggregate.
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001750 assert((hasAggregateLLVMType(E->getType()) &&
Daniel Dunbar90345582009-03-24 02:38:23 +00001751 !E->getType()->isAnyComplexType()) &&
1752 "Unexpected conditional operator!");
1753
Daniel Dunbar18aba0d2010-02-05 19:38:31 +00001754 return EmitAggExprToLValue(E);
Daniel Dunbar90345582009-03-24 02:38:23 +00001755}
1756
Mike Stumpc849c052009-11-16 06:50:58 +00001757/// EmitCastLValue - Casts are never lvalues unless that cast is a dynamic_cast.
1758/// If the cast is a dynamic_cast, we can have the usual lvalue result,
1759/// otherwise if a cast is needed by the code generator in an lvalue context,
1760/// then it must mean that we need the address of an aggregate in order to
1761/// access one of its fields. This can happen for all the reasons that casts
1762/// are permitted with aggregate result, including noop aggregate casts, and
1763/// cast from scalar to union.
Chris Lattner75dfeda2009-03-18 18:28:57 +00001764LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) {
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00001765 switch (E->getCastKind()) {
John McCall2de56d12010-08-25 11:45:40 +00001766 case CK_ToVoid:
Eli Friedmaneaae78a2009-11-16 05:48:01 +00001767 return EmitUnsupportedLValue(E, "unexpected cast lvalue");
Douglas Gregor7c7a7932010-07-15 18:58:16 +00001768
John McCall2de56d12010-08-25 11:45:40 +00001769 case CK_NoOp:
Douglas Gregor7c7a7932010-07-15 18:58:16 +00001770 if (E->getSubExpr()->Classify(getContext()).getKind()
1771 != Expr::Classification::CL_PRValue) {
1772 LValue LV = EmitLValue(E->getSubExpr());
Fariborz Jahanian98c9d1f2010-09-01 19:36:41 +00001773 if (LV.isPropertyRef() || LV.isKVCRef()) {
Douglas Gregor7c7a7932010-07-15 18:58:16 +00001774 QualType QT = E->getSubExpr()->getType();
Fariborz Jahanian98c9d1f2010-09-01 19:36:41 +00001775 RValue RV =
1776 LV.isPropertyRef() ? EmitLoadOfPropertyRefLValue(LV, QT)
1777 : EmitLoadOfKVCRefLValue(LV, QT);
Douglas Gregor7c7a7932010-07-15 18:58:16 +00001778 assert(!RV.isScalar() && "EmitCastLValue-scalar cast of property ref");
1779 llvm::Value *V = RV.getAggregateAddr();
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001780 return MakeAddrLValue(V, QT);
Douglas Gregor7c7a7932010-07-15 18:58:16 +00001781 }
1782 return LV;
1783 }
1784 // Fall through to synthesize a temporary.
1785
John McCall2de56d12010-08-25 11:45:40 +00001786 case CK_Unknown:
1787 case CK_BitCast:
1788 case CK_ArrayToPointerDecay:
1789 case CK_FunctionToPointerDecay:
1790 case CK_NullToMemberPointer:
1791 case CK_IntegralToPointer:
1792 case CK_PointerToIntegral:
1793 case CK_VectorSplat:
1794 case CK_IntegralCast:
1795 case CK_IntegralToFloating:
1796 case CK_FloatingToIntegral:
1797 case CK_FloatingCast:
1798 case CK_DerivedToBaseMemberPointer:
1799 case CK_BaseToDerivedMemberPointer:
1800 case CK_MemberPointerToBoolean:
1801 case CK_AnyPointerToBlockPointerCast: {
Douglas Gregor7c7a7932010-07-15 18:58:16 +00001802 // These casts only produce lvalues when we're binding a reference to a
1803 // temporary realized from a (converted) pure rvalue. Emit the expression
1804 // as a value, copy it into a temporary, and return an lvalue referring to
1805 // that temporary.
1806 llvm::Value *V = CreateMemTemp(E->getType(), "ref.temp");
1807 EmitAnyExprToMem(E, V, false, false);
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001808 return MakeAddrLValue(V, E->getType());
Douglas Gregor7c7a7932010-07-15 18:58:16 +00001809 }
Eli Friedmaneaae78a2009-11-16 05:48:01 +00001810
John McCall2de56d12010-08-25 11:45:40 +00001811 case CK_Dynamic: {
Mike Stumpc849c052009-11-16 06:50:58 +00001812 LValue LV = EmitLValue(E->getSubExpr());
1813 llvm::Value *V = LV.getAddress();
1814 const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(E);
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001815 return MakeAddrLValue(EmitDynamicCast(V, DCE), E->getType());
Mike Stumpc849c052009-11-16 06:50:58 +00001816 }
1817
John McCall2de56d12010-08-25 11:45:40 +00001818 case CK_ConstructorConversion:
1819 case CK_UserDefinedConversion:
1820 case CK_AnyPointerToObjCPointerCast:
Chris Lattner75dfeda2009-03-18 18:28:57 +00001821 return EmitLValue(E->getSubExpr());
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00001822
John McCall2de56d12010-08-25 11:45:40 +00001823 case CK_UncheckedDerivedToBase:
1824 case CK_DerivedToBase: {
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00001825 const RecordType *DerivedClassTy =
1826 E->getSubExpr()->getType()->getAs<RecordType>();
1827 CXXRecordDecl *DerivedClassDecl =
1828 cast<CXXRecordDecl>(DerivedClassTy->getDecl());
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00001829
1830 LValue LV = EmitLValue(E->getSubExpr());
Fariborz Jahanian353b33b2010-06-17 23:00:29 +00001831 llvm::Value *This;
Fariborz Jahanian98c9d1f2010-09-01 19:36:41 +00001832 if (LV.isPropertyRef() || LV.isKVCRef()) {
1833 QualType QT = E->getSubExpr()->getType();
1834 RValue RV =
1835 LV.isPropertyRef() ? EmitLoadOfPropertyRefLValue(LV, QT)
1836 : EmitLoadOfKVCRefLValue(LV, QT);
Fariborz Jahanian353b33b2010-06-17 23:00:29 +00001837 assert (!RV.isScalar() && "EmitCastLValue");
1838 This = RV.getAggregateAddr();
1839 }
1840 else
1841 This = LV.getAddress();
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00001842
1843 // Perform the derived-to-base conversion
1844 llvm::Value *Base =
Fariborz Jahanian353b33b2010-06-17 23:00:29 +00001845 GetAddressOfBaseClass(This, DerivedClassDecl,
John McCallf871d0c2010-08-07 06:22:56 +00001846 E->path_begin(), E->path_end(),
1847 /*NullCheckValue=*/false);
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00001848
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001849 return MakeAddrLValue(Base, E->getType());
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00001850 }
John McCall2de56d12010-08-25 11:45:40 +00001851 case CK_ToUnion:
Daniel Dunbarb2cd7772010-02-05 20:02:42 +00001852 return EmitAggExprToLValue(E);
John McCall2de56d12010-08-25 11:45:40 +00001853 case CK_BaseToDerived: {
Anders Carlssona3697c92009-11-23 17:57:54 +00001854 const RecordType *DerivedClassTy = E->getType()->getAs<RecordType>();
1855 CXXRecordDecl *DerivedClassDecl =
1856 cast<CXXRecordDecl>(DerivedClassTy->getDecl());
1857
1858 LValue LV = EmitLValue(E->getSubExpr());
1859
1860 // Perform the base-to-derived conversion
1861 llvm::Value *Derived =
Anders Carlssona04efdf2010-04-24 21:23:59 +00001862 GetAddressOfDerivedClass(LV.getAddress(), DerivedClassDecl,
John McCallf871d0c2010-08-07 06:22:56 +00001863 E->path_begin(), E->path_end(),
1864 /*NullCheckValue=*/false);
Anders Carlssona3697c92009-11-23 17:57:54 +00001865
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001866 return MakeAddrLValue(Derived, E->getType());
Eli Friedmaneaae78a2009-11-16 05:48:01 +00001867 }
John McCall2de56d12010-08-25 11:45:40 +00001868 case CK_LValueBitCast: {
Eli Friedmaneaae78a2009-11-16 05:48:01 +00001869 // This must be a reinterpret_cast (or c-style equivalent).
1870 const ExplicitCastExpr *CE = cast<ExplicitCastExpr>(E);
Anders Carlsson658e8122009-11-14 21:21:42 +00001871
1872 LValue LV = EmitLValue(E->getSubExpr());
1873 llvm::Value *V = Builder.CreateBitCast(LV.getAddress(),
1874 ConvertType(CE->getTypeAsWritten()));
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001875 return MakeAddrLValue(V, E->getType());
Anders Carlsson658e8122009-11-14 21:21:42 +00001876 }
John McCall2de56d12010-08-25 11:45:40 +00001877 case CK_ObjCObjectLValueCast: {
Douglas Gregor569c3162010-08-07 11:51:51 +00001878 LValue LV = EmitLValue(E->getSubExpr());
1879 QualType ToType = getContext().getLValueReferenceType(E->getType());
1880 llvm::Value *V = Builder.CreateBitCast(LV.getAddress(),
1881 ConvertType(ToType));
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001882 return MakeAddrLValue(V, E->getType());
Douglas Gregor569c3162010-08-07 11:51:51 +00001883 }
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00001884 }
Douglas Gregor7c7a7932010-07-15 18:58:16 +00001885
1886 llvm_unreachable("Unhandled lvalue cast kind?");
Chris Lattner75dfeda2009-03-18 18:28:57 +00001887}
1888
Fariborz Jahanian48620ba2009-10-20 23:29:04 +00001889LValue CodeGenFunction::EmitNullInitializationLValue(
Douglas Gregored8abf12010-07-08 06:14:04 +00001890 const CXXScalarValueInitExpr *E) {
Fariborz Jahanian48620ba2009-10-20 23:29:04 +00001891 QualType Ty = E->getType();
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001892 LValue LV = MakeAddrLValue(CreateMemTemp(Ty), Ty);
Anders Carlsson1884eb02010-05-22 17:35:42 +00001893 EmitNullInitialization(LV.getAddress(), Ty);
Daniel Dunbar195337d2010-02-09 02:48:28 +00001894 return LV;
Fariborz Jahanian48620ba2009-10-20 23:29:04 +00001895}
1896
Reid Spencer5f016e22007-07-11 17:01:13 +00001897//===--------------------------------------------------------------------===//
1898// Expression Emission
1899//===--------------------------------------------------------------------===//
1900
Chris Lattner7016a702007-08-20 22:37:10 +00001901
Anders Carlssond2490a92009-12-24 20:40:36 +00001902RValue CodeGenFunction::EmitCallExpr(const CallExpr *E,
1903 ReturnValueSlot ReturnValue) {
Daniel Dunbarc0ef9f52009-02-20 18:06:48 +00001904 // Builtins never have block type.
Daniel Dunbarce1d38b2009-01-09 16:50:52 +00001905 if (E->getCallee()->getType()->isBlockPointerType())
Anders Carlssona1736c02009-12-24 21:13:40 +00001906 return EmitBlockCallExpr(E, ReturnValue);
Daniel Dunbarce1d38b2009-01-09 16:50:52 +00001907
Anders Carlsson774e7c62009-04-03 22:50:24 +00001908 if (const CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(E))
Anders Carlssona1736c02009-12-24 21:13:40 +00001909 return EmitCXXMemberCallExpr(CE, ReturnValue);
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001910
Daniel Dunbarc0ef9f52009-02-20 18:06:48 +00001911 const Decl *TargetDecl = 0;
Daniel Dunbardd7b8972009-02-20 19:34:33 +00001912 if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E->getCallee())) {
1913 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CE->getSubExpr())) {
1914 TargetDecl = DRE->getDecl();
1915 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(TargetDecl))
Douglas Gregor7814e6d2009-09-12 00:22:50 +00001916 if (unsigned builtinID = FD->getBuiltinID())
Daniel Dunbardd7b8972009-02-20 19:34:33 +00001917 return EmitBuiltinExpr(FD, builtinID, E);
Daniel Dunbarc0ef9f52009-02-20 18:06:48 +00001918 }
1919 }
1920
Chris Lattner5db7ae52009-06-13 00:26:38 +00001921 if (const CXXOperatorCallExpr *CE = dyn_cast<CXXOperatorCallExpr>(E))
Anders Carlsson0f294632009-05-27 04:18:27 +00001922 if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(TargetDecl))
Anders Carlssona1736c02009-12-24 21:13:40 +00001923 return EmitCXXOperatorMemberCallExpr(CE, MD, ReturnValue);
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001924
Eli Friedmanc4451db2009-12-08 02:09:46 +00001925 if (isa<CXXPseudoDestructorExpr>(E->getCallee()->IgnoreParens())) {
Douglas Gregora71d8192009-09-04 17:36:40 +00001926 // C++ [expr.pseudo]p1:
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001927 // The result shall only be used as the operand for the function call
Douglas Gregora71d8192009-09-04 17:36:40 +00001928 // operator (), and the result of such a call has type void. The only
1929 // effect is the evaluation of the postfix-expression before the dot or
1930 // arrow.
1931 EmitScalarExpr(E->getCallee());
1932 return RValue::get(0);
1933 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001934
Chris Lattner7f02f722007-08-24 05:35:26 +00001935 llvm::Value *Callee = EmitScalarExpr(E->getCallee());
Anders Carlssond2490a92009-12-24 20:40:36 +00001936 return EmitCall(E->getCallee()->getType(), Callee, ReturnValue,
Anders Carlsson98647712009-05-27 01:22:39 +00001937 E->arg_begin(), E->arg_end(), TargetDecl);
Chris Lattnerc5e940f2007-08-31 04:44:06 +00001938}
1939
Daniel Dunbar80e62c22008-09-04 03:20:13 +00001940LValue CodeGenFunction::EmitBinaryOperatorLValue(const BinaryOperator *E) {
Chris Lattner7a574cc2009-05-12 21:28:12 +00001941 // Comma expressions just emit their LHS then their RHS as an l-value.
John McCall2de56d12010-08-25 11:45:40 +00001942 if (E->getOpcode() == BO_Comma) {
Chris Lattner7a574cc2009-05-12 21:28:12 +00001943 EmitAnyExpr(E->getLHS());
Eli Friedman130c69e2009-12-07 20:18:11 +00001944 EnsureInsertPoint();
Chris Lattner7a574cc2009-05-12 21:28:12 +00001945 return EmitLValue(E->getRHS());
1946 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001947
John McCall2de56d12010-08-25 11:45:40 +00001948 if (E->getOpcode() == BO_PtrMemD ||
1949 E->getOpcode() == BO_PtrMemI)
Fariborz Jahanian8bfd31f2009-10-22 22:57:31 +00001950 return EmitPointerToDataMemberBinaryExpr(E);
1951
Daniel Dunbar80e62c22008-09-04 03:20:13 +00001952 // Can only get l-value for binary operator expressions which are a
1953 // simple assignment of aggregate type.
John McCall2de56d12010-08-25 11:45:40 +00001954 if (E->getOpcode() != BO_Assign)
Daniel Dunbar80e62c22008-09-04 03:20:13 +00001955 return EmitUnsupportedLValue(E, "binary l-value expression");
1956
Anders Carlsson86aa0cd2009-10-19 18:28:22 +00001957 if (!hasAggregateLLVMType(E->getType())) {
1958 // Emit the LHS as an l-value.
1959 LValue LV = EmitLValue(E->getLHS());
Chris Lattner5990b542010-08-18 00:13:52 +00001960 // Store the value through the l-value.
Chris Lattnerd7241c72010-08-18 00:08:27 +00001961 EmitStoreThroughLValue(EmitAnyExpr(E->getRHS()), LV, E->getType());
Anders Carlsson86aa0cd2009-10-19 18:28:22 +00001962 return LV;
1963 }
1964
Daniel Dunbar18aba0d2010-02-05 19:38:31 +00001965 return EmitAggExprToLValue(E);
Daniel Dunbar80e62c22008-09-04 03:20:13 +00001966}
1967
Christopher Lamb22c940e2007-12-29 05:02:41 +00001968LValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) {
Christopher Lamb22c940e2007-12-29 05:02:41 +00001969 RValue RV = EmitCallExpr(E);
Anders Carlsson48265682009-05-27 01:45:47 +00001970
Chris Lattnereb99b012009-10-28 17:39:19 +00001971 if (!RV.isScalar())
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001972 return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
Chris Lattnereb99b012009-10-28 17:39:19 +00001973
1974 assert(E->getCallReturnType()->isReferenceType() &&
1975 "Can't have a scalar return unless the return type is a "
1976 "reference type!");
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001977
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001978 return MakeAddrLValue(RV.getScalarVal(), E->getType());
Christopher Lamb22c940e2007-12-29 05:02:41 +00001979}
1980
Daniel Dunbar5b5c9ef2009-02-11 20:59:32 +00001981LValue CodeGenFunction::EmitVAArgExprLValue(const VAArgExpr *E) {
1982 // FIXME: This shouldn't require another copy.
Daniel Dunbar18aba0d2010-02-05 19:38:31 +00001983 return EmitAggExprToLValue(E);
Daniel Dunbar5b5c9ef2009-02-11 20:59:32 +00001984}
1985
Anders Carlssonb58d0172009-05-30 23:23:33 +00001986LValue CodeGenFunction::EmitCXXConstructLValue(const CXXConstructExpr *E) {
Daniel Dunbar195337d2010-02-09 02:48:28 +00001987 llvm::Value *Temp = CreateMemTemp(E->getType(), "tmp");
Anders Carlssonb58d0172009-05-30 23:23:33 +00001988 EmitCXXConstructExpr(Temp, E);
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001989 return MakeAddrLValue(Temp, E->getType());
Anders Carlssonb58d0172009-05-30 23:23:33 +00001990}
1991
Anders Carlssone61c9e82009-05-30 23:30:54 +00001992LValue
Mike Stumpc2e84ae2009-11-15 08:09:41 +00001993CodeGenFunction::EmitCXXTypeidLValue(const CXXTypeidExpr *E) {
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001994 return MakeAddrLValue(EmitCXXTypeidExpr(E), E->getType());
Mike Stumpc2e84ae2009-11-15 08:09:41 +00001995}
1996
1997LValue
Anders Carlssone61c9e82009-05-30 23:30:54 +00001998CodeGenFunction::EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E) {
1999 LValue LV = EmitLValue(E->getSubExpr());
John McCallf1549f62010-07-06 01:34:17 +00002000 EmitCXXTemporary(E->getTemporary(), LV.getAddress());
Anders Carlssone61c9e82009-05-30 23:30:54 +00002001 return LV;
2002}
2003
Daniel Dunbar0a04d772008-08-23 10:51:21 +00002004LValue CodeGenFunction::EmitObjCMessageExprLValue(const ObjCMessageExpr *E) {
Daniel Dunbar0a04d772008-08-23 10:51:21 +00002005 RValue RV = EmitObjCMessageExpr(E);
Anders Carlsson7e70fb22010-06-21 20:59:55 +00002006
2007 if (!RV.isScalar())
Daniel Dunbar9f553f52010-08-21 03:08:16 +00002008 return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
Anders Carlsson7e70fb22010-06-21 20:59:55 +00002009
2010 assert(E->getMethodDecl()->getResultType()->isReferenceType() &&
2011 "Can't have a scalar return unless the return type is a "
2012 "reference type!");
2013
Daniel Dunbar9f553f52010-08-21 03:08:16 +00002014 return MakeAddrLValue(RV.getScalarVal(), E->getType());
Daniel Dunbar0a04d772008-08-23 10:51:21 +00002015}
2016
Fariborz Jahanian03b29602010-06-17 19:56:20 +00002017LValue CodeGenFunction::EmitObjCSelectorLValue(const ObjCSelectorExpr *E) {
2018 llvm::Value *V =
2019 CGM.getObjCRuntime().GetSelector(Builder, E->getSelector(), true);
Daniel Dunbar9f553f52010-08-21 03:08:16 +00002020 return MakeAddrLValue(V, E->getType());
Fariborz Jahanian03b29602010-06-17 19:56:20 +00002021}
2022
Daniel Dunbar2a031922009-04-22 05:08:15 +00002023llvm::Value *CodeGenFunction::EmitIvarOffset(const ObjCInterfaceDecl *Interface,
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00002024 const ObjCIvarDecl *Ivar) {
Fariborz Jahanianf63aa3f2009-02-10 19:02:04 +00002025 return CGM.getObjCRuntime().EmitIvarOffset(*this, Interface, Ivar);
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00002026}
2027
Fariborz Jahanian45012a72009-02-03 00:09:52 +00002028LValue CodeGenFunction::EmitLValueForIvar(QualType ObjectTy,
2029 llvm::Value *BaseValue,
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00002030 const ObjCIvarDecl *Ivar,
2031 unsigned CVRQualifiers) {
Chris Lattner26f074b2009-04-17 17:44:48 +00002032 return CGM.getObjCRuntime().EmitObjCValueForIvar(*this, ObjectTy, BaseValue,
Daniel Dunbar525c9b72009-04-21 01:19:28 +00002033 Ivar, CVRQualifiers);
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00002034}
2035
2036LValue CodeGenFunction::EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E) {
Anders Carlsson29b7e502008-08-25 01:53:23 +00002037 // FIXME: A lot of the code below could be shared with EmitMemberExpr.
2038 llvm::Value *BaseValue = 0;
2039 const Expr *BaseExpr = E->getBase();
John McCall0953e762009-09-24 19:53:00 +00002040 Qualifiers BaseQuals;
Fariborz Jahanian45012a72009-02-03 00:09:52 +00002041 QualType ObjectTy;
Anders Carlsson29b7e502008-08-25 01:53:23 +00002042 if (E->isArrow()) {
2043 BaseValue = EmitScalarExpr(BaseExpr);
Steve Naroff14108da2009-07-10 23:34:53 +00002044 ObjectTy = BaseExpr->getType()->getPointeeType();
John McCall0953e762009-09-24 19:53:00 +00002045 BaseQuals = ObjectTy.getQualifiers();
Anders Carlsson29b7e502008-08-25 01:53:23 +00002046 } else {
2047 LValue BaseLV = EmitLValue(BaseExpr);
2048 // FIXME: this isn't right for bitfields.
2049 BaseValue = BaseLV.getAddress();
Fariborz Jahanian45012a72009-02-03 00:09:52 +00002050 ObjectTy = BaseExpr->getType();
John McCall0953e762009-09-24 19:53:00 +00002051 BaseQuals = ObjectTy.getQualifiers();
Anders Carlsson29b7e502008-08-25 01:53:23 +00002052 }
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00002053
Fariborz Jahaniandbf3cfd2009-09-16 23:11:23 +00002054 LValue LV =
John McCall0953e762009-09-24 19:53:00 +00002055 EmitLValueForIvar(ObjectTy, BaseValue, E->getDecl(),
2056 BaseQuals.getCVRQualifiers());
Fariborz Jahaniandbf3cfd2009-09-16 23:11:23 +00002057 setObjCGCLValueClass(getContext(), E, LV);
2058 return LV;
Chris Lattner391d77a2008-03-30 23:03:07 +00002059}
2060
Mike Stumpdb52dcd2009-09-09 13:00:44 +00002061LValue
Daniel Dunbar85c59ed2008-08-29 08:11:39 +00002062CodeGenFunction::EmitObjCPropertyRefLValue(const ObjCPropertyRefExpr *E) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +00002063 // This is a special l-value that just issues sends when we load or store
2064 // through it.
Daniel Dunbar85c59ed2008-08-29 08:11:39 +00002065 return LValue::MakePropertyRef(E, E->getType().getCVRQualifiers());
2066}
2067
Chris Lattnereb99b012009-10-28 17:39:19 +00002068LValue CodeGenFunction::EmitObjCKVCRefLValue(
Fariborz Jahanian09105f52009-08-20 17:02:02 +00002069 const ObjCImplicitSetterGetterRefExpr *E) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +00002070 // This is a special l-value that just issues sends when we load or store
2071 // through it.
Fariborz Jahanian43f44702008-11-22 22:30:21 +00002072 return LValue::MakeKVCRef(E, E->getType().getCVRQualifiers());
2073}
2074
Chris Lattnereb99b012009-10-28 17:39:19 +00002075LValue CodeGenFunction::EmitObjCSuperExprLValue(const ObjCSuperExpr *E) {
Douglas Gregorcd9b46e2008-11-04 14:56:14 +00002076 return EmitUnsupportedLValue(E, "use of super");
2077}
2078
Chris Lattner65459942009-04-25 19:35:26 +00002079LValue CodeGenFunction::EmitStmtExprLValue(const StmtExpr *E) {
Chris Lattner65459942009-04-25 19:35:26 +00002080 // Can only get l-value for message expression returning aggregate type
2081 RValue RV = EmitAnyExprToTemp(E);
Daniel Dunbar9f553f52010-08-21 03:08:16 +00002082 return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
Chris Lattner65459942009-04-25 19:35:26 +00002083}
2084
Anders Carlsson31777a22009-12-24 19:08:58 +00002085RValue CodeGenFunction::EmitCall(QualType CalleeType, llvm::Value *Callee,
Anders Carlssond2490a92009-12-24 20:40:36 +00002086 ReturnValueSlot ReturnValue,
Anders Carlsson98647712009-05-27 01:22:39 +00002087 CallExpr::const_arg_iterator ArgBeg,
2088 CallExpr::const_arg_iterator ArgEnd,
2089 const Decl *TargetDecl) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +00002090 // Get the actual function type. The callee type will always be a pointer to
2091 // function type or a block pointer type.
2092 assert(CalleeType->isFunctionPointerType() &&
Anders Carlsson8ac67a72009-04-07 18:53:02 +00002093 "Call must have function pointer type!");
2094
John McCall00a1ad92009-10-23 08:22:42 +00002095 CalleeType = getContext().getCanonicalType(CalleeType);
2096
John McCall04a67a62010-02-05 21:31:56 +00002097 const FunctionType *FnType
2098 = cast<FunctionType>(cast<PointerType>(CalleeType)->getPointeeType());
2099 QualType ResultType = FnType->getResultType();
Daniel Dunbar19cd87e2008-08-30 03:02:31 +00002100
2101 CallArgList Args;
John McCall00a1ad92009-10-23 08:22:42 +00002102 EmitCallArgs(Args, dyn_cast<FunctionProtoType>(FnType), ArgBeg, ArgEnd);
Daniel Dunbar19cd87e2008-08-30 03:02:31 +00002103
John McCall04a67a62010-02-05 21:31:56 +00002104 return EmitCall(CGM.getTypes().getFunctionInfo(Args, FnType),
Anders Carlssond2490a92009-12-24 20:40:36 +00002105 Callee, ReturnValue, Args, TargetDecl);
Daniel Dunbar8f2926b2008-08-23 03:46:30 +00002106}
Fariborz Jahanian8bfd31f2009-10-22 22:57:31 +00002107
Chris Lattnereb99b012009-10-28 17:39:19 +00002108LValue CodeGenFunction::
2109EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E) {
Eli Friedman1c5c1a02009-11-18 05:01:17 +00002110 llvm::Value *BaseV;
John McCall2de56d12010-08-25 11:45:40 +00002111 if (E->getOpcode() == BO_PtrMemI)
Eli Friedman1c5c1a02009-11-18 05:01:17 +00002112 BaseV = EmitScalarExpr(E->getLHS());
2113 else
2114 BaseV = EmitLValue(E->getLHS()).getAddress();
Chris Lattnereb99b012009-10-28 17:39:19 +00002115
John McCall6c2ab1d2010-08-31 21:07:20 +00002116 llvm::Value *OffsetV = EmitScalarExpr(E->getRHS());
2117
2118 const MemberPointerType *MPT
2119 = E->getRHS()->getType()->getAs<MemberPointerType>();
2120
2121 llvm::Value *AddV =
2122 CGM.getCXXABI().EmitMemberDataPointerAddress(*this, BaseV, OffsetV, MPT);
2123
2124 return MakeAddrLValue(AddV, MPT->getPointeeType());
Fariborz Jahanian8bfd31f2009-10-22 22:57:31 +00002125}
2126