<s> bool <ISA_LIT>InstrInfo :: isProfitableToIfCvt ( MachineBasicBlock & TMBB , unsigned NumTCycles , unsigned ExtraTCycles , MachineBasicBlock & FMBB , unsigned NumFCycles , unsigned ExtraFCycles , BranchProbability Probability ) const {


<s> bool <ISA_LIT>InstrInfo :: isSaveCalleeSavedRegsCall ( const MachineInstr * MI ) const { return MI -> getOpcode ( ) == <STR_LIT> ;


<s> return MI -> getOpcode ( ) == <STR_LIT> ;


<s> bool <ISA_LIT>InstrInfo :: isSchedulingBoundary ( const MachineInstr * MI , const MachineBasicBlock * MBB , const MachineFunction & MF ) const { if ( MI -> isDebugValue ( ) ) return false ; if ( MI -> getDesc ( ) . isTerminator ( ) || MI -> isPosition ( ) || MI -> isInlineAsm ( ) ) return true ;


<s> default : return false ; case <STR_LIT> : case <STR_LIT> : return true ; }


<s> if ( MI -> getOperand ( <NUM_LIT> ) . isFI ( ) && MI -> getOperand ( <NUM_LIT> ) . isImm ( ) && ( MI -> getOperand ( <NUM_LIT> ) . getImm ( ) == <NUM_LIT> ) ) { FrameIndex = MI -> getOperand ( <NUM_LIT> ) . getIndex ( ) ; return MI -> getOperand ( <NUM_LIT> ) . getReg ( ) ; }


<s> } if ( VT == <STR_LIT> ) { return ( Offset >= <ISA_LIT>_MEMW_AUTOINC_MIN && Offset <= <ISA_LIT>_MEMW_AUTOINC_MAX && ( Offset & <NUM_LIT> ) == <NUM_LIT> ) ; } if ( VT == <STR_LIT> ) { return ( Offset >= <ISA_LIT>_MEMH_AUTOINC_MIN && Offset <= <ISA_LIT>_MEMH_AUTOINC_MAX && ( Offset & <NUM_LIT> ) == <NUM_LIT> ) ; } if ( VT == <STR_LIT> ) { return ( Offset >= <ISA_LIT>_MEMB_AUTOINC_MIN && Offset <= <ISA_LIT>_MEMB_AUTOINC_MAX ) ;


<s> void <ISA_LIT>InstrInfo :: loadRegFromAddr ( MachineFunction & MF , unsigned DestReg , SmallVectorImpl < MachineOperand > & Addr , const TargetRegisterClass * RC , SmallVectorImpl < MachineInstr * > & NewMIs ) const {


<s> void <ISA_LIT>InstrInfo :: loadRegFromAddr ( MachineFunction & MF , unsigned DestReg , SmallVectorImpl < MachineOperand > & Addr , const TargetRegisterClass * RC , SmallVectorImpl < MachineInstr * > & NewMIs ) const { llvm_unreachable ( <STR_LIT> ) ;


<s> MachineFunction & MF = * MBB . getParent ( ) ; MachineFrameInfo & MFI = * MF . getFrameInfo ( ) ; unsigned Align = MFI . getObjectAlignment ( FI ) ; MachineMemOperand * MMO = MF . getMachineMemOperand ( MachinePointerInfo :: getFixedStack ( MF , FI ) , MachineMemOperand :: MOLoad , MFI . getObjectSize ( FI ) , Align ) ; if ( RC == & <STR_LIT> ) { BuildMI ( MBB , I , DL , get ( <STR_LIT> ) , DestReg ) . addFrameIndex ( FI ) . addImm ( <NUM_LIT> ) . addMemOperand ( MMO ) ; } else if ( RC == & <STR_LIT> ) { BuildMI ( MBB , I , DL , get ( <STR_LIT> ) , DestReg ) . addFrameIndex ( FI ) . addImm ( <NUM_LIT> ) . addMemOperand ( MMO ) ; } else if ( RC == & <STR_LIT> ) {


<s> bool <ISA_LIT>InstrInfo :: mayBeNewStore ( const MachineInstr * MI ) const {

const uint64_t F = MI -> getDesc ( ) . TSFlags ;


<s> if ( MI -> getDesc ( ) . mayLoad ( ) || MI -> getDesc ( ) . mayStore ( ) ) { switch ( getAddrMode ( MI ) ) { case <STR_LIT> :

NonExtOpcode = <STR_LIT> ( MI -> getOpcode ( ) ) ;


<s> MachineBasicBlock & B = * MI -> getParent ( ) ; DebugLoc DL = MI -> getDebugLoc ( ) ; unsigned PredOpc = getCondOpcode ( Opc , invertJump ) ; MachineInstrBuilder T = BuildMI ( B , MI , DL , get ( PredOpc ) ) ; unsigned NOp = <NUM_LIT> , NumOps = MI -> getNumOperands ( ) ; while ( NOp < NumOps ) { MachineOperand & Op = MI -> getOperand ( NOp ) ; if ( ! Op . isReg ( ) || ! Op . isDef ( ) || Op . isImplicit ( ) ) break ; T . addOperand ( Op ) ; NOp ++ ; } unsigned PredReg , PredRegPos , PredRegFlags ; bool GotPredReg = getPredReg ( Cond , PredReg , PredRegPos , PredRegFlags ) ;


<s> return ( Opcode == <STR_LIT> ) || ( Opcode == <STR_LIT> ) || ( Opcode == <STR_LIT> ) || ( Opcode == <STR_LIT> ) || ( Opcode == <STR_LIT> ) || ( Opcode == <STR_LIT> ) ;


<s> bool <ISA_LIT>InstrInfo :: ReverseBranchCondition ( SmallVectorImpl < MachineOperand > & Cond ) const { if ( Cond . empty ( ) ) return true ; assert ( Cond [ <NUM_LIT> ] . isImm ( ) && <STR_LIT> ) ;

Opcode_t opcode = Cond [ <NUM_LIT> ] . getImm ( ) ;


<s> void <ISA_LIT>InstrInfo :: storeRegToAddr ( MachineFunction & MF , unsigned SrcReg , bool isKill , SmallVectorImpl < MachineOperand > & Addr , const TargetRegisterClass * RC , SmallVectorImpl < MachineInstr * > & NewMIs ) const {


<s> void <ISA_LIT>InstrInfo :: storeRegToAddr ( MachineFunction & MF , unsigned SrcReg , bool isKill , SmallVectorImpl < MachineOperand > & Addr , const TargetRegisterClass * RC , SmallVectorImpl < MachineInstr * > & NewMIs ) const { llvm_unreachable ( <STR_LIT> ) ;


<s> MachineFunction & MF = * MBB . getParent ( ) ; MachineFrameInfo & MFI = * MF . getFrameInfo ( ) ; unsigned Align = MFI . getObjectAlignment ( FI ) ; MachineMemOperand * MMO = MF . getMachineMemOperand ( MachinePointerInfo :: getFixedStack ( MF , FI ) , MachineMemOperand :: MOStore , MFI . getObjectSize ( FI ) , Align ) ; if ( <STR_LIT> . hasSubClassEq ( RC ) ) {

BuildMI ( MBB , I , DL , get ( <STR_LIT> ) ) . addFrameIndex ( FI ) . addImm ( <NUM_LIT> ) . addReg ( SrcReg , getKillRegState ( isKill ) ) . addMemOperand ( MMO ) ;


SubsumesPredicate ( ArrayRef < MachineOperand > Pred1 , ArrayRef < MachineOperand > Pred2 ) const {


<s> SubsumesPredicate ( ArrayRef < MachineOperand > Pred1 , ArrayRef < MachineOperand > Pred2 ) const {


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


<s> unsigned UseOpc = U -> getMachineOpcode ( ) ; Ops [ I1N ] = C0 ; If0 = SDValue ( DAG . getMachineNode ( UseOpc , dl , UVT , Ops ) , <NUM_LIT> ) ; Ops [ I1N ] = C1 ; If1 = SDValue ( DAG . getMachineNode ( UseOpc , dl , UVT , Ops ) , <NUM_LIT> ) ; } else { unsigned UseOpc = U -> getOpcode ( ) ; Ops [ I1N ] = C0 ; If0 = DAG . getNode ( UseOpc , dl , UVT , Ops ) ; Ops [ I1N ] = C1 ; If1 = DAG . getNode ( UseOpc , dl , UVT , Ops ) ; } SDValue Sel = DAG . getNode ( <STR_LIT> , dl , UVT , OpI1 , If1 , If0 ) ;

DAG . ReplaceAllUsesWith ( U , Sel . getNode ( ) ) ;


<s> EVT OpVT = OpI1 . getValueType ( ) ; if ( ! OpVT . isSimple ( ) || OpVT . getSimpleVT ( ) != <STR_LIT> ) continue ; for ( auto I = N -> use_begin ( ) , E = N -> use_end ( ) ; I != E ; ++ I ) { SDNode * U = * I ; if ( U -> getNumValues ( ) != <NUM_LIT> ) continue ; EVT UVT = U -> getValueType ( <NUM_LIT> ) ; if ( ! UVT . isSimple ( ) || ! UVT . isInteger ( ) || UVT . getSimpleVT ( ) == <STR_LIT> ) continue ; if ( isMemOPCandidate ( N , U ) ) continue ; unsigned I1N = I . getOperandNo ( ) ; SmallVector < SDValue , <NUM_LIT> > Ops ( U -> getNumOperands ( ) ) ; for ( unsigned i = <NUM_LIT> , n = U -> getNumOperands ( ) ; i != n ; ++ i ) Ops [ i ] = U -> getOperand ( i ) ; EVT BVT = Ops [ I1N ] . getValueType ( ) ; SDLoc dl ( U ) ; SDValue C0 = DAG . getConstant ( <NUM_LIT> , dl , BVT ) ; SDValue C1 = DAG . getConstant ( <NUM_LIT> , dl , BVT ) ; SDValue If0 , If1 ; if ( isa < MachineSDNode > ( U ) ) { unsigned UseOpc = U -> getMachineOpcode ( ) ; Ops [ I1N ] = C0 ; If0 = SDValue ( DAG . getMachineNode ( UseOpc , dl , UVT , Ops ) , <NUM_LIT> ) ; Ops [ I1N ] = C1 ; If1 = SDValue ( DAG . getMachineNode ( UseOpc , dl , UVT , Ops ) , <NUM_LIT> ) ; } else { unsigned UseOpc = U -> getOpcode ( ) ; Ops [ I1N ] = C0 ; If0 = DAG . getNode ( UseOpc , dl , UVT , Ops ) ;


<s> 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 ( ) ) ; } }


<s> HST = & MF . getSubtarget < <ISA_LIT>Subtarget > ( ) ; HII = HST -> getInstrInfo ( ) ; HRI = HST -> getRegisterInfo ( ) ;

SelectionDAGISel :: runOnMachineFunction ( MF ) ;


<s> bool runOnMachineFunction ( MachineFunction & MF ) override { HST = & MF . getSubtarget < <ISA_LIT>Subtarget > ( ) ; HII = HST -> getInstrInfo ( ) ; HRI = HST -> getRegisterInfo ( ) ; SelectionDAGISel :: runOnMachineFunction ( MF ) ;


<s> return SelectGlobalAddress ( N , R , false , <NUM_LIT> ) ;


<s> return SelectGlobalAddress ( N , R , true , <NUM_LIT> ) ;


<s> inline bool <ISA_LIT>DAGToDAGISel :: SelectAddrGP ( SDValue & N , SDValue & R ) {

return SelectGlobalAddress ( N , R , true , <NUM_LIT> ) ;


<s> return SelectAnyImmediate ( N , R , <NUM_LIT> ) ;


<s> inline bool <ISA_LIT>DAGToDAGISel :: SelectAnyImm0 ( SDValue & N , SDValue & R ) {

return SelectAnyImmediate ( N , R , <NUM_LIT> ) ;


<s> inline bool <ISA_LIT>DAGToDAGISel :: SelectAnyImm1 ( SDValue & N , SDValue & R ) {


<s> inline bool <ISA_LIT>DAGToDAGISel :: SelectAnyImm2 ( SDValue & N , SDValue & R ) { return SelectAnyImmediate ( N , R , <NUM_LIT> ) ;


<s> inline bool <ISA_LIT>DAGToDAGISel :: SelectAnyImm2 ( SDValue & N , SDValue & R ) {


<s> 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> ) ;


<s> if ( GA -> getOpcode ( ) == <STR_LIT> ) { uint64_t NewOff = GA -> getOffset ( ) + ( uint64_t ) Const -> getSExtValue ( ) ; R = CurDAG -> getTargetGlobalAddress ( GA -> getGlobal ( ) , SDLoc ( Const ) , N . getValueType ( ) , NewOff ) ; return true ; } } } break ; } case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : if ( ! UseGP ) R = N . getOperand ( <NUM_LIT> ) ; return ! UseGP ; case <STR_LIT> : if ( UseGP ) R = N . getOperand ( <NUM_LIT> ) ; return UseGP ; default : return false ; }


<s> SDValue Ops [ ] = { CurDAG -> getTargetConstant ( <STR_LIT> , dl , <STR_LIT> ) , N -> getOperand ( <NUM_LIT> ) , CurDAG -> getTargetConstant ( <STR_LIT> , dl , <STR_LIT> ) , N -> getOperand ( <NUM_LIT> ) , CurDAG -> getTargetConstant ( <STR_LIT> , dl , <STR_LIT> ) } ; SDNode * R = CurDAG -> getMachineNode ( TargetOpcode :: REG_SEQUENCE , dl , <STR_LIT> , Ops ) ; SDValue M0 = CurDAG -> getTargetConstant ( <NUM_LIT> , dl , <STR_LIT> ) ; SDValue M1 = CurDAG -> getTargetConstant ( <NUM_LIT> , dl , <STR_LIT> ) ;

SDNode * C = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , M0 , N -> getOperand ( <NUM_LIT> ) , M1 ) ;


<s> MVT ResTy = N -> getValueType ( <NUM_LIT> ) . getSimpleVT ( ) ; if ( HST -> isHVXVectorType ( ResTy , true ) ) return SelectHvxVAlign ( N ) ; const SDLoc & dl ( N ) ; unsigned VecLen = ResTy . getSizeInBits ( ) ; if ( VecLen == <NUM_LIT> ) { SDValue Ops [ ] = { CurDAG -> getTargetConstant ( <STR_LIT> , dl , <STR_LIT> ) , N -> getOperand ( <NUM_LIT> ) , CurDAG -> getTargetConstant ( <STR_LIT> , dl , <STR_LIT> ) , N -> getOperand ( <NUM_LIT> ) , CurDAG -> getTargetConstant ( <STR_LIT> , dl , <STR_LIT> ) } ; SDNode * R = CurDAG -> getMachineNode ( TargetOpcode :: REG_SEQUENCE , dl , <STR_LIT> , Ops ) ; SDValue M0 = CurDAG -> getTargetConstant ( <NUM_LIT> , dl , <STR_LIT> ) ; SDValue M1 = CurDAG -> getTargetConstant ( <NUM_LIT> , dl , <STR_LIT> ) ; SDNode * C = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , M0 , N -> getOperand ( <NUM_LIT> ) , M1 ) ; SDNode * S = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( R , <NUM_LIT> ) , SDValue ( C , <NUM_LIT> ) ) ; SDValue E = CurDAG -> getTargetExtractSubreg ( <STR_LIT> , dl , ResTy , SDValue ( S , <NUM_LIT> ) ) ; ReplaceNode ( N , E . getNode ( ) ) ; } else { assert ( VecLen == <NUM_LIT> ) ;

SDNode * Pu = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , N -> getOperand ( <NUM_LIT> ) ) ;


<s> EVT SrcVT ; unsigned Opc = N . getOpcode ( ) ; switch ( Opc ) { case <STR_LIT> : case <STR_LIT> : { EVT T = Opc == <STR_LIT> ? N . getOperand ( <NUM_LIT> ) . getValueType ( ) : cast < VTSDNode > ( N . getOperand ( <NUM_LIT> ) ) -> getVT ( ) ; if ( T . getSizeInBits ( ) != <NUM_LIT> ) return false ; R = N . getOperand ( <NUM_LIT> ) ; break ; } case <STR_LIT> : { LoadSDNode * L = cast < LoadSDNode > ( N ) ; if ( L -> getExtensionType ( ) != <STR_LIT> ) return false ; if ( L -> getMemoryVT ( ) . getSizeInBits ( ) > <NUM_LIT> ) return false ; R = N ; break ; } default : return false ; } EVT RT = R . getValueType ( ) ; if ( RT == <STR_LIT> ) return true ; assert ( RT == <STR_LIT> ) ; const SDLoc & dl ( N ) ; SDValue Ops [ ] = { CurDAG -> getTargetConstant ( <STR_LIT> , dl , <STR_LIT> ) , R , CurDAG -> getTargetConstant ( <STR_LIT> , dl , <STR_LIT> ) , R , CurDAG -> getTargetConstant ( <STR_LIT> , dl , <STR_LIT> ) } ; SDNode * T = CurDAG -> getMachineNode ( TargetOpcode :: REG_SEQUENCE , dl , <STR_LIT> , Ops ) ; R = SDValue ( T , <NUM_LIT> ) ; return true ;


<s> if ( isa < Instruction > ( U ) && cast < Instruction > ( U ) -> getParent ( ) -> getParent ( ) == CurF ) ++ Result ; } GAUsesInFunction [ V ] = Result ; return Result ;


<s> unsigned <ISA_LIT>DAGToDAGISel :: getUsesInFunction ( const Value * V ) { if ( GAUsesInFunction . count ( V ) ) return GAUsesInFunction [ V ] ; unsigned Result = <NUM_LIT> ; const Function * CurF = CurDAG -> getMachineFunction ( ) . getFunction ( ) ; for ( const User * U : V -> users ( ) ) {

if ( isa < Instruction > ( U ) && cast < Instruction > ( U ) -> getParent ( ) -> getParent ( ) == CurF ) ++ Result ;


<s> MachineFrameInfo & MFI = MF -> getFrameInfo ( ) ; unsigned A = MFI . getObjectAlignment ( FN -> getIndex ( ) ) ; assert ( isPowerOf2_32 ( A ) ) ; int32_t Off = C -> getSExtValue ( ) ; return ( Off >= <NUM_LIT> ) && ( ( ( A - <NUM_LIT> ) & Off ) == unsigned ( Off ) ) ; } return false ;


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


<s> if ( ConstantSDNode * C = dyn_cast < ConstantSDNode > ( Val . getOperand ( <NUM_LIT> ) ) ) { if ( C -> getZExtValue ( ) == Mask ) { Src = Val . getOperand ( <NUM_LIT> ) ; return true ; } } if ( ConstantSDNode * C = dyn_cast < ConstantSDNode > ( Val . getOperand ( <NUM_LIT> ) ) ) { if ( C -> getZExtValue ( ) == Mask ) { Src = Val . getOperand ( <NUM_LIT> ) ; return true ; } } break ; } case <STR_LIT> : case <STR_LIT> : { uint64_t Mask = ( <NUM_LIT> << NumBits ) - <NUM_LIT> ; if ( ConstantSDNode * C = dyn_cast < ConstantSDNode > ( Val . getOperand ( <NUM_LIT> ) ) ) { if ( ( C -> getZExtValue ( ) & Mask ) == <NUM_LIT> ) {


<s> } } break ; case <STR_LIT> : { uint64_t Mask = ( <NUM_LIT> << NumBits ) - <NUM_LIT> ; if ( ConstantSDNode * C = dyn_cast < ConstantSDNode > ( Val . getOperand ( <NUM_LIT> ) ) ) { if ( C -> getZExtValue ( ) == Mask ) { Src = Val . getOperand ( <NUM_LIT> ) ; return true ; } } if ( ConstantSDNode * C = dyn_cast < ConstantSDNode > ( Val . getOperand ( <NUM_LIT> ) ) ) { if ( C -> getZExtValue ( ) == Mask ) { Src = Val . getOperand ( <NUM_LIT> ) ; return true ; } } break ; } case <STR_LIT> : case <STR_LIT> : { uint64_t Mask = ( <NUM_LIT> << NumBits ) - <NUM_LIT> ; if ( ConstantSDNode * C = dyn_cast < ConstantSDNode > ( Val . getOperand ( <NUM_LIT> ) ) ) { if ( ( C -> getZExtValue ( ) & Mask ) == <NUM_LIT> ) { Src = Val . getOperand ( <NUM_LIT> ) ; return true ; } } if ( ConstantSDNode * C = dyn_cast < ConstantSDNode > ( Val . getOperand ( <NUM_LIT> ) ) ) { if ( ( C -> getZExtValue ( ) & Mask ) == <NUM_LIT> ) { Src = Val . getOperand ( <NUM_LIT> ) ; return true ; } } } default : break ; }


<s> SDValue I = CurDAG -> getTargetConstant ( Inc -> getSExtValue ( ) , dl , <STR_LIT> ) ; MachineSDNode * Res = CurDAG -> getMachineNode ( FLC -> second , dl , RTys , { IntN -> getOperand ( <NUM_LIT> ) , I , SDValue ( Mod , <NUM_LIT> ) , IntN -> getOperand ( <NUM_LIT> ) } ) ; return Res ; } static std :: map < unsigned , unsigned > LoadPbrMap = { { <STR_LIT> , <STR_LIT> } , { <STR_LIT> , <STR_LIT> } , { <STR_LIT> , <STR_LIT> } , { <STR_LIT> , <STR_LIT> } , { <STR_LIT> , <STR_LIT> } , { <STR_LIT> , <STR_LIT> } , } ; auto FLB = LoadPbrMap . find ( IntNo ) ; if ( FLB != LoadPbrMap . end ( ) ) { SDNode * Mod = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , IntN -> getOperand ( <NUM_LIT> ) ) ; EVT ValTy = ( IntNo == <STR_LIT> ) ? <STR_LIT> : <STR_LIT> ; EVT RTys [ ] = { ValTy , <STR_LIT> , <STR_LIT> } ; MachineSDNode * Res = CurDAG -> getMachineNode ( FLB -> second , dl , RTys , { IntN -> getOperand ( <NUM_LIT> ) , SDValue ( Mod , <NUM_LIT> ) , IntN -> getOperand ( <NUM_LIT> ) } ) ;


<s> DEBUG ( N -> dump ( ) ) ; SmallVector < SDNode * , <NUM_LIT> > Worklist ; Worklist . push_back ( BasePtr . getOperand ( <NUM_LIT> ) . getNode ( ) ) ; Worklist . push_back ( BasePtr . getOperand ( <NUM_LIT> ) . getNode ( ) ) ; while ( ! Worklist . empty ( ) ) { SDNode * N = Worklist . pop_back_val ( ) ; unsigned Opcode = N -> getOpcode ( ) ; if ( ! isOpcodeHandled ( N ) ) continue ; Worklist . push_back ( N -> getOperand ( <NUM_LIT> ) . getNode ( ) ) ; Worklist . push_back ( N -> getOperand ( <NUM_LIT> ) . getNode ( ) ) ; if ( N -> hasOneUse ( ) && Opcode == N -> use_begin ( ) -> getOpcode ( ) ) continue ; if ( RootWeights . count ( N ) ) continue ; RootWeights [ N ] = - <NUM_LIT> ; } 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 -> RemoveDeadNodes ( ) ; GAUsesInFunction . clear ( ) ; RootHeights . clear ( ) ; RootWeights . clear ( ) ;


<s> EVT SVT = N -> getOperand ( <NUM_LIT> ) . getValueType ( ) ; EVT DVT = N -> getValueType ( <NUM_LIT> ) ; if ( ! SVT . isVector ( ) || ! DVT . isVector ( ) || SVT . getVectorElementType ( ) == <STR_LIT> || DVT . getVectorElementType ( ) == <STR_LIT> || SVT . getSizeInBits ( ) != DVT . getSizeInBits ( ) ) { SelectCode ( N ) ; return ; } CurDAG -> ReplaceAllUsesOfValueWith ( SDValue ( N , <NUM_LIT> ) , N -> getOperand ( <NUM_LIT> ) ) ; CurDAG -> RemoveDeadNode ( N ) ;


<s> if ( N -> getValueType ( <NUM_LIT> ) == <STR_LIT> ) { SDValue V = CurDAG -> getTargetConstant ( A . getZExtValue ( ) , dl , <STR_LIT> ) ; ReplaceNode ( N , CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , V ) ) ; return ; } SelectCode ( N ) ;


<s> } SDValue IncV = CurDAG -> getTargetConstant ( Inc , dl , <STR_LIT> ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ; MemOp [ <NUM_LIT> ] = ST -> getMemOperand ( ) ; SDValue From [ <NUM_LIT> ] = { SDValue ( ST , <NUM_LIT> ) , SDValue ( ST , <NUM_LIT> ) } ; SDValue To [ <NUM_LIT> ] ; if ( IsValidInc ) { SDValue Ops [ ] = { Base , IncV , Value , Chain } ; MachineSDNode * S = CurDAG -> getMachineNode ( Opcode , dl , <STR_LIT> , <STR_LIT> , Ops ) ; S -> setMemRefs ( MemOp , MemOp + <NUM_LIT> ) ; To [ <NUM_LIT> ] = SDValue ( S , <NUM_LIT> ) ; To [ <NUM_LIT> ] = SDValue ( S , <NUM_LIT> ) ; } else { SDValue Zero = CurDAG -> getTargetConstant ( <NUM_LIT> , dl , <STR_LIT> ) ; SDValue Ops [ ] = { Base , Zero , Value , Chain } ; MachineSDNode * S = CurDAG -> getMachineNode ( Opcode , dl , <STR_LIT> , Ops ) ; S -> setMemRefs ( MemOp , MemOp + <NUM_LIT> ) ; To [ <NUM_LIT> ] = SDValue ( S , <NUM_LIT> ) ; MachineSDNode * A = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , Base , IncV ) ; To [ <NUM_LIT> ] = SDValue ( A , <NUM_LIT> ) ; }


<s> CurDAG -> RemoveDeadNode ( N ) ; return ; } SelectCode ( N ) ;


<s> StoreInstrForLoadIntrinsic ( L , N ) ; CurDAG -> RemoveDeadNode ( N ) ; return ; }


<s> if ( keepsLowBits ( V , Bits , U ) ) { SDValue R = CurDAG -> getNode ( N -> getOpcode ( ) , SDLoc ( N ) , N -> getValueType ( <NUM_LIT> ) , N -> getOperand ( <NUM_LIT> ) , U ) ;


<s> for ( unsigned i = <NUM_LIT> ; i < NE ; ++ i ) { MV |= Bit ; Bit <<= ES ; } 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 , Result_3 ) ; return ; } if ( N -> getValueType ( <NUM_LIT> ) == <STR_LIT> ) { SDNode * RsPd = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( Int , <NUM_LIT> ) ) ; ReplaceNode ( N , RsPd ) ; return ; } llvm_unreachable ( <STR_LIT> ) ; } } SelectCode ( N ) ;


