CGExpr.cpp revision 402a6d5613b3df364ba252416d5a022dee95f0ba
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 "TargetInfo.h" 22#include "clang/AST/ASTContext.h" 23#include "clang/AST/DeclObjC.h" 24#include "clang/Basic/ConvertUTF.h" 25#include "clang/Frontend/CodeGenOptions.h" 26#include "llvm/Intrinsics.h" 27#include "llvm/LLVMContext.h" 28#include "llvm/Support/MDBuilder.h" 29#include "llvm/Target/TargetData.h" 30using namespace clang; 31using namespace CodeGen; 32 33//===--------------------------------------------------------------------===// 34// Miscellaneous Helper Methods 35//===--------------------------------------------------------------------===// 36 37llvm::Value *CodeGenFunction::EmitCastToVoidPtr(llvm::Value *value) { 38 unsigned addressSpace = 39 cast<llvm::PointerType>(value->getType())->getAddressSpace(); 40 41 llvm::PointerType *destType = Int8PtrTy; 42 if (addressSpace) 43 destType = llvm::Type::getInt8PtrTy(getLLVMContext(), addressSpace); 44 45 if (value->getType() == destType) return value; 46 return Builder.CreateBitCast(value, destType); 47} 48 49/// CreateTempAlloca - This creates a alloca and inserts it into the entry 50/// block. 51llvm::AllocaInst *CodeGenFunction::CreateTempAlloca(llvm::Type *Ty, 52 const Twine &Name) { 53 if (!Builder.isNamePreserving()) 54 return new llvm::AllocaInst(Ty, 0, "", AllocaInsertPt); 55 return new llvm::AllocaInst(Ty, 0, Name, AllocaInsertPt); 56} 57 58void CodeGenFunction::InitTempAlloca(llvm::AllocaInst *Var, 59 llvm::Value *Init) { 60 llvm::StoreInst *Store = new llvm::StoreInst(Init, Var); 61 llvm::BasicBlock *Block = AllocaInsertPt->getParent(); 62 Block->getInstList().insertAfter(&*AllocaInsertPt, Store); 63} 64 65llvm::AllocaInst *CodeGenFunction::CreateIRTemp(QualType Ty, 66 const Twine &Name) { 67 llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertType(Ty), Name); 68 // FIXME: Should we prefer the preferred type alignment here? 69 CharUnits Align = getContext().getTypeAlignInChars(Ty); 70 Alloc->setAlignment(Align.getQuantity()); 71 return Alloc; 72} 73 74llvm::AllocaInst *CodeGenFunction::CreateMemTemp(QualType Ty, 75 const Twine &Name) { 76 llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertTypeForMem(Ty), Name); 77 // FIXME: Should we prefer the preferred type alignment here? 78 CharUnits Align = getContext().getTypeAlignInChars(Ty); 79 Alloc->setAlignment(Align.getQuantity()); 80 return Alloc; 81} 82 83/// EvaluateExprAsBool - Perform the usual unary conversions on the specified 84/// expression and compare the result against zero, returning an Int1Ty value. 85llvm::Value *CodeGenFunction::EvaluateExprAsBool(const Expr *E) { 86 if (const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>()) { 87 llvm::Value *MemPtr = EmitScalarExpr(E); 88 return CGM.getCXXABI().EmitMemberPointerIsNotNull(*this, MemPtr, MPT); 89 } 90 91 QualType BoolTy = getContext().BoolTy; 92 if (!E->getType()->isAnyComplexType()) 93 return EmitScalarConversion(EmitScalarExpr(E), E->getType(), BoolTy); 94 95 return EmitComplexToScalarConversion(EmitComplexExpr(E), E->getType(),BoolTy); 96} 97 98/// EmitIgnoredExpr - Emit code to compute the specified expression, 99/// ignoring the result. 100void CodeGenFunction::EmitIgnoredExpr(const Expr *E) { 101 if (E->isRValue()) 102 return (void) EmitAnyExpr(E, AggValueSlot::ignored(), true); 103 104 // Just emit it as an l-value and drop the result. 105 EmitLValue(E); 106} 107 108/// EmitAnyExpr - Emit code to compute the specified expression which 109/// can have any type. The result is returned as an RValue struct. 110/// If this is an aggregate expression, AggSlot indicates where the 111/// result should be returned. 112RValue CodeGenFunction::EmitAnyExpr(const Expr *E, 113 AggValueSlot aggSlot, 114 bool ignoreResult) { 115 if (!hasAggregateLLVMType(E->getType())) 116 return RValue::get(EmitScalarExpr(E, ignoreResult)); 117 else if (E->getType()->isAnyComplexType()) 118 return RValue::getComplex(EmitComplexExpr(E, ignoreResult, ignoreResult)); 119 120 if (!ignoreResult && aggSlot.isIgnored()) 121 aggSlot = CreateAggTemp(E->getType(), "agg-temp"); 122 EmitAggExpr(E, aggSlot); 123 return aggSlot.asRValue(); 124} 125 126/// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result will 127/// always be accessible even if no aggregate location is provided. 128RValue CodeGenFunction::EmitAnyExprToTemp(const Expr *E) { 129 AggValueSlot AggSlot = AggValueSlot::ignored(); 130 131 if (hasAggregateLLVMType(E->getType()) && 132 !E->getType()->isAnyComplexType()) 133 AggSlot = CreateAggTemp(E->getType(), "agg.tmp"); 134 return EmitAnyExpr(E, AggSlot); 135} 136 137/// EmitAnyExprToMem - Evaluate an expression into a given memory 138/// location. 139void CodeGenFunction::EmitAnyExprToMem(const Expr *E, 140 llvm::Value *Location, 141 Qualifiers Quals, 142 bool IsInit) { 143 // FIXME: This function should take an LValue as an argument. 144 if (E->getType()->isAnyComplexType()) { 145 EmitComplexExprIntoAddr(E, Location, Quals.hasVolatile()); 146 } else if (hasAggregateLLVMType(E->getType())) { 147 CharUnits Alignment = getContext().getTypeAlignInChars(E->getType()); 148 EmitAggExpr(E, AggValueSlot::forAddr(Location, Alignment, Quals, 149 AggValueSlot::IsDestructed_t(IsInit), 150 AggValueSlot::DoesNotNeedGCBarriers, 151 AggValueSlot::IsAliased_t(!IsInit))); 152 } else { 153 RValue RV = RValue::get(EmitScalarExpr(E, /*Ignore*/ false)); 154 LValue LV = MakeAddrLValue(Location, E->getType()); 155 EmitStoreThroughLValue(RV, LV); 156 } 157} 158 159namespace { 160/// \brief An adjustment to be made to the temporary created when emitting a 161/// reference binding, which accesses a particular subobject of that temporary. 162 struct SubobjectAdjustment { 163 enum { 164 DerivedToBaseAdjustment, 165 FieldAdjustment, 166 MemberPointerAdjustment 167 } Kind; 168 169 union { 170 struct { 171 const CastExpr *BasePath; 172 const CXXRecordDecl *DerivedClass; 173 } DerivedToBase; 174 175 FieldDecl *Field; 176 177 struct { 178 const MemberPointerType *MPT; 179 llvm::Value *Ptr; 180 } Ptr; 181 }; 182 183 SubobjectAdjustment(const CastExpr *BasePath, 184 const CXXRecordDecl *DerivedClass) 185 : Kind(DerivedToBaseAdjustment) { 186 DerivedToBase.BasePath = BasePath; 187 DerivedToBase.DerivedClass = DerivedClass; 188 } 189 190 SubobjectAdjustment(FieldDecl *Field) 191 : Kind(FieldAdjustment) { 192 this->Field = Field; 193 } 194 195 SubobjectAdjustment(const MemberPointerType *MPT, llvm::Value *Ptr) 196 : Kind(MemberPointerAdjustment) { 197 this->Ptr.MPT = MPT; 198 this->Ptr.Ptr = Ptr; 199 } 200 }; 201} 202 203static llvm::Value * 204CreateReferenceTemporary(CodeGenFunction &CGF, QualType Type, 205 const NamedDecl *InitializedDecl) { 206 if (const VarDecl *VD = dyn_cast_or_null<VarDecl>(InitializedDecl)) { 207 if (VD->hasGlobalStorage()) { 208 SmallString<256> Name; 209 llvm::raw_svector_ostream Out(Name); 210 CGF.CGM.getCXXABI().getMangleContext().mangleReferenceTemporary(VD, Out); 211 Out.flush(); 212 213 llvm::Type *RefTempTy = CGF.ConvertTypeForMem(Type); 214 215 // Create the reference temporary. 216 llvm::GlobalValue *RefTemp = 217 new llvm::GlobalVariable(CGF.CGM.getModule(), 218 RefTempTy, /*isConstant=*/false, 219 llvm::GlobalValue::InternalLinkage, 220 llvm::Constant::getNullValue(RefTempTy), 221 Name.str()); 222 return RefTemp; 223 } 224 } 225 226 return CGF.CreateMemTemp(Type, "ref.tmp"); 227} 228 229static llvm::Value * 230EmitExprForReferenceBinding(CodeGenFunction &CGF, const Expr *E, 231 llvm::Value *&ReferenceTemporary, 232 const CXXDestructorDecl *&ReferenceTemporaryDtor, 233 QualType &ObjCARCReferenceLifetimeType, 234 const NamedDecl *InitializedDecl) { 235 // Look through single-element init lists that claim to be lvalues. They're 236 // just syntactic wrappers in this case. 237 if (const InitListExpr *ILE = dyn_cast<InitListExpr>(E)) { 238 if (ILE->getNumInits() == 1 && ILE->isGLValue()) 239 E = ILE->getInit(0); 240 } 241 242 // Look through expressions for materialized temporaries (for now). 243 if (const MaterializeTemporaryExpr *M 244 = dyn_cast<MaterializeTemporaryExpr>(E)) { 245 // Objective-C++ ARC: 246 // If we are binding a reference to a temporary that has ownership, we 247 // need to perform retain/release operations on the temporary. 248 if (CGF.getContext().getLangOpts().ObjCAutoRefCount && 249 E->getType()->isObjCLifetimeType() && 250 (E->getType().getObjCLifetime() == Qualifiers::OCL_Strong || 251 E->getType().getObjCLifetime() == Qualifiers::OCL_Weak || 252 E->getType().getObjCLifetime() == Qualifiers::OCL_Autoreleasing)) 253 ObjCARCReferenceLifetimeType = E->getType(); 254 255 E = M->GetTemporaryExpr(); 256 } 257 258 if (const CXXDefaultArgExpr *DAE = dyn_cast<CXXDefaultArgExpr>(E)) 259 E = DAE->getExpr(); 260 261 if (const ExprWithCleanups *EWC = dyn_cast<ExprWithCleanups>(E)) { 262 CGF.enterFullExpression(EWC); 263 CodeGenFunction::RunCleanupsScope Scope(CGF); 264 265 return EmitExprForReferenceBinding(CGF, EWC->getSubExpr(), 266 ReferenceTemporary, 267 ReferenceTemporaryDtor, 268 ObjCARCReferenceLifetimeType, 269 InitializedDecl); 270 } 271 272 RValue RV; 273 if (E->isGLValue()) { 274 // Emit the expression as an lvalue. 275 LValue LV = CGF.EmitLValue(E); 276 277 if (LV.isSimple()) 278 return LV.getAddress(); 279 280 // We have to load the lvalue. 281 RV = CGF.EmitLoadOfLValue(LV); 282 } else { 283 if (!ObjCARCReferenceLifetimeType.isNull()) { 284 ReferenceTemporary = CreateReferenceTemporary(CGF, 285 ObjCARCReferenceLifetimeType, 286 InitializedDecl); 287 288 289 LValue RefTempDst = CGF.MakeAddrLValue(ReferenceTemporary, 290 ObjCARCReferenceLifetimeType); 291 292 CGF.EmitScalarInit(E, dyn_cast_or_null<ValueDecl>(InitializedDecl), 293 RefTempDst, false); 294 295 bool ExtendsLifeOfTemporary = false; 296 if (const VarDecl *Var = dyn_cast_or_null<VarDecl>(InitializedDecl)) { 297 if (Var->extendsLifetimeOfTemporary()) 298 ExtendsLifeOfTemporary = true; 299 } else if (InitializedDecl && isa<FieldDecl>(InitializedDecl)) { 300 ExtendsLifeOfTemporary = true; 301 } 302 303 if (!ExtendsLifeOfTemporary) { 304 // Since the lifetime of this temporary isn't going to be extended, 305 // we need to clean it up ourselves at the end of the full expression. 306 switch (ObjCARCReferenceLifetimeType.getObjCLifetime()) { 307 case Qualifiers::OCL_None: 308 case Qualifiers::OCL_ExplicitNone: 309 case Qualifiers::OCL_Autoreleasing: 310 break; 311 312 case Qualifiers::OCL_Strong: { 313 assert(!ObjCARCReferenceLifetimeType->isArrayType()); 314 CleanupKind cleanupKind = CGF.getARCCleanupKind(); 315 CGF.pushDestroy(cleanupKind, 316 ReferenceTemporary, 317 ObjCARCReferenceLifetimeType, 318 CodeGenFunction::destroyARCStrongImprecise, 319 cleanupKind & EHCleanup); 320 break; 321 } 322 323 case Qualifiers::OCL_Weak: 324 assert(!ObjCARCReferenceLifetimeType->isArrayType()); 325 CGF.pushDestroy(NormalAndEHCleanup, 326 ReferenceTemporary, 327 ObjCARCReferenceLifetimeType, 328 CodeGenFunction::destroyARCWeak, 329 /*useEHCleanupForArray*/ true); 330 break; 331 } 332 333 ObjCARCReferenceLifetimeType = QualType(); 334 } 335 336 return ReferenceTemporary; 337 } 338 339 SmallVector<SubobjectAdjustment, 2> Adjustments; 340 while (true) { 341 E = E->IgnoreParens(); 342 343 if (const CastExpr *CE = dyn_cast<CastExpr>(E)) { 344 if ((CE->getCastKind() == CK_DerivedToBase || 345 CE->getCastKind() == CK_UncheckedDerivedToBase) && 346 E->getType()->isRecordType()) { 347 E = CE->getSubExpr(); 348 CXXRecordDecl *Derived 349 = cast<CXXRecordDecl>(E->getType()->getAs<RecordType>()->getDecl()); 350 Adjustments.push_back(SubobjectAdjustment(CE, Derived)); 351 continue; 352 } 353 354 if (CE->getCastKind() == CK_NoOp) { 355 E = CE->getSubExpr(); 356 continue; 357 } 358 } else if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) { 359 if (!ME->isArrow() && ME->getBase()->isRValue()) { 360 assert(ME->getBase()->getType()->isRecordType()); 361 if (FieldDecl *Field = dyn_cast<FieldDecl>(ME->getMemberDecl())) { 362 E = ME->getBase(); 363 Adjustments.push_back(SubobjectAdjustment(Field)); 364 continue; 365 } 366 } 367 } else if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) { 368 if (BO->isPtrMemOp()) { 369 assert(BO->getLHS()->isRValue()); 370 E = BO->getLHS(); 371 const MemberPointerType *MPT = 372 BO->getRHS()->getType()->getAs<MemberPointerType>(); 373 llvm::Value *Ptr = CGF.EmitScalarExpr(BO->getRHS()); 374 Adjustments.push_back(SubobjectAdjustment(MPT, Ptr)); 375 } 376 } 377 378 if (const OpaqueValueExpr *opaque = dyn_cast<OpaqueValueExpr>(E)) 379 if (opaque->getType()->isRecordType()) 380 return CGF.EmitOpaqueValueLValue(opaque).getAddress(); 381 382 // Nothing changed. 383 break; 384 } 385 386 // Create a reference temporary if necessary. 387 AggValueSlot AggSlot = AggValueSlot::ignored(); 388 if (CGF.hasAggregateLLVMType(E->getType()) && 389 !E->getType()->isAnyComplexType()) { 390 ReferenceTemporary = CreateReferenceTemporary(CGF, E->getType(), 391 InitializedDecl); 392 CharUnits Alignment = CGF.getContext().getTypeAlignInChars(E->getType()); 393 AggValueSlot::IsDestructed_t isDestructed 394 = AggValueSlot::IsDestructed_t(InitializedDecl != 0); 395 AggSlot = AggValueSlot::forAddr(ReferenceTemporary, Alignment, 396 Qualifiers(), isDestructed, 397 AggValueSlot::DoesNotNeedGCBarriers, 398 AggValueSlot::IsNotAliased); 399 } 400 401 if (InitializedDecl) { 402 // Get the destructor for the reference temporary. 403 if (const RecordType *RT = E->getType()->getAs<RecordType>()) { 404 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(RT->getDecl()); 405 if (!ClassDecl->hasTrivialDestructor()) 406 ReferenceTemporaryDtor = ClassDecl->getDestructor(); 407 } 408 } 409 410 RV = CGF.EmitAnyExpr(E, AggSlot); 411 412 // Check if need to perform derived-to-base casts and/or field accesses, to 413 // get from the temporary object we created (and, potentially, for which we 414 // extended the lifetime) to the subobject we're binding the reference to. 415 if (!Adjustments.empty()) { 416 llvm::Value *Object = RV.getAggregateAddr(); 417 for (unsigned I = Adjustments.size(); I != 0; --I) { 418 SubobjectAdjustment &Adjustment = Adjustments[I-1]; 419 switch (Adjustment.Kind) { 420 case SubobjectAdjustment::DerivedToBaseAdjustment: 421 Object = 422 CGF.GetAddressOfBaseClass(Object, 423 Adjustment.DerivedToBase.DerivedClass, 424 Adjustment.DerivedToBase.BasePath->path_begin(), 425 Adjustment.DerivedToBase.BasePath->path_end(), 426 /*NullCheckValue=*/false); 427 break; 428 429 case SubobjectAdjustment::FieldAdjustment: { 430 LValue LV = CGF.MakeAddrLValue(Object, E->getType()); 431 LV = CGF.EmitLValueForField(LV, Adjustment.Field); 432 if (LV.isSimple()) { 433 Object = LV.getAddress(); 434 break; 435 } 436 437 // For non-simple lvalues, we actually have to create a copy of 438 // the object we're binding to. 439 QualType T = Adjustment.Field->getType().getNonReferenceType() 440 .getUnqualifiedType(); 441 Object = CreateReferenceTemporary(CGF, T, InitializedDecl); 442 LValue TempLV = CGF.MakeAddrLValue(Object, 443 Adjustment.Field->getType()); 444 CGF.EmitStoreThroughLValue(CGF.EmitLoadOfLValue(LV), TempLV); 445 break; 446 } 447 448 case SubobjectAdjustment::MemberPointerAdjustment: { 449 Object = CGF.CGM.getCXXABI().EmitMemberDataPointerAddress( 450 CGF, Object, Adjustment.Ptr.Ptr, Adjustment.Ptr.MPT); 451 break; 452 } 453 } 454 } 455 456 return Object; 457 } 458 } 459 460 if (RV.isAggregate()) 461 return RV.getAggregateAddr(); 462 463 // Create a temporary variable that we can bind the reference to. 464 ReferenceTemporary = CreateReferenceTemporary(CGF, E->getType(), 465 InitializedDecl); 466 467 468 unsigned Alignment = 469 CGF.getContext().getTypeAlignInChars(E->getType()).getQuantity(); 470 if (RV.isScalar()) 471 CGF.EmitStoreOfScalar(RV.getScalarVal(), ReferenceTemporary, 472 /*Volatile=*/false, Alignment, E->getType()); 473 else 474 CGF.StoreComplexToAddr(RV.getComplexVal(), ReferenceTemporary, 475 /*Volatile=*/false); 476 return ReferenceTemporary; 477} 478 479RValue 480CodeGenFunction::EmitReferenceBindingToExpr(const Expr *E, 481 const NamedDecl *InitializedDecl) { 482 llvm::Value *ReferenceTemporary = 0; 483 const CXXDestructorDecl *ReferenceTemporaryDtor = 0; 484 QualType ObjCARCReferenceLifetimeType; 485 llvm::Value *Value = EmitExprForReferenceBinding(*this, E, ReferenceTemporary, 486 ReferenceTemporaryDtor, 487 ObjCARCReferenceLifetimeType, 488 InitializedDecl); 489 if (!ReferenceTemporaryDtor && ObjCARCReferenceLifetimeType.isNull()) 490 return RValue::get(Value); 491 492 // Make sure to call the destructor for the reference temporary. 493 const VarDecl *VD = dyn_cast_or_null<VarDecl>(InitializedDecl); 494 if (VD && VD->hasGlobalStorage()) { 495 if (ReferenceTemporaryDtor) { 496 llvm::Constant *DtorFn = 497 CGM.GetAddrOfCXXDestructor(ReferenceTemporaryDtor, Dtor_Complete); 498 CGM.getCXXABI().registerGlobalDtor(*this, DtorFn, 499 cast<llvm::Constant>(ReferenceTemporary)); 500 } else { 501 assert(!ObjCARCReferenceLifetimeType.isNull()); 502 // Note: We intentionally do not register a global "destructor" to 503 // release the object. 504 } 505 506 return RValue::get(Value); 507 } 508 509 if (ReferenceTemporaryDtor) 510 PushDestructorCleanup(ReferenceTemporaryDtor, ReferenceTemporary); 511 else { 512 switch (ObjCARCReferenceLifetimeType.getObjCLifetime()) { 513 case Qualifiers::OCL_None: 514 llvm_unreachable( 515 "Not a reference temporary that needs to be deallocated"); 516 case Qualifiers::OCL_ExplicitNone: 517 case Qualifiers::OCL_Autoreleasing: 518 // Nothing to do. 519 break; 520 521 case Qualifiers::OCL_Strong: { 522 bool precise = VD && VD->hasAttr<ObjCPreciseLifetimeAttr>(); 523 CleanupKind cleanupKind = getARCCleanupKind(); 524 pushDestroy(cleanupKind, ReferenceTemporary, ObjCARCReferenceLifetimeType, 525 precise ? destroyARCStrongPrecise : destroyARCStrongImprecise, 526 cleanupKind & EHCleanup); 527 break; 528 } 529 530 case Qualifiers::OCL_Weak: { 531 // __weak objects always get EH cleanups; otherwise, exceptions 532 // could cause really nasty crashes instead of mere leaks. 533 pushDestroy(NormalAndEHCleanup, ReferenceTemporary, 534 ObjCARCReferenceLifetimeType, destroyARCWeak, true); 535 break; 536 } 537 } 538 } 539 540 return RValue::get(Value); 541} 542 543 544/// getAccessedFieldNo - Given an encoded value and a result number, return the 545/// input field number being accessed. 546unsigned CodeGenFunction::getAccessedFieldNo(unsigned Idx, 547 const llvm::Constant *Elts) { 548 return cast<llvm::ConstantInt>(Elts->getAggregateElement(Idx)) 549 ->getZExtValue(); 550} 551 552void CodeGenFunction::EmitCheck(llvm::Value *Address, unsigned Size) { 553 if (!CatchUndefined) 554 return; 555 556 // This needs to be to the standard address space. 557 Address = Builder.CreateBitCast(Address, Int8PtrTy); 558 559 llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::objectsize, IntPtrTy); 560 561 llvm::Value *Min = Builder.getFalse(); 562 llvm::Value *C = Builder.CreateCall2(F, Address, Min); 563 llvm::BasicBlock *Cont = createBasicBlock(); 564 Builder.CreateCondBr(Builder.CreateICmpUGE(C, 565 llvm::ConstantInt::get(IntPtrTy, Size)), 566 Cont, getTrapBB()); 567 EmitBlock(Cont); 568} 569 570 571CodeGenFunction::ComplexPairTy CodeGenFunction:: 572EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV, 573 bool isInc, bool isPre) { 574 ComplexPairTy InVal = LoadComplexFromAddr(LV.getAddress(), 575 LV.isVolatileQualified()); 576 577 llvm::Value *NextVal; 578 if (isa<llvm::IntegerType>(InVal.first->getType())) { 579 uint64_t AmountVal = isInc ? 1 : -1; 580 NextVal = llvm::ConstantInt::get(InVal.first->getType(), AmountVal, true); 581 582 // Add the inc/dec to the real part. 583 NextVal = Builder.CreateAdd(InVal.first, NextVal, isInc ? "inc" : "dec"); 584 } else { 585 QualType ElemTy = E->getType()->getAs<ComplexType>()->getElementType(); 586 llvm::APFloat FVal(getContext().getFloatTypeSemantics(ElemTy), 1); 587 if (!isInc) 588 FVal.changeSign(); 589 NextVal = llvm::ConstantFP::get(getLLVMContext(), FVal); 590 591 // Add the inc/dec to the real part. 592 NextVal = Builder.CreateFAdd(InVal.first, NextVal, isInc ? "inc" : "dec"); 593 } 594 595 ComplexPairTy IncVal(NextVal, InVal.second); 596 597 // Store the updated result through the lvalue. 598 StoreComplexToAddr(IncVal, LV.getAddress(), LV.isVolatileQualified()); 599 600 // If this is a postinc, return the value read from memory, otherwise use the 601 // updated value. 602 return isPre ? IncVal : InVal; 603} 604 605 606//===----------------------------------------------------------------------===// 607// LValue Expression Emission 608//===----------------------------------------------------------------------===// 609 610RValue CodeGenFunction::GetUndefRValue(QualType Ty) { 611 if (Ty->isVoidType()) 612 return RValue::get(0); 613 614 if (const ComplexType *CTy = Ty->getAs<ComplexType>()) { 615 llvm::Type *EltTy = ConvertType(CTy->getElementType()); 616 llvm::Value *U = llvm::UndefValue::get(EltTy); 617 return RValue::getComplex(std::make_pair(U, U)); 618 } 619 620 // If this is a use of an undefined aggregate type, the aggregate must have an 621 // identifiable address. Just because the contents of the value are undefined 622 // doesn't mean that the address can't be taken and compared. 623 if (hasAggregateLLVMType(Ty)) { 624 llvm::Value *DestPtr = CreateMemTemp(Ty, "undef.agg.tmp"); 625 return RValue::getAggregate(DestPtr); 626 } 627 628 return RValue::get(llvm::UndefValue::get(ConvertType(Ty))); 629} 630 631RValue CodeGenFunction::EmitUnsupportedRValue(const Expr *E, 632 const char *Name) { 633 ErrorUnsupported(E, Name); 634 return GetUndefRValue(E->getType()); 635} 636 637LValue CodeGenFunction::EmitUnsupportedLValue(const Expr *E, 638 const char *Name) { 639 ErrorUnsupported(E, Name); 640 llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType())); 641 return MakeAddrLValue(llvm::UndefValue::get(Ty), E->getType()); 642} 643 644LValue CodeGenFunction::EmitCheckedLValue(const Expr *E) { 645 LValue LV = EmitLValue(E); 646 if (!isa<DeclRefExpr>(E) && !LV.isBitField() && LV.isSimple()) 647 EmitCheck(LV.getAddress(), 648 getContext().getTypeSizeInChars(E->getType()).getQuantity()); 649 return LV; 650} 651 652/// EmitLValue - Emit code to compute a designator that specifies the location 653/// of the expression. 654/// 655/// This can return one of two things: a simple address or a bitfield reference. 656/// In either case, the LLVM Value* in the LValue structure is guaranteed to be 657/// an LLVM pointer type. 658/// 659/// If this returns a bitfield reference, nothing about the pointee type of the 660/// LLVM value is known: For example, it may not be a pointer to an integer. 661/// 662/// If this returns a normal address, and if the lvalue's C type is fixed size, 663/// this method guarantees that the returned pointer type will point to an LLVM 664/// type of the same size of the lvalue's type. If the lvalue has a variable 665/// length type, this is not possible. 666/// 667LValue CodeGenFunction::EmitLValue(const Expr *E) { 668 switch (E->getStmtClass()) { 669 default: return EmitUnsupportedLValue(E, "l-value expression"); 670 671 case Expr::ObjCPropertyRefExprClass: 672 llvm_unreachable("cannot emit a property reference directly"); 673 674 case Expr::ObjCSelectorExprClass: 675 return EmitObjCSelectorLValue(cast<ObjCSelectorExpr>(E)); 676 case Expr::ObjCIsaExprClass: 677 return EmitObjCIsaExpr(cast<ObjCIsaExpr>(E)); 678 case Expr::BinaryOperatorClass: 679 return EmitBinaryOperatorLValue(cast<BinaryOperator>(E)); 680 case Expr::CompoundAssignOperatorClass: 681 if (!E->getType()->isAnyComplexType()) 682 return EmitCompoundAssignmentLValue(cast<CompoundAssignOperator>(E)); 683 return EmitComplexCompoundAssignmentLValue(cast<CompoundAssignOperator>(E)); 684 case Expr::CallExprClass: 685 case Expr::CXXMemberCallExprClass: 686 case Expr::CXXOperatorCallExprClass: 687 case Expr::UserDefinedLiteralClass: 688 return EmitCallExprLValue(cast<CallExpr>(E)); 689 case Expr::VAArgExprClass: 690 return EmitVAArgExprLValue(cast<VAArgExpr>(E)); 691 case Expr::DeclRefExprClass: 692 return EmitDeclRefLValue(cast<DeclRefExpr>(E)); 693 case Expr::ParenExprClass: 694 return EmitLValue(cast<ParenExpr>(E)->getSubExpr()); 695 case Expr::GenericSelectionExprClass: 696 return EmitLValue(cast<GenericSelectionExpr>(E)->getResultExpr()); 697 case Expr::PredefinedExprClass: 698 return EmitPredefinedLValue(cast<PredefinedExpr>(E)); 699 case Expr::StringLiteralClass: 700 return EmitStringLiteralLValue(cast<StringLiteral>(E)); 701 case Expr::ObjCEncodeExprClass: 702 return EmitObjCEncodeExprLValue(cast<ObjCEncodeExpr>(E)); 703 case Expr::PseudoObjectExprClass: 704 return EmitPseudoObjectLValue(cast<PseudoObjectExpr>(E)); 705 case Expr::InitListExprClass: 706 return EmitInitListLValue(cast<InitListExpr>(E)); 707 case Expr::CXXTemporaryObjectExprClass: 708 case Expr::CXXConstructExprClass: 709 return EmitCXXConstructLValue(cast<CXXConstructExpr>(E)); 710 case Expr::CXXBindTemporaryExprClass: 711 return EmitCXXBindTemporaryLValue(cast<CXXBindTemporaryExpr>(E)); 712 case Expr::LambdaExprClass: 713 return EmitLambdaLValue(cast<LambdaExpr>(E)); 714 715 case Expr::ExprWithCleanupsClass: { 716 const ExprWithCleanups *cleanups = cast<ExprWithCleanups>(E); 717 enterFullExpression(cleanups); 718 RunCleanupsScope Scope(*this); 719 return EmitLValue(cleanups->getSubExpr()); 720 } 721 722 case Expr::CXXScalarValueInitExprClass: 723 return EmitNullInitializationLValue(cast<CXXScalarValueInitExpr>(E)); 724 case Expr::CXXDefaultArgExprClass: 725 return EmitLValue(cast<CXXDefaultArgExpr>(E)->getExpr()); 726 case Expr::CXXTypeidExprClass: 727 return EmitCXXTypeidLValue(cast<CXXTypeidExpr>(E)); 728 729 case Expr::ObjCMessageExprClass: 730 return EmitObjCMessageExprLValue(cast<ObjCMessageExpr>(E)); 731 case Expr::ObjCIvarRefExprClass: 732 return EmitObjCIvarRefLValue(cast<ObjCIvarRefExpr>(E)); 733 case Expr::StmtExprClass: 734 return EmitStmtExprLValue(cast<StmtExpr>(E)); 735 case Expr::UnaryOperatorClass: 736 return EmitUnaryOpLValue(cast<UnaryOperator>(E)); 737 case Expr::ArraySubscriptExprClass: 738 return EmitArraySubscriptExpr(cast<ArraySubscriptExpr>(E)); 739 case Expr::ExtVectorElementExprClass: 740 return EmitExtVectorElementExpr(cast<ExtVectorElementExpr>(E)); 741 case Expr::MemberExprClass: 742 return EmitMemberExpr(cast<MemberExpr>(E)); 743 case Expr::CompoundLiteralExprClass: 744 return EmitCompoundLiteralLValue(cast<CompoundLiteralExpr>(E)); 745 case Expr::ConditionalOperatorClass: 746 return EmitConditionalOperatorLValue(cast<ConditionalOperator>(E)); 747 case Expr::BinaryConditionalOperatorClass: 748 return EmitConditionalOperatorLValue(cast<BinaryConditionalOperator>(E)); 749 case Expr::ChooseExprClass: 750 return EmitLValue(cast<ChooseExpr>(E)->getChosenSubExpr(getContext())); 751 case Expr::OpaqueValueExprClass: 752 return EmitOpaqueValueLValue(cast<OpaqueValueExpr>(E)); 753 case Expr::SubstNonTypeTemplateParmExprClass: 754 return EmitLValue(cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement()); 755 case Expr::ImplicitCastExprClass: 756 case Expr::CStyleCastExprClass: 757 case Expr::CXXFunctionalCastExprClass: 758 case Expr::CXXStaticCastExprClass: 759 case Expr::CXXDynamicCastExprClass: 760 case Expr::CXXReinterpretCastExprClass: 761 case Expr::CXXConstCastExprClass: 762 case Expr::ObjCBridgedCastExprClass: 763 return EmitCastLValue(cast<CastExpr>(E)); 764 765 case Expr::MaterializeTemporaryExprClass: 766 return EmitMaterializeTemporaryExpr(cast<MaterializeTemporaryExpr>(E)); 767 } 768} 769 770/// Given an object of the given canonical type, can we safely copy a 771/// value out of it based on its initializer? 772static bool isConstantEmittableObjectType(QualType type) { 773 assert(type.isCanonical()); 774 assert(!type->isReferenceType()); 775 776 // Must be const-qualified but non-volatile. 777 Qualifiers qs = type.getLocalQualifiers(); 778 if (!qs.hasConst() || qs.hasVolatile()) return false; 779 780 // Otherwise, all object types satisfy this except C++ classes with 781 // mutable subobjects or non-trivial copy/destroy behavior. 782 if (const RecordType *RT = dyn_cast<RecordType>(type)) 783 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) 784 if (RD->hasMutableFields() || !RD->isTrivial()) 785 return false; 786 787 return true; 788} 789 790/// Can we constant-emit a load of a reference to a variable of the 791/// given type? This is different from predicates like 792/// Decl::isUsableInConstantExpressions because we do want it to apply 793/// in situations that don't necessarily satisfy the language's rules 794/// for this (e.g. C++'s ODR-use rules). For example, we want to able 795/// to do this with const float variables even if those variables 796/// aren't marked 'constexpr'. 797enum ConstantEmissionKind { 798 CEK_None, 799 CEK_AsReferenceOnly, 800 CEK_AsValueOrReference, 801 CEK_AsValueOnly 802}; 803static ConstantEmissionKind checkVarTypeForConstantEmission(QualType type) { 804 type = type.getCanonicalType(); 805 if (const ReferenceType *ref = dyn_cast<ReferenceType>(type)) { 806 if (isConstantEmittableObjectType(ref->getPointeeType())) 807 return CEK_AsValueOrReference; 808 return CEK_AsReferenceOnly; 809 } 810 if (isConstantEmittableObjectType(type)) 811 return CEK_AsValueOnly; 812 return CEK_None; 813} 814 815/// Try to emit a reference to the given value without producing it as 816/// an l-value. This is actually more than an optimization: we can't 817/// produce an l-value for variables that we never actually captured 818/// in a block or lambda, which means const int variables or constexpr 819/// literals or similar. 820CodeGenFunction::ConstantEmission 821CodeGenFunction::tryEmitAsConstant(DeclRefExpr *refExpr) { 822 ValueDecl *value = refExpr->getDecl(); 823 824 // The value needs to be an enum constant or a constant variable. 825 ConstantEmissionKind CEK; 826 if (isa<ParmVarDecl>(value)) { 827 CEK = CEK_None; 828 } else if (VarDecl *var = dyn_cast<VarDecl>(value)) { 829 CEK = checkVarTypeForConstantEmission(var->getType()); 830 } else if (isa<EnumConstantDecl>(value)) { 831 CEK = CEK_AsValueOnly; 832 } else { 833 CEK = CEK_None; 834 } 835 if (CEK == CEK_None) return ConstantEmission(); 836 837 Expr::EvalResult result; 838 bool resultIsReference; 839 QualType resultType; 840 841 // It's best to evaluate all the way as an r-value if that's permitted. 842 if (CEK != CEK_AsReferenceOnly && 843 refExpr->EvaluateAsRValue(result, getContext())) { 844 resultIsReference = false; 845 resultType = refExpr->getType(); 846 847 // Otherwise, try to evaluate as an l-value. 848 } else if (CEK != CEK_AsValueOnly && 849 refExpr->EvaluateAsLValue(result, getContext())) { 850 resultIsReference = true; 851 resultType = value->getType(); 852 853 // Failure. 854 } else { 855 return ConstantEmission(); 856 } 857 858 // In any case, if the initializer has side-effects, abandon ship. 859 if (result.HasSideEffects) 860 return ConstantEmission(); 861 862 // Emit as a constant. 863 llvm::Constant *C = CGM.EmitConstantValue(result.Val, resultType, this); 864 865 // Make sure we emit a debug reference to the global variable. 866 // This should probably fire even for 867 if (isa<VarDecl>(value)) { 868 if (!getContext().DeclMustBeEmitted(cast<VarDecl>(value))) 869 EmitDeclRefExprDbgValue(refExpr, C); 870 } else { 871 assert(isa<EnumConstantDecl>(value)); 872 EmitDeclRefExprDbgValue(refExpr, C); 873 } 874 875 // If we emitted a reference constant, we need to dereference that. 876 if (resultIsReference) 877 return ConstantEmission::forReference(C); 878 879 return ConstantEmission::forValue(C); 880} 881 882llvm::Value *CodeGenFunction::EmitLoadOfScalar(LValue lvalue) { 883 return EmitLoadOfScalar(lvalue.getAddress(), lvalue.isVolatile(), 884 lvalue.getAlignment().getQuantity(), 885 lvalue.getType(), lvalue.getTBAAInfo()); 886} 887 888static bool hasBooleanRepresentation(QualType Ty) { 889 if (Ty->isBooleanType()) 890 return true; 891 892 if (const EnumType *ET = Ty->getAs<EnumType>()) 893 return ET->getDecl()->getIntegerType()->isBooleanType(); 894 895 if (const AtomicType *AT = Ty->getAs<AtomicType>()) 896 return hasBooleanRepresentation(AT->getValueType()); 897 898 return false; 899} 900 901llvm::MDNode *CodeGenFunction::getRangeForLoadFromType(QualType Ty) { 902 const EnumType *ET = Ty->getAs<EnumType>(); 903 bool IsRegularCPlusPlusEnum = (getLangOpts().CPlusPlus && ET && 904 CGM.getCodeGenOpts().StrictEnums && 905 !ET->getDecl()->isFixed()); 906 bool IsBool = hasBooleanRepresentation(Ty); 907 if (!IsBool && !IsRegularCPlusPlusEnum) 908 return NULL; 909 910 llvm::APInt Min; 911 llvm::APInt End; 912 if (IsBool) { 913 Min = llvm::APInt(8, 0); 914 End = llvm::APInt(8, 2); 915 } else { 916 const EnumDecl *ED = ET->getDecl(); 917 llvm::Type *LTy = ConvertTypeForMem(ED->getIntegerType()); 918 unsigned Bitwidth = LTy->getScalarSizeInBits(); 919 unsigned NumNegativeBits = ED->getNumNegativeBits(); 920 unsigned NumPositiveBits = ED->getNumPositiveBits(); 921 922 if (NumNegativeBits) { 923 unsigned NumBits = std::max(NumNegativeBits, NumPositiveBits + 1); 924 assert(NumBits <= Bitwidth); 925 End = llvm::APInt(Bitwidth, 1) << (NumBits - 1); 926 Min = -End; 927 } else { 928 assert(NumPositiveBits <= Bitwidth); 929 End = llvm::APInt(Bitwidth, 1) << NumPositiveBits; 930 Min = llvm::APInt(Bitwidth, 0); 931 } 932 } 933 934 llvm::MDBuilder MDHelper(getLLVMContext()); 935 return MDHelper.createRange(Min, End); 936} 937 938llvm::Value *CodeGenFunction::EmitLoadOfScalar(llvm::Value *Addr, bool Volatile, 939 unsigned Alignment, QualType Ty, 940 llvm::MDNode *TBAAInfo) { 941 llvm::LoadInst *Load = Builder.CreateLoad(Addr); 942 if (Volatile) 943 Load->setVolatile(true); 944 if (Alignment) 945 Load->setAlignment(Alignment); 946 if (TBAAInfo) 947 CGM.DecorateInstruction(Load, TBAAInfo); 948 // If this is an atomic type, all normal reads must be atomic 949 if (Ty->isAtomicType()) 950 Load->setAtomic(llvm::SequentiallyConsistent); 951 952 if (CGM.getCodeGenOpts().OptimizationLevel > 0) 953 if (llvm::MDNode *RangeInfo = getRangeForLoadFromType(Ty)) 954 Load->setMetadata(llvm::LLVMContext::MD_range, RangeInfo); 955 956 return EmitFromMemory(Load, Ty); 957} 958 959llvm::Value *CodeGenFunction::EmitToMemory(llvm::Value *Value, QualType Ty) { 960 // Bool has a different representation in memory than in registers. 961 if (hasBooleanRepresentation(Ty)) { 962 // This should really always be an i1, but sometimes it's already 963 // an i8, and it's awkward to track those cases down. 964 if (Value->getType()->isIntegerTy(1)) 965 return Builder.CreateZExt(Value, Builder.getInt8Ty(), "frombool"); 966 assert(Value->getType()->isIntegerTy(8) && "value rep of bool not i1/i8"); 967 } 968 969 return Value; 970} 971 972llvm::Value *CodeGenFunction::EmitFromMemory(llvm::Value *Value, QualType Ty) { 973 // Bool has a different representation in memory than in registers. 974 if (hasBooleanRepresentation(Ty)) { 975 assert(Value->getType()->isIntegerTy(8) && "memory rep of bool not i8"); 976 return Builder.CreateTrunc(Value, Builder.getInt1Ty(), "tobool"); 977 } 978 979 return Value; 980} 981 982void CodeGenFunction::EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr, 983 bool Volatile, unsigned Alignment, 984 QualType Ty, 985 llvm::MDNode *TBAAInfo, 986 bool isInit) { 987 Value = EmitToMemory(Value, Ty); 988 989 llvm::StoreInst *Store = Builder.CreateStore(Value, Addr, Volatile); 990 if (Alignment) 991 Store->setAlignment(Alignment); 992 if (TBAAInfo) 993 CGM.DecorateInstruction(Store, TBAAInfo); 994 if (!isInit && Ty->isAtomicType()) 995 Store->setAtomic(llvm::SequentiallyConsistent); 996} 997 998void CodeGenFunction::EmitStoreOfScalar(llvm::Value *value, LValue lvalue, 999 bool isInit) { 1000 EmitStoreOfScalar(value, lvalue.getAddress(), lvalue.isVolatile(), 1001 lvalue.getAlignment().getQuantity(), lvalue.getType(), 1002 lvalue.getTBAAInfo(), isInit); 1003} 1004 1005/// EmitLoadOfLValue - Given an expression that represents a value lvalue, this 1006/// method emits the address of the lvalue, then loads the result as an rvalue, 1007/// returning the rvalue. 1008RValue CodeGenFunction::EmitLoadOfLValue(LValue LV) { 1009 if (LV.isObjCWeak()) { 1010 // load of a __weak object. 1011 llvm::Value *AddrWeakObj = LV.getAddress(); 1012 return RValue::get(CGM.getObjCRuntime().EmitObjCWeakRead(*this, 1013 AddrWeakObj)); 1014 } 1015 if (LV.getQuals().getObjCLifetime() == Qualifiers::OCL_Weak) 1016 return RValue::get(EmitARCLoadWeak(LV.getAddress())); 1017 1018 if (LV.isSimple()) { 1019 assert(!LV.getType()->isFunctionType()); 1020 1021 // Everything needs a load. 1022 return RValue::get(EmitLoadOfScalar(LV)); 1023 } 1024 1025 if (LV.isVectorElt()) { 1026 llvm::LoadInst *Load = Builder.CreateLoad(LV.getVectorAddr(), 1027 LV.isVolatileQualified()); 1028 Load->setAlignment(LV.getAlignment().getQuantity()); 1029 return RValue::get(Builder.CreateExtractElement(Load, LV.getVectorIdx(), 1030 "vecext")); 1031 } 1032 1033 // If this is a reference to a subset of the elements of a vector, either 1034 // shuffle the input or extract/insert them as appropriate. 1035 if (LV.isExtVectorElt()) 1036 return EmitLoadOfExtVectorElementLValue(LV); 1037 1038 assert(LV.isBitField() && "Unknown LValue type!"); 1039 return EmitLoadOfBitfieldLValue(LV); 1040} 1041 1042RValue CodeGenFunction::EmitLoadOfBitfieldLValue(LValue LV) { 1043 const CGBitFieldInfo &Info = LV.getBitFieldInfo(); 1044 1045 // Get the output type. 1046 llvm::Type *ResLTy = ConvertType(LV.getType()); 1047 unsigned ResSizeInBits = CGM.getTargetData().getTypeSizeInBits(ResLTy); 1048 1049 // Compute the result as an OR of all of the individual component accesses. 1050 llvm::Value *Res = 0; 1051 for (unsigned i = 0, e = Info.getNumComponents(); i != e; ++i) { 1052 const CGBitFieldInfo::AccessInfo &AI = Info.getComponent(i); 1053 CharUnits AccessAlignment = AI.AccessAlignment; 1054 if (!LV.getAlignment().isZero()) 1055 AccessAlignment = std::min(AccessAlignment, LV.getAlignment()); 1056 1057 // Get the field pointer. 1058 llvm::Value *Ptr = LV.getBitFieldBaseAddr(); 1059 1060 // Only offset by the field index if used, so that incoming values are not 1061 // required to be structures. 1062 if (AI.FieldIndex) 1063 Ptr = Builder.CreateStructGEP(Ptr, AI.FieldIndex, "bf.field"); 1064 1065 // Offset by the byte offset, if used. 1066 if (!AI.FieldByteOffset.isZero()) { 1067 Ptr = EmitCastToVoidPtr(Ptr); 1068 Ptr = Builder.CreateConstGEP1_32(Ptr, AI.FieldByteOffset.getQuantity(), 1069 "bf.field.offs"); 1070 } 1071 1072 // Cast to the access type. 1073 llvm::Type *PTy = llvm::Type::getIntNPtrTy(getLLVMContext(), AI.AccessWidth, 1074 CGM.getContext().getTargetAddressSpace(LV.getType())); 1075 Ptr = Builder.CreateBitCast(Ptr, PTy); 1076 1077 // Perform the load. 1078 llvm::LoadInst *Load = Builder.CreateLoad(Ptr, LV.isVolatileQualified()); 1079 Load->setAlignment(AccessAlignment.getQuantity()); 1080 1081 // Shift out unused low bits and mask out unused high bits. 1082 llvm::Value *Val = Load; 1083 if (AI.FieldBitStart) 1084 Val = Builder.CreateLShr(Load, AI.FieldBitStart); 1085 Val = Builder.CreateAnd(Val, llvm::APInt::getLowBitsSet(AI.AccessWidth, 1086 AI.TargetBitWidth), 1087 "bf.clear"); 1088 1089 // Extend or truncate to the target size. 1090 if (AI.AccessWidth < ResSizeInBits) 1091 Val = Builder.CreateZExt(Val, ResLTy); 1092 else if (AI.AccessWidth > ResSizeInBits) 1093 Val = Builder.CreateTrunc(Val, ResLTy); 1094 1095 // Shift into place, and OR into the result. 1096 if (AI.TargetBitOffset) 1097 Val = Builder.CreateShl(Val, AI.TargetBitOffset); 1098 Res = Res ? Builder.CreateOr(Res, Val) : Val; 1099 } 1100 1101 // If the bit-field is signed, perform the sign-extension. 1102 // 1103 // FIXME: This can easily be folded into the load of the high bits, which 1104 // could also eliminate the mask of high bits in some situations. 1105 if (Info.isSigned()) { 1106 unsigned ExtraBits = ResSizeInBits - Info.getSize(); 1107 if (ExtraBits) 1108 Res = Builder.CreateAShr(Builder.CreateShl(Res, ExtraBits), 1109 ExtraBits, "bf.val.sext"); 1110 } 1111 1112 return RValue::get(Res); 1113} 1114 1115// If this is a reference to a subset of the elements of a vector, create an 1116// appropriate shufflevector. 1117RValue CodeGenFunction::EmitLoadOfExtVectorElementLValue(LValue LV) { 1118 llvm::LoadInst *Load = Builder.CreateLoad(LV.getExtVectorAddr(), 1119 LV.isVolatileQualified()); 1120 Load->setAlignment(LV.getAlignment().getQuantity()); 1121 llvm::Value *Vec = Load; 1122 1123 const llvm::Constant *Elts = LV.getExtVectorElts(); 1124 1125 // If the result of the expression is a non-vector type, we must be extracting 1126 // a single element. Just codegen as an extractelement. 1127 const VectorType *ExprVT = LV.getType()->getAs<VectorType>(); 1128 if (!ExprVT) { 1129 unsigned InIdx = getAccessedFieldNo(0, Elts); 1130 llvm::Value *Elt = llvm::ConstantInt::get(Int32Ty, InIdx); 1131 return RValue::get(Builder.CreateExtractElement(Vec, Elt)); 1132 } 1133 1134 // Always use shuffle vector to try to retain the original program structure 1135 unsigned NumResultElts = ExprVT->getNumElements(); 1136 1137 SmallVector<llvm::Constant*, 4> Mask; 1138 for (unsigned i = 0; i != NumResultElts; ++i) 1139 Mask.push_back(Builder.getInt32(getAccessedFieldNo(i, Elts))); 1140 1141 llvm::Value *MaskV = llvm::ConstantVector::get(Mask); 1142 Vec = Builder.CreateShuffleVector(Vec, llvm::UndefValue::get(Vec->getType()), 1143 MaskV); 1144 return RValue::get(Vec); 1145} 1146 1147 1148 1149/// EmitStoreThroughLValue - Store the specified rvalue into the specified 1150/// lvalue, where both are guaranteed to the have the same type, and that type 1151/// is 'Ty'. 1152void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit) { 1153 if (!Dst.isSimple()) { 1154 if (Dst.isVectorElt()) { 1155 // Read/modify/write the vector, inserting the new element. 1156 llvm::LoadInst *Load = Builder.CreateLoad(Dst.getVectorAddr(), 1157 Dst.isVolatileQualified()); 1158 Load->setAlignment(Dst.getAlignment().getQuantity()); 1159 llvm::Value *Vec = Load; 1160 Vec = Builder.CreateInsertElement(Vec, Src.getScalarVal(), 1161 Dst.getVectorIdx(), "vecins"); 1162 llvm::StoreInst *Store = Builder.CreateStore(Vec, Dst.getVectorAddr(), 1163 Dst.isVolatileQualified()); 1164 Store->setAlignment(Dst.getAlignment().getQuantity()); 1165 return; 1166 } 1167 1168 // If this is an update of extended vector elements, insert them as 1169 // appropriate. 1170 if (Dst.isExtVectorElt()) 1171 return EmitStoreThroughExtVectorComponentLValue(Src, Dst); 1172 1173 assert(Dst.isBitField() && "Unknown LValue type"); 1174 return EmitStoreThroughBitfieldLValue(Src, Dst); 1175 } 1176 1177 // There's special magic for assigning into an ARC-qualified l-value. 1178 if (Qualifiers::ObjCLifetime Lifetime = Dst.getQuals().getObjCLifetime()) { 1179 switch (Lifetime) { 1180 case Qualifiers::OCL_None: 1181 llvm_unreachable("present but none"); 1182 1183 case Qualifiers::OCL_ExplicitNone: 1184 // nothing special 1185 break; 1186 1187 case Qualifiers::OCL_Strong: 1188 EmitARCStoreStrong(Dst, Src.getScalarVal(), /*ignore*/ true); 1189 return; 1190 1191 case Qualifiers::OCL_Weak: 1192 EmitARCStoreWeak(Dst.getAddress(), Src.getScalarVal(), /*ignore*/ true); 1193 return; 1194 1195 case Qualifiers::OCL_Autoreleasing: 1196 Src = RValue::get(EmitObjCExtendObjectLifetime(Dst.getType(), 1197 Src.getScalarVal())); 1198 // fall into the normal path 1199 break; 1200 } 1201 } 1202 1203 if (Dst.isObjCWeak() && !Dst.isNonGC()) { 1204 // load of a __weak object. 1205 llvm::Value *LvalueDst = Dst.getAddress(); 1206 llvm::Value *src = Src.getScalarVal(); 1207 CGM.getObjCRuntime().EmitObjCWeakAssign(*this, src, LvalueDst); 1208 return; 1209 } 1210 1211 if (Dst.isObjCStrong() && !Dst.isNonGC()) { 1212 // load of a __strong object. 1213 llvm::Value *LvalueDst = Dst.getAddress(); 1214 llvm::Value *src = Src.getScalarVal(); 1215 if (Dst.isObjCIvar()) { 1216 assert(Dst.getBaseIvarExp() && "BaseIvarExp is NULL"); 1217 llvm::Type *ResultType = ConvertType(getContext().LongTy); 1218 llvm::Value *RHS = EmitScalarExpr(Dst.getBaseIvarExp()); 1219 llvm::Value *dst = RHS; 1220 RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast"); 1221 llvm::Value *LHS = 1222 Builder.CreatePtrToInt(LvalueDst, ResultType, "sub.ptr.lhs.cast"); 1223 llvm::Value *BytesBetween = Builder.CreateSub(LHS, RHS, "ivar.offset"); 1224 CGM.getObjCRuntime().EmitObjCIvarAssign(*this, src, dst, 1225 BytesBetween); 1226 } else if (Dst.isGlobalObjCRef()) { 1227 CGM.getObjCRuntime().EmitObjCGlobalAssign(*this, src, LvalueDst, 1228 Dst.isThreadLocalRef()); 1229 } 1230 else 1231 CGM.getObjCRuntime().EmitObjCStrongCastAssign(*this, src, LvalueDst); 1232 return; 1233 } 1234 1235 assert(Src.isScalar() && "Can't emit an agg store with this method"); 1236 EmitStoreOfScalar(Src.getScalarVal(), Dst, isInit); 1237} 1238 1239void CodeGenFunction::EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, 1240 llvm::Value **Result) { 1241 const CGBitFieldInfo &Info = Dst.getBitFieldInfo(); 1242 1243 // Get the output type. 1244 llvm::Type *ResLTy = ConvertTypeForMem(Dst.getType()); 1245 unsigned ResSizeInBits = CGM.getTargetData().getTypeSizeInBits(ResLTy); 1246 1247 // Get the source value, truncated to the width of the bit-field. 1248 llvm::Value *SrcVal = Src.getScalarVal(); 1249 1250 if (hasBooleanRepresentation(Dst.getType())) 1251 SrcVal = Builder.CreateIntCast(SrcVal, ResLTy, /*IsSigned=*/false); 1252 1253 SrcVal = Builder.CreateAnd(SrcVal, llvm::APInt::getLowBitsSet(ResSizeInBits, 1254 Info.getSize()), 1255 "bf.value"); 1256 1257 // Return the new value of the bit-field, if requested. 1258 if (Result) { 1259 // Cast back to the proper type for result. 1260 llvm::Type *SrcTy = Src.getScalarVal()->getType(); 1261 llvm::Value *ReloadVal = Builder.CreateIntCast(SrcVal, SrcTy, false, 1262 "bf.reload.val"); 1263 1264 // Sign extend if necessary. 1265 if (Info.isSigned()) { 1266 unsigned ExtraBits = ResSizeInBits - Info.getSize(); 1267 if (ExtraBits) 1268 ReloadVal = Builder.CreateAShr(Builder.CreateShl(ReloadVal, ExtraBits), 1269 ExtraBits, "bf.reload.sext"); 1270 } 1271 1272 *Result = ReloadVal; 1273 } 1274 1275 // Iterate over the components, writing each piece to memory. 1276 for (unsigned i = 0, e = Info.getNumComponents(); i != e; ++i) { 1277 const CGBitFieldInfo::AccessInfo &AI = Info.getComponent(i); 1278 CharUnits AccessAlignment = AI.AccessAlignment; 1279 if (!Dst.getAlignment().isZero()) 1280 AccessAlignment = std::min(AccessAlignment, Dst.getAlignment()); 1281 1282 // Get the field pointer. 1283 llvm::Value *Ptr = Dst.getBitFieldBaseAddr(); 1284 unsigned addressSpace = 1285 cast<llvm::PointerType>(Ptr->getType())->getAddressSpace(); 1286 1287 // Only offset by the field index if used, so that incoming values are not 1288 // required to be structures. 1289 if (AI.FieldIndex) 1290 Ptr = Builder.CreateStructGEP(Ptr, AI.FieldIndex, "bf.field"); 1291 1292 // Offset by the byte offset, if used. 1293 if (!AI.FieldByteOffset.isZero()) { 1294 Ptr = EmitCastToVoidPtr(Ptr); 1295 Ptr = Builder.CreateConstGEP1_32(Ptr, AI.FieldByteOffset.getQuantity(), 1296 "bf.field.offs"); 1297 } 1298 1299 // Cast to the access type. 1300 llvm::Type *AccessLTy = 1301 llvm::Type::getIntNTy(getLLVMContext(), AI.AccessWidth); 1302 1303 llvm::Type *PTy = AccessLTy->getPointerTo(addressSpace); 1304 Ptr = Builder.CreateBitCast(Ptr, PTy); 1305 1306 // Extract the piece of the bit-field value to write in this access, limited 1307 // to the values that are part of this access. 1308 llvm::Value *Val = SrcVal; 1309 if (AI.TargetBitOffset) 1310 Val = Builder.CreateLShr(Val, AI.TargetBitOffset); 1311 Val = Builder.CreateAnd(Val, llvm::APInt::getLowBitsSet(ResSizeInBits, 1312 AI.TargetBitWidth)); 1313 1314 // Extend or truncate to the access size. 1315 if (ResSizeInBits < AI.AccessWidth) 1316 Val = Builder.CreateZExt(Val, AccessLTy); 1317 else if (ResSizeInBits > AI.AccessWidth) 1318 Val = Builder.CreateTrunc(Val, AccessLTy); 1319 1320 // Shift into the position in memory. 1321 if (AI.FieldBitStart) 1322 Val = Builder.CreateShl(Val, AI.FieldBitStart); 1323 1324 // If necessary, load and OR in bits that are outside of the bit-field. 1325 if (AI.TargetBitWidth != AI.AccessWidth) { 1326 llvm::LoadInst *Load = Builder.CreateLoad(Ptr, Dst.isVolatileQualified()); 1327 Load->setAlignment(AccessAlignment.getQuantity()); 1328 1329 // Compute the mask for zeroing the bits that are part of the bit-field. 1330 llvm::APInt InvMask = 1331 ~llvm::APInt::getBitsSet(AI.AccessWidth, AI.FieldBitStart, 1332 AI.FieldBitStart + AI.TargetBitWidth); 1333 1334 // Apply the mask and OR in to the value to write. 1335 Val = Builder.CreateOr(Builder.CreateAnd(Load, InvMask), Val); 1336 } 1337 1338 // Write the value. 1339 llvm::StoreInst *Store = Builder.CreateStore(Val, Ptr, 1340 Dst.isVolatileQualified()); 1341 Store->setAlignment(AccessAlignment.getQuantity()); 1342 } 1343} 1344 1345void CodeGenFunction::EmitStoreThroughExtVectorComponentLValue(RValue Src, 1346 LValue Dst) { 1347 // This access turns into a read/modify/write of the vector. Load the input 1348 // value now. 1349 llvm::LoadInst *Load = Builder.CreateLoad(Dst.getExtVectorAddr(), 1350 Dst.isVolatileQualified()); 1351 Load->setAlignment(Dst.getAlignment().getQuantity()); 1352 llvm::Value *Vec = Load; 1353 const llvm::Constant *Elts = Dst.getExtVectorElts(); 1354 1355 llvm::Value *SrcVal = Src.getScalarVal(); 1356 1357 if (const VectorType *VTy = Dst.getType()->getAs<VectorType>()) { 1358 unsigned NumSrcElts = VTy->getNumElements(); 1359 unsigned NumDstElts = 1360 cast<llvm::VectorType>(Vec->getType())->getNumElements(); 1361 if (NumDstElts == NumSrcElts) { 1362 // Use shuffle vector is the src and destination are the same number of 1363 // elements and restore the vector mask since it is on the side it will be 1364 // stored. 1365 SmallVector<llvm::Constant*, 4> Mask(NumDstElts); 1366 for (unsigned i = 0; i != NumSrcElts; ++i) 1367 Mask[getAccessedFieldNo(i, Elts)] = Builder.getInt32(i); 1368 1369 llvm::Value *MaskV = llvm::ConstantVector::get(Mask); 1370 Vec = Builder.CreateShuffleVector(SrcVal, 1371 llvm::UndefValue::get(Vec->getType()), 1372 MaskV); 1373 } else if (NumDstElts > NumSrcElts) { 1374 // Extended the source vector to the same length and then shuffle it 1375 // into the destination. 1376 // FIXME: since we're shuffling with undef, can we just use the indices 1377 // into that? This could be simpler. 1378 SmallVector<llvm::Constant*, 4> ExtMask; 1379 for (unsigned i = 0; i != NumSrcElts; ++i) 1380 ExtMask.push_back(Builder.getInt32(i)); 1381 ExtMask.resize(NumDstElts, llvm::UndefValue::get(Int32Ty)); 1382 llvm::Value *ExtMaskV = llvm::ConstantVector::get(ExtMask); 1383 llvm::Value *ExtSrcVal = 1384 Builder.CreateShuffleVector(SrcVal, 1385 llvm::UndefValue::get(SrcVal->getType()), 1386 ExtMaskV); 1387 // build identity 1388 SmallVector<llvm::Constant*, 4> Mask; 1389 for (unsigned i = 0; i != NumDstElts; ++i) 1390 Mask.push_back(Builder.getInt32(i)); 1391 1392 // modify when what gets shuffled in 1393 for (unsigned i = 0; i != NumSrcElts; ++i) 1394 Mask[getAccessedFieldNo(i, Elts)] = Builder.getInt32(i+NumDstElts); 1395 llvm::Value *MaskV = llvm::ConstantVector::get(Mask); 1396 Vec = Builder.CreateShuffleVector(Vec, ExtSrcVal, MaskV); 1397 } else { 1398 // We should never shorten the vector 1399 llvm_unreachable("unexpected shorten vector length"); 1400 } 1401 } else { 1402 // If the Src is a scalar (not a vector) it must be updating one element. 1403 unsigned InIdx = getAccessedFieldNo(0, Elts); 1404 llvm::Value *Elt = llvm::ConstantInt::get(Int32Ty, InIdx); 1405 Vec = Builder.CreateInsertElement(Vec, SrcVal, Elt); 1406 } 1407 1408 llvm::StoreInst *Store = Builder.CreateStore(Vec, Dst.getExtVectorAddr(), 1409 Dst.isVolatileQualified()); 1410 Store->setAlignment(Dst.getAlignment().getQuantity()); 1411} 1412 1413// setObjCGCLValueClass - sets class of he lvalue for the purpose of 1414// generating write-barries API. It is currently a global, ivar, 1415// or neither. 1416static void setObjCGCLValueClass(const ASTContext &Ctx, const Expr *E, 1417 LValue &LV, 1418 bool IsMemberAccess=false) { 1419 if (Ctx.getLangOpts().getGC() == LangOptions::NonGC) 1420 return; 1421 1422 if (isa<ObjCIvarRefExpr>(E)) { 1423 QualType ExpTy = E->getType(); 1424 if (IsMemberAccess && ExpTy->isPointerType()) { 1425 // If ivar is a structure pointer, assigning to field of 1426 // this struct follows gcc's behavior and makes it a non-ivar 1427 // writer-barrier conservatively. 1428 ExpTy = ExpTy->getAs<PointerType>()->getPointeeType(); 1429 if (ExpTy->isRecordType()) { 1430 LV.setObjCIvar(false); 1431 return; 1432 } 1433 } 1434 LV.setObjCIvar(true); 1435 ObjCIvarRefExpr *Exp = cast<ObjCIvarRefExpr>(const_cast<Expr*>(E)); 1436 LV.setBaseIvarExp(Exp->getBase()); 1437 LV.setObjCArray(E->getType()->isArrayType()); 1438 return; 1439 } 1440 1441 if (const DeclRefExpr *Exp = dyn_cast<DeclRefExpr>(E)) { 1442 if (const VarDecl *VD = dyn_cast<VarDecl>(Exp->getDecl())) { 1443 if (VD->hasGlobalStorage()) { 1444 LV.setGlobalObjCRef(true); 1445 LV.setThreadLocalRef(VD->isThreadSpecified()); 1446 } 1447 } 1448 LV.setObjCArray(E->getType()->isArrayType()); 1449 return; 1450 } 1451 1452 if (const UnaryOperator *Exp = dyn_cast<UnaryOperator>(E)) { 1453 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess); 1454 return; 1455 } 1456 1457 if (const ParenExpr *Exp = dyn_cast<ParenExpr>(E)) { 1458 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess); 1459 if (LV.isObjCIvar()) { 1460 // If cast is to a structure pointer, follow gcc's behavior and make it 1461 // a non-ivar write-barrier. 1462 QualType ExpTy = E->getType(); 1463 if (ExpTy->isPointerType()) 1464 ExpTy = ExpTy->getAs<PointerType>()->getPointeeType(); 1465 if (ExpTy->isRecordType()) 1466 LV.setObjCIvar(false); 1467 } 1468 return; 1469 } 1470 1471 if (const GenericSelectionExpr *Exp = dyn_cast<GenericSelectionExpr>(E)) { 1472 setObjCGCLValueClass(Ctx, Exp->getResultExpr(), LV); 1473 return; 1474 } 1475 1476 if (const ImplicitCastExpr *Exp = dyn_cast<ImplicitCastExpr>(E)) { 1477 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess); 1478 return; 1479 } 1480 1481 if (const CStyleCastExpr *Exp = dyn_cast<CStyleCastExpr>(E)) { 1482 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess); 1483 return; 1484 } 1485 1486 if (const ObjCBridgedCastExpr *Exp = dyn_cast<ObjCBridgedCastExpr>(E)) { 1487 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess); 1488 return; 1489 } 1490 1491 if (const ArraySubscriptExpr *Exp = dyn_cast<ArraySubscriptExpr>(E)) { 1492 setObjCGCLValueClass(Ctx, Exp->getBase(), LV); 1493 if (LV.isObjCIvar() && !LV.isObjCArray()) 1494 // Using array syntax to assigning to what an ivar points to is not 1495 // same as assigning to the ivar itself. {id *Names;} Names[i] = 0; 1496 LV.setObjCIvar(false); 1497 else if (LV.isGlobalObjCRef() && !LV.isObjCArray()) 1498 // Using array syntax to assigning to what global points to is not 1499 // same as assigning to the global itself. {id *G;} G[i] = 0; 1500 LV.setGlobalObjCRef(false); 1501 return; 1502 } 1503 1504 if (const MemberExpr *Exp = dyn_cast<MemberExpr>(E)) { 1505 setObjCGCLValueClass(Ctx, Exp->getBase(), LV, true); 1506 // We don't know if member is an 'ivar', but this flag is looked at 1507 // only in the context of LV.isObjCIvar(). 1508 LV.setObjCArray(E->getType()->isArrayType()); 1509 return; 1510 } 1511} 1512 1513static llvm::Value * 1514EmitBitCastOfLValueToProperType(CodeGenFunction &CGF, 1515 llvm::Value *V, llvm::Type *IRType, 1516 StringRef Name = StringRef()) { 1517 unsigned AS = cast<llvm::PointerType>(V->getType())->getAddressSpace(); 1518 return CGF.Builder.CreateBitCast(V, IRType->getPointerTo(AS), Name); 1519} 1520 1521static LValue EmitGlobalVarDeclLValue(CodeGenFunction &CGF, 1522 const Expr *E, const VarDecl *VD) { 1523 assert((VD->hasExternalStorage() || VD->isFileVarDecl()) && 1524 "Var decl must have external storage or be a file var decl!"); 1525 1526 llvm::Value *V = CGF.CGM.GetAddrOfGlobalVar(VD); 1527 llvm::Type *RealVarTy = CGF.getTypes().ConvertTypeForMem(VD->getType()); 1528 V = EmitBitCastOfLValueToProperType(CGF, V, RealVarTy); 1529 CharUnits Alignment = CGF.getContext().getDeclAlign(VD); 1530 QualType T = E->getType(); 1531 LValue LV; 1532 if (VD->getType()->isReferenceType()) { 1533 llvm::LoadInst *LI = CGF.Builder.CreateLoad(V); 1534 LI->setAlignment(Alignment.getQuantity()); 1535 V = LI; 1536 LV = CGF.MakeNaturalAlignAddrLValue(V, T); 1537 } else { 1538 LV = CGF.MakeAddrLValue(V, E->getType(), Alignment); 1539 } 1540 setObjCGCLValueClass(CGF.getContext(), E, LV); 1541 return LV; 1542} 1543 1544static LValue EmitFunctionDeclLValue(CodeGenFunction &CGF, 1545 const Expr *E, const FunctionDecl *FD) { 1546 llvm::Value *V = CGF.CGM.GetAddrOfFunction(FD); 1547 if (!FD->hasPrototype()) { 1548 if (const FunctionProtoType *Proto = 1549 FD->getType()->getAs<FunctionProtoType>()) { 1550 // Ugly case: for a K&R-style definition, the type of the definition 1551 // isn't the same as the type of a use. Correct for this with a 1552 // bitcast. 1553 QualType NoProtoType = 1554 CGF.getContext().getFunctionNoProtoType(Proto->getResultType()); 1555 NoProtoType = CGF.getContext().getPointerType(NoProtoType); 1556 V = CGF.Builder.CreateBitCast(V, CGF.ConvertType(NoProtoType)); 1557 } 1558 } 1559 CharUnits Alignment = CGF.getContext().getDeclAlign(FD); 1560 return CGF.MakeAddrLValue(V, E->getType(), Alignment); 1561} 1562 1563LValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) { 1564 const NamedDecl *ND = E->getDecl(); 1565 CharUnits Alignment = getContext().getDeclAlign(ND); 1566 QualType T = E->getType(); 1567 1568 // FIXME: We should be able to assert this for FunctionDecls as well! 1569 // FIXME: We should be able to assert this for all DeclRefExprs, not just 1570 // those with a valid source location. 1571 assert((ND->isUsed(false) || !isa<VarDecl>(ND) || 1572 !E->getLocation().isValid()) && 1573 "Should not use decl without marking it used!"); 1574 1575 if (ND->hasAttr<WeakRefAttr>()) { 1576 const ValueDecl *VD = cast<ValueDecl>(ND); 1577 llvm::Constant *Aliasee = CGM.GetWeakRefReference(VD); 1578 return MakeAddrLValue(Aliasee, E->getType(), Alignment); 1579 } 1580 1581 if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) { 1582 // Check if this is a global variable. 1583 if (VD->hasExternalStorage() || VD->isFileVarDecl()) 1584 return EmitGlobalVarDeclLValue(*this, E, VD); 1585 1586 bool isBlockVariable = VD->hasAttr<BlocksAttr>(); 1587 1588 bool NonGCable = VD->hasLocalStorage() && 1589 !VD->getType()->isReferenceType() && 1590 !isBlockVariable; 1591 1592 llvm::Value *V = LocalDeclMap[VD]; 1593 if (!V && VD->isStaticLocal()) 1594 V = CGM.getStaticLocalDeclAddress(VD); 1595 1596 // Use special handling for lambdas. 1597 if (!V) { 1598 if (FieldDecl *FD = LambdaCaptureFields.lookup(VD)) { 1599 QualType LambdaTagType = getContext().getTagDeclType(FD->getParent()); 1600 LValue LambdaLV = MakeNaturalAlignAddrLValue(CXXABIThisValue, 1601 LambdaTagType); 1602 return EmitLValueForField(LambdaLV, FD); 1603 } 1604 1605 assert(isa<BlockDecl>(CurCodeDecl) && E->refersToEnclosingLocal()); 1606 CharUnits alignment = getContext().getDeclAlign(VD); 1607 return MakeAddrLValue(GetAddrOfBlockDecl(VD, isBlockVariable), 1608 E->getType(), alignment); 1609 } 1610 1611 assert(V && "DeclRefExpr not entered in LocalDeclMap?"); 1612 1613 if (isBlockVariable) 1614 V = BuildBlockByrefAddress(V, VD); 1615 1616 LValue LV; 1617 if (VD->getType()->isReferenceType()) { 1618 llvm::LoadInst *LI = Builder.CreateLoad(V); 1619 LI->setAlignment(Alignment.getQuantity()); 1620 V = LI; 1621 LV = MakeNaturalAlignAddrLValue(V, T); 1622 } else { 1623 LV = MakeAddrLValue(V, T, Alignment); 1624 } 1625 1626 if (NonGCable) { 1627 LV.getQuals().removeObjCGCAttr(); 1628 LV.setNonGC(true); 1629 } 1630 setObjCGCLValueClass(getContext(), E, LV); 1631 return LV; 1632 } 1633 1634 if (const FunctionDecl *fn = dyn_cast<FunctionDecl>(ND)) 1635 return EmitFunctionDeclLValue(*this, E, fn); 1636 1637 llvm_unreachable("Unhandled DeclRefExpr"); 1638} 1639 1640LValue CodeGenFunction::EmitUnaryOpLValue(const UnaryOperator *E) { 1641 // __extension__ doesn't affect lvalue-ness. 1642 if (E->getOpcode() == UO_Extension) 1643 return EmitLValue(E->getSubExpr()); 1644 1645 QualType ExprTy = getContext().getCanonicalType(E->getSubExpr()->getType()); 1646 switch (E->getOpcode()) { 1647 default: llvm_unreachable("Unknown unary operator lvalue!"); 1648 case UO_Deref: { 1649 QualType T = E->getSubExpr()->getType()->getPointeeType(); 1650 assert(!T.isNull() && "CodeGenFunction::EmitUnaryOpLValue: Illegal type"); 1651 1652 LValue LV = MakeNaturalAlignAddrLValue(EmitScalarExpr(E->getSubExpr()), T); 1653 LV.getQuals().setAddressSpace(ExprTy.getAddressSpace()); 1654 1655 // We should not generate __weak write barrier on indirect reference 1656 // of a pointer to object; as in void foo (__weak id *param); *param = 0; 1657 // But, we continue to generate __strong write barrier on indirect write 1658 // into a pointer to object. 1659 if (getContext().getLangOpts().ObjC1 && 1660 getContext().getLangOpts().getGC() != LangOptions::NonGC && 1661 LV.isObjCWeak()) 1662 LV.setNonGC(!E->isOBJCGCCandidate(getContext())); 1663 return LV; 1664 } 1665 case UO_Real: 1666 case UO_Imag: { 1667 LValue LV = EmitLValue(E->getSubExpr()); 1668 assert(LV.isSimple() && "real/imag on non-ordinary l-value"); 1669 llvm::Value *Addr = LV.getAddress(); 1670 1671 // __real is valid on scalars. This is a faster way of testing that. 1672 // __imag can only produce an rvalue on scalars. 1673 if (E->getOpcode() == UO_Real && 1674 !cast<llvm::PointerType>(Addr->getType()) 1675 ->getElementType()->isStructTy()) { 1676 assert(E->getSubExpr()->getType()->isArithmeticType()); 1677 return LV; 1678 } 1679 1680 assert(E->getSubExpr()->getType()->isAnyComplexType()); 1681 1682 unsigned Idx = E->getOpcode() == UO_Imag; 1683 return MakeAddrLValue(Builder.CreateStructGEP(LV.getAddress(), 1684 Idx, "idx"), 1685 ExprTy); 1686 } 1687 case UO_PreInc: 1688 case UO_PreDec: { 1689 LValue LV = EmitLValue(E->getSubExpr()); 1690 bool isInc = E->getOpcode() == UO_PreInc; 1691 1692 if (E->getType()->isAnyComplexType()) 1693 EmitComplexPrePostIncDec(E, LV, isInc, true/*isPre*/); 1694 else 1695 EmitScalarPrePostIncDec(E, LV, isInc, true/*isPre*/); 1696 return LV; 1697 } 1698 } 1699} 1700 1701LValue CodeGenFunction::EmitStringLiteralLValue(const StringLiteral *E) { 1702 return MakeAddrLValue(CGM.GetAddrOfConstantStringFromLiteral(E), 1703 E->getType()); 1704} 1705 1706LValue CodeGenFunction::EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E) { 1707 return MakeAddrLValue(CGM.GetAddrOfConstantStringFromObjCEncode(E), 1708 E->getType()); 1709} 1710 1711static llvm::Constant* 1712GetAddrOfConstantWideString(StringRef Str, 1713 const char *GlobalName, 1714 ASTContext &Context, 1715 QualType Ty, SourceLocation Loc, 1716 CodeGenModule &CGM) { 1717 1718 StringLiteral *SL = StringLiteral::Create(Context, 1719 Str, 1720 StringLiteral::Wide, 1721 /*Pascal = */false, 1722 Ty, Loc); 1723 llvm::Constant *C = CGM.GetConstantArrayFromStringLiteral(SL); 1724 llvm::GlobalVariable *GV = 1725 new llvm::GlobalVariable(CGM.getModule(), C->getType(), 1726 !CGM.getLangOpts().WritableStrings, 1727 llvm::GlobalValue::PrivateLinkage, 1728 C, GlobalName); 1729 const unsigned WideAlignment = 1730 Context.getTypeAlignInChars(Ty).getQuantity(); 1731 GV->setAlignment(WideAlignment); 1732 return GV; 1733} 1734 1735static void ConvertUTF8ToWideString(unsigned CharByteWidth, StringRef Source, 1736 SmallString<32>& Target) { 1737 Target.resize(CharByteWidth * (Source.size() + 1)); 1738 char* ResultPtr = &Target[0]; 1739 bool success = ConvertUTF8toWide(CharByteWidth, Source, ResultPtr); 1740 (void)success; 1741 assert(success); 1742 Target.resize(ResultPtr - &Target[0]); 1743} 1744 1745LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) { 1746 switch (E->getIdentType()) { 1747 default: 1748 return EmitUnsupportedLValue(E, "predefined expression"); 1749 1750 case PredefinedExpr::Func: 1751 case PredefinedExpr::Function: 1752 case PredefinedExpr::LFunction: 1753 case PredefinedExpr::PrettyFunction: { 1754 unsigned IdentType = E->getIdentType(); 1755 std::string GlobalVarName; 1756 1757 switch (IdentType) { 1758 default: llvm_unreachable("Invalid type"); 1759 case PredefinedExpr::Func: 1760 GlobalVarName = "__func__."; 1761 break; 1762 case PredefinedExpr::Function: 1763 GlobalVarName = "__FUNCTION__."; 1764 break; 1765 case PredefinedExpr::LFunction: 1766 GlobalVarName = "L__FUNCTION__."; 1767 break; 1768 case PredefinedExpr::PrettyFunction: 1769 GlobalVarName = "__PRETTY_FUNCTION__."; 1770 break; 1771 } 1772 1773 StringRef FnName = CurFn->getName(); 1774 if (FnName.startswith("\01")) 1775 FnName = FnName.substr(1); 1776 GlobalVarName += FnName; 1777 1778 const Decl *CurDecl = CurCodeDecl; 1779 if (CurDecl == 0) 1780 CurDecl = getContext().getTranslationUnitDecl(); 1781 1782 std::string FunctionName = 1783 (isa<BlockDecl>(CurDecl) 1784 ? FnName.str() 1785 : PredefinedExpr::ComputeName((PredefinedExpr::IdentType)IdentType, 1786 CurDecl)); 1787 1788 const Type* ElemType = E->getType()->getArrayElementTypeNoTypeQual(); 1789 llvm::Constant *C; 1790 if (ElemType->isWideCharType()) { 1791 SmallString<32> RawChars; 1792 ConvertUTF8ToWideString( 1793 getContext().getTypeSizeInChars(ElemType).getQuantity(), 1794 FunctionName, RawChars); 1795 C = GetAddrOfConstantWideString(RawChars, 1796 GlobalVarName.c_str(), 1797 getContext(), 1798 E->getType(), 1799 E->getLocation(), 1800 CGM); 1801 } else { 1802 C = CGM.GetAddrOfConstantCString(FunctionName, 1803 GlobalVarName.c_str(), 1804 1); 1805 } 1806 return MakeAddrLValue(C, E->getType()); 1807 } 1808 } 1809} 1810 1811llvm::BasicBlock *CodeGenFunction::getTrapBB() { 1812 const CodeGenOptions &GCO = CGM.getCodeGenOpts(); 1813 1814 // If we are not optimzing, don't collapse all calls to trap in the function 1815 // to the same call, that way, in the debugger they can see which operation 1816 // did in fact fail. If we are optimizing, we collapse all calls to trap down 1817 // to just one per function to save on codesize. 1818 if (GCO.OptimizationLevel && TrapBB) 1819 return TrapBB; 1820 1821 llvm::BasicBlock *Cont = 0; 1822 if (HaveInsertPoint()) { 1823 Cont = createBasicBlock("cont"); 1824 EmitBranch(Cont); 1825 } 1826 TrapBB = createBasicBlock("trap"); 1827 EmitBlock(TrapBB); 1828 1829 llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::trap); 1830 llvm::CallInst *TrapCall = Builder.CreateCall(F); 1831 TrapCall->setDoesNotReturn(); 1832 TrapCall->setDoesNotThrow(); 1833 Builder.CreateUnreachable(); 1834 1835 if (Cont) 1836 EmitBlock(Cont); 1837 return TrapBB; 1838} 1839 1840/// isSimpleArrayDecayOperand - If the specified expr is a simple decay from an 1841/// array to pointer, return the array subexpression. 1842static const Expr *isSimpleArrayDecayOperand(const Expr *E) { 1843 // If this isn't just an array->pointer decay, bail out. 1844 const CastExpr *CE = dyn_cast<CastExpr>(E); 1845 if (CE == 0 || CE->getCastKind() != CK_ArrayToPointerDecay) 1846 return 0; 1847 1848 // If this is a decay from variable width array, bail out. 1849 const Expr *SubExpr = CE->getSubExpr(); 1850 if (SubExpr->getType()->isVariableArrayType()) 1851 return 0; 1852 1853 return SubExpr; 1854} 1855 1856LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) { 1857 // The index must always be an integer, which is not an aggregate. Emit it. 1858 llvm::Value *Idx = EmitScalarExpr(E->getIdx()); 1859 QualType IdxTy = E->getIdx()->getType(); 1860 bool IdxSigned = IdxTy->isSignedIntegerOrEnumerationType(); 1861 1862 // If the base is a vector type, then we are forming a vector element lvalue 1863 // with this subscript. 1864 if (E->getBase()->getType()->isVectorType()) { 1865 // Emit the vector as an lvalue to get its address. 1866 LValue LHS = EmitLValue(E->getBase()); 1867 assert(LHS.isSimple() && "Can only subscript lvalue vectors here!"); 1868 Idx = Builder.CreateIntCast(Idx, Int32Ty, IdxSigned, "vidx"); 1869 return LValue::MakeVectorElt(LHS.getAddress(), Idx, 1870 E->getBase()->getType(), LHS.getAlignment()); 1871 } 1872 1873 // Extend or truncate the index type to 32 or 64-bits. 1874 if (Idx->getType() != IntPtrTy) 1875 Idx = Builder.CreateIntCast(Idx, IntPtrTy, IdxSigned, "idxprom"); 1876 1877 // We know that the pointer points to a type of the correct size, unless the 1878 // size is a VLA or Objective-C interface. 1879 llvm::Value *Address = 0; 1880 CharUnits ArrayAlignment; 1881 if (const VariableArrayType *vla = 1882 getContext().getAsVariableArrayType(E->getType())) { 1883 // The base must be a pointer, which is not an aggregate. Emit 1884 // it. It needs to be emitted first in case it's what captures 1885 // the VLA bounds. 1886 Address = EmitScalarExpr(E->getBase()); 1887 1888 // The element count here is the total number of non-VLA elements. 1889 llvm::Value *numElements = getVLASize(vla).first; 1890 1891 // Effectively, the multiply by the VLA size is part of the GEP. 1892 // GEP indexes are signed, and scaling an index isn't permitted to 1893 // signed-overflow, so we use the same semantics for our explicit 1894 // multiply. We suppress this if overflow is not undefined behavior. 1895 if (getLangOpts().isSignedOverflowDefined()) { 1896 Idx = Builder.CreateMul(Idx, numElements); 1897 Address = Builder.CreateGEP(Address, Idx, "arrayidx"); 1898 } else { 1899 Idx = Builder.CreateNSWMul(Idx, numElements); 1900 Address = Builder.CreateInBoundsGEP(Address, Idx, "arrayidx"); 1901 } 1902 } else if (const ObjCObjectType *OIT = E->getType()->getAs<ObjCObjectType>()){ 1903 // Indexing over an interface, as in "NSString *P; P[4];" 1904 llvm::Value *InterfaceSize = 1905 llvm::ConstantInt::get(Idx->getType(), 1906 getContext().getTypeSizeInChars(OIT).getQuantity()); 1907 1908 Idx = Builder.CreateMul(Idx, InterfaceSize); 1909 1910 // The base must be a pointer, which is not an aggregate. Emit it. 1911 llvm::Value *Base = EmitScalarExpr(E->getBase()); 1912 Address = EmitCastToVoidPtr(Base); 1913 Address = Builder.CreateGEP(Address, Idx, "arrayidx"); 1914 Address = Builder.CreateBitCast(Address, Base->getType()); 1915 } else if (const Expr *Array = isSimpleArrayDecayOperand(E->getBase())) { 1916 // If this is A[i] where A is an array, the frontend will have decayed the 1917 // base to be a ArrayToPointerDecay implicit cast. While correct, it is 1918 // inefficient at -O0 to emit a "gep A, 0, 0" when codegen'ing it, then a 1919 // "gep x, i" here. Emit one "gep A, 0, i". 1920 assert(Array->getType()->isArrayType() && 1921 "Array to pointer decay must have array source type!"); 1922 LValue ArrayLV = EmitLValue(Array); 1923 llvm::Value *ArrayPtr = ArrayLV.getAddress(); 1924 llvm::Value *Zero = llvm::ConstantInt::get(Int32Ty, 0); 1925 llvm::Value *Args[] = { Zero, Idx }; 1926 1927 // Propagate the alignment from the array itself to the result. 1928 ArrayAlignment = ArrayLV.getAlignment(); 1929 1930 if (getContext().getLangOpts().isSignedOverflowDefined()) 1931 Address = Builder.CreateGEP(ArrayPtr, Args, "arrayidx"); 1932 else 1933 Address = Builder.CreateInBoundsGEP(ArrayPtr, Args, "arrayidx"); 1934 } else { 1935 // The base must be a pointer, which is not an aggregate. Emit it. 1936 llvm::Value *Base = EmitScalarExpr(E->getBase()); 1937 if (getContext().getLangOpts().isSignedOverflowDefined()) 1938 Address = Builder.CreateGEP(Base, Idx, "arrayidx"); 1939 else 1940 Address = Builder.CreateInBoundsGEP(Base, Idx, "arrayidx"); 1941 } 1942 1943 QualType T = E->getBase()->getType()->getPointeeType(); 1944 assert(!T.isNull() && 1945 "CodeGenFunction::EmitArraySubscriptExpr(): Illegal base type"); 1946 1947 1948 // Limit the alignment to that of the result type. 1949 LValue LV; 1950 if (!ArrayAlignment.isZero()) { 1951 CharUnits Align = getContext().getTypeAlignInChars(T); 1952 ArrayAlignment = std::min(Align, ArrayAlignment); 1953 LV = MakeAddrLValue(Address, T, ArrayAlignment); 1954 } else { 1955 LV = MakeNaturalAlignAddrLValue(Address, T); 1956 } 1957 1958 LV.getQuals().setAddressSpace(E->getBase()->getType().getAddressSpace()); 1959 1960 if (getContext().getLangOpts().ObjC1 && 1961 getContext().getLangOpts().getGC() != LangOptions::NonGC) { 1962 LV.setNonGC(!E->isOBJCGCCandidate(getContext())); 1963 setObjCGCLValueClass(getContext(), E, LV); 1964 } 1965 return LV; 1966} 1967 1968static 1969llvm::Constant *GenerateConstantVector(CGBuilderTy &Builder, 1970 SmallVector<unsigned, 4> &Elts) { 1971 SmallVector<llvm::Constant*, 4> CElts; 1972 for (unsigned i = 0, e = Elts.size(); i != e; ++i) 1973 CElts.push_back(Builder.getInt32(Elts[i])); 1974 1975 return llvm::ConstantVector::get(CElts); 1976} 1977 1978LValue CodeGenFunction:: 1979EmitExtVectorElementExpr(const ExtVectorElementExpr *E) { 1980 // Emit the base vector as an l-value. 1981 LValue Base; 1982 1983 // ExtVectorElementExpr's base can either be a vector or pointer to vector. 1984 if (E->isArrow()) { 1985 // If it is a pointer to a vector, emit the address and form an lvalue with 1986 // it. 1987 llvm::Value *Ptr = EmitScalarExpr(E->getBase()); 1988 const PointerType *PT = E->getBase()->getType()->getAs<PointerType>(); 1989 Base = MakeAddrLValue(Ptr, PT->getPointeeType()); 1990 Base.getQuals().removeObjCGCAttr(); 1991 } else if (E->getBase()->isGLValue()) { 1992 // Otherwise, if the base is an lvalue ( as in the case of foo.x.x), 1993 // emit the base as an lvalue. 1994 assert(E->getBase()->getType()->isVectorType()); 1995 Base = EmitLValue(E->getBase()); 1996 } else { 1997 // Otherwise, the base is a normal rvalue (as in (V+V).x), emit it as such. 1998 assert(E->getBase()->getType()->isVectorType() && 1999 "Result must be a vector"); 2000 llvm::Value *Vec = EmitScalarExpr(E->getBase()); 2001 2002 // Store the vector to memory (because LValue wants an address). 2003 llvm::Value *VecMem = CreateMemTemp(E->getBase()->getType()); 2004 Builder.CreateStore(Vec, VecMem); 2005 Base = MakeAddrLValue(VecMem, E->getBase()->getType()); 2006 } 2007 2008 QualType type = 2009 E->getType().withCVRQualifiers(Base.getQuals().getCVRQualifiers()); 2010 2011 // Encode the element access list into a vector of unsigned indices. 2012 SmallVector<unsigned, 4> Indices; 2013 E->getEncodedElementAccess(Indices); 2014 2015 if (Base.isSimple()) { 2016 llvm::Constant *CV = GenerateConstantVector(Builder, Indices); 2017 return LValue::MakeExtVectorElt(Base.getAddress(), CV, type, 2018 Base.getAlignment()); 2019 } 2020 assert(Base.isExtVectorElt() && "Can only subscript lvalue vec elts here!"); 2021 2022 llvm::Constant *BaseElts = Base.getExtVectorElts(); 2023 SmallVector<llvm::Constant *, 4> CElts; 2024 2025 for (unsigned i = 0, e = Indices.size(); i != e; ++i) 2026 CElts.push_back(BaseElts->getAggregateElement(Indices[i])); 2027 llvm::Constant *CV = llvm::ConstantVector::get(CElts); 2028 return LValue::MakeExtVectorElt(Base.getExtVectorAddr(), CV, type, 2029 Base.getAlignment()); 2030} 2031 2032LValue CodeGenFunction::EmitMemberExpr(const MemberExpr *E) { 2033 Expr *BaseExpr = E->getBase(); 2034 2035 // If this is s.x, emit s as an lvalue. If it is s->x, emit s as a scalar. 2036 LValue BaseLV; 2037 if (E->isArrow()) 2038 BaseLV = MakeNaturalAlignAddrLValue(EmitScalarExpr(BaseExpr), 2039 BaseExpr->getType()->getPointeeType()); 2040 else 2041 BaseLV = EmitLValue(BaseExpr); 2042 2043 NamedDecl *ND = E->getMemberDecl(); 2044 if (FieldDecl *Field = dyn_cast<FieldDecl>(ND)) { 2045 LValue LV = EmitLValueForField(BaseLV, Field); 2046 setObjCGCLValueClass(getContext(), E, LV); 2047 return LV; 2048 } 2049 2050 if (VarDecl *VD = dyn_cast<VarDecl>(ND)) 2051 return EmitGlobalVarDeclLValue(*this, E, VD); 2052 2053 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) 2054 return EmitFunctionDeclLValue(*this, E, FD); 2055 2056 llvm_unreachable("Unhandled member declaration!"); 2057} 2058 2059/// EmitLValueForAnonRecordField - Given that the field is a member of 2060/// an anonymous struct or union buried inside a record, and given 2061/// that the base value is a pointer to the enclosing record, derive 2062/// an lvalue for the ultimate field. 2063LValue CodeGenFunction::EmitLValueForAnonRecordField(llvm::Value *BaseValue, 2064 const IndirectFieldDecl *Field, 2065 unsigned CVRQualifiers) { 2066 IndirectFieldDecl::chain_iterator I = Field->chain_begin(), 2067 IEnd = Field->chain_end(); 2068 while (true) { 2069 QualType RecordTy = 2070 getContext().getTypeDeclType(cast<FieldDecl>(*I)->getParent()); 2071 LValue LV = EmitLValueForField(MakeAddrLValue(BaseValue, RecordTy), 2072 cast<FieldDecl>(*I)); 2073 if (++I == IEnd) return LV; 2074 2075 assert(LV.isSimple()); 2076 BaseValue = LV.getAddress(); 2077 CVRQualifiers |= LV.getVRQualifiers(); 2078 } 2079} 2080 2081LValue CodeGenFunction::EmitLValueForField(LValue base, 2082 const FieldDecl *field) { 2083 if (field->isBitField()) { 2084 const CGRecordLayout &RL = 2085 CGM.getTypes().getCGRecordLayout(field->getParent()); 2086 const CGBitFieldInfo &Info = RL.getBitFieldInfo(field); 2087 QualType fieldType = 2088 field->getType().withCVRQualifiers(base.getVRQualifiers()); 2089 return LValue::MakeBitfield(base.getAddress(), Info, fieldType, 2090 base.getAlignment()); 2091 } 2092 2093 const RecordDecl *rec = field->getParent(); 2094 QualType type = field->getType(); 2095 CharUnits alignment = getContext().getDeclAlign(field); 2096 2097 // FIXME: It should be impossible to have an LValue without alignment for a 2098 // complete type. 2099 if (!base.getAlignment().isZero()) 2100 alignment = std::min(alignment, base.getAlignment()); 2101 2102 bool mayAlias = rec->hasAttr<MayAliasAttr>(); 2103 2104 llvm::Value *addr = base.getAddress(); 2105 unsigned cvr = base.getVRQualifiers(); 2106 if (rec->isUnion()) { 2107 // For unions, there is no pointer adjustment. 2108 assert(!type->isReferenceType() && "union has reference member"); 2109 } else { 2110 // For structs, we GEP to the field that the record layout suggests. 2111 unsigned idx = CGM.getTypes().getCGRecordLayout(rec).getLLVMFieldNo(field); 2112 addr = Builder.CreateStructGEP(addr, idx, field->getName()); 2113 2114 // If this is a reference field, load the reference right now. 2115 if (const ReferenceType *refType = type->getAs<ReferenceType>()) { 2116 llvm::LoadInst *load = Builder.CreateLoad(addr, "ref"); 2117 if (cvr & Qualifiers::Volatile) load->setVolatile(true); 2118 load->setAlignment(alignment.getQuantity()); 2119 2120 if (CGM.shouldUseTBAA()) { 2121 llvm::MDNode *tbaa; 2122 if (mayAlias) 2123 tbaa = CGM.getTBAAInfo(getContext().CharTy); 2124 else 2125 tbaa = CGM.getTBAAInfo(type); 2126 CGM.DecorateInstruction(load, tbaa); 2127 } 2128 2129 addr = load; 2130 mayAlias = false; 2131 type = refType->getPointeeType(); 2132 if (type->isIncompleteType()) 2133 alignment = CharUnits(); 2134 else 2135 alignment = getContext().getTypeAlignInChars(type); 2136 cvr = 0; // qualifiers don't recursively apply to referencee 2137 } 2138 } 2139 2140 // Make sure that the address is pointing to the right type. This is critical 2141 // for both unions and structs. A union needs a bitcast, a struct element 2142 // will need a bitcast if the LLVM type laid out doesn't match the desired 2143 // type. 2144 addr = EmitBitCastOfLValueToProperType(*this, addr, 2145 CGM.getTypes().ConvertTypeForMem(type), 2146 field->getName()); 2147 2148 if (field->hasAttr<AnnotateAttr>()) 2149 addr = EmitFieldAnnotations(field, addr); 2150 2151 LValue LV = MakeAddrLValue(addr, type, alignment); 2152 LV.getQuals().addCVRQualifiers(cvr); 2153 2154 // __weak attribute on a field is ignored. 2155 if (LV.getQuals().getObjCGCAttr() == Qualifiers::Weak) 2156 LV.getQuals().removeObjCGCAttr(); 2157 2158 // Fields of may_alias structs act like 'char' for TBAA purposes. 2159 // FIXME: this should get propagated down through anonymous structs 2160 // and unions. 2161 if (mayAlias && LV.getTBAAInfo()) 2162 LV.setTBAAInfo(CGM.getTBAAInfo(getContext().CharTy)); 2163 2164 return LV; 2165} 2166 2167LValue 2168CodeGenFunction::EmitLValueForFieldInitialization(LValue Base, 2169 const FieldDecl *Field) { 2170 QualType FieldType = Field->getType(); 2171 2172 if (!FieldType->isReferenceType()) 2173 return EmitLValueForField(Base, Field); 2174 2175 const CGRecordLayout &RL = 2176 CGM.getTypes().getCGRecordLayout(Field->getParent()); 2177 unsigned idx = RL.getLLVMFieldNo(Field); 2178 llvm::Value *V = Builder.CreateStructGEP(Base.getAddress(), idx); 2179 assert(!FieldType.getObjCGCAttr() && "fields cannot have GC attrs"); 2180 2181 // Make sure that the address is pointing to the right type. This is critical 2182 // for both unions and structs. A union needs a bitcast, a struct element 2183 // will need a bitcast if the LLVM type laid out doesn't match the desired 2184 // type. 2185 llvm::Type *llvmType = ConvertTypeForMem(FieldType); 2186 V = EmitBitCastOfLValueToProperType(*this, V, llvmType, Field->getName()); 2187 2188 CharUnits Alignment = getContext().getDeclAlign(Field); 2189 2190 // FIXME: It should be impossible to have an LValue without alignment for a 2191 // complete type. 2192 if (!Base.getAlignment().isZero()) 2193 Alignment = std::min(Alignment, Base.getAlignment()); 2194 2195 return MakeAddrLValue(V, FieldType, Alignment); 2196} 2197 2198LValue CodeGenFunction::EmitCompoundLiteralLValue(const CompoundLiteralExpr *E){ 2199 if (E->isFileScope()) { 2200 llvm::Value *GlobalPtr = CGM.GetAddrOfConstantCompoundLiteral(E); 2201 return MakeAddrLValue(GlobalPtr, E->getType()); 2202 } 2203 if (E->getType()->isVariablyModifiedType()) 2204 // make sure to emit the VLA size. 2205 EmitVariablyModifiedType(E->getType()); 2206 2207 llvm::Value *DeclPtr = CreateMemTemp(E->getType(), ".compoundliteral"); 2208 const Expr *InitExpr = E->getInitializer(); 2209 LValue Result = MakeAddrLValue(DeclPtr, E->getType()); 2210 2211 EmitAnyExprToMem(InitExpr, DeclPtr, E->getType().getQualifiers(), 2212 /*Init*/ true); 2213 2214 return Result; 2215} 2216 2217LValue CodeGenFunction::EmitInitListLValue(const InitListExpr *E) { 2218 if (!E->isGLValue()) 2219 // Initializing an aggregate temporary in C++11: T{...}. 2220 return EmitAggExprToLValue(E); 2221 2222 // An lvalue initializer list must be initializing a reference. 2223 assert(E->getNumInits() == 1 && "reference init with multiple values"); 2224 return EmitLValue(E->getInit(0)); 2225} 2226 2227LValue CodeGenFunction:: 2228EmitConditionalOperatorLValue(const AbstractConditionalOperator *expr) { 2229 if (!expr->isGLValue()) { 2230 // ?: here should be an aggregate. 2231 assert((hasAggregateLLVMType(expr->getType()) && 2232 !expr->getType()->isAnyComplexType()) && 2233 "Unexpected conditional operator!"); 2234 return EmitAggExprToLValue(expr); 2235 } 2236 2237 OpaqueValueMapping binding(*this, expr); 2238 2239 const Expr *condExpr = expr->getCond(); 2240 bool CondExprBool; 2241 if (ConstantFoldsToSimpleInteger(condExpr, CondExprBool)) { 2242 const Expr *live = expr->getTrueExpr(), *dead = expr->getFalseExpr(); 2243 if (!CondExprBool) std::swap(live, dead); 2244 2245 if (!ContainsLabel(dead)) 2246 return EmitLValue(live); 2247 } 2248 2249 llvm::BasicBlock *lhsBlock = createBasicBlock("cond.true"); 2250 llvm::BasicBlock *rhsBlock = createBasicBlock("cond.false"); 2251 llvm::BasicBlock *contBlock = createBasicBlock("cond.end"); 2252 2253 ConditionalEvaluation eval(*this); 2254 EmitBranchOnBoolExpr(condExpr, lhsBlock, rhsBlock); 2255 2256 // Any temporaries created here are conditional. 2257 EmitBlock(lhsBlock); 2258 eval.begin(*this); 2259 LValue lhs = EmitLValue(expr->getTrueExpr()); 2260 eval.end(*this); 2261 2262 if (!lhs.isSimple()) 2263 return EmitUnsupportedLValue(expr, "conditional operator"); 2264 2265 lhsBlock = Builder.GetInsertBlock(); 2266 Builder.CreateBr(contBlock); 2267 2268 // Any temporaries created here are conditional. 2269 EmitBlock(rhsBlock); 2270 eval.begin(*this); 2271 LValue rhs = EmitLValue(expr->getFalseExpr()); 2272 eval.end(*this); 2273 if (!rhs.isSimple()) 2274 return EmitUnsupportedLValue(expr, "conditional operator"); 2275 rhsBlock = Builder.GetInsertBlock(); 2276 2277 EmitBlock(contBlock); 2278 2279 llvm::PHINode *phi = Builder.CreatePHI(lhs.getAddress()->getType(), 2, 2280 "cond-lvalue"); 2281 phi->addIncoming(lhs.getAddress(), lhsBlock); 2282 phi->addIncoming(rhs.getAddress(), rhsBlock); 2283 return MakeAddrLValue(phi, expr->getType()); 2284} 2285 2286/// EmitCastLValue - Casts are never lvalues unless that cast is to a reference 2287/// type. If the cast is to a reference, we can have the usual lvalue result, 2288/// otherwise if a cast is needed by the code generator in an lvalue context, 2289/// then it must mean that we need the address of an aggregate in order to 2290/// access one of its members. This can happen for all the reasons that casts 2291/// are permitted with aggregate result, including noop aggregate casts, and 2292/// cast from scalar to union. 2293LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) { 2294 switch (E->getCastKind()) { 2295 case CK_ToVoid: 2296 return EmitUnsupportedLValue(E, "unexpected cast lvalue"); 2297 2298 case CK_Dependent: 2299 llvm_unreachable("dependent cast kind in IR gen!"); 2300 2301 // These two casts are currently treated as no-ops, although they could 2302 // potentially be real operations depending on the target's ABI. 2303 case CK_NonAtomicToAtomic: 2304 case CK_AtomicToNonAtomic: 2305 2306 case CK_NoOp: 2307 case CK_LValueToRValue: 2308 if (!E->getSubExpr()->Classify(getContext()).isPRValue() 2309 || E->getType()->isRecordType()) 2310 return EmitLValue(E->getSubExpr()); 2311 // Fall through to synthesize a temporary. 2312 2313 case CK_BitCast: 2314 case CK_ArrayToPointerDecay: 2315 case CK_FunctionToPointerDecay: 2316 case CK_NullToMemberPointer: 2317 case CK_NullToPointer: 2318 case CK_IntegralToPointer: 2319 case CK_PointerToIntegral: 2320 case CK_PointerToBoolean: 2321 case CK_VectorSplat: 2322 case CK_IntegralCast: 2323 case CK_IntegralToBoolean: 2324 case CK_IntegralToFloating: 2325 case CK_FloatingToIntegral: 2326 case CK_FloatingToBoolean: 2327 case CK_FloatingCast: 2328 case CK_FloatingRealToComplex: 2329 case CK_FloatingComplexToReal: 2330 case CK_FloatingComplexToBoolean: 2331 case CK_FloatingComplexCast: 2332 case CK_FloatingComplexToIntegralComplex: 2333 case CK_IntegralRealToComplex: 2334 case CK_IntegralComplexToReal: 2335 case CK_IntegralComplexToBoolean: 2336 case CK_IntegralComplexCast: 2337 case CK_IntegralComplexToFloatingComplex: 2338 case CK_DerivedToBaseMemberPointer: 2339 case CK_BaseToDerivedMemberPointer: 2340 case CK_MemberPointerToBoolean: 2341 case CK_ReinterpretMemberPointer: 2342 case CK_AnyPointerToBlockPointerCast: 2343 case CK_ARCProduceObject: 2344 case CK_ARCConsumeObject: 2345 case CK_ARCReclaimReturnedObject: 2346 case CK_ARCExtendBlockObject: 2347 case CK_CopyAndAutoreleaseBlockObject: { 2348 // These casts only produce lvalues when we're binding a reference to a 2349 // temporary realized from a (converted) pure rvalue. Emit the expression 2350 // as a value, copy it into a temporary, and return an lvalue referring to 2351 // that temporary. 2352 llvm::Value *V = CreateMemTemp(E->getType(), "ref.temp"); 2353 EmitAnyExprToMem(E, V, E->getType().getQualifiers(), false); 2354 return MakeAddrLValue(V, E->getType()); 2355 } 2356 2357 case CK_Dynamic: { 2358 LValue LV = EmitLValue(E->getSubExpr()); 2359 llvm::Value *V = LV.getAddress(); 2360 const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(E); 2361 return MakeAddrLValue(EmitDynamicCast(V, DCE), E->getType()); 2362 } 2363 2364 case CK_ConstructorConversion: 2365 case CK_UserDefinedConversion: 2366 case CK_CPointerToObjCPointerCast: 2367 case CK_BlockPointerToObjCPointerCast: 2368 return EmitLValue(E->getSubExpr()); 2369 2370 case CK_UncheckedDerivedToBase: 2371 case CK_DerivedToBase: { 2372 const RecordType *DerivedClassTy = 2373 E->getSubExpr()->getType()->getAs<RecordType>(); 2374 CXXRecordDecl *DerivedClassDecl = 2375 cast<CXXRecordDecl>(DerivedClassTy->getDecl()); 2376 2377 LValue LV = EmitLValue(E->getSubExpr()); 2378 llvm::Value *This = LV.getAddress(); 2379 2380 // Perform the derived-to-base conversion 2381 llvm::Value *Base = 2382 GetAddressOfBaseClass(This, DerivedClassDecl, 2383 E->path_begin(), E->path_end(), 2384 /*NullCheckValue=*/false); 2385 2386 return MakeAddrLValue(Base, E->getType()); 2387 } 2388 case CK_ToUnion: 2389 return EmitAggExprToLValue(E); 2390 case CK_BaseToDerived: { 2391 const RecordType *DerivedClassTy = E->getType()->getAs<RecordType>(); 2392 CXXRecordDecl *DerivedClassDecl = 2393 cast<CXXRecordDecl>(DerivedClassTy->getDecl()); 2394 2395 LValue LV = EmitLValue(E->getSubExpr()); 2396 2397 // Perform the base-to-derived conversion 2398 llvm::Value *Derived = 2399 GetAddressOfDerivedClass(LV.getAddress(), DerivedClassDecl, 2400 E->path_begin(), E->path_end(), 2401 /*NullCheckValue=*/false); 2402 2403 return MakeAddrLValue(Derived, E->getType()); 2404 } 2405 case CK_LValueBitCast: { 2406 // This must be a reinterpret_cast (or c-style equivalent). 2407 const ExplicitCastExpr *CE = cast<ExplicitCastExpr>(E); 2408 2409 LValue LV = EmitLValue(E->getSubExpr()); 2410 llvm::Value *V = Builder.CreateBitCast(LV.getAddress(), 2411 ConvertType(CE->getTypeAsWritten())); 2412 return MakeAddrLValue(V, E->getType()); 2413 } 2414 case CK_ObjCObjectLValueCast: { 2415 LValue LV = EmitLValue(E->getSubExpr()); 2416 QualType ToType = getContext().getLValueReferenceType(E->getType()); 2417 llvm::Value *V = Builder.CreateBitCast(LV.getAddress(), 2418 ConvertType(ToType)); 2419 return MakeAddrLValue(V, E->getType()); 2420 } 2421 } 2422 2423 llvm_unreachable("Unhandled lvalue cast kind?"); 2424} 2425 2426LValue CodeGenFunction::EmitNullInitializationLValue( 2427 const CXXScalarValueInitExpr *E) { 2428 QualType Ty = E->getType(); 2429 LValue LV = MakeAddrLValue(CreateMemTemp(Ty), Ty); 2430 EmitNullInitialization(LV.getAddress(), Ty); 2431 return LV; 2432} 2433 2434LValue CodeGenFunction::EmitOpaqueValueLValue(const OpaqueValueExpr *e) { 2435 assert(OpaqueValueMappingData::shouldBindAsLValue(e)); 2436 return getOpaqueLValueMapping(e); 2437} 2438 2439LValue CodeGenFunction::EmitMaterializeTemporaryExpr( 2440 const MaterializeTemporaryExpr *E) { 2441 RValue RV = EmitReferenceBindingToExpr(E, /*InitializedDecl=*/0); 2442 return MakeAddrLValue(RV.getScalarVal(), E->getType()); 2443} 2444 2445RValue CodeGenFunction::EmitRValueForField(LValue LV, 2446 const FieldDecl *FD) { 2447 QualType FT = FD->getType(); 2448 LValue FieldLV = EmitLValueForField(LV, FD); 2449 if (FT->isAnyComplexType()) 2450 return RValue::getComplex( 2451 LoadComplexFromAddr(FieldLV.getAddress(), 2452 FieldLV.isVolatileQualified())); 2453 else if (CodeGenFunction::hasAggregateLLVMType(FT)) 2454 return FieldLV.asAggregateRValue(); 2455 2456 return EmitLoadOfLValue(FieldLV); 2457} 2458 2459//===--------------------------------------------------------------------===// 2460// Expression Emission 2461//===--------------------------------------------------------------------===// 2462 2463RValue CodeGenFunction::EmitCallExpr(const CallExpr *E, 2464 ReturnValueSlot ReturnValue) { 2465 if (CGDebugInfo *DI = getDebugInfo()) 2466 DI->EmitLocation(Builder, E->getLocStart()); 2467 2468 // Builtins never have block type. 2469 if (E->getCallee()->getType()->isBlockPointerType()) 2470 return EmitBlockCallExpr(E, ReturnValue); 2471 2472 if (const CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(E)) 2473 return EmitCXXMemberCallExpr(CE, ReturnValue); 2474 2475 if (const CUDAKernelCallExpr *CE = dyn_cast<CUDAKernelCallExpr>(E)) 2476 return EmitCUDAKernelCallExpr(CE, ReturnValue); 2477 2478 const Decl *TargetDecl = E->getCalleeDecl(); 2479 if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(TargetDecl)) { 2480 if (unsigned builtinID = FD->getBuiltinID()) 2481 return EmitBuiltinExpr(FD, builtinID, E); 2482 } 2483 2484 if (const CXXOperatorCallExpr *CE = dyn_cast<CXXOperatorCallExpr>(E)) 2485 if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(TargetDecl)) 2486 return EmitCXXOperatorMemberCallExpr(CE, MD, ReturnValue); 2487 2488 if (const CXXPseudoDestructorExpr *PseudoDtor 2489 = dyn_cast<CXXPseudoDestructorExpr>(E->getCallee()->IgnoreParens())) { 2490 QualType DestroyedType = PseudoDtor->getDestroyedType(); 2491 if (getContext().getLangOpts().ObjCAutoRefCount && 2492 DestroyedType->isObjCLifetimeType() && 2493 (DestroyedType.getObjCLifetime() == Qualifiers::OCL_Strong || 2494 DestroyedType.getObjCLifetime() == Qualifiers::OCL_Weak)) { 2495 // Automatic Reference Counting: 2496 // If the pseudo-expression names a retainable object with weak or 2497 // strong lifetime, the object shall be released. 2498 Expr *BaseExpr = PseudoDtor->getBase(); 2499 llvm::Value *BaseValue = NULL; 2500 Qualifiers BaseQuals; 2501 2502 // If this is s.x, emit s as an lvalue. If it is s->x, emit s as a scalar. 2503 if (PseudoDtor->isArrow()) { 2504 BaseValue = EmitScalarExpr(BaseExpr); 2505 const PointerType *PTy = BaseExpr->getType()->getAs<PointerType>(); 2506 BaseQuals = PTy->getPointeeType().getQualifiers(); 2507 } else { 2508 LValue BaseLV = EmitLValue(BaseExpr); 2509 BaseValue = BaseLV.getAddress(); 2510 QualType BaseTy = BaseExpr->getType(); 2511 BaseQuals = BaseTy.getQualifiers(); 2512 } 2513 2514 switch (PseudoDtor->getDestroyedType().getObjCLifetime()) { 2515 case Qualifiers::OCL_None: 2516 case Qualifiers::OCL_ExplicitNone: 2517 case Qualifiers::OCL_Autoreleasing: 2518 break; 2519 2520 case Qualifiers::OCL_Strong: 2521 EmitARCRelease(Builder.CreateLoad(BaseValue, 2522 PseudoDtor->getDestroyedType().isVolatileQualified()), 2523 /*precise*/ true); 2524 break; 2525 2526 case Qualifiers::OCL_Weak: 2527 EmitARCDestroyWeak(BaseValue); 2528 break; 2529 } 2530 } else { 2531 // C++ [expr.pseudo]p1: 2532 // The result shall only be used as the operand for the function call 2533 // operator (), and the result of such a call has type void. The only 2534 // effect is the evaluation of the postfix-expression before the dot or 2535 // arrow. 2536 EmitScalarExpr(E->getCallee()); 2537 } 2538 2539 return RValue::get(0); 2540 } 2541 2542 llvm::Value *Callee = EmitScalarExpr(E->getCallee()); 2543 return EmitCall(E->getCallee()->getType(), Callee, ReturnValue, 2544 E->arg_begin(), E->arg_end(), TargetDecl); 2545} 2546 2547LValue CodeGenFunction::EmitBinaryOperatorLValue(const BinaryOperator *E) { 2548 // Comma expressions just emit their LHS then their RHS as an l-value. 2549 if (E->getOpcode() == BO_Comma) { 2550 EmitIgnoredExpr(E->getLHS()); 2551 EnsureInsertPoint(); 2552 return EmitLValue(E->getRHS()); 2553 } 2554 2555 if (E->getOpcode() == BO_PtrMemD || 2556 E->getOpcode() == BO_PtrMemI) 2557 return EmitPointerToDataMemberBinaryExpr(E); 2558 2559 assert(E->getOpcode() == BO_Assign && "unexpected binary l-value"); 2560 2561 // Note that in all of these cases, __block variables need the RHS 2562 // evaluated first just in case the variable gets moved by the RHS. 2563 2564 if (!hasAggregateLLVMType(E->getType())) { 2565 switch (E->getLHS()->getType().getObjCLifetime()) { 2566 case Qualifiers::OCL_Strong: 2567 return EmitARCStoreStrong(E, /*ignored*/ false).first; 2568 2569 case Qualifiers::OCL_Autoreleasing: 2570 return EmitARCStoreAutoreleasing(E).first; 2571 2572 // No reason to do any of these differently. 2573 case Qualifiers::OCL_None: 2574 case Qualifiers::OCL_ExplicitNone: 2575 case Qualifiers::OCL_Weak: 2576 break; 2577 } 2578 2579 RValue RV = EmitAnyExpr(E->getRHS()); 2580 LValue LV = EmitLValue(E->getLHS()); 2581 EmitStoreThroughLValue(RV, LV); 2582 return LV; 2583 } 2584 2585 if (E->getType()->isAnyComplexType()) 2586 return EmitComplexAssignmentLValue(E); 2587 2588 return EmitAggExprToLValue(E); 2589} 2590 2591LValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) { 2592 RValue RV = EmitCallExpr(E); 2593 2594 if (!RV.isScalar()) 2595 return MakeAddrLValue(RV.getAggregateAddr(), E->getType()); 2596 2597 assert(E->getCallReturnType()->isReferenceType() && 2598 "Can't have a scalar return unless the return type is a " 2599 "reference type!"); 2600 2601 return MakeAddrLValue(RV.getScalarVal(), E->getType()); 2602} 2603 2604LValue CodeGenFunction::EmitVAArgExprLValue(const VAArgExpr *E) { 2605 // FIXME: This shouldn't require another copy. 2606 return EmitAggExprToLValue(E); 2607} 2608 2609LValue CodeGenFunction::EmitCXXConstructLValue(const CXXConstructExpr *E) { 2610 assert(E->getType()->getAsCXXRecordDecl()->hasTrivialDestructor() 2611 && "binding l-value to type which needs a temporary"); 2612 AggValueSlot Slot = CreateAggTemp(E->getType()); 2613 EmitCXXConstructExpr(E, Slot); 2614 return MakeAddrLValue(Slot.getAddr(), E->getType()); 2615} 2616 2617LValue 2618CodeGenFunction::EmitCXXTypeidLValue(const CXXTypeidExpr *E) { 2619 return MakeAddrLValue(EmitCXXTypeidExpr(E), E->getType()); 2620} 2621 2622LValue 2623CodeGenFunction::EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E) { 2624 AggValueSlot Slot = CreateAggTemp(E->getType(), "temp.lvalue"); 2625 Slot.setExternallyDestructed(); 2626 EmitAggExpr(E->getSubExpr(), Slot); 2627 EmitCXXTemporary(E->getTemporary(), E->getType(), Slot.getAddr()); 2628 return MakeAddrLValue(Slot.getAddr(), E->getType()); 2629} 2630 2631LValue 2632CodeGenFunction::EmitLambdaLValue(const LambdaExpr *E) { 2633 AggValueSlot Slot = CreateAggTemp(E->getType(), "temp.lvalue"); 2634 EmitLambdaExpr(E, Slot); 2635 return MakeAddrLValue(Slot.getAddr(), E->getType()); 2636} 2637 2638LValue CodeGenFunction::EmitObjCMessageExprLValue(const ObjCMessageExpr *E) { 2639 RValue RV = EmitObjCMessageExpr(E); 2640 2641 if (!RV.isScalar()) 2642 return MakeAddrLValue(RV.getAggregateAddr(), E->getType()); 2643 2644 assert(E->getMethodDecl()->getResultType()->isReferenceType() && 2645 "Can't have a scalar return unless the return type is a " 2646 "reference type!"); 2647 2648 return MakeAddrLValue(RV.getScalarVal(), E->getType()); 2649} 2650 2651LValue CodeGenFunction::EmitObjCSelectorLValue(const ObjCSelectorExpr *E) { 2652 llvm::Value *V = 2653 CGM.getObjCRuntime().GetSelector(Builder, E->getSelector(), true); 2654 return MakeAddrLValue(V, E->getType()); 2655} 2656 2657llvm::Value *CodeGenFunction::EmitIvarOffset(const ObjCInterfaceDecl *Interface, 2658 const ObjCIvarDecl *Ivar) { 2659 return CGM.getObjCRuntime().EmitIvarOffset(*this, Interface, Ivar); 2660} 2661 2662LValue CodeGenFunction::EmitLValueForIvar(QualType ObjectTy, 2663 llvm::Value *BaseValue, 2664 const ObjCIvarDecl *Ivar, 2665 unsigned CVRQualifiers) { 2666 return CGM.getObjCRuntime().EmitObjCValueForIvar(*this, ObjectTy, BaseValue, 2667 Ivar, CVRQualifiers); 2668} 2669 2670LValue CodeGenFunction::EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E) { 2671 // FIXME: A lot of the code below could be shared with EmitMemberExpr. 2672 llvm::Value *BaseValue = 0; 2673 const Expr *BaseExpr = E->getBase(); 2674 Qualifiers BaseQuals; 2675 QualType ObjectTy; 2676 if (E->isArrow()) { 2677 BaseValue = EmitScalarExpr(BaseExpr); 2678 ObjectTy = BaseExpr->getType()->getPointeeType(); 2679 BaseQuals = ObjectTy.getQualifiers(); 2680 } else { 2681 LValue BaseLV = EmitLValue(BaseExpr); 2682 // FIXME: this isn't right for bitfields. 2683 BaseValue = BaseLV.getAddress(); 2684 ObjectTy = BaseExpr->getType(); 2685 BaseQuals = ObjectTy.getQualifiers(); 2686 } 2687 2688 LValue LV = 2689 EmitLValueForIvar(ObjectTy, BaseValue, E->getDecl(), 2690 BaseQuals.getCVRQualifiers()); 2691 setObjCGCLValueClass(getContext(), E, LV); 2692 return LV; 2693} 2694 2695LValue CodeGenFunction::EmitStmtExprLValue(const StmtExpr *E) { 2696 // Can only get l-value for message expression returning aggregate type 2697 RValue RV = EmitAnyExprToTemp(E); 2698 return MakeAddrLValue(RV.getAggregateAddr(), E->getType()); 2699} 2700 2701RValue CodeGenFunction::EmitCall(QualType CalleeType, llvm::Value *Callee, 2702 ReturnValueSlot ReturnValue, 2703 CallExpr::const_arg_iterator ArgBeg, 2704 CallExpr::const_arg_iterator ArgEnd, 2705 const Decl *TargetDecl) { 2706 // Get the actual function type. The callee type will always be a pointer to 2707 // function type or a block pointer type. 2708 assert(CalleeType->isFunctionPointerType() && 2709 "Call must have function pointer type!"); 2710 2711 CalleeType = getContext().getCanonicalType(CalleeType); 2712 2713 const FunctionType *FnType 2714 = cast<FunctionType>(cast<PointerType>(CalleeType)->getPointeeType()); 2715 2716 CallArgList Args; 2717 EmitCallArgs(Args, dyn_cast<FunctionProtoType>(FnType), ArgBeg, ArgEnd); 2718 2719 const CGFunctionInfo &FnInfo = 2720 CGM.getTypes().arrangeFunctionCall(Args, FnType); 2721 2722 // C99 6.5.2.2p6: 2723 // If the expression that denotes the called function has a type 2724 // that does not include a prototype, [the default argument 2725 // promotions are performed]. If the number of arguments does not 2726 // equal the number of parameters, the behavior is undefined. If 2727 // the function is defined with a type that includes a prototype, 2728 // and either the prototype ends with an ellipsis (, ...) or the 2729 // types of the arguments after promotion are not compatible with 2730 // the types of the parameters, the behavior is undefined. If the 2731 // function is defined with a type that does not include a 2732 // prototype, and the types of the arguments after promotion are 2733 // not compatible with those of the parameters after promotion, 2734 // the behavior is undefined [except in some trivial cases]. 2735 // That is, in the general case, we should assume that a call 2736 // through an unprototyped function type works like a *non-variadic* 2737 // call. The way we make this work is to cast to the exact type 2738 // of the promoted arguments. 2739 if (isa<FunctionNoProtoType>(FnType) && !FnInfo.isVariadic()) { 2740 llvm::Type *CalleeTy = getTypes().GetFunctionType(FnInfo); 2741 CalleeTy = CalleeTy->getPointerTo(); 2742 Callee = Builder.CreateBitCast(Callee, CalleeTy, "callee.knr.cast"); 2743 } 2744 2745 return EmitCall(FnInfo, Callee, ReturnValue, Args, TargetDecl); 2746} 2747 2748LValue CodeGenFunction:: 2749EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E) { 2750 llvm::Value *BaseV; 2751 if (E->getOpcode() == BO_PtrMemI) 2752 BaseV = EmitScalarExpr(E->getLHS()); 2753 else 2754 BaseV = EmitLValue(E->getLHS()).getAddress(); 2755 2756 llvm::Value *OffsetV = EmitScalarExpr(E->getRHS()); 2757 2758 const MemberPointerType *MPT 2759 = E->getRHS()->getType()->getAs<MemberPointerType>(); 2760 2761 llvm::Value *AddV = 2762 CGM.getCXXABI().EmitMemberDataPointerAddress(*this, BaseV, OffsetV, MPT); 2763 2764 return MakeAddrLValue(AddV, MPT->getPointeeType()); 2765} 2766 2767static void 2768EmitAtomicOp(CodeGenFunction &CGF, AtomicExpr *E, llvm::Value *Dest, 2769 llvm::Value *Ptr, llvm::Value *Val1, llvm::Value *Val2, 2770 uint64_t Size, unsigned Align, llvm::AtomicOrdering Order) { 2771 llvm::AtomicRMWInst::BinOp Op = llvm::AtomicRMWInst::Add; 2772 llvm::Instruction::BinaryOps PostOp = (llvm::Instruction::BinaryOps)0; 2773 2774 switch (E->getOp()) { 2775 case AtomicExpr::AO__c11_atomic_init: 2776 llvm_unreachable("Already handled!"); 2777 2778 case AtomicExpr::AO__c11_atomic_compare_exchange_strong: 2779 case AtomicExpr::AO__c11_atomic_compare_exchange_weak: 2780 case AtomicExpr::AO__atomic_compare_exchange: 2781 case AtomicExpr::AO__atomic_compare_exchange_n: { 2782 // Note that cmpxchg only supports specifying one ordering and 2783 // doesn't support weak cmpxchg, at least at the moment. 2784 llvm::LoadInst *LoadVal1 = CGF.Builder.CreateLoad(Val1); 2785 LoadVal1->setAlignment(Align); 2786 llvm::LoadInst *LoadVal2 = CGF.Builder.CreateLoad(Val2); 2787 LoadVal2->setAlignment(Align); 2788 llvm::AtomicCmpXchgInst *CXI = 2789 CGF.Builder.CreateAtomicCmpXchg(Ptr, LoadVal1, LoadVal2, Order); 2790 CXI->setVolatile(E->isVolatile()); 2791 llvm::StoreInst *StoreVal1 = CGF.Builder.CreateStore(CXI, Val1); 2792 StoreVal1->setAlignment(Align); 2793 llvm::Value *Cmp = CGF.Builder.CreateICmpEQ(CXI, LoadVal1); 2794 CGF.EmitStoreOfScalar(Cmp, CGF.MakeAddrLValue(Dest, E->getType())); 2795 return; 2796 } 2797 2798 case AtomicExpr::AO__c11_atomic_load: 2799 case AtomicExpr::AO__atomic_load_n: 2800 case AtomicExpr::AO__atomic_load: { 2801 llvm::LoadInst *Load = CGF.Builder.CreateLoad(Ptr); 2802 Load->setAtomic(Order); 2803 Load->setAlignment(Size); 2804 Load->setVolatile(E->isVolatile()); 2805 llvm::StoreInst *StoreDest = CGF.Builder.CreateStore(Load, Dest); 2806 StoreDest->setAlignment(Align); 2807 return; 2808 } 2809 2810 case AtomicExpr::AO__c11_atomic_store: 2811 case AtomicExpr::AO__atomic_store: 2812 case AtomicExpr::AO__atomic_store_n: { 2813 assert(!Dest && "Store does not return a value"); 2814 llvm::LoadInst *LoadVal1 = CGF.Builder.CreateLoad(Val1); 2815 LoadVal1->setAlignment(Align); 2816 llvm::StoreInst *Store = CGF.Builder.CreateStore(LoadVal1, Ptr); 2817 Store->setAtomic(Order); 2818 Store->setAlignment(Size); 2819 Store->setVolatile(E->isVolatile()); 2820 return; 2821 } 2822 2823 case AtomicExpr::AO__c11_atomic_exchange: 2824 case AtomicExpr::AO__atomic_exchange_n: 2825 case AtomicExpr::AO__atomic_exchange: 2826 Op = llvm::AtomicRMWInst::Xchg; 2827 break; 2828 2829 case AtomicExpr::AO__atomic_add_fetch: 2830 PostOp = llvm::Instruction::Add; 2831 // Fall through. 2832 case AtomicExpr::AO__c11_atomic_fetch_add: 2833 case AtomicExpr::AO__atomic_fetch_add: 2834 Op = llvm::AtomicRMWInst::Add; 2835 break; 2836 2837 case AtomicExpr::AO__atomic_sub_fetch: 2838 PostOp = llvm::Instruction::Sub; 2839 // Fall through. 2840 case AtomicExpr::AO__c11_atomic_fetch_sub: 2841 case AtomicExpr::AO__atomic_fetch_sub: 2842 Op = llvm::AtomicRMWInst::Sub; 2843 break; 2844 2845 case AtomicExpr::AO__atomic_and_fetch: 2846 PostOp = llvm::Instruction::And; 2847 // Fall through. 2848 case AtomicExpr::AO__c11_atomic_fetch_and: 2849 case AtomicExpr::AO__atomic_fetch_and: 2850 Op = llvm::AtomicRMWInst::And; 2851 break; 2852 2853 case AtomicExpr::AO__atomic_or_fetch: 2854 PostOp = llvm::Instruction::Or; 2855 // Fall through. 2856 case AtomicExpr::AO__c11_atomic_fetch_or: 2857 case AtomicExpr::AO__atomic_fetch_or: 2858 Op = llvm::AtomicRMWInst::Or; 2859 break; 2860 2861 case AtomicExpr::AO__atomic_xor_fetch: 2862 PostOp = llvm::Instruction::Xor; 2863 // Fall through. 2864 case AtomicExpr::AO__c11_atomic_fetch_xor: 2865 case AtomicExpr::AO__atomic_fetch_xor: 2866 Op = llvm::AtomicRMWInst::Xor; 2867 break; 2868 2869 case AtomicExpr::AO__atomic_nand_fetch: 2870 PostOp = llvm::Instruction::And; 2871 // Fall through. 2872 case AtomicExpr::AO__atomic_fetch_nand: 2873 Op = llvm::AtomicRMWInst::Nand; 2874 break; 2875 } 2876 2877 llvm::LoadInst *LoadVal1 = CGF.Builder.CreateLoad(Val1); 2878 LoadVal1->setAlignment(Align); 2879 llvm::AtomicRMWInst *RMWI = 2880 CGF.Builder.CreateAtomicRMW(Op, Ptr, LoadVal1, Order); 2881 RMWI->setVolatile(E->isVolatile()); 2882 2883 // For __atomic_*_fetch operations, perform the operation again to 2884 // determine the value which was written. 2885 llvm::Value *Result = RMWI; 2886 if (PostOp) 2887 Result = CGF.Builder.CreateBinOp(PostOp, RMWI, LoadVal1); 2888 if (E->getOp() == AtomicExpr::AO__atomic_nand_fetch) 2889 Result = CGF.Builder.CreateNot(Result); 2890 llvm::StoreInst *StoreDest = CGF.Builder.CreateStore(Result, Dest); 2891 StoreDest->setAlignment(Align); 2892} 2893 2894// This function emits any expression (scalar, complex, or aggregate) 2895// into a temporary alloca. 2896static llvm::Value * 2897EmitValToTemp(CodeGenFunction &CGF, Expr *E) { 2898 llvm::Value *DeclPtr = CGF.CreateMemTemp(E->getType(), ".atomictmp"); 2899 CGF.EmitAnyExprToMem(E, DeclPtr, E->getType().getQualifiers(), 2900 /*Init*/ true); 2901 return DeclPtr; 2902} 2903 2904static RValue ConvertTempToRValue(CodeGenFunction &CGF, QualType Ty, 2905 llvm::Value *Dest) { 2906 if (Ty->isAnyComplexType()) 2907 return RValue::getComplex(CGF.LoadComplexFromAddr(Dest, false)); 2908 if (CGF.hasAggregateLLVMType(Ty)) 2909 return RValue::getAggregate(Dest); 2910 return RValue::get(CGF.EmitLoadOfScalar(CGF.MakeAddrLValue(Dest, Ty))); 2911} 2912 2913RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E, llvm::Value *Dest) { 2914 QualType AtomicTy = E->getPtr()->getType()->getPointeeType(); 2915 QualType MemTy = AtomicTy; 2916 if (const AtomicType *AT = AtomicTy->getAs<AtomicType>()) 2917 MemTy = AT->getValueType(); 2918 CharUnits sizeChars = getContext().getTypeSizeInChars(AtomicTy); 2919 uint64_t Size = sizeChars.getQuantity(); 2920 CharUnits alignChars = getContext().getTypeAlignInChars(AtomicTy); 2921 unsigned Align = alignChars.getQuantity(); 2922 unsigned MaxInlineWidth = 2923 getContext().getTargetInfo().getMaxAtomicInlineWidth(); 2924 bool UseLibcall = (Size != Align || Size > MaxInlineWidth); 2925 2926 2927 2928 llvm::Value *Ptr, *Order, *OrderFail = 0, *Val1 = 0, *Val2 = 0; 2929 Ptr = EmitScalarExpr(E->getPtr()); 2930 2931 if (E->getOp() == AtomicExpr::AO__c11_atomic_init) { 2932 assert(!Dest && "Init does not return a value"); 2933 if (!hasAggregateLLVMType(E->getVal1()->getType())) { 2934 QualType PointeeType 2935 = E->getPtr()->getType()->getAs<PointerType>()->getPointeeType(); 2936 EmitScalarInit(EmitScalarExpr(E->getVal1()), 2937 LValue::MakeAddr(Ptr, PointeeType, alignChars, 2938 getContext())); 2939 } else if (E->getType()->isAnyComplexType()) { 2940 EmitComplexExprIntoAddr(E->getVal1(), Ptr, E->isVolatile()); 2941 } else { 2942 AggValueSlot Slot = AggValueSlot::forAddr(Ptr, alignChars, 2943 AtomicTy.getQualifiers(), 2944 AggValueSlot::IsNotDestructed, 2945 AggValueSlot::DoesNotNeedGCBarriers, 2946 AggValueSlot::IsNotAliased); 2947 EmitAggExpr(E->getVal1(), Slot); 2948 } 2949 return RValue::get(0); 2950 } 2951 2952 Order = EmitScalarExpr(E->getOrder()); 2953 2954 switch (E->getOp()) { 2955 case AtomicExpr::AO__c11_atomic_init: 2956 llvm_unreachable("Already handled!"); 2957 2958 case AtomicExpr::AO__c11_atomic_load: 2959 case AtomicExpr::AO__atomic_load_n: 2960 break; 2961 2962 case AtomicExpr::AO__atomic_load: 2963 Dest = EmitScalarExpr(E->getVal1()); 2964 break; 2965 2966 case AtomicExpr::AO__atomic_store: 2967 Val1 = EmitScalarExpr(E->getVal1()); 2968 break; 2969 2970 case AtomicExpr::AO__atomic_exchange: 2971 Val1 = EmitScalarExpr(E->getVal1()); 2972 Dest = EmitScalarExpr(E->getVal2()); 2973 break; 2974 2975 case AtomicExpr::AO__c11_atomic_compare_exchange_strong: 2976 case AtomicExpr::AO__c11_atomic_compare_exchange_weak: 2977 case AtomicExpr::AO__atomic_compare_exchange_n: 2978 case AtomicExpr::AO__atomic_compare_exchange: 2979 Val1 = EmitScalarExpr(E->getVal1()); 2980 if (E->getOp() == AtomicExpr::AO__atomic_compare_exchange) 2981 Val2 = EmitScalarExpr(E->getVal2()); 2982 else 2983 Val2 = EmitValToTemp(*this, E->getVal2()); 2984 OrderFail = EmitScalarExpr(E->getOrderFail()); 2985 // Evaluate and discard the 'weak' argument. 2986 if (E->getNumSubExprs() == 6) 2987 EmitScalarExpr(E->getWeak()); 2988 break; 2989 2990 case AtomicExpr::AO__c11_atomic_fetch_add: 2991 case AtomicExpr::AO__c11_atomic_fetch_sub: 2992 if (MemTy->isPointerType()) { 2993 // For pointer arithmetic, we're required to do a bit of math: 2994 // adding 1 to an int* is not the same as adding 1 to a uintptr_t. 2995 // ... but only for the C11 builtins. The GNU builtins expect the 2996 // user to multiply by sizeof(T). 2997 QualType Val1Ty = E->getVal1()->getType(); 2998 llvm::Value *Val1Scalar = EmitScalarExpr(E->getVal1()); 2999 CharUnits PointeeIncAmt = 3000 getContext().getTypeSizeInChars(MemTy->getPointeeType()); 3001 Val1Scalar = Builder.CreateMul(Val1Scalar, CGM.getSize(PointeeIncAmt)); 3002 Val1 = CreateMemTemp(Val1Ty, ".atomictmp"); 3003 EmitStoreOfScalar(Val1Scalar, MakeAddrLValue(Val1, Val1Ty)); 3004 break; 3005 } 3006 // Fall through. 3007 case AtomicExpr::AO__atomic_fetch_add: 3008 case AtomicExpr::AO__atomic_fetch_sub: 3009 case AtomicExpr::AO__atomic_add_fetch: 3010 case AtomicExpr::AO__atomic_sub_fetch: 3011 case AtomicExpr::AO__c11_atomic_store: 3012 case AtomicExpr::AO__c11_atomic_exchange: 3013 case AtomicExpr::AO__atomic_store_n: 3014 case AtomicExpr::AO__atomic_exchange_n: 3015 case AtomicExpr::AO__c11_atomic_fetch_and: 3016 case AtomicExpr::AO__c11_atomic_fetch_or: 3017 case AtomicExpr::AO__c11_atomic_fetch_xor: 3018 case AtomicExpr::AO__atomic_fetch_and: 3019 case AtomicExpr::AO__atomic_fetch_or: 3020 case AtomicExpr::AO__atomic_fetch_xor: 3021 case AtomicExpr::AO__atomic_fetch_nand: 3022 case AtomicExpr::AO__atomic_and_fetch: 3023 case AtomicExpr::AO__atomic_or_fetch: 3024 case AtomicExpr::AO__atomic_xor_fetch: 3025 case AtomicExpr::AO__atomic_nand_fetch: 3026 Val1 = EmitValToTemp(*this, E->getVal1()); 3027 break; 3028 } 3029 3030 if (!E->getType()->isVoidType() && !Dest) 3031 Dest = CreateMemTemp(E->getType(), ".atomicdst"); 3032 3033 // Use a library call. See: http://gcc.gnu.org/wiki/Atomic/GCCMM/LIbrary . 3034 if (UseLibcall) { 3035 3036 llvm::SmallVector<QualType, 5> Params; 3037 CallArgList Args; 3038 // Size is always the first parameter 3039 Args.add(RValue::get(llvm::ConstantInt::get(SizeTy, Size)), 3040 getContext().getSizeType()); 3041 // Atomic address is always the second parameter 3042 Args.add(RValue::get(EmitCastToVoidPtr(Ptr)), 3043 getContext().VoidPtrTy); 3044 3045 const char* LibCallName; 3046 QualType RetTy = getContext().VoidTy; 3047 switch (E->getOp()) { 3048 // There is only one libcall for compare an exchange, because there is no 3049 // optimisation benefit possible from a libcall version of a weak compare 3050 // and exchange. 3051 // bool __atomic_compare_exchange(size_t size, void *obj, void *expected, 3052 // void *desired, int success, int failure) 3053 case AtomicExpr::AO__c11_atomic_compare_exchange_weak: 3054 case AtomicExpr::AO__c11_atomic_compare_exchange_strong: 3055 case AtomicExpr::AO__atomic_compare_exchange: 3056 case AtomicExpr::AO__atomic_compare_exchange_n: 3057 LibCallName = "__atomic_compare_exchange"; 3058 RetTy = getContext().BoolTy; 3059 Args.add(RValue::get(EmitCastToVoidPtr(Val1)), 3060 getContext().VoidPtrTy); 3061 Args.add(RValue::get(EmitCastToVoidPtr(Val2)), 3062 getContext().VoidPtrTy); 3063 Args.add(RValue::get(Order), 3064 getContext().IntTy); 3065 Order = OrderFail; 3066 break; 3067 // void __atomic_exchange(size_t size, void *mem, void *val, void *return, 3068 // int order) 3069 case AtomicExpr::AO__c11_atomic_exchange: 3070 case AtomicExpr::AO__atomic_exchange_n: 3071 case AtomicExpr::AO__atomic_exchange: 3072 LibCallName = "__atomic_exchange"; 3073 Args.add(RValue::get(EmitCastToVoidPtr(Val1)), 3074 getContext().VoidPtrTy); 3075 Args.add(RValue::get(EmitCastToVoidPtr(Dest)), 3076 getContext().VoidPtrTy); 3077 break; 3078 // void __atomic_store(size_t size, void *mem, void *val, int order) 3079 case AtomicExpr::AO__c11_atomic_store: 3080 case AtomicExpr::AO__atomic_store: 3081 case AtomicExpr::AO__atomic_store_n: 3082 LibCallName = "__atomic_store"; 3083 Args.add(RValue::get(EmitCastToVoidPtr(Val1)), 3084 getContext().VoidPtrTy); 3085 break; 3086 // void __atomic_load(size_t size, void *mem, void *return, int order) 3087 case AtomicExpr::AO__c11_atomic_load: 3088 case AtomicExpr::AO__atomic_load: 3089 case AtomicExpr::AO__atomic_load_n: 3090 LibCallName = "__atomic_load"; 3091 Args.add(RValue::get(EmitCastToVoidPtr(Dest)), 3092 getContext().VoidPtrTy); 3093 break; 3094#if 0 3095 // These are only defined for 1-16 byte integers. It is not clear what 3096 // their semantics would be on anything else... 3097 case AtomicExpr::Add: LibCallName = "__atomic_fetch_add_generic"; break; 3098 case AtomicExpr::Sub: LibCallName = "__atomic_fetch_sub_generic"; break; 3099 case AtomicExpr::And: LibCallName = "__atomic_fetch_and_generic"; break; 3100 case AtomicExpr::Or: LibCallName = "__atomic_fetch_or_generic"; break; 3101 case AtomicExpr::Xor: LibCallName = "__atomic_fetch_xor_generic"; break; 3102#endif 3103 default: return EmitUnsupportedRValue(E, "atomic library call"); 3104 } 3105 // order is always the last parameter 3106 Args.add(RValue::get(Order), 3107 getContext().IntTy); 3108 3109 const CGFunctionInfo &FuncInfo = 3110 CGM.getTypes().arrangeFunctionCall(RetTy, Args, 3111 FunctionType::ExtInfo(), RequiredArgs::All); 3112 llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FuncInfo); 3113 llvm::Constant *Func = CGM.CreateRuntimeFunction(FTy, LibCallName); 3114 RValue Res = EmitCall(FuncInfo, Func, ReturnValueSlot(), Args); 3115 if (E->isCmpXChg()) 3116 return Res; 3117 if (E->getType()->isVoidType()) 3118 return RValue::get(0); 3119 return ConvertTempToRValue(*this, E->getType(), Dest); 3120 } 3121 3122 llvm::Type *IPtrTy = 3123 llvm::IntegerType::get(getLLVMContext(), Size * 8)->getPointerTo(); 3124 llvm::Value *OrigDest = Dest; 3125 Ptr = Builder.CreateBitCast(Ptr, IPtrTy); 3126 if (Val1) Val1 = Builder.CreateBitCast(Val1, IPtrTy); 3127 if (Val2) Val2 = Builder.CreateBitCast(Val2, IPtrTy); 3128 if (Dest && !E->isCmpXChg()) Dest = Builder.CreateBitCast(Dest, IPtrTy); 3129 3130 if (isa<llvm::ConstantInt>(Order)) { 3131 int ord = cast<llvm::ConstantInt>(Order)->getZExtValue(); 3132 switch (ord) { 3133 case 0: // memory_order_relaxed 3134 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align, 3135 llvm::Monotonic); 3136 break; 3137 case 1: // memory_order_consume 3138 case 2: // memory_order_acquire 3139 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align, 3140 llvm::Acquire); 3141 break; 3142 case 3: // memory_order_release 3143 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align, 3144 llvm::Release); 3145 break; 3146 case 4: // memory_order_acq_rel 3147 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align, 3148 llvm::AcquireRelease); 3149 break; 3150 case 5: // memory_order_seq_cst 3151 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align, 3152 llvm::SequentiallyConsistent); 3153 break; 3154 default: // invalid order 3155 // We should not ever get here normally, but it's hard to 3156 // enforce that in general. 3157 break; 3158 } 3159 if (E->getType()->isVoidType()) 3160 return RValue::get(0); 3161 return ConvertTempToRValue(*this, E->getType(), OrigDest); 3162 } 3163 3164 // Long case, when Order isn't obviously constant. 3165 3166 bool IsStore = E->getOp() == AtomicExpr::AO__c11_atomic_store || 3167 E->getOp() == AtomicExpr::AO__atomic_store || 3168 E->getOp() == AtomicExpr::AO__atomic_store_n; 3169 bool IsLoad = E->getOp() == AtomicExpr::AO__c11_atomic_load || 3170 E->getOp() == AtomicExpr::AO__atomic_load || 3171 E->getOp() == AtomicExpr::AO__atomic_load_n; 3172 3173 // Create all the relevant BB's 3174 llvm::BasicBlock *MonotonicBB = 0, *AcquireBB = 0, *ReleaseBB = 0, 3175 *AcqRelBB = 0, *SeqCstBB = 0; 3176 MonotonicBB = createBasicBlock("monotonic", CurFn); 3177 if (!IsStore) 3178 AcquireBB = createBasicBlock("acquire", CurFn); 3179 if (!IsLoad) 3180 ReleaseBB = createBasicBlock("release", CurFn); 3181 if (!IsLoad && !IsStore) 3182 AcqRelBB = createBasicBlock("acqrel", CurFn); 3183 SeqCstBB = createBasicBlock("seqcst", CurFn); 3184 llvm::BasicBlock *ContBB = createBasicBlock("atomic.continue", CurFn); 3185 3186 // Create the switch for the split 3187 // MonotonicBB is arbitrarily chosen as the default case; in practice, this 3188 // doesn't matter unless someone is crazy enough to use something that 3189 // doesn't fold to a constant for the ordering. 3190 Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false); 3191 llvm::SwitchInst *SI = Builder.CreateSwitch(Order, MonotonicBB); 3192 3193 // Emit all the different atomics 3194 Builder.SetInsertPoint(MonotonicBB); 3195 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align, 3196 llvm::Monotonic); 3197 Builder.CreateBr(ContBB); 3198 if (!IsStore) { 3199 Builder.SetInsertPoint(AcquireBB); 3200 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align, 3201 llvm::Acquire); 3202 Builder.CreateBr(ContBB); 3203 SI->addCase(Builder.getInt32(1), AcquireBB); 3204 SI->addCase(Builder.getInt32(2), AcquireBB); 3205 } 3206 if (!IsLoad) { 3207 Builder.SetInsertPoint(ReleaseBB); 3208 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align, 3209 llvm::Release); 3210 Builder.CreateBr(ContBB); 3211 SI->addCase(Builder.getInt32(3), ReleaseBB); 3212 } 3213 if (!IsLoad && !IsStore) { 3214 Builder.SetInsertPoint(AcqRelBB); 3215 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align, 3216 llvm::AcquireRelease); 3217 Builder.CreateBr(ContBB); 3218 SI->addCase(Builder.getInt32(4), AcqRelBB); 3219 } 3220 Builder.SetInsertPoint(SeqCstBB); 3221 EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align, 3222 llvm::SequentiallyConsistent); 3223 Builder.CreateBr(ContBB); 3224 SI->addCase(Builder.getInt32(5), SeqCstBB); 3225 3226 // Cleanup and return 3227 Builder.SetInsertPoint(ContBB); 3228 if (E->getType()->isVoidType()) 3229 return RValue::get(0); 3230 return ConvertTempToRValue(*this, E->getType(), OrigDest); 3231} 3232 3233void CodeGenFunction::SetFPAccuracy(llvm::Value *Val, float Accuracy) { 3234 assert(Val->getType()->isFPOrFPVectorTy()); 3235 if (Accuracy == 0.0 || !isa<llvm::Instruction>(Val)) 3236 return; 3237 3238 llvm::MDBuilder MDHelper(getLLVMContext()); 3239 llvm::MDNode *Node = MDHelper.createFPMath(Accuracy); 3240 3241 cast<llvm::Instruction>(Val)->setMetadata(llvm::LLVMContext::MD_fpmath, Node); 3242} 3243 3244namespace { 3245 struct LValueOrRValue { 3246 LValue LV; 3247 RValue RV; 3248 }; 3249} 3250 3251static LValueOrRValue emitPseudoObjectExpr(CodeGenFunction &CGF, 3252 const PseudoObjectExpr *E, 3253 bool forLValue, 3254 AggValueSlot slot) { 3255 llvm::SmallVector<CodeGenFunction::OpaqueValueMappingData, 4> opaques; 3256 3257 // Find the result expression, if any. 3258 const Expr *resultExpr = E->getResultExpr(); 3259 LValueOrRValue result; 3260 3261 for (PseudoObjectExpr::const_semantics_iterator 3262 i = E->semantics_begin(), e = E->semantics_end(); i != e; ++i) { 3263 const Expr *semantic = *i; 3264 3265 // If this semantic expression is an opaque value, bind it 3266 // to the result of its source expression. 3267 if (const OpaqueValueExpr *ov = dyn_cast<OpaqueValueExpr>(semantic)) { 3268 3269 // If this is the result expression, we may need to evaluate 3270 // directly into the slot. 3271 typedef CodeGenFunction::OpaqueValueMappingData OVMA; 3272 OVMA opaqueData; 3273 if (ov == resultExpr && ov->isRValue() && !forLValue && 3274 CodeGenFunction::hasAggregateLLVMType(ov->getType()) && 3275 !ov->getType()->isAnyComplexType()) { 3276 CGF.EmitAggExpr(ov->getSourceExpr(), slot); 3277 3278 LValue LV = CGF.MakeAddrLValue(slot.getAddr(), ov->getType()); 3279 opaqueData = OVMA::bind(CGF, ov, LV); 3280 result.RV = slot.asRValue(); 3281 3282 // Otherwise, emit as normal. 3283 } else { 3284 opaqueData = OVMA::bind(CGF, ov, ov->getSourceExpr()); 3285 3286 // If this is the result, also evaluate the result now. 3287 if (ov == resultExpr) { 3288 if (forLValue) 3289 result.LV = CGF.EmitLValue(ov); 3290 else 3291 result.RV = CGF.EmitAnyExpr(ov, slot); 3292 } 3293 } 3294 3295 opaques.push_back(opaqueData); 3296 3297 // Otherwise, if the expression is the result, evaluate it 3298 // and remember the result. 3299 } else if (semantic == resultExpr) { 3300 if (forLValue) 3301 result.LV = CGF.EmitLValue(semantic); 3302 else 3303 result.RV = CGF.EmitAnyExpr(semantic, slot); 3304 3305 // Otherwise, evaluate the expression in an ignored context. 3306 } else { 3307 CGF.EmitIgnoredExpr(semantic); 3308 } 3309 } 3310 3311 // Unbind all the opaques now. 3312 for (unsigned i = 0, e = opaques.size(); i != e; ++i) 3313 opaques[i].unbind(CGF); 3314 3315 return result; 3316} 3317 3318RValue CodeGenFunction::EmitPseudoObjectRValue(const PseudoObjectExpr *E, 3319 AggValueSlot slot) { 3320 return emitPseudoObjectExpr(*this, E, false, slot).RV; 3321} 3322 3323LValue CodeGenFunction::EmitPseudoObjectLValue(const PseudoObjectExpr *E) { 3324 return emitPseudoObjectExpr(*this, E, true, AggValueSlot::ignored()).LV; 3325} 3326