<s> inline SDValue XformM5ToU5Imm ( signed Imm , SDLoc DL ) { assert ( ( Imm >= - <NUM_LIT> && Imm <= - <NUM_LIT> ) && <STR_LIT> ) ; return CurDAG -> getTargetConstant ( - Imm , DL , <STR_LIT>


<s> } SDNode * Result = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , N -> getOperand ( <NUM_LIT> ) , Src1 -> getOperand ( <NUM_LIT> ) , Src1 -> getOperand ( <NUM_LIT> ) ) ; ReplaceUses ( N , Result )


<s> SDValue Base = Const32 -> getOperand ( <NUM_LIT> ) ; EVT LoadedVT = LD -> getMemoryVT ( ) ; int64_t Offset = cast < GlobalAddressSDNode > ( Base ) -> getOffset ( ) ; if ( Offset != <NUM_LIT> && OffsetFitsS11 ( LoadedVT , Offset ) ) { MVT PointerTy = TLI . getPointerTy ( ) ; const GlobalValue * GV = cast < GlobalAddressSDNode > ( Base ) -> getGlobal ( ) ; SDValue TargAddr = CurDAG -> getTargetGlobalAddress ( GV , dl , PointerTy , <NUM_LIT> ) ; SDNode * NewBase = CurDAG -> getMachineNode ( <STR_LIT> , dl , PointerTy , TargAddr ) ; if ( LoadedVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( LoadedVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( LoadedVT == <STR_LIT> )


<s> if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else assert ( <NUM_LIT> && <STR_LIT> ) ; SDValue Ops [ ] = { SDValue ( NewBase , <NUM_LIT> ) , CurDAG -> getTargetConstant ( Offset , PointerTy ) , Value , Chain } ; SDNode * Result = CurDAG -> getMachineNode ( Opcode , dl , <STR_LIT> , Ops , <NUM_LIT> ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ; MemOp [ <NUM_LIT> ] = ST -> getMemOperand ( ) ; cast < MachineSDNode > ( Result ) -> setMemRefs ( MemOp , MemOp + <NUM_LIT> ) ; ReplaceUses ( ST , Result ) ; return Result ; } } } return SelectCode ( ST


<s> SDNode * <ISA_LIT>DAGToDAGISel :: SelectConstant ( SDNode * N ) { DebugLoc dl = N -> getDebugLoc ( ) ; if ( N -> getValueType ( <NUM_LIT> ) == <STR_LIT> ) { SDNode * Result ; int32_t Val = cast < ConstantSDNode > ( N ) -> getSExtValue ( ) ; if ( Val == - <NUM_LIT> ) { SDNode * IntRegTFR = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , CurDAG -> getTargetConstant ( <NUM_LIT> , <STR_LIT> ) ) ; SDNode * Pd = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( IntRegTFR , <NUM_LIT> ) ) ; SDNode * NotPd = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( Pd , <NUM_LIT> ) ) ; Result = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( Pd , <NUM_LIT> ) , SDValue ( NotPd , <NUM_LIT> ) ) ; ReplaceUses ( N , Result ) ; return Result ; } } return SelectCode ( N


<s> int32_t Val = cast < ConstantSDNode > ( OffsetNode ) -> getSExtValue ( ) ; EVT StoredVT = ST -> getMemoryVT ( ) ; if ( TII -> isValidAutoIncImm ( StoredVT , Val ) ) { SDValue Ops [ ] = { Value , Base , CurDAG -> getTargetConstant ( Val , <STR_LIT> ) , Chain } ; unsigned Opcode = <NUM_LIT> ; if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else assert ( <NUM_LIT> && <STR_LIT> ) ; SDNode * Result = CurDAG -> getMachineNode ( Opcode , dl , <STR_LIT> , <STR_LIT> , Ops , <NUM_LIT> ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ; MemOp [ <NUM_LIT> ] = ST -> getMemOperand ( ) ; cast < MachineSDNode > ( Result ) -> setMemRefs (


<s> SDNode * <ISA_LIT>DAGToDAGISel :: SelectIndexedStore ( StoreSDNode * ST , DebugLoc dl ) { SDValue Chain = ST -> getChain ( ) ; SDValue Base = ST -> getBasePtr ( ) ; SDValue Offset = ST -> getOffset ( ) ; SDValue Value = ST -> getValue ( ) ; SDNode * OffsetNode = Offset . getNode ( ) ; int32_t Val = cast < ConstantSDNode > ( OffsetNode ) -> getSExtValue ( ) ; EVT StoredVT = ST -> getMemoryVT ( ) ; if ( TII -> isValidAutoIncImm ( StoredVT , Val ) ) { SDValue Ops [ ] = { Value , Base , CurDAG -> getTargetConstant ( Val , <STR_LIT> ) , Chain } ; unsigned Opcode = <NUM_LIT> ; if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else assert ( <NUM_LIT> && <STR_LIT> ) ; SDNode * Result = CurDAG -> getMachineNode ( Opcode , dl , <STR_LIT> , <STR_LIT> , Ops , <NUM_LIT> ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ; MemOp [ <NUM_LIT> ] = ST -> getMemOperand ( ) ; cast < MachineSDNode > ( Result ) -> setMemRefs ( MemOp , MemOp + <NUM_LIT> ) ; ReplaceUses ( ST


<s> if ( IntrinsicWithPred ) { SmallVector < SDValue , <NUM_LIT> > Ops ; const MCInstrDesc & MCID = TII -> get ( IntrinsicWithPred ) ; const TargetRegisterInfo * TRI = TM . getRegisterInfo ( ) ; for ( unsigned i = <NUM_LIT> ; i < N -> getNumOperands ( ) ; ++ i ) { SDNode * Arg = N -> getOperand ( i ) . getNode ( ) ; const TargetRegisterClass * RC = TII -> getRegClass ( MCID , i , TRI ) ; if ( RC == <STR_LIT> || RC == <STR_LIT> ) { Ops . push_back ( SDValue ( Arg , <NUM_LIT> ) ) ; } else if ( RC == <STR_LIT> ) { SDNode * PdRs = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( Arg , <NUM_LIT> ) ) ; Ops . push_back ( SDValue ( PdRs , <NUM_LIT> ) ) ; } else if ( RC == NULL && ( dyn_cast < ConstantSDNode > ( Arg ) !=


<s> SDNode * Arg = N -> getOperand ( i ) . getNode ( ) ; const TargetRegisterClass * RC = TII -> getRegClass ( MCID , i , TRI ) ; if ( RC == <STR_LIT> || RC == <STR_LIT> ) { Ops . push_back ( SDValue ( Arg , <NUM_LIT> ) ) ; } else if ( RC == <STR_LIT> ) { SDNode * PdRs = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( Arg , <NUM_LIT> ) ) ; Ops . push_back ( SDValue ( PdRs , <NUM_LIT> ) ) ; } else if ( RC == NULL && ( dyn_cast < ConstantSDNode > ( Arg ) != NULL ) ) { int32_t Val = cast < ConstantSDNode > ( Arg ) -> getSExtValue ( ) ; SDValue SDVal = CurDAG -> getTargetConstant ( Val , <STR_LIT>


<s> SDValue OP0 ; SDValue OP1 ; if ( MulOp0 . getOpcode ( ) == <STR_LIT> ) { SDValue Sext0 = MulOp0 . getOperand ( <NUM_LIT> ) ; if ( Sext0 . getNode ( ) -> getValueType ( <NUM_LIT> ) != <STR_LIT> ) { SelectCode ( N ) ; } OP0 = Sext0 ; } else if ( MulOp0 . getOpcode ( ) == <STR_LIT> ) { LoadSDNode * LD = cast < LoadSDNode > ( MulOp0 . getNode ( ) ) ; if ( LD -> getMemoryVT ( ) != <STR_LIT> || LD -> getExtensionType ( ) != <STR_LIT> || LD -> getAddressingMode ( ) != <STR_LIT> ) { SelectCode ( N ) ; } SDValue Chain = LD -> getChain ( ) ; SDValue TargetConst0 = CurDAG -> getTargetConstant ( <NUM_LIT> , <STR_LIT> ) ; OP0 = SDValue ( CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , <STR_LIT> , LD -> getBasePtr ( ) , TargetConst0 , Chain ) , <NUM_LIT> ) ; } else { return SelectCode ( N ) ; } if ( MulOp1 . getOpcode ( ) == <STR_LIT> ) { SDValue Sext1 = MulOp1 . getOperand ( <NUM_LIT> ) ; if ( Sext1 . getNode ( ) -> getValueType ( <NUM_LIT> ) != <STR_LIT> ) { return SelectCode ( N ) ; } OP1 = Sext1 ; } else if ( MulOp1 . getOpcode ( ) == <STR_LIT> ) { LoadSDNode * LD = cast < LoadSDNode > ( MulOp1 . getNode ( ) ) ; if ( LD -> getMemoryVT ( ) != <STR_LIT> || LD -> getExtensionType ( ) != <STR_LIT> || LD -> getAddressingMode ( ) != <STR_LIT> ) { return SelectCode ( N ) ; } SDValue Chain = LD -> getChain ( ) ; SDValue TargetConst0 = CurDAG -> getTargetConstant ( <NUM_LIT> , <STR_LIT>


<s> SDNode * Result_2 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , TargetConst0 ) ; SDNode * Result_3 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , <STR_LIT> , SDValue ( Result_2 , <NUM_LIT> ) , SDValue ( Result_1 , <NUM_LIT> ) ) ; ReplaceUses ( N , Result_3 ) ; return Result_3 ; } if ( N -> getValueType ( <NUM_LIT> ) == <STR_LIT> ) { SDNode * RsPd = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( IsIntrinsic , <NUM_LIT> ) ) ; ReplaceUses ( N , RsPd ) ; return RsPd ; } assert ( <NUM_LIT> && <STR_LIT> ) ; } } return SelectCode ( N )


<s> case <STR_LIT> : return SelectBitcast ( N ) ; case <STR_LIT> : return SelectSHL ( N ) ; case <STR_LIT> : return SelectLoad ( N ) ; case <STR_LIT> : return SelectStore ( N ) ; case <STR_LIT> : return SelectIntrinsicWChain ( N ) ; case <STR_LIT> : return SelectIntrinsicWOChain ( N ) ; case <STR_LIT> : return SelectVAlign ( N ) ; case <STR_LIT> : return SelectVAlignAddr ( N ) ; case <STR_LIT> : return SelectTypecast ( N ) ; case <STR_LIT> : return SelectP2D (


<s> Opcode = IsValidInc ? <STR_LIT> : <STR_LIT> ; break ; case <STR_LIT> : Opcode = IsValidInc ? <STR_LIT> : <STR_LIT> ; break ; case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : Opcode = IsValidInc ? <STR_LIT> : <STR_LIT> ; break ; case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : Opcode = IsValidInc ? <STR_LIT> : <STR_LIT> ; break ; case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : if ( isAlignedMemNode ( ST ) ) { if ( ST -> isNonTemporal ( ) ) Opcode = IsValidInc ? <STR_LIT> : <STR_LIT> ; else Opcode = IsValidInc ? <STR_LIT> : <STR_LIT> ; } else { Opcode = IsValidInc ? <STR_LIT> : <STR_LIT> ; } break ; default : llvm_unreachable ( <STR_LIT> ) ; } if ( ST -> isTruncatingStore ( ) && ValueVT . getSizeInBits ( ) == <NUM_LIT> ) { assert ( StoredVT . getSizeInBits ( ) < <NUM_LIT> && <STR_LIT> ) ; Value = CurDAG -> getTargetExtractSubreg ( <STR_LIT> , dl , <STR_LIT> , Value ) ; } SDValue IncV = CurDAG -> getTargetConstant ( Inc , dl , <STR_LIT> ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ; MemOp [ <NUM_LIT> ] = ST -> getMemOperand (


<s> if ( N -> isMachineOpcode ( ) ) return N -> setNodeId ( - <NUM_LIT> ) ; switch ( N -> getOpcode ( ) ) { case <STR_LIT> : return SelectConstant ( N ) ; case <STR_LIT> : return SelectConstantFP ( N ) ; case <STR_LIT> : return SelectFrameIndex ( N ) ; case <STR_LIT> : return SelectBitcast ( N ) ; case <STR_LIT> : return SelectSHL


<s> void <ISA_LIT>DAGToDAGISel :: Select ( SDNode * N ) { if ( N -> isMachineOpcode ( ) ) return N -> setNodeId ( - <NUM_LIT> ) ; switch ( N -> getOpcode ( ) ) { case <STR_LIT> : return SelectConstant ( N ) ; case <STR_LIT> : return SelectConstantFP ( N ) ; case <STR_LIT> : return SelectFrameIndex ( N ) ; case <STR_LIT> : return SelectBitcast ( N ) ; case <STR_LIT> : return SelectSHL ( N ) ; case <STR_LIT> : return SelectLoad ( N ) ; case <STR_LIT> : return SelectStore ( N ) ; case <STR_LIT> : return SelectZeroExtend ( N ) ; case <STR_LIT> : return SelectIntrinsicWChain ( N ) ; case <STR_LIT> : return SelectIntrinsicWOChain ( N ) ; } if ( HST -> useHVXOps ( ) )


<s> if ( auto * FN = dyn_cast < FrameIndexSDNode > ( N -> getOperand ( <NUM_LIT> ) ) ) { MachineFrameInfo * MFI = MF -> getFrameInfo ( ) ; unsigned A = MFI -> getObjectAlignment ( FN -> getIndex ( ) ) ; assert ( isPowerOf2_32 ( A


<s> SDValue N0 = I -> getOperand ( <NUM_LIT> ) , N1 = I -> getOperand ( <NUM_LIT> ) ; EVT VT = I -> getValueType ( <NUM_LIT> ) ; bool SelN0 = IsSelect0 ( N0 ) ; SDValue SOp = SelN0 ? N0 : N1 ; SDValue VOp = SelN0 ? N1 : N0 ; if ( SOp . getOpcode ( ) == <STR_LIT> && SOp . getNode ( ) -> hasOneUse ( ) ) { SDValue SC = SOp . getOperand ( <NUM_LIT> ) ; SDValue SX = SOp . getOperand ( <NUM_LIT> ) ; SDValue SY = SOp . getOperand ( <NUM_LIT> ) ; SDLoc DLS = SOp ; if ( IsZero ( SY ) ) { SDValue NewOr = DAG . getNode ( <STR_LIT> , DLS , VT , SX , VOp ) ; SDValue NewSel = DAG . getNode ( <STR_LIT> , DLS , VT , SC , NewOr , VOp ) ; DAG . ReplaceAllUsesWith ( I , NewSel . getNode ( ) ) ; } else if ( IsZero ( SX ) ) { SDValue NewOr = DAG . getNode ( <STR_LIT> , DLS , VT , SY , VOp ) ; SDValue NewSel = DAG . getNode ( <STR_LIT> , DLS , VT , SC , VOp , NewOr ) ; DAG . ReplaceAllUsesWith ( I , NewSel . getNode ( ) ) ; } } } for ( auto I : Nodes ) { if ( I -> getOpcode ( ) != <STR_LIT> ) continue ; SDValue Off = I -> getOperand ( <NUM_LIT> ) ; if ( Off . getOpcode ( ) != <STR_LIT> ) continue ; SDValue T0 = Off . getOperand ( <NUM_LIT> ) ; if ( T0 . getOpcode ( ) != <STR_LIT> ) continue ; SDValue T1 = T0 . getOperand ( <NUM_LIT> ) ; SDValue T2 = T0 . getOperand ( <NUM_LIT> ) ; if ( T1 . getOpcode ( ) != <STR_LIT> ) continue ; SDValue C = T1 . getOperand ( <NUM_LIT> ) ; ConstantSDNode * CN = dyn_cast < ConstantSDNode > ( C . getNode ( ) ) ; if ( CN == nullptr ) continue ; unsigned CV = CN -> getZExtValue ( ) ; if ( CV > <NUM_LIT> ) continue ; ConstantSDNode * EN = dyn_cast < ConstantSDNode > ( T2 . getNode ( ) ) ; if ( EN == nullptr ) continue ; unsigned EV = EN -> getZExtValue ( ) ; if ( EV % ( <NUM_LIT> << CV ) != <NUM_LIT> ) continue ; unsigned DV = EV / ( <NUM_LIT> << CV ) ; SDLoc DL = SDLoc ( I


<s> auto & HMFI = * MF -> getInfo < <ISA_LIT>MachineFunctionInfo > ( ) ; unsigned AR = HMFI . getStackAlignBaseVReg ( ) ; SDValue CH = CurDAG -> getEntryNode ( ) ; SDValue Ops [ ] = { CurDAG -> getCopyFromReg ( CH , DL , AR , <STR_LIT> ) , FI , Zero } ; R = CurDAG -> getMachineNode ( <STR_LIT> , DL , <STR_LIT> , Ops ) ; } ReplaceNode ( N , R )


<s> MachineFrameInfo * MFI = MF -> getFrameInfo ( ) ; const <ISA_LIT>FrameLowering * HFI = HST -> getFrameLowering ( ) ; int FX = cast < FrameIndexSDNode > ( N ) -> getIndex ( ) ; unsigned StkA = HFI -> getStackAlignment ( ) ; unsigned MaxA = MFI -> getMaxAlignment ( ) ; SDValue FI = CurDAG -> getTargetFrameIndex ( FX , <STR_LIT> ) ; SDLoc DL ( N ) ; SDValue Zero = CurDAG -> getTargetConstant ( <NUM_LIT> , DL , <STR_LIT> ) ; SDNode * R = <NUM_LIT> ; if ( FX < <NUM_LIT> || MaxA <= StkA || ! MFI -> hasVarSizedObjects ( ) ) { R = CurDAG -> getMachineNode ( <STR_LIT> , DL , <STR_LIT> , FI , Zero ) ; } else { auto & HMFI = * MF -> getInfo < <ISA_LIT>MachineFunctionInfo > ( ) ; unsigned AR = HMFI . getStackAlignBaseVReg ( ) ; SDValue CH = CurDAG -> getEntryNode ( ) ; SDValue Ops [ ] = { CurDAG -> getCopyFromReg ( CH , DL , AR , <STR_LIT> ) , FI , Zero } ; R = CurDAG -> getMachineNode ( <STR_LIT> , DL ,


<s> unsigned AR = FuncInfo -> CreateReg ( <STR_LIT> ) ; unsigned MaxA = MFI . getMaxAlignment ( ) ; BuildMI ( EntryBB , DebugLoc ( ) , HII -> get ( <STR_LIT> ) , AR ) . addImm ( MaxA ) ; MF -> getInfo < <ISA_LIT>MachineFunctionInfo > ( )


<s> return ; case <STR_LIT> : SelectAdd ( N ) ; return ; case <STR_LIT> : SelectBitcast ( N ) ; return ; case <STR_LIT> : SelectSHL ( N ) ; return ; case <STR_LIT> : SelectLoad ( N ) ; return ; case <STR_LIT> : SelectStore ( N ) ; return ; case <STR_LIT> : SelectMul ( N ) ; return ; case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : SelectBitOp ( N ) ; return ; case <STR_LIT> : SelectZeroExtend ( N ) ; return ; case <STR_LIT> : SelectIntrinsicWChain ( N ) ; return ; case


<s> if ( N -> getOperand ( <NUM_LIT> ) . getOpcode ( ) == <STR_LIT> ) Val = cast < ConstantSDNode > ( ( N ) -> getOperand ( <NUM_LIT> ) ) -> getSExtValue ( ) ; else { SelectCode ( N ) ; return ; } } if ( Opc == <STR_LIT> ) { if ( ( ValueVT == <STR_LIT> && isPowerOf2_32 ( ~ Val ) ) || ( ValueVT == <STR_LIT> && isPowerOf2_64 ( ~ Val ) ) ) Val = ~ Val ; else { SelectCode ( N ) ; return ; } } if ( Opc == <STR_LIT> || Opc == <STR_LIT> ) { switch ( N -> getOperand ( <NUM_LIT> ) -> getOpcode ( ) ) { default : break ; case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : SelectCode ( N ) ; return ; } } unsigned BitPos = <NUM_LIT> ; if ( Opc != <STR_LIT> && Opc != <STR_LIT> ) { if ( ( ValueVT == <STR_LIT> && ! isPowerOf2_32 ( Val ) ) || ( ValueVT == <STR_LIT> && ! isPowerOf2_64 ( Val ) ) ) { SelectCode ( N ) ; return ; } BitPos = countTrailingZeros ( uint64_t ( Val ) ) ; } else { BitPos = <NUM_LIT> ; } unsigned BitOpc = <NUM_LIT> ; switch ( Opc ) { default : llvm_unreachable ( <STR_LIT> ) ; case <STR_LIT> : case <STR_LIT> : BitOpc = <STR_LIT> ; break ; case <STR_LIT> : BitOpc = <STR_LIT> ; break ; case <STR_LIT> : case <STR_LIT> : BitOpc = <STR_LIT> ; break ; } SDNode * Result ; SDValue SDVal = CurDAG -> getTargetConstant ( BitPos , dl , <STR_LIT> ) ; if ( ValueVT == <STR_LIT> || ValueVT == <STR_LIT> ) { Result = CurDAG -> getMachineNode ( BitOpc , dl , ValueVT , N -> getOperand ( <NUM_LIT> ) , SDVal ) ; } else { EVT SubValueVT


<s> const APFloat & APF = CN -> getValueAPF ( ) ; if ( N -> getValueType ( <NUM_LIT> ) == <STR_LIT> ) { ReplaceNode ( N , CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , CurDAG -> getTargetConstantFP ( APF . convertToFloat ( ) , dl , <STR_LIT> ) ) ) ; return ; } if ( N -> getValueType ( <NUM_LIT>


<s> unsigned Opcode = <NUM_LIT> ; assert ( StoredVT . isSimple ( ) ) ; switch ( StoredVT . getSimpleVT ( ) . SimpleTy ) { case <STR_LIT> : Opcode = IsValidInc ? <STR_LIT> : <STR_LIT> ; break ; case <STR_LIT> : Opcode = IsValidInc ? <STR_LIT> : <STR_LIT> ; break ; case <STR_LIT> : Opcode = IsValidInc ? <STR_LIT> : <STR_LIT> ; break ; case <STR_LIT> : Opcode = IsValidInc ? <STR_LIT> : <STR_LIT> ; break ; case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : if ( isAlignedMemNode ( ST ) ) Opcode = IsValidInc ? <STR_LIT> : <STR_LIT> ; else Opcode = IsValidInc ? <STR_LIT> : <STR_LIT> ; break ; case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : if ( isAlignedMemNode ( ST ) ) Opcode = IsValidInc ? <STR_LIT> : <STR_LIT> ; else Opcode = IsValidInc ? <STR_LIT> : <STR_LIT> ; break ; default : llvm_unreachable ( <STR_LIT> ) ; } if ( ST -> isTruncatingStore ( ) && ValueVT . getSizeInBits ( ) == <NUM_LIT> ) { assert ( StoredVT . getSizeInBits ( ) < <NUM_LIT> && <STR_LIT> ) ; Value = CurDAG -> getTargetExtractSubreg ( <STR_LIT> , dl , <STR_LIT> , Value ) ; } SDValue IncV = CurDAG -> getTargetConstant ( Inc , dl , <STR_LIT> ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ; MemOp [ <NUM_LIT> ] = ST ->


<s> return XformMskToBitPosU5Imm ( Imm ,


<s> assert ( BitPos < <NUM_LIT> && <STR_LIT> ) ; return CurDAG -> getTargetConstant ( BitPos ,


<s> return CurDAG -> getTargetConstant ( Imm - <NUM_LIT> ,


<s> inline SDValue XformSToSM2Imm ( unsigned Imm , const SDLoc &


<s> return CurDAG -> getTargetConstant ( Imm - <NUM_LIT>


<s> inline SDValue XformUToUM1Imm ( unsigned Imm , const SDLoc & DL ) { assert ( ( Imm >= <NUM_LIT> ) && <STR_LIT> ) ; return CurDAG -> getTargetConstant ( Imm - <NUM_LIT>


<s> case <STR_LIT> : case <STR_LIT> : BitOpc = <STR_LIT> ; break ; case <STR_LIT> : BitOpc = <STR_LIT> ; break ; case <STR_LIT> : case <STR_LIT> : BitOpc = <STR_LIT> ; break ; } SDNode * Result ; SDValue SDVal = CurDAG -> getTargetConstant ( bitpos , <STR_LIT> ) ; if ( ValueVT == <STR_LIT> || ValueVT == <STR_LIT> ) { Result = CurDAG -> getMachineNode ( BitOpc , dl , ValueVT , N -> getOperand ( <NUM_LIT> ) , SDVal ) ; } else { EVT SubValueVT ; if ( ValueVT == <STR_LIT> ) SubValueVT = <STR_LIT> ; else SubValueVT = <STR_LIT> ; SDNode * Reg = N -> getOperand ( <NUM_LIT> ) . getNode ( ) ; SDValue RegClass = CurDAG -> getTargetConstant ( <STR_LIT> , <STR_LIT> ) ; SDValue SubregHiIdx = CurDAG -> getTargetConstant ( <STR_LIT> , <STR_LIT> ) ; SDValue SubregLoIdx = CurDAG -> getTargetConstant ( <STR_LIT> , <STR_LIT> ) ; SDValue SubregHI = CurDAG -> getTargetExtractSubreg ( <STR_LIT> , dl , <STR_LIT> , SDValue ( Reg , <NUM_LIT> ) ) ; SDValue SubregLO = CurDAG -> getTargetExtractSubreg ( <STR_LIT> , dl , <STR_LIT> , SDValue ( Reg , <NUM_LIT> ) ) ; if ( SubValueVT != <STR_LIT> && bitpos < <NUM_LIT> ) { SDNode * Result0 = CurDAG -> getMachineNode ( BitOpc , dl , SubValueVT , SubregLO , SDVal ) ; const SDValue Ops [ ] = { RegClass , SubregHI , SubregHiIdx , SDValue ( Result0 , <NUM_LIT> ) , SubregLoIdx } ; Result = CurDAG -> getMachineNode ( TargetOpcode :: REG_SEQUENCE , dl , ValueVT , Ops ) ; } else


<s> int FX = cast < FrameIndexSDNode > ( N ) -> getIndex ( ) ; SDValue FI = CurDAG -> getTargetFrameIndex ( FX , <STR_LIT> ) ; SDValue Zero = CurDAG -> getTargetConstant ( <NUM_LIT>


<s> } else if ( LoadedVT == <STR_LIT> ) { if ( TII . isValidAutoIncImm ( LoadedVT , Val ) ) Opcode = <STR_LIT> ; else Opcode = <STR_LIT> ; } else if ( LoadedVT == <STR_LIT> ) { if ( TII . isValidAutoIncImm ( LoadedVT , Val ) ) Opcode = IsZeroExt ? <STR_LIT> : <STR_LIT> ; else Opcode = IsZeroExt ? <STR_LIT> : <STR_LIT> ; } else if ( LoadedVT == <STR_LIT> ) { if ( TII . isValidAutoIncImm ( LoadedVT , Val ) ) Opcode = IsZeroExt ? <STR_LIT> : <STR_LIT> ; else Opcode = IsZeroExt ? <STR_LIT> : <STR_LIT> ; } else llvm_unreachable ( <STR_LIT> ) ; if ( LD -> getValueType ( <NUM_LIT> ) == <STR_LIT> && IsZeroExt ) return SelectIndexedLoadZeroExtend64 ( LD , Opcode , dl ) ; if ( LD -> getValueType ( <NUM_LIT> ) == <STR_LIT> && ExtType == <STR_LIT> ) return SelectIndexedLoadSignExtend64 ( LD , Opcode , dl ) ; if ( TII . isValidAutoIncImm ( LoadedVT , Val ) ) { SDValue TargetConstVal = CurDAG -> getTargetConstant ( Val , <STR_LIT> ) ; SDNode * Result = CurDAG -> getMachineNode ( Opcode , dl , LD -> getValueType ( <NUM_LIT> ) , <STR_LIT> , <STR_LIT> , Base , TargetConstVal , Chain ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ; MemOp [ <NUM_LIT> ] = LD -> getMemOperand ( ) ; cast < MachineSDNode > ( Result ) -> setMemRefs ( MemOp , MemOp + <NUM_LIT> ) ; const SDValue Froms [ ] = { SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) } ; const SDValue Tos [ ] = { SDValue ( Result , <NUM_LIT> ) , SDValue ( Result , <NUM_LIT> ) , SDValue ( Result , <NUM_LIT> ) } ; ReplaceUses ( Froms , Tos , <NUM_LIT> ) ; return Result ; } else { SDValue TargetConst0 = CurDAG -> getTargetConstant ( <NUM_LIT> , <STR_LIT> ) ; SDValue TargetConstVal = CurDAG -> getTargetConstant ( Val , <STR_LIT> ) ; SDNode * Result_1 = CurDAG -> getMachineNode ( Opcode , dl , LD -> getValueType ( <NUM_LIT> ) , <STR_LIT> , Base , TargetConst0 , Chain ) ; SDNode * Result_2 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> ,

Base , TargetConstVal , SDValue ( Result_1 , <NUM_LIT> ) ) ;


<s> SDValue Offset = LD -> getOffset ( ) ; SDNode * OffsetNode = Offset . getNode ( ) ; int32_t Val = cast < ConstantSDNode > ( OffsetNode ) -> getSExtValue ( ) ; EVT LoadedVT = LD -> getMemoryVT ( ) ; unsigned Opcode = <NUM_LIT> ; <STR_LIT> ExtType = LD -> getExtensionType ( ) ; bool IsZeroExt = ( ExtType == <STR_LIT> || ExtType == <STR_LIT> ) ; const <ISA_LIT>InstrInfo & TII = * HST -> getInstrInfo ( ) ; if ( LoadedVT == <STR_LIT> ) { if ( TII . isValidAutoIncImm ( LoadedVT , Val ) ) Opcode = <STR_LIT> ; else Opcode = <STR_LIT> ; } else if ( LoadedVT == <STR_LIT> ) { if ( TII . isValidAutoIncImm ( LoadedVT , Val ) ) Opcode = <STR_LIT> ; else Opcode = <STR_LIT> ; } else if ( LoadedVT == <STR_LIT> ) { if ( TII . isValidAutoIncImm ( LoadedVT , Val ) ) Opcode = IsZeroExt ? <STR_LIT> : <STR_LIT> ; else Opcode = IsZeroExt ? <STR_LIT> : <STR_LIT> ; } else if ( LoadedVT == <STR_LIT> ) { if ( TII . isValidAutoIncImm ( LoadedVT , Val ) ) Opcode = IsZeroExt ? <STR_LIT> : <STR_LIT> ; else Opcode = IsZeroExt ? <STR_LIT> : <STR_LIT> ; } else llvm_unreachable ( <STR_LIT> ) ; if ( LD -> getValueType ( <NUM_LIT> ) == <STR_LIT> && IsZeroExt ) return SelectIndexedLoadZeroExtend64 ( LD , Opcode , dl ) ; if ( LD -> getValueType ( <NUM_LIT> ) == <STR_LIT> && ExtType == <STR_LIT> ) return SelectIndexedLoadSignExtend64 ( LD , Opcode , dl ) ; if ( TII . isValidAutoIncImm ( LoadedVT , Val ) ) { SDValue TargetConstVal = CurDAG -> getTargetConstant ( Val , <STR_LIT> ) ; SDNode * Result = CurDAG -> getMachineNode ( Opcode , dl , LD -> getValueType ( <NUM_LIT> ) , <STR_LIT> , <STR_LIT> , Base , TargetConstVal , Chain ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ; MemOp [ <NUM_LIT> ] = LD -> getMemOperand ( ) ; cast < MachineSDNode > ( Result ) -> setMemRefs ( MemOp , MemOp + <NUM_LIT> ) ; const SDValue Froms [ ] = { SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) } ; const SDValue Tos [ ] = { SDValue ( Result , <NUM_LIT> ) , SDValue ( Result , <NUM_LIT> ) , SDValue ( Result , <NUM_LIT> ) } ; ReplaceUses ( Froms ,


<s> SDNode * <ISA_LIT>DAGToDAGISel :: SelectIndexedLoadSignExtend64 ( LoadSDNode * LD , unsigned Opcode , SDLoc dl ) { SDValue Chain = LD -> getChain ( ) ; EVT LoadedVT = LD -> getMemoryVT ( ) ; SDValue Base = LD -> getBasePtr ( ) ; SDValue Offset = LD -> getOffset ( ) ; SDNode * OffsetNode = Offset . getNode ( ) ; int32_t Val = cast < ConstantSDNode > ( OffsetNode ) -> getSExtValue ( ) ; const <ISA_LIT>InstrInfo & TII = * HST -> getInstrInfo ( ) ; if ( TII . isValidAutoIncImm ( LoadedVT , Val ) ) { SDValue TargetConst = CurDAG -> getTargetConstant ( Val , <STR_LIT> ) ; SDNode * Result_1 = CurDAG -> getMachineNode ( Opcode , dl , <STR_LIT> , <STR_LIT> , <STR_LIT> , Base , TargetConst , Chain ) ; SDNode * Result_2 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( Result_1 , <NUM_LIT> ) ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ; MemOp [ <NUM_LIT> ] = LD -> getMemOperand ( ) ; cast < MachineSDNode > ( Result_1 ) -> setMemRefs ( MemOp , MemOp + <NUM_LIT> ) ; const SDValue Froms [ ] = { SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) } ; const SDValue Tos [ ] = { SDValue ( Result_2 , <NUM_LIT> ) , SDValue ( Result_1 , <NUM_LIT> ) , SDValue ( Result_1 , <NUM_LIT> ) } ; ReplaceUses ( Froms , Tos , <NUM_LIT> ) ; return Result_2 ; } SDValue TargetConst0 = CurDAG -> getTargetConstant ( <NUM_LIT> , <STR_LIT> ) ; SDValue TargetConstVal = CurDAG -> getTargetConstant ( Val , <STR_LIT> ) ; SDNode * Result_1 = CurDAG -> getMachineNode ( Opcode , dl , <STR_LIT> , <STR_LIT> , Base , TargetConst0 , Chain ) ; SDNode * Result_2 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( Result_1 , <NUM_LIT> ) ) ; SDNode * Result_3 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , Base , TargetConstVal , SDValue ( Result_1 , <NUM_LIT> ) ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ; MemOp [ <NUM_LIT> ] = LD -> getMemOperand ( ) ; cast < MachineSDNode > ( Result_1 ) -> setMemRefs ( MemOp , MemOp + <NUM_LIT> ) ; const SDValue Froms [ ] = { SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) } ; const SDValue Tos [ ] = { SDValue ( Result_2 , <NUM_LIT> ) , SDValue ( Result_3 , <NUM_LIT> ) , SDValue ( Result_1 , <NUM_LIT> ) } ; ReplaceUses ( Froms , Tos


<s> SDValue TargetConst = CurDAG -> getTargetConstant ( Val , <STR_LIT> ) ; SDNode * Result_1 = CurDAG -> getMachineNode ( Opcode , dl , <STR_LIT> , <STR_LIT> , <STR_LIT> , Base , TargetConst , Chain ) ; SDNode * Result_2 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( Result_1 , <NUM_LIT> ) ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ; MemOp [ <NUM_LIT> ] = LD -> getMemOperand ( ) ; cast < MachineSDNode > ( Result_1 ) -> setMemRefs ( MemOp , MemOp + <NUM_LIT> ) ; const SDValue Froms [ ] = { SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) } ; const SDValue Tos [ ] = { SDValue ( Result_2 , <NUM_LIT> ) , SDValue ( Result_1 , <NUM_LIT> ) , SDValue ( Result_1 , <NUM_LIT> ) } ; ReplaceUses ( Froms , Tos , <NUM_LIT> ) ; return


<s> ReplaceUses ( Froms , Tos , <NUM_LIT> ) ; return Result_2 ; } SDValue TargetConst0 = CurDAG -> getTargetConstant ( <NUM_LIT> , <STR_LIT> ) ; SDValue TargetConstVal = CurDAG -> getTargetConstant ( Val , <STR_LIT> ) ; SDNode * Result_1 = CurDAG -> getMachineNode ( Opcode , dl , <STR_LIT> , <STR_LIT> , Base , TargetConst0 , Chain ) ; SDNode * Result_2 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , <STR_LIT> , TargetConst0 , SDValue ( Result_1 , <NUM_LIT> ) ) ; SDNode * Result_3 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , Base , TargetConstVal , SDValue ( Result_1 , <NUM_LIT> ) ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ; MemOp [ <NUM_LIT> ] = LD -> getMemOperand ( ) ; cast < MachineSDNode > ( Result_1 ) -> setMemRefs ( MemOp , MemOp + <NUM_LIT> ) ; const SDValue Froms [ ] = { SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) } ; const SDValue Tos [ ] = { SDValue ( Result_2 , <NUM_LIT> ) , SDValue ( Result_3 , <NUM_LIT> ) , SDValue ( Result_1 , <NUM_LIT> ) } ; ReplaceUses ( Froms ,


<s> MemOp [ <NUM_LIT> ] = ST -> getMemOperand ( ) ; cast < MachineSDNode > ( Result ) -> setMemRefs ( MemOp , MemOp + <NUM_LIT> ) ; ReplaceUses ( ST , Result ) ; ReplaceUses ( SDValue ( ST , <NUM_LIT> ) , SDValue ( Result , <NUM_LIT> ) ) ; return Result ; } SDValue Ops [ ] = { Base , CurDAG -> getTargetConstant ( <NUM_LIT> , <STR_LIT> ) , Value , Chain } ; unsigned Opcode = <NUM_LIT> ; if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else llvm_unreachable ( <STR_LIT> ) ; SDValue TargetConstVal = CurDAG -> getTargetConstant ( Val , <STR_LIT> ) ; SDNode * Result_1 = CurDAG -> getMachineNode ( Opcode , dl , <STR_LIT> , Ops ) ; SDNode * Result_2 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , Base , TargetConstVal , SDValue ( Result_1 , <NUM_LIT> ) ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ; MemOp [ <NUM_LIT> ] = ST


<s> int32_t Val = cast < ConstantSDNode > ( OffsetNode ) -> getSExtValue ( ) ; EVT StoredVT = ST -> getMemoryVT ( ) ; EVT ValueVT = Value . getValueType ( ) ; const <ISA_LIT>InstrInfo & TII = * HST -> getInstrInfo ( ) ; if ( TII . isValidAutoIncImm ( StoredVT , Val ) ) { unsigned Opcode = <NUM_LIT> ; if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else llvm_unreachable ( <STR_LIT> ) ; if ( ST -> isTruncatingStore ( ) && ValueVT . getSizeInBits ( ) == <NUM_LIT> ) { assert ( StoredVT . getSizeInBits ( ) < <NUM_LIT> && <STR_LIT> ) ; Value = CurDAG -> getTargetExtractSubreg ( <STR_LIT> , dl , <STR_LIT> , Value ) ; } SDValue Ops [ ] = { Base , CurDAG -> getTargetConstant ( Val , <STR_LIT> ) , Value , Chain } ; SDNode * Result = CurDAG -> getMachineNode ( Opcode , dl , <STR_LIT> , <STR_LIT> , Ops ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ; MemOp [ <NUM_LIT> ] = ST -> getMemOperand ( ) ; cast < MachineSDNode > ( Result ) -> setMemRefs ( MemOp , MemOp + <NUM_LIT> ) ; ReplaceUses ( ST ,


<s> bool <ISA_LIT>DAGToDAGISel :: SelectInlineAsmMemoryOperand ( const SDValue & Op , unsigned ConstraintID , std :: vector < SDValue > & OutOps ) { SDValue Inp = Op , Res ; switch ( ConstraintID ) { default : return true ; case InlineAsm :: Constraint_i : case InlineAsm :: Constraint_o : case InlineAsm :: Constraint_v : case InlineAsm :: Constraint_m : if ( SelectAddrFI ( Inp , Res ) ) OutOps . push_back ( Res ) ; else OutOps . push_back ( Inp ) ; break ; } OutOps . push_back ( CurDAG -> getTargetConstant ( <NUM_LIT> , <STR_LIT> ) ) ; return false


<s> SDValue Inp = Op , Res ; switch ( ConstraintID ) { default : return true ; case InlineAsm :: Constraint_i : case InlineAsm :: Constraint_o : case InlineAsm :: Constraint_v : case InlineAsm :: Constraint_m : if ( SelectAddrFI ( Inp , Res ) ) OutOps . push_back ( Res ) ; else OutOps . push_back (


<s> } SDNode * IsIntrinsic = N -> getOperand ( <NUM_LIT> ) . getNode ( ) ; if ( ( IsIntrinsic -> getOpcode ( ) == <STR_LIT> ) ) { unsigned ID = cast < ConstantSDNode > ( IsIntrinsic -> getOperand ( <NUM_LIT> ) ) -> getZExtValue ( ) ; if ( doesIntrinsicReturnPredicate ( ID ) ) { if ( N -> getValueType ( <NUM_LIT> ) == <STR_LIT> ) { SDValue TargetConst0 = CurDAG -> getTargetConstant ( <NUM_LIT> , <STR_LIT> ) ; SDNode * Result_1 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( IsIntrinsic , <NUM_LIT> ) ) ; SDNode * Result_2 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , TargetConst0 ) ; SDNode * Result_3 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , <STR_LIT> , SDValue ( Result_2 , <NUM_LIT> ) , SDValue ( Result_1 , <NUM_LIT> ) ) ; ReplaceUses ( N , Result_3 ) ; return Result_3 ; } if ( N -> getValueType ( <NUM_LIT> )


<s> unsigned ID = cast < ConstantSDNode > ( IsIntrinsic -> getOperand ( <NUM_LIT> ) ) -> getZExtValue ( ) ; if ( doesIntrinsicReturnPredicate ( ID ) ) { if ( N -> getValueType ( <NUM_LIT> ) == <STR_LIT> ) { SDValue TargetConst0 = CurDAG -> getTargetConstant ( <NUM_LIT> , <STR_LIT> ) ; SDNode * Result_1 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( IsIntrinsic , <NUM_LIT> ) ) ; SDNode * Result_2 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , TargetConst0 ) ; SDNode * Result_3 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , <STR_LIT> , SDValue ( Result_2 , <NUM_LIT> ) , SDValue ( Result_1 , <NUM_LIT> ) ) ; ReplaceUses ( N , Result_3 ) ; return Result_3 ; } if ( N -> getValueType ( <NUM_LIT> ) == <STR_LIT> ) { SDNode * RsPd = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( IsIntrinsic , <NUM_LIT> ) ) ; ReplaceUses ( N , RsPd ) ; return RsPd ; } llvm_unreachable ( <STR_LIT> ) ; } } return SelectCode (


<s> } SDValue Ones = CurDAG -> getTargetConstant ( MV , dl , <STR_LIT> ) ; SDNode * OnesReg = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , Ones ) ; if ( ExVT . getSizeInBits ( ) == <NUM_LIT> ) { SDNode * And = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( Mask , <NUM_LIT> ) , SDValue ( OnesReg , <NUM_LIT> ) ) ; SDValue SubR = CurDAG -> getTargetConstant ( <STR_LIT> , dl , <STR_LIT> ) ; ReplaceNode ( N , CurDAG -> getMachineNode ( <STR_LIT> , dl , ExVT , SDValue ( And , <NUM_LIT> ) , SubR ) ) ; return ; } ReplaceNode ( N , CurDAG -> getMachineNode ( <STR_LIT> , dl , ExVT , SDValue ( Mask , <NUM_LIT> ) , SDValue ( OnesReg , <NUM_LIT> ) ) ) ; return ; } SDNode * Int = N -> getOperand ( <NUM_LIT> ) . getNode ( ) ; if ( ( Int -> getOpcode ( ) == <STR_LIT> ) ) { unsigned ID = cast < ConstantSDNode > ( Int -> getOperand ( <NUM_LIT> ) ) -> getZExtValue ( ) ; if ( doesIntrinsicReturnPredicate ( ID ) ) { if ( N -> getValueType ( <NUM_LIT> ) == <STR_LIT> ) { SDValue TargetConst0 = CurDAG -> getTargetConstant ( <NUM_LIT> , dl , <STR_LIT> ) ; SDNode * Result_1 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( Int , <NUM_LIT> ) ) ; SDNode * Result_2 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , TargetConst0 ) ; SDNode * Result_3 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , <STR_LIT> , SDValue ( Result_2 , <NUM_LIT> ) , SDValue ( Result_1 , <NUM_LIT> ) ) ; ReplaceNode ( N ,


<s> case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT>


<s> case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT>


<s> EVT ValueVT = N -> getValueType ( <NUM_LIT> ) ; if ( ! ( ValueVT == <STR_LIT> || ValueVT == <STR_LIT> || ValueVT == <STR_LIT> || ValueVT == <STR_LIT> ) ) return SelectCode ( N ) ; unsigned Opc = N -> getOpcode ( ) ; if ( ( Opc == <STR_LIT> || Opc == <STR_LIT> ) && ! HST -> hasV5TOps ( ) ) return SelectCode ( N ) ; int64_t Val = <NUM_LIT> ; if ( Opc != <STR_LIT> && Opc != <STR_LIT> ) { if ( N -> getOperand ( <NUM_LIT> ) . getOpcode ( ) == <STR_LIT> ) Val = cast < ConstantSDNode > ( ( N ) -> getOperand ( <NUM_LIT> ) ) -> getSExtValue ( ) ; else return SelectCode ( N ) ; } if ( Opc == <STR_LIT> ) { if ( ( ValueVT == <STR_LIT> && isPowerOf2_32 ( ~ Val ) ) || ( ValueVT == <STR_LIT> && isPowerOf2_64 ( ~ Val ) ) ) Val = ~ Val ; else return SelectCode ( N ) ; } if ( Opc == <STR_LIT> || Opc == <STR_LIT> ) { switch ( N -> getOperand ( <NUM_LIT> ) -> getOpcode ( ) ) { default : break ; case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : return SelectCode ( N ) ; } } unsigned BitPos = <NUM_LIT> ; if ( Opc != <STR_LIT> && Opc != <STR_LIT> ) { if ( ( ValueVT == <STR_LIT> && ! isPowerOf2_32 ( Val ) ) || ( ValueVT == <STR_LIT> && ! isPowerOf2_64 ( Val ) ) ) return SelectCode ( N ) ; BitPos = countTrailingZeros ( uint64_t ( Val ) ) ; } else { BitPos = <NUM_LIT> ; } unsigned BitOpc = <NUM_LIT> ; switch ( Opc ) { default : llvm_unreachable ( <STR_LIT> ) ; case <STR_LIT> : case <STR_LIT> : BitOpc = <STR_LIT> ; break ; case <STR_LIT> : BitOpc = <STR_LIT> ; break ; case <STR_LIT> : case <STR_LIT> : BitOpc =


<s> <STR_LIT> ExtType = LD -> getExtensionType ( ) ; bool IsZeroExt = ( ExtType == <STR_LIT> || ExtType == <STR_LIT> ) ; bool HasVecOffset = false ; if ( LoadedVT == <STR_LIT> ) { if ( HII -> isValidAutoIncImm ( LoadedVT , Val ) ) Opcode = <STR_LIT> ; else Opcode = <STR_LIT> ; } else if ( LoadedVT == <STR_LIT> ) { if ( HII -> isValidAutoIncImm ( LoadedVT , Val ) ) Opcode = <STR_LIT> ; else Opcode = <STR_LIT> ; } else if ( LoadedVT == <STR_LIT> ) { if ( HII -> isValidAutoIncImm ( LoadedVT , Val ) ) Opcode = IsZeroExt ? <STR_LIT> : <STR_LIT> ; else Opcode = IsZeroExt ? <STR_LIT> : <STR_LIT> ; } else if ( LoadedVT == <STR_LIT> ) { if ( HII -> isValidAutoIncImm ( LoadedVT , Val ) ) Opcode = IsZeroExt ? <STR_LIT> : <STR_LIT> ; else Opcode = IsZeroExt ? <STR_LIT> : <STR_LIT> ; } else if ( LoadedVT == <STR_LIT> || LoadedVT == <STR_LIT> || LoadedVT == <STR_LIT> || LoadedVT == <STR_LIT> ) { HasVecOffset = true ; if ( HII -> isValidAutoIncImm ( LoadedVT , Val ) ) { Opcode = <STR_LIT> ; } else Opcode = <STR_LIT> ; } else if ( LoadedVT == <STR_LIT> || LoadedVT == <STR_LIT> || LoadedVT == <STR_LIT> || LoadedVT == <STR_LIT> ) { HasVecOffset = true ; if ( HII -> isValidAutoIncImm ( LoadedVT , Val ) ) { Opcode = <STR_LIT> ; } else Opcode = <STR_LIT> ; } else llvm_unreachable ( <STR_LIT> ) ; if ( LD -> getValueType ( <NUM_LIT> ) == <STR_LIT> && IsZeroExt ) return SelectIndexedLoadZeroExtend64 ( LD


<s> const SDValue Tos [ ] = { SDValue ( Result , <NUM_LIT> ) , SDValue ( Result , <NUM_LIT> ) } ; ReplaceUses ( Froms , Tos , <NUM_LIT> ) ; } else { const SDValue Froms [ ] = { SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) } ; const SDValue Tos [ ] = { SDValue ( Result , <NUM_LIT> ) , SDValue ( Result , <NUM_LIT> ) , SDValue ( Result , <NUM_LIT> ) } ; ReplaceUses ( Froms , Tos , <NUM_LIT> ) ; } return Result ; } else { SDValue TargetConst0 = CurDAG -> getTargetConstant ( <NUM_LIT> , dl , <STR_LIT> ) ; SDValue TargetConstVal = CurDAG -> getTargetConstant ( Val , dl , <STR_LIT> ) ; SDNode * Result_1 = CurDAG -> getMachineNode ( Opcode , dl , LD -> getValueType ( <NUM_LIT> ) , <STR_LIT> , Base , TargetConst0 , Chain ) ; SDNode * Result_2 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , Base , TargetConstVal , SDValue ( Result_1 , <NUM_LIT> ) ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ; MemOp [ <NUM_LIT> ] = LD -> getMemOperand ( ) ; cast < MachineSDNode > ( Result_1 ) -> setMemRefs ( MemOp , MemOp + <NUM_LIT> ) ; const SDValue Froms [ ] = { SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) } ; const SDValue Tos [ ] = { SDValue ( Result_1 , <NUM_LIT> ) , SDValue ( Result_2 , <NUM_LIT> ) , SDValue ( Result_1 , <NUM_LIT> ) } ; ReplaceUses ( Froms , Tos , <NUM_LIT> ) ; return Result_1


<s> cast < MachineSDNode > ( Result_1 ) -> setMemRefs ( MemOp , MemOp + <NUM_LIT> ) ; const SDValue Froms [ ] = { SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) } ; const SDValue Tos [ ] = { SDValue ( Result_2 , <NUM_LIT> ) , SDValue ( Result_1 , <NUM_LIT> ) , SDValue ( Result_1 , <NUM_LIT> ) } ; ReplaceUses ( Froms , Tos , <NUM_LIT> ) ; return Result_2 ; } SDValue TargetConst0 = CurDAG -> getTargetConstant ( <NUM_LIT> , dl , <STR_LIT> ) ; SDValue TargetConstVal = CurDAG -> getTargetConstant ( Val , dl , <STR_LIT> ) ; SDNode * Result_1 = CurDAG -> getMachineNode ( Opcode , dl , <STR_LIT> , <STR_LIT> , Base , TargetConst0 , Chain ) ; SDNode * Result_2 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( Result_1 , <NUM_LIT> ) ) ; SDNode * Result_3 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , Base , TargetConstVal , SDValue ( Result_1 , <NUM_LIT> ) ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT>


<s> const SDValue Tos [ ] = { SDValue ( Result_2 , <NUM_LIT> ) , SDValue ( Result_1 , <NUM_LIT> ) , SDValue ( Result_1 , <NUM_LIT> ) } ; ReplaceUses ( Froms , Tos , <NUM_LIT> ) ; return Result_2 ; } SDValue TargetConst0 = CurDAG -> getTargetConstant ( <NUM_LIT> , dl , <STR_LIT> ) ; SDValue TargetConstVal = CurDAG -> getTargetConstant ( Val , dl , <STR_LIT> ) ; SDNode * Result_1 = CurDAG -> getMachineNode ( Opcode , dl , <STR_LIT> , <STR_LIT> , Base , TargetConst0 , Chain ) ; SDNode * Result_2 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , <STR_LIT> , TargetConst0 , SDValue ( Result_1 , <NUM_LIT> ) ) ; SDNode * Result_3 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , Base , TargetConstVal , SDValue ( Result_1 , <NUM_LIT> ) ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ; MemOp [ <NUM_LIT> ] = LD -> getMemOperand ( ) ; cast < MachineSDNode > ( Result_1 ) -> setMemRefs ( MemOp , MemOp + <NUM_LIT> ) ; const SDValue Froms [ ] = { SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) , SDValue ( LD ,


<s> else if ( StoredVT == <STR_LIT> || StoredVT == <STR_LIT> || StoredVT == <STR_LIT> || StoredVT == <STR_LIT> ) { Opcode = <STR_LIT> ; } else llvm_unreachable ( <STR_LIT> ) ; if ( ST -> isTruncatingStore ( ) && ValueVT . getSizeInBits ( ) == <NUM_LIT> ) { assert ( StoredVT . getSizeInBits ( ) < <NUM_LIT> && <STR_LIT> ) ; Value = CurDAG -> getTargetExtractSubreg ( <STR_LIT> , dl , <STR_LIT> , Value ) ; } SDValue Ops [ ] = { Base , CurDAG -> getTargetConstant ( Val , dl , <STR_LIT> ) , Value , Chain } ; SDNode * Result = CurDAG -> getMachineNode ( Opcode , dl , <STR_LIT> , <STR_LIT> , Ops ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ; MemOp [ <NUM_LIT> ] = ST -> getMemOperand ( ) ; cast < MachineSDNode > ( Result ) -> setMemRefs ( MemOp , MemOp + <NUM_LIT> ) ; ReplaceUses ( ST , Result ) ; ReplaceUses ( SDValue ( ST , <NUM_LIT> ) , SDValue ( Result , <NUM_LIT> ) ) ; return Result ; } SDValue Ops [ ] = { Base , CurDAG -> getTargetConstant ( <NUM_LIT> , dl , <STR_LIT> ) , Value , Chain } ; unsigned Opcode = <NUM_LIT> ; if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( StoredVT == <STR_LIT> || StoredVT == <STR_LIT> || StoredVT == <STR_LIT> || StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( StoredVT == <STR_LIT> || StoredVT == <STR_LIT> || StoredVT == <STR_LIT> || StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else llvm_unreachable (


<s> if ( HII -> isValidAutoIncImm ( LoadedVT , Val ) ) { SDValue TargetConst = CurDAG -> getTargetConstant ( Val , dl , <STR_LIT> ) ; SDNode * Result_1 = CurDAG -> getMachineNode ( Opcode , dl , <STR_LIT> , <STR_LIT> , <STR_LIT> , Base , TargetConst , Chain ) ; SDNode * Result_2 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( Result_1 , <NUM_LIT> ) ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ; MemOp [ <NUM_LIT> ] = LD -> getMemOperand ( ) ; cast < MachineSDNode > ( Result_1 ) -> setMemRefs ( MemOp , MemOp + <NUM_LIT> ) ; const SDValue Froms [ ] = { SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) } ; const SDValue Tos [ ] = { SDValue ( Result_2 , <NUM_LIT> ) , SDValue (

Result_1 , <NUM_LIT> ) , SDValue ( Result_1 , <NUM_LIT> ) } ;


<s> } RootWeights [ BasePtr . getNode ( ) ] = - <NUM_LIT> ; SDValue NewBasePtr = balanceSubTree ( BasePtr . getNode ( ) , true ) ; if ( N -> getOpcode ( ) == <STR_LIT> ) N = CurDAG -> UpdateNodeOperands ( N , N -> getOperand ( <NUM_LIT> ) , NewBasePtr , N -> getOperand ( <NUM_LIT> ) ) ; else N = CurDAG -> UpdateNodeOperands ( N , N -> getOperand ( <NUM_LIT> ) , N -> getOperand ( <NUM_LIT> ) , NewBasePtr , N -> getOperand ( <NUM_LIT> ) ) ; DEBUG ( dbgs ( ) << <STR_LIT> ) ; DEBUG ( N -> dump ( CurDAG ) ) ; } CurDAG -> RemoveDeadNodes ( ) ; GAUsesInFunction . clear ( ) ; RootHeights . clear ( ) ; RootWeights . clear (


<s> if ( SelectADDRriS11_2 ( N1 , CPTmpN1_0 , CPTmpN1_1 ) && N1 . getNode ( ) -> getValueType ( <NUM_LIT> ) == <STR_LIT> ) { const <ISA_LIT>InstrInfo * TII = static_cast < const <ISA_LIT>InstrInfo * > ( TM . getSubtargetImpl ( ) -> getInstrInfo ( ) ) ; if ( TII -> isValidAutoIncImm ( LoadedVT , Val ) ) { SDValue TargetConst = CurDAG -> getTargetConstant ( Val , <STR_LIT> ) ; SDNode * Result_1 = CurDAG -> getMachineNode ( Opcode , dl , <STR_LIT> , <STR_LIT> , <STR_LIT> , Base , TargetConst , Chain ) ; SDNode * Result_2 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( Result_1 , <NUM_LIT> ) ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ; MemOp [ <NUM_LIT> ] = LD -> getMemOperand ( ) ; cast < MachineSDNode > ( Result_1 ) -> setMemRefs ( MemOp , MemOp + <NUM_LIT> ) ; const SDValue Froms [ ] = { SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) } ; const SDValue Tos [ ] = { SDValue ( Result_2 , <NUM_LIT> ) , SDValue ( Result_1 , <NUM_LIT> ) , SDValue ( Result_1 , <NUM_LIT> ) } ; ReplaceUses ( Froms , Tos , <NUM_LIT> ) ; return Result_2 ; } SDValue TargetConst0 = CurDAG -> getTargetConstant ( <NUM_LIT> , <STR_LIT> ) ; SDValue TargetConstVal = CurDAG -> getTargetConstant ( Val , <STR_LIT> ) ; SDNode * Result_1 = CurDAG -> getMachineNode ( Opcode , dl , <STR_LIT> , <STR_LIT> , Base , TargetConst0 , Chain ) ; SDNode * Result_2 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( Result_1 , <NUM_LIT> ) ) ; SDNode * Result_3 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , Base , TargetConstVal , SDValue ( Result_1 , <NUM_LIT> ) ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray


<s> SDNode * <ISA_LIT>DAGToDAGISel :: SelectIndexedLoadZeroExtend64 ( LoadSDNode * LD , unsigned Opcode , SDLoc dl ) { SDValue Chain = LD -> getChain ( ) ; EVT LoadedVT = LD -> getMemoryVT ( ) ; SDValue Base = LD -> getBasePtr ( ) ; SDValue Offset = LD -> getOffset ( ) ; SDNode * OffsetNode = Offset . getNode ( ) ; int32_t Val = cast < ConstantSDNode > ( OffsetNode ) -> getSExtValue ( ) ; SDValue N1 = LD -> getOperand ( <NUM_LIT> ) ; SDValue CPTmpN1_0 ; SDValue CPTmpN1_1 ; if ( SelectADDRriS11_2 ( N1 , CPTmpN1_0 , CPTmpN1_1 ) && N1 . getNode ( ) -> getValueType ( <NUM_LIT> ) == <STR_LIT> ) { const <ISA_LIT>InstrInfo * TII = static_cast < const <ISA_LIT>InstrInfo * > ( TM . getSubtargetImpl ( ) -> getInstrInfo ( ) ) ; if ( TII -> isValidAutoIncImm ( LoadedVT , Val ) ) { SDValue TargetConstVal = CurDAG -> getTargetConstant ( Val , <STR_LIT> ) ; SDValue TargetConst0 = CurDAG -> getTargetConstant ( <NUM_LIT> , <STR_LIT> ) ; SDNode * Result_1 = CurDAG -> getMachineNode ( Opcode , dl , <STR_LIT> ,

<STR_LIT> , <STR_LIT> , Base , TargetConstVal , Chain ) ;


<s> const TargetRegisterInfo * TRI = TM . getRegisterInfo ( ) ; for ( unsigned i = <NUM_LIT> ; i < N -> getNumOperands ( ) ; ++ i ) { SDNode * Arg = N -> getOperand ( i ) . getNode ( ) ; const TargetRegisterClass * RC = TII -> getRegClass ( MCID , i , TRI ) ; if ( RC == <STR_LIT> || RC == <STR_LIT> ) { Ops . push_back ( SDValue ( Arg , <NUM_LIT> ) ) ; } else if ( RC == <STR_LIT> ) { SDNode * PdRs = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( Arg , <NUM_LIT> ) ) ; Ops . push_back ( SDValue ( PdRs , <NUM_LIT> ) ) ; } else if ( RC == NULL && ( dyn_cast < ConstantSDNode > ( Arg ) != NULL ) ) { int32_t Val = cast < ConstantSDNode > ( Arg ) -> getSExtValue ( ) ; SDValue SDVal = CurDAG -> getTargetConstant ( Val , <STR_LIT> ) ; Ops . push_back ( SDVal ) ; } else { llvm_unreachable ( <STR_LIT> ) ; } } EVT ReturnValueVT = N -> getValueType ( <NUM_LIT> ) ; SDNode * Result = CurDAG -> getMachineNode ( IntrinsicWithPred , dl , ReturnValueVT , Ops . data (


<s> FunctionPass * llvm :: create<ISA_LIT>ISelDag ( const <ISA_LIT>TargetMachine


<s> explicit <ISA_LIT>DAGToDAGISel ( const <ISA_LIT>TargetMachine & targetmachine , CodeGenOpt :: Level OptLevel ) : SelectionDAGISel ( targetmachine , OptLevel ) , Subtarget ( targetmachine . getSubtarget < <ISA_LIT>Subtarget > ( ) ) , TM ( targetmachine ) { initialize<ISA_LIT>DAGToDAGISelPass ( * PassRegistry :: getPassRegistry


<s> EVT LoadedVT = LD -> getMemoryVT ( ) ; int64_t Offset = cast < GlobalAddressSDNode > ( Base ) -> getOffset ( ) ; if ( Offset != <NUM_LIT> && OffsetFitsS11 ( LoadedVT , Offset ) ) { MVT PointerTy = TLI -> getPointerTy ( ) ; const GlobalValue * GV = cast < GlobalAddressSDNode > ( Base ) -> getGlobal ( ) ; SDValue TargAddr = CurDAG -> getTargetGlobalAddress ( GV , dl , PointerTy , <NUM_LIT> ) ; SDNode * NewBase = CurDAG -> getMachineNode ( <STR_LIT> , dl , PointerTy , TargAddr ) ; if ( LoadedVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( LoadedVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( LoadedVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( LoadedVT == <STR_LIT> ) Opcode = <STR_LIT> ; else llvm_unreachable ( <STR_LIT> ) ; SDValue TargetConstOff = CurDAG -> getTargetConstant ( Offset , PointerTy ) ; SDNode * Result = CurDAG -> getMachineNode ( Opcode , dl , LD -> getValueType ( <NUM_LIT> ) , <STR_LIT> , SDValue ( NewBase , <NUM_LIT> ) , TargetConstOff , Chain ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ; MemOp [ <NUM_LIT> ] =


<s> SDNode * Const32 = LD -> getBasePtr ( ) . getNode ( ) ; unsigned Opcode = <NUM_LIT> ; if ( Const32 -> getOpcode ( ) == <STR_LIT> && <STR_LIT> ( LD ) ) { SDValue Base = Const32 -> getOperand ( <NUM_LIT> ) ; EVT LoadedVT = LD -> getMemoryVT ( ) ; int64_t Offset = cast < GlobalAddressSDNode > ( Base ) -> getOffset ( ) ; if ( Offset != <NUM_LIT> && OffsetFitsS11 ( LoadedVT , Offset ) ) { MVT PointerTy = TLI -> getPointerTy ( ) ; const GlobalValue * GV = cast < GlobalAddressSDNode > ( Base ) -> getGlobal ( ) ; SDValue TargAddr = CurDAG -> getTargetGlobalAddress ( GV , dl , PointerTy , <NUM_LIT> ) ; SDNode * NewBase = CurDAG -> getMachineNode ( <STR_LIT> , dl , PointerTy , TargAddr ) ; if ( LoadedVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( LoadedVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( LoadedVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( LoadedVT == <STR_LIT> ) Opcode = <STR_LIT> ; else llvm_unreachable ( <STR_LIT> ) ; SDValue TargetConstOff = CurDAG -> getTargetConstant ( Offset , PointerTy ) ; SDNode * Result = CurDAG -> getMachineNode ( Opcode , dl , LD -> getValueType ( <NUM_LIT> ) , <STR_LIT> , SDValue ( NewBase , <NUM_LIT> ) , TargetConstOff , Chain ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ; MemOp [ <NUM_LIT> ] = LD -> getMemOperand ( ) ; cast < MachineSDNode > ( Result ) -> setMemRefs ( MemOp , MemOp + <NUM_LIT> ) ; ReplaceUses ( LD , Result ) ; return Result ; } } return SelectCode ( LD


<s> int64_t Offset = cast < GlobalAddressSDNode > ( Base ) -> getOffset ( ) ; if ( Offset != <NUM_LIT> && OffsetFitsS11 ( StoredVT , Offset ) ) { MVT PointerTy = TLI -> getPointerTy ( ) ; const GlobalValue * GV = cast < GlobalAddressSDNode > ( Base ) -> getGlobal ( ) ; SDValue TargAddr = CurDAG -> getTargetGlobalAddress ( GV , dl , PointerTy , <NUM_LIT> ) ; SDNode * NewBase = CurDAG -> getMachineNode ( <STR_LIT> , dl , PointerTy , TargAddr ) ; if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else llvm_unreachable ( <STR_LIT> ) ; SDValue Ops [ ] = { SDValue ( NewBase , <NUM_LIT> ) , CurDAG -> getTargetConstant ( Offset , PointerTy ) , Value , Chain } ; SDNode * Result = CurDAG -> getMachineNode ( Opcode , dl


<s> unsigned Opcode = <NUM_LIT> ; if ( ( Const32 -> getOpcode ( ) == <STR_LIT> ) && ! ( Value . getValueType ( ) == <STR_LIT> && ST -> isTruncatingStore ( ) ) ) { SDValue Base = Const32 -> getOperand ( <NUM_LIT> ) ; if ( Base . getOpcode ( ) == <STR_LIT> ) { EVT StoredVT = ST -> getMemoryVT ( ) ; int64_t Offset = cast < GlobalAddressSDNode > ( Base ) -> getOffset ( ) ; if ( Offset != <NUM_LIT> && OffsetFitsS11 ( StoredVT , Offset ) ) { MVT PointerTy = TLI -> getPointerTy ( ) ; const GlobalValue * GV = cast < GlobalAddressSDNode > ( Base ) -> getGlobal ( ) ; SDValue TargAddr = CurDAG -> getTargetGlobalAddress ( GV , dl , PointerTy , <NUM_LIT> ) ; SDNode * NewBase = CurDAG -> getMachineNode ( <STR_LIT> , dl , PointerTy , TargAddr ) ; if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else if ( StoredVT == <STR_LIT> ) Opcode = <STR_LIT> ; else llvm_unreachable ( <STR_LIT> ) ; SDValue Ops [ ] = { SDValue ( NewBase , <NUM_LIT> ) , CurDAG -> getTargetConstant ( Offset , PointerTy ) , Value , Chain } ; SDNode * Result = CurDAG -> getMachineNode ( Opcode , dl , <STR_LIT> , Ops ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ; MemOp [ <NUM_LIT> ] = ST -> getMemOperand


<s> return Result_2 ; } SDValue TargetConst0 = CurDAG -> getTargetConstant ( <NUM_LIT> , <STR_LIT> ) ; SDValue TargetConstVal = CurDAG -> getTargetConstant ( Val , <STR_LIT> ) ; SDNode * Result_1 = CurDAG -> getMachineNode ( Opcode , dl , <STR_LIT> , <STR_LIT> , Base , TargetConst0 , Chain ) ; SDNode * Result_2 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( Result_1 , <NUM_LIT> ) ) ; SDNode * Result_3 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , Base , TargetConstVal , SDValue ( Result_1 , <NUM_LIT> ) ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ; MemOp [ <NUM_LIT> ] = LD -> getMemOperand ( ) ; cast < MachineSDNode > ( Result_1 ) -> setMemRefs ( MemOp , MemOp + <NUM_LIT> ) ; const SDValue Froms [ ] = { SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) } ; const SDValue Tos [ ] = { SDValue ( Result_2 , <NUM_LIT> ) , SDValue ( Result_3 , <NUM_LIT> ) , SDValue ( Result_1 , <NUM_LIT> ) } ; ReplaceUses ( Froms , Tos , <NUM_LIT> ) ; return Result_2 ; } return SelectCode (


<s> SDNode * Arg = N -> getOperand ( i ) . getNode ( ) ; const TargetRegisterClass * RC = TII -> getRegClass ( MCID , i , TRI , * MF ) ; if ( RC == & <STR_LIT> || RC == & <STR_LIT> ) { Ops . push_back ( SDValue ( Arg , <NUM_LIT> ) ) ; } else if ( RC == & <STR_LIT> ) { SDNode * PdRs = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( Arg , <NUM_LIT> ) ) ; Ops . push_back ( SDValue ( PdRs , <NUM_LIT> ) ) ; } else if ( RC == NULL && ( dyn_cast < ConstantSDNode > ( Arg ) != NULL ) ) { int32_t Val = cast < ConstantSDNode > ( Arg ) -> getSExtValue ( ) ; SDValue SDVal = CurDAG -> getTargetConstant ( Val , <STR_LIT> ) ; Ops . push_back ( SDVal ) ; } else


<s> SDNode * <ISA_LIT>DAGToDAGISel :: SelectLoad ( SDNode * N ) { SDLoc dl ( N ) ; LoadSDNode * LD = cast < LoadSDNode > ( N ) ; <STR_LIT> AM = LD -> getAddressingMode ( ) ; if ( AM != <STR_LIT> ) return SelectIndexedLoad ( LD , dl ) ; if ( SDNode * LI = SelectLoadOfLoadIntrinsic ( LD ) ) return LI ; return SelectCode (


<s> SDNode * <ISA_LIT>DAGToDAGISel :: SelectLoad ( SDNode * N ) { SDLoc dl ( N ) ; LoadSDNode * LD = cast < LoadSDNode > ( N ) ; <STR_LIT> AM = LD -> getAddressingMode ( ) ; if ( AM != <STR_LIT> ) return SelectIndexedLoad ( LD , dl ) ; if ( SDNode * LI = SelectLoadOfLoadIntrinsic ( LD


<s> case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : IntExt = <STR_LIT> ; break ; case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : IntExt = <STR_LIT> ; break ; default : IntExt = <STR_LIT> ; break ; } if ( N -> getExtensionType ( ) != IntExt ) return nullptr ; if ( C -> getNumOperands ( ) < <NUM_LIT> || Loc . getNode ( ) != C -> getOperand ( <NUM_LIT> ) . getNode ( ) ) return nullptr ; if ( MachineSDNode * L = LoadInstrForLoadIntrinsic ( C ) ) { SDNode * S = StoreInstrForLoadIntrinsic ( L , C ) ; SDValue F [ ] = { SDValue ( N , <NUM_LIT> ) , SDValue ( N , <NUM_LIT> ) , SDValue (

C , <NUM_LIT> ) , SDValue ( C , <NUM_LIT> ) } ;


<s> if ( Size >= <NUM_LIT> ) TS = CurDAG -> getStore ( SDValue ( LoadN , <NUM_LIT> ) , dl , SDValue ( LoadN , <NUM_LIT> ) , Loc , PI , false , false , Size ) ; else TS = CurDAG -> getTruncStore ( SDValue ( LoadN , <NUM_LIT> ) , dl , SDValue ( LoadN , <NUM_LIT> ) , Loc , PI , <STR_LIT> ( Size * <NUM_LIT> ) , false , false , Size ) ; SDNode * StoreN = SelectStore ( TS . getNode ( ) ) ; ReplaceUses ( SDValue ( IntN , <NUM_LIT> ) , SDValue ( LoadN , <NUM_LIT> ) ) ; ReplaceUses ( SDValue ( IntN , <NUM_LIT> ) , SDValue ( StoreN , <NUM_LIT> ) ) ; return StoreN


<s> Deleter ( SelectionDAG & D , T & C ) : SelectionDAG :: DAGNodeDeletedListener ( D , [ & C ] ( SDNode * N , SDNode * E ) { C . erase (


<s> Deleter ( SelectionDAG & D , T & C ) : SelectionDAG :: DAGNodeDeletedListener ( D


<s> dbgs ( ) << <STR_LIT> ; } dbgs ( ) << <STR_LIT> ; auto ColorKindToName = [ ] ( ColorKind C ) { switch ( C ) { case ColorKind :: None : return <STR_LIT> ; case ColorKind :: Red : return <STR_LIT> ; case ColorKind :: Black : return <STR_LIT> ; } llvm_unreachable ( <STR_LIT> ) ; } ; dbgs ( ) << <STR_LIT> ; for ( auto C : Colors ) dbgs ( ) << <STR_LIT> << C . first << <STR_LIT> << ColorKindToName ( C . second ) << <STR_LIT> ; dbgs ( )


<s> continue ; } SDValue Vec ; unsigned M = I ; if ( M < VecLen ) { Vec = Va ; } else { Vec = Vb ; M -= VecLen ; } if ( HavePairs ) { if ( M < HwLen ) { Vec = DAG . getTargetExtractSubreg ( <STR_LIT> , dl , SingleTy , Vec ) ; } else { Vec = DAG . getTargetExtractSubreg ( <STR_LIT> , dl , SingleTy , Vec ) ; M -= HwLen ; } } SDValue Idx = DAG . getConstant ( M , dl , <STR_LIT> ) ; SDValue Ex = DAG . getNode ( <STR_LIT> , dl , LegalTy , { Vec , Idx } ) ; SDValue L = Lower . LowerOperation ( Ex , DAG ) ; assert ( L . getNode ( ) ) ; Ops . push_back ( L ) ; } SDValue LV ; if ( <NUM_LIT> * HwLen == VecLen ) { SDValue B0 = DAG . getBuildVector ( SingleTy , dl , { Ops . data ( ) , HwLen } ) ; SDValue L0 = Lower . LowerOperation ( B0 , DAG ) ; SDValue B1 = DAG . getBuildVector ( SingleTy , dl , { Ops . data ( ) + HwLen , HwLen } ) ; SDValue L1 = Lower . LowerOperation ( B1 , DAG ) ; LV = DAG . getNode ( <STR_LIT> , dl , ResTy , { L0 , L1 } ) ; } else { SDValue BV = DAG . getBuildVector ( ResTy , dl , Ops ) ; LV = Lower . LowerOperation ( BV , DAG ) ; } assert ( ! N -> use_empty ( ) ) ; ISel . ReplaceNode ( N , LV . getNode ( ) ) ; if ( AllNodes . count ( LV . getNode ( ) ) ) { DAG . RemoveDeadNodes ( ) ; return true ; } SetVector < SDNode * > SubNodes , TmpQ ; std :: map < SDNode * , unsigned > NumOps ; SubNodes . insert ( LV . getNode ( ) ) ; for ( unsigned I = <NUM_LIT> ; I != SubNodes . size ( ) ; ++ I ) { unsigned OpN = <NUM_LIT> ; SDNode * S = SubNodes [ I ] ; for ( SDValue Op : S -> ops ( ) ) { if ( AllNodes . count ( Op . getNode ( ) ) ) continue ; SubNodes . insert ( Op . getNode ( ) ) ; ++ OpN ; } NumOps . insert ( { S , OpN } ) ; if ( OpN == <NUM_LIT> ) TmpQ . insert ( S ) ; } for ( unsigned I = <NUM_LIT> ; I != TmpQ . size ( ) ; ++ I ) { SDNode * S = TmpQ [ I ] ; for ( SDNode * U : S -> uses ( ) ) { if ( ! SubNodes . count ( U )


<s> { N -> getOperand ( <NUM_LIT> ) , N -> getOperand ( <NUM_LIT> ) , N -> getOperand ( <NUM_LIT> ) } } ; SDVTList VTs = CurDAG -> getVTList ( <STR_LIT> , <STR_LIT> ) ; Result = CurDAG -> getMachineNode ( <STR_LIT> , SDLoc ( N ) , VTs , Ops ) ; break ; } case <STR_LIT> : { std :: array < SDValue , <NUM_LIT> > Ops = { { N -> getOperand ( <NUM_LIT> ) , N -> getOperand ( <NUM_LIT> ) , N -> getOperand ( <NUM_LIT> ) } } ; SDVTList VTs = CurDAG -> getVTList ( <STR_LIT> , <STR_LIT> ) ; Result = CurDAG -> getMachineNode ( <STR_LIT> , SDLoc ( N ) , VTs , Ops ) ; break ; } case <STR_LIT> : { std :: array < SDValue , <NUM_LIT> > Ops = { { N -> getOperand ( <NUM_LIT> ) , N -> getOperand ( <NUM_LIT> ) , N -> getOperand ( <NUM_LIT> ) } } ; SDVTList VTs = CurDAG -> getVTList ( <STR_LIT> , <STR_LIT> ) ; Result = CurDAG -> getMachineNode ( <STR_LIT> , SDLoc ( N ) , VTs , Ops ) ; break ; } default : llvm_unreachable ( <STR_LIT> ) ; } ReplaceUses ( N , Result ) ; ReplaceUses ( SDValue ( N , <NUM_LIT> ) , SDValue ( Result , <NUM_LIT> ) ) ; ReplaceUses ( SDValue ( N , <NUM_LIT> ) , SDValue ( Result , <NUM_LIT> ) ) ; CurDAG -> RemoveDeadNode (


<s> SDVTList VTs = CurDAG -> getVTList ( <STR_LIT> , <STR_LIT> ) ; Result = CurDAG -> getMachineNode ( <STR_LIT> , SDLoc ( N ) , VTs , Ops ) ; break ; } case <STR_LIT> : { std :: array < SDValue , <NUM_LIT> > Ops = { { N -> getOperand ( <NUM_LIT> ) , N -> getOperand ( <NUM_LIT> ) , N -> getOperand ( <NUM_LIT> ) } } ; SDVTList VTs = CurDAG -> getVTList ( <STR_LIT> , <STR_LIT> ) ; Result = CurDAG -> getMachineNode ( <STR_LIT> , SDLoc ( N ) , VTs , Ops ) ; break ; } case <STR_LIT> : { std :: array < SDValue , <NUM_LIT> > Ops = { { N -> getOperand ( <NUM_LIT> ) , N -> getOperand ( <NUM_LIT> ) , N -> getOperand ( <NUM_LIT> ) } } ; SDVTList VTs = CurDAG -> getVTList ( <STR_LIT> , <STR_LIT> ) ; Result = CurDAG -> getMachineNode ( <STR_LIT> , SDLoc ( N ) , VTs , Ops ) ; break ; } case <STR_LIT> : { std :: array < SDValue , <NUM_LIT> > Ops = { { N -> getOperand ( <NUM_LIT> ) , N -> getOperand ( <NUM_LIT> ) , N ->


<s> SDValue Base = N -> getOperand ( <NUM_LIT> ) ; SDValue Modifier = N -> getOperand ( <NUM_LIT> ) ; SDValue Offset = N -> getOperand ( <NUM_LIT> ) ; unsigned Opcode ; unsigned IntNo = cast < ConstantSDNode > ( N -> getOperand ( <NUM_LIT> ) ) -> getZExtValue ( ) ; switch ( IntNo ) { default : llvm_unreachable ( <STR_LIT> ) ; case <STR_LIT> : case <STR_LIT> : Opcode = <STR_LIT> ; break ; case <STR_LIT> : case <STR_LIT> : Opcode = <STR_LIT> ; break ; case <STR_LIT> : case <STR_LIT>


<s> unsigned IntNo = cast < ConstantSDNode > ( N -> getOperand ( <NUM_LIT> ) ) -> getZExtValue ( ) ; switch ( IntNo ) { default : llvm_unreachable ( <STR_LIT> ) ; case <STR_LIT> : case <STR_LIT> : Opcode = <STR_LIT> ; break ; case <STR_LIT> : case <STR_LIT> : Opcode = <STR_LIT> ; break ; case <STR_LIT> : case <STR_LIT> : Opcode = <STR_LIT> ; break ; } SDVTList VTs = CurDAG -> getVTList ( <STR_LIT> ) ; SDValue Ops [ ] = { Address , Predicate , Base , Modifier , Offset , Chain } ; SDNode * Result = CurDAG -> getMachineNode ( Opcode , dl , VTs , Ops ) ; MachineMemOperand * MemOp = cast < MemIntrinsicSDNode > ( N ) -> getMemOperand ( ) ; CurDAG -> setNodeMemRefs ( cast < MachineSDNode > ( Result ) , { MemOp } ) ; ReplaceNode ( N , Result )


<s> OpRef HvxSelector :: vmuxs ( ArrayRef < uint8_t > Bytes , OpRef Va , OpRef Vb , ResultStack & Results ) { DEBUG_WITH_TYPE ( <STR_LIT> , { dbgs ( ) << __func__ << '\n' ; } ) ; MVT ByteTy = getSingleVT ( <STR_LIT> ) ; MVT BoolTy = <STR_LIT> ( <STR_LIT> , HwLen ) ; const SDLoc & dl ( Results . InpNode ) ; SDValue B = getVectorConstant ( Bytes , dl ) ; Results . push ( <STR_LIT> , ByteTy , { } ) ; Results . push ( <STR_LIT> , BoolTy , { OpRef ( B ) , OpRef :: res ( - <NUM_LIT> ) } ) ; Results . push ( <STR_LIT> , ByteTy , { OpRef :: res ( - <NUM_LIT> ) , Vb , Va } ) ; return OpRef :: res ( Results . top ( )


<s> if ( S . second != unsigned ( L ) ) return OpRef :: fail ( ) ; if ( <NUM_LIT> * S . first != I ) return OpRef :: fail ( ) ; } for ( int I = L ; I < N ; I += <NUM_LIT> * L ) { auto S = findStrip ( SM . Mask . drop_front ( I ) , <NUM_LIT> , N - I ) ; if ( S . first != - <NUM_LIT> || S . second != unsigned ( L ) ) return OpRef :: fail ( ) ; } unsigned Opc = Strip . second == <NUM_LIT>


<s> SDValue HvxSelector :: getConst32 ( int Val , const SDLoc & dl ) { return DAG . getTargetConstant ( Val , dl


<s> SDValue HvxSelector :: getConst32 ( int Val , const SDLoc & dl ) { return DAG . getTargetConstant ( Val ,


<s> assert ( isPowerOf2_32 ( SegLen ) ) ; SmallVector < unsigned , <NUM_LIT> > SegList ; if ( SM . MaxSrc == - <NUM_LIT> ) return SegList ; unsigned Shift = Log2_32 ( SegLen ) ; BitVector Segs ( alignTo ( SM . MaxSrc + <NUM_LIT> , SegLen ) >> Shift ) ; for ( int I = <NUM_LIT> , E = SM . Mask . size ( ) ; I != E ; ++ I ) { int M = SM . Mask [ I ] ; if ( M >= <NUM_LIT> ) Segs . set ( M >> Shift ) ; } for ( unsigned B : Segs . set_bits ( ) ) SegList . push_back ( B


<s> unsigned NumElems = HwLen / ( ElemTy . getSizeInBits ( ) / <NUM_LIT>


<s> unsigned NumElems = HwLen / ( ElemTy . getSizeInBits


<s> OpRef Out [ <NUM_LIT> ] = { OpRef :: undef ( HalfTy ) , OpRef :: undef ( HalfTy ) } ; assert ( SegCount <= <NUM_LIT> ) ; for ( int I = <NUM_LIT> , E = SegList . size ( ) ; I != E ; ++ I ) { unsigned S = SegList [ I ] ; OpRef Op = Inp [ S / <NUM_LIT> ] ; Out [ I ] = ( S & <NUM_LIT> ) ? OpRef :: hi ( Op ) : OpRef :: lo ( Op ) ; } packSegmentMask ( SM . Mask , SegList , HwLen , NewMask ) ; return concats ( Out [ <NUM_LIT> ] , Out


<s> assert ( S != ~ <NUM_LIT> && <STR_LIT> ) ; assert ( S != ~ <NUM_LIT> && <STR_LIT> ) ; if ( InvMap . size ( ) <= S ) InvMap . resize ( S + <NUM_LIT> ) ; InvMap [ S ] = I ; } unsigned Shift = Log2_32 ( SegLen ) ; for ( int I = <NUM_LIT> , E = Mask . size ( ) ; I != E


<s> Vec = DAG . getTargetExtractSubreg ( <STR_LIT> , dl , SingleTy , Vec ) ; } else { Vec = DAG . getTargetExtractSubreg ( <STR_LIT> , dl , SingleTy , Vec ) ; M -= HwLen ; } } SDValue Idx = DAG . getConstant ( M , dl , <STR_LIT> ) ; SDValue Ex = DAG . getNode ( <STR_LIT> , dl , LegalTy , { Vec , Idx } ) ; SDValue L = Lower . LowerOperation ( Ex , DAG ) ; assert ( L . getNode ( ) ) ; Ops . push_back ( L ) ; } SDValue LV ; if ( <NUM_LIT> * HwLen == VecLen ) { SDValue B0 = DAG . getBuildVector ( SingleTy , dl , { Ops . data ( ) , HwLen } ) ; SDValue L0 = Lower . LowerOperation ( B0 , DAG ) ; SDValue B1 = DAG . getBuildVector ( SingleTy , dl , { Ops . data ( ) + HwLen , HwLen } ) ; SDValue L1 = Lower . LowerOperation ( B1 , DAG ) ; LV = DAG . getNode ( <STR_LIT> , dl , ResTy , { L0 , L1 } ) ; } else { SDValue BV = DAG . getBuildVector ( ResTy , dl , Ops ) ; LV = Lower . LowerOperation ( BV , DAG ) ; } assert ( ! N -> use_empty ( ) ) ; SDValue IS = DAG . getNode ( <STR_LIT> , dl , ResTy , LV ) ; ISel . ReplaceNode ( N , IS . getNode (


<s> for ( unsigned I = <NUM_LIT> ; I != SubNodes . size ( ) ; ++ I ) { SDNode * S = SubNodes [ I ] ; unsigned OpN = <NUM_LIT> ; for ( SDValue Op : S -> ops ( ) ) { SDNode * O = Op . getNode ( ) ; if ( llvm :: all_of ( O -> uses ( ) , InSubNodes ) ) { SubNodes . insert ( O ) ; ++ OpN ; } } NumOps . insert ( { S , OpN } ) ; if ( OpN == <NUM_LIT> ) TmpQ . insert ( S ) ; } for ( unsigned I = <NUM_LIT> ; I != TmpQ . size ( ) ; ++ I ) { SDNode * S = TmpQ [ I ] ; for ( SDNode * U : S -> uses ( ) ) { if ( U == ISelN ) continue ; auto F = NumOps . find ( U ) ; assert ( F != NumOps . end ( ) ) ; if ( F -> second > <NUM_LIT> && ! -- F -> second ) TmpQ . insert ( F -> first ) ; } } ISel . ReplaceNode ( ISelN , N0 ) ; assert ( SubNodes . size ( ) == TmpQ . size ( ) ) ; NullifyingVector < decltype ( TmpQ ) :: vector_type > Queue ( TmpQ . takeVector ( ) ) ; Deleter DUQ ( DAG , Queue ) ; for ( SDNode * S : reverse ( Queue ) ) { if ( S == nullptr ) continue ; DEBUG_WITH_TYPE ( <STR_LIT> , { dbgs ( ) << <STR_LIT> ; S -> dump ( & DAG ) ; } ) ; ISel . Select ( S


<s> for ( unsigned i = <NUM_LIT> ; i != WorkQ . size ( ) ; ++ i ) { SDNode * W = WorkQ [ i ] ; if ( ! W -> isMachineOpcode ( ) && W -> getOpcode ( ) == <STR_LIT> ) Nodes . push_back ( W ) ; for ( unsigned j = <NUM_LIT> , f = W -> getNumOperands ( ) ; j != f ; ++ j ) WorkQ . insert ( W


<s> OpRef L = shuffs1 ( PM . lo ( ) , P , Results ) ; OpRef H = shuffs1 ( PM . hi ( ) , P , Results ) ; if ( L . isValid ( ) && H . isValid ( ) ) return concats ( L , H , Results ) ; } OpRef R = perfect ( SM , Va , Results ) ; if ( R . isValid ( ) ) return R ; OpRef L = shuffs2 ( SM . lo ( ) , OpRef :: lo ( Va ) , OpRef :: hi ( Va ) , Results ) ; OpRef H = shuffs2 ( SM . hi ( ) , OpRef :: lo ( Va ) , OpRef


<s> std :: pair < int , unsigned > Strip2 = findStrip ( SM . Mask . drop_front ( HalfLen ) , <NUM_LIT> , HalfLen ) ; if ( Strip1 == Strip2 ) { const SDLoc & dl ( Results . InpNode ) ; Results . push ( <STR_LIT> , <STR_LIT> , { getConst32 ( HalfLen , dl ) } ) ; Results . push ( <STR_LIT> , getPairVT ( <STR_LIT> ) , { Va , Va , OpRef :: res ( Results . top ( ) ) } ) ; OpRef S = OpRef :: res ( Results . top ( ) ) ; return ( Strip1 . first == <NUM_LIT> ) ? OpRef :: lo ( S )


<s> OpRef C = contracting ( SM , Va , Vb , Results ) ; if ( C . isValid ( ) ) return C ; int VecLen = SM . Mask . size ( ) ; SmallVector < int , <NUM_LIT> > PackedMask ( VecLen ) ; OpRef P = packs ( SM , Va , Vb , Results , PackedMask ) ; if ( P . isValid ( ) ) return shuffs1 ( ShuffleMask ( PackedMask ) , P , Results ) ; SmallVector < int , <NUM_LIT> > MaskL ( VecLen ) , MaskR ( VecLen ) ; splitMask ( SM . Mask , MaskL , MaskR ) ; OpRef L = shuffs1 ( ShuffleMask ( MaskL ) , Va , Results ) ; OpRef R = shuffs1 ( ShuffleMask ( MaskR ) , Vb , Results ) ; if ( ! L . isValid ( ) || ! R . isValid ( ) ) return OpRef :: fail ( ) ; SmallVector < uint8_t , <NUM_LIT> > Bytes ( VecLen ) ; for ( int I = <NUM_LIT> ; I != VecLen ; ++ I ) { if ( MaskL [ I ] != - <NUM_LIT>


<s> OpRef P = packs ( SM , Va , Vb , Results , PackedMask ) ; if ( P . isValid ( ) ) return shuffs1 ( ShuffleMask ( PackedMask ) , P , Results ) ; SmallVector < int , <NUM_LIT> > MaskL ( VecLen ) , MaskR ( VecLen ) ; splitMask ( SM . Mask , MaskL , MaskR ) ; OpRef L = shuffs1 ( ShuffleMask ( MaskL ) , Va , Results ) ; OpRef R = shuffs1 ( ShuffleMask ( MaskR ) , Vb , Results ) ; if ( ! L . isValid ( ) || ! R . isValid ( ) ) return OpRef :: fail ( ) ; SmallVector < uint8_t , <NUM_LIT> > Bytes ( VecLen ) ; for ( int I = <NUM_LIT> ; I != VecLen ; ++ I ) { if ( MaskL [ I ] != - <NUM_LIT> )


<s> OpRef L = vmuxs ( Bytes . take_front ( S ) , OpRef :: lo ( Va ) , OpRef :: lo ( Vb ) , Results ) ; OpRef H = vmuxs ( Bytes . drop_front ( S ) , OpRef :: hi ( Va ) , OpRef :: hi ( Vb ) , Results ) ; return concats ( L , H , Results


<s> OpRef HvxSelector :: vmuxp ( ArrayRef < uint8_t > Bytes , OpRef Va , OpRef Vb , ResultStack & Results ) { DEBUG_WITH_TYPE ( <STR_LIT> , { dbgs ( ) << __func__ << '\n' ; } ) ; size_t S = Bytes . size ( ) / <NUM_LIT> ; OpRef L = vmuxs ( Bytes . take_front ( S ) , OpRef :: lo ( Va ) , OpRef :: lo ( Vb ) , Results ) ; OpRef H = vmuxs ( Bytes . drop_front ( S ) , OpRef :: hi ( Va ) , OpRef :: hi


<s> } else if ( SM . MinSrc > int ( HwLen ) ) { Va = Vb ; SM . MinSrc -= HwLen ; } const SDLoc & dl ( Results . InpNode ) ; SDValue S = DAG . getTargetConstant ( SM . MinSrc , dl , <STR_LIT> ) ; if ( isUInt < <NUM_LIT> > ( SM . MinSrc ) ) { Results . push ( <STR_LIT> , Ty , { Vb , Va , S } ) ; } else { Results . push ( <STR_LIT> , <STR_LIT> , { S } ) ; unsigned Top = Results . top ( ) ; Results . push ( <STR_LIT> , Ty , { Vb , Va , OpRef :: res ( Top ) } ) ; } for ( int I = <NUM_LIT> ; I != VecLen ; ++ I ) { int M = SM . Mask [ I ] ; if ( M != - <NUM_LIT> ) M -= SM . MinSrc ; NewMask [ I ] = M ; } return OpRef :: res ( Results . top ( ) ) ; } if ( Options & PackMux ) { BitVector Picked ( HwLen ) ; SmallVector < uint8_t , <NUM_LIT> > MuxBytes ( HwLen ) ; bool CanMux = true ; for ( int I = <NUM_LIT> ; I != VecLen ; ++ I ) { int M = SM . Mask [ I ] ; if ( M == - <NUM_LIT> ) continue ; if ( M >= int ( HwLen ) ) M -= HwLen ; else MuxBytes [ M


<s> unsigned Opc = N -> getOpcode ( ) ; if ( Opc == <STR_LIT> || Opc == <STR_LIT> ) return true ; if ( Opc == <STR_LIT> ) { if ( N -> getOperand ( <NUM_LIT> ) . getOpcode ( ) == <STR_LIT> ) return true ; } if ( Opc == <STR_LIT> ) { SDValue Addr = cast < LoadSDNode > ( N ) -> getBasePtr ( ) ; unsigned AddrOpc = Addr . getOpcode ( ) ; if ( AddrOpc == <STR_LIT> || AddrOpc == <STR_LIT> ) if ( Addr . getOperand ( <NUM_LIT> ) . getOpcode ( ) == <STR_LIT> ) return true ; } return false ; } ; WorkQ . insert ( N ) ; for ( unsigned i = <NUM_LIT> ; i != WorkQ . size ( ) ; ++ i ) { SDNode * W = WorkQ [ i ] ; if ( IsNodeToSelect ( W ) ) Nodes . push_back ( W ) ; for ( unsigned j = <NUM_LIT> , f = W -> getNumOperands ( ) ; j != f ; ++ j ) WorkQ . insert ( W -> getOperand ( j ) . getNode ( ) ) ; } for ( SDNode * L : Nodes )


<s> WorkQ . insert ( N ) ; for ( unsigned i = <NUM_LIT> ; i != WorkQ . size ( ) ; ++ i ) { SDNode * W = WorkQ [ i ] ; if ( IsNodeToSelect ( W ) ) Nodes . push_back ( W ) ; for ( unsigned j = <NUM_LIT> , f = W -> getNumOperands ( ) ; j != f ; ++ j ) WorkQ . insert ( W -> getOperand ( j ) . getNode ( ) ) ; } for ( SDNode * L : Nodes ) ISel .


<s> } for ( unsigned I = <NUM_LIT> ; I < WorkQ . size ( ) ; ++ I ) { Node N = WorkQ [ I ] ; NodeSet & Ns = Edges [ N ] ; auto P = getUniqueColor ( Ns ) ; if ( P . first ) { Colors [ N ] = other ( P . second ) ; continue ; } Node C = conj ( N ) ; uint8_t ColorN = other ( None ) ; uint8_t ColorC = other ( ColorN ) ; NodeSet & Cs = Edges [ C ] ; NodeSet CopyNs = Ns ; for ( Node M : CopyNs ) { uint8_t ColorM = getColor ( M ) ; if ( ColorM == ColorC ) { Cs . insert ( M ) ; Edges [ M ] . insert ( C ) ; Ns . erase ( M ) ; Edges [ M ] . erase ( N ) ; } } Colors [ N ] = ColorN ; Colors [ C ] = ColorC ; } for ( unsigned I = <NUM_LIT> ; I != Order . size ( ) ; ++ I ) if ( Colors . count ( I ) == <NUM_LIT> ) Colors [


<s> uint8_t ColorN = getColor ( N ) ; if ( ColorN == None ) continue ; if ( Color == None ) Color


<s> uint8_t Color = None ; for ( Node N : Nodes ) { uint8_t ColorN = getColor ( N ) ; if ( ColorN == None


<s> if ( Color == None ) return Red ; return Color == Red ?


<s> for ( ElemType J = <NUM_LIT> ; J != Num ; ++ J ) { ElemType I = P [ J ] ; if ( I == Ignore ) continue ; uint8_t C = M . at ( I ) ; if ( C == Coloring :: None ) continue ; if ( ColorUp == Coloring :: None ) { ColorUp = ( I < Num / <NUM_LIT> ) ? Coloring :: Red : Coloring :: Black ; } unsigned CI = ( I < Num / <NUM_LIT> ) ? I + Num / <NUM_LIT> : I - Num / <NUM_LIT> ; if ( C == ColorUp ) { if ( I < Num / <NUM_LIT> ) T [ I ] [ Step ] = Pass ; else T [ CI ] [ Step ] = Switch ; T [ J ] [ Pets ] = ( J < Num / <NUM_LIT> ) ? Pass : Switch ; UseUp = true ; } else { if ( I < Num / <NUM_LIT> ) T [ CI ] [ Step ] = Switch ; else T [ I ] [ Step ] = Pass ; T [ J ] [ Pets ] = ( J < Num / <NUM_LIT> ) ? Switch : Pass ; UseDown = true ; } } for ( ElemType J = <NUM_LIT> ; J != Num / <NUM_LIT> ; ++ J ) { ElemType PJ = P [ J ] ; ElemType PC = P [ J + Num / <NUM_LIT> ] ; ElemType QJ = PJ ; ElemType QC = PC ; if ( T [ J ] [ Pets ] == Switch ) QC = PJ ; if ( T [ J + Num / <NUM_LIT> ] [ Pets ] == Switch ) QJ = PC ; P [ J ] = QJ ; P [ J + Num / <NUM_LIT> ] = QC ; } for ( ElemType J = <NUM_LIT> ; J != Num ; ++ J ) if ( P [ J ] != Ignore && P [ J ] >= Num / <NUM_LIT> ) P [ J ] -= Num / <NUM_LIT> ; if ( Step + <NUM_LIT> < Log ) { if ( UseUp && ! route ( P , T , Size / <NUM_LIT> , Step + <NUM_LIT> ) ) return false ; if ( UseDown && ! route ( P + Size / <NUM_LIT> , T + Size / <NUM_LIT> , Size / <NUM_LIT> , Step + <NUM_LIT> ) ) return false ; } return


<s> for ( unsigned i = <NUM_LIT> ; i != WorkQ . size ( ) ; ++ i ) { SDNode * W = WorkQ [ i ] ; if ( IsLoadToSelect ( W ) ) { Loads . push_back ( W ) ; continue ; } for ( unsigned j = <NUM_LIT> , f = W -> getNumOperands ( ) ; j != f ; ++ j ) WorkQ . push_back ( W -> getOperand ( j ) . getNode ( ) ) ; } for ( SDNode * L : Loads ) ISel . Select


<s> if ( unsigned SingleOpc = pfs ( Cycles , LogLen ) ) { Results . push ( SingleOpc , SingleTy , { Va } ) ; return OpRef :: res ( Results . top ( ) ) ; } } SmallVector < unsigned , <NUM_LIT> > SwapElems ; if ( ! HavePairs ) SwapElems . push_back ( LogLen - <NUM_LIT> ) ; for ( const CycleType & C : Cycles ) { unsigned First = ( C [ <NUM_LIT> ] == LogLen - <NUM_LIT> ) ? <NUM_LIT> : <NUM_LIT> ; SwapElems . append ( C . begin ( ) + First , C . end ( ) ) ; if ( First == <NUM_LIT> ) SwapElems . push_back ( C [ <NUM_LIT> ] ) ; } if ( ! HavePairs ) SwapElems . push_back ( LogLen - <NUM_LIT> ) ; const SDLoc & dl ( Results . InpNode ) ; OpRef Arg = HavePairs ? Va : concat ( Va , OpRef :: undef ( SingleTy ) , Results ) ; if ( InvertedPair ) Arg = concat ( OpRef :: hi ( Arg ) , OpRef :: lo ( Arg ) , Results ) ; for ( unsigned I = <NUM_LIT> , E = SwapElems . size ( ) ; I != E ; ) { bool IsInc = I == E - <NUM_LIT> || SwapElems [ I ] < SwapElems [ I + <NUM_LIT> ] ; unsigned S = ( <NUM_LIT> << SwapElems [ I ] ) ; if ( I < E - <NUM_LIT> ) { while ( ++ I < E - <NUM_LIT> && IsInc == ( SwapElems [ I ] < SwapElems [ I + <NUM_LIT> ] ) ) S |= <NUM_LIT> << SwapElems [ I ] ; S |= <NUM_LIT> << SwapElems [ I ] ; } ++ I ; NodeTemplate Res ; Results . push ( <STR_LIT> , <STR_LIT> , { DAG . getTargetConstant ( S , dl , <STR_LIT> ) } ) ; Res . Opc = IsInc ? <STR_LIT> : <STR_LIT> ; Res . Ty = PairTy ; Res . Ops = { OpRef :: hi ( Arg ) , OpRef :: lo ( Arg ) , OpRef :: res ( - <NUM_LIT> ) } ; Results . push ( Res ) ; Arg = OpRef :: res ( Results . top ( ) ) ; } return HavePairs ? Arg : OpRef :: lo (


<s> return X ; } ; assert ( VecLen > <NUM_LIT> ) ; for ( unsigned I = VecLen ; I >= <NUM_LIT> ; I >>= <NUM_LIT> ) { unsigned X = XorPow2 ( LocalMask , I ) ; if ( ! isPowerOf2_32 ( X ) ) return OpRef :: fail ( ) ; for ( int J = I ; J < VecLen ; J += I ) { if ( XorPow2 ( LocalMask . slice ( J , I ) , I ) != X ) return OpRef :: fail ( ) ; } Perm [ Log2_32 ( X ) ] = Log2_32 ( I ) - <NUM_LIT> ; } using CycleType = SmallVector < unsigned , <NUM_LIT> > ; std :: set < CycleType > Cycles ; std :: set < unsigned > All ; for ( unsigned I : Perm ) All . insert ( I ) ; auto canonicalize = [ LogLen ] ( const CycleType & C ) -> CycleType { unsigned LogPos , N = C . size ( ) ; for ( LogPos = <NUM_LIT> ; LogPos != N ; ++ LogPos ) if ( C [ LogPos ] == LogLen - <NUM_LIT> ) break ; if ( LogPos == N ) return C ; CycleType NewC ( C . begin ( ) + LogPos , C . end ( ) ) ; NewC . append ( C . begin ( ) , C . begin ( ) + LogPos ) ; return NewC ; } ; auto pfs = [ ] ( const std :: set < CycleType > & Cs , unsigned Len ) { if ( Cs . size ( ) != <NUM_LIT> ) return <NUM_LIT> ; const CycleType & C = * Cs . begin ( ) ; if ( C [ <NUM_LIT> ] != Len - <NUM_LIT> ) return <NUM_LIT> ; int D = Len - C . size ( ) ; if ( D != <NUM_LIT> && D != <NUM_LIT> ) return <NUM_LIT> ; bool IsDeal = true , IsShuff = true ; for ( unsigned I = <NUM_LIT> ; I != Len - D ; ++ I ) { if ( C [ I ] != Len - <NUM_LIT> - I ) IsDeal = false ; if ( C [ I ] != I - ( <NUM_LIT> - D ) ) IsShuff = false ; } assert ( ! ( IsDeal || IsShuff ) || IsDeal != IsShuff ) ; static unsigned Deals [ ] = { <STR_LIT> , <STR_LIT> } ; static unsigned Shufs [ ] = { <STR_LIT> , <STR_LIT> } ; return IsDeal ? Deals [ D ] : ( IsShuff ? Shufs [ D ] : <NUM_LIT> ) ; } ; while ( ! All . empty ( ) ) { unsigned A = * All . begin ( ) ; All . erase ( A ) ; CycleType C ; C . push_back ( A ) ; for ( unsigned B = Perm [ A ] ; B != A ; B


<s> Op = ( Part == OpRef :: HiHalf ) ? Op . getOperand ( <NUM_LIT> ) : Op . getOperand ( <NUM_LIT> ) ; } else { MVT HalfTy = <STR_LIT> ( OpTy . getVectorElementType ( ) , OpTy . getVectorNumElements ( ) / <NUM_LIT> ) ; unsigned Sub = ( Part == OpRef :: LoHalf ) ? <STR_LIT> : <STR_LIT> ; Op = DAG . getTargetExtractSubreg ( Sub , dl , HalfTy , Op ) ; } } Ops . push_back ( Op ) ; } assert ( Node . Ty != <STR_LIT> ) ; SDNode * ResN = ( Node . Opc == TargetOpcode :: COPY ) ? Ops . front ( ) . getNode ( ) : DAG . getMachineNode ( Node . Opc , dl , Node . Ty , Ops ) ; Output . push_back ( SDValue ( ResN , <NUM_LIT> ) ) ; } SDNode * OutN = Output . back ( ) . getNode ( ) ; SDNode * InpN = Results . InpNode ; DEBUG_WITH_TYPE ( <STR_LIT> , { dbgs ( ) << <STR_LIT> ; OutN -> dumpr ( & DAG ) ; } ) ; ISel . ReplaceNode ( InpN , OutN ) ; selectVectorConstants ( OutN )


<s> unsigned S = CN -> getZExtValue ( ) % HST . getVectorLength ( ) ; if ( S == <NUM_LIT> ) { NewN = VecV . getNode ( ) ; } else if ( isUInt < <NUM_LIT> > ( S ) ) { SDValue C = DAG . getTargetConstant ( S , dl , <STR_LIT> ) ; NewN = DAG . getMachineNode ( <STR_LIT> , dl , Ty , { VecV , VecV , C } ) ; } } if ( ! NewN ) NewN = DAG . getMachineNode ( <STR_LIT> , dl ,


<s> MVT Ty = N -> getValueType ( <NUM_LIT> ) . getSimpleVT ( ) ; const SDLoc & dl ( N ) ; SDValue VecV = N -> getOperand ( <NUM_LIT> ) ; SDValue RotV = N -> getOperand ( <NUM_LIT> ) ; SDNode * NewN = nullptr ; if ( auto * CN = dyn_cast < ConstantSDNode > ( RotV . getNode ( )


<s> } ) ; MVT ResTy = N -> getValueType ( <NUM_LIT> ) . getSimpleVT ( ) ; assert ( ResTy . isVector ( ) && ResTy . getVectorElementType ( ) == <STR_LIT> ) ; auto * SN = cast < ShuffleVectorSDNode > ( N ) ; std :: vector < int > Mask ( SN -> getMask ( ) . begin ( ) , SN -> getMask ( ) . end ( ) ) ; for ( int & Idx : Mask ) if ( Idx != - <NUM_LIT> && Idx < <NUM_LIT> ) Idx = - <NUM_LIT> ; unsigned VecLen = Mask . size ( ) ; bool HavePairs = ( <NUM_LIT> * HwLen == VecLen ) ; assert ( ResTy . getSizeInBits ( ) / <NUM_LIT> == VecLen ) ; bool UseLeft = false , UseRight = false ; for ( unsigned I = <NUM_LIT> ; I != VecLen ; ++ I ) { if ( Mask [ I ] == - <NUM_LIT> ) continue ; unsigned Idx = Mask [ I ] ; assert ( Idx < <NUM_LIT> * VecLen ) ; if ( Idx < VecLen ) UseLeft = true ; else UseRight = true ; } DEBUG_WITH_TYPE ( <STR_LIT> , { dbgs ( ) << <STR_LIT> << VecLen << <STR_LIT> << HwLen << <STR_LIT> << UseLeft << <STR_LIT> << UseRight << <STR_LIT> << HavePairs << '\n' ; } ) ; if ( ! UseLeft && ! UseRight ) { ISel . ReplaceNode ( N , ISel . selectUndef ( SDLoc ( SN ) , ResTy ) . getNode ( ) ) ; DAG . RemoveDeadNode ( N ) ; return ; } SDValue Vec0 = N -> getOperand ( <NUM_LIT> ) ; SDValue Vec1 = N -> getOperand ( <NUM_LIT> ) ; ResultStack Results ( SN ) ; Results . push ( TargetOpcode :: COPY , ResTy , { Vec0 } ) ; Results . push ( TargetOpcode :: COPY , ResTy , { Vec1 } ) ; OpRef Va = OpRef :: res ( Results . top ( ) - <NUM_LIT> ) ; OpRef Vb = OpRef :: res ( Results . top ( ) ) ; OpRef Res = ! HavePairs ? shuffs2 ( ShuffleMask ( Mask ) , Va , Vb , Results ) : shuffp2 ( ShuffleMask ( Mask ) , Va , Vb , Results ) ; bool Done = Res . isValid ( ) ; if (


<s> MVT ResTy = N -> getValueType ( <NUM_LIT> ) . getSimpleVT ( ) ; assert ( ResTy . isVector ( ) && ResTy . getVectorElementType ( ) == <STR_LIT> ) ; auto * SN = cast < ShuffleVectorSDNode > ( N ) ; std :: vector < int > Mask ( SN -> getMask ( ) . begin ( ) , SN -> getMask ( ) . end ( ) ) ; for ( int & Idx : Mask ) if ( Idx != - <NUM_LIT> && Idx < <NUM_LIT> ) Idx = - <NUM_LIT> ; unsigned VecLen = Mask . size ( ) ; bool HavePairs = ( <NUM_LIT> * HwLen == VecLen ) ; assert ( ResTy . getSizeInBits ( ) / <NUM_LIT> == VecLen ) ; bool UseLeft = false , UseRight = false ; for ( unsigned I = <NUM_LIT> ; I != VecLen ; ++ I ) { if ( Mask [ I ] == - <NUM_LIT> ) continue ; unsigned Idx = Mask [ I ] ; assert ( Idx < <NUM_LIT> * VecLen ) ; if ( Idx < VecLen ) UseLeft = true ; else UseRight = true ; } DEBUG_WITH_TYPE ( <STR_LIT> , { dbgs ( ) << <STR_LIT> << VecLen << <STR_LIT> << HwLen << <STR_LIT> << UseLeft << <STR_LIT> << UseRight << <STR_LIT> << HavePairs << '\n' ; } )


<s> Opcode = <STR_LIT> ; break ; case <STR_LIT> : case <STR_LIT> : Opcode = <STR_LIT> ; break ; } SDVTList VTs = CurDAG -> getVTList ( <STR_LIT> ) ; SDValue Ops [ ] = { Address , Base , Modifier , Offset , Chain } ; SDNode * Result = CurDAG -> getMachineNode ( Opcode , dl , VTs , Ops ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ; MemOp [ <NUM_LIT> ] = cast < MemIntrinsicSDNode > ( N ) -> getMemOperand ( ) ; cast < MachineSDNode > ( Result ) -> setMemRefs ( MemOp , MemOp + <NUM_LIT> ) ; ReplaceUses ( N ,


<s> llvm_unreachable ( <STR_LIT> ) ; case <STR_LIT> : case <STR_LIT> : Opcode = <STR_LIT> ; break ; case <STR_LIT> : case <STR_LIT> : Opcode = <STR_LIT> ; break ; case <STR_LIT> : case <STR_LIT> : Opcode = <STR_LIT> ; break ; } SDVTList VTs = CurDAG -> getVTList ( <STR_LIT> ) ; SDValue Ops [ ] = { Address , Predicate , Base , Modifier , Offset , Chain } ; SDNode * Result = CurDAG -> getMachineNode ( Opcode ,


<s> SmallVector < SDNode * , <NUM_LIT> > Loads ; SetVector < SDNode * > WorkQ ; auto IsLoadToSelect = [ ] ( SDNode * N ) { if ( ! N -> isMachineOpcode ( ) && N -> getOpcode ( ) == <STR_LIT> ) { SDValue Addr = cast < LoadSDNode > ( N ) -> getBasePtr ( ) ; unsigned AddrOpc = Addr . getOpcode ( ) ; if ( AddrOpc == <STR_LIT> || AddrOpc == <STR_LIT> ) if ( Addr . getOperand ( <NUM_LIT> ) . getOpcode ( ) == <STR_LIT> ) return true ; } return false ; } ; WorkQ . insert ( N ) ; for ( unsigned i = <NUM_LIT> ; i != WorkQ . size ( ) ; ++ i ) { SDNode * W = WorkQ [ i


<s> OpRef R = shuffp1 ( ShuffleMask ( MaskR ) , Vb , Results ) ; if ( ! L . isValid ( ) || ! R . isValid ( ) ) return OpRef :: fail ( ) ; SmallVector < uint8_t , <NUM_LIT> > Bytes ( VecLen ) ; for ( int I = <NUM_LIT> ; I != VecLen ; ++ I ) { if ( MaskL [ I ] != - <NUM_LIT> ) Bytes [ I ] = <NUM_LIT> ; } return vmuxp ( Bytes , L , R


<s> for ( int Idx : Mask ) { if ( Idx == - <NUM_LIT> ) return false ; Sum += Idx ; } int N = Mask . size ( ) ; return <NUM_LIT> * Sum == N *


<s> } if ( ! HasUnused ) return Va ; SDValue B = getVectorConstant ( UsedBytes , SDLoc ( Results . InpNode ) ) ; Results . push ( <STR_LIT> , getSingleVT ( <STR_LIT> ) , { Va , OpRef ( B ) } ) ; return OpRef :: res ( Results .


<s>
for
(
Node
P
:
Order
)
{
if
(
P
!=
Ignore
)
dbgs
(
)
<<
' '
<<
P
;
else
dbgs
(
)
<<
<STR_LIT>
;
}
dbgs
(
)
<<
<STR_LIT>
;
dbgs
(
)
<<
<STR_LIT>
;
for
(
Node
N
:
Needed
)
dbgs
(
)
<<
' '
<<
N
;
dbgs
(
)
<<
<STR_LIT>
;
dbgs
(
)
<<
<STR_LIT>
;
for
(
auto
E
:
Edges
)
{
dbgs
(
)
<<
<STR_LIT>
<<
E
.
first
<<
<STR_LIT>
;
for
(
auto
N
:
E
.
second
)
dbgs
(
)
<<
' '
<<
N
;
dbgs
(
)
<<
<STR_LIT>
;
}
dbgs
(
)
<<
<STR_LIT>
;
auto
ColorKindToName
=
[
]
(
ColorKind
C
)
{
switch
(
C
)
{
case
ColorKind
::
:
return
<STR_LIT>


<s> assert ( isPowerOf2_32 ( SegLen ) ) ; SmallVector < unsigned , <NUM_LIT> > SegList ; if ( SM . MaxSrc == - <NUM_LIT> ) return SegList ; unsigned Shift = Log2_32 ( SegLen ) ; BitVector Segs ( alignTo ( SM . MaxSrc + <NUM_LIT> , SegLen ) >> Shift ) ; for ( int M : SM . Mask ) { if ( M >= <NUM_LIT> ) Segs . set ( M >> Shift ) ; } for ( unsigned B : Segs . set_bits ( ) ) SegList . push_back ( B ) ; return SegList


<s> Opcode = <STR_LIT> ; break ; case <STR_LIT> : case <STR_LIT> : Opcode = <STR_LIT> ; break ; } SDVTList VTs = CurDAG -> getVTList ( <STR_LIT> ) ; SDValue Ops [ ] = { Address , ImmOperand , Base , Modifier , Offset , Chain } ; SDNode * Result = CurDAG -> getMachineNode ( Opcode , dl , VTs , Ops ) ; MachineMemOperand * MemOp = cast < MemIntrinsicSDNode > ( N ) -> getMemOperand ( ) ; CurDAG -> setNodeMemRefs ( cast < MachineSDNode > ( Result ) , { MemOp } ) ; ReplaceNode ( N , Result


<s> case <STR_LIT> : case <STR_LIT> : Opcode = <STR_LIT> ; break ; } SDVTList VTs = CurDAG -> getVTList ( <STR_LIT> ) ; SDValue Ops [ ] = { Address , ImmOperand , Predicate , Base , Modifier , Offset , Chain } ; SDNode * Result = CurDAG -> getMachineNode ( Opcode , dl , VTs , Ops ) ; MachineMemOperand * MemOp = cast < MemIntrinsicSDNode > ( N ) -> getMemOperand ( ) ; CurDAG -> setNodeMemRefs ( cast < MachineSDNode > ( Result ) ,


<s> ShuffleMask ( ArrayRef < int > M ) : Mask ( M ) { for ( int M : Mask ) { if ( M == - <NUM_LIT>


<s> return G . getSubtarget < <ISA_LIT>Subtarget > (


<s> } } for ( unsigned I = <NUM_LIT> ; I != Order . size ( ) ; ++ I ) { if ( ! Needed . count ( I ) ) continue ; Node C = conj ( I ) ; NodeSet & Is = Edges


<s> if ( PC != Ignore && PC != I ) Edges [ I ] . insert ( PC ) ; } } for ( unsigned I = <NUM_LIT> ; I != Order . size ( ) ; ++ I ) { if ( ! Needed . count ( I ) ) continue ; Node C = conj ( I


<s> const SDLoc & dl ( Results . InpNode ) ; int VecLen = SM . Mask . size ( ) ; for ( int M : SM . Mask ) { if ( M != - <NUM_LIT> && M >= VecLen ) return OpRef :: fail ( ) ; } ForwardDeltaNetwork FN ( SM . Mask ) ; if ( FN . run ( FC ) ) { SDValue Ctl = getVectorConstant ( FC , dl ) ; Results . push ( <STR_LIT> , ResTy , { Va , OpRef ( Ctl ) } ) ; return OpRef :: res ( Results . top ( ) ) ; } ReverseDeltaNetwork RN ( SM . Mask ) ; if ( RN . run ( RC ) ) { SDValue Ctl = getVectorConstant ( RC , dl ) ; Results . push ( <STR_LIT> , ResTy , { Va ,


<s> if ( ! P . first ) return false ; Colors [ N ] = other ( P . second ) ; } for ( auto E : Edges ) { Node N = E . first ; if ( ! Needed . count ( conj ( N ) ) || Colors . count ( N ) ) continue ; auto P = getUniqueColor ( E . second ) ; if ( ! P . first ) return false ; Colors [ N ] = other ( P . second ) ; } std :: vector < Node > WorkQ ; for ( auto E : Edges ) { Node N = E . first ; if ( ! Colors . count ( N ) ) WorkQ . push_back ( N ) ; } for ( unsigned I = <NUM_LIT> ; I < WorkQ . size ( ) ; ++ I ) { Node N = WorkQ [ I ] ; NodeSet & Ns = Edges [


<s> NodeSet & Ns = Edges [ N ] ; auto P = getUniqueColor ( Ns ) ; if ( P . first ) { Colors [ N ] = other ( P . second ) ; continue ; } Node C = conj ( N ) ; ColorKind ColorN = other ( ColorKind :: None ) ; ColorKind ColorC = other ( ColorN ) ; NodeSet & Cs = Edges [ C ] ; NodeSet CopyNs = Ns ; for ( Node M : CopyNs ) { ColorKind ColorM = getColor ( M ) ; if ( ColorM == ColorC ) { Cs . insert ( M ) ; Edges [ M ] . insert ( C ) ; Ns . erase ( M ) ; Edges [ M ] . erase ( N ) ; } } Colors [ N ] = ColorN ; Colors [ C ] = ColorC ; } for ( unsigned I = <NUM_LIT> ; I != Order . size ( ) ; ++ I ) if ( Colors . count

( I ) == <NUM_LIT> ) Colors [ I ] = ColorKind :: None ;


<s> Results . push ( TargetOpcode :: REG_SEQUENCE , getPairVT ( <STR_LIT> ) , { DAG . getTargetConstant ( <STR_LIT> , dl , <STR_LIT> ) , Lo , DAG . getTargetConstant ( <STR_LIT> , dl , <STR_LIT> ) , Hi , DAG . getTargetConstant ( <STR_LIT> , dl


<s> DAG . getTargetConstant ( <STR_LIT> , dl , <STR_LIT> ) , Lo , DAG . getTargetConstant ( <STR_LIT> , dl , <STR_LIT> ) ,

Hi , DAG . getTargetConstant ( <STR_LIT> , dl , <STR_LIT> ) , } ) ;


<s> return ( Pos < Num / <NUM_LIT> ) ? Pos + Num


<s> int NextInMask = SM . Mask [ Strip . second ] ; if ( NextInMask < VecLen ) { if ( Strip . first == <NUM_LIT> && Strip . second == <NUM_LIT> && NextInMask == <NUM_LIT> ) { int N = VecLen ; for ( int I = <NUM_LIT> ; I != N / <NUM_LIT> ; ++ I ) if ( SM . Mask [ I ] != <NUM_LIT> * I ) return OpRef :: fail ( ) ; for ( int I = <NUM_LIT> ; I != N / <NUM_LIT> ; ++ I ) if ( SM . Mask [ I + N / <NUM_LIT> ] != <NUM_LIT> + <NUM_LIT> * I ) return OpRef :: fail ( ) ; for ( int I = <NUM_LIT> ; I != N / <NUM_LIT> ; ++ I ) if ( SM . Mask [ I + N / <NUM_LIT> ] != N + <NUM_LIT> * I ) return OpRef :: fail ( ) ; for ( int I = <NUM_LIT> ; I != N / <NUM_LIT> ; ++ I ) if ( SM . Mask [ I + <NUM_LIT> * N / <NUM_LIT> ] != N + <NUM_LIT> + <NUM_LIT> * I ) return OpRef :: fail ( ) ; Results . push ( <STR_LIT> , ResTy , { Vb , Va } ) ; return OpRef :: res ( Results . top ( ) ) ; } int N = VecLen ; int L = Strip . second ; if ( Strip . first != <NUM_LIT> && Strip . first != L ) return OpRef :: fail ( ) ; for ( int I = L ; I < N ; I += L ) { auto S = findStrip ( SM . Mask . drop_front ( I ) , <NUM_LIT> , N - I ) ; if ( S . first - Strip . first != <NUM_LIT> * I ) return OpRef :: fail ( ) ; if ( S . second != unsigned ( L ) ) return OpRef :: fail ( ) ; } assert ( Strip . first == <NUM_LIT> || Strip . first == L ) ; using namespace <ISA_LIT>


<s> if ( Strip . first == <NUM_LIT> && Strip . second == <NUM_LIT> && NextInMask == <NUM_LIT> ) { int N = VecLen ; for ( int I = <NUM_LIT> ; I != N / <NUM_LIT> ; ++ I ) if ( SM . Mask [ I ] != <NUM_LIT> * I ) return OpRef :: fail ( ) ; for ( int I = <NUM_LIT> ; I != N / <NUM_LIT> ; ++ I ) if ( SM . Mask [ I + N / <NUM_LIT> ] != <NUM_LIT> + <NUM_LIT> * I ) return OpRef :: fail ( ) ; for ( int I = <NUM_LIT> ; I != N / <NUM_LIT> ; ++ I ) if ( SM . Mask [ I + N / <NUM_LIT> ] != N + <NUM_LIT> * I ) return OpRef :: fail ( ) ; for ( int I = <NUM_LIT> ; I != N / <NUM_LIT> ; ++ I ) if ( SM . Mask [ I + <NUM_LIT> * N / <NUM_LIT> ] != N + <NUM_LIT> + <NUM_LIT> * I ) return OpRef :: fail ( ) ; Results . push ( <STR_LIT> , ResTy , { Vb , Va } ) ; return OpRef :: res ( Results . top ( ) ) ; } int N = VecLen ; int L = Strip . second ; if ( Strip . first != <NUM_LIT> && Strip . first != L ) return OpRef :: fail ( ) ; for ( int I = L ; I < N ; I += L ) { auto S = findStrip ( SM . Mask . drop_front ( I ) , <NUM_LIT> , N - I ) ; if ( S . first - Strip . first != <NUM_LIT> * I ) return OpRef :: fail ( ) ; if ( S . second != unsigned ( L ) ) return OpRef :: fail ( ) ; } assert ( Strip . first == <NUM_LIT> || Strip . first == L ) ; using namespace <ISA_LIT> ; NodeTemplate Res


<s> uint8_t ctl ( ElemType Pos , unsigned Step ) const { return Table [ Pos ] [ Step


<s>
for
(
Node
N
:
Needed
)
dbgs
(
)
<<
' '
<<
N
;
dbgs
(
)
<<
<STR_LIT>
;
dbgs
(
)
<<
<STR_LIT>
;
for
(
auto
E
:
Edges
)
{
dbgs
(
)
<<
<STR_LIT>
<<
E
.
first
<<
<STR_LIT>
;
for
(
auto
N
:
E
.
second
)
dbgs
(
)
<<
' '
<<
N
;
dbgs
(
)
<<
<STR_LIT>
;
}
dbgs
(
)
<<
<STR_LIT>
;
auto
ColorKindToName
=
[
]
(
ColorKind
C
)
{
switch
(
C
)
{
case
ColorKind
::
:
return
<STR_LIT>
;
case
ColorKind
::
Red


<s> BaseType :: const_iterator end ( ) const { return List . end (


<s> static OpRef fail ( ) { return OpRef (


<s> int F = A [ <NUM_LIT> ] ; int E = F ; for ( unsigned I = <NUM_LIT> ; I != MaxLen ; ++ I ) { if ( A [ I ] - E != Inc ) return { F , I } ; E = A


<s> auto F = Colors . find ( N ) ; return F != Colors . end ( ) ? F ->


<s> return static_cast < const <ISA_LIT>TargetLowering & > ( G .


<s> return static_cast < const <ISA_LIT>TargetLowering & > ( G . getTargetLoweringInfo


<s> static const <ISA_LIT>Subtarget & get<ISA_LIT>Subtarget ( SelectionDAG


<s> return static_cast < const <ISA_LIT>Subtarget & > ( G . getSubtarget


<s> unsigned NumElems = ( <NUM_LIT> * HwLen ) / ( ElemTy . getSizeInBits


<s> unsigned NumElems = HwLen / ( ElemTy . getSizeInBits ( ) / <NUM_LIT> ) ; return <STR_LIT> ( ElemTy , NumElems


<s> unsigned NumElems = HwLen / ( ElemTy . getSizeInBits (


<s> if ( ColorN == ColorKind :: None ) continue ; if ( Color == ColorKind :: None ) Color = ColorN ; else if ( Color != ColorKind :: None && Color != ColorN

) return { false , ColorKind :: None } ;


<s> return ShuffleMask ( Mask . take_back


<s> int M = Mask [ I ] ; if ( M >= <NUM_LIT> && M != I


<s> int Sum = <NUM_LIT> ; for ( int Idx : Mask ) { if ( Idx == - <NUM_LIT> ) return false ; Sum += Idx ; } int N = Mask . size ( ) ; return <NUM_LIT> * Sum == N * ( N - <NUM_LIT>


<s> static bool isUndef ( ArrayRef < int


<s> static bool isUndef ( ArrayRef < int > Mask ) { for ( int Idx : Mask ) if ( Idx != - <NUM_LIT> ) return


<s> unsigned Part = R . OpN & OpRef :: Whole ; int Idx = SignExtend32 ( R . OpN & OpRef :: Index , OpRef :: IndexBits ) ; if ( Idx < <NUM_LIT> ) Idx += I ; assert ( Idx >= <NUM_LIT> && unsigned ( Idx ) < Output . size ( ) ) ; SDValue Op = Output [ Idx ] ; MVT OpTy = Op . getValueType ( ) . getSimpleVT ( ) ; if ( Part != OpRef :: Whole ) { assert ( Part == OpRef :: LoHalf || Part == OpRef :: HiHalf ) ; MVT HalfTy = <STR_LIT> ( OpTy . getVectorElementType ( ) , OpTy . getVectorNumElements ( ) / <NUM_LIT> ) ; unsigned Sub = ( Part == OpRef :: LoHalf ) ? <STR_LIT> : <STR_LIT> ; Op = DAG . getTargetExtractSubreg ( Sub , dl , HalfTy , Op ) ; } Ops . push_back ( Op ) ; } assert ( Node . Ty != <STR_LIT> ) ; SDNode * ResN = ( Node . Opc == TargetOpcode :: COPY ) ? Ops . front ( ) . getNode ( ) : DAG . getMachineNode (


<s> uint8_t HalfIdx [ <NUM_LIT> ] = { <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> } ; unsigned Idx = <NUM_LIT> ; for ( unsigned I = <NUM_LIT> ; I != <NUM_LIT> ; ++ I ) { if ( ( HalfMask & ( <NUM_LIT> << I ) ) == <NUM_LIT> ) continue ; assert ( Idx < <NUM_LIT> ) ; OpRef Op = Inp [ I / <NUM_LIT> ] ; Out [ Idx ] = ( I & <NUM_LIT> ) ? OpRef :: hi ( Op ) : OpRef :: lo ( Op ) ; HalfIdx [ I ] = Idx ++ ; } int VecLen = SM . Mask . size ( ) ; for ( int I = <NUM_LIT> ; I != VecLen ; ++ I ) { int M = SM . Mask [ I ] ; if ( M >= <NUM_LIT> ) { uint8_t Idx = HalfIdx [ M >> LogHw ] ; assert ( Idx == <NUM_LIT> || Idx == <NUM_LIT> ) ; M = ( M & ( HwLen - <NUM_LIT> ) ) +


<s> Va = Vb ; MinSrc = SM . MinSrc - HwLen ; } const SDLoc & dl ( Results . InpNode ) ; if ( isUInt < <NUM_LIT> > ( MinSrc ) || isUInt < <NUM_LIT> > ( HwLen - MinSrc ) ) { bool IsRight = isUInt < <NUM_LIT> > ( MinSrc ) ; SDValue S = DAG . getTargetConstant ( IsRight ? MinSrc : HwLen - MinSrc , dl , <STR_LIT> ) ; unsigned Opc = IsRight ? <STR_LIT> : <STR_LIT> ; Results . push ( Opc , Ty , { Vb , Va , S } ) ; } else { SDValue S = DAG . getTargetConstant ( MinSrc , dl , <STR_LIT> ) ; Results . push ( <STR_LIT> , <STR_LIT> , { S } ) ; unsigned Top = Results . top ( ) ; Results . push ( <STR_LIT> , Ty , { Vb , Va , OpRef :: res ( Top ) } ) ; } for ( int I = <NUM_LIT> ; I != VecLen ; ++ I ) { int M = SM . Mask [ I ] ; if ( M != - <NUM_LIT> ) M -= SM . MinSrc ; NewMask [ I ] = M ; } return OpRef :: res ( Results . top ( ) ) ; } if ( Options & PackMux ) { BitVector Picked ( HwLen ) ; SmallVector < uint8_t , <NUM_LIT> > MuxBytes ( HwLen ) ; bool CanMux = true ; for ( int I = <NUM_LIT> ; I != VecLen ; ++ I ) { int M = SM . Mask [ I ] ; if ( M == - <NUM_LIT> ) continue ; if ( M >= int ( HwLen )


<s> assert ( VecLen > <NUM_LIT> ) ; for ( unsigned I = VecLen ; I >= <NUM_LIT> ; I >>= <NUM_LIT> ) { unsigned X = XorPow2 ( SM . Mask , I ) ; if ( ! isPowerOf2_32 ( X ) ) return OpRef :: fail ( ) ; for ( int J = I ; J < VecLen ; J += I ) { if ( XorPow2 ( SM . Mask . slice ( J , I ) , I ) != X ) return OpRef :: fail ( ) ; } Perm [ Log2_32 ( X ) ] = Log2_32 ( I ) - <NUM_LIT> ; } using CycleType = SmallVector < unsigned , <NUM_LIT> > ; std :: set < CycleType > Cycles ; std :: set < unsigned > All ; for ( unsigned I : Perm ) All . insert ( I ) ; auto canonicalize = [ LogLen ] ( const CycleType & C ) -> CycleType { unsigned LogPos , N = C . size ( ) ; for ( LogPos = <NUM_LIT> ; LogPos != N ; ++ LogPos ) if ( C [ LogPos ] == LogLen - <NUM_LIT> ) break ; if ( LogPos == N ) return C ; CycleType NewC ( C . begin ( ) + LogPos , C . end ( ) ) ; NewC . append ( C . begin ( ) , C . begin ( ) + LogPos ) ; return NewC ; } ; auto pfs = [ ] ( const std :: set < CycleType > & Cs , unsigned Len ) { if ( Cs . size ( ) != <NUM_LIT> ) return <NUM_LIT> ; const CycleType & C = * Cs . begin ( ) ; if ( C [ <NUM_LIT> ] != Len - <NUM_LIT> ) return <NUM_LIT> ; int D = Len - C . size ( ) ; if ( D != <NUM_LIT> && D != <NUM_LIT> ) return <NUM_LIT> ; bool IsDeal = true , IsShuff = true ; for ( unsigned I = <NUM_LIT> ; I != Len - D ; ++ I ) { if ( C [ I ] != Len - <NUM_LIT> - I ) IsDeal = false ; if ( C [ I ] != I - ( <NUM_LIT> - D ) ) IsShuff = false ; } assert ( ! ( IsDeal || IsShuff ) || IsDeal != IsShuff ) ; static unsigned Deals [ ] = { <STR_LIT> , <STR_LIT> } ; static unsigned Shufs [ ] = { <STR_LIT> , <STR_LIT> } ; return IsDeal ? Deals [ D ] : ( IsShuff ? Shufs [ D ] : <NUM_LIT> ) ; } ; while ( ! All .


<s>
void
print
(
raw_ostream
&
OS
)
const
{
OS
<<
<STR_LIT>
<<
MinSrc
<<
<STR_LIT>
<<
MaxSrc
<<
<STR_LIT>
;
for
(
int
M
:
Mask
)
OS
<<
' '
<<
M
;
OS
<<
<STR_LIT>


<s> OS << <STR_LIT> << MinSrc << <STR_LIT> <<


<s> Res . Ty = Ty ; Res . Ops = Ops ; return push ( Res