<s> } default : return false ; } EVT RT = R . getValueType ( ) ; if ( RT == <STR_LIT> ) return true ; assert ( RT == <STR_LIT> ) ; const SDLoc & dl ( N ) ; SDValue Ops [ ] = { CurDAG -> getTargetConstant ( <STR_LIT> , dl , <STR_LIT> ) , R , CurDAG -> getTargetConstant ( <STR_LIT> , dl , <STR_LIT> ) , R , CurDAG -> getTargetConstant ( <STR_LIT> , dl , <STR_LIT> ) } ;

SDNode * T = CurDAG -> getMachineNode ( TargetOpcode :: REG_SEQUENCE , dl , <STR_LIT> , Ops ) ;


<s> case <STR_LIT> : return SelectIntrinsicWOChain ( N ) ; case <STR_LIT> : return SelectTypecast ( N ) ; case <STR_LIT> : return SelectP2D ( N ) ; case <STR_LIT> : return SelectD2P ( N ) ; case <STR_LIT> : return SelectQ2V ( N ) ; case <STR_LIT> : return SelectV2Q ( N ) ; } if ( HST -> useHVXOps ( ) ) { switch ( N -> getOpcode ( ) ) { case <STR_LIT> : return SelectHvxShuffle ( N ) ; case <STR_LIT> : return SelectHvxRor ( N ) ; } }


