 |
|
 |
|
| Files: |
1 |
|
Branches Taken: |
83.1% |
419 / 504 |
| Generated: |
2010-02-10 01:31 |
|
Branches Executed: |
94.4% |
476 / 504 |
| |
|
Line Coverage: |
89.7% |
813 / 906 |
| |
 |
|
 |
1 : //===--- CGExpr.cpp - Emit LLVM Code from Expressions ---------------------===//
2 : //
3 : // The LLVM Compiler Infrastructure
4 : //
5 : // This file is distributed under the University of Illinois Open Source
6 : // License. See LICENSE.TXT for details.
7 : //
8 : //===----------------------------------------------------------------------===//
9 : //
10 : // This contains code to emit Expr nodes as LLVM code.
11 : //
12 : //===----------------------------------------------------------------------===//
13 :
14 : #include "CodeGenFunction.h"
15 : #include "CodeGenModule.h"
16 : #include "CGCall.h"
17 : #include "CGObjCRuntime.h"
18 : #include "clang/AST/ASTContext.h"
19 : #include "clang/AST/DeclObjC.h"
20 : #include "llvm/Intrinsics.h"
21 : #include "clang/CodeGen/CodeGenOptions.h"
22 : #include "llvm/Target/TargetData.h"
23 : using namespace clang;
24 : using namespace CodeGen;
25 :
26 : //===--------------------------------------------------------------------===//
27 : // Miscellaneous Helper Methods
28 : //===--------------------------------------------------------------------===//
29 :
30 : /// CreateTempAlloca - This creates a alloca and inserts it into the entry
31 : /// block.
32 : llvm::AllocaInst *CodeGenFunction::CreateTempAlloca(const llvm::Type *Ty,
33 5646: const llvm::Twine &Name) {
0: branch 1 not taken
5646: branch 2 taken
34 5646: if (!Builder.isNamePreserving())
35 0: return new llvm::AllocaInst(Ty, 0, "", AllocaInsertPt);
36 5646: return new llvm::AllocaInst(Ty, 0, Name, AllocaInsertPt);
37 : }
38 :
39 3159: llvm::Value *CodeGenFunction::CreateMemTemp(QualType Ty, const llvm::Twine &Name) {
40 3159: llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertTypeForMem(Ty), Name);
41 : // FIXME: Should we prefer the preferred type alignment here?
42 3159: CharUnits Align = getContext().getTypeAlignInChars(Ty);
43 3159: Alloc->setAlignment(Align.getQuantity());
44 3159: return Alloc;
45 : }
46 :
47 : /// EvaluateExprAsBool - Perform the usual unary conversions on the specified
48 : /// expression and compare the result against zero, returning an Int1Ty value.
49 443: llvm::Value *CodeGenFunction::EvaluateExprAsBool(const Expr *E) {
50 443: QualType BoolTy = getContext().BoolTy;
5: branch 3 taken
438: branch 4 taken
51 443: if (E->getType()->isMemberFunctionPointerType()) {
52 5: LValue LV = EmitAggExprToLValue(E);
53 :
54 : // Get the pointer.
55 : llvm::Value *FuncPtr = Builder.CreateStructGEP(LV.getAddress(), 0,
56 5: "src.ptr");
57 5: FuncPtr = Builder.CreateLoad(FuncPtr);
58 :
59 : llvm::Value *IsNotNull =
60 : Builder.CreateICmpNE(FuncPtr,
61 : llvm::Constant::getNullValue(FuncPtr->getType()),
62 5: "tobool");
63 :
64 5: return IsNotNull;
65 : }
438: branch 3 taken
0: branch 4 not taken
66 438: if (!E->getType()->isAnyComplexType())
67 438: return EmitScalarConversion(EmitScalarExpr(E), E->getType(), BoolTy);
68 :
69 0: return EmitComplexToScalarConversion(EmitComplexExpr(E), E->getType(),BoolTy);
70 : }
71 :
72 : /// EmitAnyExpr - Emit code to compute the specified expression which can have
73 : /// any type. The result is returned as an RValue struct. If this is an
74 : /// aggregate expression, the aggloc/agglocvolatile arguments indicate where the
75 : /// result should be returned.
76 : RValue CodeGenFunction::EmitAnyExpr(const Expr *E, llvm::Value *AggLoc,
77 : bool IsAggLocVolatile, bool IgnoreResult,
78 4804: bool IsInitializer) {
4465: branch 2 taken
339: branch 3 taken
79 4804: if (!hasAggregateLLVMType(E->getType()))
80 4465: return RValue::get(EmitScalarExpr(E, IgnoreResult));
61: branch 3 taken
278: branch 4 taken
81 339: else if (E->getType()->isAnyComplexType())
82 : return RValue::getComplex(EmitComplexExpr(E, false, false,
83 61: IgnoreResult, IgnoreResult));
84 :
85 278: EmitAggExpr(E, AggLoc, IsAggLocVolatile, IgnoreResult, IsInitializer);
86 278: return RValue::getAggregate(AggLoc, IsAggLocVolatile);
87 : }
88 :
89 : /// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result will
90 : /// always be accessible even if no aggregate location is provided.
91 : RValue CodeGenFunction::EmitAnyExprToTemp(const Expr *E,
92 : bool IsAggLocVolatile,
93 2063: bool IsInitializer) {
94 2063: llvm::Value *AggLoc = 0;
95 :
119: branch 2 taken
1944: branch 3 taken
104: branch 7 taken
15: branch 8 taken
104: branch 9 taken
1959: branch 10 taken
96 2063: if (hasAggregateLLVMType(E->getType()) &&
97 : !E->getType()->isAnyComplexType())
98 104: AggLoc = CreateTempAlloca(ConvertTypeForMem(E->getType()), "agg.tmp");
99 : return EmitAnyExpr(E, AggLoc, IsAggLocVolatile, /*IgnoreResult=*/false,
100 2063: IsInitializer);
101 : }
102 :
103 : RValue CodeGenFunction::EmitReferenceBindingToExpr(const Expr* E,
104 208: bool IsInitializer) {
105 208: bool ShouldDestroyTemporaries = false;
106 208: unsigned OldNumLiveTemporaries = 0;
107 :
14: branch 1 taken
194: branch 2 taken
108 208: if (const CXXDefaultArgExpr *DAE = dyn_cast<CXXDefaultArgExpr>(E))
109 14: E = DAE->getExpr();
110 :
5: branch 1 taken
203: branch 2 taken
111 208: if (const CXXExprWithTemporaries *TE = dyn_cast<CXXExprWithTemporaries>(E)) {
112 5: ShouldDestroyTemporaries = true;
113 :
114 : // Keep track of the current cleanup stack depth.
115 5: OldNumLiveTemporaries = LiveTemporaries.size();
116 :
117 5: E = TE->getSubExpr();
118 : }
119 :
120 : RValue Val;
161: branch 2 taken
47: branch 3 taken
121 208: if (E->isLvalue(getContext()) == Expr::LV_Valid) {
122 : // Emit the expr as an lvalue.
123 161: LValue LV = EmitLValue(E);
159: branch 1 taken
2: branch 2 taken
124 161: if (LV.isSimple()) {
1: branch 0 taken
158: branch 1 taken
125 159: if (ShouldDestroyTemporaries) {
126 : // Pop temporaries.
1: branch 1 taken
1: branch 2 taken
127 3: while (LiveTemporaries.size() > OldNumLiveTemporaries)
128 1: PopCXXTemporary();
129 : }
130 :
131 159: return RValue::get(LV.getAddress());
132 : }
133 :
134 2: Val = EmitLoadOfLValue(LV, E->getType());
135 :
0: branch 0 not taken
2: branch 1 taken
136 2: if (ShouldDestroyTemporaries) {
137 : // Pop temporaries.
0: branch 1 not taken
0: branch 2 not taken
138 0: while (LiveTemporaries.size() > OldNumLiveTemporaries)
139 0: PopCXXTemporary();
140 : }
141 : } else {
142 47: const CXXRecordDecl *BaseClassDecl = 0;
143 47: const CXXRecordDecl *DerivedClassDecl = 0;
144 :
4: branch 0 taken
43: branch 1 taken
145 47: if (const CastExpr *CE =
146 47: dyn_cast<CastExpr>(E->IgnoreParenNoopCasts(getContext()))) {
4: branch 1 taken
0: branch 2 not taken
147 4: if (CE->getCastKind() == CastExpr::CK_DerivedToBase) {
148 4: E = CE->getSubExpr();
149 :
150 : BaseClassDecl =
151 4: cast<CXXRecordDecl>(CE->getType()->getAs<RecordType>()->getDecl());
152 : DerivedClassDecl =
153 4: cast<CXXRecordDecl>(E->getType()->getAs<RecordType>()->getDecl());
154 : }
155 : }
156 :
157 : Val = EmitAnyExprToTemp(E, /*IsAggLocVolatile=*/false,
158 47: IsInitializer);
159 :
4: branch 0 taken
43: branch 1 taken
160 47: if (ShouldDestroyTemporaries) {
161 : // Pop temporaries.
1: branch 1 taken
4: branch 2 taken
162 9: while (LiveTemporaries.size() > OldNumLiveTemporaries)
163 1: PopCXXTemporary();
164 : }
165 :
6: branch 0 taken
41: branch 1 taken
166 47: if (IsInitializer) {
167 : // We might have to destroy the temporary variable.
5: branch 3 taken
1: branch 4 taken
168 6: if (const RecordType *RT = E->getType()->getAs<RecordType>()) {
5: branch 2 taken
0: branch 3 not taken
169 5: if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
4: branch 1 taken
1: branch 2 taken
170 5: if (!ClassDecl->hasTrivialDestructor()) {
171 : const CXXDestructorDecl *Dtor =
172 4: ClassDecl->getDestructor(getContext());
173 :
174 : {
175 4: DelayedCleanupBlock Scope(*this);
176 : EmitCXXDestructorCall(Dtor, Dtor_Complete,
177 4: Val.getAggregateAddr());
178 :
179 : // Make sure to jump to the exit block.
180 4: EmitBranch(Scope.getCleanupExitBlock());
181 : }
0: branch 0 not taken
4: branch 1 taken
182 4: if (Exceptions) {
183 0: EHCleanupBlock Cleanup(*this);
184 : EmitCXXDestructorCall(Dtor, Dtor_Complete,
185 0: Val.getAggregateAddr());
186 : }
187 : }
188 : }
189 : }
190 : }
191 :
192 : // Check if need to perform the derived-to-base cast.
4: branch 0 taken
43: branch 1 taken
193 47: if (BaseClassDecl) {
194 4: llvm::Value *Derived = Val.getAggregateAddr();
195 : llvm::Value *Base =
196 : GetAddressOfBaseClass(Derived, DerivedClassDecl, BaseClassDecl,
197 4: /*NullCheckValue=*/false);
198 4: return RValue::get(Base);
199 : }
200 : }
201 :
30: branch 1 taken
15: branch 2 taken
202 45: if (Val.isAggregate()) {
203 30: Val = RValue::get(Val.getAggregateAddr());
204 : } else {
205 : // Create a temporary variable that we can bind the reference to.
206 15: llvm::Value *Temp = CreateMemTemp(E->getType(), "reftmp");
13: branch 1 taken
2: branch 2 taken
207 15: if (Val.isScalar())
208 13: EmitStoreOfScalar(Val.getScalarVal(), Temp, false, E->getType());
209 : else
210 2: StoreComplexToAddr(Val.getComplexVal(), Temp, false);
211 15: Val = RValue::get(Temp);
212 : }
213 :
214 45: return Val;
215 : }
216 :
217 :
218 : /// getAccessedFieldNo - Given an encoded value and a result number, return the
219 : /// input field number being accessed.
220 : unsigned CodeGenFunction::getAccessedFieldNo(unsigned Idx,
221 95: const llvm::Constant *Elts) {
10: branch 1 taken
85: branch 2 taken
222 95: if (isa<llvm::ConstantAggregateZero>(Elts))
223 10: return 0;
224 :
225 85: return cast<llvm::ConstantInt>(Elts->getOperand(Idx))->getZExtValue();
226 : }
227 :
228 868: void CodeGenFunction::EmitCheck(llvm::Value *Address, unsigned Size) {
868: branch 0 taken
0: branch 1 not taken
229 868: if (!CatchUndefined)
230 868: return;
231 :
232 : const llvm::IntegerType *Size_tTy
233 0: = llvm::IntegerType::get(VMContext, LLVMPointerWidth);
234 0: Address = Builder.CreateBitCast(Address, PtrToInt8Ty);
235 :
236 : const llvm::Type *ResType[] = {
237 : Size_tTy
238 0: };
239 0: llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::objectsize, ResType, 1);
240 : const llvm::IntegerType *IntTy = cast<llvm::IntegerType>(
241 0: CGM.getTypes().ConvertType(CGM.getContext().IntTy));
242 : // In time, people may want to control this and use a 1 here.
243 0: llvm::Value *Arg = llvm::ConstantInt::get(IntTy, 0);
244 0: llvm::Value *C = Builder.CreateCall2(F, Address, Arg);
245 0: llvm::BasicBlock *Cont = createBasicBlock();
246 0: llvm::BasicBlock *Check = createBasicBlock();
247 0: llvm::Value *NegativeOne = llvm::ConstantInt::get(Size_tTy, -1ULL);
248 0: Builder.CreateCondBr(Builder.CreateICmpEQ(C, NegativeOne), Cont, Check);
249 :
250 0: EmitBlock(Check);
251 : Builder.CreateCondBr(Builder.CreateICmpUGE(C,
252 : llvm::ConstantInt::get(Size_tTy, Size)),
253 0: Cont, getTrapBB());
254 0: EmitBlock(Cont);
255 : }
256 :
257 :
258 : llvm::Value *CodeGenFunction::
259 : EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV,
260 227: bool isInc, bool isPre) {
261 227: QualType ValTy = E->getSubExpr()->getType();
262 227: llvm::Value *InVal = EmitLoadOfLValue(LV, ValTy).getScalarVal();
263 :
174: branch 0 taken
53: branch 1 taken
264 227: int AmountVal = isInc ? 1 : -1;
265 :
26: branch 2 taken
201: branch 3 taken
0: branch 7 not taken
26: branch 8 taken
0: branch 9 not taken
227: branch 10 taken
266 227: if (ValTy->isPointerType() &&
267 : ValTy->getAs<PointerType>()->isVariableArrayType()) {
268 : // The amount of the addition/subtraction needs to account for the VLA size
269 0: ErrorUnsupported(E, "VLA pointer inc/dec");
270 : }
271 :
272 : llvm::Value *NextVal;
30: branch 0 taken
197: branch 1 taken
273 227: if (const llvm::PointerType *PT =
274 227: dyn_cast<llvm::PointerType>(InVal->getType())) {
275 : llvm::Constant *Inc =
276 30: llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), AmountVal);
26: branch 2 taken
4: branch 3 taken
277 30: if (!isa<llvm::FunctionType>(PT->getElementType())) {
278 26: QualType PTEE = ValTy->getPointeeType();
4: branch 0 taken
22: branch 1 taken
279 26: if (const ObjCInterfaceType *OIT =
280 26: dyn_cast<ObjCInterfaceType>(PTEE)) {
281 : // Handle interface types, which are not represented with a concrete
282 : // type.
283 4: int size = getContext().getTypeSize(OIT) / 8;
2: branch 0 taken
2: branch 1 taken
284 4: if (!isInc)
285 2: size = -size;
286 4: Inc = llvm::ConstantInt::get(Inc->getType(), size);
287 4: const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext);
288 4: InVal = Builder.CreateBitCast(InVal, i8Ty);
289 4: NextVal = Builder.CreateGEP(InVal, Inc, "add.ptr");
290 4: llvm::Value *lhs = LV.getAddress();
291 4: lhs = Builder.CreateBitCast(lhs, llvm::PointerType::getUnqual(i8Ty));
292 4: LV = LValue::MakeAddr(lhs, MakeQualifiers(ValTy));
293 : } else
294 22: NextVal = Builder.CreateInBoundsGEP(InVal, Inc, "ptrincdec");
295 : } else {
296 4: const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext);
297 4: NextVal = Builder.CreateBitCast(InVal, i8Ty, "tmp");
298 4: NextVal = Builder.CreateGEP(NextVal, Inc, "ptrincdec");
299 4: NextVal = Builder.CreateBitCast(NextVal, InVal->getType());
300 : }
0: branch 2 not taken
197: branch 3 taken
197: branch 4 taken
197: branch 5 taken
0: branch 6 not taken
197: branch 7 taken
301 197: } else if (InVal->getType() == llvm::Type::getInt1Ty(VMContext) && isInc) {
302 : // Bool++ is an interesting case, due to promotion rules, we get:
303 : // Bool++ -> Bool = Bool+1 -> Bool = (int)Bool+1 ->
304 : // Bool = ((int)Bool+1) != 0
305 : // An interesting aspect of this is that increment is always true.
306 : // Decrement does not have this property.
307 0: NextVal = llvm::ConstantInt::getTrue(VMContext);
159: branch 2 taken
38: branch 3 taken
308 197: } else if (isa<llvm::IntegerType>(InVal->getType())) {
309 159: NextVal = llvm::ConstantInt::get(InVal->getType(), AmountVal);
310 :
311 : // Signed integer overflow is undefined behavior.
126: branch 2 taken
33: branch 3 taken
312 159: if (ValTy->isSignedIntegerType())
105: branch 0 taken
21: branch 1 taken
313 126: NextVal = Builder.CreateNSWAdd(InVal, NextVal, isInc ? "inc" : "dec");
314 : else
32: branch 0 taken
1: branch 1 taken
315 33: NextVal = Builder.CreateAdd(InVal, NextVal, isInc ? "inc" : "dec");
316 : } else {
317 : // Add the inc/dec to the real part.
18: branch 2 taken
20: branch 3 taken
318 38: if (InVal->getType()->isFloatTy())
319 : NextVal =
320 : llvm::ConstantFP::get(VMContext,
321 18: llvm::APFloat(static_cast<float>(AmountVal)));
10: branch 2 taken
10: branch 3 taken
322 20: else if (InVal->getType()->isDoubleTy())
323 : NextVal =
324 : llvm::ConstantFP::get(VMContext,
325 10: llvm::APFloat(static_cast<double>(AmountVal)));
326 : else {
327 10: llvm::APFloat F(static_cast<float>(AmountVal));
328 : bool ignored;
329 : F.convert(Target.getLongDoubleFormat(), llvm::APFloat::rmTowardZero,
330 10: &ignored);
331 10: NextVal = llvm::ConstantFP::get(VMContext, F);
332 : }
19: branch 0 taken
19: branch 1 taken
333 38: NextVal = Builder.CreateFAdd(InVal, NextVal, isInc ? "inc" : "dec");
334 : }
335 :
336 : // Store the updated result through the lvalue.
1: branch 1 taken
226: branch 2 taken
337 227: if (LV.isBitfield())
338 1: EmitStoreThroughBitfieldLValue(RValue::get(NextVal), LV, ValTy, &NextVal);
339 : else
340 226: EmitStoreThroughLValue(RValue::get(NextVal), LV, ValTy);
341 :
342 : // If this is a postinc, return the value read from memory, otherwise use the
343 : // updated value.
133: branch 0 taken
94: branch 1 taken
344 227: return isPre ? NextVal : InVal;
345 : }
346 :
347 :
348 : CodeGenFunction::ComplexPairTy CodeGenFunction::
349 : EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV,
350 8: bool isInc, bool isPre) {
351 : ComplexPairTy InVal = LoadComplexFromAddr(LV.getAddress(),
352 8: LV.isVolatileQualified());
353 :
354 : llvm::Value *NextVal;
4: branch 2 taken
4: branch 3 taken
355 8: if (isa<llvm::IntegerType>(InVal.first->getType())) {
2: branch 0 taken
2: branch 1 taken
356 4: uint64_t AmountVal = isInc ? 1 : -1;
357 4: NextVal = llvm::ConstantInt::get(InVal.first->getType(), AmountVal, true);
358 :
359 : // Add the inc/dec to the real part.
2: branch 0 taken
2: branch 1 taken
360 4: NextVal = Builder.CreateAdd(InVal.first, NextVal, isInc ? "inc" : "dec");
361 : } else {
362 4: QualType ElemTy = E->getType()->getAs<ComplexType>()->getElementType();
363 4: llvm::APFloat FVal(getContext().getFloatTypeSemantics(ElemTy), 1);
2: branch 0 taken
2: branch 1 taken
364 4: if (!isInc)
365 2: FVal.changeSign();
366 4: NextVal = llvm::ConstantFP::get(getLLVMContext(), FVal);
367 :
368 : // Add the inc/dec to the real part.
2: branch 0 taken
2: branch 1 taken
369 4: NextVal = Builder.CreateFAdd(InVal.first, NextVal, isInc ? "inc" : "dec");
370 : }
371 :
372 8: ComplexPairTy IncVal(NextVal, InVal.second);
373 :
374 : // Store the updated result through the lvalue.
375 8: StoreComplexToAddr(IncVal, LV.getAddress(), LV.isVolatileQualified());
376 :
377 : // If this is a postinc, return the value read from memory, otherwise use the
378 : // updated value.
4: branch 0 taken
4: branch 1 taken
379 8: return isPre ? IncVal : InVal;
380 : }
381 :
382 :
383 : //===----------------------------------------------------------------------===//
384 : // LValue Expression Emission
385 : //===----------------------------------------------------------------------===//
386 :
387 1530: RValue CodeGenFunction::GetUndefRValue(QualType Ty) {
1529: branch 2 taken
1: branch 3 taken
388 1530: if (Ty->isVoidType())
389 1529: return RValue::get(0);
390 :
0: branch 2 not taken
1: branch 3 taken
391 1: if (const ComplexType *CTy = Ty->getAs<ComplexType>()) {
392 0: const llvm::Type *EltTy = ConvertType(CTy->getElementType());
393 0: llvm::Value *U = llvm::UndefValue::get(EltTy);
394 0: return RValue::getComplex(std::make_pair(U, U));
395 : }
396 :
1: branch 1 taken
0: branch 2 not taken
397 1: if (hasAggregateLLVMType(Ty)) {
398 1: const llvm::Type *LTy = llvm::PointerType::getUnqual(ConvertType(Ty));
399 1: return RValue::getAggregate(llvm::UndefValue::get(LTy));
400 : }
401 :
402 0: return RValue::get(llvm::UndefValue::get(ConvertType(Ty)));
403 : }
404 :
405 : RValue CodeGenFunction::EmitUnsupportedRValue(const Expr *E,
406 0: const char *Name) {
407 0: ErrorUnsupported(E, Name);
408 0: return GetUndefRValue(E->getType());
409 : }
410 :
411 : LValue CodeGenFunction::EmitUnsupportedLValue(const Expr *E,
412 0: const char *Name) {
413 0: ErrorUnsupported(E, Name);
414 0: llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType()));
415 : return LValue::MakeAddr(llvm::UndefValue::get(Ty),
416 0: MakeQualifiers(E->getType()));
417 : }
418 :
419 4107: LValue CodeGenFunction::EmitCheckedLValue(const Expr *E) {
420 4107: LValue LV = EmitLValue(E);
1069: branch 1 taken
3038: branch 2 taken
965: branch 4 taken
104: branch 5 taken
868: branch 7 taken
97: branch 8 taken
868: branch 9 taken
3239: branch 10 taken
421 4107: if (!isa<DeclRefExpr>(E) && !LV.isBitfield() && LV.isSimple())
422 868: EmitCheck(LV.getAddress(), getContext().getTypeSize(E->getType()) / 8);
423 : return LV;
424 : }
425 :
426 : /// EmitLValue - Emit code to compute a designator that specifies the location
427 : /// of the expression.
428 : ///
429 : /// This can return one of two things: a simple address or a bitfield reference.
430 : /// In either case, the LLVM Value* in the LValue structure is guaranteed to be
431 : /// an LLVM pointer type.
432 : ///
433 : /// If this returns a bitfield reference, nothing about the pointee type of the
434 : /// LLVM value is known: For example, it may not be a pointer to an integer.
435 : ///
436 : /// If this returns a normal address, and if the lvalue's C type is fixed size,
437 : /// this method guarantees that the returned pointer type will point to an LLVM
438 : /// type of the same size of the lvalue's type. If the lvalue has a variable
439 : /// length type, this is not possible.
440 : ///
441 8051: LValue CodeGenFunction::EmitLValue(const Expr *E) {
0: branch 1 not taken
2: branch 2 taken
30: branch 3 taken
105: branch 4 taken
1: branch 5 taken
5129: branch 6 taken
64: branch 7 taken
179: branch 8 taken
600: branch 9 taken
12: branch 10 taken
19: branch 11 taken
41: branch 12 taken
25: branch 13 taken
0: branch 14 not taken
18: branch 15 taken
0: branch 16 not taken
68: branch 17 taken
0: branch 18 not taken
242: branch 19 taken
56: branch 20 taken
15: branch 21 taken
0: branch 22 not taken
1: branch 23 taken
109: branch 24 taken
258: branch 25 taken
56: branch 26 taken
726: branch 27 taken
33: branch 28 taken
10: branch 29 taken
0: branch 30 not taken
252: branch 31 taken
442 8051: switch (E->getStmtClass()) {
443 0: default: return EmitUnsupportedLValue(E, "l-value expression");
444 :
445 : case Expr::ObjCIsaExprClass:
446 2: return EmitObjCIsaExpr(cast<ObjCIsaExpr>(E));
447 : case Expr::BinaryOperatorClass:
448 30: return EmitBinaryOperatorLValue(cast<BinaryOperator>(E));
449 : case Expr::CallExprClass:
450 : case Expr::CXXMemberCallExprClass:
451 : case Expr::CXXOperatorCallExprClass:
452 105: return EmitCallExprLValue(cast<CallExpr>(E));
453 : case Expr::VAArgExprClass:
454 1: return EmitVAArgExprLValue(cast<VAArgExpr>(E));
455 : case Expr::DeclRefExprClass:
456 5129: return EmitDeclRefLValue(cast<DeclRefExpr>(E));
457 64: case Expr::ParenExprClass:return EmitLValue(cast<ParenExpr>(E)->getSubExpr());
458 : case Expr::PredefinedExprClass:
459 179: return EmitPredefinedLValue(cast<PredefinedExpr>(E));
460 : case Expr::StringLiteralClass:
461 600: return EmitStringLiteralLValue(cast<StringLiteral>(E));
462 : case Expr::ObjCEncodeExprClass:
463 12: return EmitObjCEncodeExprLValue(cast<ObjCEncodeExpr>(E));
464 :
465 : case Expr::BlockDeclRefExprClass:
466 19: return EmitBlockDeclRefLValue(cast<BlockDeclRefExpr>(E));
467 :
468 : case Expr::CXXTemporaryObjectExprClass:
469 : case Expr::CXXConstructExprClass:
470 41: return EmitCXXConstructLValue(cast<CXXConstructExpr>(E));
471 : case Expr::CXXBindTemporaryExprClass:
472 25: return EmitCXXBindTemporaryLValue(cast<CXXBindTemporaryExpr>(E));
473 : case Expr::CXXExprWithTemporariesClass:
474 0: return EmitCXXExprWithTemporariesLValue(cast<CXXExprWithTemporaries>(E));
475 : case Expr::CXXZeroInitValueExprClass:
476 18: return EmitNullInitializationLValue(cast<CXXZeroInitValueExpr>(E));
477 : case Expr::CXXDefaultArgExprClass:
478 0: return EmitLValue(cast<CXXDefaultArgExpr>(E)->getExpr());
479 : case Expr::CXXTypeidExprClass:
480 68: return EmitCXXTypeidLValue(cast<CXXTypeidExpr>(E));
481 :
482 : case Expr::ObjCMessageExprClass:
483 0: return EmitObjCMessageExprLValue(cast<ObjCMessageExpr>(E));
484 : case Expr::ObjCIvarRefExprClass:
485 242: return EmitObjCIvarRefLValue(cast<ObjCIvarRefExpr>(E));
486 : case Expr::ObjCPropertyRefExprClass:
487 56: return EmitObjCPropertyRefLValue(cast<ObjCPropertyRefExpr>(E));
488 : case Expr::ObjCImplicitSetterGetterRefExprClass:
489 15: return EmitObjCKVCRefLValue(cast<ObjCImplicitSetterGetterRefExpr>(E));
490 : case Expr::ObjCSuperExprClass:
491 0: return EmitObjCSuperExprLValue(cast<ObjCSuperExpr>(E));
492 :
493 : case Expr::StmtExprClass:
494 1: return EmitStmtExprLValue(cast<StmtExpr>(E));
495 : case Expr::UnaryOperatorClass:
496 109: return EmitUnaryOpLValue(cast<UnaryOperator>(E));
497 : case Expr::ArraySubscriptExprClass:
498 258: return EmitArraySubscriptExpr(cast<ArraySubscriptExpr>(E));
499 : case Expr::ExtVectorElementExprClass:
500 56: return EmitExtVectorElementExpr(cast<ExtVectorElementExpr>(E));
501 : case Expr::MemberExprClass:
502 726: return EmitMemberExpr(cast<MemberExpr>(E));
503 : case Expr::CompoundLiteralExprClass:
504 33: return EmitCompoundLiteralLValue(cast<CompoundLiteralExpr>(E));
505 : case Expr::ConditionalOperatorClass:
506 10: return EmitConditionalOperatorLValue(cast<ConditionalOperator>(E));
507 : case Expr::ChooseExprClass:
508 0: return EmitLValue(cast<ChooseExpr>(E)->getChosenSubExpr(getContext()));
509 : case Expr::ImplicitCastExprClass:
510 : case Expr::CStyleCastExprClass:
511 : case Expr::CXXFunctionalCastExprClass:
512 : case Expr::CXXStaticCastExprClass:
513 : case Expr::CXXDynamicCastExprClass:
514 : case Expr::CXXReinterpretCastExprClass:
515 : case Expr::CXXConstCastExprClass:
516 252: return EmitCastLValue(cast<CastExpr>(E));
517 : }
518 : }
519 :
520 : llvm::Value *CodeGenFunction::EmitLoadOfScalar(llvm::Value *Addr, bool Volatile,
521 3448: QualType Ty) {
522 3448: llvm::LoadInst *Load = Builder.CreateLoad(Addr, "tmp");
67: branch 0 taken
3381: branch 1 taken
523 3448: if (Volatile)
524 67: Load->setVolatile(true);
525 :
526 : // Bool can have different representation in memory than in registers.
527 3448: llvm::Value *V = Load;
22: branch 2 taken
3426: branch 3 taken
528 3448: if (Ty->isBooleanType())
22: branch 2 taken
0: branch 3 not taken
529 22: if (V->getType() != llvm::Type::getInt1Ty(VMContext))
530 22: V = Builder.CreateTrunc(V, llvm::Type::getInt1Ty(VMContext), "tobool");
531 :
532 3448: return V;
533 : }
534 :
535 : void CodeGenFunction::EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr,
536 4749: bool Volatile, QualType Ty) {
537 :
26: branch 2 taken
4723: branch 3 taken
538 4749: if (Ty->isBooleanType()) {
539 : // Bool can have different representation in memory than in registers.
540 26: const llvm::PointerType *DstPtr = cast<llvm::PointerType>(Addr->getType());
541 26: Value = Builder.CreateIntCast(Value, DstPtr->getElementType(), false);
542 : }
543 4749: Builder.CreateStore(Value, Addr, Volatile);
544 4749: }
545 :
546 : /// EmitLoadOfLValue - Given an expression that represents a value lvalue, this
547 : /// method emits the address of the lvalue, then loads the result as an rvalue,
548 : /// returning the rvalue.
549 3581: RValue CodeGenFunction::EmitLoadOfLValue(LValue LV, QualType ExprType) {
11: branch 1 taken
3570: branch 2 taken
550 3581: if (LV.isObjCWeak()) {
551 : // load of a __weak object.
552 11: llvm::Value *AddrWeakObj = LV.getAddress();
553 : return RValue::get(CGM.getObjCRuntime().EmitObjCWeakRead(*this,
554 11: AddrWeakObj));
555 : }
556 :
3441: branch 1 taken
129: branch 2 taken
557 3570: if (LV.isSimple()) {
558 3441: llvm::Value *Ptr = LV.getAddress();
559 : const llvm::Type *EltTy =
560 3441: cast<llvm::PointerType>(Ptr->getType())->getElementType();
561 :
562 : // Simple scalar l-value.
563 : //
564 : // FIXME: We shouldn't have to use isSingleValueType here.
3441: branch 1 taken
0: branch 2 not taken
565 3441: if (EltTy->isSingleValueType())
566 : return RValue::get(EmitLoadOfScalar(Ptr, LV.isVolatileQualified(),
567 3441: ExprType));
568 :
0: branch 2 not taken
0: branch 3 not taken
569 0: assert(ExprType->isFunctionType() && "Unknown scalar value");
570 0: return RValue::get(Ptr);
571 : }
572 :
1: branch 1 taken
128: branch 2 taken
573 129: if (LV.isVectorElt()) {
574 : llvm::Value *Vec = Builder.CreateLoad(LV.getVectorAddr(),
575 1: LV.isVolatileQualified(), "tmp");
576 : return RValue::get(Builder.CreateExtractElement(Vec, LV.getVectorIdx(),
577 1: "vecext"));
578 : }
579 :
580 : // If this is a reference to a subset of the elements of a vector, either
581 : // shuffle the input or extract/insert them as appropriate.
37: branch 1 taken
91: branch 2 taken
582 128: if (LV.isExtVectorElt())
583 37: return EmitLoadOfExtVectorElementLValue(LV, ExprType);
584 :
61: branch 1 taken
30: branch 2 taken
585 91: if (LV.isBitfield())
586 61: return EmitLoadOfBitfieldLValue(LV, ExprType);
587 :
25: branch 1 taken
5: branch 2 taken
588 30: if (LV.isPropertyRef())
589 25: return EmitLoadOfPropertyRefLValue(LV, ExprType);
590 :
5: branch 1 taken
0: branch 2 not taken
591 5: assert(LV.isKVCRef() && "Unknown LValue type!");
592 5: return EmitLoadOfKVCRefLValue(LV, ExprType);
593 : }
594 :
595 : RValue CodeGenFunction::EmitLoadOfBitfieldLValue(LValue LV,
596 61: QualType ExprType) {
597 61: unsigned StartBit = LV.getBitfieldStartBit();
598 61: unsigned BitfieldSize = LV.getBitfieldSize();
599 61: llvm::Value *Ptr = LV.getBitfieldAddr();
600 :
601 : const llvm::Type *EltTy =
602 61: cast<llvm::PointerType>(Ptr->getType())->getElementType();
603 61: unsigned EltTySize = CGM.getTargetData().getTypeSizeInBits(EltTy);
604 :
605 : // In some cases the bitfield may straddle two memory locations. Currently we
606 : // load the entire bitfield, then do the magic to sign-extend it if
607 : // necessary. This results in somewhat more code than necessary for the common
608 : // case (one load), since two shifts accomplish both the masking and sign
609 : // extension.
610 61: unsigned LowBits = std::min(BitfieldSize, EltTySize - StartBit);
611 61: llvm::Value *Val = Builder.CreateLoad(Ptr, LV.isVolatileQualified(), "tmp");
612 :
613 : // Shift to proper location.
21: branch 0 taken
40: branch 1 taken
614 61: if (StartBit)
615 21: Val = Builder.CreateLShr(Val, StartBit, "bf.lo");
616 :
617 : // Mask off unused bits.
618 : llvm::Constant *LowMask = llvm::ConstantInt::get(VMContext,
619 61: llvm::APInt::getLowBitsSet(EltTySize, LowBits));
620 61: Val = Builder.CreateAnd(Val, LowMask, "bf.lo.cleared");
621 :
622 : // Fetch the high bits if necessary.
2: branch 0 taken
59: branch 1 taken
623 61: if (LowBits < BitfieldSize) {
624 2: unsigned HighBits = BitfieldSize - LowBits;
625 : llvm::Value *HighPtr = Builder.CreateGEP(Ptr, llvm::ConstantInt::get(
626 2: llvm::Type::getInt32Ty(VMContext), 1), "bf.ptr.hi");
627 : llvm::Value *HighVal = Builder.CreateLoad(HighPtr,
628 : LV.isVolatileQualified(),
629 2: "tmp");
630 :
631 : // Mask off unused bits.
632 : llvm::Constant *HighMask = llvm::ConstantInt::get(VMContext,
633 2: llvm::APInt::getLowBitsSet(EltTySize, HighBits));
634 2: HighVal = Builder.CreateAnd(HighVal, HighMask, "bf.lo.cleared");
635 :
636 : // Shift to proper location and or in to bitfield value.
637 2: HighVal = Builder.CreateShl(HighVal, LowBits);
638 2: Val = Builder.CreateOr(Val, HighVal, "bf.val");
639 : }
640 :
641 : // Sign extend if necessary.
36: branch 1 taken
25: branch 2 taken
642 61: if (LV.isBitfieldSigned()) {
643 : llvm::Value *ExtraBits = llvm::ConstantInt::get(EltTy,
644 36: EltTySize - BitfieldSize);
645 : Val = Builder.CreateAShr(Builder.CreateShl(Val, ExtraBits),
646 36: ExtraBits, "bf.val.sext");
647 : }
648 :
649 : // The bitfield type and the normal type differ when the storage sizes differ
650 : // (currently just _Bool).
651 61: Val = Builder.CreateIntCast(Val, ConvertType(ExprType), false, "tmp");
652 :
653 61: return RValue::get(Val);
654 : }
655 :
656 : RValue CodeGenFunction::EmitLoadOfPropertyRefLValue(LValue LV,
657 25: QualType ExprType) {
658 25: return EmitObjCPropertyGet(LV.getPropertyRefExpr());
659 : }
660 :
661 : RValue CodeGenFunction::EmitLoadOfKVCRefLValue(LValue LV,
662 5: QualType ExprType) {
663 5: return EmitObjCPropertyGet(LV.getKVCRefExpr());
664 : }
665 :
666 : // If this is a reference to a subset of the elements of a vector, create an
667 : // appropriate shufflevector.
668 : RValue CodeGenFunction::EmitLoadOfExtVectorElementLValue(LValue LV,
669 37: QualType ExprType) {
670 : llvm::Value *Vec = Builder.CreateLoad(LV.getExtVectorAddr(),
671 37: LV.isVolatileQualified(), "tmp");
672 :
673 37: const llvm::Constant *Elts = LV.getExtVectorElts();
674 :
675 : // If the result of the expression is a non-vector type, we must be extracting
676 : // a single element. Just codegen as an extractelement.
677 37: const VectorType *ExprVT = ExprType->getAs<VectorType>();
9: branch 0 taken
28: branch 1 taken
678 37: if (!ExprVT) {
679 9: unsigned InIdx = getAccessedFieldNo(0, Elts);
680 : llvm::Value *Elt = llvm::ConstantInt::get(
681 9: llvm::Type::getInt32Ty(VMContext), InIdx);
682 9: return RValue::get(Builder.CreateExtractElement(Vec, Elt, "tmp"));
683 : }
684 :
685 : // Always use shuffle vector to try to retain the original program structure
686 28: unsigned NumResultElts = ExprVT->getNumElements();
687 :
688 28: llvm::SmallVector<llvm::Constant*, 4> Mask;
75: branch 0 taken
28: branch 1 taken
689 103: for (unsigned i = 0; i != NumResultElts; ++i) {
690 75: unsigned InIdx = getAccessedFieldNo(i, Elts);
691 : Mask.push_back(llvm::ConstantInt::get(
692 75: llvm::Type::getInt32Ty(VMContext), InIdx));
693 : }
694 :
695 28: llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size());
696 : Vec = Builder.CreateShuffleVector(Vec,
697 : llvm::UndefValue::get(Vec->getType()),
698 28: MaskV, "tmp");
699 28: return RValue::get(Vec);
700 : }
701 :
702 :
703 :
704 : /// EmitStoreThroughLValue - Store the specified rvalue into the specified
705 : /// lvalue, where both are guaranteed to the have the same type, and that type
706 : /// is 'Ty'.
707 : void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst,
708 1505: QualType Ty) {
54: branch 1 taken
1451: branch 2 taken
709 1505: if (!Dst.isSimple()) {
3: branch 1 taken
51: branch 2 taken
710 54: if (Dst.isVectorElt()) {
711 : // Read/modify/write the vector, inserting the new element.
712 : llvm::Value *Vec = Builder.CreateLoad(Dst.getVectorAddr(),
713 3: Dst.isVolatileQualified(), "tmp");
714 : Vec = Builder.CreateInsertElement(Vec, Src.getScalarVal(),
715 3: Dst.getVectorIdx(), "vecins");
716 3: Builder.CreateStore(Vec, Dst.getVectorAddr(),Dst.isVolatileQualified());
717 3: return;
718 : }
719 :
720 : // If this is an update of extended vector elements, insert them as
721 : // appropriate.
8: branch 1 taken
43: branch 2 taken
722 51: if (Dst.isExtVectorElt())
723 8: return EmitStoreThroughExtVectorComponentLValue(Src, Dst, Ty);
724 :
10: branch 1 taken
33: branch 2 taken
725 43: if (Dst.isBitfield())
726 10: return EmitStoreThroughBitfieldLValue(Src, Dst, Ty);
727 :
29: branch 1 taken
4: branch 2 taken
728 33: if (Dst.isPropertyRef())
729 29: return EmitStoreThroughPropertyRefLValue(Src, Dst, Ty);
730 :
4: branch 1 taken
0: branch 2 not taken
731 4: assert(Dst.isKVCRef() && "Unknown LValue type");
732 4: return EmitStoreThroughKVCRefLValue(Src, Dst, Ty);
733 : }
734 :
12: branch 1 taken
1439: branch 2 taken
11: branch 4 taken
1: branch 5 taken
11: branch 6 taken
1440: branch 7 taken
735 1451: if (Dst.isObjCWeak() && !Dst.isNonGC()) {
736 : // load of a __weak object.
737 11: llvm::Value *LvalueDst = Dst.getAddress();
738 11: llvm::Value *src = Src.getScalarVal();
739 11: CGM.getObjCRuntime().EmitObjCWeakAssign(*this, src, LvalueDst);
740 11: return;
741 : }
742 :
111: branch 1 taken
1329: branch 2 taken
111: branch 4 taken
0: branch 5 not taken
111: branch 6 taken
1329: branch 7 taken
743 1440: if (Dst.isObjCStrong() && !Dst.isNonGC()) {
744 : // load of a __strong object.
745 111: llvm::Value *LvalueDst = Dst.getAddress();
746 111: llvm::Value *src = Src.getScalarVal();
36: branch 1 taken
75: branch 2 taken
747 111: if (Dst.isObjCIvar()) {
36: branch 1 taken
0: branch 2 not taken
748 36: assert(Dst.getBaseIvarExp() && "BaseIvarExp is NULL");
749 36: const llvm::Type *ResultType = ConvertType(getContext().LongTy);
750 36: llvm::Value *RHS = EmitScalarExpr(Dst.getBaseIvarExp());
751 36: llvm::Value *dst = RHS;
752 36: RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast");
753 : llvm::Value *LHS =
754 36: Builder.CreatePtrToInt(LvalueDst, ResultType, "sub.ptr.lhs.cast");
755 36: llvm::Value *BytesBetween = Builder.CreateSub(LHS, RHS, "ivar.offset");
756 : CGM.getObjCRuntime().EmitObjCIvarAssign(*this, src, dst,
757 36: BytesBetween);
53: branch 1 taken
22: branch 2 taken
758 75: } else if (Dst.isGlobalObjCRef())
759 53: CGM.getObjCRuntime().EmitObjCGlobalAssign(*this, src, LvalueDst);
760 : else
761 22: CGM.getObjCRuntime().EmitObjCStrongCastAssign(*this, src, LvalueDst);
762 111: return;
763 : }
764 :
1329: branch 1 taken
0: branch 2 not taken
765 1329: assert(Src.isScalar() && "Can't emit an agg store with this method");
766 : EmitStoreOfScalar(Src.getScalarVal(), Dst.getAddress(),
767 1329: Dst.isVolatileQualified(), Ty);
768 : }
769 :
770 : void CodeGenFunction::EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst,
771 : QualType Ty,
772 69: llvm::Value **Result) {
773 69: unsigned StartBit = Dst.getBitfieldStartBit();
774 69: unsigned BitfieldSize = Dst.getBitfieldSize();
775 69: llvm::Value *Ptr = Dst.getBitfieldAddr();
776 :
777 : const llvm::Type *EltTy =
778 69: cast<llvm::PointerType>(Ptr->getType())->getElementType();
779 69: unsigned EltTySize = CGM.getTargetData().getTypeSizeInBits(EltTy);
780 :
781 : // Get the new value, cast to the appropriate type and masked to exactly the
782 : // size of the bit-field.
783 69: llvm::Value *SrcVal = Src.getScalarVal();
784 69: llvm::Value *NewVal = Builder.CreateIntCast(SrcVal, EltTy, false, "tmp");
785 : llvm::Constant *Mask = llvm::ConstantInt::get(VMContext,
786 69: llvm::APInt::getLowBitsSet(EltTySize, BitfieldSize));
787 69: NewVal = Builder.CreateAnd(NewVal, Mask, "bf.value");
788 :
789 : // Return the new value of the bit-field, if requested.
58: branch 0 taken
11: branch 1 taken
790 69: if (Result) {
791 : // Cast back to the proper type for result.
792 58: const llvm::Type *SrcTy = SrcVal->getType();
793 : llvm::Value *SrcTrunc = Builder.CreateIntCast(NewVal, SrcTy, false,
794 58: "bf.reload.val");
795 :
796 : // Sign extend if necessary.
36: branch 1 taken
22: branch 2 taken
797 58: if (Dst.isBitfieldSigned()) {
798 36: unsigned SrcTySize = CGM.getTargetData().getTypeSizeInBits(SrcTy);
799 : llvm::Value *ExtraBits = llvm::ConstantInt::get(SrcTy,
800 36: SrcTySize - BitfieldSize);
801 : SrcTrunc = Builder.CreateAShr(Builder.CreateShl(SrcTrunc, ExtraBits),
802 36: ExtraBits, "bf.reload.sext");
803 : }
804 :
805 58: *Result = SrcTrunc;
806 : }
807 :
808 : // In some cases the bitfield may straddle two memory locations. Emit the low
809 : // part first and check to see if the high needs to be done.
810 69: unsigned LowBits = std::min(BitfieldSize, EltTySize - StartBit);
811 : llvm::Value *LowVal = Builder.CreateLoad(Ptr, Dst.isVolatileQualified(),
812 69: "bf.prev.low");
813 :
814 : // Compute the mask for zero-ing the low part of this bitfield.
815 : llvm::Constant *InvMask =
816 : llvm::ConstantInt::get(VMContext,
817 69: ~llvm::APInt::getBitsSet(EltTySize, StartBit, StartBit + LowBits));
818 :
819 : // Compute the new low part as
820 : // LowVal = (LowVal & InvMask) | (NewVal << StartBit),
821 : // with the shift of NewVal implicitly stripping the high bits.
822 : llvm::Value *NewLowVal =
823 69: Builder.CreateShl(NewVal, StartBit, "bf.value.lo");
824 69: LowVal = Builder.CreateAnd(LowVal, InvMask, "bf.prev.lo.cleared");
825 69: LowVal = Builder.CreateOr(LowVal, NewLowVal, "bf.new.lo");
826 :
827 : // Write back.
828 69: Builder.CreateStore(LowVal, Ptr, Dst.isVolatileQualified());
829 :
830 : // If the low part doesn't cover the bitfield emit a high part.
4: branch 0 taken
65: branch 1 taken
831 69: if (LowBits < BitfieldSize) {
832 4: unsigned HighBits = BitfieldSize - LowBits;
833 : llvm::Value *HighPtr = Builder.CreateGEP(Ptr, llvm::ConstantInt::get(
834 4: llvm::Type::getInt32Ty(VMContext), 1), "bf.ptr.hi");
835 : llvm::Value *HighVal = Builder.CreateLoad(HighPtr,
836 : Dst.isVolatileQualified(),
837 4: "bf.prev.hi");
838 :
839 : // Compute the mask for zero-ing the high part of this bitfield.
840 : llvm::Constant *InvMask =
841 : llvm::ConstantInt::get(VMContext, ~llvm::APInt::getLowBitsSet(EltTySize,
842 4: HighBits));
843 :
844 : // Compute the new high part as
845 : // HighVal = (HighVal & InvMask) | (NewVal lshr LowBits),
846 : // where the high bits of NewVal have already been cleared and the
847 : // shift stripping the low bits.
848 : llvm::Value *NewHighVal =
849 4: Builder.CreateLShr(NewVal, LowBits, "bf.value.high");
850 4: HighVal = Builder.CreateAnd(HighVal, InvMask, "bf.prev.hi.cleared");
851 4: HighVal = Builder.CreateOr(HighVal, NewHighVal, "bf.new.hi");
852 :
853 : // Write back.
854 4: Builder.CreateStore(HighVal, HighPtr, Dst.isVolatileQualified());
855 : }
856 69: }
857 :
858 : void CodeGenFunction::EmitStoreThroughPropertyRefLValue(RValue Src,
859 : LValue Dst,
860 29: QualType Ty) {
861 29: EmitObjCPropertySet(Dst.getPropertyRefExpr(), Src);
862 29: }
863 :
864 : void CodeGenFunction::EmitStoreThroughKVCRefLValue(RValue Src,
865 : LValue Dst,
866 4: QualType Ty) {
867 4: EmitObjCPropertySet(Dst.getKVCRefExpr(), Src);
868 4: }
869 :
870 : void CodeGenFunction::EmitStoreThroughExtVectorComponentLValue(RValue Src,
871 : LValue Dst,
872 8: QualType Ty) {
873 : // This access turns into a read/modify/write of the vector. Load the input
874 : // value now.
875 : llvm::Value *Vec = Builder.CreateLoad(Dst.getExtVectorAddr(),
876 8: Dst.isVolatileQualified(), "tmp");
877 8: const llvm::Constant *Elts = Dst.getExtVectorElts();
878 :
879 8: llvm::Value *SrcVal = Src.getScalarVal();
880 :
2: branch 2 taken
6: branch 3 taken
881 8: if (const VectorType *VTy = Ty->getAs<VectorType>()) {
882 2: unsigned NumSrcElts = VTy->getNumElements();
883 : unsigned NumDstElts =
884 2: cast<llvm::VectorType>(Vec->getType())->getNumElements();
1: branch 0 taken
1: branch 1 taken
885 2: if (NumDstElts == NumSrcElts) {
886 : // Use shuffle vector is the src and destination are the same number of
887 : // elements and restore the vector mask since it is on the side it will be
888 : // stored.
889 1: llvm::SmallVector<llvm::Constant*, 4> Mask(NumDstElts);
2: branch 0 taken
1: branch 1 taken
890 3: for (unsigned i = 0; i != NumSrcElts; ++i) {
891 2: unsigned InIdx = getAccessedFieldNo(i, Elts);
892 : Mask[InIdx] = llvm::ConstantInt::get(
893 2: llvm::Type::getInt32Ty(VMContext), i);
894 : }
895 :
896 1: llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size());
897 : Vec = Builder.CreateShuffleVector(SrcVal,
898 : llvm::UndefValue::get(Vec->getType()),
899 1: MaskV, "tmp");
1: branch 0 taken
0: branch 1 not taken
900 1: } else if (NumDstElts > NumSrcElts) {
901 : // Extended the source vector to the same length and then shuffle it
902 : // into the destination.
903 : // FIXME: since we're shuffling with undef, can we just use the indices
904 : // into that? This could be simpler.
905 1: llvm::SmallVector<llvm::Constant*, 4> ExtMask;
906 1: const llvm::Type *Int32Ty = llvm::Type::getInt32Ty(VMContext);
907 : unsigned i;
3: branch 0 taken
1: branch 1 taken
908 4: for (i = 0; i != NumSrcElts; ++i)
909 3: ExtMask.push_back(llvm::ConstantInt::get(Int32Ty, i));
1: branch 0 taken
1: branch 1 taken
910 2: for (; i != NumDstElts; ++i)
911 1: ExtMask.push_back(llvm::UndefValue::get(Int32Ty));
912 : llvm::Value *ExtMaskV = llvm::ConstantVector::get(&ExtMask[0],
913 1: ExtMask.size());
914 : llvm::Value *ExtSrcVal =
915 : Builder.CreateShuffleVector(SrcVal,
916 : llvm::UndefValue::get(SrcVal->getType()),
917 1: ExtMaskV, "tmp");
918 : // build identity
919 1: llvm::SmallVector<llvm::Constant*, 4> Mask;
4: branch 0 taken
1: branch 1 taken
920 5: for (unsigned i = 0; i != NumDstElts; ++i)
921 4: Mask.push_back(llvm::ConstantInt::get(Int32Ty, i));
922 :
923 : // modify when what gets shuffled in
3: branch 0 taken
1: branch 1 taken
924 4: for (unsigned i = 0; i != NumSrcElts; ++i) {
925 3: unsigned Idx = getAccessedFieldNo(i, Elts);
926 3: Mask[Idx] = llvm::ConstantInt::get(Int32Ty, i+NumDstElts);
927 : }
928 1: llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size());
929 1: Vec = Builder.CreateShuffleVector(Vec, ExtSrcVal, MaskV, "tmp");
930 : } else {
931 : // We should never shorten the vector
932 0: assert(0 && "unexpected shorten vector length");
933 : }
934 : } else {
935 : // If the Src is a scalar (not a vector) it must be updating one element.
936 6: unsigned InIdx = getAccessedFieldNo(0, Elts);
937 6: const llvm::Type *Int32Ty = llvm::Type::getInt32Ty(VMContext);
938 6: llvm::Value *Elt = llvm::ConstantInt::get(Int32Ty, InIdx);
939 6: Vec = Builder.CreateInsertElement(Vec, SrcVal, Elt, "tmp");
940 : }
941 :
942 8: Builder.CreateStore(Vec, Dst.getExtVectorAddr(), Dst.isVolatileQualified());
943 8: }
944 :
945 : // setObjCGCLValueClass - sets class of he lvalue for the purpose of
946 : // generating write-barries API. It is currently a global, ivar,
947 : // or neither.
948 : static void setObjCGCLValueClass(const ASTContext &Ctx, const Expr *E,
949 5621: LValue &LV) {
4884: branch 2 taken
737: branch 3 taken
950 5621: if (Ctx.getLangOptions().getGCMode() == LangOptions::NonGC)
951 4884: return;
952 :
135: branch 1 taken
602: branch 2 taken
953 737: if (isa<ObjCIvarRefExpr>(E)) {
954 135: LV.SetObjCIvar(LV, true);
955 135: ObjCIvarRefExpr *Exp = cast<ObjCIvarRefExpr>(const_cast<Expr*>(E));
956 135: LV.setBaseIvarExp(Exp->getBase());
957 135: LV.SetObjCArray(LV, E->getType()->isArrayType());
958 135: return;
959 : }
960 :
366: branch 1 taken
236: branch 2 taken
961 602: if (const DeclRefExpr *Exp = dyn_cast<DeclRefExpr>(E)) {
366: branch 2 taken
0: branch 3 not taken
962 366: if (const VarDecl *VD = dyn_cast<VarDecl>(Exp->getDecl())) {
134: branch 1 taken
232: branch 2 taken
92: branch 4 taken
42: branch 5 taken
132: branch 7 taken
192: branch 8 taken
174: branch 9 taken
192: branch 10 taken
963 366: if ((VD->isBlockVarDecl() && !VD->hasLocalStorage()) ||
964 : VD->isFileVarDecl())
965 174: LV.SetGlobalObjCRef(LV, true);
966 : }
967 366: LV.SetObjCArray(LV, E->getType()->isArrayType());
968 366: return;
969 : }
970 :
8: branch 1 taken
228: branch 2 taken
971 236: if (const UnaryOperator *Exp = dyn_cast<UnaryOperator>(E)) {
972 8: setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV);
973 8: return;
974 : }
975 :
11: branch 1 taken
217: branch 2 taken
976 228: if (const ParenExpr *Exp = dyn_cast<ParenExpr>(E)) {
977 11: setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV);
6: branch 1 taken
5: branch 2 taken
978 11: if (LV.isObjCIvar()) {
979 : // If cast is to a structure pointer, follow gcc's behavior and make it
980 : // a non-ivar write-barrier.
981 6: QualType ExpTy = E->getType();
5: branch 2 taken
1: branch 3 taken
982 6: if (ExpTy->isPointerType())
983 5: ExpTy = ExpTy->getAs<PointerType>()->getPointeeType();
4: branch 2 taken
2: branch 3 taken
984 6: if (ExpTy->isRecordType())
985 4: LV.SetObjCIvar(LV, false);
986 : }
987 11: return;
988 : }
50: branch 1 taken
167: branch 2 taken
989 217: if (const ImplicitCastExpr *Exp = dyn_cast<ImplicitCastExpr>(E)) {
990 50: setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV);
991 50: return;
992 : }
993 :
8: branch 1 taken
159: branch 2 taken
994 167: if (const CStyleCastExpr *Exp = dyn_cast<CStyleCastExpr>(E)) {
995 8: setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV);
996 8: return;
997 : }
998 :
75: branch 1 taken
84: branch 2 taken
999 159: if (const ArraySubscriptExpr *Exp = dyn_cast<ArraySubscriptExpr>(E)) {
1000 75: setObjCGCLValueClass(Ctx, Exp->getBase(), LV);
41: branch 1 taken
34: branch 2 taken
19: branch 4 taken
22: branch 5 taken
19: branch 6 taken
56: branch 7 taken
1001 75: if (LV.isObjCIvar() && !LV.isObjCArray())
1002 : // Using array syntax to assigning to what an ivar points to is not
1003 : // same as assigning to the ivar itself. {id *Names;} Names[i] = 0;
1004 19: LV.SetObjCIvar(LV, false);
30: branch 1 taken
26: branch 2 taken
1: branch 4 taken
29: branch 5 taken
1: branch 6 taken
55: branch 7 taken
1005 56: else if (LV.isGlobalObjCRef() && !LV.isObjCArray())
1006 : // Using array syntax to assigning to what global points to is not
1007 : // same as assigning to the global itself. {id *G;} G[i] = 0;
1008 1: LV.SetGlobalObjCRef(LV, false);
1009 75: return;
1010 : }
1011 :
84: branch 1 taken
0: branch 2 not taken
1012 84: if (const MemberExpr *Exp = dyn_cast<MemberExpr>(E)) {
1013 84: setObjCGCLValueClass(Ctx, Exp->getBase(), LV);
1014 : // We don't know if member is an 'ivar', but this flag is looked at
1015 : // only in the context of LV.isObjCIvar().
1016 84: LV.SetObjCArray(LV, E->getType()->isArrayType());
1017 84: return;
1018 : }
1019 : }
1020 :
1021 : static LValue EmitGlobalVarDeclLValue(CodeGenFunction &CGF,
1022 703: const Expr *E, const VarDecl *VD) {
1023 : assert((VD->hasExternalStorage() || VD->isFileVarDecl()) &&
645: branch 1 taken
58: branch 2 taken
645: branch 4 taken
0: branch 5 not taken
1024 703: "Var decl must have external storage or be a file var decl!");
1025 :
1026 703: llvm::Value *V = CGF.CGM.GetAddrOfGlobalVar(VD);
2: branch 3 taken
701: branch 4 taken
1027 703: if (VD->getType()->isReferenceType())
1028 2: V = CGF.Builder.CreateLoad(V, "tmp");
1029 703: LValue LV = LValue::MakeAddr(V, CGF.MakeQualifiers(E->getType()));
1030 703: setObjCGCLValueClass(CGF.getContext(), E, LV);
1031 : return LV;
1032 : }
1033 :
1034 : static LValue EmitFunctionDeclLValue(CodeGenFunction &CGF,
1035 765: const Expr *E, const FunctionDecl *FD) {
1036 765: llvm::Value* V = CGF.CGM.GetAddrOfFunction(FD);
111: branch 1 taken
654: branch 2 taken
1037 765: if (!FD->hasPrototype()) {
3: branch 0 taken
108: branch 1 taken
1038 111: if (const FunctionProtoType *Proto =
1039 111: FD->getType()->getAs<FunctionProtoType>()) {
1040 : // Ugly case: for a K&R-style definition, the type of the definition
1041 : // isn't the same as the type of a use. Correct for this with a
1042 : // bitcast.
1043 : QualType NoProtoType =
1044 3: CGF.getContext().getFunctionNoProtoType(Proto->getResultType());
1045 3: NoProtoType = CGF.getContext().getPointerType(NoProtoType);
1046 3: V = CGF.Builder.CreateBitCast(V, CGF.ConvertType(NoProtoType), "tmp");
1047 : }
1048 : }
1049 765: return LValue::MakeAddr(V, CGF.MakeQualifiers(E->getType()));
1050 : }
1051 :
1052 5129: LValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) {
1053 5129: const NamedDecl *ND = E->getDecl();
1054 :
4347: branch 1 taken
782: branch 2 taken
1055 5129: if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) {
1056 :
1057 : // Check if this is a global variable.
4289: branch 1 taken
58: branch 2 taken
643: branch 4 taken
3646: branch 5 taken
701: branch 6 taken
3646: branch 7 taken
1058 4347: if (VD->hasExternalStorage() || VD->isFileVarDecl())
1059 701: return EmitGlobalVarDeclLValue(*this, E, VD);
1060 :
3591: branch 1 taken
55: branch 2 taken
3576: branch 4 taken
15: branch 5 taken
1061 3646: bool NonGCable = VD->hasLocalStorage() && !VD->hasAttr<BlocksAttr>();
1062 :
1063 3646: llvm::Value *V = LocalDeclMap[VD];
0: branch 0 not taken
3646: branch 1 taken
1064 3646: assert(V && "DeclRefExpr not entered in LocalDeclMap?");
1065 :
1066 3646: Qualifiers Quals = MakeQualifiers(E->getType());
1067 : // local variables do not get their gc attribute set.
1068 : // local static?
3576: branch 0 taken
70: branch 1 taken
1069 3646: if (NonGCable) Quals.removeObjCGCAttr();
1070 :
15: branch 1 taken
3631: branch 2 taken
1071 3646: if (VD->hasAttr<BlocksAttr>()) {
1072 15: V = Builder.CreateStructGEP(V, 1, "forwarding");
1073 15: V = Builder.CreateLoad(V);
1074 : V = Builder.CreateStructGEP(V, getByRefValueLLVMField(VD),
1075 15: VD->getNameAsString());
1076 : }
90: branch 3 taken
3556: branch 4 taken
1077 3646: if (VD->getType()->isReferenceType())
1078 90: V = Builder.CreateLoad(V, "tmp");
1079 3646: LValue LV = LValue::MakeAddr(V, Quals);
1080 3646: LValue::SetObjCNonGC(LV, NonGCable);
1081 3646: setObjCGCLValueClass(getContext(), E, LV);
1082 3646: return LV;
1083 : }
1084 :
765: branch 1 taken
17: branch 2 taken
1085 782: if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND))
1086 765: return EmitFunctionDeclLValue(*this, E, FD);
1087 :
1088 : // FIXME: the qualifier check does not seem sufficient here
17: branch 1 taken
0: branch 2 not taken
1089 17: if (E->getQualifier()) {
1090 17: const FieldDecl *FD = cast<FieldDecl>(ND);
1091 17: llvm::Value *V = CGM.EmitPointerToDataMember(FD);
1092 :
1093 17: return LValue::MakeAddr(V, MakeQualifiers(FD->getType()));
1094 : }
1095 :
1096 0: assert(false && "Unhandled DeclRefExpr");
1097 :
1098 : // an invalid LValue, but the assert will
1099 : // ensure that this point is never reached.
1100 : return LValue();
1101 : }
1102 :
1103 19: LValue CodeGenFunction::EmitBlockDeclRefLValue(const BlockDeclRefExpr *E) {
1104 19: return LValue::MakeAddr(GetAddrOfBlockDecl(E), MakeQualifiers(E->getType()));
1105 : }
1106 :
1107 109: LValue CodeGenFunction::EmitUnaryOpLValue(const UnaryOperator *E) {
1108 : // __extension__ doesn't affect lvalue-ness.
0: branch 1 not taken
109: branch 2 taken
1109 109: if (E->getOpcode() == UnaryOperator::Extension)
1110 0: return EmitLValue(E->getSubExpr());
1111 :
1112 109: QualType ExprTy = getContext().getCanonicalType(E->getSubExpr()->getType());
0: branch 1 not taken
104: branch 2 taken
4: branch 3 taken
1: branch 4 taken
1113 109: switch (E->getOpcode()) {
1114 0: default: assert(0 && "Unknown unary operator lvalue!");
1115 : case UnaryOperator::Deref: {
1116 104: QualType T = E->getSubExpr()->getType()->getPointeeType();
104: branch 1 taken
0: branch 2 not taken
1117 104: assert(!T.isNull() && "CodeGenFunction::EmitUnaryOpLValue: Illegal type");
1118 :
1119 104: Qualifiers Quals = MakeQualifiers(T);
1120 104: Quals.setAddressSpace(ExprTy.getAddressSpace());
1121 :
1122 104: LValue LV = LValue::MakeAddr(EmitScalarExpr(E->getSubExpr()), Quals);
1123 : // We should not generate __weak write barrier on indirect reference
1124 : // of a pointer to object; as in void foo (__weak id *param); *param = 0;
1125 : // But, we continue to generate __strong write barrier on indirect write
1126 : // into a pointer to object.
22: branch 2 taken
82: branch 3 taken
16: branch 7 taken
6: branch 8 taken
5: branch 10 taken
11: branch 11 taken
5: branch 12 taken
99: branch 13 taken
1127 126: if (getContext().getLangOptions().ObjC1 &&
1128 : getContext().getLangOptions().getGCMode() != LangOptions::NonGC &&
1129 : LV.isObjCWeak())
1130 5: LValue::SetObjCNonGC(LV, !E->isOBJCGCCandidate(getContext()));
1131 104: return LV;
1132 : }
1133 : case UnaryOperator::Real:
1134 : case UnaryOperator::Imag: {
1135 4: LValue LV = EmitLValue(E->getSubExpr());
1136 4: unsigned Idx = E->getOpcode() == UnaryOperator::Imag;
1137 : return LValue::MakeAddr(Builder.CreateStructGEP(LV.getAddress(),
1138 : Idx, "idx"),
1139 4: MakeQualifiers(ExprTy));
1140 : }
1141 : case UnaryOperator::PreInc:
1142 : case UnaryOperator::PreDec: {
1143 1: LValue LV = EmitLValue(E->getSubExpr());
1144 1: bool isInc = E->getOpcode() == UnaryOperator::PreInc;
1145 :
0: branch 3 not taken
1: branch 4 taken
1146 1: if (E->getType()->isAnyComplexType())
1147 0: EmitComplexPrePostIncDec(E, LV, isInc, true/*isPre*/);
1148 : else
1149 1: EmitScalarPrePostIncDec(E, LV, isInc, true/*isPre*/);
1150 1: return LV;
1151 : }
1152 : }
1153 : }
1154 :
1155 600: LValue CodeGenFunction::EmitStringLiteralLValue(const StringLiteral *E) {
1156 : return LValue::MakeAddr(CGM.GetAddrOfConstantStringFromLiteral(E),
1157 600: Qualifiers());
1158 : }
1159 :
1160 12: LValue CodeGenFunction::EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E) {
1161 : return LValue::MakeAddr(CGM.GetAddrOfConstantStringFromObjCEncode(E),
1162 12: Qualifiers());
1163 : }
1164 :
1165 :
1166 180: LValue CodeGenFunction::EmitPredefinedFunctionName(unsigned Type) {
1167 180: std::string GlobalVarName;
1168 :
0: branch 0 not taken
56: branch 1 taken
56: branch 2 taken
68: branch 3 taken
1169 180: switch (Type) {
1170 0: default: assert(0 && "Invalid type");
1171 : case PredefinedExpr::Func:
1172 56: GlobalVarName = "__func__.";
1173 56: break;
1174 : case PredefinedExpr::Function:
1175 56: GlobalVarName = "__FUNCTION__.";
1176 56: break;
1177 : case PredefinedExpr::PrettyFunction:
1178 68: GlobalVarName = "__PRETTY_FUNCTION__.";
1179 : break;
1180 : }
1181 :
1182 180: llvm::StringRef FnName = CurFn->getName();
36: branch 2 taken
144: branch 3 taken
1183 180: if (FnName.startswith("\01"))
1184 36: FnName = FnName.substr(1);
1185 180: GlobalVarName += FnName;
1186 :
1187 : std::string FunctionName =
1188 : PredefinedExpr::ComputeName(getContext(), (PredefinedExpr::IdentType)Type,
1189 180: CurCodeDecl);
1190 :
1191 : llvm::Constant *C =
1192 180: CGM.GetAddrOfConstantCString(FunctionName, GlobalVarName.c_str());
1193 180: return LValue::MakeAddr(C, Qualifiers());
1194 : }
1195 :
1196 179: LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) {
0: branch 1 not taken
179: branch 2 taken
1197 179: switch (E->getIdentType()) {
1198 : default:
1199 0: return EmitUnsupportedLValue(E, "predefined expression");
1200 : case PredefinedExpr::Func:
1201 : case PredefinedExpr::Function:
1202 : case PredefinedExpr::PrettyFunction:
1203 179: return EmitPredefinedFunctionName(E->getIdentType());
1204 : }
1205 : }
1206 :
1207 0: llvm::BasicBlock *CodeGenFunction::getTrapBB() {
1208 0: const CodeGenOptions &GCO = CGM.getCodeGenOpts();
1209 :
1210 : // If we are not optimzing, don't collapse all calls to trap in the function
1211 : // to the same call, that way, in the debugger they can see which operation
1212 : // did in fact fail. If we are optimizing, we collpase all call to trap down
1213 : // to just one per function to save on codesize.
0: branch 0 not taken
0: branch 1 not taken
0: branch 2 not taken
0: branch 3 not taken
1214 0: if (GCO.OptimizationLevel
1215 : && TrapBB)
1216 0: return TrapBB;
1217 :
1218 0: llvm::BasicBlock *Cont = 0;
0: branch 1 not taken
0: branch 2 not taken
1219 0: if (HaveInsertPoint()) {
1220 0: Cont = createBasicBlock("cont");
1221 0: EmitBranch(Cont);
1222 : }
1223 0: TrapBB = createBasicBlock("trap");
1224 0: EmitBlock(TrapBB);
1225 :
1226 0: llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::trap, 0, 0);
1227 0: llvm::CallInst *TrapCall = Builder.CreateCall(F);
1228 0: TrapCall->setDoesNotReturn();
1229 0: TrapCall->setDoesNotThrow();
1230 0: Builder.CreateUnreachable();
1231 :
0: branch 0 not taken
0: branch 1 not taken
1232 0: if (Cont)
1233 0: EmitBlock(Cont);
1234 0: return TrapBB;
1235 : }
1236 :
1237 258: LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) {
1238 : // The index must always be an integer, which is not an aggregate. Emit it.
1239 258: llvm::Value *Idx = EmitScalarExpr(E->getIdx());
1240 258: QualType IdxTy = E->getIdx()->getType();
1241 258: bool IdxSigned = IdxTy->isSignedIntegerType();
1242 :
1243 : // If the base is a vector type, then we are forming a vector element lvalue
1244 : // with this subscript.
4: branch 4 taken
254: branch 5 taken
1245 258: if (E->getBase()->getType()->isVectorType()) {
1246 : // Emit the vector as an lvalue to get its address.
1247 4: LValue LHS = EmitLValue(E->getBase());
4: branch 1 taken
0: branch 2 not taken
1248 4: assert(LHS.isSimple() && "Can only subscript lvalue vectors here!");
1249 : Idx = Builder.CreateIntCast(Idx,
1250 4: llvm::Type::getInt32Ty(VMContext), IdxSigned, "vidx");
1251 : return LValue::MakeVectorElt(LHS.getAddress(), Idx,
1252 4: E->getBase()->getType().getCVRQualifiers());
1253 : }
1254 :
1255 : // The base must be a pointer, which is not an aggregate. Emit it.
1256 254: llvm::Value *Base = EmitScalarExpr(E->getBase());
1257 :
1258 : // Extend or truncate the index type to 32 or 64-bits.
1259 254: unsigned IdxBitwidth = cast<llvm::IntegerType>(Idx->getType())->getBitWidth();
130: branch 0 taken
124: branch 1 taken
1260 254: if (IdxBitwidth != LLVMPointerWidth)
1261 : Idx = Builder.CreateIntCast(Idx,
1262 : llvm::IntegerType::get(VMContext, LLVMPointerWidth),
1263 130: IdxSigned, "idxprom");
1264 :
1265 : // FIXME: As llvm implements the object size checking, this can come out.
0: branch 0 not taken
254: branch 1 taken
1266 254: if (CatchUndefined) {
0: branch 2 not taken
0: branch 3 not taken
1267 0: if (const ImplicitCastExpr *ICE=dyn_cast<ImplicitCastExpr>(E->getBase())) {
0: branch 2 not taken
0: branch 3 not taken
1268 0: if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr())) {
0: branch 1 not taken
0: branch 2 not taken
1269 0: if (ICE->getCastKind() == CastExpr::CK_ArrayToPointerDecay) {
0: branch 0 not taken
0: branch 1 not taken
1270 0: if (const ConstantArrayType *CAT
1271 0: = getContext().getAsConstantArrayType(DRE->getType())) {
1272 0: llvm::APInt Size = CAT->getSize();
1273 0: llvm::BasicBlock *Cont = createBasicBlock("cont");
1274 : Builder.CreateCondBr(Builder.CreateICmpULE(Idx,
1275 : llvm::ConstantInt::get(Idx->getType(), Size)),
1276 0: Cont, getTrapBB());
1277 0: EmitBlock(Cont);
1278 : }
1279 : }
1280 : }
1281 : }
1282 : }
1283 :
1284 : // We know that the pointer points to a type of the correct size, unless the
1285 : // size is a VLA or Objective-C interface.
1286 254: llvm::Value *Address = 0;
1: branch 0 taken
253: branch 1 taken
1287 254: if (const VariableArrayType *VAT =
1288 254: getContext().getAsVariableArrayType(E->getType())) {
1289 1: llvm::Value *VLASize = GetVLASize(VAT);
1290 :
1291 1: Idx = Builder.CreateMul(Idx, VLASize);
1292 :
1293 1: QualType BaseType = getContext().getBaseElementType(VAT);
1294 :
1295 1: CharUnits BaseTypeSize = getContext().getTypeSizeInChars(BaseType);
1296 : Idx = Builder.CreateUDiv(Idx,
1297 : llvm::ConstantInt::get(Idx->getType(),
1298 1: BaseTypeSize.getQuantity()));
1299 1: Address = Builder.CreateInBoundsGEP(Base, Idx, "arrayidx");
5: branch 0 taken
248: branch 1 taken
1300 253: } else if (const ObjCInterfaceType *OIT =
1301 253: dyn_cast<ObjCInterfaceType>(E->getType())) {
1302 : llvm::Value *InterfaceSize =
1303 : llvm::ConstantInt::get(Idx->getType(),
1304 5: getContext().getTypeSizeInChars(OIT).getQuantity());
1305 :
1306 5: Idx = Builder.CreateMul(Idx, InterfaceSize);
1307 :
1308 5: const llvm::Type *i8PTy = llvm::Type::getInt8PtrTy(VMContext);
1309 : Address = Builder.CreateGEP(Builder.CreateBitCast(Base, i8PTy),
1310 5: Idx, "arrayidx");
1311 5: Address = Builder.CreateBitCast(Address, Base->getType());
1312 : } else {
1313 248: Address = Builder.CreateInBoundsGEP(Base, Idx, "arrayidx");
1314 : }
1315 :
1316 254: QualType T = E->getBase()->getType()->getPointeeType();
1317 : assert(!T.isNull() &&
254: branch 1 taken
0: branch 2 not taken
1318 254: "CodeGenFunction::EmitArraySubscriptExpr(): Illegal base type");
1319 :
1320 254: Qualifiers Quals = MakeQualifiers(T);
1321 254: Quals.setAddressSpace(E->getBase()->getType().getAddressSpace());
1322 :
1323 254: LValue LV = LValue::MakeAddr(Address, Quals);
80: branch 2 taken
174: branch 3 taken
70: branch 7 taken
10: branch 8 taken
70: branch 9 taken
184: branch 10 taken
1324 334: if (getContext().getLangOptions().ObjC1 &&
1325 : getContext().getLangOptions().getGCMode() != LangOptions::NonGC) {
1326 70: LValue::SetObjCNonGC(LV, !E->isOBJCGCCandidate(getContext()));
1327 70: setObjCGCLValueClass(getContext(), E, LV);
1328 : }
1329 254: return LV;
1330 : }
1331 :
1332 : static
1333 : llvm::Constant *GenerateConstantVector(llvm::LLVMContext &VMContext,
1334 45: llvm::SmallVector<unsigned, 4> &Elts) {
1335 45: llvm::SmallVector<llvm::Constant*, 4> CElts;
1336 :
106: branch 1 taken
45: branch 2 taken
1337 151: for (unsigned i = 0, e = Elts.size(); i != e; ++i)
1338 : CElts.push_back(llvm::ConstantInt::get(
1339 106: llvm::Type::getInt32Ty(VMContext), Elts[i]));
1340 :
1341 45: return llvm::ConstantVector::get(&CElts[0], CElts.size());
1342 : }
1343 :
1344 : LValue CodeGenFunction::
1345 56: EmitExtVectorElementExpr(const ExtVectorElementExpr *E) {
1346 56: const llvm::Type *Int32Ty = llvm::Type::getInt32Ty(VMContext);
1347 :
1348 : // Emit the base vector as an l-value.
1349 56: LValue Base;
1350 :
1351 : // ExtVectorElementExpr's base can either be a vector or pointer to vector.
1: branch 1 taken
55: branch 2 taken
1352 56: if (E->isArrow()) {
1353 : // If it is a pointer to a vector, emit the address and form an lvalue with
1354 : // it.
1355 1: llvm::Value *Ptr = EmitScalarExpr(E->getBase());
1356 1: const PointerType *PT = E->getBase()->getType()->getAs<PointerType>();
1357 1: Qualifiers Quals = MakeQualifiers(PT->getPointeeType());
1358 1: Quals.removeObjCGCAttr();
1359 1: Base = LValue::MakeAddr(Ptr, Quals);
53: branch 3 taken
2: branch 4 taken
1360 55: } else if (E->getBase()->isLvalue(getContext()) == Expr::LV_Valid) {
1361 : // Otherwise, if the base is an lvalue ( as in the case of foo.x.x),
1362 : // emit the base as an lvalue.
0: branch 4 not taken
53: branch 5 taken
1363 53: assert(E->getBase()->getType()->isVectorType());
1364 53: Base = EmitLValue(E->getBase());
1365 : } else {
1366 : // Otherwise, the base is a normal rvalue (as in (V+V).x), emit it as such.
1367 : assert(E->getBase()->getType()->getAs<VectorType>() &&
2: branch 4 taken
0: branch 5 not taken
1368 2: "Result must be a vector");
1369 2: llvm::Value *Vec = EmitScalarExpr(E->getBase());
1370 :
1371 : // Store the vector to memory (because LValue wants an address).
1372 2: llvm::Value *VecMem = CreateMemTemp(E->getBase()->getType());
1373 2: Builder.CreateStore(Vec, VecMem);
1374 2: Base = LValue::MakeAddr(VecMem, Qualifiers());
1375 : }
1376 :
1377 : // Encode the element access list into a vector of unsigned indices.
1378 56: llvm::SmallVector<unsigned, 4> Indices;
1379 56: E->getEncodedElementAccess(Indices);
1380 :
45: branch 1 taken
11: branch 2 taken
1381 56: if (Base.isSimple()) {
1382 45: llvm::Constant *CV = GenerateConstantVector(VMContext, Indices);
1383 : return LValue::MakeExtVectorElt(Base.getAddress(), CV,
1384 45: Base.getVRQualifiers());
1385 : }
11: branch 1 taken
0: branch 2 not taken
1386 11: assert(Base.isExtVectorElt() && "Can only subscript lvalue vec elts here!");
1387 :
1388 11: llvm::Constant *BaseElts = Base.getExtVectorElts();
1389 11: llvm::SmallVector<llvm::Constant *, 4> CElts;
1390 :
11: branch 1 taken
11: branch 2 taken
1391 22: for (unsigned i = 0, e = Indices.size(); i != e; ++i) {
0: branch 1 not taken
11: branch 2 taken
1392 11: if (isa<llvm::ConstantAggregateZero>(BaseElts))
1393 0: CElts.push_back(llvm::ConstantInt::get(Int32Ty, 0));
1394 : else
1395 11: CElts.push_back(cast<llvm::Constant>(BaseElts->getOperand(Indices[i])));
1396 : }
1397 11: llvm::Constant *CV = llvm::ConstantVector::get(&CElts[0], CElts.size());
1398 : return LValue::MakeExtVectorElt(Base.getExtVectorAddr(), CV,
1399 11: Base.getVRQualifiers());
1400 : }
1401 :
1402 726: LValue CodeGenFunction::EmitMemberExpr(const MemberExpr *E) {
1403 726: bool isNonGC = false;
1404 726: Expr *BaseExpr = E->getBase();
1405 726: llvm::Value *BaseValue = NULL;
1406 726: Qualifiers BaseQuals;
1407 :
1408 : // If this is s.x, emit s as an lvalue. If it is s->x, emit s as a scalar.
354: branch 1 taken
372: branch 2 taken
1409 726: if (E->isArrow()) {
1410 354: BaseValue = EmitScalarExpr(BaseExpr);
1411 : const PointerType *PTy =
1412 354: BaseExpr->getType()->getAs<PointerType>();
1413 354: BaseQuals = PTy->getPointeeType().getQualifiers();
371: branch 2 taken
1: branch 3 taken
1: branch 6 taken
370: branch 7 taken
2: branch 8 taken
370: branch 9 taken
1414 372: } else if (isa<ObjCPropertyRefExpr>(BaseExpr->IgnoreParens()) ||
1415 : isa<ObjCImplicitSetterGetterRefExpr>(
1416 : BaseExpr->IgnoreParens())) {
1417 2: RValue RV = EmitObjCPropertyGet(BaseExpr);
1418 2: BaseValue = RV.getAggregateAddr();
1419 2: BaseQuals = BaseExpr->getType().getQualifiers();
1420 : } else {
1421 370: LValue BaseLV = EmitLValue(BaseExpr);
116: branch 1 taken
254: branch 2 taken
1422 370: if (BaseLV.isNonGC())
1423 116: isNonGC = true;
1424 : // FIXME: this isn't right for bitfields.
1425 370: BaseValue = BaseLV.getAddress();
1426 370: QualType BaseTy = BaseExpr->getType();
1427 370: BaseQuals = BaseTy.getQualifiers();
1428 : }
1429 :
1430 726: NamedDecl *ND = E->getMemberDecl();
724: branch 1 taken
2: branch 2 taken
1431 726: if (FieldDecl *Field = dyn_cast<FieldDecl>(ND)) {
1432 : LValue LV = EmitLValueForField(BaseValue, Field,
1433 724: BaseQuals.getCVRQualifiers());
1434 724: LValue::SetObjCNonGC(LV, isNonGC);
1435 724: setObjCGCLValueClass(getContext(), E, LV);
1436 724: return LV;
1437 : }
1438 :
2: branch 1 taken
0: branch 2 not taken
1439 2: if (VarDecl *VD = dyn_cast<VarDecl>(ND))
1440 2: return EmitGlobalVarDeclLValue(*this, E, VD);
1441 :
0: branch 1 not taken
0: branch 2 not taken
1442 0: if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND))
1443 0: return EmitFunctionDeclLValue(*this, E, FD);
1444 :
1445 0: assert(false && "Unhandled member declaration!");
1446 : return LValue();
1447 : }
1448 :
1449 : LValue CodeGenFunction::EmitLValueForBitfield(llvm::Value* BaseValue,
1450 : const FieldDecl* Field,
1451 64: unsigned CVRQualifiers) {
1452 64: CodeGenTypes::BitFieldInfo Info = CGM.getTypes().getBitFieldInfo(Field);
1453 :
1454 : // FIXME: CodeGenTypes should expose a method to get the appropriate type for
1455 : // FieldTy (the appropriate type is ABI-dependent).
1456 : const llvm::Type *FieldTy =
1457 64: CGM.getTypes().ConvertTypeForMem(Field->getType());
1458 : const llvm::PointerType *BaseTy =
1459 64: cast<llvm::PointerType>(BaseValue->getType());
1460 64: unsigned AS = BaseTy->getAddressSpace();
1461 : BaseValue = Builder.CreateBitCast(BaseValue,
1462 : llvm::PointerType::get(FieldTy, AS),
1463 64: "tmp");
1464 :
1465 : llvm::Value *Idx =
1466 64: llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), Info.FieldNo);
1467 64: llvm::Value *V = Builder.CreateGEP(BaseValue, Idx, "tmp");
1468 :
1469 : return LValue::MakeBitfield(V, Info.Start, Info.Size,
1470 : Field->getType()->isSignedIntegerType(),
1471 64: Field->getType().getCVRQualifiers()|CVRQualifiers);
1472 : }
1473 :
1474 : LValue CodeGenFunction::EmitLValueForField(llvm::Value* BaseValue,
1475 : const FieldDecl* Field,
1476 1185: unsigned CVRQualifiers) {
64: branch 1 taken
1121: branch 2 taken
1477 1185: if (Field->isBitField())
1478 64: return EmitLValueForBitfield(BaseValue, Field, CVRQualifiers);
1479 :
1480 1121: unsigned idx = CGM.getTypes().getLLVMFieldNo(Field);
1481 1121: llvm::Value *V = Builder.CreateStructGEP(BaseValue, idx, "tmp");
1482 :
1483 : // Match union field type.
46: branch 2 taken
1075: branch 3 taken
1484 1121: if (Field->getParent()->isUnion()) {
1485 : const llvm::Type *FieldTy =
1486 46: CGM.getTypes().ConvertTypeForMem(Field->getType());
1487 : const llvm::PointerType * BaseTy =
1488 46: cast<llvm::PointerType>(BaseValue->getType());
1489 46: unsigned AS = BaseTy->getAddressSpace();
1490 : V = Builder.CreateBitCast(V,
1491 : llvm::PointerType::get(FieldTy, AS),
1492 46: "tmp");
1493 : }
4: branch 3 taken
1117: branch 4 taken
1494 1121: if (Field->getType()->isReferenceType())
1495 4: V = Builder.CreateLoad(V, "tmp");
1496 :
1497 1121: Qualifiers Quals = MakeQualifiers(Field->getType());
1498 1121: Quals.addCVRQualifiers(CVRQualifiers);
1499 : // __weak attribute on a field is ignored.
0: branch 1 not taken
1121: branch 2 taken
1500 1121: if (Quals.getObjCGCAttr() == Qualifiers::Weak)
1501 0: Quals.removeObjCGCAttr();
1502 :
1503 1121: return LValue::MakeAddr(V, Quals);
1504 : }
1505 :
1506 : LValue
1507 : CodeGenFunction::EmitLValueForFieldInitialization(llvm::Value* BaseValue,
1508 : const FieldDecl* Field,
1509 311: unsigned CVRQualifiers) {
1510 311: QualType FieldType = Field->getType();
1511 :
302: branch 2 taken
9: branch 3 taken
1512 311: if (!FieldType->isReferenceType())
1513 302: return EmitLValueForField(BaseValue, Field, CVRQualifiers);
1514 :
1515 9: unsigned idx = CGM.getTypes().getLLVMFieldNo(Field);
1516 9: llvm::Value *V = Builder.CreateStructGEP(BaseValue, idx, "tmp");
1517 :
9: branch 1 taken
0: branch 2 not taken
1518 9: assert(!FieldType.getObjCGCAttr() && "fields cannot have GC attrs");
1519 :
1520 9: return LValue::MakeAddr(V, MakeQualifiers(FieldType));
1521 : }
1522 :
1523 33: LValue CodeGenFunction::EmitCompoundLiteralLValue(const CompoundLiteralExpr* E){
1524 : llvm::Value *DeclPtr = CreateTempAlloca(ConvertTypeForMem(E->getType()),
1525 33: ".compoundliteral");
1526 :
1527 33: const Expr* InitExpr = E->getInitializer();
1528 33: LValue Result = LValue::MakeAddr(DeclPtr, MakeQualifiers(E->getType()));
1529 :
1: branch 3 taken
32: branch 4 taken
1530 33: if (E->getType()->isComplexType())
1531 1: EmitComplexExprIntoAddr(InitExpr, DeclPtr, false);
19: branch 2 taken
13: branch 3 taken
1532 32: else if (hasAggregateLLVMType(E->getType()))
1533 19: EmitAnyExpr(InitExpr, DeclPtr, false);
1534 : else
1535 13: EmitStoreThroughLValue(EmitAnyExpr(InitExpr), Result, E->getType());
1536 :
1537 : return Result;
1538 : }
1539 :
1540 : LValue
1541 10: CodeGenFunction::EmitConditionalOperatorLValue(const ConditionalOperator* E) {
4: branch 2 taken
6: branch 3 taken
1542 10: if (E->isLvalue(getContext()) == Expr::LV_Valid) {
0: branch 2 not taken
4: branch 3 taken
1543 4: if (int Cond = ConstantFoldsToSimpleInteger(E->getCond())) {
0: branch 0 not taken
0: branch 1 not taken
1544 0: Expr *Live = Cond == 1 ? E->getLHS() : E->getRHS();
0: branch 0 not taken
0: branch 1 not taken
1545 0: if (Live)
1546 0: return EmitLValue(Live);
1547 : }
1548 :
0: branch 1 not taken
4: branch 2 taken
1549 4: if (!E->getLHS())
1550 0: return EmitUnsupportedLValue(E, "conditional operator with missing LHS");
1551 :
1552 4: llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true");
1553 4: llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false");
1554 4: llvm::BasicBlock *ContBlock = createBasicBlock("cond.end");
1555 :
1556 4: EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock);
1557 :
1558 : // Any temporaries created here are conditional.
1559 4: BeginConditionalBranch();
1560 4: EmitBlock(LHSBlock);
1561 4: LValue LHS = EmitLValue(E->getLHS());
1562 4: EndConditionalBranch();
1563 :
0: branch 1 not taken
4: branch 2 taken
1564 4: if (!LHS.isSimple())
1565 0: return EmitUnsupportedLValue(E, "conditional operator");
1566 :
1567 : // FIXME: We shouldn't need an alloca for this.
1568 4: llvm::Value *Temp = CreateTempAlloca(LHS.getAddress()->getType(),"condtmp");
1569 4: Builder.CreateStore(LHS.getAddress(), Temp);
1570 4: EmitBranch(ContBlock);
1571 :
1572 : // Any temporaries created here are conditional.
1573 4: BeginConditionalBranch();
1574 4: EmitBlock(RHSBlock);
1575 4: LValue RHS = EmitLValue(E->getRHS());
1576 4: EndConditionalBranch();
0: branch 1 not taken
4: branch 2 taken
1577 4: if (!RHS.isSimple())
1578 0: return EmitUnsupportedLValue(E, "conditional operator");
1579 :
1580 4: Builder.CreateStore(RHS.getAddress(), Temp);
1581 4: EmitBranch(ContBlock);
1582 :
1583 4: EmitBlock(ContBlock);
1584 :
1585 4: Temp = Builder.CreateLoad(Temp, "lv");
1586 4: return LValue::MakeAddr(Temp, MakeQualifiers(E->getType()));
1587 : }
1588 :
1589 : // ?: here should be an aggregate.
1590 : assert((hasAggregateLLVMType(E->getType()) &&
1591 : !E->getType()->isAnyComplexType()) &&
6: branch 2 taken
0: branch 3 not taken
6: branch 7 taken
0: branch 8 not taken
1592 6: "Unexpected conditional operator!");
1593 :
1594 6: return EmitAggExprToLValue(E);
1595 : }
1596 :
1597 : /// EmitCastLValue - Casts are never lvalues unless that cast is a dynamic_cast.
1598 : /// If the cast is a dynamic_cast, we can have the usual lvalue result,
1599 : /// otherwise if a cast is needed by the code generator in an lvalue context,
1600 : /// then it must mean that we need the address of an aggregate in order to
1601 : /// access one of its fields. This can happen for all the reasons that casts
1602 : /// are permitted with aggregate result, including noop aggregate casts, and
1603 : /// cast from scalar to union.
1604 252: LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) {
0: branch 1 not taken
1: branch 2 taken
145: branch 3 taken
99: branch 4 taken
3: branch 5 taken
3: branch 6 taken
1: branch 7 taken
1605 252: switch (E->getCastKind()) {
1606 : default:
1607 0: return EmitUnsupportedLValue(E, "unexpected cast lvalue");
1608 :
1609 : case CastExpr::CK_Dynamic: {
1610 1: LValue LV = EmitLValue(E->getSubExpr());
1611 1: llvm::Value *V = LV.getAddress();
1612 1: const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(E);
1613 : return LValue::MakeAddr(EmitDynamicCast(V, DCE),
1614 1: MakeQualifiers(E->getType()));
1615 : }
1616 :
1617 : case CastExpr::CK_NoOp:
1618 : case CastExpr::CK_ConstructorConversion:
1619 : case CastExpr::CK_UserDefinedConversion:
1620 : case CastExpr::CK_AnyPointerToObjCPointerCast:
1621 145: return EmitLValue(E->getSubExpr());
1622 :
1623 : case CastExpr::CK_DerivedToBase: {
1624 : const RecordType *DerivedClassTy =
1625 99: E->getSubExpr()->getType()->getAs<RecordType>();
1626 : CXXRecordDecl *DerivedClassDecl =
1627 99: cast<CXXRecordDecl>(DerivedClassTy->getDecl());
1628 :
1629 99: const RecordType *BaseClassTy = E->getType()->getAs<RecordType>();
1630 99: CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseClassTy->getDecl());
1631 :
1632 99: LValue LV = EmitLValue(E->getSubExpr());
1633 :
1634 : // Perform the derived-to-base conversion
1635 : llvm::Value *Base =
1636 : GetAddressOfBaseClass(LV.getAddress(), DerivedClassDecl,
1637 99: BaseClassDecl, /*NullCheckValue=*/false);
1638 :
1639 99: return LValue::MakeAddr(Base, MakeQualifiers(E->getType()));
1640 : }
1641 : case CastExpr::CK_ToUnion:
1642 3: return EmitAggExprToLValue(E);
1643 : case CastExpr::CK_BaseToDerived: {
1644 : const RecordType *BaseClassTy =
1645 3: E->getSubExpr()->getType()->getAs<RecordType>();
1646 : CXXRecordDecl *BaseClassDecl =
1647 3: cast<CXXRecordDecl>(BaseClassTy->getDecl());
1648 :
1649 3: const RecordType *DerivedClassTy = E->getType()->getAs<RecordType>();
1650 : CXXRecordDecl *DerivedClassDecl =
1651 3: cast<CXXRecordDecl>(DerivedClassTy->getDecl());
1652 :
1653 3: LValue LV = EmitLValue(E->getSubExpr());
1654 :
1655 : // Perform the base-to-derived conversion
1656 : llvm::Value *Derived =
1657 : GetAddressOfDerivedClass(LV.getAddress(), BaseClassDecl,
1658 3: DerivedClassDecl, /*NullCheckValue=*/false);
1659 :
1660 3: return LValue::MakeAddr(Derived, MakeQualifiers(E->getType()));
1661 : }
1662 : case CastExpr::CK_BitCast: {
1663 : // This must be a reinterpret_cast (or c-style equivalent).
1664 1: const ExplicitCastExpr *CE = cast<ExplicitCastExpr>(E);
1665 :
1666 1: LValue LV = EmitLValue(E->getSubExpr());
1667 : llvm::Value *V = Builder.CreateBitCast(LV.getAddress(),
1668 1: ConvertType(CE->getTypeAsWritten()));
1669 1: return LValue::MakeAddr(V, MakeQualifiers(E->getType()));
1670 : }
1671 : }
1672 : }
1673 :
1674 : LValue CodeGenFunction::EmitNullInitializationLValue(
1675 18: const CXXZeroInitValueExpr *E) {
1676 18: QualType Ty = E->getType();
1677 18: LValue LV = LValue::MakeAddr(CreateMemTemp(Ty), MakeQualifiers(Ty));
1678 18: EmitMemSetToZero(LV.getAddress(), Ty);
1679 : return LV;
1680 : }
1681 :
1682 : //===--------------------------------------------------------------------===//
1683 : // Expression Emission
1684 : //===--------------------------------------------------------------------===//
1685 :
1686 :
1687 : RValue CodeGenFunction::EmitCallExpr(const CallExpr *E,
1688 1889: ReturnValueSlot ReturnValue) {
1689 : // Builtins never have block type.
24: branch 4 taken
1865: branch 5 taken
1690 1889: if (E->getCallee()->getType()->isBlockPointerType())
1691 24: return EmitBlockCallExpr(E, ReturnValue);
1692 :
269: branch 1 taken
1596: branch 2 taken
1693 1865: if (const CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(E))
1694 269: return EmitCXXMemberCallExpr(CE, ReturnValue);
1695 :
1696 1596: const Decl *TargetDecl = 0;
1581: branch 2 taken
15: branch 3 taken
1697 1596: if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E->getCallee())) {
1577: branch 2 taken
4: branch 3 taken
1698 1581: if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CE->getSubExpr())) {
1699 1577: TargetDecl = DRE->getDecl();
1577: branch 1 taken
0: branch 2 not taken
1700 1577: if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(TargetDecl))
796: branch 1 taken
781: branch 2 taken
1701 1577: if (unsigned builtinID = FD->getBuiltinID())
1702 796: return EmitBuiltinExpr(FD, builtinID, E);
1703 : }
1704 : }
1705 :
41: branch 1 taken
759: branch 2 taken
1706 800: if (const CXXOperatorCallExpr *CE = dyn_cast<CXXOperatorCallExpr>(E))
36: branch 1 taken
5: branch 2 taken
1707 41: if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(TargetDecl))
1708 36: return EmitCXXOperatorMemberCallExpr(CE, MD, ReturnValue);
1709 :
4: branch 3 taken
760: branch 4 taken
1710 764: if (isa<CXXPseudoDestructorExpr>(E->getCallee()->IgnoreParens())) {
1711 : // C++ [expr.pseudo]p1:
1712 : // The result shall only be used as the operand for the function call
1713 : // operator (), and the result of such a call has type void. The only
1714 : // effect is the evaluation of the postfix-expression before the dot or
1715 : // arrow.
1716 4: EmitScalarExpr(E->getCallee());
1717 4: return RValue::get(0);
1718 : }
1719 :
1720 760: llvm::Value *Callee = EmitScalarExpr(E->getCallee());
1721 : return EmitCall(E->getCallee()->getType(), Callee, ReturnValue,
1722 760: E->arg_begin(), E->arg_end(), TargetDecl);
1723 : }
1724 :
1725 30: LValue CodeGenFunction::EmitBinaryOperatorLValue(const BinaryOperator *E) {
1726 : // Comma expressions just emit their LHS then their RHS as an l-value.
2: branch 1 taken
28: branch 2 taken
1727 30: if (E->getOpcode() == BinaryOperator::Comma) {
1728 2: EmitAnyExpr(E->getLHS());
1729 2: EnsureInsertPoint();
1730 2: return EmitLValue(E->getRHS());
1731 : }
1732 :
14: branch 1 taken
14: branch 2 taken
10: branch 4 taken
4: branch 5 taken
24: branch 6 taken
4: branch 7 taken
1733 28: if (E->getOpcode() == BinaryOperator::PtrMemD ||
1734 : E->getOpcode() == BinaryOperator::PtrMemI)
1735 24: return EmitPointerToDataMemberBinaryExpr(E);
1736 :
1737 : // Can only get l-value for binary operator expressions which are a
1738 : // simple assignment of aggregate type.
0: branch 1 not taken
4: branch 2 taken
1739 4: if (E->getOpcode() != BinaryOperator::Assign)
1740 0: return EmitUnsupportedLValue(E, "binary l-value expression");
1741 :
1: branch 2 taken
3: branch 3 taken
1742 4: if (!hasAggregateLLVMType(E->getType())) {
1743 : // Emit the LHS as an l-value.
1744 1: LValue LV = EmitLValue(E->getLHS());
1745 :
1746 1: llvm::Value *RHS = EmitScalarExpr(E->getRHS());
1747 : EmitStoreOfScalar(RHS, LV.getAddress(), LV.isVolatileQualified(),
1748 1: E->getType());
1749 1: return LV;
1750 : }
1751 :
1752 3: return EmitAggExprToLValue(E);
1753 : }
1754 :
1755 105: LValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) {
1756 105: RValue RV = EmitCallExpr(E);
1757 :
26: branch 1 taken
79: branch 2 taken
1758 105: if (!RV.isScalar())
1759 26: return LValue::MakeAddr(RV.getAggregateAddr(),MakeQualifiers(E->getType()));
1760 :
1761 : assert(E->getCallReturnType()->isReferenceType() &&
1762 : "Can't have a scalar return unless the return type is a "
79: branch 3 taken
0: branch 4 not taken
1763 79: "reference type!");
1764 :
1765 79: return LValue::MakeAddr(RV.getScalarVal(), MakeQualifiers(E->getType()));
1766 : }
1767 :
1768 1: LValue CodeGenFunction::EmitVAArgExprLValue(const VAArgExpr *E) {
1769 : // FIXME: This shouldn't require another copy.
1770 1: return EmitAggExprToLValue(E);
1771 : }
1772 :
1773 41: LValue CodeGenFunction::EmitCXXConstructLValue(const CXXConstructExpr *E) {
1774 41: llvm::Value *Temp = CreateMemTemp(E->getType(), "tmp");
1775 41: EmitCXXConstructExpr(Temp, E);
1776 41: return LValue::MakeAddr(Temp, MakeQualifiers(E->getType()));
1777 : }
1778 :
1779 : LValue
1780 68: CodeGenFunction::EmitCXXTypeidLValue(const CXXTypeidExpr *E) {
1781 68: llvm::Value *Temp = EmitCXXTypeidExpr(E);
1782 68: return LValue::MakeAddr(Temp, MakeQualifiers(E->getType()));
1783 : }
1784 :
1785 : LValue
1786 25: CodeGenFunction::EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E) {
1787 25: LValue LV = EmitLValue(E->getSubExpr());
1788 25: PushCXXTemporary(E->getTemporary(), LV.getAddress());
1789 : return LV;
1790 : }
1791 :
1792 0: LValue CodeGenFunction::EmitObjCMessageExprLValue(const ObjCMessageExpr *E) {
1793 : // Can only get l-value for message expression returning aggregate type
1794 0: RValue RV = EmitObjCMessageExpr(E);
1795 : // FIXME: can this be volatile?
1796 0: return LValue::MakeAddr(RV.getAggregateAddr(), MakeQualifiers(E->getType()));
1797 : }
1798 :
1799 : llvm::Value *CodeGenFunction::EmitIvarOffset(const ObjCInterfaceDecl *Interface,
1800 18: const ObjCIvarDecl *Ivar) {
1801 18: return CGM.getObjCRuntime().EmitIvarOffset(*this, Interface, Ivar);
1802 : }
1803 :
1804 : LValue CodeGenFunction::EmitLValueForIvar(QualType ObjectTy,
1805 : llvm::Value *BaseValue,
1806 : const ObjCIvarDecl *Ivar,
1807 293: unsigned CVRQualifiers) {
1808 : return CGM.getObjCRuntime().EmitObjCValueForIvar(*this, ObjectTy, BaseValue,
1809 293: Ivar, CVRQualifiers);
1810 : }
1811 :
1812 242: LValue CodeGenFunction::EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E) {
1813 : // FIXME: A lot of the code below could be shared with EmitMemberExpr.
1814 242: llvm::Value *BaseValue = 0;
1815 242: const Expr *BaseExpr = E->getBase();
1816 242: Qualifiers BaseQuals;
1817 242: QualType ObjectTy;
236: branch 1 taken
6: branch 2 taken
1818 242: if (E->isArrow()) {
1819 236: BaseValue = EmitScalarExpr(BaseExpr);
1820 236: ObjectTy = BaseExpr->getType()->getPointeeType();
1821 236: BaseQuals = ObjectTy.getQualifiers();
1822 : } else {
1823 6: LValue BaseLV = EmitLValue(BaseExpr);
1824 : // FIXME: this isn't right for bitfields.
1825 6: BaseValue = BaseLV.getAddress();
1826 6: ObjectTy = BaseExpr->getType();
1827 6: BaseQuals = ObjectTy.getQualifiers();
1828 : }
1829 :
1830 : LValue LV =
1831 : EmitLValueForIvar(ObjectTy, BaseValue, E->getDecl(),
1832 242: BaseQuals.getCVRQualifiers());
1833 242: setObjCGCLValueClass(getContext(), E, LV);
1834 : return LV;
1835 : }
1836 :
1837 : LValue
1838 56: CodeGenFunction::EmitObjCPropertyRefLValue(const ObjCPropertyRefExpr *E) {
1839 : // This is a special l-value that just issues sends when we load or store
1840 : // through it.
1841 56: return LValue::MakePropertyRef(E, E->getType().getCVRQualifiers());
1842 : }
1843 :
1844 : LValue CodeGenFunction::EmitObjCKVCRefLValue(
1845 15: const ObjCImplicitSetterGetterRefExpr *E) {
1846 : // This is a special l-value that just issues sends when we load or store
1847 : // through it.
1848 15: return LValue::MakeKVCRef(E, E->getType().getCVRQualifiers());
1849 : }
1850 :
1851 0: LValue CodeGenFunction::EmitObjCSuperExprLValue(const ObjCSuperExpr *E) {
1852 0: return EmitUnsupportedLValue(E, "use of super");
1853 : }
1854 :
1855 1: LValue CodeGenFunction::EmitStmtExprLValue(const StmtExpr *E) {
1856 : // Can only get l-value for message expression returning aggregate type
1857 1: RValue RV = EmitAnyExprToTemp(E);
1858 : // FIXME: can this be volatile?
1859 1: return LValue::MakeAddr(RV.getAggregateAddr(), MakeQualifiers(E->getType()));
1860 : }
1861 :
1862 : RValue CodeGenFunction::EmitCall(QualType CalleeType, llvm::Value *Callee,
1863 : ReturnValueSlot ReturnValue,
1864 : CallExpr::const_arg_iterator ArgBeg,
1865 : CallExpr::const_arg_iterator ArgEnd,
1866 1176: const Decl *TargetDecl) {
1867 : // Get the actual function type. The callee type will always be a pointer to
1868 : // function type or a block pointer type.
1869 : assert(CalleeType->isFunctionPointerType() &&
1176: branch 2 taken
0: branch 3 not taken
1870 1176: "Call must have function pointer type!");
1871 :
1872 1176: CalleeType = getContext().getCanonicalType(CalleeType);
1873 :
1874 : const FunctionType *FnType
1875 1176: = cast<FunctionType>(cast<PointerType>(CalleeType)->getPointeeType());
1876 1176: QualType ResultType = FnType->getResultType();
1877 :
1878 1176: CallArgList Args;
1879 1176: EmitCallArgs(Args, dyn_cast<FunctionProtoType>(FnType), ArgBeg, ArgEnd);
1880 :
1881 : return EmitCall(CGM.getTypes().getFunctionInfo(Args, FnType),
1882 1176: Callee, ReturnValue, Args, TargetDecl);
1883 : }
1884 :
1885 : LValue CodeGenFunction::
1886 24: EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E) {
1887 : llvm::Value *BaseV;
10: branch 1 taken
14: branch 2 taken
1888 24: if (E->getOpcode() == BinaryOperator::PtrMemI)
1889 10: BaseV = EmitScalarExpr(E->getLHS());
1890 : else
1891 14: BaseV = EmitLValue(E->getLHS()).getAddress();
1892 24: const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(getLLVMContext());
1893 24: BaseV = Builder.CreateBitCast(BaseV, i8Ty);
1894 24: llvm::Value *OffsetV = EmitScalarExpr(E->getRHS());
1895 24: llvm::Value *AddV = Builder.CreateInBoundsGEP(BaseV, OffsetV, "add.ptr");
1896 :
1897 24: QualType Ty = E->getRHS()->getType();
1898 24: Ty = Ty->getAs<MemberPointerType>()->getPointeeType();
1899 :
1900 24: const llvm::Type *PType = ConvertType(getContext().getPointerType(Ty));
1901 24: AddV = Builder.CreateBitCast(AddV, PType);
1902 24: return LValue::MakeAddr(AddV, MakeQualifiers(Ty));
1903 : }
1904 :
Generated: 2010-02-10 01:31 by zcov