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