Template_token: <s> uint8_t OSABI = MCELFObjectTargetWriter :: getOSABI ( Triple :: UnknownOS ) ; return new <ISA_LIT>AsmBackend

ground_truth: ( OSABI ) ;

File: AGCAsmBackend

Func: createAGCAsmBackend

Target: AGC

Target_Clf: MPU

Compiler_Type: LLVM


Template_token: <s> std :: unique_ptr < MCObjectTargetWriter > <ISA_LIT>AsmBackend :: createObjectTargetWriter (

ground_truth: ) const {

Func: createObjectTargetWriter


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

Func: fixupNeedsRelaxation


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

ground_truth: false ;


Template_token: <s> void <ISA_LIT>AsmBackend :: relaxInstruction ( const MCInst & Inst , const

ground_truth: MCSubtargetInfo & STI , MCInst & Res ) const {

Func: relaxInstruction


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

ground_truth: getValue ( ) ) ) ;

File: AGCAsmParser

Func: addExpr


Template_token: <s> void addImmOperands ( MCInst & Inst

ground_truth: , unsigned N ) const {

Func: addImmOperands


Template_token: <s> void addRegOperands ( MCInst & Inst ,

ground_truth: unsigned N ) const {

Func: addRegOperands


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

ground_truth: Token :

Func: AGCOperand


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

Func: checkEarlyTargetMatchPredicate


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

Func: createImm


Template_token: <s> const MCExpr * getImm (

Func: getImm


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


Template_token: <s> return getParser ( ) . getTok (

ground_truth: ) . getLoc ( ) ;

Func: getLoc


Template_token: <s> return getParser ( ) . getTok ( )

ground_truth: . getLoc ( ) ;


Template_token: <s> SMLoc getStartLoc ( ) const override { return

ground_truth: StartLoc ;

Func: getStartLoc


Template_token: <s> StringRef getToken ( ) const { assert ( Kind ==

ground_truth: Token && <STR_LIT> ) ;

Func: getToken


Template_token: <s> bool isBank6 ( ) const { return isConstantImm ( ) && getConstantImm ( ) <


Template_token: <s> bool isBlock2 ( ) const { if ( ! isConstantImm ( ) ) return false ; int64_t Imm = getConstantImm (


Template_token: <s> bool isConstantImm ( ) const { return isImm ( ) && getImm ( ) ->

ground_truth: getKind ( ) == MCExpr :: Constant ;

Func: isConstantImm


Template_token: <s> bool isConstantImm ( ) const { return isImm ( ) && getImm ( ) -> getKind

ground_truth: ( ) == MCExpr :: Constant ;


Template_token: <s> return Kind == Immediate

Func: isImm


Template_token: <s> return ( isConstantImm ( ) && isUInt < <NUM_LIT> > ( getConstantImm ( ) ) )

ground_truth: || isSymbolRef ( ) ;


Template_token: <s> return ( isConstantImm ( ) && isUInt < <NUM_LIT> > (

ground_truth: getConstantImm ( ) ) ) || isSymbolRef ( ) ;


Template_token: <s> return isImm ( ) && getImm ( ) -> getKind (

ground_truth: ) == MCExpr :: SymbolRef ;

Func: isSymbolRef


Template_token: <s> return isImm ( ) && getImm ( ) -> getKind ( )

ground_truth: == MCExpr :: SymbolRef ;


Template_token: <s> bool isToken ( )

ground_truth: const override {

Func: isToken


Template_token: <s> return Kind ==

ground_truth: Token ;


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

ground_truth: ) ) ErrorLoc = IDLoc ;

Func: MatchAndEmitInstruction


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

Func: ParseDirective


Template_token: <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' ) { uint64_t Octal = CE -> getValue (

Func: parseImmediate


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

ground_truth: AsmToken :: EndOfStatement ) ) return false ;

Func: ParseInstruction


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

Func: ParseRegister


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

ground_truth: TmpInst ) ;

File: AGCAsmPrinter

Func: EmitInstruction


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

Func: getPassName


Template_token: <s> RegisterAsmPrinter < <ISA_LIT>AsmPrinter > X ( getThe<ISA_LIT>Target (

Func: LLVMInitializeAGCAsmPrinter


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

File: AGCDisassembler

Func: createAGCDisassembler


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

ground_truth: , Ctx ) ;


Template_token: <s> static DecodeStatus DecodeAccLowerRegisterClass ( MCInst & Inst , uint64_t Insn , int64_t Address

ground_truth: , const void * Decoder ) {

Func: DecodeAccLowerRegisterClass


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


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

ground_truth: :: Success ;

Func: DecodeAccRegisterClass


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


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


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

ground_truth: Imm ) ) ;


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


Template_token: <s> static DecodeStatus decodeIO9Operand ( MCInst & Inst , uint64_t Imm , int64_t Address , const void

ground_truth: * Decoder ) {


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

ground_truth: Success ;


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

ground_truth: , STI ) ;

Func: getInstruction


Template_token: <s> <ISA_LIT>ExpandPseudo ( ) : MachineFunctionPass ( ID

File: AGCExpandPseudos

Func: AGCExpandPseudo


Template_token: <s> FunctionPass * create<ISA_LIT>ExpandPseudoPass

Func: createAGCExpandPseudoPass


Template_token: <s> return new <ISA_LIT>ExpandPseudo ( )


Template_token: <s> bool <ISA_LIT>ExpandPseudo :: expandMI ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MBBI ,

ground_truth: MachineBasicBlock :: iterator & NextMBBI ) {

Func: expandMI


Template_token: <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 ) ; NextMBBI = MBB . end

Func: expandPseudoCONST


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


Template_token: <s> TII = static_cast < const <ISA_LIT>InstrInfo * > ( MF . getSubtarget ( ) . getInstrInfo ( ) ) ; bool Modified = false ; for ( auto & MBB : MF ) Modified |=

ground_truth: expandMBB ( MBB ) ;

Func: runOnMachineFunction


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

ground_truth: false ;


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

Func: strtoi


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

ground_truth: MAX_VAL ) return false ;

Func: toAGCConstant


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

ground_truth: true ;


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

ground_truth: <STR_LIT> ) ;

Func: toBankNumber


Template_token: <s> bool hasFP ( const MachineFunction &

ground_truth: MF ) const override {

File: AGCFrameLowering

Func: hasFP


Template_token: <s> void <ISA_LIT>InstPrinter :: printInst ( const MCInst * MI , raw_ostream & O , StringRef

ground_truth: Annot , const MCSubtargetInfo & STI ) {

File: AGCInstPrinter

Func: printInst


Template_token: <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 ; Octal += ( Val %

ground_truth: <NUM_LIT> ) * Pow ;

Func: printOperand


Template_token: <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 ; } assert ( KillSrc &&

File: AGCInstrInfo

Func: copyPhysReg


Template_token: <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> ) ; BuildMI ( MBB , MI , DL , get ( <STR_LIT> ) , DestReg ) . addReg ( SrcReg


Template_token: <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 ) ; ReplaceNode ( Node , New

File: AGCISelDAGToDAG

Func: SelectAGCConstant


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

File: AGCISelLowering

Func: AGCTargetLowering


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

Func: getTargetNodeName


Template_token: <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> &&

ground_truth: RegVT != <STR_LIT> ) {

Func: LowerFormalArguments


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

ground_truth: <NUM_LIT> ) . getOperand ( <NUM_LIT> ) ;

Func: LowerMUL


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

ground_truth: ) report_fatal_error ( <STR_LIT> ) ;


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

ground_truth: <STR_LIT> , RetOps ) ;

Func: LowerReturn


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

ground_truth: . push_back ( Flag ) ;


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

ground_truth: Div ) ;

Func: LowerSREM


Template_token: <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 )

ground_truth: , <STR_LIT> , Div ) ;


