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