diff --git a/llvm/include/llvm/IR/IRBuilder.h b/llvm/include/llvm/IR/IRBuilder.h index f650c06590ef2..7e0521e72ceb2 100644 --- a/llvm/include/llvm/IR/IRBuilder.h +++ b/llvm/include/llvm/IR/IRBuilder.h @@ -608,43 +608,33 @@ class IRBuilderBase { /// Create and insert a memset to the specified pointer and the /// specified value. /// - /// If the pointer isn't an i8*, it will be converted. If a TBAA tag is - /// specified, it will be added to the instruction. Likewise with alias.scope - /// and noalias tags. + /// If the pointer isn't an i8*, it will be converted. If alias metadata is + /// specified, it will be added to the instruction. CallInst *CreateMemSet(Value *Ptr, Value *Val, uint64_t Size, MaybeAlign Align, bool isVolatile = false, - MDNode *TBAATag = nullptr, MDNode *ScopeTag = nullptr, - MDNode *NoAliasTag = nullptr) { - return CreateMemSet(Ptr, Val, getInt64(Size), Align, isVolatile, - TBAATag, ScopeTag, NoAliasTag); + const AAMDNodes &AAInfo = AAMDNodes()) { + return CreateMemSet(Ptr, Val, getInt64(Size), Align, isVolatile, AAInfo); } CallInst *CreateMemSet(Value *Ptr, Value *Val, Value *Size, MaybeAlign Align, - bool isVolatile = false, MDNode *TBAATag = nullptr, - MDNode *ScopeTag = nullptr, - MDNode *NoAliasTag = nullptr); + bool isVolatile = false, + const AAMDNodes &AAInfo = AAMDNodes()); CallInst *CreateMemSetInline(Value *Dst, MaybeAlign DstAlign, Value *Val, Value *Size, bool IsVolatile = false, - MDNode *TBAATag = nullptr, - MDNode *ScopeTag = nullptr, - MDNode *NoAliasTag = nullptr); + const AAMDNodes &AAInfo = AAMDNodes()); /// Create and insert an element unordered-atomic memset of the region of /// memory starting at the given pointer to the given value. /// - /// If the pointer isn't an i8*, it will be converted. If a TBAA tag is - /// specified, it will be added to the instruction. Likewise with alias.scope - /// and noalias tags. - CallInst *CreateElementUnorderedAtomicMemSet(Value *Ptr, Value *Val, - uint64_t Size, Align Alignment, - uint32_t ElementSize, - MDNode *TBAATag = nullptr, - MDNode *ScopeTag = nullptr, - MDNode *NoAliasTag = nullptr) { - return CreateElementUnorderedAtomicMemSet(Ptr, Val, getInt64(Size), - Align(Alignment), ElementSize, - TBAATag, ScopeTag, NoAliasTag); + /// If the pointer isn't an i8*, it will be converted. If alias metadata is + /// specified, it will be added to the instruction. + CallInst * + CreateElementUnorderedAtomicMemSet(Value *Ptr, Value *Val, uint64_t Size, + Align Alignment, uint32_t ElementSize, + const AAMDNodes &AAInfo = AAMDNodes()) { + return CreateElementUnorderedAtomicMemSet( + Ptr, Val, getInt64(Size), Align(Alignment), ElementSize, AAInfo); } CallInst *CreateMalloc(Type *IntPtrTy, Type *AllocTy, Value *AllocSize, @@ -662,88 +652,72 @@ class IRBuilderBase { /// Generate the IR for a call to the builtin free function. CallInst *CreateFree(Value *Source, ArrayRef Bundles = {}); - CallInst *CreateElementUnorderedAtomicMemSet(Value *Ptr, Value *Val, - Value *Size, Align Alignment, - uint32_t ElementSize, - MDNode *TBAATag = nullptr, - MDNode *ScopeTag = nullptr, - MDNode *NoAliasTag = nullptr); + CallInst * + CreateElementUnorderedAtomicMemSet(Value *Ptr, Value *Val, Value *Size, + Align Alignment, uint32_t ElementSize, + const AAMDNodes &AAInfo = AAMDNodes()); /// Create and insert a memcpy between the specified pointers. /// - /// If the pointers aren't i8*, they will be converted. If a TBAA tag is - /// specified, it will be added to the instruction. Likewise with alias.scope + /// If the pointers aren't i8*, they will be converted. If alias metadata is + /// specified, it will be added to the instruction. /// and noalias tags. CallInst *CreateMemCpy(Value *Dst, MaybeAlign DstAlign, Value *Src, MaybeAlign SrcAlign, uint64_t Size, - bool isVolatile = false, MDNode *TBAATag = nullptr, - MDNode *TBAAStructTag = nullptr, - MDNode *ScopeTag = nullptr, - MDNode *NoAliasTag = nullptr) { + bool isVolatile = false, + const AAMDNodes &AAInfo = AAMDNodes()) { return CreateMemCpy(Dst, DstAlign, Src, SrcAlign, getInt64(Size), - isVolatile, TBAATag, TBAAStructTag, ScopeTag, - NoAliasTag); + isVolatile, AAInfo); } - CallInst *CreateMemTransferInst( - Intrinsic::ID IntrID, Value *Dst, MaybeAlign DstAlign, Value *Src, - MaybeAlign SrcAlign, Value *Size, bool isVolatile = false, - MDNode *TBAATag = nullptr, MDNode *TBAAStructTag = nullptr, - MDNode *ScopeTag = nullptr, MDNode *NoAliasTag = nullptr); + CallInst *CreateMemTransferInst(Intrinsic::ID IntrID, Value *Dst, + MaybeAlign DstAlign, Value *Src, + MaybeAlign SrcAlign, Value *Size, + bool isVolatile = false, + const AAMDNodes &AAInfo = AAMDNodes()); CallInst *CreateMemCpy(Value *Dst, MaybeAlign DstAlign, Value *Src, MaybeAlign SrcAlign, Value *Size, - bool isVolatile = false, MDNode *TBAATag = nullptr, - MDNode *TBAAStructTag = nullptr, - MDNode *ScopeTag = nullptr, - MDNode *NoAliasTag = nullptr) { + bool isVolatile = false, + const AAMDNodes &AAInfo = AAMDNodes()) { return CreateMemTransferInst(Intrinsic::memcpy, Dst, DstAlign, Src, - SrcAlign, Size, isVolatile, TBAATag, - TBAAStructTag, ScopeTag, NoAliasTag); + SrcAlign, Size, isVolatile, AAInfo); } - CallInst * - CreateMemCpyInline(Value *Dst, MaybeAlign DstAlign, Value *Src, - MaybeAlign SrcAlign, Value *Size, bool isVolatile = false, - MDNode *TBAATag = nullptr, MDNode *TBAAStructTag = nullptr, - MDNode *ScopeTag = nullptr, MDNode *NoAliasTag = nullptr) { + CallInst *CreateMemCpyInline(Value *Dst, MaybeAlign DstAlign, Value *Src, + MaybeAlign SrcAlign, Value *Size, + bool isVolatile = false, + const AAMDNodes &AAInfo = AAMDNodes()) { return CreateMemTransferInst(Intrinsic::memcpy_inline, Dst, DstAlign, Src, - SrcAlign, Size, isVolatile, TBAATag, - TBAAStructTag, ScopeTag, NoAliasTag); + SrcAlign, Size, isVolatile, AAInfo); } /// Create and insert an element unordered-atomic memcpy between the /// specified pointers. /// - /// DstAlign/SrcAlign are the alignments of the Dst/Src pointers, respectively. + /// DstAlign/SrcAlign are the alignments of the Dst/Src pointers, + /// respectively. /// - /// If the pointers aren't i8*, they will be converted. If a TBAA tag is - /// specified, it will be added to the instruction. Likewise with alias.scope - /// and noalias tags. + /// If the pointers aren't i8*, they will be converted. If alias metadata is + /// specified, it will be added to the instruction. CallInst *CreateElementUnorderedAtomicMemCpy( Value *Dst, Align DstAlign, Value *Src, Align SrcAlign, Value *Size, - uint32_t ElementSize, MDNode *TBAATag = nullptr, - MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr, - MDNode *NoAliasTag = nullptr); + uint32_t ElementSize, const AAMDNodes &AAInfo = AAMDNodes()); CallInst *CreateMemMove(Value *Dst, MaybeAlign DstAlign, Value *Src, MaybeAlign SrcAlign, uint64_t Size, - bool isVolatile = false, MDNode *TBAATag = nullptr, - MDNode *ScopeTag = nullptr, - MDNode *NoAliasTag = nullptr) { + bool isVolatile = false, + const AAMDNodes &AAInfo = AAMDNodes()) { return CreateMemMove(Dst, DstAlign, Src, SrcAlign, getInt64(Size), - isVolatile, TBAATag, ScopeTag, NoAliasTag); + isVolatile, AAInfo); } CallInst *CreateMemMove(Value *Dst, MaybeAlign DstAlign, Value *Src, MaybeAlign SrcAlign, Value *Size, - bool isVolatile = false, MDNode *TBAATag = nullptr, - MDNode *ScopeTag = nullptr, - MDNode *NoAliasTag = nullptr) { + bool isVolatile = false, + const AAMDNodes &AAInfo = AAMDNodes()) { return CreateMemTransferInst(Intrinsic::memmove, Dst, DstAlign, Src, - SrcAlign, Size, isVolatile, TBAATag, - /*TBAAStructTag=*/nullptr, ScopeTag, - NoAliasTag); + SrcAlign, Size, isVolatile, AAInfo); } /// \brief Create and insert an element unordered-atomic memmove between the @@ -752,14 +726,11 @@ class IRBuilderBase { /// DstAlign/SrcAlign are the alignments of the Dst/Src pointers, /// respectively. /// - /// If the pointers aren't i8*, they will be converted. If a TBAA tag is - /// specified, it will be added to the instruction. Likewise with alias.scope - /// and noalias tags. + /// If the pointers aren't i8*, they will be converted. If alias metadata is + /// specified, it will be added to the instruction. CallInst *CreateElementUnorderedAtomicMemMove( Value *Dst, Align DstAlign, Value *Src, Align SrcAlign, Value *Size, - uint32_t ElementSize, MDNode *TBAATag = nullptr, - MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr, - MDNode *NoAliasTag = nullptr); + uint32_t ElementSize, const AAMDNodes &AAInfo = AAMDNodes()); private: CallInst *getReductionIntrinsic(Intrinsic::ID ID, Value *Src); diff --git a/llvm/lib/IR/IRBuilder.cpp b/llvm/lib/IR/IRBuilder.cpp index 8adb85ec6091a..580b0af709337 100644 --- a/llvm/lib/IR/IRBuilder.cpp +++ b/llvm/lib/IR/IRBuilder.cpp @@ -169,8 +169,7 @@ Value *IRBuilderBase::CreateStepVector(Type *DstType, const Twine &Name) { CallInst *IRBuilderBase::CreateMemSet(Value *Ptr, Value *Val, Value *Size, MaybeAlign Align, bool isVolatile, - MDNode *TBAATag, MDNode *ScopeTag, - MDNode *NoAliasTag) { + const AAMDNodes &AAInfo) { Value *Ops[] = {Ptr, Val, Size, getInt1(isVolatile)}; Type *Tys[] = {Ptr->getType(), Size->getType()}; @@ -178,25 +177,14 @@ CallInst *IRBuilderBase::CreateMemSet(Value *Ptr, Value *Val, Value *Size, if (Align) cast(CI)->setDestAlignment(*Align); - - // Set the TBAA info if present. - if (TBAATag) - CI->setMetadata(LLVMContext::MD_tbaa, TBAATag); - - if (ScopeTag) - CI->setMetadata(LLVMContext::MD_alias_scope, ScopeTag); - - if (NoAliasTag) - CI->setMetadata(LLVMContext::MD_noalias, NoAliasTag); - + CI->setAAMetadata(AAInfo); return CI; } CallInst *IRBuilderBase::CreateMemSetInline(Value *Dst, MaybeAlign DstAlign, Value *Val, Value *Size, - bool IsVolatile, MDNode *TBAATag, - MDNode *ScopeTag, - MDNode *NoAliasTag) { + bool IsVolatile, + const AAMDNodes &AAInfo) { Value *Ops[] = {Dst, Val, Size, getInt1(IsVolatile)}; Type *Tys[] = {Dst->getType(), Size->getType()}; @@ -204,23 +192,13 @@ CallInst *IRBuilderBase::CreateMemSetInline(Value *Dst, MaybeAlign DstAlign, if (DstAlign) cast(CI)->setDestAlignment(*DstAlign); - - // Set the TBAA info if present. - if (TBAATag) - CI->setMetadata(LLVMContext::MD_tbaa, TBAATag); - - if (ScopeTag) - CI->setMetadata(LLVMContext::MD_alias_scope, ScopeTag); - - if (NoAliasTag) - CI->setMetadata(LLVMContext::MD_noalias, NoAliasTag); - + CI->setAAMetadata(AAInfo); return CI; } CallInst *IRBuilderBase::CreateElementUnorderedAtomicMemSet( Value *Ptr, Value *Val, Value *Size, Align Alignment, uint32_t ElementSize, - MDNode *TBAATag, MDNode *ScopeTag, MDNode *NoAliasTag) { + const AAMDNodes &AAInfo) { Value *Ops[] = {Ptr, Val, Size, getInt32(ElementSize)}; Type *Tys[] = {Ptr->getType(), Size->getType()}; @@ -229,24 +207,15 @@ CallInst *IRBuilderBase::CreateElementUnorderedAtomicMemSet( CreateIntrinsic(Intrinsic::memset_element_unordered_atomic, Tys, Ops); cast(CI)->setDestAlignment(Alignment); - - // Set the TBAA info if present. - if (TBAATag) - CI->setMetadata(LLVMContext::MD_tbaa, TBAATag); - - if (ScopeTag) - CI->setMetadata(LLVMContext::MD_alias_scope, ScopeTag); - - if (NoAliasTag) - CI->setMetadata(LLVMContext::MD_noalias, NoAliasTag); - + CI->setAAMetadata(AAInfo); return CI; } -CallInst *IRBuilderBase::CreateMemTransferInst( - Intrinsic::ID IntrID, Value *Dst, MaybeAlign DstAlign, Value *Src, - MaybeAlign SrcAlign, Value *Size, bool isVolatile, MDNode *TBAATag, - MDNode *TBAAStructTag, MDNode *ScopeTag, MDNode *NoAliasTag) { +CallInst *IRBuilderBase::CreateMemTransferInst(Intrinsic::ID IntrID, Value *Dst, + MaybeAlign DstAlign, Value *Src, + MaybeAlign SrcAlign, Value *Size, + bool isVolatile, + const AAMDNodes &AAInfo) { assert((IntrID == Intrinsic::memcpy || IntrID == Intrinsic::memcpy_inline || IntrID == Intrinsic::memmove) && "Unexpected intrinsic ID"); @@ -260,28 +229,13 @@ CallInst *IRBuilderBase::CreateMemTransferInst( MCI->setDestAlignment(*DstAlign); if (SrcAlign) MCI->setSourceAlignment(*SrcAlign); - - // Set the TBAA info if present. - if (TBAATag) - CI->setMetadata(LLVMContext::MD_tbaa, TBAATag); - - // Set the TBAA Struct info if present. - if (TBAAStructTag) - CI->setMetadata(LLVMContext::MD_tbaa_struct, TBAAStructTag); - - if (ScopeTag) - CI->setMetadata(LLVMContext::MD_alias_scope, ScopeTag); - - if (NoAliasTag) - CI->setMetadata(LLVMContext::MD_noalias, NoAliasTag); - + MCI->setAAMetadata(AAInfo); return CI; } CallInst *IRBuilderBase::CreateElementUnorderedAtomicMemCpy( Value *Dst, Align DstAlign, Value *Src, Align SrcAlign, Value *Size, - uint32_t ElementSize, MDNode *TBAATag, MDNode *TBAAStructTag, - MDNode *ScopeTag, MDNode *NoAliasTag) { + uint32_t ElementSize, const AAMDNodes &AAInfo) { assert(DstAlign >= ElementSize && "Pointer alignment must be at least element size"); assert(SrcAlign >= ElementSize && @@ -296,21 +250,7 @@ CallInst *IRBuilderBase::CreateElementUnorderedAtomicMemCpy( auto *AMCI = cast(CI); AMCI->setDestAlignment(DstAlign); AMCI->setSourceAlignment(SrcAlign); - - // Set the TBAA info if present. - if (TBAATag) - CI->setMetadata(LLVMContext::MD_tbaa, TBAATag); - - // Set the TBAA Struct info if present. - if (TBAAStructTag) - CI->setMetadata(LLVMContext::MD_tbaa_struct, TBAAStructTag); - - if (ScopeTag) - CI->setMetadata(LLVMContext::MD_alias_scope, ScopeTag); - - if (NoAliasTag) - CI->setMetadata(LLVMContext::MD_noalias, NoAliasTag); - + AMCI->setAAMetadata(AAInfo); return CI; } @@ -394,8 +334,7 @@ CallInst *IRBuilderBase::CreateFree(Value *Source, CallInst *IRBuilderBase::CreateElementUnorderedAtomicMemMove( Value *Dst, Align DstAlign, Value *Src, Align SrcAlign, Value *Size, - uint32_t ElementSize, MDNode *TBAATag, MDNode *TBAAStructTag, - MDNode *ScopeTag, MDNode *NoAliasTag) { + uint32_t ElementSize, const AAMDNodes &AAInfo) { assert(DstAlign >= ElementSize && "Pointer alignment must be at least element size"); assert(SrcAlign >= ElementSize && @@ -409,21 +348,7 @@ CallInst *IRBuilderBase::CreateElementUnorderedAtomicMemMove( // Set the alignment of the pointer args. CI->addParamAttr(0, Attribute::getWithAlignment(CI->getContext(), DstAlign)); CI->addParamAttr(1, Attribute::getWithAlignment(CI->getContext(), SrcAlign)); - - // Set the TBAA info if present. - if (TBAATag) - CI->setMetadata(LLVMContext::MD_tbaa, TBAATag); - - // Set the TBAA Struct info if present. - if (TBAAStructTag) - CI->setMetadata(LLVMContext::MD_tbaa_struct, TBAAStructTag); - - if (ScopeTag) - CI->setMetadata(LLVMContext::MD_alias_scope, ScopeTag); - - if (NoAliasTag) - CI->setMetadata(LLVMContext::MD_noalias, NoAliasTag); - + CI->setAAMetadata(AAInfo); return CI; } diff --git a/llvm/lib/Transforms/Scalar/InferAddressSpaces.cpp b/llvm/lib/Transforms/Scalar/InferAddressSpaces.cpp index 0087d037f8cf2..d3771c0903456 100644 --- a/llvm/lib/Transforms/Scalar/InferAddressSpaces.cpp +++ b/llvm/lib/Transforms/Scalar/InferAddressSpaces.cpp @@ -1123,14 +1123,10 @@ static bool replaceIfSimplePointerUse(const TargetTransformInfo &TTI, static bool handleMemIntrinsicPtrUse(MemIntrinsic *MI, Value *OldV, Value *NewV) { IRBuilder<> B(MI); - MDNode *TBAA = MI->getMetadata(LLVMContext::MD_tbaa); - MDNode *ScopeMD = MI->getMetadata(LLVMContext::MD_alias_scope); - MDNode *NoAliasMD = MI->getMetadata(LLVMContext::MD_noalias); - if (auto *MSI = dyn_cast(MI)) { B.CreateMemSet(NewV, MSI->getValue(), MSI->getLength(), MSI->getDestAlign(), false, // isVolatile - TBAA, ScopeMD, NoAliasMD); + MI->getAAMetadata()); } else if (auto *MTI = dyn_cast(MI)) { Value *Src = MTI->getRawSource(); Value *Dest = MTI->getRawDest(); @@ -1143,23 +1139,22 @@ static bool handleMemIntrinsicPtrUse(MemIntrinsic *MI, Value *OldV, Dest = NewV; if (auto *MCI = dyn_cast(MTI)) { - MDNode *TBAAStruct = MTI->getMetadata(LLVMContext::MD_tbaa_struct); if (MCI->isForceInlined()) B.CreateMemCpyInline(Dest, MTI->getDestAlign(), Src, MTI->getSourceAlign(), MTI->getLength(), false, // isVolatile - TBAA, TBAAStruct, ScopeMD, NoAliasMD); + MI->getAAMetadata()); else B.CreateMemCpy(Dest, MTI->getDestAlign(), Src, MTI->getSourceAlign(), MTI->getLength(), false, // isVolatile - TBAA, TBAAStruct, ScopeMD, NoAliasMD); + MI->getAAMetadata()); } else { assert(isa(MTI)); B.CreateMemMove(Dest, MTI->getDestAlign(), Src, MTI->getSourceAlign(), MTI->getLength(), false, // isVolatile - TBAA, ScopeMD, NoAliasMD); + MI->getAAMetadata()); } } else llvm_unreachable("unhandled MemIntrinsic"); diff --git a/llvm/lib/Transforms/Scalar/LoopIdiomRecognize.cpp b/llvm/lib/Transforms/Scalar/LoopIdiomRecognize.cpp index 817f42b31ecd6..f33c84c307ab8 100644 --- a/llvm/lib/Transforms/Scalar/LoopIdiomRecognize.cpp +++ b/llvm/lib/Transforms/Scalar/LoopIdiomRecognize.cpp @@ -1097,9 +1097,9 @@ bool LoopIdiomRecognize::processLoopStridedStore( CallInst *NewCall; if (Value *SplatValue = isBytewiseValue(StoredVal, *DL)) { - NewCall = Builder.CreateMemSet( - BasePtr, SplatValue, NumBytes, MaybeAlign(StoreAlignment), - /*isVolatile=*/false, AATags.TBAA, AATags.Scope, AATags.NoAlias); + NewCall = Builder.CreateMemSet(BasePtr, SplatValue, NumBytes, + MaybeAlign(StoreAlignment), + /*isVolatile=*/false, AATags); } else if (isLibFuncEmittable(M, TLI, LibFunc_memset_pattern16)) { // Everything is emitted in default address space Type *Int8PtrTy = DestInt8PtrTy; @@ -1119,16 +1119,7 @@ bool LoopIdiomRecognize::processLoopStridedStore( GV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global); // Ok to merge these. GV->setAlignment(Align(16)); NewCall = Builder.CreateCall(MSP, {BasePtr, GV, NumBytes}); - - // Set the TBAA info if present. - if (AATags.TBAA) - NewCall->setMetadata(LLVMContext::MD_tbaa, AATags.TBAA); - - if (AATags.Scope) - NewCall->setMetadata(LLVMContext::MD_alias_scope, AATags.Scope); - - if (AATags.NoAlias) - NewCall->setMetadata(LLVMContext::MD_noalias, AATags.NoAlias); + NewCall->setAAMetadata(AATags); } else { // Neither a memset, nor memset_pattern16 return Changed; @@ -1422,21 +1413,20 @@ bool LoopIdiomRecognize::processLoopStoreOfLoopLoad( // by previous checks. if (!IsAtomic) { if (UseMemMove) - NewCall = Builder.CreateMemMove( - StoreBasePtr, StoreAlign, LoadBasePtr, LoadAlign, NumBytes, - /*isVolatile=*/false, AATags.TBAA, AATags.Scope, AATags.NoAlias); + NewCall = Builder.CreateMemMove(StoreBasePtr, StoreAlign, LoadBasePtr, + LoadAlign, NumBytes, + /*isVolatile=*/false, AATags); else NewCall = Builder.CreateMemCpy(StoreBasePtr, StoreAlign, LoadBasePtr, LoadAlign, - NumBytes, /*isVolatile=*/false, AATags.TBAA, - AATags.TBAAStruct, AATags.Scope, AATags.NoAlias); + NumBytes, /*isVolatile=*/false, AATags); } else { // Create the call. // Note that unordered atomic loads/stores are *required* by the spec to // have an alignment but non-atomic loads/stores may not. NewCall = Builder.CreateElementUnorderedAtomicMemCpy( StoreBasePtr, *StoreAlign, LoadBasePtr, *LoadAlign, NumBytes, StoreSize, - AATags.TBAA, AATags.TBAAStruct, AATags.Scope, AATags.NoAlias); + AATags); } NewCall->setDebugLoc(TheStore->getDebugLoc());