Skip to content

Commit 0957233

Browse files
gchateletgchatelet
committed
[Alignment][NFC] Use Align with CreateMaskedStore
Summary: This is patch is part of a series to introduce an Alignment type. See this thread for context: http://lists.llvm.org/pipermail/llvm-dev/2019-July/133851.html See this patch for the introduction of the type: https://reviews.llvm.org/D64790 Reviewers: courbet Subscribers: hiraditya, cfe-commits, llvm-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D73106
1 parent 889a4f5 commit 0957233

File tree

9 files changed

+63
-50
lines changed

9 files changed

+63
-50
lines changed

‎clang/lib/CodeGen/CGBuiltin.cpp

Lines changed: 12 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -9714,17 +9714,16 @@ static Value *getMaskVecValue(CodeGenFunction &CGF, Value *Mask,
97149714
return MaskVec;
97159715
}
97169716

9717-
static Value *EmitX86MaskedStore(CodeGenFunction &CGF,
9718-
ArrayRef<Value *> Ops,
9719-
unsigned Align) {
9717+
static Value *EmitX86MaskedStore(CodeGenFunction &CGF, ArrayRef<Value *> Ops,
9718+
Align Alignment) {
97209719
// Cast the pointer to right type.
97219720
Value *Ptr = CGF.Builder.CreateBitCast(Ops[0],
97229721
llvm::PointerType::getUnqual(Ops[1]->getType()));
97239722

97249723
Value *MaskVec = getMaskVecValue(CGF, Ops[2],
97259724
Ops[1]->getType()->getVectorNumElements());
97269725

9727-
return CGF.Builder.CreateMaskedStore(Ops[1], Ptr, Align, MaskVec);
9726+
return CGF.Builder.CreateMaskedStore(Ops[1], Ptr, Alignment, MaskVec);
97289727
}
97299728

97309729
static Value *EmitX86MaskedLoad(CodeGenFunction &CGF, ArrayRef<Value *> Ops,
@@ -10592,12 +10591,12 @@ Value *CodeGenFunction::EmitX86BuiltinExpr(unsigned BuiltinID,
1059210591
case X86::BI__builtin_ia32_storedquqi512_mask:
1059310592
case X86::BI__builtin_ia32_storeupd512_mask:
1059410593
case X86::BI__builtin_ia32_storeups512_mask:
10595-
return EmitX86MaskedStore(*this, Ops, 1);
10594+
return EmitX86MaskedStore(*this, Ops, Align::None());
1059610595

1059710596
case X86::BI__builtin_ia32_storess128_mask:
10598-
case X86::BI__builtin_ia32_storesd128_mask: {
10599-
return EmitX86MaskedStore(*this, Ops, 1);
10600-
}
10597+
case X86::BI__builtin_ia32_storesd128_mask:
10598+
return EmitX86MaskedStore(*this, Ops, Align::None());
10599+
1060110600
case X86::BI__builtin_ia32_vpopcntb_128:
1060210601
case X86::BI__builtin_ia32_vpopcntd_128:
1060310602
case X86::BI__builtin_ia32_vpopcntq_128:
@@ -10708,11 +10707,11 @@ Value *CodeGenFunction::EmitX86BuiltinExpr(unsigned BuiltinID,
1070810707
case X86::BI__builtin_ia32_movdqa32store512_mask:
1070910708
case X86::BI__builtin_ia32_movdqa64store512_mask:
1071010709
case X86::BI__builtin_ia32_storeaps512_mask:
10711-
case X86::BI__builtin_ia32_storeapd512_mask: {
10712-
unsigned Align =
10713-
getContext().getTypeAlignInChars(E->getArg(1)->getType()).getQuantity();
10714-
return EmitX86MaskedStore(*this, Ops, Align);
10715-
}
10710+
case X86::BI__builtin_ia32_storeapd512_mask:
10711+
return EmitX86MaskedStore(
10712+
*this, Ops,
10713+
getContext().getTypeAlignInChars(E->getArg(1)->getType()).getAsAlign());
10714+
1071610715
case X86::BI__builtin_ia32_loadups128_mask:
1071710716
case X86::BI__builtin_ia32_loadups256_mask:
1071810717
case X86::BI__builtin_ia32_loadups512_mask:

‎llvm/include/llvm/IR/Constants.h

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -157,6 +157,10 @@ class ConstantInt final : public ConstantData {
157157
return Val.getSExtValue();
158158
}
159159

160+
/// Return the constant as an llvm::Align. Note that this method can assert if
161+
/// the value does not fit in 64 bits or is not a power of two.
162+
inline Align getAlignValue() const { return Align(getZExtValue()); }
163+
160164
/// A helper method that can be used to determine if the constant contained
161165
/// within is equal to a constant. This only works for very small values,
162166
/// because this is all that can be represented with all types.

‎llvm/include/llvm/IR/IRBuilder.h

Lines changed: 10 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -752,13 +752,21 @@ class IRBuilderBase {
752752
Value *PassThru = nullptr,
753753
const Twine &Name = ""),
754754
"Use the version that takes Align instead") {
755-
return CreateMaskedLoad(Ptr, Align(Alignment), Mask, PassThru, Name);
755+
return CreateMaskedLoad(Ptr, assumeAligned(Alignment), Mask, PassThru,
756+
Name);
756757
}
757758
CallInst *CreateMaskedLoad(Value *Ptr, Align Alignment, Value *Mask,
758759
Value *PassThru = nullptr, const Twine &Name = "");
759760

760761
/// Create a call to Masked Store intrinsic
761-
CallInst *CreateMaskedStore(Value *Val, Value *Ptr, unsigned Align,
762+
LLVM_ATTRIBUTE_DEPRECATED(CallInst *CreateMaskedStore(Value *Val, Value *Ptr,
763+
unsigned Alignment,
764+
Value *Mask),
765+
"Use the version that takes Align instead") {
766+
return CreateMaskedStore(Val, Ptr, assumeAligned(Alignment), Mask);
767+
}
768+
769+
CallInst *CreateMaskedStore(Value *Val, Value *Ptr, Align Alignment,
762770
Value *Mask);
763771

764772
/// Create a call to Masked Gather intrinsic

‎llvm/lib/CodeGen/ScalarizeMaskedMemIntrin.cpp

Lines changed: 16 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -849,39 +849,41 @@ bool ScalarizeMaskedMemIntrin::optimizeCallInst(CallInst *CI,
849849
bool &ModifiedDT) {
850850
IntrinsicInst *II = dyn_cast<IntrinsicInst>(CI);
851851
if (II) {
852-
unsigned Alignment;
853852
switch (II->getIntrinsicID()) {
854853
default:
855854
break;
856-
case Intrinsic::masked_load: {
855+
case Intrinsic::masked_load:
857856
// Scalarize unsupported vector masked load
858-
Alignment = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
859-
if (TTI->isLegalMaskedLoad(CI->getType(), MaybeAlign(Alignment)))
857+
if (TTI->isLegalMaskedLoad(
858+
CI->getType(),
859+
cast<ConstantInt>(CI->getArgOperand(1))->getAlignValue()))
860860
return false;
861861
scalarizeMaskedLoad(CI, ModifiedDT);
862862
return true;
863-
}
864-
case Intrinsic::masked_store: {
865-
Alignment = cast<ConstantInt>(CI->getArgOperand(2))->getZExtValue();
866-
if (TTI->isLegalMaskedStore(CI->getArgOperand(0)->getType(),
867-
MaybeAlign(Alignment)))
863+
case Intrinsic::masked_store:
864+
if (TTI->isLegalMaskedStore(
865+
CI->getArgOperand(0)->getType(),
866+
cast<ConstantInt>(CI->getArgOperand(2))->getAlignValue()))
868867
return false;
869868
scalarizeMaskedStore(CI, ModifiedDT);
870869
return true;
871-
}
872-
case Intrinsic::masked_gather:
873-
Alignment = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
870+
case Intrinsic::masked_gather: {
871+
unsigned Alignment =
872+
cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
874873
if (TTI->isLegalMaskedGather(CI->getType(), MaybeAlign(Alignment)))
875874
return false;
876875
scalarizeMaskedGather(CI, ModifiedDT);
877876
return true;
878-
case Intrinsic::masked_scatter:
879-
Alignment = cast<ConstantInt>(CI->getArgOperand(2))->getZExtValue();
877+
}
878+
case Intrinsic::masked_scatter: {
879+
unsigned Alignment =
880+
cast<ConstantInt>(CI->getArgOperand(2))->getZExtValue();
880881
if (TTI->isLegalMaskedScatter(CI->getArgOperand(0)->getType(),
881882
MaybeAlign(Alignment)))
882883
return false;
883884
scalarizeMaskedScatter(CI, ModifiedDT);
884885
return true;
886+
}
885887
case Intrinsic::masked_expandload:
886888
if (TTI->isLegalMaskedExpandLoad(CI->getType()))
887889
return false;

‎llvm/lib/IR/AutoUpgrade.cpp

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1237,18 +1237,19 @@ static Value *UpgradeMaskedStore(IRBuilder<> &Builder,
12371237
// Cast the pointer to the right type.
12381238
Ptr = Builder.CreateBitCast(Ptr,
12391239
llvm::PointerType::getUnqual(Data->getType()));
1240-
unsigned Align =
1241-
Aligned ? cast<VectorType>(Data->getType())->getBitWidth() / 8 : 1;
1240+
const Align Alignment =
1241+
Aligned ? Align(cast<VectorType>(Data->getType())->getBitWidth() / 8)
1242+
: Align::None();
12421243

12431244
// If the mask is all ones just emit a regular store.
12441245
if (const auto *C = dyn_cast<Constant>(Mask))
12451246
if (C->isAllOnesValue())
1246-
return Builder.CreateAlignedStore(Data, Ptr, Align);
1247+
return Builder.CreateAlignedStore(Data, Ptr, Alignment);
12471248

12481249
// Convert the mask from an integer type to a vector of i1.
12491250
unsigned NumElts = Data->getType()->getVectorNumElements();
12501251
Mask = getX86MaskVec(Builder, Mask, NumElts);
1251-
return Builder.CreateMaskedStore(Data, Ptr, Align, Mask);
1252+
return Builder.CreateMaskedStore(Data, Ptr, Alignment, Mask);
12521253
}
12531254

12541255
static Value *UpgradeMaskedLoad(IRBuilder<> &Builder,

‎llvm/lib/IR/IRBuilder.cpp

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -487,19 +487,19 @@ CallInst *IRBuilderBase::CreateMaskedLoad(Value *Ptr, Align Alignment,
487487
}
488488

489489
/// Create a call to a Masked Store intrinsic.
490-
/// \p Val - data to be stored,
491-
/// \p Ptr - base pointer for the store
492-
/// \p Align - alignment of the destination location
493-
/// \p Mask - vector of booleans which indicates what vector lanes should
494-
/// be accessed in memory
490+
/// \p Val - data to be stored,
491+
/// \p Ptr - base pointer for the store
492+
/// \p Alignment - alignment of the destination location
493+
/// \p Mask - vector of booleans which indicates what vector lanes should
494+
/// be accessed in memory
495495
CallInst *IRBuilderBase::CreateMaskedStore(Value *Val, Value *Ptr,
496-
unsigned Align, Value *Mask) {
496+
Align Alignment, Value *Mask) {
497497
auto *PtrTy = cast<PointerType>(Ptr->getType());
498498
Type *DataTy = PtrTy->getElementType();
499499
assert(DataTy->isVectorTy() && "Ptr should point to a vector");
500500
assert(Mask && "Mask should not be all-ones (null)");
501501
Type *OverloadedTypes[] = { DataTy, PtrTy };
502-
Value *Ops[] = { Val, Ptr, getInt32(Align), Mask };
502+
Value *Ops[] = {Val, Ptr, getInt32(Alignment.value()), Mask};
503503
return CreateMaskedIntrinsic(Intrinsic::masked_store, Ops, OverloadedTypes);
504504
}
505505

‎llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1372,7 +1372,7 @@ static bool simplifyX86MaskedStore(IntrinsicInst &II, InstCombiner &IC) {
13721372
// on each element's most significant bit (the sign bit).
13731373
Constant *BoolMask = getNegativeIsTrueBoolVec(ConstMask);
13741374

1375-
IC.Builder.CreateMaskedStore(Vec, PtrCast, 1, BoolMask);
1375+
IC.Builder.CreateMaskedStore(Vec, PtrCast, Align::None(), BoolMask);
13761376

13771377
// 'Replace uses' doesn't work for stores. Erase the original masked store.
13781378
IC.eraseInstFromFunction(II);

‎llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp

Lines changed: 5 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -2904,7 +2904,7 @@ struct MemorySanitizerVisitor : public InstVisitor<MemorySanitizerVisitor> {
29042904
IRBuilder<> IRB(&I);
29052905
Value *V = I.getArgOperand(0);
29062906
Value *Addr = I.getArgOperand(1);
2907-
const MaybeAlign Alignment(
2907+
const Align Alignment(
29082908
cast<ConstantInt>(I.getArgOperand(2))->getZExtValue());
29092909
Value *Mask = I.getArgOperand(3);
29102910
Value *Shadow = getShadow(V);
@@ -2921,21 +2921,20 @@ struct MemorySanitizerVisitor : public InstVisitor<MemorySanitizerVisitor> {
29212921
insertShadowCheck(Mask, &I);
29222922
}
29232923

2924-
IRB.CreateMaskedStore(Shadow, ShadowPtr, Alignment ? Alignment->value() : 0,
2925-
Mask);
2924+
IRB.CreateMaskedStore(Shadow, ShadowPtr, Alignment, Mask);
29262925

29272926
if (MS.TrackOrigins) {
29282927
auto &DL = F.getParent()->getDataLayout();
29292928
paintOrigin(IRB, getOrigin(V), OriginPtr,
29302929
DL.getTypeStoreSize(Shadow->getType()),
2931-
llvm::max(Alignment, kMinOriginAlignment));
2930+
std::max(Alignment, kMinOriginAlignment));
29322931
}
29332932
}
29342933

29352934
bool handleMaskedLoad(IntrinsicInst &I) {
29362935
IRBuilder<> IRB(&I);
29372936
Value *Addr = I.getArgOperand(0);
2938-
const MaybeAlign Alignment(
2937+
const Align Alignment(
29392938
cast<ConstantInt>(I.getArgOperand(1))->getZExtValue());
29402939
Value *Mask = I.getArgOperand(2);
29412940
Value *PassThru = I.getArgOperand(3);
@@ -2945,7 +2944,7 @@ struct MemorySanitizerVisitor : public InstVisitor<MemorySanitizerVisitor> {
29452944
if (PropagateShadow) {
29462945
std::tie(ShadowPtr, OriginPtr) =
29472946
getShadowOriginPtr(Addr, IRB, ShadowTy, Alignment, /*isStore*/ false);
2948-
setShadow(&I, IRB.CreateMaskedLoad(ShadowPtr, *Alignment, Mask,
2947+
setShadow(&I, IRB.CreateMaskedLoad(ShadowPtr, Alignment, Mask,
29492948
getShadow(PassThru), "_msmaskedld"));
29502949
} else {
29512950
setShadow(&I, getCleanShadow(&I));

‎llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -2343,7 +2343,7 @@ void InnerLoopVectorizer::vectorizeInterleaveGroup(Instruction *Instr,
23432343
Value *ShuffledMask = Builder.CreateShuffleVector(
23442344
BlockInMaskPart, Undefs, RepMask, "interleaved.mask");
23452345
NewStoreInstr = Builder.CreateMaskedStore(
2346-
IVec, AddrParts[Part], Group->getAlignment(), ShuffledMask);
2346+
IVec, AddrParts[Part], Group->getAlign(), ShuffledMask);
23472347
}
23482348
else
23492349
NewStoreInstr = Builder.CreateAlignedStore(IVec, AddrParts[Part],
@@ -2449,8 +2449,8 @@ void InnerLoopVectorizer::vectorizeMemoryInstruction(Instruction *Instr,
24492449
}
24502450
auto *VecPtr = CreateVecPtr(Part, State.get(Addr, {0, 0}));
24512451
if (isMaskRequired)
2452-
NewSI = Builder.CreateMaskedStore(
2453-
StoredVal, VecPtr, Alignment.value(), BlockInMaskParts[Part]);
2452+
NewSI = Builder.CreateMaskedStore(StoredVal, VecPtr, Alignment,
2453+
BlockInMaskParts[Part]);
24542454
else
24552455
NewSI =
24562456
Builder.CreateAlignedStore(StoredVal, VecPtr, Alignment.value());

0 commit comments

Comments
 (0)