<s> <ISA_LIT>MCInstLower MCInstLowering ( OutContext , * this ) ; MachineBasicBlock :: const_instr_iterator I = MI -> getIterator ( ) ; MachineBasicBlock :: const_instr_iterator E = MI -> getParent ( ) -> instr_end ( ) ; do { MCInst TmpInst ;

MCInstLowering . Lower ( & * I , TmpInst ) ;


<s> OutStreamer -> EmitRawText ( <STR_LIT> ) ;


<s> void <ISA_LIT>AsmPrinter :: EmitStartOfAsmFile ( Module & module ) {

OutStreamer -> EmitRawText ( <STR_LIT> ) ;


<s> <ISA_LIT>AsmPrinter ( TargetMachine & TM , std :: unique_ptr < MCStreamer > Streamer ) : AsmPrinter ( TM , std :: move ( Streamer ) ) {


<s> StringRef getPassName ( ) const override {


<s> RegisterAsmPrinter < <ISA_LIT>AsmPrinter > X ( getThe<ISA_LIT>Target ( ) ) ;


<s> <ISA_LIT>FiMalkrz ( ) : MachineFunctionPass ( ID ) {


<s> return MachineFunctionProperties ( ) . set ( MachineFunctionProperties :: Property :: NoVRegs ) ;


<s> const <ISA_LIT>InstrInfo & TII = * static_cast < const <ISA_LIT>InstrInfo * > ( F . getSubtarget ( ) . getInstrInfo ( ) ) ; for ( auto & BB : F ) { for ( MachineBasicBlock :: iterator I = BB . begin ( ) ; I != BB . end ( ) ; ) { MachineInstr & MI = * I ; DebugLoc DL = MI . getDebugLoc ( ) ; unsigned Opc = MI . getOpcode ( ) ; unsigned FiOpc = TII . getFiFromFiMalkrz ( Opc ) ; if ( FiOpc != <STR_LIT> ) { DEBUG ( dbgs ( ) << <STR_LIT> ) ; DEBUG ( MI . dump ( ) ) ; MIBundleBuilder Bundle ( BB , I ) ; unsigned MalkrzOpc = TII . getMalkrzFromFiMalkrz ( Opc ) ; unsigned MalkrzNumOperands = TII . get ( MalkrzOpc ) . getNumOperands ( ) ; MachineInstrBuilder Malkrz = BuildMI ( F , DL , TII . get ( MalkrzOpc ) ) ; for ( unsigned i = <NUM_LIT> ; i < MalkrzNumOperands ; i ++ ) { Malkrz . add ( MI . getOperand ( i ) ) ; } Bundle . prepend ( Malkrz ) ; unsigned FiNumOperands = TII . get ( FiOpc ) . getNumOperands ( ) ; MachineInstrBuilder Fi = BuildMI ( F , DL , TII . get ( FiOpc ) ) ; for ( unsigned i = <NUM_LIT> ; i < FiNumOperands ; i ++ ) { Fi . add ( MI . getOperand ( i + MalkrzNumOperands ) ) ; } Bundle . prepend ( Fi ) ; I = BB . erase ( MI ) ; } else {


<s> if ( FiOpc != <STR_LIT> ) { DEBUG ( dbgs ( ) << <STR_LIT> ) ; DEBUG ( MI . dump ( ) ) ; MIBundleBuilder Bundle ( BB , I ) ; unsigned MalkrzOpc = TII . getMalkrzFromFiMalkrz ( Opc ) ; unsigned MalkrzNumOperands = TII . get ( MalkrzOpc ) . getNumOperands ( ) ; MachineInstrBuilder Malkrz = BuildMI ( F , DL , TII . get ( MalkrzOpc ) ) ; for ( unsigned i = <NUM_LIT> ; i < MalkrzNumOperands ; i ++ ) { Malkrz . add ( MI . getOperand ( i ) ) ; } Bundle . prepend ( Malkrz ) ; unsigned FiNumOperands = TII . get ( FiOpc ) . getNumOperands ( ) ; MachineInstrBuilder Fi = BuildMI ( F , DL , TII . get ( FiOpc ) ) ; for ( unsigned i = <NUM_LIT> ; i < FiNumOperands ; i ++ ) { Fi . add ( MI . getOperand ( i + MalkrzNumOperands ) ) ; }


<s> MachineBasicBlock :: iterator <ISA_LIT>FrameLowering :: eliminateCallFramePseudoInstr ( MachineFunction & MF , MachineBasicBlock & MBB , MachineBasicBlock :: iterator I ) const { const <ISA_LIT>InstrInfo & TII = * static_cast < const <ISA_LIT>InstrInfo * > ( MF . getSubtarget ( ) . getInstrInfo ( ) ) ; MachineInstr & Old = * I ; DebugLoc DL = Old . getDebugLoc ( ) ; unsigned Amount = TII . getFrameSize ( Old ) ; if ( Amount != <NUM_LIT> ) { unsigned Opc = Old . getOpcode ( ) ; if ( Opc == <STR_LIT> ) { BuildMI ( MBB , I , DL , TII . get ( <STR_LIT> ) , <STR_LIT> ) . addReg ( <STR_LIT> ) . addImm ( Amount ) ; } else { assert ( Opc == <STR_LIT> ) ; BuildMI ( MBB , I , DL , TII . get ( <STR_LIT> ) , <STR_LIT> ) . addReg ( <STR_LIT> ) . addImm ( Amount ) ; } }


<s> MachineBasicBlock :: iterator MBBI = MBB . getLastNonDebugInstr ( ) ; DebugLoc DL = MBBI -> getDebugLoc ( ) ; uint64_t StackSize = MFI . getStackSize ( ) ; if ( StackSize ) { BuildMI ( MBB , MBBI , DL , TII . get ( <STR_LIT> ) , <STR_LIT> ) . addReg ( <STR_LIT> ) . addImm ( StackSize ) ;


<s> DebugLoc DL = MBBI != MBB . end ( ) ? MBBI -> getDebugLoc ( ) : DebugLoc ( ) ; uint64_t StackSize = MFI . getStackSize ( ) ; if ( StackSize ) { BuildMI ( MBB , MBBI , DL , TII . get ( <STR_LIT> ) , <STR_LIT> ) . addReg ( <STR_LIT> ) . addImm ( StackSize ) ;


<s> explicit <ISA_LIT>FrameLowering ( ) : TargetFrameLowering ( TargetFrameLowering :: StackGrowsDown , <NUM_LIT> , <NUM_LIT> ) {


<s> bool <ISA_LIT>FrameLowering :: hasFP ( const MachineFunction & MF ) const {


<s> return TargetFrameLowering :: needsFrameIndexResolution ( MF ) || ! canSimplifyCallFramePseudos ( MF ) ;


<s> bool <ISA_LIT>FrameLowering :: needsFrameIndexResolution ( const MachineFunction & MF ) const { return TargetFrameLowering :: needsFrameIndexResolution ( MF ) || ! canSimplifyCallFramePseudos ( MF ) ;


<s> <ISA_LIT>InstPrinter ( const MCAsmInfo & MAI , const MCInstrInfo & MII , const MCRegisterInfo & MRI ) : MCInstPrinter ( MAI , MII , MRI ) {


<s> <STR_LIT> CC = ( <STR_LIT> ) MI -> getOperand ( OpNo ) . getImm ( ) ;


<s> <STR_LIT> CC = ( <STR_LIT> ) MI -> getOperand ( OpNo ) . getImm ( ) ; O << <ISA_LIT>CCToString ( CC ) ;


<s> void <ISA_LIT>InstPrinter :: printInst ( const MCInst * MI , raw_ostream & O , StringRef Annot , const MCSubtargetInfo & STI ) {


<s> } if ( dispImm . isImm ( ) ) { if ( dispImm . getImm ( ) ) { O << '+' ; printOperand ( MI , OpNo + <NUM_LIT> , O ) ; } } else { O << '+' ; assert ( dispImm . isExpr ( ) && <STR_LIT> ) ; dispImm . getExpr ( ) -> print ( O , & MAI ) ;


<s> const MCOperand & dispReg = MI -> getOperand ( OpNo + <NUM_LIT> ) ; const MCOperand & dispImm = MI -> getOperand ( OpNo + <NUM_LIT> ) ; printOperand ( MI , OpNo , O ) ; if ( dispReg . getReg ( ) ) { O << '+' ; printOperand ( MI , OpNo + <NUM_LIT> , O ) ; } if ( dispImm . isImm ( ) ) { if ( dispImm . getImm ( ) ) { O << '+' ;


<s> } else if ( Op . isImm ( ) ) { O << ( uint32_t ) Op . getImm ( ) ; } else { assert ( Op . isExpr ( ) && <STR_LIT> ) ;

Op . getExpr ( ) -> print ( O , & MAI ) ;


<s> O << ( uint32_t ) Op . getImm ( ) ; } else { assert ( Op . isExpr ( ) && <STR_LIT> ) ; Op . getExpr ( ) -> print ( O , & MAI ) ;


<s> TBB = I -> getOperand ( <NUM_LIT> ) . getMBB ( ) ; continue ; } assert ( getMalkrzFromFiMalkrz ( I -> getOpcode ( ) ) == <STR_LIT> && <STR_LIT> ) ; if ( Cond . empty ( ) ) { FBB = TBB ; TBB = I -> getOperand ( <NUM_LIT> ) . getMBB ( ) ; Cond . push_back ( MachineOperand :: CreateImm ( I -> getOpcode ( ) ) ) ; for ( unsigned i = <NUM_LIT> ; i < I -> getNumOperands ( ) ; i ++ ) {

Cond . push_back ( I -> getOperand ( i ) ) ;


<s> -- I ; if ( I -> isDebugValue ( ) ) continue ; if ( ! isUnpredicatedTerminator ( * I ) ) break ; if ( ! I -> isBranch ( ) ) return true ; if ( I -> isIndirectBranch ( ) ) return true ; if ( I -> getOpcode ( ) == <STR_LIT> ) { if ( ! AllowModify ) { TBB = I -> getOperand ( <NUM_LIT> ) . getMBB ( ) ; continue ; } while ( std :: next ( I ) != MBB . end ( ) ) std :: next ( I ) -> eraseFromParent ( ) ;


<s> void <ISA_LIT>InstrInfo :: anchor ( ) {


<s> BuildMI ( MBB , I , DL , get ( <STR_LIT> ) , DestReg ) . addReg ( SrcReg , getKillRegState ( KillSrc ) ) ;


<s> void <ISA_LIT>InstrInfo :: copyPhysReg ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator I , const DebugLoc & DL , unsigned DestReg , unsigned SrcReg , bool KillSrc ) const {

BuildMI ( MBB , I , DL , get ( <STR_LIT> ) , DestReg ) . addReg ( SrcReg , getKillRegState ( KillSrc ) ) ;


<s> <ISA_LIT>InstrInfo :: <ISA_LIT>InstrInfo ( <ISA_LIT>Subtarget & STI ) : <ISA_LIT>GenInstrInfo ( <STR_LIT> , <STR_LIT> ) , RI ( ) {


<s> unsigned <ISA_LIT>InstrInfo :: getFiFromFiMalkrz ( unsigned Opc ) const { switch ( Opc ) { default : return <STR_LIT> ; case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : case <STR_LIT> : case <STR_LIT> :


<s> assert ( isFrameInstr ( I ) && <STR_LIT> ) ; assert ( I . getOperand ( <NUM_LIT> ) . getImm ( ) >= <NUM_LIT> && <STR_LIT> ) ; return I . getOperand ( <NUM_LIT> ) . getImm ( ) ;


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


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


<s> void <ISA_LIT>InstrInfo :: getNoop ( MCInst & NopInst ) const {


<s> void <ISA_LIT>InstrInfo :: getNoop ( MCInst & NopInst ) const { NopInst . setOpcode ( <STR_LIT> ) ;


<s> assert ( ( Cond . empty ( ) || ( getMalkrzFromFiMalkrz ( Cond [ <NUM_LIT> ] . getImm ( ) ) == <STR_LIT> && get ( Cond [ <NUM_LIT> ] . getImm ( ) ) . getNumOperands ( ) == Cond . size ( ) ) ) && <STR_LIT> ) ; assert ( ! BytesAdded && <STR_LIT> ) ; if ( Cond . empty ( ) ) { assert ( ! FBB && <STR_LIT> ) ; BuildMI ( & MBB , DL , get ( <STR_LIT> ) ) . addMBB ( TBB ) ; return <NUM_LIT> ; } unsigned Count = <NUM_LIT> ; MachineInstrBuilder Malkrz = BuildMI ( & MBB , DL , get ( Cond [ <NUM_LIT> ] . getImm ( ) ) ) . addMBB ( TBB ) ; for ( unsigned i = <NUM_LIT> ; i < Cond . size ( ) ; i ++ ) { Malkrz . add ( Cond [ i ] ) ; } ++ Count ; if ( FBB ) { BuildMI ( & MBB , DL , get ( <STR_LIT> ) ) . addMBB ( FBB ) ;


<s> if ( MI . isBranch ( ) && ! MI . isBarrier ( ) ) return true ; if ( ! MI . isPredicable ( ) ) return true ;


<s> bool <ISA_LIT>InstrInfo :: isUnpredicatedTerminator ( const MachineInstr & MI ) const {

if ( ! MI . isTerminator ( ) ) return false ;


<s> void <ISA_LIT>InstrInfo :: loadRegFromStackSlot ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , unsigned DestReg , int FrameIdx , const TargetRegisterClass * RC , const TargetRegisterInfo * TRI ) const { DebugLoc DL ; if ( MI != MBB . end ( ) ) DL = MI -> getDebugLoc ( ) ; MachineFunction & MF = * MBB . getParent ( ) ; MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; MachineMemOperand * MMO = MF . getMachineMemOperand ( MachinePointerInfo :: getFixedStack ( MF , FrameIdx ) , MachineMemOperand :: MOLoad , MFI . getObjectSize ( FrameIdx ) , MFI . getObjectAlignment ( FrameIdx ) ) ;

BuildMI ( MBB , MI , DL , get ( <STR_LIT> ) ) . addReg ( DestReg , getDefRegState ( true ) ) . addFrameIndex ( FrameIdx ) . addReg ( <NUM_LIT> ) . addImm ( <NUM_LIT> ) . addMemOperand ( MMO ) ;


<s> if ( MI != MBB . end ( ) ) DL = MI -> getDebugLoc ( ) ; MachineFunction & MF = * MBB . getParent ( ) ; MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; MachineMemOperand * MMO = MF . getMachineMemOperand ( MachinePointerInfo :: getFixedStack ( MF , FrameIdx ) , MachineMemOperand :: MOLoad , MFI . getObjectSize ( FrameIdx ) , MFI . getObjectAlignment ( FrameIdx ) ) ; BuildMI ( MBB , MI , DL , get ( <STR_LIT> ) ) . addReg ( DestReg , getDefRegState ( true ) ) . addFrameIndex ( FrameIdx ) . addReg ( <NUM_LIT> ) . addImm ( <NUM_LIT> ) . addMemOperand ( MMO ) ;


<s> assert ( ! BytesRemoved && <STR_LIT> ) ; MachineBasicBlock :: iterator I = MBB . end ( ) ; unsigned Count = <NUM_LIT> ; while ( I != MBB . begin ( ) ) { -- I ; if ( I -> isDebugValue ( ) ) continue ; if ( ! I -> isBranch ( ) ) break ; I -> eraseFromParent ( ) ; I = MBB . end ( ) ; ++ Count ;


<s> <STR_LIT> CC = static_cast < <STR_LIT> > ( Cond . back ( ) . getImm ( ) ) ;

Cond . back ( ) = MachineOperand :: CreateImm ( Opposite<ISA_LIT>CC ( CC ) ) ;


<s> MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; MachineMemOperand * MMO = MF . getMachineMemOperand ( MachinePointerInfo :: getFixedStack ( MF , FrameIdx ) , MachineMemOperand :: MOStore , MFI . getObjectSize ( FrameIdx ) , MFI . getObjectAlignment ( FrameIdx ) ) ; BuildMI ( MBB , MI , DL , get ( <STR_LIT> ) ) . addFrameIndex ( FrameIdx ) . addReg ( <NUM_LIT> ) . addImm ( <NUM_LIT> ) . addReg ( SrcReg , getKillRegState ( isKill ) ) . addMemOperand ( MMO ) ;


<s> MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; MachineMemOperand * MMO = MF . getMachineMemOperand ( MachinePointerInfo :: getFixedStack ( MF , FrameIdx ) , MachineMemOperand :: MOStore , MFI . getObjectSize ( FrameIdx ) , MFI . getObjectAlignment ( FrameIdx ) ) ;

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


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


<s> <ISA_LIT>DAGToDAGISel ( <ISA_LIT>TargetMachine & TM , CodeGenOpt :: Level OptLevel ) : SelectionDAGISel ( TM , OptLevel ) {


<s> StringRef getPassName ( ) const override {


<s> void <ISA_LIT>DAGToDAGISel :: Select ( SDNode * Node ) { SDLoc dl ( Node ) ; if ( Node -> isMachineOpcode ( ) ) { Node -> setNodeId ( - <NUM_LIT> ) ; return ; } switch ( Node -> getOpcode ( ) ) { default : break ; case <STR_LIT> : { int FI = cast < FrameIndexSDNode > ( Node ) -> getIndex ( ) ; SDValue TFI = CurDAG -> getTargetFrameIndex ( FI , TLI -> getPointerTy ( CurDAG -> getDataLayout ( ) ) ) ; CurDAG -> SelectNodeTo ( Node , <STR_LIT> , <STR_LIT> , TFI , CurDAG -> getTargetConstant ( <NUM_LIT> , dl , <STR_LIT> ) ) ; return ; } }


<s> default : break ; case <STR_LIT> : { int FI = cast < FrameIndexSDNode > ( Node ) -> getIndex ( ) ; SDValue TFI = CurDAG -> getTargetFrameIndex ( FI , TLI -> getPointerTy ( CurDAG -> getDataLayout ( ) ) ) ;

CurDAG -> SelectNodeTo ( Node , <STR_LIT> , <STR_LIT> , TFI , CurDAG -> getTargetConstant ( <NUM_LIT> , dl , <STR_LIT> ) ) ;


<s> Base = CurDAG -> getTargetFrameIndex ( FI , TLI -> getPointerTy ( CurDAG -> getDataLayout ( ) ) ) ; } else if ( Base . getOpcode ( ) == <STR_LIT> ) { Base = Base . getOperand ( <NUM_LIT> ) ; } else if ( Base . getOpcode ( ) == <STR_LIT> ) { SDValue BaseAdd = Base ; if ( BaseAdd . getOperand ( <NUM_LIT> ) . getOpcode ( ) == <STR_LIT> ) { Base = BaseAdd . getOperand ( <NUM_LIT> ) . getOperand ( <NUM_LIT> ) ; DispReg = BaseAdd . getOperand ( <NUM_LIT> ) ; DispImm = CurDAG -> getTargetConstant ( RHSC , SDLoc ( N ) , <STR_LIT> ) ; return true ; } else if ( BaseAdd . getOperand ( <NUM_LIT> ) . getOpcode ( ) == <STR_LIT> ) { Base = BaseAdd . getOperand ( <NUM_LIT> ) . getOperand ( <NUM_LIT> ) ; DispReg = BaseAdd . getOperand ( <NUM_LIT> ) ; DispImm = CurDAG -> getTargetConstant ( RHSC , SDLoc ( N ) , <STR_LIT> ) ; return true ; } } DispReg = CurDAG -> getRegister ( <NUM_LIT> , VT ) ; DispImm = CurDAG -> getTargetConstant ( RHSC , SDLoc ( N ) , <STR_LIT> ) ; return true ; } if ( N . getOpcode ( ) == <STR_LIT> ) { if ( N . getOperand ( <NUM_LIT> ) . getOpcode ( ) == <STR_LIT> ) { Base = N . getOperand ( <NUM_LIT> ) . getOperand ( <NUM_LIT> ) ; DispReg = N . getOperand ( <NUM_LIT> ) ; } else if ( N . getOperand ( <NUM_LIT> ) . getOpcode ( ) == <STR_LIT> ) { Base = N . getOperand ( <NUM_LIT> ) . getOperand ( <NUM_LIT> ) ; DispReg = N . getOperand ( <NUM_LIT> ) ; } else { Base = N . getOperand ( <NUM_LIT> ) ; DispReg = N . getOperand ( <NUM_LIT> ) ; } DispImm = CurDAG -> getTargetConstant ( <NUM_LIT> , SDLoc ( N ) , <STR_LIT> ) ; return true ;


<s> CCState CCInfo ( CallConv , IsVarArg , MF , RVLocs , Context ) ; return CCInfo . CheckReturn ( Outs , RetCC_<ISA_LIT> ) ;


<s> switch ( CC ) { 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> ; default : llvm_unreachable ( <STR_LIT> ) ; }


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


<s> const char * <ISA_LIT>TargetLowering :: getTargetNodeName ( unsigned Opcode ) const { switch ( ( <STR_LIT> ) Opcode ) { case <STR_LIT> : break ; 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> const BlockAddress * BA = cast < BlockAddressSDNode > ( Op ) -> getBlockAddress ( ) ; SDValue Result = DAG . getTargetBlockAddress ( BA , PtrVT ) ; return DAG . getNode ( <STR_LIT> , dl , PtrVT , Result ) ;


<s> SDLoc dl ( Op ) ; auto PtrVT = getPointerTy ( DAG . getDataLayout ( ) ) ; const BlockAddress * BA = cast < BlockAddressSDNode > ( Op ) -> getBlockAddress ( ) ; SDValue Result = DAG . getTargetBlockAddress ( BA , PtrVT ) ; return DAG . getNode ( <STR_LIT> , dl , PtrVT , Result ) ;


<s> SDValue TargetCC = DAG . getTargetConstant ( get<ISA_LIT>CC ( CC ) , dl , <STR_LIT> ) ; SDValue Ops [ ] = { Chain , Dest , LHS , RHS , TargetCC } ;

return DAG . getNode ( <STR_LIT> , dl , VT , Ops ) ;


<s> SmallVector < CCValAssign , <NUM_LIT> > ArgLocs ; CCState CCInfo ( CallConv , isVarArg , DAG . getMachineFunction ( ) , ArgLocs , * DAG . getContext ( ) ) ; CCInfo . AnalyzeCallOperands ( Outs , CC_<ISA_LIT> ) ; unsigned NumBytes = CCInfo . getNextStackOffset ( ) + <NUM_LIT> ; auto PtrVT = getPointerTy ( DAG . getDataLayout ( ) ) ; Chain = DAG . getCALLSEQ_START ( Chain , NumBytes , <NUM_LIT> , dl ) ; SmallVector < std :: pair < unsigned , SDValue > , <NUM_LIT> > RegsToPass ; SmallVector < SDValue , <NUM_LIT> > MemOpChains ; SDValue StackPtr ; for ( unsigned i = <NUM_LIT> , e = ArgLocs . size ( ) ; i != e ; ++ i ) { CCValAssign & VA = ArgLocs [ i ] ; SDValue Arg = OutVals [ i ] ; switch ( VA . getLocInfo ( ) ) { default : llvm_unreachable ( <STR_LIT> ) ; case CCValAssign :: Full : break ; case CCValAssign :: SExt : Arg = DAG . getNode ( <STR_LIT> , dl , VA . getLocVT ( ) , Arg ) ; break ; case CCValAssign :: ZExt : Arg = DAG . getNode ( <STR_LIT> , dl , VA . getLocVT ( ) , Arg ) ; break ; case CCValAssign :: AExt : Arg = DAG . getNode ( <STR_LIT> , dl , VA . getLocVT ( ) , Arg ) ; break ; } if ( VA . isRegLoc ( ) ) { RegsToPass . push_back ( std :: make_pair ( VA . getLocReg ( ) , Arg ) ) ; } else { assert ( VA . isMemLoc ( ) ) ; if ( ! StackPtr . getNode ( ) ) StackPtr = DAG . getCopyFromReg ( Chain , dl , <STR_LIT> , PtrVT ) ; unsigned offset = NumBytes - VA . getLocMemOffset ( ) - VA . getLocVT ( ) . getSizeInBits ( ) / <NUM_LIT> ; SDValue PtrOff = DAG . getNode ( <STR_LIT> , dl , PtrVT , StackPtr , DAG . getIntPtrConstant ( offset , dl ) ) ; SDValue MemOp ; <STR_LIT> Flags = Outs [ i ] . Flags ;


<s> MemOp = DAG . getMemcpy ( Chain , dl , PtrOff , Arg , SizeNode , Flags . getByValAlign ( ) , false , true , false , MachinePointerInfo ( ) , MachinePointerInfo ( ) ) ; } else { MemOp = DAG . getStore ( Chain , dl , Arg , PtrOff , MachinePointerInfo ( ) ) ; } MemOpChains . push_back ( MemOp ) ; } } if ( ! MemOpChains . empty ( ) ) Chain = DAG . getNode ( <STR_LIT> , dl , <STR_LIT> , MemOpChains ) ; SDValue InFlag ; for ( unsigned i = <NUM_LIT> , e = RegsToPass . size ( ) ; i != e ; ++ i ) { Chain = DAG . getCopyToReg ( Chain , dl , RegsToPass [ i ] . first , RegsToPass [ i ] . second , InFlag ) ; InFlag = Chain . getValue ( <NUM_LIT> ) ; } if ( GlobalAddressSDNode * G = dyn_cast < GlobalAddressSDNode > ( Callee ) ) Callee = DAG . getTargetGlobalAddress ( G -> getGlobal ( ) , dl , <STR_LIT> ) ; else if ( ExternalSymbolSDNode * E = dyn_cast < ExternalSymbolSDNode > ( Callee ) ) Callee = DAG . getTargetExternalSymbol ( E -> getSymbol ( ) , <STR_LIT> ) ; SDVTList NodeTys = DAG . getVTList ( <STR_LIT> , <STR_LIT> ) ; SmallVector < SDValue , <NUM_LIT> > Ops ; Ops . push_back ( Chain ) ; Ops . push_back ( Callee ) ; for ( unsigned i = <NUM_LIT> , e = RegsToPass . size ( ) ; i != e ; ++ i ) Ops . push_back ( DAG . getRegister ( RegsToPass [ i ] . first , RegsToPass [ i ] . second . getValueType ( ) ) ) ; const <ISA_LIT>RegisterInfo * TRI = Subtarget -> getRegisterInfo ( ) ; Ops . push_back ( DAG . getRegisterMask ( TRI -> getCallPreservedMask ( DAG . getMachineFunction ( ) , CallConv ) ) ) ;

if ( InFlag . getNode ( ) ) Ops . push_back ( InFlag ) ;


<s> for ( unsigned i = <NUM_LIT> ; i != RVLocs . size ( ) ; ++ i ) { Chain = DAG . getCopyFromReg ( Chain , dl , RVLocs [ i ] . getLocReg ( ) , RVLocs [ i ] . getValVT ( ) , InFlag ) . getValue ( <NUM_LIT> ) ; InFlag = Chain . getValue ( <NUM_LIT> ) ; InVals . push_back ( Chain . getValue ( <NUM_LIT> ) ) ; }


<s> Chain = DAG . getCopyFromReg ( Chain , dl , RVLocs [ i ] . getLocReg ( ) , RVLocs [ i ] . getValVT ( ) , InFlag ) . getValue ( <NUM_LIT> ) ; InFlag = Chain . getValue ( <NUM_LIT> ) ; InVals . push_back ( Chain . getValue ( <NUM_LIT> ) ) ; }


<s> auto PtrVT = getPointerTy ( DAG . getDataLayout ( ) ) ; SDValue Result = DAG . getTargetExternalSymbol ( Sym , PtrVT ) ; return DAG . getNode ( <STR_LIT> , dl , PtrVT , Result ) ;


<s> } } else { assert ( VA . isMemLoc ( ) ) ; SDValue InVal ; <STR_LIT> Flags = Ins [ i ] . Flags ; unsigned offset = NumBytes - VA . getLocMemOffset ( ) - VA . getLocVT ( ) . getSizeInBits ( ) / <NUM_LIT> ; if ( Flags . isByVal ( ) ) { int FI = MFI . CreateFixedObject ( Flags . getByValSize ( ) , offset , true ) ; InVal = DAG . getFrameIndex ( FI , getPointerTy ( DAG . getDataLayout ( ) ) ) ; } else { unsigned ObjSize = VA . getLocVT ( ) . getSizeInBits ( ) / <NUM_LIT> ; int FI = MFI . CreateFixedObject ( ObjSize , offset , true ) ; SDValue FIN = DAG . getFrameIndex ( FI , <STR_LIT> ) ; InVal = DAG . getLoad ( VA . getLocVT ( ) , dl , Chain , FIN , MachinePointerInfo :: getFixedStack ( DAG . getMachineFunction ( ) , FI ) ) ; } InVals . push_back ( InVal ) ;


<s> int64_t Offset = cast < GlobalAddressSDNode > ( Op ) -> getOffset ( ) ; auto PtrVT = getPointerTy ( DAG . getDataLayout ( ) ) ;

SDValue Result = DAG . getTargetGlobalAddress ( GV , dl , PtrVT ) ;


<s> SDValue <ISA_LIT>TargetLowering :: LowerGlobalAddress ( SDValue Op , SelectionDAG & DAG ) const { SDLoc dl ( Op ) ; const GlobalValue * GV = cast < GlobalAddressSDNode > ( Op ) -> getGlobal ( ) ; int64_t Offset = cast < GlobalAddressSDNode > ( Op ) -> getOffset ( ) ; auto PtrVT = getPointerTy ( DAG . getDataLayout ( ) ) ; SDValue Result = DAG . getTargetGlobalAddress ( GV , dl , PtrVT ) ; Result = DAG . getNode ( <STR_LIT> , SDLoc ( Op ) , PtrVT , Result ) ;


<s> auto PtrVT = getPointerTy ( DAG . getDataLayout ( ) ) ; SDValue Result = DAG . getTargetJumpTable ( JT -> getIndex ( ) , PtrVT ) ; return DAG . getNode ( <STR_LIT> , dl , PtrVT , Result ) ;


<s> SDValue <ISA_LIT>TargetLowering :: LowerJumpTable ( SDValue Op , SelectionDAG & DAG ) const { SDLoc dl ( Op ) ; JumpTableSDNode * JT = cast < JumpTableSDNode > ( Op ) ; auto PtrVT = getPointerTy ( DAG . getDataLayout ( ) ) ;

SDValue Result = DAG . getTargetJumpTable ( JT -> getIndex ( ) , PtrVT ) ;


<s> SDValue <ISA_LIT>TargetLowering :: LowerOperation ( SDValue Op , SelectionDAG & DAG ) const { switch ( Op . getOpcode ( ) ) { case <STR_LIT> : return LowerSELECT_CC ( Op , DAG ) ; case <STR_LIT> : return LowerBR_CC ( Op , DAG ) ; case <STR_LIT> : return LowerGlobalAddress ( Op , DAG ) ; case <STR_LIT> : return LowerBlockAddress ( Op , DAG ) ; case <STR_LIT> : return LowerExternalSymbol ( Op , DAG ) ;

case <STR_LIT> : return LowerJumpTable ( Op , DAG ) ;


<s> SDValue <ISA_LIT>TargetLowering :: LowerReturn ( SDValue Chain , CallingConv :: ID CallConv , bool isVarArg , const SmallVectorImpl < <STR_LIT> > & Outs , const SmallVectorImpl < SDValue > & OutVals , const SDLoc & dl , SelectionDAG & DAG ) const { SmallVector < CCValAssign , <NUM_LIT> > RVLocs ; CCState CCInfo ( CallConv , isVarArg , DAG . getMachineFunction ( ) , RVLocs , * DAG . getContext ( ) ) ; CCInfo . AnalyzeReturn ( Outs , RetCC_<ISA_LIT> ) ; SDValue Flag ; SmallVector < SDValue , <NUM_LIT> > RetOps ( <NUM_LIT> , Chain ) ; for ( unsigned i = <NUM_LIT> ; i != RVLocs . size ( ) ; ++ i ) { CCValAssign & VA = RVLocs [ i ] ; assert ( VA . isRegLoc ( ) && <STR_LIT> ) ; Chain = DAG . getCopyToReg ( Chain , dl , VA . getLocReg ( ) , OutVals [ i ] , Flag ) ; Flag = Chain . getValue ( <NUM_LIT> ) ; RetOps . push_back ( DAG . getRegister ( VA . getLocReg ( ) , VA . getLocVT ( ) ) ) ;


<s> SDValue FalseV = Op . getOperand ( <NUM_LIT> ) ; EVT VT = Op . getValueType ( ) ; <STR_LIT> CC = cast < CondCodeSDNode > ( Op . getOperand ( <NUM_LIT> ) ) -> get ( ) ; SDLoc dl ( Op ) ; SDValue TargetCC = DAG . getTargetConstant ( get<ISA_LIT>CC ( CC ) , dl , <STR_LIT> ) ; SDValue Ops [ ] = { FalseV , TrueV , LHS , RHS , TargetCC } ; return DAG . getNode ( <STR_LIT> , dl , VT , Ops ) ;


<s> <STR_LIT> CC = cast < CondCodeSDNode > ( Op . getOperand ( <NUM_LIT> ) ) -> get ( ) ; SDLoc dl ( Op ) ; SDValue TargetCC = DAG . getTargetConstant ( get<ISA_LIT>CC ( CC ) , dl , <STR_LIT> ) ;

SDValue Ops [ ] = { FalseV , TrueV , LHS , RHS , TargetCC } ;


<s> void <ISA_LIT>MachineFunctionInfo :: anchor ( ) {


<s> explicit <ISA_LIT>MachineFunctionInfo ( MachineFunction & MF ) {


<s> void <ISA_LIT>MCAsmInfo :: anchor ( ) {


<s> Data32bitsDirective = <STR_LIT> ; Data64bitsDirective = nullptr ; GlobalDirective = <STR_LIT> ; HasFunctionAlignment = false ; HasDotTypeDotSizeDirective = false ;


<s> IsLittleEndian = false ; SeparatorString = <STR_LIT> ; CommentString = <STR_LIT> ; PrivateGlobalPrefix = <STR_LIT> ; PrivateLabelPrefix = <STR_LIT> ; LinkerPrivateGlobalPrefix = <STR_LIT> ;


<s> OS << <STR_LIT> ; } else if ( isAcceptableChar ( C ) ) { OS << C ; } else if ( C >= 'A' && C <= 'Z' ) {


if ( EOL ) CommentToEmit . push_back ( '\n' ) ;


<s> if ( ! IsVerboseAsm ) return ; T . toVector ( CommentToEmit ) ;


<s> void <ISA_LIT>MCAsmStreamer :: addExplicitComment ( const Twine & T ) { StringRef c = T . getSingleStringRef ( ) ; if ( c . startswith ( StringRef ( MAI -> getCommentString ( ) ) ) ) { ExplicitCommentToEmit . append ( c . str ( ) ) ;


<s> void <ISA_LIT>MCAsmStreamer :: ChangeSection ( MCSection * Section , const MCExpr * Subsection ) {


<s> void <ISA_LIT>MCAsmStreamer :: EmitAssignment ( MCSymbol * Symbol , const MCExpr * Value ) { llvm_unreachable ( <STR_LIT> ) ;


<s> void <ISA_LIT>MCAsmStreamer :: EmitBundleAlignMode ( unsigned AlignPow2 ) { llvm_unreachable ( <STR_LIT> ) ;


<s> void <ISA_LIT>MCAsmStreamer :: EmitBundleLock ( bool AlignToEnd ) { llvm_unreachable ( <STR_LIT> ) ;


<s> for ( unsigned i = <NUM_LIT> , e = Data . size ( ) ; i != e ; ++ i ) { EmitValue ( MCConstantExpr :: create ( ( unsigned char ) Data [ i ] , getContext ( ) ) , <NUM_LIT> ) ; }


<s> void <ISA_LIT>MCAsmStreamer :: EmitBytes ( StringRef Data ) { for ( unsigned i = <NUM_LIT> , e = Data . size ( ) ; i != e ; ++ i ) {

EmitValue ( MCConstantExpr :: create ( ( unsigned char ) Data [ i ] , getContext ( ) ) , <NUM_LIT> ) ;


<s>
OS
<<
MAI
->
getCommentString
(
)
<<
' '
<<
Comments
.
substr
(
<NUM_LIT>
,
Position
)
<<
'\n'
;
Comments
=
Comments
.
substr
(
Position
+
<NUM_LIT>
)
;


<s> void <ISA_LIT>MCAsmStreamer :: EmitCommonSymbol ( MCSymbol * Symbol , uint64_t Size , unsigned ByteAlignment ) { llvm_unreachable ( <STR_LIT> ) ;


<s> void <ISA_LIT>MCAsmStreamer :: EmitEOL ( ) { emitExplicitComments ( ) ; if ( ! IsVerboseAsm ) { OS << '\n' ;


<s> if ( ! IsVerboseAsm ) { OS << '\n' ; return ; }


<s> MCStreamer :: EmitInstruction ( Inst , STI ) ; if ( ShowInst ) { if ( PrintSchedInfo ) GetCommentOS ( ) << <STR_LIT> ; Inst . dump_pretty ( GetCommentOS ( ) , InstPrinter . get ( ) , <STR_LIT> ) ; GetCommentOS ( ) << <STR_LIT> ; } std :: string Buffer ; { raw_string_ostream TempStream ( Buffer ) ; InstPrinter -> printInst ( & Inst , TempStream , <STR_LIT> , STI ) ; } OS << Buffer . substr ( <NUM_LIT> ) ; flushLabel ( false ) ; if ( PrintSchedInfo ) { std :: string SI = STI . getSchedInfoStr ( Inst ) ; if ( ! SI . empty ( ) ) GetCommentOS ( ) << SI ; } StringRef Comments = CommentToEmit ; if ( Comments . size ( ) && Comments . back ( ) != '\n' ) GetCommentOS ( ) << <STR_LIT> ; EmitEOL ( ) ;


<s> void <ISA_LIT>MCAsmStreamer :: EmitIntValue ( uint64_t Value , unsigned Size ) { EmitValue ( MCConstantExpr :: create ( Value , getContext ( ) ) , Size ) ;


<s> raw_string_ostream TempStream ( Name ) ; Symbol -> print ( TempStream , MAI ) ; } LabelToEmit . append ( <STR_LIT> ) ;


<s> void <ISA_LIT>MCAsmStreamer :: EmitRawTextImpl ( StringRef String ) { if ( ! String . empty ( ) && String . back ( ) == '\n' ) String = String . substr ( <NUM_LIT> , String . size ( ) - <NUM_LIT> ) ;


<s> OS << MAI -> getGlobalDirective ( ) ; break ; } Symbol -> print ( OS , MAI ) ;


<s> void <ISA_LIT>MCAsmStreamer :: EmitSymbolDesc ( MCSymbol * Symbol , unsigned DescValue ) { llvm_unreachable ( <STR_LIT> ) ;


<s> void <ISA_LIT>MCAsmStreamer :: EmitThumbFunc ( MCSymbol * Func ) {


<s> } int64_t IntValue ; if ( ! Value -> evaluateAsAbsolute ( IntValue ) ) report_fatal_error ( <STR_LIT> ) ; unsigned i = Size ; while ( i != <NUM_LIT> ) { i -- ; ValueBuffer . push_back ( ( unsigned char ) ( IntValue >> ( i * <NUM_LIT> ) ) ) ; if ( ValueBuffer . size ( ) == CurrentAlignmentToValue ) { uint64_t ValueToEmit = <NUM_LIT> ; for ( unsigned j = <NUM_LIT> ; j < CurrentAlignmentToValue ; ++ j ) { ValueToEmit = ( ValueToEmit << <NUM_LIT> ) | ValueBuffer [ j ] ; } EmitValueWithAlignment ( MCConstantExpr :: create ( ValueToEmit , getContext ( ) ) , CurrentAlignmentToValue , Loc ) ; ValueBuffer . clear ( ) ; } }


<s> void <ISA_LIT>MCAsmStreamer :: EmitValueToAlignment ( unsigned ByteAlignment , int64_t Value , unsigned ValueSize , unsigned MaxBytesToEmit ) { if ( ByteAlignment == <NUM_LIT> || ByteAlignment == <NUM_LIT> || ByteAlignment == <NUM_LIT> ) { CurrentAlignmentToValue = ByteAlignment ; return ; }

if ( ByteAlignment % <NUM_LIT> == <NUM_LIT> ) {


<s> void <ISA_LIT>MCAsmStreamer :: emitValueToOffset ( const MCExpr * Offset , unsigned char Value , SMLoc Loc ) { llvm_unreachable ( <STR_LIT> ) ;


<s> void <ISA_LIT>MCAsmStreamer :: EmitValueWithAlignment ( const MCExpr * Value , unsigned Size , SMLoc Loc ) { const char * Directive = nullptr ; switch ( Size ) { default : break ; case <NUM_LIT> : Directive = MAI -> getData8bitsDirective ( ) ; break ;

case <NUM_LIT> : Directive = MAI -> getData16bitsDirective ( ) ; break ;


<s> void <ISA_LIT>MCAsmStreamer :: EmitWeakReference ( MCSymbol * Alias , const MCSymbol * Symbol ) {


<s> void <ISA_LIT>MCAsmStreamer :: EmitZerofill ( MCSection * Section , MCSymbol * Symbol , uint64_t Size , unsigned ByteAlignment ) { llvm_unreachable ( <STR_LIT> ) ;


<s> <ISA_LIT>MCAsmStreamer :: <ISA_LIT>MCAsmStreamer ( MCContext & Ctx , std :: unique_ptr < formatted_raw_ostream > os , bool isVerboseAsm , MCInstPrinter * printer , bool showInst ) : MCStreamer ( Ctx ) , OSOwner ( std :: move ( os ) ) , OS ( * OSOwner ) , MAI ( Ctx . getAsmInfo ( ) ) , InstPrinter ( printer ) , CommentStream ( CommentToEmit ) , IsVerboseAsm ( isVerboseAsm ) , ShowInst ( showInst ) {


<s> <ISA_LIT>MCAsmStreamer :: <ISA_LIT>MCAsmStreamer ( MCContext & Ctx , std :: unique_ptr < formatted_raw_ostream > os , bool isVerboseAsm , MCInstPrinter * printer , bool showInst ) : MCStreamer ( Ctx ) , OSOwner ( std :: move ( os ) ) , OS ( * OSOwner ) , MAI ( Ctx . getAsmInfo ( ) ) , InstPrinter ( printer ) , CommentStream ( CommentToEmit ) , IsVerboseAsm ( isVerboseAsm ) , ShowInst ( showInst ) { assert ( InstPrinter ) ;


<s> void <ISA_LIT>MCAsmStreamer :: FinishImpl ( ) { flushValues ( ) ; flushLabel ( true ) ; for ( auto * Symbol : Symbols ) { if ( Symbol -> isUndefined ( ) ) { OS << <STR_LIT> ; Symbol -> print ( OS , MAI ) ; EmitEOL ( ) ;


<s> StringRef label = LabelToEmit ; if ( ! label . empty ( ) ) {


<s> if ( ! ValueBuffer . empty ( ) ) { uint64_t ValueToEmit = <NUM_LIT> ; for ( unsigned i = <NUM_LIT> , e = ValueBuffer . size ( ) ; i != e ; ++ i ) { ValueToEmit = ( ValueToEmit << <NUM_LIT> ) | ValueBuffer [ i ] ; } ValueToEmit <<= ( CurrentAlignmentToValue - ValueBuffer . size ( ) ) * <NUM_LIT> ; EmitValueWithAlignment ( MCConstantExpr :: create ( ValueToEmit , getContext ( ) ) , CurrentAlignmentToValue ) ; ValueBuffer . clear ( ) ; } CurrentAlignmentToValue = <NUM_LIT> ;


<s> ValueToEmit = ( ValueToEmit << <NUM_LIT> ) | ValueBuffer [ i ] ; } ValueToEmit <<= ( CurrentAlignmentToValue - ValueBuffer . size ( ) ) * <NUM_LIT> ; EmitValueWithAlignment ( MCConstantExpr :: create ( ValueToEmit , getContext ( ) ) , CurrentAlignmentToValue ) ;


<s> if ( ! IsVerboseAsm ) return nulls ( ) ; return CommentStream ;


<s> bool isVerboseAsm ( ) const override { return IsVerboseAsm ;


<s> void <ISA_LIT>MCAsmStreamer :: reset ( ) { LabelToEmit . clear ( ) ; ExplicitCommentToEmit . clear ( ) ; CommentToEmit . clear ( ) ; Symbols . clear ( ) ;


<s> Symbol . setIsRegistered ( true ) ; Symbols . push_back ( & Symbol ) ;


<s> MCOp = MCOperand :: createExpr ( MCSymbolRefExpr :: create ( MO . getMBB ( ) -> getSymbol ( ) , Ctx ) ) ; break ; case MachineOperand :: MO_GlobalAddress : MCOp = LowerSymbolOperand ( MO , Printer . getSymbol ( MO . getGlobal ( ) ) ) ; break ; case MachineOperand :: MO_ExternalSymbol : MCOp = LowerSymbolOperand ( MO , Printer . GetExternalSymbolSymbol ( MO . getSymbolName ( ) ) ) ; break ; case MachineOperand :: MO_JumpTableIndex : MCOp = LowerSymbolOperand ( MO , Printer . GetJTISymbol ( MO . getIndex ( ) ) ) ; break ; case MachineOperand :: MO_ConstantPoolIndex : MCOp = LowerSymbolOperand ( MO , Printer . GetCPISymbol ( MO . getIndex ( ) ) ) ; break ; case MachineOperand :: MO_BlockAddress : MCOp = LowerSymbolOperand ( MO , Printer . GetBlockAddressSymbol ( MO . getBlockAddress ( ) ) ) ; break ; case MachineOperand :: MO_RegisterMask : continue ; }


<s> case <NUM_LIT> : break ; } if ( ! MO . isJTI ( ) && MO . getOffset ( ) ) Expr = MCBinaryExpr :: createAdd ( Expr , MCConstantExpr :: create ( MO . getOffset ( ) , Ctx ) , Ctx ) ; return MCOperand :: createExpr ( Expr ) ;


<s> static MCInstrInfo * create<ISA_LIT>MCInstrInfo ( ) { MCInstrInfo * X = new MCInstrInfo ( ) ; Init<ISA_LIT>MCInstrInfo ( X ) ;


<s> MCRegisterInfo * X = new MCRegisterInfo ( ) ; Init<ISA_LIT>MCRegisterInfo ( X , <STR_LIT> ) ;


<s> static MCRegisterInfo * create<ISA_LIT>MCRegisterInfo ( const Triple & TT ) { MCRegisterInfo * X = new MCRegisterInfo ( ) ;

Init<ISA_LIT>MCRegisterInfo ( X , <STR_LIT> ) ;


<s> return create<ISA_LIT>MCSubtargetInfoImpl ( TT , CPU , FS ) ;


<s> static MCSubtargetInfo * create<ISA_LIT>MCSubtargetInfo ( const Triple & TT , StringRef CPU , StringRef FS ) { return create<ISA_LIT>MCSubtargetInfoImpl ( TT , CPU , FS ) ;


<s> void LLVMInitialize<ISA_LIT>TargetMC ( ) { RegisterMCAsmInfo < <ISA_LIT>MCAsmInfo > X ( getThe<ISA_LIT>Target ( ) ) ; TargetRegistry :: RegisterMCInstrInfo ( getThe<ISA_LIT>Target ( ) , create<ISA_LIT>MCInstrInfo ) ;

TargetRegistry :: RegisterMCRegInfo ( getThe<ISA_LIT>Target ( ) , create<ISA_LIT>MCRegisterInfo ) ;


<s> Offset += MF . getFrameInfo ( ) . getStackSize ( ) ; Offset += SPAdj ; if ( MI . getOpcode ( ) == <STR_LIT> ) { Offset += MI . getOperand ( FIOperandNum + <NUM_LIT> ) . getImm ( ) ; const TargetInstrInfo & TII = * MF . getSubtarget ( ) . getInstrInfo ( ) ; MI . setDesc ( TII . get ( <STR_LIT> ) ) ; MI . getOperand ( FIOperandNum ) . ChangeToRegister ( <STR_LIT> , false ) ; MI . RemoveOperand ( FIOperandNum + <NUM_LIT> ) ;


<s> MachineFunction & MF = * MBB . getParent ( ) ; DebugLoc dl = MI . getDebugLoc ( ) ; int FrameIndex = MI . getOperand ( FIOperandNum ) . getIndex ( ) ; int Offset = MF . getFrameInfo ( ) . getObjectOffset ( FrameIndex ) ; Offset += MF . getFrameInfo ( ) . getStackSize ( ) ; Offset += SPAdj ; if ( MI . getOpcode ( ) == <STR_LIT> ) { Offset += MI . getOperand ( FIOperandNum + <NUM_LIT> ) . getImm ( ) ; const TargetInstrInfo & TII = * MF . getSubtarget ( ) . getInstrInfo ( ) ; MI . setDesc ( TII . get ( <STR_LIT> ) ) ; MI . getOperand ( FIOperandNum ) . ChangeToRegister ( <STR_LIT> , false ) ; MI . RemoveOperand ( FIOperandNum + <NUM_LIT> ) ; if ( Offset == <NUM_LIT> ) { return ; } unsigned DstReg = MI . getOperand ( <NUM_LIT> ) . getReg ( ) ; BuildMI ( MBB , std :: next ( II ) , dl , TII . get ( <STR_LIT> ) , DstReg ) . addReg ( DstReg ) . addImm ( Offset ) ; return ; } if ( MI . getOperand ( FIOperandNum + <NUM_LIT> ) . isImm ( ) ) { Offset += ( int32_t ) MI . getOperand ( FIOperandNum + <NUM_LIT> ) . getImm ( ) ; }


<s> unsigned <ISA_LIT>RegisterInfo :: getFrameRegister ( const MachineFunction & MF ) const { return <STR_LIT> ;


<s> const TargetRegisterClass * <ISA_LIT>RegisterInfo :: getPointerRegClass ( const MachineFunction & MF , unsigned Kind ) const {


<s> BitVector <ISA_LIT>RegisterInfo :: getReservedRegs ( const MachineFunction & MF ) const { BitVector Reserved ( getNumRegs ( ) ) ;


<s> BitVector Reserved ( getNumRegs ( ) ) ; Reserved . set ( <STR_LIT> ) ;


<s> void <ISA_LIT>Subtarget :: anchor ( ) {


<s> <ISA_LIT>Subtarget :: <ISA_LIT>Subtarget ( const Triple & TT , const std :: string & CPU , const std :: string & FS , const TargetMachine & TM ) : <ISA_LIT>GenSubtargetInfo ( TT , CPU , FS ) , FrameLowering ( ) , InstrInfo ( initializeSubtargetDependencies ( CPU , FS ) ) , TLInfo ( TM , * this ) {


<s> const <ISA_LIT>InstrInfo * getInstrInfo ( ) const override {


<s> const <ISA_LIT>RegisterInfo * getRegisterInfo ( ) const override {

return & InstrInfo . getRegisterInfo ( ) ;


<s> const <ISA_LIT>TargetLowering * getTargetLowering ( ) const override {


<s> const <ISA_LIT>TargetLowering * getTargetLowering ( ) const override { return & TLInfo ;


<s> <ISA_LIT>Subtarget & <ISA_LIT>Subtarget :: initializeSubtargetDependencies ( StringRef CPU , StringRef FS ) { std :: string CPUName = CPU ;

if ( CPUName . empty ( ) ) CPUName = <STR_LIT> ;


<s> if ( CPUName . empty ( ) ) CPUName = <STR_LIT> ;

ParseSubtargetFeatures ( CPUName , FS ) ;


<s> Target & llvm :: getThe<ISA_LIT>Target ( ) { static Target The<ISA_LIT>Target ;


<s> void LLVMInitialize<ISA_LIT>TargetInfo ( ) {

RegisterTarget < Triple :: f2003f > X ( getThe<ISA_LIT>Target ( ) , <STR_LIT> , <STR_LIT> ) ;


<s> addPass ( create<ISA_LIT>ISelDag ( get<ISA_LIT>TargetMachine ( ) , getOptLevel ( ) ) ) ; return false ;


<s> addPass ( create<ISA_LIT>ISelDag ( get<ISA_LIT>TargetMachine ( ) , getOptLevel ( ) ) ) ;


<s> static std :: string computeDataLayout ( const Triple & TT , StringRef CPU , const TargetOptions & Options ) { return <STR_LIT> ;


<s> MCStreamer * S = new <ISA_LIT>MCAsmStreamer ( Context , std :: move ( FOut ) , Options . MCOptions . AsmVerbose , InstPrinter , Options . MCOptions . ShowMCInst ) ;


<s> MCStreamer * <ISA_LIT>TargetMachine :: createMCStreamerToAsm ( MCContext & Context , std :: unique_ptr < formatted_raw_ostream > FOut , MCInstPrinter * InstPrinter , MCCodeEmitter * MCE , MCAsmBackend * MAB ) {

MCStreamer * S = new <ISA_LIT>MCAsmStreamer ( Context , std :: move ( FOut ) , Options . MCOptions . AsmVerbose , InstPrinter , Options . MCOptions . ShowMCInst ) ;


<s> return new <ISA_LIT>PassConfig ( * this , PM ) ;


<s> <ISA_LIT>PassConfig ( <ISA_LIT>TargetMachine & TM , PassManagerBase & PM ) : TargetPassConfig ( TM , PM ) {


<s> static Reloc :: Model getEffectiveRelocModel ( Optional < Reloc :: Model > RM ) { if ( ! RM . hasValue ( ) ) return Reloc :: Static ;


<s> <ISA_LIT>TargetMachine & get<ISA_LIT>TargetMachine ( ) const { return getTM < <ISA_LIT>TargetMachine > ( ) ;


<s> TargetLoweringObjectFile * getObjFileLowering ( ) const override {


<s> const <ISA_LIT>Subtarget * getSubtargetImpl ( const Function & F ) const override {


<s> void LLVMInitialize<ISA_LIT>Target ( ) { RegisterTargetMachine < <ISA_LIT>TargetMachine > X ( getThe<ISA_LIT>Target ( ) ) ;


<s> <ISA_LIT>TargetMachine :: ~ <ISA_LIT>TargetMachine ( ) {


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


<s> return static_cast < <STR_LIT> > ( CC ^ <NUM_LIT> ) ;