Skip to content

Commit 830cfda

Browse files
arsenmarsenm
committed
Utils: Mostly convert memcpy expansion to use Align
The TTI hooks aren't converted. I also think the intrinsics should have mandatory alignment and never return MaybeAlign.
1 parent 7638710 commit 830cfda

File tree

3 files changed

+49
-46
lines changed

3 files changed

+49
-46
lines changed

‎llvm/include/llvm/Transforms/Utils/LowerMemIntrinsics.h

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -23,24 +23,24 @@ class MemMoveInst;
2323
class MemSetInst;
2424
class TargetTransformInfo;
2525
class Value;
26+
struct Align;
2627

2728
/// Emit a loop implementing the semantics of llvm.memcpy where the size is not
2829
/// a compile-time constant. Loop will be insterted at \p InsertBefore.
2930
void createMemCpyLoopUnknownSize(Instruction *InsertBefore, Value *SrcAddr,
3031
Value *DstAddr, Value *CopyLen,
31-
unsigned SrcAlign, unsigned DestAlign,
32+
Align SrcAlign, Align DestAlign,
3233
bool SrcIsVolatile, bool DstIsVolatile,
3334
const TargetTransformInfo &TTI);
3435

3536
/// Emit a loop implementing the semantics of an llvm.memcpy whose size is a
3637
/// compile time constant. Loop is inserted at \p InsertBefore.
3738
void createMemCpyLoopKnownSize(Instruction *InsertBefore, Value *SrcAddr,
3839
Value *DstAddr, ConstantInt *CopyLen,
39-
unsigned SrcAlign, unsigned DestAlign,
40+
Align SrcAlign, Align DestAlign,
4041
bool SrcIsVolatile, bool DstIsVolatile,
4142
const TargetTransformInfo &TTI);
4243

43-
4444
/// Expand \p MemCpy as a loop. \p MemCpy is not deleted.
4545
void expandMemCpyAsLoop(MemCpyInst *MemCpy, const TargetTransformInfo &TTI);
4646

