[llvm] f0d7fea - [IRBuilder] Use AAMDNodes helper class in CreateMem* routines [nfc-ish] (#139950)
via llvm-commits
llvm-commits at lists.llvm.org
Thu May 15 10:18:58 PDT 2025
Author: Philip Reames
Date: 2025-05-15T10:18:54-07:00
New Revision: f0d7fea98b4afc29dfca11bfc58c7411c794ccae
URL: https://github.com/llvm/llvm-project/commit/f0d7fea98b4afc29dfca11bfc58c7411c794ccae
DIFF: https://github.com/llvm/llvm-project/commit/f0d7fea98b4afc29dfca11bfc58c7411c794ccae.diff
LOG: [IRBuilder] Use AAMDNodes helper class in CreateMem* routines [nfc-ish] (#139950)
I'm not 100% sure this is NFC because we have the possibility we're
propagating additional metadata we'd missed before. We don't see any
test changes resulting from this though.
Added:
Modified:
llvm/include/llvm/IR/IRBuilder.h
llvm/lib/IR/IRBuilder.cpp
llvm/lib/Transforms/Scalar/InferAddressSpaces.cpp
llvm/lib/Transforms/Scalar/LoopIdiomRecognize.cpp
Removed:
################################################################################
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<OperandBundleDef> 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<MemSetInst>(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<MemSetInst>(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<AnyMemSetInst>(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<AnyMemCpyInst>(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<MemSetInst>(MI)) {
B.CreateMemSet(NewV, MSI->getValue(), MSI->getLength(), MSI->getDestAlign(),
false, // isVolatile
- TBAA, ScopeMD, NoAliasMD);
+ MI->getAAMetadata());
} else if (auto *MTI = dyn_cast<MemTransferInst>(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<MemCpyInst>(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<MemMoveInst>(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());
More information about the llvm-commits
mailing list