/// \brief Return true if it is cheaper to split the store of a merged int val
/// from a pair of smaller values into multiple stores.
- virtual bool isMultiStoresCheaperThanBitsMerge(SDValue Lo, SDValue Hi) const {
+ virtual bool isMultiStoresCheaperThanBitsMerge(EVT LTy, EVT HTy) const {
return false;
}
Hi.getOperand(0).getValueSizeInBits() > HalfValBitSize)
return SDValue();
- if (!TLI.isMultiStoresCheaperThanBitsMerge(Lo.getOperand(0),
- Hi.getOperand(0)))
+ // Use the EVT of low and high parts before bitcast as the input
+ // of target query.
+ EVT LowTy = (Lo.getOperand(0).getOpcode() == ISD::BITCAST)
+ ? Lo.getOperand(0).getValueType()
+ : Lo.getValueType();
+ EVT HighTy = (Hi.getOperand(0).getOpcode() == ISD::BITCAST)
+ ? Hi.getOperand(0).getValueType()
+ : Hi.getValueType();
+ if (!TLI.isMultiStoresCheaperThanBitsMerge(LowTy, HighTy))
return SDValue();
// Start to split store.
return VT == MVT::f32 || VT == MVT::f64 || VT.isVector();
}
- bool isMultiStoresCheaperThanBitsMerge(SDValue Lo,
- SDValue Hi) const override {
+ bool isMultiStoresCheaperThanBitsMerge(EVT LTy, EVT HTy) const override {
// If the pair to store is a mixture of float and int values, we will
// save two bitwise instructions and one float-to-int instruction and
// increase one store instruction. There is potentially a more
// significant benefit because it avoids the float->int domain switch
// for input value. So It is more likely a win.
- if (Lo.getOpcode() == ISD::BITCAST || Hi.getOpcode() == ISD::BITCAST) {
- SDValue Opd = (Lo.getOpcode() == ISD::BITCAST) ? Lo.getOperand(0)
- : Hi.getOperand(0);
- if (Opd.getValueType().isFloatingPoint())
- return true;
- }
+ if ((LTy.isFloatingPoint() && HTy.isInteger()) ||
+ (LTy.isInteger() && HTy.isFloatingPoint()))
+ return true;
// If the pair only contains int values, we will save two bitwise
// instructions and increase one store instruction (costing one more
// store buffer). Since the benefit is more blurred so we leave