<s> <ISA_LIT>MCInstLower MCInstLowering ( OutContext , * this ) ; MachineBasicBlock :: const_instr_iterator I = MI -> getIterator ( ) ; MachineBasicBlock :: const_instr_iterator E = MI -> getParent ( ) -> instr_end ( ) ; do { MCInst TmpInst ; MCInstLowering . Lower ( & * I ,


<s> void <ISA_LIT>AsmPrinter :: EmitStartOfAsmFile ( Module & module ) { OutStreamer -> EmitRawText


<s> StringRef getPassName ( ) const override { return


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


<s> StringRef getPassName ( ) const override


<s> return MachineFunctionProperties ( ) . set ( MachineFunctionProperties :: Property ::


<s> const <ISA_LIT>InstrInfo & TII = * static_cast < const <ISA_LIT>InstrInfo * > ( F . getSubtarget ( ) . getInstrInfo ( ) ) ; for ( auto & BB : F ) { for ( MachineBasicBlock :: iterator I = BB . begin ( ) ; I != BB . end ( ) ; ) { MachineInstr & MI = * I ; DebugLoc DL = MI . getDebugLoc ( ) ; unsigned Opc = MI . getOpcode ( ) ; unsigned FiOpc = TII . getFiFromFiMalkrz ( Opc ) ; if ( FiOpc != <STR_LIT> ) { DEBUG ( dbgs ( ) << <STR_LIT> ) ; DEBUG ( MI . dump ( ) ) ; MIBundleBuilder Bundle ( BB , I ) ; unsigned MalkrzOpc = TII . getMalkrzFromFiMalkrz ( Opc ) ; unsigned MalkrzNumOperands = TII . get ( MalkrzOpc ) . getNumOperands ( ) ; MachineInstrBuilder Malkrz = BuildMI ( F , DL , TII . get ( MalkrzOpc ) ) ; for ( unsigned i = <NUM_LIT> ; i < MalkrzNumOperands ; i ++ ) { Malkrz . add ( MI . getOperand ( i ) ) ; } Bundle . prepend ( Malkrz ) ; unsigned FiNumOperands = TII . get ( FiOpc ) . getNumOperands ( ) ; MachineInstrBuilder Fi = BuildMI ( F , DL , TII . get ( FiOpc ) ) ; for ( unsigned i = <NUM_LIT> ; i < FiNumOperands ; i ++ ) { Fi . add ( MI . getOperand ( i + MalkrzNumOperands ) ) ; } Bundle . prepend ( Fi ) ; I = BB . erase ( MI ) ; } else { ++ I


<s> if ( FiOpc != <STR_LIT> ) { DEBUG ( dbgs ( ) << <STR_LIT> ) ; DEBUG ( MI . dump ( ) ) ; MIBundleBuilder Bundle ( BB , I ) ; unsigned MalkrzOpc = TII . getMalkrzFromFiMalkrz ( Opc ) ; unsigned MalkrzNumOperands = TII . get ( MalkrzOpc ) . getNumOperands ( ) ; MachineInstrBuilder Malkrz = BuildMI ( F , DL , TII . get ( MalkrzOpc ) ) ; for ( unsigned i = <NUM_LIT> ; i < MalkrzNumOperands ; i ++ ) { Malkrz . add ( MI . getOperand ( i ) ) ; } Bundle . prepend ( Malkrz ) ; unsigned FiNumOperands = TII . get ( FiOpc ) . getNumOperands ( ) ; MachineInstrBuilder Fi = BuildMI ( F , DL , TII . get ( FiOpc ) ) ; for ( unsigned i = <NUM_LIT> ; i < FiNumOperands ; i ++ ) { Fi . add ( MI . getOperand ( i + MalkrzNumOperands ) ) ; } Bundle . prepend ( Fi )


<s> MachineBasicBlock :: iterator <ISA_LIT>FrameLowering :: eliminateCallFramePseudoInstr ( MachineFunction & MF , MachineBasicBlock & MBB , MachineBasicBlock :: iterator I ) const { const <ISA_LIT>InstrInfo & TII = * static_cast < const <ISA_LIT>InstrInfo * > ( MF . getSubtarget ( ) . getInstrInfo ( ) ) ; MachineInstr & Old = * I ; DebugLoc DL = Old . getDebugLoc ( ) ; unsigned Amount = TII . getFrameSize ( Old ) ; if ( Amount != <NUM_LIT> ) { unsigned Opc = Old . getOpcode ( ) ; if ( Opc == <STR_LIT> ) { BuildMI ( MBB , I , DL , TII . get ( <STR_LIT> ) , <STR_LIT> ) . addReg ( <STR_LIT> ) . addImm ( Amount ) ; } else { assert ( Opc == <STR_LIT> ) ; BuildMI ( MBB , I , DL , TII . get ( <STR_LIT> ) , <STR_LIT> ) . addReg ( <STR_LIT> ) . addImm ( Amount ) ; } } return MBB . erase ( I


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


<s> <STR_LIT> CC = ( <STR_LIT> ) MI -> getOperand ( OpNo ) . getImm ( ) ; O << <ISA_LIT>CCToString (


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


<s> const MCOperand & dispReg = MI -> getOperand ( OpNo + <NUM_LIT> ) ; const MCOperand & dispImm = MI -> getOperand ( OpNo + <NUM_LIT> ) ; printOperand ( MI , OpNo , O ) ; if ( dispReg . getReg ( ) ) { O << '+' ; printOperand ( MI , OpNo + <NUM_LIT> , O ) ; } if ( dispImm . isImm ( ) ) { if ( dispImm . getImm ( ) ) { O << '+' ; printOperand ( MI , OpNo +


<s> } else if ( Op . isImm ( ) ) { O << ( uint32_t ) Op . getImm ( ) ; } else { assert ( Op . isExpr ( ) && <STR_LIT> ) ; Op . getExpr ( ) -> print ( O ,


<s> TBB = I -> getOperand ( <NUM_LIT> ) . getMBB ( ) ; continue ; } assert ( getMalkrzFromFiMalkrz ( I -> getOpcode ( ) ) == <STR_LIT> && <STR_LIT> ) ; if ( Cond . empty ( ) ) { FBB = TBB ; TBB = I -> getOperand ( <NUM_LIT> ) . getMBB ( ) ; Cond . push_back ( MachineOperand :: CreateImm ( I -> getOpcode ( ) ) ) ; for ( unsigned i = <NUM_LIT> ; i < I -> getNumOperands ( ) ; i ++ ) { Cond . push_back ( I -> getOperand ( i


<s> -- I ; if ( I -> isDebugValue ( ) ) continue ; if ( ! isUnpredicatedTerminator ( * I ) ) break ; if ( ! I -> isBranch ( ) ) return true ; if ( I -> isIndirectBranch ( ) ) return true ; if ( I -> getOpcode ( ) == <STR_LIT> ) { if ( ! AllowModify ) { TBB = I -> getOperand ( <NUM_LIT> ) . getMBB ( ) ; continue ; } while ( std :: next ( I ) != MBB . end ( ) ) std :: next ( I ) -> eraseFromParent ( ) ; Cond . clear


<s> void <ISA_LIT>InstrInfo :: copyPhysReg ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator I , const DebugLoc & DL , unsigned DestReg , unsigned SrcReg , bool KillSrc ) const { BuildMI ( MBB , I , DL , get ( <STR_LIT> ) , DestReg ) . addReg ( SrcReg , getKillRegState


<s> unsigned <ISA_LIT>InstrInfo :: getFiFromFiMalkrz ( unsigned Opc ) const { switch ( Opc ) { default : return <STR_LIT> ; case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : case <STR_LIT> : return


<s> assert ( I . getOperand ( <NUM_LIT> ) . getImm ( ) >= <NUM_LIT>


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


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


<s> void <ISA_LIT>InstrInfo :: getNoop ( MCInst & NopInst ) const { NopInst . setOpcode ( <STR_LIT> )


<s> const <ISA_LIT>RegisterInfo & getRegisterInfo ( )


<s> assert ( ( Cond . empty ( ) || ( getMalkrzFromFiMalkrz ( Cond [ <NUM_LIT> ] . getImm ( ) ) == <STR_LIT> && get ( Cond [ <NUM_LIT> ] . getImm ( ) ) . getNumOperands ( ) == Cond . size ( ) ) ) && <STR_LIT> ) ; assert ( ! BytesAdded && <STR_LIT> ) ; if ( Cond . empty ( ) ) { assert ( ! FBB && <STR_LIT> ) ; BuildMI ( & MBB , DL , get ( <STR_LIT> ) ) . addMBB ( TBB ) ; return <NUM_LIT> ; } unsigned Count = <NUM_LIT> ; MachineInstrBuilder Malkrz = BuildMI ( & MBB , DL , get ( Cond [ <NUM_LIT> ] . getImm ( ) ) ) . addMBB ( TBB ) ; for ( unsigned i = <NUM_LIT> ; i < Cond . size ( ) ; i ++ ) { Malkrz . add ( Cond [ i ] ) ; } ++ Count ; if ( FBB ) { BuildMI ( & MBB , DL , get ( <STR_LIT> ) ) . addMBB ( FBB ) ; ++ Count


<s> if ( MI . isBranch ( ) && ! MI . isBarrier ( ) ) return true ; if ( ! MI . isPredicable ( ) ) return true ; return ! isPredicated (


<s> bool <ISA_LIT>InstrInfo :: isUnpredicatedTerminator ( const MachineInstr & MI ) const { if ( ! MI . isTerminator


<s> void <ISA_LIT>InstrInfo :: loadRegFromStackSlot ( MachineBasicBlock & MBB , MachineBasicBlock :: iterator MI , unsigned DestReg , int FrameIdx , const TargetRegisterClass * RC , const TargetRegisterInfo * TRI ) const { DebugLoc DL ; if ( MI != MBB . end ( ) ) DL = MI -> getDebugLoc ( ) ; MachineFunction & MF = * MBB . getParent ( ) ; MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; MachineMemOperand * MMO = MF . getMachineMemOperand ( MachinePointerInfo :: getFixedStack ( MF , FrameIdx ) , MachineMemOperand :: MOLoad , MFI . getObjectSize ( FrameIdx ) , MFI . getObjectAlignment ( FrameIdx ) ) ; BuildMI ( MBB , MI , DL , get ( <STR_LIT> ) ) . addReg ( DestReg , getDefRegState ( true ) ) . addFrameIndex ( FrameIdx ) . addReg ( <NUM_LIT> )

. addImm ( <NUM_LIT> ) . addMemOperand ( MMO ) ;


<s> <STR_LIT> CC = static_cast < <STR_LIT> > ( Cond . back ( ) . getImm ( ) ) ; Cond . back ( ) = MachineOperand ::

CreateImm ( Opposite<ISA_LIT>CC ( CC ) ) ;


<s> MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; MachineMemOperand * MMO = MF . getMachineMemOperand ( MachinePointerInfo :: getFixedStack ( MF , FrameIdx ) , MachineMemOperand :: MOStore , MFI . getObjectSize ( FrameIdx ) , MFI . getObjectAlignment ( FrameIdx ) ) ; BuildMI ( MBB , MI , DL , get ( <STR_LIT> ) ) . addFrameIndex ( FrameIdx ) . addReg ( <NUM_LIT> ) . addImm ( <NUM_LIT> ) . addReg ( SrcReg , getKillRegState ( isKill ) )


<s> return new <ISA_LIT>DAGToDAGISel ( TM ,


<s> StringRef getPassName ( ) const override { return


<s> void <ISA_LIT>DAGToDAGISel :: Select ( SDNode * Node ) { SDLoc dl ( Node ) ; if ( Node -> isMachineOpcode ( ) ) { Node -> setNodeId ( - <NUM_LIT> ) ; return ; } switch ( Node -> getOpcode ( ) ) { default : break ; case <STR_LIT> : { int FI = cast < FrameIndexSDNode > ( Node ) -> getIndex ( ) ; SDValue TFI = CurDAG -> getTargetFrameIndex ( FI , TLI -> getPointerTy ( CurDAG -> getDataLayout ( ) ) ) ; CurDAG -> SelectNodeTo ( Node , <STR_LIT> , <STR_LIT> , TFI , CurDAG -> getTargetConstant ( <NUM_LIT> , dl , <STR_LIT> ) ) ; return ; } } SelectCode (


<s> default : break ; case <STR_LIT> : { int FI = cast < FrameIndexSDNode > ( Node ) -> getIndex ( ) ; SDValue TFI = CurDAG -> getTargetFrameIndex ( FI , TLI -> getPointerTy ( CurDAG -> getDataLayout ( ) ) ) ; CurDAG -> SelectNodeTo ( Node , <STR_LIT> , <STR_LIT> , TFI , CurDAG -> getTargetConstant ( <NUM_LIT>


<s> case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; case <STR_LIT> : return <STR_LIT> ; default : llvm_unreachable (


<s> SDValue TargetCC = DAG . getTargetConstant ( get<ISA_LIT>CC ( CC ) , dl , <STR_LIT> ) ; SDValue Ops [ ] = { Chain , Dest , LHS , RHS , TargetCC } ; return DAG . getNode ( <STR_LIT> , dl ,


<s> SmallVector < CCValAssign , <NUM_LIT> > ArgLocs ; CCState CCInfo ( CallConv , isVarArg , DAG . getMachineFunction ( ) , ArgLocs , * DAG . getContext ( ) ) ; CCInfo . AnalyzeCallOperands ( Outs , CC_<ISA_LIT> ) ; unsigned NumBytes = CCInfo . getNextStackOffset ( ) + <NUM_LIT> ; auto PtrVT = getPointerTy ( DAG . getDataLayout ( ) ) ; Chain = DAG . getCALLSEQ_START ( Chain , NumBytes , <NUM_LIT> , dl ) ; SmallVector < std :: pair < unsigned , SDValue > , <NUM_LIT> > RegsToPass ; SmallVector < SDValue , <NUM_LIT> > MemOpChains ; SDValue StackPtr ; for ( unsigned i = <NUM_LIT> , e = ArgLocs . size ( ) ; i != e ; ++ i ) { CCValAssign & VA = ArgLocs [ i ] ; SDValue Arg = OutVals [ i ] ; switch ( VA . getLocInfo ( ) ) { default : llvm_unreachable ( <STR_LIT> ) ; case CCValAssign :: Full : break ; case CCValAssign :: SExt : Arg = DAG . getNode ( <STR_LIT> , dl , VA . getLocVT ( ) , Arg ) ; break ; case CCValAssign :: ZExt : Arg = DAG . getNode ( <STR_LIT> , dl , VA . getLocVT ( ) , Arg ) ; break ; case CCValAssign :: AExt : Arg = DAG . getNode ( <STR_LIT> , dl , VA . getLocVT ( ) , Arg ) ; break ; } if ( VA . isRegLoc ( ) ) { RegsToPass . push_back ( std :: make_pair ( VA . getLocReg ( ) , Arg ) ) ; } else { assert ( VA . isMemLoc ( ) ) ; if ( ! StackPtr . getNode ( ) ) StackPtr = DAG . getCopyFromReg ( Chain , dl , <STR_LIT> , PtrVT ) ; unsigned offset = NumBytes - VA . getLocMemOffset ( ) - VA . getLocVT ( ) . getSizeInBits ( ) / <NUM_LIT> ; SDValue PtrOff = DAG . getNode ( <STR_LIT> , dl , PtrVT , StackPtr , DAG . getIntPtrConstant ( offset , dl ) ) ; SDValue MemOp ; <STR_LIT> Flags = Outs [ i ] . Flags ; if ( Flags . isByVal (


<s> MemOp = DAG . getMemcpy ( Chain , dl , PtrOff , Arg , SizeNode , Flags . getByValAlign ( ) , false , true , false , MachinePointerInfo ( ) , MachinePointerInfo ( ) ) ; } else { MemOp = DAG . getStore ( Chain , dl , Arg , PtrOff , MachinePointerInfo ( ) ) ; } MemOpChains . push_back ( MemOp ) ; } } 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 , <STR_LIT> ) ; else if ( ExternalSymbolSDNode * E = dyn_cast < ExternalSymbolSDNode > ( Callee ) ) Callee = DAG . getTargetExternalSymbol ( E -> getSymbol ( ) , <STR_LIT> ) ; 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 ) Ops . push_back ( DAG . getRegister ( RegsToPass [ i ] . first , RegsToPass [ i ] . second . getValueType ( ) ) ) ; const <ISA_LIT>RegisterInfo * TRI = Subtarget -> getRegisterInfo ( ) ; Ops . push_back ( DAG . getRegisterMask ( TRI -> getCallPreservedMask ( DAG . getMachineFunction ( ) , CallConv ) ) ) ; if ( InFlag . getNode ( ) ) Ops . push_back ( InFlag


<s> for ( unsigned i = <NUM_LIT> ; i != RVLocs . size ( ) ; ++ i ) { Chain = DAG . getCopyFromReg ( Chain , dl , RVLocs [ i ] . getLocReg ( ) , RVLocs [ i ] . getValVT ( ) , InFlag ) . getValue ( <NUM_LIT> ) ; InFlag = Chain . getValue ( <NUM_LIT> ) ; InVals . push_back ( Chain . getValue ( <NUM_LIT> ) ) ; } return


<s> Chain = DAG . getCopyFromReg ( Chain , dl , RVLocs [ i ] . getLocReg ( ) , RVLocs [ i ] . getValVT ( ) , InFlag ) . getValue ( <NUM_LIT> ) ; InFlag = Chain . getValue ( <NUM_LIT> ) ; InVals . push_back ( Chain . getValue ( <NUM_LIT> ) ) ; } return Chain


<s> int64_t Offset = cast < GlobalAddressSDNode > ( Op ) -> getOffset ( ) ; auto PtrVT = getPointerTy ( DAG . getDataLayout ( ) ) ; SDValue Result = DAG . getTargetGlobalAddress (


<s> SDValue <ISA_LIT>TargetLowering :: LowerGlobalAddress ( SDValue Op , SelectionDAG & DAG ) const { SDLoc dl ( Op ) ; const GlobalValue * GV = cast < GlobalAddressSDNode > ( Op ) -> getGlobal ( ) ; int64_t Offset = cast < GlobalAddressSDNode > ( Op ) -> getOffset ( ) ; auto PtrVT = getPointerTy ( DAG . getDataLayout ( ) ) ; SDValue Result = DAG . getTargetGlobalAddress ( GV , dl , PtrVT ) ; Result = DAG . getNode ( <STR_LIT> , SDLoc ( Op ) , PtrVT , Result ) ; if ( Offset


<s> SDValue <ISA_LIT>TargetLowering :: LowerJumpTable ( SDValue Op , SelectionDAG & DAG ) const { SDLoc dl ( Op ) ; JumpTableSDNode * JT = cast < JumpTableSDNode > ( Op ) ; auto PtrVT = getPointerTy ( DAG . getDataLayout ( ) ) ; SDValue Result = DAG . getTargetJumpTable ( JT ->


<s> SDValue <ISA_LIT>TargetLowering :: LowerOperation ( SDValue Op , SelectionDAG & DAG ) const { switch ( Op . getOpcode ( ) ) { case <STR_LIT> : return LowerSELECT_CC ( Op , DAG ) ; case <STR_LIT> : return LowerBR_CC ( Op , DAG ) ; case <STR_LIT> : return LowerGlobalAddress ( Op , DAG ) ; case <STR_LIT> : return LowerBlockAddress ( Op , DAG ) ; case <STR_LIT> : return LowerExternalSymbol ( Op , DAG ) ; case <STR_LIT> : return LowerJumpTable ( Op


<s> <STR_LIT> CC = cast < CondCodeSDNode > ( Op . getOperand ( <NUM_LIT> ) ) -> get ( ) ; SDLoc dl ( Op ) ; SDValue TargetCC = DAG . getTargetConstant ( get<ISA_LIT>CC ( CC ) , dl , <STR_LIT> ) ; SDValue Ops [ ] = { FalseV , TrueV , LHS , RHS ,


<s> Data32bitsDirective = <STR_LIT> ; Data64bitsDirective = nullptr ; GlobalDirective = <STR_LIT> ; HasFunctionAlignment = false ; HasDotTypeDotSizeDirective = false ; HasSingleParameterDotFile = false


<s> IsLittleEndian = false ; SeparatorString = <STR_LIT> ; CommentString = <STR_LIT> ; PrivateGlobalPrefix = <STR_LIT> ; PrivateLabelPrefix = <STR_LIT> ; LinkerPrivateGlobalPrefix = <STR_LIT> ; InlineAsmStart = <STR_LIT>


<s> OS << <STR_LIT> ; } else if ( isAcceptableChar ( C ) ) { OS << C ; } else if ( C >= 'A' && C <= 'Z' ) { OS << '\'' << ( char ) (


<s> T . toVector ( CommentToEmit ) ; if ( EOL ) CommentToEmit . push_back


<s> if ( ! IsVerboseAsm ) return ; T . toVector ( CommentToEmit ) ; if ( EOL ) CommentToEmit . push_back


<s> void <ISA_LIT>MCAsmStreamer :: addExplicitComment ( const Twine & T ) { StringRef c = T . getSingleStringRef ( ) ; if ( c . startswith ( StringRef ( MAI -> getCommentString ( ) ) ) ) { ExplicitCommentToEmit . append ( c . str ( ) ) ; }


<s> void <ISA_LIT>MCAsmStreamer :: ChangeSection ( MCSection * Section , const MCExpr * Subsection ) { flushValues (


<s> void <ISA_LIT>MCAsmStreamer :: EmitBundleAlignMode ( unsigned


<s> void <ISA_LIT>MCAsmStreamer :: EmitBundleUnlock


<s> void <ISA_LIT>MCAsmStreamer :: EmitBytes ( StringRef Data ) { for ( unsigned i = <NUM_LIT> , e = Data . size ( ) ; i != e ; ++ i ) { EmitValue ( MCConstantExpr :: create ( ( unsigned char ) Data [ i ]


<s>
OS
<<
MAI
->
getCommentString
(
)
<<
' '
<<
Comments
.
substr
(
<NUM_LIT>
,
Position
)
<<
'\n'
;
Comments
=
Comments
.
substr
(
Position
+
<NUM_LIT>
)
;
}
while
(
!
Comments


<s> if ( ! IsVerboseAsm ) { OS << '\n' ; return ; } EmitCommentsAndEOL (


<s> void <ISA_LIT>MCAsmStreamer :: EmitIntValue ( uint64_t


<s> raw_string_ostream TempStream ( Name ) ; Symbol -> print ( TempStream , MAI ) ; } LabelToEmit . append ( <STR_LIT> ) ; LabelToEmit . append


<s> void <ISA_LIT>MCAsmStreamer :: EmitRawTextImpl ( StringRef String ) { if ( ! String . empty ( ) && String . back ( ) == '\n' ) String = String . substr ( <NUM_LIT> , String . size ( ) - <NUM_LIT> ) ; OS <<


<s> OS << MAI -> getGlobalDirective ( ) ; break ; } Symbol -> print ( OS , MAI ) ; EmitEOL (


<s> void <ISA_LIT>MCAsmStreamer :: EmitThumbFunc ( MCSymbol


<s> void <ISA_LIT>MCAsmStreamer :: EmitThumbFunc ( MCSymbol * Func ) { llvm_unreachable ( <STR_LIT> )


<s> void <ISA_LIT>MCAsmStreamer :: EmitValueToAlignment ( unsigned ByteAlignment , int64_t Value , unsigned ValueSize , unsigned MaxBytesToEmit ) { if ( ByteAlignment == <NUM_LIT> || ByteAlignment == <NUM_LIT> || ByteAlignment == <NUM_LIT> ) { CurrentAlignmentToValue = ByteAlignment ; return ; } if ( ByteAlignment % <NUM_LIT> == <NUM_LIT>


<s> void <ISA_LIT>MCAsmStreamer :: EmitValueWithAlignment ( const MCExpr * Value , unsigned Size , SMLoc Loc ) { const char * Directive = nullptr ; switch ( Size ) { default : break ; case <NUM_LIT> : Directive = MAI -> getData8bitsDirective ( ) ; break ; case <NUM_LIT> : Directive = MAI -> getData16bitsDirective (


<s> void <ISA_LIT>MCAsmStreamer :: EmitWeakReference ( MCSymbol * Alias , const MCSymbol * Symbol ) { llvm_unreachable (


<s> void <ISA_LIT>MCAsmStreamer :: EmitWeakReference ( MCSymbol * Alias


<s> <ISA_LIT>MCAsmStreamer :: <ISA_LIT>MCAsmStreamer ( MCContext & Ctx , std :: unique_ptr < formatted_raw_ostream > os , bool isVerboseAsm , MCInstPrinter * printer , bool showInst ) : MCStreamer ( Ctx ) , OSOwner ( std :: move ( os ) ) , OS ( * OSOwner ) , MAI ( Ctx . getAsmInfo ( ) ) , InstPrinter ( printer ) , CommentStream ( CommentToEmit ) , IsVerboseAsm ( isVerboseAsm ) , ShowInst ( showInst ) { assert (


<s> StringRef label = LabelToEmit ; if ( ! label . empty ( ) ) { if ( addFen


<s> ValueToEmit = ( ValueToEmit << <NUM_LIT> ) | ValueBuffer [ i ] ; } ValueToEmit <<= ( CurrentAlignmentToValue - ValueBuffer . size ( ) ) * <NUM_LIT> ; EmitValueWithAlignment ( MCConstantExpr :: create ( ValueToEmit , getContext ( ) ) , CurrentAlignmentToValue ) ; ValueBuffer . clear


<s> raw_ostream & <ISA_LIT>MCAsmStreamer :: GetCommentOS (


<s> void <ISA_LIT>MCAsmStreamer :: reset ( ) { LabelToEmit . clear ( ) ; ExplicitCommentToEmit . clear ( ) ; CommentToEmit . clear ( ) ; Symbols . clear ( ) ; CurrentAlignmentToValue =


<s> Symbol . setIsRegistered ( true ) ; Symbols . push_back ( &


<s> MCOp = MCOperand :: createExpr ( MCSymbolRefExpr :: create ( MO . getMBB ( ) -> getSymbol ( ) , Ctx ) ) ; break ; case MachineOperand :: MO_GlobalAddress : MCOp = LowerSymbolOperand ( MO , Printer . getSymbol ( MO . getGlobal ( ) ) ) ; break ; case MachineOperand :: MO_ExternalSymbol : MCOp = LowerSymbolOperand ( MO , Printer . GetExternalSymbolSymbol ( MO . getSymbolName ( ) ) ) ; break ; case MachineOperand :: MO_JumpTableIndex : MCOp = LowerSymbolOperand ( MO , Printer . GetJTISymbol ( MO . getIndex ( ) ) ) ; break ; case MachineOperand :: MO_ConstantPoolIndex : MCOp = LowerSymbolOperand ( MO , Printer . GetCPISymbol ( MO . getIndex ( ) ) ) ; break ; case MachineOperand :: MO_BlockAddress : MCOp = LowerSymbolOperand ( MO , Printer . GetBlockAddressSymbol ( MO . getBlockAddress ( ) ) ) ; break ; case MachineOperand :: MO_RegisterMask : continue ; } OutMI . addOperand (


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


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


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


<s> void LLVMInitialize<ISA_LIT>TargetMC ( ) { RegisterMCAsmInfo < <ISA_LIT>MCAsmInfo > X ( getThe<ISA_LIT>Target ( ) ) ; TargetRegistry :: RegisterMCInstrInfo ( getThe<ISA_LIT>Target ( ) , create<ISA_LIT>MCInstrInfo ) ; TargetRegistry :: RegisterMCRegInfo ( getThe<ISA_LIT>Target (


<s> Offset += MF . getFrameInfo ( ) . getStackSize ( ) ; Offset += SPAdj ; if ( MI . getOpcode ( ) == <STR_LIT> ) { Offset += MI . getOperand ( FIOperandNum + <NUM_LIT> ) . getImm ( ) ; const TargetInstrInfo & TII = * MF . getSubtarget ( ) . getInstrInfo ( ) ; MI . setDesc ( TII . get ( <STR_LIT> ) ) ; MI . getOperand ( FIOperandNum ) . ChangeToRegister ( <STR_LIT> , false ) ; MI . RemoveOperand ( FIOperandNum + <NUM_LIT> ) ; if ( Offset ==


<s> MachineFunction & MF = * MBB . getParent ( ) ; DebugLoc dl = MI . getDebugLoc ( ) ; int FrameIndex = MI . getOperand ( FIOperandNum ) . getIndex ( ) ; int Offset = MF . getFrameInfo ( ) . getObjectOffset ( FrameIndex ) ; Offset += MF . getFrameInfo ( ) . getStackSize ( ) ; Offset += SPAdj ; if ( MI . getOpcode ( ) == <STR_LIT> ) { Offset += MI . getOperand ( FIOperandNum + <NUM_LIT> ) . getImm ( ) ; const TargetInstrInfo & TII = * MF . getSubtarget ( ) . getInstrInfo ( ) ; MI . setDesc ( TII . get ( <STR_LIT> ) ) ; MI . getOperand ( FIOperandNum ) . ChangeToRegister ( <STR_LIT> , false ) ; MI . RemoveOperand ( FIOperandNum + <NUM_LIT> ) ; if ( Offset == <NUM_LIT> ) { return ; } unsigned DstReg = MI . getOperand ( <NUM_LIT> ) . getReg ( ) ; BuildMI ( MBB , std :: next ( II ) , dl , TII . get ( <STR_LIT> ) , DstReg ) . addReg ( DstReg ) . addImm ( Offset ) ; return ; } if ( MI . getOperand ( FIOperandNum + <NUM_LIT> ) . isImm ( ) ) { Offset += ( int32_t ) MI . getOperand ( FIOperandNum + <NUM_LIT> ) . getImm ( ) ; } MI . getOperand ( FIOperandNum ) . ChangeToRegister (


<s> unsigned <ISA_LIT>RegisterInfo :: getFrameRegister ( const


<s> const TargetRegisterClass * <ISA_LIT>RegisterInfo :: getPointerRegClass ( const MachineFunction & MF , unsigned Kind ) const { return &


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


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


<s> const TargetFrameLowering * getFrameLowering ( ) const override


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


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


<s> const <ISA_LIT>RegisterInfo * getRegisterInfo ( ) const override { return & InstrInfo .


<s> const SelectionDAGTargetInfo * getSelectionDAGInfo ( ) const


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


<s> <ISA_LIT>Subtarget & <ISA_LIT>Subtarget :: initializeSubtargetDependencies ( StringRef CPU , StringRef FS ) { std :: string CPUName = CPU ; if ( CPUName . empty ( )


<s> if ( CPUName . empty ( ) ) CPUName = <STR_LIT> ; ParseSubtargetFeatures ( CPUName


<s> Target & llvm :: getThe<ISA_LIT>Target ( ) { static Target The<ISA_LIT>Target ; return The<ISA_LIT>Target


<s> RegisterTarget < Triple :: f2003f > X ( getThe<ISA_LIT>Target ( ) ,


<s> void LLVMInitialize<ISA_LIT>TargetInfo ( ) { RegisterTarget < Triple :: f2003f > X ( getThe<ISA_LIT>Target ( ) , <STR_LIT>


<s> addPass ( create<ISA_LIT>ISelDag ( get<ISA_LIT>TargetMachine ( ) , getOptLevel ( ) ) ) ; return


<s> addPass ( create<ISA_LIT>FiMalkrzPass ( ) )


<s> addPass ( create<ISA_LIT>FiMalkrzPass (


<s> MCStreamer * S = new <ISA_LIT>MCAsmStreamer ( Context , std :: move ( FOut ) , Options . MCOptions . AsmVerbose , InstPrinter , Options . MCOptions . ShowMCInst ) ; return S


<s> MCStreamer * <ISA_LIT>TargetMachine :: createMCStreamerToAsm ( MCContext & Context , std :: unique_ptr < formatted_raw_ostream > FOut , MCInstPrinter * InstPrinter , MCCodeEmitter * MCE , MCAsmBackend * MAB ) { MCStreamer * S = new <ISA_LIT>MCAsmStreamer ( Context , std :: move ( FOut ) , Options . MCOptions . AsmVerbose , InstPrinter


<s> <ISA_LIT>TargetMachine :: <ISA_LIT>TargetMachine ( const Target & T , const Triple & TT , StringRef CPU , StringRef FS , const TargetOptions & Options , Optional < Reloc :: Model > RM , CodeModel :: Model CM , CodeGenOpt :: Level OL ) : LLVMTargetMachine ( T ,

computeDataLayout ( TT , CPU , Options ) , TT , CPU , FS , Options , getEffectiveRelocModel ( RM ) , CM , OL ) , TLOF ( make_unique < TargetLoweringObjectFileELF > ( ) ) , Subtarget ( TT , CPU , FS , * this ) {


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


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


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


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


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


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