<s> for ( MCSuperRegIterator Super ( Reg , this ) ; Super . isValid ( ) ; ++ Super ) if ( RC -> contains ( * Super ) ) return * Super ; return <NUM_LIT> ;


<s> for ( MCSuperRegIterator Super ( Reg , this ) ; Super . isValid ( ) ; ++ Super ) if ( RC -> contains ( * Super ) ) return * Super ;


<s> assert ( isPhysicalRegister ( reg ) && <STR_LIT> ) ; const TargetRegisterClass * BestRC = nullptr ; for ( regclass_iterator I = regclass_begin ( ) , E = regclass_end ( ) ; I != E ; ++ I ) { const TargetRegisterClass * RC = * I ; if ( ( VT == <STR_LIT> || isTypeLegalForClass ( * RC , VT ) ) && RC -> contains ( reg ) && ( ! BestRC || ( BestRC -> hasSubClass ( RC ) && RC -> getNumRegs ( ) > BestRC -> getNumRegs ( ) ) ) ) BestRC = RC ; } assert ( BestRC && <STR_LIT> ) ; return BestRC ;


<s> int <ISA_LIT>RegisterInfo :: getRegisterOrder ( unsigned Reg , const TargetRegisterClass & TRC ) const { for ( unsigned i = <NUM_LIT> ; i < TRC . getNumRegs ( ) ; ++ i ) { if ( regsOverlap ( Reg , TRC . getRegister ( i ) ) ) { return i ; } }


<s> const TargetRegisterClass * <ISA_LIT>RegisterInfo :: getRegsForTailCall ( const MachineFunction & MF ) const { return & <STR_LIT> ;


<s> Reserved . set ( * I ) ; } for ( MCSubRegIterator I ( Reg , this , true ) ; I . isValid ( ) ; ++ I ) { Reserved . set ( * I ) ; } } ; setBitVector ( <STR_LIT> ) ; setBitVector ( <STR_LIT> ) ;


