OSchip
/
llvm-project
mirror of https://github.com/THU-DSP-LAB/llvm-project.git
13
0
Fork 6
Code Issues Packages Projects Releases Wiki Activity

[IRBuilder] Remove Align-related deprecated APIs 

This removes IRBuilder methods accepting unsigned alignments
in favor of their Align/MaybeAlign variants. These methods have
been deprecated for more than a year at this point, so they
should be safe to remove.
This commit is contained in:
Nikita Popov 2021-02-13 16:39:44 +01:00
parent 6abe362ed7
commit f515ca8995
1 changed files with 0 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

135
llvm/include/llvm/IR/IRBuilder.h
View File

@ -664,32 +664,6 @@ public:
MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr, MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
MDNode *NoAliasTag = nullptr); MDNode *NoAliasTag = nullptr);
LLVM_ATTRIBUTE_DEPRECATED(CallInst *CreateElementUnorderedAtomicMemCpy(
Value *Dst, unsigned DstAlign, Value *Src,
unsigned SrcAlign, uint64_t Size,
uint32_t ElementSize, MDNode *TBAATag = nullptr,
MDNode *TBAAStructTag = nullptr,
MDNode *ScopeTag = nullptr,
MDNode *NoAliasTag = nullptr),
"Use the version that takes Align instead") {
return CreateElementUnorderedAtomicMemCpy(
Dst, Align(DstAlign), Src, Align(SrcAlign), getInt64(Size), ElementSize,
TBAATag, TBAAStructTag, ScopeTag, NoAliasTag);
}
LLVM_ATTRIBUTE_DEPRECATED(CallInst *CreateElementUnorderedAtomicMemCpy(
Value *Dst, unsigned DstAlign, Value *Src,
unsigned SrcAlign, Value *Size,
uint32_t ElementSize, MDNode *TBAATag = nullptr,
MDNode *TBAAStructTag = nullptr,
MDNode *ScopeTag = nullptr,
MDNode *NoAliasTag = nullptr),
"Use the version that takes Align instead") {
return CreateElementUnorderedAtomicMemCpy(
Dst, Align(DstAlign), Src, Align(SrcAlign), Size, ElementSize, TBAATag,
TBAAStructTag, ScopeTag, NoAliasTag);
}
CallInst *CreateMemMove(Value *Dst, MaybeAlign DstAlign, Value *Src, CallInst *CreateMemMove(Value *Dst, MaybeAlign DstAlign, Value *Src,
MaybeAlign SrcAlign, uint64_t Size, MaybeAlign SrcAlign, uint64_t Size,
bool isVolatile = false, MDNode *TBAATag = nullptr, bool isVolatile = false, MDNode *TBAATag = nullptr,
@ -720,32 +694,6 @@ public:
MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr, MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
MDNode *NoAliasTag = nullptr); MDNode *NoAliasTag = nullptr);
LLVM_ATTRIBUTE_DEPRECATED(CallInst *CreateElementUnorderedAtomicMemMove(
Value *Dst, unsigned DstAlign, Value *Src,
unsigned SrcAlign, uint64_t Size,
uint32_t ElementSize, MDNode *TBAATag = nullptr,
MDNode *TBAAStructTag = nullptr,
MDNode *ScopeTag = nullptr,
MDNode *NoAliasTag = nullptr),
"Use the version that takes Align instead") {
return CreateElementUnorderedAtomicMemMove(
Dst, Align(DstAlign), Src, Align(SrcAlign), getInt64(Size), ElementSize,
TBAATag, TBAAStructTag, ScopeTag, NoAliasTag);
}
LLVM_ATTRIBUTE_DEPRECATED(CallInst *CreateElementUnorderedAtomicMemMove(
Value *Dst, unsigned DstAlign, Value *Src,
unsigned SrcAlign, Value *Size,
uint32_t ElementSize, MDNode *TBAATag = nullptr,
MDNode *TBAAStructTag = nullptr,
MDNode *ScopeTag = nullptr,
MDNode *NoAliasTag = nullptr),
"Use the version that takes Align instead") {
return CreateElementUnorderedAtomicMemMove(
Dst, Align(DstAlign), Src, Align(SrcAlign), Size, ElementSize, TBAATag,
TBAAStructTag, ScopeTag, NoAliasTag);
}
/// Create a vector fadd reduction intrinsic of the source vector. /// Create a vector fadd reduction intrinsic of the source vector.
/// The first parameter is a scalar accumulator value for ordered reductions. /// The first parameter is a scalar accumulator value for ordered reductions.
CallInst *CreateFAddReduce(Value *Acc, Value *Src); CallInst *CreateFAddReduce(Value *Acc, Value *Src);
@ -801,51 +749,18 @@ public:
CallInst *CreateInvariantStart(Value *Ptr, ConstantInt *Size = nullptr); CallInst *CreateInvariantStart(Value *Ptr, ConstantInt *Size = nullptr);
/// Create a call to Masked Load intrinsic /// Create a call to Masked Load intrinsic
LLVM_ATTRIBUTE_DEPRECATED(
CallInst *CreateMaskedLoad(Value *Ptr, unsigned Alignment, Value *Mask,
Value *PassThru = nullptr,
const Twine &Name = ""),
"Use the version that takes Align instead") {
return CreateMaskedLoad(Ptr, assumeAligned(Alignment), Mask, PassThru,
Name);
}
CallInst *CreateMaskedLoad(Value *Ptr, Align Alignment, Value *Mask, CallInst *CreateMaskedLoad(Value *Ptr, Align Alignment, Value *Mask,
Value *PassThru = nullptr, const Twine &Name = ""); Value *PassThru = nullptr, const Twine &Name = "");
/// Create a call to Masked Store intrinsic /// Create a call to Masked Store intrinsic
LLVM_ATTRIBUTE_DEPRECATED(CallInst *CreateMaskedStore(Value *Val, Value *Ptr,
unsigned Alignment,
Value *Mask),
"Use the version that takes Align instead") {
return CreateMaskedStore(Val, Ptr, assumeAligned(Alignment), Mask);
}
CallInst *CreateMaskedStore(Value *Val, Value *Ptr, Align Alignment, CallInst *CreateMaskedStore(Value *Val, Value *Ptr, Align Alignment,
Value *Mask); Value *Mask);
/// Create a call to Masked Gather intrinsic
LLVM_ATTRIBUTE_DEPRECATED(
CallInst *CreateMaskedGather(Value *Ptrs, unsigned Alignment,
Value *Mask = nullptr,
Value *PassThru = nullptr,
const Twine &Name = ""),
"Use the version that takes Align instead") {
return CreateMaskedGather(Ptrs, Align(Alignment), Mask, PassThru, Name);
}
/// Create a call to Masked Gather intrinsic /// Create a call to Masked Gather intrinsic
CallInst *CreateMaskedGather(Value *Ptrs, Align Alignment, CallInst *CreateMaskedGather(Value *Ptrs, Align Alignment,
Value *Mask = nullptr, Value *PassThru = nullptr, Value *Mask = nullptr, Value *PassThru = nullptr,
const Twine &Name = ""); const Twine &Name = "");
/// Create a call to Masked Scatter intrinsic
LLVM_ATTRIBUTE_DEPRECATED(
CallInst *CreateMaskedScatter(Value *Val, Value *Ptrs, unsigned Alignment,
Value *Mask = nullptr),
"Use the version that takes Align instead") {
return CreateMaskedScatter(Val, Ptrs, Align(Alignment), Mask);
}
/// Create a call to Masked Scatter intrinsic /// Create a call to Masked Scatter intrinsic
CallInst *CreateMaskedScatter(Value *Val, Value *Ptrs, Align Alignment, CallInst *CreateMaskedScatter(Value *Val, Value *Ptrs, Align Alignment,
Value *Mask = nullptr); Value *Mask = nullptr);
@ -1738,35 +1653,16 @@ public:
return CreateAlignedStore(Val, Ptr, MaybeAlign(), isVolatile); return CreateAlignedStore(Val, Ptr, MaybeAlign(), isVolatile);
} }
LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr,
unsigned Align,
const char *Name),
"Use the version that takes NaybeAlign instead") {
return CreateAlignedLoad(Ty, Ptr, MaybeAlign(Align), Name);
}
LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align, LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align,
const char *Name) { const char *Name) {
return CreateAlignedLoad(Ty, Ptr, Align, /*isVolatile*/false, Name); return CreateAlignedLoad(Ty, Ptr, Align, /*isVolatile*/false, Name);
} }
LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr,
unsigned Align,
const Twine &Name = ""),
"Use the version that takes MaybeAlign instead") {
return CreateAlignedLoad(Ty, Ptr, MaybeAlign(Align), Name);
}
LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align, LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align,
const Twine &Name = "") { const Twine &Name = "") {
return CreateAlignedLoad(Ty, Ptr, Align, /*isVolatile*/false, Name); return CreateAlignedLoad(Ty, Ptr, Align, /*isVolatile*/false, Name);
} }
LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr,
unsigned Align,
bool isVolatile,
const Twine &Name = ""),
"Use the version that takes MaybeAlign instead") {
return CreateAlignedLoad(Ty, Ptr, MaybeAlign(Align), isVolatile, Name);
}
LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align, LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align,
bool isVolatile, const Twine &Name = "") { bool isVolatile, const Twine &Name = "") {
if (!Align) { if (!Align) {
@ -1776,31 +1672,6 @@ public:
return Insert(new LoadInst(Ty, Ptr, Twine(), isVolatile, *Align), Name); return Insert(new LoadInst(Ty, Ptr, Twine(), isVolatile, *Align), Name);
} }
// Deprecated [opaque pointer types]
LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateAlignedLoad(Value *Ptr,
unsigned Align,
const char *Name),
"Use the version that takes MaybeAlign instead") {
return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
MaybeAlign(Align), Name);
}
// Deprecated [opaque pointer types]
LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateAlignedLoad(Value *Ptr,
unsigned Align,
const Twine &Name = ""),
"Use the version that takes MaybeAlign instead") {
return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
MaybeAlign(Align), Name);
}
// Deprecated [opaque pointer types]
LLVM_ATTRIBUTE_DEPRECATED(LoadInst *CreateAlignedLoad(Value *Ptr,
unsigned Align,
bool isVolatile,
const Twine &Name = ""),
"Use the version that takes MaybeAlign instead") {
return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
MaybeAlign(Align), isVolatile, Name);
}
// Deprecated [opaque pointer types] // Deprecated [opaque pointer types]
LoadInst *CreateAlignedLoad(Value *Ptr, MaybeAlign Align, const char *Name) { LoadInst *CreateAlignedLoad(Value *Ptr, MaybeAlign Align, const char *Name) {
return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr, return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
@ -1819,12 +1690,6 @@ public:
Align, isVolatile, Name); Align, isVolatile, Name);
} }
LLVM_ATTRIBUTE_DEPRECATED(
StoreInst *CreateAlignedStore(Value *Val, Value *Ptr, unsigned Align,
bool isVolatile = false),
"Use the version that takes MaybeAlign instead") {
return CreateAlignedStore(Val, Ptr, MaybeAlign(Align), isVolatile);
}
StoreInst *CreateAlignedStore(Value *Val, Value *Ptr, MaybeAlign Align, StoreInst *CreateAlignedStore(Value *Val, Value *Ptr, MaybeAlign Align,
bool isVolatile = false) { bool isVolatile = false) {
if (!Align) { if (!Align) {