<s> 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 ( LD ) ) { if ( LD -> 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> ) ; } SDValue IncV = CurDAG -> getTargetConstant ( Inc , dl , <STR_LIT> ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ; MemOp [ <NUM_LIT> ] = LD -> getMemOperand ( ) ; auto getExt64 = [ this , ExtType ] ( MachineSDNode * N , const SDLoc & dl ) -> MachineSDNode * { if ( ExtType == <STR_LIT> || ExtType == <STR_LIT> ) { SDValue Zero = CurDAG -> getTargetConstant ( <NUM_LIT> , dl , <STR_LIT> ) ; return CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , Zero , SDValue ( N , <NUM_LIT> ) ) ; } if ( ExtType == <STR_LIT> ) return CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( N , <NUM_LIT> ) ) ; return N ; } ; SDValue From [ <NUM_LIT> ] = { SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) } ; SDValue To [ <NUM_LIT> ] ; EVT ValueVT = LD -> getValueType ( <NUM_LIT> ) ; if ( ValueVT == <STR_LIT> && ExtType != <STR_LIT> ) { assert ( LoadedVT . getSizeInBits ( ) <= <NUM_LIT> ) ;


<s> SDValue Base = ST -> getBasePtr ( ) ; SDValue Offset = ST -> getOffset ( ) ; SDValue Value = ST -> getValue ( ) ; int32_t Inc = cast < ConstantSDNode > ( Offset . getNode ( ) ) -> getSExtValue ( ) ; EVT StoredVT = ST -> getMemoryVT ( ) ; EVT ValueVT = Value . getValueType ( ) ; bool IsValidInc = HII -> isValidAutoIncImm ( StoredVT , Inc ) ; 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> : case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : if ( isAlignedMemNode ( ST ) ) {

if ( ST -> isNonTemporal ( ) ) Opcode = IsValidInc ? <STR_LIT> : <STR_LIT> ;


<s> StoreInstrForLoadIntrinsic ( L , N ) ; CurDAG -> RemoveDeadNode ( N ) ; return ; } unsigned IntNo = cast < ConstantSDNode > ( N -> getOperand ( <NUM_LIT> ) ) -> getZExtValue ( ) ;

if ( IntNo == <STR_LIT> || IntNo == <STR_LIT> || IntNo == <STR_LIT> || IntNo == <STR_LIT> || IntNo == <STR_LIT> || IntNo == <STR_LIT> ) {


<s> SDValue C = CurDAG -> getTargetConstant ( - <NUM_LIT> , dl , <STR_LIT> ) ; SDNode * R = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , C ) ; SDNode * T = CurDAG -> getMachineNode ( <STR_LIT> , dl , ResTy , N -> getOperand ( <NUM_LIT> ) , SDValue ( R , <NUM_LIT> ) ) ; ReplaceNode ( N , T ) ;


<s> void <ISA_LIT>DAGToDAGISel :: SelectQ2V ( SDNode * N ) { const SDLoc & dl ( N ) ; MVT ResTy = N -> getValueType ( <NUM_LIT> ) . getSimpleVT ( ) ; SDValue C = CurDAG -> getTargetConstant ( - <NUM_LIT> , dl , <STR_LIT> ) ;

SDNode * R = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , C ) ;


<s> MVT OpTy = Op . getValueType ( ) . getSimpleVT ( ) ; SDNode * T = CurDAG -> MorphNodeTo ( N , N -> getOpcode ( ) , CurDAG -> getVTList ( OpTy ) , { Op } ) ;


<s> void <ISA_LIT>DAGToDAGISel :: SelectTypecast ( SDNode * N ) { SDValue Op = N -> getOperand ( <NUM_LIT> ) ; MVT OpTy = Op . getValueType ( ) . getSimpleVT ( ) ; SDNode * T = CurDAG -> MorphNodeTo ( N , N -> getOpcode ( ) , CurDAG -> getVTList ( OpTy ) , { Op } ) ; ReplaceNode ( T , Op . getNode ( ) ) ;


<s> const SDLoc & dl ( N ) ; MVT ResTy = N -> getValueType ( <NUM_LIT> ) . getSimpleVT ( ) ; SDValue C = CurDAG -> getTargetConstant ( - <NUM_LIT> , dl , <STR_LIT> ) ;


<s> void <ISA_LIT>DAGToDAGISel :: SelectV2Q ( SDNode * N ) { const SDLoc & dl ( N ) ; MVT ResTy = N -> getValueType ( <NUM_LIT> ) . getSimpleVT ( ) ;

SDValue C = CurDAG -> getTargetConstant ( - <NUM_LIT> , dl , <STR_LIT> ) ;


<s> return <NUM_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> : return <STR_LIT> ;


<s> virtual const char * getPassName ( ) const {


<s> explicit <ISA_LIT>DAGToDAGISel ( <ISA_LIT>TargetMachine & targetmachine ) : SelectionDAGISel ( targetmachine ) , Subtarget ( targetmachine . getSubtarget < <ISA_LIT>Subtarget > ( ) ) , TM ( targetmachine ) , TII ( static_cast < const <ISA_LIT>InstrInfo * > ( TM . getInstrInfo ( ) ) ) {


<s> ConstantSDNode * N = cast < ConstantSDNode > ( S ) ;

int64_t v = ( int64_t ) N -> getSExtValue ( ) ;


<s> int64_t v = ( int64_t ) N -> getSExtValue ( ) ; return isShiftedInt < <NUM_LIT> , <NUM_LIT> > ( v ) ;


<s> static bool IsS11_1_Offset ( SDNode * S ) {

ConstantSDNode * N = cast < ConstantSDNode > ( S ) ;


<s> int64_t v = ( int64_t ) N -> getSExtValue ( ) ;

return isShiftedInt < <NUM_LIT> , <NUM_LIT> > ( v ) ;


<s> ConstantSDNode * N = cast < ConstantSDNode > ( S ) ; int64_t v = ( int64_t ) N -> getSExtValue ( ) ; return isShiftedInt < <NUM_LIT> , <NUM_LIT> > ( v ) ;


<s> int64_t v = ( int64_t ) N -> getSExtValue ( ) ; return isUInt < <NUM_LIT> > ( v ) ;


return isShiftedUInt < <NUM_LIT> , <NUM_LIT> > ( v ) ;


<s> int64_t v = ( int64_t ) N -> getSExtValue ( ) ; return isShiftedUInt < <NUM_LIT> , <NUM_LIT> > ( v ) ;


<s> ConstantSDNode * N = cast < ConstantSDNode > ( S ) ; int64_t v = ( int64_t ) N -> getSExtValue ( ) ;


<s> } if ( MemType == <STR_LIT> && isShiftedInt < <NUM_LIT> , <NUM_LIT> > ( Offset ) ) { return true ; } if ( MemType == <STR_LIT> && isShiftedInt < <NUM_LIT> , <NUM_LIT> > ( Offset ) ) { return true ; } if ( MemType == <STR_LIT> && isInt < <NUM_LIT> > ( Offset ) ) { return true ;


<s> case <STR_LIT> : return SelectSHL ( N ) ; case <STR_LIT> : return SelectLoad ( N ) ; case <STR_LIT> : return SelectStore ( N ) ; case <STR_LIT> : return SelectSelect ( N ) ; case <STR_LIT> : return SelectTruncate ( N ) ; case <STR_LIT> : return SelectMul ( N ) ;


<s> return SelectAdd ( N ) ; case <STR_LIT> : return SelectSHL ( N ) ; case <STR_LIT> : return SelectLoad ( N ) ; case <STR_LIT> : return SelectStore ( N ) ; case <STR_LIT> : return SelectSelect ( N ) ; case <STR_LIT> : return SelectTruncate ( N ) ; case <STR_LIT> : return SelectMul ( N ) ; case <STR_LIT> :


<s> SDNode * <ISA_LIT>DAGToDAGISel :: SelectAdd ( SDNode * N ) { DebugLoc dl = N -> getDebugLoc ( ) ; if ( N -> getValueType ( <NUM_LIT> ) != <STR_LIT> ) { return SelectCode ( N ) ; }

SDNode * Src1 = N -> getOperand ( <NUM_LIT> ) . getNode ( ) ;


<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> bool <ISA_LIT>DAGToDAGISel :: SelectAddr ( SDNode * Op , SDValue Addr , SDValue & Base , SDValue & Offset ) { if ( Addr . getOpcode ( ) == <STR_LIT> || Addr . getOpcode ( ) == <STR_LIT> ) return false ; if ( FrameIndexSDNode * FIN = dyn_cast < FrameIndexSDNode > ( Addr ) ) { Base = CurDAG -> getTargetFrameIndex ( FIN -> getIndex ( ) , <STR_LIT> ) ; Offset = CurDAG -> getTargetConstant ( <NUM_LIT> , <STR_LIT> ) ; return true ;


<s> Base = CurDAG -> getTargetFrameIndex ( FIN -> getIndex ( ) , <STR_LIT> ) ; Offset = CurDAG -> getTargetConstant ( <NUM_LIT> , <STR_LIT> ) ; return ( IsS11_0_Offset ( Offset . getNode ( ) ) ) ; } Base = Addr ; Offset = CurDAG -> getTargetConstant ( <NUM_LIT> , <STR_LIT> ) ;


<s> if ( FrameIndexSDNode * FIN = dyn_cast < FrameIndexSDNode > ( Addr ) ) { Base = CurDAG -> getTargetFrameIndex ( FIN -> getIndex ( ) , <STR_LIT> ) ;

Offset = CurDAG -> getTargetConstant ( <NUM_LIT> , <STR_LIT> ) ;


<s> bool <ISA_LIT>DAGToDAGISel :: SelectADDRriS11_2 ( SDValue & Addr , SDValue & Base , SDValue & Offset ) { if ( Addr . getOpcode ( ) == <STR_LIT> || Addr . getOpcode ( ) == <STR_LIT> ) return false ; if ( FrameIndexSDNode * FIN = dyn_cast < FrameIndexSDNode > ( Addr ) ) { Base = CurDAG -> getTargetFrameIndex ( FIN -> getIndex ( ) , <STR_LIT> ) ; Offset = CurDAG -> getTargetConstant ( <NUM_LIT> , <STR_LIT> ) ; return ( IsS11_2_Offset ( Offset . getNode ( ) ) ) ; } Base = Addr ;


<s> Base = CurDAG -> getTargetFrameIndex ( FIN -> getIndex ( ) , <STR_LIT> ) ; Offset = CurDAG -> getTargetConstant ( <NUM_LIT> , <STR_LIT> ) ; return ( IsS11_3_Offset ( Offset . getNode ( ) ) ) ; } Base = Addr ;


<s> if ( Addr . getOpcode ( ) == <STR_LIT> || Addr . getOpcode ( ) == <STR_LIT> ) return false ; if ( FrameIndexSDNode * FIN = dyn_cast < FrameIndexSDNode > ( Addr ) ) { Base = CurDAG -> getTargetFrameIndex ( FIN -> getIndex ( ) , <STR_LIT> ) ; Offset = CurDAG -> getTargetConstant ( <NUM_LIT> , <STR_LIT> ) ; return ( IsU6_0_Offset ( Offset . getNode ( ) ) ) ;


<s> bool <ISA_LIT>DAGToDAGISel :: SelectADDRriU6_1 ( SDValue & Addr , SDValue & Base , SDValue & Offset ) { if ( Addr . getOpcode ( ) == <STR_LIT> || Addr . getOpcode ( ) == <STR_LIT> ) return false ; if ( FrameIndexSDNode * FIN = dyn_cast < FrameIndexSDNode > ( Addr ) ) {

Base = CurDAG -> getTargetFrameIndex ( FIN -> getIndex ( ) , <STR_LIT> ) ;


<s> return ( IsU6_2_Offset ( Offset . getNode ( ) ) ) ; } Base = Addr ; Offset = CurDAG -> getTargetConstant ( <NUM_LIT> , <STR_LIT> ) ; return ( IsU6_2_Offset ( Offset . getNode ( ) ) ) ;


<s> bool <ISA_LIT>DAGToDAGISel :: SelectADDRrr ( SDValue & Addr , SDValue & R1 , SDValue & R2 ) { if ( Addr . getOpcode ( ) == <STR_LIT> ) return false ; if ( Addr . getOpcode ( ) == <STR_LIT> || Addr . getOpcode ( ) == <STR_LIT> ) return false ; if ( Addr . getOpcode ( ) == <STR_LIT> ) { if ( ConstantSDNode * CN = dyn_cast < ConstantSDNode > ( Addr . getOperand ( <NUM_LIT> ) ) ) if ( isInt < <NUM_LIT> > ( CN -> getSExtValue ( ) ) ) return false ; R1 = Addr . getOperand ( <NUM_LIT> ) ; R2 = Addr . getOperand ( <NUM_LIT> ) ;


<s> 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 , <NUM_LIT> ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ;

MemOp [ <NUM_LIT> ] = ST -> getMemOperand ( ) ;


<s> 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 ) ;


<s> 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 ; }


<s> ConstantFPSDNode * CN = dyn_cast < ConstantFPSDNode > ( N ) ; APFloat APF = CN -> getValueAPF ( ) ; if ( N -> getValueType ( <NUM_LIT> ) == <STR_LIT> ) { return CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , CurDAG -> getTargetConstantFP ( APF . convertToFloat ( ) , <STR_LIT> ) ) ; } else if ( N -> getValueType ( <NUM_LIT> ) == <STR_LIT> ) { return CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , CurDAG -> getTargetConstantFP ( APF . convertToDouble ( ) , <STR_LIT> ) ) ; }


<s> return CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , CurDAG -> getTargetConstantFP ( APF . convertToFloat ( ) , <STR_LIT> ) ) ; } else if ( N -> getValueType ( <NUM_LIT> ) == <STR_LIT> ) { return CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , CurDAG -> getTargetConstantFP ( APF . convertToDouble ( ) , <STR_LIT> ) ) ; } return SelectCode ( N ) ;


<s> 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> ) ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ; MemOp [ <NUM_LIT> ] = LD -> getMemOperand ( ) ; cast < MachineSDNode > ( Result_1 ) -> setMemRefs ( MemOp , MemOp + <NUM_LIT> ) ;


<s> 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> ) ) ; 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> ) ;


<s> 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> ) { 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 , <NUM_LIT> ) ;


<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 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> ) } ;


