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