15f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===--- CGExpr.cpp - Emit LLVM Code from Expressions ---------------------===// 25f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 35f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// The LLVM Compiler Infrastructure 45f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 50bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// This file is distributed under the University of Illinois Open Source 60bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// License. See LICENSE.TXT for details. 75f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 85f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 95f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// This contains code to emit Expr nodes as LLVM code. 115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "CodeGenFunction.h" 154c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall#include "CGCXXABI.h" 1655fc873017f10f6f566b182b70f6fc22aefa3464Chandler Carruth#include "CGCall.h" 1779bfb4b564dc3636aae15aafa6340f9430881121Devang Patel#include "CGDebugInfo.h" 18af2f62ce32e462f256855cd24b06dec4755d2827Daniel Dunbar#include "CGObjCRuntime.h" 1955fc873017f10f6f566b182b70f6fc22aefa3464Chandler Carruth#include "CGRecordLayout.h" 2055fc873017f10f6f566b182b70f6fc22aefa3464Chandler Carruth#include "CodeGenModule.h" 2101f151e0ffba72bcad770bea5f563a9b68ca050eJohn McCall#include "TargetInfo.h" 22de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/ASTContext.h" 23c4a1dea2dc56bd1357ec91b829a0b9e68229a13eDaniel Dunbar#include "clang/AST/DeclObjC.h" 246bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines#include "clang/AST/Attr.h" 2506057cef0bcd7804e80f3ce2bbe352178396c715Chandler Carruth#include "clang/Frontend/CodeGenOptions.h" 2655fc873017f10f6f566b182b70f6fc22aefa3464Chandler Carruth#include "llvm/ADT/Hashing.h" 273b844ba7d5be205a9b4f5f0b0d1b7978977f4b8cChandler Carruth#include "llvm/IR/DataLayout.h" 283b844ba7d5be205a9b4f5f0b0d1b7978977f4b8cChandler Carruth#include "llvm/IR/Intrinsics.h" 293b844ba7d5be205a9b4f5f0b0d1b7978977f4b8cChandler Carruth#include "llvm/IR/LLVMContext.h" 303b844ba7d5be205a9b4f5f0b0d1b7978977f4b8cChandler Carruth#include "llvm/IR/MDBuilder.h" 31cb5620c9b213f4bd323912159fdddda35e258a14Dmitri Gribenko#include "llvm/Support/ConvertUTF.h" 32cb5620c9b213f4bd323912159fdddda35e258a14Dmitri Gribenko 335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang; 345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace CodeGen; 355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===--------------------------------------------------------------------===// 375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Miscellaneous Helper Methods 385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===--------------------------------------------------------------------===// 395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 40d16c2cf1cafa413709aa487cbbd5dc392f1ba1ffJohn McCallllvm::Value *CodeGenFunction::EmitCastToVoidPtr(llvm::Value *value) { 41d16c2cf1cafa413709aa487cbbd5dc392f1ba1ffJohn McCall unsigned addressSpace = 42d16c2cf1cafa413709aa487cbbd5dc392f1ba1ffJohn McCall cast<llvm::PointerType>(value->getType())->getAddressSpace(); 43d16c2cf1cafa413709aa487cbbd5dc392f1ba1ffJohn McCall 442acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::PointerType *destType = Int8PtrTy; 45d16c2cf1cafa413709aa487cbbd5dc392f1ba1ffJohn McCall if (addressSpace) 46d16c2cf1cafa413709aa487cbbd5dc392f1ba1ffJohn McCall destType = llvm::Type::getInt8PtrTy(getLLVMContext(), addressSpace); 47d16c2cf1cafa413709aa487cbbd5dc392f1ba1ffJohn McCall 48d16c2cf1cafa413709aa487cbbd5dc392f1ba1ffJohn McCall if (value->getType() == destType) return value; 49d16c2cf1cafa413709aa487cbbd5dc392f1ba1ffJohn McCall return Builder.CreateBitCast(value, destType); 50d16c2cf1cafa413709aa487cbbd5dc392f1ba1ffJohn McCall} 51d16c2cf1cafa413709aa487cbbd5dc392f1ba1ffJohn McCall 525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// CreateTempAlloca - This creates a alloca and inserts it into the entry 535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// block. 542acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattnerllvm::AllocaInst *CodeGenFunction::CreateTempAlloca(llvm::Type *Ty, 555f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner const Twine &Name) { 56f1466848dce9c4c75d96a6cabdc8db560e26aac8Chris Lattner if (!Builder.isNamePreserving()) 576bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return new llvm::AllocaInst(Ty, nullptr, "", AllocaInsertPt); 586bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return new llvm::AllocaInst(Ty, nullptr, Name, AllocaInsertPt); 595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 61ac418162692a951ca3796d6830496a85a2d12493John McCallvoid CodeGenFunction::InitTempAlloca(llvm::AllocaInst *Var, 62ac418162692a951ca3796d6830496a85a2d12493John McCall llvm::Value *Init) { 636bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines auto *Store = new llvm::StoreInst(Init, Var); 64ac418162692a951ca3796d6830496a85a2d12493John McCall llvm::BasicBlock *Block = AllocaInsertPt->getParent(); 65ac418162692a951ca3796d6830496a85a2d12493John McCall Block->getInstList().insertAfter(&*AllocaInsertPt, Store); 66ac418162692a951ca3796d6830496a85a2d12493John McCall} 67ac418162692a951ca3796d6830496a85a2d12493John McCall 68121b3facb4e0585d23766f9c1e4fdf9018a4b217Chris Lattnerllvm::AllocaInst *CodeGenFunction::CreateIRTemp(QualType Ty, 695f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner const Twine &Name) { 709bd4da2cfa8b956b851200db8f9a37e175edbb15Daniel Dunbar llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertType(Ty), Name); 719bd4da2cfa8b956b851200db8f9a37e175edbb15Daniel Dunbar // FIXME: Should we prefer the preferred type alignment here? 729bd4da2cfa8b956b851200db8f9a37e175edbb15Daniel Dunbar CharUnits Align = getContext().getTypeAlignInChars(Ty); 739bd4da2cfa8b956b851200db8f9a37e175edbb15Daniel Dunbar Alloc->setAlignment(Align.getQuantity()); 749bd4da2cfa8b956b851200db8f9a37e175edbb15Daniel Dunbar return Alloc; 759bd4da2cfa8b956b851200db8f9a37e175edbb15Daniel Dunbar} 769bd4da2cfa8b956b851200db8f9a37e175edbb15Daniel Dunbar 77121b3facb4e0585d23766f9c1e4fdf9018a4b217Chris Lattnerllvm::AllocaInst *CodeGenFunction::CreateMemTemp(QualType Ty, 785f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner const Twine &Name) { 79195337d2e5d4625ae9dc1328c7cdbc7115b0261bDaniel Dunbar llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertTypeForMem(Ty), Name); 80195337d2e5d4625ae9dc1328c7cdbc7115b0261bDaniel Dunbar // FIXME: Should we prefer the preferred type alignment here? 81195337d2e5d4625ae9dc1328c7cdbc7115b0261bDaniel Dunbar CharUnits Align = getContext().getTypeAlignInChars(Ty); 82195337d2e5d4625ae9dc1328c7cdbc7115b0261bDaniel Dunbar Alloc->setAlignment(Align.getQuantity()); 83195337d2e5d4625ae9dc1328c7cdbc7115b0261bDaniel Dunbar return Alloc; 84195337d2e5d4625ae9dc1328c7cdbc7115b0261bDaniel Dunbar} 85195337d2e5d4625ae9dc1328c7cdbc7115b0261bDaniel Dunbar 865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// EvaluateExprAsBool - Perform the usual unary conversions on the specified 875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// expression and compare the result against zero, returning an Int1Ty value. 885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerllvm::Value *CodeGenFunction::EvaluateExprAsBool(const Expr *E) { 89651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines PGO.setCurrentStmt(E); 900bab0cdab751248ca389a5592bcb70eac5d39260John McCall if (const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>()) { 91d608cdb7c044365cf4e8764ade1e11e99c176078John McCall llvm::Value *MemPtr = EmitScalarExpr(E); 92d16c2cf1cafa413709aa487cbbd5dc392f1ba1ffJohn McCall return CGM.getCXXABI().EmitMemberPointerIsNotNull(*this, MemPtr, MPT); 933a1737030e3c8d209987325c61dacb8e4a65123bEli Friedman } 940bab0cdab751248ca389a5592bcb70eac5d39260John McCall 950bab0cdab751248ca389a5592bcb70eac5d39260John McCall QualType BoolTy = getContext().BoolTy; 969b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner if (!E->getType()->isAnyComplexType()) 979069fa22446996a50e9a13e2ef1053d5a7c8f1d9Chris Lattner return EmitScalarConversion(EmitScalarExpr(E), E->getType(), BoolTy); 985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 999069fa22446996a50e9a13e2ef1053d5a7c8f1d9Chris Lattner return EmitComplexToScalarConversion(EmitComplexExpr(E), E->getType(),BoolTy); 1005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 1015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1022a41637a995affa1563f4d82a8b026e326a2faa0John McCall/// EmitIgnoredExpr - Emit code to compute the specified expression, 1032a41637a995affa1563f4d82a8b026e326a2faa0John McCall/// ignoring the result. 1042a41637a995affa1563f4d82a8b026e326a2faa0John McCallvoid CodeGenFunction::EmitIgnoredExpr(const Expr *E) { 1052a41637a995affa1563f4d82a8b026e326a2faa0John McCall if (E->isRValue()) 1062a41637a995affa1563f4d82a8b026e326a2faa0John McCall return (void) EmitAnyExpr(E, AggValueSlot::ignored(), true); 1072a41637a995affa1563f4d82a8b026e326a2faa0John McCall 1082a41637a995affa1563f4d82a8b026e326a2faa0John McCall // Just emit it as an l-value and drop the result. 1092a41637a995affa1563f4d82a8b026e326a2faa0John McCall EmitLValue(E); 1102a41637a995affa1563f4d82a8b026e326a2faa0John McCall} 1112a41637a995affa1563f4d82a8b026e326a2faa0John McCall 112558d2abc7f9fd6801cc7677200992313ae90b5d8John McCall/// EmitAnyExpr - Emit code to compute the specified expression which 113558d2abc7f9fd6801cc7677200992313ae90b5d8John McCall/// can have any type. The result is returned as an RValue struct. 114558d2abc7f9fd6801cc7677200992313ae90b5d8John McCall/// If this is an aggregate expression, AggSlot indicates where the 115db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// result should be returned. 116e0c1168ec7910a1a7ed08df4d4f0c58c2fa2ecd1John McCallRValue CodeGenFunction::EmitAnyExpr(const Expr *E, 117e0c1168ec7910a1a7ed08df4d4f0c58c2fa2ecd1John McCall AggValueSlot aggSlot, 118e0c1168ec7910a1a7ed08df4d4f0c58c2fa2ecd1John McCall bool ignoreResult) { 1199d232c884ea9872d6555df0fd7359699819bc1f1John McCall switch (getEvaluationKind(E->getType())) { 1209d232c884ea9872d6555df0fd7359699819bc1f1John McCall case TEK_Scalar: 121e0c1168ec7910a1a7ed08df4d4f0c58c2fa2ecd1John McCall return RValue::get(EmitScalarExpr(E, ignoreResult)); 1229d232c884ea9872d6555df0fd7359699819bc1f1John McCall case TEK_Complex: 123e0c1168ec7910a1a7ed08df4d4f0c58c2fa2ecd1John McCall return RValue::getComplex(EmitComplexExpr(E, ignoreResult, ignoreResult)); 1249d232c884ea9872d6555df0fd7359699819bc1f1John McCall case TEK_Aggregate: 1259d232c884ea9872d6555df0fd7359699819bc1f1John McCall if (!ignoreResult && aggSlot.isIgnored()) 1269d232c884ea9872d6555df0fd7359699819bc1f1John McCall aggSlot = CreateAggTemp(E->getType(), "agg-temp"); 1279d232c884ea9872d6555df0fd7359699819bc1f1John McCall EmitAggExpr(E, aggSlot); 1289d232c884ea9872d6555df0fd7359699819bc1f1John McCall return aggSlot.asRValue(); 1299d232c884ea9872d6555df0fd7359699819bc1f1John McCall } 1309d232c884ea9872d6555df0fd7359699819bc1f1John McCall llvm_unreachable("bad evaluation kind"); 1319b65551d0b387a7597fb39356a4d8ef10046445eChris Lattner} 1329b65551d0b387a7597fb39356a4d8ef10046445eChris Lattner 133db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result will 134db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// always be accessible even if no aggregate location is provided. 135558d2abc7f9fd6801cc7677200992313ae90b5d8John McCallRValue CodeGenFunction::EmitAnyExprToTemp(const Expr *E) { 136558d2abc7f9fd6801cc7677200992313ae90b5d8John McCall AggValueSlot AggSlot = AggValueSlot::ignored(); 137db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1389d232c884ea9872d6555df0fd7359699819bc1f1John McCall if (hasAggregateEvaluationKind(E->getType())) 139558d2abc7f9fd6801cc7677200992313ae90b5d8John McCall AggSlot = CreateAggTemp(E->getType(), "agg.tmp"); 140558d2abc7f9fd6801cc7677200992313ae90b5d8John McCall return EmitAnyExpr(E, AggSlot); 14146f45b9bec4a265ad8400a538e5ec3a5683617f1Daniel Dunbar} 14246f45b9bec4a265ad8400a538e5ec3a5683617f1Daniel Dunbar 1433d3ec1c099ec8bfac3aa1fb0126fe515b7c7fa05John McCall/// EmitAnyExprToMem - Evaluate an expression into a given memory 1443d3ec1c099ec8bfac3aa1fb0126fe515b7c7fa05John McCall/// location. 1453d3ec1c099ec8bfac3aa1fb0126fe515b7c7fa05John McCallvoid CodeGenFunction::EmitAnyExprToMem(const Expr *E, 1463d3ec1c099ec8bfac3aa1fb0126fe515b7c7fa05John McCall llvm::Value *Location, 147649b4a1a9b5e6f768ca0cb84bd97b00f51083e15Chad Rosier Qualifiers Quals, 148649b4a1a9b5e6f768ca0cb84bd97b00f51083e15Chad Rosier bool IsInit) { 149f394078fde147dcf27e9b6a7965517388d64dcb6Eli Friedman // FIXME: This function should take an LValue as an argument. 1509d232c884ea9872d6555df0fd7359699819bc1f1John McCall switch (getEvaluationKind(E->getType())) { 1519d232c884ea9872d6555df0fd7359699819bc1f1John McCall case TEK_Complex: 1529d232c884ea9872d6555df0fd7359699819bc1f1John McCall EmitComplexExprIntoLValue(E, 1539d232c884ea9872d6555df0fd7359699819bc1f1John McCall MakeNaturalAlignAddrLValue(Location, E->getType()), 1549d232c884ea9872d6555df0fd7359699819bc1f1John McCall /*isInit*/ false); 1559d232c884ea9872d6555df0fd7359699819bc1f1John McCall return; 1569d232c884ea9872d6555df0fd7359699819bc1f1John McCall 1579d232c884ea9872d6555df0fd7359699819bc1f1John McCall case TEK_Aggregate: { 158d7722d9d76a851e7897f4127626616d3b1b8e530Eli Friedman CharUnits Alignment = getContext().getTypeAlignInChars(E->getType()); 159f394078fde147dcf27e9b6a7965517388d64dcb6Eli Friedman EmitAggExpr(E, AggValueSlot::forAddr(Location, Alignment, Quals, 160649b4a1a9b5e6f768ca0cb84bd97b00f51083e15Chad Rosier AggValueSlot::IsDestructed_t(IsInit), 16190b2bdf3b96892ea44e5bf6869a92a08d09a6545John McCall AggValueSlot::DoesNotNeedGCBarriers, 162649b4a1a9b5e6f768ca0cb84bd97b00f51083e15Chad Rosier AggValueSlot::IsAliased_t(!IsInit))); 1639d232c884ea9872d6555df0fd7359699819bc1f1John McCall return; 1649d232c884ea9872d6555df0fd7359699819bc1f1John McCall } 1659d232c884ea9872d6555df0fd7359699819bc1f1John McCall 1669d232c884ea9872d6555df0fd7359699819bc1f1John McCall case TEK_Scalar: { 1673d3ec1c099ec8bfac3aa1fb0126fe515b7c7fa05John McCall RValue RV = RValue::get(EmitScalarExpr(E, /*Ignore*/ false)); 1689f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar LValue LV = MakeAddrLValue(Location, E->getType()); 169545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall EmitStoreThroughLValue(RV, LV); 1709d232c884ea9872d6555df0fd7359699819bc1f1John McCall return; 1713d3ec1c099ec8bfac3aa1fb0126fe515b7c7fa05John McCall } 1729d232c884ea9872d6555df0fd7359699819bc1f1John McCall } 1739d232c884ea9872d6555df0fd7359699819bc1f1John McCall llvm_unreachable("bad evaluation kind"); 1743d3ec1c099ec8bfac3aa1fb0126fe515b7c7fa05John McCall} 1753d3ec1c099ec8bfac3aa1fb0126fe515b7c7fa05John McCall 1768a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smithstatic void 1778a07cd3f59a0ede54906bdc8ed21724815db27adRichard SmithpushTemporaryCleanup(CodeGenFunction &CGF, const MaterializeTemporaryExpr *M, 1788a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith const Expr *E, llvm::Value *ReferenceTemporary) { 1798a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith // Objective-C++ ARC: 1808a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith // If we are binding a reference to a temporary that has ownership, we 1818a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith // need to perform retain/release operations on the temporary. 1828a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith // 1838a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith // FIXME: This should be looking at E, not M. 1848a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith if (CGF.getLangOpts().ObjCAutoRefCount && 1858a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith M->getType()->isObjCLifetimeType()) { 1868a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith QualType ObjCARCReferenceLifetimeType = M->getType(); 1878a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith switch (Qualifiers::ObjCLifetime Lifetime = 1888a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith ObjCARCReferenceLifetimeType.getObjCLifetime()) { 1898a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith case Qualifiers::OCL_None: 1908a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith case Qualifiers::OCL_ExplicitNone: 1918a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith // Carry on to normal cleanup handling. 1928a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith break; 1938a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith 1948a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith case Qualifiers::OCL_Autoreleasing: 1958a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith // Nothing to do; cleaned up by an autorelease pool. 1968a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith return; 1978a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith 1988a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith case Qualifiers::OCL_Strong: 1998a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith case Qualifiers::OCL_Weak: 2008a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith switch (StorageDuration Duration = M->getStorageDuration()) { 2018a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith case SD_Static: 2028a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith // Note: we intentionally do not register a cleanup to release 2038a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith // the object on program termination. 2048a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith return; 2058a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith 2068a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith case SD_Thread: 2078a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith // FIXME: We should probably register a cleanup in this case. 2088a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith return; 2098a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith 2108a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith case SD_Automatic: 2118a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith case SD_FullExpression: 2128a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith assert(!ObjCARCReferenceLifetimeType->isArrayType()); 2138a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith CodeGenFunction::Destroyer *Destroy; 2148a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith CleanupKind CleanupKind; 2158a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith if (Lifetime == Qualifiers::OCL_Strong) { 2168a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith const ValueDecl *VD = M->getExtendingDecl(); 2178a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith bool Precise = 2188a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith VD && isa<VarDecl>(VD) && VD->hasAttr<ObjCPreciseLifetimeAttr>(); 2198a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith CleanupKind = CGF.getARCCleanupKind(); 2208a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith Destroy = Precise ? &CodeGenFunction::destroyARCStrongPrecise 2218a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith : &CodeGenFunction::destroyARCStrongImprecise; 2228a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith } else { 2238a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith // __weak objects always get EH cleanups; otherwise, exceptions 2248a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith // could cause really nasty crashes instead of mere leaks. 2258a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith CleanupKind = NormalAndEHCleanup; 2268a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith Destroy = &CodeGenFunction::destroyARCWeak; 2278a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith } 2288a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith if (Duration == SD_FullExpression) 2298a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith CGF.pushDestroy(CleanupKind, ReferenceTemporary, 2308a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith ObjCARCReferenceLifetimeType, *Destroy, 2318a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith CleanupKind & EHCleanup); 2328a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith else 2338a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith CGF.pushLifetimeExtendedDestroy(CleanupKind, ReferenceTemporary, 2348a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith ObjCARCReferenceLifetimeType, 2358a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith *Destroy, CleanupKind & EHCleanup); 2368a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith return; 2378a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith 2388a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith case SD_Dynamic: 2398a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith llvm_unreachable("temporary cannot have dynamic storage duration"); 2408a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith } 2418a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith llvm_unreachable("unknown storage duration"); 24285af7cecadbf5d4b905d6b3b4b1b6fa684183affRichard Smith } 24385af7cecadbf5d4b905d6b3b4b1b6fa684183affRichard Smith } 24485af7cecadbf5d4b905d6b3b4b1b6fa684183affRichard Smith 2456bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines CXXDestructorDecl *ReferenceTemporaryDtor = nullptr; 2468a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith if (const RecordType *RT = 2478a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith E->getType()->getBaseElementTypeUnsafe()->getAs<RecordType>()) { 2488a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith // Get the destructor for the reference temporary. 2496bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines auto *ClassDecl = cast<CXXRecordDecl>(RT->getDecl()); 2508a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith if (!ClassDecl->hasTrivialDestructor()) 2518a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith ReferenceTemporaryDtor = ClassDecl->getDestructor(); 2528a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith } 2538a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith 2548a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith if (!ReferenceTemporaryDtor) 2558a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith return; 2568a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith 2578a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith // Call the destructor for the temporary. 2588a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith switch (M->getStorageDuration()) { 2598a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith case SD_Static: 2608a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith case SD_Thread: { 2618a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith llvm::Constant *CleanupFn; 2628a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith llvm::Constant *CleanupArg; 2638a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith if (E->getType()->isArrayType()) { 2648a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith CleanupFn = CodeGenFunction(CGF.CGM).generateDestroyHelper( 2658a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith cast<llvm::Constant>(ReferenceTemporary), E->getType(), 266c7971a9efdf9880448a69aabb5182c3c27eecf6dDavid Blaikie CodeGenFunction::destroyCXXObject, CGF.getLangOpts().Exceptions, 267c7971a9efdf9880448a69aabb5182c3c27eecf6dDavid Blaikie dyn_cast_or_null<VarDecl>(M->getExtendingDecl())); 2688a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith CleanupArg = llvm::Constant::getNullValue(CGF.Int8PtrTy); 2698a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith } else { 2708a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith CleanupFn = 2718a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith CGF.CGM.GetAddrOfCXXDestructor(ReferenceTemporaryDtor, Dtor_Complete); 2728a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith CleanupArg = cast<llvm::Constant>(ReferenceTemporary); 2738a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith } 2748a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith CGF.CGM.getCXXABI().registerGlobalDtor( 2758a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith CGF, *cast<VarDecl>(M->getExtendingDecl()), CleanupFn, CleanupArg); 2768a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith break; 2778a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith } 2788a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith 2798a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith case SD_FullExpression: 2808a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith CGF.pushDestroy(NormalAndEHCleanup, ReferenceTemporary, E->getType(), 2818a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith CodeGenFunction::destroyCXXObject, 2828a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith CGF.getLangOpts().Exceptions); 2838a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith break; 2848a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith 2858a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith case SD_Automatic: 2868a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith CGF.pushLifetimeExtendedDestroy(NormalAndEHCleanup, 2878a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith ReferenceTemporary, E->getType(), 2888a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith CodeGenFunction::destroyCXXObject, 2898a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith CGF.getLangOpts().Exceptions); 2908a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith break; 2918a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith 2928a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith case SD_Dynamic: 2938a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith llvm_unreachable("temporary cannot have dynamic storage duration"); 2948a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith } 29585af7cecadbf5d4b905d6b3b4b1b6fa684183affRichard Smith} 29613dc8f98f6108dca8aaa9721567ed5a2d9911e0fSebastian Redl 29785af7cecadbf5d4b905d6b3b4b1b6fa684183affRichard Smithstatic llvm::Value * 2988a07cd3f59a0ede54906bdc8ed21724815db27adRichard SmithcreateReferenceTemporary(CodeGenFunction &CGF, 2998a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith const MaterializeTemporaryExpr *M, const Expr *Inner) { 3008a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith switch (M->getStorageDuration()) { 3018a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith case SD_FullExpression: 3028a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith case SD_Automatic: 3038a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith return CGF.CreateMemTemp(Inner->getType(), "ref.tmp"); 3048a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith 3058a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith case SD_Thread: 3068a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith case SD_Static: 3078a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith return CGF.CGM.GetAddrOfGlobalTemporary(M, Inner); 3088a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith 3098a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith case SD_Dynamic: 3108a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith llvm_unreachable("temporary can't have dynamic storage duration"); 3118a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith } 3128a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith llvm_unreachable("unknown storage duration"); 3138a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith} 314a57be5617a0735a654d4c8145be1fd752f776772Richard Smith 315d4ec562b3aaf50ea9015f82c96ebfd05a35fc7efRichard SmithLValue CodeGenFunction::EmitMaterializeTemporaryExpr( 316d4ec562b3aaf50ea9015f82c96ebfd05a35fc7efRichard Smith const MaterializeTemporaryExpr *M) { 317d4ec562b3aaf50ea9015f82c96ebfd05a35fc7efRichard Smith const Expr *E = M->GetTemporaryExpr(); 3188a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith 319d4ec562b3aaf50ea9015f82c96ebfd05a35fc7efRichard Smith if (getLangOpts().ObjCAutoRefCount && 3208a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith M->getType()->isObjCLifetimeType() && 3218a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith M->getType().getObjCLifetime() != Qualifiers::OCL_None && 3228a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith M->getType().getObjCLifetime() != Qualifiers::OCL_ExplicitNone) { 3238a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith // FIXME: Fold this into the general case below. 324d4ec562b3aaf50ea9015f82c96ebfd05a35fc7efRichard Smith llvm::Value *Object = createReferenceTemporary(*this, M, E); 325d4ec562b3aaf50ea9015f82c96ebfd05a35fc7efRichard Smith LValue RefTempDst = MakeAddrLValue(Object, M->getType()); 326d7b23167763f43d3e76b0de26141b1e52613ee3cDouglas Gregor 3276bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (auto *Var = dyn_cast<llvm::GlobalVariable>(Object)) { 3283282b84296dba58e811741b63e4429980a98df8bRichard Smith // We should not have emitted the initializer for this temporary as a 3293282b84296dba58e811741b63e4429980a98df8bRichard Smith // constant. 3303282b84296dba58e811741b63e4429980a98df8bRichard Smith assert(!Var->hasInitializer()); 3313282b84296dba58e811741b63e4429980a98df8bRichard Smith Var->setInitializer(CGM.EmitNullConstant(E->getType())); 3323282b84296dba58e811741b63e4429980a98df8bRichard Smith } 3333282b84296dba58e811741b63e4429980a98df8bRichard Smith 334d4ec562b3aaf50ea9015f82c96ebfd05a35fc7efRichard Smith EmitScalarInit(E, M->getExtendingDecl(), RefTempDst, false); 3358a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith 336d4ec562b3aaf50ea9015f82c96ebfd05a35fc7efRichard Smith pushTemporaryCleanup(*this, M, E, Object); 337d4ec562b3aaf50ea9015f82c96ebfd05a35fc7efRichard Smith return RefTempDst; 3381fd1e288d0f45b86d191d8f53f569e5143f3a18aJordan Rose } 3391fd1e288d0f45b86d191d8f53f569e5143f3a18aJordan Rose 3404e43dec4df9d7dd8e07b47bb15967f1b733a9bc6Richard Smith SmallVector<const Expr *, 2> CommaLHSs; 3411fd1e288d0f45b86d191d8f53f569e5143f3a18aJordan Rose SmallVector<SubobjectAdjustment, 2> Adjustments; 3424e43dec4df9d7dd8e07b47bb15967f1b733a9bc6Richard Smith E = E->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments); 3434e43dec4df9d7dd8e07b47bb15967f1b733a9bc6Richard Smith 3444e43dec4df9d7dd8e07b47bb15967f1b733a9bc6Richard Smith for (unsigned I = 0, N = CommaLHSs.size(); I != N; ++I) 345d4ec562b3aaf50ea9015f82c96ebfd05a35fc7efRichard Smith EmitIgnoredExpr(CommaLHSs[I]); 3464e43dec4df9d7dd8e07b47bb15967f1b733a9bc6Richard Smith 3476bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *opaque = dyn_cast<OpaqueValueExpr>(E)) { 3488a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith if (opaque->getType()->isRecordType()) { 3498a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith assert(Adjustments.empty()); 350d4ec562b3aaf50ea9015f82c96ebfd05a35fc7efRichard Smith return EmitOpaqueValueLValue(opaque); 3511fd1e288d0f45b86d191d8f53f569e5143f3a18aJordan Rose } 3521fd1e288d0f45b86d191d8f53f569e5143f3a18aJordan Rose } 353dca7ab2ea50a57545976e9d4c0472279fa397917Anders Carlsson 3548a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith // Create and initialize the reference temporary. 355d4ec562b3aaf50ea9015f82c96ebfd05a35fc7efRichard Smith llvm::Value *Object = createReferenceTemporary(*this, M, E); 3566bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (auto *Var = dyn_cast<llvm::GlobalVariable>(Object)) { 3573282b84296dba58e811741b63e4429980a98df8bRichard Smith // If the temporary is a global and has a constant initializer, we may 3583282b84296dba58e811741b63e4429980a98df8bRichard Smith // have already initialized it. 3593282b84296dba58e811741b63e4429980a98df8bRichard Smith if (!Var->hasInitializer()) { 3603282b84296dba58e811741b63e4429980a98df8bRichard Smith Var->setInitializer(CGM.EmitNullConstant(E->getType())); 3613282b84296dba58e811741b63e4429980a98df8bRichard Smith EmitAnyExprToMem(E, Object, Qualifiers(), /*IsInit*/true); 3623282b84296dba58e811741b63e4429980a98df8bRichard Smith } 3633282b84296dba58e811741b63e4429980a98df8bRichard Smith } else { 3643282b84296dba58e811741b63e4429980a98df8bRichard Smith EmitAnyExprToMem(E, Object, Qualifiers(), /*IsInit*/true); 3653282b84296dba58e811741b63e4429980a98df8bRichard Smith } 366d4ec562b3aaf50ea9015f82c96ebfd05a35fc7efRichard Smith pushTemporaryCleanup(*this, M, E, Object); 3678a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith 3688a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith // Perform derived-to-base casts and/or field accesses, to get from the 3698a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith // temporary object we created (and, potentially, for which we extended 3708a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith // the lifetime) to the subobject we're binding the reference to. 3718a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith for (unsigned I = Adjustments.size(); I != 0; --I) { 3728a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith SubobjectAdjustment &Adjustment = Adjustments[I-1]; 3738a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith switch (Adjustment.Kind) { 3748a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith case SubobjectAdjustment::DerivedToBaseAdjustment: 3758a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith Object = 376d4ec562b3aaf50ea9015f82c96ebfd05a35fc7efRichard Smith GetAddressOfBaseClass(Object, Adjustment.DerivedToBase.DerivedClass, 377d4ec562b3aaf50ea9015f82c96ebfd05a35fc7efRichard Smith Adjustment.DerivedToBase.BasePath->path_begin(), 378d4ec562b3aaf50ea9015f82c96ebfd05a35fc7efRichard Smith Adjustment.DerivedToBase.BasePath->path_end(), 379d4ec562b3aaf50ea9015f82c96ebfd05a35fc7efRichard Smith /*NullCheckValue=*/ false); 3808a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith break; 381545aa7a0f57d2bb2fc0eef83daa499300273d983Eli Friedman 3828a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith case SubobjectAdjustment::FieldAdjustment: { 383d4ec562b3aaf50ea9015f82c96ebfd05a35fc7efRichard Smith LValue LV = MakeAddrLValue(Object, E->getType()); 384d4ec562b3aaf50ea9015f82c96ebfd05a35fc7efRichard Smith LV = EmitLValueForField(LV, Adjustment.Field); 3858a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith assert(LV.isSimple() && 3868a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith "materialized temporary field is not a simple lvalue"); 3878a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith Object = LV.getAddress(); 3888a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith break; 389b3f744252a460c45e2e77053491285978286c384Anders Carlsson } 3901fd1e288d0f45b86d191d8f53f569e5143f3a18aJordan Rose 3918a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith case SubobjectAdjustment::MemberPointerAdjustment: { 392d4ec562b3aaf50ea9015f82c96ebfd05a35fc7efRichard Smith llvm::Value *Ptr = EmitScalarExpr(Adjustment.Ptr.RHS); 393d4ec562b3aaf50ea9015f82c96ebfd05a35fc7efRichard Smith Object = CGM.getCXXABI().EmitMemberDataPointerAddress( 394651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines *this, E, Object, Ptr, Adjustment.Ptr.MPT); 3958a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith break; 3968a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith } 3978a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith } 3984bbab92167713bf4f79c0b14dcc4e83d08ac4019Anders Carlsson } 3995df0d426026b3820b5f0b13a8d4e60e9373d8d9dEli Friedman 400d4ec562b3aaf50ea9015f82c96ebfd05a35fc7efRichard Smith return MakeAddrLValue(Object, M->getType()); 401dca7ab2ea50a57545976e9d4c0472279fa397917Anders Carlsson} 402dca7ab2ea50a57545976e9d4c0472279fa397917Anders Carlsson 403dca7ab2ea50a57545976e9d4c0472279fa397917Anders CarlssonRValue 404d4ec562b3aaf50ea9015f82c96ebfd05a35fc7efRichard SmithCodeGenFunction::EmitReferenceBindingToExpr(const Expr *E) { 405d4ec562b3aaf50ea9015f82c96ebfd05a35fc7efRichard Smith // Emit the expression as an lvalue. 406d4ec562b3aaf50ea9015f82c96ebfd05a35fc7efRichard Smith LValue LV = EmitLValue(E); 407d4ec562b3aaf50ea9015f82c96ebfd05a35fc7efRichard Smith assert(LV.isSimple()); 408d4ec562b3aaf50ea9015f82c96ebfd05a35fc7efRichard Smith llvm::Value *Value = LV.getAddress(); 4098a07cd3f59a0ede54906bdc8ed21724815db27adRichard Smith 410ef8225444452a1486bd721f3285301fe84643b00Stephen Hines if (sanitizePerformTypeCheck() && !E->getType()->isFunctionType()) { 4112c9f87ca5cccbfdaad82762368af5b2323320653Richard Smith // C++11 [dcl.ref]p5 (as amended by core issue 453): 4122c9f87ca5cccbfdaad82762368af5b2323320653Richard Smith // If a glvalue to which a reference is directly bound designates neither 4132c9f87ca5cccbfdaad82762368af5b2323320653Richard Smith // an existing object or function of an appropriate type nor a region of 4142c9f87ca5cccbfdaad82762368af5b2323320653Richard Smith // storage of suitable size and alignment to contain an object of the 4152c9f87ca5cccbfdaad82762368af5b2323320653Richard Smith // reference's type, the behavior is undefined. 4162c9f87ca5cccbfdaad82762368af5b2323320653Richard Smith QualType Ty = E->getType(); 4174def70d3040e73707c738f7c366737a986135edfRichard Smith EmitTypeCheck(TCK_ReferenceBinding, E->getExprLoc(), Value, Ty); 4182c9f87ca5cccbfdaad82762368af5b2323320653Richard Smith } 41981407d404a3fc8d24d0e2a052d85cae183033e2bJohn McCall 420dca7ab2ea50a57545976e9d4c0472279fa397917Anders Carlsson return RValue::get(Value); 4214029ca7ae9d3ffd7738fe2ed8782bebc30f36fd6Anders Carlsson} 4224029ca7ae9d3ffd7738fe2ed8782bebc30f36fd6Anders Carlsson 4234029ca7ae9d3ffd7738fe2ed8782bebc30f36fd6Anders Carlsson 424db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// getAccessedFieldNo - Given an encoded value and a result number, return the 425db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// input field number being accessed. 426db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stumpunsigned CodeGenFunction::getAccessedFieldNo(unsigned Idx, 4274f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman const llvm::Constant *Elts) { 42889f42834092621ab6ebac24e09b17b61ac000b6bChris Lattner return cast<llvm::ConstantInt>(Elts->getAggregateElement(Idx)) 42989f42834092621ab6ebac24e09b17b61ac000b6bChris Lattner ->getZExtValue(); 4304f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman} 4314f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman 4328e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith/// Emit the hash_16_bytes function from include/llvm/ADT/Hashing.h. 4338e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smithstatic llvm::Value *emitHash16Bytes(CGBuilderTy &Builder, llvm::Value *Low, 4348e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith llvm::Value *High) { 4358e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith llvm::Value *KMul = Builder.getInt64(0x9ddfea08eb382d69ULL); 4368e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith llvm::Value *K47 = Builder.getInt64(47); 4378e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith llvm::Value *A0 = Builder.CreateMul(Builder.CreateXor(Low, High), KMul); 4388e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith llvm::Value *A1 = Builder.CreateXor(Builder.CreateLShr(A0, K47), A0); 4398e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith llvm::Value *B0 = Builder.CreateMul(Builder.CreateXor(High, A1), KMul); 4408e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith llvm::Value *B1 = Builder.CreateXor(Builder.CreateLShr(B0, K47), B0); 4418e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith return Builder.CreateMul(B1, KMul); 4428e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith} 4438e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith 444ef8225444452a1486bd721f3285301fe84643b00Stephen Hinesbool CodeGenFunction::sanitizePerformTypeCheck() const { 445ef8225444452a1486bd721f3285301fe84643b00Stephen Hines return SanOpts->Null | SanOpts->Alignment | SanOpts->ObjectSize | 446ef8225444452a1486bd721f3285301fe84643b00Stephen Hines SanOpts->Vptr; 447ef8225444452a1486bd721f3285301fe84643b00Stephen Hines} 448ef8225444452a1486bd721f3285301fe84643b00Stephen Hines 4494def70d3040e73707c738f7c366737a986135edfRichard Smithvoid CodeGenFunction::EmitTypeCheck(TypeCheckKind TCK, SourceLocation Loc, 4504def70d3040e73707c738f7c366737a986135edfRichard Smith llvm::Value *Address, 4517ac9ef1c82c779a5348ed11b3d10e01c58803b35Richard Smith QualType Ty, CharUnits Alignment) { 452ef8225444452a1486bd721f3285301fe84643b00Stephen Hines if (!sanitizePerformTypeCheck()) 453b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump return; 454b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump 455292d67bb69e878104d2cdc1a1f72264e4fc2852aRichard Smith // Don't check pointers outside the default address space. The null check 456292d67bb69e878104d2cdc1a1f72264e4fc2852aRichard Smith // isn't correct, the object-size check isn't supported by LLVM, and we can't 457292d67bb69e878104d2cdc1a1f72264e4fc2852aRichard Smith // communicate the addresses to the runtime handler for the vptr check. 458292d67bb69e878104d2cdc1a1f72264e4fc2852aRichard Smith if (Address->getType()->getPointerAddressSpace()) 459292d67bb69e878104d2cdc1a1f72264e4fc2852aRichard Smith return; 460292d67bb69e878104d2cdc1a1f72264e4fc2852aRichard Smith 4616bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines llvm::Value *Cond = nullptr; 4626bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines llvm::BasicBlock *Done = nullptr; 4632c9f87ca5cccbfdaad82762368af5b2323320653Richard Smith 4644f45bc099f2665bc6e4bcbb169aa452390dbf3feWill Dietz if (SanOpts->Null) { 465d6396a681c9acbe56bc41bbc2bed2db45755bcd7Richard Smith // The glvalue must not be an empty glvalue. 466d6396a681c9acbe56bc41bbc2bed2db45755bcd7Richard Smith Cond = Builder.CreateICmpNE( 467d6396a681c9acbe56bc41bbc2bed2db45755bcd7Richard Smith Address, llvm::Constant::getNullValue(Address->getType())); 468c764830bdb6de82baed068889096bd3e52d4cbdaRichard Smith 469c764830bdb6de82baed068889096bd3e52d4cbdaRichard Smith if (TCK == TCK_DowncastPointer) { 470c764830bdb6de82baed068889096bd3e52d4cbdaRichard Smith // When performing a pointer downcast, it's OK if the value is null. 471c764830bdb6de82baed068889096bd3e52d4cbdaRichard Smith // Skip the remaining checks in that case. 472c764830bdb6de82baed068889096bd3e52d4cbdaRichard Smith Done = createBasicBlock("null"); 473c764830bdb6de82baed068889096bd3e52d4cbdaRichard Smith llvm::BasicBlock *Rest = createBasicBlock("not.null"); 474c764830bdb6de82baed068889096bd3e52d4cbdaRichard Smith Builder.CreateCondBr(Cond, Rest, Done); 475c764830bdb6de82baed068889096bd3e52d4cbdaRichard Smith EmitBlock(Rest); 4766bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines Cond = nullptr; 477c764830bdb6de82baed068889096bd3e52d4cbdaRichard Smith } 478d6396a681c9acbe56bc41bbc2bed2db45755bcd7Richard Smith } 4794def70d3040e73707c738f7c366737a986135edfRichard Smith 4804f45bc099f2665bc6e4bcbb169aa452390dbf3feWill Dietz if (SanOpts->ObjectSize && !Ty->isIncompleteType()) { 4812c9f87ca5cccbfdaad82762368af5b2323320653Richard Smith uint64_t Size = getContext().getTypeSizeInChars(Ty).getQuantity(); 4822c9f87ca5cccbfdaad82762368af5b2323320653Richard Smith 4832c9f87ca5cccbfdaad82762368af5b2323320653Richard Smith // The glvalue must refer to a large enough storage region. 484d6396a681c9acbe56bc41bbc2bed2db45755bcd7Richard Smith // FIXME: If Address Sanitizer is enabled, insert dynamic instrumentation 4852c9f87ca5cccbfdaad82762368af5b2323320653Richard Smith // to check this. 4868dd4baacf584b1fc7b0e2c79a0b8b197a4fb5fabMatt Arsenault // FIXME: Get object address space 4878dd4baacf584b1fc7b0e2c79a0b8b197a4fb5fabMatt Arsenault llvm::Type *Tys[2] = { IntPtrTy, Int8PtrTy }; 4888dd4baacf584b1fc7b0e2c79a0b8b197a4fb5fabMatt Arsenault llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::objectsize, Tys); 4892c9f87ca5cccbfdaad82762368af5b2323320653Richard Smith llvm::Value *Min = Builder.getFalse(); 490292d67bb69e878104d2cdc1a1f72264e4fc2852aRichard Smith llvm::Value *CastAddr = Builder.CreateBitCast(Address, Int8PtrTy); 4912c9f87ca5cccbfdaad82762368af5b2323320653Richard Smith llvm::Value *LargeEnough = 492292d67bb69e878104d2cdc1a1f72264e4fc2852aRichard Smith Builder.CreateICmpUGE(Builder.CreateCall2(F, CastAddr, Min), 4932c9f87ca5cccbfdaad82762368af5b2323320653Richard Smith llvm::ConstantInt::get(IntPtrTy, Size)); 4942c9f87ca5cccbfdaad82762368af5b2323320653Richard Smith Cond = Cond ? Builder.CreateAnd(Cond, LargeEnough) : LargeEnough; 4954def70d3040e73707c738f7c366737a986135edfRichard Smith } 4962c9f87ca5cccbfdaad82762368af5b2323320653Richard Smith 497d6396a681c9acbe56bc41bbc2bed2db45755bcd7Richard Smith uint64_t AlignVal = 0; 498d6396a681c9acbe56bc41bbc2bed2db45755bcd7Richard Smith 4994f45bc099f2665bc6e4bcbb169aa452390dbf3feWill Dietz if (SanOpts->Alignment) { 500d6396a681c9acbe56bc41bbc2bed2db45755bcd7Richard Smith AlignVal = Alignment.getQuantity(); 501d6396a681c9acbe56bc41bbc2bed2db45755bcd7Richard Smith if (!Ty->isIncompleteType() && !AlignVal) 502d6396a681c9acbe56bc41bbc2bed2db45755bcd7Richard Smith AlignVal = getContext().getTypeAlignInChars(Ty).getQuantity(); 503d6396a681c9acbe56bc41bbc2bed2db45755bcd7Richard Smith 5042c9f87ca5cccbfdaad82762368af5b2323320653Richard Smith // The glvalue must be suitably aligned. 505d6396a681c9acbe56bc41bbc2bed2db45755bcd7Richard Smith if (AlignVal) { 506d6396a681c9acbe56bc41bbc2bed2db45755bcd7Richard Smith llvm::Value *Align = 507d6396a681c9acbe56bc41bbc2bed2db45755bcd7Richard Smith Builder.CreateAnd(Builder.CreatePtrToInt(Address, IntPtrTy), 508d6396a681c9acbe56bc41bbc2bed2db45755bcd7Richard Smith llvm::ConstantInt::get(IntPtrTy, AlignVal - 1)); 509d6396a681c9acbe56bc41bbc2bed2db45755bcd7Richard Smith llvm::Value *Aligned = 510d6396a681c9acbe56bc41bbc2bed2db45755bcd7Richard Smith Builder.CreateICmpEQ(Align, llvm::ConstantInt::get(IntPtrTy, 0)); 511d6396a681c9acbe56bc41bbc2bed2db45755bcd7Richard Smith Cond = Cond ? Builder.CreateAnd(Cond, Aligned) : Aligned; 512d6396a681c9acbe56bc41bbc2bed2db45755bcd7Richard Smith } 5132c9f87ca5cccbfdaad82762368af5b2323320653Richard Smith } 514c24b9c46558919e98f4398ecbd45bc7b05f9acd9Chris Lattner 5154def70d3040e73707c738f7c366737a986135edfRichard Smith if (Cond) { 5164def70d3040e73707c738f7c366737a986135edfRichard Smith llvm::Constant *StaticData[] = { 5174def70d3040e73707c738f7c366737a986135edfRichard Smith EmitCheckSourceLocation(Loc), 5184def70d3040e73707c738f7c366737a986135edfRichard Smith EmitCheckTypeDescriptor(Ty), 5194def70d3040e73707c738f7c366737a986135edfRichard Smith llvm::ConstantInt::get(SizeTy, AlignVal), 5204def70d3040e73707c738f7c366737a986135edfRichard Smith llvm::ConstantInt::get(Int8Ty, TCK) 5214def70d3040e73707c738f7c366737a986135edfRichard Smith }; 522ad95481b2769ad61f23afc5e2c31f11c66090657Will Dietz EmitCheck(Cond, "type_mismatch", StaticData, Address, CRK_Recoverable); 5234def70d3040e73707c738f7c366737a986135edfRichard Smith } 5248e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith 525d6396a681c9acbe56bc41bbc2bed2db45755bcd7Richard Smith // If possible, check that the vptr indicates that there is a subobject of 526d6396a681c9acbe56bc41bbc2bed2db45755bcd7Richard Smith // type Ty at offset zero within this object. 527073fec91b73f08ba86ad46573141be14c7a0d262Richard Smith // 528073fec91b73f08ba86ad46573141be14c7a0d262Richard Smith // C++11 [basic.life]p5,6: 529073fec91b73f08ba86ad46573141be14c7a0d262Richard Smith // [For storage which does not refer to an object within its lifetime] 530073fec91b73f08ba86ad46573141be14c7a0d262Richard Smith // The program has undefined behavior if: 531073fec91b73f08ba86ad46573141be14c7a0d262Richard Smith // -- the [pointer or glvalue] is used to access a non-static data member 532c92384f871597902b8d5ffc33a662e8ac0d25db0Richard Smith // or call a non-static member function 5338e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith CXXRecordDecl *RD = Ty->getAsCXXRecordDecl(); 5344f45bc099f2665bc6e4bcbb169aa452390dbf3feWill Dietz if (SanOpts->Vptr && 535c764830bdb6de82baed068889096bd3e52d4cbdaRichard Smith (TCK == TCK_MemberAccess || TCK == TCK_MemberCall || 536c764830bdb6de82baed068889096bd3e52d4cbdaRichard Smith TCK == TCK_DowncastPointer || TCK == TCK_DowncastReference) && 5378e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith RD && RD->hasDefinition() && RD->isDynamicClass()) { 5388e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith // Compute a hash of the mangled name of the type. 5398e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith // 5408e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith // FIXME: This is not guaranteed to be deterministic! Move to a 5418e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith // fingerprinting mechanism once LLVM provides one. For the time 5428e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith // being the implementation happens to be deterministic. 543cfa88f893915ceb8ae4ce2f17c46c24a4d67502fDmitri Gribenko SmallString<64> MangledName; 5448e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith llvm::raw_svector_ostream Out(MangledName); 5458e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith CGM.getCXXABI().getMangleContext().mangleCXXRTTI(Ty.getUnqualifiedType(), 5468e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith Out); 5478e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith llvm::hash_code TypeHash = hash_value(Out.str()); 5488e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith 5498e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith // Load the vptr, and compute hash_16_bytes(TypeHash, vptr). 5508e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith llvm::Value *Low = llvm::ConstantInt::get(Int64Ty, TypeHash); 5518e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith llvm::Type *VPtrTy = llvm::PointerType::get(IntPtrTy, 0); 5528e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith llvm::Value *VPtrAddr = Builder.CreateBitCast(Address, VPtrTy); 5538e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith llvm::Value *VPtrVal = Builder.CreateLoad(VPtrAddr); 5548e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith llvm::Value *High = Builder.CreateZExt(VPtrVal, Int64Ty); 5558e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith 5568e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith llvm::Value *Hash = emitHash16Bytes(Builder, Low, High); 5578e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith Hash = Builder.CreateTrunc(Hash, IntPtrTy); 5588e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith 5598e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith // Look the hash up in our cache. 5608e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith const int CacheSize = 128; 5618e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith llvm::Type *HashTable = llvm::ArrayType::get(IntPtrTy, CacheSize); 5628e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith llvm::Value *Cache = CGM.CreateRuntimeVariable(HashTable, 5638e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith "__ubsan_vptr_type_cache"); 5648e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith llvm::Value *Slot = Builder.CreateAnd(Hash, 5658e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith llvm::ConstantInt::get(IntPtrTy, 5668e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith CacheSize-1)); 5678e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith llvm::Value *Indices[] = { Builder.getInt32(0), Slot }; 5688e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith llvm::Value *CacheVal = 5698e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith Builder.CreateLoad(Builder.CreateInBoundsGEP(Cache, Indices)); 5708e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith 5718e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith // If the hash isn't in the cache, call a runtime handler to perform the 5728e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith // hard work of checking whether the vptr is for an object of the right 5738e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith // type. This will either fill in the cache and return, or produce a 5748e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith // diagnostic. 5758e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith llvm::Constant *StaticData[] = { 5768e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith EmitCheckSourceLocation(Loc), 5778e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith EmitCheckTypeDescriptor(Ty), 5788e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith CGM.GetAddrOfRTTIDescriptor(Ty.getUnqualifiedType()), 5798e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith llvm::ConstantInt::get(Int8Ty, TCK) 5808e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith }; 5818e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith llvm::Value *DynamicData[] = { Address, Hash }; 5828e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith EmitCheck(Builder.CreateICmpEQ(CacheVal, Hash), 583ad95481b2769ad61f23afc5e2c31f11c66090657Will Dietz "dynamic_type_cache_miss", StaticData, DynamicData, 584ad95481b2769ad61f23afc5e2c31f11c66090657Will Dietz CRK_AlwaysRecoverable); 5858e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith } 586c764830bdb6de82baed068889096bd3e52d4cbdaRichard Smith 587c764830bdb6de82baed068889096bd3e52d4cbdaRichard Smith if (Done) { 588c764830bdb6de82baed068889096bd3e52d4cbdaRichard Smith Builder.CreateBr(Done); 589c764830bdb6de82baed068889096bd3e52d4cbdaRichard Smith EmitBlock(Done); 590c764830bdb6de82baed068889096bd3e52d4cbdaRichard Smith } 591b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump} 5929b65551d0b387a7597fb39356a4d8ef10046445eChris Lattner 593a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith/// Determine whether this expression refers to a flexible array member in a 594a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith/// struct. We disable array bounds checks for such members. 595a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smithstatic bool isFlexibleArrayMemberExpr(const Expr *E) { 596a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith // For compatibility with existing code, we treat arrays of length 0 or 597a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith // 1 as flexible array members. 598a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith const ArrayType *AT = E->getType()->castAsArrayTypeUnsafe(); 5996bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *CAT = dyn_cast<ConstantArrayType>(AT)) { 600a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith if (CAT->getSize().ugt(1)) 601a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith return false; 602a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith } else if (!isa<IncompleteArrayType>(AT)) 603a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith return false; 604a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith 605a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith E = E->IgnoreParens(); 606a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith 607a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith // A flexible array member must be the last member in the class. 6086bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *ME = dyn_cast<MemberExpr>(E)) { 609a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith // FIXME: If the base type of the member expr is not FD->getParent(), 610a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith // this should not be treated as a flexible array member access. 6116bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) { 612a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith RecordDecl::field_iterator FI( 613a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith DeclContext::decl_iterator(const_cast<FieldDecl *>(FD))); 614a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith return ++FI == FD->getParent()->field_end(); 615a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith } 616a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith } 617a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith 618a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith return false; 619a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith} 620a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith 621a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith/// If Base is known to point to the start of an array, return the length of 622a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith/// that array. Return 0 if the length cannot be determined. 6232c39b0605fff0600714532d348d24aa42a55477fBenjamin Kramerstatic llvm::Value *getArrayIndexingBound( 6242c39b0605fff0600714532d348d24aa42a55477fBenjamin Kramer CodeGenFunction &CGF, const Expr *Base, QualType &IndexedType) { 625a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith // For the vector indexing extension, the bound is the number of elements. 626a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith if (const VectorType *VT = Base->getType()->getAs<VectorType>()) { 627a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith IndexedType = Base->getType(); 628a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith return CGF.Builder.getInt32(VT->getNumElements()); 629a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith } 630a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith 631a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith Base = Base->IgnoreParens(); 632a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith 6336bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *CE = dyn_cast<CastExpr>(Base)) { 634a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith if (CE->getCastKind() == CK_ArrayToPointerDecay && 635a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith !isFlexibleArrayMemberExpr(CE->getSubExpr())) { 636a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith IndexedType = CE->getSubExpr()->getType(); 637a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith const ArrayType *AT = IndexedType->castAsArrayTypeUnsafe(); 6386bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *CAT = dyn_cast<ConstantArrayType>(AT)) 639a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith return CGF.Builder.getInt(CAT->getSize()); 6406bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines else if (const auto *VAT = dyn_cast<VariableArrayType>(AT)) 641a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith return CGF.getVLASize(VAT).first; 642a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith } 643a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith } 644a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith 6456bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return nullptr; 646a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith} 647a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith 648a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smithvoid CodeGenFunction::EmitBoundsCheck(const Expr *E, const Expr *Base, 649a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith llvm::Value *Index, QualType IndexType, 650a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith bool Accessed) { 65169170e6e41e72c84fe5303540c1aa7ca9944ff18Richard Smith assert(SanOpts->ArrayBounds && 65269170e6e41e72c84fe5303540c1aa7ca9944ff18Richard Smith "should not be called unless adding bounds checks"); 6535956bcc31ad0b1f570e04f7e19e817112f7274c5Richard Smith 654a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith QualType IndexedType; 655a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith llvm::Value *Bound = getArrayIndexingBound(*this, Base, IndexedType); 656a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith if (!Bound) 657a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith return; 658a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith 659a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith bool IndexSigned = IndexType->isSignedIntegerOrEnumerationType(); 660a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith llvm::Value *IndexVal = Builder.CreateIntCast(Index, SizeTy, IndexSigned); 661a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith llvm::Value *BoundVal = Builder.CreateIntCast(Bound, SizeTy, false); 662a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith 663a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith llvm::Constant *StaticData[] = { 664a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith EmitCheckSourceLocation(E->getExprLoc()), 665a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith EmitCheckTypeDescriptor(IndexedType), 666a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith EmitCheckTypeDescriptor(IndexType) 667a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith }; 668a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith llvm::Value *Check = Accessed ? Builder.CreateICmpULT(IndexVal, BoundVal) 669a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith : Builder.CreateICmpULE(IndexVal, BoundVal); 670a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith EmitCheck(Check, "out_of_bounds", StaticData, Index, CRK_Recoverable); 671a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith} 672a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith 673dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner 674dd36d328730d8c02915d0884541b45ec6ca0049dChris LattnerCodeGenFunction::ComplexPairTy CodeGenFunction:: 675dd36d328730d8c02915d0884541b45ec6ca0049dChris LattnerEmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV, 676dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner bool isInc, bool isPre) { 6774ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky ComplexPairTy InVal = EmitLoadOfComplex(LV, E->getExprLoc()); 6781cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 679dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner llvm::Value *NextVal; 680dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner if (isa<llvm::IntegerType>(InVal.first->getType())) { 681dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner uint64_t AmountVal = isInc ? 1 : -1; 682dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner NextVal = llvm::ConstantInt::get(InVal.first->getType(), AmountVal, true); 6831cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 684dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner // Add the inc/dec to the real part. 685dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner NextVal = Builder.CreateAdd(InVal.first, NextVal, isInc ? "inc" : "dec"); 686dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner } else { 687dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner QualType ElemTy = E->getType()->getAs<ComplexType>()->getElementType(); 688dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner llvm::APFloat FVal(getContext().getFloatTypeSemantics(ElemTy), 1); 689dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner if (!isInc) 690dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner FVal.changeSign(); 691dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner NextVal = llvm::ConstantFP::get(getLLVMContext(), FVal); 6921cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 693dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner // Add the inc/dec to the real part. 694dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner NextVal = Builder.CreateFAdd(InVal.first, NextVal, isInc ? "inc" : "dec"); 695dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner } 6961cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 697dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner ComplexPairTy IncVal(NextVal, InVal.second); 6981cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 699dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner // Store the updated result through the lvalue. 7009d232c884ea9872d6555df0fd7359699819bc1f1John McCall EmitStoreOfComplex(IncVal, LV, /*init*/ false); 7011cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 702dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner // If this is a postinc, return the value read from memory, otherwise use the 703dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner // updated value. 704dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner return isPre ? IncVal : InVal; 705dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner} 706dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner 707dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner 7085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 7095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// LValue Expression Emission 7105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 7115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 71213e81737a433b23f8c662d10d1d57356122a8caaDaniel DunbarRValue CodeGenFunction::GetUndefRValue(QualType Ty) { 713eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner if (Ty->isVoidType()) 7146bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return RValue::get(nullptr); 7159d232c884ea9872d6555df0fd7359699819bc1f1John McCall 7169d232c884ea9872d6555df0fd7359699819bc1f1John McCall switch (getEvaluationKind(Ty)) { 7179d232c884ea9872d6555df0fd7359699819bc1f1John McCall case TEK_Complex: { 7189d232c884ea9872d6555df0fd7359699819bc1f1John McCall llvm::Type *EltTy = 7199d232c884ea9872d6555df0fd7359699819bc1f1John McCall ConvertType(Ty->castAs<ComplexType>()->getElementType()); 72003e205031b08669f05c41eed5b896fc94c4a12bbOwen Anderson llvm::Value *U = llvm::UndefValue::get(EltTy); 7218fa73ed04dfad53696813cbd68058478d6c0becfDaniel Dunbar return RValue::getComplex(std::make_pair(U, U)); 722eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner } 7231cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 724b6c504b9101251bcb364dd9becbb887c97db27d3Chris Lattner // If this is a use of an undefined aggregate type, the aggregate must have an 725b6c504b9101251bcb364dd9becbb887c97db27d3Chris Lattner // identifiable address. Just because the contents of the value are undefined 726b6c504b9101251bcb364dd9becbb887c97db27d3Chris Lattner // doesn't mean that the address can't be taken and compared. 7279d232c884ea9872d6555df0fd7359699819bc1f1John McCall case TEK_Aggregate: { 728b6c504b9101251bcb364dd9becbb887c97db27d3Chris Lattner llvm::Value *DestPtr = CreateMemTemp(Ty, "undef.agg.tmp"); 729b6c504b9101251bcb364dd9becbb887c97db27d3Chris Lattner return RValue::getAggregate(DestPtr); 7308fa73ed04dfad53696813cbd68058478d6c0becfDaniel Dunbar } 7319d232c884ea9872d6555df0fd7359699819bc1f1John McCall 7329d232c884ea9872d6555df0fd7359699819bc1f1John McCall case TEK_Scalar: 7339d232c884ea9872d6555df0fd7359699819bc1f1John McCall return RValue::get(llvm::UndefValue::get(ConvertType(Ty))); 7349d232c884ea9872d6555df0fd7359699819bc1f1John McCall } 7359d232c884ea9872d6555df0fd7359699819bc1f1John McCall llvm_unreachable("bad evaluation kind"); 736ce1d38b8163650e473d7084e0686ed5a7956057bDaniel Dunbar} 737ce1d38b8163650e473d7084e0686ed5a7956057bDaniel Dunbar 73813e81737a433b23f8c662d10d1d57356122a8caaDaniel DunbarRValue CodeGenFunction::EmitUnsupportedRValue(const Expr *E, 73913e81737a433b23f8c662d10d1d57356122a8caaDaniel Dunbar const char *Name) { 74013e81737a433b23f8c662d10d1d57356122a8caaDaniel Dunbar ErrorUnsupported(E, Name); 74113e81737a433b23f8c662d10d1d57356122a8caaDaniel Dunbar return GetUndefRValue(E->getType()); 74213e81737a433b23f8c662d10d1d57356122a8caaDaniel Dunbar} 74313e81737a433b23f8c662d10d1d57356122a8caaDaniel Dunbar 7446ba82a4a4b295e54cf192c3e98b28f39990c6194Daniel DunbarLValue CodeGenFunction::EmitUnsupportedLValue(const Expr *E, 7456ba82a4a4b295e54cf192c3e98b28f39990c6194Daniel Dunbar const char *Name) { 7466ba82a4a4b295e54cf192c3e98b28f39990c6194Daniel Dunbar ErrorUnsupported(E, Name); 74796e0fc726c6fe7538522c60743705d5e696b40afOwen Anderson llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType())); 7489f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar return MakeAddrLValue(llvm::UndefValue::get(Ty), E->getType()); 7496ba82a4a4b295e54cf192c3e98b28f39990c6194Daniel Dunbar} 7506ba82a4a4b295e54cf192c3e98b28f39990c6194Daniel Dunbar 7517ac9ef1c82c779a5348ed11b3d10e01c58803b35Richard SmithLValue CodeGenFunction::EmitCheckedLValue(const Expr *E, TypeCheckKind TCK) { 752a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith LValue LV; 75369170e6e41e72c84fe5303540c1aa7ca9944ff18Richard Smith if (SanOpts->ArrayBounds && isa<ArraySubscriptExpr>(E)) 754a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith LV = EmitArraySubscriptExpr(cast<ArraySubscriptExpr>(E), /*Accessed*/true); 755a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith else 756a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith LV = EmitLValue(E); 757f0fe5bc0e46038dc79cdd27fcf0c77ad4789fdffDaniel Dunbar if (!isa<DeclRefExpr>(E) && !LV.isBitField() && LV.isSimple()) 7584def70d3040e73707c738f7c366737a986135edfRichard Smith EmitTypeCheck(TCK, E->getExprLoc(), LV.getAddress(), 7594def70d3040e73707c738f7c366737a986135edfRichard Smith E->getType(), LV.getAlignment()); 760b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump return LV; 761b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump} 762b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump 7635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// EmitLValue - Emit code to compute a designator that specifies the location 7645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// of the expression. 7655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// 766db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// This can return one of two things: a simple address or a bitfield reference. 767db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// In either case, the LLVM Value* in the LValue structure is guaranteed to be 768db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// an LLVM pointer type. 7695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// 770db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// If this returns a bitfield reference, nothing about the pointee type of the 771db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// LLVM value is known: For example, it may not be a pointer to an integer. 7725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// 773db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// If this returns a normal address, and if the lvalue's C type is fixed size, 774db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// this method guarantees that the returned pointer type will point to an LLVM 775db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type of the same size of the lvalue's type. If the lvalue has a variable 776db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// length type, this is not possible. 7775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// 7785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerLValue CodeGenFunction::EmitLValue(const Expr *E) { 7795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (E->getStmtClass()) { 7806ba82a4a4b295e54cf192c3e98b28f39990c6194Daniel Dunbar default: return EmitUnsupportedLValue(E, "l-value expression"); 7815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 782db45806b991013280a03057025c9538de64d5dfbJohn McCall case Expr::ObjCPropertyRefExprClass: 783db45806b991013280a03057025c9538de64d5dfbJohn McCall llvm_unreachable("cannot emit a property reference directly"); 784db45806b991013280a03057025c9538de64d5dfbJohn McCall 78503b2960c14aede6ac82bdef32247094ebb72fa69Fariborz Jahanian case Expr::ObjCSelectorExprClass: 786c5f804636e367ef744fd24cf88f7c956a5af0434Nico Weber return EmitObjCSelectorLValue(cast<ObjCSelectorExpr>(E)); 787820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian case Expr::ObjCIsaExprClass: 788820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian return EmitObjCIsaExpr(cast<ObjCIsaExpr>(E)); 789db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump case Expr::BinaryOperatorClass: 79080e62c29fe21cd06c93eba6e72b7e32dca06fcf9Daniel Dunbar return EmitBinaryOperatorLValue(cast<BinaryOperator>(E)); 7916a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case Expr::CompoundAssignOperatorClass: 7922a41637a995affa1563f4d82a8b026e326a2faa0John McCall if (!E->getType()->isAnyComplexType()) 7932a41637a995affa1563f4d82a8b026e326a2faa0John McCall return EmitCompoundAssignmentLValue(cast<CompoundAssignOperator>(E)); 7942a41637a995affa1563f4d82a8b026e326a2faa0John McCall return EmitComplexCompoundAssignmentLValue(cast<CompoundAssignOperator>(E)); 795db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump case Expr::CallExprClass: 796faf86648bfab7e0fa975e2b32c10fe1d8b461e8cAnders Carlsson case Expr::CXXMemberCallExprClass: 797b4609806e9232593ece09ce08b630836e825865cDouglas Gregor case Expr::CXXOperatorCallExprClass: 7989fcce65e7e1307b5b8da9be13e4092d6bb94dc1dRichard Smith case Expr::UserDefinedLiteralClass: 799b4609806e9232593ece09ce08b630836e825865cDouglas Gregor return EmitCallExprLValue(cast<CallExpr>(E)); 8005b5c9ef865607e179413462dcd71bcebb5b7daaeDaniel Dunbar case Expr::VAArgExprClass: 8015b5c9ef865607e179413462dcd71bcebb5b7daaeDaniel Dunbar return EmitVAArgExprLValue(cast<VAArgExpr>(E)); 802db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump case Expr::DeclRefExprClass: 8031a49af9681c350fef58e677f85ccb9a77e8e9d0aDouglas Gregor return EmitDeclRefLValue(cast<DeclRefExpr>(E)); 8046aff47db98890aa537edfb579b21d11d5ea3d1cdEric Christopher case Expr::ParenExprClass: 8056aff47db98890aa537edfb579b21d11d5ea3d1cdEric Christopher return EmitLValue(cast<ParenExpr>(E)->getSubExpr()); 806f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne case Expr::GenericSelectionExprClass: 807f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne return EmitLValue(cast<GenericSelectionExpr>(E)->getResultExpr()); 808d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris Lattner case Expr::PredefinedExprClass: 809d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris Lattner return EmitPredefinedLValue(cast<PredefinedExpr>(E)); 8105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Expr::StringLiteralClass: 8115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return EmitStringLiteralLValue(cast<StringLiteral>(E)); 812eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner case Expr::ObjCEncodeExprClass: 813eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner return EmitObjCEncodeExprLValue(cast<ObjCEncodeExpr>(E)); 8144b9c2d235fb9449e249d74f48ecfec601650de93John McCall case Expr::PseudoObjectExprClass: 8154b9c2d235fb9449e249d74f48ecfec601650de93John McCall return EmitPseudoObjectLValue(cast<PseudoObjectExpr>(E)); 81613dc8f98f6108dca8aaa9721567ed5a2d9911e0fSebastian Redl case Expr::InitListExprClass: 81713ec9100ca6bc03b5ce8832e4a0fcb724d47bcb1Richard Smith return EmitInitListLValue(cast<InitListExpr>(E)); 818b58d017f2b9eeed33f2ab3ede968b89cf5296bf2Anders Carlsson case Expr::CXXTemporaryObjectExprClass: 819b58d017f2b9eeed33f2ab3ede968b89cf5296bf2Anders Carlsson case Expr::CXXConstructExprClass: 820e61c9e80a108b5db7e5f0e702f0e455d737c6390Anders Carlsson return EmitCXXConstructLValue(cast<CXXConstructExpr>(E)); 821e61c9e80a108b5db7e5f0e702f0e455d737c6390Anders Carlsson case Expr::CXXBindTemporaryExprClass: 822e61c9e80a108b5db7e5f0e702f0e455d737c6390Anders Carlsson return EmitCXXBindTemporaryLValue(cast<CXXBindTemporaryExpr>(E)); 823c5f804636e367ef744fd24cf88f7c956a5af0434Nico Weber case Expr::CXXUuidofExprClass: 824c5f804636e367ef744fd24cf88f7c956a5af0434Nico Weber return EmitCXXUuidofLValue(cast<CXXUuidofExpr>(E)); 82531a3702618ab49578542cffee20ba0c8859b9d1eEli Friedman case Expr::LambdaExprClass: 82631a3702618ab49578542cffee20ba0c8859b9d1eEli Friedman return EmitLambdaLValue(cast<LambdaExpr>(E)); 8271a343ebbf413e8eae6b2737b2b2d79cbf5765571John McCall 8281a343ebbf413e8eae6b2737b2b2d79cbf5765571John McCall case Expr::ExprWithCleanupsClass: { 8296bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines const auto *cleanups = cast<ExprWithCleanups>(E); 8301a343ebbf413e8eae6b2737b2b2d79cbf5765571John McCall enterFullExpression(cleanups); 8311a343ebbf413e8eae6b2737b2b2d79cbf5765571John McCall RunCleanupsScope Scope(*this); 8321a343ebbf413e8eae6b2737b2b2d79cbf5765571John McCall return EmitLValue(cleanups->getSubExpr()); 8331a343ebbf413e8eae6b2737b2b2d79cbf5765571John McCall } 8341a343ebbf413e8eae6b2737b2b2d79cbf5765571John McCall 835370e53864aaed0288afdf532e127efe35d4b49f1Anders Carlsson case Expr::CXXDefaultArgExprClass: 836370e53864aaed0288afdf532e127efe35d4b49f1Anders Carlsson return EmitLValue(cast<CXXDefaultArgExpr>(E)->getExpr()); 837c3bf52ced9652f555aa0767bb822ec4c64546212Richard Smith case Expr::CXXDefaultInitExprClass: { 838c3bf52ced9652f555aa0767bb822ec4c64546212Richard Smith CXXDefaultInitExprScope Scope(*this); 839c3bf52ced9652f555aa0767bb822ec4c64546212Richard Smith return EmitLValue(cast<CXXDefaultInitExpr>(E)->getExpr()); 840c3bf52ced9652f555aa0767bb822ec4c64546212Richard Smith } 841c2e84ae9a6d25cea3e583c768e576b4c981ec028Mike Stump case Expr::CXXTypeidExprClass: 842c2e84ae9a6d25cea3e583c768e576b4c981ec028Mike Stump return EmitCXXTypeidLValue(cast<CXXTypeidExpr>(E)); 843e61c9e80a108b5db7e5f0e702f0e455d737c6390Anders Carlsson 8440a04d77bde7e3a661c2b41b60630d125d09ed6efDaniel Dunbar case Expr::ObjCMessageExprClass: 8450a04d77bde7e3a661c2b41b60630d125d09ed6efDaniel Dunbar return EmitObjCMessageExprLValue(cast<ObjCMessageExpr>(E)); 846db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump case Expr::ObjCIvarRefExprClass: 847391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner return EmitObjCIvarRefLValue(cast<ObjCIvarRefExpr>(E)); 848654599454c8e6cc83b1b9b3af43c49c2f66a26cbChris Lattner case Expr::StmtExprClass: 849654599454c8e6cc83b1b9b3af43c49c2f66a26cbChris Lattner return EmitStmtExprLValue(cast<StmtExpr>(E)); 850db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump case Expr::UnaryOperatorClass: 8515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return EmitUnaryOpLValue(cast<UnaryOperator>(E)); 8525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Expr::ArraySubscriptExprClass: 8535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return EmitArraySubscriptExpr(cast<ArraySubscriptExpr>(E)); 854213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman case Expr::ExtVectorElementExprClass: 855213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman return EmitExtVectorElementExpr(cast<ExtVectorElementExpr>(E)); 856db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump case Expr::MemberExprClass: 857bd4c4aebe6035e7a7125470cc9f0f92511230ee3Douglas Gregor return EmitMemberExpr(cast<MemberExpr>(E)); 85806e863f2902b8ba55b056308875c19f7ba3dab25Eli Friedman case Expr::CompoundLiteralExprClass: 85906e863f2902b8ba55b056308875c19f7ba3dab25Eli Friedman return EmitCompoundLiteralLValue(cast<CompoundLiteralExpr>(E)); 8609034558f2f9ac1dc6bd2e74f4481ca62fce28718Daniel Dunbar case Expr::ConditionalOperatorClass: 8616fcec8b58d0571866fcb162db947b029cc539ec4Anders Carlsson return EmitConditionalOperatorLValue(cast<ConditionalOperator>(E)); 86256ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall case Expr::BinaryConditionalOperatorClass: 86356ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall return EmitConditionalOperatorLValue(cast<BinaryConditionalOperator>(E)); 864670a62cd1d51042ea076cda5e93f26a1d8327fb3Chris Lattner case Expr::ChooseExprClass: 865a5e660188a3c654cf0c88ed1093b28207e870b2bEli Friedman return EmitLValue(cast<ChooseExpr>(E)->getChosenSubExpr()); 866e996ffd240f20a1048179d7727a6ee3227261921John McCall case Expr::OpaqueValueExprClass: 867e996ffd240f20a1048179d7727a6ee3227261921John McCall return EmitOpaqueValueLValue(cast<OpaqueValueExpr>(E)); 86891a5755ad73c5dc1dfb167e448fdd74e75a6df56John McCall case Expr::SubstNonTypeTemplateParmExprClass: 86991a5755ad73c5dc1dfb167e448fdd74e75a6df56John McCall return EmitLValue(cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement()); 870c3953a61f7e2a9919ce18d418f8b26a8612e87f2Chris Lattner case Expr::ImplicitCastExprClass: 871c3953a61f7e2a9919ce18d418f8b26a8612e87f2Chris Lattner case Expr::CStyleCastExprClass: 872c3953a61f7e2a9919ce18d418f8b26a8612e87f2Chris Lattner case Expr::CXXFunctionalCastExprClass: 873c3953a61f7e2a9919ce18d418f8b26a8612e87f2Chris Lattner case Expr::CXXStaticCastExprClass: 874c3953a61f7e2a9919ce18d418f8b26a8612e87f2Chris Lattner case Expr::CXXDynamicCastExprClass: 875c3953a61f7e2a9919ce18d418f8b26a8612e87f2Chris Lattner case Expr::CXXReinterpretCastExprClass: 876c3953a61f7e2a9919ce18d418f8b26a8612e87f2Chris Lattner case Expr::CXXConstCastExprClass: 877f85e193739c953358c865005855253af4f68a497John McCall case Expr::ObjCBridgedCastExprClass: 87875dfedaf702822c9e51a4f3c5d3ecf2d2ad99272Chris Lattner return EmitCastLValue(cast<CastExpr>(E)); 87913dc8f98f6108dca8aaa9721567ed5a2d9911e0fSebastian Redl 88003e80030515c800d1ab44125b9052dfffd1bd04cDouglas Gregor case Expr::MaterializeTemporaryExprClass: 88103e80030515c800d1ab44125b9052dfffd1bd04cDouglas Gregor return EmitMaterializeTemporaryExpr(cast<MaterializeTemporaryExpr>(E)); 8825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 8835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 8845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 885dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall/// Given an object of the given canonical type, can we safely copy a 886dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall/// value out of it based on its initializer? 887dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCallstatic bool isConstantEmittableObjectType(QualType type) { 888dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall assert(type.isCanonical()); 889dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall assert(!type->isReferenceType()); 890dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall 891dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall // Must be const-qualified but non-volatile. 892dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall Qualifiers qs = type.getLocalQualifiers(); 893dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall if (!qs.hasConst() || qs.hasVolatile()) return false; 894dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall 895dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall // Otherwise, all object types satisfy this except C++ classes with 896dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall // mutable subobjects or non-trivial copy/destroy behavior. 8976bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *RT = dyn_cast<RecordType>(type)) 8986bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) 899dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall if (RD->hasMutableFields() || !RD->isTrivial()) 900dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall return false; 901dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall 902dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall return true; 903dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall} 904dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall 905dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall/// Can we constant-emit a load of a reference to a variable of the 906dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall/// given type? This is different from predicates like 907dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall/// Decl::isUsableInConstantExpressions because we do want it to apply 908dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall/// in situations that don't necessarily satisfy the language's rules 909dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall/// for this (e.g. C++'s ODR-use rules). For example, we want to able 910dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall/// to do this with const float variables even if those variables 911dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall/// aren't marked 'constexpr'. 912dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCallenum ConstantEmissionKind { 913dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall CEK_None, 914dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall CEK_AsReferenceOnly, 915dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall CEK_AsValueOrReference, 916dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall CEK_AsValueOnly 917dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall}; 918dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCallstatic ConstantEmissionKind checkVarTypeForConstantEmission(QualType type) { 919dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall type = type.getCanonicalType(); 9206bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *ref = dyn_cast<ReferenceType>(type)) { 921dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall if (isConstantEmittableObjectType(ref->getPointeeType())) 922dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall return CEK_AsValueOrReference; 923dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall return CEK_AsReferenceOnly; 924dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall } 925dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall if (isConstantEmittableObjectType(type)) 926dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall return CEK_AsValueOnly; 927dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall return CEK_None; 928dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall} 929dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall 930dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall/// Try to emit a reference to the given value without producing it as 931dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall/// an l-value. This is actually more than an optimization: we can't 932dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall/// produce an l-value for variables that we never actually captured 933dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall/// in a block or lambda, which means const int variables or constexpr 934dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall/// literals or similar. 935dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCallCodeGenFunction::ConstantEmission 936f4b88a45902af1802a1cb42ba48b1c474474f228John McCallCodeGenFunction::tryEmitAsConstant(DeclRefExpr *refExpr) { 937f4b88a45902af1802a1cb42ba48b1c474474f228John McCall ValueDecl *value = refExpr->getDecl(); 938f4b88a45902af1802a1cb42ba48b1c474474f228John McCall 939dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall // The value needs to be an enum constant or a constant variable. 940dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall ConstantEmissionKind CEK; 941dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall if (isa<ParmVarDecl>(value)) { 942dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall CEK = CEK_None; 9436bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines } else if (auto *var = dyn_cast<VarDecl>(value)) { 944dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall CEK = checkVarTypeForConstantEmission(var->getType()); 945dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall } else if (isa<EnumConstantDecl>(value)) { 946dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall CEK = CEK_AsValueOnly; 947dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall } else { 948dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall CEK = CEK_None; 949dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall } 950dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall if (CEK == CEK_None) return ConstantEmission(); 951dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall 952dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall Expr::EvalResult result; 953dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall bool resultIsReference; 954dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall QualType resultType; 955dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall 956dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall // It's best to evaluate all the way as an r-value if that's permitted. 957dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall if (CEK != CEK_AsReferenceOnly && 958f4b88a45902af1802a1cb42ba48b1c474474f228John McCall refExpr->EvaluateAsRValue(result, getContext())) { 959dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall resultIsReference = false; 960dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall resultType = refExpr->getType(); 961dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall 962dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall // Otherwise, try to evaluate as an l-value. 963dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall } else if (CEK != CEK_AsValueOnly && 964f4b88a45902af1802a1cb42ba48b1c474474f228John McCall refExpr->EvaluateAsLValue(result, getContext())) { 965dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall resultIsReference = true; 966dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall resultType = value->getType(); 967dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall 968dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall // Failure. 969dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall } else { 970dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall return ConstantEmission(); 971dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall } 972dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall 973dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall // In any case, if the initializer has side-effects, abandon ship. 974dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall if (result.HasSideEffects) 975dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall return ConstantEmission(); 976dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall 977dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall // Emit as a constant. 978dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall llvm::Constant *C = CGM.EmitConstantValue(result.Val, resultType, this); 979dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall 9803b8e0b7f96164e8c49d2a833da26edd960f5da1fYunzhong Gao // Make sure we emit a debug reference to the global variable. 9813b8e0b7f96164e8c49d2a833da26edd960f5da1fYunzhong Gao // This should probably fire even for 9823b8e0b7f96164e8c49d2a833da26edd960f5da1fYunzhong Gao if (isa<VarDecl>(value)) { 9833b8e0b7f96164e8c49d2a833da26edd960f5da1fYunzhong Gao if (!getContext().DeclMustBeEmitted(cast<VarDecl>(value))) 9843b8e0b7f96164e8c49d2a833da26edd960f5da1fYunzhong Gao EmitDeclRefExprDbgValue(refExpr, C); 9853b8e0b7f96164e8c49d2a833da26edd960f5da1fYunzhong Gao } else { 9863b8e0b7f96164e8c49d2a833da26edd960f5da1fYunzhong Gao assert(isa<EnumConstantDecl>(value)); 9873b8e0b7f96164e8c49d2a833da26edd960f5da1fYunzhong Gao EmitDeclRefExprDbgValue(refExpr, C); 9883b8e0b7f96164e8c49d2a833da26edd960f5da1fYunzhong Gao } 989dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall 990dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall // If we emitted a reference constant, we need to dereference that. 991dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall if (resultIsReference) 992dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall return ConstantEmission::forReference(C); 993dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall 994dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall return ConstantEmission::forValue(C); 995dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall} 996dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall 9974ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewyckyllvm::Value *CodeGenFunction::EmitLoadOfScalar(LValue lvalue, 9984ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky SourceLocation Loc) { 999a07398ed98ea2b55ad7a505a3aab18aed93b149fJohn McCall return EmitLoadOfScalar(lvalue.getAddress(), lvalue.isVolatile(), 10006da2c716017d5c8530ec99779524491ebc5dadb8Eli Friedman lvalue.getAlignment().getQuantity(), 10014ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky lvalue.getType(), Loc, lvalue.getTBAAInfo(), 1002b37a73d5c6a0c8bb1f6e363d3b53980e4fa0ceadManman Ren lvalue.getTBAABaseType(), lvalue.getTBAAOffset()); 1003a07398ed98ea2b55ad7a505a3aab18aed93b149fJohn McCall} 1004a07398ed98ea2b55ad7a505a3aab18aed93b149fJohn McCall 1005c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindolastatic bool hasBooleanRepresentation(QualType Ty) { 1006c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola if (Ty->isBooleanType()) 1007c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola return true; 1008c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola 1009c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola if (const EnumType *ET = Ty->getAs<EnumType>()) 1010c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola return ET->getDecl()->getIntegerType()->isBooleanType(); 1011c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola 101247bfcca2d6972d98a1b25239cd1aa658b60680e2Douglas Gregor if (const AtomicType *AT = Ty->getAs<AtomicType>()) 101347bfcca2d6972d98a1b25239cd1aa658b60680e2Douglas Gregor return hasBooleanRepresentation(AT->getValueType()); 101447bfcca2d6972d98a1b25239cd1aa658b60680e2Douglas Gregor 1015c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola return false; 1016c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola} 1017c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola 1018463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smithstatic bool getRangeForType(CodeGenFunction &CGF, QualType Ty, 1019463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith llvm::APInt &Min, llvm::APInt &End, 1020463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith bool StrictEnums) { 1021c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola const EnumType *ET = Ty->getAs<EnumType>(); 1022463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith bool IsRegularCPlusPlusEnum = CGF.getLangOpts().CPlusPlus && StrictEnums && 1023463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith ET && !ET->getDecl()->isFixed(); 1024c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola bool IsBool = hasBooleanRepresentation(Ty); 1025c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola if (!IsBool && !IsRegularCPlusPlusEnum) 1026463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith return false; 1027c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola 1028c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola if (IsBool) { 1029463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith Min = llvm::APInt(CGF.getContext().getTypeSize(Ty), 0); 1030463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith End = llvm::APInt(CGF.getContext().getTypeSize(Ty), 2); 1031c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola } else { 1032c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola const EnumDecl *ED = ET->getDecl(); 1033463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith llvm::Type *LTy = CGF.ConvertTypeForMem(ED->getIntegerType()); 1034c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola unsigned Bitwidth = LTy->getScalarSizeInBits(); 1035c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola unsigned NumNegativeBits = ED->getNumNegativeBits(); 1036c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola unsigned NumPositiveBits = ED->getNumPositiveBits(); 1037c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola 1038c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola if (NumNegativeBits) { 1039c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola unsigned NumBits = std::max(NumNegativeBits, NumPositiveBits + 1); 1040c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola assert(NumBits <= Bitwidth); 1041c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola End = llvm::APInt(Bitwidth, 1) << (NumBits - 1); 1042c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola Min = -End; 1043c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola } else { 1044c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola assert(NumPositiveBits <= Bitwidth); 1045c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola End = llvm::APInt(Bitwidth, 1) << NumPositiveBits; 1046c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola Min = llvm::APInt(Bitwidth, 0); 1047c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola } 1048c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola } 1049463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith return true; 1050463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith} 1051463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith 1052463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smithllvm::MDNode *CodeGenFunction::getRangeForLoadFromType(QualType Ty) { 1053463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith llvm::APInt Min, End; 1054463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith if (!getRangeForType(*this, Ty, Min, End, 1055463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith CGM.getCodeGenOpts().StrictEnums)) 10566bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return nullptr; 1057c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola 10582d7cb069fe101da3971a07900ff583380bcac184Duncan Sands llvm::MDBuilder MDHelper(getLLVMContext()); 105960c77079d4767133a587c1c9390f2f5fd43fba9fDuncan Sands return MDHelper.createRange(Min, End); 1060c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola} 1061c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola 10629d9cc874bcc168474757a8f90476684b4a93ed76Daniel Dunbarllvm::Value *CodeGenFunction::EmitLoadOfScalar(llvm::Value *Addr, bool Volatile, 10634ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky unsigned Alignment, QualType Ty, 10644ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky SourceLocation Loc, 10654ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky llvm::MDNode *TBAAInfo, 10664ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky QualType TBAABaseType, 10674ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky uint64_t TBAAOffset) { 1068c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner // For better performance, handle vector loads differently. 1069c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner if (Ty->isVectorType()) { 1070c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner llvm::Value *V; 1071c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner const llvm::Type *EltTy = 1072c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner cast<llvm::PointerType>(Addr->getType())->getElementType(); 10731cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 10746bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines const auto *VTy = cast<llvm::VectorType>(EltTy); 10751cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 1076c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner // Handle vectors of size 3, like size 4 for better performance. 1077c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner if (VTy->getNumElements() == 3) { 10781cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 1079c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner // Bitcast to vec4 type. 1080c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner llvm::VectorType *vec4Ty = llvm::VectorType::get(VTy->getElementType(), 1081c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner 4); 1082c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner llvm::PointerType *ptVec4Ty = 1083c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner llvm::PointerType::get(vec4Ty, 1084c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner (cast<llvm::PointerType>( 1085c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner Addr->getType()))->getAddressSpace()); 1086c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner llvm::Value *Cast = Builder.CreateBitCast(Addr, ptVec4Ty, 1087c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner "castToVec4"); 1088c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner // Now load value. 1089c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner llvm::Value *LoadVal = Builder.CreateLoad(Cast, Volatile, "loadVec4"); 1090cdc2e82c317163693c99a8cbef76685e86420395Richard Smith 1091c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner // Shuffle vector to get vec3. 1092cdc2e82c317163693c99a8cbef76685e86420395Richard Smith llvm::Constant *Mask[] = { 1093cdc2e82c317163693c99a8cbef76685e86420395Richard Smith llvm::ConstantInt::get(llvm::Type::getInt32Ty(getLLVMContext()), 0), 1094cdc2e82c317163693c99a8cbef76685e86420395Richard Smith llvm::ConstantInt::get(llvm::Type::getInt32Ty(getLLVMContext()), 1), 1095cdc2e82c317163693c99a8cbef76685e86420395Richard Smith llvm::ConstantInt::get(llvm::Type::getInt32Ty(getLLVMContext()), 2) 1096cdc2e82c317163693c99a8cbef76685e86420395Richard Smith }; 1097cdc2e82c317163693c99a8cbef76685e86420395Richard Smith 1098c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner llvm::Value *MaskV = llvm::ConstantVector::get(Mask); 1099c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner V = Builder.CreateShuffleVector(LoadVal, 1100c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner llvm::UndefValue::get(vec4Ty), 1101c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner MaskV, "extractVec"); 1102c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner return EmitFromMemory(V, Ty); 1103c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner } 1104c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner } 11059eda3abe7e183b05834947391c0cdc291f4ee0d8John McCall 11069eda3abe7e183b05834947391c0cdc291f4ee0d8John McCall // Atomic operations have to be done on integral types. 11079eda3abe7e183b05834947391c0cdc291f4ee0d8John McCall if (Ty->isAtomicType()) { 11089eda3abe7e183b05834947391c0cdc291f4ee0d8John McCall LValue lvalue = LValue::MakeAddr(Addr, Ty, 11099eda3abe7e183b05834947391c0cdc291f4ee0d8John McCall CharUnits::fromQuantity(Alignment), 11109eda3abe7e183b05834947391c0cdc291f4ee0d8John McCall getContext(), TBAAInfo); 11114ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky return EmitAtomicLoad(lvalue, Loc).getScalarVal(); 11129eda3abe7e183b05834947391c0cdc291f4ee0d8John McCall } 11131cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 1114578faa837b552403e2002b97fdfbfde14f2448e5Benjamin Kramer llvm::LoadInst *Load = Builder.CreateLoad(Addr); 11152da84ff228a231adbd3f6f236b857f752d02959aDaniel Dunbar if (Volatile) 11162da84ff228a231adbd3f6f236b857f752d02959aDaniel Dunbar Load->setVolatile(true); 111791a16fa3265686b90054715eea504d9b4a13438bDaniel Dunbar if (Alignment) 111891a16fa3265686b90054715eea504d9b4a13438bDaniel Dunbar Load->setAlignment(Alignment); 1119b37a73d5c6a0c8bb1f6e363d3b53980e4fa0ceadManman Ren if (TBAAInfo) { 1120b37a73d5c6a0c8bb1f6e363d3b53980e4fa0ceadManman Ren llvm::MDNode *TBAAPath = CGM.getTBAAStructTagInfo(TBAABaseType, TBAAInfo, 1121b37a73d5c6a0c8bb1f6e363d3b53980e4fa0ceadManman Ren TBAAOffset); 1122feba9f2bdc5711894e452dfc67c9679482fbf897Manman Ren if (TBAAPath) 1123feba9f2bdc5711894e452dfc67c9679482fbf897Manman Ren CGM.DecorateInstruction(Load, TBAAPath, false/*ConvertTypeToTag*/); 1124b37a73d5c6a0c8bb1f6e363d3b53980e4fa0ceadManman Ren } 11259d9cc874bcc168474757a8f90476684b4a93ed76Daniel Dunbar 11264f45bc099f2665bc6e4bcbb169aa452390dbf3feWill Dietz if ((SanOpts->Bool && hasBooleanRepresentation(Ty)) || 11274f45bc099f2665bc6e4bcbb169aa452390dbf3feWill Dietz (SanOpts->Enum && Ty->getAs<EnumType>())) { 1128463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith llvm::APInt Min, End; 1129463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith if (getRangeForType(*this, Ty, Min, End, true)) { 1130463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith --End; 1131463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith llvm::Value *Check; 1132463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith if (!Min) 1133463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith Check = Builder.CreateICmpULE( 1134463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith Load, llvm::ConstantInt::get(getLLVMContext(), End)); 1135463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith else { 1136463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith llvm::Value *Upper = Builder.CreateICmpSLE( 1137463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith Load, llvm::ConstantInt::get(getLLVMContext(), End)); 1138463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith llvm::Value *Lower = Builder.CreateICmpSGE( 1139463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith Load, llvm::ConstantInt::get(getLLVMContext(), Min)); 1140463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith Check = Builder.CreateAnd(Upper, Lower); 1141463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith } 11424ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky llvm::Constant *StaticArgs[] = { 11434ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky EmitCheckSourceLocation(Loc), 11444ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky EmitCheckTypeDescriptor(Ty) 11454ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky }; 11464ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky EmitCheck(Check, "load_invalid_value", StaticArgs, EmitCheckValue(Load), 11474ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky CRK_Recoverable); 1148463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith } 1149463b48ba7eab6d7c96d23b59caea7f25de548293Richard Smith } else if (CGM.getCodeGenOpts().OptimizationLevel > 0) 1150c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola if (llvm::MDNode *RangeInfo = getRangeForLoadFromType(Ty)) 1151c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola Load->setMetadata(llvm::LLVMContext::MD_range, RangeInfo); 11521274ccd90aec0b205fc838c3d504821ccfb55482Douglas Gregor 1153c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola return EmitFromMemory(Load, Ty); 115488a569a9781e0472a1f1c392f6c94ed0c068d946NAKAMURA Takumi} 115588a569a9781e0472a1f1c392f6c94ed0c068d946NAKAMURA Takumi 115626815d97c5743481e317f17a8d53a6819d061862John McCallllvm::Value *CodeGenFunction::EmitToMemory(llvm::Value *Value, QualType Ty) { 115726815d97c5743481e317f17a8d53a6819d061862John McCall // Bool has a different representation in memory than in registers. 1158c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola if (hasBooleanRepresentation(Ty)) { 115926815d97c5743481e317f17a8d53a6819d061862John McCall // This should really always be an i1, but sometimes it's already 116026815d97c5743481e317f17a8d53a6819d061862John McCall // an i8, and it's awkward to track those cases down. 116126815d97c5743481e317f17a8d53a6819d061862John McCall if (Value->getType()->isIntegerTy(1)) 11628187c7e488837698c5fb7a84107e3347d276f73fEli Friedman return Builder.CreateZExt(Value, ConvertTypeForMem(Ty), "frombool"); 11638187c7e488837698c5fb7a84107e3347d276f73fEli Friedman assert(Value->getType()->isIntegerTy(getContext().getTypeSize(Ty)) && 11648187c7e488837698c5fb7a84107e3347d276f73fEli Friedman "wrong value rep of bool"); 116526815d97c5743481e317f17a8d53a6819d061862John McCall } 116611893327d056a7ebd820da8f00a3286e7430a91cRafael Espindola 116726815d97c5743481e317f17a8d53a6819d061862John McCall return Value; 116826815d97c5743481e317f17a8d53a6819d061862John McCall} 116926815d97c5743481e317f17a8d53a6819d061862John McCall 117026815d97c5743481e317f17a8d53a6819d061862John McCallllvm::Value *CodeGenFunction::EmitFromMemory(llvm::Value *Value, QualType Ty) { 117126815d97c5743481e317f17a8d53a6819d061862John McCall // Bool has a different representation in memory than in registers. 1172c3f8955d7da1019dbe16b0bdf3e49d2e08d988e9Rafael Espindola if (hasBooleanRepresentation(Ty)) { 11738187c7e488837698c5fb7a84107e3347d276f73fEli Friedman assert(Value->getType()->isIntegerTy(getContext().getTypeSize(Ty)) && 11748187c7e488837698c5fb7a84107e3347d276f73fEli Friedman "wrong value rep of bool"); 117526815d97c5743481e317f17a8d53a6819d061862John McCall return Builder.CreateTrunc(Value, Builder.getInt1Ty(), "tobool"); 117611893327d056a7ebd820da8f00a3286e7430a91cRafael Espindola } 117711893327d056a7ebd820da8f00a3286e7430a91cRafael Espindola 117826815d97c5743481e317f17a8d53a6819d061862John McCall return Value; 117926815d97c5743481e317f17a8d53a6819d061862John McCall} 118026815d97c5743481e317f17a8d53a6819d061862John McCall 118126815d97c5743481e317f17a8d53a6819d061862John McCallvoid CodeGenFunction::EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr, 118226815d97c5743481e317f17a8d53a6819d061862John McCall bool Volatile, unsigned Alignment, 11835d4a7559df106959dd721744c8971547f0f09097Nick Lewycky QualType Ty, llvm::MDNode *TBAAInfo, 1184b37a73d5c6a0c8bb1f6e363d3b53980e4fa0ceadManman Ren bool isInit, QualType TBAABaseType, 1185b37a73d5c6a0c8bb1f6e363d3b53980e4fa0ceadManman Ren uint64_t TBAAOffset) { 11861cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 1187c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner // Handle vectors differently to get better performance. 1188c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner if (Ty->isVectorType()) { 1189c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner llvm::Type *SrcTy = Value->getType(); 11906bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines auto *VecTy = cast<llvm::VectorType>(SrcTy); 1191c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner // Handle vec3 special. 1192c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner if (VecTy->getNumElements() == 3) { 1193c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner llvm::LLVMContext &VMContext = getLLVMContext(); 11941cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 1195c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner // Our source is a vec3, do a shuffle vector to make it a vec4. 1196cfa88f893915ceb8ae4ce2f17c46c24a4d67502fDmitri Gribenko SmallVector<llvm::Constant*, 4> Mask; 11975d4a7559df106959dd721744c8971547f0f09097Nick Lewycky Mask.push_back(llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 1198c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner 0)); 11995d4a7559df106959dd721744c8971547f0f09097Nick Lewycky Mask.push_back(llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 1200c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner 1)); 12015d4a7559df106959dd721744c8971547f0f09097Nick Lewycky Mask.push_back(llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 1202c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner 2)); 1203c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner Mask.push_back(llvm::UndefValue::get(llvm::Type::getInt32Ty(VMContext))); 12041cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 1205c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner llvm::Value *MaskV = llvm::ConstantVector::get(Mask); 1206c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner Value = Builder.CreateShuffleVector(Value, 1207c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner llvm::UndefValue::get(VecTy), 1208c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner MaskV, "extractVec"); 1209c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner SrcTy = llvm::VectorType::get(VecTy->getElementType(), 4); 1210c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner } 12116bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines auto *DstPtr = cast<llvm::PointerType>(Addr->getType()); 1212c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner if (DstPtr->getElementType() != SrcTy) { 1213c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner llvm::Type *MemTy = 1214c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner llvm::PointerType::get(SrcTy, DstPtr->getAddressSpace()); 1215c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner Addr = Builder.CreateBitCast(Addr, MemTy, "storetmp"); 1216c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner } 1217c58dcdc8facb646d88675bb6fbcb5c787166c4beTanya Lattner } 12181cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 121926815d97c5743481e317f17a8d53a6819d061862John McCall Value = EmitToMemory(Value, Ty); 12209d232c884ea9872d6555df0fd7359699819bc1f1John McCall 12219eda3abe7e183b05834947391c0cdc291f4ee0d8John McCall if (Ty->isAtomicType()) { 12229eda3abe7e183b05834947391c0cdc291f4ee0d8John McCall EmitAtomicStore(RValue::get(Value), 12239eda3abe7e183b05834947391c0cdc291f4ee0d8John McCall LValue::MakeAddr(Addr, Ty, 12249eda3abe7e183b05834947391c0cdc291f4ee0d8John McCall CharUnits::fromQuantity(Alignment), 12259eda3abe7e183b05834947391c0cdc291f4ee0d8John McCall getContext(), TBAAInfo), 12269eda3abe7e183b05834947391c0cdc291f4ee0d8John McCall isInit); 12279eda3abe7e183b05834947391c0cdc291f4ee0d8John McCall return; 12289eda3abe7e183b05834947391c0cdc291f4ee0d8John McCall } 12299eda3abe7e183b05834947391c0cdc291f4ee0d8John McCall 123091a16fa3265686b90054715eea504d9b4a13438bDaniel Dunbar llvm::StoreInst *Store = Builder.CreateStore(Value, Addr, Volatile); 123191a16fa3265686b90054715eea504d9b4a13438bDaniel Dunbar if (Alignment) 123291a16fa3265686b90054715eea504d9b4a13438bDaniel Dunbar Store->setAlignment(Alignment); 1233b37a73d5c6a0c8bb1f6e363d3b53980e4fa0ceadManman Ren if (TBAAInfo) { 1234b37a73d5c6a0c8bb1f6e363d3b53980e4fa0ceadManman Ren llvm::MDNode *TBAAPath = CGM.getTBAAStructTagInfo(TBAABaseType, TBAAInfo, 1235b37a73d5c6a0c8bb1f6e363d3b53980e4fa0ceadManman Ren TBAAOffset); 1236feba9f2bdc5711894e452dfc67c9679482fbf897Manman Ren if (TBAAPath) 1237feba9f2bdc5711894e452dfc67c9679482fbf897Manman Ren CGM.DecorateInstruction(Store, TBAAPath, false/*ConvertTypeToTag*/); 1238b37a73d5c6a0c8bb1f6e363d3b53980e4fa0ceadManman Ren } 12399d9cc874bcc168474757a8f90476684b4a93ed76Daniel Dunbar} 12409d9cc874bcc168474757a8f90476684b4a93ed76Daniel Dunbar 12417a7ee3033e44b45630981355460ef89efa0bdcc4David Chisnallvoid CodeGenFunction::EmitStoreOfScalar(llvm::Value *value, LValue lvalue, 12429d232c884ea9872d6555df0fd7359699819bc1f1John McCall bool isInit) { 1243a07398ed98ea2b55ad7a505a3aab18aed93b149fJohn McCall EmitStoreOfScalar(value, lvalue.getAddress(), lvalue.isVolatile(), 12446da2c716017d5c8530ec99779524491ebc5dadb8Eli Friedman lvalue.getAlignment().getQuantity(), lvalue.getType(), 1245b37a73d5c6a0c8bb1f6e363d3b53980e4fa0ceadManman Ren lvalue.getTBAAInfo(), isInit, lvalue.getTBAABaseType(), 1246b37a73d5c6a0c8bb1f6e363d3b53980e4fa0ceadManman Ren lvalue.getTBAAOffset()); 1247a07398ed98ea2b55ad7a505a3aab18aed93b149fJohn McCall} 1248a07398ed98ea2b55ad7a505a3aab18aed93b149fJohn McCall 1249db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitLoadOfLValue - Given an expression that represents a value lvalue, this 1250db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// method emits the address of the lvalue, then loads the result as an rvalue, 1251db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// returning the rvalue. 12524ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick LewyckyRValue CodeGenFunction::EmitLoadOfLValue(LValue LV, SourceLocation Loc) { 1253dbd32c20c529430fe1d22d87317f039849b8b0bbFariborz Jahanian if (LV.isObjCWeak()) { 1254db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // load of a __weak object. 12556dc2317b59cb1180a59f6c283d96b7a5dfeb5307Fariborz Jahanian llvm::Value *AddrWeakObj = LV.getAddress(); 1256eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner return RValue::get(CGM.getObjCRuntime().EmitObjCWeakRead(*this, 1257eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner AddrWeakObj)); 12586dc2317b59cb1180a59f6c283d96b7a5dfeb5307Fariborz Jahanian } 125982c458ea76bf8f0981e3d1b5070c0b0e5878d784Fariborz Jahanian if (LV.getQuals().getObjCLifetime() == Qualifiers::OCL_Weak) { 126082c458ea76bf8f0981e3d1b5070c0b0e5878d784Fariborz Jahanian llvm::Value *Object = EmitARCLoadWeakRetained(LV.getAddress()); 126182c458ea76bf8f0981e3d1b5070c0b0e5878d784Fariborz Jahanian Object = EmitObjCConsumeObject(LV.getType(), Object); 126282c458ea76bf8f0981e3d1b5070c0b0e5878d784Fariborz Jahanian return RValue::get(Object); 126382c458ea76bf8f0981e3d1b5070c0b0e5878d784Fariborz Jahanian } 1264db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 12655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (LV.isSimple()) { 1266e6d134b244cd666c47a3d2dd78f82ff0824188bdJohn McCall assert(!LV.getType()->isFunctionType()); 1267d608cdb7c044365cf4e8764ade1e11e99c176078John McCall 1268d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // Everything needs a load. 12694ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky return RValue::get(EmitLoadOfScalar(LV, Loc)); 12705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1271db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 12725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (LV.isVectorElt()) { 1273e5a8aeb4ad762b9383f9e9544c619dc386951e18Eli Friedman llvm::LoadInst *Load = Builder.CreateLoad(LV.getVectorAddr(), 1274e5a8aeb4ad762b9383f9e9544c619dc386951e18Eli Friedman LV.isVolatileQualified()); 1275e5a8aeb4ad762b9383f9e9544c619dc386951e18Eli Friedman Load->setAlignment(LV.getAlignment().getQuantity()); 1276e5a8aeb4ad762b9383f9e9544c619dc386951e18Eli Friedman return RValue::get(Builder.CreateExtractElement(Load, LV.getVectorIdx(), 12775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer "vecext")); 12785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 127946ea8eb7cc6244b479e6feca55cf234a91d383d7Chris Lattner 128046ea8eb7cc6244b479e6feca55cf234a91d383d7Chris Lattner // If this is a reference to a subset of the elements of a vector, either 128146ea8eb7cc6244b479e6feca55cf234a91d383d7Chris Lattner // shuffle the input or extract/insert them as appropriate. 1282213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman if (LV.isExtVectorElt()) 1283545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall return EmitLoadOfExtVectorElementLValue(LV); 12843b8c22d93da1432b2d4cea779d14912645c93866Lauro Ramos Venancio 12856bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines // Global Register variables always invoke intrinsics 12866bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (LV.isGlobalReg()) 12876bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return EmitLoadOfGlobalRegLValue(LV); 12886bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines 1289db45806b991013280a03057025c9538de64d5dfbJohn McCall assert(LV.isBitField() && "Unknown LValue type!"); 1290db45806b991013280a03057025c9538de64d5dfbJohn McCall return EmitLoadOfBitfieldLValue(LV); 129134cdc86af5b0a54084a512a1b2643365b8f5bdd2Chris Lattner} 12923b126125ec5dc9f17cf94e2b11acde0edce9dd6aChris Lattner 1293545d996ec5a3113f046944f11b27cc2d6cb055b4John McCallRValue CodeGenFunction::EmitLoadOfBitfieldLValue(LValue LV) { 1294efbf487da83883c2da81181cac6f040928aa4289Daniel Dunbar const CGBitFieldInfo &Info = LV.getBitFieldInfo(); 12953b8c22d93da1432b2d4cea779d14912645c93866Lauro Ramos Venancio 1296ecdb41ebc30e781ccbd3d89674caebc4fd35f023Daniel Dunbar // Get the output type. 12972acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *ResLTy = ConvertType(LV.getType()); 1298ecdb41ebc30e781ccbd3d89674caebc4fd35f023Daniel Dunbar 129972d2dab6058467036df73a5f668036a519043e5bChandler Carruth llvm::Value *Ptr = LV.getBitFieldAddr(); 130072d2dab6058467036df73a5f668036a519043e5bChandler Carruth llvm::Value *Val = Builder.CreateLoad(Ptr, LV.isVolatileQualified(), 130172d2dab6058467036df73a5f668036a519043e5bChandler Carruth "bf.load"); 130272d2dab6058467036df73a5f668036a519043e5bChandler Carruth cast<llvm::LoadInst>(Val)->setAlignment(Info.StorageAlignment); 130372d2dab6058467036df73a5f668036a519043e5bChandler Carruth 130472d2dab6058467036df73a5f668036a519043e5bChandler Carruth if (Info.IsSigned) { 1305cc41a94688615b551505e0e7c287e1c444f53a3fDavid Greene assert(static_cast<unsigned>(Info.Offset + Info.Size) <= Info.StorageSize); 130672d2dab6058467036df73a5f668036a519043e5bChandler Carruth unsigned HighBits = Info.StorageSize - Info.Offset - Info.Size; 130772d2dab6058467036df73a5f668036a519043e5bChandler Carruth if (HighBits) 130872d2dab6058467036df73a5f668036a519043e5bChandler Carruth Val = Builder.CreateShl(Val, HighBits, "bf.shl"); 130972d2dab6058467036df73a5f668036a519043e5bChandler Carruth if (Info.Offset + HighBits) 131072d2dab6058467036df73a5f668036a519043e5bChandler Carruth Val = Builder.CreateAShr(Val, Info.Offset + HighBits, "bf.ashr"); 131172d2dab6058467036df73a5f668036a519043e5bChandler Carruth } else { 131272d2dab6058467036df73a5f668036a519043e5bChandler Carruth if (Info.Offset) 131372d2dab6058467036df73a5f668036a519043e5bChandler Carruth Val = Builder.CreateLShr(Val, Info.Offset, "bf.lshr"); 1314e77372ac818cf202571dcbf8ab656c8f47ba3423Eli Bendersky if (static_cast<unsigned>(Info.Offset) + Info.Size < Info.StorageSize) 131572d2dab6058467036df73a5f668036a519043e5bChandler Carruth Val = Builder.CreateAnd(Val, llvm::APInt::getLowBitsSet(Info.StorageSize, 131672d2dab6058467036df73a5f668036a519043e5bChandler Carruth Info.Size), 131772d2dab6058467036df73a5f668036a519043e5bChandler Carruth "bf.clear"); 1318ecdb41ebc30e781ccbd3d89674caebc4fd35f023Daniel Dunbar } 131972d2dab6058467036df73a5f668036a519043e5bChandler Carruth Val = Builder.CreateIntCast(Val, ResLTy, Info.IsSigned, "bf.cast"); 1320316bb1b9eb9dc3da60e930f50c9b7578411d4966Eli Friedman 132172d2dab6058467036df73a5f668036a519043e5bChandler Carruth return RValue::get(Val); 13223b8c22d93da1432b2d4cea779d14912645c93866Lauro Ramos Venancio} 13233b8c22d93da1432b2d4cea779d14912645c93866Lauro Ramos Venancio 13246fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman// If this is a reference to a subset of the elements of a vector, create an 13256fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman// appropriate shufflevector. 1326545d996ec5a3113f046944f11b27cc2d6cb055b4John McCallRValue CodeGenFunction::EmitLoadOfExtVectorElementLValue(LValue LV) { 1327e5a8aeb4ad762b9383f9e9544c619dc386951e18Eli Friedman llvm::LoadInst *Load = Builder.CreateLoad(LV.getExtVectorAddr(), 1328e5a8aeb4ad762b9383f9e9544c619dc386951e18Eli Friedman LV.isVolatileQualified()); 1329e5a8aeb4ad762b9383f9e9544c619dc386951e18Eli Friedman Load->setAlignment(LV.getAlignment().getQuantity()); 1330e5a8aeb4ad762b9383f9e9544c619dc386951e18Eli Friedman llvm::Value *Vec = Load; 1331db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 13328a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman const llvm::Constant *Elts = LV.getExtVectorElts(); 1333db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1334db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // If the result of the expression is a non-vector type, we must be extracting 1335db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // a single element. Just codegen as an extractelement. 1336545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall const VectorType *ExprVT = LV.getType()->getAs<VectorType>(); 1337cf60cd291e8b33274a9622b7ec1818c29e90e7d4Chris Lattner if (!ExprVT) { 13384f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman unsigned InIdx = getAccessedFieldNo(0, Elts); 1339ef8225444452a1486bd721f3285301fe84643b00Stephen Hines llvm::Value *Elt = llvm::ConstantInt::get(SizeTy, InIdx); 1340578faa837b552403e2002b97fdfbfde14f2448e5Benjamin Kramer return RValue::get(Builder.CreateExtractElement(Vec, Elt)); 134134cdc86af5b0a54084a512a1b2643365b8f5bdd2Chris Lattner } 13426fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman 13436fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Always use shuffle vector to try to retain the original program structure 1344cf60cd291e8b33274a9622b7ec1818c29e90e7d4Chris Lattner unsigned NumResultElts = ExprVT->getNumElements(); 1345db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 13465f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<llvm::Constant*, 4> Mask; 13472ce8842641cc312628c4be836d34eb250e7c3f78Chris Lattner for (unsigned i = 0; i != NumResultElts; ++i) 13482ce8842641cc312628c4be836d34eb250e7c3f78Chris Lattner Mask.push_back(Builder.getInt32(getAccessedFieldNo(i, Elts))); 1349db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1350fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner llvm::Value *MaskV = llvm::ConstantVector::get(Mask); 1351fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner Vec = Builder.CreateShuffleVector(Vec, llvm::UndefValue::get(Vec->getType()), 1352578faa837b552403e2002b97fdfbfde14f2448e5Benjamin Kramer MaskV); 13536fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman return RValue::get(Vec); 13545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 13555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 13566bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines/// @brief Load of global gamed gegisters are always calls to intrinsics. 13576bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen HinesRValue CodeGenFunction::EmitLoadOfGlobalRegLValue(LValue LV) { 1358ef8225444452a1486bd721f3285301fe84643b00Stephen Hines assert((LV.getType()->isIntegerType() || LV.getType()->isPointerType()) && 1359ef8225444452a1486bd721f3285301fe84643b00Stephen Hines "Bad type for register variable"); 13606bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines llvm::MDNode *RegName = dyn_cast<llvm::MDNode>(LV.getGlobalReg()); 13616bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines assert(RegName && "Register LValue is not metadata"); 1362ef8225444452a1486bd721f3285301fe84643b00Stephen Hines 1363ef8225444452a1486bd721f3285301fe84643b00Stephen Hines // We accept integer and pointer types only 1364ef8225444452a1486bd721f3285301fe84643b00Stephen Hines llvm::Type *OrigTy = CGM.getTypes().ConvertType(LV.getType()); 1365ef8225444452a1486bd721f3285301fe84643b00Stephen Hines llvm::Type *Ty = OrigTy; 1366ef8225444452a1486bd721f3285301fe84643b00Stephen Hines if (OrigTy->isPointerTy()) 1367ef8225444452a1486bd721f3285301fe84643b00Stephen Hines Ty = CGM.getTypes().getDataLayout().getIntPtrType(OrigTy); 1368ef8225444452a1486bd721f3285301fe84643b00Stephen Hines llvm::Type *Types[] = { Ty }; 1369ef8225444452a1486bd721f3285301fe84643b00Stephen Hines 13706bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::read_register, Types); 1371ef8225444452a1486bd721f3285301fe84643b00Stephen Hines llvm::Value *Call = Builder.CreateCall(F, RegName); 1372ef8225444452a1486bd721f3285301fe84643b00Stephen Hines if (OrigTy->isPointerTy()) 1373ef8225444452a1486bd721f3285301fe84643b00Stephen Hines Call = Builder.CreateIntToPtr(Call, OrigTy); 13746bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return RValue::get(Call); 13756bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines} 137634cdc86af5b0a54084a512a1b2643365b8f5bdd2Chris Lattner 13775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 13785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// EmitStoreThroughLValue - Store the specified rvalue into the specified 13795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// lvalue, where both are guaranteed to the have the same type, and that type 13805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// is 'Ty'. 13815d4a7559df106959dd721744c8971547f0f09097Nick Lewyckyvoid CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst, 13825d4a7559df106959dd721744c8971547f0f09097Nick Lewycky bool isInit) { 1383017d6aa8e67da23b6333f669aff1e875c05fd88fChris Lattner if (!Dst.isSimple()) { 1384017d6aa8e67da23b6333f669aff1e875c05fd88fChris Lattner if (Dst.isVectorElt()) { 1385017d6aa8e67da23b6333f669aff1e875c05fd88fChris Lattner // Read/modify/write the vector, inserting the new element. 1386e5a8aeb4ad762b9383f9e9544c619dc386951e18Eli Friedman llvm::LoadInst *Load = Builder.CreateLoad(Dst.getVectorAddr(), 1387e5a8aeb4ad762b9383f9e9544c619dc386951e18Eli Friedman Dst.isVolatileQualified()); 1388e5a8aeb4ad762b9383f9e9544c619dc386951e18Eli Friedman Load->setAlignment(Dst.getAlignment().getQuantity()); 1389e5a8aeb4ad762b9383f9e9544c619dc386951e18Eli Friedman llvm::Value *Vec = Load; 13909b65551d0b387a7597fb39356a4d8ef10046445eChris Lattner Vec = Builder.CreateInsertElement(Vec, Src.getScalarVal(), 1391017d6aa8e67da23b6333f669aff1e875c05fd88fChris Lattner Dst.getVectorIdx(), "vecins"); 1392e5a8aeb4ad762b9383f9e9544c619dc386951e18Eli Friedman llvm::StoreInst *Store = Builder.CreateStore(Vec, Dst.getVectorAddr(), 1393e5a8aeb4ad762b9383f9e9544c619dc386951e18Eli Friedman Dst.isVolatileQualified()); 1394e5a8aeb4ad762b9383f9e9544c619dc386951e18Eli Friedman Store->setAlignment(Dst.getAlignment().getQuantity()); 1395017d6aa8e67da23b6333f669aff1e875c05fd88fChris Lattner return; 1396017d6aa8e67da23b6333f669aff1e875c05fd88fChris Lattner } 1397db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1398213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman // If this is an update of extended vector elements, insert them as 1399213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman // appropriate. 1400213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman if (Dst.isExtVectorElt()) 1401545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall return EmitStoreThroughExtVectorComponentLValue(Src, Dst); 1402a0c5d0eacede0f67ce46707263ddf4d8de0df706Lauro Ramos Venancio 14036bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (Dst.isGlobalReg()) 14046bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return EmitStoreThroughGlobalRegLValue(Src, Dst); 14056bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines 1406db45806b991013280a03057025c9538de64d5dfbJohn McCall assert(Dst.isBitField() && "Unknown LValue type"); 1407db45806b991013280a03057025c9538de64d5dfbJohn McCall return EmitStoreThroughBitfieldLValue(Src, Dst); 1408017d6aa8e67da23b6333f669aff1e875c05fd88fChris Lattner } 1409db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1410f85e193739c953358c865005855253af4f68a497John McCall // There's special magic for assigning into an ARC-qualified l-value. 1411f85e193739c953358c865005855253af4f68a497John McCall if (Qualifiers::ObjCLifetime Lifetime = Dst.getQuals().getObjCLifetime()) { 1412f85e193739c953358c865005855253af4f68a497John McCall switch (Lifetime) { 1413f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_None: 1414f85e193739c953358c865005855253af4f68a497John McCall llvm_unreachable("present but none"); 1415f85e193739c953358c865005855253af4f68a497John McCall 1416f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_ExplicitNone: 1417f85e193739c953358c865005855253af4f68a497John McCall // nothing special 1418f85e193739c953358c865005855253af4f68a497John McCall break; 1419f85e193739c953358c865005855253af4f68a497John McCall 1420f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_Strong: 1421545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall EmitARCStoreStrong(Dst, Src.getScalarVal(), /*ignore*/ true); 1422f85e193739c953358c865005855253af4f68a497John McCall return; 1423f85e193739c953358c865005855253af4f68a497John McCall 1424f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_Weak: 1425f85e193739c953358c865005855253af4f68a497John McCall EmitARCStoreWeak(Dst.getAddress(), Src.getScalarVal(), /*ignore*/ true); 1426f85e193739c953358c865005855253af4f68a497John McCall return; 1427f85e193739c953358c865005855253af4f68a497John McCall 1428f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_Autoreleasing: 1429545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall Src = RValue::get(EmitObjCExtendObjectLifetime(Dst.getType(), 1430545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall Src.getScalarVal())); 1431f85e193739c953358c865005855253af4f68a497John McCall // fall into the normal path 1432f85e193739c953358c865005855253af4f68a497John McCall break; 1433f85e193739c953358c865005855253af4f68a497John McCall } 1434f85e193739c953358c865005855253af4f68a497John McCall } 1435f85e193739c953358c865005855253af4f68a497John McCall 14364f676edd08bf1f1281b162107424141afe143055Fariborz Jahanian if (Dst.isObjCWeak() && !Dst.isNonGC()) { 1437db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // load of a __weak object. 1438dbd32c20c529430fe1d22d87317f039849b8b0bbFariborz Jahanian llvm::Value *LvalueDst = Dst.getAddress(); 1439dbd32c20c529430fe1d22d87317f039849b8b0bbFariborz Jahanian llvm::Value *src = Src.getScalarVal(); 1440f33651c2d79d47d8d05908185613fe33a3e18d89Mike Stump CGM.getObjCRuntime().EmitObjCWeakAssign(*this, src, LvalueDst); 1441dbd32c20c529430fe1d22d87317f039849b8b0bbFariborz Jahanian return; 1442dbd32c20c529430fe1d22d87317f039849b8b0bbFariborz Jahanian } 1443db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 14444f676edd08bf1f1281b162107424141afe143055Fariborz Jahanian if (Dst.isObjCStrong() && !Dst.isNonGC()) { 1445db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // load of a __strong object. 1446dbd32c20c529430fe1d22d87317f039849b8b0bbFariborz Jahanian llvm::Value *LvalueDst = Dst.getAddress(); 1447dbd32c20c529430fe1d22d87317f039849b8b0bbFariborz Jahanian llvm::Value *src = Src.getScalarVal(); 14486c7a1f364796ce1acb988714e9e42076d1ce332eFariborz Jahanian if (Dst.isObjCIvar()) { 14496c7a1f364796ce1acb988714e9e42076d1ce332eFariborz Jahanian assert(Dst.getBaseIvarExp() && "BaseIvarExp is NULL"); 14502acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *ResultType = ConvertType(getContext().LongTy); 14516c7a1f364796ce1acb988714e9e42076d1ce332eFariborz Jahanian llvm::Value *RHS = EmitScalarExpr(Dst.getBaseIvarExp()); 145276368e843cdf7db9c0d534384bf7a114fa260ffcFariborz Jahanian llvm::Value *dst = RHS; 14536c7a1f364796ce1acb988714e9e42076d1ce332eFariborz Jahanian RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast"); 14541cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper llvm::Value *LHS = 14556c7a1f364796ce1acb988714e9e42076d1ce332eFariborz Jahanian Builder.CreatePtrToInt(LvalueDst, ResultType, "sub.ptr.lhs.cast"); 14566c7a1f364796ce1acb988714e9e42076d1ce332eFariborz Jahanian llvm::Value *BytesBetween = Builder.CreateSub(LHS, RHS, "ivar.offset"); 145776368e843cdf7db9c0d534384bf7a114fa260ffcFariborz Jahanian CGM.getObjCRuntime().EmitObjCIvarAssign(*this, src, dst, 14586c7a1f364796ce1acb988714e9e42076d1ce332eFariborz Jahanian BytesBetween); 1459021a7a63984f0f912dc9e9dae2a1b3e1509a40ceFariborz Jahanian } else if (Dst.isGlobalObjCRef()) { 1460021a7a63984f0f912dc9e9dae2a1b3e1509a40ceFariborz Jahanian CGM.getObjCRuntime().EmitObjCGlobalAssign(*this, src, LvalueDst, 1461021a7a63984f0f912dc9e9dae2a1b3e1509a40ceFariborz Jahanian Dst.isThreadLocalRef()); 1462021a7a63984f0f912dc9e9dae2a1b3e1509a40ceFariborz Jahanian } 1463bf63b87ecf1e62ab8871a81325978377c84e1835Fariborz Jahanian else 1464bf63b87ecf1e62ab8871a81325978377c84e1835Fariborz Jahanian CGM.getObjCRuntime().EmitObjCStrongCastAssign(*this, src, LvalueDst); 1465dbd32c20c529430fe1d22d87317f039849b8b0bbFariborz Jahanian return; 1466dbd32c20c529430fe1d22d87317f039849b8b0bbFariborz Jahanian } 1467db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1468883f6a7cc7dccb1d675e27121a82614d63492a8dChris Lattner assert(Src.isScalar() && "Can't emit an agg store with this method"); 14697a7ee3033e44b45630981355460ef89efa0bdcc4David Chisnall EmitStoreOfScalar(Src.getScalarVal(), Dst, isInit); 14705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 14715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1472a0c5d0eacede0f67ce46707263ddf4d8de0df706Lauro Ramos Venanciovoid CodeGenFunction::EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, 1473ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar llvm::Value **Result) { 1474efbf487da83883c2da81181cac6f040928aa4289Daniel Dunbar const CGBitFieldInfo &Info = Dst.getBitFieldInfo(); 14752acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *ResLTy = ConvertTypeForMem(Dst.getType()); 147672d2dab6058467036df73a5f668036a519043e5bChandler Carruth llvm::Value *Ptr = Dst.getBitFieldAddr(); 1477a0c5d0eacede0f67ce46707263ddf4d8de0df706Lauro Ramos Venancio 14782677261656b2f3325218d38bdd9d102ad732da92Daniel Dunbar // Get the source value, truncated to the width of the bit-field. 1479ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar llvm::Value *SrcVal = Src.getScalarVal(); 14804803535dfef2626d2aec18ef92450b5008945352Anders Carlsson 148172d2dab6058467036df73a5f668036a519043e5bChandler Carruth // Cast the source to the storage type and shift it into place. 148272d2dab6058467036df73a5f668036a519043e5bChandler Carruth SrcVal = Builder.CreateIntCast(SrcVal, 148372d2dab6058467036df73a5f668036a519043e5bChandler Carruth Ptr->getType()->getPointerElementType(), 148472d2dab6058467036df73a5f668036a519043e5bChandler Carruth /*IsSigned=*/false); 148572d2dab6058467036df73a5f668036a519043e5bChandler Carruth llvm::Value *MaskedVal = SrcVal; 148672d2dab6058467036df73a5f668036a519043e5bChandler Carruth 148772d2dab6058467036df73a5f668036a519043e5bChandler Carruth // See if there are other bits in the bitfield's storage we'll need to load 148872d2dab6058467036df73a5f668036a519043e5bChandler Carruth // and mask together with source before storing. 148972d2dab6058467036df73a5f668036a519043e5bChandler Carruth if (Info.StorageSize != Info.Size) { 149072d2dab6058467036df73a5f668036a519043e5bChandler Carruth assert(Info.StorageSize > Info.Size && "Invalid bitfield size."); 149172d2dab6058467036df73a5f668036a519043e5bChandler Carruth llvm::Value *Val = Builder.CreateLoad(Ptr, Dst.isVolatileQualified(), 149272d2dab6058467036df73a5f668036a519043e5bChandler Carruth "bf.load"); 149372d2dab6058467036df73a5f668036a519043e5bChandler Carruth cast<llvm::LoadInst>(Val)->setAlignment(Info.StorageAlignment); 149472d2dab6058467036df73a5f668036a519043e5bChandler Carruth 149572d2dab6058467036df73a5f668036a519043e5bChandler Carruth // Mask the source value as needed. 149672d2dab6058467036df73a5f668036a519043e5bChandler Carruth if (!hasBooleanRepresentation(Dst.getType())) 149772d2dab6058467036df73a5f668036a519043e5bChandler Carruth SrcVal = Builder.CreateAnd(SrcVal, 149872d2dab6058467036df73a5f668036a519043e5bChandler Carruth llvm::APInt::getLowBitsSet(Info.StorageSize, 149972d2dab6058467036df73a5f668036a519043e5bChandler Carruth Info.Size), 150072d2dab6058467036df73a5f668036a519043e5bChandler Carruth "bf.value"); 150172d2dab6058467036df73a5f668036a519043e5bChandler Carruth MaskedVal = SrcVal; 150272d2dab6058467036df73a5f668036a519043e5bChandler Carruth if (Info.Offset) 150372d2dab6058467036df73a5f668036a519043e5bChandler Carruth SrcVal = Builder.CreateShl(SrcVal, Info.Offset, "bf.shl"); 150472d2dab6058467036df73a5f668036a519043e5bChandler Carruth 150572d2dab6058467036df73a5f668036a519043e5bChandler Carruth // Mask out the original value. 150672d2dab6058467036df73a5f668036a519043e5bChandler Carruth Val = Builder.CreateAnd(Val, 150772d2dab6058467036df73a5f668036a519043e5bChandler Carruth ~llvm::APInt::getBitsSet(Info.StorageSize, 150872d2dab6058467036df73a5f668036a519043e5bChandler Carruth Info.Offset, 150972d2dab6058467036df73a5f668036a519043e5bChandler Carruth Info.Offset + Info.Size), 151072d2dab6058467036df73a5f668036a519043e5bChandler Carruth "bf.clear"); 1511ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar 151272d2dab6058467036df73a5f668036a519043e5bChandler Carruth // Or together the unchanged values and the source value. 151372d2dab6058467036df73a5f668036a519043e5bChandler Carruth SrcVal = Builder.CreateOr(Val, SrcVal, "bf.set"); 151472d2dab6058467036df73a5f668036a519043e5bChandler Carruth } else { 151572d2dab6058467036df73a5f668036a519043e5bChandler Carruth assert(Info.Offset == 0); 1516ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar } 1517ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar 151872d2dab6058467036df73a5f668036a519043e5bChandler Carruth // Write the new value back out. 151972d2dab6058467036df73a5f668036a519043e5bChandler Carruth llvm::StoreInst *Store = Builder.CreateStore(SrcVal, Ptr, 152072d2dab6058467036df73a5f668036a519043e5bChandler Carruth Dst.isVolatileQualified()); 152172d2dab6058467036df73a5f668036a519043e5bChandler Carruth Store->setAlignment(Info.StorageAlignment); 15222677261656b2f3325218d38bdd9d102ad732da92Daniel Dunbar 152372d2dab6058467036df73a5f668036a519043e5bChandler Carruth // Return the new value of the bit-field, if requested. 152472d2dab6058467036df73a5f668036a519043e5bChandler Carruth if (Result) { 152572d2dab6058467036df73a5f668036a519043e5bChandler Carruth llvm::Value *ResultVal = MaskedVal; 152672d2dab6058467036df73a5f668036a519043e5bChandler Carruth 152772d2dab6058467036df73a5f668036a519043e5bChandler Carruth // Sign extend the value if needed. 152872d2dab6058467036df73a5f668036a519043e5bChandler Carruth if (Info.IsSigned) { 152972d2dab6058467036df73a5f668036a519043e5bChandler Carruth assert(Info.Size <= Info.StorageSize); 153072d2dab6058467036df73a5f668036a519043e5bChandler Carruth unsigned HighBits = Info.StorageSize - Info.Size; 153172d2dab6058467036df73a5f668036a519043e5bChandler Carruth if (HighBits) { 153272d2dab6058467036df73a5f668036a519043e5bChandler Carruth ResultVal = Builder.CreateShl(ResultVal, HighBits, "bf.result.shl"); 153372d2dab6058467036df73a5f668036a519043e5bChandler Carruth ResultVal = Builder.CreateAShr(ResultVal, HighBits, "bf.result.ashr"); 153472d2dab6058467036df73a5f668036a519043e5bChandler Carruth } 15352677261656b2f3325218d38bdd9d102ad732da92Daniel Dunbar } 15362677261656b2f3325218d38bdd9d102ad732da92Daniel Dunbar 153772d2dab6058467036df73a5f668036a519043e5bChandler Carruth ResultVal = Builder.CreateIntCast(ResultVal, ResLTy, Info.IsSigned, 153872d2dab6058467036df73a5f668036a519043e5bChandler Carruth "bf.result.cast"); 1539e538d48957b10bfaac46bc6138b78cfcc28ee89eEli Friedman *Result = EmitFromMemory(ResultVal, Dst.getType()); 154010e3dedb6f6bf999e23700f876f7e19e650ef642Daniel Dunbar } 1541a0c5d0eacede0f67ce46707263ddf4d8de0df706Lauro Ramos Venancio} 1542a0c5d0eacede0f67ce46707263ddf4d8de0df706Lauro Ramos Venancio 1543213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begemanvoid CodeGenFunction::EmitStoreThroughExtVectorComponentLValue(RValue Src, 1544545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall LValue Dst) { 1545017d6aa8e67da23b6333f669aff1e875c05fd88fChris Lattner // This access turns into a read/modify/write of the vector. Load the input 1546017d6aa8e67da23b6333f669aff1e875c05fd88fChris Lattner // value now. 1547e5a8aeb4ad762b9383f9e9544c619dc386951e18Eli Friedman llvm::LoadInst *Load = Builder.CreateLoad(Dst.getExtVectorAddr(), 1548e5a8aeb4ad762b9383f9e9544c619dc386951e18Eli Friedman Dst.isVolatileQualified()); 1549e5a8aeb4ad762b9383f9e9544c619dc386951e18Eli Friedman Load->setAlignment(Dst.getAlignment().getQuantity()); 1550e5a8aeb4ad762b9383f9e9544c619dc386951e18Eli Friedman llvm::Value *Vec = Load; 15518a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman const llvm::Constant *Elts = Dst.getExtVectorElts(); 1552db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 15539b65551d0b387a7597fb39356a4d8ef10046445eChris Lattner llvm::Value *SrcVal = Src.getScalarVal(); 1554db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1555545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall if (const VectorType *VTy = Dst.getType()->getAs<VectorType>()) { 15567e6b51b673997d7046f06caf09134dbd0a434a5eChris Lattner unsigned NumSrcElts = VTy->getNumElements(); 15576fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman unsigned NumDstElts = 15586fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman cast<llvm::VectorType>(Vec->getType())->getNumElements(); 15596fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman if (NumDstElts == NumSrcElts) { 1560db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Use shuffle vector is the src and destination are the same number of 1561db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // elements and restore the vector mask since it is on the side it will be 1562db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // stored. 15635f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<llvm::Constant*, 4> Mask(NumDstElts); 15642ce8842641cc312628c4be836d34eb250e7c3f78Chris Lattner for (unsigned i = 0; i != NumSrcElts; ++i) 15652ce8842641cc312628c4be836d34eb250e7c3f78Chris Lattner Mask[getAccessedFieldNo(i, Elts)] = Builder.getInt32(i); 1566db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1567fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner llvm::Value *MaskV = llvm::ConstantVector::get(Mask); 15686fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman Vec = Builder.CreateShuffleVector(SrcVal, 156903e205031b08669f05c41eed5b896fc94c4a12bbOwen Anderson llvm::UndefValue::get(Vec->getType()), 1570578faa837b552403e2002b97fdfbfde14f2448e5Benjamin Kramer MaskV); 1571b3589f44c5d295cd41de2c83f3475116835eeebdMike Stump } else if (NumDstElts > NumSrcElts) { 15726fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Extended the source vector to the same length and then shuffle it 15736fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // into the destination. 15746fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // FIXME: since we're shuffling with undef, can we just use the indices 15756fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // into that? This could be simpler. 15765f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<llvm::Constant*, 4> ExtMask; 157714c598268ff7534d3753ae84eba9b8a81bf0bf8fBenjamin Kramer for (unsigned i = 0; i != NumSrcElts; ++i) 15782ce8842641cc312628c4be836d34eb250e7c3f78Chris Lattner ExtMask.push_back(Builder.getInt32(i)); 157914c598268ff7534d3753ae84eba9b8a81bf0bf8fBenjamin Kramer ExtMask.resize(NumDstElts, llvm::UndefValue::get(Int32Ty)); 1580fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner llvm::Value *ExtMaskV = llvm::ConstantVector::get(ExtMask); 1581db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump llvm::Value *ExtSrcVal = 1582bb7677391a9db7d062a7cc637db8960d89ec7c93Daniel Dunbar Builder.CreateShuffleVector(SrcVal, 158303e205031b08669f05c41eed5b896fc94c4a12bbOwen Anderson llvm::UndefValue::get(SrcVal->getType()), 1584578faa837b552403e2002b97fdfbfde14f2448e5Benjamin Kramer ExtMaskV); 15856fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // build identity 15865f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<llvm::Constant*, 4> Mask; 1587eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner for (unsigned i = 0; i != NumDstElts; ++i) 15882ce8842641cc312628c4be836d34eb250e7c3f78Chris Lattner Mask.push_back(Builder.getInt32(i)); 1589eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner 159013ba7190c087d592104ca4f6b730a62647ee277eBill Wendling // When the vector size is odd and .odd or .hi is used, the last element 159113ba7190c087d592104ca4f6b730a62647ee277eBill Wendling // of the Elts constant array will be one past the size of the vector. 159213ba7190c087d592104ca4f6b730a62647ee277eBill Wendling // Ignore the last element here, if it is greater than the mask size. 159313ba7190c087d592104ca4f6b730a62647ee277eBill Wendling if (getAccessedFieldNo(NumSrcElts - 1, Elts) == Mask.size()) 159413ba7190c087d592104ca4f6b730a62647ee277eBill Wendling NumSrcElts--; 159513ba7190c087d592104ca4f6b730a62647ee277eBill Wendling 15966fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // modify when what gets shuffled in 15972ce8842641cc312628c4be836d34eb250e7c3f78Chris Lattner for (unsigned i = 0; i != NumSrcElts; ++i) 15982ce8842641cc312628c4be836d34eb250e7c3f78Chris Lattner Mask[getAccessedFieldNo(i, Elts)] = Builder.getInt32(i+NumDstElts); 1599fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner llvm::Value *MaskV = llvm::ConstantVector::get(Mask); 1600578faa837b552403e2002b97fdfbfde14f2448e5Benjamin Kramer Vec = Builder.CreateShuffleVector(Vec, ExtSrcVal, MaskV); 1601b3589f44c5d295cd41de2c83f3475116835eeebdMike Stump } else { 16026fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // We should never shorten the vector 1603b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("unexpected shorten vector length"); 16047e6b51b673997d7046f06caf09134dbd0a434a5eChris Lattner } 16057e6b51b673997d7046f06caf09134dbd0a434a5eChris Lattner } else { 16067e6b51b673997d7046f06caf09134dbd0a434a5eChris Lattner // If the Src is a scalar (not a vector) it must be updating one element. 16074f8d123e3e2c260de3377208106ddba87cee28b4Dan Gohman unsigned InIdx = getAccessedFieldNo(0, Elts); 1608ef8225444452a1486bd721f3285301fe84643b00Stephen Hines llvm::Value *Elt = llvm::ConstantInt::get(SizeTy, InIdx); 1609578faa837b552403e2002b97fdfbfde14f2448e5Benjamin Kramer Vec = Builder.CreateInsertElement(Vec, SrcVal, Elt); 1610017d6aa8e67da23b6333f669aff1e875c05fd88fChris Lattner } 1611db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1612e5a8aeb4ad762b9383f9e9544c619dc386951e18Eli Friedman llvm::StoreInst *Store = Builder.CreateStore(Vec, Dst.getExtVectorAddr(), 1613e5a8aeb4ad762b9383f9e9544c619dc386951e18Eli Friedman Dst.isVolatileQualified()); 1614e5a8aeb4ad762b9383f9e9544c619dc386951e18Eli Friedman Store->setAlignment(Dst.getAlignment().getQuantity()); 1615017d6aa8e67da23b6333f669aff1e875c05fd88fChris Lattner} 1616017d6aa8e67da23b6333f669aff1e875c05fd88fChris Lattner 16176bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines/// @brief Store of global named registers are always calls to intrinsics. 16186bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hinesvoid CodeGenFunction::EmitStoreThroughGlobalRegLValue(RValue Src, LValue Dst) { 1619ef8225444452a1486bd721f3285301fe84643b00Stephen Hines assert((Dst.getType()->isIntegerType() || Dst.getType()->isPointerType()) && 1620ef8225444452a1486bd721f3285301fe84643b00Stephen Hines "Bad type for register variable"); 16216bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines llvm::MDNode *RegName = dyn_cast<llvm::MDNode>(Dst.getGlobalReg()); 16226bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines assert(RegName && "Register LValue is not metadata"); 1623ef8225444452a1486bd721f3285301fe84643b00Stephen Hines 1624ef8225444452a1486bd721f3285301fe84643b00Stephen Hines // We accept integer and pointer types only 1625ef8225444452a1486bd721f3285301fe84643b00Stephen Hines llvm::Type *OrigTy = CGM.getTypes().ConvertType(Dst.getType()); 1626ef8225444452a1486bd721f3285301fe84643b00Stephen Hines llvm::Type *Ty = OrigTy; 1627ef8225444452a1486bd721f3285301fe84643b00Stephen Hines if (OrigTy->isPointerTy()) 1628ef8225444452a1486bd721f3285301fe84643b00Stephen Hines Ty = CGM.getTypes().getDataLayout().getIntPtrType(OrigTy); 1629ef8225444452a1486bd721f3285301fe84643b00Stephen Hines llvm::Type *Types[] = { Ty }; 1630ef8225444452a1486bd721f3285301fe84643b00Stephen Hines 16316bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::write_register, Types); 16326bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines llvm::Value *Value = Src.getScalarVal(); 1633ef8225444452a1486bd721f3285301fe84643b00Stephen Hines if (OrigTy->isPointerTy()) 1634ef8225444452a1486bd721f3285301fe84643b00Stephen Hines Value = Builder.CreatePtrToInt(Value, Ty); 16356bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines Builder.CreateCall2(F, RegName, Value); 16366bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines} 16376bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines 16386bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines// setObjCGCLValueClass - sets class of the lvalue for the purpose of 1639b123ea395ee607de85161f84c6e78595946304a5Fariborz Jahanian// generating write-barries API. It is currently a global, ivar, 1640b123ea395ee607de85161f84c6e78595946304a5Fariborz Jahanian// or neither. 1641eb99b0189710d996216df7d485f11939e9f1c842Chris Lattnerstatic void setObjCGCLValueClass(const ASTContext &Ctx, const Expr *E, 1642ccae76c8214c5ff469e0291371127084d252ac7aFariborz Jahanian LValue &LV, 1643ccae76c8214c5ff469e0291371127084d252ac7aFariborz Jahanian bool IsMemberAccess=false) { 16444e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (Ctx.getLangOpts().getGC() == LangOptions::NonGC) 1645b123ea395ee607de85161f84c6e78595946304a5Fariborz Jahanian return; 16461cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 1647dbf3cfd39dd5234f90235e263ba2ff4cc61258bdFariborz Jahanian if (isa<ObjCIvarRefExpr>(E)) { 1648ccae76c8214c5ff469e0291371127084d252ac7aFariborz Jahanian QualType ExpTy = E->getType(); 1649ccae76c8214c5ff469e0291371127084d252ac7aFariborz Jahanian if (IsMemberAccess && ExpTy->isPointerType()) { 1650ccae76c8214c5ff469e0291371127084d252ac7aFariborz Jahanian // If ivar is a structure pointer, assigning to field of 16511cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper // this struct follows gcc's behavior and makes it a non-ivar 1652ccae76c8214c5ff469e0291371127084d252ac7aFariborz Jahanian // writer-barrier conservatively. 1653ccae76c8214c5ff469e0291371127084d252ac7aFariborz Jahanian ExpTy = ExpTy->getAs<PointerType>()->getPointeeType(); 1654ccae76c8214c5ff469e0291371127084d252ac7aFariborz Jahanian if (ExpTy->isRecordType()) { 1655ccae76c8214c5ff469e0291371127084d252ac7aFariborz Jahanian LV.setObjCIvar(false); 1656ccae76c8214c5ff469e0291371127084d252ac7aFariborz Jahanian return; 1657ccae76c8214c5ff469e0291371127084d252ac7aFariborz Jahanian } 1658ccae76c8214c5ff469e0291371127084d252ac7aFariborz Jahanian } 16593491b3d38b9569ab19f417ed2c3c8a86885345a2Daniel Dunbar LV.setObjCIvar(true); 16606bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines auto *Exp = cast<ObjCIvarRefExpr>(const_cast<Expr *>(E)); 16616c7a1f364796ce1acb988714e9e42076d1ce332eFariborz Jahanian LV.setBaseIvarExp(Exp->getBase()); 16623491b3d38b9569ab19f417ed2c3c8a86885345a2Daniel Dunbar LV.setObjCArray(E->getType()->isArrayType()); 1663dbf3cfd39dd5234f90235e263ba2ff4cc61258bdFariborz Jahanian return; 1664dbf3cfd39dd5234f90235e263ba2ff4cc61258bdFariborz Jahanian } 16651cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 16666bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *Exp = dyn_cast<DeclRefExpr>(E)) { 16676bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *VD = dyn_cast<VarDecl>(Exp->getDecl())) { 1668b6bbcc9995186799a60ce17d0c1acff31601653aJohn McCall if (VD->hasGlobalStorage()) { 16693491b3d38b9569ab19f417ed2c3c8a86885345a2Daniel Dunbar LV.setGlobalObjCRef(true); 167038afbc7361d861968232defaeaf8e302af75b5eeRichard Smith LV.setThreadLocalRef(VD->getTLSKind() != VarDecl::TLS_None); 1671021a7a63984f0f912dc9e9dae2a1b3e1509a40ceFariborz Jahanian } 1672b123ea395ee607de85161f84c6e78595946304a5Fariborz Jahanian } 16733491b3d38b9569ab19f417ed2c3c8a86885345a2Daniel Dunbar LV.setObjCArray(E->getType()->isArrayType()); 1674eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner return; 1675b123ea395ee607de85161f84c6e78595946304a5Fariborz Jahanian } 16761cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 16776bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *Exp = dyn_cast<UnaryOperator>(E)) { 1678ccae76c8214c5ff469e0291371127084d252ac7aFariborz Jahanian setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess); 1679eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner return; 1680eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner } 16811cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 16826bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *Exp = dyn_cast<ParenExpr>(E)) { 1683ccae76c8214c5ff469e0291371127084d252ac7aFariborz Jahanian setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess); 168475b08f169fa47285ce5381091367793ed611195cFariborz Jahanian if (LV.isObjCIvar()) { 168575b08f169fa47285ce5381091367793ed611195cFariborz Jahanian // If cast is to a structure pointer, follow gcc's behavior and make it 168675b08f169fa47285ce5381091367793ed611195cFariborz Jahanian // a non-ivar write-barrier. 168775b08f169fa47285ce5381091367793ed611195cFariborz Jahanian QualType ExpTy = E->getType(); 168875b08f169fa47285ce5381091367793ed611195cFariborz Jahanian if (ExpTy->isPointerType()) 168975b08f169fa47285ce5381091367793ed611195cFariborz Jahanian ExpTy = ExpTy->getAs<PointerType>()->getPointeeType(); 169075b08f169fa47285ce5381091367793ed611195cFariborz Jahanian if (ExpTy->isRecordType()) 16911cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper LV.setObjCIvar(false); 1692eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner } 1693eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner return; 169475b08f169fa47285ce5381091367793ed611195cFariborz Jahanian } 1695f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne 16966bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *Exp = dyn_cast<GenericSelectionExpr>(E)) { 1697f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne setObjCGCLValueClass(Ctx, Exp->getResultExpr(), LV); 1698f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne return; 1699f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne } 1700f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne 17016bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *Exp = dyn_cast<ImplicitCastExpr>(E)) { 1702ccae76c8214c5ff469e0291371127084d252ac7aFariborz Jahanian setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess); 1703eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner return; 1704eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner } 17051cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 17066bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *Exp = dyn_cast<CStyleCastExpr>(E)) { 1707ccae76c8214c5ff469e0291371127084d252ac7aFariborz Jahanian setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess); 1708eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner return; 1709eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner } 1710f85e193739c953358c865005855253af4f68a497John McCall 17116bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *Exp = dyn_cast<ObjCBridgedCastExpr>(E)) { 1712ccae76c8214c5ff469e0291371127084d252ac7aFariborz Jahanian setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess); 1713f85e193739c953358c865005855253af4f68a497John McCall return; 1714f85e193739c953358c865005855253af4f68a497John McCall } 1715f85e193739c953358c865005855253af4f68a497John McCall 17166bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *Exp = dyn_cast<ArraySubscriptExpr>(E)) { 1717b123ea395ee607de85161f84c6e78595946304a5Fariborz Jahanian setObjCGCLValueClass(Ctx, Exp->getBase(), LV); 17181cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper if (LV.isObjCIvar() && !LV.isObjCArray()) 17191cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper // Using array syntax to assigning to what an ivar points to is not 17201c1afc4ed3ec30fc99e172220c8bb74a13b117b0Fariborz Jahanian // same as assigning to the ivar itself. {id *Names;} Names[i] = 0; 17211cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper LV.setObjCIvar(false); 1722fd02ed702e754f8dd0b4c979325ba99c2234f270Fariborz Jahanian else if (LV.isGlobalObjCRef() && !LV.isObjCArray()) 17231cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper // Using array syntax to assigning to what global points to is not 1724fd02ed702e754f8dd0b4c979325ba99c2234f270Fariborz Jahanian // same as assigning to the global itself. {id *G;} G[i] = 0; 17253491b3d38b9569ab19f417ed2c3c8a86885345a2Daniel Dunbar LV.setGlobalObjCRef(false); 1726eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner return; 17271c1afc4ed3ec30fc99e172220c8bb74a13b117b0Fariborz Jahanian } 1728ccae76c8214c5ff469e0291371127084d252ac7aFariborz Jahanian 17296bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *Exp = dyn_cast<MemberExpr>(E)) { 1730ccae76c8214c5ff469e0291371127084d252ac7aFariborz Jahanian setObjCGCLValueClass(Ctx, Exp->getBase(), LV, true); 17311c1afc4ed3ec30fc99e172220c8bb74a13b117b0Fariborz Jahanian // We don't know if member is an 'ivar', but this flag is looked at 17321c1afc4ed3ec30fc99e172220c8bb74a13b117b0Fariborz Jahanian // only in the context of LV.isObjCIvar(). 17333491b3d38b9569ab19f417ed2c3c8a86885345a2Daniel Dunbar LV.setObjCArray(E->getType()->isArrayType()); 1734eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner return; 1735b123ea395ee607de85161f84c6e78595946304a5Fariborz Jahanian } 1736b123ea395ee607de85161f84c6e78595946304a5Fariborz Jahanian} 1737b123ea395ee607de85161f84c6e78595946304a5Fariborz Jahanian 17383a2b657088de9413714a51bff153a59565adb3efChris Lattnerstatic llvm::Value * 1739a98742c32c159a8c76f842947c02a79c530a1d4bChandler CarruthEmitBitCastOfLValueToProperType(CodeGenFunction &CGF, 17403a2b657088de9413714a51bff153a59565adb3efChris Lattner llvm::Value *V, llvm::Type *IRType, 17415f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner StringRef Name = StringRef()) { 17423a2b657088de9413714a51bff153a59565adb3efChris Lattner unsigned AS = cast<llvm::PointerType>(V->getType())->getAddressSpace(); 1743a98742c32c159a8c76f842947c02a79c530a1d4bChandler Carruth return CGF.Builder.CreateBitCast(V, IRType->getPointerTo(AS), Name); 17443a2b657088de9413714a51bff153a59565adb3efChris Lattner} 17453a2b657088de9413714a51bff153a59565adb3efChris Lattner 1746ce53f7dbe7406a253c6b2d93ff2727079087d9ccAnders Carlssonstatic LValue EmitGlobalVarDeclLValue(CodeGenFunction &CGF, 1747ce53f7dbe7406a253c6b2d93ff2727079087d9ccAnders Carlsson const Expr *E, const VarDecl *VD) { 1748651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines QualType T = E->getType(); 1749651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 1750651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // If it's thread_local, emit a call to its wrapper function instead. 1751651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines if (VD->getTLSKind() == VarDecl::TLS_Dynamic) 1752651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines return CGF.CGM.getCXXABI().EmitThreadLocalVarDeclLValue(CGF, VD, T); 1753651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 1754ce53f7dbe7406a253c6b2d93ff2727079087d9ccAnders Carlsson llvm::Value *V = CGF.CGM.GetAddrOfGlobalVar(VD); 17552f77b3d57031ded0de2b7b977fb63b4660f82624Eli Friedman llvm::Type *RealVarTy = CGF.getTypes().ConvertTypeForMem(VD->getType()); 17562f77b3d57031ded0de2b7b977fb63b4660f82624Eli Friedman V = EmitBitCastOfLValueToProperType(CGF, V, RealVarTy); 17576da2c716017d5c8530ec99779524491ebc5dadb8Eli Friedman CharUnits Alignment = CGF.getContext().getDeclAlign(VD); 17582f77b3d57031ded0de2b7b977fb63b4660f82624Eli Friedman LValue LV; 17592f77b3d57031ded0de2b7b977fb63b4660f82624Eli Friedman if (VD->getType()->isReferenceType()) { 17602f77b3d57031ded0de2b7b977fb63b4660f82624Eli Friedman llvm::LoadInst *LI = CGF.Builder.CreateLoad(V); 17616da2c716017d5c8530ec99779524491ebc5dadb8Eli Friedman LI->setAlignment(Alignment.getQuantity()); 17622f77b3d57031ded0de2b7b977fb63b4660f82624Eli Friedman V = LI; 17632f77b3d57031ded0de2b7b977fb63b4660f82624Eli Friedman LV = CGF.MakeNaturalAlignAddrLValue(V, T); 17642f77b3d57031ded0de2b7b977fb63b4660f82624Eli Friedman } else { 1765651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines LV = CGF.MakeAddrLValue(V, T, Alignment); 17662f77b3d57031ded0de2b7b977fb63b4660f82624Eli Friedman } 1767ce53f7dbe7406a253c6b2d93ff2727079087d9ccAnders Carlsson setObjCGCLValueClass(CGF.getContext(), E, LV); 1768ce53f7dbe7406a253c6b2d93ff2727079087d9ccAnders Carlsson return LV; 1769ce53f7dbe7406a253c6b2d93ff2727079087d9ccAnders Carlsson} 1770ce53f7dbe7406a253c6b2d93ff2727079087d9ccAnders Carlsson 17719a14630714da7176c981e3c8d050f82bc42c2643Eli Friedmanstatic LValue EmitFunctionDeclLValue(CodeGenFunction &CGF, 177274339dfbfe3fa9c1839ce02e3427e4dc5478a3aeChris Lattner const Expr *E, const FunctionDecl *FD) { 1773d0db03a561671b8b466b07026cc8fbbb037bb639Chris Lattner llvm::Value *V = CGF.CGM.GetAddrOfFunction(FD); 17749a14630714da7176c981e3c8d050f82bc42c2643Eli Friedman if (!FD->hasPrototype()) { 17759a14630714da7176c981e3c8d050f82bc42c2643Eli Friedman if (const FunctionProtoType *Proto = 17769a14630714da7176c981e3c8d050f82bc42c2643Eli Friedman FD->getType()->getAs<FunctionProtoType>()) { 17779a14630714da7176c981e3c8d050f82bc42c2643Eli Friedman // Ugly case: for a K&R-style definition, the type of the definition 17789a14630714da7176c981e3c8d050f82bc42c2643Eli Friedman // isn't the same as the type of a use. Correct for this with a 17799a14630714da7176c981e3c8d050f82bc42c2643Eli Friedman // bitcast. 17809a14630714da7176c981e3c8d050f82bc42c2643Eli Friedman QualType NoProtoType = 1781651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines CGF.getContext().getFunctionNoProtoType(Proto->getReturnType()); 17829a14630714da7176c981e3c8d050f82bc42c2643Eli Friedman NoProtoType = CGF.getContext().getPointerType(NoProtoType); 1783578faa837b552403e2002b97fdfbfde14f2448e5Benjamin Kramer V = CGF.Builder.CreateBitCast(V, CGF.ConvertType(NoProtoType)); 17849a14630714da7176c981e3c8d050f82bc42c2643Eli Friedman } 17859a14630714da7176c981e3c8d050f82bc42c2643Eli Friedman } 17866da2c716017d5c8530ec99779524491ebc5dadb8Eli Friedman CharUnits Alignment = CGF.getContext().getDeclAlign(FD); 1787983e3d7dac99aed376939f1a4daadef98e09c3b9Daniel Dunbar return CGF.MakeAddrLValue(V, E->getType(), Alignment); 17889a14630714da7176c981e3c8d050f82bc42c2643Eli Friedman} 17899a14630714da7176c981e3c8d050f82bc42c2643Eli Friedman 1790524387ae3dfc0c4cf2b095f83f9e47aa549b7e55Ben Langmuirstatic LValue EmitCapturedFieldLValue(CodeGenFunction &CGF, const FieldDecl *FD, 1791524387ae3dfc0c4cf2b095f83f9e47aa549b7e55Ben Langmuir llvm::Value *ThisValue) { 1792524387ae3dfc0c4cf2b095f83f9e47aa549b7e55Ben Langmuir QualType TagType = CGF.getContext().getTagDeclType(FD->getParent()); 1793524387ae3dfc0c4cf2b095f83f9e47aa549b7e55Ben Langmuir LValue LV = CGF.MakeNaturalAlignAddrLValue(ThisValue, TagType); 1794524387ae3dfc0c4cf2b095f83f9e47aa549b7e55Ben Langmuir return CGF.EmitLValueForField(LV, FD); 1795524387ae3dfc0c4cf2b095f83f9e47aa549b7e55Ben Langmuir} 1796524387ae3dfc0c4cf2b095f83f9e47aa549b7e55Ben Langmuir 17976bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines/// Named Registers are named metadata pointing to the register name 17986bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines/// which will be read from/written to as an argument to the intrinsic 17996bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines/// @llvm.read/write_register. 18006bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines/// So far, only the name is being passed down, but other options such as 18016bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines/// register type, allocation type or even optimization options could be 18026bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines/// passed down via the metadata node. 18036bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hinesstatic LValue EmitGlobalNamedRegister(const VarDecl *VD, 18046bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines CodeGenModule &CGM, 18056bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines CharUnits Alignment) { 18066bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines SmallString<64> Name("llvm.named.register."); 18076bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines AsmLabelAttr *Asm = VD->getAttr<AsmLabelAttr>(); 18086bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines assert(Asm->getLabel().size() < 64-Name.size() && 18096bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines "Register name too big"); 18106bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines Name.append(Asm->getLabel()); 18116bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines llvm::NamedMDNode *M = 18126bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines CGM.getModule().getOrInsertNamedMetadata(Name); 18136bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (M->getNumOperands() == 0) { 18146bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines llvm::MDString *Str = llvm::MDString::get(CGM.getLLVMContext(), 18156bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines Asm->getLabel()); 18166bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines llvm::Value *Ops[] = { Str }; 18176bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines M->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops)); 18186bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines } 18196bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return LValue::MakeGlobalReg(M->getOperand(0), VD->getType(), Alignment); 18206bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines} 18216bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines 18225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerLValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) { 18231e74c4f0333b4730f44197d5e4615ea2b06599f4Anders Carlsson const NamedDecl *ND = E->getDecl(); 18246da2c716017d5c8530ec99779524491ebc5dadb8Eli Friedman CharUnits Alignment = getContext().getDeclAlign(ND); 18252f77b3d57031ded0de2b7b977fb63b4660f82624Eli Friedman QualType T = E->getType(); 1826db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 18276bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *VD = dyn_cast<VarDecl>(ND)) { 18286bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines // Global Named registers access via intrinsics only 18296bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (VD->getStorageClass() == SC_Register && 18306bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl()) 18316bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return EmitGlobalNamedRegister(VD, CGM, Alignment); 18326bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines 18336bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines // A DeclRefExpr for a reference initialized by a constant expression can 18346bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines // appear without being odr-used. Directly emit the constant initializer. 18355016a70c183a50845a0421802d161093dd0643f6Richard Smith const Expr *Init = VD->getAnyInitializer(VD); 18365016a70c183a50845a0421802d161093dd0643f6Richard Smith if (Init && !isa<ParmVarDecl>(VD) && VD->getType()->isReferenceType() && 18375016a70c183a50845a0421802d161093dd0643f6Richard Smith VD->isUsableInConstantExpressions(getContext()) && 18385016a70c183a50845a0421802d161093dd0643f6Richard Smith VD->checkInitIsICE()) { 18395016a70c183a50845a0421802d161093dd0643f6Richard Smith llvm::Constant *Val = 18405016a70c183a50845a0421802d161093dd0643f6Richard Smith CGM.EmitConstantValue(*VD->evaluateValue(), VD->getType(), this); 18415016a70c183a50845a0421802d161093dd0643f6Richard Smith assert(Val && "failed to emit reference constant expression"); 18425016a70c183a50845a0421802d161093dd0643f6Richard Smith // FIXME: Eventually we will want to emit vector element references. 18435016a70c183a50845a0421802d161093dd0643f6Richard Smith return MakeAddrLValue(Val, T, Alignment); 18445016a70c183a50845a0421802d161093dd0643f6Richard Smith } 18455016a70c183a50845a0421802d161093dd0643f6Richard Smith } 18465016a70c183a50845a0421802d161093dd0643f6Richard Smith 1847416de514f8a7a9c121e45ae450d0faef9e5a0ef9Eli Friedman // FIXME: We should be able to assert this for FunctionDecls as well! 1848416de514f8a7a9c121e45ae450d0faef9e5a0ef9Eli Friedman // FIXME: We should be able to assert this for all DeclRefExprs, not just 1849416de514f8a7a9c121e45ae450d0faef9e5a0ef9Eli Friedman // those with a valid source location. 1850416de514f8a7a9c121e45ae450d0faef9e5a0ef9Eli Friedman assert((ND->isUsed(false) || !isa<VarDecl>(ND) || 1851416de514f8a7a9c121e45ae450d0faef9e5a0ef9Eli Friedman !E->getLocation().isValid()) && 1852416de514f8a7a9c121e45ae450d0faef9e5a0ef9Eli Friedman "Should not use decl without marking it used!"); 1853416de514f8a7a9c121e45ae450d0faef9e5a0ef9Eli Friedman 18546a836706c40a31c716952b74785102c90fd6afa7Rafael Espindola if (ND->hasAttr<WeakRefAttr>()) { 18556bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines const auto *VD = cast<ValueDecl>(ND); 18566a836706c40a31c716952b74785102c90fd6afa7Rafael Espindola llvm::Constant *Aliasee = CGM.GetWeakRefReference(VD); 18575016a70c183a50845a0421802d161093dd0643f6Richard Smith return MakeAddrLValue(Aliasee, T, Alignment); 18586a836706c40a31c716952b74785102c90fd6afa7Rafael Espindola } 18596a836706c40a31c716952b74785102c90fd6afa7Rafael Espindola 18606bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *VD = dyn_cast<VarDecl>(ND)) { 18611e74c4f0333b4730f44197d5e4615ea2b06599f4Anders Carlsson // Check if this is a global variable. 1862651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines if (VD->hasLinkage() || VD->isStaticDataMember()) 1863ce53f7dbe7406a253c6b2d93ff2727079087d9ccAnders Carlsson return EmitGlobalVarDeclLValue(*this, E, VD); 1864a59869b277f9fb8d6e062cab97b6bafe7c199900Anders Carlsson 1865f4b88a45902af1802a1cb42ba48b1c474474f228John McCall bool isBlockVariable = VD->hasAttr<BlocksAttr>(); 1866f4b88a45902af1802a1cb42ba48b1c474474f228John McCall 1867f91cbd54c97fceaf84539e7234b27ad54bba735bNick Lewycky llvm::Value *V = LocalDeclMap.lookup(VD); 18681cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper if (!V && VD->isStaticLocal()) 186963326a53418b4853a83b360ce1dbdb10c5739fc7Fariborz Jahanian V = CGM.getStaticLocalDeclAddress(VD); 1870cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman 1871cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman // Use special handling for lambdas. 1872f4b88a45902af1802a1cb42ba48b1c474474f228John McCall if (!V) { 1873377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman if (FieldDecl *FD = LambdaCaptureFields.lookup(VD)) { 1874524387ae3dfc0c4cf2b095f83f9e47aa549b7e55Ben Langmuir return EmitCapturedFieldLValue(*this, FD, CXXABIThisValue); 1875524387ae3dfc0c4cf2b095f83f9e47aa549b7e55Ben Langmuir } else if (CapturedStmtInfo) { 1876524387ae3dfc0c4cf2b095f83f9e47aa549b7e55Ben Langmuir if (const FieldDecl *FD = CapturedStmtInfo->lookup(VD)) 1877524387ae3dfc0c4cf2b095f83f9e47aa549b7e55Ben Langmuir return EmitCapturedFieldLValue(*this, FD, 1878524387ae3dfc0c4cf2b095f83f9e47aa549b7e55Ben Langmuir CapturedStmtInfo->getContextValue()); 1879377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman } 1880cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman 1881f4b88a45902af1802a1cb42ba48b1c474474f228John McCall assert(isa<BlockDecl>(CurCodeDecl) && E->refersToEnclosingLocal()); 1882f4b88a45902af1802a1cb42ba48b1c474474f228John McCall return MakeAddrLValue(GetAddrOfBlockDecl(VD, isBlockVariable), 18835016a70c183a50845a0421802d161093dd0643f6Richard Smith T, Alignment); 1884f4b88a45902af1802a1cb42ba48b1c474474f228John McCall } 1885f4b88a45902af1802a1cb42ba48b1c474474f228John McCall 18860bc7049d636f63b4b0e9ee0a2edf37541f5e3beeAnders Carlsson assert(V && "DeclRefExpr not entered in LocalDeclMap?"); 18870953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 1888f4b88a45902af1802a1cb42ba48b1c474474f228John McCall if (isBlockVariable) 188952a80e19ad688091723a52ad53337767bb0ac684Fariborz Jahanian V = BuildBlockByrefAddress(V, VD); 18906d5eb76059c6251ffbb8f0cbac8d7fe9a3efabceDaniel Dunbar 18912f77b3d57031ded0de2b7b977fb63b4660f82624Eli Friedman LValue LV; 18922f77b3d57031ded0de2b7b977fb63b4660f82624Eli Friedman if (VD->getType()->isReferenceType()) { 18932f77b3d57031ded0de2b7b977fb63b4660f82624Eli Friedman llvm::LoadInst *LI = Builder.CreateLoad(V); 18946da2c716017d5c8530ec99779524491ebc5dadb8Eli Friedman LI->setAlignment(Alignment.getQuantity()); 18952f77b3d57031ded0de2b7b977fb63b4660f82624Eli Friedman V = LI; 18962f77b3d57031ded0de2b7b977fb63b4660f82624Eli Friedman LV = MakeNaturalAlignAddrLValue(V, T); 18972f77b3d57031ded0de2b7b977fb63b4660f82624Eli Friedman } else { 18982f77b3d57031ded0de2b7b977fb63b4660f82624Eli Friedman LV = MakeAddrLValue(V, T, Alignment); 18992f77b3d57031ded0de2b7b977fb63b4660f82624Eli Friedman } 19003a2b657088de9413714a51bff153a59565adb3efChris Lattner 19015b07e8077a20b80fee90bd76c43c6150c676e4a8John McCall bool isLocalStorage = VD->hasLocalStorage(); 19025b07e8077a20b80fee90bd76c43c6150c676e4a8John McCall 19035b07e8077a20b80fee90bd76c43c6150c676e4a8John McCall bool NonGCable = isLocalStorage && 19045b07e8077a20b80fee90bd76c43c6150c676e4a8John McCall !VD->getType()->isReferenceType() && 19055b07e8077a20b80fee90bd76c43c6150c676e4a8John McCall !isBlockVariable; 190675f91d6c5d654cb8570e299e19b18fe8aff4bba6Fariborz Jahanian if (NonGCable) { 19076d5eb76059c6251ffbb8f0cbac8d7fe9a3efabceDaniel Dunbar LV.getQuals().removeObjCGCAttr(); 1908ea619177353e0a9f35b7d926a92df0e103515dbeDaniel Dunbar LV.setNonGC(true); 1909ea619177353e0a9f35b7d926a92df0e103515dbeDaniel Dunbar } 19105b07e8077a20b80fee90bd76c43c6150c676e4a8John McCall 19115b07e8077a20b80fee90bd76c43c6150c676e4a8John McCall bool isImpreciseLifetime = 19125b07e8077a20b80fee90bd76c43c6150c676e4a8John McCall (isLocalStorage && !VD->hasAttr<ObjCPreciseLifetimeAttr>()); 19135b07e8077a20b80fee90bd76c43c6150c676e4a8John McCall if (isImpreciseLifetime) 19145b07e8077a20b80fee90bd76c43c6150c676e4a8John McCall LV.setARCPreciseLifetime(ARCImpreciseLifetime); 1915b123ea395ee607de85161f84c6e78595946304a5Fariborz Jahanian setObjCGCLValueClass(getContext(), E, LV); 19162682d8b3a0415d521d5ca11afb13a8bc5c559a31Fariborz Jahanian return LV; 1917eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner } 19185808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall 19196bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *FD = dyn_cast<FunctionDecl>(ND)) 19203cebc73895daccea85984d8881b5b45c8f8df9c6Richard Smith return EmitFunctionDeclLValue(*this, E, FD); 19215808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall 1922b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Unhandled DeclRefExpr"); 19235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 19245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 19255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerLValue CodeGenFunction::EmitUnaryOpLValue(const UnaryOperator *E) { 19265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // __extension__ doesn't affect lvalue-ness. 19272de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (E->getOpcode() == UO_Extension) 19285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return EmitLValue(E->getSubExpr()); 1929db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 19309619662a1d42e2008b865d3459c0677e149dad1bChris Lattner QualType ExprTy = getContext().getCanonicalType(E->getSubExpr()->getType()); 19317da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner switch (E->getOpcode()) { 1932b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("Unknown unary operator lvalue!"); 19332de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case UO_Deref: { 1934eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner QualType T = E->getSubExpr()->getType()->getPointeeType(); 1935eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner assert(!T.isNull() && "CodeGenFunction::EmitUnaryOpLValue: Illegal type"); 1936eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner 19374cac9e169bd85bea592a49a0f4a0d2f37260b29aChris Lattner LValue LV = MakeNaturalAlignAddrLValue(EmitScalarExpr(E->getSubExpr()), T); 19386d5eb76059c6251ffbb8f0cbac8d7fe9a3efabceDaniel Dunbar LV.getQuals().setAddressSpace(ExprTy.getAddressSpace()); 1939eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner 1940eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner // We should not generate __weak write barrier on indirect reference 1941eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner // of a pointer to object; as in void foo (__weak id *param); *param = 0; 1942eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner // But, we continue to generate __strong write barrier on indirect write 1943eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner // into a pointer to object. 19447edf9e38b91917b661277601c0e448eef0eb2b56Richard Smith if (getLangOpts().ObjC1 && 19457edf9e38b91917b661277601c0e448eef0eb2b56Richard Smith getLangOpts().getGC() != LangOptions::NonGC && 1946eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner LV.isObjCWeak()) 1947ea619177353e0a9f35b7d926a92df0e103515dbeDaniel Dunbar LV.setNonGC(!E->isOBJCGCCandidate(getContext())); 1948eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner return LV; 1949eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner } 19502de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case UO_Real: 19512de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case UO_Imag: { 19527da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner LValue LV = EmitLValue(E->getSubExpr()); 19532a41637a995affa1563f4d82a8b026e326a2faa0John McCall assert(LV.isSimple() && "real/imag on non-ordinary l-value"); 19542a41637a995affa1563f4d82a8b026e326a2faa0John McCall llvm::Value *Addr = LV.getAddress(); 19552a41637a995affa1563f4d82a8b026e326a2faa0John McCall 1956dfb80ded6767f7b79a0f1fa4f6921d543ff0a643Richard Smith // __real is valid on scalars. This is a faster way of testing that. 1957dfb80ded6767f7b79a0f1fa4f6921d543ff0a643Richard Smith // __imag can only produce an rvalue on scalars. 1958dfb80ded6767f7b79a0f1fa4f6921d543ff0a643Richard Smith if (E->getOpcode() == UO_Real && 1959dfb80ded6767f7b79a0f1fa4f6921d543ff0a643Richard Smith !cast<llvm::PointerType>(Addr->getType()) 19602a41637a995affa1563f4d82a8b026e326a2faa0John McCall ->getElementType()->isStructTy()) { 19612a41637a995affa1563f4d82a8b026e326a2faa0John McCall assert(E->getSubExpr()->getType()->isArithmeticType()); 19622a41637a995affa1563f4d82a8b026e326a2faa0John McCall return LV; 19632a41637a995affa1563f4d82a8b026e326a2faa0John McCall } 19642a41637a995affa1563f4d82a8b026e326a2faa0John McCall 19652a41637a995affa1563f4d82a8b026e326a2faa0John McCall assert(E->getSubExpr()->getType()->isAnyComplexType()); 19662a41637a995affa1563f4d82a8b026e326a2faa0John McCall 19672de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall unsigned Idx = E->getOpcode() == UO_Imag; 19689f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar return MakeAddrLValue(Builder.CreateStructGEP(LV.getAddress(), 19692a41637a995affa1563f4d82a8b026e326a2faa0John McCall Idx, "idx"), 19709f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar ExprTy); 19717da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner } 19722de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case UO_PreInc: 19732de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case UO_PreDec: { 1974197a338f57a9a44efd5f025ce3d462430d260016Chris Lattner LValue LV = EmitLValue(E->getSubExpr()); 19752de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall bool isInc = E->getOpcode() == UO_PreInc; 19761cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 1977197a338f57a9a44efd5f025ce3d462430d260016Chris Lattner if (E->getType()->isAnyComplexType()) 1978197a338f57a9a44efd5f025ce3d462430d260016Chris Lattner EmitComplexPrePostIncDec(E, LV, isInc, true/*isPre*/); 1979197a338f57a9a44efd5f025ce3d462430d260016Chris Lattner else 1980197a338f57a9a44efd5f025ce3d462430d260016Chris Lattner EmitScalarPrePostIncDec(E, LV, isInc, true/*isPre*/); 1981197a338f57a9a44efd5f025ce3d462430d260016Chris Lattner return LV; 1982197a338f57a9a44efd5f025ce3d462430d260016Chris Lattner } 1983e401cd5a487feee1165d3977aa3f4b68f44a3ca7Eli Friedman } 19845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 19855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 19865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerLValue CodeGenFunction::EmitStringLiteralLValue(const StringLiteral *E) { 198779c3928d816f317dd27109fb92e7d190c1c68329Daniel Dunbar return MakeAddrLValue(CGM.GetAddrOfConstantStringFromLiteral(E), 198879c3928d816f317dd27109fb92e7d190c1c68329Daniel Dunbar E->getType()); 19895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 19905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1991eaf2bb89eb2aad3b80673de30febe52df43c10ecChris LattnerLValue CodeGenFunction::EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E) { 199279c3928d816f317dd27109fb92e7d190c1c68329Daniel Dunbar return MakeAddrLValue(CGM.GetAddrOfConstantStringFromObjCEncode(E), 199379c3928d816f317dd27109fb92e7d190c1c68329Daniel Dunbar E->getType()); 1994eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner} 1995eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner 199628ad063b279378b19cb0704f977429df366a151eNico Weberstatic void ConvertUTF8ToWideString(unsigned CharByteWidth, StringRef Source, 199728ad063b279378b19cb0704f977429df366a151eNico Weber SmallString<32>& Target) { 199828ad063b279378b19cb0704f977429df366a151eNico Weber Target.resize(CharByteWidth * (Source.size() + 1)); 1999e5f0588840b20897631cc8110344fd2745ef4caaRichard Smith char *ResultPtr = &Target[0]; 2000e5f0588840b20897631cc8110344fd2745ef4caaRichard Smith const UTF8 *ErrorPtr; 2001e5f0588840b20897631cc8110344fd2745ef4caaRichard Smith bool success = ConvertUTF8toWide(CharByteWidth, Source, ResultPtr, ErrorPtr); 2002402a6d5613b3df364ba252416d5a022dee95f0baMatt Beaumont-Gay (void)success; 2003941e47cef26fb6300a8d3e366f7c5694277e5849Nico Weber assert(success); 200428ad063b279378b19cb0704f977429df366a151eNico Weber Target.resize(ResultPtr - &Target[0]); 200528ad063b279378b19cb0704f977429df366a151eNico Weber} 2006eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner 20073ec0bafda37da00aac370e24f9fff9efb90861d2Daniel DunbarLValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) { 20083ec0bafda37da00aac370e24f9fff9efb90861d2Daniel Dunbar switch (E->getIdentType()) { 20093ec0bafda37da00aac370e24f9fff9efb90861d2Daniel Dunbar default: 20103ec0bafda37da00aac370e24f9fff9efb90861d2Daniel Dunbar return EmitUnsupportedLValue(E, "predefined expression"); 2011662b71ee82339c67f2c3689196e716c6560cf925Daniel Dunbar 2012eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner case PredefinedExpr::Func: 2013eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner case PredefinedExpr::Function: 201428ad063b279378b19cb0704f977429df366a151eNico Weber case PredefinedExpr::LFunction: 2015bafa74f360cb3ec82fa8c688845330f491d167fdDavid Majnemer case PredefinedExpr::FuncDName: 20166bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines case PredefinedExpr::FuncSig: 20173ec0bafda37da00aac370e24f9fff9efb90861d2Daniel Dunbar case PredefinedExpr::PrettyFunction: { 201828bdbf0861fefb33474fddbda1d3c66ee29be2afBenjamin Kramer PredefinedExpr::IdentType IdentType = E->getIdentType(); 20196bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines std::string GVName; 20203ec0bafda37da00aac370e24f9fff9efb90861d2Daniel Dunbar 20216bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines // FIXME: We should use the string literal mangling for the Microsoft C++ 20226bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines // ABI so that strings get merged. 202328ad063b279378b19cb0704f977429df366a151eNico Weber switch (IdentType) { 2024b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("Invalid type"); 20256bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines case PredefinedExpr::Func: GVName = "__func__."; break; 20266bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines case PredefinedExpr::Function: GVName = "__FUNCTION__."; break; 20276bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines case PredefinedExpr::FuncDName: GVName = "__FUNCDNAME__."; break; 20286bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines case PredefinedExpr::FuncSig: GVName = "__FUNCSIG__."; break; 20296bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines case PredefinedExpr::LFunction: GVName = "L__FUNCTION__."; break; 20306bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines case PredefinedExpr::PrettyFunction: GVName = "__PRETTY_FUNCTION__."; break; 20313ec0bafda37da00aac370e24f9fff9efb90861d2Daniel Dunbar } 2032662b71ee82339c67f2c3689196e716c6560cf925Daniel Dunbar 20335f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner StringRef FnName = CurFn->getName(); 20343ec0bafda37da00aac370e24f9fff9efb90861d2Daniel Dunbar if (FnName.startswith("\01")) 20353ec0bafda37da00aac370e24f9fff9efb90861d2Daniel Dunbar FnName = FnName.substr(1); 20366bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines GVName += FnName; 20370a23d76999f838257f70bd43dc7f1e2242147609Daniel Dunbar 203828bdbf0861fefb33474fddbda1d3c66ee29be2afBenjamin Kramer // If this is outside of a function use the top level decl. 20393ec0bafda37da00aac370e24f9fff9efb90861d2Daniel Dunbar const Decl *CurDecl = CurCodeDecl; 20406bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (!CurDecl || isa<VarDecl>(CurDecl)) 20413ec0bafda37da00aac370e24f9fff9efb90861d2Daniel Dunbar CurDecl = getContext().getTranslationUnitDecl(); 2042662b71ee82339c67f2c3689196e716c6560cf925Daniel Dunbar 204328bdbf0861fefb33474fddbda1d3c66ee29be2afBenjamin Kramer const Type *ElemType = E->getType()->getArrayElementTypeNoTypeQual(); 204428bdbf0861fefb33474fddbda1d3c66ee29be2afBenjamin Kramer std::string FunctionName; 204528bdbf0861fefb33474fddbda1d3c66ee29be2afBenjamin Kramer if (isa<BlockDecl>(CurDecl)) { 204628bdbf0861fefb33474fddbda1d3c66ee29be2afBenjamin Kramer // Blocks use the mangled function name. 204728bdbf0861fefb33474fddbda1d3c66ee29be2afBenjamin Kramer // FIXME: ComputeName should handle blocks. 204828bdbf0861fefb33474fddbda1d3c66ee29be2afBenjamin Kramer FunctionName = FnName.str(); 204915b2674896371ac2a0fe707b538a1a29dec9d8e4Wei Pan } else if (isa<CapturedDecl>(CurDecl)) { 205015b2674896371ac2a0fe707b538a1a29dec9d8e4Wei Pan // For a captured statement, the function name is its enclosing 205115b2674896371ac2a0fe707b538a1a29dec9d8e4Wei Pan // function name not the one compiler generated. 205215b2674896371ac2a0fe707b538a1a29dec9d8e4Wei Pan FunctionName = PredefinedExpr::ComputeName(IdentType, CurDecl); 205328bdbf0861fefb33474fddbda1d3c66ee29be2afBenjamin Kramer } else { 205428bdbf0861fefb33474fddbda1d3c66ee29be2afBenjamin Kramer FunctionName = PredefinedExpr::ComputeName(IdentType, CurDecl); 205528bdbf0861fefb33474fddbda1d3c66ee29be2afBenjamin Kramer assert(cast<ConstantArrayType>(E->getType())->getSize() - 1 == 205628bdbf0861fefb33474fddbda1d3c66ee29be2afBenjamin Kramer FunctionName.size() && 205728bdbf0861fefb33474fddbda1d3c66ee29be2afBenjamin Kramer "Computed __func__ length differs from type!"); 205828bdbf0861fefb33474fddbda1d3c66ee29be2afBenjamin Kramer } 205928ad063b279378b19cb0704f977429df366a151eNico Weber 206028ad063b279378b19cb0704f977429df366a151eNico Weber llvm::Constant *C; 206128ad063b279378b19cb0704f977429df366a151eNico Weber if (ElemType->isWideCharType()) { 206228ad063b279378b19cb0704f977429df366a151eNico Weber SmallString<32> RawChars; 206328ad063b279378b19cb0704f977429df366a151eNico Weber ConvertUTF8ToWideString( 2064ef8225444452a1486bd721f3285301fe84643b00Stephen Hines getContext().getTypeSizeInChars(ElemType).getQuantity(), FunctionName, 2065ef8225444452a1486bd721f3285301fe84643b00Stephen Hines RawChars); 2066ef8225444452a1486bd721f3285301fe84643b00Stephen Hines StringLiteral *SL = StringLiteral::Create( 2067ef8225444452a1486bd721f3285301fe84643b00Stephen Hines getContext(), RawChars, StringLiteral::Wide, 2068ef8225444452a1486bd721f3285301fe84643b00Stephen Hines /*Pascal = */ false, E->getType(), E->getLocation()); 2069ef8225444452a1486bd721f3285301fe84643b00Stephen Hines C = CGM.GetAddrOfConstantStringFromLiteral(SL); 207028ad063b279378b19cb0704f977429df366a151eNico Weber } else { 20716bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines C = CGM.GetAddrOfConstantCString(FunctionName, GVName.c_str(), 1); 207228ad063b279378b19cb0704f977429df366a151eNico Weber } 207379c3928d816f317dd27109fb92e7d190c1c68329Daniel Dunbar return MakeAddrLValue(C, E->getType()); 20743ec0bafda37da00aac370e24f9fff9efb90861d2Daniel Dunbar } 2075662b71ee82339c67f2c3689196e716c6560cf925Daniel Dunbar } 2076227426661be33ff3e21f2b6b9f97971da2da044fAnders Carlsson} 2077227426661be33ff3e21f2b6b9f97971da2da044fAnders Carlsson 20784def70d3040e73707c738f7c366737a986135edfRichard Smith/// Emit a type description suitable for use by a runtime sanitizer library. The 20794def70d3040e73707c738f7c366737a986135edfRichard Smith/// format of a type descriptor is 20804def70d3040e73707c738f7c366737a986135edfRichard Smith/// 20814def70d3040e73707c738f7c366737a986135edfRichard Smith/// \code 2082dc47bdc43c62bf2ff01bc71c811a66cb5376d318Richard Smith/// { i16 TypeKind, i16 TypeInfo } 20834def70d3040e73707c738f7c366737a986135edfRichard Smith/// \endcode 20844def70d3040e73707c738f7c366737a986135edfRichard Smith/// 2085dc47bdc43c62bf2ff01bc71c811a66cb5376d318Richard Smith/// followed by an array of i8 containing the type name. TypeKind is 0 for an 2086dc47bdc43c62bf2ff01bc71c811a66cb5376d318Richard Smith/// integer, 1 for a floating point value, and -1 for anything else. 20874def70d3040e73707c738f7c366737a986135edfRichard Smithllvm::Constant *CodeGenFunction::EmitCheckTypeDescriptor(QualType T) { 2088562d45ce29e8904e686e4caf18b8e6c4d6d3798dWill Dietz // Only emit each type's descriptor once. 20896bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (llvm::Constant *C = CGM.getTypeDescriptorFromMap(T)) 2090562d45ce29e8904e686e4caf18b8e6c4d6d3798dWill Dietz return C; 2091562d45ce29e8904e686e4caf18b8e6c4d6d3798dWill Dietz 20924def70d3040e73707c738f7c366737a986135edfRichard Smith uint16_t TypeKind = -1; 20934def70d3040e73707c738f7c366737a986135edfRichard Smith uint16_t TypeInfo = 0; 20944def70d3040e73707c738f7c366737a986135edfRichard Smith 20954def70d3040e73707c738f7c366737a986135edfRichard Smith if (T->isIntegerType()) { 20964def70d3040e73707c738f7c366737a986135edfRichard Smith TypeKind = 0; 20974def70d3040e73707c738f7c366737a986135edfRichard Smith TypeInfo = (llvm::Log2_32(getContext().getTypeSize(T)) << 1) | 2098bbe89d5670b458fc1e2fff49e96e119ffb1622c8Aaron Ballman (T->isSignedIntegerType() ? 1 : 0); 20994def70d3040e73707c738f7c366737a986135edfRichard Smith } else if (T->isFloatingType()) { 21004def70d3040e73707c738f7c366737a986135edfRichard Smith TypeKind = 1; 21014def70d3040e73707c738f7c366737a986135edfRichard Smith TypeInfo = getContext().getTypeSize(T); 21024def70d3040e73707c738f7c366737a986135edfRichard Smith } 21034def70d3040e73707c738f7c366737a986135edfRichard Smith 21044def70d3040e73707c738f7c366737a986135edfRichard Smith // Format the type name as if for a diagnostic, including quotes and 21054def70d3040e73707c738f7c366737a986135edfRichard Smith // optionally an 'aka'. 2106cfa88f893915ceb8ae4ce2f17c46c24a4d67502fDmitri Gribenko SmallString<32> Buffer; 21074def70d3040e73707c738f7c366737a986135edfRichard Smith CGM.getDiags().ConvertArgToString(DiagnosticsEngine::ak_qualtype, 21084def70d3040e73707c738f7c366737a986135edfRichard Smith (intptr_t)T.getAsOpaquePtr(), 2109ef8225444452a1486bd721f3285301fe84643b00Stephen Hines StringRef(), StringRef(), None, Buffer, 21104def70d3040e73707c738f7c366737a986135edfRichard Smith ArrayRef<intptr_t>()); 21114def70d3040e73707c738f7c366737a986135edfRichard Smith 21124def70d3040e73707c738f7c366737a986135edfRichard Smith llvm::Constant *Components[] = { 2113dc47bdc43c62bf2ff01bc71c811a66cb5376d318Richard Smith Builder.getInt16(TypeKind), Builder.getInt16(TypeInfo), 2114dc47bdc43c62bf2ff01bc71c811a66cb5376d318Richard Smith llvm::ConstantDataArray::getString(getLLVMContext(), Buffer) 21154def70d3040e73707c738f7c366737a986135edfRichard Smith }; 21164def70d3040e73707c738f7c366737a986135edfRichard Smith llvm::Constant *Descriptor = llvm::ConstantStruct::getAnon(Components); 211741513444fe9d032dc74660c581d3689865bf32d3Mike Stump 21186bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines auto *GV = new llvm::GlobalVariable( 21196bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines CGM.getModule(), Descriptor->getType(), 21206bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines /*isConstant=*/true, llvm::GlobalVariable::PrivateLinkage, Descriptor); 21214def70d3040e73707c738f7c366737a986135edfRichard Smith GV->setUnnamedAddr(true); 2122562d45ce29e8904e686e4caf18b8e6c4d6d3798dWill Dietz 2123562d45ce29e8904e686e4caf18b8e6c4d6d3798dWill Dietz // Remember the descriptor for this type. 21246bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines CGM.setTypeDescriptorInMap(T, GV); 2125562d45ce29e8904e686e4caf18b8e6c4d6d3798dWill Dietz 21264def70d3040e73707c738f7c366737a986135edfRichard Smith return GV; 21274def70d3040e73707c738f7c366737a986135edfRichard Smith} 21287ac9ef1c82c779a5348ed11b3d10e01c58803b35Richard Smith 21294def70d3040e73707c738f7c366737a986135edfRichard Smithllvm::Value *CodeGenFunction::EmitCheckValue(llvm::Value *V) { 21304def70d3040e73707c738f7c366737a986135edfRichard Smith llvm::Type *TargetTy = IntPtrTy; 21314def70d3040e73707c738f7c366737a986135edfRichard Smith 2132bf8487a3c290203ae54fd81d35a94be0ff211235Richard Smith // Floating-point types which fit into intptr_t are bitcast to integers 2133bf8487a3c290203ae54fd81d35a94be0ff211235Richard Smith // and then passed directly (after zero-extension, if necessary). 2134bf8487a3c290203ae54fd81d35a94be0ff211235Richard Smith if (V->getType()->isFloatingPointTy()) { 2135bf8487a3c290203ae54fd81d35a94be0ff211235Richard Smith unsigned Bits = V->getType()->getPrimitiveSizeInBits(); 2136bf8487a3c290203ae54fd81d35a94be0ff211235Richard Smith if (Bits <= TargetTy->getIntegerBitWidth()) 2137bf8487a3c290203ae54fd81d35a94be0ff211235Richard Smith V = Builder.CreateBitCast(V, llvm::Type::getIntNTy(getLLVMContext(), 2138bf8487a3c290203ae54fd81d35a94be0ff211235Richard Smith Bits)); 2139bf8487a3c290203ae54fd81d35a94be0ff211235Richard Smith } 2140bf8487a3c290203ae54fd81d35a94be0ff211235Richard Smith 21414def70d3040e73707c738f7c366737a986135edfRichard Smith // Integers which fit in intptr_t are zero-extended and passed directly. 21424def70d3040e73707c738f7c366737a986135edfRichard Smith if (V->getType()->isIntegerTy() && 21434def70d3040e73707c738f7c366737a986135edfRichard Smith V->getType()->getIntegerBitWidth() <= TargetTy->getIntegerBitWidth()) 21444def70d3040e73707c738f7c366737a986135edfRichard Smith return Builder.CreateZExt(V, TargetTy); 21454def70d3040e73707c738f7c366737a986135edfRichard Smith 21464def70d3040e73707c738f7c366737a986135edfRichard Smith // Pointers are passed directly, everything else is passed by address. 21474def70d3040e73707c738f7c366737a986135edfRichard Smith if (!V->getType()->isPointerTy()) { 2148bf8487a3c290203ae54fd81d35a94be0ff211235Richard Smith llvm::Value *Ptr = CreateTempAlloca(V->getType()); 21494def70d3040e73707c738f7c366737a986135edfRichard Smith Builder.CreateStore(V, Ptr); 21504def70d3040e73707c738f7c366737a986135edfRichard Smith V = Ptr; 21514def70d3040e73707c738f7c366737a986135edfRichard Smith } 21524def70d3040e73707c738f7c366737a986135edfRichard Smith return Builder.CreatePtrToInt(V, TargetTy); 21534def70d3040e73707c738f7c366737a986135edfRichard Smith} 21544def70d3040e73707c738f7c366737a986135edfRichard Smith 21554def70d3040e73707c738f7c366737a986135edfRichard Smith/// \brief Emit a representation of a SourceLocation for passing to a handler 21564def70d3040e73707c738f7c366737a986135edfRichard Smith/// in a sanitizer runtime library. The format for this data is: 21574def70d3040e73707c738f7c366737a986135edfRichard Smith/// \code 21584def70d3040e73707c738f7c366737a986135edfRichard Smith/// struct SourceLocation { 21594def70d3040e73707c738f7c366737a986135edfRichard Smith/// const char *Filename; 21604def70d3040e73707c738f7c366737a986135edfRichard Smith/// int32_t Line, Column; 21614def70d3040e73707c738f7c366737a986135edfRichard Smith/// }; 21624def70d3040e73707c738f7c366737a986135edfRichard Smith/// \endcode 21634def70d3040e73707c738f7c366737a986135edfRichard Smith/// For an invalid SourceLocation, the Filename pointer is null. 21644def70d3040e73707c738f7c366737a986135edfRichard Smithllvm::Constant *CodeGenFunction::EmitCheckSourceLocation(SourceLocation Loc) { 21654def70d3040e73707c738f7c366737a986135edfRichard Smith PresumedLoc PLoc = getContext().getSourceManager().getPresumedLoc(Loc); 21664def70d3040e73707c738f7c366737a986135edfRichard Smith 21674def70d3040e73707c738f7c366737a986135edfRichard Smith llvm::Constant *Data[] = { 2168562d45ce29e8904e686e4caf18b8e6c4d6d3798dWill Dietz PLoc.isValid() ? CGM.GetAddrOfConstantCString(PLoc.getFilename(), ".src") 21694def70d3040e73707c738f7c366737a986135edfRichard Smith : llvm::Constant::getNullValue(Int8PtrTy), 21702bb6dad4a44569dd2f86e7500a5ba21680718736Evgeniy Stepanov Builder.getInt32(PLoc.isValid() ? PLoc.getLine() : 0), 21712bb6dad4a44569dd2f86e7500a5ba21680718736Evgeniy Stepanov Builder.getInt32(PLoc.isValid() ? PLoc.getColumn() : 0) 21724def70d3040e73707c738f7c366737a986135edfRichard Smith }; 21737ac9ef1c82c779a5348ed11b3d10e01c58803b35Richard Smith 21744def70d3040e73707c738f7c366737a986135edfRichard Smith return llvm::ConstantStruct::getAnon(Data); 21754def70d3040e73707c738f7c366737a986135edfRichard Smith} 21767ac9ef1c82c779a5348ed11b3d10e01c58803b35Richard Smith 21774def70d3040e73707c738f7c366737a986135edfRichard Smithvoid CodeGenFunction::EmitCheck(llvm::Value *Checked, StringRef CheckName, 2178cfa88f893915ceb8ae4ce2f17c46c24a4d67502fDmitri Gribenko ArrayRef<llvm::Constant *> StaticArgs, 2179cfa88f893915ceb8ae4ce2f17c46c24a4d67502fDmitri Gribenko ArrayRef<llvm::Value *> DynamicArgs, 2180ad95481b2769ad61f23afc5e2c31f11c66090657Will Dietz CheckRecoverableKind RecoverKind) { 21814f45bc099f2665bc6e4bcbb169aa452390dbf3feWill Dietz assert(SanOpts != &SanitizerOptions::Disabled); 218278d85b1c5830a881c0a20a1b3fea99ee73149590Chad Rosier 218378d85b1c5830a881c0a20a1b3fea99ee73149590Chad Rosier if (CGM.getCodeGenOpts().SanitizeUndefinedTrapOnError) { 218478d85b1c5830a881c0a20a1b3fea99ee73149590Chad Rosier assert (RecoverKind != CRK_AlwaysRecoverable && 218578d85b1c5830a881c0a20a1b3fea99ee73149590Chad Rosier "Runtime call required for AlwaysRecoverable kind!"); 218678d85b1c5830a881c0a20a1b3fea99ee73149590Chad Rosier return EmitTrapCheck(Checked); 218778d85b1c5830a881c0a20a1b3fea99ee73149590Chad Rosier } 218878d85b1c5830a881c0a20a1b3fea99ee73149590Chad Rosier 21894def70d3040e73707c738f7c366737a986135edfRichard Smith llvm::BasicBlock *Cont = createBasicBlock("cont"); 21907ac9ef1c82c779a5348ed11b3d10e01c58803b35Richard Smith 21914def70d3040e73707c738f7c366737a986135edfRichard Smith llvm::BasicBlock *Handler = createBasicBlock("handler." + CheckName); 21921bdbe4d23ed90f601772edd4aa00b8d757c6d6caWill Dietz 21931bdbe4d23ed90f601772edd4aa00b8d757c6d6caWill Dietz llvm::Instruction *Branch = Builder.CreateCondBr(Checked, Cont, Handler); 21941bdbe4d23ed90f601772edd4aa00b8d757c6d6caWill Dietz 21951bdbe4d23ed90f601772edd4aa00b8d757c6d6caWill Dietz // Give hint that we very much don't expect to execute the handler 21961bdbe4d23ed90f601772edd4aa00b8d757c6d6caWill Dietz // Value chosen to match UR_NONTAKEN_WEIGHT, see BranchProbabilityInfo.cpp 21971bdbe4d23ed90f601772edd4aa00b8d757c6d6caWill Dietz llvm::MDBuilder MDHelper(getLLVMContext()); 21981bdbe4d23ed90f601772edd4aa00b8d757c6d6caWill Dietz llvm::MDNode *Node = MDHelper.createBranchWeights((1U << 20) - 1, 1); 21991bdbe4d23ed90f601772edd4aa00b8d757c6d6caWill Dietz Branch->setMetadata(llvm::LLVMContext::MD_prof, Node); 22001bdbe4d23ed90f601772edd4aa00b8d757c6d6caWill Dietz 22014def70d3040e73707c738f7c366737a986135edfRichard Smith EmitBlock(Handler); 22024def70d3040e73707c738f7c366737a986135edfRichard Smith 22034def70d3040e73707c738f7c366737a986135edfRichard Smith llvm::Constant *Info = llvm::ConstantStruct::getAnon(StaticArgs); 22046bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines auto *InfoPtr = 22054a5984cc6d176d8356529e7e5aee4856088d79f0Will Dietz new llvm::GlobalVariable(CGM.getModule(), Info->getType(), false, 22064def70d3040e73707c738f7c366737a986135edfRichard Smith llvm::GlobalVariable::PrivateLinkage, Info); 22074def70d3040e73707c738f7c366737a986135edfRichard Smith InfoPtr->setUnnamedAddr(true); 22084def70d3040e73707c738f7c366737a986135edfRichard Smith 2209cfa88f893915ceb8ae4ce2f17c46c24a4d67502fDmitri Gribenko SmallVector<llvm::Value *, 4> Args; 2210cfa88f893915ceb8ae4ce2f17c46c24a4d67502fDmitri Gribenko SmallVector<llvm::Type *, 4> ArgTypes; 22114def70d3040e73707c738f7c366737a986135edfRichard Smith Args.reserve(DynamicArgs.size() + 1); 22124def70d3040e73707c738f7c366737a986135edfRichard Smith ArgTypes.reserve(DynamicArgs.size() + 1); 22134def70d3040e73707c738f7c366737a986135edfRichard Smith 22144def70d3040e73707c738f7c366737a986135edfRichard Smith // Handler functions take an i8* pointing to the (handler-specific) static 22154def70d3040e73707c738f7c366737a986135edfRichard Smith // information block, followed by a sequence of intptr_t arguments 22164def70d3040e73707c738f7c366737a986135edfRichard Smith // representing operand values. 22174def70d3040e73707c738f7c366737a986135edfRichard Smith Args.push_back(Builder.CreateBitCast(InfoPtr, Int8PtrTy)); 22184def70d3040e73707c738f7c366737a986135edfRichard Smith ArgTypes.push_back(Int8PtrTy); 22194def70d3040e73707c738f7c366737a986135edfRichard Smith for (size_t i = 0, n = DynamicArgs.size(); i != n; ++i) { 22204def70d3040e73707c738f7c366737a986135edfRichard Smith Args.push_back(EmitCheckValue(DynamicArgs[i])); 22214def70d3040e73707c738f7c366737a986135edfRichard Smith ArgTypes.push_back(IntPtrTy); 22224def70d3040e73707c738f7c366737a986135edfRichard Smith } 22234def70d3040e73707c738f7c366737a986135edfRichard Smith 2224ef8225444452a1486bd721f3285301fe84643b00Stephen Hines bool Recover = RecoverKind == CRK_AlwaysRecoverable || 2225ef8225444452a1486bd721f3285301fe84643b00Stephen Hines (RecoverKind == CRK_Recoverable && 2226ef8225444452a1486bd721f3285301fe84643b00Stephen Hines CGM.getCodeGenOpts().SanitizeRecover); 2227ad95481b2769ad61f23afc5e2c31f11c66090657Will Dietz 22284def70d3040e73707c738f7c366737a986135edfRichard Smith llvm::FunctionType *FnType = 22294def70d3040e73707c738f7c366737a986135edfRichard Smith llvm::FunctionType::get(CGM.VoidTy, ArgTypes, false); 22300d5833921cc728bc1d2e45fbaf7b3e11cddbf99dBill Wendling llvm::AttrBuilder B; 2231ad95481b2769ad61f23afc5e2c31f11c66090657Will Dietz if (!Recover) { 223272390b39c545426023ec104afe8706395d732badBill Wendling B.addAttribute(llvm::Attribute::NoReturn) 223372390b39c545426023ec104afe8706395d732badBill Wendling .addAttribute(llvm::Attribute::NoUnwind); 22348e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith } 223572390b39c545426023ec104afe8706395d732badBill Wendling B.addAttribute(llvm::Attribute::UWTable); 2236ad95481b2769ad61f23afc5e2c31f11c66090657Will Dietz 2237ad95481b2769ad61f23afc5e2c31f11c66090657Will Dietz // Checks that have two variants use a suffix to differentiate them 2238ef8225444452a1486bd721f3285301fe84643b00Stephen Hines bool NeedsAbortSuffix = RecoverKind != CRK_Unrecoverable && 2239ef8225444452a1486bd721f3285301fe84643b00Stephen Hines !CGM.getCodeGenOpts().SanitizeRecover; 224073593eb5c68e28e0eaa4f2b6251dae167eef3a83Richard Smith std::string FunctionName = ("__ubsan_handle_" + CheckName + 224173593eb5c68e28e0eaa4f2b6251dae167eef3a83Richard Smith (NeedsAbortSuffix? "_abort" : "")).str(); 2242ef8225444452a1486bd721f3285301fe84643b00Stephen Hines llvm::Value *Fn = CGM.CreateRuntimeFunction( 2243ef8225444452a1486bd721f3285301fe84643b00Stephen Hines FnType, FunctionName, 2244ef8225444452a1486bd721f3285301fe84643b00Stephen Hines llvm::AttributeSet::get(getLLVMContext(), 2245ef8225444452a1486bd721f3285301fe84643b00Stephen Hines llvm::AttributeSet::FunctionIndex, B)); 2246bd7370a78604e9a20d698bfe328c1e43f12a0613John McCall llvm::CallInst *HandlerCall = EmitNounwindRuntimeCall(Fn, Args); 2247ad95481b2769ad61f23afc5e2c31f11c66090657Will Dietz if (Recover) { 22488e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith Builder.CreateBr(Cont); 22498e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith } else { 22508e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith HandlerCall->setDoesNotReturn(); 22518e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith Builder.CreateUnreachable(); 22528e1cee6f23e2552b96b81e5ef419ab3f69c5b5c2Richard Smith } 22534def70d3040e73707c738f7c366737a986135edfRichard Smith 22547ac9ef1c82c779a5348ed11b3d10e01c58803b35Richard Smith EmitBlock(Cont); 22559c276ae0f24d4cee8f7954069d4b8eae45d0447dMike Stump} 22569c276ae0f24d4cee8f7954069d4b8eae45d0447dMike Stump 225778d85b1c5830a881c0a20a1b3fea99ee73149590Chad Rosiervoid CodeGenFunction::EmitTrapCheck(llvm::Value *Checked) { 2258cc305617e952f8c3a06b63d9225d0dd7769341b7Richard Smith llvm::BasicBlock *Cont = createBasicBlock("cont"); 2259cc305617e952f8c3a06b63d9225d0dd7769341b7Richard Smith 2260cc305617e952f8c3a06b63d9225d0dd7769341b7Richard Smith // If we're optimizing, collapse all calls to trap down to just one per 2261cc305617e952f8c3a06b63d9225d0dd7769341b7Richard Smith // function to save on code size. 2262cc305617e952f8c3a06b63d9225d0dd7769341b7Richard Smith if (!CGM.getCodeGenOpts().OptimizationLevel || !TrapBB) { 2263cc305617e952f8c3a06b63d9225d0dd7769341b7Richard Smith TrapBB = createBasicBlock("trap"); 2264cc305617e952f8c3a06b63d9225d0dd7769341b7Richard Smith Builder.CreateCondBr(Checked, Cont, TrapBB); 2265cc305617e952f8c3a06b63d9225d0dd7769341b7Richard Smith EmitBlock(TrapBB); 2266cc305617e952f8c3a06b63d9225d0dd7769341b7Richard Smith llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::trap); 2267cc305617e952f8c3a06b63d9225d0dd7769341b7Richard Smith llvm::CallInst *TrapCall = Builder.CreateCall(F); 2268cc305617e952f8c3a06b63d9225d0dd7769341b7Richard Smith TrapCall->setDoesNotReturn(); 2269cc305617e952f8c3a06b63d9225d0dd7769341b7Richard Smith TrapCall->setDoesNotThrow(); 2270cc305617e952f8c3a06b63d9225d0dd7769341b7Richard Smith Builder.CreateUnreachable(); 2271cc305617e952f8c3a06b63d9225d0dd7769341b7Richard Smith } else { 2272cc305617e952f8c3a06b63d9225d0dd7769341b7Richard Smith Builder.CreateCondBr(Checked, Cont, TrapBB); 2273cc305617e952f8c3a06b63d9225d0dd7769341b7Richard Smith } 2274cc305617e952f8c3a06b63d9225d0dd7769341b7Richard Smith 2275cc305617e952f8c3a06b63d9225d0dd7769341b7Richard Smith EmitBlock(Cont); 2276cc305617e952f8c3a06b63d9225d0dd7769341b7Richard Smith} 2277cc305617e952f8c3a06b63d9225d0dd7769341b7Richard Smith 22789269d5c05bebe634dc9f08a37b192c6977fbc067Chris Lattner/// isSimpleArrayDecayOperand - If the specified expr is a simple decay from an 22799269d5c05bebe634dc9f08a37b192c6977fbc067Chris Lattner/// array to pointer, return the array subexpression. 22809269d5c05bebe634dc9f08a37b192c6977fbc067Chris Lattnerstatic const Expr *isSimpleArrayDecayOperand(const Expr *E) { 22819269d5c05bebe634dc9f08a37b192c6977fbc067Chris Lattner // If this isn't just an array->pointer decay, bail out. 22826bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines const auto *CE = dyn_cast<CastExpr>(E); 22836bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (!CE || CE->getCastKind() != CK_ArrayToPointerDecay) 2284ef8225444452a1486bd721f3285301fe84643b00Stephen Hines return nullptr; 22851cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 22869269d5c05bebe634dc9f08a37b192c6977fbc067Chris Lattner // If this is a decay from variable width array, bail out. 22879269d5c05bebe634dc9f08a37b192c6977fbc067Chris Lattner const Expr *SubExpr = CE->getSubExpr(); 22889269d5c05bebe634dc9f08a37b192c6977fbc067Chris Lattner if (SubExpr->getType()->isVariableArrayType()) 22896bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return nullptr; 22901cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 22919269d5c05bebe634dc9f08a37b192c6977fbc067Chris Lattner return SubExpr; 22929269d5c05bebe634dc9f08a37b192c6977fbc067Chris Lattner} 22939269d5c05bebe634dc9f08a37b192c6977fbc067Chris Lattner 2294a0a628f839cf50844cc0f226bd9cb72485f98f91Richard SmithLValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E, 2295a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith bool Accessed) { 22962324512285caac0332bbbc6e4cab6245d2a370a1Ted Kremenek // The index must always be an integer, which is not an aggregate. Emit it. 22977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner llvm::Value *Idx = EmitScalarExpr(E->getIdx()); 229861d004a12eba93df9d393c80a6836d20bc0b1be5Eli Friedman QualType IdxTy = E->getIdx()->getType(); 2299575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor bool IdxSigned = IdxTy->isSignedIntegerOrEnumerationType(); 230061d004a12eba93df9d393c80a6836d20bc0b1be5Eli Friedman 230169170e6e41e72c84fe5303540c1aa7ca9944ff18Richard Smith if (SanOpts->ArrayBounds) 2302a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith EmitBoundsCheck(E, E->getBase(), Idx, IdxTy, Accessed); 2303a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith 23045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the base is a vector type, then we are forming a vector element lvalue 23055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // with this subscript. 23061e692ace08959399794363e77499b73da5494af9Eli Friedman if (E->getBase()->getType()->isVectorType()) { 23075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Emit the vector as an lvalue to get its address. 23081e692ace08959399794363e77499b73da5494af9Eli Friedman LValue LHS = EmitLValue(E->getBase()); 23092324512285caac0332bbbc6e4cab6245d2a370a1Ted Kremenek assert(LHS.isSimple() && "Can only subscript lvalue vectors here!"); 23101e692ace08959399794363e77499b73da5494af9Eli Friedman return LValue::MakeVectorElt(LHS.getAddress(), Idx, 2311e5a8aeb4ad762b9383f9e9544c619dc386951e18Eli Friedman E->getBase()->getType(), LHS.getAlignment()); 23125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2313db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23142324512285caac0332bbbc6e4cab6245d2a370a1Ted Kremenek // Extend or truncate the index type to 32 or 64-bits. 23155936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall if (Idx->getType() != IntPtrTy) 23165936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall Idx = Builder.CreateIntCast(Idx, IntPtrTy, IdxSigned, "idxprom"); 23179c276ae0f24d4cee8f7954069d4b8eae45d0447dMike Stump 2318db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // We know that the pointer points to a type of the correct size, unless the 2319db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // size is a VLA or Objective-C interface. 23206bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines llvm::Value *Address = nullptr; 23216da2c716017d5c8530ec99779524491ebc5dadb8Eli Friedman CharUnits ArrayAlignment; 2322bc8d40d85f3fa1e34569834916f18fecaa635152John McCall if (const VariableArrayType *vla = 23238b33c087fc6d97064b6620c96c732ebc5c003fb2Anders Carlsson getContext().getAsVariableArrayType(E->getType())) { 2324bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // The base must be a pointer, which is not an aggregate. Emit 2325bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // it. It needs to be emitted first in case it's what captures 2326bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // the VLA bounds. 2327bc8d40d85f3fa1e34569834916f18fecaa635152John McCall Address = EmitScalarExpr(E->getBase()); 2328db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2329bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // The element count here is the total number of non-VLA elements. 2330bc8d40d85f3fa1e34569834916f18fecaa635152John McCall llvm::Value *numElements = getVLASize(vla).first; 2331db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2332913dab2525cc705e5238023a446f5371fa411883John McCall // Effectively, the multiply by the VLA size is part of the GEP. 2333913dab2525cc705e5238023a446f5371fa411883John McCall // GEP indexes are signed, and scaling an index isn't permitted to 2334913dab2525cc705e5238023a446f5371fa411883John McCall // signed-overflow, so we use the same semantics for our explicit 2335913dab2525cc705e5238023a446f5371fa411883John McCall // multiply. We suppress this if overflow is not undefined behavior. 23364e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (getLangOpts().isSignedOverflowDefined()) { 2337913dab2525cc705e5238023a446f5371fa411883John McCall Idx = Builder.CreateMul(Idx, numElements); 23382cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner Address = Builder.CreateGEP(Address, Idx, "arrayidx"); 2339913dab2525cc705e5238023a446f5371fa411883John McCall } else { 2340913dab2525cc705e5238023a446f5371fa411883John McCall Idx = Builder.CreateNSWMul(Idx, numElements); 23412cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner Address = Builder.CreateInBoundsGEP(Address, Idx, "arrayidx"); 2342913dab2525cc705e5238023a446f5371fa411883John McCall } 23439269d5c05bebe634dc9f08a37b192c6977fbc067Chris Lattner } else if (const ObjCObjectType *OIT = E->getType()->getAs<ObjCObjectType>()){ 23449269d5c05bebe634dc9f08a37b192c6977fbc067Chris Lattner // Indexing over an interface, as in "NSString *P; P[4];" 2345db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump llvm::Value *InterfaceSize = 23464a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson llvm::ConstantInt::get(Idx->getType(), 2347199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck getContext().getTypeSizeInChars(OIT).getQuantity()); 2348db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23492a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Idx = Builder.CreateMul(Idx, InterfaceSize); 23502a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar 23519269d5c05bebe634dc9f08a37b192c6977fbc067Chris Lattner // The base must be a pointer, which is not an aggregate. Emit it. 23529269d5c05bebe634dc9f08a37b192c6977fbc067Chris Lattner llvm::Value *Base = EmitScalarExpr(E->getBase()); 2353d16c2cf1cafa413709aa487cbbd5dc392f1ba1ffJohn McCall Address = EmitCastToVoidPtr(Base); 2354d16c2cf1cafa413709aa487cbbd5dc392f1ba1ffJohn McCall Address = Builder.CreateGEP(Address, Idx, "arrayidx"); 23552a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Address = Builder.CreateBitCast(Address, Base->getType()); 23569269d5c05bebe634dc9f08a37b192c6977fbc067Chris Lattner } else if (const Expr *Array = isSimpleArrayDecayOperand(E->getBase())) { 23579269d5c05bebe634dc9f08a37b192c6977fbc067Chris Lattner // If this is A[i] where A is an array, the frontend will have decayed the 23589269d5c05bebe634dc9f08a37b192c6977fbc067Chris Lattner // base to be a ArrayToPointerDecay implicit cast. While correct, it is 23599269d5c05bebe634dc9f08a37b192c6977fbc067Chris Lattner // inefficient at -O0 to emit a "gep A, 0, 0" when codegen'ing it, then a 23609269d5c05bebe634dc9f08a37b192c6977fbc067Chris Lattner // "gep x, i" here. Emit one "gep A, 0, i". 23619269d5c05bebe634dc9f08a37b192c6977fbc067Chris Lattner assert(Array->getType()->isArrayType() && 23629269d5c05bebe634dc9f08a37b192c6977fbc067Chris Lattner "Array to pointer decay must have array source type!"); 2363a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith LValue ArrayLV; 2364a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith // For simple multidimensional array indexing, set the 'accessed' flag for 2365a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith // better bounds-checking of the base expression. 23666bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *ASE = dyn_cast<ArraySubscriptExpr>(Array)) 2367a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith ArrayLV = EmitArraySubscriptExpr(ASE, /*Accessed*/ true); 2368a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith else 2369a0a628f839cf50844cc0f226bd9cb72485f98f91Richard Smith ArrayLV = EmitLValue(Array); 2370d553408ff15b38710a1ba0947efbf4c5637018abDaniel Dunbar llvm::Value *ArrayPtr = ArrayLV.getAddress(); 23719269d5c05bebe634dc9f08a37b192c6977fbc067Chris Lattner llvm::Value *Zero = llvm::ConstantInt::get(Int32Ty, 0); 23729269d5c05bebe634dc9f08a37b192c6977fbc067Chris Lattner llvm::Value *Args[] = { Zero, Idx }; 23731cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 2374d553408ff15b38710a1ba0947efbf4c5637018abDaniel Dunbar // Propagate the alignment from the array itself to the result. 2375d553408ff15b38710a1ba0947efbf4c5637018abDaniel Dunbar ArrayAlignment = ArrayLV.getAlignment(); 2376d553408ff15b38710a1ba0947efbf4c5637018abDaniel Dunbar 23777edf9e38b91917b661277601c0e448eef0eb2b56Richard Smith if (getLangOpts().isSignedOverflowDefined()) 23780f6ac7cf7bc6a02c1a5c19d2c90ec0d1dd7786e7Jay Foad Address = Builder.CreateGEP(ArrayPtr, Args, "arrayidx"); 23792cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner else 23800f6ac7cf7bc6a02c1a5c19d2c90ec0d1dd7786e7Jay Foad Address = Builder.CreateInBoundsGEP(ArrayPtr, Args, "arrayidx"); 23812a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar } else { 23829269d5c05bebe634dc9f08a37b192c6977fbc067Chris Lattner // The base must be a pointer, which is not an aggregate. Emit it. 23839269d5c05bebe634dc9f08a37b192c6977fbc067Chris Lattner llvm::Value *Base = EmitScalarExpr(E->getBase()); 23847edf9e38b91917b661277601c0e448eef0eb2b56Richard Smith if (getLangOpts().isSignedOverflowDefined()) 23852cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner Address = Builder.CreateGEP(Base, Idx, "arrayidx"); 23862cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner else 23872cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner Address = Builder.CreateInBoundsGEP(Base, Idx, "arrayidx"); 23888b33c087fc6d97064b6620c96c732ebc5c003fb2Anders Carlsson } 2389db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 239014108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff QualType T = E->getBase()->getType()->getPointeeType(); 2391db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump assert(!T.isNull() && 239214108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff "CodeGenFunction::EmitArraySubscriptExpr(): Illegal base type"); 2393db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23941cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 2395d553408ff15b38710a1ba0947efbf4c5637018abDaniel Dunbar // Limit the alignment to that of the result type. 239644a239973dfe86a0d2432ca2502b7878fadfe23eChris Lattner LValue LV; 23976da2c716017d5c8530ec99779524491ebc5dadb8Eli Friedman if (!ArrayAlignment.isZero()) { 23986da2c716017d5c8530ec99779524491ebc5dadb8Eli Friedman CharUnits Align = getContext().getTypeAlignInChars(T); 2399d553408ff15b38710a1ba0947efbf4c5637018abDaniel Dunbar ArrayAlignment = std::min(Align, ArrayAlignment); 240044a239973dfe86a0d2432ca2502b7878fadfe23eChris Lattner LV = MakeAddrLValue(Address, T, ArrayAlignment); 240144a239973dfe86a0d2432ca2502b7878fadfe23eChris Lattner } else { 240244a239973dfe86a0d2432ca2502b7878fadfe23eChris Lattner LV = MakeNaturalAlignAddrLValue(Address, T); 2403d553408ff15b38710a1ba0947efbf4c5637018abDaniel Dunbar } 2404d553408ff15b38710a1ba0947efbf4c5637018abDaniel Dunbar 24056d5eb76059c6251ffbb8f0cbac8d7fe9a3efabceDaniel Dunbar LV.getQuals().setAddressSpace(E->getBase()->getType().getAddressSpace()); 24060953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 24077edf9e38b91917b661277601c0e448eef0eb2b56Richard Smith if (getLangOpts().ObjC1 && 24087edf9e38b91917b661277601c0e448eef0eb2b56Richard Smith getLangOpts().getGC() != LangOptions::NonGC) { 2409ea619177353e0a9f35b7d926a92df0e103515dbeDaniel Dunbar LV.setNonGC(!E->isOBJCGCCandidate(getContext())); 2410b123ea395ee607de85161f84c6e78595946304a5Fariborz Jahanian setObjCGCLValueClass(getContext(), E, LV); 2411b123ea395ee607de85161f84c6e78595946304a5Fariborz Jahanian } 2412643887ab8de731c7096f48816f19a18017d05924Fariborz Jahanian return LV; 24135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 24145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2415db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stumpstatic 2416edf5a7b4ebbb2a49c941ca11a131790f50cc55f9NAKAMURA Takumillvm::Constant *GenerateConstantVector(CGBuilderTy &Builder, 24176b9240e058bf3451685df73fc8ce181b3046e92bCraig Topper SmallVectorImpl<unsigned> &Elts) { 24185f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<llvm::Constant*, 4> CElts; 24193b8d116703db8018f855cbb4733ace426422623bNate Begeman for (unsigned i = 0, e = Elts.size(); i != e; ++i) 24202ce8842641cc312628c4be836d34eb250e7c3f78Chris Lattner CElts.push_back(Builder.getInt32(Elts[i])); 24213b8d116703db8018f855cbb4733ace426422623bNate Begeman 2422fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner return llvm::ConstantVector::get(CElts); 24233b8d116703db8018f855cbb4733ace426422623bNate Begeman} 24243b8d116703db8018f855cbb4733ace426422623bNate Begeman 2425349aaec106b459206479f7600990230b9d799c61Chris LattnerLValue CodeGenFunction:: 2426213541a68a3e137d11d2cefb612c6cdb410d7e8eNate BegemanEmitExtVectorElementExpr(const ExtVectorElementExpr *E) { 2427349aaec106b459206479f7600990230b9d799c61Chris Lattner // Emit the base vector as an l-value. 242873525de7fd9bdd534382dc89a24f1f76db3e04b9Chris Lattner LValue Base; 242973525de7fd9bdd534382dc89a24f1f76db3e04b9Chris Lattner 243073525de7fd9bdd534382dc89a24f1f76db3e04b9Chris Lattner // ExtVectorElementExpr's base can either be a vector or pointer to vector. 2431998eab186790b7246a572a9950174f7f36442c06Chris Lattner if (E->isArrow()) { 2432998eab186790b7246a572a9950174f7f36442c06Chris Lattner // If it is a pointer to a vector, emit the address and form an lvalue with 2433998eab186790b7246a572a9950174f7f36442c06Chris Lattner // it. 24342140e904dbe53657339cb5b1cc13de563ca0d1fcChris Lattner llvm::Value *Ptr = EmitScalarExpr(E->getBase()); 2435998eab186790b7246a572a9950174f7f36442c06Chris Lattner const PointerType *PT = E->getBase()->getType()->getAs<PointerType>(); 24366d5eb76059c6251ffbb8f0cbac8d7fe9a3efabceDaniel Dunbar Base = MakeAddrLValue(Ptr, PT->getPointeeType()); 24376d5eb76059c6251ffbb8f0cbac8d7fe9a3efabceDaniel Dunbar Base.getQuals().removeObjCGCAttr(); 24387eb0a9eb0cde8444b97f9c5b713d9be7a6f1e607John McCall } else if (E->getBase()->isGLValue()) { 2439998eab186790b7246a572a9950174f7f36442c06Chris Lattner // Otherwise, if the base is an lvalue ( as in the case of foo.x.x), 2440998eab186790b7246a572a9950174f7f36442c06Chris Lattner // emit the base as an lvalue. 2441998eab186790b7246a572a9950174f7f36442c06Chris Lattner assert(E->getBase()->getType()->isVectorType()); 2442998eab186790b7246a572a9950174f7f36442c06Chris Lattner Base = EmitLValue(E->getBase()); 2443998eab186790b7246a572a9950174f7f36442c06Chris Lattner } else { 2444998eab186790b7246a572a9950174f7f36442c06Chris Lattner // Otherwise, the base is a normal rvalue (as in (V+V).x), emit it as such. 2445a07398ed98ea2b55ad7a505a3aab18aed93b149fJohn McCall assert(E->getBase()->getType()->isVectorType() && 2446302c3c23905de41c3720158cca262e8f87e52014Daniel Dunbar "Result must be a vector"); 2447998eab186790b7246a572a9950174f7f36442c06Chris Lattner llvm::Value *Vec = EmitScalarExpr(E->getBase()); 24481cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 24490ad57fb93ae53ac94ebcd247201f60d87600188fChris Lattner // Store the vector to memory (because LValue wants an address). 2450195337d2e5d4625ae9dc1328c7cdbc7115b0261bDaniel Dunbar llvm::Value *VecMem = CreateMemTemp(E->getBase()->getType()); 2451998eab186790b7246a572a9950174f7f36442c06Chris Lattner Builder.CreateStore(Vec, VecMem); 24526d5eb76059c6251ffbb8f0cbac8d7fe9a3efabceDaniel Dunbar Base = MakeAddrLValue(VecMem, E->getBase()->getType()); 245373525de7fd9bdd534382dc89a24f1f76db3e04b9Chris Lattner } 2454a07398ed98ea2b55ad7a505a3aab18aed93b149fJohn McCall 2455a07398ed98ea2b55ad7a505a3aab18aed93b149fJohn McCall QualType type = 2456a07398ed98ea2b55ad7a505a3aab18aed93b149fJohn McCall E->getType().withCVRQualifiers(Base.getQuals().getCVRQualifiers()); 24571cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 24583b8d116703db8018f855cbb4733ace426422623bNate Begeman // Encode the element access list into a vector of unsigned indices. 24595f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<unsigned, 4> Indices; 24603b8d116703db8018f855cbb4733ace426422623bNate Begeman E->getEncodedElementAccess(Indices); 24613b8d116703db8018f855cbb4733ace426422623bNate Begeman 24623b8d116703db8018f855cbb4733ace426422623bNate Begeman if (Base.isSimple()) { 24632ce8842641cc312628c4be836d34eb250e7c3f78Chris Lattner llvm::Constant *CV = GenerateConstantVector(Builder, Indices); 2464e5a8aeb4ad762b9383f9e9544c619dc386951e18Eli Friedman return LValue::MakeExtVectorElt(Base.getAddress(), CV, type, 2465e5a8aeb4ad762b9383f9e9544c619dc386951e18Eli Friedman Base.getAlignment()); 24668a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman } 24673b8d116703db8018f855cbb4733ace426422623bNate Begeman assert(Base.isExtVectorElt() && "Can only subscript lvalue vec elts here!"); 24683b8d116703db8018f855cbb4733ace426422623bNate Begeman 24693b8d116703db8018f855cbb4733ace426422623bNate Begeman llvm::Constant *BaseElts = Base.getExtVectorElts(); 24705f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<llvm::Constant *, 4> CElts; 2471349aaec106b459206479f7600990230b9d799c61Chris Lattner 247289f42834092621ab6ebac24e09b17b61ac000b6bChris Lattner for (unsigned i = 0, e = Indices.size(); i != e; ++i) 247389f42834092621ab6ebac24e09b17b61ac000b6bChris Lattner CElts.push_back(BaseElts->getAggregateElement(Indices[i])); 2474fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner llvm::Constant *CV = llvm::ConstantVector::get(CElts); 2475e5a8aeb4ad762b9383f9e9544c619dc386951e18Eli Friedman return LValue::MakeExtVectorElt(Base.getExtVectorAddr(), CV, type, 2476e5a8aeb4ad762b9383f9e9544c619dc386951e18Eli Friedman Base.getAlignment()); 2477349aaec106b459206479f7600990230b9d799c61Chris Lattner} 2478349aaec106b459206479f7600990230b9d799c61Chris Lattner 2479b9b00ad6260b17c18195ff4a54c8b3abbf33fcc9Devang PatelLValue CodeGenFunction::EmitMemberExpr(const MemberExpr *E) { 2480126a856ecdb6f9285a7858fa5437949a4fd192abDevang Patel Expr *BaseExpr = E->getBase(); 24811e692ace08959399794363e77499b73da5494af9Eli Friedman 248212f65f6513afe10181aa68eb387ccac23e9e2b6eChris Lattner // If this is s.x, emit s as an lvalue. If it is s->x, emit s as a scalar. 2483377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman LValue BaseLV; 24842c9f87ca5cccbfdaad82762368af5b2323320653Richard Smith if (E->isArrow()) { 24852c9f87ca5cccbfdaad82762368af5b2323320653Richard Smith llvm::Value *Ptr = EmitScalarExpr(BaseExpr); 24862c9f87ca5cccbfdaad82762368af5b2323320653Richard Smith QualType PtrTy = BaseExpr->getType()->getPointeeType(); 24874def70d3040e73707c738f7c366737a986135edfRichard Smith EmitTypeCheck(TCK_MemberAccess, E->getExprLoc(), Ptr, PtrTy); 24882c9f87ca5cccbfdaad82762368af5b2323320653Richard Smith BaseLV = MakeNaturalAlignAddrLValue(Ptr, PtrTy); 24892c9f87ca5cccbfdaad82762368af5b2323320653Richard Smith } else 24907ac9ef1c82c779a5348ed11b3d10e01c58803b35Richard Smith BaseLV = EmitCheckedLValue(BaseExpr, TCK_MemberAccess); 2491b9b00ad6260b17c18195ff4a54c8b3abbf33fcc9Devang Patel 2492ce53f7dbe7406a253c6b2d93ff2727079087d9ccAnders Carlsson NamedDecl *ND = E->getMemberDecl(); 24936bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (auto *Field = dyn_cast<FieldDecl>(ND)) { 2494377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman LValue LV = EmitLValueForField(BaseLV, Field); 2495ce53f7dbe7406a253c6b2d93ff2727079087d9ccAnders Carlsson setObjCGCLValueClass(getContext(), E, LV); 2496ce53f7dbe7406a253c6b2d93ff2727079087d9ccAnders Carlsson return LV; 2497ce53f7dbe7406a253c6b2d93ff2727079087d9ccAnders Carlsson } 24981cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 24996bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (auto *VD = dyn_cast<VarDecl>(ND)) 2500589f9e3f7845c2a1bf97ae4357aec5b457a5ea19Anders Carlsson return EmitGlobalVarDeclLValue(*this, E, VD); 25019a14630714da7176c981e3c8d050f82bc42c2643Eli Friedman 25026bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *FD = dyn_cast<FunctionDecl>(ND)) 25039a14630714da7176c981e3c8d050f82bc42c2643Eli Friedman return EmitFunctionDeclLValue(*this, E, FD); 25049a14630714da7176c981e3c8d050f82bc42c2643Eli Friedman 2505b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Unhandled member declaration!"); 2506472778eb4fce241721c563280886e98389bc7219Eli Friedman} 2507b9b00ad6260b17c18195ff4a54c8b3abbf33fcc9Devang Patel 2508f5ebf9bf1df10ac15ba32a4b24dfe171b7848c58John McCall/// Given that we are currently emitting a lambda, emit an l-value for 2509f5ebf9bf1df10ac15ba32a4b24dfe171b7848c58John McCall/// one of its members. 2510f5ebf9bf1df10ac15ba32a4b24dfe171b7848c58John McCallLValue CodeGenFunction::EmitLValueForLambdaField(const FieldDecl *Field) { 2511f5ebf9bf1df10ac15ba32a4b24dfe171b7848c58John McCall assert(cast<CXXMethodDecl>(CurCodeDecl)->getParent()->isLambda()); 2512f5ebf9bf1df10ac15ba32a4b24dfe171b7848c58John McCall assert(cast<CXXMethodDecl>(CurCodeDecl)->getParent() == Field->getParent()); 2513f5ebf9bf1df10ac15ba32a4b24dfe171b7848c58John McCall QualType LambdaTagType = 2514f5ebf9bf1df10ac15ba32a4b24dfe171b7848c58John McCall getContext().getTagDeclType(Field->getParent()); 2515f5ebf9bf1df10ac15ba32a4b24dfe171b7848c58John McCall LValue LambdaLV = MakeNaturalAlignAddrLValue(CXXABIThisValue, LambdaTagType); 2516f5ebf9bf1df10ac15ba32a4b24dfe171b7848c58John McCall return EmitLValueForField(LambdaLV, Field); 2517f5ebf9bf1df10ac15ba32a4b24dfe171b7848c58John McCall} 2518f5ebf9bf1df10ac15ba32a4b24dfe171b7848c58John McCall 2519377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli FriedmanLValue CodeGenFunction::EmitLValueForField(LValue base, 2520377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman const FieldDecl *field) { 2521f4bcfa1b1850711d5eb092f2b0639331ef9f09f1Eli Friedman if (field->isBitField()) { 2522f4bcfa1b1850711d5eb092f2b0639331ef9f09f1Eli Friedman const CGRecordLayout &RL = 2523f4bcfa1b1850711d5eb092f2b0639331ef9f09f1Eli Friedman CGM.getTypes().getCGRecordLayout(field->getParent()); 2524f4bcfa1b1850711d5eb092f2b0639331ef9f09f1Eli Friedman const CGBitFieldInfo &Info = RL.getBitFieldInfo(field); 252572d2dab6058467036df73a5f668036a519043e5bChandler Carruth llvm::Value *Addr = base.getAddress(); 252672d2dab6058467036df73a5f668036a519043e5bChandler Carruth unsigned Idx = RL.getLLVMFieldNo(field); 252772d2dab6058467036df73a5f668036a519043e5bChandler Carruth if (Idx != 0) 252872d2dab6058467036df73a5f668036a519043e5bChandler Carruth // For structs, we GEP to the field that the record layout suggests. 252972d2dab6058467036df73a5f668036a519043e5bChandler Carruth Addr = Builder.CreateStructGEP(Addr, Idx, field->getName()); 253072d2dab6058467036df73a5f668036a519043e5bChandler Carruth // Get the access type. 253172d2dab6058467036df73a5f668036a519043e5bChandler Carruth llvm::Type *PtrTy = llvm::Type::getIntNPtrTy( 253272d2dab6058467036df73a5f668036a519043e5bChandler Carruth getLLVMContext(), Info.StorageSize, 253372d2dab6058467036df73a5f668036a519043e5bChandler Carruth CGM.getContext().getTargetAddressSpace(base.getType())); 253472d2dab6058467036df73a5f668036a519043e5bChandler Carruth if (Addr->getType() != PtrTy) 253572d2dab6058467036df73a5f668036a519043e5bChandler Carruth Addr = Builder.CreateBitCast(Addr, PtrTy); 253672d2dab6058467036df73a5f668036a519043e5bChandler Carruth 2537f4bcfa1b1850711d5eb092f2b0639331ef9f09f1Eli Friedman QualType fieldType = 2538f4bcfa1b1850711d5eb092f2b0639331ef9f09f1Eli Friedman field->getType().withCVRQualifiers(base.getVRQualifiers()); 253972d2dab6058467036df73a5f668036a519043e5bChandler Carruth return LValue::MakeBitfield(Addr, Info, fieldType, base.getAlignment()); 2540f4bcfa1b1850711d5eb092f2b0639331ef9f09f1Eli Friedman } 2541bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall 2542bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall const RecordDecl *rec = field->getParent(); 2543bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall QualType type = field->getType(); 25446da2c716017d5c8530ec99779524491ebc5dadb8Eli Friedman CharUnits alignment = getContext().getDeclAlign(field); 2545bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall 2546377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman // FIXME: It should be impossible to have an LValue without alignment for a 2547377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman // complete type. 2548377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman if (!base.getAlignment().isZero()) 2549377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman alignment = std::min(alignment, base.getAlignment()); 2550377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman 2551bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall bool mayAlias = rec->hasAttr<MayAliasAttr>(); 2552bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall 2553377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman llvm::Value *addr = base.getAddress(); 2554377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman unsigned cvr = base.getVRQualifiers(); 2555b37a73d5c6a0c8bb1f6e363d3b53980e4fa0ceadManman Ren bool TBAAPath = CGM.getCodeGenOpts().StructPathTBAA; 2556bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall if (rec->isUnion()) { 255774339dfbfe3fa9c1839ce02e3427e4dc5478a3aeChris Lattner // For unions, there is no pointer adjustment. 2558bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall assert(!type->isReferenceType() && "union has reference member"); 2559b37a73d5c6a0c8bb1f6e363d3b53980e4fa0ceadManman Ren // TODO: handle path-aware TBAA for union. 2560b37a73d5c6a0c8bb1f6e363d3b53980e4fa0ceadManman Ren TBAAPath = false; 2561bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall } else { 2562bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall // For structs, we GEP to the field that the record layout suggests. 2563bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall unsigned idx = CGM.getTypes().getCGRecordLayout(rec).getLLVMFieldNo(field); 256474339dfbfe3fa9c1839ce02e3427e4dc5478a3aeChris Lattner addr = Builder.CreateStructGEP(addr, idx, field->getName()); 2565bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall 2566bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall // If this is a reference field, load the reference right now. 2567bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall if (const ReferenceType *refType = type->getAs<ReferenceType>()) { 2568bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall llvm::LoadInst *load = Builder.CreateLoad(addr, "ref"); 2569bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall if (cvr & Qualifiers::Volatile) load->setVolatile(true); 25706da2c716017d5c8530ec99779524491ebc5dadb8Eli Friedman load->setAlignment(alignment.getQuantity()); 2571bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall 2572b37a73d5c6a0c8bb1f6e363d3b53980e4fa0ceadManman Ren // Loading the reference will disable path-aware TBAA. 2573b37a73d5c6a0c8bb1f6e363d3b53980e4fa0ceadManman Ren TBAAPath = false; 2574bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall if (CGM.shouldUseTBAA()) { 2575bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall llvm::MDNode *tbaa; 2576bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall if (mayAlias) 2577bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall tbaa = CGM.getTBAAInfo(getContext().CharTy); 2578bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall else 2579bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall tbaa = CGM.getTBAAInfo(type); 2580feba9f2bdc5711894e452dfc67c9679482fbf897Manman Ren if (tbaa) 2581feba9f2bdc5711894e452dfc67c9679482fbf897Manman Ren CGM.DecorateInstruction(load, tbaa); 2582bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall } 2583db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2584bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall addr = load; 2585bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall mayAlias = false; 2586bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall type = refType->getPointeeType(); 25872f77b3d57031ded0de2b7b977fb63b4660f82624Eli Friedman if (type->isIncompleteType()) 25886da2c716017d5c8530ec99779524491ebc5dadb8Eli Friedman alignment = CharUnits(); 25892f77b3d57031ded0de2b7b977fb63b4660f82624Eli Friedman else 25906da2c716017d5c8530ec99779524491ebc5dadb8Eli Friedman alignment = getContext().getTypeAlignInChars(type); 2591bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall cvr = 0; // qualifiers don't recursively apply to referencee 2592bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall } 2593abad06cfd01edbd6ffe80856304b5ad991b67d08Devang Patel } 25941cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 259574339dfbfe3fa9c1839ce02e3427e4dc5478a3aeChris Lattner // Make sure that the address is pointing to the right type. This is critical 259674339dfbfe3fa9c1839ce02e3427e4dc5478a3aeChris Lattner // for both unions and structs. A union needs a bitcast, a struct element 259774339dfbfe3fa9c1839ce02e3427e4dc5478a3aeChris Lattner // will need a bitcast if the LLVM type laid out doesn't match the desired 259874339dfbfe3fa9c1839ce02e3427e4dc5478a3aeChris Lattner // type. 2599a98742c32c159a8c76f842947c02a79c530a1d4bChandler Carruth addr = EmitBitCastOfLValueToProperType(*this, addr, 26003a2b657088de9413714a51bff153a59565adb3efChris Lattner CGM.getTypes().ConvertTypeForMem(type), 26013a2b657088de9413714a51bff153a59565adb3efChris Lattner field->getName()); 26020953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 260377f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge if (field->hasAttr<AnnotateAttr>()) 260477f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge addr = EmitFieldAnnotations(field, addr); 260577f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge 2606bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall LValue LV = MakeAddrLValue(addr, type, alignment); 2607bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall LV.getQuals().addCVRQualifiers(cvr); 2608b37a73d5c6a0c8bb1f6e363d3b53980e4fa0ceadManman Ren if (TBAAPath) { 2609b37a73d5c6a0c8bb1f6e363d3b53980e4fa0ceadManman Ren const ASTRecordLayout &Layout = 2610b37a73d5c6a0c8bb1f6e363d3b53980e4fa0ceadManman Ren getContext().getASTRecordLayout(field->getParent()); 2611b37a73d5c6a0c8bb1f6e363d3b53980e4fa0ceadManman Ren // Set the base type to be the base type of the base LValue and 2612b37a73d5c6a0c8bb1f6e363d3b53980e4fa0ceadManman Ren // update offset to be relative to the base type. 2613975d83c291821de340eef3c3498104172b375f79Manman Ren LV.setTBAABaseType(mayAlias ? getContext().CharTy : base.getTBAABaseType()); 2614975d83c291821de340eef3c3498104172b375f79Manman Ren LV.setTBAAOffset(mayAlias ? 0 : base.getTBAAOffset() + 2615b37a73d5c6a0c8bb1f6e363d3b53980e4fa0ceadManman Ren Layout.getFieldOffset(field->getFieldIndex()) / 2616b37a73d5c6a0c8bb1f6e363d3b53980e4fa0ceadManman Ren getContext().getCharWidth()); 2617b37a73d5c6a0c8bb1f6e363d3b53980e4fa0ceadManman Ren } 26186d5eb76059c6251ffbb8f0cbac8d7fe9a3efabceDaniel Dunbar 2619fd02ed702e754f8dd0b4c979325ba99c2234f270Fariborz Jahanian // __weak attribute on a field is ignored. 26206d5eb76059c6251ffbb8f0cbac8d7fe9a3efabceDaniel Dunbar if (LV.getQuals().getObjCGCAttr() == Qualifiers::Weak) 26216d5eb76059c6251ffbb8f0cbac8d7fe9a3efabceDaniel Dunbar LV.getQuals().removeObjCGCAttr(); 2622bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall 2623bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall // Fields of may_alias structs act like 'char' for TBAA purposes. 2624bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall // FIXME: this should get propagated down through anonymous structs 2625bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall // and unions. 2626bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall if (mayAlias && LV.getTBAAInfo()) 2627bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall LV.setTBAAInfo(CGM.getTBAAInfo(getContext().CharTy)); 2628bc7fbf0d37b286b37d96b033dfaaabf9c729bca8John McCall 26296d5eb76059c6251ffbb8f0cbac8d7fe9a3efabceDaniel Dunbar return LV; 2630b9b00ad6260b17c18195ff4a54c8b3abbf33fcc9Devang Patel} 2631b9b00ad6260b17c18195ff4a54c8b3abbf33fcc9Devang Patel 26321cc87df9747f31d1b300a29920aa8b62144b7bb2Craig TopperLValue 26331cc87df9747f31d1b300a29920aa8b62144b7bb2Craig TopperCodeGenFunction::EmitLValueForFieldInitialization(LValue Base, 2634377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman const FieldDecl *Field) { 263506a2970e9480c6d02b367b2f970baff29b9f9721Anders Carlsson QualType FieldType = Field->getType(); 26361cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 263706a2970e9480c6d02b367b2f970baff29b9f9721Anders Carlsson if (!FieldType->isReferenceType()) 2638377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman return EmitLValueForField(Base, Field); 263906a2970e9480c6d02b367b2f970baff29b9f9721Anders Carlsson 2640198bcb44b6271c92fd856403f34b518828100aacDaniel Dunbar const CGRecordLayout &RL = 2641198bcb44b6271c92fd856403f34b518828100aacDaniel Dunbar CGM.getTypes().getCGRecordLayout(Field->getParent()); 2642198bcb44b6271c92fd856403f34b518828100aacDaniel Dunbar unsigned idx = RL.getLLVMFieldNo(Field); 2643377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman llvm::Value *V = Builder.CreateStructGEP(Base.getAddress(), idx); 264406a2970e9480c6d02b367b2f970baff29b9f9721Anders Carlsson assert(!FieldType.getObjCGCAttr() && "fields cannot have GC attrs"); 264506a2970e9480c6d02b367b2f970baff29b9f9721Anders Carlsson 26461b5ba858e4628049a7105257fa712b4ab93c0a62Chris Lattner // Make sure that the address is pointing to the right type. This is critical 26471b5ba858e4628049a7105257fa712b4ab93c0a62Chris Lattner // for both unions and structs. A union needs a bitcast, a struct element 26481b5ba858e4628049a7105257fa712b4ab93c0a62Chris Lattner // will need a bitcast if the LLVM type laid out doesn't match the desired 26491b5ba858e4628049a7105257fa712b4ab93c0a62Chris Lattner // type. 26502acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *llvmType = ConvertTypeForMem(FieldType); 2651377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman V = EmitBitCastOfLValueToProperType(*this, V, llvmType, Field->getName()); 2652377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman 26536da2c716017d5c8530ec99779524491ebc5dadb8Eli Friedman CharUnits Alignment = getContext().getDeclAlign(Field); 2654377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman 2655377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman // FIXME: It should be impossible to have an LValue without alignment for a 2656377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman // complete type. 2657377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman if (!Base.getAlignment().isZero()) 2658377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman Alignment = std::min(Alignment, Base.getAlignment()); 2659377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman 2660983e3d7dac99aed376939f1a4daadef98e09c3b9Daniel Dunbar return MakeAddrLValue(V, FieldType, Alignment); 266106a2970e9480c6d02b367b2f970baff29b9f9721Anders Carlsson} 266206a2970e9480c6d02b367b2f970baff29b9f9721Anders Carlsson 2663d0db03a561671b8b466b07026cc8fbbb037bb639Chris LattnerLValue CodeGenFunction::EmitCompoundLiteralLValue(const CompoundLiteralExpr *E){ 26647401cf524cdb7aad4951d8727d280f8b271af5a2Richard Smith if (E->isFileScope()) { 26657401cf524cdb7aad4951d8727d280f8b271af5a2Richard Smith llvm::Value *GlobalPtr = CGM.GetAddrOfConstantCompoundLiteral(E); 26667401cf524cdb7aad4951d8727d280f8b271af5a2Richard Smith return MakeAddrLValue(GlobalPtr, E->getType()); 26677401cf524cdb7aad4951d8727d280f8b271af5a2Richard Smith } 2668ec22f56f2031c3e61100d42133b06f9b9f020ee6Fariborz Jahanian if (E->getType()->isVariablyModifiedType()) 2669ec22f56f2031c3e61100d42133b06f9b9f020ee6Fariborz Jahanian // make sure to emit the VLA size. 2670ec22f56f2031c3e61100d42133b06f9b9f020ee6Fariborz Jahanian EmitVariablyModifiedType(E->getType()); 26711cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 2672150065722a5f010adb0f801d26d8a129a5243669Daniel Dunbar llvm::Value *DeclPtr = CreateMemTemp(E->getType(), ".compoundliteral"); 2673d0db03a561671b8b466b07026cc8fbbb037bb639Chris Lattner const Expr *InitExpr = E->getInitializer(); 26749f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar LValue Result = MakeAddrLValue(DeclPtr, E->getType()); 267506e863f2902b8ba55b056308875c19f7ba3dab25Eli Friedman 2676649b4a1a9b5e6f768ca0cb84bd97b00f51083e15Chad Rosier EmitAnyExprToMem(InitExpr, DeclPtr, E->getType().getQualifiers(), 2677649b4a1a9b5e6f768ca0cb84bd97b00f51083e15Chad Rosier /*Init*/ true); 267806e863f2902b8ba55b056308875c19f7ba3dab25Eli Friedman 267906e863f2902b8ba55b056308875c19f7ba3dab25Eli Friedman return Result; 268006e863f2902b8ba55b056308875c19f7ba3dab25Eli Friedman} 268106e863f2902b8ba55b056308875c19f7ba3dab25Eli Friedman 268213ec9100ca6bc03b5ce8832e4a0fcb724d47bcb1Richard SmithLValue CodeGenFunction::EmitInitListLValue(const InitListExpr *E) { 268313ec9100ca6bc03b5ce8832e4a0fcb724d47bcb1Richard Smith if (!E->isGLValue()) 268413ec9100ca6bc03b5ce8832e4a0fcb724d47bcb1Richard Smith // Initializing an aggregate temporary in C++11: T{...}. 268513ec9100ca6bc03b5ce8832e4a0fcb724d47bcb1Richard Smith return EmitAggExprToLValue(E); 268613ec9100ca6bc03b5ce8832e4a0fcb724d47bcb1Richard Smith 268713ec9100ca6bc03b5ce8832e4a0fcb724d47bcb1Richard Smith // An lvalue initializer list must be initializing a reference. 268813ec9100ca6bc03b5ce8832e4a0fcb724d47bcb1Richard Smith assert(E->getNumInits() == 1 && "reference init with multiple values"); 268913ec9100ca6bc03b5ce8832e4a0fcb724d47bcb1Richard Smith return EmitLValue(E->getInit(0)); 269013ec9100ca6bc03b5ce8832e4a0fcb724d47bcb1Richard Smith} 269113ec9100ca6bc03b5ce8832e4a0fcb724d47bcb1Richard Smith 2692ef8225444452a1486bd721f3285301fe84643b00Stephen Hines/// Emit the operand of a glvalue conditional operator. This is either a glvalue 2693ef8225444452a1486bd721f3285301fe84643b00Stephen Hines/// or a (possibly-parenthesized) throw-expression. If this is a throw, no 2694ef8225444452a1486bd721f3285301fe84643b00Stephen Hines/// LValue is returned and the current block has been terminated. 2695ef8225444452a1486bd721f3285301fe84643b00Stephen Hinesstatic Optional<LValue> EmitLValueOrThrowExpression(CodeGenFunction &CGF, 2696ef8225444452a1486bd721f3285301fe84643b00Stephen Hines const Expr *Operand) { 2697ef8225444452a1486bd721f3285301fe84643b00Stephen Hines if (auto *ThrowExpr = dyn_cast<CXXThrowExpr>(Operand->IgnoreParens())) { 2698ef8225444452a1486bd721f3285301fe84643b00Stephen Hines CGF.EmitCXXThrowExpr(ThrowExpr, /*KeepInsertionPoint*/false); 2699ef8225444452a1486bd721f3285301fe84643b00Stephen Hines return None; 2700ef8225444452a1486bd721f3285301fe84643b00Stephen Hines } 2701ef8225444452a1486bd721f3285301fe84643b00Stephen Hines 2702ef8225444452a1486bd721f3285301fe84643b00Stephen Hines return CGF.EmitLValue(Operand); 2703ef8225444452a1486bd721f3285301fe84643b00Stephen Hines} 2704ef8225444452a1486bd721f3285301fe84643b00Stephen Hines 270556ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCallLValue CodeGenFunction:: 270656ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCallEmitConditionalOperatorLValue(const AbstractConditionalOperator *expr) { 270756ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall if (!expr->isGLValue()) { 2708f99a3915389109a716caafacb41fd9c4a3b8f432John McCall // ?: here should be an aggregate. 27099d232c884ea9872d6555df0fd7359699819bc1f1John McCall assert(hasAggregateEvaluationKind(expr->getType()) && 2710f99a3915389109a716caafacb41fd9c4a3b8f432John McCall "Unexpected conditional operator!"); 271156ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall return EmitAggExprToLValue(expr); 2712f99a3915389109a716caafacb41fd9c4a3b8f432John McCall } 2713ab189950908fc08dd2533692f0e8253e807c73acEli Friedman 27142c0c745709c9f258f4c968bcf3e891faa9acbca6Eli Friedman OpaqueValueMapping binding(*this, expr); 2715651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines RegionCounter Cnt = getPGORegionCounter(expr); 27162c0c745709c9f258f4c968bcf3e891faa9acbca6Eli Friedman 271756ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall const Expr *condExpr = expr->getCond(); 2718c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner bool CondExprBool; 2719c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (ConstantFoldsToSimpleInteger(condExpr, CondExprBool)) { 272056ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall const Expr *live = expr->getTrueExpr(), *dead = expr->getFalseExpr(); 2721c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (!CondExprBool) std::swap(live, dead); 272256ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 2723651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines if (!ContainsLabel(dead)) { 2724651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // If the true case is live, we need to track its region. 2725651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines if (CondExprBool) 2726651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Cnt.beginRegion(Builder); 272756ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall return EmitLValue(live); 2728651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines } 2729f99a3915389109a716caafacb41fd9c4a3b8f432John McCall } 2730f99a3915389109a716caafacb41fd9c4a3b8f432John McCall 273156ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall llvm::BasicBlock *lhsBlock = createBasicBlock("cond.true"); 273256ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall llvm::BasicBlock *rhsBlock = createBasicBlock("cond.false"); 273356ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall llvm::BasicBlock *contBlock = createBasicBlock("cond.end"); 2734150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 2735f99a3915389109a716caafacb41fd9c4a3b8f432John McCall ConditionalEvaluation eval(*this); 2736651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines EmitBranchOnBoolExpr(condExpr, lhsBlock, rhsBlock, Cnt.getCount()); 27371cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 2738f99a3915389109a716caafacb41fd9c4a3b8f432John McCall // Any temporaries created here are conditional. 273956ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall EmitBlock(lhsBlock); 2740651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Cnt.beginRegion(Builder); 2741f99a3915389109a716caafacb41fd9c4a3b8f432John McCall eval.begin(*this); 2742ef8225444452a1486bd721f3285301fe84643b00Stephen Hines Optional<LValue> lhs = 2743ef8225444452a1486bd721f3285301fe84643b00Stephen Hines EmitLValueOrThrowExpression(*this, expr->getTrueExpr()); 2744f99a3915389109a716caafacb41fd9c4a3b8f432John McCall eval.end(*this); 27451cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 2746ef8225444452a1486bd721f3285301fe84643b00Stephen Hines if (lhs && !lhs->isSimple()) 274756ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall return EmitUnsupportedLValue(expr, "conditional operator"); 27486fcec8b58d0571866fcb162db947b029cc539ec4Anders Carlsson 274956ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall lhsBlock = Builder.GetInsertBlock(); 2750ef8225444452a1486bd721f3285301fe84643b00Stephen Hines if (lhs) 2751ef8225444452a1486bd721f3285301fe84643b00Stephen Hines Builder.CreateBr(contBlock); 27521cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 2753f99a3915389109a716caafacb41fd9c4a3b8f432John McCall // Any temporaries created here are conditional. 275456ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall EmitBlock(rhsBlock); 2755f99a3915389109a716caafacb41fd9c4a3b8f432John McCall eval.begin(*this); 2756ef8225444452a1486bd721f3285301fe84643b00Stephen Hines Optional<LValue> rhs = 2757ef8225444452a1486bd721f3285301fe84643b00Stephen Hines EmitLValueOrThrowExpression(*this, expr->getFalseExpr()); 2758f99a3915389109a716caafacb41fd9c4a3b8f432John McCall eval.end(*this); 2759ef8225444452a1486bd721f3285301fe84643b00Stephen Hines if (rhs && !rhs->isSimple()) 276056ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall return EmitUnsupportedLValue(expr, "conditional operator"); 276156ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall rhsBlock = Builder.GetInsertBlock(); 2762f99a3915389109a716caafacb41fd9c4a3b8f432John McCall 276356ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall EmitBlock(contBlock); 2764f99a3915389109a716caafacb41fd9c4a3b8f432John McCall 2765ef8225444452a1486bd721f3285301fe84643b00Stephen Hines if (lhs && rhs) { 2766ef8225444452a1486bd721f3285301fe84643b00Stephen Hines llvm::PHINode *phi = Builder.CreatePHI(lhs->getAddress()->getType(), 2767ef8225444452a1486bd721f3285301fe84643b00Stephen Hines 2, "cond-lvalue"); 2768ef8225444452a1486bd721f3285301fe84643b00Stephen Hines phi->addIncoming(lhs->getAddress(), lhsBlock); 2769ef8225444452a1486bd721f3285301fe84643b00Stephen Hines phi->addIncoming(rhs->getAddress(), rhsBlock); 2770ef8225444452a1486bd721f3285301fe84643b00Stephen Hines return MakeAddrLValue(phi, expr->getType()); 2771ef8225444452a1486bd721f3285301fe84643b00Stephen Hines } else { 2772ef8225444452a1486bd721f3285301fe84643b00Stephen Hines assert((lhs || rhs) && 2773ef8225444452a1486bd721f3285301fe84643b00Stephen Hines "both operands of glvalue conditional are throw-expressions?"); 2774ef8225444452a1486bd721f3285301fe84643b00Stephen Hines return lhs ? *lhs : *rhs; 2775ef8225444452a1486bd721f3285301fe84643b00Stephen Hines } 27769034558f2f9ac1dc6bd2e74f4481ca62fce28718Daniel Dunbar} 27779034558f2f9ac1dc6bd2e74f4481ca62fce28718Daniel Dunbar 277813ec9100ca6bc03b5ce8832e4a0fcb724d47bcb1Richard Smith/// EmitCastLValue - Casts are never lvalues unless that cast is to a reference 277913ec9100ca6bc03b5ce8832e4a0fcb724d47bcb1Richard Smith/// type. If the cast is to a reference, we can have the usual lvalue result, 2780c849c052d6b4b70f2651c1969531861a5f230053Mike Stump/// otherwise if a cast is needed by the code generator in an lvalue context, 2781c849c052d6b4b70f2651c1969531861a5f230053Mike Stump/// then it must mean that we need the address of an aggregate in order to 278213ec9100ca6bc03b5ce8832e4a0fcb724d47bcb1Richard Smith/// access one of its members. This can happen for all the reasons that casts 2783c849c052d6b4b70f2651c1969531861a5f230053Mike Stump/// are permitted with aggregate result, including noop aggregate casts, and 2784c849c052d6b4b70f2651c1969531861a5f230053Mike Stump/// cast from scalar to union. 278575dfedaf702822c9e51a4f3c5d3ecf2d2ad99272Chris LattnerLValue CodeGenFunction::EmitCastLValue(const CastExpr *E) { 27860ee33cf81eb7e7e53a897efb772edf4d53af5bf1Anders Carlsson switch (E->getCastKind()) { 27872de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ToVoid: 27882de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_BitCast: 27892de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ArrayToPointerDecay: 27902de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_FunctionToPointerDecay: 27912de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_NullToMemberPointer: 2792404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall case CK_NullToPointer: 27932de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_IntegralToPointer: 27942de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_PointerToIntegral: 2795daa8e4e888758d55a7a759dd4a91b83921cef222John McCall case CK_PointerToBoolean: 27962de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_VectorSplat: 27972de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_IntegralCast: 2798daa8e4e888758d55a7a759dd4a91b83921cef222John McCall case CK_IntegralToBoolean: 27992de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_IntegralToFloating: 28002de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_FloatingToIntegral: 2801daa8e4e888758d55a7a759dd4a91b83921cef222John McCall case CK_FloatingToBoolean: 28022de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_FloatingCast: 28032bb5d00fcf71a7b4d478d478be778fff0494aff6John McCall case CK_FloatingRealToComplex: 2804f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_FloatingComplexToReal: 2805f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_FloatingComplexToBoolean: 28062bb5d00fcf71a7b4d478d478be778fff0494aff6John McCall case CK_FloatingComplexCast: 2807f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_FloatingComplexToIntegralComplex: 28082bb5d00fcf71a7b4d478d478be778fff0494aff6John McCall case CK_IntegralRealToComplex: 2809f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_IntegralComplexToReal: 2810f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_IntegralComplexToBoolean: 28112bb5d00fcf71a7b4d478d478be778fff0494aff6John McCall case CK_IntegralComplexCast: 2812f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_IntegralComplexToFloatingComplex: 28132de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_DerivedToBaseMemberPointer: 28142de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_BaseToDerivedMemberPointer: 28152de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_MemberPointerToBoolean: 28164d4e5c1ae83f4510caa486b3ad19de13048f9f04John McCall case CK_ReinterpretMemberPointer: 2817f85e193739c953358c865005855253af4f68a497John McCall case CK_AnyPointerToBlockPointerCast: 281833e56f3273457bfa22c7c50bc46cf5a18216863dJohn McCall case CK_ARCProduceObject: 281933e56f3273457bfa22c7c50bc46cf5a18216863dJohn McCall case CK_ARCConsumeObject: 282033e56f3273457bfa22c7c50bc46cf5a18216863dJohn McCall case CK_ARCReclaimReturnedObject: 28211cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper case CK_ARCExtendBlockObject: 28221d7bb6c8b5b8f98fe79607718441f6543de598f1Eli Friedman case CK_CopyAndAutoreleaseBlockObject: 2823651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines case CK_AddressSpaceConversion: 28241d7bb6c8b5b8f98fe79607718441f6543de598f1Eli Friedman return EmitUnsupportedLValue(E, "unexpected cast lvalue"); 28251d7bb6c8b5b8f98fe79607718441f6543de598f1Eli Friedman 28261d7bb6c8b5b8f98fe79607718441f6543de598f1Eli Friedman case CK_Dependent: 28271d7bb6c8b5b8f98fe79607718441f6543de598f1Eli Friedman llvm_unreachable("dependent cast kind in IR gen!"); 28281d7bb6c8b5b8f98fe79607718441f6543de598f1Eli Friedman 28291d7bb6c8b5b8f98fe79607718441f6543de598f1Eli Friedman case CK_BuiltinFnToFnPtr: 28301d7bb6c8b5b8f98fe79607718441f6543de598f1Eli Friedman llvm_unreachable("builtin functions are handled elsewhere"); 28311d7bb6c8b5b8f98fe79607718441f6543de598f1Eli Friedman 2832336d9df5e628279425344d754dc68047fa5b00a7Eli Friedman // These are never l-values; just use the aggregate emission code. 28331d7bb6c8b5b8f98fe79607718441f6543de598f1Eli Friedman case CK_NonAtomicToAtomic: 28341d7bb6c8b5b8f98fe79607718441f6543de598f1Eli Friedman case CK_AtomicToNonAtomic: 2835336d9df5e628279425344d754dc68047fa5b00a7Eli Friedman return EmitAggExprToLValue(E); 2836eaae78a6fbd762c0ac6e75fa6fdfa4d167ceb4f2Eli Friedman 2837575b374fdbfc2c2224fd3047ac11ffc4b8db9ae5Anders Carlsson case CK_Dynamic: { 2838c849c052d6b4b70f2651c1969531861a5f230053Mike Stump LValue LV = EmitLValue(E->getSubExpr()); 2839c849c052d6b4b70f2651c1969531861a5f230053Mike Stump llvm::Value *V = LV.getAddress(); 28406bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines const auto *DCE = cast<CXXDynamicCastExpr>(E); 28419f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar return MakeAddrLValue(EmitDynamicCast(V, DCE), E->getType()); 2842c849c052d6b4b70f2651c1969531861a5f230053Mike Stump } 2843c849c052d6b4b70f2651c1969531861a5f230053Mike Stump 28442de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ConstructorConversion: 28452de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_UserDefinedConversion: 28461d9b3b25f7ac0d0195bba6b507a684fe5e7943eeJohn McCall case CK_CPointerToObjCPointerCast: 28471d9b3b25f7ac0d0195bba6b507a684fe5e7943eeJohn McCall case CK_BlockPointerToObjCPointerCast: 28481d7bb6c8b5b8f98fe79607718441f6543de598f1Eli Friedman case CK_NoOp: 28491d7bb6c8b5b8f98fe79607718441f6543de598f1Eli Friedman case CK_LValueToRValue: 285075dfedaf702822c9e51a4f3c5d3ecf2d2ad99272Chris Lattner return EmitLValue(E->getSubExpr()); 28511cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 28522de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_UncheckedDerivedToBase: 28532de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_DerivedToBase: { 28541cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper const RecordType *DerivedClassTy = 28550ee33cf81eb7e7e53a897efb772edf4d53af5bf1Anders Carlsson E->getSubExpr()->getType()->getAs<RecordType>(); 28566bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines auto *DerivedClassDecl = cast<CXXRecordDecl>(DerivedClassTy->getDecl()); 28571cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 28580ee33cf81eb7e7e53a897efb772edf4d53af5bf1Anders Carlsson LValue LV = EmitLValue(E->getSubExpr()); 28590e800c9c20d1a658a91096c756c4a4a9e90264fcJohn McCall llvm::Value *This = LV.getAddress(); 28601cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 28610ee33cf81eb7e7e53a897efb772edf4d53af5bf1Anders Carlsson // Perform the derived-to-base conversion 28621cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper llvm::Value *Base = 28631cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper GetAddressOfBaseClass(This, DerivedClassDecl, 2864f871d0cc377a1367b519a6cce26be74607566ebaJohn McCall E->path_begin(), E->path_end(), 2865f871d0cc377a1367b519a6cce26be74607566ebaJohn McCall /*NullCheckValue=*/false); 28661cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 28679f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar return MakeAddrLValue(Base, E->getType()); 28680ee33cf81eb7e7e53a897efb772edf4d53af5bf1Anders Carlsson } 28692de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ToUnion: 2870b2cd777d4885b5b863863f892cef85b4884ee677Daniel Dunbar return EmitAggExprToLValue(E); 28712de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_BaseToDerived: { 2872a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson const RecordType *DerivedClassTy = E->getType()->getAs<RecordType>(); 28736bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines auto *DerivedClassDecl = cast<CXXRecordDecl>(DerivedClassTy->getDecl()); 28741cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 2875a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson LValue LV = EmitLValue(E->getSubExpr()); 2876c764830bdb6de82baed068889096bd3e52d4cbdaRichard Smith 2877a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson // Perform the base-to-derived conversion 28781cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper llvm::Value *Derived = 28791cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper GetAddressOfDerivedClass(LV.getAddress(), DerivedClassDecl, 2880f871d0cc377a1367b519a6cce26be74607566ebaJohn McCall E->path_begin(), E->path_end(), 2881f871d0cc377a1367b519a6cce26be74607566ebaJohn McCall /*NullCheckValue=*/false); 28821cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 28838593e7821c02bd429964d2daf7a6acccb8040fb2Filipe Cabecinhas // C++11 [expr.static.cast]p2: Behavior is undefined if a downcast is 28848593e7821c02bd429964d2daf7a6acccb8040fb2Filipe Cabecinhas // performed and the object is not of the derived type. 2885ef8225444452a1486bd721f3285301fe84643b00Stephen Hines if (sanitizePerformTypeCheck()) 28868593e7821c02bd429964d2daf7a6acccb8040fb2Filipe Cabecinhas EmitTypeCheck(TCK_DowncastReference, E->getExprLoc(), 28878593e7821c02bd429964d2daf7a6acccb8040fb2Filipe Cabecinhas Derived, E->getType()); 28888593e7821c02bd429964d2daf7a6acccb8040fb2Filipe Cabecinhas 28899f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar return MakeAddrLValue(Derived, E->getType()); 2890eaae78a6fbd762c0ac6e75fa6fdfa4d167ceb4f2Eli Friedman } 28912de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_LValueBitCast: { 2892eaae78a6fbd762c0ac6e75fa6fdfa4d167ceb4f2Eli Friedman // This must be a reinterpret_cast (or c-style equivalent). 28936bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines const auto *CE = cast<ExplicitCastExpr>(E); 28941cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 2895658e8123a80d0e62f227a0c1532f2a4f106b3e73Anders Carlsson LValue LV = EmitLValue(E->getSubExpr()); 2896658e8123a80d0e62f227a0c1532f2a4f106b3e73Anders Carlsson llvm::Value *V = Builder.CreateBitCast(LV.getAddress(), 2897658e8123a80d0e62f227a0c1532f2a4f106b3e73Anders Carlsson ConvertType(CE->getTypeAsWritten())); 28989f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar return MakeAddrLValue(V, E->getType()); 2899658e8123a80d0e62f227a0c1532f2a4f106b3e73Anders Carlsson } 29002de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ObjCObjectLValueCast: { 2901569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor LValue LV = EmitLValue(E->getSubExpr()); 2902569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor QualType ToType = getContext().getLValueReferenceType(E->getType()); 29031cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper llvm::Value *V = Builder.CreateBitCast(LV.getAddress(), 2904569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor ConvertType(ToType)); 29059f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar return MakeAddrLValue(V, E->getType()); 2906569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor } 2907e6b9d802fb7b16d93474c4f1c179ab36202e8a8bGuy Benyei case CK_ZeroToOCLEvent: 2908e6b9d802fb7b16d93474c4f1c179ab36202e8a8bGuy Benyei llvm_unreachable("NULL to OpenCL event lvalue cast is not valid"); 29090ee33cf81eb7e7e53a897efb772edf4d53af5bf1Anders Carlsson } 29101cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 29117c7a79303b62f51c1ff02f9ce41d81211a69d3b4Douglas Gregor llvm_unreachable("Unhandled lvalue cast kind?"); 291275dfedaf702822c9e51a4f3c5d3ecf2d2ad99272Chris Lattner} 291375dfedaf702822c9e51a4f3c5d3ecf2d2ad99272Chris Lattner 2914e996ffd240f20a1048179d7727a6ee3227261921John McCallLValue CodeGenFunction::EmitOpaqueValueLValue(const OpaqueValueExpr *e) { 2915a5493f885095bd63d525a7035ad1c224de3ae5f2John McCall assert(OpaqueValueMappingData::shouldBindAsLValue(e)); 291656ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall return getOpaqueLValueMapping(e); 2917e996ffd240f20a1048179d7727a6ee3227261921John McCall} 2918e996ffd240f20a1048179d7727a6ee3227261921John McCall 2919377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli FriedmanRValue CodeGenFunction::EmitRValueForField(LValue LV, 29204ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky const FieldDecl *FD, 29214ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky SourceLocation Loc) { 2922eaf856db5d1a272dc7188937206ef4572836f82aAnton Korobeynikov QualType FT = FD->getType(); 2923377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman LValue FieldLV = EmitLValueForField(LV, FD); 29249d232c884ea9872d6555df0fd7359699819bc1f1John McCall switch (getEvaluationKind(FT)) { 29259d232c884ea9872d6555df0fd7359699819bc1f1John McCall case TEK_Complex: 29264ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky return RValue::getComplex(EmitLoadOfComplex(FieldLV, Loc)); 29279d232c884ea9872d6555df0fd7359699819bc1f1John McCall case TEK_Aggregate: 2928377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman return FieldLV.asAggregateRValue(); 29299d232c884ea9872d6555df0fd7359699819bc1f1John McCall case TEK_Scalar: 29304ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky return EmitLoadOfLValue(FieldLV, Loc); 29319d232c884ea9872d6555df0fd7359699819bc1f1John McCall } 29329d232c884ea9872d6555df0fd7359699819bc1f1John McCall llvm_unreachable("bad evaluation kind"); 2933eaf856db5d1a272dc7188937206ef4572836f82aAnton Korobeynikov} 293403e80030515c800d1ab44125b9052dfffd1bd04cDouglas Gregor 29355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===--------------------------------------------------------------------===// 29365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Expression Emission 29375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===--------------------------------------------------------------------===// 29385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 29391cc87df9747f31d1b300a29920aa8b62144b7bb2Craig TopperRValue CodeGenFunction::EmitCallExpr(const CallExpr *E, 2940d2490a91341b57df7a7e54f8a707e7ecde2eeb4eAnders Carlsson ReturnValueSlot ReturnValue) { 294100df5eaa9f4f7cc0809fd47c95311b532fbe63c6Adrian Prantl if (CGDebugInfo *DI = getDebugInfo()) { 294200df5eaa9f4f7cc0809fd47c95311b532fbe63c6Adrian Prantl SourceLocation Loc = E->getLocStart(); 29436b6a9b3f7b54e1df0976027ab623bafa3d769638Adrian Prantl // Force column info to be generated so we can differentiate 29446b6a9b3f7b54e1df0976027ab623bafa3d769638Adrian Prantl // multiple call sites on the same line in the debug info. 29456bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines // FIXME: This is insufficient. Two calls coming from the same macro 29466bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines // expansion will still get the same line/column and break debug info. It's 29476bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines // possible that LLVM can be fixed to not rely on this uniqueness, at which 29486bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines // point this workaround can be removed. 29496b6a9b3f7b54e1df0976027ab623bafa3d769638Adrian Prantl const FunctionDecl* Callee = E->getDirectCallee(); 29506b6a9b3f7b54e1df0976027ab623bafa3d769638Adrian Prantl bool ForceColumnInfo = Callee && Callee->isInlineSpecified(); 29516b6a9b3f7b54e1df0976027ab623bafa3d769638Adrian Prantl DI->EmitLocation(Builder, Loc, ForceColumnInfo); 295200df5eaa9f4f7cc0809fd47c95311b532fbe63c6Adrian Prantl } 295379bfb4b564dc3636aae15aafa6340f9430881121Devang Patel 2954c0ef9f59937c3971c48b6fed37cf5bd8985c024bDaniel Dunbar // Builtins never have block type. 2955c0ef9f59937c3971c48b6fed37cf5bd8985c024bDaniel Dunbar if (E->getCallee()->getType()->isBlockPointerType()) 2956a1736c0c750d4514a5d8fda36670addf1e4de54aAnders Carlsson return EmitBlockCallExpr(E, ReturnValue); 2957c0ef9f59937c3971c48b6fed37cf5bd8985c024bDaniel Dunbar 29586bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *CE = dyn_cast<CXXMemberCallExpr>(E)) 2959a1736c0c750d4514a5d8fda36670addf1e4de54aAnders Carlsson return EmitCXXMemberCallExpr(CE, ReturnValue); 2960db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 29616bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *CE = dyn_cast<CUDAKernelCallExpr>(E)) 29626c0aa5ff6e6253db0f993053599e2a52b5b93b2dPeter Collingbourne return EmitCUDAKernelCallExpr(CE, ReturnValue); 29636c0aa5ff6e6253db0f993053599e2a52b5b93b2dPeter Collingbourne 29641ddc9c4674b7c737ec65241a531df8c64e40b0a9Douglas Gregor const Decl *TargetDecl = E->getCalleeDecl(); 29651ddc9c4674b7c737ec65241a531df8c64e40b0a9Douglas Gregor if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(TargetDecl)) { 29661ddc9c4674b7c737ec65241a531df8c64e40b0a9Douglas Gregor if (unsigned builtinID = FD->getBuiltinID()) 29671ddc9c4674b7c737ec65241a531df8c64e40b0a9Douglas Gregor return EmitBuiltinExpr(FD, builtinID, E); 2968c0ef9f59937c3971c48b6fed37cf5bd8985c024bDaniel Dunbar } 2969ce1d38b8163650e473d7084e0686ed5a7956057bDaniel Dunbar 29706bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *CE = dyn_cast<CXXOperatorCallExpr>(E)) 29710f294632f36459174199b77699e339715244b5abAnders Carlsson if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(TargetDecl)) 2972a1736c0c750d4514a5d8fda36670addf1e4de54aAnders Carlsson return EmitCXXOperatorMemberCallExpr(CE, MD, ReturnValue); 2973db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 29746bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *PseudoDtor = 29756bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines dyn_cast<CXXPseudoDestructorExpr>(E->getCallee()->IgnoreParens())) { 2976f85e193739c953358c865005855253af4f68a497John McCall QualType DestroyedType = PseudoDtor->getDestroyedType(); 29777edf9e38b91917b661277601c0e448eef0eb2b56Richard Smith if (getLangOpts().ObjCAutoRefCount && 2978f85e193739c953358c865005855253af4f68a497John McCall DestroyedType->isObjCLifetimeType() && 2979f85e193739c953358c865005855253af4f68a497John McCall (DestroyedType.getObjCLifetime() == Qualifiers::OCL_Strong || 2980f85e193739c953358c865005855253af4f68a497John McCall DestroyedType.getObjCLifetime() == Qualifiers::OCL_Weak)) { 2981d510fd2dde3cd0fdda9b87772adbfb0d7d26a551Benjamin Kramer // Automatic Reference Counting: 2982d510fd2dde3cd0fdda9b87772adbfb0d7d26a551Benjamin Kramer // If the pseudo-expression names a retainable object with weak or 2983d510fd2dde3cd0fdda9b87772adbfb0d7d26a551Benjamin Kramer // strong lifetime, the object shall be released. 2984f85e193739c953358c865005855253af4f68a497John McCall Expr *BaseExpr = PseudoDtor->getBase(); 29856bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines llvm::Value *BaseValue = nullptr; 2986f85e193739c953358c865005855253af4f68a497John McCall Qualifiers BaseQuals; 29871cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 2988d510fd2dde3cd0fdda9b87772adbfb0d7d26a551Benjamin Kramer // If this is s.x, emit s as an lvalue. If it is s->x, emit s as a scalar. 2989f85e193739c953358c865005855253af4f68a497John McCall if (PseudoDtor->isArrow()) { 2990f85e193739c953358c865005855253af4f68a497John McCall BaseValue = EmitScalarExpr(BaseExpr); 2991f85e193739c953358c865005855253af4f68a497John McCall const PointerType *PTy = BaseExpr->getType()->getAs<PointerType>(); 2992f85e193739c953358c865005855253af4f68a497John McCall BaseQuals = PTy->getPointeeType().getQualifiers(); 2993f85e193739c953358c865005855253af4f68a497John McCall } else { 2994f85e193739c953358c865005855253af4f68a497John McCall LValue BaseLV = EmitLValue(BaseExpr); 2995f85e193739c953358c865005855253af4f68a497John McCall BaseValue = BaseLV.getAddress(); 2996f85e193739c953358c865005855253af4f68a497John McCall QualType BaseTy = BaseExpr->getType(); 2997f85e193739c953358c865005855253af4f68a497John McCall BaseQuals = BaseTy.getQualifiers(); 2998f85e193739c953358c865005855253af4f68a497John McCall } 29991cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 3000f85e193739c953358c865005855253af4f68a497John McCall switch (PseudoDtor->getDestroyedType().getObjCLifetime()) { 3001f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_None: 3002f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_ExplicitNone: 3003f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_Autoreleasing: 3004f85e193739c953358c865005855253af4f68a497John McCall break; 30051cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 3006f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_Strong: 30071cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper EmitARCRelease(Builder.CreateLoad(BaseValue, 3008d510fd2dde3cd0fdda9b87772adbfb0d7d26a551Benjamin Kramer PseudoDtor->getDestroyedType().isVolatileQualified()), 30095b07e8077a20b80fee90bd76c43c6150c676e4a8John McCall ARCPreciseLifetime); 3010f85e193739c953358c865005855253af4f68a497John McCall break; 3011f85e193739c953358c865005855253af4f68a497John McCall 3012f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_Weak: 3013f85e193739c953358c865005855253af4f68a497John McCall EmitARCDestroyWeak(BaseValue); 3014f85e193739c953358c865005855253af4f68a497John McCall break; 3015f85e193739c953358c865005855253af4f68a497John McCall } 3016f85e193739c953358c865005855253af4f68a497John McCall } else { 3017f85e193739c953358c865005855253af4f68a497John McCall // C++ [expr.pseudo]p1: 3018f85e193739c953358c865005855253af4f68a497John McCall // The result shall only be used as the operand for the function call 3019f85e193739c953358c865005855253af4f68a497John McCall // operator (), and the result of such a call has type void. The only 3020f85e193739c953358c865005855253af4f68a497John McCall // effect is the evaluation of the postfix-expression before the dot or 30211cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper // arrow. 3022f85e193739c953358c865005855253af4f68a497John McCall EmitScalarExpr(E->getCallee()); 3023f85e193739c953358c865005855253af4f68a497John McCall } 30241cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 30256bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return RValue::get(nullptr); 3026a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor } 3027db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 30287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner llvm::Value *Callee = EmitScalarExpr(E->getCallee()); 3029b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne return EmitCall(E->getCallee()->getType(), Callee, E->getLocStart(), 3030b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne ReturnValue, E->arg_begin(), E->arg_end(), TargetDecl); 3031c5e940fa551840ecd71e8116c316c9131490f5faChris Lattner} 3032c5e940fa551840ecd71e8116c316c9131490f5faChris Lattner 303380e62c29fe21cd06c93eba6e72b7e32dca06fcf9Daniel DunbarLValue CodeGenFunction::EmitBinaryOperatorLValue(const BinaryOperator *E) { 30347a574ccd5247189693e0764bf1f5711d33ca6064Chris Lattner // Comma expressions just emit their LHS then their RHS as an l-value. 30352de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (E->getOpcode() == BO_Comma) { 30362a41637a995affa1563f4d82a8b026e326a2faa0John McCall EmitIgnoredExpr(E->getLHS()); 3037130c69e969a785ff3be9e909f8eba7f89e42ac10Eli Friedman EnsureInsertPoint(); 30387a574ccd5247189693e0764bf1f5711d33ca6064Chris Lattner return EmitLValue(E->getRHS()); 30397a574ccd5247189693e0764bf1f5711d33ca6064Chris Lattner } 3040db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 30412de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (E->getOpcode() == BO_PtrMemD || 30422de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall E->getOpcode() == BO_PtrMemI) 30438bfd31f9dad09cd52225d868bbd92a9bebe87775Fariborz Jahanian return EmitPointerToDataMemberBinaryExpr(E); 304480e62c29fe21cd06c93eba6e72b7e32dca06fcf9Daniel Dunbar 30452a41637a995affa1563f4d82a8b026e326a2faa0John McCall assert(E->getOpcode() == BO_Assign && "unexpected binary l-value"); 3046f85e193739c953358c865005855253af4f68a497John McCall 3047f85e193739c953358c865005855253af4f68a497John McCall // Note that in all of these cases, __block variables need the RHS 3048f85e193739c953358c865005855253af4f68a497John McCall // evaluated first just in case the variable gets moved by the RHS. 30499d232c884ea9872d6555df0fd7359699819bc1f1John McCall 30509d232c884ea9872d6555df0fd7359699819bc1f1John McCall switch (getEvaluationKind(E->getType())) { 30519d232c884ea9872d6555df0fd7359699819bc1f1John McCall case TEK_Scalar: { 3052f85e193739c953358c865005855253af4f68a497John McCall switch (E->getLHS()->getType().getObjCLifetime()) { 3053f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_Strong: 3054f85e193739c953358c865005855253af4f68a497John McCall return EmitARCStoreStrong(E, /*ignored*/ false).first; 3055f85e193739c953358c865005855253af4f68a497John McCall 3056f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_Autoreleasing: 3057f85e193739c953358c865005855253af4f68a497John McCall return EmitARCStoreAutoreleasing(E).first; 3058f85e193739c953358c865005855253af4f68a497John McCall 3059f85e193739c953358c865005855253af4f68a497John McCall // No reason to do any of these differently. 3060f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_None: 3061f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_ExplicitNone: 3062f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_Weak: 3063f85e193739c953358c865005855253af4f68a497John McCall break; 3064f85e193739c953358c865005855253af4f68a497John McCall } 3065f85e193739c953358c865005855253af4f68a497John McCall 3066cd940a1e13e588a43973cd7ae33b5c33a3062739John McCall RValue RV = EmitAnyExpr(E->getRHS()); 30674def70d3040e73707c738f7c366737a986135edfRichard Smith LValue LV = EmitCheckedLValue(E->getLHS(), TCK_Store); 3068545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall EmitStoreThroughLValue(RV, LV); 306986aa0cdfd5aa7b099efbcd612a014d1b5f0ff799Anders Carlsson return LV; 307086aa0cdfd5aa7b099efbcd612a014d1b5f0ff799Anders Carlsson } 307183ce9d4a552987d34cbd500e983db8d770232379John McCall 30729d232c884ea9872d6555df0fd7359699819bc1f1John McCall case TEK_Complex: 307383ce9d4a552987d34cbd500e983db8d770232379John McCall return EmitComplexAssignmentLValue(E); 307483ce9d4a552987d34cbd500e983db8d770232379John McCall 30759d232c884ea9872d6555df0fd7359699819bc1f1John McCall case TEK_Aggregate: 30769d232c884ea9872d6555df0fd7359699819bc1f1John McCall return EmitAggExprToLValue(E); 30779d232c884ea9872d6555df0fd7359699819bc1f1John McCall } 30789d232c884ea9872d6555df0fd7359699819bc1f1John McCall llvm_unreachable("bad evaluation kind"); 307980e62c29fe21cd06c93eba6e72b7e32dca06fcf9Daniel Dunbar} 308080e62c29fe21cd06c93eba6e72b7e32dca06fcf9Daniel Dunbar 308122c940ee588a420cd2e6c8f68be2ac3cc80061ffChristopher LambLValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) { 308222c940ee588a420cd2e6c8f68be2ac3cc80061ffChristopher Lamb RValue RV = EmitCallExpr(E); 3083482656833a71b63f67f3e93ee8c2d45b3d351ca8Anders Carlsson 3084eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner if (!RV.isScalar()) 30859f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar return MakeAddrLValue(RV.getAggregateAddr(), E->getType()); 30861cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 3087eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner assert(E->getCallReturnType()->isReferenceType() && 3088eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner "Can't have a scalar return unless the return type is a " 3089eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner "reference type!"); 3090db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 30919f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar return MakeAddrLValue(RV.getScalarVal(), E->getType()); 309222c940ee588a420cd2e6c8f68be2ac3cc80061ffChristopher Lamb} 309322c940ee588a420cd2e6c8f68be2ac3cc80061ffChristopher Lamb 30945b5c9ef865607e179413462dcd71bcebb5b7daaeDaniel DunbarLValue CodeGenFunction::EmitVAArgExprLValue(const VAArgExpr *E) { 30955b5c9ef865607e179413462dcd71bcebb5b7daaeDaniel Dunbar // FIXME: This shouldn't require another copy. 309618aba0dd518e486d8b50523e7dafb4b5657135d2Daniel Dunbar return EmitAggExprToLValue(E); 30975b5c9ef865607e179413462dcd71bcebb5b7daaeDaniel Dunbar} 30985b5c9ef865607e179413462dcd71bcebb5b7daaeDaniel Dunbar 3099b58d017f2b9eeed33f2ab3ede968b89cf5296bf2Anders CarlssonLValue CodeGenFunction::EmitCXXConstructLValue(const CXXConstructExpr *E) { 3100fc1e6c79bbfe0e9a58bb792996d51f42e36e3d6aJohn McCall assert(E->getType()->getAsCXXRecordDecl()->hasTrivialDestructor() 3101fc1e6c79bbfe0e9a58bb792996d51f42e36e3d6aJohn McCall && "binding l-value to type which needs a temporary"); 3102578faa837b552403e2002b97fdfbfde14f2448e5Benjamin Kramer AggValueSlot Slot = CreateAggTemp(E->getType()); 3103558d2abc7f9fd6801cc7677200992313ae90b5d8John McCall EmitCXXConstructExpr(E, Slot); 3104558d2abc7f9fd6801cc7677200992313ae90b5d8John McCall return MakeAddrLValue(Slot.getAddr(), E->getType()); 3105b58d017f2b9eeed33f2ab3ede968b89cf5296bf2Anders Carlsson} 3106b58d017f2b9eeed33f2ab3ede968b89cf5296bf2Anders Carlsson 3107e61c9e80a108b5db7e5f0e702f0e455d737c6390Anders CarlssonLValue 3108c2e84ae9a6d25cea3e583c768e576b4c981ec028Mike StumpCodeGenFunction::EmitCXXTypeidLValue(const CXXTypeidExpr *E) { 31099f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar return MakeAddrLValue(EmitCXXTypeidExpr(E), E->getType()); 3110c2e84ae9a6d25cea3e583c768e576b4c981ec028Mike Stump} 3111c2e84ae9a6d25cea3e583c768e576b4c981ec028Mike Stump 3112c5f804636e367ef744fd24cf88f7c956a5af0434Nico Weberllvm::Value *CodeGenFunction::EmitCXXUuidofExpr(const CXXUuidofExpr *E) { 31138effeda3d2cfd92abaebc5ac46fc3693c69f66f3David Majnemer return Builder.CreateBitCast(CGM.GetAddrOfUuidDescriptor(E), 31148effeda3d2cfd92abaebc5ac46fc3693c69f66f3David Majnemer ConvertType(E->getType())->getPointerTo()); 3115c5f804636e367ef744fd24cf88f7c956a5af0434Nico Weber} 3116c5f804636e367ef744fd24cf88f7c956a5af0434Nico Weber 3117c5f804636e367ef744fd24cf88f7c956a5af0434Nico WeberLValue CodeGenFunction::EmitCXXUuidofLValue(const CXXUuidofExpr *E) { 3118c5f804636e367ef744fd24cf88f7c956a5af0434Nico Weber return MakeAddrLValue(EmitCXXUuidofExpr(E), E->getType()); 3119c5f804636e367ef744fd24cf88f7c956a5af0434Nico Weber} 3120c5f804636e367ef744fd24cf88f7c956a5af0434Nico Weber 3121c2e84ae9a6d25cea3e583c768e576b4c981ec028Mike StumpLValue 3122e61c9e80a108b5db7e5f0e702f0e455d737c6390Anders CarlssonCodeGenFunction::EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E) { 3123fc1e6c79bbfe0e9a58bb792996d51f42e36e3d6aJohn McCall AggValueSlot Slot = CreateAggTemp(E->getType(), "temp.lvalue"); 3124fd71fb81c5f9382caf0131946e890b133e12ceb5John McCall Slot.setExternallyDestructed(); 3125fc1e6c79bbfe0e9a58bb792996d51f42e36e3d6aJohn McCall EmitAggExpr(E->getSubExpr(), Slot); 312686811609d9353e3aed198045d56e790eb3b6118cPeter Collingbourne EmitCXXTemporary(E->getTemporary(), E->getType(), Slot.getAddr()); 3127fc1e6c79bbfe0e9a58bb792996d51f42e36e3d6aJohn McCall return MakeAddrLValue(Slot.getAddr(), E->getType()); 3128e61c9e80a108b5db7e5f0e702f0e455d737c6390Anders Carlsson} 3129e61c9e80a108b5db7e5f0e702f0e455d737c6390Anders Carlsson 313031a3702618ab49578542cffee20ba0c8859b9d1eEli FriedmanLValue 313131a3702618ab49578542cffee20ba0c8859b9d1eEli FriedmanCodeGenFunction::EmitLambdaLValue(const LambdaExpr *E) { 313231a3702618ab49578542cffee20ba0c8859b9d1eEli Friedman AggValueSlot Slot = CreateAggTemp(E->getType(), "temp.lvalue"); 31334c5d8afd100189b6cce4fd89bfb8aec5700acb50Eli Friedman EmitLambdaExpr(E, Slot); 313431a3702618ab49578542cffee20ba0c8859b9d1eEli Friedman return MakeAddrLValue(Slot.getAddr(), E->getType()); 313531a3702618ab49578542cffee20ba0c8859b9d1eEli Friedman} 313631a3702618ab49578542cffee20ba0c8859b9d1eEli Friedman 31370a04d77bde7e3a661c2b41b60630d125d09ed6efDaniel DunbarLValue CodeGenFunction::EmitObjCMessageExprLValue(const ObjCMessageExpr *E) { 31380a04d77bde7e3a661c2b41b60630d125d09ed6efDaniel Dunbar RValue RV = EmitObjCMessageExpr(E); 31391cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 31407e70fb217dcdf96faf34df3e197c3831c86f8089Anders Carlsson if (!RV.isScalar()) 31419f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar return MakeAddrLValue(RV.getAggregateAddr(), E->getType()); 31421cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 3143651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines assert(E->getMethodDecl()->getReturnType()->isReferenceType() && 31447e70fb217dcdf96faf34df3e197c3831c86f8089Anders Carlsson "Can't have a scalar return unless the return type is a " 31457e70fb217dcdf96faf34df3e197c3831c86f8089Anders Carlsson "reference type!"); 31461cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper 31479f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar return MakeAddrLValue(RV.getScalarVal(), E->getType()); 31480a04d77bde7e3a661c2b41b60630d125d09ed6efDaniel Dunbar} 31490a04d77bde7e3a661c2b41b60630d125d09ed6efDaniel Dunbar 315003b2960c14aede6ac82bdef32247094ebb72fa69Fariborz JahanianLValue CodeGenFunction::EmitObjCSelectorLValue(const ObjCSelectorExpr *E) { 31511cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper llvm::Value *V = 3152bd7370a78604e9a20d698bfe328c1e43f12a0613John McCall CGM.getObjCRuntime().GetSelector(*this, E->getSelector(), true); 31539f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar return MakeAddrLValue(V, E->getType()); 315403b2960c14aede6ac82bdef32247094ebb72fa69Fariborz Jahanian} 315503b2960c14aede6ac82bdef32247094ebb72fa69Fariborz Jahanian 31562a03192a02dbf4fdff438d1e658356bde871aba4Daniel Dunbarllvm::Value *CodeGenFunction::EmitIvarOffset(const ObjCInterfaceDecl *Interface, 315729e0bccf2bcce22b877f8b2ed173f564c116b97eDaniel Dunbar const ObjCIvarDecl *Ivar) { 3158f63aa3fd429cdb9145d78f0b656bc78754efedb9Fariborz Jahanian return CGM.getObjCRuntime().EmitIvarOffset(*this, Interface, Ivar); 315929e0bccf2bcce22b877f8b2ed173f564c116b97eDaniel Dunbar} 316029b7e5071c4ac0979ba907d0db78f5bd7ff83fe8Anders Carlsson 316145012a7ef5abf1042c893f3f2fa5c23cb5485ea9Fariborz JahanianLValue CodeGenFunction::EmitLValueForIvar(QualType ObjectTy, 316245012a7ef5abf1042c893f3f2fa5c23cb5485ea9Fariborz Jahanian llvm::Value *BaseValue, 316329e0bccf2bcce22b877f8b2ed173f564c116b97eDaniel Dunbar const ObjCIvarDecl *Ivar, 316429e0bccf2bcce22b877f8b2ed173f564c116b97eDaniel Dunbar unsigned CVRQualifiers) { 316526f074b249b7b113c78fad22e80b0e03289aa7d2Chris Lattner return CGM.getObjCRuntime().EmitObjCValueForIvar(*this, ObjectTy, BaseValue, 3166525c9b7baeeff022127cd1b167579f3bda73b3edDaniel Dunbar Ivar, CVRQualifiers); 316729e0bccf2bcce22b877f8b2ed173f564c116b97eDaniel Dunbar} 316829e0bccf2bcce22b877f8b2ed173f564c116b97eDaniel Dunbar 316929e0bccf2bcce22b877f8b2ed173f564c116b97eDaniel DunbarLValue CodeGenFunction::EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E) { 317029b7e5071c4ac0979ba907d0db78f5bd7ff83fe8Anders Carlsson // FIXME: A lot of the code below could be shared with EmitMemberExpr. 31716bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines llvm::Value *BaseValue = nullptr; 317229b7e5071c4ac0979ba907d0db78f5bd7ff83fe8Anders Carlsson const Expr *BaseExpr = E->getBase(); 31730953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Qualifiers BaseQuals; 317445012a7ef5abf1042c893f3f2fa5c23cb5485ea9Fariborz Jahanian QualType ObjectTy; 317529b7e5071c4ac0979ba907d0db78f5bd7ff83fe8Anders Carlsson if (E->isArrow()) { 317629b7e5071c4ac0979ba907d0db78f5bd7ff83fe8Anders Carlsson BaseValue = EmitScalarExpr(BaseExpr); 317714108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff ObjectTy = BaseExpr->getType()->getPointeeType(); 31780953e767ff7817f97b3ab20896b229891eeff45bJohn McCall BaseQuals = ObjectTy.getQualifiers(); 317929b7e5071c4ac0979ba907d0db78f5bd7ff83fe8Anders Carlsson } else { 318029b7e5071c4ac0979ba907d0db78f5bd7ff83fe8Anders Carlsson LValue BaseLV = EmitLValue(BaseExpr); 318129b7e5071c4ac0979ba907d0db78f5bd7ff83fe8Anders Carlsson // FIXME: this isn't right for bitfields. 318229b7e5071c4ac0979ba907d0db78f5bd7ff83fe8Anders Carlsson BaseValue = BaseLV.getAddress(); 318345012a7ef5abf1042c893f3f2fa5c23cb5485ea9Fariborz Jahanian ObjectTy = BaseExpr->getType(); 31840953e767ff7817f97b3ab20896b229891eeff45bJohn McCall BaseQuals = ObjectTy.getQualifiers(); 318529b7e5071c4ac0979ba907d0db78f5bd7ff83fe8Anders Carlsson } 318629e0bccf2bcce22b877f8b2ed173f564c116b97eDaniel Dunbar 31871cc87df9747f31d1b300a29920aa8b62144b7bb2Craig Topper LValue LV = 31880953e767ff7817f97b3ab20896b229891eeff45bJohn McCall EmitLValueForIvar(ObjectTy, BaseValue, E->getDecl(), 31890953e767ff7817f97b3ab20896b229891eeff45bJohn McCall BaseQuals.getCVRQualifiers()); 3190dbf3cfd39dd5234f90235e263ba2ff4cc61258bdFariborz Jahanian setObjCGCLValueClass(getContext(), E, LV); 3191dbf3cfd39dd5234f90235e263ba2ff4cc61258bdFariborz Jahanian return LV; 3192391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner} 3193391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner 3194654599454c8e6cc83b1b9b3af43c49c2f66a26cbChris LattnerLValue CodeGenFunction::EmitStmtExprLValue(const StmtExpr *E) { 3195654599454c8e6cc83b1b9b3af43c49c2f66a26cbChris Lattner // Can only get l-value for message expression returning aggregate type 3196654599454c8e6cc83b1b9b3af43c49c2f66a26cbChris Lattner RValue RV = EmitAnyExprToTemp(E); 31979f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar return MakeAddrLValue(RV.getAggregateAddr(), E->getType()); 3198654599454c8e6cc83b1b9b3af43c49c2f66a26cbChris Lattner} 3199654599454c8e6cc83b1b9b3af43c49c2f66a26cbChris Lattner 320031777a2540879051a3c643b90e02c3fd3d315243Anders CarlssonRValue CodeGenFunction::EmitCall(QualType CalleeType, llvm::Value *Callee, 3201b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne SourceLocation CallLoc, 3202d2490a91341b57df7a7e54f8a707e7ecde2eeb4eAnders Carlsson ReturnValueSlot ReturnValue, 3203986477149db76e6d9f8d3c9859c9880c11b680aeAnders Carlsson CallExpr::const_arg_iterator ArgBeg, 3204986477149db76e6d9f8d3c9859c9880c11b680aeAnders Carlsson CallExpr::const_arg_iterator ArgEnd, 3205986477149db76e6d9f8d3c9859c9880c11b680aeAnders Carlsson const Decl *TargetDecl) { 3206db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Get the actual function type. The callee type will always be a pointer to 3207db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // function type or a block pointer type. 3208db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump assert(CalleeType->isFunctionPointerType() && 32098ac67a7725ef25f5df8a992277182f51316500e6Anders Carlsson "Call must have function pointer type!"); 32108ac67a7725ef25f5df8a992277182f51316500e6Anders Carlsson 321100a1ad9a34f1006d8729aa3fab4fb5f233ab5a55John McCall CalleeType = getContext().getCanonicalType(CalleeType); 321200a1ad9a34f1006d8729aa3fab4fb5f233ab5a55John McCall 32136bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines const auto *FnType = 32146bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines cast<FunctionType>(cast<PointerType>(CalleeType)->getPointeeType()); 321519cd87eb5fb3c197e631ce08fd52c446c4d4e8f1Daniel Dunbar 3216b0e603c63813c8378e35a75408ab4cefe71e93e2Adrian Prantl // Force column info to differentiate multiple inlined call sites on 3217b0e603c63813c8378e35a75408ab4cefe71e93e2Adrian Prantl // the same line, analoguous to EmitCallExpr. 32186bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines // FIXME: This is insufficient. Two calls coming from the same macro expansion 32196bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines // will still get the same line/column and break debug info. It's possible 32206bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines // that LLVM can be fixed to not rely on this uniqueness, at which point this 32216bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines // workaround can be removed. 3222b0e603c63813c8378e35a75408ab4cefe71e93e2Adrian Prantl bool ForceColumnInfo = false; 3223b0e603c63813c8378e35a75408ab4cefe71e93e2Adrian Prantl if (const FunctionDecl* FD = dyn_cast_or_null<const FunctionDecl>(TargetDecl)) 3224b0e603c63813c8378e35a75408ab4cefe71e93e2Adrian Prantl ForceColumnInfo = FD->isInlineSpecified(); 3225b0e603c63813c8378e35a75408ab4cefe71e93e2Adrian Prantl 3226b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne if (getLangOpts().CPlusPlus && SanOpts->Function && 3227b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne (!TargetDecl || !isa<FunctionDecl>(TargetDecl))) { 3228b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne if (llvm::Constant *PrefixSig = 3229b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne CGM.getTargetCodeGenInfo().getUBSanFunctionSignature(CGM)) { 3230b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne llvm::Constant *FTRTTIConst = 3231b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne CGM.GetAddrOfRTTIDescriptor(QualType(FnType, 0), /*ForEH=*/true); 3232b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne llvm::Type *PrefixStructTyElems[] = { 3233b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne PrefixSig->getType(), 3234b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne FTRTTIConst->getType() 3235b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne }; 3236b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne llvm::StructType *PrefixStructTy = llvm::StructType::get( 3237b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne CGM.getLLVMContext(), PrefixStructTyElems, /*isPacked=*/true); 3238b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne 3239b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne llvm::Value *CalleePrefixStruct = Builder.CreateBitCast( 3240b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne Callee, llvm::PointerType::getUnqual(PrefixStructTy)); 3241b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne llvm::Value *CalleeSigPtr = 3242b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne Builder.CreateConstGEP2_32(CalleePrefixStruct, 0, 0); 3243b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne llvm::Value *CalleeSig = Builder.CreateLoad(CalleeSigPtr); 3244b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne llvm::Value *CalleeSigMatch = Builder.CreateICmpEQ(CalleeSig, PrefixSig); 3245b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne 3246b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne llvm::BasicBlock *Cont = createBasicBlock("cont"); 3247b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne llvm::BasicBlock *TypeCheck = createBasicBlock("typecheck"); 3248b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne Builder.CreateCondBr(CalleeSigMatch, TypeCheck, Cont); 3249b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne 3250b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne EmitBlock(TypeCheck); 3251b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne llvm::Value *CalleeRTTIPtr = 3252b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne Builder.CreateConstGEP2_32(CalleePrefixStruct, 0, 1); 3253b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne llvm::Value *CalleeRTTI = Builder.CreateLoad(CalleeRTTIPtr); 3254b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne llvm::Value *CalleeRTTIMatch = 3255b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne Builder.CreateICmpEQ(CalleeRTTI, FTRTTIConst); 3256b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne llvm::Constant *StaticData[] = { 3257b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne EmitCheckSourceLocation(CallLoc), 3258b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne EmitCheckTypeDescriptor(CalleeType) 3259b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne }; 3260b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne EmitCheck(CalleeRTTIMatch, 3261b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne "function_type_mismatch", 3262b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne StaticData, 3263b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne Callee, 3264b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne CRK_Recoverable); 3265b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne 3266b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne Builder.CreateBr(Cont); 3267b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne EmitBlock(Cont); 3268b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne } 3269b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne } 3270b914e87377fd4d7642f544000a79f8648c6f06c9Peter Collingbourne 327119cd87eb5fb3c197e631ce08fd52c446c4d4e8f1Daniel Dunbar CallArgList Args; 3272b0e603c63813c8378e35a75408ab4cefe71e93e2Adrian Prantl EmitCallArgs(Args, dyn_cast<FunctionProtoType>(FnType), ArgBeg, ArgEnd, 3273b0e603c63813c8378e35a75408ab4cefe71e93e2Adrian Prantl ForceColumnInfo); 327419cd87eb5fb3c197e631ce08fd52c446c4d4e8f1Daniel Dunbar 3275de5d3c717684f3821b8db58037bc7140acf134aaJohn McCall const CGFunctionInfo &FnInfo = 32760f3d0970dcdf6cf17550b86838dff12813968dbcJohn McCall CGM.getTypes().arrangeFreeFunctionCall(Args, FnType); 327701f151e0ffba72bcad770bea5f563a9b68ca050eJohn McCall 327801f151e0ffba72bcad770bea5f563a9b68ca050eJohn McCall // C99 6.5.2.2p6: 327901f151e0ffba72bcad770bea5f563a9b68ca050eJohn McCall // If the expression that denotes the called function has a type 328001f151e0ffba72bcad770bea5f563a9b68ca050eJohn McCall // that does not include a prototype, [the default argument 328101f151e0ffba72bcad770bea5f563a9b68ca050eJohn McCall // promotions are performed]. If the number of arguments does not 328201f151e0ffba72bcad770bea5f563a9b68ca050eJohn McCall // equal the number of parameters, the behavior is undefined. If 328301f151e0ffba72bcad770bea5f563a9b68ca050eJohn McCall // the function is defined with a type that includes a prototype, 328401f151e0ffba72bcad770bea5f563a9b68ca050eJohn McCall // and either the prototype ends with an ellipsis (, ...) or the 328501f151e0ffba72bcad770bea5f563a9b68ca050eJohn McCall // types of the arguments after promotion are not compatible with 328601f151e0ffba72bcad770bea5f563a9b68ca050eJohn McCall // the types of the parameters, the behavior is undefined. If the 328701f151e0ffba72bcad770bea5f563a9b68ca050eJohn McCall // function is defined with a type that does not include a 328801f151e0ffba72bcad770bea5f563a9b68ca050eJohn McCall // prototype, and the types of the arguments after promotion are 328901f151e0ffba72bcad770bea5f563a9b68ca050eJohn McCall // not compatible with those of the parameters after promotion, 329001f151e0ffba72bcad770bea5f563a9b68ca050eJohn McCall // the behavior is undefined [except in some trivial cases]. 329101f151e0ffba72bcad770bea5f563a9b68ca050eJohn McCall // That is, in the general case, we should assume that a call 329201f151e0ffba72bcad770bea5f563a9b68ca050eJohn McCall // through an unprototyped function type works like a *non-variadic* 329301f151e0ffba72bcad770bea5f563a9b68ca050eJohn McCall // call. The way we make this work is to cast to the exact type 329401f151e0ffba72bcad770bea5f563a9b68ca050eJohn McCall // of the promoted arguments. 3295e56bb36e8eea89bae7dfe6eb6ea0455af126bf4aJohn McCall if (isa<FunctionNoProtoType>(FnType)) { 3296de5d3c717684f3821b8db58037bc7140acf134aaJohn McCall llvm::Type *CalleeTy = getTypes().GetFunctionType(FnInfo); 329701f151e0ffba72bcad770bea5f563a9b68ca050eJohn McCall CalleeTy = CalleeTy->getPointerTo(); 329801f151e0ffba72bcad770bea5f563a9b68ca050eJohn McCall Callee = Builder.CreateBitCast(Callee, CalleeTy, "callee.knr.cast"); 329901f151e0ffba72bcad770bea5f563a9b68ca050eJohn McCall } 330001f151e0ffba72bcad770bea5f563a9b68ca050eJohn McCall 330101f151e0ffba72bcad770bea5f563a9b68ca050eJohn McCall return EmitCall(FnInfo, Callee, ReturnValue, Args, TargetDecl); 33028f2926b73ed635afecd020da787af6a837601a2bDaniel Dunbar} 33038bfd31f9dad09cd52225d868bbd92a9bebe87775Fariborz Jahanian 3304eb99b0189710d996216df7d485f11939e9f1c842Chris LattnerLValue CodeGenFunction:: 3305eb99b0189710d996216df7d485f11939e9f1c842Chris LattnerEmitPointerToDataMemberBinaryExpr(const BinaryOperator *E) { 33061c5c1a09a4a224c5c01f0a2a0d69224c8356f0beEli Friedman llvm::Value *BaseV; 33072de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (E->getOpcode() == BO_PtrMemI) 33081c5c1a09a4a224c5c01f0a2a0d69224c8356f0beEli Friedman BaseV = EmitScalarExpr(E->getLHS()); 33091c5c1a09a4a224c5c01f0a2a0d69224c8356f0beEli Friedman else 33101c5c1a09a4a224c5c01f0a2a0d69224c8356f0beEli Friedman BaseV = EmitLValue(E->getLHS()).getAddress(); 33116c2ab1d578c6cc1f3ddcc948532cd625f1092ef2John McCall 33121c5c1a09a4a224c5c01f0a2a0d69224c8356f0beEli Friedman llvm::Value *OffsetV = EmitScalarExpr(E->getRHS()); 3313eb99b0189710d996216df7d485f11939e9f1c842Chris Lattner 33146c2ab1d578c6cc1f3ddcc948532cd625f1092ef2John McCall const MemberPointerType *MPT 33156c2ab1d578c6cc1f3ddcc948532cd625f1092ef2John McCall = E->getRHS()->getType()->getAs<MemberPointerType>(); 33166c2ab1d578c6cc1f3ddcc948532cd625f1092ef2John McCall 3317651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines llvm::Value *AddV = CGM.getCXXABI().EmitMemberDataPointerAddress( 3318651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines *this, E, BaseV, OffsetV, MPT); 33196c2ab1d578c6cc1f3ddcc948532cd625f1092ef2John McCall 33206c2ab1d578c6cc1f3ddcc948532cd625f1092ef2John McCall return MakeAddrLValue(AddV, MPT->getPointeeType()); 33218bfd31f9dad09cd52225d868bbd92a9bebe87775Fariborz Jahanian} 3322276b061970939293f1abaf694bd3ef05b2cbda79Eli Friedman 33239d232c884ea9872d6555df0fd7359699819bc1f1John McCall/// Given the address of a temporary variable, produce an r-value of 33249d232c884ea9872d6555df0fd7359699819bc1f1John McCall/// its type. 33259d232c884ea9872d6555df0fd7359699819bc1f1John McCallRValue CodeGenFunction::convertTempToRValue(llvm::Value *addr, 33264ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky QualType type, 33274ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky SourceLocation loc) { 33289d232c884ea9872d6555df0fd7359699819bc1f1John McCall LValue lvalue = MakeNaturalAlignAddrLValue(addr, type); 33299d232c884ea9872d6555df0fd7359699819bc1f1John McCall switch (getEvaluationKind(type)) { 33309d232c884ea9872d6555df0fd7359699819bc1f1John McCall case TEK_Complex: 33314ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky return RValue::getComplex(EmitLoadOfComplex(lvalue, loc)); 33329d232c884ea9872d6555df0fd7359699819bc1f1John McCall case TEK_Aggregate: 33339d232c884ea9872d6555df0fd7359699819bc1f1John McCall return lvalue.asAggregateRValue(); 33349d232c884ea9872d6555df0fd7359699819bc1f1John McCall case TEK_Scalar: 33354ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky return RValue::get(EmitLoadOfScalar(lvalue, loc)); 33369d232c884ea9872d6555df0fd7359699819bc1f1John McCall } 33379d232c884ea9872d6555df0fd7359699819bc1f1John McCall llvm_unreachable("bad evaluation kind"); 3338276b061970939293f1abaf694bd3ef05b2cbda79Eli Friedman} 3339276b061970939293f1abaf694bd3ef05b2cbda79Eli Friedman 33408250016fb9491fcfde7fce05230d66e267944484Duncan Sandsvoid CodeGenFunction::SetFPAccuracy(llvm::Value *Val, float Accuracy) { 3341c5096cbf7a42e0f9012945b00d9037a5b5a88d72Peter Collingbourne assert(Val->getType()->isFPOrFPVectorTy()); 33428250016fb9491fcfde7fce05230d66e267944484Duncan Sands if (Accuracy == 0.0 || !isa<llvm::Instruction>(Val)) 3343c5096cbf7a42e0f9012945b00d9037a5b5a88d72Peter Collingbourne return; 3344c5096cbf7a42e0f9012945b00d9037a5b5a88d72Peter Collingbourne 334560c77079d4767133a587c1c9390f2f5fd43fba9fDuncan Sands llvm::MDBuilder MDHelper(getLLVMContext()); 334660c77079d4767133a587c1c9390f2f5fd43fba9fDuncan Sands llvm::MDNode *Node = MDHelper.createFPMath(Accuracy); 3347c5096cbf7a42e0f9012945b00d9037a5b5a88d72Peter Collingbourne 33489bb1d34e34e3a428d8fb9a20922a1000ad42fd0cDuncan Sands cast<llvm::Instruction>(Val)->setMetadata(llvm::LLVMContext::MD_fpmath, Node); 3349c5096cbf7a42e0f9012945b00d9037a5b5a88d72Peter Collingbourne} 33504b9c2d235fb9449e249d74f48ecfec601650de93John McCall 33514b9c2d235fb9449e249d74f48ecfec601650de93John McCallnamespace { 33524b9c2d235fb9449e249d74f48ecfec601650de93John McCall struct LValueOrRValue { 33534b9c2d235fb9449e249d74f48ecfec601650de93John McCall LValue LV; 33544b9c2d235fb9449e249d74f48ecfec601650de93John McCall RValue RV; 33554b9c2d235fb9449e249d74f48ecfec601650de93John McCall }; 33564b9c2d235fb9449e249d74f48ecfec601650de93John McCall} 33574b9c2d235fb9449e249d74f48ecfec601650de93John McCall 33584b9c2d235fb9449e249d74f48ecfec601650de93John McCallstatic LValueOrRValue emitPseudoObjectExpr(CodeGenFunction &CGF, 33594b9c2d235fb9449e249d74f48ecfec601650de93John McCall const PseudoObjectExpr *E, 33604b9c2d235fb9449e249d74f48ecfec601650de93John McCall bool forLValue, 33614b9c2d235fb9449e249d74f48ecfec601650de93John McCall AggValueSlot slot) { 3362cfa88f893915ceb8ae4ce2f17c46c24a4d67502fDmitri Gribenko SmallVector<CodeGenFunction::OpaqueValueMappingData, 4> opaques; 33634b9c2d235fb9449e249d74f48ecfec601650de93John McCall 33644b9c2d235fb9449e249d74f48ecfec601650de93John McCall // Find the result expression, if any. 33654b9c2d235fb9449e249d74f48ecfec601650de93John McCall const Expr *resultExpr = E->getResultExpr(); 33664b9c2d235fb9449e249d74f48ecfec601650de93John McCall LValueOrRValue result; 33674b9c2d235fb9449e249d74f48ecfec601650de93John McCall 33684b9c2d235fb9449e249d74f48ecfec601650de93John McCall for (PseudoObjectExpr::const_semantics_iterator 33694b9c2d235fb9449e249d74f48ecfec601650de93John McCall i = E->semantics_begin(), e = E->semantics_end(); i != e; ++i) { 33704b9c2d235fb9449e249d74f48ecfec601650de93John McCall const Expr *semantic = *i; 33714b9c2d235fb9449e249d74f48ecfec601650de93John McCall 33724b9c2d235fb9449e249d74f48ecfec601650de93John McCall // If this semantic expression is an opaque value, bind it 33734b9c2d235fb9449e249d74f48ecfec601650de93John McCall // to the result of its source expression. 33746bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *ov = dyn_cast<OpaqueValueExpr>(semantic)) { 33754b9c2d235fb9449e249d74f48ecfec601650de93John McCall 33764b9c2d235fb9449e249d74f48ecfec601650de93John McCall // If this is the result expression, we may need to evaluate 33774b9c2d235fb9449e249d74f48ecfec601650de93John McCall // directly into the slot. 33784b9c2d235fb9449e249d74f48ecfec601650de93John McCall typedef CodeGenFunction::OpaqueValueMappingData OVMA; 33794b9c2d235fb9449e249d74f48ecfec601650de93John McCall OVMA opaqueData; 33804b9c2d235fb9449e249d74f48ecfec601650de93John McCall if (ov == resultExpr && ov->isRValue() && !forLValue && 33819d232c884ea9872d6555df0fd7359699819bc1f1John McCall CodeGenFunction::hasAggregateEvaluationKind(ov->getType())) { 33824b9c2d235fb9449e249d74f48ecfec601650de93John McCall CGF.EmitAggExpr(ov->getSourceExpr(), slot); 33834b9c2d235fb9449e249d74f48ecfec601650de93John McCall 33844b9c2d235fb9449e249d74f48ecfec601650de93John McCall LValue LV = CGF.MakeAddrLValue(slot.getAddr(), ov->getType()); 33854b9c2d235fb9449e249d74f48ecfec601650de93John McCall opaqueData = OVMA::bind(CGF, ov, LV); 33864b9c2d235fb9449e249d74f48ecfec601650de93John McCall result.RV = slot.asRValue(); 33874b9c2d235fb9449e249d74f48ecfec601650de93John McCall 33884b9c2d235fb9449e249d74f48ecfec601650de93John McCall // Otherwise, emit as normal. 33894b9c2d235fb9449e249d74f48ecfec601650de93John McCall } else { 33904b9c2d235fb9449e249d74f48ecfec601650de93John McCall opaqueData = OVMA::bind(CGF, ov, ov->getSourceExpr()); 33914b9c2d235fb9449e249d74f48ecfec601650de93John McCall 33924b9c2d235fb9449e249d74f48ecfec601650de93John McCall // If this is the result, also evaluate the result now. 33934b9c2d235fb9449e249d74f48ecfec601650de93John McCall if (ov == resultExpr) { 33944b9c2d235fb9449e249d74f48ecfec601650de93John McCall if (forLValue) 33954b9c2d235fb9449e249d74f48ecfec601650de93John McCall result.LV = CGF.EmitLValue(ov); 33964b9c2d235fb9449e249d74f48ecfec601650de93John McCall else 33974b9c2d235fb9449e249d74f48ecfec601650de93John McCall result.RV = CGF.EmitAnyExpr(ov, slot); 33984b9c2d235fb9449e249d74f48ecfec601650de93John McCall } 33994b9c2d235fb9449e249d74f48ecfec601650de93John McCall } 34004b9c2d235fb9449e249d74f48ecfec601650de93John McCall 34014b9c2d235fb9449e249d74f48ecfec601650de93John McCall opaques.push_back(opaqueData); 34024b9c2d235fb9449e249d74f48ecfec601650de93John McCall 34034b9c2d235fb9449e249d74f48ecfec601650de93John McCall // Otherwise, if the expression is the result, evaluate it 34044b9c2d235fb9449e249d74f48ecfec601650de93John McCall // and remember the result. 34054b9c2d235fb9449e249d74f48ecfec601650de93John McCall } else if (semantic == resultExpr) { 34064b9c2d235fb9449e249d74f48ecfec601650de93John McCall if (forLValue) 34074b9c2d235fb9449e249d74f48ecfec601650de93John McCall result.LV = CGF.EmitLValue(semantic); 34084b9c2d235fb9449e249d74f48ecfec601650de93John McCall else 34094b9c2d235fb9449e249d74f48ecfec601650de93John McCall result.RV = CGF.EmitAnyExpr(semantic, slot); 34104b9c2d235fb9449e249d74f48ecfec601650de93John McCall 34114b9c2d235fb9449e249d74f48ecfec601650de93John McCall // Otherwise, evaluate the expression in an ignored context. 34124b9c2d235fb9449e249d74f48ecfec601650de93John McCall } else { 34134b9c2d235fb9449e249d74f48ecfec601650de93John McCall CGF.EmitIgnoredExpr(semantic); 34144b9c2d235fb9449e249d74f48ecfec601650de93John McCall } 34154b9c2d235fb9449e249d74f48ecfec601650de93John McCall } 34164b9c2d235fb9449e249d74f48ecfec601650de93John McCall 34174b9c2d235fb9449e249d74f48ecfec601650de93John McCall // Unbind all the opaques now. 34184b9c2d235fb9449e249d74f48ecfec601650de93John McCall for (unsigned i = 0, e = opaques.size(); i != e; ++i) 34194b9c2d235fb9449e249d74f48ecfec601650de93John McCall opaques[i].unbind(CGF); 34204b9c2d235fb9449e249d74f48ecfec601650de93John McCall 34214b9c2d235fb9449e249d74f48ecfec601650de93John McCall return result; 34224b9c2d235fb9449e249d74f48ecfec601650de93John McCall} 34234b9c2d235fb9449e249d74f48ecfec601650de93John McCall 34244b9c2d235fb9449e249d74f48ecfec601650de93John McCallRValue CodeGenFunction::EmitPseudoObjectRValue(const PseudoObjectExpr *E, 34254b9c2d235fb9449e249d74f48ecfec601650de93John McCall AggValueSlot slot) { 34264b9c2d235fb9449e249d74f48ecfec601650de93John McCall return emitPseudoObjectExpr(*this, E, false, slot).RV; 34274b9c2d235fb9449e249d74f48ecfec601650de93John McCall} 34284b9c2d235fb9449e249d74f48ecfec601650de93John McCall 34294b9c2d235fb9449e249d74f48ecfec601650de93John McCallLValue CodeGenFunction::EmitPseudoObjectLValue(const PseudoObjectExpr *E) { 34304b9c2d235fb9449e249d74f48ecfec601650de93John McCall return emitPseudoObjectExpr(*this, E, true, AggValueSlot::ignored()).LV; 34314b9c2d235fb9449e249d74f48ecfec601650de93John McCall} 3432