Template_token: <s> assert ( ( & ( MF -> getContext ( ) ) == & ( AsmPrinter :: OutContext ) ) && <STR_LIT> ) ; if ( MI -> isPseudo ( ) ) llvm_unreachable ( <STR_LIT> ) ; MCInst TmpInst0

Func: EmitInstruction

Target_Clf: MPU

Compiler_Type: LLVM


Template_token: <s> if ( MI -> isPseudo ( ) ) llvm_unreachable ( <STR_LIT> ) ; MCInst TmpInst0 ; MCInstLowering . lower ( MI , TmpInst0 )


Template_token: <s> const char * getPassName ( ) const override { return

Func: getPassName


Template_token: <s> void LLVMInitialize<ISA_LIT>AsmPrinter ( ) { RegisterAsmPrinter < <ISA_LIT>AsmPrinter > X (

ground_truth: The<ISA_LIT>Target ) ;


Template_token: <s> void <ISA_LIT>FrameLowering :: emitEpilogue ( MachineFunction & MF , MachineBasicBlock & MBB ) const { MachineFrameInfo * MFrmInf = MF . getFrameInfo ( ) ; MachineBasicBlock :: iterator MBBI = std :: prev ( MBB . end ( ) ) ; const <ISA_LIT>InstrInfo & TII = * static_cast < const <ISA_LIT>InstrInfo * > ( MF . getSubtarget ( ) . getInstrInfo ( ) ) ; <ISA_LIT>FunctionInfo * MFuncInf = MF . getInfo < <ISA_LIT>FunctionInfo > ( ) ; assert ( MBBI -> getOpcode ( ) == <STR_LIT> && <STR_LIT> ) ; DebugLoc dl = MBBI -> getDebugLoc ( ) ; bool FP = hasFP ( MF ) ; int FrameSize = MFrmInf -> getStackSize ( ) ; if ( FrameSize ) { if ( FP ) { int FPSpillOffset = MFrmInf -> getObjectOffset ( MFuncInf -> getFPSpillSlot ( ) ) + FrameSize ; FPSpillOffset += Subtarget . hasSPBias ( ) ? <NUM_LIT> : <NUM_LIT> ; BuildMI ( MBB , MBBI , dl , TII . get ( <STR_LIT> ) ) . addReg ( <STR_LIT> ) . addReg ( <STR_LIT> ) . addImm ( FPSpillOffset ) ; } if ( MFuncInf -> getUsesLR ( ) ) { int LRSpillOffset = MFrmInf -> getObjectOffset ( MFuncInf -> getLRSpillSlot ( ) ) + FrameSize ; LRSpillOffset += Subtarget . hasSPBias (

Func: emitEpilogue


Template_token: <s> const TargetRegisterInfo * RegInfo = MF . getSubtarget ( ) . getRegisterInfo ( ) ; const MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; return ( MF . getTarget ( ) . Options . DisableFramePointerElim ( MF ) || RegInfo -> needsStackRealignment ( MF ) || MF . getFrameInfo ( ) -> hasVarSizedObjects ( ) ||

ground_truth: MFI -> isFrameAddressTaken ( ) ) ;

Func: hasFP


Template_token: <s> bool <ISA_LIT>FrameLowering :: hasFP ( const MachineFunction & MF ) const { const TargetRegisterInfo * RegInfo = MF . getSubtarget ( ) . getRegisterInfo (


Template_token: <s> bool hasReservedCallFrame ( const MachineFunction & MF ) const override { return true

Func: hasReservedCallFrame


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

Func: stackSlotSize


Template_token: <s> O << * MO . getExpr ( ) ; } else if ( MO . isImm ( ) ) { O << MI -> getOperand ( OpNo ) . getImm ( ) ; } else

Func: printImmOperand


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

Func: printInst


Template_token: <s> printInst ( const MCInst * MI , raw_ostream & O , StringRef Annot ) { printInstruction ( MI , O


Template_token: <s> void <ISA_LIT>InstPrinter :: printMemOperand ( const MCInst * MI , int opNum , raw_ostream & O ) { O << <STR_LIT> ; printOperand ( MI , opNum , O

Func: printMemOperand


Template_token: <s> O << <STR_LIT> ; printOperand ( MI , opNum , O ) ; O <<


Template_token: <s> void <ISA_LIT>InstPrinter :: printOperand ( const MCInst * MI , unsigned OpNo , raw_ostream & O ) const { const MCOperand & MO = MI -> getOperand ( OpNo ) ; if ( MO . isReg ( ) ) { O << getRegisterName ( MO . getReg ( ) ) ; } else if ( MO . isExpr ( ) ) { O << * MO . getExpr ( ) ; } else if ( MO . isImm (

Func: printOperand


Template_token: <s> void <ISA_LIT>InstPrinter :: printRegName ( raw_ostream & O

ground_truth: , unsigned RegNo ) const {

Func: printRegName


Template_token: <s> printS16ImmOperand ( const MCInst * MI , unsigned OpNo , raw_ostream


Template_token: <s> printSymbol ( const MCInst * MI , unsigned OpNo , raw_ostream & O , bool hi ) const { assert ( ( MI -> getOperand ( OpNo ) . isImm ( ) || MI -> getOperand ( OpNo ) . isExpr ( ) ) && <STR_LIT> ) ; O << ( hi ? <STR_LIT> : <STR_LIT> ) << <STR_LIT> ; printOperand ( MI ,

ground_truth: OpNo , O ) ;

Func: printSymbol


Template_token: <s> void printSymbolHi ( const MCInst * MI , unsigned OpNo ,

ground_truth: raw_ostream & O ) const {

Func: printSymbolHi


Template_token: <s> printSymbol ( MI , OpNo , O ,

ground_truth: false ) ;

Func: printSymbolLo


Template_token: <s> const MCOperand & MO = MI -> getOperand ( opNum ) ; if ( MO . isImm ( ) ) O << ( uint32_t )

ground_truth: MO . getImm ( ) ;

Func: printUnsignedImm


Template_token: <s> printUnsignedImm ( const MCInst * MI , int opNum , raw_ostream & O ) { const MCOperand & MO = MI -> getOperand ( opNum ) ; if ( MO . isImm ( ) ) O << ( uint32_t ) MO

ground_truth: . getImm ( ) ;


Template_token: <s> FunctionPass * llvm :: create<ISA_LIT>ISelDag ( <ISA_LIT>TargetMachine & TM , CodeGenOpt :: Level OptLevel ) { return new <ISA_LIT>DAGToDAGISel ( TM ,

ground_truth: OptLevel ) ;


Template_token: <s> assert ( <NUM_LIT> && <STR_LIT> ) ; unsigned GlobalBaseReg = getInstrInfo ( ) -> getGlobalBaseReg ( MF ) ; return CurDAG -> getRegister ( GlobalBaseReg , TLI . getPointerTy

ground_truth: ( ) ) . getNode ( ) ;

Func: getGlobalBaseReg


Template_token: <s> unsigned GlobalBaseReg = getInstrInfo ( ) -> getGlobalBaseReg ( MF ) ; return CurDAG -> getRegister ( GlobalBaseReg , TLI . getPointerTy


Template_token: <s> return CurDAG -> getTargetConstant (

ground_truth: Imm , <STR_LIT> ) ;


Template_token: <s> virtual const char * getPassName ( ) const { return


Template_token: <s> if ( Node -> hasOneUse ( ) ) return CurDAG -> SelectNodeTo ( Node , Opc , VT , TFI , imm ) ; return CurDAG -> getMachineNode ( Opc , dl , VT , TFI , imm ) ; } case <STR_LIT> : { if ( TM . getRelocationModel ( ) == Reloc :: PIC_ ) { SDValue Chain = Node -> getOperand ( <NUM_LIT> ) ; SDValue Callee = Node -> getOperand ( <NUM_LIT> ) ; SDValue R20Reg = CurDAG -> getRegister ( <STR_LIT> , <STR_LIT> ) ; SDValue InFlag ( <NUM_LIT> , <NUM_LIT> ) ; if ( ( isa < GlobalAddressSDNode > ( Callee ) ) || ( isa < ExternalSymbolSDNode > ( Callee ) ) ) { SDValue GPReg = CurDAG -> getRegister ( <STR_LIT> , <STR_LIT> ) ; SDValue Ops [ ] = { Callee , GPReg , Chain } ; SDValue Load = SDValue ( CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , <STR_LIT> , Ops , <NUM_LIT> ) , <NUM_LIT> ) ; Chain = Load . getValue ( <NUM_LIT> ) ; Chain = CurDAG -> getCopyToReg ( Chain , dl , R20Reg , Load , InFlag ) ; } else Chain = CurDAG -> getCopyToReg ( Chain , dl , R20Reg , Callee , InFlag ) ; SDNode * ResNode = CurDAG -> getMachineNode ( <STR_LIT> , dl , <STR_LIT> , <STR_LIT> , R20Reg , Chain ) ; Chain = SDValue ( ResNode , <NUM_LIT> ) ; InFlag = SDValue ( ResNode , <NUM_LIT> ) ; ReplaceUses ( SDValue ( Node , <NUM_LIT>

ground_truth: ) , Chain ) ;

Func: Select


Template_token: <s> return true ; } if ( Addr . getOpcode ( ) == <STR_LIT> || Addr . getOpcode ( ) == <STR_LIT> ) return false ; if ( Addr . getOpcode ( ) == <STR_LIT> ) { if ( ConstantSDNode * CN = dyn_cast < ConstantSDNode > ( Addr . getOperand ( <NUM_LIT> ) ) ) { if ( isInt < <NUM_LIT> > ( CN -> getSExtValue ( ) ) ) { if ( FrameIndexSDNode * FIN = dyn_cast < FrameIndexSDNode > ( Addr . getOperand ( <NUM_LIT> ) ) ) { Base = CurDAG -> getTargetFrameIndex ( FIN -> getIndex ( ) , <STR_LIT> ) ; } else { Base = Addr . getOperand ( <NUM_LIT> ) ; } Offset = CurDAG -> getTargetConstant ( CN -> getZExtValue ( ) , <STR_LIT> ) ; return true ; } } if ( Addr . getOperand ( <NUM_LIT> ) . getOpcode ( ) == MonarchISD :: Lo ) { assert ( <NUM_LIT> && <STR_LIT> ) ; Base = Addr . getOperand ( <NUM_LIT> ) ; Offset = Addr . getOperand ( <NUM_LIT> ) . getOperand

ground_truth: ( <NUM_LIT> ) ;

Func: SelectAddrRegImm


Template_token: <s> MachineFunction * F = MBB -> getParent ( ) ; MachineBasicBlock * flsBB = F -> CreateMachineBasicBlock ( LLVM_BB ) ; MachineBasicBlock * sinkBB = F -> CreateMachineBasicBlock ( LLVM_BB ) ; F -> insert ( It , flsBB ) ; F -> insert ( It , sinkBB ) ; sinkBB -> splice ( sinkBB -> begin ( ) , MBB , std :: next ( MachineBasicBlock :: iterator ( MI ) ) , MBB -> end ( ) ) ; sinkBB -> transferSuccessorsAndUpdatePHIs ( MBB ) ; MBB -> addSuccessor ( flsBB ) ; MBB -> addSuccessor (

ground_truth: sinkBB ) ;

Func: EmitCustomSelect


Template_token: <s> MachineBasicBlock * <ISA_LIT>TargetLowering :: EmitInstrWithCustomInserter ( MachineInstr * MI , MachineBasicBlock * MBB ) const { switch ( MI -> getOpcode ( )

Func: EmitInstrWithCustomInserter


Template_token: <s> switch ( Constraint [ <NUM_LIT> ] ) { default : break ; case 'd' : case 'y' : case 'f'

Func: getConstraintType


Template_token: <s> unsigned <ISA_LIT>TargetLowering :: getFunctionAlignment ( const Function * ) const { return

Func: getFunctionAlignment


Template_token: <s> case 'r' : return std :: make_pair ( <NUM_LIT> , & <STR_LIT> ) ; case 'd' : case 'y' : case 'f' : if ( VT == <STR_LIT> ) return std ::

Func: getRegForInlineAsmConstraint


Template_token: <s> std :: pair < unsigned , const TargetRegisterClass * > <ISA_LIT>TargetLowering :: getRegForInlineAsmConstraint ( const std :: string & Constraint , MVT VT ) const { if ( Constraint . size (


Template_token: <s> EVT <ISA_LIT>TargetLowering :: getSetCCResultType ( LLVMContext & Context , EVT VT ) const { return

Func: getSetCCResultType


Template_token: <s> case 'y' : if ( type -> isIntegerTy ( ) ) weight = CW_Register ; break ; case 'f' : if ( type -> isFloatTy ( ) ) weight = CW_Register ; break ; } return weight

Func: getSingleConstraintMatchWeight


Template_token: <s> const char * <ISA_LIT>TargetLowering :: getTargetNodeName ( unsigned Opcode ) const { switch ( Opcode ) { case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> :

ground_truth: return <STR_LIT> ;

Func: getTargetNodeName


Template_token: <s> unsigned NumWords = ( Size + <NUM_LIT> ) / <NUM_LIT> ; unsigned NewSize = <NUM_LIT> ; for ( unsigned i = <NUM_LIT> ; i < NumWords ; ++ i ) { if ( ! State -> AllocateReg ( ArgRegList , <NUM_LIT>

Func: HandleByVal


Template_token: <s> <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> } ; unsigned NumWords = ( Size + <NUM_LIT> ) / <NUM_LIT> ; unsigned NewSize = <NUM_LIT> ; for ( unsigned i = <NUM_LIT> ; i < NumWords


Template_token: <s> bool <ISA_LIT>TargetLowering :: isFPImmLegal ( const APFloat & Imm , EVT VT )

ground_truth: const {

Func: isFPImmLegal


Template_token: <s> bool <ISA_LIT>TargetLowering :: isOffsetFoldingLegal ( const GlobalAddressSDNode * GA

ground_truth: ) const {

Func: isOffsetFoldingLegal


Template_token: <s> SDValue SizeNode = DAG . getConstant ( NumWords * <NUM_LIT> , <STR_LIT> ) ; MemOpChains . push_back ( DAG . getMemcpy ( Chain , dl , Dst , Arg , SizeNode , Flags . getByValAlign ( ) , false , false , MachinePointerInfo ( ) , MachinePointerInfo ( ) ) ) ; } else { assert ( VA . isMemLoc ( ) ) ; SDValue StackPtr = DAG . getRegister ( <STR_LIT> , <STR_LIT> ) ; int offset = VA . getLocMemOffset ( ) ; offset += Subtarget . hasSPBias ( ) ? <NUM_LIT> : <NUM_LIT> ; SDValue PtrOff = DAG . getIntPtrConstant ( offset ) ; PtrOff = DAG . getNode ( <STR_LIT> , dl , <STR_LIT> , StackPtr , PtrOff ) ; MemOpChains . push_back ( DAG . getStore ( Chain , dl , Arg , PtrOff , MachinePointerInfo ( ) , false , false , <NUM_LIT> ) ) ; } } if ( ! MemOpChains . empty ( ) ) Chain = DAG . getNode ( <STR_LIT> , dl , <STR_LIT> , MemOpChains ) ; SDValue InFlag ; for ( unsigned i = <NUM_LIT> , e = RegsToPass . size ( ) ; i != e ; ++ i ) { Chain = DAG . getCopyToReg ( Chain , dl , RegsToPass [ i ] . first , RegsToPass [ i ] . second , InFlag ) ; InFlag = Chain . getValue ( <NUM_LIT> ) ; } if ( GlobalAddressSDNode * G = dyn_cast < GlobalAddressSDNode > ( Callee ) ) Callee = DAG . getTargetGlobalAddress ( G -> getGlobal ( ) , dl , getPointerTy ( ) ) ; else if ( ExternalSymbolSDNode * E = dyn_cast < ExternalSymbolSDNode > ( Callee ) ) Callee = DAG . getTargetExternalSymbol ( E -> getSymbol ( ) , getPointerTy ( ) ) ; SDVTList NodeTys = DAG . getVTList ( <STR_LIT> , <STR_LIT> ) ; SmallVector < SDValue , <NUM_LIT> > Ops ; Ops . push_back ( Chain ) ; Ops . push_back ( Callee ) ; for ( unsigned i = <NUM_LIT> , e = RegsToPass . size ( ) ; i != e ; ++ i ) { assert ( i < <NUM_LIT> ) ; Ops . push_back ( DAG . getRegister ( RegsToPass [ i ] . first , RegsToPass [ i ] . second . getValueType ( ) ) ) ; } if ( InFlag . getNode ( )

ground_truth: ) Ops . push_back ( InFlag ) ;

Func: LowerCall


Template_token: <s> ConstantPoolSDNode * N = cast < ConstantPoolSDNode > ( Op ) ; SDLoc dl ( Op ) ; const Constant * C = N -> getConstVal ( ) ; SDValue CP = DAG . getTargetConstantPool ( C , <STR_LIT> , N -> getAlignment ( ) ) ; SDValue Hi = DAG . getNode ( <STR_LIT> , dl , <STR_LIT> , CP ) ; SDValue Lo = DAG . getNode ( <STR_LIT> , dl , <STR_LIT> , CP ) ; return DAG . getNode ( <STR_LIT> , dl

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

Func: LowerConstantPool


Template_token: <s> SDLoc dl ( Op ) ; SDValue GA = DAG . getTargetGlobalAddress ( GV , dl , <STR_LIT> ) ; if ( DAG . isVerifiedDebugInfoDesc ( Op ) ) return GA ; SDValue Hi = DAG . getNode ( <STR_LIT> , dl , <STR_LIT> , GA ) ; SDValue Lo = DAG . getNode ( <STR_LIT> ,

ground_truth: dl , <STR_LIT> , GA ) ;

Func: LowerGlobalAddress


Template_token: <s> SDValue JTI = DAG . getTargetJumpTable ( JT -> getIndex ( ) , <STR_LIT> ) ; SDValue Hi = DAG . getNode ( <STR_LIT> , SDLoc ( JT ) , <STR_LIT> , JTI ) ; SDValue Lo = DAG . getNode ( <STR_LIT> , SDLoc

ground_truth: ( JT ) , <STR_LIT> , JTI ) ;

Func: LowerJumpTable


Template_token: <s> case <STR_LIT> : return LowerConstantPool ( Op , DAG ) ; case <STR_LIT> : return LowerGlobalAddress ( Op , DAG ) ; case <STR_LIT> : return LowerGlobalTLSAddress ( Op , DAG ) ; case <STR_LIT> : return LowerJumpTable ( Op , DAG ) ; case <STR_LIT> : return LowerSELECT_CC ( Op ,

ground_truth: DAG ) ;

Func: LowerOperation


Template_token: <s> case <STR_LIT> : return LowerConstantPool ( Op , DAG ) ; case <STR_LIT> : return LowerGlobalAddress ( Op , DAG ) ; case <STR_LIT> : return LowerGlobalTLSAddress ( Op , DAG ) ; case <STR_LIT> : return LowerJumpTable ( Op , DAG ) ; case <STR_LIT> : return LowerSELECT_CC ( Op , DAG ) ; case <STR_LIT> : return LowerVASTART ( Op ,


Template_token: <s> SDValue TrueVal = Op . getOperand ( <NUM_LIT> ) ; SDValue FalseVal = Op . getOperand ( <NUM_LIT> ) ; SDLoc dl ( Op ) ; EVT ResultTy = getSetCCResultType ( * DAG . getContext ( ) , Op . getOperand ( <NUM_LIT> ) . getValueType ( ) ) ; SDValue Cond = DAG . getNode ( <STR_LIT> , dl , ResultTy , LHS , RHS , CC ) ; return DAG . getNode ( <STR_LIT> , dl , TrueVal . getValueType ( ) , Cond , TrueVal , FalseVal , DAG . getRegister ( <STR_LIT> ,

ground_truth: <STR_LIT> ) ) ;


Template_token: <s> SDValue RHS = Op . getOperand ( <NUM_LIT> ) ; SDValue CC = Op . getOperand ( <NUM_LIT> ) ; SDValue TrueVal = Op . getOperand ( <NUM_LIT> ) ; SDValue FalseVal = Op . getOperand ( <NUM_LIT> ) ; SDLoc dl ( Op ) ; EVT ResultTy = getSetCCResultType ( * DAG . getContext ( ) , Op . getOperand ( <NUM_LIT>

ground_truth: ) . getValueType ( ) ) ;


Template_token: <s> SDValue FI = DAG . getFrameIndex ( FuncInfo -> getVarArgsFrameIndex ( ) , getPointerTy ( ) ) ; const Value * SV = cast < SrcValueSDNode > ( Op . getOperand ( <NUM_LIT>

ground_truth: ) ) -> getValue ( ) ;

Func: LowerVASTART


Template_token: <s> int getLRSpillSlot ( )

Func: getLRSpillSlot


Template_token: <s> int getLRSpillSlot (


Template_token: <s> std :: vector < std :: pair < MCSymbol * , CalleeSavedInfo > > & getSpillLabels

Func: getSpillLabels


Template_token: <s> std :: vector < std :: pair < MCSymbol * , CalleeSavedInfo >

ground_truth: > & getSpillLabels ( ) {


Template_token: <s> bool getUsesLR ( )

Func: getUsesLR


Template_token: <s> int getVarArgsFrameIndex ( ) const { return VarArgsFrameIndex

Func: getVarArgsFrameIndex


Template_token: <s> FPSpillSlot =

ground_truth: off ;

Func: setFPSpillSlot


Template_token: <s> void setLRSpillSlot ( int

ground_truth: off ) {

Func: setLRSpillSlot


Template_token: <s> LRSpillSlot =


Template_token: <s> void setUsesLR ( bool val ) { UsesLR =

ground_truth: val ;

Func: setUsesLR


Template_token: <s> VarArgsFrameIndex = idx

Func: setVarArgsFrameIndex


Template_token: <s> OutMI . setOpcode ( MI -> getOpcode ( ) ) ; for ( unsigned I = <NUM_LIT> , E = MI -> getNumOperands ( ) ; I != E ; ++ I ) { const MachineOperand & MO = MI -> getOperand ( I

Func: lower


Template_token: <s> MCELFStreamer * ES = new MCELFStreamer ( Context , MAB , OS


Template_token: <s> MCAsmInfo * MAI = new <ISA_LIT>MCAsmInfo ( TT ) ; MCCFIInstruction Inst = MCCFIInstruction :: createDefCfa ( nullptr , <STR_LIT>

ground_truth: , <NUM_LIT> ) ;


Template_token: <s> MCCFIInstruction Inst = MCCFIInstruction :: createDefCfa ( nullptr , <STR_LIT> , <NUM_LIT> ) ; MAI -> addInitialFrameState

ground_truth: ( Inst ) ;


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


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


Template_token: <s> MCStreamer * ES = create<ISA_LIT>ELFStreamer ( Context , MAB , OS , Emitter , RelaxAll ) ; new MCTargetStreamer ( * ES ) ; return ES


Template_token: <s> static MCRegisterInfo * create<ISA_LIT>MCRegisterInfo ( StringRef TT ) { MCRegisterInfo * X = new MCRegisterInfo (


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

ground_truth: X ;


Template_token: <s> MCSubtargetInfo * X = new MCSubtargetInfo ( ) ; Init<ISA_LIT>MCSubtargetInfo ( X , TT , CPU , FS ) ; return


Template_token: <s> TargetRegistry :: RegisterMCObjectStreamer ( The<ISA_LIT>Target , create<ISA_LIT>MCObjStreamer ) ; TargetRegistry :: RegisterMCInstrInfo ( The<ISA_LIT>Target , create<ISA_LIT>MCInstrInfo ) ; TargetRegistry :: RegisterMCRegInfo (


Template_token: <s> const MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; return ( MF . getFunction ( ) -> hasFnAttribute ( <STR_LIT> ) && ! MFI

ground_truth: -> hasVarSizedObjects ( ) ) ;

Func: canRealignStack


Template_token: <s> const MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; return ( MF . getFunction ( ) -> hasFnAttribute ( <STR_LIT> ) && !

ground_truth: MFI -> hasVarSizedObjects ( ) ) ;


Template_token: <s> FPRegToUse = <STR_LIT> ; } int FrameIndex = MI . getOperand ( FIOperandNum ) . getIndex ( ) ; int Offset = MF . getFrameInfo ( ) -> getObjectOffset ( FrameIndex ) ; assert ( Offset % <NUM_LIT> == <NUM_LIT> && <STR_LIT> ) ; int StackSize = MF . getFrameInfo ( ) -> getStackSize ( ) ; DEBUG ( dbgs ( ) << <STR_LIT> << MF . getFunction ( ) -> getName ( ) << <STR_LIT> ) ; DEBUG ( dbgs ( ) << <STR_LIT> ) ; DEBUG ( MI . print ( dbgs ( ) ) ) ; DEBUG ( dbgs ( ) << <STR_LIT> << FrameIndex << <STR_LIT> ) ; DEBUG ( dbgs ( ) << <STR_LIT> << Offset << <STR_LIT> ) ; DEBUG ( dbgs ( ) << <STR_LIT> << StackSize << <STR_LIT> ) ; DEBUG ( dbgs ( ) << <STR_LIT> << Offset + StackSize << <STR_LIT> ) ; DEBUG ( dbgs ( ) << <STR_LIT> << ( ( <STR_LIT> == FPRegToUse ) ? <STR_LIT> : <STR_LIT> ) << <STR_LIT> ) ; DEBUG ( dbgs ( ) << <STR_LIT> << MI . getOperand ( FIOperandNum + <NUM_LIT> ) . getImm ( ) << <STR_LIT> ) ; DEBUG ( dbgs ( ) << <STR_LIT> << MFrmInf -> isFixedObjectIndex ( FrameIndex ) << <STR_LIT> ) ; DEBUG ( dbgs ( ) << <STR_LIT> << MFrmInf -> isSpillSlotObjectIndex ( FrameIndex ) << <STR_LIT> ) ; if ( ! useFP ) { Offset += StackSize ; assert ( Offset % <NUM_LIT> == <NUM_LIT> && <STR_LIT> ) ; Offset += Subtarget . hasSPBias ( ) ? <NUM_LIT> : <NUM_LIT> ; DEBUG ( dbgs ( ) << <STR_LIT> << Offset << <STR_LIT> ) ; } Offset += MI . getOperand ( FIOperandNum + <NUM_LIT> ) . getImm ( ) ; MI . getOperand ( FIOperandNum + <NUM_LIT> ) . ChangeToImmediate ( <NUM_LIT> ) ; DEBUG ( dbgs ( ) << <STR_LIT> << Offset << <STR_LIT> ) ; if ( Offset >= - <NUM_LIT> && Offset <= <NUM_LIT> ) { MI . getOperand ( FIOperandNum ) . ChangeToRegister ( FPRegToUse , false ) ; MI . getOperand ( FIOperandNum + <NUM_LIT> ) . ChangeToImmediate ( Offset ) ; } else { assert ( <NUM_LIT> && <STR_LIT> ) ; } DEBUG ( errs ( ) << <STR_LIT> ) ; DEBUG ( MI . print ( errs ( )

Func: eliminateFrameIndex


Template_token: <s> llvm_unreachable ( <STR_LIT> ) ; return

Func: getEHHandlerRegister


Template_token: <s> const TargetFrameLowering * TFI = MF . getTarget ( ) . getSubtargetImpl

ground_truth: ( ) -> getFrameLowering ( ) ;

Func: getFrameRegister


Template_token: <s> unsigned <ISA_LIT>RegisterInfo :: getRARegister ( )

ground_truth: const {

Func: getRARegister


Template_token: <s> unsigned <ISA_LIT>RegisterInfo :: getRARegister ( ) const { return


Template_token: <s> getReservedRegs ( const MachineFunction & MF ) const { BitVector Reserved ( getNumRegs ( ) ) ; Reserved . set ( <STR_LIT> ) ; Reserved . set ( <STR_LIT> ) ; Reserved . set ( <STR_LIT> ) ; Reserved . set ( <STR_LIT> ) ; Reserved . set

ground_truth: ( <STR_LIT> ) ;

Func: getReservedRegs


Template_token: <s> getReservedRegs ( const MachineFunction & MF ) const { BitVector Reserved ( getNumRegs ( ) ) ; Reserved . set ( <STR_LIT> ) ; Reserved . set ( <STR_LIT> ) ; Reserved . set ( <STR_LIT> ) ; Reserved . set ( <STR_LIT> ) ; Reserved . set ( <STR_LIT> ) ; Reserved . set (

ground_truth: <STR_LIT> ) ;


Template_token: <s> needsStackRealignment ( const MachineFunction & MF ) const { const MachineFrameInfo * MFI = MF . getFrameInfo ( ) ; const Function * F = MF . getFunction ( ) ; unsigned StackAlign = MF . getTarget ( ) . getSubtargetImpl ( ) -> getFrameLowering ( ) -> getStackAlignment ( ) ; DEBUG ( if ( ! ( MFI -> getMaxAlignment ( ) <= StackAlign ) ) errs ( ) << <STR_LIT> << MF . getFunction ( )

ground_truth: -> getName ( ) << <STR_LIT> ) ;

Func: needsStackRealignment


Template_token: <s> const DataLayout * getDataLayout (

ground_truth: ) const override {

Func: getDataLayout


Template_token: <s> const DataLayout * getDataLayout ( ) const override { return &

ground_truth: DL ;


Template_token: <s> return & InstrInfo . getRegisterInfo (

Func: getRegisterInfo


Template_token: <s> const <ISA_LIT>SelectionDAGInfo * getSelectionDAGInfo

ground_truth: ( ) const override {

Func: getSelectionDAGInfo


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

Func: getTargetLowering


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

ground_truth: override {


Template_token: <s> bool hasBarrel ( ) const

ground_truth: { return HasBarrel ; }

Func: hasBarrel


Template_token: <s> bool hasBarrel ( ) const { return HasBarrel


Template_token: <s> bool hasDIV ( ) const { return

ground_truth: HasDIV ; }

Func: hasDIV


Template_token: <s> bool hasMUL ( ) const { return HasMUL

Func: hasMUL


Template_token: <s> bool hasMUL ( ) const {

ground_truth: return HasMUL ; }


Template_token: <s> bool hasSDIV ( ) const { return

ground_truth: HasSDIV ; }

Func: hasSDIV


Template_token: <s> bool hasSDIV ( ) const {

ground_truth: return HasSDIV ; }


Template_token: <s> bool hasSPBias ( ) const {

ground_truth: return HasSPBias ; }

Func: hasSPBias


Template_token: <s> bool hasSPBias ( ) const { return HasSPBias


Template_token: <s> void LLVMInitialize<ISA_LIT>TargetInfo ( ) { RegisterTarget < Triple :: lm32 , false >

ground_truth: X ( The<ISA_LIT>Target , <STR_LIT> , <STR_LIT> ) ;


Template_token: <s> return new <ISA_LIT>PassConfig ( this ,

ground_truth: PM ) ;

Func: createPassConfig


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


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


Template_token: <s> TargetLoweringObjectFile * getObjFileLowering ( )

ground_truth: const override {

Func: getObjFileLowering


Template_token: <s> void LLVMInitialize<ISA_LIT>Target (


Template_token: <s> IsGlobalInSmallSection ( const GlobalValue * GV , const TargetMachine & TM , SectionKind Kind ) const { const GlobalVariable * GVA = dyn_cast < GlobalVariable > ( GV ) ; if ( ! GVA ) return false ; if ( ! Kind . isBSS ( ) && ! Kind . isDataRel ( ) ) return false ; if ( Kind . isMergeable1ByteCString ( ) ) return

ground_truth: false ;

Func: IsGlobalInSmallSection


Template_token: <s> return Size > <NUM_LIT> && Size

ground_truth: <= <NUM_LIT> ;

Func: IsInSmallSection


Template_token: <s> static bool IsInSmallSection ( uint64_t Size ) { return Size > <NUM_LIT> && Size


Template_token: <s> if ( Kind . isBSS ( ) && IsGlobalInSmallSection ( GV , TM , Kind ) ) return SmallBSSSection ; if ( Kind . isDataNoRel ( ) && IsGlobalInSmallSection ( GV ,

ground_truth: TM , Kind ) ) return SmallDataSection ;

Func: SelectSectionForGlobal