<s> SDNode * Result_1 = CurDAG -> getMachineNode ( Opcode , dl , <STR_LIT> , <STR_LIT> , <STR_LIT> , Base , TargetConstVal , Chain ) ; 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> ) ) ; 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_3 , <NUM_LIT> ) , SDValue ( Result_1 , <NUM_LIT> ) , SDValue ( Result_1 , <NUM_LIT> ) } ; ReplaceUses ( Froms , Tos , <NUM_LIT> ) ; return Result_3 ; } 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> , TargetConst0 ) ; SDNode * Result_3 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , <STR_LIT> , SDValue ( Result_2 , <NUM_LIT> ) , SDValue ( Result_1 , <NUM_LIT> ) ) ; SDNode * Result_4 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , Base , TargetConstVal , SDValue ( Result_1 , <NUM_LIT> ) ) ;


<s> case 'o' : case 'v' : default : return true ; case 'm' :

if ( ! SelectAddr ( Op . getNode ( ) , Op , Op0 , Op1 ) ) return true ;


<s> case 'v' : default : return true ; case 'm' :


<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 , * 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 { llvm_unreachable ( <STR_LIT> ) ; } } EVT ReturnValueVT = N -> getValueType ( <NUM_LIT> ) ; SDNode * Result = CurDAG -> getMachineNode ( IntrinsicWithPred , dl , ReturnValueVT , Ops . data ( ) , Ops . size ( ) ) ;


