<s> raw_svector_ostream OS ( Str ) ; printInstruction ( MI , OS ) ; OutStreamer . EmitRawText ( OS . str ( ) ) ;


<s> SmallString < <NUM_LIT> > Str ; raw_svector_ostream OS ( Str ) ; printInstruction ( MI , OS ) ; OutStreamer . EmitRawText ( OS . str ( ) ) ;


<s> RegisterAsmPrinter < <ISA_LIT>ompactAsmPrinter > X ( The<ISA_LIT>ompactEncoreTarget ) ;


<s> break ; case <STR_LIT> : O << <STR_LIT> ; break ; case <STR_LIT> : O << <STR_LIT> ; break ; case <STR_LIT> : O << <STR_LIT> ; break ; case <STR_LIT> : O << <STR_LIT> ; break ; case <STR_LIT> : O << <STR_LIT> ; break ; case <STR_LIT> : O << <STR_LIT> ; break ; case <STR_LIT> : O << <STR_LIT> ; break ; case <STR_LIT> : O << <STR_LIT> ; break ; case <STR_LIT> : O << <STR_LIT> ; break ; default : assert ( <NUM_LIT> && <STR_LIT> ) ;


<s> void <ISA_LIT>ompactAsmPrinter :: printMemOperand ( const MachineInstr * MI , unsigned opNum , raw_ostream & O , const char * Modifier ) { O << <STR_LIT> ; printOperand ( MI , opNum , O ) ; if ( MI -> getNumOperands ( ) > <NUM_LIT> ) { MachineOperand MO = MI -> getOperand ( opNum + <NUM_LIT> ) ; if ( MO . getType ( ) != MachineOperand :: MO_Immediate || MO . getImm ( ) != <NUM_LIT> ) { O << <STR_LIT> ; printOperand ( MI , opNum + <NUM_LIT> , O ) ;


<s> switch ( MO . getType ( ) ) { case MachineOperand :: MO_Register : O << LowercaseString ( getRegisterName ( MO . getReg ( ) ) ) ; break ; case MachineOperand :: MO_Immediate : O << ( int ) MO . getImm ( ) ; break ; case MachineOperand :: MO_MachineBasicBlock : O << <STR_LIT> << * MO . getMBB ( ) -> getSymbol ( ) ; return ; case MachineOperand :: MO_GlobalAddress : O << <STR_LIT> << * Mang -> getSymbol ( MO . getGlobal ( ) ) ; if ( MO . getOffset ( ) > <NUM_LIT> ) { O << <STR_LIT> << MO . getOffset ( ) ; } else if ( MO . getOffset ( ) < <NUM_LIT> ) { O << <STR_LIT> << MO . getOffset ( ) ;


<s> void <ISA_LIT>ompactAsmPrinter :: printPredicateOperand ( const MachineInstr * MI , unsigned OpNum , raw_ostream & O ) { <STR_LIT> CC = ( <STR_LIT> ) MI -> getOperand ( OpNum ) . getImm ( ) ; if ( CC != <STR_LIT> ) { O << <STR_LIT> << <ISA_LIT>CCToString ( CC ) ;


<s> <STR_LIT> CC = ( <STR_LIT> ) MI -> getOperand ( OpNum ) . getImm ( ) ; if ( CC != <STR_LIT> ) { O << <STR_LIT> << <ISA_LIT>CCToString ( CC ) ;


<s> explicit <ISA_LIT>ompactFrameLowering ( const <ISA_LIT>ompactSubtarget & sti ) : TargetFrameLowering ( TargetFrameLowering :: StackGrowsDown , <NUM_LIT> , <NUM_LIT> ) , STI ( sti ) {


<s> static void EmitComment ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MBBI , DebugLoc dl , const <ISA_LIT>ompactInstrInfo & TII , std :: string Comment ) { MDNode * CommentMDNode = MDNode :: get ( getGlobalContext ( ) , ArrayRef < Value * > ( MDString :: get ( getGlobalContext ( ) , Comment ) ) ) ;

BuildMI ( MBB , MBBI , dl , TII . get ( <STR_LIT> ) ) . addMetadata ( CommentMDNode ) ;


<s> void <ISA_LIT>ompactFrameLowering :: emitEpilogue ( MachineFunction & MF , MachineBasicBlock & MBB ) const { MachineBasicBlock :: iterator MBBI = MBB . getLastNonDebugInstr ( ) ; MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; <ISA_LIT>ompactFunctionInfo * AFI = MF . getInfo < <ISA_LIT>ompactFunctionInfo > ( ) ; const <ISA_LIT>ompactInstrInfo & TII = * static_cast < const <ISA_LIT>ompactInstrInfo * > ( MF . getTarget ( ) . getInstrInfo ( ) ) ; DebugLoc dl = MBBI != MBB . end ( ) ? MBBI -> getDebugLoc ( ) : DebugLoc ( ) ; assert ( MBBI -> getDesc ( ) . isReturn ( ) && <STR_LIT> ) ; EmitComment ( MBB , MBBI , dl , TII , <STR_LIT> ) ; unsigned NumBytes = MFI -> getStackSize ( ) ; NumBytes = ( NumBytes + <NUM_LIT> ) & ~ <NUM_LIT> ; if ( NumBytes > <NUM_LIT> ) { BuildMI ( MBB , MBBI , dl , TII . get ( <STR_LIT> ) , <STR_LIT> ) . addReg ( <STR_LIT> ) . addImm ( NumBytes ) ; }

BuildMI ( MBB , MBBI , dl , TII . get ( <STR_LIT> ) ) . addReg ( <STR_LIT> ) . addReg ( <STR_LIT> ) . addImm ( UNITS_PER_WORD ) ;


<s> MachineBasicBlock :: iterator MBBI = MBB . getLastNonDebugInstr ( ) ; MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; <ISA_LIT>ompactFunctionInfo * AFI = MF . getInfo < <ISA_LIT>ompactFunctionInfo > ( ) ; const <ISA_LIT>ompactInstrInfo & TII = * static_cast < const <ISA_LIT>ompactInstrInfo * > ( MF . getTarget ( ) . getInstrInfo ( ) ) ; DebugLoc dl = MBBI != MBB . end ( ) ? MBBI -> getDebugLoc ( ) : DebugLoc ( ) ; assert ( MBBI -> getDesc ( ) . isReturn ( ) && <STR_LIT> ) ; EmitComment ( MBB , MBBI , dl , TII , <STR_LIT> ) ; unsigned NumBytes = MFI -> getStackSize ( ) ; NumBytes = ( NumBytes + <NUM_LIT> ) & ~ <NUM_LIT> ;


<s> BuildMI ( MBB , MBBI , dl , TII . get ( <STR_LIT> ) ) . addReg ( <STR_LIT> ) . addImm ( - UNITS_PER_WORD ) . addReg ( <STR_LIT> ) ; BuildMI ( MBB , MBBI , dl , TII . get ( <STR_LIT> ) , <STR_LIT> ) . addReg ( <STR_LIT> ) ; if ( NumBytes > <NUM_LIT> ) { assert ( ( NumBytes & <NUM_LIT> ) == <NUM_LIT> ) ; BuildMI ( MBB , MBBI , dl , TII . get ( <STR_LIT> ) , <STR_LIT> ) . addReg ( <STR_LIT> ) . addImm ( NumBytes ) ; } EmitComment ( MBB , MBBI , dl , TII , <STR_LIT> ) ;


<s> bool <ISA_LIT>ompactFrameLowering :: hasFP ( const MachineFunction & MF ) const { return ( DisableFramePointerElim ( MF ) || MF . getFrameInfo ( ) -> hasVarSizedObjects ( ) ) ;


<s> return true ; } if ( I -> getOpcode ( ) == <STR_LIT> ) { if ( AllowModify ) { while ( llvm :: next ( I ) != MBB . end ( ) ) { llvm :: next ( I ) -> eraseFromParent ( ) ; } Cond . clear ( ) ; FBB = <NUM_LIT> ; if ( MBB . isLayoutSuccessor ( I -> getOperand ( <NUM_LIT> ) . getMBB ( ) ) ) { TBB = <NUM_LIT> ; I -> eraseFromParent ( ) ; I = MBB . end ( ) ; continue ; } } TBB = I -> getOperand ( <NUM_LIT> ) . getMBB ( ) ; continue ; }

assert ( I -> getOpcode ( ) == <STR_LIT> && <STR_LIT> ) ;


<s> if ( MBB . isLayoutSuccessor ( I -> getOperand ( <NUM_LIT> ) . getMBB ( ) ) ) { TBB = <NUM_LIT> ; I -> eraseFromParent ( ) ; I = MBB . end ( ) ; continue ; } } TBB = I -> getOperand ( <NUM_LIT> ) . getMBB ( ) ; continue ; } assert ( I -> getOpcode ( ) == <STR_LIT> && <STR_LIT> ) ; <STR_LIT> BranchCode = static_cast < <STR_LIT> > ( I -> getOperand ( <NUM_LIT> ) . getImm ( ) ) ; if ( BranchCode == <STR_LIT> ) { return true ; } if ( Cond . empty ( ) ) { FBB = TBB ; TBB = I -> getOperand ( <NUM_LIT> ) . getMBB ( ) ; Cond . push_back ( MachineOperand :: CreateImm ( BranchCode ) ) ; continue ; } assert ( Cond . size ( ) == <NUM_LIT> ) ; assert ( TBB ) ; if ( TBB != I -> getOperand ( <NUM_LIT> ) . getMBB ( ) ) {


<s> <ISA_LIT>ompactInstrInfo :: <ISA_LIT>ompactInstrInfo ( <ISA_LIT>ompactSubtarget & ST ) : <ISA_LIT>ompactGenInstrInfo ( <STR_LIT> , <STR_LIT> ) , RI ( ST , * this ) , Subtarget ( ST ) {


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


<s> for ( unsigned i = <NUM_LIT> , e = MI -> getNumOperands ( ) ; i != e ; ++ i ) { const MachineOperand & MO = MI -> getOperand ( i ) ; if ( MO . isReg ( ) && MO . getReg ( ) == <STR_LIT> ) { Pred . push_back ( MO ) ; Found = true ; break ;


<s> virtual const <ISA_LIT>ompactRegisterInfo & getRegisterInfo ( ) const {


<s> if ( Cond . empty ( ) ) { assert ( ! FBB && <STR_LIT> ) ; BuildMI ( & MBB , DL , get ( <STR_LIT> ) ) . addMBB ( TBB ) ; return <NUM_LIT> ; } unsigned Count = <NUM_LIT> ; BuildMI ( & MBB , DL , get ( <STR_LIT> ) ) . addMBB ( TBB ) . addImm ( Cond [ <NUM_LIT> ] . getImm ( ) ) ; ++ Count ;


<s> assert ( ! FBB && <STR_LIT> ) ; BuildMI ( & MBB , DL , get ( <STR_LIT> ) ) . addMBB ( TBB ) ; return <NUM_LIT> ; } unsigned Count = <NUM_LIT> ;

BuildMI ( & MBB , DL , get ( <STR_LIT> ) ) . addMBB ( TBB ) . addImm ( Cond [ <NUM_LIT> ] . getImm ( ) ) ;


<s> static bool IsComment ( MachineInstr * I ) {

return I -> getNumOperands ( ) == <NUM_LIT> && I -> getOperand ( <NUM_LIT> ) . isMetadata ( ) ;


<s> if ( ! MI -> getDesc ( ) . isPredicable ( ) ) { return false ; } if ( MI -> getOperand ( <NUM_LIT> ) . getReg ( ) != MI -> getOperand ( <NUM_LIT> ) . getReg ( ) ) { return false ;


<s> return false ; } unsigned TUnpredCost = Probability . getNumerator ( ) * TCycles ; TUnpredCost /= Probability . getDenominator ( ) ; uint32_t Comp = Probability . getDenominator ( ) - Probability . getNumerator ( ) ; unsigned FUnpredCost = Comp * FCycles ; FUnpredCost /= Probability . getDenominator ( ) ; unsigned UnpredCost = TUnpredCost + FUnpredCost ; UnpredCost += <NUM_LIT> ;


<s> FUnpredCost /= Probability . getDenominator ( ) ; unsigned UnpredCost = TUnpredCost + FUnpredCost ; UnpredCost += <NUM_LIT> ; UnpredCost += <NUM_LIT> / <NUM_LIT> ; return ( TCycles + FCycles + TExtra + FExtra ) <= UnpredCost ;


<s> BuildMI ( MBB , MI , DL , get ( <STR_LIT> ) ) . addReg ( DestReg ) . addFrameIndex ( FrameIdx ) . addImm ( <NUM_LIT> ) ;


<s> DebugLoc DL ; if ( MI != MBB . end ( ) ) DL = MI -> getDebugLoc ( ) ; BuildMI ( MBB , MI , DL , get ( <STR_LIT> ) ) . addReg ( DestReg ) . addFrameIndex ( FrameIdx ) . addImm ( <NUM_LIT> ) ;


<s> bool <ISA_LIT>ompactInstrInfo :: PredicateInstruction ( MachineInstr * MI , const SmallVectorImpl < MachineOperand > & Pred ) const { int PIdx = MI -> findFirstPredOperandIdx ( ) ;


<s> while ( I != MBB . begin ( ) ) { -- I ; if ( I -> getOpcode ( ) != <STR_LIT> && I -> getOpcode ( ) != <STR_LIT> ) { break ;


<s> unsigned Count = <NUM_LIT> ; while ( I != MBB . begin ( ) ) { -- I ; if ( I -> getOpcode ( ) != <STR_LIT> && I -> getOpcode ( ) != <STR_LIT> ) { break ; } I -> eraseFromParent ( ) ; I = MBB . end ( ) ;


<s> bool <ISA_LIT>ompactInstrInfo :: ReverseBranchCondition ( SmallVectorImpl < MachineOperand > & Cond ) const { <STR_LIT> CC = ( <STR_LIT> ) ( int ) Cond [ <NUM_LIT> ] . getImm ( ) ;

Cond [ <NUM_LIT> ] . setImm ( <STR_LIT> ( CC ) ) ;


<s> <STR_LIT> CC = ( <STR_LIT> ) ( int ) Cond [ <NUM_LIT> ] . getImm ( ) ; Cond [ <NUM_LIT> ] . setImm ( <STR_LIT> ( CC ) ) ;


<s> void <ISA_LIT>ompactInstrInfo :: storeRegToStackSlot ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , unsigned SrcReg , bool isKill , int FrameIdx , const TargetRegisterClass * RC , const TargetRegisterInfo * TRI ) const { DebugLoc DL ; if ( MI != MBB . end ( ) ) DL = MI -> getDebugLoc ( ) ; BuildMI ( MBB , MI , DL , get ( <STR_LIT> ) ) . addFrameIndex ( FrameIdx ) . addImm ( <NUM_LIT> ) . addReg ( SrcReg , getKillRegState ( isKill ) ) ;


<s> DebugLoc DL ; if ( MI != MBB . end ( ) ) DL = MI -> getDebugLoc ( ) ;

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


<s> } <STR_LIT> CC1 = ( <STR_LIT> ) Pred1 [ <NUM_LIT> ] . getImm ( ) ; <STR_LIT> CC2 = ( <STR_LIT> ) Pred2 [ <NUM_LIT> ] . getImm ( ) ; if ( CC1 == CC2 ) { return true ; } switch ( CC1 ) { case <STR_LIT> : return true ; case <STR_LIT> :


<s> if ( Pred1 . size ( ) > <NUM_LIT> || Pred2 . size ( ) > <NUM_LIT> ) { return false ; } <STR_LIT> CC1 = ( <STR_LIT> ) Pred1 [ <NUM_LIT> ] . getImm ( ) ; <STR_LIT> CC2 = ( <STR_LIT> ) Pred2 [ <NUM_LIT> ] . getImm ( ) ; if ( CC1 == CC2 ) { return true ; } switch ( CC1 ) { case <STR_LIT> : return true ;


<s> explicit <ISA_LIT>ompactDAGToDAGISel ( <ISA_LIT>ompactTargetMachine & tm ) : SelectionDAGISel ( tm ) , Subtarget ( tm . getSubtarget < <ISA_LIT>ompactSubtarget > ( ) ) , TM ( tm ) {


<s> FunctionPass * llvm :: create<ISA_LIT>ompactISelDag ( <ISA_LIT>ompactTargetMachine & TM ) {

return new <ISA_LIT>ompactDAGToDAGISel ( TM ) ;


<s> FunctionPass * llvm :: create<ISA_LIT>ompactISelDag ( <ISA_LIT>ompactTargetMachine & TM ) { return new <ISA_LIT>ompactDAGToDAGISel ( TM ) ;


<s> if ( Op -> isMachineOpcode ( ) ) { return NULL ; } switch ( Op -> getOpcode ( ) ) { case <STR_LIT> : { assert ( Op -> getValueType ( <NUM_LIT> ) == <STR_LIT> ) ; int FI = cast < FrameIndexSDNode > ( Op ) -> getIndex ( ) ; SDValue TFI = CurDAG -> getTargetFrameIndex ( FI , <STR_LIT> ) ; if ( Op -> hasOneUse ( ) ) { return CurDAG -> SelectNodeTo ( Op , <STR_LIT> , <STR_LIT> , TFI , CurDAG -> getTargetConstant ( <NUM_LIT> , <STR_LIT> ) ) ;


<s> case <STR_LIT> : SDValue N0 = Addr . getOperand ( <NUM_LIT> ) ;

if ( GlobalAddressSDNode * G = dyn_cast < GlobalAddressSDNode > ( N0 ) ) {


<s> bool <ISA_LIT>ompactDAGToDAGISel :: SelectADDRlir ( SDValue Addr , SDValue & Offset , SDValue & R1 ) { return false ;


<s> bool <ISA_LIT>ompactDAGToDAGISel :: SelectADDRlir ( SDValue Addr , SDValue & Offset , SDValue & R1 ) {


<s> uint64_t CVal = CN -> getZExtValue ( ) ; if ( ( ( CVal << <NUM_LIT> ) >> <NUM_LIT> ) == CVal ) { SDValue N0 = Addr . getOperand ( <NUM_LIT> ) ; if ( FrameIndexSDNode * FIN = dyn_cast < FrameIndexSDNode > ( N0 ) ) { Base = CurDAG -> getTargetFrameIndex ( FIN -> getIndex ( ) , <STR_LIT> ) ; } else { Base = N0 ; } Offset = CurDAG -> getTargetConstant ( CVal , <STR_LIT> ) ; return true ; } } break ; case <STR_LIT> : SDValue N0 = Addr . getOperand ( <NUM_LIT> ) ; if ( GlobalAddressSDNode * G = dyn_cast < GlobalAddressSDNode > ( N0 ) ) { Base = CurDAG -> getTargetGlobalAddress ( G -> getGlobal ( ) , Addr . getDebugLoc ( ) , <STR_LIT> , G -> getOffset ( ) ) ; Offset = CurDAG -> getTargetConstant ( <NUM_LIT> , <STR_LIT> ) ; return true ; } break ; } Base = Addr ;


<s> bool <ISA_LIT>ompactDAGToDAGISel :: SelectADDRrli ( SDValue Addr , SDValue & R1 , SDValue & Offset ) { return false ;


<s> bool <ISA_LIT>ompactDAGToDAGISel :: SelectADDRrr ( SDValue Addr , SDValue & R1 , SDValue & R2 ) {


<s> MachineBasicBlock * copy1MBB = F -> CreateMachineBasicBlock ( LLVM_BB ) ; F -> insert ( I , copy0MBB ) ; F -> insert ( I , copy1MBB ) ; copy1MBB -> splice ( copy1MBB -> begin ( ) , BB , llvm :: next ( MachineBasicBlock :: iterator ( MI ) ) , BB -> end ( ) ) ; copy1MBB -> transferSuccessorsAndUpdatePHIs ( BB ) ; BB -> addSuccessor ( copy0MBB ) ; BB -> addSuccessor ( copy1MBB ) ; BuildMI ( BB , dl , TII . get ( <STR_LIT> ) ) . addMBB ( copy1MBB ) . addImm ( MI -> getOperand ( <NUM_LIT> ) . getImm ( ) ) ; BB = copy0MBB ;


<s> EVT <ISA_LIT>ompactTargetLowering :: getSetCCResultType ( EVT VT ) const { return <STR_LIT> ;


<s> EVT <ISA_LIT>ompactTargetLowering :: getSetCCResultType ( EVT VT ) const {


<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> ; default : return <NUM_LIT> ;


<s> switch ( Opcode ) { 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> SDValue TargetCC ; SDValue Flag = EmitCMP ( LHS , RHS , TargetCC , CC , dl , DAG ) ; return DAG . getNode ( <STR_LIT> , dl , Op . getValueType ( ) , Chain , Dest , TargetCC , Flag ) ;


<s> CCState CCInfo ( CallConv , isVarArg , DAG . getMachineFunction ( ) , getTargetMachine ( ) , RVLocs , * DAG . getContext ( ) ) ; CCInfo . AnalyzeCallResult ( Ins , RetCC_<ISA_LIT>ompact32 ) ; 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> ) ) ; } return Chain ;


<s> const GlobalValue * GV = cast < GlobalAddressSDNode > ( Op ) -> getGlobal ( ) ; int64_t Offset = cast < GlobalAddressSDNode > ( Op ) -> getOffset ( ) ;

SDValue Result = DAG . getTargetGlobalAddress ( GV , Op . getDebugLoc ( ) , getPointerTy ( ) , Offset ) ;


<s> SDValue <ISA_LIT>ompactTargetLowering :: LowerGlobalAddress ( SDValue Op , SelectionDAG & DAG ) const { const GlobalValue * GV = cast < GlobalAddressSDNode > ( Op ) -> getGlobal ( ) ; int64_t Offset = cast < GlobalAddressSDNode > ( Op ) -> getOffset ( ) ; SDValue Result = DAG . getTargetGlobalAddress ( GV , Op . getDebugLoc ( ) , getPointerTy ( ) , Offset ) ;

return DAG . getNode ( <STR_LIT> , Op . getDebugLoc ( ) , getPointerTy ( ) , Result ) ;


<s> case <STR_LIT> : return LowerSELECT_CC ( Op , DAG ) ; case <STR_LIT> : return LowerVASTART ( Op , DAG ) ; default :


<s> CCState CCInfo ( CallConv , isVarArg , DAG . getMachineFunction ( ) , DAG . getTarget ( ) , RVLocs , * DAG . getContext ( ) ) ; CCInfo . AnalyzeReturn ( Outs , RetCC_<ISA_LIT>ompact32 ) ; if ( MF . getRegInfo ( ) . liveout_empty ( ) ) { for ( unsigned i = <NUM_LIT> ; i != RVLocs . size ( ) ; ++ i ) if ( RVLocs [ i ] . isRegLoc ( ) ) { MF . getRegInfo ( ) . addLiveOut ( RVLocs [ i ] . getLocReg ( ) ) ; } } SDValue Flag ; for ( unsigned i = <NUM_LIT> ; i != RVLocs . size ( ) ; ++ i ) { CCValAssign & VA = RVLocs [ i ] ;

assert ( VA . isRegLoc ( ) && <STR_LIT> ) ;


<s> SDValue Flag = EmitCMP ( LHS , RHS , TargetCC , CC , dl , DAG ) ; SDVTList VTs = DAG . getVTList ( Op . getValueType ( ) , <STR_LIT> ) ; SmallVector < SDValue , <NUM_LIT> > Ops ; Ops . push_back ( TrueV ) ; Ops . push_back ( FalseV ) ; Ops . push_back ( TargetCC ) ;


<s> <ISA_LIT>ompactFunctionInfo * FuncInfo = MF . getInfo < <ISA_LIT>ompactFunctionInfo > ( ) ; DebugLoc dl = Op . getDebugLoc ( ) ; EVT PtrVT = DAG . getTargetLoweringInfo ( ) . getPointerTy ( ) ;

SDValue FR = DAG . getFrameIndex ( FuncInfo -> getVarArgsFrameIndex ( ) , PtrVT ) ;


<s> SDValue <ISA_LIT>ompactTargetLowering :: LowerVASTART ( SDValue Op , SelectionDAG & DAG ) const { MachineFunction & MF = DAG . getMachineFunction ( ) ; <ISA_LIT>ompactFunctionInfo * FuncInfo = MF . getInfo < <ISA_LIT>ompactFunctionInfo > ( ) ;


<s> SelectionDAG & DAG = DCI . DAG ; switch ( N -> getOpcode ( ) ) { case <STR_LIT> : return PerformSELECTCCCombine ( N , DAG , DCI ) ;


<s> <STR_LIT> CC = cast < CondCodeSDNode > ( N -> getOperand ( <NUM_LIT> ) ) -> get ( ) ; EVT ValueType = LHS . getValueType ( ) ; return SDValue ( ) ;


<s> explicit <ISA_LIT>ompactFunctionInfo ( MachineFunction & MF ) : VarArgsRegSaveSize ( <NUM_LIT> ) , VarArgsFrameIndex ( <NUM_LIT> ) {


<s> void setVarArgsRegSaveSize ( unsigned s ) { VarArgsRegSaveSize = s ;


<s> <ISA_LIT>ompactELFMCAsmInfo :: <ISA_LIT>ompactELFMCAsmInfo ( const Target & T , StringRef TT ) { UsesELFSectionDirectiveForBSS = true ; IsLittleEndian = true ; Triple TheTriple ( TT ) ; CommentString = <STR_LIT> ;


<s> static MCCodeGenInfo * create<ISA_LIT>ompactMCCodeGenInfo ( StringRef TT , Reloc :: Model RM , CodeModel :: Model CM ) { MCCodeGenInfo * X = new MCCodeGenInfo ( ) ;


<s> static MCCodeGenInfo * create<ISA_LIT>ompactMCCodeGenInfo ( StringRef TT , Reloc :: Model RM , CodeModel :: Model CM ) { MCCodeGenInfo * X = new MCCodeGenInfo ( ) ; X -> InitMCCodeGenInfo ( RM , CM ) ;


<s> MCInstrInfo * X = new MCInstrInfo ( ) ;


<s> static MCInstrInfo * create<ISA_LIT>ompactMCInstrInfo ( ) {


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


<s> Init<ISA_LIT>ompactMCRegisterInfo ( X , <STR_LIT> ) ;


<s> Init<ISA_LIT>ompactMCSubtargetInfo ( X , TT , CPU , FS ) ; return X ;


<s> void LLVMInitialize<ISA_LIT>ompactTargetMC ( ) { RegisterMCAsmInfo < <ISA_LIT>ompactELFMCAsmInfo > X ( The<ISA_LIT>ompactEncoreTarget ) ; TargetRegistry :: RegisterMCCodeGenInfo ( The<ISA_LIT>ompactEncoreTarget , create<ISA_LIT>ompactMCCodeGenInfo ) ; TargetRegistry :: RegisterMCInstrInfo ( The<ISA_LIT>ompactEncoreTarget , create<ISA_LIT>ompactMCInstrInfo ) ; TargetRegistry :: RegisterMCRegInfo ( The<ISA_LIT>ompactEncoreTarget , create<ISA_LIT>ompactMCRegisterInfo ) ; TargetRegistry :: RegisterMCSubtargetInfo ( The<ISA_LIT>ompactEncoreTarget , create<ISA_LIT>ompactMCSubtargetInfo ) ;


<s> void LLVMInitialize<ISA_LIT>ompactTargetMC ( ) { RegisterMCAsmInfo < <ISA_LIT>ompactELFMCAsmInfo > X ( The<ISA_LIT>ompactEncoreTarget ) ; TargetRegistry :: RegisterMCCodeGenInfo ( The<ISA_LIT>ompactEncoreTarget , create<ISA_LIT>ompactMCCodeGenInfo ) ;

TargetRegistry :: RegisterMCInstrInfo ( The<ISA_LIT>ompactEncoreTarget , create<ISA_LIT>ompactMCInstrInfo ) ;


<s> <ISA_LIT>ompactRegisterInfo :: <ISA_LIT>ompactRegisterInfo ( <ISA_LIT>ompactSubtarget & st , const TargetInstrInfo & tii ) : <ISA_LIT>ompactGenRegisterInfo ( <STR_LIT> ) , Subtarget ( st ) , TII ( tii ) {


<s> void <ISA_LIT>ompactRegisterInfo :: eliminateCallFramePseudoInstr ( MachineFunction & MF , MachineBasicBlock & MBB , MachineBasicBlock :: iterator I ) const {


<s> assert ( i < MI . getNumOperands ( ) && <STR_LIT> ) ; } int FrameIndex = MI . getOperand ( i ) . getIndex ( ) ; MachineFunction & MF = * MI . getParent ( ) -> getParent ( ) ; int Offset = MF . getFrameInfo ( ) -> getObjectOffset ( FrameIndex ) + MI . getOperand ( i + <NUM_LIT> ) . getImm ( ) ; if ( IsStore ( MI ) ) { if ( Offset >= - <NUM_LIT> && Offset <= <NUM_LIT> ) { MI . getOperand ( i ) . ChangeToRegister ( <STR_LIT> , false ) ; MI . getOperand ( i + <NUM_LIT> ) . ChangeToImmediate ( Offset ) ; } else { MI . getOperand ( i ) . ChangeToRegister ( <STR_LIT> , false ) ; MI . getOperand ( i + <NUM_LIT> ) . ChangeToImmediate ( <NUM_LIT> ) ; } } else { MI . getOperand ( i ) . ChangeToRegister ( <STR_LIT> , false ) ; MI . getOperand ( i + <NUM_LIT> ) . ChangeToImmediate ( Offset ) ;


<s> const unsigned * <ISA_LIT>ompactRegisterInfo :: getCalleeSavedRegs ( const MachineFunction * MF ) const { static const unsigned CalleeSavedRegs [ ] = {


<s> const unsigned * <ISA_LIT>ompactRegisterInfo :: getCalleeSavedRegs ( const MachineFunction * MF ) const { static const unsigned CalleeSavedRegs [ ] = { <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <NUM_LIT> } ; return CalleeSavedRegs ;


<s> unsigned <ISA_LIT>ompactRegisterInfo :: getFrameRegister ( const MachineFunction & MF ) const {


<s> unsigned <ISA_LIT>ompactRegisterInfo :: getRARegister ( ) const { return <STR_LIT> ;


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


<s> <ISA_LIT>ompactSelectionDAGInfo :: <ISA_LIT>ompactSelectionDAGInfo ( const <ISA_LIT>ompactTargetMachine & TM ) : TargetSelectionDAGInfo ( TM ) {


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


<s> PM . add ( create<ISA_LIT>ompactISelDag ( * this ) ) ;


<s> bool <ISA_LIT>ompactTargetMachine :: addPreSched2 ( PassManagerBase & PM , CodeGenOpt :: Level OptLevel ) {


<s> if ( OptLevel != CodeGenOpt :: None ) { PM . add ( createIfConverterPass ( ) ) ; } return true ;


<s> <ISA_LIT>ompactEncoreTargetMachine :: <ISA_LIT>ompactEncoreTargetMachine ( const Target & T , StringRef TT , StringRef CPU , StringRef FS , Reloc :: Model RM , CodeModel :: Model CM ) : <ISA_LIT>ompactTargetMachine ( T , TT , CPU , FS , RM , CM ) {


<s> <ISA_LIT>ompactTargetMachine :: <ISA_LIT>ompactTargetMachine ( const Target & T , StringRef TT , StringRef CPU , StringRef FS , Reloc :: Model RM , CodeModel :: Model CM ) : LLVMTargetMachine ( T , TT , CPU , FS , RM , CM ) , Subtarget ( TT , CPU , FS ) , DataLayout ( Subtarget . getDataLayout ( ) ) , TLInfo ( * this ) , TSInfo ( * this ) , InstrInfo ( Subtarget ) , FrameLowering ( Subtarget ) {


<s> virtual const TargetFrameLowering * getFrameLowering ( ) const { return & FrameLowering ;


<s> virtual const TargetFrameLowering * getFrameLowering ( ) const {


<s> virtual const <ISA_LIT>ompactInstrInfo * getInstrInfo ( ) const {


<s> return & InstrInfo . getRegisterInfo ( ) ;


<s> virtual const <ISA_LIT>ompactRegisterInfo * getRegisterInfo ( ) const { return & InstrInfo . getRegisterInfo ( ) ;


<s> virtual const <ISA_LIT>ompactSelectionDAGInfo * getSelectionDAGInfo ( ) const {


<s> virtual const <ISA_LIT>ompactSubtarget * getSubtargetImpl ( ) const {


<s> virtual const TargetData * getTargetData ( ) const { return & DataLayout ;


<s> virtual const <ISA_LIT>ompactTargetLowering * getTargetLowering ( ) const { return & TLInfo ;


<s> case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <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 : llvm_unreachable ( <STR_LIT> ) ; }


<s> inline static CondCodes getOppositeCondition ( CondCodes CC ) { switch ( CC ) { case COND_EQ : return COND_NE ; case COND_NE : return COND_EQ ; case COND_P : return COND_N ; case COND_N : return COND_P ; case COND_LO : return COND_HS ;