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