| //===--- CGExpr.cpp - Emit LLVM Code from Expressions ---------------------===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This contains code to emit Expr nodes as LLVM code. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "CGCXXABI.h" |
| #include "CGCall.h" |
| #include "CGCleanup.h" |
| #include "CGDebugInfo.h" |
| #include "CGObjCRuntime.h" |
| #include "CGOpenMPRuntime.h" |
| #include "CGRecordLayout.h" |
| #include "CodeGenFunction.h" |
| #include "CodeGenModule.h" |
| #include "TargetInfo.h" |
| #include "clang/AST/ASTContext.h" |
| #include "clang/AST/Attr.h" |
| #include "clang/AST/DeclObjC.h" |
| #include "clang/AST/NSAPI.h" |
| #include "clang/Frontend/CodeGenOptions.h" |
| #include "llvm/ADT/Hashing.h" |
| #include "llvm/ADT/StringExtras.h" |
| #include "llvm/IR/DataLayout.h" |
| #include "llvm/IR/Intrinsics.h" |
| #include "llvm/IR/LLVMContext.h" |
| #include "llvm/IR/MDBuilder.h" |
| #include "llvm/Support/ConvertUTF.h" |
| #include "llvm/Support/MathExtras.h" |
| #include "llvm/Support/Path.h" |
| #include "llvm/Transforms/Utils/SanitizerStats.h" |
| |
| #include <string> |
| |
| using namespace clang; |
| using namespace CodeGen; |
| |
| //===--------------------------------------------------------------------===// |
| // Miscellaneous Helper Methods |
| //===--------------------------------------------------------------------===// |
| |
| llvm::Value *CodeGenFunction::EmitCastToVoidPtr(llvm::Value *value) { |
| unsigned addressSpace = |
| cast<llvm::PointerType>(value->getType())->getAddressSpace(); |
| |
| llvm::PointerType *destType = Int8PtrTy; |
| if (addressSpace) |
| destType = llvm::Type::getInt8PtrTy(getLLVMContext(), addressSpace); |
| |
| if (value->getType() == destType) return value; |
| return Builder.CreateBitCast(value, destType); |
| } |
| |
| /// CreateTempAlloca - This creates a alloca and inserts it into the entry |
| /// block. |
| Address CodeGenFunction::CreateTempAlloca(llvm::Type *Ty, CharUnits Align, |
| const Twine &Name) { |
| auto Alloca = CreateTempAlloca(Ty, Name); |
| Alloca->setAlignment(Align.getQuantity()); |
| return Address(Alloca, Align); |
| } |
| |
| /// CreateTempAlloca - This creates a alloca and inserts it into the entry |
| /// block. |
| llvm::AllocaInst *CodeGenFunction::CreateTempAlloca(llvm::Type *Ty, |
| const Twine &Name) { |
| return new llvm::AllocaInst(Ty, nullptr, Name, AllocaInsertPt); |
| } |
| |
| /// CreateDefaultAlignTempAlloca - This creates an alloca with the |
| /// default alignment of the corresponding LLVM type, which is *not* |
| /// guaranteed to be related in any way to the expected alignment of |
| /// an AST type that might have been lowered to Ty. |
| Address CodeGenFunction::CreateDefaultAlignTempAlloca(llvm::Type *Ty, |
| const Twine &Name) { |
| CharUnits Align = |
| CharUnits::fromQuantity(CGM.getDataLayout().getABITypeAlignment(Ty)); |
| return CreateTempAlloca(Ty, Align, Name); |
| } |
| |
| void CodeGenFunction::InitTempAlloca(Address Var, llvm::Value *Init) { |
| assert(isa<llvm::AllocaInst>(Var.getPointer())); |
| auto *Store = new llvm::StoreInst(Init, Var.getPointer()); |
| Store->setAlignment(Var.getAlignment().getQuantity()); |
| llvm::BasicBlock *Block = AllocaInsertPt->getParent(); |
| Block->getInstList().insertAfter(AllocaInsertPt->getIterator(), Store); |
| } |
| |
| Address CodeGenFunction::CreateIRTemp(QualType Ty, const Twine &Name) { |
| CharUnits Align = getContext().getTypeAlignInChars(Ty); |
| return CreateTempAlloca(ConvertType(Ty), Align, Name); |
| } |
| |
| Address CodeGenFunction::CreateMemTemp(QualType Ty, const Twine &Name) { |
| // FIXME: Should we prefer the preferred type alignment here? |
| return CreateMemTemp(Ty, getContext().getTypeAlignInChars(Ty), Name); |
| } |
| |
| Address CodeGenFunction::CreateMemTemp(QualType Ty, CharUnits Align, |
| const Twine &Name) { |
| return CreateTempAlloca(ConvertTypeForMem(Ty), Align, Name); |
| } |
| |
| /// EvaluateExprAsBool - Perform the usual unary conversions on the specified |
| /// expression and compare the result against zero, returning an Int1Ty value. |
| llvm::Value *CodeGenFunction::EvaluateExprAsBool(const Expr *E) { |
| PGO.setCurrentStmt(E); |
| if (const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>()) { |
| llvm::Value *MemPtr = EmitScalarExpr(E); |
| return CGM.getCXXABI().EmitMemberPointerIsNotNull(*this, MemPtr, MPT); |
| } |
| |
| QualType BoolTy = getContext().BoolTy; |
| SourceLocation Loc = E->getExprLoc(); |
| if (!E->getType()->isAnyComplexType()) |
| return EmitScalarConversion(EmitScalarExpr(E), E->getType(), BoolTy, Loc); |
| |
| return EmitComplexToScalarConversion(EmitComplexExpr(E), E->getType(), BoolTy, |
| Loc); |
| } |
| |
| /// EmitIgnoredExpr - Emit code to compute the specified expression, |
| /// ignoring the result. |
| void CodeGenFunction::EmitIgnoredExpr(const Expr *E) { |
| if (E->isRValue()) |
| return (void) EmitAnyExpr(E, AggValueSlot::ignored(), true); |
| |
| // Just emit it as an l-value and drop the result. |
| EmitLValue(E); |
| } |
| |
| /// EmitAnyExpr - Emit code to compute the specified expression which |
| /// can have any type. The result is returned as an RValue struct. |
| /// If this is an aggregate expression, AggSlot indicates where the |
| /// result should be returned. |
| RValue CodeGenFunction::EmitAnyExpr(const Expr *E, |
| AggValueSlot aggSlot, |
| bool ignoreResult) { |
| switch (getEvaluationKind(E->getType())) { |
| case TEK_Scalar: |
| return RValue::get(EmitScalarExpr(E, ignoreResult)); |
| case TEK_Complex: |
| return RValue::getComplex(EmitComplexExpr(E, ignoreResult, ignoreResult)); |
| case TEK_Aggregate: |
| if (!ignoreResult && aggSlot.isIgnored()) |
| aggSlot = CreateAggTemp(E->getType(), "agg-temp"); |
| EmitAggExpr(E, aggSlot); |
| return aggSlot.asRValue(); |
| } |
| llvm_unreachable("bad evaluation kind"); |
| } |
| |
| /// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result will |
| /// always be accessible even if no aggregate location is provided. |
| RValue CodeGenFunction::EmitAnyExprToTemp(const Expr *E) { |
| AggValueSlot AggSlot = AggValueSlot::ignored(); |
| |
| if (hasAggregateEvaluationKind(E->getType())) |
| AggSlot = CreateAggTemp(E->getType(), "agg.tmp"); |
| return EmitAnyExpr(E, AggSlot); |
| } |
| |
| /// EmitAnyExprToMem - Evaluate an expression into a given memory |
| /// location. |
| void CodeGenFunction::EmitAnyExprToMem(const Expr *E, |
| Address Location, |
| Qualifiers Quals, |
| bool IsInit) { |
| // FIXME: This function should take an LValue as an argument. |
| switch (getEvaluationKind(E->getType())) { |
| case TEK_Complex: |
| EmitComplexExprIntoLValue(E, MakeAddrLValue(Location, E->getType()), |
| /*isInit*/ false); |
| return; |
| |
| case TEK_Aggregate: { |
| EmitAggExpr(E, AggValueSlot::forAddr(Location, Quals, |
| AggValueSlot::IsDestructed_t(IsInit), |
| AggValueSlot::DoesNotNeedGCBarriers, |
| AggValueSlot::IsAliased_t(!IsInit))); |
| return; |
| } |
| |
| case TEK_Scalar: { |
| RValue RV = RValue::get(EmitScalarExpr(E, /*Ignore*/ false)); |
| LValue LV = MakeAddrLValue(Location, E->getType()); |
| EmitStoreThroughLValue(RV, LV); |
| return; |
| } |
| } |
| llvm_unreachable("bad evaluation kind"); |
| } |
| |
| static void |
| pushTemporaryCleanup(CodeGenFunction &CGF, const MaterializeTemporaryExpr *M, |
| const Expr *E, Address ReferenceTemporary) { |
| // Objective-C++ ARC: |
| // If we are binding a reference to a temporary that has ownership, we |
| // need to perform retain/release operations on the temporary. |
| // |
| // FIXME: This should be looking at E, not M. |
| if (auto Lifetime = M->getType().getObjCLifetime()) { |
| switch (Lifetime) { |
| case Qualifiers::OCL_None: |
| case Qualifiers::OCL_ExplicitNone: |
| // Carry on to normal cleanup handling. |
| break; |
| |
| case Qualifiers::OCL_Autoreleasing: |
| // Nothing to do; cleaned up by an autorelease pool. |
| return; |
| |
| case Qualifiers::OCL_Strong: |
| case Qualifiers::OCL_Weak: |
| switch (StorageDuration Duration = M->getStorageDuration()) { |
| case SD_Static: |
| // Note: we intentionally do not register a cleanup to release |
| // the object on program termination. |
| return; |
| |
| case SD_Thread: |
| // FIXME: We should probably register a cleanup in this case. |
| return; |
| |
| case SD_Automatic: |
| case SD_FullExpression: |
| CodeGenFunction::Destroyer *Destroy; |
| CleanupKind CleanupKind; |
| if (Lifetime == Qualifiers::OCL_Strong) { |
| const ValueDecl *VD = M->getExtendingDecl(); |
| bool Precise = |
| VD && isa<VarDecl>(VD) && VD->hasAttr<ObjCPreciseLifetimeAttr>(); |
| CleanupKind = CGF.getARCCleanupKind(); |
| Destroy = Precise ? &CodeGenFunction::destroyARCStrongPrecise |
| : &CodeGenFunction::destroyARCStrongImprecise; |
| } else { |
| // __weak objects always get EH cleanups; otherwise, exceptions |
| // could cause really nasty crashes instead of mere leaks. |
| CleanupKind = NormalAndEHCleanup; |
| Destroy = &CodeGenFunction::destroyARCWeak; |
| } |
| if (Duration == SD_FullExpression) |
| CGF.pushDestroy(CleanupKind, ReferenceTemporary, |
| M->getType(), *Destroy, |
| CleanupKind & EHCleanup); |
| else |
| CGF.pushLifetimeExtendedDestroy(CleanupKind, ReferenceTemporary, |
| M->getType(), |
| *Destroy, CleanupKind & EHCleanup); |
| return; |
| |
| case SD_Dynamic: |
| llvm_unreachable("temporary cannot have dynamic storage duration"); |
| } |
| llvm_unreachable("unknown storage duration"); |
| } |
| } |
| |
| CXXDestructorDecl *ReferenceTemporaryDtor = nullptr; |
| if (const RecordType *RT = |
| E->getType()->getBaseElementTypeUnsafe()->getAs<RecordType>()) { |
| // Get the destructor for the reference temporary. |
| auto *ClassDecl = cast<CXXRecordDecl>(RT->getDecl()); |
| if (!ClassDecl->hasTrivialDestructor()) |
| ReferenceTemporaryDtor = ClassDecl->getDestructor(); |
| } |
| |
| if (!ReferenceTemporaryDtor) |
| return; |
| |
| // Call the destructor for the temporary. |
| switch (M->getStorageDuration()) { |
| case SD_Static: |
| case SD_Thread: { |
| llvm::Constant *CleanupFn; |
| llvm::Constant *CleanupArg; |
| if (E->getType()->isArrayType()) { |
| CleanupFn = CodeGenFunction(CGF.CGM).generateDestroyHelper( |
| ReferenceTemporary, E->getType(), |
| CodeGenFunction::destroyCXXObject, CGF.getLangOpts().Exceptions, |
| dyn_cast_or_null<VarDecl>(M->getExtendingDecl())); |
| CleanupArg = llvm::Constant::getNullValue(CGF.Int8PtrTy); |
| } else { |
| CleanupFn = CGF.CGM.getAddrOfCXXStructor(ReferenceTemporaryDtor, |
| StructorType::Complete); |
| CleanupArg = cast<llvm::Constant>(ReferenceTemporary.getPointer()); |
| } |
| CGF.CGM.getCXXABI().registerGlobalDtor( |
| CGF, *cast<VarDecl>(M->getExtendingDecl()), CleanupFn, CleanupArg); |
| break; |
| } |
| |
| case SD_FullExpression: |
| CGF.pushDestroy(NormalAndEHCleanup, ReferenceTemporary, E->getType(), |
| CodeGenFunction::destroyCXXObject, |
| CGF.getLangOpts().Exceptions); |
| break; |
| |
| case SD_Automatic: |
| CGF.pushLifetimeExtendedDestroy(NormalAndEHCleanup, |
| ReferenceTemporary, E->getType(), |
| CodeGenFunction::destroyCXXObject, |
| CGF.getLangOpts().Exceptions); |
| break; |
| |
| case SD_Dynamic: |
| llvm_unreachable("temporary cannot have dynamic storage duration"); |
| } |
| } |
| |
| static Address |
| createReferenceTemporary(CodeGenFunction &CGF, |
| const MaterializeTemporaryExpr *M, const Expr *Inner) { |
| switch (M->getStorageDuration()) { |
| case SD_FullExpression: |
| case SD_Automatic: { |
| // If we have a constant temporary array or record try to promote it into a |
| // constant global under the same rules a normal constant would've been |
| // promoted. This is easier on the optimizer and generally emits fewer |
| // instructions. |
| QualType Ty = Inner->getType(); |
| if (CGF.CGM.getCodeGenOpts().MergeAllConstants && |
| (Ty->isArrayType() || Ty->isRecordType()) && |
| CGF.CGM.isTypeConstant(Ty, true)) |
| if (llvm::Constant *Init = CGF.CGM.EmitConstantExpr(Inner, Ty, &CGF)) { |
| auto *GV = new llvm::GlobalVariable( |
| CGF.CGM.getModule(), Init->getType(), /*isConstant=*/true, |
| llvm::GlobalValue::PrivateLinkage, Init, ".ref.tmp"); |
| CharUnits alignment = CGF.getContext().getTypeAlignInChars(Ty); |
| GV->setAlignment(alignment.getQuantity()); |
| // FIXME: Should we put the new global into a COMDAT? |
| return Address(GV, alignment); |
| } |
| return CGF.CreateMemTemp(Ty, "ref.tmp"); |
| } |
| case SD_Thread: |
| case SD_Static: |
| return CGF.CGM.GetAddrOfGlobalTemporary(M, Inner); |
| |
| case SD_Dynamic: |
| llvm_unreachable("temporary can't have dynamic storage duration"); |
| } |
| llvm_unreachable("unknown storage duration"); |
| } |
| |
| LValue CodeGenFunction:: |
| EmitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *M) { |
| const Expr *E = M->GetTemporaryExpr(); |
| |
| // FIXME: ideally this would use EmitAnyExprToMem, however, we cannot do so |
| // as that will cause the lifetime adjustment to be lost for ARC |
| auto ownership = M->getType().getObjCLifetime(); |
| if (ownership != Qualifiers::OCL_None && |
| ownership != Qualifiers::OCL_ExplicitNone) { |
| Address Object = createReferenceTemporary(*this, M, E); |
| if (auto *Var = dyn_cast<llvm::GlobalVariable>(Object.getPointer())) { |
| Object = Address(llvm::ConstantExpr::getBitCast(Var, |
| ConvertTypeForMem(E->getType()) |
| ->getPointerTo(Object.getAddressSpace())), |
| Object.getAlignment()); |
| |
| // createReferenceTemporary will promote the temporary to a global with a |
| // constant initializer if it can. It can only do this to a value of |
| // ARC-manageable type if the value is global and therefore "immune" to |
| // ref-counting operations. Therefore we have no need to emit either a |
| // dynamic initialization or a cleanup and we can just return the address |
| // of the temporary. |
| if (Var->hasInitializer()) |
| return MakeAddrLValue(Object, M->getType(), AlignmentSource::Decl); |
| |
| Var->setInitializer(CGM.EmitNullConstant(E->getType())); |
| } |
| LValue RefTempDst = MakeAddrLValue(Object, M->getType(), |
| AlignmentSource::Decl); |
| |
| switch (getEvaluationKind(E->getType())) { |
| default: llvm_unreachable("expected scalar or aggregate expression"); |
| case TEK_Scalar: |
| EmitScalarInit(E, M->getExtendingDecl(), RefTempDst, false); |
| break; |
| case TEK_Aggregate: { |
| EmitAggExpr(E, AggValueSlot::forAddr(Object, |
| E->getType().getQualifiers(), |
| AggValueSlot::IsDestructed, |
| AggValueSlot::DoesNotNeedGCBarriers, |
| AggValueSlot::IsNotAliased)); |
| break; |
| } |
| } |
| |
| pushTemporaryCleanup(*this, M, E, Object); |
| return RefTempDst; |
| } |
| |
| SmallVector<const Expr *, 2> CommaLHSs; |
| SmallVector<SubobjectAdjustment, 2> Adjustments; |
| E = E->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments); |
| |
| for (const auto &Ignored : CommaLHSs) |
| EmitIgnoredExpr(Ignored); |
| |
| if (const auto *opaque = dyn_cast<OpaqueValueExpr>(E)) { |
| if (opaque->getType()->isRecordType()) { |
| assert(Adjustments.empty()); |
| return EmitOpaqueValueLValue(opaque); |
| } |
| } |
| |
| // Create and initialize the reference temporary. |
| Address Object = createReferenceTemporary(*this, M, E); |
| if (auto *Var = dyn_cast<llvm::GlobalVariable>(Object.getPointer())) { |
| Object = Address(llvm::ConstantExpr::getBitCast( |
| Var, ConvertTypeForMem(E->getType())->getPointerTo()), |
| Object.getAlignment()); |
| // If the temporary is a global and has a constant initializer or is a |
| // constant temporary that we promoted to a global, we may have already |
| // initialized it. |
| if (!Var->hasInitializer()) { |
| Var->setInitializer(CGM.EmitNullConstant(E->getType())); |
| EmitAnyExprToMem(E, Object, Qualifiers(), /*IsInit*/true); |
| } |
| } else { |
| switch (M->getStorageDuration()) { |
| case SD_Automatic: |
| case SD_FullExpression: |
| if (auto *Size = EmitLifetimeStart( |
| CGM.getDataLayout().getTypeAllocSize(Object.getElementType()), |
| Object.getPointer())) { |
| if (M->getStorageDuration() == SD_Automatic) |
| pushCleanupAfterFullExpr<CallLifetimeEnd>(NormalEHLifetimeMarker, |
| Object, Size); |
| else |
| pushFullExprCleanup<CallLifetimeEnd>(NormalEHLifetimeMarker, Object, |
| Size); |
| } |
| break; |
| default: |
| break; |
| } |
| EmitAnyExprToMem(E, Object, Qualifiers(), /*IsInit*/true); |
| } |
| pushTemporaryCleanup(*this, M, E, Object); |
| |
| // Perform derived-to-base casts and/or field accesses, to get from the |
| // temporary object we created (and, potentially, for which we extended |
| // the lifetime) to the subobject we're binding the reference to. |
| for (unsigned I = Adjustments.size(); I != 0; --I) { |
| SubobjectAdjustment &Adjustment = Adjustments[I-1]; |
| switch (Adjustment.Kind) { |
| case SubobjectAdjustment::DerivedToBaseAdjustment: |
| Object = |
| GetAddressOfBaseClass(Object, Adjustment.DerivedToBase.DerivedClass, |
| Adjustment.DerivedToBase.BasePath->path_begin(), |
| Adjustment.DerivedToBase.BasePath->path_end(), |
| /*NullCheckValue=*/ false, E->getExprLoc()); |
| break; |
| |
| case SubobjectAdjustment::FieldAdjustment: { |
| LValue LV = MakeAddrLValue(Object, E->getType(), |
| AlignmentSource::Decl); |
| LV = EmitLValueForField(LV, Adjustment.Field); |
| assert(LV.isSimple() && |
| "materialized temporary field is not a simple lvalue"); |
| Object = LV.getAddress(); |
| break; |
| } |
| |
| case SubobjectAdjustment::MemberPointerAdjustment: { |
| llvm::Value *Ptr = EmitScalarExpr(Adjustment.Ptr.RHS); |
| Object = EmitCXXMemberDataPointerAddress(E, Object, Ptr, |
| Adjustment.Ptr.MPT); |
| break; |
| } |
| } |
| } |
| |
| return MakeAddrLValue(Object, M->getType(), AlignmentSource::Decl); |
| } |
| |
| RValue |
| CodeGenFunction::EmitReferenceBindingToExpr(const Expr *E) { |
| // Emit the expression as an lvalue. |
| LValue LV = EmitLValue(E); |
| assert(LV.isSimple()); |
| llvm::Value *Value = LV.getPointer(); |
| |
| if (sanitizePerformTypeCheck() && !E->getType()->isFunctionType()) { |
| // C++11 [dcl.ref]p5 (as amended by core issue 453): |
| // If a glvalue to which a reference is directly bound designates neither |
| // an existing object or function of an appropriate type nor a region of |
| // storage of suitable size and alignment to contain an object of the |
| // reference's type, the behavior is undefined. |
| QualType Ty = E->getType(); |
| EmitTypeCheck(TCK_ReferenceBinding, E->getExprLoc(), Value, Ty); |
| } |
| |
| return RValue::get(Value); |
| } |
| |
| |
| /// getAccessedFieldNo - Given an encoded value and a result number, return the |
| /// input field number being accessed. |
| unsigned CodeGenFunction::getAccessedFieldNo(unsigned Idx, |
| const llvm::Constant *Elts) { |
| return cast<llvm::ConstantInt>(Elts->getAggregateElement(Idx)) |
| ->getZExtValue(); |
| } |
| |
| /// Emit the hash_16_bytes function from include/llvm/ADT/Hashing.h. |
| static llvm::Value *emitHash16Bytes(CGBuilderTy &Builder, llvm::Value *Low, |
| llvm::Value *High) { |
| llvm::Value *KMul = Builder.getInt64(0x9ddfea08eb382d69ULL); |
| llvm::Value *K47 = Builder.getInt64(47); |
| llvm::Value *A0 = Builder.CreateMul(Builder.CreateXor(Low, High), KMul); |
| llvm::Value *A1 = Builder.CreateXor(Builder.CreateLShr(A0, K47), A0); |
| llvm::Value *B0 = Builder.CreateMul(Builder.CreateXor(High, A1), KMul); |
| llvm::Value *B1 = Builder.CreateXor(Builder.CreateLShr(B0, K47), B0); |
| return Builder.CreateMul(B1, KMul); |
| } |
| |
| bool CodeGenFunction::sanitizePerformTypeCheck() const { |
| return SanOpts.has(SanitizerKind::Null) | |
| SanOpts.has(SanitizerKind::Alignment) | |
| SanOpts.has(SanitizerKind::ObjectSize) | |
| SanOpts.has(SanitizerKind::Vptr); |
| } |
| |
| void CodeGenFunction::EmitTypeCheck(TypeCheckKind TCK, SourceLocation Loc, |
| llvm::Value *Ptr, QualType Ty, |
| CharUnits Alignment, bool SkipNullCheck) { |
| if (!sanitizePerformTypeCheck()) |
| return; |
| |
| // Don't check pointers outside the default address space. The null check |
| // isn't correct, the object-size check isn't supported by LLVM, and we can't |
| // communicate the addresses to the runtime handler for the vptr check. |
| if (Ptr->getType()->getPointerAddressSpace()) |
| return; |
| |
| SanitizerScope SanScope(this); |
| |
| SmallVector<std::pair<llvm::Value *, SanitizerMask>, 3> Checks; |
| llvm::BasicBlock *Done = nullptr; |
| |
| bool AllowNullPointers = TCK == TCK_DowncastPointer || TCK == TCK_Upcast || |
| TCK == TCK_UpcastToVirtualBase; |
| if ((SanOpts.has(SanitizerKind::Null) || AllowNullPointers) && |
| !SkipNullCheck) { |
| // The glvalue must not be an empty glvalue. |
| llvm::Value *IsNonNull = Builder.CreateIsNotNull(Ptr); |
| |
| if (AllowNullPointers) { |
| // When performing pointer casts, it's OK if the value is null. |
| // Skip the remaining checks in that case. |
| Done = createBasicBlock("null"); |
| llvm::BasicBlock *Rest = createBasicBlock("not.null"); |
| Builder.CreateCondBr(IsNonNull, Rest, Done); |
| EmitBlock(Rest); |
| } else { |
| Checks.push_back(std::make_pair(IsNonNull, SanitizerKind::Null)); |
| } |
| } |
| |
| if (SanOpts.has(SanitizerKind::ObjectSize) && !Ty->isIncompleteType()) { |
| uint64_t Size = getContext().getTypeSizeInChars(Ty).getQuantity(); |
| |
| // The glvalue must refer to a large enough storage region. |
| // FIXME: If Address Sanitizer is enabled, insert dynamic instrumentation |
| // to check this. |
| // FIXME: Get object address space |
| llvm::Type *Tys[2] = { IntPtrTy, Int8PtrTy }; |
| llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::objectsize, Tys); |
| llvm::Value *Min = Builder.getFalse(); |
| llvm::Value *CastAddr = Builder.CreateBitCast(Ptr, Int8PtrTy); |
| llvm::Value *LargeEnough = |
| Builder.CreateICmpUGE(Builder.CreateCall(F, {CastAddr, Min}), |
| llvm::ConstantInt::get(IntPtrTy, Size)); |
| Checks.push_back(std::make_pair(LargeEnough, SanitizerKind::ObjectSize)); |
| } |
| |
| uint64_t AlignVal = 0; |
| |
| if (SanOpts.has(SanitizerKind::Alignment)) { |
| AlignVal = Alignment.getQuantity(); |
| if (!Ty->isIncompleteType() && !AlignVal) |
| AlignVal = getContext().getTypeAlignInChars(Ty).getQuantity(); |
| |
| // The glvalue must be suitably aligned. |
| if (AlignVal) { |
| llvm::Value *Align = |
| Builder.CreateAnd(Builder.CreatePtrToInt(Ptr, IntPtrTy), |
| llvm::ConstantInt::get(IntPtrTy, AlignVal - 1)); |
| llvm::Value *Aligned = |
| Builder.CreateICmpEQ(Align, llvm::ConstantInt::get(IntPtrTy, 0)); |
| Checks.push_back(std::make_pair(Aligned, SanitizerKind::Alignment)); |
| } |
| } |
| |
| if (Checks.size() > 0) { |
| // Make sure we're not losing information. Alignment needs to be a power of |
| // 2 |
| assert(!AlignVal || (uint64_t)1 << llvm::Log2_64(AlignVal) == AlignVal); |
| llvm::Constant *StaticData[] = { |
| EmitCheckSourceLocation(Loc), EmitCheckTypeDescriptor(Ty), |
| llvm::ConstantInt::get(Int8Ty, AlignVal ? llvm::Log2_64(AlignVal) : 1), |
| llvm::ConstantInt::get(Int8Ty, TCK)}; |
| EmitCheck(Checks, SanitizerHandler::TypeMismatch, StaticData, Ptr); |
| } |
| |
| // If possible, check that the vptr indicates that there is a subobject of |
| // type Ty at offset zero within this object. |
| // |
| // C++11 [basic.life]p5,6: |
| // [For storage which does not refer to an object within its lifetime] |
| // The program has undefined behavior if: |
| // -- the [pointer or glvalue] is used to access a non-static data member |
| // or call a non-static member function |
| CXXRecordDecl *RD = Ty->getAsCXXRecordDecl(); |
| if (SanOpts.has(SanitizerKind::Vptr) && |
| (TCK == TCK_MemberAccess || TCK == TCK_MemberCall || |
| TCK == TCK_DowncastPointer || TCK == TCK_DowncastReference || |
| TCK == TCK_UpcastToVirtualBase) && |
| RD && RD->hasDefinition() && RD->isDynamicClass()) { |
| // Compute a hash of the mangled name of the type. |
| // |
| // FIXME: This is not guaranteed to be deterministic! Move to a |
| // fingerprinting mechanism once LLVM provides one. For the time |
| // being the implementation happens to be deterministic. |
| SmallString<64> MangledName; |
| llvm::raw_svector_ostream Out(MangledName); |
| CGM.getCXXABI().getMangleContext().mangleCXXRTTI(Ty.getUnqualifiedType(), |
| Out); |
| |
| // Blacklist based on the mangled type. |
| if (!CGM.getContext().getSanitizerBlacklist().isBlacklistedType( |
| Out.str())) { |
| llvm::hash_code TypeHash = hash_value(Out.str()); |
| |
| // Load the vptr, and compute hash_16_bytes(TypeHash, vptr). |
| llvm::Value *Low = llvm::ConstantInt::get(Int64Ty, TypeHash); |
| llvm::Type *VPtrTy = llvm::PointerType::get(IntPtrTy, 0); |
| Address VPtrAddr(Builder.CreateBitCast(Ptr, VPtrTy), getPointerAlign()); |
| llvm::Value *VPtrVal = Builder.CreateLoad(VPtrAddr); |
| llvm::Value *High = Builder.CreateZExt(VPtrVal, Int64Ty); |
| |
| llvm::Value *Hash = emitHash16Bytes(Builder, Low, High); |
| Hash = Builder.CreateTrunc(Hash, IntPtrTy); |
| |
| // Look the hash up in our cache. |
| const int CacheSize = 128; |
| llvm::Type *HashTable = llvm::ArrayType::get(IntPtrTy, CacheSize); |
| llvm::Value *Cache = CGM.CreateRuntimeVariable(HashTable, |
| "__ubsan_vptr_type_cache"); |
| llvm::Value *Slot = Builder.CreateAnd(Hash, |
| llvm::ConstantInt::get(IntPtrTy, |
| CacheSize-1)); |
| llvm::Value *Indices[] = { Builder.getInt32(0), Slot }; |
| llvm::Value *CacheVal = |
| Builder.CreateAlignedLoad(Builder.CreateInBoundsGEP(Cache, Indices), |
| getPointerAlign()); |
| |
| // If the hash isn't in the cache, call a runtime handler to perform the |
| // hard work of checking whether the vptr is for an object of the right |
| // type. This will either fill in the cache and return, or produce a |
| // diagnostic. |
| llvm::Value *EqualHash = Builder.CreateICmpEQ(CacheVal, Hash); |
| llvm::Constant *StaticData[] = { |
| EmitCheckSourceLocation(Loc), |
| EmitCheckTypeDescriptor(Ty), |
| CGM.GetAddrOfRTTIDescriptor(Ty.getUnqualifiedType()), |
| llvm::ConstantInt::get(Int8Ty, TCK) |
| }; |
| llvm::Value *DynamicData[] = { Ptr, Hash }; |
| EmitCheck(std::make_pair(EqualHash, SanitizerKind::Vptr), |
| SanitizerHandler::DynamicTypeCacheMiss, StaticData, |
| DynamicData); |
| } |
| } |
| |
| if (Done) { |
| Builder.CreateBr(Done); |
| EmitBlock(Done); |
| } |
| } |
| |
| /// Determine whether this expression refers to a flexible array member in a |
| /// struct. We disable array bounds checks for such members. |
| static bool isFlexibleArrayMemberExpr(const Expr *E) { |
| // For compatibility with existing code, we treat arrays of length 0 or |
| // 1 as flexible array members. |
| const ArrayType *AT = E->getType()->castAsArrayTypeUnsafe(); |
| if (const auto *CAT = dyn_cast<ConstantArrayType>(AT)) { |
| if (CAT->getSize().ugt(1)) |
| return false; |
| } else if (!isa<IncompleteArrayType>(AT)) |
| return false; |
| |
| E = E->IgnoreParens(); |
| |
| // A flexible array member must be the last member in the class. |
| if (const auto *ME = dyn_cast<MemberExpr>(E)) { |
| // FIXME: If the base type of the member expr is not FD->getParent(), |
| // this should not be treated as a flexible array member access. |
| if (const auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) { |
| RecordDecl::field_iterator FI( |
| DeclContext::decl_iterator(const_cast<FieldDecl *>(FD))); |
| return ++FI == FD->getParent()->field_end(); |
| } |
| } else if (const auto *IRE = dyn_cast<ObjCIvarRefExpr>(E)) { |
| return IRE->getDecl()->getNextIvar() == nullptr; |
| } |
| |
| return false; |
| } |
| |
| /// If Base is known to point to the start of an array, return the length of |
| /// that array. Return 0 if the length cannot be determined. |
| static llvm::Value *getArrayIndexingBound( |
| CodeGenFunction &CGF, const Expr *Base, QualType &IndexedType) { |
| // For the vector indexing extension, the bound is the number of elements. |
| if (const VectorType *VT = Base->getType()->getAs<VectorType>()) { |
| IndexedType = Base->getType(); |
| return CGF.Builder.getInt32(VT->getNumElements()); |
| } |
| |
| Base = Base->IgnoreParens(); |
| |
| if (const auto *CE = dyn_cast<CastExpr>(Base)) { |
| if (CE->getCastKind() == CK_ArrayToPointerDecay && |
| !isFlexibleArrayMemberExpr(CE->getSubExpr())) { |
| IndexedType = CE->getSubExpr()->getType(); |
| const ArrayType *AT = IndexedType->castAsArrayTypeUnsafe(); |
| if (const auto *CAT = dyn_cast<ConstantArrayType>(AT)) |
| return CGF.Builder.getInt(CAT->getSize()); |
| else if (const auto *VAT = dyn_cast<VariableArrayType>(AT)) |
| return CGF.getVLASize(VAT).first; |
| } |
| } |
| |
| return nullptr; |
| } |
| |
| void CodeGenFunction::EmitBoundsCheck(const Expr *E, const Expr *Base, |
| llvm::Value *Index, QualType IndexType, |
| bool Accessed) { |
| assert(SanOpts.has(SanitizerKind::ArrayBounds) && |
| "should not be called unless adding bounds checks"); |
| SanitizerScope SanScope(this); |
| |
| QualType IndexedType; |
| llvm::Value *Bound = getArrayIndexingBound(*this, Base, IndexedType); |
| if (!Bound) |
| return; |
| |
| bool IndexSigned = IndexType->isSignedIntegerOrEnumerationType(); |
| llvm::Value *IndexVal = Builder.CreateIntCast(Index, SizeTy, IndexSigned); |
| llvm::Value *BoundVal = Builder.CreateIntCast(Bound, SizeTy, false); |
| |
| llvm::Constant *StaticData[] = { |
| EmitCheckSourceLocation(E->getExprLoc()), |
| EmitCheckTypeDescriptor(IndexedType), |
| EmitCheckTypeDescriptor(IndexType) |
| }; |
| llvm::Value *Check = Accessed ? Builder.CreateICmpULT(IndexVal, BoundVal) |
| : Builder.CreateICmpULE(IndexVal, BoundVal); |
| EmitCheck(std::make_pair(Check, SanitizerKind::ArrayBounds), |
| SanitizerHandler::OutOfBounds, StaticData, Index); |
| } |
| |
| |
| CodeGenFunction::ComplexPairTy CodeGenFunction:: |
| EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV, |
| bool isInc, bool isPre) { |
| ComplexPairTy InVal = EmitLoadOfComplex(LV, E->getExprLoc()); |
| |
| llvm::Value *NextVal; |
| if (isa<llvm::IntegerType>(InVal.first->getType())) { |
| uint64_t AmountVal = isInc ? 1 : -1; |
| NextVal = llvm::ConstantInt::get(InVal.first->getType(), AmountVal, true); |
| |
| // Add the inc/dec to the real part. |
| NextVal = Builder.CreateAdd(InVal.first, NextVal, isInc ? "inc" : "dec"); |
| } else { |
| QualType ElemTy = E->getType()->getAs<ComplexType>()->getElementType(); |
| llvm::APFloat FVal(getContext().getFloatTypeSemantics(ElemTy), 1); |
| if (!isInc) |
| FVal.changeSign(); |
| NextVal = llvm::ConstantFP::get(getLLVMContext(), FVal); |
| |
| // Add the inc/dec to the real part. |
| NextVal = Builder.CreateFAdd(InVal.first, NextVal, isInc ? "inc" : "dec"); |
| } |
| |
| ComplexPairTy IncVal(NextVal, InVal.second); |
| |
| // Store the updated result through the lvalue. |
| EmitStoreOfComplex(IncVal, LV, /*init*/ false); |
| |
| // If this is a postinc, return the value read from memory, otherwise use the |
| // updated value. |
| return isPre ? IncVal : InVal; |
| } |
| |
| void CodeGenModule::EmitExplicitCastExprType(const ExplicitCastExpr *E, |
| CodeGenFunction *CGF) { |
| // Bind VLAs in the cast type. |
| if (CGF && E->getType()->isVariablyModifiedType()) |
| CGF->EmitVariablyModifiedType(E->getType()); |
| |
| if (CGDebugInfo *DI = getModuleDebugInfo()) |
| DI->EmitExplicitCastType(E->getType()); |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // LValue Expression Emission |
| //===----------------------------------------------------------------------===// |
| |
| /// EmitPointerWithAlignment - Given an expression of pointer type, try to |
| /// derive a more accurate bound on the alignment of the pointer. |
| Address CodeGenFunction::EmitPointerWithAlignment(const Expr *E, |
| AlignmentSource *Source) { |
| // We allow this with ObjC object pointers because of fragile ABIs. |
| assert(E->getType()->isPointerType() || |
| E->getType()->isObjCObjectPointerType()); |
| E = E->IgnoreParens(); |
| |
| // Casts: |
| if (const CastExpr *CE = dyn_cast<CastExpr>(E)) { |
| if (const auto *ECE = dyn_cast<ExplicitCastExpr>(CE)) |
| CGM.EmitExplicitCastExprType(ECE, this); |
| |
| switch (CE->getCastKind()) { |
| // Non-converting casts (but not C's implicit conversion from void*). |
| case CK_BitCast: |
| case CK_NoOp: |
| if (auto PtrTy = CE->getSubExpr()->getType()->getAs<PointerType>()) { |
| if (PtrTy->getPointeeType()->isVoidType()) |
| break; |
| |
| AlignmentSource InnerSource; |
| Address Addr = EmitPointerWithAlignment(CE->getSubExpr(), &InnerSource); |
| if (Source) *Source = InnerSource; |
| |
| // If this is an explicit bitcast, and the source l-value is |
| // opaque, honor the alignment of the casted-to type. |
| if (isa<ExplicitCastExpr>(CE) && |
| InnerSource != AlignmentSource::Decl) { |
| Addr = Address(Addr.getPointer(), |
| getNaturalPointeeTypeAlignment(E->getType(), Source)); |
| } |
| |
| if (SanOpts.has(SanitizerKind::CFIUnrelatedCast) && |
| CE->getCastKind() == CK_BitCast) { |
| if (auto PT = E->getType()->getAs<PointerType>()) |
| EmitVTablePtrCheckForCast(PT->getPointeeType(), Addr.getPointer(), |
| /*MayBeNull=*/true, |
| CodeGenFunction::CFITCK_UnrelatedCast, |
| CE->getLocStart()); |
| } |
| |
| return Builder.CreateBitCast(Addr, ConvertType(E->getType())); |
| } |
| break; |
| |
| // Array-to-pointer decay. |
| case CK_ArrayToPointerDecay: |
| return EmitArrayToPointerDecay(CE->getSubExpr(), Source); |
| |
| // Derived-to-base conversions. |
| case CK_UncheckedDerivedToBase: |
| case CK_DerivedToBase: { |
| Address Addr = EmitPointerWithAlignment(CE->getSubExpr(), Source); |
| auto Derived = CE->getSubExpr()->getType()->getPointeeCXXRecordDecl(); |
| return GetAddressOfBaseClass(Addr, Derived, |
| CE->path_begin(), CE->path_end(), |
| ShouldNullCheckClassCastValue(CE), |
| CE->getExprLoc()); |
| } |
| |
| // TODO: Is there any reason to treat base-to-derived conversions |
| // specially? |
| default: |
| break; |
| } |
| } |
| |
| // Unary &. |
| if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) { |
| if (UO->getOpcode() == UO_AddrOf) { |
| LValue LV = EmitLValue(UO->getSubExpr()); |
| if (Source) *Source = LV.getAlignmentSource(); |
| return LV.getAddress(); |
| } |
| } |
| |
| // TODO: conditional operators, comma. |
| |
| // Otherwise, use the alignment of the type. |
| CharUnits Align = getNaturalPointeeTypeAlignment(E->getType(), Source); |
| return Address(EmitScalarExpr(E), Align); |
| } |
| |
| RValue CodeGenFunction::GetUndefRValue(QualType Ty) { |
| if (Ty->isVoidType()) |
| return RValue::get(nullptr); |
| |
| switch (getEvaluationKind(Ty)) { |
| case TEK_Complex: { |
| llvm::Type *EltTy = |
| ConvertType(Ty->castAs<ComplexType>()->getElementType()); |
| llvm::Value *U = llvm::UndefValue::get(EltTy); |
| return RValue::getComplex(std::make_pair(U, U)); |
| } |
| |
| // If this is a use of an undefined aggregate type, the aggregate must have an |
| // identifiable address. Just because the contents of the value are undefined |
| // doesn't mean that the address can't be taken and compared. |
| case TEK_Aggregate: { |
| Address DestPtr = CreateMemTemp(Ty, "undef.agg.tmp"); |
| return RValue::getAggregate(DestPtr); |
| } |
| |
| case TEK_Scalar: |
| return RValue::get(llvm::UndefValue::get(ConvertType(Ty))); |
| } |
| llvm_unreachable("bad evaluation kind"); |
| } |
| |
| RValue CodeGenFunction::EmitUnsupportedRValue(const Expr *E, |
| const char *Name) { |
| ErrorUnsupported(E, Name); |
| return GetUndefRValue(E->getType()); |
| } |
| |
| LValue CodeGenFunction::EmitUnsupportedLValue(const Expr *E, |
| const char *Name) { |
| ErrorUnsupported(E, Name); |
| llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType())); |
| return MakeAddrLValue(Address(llvm::UndefValue::get(Ty), CharUnits::One()), |
| E->getType()); |
| } |
| |
| LValue CodeGenFunction::EmitCheckedLValue(const Expr *E, TypeCheckKind TCK) { |
| LValue LV; |
| if (SanOpts.has(SanitizerKind::ArrayBounds) && isa<ArraySubscriptExpr>(E)) |
| LV = EmitArraySubscriptExpr(cast<ArraySubscriptExpr>(E), /*Accessed*/true); |
| else |
| LV = EmitLValue(E); |
| if (!isa<DeclRefExpr>(E) && !LV.isBitField() && LV.isSimple()) |
| EmitTypeCheck(TCK, E->getExprLoc(), LV.getPointer(), |
| E->getType(), LV.getAlignment()); |
| return LV; |
| } |
| |
| /// EmitLValue - Emit code to compute a designator that specifies the location |
| /// of the expression. |
| /// |
| /// This can return one of two things: a simple address or a bitfield reference. |
| /// In either case, the LLVM Value* in the LValue structure is guaranteed to be |
| /// an LLVM pointer type. |
| /// |
| /// If this returns a bitfield reference, nothing about the pointee type of the |
| /// LLVM value is known: For example, it may not be a pointer to an integer. |
| /// |
| /// If this returns a normal address, and if the lvalue's C type is fixed size, |
| /// this method guarantees that the returned pointer type will point to an LLVM |
| /// type of the same size of the lvalue's type. If the lvalue has a variable |
| /// length type, this is not possible. |
| /// |
| LValue CodeGenFunction::EmitLValue(const Expr *E) { |
| ApplyDebugLocation DL(*this, E); |
| switch (E->getStmtClass()) { |
| default: return EmitUnsupportedLValue(E, "l-value expression"); |
| |
| case Expr::ObjCPropertyRefExprClass: |
| llvm_unreachable("cannot emit a property reference directly"); |
| |
| case Expr::ObjCSelectorExprClass: |
| return EmitObjCSelectorLValue(cast<ObjCSelectorExpr>(E)); |
| case Expr::ObjCIsaExprClass: |
| return EmitObjCIsaExpr(cast<ObjCIsaExpr>(E)); |
| case Expr::BinaryOperatorClass: |
| return EmitBinaryOperatorLValue(cast<BinaryOperator>(E)); |
| case Expr::CompoundAssignOperatorClass: { |
| QualType Ty = E->getType(); |
| if (const AtomicType *AT = Ty->getAs<AtomicType>()) |
| Ty = AT->getValueType(); |
| if (!Ty->isAnyComplexType()) |
| return EmitCompoundAssignmentLValue(cast<CompoundAssignOperator>(E)); |
| return EmitComplexCompoundAssignmentLValue(cast<CompoundAssignOperator>(E)); |
| } |
| case Expr::CallExprClass: |
| case Expr::CXXMemberCallExprClass: |
| case Expr::CXXOperatorCallExprClass: |
| case Expr::UserDefinedLiteralClass: |
| return EmitCallExprLValue(cast<CallExpr>(E)); |
| case Expr::VAArgExprClass: |
| return EmitVAArgExprLValue(cast<VAArgExpr>(E)); |
| case Expr::DeclRefExprClass: |
| return EmitDeclRefLValue(cast<DeclRefExpr>(E)); |
| case Expr::ParenExprClass: |
| return EmitLValue(cast<ParenExpr>(E)->getSubExpr()); |
| case Expr::GenericSelectionExprClass: |
| return EmitLValue(cast<GenericSelectionExpr>(E)->getResultExpr()); |
| case Expr::PredefinedExprClass: |
| return EmitPredefinedLValue(cast<PredefinedExpr>(E)); |
| case Expr::StringLiteralClass: |
| return EmitStringLiteralLValue(cast<StringLiteral>(E)); |
| case Expr::ObjCEncodeExprClass: |
| return EmitObjCEncodeExprLValue(cast<ObjCEncodeExpr>(E)); |
| case Expr::PseudoObjectExprClass: |
| return EmitPseudoObjectLValue(cast<PseudoObjectExpr>(E)); |
| case Expr::InitListExprClass: |
| return EmitInitListLValue(cast<InitListExpr>(E)); |
| case Expr::CXXTemporaryObjectExprClass: |
| case Expr::CXXConstructExprClass: |
| return EmitCXXConstructLValue(cast<CXXConstructExpr>(E)); |
| case Expr::CXXBindTemporaryExprClass: |
| return EmitCXXBindTemporaryLValue(cast<CXXBindTemporaryExpr>(E)); |
| case Expr::CXXUuidofExprClass: |
| return EmitCXXUuidofLValue(cast<CXXUuidofExpr>(E)); |
| case Expr::LambdaExprClass: |
| return EmitLambdaLValue(cast<LambdaExpr>(E)); |
| |
| case Expr::ExprWithCleanupsClass: { |
| const auto *cleanups = cast<ExprWithCleanups>(E); |
| enterFullExpression(cleanups); |
| RunCleanupsScope Scope(*this); |
| return EmitLValue(cleanups->getSubExpr()); |
| } |
| |
| case Expr::CXXDefaultArgExprClass: |
| return EmitLValue(cast<CXXDefaultArgExpr>(E)->getExpr()); |
| case Expr::CXXDefaultInitExprClass: { |
| CXXDefaultInitExprScope Scope(*this); |
| return EmitLValue(cast<CXXDefaultInitExpr>(E)->getExpr()); |
| } |
| case Expr::CXXTypeidExprClass: |
| return EmitCXXTypeidLValue(cast<CXXTypeidExpr>(E)); |
| |
| case Expr::ObjCMessageExprClass: |
| return EmitObjCMessageExprLValue(cast<ObjCMessageExpr>(E)); |
| case Expr::ObjCIvarRefExprClass: |
| return EmitObjCIvarRefLValue(cast<ObjCIvarRefExpr>(E)); |
| case Expr::StmtExprClass: |
| return EmitStmtExprLValue(cast<StmtExpr>(E)); |
| case Expr::UnaryOperatorClass: |
| return EmitUnaryOpLValue(cast<UnaryOperator>(E)); |
| case Expr::ArraySubscriptExprClass: |
| return EmitArraySubscriptExpr(cast<ArraySubscriptExpr>(E)); |
| case Expr::OMPArraySectionExprClass: |
| return EmitOMPArraySectionExpr(cast<OMPArraySectionExpr>(E)); |
| case Expr::ExtVectorElementExprClass: |
| return EmitExtVectorElementExpr(cast<ExtVectorElementExpr>(E)); |
| case Expr::MemberExprClass: |
| return EmitMemberExpr(cast<MemberExpr>(E)); |
| case Expr::CompoundLiteralExprClass: |
| return EmitCompoundLiteralLValue(cast<CompoundLiteralExpr>(E)); |
| case Expr::ConditionalOperatorClass: |
| return EmitConditionalOperatorLValue(cast<ConditionalOperator>(E)); |
| case Expr::BinaryConditionalOperatorClass: |
| return EmitConditionalOperatorLValue(cast<BinaryConditionalOperator>(E)); |
| case Expr::ChooseExprClass: |
| return EmitLValue(cast<ChooseExpr>(E)->getChosenSubExpr()); |
| case Expr::OpaqueValueExprClass: |
| return EmitOpaqueValueLValue(cast<OpaqueValueExpr>(E)); |
| case Expr::SubstNonTypeTemplateParmExprClass: |
| return EmitLValue(cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement()); |
| case Expr::ImplicitCastExprClass: |
| case Expr::CStyleCastExprClass: |
| case Expr::CXXFunctionalCastExprClass: |
| case Expr::CXXStaticCastExprClass: |
| case Expr::CXXDynamicCastExprClass: |
| case Expr::CXXReinterpretCastExprClass: |
| case Expr::CXXConstCastExprClass: |
| case Expr::ObjCBridgedCastExprClass: |
| return EmitCastLValue(cast<CastExpr>(E)); |
| |
| case Expr::MaterializeTemporaryExprClass: |
| return EmitMaterializeTemporaryExpr(cast<MaterializeTemporaryExpr>(E)); |
| } |
| } |
| |
| /// Given an object of the given canonical type, can we safely copy a |
| /// value out of it based on its initializer? |
| static bool isConstantEmittableObjectType(QualType type) { |
| assert(type.isCanonical()); |
| assert(!type->isReferenceType()); |
| |
| // Must be const-qualified but non-volatile. |
| Qualifiers qs = type.getLocalQualifiers(); |
| if (!qs.hasConst() || qs.hasVolatile()) return false; |
| |
| // Otherwise, all object types satisfy this except C++ classes with |
| // mutable subobjects or non-trivial copy/destroy behavior. |
| if (const auto *RT = dyn_cast<RecordType>(type)) |
| if (const auto *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) |
| if (RD->hasMutableFields() || !RD->isTrivial()) |
| return false; |
| |
| return true; |
| } |
| |
| /// Can we constant-emit a load of a reference to a variable of the |
| /// given type? This is different from predicates like |
| /// Decl::isUsableInConstantExpressions because we do want it to apply |
| /// in situations that don't necessarily satisfy the language's rules |
| /// for this (e.g. C++'s ODR-use rules). For example, we want to able |
| /// to do this with const float variables even if those variables |
| /// aren't marked 'constexpr'. |
| enum ConstantEmissionKind { |
| CEK_None, |
| CEK_AsReferenceOnly, |
| CEK_AsValueOrReference, |
| CEK_AsValueOnly |
| }; |
| static ConstantEmissionKind checkVarTypeForConstantEmission(QualType type) { |
| type = type.getCanonicalType(); |
| if (const auto *ref = dyn_cast<ReferenceType>(type)) { |
| if (isConstantEmittableObjectType(ref->getPointeeType())) |
| return CEK_AsValueOrReference; |
| return CEK_AsReferenceOnly; |
| } |
| if (isConstantEmittableObjectType(type)) |
| return CEK_AsValueOnly; |
| return CEK_None; |
| } |
| |
| /// Try to emit a reference to the given value without producing it as |
| /// an l-value. This is actually more than an optimization: we can't |
| /// produce an l-value for variables that we never actually captured |
| /// in a block or lambda, which means const int variables or constexpr |
| /// literals or similar. |
| CodeGenFunction::ConstantEmission |
| CodeGenFunction::tryEmitAsConstant(DeclRefExpr *refExpr) { |
| ValueDecl *value = refExpr->getDecl(); |
| |
| // The value needs to be an enum constant or a constant variable. |
| ConstantEmissionKind CEK; |
| if (isa<ParmVarDecl>(value)) { |
| CEK = CEK_None; |
| } else if (auto *var = dyn_cast<VarDecl>(value)) { |
| CEK = checkVarTypeForConstantEmission(var->getType()); |
| } else if (isa<EnumConstantDecl>(value)) { |
| CEK = CEK_AsValueOnly; |
| } else { |
| CEK = CEK_None; |
| } |
| if (CEK == CEK_None) return ConstantEmission(); |
| |
| Expr::EvalResult result; |
| bool resultIsReference; |
| QualType resultType; |
| |
| // It's best to evaluate all the way as an r-value if that's permitted. |
| if (CEK != CEK_AsReferenceOnly && |
| refExpr->EvaluateAsRValue(result, getContext())) { |
| resultIsReference = false; |
| resultType = refExpr->getType(); |
| |
| // Otherwise, try to evaluate as an l-value. |
| } else if (CEK != CEK_AsValueOnly && |
| refExpr->EvaluateAsLValue(result, getContext())) { |
| resultIsReference = true; |
| resultType = value->getType(); |
| |
| // Failure. |
| } else { |
| return ConstantEmission(); |
| } |
| |
| // In any case, if the initializer has side-effects, abandon ship. |
| if (result.HasSideEffects) |
| return ConstantEmission(); |
| |
| // Emit as a constant. |
| llvm::Constant *C = CGM.EmitConstantValue(result.Val, resultType, this); |
| |
| // Make sure we emit a debug reference to the global variable. |
| // This should probably fire even for |
| if (isa<VarDecl>(value)) { |
| if (!getContext().DeclMustBeEmitted(cast<VarDecl>(value))) |
| EmitDeclRefExprDbgValue(refExpr, result.Val); |
| } else { |
| assert(isa<EnumConstantDecl>(value)); |
| EmitDeclRefExprDbgValue(refExpr, result.Val); |
| } |
| |
| // If we emitted a reference constant, we need to dereference that. |
| if (resultIsReference) |
| return ConstantEmission::forReference(C); |
| |
| return ConstantEmission::forValue(C); |
| } |
| |
| llvm::Value *CodeGenFunction::EmitLoadOfScalar(LValue lvalue, |
| SourceLocation Loc) { |
| return EmitLoadOfScalar(lvalue.getAddress(), lvalue.isVolatile(), |
| lvalue.getType(), Loc, lvalue.getAlignmentSource(), |
| lvalue.getTBAAInfo(), |
| lvalue.getTBAABaseType(), lvalue.getTBAAOffset(), |
| lvalue.isNontemporal()); |
| } |
| |
| static bool hasBooleanRepresentation(QualType Ty) { |
| if (Ty->isBooleanType()) |
| return true; |
| |
| if (const EnumType *ET = Ty->getAs<EnumType>()) |
| return ET->getDecl()->getIntegerType()->isBooleanType(); |
| |
| if (const AtomicType *AT = Ty->getAs<AtomicType>()) |
| return hasBooleanRepresentation(AT->getValueType()); |
| |
| return false; |
| } |
| |
| static bool getRangeForType(CodeGenFunction &CGF, QualType Ty, |
| llvm::APInt &Min, llvm::APInt &End, |
| bool StrictEnums, bool IsBool) { |
| const EnumType *ET = Ty->getAs<EnumType>(); |
| bool IsRegularCPlusPlusEnum = CGF.getLangOpts().CPlusPlus && StrictEnums && |
| ET && !ET->getDecl()->isFixed(); |
| if (!IsBool && !IsRegularCPlusPlusEnum) |
| return false; |
| |
| if (IsBool) { |
| Min = llvm::APInt(CGF.getContext().getTypeSize(Ty), 0); |
| End = llvm::APInt(CGF.getContext().getTypeSize(Ty), 2); |
| } else { |
| const EnumDecl *ED = ET->getDecl(); |
| llvm::Type *LTy = CGF.ConvertTypeForMem(ED->getIntegerType()); |
| unsigned Bitwidth = LTy->getScalarSizeInBits(); |
| unsigned NumNegativeBits = ED->getNumNegativeBits(); |
| unsigned NumPositiveBits = ED->getNumPositiveBits(); |
| |
| if (NumNegativeBits) { |
| unsigned NumBits = std::max(NumNegativeBits, NumPositiveBits + 1); |
| assert(NumBits <= Bitwidth); |
| End = llvm::APInt(Bitwidth, 1) << (NumBits - 1); |
| Min = -End; |
| } else { |
| assert(NumPositiveBits <= Bitwidth); |
| End = llvm::APInt(Bitwidth, 1) << NumPositiveBits; |
| Min = llvm::APInt(Bitwidth, 0); |
| } |
| } |
| return true; |
| } |
| |
| llvm::MDNode *CodeGenFunction::getRangeForLoadFromType(QualType Ty) { |
| llvm::APInt Min, End; |
| if (!getRangeForType(*this, Ty, Min, End, CGM.getCodeGenOpts().StrictEnums, |
| hasBooleanRepresentation(Ty))) |
| return nullptr; |
| |
| llvm::MDBuilder MDHelper(getLLVMContext()); |
| return MDHelper.createRange(Min, End); |
| } |
| |
| llvm::Value *CodeGenFunction::EmitLoadOfScalar(Address Addr, bool Volatile, |
| QualType Ty, |
| SourceLocation Loc, |
| AlignmentSource AlignSource, |
| llvm::MDNode *TBAAInfo, |
| QualType TBAABaseType, |
| uint64_t TBAAOffset, |
| bool isNontemporal) { |
| // For better performance, handle vector loads differently. |
| if (Ty->isVectorType()) { |
| const llvm::Type *EltTy = Addr.getElementType(); |
| |
| const auto *VTy = cast<llvm::VectorType>(EltTy); |
| |
| // Handle vectors of size 3 like size 4 for better performance. |
| if (VTy->getNumElements() == 3) { |
| |
| // Bitcast to vec4 type. |
| llvm::VectorType *vec4Ty = llvm::VectorType::get(VTy->getElementType(), |
| 4); |
| Address Cast = Builder.CreateElementBitCast(Addr, vec4Ty, "castToVec4"); |
| // Now load value. |
| llvm::Value *V = Builder.CreateLoad(Cast, Volatile, "loadVec4"); |
| |
| // Shuffle vector to get vec3. |
| V = Builder.CreateShuffleVector(V, llvm::UndefValue::get(vec4Ty), |
| {0, 1, 2}, "extractVec"); |
| return EmitFromMemory(V, Ty); |
| } |
| } |
| |
| // Atomic operations have to be done on integral types. |
| LValue AtomicLValue = |
| LValue::MakeAddr(Addr, Ty, getContext(), AlignSource, TBAAInfo); |
| if (Ty->isAtomicType() || LValueIsSuitableForInlineAtomic(AtomicLValue)) { |
| return EmitAtomicLoad(AtomicLValue, Loc).getScalarVal(); |
| } |
| |
| llvm::LoadInst *Load = Builder.CreateLoad(Addr, Volatile); |
| if (isNontemporal) { |
| llvm::MDNode *Node = llvm::MDNode::get( |
| Load->getContext(), llvm::ConstantAsMetadata::get(Builder.getInt32(1))); |
| Load->setMetadata(CGM.getModule().getMDKindID("nontemporal"), Node); |
| } |
| if (TBAAInfo) { |
| llvm::MDNode *TBAAPath = CGM.getTBAAStructTagInfo(TBAABaseType, TBAAInfo, |
| TBAAOffset); |
| if (TBAAPath) |
| CGM.DecorateInstructionWithTBAA(Load, TBAAPath, |
| false /*ConvertTypeToTag*/); |
| } |
| |
| bool IsBool = hasBooleanRepresentation(Ty) || |
| NSAPI(CGM.getContext()).isObjCBOOLType(Ty); |
| bool NeedsBoolCheck = SanOpts.has(SanitizerKind::Bool) && IsBool; |
| bool NeedsEnumCheck = |
| SanOpts.has(SanitizerKind::Enum) && Ty->getAs<EnumType>(); |
| if (NeedsBoolCheck || NeedsEnumCheck) { |
| SanitizerScope SanScope(this); |
| llvm::APInt Min, End; |
| if (getRangeForType(*this, Ty, Min, End, /*StrictEnums=*/true, IsBool)) { |
| --End; |
| llvm::Value *Check; |
| if (!Min) |
| Check = Builder.CreateICmpULE( |
| Load, llvm::ConstantInt::get(getLLVMContext(), End)); |
| else { |
| llvm::Value *Upper = Builder.CreateICmpSLE( |
| Load, llvm::ConstantInt::get(getLLVMContext(), End)); |
| llvm::Value *Lower = Builder.CreateICmpSGE( |
| Load, llvm::ConstantInt::get(getLLVMContext(), Min)); |
| Check = Builder.CreateAnd(Upper, Lower); |
| } |
| llvm::Constant *StaticArgs[] = { |
| EmitCheckSourceLocation(Loc), |
| EmitCheckTypeDescriptor(Ty) |
| }; |
| SanitizerMask Kind = NeedsEnumCheck ? SanitizerKind::Enum : SanitizerKind::Bool; |
| EmitCheck(std::make_pair(Check, Kind), SanitizerHandler::LoadInvalidValue, |
| StaticArgs, EmitCheckValue(Load)); |
| } |
| } else if (CGM.getCodeGenOpts().OptimizationLevel > 0) |
| if (llvm::MDNode *RangeInfo = getRangeForLoadFromType(Ty)) |
| Load->setMetadata(llvm::LLVMContext::MD_range, RangeInfo); |
| |
| return EmitFromMemory(Load, Ty); |
| } |
| |
| llvm::Value *CodeGenFunction::EmitToMemory(llvm::Value *Value, QualType Ty) { |
| // Bool has a different representation in memory than in registers. |
| if (hasBooleanRepresentation(Ty)) { |
| // This should really always be an i1, but sometimes it's already |
| // an i8, and it's awkward to track those cases down. |
| if (Value->getType()->isIntegerTy(1)) |
| return Builder.CreateZExt(Value, ConvertTypeForMem(Ty), "frombool"); |
| assert(Value->getType()->isIntegerTy(getContext().getTypeSize(Ty)) && |
| "wrong value rep of bool"); |
| } |
| |
| return Value; |
| } |
| |
| llvm::Value *CodeGenFunction::EmitFromMemory(llvm::Value *Value, QualType Ty) { |
| // Bool has a different representation in memory than in registers. |
| if (hasBooleanRepresentation(Ty)) { |
| assert(Value->getType()->isIntegerTy(getContext().getTypeSize(Ty)) && |
| "wrong value rep of bool"); |
| return Builder.CreateTrunc(Value, Builder.getInt1Ty(), "tobool"); |
| } |
| |
| return Value; |
| } |
| |
| void CodeGenFunction::EmitStoreOfScalar(llvm::Value *Value, Address Addr, |
| bool Volatile, QualType Ty, |
| AlignmentSource AlignSource, |
| llvm::MDNode *TBAAInfo, |
| bool isInit, QualType TBAABaseType, |
| uint64_t TBAAOffset, |
| bool isNontemporal) { |
| |
| // Handle vectors differently to get better performance. |
| if (Ty->isVectorType()) { |
| llvm::Type *SrcTy = Value->getType(); |
| auto *VecTy = cast<llvm::VectorType>(SrcTy); |
| // Handle vec3 special. |
| if (VecTy->getNumElements() == 3) { |
| // Our source is a vec3, do a shuffle vector to make it a vec4. |
| llvm::Constant *Mask[] = {Builder.getInt32(0), Builder.getInt32(1), |
| Builder.getInt32(2), |
| llvm::UndefValue::get(Builder.getInt32Ty())}; |
| llvm::Value *MaskV = llvm::ConstantVector::get(Mask); |
| Value = Builder.CreateShuffleVector(Value, |
| llvm::UndefValue::get(VecTy), |
| MaskV, "extractVec"); |
| SrcTy = llvm::VectorType::get(VecTy->getElementType(), 4); |
| } |
| if (Addr.getElementType() != SrcTy) { |
| Addr = Builder.CreateElementBitCast(Addr, SrcTy, "storetmp"); |
| } |
| } |
| |
| Value = EmitToMemory(Value, Ty); |
| |
| LValue AtomicLValue = |
| LValue::MakeAddr(Addr, Ty, getContext(), AlignSource, TBAAInfo); |
| if (Ty->isAtomicType() || |
| (!isInit && LValueIsSuitableForInlineAtomic(AtomicLValue))) { |
| EmitAtomicStore(RValue::get(Value), AtomicLValue, isInit); |
| return; |
| } |
| |
| llvm::StoreInst *Store = Builder.CreateStore(Value, Addr, Volatile); |
| if (isNontemporal) { |
| llvm::MDNode *Node = |
| llvm::MDNode::get(Store->getContext(), |
| llvm::ConstantAsMetadata::get(Builder.getInt32(1))); |
| Store->setMetadata(CGM.getModule().getMDKindID("nontemporal"), Node); |
| } |
| if (TBAAInfo) { |
| llvm::MDNode *TBAAPath = CGM.getTBAAStructTagInfo(TBAABaseType, TBAAInfo, |
| TBAAOffset); |
| if (TBAAPath) |
| CGM.DecorateInstructionWithTBAA(Store, TBAAPath, |
| false /*ConvertTypeToTag*/); |
| } |
| } |
| |
| void CodeGenFunction::EmitStoreOfScalar(llvm::Value *value, LValue lvalue, |
| bool isInit) { |
| EmitStoreOfScalar(value, lvalue.getAddress(), lvalue.isVolatile(), |
| lvalue.getType(), lvalue.getAlignmentSource(), |
| lvalue.getTBAAInfo(), isInit, lvalue.getTBAABaseType(), |
| lvalue.getTBAAOffset(), lvalue.isNontemporal()); |
| } |
| |
| /// EmitLoadOfLValue - Given an expression that represents a value lvalue, this |
| /// method emits the address of the lvalue, then loads the result as an rvalue, |
| /// returning the rvalue. |
| RValue CodeGenFunction::EmitLoadOfLValue(LValue LV, SourceLocation Loc) { |
| if (LV.isObjCWeak()) { |
| // load of a __weak object. |
| Address AddrWeakObj = LV.getAddress(); |
| return RValue::get(CGM.getObjCRuntime().EmitObjCWeakRead(*this, |
| AddrWeakObj)); |
| } |
| if (LV.getQuals().getObjCLifetime() == Qualifiers::OCL_Weak) { |
| // In MRC mode, we do a load+autorelease. |
| if (!getLangOpts().ObjCAutoRefCount) { |
| return RValue::get(EmitARCLoadWeak(LV.getAddress())); |
| } |
| |
| // In ARC mode, we load retained and then consume the value. |
| llvm::Value *Object = EmitARCLoadWeakRetained(LV.getAddress()); |
| Object = EmitObjCConsumeObject(LV.getType(), Object); |
| return RValue::get(Object); |
| } |
| |
| if (LV.isSimple()) { |
| assert(!LV.getType()->isFunctionType()); |
| |
| // Everything needs a load. |
| return RValue::get(EmitLoadOfScalar(LV, Loc)); |
| } |
| |
| if (LV.isVectorElt()) { |
| llvm::LoadInst *Load = Builder.CreateLoad(LV.getVectorAddress(), |
| LV.isVolatileQualified()); |
| return RValue::get(Builder.CreateExtractElement(Load, LV.getVectorIdx(), |
| "vecext")); |
| } |
| |
| // If this is a reference to a subset of the elements of a vector, either |
| // shuffle the input or extract/insert them as appropriate. |
| if (LV.isExtVectorElt()) |
| return EmitLoadOfExtVectorElementLValue(LV); |
| |
| // Global Register variables always invoke intrinsics |
| if (LV.isGlobalReg()) |
| return EmitLoadOfGlobalRegLValue(LV); |
| |
| assert(LV.isBitField() && "Unknown LValue type!"); |
| return EmitLoadOfBitfieldLValue(LV); |
| } |
| |
| RValue CodeGenFunction::EmitLoadOfBitfieldLValue(LValue LV) { |
| const CGBitFieldInfo &Info = LV.getBitFieldInfo(); |
| |
| // Get the output type. |
| llvm::Type *ResLTy = ConvertType(LV.getType()); |
| |
| Address Ptr = LV.getBitFieldAddress(); |
| llvm::Value *Val = Builder.CreateLoad(Ptr, LV.isVolatileQualified(), "bf.load"); |
| |
| if (Info.IsSigned) { |
| assert(static_cast<unsigned>(Info.Offset + Info.Size) <= Info.StorageSize); |
| unsigned HighBits = Info.StorageSize - Info.Offset - Info.Size; |
| if (HighBits) |
| Val = Builder.CreateShl(Val, HighBits, "bf.shl"); |
| if (Info.Offset + HighBits) |
| Val = Builder.CreateAShr(Val, Info.Offset + HighBits, "bf.ashr"); |
| } else { |
| if (Info.Offset) |
| Val = Builder.CreateLShr(Val, Info.Offset, "bf.lshr"); |
| if (static_cast<unsigned>(Info.Offset) + Info.Size < Info.StorageSize) |
| Val = Builder.CreateAnd(Val, llvm::APInt::getLowBitsSet(Info.StorageSize, |
| Info.Size), |
| "bf.clear"); |
| } |
| Val = Builder.CreateIntCast(Val, ResLTy, Info.IsSigned, "bf.cast"); |
| |
| return RValue::get(Val); |
| } |
| |
| // If this is a reference to a subset of the elements of a vector, create an |
| // appropriate shufflevector. |
| RValue CodeGenFunction::EmitLoadOfExtVectorElementLValue(LValue LV) { |
| llvm::Value *Vec = Builder.CreateLoad(LV.getExtVectorAddress(), |
| LV.isVolatileQualified()); |
| |
| const llvm::Constant *Elts = LV.getExtVectorElts(); |
| |
| // If the result of the expression is a non-vector type, we must be extracting |
| // a single element. Just codegen as an extractelement. |
| const VectorType *ExprVT = LV.getType()->getAs<VectorType>(); |
| if (!ExprVT) { |
| unsigned InIdx = getAccessedFieldNo(0, Elts); |
| llvm::Value *Elt = llvm::ConstantInt::get(SizeTy, InIdx); |
| return RValue::get(Builder.CreateExtractElement(Vec, Elt)); |
| } |
| |
| // Always use shuffle vector to try to retain the original program structure |
| unsigned NumResultElts = ExprVT->getNumElements(); |
| |
| SmallVector<llvm::Constant*, 4> Mask; |
| for (unsigned i = 0; i != NumResultElts; ++i) |
| Mask.push_back(Builder.getInt32(getAccessedFieldNo(i, Elts))); |
| |
| llvm::Value *MaskV = llvm::ConstantVector::get(Mask); |
| Vec = Builder.CreateShuffleVector(Vec, llvm::UndefValue::get(Vec->getType()), |
| MaskV); |
| return RValue::get(Vec); |
| } |
| |
| /// @brief Generates lvalue for partial ext_vector access. |
| Address CodeGenFunction::EmitExtVectorElementLValue(LValue LV) { |
| Address VectorAddress = LV.getExtVectorAddress(); |
| const VectorType *ExprVT = LV.getType()->getAs<VectorType>(); |
| QualType EQT = ExprVT->getElementType(); |
| llvm::Type *VectorElementTy = CGM.getTypes().ConvertType(EQT); |
| |
| Address CastToPointerElement = |
| Builder.CreateElementBitCast(VectorAddress, VectorElementTy, |
| "conv.ptr.element"); |
| |
| const llvm::Constant *Elts = LV.getExtVectorElts(); |
| unsigned ix = getAccessedFieldNo(0, Elts); |
| |
| Address VectorBasePtrPlusIx = |
| Builder.CreateConstInBoundsGEP(CastToPointerElement, ix, |
| getContext().getTypeSizeInChars(EQT), |
| "vector.elt"); |
| |
| return VectorBasePtrPlusIx; |
| } |
| |
| /// @brief Load of global gamed gegisters are always calls to intrinsics. |
| RValue CodeGenFunction::EmitLoadOfGlobalRegLValue(LValue LV) { |
| assert((LV.getType()->isIntegerType() || LV.getType()->isPointerType()) && |
| "Bad type for register variable"); |
| llvm::MDNode *RegName = cast<llvm::MDNode>( |
| cast<llvm::MetadataAsValue>(LV.getGlobalReg())->getMetadata()); |
| |
| // We accept integer and pointer types only |
| llvm::Type *OrigTy = CGM.getTypes().ConvertType(LV.getType()); |
| llvm::Type *Ty = OrigTy; |
| if (OrigTy->isPointerTy()) |
| Ty = CGM.getTypes().getDataLayout().getIntPtrType(OrigTy); |
| llvm::Type *Types[] = { Ty }; |
| |
| llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::read_register, Types); |
| llvm::Value *Call = Builder.CreateCall( |
| F, llvm::MetadataAsValue::get(Ty->getContext(), RegName)); |
| if (OrigTy->isPointerTy()) |
| Call = Builder.CreateIntToPtr(Call, OrigTy); |
| return RValue::get(Call); |
| } |
| |
| |
| /// EmitStoreThroughLValue - Store the specified rvalue into the specified |
| /// lvalue, where both are guaranteed to the have the same type, and that type |
| /// is 'Ty'. |
| void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst, |
| bool isInit) { |
| if (!Dst.isSimple()) { |
| if (Dst.isVectorElt()) { |
| // Read/modify/write the vector, inserting the new element. |
| llvm::Value *Vec = Builder.CreateLoad(Dst.getVectorAddress(), |
| Dst.isVolatileQualified()); |
| Vec = Builder.CreateInsertElement(Vec, Src.getScalarVal(), |
| Dst.getVectorIdx(), "vecins"); |
| Builder.CreateStore(Vec, Dst.getVectorAddress(), |
| Dst.isVolatileQualified()); |
| return; |
| } |
| |
| // If this is an update of extended vector elements, insert them as |
| // appropriate. |
| if (Dst.isExtVectorElt()) |
| return EmitStoreThroughExtVectorComponentLValue(Src, Dst); |
| |
| if (Dst.isGlobalReg()) |
| return EmitStoreThroughGlobalRegLValue(Src, Dst); |
| |
| assert(Dst.isBitField() && "Unknown LValue type"); |
| return EmitStoreThroughBitfieldLValue(Src, Dst); |
| } |
| |
| // There's special magic for assigning into an ARC-qualified l-value. |
| if (Qualifiers::ObjCLifetime Lifetime = Dst.getQuals().getObjCLifetime()) { |
| switch (Lifetime) { |
| case Qualifiers::OCL_None: |
| llvm_unreachable("present but none"); |
| |
| case Qualifiers::OCL_ExplicitNone: |
| // nothing special |
| break; |
| |
| case Qualifiers::OCL_Strong: |
| if (isInit) { |
| Src = RValue::get(EmitARCRetain(Dst.getType(), Src.getScalarVal())); |
| break; |
| } |
| EmitARCStoreStrong(Dst, Src.getScalarVal(), /*ignore*/ true); |
| return; |
| |
| case Qualifiers::OCL_Weak: |
| if (isInit) |
| // Initialize and then skip the primitive store. |
| EmitARCInitWeak(Dst.getAddress(), Src.getScalarVal()); |
| else |
| EmitARCStoreWeak(Dst.getAddress(), Src.getScalarVal(), /*ignore*/ true); |
| return; |
| |
| case Qualifiers::OCL_Autoreleasing: |
| Src = RValue::get(EmitObjCExtendObjectLifetime(Dst.getType(), |
| Src.getScalarVal())); |
| // fall into the normal path |
| break; |
| } |
| } |
| |
| if (Dst.isObjCWeak() && !Dst.isNonGC()) { |
| // load of a __weak object. |
| Address LvalueDst = Dst.getAddress(); |
| llvm::Value *src = Src.getScalarVal(); |
| CGM.getObjCRuntime().EmitObjCWeakAssign(*this, src, LvalueDst); |
| return; |
| } |
| |
| if (Dst.isObjCStrong() && !Dst.isNonGC()) { |
| // load of a __strong object. |
| Address LvalueDst = Dst.getAddress(); |
| llvm::Value *src = Src.getScalarVal(); |
| if (Dst.isObjCIvar()) { |
| assert(Dst.getBaseIvarExp() && "BaseIvarExp is NULL"); |
| llvm::Type *ResultType = IntPtrTy; |
| Address dst = EmitPointerWithAlignment(Dst.getBaseIvarExp()); |
| llvm::Value *RHS = dst.getPointer(); |
| RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast"); |
| llvm::Value *LHS = |
| Builder.CreatePtrToInt(LvalueDst.getPointer(), ResultType, |
| "sub.ptr.lhs.cast"); |
| llvm::Value *BytesBetween = Builder.CreateSub(LHS, RHS, "ivar.offset"); |
| CGM.getObjCRuntime().EmitObjCIvarAssign(*this, src, dst, |
| BytesBetween); |
| } else if (Dst.isGlobalObjCRef()) { |
| CGM.getObjCRuntime().EmitObjCGlobalAssign(*this, src, LvalueDst, |
| Dst.isThreadLocalRef()); |
| } |
| else |
| CGM.getObjCRuntime().EmitObjCStrongCastAssign(*this, src, LvalueDst); |
| return; |
| } |
| |
| assert(Src.isScalar() && "Can't emit an agg store with this method"); |
| EmitStoreOfScalar(Src.getScalarVal(), Dst, isInit); |
| } |
| |
| void CodeGenFunction::EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, |
| llvm::Value **Result) { |
| const CGBitFieldInfo &Info = Dst.getBitFieldInfo(); |
| llvm::Type *ResLTy = ConvertTypeForMem(Dst.getType()); |
| Address Ptr = Dst.getBitFieldAddress(); |
| |
| // Get the source value, truncated to the width of the bit-field. |
| llvm::Value *SrcVal = Src.getScalarVal(); |
| |
| // Cast the source to the storage type and shift it into place. |
| SrcVal = Builder.CreateIntCast(SrcVal, Ptr.getElementType(), |
| /*IsSigned=*/false); |
| llvm::Value *MaskedVal = SrcVal; |
| |
| // See if there are other bits in the bitfield's storage we'll need to load |
| // and mask together with source before storing. |
| if (Info.StorageSize != Info.Size) { |
| assert(Info.StorageSize > Info.Size && "Invalid bitfield size."); |
| llvm::Value *Val = |
| Builder.CreateLoad(Ptr, Dst.isVolatileQualified(), "bf.load"); |
| |
| // Mask the source value as needed. |
| if (!hasBooleanRepresentation(Dst.getType())) |
| SrcVal = Builder.CreateAnd(SrcVal, |
| llvm::APInt::getLowBitsSet(Info.StorageSize, |
| Info.Size), |
| "bf.value"); |
| MaskedVal = SrcVal; |
| if (Info.Offset) |
| SrcVal = Builder.CreateShl(SrcVal, Info.Offset, "bf.shl"); |
| |
| // Mask out the original value. |
| Val = Builder.CreateAnd(Val, |
| ~llvm::APInt::getBitsSet(Info.StorageSize, |
| Info.Offset, |
| Info.Offset + Info.Size), |
| "bf.clear"); |
| |
| // Or together the unchanged values and the source value. |
| SrcVal = Builder.CreateOr(Val, SrcVal, "bf.set"); |
| } else { |
| assert(Info.Offset == 0); |
| } |
| |
| // Write the new value back out. |
| Builder.CreateStore(SrcVal, Ptr, Dst.isVolatileQualified()); |
| |
| // Return the new value of the bit-field, if requested. |
| if (Result) { |
| llvm::Value *ResultVal = MaskedVal; |
| |
| // Sign extend the value if needed. |
| if (Info.IsSigned) { |
| assert(Info.Size <= Info.StorageSize); |
| unsigned HighBits = Info.StorageSize - Info.Size; |
| if (HighBits) { |
| ResultVal = Builder.CreateShl(ResultVal, HighBits, "bf.result.shl"); |
| ResultVal = Builder.CreateAShr(ResultVal, HighBits, "bf.result.ashr"); |
| } |
| } |
| |
| ResultVal = Builder.CreateIntCast(ResultVal, ResLTy, Info.IsSigned, |
| "bf.result.cast"); |
| *Result = EmitFromMemory(ResultVal, Dst.getType()); |
| } |
| } |
| |
| void CodeGenFunction::EmitStoreThroughExtVectorComponentLValue(RValue Src, |
| LValue Dst) { |
| // This access turns into a read/modify/write of the vector. Load the input |
| // value now. |
| llvm::Value *Vec = Builder.CreateLoad(Dst.getExtVectorAddress(), |
| Dst.isVolatileQualified()); |
| const llvm::Constant *Elts = Dst.getExtVectorElts(); |
| |
| llvm::Value *SrcVal = Src.getScalarVal(); |
| |
| if (const VectorType *VTy = Dst.getType()->getAs<VectorType>()) { |
| unsigned NumSrcElts = VTy->getNumElements(); |
| unsigned NumDstElts = Vec->getType()->getVectorNumElements(); |
| if (NumDstElts == NumSrcElts) { |
| // Use shuffle vector is the src and destination are the same number of |
| // elements and restore the vector mask since it is on the side it will be |
| // stored. |
| SmallVector<llvm::Constant*, 4> Mask(NumDstElts); |
| for (unsigned i = 0; i != NumSrcElts; ++i) |
| Mask[getAccessedFieldNo(i, Elts)] = Builder.getInt32(i); |
| |
| llvm::Value *MaskV = llvm::ConstantVector::get(Mask); |
| Vec = Builder.CreateShuffleVector(SrcVal, |
| llvm::UndefValue::get(Vec->getType()), |
| MaskV); |
| } else if (NumDstElts > NumSrcElts) { |
| // Extended the source vector to the same length and then shuffle it |
| // into the destination. |
| // FIXME: since we're shuffling with undef, can we just use the indices |
| // into that? This could be simpler. |
| SmallVector<llvm::Constant*, 4> ExtMask; |
| for (unsigned i = 0; i != NumSrcElts; ++i) |
| ExtMask.push_back(Builder.getInt32(i)); |
| ExtMask.resize(NumDstElts, llvm::UndefValue::get(Int32Ty)); |
| llvm::Value *ExtMaskV = llvm::ConstantVector::get(ExtMask); |
| llvm::Value *ExtSrcVal = |
| Builder.CreateShuffleVector(SrcVal, |
| llvm::UndefValue::get(SrcVal->getType()), |
| ExtMaskV); |
| // build identity |
| SmallVector<llvm::Constant*, 4> Mask; |
| for (unsigned i = 0; i != NumDstElts; ++i) |
| Mask.push_back(Builder.getInt32(i)); |
| |
| // When the vector size is odd and .odd or .hi is used, the last element |
| // of the Elts constant array will be one past the size of the vector. |
| // Ignore the last element here, if it is greater than the mask size. |
| if (getAccessedFieldNo(NumSrcElts - 1, Elts) == Mask.size()) |
| NumSrcElts--; |
| |
| // modify when what gets shuffled in |
| for (unsigned i = 0; i != NumSrcElts; ++i) |
| Mask[getAccessedFieldNo(i, Elts)] = Builder.getInt32(i+NumDstElts); |
| llvm::Value *MaskV = llvm::ConstantVector::get(Mask); |
| Vec = Builder.CreateShuffleVector(Vec, ExtSrcVal, MaskV); |
| } else { |
| // We should never shorten the vector |
| llvm_unreachable("unexpected shorten vector length"); |
| } |
| } else { |
| // If the Src is a scalar (not a vector) it must be updating one element. |
| unsigned InIdx = getAccessedFieldNo(0, Elts); |
| llvm::Value *Elt = llvm::ConstantInt::get(SizeTy, InIdx); |
| Vec = Builder.CreateInsertElement(Vec, SrcVal, Elt); |
| } |
| |
| Builder.CreateStore(Vec, Dst.getExtVectorAddress(), |
| Dst.isVolatileQualified()); |
| } |
| |
| /// @brief Store of global named registers are always calls to intrinsics. |
| void CodeGenFunction::EmitStoreThroughGlobalRegLValue(RValue Src, LValue Dst) { |
| assert((Dst.getType()->isIntegerType() || Dst.getType()->isPointerType()) && |
| "Bad type for register variable"); |
| llvm::MDNode *RegName = cast<llvm::MDNode>( |
| cast<llvm::MetadataAsValue>(Dst.getGlobalReg())->getMetadata()); |
| assert(RegName && "Register LValue is not metadata"); |
| |
| // We accept integer and pointer types only |
| llvm::Type *OrigTy = CGM.getTypes().ConvertType(Dst.getType()); |
| llvm::Type *Ty = OrigTy; |
| if (OrigTy->isPointerTy()) |
| Ty = CGM.getTypes().getDataLayout().getIntPtrType(OrigTy); |
| llvm::Type *Types[] = { Ty }; |
| |
| llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::write_register, Types); |
| llvm::Value *Value = Src.getScalarVal(); |
| if (OrigTy->isPointerTy()) |
| Value = Builder.CreatePtrToInt(Value, Ty); |
| Builder.CreateCall( |
| F, {llvm::MetadataAsValue::get(Ty->getContext(), RegName), Value}); |
| } |
| |
| // setObjCGCLValueClass - sets class of the lvalue for the purpose of |
| // generating write-barries API. It is currently a global, ivar, |
| // or neither. |
| static void setObjCGCLValueClass(const ASTContext &Ctx, const Expr *E, |
| LValue &LV, |
| bool IsMemberAccess=false) { |
| if (Ctx.getLangOpts().getGC() == LangOptions::NonGC) |
| return; |
| |
| if (isa<ObjCIvarRefExpr>(E)) { |
| QualType ExpTy = E->getType(); |
| if (IsMemberAccess && ExpTy->isPointerType()) { |
| // If ivar is a structure pointer, assigning to field of |
| // this struct follows gcc's behavior and makes it a non-ivar |
| // writer-barrier conservatively. |
| ExpTy = ExpTy->getAs<PointerType>()->getPointeeType(); |
| if (ExpTy->isRecordType()) { |
| LV.setObjCIvar(false); |
| return; |
| } |
| } |
| LV.setObjCIvar(true); |
| auto *Exp = cast<ObjCIvarRefExpr>(const_cast<Expr *>(E)); |
| LV.setBaseIvarExp(Exp->getBase()); |
| LV.setObjCArray(E->getType()->isArrayType()); |
| return; |
| } |
| |
| if (const auto *Exp = dyn_cast<DeclRefExpr>(E)) { |
| if (const auto *VD = dyn_cast<VarDecl>(Exp->getDecl())) { |
| if (VD->hasGlobalStorage()) { |
| LV.setGlobalObjCRef(true); |
| LV.setThreadLocalRef(VD->getTLSKind() != VarDecl::TLS_None); |
| } |
| } |
| LV.setObjCArray(E->getType()->isArrayType()); |
| return; |
| } |
| |
| if (const auto *Exp = dyn_cast<UnaryOperator>(E)) { |
| setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess); |
| return; |
| } |
| |
| if (const auto *Exp = dyn_cast<ParenExpr>(E)) { |
| setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess); |
| if (LV.isObjCIvar()) { |
| // If cast is to a structure pointer, follow gcc's behavior and make it |
| // a non-ivar write-barrier. |
| QualType ExpTy = E->getType(); |
| if (ExpTy->isPointerType()) |
| ExpTy = ExpTy->getAs<PointerType>()->getPointeeType(); |
| if (ExpTy->isRecordType()) |
| LV.setObjCIvar(false); |
| } |
| return; |
| } |
| |
| if (const auto *Exp = dyn_cast<GenericSelectionExpr>(E)) { |
| setObjCGCLValueClass(Ctx, Exp->getResultExpr(), LV); |
| return; |
| } |
| |
| if (const auto *Exp = dyn_cast<ImplicitCastExpr>(E)) { |
| setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess); |
| return; |
| } |
| |
| if (const auto *Exp = dyn_cast<CStyleCastExpr>(E)) { |
| setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess); |
| return; |
| } |
| |
| if (const auto *Exp = dyn_cast<ObjCBridgedCastExpr>(E)) { |
| setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess); |
| return; |
| } |
| |
| if (const auto *Exp = dyn_cast<ArraySubscriptExpr>(E)) { |
| setObjCGCLValueClass(Ctx, Exp->getBase(), LV); |
| if (LV.isObjCIvar() && !LV.isObjCArray()) |
| // Using array syntax to assigning to what an ivar points to is not |
| // same as assigning to the ivar itself. {id *Names;} Names[i] = 0; |
| LV.setObjCIvar(false); |
| else if (LV.isGlobalObjCRef() && !LV.isObjCArray()) |
| // Using array syntax to assigning to what global points to is not |
| // same as assigning to the global itself. {id *G;} G[i] = 0; |
| LV.setGlobalObjCRef(false); |
| return; |
| } |
| |
| if (const auto *Exp = dyn_cast<MemberExpr>(E)) { |
| setObjCGCLValueClass(Ctx, Exp->getBase(), LV, true); |
| // We don't know if member is an 'ivar', but this flag is looked at |
| // only in the context of LV.isObjCIvar(). |
| LV.setObjCArray(E->getType()->isArrayType()); |
| return; |
| } |
| } |
| |
| static llvm::Value * |
| EmitBitCastOfLValueToProperType(CodeGenFunction &CGF, |
| llvm::Value *V, llvm::Type *IRType, |
| StringRef Name = StringRef()) { |
| unsigned AS = cast<llvm::PointerType>(V->getType())->getAddressSpace(); |
| return CGF.Builder.CreateBitCast(V, IRType->getPointerTo(AS), Name); |
| } |
| |
| static LValue EmitThreadPrivateVarDeclLValue( |
| CodeGenFunction &CGF, const VarDecl *VD, QualType T, Address Addr, |
| llvm::Type *RealVarTy, SourceLocation Loc) { |
| Addr = CGF.CGM.getOpenMPRuntime().getAddrOfThreadPrivate(CGF, VD, Addr, Loc); |
| Addr = CGF.Builder.CreateElementBitCast(Addr, RealVarTy); |
| return CGF.MakeAddrLValue(Addr, T, AlignmentSource::Decl); |
| } |
| |
| Address CodeGenFunction::EmitLoadOfReference(Address Addr, |
| const ReferenceType *RefTy, |
| AlignmentSource *Source) { |
| llvm::Value *Ptr = Builder.CreateLoad(Addr); |
| return Address(Ptr, getNaturalTypeAlignment(RefTy->getPointeeType(), |
| Source, /*forPointee*/ true)); |
| |
| } |
| |
| LValue CodeGenFunction::EmitLoadOfReferenceLValue(Address RefAddr, |
| const ReferenceType *RefTy) { |
| AlignmentSource Source; |
| Address Addr = EmitLoadOfReference(RefAddr, RefTy, &Source); |
| return MakeAddrLValue(Addr, RefTy->getPointeeType(), Source); |
| } |
| |
| Address CodeGenFunction::EmitLoadOfPointer(Address Ptr, |
| const PointerType *PtrTy, |
| AlignmentSource *Source) { |
| llvm::Value *Addr = Builder.CreateLoad(Ptr); |
| return Address(Addr, getNaturalTypeAlignment(PtrTy->getPointeeType(), Source, |
| /*forPointeeType=*/true)); |
| } |
| |
| LValue CodeGenFunction::EmitLoadOfPointerLValue(Address PtrAddr, |
| const PointerType *PtrTy) { |
| AlignmentSource Source; |
| Address Addr = EmitLoadOfPointer(PtrAddr, PtrTy, &Source); |
| return MakeAddrLValue(Addr, PtrTy->getPointeeType(), Source); |
| } |
| |
| static LValue EmitGlobalVarDeclLValue(CodeGenFunction &CGF, |
| const Expr *E, const VarDecl *VD) { |
| QualType T = E->getType(); |
| |
| // If it's thread_local, emit a call to its wrapper function instead. |
| if (VD->getTLSKind() == VarDecl::TLS_Dynamic && |
| CGF.CGM.getCXXABI().usesThreadWrapperFunction()) |
| return CGF.CGM.getCXXABI().EmitThreadLocalVarDeclLValue(CGF, VD, T); |
| |
| llvm::Value *V = CGF.CGM.GetAddrOfGlobalVar(VD); |
| llvm::Type *RealVarTy = CGF.getTypes().ConvertTypeForMem(VD->getType()); |
| V = EmitBitCastOfLValueToProperType(CGF, V, RealVarTy); |
| CharUnits Alignment = CGF.getContext().getDeclAlign(VD); |
| Address Addr(V, Alignment); |
| LValue LV; |
| // Emit reference to the private copy of the variable if it is an OpenMP |
| // threadprivate variable. |
| if (CGF.getLangOpts().OpenMP && VD->hasAttr<OMPThreadPrivateDeclAttr>()) |
| return EmitThreadPrivateVarDeclLValue(CGF, VD, T, Addr, RealVarTy, |
| E->getExprLoc()); |
| if (auto RefTy = VD->getType()->getAs<ReferenceType>()) { |
| LV = CGF.EmitLoadOfReferenceLValue(Addr, RefTy); |
| } else { |
| LV = CGF.MakeAddrLValue(Addr, T, AlignmentSource::Decl); |
| } |
| setObjCGCLValueClass(CGF.getContext(), E, LV); |
| return LV; |
| } |
| |
| static llvm::Constant *EmitFunctionDeclPointer(CodeGenModule &CGM, |
| const FunctionDecl *FD) { |
| if (FD->hasAttr<WeakRefAttr>()) { |
| ConstantAddress aliasee = CGM.GetWeakRefReference(FD); |
| return aliasee.getPointer(); |
| } |
| |
| llvm::Constant *V = CGM.GetAddrOfFunction(FD); |
| if (!FD->hasPrototype()) { |
| if (const FunctionProtoType *Proto = |
| FD->getType()->getAs<FunctionProtoType>()) { |
| // Ugly case: for a K&R-style definition, the type of the definition |
| // isn't the same as the type of a use. Correct for this with a |
| // bitcast. |
| QualType NoProtoType = |
| CGM.getContext().getFunctionNoProtoType(Proto->getReturnType()); |
| NoProtoType = CGM.getContext().getPointerType(NoProtoType); |
| V = llvm::ConstantExpr::getBitCast(V, |
| CGM.getTypes().ConvertType(NoProtoType)); |
| } |
| } |
| return V; |
| } |
| |
| static LValue EmitFunctionDeclLValue(CodeGenFunction &CGF, |
| const Expr *E, const FunctionDecl *FD) { |
| llvm::Value *V = EmitFunctionDeclPointer(CGF.CGM, FD); |
| CharUnits Alignment = CGF.getContext().getDeclAlign(FD); |
| return CGF.MakeAddrLValue(V, E->getType(), Alignment, AlignmentSource::Decl); |
| } |
| |
| static LValue EmitCapturedFieldLValue(CodeGenFunction &CGF, const FieldDecl *FD, |
| llvm::Value *ThisValue) { |
| QualType TagType = CGF.getContext().getTagDeclType(FD->getParent()); |
| LValue LV = CGF.MakeNaturalAlignAddrLValue(ThisValue, TagType); |
| return CGF.EmitLValueForField(LV, FD); |
| } |
| |
| /// Named Registers are named metadata pointing to the register name |
| /// which will be read from/written to as an argument to the intrinsic |
| /// @llvm.read/write_register. |
| /// So far, only the name is being passed down, but other options such as |
| /// register type, allocation type or even optimization options could be |
| /// passed down via the metadata node. |
| static LValue EmitGlobalNamedRegister(const VarDecl *VD, CodeGenModule &CGM) { |
| SmallString<64> Name("llvm.named.register."); |
| AsmLabelAttr *Asm = VD->getAttr<AsmLabelAttr>(); |
| assert(Asm->getLabel().size() < 64-Name.size() && |
| "Register name too big"); |
| Name.append(Asm->getLabel()); |
| llvm::NamedMDNode *M = |
| CGM.getModule().getOrInsertNamedMetadata(Name); |
| if (M->getNumOperands() == 0) { |
| llvm::MDString *Str = llvm::MDString::get(CGM.getLLVMContext(), |
| Asm->getLabel()); |
| llvm::Metadata *Ops[] = {Str}; |
| M->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops)); |
| } |
| |
| CharUnits Alignment = CGM.getContext().getDeclAlign(VD); |
| |
| llvm::Value *Ptr = |
| llvm::MetadataAsValue::get(CGM.getLLVMContext(), M->getOperand(0)); |
| return LValue::MakeGlobalReg(Address(Ptr, Alignment), VD->getType()); |
| } |
| |
| LValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) { |
| const NamedDecl *ND = E->getDecl(); |
| QualType T = E->getType(); |
| |
| if (const auto *VD = dyn_cast<VarDecl>(ND)) { |
| // Global Named registers access via intrinsics only |
| if (VD->getStorageClass() == SC_Register && |
| VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl()) |
| return EmitGlobalNamedRegister(VD, CGM); |
| |
| // A DeclRefExpr for a reference initialized by a constant expression can |
| // appear without being odr-used. Directly emit the constant initializer. |
| const Expr *Init = VD->getAnyInitializer(VD); |
| if (Init && !isa<ParmVarDecl>(VD) && VD->getType()->isReferenceType() && |
| VD->isUsableInConstantExpressions(getContext()) && |
| VD->checkInitIsICE() && |
| // Do not emit if it is private OpenMP variable. |
| !(E->refersToEnclosingVariableOrCapture() && CapturedStmtInfo && |
| LocalDeclMap.count(VD))) { |
| llvm::Constant *Val = |
| CGM.EmitConstantValue(*VD->evaluateValue(), VD->getType(), this); |
| assert(Val && "failed to emit reference constant expression"); |
| // FIXME: Eventually we will want to emit vector element references. |
| |
| // Should we be using the alignment of the constant pointer we emitted? |
| CharUnits Alignment = getNaturalTypeAlignment(E->getType(), nullptr, |
| /*pointee*/ true); |
| |
| return MakeAddrLValue(Address(Val, Alignment), T, AlignmentSource::Decl); |
| } |
| |
| // Check for captured variables. |
| if (E->refersToEnclosingVariableOrCapture()) { |
| if (auto *FD = LambdaCaptureFields.lookup(VD)) |
| return EmitCapturedFieldLValue(*this, FD, CXXABIThisValue); |
| else if (CapturedStmtInfo) { |
| auto I = LocalDeclMap.find(VD); |
| if (I != LocalDeclMap.end()) { |
| if (auto RefTy = VD->getType()->getAs<ReferenceType>()) |
| return EmitLoadOfReferenceLValue(I->second, RefTy); |
| return MakeAddrLValue(I->second, T); |
| } |
| LValue CapLVal = |
| EmitCapturedFieldLValue(*this, CapturedStmtInfo->lookup(VD), |
| CapturedStmtInfo->getContextValue()); |
| return MakeAddrLValue( |
| Address(CapLVal.getPointer(), getContext().getDeclAlign(VD)), |
| CapLVal.getType(), AlignmentSource::Decl); |
| } |
| |
| assert(isa<BlockDecl>(CurCodeDecl)); |
| Address addr = GetAddrOfBlockDecl(VD, VD->hasAttr<BlocksAttr>()); |
| return MakeAddrLValue(addr, T, AlignmentSource::Decl); |
| } |
| } |
| |
| // FIXME: We should be able to assert this for FunctionDecls as well! |
| // FIXME: We should be able to assert this for all DeclRefExprs, not just |
| // those with a valid source location. |
| assert((ND->isUsed(false) || !isa<VarDecl>(ND) || |
| !E->getLocation().isValid()) && |
| "Should not use decl without marking it used!"); |
| |
| if (ND->hasAttr<WeakRefAttr>()) { |
| const auto *VD = cast<ValueDecl>(ND); |
| ConstantAddress Aliasee = CGM.GetWeakRefReference(VD); |
| return MakeAddrLValue(Aliasee, T, AlignmentSource::Decl); |
| } |
| |
| if (const auto *VD = dyn_cast<VarDecl>(ND)) { |
| // Check if this is a global variable. |
| if (VD->hasLinkage() || VD->isStaticDataMember()) |
| return EmitGlobalVarDeclLValue(*this, E, VD); |
| |
| Address addr = Address::invalid(); |
| |
| // The variable should generally be present in the local decl map. |
| auto iter = LocalDeclMap.find(VD); |
| if (iter != LocalDeclMap.end()) { |
| addr = iter->second; |
| |
| // Otherwise, it might be static local we haven't emitted yet for |
| // some reason; most likely, because it's in an outer function. |
| } else if (VD->isStaticLocal()) { |
| addr = Address(CGM.getOrCreateStaticVarDecl( |
| *VD, CGM.getLLVMLinkageVarDefinition(VD, /*isConstant=*/false)), |
| getContext().getDeclAlign(VD)); |
| |
| // No other cases for now. |
| } else { |
| llvm_unreachable("DeclRefExpr for Decl not entered in LocalDeclMap?"); |
| } |
| |
| |
| // Check for OpenMP threadprivate variables. |
| if (getLangOpts().OpenMP && VD->hasAttr<OMPThreadPrivateDeclAttr>()) { |
| return EmitThreadPrivateVarDeclLValue( |
| *this, VD, T, addr, getTypes().ConvertTypeForMem(VD->getType()), |
| E->getExprLoc()); |
| } |
| |
| // Drill into block byref variables. |
| bool isBlockByref = VD->hasAttr<BlocksAttr>(); |
| if (isBlockByref) { |
| addr = emitBlockByrefAddress(addr, VD); |
| } |
| |
| // Drill into reference types. |
| LValue LV; |
| if (auto RefTy = VD->getType()->getAs<ReferenceType>()) { |
| LV = EmitLoadOfReferenceLValue(addr, RefTy); |
| } else { |
| LV = MakeAddrLValue(addr, T, AlignmentSource::Decl); |
| } |
| |
| bool isLocalStorage = VD->hasLocalStorage(); |
| |
| bool NonGCable = isLocalStorage && |
| !VD->getType()->isReferenceType() && |
| !isBlockByref; |
| if (NonGCable) { |
| LV.getQuals().removeObjCGCAttr(); |
| LV.setNonGC(true); |
| } |
| |
| bool isImpreciseLifetime = |
| (isLocalStorage && !VD->hasAttr<ObjCPreciseLifetimeAttr>()); |
| if (isImpreciseLifetime) |
| LV.setARCPreciseLifetime(ARCImpreciseLifetime); |
| setObjCGCLValueClass(getContext(), E, LV); |
| return LV; |
| } |
| |
| if (const auto *FD = dyn_cast<FunctionDecl>(ND)) |
| return EmitFunctionDeclLValue(*this, E, FD); |
| |
| // FIXME: While we're emitting a binding from an enclosing scope, all other |
| // DeclRefExprs we see should be implicitly treated as if they also refer to |
| // an enclosing scope. |
| if (const auto *BD = dyn_cast<BindingDecl>(ND)) |
| return EmitLValue(BD->getBinding()); |
| |
| llvm_unreachable("Unhandled DeclRefExpr"); |
| } |
| |
| LValue CodeGenFunction::EmitUnaryOpLValue(const UnaryOperator *E) { |
| // __extension__ doesn't affect lvalue-ness. |
| if (E->getOpcode() == UO_Extension) |
| return EmitLValue(E->getSubExpr()); |
| |
| QualType ExprTy = getContext().getCanonicalType(E->getSubExpr()->getType()); |
| switch (E->getOpcode()) { |
| default: llvm_unreachable("Unknown unary operator lvalue!"); |
| case UO_Deref: { |
| QualType T = E->getSubExpr()->getType()->getPointeeType(); |
| assert(!T.isNull() && "CodeGenFunction::EmitUnaryOpLValue: Illegal type"); |
| |
| AlignmentSource AlignSource; |
| Address Addr = EmitPointerWithAlignment(E->getSubExpr(), &AlignSource); |
| LValue LV = MakeAddrLValue(Addr, T, AlignSource); |
| LV.getQuals().setAddressSpace(ExprTy.getAddressSpace()); |
| |
| // We should not generate __weak write barrier on indirect reference |
| // of a pointer to object; as in void foo (__weak id *param); *param = 0; |
| // But, we continue to generate __strong write barrier on indirect write |
| // into a pointer to object. |
| if (getLangOpts().ObjC1 && |
| getLangOpts().getGC() != LangOptions::NonGC && |
| LV.isObjCWeak()) |
| LV.setNonGC(!E->isOBJCGCCandidate(getContext())); |
| return LV; |
| } |
| case UO_Real: |
| case UO_Imag: { |
| LValue LV = EmitLValue(E->getSubExpr()); |
| assert(LV.isSimple() && "real/imag on non-ordinary l-value"); |
| |
| // __real is valid on scalars. This is a faster way of testing that. |
| // __imag can only produce an rvalue on scalars. |
| if (E->getOpcode() == UO_Real && |
| !LV.getAddress().getElementType()->isStructTy()) { |
| assert(E->getSubExpr()->getType()->isArithmeticType()); |
| return LV; |
| } |
| |
| QualType T = ExprTy->castAs<ComplexType>()->getElementType(); |
| |
| Address Component = |
| (E->getOpcode() == UO_Real |
| ? emitAddrOfRealComponent(LV.getAddress(), LV.getType()) |
| : emitAddrOfImagComponent(LV.getAddress(), LV.getType())); |
| LValue ElemLV = MakeAddrLValue(Component, T, LV.getAlignmentSource()); |
| ElemLV.getQuals().addQualifiers(LV.getQuals()); |
| return ElemLV; |
| } |
| case UO_PreInc: |
| case UO_PreDec: { |
| LValue LV = EmitLValue(E->getSubExpr()); |
| bool isInc = E->getOpcode() == UO_PreInc; |
| |
| if (E->getType()->isAnyComplexType()) |
| EmitComplexPrePostIncDec(E, LV, isInc, true/*isPre*/); |
| else |
| EmitScalarPrePostIncDec(E, LV, isInc, true/*isPre*/); |
| return LV; |
| } |
| } |
| } |
| |
| LValue CodeGenFunction::EmitStringLiteralLValue(const StringLiteral *E) { |
| return MakeAddrLValue(CGM.GetAddrOfConstantStringFromLiteral(E), |
| E->getType(), AlignmentSource::Decl); |
| } |
| |
| LValue CodeGenFunction::EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E) { |
| return MakeAddrLValue(CGM.GetAddrOfConstantStringFromObjCEncode(E), |
| E->getType(), AlignmentSource::Decl); |
| } |
| |
| LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) { |
| auto SL = E->getFunctionName(); |
| assert(SL != nullptr && "No StringLiteral name in PredefinedExpr"); |
| StringRef FnName = CurFn->getName(); |
| if (FnName.startswith("\01")) |
| FnName = FnName.substr(1); |
| StringRef NameItems[] = { |
| PredefinedExpr::getIdentTypeName(E->getIdentType()), FnName}; |
| std::string GVName = llvm::join(NameItems, NameItems + 2, "."); |
| if (auto *BD = dyn_cast<BlockDecl>(CurCodeDecl)) { |
| std::string Name = SL->getString(); |
| if (!Name.empty()) { |
| unsigned Discriminator = |
| CGM.getCXXABI().getMangleContext().getBlockId(BD, true); |
| if (Discriminator) |
| Name += "_" + Twine(Discriminator + 1).str(); |
| auto C = CGM.GetAddrOfConstantCString(Name, GVName.c_str()); |
| return MakeAddrLValue(C, E->getType(), AlignmentSource::Decl); |
| } else { |
| auto C = CGM.GetAddrOfConstantCString(FnName, GVName.c_str()); |
| return MakeAddrLValue(C, E->getType(), AlignmentSource::Decl); |
| } |
| } |
| auto C = CGM.GetAddrOfConstantStringFromLiteral(SL, GVName); |
| return MakeAddrLValue(C, E->getType(), AlignmentSource::Decl); |
| } |
| |
| /// Emit a type description suitable for use by a runtime sanitizer library. The |
| /// format of a type descriptor is |
| /// |
| /// \code |
| /// { i16 TypeKind, i16 TypeInfo } |
| /// \endcode |
| /// |
| /// followed by an array of i8 containing the type name. TypeKind is 0 for an |
| /// integer, 1 for a floating point value, and -1 for anything else. |
| llvm::Constant *CodeGenFunction::EmitCheckTypeDescriptor(QualType T) { |
| // Only emit each type's descriptor once. |
| if (llvm::Constant *C = CGM.getTypeDescriptorFromMap(T)) |
| return C; |
| |
| uint16_t TypeKind = -1; |
| uint16_t TypeInfo = 0; |
| |
| if (T->isIntegerType()) { |
| TypeKind = 0; |
| TypeInfo = (llvm::Log2_32(getContext().getTypeSize(T)) << 1) | |
| (T->isSignedIntegerType() ? 1 : 0); |
| } else if (T->isFloatingType()) { |
| TypeKind = 1; |
| TypeInfo = getContext().getTypeSize(T); |
| } |
| |
| // Format the type name as if for a diagnostic, including quotes and |
| // optionally an 'aka'. |
| SmallString<32> Buffer; |
| CGM.getDiags().ConvertArgToString(DiagnosticsEngine::ak_qualtype, |
| (intptr_t)T.getAsOpaquePtr(), |
| StringRef(), StringRef(), None, Buffer, |
| None); |
| |
| llvm::Constant *Components[] = { |
| Builder.getInt16(TypeKind), Builder.getInt16(TypeInfo), |
| llvm::ConstantDataArray::getString(getLLVMContext(), Buffer) |
| }; |
| llvm::Constant *Descriptor = llvm::ConstantStruct::getAnon(Components); |
| |
| auto *GV = new llvm::GlobalVariable( |
| CGM.getModule(), Descriptor->getType(), |
| /*isConstant=*/true, llvm::GlobalVariable::PrivateLinkage, Descriptor); |
| GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); |
| CGM.getSanitizerMetadata()->disableSanitizerForGlobal(GV); |
| |
| // Remember the descriptor for this type. |
| CGM.setTypeDescriptorInMap(T, GV); |
| |
| return GV; |
| } |
| |
| llvm::Value *CodeGenFunction::EmitCheckValue(llvm::Value *V) { |
| llvm::Type *TargetTy = IntPtrTy; |
| |
| // Floating-point types which fit into intptr_t are bitcast to integers |
| // and then passed directly (after zero-extension, if necessary). |
| if (V->getType()->isFloatingPointTy()) { |
| unsigned Bits = V->getType()->getPrimitiveSizeInBits(); |
| if (Bits <= TargetTy->getIntegerBitWidth()) |
| V = Builder.CreateBitCast(V, llvm::Type::getIntNTy(getLLVMContext(), |
| Bits)); |
| } |
| |
| // Integers which fit in intptr_t are zero-extended and passed directly. |
| if (V->getType()->isIntegerTy() && |
| V->getType()->getIntegerBitWidth() <= TargetTy->getIntegerBitWidth()) |
| return Builder.CreateZExt(V, TargetTy); |
| |
| // Pointers are passed directly, everything else is passed by address. |
| if (!V->getType()->isPointerTy()) { |
| Address Ptr = CreateDefaultAlignTempAlloca(V->getType()); |
| Builder.CreateStore(V, Ptr); |
| V = Ptr.getPointer(); |
| } |
| return Builder.CreatePtrToInt(V, TargetTy); |
| } |
| |
| /// \brief Emit a representation of a SourceLocation for passing to a handler |
| /// in a sanitizer runtime library. The format for this data is: |
| /// \code |
| /// struct SourceLocation { |
| /// const char *Filename; |
| /// int32_t Line, Column; |
| /// }; |
| /// \endcode |
| /// For an invalid SourceLocation, the Filename pointer is null. |
| llvm::Constant *CodeGenFunction::EmitCheckSourceLocation(SourceLocation Loc) { |
| llvm::Constant *Filename; |
| int Line, Column; |
| |
| PresumedLoc PLoc = getContext().getSourceManager().getPresumedLoc(Loc); |
| if (PLoc.isValid()) { |
| StringRef FilenameString = PLoc.getFilename(); |
| |
| int PathComponentsToStrip = |
| CGM.getCodeGenOpts().EmitCheckPathComponentsToStrip; |
| if (PathComponentsToStrip < 0) { |
| assert(PathComponentsToStrip != INT_MIN); |
| int PathComponentsToKeep = -PathComponentsToStrip; |
| auto I = llvm::sys::path::rbegin(FilenameString); |
| auto E = llvm::sys::path::rend(FilenameString); |
| while (I != E && --PathComponentsToKeep) |
| ++I; |
| |
| FilenameString = FilenameString.substr(I - E); |
| } else if (PathComponentsToStrip > 0) { |
| auto I = llvm::sys::path::begin(FilenameString); |
| auto E = llvm::sys::path::end(FilenameString); |
| while (I != E && PathComponentsToStrip--) |
| ++I; |
| |
| if (I != E) |
| FilenameString = |
| FilenameString.substr(I - llvm::sys::path::begin(FilenameString)); |
| else |
| FilenameString = llvm::sys::path::filename(FilenameString); |
| } |
| |
| auto FilenameGV = CGM.GetAddrOfConstantCString(FilenameString, ".src"); |
| CGM.getSanitizerMetadata()->disableSanitizerForGlobal( |
| cast<llvm::GlobalVariable>(FilenameGV.getPointer())); |
| Filename = FilenameGV.getPointer(); |
| Line = PLoc.getLine(); |
| Column = PLoc.getColumn(); |
| } else { |
| Filename = llvm::Constant::getNullValue(Int8PtrTy); |
| Line = Column = 0; |
| } |
| |
| llvm::Constant *Data[] = {Filename, Builder.getInt32(Line), |
| Builder.getInt32(Column)}; |
| |
| return llvm::ConstantStruct::getAnon(Data); |
| } |
| |
| namespace { |
| /// \brief Specify under what conditions this check can be recovered |
| enum class CheckRecoverableKind { |
| /// Always terminate program execution if this check fails. |
| Unrecoverable, |
| /// Check supports recovering, runtime has both fatal (noreturn) and |
| /// non-fatal handlers for this check. |
| Recoverable, |
| /// Runtime conditionally aborts, always need to support recovery. |
| AlwaysRecoverable |
| }; |
| } |
| |
| static CheckRecoverableKind getRecoverableKind(SanitizerMask Kind) { |
| assert(llvm::countPopulation(Kind) == 1); |
| switch (Kind) { |
| case SanitizerKind::Vptr: |
| return CheckRecoverableKind::AlwaysRecoverable; |
| case SanitizerKind::Return: |
| case SanitizerKind::Unreachable: |
| return CheckRecoverableKind::Unrecoverable; |
| default: |
| return CheckRecoverableKind::Recoverable; |
| } |
| } |
| |
| namespace { |
| struct SanitizerHandlerInfo { |
| char const *const Name; |
| unsigned Version; |
| }; |
| } |
| |
| const SanitizerHandlerInfo SanitizerHandlers[] = { |
| #define SANITIZER_CHECK(Enum, Name, Version) {#Name, Version}, |
| LIST_SANITIZER_CHECKS |
| #undef SANITIZER_CHECK |
| }; |
| |
| static void emitCheckHandlerCall(CodeGenFunction &CGF, |
| llvm::FunctionType *FnType, |
| ArrayRef<llvm::Value *> FnArgs, |
| SanitizerHandler CheckHandler, |
| CheckRecoverableKind RecoverKind, bool IsFatal, |
| llvm::BasicBlock *ContBB) { |
| assert(IsFatal || RecoverKind != CheckRecoverableKind::Unrecoverable); |
| bool NeedsAbortSuffix = |
| IsFatal && RecoverKind != CheckRecoverableKind::Unrecoverable; |
| const SanitizerHandlerInfo &CheckInfo = SanitizerHandlers[CheckHandler]; |
| const StringRef CheckName = CheckInfo.Name; |
| std::string FnName = |
| ("__ubsan_handle_" + CheckName + |
| (CheckInfo.Version ? "_v" + llvm::utostr(CheckInfo.Version) : "") + |
| (NeedsAbortSuffix ? "_abort" : "")) |
| .str(); |
| bool MayReturn = |
| !IsFatal || RecoverKind == CheckRecoverableKind::AlwaysRecoverable; |
| |
| llvm::AttrBuilder B; |
| if (!MayReturn) { |
| B.addAttribute(llvm::Attribute::NoReturn) |
| .addAttribute(llvm::Attribute::NoUnwind); |
| } |
| B.addAttribute(llvm::Attribute::UWTable); |
| |
| llvm::Value *Fn = CGF.CGM.CreateRuntimeFunction( |
| FnType, FnName, |
| llvm::AttributeSet::get(CGF.getLLVMContext(), |
| llvm::AttributeSet::FunctionIndex, B), |
| /*Local=*/true); |
| llvm::CallInst *HandlerCall = CGF.EmitNounwindRuntimeCall(Fn, FnArgs); |
| if (!MayReturn) { |
| HandlerCall->setDoesNotReturn(); |
| CGF.Builder.CreateUnreachable(); |
| } else { |
| CGF.Builder.CreateBr(ContBB); |
| } |
| } |
| |
| void CodeGenFunction::EmitCheck( |
| ArrayRef<std::pair<llvm::Value *, SanitizerMask>> Checked, |
| SanitizerHandler CheckHandler, ArrayRef<llvm::Constant *> StaticArgs, |
| ArrayRef<llvm::Value *> DynamicArgs) { |
| assert(IsSanitizerScope); |
| assert(Checked.size() > 0); |
| assert(CheckHandler >= 0 && |
| CheckHandler < sizeof(SanitizerHandlers) / sizeof(*SanitizerHandlers)); |