<s> DebugLoc dl = N -> getDebugLoc ( ) ; LoadSDNode * LD = cast < LoadSDNode > ( N ) ;

<STR_LIT> AM = LD -> getAddressingMode ( ) ;


<s> bool <ISA_LIT>DAGToDAGISel :: SelectMEMriS11_2 ( SDValue & Addr , SDValue & Base , SDValue & Offset ) { if ( Addr . getOpcode ( ) != <STR_LIT> ) {

return ( SelectADDRriS11_2 ( Addr , Base , Offset ) ) ;


<s> if ( N -> getValueType ( <NUM_LIT> ) == <STR_LIT> ) { SDValue MulOp0 = N -> getOperand ( <NUM_LIT> ) ; SDValue MulOp1 = N -> getOperand ( <NUM_LIT> ) ; SDValue OP0 ; SDValue OP1 ; if ( MulOp0 . getOpcode ( ) == <STR_LIT> ) { SDValue Sext0 = MulOp0 . getOperand ( <NUM_LIT> ) ; if ( Sext0 . getNode ( ) -> getValueType ( <NUM_LIT> ) != <STR_LIT> ) { return 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> ) { return 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> ) ; OP1 = SDValue ( CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , <STR_LIT> , LD -> getBasePtr ( ) , TargetConst0 , Chain ) , <NUM_LIT> ) ; } else { return SelectCode ( N ) ; } SDNode * Result = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , OP0 , OP1 ) ; ReplaceUses ( N , Result ) ; return Result ;


<s> SDValue OP1 ; if ( MulOp0 . getOpcode ( ) == <STR_LIT> ) { SDValue Sext0 = MulOp0 . getOperand ( <NUM_LIT> ) ; if ( Sext0 . getNode ( ) -> getValueType ( <NUM_LIT> ) != <STR_LIT> ) { return 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> ) { return 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> ) ; OP1 = SDValue ( CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , <STR_LIT> , LD -> getBasePtr ( ) , TargetConst0 , Chain ) , <NUM_LIT> ) ; } else { return SelectCode ( N ) ; }

SDNode * Result = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , OP0 , OP1 ) ;


<s> } } } if ( cast < CondCodeSDNode > ( N02 ) -> get ( ) == <STR_LIT> ) { SDValue N1 = N -> getOperand ( <NUM_LIT> ) ; if ( N01 == N1 ) { SDValue N2 = N -> getOperand ( <NUM_LIT> ) ; if ( N000 == N2 && N0 . getNode ( ) -> getValueType ( N0 . getResNo ( ) ) == <STR_LIT> && N00 . getNode ( ) -> getValueType ( N00 . getResNo ( ) ) == <STR_LIT> ) { SDNode * SextNode = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , N000 ) ; SDNode * Result = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( SextNode , <NUM_LIT> ) , N1 ) ; ReplaceUses ( N , Result ) ; return Result ; } }


<s> if ( N000 == N2 && N0 . getNode ( ) -> getValueType ( N0 . getResNo ( ) ) == <STR_LIT> && N00 . getNode ( ) -> getValueType ( N00 . getResNo ( ) ) == <STR_LIT> ) { SDNode * SextNode = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , N000 ) ; SDNode * Result = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( SextNode , <NUM_LIT> ) , N1 ) ; ReplaceUses ( N , Result ) ; return Result ; } } } if ( cast < CondCodeSDNode > ( N02 ) -> get ( ) == <STR_LIT> ) { SDValue N1 = N -> getOperand ( <NUM_LIT> ) ; if ( N01 == N1 ) { SDValue N2 = N -> getOperand ( <NUM_LIT> ) ; if ( N000 == N2 && N0 . getNode ( ) -> getValueType ( N0 . getResNo ( ) ) == <STR_LIT> && N00 . getNode ( ) -> getValueType ( N00 . getResNo ( ) ) == <STR_LIT> ) { SDNode * SextNode = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , N000 ) ; SDNode * Result = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( SextNode , <NUM_LIT> ) , N1 ) ; ReplaceUses ( N , Result ) ; return Result ; }


