<s> <ISA_LIT>AsmBackend ( uint8_t OSABI ) : MCAsmBackend ( <STR_LIT> ) , OSABI ( OSABI ) {


<s> uint8_t OSABI = MCELFObjectTargetWriter :: getOSABI ( Triple :: UnknownOS ) ;

return new <ISA_LIT>AsmBackend ( OSABI ) ;


<s> std :: unique_ptr < MCObjectTargetWriter > <ISA_LIT>AsmBackend :: createObjectTargetWriter ( ) const { return create<ISA_LIT>ELFObjectWriter ( OSABI ) ;


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


<s> unsigned getMinimumNopSize ( ) const override { return <NUM_LIT> ;


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


<s> bool mayNeedRelaxation ( const MCInst & Inst , const MCSubtargetInfo & STI ) const override { return false ;


<s> for ( uint64_t i = <NUM_LIT> ; i < NopCount ; i ++ ) <ISA_LIT>MCCodeEmitter :: emitBitsWithParity ( OS , <NUM_LIT> ) ; return true ;


<s> ~ <ISA_LIT>AsmBackend ( ) override {


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


<s> Kind = o . Kind ; StartLoc = o . StartLoc ; EndLoc = o . EndLoc ; switch ( Kind ) { case Immediate : Imm = o . Imm ; break ;


<s> EndLoc = o . EndLoc ; switch ( Kind ) { case Immediate : Imm = o . Imm ;


<s> unsigned <ISA_LIT>AsmParser :: checkEarlyTargetMatchPredicate ( MCInst & Inst , const OperandVector & Operands ) { unsigned Opcode = Inst . getOpcode ( ) ; if ( Opcode == <STR_LIT> ) { ParsedExtend = true ; return Match_IgnoredExtend ; } bool InstIsExtracode = MII . get ( Opcode ) . TSFlags & <STR_LIT> ;

if ( ! ParsingExtracode ) return InstIsExtracode ? Match_ExtracodeFail : Match_Success ;


<s> Op -> Imm . Val = Val ; Op -> StartLoc = S ; Op -> EndLoc = E ;


<s> Op -> StartLoc = S ; Op -> EndLoc = S ; return Op ;


<s> int64_t getConstantImm ( ) const { uint64_t Val = static_cast < const MCConstantExpr * > ( getImm ( ) ) -> getValue ( ) ; return Val ;


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


<s> SMLoc getStartLoc ( ) const override {


<s> assert ( Kind == Token && <STR_LIT> ) ; return Tok ;


<s> return ( isConstantImm ( ) && isUInt < <NUM_LIT> > ( getConstantImm ( ) ) ) || isSymbolRef ( ) ;


<s> bool isAddress12 ( ) const { return ( isConstantImm ( ) && isUInt < <NUM_LIT> > ( getConstantImm ( ) ) ) || isSymbolRef ( ) ;


return isConstantImm ( ) && getConstantImm ( ) < <NUM_LIT> ;


<s> return isConstantImm ( ) && getConstantImm ( ) < <NUM_LIT> ;


<s> bool isBlock2 ( ) const { if ( ! isConstantImm ( ) ) return false ;


return isImm ( ) && getImm ( ) -> getKind ( ) == MCExpr :: Constant ;


<s> bool isMem ( ) const override { return false ;


<s> bool isMem12 ( ) const { return ( isConstantImm ( ) && isUInt < <NUM_LIT> > ( getConstantImm ( ) ) ) || isSymbolRef ( ) ;


<s> RegisterMCAsmParser < <ISA_LIT>AsmParser > X ( getThe<ISA_LIT>Target ( ) ) ;


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


<s> switch ( MatchInstructionImpl ( Operands , Inst , ErrorInfo , MatchingInlineAsm ) ) { default : llvm_unreachable ( <STR_LIT> ) ; case Match_IgnoredExtend : return false ; case Match_Success : Inst . setLoc ( IDLoc ) ; Out . EmitInstruction ( Inst , getSTI ( ) ) ; return false ; case Match_MnemonicFail : return Error ( IDLoc , <STR_LIT> ) ; case Match_ExtracodeFail : return Error ( IDLoc , <STR_LIT> ) ; case Match_NonExtracodeFail : return Error ( IDLoc , <STR_LIT> ) ; case Match_InvalidOperand : { SMLoc ErrorLoc = IDLoc ; if ( ErrorInfo != ~ <NUM_LIT> ) { if ( ErrorInfo >= Operands . size ( ) ) return Error ( ErrorLoc , <STR_LIT> ) ; ErrorLoc = Operands [ ErrorInfo ] -> getStartLoc ( ) ;

if ( ErrorLoc == SMLoc ( ) ) ErrorLoc = IDLoc ;


<s> bool <ISA_LIT>AsmParser :: ParseDirective ( AsmToken DirectiveID ) {


<s> bool <ISA_LIT>AsmParser :: ParseDirective ( AsmToken DirectiveID ) { return true ;


<s> default : return MatchOperand_NoMatch ; case AsmToken :: Minus : case AsmToken :: Plus : case AsmToken :: Integer : case AsmToken :: Identifier : break ; } const MCExpr * IdVal ; SMLoc StartLoc = getLoc ( ) ; if ( getParser ( ) . parseExpression ( IdVal ) ) return MatchOperand_ParseFail ; if ( auto * CE = dyn_cast < MCConstantExpr > ( IdVal ) ) { if ( StartLoc . getPointer ( ) [ <NUM_LIT> ] != '0' ) {


<s> bool <ISA_LIT>AsmParser :: ParseInstruction ( ParseInstructionInfo & Info , StringRef Name , SMLoc NameLoc , OperandVector & Operands ) { ParsingExtracode = ParsedExtend ; ParsedExtend = false ; Operands . push_back ( <STR_LIT> ( Name , NameLoc ) ) ;

if ( getLexer ( ) . is ( AsmToken :: EndOfStatement ) ) return false ;


<s> return Error ( StartLoc , <STR_LIT> ) ;


<s> bool <ISA_LIT>AsmParser :: ParseRegister ( unsigned & RegNo , SMLoc & StartLoc , SMLoc & EndLoc ) {


<s> case Immediate : OS << * getImm ( ) ; break ; case Token : OS << <STR_LIT> << getToken ( ) << <STR_LIT> ; break ;


<s> case Token : OS << <STR_LIT> << getToken ( ) << <STR_LIT> ;


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


<s> Lower<ISA_LIT>MachineInstrToMCInst ( MI , TmpInst ) ;

EmitToStreamer ( * OutStreamer , TmpInst ) ;


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


<s> StringRef getPassName ( ) const override {


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


<s> <ISA_LIT>Disassembler ( const MCSubtargetInfo & STI , MCContext & Ctx ) : MCDisassembler ( STI , Ctx ) {


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

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


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

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


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


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


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


<s> Inst . addOperand ( MCOperand :: createImm ( Imm ) ) ;


<s> assert ( isUInt < <NUM_LIT> > ( Imm ) && <STR_LIT> ) ;

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


<s> assert ( isUInt < <NUM_LIT> > ( Imm ) && <STR_LIT> ) ; Inst . addOperand ( MCOperand :: createImm ( Imm ) ) ; return MCDisassembler :: Success ;


<s> if ( MI . getOpcode ( ) != <STR_LIT> ) { Size = <NUM_LIT> ; return Result ; } Instruction = <STR_LIT> :: read16be ( Bytes . drop_front ( <NUM_LIT> ) . data ( ) ) ; Instruction = ( Instruction & <NUM_LIT> ) >> <NUM_LIT> ;

Result = decodeInstruction ( DecoderTableExtracode16 , MI , Instruction , Address , this , STI ) ;


<s> void LLVMInitialize<ISA_LIT>Disassembler ( ) { TargetRegistry :: RegisterMCDisassembler ( getThe<ISA_LIT>Target ( ) , create<ISA_LIT>Disassembler ) ;


<s> <ISA_LIT>ExpandPseudo ( ) : MachineFunctionPass ( ID ) { initialize<ISA_LIT>ExpandPseudoPass ( * PassRegistry :: getPassRegistry ( ) ) ;


<s> while ( MBBI != E ) { MachineBasicBlock :: iterator NMBBI = std :: next ( MBBI ) ; Modified |= expandMI ( MBB , MBBI , NMBBI ) ; MBBI = NMBBI ;


<s> while ( MBBI != E ) { MachineBasicBlock :: iterator NMBBI = std :: next ( MBBI ) ; Modified |= expandMI ( MBB , MBBI , NMBBI ) ; MBBI = NMBBI ; } return Modified ;


<s> bool <ISA_LIT>ExpandPseudo :: expandMI ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MBBI , MachineBasicBlock :: iterator & NextMBBI ) { switch ( MBBI -> getOpcode ( ) ) { default : break ; case <STR_LIT> : return expandPseudoCONST ( MBB , MBBI , NextMBBI ) ; } return false ;


<s> unsigned DestReg = MI . getOperand ( <NUM_LIT> ) . getReg ( ) ; int64_t Constant = MI . getOperand ( <NUM_LIT> ) . getImm ( ) ; if ( ! to<ISA_LIT>Constant ( Constant ) ) report_fatal_error ( <STR_LIT> ) ; MachineBasicBlock * NewMBB = MF -> CreateMachineBasicBlock ( MBB . getBasicBlock ( ) ) ; MF -> insert ( ++ MBB . getIterator ( ) , NewMBB ) ; BuildMI ( NewMBB , DL , TII -> get ( <STR_LIT> ) ) . addReg ( DestReg ) ; BuildMI ( NewMBB , DL , TII -> get ( <STR_LIT> ) ) . addImm ( Constant ) ; const TargetMachine & TM = MF -> getTarget ( ) ; StringRef SectionName = ( ( MCSectionELF * ) TM . getObjFileLowering ( ) -> SectionForGlobal ( & MF -> getFunction ( ) , TM ) ) -> getSectionName ( ) ; BuildMI ( NewMBB , DL , TII -> get ( <STR_LIT> ) ) . addImm ( toBankNumber ( SectionName ) ) ; NewMBB -> splice ( NewMBB -> end ( ) , & MBB , std :: next ( MBBI ) , MBB . end ( ) ) ; NewMBB -> transferSuccessorsAndUpdatePHIs ( & MBB ) ; MBB . addSuccessor ( NewMBB ) ; LivePhysRegs LiveRegs ; computeAndAddLiveIns ( LiveRegs , * NewMBB ) ;


<s> StringRef getPassName ( ) const override {


<s> TII = static_cast < const <ISA_LIT>InstrInfo * > ( MF . getSubtarget ( ) . getInstrInfo ( ) ) ; bool Modified = false ;

for ( auto & MBB : MF ) Modified |= expandMBB ( MBB ) ;


<s> TII = static_cast < const <ISA_LIT>InstrInfo * > ( MF . getSubtarget ( ) . getInstrInfo ( ) ) ;


<s> int64_t Result = std :: stoi ( Input . str ( ) , & Idx , <NUM_LIT> ) ; if ( Idx < Input . size ( ) - <NUM_LIT> ) report_fatal_error ( <STR_LIT> ) ; return Result ;


<s> int64_t Result = std :: stoi ( Input . str ( ) , & Idx , <NUM_LIT> ) ;

if ( Idx < Input . size ( ) - <NUM_LIT> ) report_fatal_error ( <STR_LIT> ) ;


<s> static bool to<ISA_LIT>Constant ( int64_t & Constant ) { constexpr int64_t MAX_VAL = ( <NUM_LIT> << <NUM_LIT> ) - <NUM_LIT> ;

if ( Constant > MAX_VAL ) return false ;


<s> if ( Constant > MAX_VAL ) return false ; if ( Constant < - MAX_VAL ) return false ; if ( Constant < <NUM_LIT> ) Constant = ( Constant - <NUM_LIT> ) & <NUM_LIT> ;


<s> int64_t BlockNumber = strtoi ( SectionName . drop_front ( <NUM_LIT> ) ) ; if ( BlockNumber == <NUM_LIT> || BlockNumber == <NUM_LIT> ) return BlockNumber ; }


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


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


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


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


<s> uint64_t Pow = <NUM_LIT> ; uint64_t Octal = <NUM_LIT> ; for ( unsigned i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { if ( Val == <NUM_LIT> ) break ; Octal += ( Val % <NUM_LIT> ) * Pow ; Val /= <NUM_LIT> ; Pow *= <NUM_LIT> ;


<s> if ( MO . isImm ( ) ) { uint64_t Val = MO . getImm ( ) ; uint64_t Pow = <NUM_LIT> ; uint64_t Octal = <NUM_LIT> ; for ( unsigned i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { if ( Val == <NUM_LIT> ) break ;


<s> <ISA_LIT>InstrInfo :: <ISA_LIT>InstrInfo ( ) : <ISA_LIT>GenInstrInfo ( ) {


<s> if ( SrcReg == DestReg ) return ; if ( DestReg == <STR_LIT> ) { assert ( <STR_LIT> . contains ( SrcReg ) && <STR_LIT> ) ; BuildMI ( MBB , MI , DL , get ( <STR_LIT> ) , DestReg ) . addReg ( SrcReg , RegState :: Define ) . addReg ( SrcReg , getKillRegState ( KillSrc ) ) ; return ; } assert ( <STR_LIT> . contains ( DestReg ) && <STR_LIT> ) ; if ( SrcReg != <STR_LIT> ) { assert ( <STR_LIT> . contains ( SrcReg ) && <STR_LIT> ) ; BuildMI ( MBB , MI , DL , get ( <STR_LIT> ) , DestReg ) . addReg ( SrcReg , RegState :: Define ) . addReg ( SrcReg , getKillRegState ( KillSrc ) ) ; KillSrc = true ; }


<s> if ( DestReg == <STR_LIT> ) { assert ( <STR_LIT> . contains ( SrcReg ) && <STR_LIT> ) ; BuildMI ( MBB , MI , DL , get ( <STR_LIT> ) , DestReg ) . addReg ( SrcReg , RegState :: Define ) . addReg ( SrcReg , getKillRegState ( KillSrc ) ) ; return ; } assert ( <STR_LIT> . contains ( DestReg ) && <STR_LIT> ) ; if ( SrcReg != <STR_LIT> ) { assert ( <STR_LIT> . contains ( SrcReg ) && <STR_LIT> ) ;


<s> explicit <ISA_LIT>DAGToDAGISel ( <ISA_LIT>TargetMachine & TM ) : SelectionDAGISel ( TM ) {


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


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


<s> break ; case <STR_LIT> : { Select<ISA_LIT>Constant ( Node ) ; return ; } } for ( auto & Op : Node -> ops ( ) ) { switch ( Op . getNode ( ) -> getOpcode ( ) ) { default :


<s> assert ( Node -> getValueType ( <NUM_LIT> ) == <STR_LIT> && <STR_LIT> ) ; SDLoc DL ( Node ) ; int64_t ConstImm = cast < ConstantSDNode > ( Node ) -> getSExtValue ( ) ; SDValue ConstValue = CurDAG -> getTargetConstant ( ConstImm , DL , <STR_LIT> ) ; SDNode * New = CurDAG -> getMachineNode ( <STR_LIT> , DL , <STR_LIT> , ConstValue ) ;


<s> <ISA_LIT>TargetLowering :: <ISA_LIT>TargetLowering ( const TargetMachine & TM , const <ISA_LIT>Subtarget & STI ) : TargetLowering ( TM ) , Subtarget ( STI ) { addRegisterClass ( <STR_LIT> , & <STR_LIT> ) ;


<s> switch ( ( <STR_LIT> ) Opcode ) { default : break ; case <STR_LIT> : return <STR_LIT> ; }


<s> default : report_fatal_error ( <STR_LIT> ) ; case CallingConv :: C : break ; } MachineFunction & MF = DAG . getMachineFunction ( ) ; MachineRegisterInfo & RegInfo = MF . getRegInfo ( ) ; if ( IsVarArg ) report_fatal_error ( <STR_LIT> ) ; SmallVector < CCValAssign , <NUM_LIT> > ArgLocs ; CCState CCInfo ( CallConv , IsVarArg , MF , ArgLocs , * DAG . getContext ( ) ) ; CCInfo . AnalyzeFormalArguments ( Ins , CC_<ISA_LIT> ) ; for ( auto & VA : ArgLocs ) { if ( ! VA . isRegLoc ( ) ) report_fatal_error ( <STR_LIT> ) ; EVT RegVT = VA . getLocVT ( ) ;

if ( RegVT != <STR_LIT> && RegVT != <STR_LIT> ) {


<s> SDValue <ISA_LIT>TargetLowering :: LowerMUL ( SDValue Op , SelectionDAG & DAG ) const { assert ( Op . getValueType ( ) == <STR_LIT> && <STR_LIT> ) ; if ( Op . getOperand ( <NUM_LIT> ) . getOpcode ( ) != <STR_LIT> || Op . getOperand ( <NUM_LIT> ) . getOpcode ( ) != <STR_LIT> ) report_fatal_error ( <STR_LIT> ) ;

SDValue Arg0 = Op . getOperand ( <NUM_LIT> ) . getOperand ( <NUM_LIT> ) ;


<s> SDValue Arg0 = Op . getOperand ( <NUM_LIT> ) . getOperand ( <NUM_LIT> ) ; SDValue Arg1 = Op . getOperand ( <NUM_LIT> ) . getOperand ( <NUM_LIT> ) ;

if ( Arg0 . getValueType ( ) != <STR_LIT> || Arg1 . getValueType ( ) != <STR_LIT> ) report_fatal_error ( <STR_LIT> ) ;


<s> case <STR_LIT> : return LowerMUL ( Op , DAG ) ; case <STR_LIT> : return LowerSDIV ( Op , DAG ) ; case <STR_LIT> : return LowerSREM ( Op , DAG ) ; }


<s> return LowerMUL ( Op , DAG ) ; case <STR_LIT> : return LowerSDIV ( Op , DAG ) ; case <STR_LIT> : return LowerSREM ( Op , DAG ) ; }


<s> if ( VA . getValNo ( ) == <NUM_LIT> ) { ArgOut = DAG . getRegister ( VA . getLocReg ( ) , VA . getLocVT ( ) ) ; } else if ( VA . getValNo ( ) == <NUM_LIT> ) { ArgOut = DAG . getRegister ( VA . getLocReg ( ) , VA . getLocVT ( ) ) ; } else report_fatal_error ( <STR_LIT> ) ; RetOps . push_back ( DAG . getRegister ( VA . getLocReg ( ) , VA . getLocVT ( ) ) ) ; } RetOps [ <NUM_LIT> ] = Chain ; if ( Flag . getNode ( ) ) RetOps . push_back ( Flag ) ;

return DAG . getNode ( <STR_LIT> , DL , <STR_LIT> , RetOps ) ;


<s> 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 ) ; Flag = Chain . getValue ( <NUM_LIT> ) ; SDValue ArgOut ; if ( VA . getValNo ( ) == <NUM_LIT> ) { ArgOut = DAG . getRegister ( VA . getLocReg ( ) , VA . getLocVT ( ) ) ; } else if ( VA . getValNo ( ) == <NUM_LIT> ) { ArgOut = DAG . getRegister ( VA . getLocReg ( ) , VA . getLocVT ( ) ) ; } else report_fatal_error ( <STR_LIT> ) ; RetOps . push_back ( DAG . getRegister ( VA . getLocReg ( ) , VA . getLocVT ( ) ) ) ; } RetOps [ <NUM_LIT> ] = Chain ;

if ( Flag . getNode ( ) ) RetOps . push_back ( Flag ) ;


<s> assert ( Op . getValueType ( ) == <STR_LIT> && <STR_LIT> ) ; if ( Op . getOperand ( <NUM_LIT> ) . getOpcode ( ) != <STR_LIT> ) report_fatal_error ( <STR_LIT> ) ; SDValue Denominator = Op . getOperand ( <NUM_LIT> ) . getOperand ( <NUM_LIT> ) ; if ( Denominator . getValueType ( ) != <STR_LIT> ) report_fatal_error ( <STR_LIT> ) ; SDValue Div = SDValue ( DAG . getMachineNode ( <STR_LIT> , SDLoc ( Op ) , <STR_LIT> , <STR_LIT> , Op . getOperand ( <NUM_LIT> ) , Denominator ) , <NUM_LIT> ) ; return DAG . getNode ( <STR_LIT> , SDLoc ( Op ) , <STR_LIT> , Div ) ;


<s> if ( Denominator . getValueType ( ) != <STR_LIT> ) report_fatal_error ( <STR_LIT> ) ; SDValue Div = SDValue ( DAG . getMachineNode ( <STR_LIT> , SDLoc ( Op ) , <STR_LIT> , <STR_LIT> , Op . getOperand ( <NUM_LIT> ) , Denominator ) , <NUM_LIT> ) ;

return DAG . getNode ( <STR_LIT> , SDLoc ( Op ) , <STR_LIT> , Div ) ;


<s> switch ( N -> getOpcode ( ) ) { default :

SDValue Res = LowerOperation ( SDValue ( N , <NUM_LIT> ) , DAG ) ;


<s> for ( unsigned I = <NUM_LIT> , E = Res -> getNumValues ( ) ; I != E ; ++ I ) Results . push_back ( Res . getValue ( I ) ) ; break ;


<s> CodePointerSize = <NUM_LIT> ; MinInstAlignment = <NUM_LIT> ; MaxInstLength = <NUM_LIT> ; IsLittleEndian = false ; CommentString = <STR_LIT> ;


<s> <ISA_LIT>MCAsmInfo :: <ISA_LIT>MCAsmInfo ( const Triple & TT ) { CodePointerSize = <NUM_LIT> ; MinInstAlignment = <NUM_LIT> ; MaxInstLength = <NUM_LIT> ;


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


<s> <ISA_LIT>MCCodeEmitter ( const MCInstrInfo & MCII , MCContext & Ctx ) : MCII ( MCII ) , Ctx ( Ctx ) {


<s> void <ISA_LIT>MCCodeEmitter :: emitBitsWithParity ( raw_ostream & OS , uint16_t Bits ) {

uint16_t Encoding = getEncodingWithParity ( Bits ) ;


<s> if ( MO . isExpr ( ) && MO . getExpr ( ) -> getKind ( ) == MCExpr :: SymbolRef ) return <NUM_LIT> ;


<s> if ( MO . isExpr ( ) && MO . getExpr ( ) -> getKind ( ) == MCExpr :: SymbolRef ) return <NUM_LIT> ; llvm_unreachable ( <STR_LIT> ) ; return <NUM_LIT> ;


<s> static uint16_t getParityBitForEncoding ( uint16_t Enc ) {


<s> ~ <ISA_LIT>MCCodeEmitter ( ) override {


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


<s> return llvm :: make_unique < <ISA_LIT>ELFObjectWriter > ( OSABI ) ;


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


<s> <ISA_LIT>MCELFStreamer :: <ISA_LIT>MCELFStreamer ( MCContext & Context , std :: unique_ptr < MCAsmBackend > TAB , std :: unique_ptr < MCObjectWriter > OW , std :: unique_ptr < MCCodeEmitter > Emitter ) : MCELFStreamer ( Context , std :: move ( TAB ) , std :: move ( OW ) , std :: move ( Emitter ) ) {


<s> return new <ISA_LIT>MCELFStreamer ( Context , std :: move ( MAB ) , std :: move ( OW ) , std :: move ( CE ) ) ;


<s> MCSection * Section = ( ( MCSection * ) getContext ( ) . getELFSection ( SectionName , ELF :: SHT_PROGBITS , ELF :: SHF_EXECINSTR | ELF :: SHF_ALLOC ) ) ; SwitchSection ( Section , nullptr ) ; return ; } case <STR_LIT> : { StringRef SectionName = <STR_LIT> + itostr ( Inst . getOperand ( <NUM_LIT> ) . getImm ( ) ) ; MCSection * Section = ( ( MCSection * ) getContext ( ) . getELFSection ( SectionName , ELF :: SHT_PROGBITS , ELF :: SHF_EXECINSTR | ELF :: SHF_ALLOC ) ) ; SwitchSection ( Section , nullptr ) ;


<s> void <ISA_LIT>MCELFStreamer :: EmitInstruction ( const MCInst & Inst , const MCSubtargetInfo & STI , bool ) { switch ( Inst . getOpcode ( ) ) { default : break ; case <STR_LIT> : { int64_t ImmOp = Inst . getOperand ( <NUM_LIT> ) . getImm ( ) ; StringRef SectionName = ImmOp == <NUM_LIT> ? <STR_LIT> : ( <STR_LIT> + itostr ( ImmOp ) ) ; MCSection * Section = ( ( MCSection * ) getContext ( ) . getELFSection ( SectionName , ELF :: SHT_PROGBITS , ELF :: SHF_EXECINSTR | ELF :: SHF_ALLOC ) ) ; SwitchSection ( Section , nullptr ) ; return ; } case <STR_LIT> : { StringRef SectionName = <STR_LIT> + itostr ( Inst . getOperand ( <NUM_LIT> ) . getImm ( ) ) ; MCSection * Section = ( ( MCSection * ) getContext ( ) . getELFSection ( SectionName , ELF :: SHT_PROGBITS , ELF :: SHF_EXECINSTR | ELF :: SHF_ALLOC ) ) ; SwitchSection ( Section , nullptr ) ; return ; } case <STR_LIT> : {


<s> OutMI . setOpcode ( MI -> getOpcode ( ) ) ; for ( const MachineOperand & MO : MI -> operands ( ) ) { MCOperand MCOp ; if ( Lower<ISA_LIT>MachineOperandToMCOperand ( MO , MCOp ) ) OutMI . addOperand ( MCOp ) ; }


<s> void llvm :: Lower<ISA_LIT>MachineInstrToMCInst ( const MachineInstr * MI , MCInst & OutMI ) { OutMI . setOpcode ( MI -> getOpcode ( ) ) ;

for ( const MachineOperand & MO : MI -> operands ( ) ) {


<s> report_fatal_error ( <STR_LIT> ) ; case MachineOperand :: MO_Register : if ( MO . isImplicit ( ) ) return false ; MCOp = MCOperand :: createImm ( MO . getReg ( ) - <NUM_LIT> ) ; break ; case MachineOperand :: MO_Immediate : MCOp = MCOperand :: createImm ( MO . getImm ( ) ) ;


<s> case MachineOperand :: MO_Register : if ( MO . isImplicit ( ) ) return false ; MCOp = MCOperand :: createImm ( MO . getReg ( ) - <NUM_LIT> ) ; break ; case MachineOperand :: MO_Immediate : MCOp = MCOperand :: createImm ( MO . getImm ( ) ) ; break ; } return true ;


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


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


<s> TargetRegistry :: RegisterMCAsmInfo ( T , create<ISA_LIT>MCAsmInfo ) ; TargetRegistry :: RegisterMCInstrInfo ( T , create<ISA_LIT>MCInstrInfo ) ; TargetRegistry :: RegisterMCRegInfo ( T , create<ISA_LIT>MCRegisterInfo ) ; TargetRegistry :: RegisterMCSubtargetInfo ( T , create<ISA_LIT>MCSubtargetInfoImpl ) ; TargetRegistry :: RegisterELFStreamer ( T , create<ISA_LIT>MCELFStreamer ) ; TargetRegistry :: RegisterMCCodeEmitter ( T , create<ISA_LIT>MCCodeEmitter ) ;

TargetRegistry :: RegisterMCAsmBackend ( T , create<ISA_LIT>AsmBackend ) ;


<s> TargetRegistry :: RegisterELFStreamer ( T , create<ISA_LIT>MCELFStreamer ) ; TargetRegistry :: RegisterMCCodeEmitter ( T , create<ISA_LIT>MCCodeEmitter ) ; TargetRegistry :: RegisterMCAsmBackend ( T , create<ISA_LIT>AsmBackend ) ; TargetRegistry :: RegisterMCInstPrinter ( T , create<ISA_LIT>MCInstPrinter ) ;


<s> <ISA_LIT>RegisterInfo :: <ISA_LIT>RegisterInfo ( unsigned HwMode ) : <ISA_LIT>GenRegisterInfo ( <STR_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , HwMode ) {


<s> void <ISA_LIT>RegisterInfo :: eliminateFrameIndex ( MachineBasicBlock :: iterator II , int SPAdj , unsigned FIOperandNum , RegScavenger * RS ) const {


<s> const MCPhysReg * <ISA_LIT>RegisterInfo :: getCalleeSavedRegs ( const MachineFunction * MF ) const { return CSR_SaveList ;


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


<s> BitVector Reserved ( getNumRegs ( ) ) ; return Reserved ;


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


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


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


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


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


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

RegisterTarget < Triple :: agc > A ( getThe<ISA_LIT>Target ( ) , <STR_LIT> , <STR_LIT> , <STR_LIT> ) ;


<s> bool <ISA_LIT>PassConfig :: addInstSelector ( ) { addPass ( create<ISA_LIT>ISelDag ( get<ISA_LIT>TargetMachine ( ) ) ) ;


<s> bool <ISA_LIT>PassConfig :: addInstSelector ( ) {

addPass ( create<ISA_LIT>ISelDag ( get<ISA_LIT>TargetMachine ( ) ) ) ;


<s> void <ISA_LIT>PassConfig :: addPreEmitPass2 ( ) {

addPass ( create<ISA_LIT>ExpandPseudoPass ( ) ) ;


<s> addPass ( create<ISA_LIT>ExpandPseudoPass ( ) ) ;


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


<s> return getTM < <ISA_LIT>TargetMachine > ( ) ;


<s> <ISA_LIT>TargetMachine & get<ISA_LIT>TargetMachine ( ) const {

return getTM < <ISA_LIT>TargetMachine > ( ) ;


<s> static Reloc :: Model getEffectiveRelocModel ( Optional < Reloc :: Model > RM ) {

if ( ! RM . hasValue ( ) ) return Reloc :: Static ;


<s> if ( ! RM . hasValue ( ) ) return Reloc :: Static ; return * RM ;


<s> TargetLoweringObjectFile * getObjFileLowering ( ) const override {


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


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

RegisterTargetMachine < <ISA_LIT>TargetMachine > A ( getThe<ISA_LIT>Target ( ) ) ;


<s> TextSection = ( MCSection * ) Ctx . getELFSection ( <STR_LIT> , ELF :: SHT_PROGBITS , ELF :: SHF_EXECINSTR | ELF :: SHF_ALLOC ) ;


<s> InitializeELF ( TM . Options . UseInitArray ) ; TextSection = ( MCSection * ) Ctx . getELFSection ( <STR_LIT> , ELF :: SHT_PROGBITS , ELF :: SHF_EXECINSTR | ELF :: SHF_ALLOC ) ;


<s> if ( ! F || F -> hasFnAttribute ( <STR_LIT> ) ) return TargetLoweringObjectFileELF :: SelectSectionForGlobal ( GO , Kind , TM ) ; return TextSection ;


<s> const Function * F = dyn_cast < Function > ( GO ) ; if ( ! F || F -> hasFnAttribute ( <STR_LIT> ) ) return TargetLoweringObjectFileELF :: SelectSectionForGlobal ( GO , Kind , TM ) ; return TextSection ;