<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> ; case MCFixupKind ::


<s> MCAsmBackend * llvm :: create<ISA_LIT>AsmBackend ( const Target & T , const MCRegisterInfo & MRI , const


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


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


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


<s> IsResolved = true ; ( void ) adjustFixupValue ( Fixup , Value ,


<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 ; ( void ) adjustFixupValue ( Fixup , Value , & Asm .


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


<s> else if ( const MCConstantExpr * CE = dyn_cast < MCConstantExpr > ( Expr ) ) Inst . addOperand (

MCOperand :: createImm ( CE -> getValue ( ) ) ) ;


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


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


<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 ( ) ) ) ; const MCExpr * Expr


<s> Inst . addOperand ( MCOperand :: createReg ( getReg


<s> Inst . addOperand ( MCOperand :: createReg (


<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 ; Op -> EndLoc


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


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


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


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


<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> SMLoc getEndLoc ( ) const { return EndLoc


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


<s> MCAsmParser & getParser ( ) const { return


<s> unsigned <ISA_LIT>AsmParser :: getReg ( int RC , int RegNo


<s> bool isCond ( ) const { return Kind == k_CondCode


<s> bool isMem ( ) const { return Kind == k_Memory


<s> bool isToken ( ) const { return Kind == k_Token


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


<s> int CC = StringSwitch < unsigned > ( Name ) . 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> ) . 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 ( - <NUM_LIT> ) ;


<s> int <ISA_LIT>AsmParser :: matchRegisterName ( StringRef Name ) { int CC = StringSwitch < unsigned > ( Name ) . 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> ) . 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 ( - <NUM_LIT> ) ;


<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 ; } if ( IDVal ==


<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 ; } if ( IDVal ==


<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 ( ) ; return Error ( Loc , <STR_LIT> )


<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> ) { Error ( Parser . getTok ( ) . getLoc


<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 ( ) ) ) ; Parser . Lex (


<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


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


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


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


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


<s> Parser . eatToEndOfStatement ( ) ; return Error ( Loc


<s> void <ISA_LIT>AsmPrinter :: EmitFunctionBodyStart


<s> MCInstLowering . Initialize ( Mang , & MF -> getContext (


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


<s> RegisterAsmPrinter < <ISA_LIT>AsmPrinter > X ( The<ISA_LIT>Target


<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 ( ) )


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


<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 ; case 'z' :


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


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


<s> static MCDisassembler * create<ISA_LIT>Disassebler ( const Target & T , const MCSubtargetInfo


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


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


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


<s> if ( RegNo > <NUM_LIT> ) return MCDisassembler :: Fail ; Inst . addOperand ( MCOperand :: createReg (


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


<s> static DecodeStatus DecodeGRRegsRegisterClass ( MCInst & Inst , unsigned RegNo , uint64_t


<s> unsigned JumpOffset = fieldFromInstruction ( Insn , <NUM_LIT> , <NUM_LIT> ) ; Inst . addOperand ( MCOperand ::


<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 [


<s> TargetRegistry :: RegisterMCDisassembler (


<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> ) ; return MCDisassembler ::


<s> return MCDisassembler :: Fail ; } Insn = ( Bytes [ <NUM_LIT> ] << <NUM_LIT> ) | ( Bytes [ <NUM_LIT> ] << <NUM_LIT> ) | (

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


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


<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> : Type = ELF ::


<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 (


<s> if ( I -> getOpcode ( ) == <STR_LIT> || I -> getOpcode ( ) == <STR_LIT>


<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> 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 { BuildMI ( MBB , MBBI , dl , TII . get ( <STR_LIT> ) , StackReg ) . addReg ( StackReg ) . addImm ( StackSize )


<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


<s> 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 &


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


<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> : return <STR_LIT>


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


<s> std :: stringstream stream ; stream << std :: hex << val ; return stream . str


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


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


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


<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 << '+' ; OS << <ISA_LIT>_ez_int2hex


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


<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> ) { 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 (


<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> ) ; } else


<s> const MachineFunction * MF = MI . getParent ( ) -> getParent ( ) ; const char * AsmStr = MI . getOperand ( <NUM_LIT> ) .


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


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


<s> unsigned <ISA_LIT>InstrInfo :: isStoreToStackSlot ( const MachineInstr * MI


<s> unsigned <ISA_LIT>InstrInfo :: isStoreToStackSlot ( const MachineInstr * MI , int & FrameIndex ) const { return <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 ; unsigned Opc = I


<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> ) ) ; } if ( ImmQ4 )


<s> virtual const char * getPassName ( ) const


<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 ( ) ; unsigned char TargetFlags =


<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 ( ) ; if ( operand2Opc == <STR_LIT> || operand2Opc ==


<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>


<s> SDValue RHS = N -> getOperand ( <NUM_LIT> ) ; SDValue CompareOps [ ] = {


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


<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


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


<s> return CurDAG -> getMachineNode ( <STR_LIT> , N , <STR_LIT> ,


<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 ) ; else return SelectCode ( N


<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 (


<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> ,


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


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


<s> static void AnalyzeReturnValues ( CCState & State , SmallVectorImpl < CCValAssign >

& RVLocs , const SmallVectorImpl < ArgT > & Args ) {


<s> std :: reverse ( RVLocs . begin ( ) , RVLocs .


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


<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 ( ) !=


<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 ) ) ,


<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 ) ; setOperationAction ( <STR_LIT> , <STR_LIT> ,


<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 ) ; setOperationAction ( <STR_LIT> , <STR_LIT>


<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> : if ( const ConstantSDNode * C = dyn_cast < ConstantSDNode


<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' : case 'O'


<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 ) ; assert ( Mask && <STR_LIT>


<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 ,


<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 ,


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


<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 ) ; Flag = Chain . getValue (


<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


<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 ) ) ; Prefix . assign ( B


<s> assert ( Prefix == <STR_LIT> ) ; RC = getRegClassFor ( ( VT == <STR_LIT> ) ? <STR_LIT> : VT ) ; assert ( Reg < RC -> getNumRegs ( ) ) ; return std :: make_pair ( * ( RC -> begin ( ) + Reg )


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


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


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


<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> ) ; const MCExpr * Expr = MO


<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


<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 ; } return MCOperand


<s> static MCAsmInfo * create<ISA_LIT>MCAsmInfo ( const MCRegisterInfo & MRI , const Triple & TT ) { return new <ISA_LIT>MCAsmInfo ( 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 ) { report_fatal_error ( <STR_LIT>


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


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


<s> static MCSubtargetInfo * create<ISA_LIT>MCSubtargetInfo ( const Triple &


<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 ,


<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> } ; return CalleeSavedRegs


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


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


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


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


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


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


<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 InstrItineraryData * getInstrItineraryData ( ) const override { return & InstrItins


<s> return & InstrInfo . getRegisterInfo (


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


<s> RegisterTarget < Triple :: fisc > X ( The<ISA_LIT>Target , <STR_LIT> , <STR_LIT>


<s> void <ISA_LIT>PassConfig :: addPreEmitPass ( )


<s> bool <ISA_LIT>PassConfig :: addPreISel (


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

StringRef CPU , const TargetOptions & Options ) {


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


<s> return new <ISA_LIT>PassConfig ( this


<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 > ( ) ) { initAsmInfo ( )


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


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


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