Legal, // The target natively supports this type.
PromoteInteger, // Replace this integer type with a larger one.
ExpandInteger, // Split this integer type into two of half the size.
- PromoteFloat, // Convert this float type to a same size integer type.
+ SoftenFloat, // Convert this float type to a same size integer type.
ExpandFloat, // Split this float type into two of half the size.
Scalarize, // Replace this one-element vector type with its element type.
Split // This vector type should be split into smaller vectors.
return ExpandInteger;
else if (VT.getSizeInBits() ==
TLI.getTypeToTransformTo(VT).getSizeInBits())
- return PromoteFloat;
+ return SoftenFloat;
else
return ExpandFloat;
} else if (VT.getVectorNumElements() == 1) {
/// indicates which operands are the expanded version of the input.
DenseMap<SDOperand, std::pair<SDOperand, SDOperand> > ExpandedIntegers;
- /// PromotedFloats - For floating point nodes converted to integers of
+ /// SoftenedFloats - For floating point nodes converted to integers of
/// the same size, this map indicates the converted value to use.
- DenseMap<SDOperand, SDOperand> PromotedFloats;
+ DenseMap<SDOperand, SDOperand> SoftenedFloats;
/// ExpandedFloats - For float nodes that need to be expanded this map
/// indicates which operands are the expanded version of the input.
void ExpandIntegerResult(SDNode *N, unsigned ResNo);
void ExpandIntRes_ANY_EXTEND (SDNode *N, SDOperand &Lo, SDOperand &Hi);
void ExpandIntRes_AssertZext (SDNode *N, SDOperand &Lo, SDOperand &Hi);
- void ExpandIntRes_BIT_CONVERT (SDNode *N, SDOperand &Lo, SDOperand &Hi);
- void ExpandIntRes_BUILD_PAIR (SDNode *N, SDOperand &Lo, SDOperand &Hi);
void ExpandIntRes_Constant (SDNode *N, SDOperand &Lo, SDOperand &Hi);
void ExpandIntRes_CTLZ (SDNode *N, SDOperand &Lo, SDOperand &Hi);
void ExpandIntRes_CTPOP (SDNode *N, SDOperand &Lo, SDOperand &Hi);
void ExpandIntRes_CTTZ (SDNode *N, SDOperand &Lo, SDOperand &Hi);
- void ExpandIntRes_EXTRACT_VECTOR_ELT(SDNode *N, SDOperand &Lo, SDOperand &Hi);
void ExpandIntRes_LOAD (LoadSDNode *N, SDOperand &Lo, SDOperand &Hi);
- void ExpandIntRes_MERGE_VALUES (SDNode *N, SDOperand &Lo, SDOperand &Hi);
void ExpandIntRes_SIGN_EXTEND (SDNode *N, SDOperand &Lo, SDOperand &Hi);
void ExpandIntRes_SIGN_EXTEND_INREG (SDNode *N, SDOperand &Lo, SDOperand &Hi);
void ExpandIntRes_TRUNCATE (SDNode *N, SDOperand &Lo, SDOperand &Hi);
- void ExpandIntRes_UNDEF (SDNode *N, SDOperand &Lo, SDOperand &Hi);
void ExpandIntRes_ZERO_EXTEND (SDNode *N, SDOperand &Lo, SDOperand &Hi);
void ExpandIntRes_FP_TO_SINT (SDNode *N, SDOperand &Lo, SDOperand &Hi);
void ExpandIntRes_FP_TO_UINT (SDNode *N, SDOperand &Lo, SDOperand &Hi);
void ExpandIntRes_Logical (SDNode *N, SDOperand &Lo, SDOperand &Hi);
- void ExpandIntRes_BSWAP (SDNode *N, SDOperand &Lo, SDOperand &Hi);
void ExpandIntRes_ADDSUB (SDNode *N, SDOperand &Lo, SDOperand &Hi);
void ExpandIntRes_ADDSUBC (SDNode *N, SDOperand &Lo, SDOperand &Hi);
void ExpandIntRes_ADDSUBE (SDNode *N, SDOperand &Lo, SDOperand &Hi);
- void ExpandIntRes_SELECT (SDNode *N, SDOperand &Lo, SDOperand &Hi);
- void ExpandIntRes_SELECT_CC (SDNode *N, SDOperand &Lo, SDOperand &Hi);
+ void ExpandIntRes_BSWAP (SDNode *N, SDOperand &Lo, SDOperand &Hi);
void ExpandIntRes_MUL (SDNode *N, SDOperand &Lo, SDOperand &Hi);
void ExpandIntRes_SDIV (SDNode *N, SDOperand &Lo, SDOperand &Hi);
void ExpandIntRes_SREM (SDNode *N, SDOperand &Lo, SDOperand &Hi);
SDOperand ExpandIntOp_BR_CC(SDNode *N);
SDOperand ExpandIntOp_BUILD_VECTOR(SDNode *N);
SDOperand ExpandIntOp_EXTRACT_ELEMENT(SDNode *N);
+ SDOperand ExpandIntOp_SELECT_CC(SDNode *N);
SDOperand ExpandIntOp_SETCC(SDNode *N);
SDOperand ExpandIntOp_SINT_TO_FP(SDOperand Source, MVT DestTy);
SDOperand ExpandIntOp_STORE(StoreSDNode *N, unsigned OpNo);
SDOperand ExpandIntOp_TRUNCATE(SDNode *N);
SDOperand ExpandIntOp_UINT_TO_FP(SDOperand Source, MVT DestTy);
- void ExpandSetCCOperands(SDOperand &NewLHS, SDOperand &NewRHS,
- ISD::CondCode &CCCode);
+ void IntegerExpandSetCCOperands(SDOperand &NewLHS, SDOperand &NewRHS,
+ ISD::CondCode &CCCode);
//===--------------------------------------------------------------------===//
// Float to Integer Conversion Support: LegalizeFloatTypes.cpp
//===--------------------------------------------------------------------===//
- SDOperand GetPromotedFloat(SDOperand Op) {
- SDOperand &PromotedOp = PromotedFloats[Op];
- RemapNode(PromotedOp);
- assert(PromotedOp.Val && "Operand wasn't converted to integer?");
- return PromotedOp;
+ SDOperand GetSoftenedFloat(SDOperand Op) {
+ SDOperand &SoftenedOp = SoftenedFloats[Op];
+ RemapNode(SoftenedOp);
+ assert(SoftenedOp.Val && "Operand wasn't converted to integer?");
+ return SoftenedOp;
}
- void SetPromotedFloat(SDOperand Op, SDOperand Result);
+ void SetSoftenedFloat(SDOperand Op, SDOperand Result);
// Result Float to Integer Conversion.
- void PromoteFloatResult(SDNode *N, unsigned OpNo);
- SDOperand PromoteFloatRes_BIT_CONVERT(SDNode *N);
- SDOperand PromoteFloatRes_BUILD_PAIR(SDNode *N);
- SDOperand PromoteFloatRes_ConstantFP(ConstantFPSDNode *N);
- SDOperand PromoteFloatRes_FADD(SDNode *N);
- SDOperand PromoteFloatRes_FCOPYSIGN(SDNode *N);
- SDOperand PromoteFloatRes_FMUL(SDNode *N);
- SDOperand PromoteFloatRes_FSUB(SDNode *N);
- SDOperand PromoteFloatRes_LOAD(SDNode *N);
- SDOperand PromoteFloatRes_XINT_TO_FP(SDNode *N);
+ void SoftenFloatResult(SDNode *N, unsigned OpNo);
+ SDOperand SoftenFloatRes_BIT_CONVERT(SDNode *N);
+ SDOperand SoftenFloatRes_BUILD_PAIR(SDNode *N);
+ SDOperand SoftenFloatRes_ConstantFP(ConstantFPSDNode *N);
+ SDOperand SoftenFloatRes_FADD(SDNode *N);
+ SDOperand SoftenFloatRes_FCOPYSIGN(SDNode *N);
+ SDOperand SoftenFloatRes_FMUL(SDNode *N);
+ SDOperand SoftenFloatRes_FSUB(SDNode *N);
+ SDOperand SoftenFloatRes_LOAD(SDNode *N);
+ SDOperand SoftenFloatRes_XINT_TO_FP(SDNode *N);
// Operand Float to Integer Conversion.
- bool PromoteFloatOperand(SDNode *N, unsigned OpNo);
- SDOperand PromoteFloatOp_BIT_CONVERT(SDNode *N);
+ bool SoftenFloatOperand(SDNode *N, unsigned OpNo);
+ SDOperand SoftenFloatOp_BIT_CONVERT(SDNode *N);
+ SDOperand SoftenFloatOp_BR_CC(SDNode *N);
+ SDOperand SoftenFloatOp_SELECT_CC(SDNode *N);
+ SDOperand SoftenFloatOp_SETCC(SDNode *N);
+
+ void SoftenSetCCOperands(SDOperand &NewLHS, SDOperand &NewRHS,
+ ISD::CondCode &CCCode);
//===--------------------------------------------------------------------===//
// Float Expansion Support: LegalizeFloatTypes.cpp
// Float Result Expansion.
void ExpandFloatResult(SDNode *N, unsigned ResNo);
+ void ExpandFloatRes_ConstantFP(SDNode *N, SDOperand &Lo, SDOperand &Hi);
+ void ExpandFloatRes_FADD (SDNode *N, SDOperand &Lo, SDOperand &Hi);
+ void ExpandFloatRes_FDIV (SDNode *N, SDOperand &Lo, SDOperand &Hi);
+ void ExpandFloatRes_FMUL (SDNode *N, SDOperand &Lo, SDOperand &Hi);
+ void ExpandFloatRes_FSUB (SDNode *N, SDOperand &Lo, SDOperand &Hi);
+ void ExpandFloatRes_LOAD (SDNode *N, SDOperand &Lo, SDOperand &Hi);
+ void ExpandFloatRes_XINT_TO_FP(SDNode *N, SDOperand &Lo, SDOperand &Hi);
// Float Operand Expansion.
bool ExpandFloatOperand(SDNode *N, unsigned OperandNo);
+ SDOperand ExpandFloatOp_BR_CC(SDNode *N);
+ SDOperand ExpandFloatOp_FP_ROUND(SDNode *N);
+ SDOperand ExpandFloatOp_FP_TO_SINT(SDNode *N);
+ SDOperand ExpandFloatOp_FP_TO_UINT(SDNode *N);
+ SDOperand ExpandFloatOp_SELECT_CC(SDNode *N);
+ SDOperand ExpandFloatOp_SETCC(SDNode *N);
+ SDOperand ExpandFloatOp_STORE(SDNode *N, unsigned OpNo);
+
+ void FloatExpandSetCCOperands(SDOperand &NewLHS, SDOperand &NewRHS,
+ ISD::CondCode &CCCode);
//===--------------------------------------------------------------------===//
// Scalarization Support: LegalizeVectorTypes.cpp
// Vector Result Scalarization: <1 x ty> -> ty.
void ScalarizeResult(SDNode *N, unsigned OpNo);
- SDOperand ScalarizeRes_BinOp(SDNode *N);
- SDOperand ScalarizeRes_UnaryOp(SDNode *N);
+ SDOperand ScalarizeVecRes_BinOp(SDNode *N);
+ SDOperand ScalarizeVecRes_UnaryOp(SDNode *N);
- SDOperand ScalarizeRes_BIT_CONVERT(SDNode *N);
- SDOperand ScalarizeRes_FPOWI(SDNode *N);
- SDOperand ScalarizeRes_INSERT_VECTOR_ELT(SDNode *N);
- SDOperand ScalarizeRes_LOAD(LoadSDNode *N);
- SDOperand ScalarizeRes_SELECT(SDNode *N);
- SDOperand ScalarizeRes_UNDEF(SDNode *N);
- SDOperand ScalarizeRes_VECTOR_SHUFFLE(SDNode *N);
+ SDOperand ScalarizeVecRes_BIT_CONVERT(SDNode *N);
+ SDOperand ScalarizeVecRes_FPOWI(SDNode *N);
+ SDOperand ScalarizeVecRes_INSERT_VECTOR_ELT(SDNode *N);
+ SDOperand ScalarizeVecRes_LOAD(LoadSDNode *N);
+ SDOperand ScalarizeVecRes_SELECT(SDNode *N);
+ SDOperand ScalarizeVecRes_UNDEF(SDNode *N);
+ SDOperand ScalarizeVecRes_VECTOR_SHUFFLE(SDNode *N);
// Vector Operand Scalarization: <1 x ty> -> ty.
bool ScalarizeOperand(SDNode *N, unsigned OpNo);
- SDOperand ScalarizeOp_BIT_CONVERT(SDNode *N);
- SDOperand ScalarizeOp_EXTRACT_VECTOR_ELT(SDNode *N);
- SDOperand ScalarizeOp_STORE(StoreSDNode *N, unsigned OpNo);
+ SDOperand ScalarizeVecOp_BIT_CONVERT(SDNode *N);
+ SDOperand ScalarizeVecOp_EXTRACT_VECTOR_ELT(SDNode *N);
+ SDOperand ScalarizeVecOp_STORE(StoreSDNode *N, unsigned OpNo);
//===--------------------------------------------------------------------===//
// Vector Splitting Support: LegalizeVectorTypes.cpp
// Vector Result Splitting: <128 x ty> -> 2 x <64 x ty>.
void SplitResult(SDNode *N, unsigned OpNo);
- void SplitRes_UNDEF(SDNode *N, SDOperand &Lo, SDOperand &Hi);
- void SplitRes_LOAD(LoadSDNode *N, SDOperand &Lo, SDOperand &Hi);
- void SplitRes_BUILD_PAIR(SDNode *N, SDOperand &Lo, SDOperand &Hi);
- void SplitRes_INSERT_VECTOR_ELT(SDNode *N, SDOperand &Lo, SDOperand &Hi);
- void SplitRes_VECTOR_SHUFFLE(SDNode *N, SDOperand &Lo, SDOperand &Hi);
+ void SplitVecRes_UNDEF(SDNode *N, SDOperand &Lo, SDOperand &Hi);
+ void SplitVecRes_LOAD(LoadSDNode *N, SDOperand &Lo, SDOperand &Hi);
+ void SplitVecRes_BUILD_PAIR(SDNode *N, SDOperand &Lo, SDOperand &Hi);
+ void SplitVecRes_INSERT_VECTOR_ELT(SDNode *N, SDOperand &Lo, SDOperand &Hi);
+ void SplitVecRes_VECTOR_SHUFFLE(SDNode *N, SDOperand &Lo, SDOperand &Hi);
- void SplitRes_BUILD_VECTOR(SDNode *N, SDOperand &Lo, SDOperand &Hi);
- void SplitRes_CONCAT_VECTORS(SDNode *N, SDOperand &Lo, SDOperand &Hi);
- void SplitRes_BIT_CONVERT(SDNode *N, SDOperand &Lo, SDOperand &Hi);
- void SplitRes_UnOp(SDNode *N, SDOperand &Lo, SDOperand &Hi);
- void SplitRes_BinOp(SDNode *N, SDOperand &Lo, SDOperand &Hi);
- void SplitRes_FPOWI(SDNode *N, SDOperand &Lo, SDOperand &Hi);
- void SplitRes_SELECT(SDNode *N, SDOperand &Lo, SDOperand &Hi);
+ void SplitVecRes_BUILD_VECTOR(SDNode *N, SDOperand &Lo, SDOperand &Hi);
+ void SplitVecRes_CONCAT_VECTORS(SDNode *N, SDOperand &Lo, SDOperand &Hi);
+ void SplitVecRes_BIT_CONVERT(SDNode *N, SDOperand &Lo, SDOperand &Hi);
+ void SplitVecRes_UnOp(SDNode *N, SDOperand &Lo, SDOperand &Hi);
+ void SplitVecRes_BinOp(SDNode *N, SDOperand &Lo, SDOperand &Hi);
+ void SplitVecRes_FPOWI(SDNode *N, SDOperand &Lo, SDOperand &Hi);
+ void SplitVecRes_SELECT(SDNode *N, SDOperand &Lo, SDOperand &Hi);
// Vector Operand Splitting: <128 x ty> -> 2 x <64 x ty>.
bool SplitOperand(SDNode *N, unsigned OpNo);
- SDOperand SplitOp_BIT_CONVERT(SDNode *N);
- SDOperand SplitOp_EXTRACT_SUBVECTOR(SDNode *N);
- SDOperand SplitOp_EXTRACT_VECTOR_ELT(SDNode *N);
- SDOperand SplitOp_RET(SDNode *N, unsigned OpNo);
- SDOperand SplitOp_STORE(StoreSDNode *N, unsigned OpNo);
- SDOperand SplitOp_VECTOR_SHUFFLE(SDNode *N, unsigned OpNo);
+ SDOperand SplitVecOp_BIT_CONVERT(SDNode *N);
+ SDOperand SplitVecOp_EXTRACT_SUBVECTOR(SDNode *N);
+ SDOperand SplitVecOp_EXTRACT_VECTOR_ELT(SDNode *N);
+ SDOperand SplitVecOp_RET(SDNode *N, unsigned OpNo);
+ SDOperand SplitVecOp_STORE(StoreSDNode *N, unsigned OpNo);
+ SDOperand SplitVecOp_VECTOR_SHUFFLE(SDNode *N, unsigned OpNo);
+
+ //===--------------------------------------------------------------------===//
+ // Generic Splitting: LegalizeTypesGeneric.cpp
+ //===--------------------------------------------------------------------===//
+
+ // Legalization methods which only use that the illegal type is split into two
+ // not necessarily identical types. As such they can be used for splitting
+ // vectors and expanding integers and floats.
+
+ void GetSplitOp(SDOperand Op, SDOperand &Lo, SDOperand &Hi) {
+ if (Op.getValueType().isVector())
+ GetSplitVector(Op, Lo, Hi);
+ else if (Op.getValueType().isInteger())
+ GetExpandedInteger(Op, Lo, Hi);
+ else
+ GetExpandedFloat(Op, Lo, Hi);
+ }
+
+ /// GetSplitDestVTs - Compute the VTs needed for the low/hi parts of a type
+ /// which is split (or expanded) into two not necessarily identical pieces.
+ void GetSplitDestVTs(MVT InVT, MVT &LoVT, MVT &HiVT);
+
+ // Generic Result Splitting.
+ void SplitRes_MERGE_VALUES(SDNode *N, SDOperand &Lo, SDOperand &Hi);
+ void SplitRes_SELECT (SDNode *N, SDOperand &Lo, SDOperand &Hi);
+ void SplitRes_SELECT_CC (SDNode *N, SDOperand &Lo, SDOperand &Hi);
+ void SplitRes_UNDEF (SDNode *N, SDOperand &Lo, SDOperand &Hi);
+
+ //===--------------------------------------------------------------------===//
+ // Generic Expansion: LegalizeTypesGeneric.cpp
+ //===--------------------------------------------------------------------===//
+
+ // Legalization methods which only use that the illegal type is split into two
+ // identical types of half the size, and that the Lo/Hi part is stored first
+ // in memory on little/big-endian machines, followed by the Hi/Lo part. As
+ // such they can be used for expanding integers and floats.
+
+ void GetExpandedOp(SDOperand Op, SDOperand &Lo, SDOperand &Hi) {
+ if (Op.getValueType().isInteger())
+ GetExpandedInteger(Op, Lo, Hi);
+ else
+ GetExpandedFloat(Op, Lo, Hi);
+ }
+
+ // Generic Result Expansion.
+ void ExpandRes_BIT_CONVERT (SDNode *N, SDOperand &Lo, SDOperand &Hi);
+ void ExpandRes_BUILD_PAIR (SDNode *N, SDOperand &Lo, SDOperand &Hi);
+ void ExpandRes_EXTRACT_ELEMENT (SDNode *N, SDOperand &Lo, SDOperand &Hi);
+ void ExpandRes_EXTRACT_VECTOR_ELT(SDNode *N, SDOperand &Lo, SDOperand &Hi);
+ void ExpandRes_NormalLoad (SDNode *N, SDOperand &Lo, SDOperand &Hi);
+
+ // Generic Operand Expansion.
+ SDOperand ExpandOp_BIT_CONVERT (SDNode *N);
+ SDOperand ExpandOp_BUILD_VECTOR (SDNode *N);
+ SDOperand ExpandOp_EXTRACT_ELEMENT(SDNode *N);
+ SDOperand ExpandOp_NormalStore (SDNode *N, unsigned OpNo);
+
};
} // end namespace llvm.
projects / oota-llvm.git / blobdiff