Skip to content

Commit b91535f

Browse files
gchateletgchatelet
committed
[Alignment][NFC] Return Align for SelectionDAGNodes::getOriginalAlignment/getAlignment
Summary: Also deprecate getOriginalAlignment, getAlignment will take much more time as it is pervasive through the codebase (including TableGened files). 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, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D76933
1 parent eb90692 commit b91535f

File tree

3 files changed

+49
-46
lines changed

3 files changed

+49
-46
lines changed

‎llvm/include/llvm/CodeGen/SelectionDAGNodes.h

Lines changed: 7 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1292,7 +1292,13 @@ class MemSDNode : public SDNode {
12921292
bool writeMem() const { return MMO->isStore(); }
12931293

12941294
/// Returns alignment and volatility of the memory access
1295-
unsigned getOriginalAlignment() const { return MMO->getBaseAlign().value(); }
1295+
Align getOriginalAlign() const { return MMO->getBaseAlign(); }
1296+
Align getAlign() const { return MMO->getAlign(); }
1297+
LLVM_ATTRIBUTE_DEPRECATED(unsigned getOriginalAlignment() const,
1298+
"Use getOriginalAlign() instead") {
1299+
return MMO->getBaseAlign().value();
1300+
}
1301+
// FIXME: Remove once transition to getAlign is over.
12961302
unsigned getAlignment() const { return MMO->getAlign().value(); }
12971303

12981304
/// Return the SubclassData value, without HasDebugValue. This contains an

‎llvm/lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp

Lines changed: 35 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -337,7 +337,7 @@ SDValue DAGTypeLegalizer::ScalarizeVecRes_LOAD(LoadSDNode *N) {
337337
N->getValueType(0).getVectorElementType(), SDLoc(N), N->getChain(),
338338
N->getBasePtr(), DAG.getUNDEF(N->getBasePtr().getValueType()),
339339
N->getPointerInfo(), N->getMemoryVT().getVectorElementType(),
340-
N->getOriginalAlignment(), N->getMemOperand()->getFlags(),
340+
N->getOriginalAlign().value(), N->getMemOperand()->getFlags(),
341341
N->getAAInfo());
342342

343343
// Legalize the chain result - switch anything that used the old chain to
@@ -755,8 +755,8 @@ SDValue DAGTypeLegalizer::ScalarizeVecOp_STORE(StoreSDNode *N, unsigned OpNo){
755755

756756
return DAG.getStore(N->getChain(), dl, GetScalarizedVector(N->getOperand(1)),
757757
N->getBasePtr(), N->getPointerInfo(),
758-
N->getOriginalAlignment(), N->getMemOperand()->getFlags(),
759-
N->getAAInfo());
758+
N->getOriginalAlign().value(),
759+
N->getMemOperand()->getFlags(), N->getAAInfo());
760760
}
761761

762762
/// If the value to round is a vector that needs to be scalarized, it must be
@@ -1509,7 +1509,7 @@ void DAGTypeLegalizer::SplitVecRes_LOAD(LoadSDNode *LD, SDValue &Lo,
15091509
SDValue Ptr = LD->getBasePtr();
15101510
SDValue Offset = DAG.getUNDEF(Ptr.getValueType());
15111511
EVT MemoryVT = LD->getMemoryVT();
1512-
unsigned Alignment = LD->getOriginalAlignment();
1512+
Align Alignment = LD->getOriginalAlign();
15131513
MachineMemOperand::Flags MMOFlags = LD->getMemOperand()->getFlags();
15141514
AAMDNodes AAInfo = LD->getAAInfo();
15151515

@@ -1525,13 +1525,14 @@ void DAGTypeLegalizer::SplitVecRes_LOAD(LoadSDNode *LD, SDValue &Lo,
15251525
}
15261526

15271527
Lo = DAG.getLoad(ISD::UNINDEXED, ExtType, LoVT, dl, Ch, Ptr, Offset,
1528-
LD->getPointerInfo(), LoMemVT, Alignment, MMOFlags, AAInfo);
1528+
LD->getPointerInfo(), LoMemVT, Alignment.value(), MMOFlags,
1529+
AAInfo);
15291530

