CGExpr.cpp revision e69b09955acbde87470eea8bc99b580195569dc0
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 "CGCXXABI.h" 18#include "CGRecordLayout.h" 19#include "CGObjCRuntime.h" 20#include "clang/AST/ASTContext.h" 21#include "clang/AST/DeclObjC.h" 22#include "llvm/Intrinsics.h" 23#include "clang/Frontend/CodeGenOptions.h" 24#include "llvm/Target/TargetData.h" 25using namespace clang; 26using namespace CodeGen; 27 28//===--------------------------------------------------------------------===// 29// Miscellaneous Helper Methods 30//===--------------------------------------------------------------------===// 31 32llvm::Value *CodeGenFunction::EmitCastToVoidPtr(llvm::Value *value) { 33 unsigned addressSpace = 34 cast<llvm::PointerType>(value->getType())->getAddressSpace(); 35 36 const llvm::PointerType *destType = Int8PtrTy; 37 if (addressSpace) 38 destType = llvm::Type::getInt8PtrTy(getLLVMContext(), addressSpace); 39 40 if (value->getType() == destType) return value; 41 return Builder.CreateBitCast(value, destType); 42} 43 44/// CreateTempAlloca - This creates a alloca and inserts it into the entry 45/// block. 46llvm::AllocaInst *CodeGenFunction::CreateTempAlloca(const llvm::Type *Ty, 47 const llvm::Twine &Name) { 48 if (!Builder.isNamePreserving()) 49 return new llvm::AllocaInst(Ty, 0, "", AllocaInsertPt); 50 return new llvm::AllocaInst(Ty, 0, Name, AllocaInsertPt); 51} 52 53void CodeGenFunction::InitTempAlloca(llvm::AllocaInst *Var, 54 llvm::Value *Init) { 55 llvm::StoreInst *Store = new llvm::StoreInst(Init, Var); 56 llvm::BasicBlock *Block = AllocaInsertPt->getParent(); 57 Block->getInstList().insertAfter(&*AllocaInsertPt, Store); 58} 59 60llvm::AllocaInst *CodeGenFunction::CreateIRTemp(QualType Ty, 61 const llvm::Twine &Name) { 62 llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertType(Ty), Name); 63 // FIXME: Should we prefer the preferred type alignment here? 64 CharUnits Align = getContext().getTypeAlignInChars(Ty); 65 Alloc->setAlignment(Align.getQuantity()); 66 return Alloc; 67} 68 69llvm::AllocaInst *CodeGenFunction::CreateMemTemp(QualType Ty, 70 const llvm::Twine &Name) { 71 llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertTypeForMem(Ty), Name); 72 // FIXME: Should we prefer the preferred type alignment here? 73 CharUnits Align = getContext().getTypeAlignInChars(Ty); 74 Alloc->setAlignment(Align.getQuantity()); 75 return Alloc; 76} 77 78/// EvaluateExprAsBool - Perform the usual unary conversions on the specified 79/// expression and compare the result against zero, returning an Int1Ty value. 80llvm::Value *CodeGenFunction::EvaluateExprAsBool(const Expr *E) { 81 if (const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>()) { 82 llvm::Value *MemPtr = EmitScalarExpr(E); 83 return CGM.getCXXABI().EmitMemberPointerIsNotNull(*this, MemPtr, MPT); 84 } 85 86 QualType BoolTy = getContext().BoolTy; 87 if (!E->getType()->isAnyComplexType()) 88 return EmitScalarConversion(EmitScalarExpr(E), E->getType(), BoolTy); 89 90 return EmitComplexToScalarConversion(EmitComplexExpr(E), E->getType(),BoolTy); 91} 92 93/// EmitIgnoredExpr - Emit code to compute the specified expression, 94/// ignoring the result. 95void CodeGenFunction::EmitIgnoredExpr(const Expr *E) { 96 if (E->isRValue()) 97 return (void) EmitAnyExpr(E, AggValueSlot::ignored(), true); 98 99 // Just emit it as an l-value and drop the result. 100 EmitLValue(E); 101} 102 103/// EmitAnyExpr - Emit code to compute the specified expression which 104/// can have any type. The result is returned as an RValue struct. 105/// If this is an aggregate expression, AggSlot indicates where the 106/// result should be returned. 107RValue CodeGenFunction::EmitAnyExpr(const Expr *E, AggValueSlot AggSlot, 108 bool IgnoreResult) { 109 if (!hasAggregateLLVMType(E->getType())) 110 return RValue::get(EmitScalarExpr(E, IgnoreResult)); 111 else if (E->getType()->isAnyComplexType()) 112 return RValue::getComplex(EmitComplexExpr(E, IgnoreResult, IgnoreResult)); 113 114 EmitAggExpr(E, AggSlot, IgnoreResult); 115 return AggSlot.asRValue(); 116} 117 118/// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result will 119/// always be accessible even if no aggregate location is provided. 120RValue CodeGenFunction::EmitAnyExprToTemp(const Expr *E) { 121 AggValueSlot AggSlot = AggValueSlot::ignored(); 122 123 if (hasAggregateLLVMType(E->getType()) && 124 !E->getType()->isAnyComplexType()) 125 AggSlot = CreateAggTemp(E->getType(), "agg.tmp"); 126 return EmitAnyExpr(E, AggSlot); 127} 128 129/// EmitAnyExprToMem - Evaluate an expression into a given memory 130/// location. 131void CodeGenFunction::EmitAnyExprToMem(const Expr *E, 132 llvm::Value *Location, 133 bool IsLocationVolatile, 134 bool IsInit) { 135 if (E->getType()->isComplexType()) 136 EmitComplexExprIntoAddr(E, Location, IsLocationVolatile); 137 else if (hasAggregateLLVMType(E->getType())) 138 EmitAggExpr(E, AggValueSlot::forAddr(Location, IsLocationVolatile, IsInit)); 139 else { 140 RValue RV = RValue::get(EmitScalarExpr(E, /*Ignore*/ false)); 141 LValue LV = MakeAddrLValue(Location, E->getType()); 142 EmitStoreThroughLValue(RV, LV, E->getType()); 143 } 144} 145 146namespace { 147/// \brief An adjustment to be made to the temporary created when emitting a 148/// reference binding, which accesses a particular subobject of that temporary. 149 struct SubobjectAdjustment { 150 enum { DerivedToBaseAdjustment, FieldAdjustment } Kind; 151 152 union { 153 struct { 154 const CastExpr *BasePath; 155 const CXXRecordDecl *DerivedClass; 156 } DerivedToBase; 157 158 FieldDecl *Field; 159 }; 160 161 SubobjectAdjustment(const CastExpr *BasePath, 162 const CXXRecordDecl *DerivedClass) 163 : Kind(DerivedToBaseAdjustment) { 164 DerivedToBase.BasePath = BasePath; 165 DerivedToBase.DerivedClass = DerivedClass; 166 } 167 168 SubobjectAdjustment(FieldDecl *Field) 169 : Kind(FieldAdjustment) { 170 this->Field = Field; 171 } 172 }; 173} 174 175static llvm::Value * 176CreateReferenceTemporary(CodeGenFunction& CGF, QualType Type, 177 const NamedDecl *InitializedDecl) { 178 if (const VarDecl *VD = dyn_cast_or_null<VarDecl>(InitializedDecl)) { 179 if (VD->hasGlobalStorage()) { 180 llvm::SmallString<256> Name; 181 llvm::raw_svector_ostream Out(Name); 182 CGF.CGM.getCXXABI().getMangleContext().mangleReferenceTemporary(VD, Out); 183 Out.flush(); 184 185 const llvm::Type *RefTempTy = CGF.ConvertTypeForMem(Type); 186 187 // Create the reference temporary. 188 llvm::GlobalValue *RefTemp = 189 new llvm::GlobalVariable(CGF.CGM.getModule(), 190 RefTempTy, /*isConstant=*/false, 191 llvm::GlobalValue::InternalLinkage, 192 llvm::Constant::getNullValue(RefTempTy), 193 Name.str()); 194 return RefTemp; 195 } 196 } 197 198 return CGF.CreateMemTemp(Type, "ref.tmp"); 199} 200 201static llvm::Value * 202EmitExprForReferenceBinding(CodeGenFunction &CGF, const Expr *E, 203 llvm::Value *&ReferenceTemporary, 204 const CXXDestructorDecl *&ReferenceTemporaryDtor, 205 const NamedDecl *InitializedDecl) { 206 if (const CXXDefaultArgExpr *DAE = dyn_cast<CXXDefaultArgExpr>(E)) 207 E = DAE->getExpr(); 208 209 if (const ExprWithCleanups *TE = dyn_cast<ExprWithCleanups>(E)) { 210 CodeGenFunction::RunCleanupsScope Scope(CGF); 211 212 return EmitExprForReferenceBinding(CGF, TE->getSubExpr(), 213 ReferenceTemporary, 214 ReferenceTemporaryDtor, 215 InitializedDecl); 216 } 217 218 RValue RV; 219 if (E->isGLValue()) { 220 // Emit the expression as an lvalue. 221 LValue LV = CGF.EmitLValue(E); 222 if (LV.isSimple()) 223 return LV.getAddress(); 224 225 // We have to load the lvalue. 226 RV = CGF.EmitLoadOfLValue(LV, E->getType()); 227 } else { 228 QualType ResultTy = E->getType(); 229 230 llvm::SmallVector<SubobjectAdjustment, 2> Adjustments; 231 while (true) { 232 if (const ParenExpr *PE = dyn_cast<ParenExpr>(E)) { 233 E = PE->getSubExpr(); 234 continue; 235 } 236 237 if (const CastExpr *CE = dyn_cast<CastExpr>(E)) { 238 if ((CE->getCastKind() == CK_DerivedToBase || 239 CE->getCastKind() == CK_UncheckedDerivedToBase) && 240 E->getType()->isRecordType()) { 241 E = CE->getSubExpr(); 242 CXXRecordDecl *Derived 243 = cast<CXXRecordDecl>(E->getType()->getAs<RecordType>()->getDecl()); 244 Adjustments.push_back(SubobjectAdjustment(CE, Derived)); 245 continue; 246 } 247 248 if (CE->getCastKind() == CK_NoOp) { 249 E = CE->getSubExpr(); 250 continue; 251 } 252 } else if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) { 253 if (!ME->isArrow() && ME->getBase()->isRValue()) { 254 assert(ME->getBase()->getType()->isRecordType()); 255 if (FieldDecl *Field = dyn_cast<FieldDecl>(ME->getMemberDecl())) { 256 E = ME->getBase(); 257 Adjustments.push_back(SubobjectAdjustment(Field)); 258 continue; 259 } 260 } 261 } 262 263 // Nothing changed. 264 break; 265 } 266 267 // Create a reference temporary if necessary. 268 AggValueSlot AggSlot = AggValueSlot::ignored(); 269 if (CGF.hasAggregateLLVMType(E->getType()) && 270 !E->getType()->isAnyComplexType()) { 271 ReferenceTemporary = CreateReferenceTemporary(CGF, E->getType(), 272 InitializedDecl); 273 AggSlot = AggValueSlot::forAddr(ReferenceTemporary, false, 274 InitializedDecl != 0); 275 } 276 277 RV = CGF.EmitAnyExpr(E, AggSlot); 278 279 if (InitializedDecl) { 280 // Get the destructor for the reference temporary. 281 if (const RecordType *RT = E->getType()->getAs<RecordType>()) { 282 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(RT->getDecl()); 283 if (!ClassDecl->hasTrivialDestructor()) 284 ReferenceTemporaryDtor = ClassDecl->getDestructor(); 285 } 286 } 287 288 // Check if need to perform derived-to-base casts and/or field accesses, to 289 // get from the temporary object we created (and, potentially, for which we 290 // extended the lifetime) to the subobject we're binding the reference to. 291 if (!Adjustments.empty()) { 292 llvm::Value *Object = RV.getAggregateAddr(); 293 for (unsigned I = Adjustments.size(); I != 0; --I) { 294 SubobjectAdjustment &Adjustment = Adjustments[I-1]; 295 switch (Adjustment.Kind) { 296 case SubobjectAdjustment::DerivedToBaseAdjustment: 297 Object = 298 CGF.GetAddressOfBaseClass(Object, 299 Adjustment.DerivedToBase.DerivedClass, 300 Adjustment.DerivedToBase.BasePath->path_begin(), 301 Adjustment.DerivedToBase.BasePath->path_end(), 302 /*NullCheckValue=*/false); 303 break; 304 305 case SubobjectAdjustment::FieldAdjustment: { 306 LValue LV = 307 CGF.EmitLValueForField(Object, Adjustment.Field, 0); 308 if (LV.isSimple()) { 309 Object = LV.getAddress(); 310 break; 311 } 312 313 // For non-simple lvalues, we actually have to create a copy of 314 // the object we're binding to. 315 QualType T = Adjustment.Field->getType().getNonReferenceType() 316 .getUnqualifiedType(); 317 Object = CreateReferenceTemporary(CGF, T, InitializedDecl); 318 LValue TempLV = CGF.MakeAddrLValue(Object, 319 Adjustment.Field->getType()); 320 CGF.EmitStoreThroughLValue(CGF.EmitLoadOfLValue(LV, T), TempLV, T); 321 break; 322 } 323 324 } 325 } 326 327 const llvm::Type *ResultPtrTy = CGF.ConvertType(ResultTy)->getPointerTo(); 328 return CGF.Builder.CreateBitCast(Object, ResultPtrTy, "temp"); 329 } 330 } 331 332 if (RV.isAggregate()) 333 return RV.getAggregateAddr(); 334 335 // Create a temporary variable that we can bind the reference to. 336 ReferenceTemporary = CreateReferenceTemporary(CGF, E->getType(), 337 InitializedDecl); 338 339 340 unsigned Alignment = 341 CGF.getContext().getTypeAlignInChars(E->getType()).getQuantity(); 342 if (RV.isScalar()) 343 CGF.EmitStoreOfScalar(RV.getScalarVal(), ReferenceTemporary, 344 /*Volatile=*/false, Alignment, E->getType()); 345 else 346 CGF.StoreComplexToAddr(RV.getComplexVal(), ReferenceTemporary, 347 /*Volatile=*/false); 348 return ReferenceTemporary; 349} 350 351RValue 352CodeGenFunction::EmitReferenceBindingToExpr(const Expr *E, 353 const NamedDecl *InitializedDecl) { 354 llvm::Value *ReferenceTemporary = 0; 355 const CXXDestructorDecl *ReferenceTemporaryDtor = 0; 356 llvm::Value *Value = EmitExprForReferenceBinding(*this, E, ReferenceTemporary, 357 ReferenceTemporaryDtor, 358 InitializedDecl); 359 if (!ReferenceTemporaryDtor) 360 return RValue::get(Value); 361 362 // Make sure to call the destructor for the reference temporary. 363 if (const VarDecl *VD = dyn_cast_or_null<VarDecl>(InitializedDecl)) { 364 if (VD->hasGlobalStorage()) { 365 llvm::Constant *DtorFn = 366 CGM.GetAddrOfCXXDestructor(ReferenceTemporaryDtor, Dtor_Complete); 367 EmitCXXGlobalDtorRegistration(DtorFn, 368 cast<llvm::Constant>(ReferenceTemporary)); 369 370 return RValue::get(Value); 371 } 372 } 373 374 PushDestructorCleanup(ReferenceTemporaryDtor, ReferenceTemporary); 375 376 return RValue::get(Value); 377} 378 379 380/// getAccessedFieldNo - Given an encoded value and a result number, return the 381/// input field number being accessed. 382unsigned CodeGenFunction::getAccessedFieldNo(unsigned Idx, 383 const llvm::Constant *Elts) { 384 if (isa<llvm::ConstantAggregateZero>(Elts)) 385 return 0; 386 387 return cast<llvm::ConstantInt>(Elts->getOperand(Idx))->getZExtValue(); 388} 389 390void CodeGenFunction::EmitCheck(llvm::Value *Address, unsigned Size) { 391 if (!CatchUndefined) 392 return; 393 394 // This needs to be to the standard address space. 395 Address = Builder.CreateBitCast(Address, Int8PtrTy); 396 397 const llvm::Type *IntPtrT = IntPtrTy; 398 llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::objectsize, &IntPtrT, 1); 399 400 // In time, people may want to control this and use a 1 here. 401 llvm::Value *Arg = Builder.getFalse(); 402 llvm::Value *C = Builder.CreateCall2(F, Address, Arg); 403 llvm::BasicBlock *Cont = createBasicBlock(); 404 llvm::BasicBlock *Check = createBasicBlock(); 405 llvm::Value *NegativeOne = llvm::ConstantInt::get(IntPtrTy, -1ULL); 406 Builder.CreateCondBr(Builder.CreateICmpEQ(C, NegativeOne), Cont, Check); 407 408 EmitBlock(Check); 409 Builder.CreateCondBr(Builder.CreateICmpUGE(C, 410 llvm::ConstantInt::get(IntPtrTy, Size)), 411 Cont, getTrapBB()); 412 EmitBlock(Cont); 413} 414 415 416CodeGenFunction::ComplexPairTy CodeGenFunction:: 417EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV, 418 bool isInc, bool isPre) { 419 ComplexPairTy InVal = LoadComplexFromAddr(LV.getAddress(), 420 LV.isVolatileQualified()); 421 422 llvm::Value *NextVal; 423 if (isa<llvm::IntegerType>(InVal.first->getType())) { 424 uint64_t AmountVal = isInc ? 1 : -1; 425 NextVal = llvm::ConstantInt::get(InVal.first->getType(), AmountVal, true); 426 427 // Add the inc/dec to the real part. 428 NextVal = Builder.CreateAdd(InVal.first, NextVal, isInc ? "inc" : "dec"); 429 } else { 430 QualType ElemTy = E->getType()->getAs<ComplexType>()->getElementType(); 431 llvm::APFloat FVal(getContext().getFloatTypeSemantics(ElemTy), 1); 432 if (!isInc) 433 FVal.changeSign(); 434 NextVal = llvm::ConstantFP::get(getLLVMContext(), FVal); 435 436 // Add the inc/dec to the real part. 437 NextVal = Builder.CreateFAdd(InVal.first, NextVal, isInc ? "inc" : "dec"); 438 } 439 440 ComplexPairTy IncVal(NextVal, InVal.second); 441 442 // Store the updated result through the lvalue. 443 StoreComplexToAddr(IncVal, LV.getAddress(), LV.isVolatileQualified()); 444 445 // If this is a postinc, return the value read from memory, otherwise use the 446 // updated value. 447 return isPre ? IncVal : InVal; 448} 449 450 451//===----------------------------------------------------------------------===// 452// LValue Expression Emission 453//===----------------------------------------------------------------------===// 454 455RValue CodeGenFunction::GetUndefRValue(QualType Ty) { 456 if (Ty->isVoidType()) 457 return RValue::get(0); 458 459 if (const ComplexType *CTy = Ty->getAs<ComplexType>()) { 460 const llvm::Type *EltTy = ConvertType(CTy->getElementType()); 461 llvm::Value *U = llvm::UndefValue::get(EltTy); 462 return RValue::getComplex(std::make_pair(U, U)); 463 } 464 465 // If this is a use of an undefined aggregate type, the aggregate must have an 466 // identifiable address. Just because the contents of the value are undefined 467 // doesn't mean that the address can't be taken and compared. 468 if (hasAggregateLLVMType(Ty)) { 469 llvm::Value *DestPtr = CreateMemTemp(Ty, "undef.agg.tmp"); 470 return RValue::getAggregate(DestPtr); 471 } 472 473 return RValue::get(llvm::UndefValue::get(ConvertType(Ty))); 474} 475 476RValue CodeGenFunction::EmitUnsupportedRValue(const Expr *E, 477 const char *Name) { 478 ErrorUnsupported(E, Name); 479 return GetUndefRValue(E->getType()); 480} 481 482LValue CodeGenFunction::EmitUnsupportedLValue(const Expr *E, 483 const char *Name) { 484 ErrorUnsupported(E, Name); 485 llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType())); 486 return MakeAddrLValue(llvm::UndefValue::get(Ty), E->getType()); 487} 488 489LValue CodeGenFunction::EmitCheckedLValue(const Expr *E) { 490 LValue LV = EmitLValue(E); 491 if (!isa<DeclRefExpr>(E) && !LV.isBitField() && LV.isSimple()) 492 EmitCheck(LV.getAddress(), 493 getContext().getTypeSizeInChars(E->getType()).getQuantity()); 494 return LV; 495} 496 497/// EmitLValue - Emit code to compute a designator that specifies the location 498/// of the expression. 499/// 500/// This can return one of two things: a simple address or a bitfield reference. 501/// In either case, the LLVM Value* in the LValue structure is guaranteed to be 502/// an LLVM pointer type. 503/// 504/// If this returns a bitfield reference, nothing about the pointee type of the 505/// LLVM value is known: For example, it may not be a pointer to an integer. 506/// 507/// If this returns a normal address, and if the lvalue's C type is fixed size, 508/// this method guarantees that the returned pointer type will point to an LLVM 509/// type of the same size of the lvalue's type. If the lvalue has a variable 510/// length type, this is not possible. 511/// 512LValue CodeGenFunction::EmitLValue(const Expr *E) { 513 llvm::DenseMap<const Expr *, LValue>::iterator I = 514 ConditionalSaveLValueExprs.find(E); 515 if (I != ConditionalSaveLValueExprs.end()) 516 return I->second; 517 518 switch (E->getStmtClass()) { 519 default: return EmitUnsupportedLValue(E, "l-value expression"); 520 521 case Expr::ObjCSelectorExprClass: 522 return EmitObjCSelectorLValue(cast<ObjCSelectorExpr>(E)); 523 case Expr::ObjCIsaExprClass: 524 return EmitObjCIsaExpr(cast<ObjCIsaExpr>(E)); 525 case Expr::BinaryOperatorClass: 526 return EmitBinaryOperatorLValue(cast<BinaryOperator>(E)); 527 case Expr::CompoundAssignOperatorClass: 528 if (!E->getType()->isAnyComplexType()) 529 return EmitCompoundAssignmentLValue(cast<CompoundAssignOperator>(E)); 530 return EmitComplexCompoundAssignmentLValue(cast<CompoundAssignOperator>(E)); 531 case Expr::CallExprClass: 532 case Expr::CXXMemberCallExprClass: 533 case Expr::CXXOperatorCallExprClass: 534 return EmitCallExprLValue(cast<CallExpr>(E)); 535 case Expr::VAArgExprClass: 536 return EmitVAArgExprLValue(cast<VAArgExpr>(E)); 537 case Expr::DeclRefExprClass: 538 return EmitDeclRefLValue(cast<DeclRefExpr>(E)); 539 case Expr::ParenExprClass:return EmitLValue(cast<ParenExpr>(E)->getSubExpr()); 540 case Expr::PredefinedExprClass: 541 return EmitPredefinedLValue(cast<PredefinedExpr>(E)); 542 case Expr::StringLiteralClass: 543 return EmitStringLiteralLValue(cast<StringLiteral>(E)); 544 case Expr::ObjCEncodeExprClass: 545 return EmitObjCEncodeExprLValue(cast<ObjCEncodeExpr>(E)); 546 547 case Expr::BlockDeclRefExprClass: 548 return EmitBlockDeclRefLValue(cast<BlockDeclRefExpr>(E)); 549 550 case Expr::CXXTemporaryObjectExprClass: 551 case Expr::CXXConstructExprClass: 552 return EmitCXXConstructLValue(cast<CXXConstructExpr>(E)); 553 case Expr::CXXBindTemporaryExprClass: 554 return EmitCXXBindTemporaryLValue(cast<CXXBindTemporaryExpr>(E)); 555 case Expr::ExprWithCleanupsClass: 556 return EmitExprWithCleanupsLValue(cast<ExprWithCleanups>(E)); 557 case Expr::CXXScalarValueInitExprClass: 558 return EmitNullInitializationLValue(cast<CXXScalarValueInitExpr>(E)); 559 case Expr::CXXDefaultArgExprClass: 560 return EmitLValue(cast<CXXDefaultArgExpr>(E)->getExpr()); 561 case Expr::CXXTypeidExprClass: 562 return EmitCXXTypeidLValue(cast<CXXTypeidExpr>(E)); 563 564 case Expr::ObjCMessageExprClass: 565 return EmitObjCMessageExprLValue(cast<ObjCMessageExpr>(E)); 566 case Expr::ObjCIvarRefExprClass: 567 return EmitObjCIvarRefLValue(cast<ObjCIvarRefExpr>(E)); 568 case Expr::ObjCPropertyRefExprClass: 569 return EmitObjCPropertyRefLValue(cast<ObjCPropertyRefExpr>(E)); 570 case Expr::StmtExprClass: 571 return EmitStmtExprLValue(cast<StmtExpr>(E)); 572 case Expr::UnaryOperatorClass: 573 return EmitUnaryOpLValue(cast<UnaryOperator>(E)); 574 case Expr::ArraySubscriptExprClass: 575 return EmitArraySubscriptExpr(cast<ArraySubscriptExpr>(E)); 576 case Expr::ExtVectorElementExprClass: 577 return EmitExtVectorElementExpr(cast<ExtVectorElementExpr>(E)); 578 case Expr::MemberExprClass: 579 return EmitMemberExpr(cast<MemberExpr>(E)); 580 case Expr::CompoundLiteralExprClass: 581 return EmitCompoundLiteralLValue(cast<CompoundLiteralExpr>(E)); 582 case Expr::ConditionalOperatorClass: 583 return EmitConditionalOperatorLValue(cast<ConditionalOperator>(E)); 584 case Expr::ChooseExprClass: 585 return EmitLValue(cast<ChooseExpr>(E)->getChosenSubExpr(getContext())); 586 case Expr::ImplicitCastExprClass: 587 case Expr::CStyleCastExprClass: 588 case Expr::CXXFunctionalCastExprClass: 589 case Expr::CXXStaticCastExprClass: 590 case Expr::CXXDynamicCastExprClass: 591 case Expr::CXXReinterpretCastExprClass: 592 case Expr::CXXConstCastExprClass: 593 return EmitCastLValue(cast<CastExpr>(E)); 594 } 595} 596 597llvm::Value *CodeGenFunction::EmitLoadOfScalar(llvm::Value *Addr, bool Volatile, 598 unsigned Alignment, QualType Ty, 599 llvm::MDNode *TBAAInfo) { 600 llvm::LoadInst *Load = Builder.CreateLoad(Addr, "tmp"); 601 if (Volatile) 602 Load->setVolatile(true); 603 if (Alignment) 604 Load->setAlignment(Alignment); 605 if (TBAAInfo) 606 CGM.DecorateInstruction(Load, TBAAInfo); 607 608 return EmitFromMemory(Load, Ty); 609} 610 611static bool isBooleanUnderlyingType(QualType Ty) { 612 if (const EnumType *ET = dyn_cast<EnumType>(Ty)) 613 return ET->getDecl()->getIntegerType()->isBooleanType(); 614 return false; 615} 616 617llvm::Value *CodeGenFunction::EmitToMemory(llvm::Value *Value, QualType Ty) { 618 // Bool has a different representation in memory than in registers. 619 if (Ty->isBooleanType() || isBooleanUnderlyingType(Ty)) { 620 // This should really always be an i1, but sometimes it's already 621 // an i8, and it's awkward to track those cases down. 622 if (Value->getType()->isIntegerTy(1)) 623 return Builder.CreateZExt(Value, Builder.getInt8Ty(), "frombool"); 624 assert(Value->getType()->isIntegerTy(8) && "value rep of bool not i1/i8"); 625 } 626 627 return Value; 628} 629 630llvm::Value *CodeGenFunction::EmitFromMemory(llvm::Value *Value, QualType Ty) { 631 // Bool has a different representation in memory than in registers. 632 if (Ty->isBooleanType() || isBooleanUnderlyingType(Ty)) { 633 assert(Value->getType()->isIntegerTy(8) && "memory rep of bool not i8"); 634 return Builder.CreateTrunc(Value, Builder.getInt1Ty(), "tobool"); 635 } 636 637 return Value; 638} 639 640void CodeGenFunction::EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr, 641 bool Volatile, unsigned Alignment, 642 QualType Ty, 643 llvm::MDNode *TBAAInfo) { 644 Value = EmitToMemory(Value, Ty); 645 llvm::StoreInst *Store = Builder.CreateStore(Value, Addr, Volatile); 646 if (Alignment) 647 Store->setAlignment(Alignment); 648 if (TBAAInfo) 649 CGM.DecorateInstruction(Store, TBAAInfo); 650} 651 652/// EmitLoadOfLValue - Given an expression that represents a value lvalue, this 653/// method emits the address of the lvalue, then loads the result as an rvalue, 654/// returning the rvalue. 655RValue CodeGenFunction::EmitLoadOfLValue(LValue LV, QualType ExprType) { 656 if (LV.isObjCWeak()) { 657 // load of a __weak object. 658 llvm::Value *AddrWeakObj = LV.getAddress(); 659 return RValue::get(CGM.getObjCRuntime().EmitObjCWeakRead(*this, 660 AddrWeakObj)); 661 } 662 663 if (LV.isSimple()) { 664 llvm::Value *Ptr = LV.getAddress(); 665 666 // Functions are l-values that don't require loading. 667 if (ExprType->isFunctionType()) 668 return RValue::get(Ptr); 669 670 // Everything needs a load. 671 return RValue::get(EmitLoadOfScalar(Ptr, LV.isVolatileQualified(), 672 LV.getAlignment(), ExprType, 673 LV.getTBAAInfo())); 674 675 } 676 677 if (LV.isVectorElt()) { 678 llvm::Value *Vec = Builder.CreateLoad(LV.getVectorAddr(), 679 LV.isVolatileQualified(), "tmp"); 680 return RValue::get(Builder.CreateExtractElement(Vec, LV.getVectorIdx(), 681 "vecext")); 682 } 683 684 // If this is a reference to a subset of the elements of a vector, either 685 // shuffle the input or extract/insert them as appropriate. 686 if (LV.isExtVectorElt()) 687 return EmitLoadOfExtVectorElementLValue(LV, ExprType); 688 689 if (LV.isBitField()) 690 return EmitLoadOfBitfieldLValue(LV, ExprType); 691 692 assert(LV.isPropertyRef() && "Unknown LValue type!"); 693 return EmitLoadOfPropertyRefLValue(LV); 694} 695 696RValue CodeGenFunction::EmitLoadOfBitfieldLValue(LValue LV, 697 QualType ExprType) { 698 const CGBitFieldInfo &Info = LV.getBitFieldInfo(); 699 700 // Get the output type. 701 const llvm::Type *ResLTy = ConvertType(ExprType); 702 unsigned ResSizeInBits = CGM.getTargetData().getTypeSizeInBits(ResLTy); 703 704 // Compute the result as an OR of all of the individual component accesses. 705 llvm::Value *Res = 0; 706 for (unsigned i = 0, e = Info.getNumComponents(); i != e; ++i) { 707 const CGBitFieldInfo::AccessInfo &AI = Info.getComponent(i); 708 709 // Get the field pointer. 710 llvm::Value *Ptr = LV.getBitFieldBaseAddr(); 711 712 // Only offset by the field index if used, so that incoming values are not 713 // required to be structures. 714 if (AI.FieldIndex) 715 Ptr = Builder.CreateStructGEP(Ptr, AI.FieldIndex, "bf.field"); 716 717 // Offset by the byte offset, if used. 718 if (AI.FieldByteOffset) { 719 Ptr = EmitCastToVoidPtr(Ptr); 720 Ptr = Builder.CreateConstGEP1_32(Ptr, AI.FieldByteOffset,"bf.field.offs"); 721 } 722 723 // Cast to the access type. 724 const llvm::Type *PTy = llvm::Type::getIntNPtrTy(getLLVMContext(), 725 AI.AccessWidth, 726 ExprType.getAddressSpace()); 727 Ptr = Builder.CreateBitCast(Ptr, PTy); 728 729 // Perform the load. 730 llvm::LoadInst *Load = Builder.CreateLoad(Ptr, LV.isVolatileQualified()); 731 if (AI.AccessAlignment) 732 Load->setAlignment(AI.AccessAlignment); 733 734 // Shift out unused low bits and mask out unused high bits. 735 llvm::Value *Val = Load; 736 if (AI.FieldBitStart) 737 Val = Builder.CreateLShr(Load, AI.FieldBitStart); 738 Val = Builder.CreateAnd(Val, llvm::APInt::getLowBitsSet(AI.AccessWidth, 739 AI.TargetBitWidth), 740 "bf.clear"); 741 742 // Extend or truncate to the target size. 743 if (AI.AccessWidth < ResSizeInBits) 744 Val = Builder.CreateZExt(Val, ResLTy); 745 else if (AI.AccessWidth > ResSizeInBits) 746 Val = Builder.CreateTrunc(Val, ResLTy); 747 748 // Shift into place, and OR into the result. 749 if (AI.TargetBitOffset) 750 Val = Builder.CreateShl(Val, AI.TargetBitOffset); 751 Res = Res ? Builder.CreateOr(Res, Val) : Val; 752 } 753 754 // If the bit-field is signed, perform the sign-extension. 755 // 756 // FIXME: This can easily be folded into the load of the high bits, which 757 // could also eliminate the mask of high bits in some situations. 758 if (Info.isSigned()) { 759 unsigned ExtraBits = ResSizeInBits - Info.getSize(); 760 if (ExtraBits) 761 Res = Builder.CreateAShr(Builder.CreateShl(Res, ExtraBits), 762 ExtraBits, "bf.val.sext"); 763 } 764 765 return RValue::get(Res); 766} 767 768// If this is a reference to a subset of the elements of a vector, create an 769// appropriate shufflevector. 770RValue CodeGenFunction::EmitLoadOfExtVectorElementLValue(LValue LV, 771 QualType ExprType) { 772 llvm::Value *Vec = Builder.CreateLoad(LV.getExtVectorAddr(), 773 LV.isVolatileQualified(), "tmp"); 774 775 const llvm::Constant *Elts = LV.getExtVectorElts(); 776 777 // If the result of the expression is a non-vector type, we must be extracting 778 // a single element. Just codegen as an extractelement. 779 const VectorType *ExprVT = ExprType->getAs<VectorType>(); 780 if (!ExprVT) { 781 unsigned InIdx = getAccessedFieldNo(0, Elts); 782 llvm::Value *Elt = llvm::ConstantInt::get(Int32Ty, InIdx); 783 return RValue::get(Builder.CreateExtractElement(Vec, Elt, "tmp")); 784 } 785 786 // Always use shuffle vector to try to retain the original program structure 787 unsigned NumResultElts = ExprVT->getNumElements(); 788 789 llvm::SmallVector<llvm::Constant*, 4> Mask; 790 for (unsigned i = 0; i != NumResultElts; ++i) { 791 unsigned InIdx = getAccessedFieldNo(i, Elts); 792 Mask.push_back(llvm::ConstantInt::get(Int32Ty, InIdx)); 793 } 794 795 llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size()); 796 Vec = Builder.CreateShuffleVector(Vec, 797 llvm::UndefValue::get(Vec->getType()), 798 MaskV, "tmp"); 799 return RValue::get(Vec); 800} 801 802 803 804/// EmitStoreThroughLValue - Store the specified rvalue into the specified 805/// lvalue, where both are guaranteed to the have the same type, and that type 806/// is 'Ty'. 807void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst, 808 QualType Ty) { 809 if (!Dst.isSimple()) { 810 if (Dst.isVectorElt()) { 811 // Read/modify/write the vector, inserting the new element. 812 llvm::Value *Vec = Builder.CreateLoad(Dst.getVectorAddr(), 813 Dst.isVolatileQualified(), "tmp"); 814 Vec = Builder.CreateInsertElement(Vec, Src.getScalarVal(), 815 Dst.getVectorIdx(), "vecins"); 816 Builder.CreateStore(Vec, Dst.getVectorAddr(),Dst.isVolatileQualified()); 817 return; 818 } 819 820 // If this is an update of extended vector elements, insert them as 821 // appropriate. 822 if (Dst.isExtVectorElt()) 823 return EmitStoreThroughExtVectorComponentLValue(Src, Dst, Ty); 824 825 if (Dst.isBitField()) 826 return EmitStoreThroughBitfieldLValue(Src, Dst, Ty); 827 828 assert(Dst.isPropertyRef() && "Unknown LValue type"); 829 return EmitStoreThroughPropertyRefLValue(Src, Dst); 830 } 831 832 if (Dst.isObjCWeak() && !Dst.isNonGC()) { 833 // load of a __weak object. 834 llvm::Value *LvalueDst = Dst.getAddress(); 835 llvm::Value *src = Src.getScalarVal(); 836 CGM.getObjCRuntime().EmitObjCWeakAssign(*this, src, LvalueDst); 837 return; 838 } 839 840 if (Dst.isObjCStrong() && !Dst.isNonGC()) { 841 // load of a __strong object. 842 llvm::Value *LvalueDst = Dst.getAddress(); 843 llvm::Value *src = Src.getScalarVal(); 844 if (Dst.isObjCIvar()) { 845 assert(Dst.getBaseIvarExp() && "BaseIvarExp is NULL"); 846 const llvm::Type *ResultType = ConvertType(getContext().LongTy); 847 llvm::Value *RHS = EmitScalarExpr(Dst.getBaseIvarExp()); 848 llvm::Value *dst = RHS; 849 RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast"); 850 llvm::Value *LHS = 851 Builder.CreatePtrToInt(LvalueDst, ResultType, "sub.ptr.lhs.cast"); 852 llvm::Value *BytesBetween = Builder.CreateSub(LHS, RHS, "ivar.offset"); 853 CGM.getObjCRuntime().EmitObjCIvarAssign(*this, src, dst, 854 BytesBetween); 855 } else if (Dst.isGlobalObjCRef()) { 856 CGM.getObjCRuntime().EmitObjCGlobalAssign(*this, src, LvalueDst, 857 Dst.isThreadLocalRef()); 858 } 859 else 860 CGM.getObjCRuntime().EmitObjCStrongCastAssign(*this, src, LvalueDst); 861 return; 862 } 863 864 assert(Src.isScalar() && "Can't emit an agg store with this method"); 865 EmitStoreOfScalar(Src.getScalarVal(), Dst.getAddress(), 866 Dst.isVolatileQualified(), Dst.getAlignment(), Ty, 867 Dst.getTBAAInfo()); 868} 869 870void CodeGenFunction::EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, 871 QualType Ty, 872 llvm::Value **Result) { 873 const CGBitFieldInfo &Info = Dst.getBitFieldInfo(); 874 875 // Get the output type. 876 const llvm::Type *ResLTy = ConvertTypeForMem(Ty); 877 unsigned ResSizeInBits = CGM.getTargetData().getTypeSizeInBits(ResLTy); 878 879 // Get the source value, truncated to the width of the bit-field. 880 llvm::Value *SrcVal = Src.getScalarVal(); 881 882 if (Ty->isBooleanType()) 883 SrcVal = Builder.CreateIntCast(SrcVal, ResLTy, /*IsSigned=*/false); 884 885 SrcVal = Builder.CreateAnd(SrcVal, llvm::APInt::getLowBitsSet(ResSizeInBits, 886 Info.getSize()), 887 "bf.value"); 888 889 // Return the new value of the bit-field, if requested. 890 if (Result) { 891 // Cast back to the proper type for result. 892 const llvm::Type *SrcTy = Src.getScalarVal()->getType(); 893 llvm::Value *ReloadVal = Builder.CreateIntCast(SrcVal, SrcTy, false, 894 "bf.reload.val"); 895 896 // Sign extend if necessary. 897 if (Info.isSigned()) { 898 unsigned ExtraBits = ResSizeInBits - Info.getSize(); 899 if (ExtraBits) 900 ReloadVal = Builder.CreateAShr(Builder.CreateShl(ReloadVal, ExtraBits), 901 ExtraBits, "bf.reload.sext"); 902 } 903 904 *Result = ReloadVal; 905 } 906 907 // Iterate over the components, writing each piece to memory. 908 for (unsigned i = 0, e = Info.getNumComponents(); i != e; ++i) { 909 const CGBitFieldInfo::AccessInfo &AI = Info.getComponent(i); 910 911 // Get the field pointer. 912 llvm::Value *Ptr = Dst.getBitFieldBaseAddr(); 913 unsigned addressSpace = 914 cast<llvm::PointerType>(Ptr->getType())->getAddressSpace(); 915 916 // Only offset by the field index if used, so that incoming values are not 917 // required to be structures. 918 if (AI.FieldIndex) 919 Ptr = Builder.CreateStructGEP(Ptr, AI.FieldIndex, "bf.field"); 920 921 // Offset by the byte offset, if used. 922 if (AI.FieldByteOffset) { 923 Ptr = EmitCastToVoidPtr(Ptr); 924 Ptr = Builder.CreateConstGEP1_32(Ptr, AI.FieldByteOffset,"bf.field.offs"); 925 } 926 927 // Cast to the access type. 928 const llvm::Type *AccessLTy = 929 llvm::Type::getIntNTy(getLLVMContext(), AI.AccessWidth); 930 931 const llvm::Type *PTy = AccessLTy->getPointerTo(addressSpace); 932 Ptr = Builder.CreateBitCast(Ptr, PTy); 933 934 // Extract the piece of the bit-field value to write in this access, limited 935 // to the values that are part of this access. 936 llvm::Value *Val = SrcVal; 937 if (AI.TargetBitOffset) 938 Val = Builder.CreateLShr(Val, AI.TargetBitOffset); 939 Val = Builder.CreateAnd(Val, llvm::APInt::getLowBitsSet(ResSizeInBits, 940 AI.TargetBitWidth)); 941 942 // Extend or truncate to the access size. 943 if (ResSizeInBits < AI.AccessWidth) 944 Val = Builder.CreateZExt(Val, AccessLTy); 945 else if (ResSizeInBits > AI.AccessWidth) 946 Val = Builder.CreateTrunc(Val, AccessLTy); 947 948 // Shift into the position in memory. 949 if (AI.FieldBitStart) 950 Val = Builder.CreateShl(Val, AI.FieldBitStart); 951 952 // If necessary, load and OR in bits that are outside of the bit-field. 953 if (AI.TargetBitWidth != AI.AccessWidth) { 954 llvm::LoadInst *Load = Builder.CreateLoad(Ptr, Dst.isVolatileQualified()); 955 if (AI.AccessAlignment) 956 Load->setAlignment(AI.AccessAlignment); 957 958 // Compute the mask for zeroing the bits that are part of the bit-field. 959 llvm::APInt InvMask = 960 ~llvm::APInt::getBitsSet(AI.AccessWidth, AI.FieldBitStart, 961 AI.FieldBitStart + AI.TargetBitWidth); 962 963 // Apply the mask and OR in to the value to write. 964 Val = Builder.CreateOr(Builder.CreateAnd(Load, InvMask), Val); 965 } 966 967 // Write the value. 968 llvm::StoreInst *Store = Builder.CreateStore(Val, Ptr, 969 Dst.isVolatileQualified()); 970 if (AI.AccessAlignment) 971 Store->setAlignment(AI.AccessAlignment); 972 } 973} 974 975void CodeGenFunction::EmitStoreThroughExtVectorComponentLValue(RValue Src, 976 LValue Dst, 977 QualType Ty) { 978 // This access turns into a read/modify/write of the vector. Load the input 979 // value now. 980 llvm::Value *Vec = Builder.CreateLoad(Dst.getExtVectorAddr(), 981 Dst.isVolatileQualified(), "tmp"); 982 const llvm::Constant *Elts = Dst.getExtVectorElts(); 983 984 llvm::Value *SrcVal = Src.getScalarVal(); 985 986 if (const VectorType *VTy = Ty->getAs<VectorType>()) { 987 unsigned NumSrcElts = VTy->getNumElements(); 988 unsigned NumDstElts = 989 cast<llvm::VectorType>(Vec->getType())->getNumElements(); 990 if (NumDstElts == NumSrcElts) { 991 // Use shuffle vector is the src and destination are the same number of 992 // elements and restore the vector mask since it is on the side it will be 993 // stored. 994 llvm::SmallVector<llvm::Constant*, 4> Mask(NumDstElts); 995 for (unsigned i = 0; i != NumSrcElts; ++i) { 996 unsigned InIdx = getAccessedFieldNo(i, Elts); 997 Mask[InIdx] = llvm::ConstantInt::get(Int32Ty, i); 998 } 999 1000 llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size()); 1001 Vec = Builder.CreateShuffleVector(SrcVal, 1002 llvm::UndefValue::get(Vec->getType()), 1003 MaskV, "tmp"); 1004 } else if (NumDstElts > NumSrcElts) { 1005 // Extended the source vector to the same length and then shuffle it 1006 // into the destination. 1007 // FIXME: since we're shuffling with undef, can we just use the indices 1008 // into that? This could be simpler. 1009 llvm::SmallVector<llvm::Constant*, 4> ExtMask; 1010 unsigned i; 1011 for (i = 0; i != NumSrcElts; ++i) 1012 ExtMask.push_back(llvm::ConstantInt::get(Int32Ty, i)); 1013 for (; i != NumDstElts; ++i) 1014 ExtMask.push_back(llvm::UndefValue::get(Int32Ty)); 1015 llvm::Value *ExtMaskV = llvm::ConstantVector::get(&ExtMask[0], 1016 ExtMask.size()); 1017 llvm::Value *ExtSrcVal = 1018 Builder.CreateShuffleVector(SrcVal, 1019 llvm::UndefValue::get(SrcVal->getType()), 1020 ExtMaskV, "tmp"); 1021 // build identity 1022 llvm::SmallVector<llvm::Constant*, 4> Mask; 1023 for (unsigned i = 0; i != NumDstElts; ++i) 1024 Mask.push_back(llvm::ConstantInt::get(Int32Ty, i)); 1025 1026 // modify when what gets shuffled in 1027 for (unsigned i = 0; i != NumSrcElts; ++i) { 1028 unsigned Idx = getAccessedFieldNo(i, Elts); 1029 Mask[Idx] = llvm::ConstantInt::get(Int32Ty, i+NumDstElts); 1030 } 1031 llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size()); 1032 Vec = Builder.CreateShuffleVector(Vec, ExtSrcVal, MaskV, "tmp"); 1033 } else { 1034 // We should never shorten the vector 1035 assert(0 && "unexpected shorten vector length"); 1036 } 1037 } else { 1038 // If the Src is a scalar (not a vector) it must be updating one element. 1039 unsigned InIdx = getAccessedFieldNo(0, Elts); 1040 llvm::Value *Elt = llvm::ConstantInt::get(Int32Ty, InIdx); 1041 Vec = Builder.CreateInsertElement(Vec, SrcVal, Elt, "tmp"); 1042 } 1043 1044 Builder.CreateStore(Vec, Dst.getExtVectorAddr(), Dst.isVolatileQualified()); 1045} 1046 1047// setObjCGCLValueClass - sets class of he lvalue for the purpose of 1048// generating write-barries API. It is currently a global, ivar, 1049// or neither. 1050static void setObjCGCLValueClass(const ASTContext &Ctx, const Expr *E, 1051 LValue &LV) { 1052 if (Ctx.getLangOptions().getGCMode() == LangOptions::NonGC) 1053 return; 1054 1055 if (isa<ObjCIvarRefExpr>(E)) { 1056 LV.setObjCIvar(true); 1057 ObjCIvarRefExpr *Exp = cast<ObjCIvarRefExpr>(const_cast<Expr*>(E)); 1058 LV.setBaseIvarExp(Exp->getBase()); 1059 LV.setObjCArray(E->getType()->isArrayType()); 1060 return; 1061 } 1062 1063 if (const DeclRefExpr *Exp = dyn_cast<DeclRefExpr>(E)) { 1064 if (const VarDecl *VD = dyn_cast<VarDecl>(Exp->getDecl())) { 1065 if (VD->hasGlobalStorage()) { 1066 LV.setGlobalObjCRef(true); 1067 LV.setThreadLocalRef(VD->isThreadSpecified()); 1068 } 1069 } 1070 LV.setObjCArray(E->getType()->isArrayType()); 1071 return; 1072 } 1073 1074 if (const UnaryOperator *Exp = dyn_cast<UnaryOperator>(E)) { 1075 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV); 1076 return; 1077 } 1078 1079 if (const ParenExpr *Exp = dyn_cast<ParenExpr>(E)) { 1080 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV); 1081 if (LV.isObjCIvar()) { 1082 // If cast is to a structure pointer, follow gcc's behavior and make it 1083 // a non-ivar write-barrier. 1084 QualType ExpTy = E->getType(); 1085 if (ExpTy->isPointerType()) 1086 ExpTy = ExpTy->getAs<PointerType>()->getPointeeType(); 1087 if (ExpTy->isRecordType()) 1088 LV.setObjCIvar(false); 1089 } 1090 return; 1091 } 1092 if (const ImplicitCastExpr *Exp = dyn_cast<ImplicitCastExpr>(E)) { 1093 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV); 1094 return; 1095 } 1096 1097 if (const CStyleCastExpr *Exp = dyn_cast<CStyleCastExpr>(E)) { 1098 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV); 1099 return; 1100 } 1101 1102 if (const ArraySubscriptExpr *Exp = dyn_cast<ArraySubscriptExpr>(E)) { 1103 setObjCGCLValueClass(Ctx, Exp->getBase(), LV); 1104 if (LV.isObjCIvar() && !LV.isObjCArray()) 1105 // Using array syntax to assigning to what an ivar points to is not 1106 // same as assigning to the ivar itself. {id *Names;} Names[i] = 0; 1107 LV.setObjCIvar(false); 1108 else if (LV.isGlobalObjCRef() && !LV.isObjCArray()) 1109 // Using array syntax to assigning to what global points to is not 1110 // same as assigning to the global itself. {id *G;} G[i] = 0; 1111 LV.setGlobalObjCRef(false); 1112 return; 1113 } 1114 1115 if (const MemberExpr *Exp = dyn_cast<MemberExpr>(E)) { 1116 setObjCGCLValueClass(Ctx, Exp->getBase(), LV); 1117 // We don't know if member is an 'ivar', but this flag is looked at 1118 // only in the context of LV.isObjCIvar(). 1119 LV.setObjCArray(E->getType()->isArrayType()); 1120 return; 1121 } 1122} 1123 1124static LValue EmitGlobalVarDeclLValue(CodeGenFunction &CGF, 1125 const Expr *E, const VarDecl *VD) { 1126 assert((VD->hasExternalStorage() || VD->isFileVarDecl()) && 1127 "Var decl must have external storage or be a file var decl!"); 1128 1129 llvm::Value *V = CGF.CGM.GetAddrOfGlobalVar(VD); 1130 if (VD->getType()->isReferenceType()) 1131 V = CGF.Builder.CreateLoad(V, "tmp"); 1132 unsigned Alignment = CGF.getContext().getDeclAlign(VD).getQuantity(); 1133 LValue LV = CGF.MakeAddrLValue(V, E->getType(), Alignment); 1134 setObjCGCLValueClass(CGF.getContext(), E, LV); 1135 return LV; 1136} 1137 1138static LValue EmitFunctionDeclLValue(CodeGenFunction &CGF, 1139 const Expr *E, const FunctionDecl *FD) { 1140 llvm::Value *V = CGF.CGM.GetAddrOfFunction(FD); 1141 if (!FD->hasPrototype()) { 1142 if (const FunctionProtoType *Proto = 1143 FD->getType()->getAs<FunctionProtoType>()) { 1144 // Ugly case: for a K&R-style definition, the type of the definition 1145 // isn't the same as the type of a use. Correct for this with a 1146 // bitcast. 1147 QualType NoProtoType = 1148 CGF.getContext().getFunctionNoProtoType(Proto->getResultType()); 1149 NoProtoType = CGF.getContext().getPointerType(NoProtoType); 1150 V = CGF.Builder.CreateBitCast(V, CGF.ConvertType(NoProtoType), "tmp"); 1151 } 1152 } 1153 unsigned Alignment = CGF.getContext().getDeclAlign(FD).getQuantity(); 1154 return CGF.MakeAddrLValue(V, E->getType(), Alignment); 1155} 1156 1157LValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) { 1158 const NamedDecl *ND = E->getDecl(); 1159 unsigned Alignment = getContext().getDeclAlign(ND).getQuantity(); 1160 1161 if (ND->hasAttr<WeakRefAttr>()) { 1162 const ValueDecl *VD = cast<ValueDecl>(ND); 1163 llvm::Constant *Aliasee = CGM.GetWeakRefReference(VD); 1164 return MakeAddrLValue(Aliasee, E->getType(), Alignment); 1165 } 1166 1167 if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) { 1168 1169 // Check if this is a global variable. 1170 if (VD->hasExternalStorage() || VD->isFileVarDecl()) 1171 return EmitGlobalVarDeclLValue(*this, E, VD); 1172 1173 bool NonGCable = VD->hasLocalStorage() && 1174 !VD->getType()->isReferenceType() && 1175 !VD->hasAttr<BlocksAttr>(); 1176 1177 llvm::Value *V = LocalDeclMap[VD]; 1178 if (!V && VD->isStaticLocal()) 1179 V = CGM.getStaticLocalDeclAddress(VD); 1180 assert(V && "DeclRefExpr not entered in LocalDeclMap?"); 1181 1182 if (VD->hasAttr<BlocksAttr>()) 1183 V = BuildBlockByrefAddress(V, VD); 1184 1185 if (VD->getType()->isReferenceType()) 1186 V = Builder.CreateLoad(V, "tmp"); 1187 1188 LValue LV = MakeAddrLValue(V, E->getType(), Alignment); 1189 if (NonGCable) { 1190 LV.getQuals().removeObjCGCAttr(); 1191 LV.setNonGC(true); 1192 } 1193 setObjCGCLValueClass(getContext(), E, LV); 1194 return LV; 1195 } 1196 1197 if (const FunctionDecl *fn = dyn_cast<FunctionDecl>(ND)) 1198 return EmitFunctionDeclLValue(*this, E, fn); 1199 1200 assert(false && "Unhandled DeclRefExpr"); 1201 1202 // an invalid LValue, but the assert will 1203 // ensure that this point is never reached. 1204 return LValue(); 1205} 1206 1207LValue CodeGenFunction::EmitBlockDeclRefLValue(const BlockDeclRefExpr *E) { 1208 unsigned Alignment = 1209 getContext().getDeclAlign(E->getDecl()).getQuantity(); 1210 return MakeAddrLValue(GetAddrOfBlockDecl(E), E->getType(), Alignment); 1211} 1212 1213LValue CodeGenFunction::EmitUnaryOpLValue(const UnaryOperator *E) { 1214 // __extension__ doesn't affect lvalue-ness. 1215 if (E->getOpcode() == UO_Extension) 1216 return EmitLValue(E->getSubExpr()); 1217 1218 QualType ExprTy = getContext().getCanonicalType(E->getSubExpr()->getType()); 1219 switch (E->getOpcode()) { 1220 default: assert(0 && "Unknown unary operator lvalue!"); 1221 case UO_Deref: { 1222 QualType T = E->getSubExpr()->getType()->getPointeeType(); 1223 assert(!T.isNull() && "CodeGenFunction::EmitUnaryOpLValue: Illegal type"); 1224 1225 LValue LV = MakeAddrLValue(EmitScalarExpr(E->getSubExpr()), T); 1226 LV.getQuals().setAddressSpace(ExprTy.getAddressSpace()); 1227 1228 // We should not generate __weak write barrier on indirect reference 1229 // of a pointer to object; as in void foo (__weak id *param); *param = 0; 1230 // But, we continue to generate __strong write barrier on indirect write 1231 // into a pointer to object. 1232 if (getContext().getLangOptions().ObjC1 && 1233 getContext().getLangOptions().getGCMode() != LangOptions::NonGC && 1234 LV.isObjCWeak()) 1235 LV.setNonGC(!E->isOBJCGCCandidate(getContext())); 1236 return LV; 1237 } 1238 case UO_Real: 1239 case UO_Imag: { 1240 LValue LV = EmitLValue(E->getSubExpr()); 1241 assert(LV.isSimple() && "real/imag on non-ordinary l-value"); 1242 llvm::Value *Addr = LV.getAddress(); 1243 1244 // real and imag are valid on scalars. This is a faster way of 1245 // testing that. 1246 if (!cast<llvm::PointerType>(Addr->getType()) 1247 ->getElementType()->isStructTy()) { 1248 assert(E->getSubExpr()->getType()->isArithmeticType()); 1249 return LV; 1250 } 1251 1252 assert(E->getSubExpr()->getType()->isAnyComplexType()); 1253 1254 unsigned Idx = E->getOpcode() == UO_Imag; 1255 return MakeAddrLValue(Builder.CreateStructGEP(LV.getAddress(), 1256 Idx, "idx"), 1257 ExprTy); 1258 } 1259 case UO_PreInc: 1260 case UO_PreDec: { 1261 LValue LV = EmitLValue(E->getSubExpr()); 1262 bool isInc = E->getOpcode() == UO_PreInc; 1263 1264 if (E->getType()->isAnyComplexType()) 1265 EmitComplexPrePostIncDec(E, LV, isInc, true/*isPre*/); 1266 else 1267 EmitScalarPrePostIncDec(E, LV, isInc, true/*isPre*/); 1268 return LV; 1269 } 1270 } 1271} 1272 1273LValue CodeGenFunction::EmitStringLiteralLValue(const StringLiteral *E) { 1274 return MakeAddrLValue(CGM.GetAddrOfConstantStringFromLiteral(E), 1275 E->getType()); 1276} 1277 1278LValue CodeGenFunction::EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E) { 1279 return MakeAddrLValue(CGM.GetAddrOfConstantStringFromObjCEncode(E), 1280 E->getType()); 1281} 1282 1283 1284LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) { 1285 switch (E->getIdentType()) { 1286 default: 1287 return EmitUnsupportedLValue(E, "predefined expression"); 1288 1289 case PredefinedExpr::Func: 1290 case PredefinedExpr::Function: 1291 case PredefinedExpr::PrettyFunction: { 1292 unsigned Type = E->getIdentType(); 1293 std::string GlobalVarName; 1294 1295 switch (Type) { 1296 default: assert(0 && "Invalid type"); 1297 case PredefinedExpr::Func: 1298 GlobalVarName = "__func__."; 1299 break; 1300 case PredefinedExpr::Function: 1301 GlobalVarName = "__FUNCTION__."; 1302 break; 1303 case PredefinedExpr::PrettyFunction: 1304 GlobalVarName = "__PRETTY_FUNCTION__."; 1305 break; 1306 } 1307 1308 llvm::StringRef FnName = CurFn->getName(); 1309 if (FnName.startswith("\01")) 1310 FnName = FnName.substr(1); 1311 GlobalVarName += FnName; 1312 1313 const Decl *CurDecl = CurCodeDecl; 1314 if (CurDecl == 0) 1315 CurDecl = getContext().getTranslationUnitDecl(); 1316 1317 std::string FunctionName = 1318 (isa<BlockDecl>(CurDecl) 1319 ? FnName.str() 1320 : PredefinedExpr::ComputeName((PredefinedExpr::IdentType)Type, CurDecl)); 1321 1322 llvm::Constant *C = 1323 CGM.GetAddrOfConstantCString(FunctionName, GlobalVarName.c_str()); 1324 return MakeAddrLValue(C, E->getType()); 1325 } 1326 } 1327} 1328 1329llvm::BasicBlock *CodeGenFunction::getTrapBB() { 1330 const CodeGenOptions &GCO = CGM.getCodeGenOpts(); 1331 1332 // If we are not optimzing, don't collapse all calls to trap in the function 1333 // to the same call, that way, in the debugger they can see which operation 1334 // did in fact fail. If we are optimizing, we collapse all calls to trap down 1335 // to just one per function to save on codesize. 1336 if (GCO.OptimizationLevel && TrapBB) 1337 return TrapBB; 1338 1339 llvm::BasicBlock *Cont = 0; 1340 if (HaveInsertPoint()) { 1341 Cont = createBasicBlock("cont"); 1342 EmitBranch(Cont); 1343 } 1344 TrapBB = createBasicBlock("trap"); 1345 EmitBlock(TrapBB); 1346 1347 llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::trap, 0, 0); 1348 llvm::CallInst *TrapCall = Builder.CreateCall(F); 1349 TrapCall->setDoesNotReturn(); 1350 TrapCall->setDoesNotThrow(); 1351 Builder.CreateUnreachable(); 1352 1353 if (Cont) 1354 EmitBlock(Cont); 1355 return TrapBB; 1356} 1357 1358/// isSimpleArrayDecayOperand - If the specified expr is a simple decay from an 1359/// array to pointer, return the array subexpression. 1360static const Expr *isSimpleArrayDecayOperand(const Expr *E) { 1361 // If this isn't just an array->pointer decay, bail out. 1362 const CastExpr *CE = dyn_cast<CastExpr>(E); 1363 if (CE == 0 || CE->getCastKind() != CK_ArrayToPointerDecay) 1364 return 0; 1365 1366 // If this is a decay from variable width array, bail out. 1367 const Expr *SubExpr = CE->getSubExpr(); 1368 if (SubExpr->getType()->isVariableArrayType()) 1369 return 0; 1370 1371 return SubExpr; 1372} 1373 1374LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) { 1375 // The index must always be an integer, which is not an aggregate. Emit it. 1376 llvm::Value *Idx = EmitScalarExpr(E->getIdx()); 1377 QualType IdxTy = E->getIdx()->getType(); 1378 bool IdxSigned = IdxTy->isSignedIntegerType(); 1379 1380 // If the base is a vector type, then we are forming a vector element lvalue 1381 // with this subscript. 1382 if (E->getBase()->getType()->isVectorType()) { 1383 // Emit the vector as an lvalue to get its address. 1384 LValue LHS = EmitLValue(E->getBase()); 1385 assert(LHS.isSimple() && "Can only subscript lvalue vectors here!"); 1386 Idx = Builder.CreateIntCast(Idx, Int32Ty, IdxSigned, "vidx"); 1387 return LValue::MakeVectorElt(LHS.getAddress(), Idx, 1388 E->getBase()->getType().getCVRQualifiers()); 1389 } 1390 1391 // Extend or truncate the index type to 32 or 64-bits. 1392 if (!Idx->getType()->isIntegerTy(LLVMPointerWidth)) 1393 Idx = Builder.CreateIntCast(Idx, IntPtrTy, 1394 IdxSigned, "idxprom"); 1395 1396 // FIXME: As llvm implements the object size checking, this can come out. 1397 if (CatchUndefined) { 1398 if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E->getBase())){ 1399 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr())) { 1400 if (ICE->getCastKind() == CK_ArrayToPointerDecay) { 1401 if (const ConstantArrayType *CAT 1402 = getContext().getAsConstantArrayType(DRE->getType())) { 1403 llvm::APInt Size = CAT->getSize(); 1404 llvm::BasicBlock *Cont = createBasicBlock("cont"); 1405 Builder.CreateCondBr(Builder.CreateICmpULE(Idx, 1406 llvm::ConstantInt::get(Idx->getType(), Size)), 1407 Cont, getTrapBB()); 1408 EmitBlock(Cont); 1409 } 1410 } 1411 } 1412 } 1413 } 1414 1415 // We know that the pointer points to a type of the correct size, unless the 1416 // size is a VLA or Objective-C interface. 1417 llvm::Value *Address = 0; 1418 if (const VariableArrayType *VAT = 1419 getContext().getAsVariableArrayType(E->getType())) { 1420 llvm::Value *VLASize = GetVLASize(VAT); 1421 1422 Idx = Builder.CreateMul(Idx, VLASize); 1423 1424 // The base must be a pointer, which is not an aggregate. Emit it. 1425 llvm::Value *Base = EmitScalarExpr(E->getBase()); 1426 1427 Address = EmitCastToVoidPtr(Base); 1428 Address = Builder.CreateInBoundsGEP(Address, Idx, "arrayidx"); 1429 Address = Builder.CreateBitCast(Address, Base->getType()); 1430 } else if (const ObjCObjectType *OIT = E->getType()->getAs<ObjCObjectType>()){ 1431 // Indexing over an interface, as in "NSString *P; P[4];" 1432 llvm::Value *InterfaceSize = 1433 llvm::ConstantInt::get(Idx->getType(), 1434 getContext().getTypeSizeInChars(OIT).getQuantity()); 1435 1436 Idx = Builder.CreateMul(Idx, InterfaceSize); 1437 1438 // The base must be a pointer, which is not an aggregate. Emit it. 1439 llvm::Value *Base = EmitScalarExpr(E->getBase()); 1440 Address = EmitCastToVoidPtr(Base); 1441 Address = Builder.CreateGEP(Address, Idx, "arrayidx"); 1442 Address = Builder.CreateBitCast(Address, Base->getType()); 1443 } else if (const Expr *Array = isSimpleArrayDecayOperand(E->getBase())) { 1444 // If this is A[i] where A is an array, the frontend will have decayed the 1445 // base to be a ArrayToPointerDecay implicit cast. While correct, it is 1446 // inefficient at -O0 to emit a "gep A, 0, 0" when codegen'ing it, then a 1447 // "gep x, i" here. Emit one "gep A, 0, i". 1448 assert(Array->getType()->isArrayType() && 1449 "Array to pointer decay must have array source type!"); 1450 llvm::Value *ArrayPtr = EmitLValue(Array).getAddress(); 1451 llvm::Value *Zero = llvm::ConstantInt::get(Int32Ty, 0); 1452 llvm::Value *Args[] = { Zero, Idx }; 1453 1454 Address = Builder.CreateInBoundsGEP(ArrayPtr, Args, Args+2, "arrayidx"); 1455 } else { 1456 // The base must be a pointer, which is not an aggregate. Emit it. 1457 llvm::Value *Base = EmitScalarExpr(E->getBase()); 1458 Address = Builder.CreateInBoundsGEP(Base, Idx, "arrayidx"); 1459 } 1460 1461 QualType T = E->getBase()->getType()->getPointeeType(); 1462 assert(!T.isNull() && 1463 "CodeGenFunction::EmitArraySubscriptExpr(): Illegal base type"); 1464 1465 LValue LV = MakeAddrLValue(Address, T); 1466 LV.getQuals().setAddressSpace(E->getBase()->getType().getAddressSpace()); 1467 1468 if (getContext().getLangOptions().ObjC1 && 1469 getContext().getLangOptions().getGCMode() != LangOptions::NonGC) { 1470 LV.setNonGC(!E->isOBJCGCCandidate(getContext())); 1471 setObjCGCLValueClass(getContext(), E, LV); 1472 } 1473 return LV; 1474} 1475 1476static 1477llvm::Constant *GenerateConstantVector(llvm::LLVMContext &VMContext, 1478 llvm::SmallVector<unsigned, 4> &Elts) { 1479 llvm::SmallVector<llvm::Constant*, 4> CElts; 1480 1481 const llvm::Type *Int32Ty = llvm::Type::getInt32Ty(VMContext); 1482 for (unsigned i = 0, e = Elts.size(); i != e; ++i) 1483 CElts.push_back(llvm::ConstantInt::get(Int32Ty, Elts[i])); 1484 1485 return llvm::ConstantVector::get(&CElts[0], CElts.size()); 1486} 1487 1488LValue CodeGenFunction:: 1489EmitExtVectorElementExpr(const ExtVectorElementExpr *E) { 1490 // Emit the base vector as an l-value. 1491 LValue Base; 1492 1493 // ExtVectorElementExpr's base can either be a vector or pointer to vector. 1494 if (E->isArrow()) { 1495 // If it is a pointer to a vector, emit the address and form an lvalue with 1496 // it. 1497 llvm::Value *Ptr = EmitScalarExpr(E->getBase()); 1498 const PointerType *PT = E->getBase()->getType()->getAs<PointerType>(); 1499 Base = MakeAddrLValue(Ptr, PT->getPointeeType()); 1500 Base.getQuals().removeObjCGCAttr(); 1501 } else if (E->getBase()->isGLValue()) { 1502 // Otherwise, if the base is an lvalue ( as in the case of foo.x.x), 1503 // emit the base as an lvalue. 1504 assert(E->getBase()->getType()->isVectorType()); 1505 Base = EmitLValue(E->getBase()); 1506 } else { 1507 // Otherwise, the base is a normal rvalue (as in (V+V).x), emit it as such. 1508 assert(E->getBase()->getType()->getAs<VectorType>() && 1509 "Result must be a vector"); 1510 llvm::Value *Vec = EmitScalarExpr(E->getBase()); 1511 1512 // Store the vector to memory (because LValue wants an address). 1513 llvm::Value *VecMem = CreateMemTemp(E->getBase()->getType()); 1514 Builder.CreateStore(Vec, VecMem); 1515 Base = MakeAddrLValue(VecMem, E->getBase()->getType()); 1516 } 1517 1518 // Encode the element access list into a vector of unsigned indices. 1519 llvm::SmallVector<unsigned, 4> Indices; 1520 E->getEncodedElementAccess(Indices); 1521 1522 if (Base.isSimple()) { 1523 llvm::Constant *CV = GenerateConstantVector(getLLVMContext(), Indices); 1524 return LValue::MakeExtVectorElt(Base.getAddress(), CV, 1525 Base.getVRQualifiers()); 1526 } 1527 assert(Base.isExtVectorElt() && "Can only subscript lvalue vec elts here!"); 1528 1529 llvm::Constant *BaseElts = Base.getExtVectorElts(); 1530 llvm::SmallVector<llvm::Constant *, 4> CElts; 1531 1532 for (unsigned i = 0, e = Indices.size(); i != e; ++i) { 1533 if (isa<llvm::ConstantAggregateZero>(BaseElts)) 1534 CElts.push_back(llvm::ConstantInt::get(Int32Ty, 0)); 1535 else 1536 CElts.push_back(cast<llvm::Constant>(BaseElts->getOperand(Indices[i]))); 1537 } 1538 llvm::Constant *CV = llvm::ConstantVector::get(&CElts[0], CElts.size()); 1539 return LValue::MakeExtVectorElt(Base.getExtVectorAddr(), CV, 1540 Base.getVRQualifiers()); 1541} 1542 1543LValue CodeGenFunction::EmitMemberExpr(const MemberExpr *E) { 1544 bool isNonGC = false; 1545 Expr *BaseExpr = E->getBase(); 1546 llvm::Value *BaseValue = NULL; 1547 Qualifiers BaseQuals; 1548 1549 // If this is s.x, emit s as an lvalue. If it is s->x, emit s as a scalar. 1550 if (E->isArrow()) { 1551 BaseValue = EmitScalarExpr(BaseExpr); 1552 const PointerType *PTy = 1553 BaseExpr->getType()->getAs<PointerType>(); 1554 BaseQuals = PTy->getPointeeType().getQualifiers(); 1555 } else { 1556 LValue BaseLV = EmitLValue(BaseExpr); 1557 if (BaseLV.isNonGC()) 1558 isNonGC = true; 1559 // FIXME: this isn't right for bitfields. 1560 BaseValue = BaseLV.getAddress(); 1561 QualType BaseTy = BaseExpr->getType(); 1562 BaseQuals = BaseTy.getQualifiers(); 1563 } 1564 1565 NamedDecl *ND = E->getMemberDecl(); 1566 if (FieldDecl *Field = dyn_cast<FieldDecl>(ND)) { 1567 LValue LV = EmitLValueForField(BaseValue, Field, 1568 BaseQuals.getCVRQualifiers()); 1569 LV.setNonGC(isNonGC); 1570 setObjCGCLValueClass(getContext(), E, LV); 1571 return LV; 1572 } 1573 1574 if (VarDecl *VD = dyn_cast<VarDecl>(ND)) 1575 return EmitGlobalVarDeclLValue(*this, E, VD); 1576 1577 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) 1578 return EmitFunctionDeclLValue(*this, E, FD); 1579 1580 assert(false && "Unhandled member declaration!"); 1581 return LValue(); 1582} 1583 1584LValue CodeGenFunction::EmitLValueForBitfield(llvm::Value *BaseValue, 1585 const FieldDecl *Field, 1586 unsigned CVRQualifiers) { 1587 const CGRecordLayout &RL = 1588 CGM.getTypes().getCGRecordLayout(Field->getParent()); 1589 const CGBitFieldInfo &Info = RL.getBitFieldInfo(Field); 1590 return LValue::MakeBitfield(BaseValue, Info, 1591 Field->getType().getCVRQualifiers()|CVRQualifiers); 1592} 1593 1594/// EmitLValueForAnonRecordField - Given that the field is a member of 1595/// an anonymous struct or union buried inside a record, and given 1596/// that the base value is a pointer to the enclosing record, derive 1597/// an lvalue for the ultimate field. 1598LValue CodeGenFunction::EmitLValueForAnonRecordField(llvm::Value *BaseValue, 1599 const IndirectFieldDecl *Field, 1600 unsigned CVRQualifiers) { 1601 IndirectFieldDecl::chain_iterator I = Field->chain_begin(), 1602 IEnd = Field->chain_end(); 1603 while (true) { 1604 LValue LV = EmitLValueForField(BaseValue, cast<FieldDecl>(*I), CVRQualifiers); 1605 if (++I == IEnd) return LV; 1606 1607 assert(LV.isSimple()); 1608 BaseValue = LV.getAddress(); 1609 CVRQualifiers |= LV.getVRQualifiers(); 1610 } 1611} 1612 1613LValue CodeGenFunction::EmitLValueForField(llvm::Value *BaseValue, 1614 const FieldDecl *Field, 1615 unsigned CVRQualifiers) { 1616 if (Field->isBitField()) 1617 return EmitLValueForBitfield(BaseValue, Field, CVRQualifiers); 1618 1619 const CGRecordLayout &RL = 1620 CGM.getTypes().getCGRecordLayout(Field->getParent()); 1621 unsigned idx = RL.getLLVMFieldNo(Field); 1622 llvm::Value *V = Builder.CreateStructGEP(BaseValue, idx, "tmp"); 1623 1624 // Match union field type. 1625 if (Field->getParent()->isUnion()) { 1626 const llvm::Type *FieldTy = 1627 CGM.getTypes().ConvertTypeForMem(Field->getType()); 1628 const llvm::PointerType *BaseTy = 1629 cast<llvm::PointerType>(BaseValue->getType()); 1630 unsigned AS = BaseTy->getAddressSpace(); 1631 V = Builder.CreateBitCast(V, 1632 llvm::PointerType::get(FieldTy, AS), 1633 "tmp"); 1634 } 1635 if (Field->getType()->isReferenceType()) 1636 V = Builder.CreateLoad(V, "tmp"); 1637 1638 unsigned Alignment = getContext().getDeclAlign(Field).getQuantity(); 1639 LValue LV = MakeAddrLValue(V, Field->getType(), Alignment); 1640 LV.getQuals().addCVRQualifiers(CVRQualifiers); 1641 1642 // __weak attribute on a field is ignored. 1643 if (LV.getQuals().getObjCGCAttr() == Qualifiers::Weak) 1644 LV.getQuals().removeObjCGCAttr(); 1645 1646 return LV; 1647} 1648 1649LValue 1650CodeGenFunction::EmitLValueForFieldInitialization(llvm::Value *BaseValue, 1651 const FieldDecl *Field, 1652 unsigned CVRQualifiers) { 1653 QualType FieldType = Field->getType(); 1654 1655 if (!FieldType->isReferenceType()) 1656 return EmitLValueForField(BaseValue, Field, CVRQualifiers); 1657 1658 const CGRecordLayout &RL = 1659 CGM.getTypes().getCGRecordLayout(Field->getParent()); 1660 unsigned idx = RL.getLLVMFieldNo(Field); 1661 llvm::Value *V = Builder.CreateStructGEP(BaseValue, idx, "tmp"); 1662 1663 assert(!FieldType.getObjCGCAttr() && "fields cannot have GC attrs"); 1664 1665 unsigned Alignment = getContext().getDeclAlign(Field).getQuantity(); 1666 return MakeAddrLValue(V, FieldType, Alignment); 1667} 1668 1669LValue CodeGenFunction::EmitCompoundLiteralLValue(const CompoundLiteralExpr *E){ 1670 llvm::Value *DeclPtr = CreateMemTemp(E->getType(), ".compoundliteral"); 1671 const Expr *InitExpr = E->getInitializer(); 1672 LValue Result = MakeAddrLValue(DeclPtr, E->getType()); 1673 1674 EmitAnyExprToMem(InitExpr, DeclPtr, /*Volatile*/ false, /*Init*/ true); 1675 1676 return Result; 1677} 1678 1679LValue 1680CodeGenFunction::EmitConditionalOperatorLValue(const ConditionalOperator *E) { 1681 if (!E->isGLValue()) { 1682 // ?: here should be an aggregate. 1683 assert((hasAggregateLLVMType(E->getType()) && 1684 !E->getType()->isAnyComplexType()) && 1685 "Unexpected conditional operator!"); 1686 return EmitAggExprToLValue(E); 1687 } 1688 1689 if (int Cond = ConstantFoldsToSimpleInteger(E->getCond())) { 1690 Expr *Live = Cond == 1 ? E->getLHS() : E->getRHS(); 1691 if (Live) 1692 return EmitLValue(Live); 1693 } 1694 1695 llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true"); 1696 llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false"); 1697 llvm::BasicBlock *ContBlock = createBasicBlock("cond.end"); 1698 1699 ConditionalEvaluation eval(*this); 1700 1701 if (E->getLHS()) 1702 EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock); 1703 else { 1704 Expr *save = E->getSAVE(); 1705 assert(save && "VisitConditionalOperator - save is null"); 1706 // Intentianlly not doing direct assignment to ConditionalSaveExprs[save] 1707 LValue SaveVal = EmitLValue(save); 1708 ConditionalSaveLValueExprs[save] = SaveVal; 1709 EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock); 1710 } 1711 1712 // Any temporaries created here are conditional. 1713 EmitBlock(LHSBlock); 1714 eval.begin(*this); 1715 LValue LHS = EmitLValue(E->getTrueExpr()); 1716 eval.end(*this); 1717 1718 if (!LHS.isSimple()) 1719 return EmitUnsupportedLValue(E, "conditional operator"); 1720 1721 LHSBlock = Builder.GetInsertBlock(); 1722 Builder.CreateBr(ContBlock); 1723 1724 // Any temporaries created here are conditional. 1725 EmitBlock(RHSBlock); 1726 eval.begin(*this); 1727 LValue RHS = EmitLValue(E->getRHS()); 1728 eval.end(*this); 1729 if (!RHS.isSimple()) 1730 return EmitUnsupportedLValue(E, "conditional operator"); 1731 RHSBlock = Builder.GetInsertBlock(); 1732 1733 EmitBlock(ContBlock); 1734 1735 llvm::PHINode *phi = Builder.CreatePHI(LHS.getAddress()->getType(), 1736 "cond-lvalue"); 1737 phi->reserveOperandSpace(2); 1738 phi->addIncoming(LHS.getAddress(), LHSBlock); 1739 phi->addIncoming(RHS.getAddress(), RHSBlock); 1740 return MakeAddrLValue(phi, E->getType()); 1741} 1742 1743/// EmitCastLValue - Casts are never lvalues unless that cast is a dynamic_cast. 1744/// If the cast is a dynamic_cast, we can have the usual lvalue result, 1745/// otherwise if a cast is needed by the code generator in an lvalue context, 1746/// then it must mean that we need the address of an aggregate in order to 1747/// access one of its fields. This can happen for all the reasons that casts 1748/// are permitted with aggregate result, including noop aggregate casts, and 1749/// cast from scalar to union. 1750LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) { 1751 switch (E->getCastKind()) { 1752 case CK_ToVoid: 1753 return EmitUnsupportedLValue(E, "unexpected cast lvalue"); 1754 1755 case CK_Dependent: 1756 llvm_unreachable("dependent cast kind in IR gen!"); 1757 1758 case CK_GetObjCProperty: { 1759 LValue LV = EmitLValue(E->getSubExpr()); 1760 assert(LV.isPropertyRef()); 1761 RValue RV = EmitLoadOfPropertyRefLValue(LV); 1762 1763 // Property is an aggregate r-value. 1764 if (RV.isAggregate()) { 1765 return MakeAddrLValue(RV.getAggregateAddr(), E->getType()); 1766 } 1767 1768 // Implicit property returns an l-value. 1769 assert(RV.isScalar()); 1770 return MakeAddrLValue(RV.getScalarVal(), E->getSubExpr()->getType()); 1771 } 1772 1773 case CK_NoOp: 1774 case CK_LValueToRValue: 1775 if (!E->getSubExpr()->Classify(getContext()).isPRValue() 1776 || E->getType()->isRecordType()) 1777 return EmitLValue(E->getSubExpr()); 1778 // Fall through to synthesize a temporary. 1779 1780 case CK_BitCast: 1781 case CK_ArrayToPointerDecay: 1782 case CK_FunctionToPointerDecay: 1783 case CK_NullToMemberPointer: 1784 case CK_NullToPointer: 1785 case CK_IntegralToPointer: 1786 case CK_PointerToIntegral: 1787 case CK_PointerToBoolean: 1788 case CK_VectorSplat: 1789 case CK_IntegralCast: 1790 case CK_IntegralToBoolean: 1791 case CK_IntegralToFloating: 1792 case CK_FloatingToIntegral: 1793 case CK_FloatingToBoolean: 1794 case CK_FloatingCast: 1795 case CK_FloatingRealToComplex: 1796 case CK_FloatingComplexToReal: 1797 case CK_FloatingComplexToBoolean: 1798 case CK_FloatingComplexCast: 1799 case CK_FloatingComplexToIntegralComplex: 1800 case CK_IntegralRealToComplex: 1801 case CK_IntegralComplexToReal: 1802 case CK_IntegralComplexToBoolean: 1803 case CK_IntegralComplexCast: 1804 case CK_IntegralComplexToFloatingComplex: 1805 case CK_DerivedToBaseMemberPointer: 1806 case CK_BaseToDerivedMemberPointer: 1807 case CK_MemberPointerToBoolean: 1808 case CK_AnyPointerToBlockPointerCast: { 1809 // These casts only produce lvalues when we're binding a reference to a 1810 // temporary realized from a (converted) pure rvalue. Emit the expression 1811 // as a value, copy it into a temporary, and return an lvalue referring to 1812 // that temporary. 1813 llvm::Value *V = CreateMemTemp(E->getType(), "ref.temp"); 1814 EmitAnyExprToMem(E, V, false, false); 1815 return MakeAddrLValue(V, E->getType()); 1816 } 1817 1818 case CK_Dynamic: { 1819 LValue LV = EmitLValue(E->getSubExpr()); 1820 llvm::Value *V = LV.getAddress(); 1821 const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(E); 1822 return MakeAddrLValue(EmitDynamicCast(V, DCE), E->getType()); 1823 } 1824 1825 case CK_ConstructorConversion: 1826 case CK_UserDefinedConversion: 1827 case CK_AnyPointerToObjCPointerCast: 1828 return EmitLValue(E->getSubExpr()); 1829 1830 case CK_UncheckedDerivedToBase: 1831 case CK_DerivedToBase: { 1832 const RecordType *DerivedClassTy = 1833 E->getSubExpr()->getType()->getAs<RecordType>(); 1834 CXXRecordDecl *DerivedClassDecl = 1835 cast<CXXRecordDecl>(DerivedClassTy->getDecl()); 1836 1837 LValue LV = EmitLValue(E->getSubExpr()); 1838 llvm::Value *This = LV.getAddress(); 1839 1840 // Perform the derived-to-base conversion 1841 llvm::Value *Base = 1842 GetAddressOfBaseClass(This, DerivedClassDecl, 1843 E->path_begin(), E->path_end(), 1844 /*NullCheckValue=*/false); 1845 1846 return MakeAddrLValue(Base, E->getType()); 1847 } 1848 case CK_ToUnion: 1849 return EmitAggExprToLValue(E); 1850 case CK_BaseToDerived: { 1851 const RecordType *DerivedClassTy = E->getType()->getAs<RecordType>(); 1852 CXXRecordDecl *DerivedClassDecl = 1853 cast<CXXRecordDecl>(DerivedClassTy->getDecl()); 1854 1855 LValue LV = EmitLValue(E->getSubExpr()); 1856 1857 // Perform the base-to-derived conversion 1858 llvm::Value *Derived = 1859 GetAddressOfDerivedClass(LV.getAddress(), DerivedClassDecl, 1860 E->path_begin(), E->path_end(), 1861 /*NullCheckValue=*/false); 1862 1863 return MakeAddrLValue(Derived, E->getType()); 1864 } 1865 case CK_LValueBitCast: { 1866 // This must be a reinterpret_cast (or c-style equivalent). 1867 const ExplicitCastExpr *CE = cast<ExplicitCastExpr>(E); 1868 1869 LValue LV = EmitLValue(E->getSubExpr()); 1870 llvm::Value *V = Builder.CreateBitCast(LV.getAddress(), 1871 ConvertType(CE->getTypeAsWritten())); 1872 return MakeAddrLValue(V, E->getType()); 1873 } 1874 case CK_ObjCObjectLValueCast: { 1875 LValue LV = EmitLValue(E->getSubExpr()); 1876 QualType ToType = getContext().getLValueReferenceType(E->getType()); 1877 llvm::Value *V = Builder.CreateBitCast(LV.getAddress(), 1878 ConvertType(ToType)); 1879 return MakeAddrLValue(V, E->getType()); 1880 } 1881 } 1882 1883 llvm_unreachable("Unhandled lvalue cast kind?"); 1884} 1885 1886LValue CodeGenFunction::EmitNullInitializationLValue( 1887 const CXXScalarValueInitExpr *E) { 1888 QualType Ty = E->getType(); 1889 LValue LV = MakeAddrLValue(CreateMemTemp(Ty), Ty); 1890 EmitNullInitialization(LV.getAddress(), Ty); 1891 return LV; 1892} 1893 1894//===--------------------------------------------------------------------===// 1895// Expression Emission 1896//===--------------------------------------------------------------------===// 1897 1898 1899RValue CodeGenFunction::EmitCallExpr(const CallExpr *E, 1900 ReturnValueSlot ReturnValue) { 1901 // Builtins never have block type. 1902 if (E->getCallee()->getType()->isBlockPointerType()) 1903 return EmitBlockCallExpr(E, ReturnValue); 1904 1905 if (const CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(E)) 1906 return EmitCXXMemberCallExpr(CE, ReturnValue); 1907 1908 const Decl *TargetDecl = 0; 1909 if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E->getCallee())) { 1910 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CE->getSubExpr())) { 1911 TargetDecl = DRE->getDecl(); 1912 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(TargetDecl)) 1913 if (unsigned builtinID = FD->getBuiltinID()) 1914 return EmitBuiltinExpr(FD, builtinID, E); 1915 } 1916 } 1917 1918 if (const CXXOperatorCallExpr *CE = dyn_cast<CXXOperatorCallExpr>(E)) 1919 if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(TargetDecl)) 1920 return EmitCXXOperatorMemberCallExpr(CE, MD, ReturnValue); 1921 1922 if (isa<CXXPseudoDestructorExpr>(E->getCallee()->IgnoreParens())) { 1923 // C++ [expr.pseudo]p1: 1924 // The result shall only be used as the operand for the function call 1925 // operator (), and the result of such a call has type void. The only 1926 // effect is the evaluation of the postfix-expression before the dot or 1927 // arrow. 1928 EmitScalarExpr(E->getCallee()); 1929 return RValue::get(0); 1930 } 1931 1932 llvm::Value *Callee = EmitScalarExpr(E->getCallee()); 1933 return EmitCall(E->getCallee()->getType(), Callee, ReturnValue, 1934 E->arg_begin(), E->arg_end(), TargetDecl); 1935} 1936 1937LValue CodeGenFunction::EmitBinaryOperatorLValue(const BinaryOperator *E) { 1938 // Comma expressions just emit their LHS then their RHS as an l-value. 1939 if (E->getOpcode() == BO_Comma) { 1940 EmitIgnoredExpr(E->getLHS()); 1941 EnsureInsertPoint(); 1942 return EmitLValue(E->getRHS()); 1943 } 1944 1945 if (E->getOpcode() == BO_PtrMemD || 1946 E->getOpcode() == BO_PtrMemI) 1947 return EmitPointerToDataMemberBinaryExpr(E); 1948 1949 assert(E->getOpcode() == BO_Assign && "unexpected binary l-value"); 1950 1951 if (!hasAggregateLLVMType(E->getType())) { 1952 // __block variables need the RHS evaluated first. 1953 RValue RV = EmitAnyExpr(E->getRHS()); 1954 LValue LV = EmitLValue(E->getLHS()); 1955 EmitStoreThroughLValue(RV, LV, E->getType()); 1956 return LV; 1957 } 1958 1959 if (E->getType()->isAnyComplexType()) 1960 return EmitComplexAssignmentLValue(E); 1961 1962 return EmitAggExprToLValue(E); 1963} 1964 1965LValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) { 1966 RValue RV = EmitCallExpr(E); 1967 1968 if (!RV.isScalar()) 1969 return MakeAddrLValue(RV.getAggregateAddr(), E->getType()); 1970 1971 assert(E->getCallReturnType()->isReferenceType() && 1972 "Can't have a scalar return unless the return type is a " 1973 "reference type!"); 1974 1975 return MakeAddrLValue(RV.getScalarVal(), E->getType()); 1976} 1977 1978LValue CodeGenFunction::EmitVAArgExprLValue(const VAArgExpr *E) { 1979 // FIXME: This shouldn't require another copy. 1980 return EmitAggExprToLValue(E); 1981} 1982 1983LValue CodeGenFunction::EmitCXXConstructLValue(const CXXConstructExpr *E) { 1984 assert(E->getType()->getAsCXXRecordDecl()->hasTrivialDestructor() 1985 && "binding l-value to type which needs a temporary"); 1986 AggValueSlot Slot = CreateAggTemp(E->getType(), "tmp"); 1987 EmitCXXConstructExpr(E, Slot); 1988 return MakeAddrLValue(Slot.getAddr(), E->getType()); 1989} 1990 1991LValue 1992CodeGenFunction::EmitCXXTypeidLValue(const CXXTypeidExpr *E) { 1993 return MakeAddrLValue(EmitCXXTypeidExpr(E), E->getType()); 1994} 1995 1996LValue 1997CodeGenFunction::EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E) { 1998 AggValueSlot Slot = CreateAggTemp(E->getType(), "temp.lvalue"); 1999 Slot.setLifetimeExternallyManaged(); 2000 EmitAggExpr(E->getSubExpr(), Slot); 2001 EmitCXXTemporary(E->getTemporary(), Slot.getAddr()); 2002 return MakeAddrLValue(Slot.getAddr(), E->getType()); 2003} 2004 2005LValue CodeGenFunction::EmitObjCMessageExprLValue(const ObjCMessageExpr *E) { 2006 RValue RV = EmitObjCMessageExpr(E); 2007 2008 if (!RV.isScalar()) 2009 return MakeAddrLValue(RV.getAggregateAddr(), E->getType()); 2010 2011 assert(E->getMethodDecl()->getResultType()->isReferenceType() && 2012 "Can't have a scalar return unless the return type is a " 2013 "reference type!"); 2014 2015 return MakeAddrLValue(RV.getScalarVal(), E->getType()); 2016} 2017 2018LValue CodeGenFunction::EmitObjCSelectorLValue(const ObjCSelectorExpr *E) { 2019 llvm::Value *V = 2020 CGM.getObjCRuntime().GetSelector(Builder, E->getSelector(), true); 2021 return MakeAddrLValue(V, E->getType()); 2022} 2023 2024llvm::Value *CodeGenFunction::EmitIvarOffset(const ObjCInterfaceDecl *Interface, 2025 const ObjCIvarDecl *Ivar) { 2026 return CGM.getObjCRuntime().EmitIvarOffset(*this, Interface, Ivar); 2027} 2028 2029LValue CodeGenFunction::EmitLValueForIvar(QualType ObjectTy, 2030 llvm::Value *BaseValue, 2031 const ObjCIvarDecl *Ivar, 2032 unsigned CVRQualifiers) { 2033 return CGM.getObjCRuntime().EmitObjCValueForIvar(*this, ObjectTy, BaseValue, 2034 Ivar, CVRQualifiers); 2035} 2036 2037LValue CodeGenFunction::EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E) { 2038 // FIXME: A lot of the code below could be shared with EmitMemberExpr. 2039 llvm::Value *BaseValue = 0; 2040 const Expr *BaseExpr = E->getBase(); 2041 Qualifiers BaseQuals; 2042 QualType ObjectTy; 2043 if (E->isArrow()) { 2044 BaseValue = EmitScalarExpr(BaseExpr); 2045 ObjectTy = BaseExpr->getType()->getPointeeType(); 2046 BaseQuals = ObjectTy.getQualifiers(); 2047 } else { 2048 LValue BaseLV = EmitLValue(BaseExpr); 2049 // FIXME: this isn't right for bitfields. 2050 BaseValue = BaseLV.getAddress(); 2051 ObjectTy = BaseExpr->getType(); 2052 BaseQuals = ObjectTy.getQualifiers(); 2053 } 2054 2055 LValue LV = 2056 EmitLValueForIvar(ObjectTy, BaseValue, E->getDecl(), 2057 BaseQuals.getCVRQualifiers()); 2058 setObjCGCLValueClass(getContext(), E, LV); 2059 return LV; 2060} 2061 2062LValue CodeGenFunction::EmitStmtExprLValue(const StmtExpr *E) { 2063 // Can only get l-value for message expression returning aggregate type 2064 RValue RV = EmitAnyExprToTemp(E); 2065 return MakeAddrLValue(RV.getAggregateAddr(), E->getType()); 2066} 2067 2068RValue CodeGenFunction::EmitCall(QualType CalleeType, llvm::Value *Callee, 2069 ReturnValueSlot ReturnValue, 2070 CallExpr::const_arg_iterator ArgBeg, 2071 CallExpr::const_arg_iterator ArgEnd, 2072 const Decl *TargetDecl) { 2073 // Get the actual function type. The callee type will always be a pointer to 2074 // function type or a block pointer type. 2075 assert(CalleeType->isFunctionPointerType() && 2076 "Call must have function pointer type!"); 2077 2078 CalleeType = getContext().getCanonicalType(CalleeType); 2079 2080 const FunctionType *FnType 2081 = cast<FunctionType>(cast<PointerType>(CalleeType)->getPointeeType()); 2082 2083 CallArgList Args; 2084 EmitCallArgs(Args, dyn_cast<FunctionProtoType>(FnType), ArgBeg, ArgEnd); 2085 2086 return EmitCall(CGM.getTypes().getFunctionInfo(Args, FnType), 2087 Callee, ReturnValue, Args, TargetDecl); 2088} 2089 2090LValue CodeGenFunction:: 2091EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E) { 2092 llvm::Value *BaseV; 2093 if (E->getOpcode() == BO_PtrMemI) 2094 BaseV = EmitScalarExpr(E->getLHS()); 2095 else 2096 BaseV = EmitLValue(E->getLHS()).getAddress(); 2097 2098 llvm::Value *OffsetV = EmitScalarExpr(E->getRHS()); 2099 2100 const MemberPointerType *MPT 2101 = E->getRHS()->getType()->getAs<MemberPointerType>(); 2102 2103 llvm::Value *AddV = 2104 CGM.getCXXABI().EmitMemberDataPointerAddress(*this, BaseV, OffsetV, MPT); 2105 2106 return MakeAddrLValue(AddV, MPT->getPointeeType()); 2107} 2108