1263508Sdim//===-- LegalizeTypes.h - DAG Type Legalizer class definition ---*- C++ -*-===// 2193323Sed// 3193323Sed// The LLVM Compiler Infrastructure 4193323Sed// 5193323Sed// This file is distributed under the University of Illinois Open Source 6193323Sed// License. See LICENSE.TXT for details. 7193323Sed// 8193323Sed//===----------------------------------------------------------------------===// 9193323Sed// 10193323Sed// This file defines the DAGTypeLegalizer class. This is a private interface 11193323Sed// shared between the code that implements the SelectionDAG::LegalizeTypes 12193323Sed// method. 13193323Sed// 14193323Sed//===----------------------------------------------------------------------===// 15193323Sed 16193323Sed#ifndef SELECTIONDAG_LEGALIZETYPES_H 17193323Sed#define SELECTIONDAG_LEGALIZETYPES_H 18193323Sed 19193323Sed#define DEBUG_TYPE "legalize-types" 20193323Sed#include "llvm/ADT/DenseMap.h" 21193323Sed#include "llvm/ADT/DenseSet.h" 22249423Sdim#include "llvm/CodeGen/SelectionDAG.h" 23193323Sed#include "llvm/Support/Compiler.h" 24193323Sed#include "llvm/Support/Debug.h" 25249423Sdim#include "llvm/Target/TargetLowering.h" 26193323Sed 27193323Sednamespace llvm { 28193323Sed 29193323Sed//===----------------------------------------------------------------------===// 30193323Sed/// DAGTypeLegalizer - This takes an arbitrary SelectionDAG as input and hacks 31193323Sed/// on it until only value types the target machine can handle are left. This 32193323Sed/// involves promoting small sizes to large sizes or splitting up large values 33193323Sed/// into small values. 34193323Sed/// 35208599Srdivackyclass LLVM_LIBRARY_VISIBILITY DAGTypeLegalizer { 36207618Srdivacky const TargetLowering &TLI; 37193323Sed SelectionDAG &DAG; 38193323Sedpublic: 39193323Sed // NodeIdFlags - This pass uses the NodeId on the SDNodes to hold information 40193323Sed // about the state of the node. The enum has all the values. 41193323Sed enum NodeIdFlags { 42193323Sed /// ReadyToProcess - All operands have been processed, so this node is ready 43193323Sed /// to be handled. 44193323Sed ReadyToProcess = 0, 45193323Sed 46193323Sed /// NewNode - This is a new node, not before seen, that was created in the 47193323Sed /// process of legalizing some other node. 48193323Sed NewNode = -1, 49193323Sed 50193323Sed /// Unanalyzed - This node's ID needs to be set to the number of its 51193323Sed /// unprocessed operands. 52193323Sed Unanalyzed = -2, 53193323Sed 54193323Sed /// Processed - This is a node that has already been processed. 55193323Sed Processed = -3 56193323Sed 57193323Sed // 1+ - This is a node which has this many unprocessed operands. 58193323Sed }; 59193323Sedprivate: 60193323Sed 61193323Sed /// ValueTypeActions - This is a bitvector that contains two bits for each 62193323Sed /// simple value type, where the two bits correspond to the LegalizeAction 63193323Sed /// enum from TargetLowering. This can be queried with "getTypeAction(VT)". 64193323Sed TargetLowering::ValueTypeActionImpl ValueTypeActions; 65193323Sed 66193323Sed /// getTypeAction - Return how we should legalize values of this type. 67223017Sdim TargetLowering::LegalizeTypeAction getTypeAction(EVT VT) const { 68223017Sdim return TLI.getTypeAction(*DAG.getContext(), VT); 69193323Sed } 70193323Sed 71193323Sed /// isTypeLegal - Return true if this type is legal on this target. 72198090Srdivacky bool isTypeLegal(EVT VT) const { 73223017Sdim return TLI.getTypeAction(*DAG.getContext(), VT) == TargetLowering::TypeLegal; 74193323Sed } 75193323Sed 76263508Sdim EVT getSetCCResultType(EVT VT) const { 77263508Sdim return TLI.getSetCCResultType(*DAG.getContext(), VT); 78263508Sdim } 79263508Sdim 80193323Sed /// IgnoreNodeResults - Pretend all of this node's results are legal. 81193323Sed bool IgnoreNodeResults(SDNode *N) const { 82193323Sed return N->getOpcode() == ISD::TargetConstant; 83193323Sed } 84193323Sed 85193323Sed /// PromotedIntegers - For integer nodes that are below legal width, this map 86193323Sed /// indicates what promoted value to use. 87249423Sdim SmallDenseMap<SDValue, SDValue, 8> PromotedIntegers; 88193323Sed 89193323Sed /// ExpandedIntegers - For integer nodes that need to be expanded this map 90193323Sed /// indicates which operands are the expanded version of the input. 91249423Sdim SmallDenseMap<SDValue, std::pair<SDValue, SDValue>, 8> ExpandedIntegers; 92193323Sed 93193323Sed /// SoftenedFloats - For floating point nodes converted to integers of 94193323Sed /// the same size, this map indicates the converted value to use. 95249423Sdim SmallDenseMap<SDValue, SDValue, 8> SoftenedFloats; 96193323Sed 97193323Sed /// ExpandedFloats - For float nodes that need to be expanded this map 98193323Sed /// indicates which operands are the expanded version of the input. 99249423Sdim SmallDenseMap<SDValue, std::pair<SDValue, SDValue>, 8> ExpandedFloats; 100193323Sed 101193323Sed /// ScalarizedVectors - For nodes that are <1 x ty>, this map indicates the 102193323Sed /// scalar value of type 'ty' to use. 103249423Sdim SmallDenseMap<SDValue, SDValue, 8> ScalarizedVectors; 104193323Sed 105193323Sed /// SplitVectors - For nodes that need to be split this map indicates 106193323Sed /// which operands are the expanded version of the input. 107249423Sdim SmallDenseMap<SDValue, std::pair<SDValue, SDValue>, 8> SplitVectors; 108193323Sed 109193323Sed /// WidenedVectors - For vector nodes that need to be widened, indicates 110193323Sed /// the widened value to use. 111249423Sdim SmallDenseMap<SDValue, SDValue, 8> WidenedVectors; 112193323Sed 113193323Sed /// ReplacedValues - For values that have been replaced with another, 114193323Sed /// indicates the replacement value to use. 115249423Sdim SmallDenseMap<SDValue, SDValue, 8> ReplacedValues; 116193323Sed 117193323Sed /// Worklist - This defines a worklist of nodes to process. In order to be 118193323Sed /// pushed onto this worklist, all operands of a node must have already been 119193323Sed /// processed. 120193323Sed SmallVector<SDNode*, 128> Worklist; 121193323Sed 122193323Sedpublic: 123193323Sed explicit DAGTypeLegalizer(SelectionDAG &dag) 124193323Sed : TLI(dag.getTargetLoweringInfo()), DAG(dag), 125193323Sed ValueTypeActions(TLI.getValueTypeActions()) { 126195098Sed assert(MVT::LAST_VALUETYPE <= MVT::MAX_ALLOWED_VALUETYPE && 127193323Sed "Too many value types for ValueTypeActions to hold!"); 128193323Sed } 129193323Sed 130193323Sed /// run - This is the main entry point for the type legalizer. This does a 131193323Sed /// top-down traversal of the dag, legalizing types as it goes. Returns 132193323Sed /// "true" if it made any changes. 133193323Sed bool run(); 134193323Sed 135193323Sed void NoteDeletion(SDNode *Old, SDNode *New) { 136193323Sed ExpungeNode(Old); 137193323Sed ExpungeNode(New); 138193323Sed for (unsigned i = 0, e = Old->getNumValues(); i != e; ++i) 139193323Sed ReplacedValues[SDValue(Old, i)] = SDValue(New, i); 140193323Sed } 141193323Sed 142239462Sdim SelectionDAG &getDAG() const { return DAG; } 143239462Sdim 144193323Sedprivate: 145193323Sed SDNode *AnalyzeNewNode(SDNode *N); 146193323Sed void AnalyzeNewValue(SDValue &Val); 147193323Sed void ExpungeNode(SDNode *N); 148193323Sed void PerformExpensiveChecks(); 149193323Sed void RemapValue(SDValue &N); 150193323Sed 151193323Sed // Common routines. 152193323Sed SDValue BitConvertToInteger(SDValue Op); 153193323Sed SDValue BitConvertVectorToIntegerVector(SDValue Op); 154198090Srdivacky SDValue CreateStackStoreLoad(SDValue Op, EVT DestVT); 155198090Srdivacky bool CustomLowerNode(SDNode *N, EVT VT, bool LegalizeResult); 156199989Srdivacky bool CustomWidenLowerNode(SDNode *N, EVT VT); 157226633Sdim 158226633Sdim /// DisintegrateMERGE_VALUES - Replace each result of the given MERGE_VALUES 159226633Sdim /// node with the corresponding input operand, except for the result 'ResNo', 160239462Sdim /// for which the corresponding input operand is returned. 161226633Sdim SDValue DisintegrateMERGE_VALUES(SDNode *N, unsigned ResNo); 162226633Sdim 163198090Srdivacky SDValue GetVectorElementPointer(SDValue VecPtr, EVT EltVT, SDValue Index); 164193323Sed SDValue JoinIntegers(SDValue Lo, SDValue Hi); 165193323Sed SDValue LibCallify(RTLIB::Libcall LC, SDNode *N, bool isSigned); 166226633Sdim 167226633Sdim std::pair<SDValue, SDValue> ExpandChainLibCall(RTLIB::Libcall LC, 168226633Sdim SDNode *Node, bool isSigned); 169226633Sdim std::pair<SDValue, SDValue> ExpandAtomic(SDNode *Node); 170218893Sdim 171198090Srdivacky SDValue PromoteTargetBoolean(SDValue Bool, EVT VT); 172193323Sed void ReplaceValueWith(SDValue From, SDValue To); 173193323Sed void SplitInteger(SDValue Op, SDValue &Lo, SDValue &Hi); 174198090Srdivacky void SplitInteger(SDValue Op, EVT LoVT, EVT HiVT, 175193323Sed SDValue &Lo, SDValue &Hi); 176193323Sed 177193323Sed //===--------------------------------------------------------------------===// 178193323Sed // Integer Promotion Support: LegalizeIntegerTypes.cpp 179193323Sed //===--------------------------------------------------------------------===// 180193323Sed 181193323Sed /// GetPromotedInteger - Given a processed operand Op which was promoted to a 182193323Sed /// larger integer type, this returns the promoted value. The low bits of the 183193323Sed /// promoted value corresponding to the original type are exactly equal to Op. 184193323Sed /// The extra bits contain rubbish, so the promoted value may need to be zero- 185193323Sed /// or sign-extended from the original type before it is usable (the helpers 186193323Sed /// SExtPromotedInteger and ZExtPromotedInteger can do this for you). 187193323Sed /// For example, if Op is an i16 and was promoted to an i32, then this method 188193323Sed /// returns an i32, the lower 16 bits of which coincide with Op, and the upper 189193323Sed /// 16 bits of which contain rubbish. 190193323Sed SDValue GetPromotedInteger(SDValue Op) { 191193323Sed SDValue &PromotedOp = PromotedIntegers[Op]; 192193323Sed RemapValue(PromotedOp); 193193323Sed assert(PromotedOp.getNode() && "Operand wasn't promoted?"); 194193323Sed return PromotedOp; 195193323Sed } 196193323Sed void SetPromotedInteger(SDValue Op, SDValue Result); 197193323Sed 198193323Sed /// SExtPromotedInteger - Get a promoted operand and sign extend it to the 199193323Sed /// final size. 200193323Sed SDValue SExtPromotedInteger(SDValue Op) { 201198090Srdivacky EVT OldVT = Op.getValueType(); 202263508Sdim SDLoc dl(Op); 203193323Sed Op = GetPromotedInteger(Op); 204193323Sed return DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, Op.getValueType(), Op, 205193323Sed DAG.getValueType(OldVT)); 206193323Sed } 207193323Sed 208193323Sed /// ZExtPromotedInteger - Get a promoted operand and zero extend it to the 209193323Sed /// final size. 210193323Sed SDValue ZExtPromotedInteger(SDValue Op) { 211198090Srdivacky EVT OldVT = Op.getValueType(); 212263508Sdim SDLoc dl(Op); 213193323Sed Op = GetPromotedInteger(Op); 214224145Sdim return DAG.getZeroExtendInReg(Op, dl, OldVT.getScalarType()); 215193323Sed } 216193323Sed 217193323Sed // Integer Result Promotion. 218193323Sed void PromoteIntegerResult(SDNode *N, unsigned ResNo); 219226633Sdim SDValue PromoteIntRes_MERGE_VALUES(SDNode *N, unsigned ResNo); 220193323Sed SDValue PromoteIntRes_AssertSext(SDNode *N); 221193323Sed SDValue PromoteIntRes_AssertZext(SDNode *N); 222226633Sdim SDValue PromoteIntRes_Atomic0(AtomicSDNode *N); 223193323Sed SDValue PromoteIntRes_Atomic1(AtomicSDNode *N); 224193323Sed SDValue PromoteIntRes_Atomic2(AtomicSDNode *N); 225223017Sdim SDValue PromoteIntRes_EXTRACT_SUBVECTOR(SDNode *N); 226223017Sdim SDValue PromoteIntRes_VECTOR_SHUFFLE(SDNode *N); 227223017Sdim SDValue PromoteIntRes_BUILD_VECTOR(SDNode *N); 228223017Sdim SDValue PromoteIntRes_SCALAR_TO_VECTOR(SDNode *N); 229223017Sdim SDValue PromoteIntRes_INSERT_VECTOR_ELT(SDNode *N); 230226633Sdim SDValue PromoteIntRes_CONCAT_VECTORS(SDNode *N); 231218893Sdim SDValue PromoteIntRes_BITCAST(SDNode *N); 232193323Sed SDValue PromoteIntRes_BSWAP(SDNode *N); 233193323Sed SDValue PromoteIntRes_BUILD_PAIR(SDNode *N); 234193323Sed SDValue PromoteIntRes_Constant(SDNode *N); 235193323Sed SDValue PromoteIntRes_CONVERT_RNDSAT(SDNode *N); 236193323Sed SDValue PromoteIntRes_CTLZ(SDNode *N); 237193323Sed SDValue PromoteIntRes_CTPOP(SDNode *N); 238193323Sed SDValue PromoteIntRes_CTTZ(SDNode *N); 239193323Sed SDValue PromoteIntRes_EXTRACT_VECTOR_ELT(SDNode *N); 240193323Sed SDValue PromoteIntRes_FP_TO_XINT(SDNode *N); 241205218Srdivacky SDValue PromoteIntRes_FP32_TO_FP16(SDNode *N); 242193323Sed SDValue PromoteIntRes_INT_EXTEND(SDNode *N); 243193323Sed SDValue PromoteIntRes_LOAD(LoadSDNode *N); 244193323Sed SDValue PromoteIntRes_Overflow(SDNode *N); 245193323Sed SDValue PromoteIntRes_SADDSUBO(SDNode *N, unsigned ResNo); 246193323Sed SDValue PromoteIntRes_SDIV(SDNode *N); 247193323Sed SDValue PromoteIntRes_SELECT(SDNode *N); 248226633Sdim SDValue PromoteIntRes_VSELECT(SDNode *N); 249193323Sed SDValue PromoteIntRes_SELECT_CC(SDNode *N); 250193323Sed SDValue PromoteIntRes_SETCC(SDNode *N); 251193323Sed SDValue PromoteIntRes_SHL(SDNode *N); 252193323Sed SDValue PromoteIntRes_SimpleIntBinOp(SDNode *N); 253193323Sed SDValue PromoteIntRes_SIGN_EXTEND_INREG(SDNode *N); 254193323Sed SDValue PromoteIntRes_SRA(SDNode *N); 255193323Sed SDValue PromoteIntRes_SRL(SDNode *N); 256193323Sed SDValue PromoteIntRes_TRUNCATE(SDNode *N); 257193323Sed SDValue PromoteIntRes_UADDSUBO(SDNode *N, unsigned ResNo); 258193323Sed SDValue PromoteIntRes_UDIV(SDNode *N); 259193323Sed SDValue PromoteIntRes_UNDEF(SDNode *N); 260193323Sed SDValue PromoteIntRes_VAARG(SDNode *N); 261193323Sed SDValue PromoteIntRes_XMULO(SDNode *N, unsigned ResNo); 262193323Sed 263193323Sed // Integer Operand Promotion. 264193323Sed bool PromoteIntegerOperand(SDNode *N, unsigned OperandNo); 265193323Sed SDValue PromoteIntOp_ANY_EXTEND(SDNode *N); 266226633Sdim SDValue PromoteIntOp_ATOMIC_STORE(AtomicSDNode *N); 267218893Sdim SDValue PromoteIntOp_BITCAST(SDNode *N); 268193323Sed SDValue PromoteIntOp_BUILD_PAIR(SDNode *N); 269193323Sed SDValue PromoteIntOp_BR_CC(SDNode *N, unsigned OpNo); 270193323Sed SDValue PromoteIntOp_BRCOND(SDNode *N, unsigned OpNo); 271193323Sed SDValue PromoteIntOp_BUILD_VECTOR(SDNode *N); 272193323Sed SDValue PromoteIntOp_CONVERT_RNDSAT(SDNode *N); 273193323Sed SDValue PromoteIntOp_INSERT_VECTOR_ELT(SDNode *N, unsigned OpNo); 274223017Sdim SDValue PromoteIntOp_EXTRACT_ELEMENT(SDNode *N); 275223017Sdim SDValue PromoteIntOp_EXTRACT_VECTOR_ELT(SDNode *N); 276223017Sdim SDValue PromoteIntOp_CONCAT_VECTORS(SDNode *N); 277193323Sed SDValue PromoteIntOp_SCALAR_TO_VECTOR(SDNode *N); 278193323Sed SDValue PromoteIntOp_SELECT(SDNode *N, unsigned OpNo); 279193323Sed SDValue PromoteIntOp_SELECT_CC(SDNode *N, unsigned OpNo); 280193323Sed SDValue PromoteIntOp_SETCC(SDNode *N, unsigned OpNo); 281226633Sdim SDValue PromoteIntOp_VSETCC(SDNode *N, unsigned OpNo); 282193323Sed SDValue PromoteIntOp_Shift(SDNode *N); 283193323Sed SDValue PromoteIntOp_SIGN_EXTEND(SDNode *N); 284193323Sed SDValue PromoteIntOp_SINT_TO_FP(SDNode *N); 285193323Sed SDValue PromoteIntOp_STORE(StoreSDNode *N, unsigned OpNo); 286193323Sed SDValue PromoteIntOp_TRUNCATE(SDNode *N); 287193323Sed SDValue PromoteIntOp_UINT_TO_FP(SDNode *N); 288193323Sed SDValue PromoteIntOp_ZERO_EXTEND(SDNode *N); 289193323Sed 290193323Sed void PromoteSetCCOperands(SDValue &LHS,SDValue &RHS, ISD::CondCode Code); 291193323Sed 292193323Sed //===--------------------------------------------------------------------===// 293193323Sed // Integer Expansion Support: LegalizeIntegerTypes.cpp 294193323Sed //===--------------------------------------------------------------------===// 295193323Sed 296193323Sed /// GetExpandedInteger - Given a processed operand Op which was expanded into 297193323Sed /// two integers of half the size, this returns the two halves. The low bits 298193323Sed /// of Op are exactly equal to the bits of Lo; the high bits exactly equal Hi. 299193323Sed /// For example, if Op is an i64 which was expanded into two i32's, then this 300193323Sed /// method returns the two i32's, with Lo being equal to the lower 32 bits of 301193323Sed /// Op, and Hi being equal to the upper 32 bits. 302193323Sed void GetExpandedInteger(SDValue Op, SDValue &Lo, SDValue &Hi); 303193323Sed void SetExpandedInteger(SDValue Op, SDValue Lo, SDValue Hi); 304193323Sed 305193323Sed // Integer Result Expansion. 306193323Sed void ExpandIntegerResult(SDNode *N, unsigned ResNo); 307226633Sdim void ExpandIntRes_MERGE_VALUES (SDNode *N, unsigned ResNo, 308226633Sdim SDValue &Lo, SDValue &Hi); 309193323Sed void ExpandIntRes_ANY_EXTEND (SDNode *N, SDValue &Lo, SDValue &Hi); 310193323Sed void ExpandIntRes_AssertSext (SDNode *N, SDValue &Lo, SDValue &Hi); 311193323Sed void ExpandIntRes_AssertZext (SDNode *N, SDValue &Lo, SDValue &Hi); 312193323Sed void ExpandIntRes_Constant (SDNode *N, SDValue &Lo, SDValue &Hi); 313193323Sed void ExpandIntRes_CTLZ (SDNode *N, SDValue &Lo, SDValue &Hi); 314193323Sed void ExpandIntRes_CTPOP (SDNode *N, SDValue &Lo, SDValue &Hi); 315193323Sed void ExpandIntRes_CTTZ (SDNode *N, SDValue &Lo, SDValue &Hi); 316193323Sed void ExpandIntRes_LOAD (LoadSDNode *N, SDValue &Lo, SDValue &Hi); 317193323Sed void ExpandIntRes_SIGN_EXTEND (SDNode *N, SDValue &Lo, SDValue &Hi); 318193323Sed void ExpandIntRes_SIGN_EXTEND_INREG (SDNode *N, SDValue &Lo, SDValue &Hi); 319193323Sed void ExpandIntRes_TRUNCATE (SDNode *N, SDValue &Lo, SDValue &Hi); 320193323Sed void ExpandIntRes_ZERO_EXTEND (SDNode *N, SDValue &Lo, SDValue &Hi); 321193323Sed void ExpandIntRes_FP_TO_SINT (SDNode *N, SDValue &Lo, SDValue &Hi); 322193323Sed void ExpandIntRes_FP_TO_UINT (SDNode *N, SDValue &Lo, SDValue &Hi); 323193323Sed 324193323Sed void ExpandIntRes_Logical (SDNode *N, SDValue &Lo, SDValue &Hi); 325193323Sed void ExpandIntRes_ADDSUB (SDNode *N, SDValue &Lo, SDValue &Hi); 326193323Sed void ExpandIntRes_ADDSUBC (SDNode *N, SDValue &Lo, SDValue &Hi); 327193323Sed void ExpandIntRes_ADDSUBE (SDNode *N, SDValue &Lo, SDValue &Hi); 328193323Sed void ExpandIntRes_BSWAP (SDNode *N, SDValue &Lo, SDValue &Hi); 329193323Sed void ExpandIntRes_MUL (SDNode *N, SDValue &Lo, SDValue &Hi); 330193323Sed void ExpandIntRes_SDIV (SDNode *N, SDValue &Lo, SDValue &Hi); 331193323Sed void ExpandIntRes_SREM (SDNode *N, SDValue &Lo, SDValue &Hi); 332193323Sed void ExpandIntRes_UDIV (SDNode *N, SDValue &Lo, SDValue &Hi); 333193323Sed void ExpandIntRes_UREM (SDNode *N, SDValue &Lo, SDValue &Hi); 334193323Sed void ExpandIntRes_Shift (SDNode *N, SDValue &Lo, SDValue &Hi); 335193323Sed 336210299Sed void ExpandIntRes_SADDSUBO (SDNode *N, SDValue &Lo, SDValue &Hi); 337210299Sed void ExpandIntRes_UADDSUBO (SDNode *N, SDValue &Lo, SDValue &Hi); 338224145Sdim void ExpandIntRes_XMULO (SDNode *N, SDValue &Lo, SDValue &Hi); 339210299Sed 340226633Sdim void ExpandIntRes_ATOMIC_LOAD (SDNode *N, SDValue &Lo, SDValue &Hi); 341226633Sdim 342193323Sed void ExpandShiftByConstant(SDNode *N, unsigned Amt, 343193323Sed SDValue &Lo, SDValue &Hi); 344193323Sed bool ExpandShiftWithKnownAmountBit(SDNode *N, SDValue &Lo, SDValue &Hi); 345193323Sed bool ExpandShiftWithUnknownAmountBit(SDNode *N, SDValue &Lo, SDValue &Hi); 346193323Sed 347193323Sed // Integer Operand Expansion. 348193323Sed bool ExpandIntegerOperand(SDNode *N, unsigned OperandNo); 349218893Sdim SDValue ExpandIntOp_BITCAST(SDNode *N); 350193323Sed SDValue ExpandIntOp_BR_CC(SDNode *N); 351193323Sed SDValue ExpandIntOp_BUILD_VECTOR(SDNode *N); 352193323Sed SDValue ExpandIntOp_EXTRACT_ELEMENT(SDNode *N); 353193323Sed SDValue ExpandIntOp_SELECT_CC(SDNode *N); 354193323Sed SDValue ExpandIntOp_SETCC(SDNode *N); 355193323Sed SDValue ExpandIntOp_Shift(SDNode *N); 356193323Sed SDValue ExpandIntOp_SINT_TO_FP(SDNode *N); 357193323Sed SDValue ExpandIntOp_STORE(StoreSDNode *N, unsigned OpNo); 358193323Sed SDValue ExpandIntOp_TRUNCATE(SDNode *N); 359193323Sed SDValue ExpandIntOp_UINT_TO_FP(SDNode *N); 360200581Srdivacky SDValue ExpandIntOp_RETURNADDR(SDNode *N); 361226633Sdim SDValue ExpandIntOp_ATOMIC_STORE(SDNode *N); 362193323Sed 363193323Sed void IntegerExpandSetCCOperands(SDValue &NewLHS, SDValue &NewRHS, 364263508Sdim ISD::CondCode &CCCode, SDLoc dl); 365193323Sed 366193323Sed //===--------------------------------------------------------------------===// 367193323Sed // Float to Integer Conversion Support: LegalizeFloatTypes.cpp 368193323Sed //===--------------------------------------------------------------------===// 369193323Sed 370193323Sed /// GetSoftenedFloat - Given a processed operand Op which was converted to an 371193323Sed /// integer of the same size, this returns the integer. The integer contains 372193323Sed /// exactly the same bits as Op - only the type changed. For example, if Op 373193323Sed /// is an f32 which was softened to an i32, then this method returns an i32, 374193323Sed /// the bits of which coincide with those of Op. 375193323Sed SDValue GetSoftenedFloat(SDValue Op) { 376193323Sed SDValue &SoftenedOp = SoftenedFloats[Op]; 377193323Sed RemapValue(SoftenedOp); 378193323Sed assert(SoftenedOp.getNode() && "Operand wasn't converted to integer?"); 379193323Sed return SoftenedOp; 380193323Sed } 381193323Sed void SetSoftenedFloat(SDValue Op, SDValue Result); 382193323Sed 383193323Sed // Result Float to Integer Conversion. 384193323Sed void SoftenFloatResult(SDNode *N, unsigned OpNo); 385226633Sdim SDValue SoftenFloatRes_MERGE_VALUES(SDNode *N, unsigned ResNo); 386218893Sdim SDValue SoftenFloatRes_BITCAST(SDNode *N); 387193323Sed SDValue SoftenFloatRes_BUILD_PAIR(SDNode *N); 388193323Sed SDValue SoftenFloatRes_ConstantFP(ConstantFPSDNode *N); 389193323Sed SDValue SoftenFloatRes_EXTRACT_VECTOR_ELT(SDNode *N); 390193323Sed SDValue SoftenFloatRes_FABS(SDNode *N); 391193323Sed SDValue SoftenFloatRes_FADD(SDNode *N); 392193323Sed SDValue SoftenFloatRes_FCEIL(SDNode *N); 393193323Sed SDValue SoftenFloatRes_FCOPYSIGN(SDNode *N); 394193323Sed SDValue SoftenFloatRes_FCOS(SDNode *N); 395193323Sed SDValue SoftenFloatRes_FDIV(SDNode *N); 396193323Sed SDValue SoftenFloatRes_FEXP(SDNode *N); 397193323Sed SDValue SoftenFloatRes_FEXP2(SDNode *N); 398193323Sed SDValue SoftenFloatRes_FFLOOR(SDNode *N); 399193323Sed SDValue SoftenFloatRes_FLOG(SDNode *N); 400193323Sed SDValue SoftenFloatRes_FLOG2(SDNode *N); 401193323Sed SDValue SoftenFloatRes_FLOG10(SDNode *N); 402224145Sdim SDValue SoftenFloatRes_FMA(SDNode *N); 403193323Sed SDValue SoftenFloatRes_FMUL(SDNode *N); 404193323Sed SDValue SoftenFloatRes_FNEARBYINT(SDNode *N); 405193323Sed SDValue SoftenFloatRes_FNEG(SDNode *N); 406193323Sed SDValue SoftenFloatRes_FP_EXTEND(SDNode *N); 407205218Srdivacky SDValue SoftenFloatRes_FP16_TO_FP32(SDNode *N); 408193323Sed SDValue SoftenFloatRes_FP_ROUND(SDNode *N); 409193323Sed SDValue SoftenFloatRes_FPOW(SDNode *N); 410193323Sed SDValue SoftenFloatRes_FPOWI(SDNode *N); 411193323Sed SDValue SoftenFloatRes_FREM(SDNode *N); 412193323Sed SDValue SoftenFloatRes_FRINT(SDNode *N); 413263508Sdim SDValue SoftenFloatRes_FROUND(SDNode *N); 414193323Sed SDValue SoftenFloatRes_FSIN(SDNode *N); 415193323Sed SDValue SoftenFloatRes_FSQRT(SDNode *N); 416193323Sed SDValue SoftenFloatRes_FSUB(SDNode *N); 417193323Sed SDValue SoftenFloatRes_FTRUNC(SDNode *N); 418193323Sed SDValue SoftenFloatRes_LOAD(SDNode *N); 419193323Sed SDValue SoftenFloatRes_SELECT(SDNode *N); 420193323Sed SDValue SoftenFloatRes_SELECT_CC(SDNode *N); 421193323Sed SDValue SoftenFloatRes_UNDEF(SDNode *N); 422193323Sed SDValue SoftenFloatRes_VAARG(SDNode *N); 423193323Sed SDValue SoftenFloatRes_XINT_TO_FP(SDNode *N); 424193323Sed 425193323Sed // Operand Float to Integer Conversion. 426193323Sed bool SoftenFloatOperand(SDNode *N, unsigned OpNo); 427218893Sdim SDValue SoftenFloatOp_BITCAST(SDNode *N); 428193323Sed SDValue SoftenFloatOp_BR_CC(SDNode *N); 429193323Sed SDValue SoftenFloatOp_FP_ROUND(SDNode *N); 430193323Sed SDValue SoftenFloatOp_FP_TO_SINT(SDNode *N); 431193323Sed SDValue SoftenFloatOp_FP_TO_UINT(SDNode *N); 432205218Srdivacky SDValue SoftenFloatOp_FP32_TO_FP16(SDNode *N); 433193323Sed SDValue SoftenFloatOp_SELECT_CC(SDNode *N); 434193323Sed SDValue SoftenFloatOp_SETCC(SDNode *N); 435193323Sed SDValue SoftenFloatOp_STORE(SDNode *N, unsigned OpNo); 436193323Sed 437193323Sed //===--------------------------------------------------------------------===// 438193323Sed // Float Expansion Support: LegalizeFloatTypes.cpp 439193323Sed //===--------------------------------------------------------------------===// 440193323Sed 441193323Sed /// GetExpandedFloat - Given a processed operand Op which was expanded into 442193323Sed /// two floating point values of half the size, this returns the two halves. 443193323Sed /// The low bits of Op are exactly equal to the bits of Lo; the high bits 444193323Sed /// exactly equal Hi. For example, if Op is a ppcf128 which was expanded 445193323Sed /// into two f64's, then this method returns the two f64's, with Lo being 446193323Sed /// equal to the lower 64 bits of Op, and Hi to the upper 64 bits. 447193323Sed void GetExpandedFloat(SDValue Op, SDValue &Lo, SDValue &Hi); 448193323Sed void SetExpandedFloat(SDValue Op, SDValue Lo, SDValue Hi); 449193323Sed 450193323Sed // Float Result Expansion. 451193323Sed void ExpandFloatResult(SDNode *N, unsigned ResNo); 452193323Sed void ExpandFloatRes_ConstantFP(SDNode *N, SDValue &Lo, SDValue &Hi); 453193323Sed void ExpandFloatRes_FABS (SDNode *N, SDValue &Lo, SDValue &Hi); 454193323Sed void ExpandFloatRes_FADD (SDNode *N, SDValue &Lo, SDValue &Hi); 455193323Sed void ExpandFloatRes_FCEIL (SDNode *N, SDValue &Lo, SDValue &Hi); 456205218Srdivacky void ExpandFloatRes_FCOPYSIGN (SDNode *N, SDValue &Lo, SDValue &Hi); 457193323Sed void ExpandFloatRes_FCOS (SDNode *N, SDValue &Lo, SDValue &Hi); 458193323Sed void ExpandFloatRes_FDIV (SDNode *N, SDValue &Lo, SDValue &Hi); 459193323Sed void ExpandFloatRes_FEXP (SDNode *N, SDValue &Lo, SDValue &Hi); 460193323Sed void ExpandFloatRes_FEXP2 (SDNode *N, SDValue &Lo, SDValue &Hi); 461193323Sed void ExpandFloatRes_FFLOOR (SDNode *N, SDValue &Lo, SDValue &Hi); 462193323Sed void ExpandFloatRes_FLOG (SDNode *N, SDValue &Lo, SDValue &Hi); 463193323Sed void ExpandFloatRes_FLOG2 (SDNode *N, SDValue &Lo, SDValue &Hi); 464193323Sed void ExpandFloatRes_FLOG10 (SDNode *N, SDValue &Lo, SDValue &Hi); 465224145Sdim void ExpandFloatRes_FMA (SDNode *N, SDValue &Lo, SDValue &Hi); 466193323Sed void ExpandFloatRes_FMUL (SDNode *N, SDValue &Lo, SDValue &Hi); 467193323Sed void ExpandFloatRes_FNEARBYINT(SDNode *N, SDValue &Lo, SDValue &Hi); 468193323Sed void ExpandFloatRes_FNEG (SDNode *N, SDValue &Lo, SDValue &Hi); 469193323Sed void ExpandFloatRes_FP_EXTEND (SDNode *N, SDValue &Lo, SDValue &Hi); 470193323Sed void ExpandFloatRes_FPOW (SDNode *N, SDValue &Lo, SDValue &Hi); 471193323Sed void ExpandFloatRes_FPOWI (SDNode *N, SDValue &Lo, SDValue &Hi); 472249423Sdim void ExpandFloatRes_FREM (SDNode *N, SDValue &Lo, SDValue &Hi); 473193323Sed void ExpandFloatRes_FRINT (SDNode *N, SDValue &Lo, SDValue &Hi); 474263508Sdim void ExpandFloatRes_FROUND (SDNode *N, SDValue &Lo, SDValue &Hi); 475193323Sed void ExpandFloatRes_FSIN (SDNode *N, SDValue &Lo, SDValue &Hi); 476193323Sed void ExpandFloatRes_FSQRT (SDNode *N, SDValue &Lo, SDValue &Hi); 477193323Sed void ExpandFloatRes_FSUB (SDNode *N, SDValue &Lo, SDValue &Hi); 478193323Sed void ExpandFloatRes_FTRUNC (SDNode *N, SDValue &Lo, SDValue &Hi); 479193323Sed void ExpandFloatRes_LOAD (SDNode *N, SDValue &Lo, SDValue &Hi); 480193323Sed void ExpandFloatRes_XINT_TO_FP(SDNode *N, SDValue &Lo, SDValue &Hi); 481193323Sed 482193323Sed // Float Operand Expansion. 483193323Sed bool ExpandFloatOperand(SDNode *N, unsigned OperandNo); 484193323Sed SDValue ExpandFloatOp_BR_CC(SDNode *N); 485263508Sdim SDValue ExpandFloatOp_FCOPYSIGN(SDNode *N); 486193323Sed SDValue ExpandFloatOp_FP_ROUND(SDNode *N); 487193323Sed SDValue ExpandFloatOp_FP_TO_SINT(SDNode *N); 488193323Sed SDValue ExpandFloatOp_FP_TO_UINT(SDNode *N); 489193323Sed SDValue ExpandFloatOp_SELECT_CC(SDNode *N); 490193323Sed SDValue ExpandFloatOp_SETCC(SDNode *N); 491193323Sed SDValue ExpandFloatOp_STORE(SDNode *N, unsigned OpNo); 492193323Sed 493193323Sed void FloatExpandSetCCOperands(SDValue &NewLHS, SDValue &NewRHS, 494263508Sdim ISD::CondCode &CCCode, SDLoc dl); 495193323Sed 496193323Sed //===--------------------------------------------------------------------===// 497193323Sed // Scalarization Support: LegalizeVectorTypes.cpp 498193323Sed //===--------------------------------------------------------------------===// 499193323Sed 500193323Sed /// GetScalarizedVector - Given a processed one-element vector Op which was 501193323Sed /// scalarized to its element type, this returns the element. For example, 502193323Sed /// if Op is a v1i32, Op = < i32 val >, this method returns val, an i32. 503193323Sed SDValue GetScalarizedVector(SDValue Op) { 504193323Sed SDValue &ScalarizedOp = ScalarizedVectors[Op]; 505193323Sed RemapValue(ScalarizedOp); 506193323Sed assert(ScalarizedOp.getNode() && "Operand wasn't scalarized?"); 507193323Sed return ScalarizedOp; 508193323Sed } 509193323Sed void SetScalarizedVector(SDValue Op, SDValue Result); 510193323Sed 511193323Sed // Vector Result Scalarization: <1 x ty> -> ty. 512193323Sed void ScalarizeVectorResult(SDNode *N, unsigned OpNo); 513226633Sdim SDValue ScalarizeVecRes_MERGE_VALUES(SDNode *N, unsigned ResNo); 514193323Sed SDValue ScalarizeVecRes_BinOp(SDNode *N); 515239462Sdim SDValue ScalarizeVecRes_TernaryOp(SDNode *N); 516193323Sed SDValue ScalarizeVecRes_UnaryOp(SDNode *N); 517202375Srdivacky SDValue ScalarizeVecRes_InregOp(SDNode *N); 518193323Sed 519218893Sdim SDValue ScalarizeVecRes_BITCAST(SDNode *N); 520239462Sdim SDValue ScalarizeVecRes_BUILD_VECTOR(SDNode *N); 521193323Sed SDValue ScalarizeVecRes_CONVERT_RNDSAT(SDNode *N); 522193323Sed SDValue ScalarizeVecRes_EXTRACT_SUBVECTOR(SDNode *N); 523221345Sdim SDValue ScalarizeVecRes_FP_ROUND(SDNode *N); 524193323Sed SDValue ScalarizeVecRes_FPOWI(SDNode *N); 525193323Sed SDValue ScalarizeVecRes_INSERT_VECTOR_ELT(SDNode *N); 526193323Sed SDValue ScalarizeVecRes_LOAD(LoadSDNode *N); 527193323Sed SDValue ScalarizeVecRes_SCALAR_TO_VECTOR(SDNode *N); 528200581Srdivacky SDValue ScalarizeVecRes_SIGN_EXTEND_INREG(SDNode *N); 529234353Sdim SDValue ScalarizeVecRes_VSELECT(SDNode *N); 530193323Sed SDValue ScalarizeVecRes_SELECT(SDNode *N); 531193323Sed SDValue ScalarizeVecRes_SELECT_CC(SDNode *N); 532198090Srdivacky SDValue ScalarizeVecRes_SETCC(SDNode *N); 533193323Sed SDValue ScalarizeVecRes_UNDEF(SDNode *N); 534193323Sed SDValue ScalarizeVecRes_VECTOR_SHUFFLE(SDNode *N); 535193323Sed SDValue ScalarizeVecRes_VSETCC(SDNode *N); 536193323Sed 537193323Sed // Vector Operand Scalarization: <1 x ty> -> ty. 538193323Sed bool ScalarizeVectorOperand(SDNode *N, unsigned OpNo); 539218893Sdim SDValue ScalarizeVecOp_BITCAST(SDNode *N); 540263508Sdim SDValue ScalarizeVecOp_UnaryOp(SDNode *N); 541193323Sed SDValue ScalarizeVecOp_CONCAT_VECTORS(SDNode *N); 542193323Sed SDValue ScalarizeVecOp_EXTRACT_VECTOR_ELT(SDNode *N); 543193323Sed SDValue ScalarizeVecOp_STORE(StoreSDNode *N, unsigned OpNo); 544193323Sed 545193323Sed //===--------------------------------------------------------------------===// 546193323Sed // Vector Splitting Support: LegalizeVectorTypes.cpp 547193323Sed //===--------------------------------------------------------------------===// 548193323Sed 549198090Srdivacky /// GetSplitVector - Given a processed vector Op which was split into vectors 550198090Srdivacky /// of half the size, this method returns the halves. The first elements of 551193323Sed /// Op coincide with the elements of Lo; the remaining elements of Op coincide 552193323Sed /// with the elements of Hi: Op is what you would get by concatenating Lo and 553193323Sed /// Hi. For example, if Op is a v8i32 that was split into two v4i32's, then 554193323Sed /// this method returns the two v4i32's, with Lo corresponding to the first 4 555193323Sed /// elements of Op, and Hi to the last 4 elements. 556193323Sed void GetSplitVector(SDValue Op, SDValue &Lo, SDValue &Hi); 557193323Sed void SetSplitVector(SDValue Op, SDValue Lo, SDValue Hi); 558193323Sed 559193323Sed // Vector Result Splitting: <128 x ty> -> 2 x <64 x ty>. 560193323Sed void SplitVectorResult(SDNode *N, unsigned OpNo); 561193323Sed void SplitVecRes_BinOp(SDNode *N, SDValue &Lo, SDValue &Hi); 562239462Sdim void SplitVecRes_TernaryOp(SDNode *N, SDValue &Lo, SDValue &Hi); 563193323Sed void SplitVecRes_UnaryOp(SDNode *N, SDValue &Lo, SDValue &Hi); 564263508Sdim void SplitVecRes_ExtendOp(SDNode *N, SDValue &Lo, SDValue &Hi); 565202375Srdivacky void SplitVecRes_InregOp(SDNode *N, SDValue &Lo, SDValue &Hi); 566193323Sed 567218893Sdim void SplitVecRes_BITCAST(SDNode *N, SDValue &Lo, SDValue &Hi); 568193323Sed void SplitVecRes_BUILD_PAIR(SDNode *N, SDValue &Lo, SDValue &Hi); 569193323Sed void SplitVecRes_BUILD_VECTOR(SDNode *N, SDValue &Lo, SDValue &Hi); 570193323Sed void SplitVecRes_CONCAT_VECTORS(SDNode *N, SDValue &Lo, SDValue &Hi); 571193323Sed void SplitVecRes_EXTRACT_SUBVECTOR(SDNode *N, SDValue &Lo, SDValue &Hi); 572267813Sdim void SplitVecRes_INSERT_SUBVECTOR(SDNode *N, SDValue &Lo, SDValue &Hi); 573193323Sed void SplitVecRes_FPOWI(SDNode *N, SDValue &Lo, SDValue &Hi); 574193323Sed void SplitVecRes_INSERT_VECTOR_ELT(SDNode *N, SDValue &Lo, SDValue &Hi); 575193323Sed void SplitVecRes_LOAD(LoadSDNode *N, SDValue &Lo, SDValue &Hi); 576193323Sed void SplitVecRes_SCALAR_TO_VECTOR(SDNode *N, SDValue &Lo, SDValue &Hi); 577200581Srdivacky void SplitVecRes_SIGN_EXTEND_INREG(SDNode *N, SDValue &Lo, SDValue &Hi); 578198090Srdivacky void SplitVecRes_SETCC(SDNode *N, SDValue &Lo, SDValue &Hi); 579193323Sed void SplitVecRes_UNDEF(SDNode *N, SDValue &Lo, SDValue &Hi); 580198090Srdivacky void SplitVecRes_VECTOR_SHUFFLE(ShuffleVectorSDNode *N, SDValue &Lo, 581193323Sed SDValue &Hi); 582193323Sed 583193323Sed // Vector Operand Splitting: <128 x ty> -> 2 x <64 x ty>. 584193323Sed bool SplitVectorOperand(SDNode *N, unsigned OpNo); 585249423Sdim SDValue SplitVecOp_VSELECT(SDNode *N, unsigned OpNo); 586193323Sed SDValue SplitVecOp_UnaryOp(SDNode *N); 587193323Sed 588218893Sdim SDValue SplitVecOp_BITCAST(SDNode *N); 589193323Sed SDValue SplitVecOp_EXTRACT_SUBVECTOR(SDNode *N); 590193323Sed SDValue SplitVecOp_EXTRACT_VECTOR_ELT(SDNode *N); 591193323Sed SDValue SplitVecOp_STORE(StoreSDNode *N, unsigned OpNo); 592212904Sdim SDValue SplitVecOp_CONCAT_VECTORS(SDNode *N); 593251662Sdim SDValue SplitVecOp_TRUNCATE(SDNode *N); 594226633Sdim SDValue SplitVecOp_VSETCC(SDNode *N); 595218893Sdim SDValue SplitVecOp_FP_ROUND(SDNode *N); 596193323Sed 597193323Sed //===--------------------------------------------------------------------===// 598193323Sed // Vector Widening Support: LegalizeVectorTypes.cpp 599193323Sed //===--------------------------------------------------------------------===// 600193323Sed 601193323Sed /// GetWidenedVector - Given a processed vector Op which was widened into a 602193323Sed /// larger vector, this method returns the larger vector. The elements of 603193323Sed /// the returned vector consist of the elements of Op followed by elements 604193323Sed /// containing rubbish. For example, if Op is a v2i32 that was widened to a 605193323Sed /// v4i32, then this method returns a v4i32 for which the first two elements 606193323Sed /// are the same as those of Op, while the last two elements contain rubbish. 607193323Sed SDValue GetWidenedVector(SDValue Op) { 608193323Sed SDValue &WidenedOp = WidenedVectors[Op]; 609193323Sed RemapValue(WidenedOp); 610193323Sed assert(WidenedOp.getNode() && "Operand wasn't widened?"); 611193323Sed return WidenedOp; 612193323Sed } 613193323Sed void SetWidenedVector(SDValue Op, SDValue Result); 614193323Sed 615193323Sed // Widen Vector Result Promotion. 616193323Sed void WidenVectorResult(SDNode *N, unsigned ResNo); 617226633Sdim SDValue WidenVecRes_MERGE_VALUES(SDNode* N, unsigned ResNo); 618218893Sdim SDValue WidenVecRes_BITCAST(SDNode* N); 619193323Sed SDValue WidenVecRes_BUILD_VECTOR(SDNode* N); 620193323Sed SDValue WidenVecRes_CONCAT_VECTORS(SDNode* N); 621193323Sed SDValue WidenVecRes_CONVERT_RNDSAT(SDNode* N); 622193323Sed SDValue WidenVecRes_EXTRACT_SUBVECTOR(SDNode* N); 623193323Sed SDValue WidenVecRes_INSERT_VECTOR_ELT(SDNode* N); 624193323Sed SDValue WidenVecRes_LOAD(SDNode* N); 625193323Sed SDValue WidenVecRes_SCALAR_TO_VECTOR(SDNode* N); 626200581Srdivacky SDValue WidenVecRes_SIGN_EXTEND_INREG(SDNode* N); 627193323Sed SDValue WidenVecRes_SELECT(SDNode* N); 628193323Sed SDValue WidenVecRes_SELECT_CC(SDNode* N); 629203954Srdivacky SDValue WidenVecRes_SETCC(SDNode* N); 630193323Sed SDValue WidenVecRes_UNDEF(SDNode *N); 631193323Sed SDValue WidenVecRes_VECTOR_SHUFFLE(ShuffleVectorSDNode *N); 632193323Sed SDValue WidenVecRes_VSETCC(SDNode* N); 633193323Sed 634243830Sdim SDValue WidenVecRes_Ternary(SDNode *N); 635193323Sed SDValue WidenVecRes_Binary(SDNode *N); 636263508Sdim SDValue WidenVecRes_BinaryCanTrap(SDNode *N); 637193323Sed SDValue WidenVecRes_Convert(SDNode *N); 638210299Sed SDValue WidenVecRes_POWI(SDNode *N); 639193323Sed SDValue WidenVecRes_Shift(SDNode *N); 640193323Sed SDValue WidenVecRes_Unary(SDNode *N); 641202375Srdivacky SDValue WidenVecRes_InregOp(SDNode *N); 642193323Sed 643193323Sed // Widen Vector Operand. 644243830Sdim bool WidenVectorOperand(SDNode *N, unsigned OpNo); 645218893Sdim SDValue WidenVecOp_BITCAST(SDNode *N); 646193323Sed SDValue WidenVecOp_CONCAT_VECTORS(SDNode *N); 647193323Sed SDValue WidenVecOp_EXTRACT_VECTOR_ELT(SDNode *N); 648198396Srdivacky SDValue WidenVecOp_EXTRACT_SUBVECTOR(SDNode *N); 649193323Sed SDValue WidenVecOp_STORE(SDNode* N); 650234353Sdim SDValue WidenVecOp_SETCC(SDNode* N); 651193323Sed 652193323Sed SDValue WidenVecOp_Convert(SDNode *N); 653193323Sed 654193323Sed //===--------------------------------------------------------------------===// 655193323Sed // Vector Widening Utilities Support: LegalizeVectorTypes.cpp 656193323Sed //===--------------------------------------------------------------------===// 657193323Sed 658203954Srdivacky /// Helper GenWidenVectorLoads - Helper function to generate a set of 659193323Sed /// loads to load a vector with a resulting wider type. It takes 660203954Srdivacky /// LdChain: list of chains for the load to be generated. 661203954Srdivacky /// Ld: load to widen 662263508Sdim SDValue GenWidenVectorLoads(SmallVectorImpl<SDValue> &LdChain, 663203954Srdivacky LoadSDNode *LD); 664193323Sed 665203954Srdivacky /// GenWidenVectorExtLoads - Helper function to generate a set of extension 666203954Srdivacky /// loads to load a ector with a resulting wider type. It takes 667203954Srdivacky /// LdChain: list of chains for the load to be generated. 668203954Srdivacky /// Ld: load to widen 669203954Srdivacky /// ExtType: extension element type 670263508Sdim SDValue GenWidenVectorExtLoads(SmallVectorImpl<SDValue> &LdChain, 671203954Srdivacky LoadSDNode *LD, ISD::LoadExtType ExtType); 672203954Srdivacky 673193323Sed /// Helper genWidenVectorStores - Helper function to generate a set of 674193323Sed /// stores to store a widen vector into non widen memory 675193323Sed /// StChain: list of chains for the stores we have generated 676203954Srdivacky /// ST: store of a widen value 677263508Sdim void GenWidenVectorStores(SmallVectorImpl<SDValue> &StChain, StoreSDNode *ST); 678193323Sed 679203954Srdivacky /// Helper genWidenVectorTruncStores - Helper function to generate a set of 680203954Srdivacky /// stores to store a truncate widen vector into non widen memory 681203954Srdivacky /// StChain: list of chains for the stores we have generated 682203954Srdivacky /// ST: store of a widen value 683263508Sdim void GenWidenVectorTruncStores(SmallVectorImpl<SDValue> &StChain, 684203954Srdivacky StoreSDNode *ST); 685203954Srdivacky 686193323Sed /// Modifies a vector input (widen or narrows) to a vector of NVT. The 687193323Sed /// input vector must have the same element type as NVT. 688198090Srdivacky SDValue ModifyToType(SDValue InOp, EVT WidenVT); 689193323Sed 690193323Sed 691193323Sed //===--------------------------------------------------------------------===// 692193323Sed // Generic Splitting: LegalizeTypesGeneric.cpp 693193323Sed //===--------------------------------------------------------------------===// 694193323Sed 695193323Sed // Legalization methods which only use that the illegal type is split into two 696193323Sed // not necessarily identical types. As such they can be used for splitting 697193323Sed // vectors and expanding integers and floats. 698193323Sed 699193323Sed void GetSplitOp(SDValue Op, SDValue &Lo, SDValue &Hi) { 700193323Sed if (Op.getValueType().isVector()) 701193323Sed GetSplitVector(Op, Lo, Hi); 702193323Sed else if (Op.getValueType().isInteger()) 703193323Sed GetExpandedInteger(Op, Lo, Hi); 704193323Sed else 705193323Sed GetExpandedFloat(Op, Lo, Hi); 706193323Sed } 707193323Sed 708193323Sed /// GetPairElements - Use ISD::EXTRACT_ELEMENT nodes to extract the low and 709193323Sed /// high parts of the given value. 710193323Sed void GetPairElements(SDValue Pair, SDValue &Lo, SDValue &Hi); 711193323Sed 712193323Sed // Generic Result Splitting. 713226633Sdim void SplitRes_MERGE_VALUES(SDNode *N, unsigned ResNo, 714226633Sdim SDValue &Lo, SDValue &Hi); 715193323Sed void SplitRes_SELECT (SDNode *N, SDValue &Lo, SDValue &Hi); 716193323Sed void SplitRes_SELECT_CC (SDNode *N, SDValue &Lo, SDValue &Hi); 717193323Sed void SplitRes_UNDEF (SDNode *N, SDValue &Lo, SDValue &Hi); 718193323Sed 719193323Sed //===--------------------------------------------------------------------===// 720193323Sed // Generic Expansion: LegalizeTypesGeneric.cpp 721193323Sed //===--------------------------------------------------------------------===// 722193323Sed 723193323Sed // Legalization methods which only use that the illegal type is split into two 724193323Sed // identical types of half the size, and that the Lo/Hi part is stored first 725193323Sed // in memory on little/big-endian machines, followed by the Hi/Lo part. As 726193323Sed // such they can be used for expanding integers and floats. 727193323Sed 728193323Sed void GetExpandedOp(SDValue Op, SDValue &Lo, SDValue &Hi) { 729193323Sed if (Op.getValueType().isInteger()) 730193323Sed GetExpandedInteger(Op, Lo, Hi); 731193323Sed else 732193323Sed GetExpandedFloat(Op, Lo, Hi); 733193323Sed } 734193323Sed 735263508Sdim 736263508Sdim /// This function will split the integer \p Op into \p NumElements 737263508Sdim /// operations of type \p EltVT and store them in \p Ops. 738263508Sdim void IntegerToVector(SDValue Op, unsigned NumElements, 739263508Sdim SmallVectorImpl<SDValue> &Ops, EVT EltVT); 740263508Sdim 741193323Sed // Generic Result Expansion. 742226633Sdim void ExpandRes_MERGE_VALUES (SDNode *N, unsigned ResNo, 743226633Sdim SDValue &Lo, SDValue &Hi); 744218893Sdim void ExpandRes_BITCAST (SDNode *N, SDValue &Lo, SDValue &Hi); 745193323Sed void ExpandRes_BUILD_PAIR (SDNode *N, SDValue &Lo, SDValue &Hi); 746193323Sed void ExpandRes_EXTRACT_ELEMENT (SDNode *N, SDValue &Lo, SDValue &Hi); 747193323Sed void ExpandRes_EXTRACT_VECTOR_ELT(SDNode *N, SDValue &Lo, SDValue &Hi); 748193323Sed void ExpandRes_NormalLoad (SDNode *N, SDValue &Lo, SDValue &Hi); 749193323Sed void ExpandRes_VAARG (SDNode *N, SDValue &Lo, SDValue &Hi); 750193323Sed 751193323Sed // Generic Operand Expansion. 752218893Sdim SDValue ExpandOp_BITCAST (SDNode *N); 753193323Sed SDValue ExpandOp_BUILD_VECTOR (SDNode *N); 754193323Sed SDValue ExpandOp_EXTRACT_ELEMENT (SDNode *N); 755193323Sed SDValue ExpandOp_INSERT_VECTOR_ELT(SDNode *N); 756193323Sed SDValue ExpandOp_SCALAR_TO_VECTOR (SDNode *N); 757193323Sed SDValue ExpandOp_NormalStore (SDNode *N, unsigned OpNo); 758193323Sed}; 759193323Sed 760193323Sed} // end namespace llvm. 761193323Sed 762193323Sed#endif 763