Template_token: <s> switch ( N -> getOpcode ( ) ) { default : SDValue Res = LowerOperation ( SDValue ( N , <NUM_LIT> )

ground_truth: , DAG ) ;

Func: ReplaceNodeResults


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

File: AGCMCAsmInfo

Func: AGCMCAsmInfo


Template_token: <s> MCCodeEmitter * llvm :: create<ISA_LIT>MCCodeEmitter ( const MCInstrInfo & MCII , const MCRegisterInfo

ground_truth: & MRI , MCContext & Ctx ) {

File: AGCMCCodeEmitter

Func: createAGCMCCodeEmitter


Template_token: <s> <STR_LIT> :: write < uint16_t > (

ground_truth: OS , Encoding , <STR_LIT> ) ;

Func: emitBitsWithParity


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


Template_token: <s> return ( Bits << <NUM_LIT> ) | getParityBitForEncoding (

ground_truth: Bits ) ;

Func: getEncodingWithParity


Template_token: <s> return ( Bits << <NUM_LIT> )

ground_truth: | getParityBitForEncoding ( Bits ) ;


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

Func: getMachineOpValue


Template_token: <s> static uint16_t getParityBitForEncoding ( uint16_t Enc ) { uint16_t ParityBit = <NUM_LIT>

Func: getParityBitForEncoding


Template_token: <s> for ( int i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) ParityBit ^=


Template_token: <s> MCStreamer * create<ISA_LIT>MCELFStreamer ( const Triple & TT , MCContext & Context , std :: unique_ptr < MCAsmBackend > && MAB , std :: unique_ptr < MCObjectWriter

ground_truth: > && OW , std :: unique_ptr < MCCodeEmitter > && CE , bool RelaxAll ) {

File: AGCMCELFStreamer

Func: createAGCMCELFStreamer


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

File: AGCMCInstLower

Func: LowerAGCMachineInstrToMCInst


Template_token: <s> static MCAsmInfo * create<ISA_LIT>MCAsmInfo ( const MCRegisterInfo & MRI , const

ground_truth: Triple & TT ) {

File: AGCMCTargetDesc

Func: createAGCMCAsmInfo


Template_token: <s> static MCAsmInfo * create<ISA_LIT>MCAsmInfo ( const MCRegisterInfo & MRI , const Triple &

ground_truth: TT ) {


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

Func: createAGCMCInstrInfo


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

ground_truth: , create<ISA_LIT>AsmBackend ) ;

Func: LLVMInitializeAGCTargetMC


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

File: AGCRegisterInfo

Func: eliminateFrameIndex


Template_token: <s> const MCPhysReg * <ISA_LIT>RegisterInfo :: getCalleeSavedRegs ( const MachineFunction * MF

ground_truth: ) const {

Func: getCalleeSavedRegs


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

Func: getFrameRegister


Template_token: <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 ) { std :: string CPUName

ground_truth: = CPU ;

File: AGCSubtarget

Func: AGCSubtarget


Template_token: <s> const <ISA_LIT>RegisterInfo * getRegisterInfo

ground_truth: ( ) const override {

Func: getRegisterInfo


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

Func: getTargetLowering


Template_token: <s> Target & getThe<ISA_LIT>Target (

File: AGCTargetInfo

Func: getTheAGCTarget


Template_token: <s> void LLVMInitialize<ISA_LIT>TargetInfo ( ) { RegisterTarget < Triple :: agc > A ( getThe<ISA_LIT>Target ( ) , <STR_LIT>

ground_truth: , <STR_LIT> , <STR_LIT> ) ;

Func: LLVMInitializeAGCTargetInfo


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

File: AGCTargetMachine

Func: addInstSelector


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


Template_token: <s> void <ISA_LIT>PassConfig :: addPreEmitPass2 ( ) { addPass ( create<ISA_LIT>ExpandPseudoPass (


Template_token: <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 , <STR_LIT> , TT , CPU , FS , Options , getEffectiveRelocModel ( RM ) , getEffectiveCodeModel ( CM , CodeModel :: Small ) , OL ) , TLOF ( make_unique < <ISA_LIT>ELFTargetObjectFile

ground_truth: > ( ) ) , Subtarget ( TT , CPU , FS , * this ) {

Func: AGCTargetMachine


Template_token: <s> TargetPassConfig * <ISA_LIT>TargetMachine :: createPassConfig ( PassManagerBase

Func: createPassConfig


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


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

Func: getAGCTargetMachine


Template_token: <s> static Reloc :: Model getEffectiveRelocModel ( Optional < Reloc :: Model > RM ) { if ( ! RM . hasValue ( ) ) return Reloc

ground_truth: :: Static ;

Func: getEffectiveRelocModel


Template_token: <s> TargetLoweringObjectFile * getObjFileLowering ( ) const override { return TLOF . get

Func: getObjFileLowering


Template_token: <s> const <ISA_LIT>Subtarget * getSubtargetImpl ( const Function & )

ground_truth: const override {

Func: getSubtargetImpl


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

ground_truth: Subtarget ;


Template_token: <s> void LLVMInitialize<ISA_LIT>Target ( ) { RegisterTargetMachine < <ISA_LIT>TargetMachine > A ( getThe<ISA_LIT>Target

Func: LLVMInitializeAGCTarget


Template_token: <s> RegisterTargetMachine < <ISA_LIT>TargetMachine > A ( getThe<ISA_LIT>Target ( )