<s> if ( ConstantSDNode * CN = dyn_cast < ConstantSDNode > ( Val . getNode ( ) ) ) if ( isInt < <NUM_LIT> > ( CN -> getSExtValue ( ) ) ) { SDNode * Result = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , Mul_0 , Val ) ; ReplaceUses ( N , Result ) ; return Result ; } } } else if ( Shl_0 . getOpcode ( ) == <STR_LIT> ) { SDValue Sub_0 = Shl_0 . getOperand ( <NUM_LIT> ) ; SDValue Sub_1 = Shl_0 . getOperand ( <NUM_LIT> ) ; if ( Sub_0 . getOpcode ( ) == <STR_LIT> ) { int32_t SubConst = cast < ConstantSDNode > ( Sub_0 . getNode ( ) ) -> getSExtValue ( ) ; if ( SubConst == <NUM_LIT> ) { if ( Sub_1 . getOpcode ( ) == <STR_LIT> ) { SDValue Shl2_0 = Sub_1 . getOperand ( <NUM_LIT> ) ; SDValue Shl2_1 = Sub_1 . getOperand ( <NUM_LIT> ) ; if ( Shl2_1 . getOpcode ( ) == <STR_LIT> ) { int32_t ShlConst = cast < ConstantSDNode > ( Shl_1 . getNode ( ) ) -> getSExtValue ( ) ; int32_t Shl2Const = cast < ConstantSDNode > ( Shl2_1 . getNode ( ) ) -> getSExtValue ( ) ; int32_t ValConst = <NUM_LIT> << ( ShlConst + Shl2Const ) ; SDValue Val = CurDAG -> getTargetConstant ( - ValConst , <STR_LIT> ) ; if ( ConstantSDNode * CN = dyn_cast < ConstantSDNode > ( Val . getNode ( ) ) ) if ( isInt < <NUM_LIT> > ( CN -> getSExtValue ( ) ) ) { SDNode * Result = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , Shl2_0 , Val ) ;


<s> if ( Mul_1 . getOpcode ( ) == <STR_LIT> ) { int32_t ShlConst = cast < ConstantSDNode > ( Shl_1 . getNode ( ) ) -> getSExtValue ( ) ; int32_t MulConst = cast < ConstantSDNode > ( Mul_1 . getNode ( ) ) -> getSExtValue ( ) ; int32_t ValConst = MulConst << ShlConst ; SDValue Val = CurDAG -> getTargetConstant ( ValConst , <STR_LIT> ) ; if ( ConstantSDNode * CN = dyn_cast < ConstantSDNode > ( Val . getNode ( ) ) ) if ( isInt < <NUM_LIT> > ( CN -> getSExtValue ( ) ) ) { SDNode * Result = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , Mul_0 , Val ) ; ReplaceUses ( N , Result ) ; return Result ; } } } else if ( Shl_0 . getOpcode ( ) == <STR_LIT> ) {

SDValue Sub_0 = Shl_0 . getOperand ( <NUM_LIT> ) ;


<s> StoreSDNode * ST = cast < StoreSDNode > ( N ) ; <STR_LIT> AM = ST -> getAddressingMode ( ) ; if ( AM != <STR_LIT> ) { return SelectIndexedStore ( ST , dl ) ; } return SelectBaseOffsetStore ( ST , dl ) ;


<s> SDValue MulOp1 = Mul . getOperand ( <NUM_LIT> ) ; SDValue OP0 ; SDValue OP1 ; if ( MulOp0 . getOpcode ( ) == <STR_LIT> ) { SDValue Sext0 = MulOp0 . getOperand ( <NUM_LIT> ) ; if ( Sext0 . getNode ( ) -> getValueType ( <NUM_LIT> ) != <STR_LIT> ) { return 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> ) { return 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 ) ;


<s> 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> ) ; }


<s> FunctionPass * llvm :: create<ISA_LIT>ISelDag ( <ISA_LIT>TargetMachine & TM , CodeGenOpt :: Level OptLevel ) { return new <ISA_LIT>DAGToDAGISel ( TM , OptLevel ) ;


<s> inline bool <ISA_LIT>DAGToDAGISel :: foldGlobalAddress ( SDValue & N , SDValue & R ) { return foldGlobalAddressImpl ( N , R , false ) ;


<s> return foldGlobalAddressImpl ( N , R , true ) ;


<s> SDValue N1 = N . getOperand ( <NUM_LIT> ) ; if ( ( ShouldLookForGP && ( N0 . getOpcode ( ) == <STR_LIT> ) ) || ( ! ShouldLookForGP && ( N0 . getOpcode ( ) == <STR_LIT> ) ) ) { ConstantSDNode * Const = dyn_cast < ConstantSDNode > ( N1 ) ; GlobalAddressSDNode * GA = dyn_cast < GlobalAddressSDNode > ( N0 . getOperand ( <NUM_LIT> ) ) ; if ( Const && GA && ( GA -> getOpcode ( ) == <STR_LIT> ) ) { if ( ( N0 . getOpcode ( ) == <STR_LIT> ) && ! hasNumUsesBelowThresGA ( GA ) ) return false ; R = CurDAG -> getTargetGlobalAddress ( GA -> getGlobal ( ) , SDLoc ( Const ) , N . getValueType ( ) , GA -> getOffset ( ) + ( uint64_t ) Const -> getSExtValue ( ) ) ; return true ; } }


<s> if ( ( N0 . getOpcode ( ) == <STR_LIT> ) && ! hasNumUsesBelowThresGA ( GA ) ) return false ; R = CurDAG -> getTargetGlobalAddress ( GA -> getGlobal ( ) , SDLoc ( Const ) , N . getValueType ( ) , GA -> getOffset ( ) + ( uint64_t ) Const -> getSExtValue ( ) ) ; return true ; } }


<s> DenseMap < const GlobalValue * , unsigned > :: const_iterator GI = GlobalAddressUseCountMap . find ( GA -> getGlobal ( ) ) ; if ( GI == GlobalAddressUseCountMap . end ( ) ) return false ;

return GI -> second <= MaxNumOfUsesForConstExtenders ;


<s> bool <ISA_LIT>DAGToDAGISel :: hasNumUsesBelowThresGA ( SDNode * N ) const { assert ( N -> getOpcode ( ) == <STR_LIT> && <STR_LIT> ) ; if ( TM . getOptLevel ( ) == CodeGenOpt :: Aggressive ) return true ; GlobalAddressSDNode * GA = cast < GlobalAddressSDNode > ( N ) ; DenseMap < const GlobalValue * , unsigned > :: const_iterator GI = GlobalAddressUseCountMap . find ( GA -> getGlobal ( ) ) ; if ( GI == GlobalAddressUseCountMap . end ( ) ) return false ; return GI -> second <= MaxNumOfUsesForConstExtenders ;


<s> explicit <ISA_LIT>DAGToDAGISel ( <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> uint32_t c = CountPopulation_64 ( v ) ; return c == <NUM_LIT> ;


<s> static void initializePassOnce ( PassRegistry & Registry ) { const char * Name = <STR_LIT> ; PassInfo * PI = new PassInfo ( Name , <STR_LIT> , & SelectionDAGISel :: ID , <NUM_LIT> , false , false ) ; Registry . registerPass ( * PI , true ) ;


<s> for ( SDNode :: use_iterator I = N -> use_begin ( ) , E = N -> use_end ( ) ; I != E ; ++ I ) { UseCount ++ ; } return ( UseCount <= <NUM_LIT> ) ;


<s> SDLoc dl ( N ) ; if ( N -> getValueType ( <NUM_LIT> ) != <STR_LIT> ) { return SelectCode ( N ) ; } SDNode * Src1 = N -> getOperand ( <NUM_LIT> ) . getNode ( ) ; if ( Src1 -> getOpcode ( ) != <STR_LIT> || ! Src1 -> hasOneUse ( ) || Src1 -> getValueType ( <NUM_LIT> ) != <STR_LIT> ) { return SelectCode ( N ) ; } SDNode * Result = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , N -> getOperand ( <NUM_LIT> ) , Src1 -> getOperand ( <NUM_LIT> ) , Src1 -> getOperand ( <NUM_LIT> ) ) ; ReplaceUses ( N , Result ) ; return Result ;


<s> 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 ( ) ;


<s> 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 ) ;


<s> 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 ;


<s> 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 ; } }


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


<s> if ( LD -> getValueType ( <NUM_LIT> ) == <STR_LIT> && LD -> getExtensionType ( ) == <STR_LIT> ) { return SelectIndexedLoadZeroExtend64 ( LD , Opcode , dl ) ; } if ( LD -> getValueType ( <NUM_LIT> ) == <STR_LIT> && LD -> getExtensionType ( ) == <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> ) ;


<s> 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 . 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 ) ;


<s> 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> ) } ;


<s> return Result_3 ; } 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> , TargetConst0 ) ; SDNode * Result_3 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , <STR_LIT> , SDValue ( Result_2 , <NUM_LIT> ) , SDValue ( Result_1 , <NUM_LIT> ) ) ; SDNode * Result_4 = 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_3 , <NUM_LIT> ) , SDValue ( Result_4 , <NUM_LIT> ) , SDValue ( Result_1 , <NUM_LIT> ) } ; ReplaceUses ( Froms , Tos , <NUM_LIT> ) ; return Result_3 ;


<s> SDNode * OffsetNode = Offset . getNode ( ) ; int32_t Val = cast < ConstantSDNode > ( OffsetNode ) -> getSExtValue ( ) ; EVT StoredVT = ST -> getMemoryVT ( ) ; const <ISA_LIT>InstrInfo * TII = static_cast < const <ISA_LIT>InstrInfo * > ( TM . getInstrInfo ( ) ) ; if ( TII -> isValidAutoIncImm ( StoredVT , Val ) ) { SDValue Ops [ ] = { Base , CurDAG -> getTargetConstant ( Val , <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> ) ; 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> , <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> ;


<s> 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 { llvm_unreachable ( <STR_LIT> ) ; } } EVT ReturnValueVT = N -> getValueType ( <NUM_LIT> ) ;

SDNode * Result = CurDAG -> getMachineNode ( IntrinsicWithPred , dl , ReturnValueVT , Ops ) ;


<s> 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 , * 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 { llvm_unreachable ( <STR_LIT> ) ; }


<s> <STR_LIT> AM = LD -> getAddressingMode ( ) ; if ( AM != <STR_LIT> ) { result = SelectIndexedLoad ( LD , dl ) ; } else { result = SelectBaseOffsetLoad ( LD , dl ) ; } return result ;


<s> <STR_LIT> AM = LD -> getAddressingMode ( ) ; if ( AM != <STR_LIT> ) { result = SelectIndexedLoad ( LD , dl ) ; } else {

result = SelectBaseOffsetLoad ( LD , dl ) ;


<s> SDValue OP0 ; SDValue OP1 ; if ( MulOp0 . getOpcode ( ) == <STR_LIT> ) { SDValue Sext0 = MulOp0 . getOperand ( <NUM_LIT> ) ; if ( Sext0 . getNode ( ) -> getValueType ( <NUM_LIT> ) != <STR_LIT> ) { return 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> ) { return 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 ( ) ;


<s> if ( N000 == N2 && N0 . getNode ( ) -> getValueType ( N0 . getResNo ( ) ) == <STR_LIT> && N00 . getNode ( ) -> getValueType ( N00 . getResNo ( ) ) == <STR_LIT> ) { SDNode * SextNode = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , N000 ) ; SDNode * Result = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( SextNode , <NUM_LIT> ) , N1 ) ; ReplaceUses ( N , Result ) ; return Result ; } } } if ( cast < CondCodeSDNode > ( N02 ) -> get ( ) == <STR_LIT> ) { SDValue N1 = N -> getOperand ( <NUM_LIT> ) ; if ( N01 == N1 ) { SDValue N2 = N -> getOperand ( <NUM_LIT> ) ; if ( N000 == N2 && N0 . getNode ( ) -> getValueType ( N0 . getResNo ( ) ) == <STR_LIT> && N00 . getNode ( ) -> getValueType ( N00 . getResNo ( ) ) == <STR_LIT> ) { SDNode * SextNode = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , N000 ) ; SDNode * Result = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( SextNode , <NUM_LIT> ) , N1 ) ; ReplaceUses ( N , Result ) ; return Result ; } }