<s> if ( hasBasePointer ( MF ) ) { CallingConv :: ID CC = MF . getFunction ( ) . getCallingConv ( ) ; const uint32_t * RegMask = getCallPreservedMask ( MF , CC ) ; if ( MachineOperand :: clobbersPhysReg ( RegMask , getBaseRegister ( ) ) ) report_fatal_error ( <STR_LIT> <STR_LIT> <STR_LIT> ) ;


<s> int <ISA_LIT>RegisterInfo :: getSpillRegisterOrder ( unsigned Reg ) const { int Result = getRegisterOrder ( Reg , * getRegClass ( <STR_LIT> ) ) ; if ( Result < <NUM_LIT> ) { llvm_unreachable ( <STR_LIT> ) ;


<s> unsigned getSpillSize ( const TargetRegisterClass & RC ) const override { return <NUM_LIT> ;


<s> unsigned getStackRegister ( ) const { return StackPtr ;


<s> if ( ! EnableBasePointer ) return false ;

bool CantUseFP = needsStackRealignment ( MF ) ;


<s> const MachineFrameInfo & MFI = MF . getFrameInfo ( ) ; if ( ! EnableBasePointer ) return false ;


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


<s> void <ISA_LIT>Subtarget :: anchor ( ) {


<s> unsigned char <ISA_LIT>Subtarget :: classifyBlockAddressReference ( ) const {


<s> classifyExternalReference ( const Module & M ) const { if ( TM . shouldAssumeDSOLocal ( M , nullptr ) ) return classifyLocalReference ( nullptr ) ;


<s> classifyGlobalFunctionReference ( const GlobalValue * GV , const Module & M ) const { if ( TM . shouldAssumeDSOLocal ( M , GV ) ) return <STR_LIT> ;

auto * F = dyn_cast_or_null < Function > ( GV ) ;


<s> case CodeModel :: Kernel : { if ( isPositionIndependent ( ) ) { return <STR_LIT> ; } else { return <STR_LIT> ; } } case CodeModel :: Medium : { if ( isPositionIndependent ( ) ) {


<s> default : llvm_unreachable ( <STR_LIT> ) ; case CodeModel :: Small : case CodeModel :: Kernel : { return <STR_LIT> ; } case CodeModel :: Medium : { if ( isPositionIndependent ( ) ) { if ( IsM68020 ) {


<s> case CodeModel :: Small : case CodeModel :: Kernel : { return <STR_LIT> ; } case CodeModel :: Medium : { if ( isPositionIndependent ( ) ) { if ( IsM68020 ) { return <STR_LIT> ; } return <STR_LIT> ; } else { if ( IsM68020 ) {


<s> const <ISA_LIT>FrameLowering * getFrameLowering ( ) const override { return & FrameLowering ;


<s> const <ISA_LIT>FrameLowering * getFrameLowering ( ) const override {


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


<s> if ( TM . getCodeModel ( ) == CodeModel :: Medium && ! isM68020 ( ) ) return MachineJumpTableInfo :: EK_Custom32 ;

return MachineJumpTableInfo :: EK_LabelDifference32 ;


<s> getJumpTableEncoding ( ) const { if ( isPositionIndependent ( ) ) { if ( TM . getCodeModel ( ) == CodeModel :: Medium && ! isM68020 ( ) ) return MachineJumpTableInfo :: EK_Custom32 ; return MachineJumpTableInfo :: EK_LabelDifference32 ; }

return MachineJumpTableInfo :: EK_BlockAddress ;


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

return & InstrInfo . getRegisterInfo ( ) ;


<s> const SelectionDAGTargetInfo * getSelectionDAGInfo ( ) const override { return & TSInfo ;


<s> unsigned getSlotSize ( ) const { return <NUM_LIT> ;


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


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


<s> initializeSubtargetDependencies ( StringRef CPU , Triple TT , StringRef FS , const <ISA_LIT>TargetMachine & TM ) { std :: string CPUName = select<ISA_LIT>CPU ( TT , CPU ) ; IsM68000 = true ; InstrItins = getInstrItineraryForCPU ( CPUName ) ; stackAlignment = <NUM_LIT> ;


<s> initializeSubtargetDependencies ( StringRef CPU , Triple TT , StringRef FS , const <ISA_LIT>TargetMachine & TM ) { std :: string CPUName = select<ISA_LIT>CPU ( TT , CPU ) ; IsM68000 = true ; InstrItins = getInstrItineraryForCPU ( CPUName ) ;


<s> isLegalToCallImmediateAddr ( ) const { return true ;


<s> isLegalToCallImmediateAddr ( ) const {


<s> bool isM68010 ( ) const { return IsM68010 ;


<s> bool isM68020 ( ) const { return IsM68020 ;


<s> bool isM68030 ( ) const { return IsM68030 ;


<s> bool isM68040 ( ) const { return IsM68040 ;


<s> bool <ISA_LIT>Subtarget :: isPositionIndependent ( ) const { return TM . isPositionIndependent ( ) ;


<s> return TargetTriple . isOSBinFormatELF ( ) ;


<s> <ISA_LIT>GenSubtargetInfo ( TT , CPU , FS ) , TM ( TM ) , TSInfo ( ) , InstrInfo ( initializeSubtargetDependencies ( CPU , TT , FS , TM ) ) , FrameLowering ( * this , this -> getStackAlignment ( ) ) , TLInfo ( TM , * this ) , TargetTriple ( TT ) {


<s> static StringRef select<ISA_LIT>CPU ( Triple TT , StringRef CPU ) {

if ( CPU . empty ( ) || CPU == <STR_LIT> ) {


<s> RegisterTarget < Triple :: m680x0 , true > X ( The<ISA_LIT>Target , <STR_LIT> , <STR_LIT> , <STR_LIT> ) ;


<s> void LLVMInitialize<ISA_LIT>TargetInfo ( ) {

RegisterTarget < Triple :: m680x0 , true > X ( The<ISA_LIT>Target , <STR_LIT> , <STR_LIT> , <STR_LIT> ) ;


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


<s> addPass ( create<ISA_LIT>CollapseMOVEMPass ( ) ) ;


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


<s> if ( ! CM ) { return CodeModel :: Small ; } else if ( CM == CodeModel :: Large ) { llvm_unreachable ( <STR_LIT> ) ; } else if ( CM == CodeModel :: Kernel ) { llvm_unreachable ( <STR_LIT> ) ; } return CM . getValue ( ) ;


<s> Reloc :: Model getEffectiveRelocModel ( const Triple & TT , Optional < Reloc :: Model > RM ) { if ( ! RM . hasValue ( ) ) { return Reloc :: Static ;


<s> return * get<ISA_LIT>TargetMachine ( ) . getSubtargetImpl ( ) ;


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


<s> const <ISA_LIT>Subtarget * getSubtargetImpl ( ) const {


<s> void LLVMInitialize<ISA_LIT>Target ( ) {

RegisterTargetMachine < <ISA_LIT>TargetMachine > X ( The<ISA_LIT>Target ) ;


<s> <ISA_LIT>PassConfig ( <ISA_LIT>TargetMachine & TM , PassManagerBase & PM ) : TargetPassConfig ( TM , PM ) {


<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 , computeDataLayout ( TT , CPU , Options ) , TT , CPU , FS , Options , getEffectiveRelocModel ( TT , RM ) , :: getEffectiveCodeModel ( CM , JIT ) , OL ) , TLOF ( make_unique < <ISA_LIT>ELFTargetObjectFile > ( ) ) , Subtarget ( TT , CPU , FS , * this ) {


<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 , computeDataLayout ( TT , CPU , Options ) , TT , CPU , FS , Options , getEffectiveRelocModel ( TT , RM ) , :: getEffectiveCodeModel ( CM , JIT ) , OL ) , TLOF ( make_unique < <ISA_LIT>ELFTargetObjectFile > ( ) ) , Subtarget ( TT , CPU , FS , * this ) { initAsmInfo ( ) ;


<s> <ISA_LIT>TargetMachine :: ~ <ISA_LIT>TargetMachine ( ) {


<s> this -> TM = & static_cast < const <ISA_LIT>TargetMachine & > ( TM ) ; SmallDataSection = getContext ( ) . getELFSection ( <STR_LIT> , ELF :: SHT_PROGBITS , ELF :: SHF_WRITE | ELF :: SHF_ALLOC ) ;

SmallBSSSection = getContext ( ) . getELFSection ( <STR_LIT> , ELF :: SHT_NOBITS , ELF :: SHF_WRITE | ELF :: SHF_ALLOC ) ;