1 //===--- CGExpr.cpp - Emit LLVM Code from Expressions ---------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This contains code to emit Expr nodes as LLVM code. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "CGCXXABI.h" 14 #include "CGCall.h" 15 #include "CGCleanup.h" 16 #include "CGDebugInfo.h" 17 #include "CGObjCRuntime.h" 18 #include "CGOpenMPRuntime.h" 19 #include "CGRecordLayout.h" 20 #include "CodeGenFunction.h" 21 #include "CodeGenModule.h" 22 #include "ConstantEmitter.h" 23 #include "TargetInfo.h" 24 #include "clang/AST/ASTContext.h" 25 #include "clang/AST/Attr.h" 26 #include "clang/AST/DeclObjC.h" 27 #include "clang/AST/NSAPI.h" 28 #include "clang/Basic/Builtins.h" 29 #include "clang/Basic/CodeGenOptions.h" 30 #include "llvm/ADT/Hashing.h" 31 #include "llvm/ADT/StringExtras.h" 32 #include "llvm/IR/DataLayout.h" 33 #include "llvm/IR/Intrinsics.h" 34 #include "llvm/IR/LLVMContext.h" 35 #include "llvm/IR/MDBuilder.h" 36 #include "llvm/Support/ConvertUTF.h" 37 #include "llvm/Support/MathExtras.h" 38 #include "llvm/Support/Path.h" 39 #include "llvm/Transforms/Utils/SanitizerStats.h" 40 41 #include <string> 42 43 using namespace clang; 44 using namespace CodeGen; 45 46 //===--------------------------------------------------------------------===// 47 // Miscellaneous Helper Methods 48 //===--------------------------------------------------------------------===// 49 50 llvm::Value *CodeGenFunction::EmitCastToVoidPtr(llvm::Value *value) { 51 unsigned addressSpace = 52 cast<llvm::PointerType>(value->getType())->getAddressSpace(); 53 54 llvm::PointerType *destType = Int8PtrTy; 55 if (addressSpace) 56 destType = llvm::Type::getInt8PtrTy(getLLVMContext(), addressSpace); 57 58 if (value->getType() == destType) return value; 59 return Builder.CreateBitCast(value, destType); 60 } 61 62 /// CreateTempAlloca - This creates a alloca and inserts it into the entry 63 /// block. 64 Address CodeGenFunction::CreateTempAllocaWithoutCast(llvm::Type *Ty, 65 CharUnits Align, 66 const Twine &Name, 67 llvm::Value *ArraySize) { 68 auto Alloca = CreateTempAlloca(Ty, Name, ArraySize); 69 Alloca->setAlignment(Align.getQuantity()); 70 return Address(Alloca, Align); 71 } 72 73 /// CreateTempAlloca - This creates a alloca and inserts it into the entry 74 /// block. The alloca is casted to default address space if necessary. 75 Address CodeGenFunction::CreateTempAlloca(llvm::Type *Ty, CharUnits Align, 76 const Twine &Name, 77 llvm::Value *ArraySize, 78 Address *AllocaAddr) { 79 auto Alloca = CreateTempAllocaWithoutCast(Ty, Align, Name, ArraySize); 80 if (AllocaAddr) 81 *AllocaAddr = Alloca; 82 llvm::Value *V = Alloca.getPointer(); 83 // Alloca always returns a pointer in alloca address space, which may 84 // be different from the type defined by the language. For example, 85 // in C++ the auto variables are in the default address space. Therefore 86 // cast alloca to the default address space when necessary. 87 if (getASTAllocaAddressSpace() != LangAS::Default) { 88 auto DestAddrSpace = getContext().getTargetAddressSpace(LangAS::Default); 89 llvm::IRBuilderBase::InsertPointGuard IPG(Builder); 90 // When ArraySize is nullptr, alloca is inserted at AllocaInsertPt, 91 // otherwise alloca is inserted at the current insertion point of the 92 // builder. 93 if (!ArraySize) 94 Builder.SetInsertPoint(AllocaInsertPt); 95 V = getTargetHooks().performAddrSpaceCast( 96 *this, V, getASTAllocaAddressSpace(), LangAS::Default, 97 Ty->getPointerTo(DestAddrSpace), /*non-null*/ true); 98 } 99 100 return Address(V, Align); 101 } 102 103 /// CreateTempAlloca - This creates an alloca and inserts it into the entry 104 /// block if \p ArraySize is nullptr, otherwise inserts it at the current 105 /// insertion point of the builder. 106 llvm::AllocaInst *CodeGenFunction::CreateTempAlloca(llvm::Type *Ty, 107 const Twine &Name, 108 llvm::Value *ArraySize) { 109 if (ArraySize) 110 return Builder.CreateAlloca(Ty, ArraySize, Name); 111 return new llvm::AllocaInst(Ty, CGM.getDataLayout().getAllocaAddrSpace(), 112 ArraySize, Name, AllocaInsertPt); 113 } 114 115 /// CreateDefaultAlignTempAlloca - This creates an alloca with the 116 /// default alignment of the corresponding LLVM type, which is *not* 117 /// guaranteed to be related in any way to the expected alignment of 118 /// an AST type that might have been lowered to Ty. 119 Address CodeGenFunction::CreateDefaultAlignTempAlloca(llvm::Type *Ty, 120 const Twine &Name) { 121 CharUnits Align = 122 CharUnits::fromQuantity(CGM.getDataLayout().getABITypeAlignment(Ty)); 123 return CreateTempAlloca(Ty, Align, Name); 124 } 125 126 void CodeGenFunction::InitTempAlloca(Address Var, llvm::Value *Init) { 127 assert(isa<llvm::AllocaInst>(Var.getPointer())); 128 auto *Store = new llvm::StoreInst(Init, Var.getPointer()); 129 Store->setAlignment(Var.getAlignment().getQuantity()); 130 llvm::BasicBlock *Block = AllocaInsertPt->getParent(); 131 Block->getInstList().insertAfter(AllocaInsertPt->getIterator(), Store); 132 } 133 134 Address CodeGenFunction::CreateIRTemp(QualType Ty, const Twine &Name) { 135 CharUnits Align = getContext().getTypeAlignInChars(Ty); 136 return CreateTempAlloca(ConvertType(Ty), Align, Name); 137 } 138 139 Address CodeGenFunction::CreateMemTemp(QualType Ty, const Twine &Name, 140 Address *Alloca) { 141 // FIXME: Should we prefer the preferred type alignment here? 142 return CreateMemTemp(Ty, getContext().getTypeAlignInChars(Ty), Name, Alloca); 143 } 144 145 Address CodeGenFunction::CreateMemTemp(QualType Ty, CharUnits Align, 146 const Twine &Name, Address *Alloca) { 147 return CreateTempAlloca(ConvertTypeForMem(Ty), Align, Name, 148 /*ArraySize=*/nullptr, Alloca); 149 } 150 151 Address CodeGenFunction::CreateMemTempWithoutCast(QualType Ty, CharUnits Align, 152 const Twine &Name) { 153 return CreateTempAllocaWithoutCast(ConvertTypeForMem(Ty), Align, Name); 154 } 155 156 Address CodeGenFunction::CreateMemTempWithoutCast(QualType Ty, 157 const Twine &Name) { 158 return CreateMemTempWithoutCast(Ty, getContext().getTypeAlignInChars(Ty), 159 Name); 160 } 161 162 /// EvaluateExprAsBool - Perform the usual unary conversions on the specified 163 /// expression and compare the result against zero, returning an Int1Ty value. 164 llvm::Value *CodeGenFunction::EvaluateExprAsBool(const Expr *E) { 165 PGO.setCurrentStmt(E); 166 if (const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>()) { 167 llvm::Value *MemPtr = EmitScalarExpr(E); 168 return CGM.getCXXABI().EmitMemberPointerIsNotNull(*this, MemPtr, MPT); 169 } 170 171 QualType BoolTy = getContext().BoolTy; 172 SourceLocation Loc = E->getExprLoc(); 173 if (!E->getType()->isAnyComplexType()) 174 return EmitScalarConversion(EmitScalarExpr(E), E->getType(), BoolTy, Loc); 175 176 return EmitComplexToScalarConversion(EmitComplexExpr(E), E->getType(), BoolTy, 177 Loc); 178 } 179 180 /// EmitIgnoredExpr - Emit code to compute the specified expression, 181 /// ignoring the result. 182 void CodeGenFunction::EmitIgnoredExpr(const Expr *E) { 183 if (E->isRValue()) 184 return (void) EmitAnyExpr(E, AggValueSlot::ignored(), true); 185 186 // Just emit it as an l-value and drop the result. 187 EmitLValue(E); 188 } 189 190 /// EmitAnyExpr - Emit code to compute the specified expression which 191 /// can have any type. The result is returned as an RValue struct. 192 /// If this is an aggregate expression, AggSlot indicates where the 193 /// result should be returned. 194 RValue CodeGenFunction::EmitAnyExpr(const Expr *E, 195 AggValueSlot aggSlot, 196 bool ignoreResult) { 197 switch (getEvaluationKind(E->getType())) { 198 case TEK_Scalar: 199 return RValue::get(EmitScalarExpr(E, ignoreResult)); 200 case TEK_Complex: 201 return RValue::getComplex(EmitComplexExpr(E, ignoreResult, ignoreResult)); 202 case TEK_Aggregate: 203 if (!ignoreResult && aggSlot.isIgnored()) 204 aggSlot = CreateAggTemp(E->getType(), "agg-temp"); 205 EmitAggExpr(E, aggSlot); 206 return aggSlot.asRValue(); 207 } 208 llvm_unreachable("bad evaluation kind"); 209 } 210 211 /// EmitAnyExprToTemp - Similar to EmitAnyExpr(), however, the result will 212 /// always be accessible even if no aggregate location is provided. 213 RValue CodeGenFunction::EmitAnyExprToTemp(const Expr *E) { 214 AggValueSlot AggSlot = AggValueSlot::ignored(); 215 216 if (hasAggregateEvaluationKind(E->getType())) 217 AggSlot = CreateAggTemp(E->getType(), "agg.tmp"); 218 return EmitAnyExpr(E, AggSlot); 219 } 220 221 /// EmitAnyExprToMem - Evaluate an expression into a given memory 222 /// location. 223 void CodeGenFunction::EmitAnyExprToMem(const Expr *E, 224 Address Location, 225 Qualifiers Quals, 226 bool IsInit) { 227 // FIXME: This function should take an LValue as an argument. 228 switch (getEvaluationKind(E->getType())) { 229 case TEK_Complex: 230 EmitComplexExprIntoLValue(E, MakeAddrLValue(Location, E->getType()), 231 /*isInit*/ false); 232 return; 233 234 case TEK_Aggregate: { 235 EmitAggExpr(E, AggValueSlot::forAddr(Location, Quals, 236 AggValueSlot::IsDestructed_t(IsInit), 237 AggValueSlot::DoesNotNeedGCBarriers, 238 AggValueSlot::IsAliased_t(!IsInit), 239 AggValueSlot::MayOverlap)); 240 return; 241 } 242 243 case TEK_Scalar: { 244 RValue RV = RValue::get(EmitScalarExpr(E, /*Ignore*/ false)); 245 LValue LV = MakeAddrLValue(Location, E->getType()); 246 EmitStoreThroughLValue(RV, LV); 247 return; 248 } 249 } 250 llvm_unreachable("bad evaluation kind"); 251 } 252 253 static void 254 pushTemporaryCleanup(CodeGenFunction &CGF, const MaterializeTemporaryExpr *M, 255 const Expr *E, Address ReferenceTemporary) { 256 // Objective-C++ ARC: 257 // If we are binding a reference to a temporary that has ownership, we 258 // need to perform retain/release operations on the temporary. 259 // 260 // FIXME: This should be looking at E, not M. 261 if (auto Lifetime = M->getType().getObjCLifetime()) { 262 switch (Lifetime) { 263 case Qualifiers::OCL_None: 264 case Qualifiers::OCL_ExplicitNone: 265 // Carry on to normal cleanup handling. 266 break; 267 268 case Qualifiers::OCL_Autoreleasing: 269 // Nothing to do; cleaned up by an autorelease pool. 270 return; 271 272 case Qualifiers::OCL_Strong: 273 case Qualifiers::OCL_Weak: 274 switch (StorageDuration Duration = M->getStorageDuration()) { 275 case SD_Static: 276 // Note: we intentionally do not register a cleanup to release 277 // the object on program termination. 278 return; 279 280 case SD_Thread: 281 // FIXME: We should probably register a cleanup in this case. 282 return; 283 284 case SD_Automatic: 285 case SD_FullExpression: 286 CodeGenFunction::Destroyer *Destroy; 287 CleanupKind CleanupKind; 288 if (Lifetime == Qualifiers::OCL_Strong) { 289 const ValueDecl *VD = M->getExtendingDecl(); 290 bool Precise = 291 VD && isa<VarDecl>(VD) && VD->hasAttr<ObjCPreciseLifetimeAttr>(); 292 CleanupKind = CGF.getARCCleanupKind(); 293 Destroy = Precise ? &CodeGenFunction::destroyARCStrongPrecise 294 : &CodeGenFunction::destroyARCStrongImprecise; 295 } else { 296 // __weak objects always get EH cleanups; otherwise, exceptions 297 // could cause really nasty crashes instead of mere leaks. 298 CleanupKind = NormalAndEHCleanup; 299 Destroy = &CodeGenFunction::destroyARCWeak; 300 } 301 if (Duration == SD_FullExpression) 302 CGF.pushDestroy(CleanupKind, ReferenceTemporary, 303 M->getType(), *Destroy, 304 CleanupKind & EHCleanup); 305 else 306 CGF.pushLifetimeExtendedDestroy(CleanupKind, ReferenceTemporary, 307 M->getType(), 308 *Destroy, CleanupKind & EHCleanup); 309 return; 310 311 case SD_Dynamic: 312 llvm_unreachable("temporary cannot have dynamic storage duration"); 313 } 314 llvm_unreachable("unknown storage duration"); 315 } 316 } 317 318 CXXDestructorDecl *ReferenceTemporaryDtor = nullptr; 319 if (const RecordType *RT = 320 E->getType()->getBaseElementTypeUnsafe()->getAs<RecordType>()) { 321 // Get the destructor for the reference temporary. 322 auto *ClassDecl = cast<CXXRecordDecl>(RT->getDecl()); 323 if (!ClassDecl->hasTrivialDestructor()) 324 ReferenceTemporaryDtor = ClassDecl->getDestructor(); 325 } 326 327 if (!ReferenceTemporaryDtor) 328 return; 329 330 // Call the destructor for the temporary. 331 switch (M->getStorageDuration()) { 332 case SD_Static: 333 case SD_Thread: { 334 llvm::FunctionCallee CleanupFn; 335 llvm::Constant *CleanupArg; 336 if (E->getType()->isArrayType()) { 337 CleanupFn = CodeGenFunction(CGF.CGM).generateDestroyHelper( 338 ReferenceTemporary, E->getType(), 339 CodeGenFunction::destroyCXXObject, CGF.getLangOpts().Exceptions, 340 dyn_cast_or_null<VarDecl>(M->getExtendingDecl())); 341 CleanupArg = llvm::Constant::getNullValue(CGF.Int8PtrTy); 342 } else { 343 CleanupFn = CGF.CGM.getAddrAndTypeOfCXXStructor( 344 GlobalDecl(ReferenceTemporaryDtor, Dtor_Complete)); 345 CleanupArg = cast<llvm::Constant>(ReferenceTemporary.getPointer()); 346 } 347 CGF.CGM.getCXXABI().registerGlobalDtor( 348 CGF, *cast<VarDecl>(M->getExtendingDecl()), CleanupFn, CleanupArg); 349 break; 350 } 351 352 case SD_FullExpression: 353 CGF.pushDestroy(NormalAndEHCleanup, ReferenceTemporary, E->getType(), 354 CodeGenFunction::destroyCXXObject, 355 CGF.getLangOpts().Exceptions); 356 break; 357 358 case SD_Automatic: 359 CGF.pushLifetimeExtendedDestroy(NormalAndEHCleanup, 360 ReferenceTemporary, E->getType(), 361 CodeGenFunction::destroyCXXObject, 362 CGF.getLangOpts().Exceptions); 363 break; 364 365 case SD_Dynamic: 366 llvm_unreachable("temporary cannot have dynamic storage duration"); 367 } 368 } 369 370 static Address createReferenceTemporary(CodeGenFunction &CGF, 371 const MaterializeTemporaryExpr *M, 372 const Expr *Inner, 373 Address *Alloca = nullptr) { 374 auto &TCG = CGF.getTargetHooks(); 375 switch (M->getStorageDuration()) { 376 case SD_FullExpression: 377 case SD_Automatic: { 378 // If we have a constant temporary array or record try to promote it into a 379 // constant global under the same rules a normal constant would've been 380 // promoted. This is easier on the optimizer and generally emits fewer 381 // instructions. 382 QualType Ty = Inner->getType(); 383 if (CGF.CGM.getCodeGenOpts().MergeAllConstants && 384 (Ty->isArrayType() || Ty->isRecordType()) && 385 CGF.CGM.isTypeConstant(Ty, true)) 386 if (auto Init = ConstantEmitter(CGF).tryEmitAbstract(Inner, Ty)) { 387 if (auto AddrSpace = CGF.getTarget().getConstantAddressSpace()) { 388 auto AS = AddrSpace.getValue(); 389 auto *GV = new llvm::GlobalVariable( 390 CGF.CGM.getModule(), Init->getType(), /*isConstant=*/true, 391 llvm::GlobalValue::PrivateLinkage, Init, ".ref.tmp", nullptr, 392 llvm::GlobalValue::NotThreadLocal, 393 CGF.getContext().getTargetAddressSpace(AS)); 394 CharUnits alignment = CGF.getContext().getTypeAlignInChars(Ty); 395 GV->setAlignment(alignment.getQuantity()); 396 llvm::Constant *C = GV; 397 if (AS != LangAS::Default) 398 C = TCG.performAddrSpaceCast( 399 CGF.CGM, GV, AS, LangAS::Default, 400 GV->getValueType()->getPointerTo( 401 CGF.getContext().getTargetAddressSpace(LangAS::Default))); 402 // FIXME: Should we put the new global into a COMDAT? 403 return Address(C, alignment); 404 } 405 } 406 return CGF.CreateMemTemp(Ty, "ref.tmp", Alloca); 407 } 408 case SD_Thread: 409 case SD_Static: 410 return CGF.CGM.GetAddrOfGlobalTemporary(M, Inner); 411 412 case SD_Dynamic: 413 llvm_unreachable("temporary can't have dynamic storage duration"); 414 } 415 llvm_unreachable("unknown storage duration"); 416 } 417 418 LValue CodeGenFunction:: 419 EmitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *M) { 420 const Expr *E = M->GetTemporaryExpr(); 421 422 assert((!M->getExtendingDecl() || !isa<VarDecl>(M->getExtendingDecl()) || 423 !cast<VarDecl>(M->getExtendingDecl())->isARCPseudoStrong()) && 424 "Reference should never be pseudo-strong!"); 425 426 // FIXME: ideally this would use EmitAnyExprToMem, however, we cannot do so 427 // as that will cause the lifetime adjustment to be lost for ARC 428 auto ownership = M->getType().getObjCLifetime(); 429 if (ownership != Qualifiers::OCL_None && 430 ownership != Qualifiers::OCL_ExplicitNone) { 431 Address Object = createReferenceTemporary(*this, M, E); 432 if (auto *Var = dyn_cast<llvm::GlobalVariable>(Object.getPointer())) { 433 Object = Address(llvm::ConstantExpr::getBitCast(Var, 434 ConvertTypeForMem(E->getType()) 435 ->getPointerTo(Object.getAddressSpace())), 436 Object.getAlignment()); 437 438 // createReferenceTemporary will promote the temporary to a global with a 439 // constant initializer if it can. It can only do this to a value of 440 // ARC-manageable type if the value is global and therefore "immune" to 441 // ref-counting operations. Therefore we have no need to emit either a 442 // dynamic initialization or a cleanup and we can just return the address 443 // of the temporary. 444 if (Var->hasInitializer()) 445 return MakeAddrLValue(Object, M->getType(), AlignmentSource::Decl); 446 447 Var->setInitializer(CGM.EmitNullConstant(E->getType())); 448 } 449 LValue RefTempDst = MakeAddrLValue(Object, M->getType(), 450 AlignmentSource::Decl); 451 452 switch (getEvaluationKind(E->getType())) { 453 default: llvm_unreachable("expected scalar or aggregate expression"); 454 case TEK_Scalar: 455 EmitScalarInit(E, M->getExtendingDecl(), RefTempDst, false); 456 break; 457 case TEK_Aggregate: { 458 EmitAggExpr(E, AggValueSlot::forAddr(Object, 459 E->getType().getQualifiers(), 460 AggValueSlot::IsDestructed, 461 AggValueSlot::DoesNotNeedGCBarriers, 462 AggValueSlot::IsNotAliased, 463 AggValueSlot::DoesNotOverlap)); 464 break; 465 } 466 } 467 468 pushTemporaryCleanup(*this, M, E, Object); 469 return RefTempDst; 470 } 471 472 SmallVector<const Expr *, 2> CommaLHSs; 473 SmallVector<SubobjectAdjustment, 2> Adjustments; 474 E = E->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments); 475 476 for (const auto &Ignored : CommaLHSs) 477 EmitIgnoredExpr(Ignored); 478 479 if (const auto *opaque = dyn_cast<OpaqueValueExpr>(E)) { 480 if (opaque->getType()->isRecordType()) { 481 assert(Adjustments.empty()); 482 return EmitOpaqueValueLValue(opaque); 483 } 484 } 485 486 // Create and initialize the reference temporary. 487 Address Alloca = Address::invalid(); 488 Address Object = createReferenceTemporary(*this, M, E, &Alloca); 489 if (auto *Var = dyn_cast<llvm::GlobalVariable>( 490 Object.getPointer()->stripPointerCasts())) { 491 Object = Address(llvm::ConstantExpr::getBitCast( 492 cast<llvm::Constant>(Object.getPointer()), 493 ConvertTypeForMem(E->getType())->getPointerTo()), 494 Object.getAlignment()); 495 // If the temporary is a global and has a constant initializer or is a 496 // constant temporary that we promoted to a global, we may have already 497 // initialized it. 498 if (!Var->hasInitializer()) { 499 Var->setInitializer(CGM.EmitNullConstant(E->getType())); 500 EmitAnyExprToMem(E, Object, Qualifiers(), /*IsInit*/true); 501 } 502 } else { 503 switch (M->getStorageDuration()) { 504 case SD_Automatic: 505 if (auto *Size = EmitLifetimeStart( 506 CGM.getDataLayout().getTypeAllocSize(Alloca.getElementType()), 507 Alloca.getPointer())) { 508 pushCleanupAfterFullExpr<CallLifetimeEnd>(NormalEHLifetimeMarker, 509 Alloca, Size); 510 } 511 break; 512 513 case SD_FullExpression: { 514 if (!ShouldEmitLifetimeMarkers) 515 break; 516 517 // Avoid creating a conditional cleanup just to hold an llvm.lifetime.end 518 // marker. Instead, start the lifetime of a conditional temporary earlier 519 // so that it's unconditional. Don't do this in ASan's use-after-scope 520 // mode so that it gets the more precise lifetime marks. If the type has 521 // a non-trivial destructor, we'll have a cleanup block for it anyway, 522 // so this typically doesn't help; skip it in that case. 523 ConditionalEvaluation *OldConditional = nullptr; 524 CGBuilderTy::InsertPoint OldIP; 525 if (isInConditionalBranch() && !E->getType().isDestructedType() && 526 !CGM.getCodeGenOpts().SanitizeAddressUseAfterScope) { 527 OldConditional = OutermostConditional; 528 OutermostConditional = nullptr; 529 530 OldIP = Builder.saveIP(); 531 llvm::BasicBlock *Block = OldConditional->getStartingBlock(); 532 Builder.restoreIP(CGBuilderTy::InsertPoint( 533 Block, llvm::BasicBlock::iterator(Block->back()))); 534 } 535 536 if (auto *Size = EmitLifetimeStart( 537 CGM.getDataLayout().getTypeAllocSize(Alloca.getElementType()), 538 Alloca.getPointer())) { 539 pushFullExprCleanup<CallLifetimeEnd>(NormalEHLifetimeMarker, Alloca, 540 Size); 541 } 542 543 if (OldConditional) { 544 OutermostConditional = OldConditional; 545 Builder.restoreIP(OldIP); 546 } 547 break; 548 } 549 550 default: 551 break; 552 } 553 EmitAnyExprToMem(E, Object, Qualifiers(), /*IsInit*/true); 554 } 555 pushTemporaryCleanup(*this, M, E, Object); 556 557 // Perform derived-to-base casts and/or field accesses, to get from the 558 // temporary object we created (and, potentially, for which we extended 559 // the lifetime) to the subobject we're binding the reference to. 560 for (unsigned I = Adjustments.size(); I != 0; --I) { 561 SubobjectAdjustment &Adjustment = Adjustments[I-1]; 562 switch (Adjustment.Kind) { 563 case SubobjectAdjustment::DerivedToBaseAdjustment: 564 Object = 565 GetAddressOfBaseClass(Object, Adjustment.DerivedToBase.DerivedClass, 566 Adjustment.DerivedToBase.BasePath->path_begin(), 567 Adjustment.DerivedToBase.BasePath->path_end(), 568 /*NullCheckValue=*/ false, E->getExprLoc()); 569 break; 570 571 case SubobjectAdjustment::FieldAdjustment: { 572 LValue LV = MakeAddrLValue(Object, E->getType(), AlignmentSource::Decl); 573 LV = EmitLValueForField(LV, Adjustment.Field); 574 assert(LV.isSimple() && 575 "materialized temporary field is not a simple lvalue"); 576 Object = LV.getAddress(); 577 break; 578 } 579 580 case SubobjectAdjustment::MemberPointerAdjustment: { 581 llvm::Value *Ptr = EmitScalarExpr(Adjustment.Ptr.RHS); 582 Object = EmitCXXMemberDataPointerAddress(E, Object, Ptr, 583 Adjustment.Ptr.MPT); 584 break; 585 } 586 } 587 } 588 589 return MakeAddrLValue(Object, M->getType(), AlignmentSource::Decl); 590 } 591 592 RValue 593 CodeGenFunction::EmitReferenceBindingToExpr(const Expr *E) { 594 // Emit the expression as an lvalue. 595 LValue LV = EmitLValue(E); 596 assert(LV.isSimple()); 597 llvm::Value *Value = LV.getPointer(); 598 599 if (sanitizePerformTypeCheck() && !E->getType()->isFunctionType()) { 600 // C++11 [dcl.ref]p5 (as amended by core issue 453): 601 // If a glvalue to which a reference is directly bound designates neither 602 // an existing object or function of an appropriate type nor a region of 603 // storage of suitable size and alignment to contain an object of the 604 // reference's type, the behavior is undefined. 605 QualType Ty = E->getType(); 606 EmitTypeCheck(TCK_ReferenceBinding, E->getExprLoc(), Value, Ty); 607 } 608 609 return RValue::get(Value); 610 } 611 612 613 /// getAccessedFieldNo - Given an encoded value and a result number, return the 614 /// input field number being accessed. 615 unsigned CodeGenFunction::getAccessedFieldNo(unsigned Idx, 616 const llvm::Constant *Elts) { 617 return cast<llvm::ConstantInt>(Elts->getAggregateElement(Idx)) 618 ->getZExtValue(); 619 } 620 621 /// Emit the hash_16_bytes function from include/llvm/ADT/Hashing.h. 622 static llvm::Value *emitHash16Bytes(CGBuilderTy &Builder, llvm::Value *Low, 623 llvm::Value *High) { 624 llvm::Value *KMul = Builder.getInt64(0x9ddfea08eb382d69ULL); 625 llvm::Value *K47 = Builder.getInt64(47); 626 llvm::Value *A0 = Builder.CreateMul(Builder.CreateXor(Low, High), KMul); 627 llvm::Value *A1 = Builder.CreateXor(Builder.CreateLShr(A0, K47), A0); 628 llvm::Value *B0 = Builder.CreateMul(Builder.CreateXor(High, A1), KMul); 629 llvm::Value *B1 = Builder.CreateXor(Builder.CreateLShr(B0, K47), B0); 630 return Builder.CreateMul(B1, KMul); 631 } 632 633 bool CodeGenFunction::isNullPointerAllowed(TypeCheckKind TCK) { 634 return TCK == TCK_DowncastPointer || TCK == TCK_Upcast || 635 TCK == TCK_UpcastToVirtualBase || TCK == TCK_DynamicOperation; 636 } 637 638 bool CodeGenFunction::isVptrCheckRequired(TypeCheckKind TCK, QualType Ty) { 639 CXXRecordDecl *RD = Ty->getAsCXXRecordDecl(); 640 return (RD && RD->hasDefinition() && RD->isDynamicClass()) && 641 (TCK == TCK_MemberAccess || TCK == TCK_MemberCall || 642 TCK == TCK_DowncastPointer || TCK == TCK_DowncastReference || 643 TCK == TCK_UpcastToVirtualBase || TCK == TCK_DynamicOperation); 644 } 645 646 bool CodeGenFunction::sanitizePerformTypeCheck() const { 647 return SanOpts.has(SanitizerKind::Null) | 648 SanOpts.has(SanitizerKind::Alignment) | 649 SanOpts.has(SanitizerKind::ObjectSize) | 650 SanOpts.has(SanitizerKind::Vptr); 651 } 652 653 void CodeGenFunction::EmitTypeCheck(TypeCheckKind TCK, SourceLocation Loc, 654 llvm::Value *Ptr, QualType Ty, 655 CharUnits Alignment, 656 SanitizerSet SkippedChecks, 657 llvm::Value *ArraySize) { 658 if (!sanitizePerformTypeCheck()) 659 return; 660 661 // Don't check pointers outside the default address space. The null check 662 // isn't correct, the object-size check isn't supported by LLVM, and we can't 663 // communicate the addresses to the runtime handler for the vptr check. 664 if (Ptr->getType()->getPointerAddressSpace()) 665 return; 666 667 // Don't check pointers to volatile data. The behavior here is implementation- 668 // defined. 669 if (Ty.isVolatileQualified()) 670 return; 671 672 SanitizerScope SanScope(this); 673 674 SmallVector<std::pair<llvm::Value *, SanitizerMask>, 3> Checks; 675 llvm::BasicBlock *Done = nullptr; 676 677 // Quickly determine whether we have a pointer to an alloca. It's possible 678 // to skip null checks, and some alignment checks, for these pointers. This 679 // can reduce compile-time significantly. 680 auto PtrToAlloca = 681 dyn_cast<llvm::AllocaInst>(Ptr->stripPointerCastsNoFollowAliases()); 682 683 llvm::Value *True = llvm::ConstantInt::getTrue(getLLVMContext()); 684 llvm::Value *IsNonNull = nullptr; 685 bool IsGuaranteedNonNull = 686 SkippedChecks.has(SanitizerKind::Null) || PtrToAlloca; 687 bool AllowNullPointers = isNullPointerAllowed(TCK); 688 if ((SanOpts.has(SanitizerKind::Null) || AllowNullPointers) && 689 !IsGuaranteedNonNull) { 690 // The glvalue must not be an empty glvalue. 691 IsNonNull = Builder.CreateIsNotNull(Ptr); 692 693 // The IR builder can constant-fold the null check if the pointer points to 694 // a constant. 695 IsGuaranteedNonNull = IsNonNull == True; 696 697 // Skip the null check if the pointer is known to be non-null. 698 if (!IsGuaranteedNonNull) { 699 if (AllowNullPointers) { 700 // When performing pointer casts, it's OK if the value is null. 701 // Skip the remaining checks in that case. 702 Done = createBasicBlock("null"); 703 llvm::BasicBlock *Rest = createBasicBlock("not.null"); 704 Builder.CreateCondBr(IsNonNull, Rest, Done); 705 EmitBlock(Rest); 706 } else { 707 Checks.push_back(std::make_pair(IsNonNull, SanitizerKind::Null)); 708 } 709 } 710 } 711 712 if (SanOpts.has(SanitizerKind::ObjectSize) && 713 !SkippedChecks.has(SanitizerKind::ObjectSize) && 714 !Ty->isIncompleteType()) { 715 uint64_t TySize = getContext().getTypeSizeInChars(Ty).getQuantity(); 716 llvm::Value *Size = llvm::ConstantInt::get(IntPtrTy, TySize); 717 if (ArraySize) 718 Size = Builder.CreateMul(Size, ArraySize); 719 720 // Degenerate case: new X[0] does not need an objectsize check. 721 llvm::Constant *ConstantSize = dyn_cast<llvm::Constant>(Size); 722 if (!ConstantSize || !ConstantSize->isNullValue()) { 723 // The glvalue must refer to a large enough storage region. 724 // FIXME: If Address Sanitizer is enabled, insert dynamic instrumentation 725 // to check this. 726 // FIXME: Get object address space 727 llvm::Type *Tys[2] = { IntPtrTy, Int8PtrTy }; 728 llvm::Function *F = CGM.getIntrinsic(llvm::Intrinsic::objectsize, Tys); 729 llvm::Value *Min = Builder.getFalse(); 730 llvm::Value *NullIsUnknown = Builder.getFalse(); 731 llvm::Value *Dynamic = Builder.getFalse(); 732 llvm::Value *CastAddr = Builder.CreateBitCast(Ptr, Int8PtrTy); 733 llvm::Value *LargeEnough = Builder.CreateICmpUGE( 734 Builder.CreateCall(F, {CastAddr, Min, NullIsUnknown, Dynamic}), Size); 735 Checks.push_back(std::make_pair(LargeEnough, SanitizerKind::ObjectSize)); 736 } 737 } 738 739 uint64_t AlignVal = 0; 740 llvm::Value *PtrAsInt = nullptr; 741 742 if (SanOpts.has(SanitizerKind::Alignment) && 743 !SkippedChecks.has(SanitizerKind::Alignment)) { 744 AlignVal = Alignment.getQuantity(); 745 if (!Ty->isIncompleteType() && !AlignVal) 746 AlignVal = getContext().getTypeAlignInChars(Ty).getQuantity(); 747 748 // The glvalue must be suitably aligned. 749 if (AlignVal > 1 && 750 (!PtrToAlloca || PtrToAlloca->getAlignment() < AlignVal)) { 751 PtrAsInt = Builder.CreatePtrToInt(Ptr, IntPtrTy); 752 llvm::Value *Align = Builder.CreateAnd( 753 PtrAsInt, llvm::ConstantInt::get(IntPtrTy, AlignVal - 1)); 754 llvm::Value *Aligned = 755 Builder.CreateICmpEQ(Align, llvm::ConstantInt::get(IntPtrTy, 0)); 756 if (Aligned != True) 757 Checks.push_back(std::make_pair(Aligned, SanitizerKind::Alignment)); 758 } 759 } 760 761 if (Checks.size() > 0) { 762 // Make sure we're not losing information. Alignment needs to be a power of 763 // 2 764 assert(!AlignVal || (uint64_t)1 << llvm::Log2_64(AlignVal) == AlignVal); 765 llvm::Constant *StaticData[] = { 766 EmitCheckSourceLocation(Loc), EmitCheckTypeDescriptor(Ty), 767 llvm::ConstantInt::get(Int8Ty, AlignVal ? llvm::Log2_64(AlignVal) : 1), 768 llvm::ConstantInt::get(Int8Ty, TCK)}; 769 EmitCheck(Checks, SanitizerHandler::TypeMismatch, StaticData, 770 PtrAsInt ? PtrAsInt : Ptr); 771 } 772 773 // If possible, check that the vptr indicates that there is a subobject of 774 // type Ty at offset zero within this object. 775 // 776 // C++11 [basic.life]p5,6: 777 // [For storage which does not refer to an object within its lifetime] 778 // The program has undefined behavior if: 779 // -- the [pointer or glvalue] is used to access a non-static data member 780 // or call a non-static member function 781 if (SanOpts.has(SanitizerKind::Vptr) && 782 !SkippedChecks.has(SanitizerKind::Vptr) && isVptrCheckRequired(TCK, Ty)) { 783 // Ensure that the pointer is non-null before loading it. If there is no 784 // compile-time guarantee, reuse the run-time null check or emit a new one. 785 if (!IsGuaranteedNonNull) { 786 if (!IsNonNull) 787 IsNonNull = Builder.CreateIsNotNull(Ptr); 788 if (!Done) 789 Done = createBasicBlock("vptr.null"); 790 llvm::BasicBlock *VptrNotNull = createBasicBlock("vptr.not.null"); 791 Builder.CreateCondBr(IsNonNull, VptrNotNull, Done); 792 EmitBlock(VptrNotNull); 793 } 794 795 // Compute a hash of the mangled name of the type. 796 // 797 // FIXME: This is not guaranteed to be deterministic! Move to a 798 // fingerprinting mechanism once LLVM provides one. For the time 799 // being the implementation happens to be deterministic. 800 SmallString<64> MangledName; 801 llvm::raw_svector_ostream Out(MangledName); 802 CGM.getCXXABI().getMangleContext().mangleCXXRTTI(Ty.getUnqualifiedType(), 803 Out); 804 805 // Blacklist based on the mangled type. 806 if (!CGM.getContext().getSanitizerBlacklist().isBlacklistedType( 807 SanitizerKind::Vptr, Out.str())) { 808 llvm::hash_code TypeHash = hash_value(Out.str()); 809 810 // Load the vptr, and compute hash_16_bytes(TypeHash, vptr). 811 llvm::Value *Low = llvm::ConstantInt::get(Int64Ty, TypeHash); 812 llvm::Type *VPtrTy = llvm::PointerType::get(IntPtrTy, 0); 813 Address VPtrAddr(Builder.CreateBitCast(Ptr, VPtrTy), getPointerAlign()); 814 llvm::Value *VPtrVal = Builder.CreateLoad(VPtrAddr); 815 llvm::Value *High = Builder.CreateZExt(VPtrVal, Int64Ty); 816 817 llvm::Value *Hash = emitHash16Bytes(Builder, Low, High); 818 Hash = Builder.CreateTrunc(Hash, IntPtrTy); 819 820 // Look the hash up in our cache. 821 const int CacheSize = 128; 822 llvm::Type *HashTable = llvm::ArrayType::get(IntPtrTy, CacheSize); 823 llvm::Value *Cache = CGM.CreateRuntimeVariable(HashTable, 824 "__ubsan_vptr_type_cache"); 825 llvm::Value *Slot = Builder.CreateAnd(Hash, 826 llvm::ConstantInt::get(IntPtrTy, 827 CacheSize-1)); 828 llvm::Value *Indices[] = { Builder.getInt32(0), Slot }; 829 llvm::Value *CacheVal = 830 Builder.CreateAlignedLoad(Builder.CreateInBoundsGEP(Cache, Indices), 831 getPointerAlign()); 832 833 // If the hash isn't in the cache, call a runtime handler to perform the 834 // hard work of checking whether the vptr is for an object of the right 835 // type. This will either fill in the cache and return, or produce a 836 // diagnostic. 837 llvm::Value *EqualHash = Builder.CreateICmpEQ(CacheVal, Hash); 838 llvm::Constant *StaticData[] = { 839 EmitCheckSourceLocation(Loc), 840 EmitCheckTypeDescriptor(Ty), 841 CGM.GetAddrOfRTTIDescriptor(Ty.getUnqualifiedType()), 842 llvm::ConstantInt::get(Int8Ty, TCK) 843 }; 844 llvm::Value *DynamicData[] = { Ptr, Hash }; 845 EmitCheck(std::make_pair(EqualHash, SanitizerKind::Vptr), 846 SanitizerHandler::DynamicTypeCacheMiss, StaticData, 847 DynamicData); 848 } 849 } 850 851 if (Done) { 852 Builder.CreateBr(Done); 853 EmitBlock(Done); 854 } 855 } 856 857 /// Determine whether this expression refers to a flexible array member in a 858 /// struct. We disable array bounds checks for such members. 859 static bool isFlexibleArrayMemberExpr(const Expr *E) { 860 // For compatibility with existing code, we treat arrays of length 0 or 861 // 1 as flexible array members. 862 const ArrayType *AT = E->getType()->castAsArrayTypeUnsafe(); 863 if (const auto *CAT = dyn_cast<ConstantArrayType>(AT)) { 864 if (CAT->getSize().ugt(1)) 865 return false; 866 } else if (!isa<IncompleteArrayType>(AT)) 867 return false; 868 869 E = E->IgnoreParens(); 870 871 // A flexible array member must be the last member in the class. 872 if (const auto *ME = dyn_cast<MemberExpr>(E)) { 873 // FIXME: If the base type of the member expr is not FD->getParent(), 874 // this should not be treated as a flexible array member access. 875 if (const auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) { 876 RecordDecl::field_iterator FI( 877 DeclContext::decl_iterator(const_cast<FieldDecl *>(FD))); 878 return ++FI == FD->getParent()->field_end(); 879 } 880 } else if (const auto *IRE = dyn_cast<ObjCIvarRefExpr>(E)) { 881 return IRE->getDecl()->getNextIvar() == nullptr; 882 } 883 884 return false; 885 } 886 887 llvm::Value *CodeGenFunction::LoadPassedObjectSize(const Expr *E, 888 QualType EltTy) { 889 ASTContext &C = getContext(); 890 uint64_t EltSize = C.getTypeSizeInChars(EltTy).getQuantity(); 891 if (!EltSize) 892 return nullptr; 893 894 auto *ArrayDeclRef = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts()); 895 if (!ArrayDeclRef) 896 return nullptr; 897 898 auto *ParamDecl = dyn_cast<ParmVarDecl>(ArrayDeclRef->getDecl()); 899 if (!ParamDecl) 900 return nullptr; 901 902 auto *POSAttr = ParamDecl->getAttr<PassObjectSizeAttr>(); 903 if (!POSAttr) 904 return nullptr; 905 906 // Don't load the size if it's a lower bound. 907 int POSType = POSAttr->getType(); 908 if (POSType != 0 && POSType != 1) 909 return nullptr; 910 911 // Find the implicit size parameter. 912 auto PassedSizeIt = SizeArguments.find(ParamDecl); 913 if (PassedSizeIt == SizeArguments.end()) 914 return nullptr; 915 916 const ImplicitParamDecl *PassedSizeDecl = PassedSizeIt->second; 917 assert(LocalDeclMap.count(PassedSizeDecl) && "Passed size not loadable"); 918 Address AddrOfSize = LocalDeclMap.find(PassedSizeDecl)->second; 919 llvm::Value *SizeInBytes = EmitLoadOfScalar(AddrOfSize, /*Volatile=*/false, 920 C.getSizeType(), E->getExprLoc()); 921 llvm::Value *SizeOfElement = 922 llvm::ConstantInt::get(SizeInBytes->getType(), EltSize); 923 return Builder.CreateUDiv(SizeInBytes, SizeOfElement); 924 } 925 926 /// If Base is known to point to the start of an array, return the length of 927 /// that array. Return 0 if the length cannot be determined. 928 static llvm::Value *getArrayIndexingBound( 929 CodeGenFunction &CGF, const Expr *Base, QualType &IndexedType) { 930 // For the vector indexing extension, the bound is the number of elements. 931 if (const VectorType *VT = Base->getType()->getAs<VectorType>()) { 932 IndexedType = Base->getType(); 933 return CGF.Builder.getInt32(VT->getNumElements()); 934 } 935 936 Base = Base->IgnoreParens(); 937 938 if (const auto *CE = dyn_cast<CastExpr>(Base)) { 939 if (CE->getCastKind() == CK_ArrayToPointerDecay && 940 !isFlexibleArrayMemberExpr(CE->getSubExpr())) { 941 IndexedType = CE->getSubExpr()->getType(); 942 const ArrayType *AT = IndexedType->castAsArrayTypeUnsafe(); 943 if (const auto *CAT = dyn_cast<ConstantArrayType>(AT)) 944 return CGF.Builder.getInt(CAT->getSize()); 945 else if (const auto *VAT = dyn_cast<VariableArrayType>(AT)) 946 return CGF.getVLASize(VAT).NumElts; 947 // Ignore pass_object_size here. It's not applicable on decayed pointers. 948 } 949 } 950 951 QualType EltTy{Base->getType()->getPointeeOrArrayElementType(), 0}; 952 if (llvm::Value *POS = CGF.LoadPassedObjectSize(Base, EltTy)) { 953 IndexedType = Base->getType(); 954 return POS; 955 } 956 957 return nullptr; 958 } 959 960 void CodeGenFunction::EmitBoundsCheck(const Expr *E, const Expr *Base, 961 llvm::Value *Index, QualType IndexType, 962 bool Accessed) { 963 assert(SanOpts.has(SanitizerKind::ArrayBounds) && 964 "should not be called unless adding bounds checks"); 965 SanitizerScope SanScope(this); 966 967 QualType IndexedType; 968 llvm::Value *Bound = getArrayIndexingBound(*this, Base, IndexedType); 969 if (!Bound) 970 return; 971 972 bool IndexSigned = IndexType->isSignedIntegerOrEnumerationType(); 973 llvm::Value *IndexVal = Builder.CreateIntCast(Index, SizeTy, IndexSigned); 974 llvm::Value *BoundVal = Builder.CreateIntCast(Bound, SizeTy, false); 975 976 llvm::Constant *StaticData[] = { 977 EmitCheckSourceLocation(E->getExprLoc()), 978 EmitCheckTypeDescriptor(IndexedType), 979 EmitCheckTypeDescriptor(IndexType) 980 }; 981 llvm::Value *Check = Accessed ? Builder.CreateICmpULT(IndexVal, BoundVal) 982 : Builder.CreateICmpULE(IndexVal, BoundVal); 983 EmitCheck(std::make_pair(Check, SanitizerKind::ArrayBounds), 984 SanitizerHandler::OutOfBounds, StaticData, Index); 985 } 986 987 988 CodeGenFunction::ComplexPairTy CodeGenFunction:: 989 EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV, 990 bool isInc, bool isPre) { 991 ComplexPairTy InVal = EmitLoadOfComplex(LV, E->getExprLoc()); 992 993 llvm::Value *NextVal; 994 if (isa<llvm::IntegerType>(InVal.first->getType())) { 995 uint64_t AmountVal = isInc ? 1 : -1; 996 NextVal = llvm::ConstantInt::get(InVal.first->getType(), AmountVal, true); 997 998 // Add the inc/dec to the real part. 999 NextVal = Builder.CreateAdd(InVal.first, NextVal, isInc ? "inc" : "dec"); 1000 } else { 1001 QualType ElemTy = E->getType()->getAs<ComplexType>()->getElementType(); 1002 llvm::APFloat FVal(getContext().getFloatTypeSemantics(ElemTy), 1); 1003 if (!isInc) 1004 FVal.changeSign(); 1005 NextVal = llvm::ConstantFP::get(getLLVMContext(), FVal); 1006 1007 // Add the inc/dec to the real part. 1008 NextVal = Builder.CreateFAdd(InVal.first, NextVal, isInc ? "inc" : "dec"); 1009 } 1010 1011 ComplexPairTy IncVal(NextVal, InVal.second); 1012 1013 // Store the updated result through the lvalue. 1014 EmitStoreOfComplex(IncVal, LV, /*init*/ false); 1015 1016 // If this is a postinc, return the value read from memory, otherwise use the 1017 // updated value. 1018 return isPre ? IncVal : InVal; 1019 } 1020 1021 void CodeGenModule::EmitExplicitCastExprType(const ExplicitCastExpr *E, 1022 CodeGenFunction *CGF) { 1023 // Bind VLAs in the cast type. 1024 if (CGF && E->getType()->isVariablyModifiedType()) 1025 CGF->EmitVariablyModifiedType(E->getType()); 1026 1027 if (CGDebugInfo *DI = getModuleDebugInfo()) 1028 DI->EmitExplicitCastType(E->getType()); 1029 } 1030 1031 //===----------------------------------------------------------------------===// 1032 // LValue Expression Emission 1033 //===----------------------------------------------------------------------===// 1034 1035 /// EmitPointerWithAlignment - Given an expression of pointer type, try to 1036 /// derive a more accurate bound on the alignment of the pointer. 1037 Address CodeGenFunction::EmitPointerWithAlignment(const Expr *E, 1038 LValueBaseInfo *BaseInfo, 1039 TBAAAccessInfo *TBAAInfo) { 1040 // We allow this with ObjC object pointers because of fragile ABIs. 1041 assert(E->getType()->isPointerType() || 1042 E->getType()->isObjCObjectPointerType()); 1043 E = E->IgnoreParens(); 1044 1045 // Casts: 1046 if (const CastExpr *CE = dyn_cast<CastExpr>(E)) { 1047 if (const auto *ECE = dyn_cast<ExplicitCastExpr>(CE)) 1048 CGM.EmitExplicitCastExprType(ECE, this); 1049 1050 switch (CE->getCastKind()) { 1051 // Non-converting casts (but not C's implicit conversion from void*). 1052 case CK_BitCast: 1053 case CK_NoOp: 1054 case CK_AddressSpaceConversion: 1055 if (auto PtrTy = CE->getSubExpr()->getType()->getAs<PointerType>()) { 1056 if (PtrTy->getPointeeType()->isVoidType()) 1057 break; 1058 1059 LValueBaseInfo InnerBaseInfo; 1060 TBAAAccessInfo InnerTBAAInfo; 1061 Address Addr = EmitPointerWithAlignment(CE->getSubExpr(), 1062 &InnerBaseInfo, 1063 &InnerTBAAInfo); 1064 if (BaseInfo) *BaseInfo = InnerBaseInfo; 1065 if (TBAAInfo) *TBAAInfo = InnerTBAAInfo; 1066 1067 if (isa<ExplicitCastExpr>(CE)) { 1068 LValueBaseInfo TargetTypeBaseInfo; 1069 TBAAAccessInfo TargetTypeTBAAInfo; 1070 CharUnits Align = getNaturalPointeeTypeAlignment(E->getType(), 1071 &TargetTypeBaseInfo, 1072 &TargetTypeTBAAInfo); 1073 if (TBAAInfo) 1074 *TBAAInfo = CGM.mergeTBAAInfoForCast(*TBAAInfo, 1075 TargetTypeTBAAInfo); 1076 // If the source l-value is opaque, honor the alignment of the 1077 // casted-to type. 1078 if (InnerBaseInfo.getAlignmentSource() != AlignmentSource::Decl) { 1079 if (BaseInfo) 1080 BaseInfo->mergeForCast(TargetTypeBaseInfo); 1081 Addr = Address(Addr.getPointer(), Align); 1082 } 1083 } 1084 1085 if (SanOpts.has(SanitizerKind::CFIUnrelatedCast) && 1086 CE->getCastKind() == CK_BitCast) { 1087 if (auto PT = E->getType()->getAs<PointerType>()) 1088 EmitVTablePtrCheckForCast(PT->getPointeeType(), Addr.getPointer(), 1089 /*MayBeNull=*/true, 1090 CodeGenFunction::CFITCK_UnrelatedCast, 1091 CE->getBeginLoc()); 1092 } 1093 return CE->getCastKind() != CK_AddressSpaceConversion 1094 ? Builder.CreateBitCast(Addr, ConvertType(E->getType())) 1095 : Builder.CreateAddrSpaceCast(Addr, 1096 ConvertType(E->getType())); 1097 } 1098 break; 1099 1100 // Array-to-pointer decay. 1101 case CK_ArrayToPointerDecay: 1102 return EmitArrayToPointerDecay(CE->getSubExpr(), BaseInfo, TBAAInfo); 1103 1104 // Derived-to-base conversions. 1105 case CK_UncheckedDerivedToBase: 1106 case CK_DerivedToBase: { 1107 // TODO: Support accesses to members of base classes in TBAA. For now, we 1108 // conservatively pretend that the complete object is of the base class 1109 // type. 1110 if (TBAAInfo) 1111 *TBAAInfo = CGM.getTBAAAccessInfo(E->getType()); 1112 Address Addr = EmitPointerWithAlignment(CE->getSubExpr(), BaseInfo); 1113 auto Derived = CE->getSubExpr()->getType()->getPointeeCXXRecordDecl(); 1114 return GetAddressOfBaseClass(Addr, Derived, 1115 CE->path_begin(), CE->path_end(), 1116 ShouldNullCheckClassCastValue(CE), 1117 CE->getExprLoc()); 1118 } 1119 1120 // TODO: Is there any reason to treat base-to-derived conversions 1121 // specially? 1122 default: 1123 break; 1124 } 1125 } 1126 1127 // Unary &. 1128 if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) { 1129 if (UO->getOpcode() == UO_AddrOf) { 1130 LValue LV = EmitLValue(UO->getSubExpr()); 1131 if (BaseInfo) *BaseInfo = LV.getBaseInfo(); 1132 if (TBAAInfo) *TBAAInfo = LV.getTBAAInfo(); 1133 return LV.getAddress(); 1134 } 1135 } 1136 1137 // TODO: conditional operators, comma. 1138 1139 // Otherwise, use the alignment of the type. 1140 CharUnits Align = getNaturalPointeeTypeAlignment(E->getType(), BaseInfo, 1141 TBAAInfo); 1142 return Address(EmitScalarExpr(E), Align); 1143 } 1144 1145 RValue CodeGenFunction::GetUndefRValue(QualType Ty) { 1146 if (Ty->isVoidType()) 1147 return RValue::get(nullptr); 1148 1149 switch (getEvaluationKind(Ty)) { 1150 case TEK_Complex: { 1151 llvm::Type *EltTy = 1152 ConvertType(Ty->castAs<ComplexType>()->getElementType()); 1153 llvm::Value *U = llvm::UndefValue::get(EltTy); 1154 return RValue::getComplex(std::make_pair(U, U)); 1155 } 1156 1157 // If this is a use of an undefined aggregate type, the aggregate must have an 1158 // identifiable address. Just because the contents of the value are undefined 1159 // doesn't mean that the address can't be taken and compared. 1160 case TEK_Aggregate: { 1161 Address DestPtr = CreateMemTemp(Ty, "undef.agg.tmp"); 1162 return RValue::getAggregate(DestPtr); 1163 } 1164 1165 case TEK_Scalar: 1166 return RValue::get(llvm::UndefValue::get(ConvertType(Ty))); 1167 } 1168 llvm_unreachable("bad evaluation kind"); 1169 } 1170 1171 RValue CodeGenFunction::EmitUnsupportedRValue(const Expr *E, 1172 const char *Name) { 1173 ErrorUnsupported(E, Name); 1174 return GetUndefRValue(E->getType()); 1175 } 1176 1177 LValue CodeGenFunction::EmitUnsupportedLValue(const Expr *E, 1178 const char *Name) { 1179 ErrorUnsupported(E, Name); 1180 llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType())); 1181 return MakeAddrLValue(Address(llvm::UndefValue::get(Ty), CharUnits::One()), 1182 E->getType()); 1183 } 1184 1185 bool CodeGenFunction::IsWrappedCXXThis(const Expr *Obj) { 1186 const Expr *Base = Obj; 1187 while (!isa<CXXThisExpr>(Base)) { 1188 // The result of a dynamic_cast can be null. 1189 if (isa<CXXDynamicCastExpr>(Base)) 1190 return false; 1191 1192 if (const auto *CE = dyn_cast<CastExpr>(Base)) { 1193 Base = CE->getSubExpr(); 1194 } else if (const auto *PE = dyn_cast<ParenExpr>(Base)) { 1195 Base = PE->getSubExpr(); 1196 } else if (const auto *UO = dyn_cast<UnaryOperator>(Base)) { 1197 if (UO->getOpcode() == UO_Extension) 1198 Base = UO->getSubExpr(); 1199 else 1200 return false; 1201 } else { 1202 return false; 1203 } 1204 } 1205 return true; 1206 } 1207 1208 LValue CodeGenFunction::EmitCheckedLValue(const Expr *E, TypeCheckKind TCK) { 1209 LValue LV; 1210 if (SanOpts.has(SanitizerKind::ArrayBounds) && isa<ArraySubscriptExpr>(E)) 1211 LV = EmitArraySubscriptExpr(cast<ArraySubscriptExpr>(E), /*Accessed*/true); 1212 else 1213 LV = EmitLValue(E); 1214 if (!isa<DeclRefExpr>(E) && !LV.isBitField() && LV.isSimple()) { 1215 SanitizerSet SkippedChecks; 1216 if (const auto *ME = dyn_cast<MemberExpr>(E)) { 1217 bool IsBaseCXXThis = IsWrappedCXXThis(ME->getBase()); 1218 if (IsBaseCXXThis) 1219 SkippedChecks.set(SanitizerKind::Alignment, true); 1220 if (IsBaseCXXThis || isa<DeclRefExpr>(ME->getBase())) 1221 SkippedChecks.set(SanitizerKind::Null, true); 1222 } 1223 EmitTypeCheck(TCK, E->getExprLoc(), LV.getPointer(), 1224 E->getType(), LV.getAlignment(), SkippedChecks); 1225 } 1226 return LV; 1227 } 1228 1229 /// EmitLValue - Emit code to compute a designator that specifies the location 1230 /// of the expression. 1231 /// 1232 /// This can return one of two things: a simple address or a bitfield reference. 1233 /// In either case, the LLVM Value* in the LValue structure is guaranteed to be 1234 /// an LLVM pointer type. 1235 /// 1236 /// If this returns a bitfield reference, nothing about the pointee type of the 1237 /// LLVM value is known: For example, it may not be a pointer to an integer. 1238 /// 1239 /// If this returns a normal address, and if the lvalue's C type is fixed size, 1240 /// this method guarantees that the returned pointer type will point to an LLVM 1241 /// type of the same size of the lvalue's type. If the lvalue has a variable 1242 /// length type, this is not possible. 1243 /// 1244 LValue CodeGenFunction::EmitLValue(const Expr *E) { 1245 ApplyDebugLocation DL(*this, E); 1246 switch (E->getStmtClass()) { 1247 default: return EmitUnsupportedLValue(E, "l-value expression"); 1248 1249 case Expr::ObjCPropertyRefExprClass: 1250 llvm_unreachable("cannot emit a property reference directly"); 1251 1252 case Expr::ObjCSelectorExprClass: 1253 return EmitObjCSelectorLValue(cast<ObjCSelectorExpr>(E)); 1254 case Expr::ObjCIsaExprClass: 1255 return EmitObjCIsaExpr(cast<ObjCIsaExpr>(E)); 1256 case Expr::BinaryOperatorClass: 1257 return EmitBinaryOperatorLValue(cast<BinaryOperator>(E)); 1258 case Expr::CompoundAssignOperatorClass: { 1259 QualType Ty = E->getType(); 1260 if (const AtomicType *AT = Ty->getAs<AtomicType>()) 1261 Ty = AT->getValueType(); 1262 if (!Ty->isAnyComplexType()) 1263 return EmitCompoundAssignmentLValue(cast<CompoundAssignOperator>(E)); 1264 return EmitComplexCompoundAssignmentLValue(cast<CompoundAssignOperator>(E)); 1265 } 1266 case Expr::CallExprClass: 1267 case Expr::CXXMemberCallExprClass: 1268 case Expr::CXXOperatorCallExprClass: 1269 case Expr::UserDefinedLiteralClass: 1270 return EmitCallExprLValue(cast<CallExpr>(E)); 1271 case Expr::VAArgExprClass: 1272 return EmitVAArgExprLValue(cast<VAArgExpr>(E)); 1273 case Expr::DeclRefExprClass: 1274 return EmitDeclRefLValue(cast<DeclRefExpr>(E)); 1275 case Expr::ConstantExprClass: 1276 return EmitLValue(cast<ConstantExpr>(E)->getSubExpr()); 1277 case Expr::ParenExprClass: 1278 return EmitLValue(cast<ParenExpr>(E)->getSubExpr()); 1279 case Expr::GenericSelectionExprClass: 1280 return EmitLValue(cast<GenericSelectionExpr>(E)->getResultExpr()); 1281 case Expr::PredefinedExprClass: 1282 return EmitPredefinedLValue(cast<PredefinedExpr>(E)); 1283 case Expr::StringLiteralClass: 1284 return EmitStringLiteralLValue(cast<StringLiteral>(E)); 1285 case Expr::ObjCEncodeExprClass: 1286 return EmitObjCEncodeExprLValue(cast<ObjCEncodeExpr>(E)); 1287 case Expr::PseudoObjectExprClass: 1288 return EmitPseudoObjectLValue(cast<PseudoObjectExpr>(E)); 1289 case Expr::InitListExprClass: 1290 return EmitInitListLValue(cast<InitListExpr>(E)); 1291 case Expr::CXXTemporaryObjectExprClass: 1292 case Expr::CXXConstructExprClass: 1293 return EmitCXXConstructLValue(cast<CXXConstructExpr>(E)); 1294 case Expr::CXXBindTemporaryExprClass: 1295 return EmitCXXBindTemporaryLValue(cast<CXXBindTemporaryExpr>(E)); 1296 case Expr::CXXUuidofExprClass: 1297 return EmitCXXUuidofLValue(cast<CXXUuidofExpr>(E)); 1298 case Expr::LambdaExprClass: 1299 return EmitAggExprToLValue(E); 1300 1301 case Expr::ExprWithCleanupsClass: { 1302 const auto *cleanups = cast<ExprWithCleanups>(E); 1303 enterFullExpression(cleanups); 1304 RunCleanupsScope Scope(*this); 1305 LValue LV = EmitLValue(cleanups->getSubExpr()); 1306 if (LV.isSimple()) { 1307 // Defend against branches out of gnu statement expressions surrounded by 1308 // cleanups. 1309 llvm::Value *V = LV.getPointer(); 1310 Scope.ForceCleanup({&V}); 1311 return LValue::MakeAddr(Address(V, LV.getAlignment()), LV.getType(), 1312 getContext(), LV.getBaseInfo(), LV.getTBAAInfo()); 1313 } 1314 // FIXME: Is it possible to create an ExprWithCleanups that produces a 1315 // bitfield lvalue or some other non-simple lvalue? 1316 return LV; 1317 } 1318 1319 case Expr::CXXDefaultArgExprClass: { 1320 auto *DAE = cast<CXXDefaultArgExpr>(E); 1321 CXXDefaultArgExprScope Scope(*this, DAE); 1322 return EmitLValue(DAE->getExpr()); 1323 } 1324 case Expr::CXXDefaultInitExprClass: { 1325 auto *DIE = cast<CXXDefaultInitExpr>(E); 1326 CXXDefaultInitExprScope Scope(*this, DIE); 1327 return EmitLValue(DIE->getExpr()); 1328 } 1329 case Expr::CXXTypeidExprClass: 1330 return EmitCXXTypeidLValue(cast<CXXTypeidExpr>(E)); 1331 1332 case Expr::ObjCMessageExprClass: 1333 return EmitObjCMessageExprLValue(cast<ObjCMessageExpr>(E)); 1334 case Expr::ObjCIvarRefExprClass: 1335 return EmitObjCIvarRefLValue(cast<ObjCIvarRefExpr>(E)); 1336 case Expr::StmtExprClass: 1337 return EmitStmtExprLValue(cast<StmtExpr>(E)); 1338 case Expr::UnaryOperatorClass: 1339 return EmitUnaryOpLValue(cast<UnaryOperator>(E)); 1340 case Expr::ArraySubscriptExprClass: 1341 return EmitArraySubscriptExpr(cast<ArraySubscriptExpr>(E)); 1342 case Expr::OMPArraySectionExprClass: 1343 return EmitOMPArraySectionExpr(cast<OMPArraySectionExpr>(E)); 1344 case Expr::ExtVectorElementExprClass: 1345 return EmitExtVectorElementExpr(cast<ExtVectorElementExpr>(E)); 1346 case Expr::MemberExprClass: 1347 return EmitMemberExpr(cast<MemberExpr>(E)); 1348 case Expr::CompoundLiteralExprClass: 1349 return EmitCompoundLiteralLValue(cast<CompoundLiteralExpr>(E)); 1350 case Expr::ConditionalOperatorClass: 1351 return EmitConditionalOperatorLValue(cast<ConditionalOperator>(E)); 1352 case Expr::BinaryConditionalOperatorClass: 1353 return EmitConditionalOperatorLValue(cast<BinaryConditionalOperator>(E)); 1354 case Expr::ChooseExprClass: 1355 return EmitLValue(cast<ChooseExpr>(E)->getChosenSubExpr()); 1356 case Expr::OpaqueValueExprClass: 1357 return EmitOpaqueValueLValue(cast<OpaqueValueExpr>(E)); 1358 case Expr::SubstNonTypeTemplateParmExprClass: 1359 return EmitLValue(cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement()); 1360 case Expr::ImplicitCastExprClass: 1361 case Expr::CStyleCastExprClass: 1362 case Expr::CXXFunctionalCastExprClass: 1363 case Expr::CXXStaticCastExprClass: 1364 case Expr::CXXDynamicCastExprClass: 1365 case Expr::CXXReinterpretCastExprClass: 1366 case Expr::CXXConstCastExprClass: 1367 case Expr::ObjCBridgedCastExprClass: 1368 return EmitCastLValue(cast<CastExpr>(E)); 1369 1370 case Expr::MaterializeTemporaryExprClass: 1371 return EmitMaterializeTemporaryExpr(cast<MaterializeTemporaryExpr>(E)); 1372 1373 case Expr::CoawaitExprClass: 1374 return EmitCoawaitLValue(cast<CoawaitExpr>(E)); 1375 case Expr::CoyieldExprClass: 1376 return EmitCoyieldLValue(cast<CoyieldExpr>(E)); 1377 } 1378 } 1379 1380 /// Given an object of the given canonical type, can we safely copy a 1381 /// value out of it based on its initializer? 1382 static bool isConstantEmittableObjectType(QualType type) { 1383 assert(type.isCanonical()); 1384 assert(!type->isReferenceType()); 1385 1386 // Must be const-qualified but non-volatile. 1387 Qualifiers qs = type.getLocalQualifiers(); 1388 if (!qs.hasConst() || qs.hasVolatile()) return false; 1389 1390 // Otherwise, all object types satisfy this except C++ classes with 1391 // mutable subobjects or non-trivial copy/destroy behavior. 1392 if (const auto *RT = dyn_cast<RecordType>(type)) 1393 if (const auto *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) 1394 if (RD->hasMutableFields() || !RD->isTrivial()) 1395 return false; 1396 1397 return true; 1398 } 1399 1400 /// Can we constant-emit a load of a reference to a variable of the 1401 /// given type? This is different from predicates like 1402 /// Decl::mightBeUsableInConstantExpressions because we do want it to apply 1403 /// in situations that don't necessarily satisfy the language's rules 1404 /// for this (e.g. C++'s ODR-use rules). For example, we want to able 1405 /// to do this with const float variables even if those variables 1406 /// aren't marked 'constexpr'. 1407 enum ConstantEmissionKind { 1408 CEK_None, 1409 CEK_AsReferenceOnly, 1410 CEK_AsValueOrReference, 1411 CEK_AsValueOnly 1412 }; 1413 static ConstantEmissionKind checkVarTypeForConstantEmission(QualType type) { 1414 type = type.getCanonicalType(); 1415 if (const auto *ref = dyn_cast<ReferenceType>(type)) { 1416 if (isConstantEmittableObjectType(ref->getPointeeType())) 1417 return CEK_AsValueOrReference; 1418 return CEK_AsReferenceOnly; 1419 } 1420 if (isConstantEmittableObjectType(type)) 1421 return CEK_AsValueOnly; 1422 return CEK_None; 1423 } 1424 1425 /// Try to emit a reference to the given value without producing it as 1426 /// an l-value. This is just an optimization, but it avoids us needing 1427 /// to emit global copies of variables if they're named without triggering 1428 /// a formal use in a context where we can't emit a direct reference to them, 1429 /// for instance if a block or lambda or a member of a local class uses a 1430 /// const int variable or constexpr variable from an enclosing function. 1431 CodeGenFunction::ConstantEmission 1432 CodeGenFunction::tryEmitAsConstant(DeclRefExpr *refExpr) { 1433 ValueDecl *value = refExpr->getDecl(); 1434 1435 // The value needs to be an enum constant or a constant variable. 1436 ConstantEmissionKind CEK; 1437 if (isa<ParmVarDecl>(value)) { 1438 CEK = CEK_None; 1439 } else if (auto *var = dyn_cast<VarDecl>(value)) { 1440 CEK = checkVarTypeForConstantEmission(var->getType()); 1441 } else if (isa<EnumConstantDecl>(value)) { 1442 CEK = CEK_AsValueOnly; 1443 } else { 1444 CEK = CEK_None; 1445 } 1446 if (CEK == CEK_None) return ConstantEmission(); 1447 1448 Expr::EvalResult result; 1449 bool resultIsReference; 1450 QualType resultType; 1451 1452 // It's best to evaluate all the way as an r-value if that's permitted. 1453 if (CEK != CEK_AsReferenceOnly && 1454 refExpr->EvaluateAsRValue(result, getContext())) { 1455 resultIsReference = false; 1456 resultType = refExpr->getType(); 1457 1458 // Otherwise, try to evaluate as an l-value. 1459 } else if (CEK != CEK_AsValueOnly && 1460 refExpr->EvaluateAsLValue(result, getContext())) { 1461 resultIsReference = true; 1462 resultType = value->getType(); 1463 1464 // Failure. 1465 } else { 1466 return ConstantEmission(); 1467 } 1468 1469 // In any case, if the initializer has side-effects, abandon ship. 1470 if (result.HasSideEffects) 1471 return ConstantEmission(); 1472 1473 // Emit as a constant. 1474 auto C = ConstantEmitter(*this).emitAbstract(refExpr->getLocation(), 1475 result.Val, resultType); 1476 1477 // Make sure we emit a debug reference to the global variable. 1478 // This should probably fire even for 1479 if (isa<VarDecl>(value)) { 1480 if (!getContext().DeclMustBeEmitted(cast<VarDecl>(value))) 1481 EmitDeclRefExprDbgValue(refExpr, result.Val); 1482 } else { 1483 assert(isa<EnumConstantDecl>(value)); 1484 EmitDeclRefExprDbgValue(refExpr, result.Val); 1485 } 1486 1487 // If we emitted a reference constant, we need to dereference that. 1488 if (resultIsReference) 1489 return ConstantEmission::forReference(C); 1490 1491 return ConstantEmission::forValue(C); 1492 } 1493 1494 static DeclRefExpr *tryToConvertMemberExprToDeclRefExpr(CodeGenFunction &CGF, 1495 const MemberExpr *ME) { 1496 if (auto *VD = dyn_cast<VarDecl>(ME->getMemberDecl())) { 1497 // Try to emit static variable member expressions as DREs. 1498 return DeclRefExpr::Create( 1499 CGF.getContext(), NestedNameSpecifierLoc(), SourceLocation(), VD, 1500 /*RefersToEnclosingVariableOrCapture=*/false, ME->getExprLoc(), 1501 ME->getType(), ME->getValueKind(), nullptr, nullptr, ME->isNonOdrUse()); 1502 } 1503 return nullptr; 1504 } 1505 1506 CodeGenFunction::ConstantEmission 1507 CodeGenFunction::tryEmitAsConstant(const MemberExpr *ME) { 1508 if (DeclRefExpr *DRE = tryToConvertMemberExprToDeclRefExpr(*this, ME)) 1509 return tryEmitAsConstant(DRE); 1510 return ConstantEmission(); 1511 } 1512 1513 llvm::Value *CodeGenFunction::emitScalarConstant( 1514 const CodeGenFunction::ConstantEmission &Constant, Expr *E) { 1515 assert(Constant && "not a constant"); 1516 if (Constant.isReference()) 1517 return EmitLoadOfLValue(Constant.getReferenceLValue(*this, E), 1518 E->getExprLoc()) 1519 .getScalarVal(); 1520 return Constant.getValue(); 1521 } 1522 1523 llvm::Value *CodeGenFunction::EmitLoadOfScalar(LValue lvalue, 1524 SourceLocation Loc) { 1525 return EmitLoadOfScalar(lvalue.getAddress(), lvalue.isVolatile(), 1526 lvalue.getType(), Loc, lvalue.getBaseInfo(), 1527 lvalue.getTBAAInfo(), lvalue.isNontemporal()); 1528 } 1529 1530 static bool hasBooleanRepresentation(QualType Ty) { 1531 if (Ty->isBooleanType()) 1532 return true; 1533 1534 if (const EnumType *ET = Ty->getAs<EnumType>()) 1535 return ET->getDecl()->getIntegerType()->isBooleanType(); 1536 1537 if (const AtomicType *AT = Ty->getAs<AtomicType>()) 1538 return hasBooleanRepresentation(AT->getValueType()); 1539 1540 return false; 1541 } 1542 1543 static bool getRangeForType(CodeGenFunction &CGF, QualType Ty, 1544 llvm::APInt &Min, llvm::APInt &End, 1545 bool StrictEnums, bool IsBool) { 1546 const EnumType *ET = Ty->getAs<EnumType>(); 1547 bool IsRegularCPlusPlusEnum = CGF.getLangOpts().CPlusPlus && StrictEnums && 1548 ET && !ET->getDecl()->isFixed(); 1549 if (!IsBool && !IsRegularCPlusPlusEnum) 1550 return false; 1551 1552 if (IsBool) { 1553 Min = llvm::APInt(CGF.getContext().getTypeSize(Ty), 0); 1554 End = llvm::APInt(CGF.getContext().getTypeSize(Ty), 2); 1555 } else { 1556 const EnumDecl *ED = ET->getDecl(); 1557 llvm::Type *LTy = CGF.ConvertTypeForMem(ED->getIntegerType()); 1558 unsigned Bitwidth = LTy->getScalarSizeInBits(); 1559 unsigned NumNegativeBits = ED->getNumNegativeBits(); 1560 unsigned NumPositiveBits = ED->getNumPositiveBits(); 1561 1562 if (NumNegativeBits) { 1563 unsigned NumBits = std::max(NumNegativeBits, NumPositiveBits + 1); 1564 assert(NumBits <= Bitwidth); 1565 End = llvm::APInt(Bitwidth, 1) << (NumBits - 1); 1566 Min = -End; 1567 } else { 1568 assert(NumPositiveBits <= Bitwidth); 1569 End = llvm::APInt(Bitwidth, 1) << NumPositiveBits; 1570 Min = llvm::APInt(Bitwidth, 0); 1571 } 1572 } 1573 return true; 1574 } 1575 1576 llvm::MDNode *CodeGenFunction::getRangeForLoadFromType(QualType Ty) { 1577 llvm::APInt Min, End; 1578 if (!getRangeForType(*this, Ty, Min, End, CGM.getCodeGenOpts().StrictEnums, 1579 hasBooleanRepresentation(Ty))) 1580 return nullptr; 1581 1582 llvm::MDBuilder MDHelper(getLLVMContext()); 1583 return MDHelper.createRange(Min, End); 1584 } 1585 1586 bool CodeGenFunction::EmitScalarRangeCheck(llvm::Value *Value, QualType Ty, 1587 SourceLocation Loc) { 1588 bool HasBoolCheck = SanOpts.has(SanitizerKind::Bool); 1589 bool HasEnumCheck = SanOpts.has(SanitizerKind::Enum); 1590 if (!HasBoolCheck && !HasEnumCheck) 1591 return false; 1592 1593 bool IsBool = hasBooleanRepresentation(Ty) || 1594 NSAPI(CGM.getContext()).isObjCBOOLType(Ty); 1595 bool NeedsBoolCheck = HasBoolCheck && IsBool; 1596 bool NeedsEnumCheck = HasEnumCheck && Ty->getAs<EnumType>(); 1597 if (!NeedsBoolCheck && !NeedsEnumCheck) 1598 return false; 1599 1600 // Single-bit booleans don't need to be checked. Special-case this to avoid 1601 // a bit width mismatch when handling bitfield values. This is handled by 1602 // EmitFromMemory for the non-bitfield case. 1603 if (IsBool && 1604 cast<llvm::IntegerType>(Value->getType())->getBitWidth() == 1) 1605 return false; 1606 1607 llvm::APInt Min, End; 1608 if (!getRangeForType(*this, Ty, Min, End, /*StrictEnums=*/true, IsBool)) 1609 return true; 1610 1611 auto &Ctx = getLLVMContext(); 1612 SanitizerScope SanScope(this); 1613 llvm::Value *Check; 1614 --End; 1615 if (!Min) { 1616 Check = Builder.CreateICmpULE(Value, llvm::ConstantInt::get(Ctx, End)); 1617 } else { 1618 llvm::Value *Upper = 1619 Builder.CreateICmpSLE(Value, llvm::ConstantInt::get(Ctx, End)); 1620 llvm::Value *Lower = 1621 Builder.CreateICmpSGE(Value, llvm::ConstantInt::get(Ctx, Min)); 1622 Check = Builder.CreateAnd(Upper, Lower); 1623 } 1624 llvm::Constant *StaticArgs[] = {EmitCheckSourceLocation(Loc), 1625 EmitCheckTypeDescriptor(Ty)}; 1626 SanitizerMask Kind = 1627 NeedsEnumCheck ? SanitizerKind::Enum : SanitizerKind::Bool; 1628 EmitCheck(std::make_pair(Check, Kind), SanitizerHandler::LoadInvalidValue, 1629 StaticArgs, EmitCheckValue(Value)); 1630 return true; 1631 } 1632 1633 llvm::Value *CodeGenFunction::EmitLoadOfScalar(Address Addr, bool Volatile, 1634 QualType Ty, 1635 SourceLocation Loc, 1636 LValueBaseInfo BaseInfo, 1637 TBAAAccessInfo TBAAInfo, 1638 bool isNontemporal) { 1639 if (!CGM.getCodeGenOpts().PreserveVec3Type) { 1640 // For better performance, handle vector loads differently. 1641 if (Ty->isVectorType()) { 1642 const llvm::Type *EltTy = Addr.getElementType(); 1643 1644 const auto *VTy = cast<llvm::VectorType>(EltTy); 1645 1646 // Handle vectors of size 3 like size 4 for better performance. 1647 if (VTy->getNumElements() == 3) { 1648 1649 // Bitcast to vec4 type. 1650 llvm::VectorType *vec4Ty = 1651 llvm::VectorType::get(VTy->getElementType(), 4); 1652 Address Cast = Builder.CreateElementBitCast(Addr, vec4Ty, "castToVec4"); 1653 // Now load value. 1654 llvm::Value *V = Builder.CreateLoad(Cast, Volatile, "loadVec4"); 1655 1656 // Shuffle vector to get vec3. 1657 V = Builder.CreateShuffleVector(V, llvm::UndefValue::get(vec4Ty), 1658 {0, 1, 2}, "extractVec"); 1659 return EmitFromMemory(V, Ty); 1660 } 1661 } 1662 } 1663 1664 // Atomic operations have to be done on integral types. 1665 LValue AtomicLValue = 1666 LValue::MakeAddr(Addr, Ty, getContext(), BaseInfo, TBAAInfo); 1667 if (Ty->isAtomicType() || LValueIsSuitableForInlineAtomic(AtomicLValue)) { 1668 return EmitAtomicLoad(AtomicLValue, Loc).getScalarVal(); 1669 } 1670 1671 llvm::LoadInst *Load = Builder.CreateLoad(Addr, Volatile); 1672 if (isNontemporal) { 1673 llvm::MDNode *Node = llvm::MDNode::get( 1674 Load->getContext(), llvm::ConstantAsMetadata::get(Builder.getInt32(1))); 1675 Load->setMetadata(CGM.getModule().getMDKindID("nontemporal"), Node); 1676 } 1677 1678 CGM.DecorateInstructionWithTBAA(Load, TBAAInfo); 1679 1680 if (EmitScalarRangeCheck(Load, Ty, Loc)) { 1681 // In order to prevent the optimizer from throwing away the check, don't 1682 // attach range metadata to the load. 1683 } else if (CGM.getCodeGenOpts().OptimizationLevel > 0) 1684 if (llvm::MDNode *RangeInfo = getRangeForLoadFromType(Ty)) 1685 Load->setMetadata(llvm::LLVMContext::MD_range, RangeInfo); 1686 1687 return EmitFromMemory(Load, Ty); 1688 } 1689 1690 llvm::Value *CodeGenFunction::EmitToMemory(llvm::Value *Value, QualType Ty) { 1691 // Bool has a different representation in memory than in registers. 1692 if (hasBooleanRepresentation(Ty)) { 1693 // This should really always be an i1, but sometimes it's already 1694 // an i8, and it's awkward to track those cases down. 1695 if (Value->getType()->isIntegerTy(1)) 1696 return Builder.CreateZExt(Value, ConvertTypeForMem(Ty), "frombool"); 1697 assert(Value->getType()->isIntegerTy(getContext().getTypeSize(Ty)) && 1698 "wrong value rep of bool"); 1699 } 1700 1701 return Value; 1702 } 1703 1704 llvm::Value *CodeGenFunction::EmitFromMemory(llvm::Value *Value, QualType Ty) { 1705 // Bool has a different representation in memory than in registers. 1706 if (hasBooleanRepresentation(Ty)) { 1707 assert(Value->getType()->isIntegerTy(getContext().getTypeSize(Ty)) && 1708 "wrong value rep of bool"); 1709 return Builder.CreateTrunc(Value, Builder.getInt1Ty(), "tobool"); 1710 } 1711 1712 return Value; 1713 } 1714 1715 void CodeGenFunction::EmitStoreOfScalar(llvm::Value *Value, Address Addr, 1716 bool Volatile, QualType Ty, 1717 LValueBaseInfo BaseInfo, 1718 TBAAAccessInfo TBAAInfo, 1719 bool isInit, bool isNontemporal) { 1720 if (!CGM.getCodeGenOpts().PreserveVec3Type) { 1721 // Handle vectors differently to get better performance. 1722 if (Ty->isVectorType()) { 1723 llvm::Type *SrcTy = Value->getType(); 1724 auto *VecTy = dyn_cast<llvm::VectorType>(SrcTy); 1725 // Handle vec3 special. 1726 if (VecTy && VecTy->getNumElements() == 3) { 1727 // Our source is a vec3, do a shuffle vector to make it a vec4. 1728 llvm::Constant *Mask[] = {Builder.getInt32(0), Builder.getInt32(1), 1729 Builder.getInt32(2), 1730 llvm::UndefValue::get(Builder.getInt32Ty())}; 1731 llvm::Value *MaskV = llvm::ConstantVector::get(Mask); 1732 Value = Builder.CreateShuffleVector(Value, llvm::UndefValue::get(VecTy), 1733 MaskV, "extractVec"); 1734 SrcTy = llvm::VectorType::get(VecTy->getElementType(), 4); 1735 } 1736 if (Addr.getElementType() != SrcTy) { 1737 Addr = Builder.CreateElementBitCast(Addr, SrcTy, "storetmp"); 1738 } 1739 } 1740 } 1741 1742 Value = EmitToMemory(Value, Ty); 1743 1744 LValue AtomicLValue = 1745 LValue::MakeAddr(Addr, Ty, getContext(), BaseInfo, TBAAInfo); 1746 if (Ty->isAtomicType() || 1747 (!isInit && LValueIsSuitableForInlineAtomic(AtomicLValue))) { 1748 EmitAtomicStore(RValue::get(Value), AtomicLValue, isInit); 1749 return; 1750 } 1751 1752 llvm::StoreInst *Store = Builder.CreateStore(Value, Addr, Volatile); 1753 if (isNontemporal) { 1754 llvm::MDNode *Node = 1755 llvm::MDNode::get(Store->getContext(), 1756 llvm::ConstantAsMetadata::get(Builder.getInt32(1))); 1757 Store->setMetadata(CGM.getModule().getMDKindID("nontemporal"), Node); 1758 } 1759 1760 CGM.DecorateInstructionWithTBAA(Store, TBAAInfo); 1761 } 1762 1763 void CodeGenFunction::EmitStoreOfScalar(llvm::Value *value, LValue lvalue, 1764 bool isInit) { 1765 EmitStoreOfScalar(value, lvalue.getAddress(), lvalue.isVolatile(), 1766 lvalue.getType(), lvalue.getBaseInfo(), 1767 lvalue.getTBAAInfo(), isInit, lvalue.isNontemporal()); 1768 } 1769 1770 /// EmitLoadOfLValue - Given an expression that represents a value lvalue, this 1771 /// method emits the address of the lvalue, then loads the result as an rvalue, 1772 /// returning the rvalue. 1773 RValue CodeGenFunction::EmitLoadOfLValue(LValue LV, SourceLocation Loc) { 1774 if (LV.isObjCWeak()) { 1775 // load of a __weak object. 1776 Address AddrWeakObj = LV.getAddress(); 1777 return RValue::get(CGM.getObjCRuntime().EmitObjCWeakRead(*this, 1778 AddrWeakObj)); 1779 } 1780 if (LV.getQuals().getObjCLifetime() == Qualifiers::OCL_Weak) { 1781 // In MRC mode, we do a load+autorelease. 1782 if (!getLangOpts().ObjCAutoRefCount) { 1783 return RValue::get(EmitARCLoadWeak(LV.getAddress())); 1784 } 1785 1786 // In ARC mode, we load retained and then consume the value. 1787 llvm::Value *Object = EmitARCLoadWeakRetained(LV.getAddress()); 1788 Object = EmitObjCConsumeObject(LV.getType(), Object); 1789 return RValue::get(Object); 1790 } 1791 1792 if (LV.isSimple()) { 1793 assert(!LV.getType()->isFunctionType()); 1794 1795 // Everything needs a load. 1796 return RValue::get(EmitLoadOfScalar(LV, Loc)); 1797 } 1798 1799 if (LV.isVectorElt()) { 1800 llvm::LoadInst *Load = Builder.CreateLoad(LV.getVectorAddress(), 1801 LV.isVolatileQualified()); 1802 return RValue::get(Builder.CreateExtractElement(Load, LV.getVectorIdx(), 1803 "vecext")); 1804 } 1805 1806 // If this is a reference to a subset of the elements of a vector, either 1807 // shuffle the input or extract/insert them as appropriate. 1808 if (LV.isExtVectorElt()) 1809 return EmitLoadOfExtVectorElementLValue(LV); 1810 1811 // Global Register variables always invoke intrinsics 1812 if (LV.isGlobalReg()) 1813 return EmitLoadOfGlobalRegLValue(LV); 1814 1815 assert(LV.isBitField() && "Unknown LValue type!"); 1816 return EmitLoadOfBitfieldLValue(LV, Loc); 1817 } 1818 1819 RValue CodeGenFunction::EmitLoadOfBitfieldLValue(LValue LV, 1820 SourceLocation Loc) { 1821 const CGBitFieldInfo &Info = LV.getBitFieldInfo(); 1822 1823 // Get the output type. 1824 llvm::Type *ResLTy = ConvertType(LV.getType()); 1825 1826 Address Ptr = LV.getBitFieldAddress(); 1827 llvm::Value *Val = Builder.CreateLoad(Ptr, LV.isVolatileQualified(), "bf.load"); 1828 1829 if (Info.IsSigned) { 1830 assert(static_cast<unsigned>(Info.Offset + Info.Size) <= Info.StorageSize); 1831 unsigned HighBits = Info.StorageSize - Info.Offset - Info.Size; 1832 if (HighBits) 1833 Val = Builder.CreateShl(Val, HighBits, "bf.shl"); 1834 if (Info.Offset + HighBits) 1835 Val = Builder.CreateAShr(Val, Info.Offset + HighBits, "bf.ashr"); 1836 } else { 1837 if (Info.Offset) 1838 Val = Builder.CreateLShr(Val, Info.Offset, "bf.lshr"); 1839 if (static_cast<unsigned>(Info.Offset) + Info.Size < Info.StorageSize) 1840 Val = Builder.CreateAnd(Val, llvm::APInt::getLowBitsSet(Info.StorageSize, 1841 Info.Size), 1842 "bf.clear"); 1843 } 1844 Val = Builder.CreateIntCast(Val, ResLTy, Info.IsSigned, "bf.cast"); 1845 EmitScalarRangeCheck(Val, LV.getType(), Loc); 1846 return RValue::get(Val); 1847 } 1848 1849 // If this is a reference to a subset of the elements of a vector, create an 1850 // appropriate shufflevector. 1851 RValue CodeGenFunction::EmitLoadOfExtVectorElementLValue(LValue LV) { 1852 llvm::Value *Vec = Builder.CreateLoad(LV.getExtVectorAddress(), 1853 LV.isVolatileQualified()); 1854 1855 const llvm::Constant *Elts = LV.getExtVectorElts(); 1856 1857 // If the result of the expression is a non-vector type, we must be extracting 1858 // a single element. Just codegen as an extractelement. 1859 const VectorType *ExprVT = LV.getType()->getAs<VectorType>(); 1860 if (!ExprVT) { 1861 unsigned InIdx = getAccessedFieldNo(0, Elts); 1862 llvm::Value *Elt = llvm::ConstantInt::get(SizeTy, InIdx); 1863 return RValue::get(Builder.CreateExtractElement(Vec, Elt)); 1864 } 1865 1866 // Always use shuffle vector to try to retain the original program structure 1867 unsigned NumResultElts = ExprVT->getNumElements(); 1868 1869 SmallVector<llvm::Constant*, 4> Mask; 1870 for (unsigned i = 0; i != NumResultElts; ++i) 1871 Mask.push_back(Builder.getInt32(getAccessedFieldNo(i, Elts))); 1872 1873 llvm::Value *MaskV = llvm::ConstantVector::get(Mask); 1874 Vec = Builder.CreateShuffleVector(Vec, llvm::UndefValue::get(Vec->getType()), 1875 MaskV); 1876 return RValue::get(Vec); 1877 } 1878 1879 /// Generates lvalue for partial ext_vector access. 1880 Address CodeGenFunction::EmitExtVectorElementLValue(LValue LV) { 1881 Address VectorAddress = LV.getExtVectorAddress(); 1882 const VectorType *ExprVT = LV.getType()->getAs<VectorType>(); 1883 QualType EQT = ExprVT->getElementType(); 1884 llvm::Type *VectorElementTy = CGM.getTypes().ConvertType(EQT); 1885 1886 Address CastToPointerElement = 1887 Builder.CreateElementBitCast(VectorAddress, VectorElementTy, 1888 "conv.ptr.element"); 1889 1890 const llvm::Constant *Elts = LV.getExtVectorElts(); 1891 unsigned ix = getAccessedFieldNo(0, Elts); 1892 1893 Address VectorBasePtrPlusIx = 1894 Builder.CreateConstInBoundsGEP(CastToPointerElement, ix, 1895 "vector.elt"); 1896 1897 return VectorBasePtrPlusIx; 1898 } 1899 1900 /// Load of global gamed gegisters are always calls to intrinsics. 1901 RValue CodeGenFunction::EmitLoadOfGlobalRegLValue(LValue LV) { 1902 assert((LV.getType()->isIntegerType() || LV.getType()->isPointerType()) && 1903 "Bad type for register variable"); 1904 llvm::MDNode *RegName = cast<llvm::MDNode>( 1905 cast<llvm::MetadataAsValue>(LV.getGlobalReg())->getMetadata()); 1906 1907 // We accept integer and pointer types only 1908 llvm::Type *OrigTy = CGM.getTypes().ConvertType(LV.getType()); 1909 llvm::Type *Ty = OrigTy; 1910 if (OrigTy->isPointerTy()) 1911 Ty = CGM.getTypes().getDataLayout().getIntPtrType(OrigTy); 1912 llvm::Type *Types[] = { Ty }; 1913 1914 llvm::Function *F = CGM.getIntrinsic(llvm::Intrinsic::read_register, Types); 1915 llvm::Value *Call = Builder.CreateCall( 1916 F, llvm::MetadataAsValue::get(Ty->getContext(), RegName)); 1917 if (OrigTy->isPointerTy()) 1918 Call = Builder.CreateIntToPtr(Call, OrigTy); 1919 return RValue::get(Call); 1920 } 1921 1922 1923 /// EmitStoreThroughLValue - Store the specified rvalue into the specified 1924 /// lvalue, where both are guaranteed to the have the same type, and that type 1925 /// is 'Ty'. 1926 void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst, 1927 bool isInit) { 1928 if (!Dst.isSimple()) { 1929 if (Dst.isVectorElt()) { 1930 // Read/modify/write the vector, inserting the new element. 1931 llvm::Value *Vec = Builder.CreateLoad(Dst.getVectorAddress(), 1932 Dst.isVolatileQualified()); 1933 Vec = Builder.CreateInsertElement(Vec, Src.getScalarVal(), 1934 Dst.getVectorIdx(), "vecins"); 1935 Builder.CreateStore(Vec, Dst.getVectorAddress(), 1936 Dst.isVolatileQualified()); 1937 return; 1938 } 1939 1940 // If this is an update of extended vector elements, insert them as 1941 // appropriate. 1942 if (Dst.isExtVectorElt()) 1943 return EmitStoreThroughExtVectorComponentLValue(Src, Dst); 1944 1945 if (Dst.isGlobalReg()) 1946 return EmitStoreThroughGlobalRegLValue(Src, Dst); 1947 1948 assert(Dst.isBitField() && "Unknown LValue type"); 1949 return EmitStoreThroughBitfieldLValue(Src, Dst); 1950 } 1951 1952 // There's special magic for assigning into an ARC-qualified l-value. 1953 if (Qualifiers::ObjCLifetime Lifetime = Dst.getQuals().getObjCLifetime()) { 1954 switch (Lifetime) { 1955 case Qualifiers::OCL_None: 1956 llvm_unreachable("present but none"); 1957 1958 case Qualifiers::OCL_ExplicitNone: 1959 // nothing special 1960 break; 1961 1962 case Qualifiers::OCL_Strong: 1963 if (isInit) { 1964 Src = RValue::get(EmitARCRetain(Dst.getType(), Src.getScalarVal())); 1965 break; 1966 } 1967 EmitARCStoreStrong(Dst, Src.getScalarVal(), /*ignore*/ true); 1968 return; 1969 1970 case Qualifiers::OCL_Weak: 1971 if (isInit) 1972 // Initialize and then skip the primitive store. 1973 EmitARCInitWeak(Dst.getAddress(), Src.getScalarVal()); 1974 else 1975 EmitARCStoreWeak(Dst.getAddress(), Src.getScalarVal(), /*ignore*/ true); 1976 return; 1977 1978 case Qualifiers::OCL_Autoreleasing: 1979 Src = RValue::get(EmitObjCExtendObjectLifetime(Dst.getType(), 1980 Src.getScalarVal())); 1981 // fall into the normal path 1982 break; 1983 } 1984 } 1985 1986 if (Dst.isObjCWeak() && !Dst.isNonGC()) { 1987 // load of a __weak object. 1988 Address LvalueDst = Dst.getAddress(); 1989 llvm::Value *src = Src.getScalarVal(); 1990 CGM.getObjCRuntime().EmitObjCWeakAssign(*this, src, LvalueDst); 1991 return; 1992 } 1993 1994 if (Dst.isObjCStrong() && !Dst.isNonGC()) { 1995 // load of a __strong object. 1996 Address LvalueDst = Dst.getAddress(); 1997 llvm::Value *src = Src.getScalarVal(); 1998 if (Dst.isObjCIvar()) { 1999 assert(Dst.getBaseIvarExp() && "BaseIvarExp is NULL"); 2000 llvm::Type *ResultType = IntPtrTy; 2001 Address dst = EmitPointerWithAlignment(Dst.getBaseIvarExp()); 2002 llvm::Value *RHS = dst.getPointer(); 2003 RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast"); 2004 llvm::Value *LHS = 2005 Builder.CreatePtrToInt(LvalueDst.getPointer(), ResultType, 2006 "sub.ptr.lhs.cast"); 2007 llvm::Value *BytesBetween = Builder.CreateSub(LHS, RHS, "ivar.offset"); 2008 CGM.getObjCRuntime().EmitObjCIvarAssign(*this, src, dst, 2009 BytesBetween); 2010 } else if (Dst.isGlobalObjCRef()) { 2011 CGM.getObjCRuntime().EmitObjCGlobalAssign(*this, src, LvalueDst, 2012 Dst.isThreadLocalRef()); 2013 } 2014 else 2015 CGM.getObjCRuntime().EmitObjCStrongCastAssign(*this, src, LvalueDst); 2016 return; 2017 } 2018 2019 assert(Src.isScalar() && "Can't emit an agg store with this method"); 2020 EmitStoreOfScalar(Src.getScalarVal(), Dst, isInit); 2021 } 2022 2023 void CodeGenFunction::EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, 2024 llvm::Value **Result) { 2025 const CGBitFieldInfo &Info = Dst.getBitFieldInfo(); 2026 llvm::Type *ResLTy = ConvertTypeForMem(Dst.getType()); 2027 Address Ptr = Dst.getBitFieldAddress(); 2028 2029 // Get the source value, truncated to the width of the bit-field. 2030 llvm::Value *SrcVal = Src.getScalarVal(); 2031 2032 // Cast the source to the storage type and shift it into place. 2033 SrcVal = Builder.CreateIntCast(SrcVal, Ptr.getElementType(), 2034 /*isSigned=*/false); 2035 llvm::Value *MaskedVal = SrcVal; 2036 2037 // See if there are other bits in the bitfield's storage we'll need to load 2038 // and mask together with source before storing. 2039 if (Info.StorageSize != Info.Size) { 2040 assert(Info.StorageSize > Info.Size && "Invalid bitfield size."); 2041 llvm::Value *Val = 2042 Builder.CreateLoad(Ptr, Dst.isVolatileQualified(), "bf.load"); 2043 2044 // Mask the source value as needed. 2045 if (!hasBooleanRepresentation(Dst.getType())) 2046 SrcVal = Builder.CreateAnd(SrcVal, 2047 llvm::APInt::getLowBitsSet(Info.StorageSize, 2048 Info.Size), 2049 "bf.value"); 2050 MaskedVal = SrcVal; 2051 if (Info.Offset) 2052 SrcVal = Builder.CreateShl(SrcVal, Info.Offset, "bf.shl"); 2053 2054 // Mask out the original value. 2055 Val = Builder.CreateAnd(Val, 2056 ~llvm::APInt::getBitsSet(Info.StorageSize, 2057 Info.Offset, 2058 Info.Offset + Info.Size), 2059 "bf.clear"); 2060 2061 // Or together the unchanged values and the source value. 2062 SrcVal = Builder.CreateOr(Val, SrcVal, "bf.set"); 2063 } else { 2064 assert(Info.Offset == 0); 2065 } 2066 2067 // Write the new value back out. 2068 Builder.CreateStore(SrcVal, Ptr, Dst.isVolatileQualified()); 2069 2070 // Return the new value of the bit-field, if requested. 2071 if (Result) { 2072 llvm::Value *ResultVal = MaskedVal; 2073 2074 // Sign extend the value if needed. 2075 if (Info.IsSigned) { 2076 assert(Info.Size <= Info.StorageSize); 2077 unsigned HighBits = Info.StorageSize - Info.Size; 2078 if (HighBits) { 2079 ResultVal = Builder.CreateShl(ResultVal, HighBits, "bf.result.shl"); 2080 ResultVal = Builder.CreateAShr(ResultVal, HighBits, "bf.result.ashr"); 2081 } 2082 } 2083 2084 ResultVal = Builder.CreateIntCast(ResultVal, ResLTy, Info.IsSigned, 2085 "bf.result.cast"); 2086 *Result = EmitFromMemory(ResultVal, Dst.getType()); 2087 } 2088 } 2089 2090 void CodeGenFunction::EmitStoreThroughExtVectorComponentLValue(RValue Src, 2091 LValue Dst) { 2092 // This access turns into a read/modify/write of the vector. Load the input 2093 // value now. 2094 llvm::Value *Vec = Builder.CreateLoad(Dst.getExtVectorAddress(), 2095 Dst.isVolatileQualified()); 2096 const llvm::Constant *Elts = Dst.getExtVectorElts(); 2097 2098 llvm::Value *SrcVal = Src.getScalarVal(); 2099 2100 if (const VectorType *VTy = Dst.getType()->getAs<VectorType>()) { 2101 unsigned NumSrcElts = VTy->getNumElements(); 2102 unsigned NumDstElts = Vec->getType()->getVectorNumElements(); 2103 if (NumDstElts == NumSrcElts) { 2104 // Use shuffle vector is the src and destination are the same number of 2105 // elements and restore the vector mask since it is on the side it will be 2106 // stored. 2107 SmallVector<llvm::Constant*, 4> Mask(NumDstElts); 2108 for (unsigned i = 0; i != NumSrcElts; ++i) 2109 Mask[getAccessedFieldNo(i, Elts)] = Builder.getInt32(i); 2110 2111 llvm::Value *MaskV = llvm::ConstantVector::get(Mask); 2112 Vec = Builder.CreateShuffleVector(SrcVal, 2113 llvm::UndefValue::get(Vec->getType()), 2114 MaskV); 2115 } else if (NumDstElts > NumSrcElts) { 2116 // Extended the source vector to the same length and then shuffle it 2117 // into the destination. 2118 // FIXME: since we're shuffling with undef, can we just use the indices 2119 // into that? This could be simpler. 2120 SmallVector<llvm::Constant*, 4> ExtMask; 2121 for (unsigned i = 0; i != NumSrcElts; ++i) 2122 ExtMask.push_back(Builder.getInt32(i)); 2123 ExtMask.resize(NumDstElts, llvm::UndefValue::get(Int32Ty)); 2124 llvm::Value *ExtMaskV = llvm::ConstantVector::get(ExtMask); 2125 llvm::Value *ExtSrcVal = 2126 Builder.CreateShuffleVector(SrcVal, 2127 llvm::UndefValue::get(SrcVal->getType()), 2128 ExtMaskV); 2129 // build identity 2130 SmallVector<llvm::Constant*, 4> Mask; 2131 for (unsigned i = 0; i != NumDstElts; ++i) 2132 Mask.push_back(Builder.getInt32(i)); 2133 2134 // When the vector size is odd and .odd or .hi is used, the last element 2135 // of the Elts constant array will be one past the size of the vector. 2136 // Ignore the last element here, if it is greater than the mask size. 2137 if (getAccessedFieldNo(NumSrcElts - 1, Elts) == Mask.size()) 2138 NumSrcElts--; 2139 2140 // modify when what gets shuffled in 2141 for (unsigned i = 0; i != NumSrcElts; ++i) 2142 Mask[getAccessedFieldNo(i, Elts)] = Builder.getInt32(i+NumDstElts); 2143 llvm::Value *MaskV = llvm::ConstantVector::get(Mask); 2144 Vec = Builder.CreateShuffleVector(Vec, ExtSrcVal, MaskV); 2145 } else { 2146 // We should never shorten the vector 2147 llvm_unreachable("unexpected shorten vector length"); 2148 } 2149 } else { 2150 // If the Src is a scalar (not a vector) it must be updating one element. 2151 unsigned InIdx = getAccessedFieldNo(0, Elts); 2152 llvm::Value *Elt = llvm::ConstantInt::get(SizeTy, InIdx); 2153 Vec = Builder.CreateInsertElement(Vec, SrcVal, Elt); 2154 } 2155 2156 Builder.CreateStore(Vec, Dst.getExtVectorAddress(), 2157 Dst.isVolatileQualified()); 2158 } 2159 2160 /// Store of global named registers are always calls to intrinsics. 2161 void CodeGenFunction::EmitStoreThroughGlobalRegLValue(RValue Src, LValue Dst) { 2162 assert((Dst.getType()->isIntegerType() || Dst.getType()->isPointerType()) && 2163 "Bad type for register variable"); 2164 llvm::MDNode *RegName = cast<llvm::MDNode>( 2165 cast<llvm::MetadataAsValue>(Dst.getGlobalReg())->getMetadata()); 2166 assert(RegName && "Register LValue is not metadata"); 2167 2168 // We accept integer and pointer types only 2169 llvm::Type *OrigTy = CGM.getTypes().ConvertType(Dst.getType()); 2170 llvm::Type *Ty = OrigTy; 2171 if (OrigTy->isPointerTy()) 2172 Ty = CGM.getTypes().getDataLayout().getIntPtrType(OrigTy); 2173 llvm::Type *Types[] = { Ty }; 2174 2175 llvm::Function *F = CGM.getIntrinsic(llvm::Intrinsic::write_register, Types); 2176 llvm::Value *Value = Src.getScalarVal(); 2177 if (OrigTy->isPointerTy()) 2178 Value = Builder.CreatePtrToInt(Value, Ty); 2179 Builder.CreateCall( 2180 F, {llvm::MetadataAsValue::get(Ty->getContext(), RegName), Value}); 2181 } 2182 2183 // setObjCGCLValueClass - sets class of the lvalue for the purpose of 2184 // generating write-barries API. It is currently a global, ivar, 2185 // or neither. 2186 static void setObjCGCLValueClass(const ASTContext &Ctx, const Expr *E, 2187 LValue &LV, 2188 bool IsMemberAccess=false) { 2189 if (Ctx.getLangOpts().getGC() == LangOptions::NonGC) 2190 return; 2191 2192 if (isa<ObjCIvarRefExpr>(E)) { 2193 QualType ExpTy = E->getType(); 2194 if (IsMemberAccess && ExpTy->isPointerType()) { 2195 // If ivar is a structure pointer, assigning to field of 2196 // this struct follows gcc's behavior and makes it a non-ivar 2197 // writer-barrier conservatively. 2198 ExpTy = ExpTy->getAs<PointerType>()->getPointeeType(); 2199 if (ExpTy->isRecordType()) { 2200 LV.setObjCIvar(false); 2201 return; 2202 } 2203 } 2204 LV.setObjCIvar(true); 2205 auto *Exp = cast<ObjCIvarRefExpr>(const_cast<Expr *>(E)); 2206 LV.setBaseIvarExp(Exp->getBase()); 2207 LV.setObjCArray(E->getType()->isArrayType()); 2208 return; 2209 } 2210 2211 if (const auto *Exp = dyn_cast<DeclRefExpr>(E)) { 2212 if (const auto *VD = dyn_cast<VarDecl>(Exp->getDecl())) { 2213 if (VD->hasGlobalStorage()) { 2214 LV.setGlobalObjCRef(true); 2215 LV.setThreadLocalRef(VD->getTLSKind() != VarDecl::TLS_None); 2216 } 2217 } 2218 LV.setObjCArray(E->getType()->isArrayType()); 2219 return; 2220 } 2221 2222 if (const auto *Exp = dyn_cast<UnaryOperator>(E)) { 2223 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess); 2224 return; 2225 } 2226 2227 if (const auto *Exp = dyn_cast<ParenExpr>(E)) { 2228 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess); 2229 if (LV.isObjCIvar()) { 2230 // If cast is to a structure pointer, follow gcc's behavior and make it 2231 // a non-ivar write-barrier. 2232 QualType ExpTy = E->getType(); 2233 if (ExpTy->isPointerType()) 2234 ExpTy = ExpTy->getAs<PointerType>()->getPointeeType(); 2235 if (ExpTy->isRecordType()) 2236 LV.setObjCIvar(false); 2237 } 2238 return; 2239 } 2240 2241 if (const auto *Exp = dyn_cast<GenericSelectionExpr>(E)) { 2242 setObjCGCLValueClass(Ctx, Exp->getResultExpr(), LV); 2243 return; 2244 } 2245 2246 if (const auto *Exp = dyn_cast<ImplicitCastExpr>(E)) { 2247 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess); 2248 return; 2249 } 2250 2251 if (const auto *Exp = dyn_cast<CStyleCastExpr>(E)) { 2252 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess); 2253 return; 2254 } 2255 2256 if (const auto *Exp = dyn_cast<ObjCBridgedCastExpr>(E)) { 2257 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess); 2258 return; 2259 } 2260 2261 if (const auto *Exp = dyn_cast<ArraySubscriptExpr>(E)) { 2262 setObjCGCLValueClass(Ctx, Exp->getBase(), LV); 2263 if (LV.isObjCIvar() && !LV.isObjCArray()) 2264 // Using array syntax to assigning to what an ivar points to is not 2265 // same as assigning to the ivar itself. {id *Names;} Names[i] = 0; 2266 LV.setObjCIvar(false); 2267 else if (LV.isGlobalObjCRef() && !LV.isObjCArray()) 2268 // Using array syntax to assigning to what global points to is not 2269 // same as assigning to the global itself. {id *G;} G[i] = 0; 2270 LV.setGlobalObjCRef(false); 2271 return; 2272 } 2273 2274 if (const auto *Exp = dyn_cast<MemberExpr>(E)) { 2275 setObjCGCLValueClass(Ctx, Exp->getBase(), LV, true); 2276 // We don't know if member is an 'ivar', but this flag is looked at 2277 // only in the context of LV.isObjCIvar(). 2278 LV.setObjCArray(E->getType()->isArrayType()); 2279 return; 2280 } 2281 } 2282 2283 static llvm::Value * 2284 EmitBitCastOfLValueToProperType(CodeGenFunction &CGF, 2285 llvm::Value *V, llvm::Type *IRType, 2286 StringRef Name = StringRef()) { 2287 unsigned AS = cast<llvm::PointerType>(V->getType())->getAddressSpace(); 2288 return CGF.Builder.CreateBitCast(V, IRType->getPointerTo(AS), Name); 2289 } 2290 2291 static LValue EmitThreadPrivateVarDeclLValue( 2292 CodeGenFunction &CGF, const VarDecl *VD, QualType T, Address Addr, 2293 llvm::Type *RealVarTy, SourceLocation Loc) { 2294 Addr = CGF.CGM.getOpenMPRuntime().getAddrOfThreadPrivate(CGF, VD, Addr, Loc); 2295 Addr = CGF.Builder.CreateElementBitCast(Addr, RealVarTy); 2296 return CGF.MakeAddrLValue(Addr, T, AlignmentSource::Decl); 2297 } 2298 2299 static Address emitDeclTargetVarDeclLValue(CodeGenFunction &CGF, 2300 const VarDecl *VD, QualType T) { 2301 llvm::Optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res = 2302 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD); 2303 // Return an invalid address if variable is MT_To and unified 2304 // memory is not enabled. For all other cases: MT_Link and 2305 // MT_To with unified memory, return a valid address. 2306 if (!Res || (*Res == OMPDeclareTargetDeclAttr::MT_To && 2307 !CGF.CGM.getOpenMPRuntime().hasRequiresUnifiedSharedMemory())) 2308 return Address::invalid(); 2309 assert(((*Res == OMPDeclareTargetDeclAttr::MT_Link) || 2310 (*Res == OMPDeclareTargetDeclAttr::MT_To && 2311 CGF.CGM.getOpenMPRuntime().hasRequiresUnifiedSharedMemory())) && 2312 "Expected link clause OR to clause with unified memory enabled."); 2313 QualType PtrTy = CGF.getContext().getPointerType(VD->getType()); 2314 Address Addr = CGF.CGM.getOpenMPRuntime().getAddrOfDeclareTargetVar(VD); 2315 return CGF.EmitLoadOfPointer(Addr, PtrTy->castAs<PointerType>()); 2316 } 2317 2318 Address 2319 CodeGenFunction::EmitLoadOfReference(LValue RefLVal, 2320 LValueBaseInfo *PointeeBaseInfo, 2321 TBAAAccessInfo *PointeeTBAAInfo) { 2322 llvm::LoadInst *Load = Builder.CreateLoad(RefLVal.getAddress(), 2323 RefLVal.isVolatile()); 2324 CGM.DecorateInstructionWithTBAA(Load, RefLVal.getTBAAInfo()); 2325 2326 CharUnits Align = getNaturalTypeAlignment(RefLVal.getType()->getPointeeType(), 2327 PointeeBaseInfo, PointeeTBAAInfo, 2328 /* forPointeeType= */ true); 2329 return Address(Load, Align); 2330 } 2331 2332 LValue CodeGenFunction::EmitLoadOfReferenceLValue(LValue RefLVal) { 2333 LValueBaseInfo PointeeBaseInfo; 2334 TBAAAccessInfo PointeeTBAAInfo; 2335 Address PointeeAddr = EmitLoadOfReference(RefLVal, &PointeeBaseInfo, 2336 &PointeeTBAAInfo); 2337 return MakeAddrLValue(PointeeAddr, RefLVal.getType()->getPointeeType(), 2338 PointeeBaseInfo, PointeeTBAAInfo); 2339 } 2340 2341 Address CodeGenFunction::EmitLoadOfPointer(Address Ptr, 2342 const PointerType *PtrTy, 2343 LValueBaseInfo *BaseInfo, 2344 TBAAAccessInfo *TBAAInfo) { 2345 llvm::Value *Addr = Builder.CreateLoad(Ptr); 2346 return Address(Addr, getNaturalTypeAlignment(PtrTy->getPointeeType(), 2347 BaseInfo, TBAAInfo, 2348 /*forPointeeType=*/true)); 2349 } 2350 2351 LValue CodeGenFunction::EmitLoadOfPointerLValue(Address PtrAddr, 2352 const PointerType *PtrTy) { 2353 LValueBaseInfo BaseInfo; 2354 TBAAAccessInfo TBAAInfo; 2355 Address Addr = EmitLoadOfPointer(PtrAddr, PtrTy, &BaseInfo, &TBAAInfo); 2356 return MakeAddrLValue(Addr, PtrTy->getPointeeType(), BaseInfo, TBAAInfo); 2357 } 2358 2359 static LValue EmitGlobalVarDeclLValue(CodeGenFunction &CGF, 2360 const Expr *E, const VarDecl *VD) { 2361 QualType T = E->getType(); 2362 2363 // If it's thread_local, emit a call to its wrapper function instead. 2364 if (VD->getTLSKind() == VarDecl::TLS_Dynamic && 2365 CGF.CGM.getCXXABI().usesThreadWrapperFunction()) 2366 return CGF.CGM.getCXXABI().EmitThreadLocalVarDeclLValue(CGF, VD, T); 2367 // Check if the variable is marked as declare target with link clause in 2368 // device codegen. 2369 if (CGF.getLangOpts().OpenMPIsDevice) { 2370 Address Addr = emitDeclTargetVarDeclLValue(CGF, VD, T); 2371 if (Addr.isValid()) 2372 return CGF.MakeAddrLValue(Addr, T, AlignmentSource::Decl); 2373 } 2374 2375 llvm::Value *V = CGF.CGM.GetAddrOfGlobalVar(VD); 2376 llvm::Type *RealVarTy = CGF.getTypes().ConvertTypeForMem(VD->getType()); 2377 V = EmitBitCastOfLValueToProperType(CGF, V, RealVarTy); 2378 CharUnits Alignment = CGF.getContext().getDeclAlign(VD); 2379 Address Addr(V, Alignment); 2380 // Emit reference to the private copy of the variable if it is an OpenMP 2381 // threadprivate variable. 2382 if (CGF.getLangOpts().OpenMP && !CGF.getLangOpts().OpenMPSimd && 2383 VD->hasAttr<OMPThreadPrivateDeclAttr>()) { 2384 return EmitThreadPrivateVarDeclLValue(CGF, VD, T, Addr, RealVarTy, 2385 E->getExprLoc()); 2386 } 2387 LValue LV = VD->getType()->isReferenceType() ? 2388 CGF.EmitLoadOfReferenceLValue(Addr, VD->getType(), 2389 AlignmentSource::Decl) : 2390 CGF.MakeAddrLValue(Addr, T, AlignmentSource::Decl); 2391 setObjCGCLValueClass(CGF.getContext(), E, LV); 2392 return LV; 2393 } 2394 2395 static llvm::Constant *EmitFunctionDeclPointer(CodeGenModule &CGM, 2396 const FunctionDecl *FD) { 2397 if (FD->hasAttr<WeakRefAttr>()) { 2398 ConstantAddress aliasee = CGM.GetWeakRefReference(FD); 2399 return aliasee.getPointer(); 2400 } 2401 2402 llvm::Constant *V = CGM.GetAddrOfFunction(FD); 2403 if (!FD->hasPrototype()) { 2404 if (const FunctionProtoType *Proto = 2405 FD->getType()->getAs<FunctionProtoType>()) { 2406 // Ugly case: for a K&R-style definition, the type of the definition 2407 // isn't the same as the type of a use. Correct for this with a 2408 // bitcast. 2409 QualType NoProtoType = 2410 CGM.getContext().getFunctionNoProtoType(Proto->getReturnType()); 2411 NoProtoType = CGM.getContext().getPointerType(NoProtoType); 2412 V = llvm::ConstantExpr::getBitCast(V, 2413 CGM.getTypes().ConvertType(NoProtoType)); 2414 } 2415 } 2416 return V; 2417 } 2418 2419 static LValue EmitFunctionDeclLValue(CodeGenFunction &CGF, 2420 const Expr *E, const FunctionDecl *FD) { 2421 llvm::Value *V = EmitFunctionDeclPointer(CGF.CGM, FD); 2422 CharUnits Alignment = CGF.getContext().getDeclAlign(FD); 2423 return CGF.MakeAddrLValue(V, E->getType(), Alignment, 2424 AlignmentSource::Decl); 2425 } 2426 2427 static LValue EmitCapturedFieldLValue(CodeGenFunction &CGF, const FieldDecl *FD, 2428 llvm::Value *ThisValue) { 2429 QualType TagType = CGF.getContext().getTagDeclType(FD->getParent()); 2430 LValue LV = CGF.MakeNaturalAlignAddrLValue(ThisValue, TagType); 2431 return CGF.EmitLValueForField(LV, FD); 2432 } 2433 2434 /// Named Registers are named metadata pointing to the register name 2435 /// which will be read from/written to as an argument to the intrinsic 2436 /// @llvm.read/write_register. 2437 /// So far, only the name is being passed down, but other options such as 2438 /// register type, allocation type or even optimization options could be 2439 /// passed down via the metadata node. 2440 static LValue EmitGlobalNamedRegister(const VarDecl *VD, CodeGenModule &CGM) { 2441 SmallString<64> Name("llvm.named.register."); 2442 AsmLabelAttr *Asm = VD->getAttr<AsmLabelAttr>(); 2443 assert(Asm->getLabel().size() < 64-Name.size() && 2444 "Register name too big"); 2445 Name.append(Asm->getLabel()); 2446 llvm::NamedMDNode *M = 2447 CGM.getModule().getOrInsertNamedMetadata(Name); 2448 if (M->getNumOperands() == 0) { 2449 llvm::MDString *Str = llvm::MDString::get(CGM.getLLVMContext(), 2450 Asm->getLabel()); 2451 llvm::Metadata *Ops[] = {Str}; 2452 M->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops)); 2453 } 2454 2455 CharUnits Alignment = CGM.getContext().getDeclAlign(VD); 2456 2457 llvm::Value *Ptr = 2458 llvm::MetadataAsValue::get(CGM.getLLVMContext(), M->getOperand(0)); 2459 return LValue::MakeGlobalReg(Address(Ptr, Alignment), VD->getType()); 2460 } 2461 2462 /// Determine whether we can emit a reference to \p VD from the current 2463 /// context, despite not necessarily having seen an odr-use of the variable in 2464 /// this context. 2465 static bool canEmitSpuriousReferenceToVariable(CodeGenFunction &CGF, 2466 const DeclRefExpr *E, 2467 const VarDecl *VD, 2468 bool IsConstant) { 2469 // For a variable declared in an enclosing scope, do not emit a spurious 2470 // reference even if we have a capture, as that will emit an unwarranted 2471 // reference to our capture state, and will likely generate worse code than 2472 // emitting a local copy. 2473 if (E->refersToEnclosingVariableOrCapture()) 2474 return false; 2475 2476 // For a local declaration declared in this function, we can always reference 2477 // it even if we don't have an odr-use. 2478 if (VD->hasLocalStorage()) { 2479 return VD->getDeclContext() == 2480 dyn_cast_or_null<DeclContext>(CGF.CurCodeDecl); 2481 } 2482 2483 // For a global declaration, we can emit a reference to it if we know 2484 // for sure that we are able to emit a definition of it. 2485 VD = VD->getDefinition(CGF.getContext()); 2486 if (!VD) 2487 return false; 2488 2489 // Don't emit a spurious reference if it might be to a variable that only 2490 // exists on a different device / target. 2491 // FIXME: This is unnecessarily broad. Check whether this would actually be a 2492 // cross-target reference. 2493 if (CGF.getLangOpts().OpenMP || CGF.getLangOpts().CUDA || 2494 CGF.getLangOpts().OpenCL) { 2495 return false; 2496 } 2497 2498 // We can emit a spurious reference only if the linkage implies that we'll 2499 // be emitting a non-interposable symbol that will be retained until link 2500 // time. 2501 switch (CGF.CGM.getLLVMLinkageVarDefinition(VD, IsConstant)) { 2502 case llvm::GlobalValue::ExternalLinkage: 2503 case llvm::GlobalValue::LinkOnceODRLinkage: 2504 case llvm::GlobalValue::WeakODRLinkage: 2505 case llvm::GlobalValue::InternalLinkage: 2506 case llvm::GlobalValue::PrivateLinkage: 2507 return true; 2508 default: 2509 return false; 2510 } 2511 } 2512 2513 LValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) { 2514 const NamedDecl *ND = E->getDecl(); 2515 QualType T = E->getType(); 2516 2517 assert(E->isNonOdrUse() != NOUR_Unevaluated && 2518 "should not emit an unevaluated operand"); 2519 2520 if (const auto *VD = dyn_cast<VarDecl>(ND)) { 2521 // Global Named registers access via intrinsics only 2522 if (VD->getStorageClass() == SC_Register && 2523 VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl()) 2524 return EmitGlobalNamedRegister(VD, CGM); 2525 2526 // If this DeclRefExpr does not constitute an odr-use of the variable, 2527 // we're not permitted to emit a reference to it in general, and it might 2528 // not be captured if capture would be necessary for a use. Emit the 2529 // constant value directly instead. 2530 if (E->isNonOdrUse() == NOUR_Constant && 2531 (VD->getType()->isReferenceType() || 2532 !canEmitSpuriousReferenceToVariable(*this, E, VD, true))) { 2533 VD->getAnyInitializer(VD); 2534 llvm::Constant *Val = ConstantEmitter(*this).emitAbstract( 2535 E->getLocation(), *VD->evaluateValue(), VD->getType()); 2536 assert(Val && "failed to emit constant expression"); 2537 2538 Address Addr = Address::invalid(); 2539 if (!VD->getType()->isReferenceType()) { 2540 // Spill the constant value to a global. 2541 Addr = CGM.createUnnamedGlobalFrom(*VD, Val, 2542 getContext().getDeclAlign(VD)); 2543 llvm::Type *VarTy = getTypes().ConvertTypeForMem(VD->getType()); 2544 auto *PTy = llvm::PointerType::get( 2545 VarTy, getContext().getTargetAddressSpace(VD->getType())); 2546 if (PTy != Addr.getType()) 2547 Addr = Builder.CreatePointerBitCastOrAddrSpaceCast(Addr, PTy); 2548 } else { 2549 // Should we be using the alignment of the constant pointer we emitted? 2550 CharUnits Alignment = 2551 getNaturalTypeAlignment(E->getType(), 2552 /* BaseInfo= */ nullptr, 2553 /* TBAAInfo= */ nullptr, 2554 /* forPointeeType= */ true); 2555 Addr = Address(Val, Alignment); 2556 } 2557 return MakeAddrLValue(Addr, T, AlignmentSource::Decl); 2558 } 2559 2560 // FIXME: Handle other kinds of non-odr-use DeclRefExprs. 2561 2562 // Check for captured variables. 2563 if (E->refersToEnclosingVariableOrCapture()) { 2564 VD = VD->getCanonicalDecl(); 2565 if (auto *FD = LambdaCaptureFields.lookup(VD)) 2566 return EmitCapturedFieldLValue(*this, FD, CXXABIThisValue); 2567 else if (CapturedStmtInfo) { 2568 auto I = LocalDeclMap.find(VD); 2569 if (I != LocalDeclMap.end()) { 2570 if (VD->getType()->isReferenceType()) 2571 return EmitLoadOfReferenceLValue(I->second, VD->getType(), 2572 AlignmentSource::Decl); 2573 return MakeAddrLValue(I->second, T); 2574 } 2575 LValue CapLVal = 2576 EmitCapturedFieldLValue(*this, CapturedStmtInfo->lookup(VD), 2577 CapturedStmtInfo->getContextValue()); 2578 return MakeAddrLValue( 2579 Address(CapLVal.getPointer(), getContext().getDeclAlign(VD)), 2580 CapLVal.getType(), LValueBaseInfo(AlignmentSource::Decl), 2581 CapLVal.getTBAAInfo()); 2582 } 2583 2584 assert(isa<BlockDecl>(CurCodeDecl)); 2585 Address addr = GetAddrOfBlockDecl(VD); 2586 return MakeAddrLValue(addr, T, AlignmentSource::Decl); 2587 } 2588 } 2589 2590 // FIXME: We should be able to assert this for FunctionDecls as well! 2591 // FIXME: We should be able to assert this for all DeclRefExprs, not just 2592 // those with a valid source location. 2593 assert((ND->isUsed(false) || !isa<VarDecl>(ND) || E->isNonOdrUse() || 2594 !E->getLocation().isValid()) && 2595 "Should not use decl without marking it used!"); 2596 2597 if (ND->hasAttr<WeakRefAttr>()) { 2598 const auto *VD = cast<ValueDecl>(ND); 2599 ConstantAddress Aliasee = CGM.GetWeakRefReference(VD); 2600 return MakeAddrLValue(Aliasee, T, AlignmentSource::Decl); 2601 } 2602 2603 if (const auto *VD = dyn_cast<VarDecl>(ND)) { 2604 // Check if this is a global variable. 2605 if (VD->hasLinkage() || VD->isStaticDataMember()) 2606 return EmitGlobalVarDeclLValue(*this, E, VD); 2607 2608 Address addr = Address::invalid(); 2609 2610 // The variable should generally be present in the local decl map. 2611 auto iter = LocalDeclMap.find(VD); 2612 if (iter != LocalDeclMap.end()) { 2613 addr = iter->second; 2614 2615 // Otherwise, it might be static local we haven't emitted yet for 2616 // some reason; most likely, because it's in an outer function. 2617 } else if (VD->isStaticLocal()) { 2618 addr = Address(CGM.getOrCreateStaticVarDecl( 2619 *VD, CGM.getLLVMLinkageVarDefinition(VD, /*IsConstant=*/false)), 2620 getContext().getDeclAlign(VD)); 2621 2622 // No other cases for now. 2623 } else { 2624 llvm_unreachable("DeclRefExpr for Decl not entered in LocalDeclMap?"); 2625 } 2626 2627 2628 // Check for OpenMP threadprivate variables. 2629 if (getLangOpts().OpenMP && !getLangOpts().OpenMPSimd && 2630 VD->hasAttr<OMPThreadPrivateDeclAttr>()) { 2631 return EmitThreadPrivateVarDeclLValue( 2632 *this, VD, T, addr, getTypes().ConvertTypeForMem(VD->getType()), 2633 E->getExprLoc()); 2634 } 2635 2636 // Drill into block byref variables. 2637 bool isBlockByref = VD->isEscapingByref(); 2638 if (isBlockByref) { 2639 addr = emitBlockByrefAddress(addr, VD); 2640 } 2641 2642 // Drill into reference types. 2643 LValue LV = VD->getType()->isReferenceType() ? 2644 EmitLoadOfReferenceLValue(addr, VD->getType(), AlignmentSource::Decl) : 2645 MakeAddrLValue(addr, T, AlignmentSource::Decl); 2646 2647 bool isLocalStorage = VD->hasLocalStorage(); 2648 2649 bool NonGCable = isLocalStorage && 2650 !VD->getType()->isReferenceType() && 2651 !isBlockByref; 2652 if (NonGCable) { 2653 LV.getQuals().removeObjCGCAttr(); 2654 LV.setNonGC(true); 2655 } 2656 2657 bool isImpreciseLifetime = 2658 (isLocalStorage && !VD->hasAttr<ObjCPreciseLifetimeAttr>()); 2659 if (isImpreciseLifetime) 2660 LV.setARCPreciseLifetime(ARCImpreciseLifetime); 2661 setObjCGCLValueClass(getContext(), E, LV); 2662 return LV; 2663 } 2664 2665 if (const auto *FD = dyn_cast<FunctionDecl>(ND)) 2666 return EmitFunctionDeclLValue(*this, E, FD); 2667 2668 // FIXME: While we're emitting a binding from an enclosing scope, all other 2669 // DeclRefExprs we see should be implicitly treated as if they also refer to 2670 // an enclosing scope. 2671 if (const auto *BD = dyn_cast<BindingDecl>(ND)) 2672 return EmitLValue(BD->getBinding()); 2673 2674 llvm_unreachable("Unhandled DeclRefExpr"); 2675 } 2676 2677 LValue CodeGenFunction::EmitUnaryOpLValue(const UnaryOperator *E) { 2678 // __extension__ doesn't affect lvalue-ness. 2679 if (E->getOpcode() == UO_Extension) 2680 return EmitLValue(E->getSubExpr()); 2681 2682 QualType ExprTy = getContext().getCanonicalType(E->getSubExpr()->getType()); 2683 switch (E->getOpcode()) { 2684 default: llvm_unreachable("Unknown unary operator lvalue!"); 2685 case UO_Deref: { 2686 QualType T = E->getSubExpr()->getType()->getPointeeType(); 2687 assert(!T.isNull() && "CodeGenFunction::EmitUnaryOpLValue: Illegal type"); 2688 2689 LValueBaseInfo BaseInfo; 2690 TBAAAccessInfo TBAAInfo; 2691 Address Addr = EmitPointerWithAlignment(E->getSubExpr(), &BaseInfo, 2692 &TBAAInfo); 2693 LValue LV = MakeAddrLValue(Addr, T, BaseInfo, TBAAInfo); 2694 LV.getQuals().setAddressSpace(ExprTy.getAddressSpace()); 2695 2696 // We should not generate __weak write barrier on indirect reference 2697 // of a pointer to object; as in void foo (__weak id *param); *param = 0; 2698 // But, we continue to generate __strong write barrier on indirect write 2699 // into a pointer to object. 2700 if (getLangOpts().ObjC && 2701 getLangOpts().getGC() != LangOptions::NonGC && 2702 LV.isObjCWeak()) 2703 LV.setNonGC(!E->isOBJCGCCandidate(getContext())); 2704 return LV; 2705 } 2706 case UO_Real: 2707 case UO_Imag: { 2708 LValue LV = EmitLValue(E->getSubExpr()); 2709 assert(LV.isSimple() && "real/imag on non-ordinary l-value"); 2710 2711 // __real is valid on scalars. This is a faster way of testing that. 2712 // __imag can only produce an rvalue on scalars. 2713 if (E->getOpcode() == UO_Real && 2714 !LV.getAddress().getElementType()->isStructTy()) { 2715 assert(E->getSubExpr()->getType()->isArithmeticType()); 2716 return LV; 2717 } 2718 2719 QualType T = ExprTy->castAs<ComplexType>()->getElementType(); 2720 2721 Address Component = 2722 (E->getOpcode() == UO_Real 2723 ? emitAddrOfRealComponent(LV.getAddress(), LV.getType()) 2724 : emitAddrOfImagComponent(LV.getAddress(), LV.getType())); 2725 LValue ElemLV = MakeAddrLValue(Component, T, LV.getBaseInfo(), 2726 CGM.getTBAAInfoForSubobject(LV, T)); 2727 ElemLV.getQuals().addQualifiers(LV.getQuals()); 2728 return ElemLV; 2729 } 2730 case UO_PreInc: 2731 case UO_PreDec: { 2732 LValue LV = EmitLValue(E->getSubExpr()); 2733 bool isInc = E->getOpcode() == UO_PreInc; 2734 2735 if (E->getType()->isAnyComplexType()) 2736 EmitComplexPrePostIncDec(E, LV, isInc, true/*isPre*/); 2737 else 2738 EmitScalarPrePostIncDec(E, LV, isInc, true/*isPre*/); 2739 return LV; 2740 } 2741 } 2742 } 2743 2744 LValue CodeGenFunction::EmitStringLiteralLValue(const StringLiteral *E) { 2745 return MakeAddrLValue(CGM.GetAddrOfConstantStringFromLiteral(E), 2746 E->getType(), AlignmentSource::Decl); 2747 } 2748 2749 LValue CodeGenFunction::EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E) { 2750 return MakeAddrLValue(CGM.GetAddrOfConstantStringFromObjCEncode(E), 2751 E->getType(), AlignmentSource::Decl); 2752 } 2753 2754 LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) { 2755 auto SL = E->getFunctionName(); 2756 assert(SL != nullptr && "No StringLiteral name in PredefinedExpr"); 2757 StringRef FnName = CurFn->getName(); 2758 if (FnName.startswith("\01")) 2759 FnName = FnName.substr(1); 2760 StringRef NameItems[] = { 2761 PredefinedExpr::getIdentKindName(E->getIdentKind()), FnName}; 2762 std::string GVName = llvm::join(NameItems, NameItems + 2, "."); 2763 if (auto *BD = dyn_cast_or_null<BlockDecl>(CurCodeDecl)) { 2764 std::string Name = SL->getString(); 2765 if (!Name.empty()) { 2766 unsigned Discriminator = 2767 CGM.getCXXABI().getMangleContext().getBlockId(BD, true); 2768 if (Discriminator) 2769 Name += "_" + Twine(Discriminator + 1).str(); 2770 auto C = CGM.GetAddrOfConstantCString(Name, GVName.c_str()); 2771 return MakeAddrLValue(C, E->getType(), AlignmentSource::Decl); 2772 } else { 2773 auto C = CGM.GetAddrOfConstantCString(FnName, GVName.c_str()); 2774 return MakeAddrLValue(C, E->getType(), AlignmentSource::Decl); 2775 } 2776 } 2777 auto C = CGM.GetAddrOfConstantStringFromLiteral(SL, GVName); 2778 return MakeAddrLValue(C, E->getType(), AlignmentSource::Decl); 2779 } 2780 2781 /// Emit a type description suitable for use by a runtime sanitizer library. The 2782 /// format of a type descriptor is 2783 /// 2784 /// \code 2785 /// { i16 TypeKind, i16 TypeInfo } 2786 /// \endcode 2787 /// 2788 /// followed by an array of i8 containing the type name. TypeKind is 0 for an 2789 /// integer, 1 for a floating point value, and -1 for anything else. 2790 llvm::Constant *CodeGenFunction::EmitCheckTypeDescriptor(QualType T) { 2791 // Only emit each type's descriptor once. 2792 if (llvm::Constant *C = CGM.getTypeDescriptorFromMap(T)) 2793 return C; 2794 2795 uint16_t TypeKind = -1; 2796 uint16_t TypeInfo = 0; 2797 2798 if (T->isIntegerType()) { 2799 TypeKind = 0; 2800 TypeInfo = (llvm::Log2_32(getContext().getTypeSize(T)) << 1) | 2801 (T->isSignedIntegerType() ? 1 : 0); 2802 } else if (T->isFloatingType()) { 2803 TypeKind = 1; 2804 TypeInfo = getContext().getTypeSize(T); 2805 } 2806 2807 // Format the type name as if for a diagnostic, including quotes and 2808 // optionally an 'aka'. 2809 SmallString<32> Buffer; 2810 CGM.getDiags().ConvertArgToString(DiagnosticsEngine::ak_qualtype, 2811 (intptr_t)T.getAsOpaquePtr(), 2812 StringRef(), StringRef(), None, Buffer, 2813 None); 2814 2815 llvm::Constant *Components[] = { 2816 Builder.getInt16(TypeKind), Builder.getInt16(TypeInfo), 2817 llvm::ConstantDataArray::getString(getLLVMContext(), Buffer) 2818 }; 2819 llvm::Constant *Descriptor = llvm::ConstantStruct::getAnon(Components); 2820 2821 auto *GV = new llvm::GlobalVariable( 2822 CGM.getModule(), Descriptor->getType(), 2823 /*isConstant=*/true, llvm::GlobalVariable::PrivateLinkage, Descriptor); 2824 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); 2825 CGM.getSanitizerMetadata()->disableSanitizerForGlobal(GV); 2826 2827 // Remember the descriptor for this type. 2828 CGM.setTypeDescriptorInMap(T, GV); 2829 2830 return GV; 2831 } 2832 2833 llvm::Value *CodeGenFunction::EmitCheckValue(llvm::Value *V) { 2834 llvm::Type *TargetTy = IntPtrTy; 2835 2836 if (V->getType() == TargetTy) 2837 return V; 2838 2839 // Floating-point types which fit into intptr_t are bitcast to integers 2840 // and then passed directly (after zero-extension, if necessary). 2841 if (V->getType()->isFloatingPointTy()) { 2842 unsigned Bits = V->getType()->getPrimitiveSizeInBits(); 2843 if (Bits <= TargetTy->getIntegerBitWidth()) 2844 V = Builder.CreateBitCast(V, llvm::Type::getIntNTy(getLLVMContext(), 2845 Bits)); 2846 } 2847 2848 // Integers which fit in intptr_t are zero-extended and passed directly. 2849 if (V->getType()->isIntegerTy() && 2850 V->getType()->getIntegerBitWidth() <= TargetTy->getIntegerBitWidth()) 2851 return Builder.CreateZExt(V, TargetTy); 2852 2853 // Pointers are passed directly, everything else is passed by address. 2854 if (!V->getType()->isPointerTy()) { 2855 Address Ptr = CreateDefaultAlignTempAlloca(V->getType()); 2856 Builder.CreateStore(V, Ptr); 2857 V = Ptr.getPointer(); 2858 } 2859 return Builder.CreatePtrToInt(V, TargetTy); 2860 } 2861 2862 /// Emit a representation of a SourceLocation for passing to a handler 2863 /// in a sanitizer runtime library. The format for this data is: 2864 /// \code 2865 /// struct SourceLocation { 2866 /// const char *Filename; 2867 /// int32_t Line, Column; 2868 /// }; 2869 /// \endcode 2870 /// For an invalid SourceLocation, the Filename pointer is null. 2871 llvm::Constant *CodeGenFunction::EmitCheckSourceLocation(SourceLocation Loc) { 2872 llvm::Constant *Filename; 2873 int Line, Column; 2874 2875 PresumedLoc PLoc = getContext().getSourceManager().getPresumedLoc(Loc); 2876 if (PLoc.isValid()) { 2877 StringRef FilenameString = PLoc.getFilename(); 2878 2879 int PathComponentsToStrip = 2880 CGM.getCodeGenOpts().EmitCheckPathComponentsToStrip; 2881 if (PathComponentsToStrip < 0) { 2882 assert(PathComponentsToStrip != INT_MIN); 2883 int PathComponentsToKeep = -PathComponentsToStrip; 2884 auto I = llvm::sys::path::rbegin(FilenameString); 2885 auto E = llvm::sys::path::rend(FilenameString); 2886 while (I != E && --PathComponentsToKeep) 2887 ++I; 2888 2889 FilenameString = FilenameString.substr(I - E); 2890 } else if (PathComponentsToStrip > 0) { 2891 auto I = llvm::sys::path::begin(FilenameString); 2892 auto E = llvm::sys::path::end(FilenameString); 2893 while (I != E && PathComponentsToStrip--) 2894 ++I; 2895 2896 if (I != E) 2897 FilenameString = 2898 FilenameString.substr(I - llvm::sys::path::begin(FilenameString)); 2899 else 2900 FilenameString = llvm::sys::path::filename(FilenameString); 2901 } 2902 2903 auto FilenameGV = CGM.GetAddrOfConstantCString(FilenameString, ".src"); 2904 CGM.getSanitizerMetadata()->disableSanitizerForGlobal( 2905 cast<llvm::GlobalVariable>(FilenameGV.getPointer())); 2906 Filename = FilenameGV.getPointer(); 2907 Line = PLoc.getLine(); 2908 Column = PLoc.getColumn(); 2909 } else { 2910 Filename = llvm::Constant::getNullValue(Int8PtrTy); 2911 Line = Column = 0; 2912 } 2913 2914 llvm::Constant *Data[] = {Filename, Builder.getInt32(Line), 2915 Builder.getInt32(Column)}; 2916 2917 return llvm::ConstantStruct::getAnon(Data); 2918 } 2919 2920 namespace { 2921 /// Specify under what conditions this check can be recovered 2922 enum class CheckRecoverableKind { 2923 /// Always terminate program execution if this check fails. 2924 Unrecoverable, 2925 /// Check supports recovering, runtime has both fatal (noreturn) and 2926 /// non-fatal handlers for this check. 2927 Recoverable, 2928 /// Runtime conditionally aborts, always need to support recovery. 2929 AlwaysRecoverable 2930 }; 2931 } 2932 2933 static CheckRecoverableKind getRecoverableKind(SanitizerMask Kind) { 2934 assert(Kind.countPopulation() == 1); 2935 if (Kind == SanitizerKind::Function || Kind == SanitizerKind::Vptr) 2936 return CheckRecoverableKind::AlwaysRecoverable; 2937 else if (Kind == SanitizerKind::Return || Kind == SanitizerKind::Unreachable) 2938 return CheckRecoverableKind::Unrecoverable; 2939 else 2940 return CheckRecoverableKind::Recoverable; 2941 } 2942 2943 namespace { 2944 struct SanitizerHandlerInfo { 2945 char const *const Name; 2946 unsigned Version; 2947 }; 2948 } 2949 2950 const SanitizerHandlerInfo SanitizerHandlers[] = { 2951 #define SANITIZER_CHECK(Enum, Name, Version) {#Name, Version}, 2952 LIST_SANITIZER_CHECKS 2953 #undef SANITIZER_CHECK 2954 }; 2955 2956 static void emitCheckHandlerCall(CodeGenFunction &CGF, 2957 llvm::FunctionType *FnType, 2958 ArrayRef<llvm::Value *> FnArgs, 2959 SanitizerHandler CheckHandler, 2960 CheckRecoverableKind RecoverKind, bool IsFatal, 2961 llvm::BasicBlock *ContBB) { 2962 assert(IsFatal || RecoverKind != CheckRecoverableKind::Unrecoverable); 2963 Optional<ApplyDebugLocation> DL; 2964 if (!CGF.Builder.getCurrentDebugLocation()) { 2965 // Ensure that the call has at least an artificial debug location. 2966 DL.emplace(CGF, SourceLocation()); 2967 } 2968 bool NeedsAbortSuffix = 2969 IsFatal && RecoverKind != CheckRecoverableKind::Unrecoverable; 2970 bool MinimalRuntime = CGF.CGM.getCodeGenOpts().SanitizeMinimalRuntime; 2971 const SanitizerHandlerInfo &CheckInfo = SanitizerHandlers[CheckHandler]; 2972 const StringRef CheckName = CheckInfo.Name; 2973 std::string FnName = "__ubsan_handle_" + CheckName.str(); 2974 if (CheckInfo.Version && !MinimalRuntime) 2975 FnName += "_v" + llvm::utostr(CheckInfo.Version); 2976 if (MinimalRuntime) 2977 FnName += "_minimal"; 2978 if (NeedsAbortSuffix) 2979 FnName += "_abort"; 2980 bool MayReturn = 2981 !IsFatal || RecoverKind == CheckRecoverableKind::AlwaysRecoverable; 2982 2983 llvm::AttrBuilder B; 2984 if (!MayReturn) { 2985 B.addAttribute(llvm::Attribute::NoReturn) 2986 .addAttribute(llvm::Attribute::NoUnwind); 2987 } 2988 B.addAttribute(llvm::Attribute::UWTable); 2989 2990 llvm::FunctionCallee Fn = CGF.CGM.CreateRuntimeFunction( 2991 FnType, FnName, 2992 llvm::AttributeList::get(CGF.getLLVMContext(), 2993 llvm::AttributeList::FunctionIndex, B), 2994 /*Local=*/true); 2995 llvm::CallInst *HandlerCall = CGF.EmitNounwindRuntimeCall(Fn, FnArgs); 2996 if (!MayReturn) { 2997 HandlerCall->setDoesNotReturn(); 2998 CGF.Builder.CreateUnreachable(); 2999 } else { 3000 CGF.Builder.CreateBr(ContBB); 3001 } 3002 } 3003 3004 void CodeGenFunction::EmitCheck( 3005 ArrayRef<std::pair<llvm::Value *, SanitizerMask>> Checked, 3006 SanitizerHandler CheckHandler, ArrayRef<llvm::Constant *> StaticArgs, 3007 ArrayRef<llvm::Value *> DynamicArgs) { 3008 assert(IsSanitizerScope); 3009 assert(Checked.size() > 0); 3010 assert(CheckHandler >= 0 && 3011 size_t(CheckHandler) < llvm::array_lengthof(SanitizerHandlers)); 3012 const StringRef CheckName = SanitizerHandlers[CheckHandler].Name; 3013 3014 llvm::Value *FatalCond = nullptr; 3015 llvm::Value *RecoverableCond = nullptr; 3016 llvm::Value *TrapCond = nullptr; 3017 for (int i = 0, n = Checked.size(); i < n; ++i) { 3018 llvm::Value *Check = Checked[i].first; 3019 // -fsanitize-trap= overrides -fsanitize-recover=. 3020 llvm::Value *&Cond = 3021 CGM.getCodeGenOpts().SanitizeTrap.has(Checked[i].second) 3022 ? TrapCond 3023 : CGM.getCodeGenOpts().SanitizeRecover.has(Checked[i].second) 3024 ? RecoverableCond 3025 : FatalCond; 3026 Cond = Cond ? Builder.CreateAnd(Cond, Check) : Check; 3027 } 3028 3029 if (TrapCond) 3030 EmitTrapCheck(TrapCond); 3031 if (!FatalCond && !RecoverableCond) 3032 return; 3033 3034 llvm::Value *JointCond; 3035 if (FatalCond && RecoverableCond) 3036 JointCond = Builder.CreateAnd(FatalCond, RecoverableCond); 3037 else 3038 JointCond = FatalCond ? FatalCond : RecoverableCond; 3039 assert(JointCond); 3040 3041 CheckRecoverableKind RecoverKind = getRecoverableKind(Checked[0].second); 3042 assert(SanOpts.has(Checked[0].second)); 3043 #ifndef NDEBUG 3044 for (int i = 1, n = Checked.size(); i < n; ++i) { 3045 assert(RecoverKind == getRecoverableKind(Checked[i].second) && 3046 "All recoverable kinds in a single check must be same!"); 3047 assert(SanOpts.has(Checked[i].second)); 3048 } 3049 #endif 3050 3051 llvm::BasicBlock *Cont = createBasicBlock("cont"); 3052 llvm::BasicBlock *Handlers = createBasicBlock("handler." + CheckName); 3053 llvm::Instruction *Branch = Builder.CreateCondBr(JointCond, Cont, Handlers); 3054 // Give hint that we very much don't expect to execute the handler 3055 // Value chosen to match UR_NONTAKEN_WEIGHT, see BranchProbabilityInfo.cpp 3056 llvm::MDBuilder MDHelper(getLLVMContext()); 3057 llvm::MDNode *Node = MDHelper.createBranchWeights((1U << 20) - 1, 1); 3058 Branch->setMetadata(llvm::LLVMContext::MD_prof, Node); 3059 EmitBlock(Handlers); 3060 3061 // Handler functions take an i8* pointing to the (handler-specific) static 3062 // information block, followed by a sequence of intptr_t arguments 3063 // representing operand values. 3064 SmallVector<llvm::Value *, 4> Args; 3065 SmallVector<llvm::Type *, 4> ArgTypes; 3066 if (!CGM.getCodeGenOpts().SanitizeMinimalRuntime) { 3067 Args.reserve(DynamicArgs.size() + 1); 3068 ArgTypes.reserve(DynamicArgs.size() + 1); 3069 3070 // Emit handler arguments and create handler function type. 3071 if (!StaticArgs.empty()) { 3072 llvm::Constant *Info = llvm::ConstantStruct::getAnon(StaticArgs); 3073 auto *InfoPtr = 3074 new llvm::GlobalVariable(CGM.getModule(), Info->getType(), false, 3075 llvm::GlobalVariable::PrivateLinkage, Info); 3076 InfoPtr->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); 3077 CGM.getSanitizerMetadata()->disableSanitizerForGlobal(InfoPtr); 3078 Args.push_back(Builder.CreateBitCast(InfoPtr, Int8PtrTy)); 3079 ArgTypes.push_back(Int8PtrTy); 3080 } 3081 3082 for (size_t i = 0, n = DynamicArgs.size(); i != n; ++i) { 3083 Args.push_back(EmitCheckValue(DynamicArgs[i])); 3084 ArgTypes.push_back(IntPtrTy); 3085 } 3086 } 3087 3088 llvm::FunctionType *FnType = 3089 llvm::FunctionType::get(CGM.VoidTy, ArgTypes, false); 3090 3091 if (!FatalCond || !RecoverableCond) { 3092 // Simple case: we need to generate a single handler call, either 3093 // fatal, or non-fatal. 3094 emitCheckHandlerCall(*this, FnType, Args, CheckHandler, RecoverKind, 3095 (FatalCond != nullptr), Cont); 3096 } else { 3097 // Emit two handler calls: first one for set of unrecoverable checks, 3098 // another one for recoverable. 3099 llvm::BasicBlock *NonFatalHandlerBB = 3100 createBasicBlock("non_fatal." + CheckName); 3101 llvm::BasicBlock *FatalHandlerBB = createBasicBlock("fatal." + CheckName); 3102 Builder.CreateCondBr(FatalCond, NonFatalHandlerBB, FatalHandlerBB); 3103 EmitBlock(FatalHandlerBB); 3104 emitCheckHandlerCall(*this, FnType, Args, CheckHandler, RecoverKind, true, 3105 NonFatalHandlerBB); 3106 EmitBlock(NonFatalHandlerBB); 3107 emitCheckHandlerCall(*this, FnType, Args, CheckHandler, RecoverKind, false, 3108 Cont); 3109 } 3110 3111 EmitBlock(Cont); 3112 } 3113 3114 void CodeGenFunction::EmitCfiSlowPathCheck( 3115 SanitizerMask Kind, llvm::Value *Cond, llvm::ConstantInt *TypeId, 3116 llvm::Value *Ptr, ArrayRef<llvm::Constant *> StaticArgs) { 3117 llvm::BasicBlock *Cont = createBasicBlock("cfi.cont"); 3118 3119 llvm::BasicBlock *CheckBB = createBasicBlock("cfi.slowpath"); 3120 llvm::BranchInst *BI = Builder.CreateCondBr(Cond, Cont, CheckBB); 3121 3122 llvm::MDBuilder MDHelper(getLLVMContext()); 3123 llvm::MDNode *Node = MDHelper.createBranchWeights((1U << 20) - 1, 1); 3124 BI->setMetadata(llvm::LLVMContext::MD_prof, Node); 3125 3126 EmitBlock(CheckBB); 3127 3128 bool WithDiag = !CGM.getCodeGenOpts().SanitizeTrap.has(Kind); 3129 3130 llvm::CallInst *CheckCall; 3131 llvm::FunctionCallee SlowPathFn; 3132 if (WithDiag) { 3133 llvm::Constant *Info = llvm::ConstantStruct::getAnon(StaticArgs); 3134 auto *InfoPtr = 3135 new llvm::GlobalVariable(CGM.getModule(), Info->getType(), false, 3136 llvm::GlobalVariable::PrivateLinkage, Info); 3137 InfoPtr->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); 3138 CGM.getSanitizerMetadata()->disableSanitizerForGlobal(InfoPtr); 3139 3140 SlowPathFn = CGM.getModule().getOrInsertFunction( 3141 "__cfi_slowpath_diag", 3142 llvm::FunctionType::get(VoidTy, {Int64Ty, Int8PtrTy, Int8PtrTy}, 3143 false)); 3144 CheckCall = Builder.CreateCall( 3145 SlowPathFn, {TypeId, Ptr, Builder.CreateBitCast(InfoPtr, Int8PtrTy)}); 3146 } else { 3147 SlowPathFn = CGM.getModule().getOrInsertFunction( 3148 "__cfi_slowpath", 3149 llvm::FunctionType::get(VoidTy, {Int64Ty, Int8PtrTy}, false)); 3150 CheckCall = Builder.CreateCall(SlowPathFn, {TypeId, Ptr}); 3151 } 3152 3153 CGM.setDSOLocal( 3154 cast<llvm::GlobalValue>(SlowPathFn.getCallee()->stripPointerCasts())); 3155 CheckCall->setDoesNotThrow(); 3156 3157 EmitBlock(Cont); 3158 } 3159 3160 // Emit a stub for __cfi_check function so that the linker knows about this 3161 // symbol in LTO mode. 3162 void CodeGenFunction::EmitCfiCheckStub() { 3163 llvm::Module *M = &CGM.getModule(); 3164 auto &Ctx = M->getContext(); 3165 llvm::Function *F = llvm::Function::Create( 3166 llvm::FunctionType::get(VoidTy, {Int64Ty, Int8PtrTy, Int8PtrTy}, false), 3167 llvm::GlobalValue::WeakAnyLinkage, "__cfi_check", M); 3168 CGM.setDSOLocal(F); 3169 llvm::BasicBlock *BB = llvm::BasicBlock::Create(Ctx, "entry", F); 3170 // FIXME: consider emitting an intrinsic call like 3171 // call void @llvm.cfi_check(i64 %0, i8* %1, i8* %2) 3172 // which can be lowered in CrossDSOCFI pass to the actual contents of 3173 // __cfi_check. This would allow inlining of __cfi_check calls. 3174 llvm::CallInst::Create( 3175 llvm::Intrinsic::getDeclaration(M, llvm::Intrinsic::trap), "", BB); 3176 llvm::ReturnInst::Create(Ctx, nullptr, BB); 3177 } 3178 3179 // This function is basically a switch over the CFI failure kind, which is 3180 // extracted from CFICheckFailData (1st function argument). Each case is either 3181 // llvm.trap or a call to one of the two runtime handlers, based on 3182 // -fsanitize-trap and -fsanitize-recover settings. Default case (invalid 3183 // failure kind) traps, but this should really never happen. CFICheckFailData 3184 // can be nullptr if the calling module has -fsanitize-trap behavior for this 3185 // check kind; in this case __cfi_check_fail traps as well. 3186 void CodeGenFunction::EmitCfiCheckFail() { 3187 SanitizerScope SanScope(this); 3188 FunctionArgList Args; 3189 ImplicitParamDecl ArgData(getContext(), getContext().VoidPtrTy, 3190 ImplicitParamDecl::Other); 3191 ImplicitParamDecl ArgAddr(getContext(), getContext().VoidPtrTy, 3192 ImplicitParamDecl::Other); 3193 Args.push_back(&ArgData); 3194 Args.push_back(&ArgAddr); 3195 3196 const CGFunctionInfo &FI = 3197 CGM.getTypes().arrangeBuiltinFunctionDeclaration(getContext().VoidTy, Args); 3198 3199 llvm::Function *F = llvm::Function::Create( 3200 llvm::FunctionType::get(VoidTy, {VoidPtrTy, VoidPtrTy}, false), 3201 llvm::GlobalValue::WeakODRLinkage, "__cfi_check_fail", &CGM.getModule()); 3202 F->setVisibility(llvm::GlobalValue::HiddenVisibility); 3203 3204 StartFunction(GlobalDecl(), CGM.getContext().VoidTy, F, FI, Args, 3205 SourceLocation()); 3206 3207 // This function should not be affected by blacklist. This function does 3208 // not have a source location, but "src:*" would still apply. Revert any 3209 // changes to SanOpts made in StartFunction. 3210 SanOpts = CGM.getLangOpts().Sanitize; 3211 3212 llvm::Value *Data = 3213 EmitLoadOfScalar(GetAddrOfLocalVar(&ArgData), /*Volatile=*/false, 3214 CGM.getContext().VoidPtrTy, ArgData.getLocation()); 3215 llvm::Value *Addr = 3216 EmitLoadOfScalar(GetAddrOfLocalVar(&ArgAddr), /*Volatile=*/false, 3217 CGM.getContext().VoidPtrTy, ArgAddr.getLocation()); 3218 3219 // Data == nullptr means the calling module has trap behaviour for this check. 3220 llvm::Value *DataIsNotNullPtr = 3221 Builder.CreateICmpNE(Data, llvm::ConstantPointerNull::get(Int8PtrTy)); 3222 EmitTrapCheck(DataIsNotNullPtr); 3223 3224 llvm::StructType *SourceLocationTy = 3225 llvm::StructType::get(VoidPtrTy, Int32Ty, Int32Ty); 3226 llvm::StructType *CfiCheckFailDataTy = 3227 llvm::StructType::get(Int8Ty, SourceLocationTy, VoidPtrTy); 3228 3229 llvm::Value *V = Builder.CreateConstGEP2_32( 3230 CfiCheckFailDataTy, 3231 Builder.CreatePointerCast(Data, CfiCheckFailDataTy->getPointerTo(0)), 0, 3232 0); 3233 Address CheckKindAddr(V, getIntAlign()); 3234 llvm::Value *CheckKind = Builder.CreateLoad(CheckKindAddr); 3235 3236 llvm::Value *AllVtables = llvm::MetadataAsValue::get( 3237 CGM.getLLVMContext(), 3238 llvm::MDString::get(CGM.getLLVMContext(), "all-vtables")); 3239 llvm::Value *ValidVtable = Builder.CreateZExt( 3240 Builder.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::type_test), 3241 {Addr, AllVtables}), 3242 IntPtrTy); 3243 3244 const std::pair<int, SanitizerMask> CheckKinds[] = { 3245 {CFITCK_VCall, SanitizerKind::CFIVCall}, 3246 {CFITCK_NVCall, SanitizerKind::CFINVCall}, 3247 {CFITCK_DerivedCast, SanitizerKind::CFIDerivedCast}, 3248 {CFITCK_UnrelatedCast, SanitizerKind::CFIUnrelatedCast}, 3249 {CFITCK_ICall, SanitizerKind::CFIICall}}; 3250 3251 SmallVector<std::pair<llvm::Value *, SanitizerMask>, 5> Checks; 3252 for (auto CheckKindMaskPair : CheckKinds) { 3253 int Kind = CheckKindMaskPair.first; 3254 SanitizerMask Mask = CheckKindMaskPair.second; 3255 llvm::Value *Cond = 3256 Builder.CreateICmpNE(CheckKind, llvm::ConstantInt::get(Int8Ty, Kind)); 3257 if (CGM.getLangOpts().Sanitize.has(Mask)) 3258 EmitCheck(std::make_pair(Cond, Mask), SanitizerHandler::CFICheckFail, {}, 3259 {Data, Addr, ValidVtable}); 3260 else 3261 EmitTrapCheck(Cond); 3262 } 3263 3264 FinishFunction(); 3265 // The only reference to this function will be created during LTO link. 3266 // Make sure it survives until then. 3267 CGM.addUsedGlobal(F); 3268 } 3269 3270 void CodeGenFunction::EmitUnreachable(SourceLocation Loc) { 3271 if (SanOpts.has(SanitizerKind::Unreachable)) { 3272 SanitizerScope SanScope(this); 3273 EmitCheck(std::make_pair(static_cast<llvm::Value *>(Builder.getFalse()), 3274 SanitizerKind::Unreachable), 3275 SanitizerHandler::BuiltinUnreachable, 3276 EmitCheckSourceLocation(Loc), None); 3277 } 3278 Builder.CreateUnreachable(); 3279 } 3280 3281 void CodeGenFunction::EmitTrapCheck(llvm::Value *Checked) { 3282 llvm::BasicBlock *Cont = createBasicBlock("cont"); 3283 3284 // If we're optimizing, collapse all calls to trap down to just one per 3285 // function to save on code size. 3286 if (!CGM.getCodeGenOpts().OptimizationLevel || !TrapBB) { 3287 TrapBB = createBasicBlock("trap"); 3288 Builder.CreateCondBr(Checked, Cont, TrapBB); 3289 EmitBlock(TrapBB); 3290 llvm::CallInst *TrapCall = EmitTrapCall(llvm::Intrinsic::trap); 3291 TrapCall->setDoesNotReturn(); 3292 TrapCall->setDoesNotThrow(); 3293 Builder.CreateUnreachable(); 3294 } else { 3295 Builder.CreateCondBr(Checked, Cont, TrapBB); 3296 } 3297 3298 EmitBlock(Cont); 3299 } 3300 3301 llvm::CallInst *CodeGenFunction::EmitTrapCall(llvm::Intrinsic::ID IntrID) { 3302 llvm::CallInst *TrapCall = Builder.CreateCall(CGM.getIntrinsic(IntrID)); 3303 3304 if (!CGM.getCodeGenOpts().TrapFuncName.empty()) { 3305 auto A = llvm::Attribute::get(getLLVMContext(), "trap-func-name", 3306 CGM.getCodeGenOpts().TrapFuncName); 3307 TrapCall->addAttribute(llvm::AttributeList::FunctionIndex, A); 3308 } 3309 3310 return TrapCall; 3311 } 3312 3313 Address CodeGenFunction::EmitArrayToPointerDecay(const Expr *E, 3314 LValueBaseInfo *BaseInfo, 3315 TBAAAccessInfo *TBAAInfo) { 3316 assert(E->getType()->isArrayType() && 3317 "Array to pointer decay must have array source type!"); 3318 3319 // Expressions of array type can't be bitfields or vector elements. 3320 LValue LV = EmitLValue(E); 3321 Address Addr = LV.getAddress(); 3322 3323 // If the array type was an incomplete type, we need to make sure 3324 // the decay ends up being the right type. 3325 llvm::Type *NewTy = ConvertType(E->getType()); 3326 Addr = Builder.CreateElementBitCast(Addr, NewTy); 3327 3328 // Note that VLA pointers are always decayed, so we don't need to do 3329 // anything here. 3330 if (!E->getType()->isVariableArrayType()) { 3331 assert(isa<llvm::ArrayType>(Addr.getElementType()) && 3332 "Expected pointer to array"); 3333 Addr = Builder.CreateConstArrayGEP(Addr, 0, "arraydecay"); 3334 } 3335 3336 // The result of this decay conversion points to an array element within the 3337 // base lvalue. However, since TBAA currently does not support representing 3338 // accesses to elements of member arrays, we conservatively represent accesses 3339 // to the pointee object as if it had no any base lvalue specified. 3340 // TODO: Support TBAA for member arrays. 3341 QualType EltType = E->getType()->castAsArrayTypeUnsafe()->getElementType(); 3342 if (BaseInfo) *BaseInfo = LV.getBaseInfo(); 3343 if (TBAAInfo) *TBAAInfo = CGM.getTBAAAccessInfo(EltType); 3344 3345 return Builder.CreateElementBitCast(Addr, ConvertTypeForMem(EltType)); 3346 } 3347 3348 /// isSimpleArrayDecayOperand - If the specified expr is a simple decay from an 3349 /// array to pointer, return the array subexpression. 3350 static const Expr *isSimpleArrayDecayOperand(const Expr *E) { 3351 // If this isn't just an array->pointer decay, bail out. 3352 const auto *CE = dyn_cast<CastExpr>(E); 3353 if (!CE || CE->getCastKind() != CK_ArrayToPointerDecay) 3354 return nullptr; 3355 3356 // If this is a decay from variable width array, bail out. 3357 const Expr *SubExpr = CE->getSubExpr(); 3358 if (SubExpr->getType()->isVariableArrayType()) 3359 return nullptr; 3360 3361 return SubExpr; 3362 } 3363 3364 static llvm::Value *emitArraySubscriptGEP(CodeGenFunction &CGF, 3365 llvm::Value *ptr, 3366 ArrayRef<llvm::Value*> indices, 3367 bool inbounds, 3368 bool signedIndices, 3369 SourceLocation loc, 3370 const llvm::Twine &name = "arrayidx") { 3371 if (inbounds) { 3372 return CGF.EmitCheckedInBoundsGEP(ptr, indices, signedIndices, 3373 CodeGenFunction::NotSubtraction, loc, 3374 name); 3375 } else { 3376 return CGF.Builder.CreateGEP(ptr, indices, name); 3377 } 3378 } 3379 3380 static CharUnits getArrayElementAlign(CharUnits arrayAlign, 3381 llvm::Value *idx, 3382 CharUnits eltSize) { 3383 // If we have a constant index, we can use the exact offset of the 3384 // element we're accessing. 3385 if (auto constantIdx = dyn_cast<llvm::ConstantInt>(idx)) { 3386 CharUnits offset = constantIdx->getZExtValue() * eltSize; 3387 return arrayAlign.alignmentAtOffset(offset); 3388 3389 // Otherwise, use the worst-case alignment for any element. 3390 } else { 3391 return arrayAlign.alignmentOfArrayElement(eltSize); 3392 } 3393 } 3394 3395 static QualType getFixedSizeElementType(const ASTContext &ctx, 3396 const VariableArrayType *vla) { 3397 QualType eltType; 3398 do { 3399 eltType = vla->getElementType(); 3400 } while ((vla = ctx.getAsVariableArrayType(eltType))); 3401 return eltType; 3402 } 3403 3404 static Address emitArraySubscriptGEP(CodeGenFunction &CGF, Address addr, 3405 ArrayRef<llvm::Value *> indices, 3406 QualType eltType, bool inbounds, 3407 bool signedIndices, SourceLocation loc, 3408 const llvm::Twine &name = "arrayidx") { 3409 // All the indices except that last must be zero. 3410 #ifndef NDEBUG 3411 for (auto idx : indices.drop_back()) 3412 assert(isa<llvm::ConstantInt>(idx) && 3413 cast<llvm::ConstantInt>(idx)->isZero()); 3414 #endif 3415 3416 // Determine the element size of the statically-sized base. This is 3417 // the thing that the indices are expressed in terms of. 3418 if (auto vla = CGF.getContext().getAsVariableArrayType(eltType)) { 3419 eltType = getFixedSizeElementType(CGF.getContext(), vla); 3420 } 3421 3422 // We can use that to compute the best alignment of the element. 3423 CharUnits eltSize = CGF.getContext().getTypeSizeInChars(eltType); 3424 CharUnits eltAlign = 3425 getArrayElementAlign(addr.getAlignment(), indices.back(), eltSize); 3426 3427 llvm::Value *eltPtr; 3428 auto LastIndex = dyn_cast<llvm::ConstantInt>(indices.back()); 3429 if (!CGF.IsInPreservedAIRegion || !LastIndex) { 3430 eltPtr = emitArraySubscriptGEP( 3431 CGF, addr.getPointer(), indices, inbounds, signedIndices, 3432 loc, name); 3433 } else { 3434 // Remember the original array subscript for bpf target 3435 unsigned idx = LastIndex->getZExtValue(); 3436 eltPtr = CGF.Builder.CreatePreserveArrayAccessIndex(addr.getPointer(), 3437 indices.size() - 1, 3438 idx); 3439 } 3440 3441 return Address(eltPtr, eltAlign); 3442 } 3443 3444 LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E, 3445 bool Accessed) { 3446 // The index must always be an integer, which is not an aggregate. Emit it 3447 // in lexical order (this complexity is, sadly, required by C++17). 3448 llvm::Value *IdxPre = 3449 (E->getLHS() == E->getIdx()) ? EmitScalarExpr(E->getIdx()) : nullptr; 3450 bool SignedIndices = false; 3451 auto EmitIdxAfterBase = [&, IdxPre](bool Promote) -> llvm::Value * { 3452 auto *Idx = IdxPre; 3453 if (E->getLHS() != E->getIdx()) { 3454 assert(E->getRHS() == E->getIdx() && "index was neither LHS nor RHS"); 3455 Idx = EmitScalarExpr(E->getIdx()); 3456 } 3457 3458 QualType IdxTy = E->getIdx()->getType(); 3459 bool IdxSigned = IdxTy->isSignedIntegerOrEnumerationType(); 3460 SignedIndices |= IdxSigned; 3461 3462 if (SanOpts.has(SanitizerKind::ArrayBounds)) 3463 EmitBoundsCheck(E, E->getBase(), Idx, IdxTy, Accessed); 3464 3465 // Extend or truncate the index type to 32 or 64-bits. 3466 if (Promote && Idx->getType() != IntPtrTy) 3467 Idx = Builder.CreateIntCast(Idx, IntPtrTy, IdxSigned, "idxprom"); 3468 3469 return Idx; 3470 }; 3471 IdxPre = nullptr; 3472 3473 // If the base is a vector type, then we are forming a vector element lvalue 3474 // with this subscript. 3475 if (E->getBase()->getType()->isVectorType() && 3476 !isa<ExtVectorElementExpr>(E->getBase())) { 3477 // Emit the vector as an lvalue to get its address. 3478 LValue LHS = EmitLValue(E->getBase()); 3479 auto *Idx = EmitIdxAfterBase(/*Promote*/false); 3480 assert(LHS.isSimple() && "Can only subscript lvalue vectors here!"); 3481 return LValue::MakeVectorElt(LHS.getAddress(), Idx, E->getBase()->getType(), 3482 LHS.getBaseInfo(), TBAAAccessInfo()); 3483 } 3484 3485 // All the other cases basically behave like simple offsetting. 3486 3487 // Handle the extvector case we ignored above. 3488 if (isa<ExtVectorElementExpr>(E->getBase())) { 3489 LValue LV = EmitLValue(E->getBase()); 3490 auto *Idx = EmitIdxAfterBase(/*Promote*/true); 3491 Address Addr = EmitExtVectorElementLValue(LV); 3492 3493 QualType EltType = LV.getType()->castAs<VectorType>()->getElementType(); 3494 Addr = emitArraySubscriptGEP(*this, Addr, Idx, EltType, /*inbounds*/ true, 3495 SignedIndices, E->getExprLoc()); 3496 return MakeAddrLValue(Addr, EltType, LV.getBaseInfo(), 3497 CGM.getTBAAInfoForSubobject(LV, EltType)); 3498 } 3499 3500 LValueBaseInfo EltBaseInfo; 3501 TBAAAccessInfo EltTBAAInfo; 3502 Address Addr = Address::invalid(); 3503 if (const VariableArrayType *vla = 3504 getContext().getAsVariableArrayType(E->getType())) { 3505 // The base must be a pointer, which is not an aggregate. Emit 3506 // it. It needs to be emitted first in case it's what captures 3507 // the VLA bounds. 3508 Addr = EmitPointerWithAlignment(E->getBase(), &EltBaseInfo, &EltTBAAInfo); 3509 auto *Idx = EmitIdxAfterBase(/*Promote*/true); 3510 3511 // The element count here is the total number of non-VLA elements. 3512 llvm::Value *numElements = getVLASize(vla).NumElts; 3513 3514 // Effectively, the multiply by the VLA size is part of the GEP. 3515 // GEP indexes are signed, and scaling an index isn't permitted to 3516 // signed-overflow, so we use the same semantics for our explicit 3517 // multiply. We suppress this if overflow is not undefined behavior. 3518 if (getLangOpts().isSignedOverflowDefined()) { 3519 Idx = Builder.CreateMul(Idx, numElements); 3520 } else { 3521 Idx = Builder.CreateNSWMul(Idx, numElements); 3522 } 3523 3524 Addr = emitArraySubscriptGEP(*this, Addr, Idx, vla->getElementType(), 3525 !getLangOpts().isSignedOverflowDefined(), 3526 SignedIndices, E->getExprLoc()); 3527 3528 } else if (const ObjCObjectType *OIT = E->getType()->getAs<ObjCObjectType>()){ 3529 // Indexing over an interface, as in "NSString *P; P[4];" 3530 3531 // Emit the base pointer. 3532 Addr = EmitPointerWithAlignment(E->getBase(), &EltBaseInfo, &EltTBAAInfo); 3533 auto *Idx = EmitIdxAfterBase(/*Promote*/true); 3534 3535 CharUnits InterfaceSize = getContext().getTypeSizeInChars(OIT); 3536 llvm::Value *InterfaceSizeVal = 3537 llvm::ConstantInt::get(Idx->getType(), InterfaceSize.getQuantity()); 3538 3539 llvm::Value *ScaledIdx = Builder.CreateMul(Idx, InterfaceSizeVal); 3540 3541 // We don't necessarily build correct LLVM struct types for ObjC 3542 // interfaces, so we can't rely on GEP to do this scaling 3543 // correctly, so we need to cast to i8*. FIXME: is this actually 3544 // true? A lot of other things in the fragile ABI would break... 3545 llvm::Type *OrigBaseTy = Addr.getType(); 3546 Addr = Builder.CreateElementBitCast(Addr, Int8Ty); 3547 3548 // Do the GEP. 3549 CharUnits EltAlign = 3550 getArrayElementAlign(Addr.getAlignment(), Idx, InterfaceSize); 3551 llvm::Value *EltPtr = 3552 emitArraySubscriptGEP(*this, Addr.getPointer(), ScaledIdx, false, 3553 SignedIndices, E->getExprLoc()); 3554 Addr = Address(EltPtr, EltAlign); 3555 3556 // Cast back. 3557 Addr = Builder.CreateBitCast(Addr, OrigBaseTy); 3558 } else if (const Expr *Array = isSimpleArrayDecayOperand(E->getBase())) { 3559 // If this is A[i] where A is an array, the frontend will have decayed the 3560 // base to be a ArrayToPointerDecay implicit cast. While correct, it is 3561 // inefficient at -O0 to emit a "gep A, 0, 0" when codegen'ing it, then a 3562 // "gep x, i" here. Emit one "gep A, 0, i". 3563 assert(Array->getType()->isArrayType() && 3564 "Array to pointer decay must have array source type!"); 3565 LValue ArrayLV; 3566 // For simple multidimensional array indexing, set the 'accessed' flag for 3567 // better bounds-checking of the base expression. 3568 if (const auto *ASE = dyn_cast<ArraySubscriptExpr>(Array)) 3569 ArrayLV = EmitArraySubscriptExpr(ASE, /*Accessed*/ true); 3570 else 3571 ArrayLV = EmitLValue(Array); 3572 auto *Idx = EmitIdxAfterBase(/*Promote*/true); 3573 3574 // Propagate the alignment from the array itself to the result. 3575 Addr = emitArraySubscriptGEP( 3576 *this, ArrayLV.getAddress(), {CGM.getSize(CharUnits::Zero()), Idx}, 3577 E->getType(), !getLangOpts().isSignedOverflowDefined(), SignedIndices, 3578 E->getExprLoc()); 3579 EltBaseInfo = ArrayLV.getBaseInfo(); 3580 EltTBAAInfo = CGM.getTBAAInfoForSubobject(ArrayLV, E->getType()); 3581 } else { 3582 // The base must be a pointer; emit it with an estimate of its alignment. 3583 Addr = EmitPointerWithAlignment(E->getBase(), &EltBaseInfo, &EltTBAAInfo); 3584 auto *Idx = EmitIdxAfterBase(/*Promote*/true); 3585 Addr = emitArraySubscriptGEP(*this, Addr, Idx, E->getType(), 3586 !getLangOpts().isSignedOverflowDefined(), 3587 SignedIndices, E->getExprLoc()); 3588 } 3589 3590 LValue LV = MakeAddrLValue(Addr, E->getType(), EltBaseInfo, EltTBAAInfo); 3591 3592 if (getLangOpts().ObjC && 3593 getLangOpts().getGC() != LangOptions::NonGC) { 3594 LV.setNonGC(!E->isOBJCGCCandidate(getContext())); 3595 setObjCGCLValueClass(getContext(), E, LV); 3596 } 3597 return LV; 3598 } 3599 3600 static Address emitOMPArraySectionBase(CodeGenFunction &CGF, const Expr *Base, 3601 LValueBaseInfo &BaseInfo, 3602 TBAAAccessInfo &TBAAInfo, 3603 QualType BaseTy, QualType ElTy, 3604 bool IsLowerBound) { 3605 LValue BaseLVal; 3606 if (auto *ASE = dyn_cast<OMPArraySectionExpr>(Base->IgnoreParenImpCasts())) { 3607 BaseLVal = CGF.EmitOMPArraySectionExpr(ASE, IsLowerBound); 3608 if (BaseTy->isArrayType()) { 3609 Address Addr = BaseLVal.getAddress(); 3610 BaseInfo = BaseLVal.getBaseInfo(); 3611 3612 // If the array type was an incomplete type, we need to make sure 3613 // the decay ends up being the right type. 3614 llvm::Type *NewTy = CGF.ConvertType(BaseTy); 3615 Addr = CGF.Builder.CreateElementBitCast(Addr, NewTy); 3616 3617 // Note that VLA pointers are always decayed, so we don't need to do 3618 // anything here. 3619 if (!BaseTy->isVariableArrayType()) { 3620 assert(isa<llvm::ArrayType>(Addr.getElementType()) && 3621 "Expected pointer to array"); 3622 Addr = CGF.Builder.CreateConstArrayGEP(Addr, 0, "arraydecay"); 3623 } 3624 3625 return CGF.Builder.CreateElementBitCast(Addr, 3626 CGF.ConvertTypeForMem(ElTy)); 3627 } 3628 LValueBaseInfo TypeBaseInfo; 3629 TBAAAccessInfo TypeTBAAInfo; 3630 CharUnits Align = CGF.getNaturalTypeAlignment(ElTy, &TypeBaseInfo, 3631 &TypeTBAAInfo); 3632 BaseInfo.mergeForCast(TypeBaseInfo); 3633 TBAAInfo = CGF.CGM.mergeTBAAInfoForCast(TBAAInfo, TypeTBAAInfo); 3634 return Address(CGF.Builder.CreateLoad(BaseLVal.getAddress()), Align); 3635 } 3636 return CGF.EmitPointerWithAlignment(Base, &BaseInfo, &TBAAInfo); 3637 } 3638 3639 LValue CodeGenFunction::EmitOMPArraySectionExpr(const OMPArraySectionExpr *E, 3640 bool IsLowerBound) { 3641 QualType BaseTy = OMPArraySectionExpr::getBaseOriginalType(E->getBase()); 3642 QualType ResultExprTy; 3643 if (auto *AT = getContext().getAsArrayType(BaseTy)) 3644 ResultExprTy = AT->getElementType(); 3645 else 3646 ResultExprTy = BaseTy->getPointeeType(); 3647 llvm::Value *Idx = nullptr; 3648 if (IsLowerBound || E->getColonLoc().isInvalid()) { 3649 // Requesting lower bound or upper bound, but without provided length and 3650 // without ':' symbol for the default length -> length = 1. 3651 // Idx = LowerBound ?: 0; 3652 if (auto *LowerBound = E->getLowerBound()) { 3653 Idx = Builder.CreateIntCast( 3654 EmitScalarExpr(LowerBound), IntPtrTy, 3655 LowerBound->getType()->hasSignedIntegerRepresentation()); 3656 } else 3657 Idx = llvm::ConstantInt::getNullValue(IntPtrTy); 3658 } else { 3659 // Try to emit length or lower bound as constant. If this is possible, 1 3660 // is subtracted from constant length or lower bound. Otherwise, emit LLVM 3661 // IR (LB + Len) - 1. 3662 auto &C = CGM.getContext(); 3663 auto *Length = E->getLength(); 3664 llvm::APSInt ConstLength; 3665 if (Length) { 3666 // Idx = LowerBound + Length - 1; 3667 if (Length->isIntegerConstantExpr(ConstLength, C)) { 3668 ConstLength = ConstLength.zextOrTrunc(PointerWidthInBits); 3669 Length = nullptr; 3670 } 3671 auto *LowerBound = E->getLowerBound(); 3672 llvm::APSInt ConstLowerBound(PointerWidthInBits, /*isUnsigned=*/false); 3673 if (LowerBound && LowerBound->isIntegerConstantExpr(ConstLowerBound, C)) { 3674 ConstLowerBound = ConstLowerBound.zextOrTrunc(PointerWidthInBits); 3675 LowerBound = nullptr; 3676 } 3677 if (!Length) 3678 --ConstLength; 3679 else if (!LowerBound) 3680 --ConstLowerBound; 3681 3682 if (Length || LowerBound) { 3683 auto *LowerBoundVal = 3684 LowerBound 3685 ? Builder.CreateIntCast( 3686 EmitScalarExpr(LowerBound), IntPtrTy, 3687 LowerBound->getType()->hasSignedIntegerRepresentation()) 3688 : llvm::ConstantInt::get(IntPtrTy, ConstLowerBound); 3689 auto *LengthVal = 3690 Length 3691 ? Builder.CreateIntCast( 3692 EmitScalarExpr(Length), IntPtrTy, 3693 Length->getType()->hasSignedIntegerRepresentation()) 3694 : llvm::ConstantInt::get(IntPtrTy, ConstLength); 3695 Idx = Builder.CreateAdd(LowerBoundVal, LengthVal, "lb_add_len", 3696 /*HasNUW=*/false, 3697 !getLangOpts().isSignedOverflowDefined()); 3698 if (Length && LowerBound) { 3699 Idx = Builder.CreateSub( 3700 Idx, llvm::ConstantInt::get(IntPtrTy, /*V=*/1), "idx_sub_1", 3701 /*HasNUW=*/false, !getLangOpts().isSignedOverflowDefined()); 3702 } 3703 } else 3704 Idx = llvm::ConstantInt::get(IntPtrTy, ConstLength + ConstLowerBound); 3705 } else { 3706 // Idx = ArraySize - 1; 3707 QualType ArrayTy = BaseTy->isPointerType() 3708 ? E->getBase()->IgnoreParenImpCasts()->getType() 3709 : BaseTy; 3710 if (auto *VAT = C.getAsVariableArrayType(ArrayTy)) { 3711 Length = VAT->getSizeExpr(); 3712 if (Length->isIntegerConstantExpr(ConstLength, C)) 3713 Length = nullptr; 3714 } else { 3715 auto *CAT = C.getAsConstantArrayType(ArrayTy); 3716 ConstLength = CAT->getSize(); 3717 } 3718 if (Length) { 3719 auto *LengthVal = Builder.CreateIntCast( 3720 EmitScalarExpr(Length), IntPtrTy, 3721 Length->getType()->hasSignedIntegerRepresentation()); 3722 Idx = Builder.CreateSub( 3723 LengthVal, llvm::ConstantInt::get(IntPtrTy, /*V=*/1), "len_sub_1", 3724 /*HasNUW=*/false, !getLangOpts().isSignedOverflowDefined()); 3725 } else { 3726 ConstLength = ConstLength.zextOrTrunc(PointerWidthInBits); 3727 --ConstLength; 3728 Idx = llvm::ConstantInt::get(IntPtrTy, ConstLength); 3729 } 3730 } 3731 } 3732 assert(Idx); 3733 3734 Address EltPtr = Address::invalid(); 3735 LValueBaseInfo BaseInfo; 3736 TBAAAccessInfo TBAAInfo; 3737 if (auto *VLA = getContext().getAsVariableArrayType(ResultExprTy)) { 3738 // The base must be a pointer, which is not an aggregate. Emit 3739 // it. It needs to be emitted first in case it's what captures 3740 // the VLA bounds. 3741 Address Base = 3742 emitOMPArraySectionBase(*this, E->getBase(), BaseInfo, TBAAInfo, 3743 BaseTy, VLA->getElementType(), IsLowerBound); 3744 // The element count here is the total number of non-VLA elements. 3745 llvm::Value *NumElements = getVLASize(VLA).NumElts; 3746 3747 // Effectively, the multiply by the VLA size is part of the GEP. 3748 // GEP indexes are signed, and scaling an index isn't permitted to 3749 // signed-overflow, so we use the same semantics for our explicit 3750 // multiply. We suppress this if overflow is not undefined behavior. 3751 if (getLangOpts().isSignedOverflowDefined()) 3752 Idx = Builder.CreateMul(Idx, NumElements); 3753 else 3754 Idx = Builder.CreateNSWMul(Idx, NumElements); 3755 EltPtr = emitArraySubscriptGEP(*this, Base, Idx, VLA->getElementType(), 3756 !getLangOpts().isSignedOverflowDefined(), 3757 /*signedIndices=*/false, E->getExprLoc()); 3758 } else if (const Expr *Array = isSimpleArrayDecayOperand(E->getBase())) { 3759 // If this is A[i] where A is an array, the frontend will have decayed the 3760 // base to be a ArrayToPointerDecay implicit cast. While correct, it is 3761 // inefficient at -O0 to emit a "gep A, 0, 0" when codegen'ing it, then a 3762 // "gep x, i" here. Emit one "gep A, 0, i". 3763 assert(Array->getType()->isArrayType() && 3764 "Array to pointer decay must have array source type!"); 3765 LValue ArrayLV; 3766 // For simple multidimensional array indexing, set the 'accessed' flag for 3767 // better bounds-checking of the base expression. 3768 if (const auto *ASE = dyn_cast<ArraySubscriptExpr>(Array)) 3769 ArrayLV = EmitArraySubscriptExpr(ASE, /*Accessed*/ true); 3770 else 3771 ArrayLV = EmitLValue(Array); 3772 3773 // Propagate the alignment from the array itself to the result. 3774 EltPtr = emitArraySubscriptGEP( 3775 *this, ArrayLV.getAddress(), {CGM.getSize(CharUnits::Zero()), Idx}, 3776 ResultExprTy, !getLangOpts().isSignedOverflowDefined(), 3777 /*signedIndices=*/false, E->getExprLoc()); 3778 BaseInfo = ArrayLV.getBaseInfo(); 3779 TBAAInfo = CGM.getTBAAInfoForSubobject(ArrayLV, ResultExprTy); 3780 } else { 3781 Address Base = emitOMPArraySectionBase(*this, E->getBase(), BaseInfo, 3782 TBAAInfo, BaseTy, ResultExprTy, 3783 IsLowerBound); 3784 EltPtr = emitArraySubscriptGEP(*this, Base, Idx, ResultExprTy, 3785 !getLangOpts().isSignedOverflowDefined(), 3786 /*signedIndices=*/false, E->getExprLoc()); 3787 } 3788 3789 return MakeAddrLValue(EltPtr, ResultExprTy, BaseInfo, TBAAInfo); 3790 } 3791 3792 LValue CodeGenFunction:: 3793 EmitExtVectorElementExpr(const ExtVectorElementExpr *E) { 3794 // Emit the base vector as an l-value. 3795 LValue Base; 3796 3797 // ExtVectorElementExpr's base can either be a vector or pointer to vector. 3798 if (E->isArrow()) { 3799 // If it is a pointer to a vector, emit the address and form an lvalue with 3800 // it. 3801 LValueBaseInfo BaseInfo; 3802 TBAAAccessInfo TBAAInfo; 3803 Address Ptr = EmitPointerWithAlignment(E->getBase(), &BaseInfo, &TBAAInfo); 3804 const PointerType *PT = E->getBase()->getType()->getAs<PointerType>(); 3805 Base = MakeAddrLValue(Ptr, PT->getPointeeType(), BaseInfo, TBAAInfo); 3806 Base.getQuals().removeObjCGCAttr(); 3807 } else if (E->getBase()->isGLValue()) { 3808 // Otherwise, if the base is an lvalue ( as in the case of foo.x.x), 3809 // emit the base as an lvalue. 3810 assert(E->getBase()->getType()->isVectorType()); 3811 Base = EmitLValue(E->getBase()); 3812 } else { 3813 // Otherwise, the base is a normal rvalue (as in (V+V).x), emit it as such. 3814 assert(E->getBase()->getType()->isVectorType() && 3815 "Result must be a vector"); 3816 llvm::Value *Vec = EmitScalarExpr(E->getBase()); 3817 3818 // Store the vector to memory (because LValue wants an address). 3819 Address VecMem = CreateMemTemp(E->getBase()->getType()); 3820 Builder.CreateStore(Vec, VecMem); 3821 Base = MakeAddrLValue(VecMem, E->getBase()->getType(), 3822 AlignmentSource::Decl); 3823 } 3824 3825 QualType type = 3826 E->getType().withCVRQualifiers(Base.getQuals().getCVRQualifiers()); 3827 3828 // Encode the element access list into a vector of unsigned indices. 3829 SmallVector<uint32_t, 4> Indices; 3830 E->getEncodedElementAccess(Indices); 3831 3832 if (Base.isSimple()) { 3833 llvm::Constant *CV = 3834 llvm::ConstantDataVector::get(getLLVMContext(), Indices); 3835 return LValue::MakeExtVectorElt(Base.getAddress(), CV, type, 3836 Base.getBaseInfo(), TBAAAccessInfo()); 3837 } 3838 assert(Base.isExtVectorElt() && "Can only subscript lvalue vec elts here!"); 3839 3840 llvm::Constant *BaseElts = Base.getExtVectorElts(); 3841 SmallVector<llvm::Constant *, 4> CElts; 3842 3843 for (unsigned i = 0, e = Indices.size(); i != e; ++i) 3844 CElts.push_back(BaseElts->getAggregateElement(Indices[i])); 3845 llvm::Constant *CV = llvm::ConstantVector::get(CElts); 3846 return LValue::MakeExtVectorElt(Base.getExtVectorAddress(), CV, type, 3847 Base.getBaseInfo(), TBAAAccessInfo()); 3848 } 3849 3850 LValue CodeGenFunction::EmitMemberExpr(const MemberExpr *E) { 3851 if (DeclRefExpr *DRE = tryToConvertMemberExprToDeclRefExpr(*this, E)) { 3852 EmitIgnoredExpr(E->getBase()); 3853 return EmitDeclRefLValue(DRE); 3854 } 3855 3856 Expr *BaseExpr = E->getBase(); 3857 // If this is s.x, emit s as an lvalue. If it is s->x, emit s as a scalar. 3858 LValue BaseLV; 3859 if (E->isArrow()) { 3860 LValueBaseInfo BaseInfo; 3861 TBAAAccessInfo TBAAInfo; 3862 Address Addr = EmitPointerWithAlignment(BaseExpr, &BaseInfo, &TBAAInfo); 3863 QualType PtrTy = BaseExpr->getType()->getPointeeType(); 3864 SanitizerSet SkippedChecks; 3865 bool IsBaseCXXThis = IsWrappedCXXThis(BaseExpr); 3866 if (IsBaseCXXThis) 3867 SkippedChecks.set(SanitizerKind::Alignment, true); 3868 if (IsBaseCXXThis || isa<DeclRefExpr>(BaseExpr)) 3869 SkippedChecks.set(SanitizerKind::Null, true); 3870 EmitTypeCheck(TCK_MemberAccess, E->getExprLoc(), Addr.getPointer(), PtrTy, 3871 /*Alignment=*/CharUnits::Zero(), SkippedChecks); 3872 BaseLV = MakeAddrLValue(Addr, PtrTy, BaseInfo, TBAAInfo); 3873 } else 3874 BaseLV = EmitCheckedLValue(BaseExpr, TCK_MemberAccess); 3875 3876 NamedDecl *ND = E->getMemberDecl(); 3877 if (auto *Field = dyn_cast<FieldDecl>(ND)) { 3878 LValue LV = EmitLValueForField(BaseLV, Field); 3879 setObjCGCLValueClass(getContext(), E, LV); 3880 return LV; 3881 } 3882 3883 if (const auto *FD = dyn_cast<FunctionDecl>(ND)) 3884 return EmitFunctionDeclLValue(*this, E, FD); 3885 3886 llvm_unreachable("Unhandled member declaration!"); 3887 } 3888 3889 /// Given that we are currently emitting a lambda, emit an l-value for 3890 /// one of its members. 3891 LValue CodeGenFunction::EmitLValueForLambdaField(const FieldDecl *Field) { 3892 assert(cast<CXXMethodDecl>(CurCodeDecl)->getParent()->isLambda()); 3893 assert(cast<CXXMethodDecl>(CurCodeDecl)->getParent() == Field->getParent()); 3894 QualType LambdaTagType = 3895 getContext().getTagDeclType(Field->getParent()); 3896 LValue LambdaLV = MakeNaturalAlignAddrLValue(CXXABIThisValue, LambdaTagType); 3897 return EmitLValueForField(LambdaLV, Field); 3898 } 3899 3900 /// Get the field index in the debug info. The debug info structure/union 3901 /// will ignore the unnamed bitfields. 3902 unsigned CodeGenFunction::getDebugInfoFIndex(const RecordDecl *Rec, 3903 unsigned FieldIndex) { 3904 unsigned I = 0, Skipped = 0; 3905 3906 for (auto F : Rec->getDefinition()->fields()) { 3907 if (I == FieldIndex) 3908 break; 3909 if (F->isUnnamedBitfield()) 3910 Skipped++; 3911 I++; 3912 } 3913 3914 return FieldIndex - Skipped; 3915 } 3916 3917 /// Get the address of a zero-sized field within a record. The resulting 3918 /// address doesn't necessarily have the right type. 3919 static Address emitAddrOfZeroSizeField(CodeGenFunction &CGF, Address Base, 3920 const FieldDecl *Field) { 3921 CharUnits Offset = CGF.getContext().toCharUnitsFromBits( 3922 CGF.getContext().getFieldOffset(Field)); 3923 if (Offset.isZero()) 3924 return Base; 3925 Base = CGF.Builder.CreateElementBitCast(Base, CGF.Int8Ty); 3926 return CGF.Builder.CreateConstInBoundsByteGEP(Base, Offset); 3927 } 3928 3929 /// Drill down to the storage of a field without walking into 3930 /// reference types. 3931 /// 3932 /// The resulting address doesn't necessarily have the right type. 3933 static Address emitAddrOfFieldStorage(CodeGenFunction &CGF, Address base, 3934 const FieldDecl *field) { 3935 if (field->isZeroSize(CGF.getContext())) 3936 return emitAddrOfZeroSizeField(CGF, base, field); 3937 3938 const RecordDecl *rec = field->getParent(); 3939 3940 unsigned idx = 3941 CGF.CGM.getTypes().getCGRecordLayout(rec).getLLVMFieldNo(field); 3942 3943 return CGF.Builder.CreateStructGEP(base, idx, field->getName()); 3944 } 3945 3946 static Address emitPreserveStructAccess(CodeGenFunction &CGF, Address base, 3947 const FieldDecl *field) { 3948 const RecordDecl *rec = field->getParent(); 3949 llvm::DIType *DbgInfo = CGF.getDebugInfo()->getOrCreateRecordType( 3950 CGF.getContext().getRecordType(rec), rec->getLocation()); 3951 3952 unsigned idx = 3953 CGF.CGM.getTypes().getCGRecordLayout(rec).getLLVMFieldNo(field); 3954 3955 return CGF.Builder.CreatePreserveStructAccessIndex( 3956 base, idx, CGF.getDebugInfoFIndex(rec, field->getFieldIndex()), DbgInfo); 3957 } 3958 3959 static bool hasAnyVptr(const QualType Type, const ASTContext &Context) { 3960 const auto *RD = Type.getTypePtr()->getAsCXXRecordDecl(); 3961 if (!RD) 3962 return false; 3963 3964 if (RD->isDynamicClass()) 3965 return true; 3966 3967 for (const auto &Base : RD->bases()) 3968 if (hasAnyVptr(Base.getType(), Context)) 3969 return true; 3970 3971 for (const FieldDecl *Field : RD->fields()) 3972 if (hasAnyVptr(Field->getType(), Context)) 3973 return true; 3974 3975 return false; 3976 } 3977 3978 LValue CodeGenFunction::EmitLValueForField(LValue base, 3979 const FieldDecl *field) { 3980 LValueBaseInfo BaseInfo = base.getBaseInfo(); 3981 3982 if (field->isBitField()) { 3983 const CGRecordLayout &RL = 3984 CGM.getTypes().getCGRecordLayout(field->getParent()); 3985 const CGBitFieldInfo &Info = RL.getBitFieldInfo(field); 3986 Address Addr = base.getAddress(); 3987 unsigned Idx = RL.getLLVMFieldNo(field); 3988 if (Idx != 0) 3989 // For structs, we GEP to the field that the record layout suggests. 3990 Addr = Builder.CreateStructGEP(Addr, Idx, field->getName()); 3991 // Get the access type. 3992 llvm::Type *FieldIntTy = 3993 llvm::Type::getIntNTy(getLLVMContext(), Info.StorageSize); 3994 if (Addr.getElementType() != FieldIntTy) 3995 Addr = Builder.CreateElementBitCast(Addr, FieldIntTy); 3996 3997 QualType fieldType = 3998 field->getType().withCVRQualifiers(base.getVRQualifiers()); 3999 // TODO: Support TBAA for bit fields. 4000 LValueBaseInfo FieldBaseInfo(BaseInfo.getAlignmentSource()); 4001 return LValue::MakeBitfield(Addr, Info, fieldType, FieldBaseInfo, 4002 TBAAAccessInfo()); 4003 } 4004 4005 // Fields of may-alias structures are may-alias themselves. 4006 // FIXME: this should get propagated down through anonymous structs 4007 // and unions. 4008 QualType FieldType = field->getType(); 4009 const RecordDecl *rec = field->getParent(); 4010 AlignmentSource BaseAlignSource = BaseInfo.getAlignmentSource(); 4011 LValueBaseInfo FieldBaseInfo(getFieldAlignmentSource(BaseAlignSource)); 4012 TBAAAccessInfo FieldTBAAInfo; 4013 if (base.getTBAAInfo().isMayAlias() || 4014 rec->hasAttr<MayAliasAttr>() || FieldType->isVectorType()) { 4015 FieldTBAAInfo = TBAAAccessInfo::getMayAliasInfo(); 4016 } else if (rec->isUnion()) { 4017 // TODO: Support TBAA for unions. 4018 FieldTBAAInfo = TBAAAccessInfo::getMayAliasInfo(); 4019 } else { 4020 // If no base type been assigned for the base access, then try to generate 4021 // one for this base lvalue. 4022 FieldTBAAInfo = base.getTBAAInfo(); 4023 if (!FieldTBAAInfo.BaseType) { 4024 FieldTBAAInfo.BaseType = CGM.getTBAABaseTypeInfo(base.getType()); 4025 assert(!FieldTBAAInfo.Offset && 4026 "Nonzero offset for an access with no base type!"); 4027 } 4028 4029 // Adjust offset to be relative to the base type. 4030 const ASTRecordLayout &Layout = 4031 getContext().getASTRecordLayout(field->getParent()); 4032 unsigned CharWidth = getContext().getCharWidth(); 4033 if (FieldTBAAInfo.BaseType) 4034 FieldTBAAInfo.Offset += 4035 Layout.getFieldOffset(field->getFieldIndex()) / CharWidth; 4036 4037 // Update the final access type and size. 4038 FieldTBAAInfo.AccessType = CGM.getTBAATypeInfo(FieldType); 4039 FieldTBAAInfo.Size = 4040 getContext().getTypeSizeInChars(FieldType).getQuantity(); 4041 } 4042 4043 Address addr = base.getAddress(); 4044 if (auto *ClassDef = dyn_cast<CXXRecordDecl>(rec)) { 4045 if (CGM.getCodeGenOpts().StrictVTablePointers && 4046 ClassDef->isDynamicClass()) { 4047 // Getting to any field of dynamic object requires stripping dynamic 4048 // information provided by invariant.group. This is because accessing 4049 // fields may leak the real address of dynamic object, which could result 4050 // in miscompilation when leaked pointer would be compared. 4051 auto *stripped = Builder.CreateStripInvariantGroup(addr.getPointer()); 4052 addr = Address(stripped, addr.getAlignment()); 4053 } 4054 } 4055 4056 unsigned RecordCVR = base.getVRQualifiers(); 4057 if (rec->isUnion()) { 4058 // For unions, there is no pointer adjustment. 4059 assert(!FieldType->isReferenceType() && "union has reference member"); 4060 if (CGM.getCodeGenOpts().StrictVTablePointers && 4061 hasAnyVptr(FieldType, getContext())) 4062 // Because unions can easily skip invariant.barriers, we need to add 4063 // a barrier every time CXXRecord field with vptr is referenced. 4064 addr = Address(Builder.CreateLaunderInvariantGroup(addr.getPointer()), 4065 addr.getAlignment()); 4066 4067 if (IsInPreservedAIRegion) { 4068 // Remember the original union field index 4069 llvm::DIType *DbgInfo = getDebugInfo()->getOrCreateRecordType( 4070 getContext().getRecordType(rec), rec->getLocation()); 4071 addr = Address( 4072 Builder.CreatePreserveUnionAccessIndex( 4073 addr.getPointer(), getDebugInfoFIndex(rec, field->getFieldIndex()), DbgInfo), 4074 addr.getAlignment()); 4075 } 4076 } else { 4077 4078 if (!IsInPreservedAIRegion) 4079 // For structs, we GEP to the field that the record layout suggests. 4080 addr = emitAddrOfFieldStorage(*this, addr, field); 4081 else 4082 // Remember the original struct field index 4083 addr = emitPreserveStructAccess(*this, addr, field); 4084 4085 // If this is a reference field, load the reference right now. 4086 if (FieldType->isReferenceType()) { 4087 LValue RefLVal = MakeAddrLValue(addr, FieldType, FieldBaseInfo, 4088 FieldTBAAInfo); 4089 if (RecordCVR & Qualifiers::Volatile) 4090 RefLVal.getQuals().addVolatile(); 4091 addr = EmitLoadOfReference(RefLVal, &FieldBaseInfo, &FieldTBAAInfo); 4092 4093 // Qualifiers on the struct don't apply to the referencee. 4094 RecordCVR = 0; 4095 FieldType = FieldType->getPointeeType(); 4096 } 4097 } 4098 4099 // Make sure that the address is pointing to the right type. This is critical 4100 // for both unions and structs. A union needs a bitcast, a struct element 4101 // will need a bitcast if the LLVM type laid out doesn't match the desired 4102 // type. 4103 addr = Builder.CreateElementBitCast( 4104 addr, CGM.getTypes().ConvertTypeForMem(FieldType), field->getName()); 4105 4106 if (field->hasAttr<AnnotateAttr>()) 4107 addr = EmitFieldAnnotations(field, addr); 4108 4109 LValue LV = MakeAddrLValue(addr, FieldType, FieldBaseInfo, FieldTBAAInfo); 4110 LV.getQuals().addCVRQualifiers(RecordCVR); 4111 4112 // __weak attribute on a field is ignored. 4113 if (LV.getQuals().getObjCGCAttr() == Qualifiers::Weak) 4114 LV.getQuals().removeObjCGCAttr(); 4115 4116 return LV; 4117 } 4118 4119 LValue 4120 CodeGenFunction::EmitLValueForFieldInitialization(LValue Base, 4121 const FieldDecl *Field) { 4122 QualType FieldType = Field->getType(); 4123 4124 if (!FieldType->isReferenceType()) 4125 return EmitLValueForField(Base, Field); 4126 4127 Address V = emitAddrOfFieldStorage(*this, Base.getAddress(), Field); 4128 4129 // Make sure that the address is pointing to the right type. 4130 llvm::Type *llvmType = ConvertTypeForMem(FieldType); 4131 V = Builder.CreateElementBitCast(V, llvmType, Field->getName()); 4132 4133 // TODO: Generate TBAA information that describes this access as a structure 4134 // member access and not just an access to an object of the field's type. This 4135 // should be similar to what we do in EmitLValueForField(). 4136 LValueBaseInfo BaseInfo = Base.getBaseInfo(); 4137 AlignmentSource FieldAlignSource = BaseInfo.getAlignmentSource(); 4138 LValueBaseInfo FieldBaseInfo(getFieldAlignmentSource(FieldAlignSource)); 4139 return MakeAddrLValue(V, FieldType, FieldBaseInfo, 4140 CGM.getTBAAInfoForSubobject(Base, FieldType)); 4141 } 4142 4143 LValue CodeGenFunction::EmitCompoundLiteralLValue(const CompoundLiteralExpr *E){ 4144 if (E->isFileScope()) { 4145 ConstantAddress GlobalPtr = CGM.GetAddrOfConstantCompoundLiteral(E); 4146 return MakeAddrLValue(GlobalPtr, E->getType(), AlignmentSource::Decl); 4147 } 4148 if (E->getType()->isVariablyModifiedType()) 4149 // make sure to emit the VLA size. 4150 EmitVariablyModifiedType(E->getType()); 4151 4152 Address DeclPtr = CreateMemTemp(E->getType(), ".compoundliteral"); 4153 const Expr *InitExpr = E->getInitializer(); 4154 LValue Result = MakeAddrLValue(DeclPtr, E->getType(), AlignmentSource::Decl); 4155 4156 EmitAnyExprToMem(InitExpr, DeclPtr, E->getType().getQualifiers(), 4157 /*Init*/ true); 4158 4159 return Result; 4160 } 4161 4162 LValue CodeGenFunction::EmitInitListLValue(const InitListExpr *E) { 4163 if (!E->isGLValue()) 4164 // Initializing an aggregate temporary in C++11: T{...}. 4165 return EmitAggExprToLValue(E); 4166 4167 // An lvalue initializer list must be initializing a reference. 4168 assert(E->isTransparent() && "non-transparent glvalue init list"); 4169 return EmitLValue(E->getInit(0)); 4170 } 4171 4172 /// Emit the operand of a glvalue conditional operator. This is either a glvalue 4173 /// or a (possibly-parenthesized) throw-expression. If this is a throw, no 4174 /// LValue is returned and the current block has been terminated. 4175 static Optional<LValue> EmitLValueOrThrowExpression(CodeGenFunction &CGF, 4176 const Expr *Operand) { 4177 if (auto *ThrowExpr = dyn_cast<CXXThrowExpr>(Operand->IgnoreParens())) { 4178 CGF.EmitCXXThrowExpr(ThrowExpr, /*KeepInsertionPoint*/false); 4179 return None; 4180 } 4181 4182 return CGF.EmitLValue(Operand); 4183 } 4184 4185 LValue CodeGenFunction:: 4186 EmitConditionalOperatorLValue(const AbstractConditionalOperator *expr) { 4187 if (!expr->isGLValue()) { 4188 // ?: here should be an aggregate. 4189 assert(hasAggregateEvaluationKind(expr->getType()) && 4190 "Unexpected conditional operator!"); 4191 return EmitAggExprToLValue(expr); 4192 } 4193 4194 OpaqueValueMapping binding(*this, expr); 4195 4196 const Expr *condExpr = expr->getCond(); 4197 bool CondExprBool; 4198 if (ConstantFoldsToSimpleInteger(condExpr, CondExprBool)) { 4199 const Expr *live = expr->getTrueExpr(), *dead = expr->getFalseExpr(); 4200 if (!CondExprBool) std::swap(live, dead); 4201 4202 if (!ContainsLabel(dead)) { 4203 // If the true case is live, we need to track its region. 4204 if (CondExprBool) 4205 incrementProfileCounter(expr); 4206 return EmitLValue(live); 4207 } 4208 } 4209 4210 llvm::BasicBlock *lhsBlock = createBasicBlock("cond.true"); 4211 llvm::BasicBlock *rhsBlock = createBasicBlock("cond.false"); 4212 llvm::BasicBlock *contBlock = createBasicBlock("cond.end"); 4213 4214 ConditionalEvaluation eval(*this); 4215 EmitBranchOnBoolExpr(condExpr, lhsBlock, rhsBlock, getProfileCount(expr)); 4216 4217 // Any temporaries created here are conditional. 4218 EmitBlock(lhsBlock); 4219 incrementProfileCounter(expr); 4220 eval.begin(*this); 4221 Optional<LValue> lhs = 4222 EmitLValueOrThrowExpression(*this, expr->getTrueExpr()); 4223 eval.end(*this); 4224 4225 if (lhs && !lhs->isSimple()) 4226 return EmitUnsupportedLValue(expr, "conditional operator"); 4227 4228 lhsBlock = Builder.GetInsertBlock(); 4229 if (lhs) 4230 Builder.CreateBr(contBlock); 4231 4232 // Any temporaries created here are conditional. 4233 EmitBlock(rhsBlock); 4234 eval.begin(*this); 4235 Optional<LValue> rhs = 4236 EmitLValueOrThrowExpression(*this, expr->getFalseExpr()); 4237 eval.end(*this); 4238 if (rhs && !rhs->isSimple()) 4239 return EmitUnsupportedLValue(expr, "conditional operator"); 4240 rhsBlock = Builder.GetInsertBlock(); 4241 4242 EmitBlock(contBlock); 4243 4244 if (lhs && rhs) { 4245 llvm::PHINode *phi = Builder.CreatePHI(lhs->getPointer()->getType(), 4246 2, "cond-lvalue"); 4247 phi->addIncoming(lhs->getPointer(), lhsBlock); 4248 phi->addIncoming(rhs->getPointer(), rhsBlock); 4249 Address result(phi, std::min(lhs->getAlignment(), rhs->getAlignment())); 4250 AlignmentSource alignSource = 4251 std::max(lhs->getBaseInfo().getAlignmentSource(), 4252 rhs->getBaseInfo().getAlignmentSource()); 4253 TBAAAccessInfo TBAAInfo = CGM.mergeTBAAInfoForConditionalOperator( 4254 lhs->getTBAAInfo(), rhs->getTBAAInfo()); 4255 return MakeAddrLValue(result, expr->getType(), LValueBaseInfo(alignSource), 4256 TBAAInfo); 4257 } else { 4258 assert((lhs || rhs) && 4259 "both operands of glvalue conditional are throw-expressions?"); 4260 return lhs ? *lhs : *rhs; 4261 } 4262 } 4263 4264 /// EmitCastLValue - Casts are never lvalues unless that cast is to a reference 4265 /// type. If the cast is to a reference, we can have the usual lvalue result, 4266 /// otherwise if a cast is needed by the code generator in an lvalue context, 4267 /// then it must mean that we need the address of an aggregate in order to 4268 /// access one of its members. This can happen for all the reasons that casts 4269 /// are permitted with aggregate result, including noop aggregate casts, and 4270 /// cast from scalar to union. 4271 LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) { 4272 switch (E->getCastKind()) { 4273 case CK_ToVoid: 4274 case CK_BitCast: 4275 case CK_LValueToRValueBitCast: 4276 case CK_ArrayToPointerDecay: 4277 case CK_FunctionToPointerDecay: 4278 case CK_NullToMemberPointer: 4279 case CK_NullToPointer: 4280 case CK_IntegralToPointer: 4281 case CK_PointerToIntegral: 4282 case CK_PointerToBoolean: 4283 case CK_VectorSplat: 4284 case CK_IntegralCast: 4285 case CK_BooleanToSignedIntegral: 4286 case CK_IntegralToBoolean: 4287 case CK_IntegralToFloating: 4288 case CK_FloatingToIntegral: 4289 case CK_FloatingToBoolean: 4290 case CK_FloatingCast: 4291 case CK_FloatingRealToComplex: 4292 case CK_FloatingComplexToReal: 4293 case CK_FloatingComplexToBoolean: 4294 case CK_FloatingComplexCast: 4295 case CK_FloatingComplexToIntegralComplex: 4296 case CK_IntegralRealToComplex: 4297 case CK_IntegralComplexToReal: 4298 case CK_IntegralComplexToBoolean: 4299 case CK_IntegralComplexCast: 4300 case CK_IntegralComplexToFloatingComplex: 4301 case CK_DerivedToBaseMemberPointer: 4302 case CK_BaseToDerivedMemberPointer: 4303 case CK_MemberPointerToBoolean: 4304 case CK_ReinterpretMemberPointer: 4305 case CK_AnyPointerToBlockPointerCast: 4306 case CK_ARCProduceObject: 4307 case CK_ARCConsumeObject: 4308 case CK_ARCReclaimReturnedObject: 4309 case CK_ARCExtendBlockObject: 4310 case CK_CopyAndAutoreleaseBlockObject: 4311 case CK_IntToOCLSampler: 4312 case CK_FixedPointCast: 4313 case CK_FixedPointToBoolean: 4314 case CK_FixedPointToIntegral: 4315 case CK_IntegralToFixedPoint: 4316 return EmitUnsupportedLValue(E, "unexpected cast lvalue"); 4317 4318 case CK_Dependent: 4319 llvm_unreachable("dependent cast kind in IR gen!"); 4320 4321 case CK_BuiltinFnToFnPtr: 4322 llvm_unreachable("builtin functions are handled elsewhere"); 4323 4324 // These are never l-values; just use the aggregate emission code. 4325 case CK_NonAtomicToAtomic: 4326 case CK_AtomicToNonAtomic: 4327 return EmitAggExprToLValue(E); 4328 4329 case CK_Dynamic: { 4330 LValue LV = EmitLValue(E->getSubExpr()); 4331 Address V = LV.getAddress(); 4332 const auto *DCE = cast<CXXDynamicCastExpr>(E); 4333 return MakeNaturalAlignAddrLValue(EmitDynamicCast(V, DCE), E->getType()); 4334 } 4335 4336 case CK_ConstructorConversion: 4337 case CK_UserDefinedConversion: 4338 case CK_CPointerToObjCPointerCast: 4339 case CK_BlockPointerToObjCPointerCast: 4340 case CK_NoOp: 4341 case CK_LValueToRValue: 4342 return EmitLValue(E->getSubExpr()); 4343 4344 case CK_UncheckedDerivedToBase: 4345 case CK_DerivedToBase: { 4346 const RecordType *DerivedClassTy = 4347 E->getSubExpr()->getType()->getAs<RecordType>(); 4348 auto *DerivedClassDecl = cast<CXXRecordDecl>(DerivedClassTy->getDecl()); 4349 4350 LValue LV = EmitLValue(E->getSubExpr()); 4351 Address This = LV.getAddress(); 4352 4353 // Perform the derived-to-base conversion 4354 Address Base = GetAddressOfBaseClass( 4355 This, DerivedClassDecl, E->path_begin(), E->path_end(), 4356 /*NullCheckValue=*/false, E->getExprLoc()); 4357 4358 // TODO: Support accesses to members of base classes in TBAA. For now, we 4359 // conservatively pretend that the complete object is of the base class 4360 // type. 4361 return MakeAddrLValue(Base, E->getType(), LV.getBaseInfo(), 4362 CGM.getTBAAInfoForSubobject(LV, E->getType())); 4363 } 4364 case CK_ToUnion: 4365 return EmitAggExprToLValue(E); 4366 case CK_BaseToDerived: { 4367 const RecordType *DerivedClassTy = E->getType()->getAs<RecordType>(); 4368 auto *DerivedClassDecl = cast<CXXRecordDecl>(DerivedClassTy->getDecl()); 4369 4370 LValue LV = EmitLValue(E->getSubExpr()); 4371 4372 // Perform the base-to-derived conversion 4373 Address Derived = 4374 GetAddressOfDerivedClass(LV.getAddress(), DerivedClassDecl, 4375 E->path_begin(), E->path_end(), 4376 /*NullCheckValue=*/false); 4377 4378 // C++11 [expr.static.cast]p2: Behavior is undefined if a downcast is 4379 // performed and the object is not of the derived type. 4380 if (sanitizePerformTypeCheck()) 4381 EmitTypeCheck(TCK_DowncastReference, E->getExprLoc(), 4382 Derived.getPointer(), E->getType()); 4383 4384 if (SanOpts.has(SanitizerKind::CFIDerivedCast)) 4385 EmitVTablePtrCheckForCast(E->getType(), Derived.getPointer(), 4386 /*MayBeNull=*/false, CFITCK_DerivedCast, 4387 E->getBeginLoc()); 4388 4389 return MakeAddrLValue(Derived, E->getType(), LV.getBaseInfo(), 4390 CGM.getTBAAInfoForSubobject(LV, E->getType())); 4391 } 4392 case CK_LValueBitCast: { 4393 // This must be a reinterpret_cast (or c-style equivalent). 4394 const auto *CE = cast<ExplicitCastExpr>(E); 4395 4396 CGM.EmitExplicitCastExprType(CE, this); 4397 LValue LV = EmitLValue(E->getSubExpr()); 4398 Address V = Builder.CreateBitCast(LV.getAddress(), 4399 ConvertType(CE->getTypeAsWritten())); 4400 4401 if (SanOpts.has(SanitizerKind::CFIUnrelatedCast)) 4402 EmitVTablePtrCheckForCast(E->getType(), V.getPointer(), 4403 /*MayBeNull=*/false, CFITCK_UnrelatedCast, 4404 E->getBeginLoc()); 4405 4406 return MakeAddrLValue(V, E->getType(), LV.getBaseInfo(), 4407 CGM.getTBAAInfoForSubobject(LV, E->getType())); 4408 } 4409 case CK_AddressSpaceConversion: { 4410 LValue LV = EmitLValue(E->getSubExpr()); 4411 QualType DestTy = getContext().getPointerType(E->getType()); 4412 llvm::Value *V = getTargetHooks().performAddrSpaceCast( 4413 *this, LV.getPointer(), E->getSubExpr()->getType().getAddressSpace(), 4414 E->getType().getAddressSpace(), ConvertType(DestTy)); 4415 return MakeAddrLValue(Address(V, LV.getAddress().getAlignment()), 4416 E->getType(), LV.getBaseInfo(), LV.getTBAAInfo()); 4417 } 4418 case CK_ObjCObjectLValueCast: { 4419 LValue LV = EmitLValue(E->getSubExpr()); 4420 Address V = Builder.CreateElementBitCast(LV.getAddress(), 4421 ConvertType(E->getType())); 4422 return MakeAddrLValue(V, E->getType(), LV.getBaseInfo(), 4423 CGM.getTBAAInfoForSubobject(LV, E->getType())); 4424 } 4425 case CK_ZeroToOCLOpaqueType: 4426 llvm_unreachable("NULL to OpenCL opaque type lvalue cast is not valid"); 4427 } 4428 4429 llvm_unreachable("Unhandled lvalue cast kind?"); 4430 } 4431 4432 LValue CodeGenFunction::EmitOpaqueValueLValue(const OpaqueValueExpr *e) { 4433 assert(OpaqueValueMappingData::shouldBindAsLValue(e)); 4434 return getOrCreateOpaqueLValueMapping(e); 4435 } 4436 4437 LValue 4438 CodeGenFunction::getOrCreateOpaqueLValueMapping(const OpaqueValueExpr *e) { 4439 assert(OpaqueValueMapping::shouldBindAsLValue(e)); 4440 4441 llvm::DenseMap<const OpaqueValueExpr*,LValue>::iterator 4442 it = OpaqueLValues.find(e); 4443 4444 if (it != OpaqueLValues.end()) 4445 return it->second; 4446 4447 assert(e->isUnique() && "LValue for a nonunique OVE hasn't been emitted"); 4448 return EmitLValue(e->getSourceExpr()); 4449 } 4450 4451 RValue 4452 CodeGenFunction::getOrCreateOpaqueRValueMapping(const OpaqueValueExpr *e) { 4453 assert(!OpaqueValueMapping::shouldBindAsLValue(e)); 4454 4455 llvm::DenseMap<const OpaqueValueExpr*,RValue>::iterator 4456 it = OpaqueRValues.find(e); 4457 4458 if (it != OpaqueRValues.end()) 4459 return it->second; 4460 4461 assert(e->isUnique() && "RValue for a nonunique OVE hasn't been emitted"); 4462 return EmitAnyExpr(e->getSourceExpr()); 4463 } 4464 4465 RValue CodeGenFunction::EmitRValueForField(LValue LV, 4466 const FieldDecl *FD, 4467 SourceLocation Loc) { 4468 QualType FT = FD->getType(); 4469 LValue FieldLV = EmitLValueForField(LV, FD); 4470 switch (getEvaluationKind(FT)) { 4471 case TEK_Complex: 4472 return RValue::getComplex(EmitLoadOfComplex(FieldLV, Loc)); 4473 case TEK_Aggregate: 4474 return FieldLV.asAggregateRValue(); 4475 case TEK_Scalar: 4476 // This routine is used to load fields one-by-one to perform a copy, so 4477 // don't load reference fields. 4478 if (FD->getType()->isReferenceType()) 4479 return RValue::get(FieldLV.getPointer()); 4480 return EmitLoadOfLValue(FieldLV, Loc); 4481 } 4482 llvm_unreachable("bad evaluation kind"); 4483 } 4484 4485 //===--------------------------------------------------------------------===// 4486 // Expression Emission 4487 //===--------------------------------------------------------------------===// 4488 4489 RValue CodeGenFunction::EmitCallExpr(const CallExpr *E, 4490 ReturnValueSlot ReturnValue) { 4491 // Builtins never have block type. 4492 if (E->getCallee()->getType()->isBlockPointerType()) 4493 return EmitBlockCallExpr(E, ReturnValue); 4494 4495 if (const auto *CE = dyn_cast<CXXMemberCallExpr>(E)) 4496 return EmitCXXMemberCallExpr(CE, ReturnValue); 4497 4498 if (const auto *CE = dyn_cast<CUDAKernelCallExpr>(E)) 4499 return EmitCUDAKernelCallExpr(CE, ReturnValue); 4500 4501 if (const auto *CE = dyn_cast<CXXOperatorCallExpr>(E)) 4502 if (const CXXMethodDecl *MD = 4503 dyn_cast_or_null<CXXMethodDecl>(CE->getCalleeDecl())) 4504 return EmitCXXOperatorMemberCallExpr(CE, MD, ReturnValue); 4505 4506 CGCallee callee = EmitCallee(E->getCallee()); 4507 4508 if (callee.isBuiltin()) { 4509 return EmitBuiltinExpr(callee.getBuiltinDecl(), callee.getBuiltinID(), 4510 E, ReturnValue); 4511 } 4512 4513 if (callee.isPseudoDestructor()) { 4514 return EmitCXXPseudoDestructorExpr(callee.getPseudoDestructorExpr()); 4515 } 4516 4517 return EmitCall(E->getCallee()->getType(), callee, E, ReturnValue); 4518 } 4519 4520 /// Emit a CallExpr without considering whether it might be a subclass. 4521 RValue CodeGenFunction::EmitSimpleCallExpr(const CallExpr *E, 4522 ReturnValueSlot ReturnValue) { 4523 CGCallee Callee = EmitCallee(E->getCallee()); 4524 return EmitCall(E->getCallee()->getType(), Callee, E, ReturnValue); 4525 } 4526 4527 static CGCallee EmitDirectCallee(CodeGenFunction &CGF, const FunctionDecl *FD) { 4528 if (auto builtinID = FD->getBuiltinID()) { 4529 return CGCallee::forBuiltin(builtinID, FD); 4530 } 4531 4532 llvm::Constant *calleePtr = EmitFunctionDeclPointer(CGF.CGM, FD); 4533 return CGCallee::forDirect(calleePtr, GlobalDecl(FD)); 4534 } 4535 4536 CGCallee CodeGenFunction::EmitCallee(const Expr *E) { 4537 E = E->IgnoreParens(); 4538 4539 // Look through function-to-pointer decay. 4540 if (auto ICE = dyn_cast<ImplicitCastExpr>(E)) { 4541 if (ICE->getCastKind() == CK_FunctionToPointerDecay || 4542 ICE->getCastKind() == CK_BuiltinFnToFnPtr) { 4543 return EmitCallee(ICE->getSubExpr()); 4544 } 4545 4546 // Resolve direct calls. 4547 } else if (auto DRE = dyn_cast<DeclRefExpr>(E)) { 4548 if (auto FD = dyn_cast<FunctionDecl>(DRE->getDecl())) { 4549 return EmitDirectCallee(*this, FD); 4550 } 4551 } else if (auto ME = dyn_cast<MemberExpr>(E)) { 4552 if (auto FD = dyn_cast<FunctionDecl>(ME->getMemberDecl())) { 4553 EmitIgnoredExpr(ME->getBase()); 4554 return EmitDirectCallee(*this, FD); 4555 } 4556 4557 // Look through template substitutions. 4558 } else if (auto NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) { 4559 return EmitCallee(NTTP->getReplacement()); 4560 4561 // Treat pseudo-destructor calls differently. 4562 } else if (auto PDE = dyn_cast<CXXPseudoDestructorExpr>(E)) { 4563 return CGCallee::forPseudoDestructor(PDE); 4564 } 4565 4566 // Otherwise, we have an indirect reference. 4567 llvm::Value *calleePtr; 4568 QualType functionType; 4569 if (auto ptrType = E->getType()->getAs<PointerType>()) { 4570 calleePtr = EmitScalarExpr(E); 4571 functionType = ptrType->getPointeeType(); 4572 } else { 4573 functionType = E->getType(); 4574 calleePtr = EmitLValue(E).getPointer(); 4575 } 4576 assert(functionType->isFunctionType()); 4577 4578 GlobalDecl GD; 4579 if (const auto *VD = 4580 dyn_cast_or_null<VarDecl>(E->getReferencedDeclOfCallee())) 4581 GD = GlobalDecl(VD); 4582 4583 CGCalleeInfo calleeInfo(functionType->getAs<FunctionProtoType>(), GD); 4584 CGCallee callee(calleeInfo, calleePtr); 4585 return callee; 4586 } 4587 4588 LValue CodeGenFunction::EmitBinaryOperatorLValue(const BinaryOperator *E) { 4589 // Comma expressions just emit their LHS then their RHS as an l-value. 4590 if (E->getOpcode() == BO_Comma) { 4591 EmitIgnoredExpr(E->getLHS()); 4592 EnsureInsertPoint(); 4593 return EmitLValue(E->getRHS()); 4594 } 4595 4596 if (E->getOpcode() == BO_PtrMemD || 4597 E->getOpcode() == BO_PtrMemI) 4598 return EmitPointerToDataMemberBinaryExpr(E); 4599 4600 assert(E->getOpcode() == BO_Assign && "unexpected binary l-value"); 4601 4602 // Note that in all of these cases, __block variables need the RHS 4603 // evaluated first just in case the variable gets moved by the RHS. 4604 4605 switch (getEvaluationKind(E->getType())) { 4606 case TEK_Scalar: { 4607 switch (E->getLHS()->getType().getObjCLifetime()) { 4608 case Qualifiers::OCL_Strong: 4609 return EmitARCStoreStrong(E, /*ignored*/ false).first; 4610 4611 case Qualifiers::OCL_Autoreleasing: 4612 return EmitARCStoreAutoreleasing(E).first; 4613 4614 // No reason to do any of these differently. 4615 case Qualifiers::OCL_None: 4616 case Qualifiers::OCL_ExplicitNone: 4617 case Qualifiers::OCL_Weak: 4618 break; 4619 } 4620 4621 RValue RV = EmitAnyExpr(E->getRHS()); 4622 LValue LV = EmitCheckedLValue(E->getLHS(), TCK_Store); 4623 if (RV.isScalar()) 4624 EmitNullabilityCheck(LV, RV.getScalarVal(), E->getExprLoc()); 4625 EmitStoreThroughLValue(RV, LV); 4626 return LV; 4627 } 4628 4629 case TEK_Complex: 4630 return EmitComplexAssignmentLValue(E); 4631 4632 case TEK_Aggregate: 4633 return EmitAggExprToLValue(E); 4634 } 4635 llvm_unreachable("bad evaluation kind"); 4636 } 4637 4638 LValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) { 4639 RValue RV = EmitCallExpr(E); 4640 4641 if (!RV.isScalar()) 4642 return MakeAddrLValue(RV.getAggregateAddress(), E->getType(), 4643 AlignmentSource::Decl); 4644 4645 assert(E->getCallReturnType(getContext())->isReferenceType() && 4646 "Can't have a scalar return unless the return type is a " 4647 "reference type!"); 4648 4649 return MakeNaturalAlignPointeeAddrLValue(RV.getScalarVal(), E->getType()); 4650 } 4651 4652 LValue CodeGenFunction::EmitVAArgExprLValue(const VAArgExpr *E) { 4653 // FIXME: This shouldn't require another copy. 4654 return EmitAggExprToLValue(E); 4655 } 4656 4657 LValue CodeGenFunction::EmitCXXConstructLValue(const CXXConstructExpr *E) { 4658 assert(E->getType()->getAsCXXRecordDecl()->hasTrivialDestructor() 4659 && "binding l-value to type which needs a temporary"); 4660 AggValueSlot Slot = CreateAggTemp(E->getType()); 4661 EmitCXXConstructExpr(E, Slot); 4662 return MakeAddrLValue(Slot.getAddress(), E->getType(), AlignmentSource::Decl); 4663 } 4664 4665 LValue 4666 CodeGenFunction::EmitCXXTypeidLValue(const CXXTypeidExpr *E) { 4667 return MakeNaturalAlignAddrLValue(EmitCXXTypeidExpr(E), E->getType()); 4668 } 4669 4670 Address CodeGenFunction::EmitCXXUuidofExpr(const CXXUuidofExpr *E) { 4671 return Builder.CreateElementBitCast(CGM.GetAddrOfUuidDescriptor(E), 4672 ConvertType(E->getType())); 4673 } 4674 4675 LValue CodeGenFunction::EmitCXXUuidofLValue(const CXXUuidofExpr *E) { 4676 return MakeAddrLValue(EmitCXXUuidofExpr(E), E->getType(), 4677 AlignmentSource::Decl); 4678 } 4679 4680 LValue 4681 CodeGenFunction::EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E) { 4682 AggValueSlot Slot = CreateAggTemp(E->getType(), "temp.lvalue"); 4683 Slot.setExternallyDestructed(); 4684 EmitAggExpr(E->getSubExpr(), Slot); 4685 EmitCXXTemporary(E->getTemporary(), E->getType(), Slot.getAddress()); 4686 return MakeAddrLValue(Slot.getAddress(), E->getType(), AlignmentSource::Decl); 4687 } 4688 4689 LValue CodeGenFunction::EmitObjCMessageExprLValue(const ObjCMessageExpr *E) { 4690 RValue RV = EmitObjCMessageExpr(E); 4691 4692 if (!RV.isScalar()) 4693 return MakeAddrLValue(RV.getAggregateAddress(), E->getType(), 4694 AlignmentSource::Decl); 4695 4696 assert(E->getMethodDecl()->getReturnType()->isReferenceType() && 4697 "Can't have a scalar return unless the return type is a " 4698 "reference type!"); 4699 4700 return MakeNaturalAlignPointeeAddrLValue(RV.getScalarVal(), E->getType()); 4701 } 4702 4703 LValue CodeGenFunction::EmitObjCSelectorLValue(const ObjCSelectorExpr *E) { 4704 Address V = 4705 CGM.getObjCRuntime().GetAddrOfSelector(*this, E->getSelector()); 4706 return MakeAddrLValue(V, E->getType(), AlignmentSource::Decl); 4707 } 4708 4709 llvm::Value *CodeGenFunction::EmitIvarOffset(const ObjCInterfaceDecl *Interface, 4710 const ObjCIvarDecl *Ivar) { 4711 return CGM.getObjCRuntime().EmitIvarOffset(*this, Interface, Ivar); 4712 } 4713 4714 LValue CodeGenFunction::EmitLValueForIvar(QualType ObjectTy, 4715 llvm::Value *BaseValue, 4716 const ObjCIvarDecl *Ivar, 4717 unsigned CVRQualifiers) { 4718 return CGM.getObjCRuntime().EmitObjCValueForIvar(*this, ObjectTy, BaseValue, 4719 Ivar, CVRQualifiers); 4720 } 4721 4722 LValue CodeGenFunction::EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E) { 4723 // FIXME: A lot of the code below could be shared with EmitMemberExpr. 4724 llvm::Value *BaseValue = nullptr; 4725 const Expr *BaseExpr = E->getBase(); 4726 Qualifiers BaseQuals; 4727 QualType ObjectTy; 4728 if (E->isArrow()) { 4729 BaseValue = EmitScalarExpr(BaseExpr); 4730 ObjectTy = BaseExpr->getType()->getPointeeType(); 4731 BaseQuals = ObjectTy.getQualifiers(); 4732 } else { 4733 LValue BaseLV = EmitLValue(BaseExpr); 4734 BaseValue = BaseLV.getPointer(); 4735 ObjectTy = BaseExpr->getType(); 4736 BaseQuals = ObjectTy.getQualifiers(); 4737 } 4738 4739 LValue LV = 4740 EmitLValueForIvar(ObjectTy, BaseValue, E->getDecl(), 4741 BaseQuals.getCVRQualifiers()); 4742 setObjCGCLValueClass(getContext(), E, LV); 4743 return LV; 4744 } 4745 4746 LValue CodeGenFunction::EmitStmtExprLValue(const StmtExpr *E) { 4747 // Can only get l-value for message expression returning aggregate type 4748 RValue RV = EmitAnyExprToTemp(E); 4749 return MakeAddrLValue(RV.getAggregateAddress(), E->getType(), 4750 AlignmentSource::Decl); 4751 } 4752 4753 RValue CodeGenFunction::EmitCall(QualType CalleeType, const CGCallee &OrigCallee, 4754 const CallExpr *E, ReturnValueSlot ReturnValue, 4755 llvm::Value *Chain) { 4756 // Get the actual function type. The callee type will always be a pointer to 4757 // function type or a block pointer type. 4758 assert(CalleeType->isFunctionPointerType() && 4759 "Call must have function pointer type!"); 4760 4761 const Decl *TargetDecl = 4762 OrigCallee.getAbstractInfo().getCalleeDecl().getDecl(); 4763 4764 CalleeType = getContext().getCanonicalType(CalleeType); 4765 4766 auto PointeeType = cast<PointerType>(CalleeType)->getPointeeType(); 4767 4768 CGCallee Callee = OrigCallee; 4769 4770 if (getLangOpts().CPlusPlus && SanOpts.has(SanitizerKind::Function) && 4771 (!TargetDecl || !isa<FunctionDecl>(TargetDecl))) { 4772 if (llvm::Constant *PrefixSig = 4773 CGM.getTargetCodeGenInfo().getUBSanFunctionSignature(CGM)) { 4774 SanitizerScope SanScope(this); 4775 // Remove any (C++17) exception specifications, to allow calling e.g. a 4776 // noexcept function through a non-noexcept pointer. 4777 auto ProtoTy = 4778 getContext().getFunctionTypeWithExceptionSpec(PointeeType, EST_None); 4779 llvm::Constant *FTRTTIConst = 4780 CGM.GetAddrOfRTTIDescriptor(ProtoTy, /*ForEH=*/true); 4781 llvm::Type *PrefixStructTyElems[] = {PrefixSig->getType(), Int32Ty}; 4782 llvm::StructType *PrefixStructTy = llvm::StructType::get( 4783 CGM.getLLVMContext(), PrefixStructTyElems, /*isPacked=*/true); 4784 4785 llvm::Value *CalleePtr = Callee.getFunctionPointer(); 4786 4787 llvm::Value *CalleePrefixStruct = Builder.CreateBitCast( 4788 CalleePtr, llvm::PointerType::getUnqual(PrefixStructTy)); 4789 llvm::Value *CalleeSigPtr = 4790 Builder.CreateConstGEP2_32(PrefixStructTy, CalleePrefixStruct, 0, 0); 4791 llvm::Value *CalleeSig = 4792 Builder.CreateAlignedLoad(CalleeSigPtr, getIntAlign()); 4793 llvm::Value *CalleeSigMatch = Builder.CreateICmpEQ(CalleeSig, PrefixSig); 4794 4795 llvm::BasicBlock *Cont = createBasicBlock("cont"); 4796 llvm::BasicBlock *TypeCheck = createBasicBlock("typecheck"); 4797 Builder.CreateCondBr(CalleeSigMatch, TypeCheck, Cont); 4798 4799 EmitBlock(TypeCheck); 4800 llvm::Value *CalleeRTTIPtr = 4801 Builder.CreateConstGEP2_32(PrefixStructTy, CalleePrefixStruct, 0, 1); 4802 llvm::Value *CalleeRTTIEncoded = 4803 Builder.CreateAlignedLoad(CalleeRTTIPtr, getPointerAlign()); 4804 llvm::Value *CalleeRTTI = 4805 DecodeAddrUsedInPrologue(CalleePtr, CalleeRTTIEncoded); 4806 llvm::Value *CalleeRTTIMatch = 4807 Builder.CreateICmpEQ(CalleeRTTI, FTRTTIConst); 4808 llvm::Constant *StaticData[] = {EmitCheckSourceLocation(E->getBeginLoc()), 4809 EmitCheckTypeDescriptor(CalleeType)}; 4810 EmitCheck(std::make_pair(CalleeRTTIMatch, SanitizerKind::Function), 4811 SanitizerHandler::FunctionTypeMismatch, StaticData, 4812 {CalleePtr, CalleeRTTI, FTRTTIConst}); 4813 4814 Builder.CreateBr(Cont); 4815 EmitBlock(Cont); 4816 } 4817 } 4818 4819 const auto *FnType = cast<FunctionType>(PointeeType); 4820 4821 // If we are checking indirect calls and this call is indirect, check that the 4822 // function pointer is a member of the bit set for the function type. 4823 if (SanOpts.has(SanitizerKind::CFIICall) && 4824 (!TargetDecl || !isa<FunctionDecl>(TargetDecl))) { 4825 SanitizerScope SanScope(this); 4826 EmitSanitizerStatReport(llvm::SanStat_CFI_ICall); 4827 4828 llvm::Metadata *MD; 4829 if (CGM.getCodeGenOpts().SanitizeCfiICallGeneralizePointers) 4830 MD = CGM.CreateMetadataIdentifierGeneralized(QualType(FnType, 0)); 4831 else 4832 MD = CGM.CreateMetadataIdentifierForType(QualType(FnType, 0)); 4833 4834 llvm::Value *TypeId = llvm::MetadataAsValue::get(getLLVMContext(), MD); 4835 4836 llvm::Value *CalleePtr = Callee.getFunctionPointer(); 4837 llvm::Value *CastedCallee = Builder.CreateBitCast(CalleePtr, Int8PtrTy); 4838 llvm::Value *TypeTest = Builder.CreateCall( 4839 CGM.getIntrinsic(llvm::Intrinsic::type_test), {CastedCallee, TypeId}); 4840 4841 auto CrossDsoTypeId = CGM.CreateCrossDsoCfiTypeId(MD); 4842 llvm::Constant *StaticData[] = { 4843 llvm::ConstantInt::get(Int8Ty, CFITCK_ICall), 4844 EmitCheckSourceLocation(E->getBeginLoc()), 4845 EmitCheckTypeDescriptor(QualType(FnType, 0)), 4846 }; 4847 if (CGM.getCodeGenOpts().SanitizeCfiCrossDso && CrossDsoTypeId) { 4848 EmitCfiSlowPathCheck(SanitizerKind::CFIICall, TypeTest, CrossDsoTypeId, 4849 CastedCallee, StaticData); 4850 } else { 4851 EmitCheck(std::make_pair(TypeTest, SanitizerKind::CFIICall), 4852 SanitizerHandler::CFICheckFail, StaticData, 4853 {CastedCallee, llvm::UndefValue::get(IntPtrTy)}); 4854 } 4855 } 4856 4857 CallArgList Args; 4858 if (Chain) 4859 Args.add(RValue::get(Builder.CreateBitCast(Chain, CGM.VoidPtrTy)), 4860 CGM.getContext().VoidPtrTy); 4861 4862 // C++17 requires that we evaluate arguments to a call using assignment syntax 4863 // right-to-left, and that we evaluate arguments to certain other operators 4864 // left-to-right. Note that we allow this to override the order dictated by 4865 // the calling convention on the MS ABI, which means that parameter 4866 // destruction order is not necessarily reverse construction order. 4867 // FIXME: Revisit this based on C++ committee response to unimplementability. 4868 EvaluationOrder Order = EvaluationOrder::Default; 4869 if (auto *OCE = dyn_cast<CXXOperatorCallExpr>(E)) { 4870 if (OCE->isAssignmentOp()) 4871 Order = EvaluationOrder::ForceRightToLeft; 4872 else { 4873 switch (OCE->getOperator()) { 4874 case OO_LessLess: 4875 case OO_GreaterGreater: 4876 case OO_AmpAmp: 4877 case OO_PipePipe: 4878 case OO_Comma: 4879 case OO_ArrowStar: 4880 Order = EvaluationOrder::ForceLeftToRight; 4881 break; 4882 default: 4883 break; 4884 } 4885 } 4886 } 4887 4888 EmitCallArgs(Args, dyn_cast<FunctionProtoType>(FnType), E->arguments(), 4889 E->getDirectCallee(), /*ParamsToSkip*/ 0, Order); 4890 4891 const CGFunctionInfo &FnInfo = CGM.getTypes().arrangeFreeFunctionCall( 4892 Args, FnType, /*ChainCall=*/Chain); 4893 4894 // C99 6.5.2.2p6: 4895 // If the expression that denotes the called function has a type 4896 // that does not include a prototype, [the default argument 4897 // promotions are performed]. If the number of arguments does not 4898 // equal the number of parameters, the behavior is undefined. If 4899 // the function is defined with a type that includes a prototype, 4900 // and either the prototype ends with an ellipsis (, ...) or the 4901 // types of the arguments after promotion are not compatible with 4902 // the types of the parameters, the behavior is undefined. If the 4903 // function is defined with a type that does not include a 4904 // prototype, and the types of the arguments after promotion are 4905 // not compatible with those of the parameters after promotion, 4906 // the behavior is undefined [except in some trivial cases]. 4907 // That is, in the general case, we should assume that a call 4908 // through an unprototyped function type works like a *non-variadic* 4909 // call. The way we make this work is to cast to the exact type 4910 // of the promoted arguments. 4911 // 4912 // Chain calls use this same code path to add the invisible chain parameter 4913 // to the function type. 4914 if (isa<FunctionNoProtoType>(FnType) || Chain) { 4915 llvm::Type *CalleeTy = getTypes().GetFunctionType(FnInfo); 4916 CalleeTy = CalleeTy->getPointerTo(); 4917 4918 llvm::Value *CalleePtr = Callee.getFunctionPointer(); 4919 CalleePtr = Builder.CreateBitCast(CalleePtr, CalleeTy, "callee.knr.cast"); 4920 Callee.setFunctionPointer(CalleePtr); 4921 } 4922 4923 llvm::CallBase *CallOrInvoke = nullptr; 4924 RValue Call = EmitCall(FnInfo, Callee, ReturnValue, Args, &CallOrInvoke, 4925 E->getExprLoc()); 4926 4927 // Generate function declaration DISuprogram in order to be used 4928 // in debug info about call sites. 4929 if (CGDebugInfo *DI = getDebugInfo()) { 4930 if (auto *CalleeDecl = dyn_cast_or_null<FunctionDecl>(TargetDecl)) 4931 DI->EmitFuncDeclForCallSite(CallOrInvoke, QualType(FnType, 0), 4932 CalleeDecl); 4933 } 4934 4935 return Call; 4936 } 4937 4938 LValue CodeGenFunction:: 4939 EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E) { 4940 Address BaseAddr = Address::invalid(); 4941 if (E->getOpcode() == BO_PtrMemI) { 4942 BaseAddr = EmitPointerWithAlignment(E->getLHS()); 4943 } else { 4944 BaseAddr = EmitLValue(E->getLHS()).getAddress(); 4945 } 4946 4947 llvm::Value *OffsetV = EmitScalarExpr(E->getRHS()); 4948 4949 const MemberPointerType *MPT 4950 = E->getRHS()->getType()->getAs<MemberPointerType>(); 4951 4952 LValueBaseInfo BaseInfo; 4953 TBAAAccessInfo TBAAInfo; 4954 Address MemberAddr = 4955 EmitCXXMemberDataPointerAddress(E, BaseAddr, OffsetV, MPT, &BaseInfo, 4956 &TBAAInfo); 4957 4958 return MakeAddrLValue(MemberAddr, MPT->getPointeeType(), BaseInfo, TBAAInfo); 4959 } 4960 4961 /// Given the address of a temporary variable, produce an r-value of 4962 /// its type. 4963 RValue CodeGenFunction::convertTempToRValue(Address addr, 4964 QualType type, 4965 SourceLocation loc) { 4966 LValue lvalue = MakeAddrLValue(addr, type, AlignmentSource::Decl); 4967 switch (getEvaluationKind(type)) { 4968 case TEK_Complex: 4969 return RValue::getComplex(EmitLoadOfComplex(lvalue, loc)); 4970 case TEK_Aggregate: 4971 return lvalue.asAggregateRValue(); 4972 case TEK_Scalar: 4973 return RValue::get(EmitLoadOfScalar(lvalue, loc)); 4974 } 4975 llvm_unreachable("bad evaluation kind"); 4976 } 4977 4978 void CodeGenFunction::SetFPAccuracy(llvm::Value *Val, float Accuracy) { 4979 assert(Val->getType()->isFPOrFPVectorTy()); 4980 if (Accuracy == 0.0 || !isa<llvm::Instruction>(Val)) 4981 return; 4982 4983 llvm::MDBuilder MDHelper(getLLVMContext()); 4984 llvm::MDNode *Node = MDHelper.createFPMath(Accuracy); 4985 4986 cast<llvm::Instruction>(Val)->setMetadata(llvm::LLVMContext::MD_fpmath, Node); 4987 } 4988 4989 namespace { 4990 struct LValueOrRValue { 4991 LValue LV; 4992 RValue RV; 4993 }; 4994 } 4995 4996 static LValueOrRValue emitPseudoObjectExpr(CodeGenFunction &CGF, 4997 const PseudoObjectExpr *E, 4998 bool forLValue, 4999 AggValueSlot slot) { 5000 SmallVector<CodeGenFunction::OpaqueValueMappingData, 4> opaques; 5001 5002 // Find the result expression, if any. 5003 const Expr *resultExpr = E->getResultExpr(); 5004 LValueOrRValue result; 5005 5006 for (PseudoObjectExpr::const_semantics_iterator 5007 i = E->semantics_begin(), e = E->semantics_end(); i != e; ++i) { 5008 const Expr *semantic = *i; 5009 5010 // If this semantic expression is an opaque value, bind it 5011 // to the result of its source expression. 5012 if (const auto *ov = dyn_cast<OpaqueValueExpr>(semantic)) { 5013 // Skip unique OVEs. 5014 if (ov->isUnique()) { 5015 assert(ov != resultExpr && 5016 "A unique OVE cannot be used as the result expression"); 5017 continue; 5018 } 5019 5020 // If this is the result expression, we may need to evaluate 5021 // directly into the slot. 5022 typedef CodeGenFunction::OpaqueValueMappingData OVMA; 5023 OVMA opaqueData; 5024 if (ov == resultExpr && ov->isRValue() && !forLValue && 5025 CodeGenFunction::hasAggregateEvaluationKind(ov->getType())) { 5026 CGF.EmitAggExpr(ov->getSourceExpr(), slot); 5027 LValue LV = CGF.MakeAddrLValue(slot.getAddress(), ov->getType(), 5028 AlignmentSource::Decl); 5029 opaqueData = OVMA::bind(CGF, ov, LV); 5030 result.RV = slot.asRValue(); 5031 5032 // Otherwise, emit as normal. 5033 } else { 5034 opaqueData = OVMA::bind(CGF, ov, ov->getSourceExpr()); 5035 5036 // If this is the result, also evaluate the result now. 5037 if (ov == resultExpr) { 5038 if (forLValue) 5039 result.LV = CGF.EmitLValue(ov); 5040 else 5041 result.RV = CGF.EmitAnyExpr(ov, slot); 5042 } 5043 } 5044 5045 opaques.push_back(opaqueData); 5046 5047 // Otherwise, if the expression is the result, evaluate it 5048 // and remember the result. 5049 } else if (semantic == resultExpr) { 5050 if (forLValue) 5051 result.LV = CGF.EmitLValue(semantic); 5052 else 5053 result.RV = CGF.EmitAnyExpr(semantic, slot); 5054 5055 // Otherwise, evaluate the expression in an ignored context. 5056 } else { 5057 CGF.EmitIgnoredExpr(semantic); 5058 } 5059 } 5060 5061 // Unbind all the opaques now. 5062 for (unsigned i = 0, e = opaques.size(); i != e; ++i) 5063 opaques[i].unbind(CGF); 5064 5065 return result; 5066 } 5067 5068 RValue CodeGenFunction::EmitPseudoObjectRValue(const PseudoObjectExpr *E, 5069 AggValueSlot slot) { 5070 return emitPseudoObjectExpr(*this, E, false, slot).RV; 5071 } 5072 5073 LValue CodeGenFunction::EmitPseudoObjectLValue(const PseudoObjectExpr *E) { 5074 return emitPseudoObjectExpr(*this, E, true, AggValueSlot::ignored()).LV; 5075 } 5076