<s> return Result ; } } } if ( cast < CondCodeSDNode > ( N02 ) -> get ( ) == <STR_LIT> ) { SDValue N1 = N -> getOperand ( <NUM_LIT> ) ; if ( N01 == N1 ) { SDValue N2 = N -> getOperand ( <NUM_LIT> ) ; if ( N000 == N2 && N0 . getNode ( ) -> getValueType ( N0 . getResNo ( ) ) == <STR_LIT> && N00 . getNode ( ) -> getValueType ( N00 . getResNo ( ) ) == <STR_LIT> ) { SDNode * SextNode = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , N000 ) ; SDNode * Result = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( SextNode , <NUM_LIT> ) , N1 ) ; ReplaceUses ( N , Result ) ; return Result ;


<s> SDValue Mul_1 = Shl_0 . getOperand ( <NUM_LIT> ) ; if ( Mul_1 . getOpcode ( ) == <STR_LIT> ) { int32_t ShlConst = cast < ConstantSDNode > ( Shl_1 . getNode ( ) ) -> getSExtValue ( ) ; int32_t MulConst = cast < ConstantSDNode > ( Mul_1 . getNode ( ) ) -> getSExtValue ( ) ; int32_t ValConst = MulConst << ShlConst ; SDValue Val = CurDAG -> getTargetConstant ( ValConst , <STR_LIT> ) ; if ( ConstantSDNode * CN = dyn_cast < ConstantSDNode > ( Val . getNode ( ) ) ) if ( isInt < <NUM_LIT> > ( CN -> getSExtValue ( ) ) ) { SDNode * Result = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , Mul_0 , Val ) ; ReplaceUses ( N , Result ) ; return Result ; } } } else if ( Shl_0 . getOpcode ( ) == <STR_LIT> ) { SDValue Sub_0 = Shl_0 . getOperand ( <NUM_LIT> ) ; SDValue Sub_1 = Shl_0 . getOperand ( <NUM_LIT> ) ; if ( Sub_0 . getOpcode ( ) == <STR_LIT> ) { int32_t SubConst = cast < ConstantSDNode > ( Sub_0 . getNode ( ) ) -> getSExtValue ( ) ; if ( SubConst == <NUM_LIT> ) { if ( Sub_1 . getOpcode ( ) == <STR_LIT> ) { SDValue Shl2_0 = Sub_1 . getOperand ( <NUM_LIT> ) ; SDValue Shl2_1 = Sub_1 . getOperand ( <NUM_LIT> ) ; if ( Shl2_1 . getOpcode ( ) == <STR_LIT> ) { int32_t ShlConst = cast < ConstantSDNode > ( Shl_1 . getNode ( ) ) -> getSExtValue ( ) ; int32_t Shl2Const = cast < ConstantSDNode > ( Shl2_1 . getNode ( ) ) -> getSExtValue ( ) ; int32_t ValConst = <NUM_LIT> << ( ShlConst + Shl2Const ) ; SDValue Val = CurDAG -> getTargetConstant ( - ValConst , <STR_LIT> ) ; if ( ConstantSDNode * CN = dyn_cast < ConstantSDNode > ( Val . getNode ( ) ) ) if ( isInt < <NUM_LIT> > ( CN -> getSExtValue ( ) ) ) { SDNode * Result = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , Shl2_0 , Val ) ; ReplaceUses ( N , Result ) ; return Result ; } } } }


<s> <STR_LIT> AM = ST -> getAddressingMode ( ) ; if ( AM != <STR_LIT> ) { return SelectIndexedStore ( ST , dl ) ; } return SelectBaseOffsetStore ( ST , dl ) ;


<s> 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 ) ;


<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 ; }


<s> return CurDAG -> getTargetConstant ( - Imm , <STR_LIT> ) ;


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


<s> SDValue XformMskToBitPosU3Imm ( uint8_t Imm ) { return XformMskToBitPosU5Imm ( Imm ) ;


<s> SDValue XformMskToBitPosU3Imm ( uint8_t Imm ) {


<s> assert ( bitPos >= <NUM_LIT> && bitPos < <NUM_LIT> && <STR_LIT> ) ;

return CurDAG -> getTargetConstant ( bitPos , <STR_LIT> ) ;


<s> int32_t bitPos ; bitPos = Log2_32 ( Imm ) ;

assert ( bitPos >= <NUM_LIT> && bitPos < <NUM_LIT> && <STR_LIT> ) ;


<s> inline SDValue XformSToSM1Imm ( signed Imm ) { return CurDAG -> getTargetConstant ( Imm - <NUM_LIT> , <STR_LIT> ) ;


<s> inline SDValue XformSToSM1Imm ( signed Imm ) {

return CurDAG -> getTargetConstant ( Imm - <NUM_LIT> , <STR_LIT> ) ;


<s> return CurDAG -> getTargetConstant ( Imm - <NUM_LIT> , <STR_LIT> ) ;


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


<s> Worklist . push_back ( BasePtr . getOperand ( <NUM_LIT> ) . getNode ( ) ) ; Worklist . push_back ( BasePtr . getOperand ( <NUM_LIT> ) . getNode ( ) ) ; while ( ! Worklist . empty ( ) ) { SDNode * N = Worklist . pop_back_val ( ) ; unsigned Opcode = N -> getOpcode ( ) ; if ( ! isOpcodeHandled ( N ) ) continue ; Worklist . push_back ( N -> getOperand ( <NUM_LIT> ) . getNode ( ) ) ; Worklist . push_back ( N -> getOperand ( <NUM_LIT> ) . getNode ( ) ) ; if ( N -> hasOneUse ( ) && Opcode == N -> use_begin ( ) -> getOpcode ( ) ) continue ; if ( RootWeights . count ( N ) ) continue ; RootWeights [ N ] = - <NUM_LIT> ; } 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> ) ) ; LLVM_DEBUG ( dbgs ( ) << <STR_LIT> ) ; LLVM_DEBUG ( N -> dump ( CurDAG ) ) ; } CurDAG -> RemoveDeadNodes ( ) ; GAUsesInFunction . clear ( ) ; RootHeights . clear ( ) ; RootWeights . clear ( ) ;


<s> Worklist . push_back ( N -> getOperand ( <NUM_LIT> ) . getNode ( ) ) ; Worklist . push_back ( N -> getOperand ( <NUM_LIT> ) . getNode ( ) ) ; if ( N -> hasOneUse ( ) && Opcode == N -> use_begin ( ) -> getOpcode ( ) ) continue ; if ( RootWeights . count ( N ) ) continue ; RootWeights [ N ] = - <NUM_LIT> ; } 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> ) ) ;


<s> 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 ( N ) ; case <STR_LIT> : return SelectD2P ( N ) ; case <STR_LIT> : return SelectQ2V ( N ) ; case <STR_LIT> : return SelectV2Q ( N ) ; } if ( HST -> useHVXOps ( ) ) { switch ( N -> getOpcode ( ) ) { case <STR_LIT> : return SelectHvxShuffle ( N ) ; case <STR_LIT> : return SelectHvxRor ( N ) ;


<s> case <STR_LIT> : return SelectConstantFP ( N ) ; case <STR_LIT> : return SelectFrameIndex ( 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 ( N ) ; case <STR_LIT> : return SelectD2P ( N ) ; case <STR_LIT> : return SelectQ2V ( N ) ; case <STR_LIT> : return SelectV2Q ( N ) ;


<s> } SDValue IncV = CurDAG -> getTargetConstant ( Inc , dl , <STR_LIT> ) ; MachineSDNode :: mmo_iterator MemOp = MF -> allocateMemRefsArray ( <NUM_LIT> ) ; MemOp [ <NUM_LIT> ] = LD -> getMemOperand ( ) ; auto getExt64 = [ this , ExtType ] ( MachineSDNode * N , const SDLoc & dl ) -> MachineSDNode * { if ( ExtType == <STR_LIT> || ExtType == <STR_LIT> ) { SDValue Zero = CurDAG -> getTargetConstant ( <NUM_LIT> , dl , <STR_LIT> ) ; return CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , Zero , SDValue ( N , <NUM_LIT> ) ) ; } if ( ExtType == <STR_LIT> ) return CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( N , <NUM_LIT> ) ) ; return N ; } ; SDValue From [ <NUM_LIT> ] = { SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) , SDValue ( LD , <NUM_LIT> ) } ; SDValue To [ <NUM_LIT> ] ; EVT ValueVT = LD -> getValueType ( <NUM_LIT> ) ; if ( ValueVT == <STR_LIT> && ExtType != <STR_LIT> ) { assert ( LoadedVT . getSizeInBits ( ) <= <NUM_LIT> ) ; ValueVT = <STR_LIT> ; } if ( IsValidInc ) { MachineSDNode * L = CurDAG -> getMachineNode ( Opcode , dl , ValueVT , <STR_LIT> , <STR_LIT> , Base , IncV , Chain ) ; L -> setMemRefs ( MemOp , MemOp + <NUM_LIT> ) ; To [ <NUM_LIT> ] = SDValue ( L , <NUM_LIT> ) ; To [ <NUM_LIT> ] = SDValue ( L , <NUM_LIT> ) ; if ( LD -> getValueType ( <NUM_LIT> ) == <STR_LIT> ) L = getExt64 ( L , dl ) ; To [ <NUM_LIT> ] = SDValue ( L , <NUM_LIT> ) ; } else { SDValue Zero = CurDAG -> getTargetConstant ( <NUM_LIT> , dl , <STR_LIT> ) ; MachineSDNode * L = CurDAG -> getMachineNode ( Opcode , dl , ValueVT , <STR_LIT> , Base , Zero , Chain ) ; L -> setMemRefs ( MemOp , MemOp + <NUM_LIT> ) ; To [ <NUM_LIT> ] = SDValue ( L , <NUM_LIT> ) ; MachineSDNode * A = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , Base , IncV ) ; To [ <NUM_LIT> ] = SDValue ( A , <NUM_LIT> ) ;