‎llvm/lib/Target/NVPTX/NVPTXLowerAggrCopies.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -113,8 +113,8 @@ bool NVPTXLowerAggrCopies::runOnFunction(Function &F) {
113113
createMemCpyLoopKnownSize(/* ConvertedInst */ SI,
114114
/* SrcAddr */ SrcAddr, /* DstAddr */ DstAddr,
115115
/* CopyLen */ CopyLen,
116-
/* SrcAlign */ LI->getAlignment(),
117-
/* DestAlign */ SI->getAlignment(),
116+
/* SrcAlign */ LI->getAlign().valueOrOne(),
117+
/* DestAlign */ SI->getAlign().valueOrOne(),
118118
/* SrcIsVolatile */ LI->isVolatile(),
119119
/* DstIsVolatile */ SI->isVolatile(), TTI);
120120

‎llvm/lib/Transforms/Utils/LowerMemIntrinsics.cpp

Lines changed: 44 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,7 @@ using namespace llvm;
1616

1717
void llvm::createMemCpyLoopKnownSize(Instruction *InsertBefore, Value *SrcAddr,
1818
Value *DstAddr, ConstantInt *CopyLen,
19-
unsigned SrcAlign, unsigned DstAlign,
19+
Align SrcAlign, Align DstAlign,
2020
bool SrcIsVolatile, bool DstIsVolatile,
2121
const TargetTransformInfo &TTI) {
2222
// No need to expand zero length copies.
@@ -33,8 +33,8 @@ void llvm::createMemCpyLoopKnownSize(Instruction *InsertBefore, Value *SrcAddr,
3333
unsigned DstAS = cast<PointerType>(DstAddr->getType())->getAddressSpace();
3434

3535
Type *TypeOfCopyLen = CopyLen->getType();
36-
Type *LoopOpType = TTI.getMemcpyLoopLoweringType(Ctx, CopyLen, SrcAS, DstAS,
37-
SrcAlign, DstAlign);
36+
Type *LoopOpType = TTI.getMemcpyLoopLoweringType(
37+
Ctx, CopyLen, SrcAS, DstAS, SrcAlign.value(), DstAlign.value());
3838

3939
unsigned LoopOpSize = DL.getTypeStoreSize(LoopOpType);
4040
uint64_t LoopEndCount = CopyLen->getZExtValue() / LoopOpSize;
@@ -59,8 +59,8 @@ void llvm::createMemCpyLoopKnownSize(Instruction *InsertBefore, Value *SrcAddr,
5959
DstAddr = PLBuilder.CreateBitCast(DstAddr, DstOpType);
6060
}
6161

62-
Align PartDstAlign(MinAlign(DstAlign, LoopOpSize));
63-
Align PartSrcAlign(MinAlign(SrcAlign, LoopOpSize));
62+
Align PartDstAlign(commonAlignment(DstAlign, LoopOpSize));
63+
Align PartSrcAlign(commonAlignment(SrcAlign, LoopOpSize));
6464

6565
IRBuilder<> LoopBuilder(LoopBB);
6666
PHINode *LoopIndex = LoopBuilder.CreatePHI(TypeOfCopyLen, 2, "loop-index");
@@ -92,11 +92,12 @@ void llvm::createMemCpyLoopKnownSize(Instruction *InsertBefore, Value *SrcAddr,
9292

9393
SmallVector<Type *, 5> RemainingOps;
9494
TTI.getMemcpyLoopResidualLoweringType(RemainingOps, Ctx, RemainingBytes,
95-
SrcAS, DstAS, SrcAlign, DstAlign);
95+
SrcAS, DstAS, SrcAlign.value(),
96+
DstAlign.value());
9697

9798
for (auto OpTy : RemainingOps) {
98-
Align PartSrcAlign(MinAlign(SrcAlign, BytesCopied));
99-
Align PartDstAlign(MinAlign(DstAlign, BytesCopied));
99+
Align PartSrcAlign(commonAlignment(SrcAlign, BytesCopied));
100+
Align PartDstAlign(commonAlignment(DstAlign, BytesCopied));
100101

101102
// Calaculate the new index
102103
unsigned OperandSize = DL.getTypeStoreSize(OpTy);
@@ -131,8 +132,8 @@ void llvm::createMemCpyLoopKnownSize(Instruction *InsertBefore, Value *SrcAddr,
131132

132133
void llvm::createMemCpyLoopUnknownSize(Instruction *InsertBefore,
133134
Value *SrcAddr, Value *DstAddr,
134-
Value *CopyLen, unsigned SrcAlign,
135-
unsigned DstAlign, bool SrcIsVolatile,
135+
Value *CopyLen, Align SrcAlign,
136+
Align DstAlign, bool SrcIsVolatile,
136137
bool DstIsVolatile,
137138
const TargetTransformInfo &TTI) {
138139
BasicBlock *PreLoopBB = InsertBefore->getParent();
@@ -145,8 +146,8 @@ void llvm::createMemCpyLoopUnknownSize(Instruction *InsertBefore,
145146
unsigned SrcAS = cast<PointerType>(SrcAddr->getType())->getAddressSpace();
146147
unsigned DstAS = cast<PointerType>(DstAddr->getType())->getAddressSpace();
147148

148-
Type *LoopOpType = TTI.getMemcpyLoopLoweringType(Ctx, CopyLen, SrcAS, DstAS,
149-
SrcAlign, DstAlign);
149+
Type *LoopOpType = TTI.getMemcpyLoopLoweringType(
150+
Ctx, CopyLen, SrcAS, DstAS, SrcAlign.value(), DstAlign.value());
150151
unsigned LoopOpSize = DL.getTypeStoreSize(LoopOpType);
151152

152153
IRBuilder<> PLBuilder(PreLoopBB->getTerminator());
@@ -175,8 +176,8 @@ void llvm::createMemCpyLoopUnknownSize(Instruction *InsertBefore,
175176
BasicBlock::Create(Ctx, "loop-memcpy-expansion", ParentFunc, PostLoopBB);
176177
IRBuilder<> LoopBuilder(LoopBB);
177178

178-
Align PartSrcAlign(MinAlign(SrcAlign, LoopOpSize));
179-
Align PartDstAlign(MinAlign(DstAlign, LoopOpSize));
179+
Align PartSrcAlign(commonAlignment(SrcAlign, LoopOpSize));
180+
Align PartDstAlign(commonAlignment(DstAlign, LoopOpSize));
180181

181182
PHINode *LoopIndex = LoopBuilder.CreatePHI(CopyLenType, 2, "loop-index");
182183
LoopIndex->addIncoming(ConstantInt::get(CopyLenType, 0U), PreLoopBB);
@@ -288,8 +289,8 @@ void llvm::createMemCpyLoopUnknownSize(Instruction *InsertBefore,
288289
// return dst;
289290
// }
290291
static void createMemMoveLoop(Instruction *InsertBefore, Value *SrcAddr,
291-
Value *DstAddr, Value *CopyLen, unsigned SrcAlign,
292-
unsigned DstAlign, bool SrcIsVolatile,
292+
Value *DstAddr, Value *CopyLen, Align SrcAlign,
293+
Align DstAlign, bool SrcIsVolatile,
293294
bool DstIsVolatile) {
294295
Type *TypeOfCopyLen = CopyLen->getType();
295296
BasicBlock *OrigBB = InsertBefore->getParent();
@@ -323,8 +324,8 @@ static void createMemMoveLoop(Instruction *InsertBefore, Value *SrcAddr,
323324
ExitBB->setName("memmove_done");
324325

325326
unsigned PartSize = DL.getTypeStoreSize(EltTy);
326-
Align PartSrcAlign(MinAlign(SrcAlign, PartSize));
327-
Align PartDstAlign(MinAlign(DstAlign, PartSize));
327+
Align PartSrcAlign(commonAlignment(SrcAlign, PartSize));
328+
Align PartDstAlign(commonAlignment(DstAlign, PartSize));
328329

329330
// Initial comparison of n == 0 that lets us skip the loops altogether. Shared
330331
// between both backwards and forward copy clauses.
@@ -375,7 +376,7 @@ static void createMemMoveLoop(Instruction *InsertBefore, Value *SrcAddr,
375376
}
376377

377378
static void createMemSetLoop(Instruction *InsertBefore, Value *DstAddr,
378-
Value *CopyLen, Value *SetValue, unsigned DstAlign,
379+
Value *CopyLen, Value *SetValue, Align DstAlign,
379380
bool IsVolatile) {
380381
Type *TypeOfCopyLen = CopyLen->getType();
381382
BasicBlock *OrigBB = InsertBefore->getParent();
@@ -399,7 +400,7 @@ static void createMemSetLoop(Instruction *InsertBefore, Value *DstAddr,
399400
OrigBB->getTerminator()->eraseFromParent();
400401

401402
unsigned PartSize = DL.getTypeStoreSize(SetValue->getType());
402-
Align PartAlign(MinAlign(DstAlign, PartSize));
403+
Align PartAlign(commonAlignment(DstAlign, PartSize));
403404

404405
IRBuilder<> LoopBuilder(LoopBB);
405406
PHINode *LoopIndex = LoopBuilder.CreatePHI(TypeOfCopyLen, 0);
@@ -421,25 +422,27 @@ static void createMemSetLoop(Instruction *InsertBefore, Value *DstAddr,
421422
void llvm::expandMemCpyAsLoop(MemCpyInst *Memcpy,
422423
const TargetTransformInfo &TTI) {
423424
if (ConstantInt *CI = dyn_cast<ConstantInt>(Memcpy->getLength())) {
424-
createMemCpyLoopKnownSize(/* InsertBefore */ Memcpy,
425-
/* SrcAddr */ Memcpy->getRawSource(),
426-
/* DstAddr */ Memcpy->getRawDest(),
427-
/* CopyLen */ CI,
428-
/* SrcAlign */ Memcpy->getSourceAlignment(),
429-
/* DestAlign */ Memcpy->getDestAlignment(),
430-
/* SrcIsVolatile */ Memcpy->isVolatile(),
431-
/* DstIsVolatile */ Memcpy->isVolatile(),
432-
/* TargetTransformInfo */ TTI);
425+
createMemCpyLoopKnownSize(
426+
/* InsertBefore */ Memcpy,
427+
/* SrcAddr */ Memcpy->getRawSource(),
428+
/* DstAddr */ Memcpy->getRawDest(),
429+
/* CopyLen */ CI,
430+
/* SrcAlign */ Memcpy->getSourceAlign().valueOrOne(),
431+
/* DestAlign */ Memcpy->getDestAlign().valueOrOne(),
432+
/* SrcIsVolatile */ Memcpy->isVolatile(),
433+
/* DstIsVolatile */ Memcpy->isVolatile(),
434+
/* TargetTransformInfo */ TTI);
433435
} else {
434-
createMemCpyLoopUnknownSize(/* InsertBefore */ Memcpy,
435-
/* SrcAddr */ Memcpy->getRawSource(),
436-
/* DstAddr */ Memcpy->getRawDest(),
437-
/* CopyLen */ Memcpy->getLength(),
438-
/* SrcAlign */ Memcpy->getSourceAlignment(),
439-
/* DestAlign */ Memcpy->getDestAlignment(),
440-
/* SrcIsVolatile */ Memcpy->isVolatile(),
441-
/* DstIsVolatile */ Memcpy->isVolatile(),
442-
/* TargetTransfomrInfo */ TTI);
436+
createMemCpyLoopUnknownSize(
437+
/* InsertBefore */ Memcpy,
438+
/* SrcAddr */ Memcpy->getRawSource(),
439+
/* DstAddr */ Memcpy->getRawDest(),
440+
/* CopyLen */ Memcpy->getLength(),
441+
/* SrcAlign */ Memcpy->getSourceAlign().valueOrOne(),
442+
/* DestAlign */ Memcpy->getDestAlign().valueOrOne(),
443+
/* SrcIsVolatile */ Memcpy->isVolatile(),
444+
/* DstIsVolatile */ Memcpy->isVolatile(),
445+
/* TargetTransfomrInfo */ TTI);
443446
}
444447
}
445448

@@ -448,8 +451,8 @@ void llvm::expandMemMoveAsLoop(MemMoveInst *Memmove) {
448451
/* SrcAddr */ Memmove->getRawSource(),
449452
/* DstAddr */ Memmove->getRawDest(),
450453
/* CopyLen */ Memmove->getLength(),
451-
/* SrcAlign */ Memmove->getSourceAlignment(),
452-
/* DestAlign */ Memmove->getDestAlignment(),
454+
/* SrcAlign */ Memmove->getSourceAlign().valueOrOne(),
455+
/* DestAlign */ Memmove->getDestAlign().valueOrOne(),
453456
/* SrcIsVolatile */ Memmove->isVolatile(),
454457
/* DstIsVolatile */ Memmove->isVolatile());
455458
}
@@ -459,6 +462,6 @@ void llvm::expandMemSetAsLoop(MemSetInst *Memset) {
459462
/* DstAddr */ Memset->getRawDest(),
460463
/* CopyLen */ Memset->getLength(),
461464
/* SetValue */ Memset->getValue(),
462-
/* Alignment */ Memset->getDestAlignment(),
465+
/* Alignment */ Memset->getDestAlign().valueOrOne(),
463466
Memset->isVolatile());
464467
}

0 commit comments

Comments
 (0)