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