<s> 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> : 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 ( ) ; SDValue From [ <NUM_LIT> ] = { SDValue ( ST , <NUM_LIT> ) , SDValue ( ST , <NUM_LIT> ) } ; SDValue To [ <NUM_LIT> ] ; if ( IsValidInc ) { SDValue Ops [ ] = { Base , IncV , Value , Chain } ; MachineSDNode * S = CurDAG -> getMachineNode ( Opcode , dl , <STR_LIT> , <STR_LIT> , Ops ) ;

S -> setMemRefs ( MemOp , MemOp + <NUM_LIT> ) ;


<s> initialize<ISA_LIT>DAGToDAGISelPass ( * PassRegistry :: getPassRegistry ( ) ) ;


<s> return true ; } } if ( ConstantSDNode * C = dyn_cast < ConstantSDNode > ( Val . getOperand ( <NUM_LIT> ) ) ) { if ( C -> getZExtValue ( ) == FromMask ) { Src = Val . getOperand ( <NUM_LIT> ) ; return true ; } } break ; } case <STR_LIT> : case <STR_LIT> : { uint64_t FromMask = ( <NUM_LIT> << FromBits ) - <NUM_LIT> ; if ( ConstantSDNode * C = dyn_cast < ConstantSDNode > ( Val . getOperand ( <NUM_LIT> ) ) ) { if ( ( C -> getZExtValue ( ) & FromMask ) == <NUM_LIT> ) { Src = Val . getOperand ( <NUM_LIT> ) ; return true ; } } if ( ConstantSDNode * C = dyn_cast < ConstantSDNode > ( Val . getOperand ( <NUM_LIT> ) ) ) { if ( ( C -> getZExtValue ( ) & FromMask ) == <NUM_LIT> ) { Src = Val . getOperand ( <NUM_LIT> ) ; return true ;


<s> bool runOnMachineFunction ( MachineFunction & MF ) override { Subtarget = & MF . getSubtarget < <ISA_LIT>Subtarget > ( ) ; return SelectionDAGISel :: runOnMachineFunction ( MF ) ;


<s> return SelectAdd ( N ) ; case <STR_LIT> : return SelectSHL ( N ) ; case <STR_LIT> : return SelectLoad ( N ) ; case <STR_LIT> : return SelectStore ( N ) ; case <STR_LIT> : return SelectSelect ( N ) ; case <STR_LIT> : return SelectTruncate ( N ) ;


<s> switch ( N -> getOpcode ( ) ) { case <STR_LIT> : return SelectConstant ( N ) ; case <STR_LIT> : return SelectConstantFP ( N ) ; case <STR_LIT> : return SelectAdd ( N ) ; case <STR_LIT> : return SelectSHL ( N ) ; case <STR_LIT> : return SelectLoad ( N ) ; case <STR_LIT> :


<s> if ( N . getOpcode ( ) != <STR_LIT> ) return false ; FrameIndexSDNode * FX = cast < FrameIndexSDNode > ( N ) ;

R = CurDAG -> getTargetFrameIndex ( FX -> getIndex ( ) , <STR_LIT> ) ;


<s> bool <ISA_LIT>DAGToDAGISel :: SelectAddrFI ( SDValue & N , SDValue & R ) {

if ( N . getOpcode ( ) != <STR_LIT> ) return false ;


<s> EVT LoadedVT = LD -> getMemoryVT ( ) ; int64_t Offset = cast < GlobalAddressSDNode > ( Base ) -> getOffset ( ) ; if ( Offset != <NUM_LIT> && OffsetFitsS11 ( LoadedVT , Offset ) ) { MVT PointerTy = getTargetLowering ( ) -> 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> ) ;


<s> SDLoc dl ( N ) ; 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 ; } }


<s> else Opcode = zextval ? <STR_LIT> : <STR_LIT> ; } else llvm_unreachable ( <STR_LIT> ) ; if ( LD -> getValueType ( <NUM_LIT> ) == <STR_LIT> && LD -> getExtensionType ( ) == <STR_LIT> ) { return SelectIndexedLoadZeroExtend64 ( LD , Opcode , dl ) ; } if ( LD -> getValueType ( <NUM_LIT> ) == <STR_LIT> && LD -> getExtensionType ( ) == <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 ) ;


<s> 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 = Subtarget -> 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 ; }


<s> 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 , <NUM_LIT> ) ; return Result_2 ;


<s> if ( SelectADDRriS11_2 ( N1 , CPTmpN1_0 , CPTmpN1_1 ) && N1 . getNode ( ) -> getValueType ( <NUM_LIT> ) == <STR_LIT> ) { const <ISA_LIT>InstrInfo * TII = Subtarget -> 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 ) ; 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> ) ) ; 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_3 , <NUM_LIT> ) , SDValue ( Result_1 , <NUM_LIT> ) , SDValue ( Result_1 , <NUM_LIT> ) } ; ReplaceUses ( Froms , Tos , <NUM_LIT> ) ; return Result_3 ; } 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> , TargetConst0 ) ; SDNode * Result_3 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , <STR_LIT> , SDValue ( Result_2 , <NUM_LIT> ) , SDValue ( Result_1 , <NUM_LIT> ) ) ;

SDNode * Result_4 = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , Base , TargetConstVal , SDValue ( Result_1 , <NUM_LIT> ) ) ;


<s> SDValue MulOp0 = N -> getOperand ( <NUM_LIT> ) ; SDValue MulOp1 = N -> getOperand ( <NUM_LIT> ) ; SDValue OP0 ; SDValue OP1 ; if ( MulOp0 . getOpcode ( ) == <STR_LIT> ) { SDValue Sext0 = MulOp0 . getOperand ( <NUM_LIT> ) ; if ( Sext0 . getNode ( ) -> getValueType ( <NUM_LIT> ) != <STR_LIT> ) { return 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> ) { return 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 {


<s> } if ( cast < CondCodeSDNode > ( N02 ) -> get ( ) == <STR_LIT> ) { SDValue N1 = N -> getOperand ( <NUM_LIT> ) ; if ( N01 == N1 ) { SDValue N2 = N -> getOperand ( <NUM_LIT> ) ; if ( N000 == N2 && N0 . getNode ( ) -> getValueType ( N0 . getResNo ( ) ) == <STR_LIT> && N00 . getNode ( ) -> getValueType ( N00 . getResNo ( ) ) == <STR_LIT> ) { SDNode * SextNode = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , N000 ) ; SDNode * Result = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , SDValue ( SextNode , <NUM_LIT> ) , N1 ) ; ReplaceUses ( N , Result ) ; return Result ; } } } }


<s> int32_t SubConst = cast < ConstantSDNode > ( Sub_0 . getNode ( ) ) -> getSExtValue ( ) ; if ( SubConst == <NUM_LIT> ) { if ( Sub_1 . getOpcode ( ) == <STR_LIT> ) { SDValue Shl2_0 = Sub_1 . getOperand ( <NUM_LIT> ) ; SDValue Shl2_1 = Sub_1 . getOperand ( <NUM_LIT> ) ; if ( Shl2_1 . getOpcode ( ) == <STR_LIT> ) { int32_t ShlConst = cast < ConstantSDNode > ( Shl_1 . getNode ( ) ) -> getSExtValue ( ) ; int32_t Shl2Const = cast < ConstantSDNode > ( Shl2_1 . getNode ( ) ) -> getSExtValue ( ) ; int32_t ValConst = <NUM_LIT> << ( ShlConst + Shl2Const ) ; SDValue Val = CurDAG -> getTargetConstant ( - ValConst , <STR_LIT> ) ; if ( ConstantSDNode * CN = dyn_cast < ConstantSDNode > ( Val . getNode ( ) ) ) if ( isInt < <NUM_LIT> > ( CN -> getSExtValue ( ) ) ) { SDNode * Result = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , Shl2_0 , Val ) ; ReplaceUses ( N , Result ) ; return Result ; } } }


<s> } int32_t ShiftConst = cast < ConstantSDNode > ( ShiftOp1 . getNode ( ) ) -> getSExtValue ( ) ; if ( ShiftConst != <NUM_LIT> ) { return SelectCode ( N ) ; } SDValue Mul = ShiftOp0 ; if ( Mul . getOpcode ( ) != <STR_LIT> ) { return SelectCode ( N ) ; } SDValue MulOp0 = Mul . getOperand ( <NUM_LIT> ) ; SDValue MulOp1 = Mul . getOperand ( <NUM_LIT> ) ; SDValue OP0 ; SDValue OP1 ; if ( MulOp0 . getOpcode ( ) == <STR_LIT> ) { SDValue Sext0 = MulOp0 . getOperand ( <NUM_LIT> ) ; if ( Sext0 . getNode ( ) -> getValueType ( <NUM_LIT> ) != <STR_LIT> ) { return 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> ) { return 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> ) ; OP1 = SDValue ( CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , <STR_LIT> , LD -> getBasePtr ( ) , TargetConst0 , Chain ) , <NUM_LIT> ) ; } else {