<s> case FK_Data_2 : case FK_Data_4 : case FK_Data_8 : return Value ; case <STR_LIT> : { int64_t SVal = ( int64_t ) Value ; if ( SVal < - <NUM_LIT> || SVal > <NUM_LIT> ) Ctx . reportError ( Fixup . getLoc ( ) , <STR_LIT> ) ; if ( Value & <NUM_LIT> ) Ctx . reportError ( Fixup . getLoc ( ) , <STR_LIT> ) ; if ( SVal < <NUM_LIT> ) { Value = ( uint64_t ) ( SVal + <NUM_LIT> ) >> <NUM_LIT> ; Value |= <NUM_LIT> << <NUM_LIT> ; } else { Value = Value >> <NUM_LIT> ; } return Value ; } case <STR_LIT> : { int64_t SVal = ( int64_t ) Value ;


<s> MCContext & Ctx = Asm . getContext ( ) ; MCFixupKind Kind = Fixup . getKind ( ) ; MCFixupKindInfo Info = getFixupKindInfo ( Kind ) ; unsigned Offset = Fixup . getOffset ( ) ; if ( Kind == static_cast < MCFixupKind > ( <STR_LIT> ) || Kind == static_cast < MCFixupKind > ( <STR_LIT> ) ) Data [ Offset ] &= <NUM_LIT> ; Value = adjustFixupValue ( Fixup , Value , Ctx ) ; if ( ! Value ) return ;


<s> MCAsmBackend * llvm :: create<ISA_LIT>AsmBackend ( const Target & T , const MCSubtargetInfo & STI , const MCRegisterInfo & MRI , const MCTargetOptions & Options ) { const Triple & TT = STI . getTargetTriple ( ) ;

uint8_t OSABI = MCELFObjectTargetWriter :: getOSABI ( TT . getOS ( ) ) ;


<s> uint8_t OSABI = MCELFObjectTargetWriter :: getOSABI ( TT . getOS ( ) ) ;

return new <ISA_LIT>AsmBackend ( STI , OSABI ) ;


<s> return create<ISA_LIT>ELFObjectWriter ( 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 { return false ;


<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> , <NUM_LIT> } , { <STR_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> } , { <STR_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> } , { <STR_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> } } ;

if ( Kind < FirstTargetFixupKind ) return MCAsmBackend :: getFixupKindInfo ( Kind ) ;


<s> unsigned getNumFixupKinds ( ) const override {


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


<s> <ISA_LIT>AsmBackend ( const MCSubtargetInfo & STI , uint8_t OSABI ) : MCAsmBackend ( <STR_LIT> ) , STI ( STI ) , OSABI ( OSABI ) {


<s> void relaxInstruction ( const MCInst & Inst , const MCSubtargetInfo & STI , MCInst & Res ) const override { report_fatal_error ( <STR_LIT> ) ;


<s> for ( uint64_t i = <NUM_LIT> ; i < Count ; i += <NUM_LIT> ) OS . write ( <STR_LIT> , <NUM_LIT> ) ;


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


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

else Inst . addOperand ( MCOperand :: createExpr ( Expr ) ) ;


<s> void addExpr ( MCInst & Inst , const MCExpr * Expr ) const { assert ( Expr && <STR_LIT> ) ; if ( auto * 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> ) ; addExpr ( Inst , getImm ( ) ) ;


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

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


<s> auto Op = std :: make_unique < <ISA_LIT>Operand > ( Immediate ) ; Op -> Imm . Val = Val ; Op -> StartLoc = S ;


<s> auto Op = std :: make_unique < <ISA_LIT>Operand > ( Immediate ) ; Op -> Imm . Val = Val ; Op -> StartLoc = S ; Op -> EndLoc = E ;


<s> static std :: unique_ptr < <ISA_LIT>Operand > createReg ( unsigned RegNo , SMLoc S , SMLoc E ) { auto Op = std :: make_unique < <ISA_LIT>Operand > ( Register ) ; Op -> Reg . RegNum = RegNo ;


<s> Op -> Reg . RegNum = RegNo ; Op -> StartLoc = S ; Op -> EndLoc = E ;


<s> static std :: unique_ptr < <ISA_LIT>Operand > createToken ( StringRef Str , SMLoc S ) { auto Op = std :: make_unique < <ISA_LIT>Operand > ( Token ) ; Op -> Tok = Str ;


<s> int64_t getConstantImm ( ) const { const MCExpr * Val = getImm ( ) ;

return static_cast < const MCConstantExpr * > ( Val ) -> getValue ( ) ;


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


<s> SMLoc getEndLoc ( ) const override {


<s> const MCExpr * getImm ( ) const { assert ( Kind == Immediate && <STR_LIT> ) ;


<s> assert ( Kind == Immediate && <STR_LIT> ) ; return Imm . Val ;


return getParser ( ) . getTok ( ) . getLoc ( ) ;


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


<s> SMLoc getStartLoc ( ) const override {


<s> bool isAcceptableSymbolRef ( const MCExpr * Expr ) const { if ( isa < MCConstantExpr > ( Expr ) || isa < MCSymbolRefExpr > ( Expr ) ) return true ; const MCBinaryExpr * BE = dyn_cast < MCBinaryExpr > ( Expr ) ;


<s> if ( BE -> getOpcode ( ) != MCBinaryExpr :: Add && BE -> getOpcode ( ) != MCBinaryExpr :: Sub ) return false ; if ( BE -> getOpcode ( ) == MCBinaryExpr :: Sub && isa < MCSymbolRefExpr > ( BE -> getRHS ( ) ) ) return true ;

auto AddendExpr = dyn_cast < MCConstantExpr > ( BE -> getRHS ( ) ) ;


<s> return isImm ( ) && isAcceptableSymbolRef ( getImm ( ) ) ;


<s> bool isBranchImm24 ( ) const { return isImm ( ) && isAcceptableSymbolRef ( getImm ( ) ) ;


<s> return isImm ( ) && dyn_cast < MCConstantExpr > ( getImm ( ) ) ;


if ( ! isConstantImm ( ) ) return false ;


<s> if ( ! isConstantImm ( ) ) return false ; int64_t imm = getConstantImm ( ) ; return imm >= <NUM_LIT> && imm <= <NUM_LIT> ;


<s> return isUInt < <NUM_LIT> > ( getConstantImm ( ) ) ; } return isImm ( ) && isAcceptableSymbolRef ( getImm ( ) ) ;


<s> bool isLabelImm16 ( ) const { if ( isConstantImm ( ) ) { return isUInt < <NUM_LIT> > ( getConstantImm ( ) ) ; }

return isImm ( ) && isAcceptableSymbolRef ( getImm ( ) ) ;


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


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


<s> bool isWydeL ( ) const { return isLabelImm16 ( ) ;


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

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


<s> default : break ; case Match_Success : Inst . setLoc ( IDLoc ) ; Out . EmitInstruction ( Inst , getSTI ( ) ) ; return false ; case Match_MissingFeature : return Error ( IDLoc , <STR_LIT> ) ; case Match_MnemonicFail : return Error ( IDLoc , <STR_LIT> ) ; case Match_InvalidOperand : ErrorLoc = IDLoc ; if ( ErrorInfo != ~ <NUM_LIT> ) { if ( ErrorInfo >= Operands . size ( ) ) return Error ( ErrorLoc , <STR_LIT> ) ; ErrorLoc = ( ( <ISA_LIT>Operand & ) * Operands [ ErrorInfo ] ) . getStartLoc ( ) ; if ( ErrorLoc == SMLoc ( ) ) ErrorLoc = IDLoc ; } return Error ( ErrorLoc , <STR_LIT> ) ; case Match_InvalidUImm8 : ErrorLoc = ( ( <ISA_LIT>Operand & ) * Operands [ ErrorInfo ] ) . getStartLoc ( ) ; return Error ( ErrorLoc , <STR_LIT> ) ; case Match_InvalidUImm16 : ErrorLoc = ( ( <ISA_LIT>Operand & ) * Operands [ ErrorInfo ] ) . getStartLoc ( ) ; return Error ( ErrorLoc , <STR_LIT> ) ; case Match_InvalidFloatRoundMode : ErrorLoc = ( ( <ISA_LIT>Operand & ) * Operands [ ErrorInfo ] ) . getStartLoc ( ) ; return Error ( ErrorLoc , <STR_LIT> <STR_LIT> ) ; case Match_InvalidWyde : ErrorLoc = ( ( <ISA_LIT>Operand & ) * Operands [ ErrorInfo ] ) . getStartLoc ( ) ; return Error ( ErrorLoc , <STR_LIT> <STR_LIT> ) ; case Match_InvalidBranchImm16 : ErrorLoc = ( ( <ISA_LIT>Operand & ) * Operands [ ErrorInfo ] ) . getStartLoc ( ) ;


<s> case Match_Success : Inst . setLoc ( IDLoc ) ; Out . EmitInstruction ( Inst , getSTI ( ) ) ; return false ; case Match_MissingFeature : return Error ( IDLoc , <STR_LIT> ) ; case Match_MnemonicFail : return Error ( IDLoc , <STR_LIT> ) ; case Match_InvalidOperand : ErrorLoc = IDLoc ; if ( ErrorInfo != ~ <NUM_LIT> ) { if ( ErrorInfo >= Operands . size ( ) ) return Error ( ErrorLoc , <STR_LIT> ) ; ErrorLoc = ( ( <ISA_LIT>Operand & ) * Operands [ ErrorInfo ] ) . getStartLoc ( ) ; if ( ErrorLoc == SMLoc ( ) ) ErrorLoc = IDLoc ; } return Error ( ErrorLoc , <STR_LIT> ) ; case Match_InvalidUImm8 : ErrorLoc = ( ( <ISA_LIT>Operand & ) * Operands [ ErrorInfo ] ) . getStartLoc ( ) ; return Error ( ErrorLoc , <STR_LIT> ) ; case Match_InvalidUImm16 : ErrorLoc = ( ( <ISA_LIT>Operand & ) * Operands [ ErrorInfo ] ) . getStartLoc ( ) ; return Error ( ErrorLoc , <STR_LIT> ) ; case Match_InvalidFloatRoundMode : ErrorLoc = ( ( <ISA_LIT>Operand & ) * Operands [ ErrorInfo ] ) . getStartLoc ( ) ; return Error ( ErrorLoc , <STR_LIT> <STR_LIT> ) ;


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


<s> case Immediate : Imm = o . Imm ; break ; case Token : Tok = o . Tok ; break ; }


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


<s> const MCExpr * Res ; switch ( getLexer ( ) . getKind ( ) ) { default : return MatchOperand_NoMatch ; case AsmToken :: LParen : case AsmToken :: Minus : case AsmToken :: Plus : case AsmToken :: Integer : case AsmToken :: String : case AsmToken :: Identifier :

if ( getParser ( ) . parseExpression ( Res ) ) return MatchOperand_ParseFail ;


<s> OperandMatchResultTy <ISA_LIT>AsmParser :: parseImmediate ( OperandVector & Operands ) { SMLoc S = getLoc ( ) ; SMLoc E = SMLoc :: getFromPointer ( S . getPointer ( ) - <NUM_LIT> ) ; const MCExpr * Res ; switch ( getLexer ( ) . getKind ( ) ) { default :


<s> if ( getLexer ( ) . isNot ( AsmToken :: EndOfStatement ) ) { SMLoc Loc = getLexer ( ) . getLoc ( ) ; getParser ( ) . eatToEndOfStatement ( ) ; return Error ( Loc , <STR_LIT> ) ; }


<s> if ( parseRegister ( Operands ) == MatchOperand_Success ) return false ; if ( parseImmediate ( Operands ) == MatchOperand_Success ) return false ; Error ( getLoc ( ) , <STR_LIT> ) ;


<s> Name = StringRef ( std :: string ( <STR_LIT> ) + getLexer ( ) . getTok ( ) . getString ( ) . str ( ) ) ; break ; case AsmToken :: Identifier : Name = getLexer ( ) . getTok ( ) . getIdentifier ( ) ; break ; }

unsigned RegNo = MatchRegisterName ( Name ) ;


<s> Name = StringRef ( std :: string ( <STR_LIT> ) + getLexer ( ) . getTok ( ) . getString ( ) . str ( ) ) ; break ; case AsmToken :: Identifier : Name = getLexer ( ) . getTok ( ) . getIdentifier ( ) ; break ; } unsigned RegNo = MatchRegisterName ( Name ) ; E = SMLoc :: getFromPointer ( getLoc ( ) . getPointer ( ) - <NUM_LIT> ) ; if ( RegNo == <NUM_LIT> ) { return MatchOperand_NoMatch ; } Operands . push_back ( <STR_LIT> ( RegNo , S , E ) ) ; getLexer ( ) . Lex ( ) ; return MatchOperand_Success ;


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


<s> OS << <STR_LIT> ; OS << getReg ( ) << <STR_LIT> ; break ; case Token :

OS << <STR_LIT> << getToken ( ) << <STR_LIT> ;


<s> Lower<ISA_LIT>MachineInstrToMCInst ( MI , TmpInst , * this ) ; EmitToStreamer ( * OutStreamer , TmpInst ) ;


<s> if ( emitPseudoExpansionLowering ( * OutStreamer , MI ) ) return ; MCInst TmpInst ;

Lower<ISA_LIT>MachineInstrToMCInst ( MI , TmpInst , * this ) ;


<s> void LLVMInitialize<ISA_LIT>AsmPrinter ( ) { RegisterAsmPrinter < <ISA_LIT>AsmPrinter > Y ( getThe<ISA_LIT>Target ( ) ) ;


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

RegisterAsmPrinter < <ISA_LIT>AsmPrinter > Y ( getThe<ISA_LIT>Target ( ) ) ;


<s> bool lowerOperand ( const MachineOperand & MO , MCOperand & MCOp ) const { return Lower<ISA_LIT>MachineOperandToMCOperand ( MO , MCOp , * this ) ;


<s> return Lower<ISA_LIT>MachineOperandToMCOperand ( MO , MCOp , * this ) ;


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


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


<s> if ( RegNo > sizeof ( SRDecoderTable ) ) return MCDisassembler :: Fail ; unsigned Reg = SRDecoderTable [ RegNo ] ; Inst . addOperand ( MCOperand :: createReg ( Reg ) ) ;


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


<s> Size = <NUM_LIT> ; if ( Bytes . size ( ) < <NUM_LIT> ) { Size = <NUM_LIT> ; return MCDisassembler :: Fail ; } uint32_t Inst = <STR_LIT> :: read32be ( Bytes . data ( ) ) ; return decodeInstruction ( DecoderTable<ISA_LIT>32 , MI , Inst , Address , this , STI ) ;


<s> DecodeStatus <ISA_LIT>Disassembler :: getInstruction ( MCInst & MI , uint64_t & Size , ArrayRef < uint8_t > Bytes , uint64_t Address , raw_ostream & OS , raw_ostream & CS ) const { Size = <NUM_LIT> ;


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


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


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


<s> std :: unique_ptr < MCObjectTargetWriter > llvm :: create<ISA_LIT>ELFObjectWriter ( uint8_t OSABI ) {

return std :: make_unique < <ISA_LIT>ELFObjectWriter > ( OSABI ) ;


<s> unsigned <ISA_LIT>ELFObjectWriter :: getRelocType ( MCContext & Ctx , const MCValue & Target , const MCFixup & Fixup , bool IsPCRel ) const { switch ( ( unsigned ) Fixup . getKind ( ) ) { default : llvm_unreachable ( <STR_LIT> ) ; case FK_Data_8 : return ELF :: R_<ISA_LIT>_DATA ; case <STR_LIT> : return ELF :: R_<ISA_LIT>_REL_16 ; case <STR_LIT> : return ELF :: R_<ISA_LIT>_REL_24 ; case <STR_LIT> : return ELF :: R_<ISA_LIT>_H ;


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


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


<s> else if ( Val < <NUM_LIT> && Val >= - <NUM_LIT> ) BuildMI ( MBB , MBBI , DL , TII -> get ( <STR_LIT> ) , DestReg ) . addReg ( SrcReg ) . addImm ( - Val ) . setMIFlag ( Flag ) ; else report_fatal_error ( <STR_LIT> <STR_LIT> ) ;


<s> else if ( Val < <NUM_LIT> && Val >= - <NUM_LIT> ) BuildMI ( MBB , MBBI , DL , TII -> get ( <STR_LIT> ) , DestReg ) . addReg ( SrcReg ) . addImm ( - Val ) . setMIFlag ( Flag ) ;


<s> TargetFrameLowering :: determineCalleeSaves ( MF , SavedRegs , RS ) ; SavedRegs . set ( <STR_LIT> ) ;


<s> uint64_t StackAlign = RI -> needsStackRealignment ( MF ) ? MFI . getMaxAlignment ( ) : getStackAlignment ( ) ; uint64_t MaxCallFrameSize = MFI . getMaxCallFrameSize ( ) ; if ( MFI . hasVarSizedObjects ( ) ) MaxCallFrameSize = alignTo ( MaxCallFrameSize , StackAlign ) ; MFI . setMaxCallFrameSize ( MaxCallFrameSize ) ; if ( ! ( hasReservedCallFrame ( MF ) && MFI . adjustsStack ( ) ) ) FrameSize += MaxCallFrameSize ;

FrameSize = alignTo ( FrameSize , StackAlign ) ;


<s> uint64_t FrameSize = MFI . getStackSize ( ) ; uint64_t StackAlign = RI -> needsStackRealignment ( MF ) ? MFI . getMaxAlignment ( ) : getStackAlignment ( ) ; uint64_t MaxCallFrameSize = MFI . getMaxCallFrameSize ( ) ;

if ( MFI . hasVarSizedObjects ( ) ) MaxCallFrameSize = alignTo ( MaxCallFrameSize , StackAlign ) ;


<s> MachineBasicBlock :: iterator eliminateCallFramePseudoInstr ( MachineFunction & MF , MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI ) const override {


<s> if ( ! hasFP ( MF ) ) { report_fatal_error ( <STR_LIT> ) ; } MachineBasicBlock :: iterator MBBI = MBB . getLastNonDebugInstr ( ) ; const <ISA_LIT>RegisterInfo * RI = STI . getRegisterInfo ( ) ; MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; DebugLoc DL = MBBI -> getDebugLoc ( ) ; unsigned FPReg = getFPReg ( STI ) ; unsigned SPReg = getSPReg ( STI ) ; MachineBasicBlock :: iterator LastFrameDestroy = MBBI ; size_t CalleeSavedSize = getCalleeSavedSize ( MFI . getCalleeSavedInfo ( ) , MF . getSubtarget ( ) . getRegisterInfo ( ) ) ; std :: advance ( LastFrameDestroy , - CalleeSavedSize ) ; uint64_t StackSize = MFI . getStackSize ( ) ; if ( RI -> needsStackRealignment ( MF ) || MFI . hasVarSizedObjects ( ) ) { adjustReg ( MBB , LastFrameDestroy , DL , SPReg , FPReg , - StackSize , MachineInstr :: FrameDestroy ) ; }

adjustReg ( MBB , MBBI , DL , SPReg , SPReg , StackSize , MachineInstr :: FrameDestroy ) ;


<s> void <ISA_LIT>FrameLowering :: emitEpilogue ( MachineFunction & MF , MachineBasicBlock & MBB ) const { if ( ! hasFP ( MF ) ) { report_fatal_error ( <STR_LIT> ) ; } MachineBasicBlock :: iterator MBBI = MBB . getLastNonDebugInstr ( ) ; const <ISA_LIT>RegisterInfo * RI = STI . getRegisterInfo ( ) ; MachineFrameInfo & MFI = MF . getFrameInfo ( ) ;


<s> static size_t getCalleeSavedSize ( const std :: vector < CalleeSavedInfo > & CSI , const TargetRegisterInfo * TRI ) { size_t Size = <NUM_LIT> ; for ( const CalleeSavedInfo & CI : CSI ) { unsigned Reg = CI . getReg ( ) ; const TargetRegisterClass * RC = TRI -> getMinimalPhysRegClass ( Reg ) ; if ( <STR_LIT> . hasSubClassEq ( RC ) ) Size += <NUM_LIT> ; else if ( <STR_LIT> . hasSubClassEq ( RC ) ) Size += <NUM_LIT> ; else llvm_unreachable ( <STR_LIT> ) ; } return Size ;


<s> static unsigned getFPReg ( const <ISA_LIT>Subtarget & STI ) { return <STR_LIT> ;


<s> int MinCSFI = <NUM_LIT> ; int MaxCSFI = - <NUM_LIT> ; int Offset = MFI . getObjectOffset ( FI ) - getOffsetOfLocalArea ( ) + MFI . getOffsetAdjustment ( ) ; if ( CSI . size ( ) ) { MinCSFI = CSI [ <NUM_LIT> ] . getFrameIdx ( ) ; MaxCSFI = CSI [ CSI . size ( ) - <NUM_LIT> ] . getFrameIdx ( ) ;


<s> int MinCSFI = <NUM_LIT> ; int MaxCSFI = - <NUM_LIT> ; int Offset = MFI . getObjectOffset ( FI ) - getOffsetOfLocalArea ( ) + MFI . getOffsetAdjustment ( ) ; if ( CSI . size ( ) ) { MinCSFI = CSI [ <NUM_LIT> ] . getFrameIdx ( ) ;

MaxCSFI = CSI [ CSI . size ( ) - <NUM_LIT> ] . getFrameIdx ( ) ;


<s> static unsigned getSPReg ( const <ISA_LIT>Subtarget & STI ) {


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


<s> explicit <ISA_LIT>FrameLowering ( const <ISA_LIT>Subtarget & STI ) : TargetFrameLowering ( StackGrowsDown , Align ( <NUM_LIT> ) , <NUM_LIT> ) , STI ( STI ) {


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


<s> case <STR_LIT> : case <STR_LIT> : back = true ; break ; default : back = false ; } auto Val = Op . getImm ( ) << <NUM_LIT> ; if ( back ) { Val -= <NUM_LIT> ; } O << formatHex ( Val ) ; return ; } MI -> getOperand ( OpNum ) . getExpr ( ) -> print ( O , & MAI ) ;


<s> printInstruction ( MI , O ) ; printAnnotation ( O , Annot ) ;


<s> if ( Opcode == <STR_LIT> ) back = true ; auto Val = Op . getImm ( ) << <NUM_LIT> ; if ( back ) { Val -= <NUM_LIT> ; } O << formatHex ( Val ) ; return ;


<s> const MCOperand & Op = MI -> getOperand ( OpNum ) ; unsigned Opcode = MI -> getOpcode ( ) ; if ( Op . isImm ( ) ) { bool back = false ; if ( Opcode == <STR_LIT> ) back = true ; auto Val = Op . getImm ( ) << <NUM_LIT> ; if ( back ) { Val -= <NUM_LIT> ; } O << formatHex ( Val ) ; return ;


<s> void <ISA_LIT>InstrInfo :: copyPhysReg ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MBBI , const DebugLoc & DL , MCRegister DstReg , MCRegister SrcReg , bool KillSrc ) const { assert ( <STR_LIT> . contains ( DstReg , SrcReg ) && <STR_LIT> ) ;

BuildMI ( MBB , MBBI , DL , get ( <STR_LIT> ) , DstReg ) . addReg ( SrcReg , getKillRegState ( KillSrc ) ) . addImm ( <NUM_LIT> ) ;


<s> DebugLoc DL = MI -> getDebugLoc ( ) ; MachineBasicBlock * MBB = MI -> getParent ( ) ; BuildMI ( * MBB , MI , DL , get ( <STR_LIT> ) ) . add ( MI -> getOperand ( <NUM_LIT> ) ) . add ( MI -> getOperand ( <NUM_LIT> ) ) ; BuildMI ( * MBB , MI , DL , get ( <STR_LIT> ) ) . add ( MI -> getOperand ( <NUM_LIT> ) ) . add ( MI -> getOperand ( <NUM_LIT> ) ) ; BuildMI ( * MBB , MI , DL , get ( <STR_LIT> ) ) . add ( MI -> getOperand ( <NUM_LIT> ) ) . add ( MI -> getOperand ( <NUM_LIT> ) ) ;


<s> if ( MI -> getOperand ( <NUM_LIT> ) . isDead ( ) ) return ; DebugLoc DL = MI -> getDebugLoc ( ) ; MachineBasicBlock * MBB = MI -> getParent ( ) ; BuildMI ( * MBB , MI , DL , get ( <STR_LIT> ) ) . add ( MI -> getOperand ( <NUM_LIT> ) ) . add ( MI -> getOperand ( <NUM_LIT> ) ) ; BuildMI ( * MBB , MI , DL , get ( <STR_LIT> ) ) . add ( MI -> getOperand ( <NUM_LIT> ) ) . add ( MI -> getOperand ( <NUM_LIT> ) ) ; BuildMI ( * MBB , MI , DL , get ( <STR_LIT> ) ) . add ( MI -> getOperand ( <NUM_LIT> ) ) . add ( MI -> getOperand ( <NUM_LIT> ) ) ; BuildMI ( * MBB , MI , DL , get ( <STR_LIT> ) ) . add ( MI -> getOperand ( <NUM_LIT> ) ) . add ( MI -> getOperand ( <NUM_LIT> ) ) ;


<s> } if ( uimm >> <NUM_LIT> ) { BuildMI ( * MBB , MI , DL , get ( <STR_LIT> ) ) . add ( MI -> getOperand ( <NUM_LIT> ) ) . addImm ( uimm >> <NUM_LIT> ) ; } } else { imm = - imm ; if ( ! ( imm >> <NUM_LIT> ) ) { BuildMI ( * MBB , MI , DL , get ( <STR_LIT> ) ) . add ( MI -> getOperand ( <NUM_LIT> ) ) . addImm ( <NUM_LIT> ) . addImm ( imm ) ; } else { BuildMI ( * MBB , MI , DL , get ( <STR_LIT> ) ) . add ( MI -> getOperand ( <NUM_LIT> ) ) . addImm ( imm & <NUM_LIT> ) ; if ( imm >> <NUM_LIT> ) { BuildMI ( * MBB , MI , DL , get ( <STR_LIT> ) ) . add ( MI -> getOperand ( <NUM_LIT> ) ) . addImm ( ( imm >> <NUM_LIT> ) & <NUM_LIT> ) ; } BuildMI ( * MBB , MI , DL , get ( <STR_LIT> ) ) . add ( MI -> getOperand ( <NUM_LIT> ) ) . addImm ( <NUM_LIT> ) . addReg ( MI -> getOperand ( <NUM_LIT> ) . getReg ( ) ) ; } } MBB -> erase ( MI ) ;


<s> bool <ISA_LIT>InstrInfo :: expandPostRAPseudo ( MachineInstr & MI ) const { switch ( MI . getOpcode ( ) ) { default : return false ; case <STR_LIT> : expandLDImm ( MI ) ;


<s> default : return false ; case <STR_LIT> : expandLDImm ( MI ) ; return true ; case <STR_LIT> : expandLDAddr ( MI ) ; return true ; }


<s> DebugLoc DL ; if ( I != MBB . end ( ) ) DL = I -> getDebugLoc ( ) ; if ( <STR_LIT> . hasSubClassEq ( RC ) ) {

BuildMI ( MBB , I , DL , get ( <STR_LIT> ) , DstReg ) . addFrameIndex ( FI ) . addImm ( <NUM_LIT> ) ;


<s> if ( <STR_LIT> . hasSubClassEq ( RC ) ) { BuildMI ( MBB , I , DL , get ( <STR_LIT> ) , DstReg ) . addFrameIndex ( FI ) . addImm ( <NUM_LIT> ) ; } else if ( <STR_LIT> . hasSubClassEq ( RC ) ) {

BuildMI ( MBB , I , DL , get ( <STR_LIT> ) ) . addReg ( <STR_LIT> , RegState :: Define ) . addFrameIndex ( FI ) . addImm ( <NUM_LIT> ) ;


<s> BuildMI ( MBB , I , DL , get ( <STR_LIT> ) ) . addReg ( SrcReg , getKillRegState ( IsKill ) ) . addFrameIndex ( FI ) . addImm ( <NUM_LIT> ) ; } else if ( <STR_LIT> . hasSubClassEq ( RC ) ) { BuildMI ( MBB , I , DL , get ( <STR_LIT> ) ) . addReg ( <STR_LIT> , RegState :: Define ) . addReg ( SrcReg ) ; BuildMI ( MBB , I , DL , get ( <STR_LIT> ) ) . addReg ( <STR_LIT> , RegState :: Kill ) . addFrameIndex ( FI ) . addImm ( <NUM_LIT> ) ; } else {


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


<s> StringRef getPassName ( ) const override {


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


<s> Node -> setNodeId ( - <NUM_LIT> ) ; return ; } if ( Opcode == <STR_LIT> ) { SDLoc DL ( Node ) ; SDValue Imm = CurDAG -> getTargetConstant ( <NUM_LIT> , DL , <STR_LIT> ) ; int FI = dyn_cast < FrameIndexSDNode > ( Node ) -> getIndex ( ) ;

EVT VT = Node -> getValueType ( <NUM_LIT> ) ;


<s> bool <ISA_LIT>DAGToDAGISel :: SelectAddrFI ( SDValue Addr , SDValue & Base ) { if ( auto FIN = dyn_cast < FrameIndexSDNode > ( Addr ) ) { Base = CurDAG -> getTargetFrameIndex ( FIN -> getIndex ( ) , <STR_LIT> ) ; return true ;


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


<s> MachineFunction & MF = DAG . getMachineFunction ( ) ; SmallVector < CCValAssign , <NUM_LIT> > ArgLocs ; CCState ArgCCInfo ( CallConv , IsVarArg , MF , ArgLocs , * DAG . getContext ( ) ) ; ArgCCInfo . AnalyzeCallOperands ( Outs , CC_<ISA_LIT> ) ; unsigned NumBytes = ArgCCInfo . getNextStackOffset ( ) ; for ( auto & Arg : Outs ) { if ( ! Arg . Flags . isByVal ( ) ) continue ; report_fatal_error ( <STR_LIT> ) ; } Chain = DAG . getCALLSEQ_START ( Chain , NumBytes , <NUM_LIT> , CLI . DL ) ; SmallVector < std :: pair < unsigned , SDValue > , <NUM_LIT> > RegsToPass ; for ( unsigned I = <NUM_LIT> , E = ArgLocs . size ( ) ; I != E ; ++ I ) { CCValAssign & VA = ArgLocs [ I ] ; SDValue ArgValue = OutVals [ I ] ; switch ( VA . getLocInfo ( ) ) { case CCValAssign :: Full : break ; default : llvm_unreachable ( <STR_LIT> ) ; } if ( VA . isRegLoc ( ) ) { RegsToPass . push_back ( std :: make_pair ( VA . getLocReg ( ) , ArgValue ) ) ; } else { assert ( VA . isMemLoc ( ) && <STR_LIT> ) ; report_fatal_error ( <STR_LIT> ) ; } } SDValue Glue ; for ( auto & Reg : RegsToPass ) { Chain = DAG . getCopyToReg ( Chain , DL , Reg . first , Reg . second , Glue ) ; Glue = Chain . getValue ( <NUM_LIT> ) ; }

if ( isa < GlobalAddressSDNode > ( Callee ) ) {


<s> if ( RegVT != <STR_LIT> ) { LLVM_DEBUG ( dbgs ( ) << <STR_LIT> << RegVT . getEVTString ( ) << <STR_LIT> ) ; report_fatal_error ( <STR_LIT> ) ; } const unsigned VReg = RegInfo . createVirtualRegister ( & <STR_LIT> ) ; RegInfo . addLiveIn ( VA . getLocReg ( ) , VReg ) ; SDValue ArgIn = DAG . getCopyFromReg ( Chain , DL , VReg , RegVT ) ; InVals . push_back ( ArgIn ) ; } return Chain ;


<s> 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> ) { LLVM_DEBUG ( dbgs ( ) << <STR_LIT> << RegVT . getEVTString ( ) << <STR_LIT> ) ; report_fatal_error ( <STR_LIT> ) ; }

const unsigned VReg = RegInfo . createVirtualRegister ( & <STR_LIT> ) ;


<s> EVT Ty = Op . getValueType ( ) ; GlobalAddressSDNode * N = cast < GlobalAddressSDNode > ( Op ) ;

const GlobalValue * GV = N -> getGlobal ( ) ;


<s> case <STR_LIT> : return LowerGlobalAddress ( Op , DAG ) ; case <STR_LIT> : return LowerSELECT ( Op , DAG ) ;


<s> if ( IsVarArg ) { report_fatal_error ( <STR_LIT> ) ; } 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 ) {


<s> bool shouldConvertConstantLoadToIntImm ( const APInt & Imm , Type * Ty ) const override {


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


<s> CodePointerSize = CalleeSaveStackSlotSize = <NUM_LIT> ; CommentString = <STR_LIT> ;


<s> <ISA_LIT>MCAsmInfo :: <ISA_LIT>MCAsmInfo ( const Triple & TT ) { IsLittleEndian = false ; UseIntegratedAssembler = true ;

CodePointerSize = CalleeSaveStackSlotSize = <NUM_LIT> ;


<s> Fixups . push_back ( MCFixup :: create ( <NUM_LIT> , MCOp . getExpr ( ) , Kind ) ) ;


<s> unsigned <ISA_LIT>MCCodeEmitter :: getBranchTargetOpValue ( const MCInst & Inst , unsigned OpNo , SmallVectorImpl < MCFixup > & Fixups , const MCSubtargetInfo & SubtargetInfo ) const { const MCOperand & MCOp = Inst . getOperand ( OpNo ) ;

MCFixupKind Kind = static_cast < MCFixupKind > ( <STR_LIT> ) ;


<s> unsigned <ISA_LIT>MCCodeEmitter :: getHWydeOpValue ( const MCInst & Inst , unsigned OpNo , SmallVectorImpl < MCFixup > & Fixups , const MCSubtargetInfo & SubtargetInfo ) const {

return getLabelOpValue ( Inst , OpNo , Fixups , SubtargetInfo , static_cast < MCFixupKind > ( <STR_LIT> ) ) ;


<s> unsigned <ISA_LIT>MCCodeEmitter :: getJumpTargetOpValue ( const MCInst & Inst , unsigned OpNo , SmallVectorImpl < MCFixup > & Fixups , const MCSubtargetInfo & SubtargetInfo ) const {

const MCOperand & MCOp = Inst . getOperand ( OpNo ) ;


<s> if ( MCOp . isImm ( ) ) return getMachineOpValue ( Inst , MCOp , Fixups , SubtargetInfo ) ; Fixups . push_back ( MCFixup :: create ( <NUM_LIT> , MCOp . getExpr ( ) , Kind ) ) ; return <NUM_LIT> ;


<s> const MCOperand & MCOp = Inst . getOperand ( OpNo ) ; if ( MCOp . isImm ( ) ) return getMachineOpValue ( Inst , MCOp , Fixups , SubtargetInfo ) ;

Fixups . push_back ( MCFixup :: create ( <NUM_LIT> , MCOp . getExpr ( ) , Kind ) ) ;


<s> unsigned <ISA_LIT>MCCodeEmitter :: getLWydeOpValue ( const MCInst & Inst , unsigned OpNo , SmallVectorImpl < MCFixup > & Fixups , const MCSubtargetInfo & SubtargetInfo ) const {


<s> unsigned <ISA_LIT>MCCodeEmitter :: getLWydeOpValue ( const MCInst & Inst , unsigned OpNo , SmallVectorImpl < MCFixup > & Fixups , const MCSubtargetInfo & SubtargetInfo ) const { return getLabelOpValue ( Inst , OpNo , Fixups , SubtargetInfo , static_cast < MCFixupKind > ( <STR_LIT> ) ) ;


<s> if ( MO . isReg ( ) ) return Ctx . getRegisterInfo ( ) -> getEncodingValue ( MO . getReg ( ) ) ;

if ( MO . isImm ( ) ) return static_cast < unsigned > ( MO . getImm ( ) ) ;


<s> unsigned <ISA_LIT>MCCodeEmitter :: getMHWydeOpValue ( const MCInst & Inst , unsigned OpNo , SmallVectorImpl < MCFixup > & Fixups , const MCSubtargetInfo & SubtargetInfo ) const { return getLabelOpValue ( Inst , OpNo , Fixups , SubtargetInfo , static_cast < MCFixupKind > ( <STR_LIT> ) ) ;


<s> unsigned <ISA_LIT>MCCodeEmitter :: getMLWydeOpValue ( const MCInst & Inst , unsigned OpNo , SmallVectorImpl < MCFixup > & Fixups , const MCSubtargetInfo & SubtargetInfo ) const { return getLabelOpValue ( Inst , OpNo , Fixups , SubtargetInfo , static_cast < MCFixupKind > ( <STR_LIT> ) ) ;


<s> <ISA_LIT>MCCodeEmitter ( MCContext & ctx ) : Ctx ( ctx ) {


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


<s> MCOperand MCOp ; if ( Lower<ISA_LIT>MachineOperandToMCOperand ( MO , MCOp , AP ) ) OutMI . addOperand ( MCOp ) ;


<s> OutMI . setOpcode ( MI -> getOpcode ( ) ) ; for ( const MachineOperand & MO : MI -> operands ( ) ) {


<s> case MachineOperand :: MO_RegisterMask : return false ; case MachineOperand :: MO_Immediate : MCOp = MCOperand :: createImm ( MO . getImm ( ) ) ; break ; case MachineOperand :: MO_MachineBasicBlock : MCOp = MCOperand :: createExpr ( MCSymbolRefExpr :: create ( MO . getMBB ( ) -> getSymbol ( ) , AP . OutContext ) ) ; break ;

case MachineOperand :: MO_GlobalAddress :


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


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


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


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


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

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


<s> std :: string CPUName = CPU ; if ( CPUName . empty ( ) ) CPUName = <STR_LIT> ;

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


<s> TargetRegistry :: RegisterMCAsmBackend ( getThe<ISA_LIT>Target ( ) , create<ISA_LIT>AsmBackend ) ; TargetRegistry :: RegisterMCCodeEmitter ( getThe<ISA_LIT>Target ( ) , create<ISA_LIT>MCCodeEmitter ) ;

TargetRegistry :: RegisterMCSubtargetInfo ( getThe<ISA_LIT>Target ( ) , create<ISA_LIT>MCSubtargetInfo ) ;


<s> MachineInstr & MI = * II ; MachineFunction & MF = * MI . getParent ( ) -> getParent ( ) ; MachineRegisterInfo & MRI = MF . getRegInfo ( ) ; const TargetInstrInfo * TII = MF . getSubtarget ( ) . getInstrInfo ( ) ; DebugLoc DL = MI . getDebugLoc ( ) ; int FrameIndex = MI . getOperand ( FIOperandNum ) . getIndex ( ) ; unsigned FrameReg ; int Offset = getFrameLowering ( MF ) -> getFrameIndexReference ( MF , FrameIndex , FrameReg ) + MI . getOperand ( FIOperandNum + <NUM_LIT> ) . getImm ( ) ; assert ( MF . getSubtarget ( ) . getFrameLowering ( ) -> hasFP ( MF ) && <STR_LIT> ) ; if ( MI . getOpcode ( ) == <STR_LIT> && Offset < <NUM_LIT> && isInt < <NUM_LIT> > ( Offset ) ) { MI . setDesc ( TII -> get ( <STR_LIT> ) ) ; MI . getOperand ( FIOperandNum + <NUM_LIT> ) . ChangeToImmediate ( - Offset ) ; } else if ( Offset < <NUM_LIT> ) { MI . setDesc ( TII -> get ( getRegOpForImmOpVariant ( MI . getOpcode ( ) ) ) ) ;

unsigned Reg = MRI . createVirtualRegister ( & <STR_LIT> ) ;


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


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


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


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


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


<s> bool requiresRegisterScavenging ( const MachineFunction & MF ) const override {


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


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


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


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


<s> if ( CPUName . empty ( ) ) CPUName = <STR_LIT> ; ParseSubtargetFeatures ( CPUName , FS ) ; return * this ;


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


<s> static std :: string computeDataLayout ( const Triple & TT ) {


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


<s> TargetPassConfig * <ISA_LIT>TargetMachine :: createPassConfig ( PassManagerBase & PM ) {

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


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


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


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


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


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

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


<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 , Optional < Reloc :: Model > RM , Optional < CodeModel :: Model > CM , CodeGenOpt :: Level OL , bool JIT ) : LLVMTargetMachine ( T , computeDataLayout ( TT ) , TT , CPU , FS , Options , getEffectiveRelocModel ( TT , RM ) , getEffectiveCodeModel ( CM , CodeModel :: Small ) , OL ) , TLOF ( std :: make_unique < TargetLoweringObjectFileELF > ( ) ) , Subtarget ( TT , CPU , FS , * this ) {