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