Template_token: <s> auto NumBits = Info . TargetSize + Info . TargetOffset ; auto NumBytes = ( NumBits / <NUM_LIT> ) + ( ( NumBits % <NUM_LIT> ) == <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ) ; Value <<= Info . TargetOffset ; unsigned Offset = Fixup . getOffset ( ) ; assert ( Offset + NumBytes <= Data . size ( ) &&

ground_truth: <STR_LIT> ) ;

Func: applyFixup

Target_Clf: CPU

Compiler_Type: LLVM


Template_token: <s> auto NumBits = Info . TargetSize + Info . TargetOffset ; auto NumBytes = ( NumBits / <NUM_LIT> ) + ( ( NumBits % <NUM_LIT> ) == <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ) ; Value <<= Info . TargetOffset ; unsigned Offset = Fixup . getOffset ( ) ; assert ( Offset + NumBytes <= Data

ground_truth: . size ( ) && <STR_LIT> ) ;


Template_token: <s> static void assertUnsignedWidth ( unsigned Width , uint64_t Value , std :: string Description , const MCFixup & Fixup , MCContext * Ctx = nullptr ) { if ( ! isUIntN ( Width , Value

Func: assertUnsignedWidth


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

ground_truth: MCTargetOptions & TO ) {


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

Func: createObjectTargetWriter


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

ground_truth: <NUM_LIT> ) ;


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

Func: fixupNeedsRelaxation


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

ground_truth: false ;


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

Func: mayNeedRelaxation


Template_token: <s> bool <ISA_LIT>AsmBackend :: shouldForceRelocation ( const MCAssembler & Asm , const MCFixup & Fixup , const MCValue & Target ) { switch ( ( unsigned ) Fixup . getKind ( ) ) { default : return false

Func: shouldForceRelocation


Template_token: <s> bool <ISA_LIT>AsmBackend :: writeNopData ( raw_ostream &

ground_truth: OS , uint64_t Count ) const {

Func: writeNopData


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

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

Func: addExpr


Template_token: <s> void addExpr ( MCInst & Inst , const MCExpr * Expr ) const { if ( Expr == <NUM_LIT> ) Inst . addOperand ( MCOperand :: createImm ( <NUM_LIT> ) ) ; else if ( const MCConstantExpr * CE = dyn_cast < MCConstantExpr > ( Expr ) ) Inst . addOperand ( MCOperand

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


Template_token: <s> assert ( N == <NUM_LIT> && <STR_LIT> ) ; Inst . addOperand ( MCOperand :: createReg ( getMemBase ( ) )

Func: addMemOperands


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

ground_truth: getMemOff ( ) ;


Template_token: <s> assert ( N == <NUM_LIT> && <STR_LIT> ) ; Inst . addOperand ( MCOperand :: createReg (

ground_truth: getReg ( ) ) ) ;

Func: addRegOperands


Template_token: <s> Op -> Mem . Base = Base ; Op -> Mem . Off = Off ; Op -> StartLoc = S ; Op -> EndLoc

Func: CreateMem


Template_token: <s> static std :: unique_ptr < <ISA_LIT>Operand > CreateReg ( unsigned RegNum , SMLoc S , SMLoc E ) { auto Op = std :: make_unique < <ISA_LIT>Operand > ( k_Register ) ; Op -> Reg . RegNum = RegNum ; Op -> StartLoc = S ; Op -> EndLoc

Func: CreateReg


Template_token: <s> static std :: unique_ptr < <ISA_LIT>Operand > CreateToken ( StringRef Str , SMLoc S ) { auto Op = std :: make_unique < <ISA_LIT>Operand > ( k_Token ) ; Op -> Tok . Data = Str . data ( ) ; Op -> Tok . Length = Str . size ( ) ; Op -> StartLoc = S ; Op -> EndLoc

Func: CreateToken


Template_token: <s> const MCExpr * <ISA_LIT>AsmParser :: evaluateRelocExpr ( const MCExpr * Expr , StringRef RelocStr ) { <ISA_LIT>MCExpr :: VariantKind Kind = StringSwitch < <ISA_LIT>MCExpr :: VariantKind > ( RelocStr ) . Default

ground_truth: ( <ISA_LIT>MCExpr :: VK_<ISA_LIT>_None ) ;

Func: evaluateRelocExpr


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

Func: getEndLoc


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

ground_truth: Val ;

Func: getImm


Template_token: <s> unsigned getMemBase ( ) const { assert ( ( Kind == k_Memory ) && <STR_LIT>

Func: getMemBase


Template_token: <s> const MCExpr * getMemOff

ground_truth: ( ) const {

Func: getMemOff


Template_token: <s> assert ( ( Kind == k_Register

Func: getReg


Template_token: <s> return StringRef ( Tok . Data , Tok .

ground_truth: Length ) ;

Func: getToken


Template_token: <s> bool isImm ( ) const override { return Kind == k_Immediate

Func: isImm


Template_token: <s> bool isImm ( )

ground_truth: const override {


Template_token: <s> bool isMem ( ) const

ground_truth: override {

Func: isMem


Template_token: <s> bool isReorder ( ) { return reorder

Func: isReorder


Template_token: <s> bool isToken ( ) const override { return Kind

ground_truth: == k_Token ;

Func: isToken


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


Template_token: <s> bool <ISA_LIT>AsmParser :: MatchAndEmitInstruction ( SMLoc IDLoc , unsigned & Opcode , OperandVector & Operands , MCStreamer & Out , uint64_t & ErrorInfo , bool MatchingInlineAsm ) { print<ISA_LIT>Operands ( Operands ) ; MCInst Inst ; unsigned MatchResult = MatchInstructionImpl ( Operands , Inst , ErrorInfo , MatchingInlineAsm ) ; switch ( MatchResult ) { default : break ; case Match_Success : { Inst . setLoc ( IDLoc ) ; Out . emitInstruction ( Inst , getSTI ( ) ) ; return false ; } case Match_MissingFeature : Error ( IDLoc , <STR_LIT> ) ; return true ; case Match_InvalidOperand : { SMLoc ErrorLoc = IDLoc ; if ( ErrorInfo != ~ <NUM_LIT>

Func: MatchAndEmitInstruction


Template_token: <s> Inst . setLoc ( IDLoc ) ; Out . emitInstruction ( Inst , getSTI ( ) ) ; return false ; } case Match_MissingFeature : Error ( IDLoc , <STR_LIT> ) ; return true ; case Match_InvalidOperand : { SMLoc ErrorLoc = IDLoc ; if ( ErrorInfo != ~ <NUM_LIT> ) { if ( ErrorInfo >= Operands . size ( ) ) return Error ( IDLoc , <STR_LIT> ) ; ErrorLoc = ( ( <ISA_LIT>Operand & ) * Operands [ ErrorInfo ] )

ground_truth: . getStartLoc ( ) ;


Template_token: <s> return MatchRegisterName (

ground_truth: Name ) ;

Func: matchRegisterName


Template_token: <s> MCAsmParserExtension :: Initialize ( parser ) ; setAvailableFeatures ( ComputeAvailableFeatures ( getSTI ( ) . getFeatureBits (


Template_token: <s> bool <ISA_LIT>AsmParser :: parseDirectiveSet ( ) { const AsmToken & Tok = getParser ( ) . getTok ( ) ; if ( Tok . getString ( ) == <STR_LIT> ) { return parseSetReorderDirective ( ) ; } else if ( Tok . getString ( ) ==

ground_truth: <STR_LIT> ) {

Func: parseDirectiveSet


Template_token: <s> Operands . push_back ( <STR_LIT> ( <STR_LIT> , S ) ) ; Parser . Lex ( ) ; } return false ; } StringRef Identifier ; if ( Parser . parseIdentifier ( Identifier ) ) return true ; SMLoc E = SMLoc :: getFromPointer ( Parser . getTok ( ) . getLoc ( ) . getPointer ( ) - <NUM_LIT> ) ; MCSymbol * Sym = getContext ( ) . getOrCreateSymbol ( <STR_LIT> + Identifier ) ; const MCExpr * Res = MCSymbolRefExpr :: create ( Sym , MCSymbolRefExpr :: VK_None , getContext ( ) ) ; Operands . push_back ( <STR_LIT> ( Res , S , E ) ) ; return false ; } case AsmToken :: Identifier : case AsmToken :: LParen : case AsmToken :: Minus : case AsmToken :: Plus : case AsmToken :: Integer : case AsmToken :: String : { const MCExpr * IdVal ; SMLoc S = Parser . getTok ( ) . getLoc ( ) ; if ( getParser ( ) . parseExpression ( IdVal ) ) return true ; SMLoc E = SMLoc :: getFromPointer ( Parser . getTok ( ) . getLoc ( ) . getPointer ( ) - <NUM_LIT> ) ; Operands . push_back ( <STR_LIT> ( IdVal , S , E ) ) ; return false ; } case AsmToken :: Percent : { const MCExpr * IdVal ; SMLoc S = Parser . getTok ( ) . getLoc ( ) ; if ( parseRelocOperand ( IdVal ) ) return true ; SMLoc E = SMLoc :: getFromPointer ( Parser . getTok ( ) . getLoc (

ground_truth: ) . getPointer ( ) - <NUM_LIT> ) ;

Func: ParseOperand


Template_token: <s> if ( Tok . isNot ( AsmToken :: Identifier ) ) return true ; std :: string Str = Tok . getIdentifier ( ) . str ( ) ; Parser . Lex ( ) ; const MCExpr * IdVal ; SMLoc EndLoc ; if ( getLexer ( ) . getKind ( ) == AsmToken :: LParen ) { while ( <NUM_LIT> ) { Parser . Lex ( ) ; if ( getLexer ( ) . getKind ( ) == AsmToken :: Percent ) { Parser . Lex ( ) ; const AsmToken & nextTok = Parser . getTok ( ) ; if ( nextTok . isNot ( AsmToken :: Identifier ) ) return true ; Str += <STR_LIT> ; Str += nextTok . getIdentifier ( ) ; Parser . Lex ( ) ; if ( getLexer ( ) . getKind ( ) != AsmToken :: LParen ) return true ; } else break ; } if ( getParser ( ) . parseParenExpression ( IdVal , EndLoc

ground_truth: ) ) return true ;

Func: parseRelocOperand


Template_token: <s> reportParseError ( <STR_LIT> ) ; return false ; } Options . setMacro ( ) ; Parser . Lex (

Func: parseSetMacroDirective


Template_token: <s> case k_Immediate : OS << <STR_LIT> ; OS << * Imm . Val ; OS << <STR_LIT> ; break ; case k_Memory : OS << <STR_LIT> ; OS << Mem . Base ; OS << <STR_LIT> ; OS << * Mem . Off ; OS <<

Func: print


Template_token: <s> void print<ISA_LIT>Operands ( OperandVector & Operands ) { LLVM_DEBUG ( dbgs ( ) << <STR_LIT> ) ; for ( size_t i = <NUM_LIT> ; i < Operands . size (


Template_token: <s> SMLoc Loc = getLexer ( ) . getLoc ( ) ; getParser ( ) . eatToEndOfStatement

Func: reportParseError


Template_token: <s> void setNoreorder (

Func: setNoreorder


Template_token: <s> int RegNo = matchRegisterName ( RegisterName ) ; if ( RegNo == <NUM_LIT> ) return true ; Operands . push_back ( <STR_LIT> ( RegNo , S , Parser . getTok ( ) . getLoc ( ) ) ) ; Parser . Lex (

Func: tryParseRegisterOperand


Template_token: <s> return std :: make_unique < <ISA_LIT>ELFObjectWriter > (

ground_truth: OSABI ) ;


Template_token: <s> void <ISA_LIT>FrameLowering :: determineCalleeSaves ( MachineFunction & MF , BitVector & SavedRegs , RegScavenger * RS ) const { TargetFrameLowering :: determineCalleeSaves ( MF

ground_truth: , SavedRegs , RS ) ;

Func: determineCalleeSaves


Template_token: <s> MachineBasicBlock :: iterator <ISA_LIT>FrameLowering :: eliminateCallFramePseudoInstr ( MachineFunction & MF , MachineBasicBlock & MBB , MachineBasicBlock :: iterator I ) const { return MBB . erase ( I )

Func: eliminateCallFramePseudoInstr


Template_token: <s> MachineBasicBlock :: iterator <ISA_LIT>FrameLowering :: eliminateCallFramePseudoInstr ( MachineFunction & MF , MachineBasicBlock & MBB

ground_truth: , MachineBasicBlock :: iterator I ) const {


Template_token: <s> int <ISA_LIT>FrameLowering :: getFrameIndexReference ( const MachineFunction & MF , int FI , Register & FrameReg ) const { const <ISA_LIT>Subtarget & Subtarget = MF . getSubtarget < <ISA_LIT>Subtarget > ( ) ; const MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; const <ISA_LIT>RegisterInfo * RegInfo = Subtarget . getRegisterInfo ( ) ; FrameReg = RegInfo -> getFrameRegister ( MF ) ; int64_t FrameOffset = MFI . getObjectOffset ( FI ) + MFI

ground_truth: . getOffsetAdjustment ( ) ;

Func: getFrameIndexReference


Template_token: <s> return MF . getFrameInfo ( ) . hasVarSizedObjects

Func: hasFP


Template_token: <s> bool <ISA_LIT>FrameLowering :: hasFP ( const MachineFunction & MF ) const { return MF . getFrameInfo ( ) .

ground_truth: hasVarSizedObjects ( ) ;


Template_token: <s> bool <ISA_LIT>FrameLowering :: isFPCloseToIncomingSP ( )

ground_truth: const {

Func: isFPCloseToIncomingSP


Template_token: <s> void <ISA_LIT>InstPrinter :: printInst ( const MCInst * MI , uint64_t Address , StringRef Annot ,

ground_truth: const MCSubtargetInfo & STI , raw_ostream & O ) {

Func: printInst


Template_token: <s> OS << '$' << StringRef ( getRegisterName ( RegNo

Func: printRegName


Template_token: <s> const <ISA_LIT>RegisterInfo & getRegisterInfo (

ground_truth: ) const {

Func: getRegisterInfo


Template_token: <s> return new <ISA_LIT>DAGToDAGISel (

ground_truth: TM , OptLevel ) ;


Template_token: <s> StringRef getPassName ( )

ground_truth: const override {

Func: getPassName


Template_token: <s> bool <ISA_LIT>DAGToDAGISel :: runOnMachineFunction ( MachineFunction & MF ) { Subtarget = & MF . getSubtarget

ground_truth: < <ISA_LIT>Subtarget > ( ) ;

Func: runOnMachineFunction


Template_token: <s> if ( N -> isMachineOpcode ( ) ) { LLVM_DEBUG ( errs ( ) << <STR_LIT> ; N -> dump ( CurDAG ) ; errs

Func: Select


Template_token: <s> bool <ISA_LIT>DAGToDAGISel :: trySelect ( SDNode

Func: trySelect


Template_token: <s> bool <ISA_LIT>DAGToDAGISel :: trySelect ( SDNode *


Template_token: <s> MachineBasicBlock * <ISA_LIT>TargetLowering :: EmitInstrWithCustomInserter ( MachineInstr & MI , MachineBasicBlock * MBB ) const { llvm_unreachable (

ground_truth: <STR_LIT> ) ;

Func: EmitInstrWithCustomInserter


Template_token: <s> const char * <ISA_LIT>TargetLowering :: getTargetNodeName (

ground_truth: unsigned Opcode ) const {

Func: getTargetNodeName


Template_token: <s> SDValue <ISA_LIT>TargetLowering :: LowerOperation ( SDValue Op , SelectionDAG & DAG ) const { llvm_unreachable (

Func: LowerOperation


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> ) ; computeRegisterProperties ( Subtarget . getRegisterInfo ( ) ) ; setStackPointerRegisterToSaveRestore ( <STR_LIT>


Template_token: <s> PrivateLabelPrefix = <STR_LIT> ; SupportsDebugInformation = true ; UseIntegratedAssembler =

ground_truth: true ;


Template_token: <s> void <ISA_LIT>MCCodeEmitter :: encodeInstruction ( const MCInst & MI , raw_ostream & OS , SmallVectorImpl < MCFixup > & Fixups , const MCSubtargetInfo & STI ) const { verifyInstructionPredicates ( MI , computeAvailableFeatures ( STI . getFeatureBits ( ) ) ) ; uint64_t Binary = getBinaryCodeForInstr ( MI , Fixups ,

ground_truth: STI ) ;

Func: encodeInstruction


Template_token: <s> void <ISA_LIT>MCCodeEmitter :: encodeInstruction ( const MCInst & MI , raw_ostream & OS , SmallVectorImpl < MCFixup > & Fixups , const MCSubtargetInfo & STI ) const { verifyInstructionPredicates ( MI , computeAvailableFeatures ( STI . getFeatureBits ( ) ) ) ; uint64_t Binary = getBinaryCodeForInstr ( MI , Fixups , STI ) ; <STR_LIT> :: write < uint32_t > ( OS , Binary ,


Template_token: <s> return new ( Ctx ) <ISA_LIT>MCExpr

ground_truth: ( Kind , Expr ) ;

Func: create


Template_token: <s> return Expr -> findAssociatedFragment

Func: findAssociatedFragment


Template_token: <s> Expr -> print ( OS

ground_truth: , MAI ) ;

Func: printImpl


Template_token: <s> Expr -> print ( OS , MAI


Template_token: <s> void <ISA_LIT>MCExpr :: visitUsedExpr ( MCStreamer & Streamer ) const { Streamer . visitUsedExpr ( * Expr )

Func: visitUsedExpr


Template_token: <s> void <ISA_LIT>MCExpr :: visitUsedExpr ( MCStreamer & Streamer ) const { Streamer . visitUsedExpr (

ground_truth: * Expr ) ;


Template_token: <s> static MCStreamer * createMCStreamer ( const Triple & TT , MCContext & Context , std :: unique_ptr < MCAsmBackend > && MAB , std :: unique_ptr < MCObjectWriter > && OW , std :: unique_ptr < MCCodeEmitter > && Emitter , bool RelaxAll ) { return createELFStreamer ( Context , std :: move ( MAB ) , std :: move ( OW ) , std :: move ( Emitter )

ground_truth: , RelaxAll ) ;

Func: createMCStreamer


Template_token: <s> static MCStreamer * createMCStreamer ( const Triple & TT , MCContext & Context , std :: unique_ptr < MCAsmBackend > && MAB , std :: unique_ptr < MCObjectWriter > && OW , std :: unique_ptr < MCCodeEmitter > && Emitter , bool RelaxAll ) { return createELFStreamer ( Context , std :: move ( MAB ) , std :: move ( OW ) ,

ground_truth: std :: move ( Emitter ) , RelaxAll ) ;


Template_token: <s> if ( SyntaxVariant == <NUM_LIT> ) return new <ISA_LIT>InstPrinter (

ground_truth: MAI , MII , MRI ) ;


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

ground_truth: nullptr ;


Template_token: <s> Init<ISA_LIT>MCRegisterInfo ( X , <NUM_LIT> ) ; return

ground_truth: X ;


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


Template_token: <s> TargetRegistry :: RegisterMCSubtargetInfo ( getThe<ISA_LIT>Target ( ) , create<ISA_LIT>MCSubtargetInfo ) ; TargetRegistry :: RegisterMCInstPrinter ( getThe<ISA_LIT>Target ( ) , create<ISA_LIT>MCInstPrinter ) ; TargetRegistry :: RegisterMCCodeEmitter ( getThe<ISA_LIT>Target ( ) , create<ISA_LIT>MCCodeEmitter ) ; TargetRegistry :: RegisterELFStreamer ( getThe<ISA_LIT>Target (

ground_truth: ) , createMCStreamer ) ;


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

ground_truth: MF ) const {

Func: getCalleeSavedRegs


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

ground_truth: ID CC ) const {

Func: getCallPreservedMask


Template_token: <s> markSuperRegs ( Reserved , <STR_LIT> ) ; markSuperRegs ( Reserved , <STR_LIT> ) ; markSuperRegs ( Reserved , <STR_LIT> ) ; markSuperRegs ( Reserved , <STR_LIT> ) ; markSuperRegs ( Reserved , <STR_LIT> ) ; markSuperRegs ( Reserved , <STR_LIT> ) ; markSuperRegs ( Reserved , <STR_LIT> ) ; markSuperRegs ( Reserved , <STR_LIT> ) ; markSuperRegs ( Reserved , <STR_LIT> ) ; markSuperRegs ( Reserved , <STR_LIT> ) ; markSuperRegs ( Reserved ,

Func: getReservedRegs


Template_token: <s> return MFI . getNumFixedObjects ( ) && needsStackRealignment

Func: hasBasePointer


Template_token: <s> bool <ISA_LIT>RegisterInfo :: hasBasePointer ( const MachineFunction & MF ) const { const MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; return MFI . getNumFixedObjects ( )

ground_truth: && needsStackRealignment ( MF ) ;


Template_token: <s> const <ISA_LIT>InstrInfo * getInstrInfo

ground_truth: ( ) const override {

Func: getInstrInfo


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

ground_truth: InstrInfo ;


Template_token: <s> const <ISA_LIT>TargetLowering * getTargetLowering (

ground_truth: ) const override {

Func: getTargetLowering


Template_token: <s> ParseSubtargetFeatures ( CPU , FS ) ; return *

ground_truth: this ;

Func: initializeSubtargetDependencies


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

ground_truth: ( ) , TLInfo ( TM , initializeSubtargetDependencies ( CPU , FS , TM ) ) {


Template_token: <s> LLVM_EXTERNAL_VISIBILITY void LLVMInitialize<ISA_LIT>TargetInfo ( ) { llvm :: RegisterTarget < llvm :: Triple :: mina32 > X (

ground_truth: llvm :: getThe<ISA_LIT>Target ( ) , <STR_LIT> , <STR_LIT> , <STR_LIT> ) ;


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

ground_truth: getOptLevel ( ) ) ) ;

Func: addInstSelector


Template_token: <s> return new <ISA_LIT>PassConfig ( *

ground_truth: this , PM ) ;

Func: createPassConfig


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

ground_truth: * RM : Reloc :: Static ;

Func: getEffectiveRelocModel


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

ground_truth: : Reloc :: Static ;


Template_token: <s> return getTM < <ISA_LIT>TargetMachine


Template_token: <s> TargetLoweringObjectFile * getObjFileLowering ( )

ground_truth: const override {

Func: getObjFileLowering


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

Func: getSubtargetImpl


Template_token: <s> bool isMachineVerifierClean ( ) const override { return

ground_truth: false ;

Func: isMachineVerifierClean


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