Ranges);
}
/// FIXME: Remove once transition to Align is over.
+ LLVM_DEPRECATED("Use the getLoad function that takes a MaybeAlign instead",
+ "")
inline SDValue
getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType, EVT VT,
const SDLoc &dl, SDValue Chain, SDValue Ptr, SDValue Offset,
MMOFlags, AAInfo);
}
/// FIXME: Remove once transition to Align is over.
+ LLVM_DEPRECATED("Use the version that takes a MaybeAlign instead", "")
inline SDValue
getStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr,
MachinePointerInfo PtrInfo, unsigned Alignment,
AAInfo);
}
/// FIXME: Remove once transition to Align is over.
+ LLVM_DEPRECATED("Use the version that takes a MaybeAlign instead", "")
inline SDValue
getTruncStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr,
MachinePointerInfo PtrInfo, EVT SVT, unsigned Alignment,
// size of the register which isn't useful.
unsigned PartOffset = VA.getLocMemOffset();
- unsigned Alignment = MinAlign(VT.getStoreSize(), PartOffset);
+ Align Alignment = commonAlignment(Align(VT.getStoreSize()), PartOffset);
MachinePointerInfo PtrInfo(AMDGPUAS::PARAM_I_ADDRESS);
SDValue Arg = DAG.getLoad(
SDValue Store = DAG.getTruncStore(
Ch, DL, Extract, NewPtr, St->getPointerInfo().getWithOffset(NewOffset),
- NewToVT, Alignment.value(), MMOFlags, AAInfo);
+ NewToVT, Alignment, MMOFlags, AAInfo);
Stores.push_back(Store);
}
return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Stores);
SDValue Extract = Trunc.getOperand(i);
SDValue Store = DAG.getTruncStore(
Ch, DL, Extract, NewPtr, St->getPointerInfo().getWithOffset(NewOffset),
- NewToVT, Alignment.value(), MMOFlags, AAInfo);
+ NewToVT, Alignment, MMOFlags, AAInfo);
Stores.push_back(Store);
}
return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Stores);
AAMDNodes AAInfo = St->getAAInfo();
EVT NewToVT = EVT::getIntegerVT(C, VT.getSizeInBits());
SDValue Store = DAG.getTruncStore(Ch, DL, SDValue(GetLane, 0), BasePtr,
- St->getPointerInfo(), NewToVT,
- Alignment.value(), MMOFlags, AAInfo);
+ St->getPointerInfo(), NewToVT, Alignment,
+ MMOFlags, AAInfo);
return Store;
}
// MVI, MVHHI, MVHI and MVGHI respectively.
static SDValue memsetStore(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain,
SDValue Dst, uint64_t ByteVal, uint64_t Size,
- unsigned Align, MachinePointerInfo DstPtrInfo) {
+ Align Alignment, MachinePointerInfo DstPtrInfo) {
uint64_t StoreVal = ByteVal;
for (unsigned I = 1; I < Size; ++I)
StoreVal |= ByteVal << (I * 8);
return DAG.getStore(
Chain, DL, DAG.getConstant(StoreVal, DL, MVT::getIntegerVT(Size * 8)),
- Dst, DstPtrInfo, Align);
+ Dst, DstPtrInfo, Alignment);
}
SDValue SystemZSelectionDAGInfo::EmitTargetCodeForMemset(
unsigned Size1 = Bytes == 16 ? 8 : 1 << findLastSet(Bytes);
unsigned Size2 = Bytes - Size1;
SDValue Chain1 = memsetStore(DAG, DL, Chain, Dst, ByteVal, Size1,
- Alignment.value(), DstPtrInfo);
+ Alignment, DstPtrInfo);
if (Size2 == 0)
return Chain1;
Dst = DAG.getNode(ISD::ADD, DL, PtrVT, Dst,
DAG.getConstant(Size1, DL, PtrVT));
DstPtrInfo = DstPtrInfo.getWithOffset(Size1);
- SDValue Chain2 = memsetStore(
- DAG, DL, Chain, Dst, ByteVal, Size2,
- std::min((unsigned)Alignment.value(), Size1), DstPtrInfo);
+ SDValue Chain2 =
+ memsetStore(DAG, DL, Chain, Dst, ByteVal, Size2,
+ std::min(Alignment, Align(Size1)), DstPtrInfo);
return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Chain1, Chain2);
}
} else {
SDNode *Lo64 = DAG.getMachineNode(TargetOpcode::EXTRACT_SUBREG, DL, MVT::i64,
StNode->getValue(), SubRegOdd);
- unsigned Alignment = StNode->getAlign().value();
+ Align Alignment = StNode->getAlign();
if (Alignment > 8)
- Alignment = 8;
+ Alignment = Align(8);
// VE stores Hi64 to 8(addr) and Lo64 to 0(addr)
SDValue OutChains[2];
assert(StNode && StNode->getOffset().isUndef() && "Unexpected node type");
SDValue BasePtr = StNode->getBasePtr();
- unsigned Alignment = StNode->getAlign().value();
+ Align Alignment = StNode->getAlign();
if (Alignment > 8)
- Alignment = 8;
+ Alignment = Align(8);
EVT AddrVT = BasePtr.getValueType();
EVT MemVT = StNode->getMemoryVT();
if (MemVT == MVT::v256i1 || MemVT == MVT::v4i64) {
// Update rounding mode bits and store the new FP Control Word into stack.
CWD = DAG.getNode(ISD::OR, DL, MVT::i16, CWD, RMBits);
- Chain = DAG.getStore(Chain, DL, CWD, StackSlot, MPI, /* Alignment = */ 2);
+ Chain = DAG.getStore(Chain, DL, CWD, StackSlot, MPI, Align(2));
// Load FP control word from the slot.
SDValue OpsLD[] = {Chain, StackSlot};
// Update rounding mode bits and store the new FP Control Word into stack.
CWD = DAG.getNode(ISD::OR, DL, MVT::i32, CWD, RMBits);
- Chain = DAG.getStore(Chain, DL, CWD, StackSlot, MPI, /* Alignment = */ 4);
+ Chain = DAG.getStore(Chain, DL, CWD, StackSlot, MPI, Align(4));
// Load MXCSR from the slot.
Chain = DAG.getNode(