blob: 70fa004de856bee392770f9ee8e5e201a1a1910a [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"
Daniel Dunbaraf2f62c2008-08-13 00:59:25 +000017#include "CGObjCRuntime.h"
Daniel Dunbarde7fb842008-08-11 05:00:27 +000018#include "clang/AST/ASTContext.h"
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000019#include "clang/AST/DeclObjC.h"
Eli Friedman316bb1b2008-05-17 20:03:47 +000020#include "llvm/Target/TargetData.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000021using namespace clang;
22using namespace CodeGen;
23
24//===--------------------------------------------------------------------===//
25// Miscellaneous Helper Methods
26//===--------------------------------------------------------------------===//
27
28/// CreateTempAlloca - This creates a alloca and inserts it into the entry
29/// block.
30llvm::AllocaInst *CodeGenFunction::CreateTempAlloca(const llvm::Type *Ty,
Daniel Dunbar259e9cc2009-10-19 01:21:05 +000031 const llvm::Twine &Name) {
Chris Lattnerf1466842009-03-22 00:24:14 +000032 if (!Builder.isNamePreserving())
Daniel Dunbar259e9cc2009-10-19 01:21:05 +000033 return new llvm::AllocaInst(Ty, 0, "", AllocaInsertPt);
Devang Pateld35e2e02009-10-12 22:29:02 +000034 return new llvm::AllocaInst(Ty, 0, Name, AllocaInsertPt);
Reid Spencer5f016e22007-07-11 17:01:13 +000035}
36
37/// EvaluateExprAsBool - Perform the usual unary conversions on the specified
38/// expression and compare the result against zero, returning an Int1Ty value.
39llvm::Value *CodeGenFunction::EvaluateExprAsBool(const Expr *E) {
Chris Lattner9069fa22007-08-26 16:46:58 +000040 QualType BoolTy = getContext().BoolTy;
Eli Friedman3a173702009-12-11 09:26:29 +000041 if (E->getType()->isMemberFunctionPointerType()) {
42 llvm::Value *Ptr = CreateTempAlloca(ConvertType(E->getType()));
43 EmitAggExpr(E, Ptr, /*VolatileDest=*/false);
44
45 // Get the pointer.
46 llvm::Value *FuncPtr = Builder.CreateStructGEP(Ptr, 0, "src.ptr");
47 FuncPtr = Builder.CreateLoad(FuncPtr);
48
49 llvm::Value *IsNotNull =
50 Builder.CreateICmpNE(FuncPtr,
51 llvm::Constant::getNullValue(FuncPtr->getType()),
52 "tobool");
53
54 return IsNotNull;
55 }
Chris Lattner9b2dc282008-04-04 16:54:41 +000056 if (!E->getType()->isAnyComplexType())
Chris Lattner9069fa22007-08-26 16:46:58 +000057 return EmitScalarConversion(EmitScalarExpr(E), E->getType(), BoolTy);
Reid Spencer5f016e22007-07-11 17:01:13 +000058
Chris Lattner9069fa22007-08-26 16:46:58 +000059 return EmitComplexToScalarConversion(EmitComplexExpr(E), E->getType(),BoolTy);
Reid Spencer5f016e22007-07-11 17:01:13 +000060}
61
Chris Lattner9b655512007-08-31 22:49:20 +000062/// EmitAnyExpr - Emit code to compute the specified expression which can have
63/// any type. The result is returned as an RValue struct. If this is an
Mike Stumpdb52dcd2009-09-09 13:00:44 +000064/// aggregate expression, the aggloc/agglocvolatile arguments indicate where the
65/// result should be returned.
66RValue CodeGenFunction::EmitAnyExpr(const Expr *E, llvm::Value *AggLoc,
Anders Carlsson14c5cbf2009-08-16 07:36:22 +000067 bool IsAggLocVolatile, bool IgnoreResult,
68 bool IsInitializer) {
Chris Lattner9b655512007-08-31 22:49:20 +000069 if (!hasAggregateLLVMType(E->getType()))
Mike Stump7f79f9b2009-05-29 15:46:01 +000070 return RValue::get(EmitScalarExpr(E, IgnoreResult));
Chris Lattner9b2dc282008-04-04 16:54:41 +000071 else if (E->getType()->isAnyComplexType())
Mike Stump7f79f9b2009-05-29 15:46:01 +000072 return RValue::getComplex(EmitComplexExpr(E, false, false,
73 IgnoreResult, IgnoreResult));
Mike Stumpdb52dcd2009-09-09 13:00:44 +000074
Anders Carlsson14c5cbf2009-08-16 07:36:22 +000075 EmitAggExpr(E, AggLoc, IsAggLocVolatile, IgnoreResult, IsInitializer);
76 return RValue::getAggregate(AggLoc, IsAggLocVolatile);
Chris Lattner9b655512007-08-31 22:49:20 +000077}
78
Mike Stumpdb52dcd2009-09-09 13:00:44 +000079/// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result will
80/// always be accessible even if no aggregate location is provided.
81RValue CodeGenFunction::EmitAnyExprToTemp(const Expr *E,
Anders Carlsson14c5cbf2009-08-16 07:36:22 +000082 bool IsAggLocVolatile,
83 bool IsInitializer) {
84 llvm::Value *AggLoc = 0;
Mike Stumpdb52dcd2009-09-09 13:00:44 +000085
86 if (hasAggregateLLVMType(E->getType()) &&
Daniel Dunbar46f45b92008-09-09 01:06:48 +000087 !E->getType()->isAnyComplexType())
88 AggLoc = CreateTempAlloca(ConvertType(E->getType()), "agg.tmp");
Mike Stumpdb52dcd2009-09-09 13:00:44 +000089 return EmitAnyExpr(E, AggLoc, IsAggLocVolatile, /*IgnoreResult=*/false,
Anders Carlsson14c5cbf2009-08-16 07:36:22 +000090 IsInitializer);
Daniel Dunbar46f45b92008-09-09 01:06:48 +000091}
92
Anders Carlsson4029ca72009-05-20 00:24:07 +000093RValue CodeGenFunction::EmitReferenceBindingToExpr(const Expr* E,
Anders Carlsson14c5cbf2009-08-16 07:36:22 +000094 QualType DestType,
95 bool IsInitializer) {
Anders Carlssone1b7ea12009-10-18 23:09:21 +000096 bool ShouldDestroyTemporaries = false;
97 unsigned OldNumLiveTemporaries = 0;
98
Anders Carlssonb3f74422009-10-15 00:51:46 +000099 if (const CXXExprWithTemporaries *TE = dyn_cast<CXXExprWithTemporaries>(E)) {
Anders Carlssone1b7ea12009-10-18 23:09:21 +0000100 ShouldDestroyTemporaries = TE->shouldDestroyTemporaries();
101
Chris Lattnereb99b012009-10-28 17:39:19 +0000102 // Keep track of the current cleanup stack depth.
103 if (ShouldDestroyTemporaries)
Anders Carlssone1b7ea12009-10-18 23:09:21 +0000104 OldNumLiveTemporaries = LiveTemporaries.size();
Anders Carlssonb3f74422009-10-15 00:51:46 +0000105
Anders Carlssone1b7ea12009-10-18 23:09:21 +0000106 E = TE->getSubExpr();
Anders Carlssonb3f74422009-10-15 00:51:46 +0000107 }
108
Eli Friedman5df0d422009-05-20 02:31:19 +0000109 RValue Val;
110 if (E->isLvalue(getContext()) == Expr::LV_Valid) {
Anders Carlsson4bbab922009-05-20 00:36:58 +0000111 // Emit the expr as an lvalue.
112 LValue LV = EmitLValue(E);
Eli Friedman5df0d422009-05-20 02:31:19 +0000113 if (LV.isSimple())
114 return RValue::get(LV.getAddress());
115 Val = EmitLoadOfLValue(LV, E->getType());
Anders Carlssone1b7ea12009-10-18 23:09:21 +0000116
117 if (ShouldDestroyTemporaries) {
118 // Pop temporaries.
119 while (LiveTemporaries.size() > OldNumLiveTemporaries)
120 PopCXXTemporary();
121 }
Eli Friedman5df0d422009-05-20 02:31:19 +0000122 } else {
Anders Carlssonb3f74422009-10-15 00:51:46 +0000123 const CXXRecordDecl *BaseClassDecl = 0;
124 const CXXRecordDecl *DerivedClassDecl = 0;
125
126 if (const CastExpr *CE =
127 dyn_cast<CastExpr>(E->IgnoreParenNoopCasts(getContext()))) {
128 if (CE->getCastKind() == CastExpr::CK_DerivedToBase) {
129 E = CE->getSubExpr();
130
131 BaseClassDecl =
132 cast<CXXRecordDecl>(CE->getType()->getAs<RecordType>()->getDecl());
133 DerivedClassDecl =
134 cast<CXXRecordDecl>(E->getType()->getAs<RecordType>()->getDecl());
135 }
136 }
137
Anders Carlsson14c5cbf2009-08-16 07:36:22 +0000138 Val = EmitAnyExprToTemp(E, /*IsAggLocVolatile=*/false,
139 IsInitializer);
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000140
Anders Carlssone1b7ea12009-10-18 23:09:21 +0000141 if (ShouldDestroyTemporaries) {
142 // Pop temporaries.
143 while (LiveTemporaries.size() > OldNumLiveTemporaries)
144 PopCXXTemporary();
145 }
146
Anders Carlsson2da76932009-08-16 17:54:29 +0000147 if (IsInitializer) {
148 // We might have to destroy the temporary variable.
149 if (const RecordType *RT = E->getType()->getAs<RecordType>()) {
150 if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
151 if (!ClassDecl->hasTrivialDestructor()) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000152 const CXXDestructorDecl *Dtor =
Anders Carlsson2da76932009-08-16 17:54:29 +0000153 ClassDecl->getDestructor(getContext());
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000154
Mike Stumpd88ea562009-12-09 03:35:49 +0000155 {
Anders Carlsson6ec687d2009-12-11 01:00:09 +0000156 DelayedCleanupBlock Scope(*this);
Mike Stumpd88ea562009-12-09 03:35:49 +0000157 EmitCXXDestructorCall(Dtor, Dtor_Complete,
158 Val.getAggregateAddr());
Anders Carlsson6ec687d2009-12-11 01:00:09 +0000159
160 // Make sure to jump to the exit block.
161 EmitBranch(Scope.getCleanupExitBlock());
Mike Stumpd88ea562009-12-09 03:35:49 +0000162 }
163 if (Exceptions) {
164 EHCleanupBlock Cleanup(*this);
165 EmitCXXDestructorCall(Dtor, Dtor_Complete,
166 Val.getAggregateAddr());
167 }
Anders Carlsson2da76932009-08-16 17:54:29 +0000168 }
Anders Carlsson8478ce62009-08-16 17:50:25 +0000169 }
170 }
171 }
Anders Carlssonb3f74422009-10-15 00:51:46 +0000172
173 // Check if need to perform the derived-to-base cast.
174 if (BaseClassDecl) {
175 llvm::Value *Derived = Val.getAggregateAddr();
Anders Carlssonb3f74422009-10-15 00:51:46 +0000176 llvm::Value *Base =
Anders Carlssona3697c92009-11-23 17:57:54 +0000177 GetAddressOfBaseClass(Derived, DerivedClassDecl, BaseClassDecl,
178 /*NullCheckValue=*/false);
Anders Carlssonb3f74422009-10-15 00:51:46 +0000179 return RValue::get(Base);
180 }
Anders Carlsson4bbab922009-05-20 00:36:58 +0000181 }
Eli Friedman5df0d422009-05-20 02:31:19 +0000182
183 if (Val.isAggregate()) {
184 Val = RValue::get(Val.getAggregateAddr());
185 } else {
Anders Carlsson7cd3a642009-05-20 01:35:03 +0000186 // Create a temporary variable that we can bind the reference to.
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000187 llvm::Value *Temp = CreateTempAlloca(ConvertTypeForMem(E->getType()),
Anders Carlssone04d1c72009-05-20 01:03:17 +0000188 "reftmp");
Eli Friedman5df0d422009-05-20 02:31:19 +0000189 if (Val.isScalar())
190 EmitStoreOfScalar(Val.getScalarVal(), Temp, false, E->getType());
191 else
192 StoreComplexToAddr(Val.getComplexVal(), Temp, false);
193 Val = RValue::get(Temp);
Anders Carlssone04d1c72009-05-20 01:03:17 +0000194 }
Eli Friedman5df0d422009-05-20 02:31:19 +0000195
196 return Val;
Anders Carlsson4029ca72009-05-20 00:24:07 +0000197}
198
199
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000200/// getAccessedFieldNo - Given an encoded value and a result number, return the
201/// input field number being accessed.
202unsigned CodeGenFunction::getAccessedFieldNo(unsigned Idx,
Dan Gohman4f8d1232008-05-22 00:50:06 +0000203 const llvm::Constant *Elts) {
204 if (isa<llvm::ConstantAggregateZero>(Elts))
205 return 0;
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000206
Dan Gohman4f8d1232008-05-22 00:50:06 +0000207 return cast<llvm::ConstantInt>(Elts->getOperand(Idx))->getZExtValue();
208}
209
Chris Lattner9b655512007-08-31 22:49:20 +0000210
Reid Spencer5f016e22007-07-11 17:01:13 +0000211//===----------------------------------------------------------------------===//
212// LValue Expression Emission
213//===----------------------------------------------------------------------===//
214
Daniel Dunbar13e81732009-02-05 07:09:07 +0000215RValue CodeGenFunction::GetUndefRValue(QualType Ty) {
Chris Lattnereb99b012009-10-28 17:39:19 +0000216 if (Ty->isVoidType())
Daniel Dunbar13e81732009-02-05 07:09:07 +0000217 return RValue::get(0);
Chris Lattnereb99b012009-10-28 17:39:19 +0000218
219 if (const ComplexType *CTy = Ty->getAs<ComplexType>()) {
Daniel Dunbar8fa73ed2009-01-09 20:09:28 +0000220 const llvm::Type *EltTy = ConvertType(CTy->getElementType());
Owen Anderson03e20502009-07-30 23:11:26 +0000221 llvm::Value *U = llvm::UndefValue::get(EltTy);
Daniel Dunbar8fa73ed2009-01-09 20:09:28 +0000222 return RValue::getComplex(std::make_pair(U, U));
Chris Lattnereb99b012009-10-28 17:39:19 +0000223 }
224
225 if (hasAggregateLLVMType(Ty)) {
Owen Anderson96e0fc72009-07-29 22:16:19 +0000226 const llvm::Type *LTy = llvm::PointerType::getUnqual(ConvertType(Ty));
Owen Anderson03e20502009-07-30 23:11:26 +0000227 return RValue::getAggregate(llvm::UndefValue::get(LTy));
Daniel Dunbar8fa73ed2009-01-09 20:09:28 +0000228 }
Chris Lattnereb99b012009-10-28 17:39:19 +0000229
230 return RValue::get(llvm::UndefValue::get(ConvertType(Ty)));
Daniel Dunbarce1d38b2009-01-09 16:50:52 +0000231}
232
Daniel Dunbar13e81732009-02-05 07:09:07 +0000233RValue CodeGenFunction::EmitUnsupportedRValue(const Expr *E,
234 const char *Name) {
235 ErrorUnsupported(E, Name);
236 return GetUndefRValue(E->getType());
237}
238
Daniel Dunbar6ba82a42008-08-25 20:45:57 +0000239LValue CodeGenFunction::EmitUnsupportedLValue(const Expr *E,
240 const char *Name) {
241 ErrorUnsupported(E, Name);
Owen Anderson96e0fc72009-07-29 22:16:19 +0000242 llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType()));
Owen Anderson03e20502009-07-30 23:11:26 +0000243 return LValue::MakeAddr(llvm::UndefValue::get(Ty),
John McCall0953e762009-09-24 19:53:00 +0000244 MakeQualifiers(E->getType()));
Daniel Dunbar6ba82a42008-08-25 20:45:57 +0000245}
246
Reid Spencer5f016e22007-07-11 17:01:13 +0000247/// EmitLValue - Emit code to compute a designator that specifies the location
248/// of the expression.
249///
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000250/// This can return one of two things: a simple address or a bitfield reference.
251/// In either case, the LLVM Value* in the LValue structure is guaranteed to be
252/// an LLVM pointer type.
Reid Spencer5f016e22007-07-11 17:01:13 +0000253///
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000254/// If this returns a bitfield reference, nothing about the pointee type of the
255/// LLVM value is known: For example, it may not be a pointer to an integer.
Reid Spencer5f016e22007-07-11 17:01:13 +0000256///
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000257/// If this returns a normal address, and if the lvalue's C type is fixed size,
258/// this method guarantees that the returned pointer type will point to an LLVM
259/// type of the same size of the lvalue's type. If the lvalue has a variable
260/// length type, this is not possible.
Reid Spencer5f016e22007-07-11 17:01:13 +0000261///
262LValue CodeGenFunction::EmitLValue(const Expr *E) {
263 switch (E->getStmtClass()) {
Daniel Dunbar6ba82a42008-08-25 20:45:57 +0000264 default: return EmitUnsupportedLValue(E, "l-value expression");
Reid Spencer5f016e22007-07-11 17:01:13 +0000265
Fariborz Jahanian820bca42009-12-09 23:35:29 +0000266 case Expr::ObjCIsaExprClass:
267 return EmitObjCIsaExpr(cast<ObjCIsaExpr>(E));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000268 case Expr::BinaryOperatorClass:
Daniel Dunbar80e62c22008-09-04 03:20:13 +0000269 return EmitBinaryOperatorLValue(cast<BinaryOperator>(E));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000270 case Expr::CallExprClass:
Anders Carlssonfaf86642009-09-01 21:18:52 +0000271 case Expr::CXXMemberCallExprClass:
Douglas Gregorb4609802008-11-14 16:09:21 +0000272 case Expr::CXXOperatorCallExprClass:
273 return EmitCallExprLValue(cast<CallExpr>(E));
Daniel Dunbar5b5c9ef2009-02-11 20:59:32 +0000274 case Expr::VAArgExprClass:
275 return EmitVAArgExprLValue(cast<VAArgExpr>(E));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000276 case Expr::DeclRefExprClass:
Douglas Gregor1a49af92009-01-06 05:10:23 +0000277 return EmitDeclRefLValue(cast<DeclRefExpr>(E));
Reid Spencer5f016e22007-07-11 17:01:13 +0000278 case Expr::ParenExprClass:return EmitLValue(cast<ParenExpr>(E)->getSubExpr());
Chris Lattnerd9f69102008-08-10 01:53:14 +0000279 case Expr::PredefinedExprClass:
280 return EmitPredefinedLValue(cast<PredefinedExpr>(E));
Reid Spencer5f016e22007-07-11 17:01:13 +0000281 case Expr::StringLiteralClass:
282 return EmitStringLiteralLValue(cast<StringLiteral>(E));
Chris Lattnereaf2bb82009-02-24 22:18:39 +0000283 case Expr::ObjCEncodeExprClass:
284 return EmitObjCEncodeExprLValue(cast<ObjCEncodeExpr>(E));
Chris Lattner391d77a2008-03-30 23:03:07 +0000285
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000286 case Expr::BlockDeclRefExprClass:
Mike Stumpa99038c2009-02-28 09:07:16 +0000287 return EmitBlockDeclRefLValue(cast<BlockDeclRefExpr>(E));
288
Anders Carlssonb58d0172009-05-30 23:23:33 +0000289 case Expr::CXXTemporaryObjectExprClass:
290 case Expr::CXXConstructExprClass:
Anders Carlssone61c9e82009-05-30 23:30:54 +0000291 return EmitCXXConstructLValue(cast<CXXConstructExpr>(E));
292 case Expr::CXXBindTemporaryExprClass:
293 return EmitCXXBindTemporaryLValue(cast<CXXBindTemporaryExpr>(E));
Anders Carlssonb9ea0b52009-09-14 01:10:45 +0000294 case Expr::CXXExprWithTemporariesClass:
295 return EmitCXXExprWithTemporariesLValue(cast<CXXExprWithTemporaries>(E));
Anders Carlsson370e5382009-11-14 01:51:50 +0000296 case Expr::CXXZeroInitValueExprClass:
297 return EmitNullInitializationLValue(cast<CXXZeroInitValueExpr>(E));
298 case Expr::CXXDefaultArgExprClass:
299 return EmitLValue(cast<CXXDefaultArgExpr>(E)->getExpr());
Mike Stumpc2e84ae2009-11-15 08:09:41 +0000300 case Expr::CXXTypeidExprClass:
301 return EmitCXXTypeidLValue(cast<CXXTypeidExpr>(E));
Anders Carlssone61c9e82009-05-30 23:30:54 +0000302
Daniel Dunbar0a04d772008-08-23 10:51:21 +0000303 case Expr::ObjCMessageExprClass:
304 return EmitObjCMessageExprLValue(cast<ObjCMessageExpr>(E));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000305 case Expr::ObjCIvarRefExprClass:
Chris Lattner391d77a2008-03-30 23:03:07 +0000306 return EmitObjCIvarRefLValue(cast<ObjCIvarRefExpr>(E));
Daniel Dunbar6ba82a42008-08-25 20:45:57 +0000307 case Expr::ObjCPropertyRefExprClass:
Daniel Dunbar85c59ed2008-08-29 08:11:39 +0000308 return EmitObjCPropertyRefLValue(cast<ObjCPropertyRefExpr>(E));
Fariborz Jahanian09105f52009-08-20 17:02:02 +0000309 case Expr::ObjCImplicitSetterGetterRefExprClass:
310 return EmitObjCKVCRefLValue(cast<ObjCImplicitSetterGetterRefExpr>(E));
Douglas Gregorcd9b46e2008-11-04 14:56:14 +0000311 case Expr::ObjCSuperExprClass:
Chris Lattner65459942009-04-25 19:35:26 +0000312 return EmitObjCSuperExprLValue(cast<ObjCSuperExpr>(E));
Douglas Gregorcd9b46e2008-11-04 14:56:14 +0000313
Chris Lattner65459942009-04-25 19:35:26 +0000314 case Expr::StmtExprClass:
315 return EmitStmtExprLValue(cast<StmtExpr>(E));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000316 case Expr::UnaryOperatorClass:
Reid Spencer5f016e22007-07-11 17:01:13 +0000317 return EmitUnaryOpLValue(cast<UnaryOperator>(E));
318 case Expr::ArraySubscriptExprClass:
319 return EmitArraySubscriptExpr(cast<ArraySubscriptExpr>(E));
Nate Begeman213541a2008-04-18 23:10:10 +0000320 case Expr::ExtVectorElementExprClass:
321 return EmitExtVectorElementExpr(cast<ExtVectorElementExpr>(E));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000322 case Expr::MemberExprClass:
Douglas Gregorbd4c4ae2009-08-26 22:36:53 +0000323 return EmitMemberExpr(cast<MemberExpr>(E));
Eli Friedman06e863f2008-05-13 23:18:27 +0000324 case Expr::CompoundLiteralExprClass:
325 return EmitCompoundLiteralLValue(cast<CompoundLiteralExpr>(E));
Daniel Dunbar90345582009-03-24 02:38:23 +0000326 case Expr::ConditionalOperatorClass:
Anders Carlsson6fcec8b2009-09-15 16:35:24 +0000327 return EmitConditionalOperatorLValue(cast<ConditionalOperator>(E));
Chris Lattner670a62c2008-12-12 05:35:08 +0000328 case Expr::ChooseExprClass:
Eli Friedman79769322009-03-04 05:52:32 +0000329 return EmitLValue(cast<ChooseExpr>(E)->getChosenSubExpr(getContext()));
Chris Lattnerc3953a62009-03-18 04:02:57 +0000330 case Expr::ImplicitCastExprClass:
331 case Expr::CStyleCastExprClass:
332 case Expr::CXXFunctionalCastExprClass:
333 case Expr::CXXStaticCastExprClass:
334 case Expr::CXXDynamicCastExprClass:
335 case Expr::CXXReinterpretCastExprClass:
336 case Expr::CXXConstCastExprClass:
Chris Lattner75dfeda2009-03-18 18:28:57 +0000337 return EmitCastLValue(cast<CastExpr>(E));
Reid Spencer5f016e22007-07-11 17:01:13 +0000338 }
339}
340
Daniel Dunbar9d9cc872009-02-10 00:57:50 +0000341llvm::Value *CodeGenFunction::EmitLoadOfScalar(llvm::Value *Addr, bool Volatile,
342 QualType Ty) {
Daniel Dunbar2da84ff2009-11-29 21:23:36 +0000343 llvm::LoadInst *Load = Builder.CreateLoad(Addr, "tmp");
344 if (Volatile)
345 Load->setVolatile(true);
Daniel Dunbar9d9cc872009-02-10 00:57:50 +0000346
Anders Carlsson3bb423b2009-05-19 19:36:19 +0000347 // Bool can have different representation in memory than in registers.
Daniel Dunbar2da84ff2009-11-29 21:23:36 +0000348 llvm::Value *V = Load;
Daniel Dunbar9d9cc872009-02-10 00:57:50 +0000349 if (Ty->isBooleanType())
Owen Anderson0032b272009-08-13 21:57:51 +0000350 if (V->getType() != llvm::Type::getInt1Ty(VMContext))
351 V = Builder.CreateTrunc(V, llvm::Type::getInt1Ty(VMContext), "tobool");
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000352
Daniel Dunbar9d9cc872009-02-10 00:57:50 +0000353 return V;
354}
355
356void CodeGenFunction::EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr,
Anders Carlssonb4aa4662009-05-19 18:50:41 +0000357 bool Volatile, QualType Ty) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000358
Anders Carlsson3bb423b2009-05-19 19:36:19 +0000359 if (Ty->isBooleanType()) {
360 // Bool can have different representation in memory than in registers.
Anders Carlsson3bb423b2009-05-19 19:36:19 +0000361 const llvm::PointerType *DstPtr = cast<llvm::PointerType>(Addr->getType());
Eli Friedman2b06d342009-12-01 22:31:51 +0000362 Value = Builder.CreateIntCast(Value, DstPtr->getElementType(), false);
Daniel Dunbar9d9cc872009-02-10 00:57:50 +0000363 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000364 Builder.CreateStore(Value, Addr, Volatile);
Daniel Dunbar9d9cc872009-02-10 00:57:50 +0000365}
366
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000367/// EmitLoadOfLValue - Given an expression that represents a value lvalue, this
368/// method emits the address of the lvalue, then loads the result as an rvalue,
369/// returning the rvalue.
Reid Spencer5f016e22007-07-11 17:01:13 +0000370RValue CodeGenFunction::EmitLoadOfLValue(LValue LV, QualType ExprType) {
Fariborz Jahaniandbd32c22008-11-19 17:34:06 +0000371 if (LV.isObjCWeak()) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000372 // load of a __weak object.
Fariborz Jahanian6dc23172008-11-18 21:45:40 +0000373 llvm::Value *AddrWeakObj = LV.getAddress();
Chris Lattnereb99b012009-10-28 17:39:19 +0000374 return RValue::get(CGM.getObjCRuntime().EmitObjCWeakRead(*this,
375 AddrWeakObj));
Fariborz Jahanian6dc23172008-11-18 21:45:40 +0000376 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000377
Reid Spencer5f016e22007-07-11 17:01:13 +0000378 if (LV.isSimple()) {
379 llvm::Value *Ptr = LV.getAddress();
380 const llvm::Type *EltTy =
381 cast<llvm::PointerType>(Ptr->getType())->getElementType();
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000382
Reid Spencer5f016e22007-07-11 17:01:13 +0000383 // Simple scalar l-value.
Daniel Dunbar9d9cc872009-02-10 00:57:50 +0000384 if (EltTy->isSingleValueType())
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000385 return RValue::get(EmitLoadOfScalar(Ptr, LV.isVolatileQualified(),
Daniel Dunbar9d9cc872009-02-10 00:57:50 +0000386 ExprType));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000387
Chris Lattner883f6a72007-08-11 00:04:45 +0000388 assert(ExprType->isFunctionType() && "Unknown scalar value");
389 return RValue::get(Ptr);
Reid Spencer5f016e22007-07-11 17:01:13 +0000390 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000391
Reid Spencer5f016e22007-07-11 17:01:13 +0000392 if (LV.isVectorElt()) {
Eli Friedman1e692ac2008-06-13 23:01:12 +0000393 llvm::Value *Vec = Builder.CreateLoad(LV.getVectorAddr(),
394 LV.isVolatileQualified(), "tmp");
Reid Spencer5f016e22007-07-11 17:01:13 +0000395 return RValue::get(Builder.CreateExtractElement(Vec, LV.getVectorIdx(),
396 "vecext"));
397 }
Chris Lattner46ea8eb2007-08-03 00:16:29 +0000398
399 // If this is a reference to a subset of the elements of a vector, either
400 // shuffle the input or extract/insert them as appropriate.
Nate Begeman213541a2008-04-18 23:10:10 +0000401 if (LV.isExtVectorElt())
402 return EmitLoadOfExtVectorElementLValue(LV, ExprType);
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +0000403
404 if (LV.isBitfield())
405 return EmitLoadOfBitfieldLValue(LV, ExprType);
406
Daniel Dunbar85c59ed2008-08-29 08:11:39 +0000407 if (LV.isPropertyRef())
408 return EmitLoadOfPropertyRefLValue(LV, ExprType);
409
Chris Lattner73525de2009-02-16 21:11:58 +0000410 assert(LV.isKVCRef() && "Unknown LValue type!");
411 return EmitLoadOfKVCRefLValue(LV, ExprType);
Reid Spencer5f016e22007-07-11 17:01:13 +0000412}
413
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +0000414RValue CodeGenFunction::EmitLoadOfBitfieldLValue(LValue LV,
415 QualType ExprType) {
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000416 unsigned StartBit = LV.getBitfieldStartBit();
417 unsigned BitfieldSize = LV.getBitfieldSize();
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +0000418 llvm::Value *Ptr = LV.getBitfieldAddr();
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000419
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000420 const llvm::Type *EltTy =
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +0000421 cast<llvm::PointerType>(Ptr->getType())->getElementType();
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000422 unsigned EltTySize = CGM.getTargetData().getTypeSizeInBits(EltTy);
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +0000423
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000424 // In some cases the bitfield may straddle two memory locations. Currently we
425 // load the entire bitfield, then do the magic to sign-extend it if
426 // necessary. This results in somewhat more code than necessary for the common
427 // case (one load), since two shifts accomplish both the masking and sign
428 // extension.
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000429 unsigned LowBits = std::min(BitfieldSize, EltTySize - StartBit);
430 llvm::Value *Val = Builder.CreateLoad(Ptr, LV.isVolatileQualified(), "tmp");
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000431
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000432 // Shift to proper location.
Daniel Dunbarf3edc2f2008-11-13 02:20:34 +0000433 if (StartBit)
Chris Lattner86b85b22009-12-06 17:22:42 +0000434 Val = Builder.CreateLShr(Val, StartBit, "bf.lo");
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000435
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000436 // Mask off unused bits.
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000437 llvm::Constant *LowMask = llvm::ConstantInt::get(VMContext,
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000438 llvm::APInt::getLowBitsSet(EltTySize, LowBits));
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000439 Val = Builder.CreateAnd(Val, LowMask, "bf.lo.cleared");
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000440
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000441 // Fetch the high bits if necessary.
442 if (LowBits < BitfieldSize) {
443 unsigned HighBits = BitfieldSize - LowBits;
Owen Anderson0032b272009-08-13 21:57:51 +0000444 llvm::Value *HighPtr = Builder.CreateGEP(Ptr, llvm::ConstantInt::get(
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000445 llvm::Type::getInt32Ty(VMContext), 1), "bf.ptr.hi");
446 llvm::Value *HighVal = Builder.CreateLoad(HighPtr,
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000447 LV.isVolatileQualified(),
448 "tmp");
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000449
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000450 // Mask off unused bits.
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000451 llvm::Constant *HighMask = llvm::ConstantInt::get(VMContext,
452 llvm::APInt::getLowBitsSet(EltTySize, HighBits));
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000453 HighVal = Builder.CreateAnd(HighVal, HighMask, "bf.lo.cleared");
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +0000454
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000455 // Shift to proper location and or in to bitfield value.
Chris Lattner86b85b22009-12-06 17:22:42 +0000456 HighVal = Builder.CreateShl(HighVal, LowBits);
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000457 Val = Builder.CreateOr(Val, HighVal, "bf.val");
458 }
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +0000459
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000460 // Sign extend if necessary.
461 if (LV.isBitfieldSigned()) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000462 llvm::Value *ExtraBits = llvm::ConstantInt::get(EltTy,
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000463 EltTySize - BitfieldSize);
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000464 Val = Builder.CreateAShr(Builder.CreateShl(Val, ExtraBits),
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000465 ExtraBits, "bf.val.sext");
466 }
Eli Friedman316bb1b2008-05-17 20:03:47 +0000467
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000468 // The bitfield type and the normal type differ when the storage sizes differ
469 // (currently just _Bool).
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000470 Val = Builder.CreateIntCast(Val, ConvertType(ExprType), false, "tmp");
Eli Friedman316bb1b2008-05-17 20:03:47 +0000471
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000472 return RValue::get(Val);
Lauro Ramos Venancio3b8c22d2008-01-22 20:17:04 +0000473}
474
Daniel Dunbar85c59ed2008-08-29 08:11:39 +0000475RValue CodeGenFunction::EmitLoadOfPropertyRefLValue(LValue LV,
476 QualType ExprType) {
477 return EmitObjCPropertyGet(LV.getPropertyRefExpr());
478}
479
Fariborz Jahanian43f44702008-11-22 22:30:21 +0000480RValue CodeGenFunction::EmitLoadOfKVCRefLValue(LValue LV,
481 QualType ExprType) {
482 return EmitObjCPropertyGet(LV.getKVCRefExpr());
483}
484
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000485// If this is a reference to a subset of the elements of a vector, create an
486// appropriate shufflevector.
Nate Begeman213541a2008-04-18 23:10:10 +0000487RValue CodeGenFunction::EmitLoadOfExtVectorElementLValue(LValue LV,
488 QualType ExprType) {
Eli Friedman1e692ac2008-06-13 23:01:12 +0000489 llvm::Value *Vec = Builder.CreateLoad(LV.getExtVectorAddr(),
490 LV.isVolatileQualified(), "tmp");
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000491
Nate Begeman8a997642008-05-09 06:41:27 +0000492 const llvm::Constant *Elts = LV.getExtVectorElts();
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000493
494 // If the result of the expression is a non-vector type, we must be extracting
495 // a single element. Just codegen as an extractelement.
John McCall183700f2009-09-21 23:43:11 +0000496 const VectorType *ExprVT = ExprType->getAs<VectorType>();
Chris Lattnercf60cd22007-08-10 17:10:08 +0000497 if (!ExprVT) {
Dan Gohman4f8d1232008-05-22 00:50:06 +0000498 unsigned InIdx = getAccessedFieldNo(0, Elts);
Owen Anderson0032b272009-08-13 21:57:51 +0000499 llvm::Value *Elt = llvm::ConstantInt::get(
500 llvm::Type::getInt32Ty(VMContext), InIdx);
Chris Lattner34cdc862007-08-03 16:18:34 +0000501 return RValue::get(Builder.CreateExtractElement(Vec, Elt, "tmp"));
502 }
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000503
504 // Always use shuffle vector to try to retain the original program structure
Chris Lattnercf60cd22007-08-10 17:10:08 +0000505 unsigned NumResultElts = ExprVT->getNumElements();
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000506
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000507 llvm::SmallVector<llvm::Constant*, 4> Mask;
Chris Lattner34cdc862007-08-03 16:18:34 +0000508 for (unsigned i = 0; i != NumResultElts; ++i) {
Dan Gohman4f8d1232008-05-22 00:50:06 +0000509 unsigned InIdx = getAccessedFieldNo(i, Elts);
Owen Anderson0032b272009-08-13 21:57:51 +0000510 Mask.push_back(llvm::ConstantInt::get(
511 llvm::Type::getInt32Ty(VMContext), InIdx));
Chris Lattner34cdc862007-08-03 16:18:34 +0000512 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000513
Owen Anderson4a289322009-07-28 21:22:35 +0000514 llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size());
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000515 Vec = Builder.CreateShuffleVector(Vec,
Owen Anderson03e20502009-07-30 23:11:26 +0000516 llvm::UndefValue::get(Vec->getType()),
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000517 MaskV, "tmp");
518 return RValue::get(Vec);
Chris Lattner34cdc862007-08-03 16:18:34 +0000519}
520
521
Reid Spencer5f016e22007-07-11 17:01:13 +0000522
523/// EmitStoreThroughLValue - Store the specified rvalue into the specified
524/// lvalue, where both are guaranteed to the have the same type, and that type
525/// is 'Ty'.
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000526void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst,
Reid Spencer5f016e22007-07-11 17:01:13 +0000527 QualType Ty) {
Chris Lattner017d6aa2007-08-03 16:28:33 +0000528 if (!Dst.isSimple()) {
529 if (Dst.isVectorElt()) {
530 // Read/modify/write the vector, inserting the new element.
Eli Friedman1e692ac2008-06-13 23:01:12 +0000531 llvm::Value *Vec = Builder.CreateLoad(Dst.getVectorAddr(),
532 Dst.isVolatileQualified(), "tmp");
Chris Lattner9b655512007-08-31 22:49:20 +0000533 Vec = Builder.CreateInsertElement(Vec, Src.getScalarVal(),
Chris Lattner017d6aa2007-08-03 16:28:33 +0000534 Dst.getVectorIdx(), "vecins");
Eli Friedman1e692ac2008-06-13 23:01:12 +0000535 Builder.CreateStore(Vec, Dst.getVectorAddr(),Dst.isVolatileQualified());
Chris Lattner017d6aa2007-08-03 16:28:33 +0000536 return;
537 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000538
Nate Begeman213541a2008-04-18 23:10:10 +0000539 // If this is an update of extended vector elements, insert them as
540 // appropriate.
541 if (Dst.isExtVectorElt())
542 return EmitStoreThroughExtVectorComponentLValue(Src, Dst, Ty);
Lauro Ramos Venancioa0c5d0e2008-01-22 22:36:45 +0000543
544 if (Dst.isBitfield())
545 return EmitStoreThroughBitfieldLValue(Src, Dst, Ty);
546
Daniel Dunbar85c59ed2008-08-29 08:11:39 +0000547 if (Dst.isPropertyRef())
548 return EmitStoreThroughPropertyRefLValue(Src, Dst, Ty);
549
Chris Lattnereb99b012009-10-28 17:39:19 +0000550 assert(Dst.isKVCRef() && "Unknown LValue type");
551 return EmitStoreThroughKVCRefLValue(Src, Dst, Ty);
Chris Lattner017d6aa2007-08-03 16:28:33 +0000552 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000553
Fariborz Jahanian4f676ed2009-02-21 00:30:43 +0000554 if (Dst.isObjCWeak() && !Dst.isNonGC()) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000555 // load of a __weak object.
Fariborz Jahaniandbd32c22008-11-19 17:34:06 +0000556 llvm::Value *LvalueDst = Dst.getAddress();
557 llvm::Value *src = Src.getScalarVal();
Mike Stumpf33651c2009-04-14 00:57:29 +0000558 CGM.getObjCRuntime().EmitObjCWeakAssign(*this, src, LvalueDst);
Fariborz Jahaniandbd32c22008-11-19 17:34:06 +0000559 return;
560 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000561
Fariborz Jahanian4f676ed2009-02-21 00:30:43 +0000562 if (Dst.isObjCStrong() && !Dst.isNonGC()) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000563 // load of a __strong object.
Fariborz Jahaniandbd32c22008-11-19 17:34:06 +0000564 llvm::Value *LvalueDst = Dst.getAddress();
565 llvm::Value *src = Src.getScalarVal();
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +0000566 if (Dst.isObjCIvar()) {
567 assert(Dst.getBaseIvarExp() && "BaseIvarExp is NULL");
568 const llvm::Type *ResultType = ConvertType(getContext().LongTy);
569 llvm::Value *RHS = EmitScalarExpr(Dst.getBaseIvarExp());
Fariborz Jahanian76368e82009-09-25 00:00:20 +0000570 llvm::Value *dst = RHS;
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +0000571 RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast");
572 llvm::Value *LHS =
573 Builder.CreatePtrToInt(LvalueDst, ResultType, "sub.ptr.lhs.cast");
574 llvm::Value *BytesBetween = Builder.CreateSub(LHS, RHS, "ivar.offset");
Fariborz Jahanian76368e82009-09-25 00:00:20 +0000575 CGM.getObjCRuntime().EmitObjCIvarAssign(*this, src, dst,
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +0000576 BytesBetween);
Chris Lattnereb99b012009-10-28 17:39:19 +0000577 } else if (Dst.isGlobalObjCRef())
Fariborz Jahanianbf63b872009-05-04 23:27:20 +0000578 CGM.getObjCRuntime().EmitObjCGlobalAssign(*this, src, LvalueDst);
579 else
580 CGM.getObjCRuntime().EmitObjCStrongCastAssign(*this, src, LvalueDst);
Fariborz Jahaniandbd32c22008-11-19 17:34:06 +0000581 return;
582 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000583
Chris Lattner883f6a72007-08-11 00:04:45 +0000584 assert(Src.isScalar() && "Can't emit an agg store with this method");
Anders Carlssonb4aa4662009-05-19 18:50:41 +0000585 EmitStoreOfScalar(Src.getScalarVal(), Dst.getAddress(),
586 Dst.isVolatileQualified(), Ty);
Reid Spencer5f016e22007-07-11 17:01:13 +0000587}
588
Lauro Ramos Venancioa0c5d0e2008-01-22 22:36:45 +0000589void CodeGenFunction::EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst,
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000590 QualType Ty,
Daniel Dunbared3849b2008-11-19 09:36:46 +0000591 llvm::Value **Result) {
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000592 unsigned StartBit = Dst.getBitfieldStartBit();
593 unsigned BitfieldSize = Dst.getBitfieldSize();
Lauro Ramos Venancioa0c5d0e2008-01-22 22:36:45 +0000594 llvm::Value *Ptr = Dst.getBitfieldAddr();
Lauro Ramos Venancioa0c5d0e2008-01-22 22:36:45 +0000595
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000596 const llvm::Type *EltTy =
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000597 cast<llvm::PointerType>(Ptr->getType())->getElementType();
598 unsigned EltTySize = CGM.getTargetData().getTypeSizeInBits(EltTy);
599
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000600 // Get the new value, cast to the appropriate type and masked to exactly the
601 // size of the bit-field.
Daniel Dunbared3849b2008-11-19 09:36:46 +0000602 llvm::Value *SrcVal = Src.getScalarVal();
603 llvm::Value *NewVal = Builder.CreateIntCast(SrcVal, EltTy, false, "tmp");
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000604 llvm::Constant *Mask = llvm::ConstantInt::get(VMContext,
605 llvm::APInt::getLowBitsSet(EltTySize, BitfieldSize));
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000606 NewVal = Builder.CreateAnd(NewVal, Mask, "bf.value");
Lauro Ramos Venancioa0c5d0e2008-01-22 22:36:45 +0000607
Daniel Dunbared3849b2008-11-19 09:36:46 +0000608 // Return the new value of the bit-field, if requested.
609 if (Result) {
610 // Cast back to the proper type for result.
611 const llvm::Type *SrcTy = SrcVal->getType();
612 llvm::Value *SrcTrunc = Builder.CreateIntCast(NewVal, SrcTy, false,
613 "bf.reload.val");
614
615 // Sign extend if necessary.
616 if (Dst.isBitfieldSigned()) {
617 unsigned SrcTySize = CGM.getTargetData().getTypeSizeInBits(SrcTy);
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000618 llvm::Value *ExtraBits = llvm::ConstantInt::get(SrcTy,
Daniel Dunbared3849b2008-11-19 09:36:46 +0000619 SrcTySize - BitfieldSize);
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000620 SrcTrunc = Builder.CreateAShr(Builder.CreateShl(SrcTrunc, ExtraBits),
Daniel Dunbared3849b2008-11-19 09:36:46 +0000621 ExtraBits, "bf.reload.sext");
622 }
623
624 *Result = SrcTrunc;
625 }
626
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000627 // In some cases the bitfield may straddle two memory locations. Emit the low
628 // part first and check to see if the high needs to be done.
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000629 unsigned LowBits = std::min(BitfieldSize, EltTySize - StartBit);
630 llvm::Value *LowVal = Builder.CreateLoad(Ptr, Dst.isVolatileQualified(),
631 "bf.prev.low");
Eli Friedman316bb1b2008-05-17 20:03:47 +0000632
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000633 // Compute the mask for zero-ing the low part of this bitfield.
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000634 llvm::Constant *InvMask =
Owen Anderson4a28d5d2009-07-24 23:12:58 +0000635 llvm::ConstantInt::get(VMContext,
636 ~llvm::APInt::getBitsSet(EltTySize, StartBit, StartBit + LowBits));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000637
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000638 // Compute the new low part as
639 // LowVal = (LowVal & InvMask) | (NewVal << StartBit),
640 // with the shift of NewVal implicitly stripping the high bits.
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000641 llvm::Value *NewLowVal =
Chris Lattner86b85b22009-12-06 17:22:42 +0000642 Builder.CreateShl(NewVal, StartBit, "bf.value.lo");
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000643 LowVal = Builder.CreateAnd(LowVal, InvMask, "bf.prev.lo.cleared");
644 LowVal = Builder.CreateOr(LowVal, NewLowVal, "bf.new.lo");
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000645
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000646 // Write back.
647 Builder.CreateStore(LowVal, Ptr, Dst.isVolatileQualified());
Eli Friedman316bb1b2008-05-17 20:03:47 +0000648
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000649 // If the low part doesn't cover the bitfield emit a high part.
650 if (LowBits < BitfieldSize) {
651 unsigned HighBits = BitfieldSize - LowBits;
Owen Anderson0032b272009-08-13 21:57:51 +0000652 llvm::Value *HighPtr = Builder.CreateGEP(Ptr, llvm::ConstantInt::get(
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000653 llvm::Type::getInt32Ty(VMContext), 1), "bf.ptr.hi");
654 llvm::Value *HighVal = Builder.CreateLoad(HighPtr,
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000655 Dst.isVolatileQualified(),
656 "bf.prev.hi");
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000657
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000658 // Compute the mask for zero-ing the high part of this bitfield.
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000659 llvm::Constant *InvMask =
660 llvm::ConstantInt::get(VMContext, ~llvm::APInt::getLowBitsSet(EltTySize,
Owen Andersona1cf15f2009-07-14 23:10:40 +0000661 HighBits));
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000662
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000663 // Compute the new high part as
664 // HighVal = (HighVal & InvMask) | (NewVal lshr LowBits),
665 // where the high bits of NewVal have already been cleared and the
666 // shift stripping the low bits.
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000667 llvm::Value *NewHighVal =
Chris Lattner86b85b22009-12-06 17:22:42 +0000668 Builder.CreateLShr(NewVal, LowBits, "bf.value.high");
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000669 HighVal = Builder.CreateAnd(HighVal, InvMask, "bf.prev.hi.cleared");
670 HighVal = Builder.CreateOr(HighVal, NewHighVal, "bf.new.hi");
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000671
Daniel Dunbar10e3ded2008-08-06 05:08:45 +0000672 // Write back.
673 Builder.CreateStore(HighVal, HighPtr, Dst.isVolatileQualified());
674 }
Lauro Ramos Venancioa0c5d0e2008-01-22 22:36:45 +0000675}
676
Daniel Dunbar85c59ed2008-08-29 08:11:39 +0000677void CodeGenFunction::EmitStoreThroughPropertyRefLValue(RValue Src,
678 LValue Dst,
679 QualType Ty) {
680 EmitObjCPropertySet(Dst.getPropertyRefExpr(), Src);
681}
682
Fariborz Jahanian43f44702008-11-22 22:30:21 +0000683void CodeGenFunction::EmitStoreThroughKVCRefLValue(RValue Src,
684 LValue Dst,
685 QualType Ty) {
686 EmitObjCPropertySet(Dst.getKVCRefExpr(), Src);
687}
688
Nate Begeman213541a2008-04-18 23:10:10 +0000689void CodeGenFunction::EmitStoreThroughExtVectorComponentLValue(RValue Src,
690 LValue Dst,
691 QualType Ty) {
Chris Lattner017d6aa2007-08-03 16:28:33 +0000692 // This access turns into a read/modify/write of the vector. Load the input
693 // value now.
Eli Friedman1e692ac2008-06-13 23:01:12 +0000694 llvm::Value *Vec = Builder.CreateLoad(Dst.getExtVectorAddr(),
695 Dst.isVolatileQualified(), "tmp");
Nate Begeman8a997642008-05-09 06:41:27 +0000696 const llvm::Constant *Elts = Dst.getExtVectorElts();
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000697
Chris Lattner9b655512007-08-31 22:49:20 +0000698 llvm::Value *SrcVal = Src.getScalarVal();
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000699
John McCall183700f2009-09-21 23:43:11 +0000700 if (const VectorType *VTy = Ty->getAs<VectorType>()) {
Chris Lattner7e6b51b2007-08-03 16:37:04 +0000701 unsigned NumSrcElts = VTy->getNumElements();
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000702 unsigned NumDstElts =
703 cast<llvm::VectorType>(Vec->getType())->getNumElements();
704 if (NumDstElts == NumSrcElts) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000705 // Use shuffle vector is the src and destination are the same number of
706 // elements and restore the vector mask since it is on the side it will be
707 // stored.
Nate Begeman6e5dd862009-06-26 21:12:50 +0000708 llvm::SmallVector<llvm::Constant*, 4> Mask(NumDstElts);
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000709 for (unsigned i = 0; i != NumSrcElts; ++i) {
710 unsigned InIdx = getAccessedFieldNo(i, Elts);
Owen Anderson0032b272009-08-13 21:57:51 +0000711 Mask[InIdx] = llvm::ConstantInt::get(
712 llvm::Type::getInt32Ty(VMContext), i);
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000713 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000714
Owen Anderson4a289322009-07-28 21:22:35 +0000715 llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size());
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000716 Vec = Builder.CreateShuffleVector(SrcVal,
Owen Anderson03e20502009-07-30 23:11:26 +0000717 llvm::UndefValue::get(Vec->getType()),
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000718 MaskV, "tmp");
Mike Stumpb3589f42009-07-30 22:28:39 +0000719 } else if (NumDstElts > NumSrcElts) {
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000720 // Extended the source vector to the same length and then shuffle it
721 // into the destination.
722 // FIXME: since we're shuffling with undef, can we just use the indices
723 // into that? This could be simpler.
724 llvm::SmallVector<llvm::Constant*, 4> ExtMask;
Chris Lattnereb99b012009-10-28 17:39:19 +0000725 const llvm::Type *Int32Ty = llvm::Type::getInt32Ty(VMContext);
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000726 unsigned i;
727 for (i = 0; i != NumSrcElts; ++i)
Chris Lattnereb99b012009-10-28 17:39:19 +0000728 ExtMask.push_back(llvm::ConstantInt::get(Int32Ty, i));
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000729 for (; i != NumDstElts; ++i)
Chris Lattnereb99b012009-10-28 17:39:19 +0000730 ExtMask.push_back(llvm::UndefValue::get(Int32Ty));
Owen Anderson4a289322009-07-28 21:22:35 +0000731 llvm::Value *ExtMaskV = llvm::ConstantVector::get(&ExtMask[0],
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000732 ExtMask.size());
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000733 llvm::Value *ExtSrcVal =
Daniel Dunbarbb767732009-02-17 18:31:04 +0000734 Builder.CreateShuffleVector(SrcVal,
Owen Anderson03e20502009-07-30 23:11:26 +0000735 llvm::UndefValue::get(SrcVal->getType()),
Daniel Dunbarbb767732009-02-17 18:31:04 +0000736 ExtMaskV, "tmp");
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000737 // build identity
738 llvm::SmallVector<llvm::Constant*, 4> Mask;
Chris Lattnereb99b012009-10-28 17:39:19 +0000739 for (unsigned i = 0; i != NumDstElts; ++i)
740 Mask.push_back(llvm::ConstantInt::get(Int32Ty, i));
741
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000742 // modify when what gets shuffled in
743 for (unsigned i = 0; i != NumSrcElts; ++i) {
744 unsigned Idx = getAccessedFieldNo(i, Elts);
Chris Lattnereb99b012009-10-28 17:39:19 +0000745 Mask[Idx] = llvm::ConstantInt::get(Int32Ty, i+NumDstElts);
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000746 }
Owen Anderson4a289322009-07-28 21:22:35 +0000747 llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size());
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000748 Vec = Builder.CreateShuffleVector(Vec, ExtSrcVal, MaskV, "tmp");
Mike Stumpb3589f42009-07-30 22:28:39 +0000749 } else {
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000750 // We should never shorten the vector
751 assert(0 && "unexpected shorten vector length");
Chris Lattner7e6b51b2007-08-03 16:37:04 +0000752 }
753 } else {
754 // If the Src is a scalar (not a vector) it must be updating one element.
Dan Gohman4f8d1232008-05-22 00:50:06 +0000755 unsigned InIdx = getAccessedFieldNo(0, Elts);
Chris Lattnereb99b012009-10-28 17:39:19 +0000756 const llvm::Type *Int32Ty = llvm::Type::getInt32Ty(VMContext);
757 llvm::Value *Elt = llvm::ConstantInt::get(Int32Ty, InIdx);
Chris Lattner017d6aa2007-08-03 16:28:33 +0000758 Vec = Builder.CreateInsertElement(Vec, SrcVal, Elt, "tmp");
Chris Lattner017d6aa2007-08-03 16:28:33 +0000759 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000760
Eli Friedman1e692ac2008-06-13 23:01:12 +0000761 Builder.CreateStore(Vec, Dst.getExtVectorAddr(), Dst.isVolatileQualified());
Chris Lattner017d6aa2007-08-03 16:28:33 +0000762}
763
Fariborz Jahanianb123ea32009-09-16 21:37:16 +0000764// setObjCGCLValueClass - sets class of he lvalue for the purpose of
765// generating write-barries API. It is currently a global, ivar,
766// or neither.
Chris Lattnereb99b012009-10-28 17:39:19 +0000767static void setObjCGCLValueClass(const ASTContext &Ctx, const Expr *E,
768 LValue &LV) {
Fariborz Jahanianb9242592009-09-21 23:03:37 +0000769 if (Ctx.getLangOptions().getGCMode() == LangOptions::NonGC)
Fariborz Jahanianb123ea32009-09-16 21:37:16 +0000770 return;
771
Fariborz Jahaniandbf3cfd2009-09-16 23:11:23 +0000772 if (isa<ObjCIvarRefExpr>(E)) {
773 LV.SetObjCIvar(LV, true);
Fariborz Jahanian6c7a1f32009-09-24 22:25:38 +0000774 ObjCIvarRefExpr *Exp = cast<ObjCIvarRefExpr>(const_cast<Expr*>(E));
775 LV.setBaseIvarExp(Exp->getBase());
Fariborz Jahanianfd02ed72009-09-21 18:54:29 +0000776 LV.SetObjCArray(LV, E->getType()->isArrayType());
Fariborz Jahaniandbf3cfd2009-09-16 23:11:23 +0000777 return;
778 }
Chris Lattnereb99b012009-10-28 17:39:19 +0000779
Fariborz Jahanianb123ea32009-09-16 21:37:16 +0000780 if (const DeclRefExpr *Exp = dyn_cast<DeclRefExpr>(E)) {
781 if (const VarDecl *VD = dyn_cast<VarDecl>(Exp->getDecl())) {
782 if ((VD->isBlockVarDecl() && !VD->hasLocalStorage()) ||
783 VD->isFileVarDecl())
784 LV.SetGlobalObjCRef(LV, true);
785 }
Fariborz Jahanianfd02ed72009-09-21 18:54:29 +0000786 LV.SetObjCArray(LV, E->getType()->isArrayType());
Chris Lattnereb99b012009-10-28 17:39:19 +0000787 return;
Fariborz Jahanianb123ea32009-09-16 21:37:16 +0000788 }
Chris Lattnereb99b012009-10-28 17:39:19 +0000789
790 if (const UnaryOperator *Exp = dyn_cast<UnaryOperator>(E)) {
Fariborz Jahanianb123ea32009-09-16 21:37:16 +0000791 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV);
Chris Lattnereb99b012009-10-28 17:39:19 +0000792 return;
793 }
794
795 if (const ParenExpr *Exp = dyn_cast<ParenExpr>(E)) {
Fariborz Jahanianb123ea32009-09-16 21:37:16 +0000796 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV);
Fariborz Jahanian75b08f12009-09-30 17:10:29 +0000797 if (LV.isObjCIvar()) {
798 // If cast is to a structure pointer, follow gcc's behavior and make it
799 // a non-ivar write-barrier.
800 QualType ExpTy = E->getType();
801 if (ExpTy->isPointerType())
802 ExpTy = ExpTy->getAs<PointerType>()->getPointeeType();
803 if (ExpTy->isRecordType())
804 LV.SetObjCIvar(LV, false);
Chris Lattnereb99b012009-10-28 17:39:19 +0000805 }
806 return;
Fariborz Jahanian75b08f12009-09-30 17:10:29 +0000807 }
Chris Lattnereb99b012009-10-28 17:39:19 +0000808 if (const ImplicitCastExpr *Exp = dyn_cast<ImplicitCastExpr>(E)) {
Fariborz Jahanianb123ea32009-09-16 21:37:16 +0000809 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV);
Chris Lattnereb99b012009-10-28 17:39:19 +0000810 return;
811 }
812
813 if (const CStyleCastExpr *Exp = dyn_cast<CStyleCastExpr>(E)) {
Fariborz Jahanianb123ea32009-09-16 21:37:16 +0000814 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV);
Chris Lattnereb99b012009-10-28 17:39:19 +0000815 return;
816 }
817
818 if (const ArraySubscriptExpr *Exp = dyn_cast<ArraySubscriptExpr>(E)) {
Fariborz Jahanianb123ea32009-09-16 21:37:16 +0000819 setObjCGCLValueClass(Ctx, Exp->getBase(), LV);
Fariborz Jahanianfd02ed72009-09-21 18:54:29 +0000820 if (LV.isObjCIvar() && !LV.isObjCArray())
Fariborz Jahanian1c1afc42009-09-18 00:04:00 +0000821 // Using array syntax to assigning to what an ivar points to is not
822 // same as assigning to the ivar itself. {id *Names;} Names[i] = 0;
823 LV.SetObjCIvar(LV, false);
Fariborz Jahanianfd02ed72009-09-21 18:54:29 +0000824 else if (LV.isGlobalObjCRef() && !LV.isObjCArray())
825 // Using array syntax to assigning to what global points to is not
826 // same as assigning to the global itself. {id *G;} G[i] = 0;
827 LV.SetGlobalObjCRef(LV, false);
Chris Lattnereb99b012009-10-28 17:39:19 +0000828 return;
Fariborz Jahanian1c1afc42009-09-18 00:04:00 +0000829 }
Chris Lattnereb99b012009-10-28 17:39:19 +0000830
831 if (const MemberExpr *Exp = dyn_cast<MemberExpr>(E)) {
Fariborz Jahanianb123ea32009-09-16 21:37:16 +0000832 setObjCGCLValueClass(Ctx, Exp->getBase(), LV);
Fariborz Jahanian1c1afc42009-09-18 00:04:00 +0000833 // We don't know if member is an 'ivar', but this flag is looked at
834 // only in the context of LV.isObjCIvar().
Fariborz Jahanianfd02ed72009-09-21 18:54:29 +0000835 LV.SetObjCArray(LV, E->getType()->isArrayType());
Chris Lattnereb99b012009-10-28 17:39:19 +0000836 return;
Fariborz Jahanianb123ea32009-09-16 21:37:16 +0000837 }
838}
839
Anders Carlssonce53f7d2009-11-07 23:06:58 +0000840static LValue EmitGlobalVarDeclLValue(CodeGenFunction &CGF,
841 const Expr *E, const VarDecl *VD) {
Daniel Dunbard2113f22009-11-08 09:46:46 +0000842 assert((VD->hasExternalStorage() || VD->isFileVarDecl()) &&
Anders Carlssonce53f7d2009-11-07 23:06:58 +0000843 "Var decl must have external storage or be a file var decl!");
844
845 llvm::Value *V = CGF.CGM.GetAddrOfGlobalVar(VD);
846 if (VD->getType()->isReferenceType())
847 V = CGF.Builder.CreateLoad(V, "tmp");
848 LValue LV = LValue::MakeAddr(V, CGF.MakeQualifiers(E->getType()));
849 setObjCGCLValueClass(CGF.getContext(), E, LV);
850 return LV;
851}
852
Eli Friedman9a146302009-11-26 06:08:14 +0000853static LValue EmitFunctionDeclLValue(CodeGenFunction &CGF,
854 const Expr *E, const FunctionDecl *FD) {
855 llvm::Value* V = CGF.CGM.GetAddrOfFunction(FD);
856 if (!FD->hasPrototype()) {
857 if (const FunctionProtoType *Proto =
858 FD->getType()->getAs<FunctionProtoType>()) {
859 // Ugly case: for a K&R-style definition, the type of the definition
860 // isn't the same as the type of a use. Correct for this with a
861 // bitcast.
862 QualType NoProtoType =
863 CGF.getContext().getFunctionNoProtoType(Proto->getResultType());
864 NoProtoType = CGF.getContext().getPointerType(NoProtoType);
865 V = CGF.Builder.CreateBitCast(V, CGF.ConvertType(NoProtoType), "tmp");
866 }
867 }
868 return LValue::MakeAddr(V, CGF.MakeQualifiers(E->getType()));
869}
870
Reid Spencer5f016e22007-07-11 17:01:13 +0000871LValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) {
Anders Carlsson1e74c4f2009-11-07 22:53:10 +0000872 const NamedDecl *ND = E->getDecl();
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000873
Anders Carlsson1e74c4f2009-11-07 22:53:10 +0000874 if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) {
Anders Carlsson1e74c4f2009-11-07 22:53:10 +0000875
876 // Check if this is a global variable.
Anders Carlssonce53f7d2009-11-07 23:06:58 +0000877 if (VD->hasExternalStorage() || VD->isFileVarDecl())
878 return EmitGlobalVarDeclLValue(*this, E, VD);
Anders Carlsson0bc70492009-11-07 22:46:42 +0000879
880 bool NonGCable = VD->hasLocalStorage() && !VD->hasAttr<BlocksAttr>();
881
882 llvm::Value *V = LocalDeclMap[VD];
883 assert(V && "DeclRefExpr not entered in LocalDeclMap?");
884
885 Qualifiers Quals = MakeQualifiers(E->getType());
886 // local variables do not get their gc attribute set.
887 // local static?
888 if (NonGCable) Quals.removeObjCGCAttr();
889
890 if (VD->hasAttr<BlocksAttr>()) {
891 V = Builder.CreateStructGEP(V, 1, "forwarding");
Daniel Dunbar2da84ff2009-11-29 21:23:36 +0000892 V = Builder.CreateLoad(V);
Anders Carlsson0bc70492009-11-07 22:46:42 +0000893 V = Builder.CreateStructGEP(V, getByRefValueLLVMField(VD),
894 VD->getNameAsString());
895 }
896 if (VD->getType()->isReferenceType())
897 V = Builder.CreateLoad(V, "tmp");
Anders Carlssonce53f7d2009-11-07 23:06:58 +0000898 LValue LV = LValue::MakeAddr(V, Quals);
Anders Carlsson0bc70492009-11-07 22:46:42 +0000899 LValue::SetObjCNonGC(LV, NonGCable);
Fariborz Jahanianb123ea32009-09-16 21:37:16 +0000900 setObjCGCLValueClass(getContext(), E, LV);
Fariborz Jahanian2682d8b2008-11-20 00:15:42 +0000901 return LV;
Chris Lattnereb99b012009-10-28 17:39:19 +0000902 }
903
Eli Friedman9a146302009-11-26 06:08:14 +0000904 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND))
905 return EmitFunctionDeclLValue(*this, E, FD);
Chris Lattnereb99b012009-10-28 17:39:19 +0000906
Chris Lattnereb99b012009-10-28 17:39:19 +0000907 if (E->getQualifier()) {
Douglas Gregora2813ce2009-10-23 18:54:35 +0000908 // FIXME: the qualifier check does not seem sufficient here
Anders Carlsson1e74c4f2009-11-07 22:53:10 +0000909 return EmitPointerToDataMemberLValue(cast<FieldDecl>(ND));
Chris Lattner41110242008-06-17 18:05:57 +0000910 }
Chris Lattnereb99b012009-10-28 17:39:19 +0000911
Anders Carlsson1e74c4f2009-11-07 22:53:10 +0000912 assert(false && "Unhandled DeclRefExpr");
913
914 // an invalid LValue, but the assert will
915 // ensure that this point is never reached.
Chris Lattnerb1776cb2007-09-16 19:23:47 +0000916 return LValue();
Reid Spencer5f016e22007-07-11 17:01:13 +0000917}
918
Mike Stumpa99038c2009-02-28 09:07:16 +0000919LValue CodeGenFunction::EmitBlockDeclRefLValue(const BlockDeclRefExpr *E) {
John McCall0953e762009-09-24 19:53:00 +0000920 return LValue::MakeAddr(GetAddrOfBlockDecl(E), MakeQualifiers(E->getType()));
Mike Stumpa99038c2009-02-28 09:07:16 +0000921}
922
Reid Spencer5f016e22007-07-11 17:01:13 +0000923LValue CodeGenFunction::EmitUnaryOpLValue(const UnaryOperator *E) {
924 // __extension__ doesn't affect lvalue-ness.
925 if (E->getOpcode() == UnaryOperator::Extension)
926 return EmitLValue(E->getSubExpr());
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000927
Chris Lattner96196622008-07-26 22:37:01 +0000928 QualType ExprTy = getContext().getCanonicalType(E->getSubExpr()->getType());
Chris Lattner7da36f62007-10-30 22:53:42 +0000929 switch (E->getOpcode()) {
930 default: assert(0 && "Unknown unary operator lvalue!");
Chris Lattnereb99b012009-10-28 17:39:19 +0000931 case UnaryOperator::Deref: {
932 QualType T = E->getSubExpr()->getType()->getPointeeType();
933 assert(!T.isNull() && "CodeGenFunction::EmitUnaryOpLValue: Illegal type");
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000934
Chris Lattnereb99b012009-10-28 17:39:19 +0000935 Qualifiers Quals = MakeQualifiers(T);
936 Quals.setAddressSpace(ExprTy.getAddressSpace());
John McCall0953e762009-09-24 19:53:00 +0000937
Chris Lattnereb99b012009-10-28 17:39:19 +0000938 LValue LV = LValue::MakeAddr(EmitScalarExpr(E->getSubExpr()), Quals);
939 // We should not generate __weak write barrier on indirect reference
940 // of a pointer to object; as in void foo (__weak id *param); *param = 0;
941 // But, we continue to generate __strong write barrier on indirect write
942 // into a pointer to object.
943 if (getContext().getLangOptions().ObjC1 &&
944 getContext().getLangOptions().getGCMode() != LangOptions::NonGC &&
945 LV.isObjCWeak())
946 LValue::SetObjCNonGC(LV, !E->isOBJCGCCandidate(getContext()));
947 return LV;
948 }
Chris Lattner7da36f62007-10-30 22:53:42 +0000949 case UnaryOperator::Real:
Eli Friedmane401cd52009-11-09 04:20:47 +0000950 case UnaryOperator::Imag: {
Chris Lattner7da36f62007-10-30 22:53:42 +0000951 LValue LV = EmitLValue(E->getSubExpr());
Chris Lattner36b6a0a2008-03-19 05:19:41 +0000952 unsigned Idx = E->getOpcode() == UnaryOperator::Imag;
953 return LValue::MakeAddr(Builder.CreateStructGEP(LV.getAddress(),
Chris Lattnerb77792e2008-07-26 22:17:49 +0000954 Idx, "idx"),
John McCall0953e762009-09-24 19:53:00 +0000955 MakeQualifiers(ExprTy));
Chris Lattner7da36f62007-10-30 22:53:42 +0000956 }
Eli Friedmane401cd52009-11-09 04:20:47 +0000957 case UnaryOperator::PreInc:
958 case UnaryOperator::PreDec:
959 return EmitUnsupportedLValue(E, "pre-inc/dec expression");
960 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000961}
962
963LValue CodeGenFunction::EmitStringLiteralLValue(const StringLiteral *E) {
John McCall0953e762009-09-24 19:53:00 +0000964 return LValue::MakeAddr(CGM.GetAddrOfConstantStringFromLiteral(E),
965 Qualifiers());
Reid Spencer5f016e22007-07-11 17:01:13 +0000966}
967
Chris Lattnereaf2bb82009-02-24 22:18:39 +0000968LValue CodeGenFunction::EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E) {
John McCall0953e762009-09-24 19:53:00 +0000969 return LValue::MakeAddr(CGM.GetAddrOfConstantStringFromObjCEncode(E),
970 Qualifiers());
Chris Lattnereaf2bb82009-02-24 22:18:39 +0000971}
972
973
Daniel Dunbar662b71e2008-10-17 21:58:32 +0000974LValue CodeGenFunction::EmitPredefinedFunctionName(unsigned Type) {
Anders Carlsson22742662007-07-21 05:21:51 +0000975 std::string GlobalVarName;
Daniel Dunbar662b71e2008-10-17 21:58:32 +0000976
977 switch (Type) {
Chris Lattnereb99b012009-10-28 17:39:19 +0000978 default: assert(0 && "Invalid type");
Chris Lattnereaf2bb82009-02-24 22:18:39 +0000979 case PredefinedExpr::Func:
980 GlobalVarName = "__func__.";
981 break;
982 case PredefinedExpr::Function:
983 GlobalVarName = "__FUNCTION__.";
984 break;
985 case PredefinedExpr::PrettyFunction:
Chris Lattnereaf2bb82009-02-24 22:18:39 +0000986 GlobalVarName = "__PRETTY_FUNCTION__.";
987 break;
Anders Carlsson22742662007-07-21 05:21:51 +0000988 }
Daniel Dunbar662b71e2008-10-17 21:58:32 +0000989
Daniel Dunbar0a23d762009-09-12 23:06:21 +0000990 llvm::StringRef FnName = CurFn->getName();
991 if (FnName.startswith("\01"))
992 FnName = FnName.substr(1);
993 GlobalVarName += FnName;
994
Anders Carlsson3a082d82009-09-08 18:24:21 +0000995 std::string FunctionName =
Mike Stump1eb44332009-09-09 15:08:12 +0000996 PredefinedExpr::ComputeName(getContext(), (PredefinedExpr::IdentType)Type,
Anders Carlsson3a082d82009-09-08 18:24:21 +0000997 CurCodeDecl);
Daniel Dunbar662b71e2008-10-17 21:58:32 +0000998
Mike Stumpdb52dcd2009-09-09 13:00:44 +0000999 llvm::Constant *C =
Daniel Dunbar662b71e2008-10-17 21:58:32 +00001000 CGM.GetAddrOfConstantCString(FunctionName, GlobalVarName.c_str());
John McCall0953e762009-09-24 19:53:00 +00001001 return LValue::MakeAddr(C, Qualifiers());
Daniel Dunbar662b71e2008-10-17 21:58:32 +00001002}
1003
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001004LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) {
Daniel Dunbar662b71e2008-10-17 21:58:32 +00001005 switch (E->getIdentType()) {
1006 default:
1007 return EmitUnsupportedLValue(E, "predefined expression");
1008 case PredefinedExpr::Func:
1009 case PredefinedExpr::Function:
1010 case PredefinedExpr::PrettyFunction:
1011 return EmitPredefinedFunctionName(E->getIdentType());
1012 }
Anders Carlsson22742662007-07-21 05:21:51 +00001013}
1014
Reid Spencer5f016e22007-07-11 17:01:13 +00001015LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) {
Ted Kremenek23245122007-08-20 16:18:38 +00001016 // The index must always be an integer, which is not an aggregate. Emit it.
Chris Lattner7f02f722007-08-24 05:35:26 +00001017 llvm::Value *Idx = EmitScalarExpr(E->getIdx());
Eli Friedman61d004a2009-06-06 19:09:26 +00001018 QualType IdxTy = E->getIdx()->getType();
1019 bool IdxSigned = IdxTy->isSignedIntegerType();
1020
Reid Spencer5f016e22007-07-11 17:01:13 +00001021 // If the base is a vector type, then we are forming a vector element lvalue
1022 // with this subscript.
Eli Friedman1e692ac2008-06-13 23:01:12 +00001023 if (E->getBase()->getType()->isVectorType()) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001024 // Emit the vector as an lvalue to get its address.
Eli Friedman1e692ac2008-06-13 23:01:12 +00001025 LValue LHS = EmitLValue(E->getBase());
Ted Kremenek23245122007-08-20 16:18:38 +00001026 assert(LHS.isSimple() && "Can only subscript lvalue vectors here!");
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001027 Idx = Builder.CreateIntCast(Idx,
Owen Anderson0032b272009-08-13 21:57:51 +00001028 llvm::Type::getInt32Ty(VMContext), IdxSigned, "vidx");
Eli Friedman1e692ac2008-06-13 23:01:12 +00001029 return LValue::MakeVectorElt(LHS.getAddress(), Idx,
John McCall0953e762009-09-24 19:53:00 +00001030 E->getBase()->getType().getCVRQualifiers());
Reid Spencer5f016e22007-07-11 17:01:13 +00001031 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001032
Ted Kremenek23245122007-08-20 16:18:38 +00001033 // The base must be a pointer, which is not an aggregate. Emit it.
Chris Lattner7f02f722007-08-24 05:35:26 +00001034 llvm::Value *Base = EmitScalarExpr(E->getBase());
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001035
Ted Kremenek23245122007-08-20 16:18:38 +00001036 // Extend or truncate the index type to 32 or 64-bits.
Reid Spencer5f016e22007-07-11 17:01:13 +00001037 unsigned IdxBitwidth = cast<llvm::IntegerType>(Idx->getType())->getBitWidth();
Sanjiv Gupta7cabee52009-04-24 02:40:57 +00001038 if (IdxBitwidth != LLVMPointerWidth)
Owen Anderson0032b272009-08-13 21:57:51 +00001039 Idx = Builder.CreateIntCast(Idx,
1040 llvm::IntegerType::get(VMContext, LLVMPointerWidth),
Reid Spencer5f016e22007-07-11 17:01:13 +00001041 IdxSigned, "idxprom");
1042
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001043 // We know that the pointer points to a type of the correct size, unless the
1044 // size is a VLA or Objective-C interface.
Daniel Dunbar2a866252009-04-25 05:08:32 +00001045 llvm::Value *Address = 0;
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001046 if (const VariableArrayType *VAT =
Anders Carlsson8b33c082008-12-21 00:11:23 +00001047 getContext().getAsVariableArrayType(E->getType())) {
Chris Lattner881eb9c2009-08-14 23:43:22 +00001048 llvm::Value *VLASize = GetVLASize(VAT);
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001049
Anders Carlsson8b33c082008-12-21 00:11:23 +00001050 Idx = Builder.CreateMul(Idx, VLASize);
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001051
Anders Carlsson6183a992008-12-21 03:44:36 +00001052 QualType BaseType = getContext().getBaseElementType(VAT);
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001053
Anders Carlsson8b33c082008-12-21 00:11:23 +00001054 uint64_t BaseTypeSize = getContext().getTypeSize(BaseType) / 8;
1055 Idx = Builder.CreateUDiv(Idx,
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001056 llvm::ConstantInt::get(Idx->getType(),
Anders Carlsson8b33c082008-12-21 00:11:23 +00001057 BaseTypeSize));
Dan Gohman664f8932009-08-12 00:33:55 +00001058 Address = Builder.CreateInBoundsGEP(Base, Idx, "arrayidx");
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001059 } else if (const ObjCInterfaceType *OIT =
Daniel Dunbar2a866252009-04-25 05:08:32 +00001060 dyn_cast<ObjCInterfaceType>(E->getType())) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001061 llvm::Value *InterfaceSize =
Owen Anderson4a28d5d2009-07-24 23:12:58 +00001062 llvm::ConstantInt::get(Idx->getType(),
Daniel Dunbar2a866252009-04-25 05:08:32 +00001063 getContext().getTypeSize(OIT) / 8);
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001064
Daniel Dunbar2a866252009-04-25 05:08:32 +00001065 Idx = Builder.CreateMul(Idx, InterfaceSize);
1066
Benjamin Kramer3c0ef8c2009-10-13 10:07:13 +00001067 const llvm::Type *i8PTy = llvm::Type::getInt8PtrTy(VMContext);
Dan Gohman664f8932009-08-12 00:33:55 +00001068 Address = Builder.CreateGEP(Builder.CreateBitCast(Base, i8PTy),
Daniel Dunbar2a866252009-04-25 05:08:32 +00001069 Idx, "arrayidx");
1070 Address = Builder.CreateBitCast(Address, Base->getType());
1071 } else {
Dan Gohman664f8932009-08-12 00:33:55 +00001072 Address = Builder.CreateInBoundsGEP(Base, Idx, "arrayidx");
Anders Carlsson8b33c082008-12-21 00:11:23 +00001073 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001074
Steve Naroff14108da2009-07-10 23:34:53 +00001075 QualType T = E->getBase()->getType()->getPointeeType();
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001076 assert(!T.isNull() &&
Steve Naroff14108da2009-07-10 23:34:53 +00001077 "CodeGenFunction::EmitArraySubscriptExpr(): Illegal base type");
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001078
John McCall0953e762009-09-24 19:53:00 +00001079 Qualifiers Quals = MakeQualifiers(T);
1080 Quals.setAddressSpace(E->getBase()->getType().getAddressSpace());
1081
1082 LValue LV = LValue::MakeAddr(Address, Quals);
Fariborz Jahanian643887a2009-02-21 23:37:19 +00001083 if (getContext().getLangOptions().ObjC1 &&
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001084 getContext().getLangOptions().getGCMode() != LangOptions::NonGC) {
Fariborz Jahanian102e3902009-06-01 21:29:32 +00001085 LValue::SetObjCNonGC(LV, !E->isOBJCGCCandidate(getContext()));
Fariborz Jahanianb123ea32009-09-16 21:37:16 +00001086 setObjCGCLValueClass(getContext(), E, LV);
1087 }
Fariborz Jahanian643887a2009-02-21 23:37:19 +00001088 return LV;
Reid Spencer5f016e22007-07-11 17:01:13 +00001089}
1090
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001091static
Owen Andersona1cf15f2009-07-14 23:10:40 +00001092llvm::Constant *GenerateConstantVector(llvm::LLVMContext &VMContext,
1093 llvm::SmallVector<unsigned, 4> &Elts) {
Nate Begeman3b8d1162008-05-13 21:03:02 +00001094 llvm::SmallVector<llvm::Constant *, 4> CElts;
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001095
Nate Begeman3b8d1162008-05-13 21:03:02 +00001096 for (unsigned i = 0, e = Elts.size(); i != e; ++i)
Owen Anderson0032b272009-08-13 21:57:51 +00001097 CElts.push_back(llvm::ConstantInt::get(
1098 llvm::Type::getInt32Ty(VMContext), Elts[i]));
Nate Begeman3b8d1162008-05-13 21:03:02 +00001099
Owen Anderson4a289322009-07-28 21:22:35 +00001100 return llvm::ConstantVector::get(&CElts[0], CElts.size());
Nate Begeman3b8d1162008-05-13 21:03:02 +00001101}
1102
Chris Lattner349aaec2007-08-02 23:37:31 +00001103LValue CodeGenFunction::
Nate Begeman213541a2008-04-18 23:10:10 +00001104EmitExtVectorElementExpr(const ExtVectorElementExpr *E) {
Chris Lattner349aaec2007-08-02 23:37:31 +00001105 // Emit the base vector as an l-value.
Chris Lattner73525de2009-02-16 21:11:58 +00001106 LValue Base;
1107
1108 // ExtVectorElementExpr's base can either be a vector or pointer to vector.
Chris Lattner2140e902009-02-16 22:14:05 +00001109 if (!E->isArrow()) {
Chris Lattner73525de2009-02-16 21:11:58 +00001110 assert(E->getBase()->getType()->isVectorType());
1111 Base = EmitLValue(E->getBase());
Chris Lattner2140e902009-02-16 22:14:05 +00001112 } else {
Ted Kremenek6217b802009-07-29 21:53:49 +00001113 const PointerType *PT = E->getBase()->getType()->getAs<PointerType>();
Chris Lattner2140e902009-02-16 22:14:05 +00001114 llvm::Value *Ptr = EmitScalarExpr(E->getBase());
John McCall0953e762009-09-24 19:53:00 +00001115 Qualifiers Quals = MakeQualifiers(PT->getPointeeType());
1116 Quals.removeObjCGCAttr();
1117 Base = LValue::MakeAddr(Ptr, Quals);
Chris Lattner73525de2009-02-16 21:11:58 +00001118 }
Chris Lattner349aaec2007-08-02 23:37:31 +00001119
Nate Begeman3b8d1162008-05-13 21:03:02 +00001120 // Encode the element access list into a vector of unsigned indices.
1121 llvm::SmallVector<unsigned, 4> Indices;
1122 E->getEncodedElementAccess(Indices);
1123
1124 if (Base.isSimple()) {
Owen Andersona1cf15f2009-07-14 23:10:40 +00001125 llvm::Constant *CV = GenerateConstantVector(VMContext, Indices);
Eli Friedman1e692ac2008-06-13 23:01:12 +00001126 return LValue::MakeExtVectorElt(Base.getAddress(), CV,
John McCall0953e762009-09-24 19:53:00 +00001127 Base.getVRQualifiers());
Nate Begeman3b8d1162008-05-13 21:03:02 +00001128 }
1129 assert(Base.isExtVectorElt() && "Can only subscript lvalue vec elts here!");
1130
1131 llvm::Constant *BaseElts = Base.getExtVectorElts();
1132 llvm::SmallVector<llvm::Constant *, 4> CElts;
1133
Chris Lattner67665862009-10-28 05:12:07 +00001134 const llvm::Type *Int32Ty = llvm::Type::getInt32Ty(VMContext);
Nate Begeman3b8d1162008-05-13 21:03:02 +00001135 for (unsigned i = 0, e = Indices.size(); i != e; ++i) {
1136 if (isa<llvm::ConstantAggregateZero>(BaseElts))
Chris Lattner67665862009-10-28 05:12:07 +00001137 CElts.push_back(llvm::ConstantInt::get(Int32Ty, 0));
Nate Begeman3b8d1162008-05-13 21:03:02 +00001138 else
Chris Lattner67665862009-10-28 05:12:07 +00001139 CElts.push_back(cast<llvm::Constant>(BaseElts->getOperand(Indices[i])));
Nate Begeman3b8d1162008-05-13 21:03:02 +00001140 }
Owen Anderson4a289322009-07-28 21:22:35 +00001141 llvm::Constant *CV = llvm::ConstantVector::get(&CElts[0], CElts.size());
Eli Friedman1e692ac2008-06-13 23:01:12 +00001142 return LValue::MakeExtVectorElt(Base.getExtVectorAddr(), CV,
John McCall0953e762009-09-24 19:53:00 +00001143 Base.getVRQualifiers());
Chris Lattner349aaec2007-08-02 23:37:31 +00001144}
1145
Devang Patelb9b00ad2007-10-23 20:28:39 +00001146LValue CodeGenFunction::EmitMemberExpr(const MemberExpr *E) {
Devang Patelfe2419a2007-12-11 21:33:16 +00001147 bool isUnion = false;
Fariborz Jahanian4f676ed2009-02-21 00:30:43 +00001148 bool isNonGC = false;
Devang Patel126a8562007-10-24 22:26:28 +00001149 Expr *BaseExpr = E->getBase();
Devang Patel126a8562007-10-24 22:26:28 +00001150 llvm::Value *BaseValue = NULL;
John McCall0953e762009-09-24 19:53:00 +00001151 Qualifiers BaseQuals;
Eli Friedman1e692ac2008-06-13 23:01:12 +00001152
Chris Lattner12f65f62007-12-02 18:52:07 +00001153 // 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 +00001154 if (E->isArrow()) {
Devang Patel0a961182007-10-26 18:15:21 +00001155 BaseValue = EmitScalarExpr(BaseExpr);
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001156 const PointerType *PTy =
Ted Kremenek6217b802009-07-29 21:53:49 +00001157 BaseExpr->getType()->getAs<PointerType>();
Devang Patelfe2419a2007-12-11 21:33:16 +00001158 if (PTy->getPointeeType()->isUnionType())
1159 isUnion = true;
John McCall0953e762009-09-24 19:53:00 +00001160 BaseQuals = PTy->getPointeeType().getQualifiers();
Fariborz Jahaniand2e1eb02009-09-01 17:02:21 +00001161 } else if (isa<ObjCPropertyRefExpr>(BaseExpr->IgnoreParens()) ||
1162 isa<ObjCImplicitSetterGetterRefExpr>(
1163 BaseExpr->IgnoreParens())) {
Fariborz Jahanian35c33292009-01-12 23:27:26 +00001164 RValue RV = EmitObjCPropertyGet(BaseExpr);
1165 BaseValue = RV.getAggregateAddr();
1166 if (BaseExpr->getType()->isUnionType())
1167 isUnion = true;
John McCall0953e762009-09-24 19:53:00 +00001168 BaseQuals = BaseExpr->getType().getQualifiers();
Chris Lattner1bd885e2009-02-16 22:25:49 +00001169 } else {
Chris Lattner12f65f62007-12-02 18:52:07 +00001170 LValue BaseLV = EmitLValue(BaseExpr);
Fariborz Jahanian4f676ed2009-02-21 00:30:43 +00001171 if (BaseLV.isNonGC())
1172 isNonGC = true;
Chris Lattner12f65f62007-12-02 18:52:07 +00001173 // FIXME: this isn't right for bitfields.
1174 BaseValue = BaseLV.getAddress();
Fariborz Jahaniana91d6a62009-07-29 00:44:13 +00001175 QualType BaseTy = BaseExpr->getType();
1176 if (BaseTy->isUnionType())
Devang Patelfe2419a2007-12-11 21:33:16 +00001177 isUnion = true;
John McCall0953e762009-09-24 19:53:00 +00001178 BaseQuals = BaseTy.getQualifiers();
Chris Lattner12f65f62007-12-02 18:52:07 +00001179 }
Devang Patelb9b00ad2007-10-23 20:28:39 +00001180
Anders Carlssonce53f7d2009-11-07 23:06:58 +00001181 NamedDecl *ND = E->getMemberDecl();
1182 if (FieldDecl *Field = dyn_cast<FieldDecl>(ND)) {
1183 LValue LV = EmitLValueForField(BaseValue, Field, isUnion,
1184 BaseQuals.getCVRQualifiers());
1185 LValue::SetObjCNonGC(LV, isNonGC);
1186 setObjCGCLValueClass(getContext(), E, LV);
1187 return LV;
1188 }
1189
Anders Carlsson589f9e32009-11-07 23:16:50 +00001190 if (VarDecl *VD = dyn_cast<VarDecl>(ND))
1191 return EmitGlobalVarDeclLValue(*this, E, VD);
Eli Friedman9a146302009-11-26 06:08:14 +00001192
1193 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND))
1194 return EmitFunctionDeclLValue(*this, E, FD);
1195
Anders Carlssonce53f7d2009-11-07 23:06:58 +00001196 assert(false && "Unhandled member declaration!");
1197 return LValue();
Eli Friedman472778e2008-02-09 08:50:58 +00001198}
Devang Patelb9b00ad2007-10-23 20:28:39 +00001199
Fariborz Jahanianfd64bb62008-12-15 20:35:07 +00001200LValue CodeGenFunction::EmitLValueForBitfield(llvm::Value* BaseValue,
Anders Carlsson0ed303c2009-11-17 03:57:07 +00001201 const FieldDecl* Field,
Fariborz Jahanian598d3f62009-02-03 19:03:09 +00001202 unsigned CVRQualifiers) {
Anders Carlsson8330cee2009-07-23 17:01:21 +00001203 CodeGenTypes::BitFieldInfo Info = CGM.getTypes().getBitFieldInfo(Field);
1204
Mike Stumpf5408fe2009-05-16 07:57:57 +00001205 // FIXME: CodeGenTypes should expose a method to get the appropriate type for
1206 // FieldTy (the appropriate type is ABI-dependent).
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001207 const llvm::Type *FieldTy =
Daniel Dunbarbb767732009-02-17 18:31:04 +00001208 CGM.getTypes().ConvertTypeForMem(Field->getType());
Fariborz Jahanianfd64bb62008-12-15 20:35:07 +00001209 const llvm::PointerType *BaseTy =
1210 cast<llvm::PointerType>(BaseValue->getType());
1211 unsigned AS = BaseTy->getAddressSpace();
1212 BaseValue = Builder.CreateBitCast(BaseValue,
Owen Anderson96e0fc72009-07-29 22:16:19 +00001213 llvm::PointerType::get(FieldTy, AS),
Fariborz Jahanianfd64bb62008-12-15 20:35:07 +00001214 "tmp");
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001215
1216 llvm::Value *Idx =
Owen Anderson0032b272009-08-13 21:57:51 +00001217 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), Info.FieldNo);
Anders Carlsson8330cee2009-07-23 17:01:21 +00001218 llvm::Value *V = Builder.CreateGEP(BaseValue, Idx, "tmp");
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001219
Anders Carlsson8330cee2009-07-23 17:01:21 +00001220 return LValue::MakeBitfield(V, Info.Start, Info.Size,
Fariborz Jahanianfd64bb62008-12-15 20:35:07 +00001221 Field->getType()->isSignedIntegerType(),
1222 Field->getType().getCVRQualifiers()|CVRQualifiers);
1223}
1224
Eli Friedman472778e2008-02-09 08:50:58 +00001225LValue CodeGenFunction::EmitLValueForField(llvm::Value* BaseValue,
Anders Carlsson0ed303c2009-11-17 03:57:07 +00001226 const FieldDecl* Field,
Eli Friedman1e692ac2008-06-13 23:01:12 +00001227 bool isUnion,
Mike Stump1eb44332009-09-09 15:08:12 +00001228 unsigned CVRQualifiers) {
Fariborz Jahanianfd64bb62008-12-15 20:35:07 +00001229 if (Field->isBitField())
Fariborz Jahanian598d3f62009-02-03 19:03:09 +00001230 return EmitLValueForBitfield(BaseValue, Field, CVRQualifiers);
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001231
Fariborz Jahanian598d3f62009-02-03 19:03:09 +00001232 unsigned idx = CGM.getTypes().getLLVMFieldNo(Field);
Fariborz Jahanianfd64bb62008-12-15 20:35:07 +00001233 llvm::Value *V = Builder.CreateStructGEP(BaseValue, idx, "tmp");
Eli Friedman1e86b342008-05-29 11:33:25 +00001234
Devang Patelabad06c2007-10-26 19:42:18 +00001235 // Match union field type.
Lauro Ramos Venanciod957aa02008-02-07 19:29:53 +00001236 if (isUnion) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001237 const llvm::Type *FieldTy =
Eli Friedman1e692ac2008-06-13 23:01:12 +00001238 CGM.getTypes().ConvertTypeForMem(Field->getType());
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001239 const llvm::PointerType * BaseTy =
Devang Patele9b8c0a2007-10-30 20:59:40 +00001240 cast<llvm::PointerType>(BaseValue->getType());
Eli Friedman788d5712008-05-21 13:24:44 +00001241 unsigned AS = BaseTy->getAddressSpace();
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001242 V = Builder.CreateBitCast(V,
1243 llvm::PointerType::get(FieldTy, AS),
Eli Friedman788d5712008-05-21 13:24:44 +00001244 "tmp");
Devang Patelabad06c2007-10-26 19:42:18 +00001245 }
Eli Friedman2be58612009-05-30 21:09:44 +00001246 if (Field->getType()->isReferenceType())
1247 V = Builder.CreateLoad(V, "tmp");
John McCall0953e762009-09-24 19:53:00 +00001248
1249 Qualifiers Quals = MakeQualifiers(Field->getType());
1250 Quals.addCVRQualifiers(CVRQualifiers);
Fariborz Jahanianfd02ed72009-09-21 18:54:29 +00001251 // __weak attribute on a field is ignored.
John McCall0953e762009-09-24 19:53:00 +00001252 if (Quals.getObjCGCAttr() == Qualifiers::Weak)
1253 Quals.removeObjCGCAttr();
Fariborz Jahanianfd02ed72009-09-21 18:54:29 +00001254
John McCall0953e762009-09-24 19:53:00 +00001255 return LValue::MakeAddr(V, Quals);
Devang Patelb9b00ad2007-10-23 20:28:39 +00001256}
1257
Chris Lattner75dfeda2009-03-18 18:28:57 +00001258LValue CodeGenFunction::EmitCompoundLiteralLValue(const CompoundLiteralExpr* E){
Eli Friedman06e863f2008-05-13 23:18:27 +00001259 const llvm::Type *LTy = ConvertType(E->getType());
1260 llvm::Value *DeclPtr = CreateTempAlloca(LTy, ".compoundliteral");
1261
1262 const Expr* InitExpr = E->getInitializer();
John McCall0953e762009-09-24 19:53:00 +00001263 LValue Result = LValue::MakeAddr(DeclPtr, MakeQualifiers(E->getType()));
Eli Friedman06e863f2008-05-13 23:18:27 +00001264
Chris Lattnereb99b012009-10-28 17:39:19 +00001265 if (E->getType()->isComplexType())
Eli Friedman06e863f2008-05-13 23:18:27 +00001266 EmitComplexExprIntoAddr(InitExpr, DeclPtr, false);
Chris Lattnereb99b012009-10-28 17:39:19 +00001267 else if (hasAggregateLLVMType(E->getType()))
Eli Friedman06e863f2008-05-13 23:18:27 +00001268 EmitAnyExpr(InitExpr, DeclPtr, false);
Chris Lattnereb99b012009-10-28 17:39:19 +00001269 else
Eli Friedman06e863f2008-05-13 23:18:27 +00001270 EmitStoreThroughLValue(EmitAnyExpr(InitExpr), Result, E->getType());
Eli Friedman06e863f2008-05-13 23:18:27 +00001271
1272 return Result;
1273}
1274
Anders Carlsson6fcec8b2009-09-15 16:35:24 +00001275LValue
1276CodeGenFunction::EmitConditionalOperatorLValue(const ConditionalOperator* E) {
1277 if (E->isLvalue(getContext()) == Expr::LV_Valid) {
1278 llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true");
1279 llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false");
1280 llvm::BasicBlock *ContBlock = createBasicBlock("cond.end");
1281
1282 llvm::Value *Cond = EvaluateExprAsBool(E->getCond());
1283 Builder.CreateCondBr(Cond, LHSBlock, RHSBlock);
1284
1285 EmitBlock(LHSBlock);
Daniel Dunbar90345582009-03-24 02:38:23 +00001286
Anders Carlsson6fcec8b2009-09-15 16:35:24 +00001287 LValue LHS = EmitLValue(E->getLHS());
1288 if (!LHS.isSimple())
1289 return EmitUnsupportedLValue(E, "conditional operator");
1290
Chris Lattnereb99b012009-10-28 17:39:19 +00001291 llvm::Value *Temp = CreateTempAlloca(LHS.getAddress()->getType(),"condtmp");
Anders Carlsson6fcec8b2009-09-15 16:35:24 +00001292 Builder.CreateStore(LHS.getAddress(), Temp);
1293 EmitBranch(ContBlock);
1294
1295 EmitBlock(RHSBlock);
1296 LValue RHS = EmitLValue(E->getRHS());
1297 if (!RHS.isSimple())
1298 return EmitUnsupportedLValue(E, "conditional operator");
1299
1300 Builder.CreateStore(RHS.getAddress(), Temp);
1301 EmitBranch(ContBlock);
1302
1303 EmitBlock(ContBlock);
1304
1305 Temp = Builder.CreateLoad(Temp, "lv");
John McCall0953e762009-09-24 19:53:00 +00001306 return LValue::MakeAddr(Temp, MakeQualifiers(E->getType()));
Anders Carlsson6fcec8b2009-09-15 16:35:24 +00001307 }
1308
Daniel Dunbar90345582009-03-24 02:38:23 +00001309 // ?: here should be an aggregate.
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001310 assert((hasAggregateLLVMType(E->getType()) &&
Daniel Dunbar90345582009-03-24 02:38:23 +00001311 !E->getType()->isAnyComplexType()) &&
1312 "Unexpected conditional operator!");
1313
1314 llvm::Value *Temp = CreateTempAlloca(ConvertType(E->getType()));
1315 EmitAggExpr(E, Temp, false);
1316
John McCall0953e762009-09-24 19:53:00 +00001317 return LValue::MakeAddr(Temp, MakeQualifiers(E->getType()));
Daniel Dunbar90345582009-03-24 02:38:23 +00001318}
1319
Mike Stumpc849c052009-11-16 06:50:58 +00001320/// EmitCastLValue - Casts are never lvalues unless that cast is a dynamic_cast.
1321/// If the cast is a dynamic_cast, we can have the usual lvalue result,
1322/// otherwise if a cast is needed by the code generator in an lvalue context,
1323/// then it must mean that we need the address of an aggregate in order to
1324/// access one of its fields. This can happen for all the reasons that casts
1325/// are permitted with aggregate result, including noop aggregate casts, and
1326/// cast from scalar to union.
Chris Lattner75dfeda2009-03-18 18:28:57 +00001327LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) {
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00001328 switch (E->getCastKind()) {
1329 default:
Eli Friedmaneaae78a2009-11-16 05:48:01 +00001330 return EmitUnsupportedLValue(E, "unexpected cast lvalue");
1331
Mike Stumpc849c052009-11-16 06:50:58 +00001332 case CastExpr::CK_Dynamic: {
1333 LValue LV = EmitLValue(E->getSubExpr());
1334 llvm::Value *V = LV.getAddress();
1335 const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(E);
1336 return LValue::MakeAddr(EmitDynamicCast(V, DCE),
1337 MakeQualifiers(E->getType()));
1338 }
1339
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00001340 case CastExpr::CK_NoOp:
1341 case CastExpr::CK_ConstructorConversion:
1342 case CastExpr::CK_UserDefinedConversion:
Chris Lattner75dfeda2009-03-18 18:28:57 +00001343 return EmitLValue(E->getSubExpr());
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00001344
1345 case CastExpr::CK_DerivedToBase: {
1346 const RecordType *DerivedClassTy =
1347 E->getSubExpr()->getType()->getAs<RecordType>();
1348 CXXRecordDecl *DerivedClassDecl =
1349 cast<CXXRecordDecl>(DerivedClassTy->getDecl());
Chris Lattner75dfeda2009-03-18 18:28:57 +00001350
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00001351 const RecordType *BaseClassTy = E->getType()->getAs<RecordType>();
1352 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseClassTy->getDecl());
1353
1354 LValue LV = EmitLValue(E->getSubExpr());
1355
1356 // Perform the derived-to-base conversion
1357 llvm::Value *Base =
Anders Carlssona3697c92009-11-23 17:57:54 +00001358 GetAddressOfBaseClass(LV.getAddress(), DerivedClassDecl,
1359 BaseClassDecl, /*NullCheckValue=*/false);
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00001360
John McCall0953e762009-09-24 19:53:00 +00001361 return LValue::MakeAddr(Base, MakeQualifiers(E->getType()));
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00001362 }
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00001363 case CastExpr::CK_ToUnion: {
1364 llvm::Value *Temp = CreateTempAlloca(ConvertType(E->getType()));
1365 EmitAnyExpr(E->getSubExpr(), Temp, false);
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001366
John McCall0953e762009-09-24 19:53:00 +00001367 return LValue::MakeAddr(Temp, MakeQualifiers(E->getType()));
Anders Carlsson658e8122009-11-14 21:21:42 +00001368 }
Eli Friedmaneaae78a2009-11-16 05:48:01 +00001369 case CastExpr::CK_BaseToDerived: {
Anders Carlssona3697c92009-11-23 17:57:54 +00001370 const RecordType *BaseClassTy =
1371 E->getSubExpr()->getType()->getAs<RecordType>();
1372 CXXRecordDecl *BaseClassDecl =
1373 cast<CXXRecordDecl>(BaseClassTy->getDecl());
1374
1375 const RecordType *DerivedClassTy = E->getType()->getAs<RecordType>();
1376 CXXRecordDecl *DerivedClassDecl =
1377 cast<CXXRecordDecl>(DerivedClassTy->getDecl());
1378
1379 LValue LV = EmitLValue(E->getSubExpr());
1380
1381 // Perform the base-to-derived conversion
1382 llvm::Value *Derived =
1383 GetAddressOfDerivedClass(LV.getAddress(), BaseClassDecl,
1384 DerivedClassDecl, /*NullCheckValue=*/false);
1385
1386 return LValue::MakeAddr(Derived, MakeQualifiers(E->getType()));
Eli Friedmaneaae78a2009-11-16 05:48:01 +00001387 }
Anders Carlsson658e8122009-11-14 21:21:42 +00001388 case CastExpr::CK_BitCast: {
Eli Friedmaneaae78a2009-11-16 05:48:01 +00001389 // This must be a reinterpret_cast (or c-style equivalent).
1390 const ExplicitCastExpr *CE = cast<ExplicitCastExpr>(E);
Anders Carlsson658e8122009-11-14 21:21:42 +00001391
1392 LValue LV = EmitLValue(E->getSubExpr());
1393 llvm::Value *V = Builder.CreateBitCast(LV.getAddress(),
1394 ConvertType(CE->getTypeAsWritten()));
1395 return LValue::MakeAddr(V, MakeQualifiers(E->getType()));
1396 }
Anders Carlsson0ee33cf2009-09-12 16:16:49 +00001397 }
Chris Lattner75dfeda2009-03-18 18:28:57 +00001398}
1399
Fariborz Jahanian48620ba2009-10-20 23:29:04 +00001400LValue CodeGenFunction::EmitNullInitializationLValue(
1401 const CXXZeroInitValueExpr *E) {
1402 QualType Ty = E->getType();
1403 const llvm::Type *LTy = ConvertTypeForMem(Ty);
1404 llvm::AllocaInst *Alloc = CreateTempAlloca(LTy);
1405 unsigned Align = getContext().getTypeAlign(Ty)/8;
1406 Alloc->setAlignment(Align);
1407 LValue lvalue = LValue::MakeAddr(Alloc, Qualifiers());
1408 EmitMemSetToZero(lvalue.getAddress(), Ty);
1409 return lvalue;
1410}
1411
Reid Spencer5f016e22007-07-11 17:01:13 +00001412//===--------------------------------------------------------------------===//
1413// Expression Emission
1414//===--------------------------------------------------------------------===//
1415
Chris Lattner7016a702007-08-20 22:37:10 +00001416
Reid Spencer5f016e22007-07-11 17:01:13 +00001417RValue CodeGenFunction::EmitCallExpr(const CallExpr *E) {
Daniel Dunbarc0ef9f52009-02-20 18:06:48 +00001418 // Builtins never have block type.
Daniel Dunbarce1d38b2009-01-09 16:50:52 +00001419 if (E->getCallee()->getType()->isBlockPointerType())
Anders Carlssonacfde802009-02-12 00:39:25 +00001420 return EmitBlockCallExpr(E);
Daniel Dunbarce1d38b2009-01-09 16:50:52 +00001421
Anders Carlsson774e7c62009-04-03 22:50:24 +00001422 if (const CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(E))
1423 return EmitCXXMemberCallExpr(CE);
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001424
Daniel Dunbarc0ef9f52009-02-20 18:06:48 +00001425 const Decl *TargetDecl = 0;
Daniel Dunbardd7b8972009-02-20 19:34:33 +00001426 if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E->getCallee())) {
1427 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CE->getSubExpr())) {
1428 TargetDecl = DRE->getDecl();
1429 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(TargetDecl))
Douglas Gregor7814e6d2009-09-12 00:22:50 +00001430 if (unsigned builtinID = FD->getBuiltinID())
Daniel Dunbardd7b8972009-02-20 19:34:33 +00001431 return EmitBuiltinExpr(FD, builtinID, E);
Daniel Dunbarc0ef9f52009-02-20 18:06:48 +00001432 }
1433 }
1434
Chris Lattner5db7ae52009-06-13 00:26:38 +00001435 if (const CXXOperatorCallExpr *CE = dyn_cast<CXXOperatorCallExpr>(E))
Anders Carlsson0f294632009-05-27 04:18:27 +00001436 if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(TargetDecl))
1437 return EmitCXXOperatorMemberCallExpr(CE, MD);
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001438
Eli Friedmanc4451db2009-12-08 02:09:46 +00001439 if (isa<CXXPseudoDestructorExpr>(E->getCallee()->IgnoreParens())) {
Douglas Gregora71d8192009-09-04 17:36:40 +00001440 // C++ [expr.pseudo]p1:
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001441 // The result shall only be used as the operand for the function call
Douglas Gregora71d8192009-09-04 17:36:40 +00001442 // operator (), and the result of such a call has type void. The only
1443 // effect is the evaluation of the postfix-expression before the dot or
1444 // arrow.
1445 EmitScalarExpr(E->getCallee());
1446 return RValue::get(0);
1447 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001448
Chris Lattner7f02f722007-08-24 05:35:26 +00001449 llvm::Value *Callee = EmitScalarExpr(E->getCallee());
Anders Carlsson98647712009-05-27 01:22:39 +00001450 return EmitCall(Callee, E->getCallee()->getType(),
1451 E->arg_begin(), E->arg_end(), TargetDecl);
Chris Lattnerc5e940f2007-08-31 04:44:06 +00001452}
1453
Daniel Dunbar80e62c22008-09-04 03:20:13 +00001454LValue CodeGenFunction::EmitBinaryOperatorLValue(const BinaryOperator *E) {
Chris Lattner7a574cc2009-05-12 21:28:12 +00001455 // Comma expressions just emit their LHS then their RHS as an l-value.
1456 if (E->getOpcode() == BinaryOperator::Comma) {
1457 EmitAnyExpr(E->getLHS());
Eli Friedman130c69e2009-12-07 20:18:11 +00001458 EnsureInsertPoint();
Chris Lattner7a574cc2009-05-12 21:28:12 +00001459 return EmitLValue(E->getRHS());
1460 }
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001461
Fariborz Jahanian52f08bc2009-10-26 21:58:25 +00001462 if (E->getOpcode() == BinaryOperator::PtrMemD ||
1463 E->getOpcode() == BinaryOperator::PtrMemI)
Fariborz Jahanian8bfd31f2009-10-22 22:57:31 +00001464 return EmitPointerToDataMemberBinaryExpr(E);
1465
Daniel Dunbar80e62c22008-09-04 03:20:13 +00001466 // Can only get l-value for binary operator expressions which are a
1467 // simple assignment of aggregate type.
1468 if (E->getOpcode() != BinaryOperator::Assign)
1469 return EmitUnsupportedLValue(E, "binary l-value expression");
1470
Anders Carlsson86aa0cd2009-10-19 18:28:22 +00001471 if (!hasAggregateLLVMType(E->getType())) {
1472 // Emit the LHS as an l-value.
1473 LValue LV = EmitLValue(E->getLHS());
1474
1475 llvm::Value *RHS = EmitScalarExpr(E->getRHS());
1476 EmitStoreOfScalar(RHS, LV.getAddress(), LV.isVolatileQualified(),
1477 E->getType());
1478 return LV;
1479 }
1480
Daniel Dunbar80e62c22008-09-04 03:20:13 +00001481 llvm::Value *Temp = CreateTempAlloca(ConvertType(E->getType()));
1482 EmitAggExpr(E, Temp, false);
1483 // FIXME: Are these qualifiers correct?
John McCall0953e762009-09-24 19:53:00 +00001484 return LValue::MakeAddr(Temp, MakeQualifiers(E->getType()));
Daniel Dunbar80e62c22008-09-04 03:20:13 +00001485}
1486
Christopher Lamb22c940e2007-12-29 05:02:41 +00001487LValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) {
Christopher Lamb22c940e2007-12-29 05:02:41 +00001488 RValue RV = EmitCallExpr(E);
Anders Carlsson48265682009-05-27 01:45:47 +00001489
Chris Lattnereb99b012009-10-28 17:39:19 +00001490 if (!RV.isScalar())
1491 return LValue::MakeAddr(RV.getAggregateAddr(),MakeQualifiers(E->getType()));
1492
1493 assert(E->getCallReturnType()->isReferenceType() &&
1494 "Can't have a scalar return unless the return type is a "
1495 "reference type!");
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001496
Chris Lattnereb99b012009-10-28 17:39:19 +00001497 return LValue::MakeAddr(RV.getScalarVal(), MakeQualifiers(E->getType()));
Christopher Lamb22c940e2007-12-29 05:02:41 +00001498}
1499
Daniel Dunbar5b5c9ef2009-02-11 20:59:32 +00001500LValue CodeGenFunction::EmitVAArgExprLValue(const VAArgExpr *E) {
1501 // FIXME: This shouldn't require another copy.
1502 llvm::Value *Temp = CreateTempAlloca(ConvertType(E->getType()));
1503 EmitAggExpr(E, Temp, false);
John McCall0953e762009-09-24 19:53:00 +00001504 return LValue::MakeAddr(Temp, MakeQualifiers(E->getType()));
Daniel Dunbar5b5c9ef2009-02-11 20:59:32 +00001505}
1506
Anders Carlssonb58d0172009-05-30 23:23:33 +00001507LValue CodeGenFunction::EmitCXXConstructLValue(const CXXConstructExpr *E) {
1508 llvm::Value *Temp = CreateTempAlloca(ConvertTypeForMem(E->getType()), "tmp");
1509 EmitCXXConstructExpr(Temp, E);
John McCall0953e762009-09-24 19:53:00 +00001510 return LValue::MakeAddr(Temp, MakeQualifiers(E->getType()));
Anders Carlssonb58d0172009-05-30 23:23:33 +00001511}
1512
Anders Carlssone61c9e82009-05-30 23:30:54 +00001513LValue
Mike Stumpc2e84ae2009-11-15 08:09:41 +00001514CodeGenFunction::EmitCXXTypeidLValue(const CXXTypeidExpr *E) {
1515 llvm::Value *Temp = EmitCXXTypeidExpr(E);
1516 return LValue::MakeAddr(Temp, MakeQualifiers(E->getType()));
1517}
1518
1519LValue
Anders Carlssone61c9e82009-05-30 23:30:54 +00001520CodeGenFunction::EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E) {
1521 LValue LV = EmitLValue(E->getSubExpr());
Anders Carlsson543ac0c2009-05-31 00:34:10 +00001522 PushCXXTemporary(E->getTemporary(), LV.getAddress());
Anders Carlssone61c9e82009-05-30 23:30:54 +00001523 return LV;
1524}
1525
Daniel Dunbar0a04d772008-08-23 10:51:21 +00001526LValue CodeGenFunction::EmitObjCMessageExprLValue(const ObjCMessageExpr *E) {
1527 // Can only get l-value for message expression returning aggregate type
1528 RValue RV = EmitObjCMessageExpr(E);
1529 // FIXME: can this be volatile?
John McCall0953e762009-09-24 19:53:00 +00001530 return LValue::MakeAddr(RV.getAggregateAddr(), MakeQualifiers(E->getType()));
Daniel Dunbar0a04d772008-08-23 10:51:21 +00001531}
1532
Daniel Dunbar2a031922009-04-22 05:08:15 +00001533llvm::Value *CodeGenFunction::EmitIvarOffset(const ObjCInterfaceDecl *Interface,
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00001534 const ObjCIvarDecl *Ivar) {
Fariborz Jahanianf63aa3f2009-02-10 19:02:04 +00001535 return CGM.getObjCRuntime().EmitIvarOffset(*this, Interface, Ivar);
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00001536}
1537
Fariborz Jahanian45012a72009-02-03 00:09:52 +00001538LValue CodeGenFunction::EmitLValueForIvar(QualType ObjectTy,
1539 llvm::Value *BaseValue,
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00001540 const ObjCIvarDecl *Ivar,
1541 unsigned CVRQualifiers) {
Chris Lattner26f074b2009-04-17 17:44:48 +00001542 return CGM.getObjCRuntime().EmitObjCValueForIvar(*this, ObjectTy, BaseValue,
Daniel Dunbar525c9b72009-04-21 01:19:28 +00001543 Ivar, CVRQualifiers);
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00001544}
1545
1546LValue CodeGenFunction::EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E) {
Anders Carlsson29b7e502008-08-25 01:53:23 +00001547 // FIXME: A lot of the code below could be shared with EmitMemberExpr.
1548 llvm::Value *BaseValue = 0;
1549 const Expr *BaseExpr = E->getBase();
John McCall0953e762009-09-24 19:53:00 +00001550 Qualifiers BaseQuals;
Fariborz Jahanian45012a72009-02-03 00:09:52 +00001551 QualType ObjectTy;
Anders Carlsson29b7e502008-08-25 01:53:23 +00001552 if (E->isArrow()) {
1553 BaseValue = EmitScalarExpr(BaseExpr);
Steve Naroff14108da2009-07-10 23:34:53 +00001554 ObjectTy = BaseExpr->getType()->getPointeeType();
John McCall0953e762009-09-24 19:53:00 +00001555 BaseQuals = ObjectTy.getQualifiers();
Anders Carlsson29b7e502008-08-25 01:53:23 +00001556 } else {
1557 LValue BaseLV = EmitLValue(BaseExpr);
1558 // FIXME: this isn't right for bitfields.
1559 BaseValue = BaseLV.getAddress();
Fariborz Jahanian45012a72009-02-03 00:09:52 +00001560 ObjectTy = BaseExpr->getType();
John McCall0953e762009-09-24 19:53:00 +00001561 BaseQuals = ObjectTy.getQualifiers();
Anders Carlsson29b7e502008-08-25 01:53:23 +00001562 }
Daniel Dunbar29e0bcc2008-09-24 04:00:38 +00001563
Fariborz Jahaniandbf3cfd2009-09-16 23:11:23 +00001564 LValue LV =
John McCall0953e762009-09-24 19:53:00 +00001565 EmitLValueForIvar(ObjectTy, BaseValue, E->getDecl(),
1566 BaseQuals.getCVRQualifiers());
Fariborz Jahaniandbf3cfd2009-09-16 23:11:23 +00001567 setObjCGCLValueClass(getContext(), E, LV);
1568 return LV;
Chris Lattner391d77a2008-03-30 23:03:07 +00001569}
1570
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001571LValue
Daniel Dunbar85c59ed2008-08-29 08:11:39 +00001572CodeGenFunction::EmitObjCPropertyRefLValue(const ObjCPropertyRefExpr *E) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001573 // This is a special l-value that just issues sends when we load or store
1574 // through it.
Daniel Dunbar85c59ed2008-08-29 08:11:39 +00001575 return LValue::MakePropertyRef(E, E->getType().getCVRQualifiers());
1576}
1577
Chris Lattnereb99b012009-10-28 17:39:19 +00001578LValue CodeGenFunction::EmitObjCKVCRefLValue(
Fariborz Jahanian09105f52009-08-20 17:02:02 +00001579 const ObjCImplicitSetterGetterRefExpr *E) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001580 // This is a special l-value that just issues sends when we load or store
1581 // through it.
Fariborz Jahanian43f44702008-11-22 22:30:21 +00001582 return LValue::MakeKVCRef(E, E->getType().getCVRQualifiers());
1583}
1584
Chris Lattnereb99b012009-10-28 17:39:19 +00001585LValue CodeGenFunction::EmitObjCSuperExprLValue(const ObjCSuperExpr *E) {
Douglas Gregorcd9b46e2008-11-04 14:56:14 +00001586 return EmitUnsupportedLValue(E, "use of super");
1587}
1588
Chris Lattner65459942009-04-25 19:35:26 +00001589LValue CodeGenFunction::EmitStmtExprLValue(const StmtExpr *E) {
Chris Lattner65459942009-04-25 19:35:26 +00001590 // Can only get l-value for message expression returning aggregate type
1591 RValue RV = EmitAnyExprToTemp(E);
1592 // FIXME: can this be volatile?
John McCall0953e762009-09-24 19:53:00 +00001593 return LValue::MakeAddr(RV.getAggregateAddr(), MakeQualifiers(E->getType()));
Chris Lattner65459942009-04-25 19:35:26 +00001594}
1595
1596
Anders Carlsson909fbf72009-11-07 22:00:15 +00001597LValue CodeGenFunction::EmitPointerToDataMemberLValue(const FieldDecl *Field) {
Fariborz Jahanian39762952009-10-21 21:01:47 +00001598 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Field->getDeclContext());
1599 QualType NNSpecTy =
1600 getContext().getCanonicalType(
1601 getContext().getTypeDeclType(const_cast<CXXRecordDecl*>(ClassDecl)));
Fariborz Jahaniana6362992009-10-21 18:38:00 +00001602 NNSpecTy = getContext().getPointerType(NNSpecTy);
1603 llvm::Value *V = llvm::Constant::getNullValue(ConvertType(NNSpecTy));
Anders Carlsson0ed303c2009-11-17 03:57:07 +00001604 LValue MemExpLV = EmitLValueForField(V, Field, /*isUnion=*/false,
1605 /*Qualifiers=*/0);
Chris Lattnereb99b012009-10-28 17:39:19 +00001606 const llvm::Type *ResultType = ConvertType(getContext().getPointerDiffType());
1607 V = Builder.CreatePtrToInt(MemExpLV.getAddress(), ResultType, "datamember");
Anders Carlsson909fbf72009-11-07 22:00:15 +00001608 return LValue::MakeAddr(V, MakeQualifiers(Field->getType()));
Fariborz Jahaniana6362992009-10-21 18:38:00 +00001609}
1610
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001611RValue CodeGenFunction::EmitCall(llvm::Value *Callee, QualType CalleeType,
Anders Carlsson98647712009-05-27 01:22:39 +00001612 CallExpr::const_arg_iterator ArgBeg,
1613 CallExpr::const_arg_iterator ArgEnd,
1614 const Decl *TargetDecl) {
Mike Stumpdb52dcd2009-09-09 13:00:44 +00001615 // Get the actual function type. The callee type will always be a pointer to
1616 // function type or a block pointer type.
1617 assert(CalleeType->isFunctionPointerType() &&
Anders Carlsson8ac67a72009-04-07 18:53:02 +00001618 "Call must have function pointer type!");
1619
John McCall00a1ad92009-10-23 08:22:42 +00001620 CalleeType = getContext().getCanonicalType(CalleeType);
1621
1622 QualType FnType = cast<PointerType>(CalleeType)->getPointeeType();
1623 QualType ResultType = cast<FunctionType>(FnType)->getResultType();
Daniel Dunbar19cd87e2008-08-30 03:02:31 +00001624
1625 CallArgList Args;
John McCall00a1ad92009-10-23 08:22:42 +00001626 EmitCallArgs(Args, dyn_cast<FunctionProtoType>(FnType), ArgBeg, ArgEnd);
Daniel Dunbar19cd87e2008-08-30 03:02:31 +00001627
Daniel Dunbar8a9f3fd2009-09-11 22:25:00 +00001628 // FIXME: We should not need to do this, it should be part of the function
1629 // type.
1630 unsigned CallingConvention = 0;
1631 if (const llvm::Function *F =
1632 dyn_cast<llvm::Function>(Callee->stripPointerCasts()))
1633 CallingConvention = F->getCallingConv();
1634 return EmitCall(CGM.getTypes().getFunctionInfo(ResultType, Args,
1635 CallingConvention),
Daniel Dunbarc0ef9f52009-02-20 18:06:48 +00001636 Callee, Args, TargetDecl);
Daniel Dunbar8f2926b2008-08-23 03:46:30 +00001637}
Fariborz Jahanian8bfd31f2009-10-22 22:57:31 +00001638
Chris Lattnereb99b012009-10-28 17:39:19 +00001639LValue CodeGenFunction::
1640EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E) {
Eli Friedman1c5c1a02009-11-18 05:01:17 +00001641 llvm::Value *BaseV;
Fariborz Jahanian52f08bc2009-10-26 21:58:25 +00001642 if (E->getOpcode() == BinaryOperator::PtrMemI)
Eli Friedman1c5c1a02009-11-18 05:01:17 +00001643 BaseV = EmitScalarExpr(E->getLHS());
1644 else
1645 BaseV = EmitLValue(E->getLHS()).getAddress();
Fariborz Jahanian8bfd31f2009-10-22 22:57:31 +00001646 const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(getLLVMContext());
1647 BaseV = Builder.CreateBitCast(BaseV, i8Ty);
Eli Friedman1c5c1a02009-11-18 05:01:17 +00001648 llvm::Value *OffsetV = EmitScalarExpr(E->getRHS());
Fariborz Jahanian8bfd31f2009-10-22 22:57:31 +00001649 llvm::Value *AddV = Builder.CreateInBoundsGEP(BaseV, OffsetV, "add.ptr");
Chris Lattnereb99b012009-10-28 17:39:19 +00001650
Fariborz Jahanian8bfd31f2009-10-22 22:57:31 +00001651 QualType Ty = E->getRHS()->getType();
Chris Lattnereb99b012009-10-28 17:39:19 +00001652 Ty = Ty->getAs<MemberPointerType>()->getPointeeType();
1653
1654 const llvm::Type *PType = ConvertType(getContext().getPointerType(Ty));
Fariborz Jahanian8bfd31f2009-10-22 22:57:31 +00001655 AddV = Builder.CreateBitCast(AddV, PType);
Chris Lattnereb99b012009-10-28 17:39:19 +00001656 return LValue::MakeAddr(AddV, MakeQualifiers(Ty));
Fariborz Jahanian8bfd31f2009-10-22 22:57:31 +00001657}
1658