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