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