<s> return ( ( Value >>= <NUM_LIT> ) & <NUM_LIT> ) << <NUM_LIT> ; case <STR_LIT> : return ( Value & <NUM_LIT> ) << <NUM_LIT> ; case <STR_LIT> : return Value & <NUM_LIT> ; case <STR_LIT> : return ( Value & <NUM_LIT> ) << <NUM_LIT> ; case <STR_LIT> : return ( Value & <NUM_LIT> ) << <NUM_LIT> ; case <STR_LIT> : return ( Value & <NUM_LIT> ) << <NUM_LIT> ; case <STR_LIT> : return ( Value & <NUM_LIT> ) << <NUM_LIT> ; case <STR_LIT> : return ( ( Value + ( ( <ISA_LIT>TextSectOffset - <NUM_LIT> ) * <NUM_LIT> ) ) & <NUM_LIT> ) << <NUM_LIT> ; case MCFixupKind :: FK_Data_2 : return Value << <NUM_LIT> ;


<s> unsigned NumBytes = <NUM_LIT> ; Value = adjustFixupValue ( Fixup , Value ) ; if ( ! Value ) return ; unsigned Offset = Fixup . getOffset ( ) ; assert ( Offset + NumBytes <= DataSize && <STR_LIT> ) ; for ( unsigned i = <NUM_LIT> ; i != NumBytes ; ++ i ) Data [ Offset + i ] |= uint8_t ( ( Value >> ( ( NumBytes - i - <NUM_LIT> ) * <NUM_LIT> ) ) & <NUM_LIT> ) ;


