blob: 9e3ed62731091be336a3488614d77331b10be5b0 [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
John McCalld16c2cf2011-02-08 08:22:06 +000032llvm::Value *CodeGenFunction::EmitCastToVoidPtr(llvm::Value *value) {
33 unsigned addressSpace =
34 cast<llvm::PointerType>(value->getType())->getAddressSpace();
35
36 const llvm::PointerType *destType = Int8PtrTy;
37 if (addressSpace)
38 destType = llvm::Type::getInt8PtrTy(getLLVMContext(), addressSpace);
39
40 if (value->getType() == destType) return value;
41 return Builder.CreateBitCast(value, destType);
42}
43
Reid Spencer5f016e22007-07-11 17:01:13 +000044/// CreateTempAlloca - This creates a alloca and inserts it into the entry
45/// block.
46llvm::AllocaInst *CodeGenFunction::CreateTempAlloca(const llvm::Type *Ty,
Daniel Dunbar259e9cc2009-10-19 01:21:05 +000047 const llvm::Twine &Name) {
Chris Lattnerf1466842009-03-22 00:24:14 +000048 if (!Builder.isNamePreserving())
Daniel Dunbar259e9cc2009-10-19 01:21:05 +000049 return new llvm::AllocaInst(Ty, 0, "", AllocaInsertPt);
Devang Pateld35e2e02009-10-12 22:29:02 +000050 return new llvm::AllocaInst(Ty, 0, Name, AllocaInsertPt);
Reid Spencer5f016e22007-07-11 17:01:13 +000051}
52
John McCallac418162010-04-22 01:10:34 +000053void CodeGenFunction::InitTempAlloca(llvm::AllocaInst *Var,
54 llvm::Value *Init) {
55 llvm::StoreInst *Store = new llvm::StoreInst(Init, Var);
56 llvm::BasicBlock *Block = AllocaInsertPt->getParent();
57 Block->getInstList().insertAfter(&*AllocaInsertPt, Store);
58}
59
Chris Lattner121b3fa2010-07-05 20:21:00 +000060llvm::AllocaInst *CodeGenFunction::CreateIRTemp(QualType Ty,
61 const llvm::Twine &Name) {
Daniel Dunbar9bd4da22010-02-16 19:44:13 +000062 llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertType(Ty), Name);
63 // FIXME: Should we prefer the preferred type alignment here?
64 CharUnits Align = getContext().getTypeAlignInChars(Ty);
65 Alloc->setAlignment(Align.getQuantity());
66 return Alloc;
67}
68
Chris Lattner121b3fa2010-07-05 20:21:00 +000069llvm::AllocaInst *CodeGenFunction::CreateMemTemp(QualType Ty,
70 const llvm::Twine &Name) {
Daniel Dunbar195337d2010-02-09 02:48:28 +000071 llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertTypeForMem(Ty), Name);
72 // FIXME: Should we prefer the preferred type alignment here?
73 CharUnits Align = getContext().getTypeAlignInChars(Ty);
74 Alloc->setAlignment(Align.getQuantity());
75 return Alloc;
76}
77
Reid Spencer5f016e22007-07-11 17:01:13 +000078/// EvaluateExprAsBool - Perform the usual unary conversions on the specified
79/// expression and compare the result against zero, returning an Int1Ty value.
80llvm::Value *CodeGenFunction::EvaluateExprAsBool(const Expr *E) {
John McCall0bab0cd2010-08-23 01:21:21 +000081 if (const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>()) {
John McCalld608cdb2010-08-22 10:59:02 +000082 llvm::Value *MemPtr = EmitScalarExpr(E);
John McCalld16c2cf2011-02-08 08:22:06 +000083 return CGM.getCXXABI().EmitMemberPointerIsNotNull(*this, MemPtr, MPT);
Eli Friedman3a173702009-12-11 09:26:29 +000084 }
John McCall0bab0cd2010-08-23 01:21:21 +000085
86 QualType BoolTy = getContext().BoolTy;
Chris Lattner9b2dc282008-04-04 16:54:41 +000087 if (!E->getType()->isAnyComplexType())
Chris Lattner9069fa22007-08-26 16:46:58 +000088 return EmitScalarConversion(EmitScalarExpr(E), E->getType(), BoolTy);
Reid Spencer5f016e22007-07-11 17:01:13 +000089
Chris Lattner9069fa22007-08-26 16:46:58 +000090 return EmitComplexToScalarConversion(EmitComplexExpr(E), E->getType(),BoolTy);
Reid Spencer5f016e22007-07-11 17:01:13 +000091}
92
John McCall2a416372010-12-05 02:00:02 +000093/// EmitIgnoredExpr - Emit code to compute the specified expression,
94/// ignoring the result.
95void CodeGenFunction::EmitIgnoredExpr(const Expr *E) {
96 if (E->isRValue())
97 return (void) EmitAnyExpr(E, AggValueSlot::ignored(), true);
98
99 // Just emit it as an l-value and drop the result.
100 EmitLValue(E);
101}
102
John McCall558d2ab2010-09-15 10:14:12 +0000103/// EmitAnyExpr - Emit code to compute the specified expression which
104/// can have any type. The result is returned as an RValue struct.
105/// If this is an aggregate expression, AggSlot indicates where the
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000106/// result should be returned.
John McCall558d2ab2010-09-15 10:14:12 +0000107RValue CodeGenFunction::EmitAnyExpr(const Expr *E, AggValueSlot AggSlot,
108 bool IgnoreResult) {
Chris Lattner9b655512007-08-31 22:49:20 +0000109 if (!hasAggregateLLVMType(E->getType()))
Mike Stump7f79f9b2009-05-29 15:46:01 +0000110 return RValue::get(EmitScalarExpr(E, IgnoreResult));
Chris Lattner9b2dc282008-04-04 16:54:41 +0000111 else if (E->getType()->isAnyComplexType())
John McCallb418d742010-11-16 10:08:07 +0000112 return RValue::getComplex(EmitComplexExpr(E, IgnoreResult, IgnoreResult));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000113
John McCall558d2ab2010-09-15 10:14:12 +0000114 EmitAggExpr(E, AggSlot, IgnoreResult);
115 return AggSlot.asRValue();
Chris Lattner9b655512007-08-31 22:49:20 +0000116}
117
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000118/// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result will
119/// always be accessible even if no aggregate location is provided.
John McCall558d2ab2010-09-15 10:14:12 +0000120RValue CodeGenFunction::EmitAnyExprToTemp(const Expr *E) {
121 AggValueSlot AggSlot = AggValueSlot::ignored();
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000122
123 if (hasAggregateLLVMType(E->getType()) &&
Daniel Dunbar46f45b92008-09-09 01:06:48 +0000124 !E->getType()->isAnyComplexType())
John McCall558d2ab2010-09-15 10:14:12 +0000125 AggSlot = CreateAggTemp(E->getType(), "agg.tmp");
126 return EmitAnyExpr(E, AggSlot);
Daniel Dunbar46f45b92008-09-09 01:06:48 +0000127}
128
John McCall3d3ec1c2010-04-21 10:05:39 +0000129/// EmitAnyExprToMem - Evaluate an expression into a given memory
130/// location.
131void CodeGenFunction::EmitAnyExprToMem(const Expr *E,
132 llvm::Value *Location,
133 bool IsLocationVolatile,
134 bool IsInit) {
135 if (E->getType()->isComplexType())
136 EmitComplexExprIntoAddr(E, Location, IsLocationVolatile);
137 else if (hasAggregateLLVMType(E->getType()))
John McCall558d2ab2010-09-15 10:14:12 +0000138 EmitAggExpr(E, AggValueSlot::forAddr(Location, IsLocationVolatile, IsInit));
John McCall3d3ec1c2010-04-21 10:05:39 +0000139 else {
140 RValue RV = RValue::get(EmitScalarExpr(E, /*Ignore*/ false));
Daniel Dunbar9f553f52010-08-21 03:08:16 +0000141 LValue LV = MakeAddrLValue(Location, E->getType());
John McCall3d3ec1c2010-04-21 10:05:39 +0000142 EmitStoreThroughLValue(RV, LV, E->getType());
143 }
144}
145
Benjamin Kramer54353f42010-11-25 18:29:30 +0000146namespace {
Douglas Gregor60dcb842010-05-20 08:36:28 +0000147/// \brief An adjustment to be made to the temporary created when emitting a
148/// reference binding, which accesses a particular subobject of that temporary.
Benjamin Kramer54353f42010-11-25 18:29:30 +0000149 struct SubobjectAdjustment {
150 enum { DerivedToBaseAdjustment, FieldAdjustment } Kind;
151
152 union {
153 struct {
154 const CastExpr *BasePath;
155 const CXXRecordDecl *DerivedClass;
156 } DerivedToBase;
157
158 FieldDecl *Field;
159 };
160
161 SubobjectAdjustment(const CastExpr *BasePath,
162 const CXXRecordDecl *DerivedClass)
163 : Kind(DerivedToBaseAdjustment) {
164 DerivedToBase.BasePath = BasePath;
165 DerivedToBase.DerivedClass = DerivedClass;
166 }
167
168 SubobjectAdjustment(FieldDecl *Field)
169 : Kind(FieldAdjustment) {
170 this->Field = Field;
171 }
Douglas Gregor60dcb842010-05-20 08:36:28 +0000172 };
Benjamin Kramer54353f42010-11-25 18:29:30 +0000173}
Douglas Gregor60dcb842010-05-20 08:36:28 +0000174
Anders Carlssondca7ab22010-06-27 16:56:04 +0000175static llvm::Value *
Anders Carlsson656746c2010-06-27 17:23:46 +0000176CreateReferenceTemporary(CodeGenFunction& CGF, QualType Type,
177 const NamedDecl *InitializedDecl) {
178 if (const VarDecl *VD = dyn_cast_or_null<VarDecl>(InitializedDecl)) {
179 if (VD->hasGlobalStorage()) {
180 llvm::SmallString<256> Name;
Rafael Espindolaf0be9792011-02-11 02:52:17 +0000181 llvm::raw_svector_ostream Out(Name);
182 CGF.CGM.getCXXABI().getMangleContext().mangleReferenceTemporary(VD, Out);
183 Out.flush();
184
Anders Carlsson656746c2010-06-27 17:23:46 +0000185 const llvm::Type *RefTempTy = CGF.ConvertTypeForMem(Type);
186
187 // Create the reference temporary.
188 llvm::GlobalValue *RefTemp =
189 new llvm::GlobalVariable(CGF.CGM.getModule(),
190 RefTempTy, /*isConstant=*/false,
191 llvm::GlobalValue::InternalLinkage,
192 llvm::Constant::getNullValue(RefTempTy),
193 Name.str());
194 return RefTemp;
195 }
196 }
197
198 return CGF.CreateMemTemp(Type, "ref.tmp");
199}
200
201static llvm::Value *
Chris Lattnerd0db03a2010-09-06 00:11:41 +0000202EmitExprForReferenceBinding(CodeGenFunction &CGF, const Expr *E,
Anders Carlssondca7ab22010-06-27 16:56:04 +0000203 llvm::Value *&ReferenceTemporary,
204 const CXXDestructorDecl *&ReferenceTemporaryDtor,
Anders Carlsson656746c2010-06-27 17:23:46 +0000205 const NamedDecl *InitializedDecl) {
Eli Friedman27a9b722009-12-19 00:20:10 +0000206 if (const CXXDefaultArgExpr *DAE = dyn_cast<CXXDefaultArgExpr>(E))
207 E = DAE->getExpr();
Anders Carlssonb3f74422009-10-15 00:51:46 +0000208
John McCall4765fa02010-12-06 08:20:24 +0000209 if (const ExprWithCleanups *TE = dyn_cast<ExprWithCleanups>(E)) {
John McCallf1549f62010-07-06 01:34:17 +0000210 CodeGenFunction::RunCleanupsScope Scope(CGF);
Anders Carlssondca7ab22010-06-27 16:56:04 +0000211
212 return EmitExprForReferenceBinding(CGF, TE->getSubExpr(),
213 ReferenceTemporary,
214 ReferenceTemporaryDtor,
Anders Carlsson656746c2010-06-27 17:23:46 +0000215 InitializedDecl);
Anders Carlssondca7ab22010-06-27 16:56:04 +0000216 }
217
218 RValue RV;
Douglas Gregorda29e092011-01-22 02:44:21 +0000219 if (E->isGLValue()) {
Anders Carlssondca7ab22010-06-27 16:56:04 +0000220 // Emit the expression as an lvalue.
221 LValue LV = CGF.EmitLValue(E);
Anders Carlssondca7ab22010-06-27 16:56:04 +0000222 if (LV.isSimple())
223 return LV.getAddress();
Anders Carlsson0dc73662010-02-04 17:32:58 +0000224
Anders Carlssondca7ab22010-06-27 16:56:04 +0000225 // We have to load the lvalue.
226 RV = CGF.EmitLoadOfLValue(LV, E->getType());
Eli Friedman5df0d422009-05-20 02:31:19 +0000227 } else {
Douglas Gregor60dcb842010-05-20 08:36:28 +0000228 QualType ResultTy = E->getType();
Anders Carlssondca7ab22010-06-27 16:56:04 +0000229
Douglas Gregor60dcb842010-05-20 08:36:28 +0000230 llvm::SmallVector<SubobjectAdjustment, 2> Adjustments;
Anders Carlssondca7ab22010-06-27 16:56:04 +0000231 while (true) {
Douglas Gregor2d6b0e92010-05-22 05:17:18 +0000232 if (const ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
233 E = PE->getSubExpr();
234 continue;
235 }
236
237 if (const CastExpr *CE = dyn_cast<CastExpr>(E)) {
John McCall2de56d12010-08-25 11:45:40 +0000238 if ((CE->getCastKind() == CK_DerivedToBase ||
239 CE->getCastKind() == CK_UncheckedDerivedToBase) &&
Douglas Gregor2d6b0e92010-05-22 05:17:18 +0000240 E->getType()->isRecordType()) {
Douglas Gregor60dcb842010-05-20 08:36:28 +0000241 E = CE->getSubExpr();
242 CXXRecordDecl *Derived
243 = cast<CXXRecordDecl>(E->getType()->getAs<RecordType>()->getDecl());
John McCallf871d0c2010-08-07 06:22:56 +0000244 Adjustments.push_back(SubobjectAdjustment(CE, Derived));
Douglas Gregor60dcb842010-05-20 08:36:28 +0000245 continue;
246 }
Douglas Gregor2d6b0e92010-05-22 05:17:18 +0000247
John McCall2de56d12010-08-25 11:45:40 +0000248 if (CE->getCastKind() == CK_NoOp) {
Douglas Gregor2d6b0e92010-05-22 05:17:18 +0000249 E = CE->getSubExpr();
250 continue;
251 }
252 } else if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
John McCall7eb0a9e2010-11-24 05:12:34 +0000253 if (!ME->isArrow() && ME->getBase()->isRValue()) {
254 assert(ME->getBase()->getType()->isRecordType());
Douglas Gregor60dcb842010-05-20 08:36:28 +0000255 if (FieldDecl *Field = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
256 E = ME->getBase();
Daniel Dunbar333d42d2010-08-21 03:37:02 +0000257 Adjustments.push_back(SubobjectAdjustment(Field));
Douglas Gregor60dcb842010-05-20 08:36:28 +0000258 continue;
259 }
260 }
Anders Carlssonb3f74422009-10-15 00:51:46 +0000261 }
Douglas Gregor2d6b0e92010-05-22 05:17:18 +0000262
263 // Nothing changed.
264 break;
Anders Carlsson8478ce62009-08-16 17:50:25 +0000265 }
Anders Carlssonb3f74422009-10-15 00:51:46 +0000266
Anders Carlssondca7ab22010-06-27 16:56:04 +0000267 // Create a reference temporary if necessary.
John McCall558d2ab2010-09-15 10:14:12 +0000268 AggValueSlot AggSlot = AggValueSlot::ignored();
Anders Carlssondca7ab22010-06-27 16:56:04 +0000269 if (CGF.hasAggregateLLVMType(E->getType()) &&
John McCall558d2ab2010-09-15 10:14:12 +0000270 !E->getType()->isAnyComplexType()) {
Anders Carlsson656746c2010-06-27 17:23:46 +0000271 ReferenceTemporary = CreateReferenceTemporary(CGF, E->getType(),
272 InitializedDecl);
John McCall558d2ab2010-09-15 10:14:12 +0000273 AggSlot = AggValueSlot::forAddr(ReferenceTemporary, false,
274 InitializedDecl != 0);
275 }
Anders Carlsson656746c2010-06-27 17:23:46 +0000276
John McCall558d2ab2010-09-15 10:14:12 +0000277 RV = CGF.EmitAnyExpr(E, AggSlot);
Anders Carlssondca7ab22010-06-27 16:56:04 +0000278
Anders Carlsson656746c2010-06-27 17:23:46 +0000279 if (InitializedDecl) {
Anders Carlssondca7ab22010-06-27 16:56:04 +0000280 // Get the destructor for the reference temporary.
281 if (const RecordType *RT = E->getType()->getAs<RecordType>()) {
282 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(RT->getDecl());
283 if (!ClassDecl->hasTrivialDestructor())
Douglas Gregor1d110e02010-07-01 14:13:13 +0000284 ReferenceTemporaryDtor = ClassDecl->getDestructor();
Anders Carlssondca7ab22010-06-27 16:56:04 +0000285 }
286 }
287
Douglas Gregor60dcb842010-05-20 08:36:28 +0000288 // Check if need to perform derived-to-base casts and/or field accesses, to
289 // get from the temporary object we created (and, potentially, for which we
290 // extended the lifetime) to the subobject we're binding the reference to.
291 if (!Adjustments.empty()) {
Anders Carlssondca7ab22010-06-27 16:56:04 +0000292 llvm::Value *Object = RV.getAggregateAddr();
Douglas Gregor60dcb842010-05-20 08:36:28 +0000293 for (unsigned I = Adjustments.size(); I != 0; --I) {
294 SubobjectAdjustment &Adjustment = Adjustments[I-1];
295 switch (Adjustment.Kind) {
296 case SubobjectAdjustment::DerivedToBaseAdjustment:
Anders Carlssondca7ab22010-06-27 16:56:04 +0000297 Object =
298 CGF.GetAddressOfBaseClass(Object,
299 Adjustment.DerivedToBase.DerivedClass,
John McCallf871d0c2010-08-07 06:22:56 +0000300 Adjustment.DerivedToBase.BasePath->path_begin(),
301 Adjustment.DerivedToBase.BasePath->path_end(),
Anders Carlssondca7ab22010-06-27 16:56:04 +0000302 /*NullCheckValue=*/false);
Douglas Gregor60dcb842010-05-20 08:36:28 +0000303 break;
304
305 case SubobjectAdjustment::FieldAdjustment: {
Anders Carlssondca7ab22010-06-27 16:56:04 +0000306 LValue LV =
Daniel Dunbar333d42d2010-08-21 03:37:02 +0000307 CGF.EmitLValueForField(Object, Adjustment.Field, 0);
Douglas Gregor60dcb842010-05-20 08:36:28 +0000308 if (LV.isSimple()) {
309 Object = LV.getAddress();
310 break;
311 }
312
313 // For non-simple lvalues, we actually have to create a copy of
314 // the object we're binding to.
Daniel Dunbar333d42d2010-08-21 03:37:02 +0000315 QualType T = Adjustment.Field->getType().getNonReferenceType()
316 .getUnqualifiedType();
Anders Carlsson045a6d82010-06-27 17:52:15 +0000317 Object = CreateReferenceTemporary(CGF, T, InitializedDecl);
Daniel Dunbar333d42d2010-08-21 03:37:02 +0000318 LValue TempLV = CGF.MakeAddrLValue(Object,
319 Adjustment.Field->getType());
Anders Carlssondca7ab22010-06-27 16:56:04 +0000320 CGF.EmitStoreThroughLValue(CGF.EmitLoadOfLValue(LV, T), TempLV, T);
Douglas Gregor60dcb842010-05-20 08:36:28 +0000321 break;
322 }
Anders Carlssondca7ab22010-06-27 16:56:04 +0000323
Douglas Gregor60dcb842010-05-20 08:36:28 +0000324 }
325 }
326
Anders Carlssondca7ab22010-06-27 16:56:04 +0000327 const llvm::Type *ResultPtrTy = CGF.ConvertType(ResultTy)->getPointerTo();
328 return CGF.Builder.CreateBitCast(Object, ResultPtrTy, "temp");
Anders Carlssonb3f74422009-10-15 00:51:46 +0000329 }
Anders Carlsson4bbab922009-05-20 00:36:58 +0000330 }
Eli Friedman5df0d422009-05-20 02:31:19 +0000331
Anders Carlssondca7ab22010-06-27 16:56:04 +0000332 if (RV.isAggregate())
333 return RV.getAggregateAddr();
Eli Friedman5df0d422009-05-20 02:31:19 +0000334
Anders Carlssondca7ab22010-06-27 16:56:04 +0000335 // Create a temporary variable that we can bind the reference to.
Anders Carlsson656746c2010-06-27 17:23:46 +0000336 ReferenceTemporary = CreateReferenceTemporary(CGF, E->getType(),
337 InitializedDecl);
338
Daniel Dunbar91a16fa2010-08-21 02:24:36 +0000339
340 unsigned Alignment =
341 CGF.getContext().getTypeAlignInChars(E->getType()).getQuantity();
Anders Carlssondca7ab22010-06-27 16:56:04 +0000342 if (RV.isScalar())
343 CGF.EmitStoreOfScalar(RV.getScalarVal(), ReferenceTemporary,
Daniel Dunbar91a16fa2010-08-21 02:24:36 +0000344 /*Volatile=*/false, Alignment, E->getType());
Anders Carlssondca7ab22010-06-27 16:56:04 +0000345 else
346 CGF.StoreComplexToAddr(RV.getComplexVal(), ReferenceTemporary,
347 /*Volatile=*/false);
348 return ReferenceTemporary;
349}
350
351RValue
Chris Lattnerd0db03a2010-09-06 00:11:41 +0000352CodeGenFunction::EmitReferenceBindingToExpr(const Expr *E,
Anders Carlssondca7ab22010-06-27 16:56:04 +0000353 const NamedDecl *InitializedDecl) {
354 llvm::Value *ReferenceTemporary = 0;
355 const CXXDestructorDecl *ReferenceTemporaryDtor = 0;
356 llvm::Value *Value = EmitExprForReferenceBinding(*this, E, ReferenceTemporary,
357 ReferenceTemporaryDtor,
358 InitializedDecl);
Anders Carlsson045a6d82010-06-27 17:52:15 +0000359 if (!ReferenceTemporaryDtor)
360 return RValue::get(Value);
361
Anders Carlssondca7ab22010-06-27 16:56:04 +0000362 // Make sure to call the destructor for the reference temporary.
Anders Carlsson045a6d82010-06-27 17:52:15 +0000363 if (const VarDecl *VD = dyn_cast_or_null<VarDecl>(InitializedDecl)) {
364 if (VD->hasGlobalStorage()) {
365 llvm::Constant *DtorFn =
366 CGM.GetAddrOfCXXDestructor(ReferenceTemporaryDtor, Dtor_Complete);
John McCalld16c2cf2011-02-08 08:22:06 +0000367 EmitCXXGlobalDtorRegistration(DtorFn,
368 cast<llvm::Constant>(ReferenceTemporary));
Anders Carlsson045a6d82010-06-27 17:52:15 +0000369
370 return RValue::get(Value);
371 }
372 }
John McCall81407d42010-07-21 06:29:51 +0000373
374 PushDestructorCleanup(ReferenceTemporaryDtor, ReferenceTemporary);
Anders Carlssondca7ab22010-06-27 16:56:04 +0000375
376 return RValue::get(Value);
Anders Carlsson4029ca72009-05-20 00:24:07 +0000377}
378
379
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000380/// getAccessedFieldNo - Given an encoded value and a result number, return the
381/// input field number being accessed.
382unsigned CodeGenFunction::getAccessedFieldNo(unsigned Idx,
Dan Gohman4f8d1232008-05-22 00:50:06 +0000383 const llvm::Constant *Elts) {
384 if (isa<llvm::ConstantAggregateZero>(Elts))
385 return 0;
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000386
Dan Gohman4f8d1232008-05-22 00:50:06 +0000387 return cast<llvm::ConstantInt>(Elts->getOperand(Idx))->getZExtValue();
388}
389
Mike Stumpb14e62d2009-12-16 02:57:00 +0000390void CodeGenFunction::EmitCheck(llvm::Value *Address, unsigned Size) {
391 if (!CatchUndefined)
392 return;
393
John McCalld16c2cf2011-02-08 08:22:06 +0000394 // This needs to be to the standard address space.
395 Address = Builder.CreateBitCast(Address, Int8PtrTy);
Mike Stumpb14e62d2009-12-16 02:57:00 +0000396
Chris Lattner77b89b82010-06-27 07:15:29 +0000397 const llvm::Type *IntPtrT = IntPtrTy;
398 llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::objectsize, &IntPtrT, 1);
Chris Lattnerc24b9c42010-04-10 18:34:14 +0000399
Mike Stumpb14e62d2009-12-16 02:57:00 +0000400 // In time, people may want to control this and use a 1 here.
John McCalld16c2cf2011-02-08 08:22:06 +0000401 llvm::Value *Arg = Builder.getFalse();
Mike Stumpb14e62d2009-12-16 02:57:00 +0000402 llvm::Value *C = Builder.CreateCall2(F, Address, Arg);
403 llvm::BasicBlock *Cont = createBasicBlock();
404 llvm::BasicBlock *Check = createBasicBlock();
Chris Lattner77b89b82010-06-27 07:15:29 +0000405 llvm::Value *NegativeOne = llvm::ConstantInt::get(IntPtrTy, -1ULL);
Mike Stumpb14e62d2009-12-16 02:57:00 +0000406 Builder.CreateCondBr(Builder.CreateICmpEQ(C, NegativeOne), Cont, Check);
407
408 EmitBlock(Check);
409 Builder.CreateCondBr(Builder.CreateICmpUGE(C,
Chris Lattner77b89b82010-06-27 07:15:29 +0000410 llvm::ConstantInt::get(IntPtrTy, Size)),
Mike Stumpb14e62d2009-12-16 02:57:00 +0000411 Cont, getTrapBB());
412 EmitBlock(Cont);
413}
Chris Lattner9b655512007-08-31 22:49:20 +0000414
Chris Lattnerdd36d322010-01-09 21:40:03 +0000415
Chris Lattnerdd36d322010-01-09 21:40:03 +0000416CodeGenFunction::ComplexPairTy CodeGenFunction::
417EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV,
418 bool isInc, bool isPre) {
419 ComplexPairTy InVal = LoadComplexFromAddr(LV.getAddress(),
420 LV.isVolatileQualified());
421
422 llvm::Value *NextVal;
423 if (isa<llvm::IntegerType>(InVal.first->getType())) {
424 uint64_t AmountVal = isInc ? 1 : -1;
425 NextVal = llvm::ConstantInt::get(InVal.first->getType(), AmountVal, true);
426
427 // Add the inc/dec to the real part.
428 NextVal = Builder.CreateAdd(InVal.first, NextVal, isInc ? "inc" : "dec");
429 } else {
430 QualType ElemTy = E->getType()->getAs<ComplexType>()->getElementType();
431 llvm::APFloat FVal(getContext().getFloatTypeSemantics(ElemTy), 1);
432 if (!isInc)
433 FVal.changeSign();
434 NextVal = llvm::ConstantFP::get(getLLVMContext(), FVal);
435
436 // Add the inc/dec to the real part.
437 NextVal = Builder.CreateFAdd(InVal.first, NextVal, isInc ? "inc" : "dec");
438 }
439
440 ComplexPairTy IncVal(NextVal, InVal.second);
441
442 // Store the updated result through the lvalue.
443 StoreComplexToAddr(IncVal, LV.getAddress(), LV.isVolatileQualified());
444
445 // If this is a postinc, return the value read from memory, otherwise use the
446 // updated value.
447 return isPre ? IncVal : InVal;
448}
449
450
Reid Spencer5f016e22007-07-11 17:01:13 +0000451//===----------------------------------------------------------------------===//
452// LValue Expression Emission
453//===----------------------------------------------------------------------===//
454
Daniel Dunbar13e81732009-02-05 07:09:07 +0000455RValue CodeGenFunction::GetUndefRValue(QualType Ty) {
Chris Lattnereb99b012009-10-28 17:39:19 +0000456 if (Ty->isVoidType())
Daniel Dunbar13e81732009-02-05 07:09:07 +0000457 return RValue::get(0);
Chris Lattnereb99b012009-10-28 17:39:19 +0000458
459 if (const ComplexType *CTy = Ty->getAs<ComplexType>()) {
Daniel Dunbar8fa73ed2009-01-09 20:09:28 +0000460 const llvm::Type *EltTy = ConvertType(CTy->getElementType());
Owen Anderson03e20502009-07-30 23:11:26 +0000461 llvm::Value *U = llvm::UndefValue::get(EltTy);
Daniel Dunbar8fa73ed2009-01-09 20:09:28 +0000462 return RValue::getComplex(std::make_pair(U, U));
Chris Lattnereb99b012009-10-28 17:39:19 +0000463 }
464
Chris Lattnerb6c504b2010-08-23 05:26:13 +0000465 // If this is a use of an undefined aggregate type, the aggregate must have an
466 // identifiable address. Just because the contents of the value are undefined
467 // doesn't mean that the address can't be taken and compared.
Chris Lattnereb99b012009-10-28 17:39:19 +0000468 if (hasAggregateLLVMType(Ty)) {
Chris Lattnerb6c504b2010-08-23 05:26:13 +0000469 llvm::Value *DestPtr = CreateMemTemp(Ty, "undef.agg.tmp");
470 return RValue::getAggregate(DestPtr);
Daniel Dunbar8fa73ed2009-01-09 20:09:28 +0000471 }
Chris Lattnereb99b012009-10-28 17:39:19 +0000472
473 return RValue::get(llvm::UndefValue::get(ConvertType(Ty)));
Daniel Dunbarce1d38b2009-01-09 16:50:52 +0000474}
475
Daniel Dunbar13e81732009-02-05 07:09:07 +0000476RValue CodeGenFunction::EmitUnsupportedRValue(const Expr *E,
477 const char *Name) {
478 ErrorUnsupported(E, Name);
479 return GetUndefRValue(E->getType());
480}
481
Daniel Dunbar6ba82a42008-08-25 20:45:57 +0000482LValue CodeGenFunction::EmitUnsupportedLValue(const Expr *E,
483 const char *Name) {
484 ErrorUnsupported(E, Name);
Owen Anderson96e0fc72009-07-29 22:16:19 +0000485 llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType()));
Daniel Dunbar9f553f52010-08-21 03:08:16 +0000486 return MakeAddrLValue(llvm::UndefValue::get(Ty), E->getType());
Daniel Dunbar6ba82a42008-08-25 20:45:57 +0000487}
488
Mike Stumpb14e62d2009-12-16 02:57:00 +0000489LValue CodeGenFunction::EmitCheckedLValue(const Expr *E) {
490 LValue LV = EmitLValue(E);
Daniel Dunbarf0fe5bc2010-04-05 21:36:35 +0000491 if (!isa<DeclRefExpr>(E) && !LV.isBitField() && LV.isSimple())
Ken Dyckfe710082011-01-19 01:58:38 +0000492 EmitCheck(LV.getAddress(),
493 getContext().getTypeSizeInChars(E->getType()).getQuantity());
Mike Stumpb14e62d2009-12-16 02:57:00 +0000494 return LV;
495}
496
Reid Spencer5f016e22007-07-11 17:01:13 +0000497/// EmitLValue - Emit code to compute a designator that specifies the location
498/// of the expression.
499///
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000500/// This can return one of two things: a simple address or a bitfield reference.
501/// In either case, the LLVM Value* in the LValue structure is guaranteed to be
502/// an LLVM pointer type.
Reid Spencer5f016e22007-07-11 17:01:13 +0000503///
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000504/// If this returns a bitfield reference, nothing about the pointee type of the
505/// LLVM value is known: For example, it may not be a pointer to an integer.
Reid Spencer5f016e22007-07-11 17:01:13 +0000506///
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000507/// If this returns a normal address, and if the lvalue's C type is fixed size,
508/// this method guarantees that the returned pointer type will point to an LLVM
509/// type of the same size of the lvalue's type. If the lvalue has a variable
510/// length type, this is not possible.
Reid Spencer5f016e22007-07-11 17:01:13 +0000511///
512LValue CodeGenFunction::EmitLValue(const Expr *E) {
Fariborz Jahanian0b787102010-09-21 18:32:21 +0000513 llvm::DenseMap<const Expr *, LValue>::iterator I =
John McCalld16c2cf2011-02-08 08:22:06 +0000514 ConditionalSaveLValueExprs.find(E);
515 if (I != ConditionalSaveLValueExprs.end())
Fariborz Jahanian0b787102010-09-21 18:32:21 +0000516 return I->second;
517
Reid Spencer5f016e22007-07-11 17:01:13 +0000518 switch (E->getStmtClass()) {
Daniel Dunbar6ba82a42008-08-25 20:45:57 +0000519 default: return EmitUnsupportedLValue(E, "l-value expression");
Reid Spencer5f016e22007-07-11 17:01:13 +0000520
Fariborz Jahanian03b29602010-06-17 19:56:20 +0000521 case Expr::ObjCSelectorExprClass:
522 return EmitObjCSelectorLValue(cast<ObjCSelectorExpr>(E));
Fariborz Jahanian820bca42009-12-09 23:35:29 +0000523 case Expr::ObjCIsaExprClass:
524 return EmitObjCIsaExpr(cast<ObjCIsaExpr>(E));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000525 case Expr::BinaryOperatorClass:
Daniel Dunbar80e62c22008-09-04 03:20:13 +0000526 return EmitBinaryOperatorLValue(cast<BinaryOperator>(E));
Douglas Gregor6a03e342010-04-23 04:16:32 +0000527 case Expr::CompoundAssignOperatorClass:
John McCall2a416372010-12-05 02:00:02 +0000528 if (!E->getType()->isAnyComplexType())
529 return EmitCompoundAssignmentLValue(cast<CompoundAssignOperator>(E));
530 return EmitComplexCompoundAssignmentLValue(cast<CompoundAssignOperator>(E));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000531 case Expr::CallExprClass:
Anders Carlssonfaf86642009-09-01 21:18:52 +0000532 case Expr::CXXMemberCallExprClass:
Douglas Gregorb4609802008-11-14 16:09:21 +0000533 case Expr::CXXOperatorCallExprClass:
534 return EmitCallExprLValue(cast<CallExpr>(E));
Daniel Dunbar5b5c9ef2009-02-11 20:59:32 +0000535 case Expr::VAArgExprClass:
536 return EmitVAArgExprLValue(cast<VAArgExpr>(E));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000537 case Expr::DeclRefExprClass:
Douglas Gregor1a49af92009-01-06 05:10:23 +0000538 return EmitDeclRefLValue(cast<DeclRefExpr>(E));
Reid Spencer5f016e22007-07-11 17:01:13 +0000539 case Expr::ParenExprClass:return EmitLValue(cast<ParenExpr>(E)->getSubExpr());
Chris Lattnerd9f69102008-08-10 01:53:14 +0000540 case Expr::PredefinedExprClass:
541 return EmitPredefinedLValue(cast<PredefinedExpr>(E));
Reid Spencer5f016e22007-07-11 17:01:13 +0000542 case Expr::StringLiteralClass:
543 return EmitStringLiteralLValue(cast<StringLiteral>(E));
Chris Lattnereaf2bb82009-02-24 22:18:39 +0000544 case Expr::ObjCEncodeExprClass:
545 return EmitObjCEncodeExprLValue(cast<ObjCEncodeExpr>(E));
Chris Lattner391d77a2008-03-30 23:03:07 +0000546
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000547 case Expr::BlockDeclRefExprClass:
Mike Stumpa99038c2009-02-28 09:07:16 +0000548 return EmitBlockDeclRefLValue(cast<BlockDeclRefExpr>(E));
549
Anders Carlssonb58d0172009-05-30 23:23:33 +0000550 case Expr::CXXTemporaryObjectExprClass:
551 case Expr::CXXConstructExprClass:
Anders Carlssone61c9e82009-05-30 23:30:54 +0000552 return EmitCXXConstructLValue(cast<CXXConstructExpr>(E));
553 case Expr::CXXBindTemporaryExprClass:
554 return EmitCXXBindTemporaryLValue(cast<CXXBindTemporaryExpr>(E));
John McCall4765fa02010-12-06 08:20:24 +0000555 case Expr::ExprWithCleanupsClass:
556 return EmitExprWithCleanupsLValue(cast<ExprWithCleanups>(E));
Douglas Gregored8abf12010-07-08 06:14:04 +0000557 case Expr::CXXScalarValueInitExprClass:
558 return EmitNullInitializationLValue(cast<CXXScalarValueInitExpr>(E));
Anders Carlsson370e5382009-11-14 01:51:50 +0000559 case Expr::CXXDefaultArgExprClass:
560 return EmitLValue(cast<CXXDefaultArgExpr>(E)->getExpr());
Mike Stumpc2e84ae2009-11-15 08:09:41 +0000561 case Expr::CXXTypeidExprClass:
562 return EmitCXXTypeidLValue(cast<CXXTypeidExpr>(E));
Anders Carlssone61c9e82009-05-30 23:30:54 +0000563
Daniel Dunbar0a04d772008-08-23 10:51:21 +0000564 case Expr::ObjCMessageExprClass:
565 return EmitObjCMessageExprLValue(cast<ObjCMessageExpr>(E));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000566 case Expr::ObjCIvarRefExprClass:
Chris Lattner391d77a2008-03-30 23:03:07 +0000567 return EmitObjCIvarRefLValue(cast<ObjCIvarRefExpr>(E));
Daniel Dunbar6ba82a42008-08-25 20:45:57 +0000568 case Expr::ObjCPropertyRefExprClass:
Daniel Dunbar85c59ed2008-08-29 08:11:39 +0000569 return EmitObjCPropertyRefLValue(cast<ObjCPropertyRefExpr>(E));
Chris Lattner65459942009-04-25 19:35:26 +0000570 case Expr::StmtExprClass:
571 return EmitStmtExprLValue(cast<StmtExpr>(E));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000572 case Expr::UnaryOperatorClass:
Reid Spencer5f016e22007-07-11 17:01:13 +0000573 return EmitUnaryOpLValue(cast<UnaryOperator>(E));
574 case Expr::ArraySubscriptExprClass:
575 return EmitArraySubscriptExpr(cast<ArraySubscriptExpr>(E));
Nate Begeman213541a2008-04-18 23:10:10 +0000576 case Expr::ExtVectorElementExprClass:
577 return EmitExtVectorElementExpr(cast<ExtVectorElementExpr>(E));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000578 case Expr::MemberExprClass:
Douglas Gregorbd4c4ae2009-08-26 22:36:53 +0000579 return EmitMemberExpr(cast<MemberExpr>(E));
Eli Friedman06e863f2008-05-13 23:18:27 +0000580 case Expr::CompoundLiteralExprClass:
581 return EmitCompoundLiteralLValue(cast<CompoundLiteralExpr>(E));
Daniel Dunbar90345582009-03-24 02:38:23 +0000582 case Expr::ConditionalOperatorClass:
Anders Carlsson6fcec8b2009-09-15 16:35:24 +0000583 return EmitConditionalOperatorLValue(cast<ConditionalOperator>(E));
Chris Lattner670a62c2008-12-12 05:35:08 +0000584 case Expr::ChooseExprClass:
Eli Friedman79769322009-03-04 05:52:32 +0000585 return EmitLValue(cast<ChooseExpr>(E)->getChosenSubExpr(getContext()));
Chris Lattnerc3953a62009-03-18 04:02:57 +0000586 case Expr::ImplicitCastExprClass:
587 case Expr::CStyleCastExprClass:
588 case Expr::CXXFunctionalCastExprClass:
589 case Expr::CXXStaticCastExprClass:
590 case Expr::CXXDynamicCastExprClass:
591 case Expr::CXXReinterpretCastExprClass:
592 case Expr::CXXConstCastExprClass:
Chris Lattner75dfeda2009-03-18 18:28:57 +0000593 return EmitCastLValue(cast<CastExpr>(E));
Reid Spencer5f016e22007-07-11 17:01:13 +0000594 }
595}
596
Daniel Dunbar9d9cc872009-02-10 00:57:50 +0000597llvm::Value *CodeGenFunction::EmitLoadOfScalar(llvm::Value *Addr, bool Volatile,
Dan Gohman3d5aff52010-10-14 23:06:10 +0000598 unsigned Alignment, QualType Ty,
599 llvm::MDNode *TBAAInfo) {
Daniel Dunbar2da84ff2009-11-29 21:23:36 +0000600 llvm::LoadInst *Load = Builder.CreateLoad(Addr, "tmp");
601 if (Volatile)
602 Load->setVolatile(true);
Daniel Dunbar91a16fa2010-08-21 02:24:36 +0000603 if (Alignment)
604 Load->setAlignment(Alignment);
Dan Gohman3d5aff52010-10-14 23:06:10 +0000605 if (TBAAInfo)
606 CGM.DecorateInstruction(Load, TBAAInfo);
Daniel Dunbar9d9cc872009-02-10 00:57:50 +0000607
John McCall26815d92010-10-27 20:58:56 +0000608 return EmitFromMemory(Load, Ty);
Daniel Dunbar9d9cc872009-02-10 00:57:50 +0000609}
610
Douglas Gregor1274ccd2010-10-08 23:50:27 +0000611static bool isBooleanUnderlyingType(QualType Ty) {
612 if (const EnumType *ET = dyn_cast<EnumType>(Ty))
613 return ET->getDecl()->getIntegerType()->isBooleanType();
614 return false;
615}
616
John McCall26815d92010-10-27 20:58:56 +0000617llvm::Value *CodeGenFunction::EmitToMemory(llvm::Value *Value, QualType Ty) {
618 // Bool has a different representation in memory than in registers.
619 if (Ty->isBooleanType() || isBooleanUnderlyingType(Ty)) {
620 // This should really always be an i1, but sometimes it's already
621 // an i8, and it's awkward to track those cases down.
622 if (Value->getType()->isIntegerTy(1))
623 return Builder.CreateZExt(Value, Builder.getInt8Ty(), "frombool");
624 assert(Value->getType()->isIntegerTy(8) && "value rep of bool not i1/i8");
625 }
626
627 return Value;
628}
629
630llvm::Value *CodeGenFunction::EmitFromMemory(llvm::Value *Value, QualType Ty) {
631 // Bool has a different representation in memory than in registers.
632 if (Ty->isBooleanType() || isBooleanUnderlyingType(Ty)) {
633 assert(Value->getType()->isIntegerTy(8) && "memory rep of bool not i8");
634 return Builder.CreateTrunc(Value, Builder.getInt1Ty(), "tobool");
635 }
636
637 return Value;
638}
639
Daniel Dunbar9d9cc872009-02-10 00:57:50 +0000640void CodeGenFunction::EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr,
Daniel Dunbar91a16fa2010-08-21 02:24:36 +0000641 bool Volatile, unsigned Alignment,
Dan Gohman3d5aff52010-10-14 23:06:10 +0000642 QualType Ty,
643 llvm::MDNode *TBAAInfo) {
John McCall26815d92010-10-27 20:58:56 +0000644 Value = EmitToMemory(Value, Ty);
Daniel Dunbar91a16fa2010-08-21 02:24:36 +0000645 llvm::StoreInst *Store = Builder.CreateStore(Value, Addr, Volatile);
646 if (Alignment)
647 Store->setAlignment(Alignment);
Dan Gohman3d5aff52010-10-14 23:06:10 +0000648 if (TBAAInfo)
649 CGM.DecorateInstruction(Store, TBAAInfo);
Daniel Dunbar9d9cc872009-02-10 00:57:50 +0000650}
651
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000652/// EmitLoadOfLValue - Given an expression that represents a value lvalue, this
653/// method emits the address of the lvalue, then loads the result as an rvalue,
654/// returning the rvalue.
Reid Spencer5f016e22007-07-11 17:01:13 +0000655RValue CodeGenFunction::EmitLoadOfLValue(LValue LV, QualType ExprType) {
Fariborz Jahaniandbd32c22008-11-19 17:34:06 +0000656 if (LV.isObjCWeak()) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000657 // load of a __weak object.
Fariborz Jahanian6dc23172008-11-18 21:45:40 +0000658 llvm::Value *AddrWeakObj = LV.getAddress();
Chris Lattnereb99b012009-10-28 17:39:19 +0000659 return RValue::get(CGM.getObjCRuntime().EmitObjCWeakRead(*this,
660 AddrWeakObj));
Fariborz Jahanian6dc23172008-11-18 21:45:40 +0000661 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000662
Reid Spencer5f016e22007-07-11 17:01:13 +0000663 if (LV.isSimple()) {
664 llvm::Value *Ptr = LV.getAddress();
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000665
John McCalld608cdb2010-08-22 10:59:02 +0000666 // Functions are l-values that don't require loading.
667 if (ExprType->isFunctionType())
668 return RValue::get(Ptr);
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000669
John McCalld608cdb2010-08-22 10:59:02 +0000670 // Everything needs a load.
671 return RValue::get(EmitLoadOfScalar(Ptr, LV.isVolatileQualified(),
Dan Gohman3d5aff52010-10-14 23:06:10 +0000672 LV.getAlignment(), ExprType,
673 LV.getTBAAInfo()));
John McCalld608cdb2010-08-22 10:59:02 +0000674
Reid Spencer5f016e22007-07-11 17:01:13 +0000675 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000676
Reid Spencer5f016e22007-07-11 17:01:13 +0000677 if (LV.isVectorElt()) {
Eli Friedman1e692ac2008-06-13 23:01:12 +0000678 llvm::Value *Vec = Builder.CreateLoad(LV.getVectorAddr(),
679 LV.isVolatileQualified(), "tmp");
Reid Spencer5f016e22007-07-11 17:01:13 +0000680 return RValue::get(Builder.CreateExtractElement(Vec, LV.getVectorIdx(),
681 "vecext"));
682 }
Chris Lattner46ea8eb2007-08-03 00:16:29 +0000683
684 // If this is a reference to a subset of the elements of a vector, either
685 // shuffle the input or extract/insert them as appropriate.
Nate Begeman213541a2008-04-18 23:10:10 +0000686 if (LV.isExtVectorElt())
687 return EmitLoadOfExtVectorElementLValue(LV, ExprType);
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +0000688
Daniel Dunbarf0fe5bc2010-04-05 21:36:35 +0000689 if (LV.isBitField())
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +0000690 return EmitLoadOfBitfieldLValue(LV, ExprType);
691
John McCall119a1c62010-12-04 02:32:38 +0000692 assert(LV.isPropertyRef() && "Unknown LValue type!");
693 return EmitLoadOfPropertyRefLValue(LV);
Reid Spencer5f016e22007-07-11 17:01:13 +0000694}
695
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +0000696RValue CodeGenFunction::EmitLoadOfBitfieldLValue(LValue LV,
697 QualType ExprType) {
Daniel Dunbarefbf4872010-04-06 01:07:44 +0000698 const CGBitFieldInfo &Info = LV.getBitFieldInfo();
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000699
Daniel Dunbarecdb41e2010-04-13 23:34:15 +0000700 // Get the output type.
701 const llvm::Type *ResLTy = ConvertType(ExprType);
702 unsigned ResSizeInBits = CGM.getTargetData().getTypeSizeInBits(ResLTy);
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +0000703
Daniel Dunbarecdb41e2010-04-13 23:34:15 +0000704 // Compute the result as an OR of all of the individual component accesses.
705 llvm::Value *Res = 0;
706 for (unsigned i = 0, e = Info.getNumComponents(); i != e; ++i) {
707 const CGBitFieldInfo::AccessInfo &AI = Info.getComponent(i);
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000708
Daniel Dunbarecdb41e2010-04-13 23:34:15 +0000709 // Get the field pointer.
710 llvm::Value *Ptr = LV.getBitFieldBaseAddr();
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000711
Daniel Dunbarecdb41e2010-04-13 23:34:15 +0000712 // Only offset by the field index if used, so that incoming values are not
713 // required to be structures.
714 if (AI.FieldIndex)
715 Ptr = Builder.CreateStructGEP(Ptr, AI.FieldIndex, "bf.field");
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000716
Daniel Dunbarecdb41e2010-04-13 23:34:15 +0000717 // Offset by the byte offset, if used.
718 if (AI.FieldByteOffset) {
John McCalld16c2cf2011-02-08 08:22:06 +0000719 Ptr = EmitCastToVoidPtr(Ptr);
Daniel Dunbarecdb41e2010-04-13 23:34:15 +0000720 Ptr = Builder.CreateConstGEP1_32(Ptr, AI.FieldByteOffset,"bf.field.offs");
721 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000722
Daniel Dunbarecdb41e2010-04-13 23:34:15 +0000723 // Cast to the access type.
John McCalld16c2cf2011-02-08 08:22:06 +0000724 const llvm::Type *PTy = llvm::Type::getIntNPtrTy(getLLVMContext(),
725 AI.AccessWidth,
Daniel Dunbarecdb41e2010-04-13 23:34:15 +0000726 ExprType.getAddressSpace());
727 Ptr = Builder.CreateBitCast(Ptr, PTy);
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +0000728
Daniel Dunbarecdb41e2010-04-13 23:34:15 +0000729 // Perform the load.
730 llvm::LoadInst *Load = Builder.CreateLoad(Ptr, LV.isVolatileQualified());
731 if (AI.AccessAlignment)
732 Load->setAlignment(AI.AccessAlignment);
733
734 // Shift out unused low bits and mask out unused high bits.
735 llvm::Value *Val = Load;
736 if (AI.FieldBitStart)
Daniel Dunbar26772612010-04-15 03:47:33 +0000737 Val = Builder.CreateLShr(Load, AI.FieldBitStart);
Daniel Dunbarecdb41e2010-04-13 23:34:15 +0000738 Val = Builder.CreateAnd(Val, llvm::APInt::getLowBitsSet(AI.AccessWidth,
739 AI.TargetBitWidth),
740 "bf.clear");
741
742 // Extend or truncate to the target size.
743 if (AI.AccessWidth < ResSizeInBits)
744 Val = Builder.CreateZExt(Val, ResLTy);
745 else if (AI.AccessWidth > ResSizeInBits)
746 Val = Builder.CreateTrunc(Val, ResLTy);
747
748 // Shift into place, and OR into the result.
749 if (AI.TargetBitOffset)
750 Val = Builder.CreateShl(Val, AI.TargetBitOffset);
751 Res = Res ? Builder.CreateOr(Res, Val) : Val;
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000752 }
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +0000753
Daniel Dunbarecdb41e2010-04-13 23:34:15 +0000754 // If the bit-field is signed, perform the sign-extension.
755 //
756 // FIXME: This can easily be folded into the load of the high bits, which
757 // could also eliminate the mask of high bits in some situations.
758 if (Info.isSigned()) {
Daniel Dunbar26772612010-04-15 03:47:33 +0000759 unsigned ExtraBits = ResSizeInBits - Info.getSize();
Daniel Dunbarecdb41e2010-04-13 23:34:15 +0000760 if (ExtraBits)
761 Res = Builder.CreateAShr(Builder.CreateShl(Res, ExtraBits),
762 ExtraBits, "bf.val.sext");
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000763 }
Eli Friedman316bb1b2008-05-17 20:03:47 +0000764
Daniel Dunbarecdb41e2010-04-13 23:34:15 +0000765 return RValue::get(Res);
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +0000766}
767
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000768// If this is a reference to a subset of the elements of a vector, create an
769// appropriate shufflevector.
Nate Begeman213541a2008-04-18 23:10:10 +0000770RValue CodeGenFunction::EmitLoadOfExtVectorElementLValue(LValue LV,
771 QualType ExprType) {
Eli Friedman1e692ac2008-06-13 23:01:12 +0000772 llvm::Value *Vec = Builder.CreateLoad(LV.getExtVectorAddr(),
773 LV.isVolatileQualified(), "tmp");
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000774
Nate Begeman8a997642008-05-09 06:41:27 +0000775 const llvm::Constant *Elts = LV.getExtVectorElts();
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000776
777 // If the result of the expression is a non-vector type, we must be extracting
778 // a single element. Just codegen as an extractelement.
John McCall183700f2009-09-21 23:43:11 +0000779 const VectorType *ExprVT = ExprType->getAs<VectorType>();
Chris Lattnercf60cd22007-08-10 17:10:08 +0000780 if (!ExprVT) {
Dan Gohman4f8d1232008-05-22 00:50:06 +0000781 unsigned InIdx = getAccessedFieldNo(0, Elts);
Chris Lattner77b89b82010-06-27 07:15:29 +0000782 llvm::Value *Elt = llvm::ConstantInt::get(Int32Ty, InIdx);
Chris Lattner34cdc862007-08-03 16:18:34 +0000783 return RValue::get(Builder.CreateExtractElement(Vec, Elt, "tmp"));
784 }
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000785
786 // Always use shuffle vector to try to retain the original program structure
Chris Lattnercf60cd22007-08-10 17:10:08 +0000787 unsigned NumResultElts = ExprVT->getNumElements();
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000788
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000789 llvm::SmallVector<llvm::Constant*, 4> Mask;
Chris Lattner34cdc862007-08-03 16:18:34 +0000790 for (unsigned i = 0; i != NumResultElts; ++i) {
Dan Gohman4f8d1232008-05-22 00:50:06 +0000791 unsigned InIdx = getAccessedFieldNo(i, Elts);
Chris Lattner77b89b82010-06-27 07:15:29 +0000792 Mask.push_back(llvm::ConstantInt::get(Int32Ty, InIdx));
Chris Lattner34cdc862007-08-03 16:18:34 +0000793 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000794
Chris Lattnerfb018d12011-02-15 00:14:06 +0000795 llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
796 Vec = Builder.CreateShuffleVector(Vec, llvm::UndefValue::get(Vec->getType()),
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000797 MaskV, "tmp");
798 return RValue::get(Vec);
Chris Lattner34cdc862007-08-03 16:18:34 +0000799}
800
801
Reid Spencer5f016e22007-07-11 17:01:13 +0000802
803/// EmitStoreThroughLValue - Store the specified rvalue into the specified
804/// lvalue, where both are guaranteed to the have the same type, and that type
805/// is 'Ty'.
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000806void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst,
Reid Spencer5f016e22007-07-11 17:01:13 +0000807 QualType Ty) {
Chris Lattner017d6aa2007-08-03 16:28:33 +0000808 if (!Dst.isSimple()) {
809 if (Dst.isVectorElt()) {
810 // Read/modify/write the vector, inserting the new element.
Eli Friedman1e692ac2008-06-13 23:01:12 +0000811 llvm::Value *Vec = Builder.CreateLoad(Dst.getVectorAddr(),
812 Dst.isVolatileQualified(), "tmp");
Chris Lattner9b655512007-08-31 22:49:20 +0000813 Vec = Builder.CreateInsertElement(Vec, Src.getScalarVal(),
Chris Lattner017d6aa2007-08-03 16:28:33 +0000814 Dst.getVectorIdx(), "vecins");
Eli Friedman1e692ac2008-06-13 23:01:12 +0000815 Builder.CreateStore(Vec, Dst.getVectorAddr(),Dst.isVolatileQualified());
Chris Lattner017d6aa2007-08-03 16:28:33 +0000816 return;
817 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000818
Nate Begeman213541a2008-04-18 23:10:10 +0000819 // If this is an update of extended vector elements, insert them as
820 // appropriate.
821 if (Dst.isExtVectorElt())
822 return EmitStoreThroughExtVectorComponentLValue(Src, Dst, Ty);
Lauro Ramos Venancioa0c5d0e2008-01-22 22:36:45 +0000823
Daniel Dunbarf0fe5bc2010-04-05 21:36:35 +0000824 if (Dst.isBitField())
Lauro Ramos Venancioa0c5d0e2008-01-22 22:36:45 +0000825 return EmitStoreThroughBitfieldLValue(Src, Dst, Ty);
826
John McCall119a1c62010-12-04 02:32:38 +0000827 assert(Dst.isPropertyRef() && "Unknown LValue type");
828 return EmitStoreThroughPropertyRefLValue(Src, Dst);
Chris Lattner017d6aa2007-08-03 16:28:33 +0000829 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000830
Fariborz Jahanian4f676ed2009-02-21 00:30:43 +0000831 if (Dst.isObjCWeak() && !Dst.isNonGC()) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000832 // load of a __weak object.
Fariborz Jahaniandbd32c22008-11-19 17:34:06 +0000833 llvm::Value *LvalueDst = Dst.getAddress();
834 llvm::Value *src = Src.getScalarVal();
Mike Stumpf33651c2009-04-14 00:57:29 +0000835 CGM.getObjCRuntime().EmitObjCWeakAssign(*this, src, LvalueDst);
Fariborz Jahaniandbd32c22008-11-19 17:34:06 +0000836 return;
837 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000838
Fariborz Jahanian4f676ed2009-02-21 00:30:43 +0000839 if (Dst.isObjCStrong() && !Dst.isNonGC()) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000840 // load of a __strong object.
Fariborz Jahaniandbd32c22008-11-19 17:34:06 +0000841 llvm::Value *LvalueDst = Dst.getAddress();
842 llvm::Value *src = Src.getScalarVal();
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +0000843 if (Dst.isObjCIvar()) {
844 assert(Dst.getBaseIvarExp() && "BaseIvarExp is NULL");
845 const llvm::Type *ResultType = ConvertType(getContext().LongTy);
846 llvm::Value *RHS = EmitScalarExpr(Dst.getBaseIvarExp());
Fariborz Jahanian76368e82009-09-25 00:00:20 +0000847 llvm::Value *dst = RHS;
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +0000848 RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast");
849 llvm::Value *LHS =
850 Builder.CreatePtrToInt(LvalueDst, ResultType, "sub.ptr.lhs.cast");
851 llvm::Value *BytesBetween = Builder.CreateSub(LHS, RHS, "ivar.offset");
Fariborz Jahanian76368e82009-09-25 00:00:20 +0000852 CGM.getObjCRuntime().EmitObjCIvarAssign(*this, src, dst,
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +0000853 BytesBetween);
Fariborz Jahanian021a7a62010-07-20 20:30:03 +0000854 } else if (Dst.isGlobalObjCRef()) {
855 CGM.getObjCRuntime().EmitObjCGlobalAssign(*this, src, LvalueDst,
856 Dst.isThreadLocalRef());
857 }
Fariborz Jahanianbf63b872009-05-04 23:27:20 +0000858 else
859 CGM.getObjCRuntime().EmitObjCStrongCastAssign(*this, src, LvalueDst);
Fariborz Jahaniandbd32c22008-11-19 17:34:06 +0000860 return;
861 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000862
Chris Lattner883f6a72007-08-11 00:04:45 +0000863 assert(Src.isScalar() && "Can't emit an agg store with this method");
Anders Carlssonb4aa4662009-05-19 18:50:41 +0000864 EmitStoreOfScalar(Src.getScalarVal(), Dst.getAddress(),
Dan Gohman3d5aff52010-10-14 23:06:10 +0000865 Dst.isVolatileQualified(), Dst.getAlignment(), Ty,
866 Dst.getTBAAInfo());
Reid Spencer5f016e22007-07-11 17:01:13 +0000867}
868
Lauro Ramos Venancioa0c5d0e2008-01-22 22:36:45 +0000869void CodeGenFunction::EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst,
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000870 QualType Ty,
Daniel Dunbared3849b2008-11-19 09:36:46 +0000871 llvm::Value **Result) {
Daniel Dunbarefbf4872010-04-06 01:07:44 +0000872 const CGBitFieldInfo &Info = Dst.getBitFieldInfo();
Lauro Ramos Venancioa0c5d0e2008-01-22 22:36:45 +0000873
Daniel Dunbar26772612010-04-15 03:47:33 +0000874 // Get the output type.
Anders Carlsson48035352010-04-17 21:52:22 +0000875 const llvm::Type *ResLTy = ConvertTypeForMem(Ty);
Daniel Dunbar26772612010-04-15 03:47:33 +0000876 unsigned ResSizeInBits = CGM.getTargetData().getTypeSizeInBits(ResLTy);
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000877
Daniel Dunbar26772612010-04-15 03:47:33 +0000878 // Get the source value, truncated to the width of the bit-field.
Daniel Dunbared3849b2008-11-19 09:36:46 +0000879 llvm::Value *SrcVal = Src.getScalarVal();
Anders Carlsson48035352010-04-17 21:52:22 +0000880
881 if (Ty->isBooleanType())
882 SrcVal = Builder.CreateIntCast(SrcVal, ResLTy, /*IsSigned=*/false);
883
Daniel Dunbar26772612010-04-15 03:47:33 +0000884 SrcVal = Builder.CreateAnd(SrcVal, llvm::APInt::getLowBitsSet(ResSizeInBits,
885 Info.getSize()),
886 "bf.value");
Lauro Ramos Venancioa0c5d0e2008-01-22 22:36:45 +0000887
Daniel Dunbared3849b2008-11-19 09:36:46 +0000888 // Return the new value of the bit-field, if requested.
889 if (Result) {
890 // Cast back to the proper type for result.
Daniel Dunbar26772612010-04-15 03:47:33 +0000891 const llvm::Type *SrcTy = Src.getScalarVal()->getType();
892 llvm::Value *ReloadVal = Builder.CreateIntCast(SrcVal, SrcTy, false,
893 "bf.reload.val");
Daniel Dunbared3849b2008-11-19 09:36:46 +0000894
895 // Sign extend if necessary.
Daniel Dunbar26772612010-04-15 03:47:33 +0000896 if (Info.isSigned()) {
897 unsigned ExtraBits = ResSizeInBits - Info.getSize();
898 if (ExtraBits)
899 ReloadVal = Builder.CreateAShr(Builder.CreateShl(ReloadVal, ExtraBits),
900 ExtraBits, "bf.reload.sext");
Daniel Dunbared3849b2008-11-19 09:36:46 +0000901 }
902
Daniel Dunbar26772612010-04-15 03:47:33 +0000903 *Result = ReloadVal;
Daniel Dunbared3849b2008-11-19 09:36:46 +0000904 }
905
Daniel Dunbar26772612010-04-15 03:47:33 +0000906 // Iterate over the components, writing each piece to memory.
907 for (unsigned i = 0, e = Info.getNumComponents(); i != e; ++i) {
908 const CGBitFieldInfo::AccessInfo &AI = Info.getComponent(i);
Eli Friedman316bb1b2008-05-17 20:03:47 +0000909
Daniel Dunbar26772612010-04-15 03:47:33 +0000910 // Get the field pointer.
911 llvm::Value *Ptr = Dst.getBitFieldBaseAddr();
John McCalld16c2cf2011-02-08 08:22:06 +0000912 unsigned addressSpace =
913 cast<llvm::PointerType>(Ptr->getType())->getAddressSpace();
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000914
Daniel Dunbar26772612010-04-15 03:47:33 +0000915 // Only offset by the field index if used, so that incoming values are not
916 // required to be structures.
917 if (AI.FieldIndex)
918 Ptr = Builder.CreateStructGEP(Ptr, AI.FieldIndex, "bf.field");
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000919
Daniel Dunbar26772612010-04-15 03:47:33 +0000920 // Offset by the byte offset, if used.
921 if (AI.FieldByteOffset) {
John McCalld16c2cf2011-02-08 08:22:06 +0000922 Ptr = EmitCastToVoidPtr(Ptr);
Daniel Dunbar26772612010-04-15 03:47:33 +0000923 Ptr = Builder.CreateConstGEP1_32(Ptr, AI.FieldByteOffset,"bf.field.offs");
924 }
Eli Friedman316bb1b2008-05-17 20:03:47 +0000925
Daniel Dunbar26772612010-04-15 03:47:33 +0000926 // Cast to the access type.
John McCalld16c2cf2011-02-08 08:22:06 +0000927 const llvm::Type *AccessLTy =
928 llvm::Type::getIntNTy(getLLVMContext(), AI.AccessWidth);
929
930 const llvm::Type *PTy = AccessLTy->getPointerTo(addressSpace);
Daniel Dunbar26772612010-04-15 03:47:33 +0000931 Ptr = Builder.CreateBitCast(Ptr, PTy);
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000932
Daniel Dunbar26772612010-04-15 03:47:33 +0000933 // Extract the piece of the bit-field value to write in this access, limited
934 // to the values that are part of this access.
935 llvm::Value *Val = SrcVal;
936 if (AI.TargetBitOffset)
937 Val = Builder.CreateLShr(Val, AI.TargetBitOffset);
938 Val = Builder.CreateAnd(Val, llvm::APInt::getLowBitsSet(ResSizeInBits,
939 AI.TargetBitWidth));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000940
Daniel Dunbar26772612010-04-15 03:47:33 +0000941 // Extend or truncate to the access size.
Daniel Dunbar26772612010-04-15 03:47:33 +0000942 if (ResSizeInBits < AI.AccessWidth)
943 Val = Builder.CreateZExt(Val, AccessLTy);
944 else if (ResSizeInBits > AI.AccessWidth)
945 Val = Builder.CreateTrunc(Val, AccessLTy);
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000946
Daniel Dunbar26772612010-04-15 03:47:33 +0000947 // Shift into the position in memory.
948 if (AI.FieldBitStart)
949 Val = Builder.CreateShl(Val, AI.FieldBitStart);
950
951 // If necessary, load and OR in bits that are outside of the bit-field.
952 if (AI.TargetBitWidth != AI.AccessWidth) {
953 llvm::LoadInst *Load = Builder.CreateLoad(Ptr, Dst.isVolatileQualified());
954 if (AI.AccessAlignment)
955 Load->setAlignment(AI.AccessAlignment);
956
957 // Compute the mask for zeroing the bits that are part of the bit-field.
958 llvm::APInt InvMask =
959 ~llvm::APInt::getBitsSet(AI.AccessWidth, AI.FieldBitStart,
960 AI.FieldBitStart + AI.TargetBitWidth);
961
962 // Apply the mask and OR in to the value to write.
963 Val = Builder.CreateOr(Builder.CreateAnd(Load, InvMask), Val);
964 }
965
966 // Write the value.
967 llvm::StoreInst *Store = Builder.CreateStore(Val, Ptr,
968 Dst.isVolatileQualified());
969 if (AI.AccessAlignment)
970 Store->setAlignment(AI.AccessAlignment);
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000971 }
Lauro Ramos Venancioa0c5d0e2008-01-22 22:36:45 +0000972}
973
Nate Begeman213541a2008-04-18 23:10:10 +0000974void CodeGenFunction::EmitStoreThroughExtVectorComponentLValue(RValue Src,
975 LValue Dst,
976 QualType Ty) {
Chris Lattner017d6aa2007-08-03 16:28:33 +0000977 // This access turns into a read/modify/write of the vector. Load the input
978 // value now.
Eli Friedman1e692ac2008-06-13 23:01:12 +0000979 llvm::Value *Vec = Builder.CreateLoad(Dst.getExtVectorAddr(),
980 Dst.isVolatileQualified(), "tmp");
Nate Begeman8a997642008-05-09 06:41:27 +0000981 const llvm::Constant *Elts = Dst.getExtVectorElts();
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000982
Chris Lattner9b655512007-08-31 22:49:20 +0000983 llvm::Value *SrcVal = Src.getScalarVal();
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000984
John McCall183700f2009-09-21 23:43:11 +0000985 if (const VectorType *VTy = Ty->getAs<VectorType>()) {
Chris Lattner7e6b51b2007-08-03 16:37:04 +0000986 unsigned NumSrcElts = VTy->getNumElements();
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000987 unsigned NumDstElts =
988 cast<llvm::VectorType>(Vec->getType())->getNumElements();
989 if (NumDstElts == NumSrcElts) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000990 // Use shuffle vector is the src and destination are the same number of
991 // elements and restore the vector mask since it is on the side it will be
992 // stored.
Nate Begeman6e5dd862009-06-26 21:12:50 +0000993 llvm::SmallVector<llvm::Constant*, 4> Mask(NumDstElts);
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000994 for (unsigned i = 0; i != NumSrcElts; ++i) {
995 unsigned InIdx = getAccessedFieldNo(i, Elts);
Chris Lattner77b89b82010-06-27 07:15:29 +0000996 Mask[InIdx] = llvm::ConstantInt::get(Int32Ty, i);
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000997 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000998
Chris Lattnerfb018d12011-02-15 00:14:06 +0000999 llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
Nate Begeman6fe7c8a2009-01-18 06:42:49 +00001000 Vec = Builder.CreateShuffleVector(SrcVal,
Owen Anderson03e20502009-07-30 23:11:26 +00001001 llvm::UndefValue::get(Vec->getType()),
Nate Begeman6fe7c8a2009-01-18 06:42:49 +00001002 MaskV, "tmp");
Mike Stumpb3589f42009-07-30 22:28:39 +00001003 } else if (NumDstElts > NumSrcElts) {
Nate Begeman6fe7c8a2009-01-18 06:42:49 +00001004 // Extended the source vector to the same length and then shuffle it
1005 // into the destination.
1006 // FIXME: since we're shuffling with undef, can we just use the indices
1007 // into that? This could be simpler.
1008 llvm::SmallVector<llvm::Constant*, 4> ExtMask;
1009 unsigned i;
1010 for (i = 0; i != NumSrcElts; ++i)
Chris Lattnereb99b012009-10-28 17:39:19 +00001011 ExtMask.push_back(llvm::ConstantInt::get(Int32Ty, i));
Nate Begeman6fe7c8a2009-01-18 06:42:49 +00001012 for (; i != NumDstElts; ++i)
Chris Lattnereb99b012009-10-28 17:39:19 +00001013 ExtMask.push_back(llvm::UndefValue::get(Int32Ty));
Chris Lattnerfb018d12011-02-15 00:14:06 +00001014 llvm::Value *ExtMaskV = llvm::ConstantVector::get(ExtMask);
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001015 llvm::Value *ExtSrcVal =
Daniel Dunbarbb767732009-02-17 18:31:04 +00001016 Builder.CreateShuffleVector(SrcVal,
Owen Anderson03e20502009-07-30 23:11:26 +00001017 llvm::UndefValue::get(SrcVal->getType()),
Daniel Dunbarbb767732009-02-17 18:31:04 +00001018 ExtMaskV, "tmp");
Nate Begeman6fe7c8a2009-01-18 06:42:49 +00001019 // build identity
1020 llvm::SmallVector<llvm::Constant*, 4> Mask;
Chris Lattnereb99b012009-10-28 17:39:19 +00001021 for (unsigned i = 0; i != NumDstElts; ++i)
1022 Mask.push_back(llvm::ConstantInt::get(Int32Ty, i));
1023
Nate Begeman6fe7c8a2009-01-18 06:42:49 +00001024 // modify when what gets shuffled in
1025 for (unsigned i = 0; i != NumSrcElts; ++i) {
1026 unsigned Idx = getAccessedFieldNo(i, Elts);
Chris Lattnereb99b012009-10-28 17:39:19 +00001027 Mask[Idx] = llvm::ConstantInt::get(Int32Ty, i+NumDstElts);
Nate Begeman6fe7c8a2009-01-18 06:42:49 +00001028 }
Chris Lattnerfb018d12011-02-15 00:14:06 +00001029 llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
Nate Begeman6fe7c8a2009-01-18 06:42:49 +00001030 Vec = Builder.CreateShuffleVector(Vec, ExtSrcVal, MaskV, "tmp");
Mike Stumpb3589f42009-07-30 22:28:39 +00001031 } else {
Nate Begeman6fe7c8a2009-01-18 06:42:49 +00001032 // We should never shorten the vector
1033 assert(0 && "unexpected shorten vector length");
Chris Lattner7e6b51b2007-08-03 16:37:04 +00001034 }
1035 } else {
1036 // If the Src is a scalar (not a vector) it must be updating one element.
Dan Gohman4f8d1232008-05-22 00:50:06 +00001037 unsigned InIdx = getAccessedFieldNo(0, Elts);
Chris Lattnereb99b012009-10-28 17:39:19 +00001038 llvm::Value *Elt = llvm::ConstantInt::get(Int32Ty, InIdx);
Chris Lattner017d6aa2007-08-03 16:28:33 +00001039 Vec = Builder.CreateInsertElement(Vec, SrcVal, Elt, "tmp");
Chris Lattner017d6aa2007-08-03 16:28:33 +00001040 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001041
Eli Friedman1e692ac2008-06-13 23:01:12 +00001042 Builder.CreateStore(Vec, Dst.getExtVectorAddr(), Dst.isVolatileQualified());
Chris Lattner017d6aa2007-08-03 16:28:33 +00001043}
1044
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001045// setObjCGCLValueClass - sets class of he lvalue for the purpose of
1046// generating write-barries API. It is currently a global, ivar,
1047// or neither.
Chris Lattnereb99b012009-10-28 17:39:19 +00001048static void setObjCGCLValueClass(const ASTContext &Ctx, const Expr *E,
1049 LValue &LV) {
Fariborz Jahanianb9242592009-09-21 23:03:37 +00001050 if (Ctx.getLangOptions().getGCMode() == LangOptions::NonGC)
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001051 return;
1052
Fariborz Jahaniandbf3cfd2009-09-16 23:11:23 +00001053 if (isa<ObjCIvarRefExpr>(E)) {
Daniel Dunbar3491b3d2010-08-21 03:51:29 +00001054 LV.setObjCIvar(true);
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +00001055 ObjCIvarRefExpr *Exp = cast<ObjCIvarRefExpr>(const_cast<Expr*>(E));
1056 LV.setBaseIvarExp(Exp->getBase());
Daniel Dunbar3491b3d2010-08-21 03:51:29 +00001057 LV.setObjCArray(E->getType()->isArrayType());
Fariborz Jahaniandbf3cfd2009-09-16 23:11:23 +00001058 return;
1059 }
Chris Lattnereb99b012009-10-28 17:39:19 +00001060
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001061 if (const DeclRefExpr *Exp = dyn_cast<DeclRefExpr>(E)) {
1062 if (const VarDecl *VD = dyn_cast<VarDecl>(Exp->getDecl())) {
John McCallb6bbcc92010-10-15 04:57:14 +00001063 if (VD->hasGlobalStorage()) {
Daniel Dunbar3491b3d2010-08-21 03:51:29 +00001064 LV.setGlobalObjCRef(true);
1065 LV.setThreadLocalRef(VD->isThreadSpecified());
Fariborz Jahanian021a7a62010-07-20 20:30:03 +00001066 }
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001067 }
Daniel Dunbar3491b3d2010-08-21 03:51:29 +00001068 LV.setObjCArray(E->getType()->isArrayType());
Chris Lattnereb99b012009-10-28 17:39:19 +00001069 return;
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001070 }
Chris Lattnereb99b012009-10-28 17:39:19 +00001071
1072 if (const UnaryOperator *Exp = dyn_cast<UnaryOperator>(E)) {
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001073 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV);
Chris Lattnereb99b012009-10-28 17:39:19 +00001074 return;
1075 }
1076
1077 if (const ParenExpr *Exp = dyn_cast<ParenExpr>(E)) {
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001078 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV);
Fariborz Jahanian75b08f12009-09-30 17:10:29 +00001079 if (LV.isObjCIvar()) {
1080 // If cast is to a structure pointer, follow gcc's behavior and make it
1081 // a non-ivar write-barrier.
1082 QualType ExpTy = E->getType();
1083 if (ExpTy->isPointerType())
1084 ExpTy = ExpTy->getAs<PointerType>()->getPointeeType();
1085 if (ExpTy->isRecordType())
Daniel Dunbar3491b3d2010-08-21 03:51:29 +00001086 LV.setObjCIvar(false);
Chris Lattnereb99b012009-10-28 17:39:19 +00001087 }
1088 return;
Fariborz Jahanian75b08f12009-09-30 17:10:29 +00001089 }
Chris Lattnereb99b012009-10-28 17:39:19 +00001090 if (const ImplicitCastExpr *Exp = dyn_cast<ImplicitCastExpr>(E)) {
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001091 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV);
Chris Lattnereb99b012009-10-28 17:39:19 +00001092 return;
1093 }
1094
1095 if (const CStyleCastExpr *Exp = dyn_cast<CStyleCastExpr>(E)) {
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001096 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV);
Chris Lattnereb99b012009-10-28 17:39:19 +00001097 return;
1098 }
1099
1100 if (const ArraySubscriptExpr *Exp = dyn_cast<ArraySubscriptExpr>(E)) {
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001101 setObjCGCLValueClass(Ctx, Exp->getBase(), LV);
Fariborz Jahanianfd02ed72009-09-21 18:54:29 +00001102 if (LV.isObjCIvar() && !LV.isObjCArray())
Fariborz Jahanian1c1afc42009-09-18 00:04:00 +00001103 // Using array syntax to assigning to what an ivar points to is not
1104 // same as assigning to the ivar itself. {id *Names;} Names[i] = 0;
Daniel Dunbar3491b3d2010-08-21 03:51:29 +00001105 LV.setObjCIvar(false);
Fariborz Jahanianfd02ed72009-09-21 18:54:29 +00001106 else if (LV.isGlobalObjCRef() && !LV.isObjCArray())
1107 // Using array syntax to assigning to what global points to is not
1108 // same as assigning to the global itself. {id *G;} G[i] = 0;
Daniel Dunbar3491b3d2010-08-21 03:51:29 +00001109 LV.setGlobalObjCRef(false);
Chris Lattnereb99b012009-10-28 17:39:19 +00001110 return;
Fariborz Jahanian1c1afc42009-09-18 00:04:00 +00001111 }
Chris Lattnereb99b012009-10-28 17:39:19 +00001112
1113 if (const MemberExpr *Exp = dyn_cast<MemberExpr>(E)) {
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001114 setObjCGCLValueClass(Ctx, Exp->getBase(), LV);
Fariborz Jahanian1c1afc42009-09-18 00:04:00 +00001115 // We don't know if member is an 'ivar', but this flag is looked at
1116 // only in the context of LV.isObjCIvar().
Daniel Dunbar3491b3d2010-08-21 03:51:29 +00001117 LV.setObjCArray(E->getType()->isArrayType());
Chris Lattnereb99b012009-10-28 17:39:19 +00001118 return;
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001119 }
1120}
1121
Anders Carlssonce53f7d2009-11-07 23:06:58 +00001122static LValue EmitGlobalVarDeclLValue(CodeGenFunction &CGF,
1123 const Expr *E, const VarDecl *VD) {
Daniel Dunbard2113f22009-11-08 09:46:46 +00001124 assert((VD->hasExternalStorage() || VD->isFileVarDecl()) &&
Anders Carlssonce53f7d2009-11-07 23:06:58 +00001125 "Var decl must have external storage or be a file var decl!");
1126
1127 llvm::Value *V = CGF.CGM.GetAddrOfGlobalVar(VD);
1128 if (VD->getType()->isReferenceType())
1129 V = CGF.Builder.CreateLoad(V, "tmp");
Daniel Dunbar983e3d72010-08-21 04:20:22 +00001130 unsigned Alignment = CGF.getContext().getDeclAlign(VD).getQuantity();
1131 LValue LV = CGF.MakeAddrLValue(V, E->getType(), Alignment);
Anders Carlssonce53f7d2009-11-07 23:06:58 +00001132 setObjCGCLValueClass(CGF.getContext(), E, LV);
1133 return LV;
1134}
1135
Eli Friedman9a146302009-11-26 06:08:14 +00001136static LValue EmitFunctionDeclLValue(CodeGenFunction &CGF,
1137 const Expr *E, const FunctionDecl *FD) {
Chris Lattnerd0db03a2010-09-06 00:11:41 +00001138 llvm::Value *V = CGF.CGM.GetAddrOfFunction(FD);
Eli Friedman9a146302009-11-26 06:08:14 +00001139 if (!FD->hasPrototype()) {
1140 if (const FunctionProtoType *Proto =
1141 FD->getType()->getAs<FunctionProtoType>()) {
1142 // Ugly case: for a K&R-style definition, the type of the definition
1143 // isn't the same as the type of a use. Correct for this with a
1144 // bitcast.
1145 QualType NoProtoType =
1146 CGF.getContext().getFunctionNoProtoType(Proto->getResultType());
1147 NoProtoType = CGF.getContext().getPointerType(NoProtoType);
1148 V = CGF.Builder.CreateBitCast(V, CGF.ConvertType(NoProtoType), "tmp");
1149 }
1150 }
Daniel Dunbar983e3d72010-08-21 04:20:22 +00001151 unsigned Alignment = CGF.getContext().getDeclAlign(FD).getQuantity();
1152 return CGF.MakeAddrLValue(V, E->getType(), Alignment);
Eli Friedman9a146302009-11-26 06:08:14 +00001153}
1154
Reid Spencer5f016e22007-07-11 17:01:13 +00001155LValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) {
Anders Carlsson1e74c4f2009-11-07 22:53:10 +00001156 const NamedDecl *ND = E->getDecl();
John McCalld16c2cf2011-02-08 08:22:06 +00001157 unsigned Alignment = getContext().getDeclAlign(ND).getQuantity();
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001158
Rafael Espindola6a836702010-03-04 18:17:24 +00001159 if (ND->hasAttr<WeakRefAttr>()) {
Chris Lattnerd0db03a2010-09-06 00:11:41 +00001160 const ValueDecl *VD = cast<ValueDecl>(ND);
Rafael Espindola6a836702010-03-04 18:17:24 +00001161 llvm::Constant *Aliasee = CGM.GetWeakRefReference(VD);
Daniel Dunbar983e3d72010-08-21 04:20:22 +00001162 return MakeAddrLValue(Aliasee, E->getType(), Alignment);
Rafael Espindola6a836702010-03-04 18:17:24 +00001163 }
1164
Anders Carlsson1e74c4f2009-11-07 22:53:10 +00001165 if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) {
Anders Carlsson1e74c4f2009-11-07 22:53:10 +00001166
1167 // Check if this is a global variable.
Anders Carlssonce53f7d2009-11-07 23:06:58 +00001168 if (VD->hasExternalStorage() || VD->isFileVarDecl())
1169 return EmitGlobalVarDeclLValue(*this, E, VD);
Anders Carlsson0bc70492009-11-07 22:46:42 +00001170
Fariborz Jahanian75f91d62010-11-19 18:17:09 +00001171 bool NonGCable = VD->hasLocalStorage() &&
1172 !VD->getType()->isReferenceType() &&
1173 !VD->hasAttr<BlocksAttr>();
Anders Carlsson0bc70492009-11-07 22:46:42 +00001174
1175 llvm::Value *V = LocalDeclMap[VD];
Fariborz Jahanian09349142010-09-07 23:26:17 +00001176 if (!V && VD->isStaticLocal())
Fariborz Jahanian63326a52010-04-19 18:15:02 +00001177 V = CGM.getStaticLocalDeclAddress(VD);
Anders Carlsson0bc70492009-11-07 22:46:42 +00001178 assert(V && "DeclRefExpr not entered in LocalDeclMap?");
1179
Fariborz Jahanian52a80e12011-01-26 23:08:27 +00001180 if (VD->hasAttr<BlocksAttr>())
1181 V = BuildBlockByrefAddress(V, VD);
1182
Anders Carlsson0bc70492009-11-07 22:46:42 +00001183 if (VD->getType()->isReferenceType())
1184 V = Builder.CreateLoad(V, "tmp");
Daniel Dunbar6d5eb762010-08-21 03:44:13 +00001185
Daniel Dunbar983e3d72010-08-21 04:20:22 +00001186 LValue LV = MakeAddrLValue(V, E->getType(), Alignment);
Fariborz Jahanian75f91d62010-11-19 18:17:09 +00001187 if (NonGCable) {
Daniel Dunbar6d5eb762010-08-21 03:44:13 +00001188 LV.getQuals().removeObjCGCAttr();
Daniel Dunbarea619172010-08-21 03:22:38 +00001189 LV.setNonGC(true);
1190 }
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001191 setObjCGCLValueClass(getContext(), E, LV);
Fariborz Jahanian2682d8b2008-11-20 00:15:42 +00001192 return LV;
Chris Lattnereb99b012009-10-28 17:39:19 +00001193 }
John McCall5808ce42011-02-03 08:15:49 +00001194
1195 if (const FunctionDecl *fn = dyn_cast<FunctionDecl>(ND))
1196 return EmitFunctionDeclLValue(*this, E, fn);
1197
Anders Carlsson1e74c4f2009-11-07 22:53:10 +00001198 assert(false && "Unhandled DeclRefExpr");
1199
1200 // an invalid LValue, but the assert will
1201 // ensure that this point is never reached.
Chris Lattnerb1776cb2007-09-16 19:23:47 +00001202 return LValue();
Reid Spencer5f016e22007-07-11 17:01:13 +00001203}
1204
Mike Stumpa99038c2009-02-28 09:07:16 +00001205LValue CodeGenFunction::EmitBlockDeclRefLValue(const BlockDeclRefExpr *E) {
Daniel Dunbar983e3d72010-08-21 04:20:22 +00001206 unsigned Alignment =
John McCalld16c2cf2011-02-08 08:22:06 +00001207 getContext().getDeclAlign(E->getDecl()).getQuantity();
Daniel Dunbar983e3d72010-08-21 04:20:22 +00001208 return MakeAddrLValue(GetAddrOfBlockDecl(E), E->getType(), Alignment);
Mike Stumpa99038c2009-02-28 09:07:16 +00001209}
1210
Reid Spencer5f016e22007-07-11 17:01:13 +00001211LValue CodeGenFunction::EmitUnaryOpLValue(const UnaryOperator *E) {
1212 // __extension__ doesn't affect lvalue-ness.
John McCall2de56d12010-08-25 11:45:40 +00001213 if (E->getOpcode() == UO_Extension)
Reid Spencer5f016e22007-07-11 17:01:13 +00001214 return EmitLValue(E->getSubExpr());
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001215
Chris Lattner96196622008-07-26 22:37:01 +00001216 QualType ExprTy = getContext().getCanonicalType(E->getSubExpr()->getType());
Chris Lattner7da36f62007-10-30 22:53:42 +00001217 switch (E->getOpcode()) {
1218 default: assert(0 && "Unknown unary operator lvalue!");
John McCall2de56d12010-08-25 11:45:40 +00001219 case UO_Deref: {
Chris Lattnereb99b012009-10-28 17:39:19 +00001220 QualType T = E->getSubExpr()->getType()->getPointeeType();
1221 assert(!T.isNull() && "CodeGenFunction::EmitUnaryOpLValue: Illegal type");
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001222
Daniel Dunbar6d5eb762010-08-21 03:44:13 +00001223 LValue LV = MakeAddrLValue(EmitScalarExpr(E->getSubExpr()), T);
1224 LV.getQuals().setAddressSpace(ExprTy.getAddressSpace());
John McCall0953e762009-09-24 19:53:00 +00001225
Chris Lattnereb99b012009-10-28 17:39:19 +00001226 // We should not generate __weak write barrier on indirect reference
1227 // of a pointer to object; as in void foo (__weak id *param); *param = 0;
1228 // But, we continue to generate __strong write barrier on indirect write
1229 // into a pointer to object.
1230 if (getContext().getLangOptions().ObjC1 &&
1231 getContext().getLangOptions().getGCMode() != LangOptions::NonGC &&
1232 LV.isObjCWeak())
Daniel Dunbarea619172010-08-21 03:22:38 +00001233 LV.setNonGC(!E->isOBJCGCCandidate(getContext()));
Chris Lattnereb99b012009-10-28 17:39:19 +00001234 return LV;
1235 }
John McCall2de56d12010-08-25 11:45:40 +00001236 case UO_Real:
1237 case UO_Imag: {
Chris Lattner7da36f62007-10-30 22:53:42 +00001238 LValue LV = EmitLValue(E->getSubExpr());
John McCall2a416372010-12-05 02:00:02 +00001239 assert(LV.isSimple() && "real/imag on non-ordinary l-value");
1240 llvm::Value *Addr = LV.getAddress();
1241
1242 // real and imag are valid on scalars. This is a faster way of
1243 // testing that.
1244 if (!cast<llvm::PointerType>(Addr->getType())
1245 ->getElementType()->isStructTy()) {
1246 assert(E->getSubExpr()->getType()->isArithmeticType());
1247 return LV;
1248 }
1249
1250 assert(E->getSubExpr()->getType()->isAnyComplexType());
1251
John McCall2de56d12010-08-25 11:45:40 +00001252 unsigned Idx = E->getOpcode() == UO_Imag;
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001253 return MakeAddrLValue(Builder.CreateStructGEP(LV.getAddress(),
John McCall2a416372010-12-05 02:00:02 +00001254 Idx, "idx"),
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001255 ExprTy);
Chris Lattner7da36f62007-10-30 22:53:42 +00001256 }
John McCall2de56d12010-08-25 11:45:40 +00001257 case UO_PreInc:
1258 case UO_PreDec: {
Chris Lattner197a3382010-01-09 21:44:40 +00001259 LValue LV = EmitLValue(E->getSubExpr());
John McCall2de56d12010-08-25 11:45:40 +00001260 bool isInc = E->getOpcode() == UO_PreInc;
Chris Lattner197a3382010-01-09 21:44:40 +00001261
1262 if (E->getType()->isAnyComplexType())
1263 EmitComplexPrePostIncDec(E, LV, isInc, true/*isPre*/);
1264 else
1265 EmitScalarPrePostIncDec(E, LV, isInc, true/*isPre*/);
1266 return LV;
1267 }
Eli Friedmane401cd52009-11-09 04:20:47 +00001268 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001269}
1270
1271LValue CodeGenFunction::EmitStringLiteralLValue(const StringLiteral *E) {
Daniel Dunbar79c39282010-08-21 03:15:20 +00001272 return MakeAddrLValue(CGM.GetAddrOfConstantStringFromLiteral(E),
1273 E->getType());
Reid Spencer5f016e22007-07-11 17:01:13 +00001274}
1275
Chris Lattnereaf2bb82009-02-24 22:18:39 +00001276LValue CodeGenFunction::EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E) {
Daniel Dunbar79c39282010-08-21 03:15:20 +00001277 return MakeAddrLValue(CGM.GetAddrOfConstantStringFromObjCEncode(E),
1278 E->getType());
Chris Lattnereaf2bb82009-02-24 22:18:39 +00001279}
1280
1281
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001282LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) {
Daniel Dunbar662b71e2008-10-17 21:58:32 +00001283 switch (E->getIdentType()) {
1284 default:
1285 return EmitUnsupportedLValue(E, "predefined expression");
Daniel Dunbar3ec0baf2010-08-21 03:01:12 +00001286
Daniel Dunbar662b71e2008-10-17 21:58:32 +00001287 case PredefinedExpr::Func:
1288 case PredefinedExpr::Function:
Daniel Dunbar3ec0baf2010-08-21 03:01:12 +00001289 case PredefinedExpr::PrettyFunction: {
1290 unsigned Type = E->getIdentType();
1291 std::string GlobalVarName;
1292
1293 switch (Type) {
1294 default: assert(0 && "Invalid type");
1295 case PredefinedExpr::Func:
1296 GlobalVarName = "__func__.";
1297 break;
1298 case PredefinedExpr::Function:
1299 GlobalVarName = "__FUNCTION__.";
1300 break;
1301 case PredefinedExpr::PrettyFunction:
1302 GlobalVarName = "__PRETTY_FUNCTION__.";
1303 break;
1304 }
1305
1306 llvm::StringRef FnName = CurFn->getName();
1307 if (FnName.startswith("\01"))
1308 FnName = FnName.substr(1);
1309 GlobalVarName += FnName;
1310
1311 const Decl *CurDecl = CurCodeDecl;
1312 if (CurDecl == 0)
1313 CurDecl = getContext().getTranslationUnitDecl();
1314
1315 std::string FunctionName =
John McCall6b5a61b2011-02-07 10:33:21 +00001316 (isa<BlockDecl>(CurDecl)
1317 ? FnName.str()
1318 : PredefinedExpr::ComputeName((PredefinedExpr::IdentType)Type, CurDecl));
Daniel Dunbar3ec0baf2010-08-21 03:01:12 +00001319
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!");
John McCalld16c2cf2011-02-08 08:22:06 +00001384 Idx = Builder.CreateIntCast(Idx, 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
Chris Lattner9269d5c2010-06-26 23:03:20 +00001422 // The base must be a pointer, which is not an aggregate. Emit it.
1423 llvm::Value *Base = EmitScalarExpr(E->getBase());
John McCalld16c2cf2011-02-08 08:22:06 +00001424
1425 Address = EmitCastToVoidPtr(Base);
1426 Address = Builder.CreateInBoundsGEP(Address, Idx, "arrayidx");
Argyrios Kyrtzidis981b6fd2010-11-09 01:30:48 +00001427 Address = Builder.CreateBitCast(Address, Base->getType());
Chris Lattner9269d5c2010-06-26 23:03:20 +00001428 } else if (const ObjCObjectType *OIT = E->getType()->getAs<ObjCObjectType>()){
1429 // Indexing over an interface, as in "NSString *P; P[4];"
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001430 llvm::Value *InterfaceSize =
Owen Anderson4a28d5d2009-07-24 23:12:58 +00001431 llvm::ConstantInt::get(Idx->getType(),
Ken Dyck199c3d62010-01-11 17:06:35 +00001432 getContext().getTypeSizeInChars(OIT).getQuantity());
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001433
Daniel Dunbar2a866252009-04-25 05:08:32 +00001434 Idx = Builder.CreateMul(Idx, InterfaceSize);
1435
Chris Lattner9269d5c2010-06-26 23:03:20 +00001436 // The base must be a pointer, which is not an aggregate. Emit it.
1437 llvm::Value *Base = EmitScalarExpr(E->getBase());
John McCalld16c2cf2011-02-08 08:22:06 +00001438 Address = EmitCastToVoidPtr(Base);
1439 Address = Builder.CreateGEP(Address, Idx, "arrayidx");
Daniel Dunbar2a866252009-04-25 05:08:32 +00001440 Address = Builder.CreateBitCast(Address, Base->getType());
Chris Lattner9269d5c2010-06-26 23:03:20 +00001441 } else if (const Expr *Array = isSimpleArrayDecayOperand(E->getBase())) {
1442 // If this is A[i] where A is an array, the frontend will have decayed the
1443 // base to be a ArrayToPointerDecay implicit cast. While correct, it is
1444 // inefficient at -O0 to emit a "gep A, 0, 0" when codegen'ing it, then a
1445 // "gep x, i" here. Emit one "gep A, 0, i".
1446 assert(Array->getType()->isArrayType() &&
1447 "Array to pointer decay must have array source type!");
1448 llvm::Value *ArrayPtr = EmitLValue(Array).getAddress();
Chris Lattner9269d5c2010-06-26 23:03:20 +00001449 llvm::Value *Zero = llvm::ConstantInt::get(Int32Ty, 0);
1450 llvm::Value *Args[] = { Zero, Idx };
1451
1452 Address = Builder.CreateInBoundsGEP(ArrayPtr, Args, Args+2, "arrayidx");
Daniel Dunbar2a866252009-04-25 05:08:32 +00001453 } else {
Chris Lattner9269d5c2010-06-26 23:03:20 +00001454 // The base must be a pointer, which is not an aggregate. Emit it.
1455 llvm::Value *Base = EmitScalarExpr(E->getBase());
Dan Gohman664f8932009-08-12 00:33:55 +00001456 Address = Builder.CreateInBoundsGEP(Base, Idx, "arrayidx");
Anders Carlsson8b33c082008-12-21 00:11:23 +00001457 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001458
Steve Naroff14108da2009-07-10 23:34:53 +00001459 QualType T = E->getBase()->getType()->getPointeeType();
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001460 assert(!T.isNull() &&
Steve Naroff14108da2009-07-10 23:34:53 +00001461 "CodeGenFunction::EmitArraySubscriptExpr(): Illegal base type");
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001462
Daniel Dunbar6d5eb762010-08-21 03:44:13 +00001463 LValue LV = MakeAddrLValue(Address, T);
1464 LV.getQuals().setAddressSpace(E->getBase()->getType().getAddressSpace());
John McCall0953e762009-09-24 19:53:00 +00001465
Fariborz Jahanian643887a2009-02-21 23:37:19 +00001466 if (getContext().getLangOptions().ObjC1 &&
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001467 getContext().getLangOptions().getGCMode() != LangOptions::NonGC) {
Daniel Dunbarea619172010-08-21 03:22:38 +00001468 LV.setNonGC(!E->isOBJCGCCandidate(getContext()));
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001469 setObjCGCLValueClass(getContext(), E, LV);
1470 }
Fariborz Jahanian643887a2009-02-21 23:37:19 +00001471 return LV;
Reid Spencer5f016e22007-07-11 17:01:13 +00001472}
1473
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001474static
Owen Andersona1cf15f2009-07-14 23:10:40 +00001475llvm::Constant *GenerateConstantVector(llvm::LLVMContext &VMContext,
1476 llvm::SmallVector<unsigned, 4> &Elts) {
Chris Lattner998eab12009-12-23 21:31:11 +00001477 llvm::SmallVector<llvm::Constant*, 4> CElts;
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001478
Chris Lattner77b89b82010-06-27 07:15:29 +00001479 const llvm::Type *Int32Ty = llvm::Type::getInt32Ty(VMContext);
Nate Begeman3b8d1162008-05-13 21:03:02 +00001480 for (unsigned i = 0, e = Elts.size(); i != e; ++i)
Chris Lattner77b89b82010-06-27 07:15:29 +00001481 CElts.push_back(llvm::ConstantInt::get(Int32Ty, Elts[i]));
Nate Begeman3b8d1162008-05-13 21:03:02 +00001482
Chris Lattnerfb018d12011-02-15 00:14:06 +00001483 return llvm::ConstantVector::get(CElts);
Nate Begeman3b8d1162008-05-13 21:03:02 +00001484}
1485
Chris Lattner349aaec2007-08-02 23:37:31 +00001486LValue CodeGenFunction::
Nate Begeman213541a2008-04-18 23:10:10 +00001487EmitExtVectorElementExpr(const ExtVectorElementExpr *E) {
Chris Lattner349aaec2007-08-02 23:37:31 +00001488 // Emit the base vector as an l-value.
Chris Lattner73525de2009-02-16 21:11:58 +00001489 LValue Base;
1490
1491 // ExtVectorElementExpr's base can either be a vector or pointer to vector.
Chris Lattner998eab12009-12-23 21:31:11 +00001492 if (E->isArrow()) {
1493 // If it is a pointer to a vector, emit the address and form an lvalue with
1494 // it.
Chris Lattner2140e902009-02-16 22:14:05 +00001495 llvm::Value *Ptr = EmitScalarExpr(E->getBase());
Chris Lattner998eab12009-12-23 21:31:11 +00001496 const PointerType *PT = E->getBase()->getType()->getAs<PointerType>();
Daniel Dunbar6d5eb762010-08-21 03:44:13 +00001497 Base = MakeAddrLValue(Ptr, PT->getPointeeType());
1498 Base.getQuals().removeObjCGCAttr();
John McCall7eb0a9e2010-11-24 05:12:34 +00001499 } else if (E->getBase()->isGLValue()) {
Chris Lattner998eab12009-12-23 21:31:11 +00001500 // Otherwise, if the base is an lvalue ( as in the case of foo.x.x),
1501 // emit the base as an lvalue.
1502 assert(E->getBase()->getType()->isVectorType());
1503 Base = EmitLValue(E->getBase());
1504 } else {
1505 // Otherwise, the base is a normal rvalue (as in (V+V).x), emit it as such.
Daniel Dunbar302c3c22010-01-04 18:02:28 +00001506 assert(E->getBase()->getType()->getAs<VectorType>() &&
1507 "Result must be a vector");
Chris Lattner998eab12009-12-23 21:31:11 +00001508 llvm::Value *Vec = EmitScalarExpr(E->getBase());
1509
Chris Lattner0ad57fb2009-12-23 21:33:41 +00001510 // Store the vector to memory (because LValue wants an address).
Daniel Dunbar195337d2010-02-09 02:48:28 +00001511 llvm::Value *VecMem = CreateMemTemp(E->getBase()->getType());
Chris Lattner998eab12009-12-23 21:31:11 +00001512 Builder.CreateStore(Vec, VecMem);
Daniel Dunbar6d5eb762010-08-21 03:44:13 +00001513 Base = MakeAddrLValue(VecMem, E->getBase()->getType());
Chris Lattner998eab12009-12-23 21:31:11 +00001514 }
1515
Nate Begeman3b8d1162008-05-13 21:03:02 +00001516 // Encode the element access list into a vector of unsigned indices.
1517 llvm::SmallVector<unsigned, 4> Indices;
1518 E->getEncodedElementAccess(Indices);
1519
1520 if (Base.isSimple()) {
John McCalld16c2cf2011-02-08 08:22:06 +00001521 llvm::Constant *CV = GenerateConstantVector(getLLVMContext(), Indices);
Eli Friedman1e692ac2008-06-13 23:01:12 +00001522 return LValue::MakeExtVectorElt(Base.getAddress(), CV,
John McCall0953e762009-09-24 19:53:00 +00001523 Base.getVRQualifiers());
Nate Begeman3b8d1162008-05-13 21:03:02 +00001524 }
1525 assert(Base.isExtVectorElt() && "Can only subscript lvalue vec elts here!");
1526
1527 llvm::Constant *BaseElts = Base.getExtVectorElts();
1528 llvm::SmallVector<llvm::Constant *, 4> CElts;
1529
1530 for (unsigned i = 0, e = Indices.size(); i != e; ++i) {
1531 if (isa<llvm::ConstantAggregateZero>(BaseElts))
Chris Lattner67665862009-10-28 05:12:07 +00001532 CElts.push_back(llvm::ConstantInt::get(Int32Ty, 0));
Nate Begeman3b8d1162008-05-13 21:03:02 +00001533 else
Chris Lattner67665862009-10-28 05:12:07 +00001534 CElts.push_back(cast<llvm::Constant>(BaseElts->getOperand(Indices[i])));
Nate Begeman3b8d1162008-05-13 21:03:02 +00001535 }
Chris Lattnerfb018d12011-02-15 00:14:06 +00001536 llvm::Constant *CV = llvm::ConstantVector::get(CElts);
Eli Friedman1e692ac2008-06-13 23:01:12 +00001537 return LValue::MakeExtVectorElt(Base.getExtVectorAddr(), CV,
John McCall0953e762009-09-24 19:53:00 +00001538 Base.getVRQualifiers());
Chris Lattner349aaec2007-08-02 23:37:31 +00001539}
1540
Devang Patelb9b00ad2007-10-23 20:28:39 +00001541LValue CodeGenFunction::EmitMemberExpr(const MemberExpr *E) {
Fariborz Jahanian4f676ed2009-02-21 00:30:43 +00001542 bool isNonGC = false;
Devang Patel126a8562007-10-24 22:26:28 +00001543 Expr *BaseExpr = E->getBase();
Devang Patel126a8562007-10-24 22:26:28 +00001544 llvm::Value *BaseValue = NULL;
John McCall0953e762009-09-24 19:53:00 +00001545 Qualifiers BaseQuals;
Eli Friedman1e692ac2008-06-13 23:01:12 +00001546
Chris Lattner12f65f62007-12-02 18:52:07 +00001547 // 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 +00001548 if (E->isArrow()) {
Devang Patel0a961182007-10-26 18:15:21 +00001549 BaseValue = EmitScalarExpr(BaseExpr);
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001550 const PointerType *PTy =
Ted Kremenek6217b802009-07-29 21:53:49 +00001551 BaseExpr->getType()->getAs<PointerType>();
John McCall0953e762009-09-24 19:53:00 +00001552 BaseQuals = PTy->getPointeeType().getQualifiers();
Chris Lattner1bd885e2009-02-16 22:25:49 +00001553 } else {
Chris Lattner12f65f62007-12-02 18:52:07 +00001554 LValue BaseLV = EmitLValue(BaseExpr);
Fariborz Jahanian4f676ed2009-02-21 00:30:43 +00001555 if (BaseLV.isNonGC())
1556 isNonGC = true;
Chris Lattner12f65f62007-12-02 18:52:07 +00001557 // FIXME: this isn't right for bitfields.
1558 BaseValue = BaseLV.getAddress();
Fariborz Jahaniana91d6a62009-07-29 00:44:13 +00001559 QualType BaseTy = BaseExpr->getType();
John McCall0953e762009-09-24 19:53:00 +00001560 BaseQuals = BaseTy.getQualifiers();
Chris Lattner12f65f62007-12-02 18:52:07 +00001561 }
Devang Patelb9b00ad2007-10-23 20:28:39 +00001562
Anders Carlssonce53f7d2009-11-07 23:06:58 +00001563 NamedDecl *ND = E->getMemberDecl();
1564 if (FieldDecl *Field = dyn_cast<FieldDecl>(ND)) {
Anders Carlssone6d2a532010-01-29 05:05:36 +00001565 LValue LV = EmitLValueForField(BaseValue, Field,
Anders Carlssonce53f7d2009-11-07 23:06:58 +00001566 BaseQuals.getCVRQualifiers());
Daniel Dunbarea619172010-08-21 03:22:38 +00001567 LV.setNonGC(isNonGC);
Anders Carlssonce53f7d2009-11-07 23:06:58 +00001568 setObjCGCLValueClass(getContext(), E, LV);
1569 return LV;
1570 }
1571
Anders Carlsson589f9e32009-11-07 23:16:50 +00001572 if (VarDecl *VD = dyn_cast<VarDecl>(ND))
1573 return EmitGlobalVarDeclLValue(*this, E, VD);
Eli Friedman9a146302009-11-26 06:08:14 +00001574
1575 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND))
1576 return EmitFunctionDeclLValue(*this, E, FD);
1577
Anders Carlssonce53f7d2009-11-07 23:06:58 +00001578 assert(false && "Unhandled member declaration!");
1579 return LValue();
Eli Friedman472778e2008-02-09 08:50:58 +00001580}
Devang Patelb9b00ad2007-10-23 20:28:39 +00001581
Chris Lattnerd0db03a2010-09-06 00:11:41 +00001582LValue CodeGenFunction::EmitLValueForBitfield(llvm::Value *BaseValue,
1583 const FieldDecl *Field,
Fariborz Jahanian598d3f62009-02-03 19:03:09 +00001584 unsigned CVRQualifiers) {
Daniel Dunbar198bcb42010-03-31 01:09:11 +00001585 const CGRecordLayout &RL =
1586 CGM.getTypes().getCGRecordLayout(Field->getParent());
Daniel Dunbar2eec0b22010-04-05 16:20:44 +00001587 const CGBitFieldInfo &Info = RL.getBitFieldInfo(Field);
Daniel Dunbar7f289642010-04-08 02:59:45 +00001588 return LValue::MakeBitfield(BaseValue, Info,
Daniel Dunbarf0fe5bc2010-04-05 21:36:35 +00001589 Field->getType().getCVRQualifiers()|CVRQualifiers);
Fariborz Jahanianfd64bb62008-12-15 20:35:07 +00001590}
1591
John McCalla9976d32010-05-21 01:18:57 +00001592/// EmitLValueForAnonRecordField - Given that the field is a member of
1593/// an anonymous struct or union buried inside a record, and given
1594/// that the base value is a pointer to the enclosing record, derive
1595/// an lvalue for the ultimate field.
1596LValue CodeGenFunction::EmitLValueForAnonRecordField(llvm::Value *BaseValue,
Francois Pichet00eb3f92010-12-04 09:14:42 +00001597 const IndirectFieldDecl *Field,
John McCalla9976d32010-05-21 01:18:57 +00001598 unsigned CVRQualifiers) {
Francois Pichet00eb3f92010-12-04 09:14:42 +00001599 IndirectFieldDecl::chain_iterator I = Field->chain_begin(),
1600 IEnd = Field->chain_end();
John McCalla9976d32010-05-21 01:18:57 +00001601 while (true) {
Francois Pichet00eb3f92010-12-04 09:14:42 +00001602 LValue LV = EmitLValueForField(BaseValue, cast<FieldDecl>(*I), CVRQualifiers);
1603 if (++I == IEnd) return LV;
John McCalla9976d32010-05-21 01:18:57 +00001604
1605 assert(LV.isSimple());
1606 BaseValue = LV.getAddress();
1607 CVRQualifiers |= LV.getVRQualifiers();
1608 }
1609}
1610
Chris Lattnerd0db03a2010-09-06 00:11:41 +00001611LValue CodeGenFunction::EmitLValueForField(llvm::Value *BaseValue,
1612 const FieldDecl *Field,
Mike Stump1eb44332009-09-09 15:08:12 +00001613 unsigned CVRQualifiers) {
Fariborz Jahanianfd64bb62008-12-15 20:35:07 +00001614 if (Field->isBitField())
Fariborz Jahanian598d3f62009-02-03 19:03:09 +00001615 return EmitLValueForBitfield(BaseValue, Field, CVRQualifiers);
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001616
Daniel Dunbar198bcb42010-03-31 01:09:11 +00001617 const CGRecordLayout &RL =
1618 CGM.getTypes().getCGRecordLayout(Field->getParent());
1619 unsigned idx = RL.getLLVMFieldNo(Field);
Fariborz Jahanianfd64bb62008-12-15 20:35:07 +00001620 llvm::Value *V = Builder.CreateStructGEP(BaseValue, idx, "tmp");
Eli Friedman1e86b342008-05-29 11:33:25 +00001621
Devang Patelabad06c2007-10-26 19:42:18 +00001622 // Match union field type.
Anders Carlssone6d2a532010-01-29 05:05:36 +00001623 if (Field->getParent()->isUnion()) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001624 const llvm::Type *FieldTy =
Eli Friedman1e692ac2008-06-13 23:01:12 +00001625 CGM.getTypes().ConvertTypeForMem(Field->getType());
Chris Lattnerd0db03a2010-09-06 00:11:41 +00001626 const llvm::PointerType *BaseTy =
Devang Patele9b8c0a2007-10-30 20:59:40 +00001627 cast<llvm::PointerType>(BaseValue->getType());
Eli Friedman788d5712008-05-21 13:24:44 +00001628 unsigned AS = BaseTy->getAddressSpace();
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001629 V = Builder.CreateBitCast(V,
1630 llvm::PointerType::get(FieldTy, AS),
Eli Friedman788d5712008-05-21 13:24:44 +00001631 "tmp");
Devang Patelabad06c2007-10-26 19:42:18 +00001632 }
Eli Friedman2be58612009-05-30 21:09:44 +00001633 if (Field->getType()->isReferenceType())
1634 V = Builder.CreateLoad(V, "tmp");
John McCall0953e762009-09-24 19:53:00 +00001635
Daniel Dunbar983e3d72010-08-21 04:20:22 +00001636 unsigned Alignment = getContext().getDeclAlign(Field).getQuantity();
1637 LValue LV = MakeAddrLValue(V, Field->getType(), Alignment);
Daniel Dunbar6d5eb762010-08-21 03:44:13 +00001638 LV.getQuals().addCVRQualifiers(CVRQualifiers);
1639
Fariborz Jahanianfd02ed72009-09-21 18:54:29 +00001640 // __weak attribute on a field is ignored.
Daniel Dunbar6d5eb762010-08-21 03:44:13 +00001641 if (LV.getQuals().getObjCGCAttr() == Qualifiers::Weak)
1642 LV.getQuals().removeObjCGCAttr();
Fariborz Jahanianfd02ed72009-09-21 18:54:29 +00001643
Daniel Dunbar6d5eb762010-08-21 03:44:13 +00001644 return LV;
Devang Patelb9b00ad2007-10-23 20:28:39 +00001645}
1646
Anders Carlsson06a29702010-01-29 05:24:29 +00001647LValue
Chris Lattnerd0db03a2010-09-06 00:11:41 +00001648CodeGenFunction::EmitLValueForFieldInitialization(llvm::Value *BaseValue,
1649 const FieldDecl *Field,
Anders Carlsson06a29702010-01-29 05:24:29 +00001650 unsigned CVRQualifiers) {
1651 QualType FieldType = Field->getType();
1652
1653 if (!FieldType->isReferenceType())
1654 return EmitLValueForField(BaseValue, Field, CVRQualifiers);
1655
Daniel Dunbar198bcb42010-03-31 01:09:11 +00001656 const CGRecordLayout &RL =
1657 CGM.getTypes().getCGRecordLayout(Field->getParent());
1658 unsigned idx = RL.getLLVMFieldNo(Field);
Anders Carlsson06a29702010-01-29 05:24:29 +00001659 llvm::Value *V = Builder.CreateStructGEP(BaseValue, idx, "tmp");
1660
1661 assert(!FieldType.getObjCGCAttr() && "fields cannot have GC attrs");
1662
Daniel Dunbar983e3d72010-08-21 04:20:22 +00001663 unsigned Alignment = getContext().getDeclAlign(Field).getQuantity();
1664 return MakeAddrLValue(V, FieldType, Alignment);
Anders Carlsson06a29702010-01-29 05:24:29 +00001665}
1666
Chris Lattnerd0db03a2010-09-06 00:11:41 +00001667LValue CodeGenFunction::EmitCompoundLiteralLValue(const CompoundLiteralExpr *E){
Daniel Dunbar15006572010-02-16 19:43:39 +00001668 llvm::Value *DeclPtr = CreateMemTemp(E->getType(), ".compoundliteral");
Chris Lattnerd0db03a2010-09-06 00:11:41 +00001669 const Expr *InitExpr = E->getInitializer();
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001670 LValue Result = MakeAddrLValue(DeclPtr, E->getType());
Eli Friedman06e863f2008-05-13 23:18:27 +00001671
John McCall558d2ab2010-09-15 10:14:12 +00001672 EmitAnyExprToMem(InitExpr, DeclPtr, /*Volatile*/ false, /*Init*/ true);
Eli Friedman06e863f2008-05-13 23:18:27 +00001673
1674 return Result;
1675}
1676
Anders Carlsson6fcec8b2009-09-15 16:35:24 +00001677LValue
Chris Lattnerd0db03a2010-09-06 00:11:41 +00001678CodeGenFunction::EmitConditionalOperatorLValue(const ConditionalOperator *E) {
John McCallf99a3912011-01-26 19:21:13 +00001679 if (!E->isGLValue()) {
1680 // ?: here should be an aggregate.
1681 assert((hasAggregateLLVMType(E->getType()) &&
1682 !E->getType()->isAnyComplexType()) &&
1683 "Unexpected conditional operator!");
1684 return EmitAggExprToLValue(E);
Anders Carlsson6fcec8b2009-09-15 16:35:24 +00001685 }
Daniel Dunbar90345582009-03-24 02:38:23 +00001686
John McCallf99a3912011-01-26 19:21:13 +00001687 if (int Cond = ConstantFoldsToSimpleInteger(E->getCond())) {
1688 Expr *Live = Cond == 1 ? E->getLHS() : E->getRHS();
1689 if (Live)
1690 return EmitLValue(Live);
1691 }
1692
1693 llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true");
1694 llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false");
1695 llvm::BasicBlock *ContBlock = createBasicBlock("cond.end");
1696
1697 ConditionalEvaluation eval(*this);
1698
1699 if (E->getLHS())
1700 EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock);
1701 else {
1702 Expr *save = E->getSAVE();
1703 assert(save && "VisitConditionalOperator - save is null");
1704 // Intentianlly not doing direct assignment to ConditionalSaveExprs[save]
1705 LValue SaveVal = EmitLValue(save);
1706 ConditionalSaveLValueExprs[save] = SaveVal;
1707 EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock);
1708 }
1709
1710 // Any temporaries created here are conditional.
1711 EmitBlock(LHSBlock);
1712 eval.begin(*this);
1713 LValue LHS = EmitLValue(E->getTrueExpr());
1714 eval.end(*this);
1715
1716 if (!LHS.isSimple())
1717 return EmitUnsupportedLValue(E, "conditional operator");
1718
1719 LHSBlock = Builder.GetInsertBlock();
1720 Builder.CreateBr(ContBlock);
1721
1722 // Any temporaries created here are conditional.
1723 EmitBlock(RHSBlock);
1724 eval.begin(*this);
1725 LValue RHS = EmitLValue(E->getRHS());
1726 eval.end(*this);
1727 if (!RHS.isSimple())
1728 return EmitUnsupportedLValue(E, "conditional operator");
1729 RHSBlock = Builder.GetInsertBlock();
1730
1731 EmitBlock(ContBlock);
1732
1733 llvm::PHINode *phi = Builder.CreatePHI(LHS.getAddress()->getType(),
1734 "cond-lvalue");
1735 phi->reserveOperandSpace(2);
1736 phi->addIncoming(LHS.getAddress(), LHSBlock);
1737 phi->addIncoming(RHS.getAddress(), RHSBlock);
1738 return MakeAddrLValue(phi, E->getType());
Daniel Dunbar90345582009-03-24 02:38:23 +00001739}
1740
Mike Stumpc849c052009-11-16 06:50:58 +00001741/// EmitCastLValue - Casts are never lvalues unless that cast is a dynamic_cast.
1742/// If the cast is a dynamic_cast, we can have the usual lvalue result,
1743/// otherwise if a cast is needed by the code generator in an lvalue context,
1744/// then it must mean that we need the address of an aggregate in order to
1745/// access one of its fields. This can happen for all the reasons that casts
1746/// are permitted with aggregate result, including noop aggregate casts, and
1747/// cast from scalar to union.
Chris Lattner75dfeda2009-03-18 18:28:57 +00001748LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) {
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00001749 switch (E->getCastKind()) {
John McCall2de56d12010-08-25 11:45:40 +00001750 case CK_ToVoid:
Eli Friedmaneaae78a2009-11-16 05:48:01 +00001751 return EmitUnsupportedLValue(E, "unexpected cast lvalue");
John McCalldaa8e4e2010-11-15 09:13:47 +00001752
1753 case CK_Dependent:
1754 llvm_unreachable("dependent cast kind in IR gen!");
1755
John McCallf6a16482010-12-04 03:47:34 +00001756 case CK_GetObjCProperty: {
1757 LValue LV = EmitLValue(E->getSubExpr());
1758 assert(LV.isPropertyRef());
1759 RValue RV = EmitLoadOfPropertyRefLValue(LV);
1760
1761 // Property is an aggregate r-value.
1762 if (RV.isAggregate()) {
1763 return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
1764 }
1765
1766 // Implicit property returns an l-value.
1767 assert(RV.isScalar());
1768 return MakeAddrLValue(RV.getScalarVal(), E->getSubExpr()->getType());
1769 }
1770
John McCall2de56d12010-08-25 11:45:40 +00001771 case CK_NoOp:
Douglas Gregorb3d5e2f2011-01-27 23:22:05 +00001772 case CK_LValueToRValue:
1773 if (!E->getSubExpr()->Classify(getContext()).isPRValue()
1774 || E->getType()->isRecordType())
John McCall0e800c92010-12-04 08:14:53 +00001775 return EmitLValue(E->getSubExpr());
Douglas Gregor7c7a7932010-07-15 18:58:16 +00001776 // Fall through to synthesize a temporary.
John McCalldaa8e4e2010-11-15 09:13:47 +00001777
John McCall2de56d12010-08-25 11:45:40 +00001778 case CK_BitCast:
1779 case CK_ArrayToPointerDecay:
1780 case CK_FunctionToPointerDecay:
1781 case CK_NullToMemberPointer:
John McCall404cd162010-11-13 01:35:44 +00001782 case CK_NullToPointer:
John McCall2de56d12010-08-25 11:45:40 +00001783 case CK_IntegralToPointer:
1784 case CK_PointerToIntegral:
John McCalldaa8e4e2010-11-15 09:13:47 +00001785 case CK_PointerToBoolean:
John McCall2de56d12010-08-25 11:45:40 +00001786 case CK_VectorSplat:
1787 case CK_IntegralCast:
John McCalldaa8e4e2010-11-15 09:13:47 +00001788 case CK_IntegralToBoolean:
John McCall2de56d12010-08-25 11:45:40 +00001789 case CK_IntegralToFloating:
1790 case CK_FloatingToIntegral:
John McCalldaa8e4e2010-11-15 09:13:47 +00001791 case CK_FloatingToBoolean:
John McCall2de56d12010-08-25 11:45:40 +00001792 case CK_FloatingCast:
John McCall2bb5d002010-11-13 09:02:35 +00001793 case CK_FloatingRealToComplex:
John McCallf3ea8cf2010-11-14 08:17:51 +00001794 case CK_FloatingComplexToReal:
1795 case CK_FloatingComplexToBoolean:
John McCall2bb5d002010-11-13 09:02:35 +00001796 case CK_FloatingComplexCast:
John McCallf3ea8cf2010-11-14 08:17:51 +00001797 case CK_FloatingComplexToIntegralComplex:
John McCall2bb5d002010-11-13 09:02:35 +00001798 case CK_IntegralRealToComplex:
John McCallf3ea8cf2010-11-14 08:17:51 +00001799 case CK_IntegralComplexToReal:
1800 case CK_IntegralComplexToBoolean:
John McCall2bb5d002010-11-13 09:02:35 +00001801 case CK_IntegralComplexCast:
John McCallf3ea8cf2010-11-14 08:17:51 +00001802 case CK_IntegralComplexToFloatingComplex:
John McCall2de56d12010-08-25 11:45:40 +00001803 case CK_DerivedToBaseMemberPointer:
1804 case CK_BaseToDerivedMemberPointer:
1805 case CK_MemberPointerToBoolean:
1806 case CK_AnyPointerToBlockPointerCast: {
Douglas Gregor7c7a7932010-07-15 18:58:16 +00001807 // These casts only produce lvalues when we're binding a reference to a
1808 // temporary realized from a (converted) pure rvalue. Emit the expression
1809 // as a value, copy it into a temporary, and return an lvalue referring to
1810 // that temporary.
1811 llvm::Value *V = CreateMemTemp(E->getType(), "ref.temp");
1812 EmitAnyExprToMem(E, V, false, false);
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001813 return MakeAddrLValue(V, E->getType());
Douglas Gregor7c7a7932010-07-15 18:58:16 +00001814 }
Eli Friedmaneaae78a2009-11-16 05:48:01 +00001815
John McCall2de56d12010-08-25 11:45:40 +00001816 case CK_Dynamic: {
Mike Stumpc849c052009-11-16 06:50:58 +00001817 LValue LV = EmitLValue(E->getSubExpr());
1818 llvm::Value *V = LV.getAddress();
1819 const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(E);
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001820 return MakeAddrLValue(EmitDynamicCast(V, DCE), E->getType());
Mike Stumpc849c052009-11-16 06:50:58 +00001821 }
1822
John McCall2de56d12010-08-25 11:45:40 +00001823 case CK_ConstructorConversion:
1824 case CK_UserDefinedConversion:
1825 case CK_AnyPointerToObjCPointerCast:
Chris Lattner75dfeda2009-03-18 18:28:57 +00001826 return EmitLValue(E->getSubExpr());
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00001827
John McCall2de56d12010-08-25 11:45:40 +00001828 case CK_UncheckedDerivedToBase:
1829 case CK_DerivedToBase: {
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00001830 const RecordType *DerivedClassTy =
1831 E->getSubExpr()->getType()->getAs<RecordType>();
1832 CXXRecordDecl *DerivedClassDecl =
1833 cast<CXXRecordDecl>(DerivedClassTy->getDecl());
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00001834
1835 LValue LV = EmitLValue(E->getSubExpr());
John McCall0e800c92010-12-04 08:14:53 +00001836 llvm::Value *This = LV.getAddress();
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00001837
1838 // Perform the derived-to-base conversion
1839 llvm::Value *Base =
Fariborz Jahanian353b33b2010-06-17 23:00:29 +00001840 GetAddressOfBaseClass(This, DerivedClassDecl,
John McCallf871d0c2010-08-07 06:22:56 +00001841 E->path_begin(), E->path_end(),
1842 /*NullCheckValue=*/false);
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00001843
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001844 return MakeAddrLValue(Base, E->getType());
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00001845 }
John McCall2de56d12010-08-25 11:45:40 +00001846 case CK_ToUnion:
Daniel Dunbarb2cd7772010-02-05 20:02:42 +00001847 return EmitAggExprToLValue(E);
John McCall2de56d12010-08-25 11:45:40 +00001848 case CK_BaseToDerived: {
Anders Carlssona3697c92009-11-23 17:57:54 +00001849 const RecordType *DerivedClassTy = E->getType()->getAs<RecordType>();
1850 CXXRecordDecl *DerivedClassDecl =
1851 cast<CXXRecordDecl>(DerivedClassTy->getDecl());
1852
1853 LValue LV = EmitLValue(E->getSubExpr());
1854
1855 // Perform the base-to-derived conversion
1856 llvm::Value *Derived =
Anders Carlssona04efdf2010-04-24 21:23:59 +00001857 GetAddressOfDerivedClass(LV.getAddress(), DerivedClassDecl,
John McCallf871d0c2010-08-07 06:22:56 +00001858 E->path_begin(), E->path_end(),
1859 /*NullCheckValue=*/false);
Anders Carlssona3697c92009-11-23 17:57:54 +00001860
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001861 return MakeAddrLValue(Derived, E->getType());
Eli Friedmaneaae78a2009-11-16 05:48:01 +00001862 }
John McCall2de56d12010-08-25 11:45:40 +00001863 case CK_LValueBitCast: {
Eli Friedmaneaae78a2009-11-16 05:48:01 +00001864 // This must be a reinterpret_cast (or c-style equivalent).
1865 const ExplicitCastExpr *CE = cast<ExplicitCastExpr>(E);
Anders Carlsson658e8122009-11-14 21:21:42 +00001866
1867 LValue LV = EmitLValue(E->getSubExpr());
1868 llvm::Value *V = Builder.CreateBitCast(LV.getAddress(),
1869 ConvertType(CE->getTypeAsWritten()));
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001870 return MakeAddrLValue(V, E->getType());
Anders Carlsson658e8122009-11-14 21:21:42 +00001871 }
John McCall2de56d12010-08-25 11:45:40 +00001872 case CK_ObjCObjectLValueCast: {
Douglas Gregor569c3162010-08-07 11:51:51 +00001873 LValue LV = EmitLValue(E->getSubExpr());
1874 QualType ToType = getContext().getLValueReferenceType(E->getType());
1875 llvm::Value *V = Builder.CreateBitCast(LV.getAddress(),
1876 ConvertType(ToType));
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001877 return MakeAddrLValue(V, E->getType());
Douglas Gregor569c3162010-08-07 11:51:51 +00001878 }
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00001879 }
Douglas Gregor7c7a7932010-07-15 18:58:16 +00001880
1881 llvm_unreachable("Unhandled lvalue cast kind?");
Chris Lattner75dfeda2009-03-18 18:28:57 +00001882}
1883
Fariborz Jahanian48620ba2009-10-20 23:29:04 +00001884LValue CodeGenFunction::EmitNullInitializationLValue(
Douglas Gregored8abf12010-07-08 06:14:04 +00001885 const CXXScalarValueInitExpr *E) {
Fariborz Jahanian48620ba2009-10-20 23:29:04 +00001886 QualType Ty = E->getType();
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001887 LValue LV = MakeAddrLValue(CreateMemTemp(Ty), Ty);
Anders Carlsson1884eb02010-05-22 17:35:42 +00001888 EmitNullInitialization(LV.getAddress(), Ty);
Daniel Dunbar195337d2010-02-09 02:48:28 +00001889 return LV;
Fariborz Jahanian48620ba2009-10-20 23:29:04 +00001890}
1891
Reid Spencer5f016e22007-07-11 17:01:13 +00001892//===--------------------------------------------------------------------===//
1893// Expression Emission
1894//===--------------------------------------------------------------------===//
1895
Chris Lattner7016a702007-08-20 22:37:10 +00001896
Anders Carlssond2490a92009-12-24 20:40:36 +00001897RValue CodeGenFunction::EmitCallExpr(const CallExpr *E,
1898 ReturnValueSlot ReturnValue) {
Daniel Dunbarc0ef9f52009-02-20 18:06:48 +00001899 // Builtins never have block type.
Daniel Dunbarce1d38b2009-01-09 16:50:52 +00001900 if (E->getCallee()->getType()->isBlockPointerType())
Anders Carlssona1736c02009-12-24 21:13:40 +00001901 return EmitBlockCallExpr(E, ReturnValue);
Daniel Dunbarce1d38b2009-01-09 16:50:52 +00001902
Anders Carlsson774e7c62009-04-03 22:50:24 +00001903 if (const CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(E))
Anders Carlssona1736c02009-12-24 21:13:40 +00001904 return EmitCXXMemberCallExpr(CE, ReturnValue);
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001905
Daniel Dunbarc0ef9f52009-02-20 18:06:48 +00001906 const Decl *TargetDecl = 0;
Daniel Dunbardd7b8972009-02-20 19:34:33 +00001907 if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E->getCallee())) {
1908 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CE->getSubExpr())) {
1909 TargetDecl = DRE->getDecl();
1910 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(TargetDecl))
Douglas Gregor7814e6d2009-09-12 00:22:50 +00001911 if (unsigned builtinID = FD->getBuiltinID())
Daniel Dunbardd7b8972009-02-20 19:34:33 +00001912 return EmitBuiltinExpr(FD, builtinID, E);
Daniel Dunbarc0ef9f52009-02-20 18:06:48 +00001913 }
1914 }
1915
Chris Lattner5db7ae52009-06-13 00:26:38 +00001916 if (const CXXOperatorCallExpr *CE = dyn_cast<CXXOperatorCallExpr>(E))
Anders Carlsson0f294632009-05-27 04:18:27 +00001917 if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(TargetDecl))
Anders Carlssona1736c02009-12-24 21:13:40 +00001918 return EmitCXXOperatorMemberCallExpr(CE, MD, ReturnValue);
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001919
Eli Friedmanc4451db2009-12-08 02:09:46 +00001920 if (isa<CXXPseudoDestructorExpr>(E->getCallee()->IgnoreParens())) {
Douglas Gregora71d8192009-09-04 17:36:40 +00001921 // C++ [expr.pseudo]p1:
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001922 // The result shall only be used as the operand for the function call
Douglas Gregora71d8192009-09-04 17:36:40 +00001923 // operator (), and the result of such a call has type void. The only
1924 // effect is the evaluation of the postfix-expression before the dot or
1925 // arrow.
1926 EmitScalarExpr(E->getCallee());
1927 return RValue::get(0);
1928 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001929
Chris Lattner7f02f722007-08-24 05:35:26 +00001930 llvm::Value *Callee = EmitScalarExpr(E->getCallee());
Anders Carlssond2490a92009-12-24 20:40:36 +00001931 return EmitCall(E->getCallee()->getType(), Callee, ReturnValue,
Anders Carlsson98647712009-05-27 01:22:39 +00001932 E->arg_begin(), E->arg_end(), TargetDecl);
Chris Lattnerc5e940f2007-08-31 04:44:06 +00001933}
1934
Daniel Dunbar80e62c22008-09-04 03:20:13 +00001935LValue CodeGenFunction::EmitBinaryOperatorLValue(const BinaryOperator *E) {
Chris Lattner7a574cc2009-05-12 21:28:12 +00001936 // Comma expressions just emit their LHS then their RHS as an l-value.
John McCall2de56d12010-08-25 11:45:40 +00001937 if (E->getOpcode() == BO_Comma) {
John McCall2a416372010-12-05 02:00:02 +00001938 EmitIgnoredExpr(E->getLHS());
Eli Friedman130c69e2009-12-07 20:18:11 +00001939 EnsureInsertPoint();
Chris Lattner7a574cc2009-05-12 21:28:12 +00001940 return EmitLValue(E->getRHS());
1941 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001942
John McCall2de56d12010-08-25 11:45:40 +00001943 if (E->getOpcode() == BO_PtrMemD ||
1944 E->getOpcode() == BO_PtrMemI)
Fariborz Jahanian8bfd31f2009-10-22 22:57:31 +00001945 return EmitPointerToDataMemberBinaryExpr(E);
Daniel Dunbar80e62c22008-09-04 03:20:13 +00001946
John McCall2a416372010-12-05 02:00:02 +00001947 assert(E->getOpcode() == BO_Assign && "unexpected binary l-value");
John McCall83ce9d42010-11-16 23:07:28 +00001948
Anders Carlsson86aa0cd2009-10-19 18:28:22 +00001949 if (!hasAggregateLLVMType(E->getType())) {
John McCallcd940a12010-12-06 06:10:02 +00001950 // __block variables need the RHS evaluated first.
1951 RValue RV = EmitAnyExpr(E->getRHS());
Anders Carlsson86aa0cd2009-10-19 18:28:22 +00001952 LValue LV = EmitLValue(E->getLHS());
John McCallcd940a12010-12-06 06:10:02 +00001953 EmitStoreThroughLValue(RV, LV, E->getType());
Anders Carlsson86aa0cd2009-10-19 18:28:22 +00001954 return LV;
1955 }
John McCall83ce9d42010-11-16 23:07:28 +00001956
1957 if (E->getType()->isAnyComplexType())
1958 return EmitComplexAssignmentLValue(E);
1959
Daniel Dunbar18aba0d2010-02-05 19:38:31 +00001960 return EmitAggExprToLValue(E);
Daniel Dunbar80e62c22008-09-04 03:20:13 +00001961}
1962
Christopher Lamb22c940e2007-12-29 05:02:41 +00001963LValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) {
Christopher Lamb22c940e2007-12-29 05:02:41 +00001964 RValue RV = EmitCallExpr(E);
Anders Carlsson48265682009-05-27 01:45:47 +00001965
Chris Lattnereb99b012009-10-28 17:39:19 +00001966 if (!RV.isScalar())
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001967 return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
Chris Lattnereb99b012009-10-28 17:39:19 +00001968
1969 assert(E->getCallReturnType()->isReferenceType() &&
1970 "Can't have a scalar return unless the return type is a "
1971 "reference type!");
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001972
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001973 return MakeAddrLValue(RV.getScalarVal(), E->getType());
Christopher Lamb22c940e2007-12-29 05:02:41 +00001974}
1975
Daniel Dunbar5b5c9ef2009-02-11 20:59:32 +00001976LValue CodeGenFunction::EmitVAArgExprLValue(const VAArgExpr *E) {
1977 // FIXME: This shouldn't require another copy.
Daniel Dunbar18aba0d2010-02-05 19:38:31 +00001978 return EmitAggExprToLValue(E);
Daniel Dunbar5b5c9ef2009-02-11 20:59:32 +00001979}
1980
Anders Carlssonb58d0172009-05-30 23:23:33 +00001981LValue CodeGenFunction::EmitCXXConstructLValue(const CXXConstructExpr *E) {
John McCallfc1e6c72010-09-18 00:58:34 +00001982 assert(E->getType()->getAsCXXRecordDecl()->hasTrivialDestructor()
1983 && "binding l-value to type which needs a temporary");
John McCall558d2ab2010-09-15 10:14:12 +00001984 AggValueSlot Slot = CreateAggTemp(E->getType(), "tmp");
1985 EmitCXXConstructExpr(E, Slot);
1986 return MakeAddrLValue(Slot.getAddr(), E->getType());
Anders Carlssonb58d0172009-05-30 23:23:33 +00001987}
1988
Anders Carlssone61c9e82009-05-30 23:30:54 +00001989LValue
Mike Stumpc2e84ae2009-11-15 08:09:41 +00001990CodeGenFunction::EmitCXXTypeidLValue(const CXXTypeidExpr *E) {
Daniel Dunbar9f553f52010-08-21 03:08:16 +00001991 return MakeAddrLValue(EmitCXXTypeidExpr(E), E->getType());
Mike Stumpc2e84ae2009-11-15 08:09:41 +00001992}
1993
1994LValue
Anders Carlssone61c9e82009-05-30 23:30:54 +00001995CodeGenFunction::EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E) {
John McCallfc1e6c72010-09-18 00:58:34 +00001996 AggValueSlot Slot = CreateAggTemp(E->getType(), "temp.lvalue");
1997 Slot.setLifetimeExternallyManaged();
1998 EmitAggExpr(E->getSubExpr(), Slot);
1999 EmitCXXTemporary(E->getTemporary(), Slot.getAddr());
2000 return MakeAddrLValue(Slot.getAddr(), E->getType());
Anders Carlssone61c9e82009-05-30 23:30:54 +00002001}
2002
Daniel Dunbar0a04d772008-08-23 10:51:21 +00002003LValue CodeGenFunction::EmitObjCMessageExprLValue(const ObjCMessageExpr *E) {
Daniel Dunbar0a04d772008-08-23 10:51:21 +00002004 RValue RV = EmitObjCMessageExpr(E);
Anders Carlsson7e70fb22010-06-21 20:59:55 +00002005
2006 if (!RV.isScalar())
Daniel Dunbar9f553f52010-08-21 03:08:16 +00002007 return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
Anders Carlsson7e70fb22010-06-21 20:59:55 +00002008
2009 assert(E->getMethodDecl()->getResultType()->isReferenceType() &&
2010 "Can't have a scalar return unless the return type is a "
2011 "reference type!");
2012
Daniel Dunbar9f553f52010-08-21 03:08:16 +00002013 return MakeAddrLValue(RV.getScalarVal(), E->getType());
Daniel Dunbar0a04d772008-08-23 10:51:21 +00002014}
2015
Fariborz Jahanian03b29602010-06-17 19:56:20 +00002016LValue CodeGenFunction::EmitObjCSelectorLValue(const ObjCSelectorExpr *E) {
2017 llvm::Value *V =
2018 CGM.getObjCRuntime().GetSelector(Builder, E->getSelector(), true);
Daniel Dunbar9f553f52010-08-21 03:08:16 +00002019 return MakeAddrLValue(V, E->getType());
Fariborz Jahanian03b29602010-06-17 19:56:20 +00002020}
2021
Daniel Dunbar2a031922009-04-22 05:08:15 +00002022llvm::Value *CodeGenFunction::EmitIvarOffset(const ObjCInterfaceDecl *Interface,
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00002023 const ObjCIvarDecl *Ivar) {
Fariborz Jahanianf63aa3f2009-02-10 19:02:04 +00002024 return CGM.getObjCRuntime().EmitIvarOffset(*this, Interface, Ivar);
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00002025}
2026
Fariborz Jahanian45012a72009-02-03 00:09:52 +00002027LValue CodeGenFunction::EmitLValueForIvar(QualType ObjectTy,
2028 llvm::Value *BaseValue,
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00002029 const ObjCIvarDecl *Ivar,
2030 unsigned CVRQualifiers) {
Chris Lattner26f074b2009-04-17 17:44:48 +00002031 return CGM.getObjCRuntime().EmitObjCValueForIvar(*this, ObjectTy, BaseValue,
Daniel Dunbar525c9b72009-04-21 01:19:28 +00002032 Ivar, CVRQualifiers);
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00002033}
2034
2035LValue CodeGenFunction::EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E) {
Anders Carlsson29b7e502008-08-25 01:53:23 +00002036 // FIXME: A lot of the code below could be shared with EmitMemberExpr.
2037 llvm::Value *BaseValue = 0;
2038 const Expr *BaseExpr = E->getBase();
John McCall0953e762009-09-24 19:53:00 +00002039 Qualifiers BaseQuals;
Fariborz Jahanian45012a72009-02-03 00:09:52 +00002040 QualType ObjectTy;
Anders Carlsson29b7e502008-08-25 01:53:23 +00002041 if (E->isArrow()) {
2042 BaseValue = EmitScalarExpr(BaseExpr);
Steve Naroff14108da2009-07-10 23:34:53 +00002043 ObjectTy = BaseExpr->getType()->getPointeeType();
John McCall0953e762009-09-24 19:53:00 +00002044 BaseQuals = ObjectTy.getQualifiers();
Anders Carlsson29b7e502008-08-25 01:53:23 +00002045 } else {
2046 LValue BaseLV = EmitLValue(BaseExpr);
2047 // FIXME: this isn't right for bitfields.
2048 BaseValue = BaseLV.getAddress();
Fariborz Jahanian45012a72009-02-03 00:09:52 +00002049 ObjectTy = BaseExpr->getType();
John McCall0953e762009-09-24 19:53:00 +00002050 BaseQuals = ObjectTy.getQualifiers();
Anders Carlsson29b7e502008-08-25 01:53:23 +00002051 }
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00002052
Fariborz Jahaniandbf3cfd2009-09-16 23:11:23 +00002053 LValue LV =
John McCall0953e762009-09-24 19:53:00 +00002054 EmitLValueForIvar(ObjectTy, BaseValue, E->getDecl(),
2055 BaseQuals.getCVRQualifiers());
Fariborz Jahaniandbf3cfd2009-09-16 23:11:23 +00002056 setObjCGCLValueClass(getContext(), E, LV);
2057 return LV;
Chris Lattner391d77a2008-03-30 23:03:07 +00002058}
2059
Chris Lattner65459942009-04-25 19:35:26 +00002060LValue CodeGenFunction::EmitStmtExprLValue(const StmtExpr *E) {
Chris Lattner65459942009-04-25 19:35:26 +00002061 // Can only get l-value for message expression returning aggregate type
2062 RValue RV = EmitAnyExprToTemp(E);
Daniel Dunbar9f553f52010-08-21 03:08:16 +00002063 return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
Chris Lattner65459942009-04-25 19:35:26 +00002064}
2065
Anders Carlsson31777a22009-12-24 19:08:58 +00002066RValue CodeGenFunction::EmitCall(QualType CalleeType, llvm::Value *Callee,
Anders Carlssond2490a92009-12-24 20:40:36 +00002067 ReturnValueSlot ReturnValue,
Anders Carlsson98647712009-05-27 01:22:39 +00002068 CallExpr::const_arg_iterator ArgBeg,
2069 CallExpr::const_arg_iterator ArgEnd,
2070 const Decl *TargetDecl) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +00002071 // Get the actual function type. The callee type will always be a pointer to
2072 // function type or a block pointer type.
2073 assert(CalleeType->isFunctionPointerType() &&
Anders Carlsson8ac67a72009-04-07 18:53:02 +00002074 "Call must have function pointer type!");
2075
John McCall00a1ad92009-10-23 08:22:42 +00002076 CalleeType = getContext().getCanonicalType(CalleeType);
2077
John McCall04a67a62010-02-05 21:31:56 +00002078 const FunctionType *FnType
2079 = cast<FunctionType>(cast<PointerType>(CalleeType)->getPointeeType());
Daniel Dunbar19cd87e2008-08-30 03:02:31 +00002080
2081 CallArgList Args;
John McCall00a1ad92009-10-23 08:22:42 +00002082 EmitCallArgs(Args, dyn_cast<FunctionProtoType>(FnType), ArgBeg, ArgEnd);
Daniel Dunbar19cd87e2008-08-30 03:02:31 +00002083
John McCall04a67a62010-02-05 21:31:56 +00002084 return EmitCall(CGM.getTypes().getFunctionInfo(Args, FnType),
Anders Carlssond2490a92009-12-24 20:40:36 +00002085 Callee, ReturnValue, Args, TargetDecl);
Daniel Dunbar8f2926b2008-08-23 03:46:30 +00002086}
Fariborz Jahanian8bfd31f2009-10-22 22:57:31 +00002087
Chris Lattnereb99b012009-10-28 17:39:19 +00002088LValue CodeGenFunction::
2089EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E) {
Eli Friedman1c5c1a02009-11-18 05:01:17 +00002090 llvm::Value *BaseV;
John McCall2de56d12010-08-25 11:45:40 +00002091 if (E->getOpcode() == BO_PtrMemI)
Eli Friedman1c5c1a02009-11-18 05:01:17 +00002092 BaseV = EmitScalarExpr(E->getLHS());
2093 else
2094 BaseV = EmitLValue(E->getLHS()).getAddress();
Chris Lattnereb99b012009-10-28 17:39:19 +00002095
John McCall6c2ab1d2010-08-31 21:07:20 +00002096 llvm::Value *OffsetV = EmitScalarExpr(E->getRHS());
2097
2098 const MemberPointerType *MPT
2099 = E->getRHS()->getType()->getAs<MemberPointerType>();
2100
2101 llvm::Value *AddV =
2102 CGM.getCXXABI().EmitMemberDataPointerAddress(*this, BaseV, OffsetV, MPT);
2103
2104 return MakeAddrLValue(AddV, MPT->getPointeeType());
Fariborz Jahanian8bfd31f2009-10-22 22:57:31 +00002105}