15301531
unsigned IncrementSize = LoMemVT.getSizeInBits()/8;
15311532
Ptr = DAG.getObjectPtrOffset(dl, Ptr, IncrementSize);
15321533
Hi = DAG.getLoad(ISD::UNINDEXED, ExtType, HiVT, dl, Ch, Ptr, Offset,
15331534
LD->getPointerInfo().getWithOffset(IncrementSize), HiMemVT,
1534-
Alignment, MMOFlags, AAInfo);
1535+
Alignment.value(), MMOFlags, AAInfo);
15351536

15361537
// Build a factor node to remember that this load is independent of the
15371538
// other one.
@@ -1556,7 +1557,7 @@ void DAGTypeLegalizer::SplitVecRes_MLOAD(MaskedLoadSDNode *MLD,
15561557
assert(Offset.isUndef() && "Unexpected indexed masked load offset");
15571558
SDValue Mask = MLD->getMask();
15581559
SDValue PassThru = MLD->getPassThru();
1559-
unsigned Alignment = MLD->getOriginalAlignment();
1560+
Align Alignment = MLD->getOriginalAlign();
15601561
ISD::LoadExtType ExtType = MLD->getExtensionType();
15611562

15621563
// Split Mask operand
@@ -1580,10 +1581,9 @@ void DAGTypeLegalizer::SplitVecRes_MLOAD(MaskedLoadSDNode *MLD,
15801581
else
15811582
std::tie(PassThruLo, PassThruHi) = DAG.SplitVector(PassThru, dl);
15821583

1583-
MachineMemOperand *MMO = DAG.getMachineFunction().
1584-
getMachineMemOperand(MLD->getPointerInfo(),
1585-
MachineMemOperand::MOLoad, LoMemVT.getStoreSize(),
1586-
Alignment, MLD->getAAInfo(), MLD->getRanges());
1584+
MachineMemOperand *MMO = DAG.getMachineFunction().getMachineMemOperand(
1585+
MLD->getPointerInfo(), MachineMemOperand::MOLoad, LoMemVT.getStoreSize(),
1586+
Alignment.value(), MLD->getAAInfo(), MLD->getRanges());
15871587

15881588
Lo = DAG.getMaskedLoad(LoVT, dl, Ch, Ptr, Offset, MaskLo, PassThruLo, LoMemVT,
15891589
MMO, MLD->getAddressingMode(), ExtType,
@@ -1595,7 +1595,7 @@ void DAGTypeLegalizer::SplitVecRes_MLOAD(MaskedLoadSDNode *MLD,
15951595

15961596
MMO = DAG.getMachineFunction().getMachineMemOperand(
15971597
MLD->getPointerInfo().getWithOffset(HiOffset), MachineMemOperand::MOLoad,
1598-
HiMemVT.getStoreSize(), Alignment, MLD->getAAInfo(),
1598+
HiMemVT.getStoreSize(), Alignment.value(), MLD->getAAInfo(),
15991599
MLD->getRanges());
16001600

16011601
Hi = DAG.getMaskedLoad(HiVT, dl, Ch, Ptr, Offset, MaskHi, PassThruHi, HiMemVT,
@@ -1625,7 +1625,7 @@ void DAGTypeLegalizer::SplitVecRes_MGATHER(MaskedGatherSDNode *MGT,
16251625
SDValue PassThru = MGT->getPassThru();
16261626
SDValue Index = MGT->getIndex();
16271627
SDValue Scale = MGT->getScale();
1628-
unsigned Alignment = MGT->getOriginalAlignment();
1628+
Align Alignment = MGT->getOriginalAlign();
16291629

16301630
// Split Mask operand
16311631
SDValue MaskLo, MaskHi;
@@ -1652,7 +1652,7 @@ void DAGTypeLegalizer::SplitVecRes_MGATHER(MaskedGatherSDNode *MGT,
16521652

16531653
MachineMemOperand *MMO = DAG.getMachineFunction().getMachineMemOperand(
16541654
MGT->getPointerInfo(), MachineMemOperand::MOLoad,
1655-
MemoryLocation::UnknownSize, Alignment, MGT->getAAInfo(),
1655+
MemoryLocation::UnknownSize, Alignment.value(), MGT->getAAInfo(),
16561656
MGT->getRanges());
16571657

16581658
SDValue OpsLo[] = {Ch, PassThruLo, MaskLo, Ptr, IndexLo, Scale};
@@ -2255,7 +2255,7 @@ SDValue DAGTypeLegalizer::SplitVecOp_MGATHER(MaskedGatherSDNode *MGT,
22552255
SDValue Scale = MGT->getScale();
22562256
SDValue Mask = MGT->getMask();
22572257
SDValue PassThru = MGT->getPassThru();
2258-
unsigned Alignment = MGT->getOriginalAlignment();
2258+
Align Alignment = MGT->getOriginalAlign();
22592259

22602260
SDValue MaskLo, MaskHi;
22612261
if (getTypeAction(Mask.getValueType()) == TargetLowering::TypeSplitVector)
@@ -2280,20 +2280,17 @@ SDValue DAGTypeLegalizer::SplitVecOp_MGATHER(MaskedGatherSDNode *MGT,
22802280
else
22812281
std::tie(IndexLo, IndexHi) = DAG.SplitVector(Index, dl);
22822282

2283-
MachineMemOperand *MMO = DAG.getMachineFunction().
2284-
getMachineMemOperand(MGT->getPointerInfo(),
2285-
MachineMemOperand::MOLoad, LoMemVT.getStoreSize(),
2286-
Alignment, MGT->getAAInfo(), MGT->getRanges());
2283+
MachineMemOperand *MMO = DAG.getMachineFunction().getMachineMemOperand(
2284+
MGT->getPointerInfo(), MachineMemOperand::MOLoad, LoMemVT.getStoreSize(),
2285+
Alignment.value(), MGT->getAAInfo(), MGT->getRanges());
22872286

22882287
SDValue OpsLo[] = {Ch, PassThruLo, MaskLo, Ptr, IndexLo, Scale};
22892288
SDValue Lo = DAG.getMaskedGather(DAG.getVTList(LoVT, MVT::Other), LoVT, dl,
22902289
OpsLo, MMO, MGT->getIndexType());
22912290

2292-
MMO = DAG.getMachineFunction().
2293-
getMachineMemOperand(MGT->getPointerInfo(),
2294-
MachineMemOperand::MOLoad, HiMemVT.getStoreSize(),
2295-
Alignment, MGT->getAAInfo(),
2296-
MGT->getRanges());
2291+
MMO = DAG.getMachineFunction().getMachineMemOperand(
2292+
MGT->getPointerInfo(), MachineMemOperand::MOLoad, HiMemVT.getStoreSize(),
2293+
Alignment.value(), MGT->getAAInfo(), MGT->getRanges());
22972294

22982295
SDValue OpsHi[] = {Ch, PassThruHi, MaskHi, Ptr, IndexHi, Scale};
22992296
SDValue Hi = DAG.getMaskedGather(DAG.getVTList(HiVT, MVT::Other), HiVT, dl,
@@ -2324,7 +2321,7 @@ SDValue DAGTypeLegalizer::SplitVecOp_MSTORE(MaskedStoreSDNode *N,
23242321
SDValue Mask = N->getMask();
23252322
SDValue Data = N->getValue();
23262323
EVT MemoryVT = N->getMemoryVT();
2327-
unsigned Alignment = N->getOriginalAlignment();
2324+
Align Alignment = N->getOriginalAlign();
23282325
SDLoc DL(N);
23292326

23302327
EVT LoMemVT, HiMemVT;
@@ -2349,10 +2346,9 @@ SDValue DAGTypeLegalizer::SplitVecOp_MSTORE(MaskedStoreSDNode *N,
23492346
}
23502347

23512348
SDValue Lo, Hi;
2352-
MachineMemOperand *MMO = DAG.getMachineFunction().
2353-
getMachineMemOperand(N->getPointerInfo(),
2354-
MachineMemOperand::MOStore, LoMemVT.getStoreSize(),
2355-
Alignment, N->getAAInfo(), N->getRanges());
2349+
MachineMemOperand *MMO = DAG.getMachineFunction().getMachineMemOperand(
2350+
N->getPointerInfo(), MachineMemOperand::MOStore, LoMemVT.getStoreSize(),
2351+
Alignment.value(), N->getAAInfo(), N->getRanges());
23562352

23572353
Lo = DAG.getMaskedStore(Ch, DL, DataLo, Ptr, Offset, MaskLo, LoMemVT, MMO,
23582354
N->getAddressingMode(), N->isTruncatingStore(),
@@ -2364,7 +2360,7 @@ SDValue DAGTypeLegalizer::SplitVecOp_MSTORE(MaskedStoreSDNode *N,
23642360

23652361
MMO = DAG.getMachineFunction().getMachineMemOperand(
23662362
N->getPointerInfo().getWithOffset(HiOffset), MachineMemOperand::MOStore,
2367-
HiMemVT.getStoreSize(), Alignment, N->getAAInfo(),
2363+
HiMemVT.getStoreSize(), Alignment.value(), N->getAAInfo(),
23682364
N->getRanges());
23692365

23702366
Hi = DAG.getMaskedStore(Ch, DL, DataHi, Ptr, Offset, MaskHi, HiMemVT, MMO,
@@ -2384,7 +2380,7 @@ SDValue DAGTypeLegalizer::SplitVecOp_MSCATTER(MaskedScatterSDNode *N,
23842380
SDValue Index = N->getIndex();
23852381
SDValue Scale = N->getScale();
23862382
SDValue Data = N->getValue();
2387-
unsigned Alignment = N->getOriginalAlignment();
2383+
Align Alignment = N->getOriginalAlign();
23882384
SDLoc DL(N);
23892385

23902386
// Split all operands
@@ -2416,7 +2412,8 @@ SDValue DAGTypeLegalizer::SplitVecOp_MSCATTER(MaskedScatterSDNode *N,
24162412
SDValue Lo;
24172413
MachineMemOperand *MMO = DAG.getMachineFunction().getMachineMemOperand(
24182414
N->getPointerInfo(), MachineMemOperand::MOStore,
2419-
MemoryLocation::UnknownSize, Alignment, N->getAAInfo(), N->getRanges());
2415+
MemoryLocation::UnknownSize, Alignment.value(), N->getAAInfo(),
2416+
N->getRanges());
24202417

24212418
SDValue OpsLo[] = {Ch, DataLo, MaskLo, Ptr, IndexLo, Scale};
24222419
Lo = DAG.getMaskedScatter(DAG.getVTList(MVT::Other), DataLo.getValueType(),
@@ -2439,7 +2436,7 @@ SDValue DAGTypeLegalizer::SplitVecOp_STORE(StoreSDNode *N, unsigned OpNo) {
24392436
SDValue Ch = N->getChain();
24402437
SDValue Ptr = N->getBasePtr();
24412438
EVT MemoryVT = N->getMemoryVT();
2442-
unsigned Alignment = N->getOriginalAlignment();
2439+
Align Alignment = N->getOriginalAlign();
24432440
MachineMemOperand::Flags MMOFlags = N->getMemOperand()->getFlags();
24442441
AAMDNodes AAInfo = N->getAAInfo();
24452442
SDValue Lo, Hi;
@@ -2456,22 +2453,22 @@ SDValue DAGTypeLegalizer::SplitVecOp_STORE(StoreSDNode *N, unsigned OpNo) {
24562453

24572454
if (isTruncating)
24582455
Lo = DAG.getTruncStore(Ch, DL, Lo, Ptr, N->getPointerInfo(), LoMemVT,
2459-
Alignment, MMOFlags, AAInfo);
2456+
Alignment.value(), MMOFlags, AAInfo);
24602457
else
2461-
Lo = DAG.getStore(Ch, DL, Lo, Ptr, N->getPointerInfo(), Alignment, MMOFlags,
2462-
AAInfo);
2458+
Lo = DAG.getStore(Ch, DL, Lo, Ptr, N->getPointerInfo(), Alignment.value(),
2459+
MMOFlags, AAInfo);
24632460

24642461
// Increment the pointer to the other half.
24652462
Ptr = DAG.getObjectPtrOffset(DL, Ptr, IncrementSize);
24662463

24672464
if (isTruncating)
24682465
Hi = DAG.getTruncStore(Ch, DL, Hi, Ptr,
24692466
N->getPointerInfo().getWithOffset(IncrementSize),
2470-
HiMemVT, Alignment, MMOFlags, AAInfo);
2467+
HiMemVT, Alignment.value(), MMOFlags, AAInfo);
24712468
else
24722469
Hi = DAG.getStore(Ch, DL, Hi, Ptr,
24732470
N->getPointerInfo().getWithOffset(IncrementSize),
2474-
Alignment, MMOFlags, AAInfo);
2471+
Alignment.value(), MMOFlags, AAInfo);
24752472

24762473
return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Lo, Hi);
24772474
}

‎llvm/lib/Target/ARM/ARMISelLowering.cpp

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -13924,7 +13924,7 @@ static SDValue PerformSplittingToNarrowingStores(StoreSDNode *St,
1392413924
// Details about the old store
1392513925
SDValue Ch = St->getChain();
1392613926
SDValue BasePtr = St->getBasePtr();
13927-
unsigned Alignment = St->getOriginalAlignment();
13927+
Align Alignment = St->getOriginalAlign();
1392813928
MachineMemOperand::Flags MMOFlags = St->getMemOperand()->getFlags();
1392913929
AAMDNodes AAInfo = St->getAAInfo();
1393013930

@@ -13941,7 +13941,7 @@ static SDValue PerformSplittingToNarrowingStores(StoreSDNode *St,
1394113941
DAG.getConstant(i * NumElements, DL, MVT::i32));
1394213942
SDValue Store = DAG.getTruncStore(
1394313943
Ch, DL, Extract, NewPtr, St->getPointerInfo().getWithOffset(NewOffset),
13944-
NewToVT, Alignment, MMOFlags, AAInfo);
13944+
NewToVT, Alignment.value(), MMOFlags, AAInfo);
1394513945
Stores.push_back(Store);
1394613946
}
1394713947
return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Stores);
@@ -14586,7 +14586,7 @@ static SDValue PerformSplittingToWideningLoad(SDNode *N, SelectionDAG &DAG) {
1458614586
// Details about the old load
1458714587
SDValue Ch = LD->getChain();
1458814588
SDValue BasePtr = LD->getBasePtr();
14589-
unsigned Alignment = LD->getOriginalAlignment();
14589+
Align Alignment = LD->getOriginalAlign();
1459014590
MachineMemOperand::Flags MMOFlags = LD->getMemOperand()->getFlags();
1459114591
AAMDNodes AAInfo = LD->getAAInfo();
1459214592

@@ -14602,13 +14602,13 @@ static SDValue PerformSplittingToWideningLoad(SDNode *N, SelectionDAG &DAG) {
1460214602
// is good enough, as legalisation will take it from there. They are either
1460314603
// already legal or they will be split further into something that is
1460414604
// legal.
14605-
SDValue NewLoad1 =
14606-
DAG.getLoad(ISD::UNINDEXED, NewExtType, NewToVT, DL, Ch, BasePtr, Offset,
14607-
LD->getPointerInfo(), NewFromVT, Alignment, MMOFlags, AAInfo);
14605+
SDValue NewLoad1 = DAG.getLoad(
14606+
ISD::UNINDEXED, NewExtType, NewToVT, DL, Ch, BasePtr, Offset,
14607+
LD->getPointerInfo(), NewFromVT, Alignment.value(), MMOFlags, AAInfo);
1460814608
SDValue NewLoad2 =
1460914609
DAG.getLoad(ISD::UNINDEXED, NewExtType, NewToVT, DL, Ch, NewPtr, Offset,
1461014610
LD->getPointerInfo().getWithOffset(NewOffset), NewFromVT,
14611-
Alignment, MMOFlags, AAInfo);
14611+
Alignment.value(), MMOFlags, AAInfo);
1461214612

1461314613
SDValue NewChain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
1461414614
SDValue(NewLoad1.getNode(), 1),

0 commit comments

Comments
 (0)