<s> MCAsmBackend * llvm :: create<ISA_LIT>AsmBackend ( const Target & T , const MCRegisterInfo & MRI , const Triple & TT , StringRef CPU ) { const uint8_t ABI = MCELFObjectTargetWriter :: getOSABI ( TT . getOS ( ) ) ; return new ELF<ISA_LIT>AsmBackend ( T , TT . getTriple ( ) , ABI ) ;


<s> return create<ISA_LIT>ELFObjectWriter ( OS , OSABI ) ;


<s> ELF<ISA_LIT>AsmBackend ( const Target & T , const StringRef TT , uint8_t _OSABI ) : <ISA_LIT>AsmBackend ( T , TT ) , OSABI ( _OSABI ) {


<s> <ISA_LIT>AsmBackend ( const Target & T , const StringRef TT ) : MCAsmBackend ( ) {


<s> <ISA_LIT>ELFObjectWriter ( uint8_t OSABI ) : MCELFObjectTargetWriter ( true , OSABI , ELF :: EM_<ISA_LIT> , false ) {


<s> bool fixupNeedsRelaxation ( const MCFixup & Fixup , uint64_t Value , const MCRelaxableFragment * DF , const MCAsmLayout & Layout ) const override {


<s> const MCFixupKindInfo & getFixupKindInfo ( MCFixupKind Kind ) const override { const static MCFixupKindInfo Infos [ <STR_LIT> ] = { { <STR_LIT> , <NUM_LIT> , <NUM_LIT> , MCFixupKindInfo :: FKF_IsPCRel } , { <STR_LIT> , <NUM_LIT> , <NUM_LIT> , MCFixupKindInfo :: FKF_IsPCRel } , { <STR_LIT> , <NUM_LIT> , <NUM_LIT> , MCFixupKindInfo :: FKF_IsPCRel } , { <STR_LIT> , <NUM_LIT> , <NUM_LIT> , MCFixupKindInfo :: FKF_IsPCRel } , { <STR_LIT> , <NUM_LIT> , <NUM_LIT> , MCFixupKindInfo :: FKF_IsPCRel } , { <STR_LIT> , <NUM_LIT> , <NUM_LIT> , MCFixupKindInfo :: FKF_IsPCRel } , { <STR_LIT> , <NUM_LIT> , <NUM_LIT> , MCFixupKindInfo :: FKF_IsPCRel } , { <STR_LIT> , <NUM_LIT> , <NUM_LIT> , MCFixupKindInfo :: FKF_IsPCRel } , { <STR_LIT> , <NUM_LIT> , <NUM_LIT> , MCFixupKindInfo :: FKF_IsPCRel } , { <STR_LIT> , <NUM_LIT> , <NUM_LIT> , MCFixupKindInfo :: FKF_IsPCRel } , } ; if ( Kind < FirstTargetFixupKind ) return MCAsmBackend :: getFixupKindInfo ( Kind ) ; assert ( unsigned ( Kind - FirstTargetFixupKind ) < getNumFixupKinds ( ) && <STR_LIT> ) ; return Infos [ Kind - FirstTargetFixupKind ] ;


<s> unsigned getNumFixupKinds ( ) const override { return <STR_LIT> ;


<s> bool mayNeedRelaxation ( const MCInst & Inst ) const override {


( void ) adjustFixupValue ( Fixup , Value , & Asm . getContext ( ) ) ;


<s> void <ISA_LIT>AsmBackend :: processFixupValue ( const MCAssembler & Asm , const MCAsmLayout & Layout , const MCFixup & Fixup , const MCFragment * DF , const MCValue & Target , uint64_t & Value , bool & IsResolved ) { IsResolved = true ;


<s> void relaxInstruction ( const MCInst & Inst , MCInst & Res ) const override {


<s> bool writeNopData ( uint64_t Count , MCObjectWriter * OW ) const override { if ( Count == <NUM_LIT> ) return true ;


<s> if ( Count == <NUM_LIT> ) return true ; return false ;


<s> if ( Expr == <NUM_LIT> ) Inst . addOperand ( MCOperand :: createImm ( <NUM_LIT> ) ) ; else if ( const MCConstantExpr * CE = dyn_cast < MCConstantExpr > ( Expr ) ) Inst . addOperand ( MCOperand :: createImm ( CE -> getValue ( ) ) ) ; else Inst . addOperand ( MCOperand :: createExpr ( Expr ) ) ;


<s> void addImmOperands ( MCInst & Inst , unsigned N ) const { assert ( N == <NUM_LIT> && <STR_LIT> ) ; const MCExpr * Expr = getImm ( ) ;


<s> assert ( N == <NUM_LIT> && <STR_LIT> ) ; const MCExpr * Expr = getImm ( ) ;


<s> void addMemOperands ( MCInst & Inst , unsigned N ) const { assert ( N == <NUM_LIT> && <STR_LIT> ) ;

Inst . addOperand ( MCOperand :: createReg ( getMemBase ( ) ) ) ;


<s> void addMemOperands ( MCInst & Inst , unsigned N ) const { assert ( N == <NUM_LIT> && <STR_LIT> ) ; Inst . addOperand ( MCOperand :: createReg ( getMemBase ( ) ) ) ;


<s> static std :: unique_ptr < <ISA_LIT>Operand > CreateCondCode ( <STR_LIT> Code , SMLoc S , SMLoc E ) { auto Op = make_unique < <ISA_LIT>Operand > ( k_CondCode ) ; Op -> CondCode . Code = Code ; Op -> StartLoc = S ;


<s> static std :: unique_ptr < <ISA_LIT>Operand > CreateImm ( const MCExpr * Val , SMLoc S , SMLoc E ) { auto Op = make_unique < <ISA_LIT>Operand > ( k_Immediate ) ; Op -> Imm . Val = Val ; Op -> StartLoc = S ; Op -> EndLoc = E ; return Op ;


<s> Op -> Mem . Off = Off ; Op -> StartLoc = S ; Op -> EndLoc = E ;


<s> auto Op = make_unique < <ISA_LIT>Operand > ( k_Register ) ; Op -> Reg . RegNum = RegNum ; Op -> StartLoc = S ; Op -> EndLoc = E ;


<s> Op -> Tok . Length = Str . size ( ) ; Op -> StartLoc = S ; Op -> EndLoc = S ;


<s> static std :: unique_ptr < <ISA_LIT>Operand > CreateToken ( StringRef Str , SMLoc S ) {

auto Op = make_unique < <ISA_LIT>Operand > ( k_Token ) ;


<s> const MCExpr * <ISA_LIT>AsmParser :: evaluateRelocExpr ( const MCExpr * Expr , StringRef RelocStr , std :: string Identifier ) { MCSymbolRefExpr :: VariantKind Kind = StringSwitch < MCSymbolRefExpr :: VariantKind > ( RelocStr ) . Case ( <STR_LIT> , MCSymbolRefExpr :: VK_<ISA_LIT>_Q1 ) . Case ( <STR_LIT> , MCSymbolRefExpr :: VK_<ISA_LIT>_Q2 ) . Case ( <STR_LIT> , MCSymbolRefExpr :: VK_<ISA_LIT>_Q3 ) . Case ( <STR_LIT> , MCSymbolRefExpr :: VK_<ISA_LIT>_Q4 ) . Case ( <STR_LIT> , MCSymbolRefExpr :: VK_<ISA_LIT>_CALL26 ) . Case ( <STR_LIT> , MCSymbolRefExpr :: VK_<ISA_LIT>_CALL19 ) . Case ( <STR_LIT> , MCSymbolRefExpr :: VK_<ISA_LIT>_9BIT ) . Case ( <STR_LIT> , MCSymbolRefExpr :: VK_<ISA_LIT>_6BIT ) . Case ( <STR_LIT> , MCSymbolRefExpr :: VK_<ISA_LIT>_12BIT ) . Case ( <STR_LIT> , MCSymbolRefExpr :: VK_<ISA_LIT>_MOVRZ ) . Default ( MCSymbolRefExpr :: VK_<ISA_LIT>_NONE ) ; assert ( Kind != MCSymbolRefExpr :: VK_<ISA_LIT>_NONE ) ; MCContext & Ctx = getContext ( ) ; return MCSymbolRefExpr :: create ( Ctx . getOrCreateSymbol ( Identifier ) , Kind , Ctx ) ;


<s> <ISA_LIT>AsmParser ( const MCSubtargetInfo & sti , MCAsmParser & parser , const MCInstrInfo & MII , const MCTargetOptions & Options ) : MCTargetAsmParser ( Options , sti ) , Parser ( parser ) {

setAvailableFeatures ( ComputeAvailableFeatures ( getSTI ( ) . getFeatureBits ( ) ) ) ;


<s> setAvailableFeatures ( ComputeAvailableFeatures ( getSTI ( ) . getFeatureBits ( ) ) ) ;


<s> <ISA_LIT>AssemblerOptions ( ) : reorder ( true ) , macro ( true ) {


<s> <ISA_LIT>Operand ( KindTy K ) : MCParsedAsmOperand ( ) , Kind ( K ) {


<s> MCAsmLexer & getLexer ( ) const { return Parser . getLexer ( ) ;


<s> assert ( ( Kind == k_Memory ) && <STR_LIT> ) ; return Mem . Base ;


<s> assert ( ( Kind == k_Memory ) && <STR_LIT> ) ;


<s> unsigned <ISA_LIT>AsmParser :: getReg ( int RC , int RegNo ) { return * ( getContext ( ) . getRegisterInfo ( ) -> getRegClass ( RC ) . begin ( ) + RegNo ) ;


<s> SMLoc getStartLoc ( ) const { return StartLoc ;


<s> assert ( Kind == k_Token && <STR_LIT> ) ; return StringRef ( Tok . Data , Tok . Length ) ;


<s> bool isReorder ( ) { return reorder ;


<s> void LLVMInitialize<ISA_LIT>AsmParser ( ) { RegisterMCAsmParser < <ISA_LIT>AsmParser > X ( The<ISA_LIT>Target ) ;


<s> SMLoc ErrorLoc = IDLoc ; if ( ErrorInfo != ~ <NUM_LIT> ) { if ( ErrorInfo >= Operands . size ( ) ) return Error ( IDLoc , <STR_LIT> ) ; ErrorLoc = ( ( <ISA_LIT>Operand & ) * Operands [ ErrorInfo ] ) . getStartLoc ( ) ; if ( ErrorLoc == SMLoc ( ) ) ErrorLoc = IDLoc ; } return Error ( ErrorLoc , <STR_LIT> ) ; } case Match_MnemonicFail : return Error ( IDLoc , <STR_LIT> ) ; } return true ;


<s> int <ISA_LIT>AsmParser :: matchRegisterByNumber ( unsigned RegNum , StringRef Mnemonic ) {

if ( RegNum > <NUM_LIT> ) return - <NUM_LIT> ;


<s> <STR_LIT> CC = StringSwitch < <STR_LIT> > ( Cond . lower ( ) ) . Case ( <STR_LIT> , <STR_LIT> :: COND_EQ ) . Case ( <STR_LIT> , <STR_LIT> :: COND_NE ) . Case ( <STR_LIT> , <STR_LIT> :: COND_GT ) . Case ( <STR_LIT> , <STR_LIT> :: COND_GT ) . Case ( <STR_LIT> , <STR_LIT> :: COND_LE ) . Case ( <STR_LIT> , <STR_LIT> :: COND_LE ) . Case ( <STR_LIT> , <STR_LIT> :: COND_GE ) . Case ( <STR_LIT> , <STR_LIT> :: COND_LT ) . Case ( <STR_LIT> , <STR_LIT> :: COND_GT ) . Default ( <STR_LIT> :: COND_INVAL ) ; return CC ;


<s> StringRef IDVal = DirectiveID . getString ( ) ; if ( IDVal == <STR_LIT> ) { Parser . Lex ( ) ; return false ; } if ( IDVal == <STR_LIT> ) { Parser . Lex ( ) ; return false ; } if ( IDVal == <STR_LIT> ) { Parser . eatToEndOfStatement ( ) ; return false ; } if ( IDVal == <STR_LIT> ) { return parseDirectiveSet ( ) ; } if ( IDVal == <STR_LIT> ) { Parser . eatToEndOfStatement ( ) ; return false ; }


<s> if ( IDVal == <STR_LIT> ) { Parser . Lex ( ) ; return false ; } if ( IDVal == <STR_LIT> ) { Parser . Lex ( ) ; return false ; } if ( IDVal == <STR_LIT> ) { Parser . eatToEndOfStatement ( ) ; return false ; } if ( IDVal == <STR_LIT> ) { return parseDirectiveSet ( ) ; } if ( IDVal == <STR_LIT> ) { Parser . eatToEndOfStatement ( ) ; return false ; } if ( IDVal == <STR_LIT> ) { Parser . eatToEndOfStatement ( ) ; return false ; }


<s> else if ( Tok . getString ( ) == <STR_LIT> ) return parseSetMacroDirective ( ) ; else if ( Tok . getString ( ) == <STR_LIT> ) return parseSetNoMacroDirective ( ) ; return true ;


<s> bool <ISA_LIT>AsmParser :: ParseInstruction ( ParseInstructionInfo & Info , StringRef Name , SMLoc NameLoc , OperandVector & Operands ) { <ISA_LIT>TextSectOffset ++ ; if ( Name == <STR_LIT> ) Name = <STR_LIT> ; Name = StringSwitch < StringRef > ( Name . lower ( ) ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Default ( Name ) ; size_t Start = <NUM_LIT> , Next = Name . find ( '.' ) ; StringRef Head = Name . slice ( Start , Next ) ; Operands . push_back ( <STR_LIT> ( Head , NameLoc ) ) ; if ( Head == <STR_LIT> && Next != StringRef :: npos ) { Start = Next ; Next = Name . find ( '.' , Start + <NUM_LIT> ) ; Head = Name . slice ( Start + <NUM_LIT> , Next ) ; SMLoc SuffixLoc = SMLoc :: getFromPointer ( NameLoc . getPointer ( ) + ( Head . data ( ) - Name . data ( ) ) ) ; <STR_LIT> CC = parseCondCodeString ( Head ) ; if ( CC == <STR_LIT> :: COND_INVAL ) return Error ( SuffixLoc , <STR_LIT> ) ; const MCExpr * CC_Expr = MCConstantExpr :: create ( ( int64_t ) CC , getContext ( ) ) ; Operands . push_back ( <STR_LIT> ( CC_Expr , Parser . getTok ( ) . getLoc ( ) , SMLoc :: getFromPointer ( Parser . getTok ( ) . getLoc ( ) . getPointer ( ) - <NUM_LIT> ) ) ) ; } if ( getLexer ( ) . isNot ( AsmToken :: EndOfStatement ) ) { if ( ParseOperand ( Operands , Name ) ) { SMLoc Loc = getLexer ( ) . getLoc ( ) ; Parser . eatToEndOfStatement ( ) ; return Error ( Loc , <STR_LIT> ) ; } while ( getLexer ( ) . is ( AsmToken :: Comma ) ) { Parser . Lex ( ) ; if ( ParseOperand ( Operands , Name ) ) { SMLoc Loc = getLexer ( ) . getLoc ( ) ; Parser . eatToEndOfStatement ( ) ;


<s> bool <ISA_LIT>AsmParser :: ParseInstruction ( ParseInstructionInfo & Info , StringRef Name , SMLoc NameLoc , OperandVector & Operands ) { <ISA_LIT>TextSectOffset ++ ; if ( Name == <STR_LIT> ) Name = <STR_LIT> ; Name = StringSwitch < StringRef > ( Name . lower ( ) ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Case ( <STR_LIT> , <STR_LIT> ) . Default ( Name ) ; size_t Start = <NUM_LIT> , Next = Name . find ( '.' ) ; StringRef Head = Name . slice ( Start , Next ) ; Operands . push_back ( <STR_LIT> ( Head , NameLoc ) ) ; if ( Head == <STR_LIT> && Next != StringRef :: npos ) { Start = Next ; Next = Name . find ( '.' , Start + <NUM_LIT> ) ; Head = Name . slice ( Start + <NUM_LIT> , Next ) ; SMLoc SuffixLoc = SMLoc :: getFromPointer ( NameLoc . getPointer ( ) + ( Head . data ( ) - Name . data ( ) ) ) ; <STR_LIT> CC = parseCondCodeString ( Head ) ; if ( CC == <STR_LIT> :: COND_INVAL ) return Error ( SuffixLoc , <STR_LIT> ) ; const MCExpr * CC_Expr = MCConstantExpr :: create ( ( int64_t ) CC , getContext ( ) ) ; Operands . push_back ( <STR_LIT> ( CC_Expr , Parser . getTok ( ) . getLoc ( ) , SMLoc :: getFromPointer ( Parser . getTok ( ) . getLoc ( ) . getPointer ( ) - <NUM_LIT> ) ) ) ; } if ( getLexer ( ) . isNot ( AsmToken :: EndOfStatement ) ) { if ( ParseOperand ( Operands , Name ) ) { SMLoc Loc = getLexer ( ) . getLoc ( ) ; Parser . eatToEndOfStatement ( ) ; return Error ( Loc , <STR_LIT> ) ;


<s> case AsmToken :: Plus : return ( getParser ( ) . parseExpression ( Res ) ) ; case AsmToken :: Percent : return parseRelocOperand ( Res ) ; case AsmToken :: LParen : return false ;


<s> <ISA_LIT>AsmParser :: OperandMatchResultTy <ISA_LIT>AsmParser :: parseMemOperand ( OperandVector & Operands ) { if ( std :: string ( Parser . getTok ( ) . getString ( ) ) != <STR_LIT> ) { Error ( Parser . getTok ( ) . getLoc ( ) , <STR_LIT> ) ; Parser . Lex ( ) ; return MatchOperand_ParseFail ; } Parser . Lex ( ) ; const MCExpr * IdVal = <NUM_LIT> ; const AsmToken & Tok = Parser . getTok ( ) ; SMLoc S = Tok . getLoc ( ) ; if ( isOperandRegister ( Tok ) ) { if ( ParseRegisterOperand ( & Operands , <STR_LIT> ) ) { Error ( Parser . getTok ( ) . getLoc ( ) , <STR_LIT> ) ; return MatchOperand_ParseFail ;


<s> SMLoc S = Tok . getLoc ( ) ; if ( isOperandRegister ( Tok ) ) { if ( ParseRegisterOperand ( & Operands , <STR_LIT> ) ) { Error ( Parser . getTok ( ) . getLoc ( ) , <STR_LIT> ) ; return MatchOperand_ParseFail ; } } else { Error ( Parser . getTok ( ) . getLoc ( ) , <STR_LIT> ) ; return MatchOperand_ParseFail ; } const AsmToken & Tok2 = Parser . getTok ( ) ; if ( Tok2 . isNot ( AsmToken :: Comma ) ) { Error ( Parser . getTok ( ) . getLoc ( ) , <STR_LIT> ) ; return MatchOperand_ParseFail ; } SMLoc E = SMLoc :: getFromPointer ( Parser . getTok ( ) . getLoc ( ) . getPointer ( ) - <NUM_LIT> ) ; Parser . Lex ( ) ; if ( parseMemOffset ( IdVal ) ) return MatchOperand_ParseFail ; if ( std :: string ( Parser . getTok ( ) . getString ( ) ) != <STR_LIT> ) {


<s> DEBUG ( dbgs ( ) << <STR_LIT> ) ; std :: string token_str = std :: string ( Parser . getTok ( ) . getString ( ) ) ; switch ( getLexer ( ) . getKind ( ) ) { default : Error ( Parser . getTok ( ) . getLoc ( ) , <STR_LIT> ) ; return true ; case AsmToken :: Identifier : case AsmToken :: LParen : case AsmToken :: Minus : case AsmToken :: Plus : case AsmToken :: Integer : case AsmToken :: String : { if ( isOperandRegister ( Parser . getTok ( ) ) ) return ParseRegisterOperand ( & Operands , Mnemonic ) ; if ( token_str == <STR_LIT> ) Parser . Lex ( ) ; const MCExpr * IdVal ; SMLoc S = Parser . getTok ( ) . getLoc ( ) ; if ( getParser ( ) . parseExpression ( IdVal ) ) return true ; if ( IdVal -> getKind ( ) == MCExpr :: ExprKind :: SymbolRef ) { StringRef Opcode = StringRef ( ( ( <ISA_LIT>Operand * ) ( Operands [ <NUM_LIT> ] . get ( ) ) ) -> Tok . Data , ( ( <ISA_LIT>Operand * ) ( Operands [ <NUM_LIT> ] . get ( ) ) ) -> Tok . Length ) ;


<s> StartLoc = Parser . getTok ( ) . getLoc ( ) ; RegNo = ParseRegisterOperand ( nullptr , <STR_LIT> ) ;

EndLoc = Parser . getTok ( ) . getLoc ( ) ;


<s> if ( Tok . is ( AsmToken :: Identifier ) ) RegNo = matchRegisterName ( Tok . getString ( ) . lower ( ) ) ; else if ( Tok . is ( AsmToken :: Integer ) ) RegNo = matchRegisterByNumber ( static_cast < unsigned > ( Tok . getIntVal ( ) ) , Mnemonic . lower ( ) ) ; if ( RegNo == - <NUM_LIT> ) return true ; if ( Operands ) { Operands -> push_back ( <STR_LIT> ( RegNo , S , Parser . getTok ( ) . getLoc ( ) ) ) ;


<s> Parser . Lex ( ) ; const AsmToken & Tok = Parser . getTok ( ) ; if ( Tok . isNot ( AsmToken :: Identifier ) ) return true ; std :: string Str = Tok . getIdentifier ( ) . str ( ) ; std :: string LabelStr ; Parser . Lex ( ) ; const MCExpr * IdVal ; SMLoc EndLoc ; if ( getLexer ( ) . getKind ( ) == AsmToken :: LParen ) { Parser . Lex ( ) ;

if ( getLexer ( ) . getKind ( ) == AsmToken :: Dot ) Parser . Lex ( ) ;


<s> } Options . setMacro ( ) ; Parser . Lex ( ) ;


<s> } if ( Options . isReorder ( ) ) { reportParseError ( <STR_LIT> ) ; return false ; } Options . setNomacro ( ) ;


<s> bool <ISA_LIT>AsmParser :: parseSetNoReorderDirective ( ) { Parser . Lex ( ) ; if ( getLexer ( ) . isNot ( AsmToken :: EndOfStatement ) ) { reportParseError ( <STR_LIT> ) ; return false ;


<s> } Options . setNoreorder ( ) ; Parser . Lex ( ) ;


<s> bool <ISA_LIT>AsmParser :: parseSetReorderDirective ( ) { Parser . Lex ( ) ; if ( getLexer ( ) . isNot ( AsmToken :: EndOfStatement ) ) { reportParseError ( <STR_LIT> ) ; return false ; }


<s> OutStreamer -> EmitLabel ( CurrentFnSym ) ;


<s> MCInstLowering . Lower ( MI , TmpInst ) ;

EmitToStreamer ( * OutStreamer , TmpInst ) ;


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


<s> int Offset = <NUM_LIT> ; if ( ExtraCode ) return true ; const MachineOperand & MO = MI -> getOperand ( OpNum ) ; assert ( MO . isReg ( ) && <STR_LIT> ) ;

O << <STR_LIT> << <ISA_LIT>InstPrinter :: getRegisterName ( MO . getReg ( ) ) << <STR_LIT> << Offset << <STR_LIT> ;


<s> bool <ISA_LIT>AsmPrinter :: PrintAsmMemoryOperand ( const MachineInstr * MI , unsigned OpNum , unsigned AsmVariant , const char * ExtraCode , raw_ostream & O ) {


<s> O << <STR_LIT> << StringRef ( utohexstr ( MO . getImm ( ) ) ) . lower ( ) ; return false ; case 'x' : if ( ( MO . getType ( ) ) != MachineOperand :: MO_Immediate ) return true ; O << <STR_LIT> << StringRef ( utohexstr ( MO . getImm ( ) & <NUM_LIT> ) ) . lower ( ) ; return false ; case 'd' : if ( ( MO . getType ( ) ) != MachineOperand :: MO_Immediate ) return true ; O << MO . getImm ( ) ; return false ; case 'm' : if ( ( MO . getType ( ) ) != MachineOperand :: MO_Immediate ) return true ; O << MO . getImm ( ) - <NUM_LIT> ; return false ;


<s> O << * MO . getMBB ( ) -> getSymbol ( ) ; return ; case MachineOperand :: MO_GlobalAddress : O << * getSymbol ( MO . getGlobal ( ) ) ; break ; case MachineOperand :: MO_BlockAddress : { MCSymbol * BA = GetBlockAddressSymbol ( MO . getBlockAddress ( ) ) ; O << BA -> getName ( ) ; break ; } case MachineOperand :: MO_ExternalSymbol : O << * GetExternalSymbolSymbol ( MO . getSymbolName ( ) ) ; break ; case MachineOperand :: MO_JumpTableIndex : O << MAI -> getPrivateGlobalPrefix ( ) << <STR_LIT> << getFunctionNumber ( ) << '_' << MO . getIndex ( ) ; break ; case MachineOperand :: MO_ConstantPoolIndex : O << MAI -> getPrivateGlobalPrefix ( ) << <STR_LIT> << getFunctionNumber ( ) << <STR_LIT> << MO . getIndex ( ) ; if ( MO . getOffset ( ) ) O << <STR_LIT> << MO . getOffset ( ) ;


<s> FunctionPass * llvm :: create<ISA_LIT>DelaySlotFillerPass ( <ISA_LIT>TargetMachine & tm ) { return new Filler ( tm ) ;


<s> Filler ( TargetMachine & tm ) : MachineFunctionPass ( ID ) {


<s> const char * getPassName ( ) const override { return <STR_LIT> ;


<s> const <ISA_LIT>Subtarget & STI = MBB . getParent ( ) -> getSubtarget < <ISA_LIT>Subtarget > ( ) ; const <ISA_LIT>InstrInfo * TII = STI . getInstrInfo ( ) ; for ( Iter I = MBB . begin ( ) ; I != MBB . end ( ) ; ++ I ) { const MachineInstr * MI = & * I ; if ( insertStall ( MBB , I , TII , MI -> getOpcode ( ) ) ) { FilledSlots ++ ; Changed = true ;


<s> bool Changed = false ; for ( MachineFunction :: iterator FI = F . begin ( ) , FE = F . end ( ) ; FI != FE ; ++ FI ) { Changed |= runOnMachineBasicBlock ( * FI ) ; <ISA_LIT>TextSectOffset += FI -> size ( ) ; }


<s> for ( MachineFunction :: iterator FI = F . begin ( ) , FE = F . end ( ) ; FI != FE ; ++ FI ) { Changed |= runOnMachineBasicBlock ( * FI ) ; <ISA_LIT>TextSectOffset += FI -> size ( ) ; } return Changed ;


<s> static MCDisassembler * create<ISA_LIT>Disassebler ( const Target & T , const MCSubtargetInfo & STI , MCContext & Ctx ) {

return new <ISA_LIT>Disassembler ( STI , Ctx ) ;


<s> static DecodeStatus DecodeBranch26Target ( MCInst & Inst , unsigned Insn , uint64_t Address , const void * Decoder ) { Inst . addOperand ( MCOperand :: createImm ( SignExtend32 < <NUM_LIT> > ( Insn ) ) ) ;


<s> static DecodeStatus DecodeBranch26Target ( MCInst & Inst , unsigned Insn , uint64_t Address , const void * Decoder ) {

Inst . addOperand ( MCOperand :: createImm ( SignExtend32 < <NUM_LIT> > ( Insn ) ) ) ;


<s> Inst . addOperand ( MCOperand :: createImm ( SignExtend32 < <NUM_LIT> > ( Insn ) ) ) ;


<s> Inst . addOperand ( MCOperand :: createImm ( SignExtend32 < <NUM_LIT> > ( Insn ) ) ) ; return MCDisassembler :: Success ;


<s> if ( RegNo > <NUM_LIT> ) return MCDisassembler :: Fail ;

Inst . addOperand ( MCOperand :: createReg ( CPURegsTable [ RegNo ] ) ) ;


<s> static DecodeStatus DecodeCPURegsRegisterClass ( MCInst & Inst , unsigned RegNo , uint64_t Address , const void * Decoder ) { if ( RegNo > <NUM_LIT> ) return MCDisassembler :: Fail ;


<s> return DecodeCPURegsRegisterClass ( Inst , RegNo , Address , Decoder ) ;


<s> unsigned JumpOffset = fieldFromInstruction ( Insn , <NUM_LIT> , <NUM_LIT> ) ;

Inst . addOperand ( MCOperand :: createImm ( JumpOffset ) ) ;


<s> static DecodeStatus DecodeMem ( MCInst & Inst , unsigned Insn , uint64_t Address , const void * Decoder ) { int Reg = ( int ) fieldFromInstruction ( Insn , <NUM_LIT> , <NUM_LIT> ) ; int Offset = SignExtend32 < <NUM_LIT> > ( ( Insn & <NUM_LIT> ) >> <NUM_LIT> ) ; int Base = ( int ) fieldFromInstruction ( Insn , <NUM_LIT> , <NUM_LIT> ) ; Inst . addOperand ( MCOperand :: createReg ( CPURegsTable [ Reg ] ) ) ;

Inst . addOperand ( MCOperand :: createReg ( CPURegsTable [ Base ] ) ) ;


<s> TargetRegistry :: RegisterMCDisassembler ( The<ISA_LIT>Target , create<ISA_LIT>Disassebler ) ;


<s> static DecodeStatus readInstruction32 ( ArrayRef < uint8_t > Bytes , uint64_t Address , uint64_t & Size , uint32_t & Insn ) { if ( Bytes . size ( ) < <NUM_LIT> ) { Size = <NUM_LIT> ; return MCDisassembler :: Fail ; } Insn = ( Bytes [ <NUM_LIT> ] << <NUM_LIT> ) | ( Bytes [ <NUM_LIT> ] << <NUM_LIT> ) | ( Bytes [ <NUM_LIT> ] << <NUM_LIT> ) | ( Bytes [ <NUM_LIT> ] << <NUM_LIT> ) ;


Insn = ( Bytes [ <NUM_LIT> ] << <NUM_LIT> ) | ( Bytes [ <NUM_LIT> ] << <NUM_LIT> ) | ( Bytes [ <NUM_LIT> ] << <NUM_LIT> ) | ( Bytes [ <NUM_LIT> ] << <NUM_LIT> ) ;


<s> virtual ~ <ISA_LIT>Disassembler ( ) {


<s> MCObjectWriter * llvm :: create<ISA_LIT>ELFObjectWriter ( raw_pwrite_stream & OS , uint8_t OSABI ) { MCELFObjectTargetWriter * MOTW = new <ISA_LIT>ELFObjectWriter ( OSABI ) ;

return createELFObjectWriter ( MOTW , OS , false ) ;


<s> return createELFObjectWriter ( MOTW , OS , false ) ;


<s> <ISA_LIT>ELFObjectWriter :: <ISA_LIT>ELFObjectWriter ( uint8_t OSABI ) : MCELFObjectTargetWriter ( true , OSABI , ELF :: EM_<ISA_LIT> , false ) {


<s> llvm_unreachable ( <STR_LIT> ) ; case <STR_LIT> : Type = ELF :: R_<ISA_LIT>_MOV_Q1 ; break ; case <STR_LIT> : Type = ELF :: R_<ISA_LIT>_MOV_Q2 ; break ; case <STR_LIT> : Type = ELF :: R_<ISA_LIT>_MOV_Q3 ; break ; case <STR_LIT> : Type = ELF :: R_<ISA_LIT>_MOV_Q4 ; break ; case <STR_LIT> : Type = ELF :: R_<ISA_LIT>_CALL26 ; break ; case <STR_LIT> : Type = ELF :: R_<ISA_LIT>_CALL19 ; break ; case <STR_LIT> : Type = ELF :: R_<ISA_LIT>_9_ADDRESS ; break ; case <STR_LIT> : Type = ELF :: R_<ISA_LIT>_6_SHAMT ; break ; case <STR_LIT> :


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


<s> MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; uint64_t StackSize = MFI -> getStackSize ( ) ; unsigned StackAlign = getStackAlignment ( ) ; if ( StackAlign > <NUM_LIT> ) StackSize = RoundUpToAlignment ( StackSize , StackAlign ) ; return StackSize ;


<s> if ( StackAlign > <NUM_LIT> ) StackSize = RoundUpToAlignment ( StackSize , StackAlign ) ; return StackSize ;


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

if ( I -> getOpcode ( ) == <STR_LIT> || I -> getOpcode ( ) == <STR_LIT> ) MBB . erase ( I ) ;


<s> if ( ! StackSize ) return ; unsigned StackReg = <STR_LIT> ; unsigned OffsetReg = materializeOffset ( MF , MBB , MBBI , ( unsigned ) StackSize ) ; if ( OffsetReg ) { BuildMI ( MBB , MBBI , dl , TII . get ( <STR_LIT> ) , StackReg ) . addReg ( StackReg ) . addReg ( OffsetReg ) . setMIFlag ( MachineInstr :: FrameSetup ) ; } else {

BuildMI ( MBB , MBBI , dl , TII . get ( <STR_LIT> ) , StackReg ) . addReg ( StackReg ) . addImm ( StackSize ) . setMIFlag ( MachineInstr :: FrameSetup ) ;


<s> unsigned StackReg = <STR_LIT> ; unsigned OffsetReg = materializeOffset ( MF , MBB , MBBI , ( unsigned ) StackSize ) ; if ( OffsetReg ) { BuildMI ( MBB , MBBI , dl , TII . get ( <STR_LIT> ) , StackReg ) . addReg ( StackReg ) . addReg ( OffsetReg ) . setMIFlag ( MachineInstr :: FrameSetup ) ; } else { BuildMI ( MBB , MBBI , dl , TII . get ( <STR_LIT> ) , StackReg ) . addReg ( StackReg ) . addImm ( StackSize ) . setMIFlag ( MachineInstr :: FrameSetup ) ;


<s> void <ISA_LIT>FrameLowering :: emitPrologue ( MachineFunction & MF , MachineBasicBlock & MBB ) const { const TargetInstrInfo & TII = * MF . getSubtarget ( ) . getInstrInfo ( ) ; MachineBasicBlock :: iterator MBBI = MBB . begin ( ) ; DebugLoc dl = MBBI != MBB . end ( ) ? MBBI -> getDebugLoc ( ) : DebugLoc ( ) ; uint64_t StackSize = computeStackSize ( MF ) ; if ( ! StackSize ) return ; unsigned StackReg = <STR_LIT> ; unsigned OffsetReg = materializeOffset ( MF , MBB , MBBI , ( unsigned ) StackSize ) ; if ( OffsetReg ) { BuildMI ( MBB , MBBI , dl , TII . get ( <STR_LIT> ) , StackReg ) . addReg ( StackReg ) . addReg ( OffsetReg ) . setMIFlag ( MachineInstr :: FrameSetup ) ; } else {


<s> if ( ! StackSize ) return ; unsigned StackReg = <STR_LIT> ; unsigned OffsetReg = materializeOffset ( MF , MBB , MBBI , ( unsigned ) StackSize ) ; if ( OffsetReg ) { BuildMI ( MBB , MBBI , dl , TII . get ( <STR_LIT> ) , StackReg ) . addReg ( StackReg ) . addReg ( OffsetReg ) . setMIFlag ( MachineInstr :: FrameSetup ) ;


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


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


<s> DebugLoc dl = MBBI != MBB . end ( ) ? MBBI -> getDebugLoc ( ) : DebugLoc ( ) ; const uint64_t MaxSubImm = <NUM_LIT> ; if ( Offset <= MaxSubImm ) { return <NUM_LIT> ; } else { unsigned OffsetReg = <STR_LIT> ; unsigned OffsetQ1 = ( unsigned ) ( Offset & <NUM_LIT> ) ; unsigned OffsetQ2 = ( unsigned ) ( ( Offset & <NUM_LIT> ) >> <NUM_LIT> ) ; unsigned OffsetQ3 = ( unsigned ) ( ( Offset & <NUM_LIT> ) >> <NUM_LIT> ) ;

unsigned OffsetQ4 = ( unsigned ) ( ( Offset & <NUM_LIT> ) >> <NUM_LIT> ) ;


<s> const uint64_t MaxSubImm = <NUM_LIT> ; if ( Offset <= MaxSubImm ) { return <NUM_LIT> ; } else { unsigned OffsetReg = <STR_LIT> ; unsigned OffsetQ1 = ( unsigned ) ( Offset & <NUM_LIT> ) ; unsigned OffsetQ2 = ( unsigned ) ( ( Offset & <NUM_LIT> ) >> <NUM_LIT> ) ; unsigned OffsetQ3 = ( unsigned ) ( ( Offset & <NUM_LIT> ) >> <NUM_LIT> ) ; unsigned OffsetQ4 = ( unsigned ) ( ( Offset & <NUM_LIT> ) >> <NUM_LIT> ) ; BuildMI ( MBB , MBBI , dl , TII . get ( <STR_LIT> ) , OffsetReg ) . addImm ( OffsetQ1 ) . setMIFlag ( MachineInstr :: FrameSetup ) ; if ( OffsetQ2 ) { BuildMI ( MBB , MBBI , dl , TII . get ( <STR_LIT> ) , OffsetReg ) . addReg ( OffsetReg ) . addImm ( OffsetQ2 ) . setMIFlag ( MachineInstr :: FrameSetup ) ; } if ( OffsetQ3 ) { BuildMI ( MBB , MBBI , dl , TII . get ( <STR_LIT> ) , OffsetReg ) . addReg ( OffsetReg ) . addImm ( OffsetQ3 ) . setMIFlag ( MachineInstr :: FrameSetup ) ; } if ( OffsetQ4 ) { BuildMI ( MBB , MBBI , dl , TII . get ( <STR_LIT> ) , OffsetReg ) . addReg ( OffsetReg ) . addImm ( OffsetQ4 ) . setMIFlag ( MachineInstr :: FrameSetup ) ; } return OffsetReg ;


<s> static int stackSlotSize ( ) { return <NUM_LIT> ;


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


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


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


<s> static std :: string <ISA_LIT>_ez_int2hex ( int64_t val ) { std :: stringstream stream ;


<s> std :: stringstream stream ; stream << std :: hex << val ;


<s> O << <STR_LIT> ; printRegName ( O , Op1 . getReg ( ) ) ; unsigned Offset = Op2 . getImm ( ) ;

O << <STR_LIT> << <ISA_LIT>_ez_int2hex ( Offset ) << <STR_LIT> ;


<s> <STR_LIT> CC = ( <STR_LIT> ) Op . getImm ( ) ; const char * Str = <ISA_LIT>_condCodeToString ( CC ) ;


<s> <STR_LIT> CC = ( <STR_LIT> ) Op . getImm ( ) ;

const char * Str = <ISA_LIT>_condCodeToString ( CC ) ;


<s> const MCConstantExpr * CE = dyn_cast < MCConstantExpr > ( BE -> getRHS ( ) ) ; assert ( SRE && CE && <STR_LIT> ) ; Offset = CE -> getValue ( ) ; } else { SRE = dyn_cast < MCSymbolRefExpr > ( Expr ) ; assert ( SRE && <STR_LIT> ) ; } const MCSymbolRefExpr :: VariantKind Kind = SRE -> getKind ( ) ; switch ( Kind ) { case MCSymbolRefExpr :: VK_None : break ; case MCSymbolRefExpr :: VK_<ISA_LIT>_Q1 : OS << <STR_LIT> ; break ; case MCSymbolRefExpr :: VK_<ISA_LIT>_Q2 : OS << <STR_LIT> ; break ; case MCSymbolRefExpr :: VK_<ISA_LIT>_Q3 : OS << <STR_LIT> ; break ; case MCSymbolRefExpr :: VK_<ISA_LIT>_Q4 : OS << <STR_LIT> ; break ; case MCSymbolRefExpr :: VK_<ISA_LIT>_CALL26 : OS << <STR_LIT> ; break ; case MCSymbolRefExpr :: VK_<ISA_LIT>_CALL19 : OS << <STR_LIT> ; break ; case MCSymbolRefExpr :: VK_<ISA_LIT>_9BIT : OS << <STR_LIT> ; break ; case MCSymbolRefExpr :: VK_<ISA_LIT>_6BIT : OS << <STR_LIT> ; break ; case MCSymbolRefExpr :: VK_<ISA_LIT>_12BIT : OS << <STR_LIT> ; break ; case MCSymbolRefExpr :: VK_<ISA_LIT>_MOVRZ : OS << <STR_LIT> ; break ; default : { std :: string msg = <STR_LIT> + std :: to_string ( Kind ) + <STR_LIT> ; llvm_unreachable ( msg . c_str ( ) ) ; } } OS << SRE -> getSymbol ( ) ; if ( Offset ) { if ( Offset > <NUM_LIT> ) OS << '+' ;


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


<s> std :: string lsl_str = <STR_LIT> ; if ( ( MI -> getOpcode ( ) == <STR_LIT> || MI -> getOpcode ( ) == <STR_LIT> || MI -> getOpcode ( ) == <STR_LIT> || MI -> getOpcode ( ) == <STR_LIT> ) && OpNo == <NUM_LIT> ) lsl_str = <STR_LIT> ;

O << lsl_str << <STR_LIT> << <ISA_LIT>_ez_int2hex ( Op . getImm ( ) ) ;


<s> if ( ( MI -> getOpcode ( ) == <STR_LIT> || MI -> getOpcode ( ) == <STR_LIT> || MI -> getOpcode ( ) == <STR_LIT> || MI -> getOpcode ( ) == <STR_LIT> ) && OpNo == <NUM_LIT> ) lsl_str = <STR_LIT> ; O << lsl_str << <STR_LIT> << <ISA_LIT>_ez_int2hex ( Op . getImm ( ) ) ;


<s> void <ISA_LIT>InstPrinter :: printRegName ( raw_ostream & OS , unsigned RegNo ) const { OS << StringRef ( getRegisterName ( RegNo ) ) . lower ( ) ;


<s> OS << StringRef ( getRegisterName ( RegNo ) ) . lower ( ) ;


<s> if ( MI . getOpcode ( ) == <STR_LIT> ) { MachineBasicBlock * TargetBB = MI . getOperand ( <NUM_LIT> ) . getMBB ( ) ; if ( HasCondBranch ) FBB = TargetBB ; else TBB = TargetBB ; } else if ( MI . getOpcode ( ) == <STR_LIT> ) { MachineBasicBlock * TargetBB = MI . getOperand ( <NUM_LIT> ) . getMBB ( ) ; TBB = TargetBB ;

Cond . push_back ( MI . getOperand ( <NUM_LIT> ) ) ;


<s> bool HasCondBranch = false ; TBB = nullptr ; FBB = nullptr ; for ( MachineInstr & MI : MBB ) { if ( MI . getOpcode ( ) == <STR_LIT> ) {

MachineBasicBlock * TargetBB = MI . getOperand ( <NUM_LIT> ) . getMBB ( ) ;


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


<s> void <ISA_LIT>InstrInfo :: copyPhysReg ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator I , DebugLoc DL , unsigned DestReg , unsigned SrcReg , bool KillSrc ) const { BuildMI ( MBB , I , I -> getDebugLoc ( ) , get ( <STR_LIT> ) , DestReg ) . addReg ( SrcReg , getKillRegState ( KillSrc ) ) ;


<s> case <STR_LIT> : { DebugLoc DL = MI -> getDebugLoc ( ) ; MachineBasicBlock & MBB = * MI -> getParent ( ) ; const unsigned DstReg = MI -> getOperand ( <NUM_LIT> ) . getReg ( ) ; const bool DstIsDead = MI -> getOperand ( <NUM_LIT> ) . isDead ( ) ; const MachineOperand & MO = MI -> getOperand ( <NUM_LIT> ) ; auto Q1 = BuildMI ( MBB , MI , DL , get ( <STR_LIT> ) , DstReg ) ; auto Q2 = BuildMI ( MBB , MI , DL , get ( <STR_LIT> ) ) . addReg ( DstReg , RegState :: Define | getDeadRegState ( DstIsDead ) ) . addReg ( DstReg ) ; auto Q3 = BuildMI ( MBB , MI , DL , get ( <STR_LIT> ) ) . addReg ( DstReg , RegState :: Define | getDeadRegState ( DstIsDead ) ) . addReg ( DstReg ) ; auto Q4 = BuildMI ( MBB , MI , DL , get ( <STR_LIT> ) ) . addReg ( DstReg , RegState :: Define | getDeadRegState ( DstIsDead ) ) . addReg ( DstReg ) ; if ( MO . isImm ( ) ) { const uint64_t Imm = MO . getImm ( ) ; Q1 = Q1 . addImm ( Imm & <NUM_LIT> ) . addImm ( <NUM_LIT> ) ; Q2 = Q2 . addImm ( ( Imm >> <NUM_LIT> ) & <NUM_LIT> ) . addImm ( <NUM_LIT> ) ; Q3 = Q3 . addImm ( ( Imm >> <NUM_LIT> ) & <NUM_LIT> ) . addImm ( <NUM_LIT> ) ; Q4 = Q4 . addImm ( ( Imm >> <NUM_LIT> ) & <NUM_LIT> ) . addImm ( <NUM_LIT> ) ;


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


<s> const MachineFunction * MF = MI . getParent ( ) -> getParent ( ) ;

const char * AsmStr = MI . getOperand ( <NUM_LIT> ) . getSymbolName ( ) ;


<s> const <ISA_LIT>RegisterInfo & getRegisterInfo ( ) const {


<s> unsigned <ISA_LIT>InstrInfo :: InsertBranch ( MachineBasicBlock & MBB , MachineBasicBlock * TBB , MachineBasicBlock * FBB , ArrayRef < MachineOperand > Cond , DebugLoc DL ) const { unsigned NumInserted = <NUM_LIT> ; if ( Cond . size ( ) > <NUM_LIT> ) { BuildMI ( MBB , MBB . end ( ) , DL , get ( <STR_LIT> ) ) . addOperand ( Cond [ <NUM_LIT> ] ) . addMBB ( TBB ) ; NumInserted ++ ; } if ( Cond . empty ( ) || FBB ) { BuildMI ( MBB , MBB . end ( ) , DL , get ( <STR_LIT> ) ) . addMBB ( Cond . empty ( ) ? TBB : FBB ) ; NumInserted ++ ;


<s> unsigned <ISA_LIT>InstrInfo :: isLoadFromStackSlot ( const MachineInstr * MI , int & FrameIndex ) const {


<s> unsigned <ISA_LIT>InstrInfo :: isStoreToStackSlot ( const MachineInstr * MI , int & FrameIndex ) const {


<s> BuildMI ( MBB , I , I -> getDebugLoc ( ) , get ( <STR_LIT> ) , DestReg ) . addFrameIndex ( FrameIndex ) . addImm ( <NUM_LIT> ) ;


<s> void <ISA_LIT>InstrInfo :: loadRegFromStackSlot ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator I , unsigned DestReg , int FrameIndex , const TargetRegisterClass * RC , const TargetRegisterInfo * TRI ) const { BuildMI ( MBB , I , I -> getDebugLoc ( ) , get ( <STR_LIT> ) , DestReg ) . addFrameIndex ( FrameIndex ) . addImm ( <NUM_LIT> ) ;


<s> unsigned <ISA_LIT>InstrInfo :: RemoveBranch ( MachineBasicBlock & MBB ) const { if ( MBB . empty ( ) ) return <NUM_LIT> ; unsigned NumRemoved = <NUM_LIT> ; auto I = MBB . end ( ) ; do { -- I ;


<s> BuildMI ( MBB , I , I -> getDebugLoc ( ) , get ( <STR_LIT> ) ) . addReg ( SrcReg , getKillRegState ( isKill ) ) . addFrameIndex ( FrameIndex ) . addImm ( <NUM_LIT> ) ;


<s> void <ISA_LIT>InstrInfo :: storeRegToStackSlot ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator I , unsigned SrcReg , bool isKill , int FrameIndex , const TargetRegisterClass * RC , const TargetRegisterInfo * TRI ) const { BuildMI ( MBB , I , I -> getDebugLoc ( ) , get ( <STR_LIT> ) ) . addReg ( SrcReg , getKillRegState ( isKill ) ) . addFrameIndex ( FrameIndex ) . addImm ( <NUM_LIT> ) ;


<s> SDValue SD_ImmQ2 = CurDAG -> getTargetConstant ( ImmQ2 , N , <STR_LIT> ) ; Move = CurDAG -> getMachineNode ( <STR_LIT> , N , <STR_LIT> , SD_ImmQ2 , CurDAG -> getTargetConstant ( <NUM_LIT> , N , <STR_LIT> ) , SDValue ( Move , <NUM_LIT> ) ) ; } if ( ImmQ3 ) { SDValue SD_ImmQ3 = CurDAG -> getTargetConstant ( ImmQ3 , N , <STR_LIT> ) ; Move = CurDAG -> getMachineNode ( <STR_LIT> , N , <STR_LIT> , SD_ImmQ3 , CurDAG -> getTargetConstant ( <NUM_LIT> , N , <STR_LIT> ) , SDValue ( Move , <NUM_LIT> ) ) ; }


<s> return new <ISA_LIT>DAGToDAGISel ( TM , OptLevel ) ;


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


<s> explicit <ISA_LIT>DAGToDAGISel ( <ISA_LIT>TargetMachine & TM , CodeGenOpt :: Level OptLevel ) : SelectionDAGISel ( TM , OptLevel ) , Subtarget ( * TM . getSubtargetImpl ( ) ) {


<s> switch ( N -> getOpcode ( ) ) { case <STR_LIT> : return SelectIndexedLoad ( N ) ; case <STR_LIT> : return SelectIndexedStore ( N ) ; case <STR_LIT> : return SelectFrameIndex ( N ) ; case <STR_LIT> : return ConstantToRegisterExpand ( N , SDValue ( N , <NUM_LIT> ) ) . getNode ( ) ; case <STR_LIT> : if ( N -> getOperand ( <NUM_LIT> ) . getOpcode ( ) == <STR_LIT> ) return SelectTargetGlobalAddressforADD ( N , N -> getOperand ( <NUM_LIT> ) . getNode ( ) ) ; break ; case <STR_LIT> : return SelectCompare ( N ) ; case <STR_LIT> : return SelectConditionalBranch ( N ) ; case <STR_LIT> : if ( N -> getOperand ( <NUM_LIT> ) . getOpcode ( ) == <STR_LIT> ) { GlobalAddressSDNode * GA = dyn_cast < GlobalAddressSDNode > ( N -> getOperand ( <NUM_LIT> ) ) ; const GlobalValue * GV = GA -> getGlobal ( ) ;


<s> if ( GV -> getValueID ( ) == Value :: FunctionVal ) TargetFlags = <STR_LIT> ; SDValue TargetGlobalAddr = CurDAG -> getTargetGlobalAddress ( GV , SDLoc ( N ) , <STR_LIT> , GA -> getOffset ( ) , TargetFlags ) ; MachineSDNode * Move = CurDAG -> getMachineNode ( <STR_LIT> , N , <STR_LIT> , TargetGlobalAddr , CurDAG -> getTargetConstant ( <NUM_LIT> , N , <STR_LIT> ) ) ; CurDAG -> ReplaceAllUsesWith ( N -> getOperand ( <NUM_LIT> ) , SDValue ( Move , <NUM_LIT> ) ) ; } break ; case <STR_LIT> : { unsigned int operand2Opc = N -> getOperand ( <NUM_LIT> ) . getOpcode ( ) ;


<s> unsigned int operand2Opc = N -> getOperand ( <NUM_LIT> ) . getOpcode ( ) ; if ( operand2Opc == <STR_LIT> ) { return CurDAG -> getMachineNode ( <STR_LIT> , N , BRLTys , { SDValue ( SelectIndexedLoad ( N -> getOperand ( <NUM_LIT> ) . getNode ( ) ) , <NUM_LIT> ) , N -> getOperand ( <NUM_LIT> ) , N -> getOperand ( <NUM_LIT> ) } ) ; } else if ( operand2Opc == <STR_LIT> ) {

return CurDAG -> getMachineNode ( <STR_LIT> , N , BRLTys , { N -> getOperand ( <NUM_LIT> ) , N -> getOperand ( <NUM_LIT> ) , N -> getOperand ( <NUM_LIT> ) } ) ;


<s> SDValue RHS = N -> getOperand ( <NUM_LIT> ) ;

SDValue CompareOps [ ] = { LHS , RHS } ;


<s> SDNode * <ISA_LIT>DAGToDAGISel :: SelectCompare ( SDNode * N ) { SDValue LHS = N -> getOperand ( <NUM_LIT> ) ; SDValue RHS = N -> getOperand ( <NUM_LIT> ) ;


<s> SDVTList CompareVT = CurDAG -> getVTList ( CompareTys ) ; SDValue CompareOps [ ] = { LHS , RHS , Chain } ; SDNode * Compare = CurDAG -> getMachineNode ( <STR_LIT> , N , CompareVT , CompareOps ) ; CondCodeSDNode * CC = cast < CondCodeSDNode > ( Cond . getNode ( ) ) ; uint64_t TargetCCode ; switch ( CC -> get ( ) ) { case <STR_LIT> :: SETOEQ : case <STR_LIT> :: SETUEQ : case <STR_LIT> :: SETEQ : TargetCCode = <STR_LIT> ; break ; case <STR_LIT> :: SETONE : case <STR_LIT> :: SETUNE : case <STR_LIT> :: SETNE : TargetCCode = <STR_LIT> ; break ; case <STR_LIT> :: SETOLT : case <STR_LIT> :: SETULT : case <STR_LIT> :: SETLT : TargetCCode = <STR_LIT> ; break ; case <STR_LIT> :: SETOLE : case <STR_LIT> :: SETULE : case <STR_LIT> :: SETLE : TargetCCode = <STR_LIT> ; break ; case <STR_LIT> :: SETOGT : case <STR_LIT> :: SETUGT : case <STR_LIT> :: SETGT : TargetCCode = <STR_LIT> ; break ;

case <STR_LIT> :: SETOGE : case <STR_LIT> :: SETUGE : case <STR_LIT> :: SETGE : TargetCCode = <STR_LIT> ; break ;


<s> SDValue ops [ ] = { TFI , CurDAG -> getTargetConstant ( <NUM_LIT> , N , <STR_LIT> ) } ; return CurDAG -> SelectNodeTo ( N , <STR_LIT> , <STR_LIT> , ops ) ;


<s> case <STR_LIT> : Src = ConstantToRegisterExpand ( N , Src ) ; break ; case <STR_LIT> : { GlobalAddressSDNode * GA = dyn_cast < GlobalAddressSDNode > ( Src ) ; const GlobalValue * GV = GA -> getGlobal ( ) ; unsigned char TargetFlags = <STR_LIT> ; if ( GV -> getValueID ( ) == Value :: FunctionVal ) TargetFlags = <STR_LIT> ; SDValue TargetGlobalAddr = CurDAG -> getTargetGlobalAddress ( GV , SDLoc ( N ) , <STR_LIT> , GA -> getOffset ( ) , TargetFlags ) ; MachineSDNode * Move = CurDAG -> getMachineNode ( <STR_LIT> , N , <STR_LIT> , TargetGlobalAddr , CurDAG -> getTargetConstant ( <NUM_LIT> , N , <STR_LIT> ) ) ; Src = SDValue ( Move , <NUM_LIT> ) ; break ; } default : break ; } switch ( Base . getOpcode ( ) ) { case <STR_LIT> : Base = ConstantToRegisterExpand ( N , Base ) ; break ; case <STR_LIT> : break ; case <STR_LIT> : { FrameIndexSDNode * FIN = dyn_cast < FrameIndexSDNode > ( STNode -> getBasePtr ( ) ) ; Base = CurDAG -> getTargetFrameIndex ( FIN -> getIndex ( ) , <STR_LIT> ) ; break ; } case <STR_LIT> : { GlobalAddressSDNode * GA = dyn_cast < GlobalAddressSDNode > ( Base ) ; const GlobalValue * GV = GA -> getGlobal ( ) ; unsigned char TargetFlags = <STR_LIT> ; if ( GV -> getValueID ( ) == Value :: FunctionVal ) TargetFlags = <STR_LIT> ; SDValue TargetGlobalAddr = CurDAG -> getTargetGlobalAddress ( GV , SDLoc ( N ) , <STR_LIT> , GA -> getOffset ( ) , TargetFlags ) ; MachineSDNode * Move = CurDAG -> getMachineNode ( <STR_LIT> , N , <STR_LIT> , TargetGlobalAddr , CurDAG -> getTargetConstant ( <NUM_LIT> , N , <STR_LIT> ) ) ; Base = SDValue ( Move , <NUM_LIT> ) ; break ; } case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : break ; } SDValue ops [ ] = { Src , Base , Offset , STNode -> getChain ( ) } ; return CurDAG -> getMachineNode ( Opc , SDLoc ( N ) , <STR_LIT> , ops ) ;


<s> case InlineAsm :: Constraint_m : OutOps . push_back ( Op ) ; return false ; }


<s> SDValue Op2 = N -> getOperand ( <NUM_LIT> ) ; return CurDAG -> getMachineNode ( <STR_LIT> , N , <STR_LIT> , Op1 , Op2 ) ;


<s> unsigned Opc = N -> getOpcode ( ) ; SDValue Src1 = N -> getOperand ( <NUM_LIT> ) ; SDValue Src2 = N -> getOperand ( <NUM_LIT> ) ; if ( Src2 . getOpcode ( ) == <STR_LIT> ) Src2 = SDValue ( SelectIndexedLoad ( Src2 . getNode ( ) ) , <NUM_LIT> ) ; if ( Opc == <STR_LIT> ) return CurDAG -> getMachineNode ( <STR_LIT> , N , <STR_LIT> , Src1 , Src2 ) ; else if ( Opc == <STR_LIT> ) return CurDAG -> getMachineNode ( <STR_LIT> , N , <STR_LIT> , Src1 , Src2 ) ; else if ( Opc == <STR_LIT> ) return CurDAG -> getMachineNode ( <STR_LIT> , N , <STR_LIT> , Src1 , Src2 ) ;


<s> unsigned char TargetFlags = <STR_LIT> ; if ( GV -> getValueID ( ) == Value :: FunctionVal ) TargetFlags = <STR_LIT> ; SDValue TargetGlobalAddr = CurDAG -> getTargetGlobalAddress ( GV , SDLoc ( N ) , <STR_LIT> , GA -> getOffset ( ) , TargetFlags ) ; MachineSDNode * Move = CurDAG -> getMachineNode ( <STR_LIT> , N , <STR_LIT> , TargetGlobalAddr , CurDAG -> getTargetConstant ( <NUM_LIT> , N , <STR_LIT> ) ) ; SDValue op2 = N -> getOperand ( <NUM_LIT> ) ; unsigned Opcode ; if ( op2 . getOpcode ( ) == <STR_LIT> ) {

op2 = CurDAG -> getTargetConstant ( cast < ConstantSDNode > ( op2 . getNode ( ) ) -> getZExtValue ( ) , N , <STR_LIT> ) ;


<s> MachineSDNode * Move = CurDAG -> getMachineNode ( <STR_LIT> , N , <STR_LIT> , TargetGlobalAddr , CurDAG -> getTargetConstant ( <NUM_LIT> , N , <STR_LIT> ) ) ; SDValue op2 = N -> getOperand ( <NUM_LIT> ) ; unsigned Opcode ; if ( op2 . getOpcode ( ) == <STR_LIT> ) { op2 = CurDAG -> getTargetConstant ( cast < ConstantSDNode > ( op2 . getNode ( ) ) -> getZExtValue ( ) , N , <STR_LIT> ) ; Opcode = <STR_LIT> ; } else { Opcode = <STR_LIT> ; }

return CurDAG -> getMachineNode ( Opcode , SDLoc ( N ) , <STR_LIT> , SDValue ( Move , <NUM_LIT> ) , op2 ) ;


<s> static void AnalyzeArguments ( CCState & State , SmallVectorImpl < CCValAssign > & ArgLocs , const SmallVectorImpl < ArgT > & Args ) { static const MCPhysReg RegList [ ] = { <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> } ; static const unsigned NbRegs = array_lengthof ( RegList ) ; SmallVector < unsigned , <NUM_LIT> > ArgsParts ; ParseFunctionArgs ( Args , ArgsParts ) ; if ( State . isVarArg ( ) ) { unsigned ValNo = <NUM_LIT> ; for ( unsigned i = <NUM_LIT> , e = ArgsParts . size ( ) ; i != e ; i ++ ) { MVT ArgVT = Args [ ValNo ] . VT ; MVT LocVT = ArgVT ; CCValAssign :: LocInfo LocInfo = CCValAssign :: Full ; for ( unsigned j = <NUM_LIT> ; j < ArgsParts [ i ] ; j ++ ) { if ( i == <NUM_LIT> && j == <NUM_LIT> ) State . addLoc ( CCValAssign :: getCustomMem ( ValNo ++ , ArgVT , State . AllocateStack ( <NUM_LIT> , <NUM_LIT> ) , LocVT , LocInfo ) ) ; else State . addLoc ( CCValAssign :: getCustomMem ( ValNo ++ , ArgVT , State . AllocateStack ( <NUM_LIT> , <NUM_LIT> ) , LocVT , LocInfo ) ) ; } } return ; } unsigned RegsLeft = NbRegs ; bool UseStack = false ; unsigned ValNo = <NUM_LIT> ; for ( unsigned i = <NUM_LIT> , e = ArgsParts . size ( ) ; i != e ; i ++ ) { MVT ArgVT = Args [ ValNo ] . VT ; <STR_LIT> ArgFlags = Args [ ValNo ] . Flags ; MVT LocVT = ArgVT ; CCValAssign :: LocInfo LocInfo = CCValAssign :: Full ; if ( ArgFlags . isByVal ( ) ) {

State . HandleByVal ( ValNo ++ , ArgVT , LocVT , LocInfo , <NUM_LIT> , <NUM_LIT> , ArgFlags ) ;


<s> static const MCPhysReg RegList [ ] = { <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> } ; static const unsigned NbRegs = array_lengthof ( RegList ) ; SmallVector < unsigned , <NUM_LIT> > ArgsParts ; ParseFunctionArgs ( Args , ArgsParts ) ; if ( State . isVarArg ( ) ) { unsigned ValNo = <NUM_LIT> ; for ( unsigned i = <NUM_LIT> , e = ArgsParts . size ( ) ; i != e ; i ++ ) { MVT ArgVT = Args [ ValNo ] . VT ; MVT LocVT = ArgVT ; CCValAssign :: LocInfo LocInfo = CCValAssign :: Full ; for ( unsigned j = <NUM_LIT> ; j < ArgsParts [ i ] ; j ++ ) {

if ( i == <NUM_LIT> && j == <NUM_LIT> ) State . addLoc ( CCValAssign :: getCustomMem ( ValNo ++ , ArgVT , State . AllocateStack ( <NUM_LIT> , <NUM_LIT> ) , LocVT , LocInfo ) ) ;


<s> static void AnalyzeRetResult ( CCState & State , const SmallVectorImpl < <STR_LIT> > & Outs ) {

State . AnalyzeReturn ( Outs , RetCC_<ISA_LIT> ) ;


<s> State . AnalyzeFormalArguments ( Ins , CC_<ISA_LIT> ) ;


<s> static void AnalyzeVarArgs ( CCState & State , const SmallVectorImpl < <STR_LIT> > & Ins ) {

State . AnalyzeFormalArguments ( Ins , CC_<ISA_LIT> ) ;


<s> SmallVector < CCValAssign , <NUM_LIT> > RVLocs ; CCState CCInfo ( CallConv , isVarArg , MF , RVLocs , Context ) ; if ( ! CCInfo . CheckReturn ( Outs , RetCC_<ISA_LIT> ) ) return false ;

if ( CCInfo . getNextStackOffset ( ) != <NUM_LIT> && isVarArg ) return false ;


<s> MachineFunction :: iterator I = ++ BB -> getIterator ( ) ; MachineBasicBlock * ThisMBB = BB ; MachineFunction * F = BB -> getParent ( ) ; MachineBasicBlock * Copy0MBB = F -> CreateMachineBasicBlock ( LLVM_BB ) ; MachineBasicBlock * Copy1MBB = F -> CreateMachineBasicBlock ( LLVM_BB ) ; F -> insert ( I , Copy0MBB ) ; F -> insert ( I , Copy1MBB ) ;

Copy1MBB -> splice ( Copy1MBB -> begin ( ) , BB , std :: next ( MachineBasicBlock :: iterator ( MI ) ) , BB -> end ( ) ) ;


<s> setSchedulingPreference ( Sched :: Source ) ; setOperationAction ( <STR_LIT> , <STR_LIT> , Custom ) ; setOperationAction ( <STR_LIT> , <STR_LIT> , Expand ) ; setOperationAction ( <STR_LIT> , <STR_LIT> , Custom ) ; setOperationAction ( <STR_LIT> , <STR_LIT> , Custom ) ; setOperationAction ( <STR_LIT> , <STR_LIT> , Expand ) ; setOperationAction ( <STR_LIT> , <STR_LIT> , Expand ) ; setOperationAction ( <STR_LIT> , <STR_LIT> , Expand ) ; setOperationAction ( <STR_LIT> , <STR_LIT> , Expand ) ; setOperationAction ( <STR_LIT> , <STR_LIT> , Expand ) ;


<s> setOperationAction ( <STR_LIT> , <STR_LIT> , Custom ) ; setOperationAction ( <STR_LIT> , <STR_LIT> , Custom ) ; setOperationAction ( <STR_LIT> , <STR_LIT> , Expand ) ; setOperationAction ( <STR_LIT> , <STR_LIT> , Expand ) ; setOperationAction ( <STR_LIT> , <STR_LIT> , Expand ) ; setOperationAction ( <STR_LIT> , <STR_LIT> , Expand ) ; setOperationAction ( <STR_LIT> , <STR_LIT> , Expand ) ; setOperationAction ( <STR_LIT> , <STR_LIT> , Expand ) ; setOperationAction ( <STR_LIT> , <STR_LIT> , Expand ) ; setOperationAction ( <STR_LIT> , <STR_LIT> , Expand ) ; setOperationAction ( <STR_LIT> , <STR_LIT> , Expand ) ;


<s> assert ( ! LHS . getValueType ( ) . isFloatingPoint ( ) && <STR_LIT> ) ; <STR_LIT> TCC = <STR_LIT> ; switch ( CC ) { default : llvm_unreachable ( <STR_LIT> ) ; case <STR_LIT> : TCC = <STR_LIT> ; if ( LHS . getOpcode ( ) == <STR_LIT> ) std :: swap ( LHS , RHS ) ; break ; case <STR_LIT> : TCC = <STR_LIT> ; if ( LHS . getOpcode ( ) == <STR_LIT> ) std :: swap ( LHS , RHS ) ; break ; case <STR_LIT> : std :: swap ( LHS , RHS ) ; case <STR_LIT> : if ( const ConstantSDNode * C = dyn_cast < ConstantSDNode > ( LHS ) ) { LHS = RHS ; RHS = DAG . getConstant ( C -> getSExtValue ( ) + <NUM_LIT> , dl , C -> getValueType ( <NUM_LIT> ) ) ; TCC = <STR_LIT> ; break ; } TCC = <STR_LIT> ; break ; case <STR_LIT> : std :: swap ( LHS , RHS ) ; case <STR_LIT> :


<s> switch ( Constraint [ <NUM_LIT> ] ) { case 'r' : if ( VT == <STR_LIT> || VT == <STR_LIT> || VT == <STR_LIT> || VT == <STR_LIT> ) return std :: make_pair ( <NUM_LIT> , & <STR_LIT> ) ; return std :: make_pair ( <NUM_LIT> , static_cast < const TargetRegisterClass * > ( <NUM_LIT> ) ) ; case 'c' : if ( VT == <STR_LIT> ) return std :: make_pair ( ( unsigned ) <STR_LIT> , & <STR_LIT> ) ; assert ( <STR_LIT> ) ; }


<s> Value * CallOperandVal = info . CallOperandVal ; if ( ! CallOperandVal ) return CW_Default ; Type * type = CallOperandVal -> getType ( ) ; switch ( * constraint ) { default : weight = TargetLowering :: getSingleConstraintMatchWeight ( info , constraint ) ; break ; case 'c' : if ( type -> isIntegerTy ( ) ) weight = CW_SpecificReg ; break ; case 'I' : case 'J' : case 'K' : case 'L' : case 'N' : case 'O' : case 'P' : if ( isa < ConstantInt > ( CallOperandVal ) ) weight = CW_Constant ; break ; case 'R' : weight = CW_Memory ;


<s> Type * type = CallOperandVal -> getType ( ) ; switch ( * constraint ) { default : weight = TargetLowering :: getSingleConstraintMatchWeight ( info , constraint ) ; break ; case 'c' : if ( type -> isIntegerTy ( ) ) weight = CW_SpecificReg ; break ; case 'I' : case 'J' : case 'K' : case 'L' : case 'N' :


<s> return NULL ; 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> switch ( AM . Scale ) { case <NUM_LIT> : break ; case <NUM_LIT> : if ( ! AM . HasBaseReg ) break ; return false ; default : return false ;


<s> Result = DAG . getTargetConstant ( Val , DL , Type ) ; break ; } } return ; case 'N' : if ( ConstantSDNode * C = dyn_cast < ConstantSDNode > ( Op ) ) { EVT Type = Op . getValueType ( ) ; int64_t Val = C -> getSExtValue ( ) ; if ( ( Val >= - <NUM_LIT> ) && ( Val <= - <NUM_LIT> ) ) { Result = DAG . getTargetConstant ( Val , DL , Type ) ; break ; } } return ; case 'O' : if ( ConstantSDNode * C = dyn_cast < ConstantSDNode > ( Op ) ) { EVT Type = Op . getValueType ( ) ; int64_t Val = C -> getSExtValue ( ) ; if ( ( isInt < <NUM_LIT> > ( Val ) ) ) { Result = DAG . getTargetConstant ( Val , DL , Type ) ; break ; } } return ; case 'P' : if ( ConstantSDNode * C = dyn_cast < ConstantSDNode > ( Op ) ) { EVT Type = Op . getValueType ( ) ; int64_t Val = C -> getSExtValue ( ) ; if ( ( Val <= <NUM_LIT> ) && ( Val >= <NUM_LIT> ) ) { Result = DAG . getTargetConstant ( Val , DL , Type ) ; break ; } }


<s> if ( ! MemOpChains . empty ( ) ) Chain = DAG . getNode ( <STR_LIT> , Loc , <STR_LIT> , MemOpChains ) ; SDValue InFlag ; for ( unsigned i = <NUM_LIT> , e = RegsToPass . size ( ) ; i != e ; ++ i ) { Chain = DAG . getCopyToReg ( Chain , Loc , RegsToPass [ i ] . first , RegsToPass [ i ] . second , InFlag ) ; InFlag = Chain . getValue ( <NUM_LIT> ) ; } EVT PtrVT = getPointerTy ( DAG . getDataLayout ( ) ) ; GlobalAddressSDNode * G = dyn_cast < GlobalAddressSDNode > ( Callee ) ; if ( G ) Callee = DAG . getGlobalAddress ( G -> getGlobal ( ) , Loc , PtrVT , <NUM_LIT> ) ; std :: vector < SDValue > 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 uint32_t * Mask ; const TargetRegisterInfo * TRI = DAG . getSubtarget ( ) . getRegisterInfo ( ) ; Mask = TRI -> getCallPreservedMask ( DAG . getMachineFunction ( ) , CallConv ) ;


<s> InFlag = Chain . getValue ( <NUM_LIT> ) ; } EVT PtrVT = getPointerTy ( DAG . getDataLayout ( ) ) ; GlobalAddressSDNode * G = dyn_cast < GlobalAddressSDNode > ( Callee ) ; if ( G ) Callee = DAG . getGlobalAddress ( G -> getGlobal ( ) , Loc , PtrVT , <NUM_LIT> ) ; std :: vector < SDValue > 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 uint32_t * Mask ; const TargetRegisterInfo * TRI = DAG . getSubtarget ( ) . getRegisterInfo ( ) ; Mask = TRI -> getCallPreservedMask ( DAG . getMachineFunction ( ) , CallConv ) ; assert ( Mask && <STR_LIT> ) ; Ops . push_back ( DAG . getRegisterMask ( Mask ) ) ; if ( InFlag . getNode ( ) ) Ops . push_back ( InFlag ) ; SDVTList NodeTys = DAG . getVTList ( <STR_LIT> , <STR_LIT> ) ; Chain = DAG . getNode ( <STR_LIT> , Loc , NodeTys , Ops ) ; InFlag = Chain . getValue ( <NUM_LIT> ) ; Chain = DAG . getCALLSEQ_END ( Chain , DAG . getIntPtrConstant ( NumBytes , Loc , true ) , DAG . getIntPtrConstant ( <NUM_LIT> , Loc , true ) , InFlag , Loc ) ; if ( ! Ins . empty ( ) ) InFlag = Chain . getValue ( <NUM_LIT> ) ;

return LowerCallResult ( Chain , InFlag , CallConv , isVarArg , Ins , Loc , DAG , InVals ) ;


<s> SDValue <ISA_LIT>TargetLowering :: LowerCallResult ( SDValue Chain , SDValue InGlue , CallingConv :: ID CallConv , bool isVarArg , const SmallVectorImpl < <STR_LIT> > & Ins , SDLoc dl , SelectionDAG & DAG , SmallVectorImpl < SDValue > & InVals ) const { SmallVector < CCValAssign , <NUM_LIT> > RVLocs ; CCState CCInfo ( CallConv , isVarArg , DAG . getMachineFunction ( ) , RVLocs , * DAG . getContext ( ) ) ;

AnalyzeReturnValues ( CCInfo , RVLocs , Ins ) ;


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


<s> } for ( unsigned i = <NUM_LIT> , e = ArgLocs . size ( ) ; i != e ; ++ i ) { CCValAssign & VA = ArgLocs [ i ] ; if ( VA . isRegLoc ( ) ) { EVT RegVT = VA . getLocVT ( ) ; switch ( RegVT . getSimpleVT ( ) . SimpleTy ) { default : { errs ( ) << <STR_LIT> << RegVT . getSimpleVT ( ) . SimpleTy << <STR_LIT> ; llvm_unreachable ( nullptr ) ; } case <STR_LIT> : unsigned VReg = RegInfo . createVirtualRegister ( & <STR_LIT> ) ; RegInfo . addLiveIn ( VA . getLocReg ( ) , VReg ) ; SDValue ArgValue = DAG . getCopyFromReg ( Chain , dl , VReg , RegVT ) ; if ( VA . getLocInfo ( ) == CCValAssign :: SExt ) ArgValue = DAG . getNode ( <STR_LIT> , dl , RegVT , ArgValue , DAG . getValueType ( VA . getValVT ( ) ) ) ; else if ( VA . getLocInfo ( ) == CCValAssign :: ZExt ) ArgValue = DAG . getNode ( <STR_LIT> , dl , RegVT , ArgValue , DAG . getValueType ( VA . getValVT ( ) ) ) ; if ( VA . getLocInfo ( ) != CCValAssign :: Full ) ArgValue = DAG . getNode ( <STR_LIT> , dl , VA . getValVT ( ) , ArgValue ) ; InVals . push_back ( ArgValue ) ; } } else { assert ( VA . isMemLoc ( ) ) ; SDValue InVal ; <STR_LIT> Flags = Ins [ i ] . Flags ; if ( Flags . isByVal ( ) ) { int FI = MFI -> CreateFixedObject ( Flags . getByValSize ( ) , VA . getLocMemOffset ( ) , true ) ; InVal = DAG . getFrameIndex ( FI , getPointerTy ( DAG . getDataLayout ( ) ) ) ; }


<s> EVT VT = Op . getValueType ( ) ; SDValue TargetAddr = DAG . getTargetGlobalAddress ( GlobalAddr -> getGlobal ( ) , Op , <STR_LIT> , <NUM_LIT> , <STR_LIT> ) ; return DAG . getNode ( <STR_LIT> , Op , VT , TargetAddr ) ;


<s> SDValue TargetAddr = DAG . getTargetGlobalAddress ( GlobalAddr -> getGlobal ( ) , Op , <STR_LIT> , <NUM_LIT> , <STR_LIT> ) ; return DAG . getNode ( <STR_LIT> , Op , VT , TargetAddr ) ;


<s> switch ( Op . getOpcode ( ) ) { default : llvm_unreachable ( <STR_LIT> ) ; case <STR_LIT> : return LowerGlobalAddress ( Op , DAG ) ;


<s> 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> , e = RVLocs . size ( ) ; i < e ; ++ i ) { CCValAssign & VA = RVLocs [ i ] ; assert ( VA . isRegLoc ( ) && <STR_LIT> ) ; Chain = DAG . getCopyToReg ( Chain , dl , VA . getLocReg ( ) , OutVals [ i ] , Flag ) ;


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


<s> SDValue Flag = <ISA_LIT>_EmitCMP ( LHS , RHS , TargetCC , CC , dl , DAG ) ; SDVTList VTs = DAG . getVTList ( Op . getValueType ( ) , <STR_LIT> ) ; SDValue Ops [ ] = { TrueV , FalseV , TargetCC , Flag } ;

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


<s> SDValue FI = DAG . getFrameIndex ( FuncInfo -> getVarArgsFrameIndex ( ) , getPointerTy ( MF . getDataLayout ( ) ) ) ; const Value * SV = cast < SrcValueSDNode > ( Op . getOperand ( <NUM_LIT> ) ) -> getValue ( ) ; return DAG . getStore ( Op . getOperand ( <NUM_LIT> ) , SDLoc ( Op ) , FI , Op . getOperand ( <NUM_LIT> ) , MachinePointerInfo ( SV ) , false , false , <NUM_LIT> ) ;


<s> MachineFunction & MF = DAG . getMachineFunction ( ) ; <ISA_LIT>MachineFunctionInfo * FuncInfo = MF . getInfo < <ISA_LIT>MachineFunctionInfo > ( ) ; SDValue FI = DAG . getFrameIndex ( FuncInfo -> getVarArgsFrameIndex ( ) , getPointerTy ( MF . getDataLayout ( ) ) ) ; const Value * SV = cast < SrcValueSDNode > ( Op . getOperand ( <NUM_LIT> ) ) -> getValue ( ) ; return DAG . getStore ( Op . getOperand ( <NUM_LIT> ) , SDLoc ( Op ) , FI , Op . getOperand ( <NUM_LIT> ) , MachinePointerInfo ( SV ) , false , false , <NUM_LIT> ) ;


<s> StringRef :: const_iterator I , B = C . begin ( ) + <NUM_LIT> , E = C . end ( ) - <NUM_LIT> ; I = std :: find_if ( B , E , std :: ptr_fun ( isdigit ) ) ;


<s> assert ( Prefix == <STR_LIT> ) ; RC = getRegClassFor ( ( VT == <STR_LIT> ) ? <STR_LIT> : VT ) ; assert ( Reg < RC -> getNumRegs ( ) ) ;

return std :: make_pair ( * ( RC -> begin ( ) + Reg ) , RC ) ;


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


<s> explicit <ISA_LIT>MachineFunctionInfo ( MachineFunction & MF ) : CalleeSavedFrameSize ( <NUM_LIT> ) , ReturnAddrIndex ( <NUM_LIT> ) {


<s> int getRAIndex ( ) const { return ReturnAddrIndex ;


<s> void setRAIndex ( int Index ) { ReturnAddrIndex = Index ;


<s> void setVarArgsFrameIndex ( int Index ) { VarArgsFrameIndex = Index ;


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


<s> MCCodeEmitter * llvm :: create<ISA_LIT>MCCodeEmitter ( const MCInstrInfo & MCII , const MCRegisterInfo & MRI , MCContext & Ctx ) { return new <ISA_LIT>MCCodeEmitter ( MCII , Ctx ) ;


<s> return new <ISA_LIT>MCCodeEmitter ( MCII , Ctx ) ;


<s> unsigned Shift = ( Size - <NUM_LIT> - i ) * <NUM_LIT> ; EmitByte ( ( Val >> Shift ) & <NUM_LIT> , OS ) ; }


<s> llvm_unreachable ( <STR_LIT> ) ; } const uint32_t Binary = getBinaryCodeForInstr ( MI , Fixups , STI ) ; EmitConstant ( Binary , Desc . getSize ( ) , OS ) ; ++ MCNumEmitted ;


<s> if ( Desc . getSize ( ) != <NUM_LIT> ) { llvm_unreachable ( <STR_LIT> ) ; } const uint32_t Binary = getBinaryCodeForInstr ( MI , Fixups , STI ) ;

EmitConstant ( Binary , Desc . getSize ( ) , OS ) ;


<s> <ISA_LIT>MCCodeEmitter ( const MCInstrInfo & mcii , MCContext & ctx ) : MCII ( mcii ) , CTX ( ctx ) {


<s> if ( MO . isImm ( ) ) return MO . getImm ( ) ; assert ( MO . isExpr ( ) && <STR_LIT> ) ; const MCExpr * Expr = MO . getExpr ( ) ; Fixups . push_back ( MCFixup :: create ( <NUM_LIT> , Expr , MCFixupKind ( <STR_LIT> ) ) ) ; return <NUM_LIT> ;


<s> const MCOperand & MO = MI . getOperand ( OpIdx ) ; if ( MO . isImm ( ) ) return MO . getImm ( ) ; assert ( MO . isExpr ( ) && <STR_LIT> ) ;

const MCExpr * Expr = MO . getExpr ( ) ;


<s> unsigned <ISA_LIT>MCCodeEmitter :: getBranch26TargetOpValue ( const MCInst & MI , unsigned OpIdx , SmallVectorImpl < MCFixup > & Fixups , const MCSubtargetInfo & STI ) const { const MCOperand & MO = MI . getOperand ( OpIdx ) ; if ( MO . isImm ( ) ) return MO . getImm ( ) ; assert ( MO . isExpr ( ) && <STR_LIT> ) ;


<s> const MCOperand & ImmMO = MI . getOperand ( OpIdx + <NUM_LIT> ) ; assert ( ImmMO . getImm ( ) >= <NUM_LIT> ) ; Bits |= ( getMachineOpValue ( MI , RegMO , Fixups , STI ) << <NUM_LIT> ) ;

Bits |= ( unsigned ) ImmMO . getImm ( ) & <NUM_LIT> ;


<s> <ISA_LIT>MCInstLower :: <ISA_LIT>MCInstLower ( class AsmPrinter & asmprinter ) : Printer ( asmprinter ) {


<s> void <ISA_LIT>MCInstLower :: Initialize ( Mangler * M , MCContext * C ) { Mang = M ; Ctx = C ;


<s> OutMI . setOpcode ( MI -> getOpcode ( ) ) ; for ( auto & MO : MI -> operands ( ) ) { const MCOperand MCOp = LowerOperand ( MO ) ; if ( MCOp . isValid ( ) ) OutMI . addOperand ( MCOp ) ; }


<s> case MachineOperand :: MO_Immediate : return MCOperand :: createImm ( MO . getImm ( ) + offset ) ; case MachineOperand :: MO_MachineBasicBlock : case MachineOperand :: MO_GlobalAddress : case MachineOperand :: MO_ExternalSymbol : case MachineOperand :: MO_JumpTableIndex : case MachineOperand :: MO_ConstantPoolIndex : case MachineOperand :: MO_BlockAddress : return LowerSymbolOperand ( MO , MOTy , offset ) ; case MachineOperand :: MO_RegisterMask : break ; }


<s> Offset += MO . getOffset ( ) ; break ; case MachineOperand :: MO_ExternalSymbol : Symbol = Printer . GetExternalSymbolSymbol ( MO . getSymbolName ( ) ) ; Offset += MO . getOffset ( ) ; break ; case MachineOperand :: MO_JumpTableIndex : Symbol = Printer . GetJTISymbol ( MO . getIndex ( ) ) ; break ; case MachineOperand :: MO_ConstantPoolIndex : Symbol = Printer . GetCPISymbol ( MO . getIndex ( ) ) ; Offset += MO . getOffset ( ) ; break ; default : llvm_unreachable ( <STR_LIT> ) ; } const unsigned Option = MO . getTargetFlags ( ) & <STR_LIT> ; MCSymbolRefExpr :: VariantKind Kind = MCSymbolRefExpr :: VK_None ; switch ( Option ) { default : break ; case <STR_LIT> : Kind = MCSymbolRefExpr :: VK_<ISA_LIT>_Q1 ; break ; case <STR_LIT> : Kind = MCSymbolRefExpr :: VK_<ISA_LIT>_Q2 ; break ; case <STR_LIT> : Kind = MCSymbolRefExpr :: VK_<ISA_LIT>_Q3 ; break ; case <STR_LIT> : Kind = MCSymbolRefExpr :: VK_<ISA_LIT>_Q4 ; break ; case <STR_LIT> : Kind = MCSymbolRefExpr :: VK_<ISA_LIT>_CALL26 ; break ; case <STR_LIT> : Kind = MCSymbolRefExpr :: VK_<ISA_LIT>_CALL19 ; break ; case <STR_LIT> : Kind = MCSymbolRefExpr :: VK_<ISA_LIT>_9BIT ; break ; case <STR_LIT> : Kind = MCSymbolRefExpr :: VK_<ISA_LIT>_6BIT ; break ; case <STR_LIT> : Kind = MCSymbolRefExpr :: VK_<ISA_LIT>_12BIT ;


<s> static MCAsmInfo * create<ISA_LIT>MCAsmInfo ( const MCRegisterInfo & MRI , const Triple & TT ) {


<s> static MCCodeGenInfo * create<ISA_LIT>MCCodeGenInfo ( const Triple & TT , Reloc :: Model RM , CodeModel :: Model CM , CodeGenOpt :: Level OL ) { MCCodeGenInfo * X = new MCCodeGenInfo ( ) ; if ( RM == Reloc :: Default ) RM = Reloc :: Static ; if ( CM == CodeModel :: Default ) CM = CodeModel :: Small ; if ( CM != CodeModel :: Small && CM != CodeModel :: Large ) {


<s> static MCInstPrinter * create<ISA_LIT>MCInstPrinter ( const Triple & TT , unsigned SyntaxVariant , const MCAsmInfo & MAI , const MCInstrInfo & MII , const MCRegisterInfo & MRI ) { return new <ISA_LIT>InstPrinter ( MAI , MII , MRI ) ;


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


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

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


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


<s> TargetRegistry :: RegisterMCInstrInfo ( The<ISA_LIT>Target , create<ISA_LIT>MCInstrInfo ) ; TargetRegistry :: RegisterMCRegInfo ( The<ISA_LIT>Target , create<ISA_LIT>MCRegisterInfo ) ; TargetRegistry :: RegisterMCSubtargetInfo ( The<ISA_LIT>Target , create<ISA_LIT>MCSubtargetInfo ) ;

TargetRegistry :: RegisterMCInstPrinter ( The<ISA_LIT>Target , create<ISA_LIT>MCInstPrinter ) ;


<s> unsigned ImmOpIdx = <NUM_LIT> ; switch ( MI . getOpcode ( ) ) { default : return ; 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> : 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> : case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : ImmOpIdx = FIOperandNum + <NUM_LIT> ; break ;


<s> <ISA_LIT>RegisterInfo :: <ISA_LIT>RegisterInfo ( ) : <ISA_LIT>GenRegisterInfo ( <STR_LIT> ) {


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


<s> const uint32_t * <ISA_LIT>RegisterInfo :: getCallPreservedMask ( const MachineFunction & MF , CallingConv :: ID ) const {


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


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


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


<s> bool <ISA_LIT>RegisterInfo :: requiresRegisterScavenging ( const MachineFunction & MF ) const { return true ;


<s> bool <ISA_LIT>RegisterInfo :: trackLivenessAfterRegAlloc ( const MachineFunction & MF ) const { return true ;


<s> bool <ISA_LIT>RegisterInfo :: trackLivenessAfterRegAlloc ( const MachineFunction & MF ) const {


<s> bool <ISA_LIT>RegisterInfo :: useFPForScavengingIndex ( const MachineFunction & MF ) const { return false ;


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


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


<s> <ISA_LIT>Subtarget :: <ISA_LIT>Subtarget ( const Triple & TT , StringRef CPU , StringRef FS , <ISA_LIT>TargetMachine & TM ) : <ISA_LIT>GenSubtargetInfo ( TT , CPU , FS ) , DL ( <STR_LIT> ) , InstrInfo ( ) , TLInfo ( TM ) , TSInfo ( ) , FrameLowering ( ) {

InstrItins = getInstrItineraryForCPU ( CPU ) ;


<s> const <ISA_LIT>FrameLowering * getFrameLowering ( ) const override { return & FrameLowering ;


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


<s> const InstrItineraryData * getInstrItineraryData ( ) const override {


<s> const <ISA_LIT>RegisterInfo * getRegisterInfo ( ) const override { return & InstrInfo . getRegisterInfo ( ) ;


<s> RegisterTarget < Triple :: fisc > X ( The<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>DelaySlotFillerPass ( get<ISA_LIT>TargetMachine ( ) ) ) ;


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


<s> TargetPassConfig * <ISA_LIT>TargetMachine :: createPassConfig ( PassManagerBase & PM ) { return new <ISA_LIT>PassConfig ( this , PM ) ;


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


<s> <ISA_LIT>TargetMachine :: <ISA_LIT>TargetMachine ( const Target & T , const Triple & TT , StringRef CPU , StringRef FS , const TargetOptions & Options , Reloc :: Model RM , CodeModel :: Model CM , CodeGenOpt :: Level OL ) : LLVMTargetMachine ( T , computeDataLayout ( TT , CPU , Options ) , TT , CPU , FS , Options , RM , CM , OL ) , Subtarget ( TT , CPU , FS , * this ) , TLOF ( make_unique < TargetLoweringObjectFileELF > ( ) ) {


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


<s> virtual const TargetSubtargetInfo * getSubtargetImpl ( const Function & ) const override {


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

RegisterTargetMachine < <ISA_LIT>TargetMachine > X ( The<ISA_LIT>Target ) ;


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