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