X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FCodeGen%2FSelectionDAG%2FLegalizeTypes.h;h=48d4b391fb5a5d80f7d689e975cb093bf73e2d09;hb=e326332acd5fefb9854118603b4d07d4e44b64c5;hp=0ecc70f4afff8317c88c1ce45704a91d84a6cdd2;hpb=eeaad40246e45ec48c85acac4ab57e82457abf19;p=oota-llvm.git diff --git a/lib/CodeGen/SelectionDAG/LegalizeTypes.h b/lib/CodeGen/SelectionDAG/LegalizeTypes.h index 0ecc70f4aff..48d4b391fb5 100644 --- a/lib/CodeGen/SelectionDAG/LegalizeTypes.h +++ b/lib/CodeGen/SelectionDAG/LegalizeTypes.h @@ -2,8 +2,8 @@ // // The LLVM Compiler Infrastructure // -// This file was developed by Chris Lattner and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // @@ -40,7 +40,7 @@ namespace llvm { class VISIBILITY_HIDDEN DAGTypeLegalizer { TargetLowering &TLI; SelectionDAG &DAG; - +public: // NodeIDFlags - This pass uses the NodeID on the SDNodes to hold information // about the state of the node. The enum has all the values. enum NodeIDFlags { @@ -57,54 +57,80 @@ class VISIBILITY_HIDDEN DAGTypeLegalizer { // 1+ - This is a node which has this many unlegalized operands. }; - +private: enum LegalizeAction { Legal, // The target natively supports this type. Promote, // This type should be executed in a larger type. - Expand // This type should be split into two types of half the size. + Expand, // This type should be split into two types of half the size. + FloatToInt, // Convert a floating point type to an integer of the same size. + Scalarize, // Replace this one-element vector type with its element type. + Split // This vector type should be split into smaller vectors. }; - + /// ValueTypeActions - This is a bitvector that contains two bits for each /// simple value type, where the two bits correspond to the LegalizeAction - /// enum. This can be queried with "getTypeAction(VT)". + /// enum from TargetLowering. This can be queried with "getTypeAction(VT)". TargetLowering::ValueTypeActionImpl ValueTypeActions; /// getTypeAction - Return how we should legalize values of this type, either - /// it is already legal or we need to expand it into multiple registers of - /// smaller integer type, or we need to promote it to a larger type. + /// it is already legal, or we need to promote it to a larger integer type, or + /// we need to expand it into multiple registers of a smaller integer type, or + /// we need to scalarize a one-element vector type into the element type, or + /// we need to split a vector type into smaller vector types. LegalizeAction getTypeAction(MVT::ValueType VT) const { - return (LegalizeAction)ValueTypeActions.getTypeAction(VT); + switch (ValueTypeActions.getTypeAction(VT)) { + default: + assert(false && "Unknown legalize action!"); + case TargetLowering::Legal: + return Legal; + case TargetLowering::Promote: + return Promote; + case TargetLowering::Expand: + // Expand can mean + // 1) split scalar in half, 2) convert a float to an integer, + // 3) scalarize a single-element vector, 4) split a vector in two. + if (!MVT::isVector(VT)) { + if (MVT::getSizeInBits(VT) == + MVT::getSizeInBits(TLI.getTypeToTransformTo(VT))) + return FloatToInt; + else + return Expand; + } else if (MVT::getVectorNumElements(VT) == 1) { + return Scalarize; + } else { + return Split; + } + } } - + /// isTypeLegal - Return true if this type is legal on this target. - /// bool isTypeLegal(MVT::ValueType VT) const { - return getTypeAction(VT) == Legal; + return ValueTypeActions.getTypeAction(VT) == TargetLowering::Legal; } - - SDOperand getIntPtrConstant(uint64_t Val) { - return DAG.getConstant(Val, TLI.getPointerTy()); - } - + /// PromotedNodes - For nodes that are below legal width, this map indicates /// what promoted value to use. - DenseMap PromotedNodes; + DenseMap PromotedNodes; /// ExpandedNodes - For nodes that need to be expanded this map indicates /// which operands are the expanded version of the input. - DenseMap > ExpandedNodes; + DenseMap > ExpandedNodes; + + /// FloatToIntedNodes - For floating point nodes converted to integers of + /// the same size, this map indicates the converted value to use. + DenseMap FloatToIntedNodes; /// ScalarizedNodes - For nodes that are <1 x ty>, this map indicates the /// scalar value of type 'ty' to use. - DenseMap ScalarizedNodes; + DenseMap ScalarizedNodes; /// SplitNodes - For nodes that need to be split this map indicates /// which operands are the expanded version of the input. - DenseMap > SplitNodes; + DenseMap > SplitNodes; /// ReplacedNodes - For nodes that have been replaced with another, /// indicates the replacement node to use. - DenseMap ReplacedNodes; + DenseMap ReplacedNodes; /// Worklist - This defines a worklist of nodes to process. In order to be /// pushed onto this worklist, all operands of a node must have already been @@ -121,18 +147,29 @@ public: void run(); + /// ReanalyzeNode - Recompute the NodeID and correct processed operands + /// for the specified node, adding it to the worklist if ready. + void ReanalyzeNode(SDNode *N) { + N->setNodeId(NewNode); + AnalyzeNewNode(N); + } + private: - void MarkNewNodes(SDNode *N); - + void AnalyzeNewNode(SDNode *&N); + void ReplaceValueWith(SDOperand From, SDOperand To); void ReplaceNodeWith(SDNode *From, SDNode *To); void RemapNode(SDOperand &N); // Common routines. + SDOperand BitConvertToInteger(SDOperand Op); SDOperand CreateStackStoreLoad(SDOperand Op, MVT::ValueType DestVT); SDOperand HandleMemIntrinsic(SDNode *N); - void SplitOp(SDOperand Op, SDOperand &Lo, SDOperand &Hi); + SDOperand JoinIntegers(SDOperand Lo, SDOperand Hi); + void SplitInteger(SDOperand Op, SDOperand &Lo, SDOperand &Hi); + void SplitInteger(SDOperand Op, MVT::ValueType LoVT, MVT::ValueType HiVT, + SDOperand &Lo, SDOperand &Hi); //===--------------------------------------------------------------------===// // Promotion Support: LegalizeTypesPromote.cpp @@ -156,38 +193,49 @@ private: // Result Promotion. void PromoteResult(SDNode *N, unsigned ResNo); - SDOperand PromoteResult_UNDEF(SDNode *N); + SDOperand PromoteResult_BIT_CONVERT(SDNode *N); + SDOperand PromoteResult_BUILD_PAIR(SDNode *N); SDOperand PromoteResult_Constant(SDNode *N); - SDOperand PromoteResult_TRUNCATE(SDNode *N); - SDOperand PromoteResult_INT_EXTEND(SDNode *N); + SDOperand PromoteResult_CTLZ(SDNode *N); + SDOperand PromoteResult_CTPOP(SDNode *N); + SDOperand PromoteResult_CTTZ(SDNode *N); + SDOperand PromoteResult_EXTRACT_VECTOR_ELT(SDNode *N); SDOperand PromoteResult_FP_ROUND(SDNode *N); SDOperand PromoteResult_FP_TO_XINT(SDNode *N); - SDOperand PromoteResult_SETCC(SDNode *N); + SDOperand PromoteResult_INT_EXTEND(SDNode *N); SDOperand PromoteResult_LOAD(LoadSDNode *N); - SDOperand PromoteResult_SimpleIntBinOp(SDNode *N); SDOperand PromoteResult_SDIV(SDNode *N); - SDOperand PromoteResult_UDIV(SDNode *N); + SDOperand PromoteResult_SELECT (SDNode *N); + SDOperand PromoteResult_SELECT_CC(SDNode *N); + SDOperand PromoteResult_SETCC(SDNode *N); SDOperand PromoteResult_SHL(SDNode *N); + SDOperand PromoteResult_SimpleIntBinOp(SDNode *N); SDOperand PromoteResult_SRA(SDNode *N); SDOperand PromoteResult_SRL(SDNode *N); - SDOperand PromoteResult_SELECT (SDNode *N); - SDOperand PromoteResult_SELECT_CC(SDNode *N); - + SDOperand PromoteResult_TRUNCATE(SDNode *N); + SDOperand PromoteResult_UDIV(SDNode *N); + SDOperand PromoteResult_UNDEF(SDNode *N); + // Operand Promotion. bool PromoteOperand(SDNode *N, unsigned OperandNo); SDOperand PromoteOperand_ANY_EXTEND(SDNode *N); - SDOperand PromoteOperand_ZERO_EXTEND(SDNode *N); - SDOperand PromoteOperand_SIGN_EXTEND(SDNode *N); - SDOperand PromoteOperand_TRUNCATE(SDNode *N); + SDOperand PromoteOperand_BUILD_PAIR(SDNode *N); + SDOperand PromoteOperand_BR_CC(SDNode *N, unsigned OpNo); + SDOperand PromoteOperand_BRCOND(SDNode *N, unsigned OpNo); + SDOperand PromoteOperand_BUILD_VECTOR(SDNode *N); SDOperand PromoteOperand_FP_EXTEND(SDNode *N); SDOperand PromoteOperand_FP_ROUND(SDNode *N); SDOperand PromoteOperand_INT_TO_FP(SDNode *N); + SDOperand PromoteOperand_INSERT_VECTOR_ELT(SDNode *N, unsigned OpNo); + SDOperand PromoteOperand_MEMBARRIER(SDNode *N); + SDOperand PromoteOperand_RET(SDNode *N, unsigned OpNo); SDOperand PromoteOperand_SELECT(SDNode *N, unsigned OpNo); - SDOperand PromoteOperand_BRCOND(SDNode *N, unsigned OpNo); - SDOperand PromoteOperand_BR_CC(SDNode *N, unsigned OpNo); SDOperand PromoteOperand_SETCC(SDNode *N, unsigned OpNo); + SDOperand PromoteOperand_SIGN_EXTEND(SDNode *N); SDOperand PromoteOperand_STORE(StoreSDNode *N, unsigned OpNo); - + SDOperand PromoteOperand_TRUNCATE(SDNode *N); + SDOperand PromoteOperand_ZERO_EXTEND(SDNode *N); + void PromoteSetCCOperands(SDOperand &LHS,SDOperand &RHS, ISD::CondCode Code); //===--------------------------------------------------------------------===// @@ -199,16 +247,22 @@ private: // Result Expansion. void ExpandResult(SDNode *N, unsigned ResNo); - void ExpandResult_UNDEF (SDNode *N, SDOperand &Lo, SDOperand &Hi); - void ExpandResult_Constant (SDNode *N, SDOperand &Lo, SDOperand &Hi); + void ExpandResult_ANY_EXTEND (SDNode *N, SDOperand &Lo, SDOperand &Hi); + void ExpandResult_AssertZext (SDNode *N, SDOperand &Lo, SDOperand &Hi); + void ExpandResult_BIT_CONVERT(SDNode *N, SDOperand &Lo, SDOperand &Hi); void ExpandResult_BUILD_PAIR (SDNode *N, SDOperand &Lo, SDOperand &Hi); + void ExpandResult_Constant (SDNode *N, SDOperand &Lo, SDOperand &Hi); + void ExpandResult_CTLZ (SDNode *N, SDOperand &Lo, SDOperand &Hi); + void ExpandResult_CTPOP (SDNode *N, SDOperand &Lo, SDOperand &Hi); + void ExpandResult_CTTZ (SDNode *N, SDOperand &Lo, SDOperand &Hi); + void ExpandResult_EXTRACT_VECTOR_ELT(SDNode *N, SDOperand &Lo, SDOperand &Hi); + void ExpandResult_LOAD (LoadSDNode *N, SDOperand &Lo, SDOperand &Hi); void ExpandResult_MERGE_VALUES(SDNode *N, SDOperand &Lo, SDOperand &Hi); - void ExpandResult_ANY_EXTEND (SDNode *N, SDOperand &Lo, SDOperand &Hi); - void ExpandResult_ZERO_EXTEND(SDNode *N, SDOperand &Lo, SDOperand &Hi); void ExpandResult_SIGN_EXTEND(SDNode *N, SDOperand &Lo, SDOperand &Hi); - void ExpandResult_BIT_CONVERT(SDNode *N, SDOperand &Lo, SDOperand &Hi); void ExpandResult_SIGN_EXTEND_INREG(SDNode *N, SDOperand &Lo, SDOperand &Hi); - void ExpandResult_LOAD (LoadSDNode *N, SDOperand &Lo, SDOperand &Hi); + void ExpandResult_TRUNCATE (SDNode *N, SDOperand &Lo, SDOperand &Hi); + void ExpandResult_UNDEF (SDNode *N, SDOperand &Lo, SDOperand &Hi); + void ExpandResult_ZERO_EXTEND(SDNode *N, SDOperand &Lo, SDOperand &Hi); void ExpandResult_Logical (SDNode *N, SDOperand &Lo, SDOperand &Hi); void ExpandResult_BSWAP (SDNode *N, SDOperand &Lo, SDOperand &Hi); @@ -226,17 +280,41 @@ private: // Operand Expansion. bool ExpandOperand(SDNode *N, unsigned OperandNo); - SDOperand ExpandOperand_TRUNCATE(SDNode *N); SDOperand ExpandOperand_BIT_CONVERT(SDNode *N); - SDOperand ExpandOperand_UINT_TO_FP(SDOperand Source, MVT::ValueType DestTy); - SDOperand ExpandOperand_SINT_TO_FP(SDOperand Source, MVT::ValueType DestTy); + SDOperand ExpandOperand_BR_CC(SDNode *N); + SDOperand ExpandOperand_BUILD_VECTOR(SDNode *N); SDOperand ExpandOperand_EXTRACT_ELEMENT(SDNode *N); SDOperand ExpandOperand_SETCC(SDNode *N); + SDOperand ExpandOperand_SINT_TO_FP(SDOperand Source, MVT::ValueType DestTy); SDOperand ExpandOperand_STORE(StoreSDNode *N, unsigned OpNo); - + SDOperand ExpandOperand_TRUNCATE(SDNode *N); + SDOperand ExpandOperand_UINT_TO_FP(SDOperand Source, MVT::ValueType DestTy); + void ExpandSetCCOperands(SDOperand &NewLHS, SDOperand &NewRHS, ISD::CondCode &CCCode); + //===--------------------------------------------------------------------===// + // Float to Integer Conversion Support: LegalizeTypesFloatToInt.cpp + //===--------------------------------------------------------------------===// + + SDOperand GetIntegerOp(SDOperand Op) { + SDOperand &IntegerOp = FloatToIntedNodes[Op]; + RemapNode(IntegerOp); + assert(IntegerOp.Val && "Operand wasn't converted to integer?"); + return IntegerOp; + } + void SetIntegerOp(SDOperand Op, SDOperand Result); + + // Result Float to Integer Conversion. + void FloatToIntResult(SDNode *N, unsigned OpNo); + SDOperand FloatToIntRes_BIT_CONVERT(SDNode *N); + SDOperand FloatToIntRes_BUILD_PAIR(SDNode *N); + SDOperand FloatToIntRes_FCOPYSIGN(SDNode *N); + + // Operand Float to Integer Conversion. + bool FloatToIntOperand(SDNode *N, unsigned OpNo); + SDOperand FloatToIntOp_BIT_CONVERT(SDNode *N); + //===--------------------------------------------------------------------===// // Scalarization Support: LegalizeTypesScalarize.cpp //===--------------------------------------------------------------------===// @@ -251,18 +329,22 @@ private: // Result Vector Scalarization: <1 x ty> -> ty. void ScalarizeResult(SDNode *N, unsigned OpNo); - SDOperand ScalarizeRes_UNDEF(SDNode *N); - SDOperand ScalarizeRes_LOAD(LoadSDNode *N); SDOperand ScalarizeRes_BinOp(SDNode *N); SDOperand ScalarizeRes_UnaryOp(SDNode *N); - SDOperand ScalarizeRes_FPOWI(SDNode *N); - SDOperand ScalarizeRes_VECTOR_SHUFFLE(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); + // Operand Vector Scalarization: <1 x ty> -> ty. bool ScalarizeOperand(SDNode *N, unsigned OpNo); - SDOperand ScalarizeOp_EXTRACT_VECTOR_ELT(SDNode *N, unsigned OpNo); + SDOperand ScalarizeOp_BIT_CONVERT(SDNode *N); + SDOperand ScalarizeOp_EXTRACT_VECTOR_ELT(SDNode *N); + SDOperand ScalarizeOp_STORE(StoreSDNode *N, unsigned OpNo); //===--------------------------------------------------------------------===// // Vector Splitting Support: LegalizeTypesSplit.cpp @@ -288,10 +370,15 @@ private: void SplitRes_FPOWI(SDNode *N, SDOperand &Lo, SDOperand &Hi); void SplitRes_SELECT(SDNode *N, SDOperand &Lo, SDOperand &Hi); - // Operand Vector Scalarization: <128 x ty> -> 2 x <64 x ty>. + // Operand Vector Splitting: <128 x ty> -> 2 x <64 x ty>. bool SplitOperand(SDNode *N, unsigned OpNo); - - SDOperand SplitOperand_STORE(StoreSDNode *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); }; } // end namespace llvm.