<s> monitor ( NULL , NULL , NULL , <NUM_LIT> , <NUM_LIT> ) ; free ( monitor_buffer ) ;


<s> monitor ( NULL , NULL , NULL , <NUM_LIT> , <NUM_LIT> ) ;


<s> write ( <NUM_LIT> , msg , sizeof ( msg ) - <NUM_LIT> ) ; _exit ( - <NUM_LIT> ) ; } monitor ( & stext , & etext , monitor_buffer , len , <NUM_LIT> ) ;


<s> int len = ( & etext - & stext + <NUM_LIT> ) / <NUM_LIT> ; monitor_buffer = ( WORD * ) calloc ( len , sizeof ( WORD ) ) ; if ( monitor_buffer == NULL ) {


<s> char * * argv ; int argc ; __splimit = d0 ; argc = fp [ <NUM_LIT> ] ; argv = ( char * * ) & fp [ <NUM_LIT> ] ; environ = & argv [ argc + <NUM_LIT> ] ; initfpu ( ) ; __istart ( ) ; __compatmode ( ) ; atexit ( _cleanup ) ; monitor_start ( ) ; InitMac ( ) ; exit ( main ( argc , argv , environ ) ) ;


<s> int argc ; __splimit = d0 ; argc = fp [ <NUM_LIT> ] ; argv = ( char * * ) & fp [ <NUM_LIT> ] ; environ = & argv [ argc + <NUM_LIT> ] ;


<s> if ( current_block -> used >= FNS_PER_BLOCK ) { struct atexit_fn_block * new_block = ( struct atexit_fn_block * ) malloc ( sizeof ( struct atexit_fn_block ) ) ;

if ( new_block == NULL ) return - <NUM_LIT> ;


<s> register long * fncnt = * pfncnt ; if ( ! fncnt ) { struct cnt * newcnt = _countbase ++ ; newcnt -> fnpc = ( char * ) __builtin_return_address ( <NUM_LIT> ) ; * pfncnt = fncnt = & newcnt -> mcnt ;


<s> newcnt -> fnpc = ( char * ) __builtin_return_address ( <NUM_LIT> ) ; * pfncnt = fncnt = & newcnt -> mcnt ;


<s> register union float_long fl1 ; register union double_long dl ; register long exp ; register long mant ; fl1 . f = a1 ; if ( ! fl1 . l ) { dl . l . upper = dl . l . lower = <NUM_LIT> ; return dl . d ; } dl . l . upper = SIGN ( fl1 . l ) ; exp = EXP ( fl1 . l ) ; mant = MANT ( fl1 . l ) & ~ HIDDEN ;


<s> register long exp ; register long mant ; fl1 . f = a1 ; if ( ! fl1 . l ) { dl . l . upper = dl . l . lower = <NUM_LIT> ; return dl . d ; } dl . l . upper = SIGN ( fl1 . l ) ; exp = EXP ( fl1 . l ) ; mant = MANT ( fl1 . l ) & ~ HIDDEN ; if ( exp == <NUM_LIT> ) { exp = <NUM_LIT> ; while ( ! ( mant & HIDDEN ) ) { mant <<= <NUM_LIT> ; exp -- ; }


<s> register union double_long dl1 ; register long exp ; register long l ; dl1 . d = a1 ; if ( ! dl1 . l . upper && ! dl1 . l . lower ) return <NUM_LIT> ; exp = EXPD ( dl1 ) - EXCESSD - <NUM_LIT> ; l = MANTD ( dl1 ) ; if ( exp > <NUM_LIT> ) {

return SIGND ( dl1 ) ? <NUM_LIT> : <NUM_LIT> ;


<s> long __fixdfsi ( double a1 ) { register union double_long dl1 ; register long exp ; register long l ; dl1 . d = a1 ; if ( ! dl1 . l . upper && ! dl1 . l . lower ) return <NUM_LIT> ; exp = EXPD ( dl1 ) - EXCESSD - <NUM_LIT> ; l = MANTD ( dl1 ) ;


<s> long __fixsfsi ( float a1 ) { double foo = a1 ; return __fixdfsi ( foo ) ;


<s> long __fixsfsi ( float a1 ) { double foo = a1 ;


<s> long __fixxfsi ( long double ld ) { long foo = __fixdfsi ( ( double ) ld ) ; return foo ;


<s> sign = SIGNBIT ; a1 = ( long ) - ( unsigned long ) a1 ; if ( a1 < <NUM_LIT> ) { dl . l . upper = SIGNBIT | ( ( <NUM_LIT> + EXCESSD ) << <NUM_LIT> ) ; dl . l . lower = <NUM_LIT> ; return dl . d ; } } while ( a1 < <NUM_LIT> ) { a1 <<= <NUM_LIT> ; exp -= <NUM_LIT> ; } while ( a1 < <NUM_LIT> ) { a1 <<= <NUM_LIT> ;


<s> float __floatsisf ( long l ) { double foo = __floatsidf ( l ) ;


<s> long double __floatsixf ( long l ) { double foo = __floatsidf ( l ) ; return foo ;


<s> } mant += <NUM_LIT> ; mant >>= <NUM_LIT> ; if ( mant & <NUM_LIT> ) { mant >>= <NUM_LIT> ; exp ++ ; } mant &= ~ HIDDEN ; fl . l = PACK ( SIGND ( dl1 ) , exp , mant ) ; return ( fl . f ) ;


<s> long double __addxf3 ( long double x1 , long double x2 ) {


<s> return __cmpdf2 ( ( double ) x1 , ( double ) x2 ) ;


<s> long __cmpxf2 ( long double x1 , long double x2 ) {

return __cmpdf2 ( ( double ) x1 , ( double ) x2 ) ;


<s> return ( double ) x1 / ( double ) x2 ;


<s> long __eqxf2 ( long double x1 , long double x2 ) {


<s> long double __extenddfxf2 ( double d ) { register union double_long dl ; register union long_double_long ldl ; register long exp ; dl . d = d ;

if ( ! dl . l . upper && ! dl . l . lower ) return <NUM_LIT> ;


<s> register union double_long dl ; register long exp ; fl1 . f = a1 ; if ( ! fl1 . l ) { dl . l . upper = dl . l . lower = <NUM_LIT> ; return dl . d ; } dl . l . upper = SIGN ( fl1 . l ) ; exp = EXP ( fl1 . l ) - EXCESS + EXCESSD ; dl . l . upper |= exp << <NUM_LIT> ; dl . l . upper |= ( MANT ( fl1 . l ) & ~ HIDDEN ) >> <NUM_LIT> ; dl . l . lower = MANT ( fl1 . l ) << <NUM_LIT> ;


<s> if ( ! fl1 . l ) { dl . l . upper = dl . l . lower = <NUM_LIT> ; return dl . d ; } dl . l . upper = SIGN ( fl1 . l ) ; exp = EXP ( fl1 . l ) - EXCESS + EXCESSD ; dl . l . upper |= exp << <NUM_LIT> ; dl . l . upper |= ( MANT ( fl1 . l ) & ~ HIDDEN ) >> <NUM_LIT> ; dl . l . lower = MANT ( fl1 . l ) << <NUM_LIT> ;


<s> long double foo = __extenddfxf2 ( __extendsfdf2 ( f ) ) ;


<s> register long exp ; register long l ; dl1 . d = a1 ; if ( ! dl1 . l . upper && ! dl1 . l . lower ) return <NUM_LIT> ; exp = EXPD ( dl1 ) - EXCESSD - <NUM_LIT> ; l = MANTD ( dl1 ) ; if ( exp > <NUM_LIT> ) { return SIGND ( dl1 ) ? <NUM_LIT> : <NUM_LIT> ; } if ( exp <= - <NUM_LIT> ) return <NUM_LIT> ; if ( exp < <NUM_LIT> ) l >>= - exp ; return ( SIGND ( dl1 ) ? - l : l ) ;


<s> if ( ! dl1 . l . upper && ! dl1 . l . lower ) return <NUM_LIT> ; exp = EXPD ( dl1 ) - EXCESSD - <NUM_LIT> ; l = MANTD ( dl1 ) ; if ( exp > <NUM_LIT> ) { return SIGND ( dl1 ) ? <NUM_LIT> : <NUM_LIT> ; } if ( exp <= - <NUM_LIT> ) return <NUM_LIT> ;


<s> a1 = - a1 ; if ( a1 < <NUM_LIT> ) { dl . l . upper = SIGNBIT | ( ( <NUM_LIT> + EXCESSD ) << <NUM_LIT> ) ; dl . l . lower = <NUM_LIT> ; return dl . d ; } } while ( a1 < <NUM_LIT> ) { a1 <<= <NUM_LIT> ; exp -= <NUM_LIT> ; } while ( a1 < <NUM_LIT> ) { a1 <<= <NUM_LIT> ; exp -- ; } dl . l . upper = sign ; dl . l . upper |= exp << <NUM_LIT> ; dl . l . upper |= ( a1 >> <NUM_LIT> ) & ~ HIDDEND ;


<s> dl . l . upper = SIGNBIT | ( ( <NUM_LIT> + EXCESSD ) << <NUM_LIT> ) ; dl . l . lower = <NUM_LIT> ; return dl . d ; } } while ( a1 < <NUM_LIT> ) { a1 <<= <NUM_LIT> ; exp -= <NUM_LIT> ; } while ( a1 < <NUM_LIT> ) { a1 <<= <NUM_LIT> ; exp -- ;


<s> long __gexf2 ( long double x1 , long double x2 ) {


<s> long __gtxf2 ( long double x1 , long double x2 ) { return __cmpdf2 ( ( double ) x1 , ( double ) x2 ) ;


<s> long __lexf2 ( long double x1 , long double x2 ) {


<s> long double __mulxf3 ( long double x1 , long double x2 ) {


<s> return ( double ) x1 * ( double ) x2 ;


<s> long double __negxf2 ( long double x1 ) {


<s> return __cmpdf2 ( ( double ) x1 , ( double ) x2 ) ;


<s> long double __subxf3 ( long double x1 , long double x2 ) {


<s> return ( double ) x1 - ( double ) x2 ;


<s> if ( ! dl1 . l . upper && ! dl1 . l . lower ) return <NUM_LIT> ; exp = EXPD ( dl1 ) - EXCESSD + EXCESS ; mant = MANTD ( dl1 ) >> <NUM_LIT> ; mant += <NUM_LIT> ; mant >>= <NUM_LIT> ; if ( mant & <NUM_LIT> ) {


<s> register union long_double_long ldl ; ldl . ld = ld ; if ( ! ldl . l . upper && ! ldl . l . middle && ! ldl . l . lower ) return <NUM_LIT> ; exp = EXPX ( ldl ) - EXCESSX + EXCESSD ; if ( exp >= EXPDMASK ) exp = EXPDMASK - <NUM_LIT> ; dl . l . upper = SIGNX ( ldl ) ; dl . l . upper |= exp << ( <NUM_LIT> - ( EXPDBITS + <NUM_LIT> ) ) ; dl . l . upper |= ( ldl . l . middle & MANTXMASK ) >> ( EXPDBITS + <NUM_LIT> - <NUM_LIT> ) ; dl . l . lower = ( ldl . l . middle & MANTXMASK ) << ( <NUM_LIT> - ( EXPDBITS + <NUM_LIT> - <NUM_LIT> ) ) ; dl . l . lower |= ldl . l . lower >> ( EXPDBITS + <NUM_LIT> - <NUM_LIT> ) ;


<s> register union double_long dl ; register union long_double_long ldl ; ldl . ld = ld ; if ( ! ldl . l . upper && ! ldl . l . middle && ! ldl . l . lower ) return <NUM_LIT> ; exp = EXPX ( ldl ) - EXCESSX + EXCESSD ; if ( exp >= EXPDMASK ) exp = EXPDMASK - <NUM_LIT> ; dl . l . upper = SIGNX ( ldl ) ; dl . l . upper |= exp << ( <NUM_LIT> - ( EXPDBITS + <NUM_LIT> ) ) ; dl . l . upper |= ( ldl . l . middle & MANTXMASK ) >> ( EXPDBITS + <NUM_LIT> - <NUM_LIT> ) ; dl . l . lower = ( ldl . l . middle & MANTXMASK ) << ( <NUM_LIT> - ( EXPDBITS + <NUM_LIT> - <NUM_LIT> ) ) ;

dl . l . lower |= ldl . l . lower >> ( EXPDBITS + <NUM_LIT> - <NUM_LIT> ) ;


<s> if ( GET_CODE ( countop ) == CONST_INT ) { int count = INTVAL ( countop ) ; if ( count > signpos ) { int offset = ( count & ~ signpos ) / <NUM_LIT> ; count = count & signpos ; ops [ <NUM_LIT> ] = dataop = adjust_address ( dataop , QImode , offset ) ; } if ( code == EQ || code == NE ) { if ( count == <NUM_LIT> ) { output_asm_insn ( <STR_LIT> , ops ) ; return code == EQ ? PLUS : MINUS ; }


<s> output_asm_insn ( <STR_LIT> , ops ) ; return code == EQ ? PLUS : MINUS ; } if ( count == <NUM_LIT> ) { output_asm_insn ( <STR_LIT> , ops ) ; return code == EQ ? PLUS : MINUS ; } } if ( TUNE_CPU32 || TARGET_COLDFIRE || optimize_size ) { if ( count == <NUM_LIT> && DATA_REG_P ( ops [ <NUM_LIT> ] ) && ( code == EQ || code == NE ) ) { output_asm_insn ( <STR_LIT> , ops ) ; return code == EQ ? PLUS : MINUS ; } if ( count == <NUM_LIT> && DATA_REG_P ( ops [ <NUM_LIT> ] ) && ( code == EQ || code == NE ) ) { output_asm_insn ( <STR_LIT> , ops ) ; return code == EQ ? NE : EQ ; } } cc_status . flags = CC_NOT_NEGATIVE ; } output_asm_insn ( <STR_LIT> , ops ) ;


return cc_status . flags & CC_IN_68881 ;


<s> int flags_in_68881 ( ) { return cc_status . flags & CC_IN_68881 ;


<s> r = REAL_VALUE_ATOF ( strings_68881 [ i ] , mode ) ; values_68881 [ i ] = r ; } inited_68881_table = <NUM_LIT> ;


<s> mode = DFmode ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { if ( i == <NUM_LIT> ) mode = SFmode ; r = REAL_VALUE_ATOF ( strings_FPA [ i ] , mode ) ; values_FPA [ i ] = r ;


<s> int i ; def_align = <NUM_LIT> ; m68k_align_loops = def_align ; if ( m68k_align_loops_string ) { i = atoi ( m68k_align_loops_string ) ; if ( i < <NUM_LIT> || i > MAX_CODE_ALIGN ) error ( <STR_LIT> , i , MAX_CODE_ALIGN ) ; else m68k_align_loops = i ; } m68k_align_jumps = def_align ; if ( m68k_align_jumps_string ) { i = atoi ( m68k_align_jumps_string ) ; if ( i < <NUM_LIT> || i > MAX_CODE_ALIGN ) error ( <STR_LIT> , i , MAX_CODE_ALIGN ) ; else m68k_align_jumps = i ; } m68k_align_funcs = def_align ; if ( m68k_align_funcs_string ) { i = atoi ( m68k_align_funcs_string ) ;


<s> def_align = <NUM_LIT> ; m68k_align_loops = def_align ; if ( m68k_align_loops_string ) { i = atoi ( m68k_align_loops_string ) ; if ( i < <NUM_LIT> || i > MAX_CODE_ALIGN ) error ( <STR_LIT> , i , MAX_CODE_ALIGN ) ; else m68k_align_loops = i ; } m68k_align_jumps = def_align ; if ( m68k_align_jumps_string ) { i = atoi ( m68k_align_jumps_string ) ; if ( i < <NUM_LIT> || i > MAX_CODE_ALIGN ) error ( <STR_LIT> , i , MAX_CODE_ALIGN ) ; else m68k_align_jumps = i ; } m68k_align_funcs = def_align ; if ( m68k_align_funcs_string ) { i = atoi ( m68k_align_funcs_string ) ; if ( i < <NUM_LIT> || i > MAX_CODE_ALIGN ) error ( <STR_LIT> , i , MAX_CODE_ALIGN ) ; else m68k_align_funcs = i ;


<s> int regno ; if ( ! reload_completed || frame_pointer_needed || get_frame_size ( ) != <NUM_LIT> ) return <NUM_LIT> ; for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( regs_ever_live [ regno ] && ! call_used_regs [ regno ] ) return <NUM_LIT> ;

if ( flag_pic && current_function_uses_pic_offset_table ) return <NUM_LIT> ;


<s> for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( regs_ever_live [ regno ] && ! call_used_regs [ regno ] ) return <NUM_LIT> ;


<s> case NOTB : case NOTW : case NEGW : case SWAP : return <NUM_LIT> ; case MOVL :


<s> i = INTVAL ( constant ) ; if ( USE_MOVQ ( i ) ) return MOVQ ; if ( ! TARGET_COLDFIRE ) { if ( USE_MOVQ ( i ^ <NUM_LIT> ) ) return NOTB ; if ( USE_MOVQ ( i ^ <NUM_LIT> ) ) return NOTW ; if ( i == - <NUM_LIT> ) return NEGW ; } u = i ; if ( USE_MOVQ ( ( u >> <NUM_LIT> ) | ( u << <NUM_LIT> ) ) ) return SWAP ; if ( TARGET_CFV4 ) { if ( i >= <NUM_LIT> && i <= <NUM_LIT> ) return MVZ ; if ( i >= - <NUM_LIT> && i <= <NUM_LIT> ) return MVS ;


<s> int floating_exact_log2 ( rtx x ) { REAL_VALUE_TYPE r , r1 ; int exp ; REAL_VALUE_FROM_CONST_DOUBLE ( r , x ) ; if ( REAL_VALUES_LESS ( r , dconst1 ) ) return <NUM_LIT> ; exp = real_exponent ( & r ) ; real_2expN ( & r1 , exp ) ; if ( REAL_VALUES_EQUAL ( r1 , r ) ) return exp ; return <NUM_LIT> ;


<s> if ( REAL_VALUES_LESS ( r , dconst1 ) ) return <NUM_LIT> ; exp = real_exponent ( & r ) ; real_2expN ( & r1 , exp ) ;

if ( REAL_VALUES_EQUAL ( r1 , r ) ) return exp ;


<s> if ( i == <NUM_LIT> ) mode = DFmode ; r = REAL_VALUE_ATOF ( strings_68881 [ i ] , mode ) ; values_68881 [ i ] = r ;


<s> int i ; REAL_VALUE_TYPE r ; enum machine_mode mode ; mode = SFmode ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { if ( i == <NUM_LIT> ) mode = DFmode ; r = REAL_VALUE_ATOF ( strings_68881 [ i ] , mode ) ;


<s> MEM_READONLY_P ( pic_ref ) = <NUM_LIT> ; emit_move_insn ( reg , pic_ref ) ; return reg ; } else if ( GET_CODE ( orig ) == CONST ) { rtx base ; if ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == PLUS && XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) == pic_offset_table_rtx ) return orig ; gcc_assert ( reg ) ; gcc_assert ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == PLUS ) ;

base = legitimize_pic_address ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) , Pmode , reg ) ;


<s> static void m68k_coff_asm_named_section ( const char * name , unsigned int flags , tree decl ATTRIBUTE_UNUSED ) {


<s> if ( flags & SECTION_WRITE ) flagchar = 'd' ; else flagchar = 'x' ;

fprintf ( asm_out_file , <STR_LIT> , name , flagchar ) ;


<s> unsigned int mask , rmask ; bool interrupt_handler = m68k_interrupt_function_p ( current_function_decl ) ; if ( current_frame . funcdef_no == current_function_funcdef_no && reload_completed ) return ; current_frame . size = ( get_frame_size ( ) + <NUM_LIT> ) & - <NUM_LIT> ; mask = rmask = saved = <NUM_LIT> ; for ( regno = <NUM_LIT> ; regno < <NUM_LIT> ; regno ++ ) if ( m68k_save_reg ( regno , interrupt_handler ) ) { mask |= <NUM_LIT> << regno ; rmask |= <NUM_LIT> << ( <NUM_LIT> - regno ) ;


<s> if ( m68k_interrupt_function_p ( current_function_decl ) && ! regs_ever_live [ new_reg ] ) return <NUM_LIT> ;


<s> static bool m68k_interrupt_function_p ( tree func ) { tree a ; if ( TREE_CODE ( func ) != FUNCTION_DECL ) return false ; a = lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( func ) ) ;


<s> } } if ( current_function_limit_stack ) { if ( REG_P ( stack_limit_rtx ) ) asm_fprintf ( stream , <STR_LIT> ASM_DOT <STR_LIT> , M68K_REGNAME ( REGNO ( stack_limit_rtx ) ) ) ; else if ( GET_CODE ( stack_limit_rtx ) != SYMBOL_REF ) warning ( <NUM_LIT> , <STR_LIT> ) ; } if ( current_frame . reg_no <= <NUM_LIT> ) { int i ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( current_frame . reg_rev_mask & ( <NUM_LIT> << i ) ) { asm_fprintf ( stream , MOTOROLA ? <STR_LIT> : <STR_LIT> , M68K_REGNAME ( <NUM_LIT> - i ) ) ; if ( dwarf2out_do_frame ( ) ) { char * l = ( char * ) dwarf2out_cfi_label ( ) ; cfa_offset += <NUM_LIT> ; if ( ! frame_pointer_needed ) dwarf2out_def_cfa ( l , STACK_POINTER_REGNUM , cfa_offset ) ; dwarf2out_reg_save ( l , <NUM_LIT> - i , - cfa_offset ) ; } } } else if ( current_frame . reg_rev_mask ) { if ( TARGET_COLDFIRE ) asm_fprintf ( stream , MOTOROLA ? <STR_LIT> : <STR_LIT> , current_frame . reg_mask ) ; else asm_fprintf ( stream , MOTOROLA ? <STR_LIT> : <STR_LIT> , current_frame . reg_rev_mask ) ; if ( dwarf2out_do_frame ( ) ) { char * l = ( char * ) dwarf2out_cfi_label ( ) ; int n_regs , regno ; cfa_offset += current_frame . reg_no * <NUM_LIT> ; if ( ! frame_pointer_needed ) dwarf2out_def_cfa ( l , STACK_POINTER_REGNUM , cfa_offset ) ; for ( regno = <NUM_LIT> , n_regs = <NUM_LIT> ; regno < <NUM_LIT> ; regno ++ ) if ( current_frame . reg_mask & ( <NUM_LIT> << regno ) ) dwarf2out_reg_save ( l , regno , - cfa_offset + n_regs ++ * <NUM_LIT> ) ; } } if ( ! TARGET_SEP_DATA && flag_pic && ( current_function_uses_pic_offset_table || ( ! current_function_is_leaf && TARGET_ID_SHARED_LIBRARY ) ) ) { if ( TARGET_ID_SHARED_LIBRARY ) { asm_fprintf ( stream , <STR_LIT> , M68K_REGNAME ( PIC_OFFSET_TABLE_REGNUM ) , m68k_library_id_string , M68K_REGNAME ( PIC_OFFSET_TABLE_REGNUM ) ) ; } else {

if ( MOTOROLA ) asm_fprintf ( stream , <STR_LIT> , M68K_REGNAME ( PIC_OFFSET_TABLE_REGNUM ) ) ;


<s> else asm_fprintf ( stream , MOTOROLA ? <STR_LIT> : <STR_LIT> , - fsize_with_regs ) ; } else asm_fprintf ( stream , <STR_LIT> ASM_DOT <STR_LIT> , - fsize_with_regs ) ; if ( dwarf2out_do_frame ( ) ) { cfa_offset += current_frame . size + <NUM_LIT> ; dwarf2out_def_cfa ( <STR_LIT> , STACK_POINTER_REGNUM , cfa_offset ) ; } } if ( current_frame . fpu_mask ) { asm_fprintf ( stream , MOTOROLA ? <STR_LIT> : <STR_LIT> , current_frame . fpu_mask ) ; if ( dwarf2out_do_frame ( ) ) { char * l = ( char * ) dwarf2out_cfi_label ( ) ; int n_regs , regno ; cfa_offset += current_frame . fpu_no * <NUM_LIT> ; if ( ! frame_pointer_needed ) dwarf2out_def_cfa ( l , STACK_POINTER_REGNUM , cfa_offset ) ; for ( regno = <NUM_LIT> , n_regs = <NUM_LIT> ; regno < <NUM_LIT> ; regno ++ ) if ( current_frame . fpu_mask & ( <NUM_LIT> << ( regno - <NUM_LIT> ) ) ) dwarf2out_reg_save ( l , regno , - cfa_offset + n_regs ++ * <NUM_LIT> ) ; } } if ( current_function_limit_stack ) { if ( REG_P ( stack_limit_rtx ) ) asm_fprintf ( stream , <STR_LIT> ASM_DOT <STR_LIT> , M68K_REGNAME ( REGNO ( stack_limit_rtx ) ) ) ; else if ( GET_CODE ( stack_limit_rtx ) != SYMBOL_REF ) warning ( <NUM_LIT> , <STR_LIT> ) ; } if ( current_frame . reg_no <= <NUM_LIT> ) { int i ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( current_frame . reg_rev_mask & ( <NUM_LIT> << i ) ) { asm_fprintf ( stream , MOTOROLA ? <STR_LIT> : <STR_LIT> , M68K_REGNAME ( <NUM_LIT> - i ) ) ; if ( dwarf2out_do_frame ( ) ) { char * l = ( char * ) dwarf2out_cfi_label ( ) ; cfa_offset += <NUM_LIT> ; if ( ! frame_pointer_needed ) dwarf2out_def_cfa ( l , STACK_POINTER_REGNUM , cfa_offset ) ; dwarf2out_reg_save ( l , <NUM_LIT> - i , - cfa_offset ) ; } } } else if ( current_frame . reg_rev_mask ) { if ( TARGET_COLDFIRE ) asm_fprintf ( stream , MOTOROLA ? <STR_LIT> :


<s> void m68k_output_pic_call ( rtx dest ) { const char * out ; if ( ! ( GET_CODE ( dest ) == MEM && GET_CODE ( XEXP ( dest , <NUM_LIT> ) ) == SYMBOL_REF ) ) out = <STR_LIT> ; else if ( TARGET_PCREL ) out = <STR_LIT> ;

else if ( TARGET_68020 ) out = <STR_LIT> ;


<s> } else if ( regno < <NUM_LIT> ) { if ( GET_MODE_SIZE ( mode ) == <NUM_LIT> ) return false ; if ( regno + GET_MODE_SIZE ( mode ) / <NUM_LIT> <= <NUM_LIT> ) return true ; } else if ( regno < <NUM_LIT> ) { if ( ( GET_MODE_CLASS ( mode ) == MODE_FLOAT || GET_MODE_CLASS ( mode ) == MODE_COMPLEX_FLOAT ) && GET_MODE_UNIT_SIZE ( mode ) <= <NUM_LIT> ) return true ;


<s> if ( regno + GET_MODE_SIZE ( mode ) / <NUM_LIT> <= <NUM_LIT> ) return true ; } else if ( regno < <NUM_LIT> ) { if ( GET_MODE_SIZE ( mode ) == <NUM_LIT> ) return false ; if ( regno + GET_MODE_SIZE ( mode ) / <NUM_LIT> <= <NUM_LIT> ) return true ; } else if ( regno < <NUM_LIT> ) { if ( ( GET_MODE_CLASS ( mode ) == MODE_FLOAT || GET_MODE_CLASS ( mode ) == MODE_COMPLEX_FLOAT ) && GET_MODE_UNIT_SIZE ( mode ) <= <NUM_LIT> ) return true ;


<s> if ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) < <NUM_LIT> ) * total = COSTS_N_INSNS ( <NUM_LIT> ) + INTVAL ( XEXP ( x , <NUM_LIT> ) ) / <NUM_LIT> ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) + ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) - <NUM_LIT> ) / <NUM_LIT> ; } else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT && ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) == <NUM_LIT> ) ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT && ! ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) > <NUM_LIT> && INTVAL ( XEXP ( x , <NUM_LIT> ) ) <= <NUM_LIT> ) ) { * total = COSTS_N_INSNS ( TARGET_COLDFIRE ? <NUM_LIT> : <NUM_LIT> ) ; return true ; } return false ; case MULT : if ( ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == ZERO_EXTEND || GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == SIGN_EXTEND ) && GET_MODE ( x ) == SImode ) * total = COSTS_N_INSNS ( MULW_COST ) ; else if ( GET_MODE ( x ) == QImode || GET_MODE ( x ) == HImode ) * total = COSTS_N_INSNS ( MULW_COST ) ; else * total = COSTS_N_INSNS ( MULL_COST ) ; return true ; case DIV : case UDIV : case MOD : case UMOD : if ( GET_MODE ( x ) == QImode || GET_MODE ( x ) == HImode ) * total = COSTS_N_INSNS ( DIVW_COST ) ;

else if ( TARGET_CF_HWDIV ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ;


<s> if ( current_function_calls_eh_return ) { unsigned int i ; for ( i = <NUM_LIT> ; ; i ++ ) { unsigned int test = EH_RETURN_DATA_REGNO ( i ) ; if ( test == INVALID_REGNUM ) break ; if ( test == regno ) return true ; } } if ( fixed_regs [ regno ] ) return false ;

if ( regno == FRAME_POINTER_REGNUM && frame_pointer_needed ) return false ;


<s> for ( i = <NUM_LIT> ; ; i ++ ) { unsigned int test = EH_RETURN_DATA_REGNO ( i ) ; if ( test == INVALID_REGNUM ) break ; if ( test == regno ) return true ; } }

if ( fixed_regs [ regno ] ) return false ;


<s> } else if ( GET_CODE ( exp ) == PARALLEL && GET_CODE ( XVECEXP ( exp , <NUM_LIT> , <NUM_LIT> ) ) == SET ) { if ( ADDRESS_REG_P ( XEXP ( XVECEXP ( exp , <NUM_LIT> , <NUM_LIT> ) , <NUM_LIT> ) ) ) CC_STATUS_INIT ; else if ( XEXP ( XVECEXP ( exp , <NUM_LIT> , <NUM_LIT> ) , <NUM_LIT> ) != pc_rtx ) { cc_status . flags = <NUM_LIT> ; cc_status . value1 = XEXP ( XVECEXP ( exp , <NUM_LIT> , <NUM_LIT> ) , <NUM_LIT> ) ; cc_status . value2 = XEXP ( XVECEXP ( exp , <NUM_LIT> , <NUM_LIT> ) , <NUM_LIT> ) ; } } else CC_STATUS_INIT ; if ( cc_status . value2 != <NUM_LIT> && ADDRESS_REG_P ( cc_status . value2 ) && GET_MODE ( cc_status . value2 ) == QImode ) CC_STATUS_INIT ; if ( cc_status . value2 != <NUM_LIT> ) switch ( GET_CODE ( cc_status . value2 ) ) { case ASHIFT : case ASHIFTRT : case LSHIFTRT : case ROTATE : case ROTATERT : CC_STATUS_INIT ; break ; case PLUS : case MINUS : case MULT : case DIV : case UDIV : case MOD : case UMOD : case NEG : if ( GET_MODE ( cc_status . value2 ) != VOIDmode ) cc_status . flags |= CC_NO_OVERFLOW ; break ; case ZERO_EXTEND : cc_status . flags |= CC_NOT_NEGATIVE ; default : break ; } if ( cc_status . value1 && GET_CODE ( cc_status . value1 ) == REG && cc_status . value2 && reg_overlap_mentioned_p ( cc_status . value1 , cc_status . value2 ) ) cc_status . value2 = <NUM_LIT> ; if ( ( ( cc_status . value1 && FP_REG_P ( cc_status . value1 ) ) || ( cc_status . value2 && FP_REG_P ( cc_status . value2 ) ) ) ) cc_status . flags = CC_IN_68881 ;


<s> if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT ) { if ( INTVAL ( operands [ <NUM_LIT> ] ) > <NUM_LIT> && INTVAL ( operands [ <NUM_LIT> ] ) <= <NUM_LIT> ) return <STR_LIT> ; if ( INTVAL ( operands [ <NUM_LIT> ] ) < <NUM_LIT> && INTVAL ( operands [ <NUM_LIT> ] ) >= - <NUM_LIT> ) { operands [ <NUM_LIT> ] = GEN_INT ( - INTVAL ( operands [ <NUM_LIT> ] ) ) ; return <STR_LIT> ; } if ( TARGET_CPU32 && REG_P ( operands [ <NUM_LIT> ] ) ) { if ( INTVAL ( operands [ <NUM_LIT> ] ) > <NUM_LIT> && INTVAL ( operands [ <NUM_LIT> ] ) <= <NUM_LIT> ) { operands [ <NUM_LIT> ] = GEN_INT ( INTVAL ( operands [ <NUM_LIT> ] ) - <NUM_LIT> ) ; return <STR_LIT> ; } if ( INTVAL ( operands [ <NUM_LIT> ] ) < - <NUM_LIT> && INTVAL ( operands [ <NUM_LIT> ] ) >= - <NUM_LIT> ) { operands [ <NUM_LIT> ] = GEN_INT ( - INTVAL ( operands [ <NUM_LIT> ] ) - <NUM_LIT> ) ; return <STR_LIT> ; } } if ( ADDRESS_REG_P ( operands [ <NUM_LIT> ] ) && INTVAL ( operands [ <NUM_LIT> ] ) >= - <NUM_LIT> && INTVAL ( operands [ <NUM_LIT> ] ) < <NUM_LIT> ) {


<s> operands [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; operands [ <NUM_LIT> ] = tmp ; } if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT && ( INTVAL ( operands [ <NUM_LIT> ] ) < - <NUM_LIT> || INTVAL ( operands [ <NUM_LIT> ] ) > <NUM_LIT> ) ) return <STR_LIT> ; if ( GET_CODE ( operands [ <NUM_LIT> ] ) == REG ) return MOTOROLA ? <STR_LIT> : <STR_LIT> ; return MOTOROLA ? <STR_LIT> : <STR_LIT> ; } if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT ) { if ( INTVAL ( operands [ <NUM_LIT> ] ) > <NUM_LIT> && INTVAL ( operands [ <NUM_LIT> ] ) <= <NUM_LIT> ) return <STR_LIT> ; if ( INTVAL ( operands [ <NUM_LIT> ] ) < <NUM_LIT> && INTVAL ( operands [ <NUM_LIT> ] ) >= - <NUM_LIT> ) { operands [ <NUM_LIT> ] = GEN_INT ( - INTVAL ( operands [ <NUM_LIT> ] ) ) ;


<s> if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT && ( INTVAL ( operands [ <NUM_LIT> ] ) | <NUM_LIT> ) == - <NUM_LIT> && ( DATA_REG_P ( operands [ <NUM_LIT> ] ) || offsettable_memref_p ( operands [ <NUM_LIT> ] ) ) && ! TARGET_COLDFIRE ) { if ( GET_CODE ( operands [ <NUM_LIT> ] ) != REG ) operands [ <NUM_LIT> ] = adjust_address ( operands [ <NUM_LIT> ] , HImode , <NUM_LIT> ) ; operands [ <NUM_LIT> ] = GEN_INT ( INTVAL ( operands [ <NUM_LIT> ] ) & <NUM_LIT> ) ; CC_STATUS_INIT ; if ( operands [ <NUM_LIT> ] == const0_rtx ) return <STR_LIT> ;


<s> return <STR_LIT> ; } if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT && ( logval = exact_log2 ( ~ INTVAL ( operands [ <NUM_LIT> ] ) ) ) >= <NUM_LIT> && ( DATA_REG_P ( operands [ <NUM_LIT> ] ) || offsettable_memref_p ( operands [ <NUM_LIT> ] ) ) ) { if ( DATA_REG_P ( operands [ <NUM_LIT> ] ) ) { operands [ <NUM_LIT> ] = GEN_INT ( logval ) ; } else { operands [ <NUM_LIT> ] = adjust_address ( operands [ <NUM_LIT> ] , SImode , <NUM_LIT> - ( logval / <NUM_LIT> ) ) ;

operands [ <NUM_LIT> ] = GEN_INT ( logval % <NUM_LIT> ) ;


<s> if ( GET_CODE ( countop ) == CONST_INT ) { register int count = INTVAL ( countop ) ; if ( count > signpos ) { int offset = ( count & ~ signpos ) / <NUM_LIT> ; count = count & signpos ; operands [ <NUM_LIT> ] = dataop = adjust_address ( dataop , QImode , offset ) ; } if ( count == signpos ) cc_status . flags = CC_NOT_POSITIVE | CC_Z_IN_NOT_N ; else cc_status . flags = CC_NOT_NEGATIVE | CC_Z_IN_NOT_N ; if ( count == <NUM_LIT> && next_insn_tests_no_inequality ( insn ) ) return <STR_LIT> ; if ( count == <NUM_LIT> && next_insn_tests_no_inequality ( insn ) ) return <STR_LIT> ; if ( count == <NUM_LIT> && next_insn_tests_no_inequality ( insn ) ) return <STR_LIT> ; cc_status . flags = CC_NOT_NEGATIVE ; } return <STR_LIT> ;


<s> output_asm_insn ( MOTOROLA ? <STR_LIT> : <STR_LIT> , operands ) ; break ; case GT : output_asm_insn ( MOTOROLA ? <STR_LIT> : <STR_LIT> , operands ) ; break ; case GTU : output_asm_insn ( MOTOROLA ? <STR_LIT> : <STR_LIT> , operands ) ; break ; case LT : output_asm_insn ( MOTOROLA ? <STR_LIT> : <STR_LIT> , operands ) ; break ; case LTU : output_asm_insn ( MOTOROLA ? <STR_LIT> : <STR_LIT> , operands ) ; break ; case GE : output_asm_insn ( MOTOROLA ? <STR_LIT> : <STR_LIT> , operands ) ; break ; case GEU : output_asm_insn ( MOTOROLA ? <STR_LIT> : <STR_LIT> , operands ) ; break ; case LE : output_asm_insn ( MOTOROLA ? <STR_LIT> : <STR_LIT> , operands ) ; break ; case LEU : output_asm_insn ( MOTOROLA ? <STR_LIT> : <STR_LIT> , operands ) ; break ; default : gcc_unreachable ( ) ; } switch ( GET_MODE ( operands [ <NUM_LIT> ] ) ) { case SImode : output_asm_insn ( MOTOROLA ? <STR_LIT> : <STR_LIT> , operands ) ; break ; case HImode : break ;


<s> if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT && INTVAL ( operands [ <NUM_LIT> ] ) >> <NUM_LIT> == <NUM_LIT> && ( DATA_REG_P ( operands [ <NUM_LIT> ] ) || offsettable_memref_p ( operands [ <NUM_LIT> ] ) ) && ! TARGET_COLDFIRE ) { if ( GET_CODE ( operands [ <NUM_LIT> ] ) != REG ) operands [ <NUM_LIT> ] = adjust_address ( operands [ <NUM_LIT> ] , HImode , <NUM_LIT> ) ; CC_STATUS_INIT ; if ( INTVAL ( operands [ <NUM_LIT> ] ) == <NUM_LIT> ) return <STR_LIT> ; return <STR_LIT> ; } if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT && ( logval = exact_log2 ( INTVAL ( operands [ <NUM_LIT> ] ) ) ) >= <NUM_LIT> && ( DATA_REG_P ( operands [ <NUM_LIT> ] ) || offsettable_memref_p ( operands [ <NUM_LIT> ] ) ) ) { if ( DATA_REG_P ( operands [ <NUM_LIT> ] ) ) operands [ <NUM_LIT> ] = GEN_INT ( logval ) ;


<s> return <STR_LIT> ; } if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT && ( logval = exact_log2 ( INTVAL ( operands [ <NUM_LIT> ] ) ) ) >= <NUM_LIT> && ( DATA_REG_P ( operands [ <NUM_LIT> ] ) || offsettable_memref_p ( operands [ <NUM_LIT> ] ) ) ) {

if ( DATA_REG_P ( operands [ <NUM_LIT> ] ) ) operands [ <NUM_LIT> ] = GEN_INT ( logval ) ;


<s> return <STR_LIT> ; case MOVQ : return <STR_LIT> ; case NOTB : CC_STATUS_INIT ; operands [ <NUM_LIT> ] = GEN_INT ( i ^ <NUM_LIT> ) ; return <STR_LIT> ; case NOTW : CC_STATUS_INIT ; operands [ <NUM_LIT> ] = GEN_INT ( i ^ <NUM_LIT> ) ; return <STR_LIT> ; case NEGW : CC_STATUS_INIT ; return <STR_LIT> ; case SWAP : { unsigned u = i ; operands [ <NUM_LIT> ] = GEN_INT ( ( u << <NUM_LIT> ) | ( u >> <NUM_LIT> ) ) ; return <STR_LIT> ; } case MOVL :


<s> return <STR_LIT> ; } else if ( INTVAL ( operands [ <NUM_LIT> ] ) < <NUM_LIT> && INTVAL ( operands [ <NUM_LIT> ] ) >= - <NUM_LIT> ) return <STR_LIT> ; } else if ( CONSTANT_P ( operands [ <NUM_LIT> ] ) ) return <STR_LIT> ; if ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM && GET_CODE ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) , <NUM_LIT> ) ) == LABEL_REF && GET_CODE ( XEXP ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) , <NUM_LIT> ) ) != PLUS ) { rtx labelref = XEXP ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) , <NUM_LIT> ) ; if ( MOTOROLA ) asm_fprintf ( asm_out_file , <STR_LIT> , CODE_LABEL_NUMBER ( XEXP ( labelref , <NUM_LIT> ) ) ) ; else ( * targetm . asm_out . internal_label ) ( asm_out_file , <STR_LIT> , CODE_LABEL_NUMBER ( XEXP ( labelref , <NUM_LIT> ) ) ) ; } return <STR_LIT> ;


<s> const char * output_move_himode ( rtx * operands ) { if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT ) { if ( operands [ <NUM_LIT> ] == const0_rtx && ( DATA_REG_P ( operands [ <NUM_LIT> ] ) || GET_CODE ( operands [ <NUM_LIT> ] ) == MEM ) && ( ( TARGET_68020 || TARGET_COLDFIRE ) || ! ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM && MEM_VOLATILE_P ( operands [ <NUM_LIT> ] ) ) ) ) return <STR_LIT> ; else if ( operands [ <NUM_LIT> ] == const0_rtx && ADDRESS_REG_P ( operands [ <NUM_LIT> ] ) ) return <STR_LIT> ; else if ( DATA_REG_P ( operands [ <NUM_LIT> ] ) && INTVAL ( operands [ <NUM_LIT> ] ) < <NUM_LIT> && INTVAL ( operands [ <NUM_LIT> ] ) >= - <NUM_LIT> ) { return <STR_LIT> ;


<s> if ( ! ADDRESS_REG_P ( operands [ <NUM_LIT> ] ) && ( ( TARGET_68020 || TARGET_COLDFIRE ) || ! ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM && MEM_VOLATILE_P ( operands [ <NUM_LIT> ] ) ) ) ) { if ( operands [ <NUM_LIT> ] == const0_rtx ) return <STR_LIT> ; if ( ( ! TARGET_COLDFIRE || DATA_REG_P ( operands [ <NUM_LIT> ] ) ) && GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT && ( INTVAL ( operands [ <NUM_LIT> ] ) & <NUM_LIT> ) == <NUM_LIT> ) { CC_STATUS_INIT ; return <STR_LIT> ; }


<s> const char * output_move_qimode ( rtx * operands ) { gcc_assert ( ! ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM && GET_CODE ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) == PRE_DEC && XEXP ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) , <NUM_LIT> ) == stack_pointer_rtx && ! ADDRESS_REG_P ( operands [ <NUM_LIT> ] ) && ! TARGET_COLDFIRE ) ) ; if ( ! ADDRESS_REG_P ( operands [ <NUM_LIT> ] ) && ( ( TARGET_68020 || TARGET_COLDFIRE ) || ! ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM && MEM_VOLATILE_P ( operands [ <NUM_LIT> ] ) ) ) ) { if ( operands [ <NUM_LIT> ] == const0_rtx ) return <STR_LIT> ; if ( ( ! TARGET_COLDFIRE || DATA_REG_P ( operands [ <NUM_LIT> ] ) ) && GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT && ( INTVAL ( operands [ <NUM_LIT> ] ) & <NUM_LIT> ) == <NUM_LIT> ) { CC_STATUS_INIT ; return <STR_LIT> ; } }

if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT && DATA_REG_P ( operands [ <NUM_LIT> ] ) && INTVAL ( operands [ <NUM_LIT> ] ) < <NUM_LIT> && INTVAL ( operands [ <NUM_LIT> ] ) >= - <NUM_LIT> ) {


<s> else if ( ( GET_CODE ( operands [ <NUM_LIT> ] ) == SYMBOL_REF || GET_CODE ( operands [ <NUM_LIT> ] ) == CONST ) && push_operand ( operands [ <NUM_LIT> ] , SImode ) ) return <STR_LIT> ; else if ( ( GET_CODE ( operands [ <NUM_LIT> ] ) == SYMBOL_REF || GET_CODE ( operands [ <NUM_LIT> ] ) == CONST ) && ADDRESS_REG_P ( operands [ <NUM_LIT> ] ) ) return <STR_LIT> ;


<s> if ( valid_mov3q_const ( operands [ <NUM_LIT> ] ) ) return <STR_LIT> ; return <STR_LIT> ; }

else if ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM && GET_CODE ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) == PRE_DEC && REGNO ( XEXP ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) , <NUM_LIT> ) ) == STACK_POINTER_REGNUM && INTVAL ( operands [ <NUM_LIT> ] ) < <NUM_LIT> && INTVAL ( operands [ <NUM_LIT> ] ) >= - <NUM_LIT> ) {


<s> const char * output_move_stricthi ( rtx * operands ) { if ( operands [ <NUM_LIT> ] == const0_rtx && ( ( TARGET_68020 || TARGET_COLDFIRE ) || ! ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM && MEM_VOLATILE_P ( operands [ <NUM_LIT> ] ) ) ) ) return <STR_LIT> ; return <STR_LIT> ;


<s> const char * output_move_strictqi ( rtx * operands ) { if ( operands [ <NUM_LIT> ] == const0_rtx && ( ( TARGET_68020 || TARGET_COLDFIRE ) || ! ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM && MEM_VOLATILE_P ( operands [ <NUM_LIT> ] ) ) ) ) return <STR_LIT> ;


<s> const char * output_move_strictqi ( rtx * operands ) { if ( operands [ <NUM_LIT> ] == const0_rtx && ( ( TARGET_68020 || TARGET_COLDFIRE ) || ! ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM && MEM_VOLATILE_P ( operands [ <NUM_LIT> ] ) ) ) ) return <STR_LIT> ; return <STR_LIT> ;


<s> return <STR_LIT> ; } if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT && ( logval = exact_log2 ( INTVAL ( operands [ <NUM_LIT> ] ) ) ) >= <NUM_LIT> && ( DATA_REG_P ( operands [ <NUM_LIT> ] ) || offsettable_memref_p ( operands [ <NUM_LIT> ] ) ) ) { if ( DATA_REG_P ( operands [ <NUM_LIT> ] ) ) operands [ <NUM_LIT> ] = GEN_INT ( logval ) ;


<s> void override_options ( void ) { if ( TARGET_SEP_DATA && TARGET_ID_SHARED_LIBRARY ) error ( <STR_LIT> ) ; if ( TARGET_SEP_DATA || TARGET_ID_SHARED_LIBRARY ) flag_pic = <NUM_LIT> ;

if ( ! TARGET_68020 && ! TARGET_COLDFIRE && ( flag_pic == <NUM_LIT> ) ) error ( <STR_LIT> ) ;


<s> void override_options ( void ) { if ( TARGET_SEP_DATA && TARGET_ID_SHARED_LIBRARY ) error ( <STR_LIT> ) ; if ( TARGET_SEP_DATA || TARGET_ID_SHARED_LIBRARY ) flag_pic = <NUM_LIT> ; if ( ! TARGET_68020 && ! TARGET_COLDFIRE && ( flag_pic == <NUM_LIT> ) ) error ( <STR_LIT> ) ;


<s> REAL_VALUE_FROM_CONST_DOUBLE ( r , x ) ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { if ( REAL_VALUES_IDENTICAL ( r , values_68881 [ i ] ) ) return ( codes_68881 [ i ] ) ; }

if ( GET_MODE ( x ) == SFmode ) return <NUM_LIT> ;


<s> rtx p ; p = prev_nonnote_insn ( first_insn ) ; while ( p ) { if ( GET_CODE ( p ) != INSN ) return false ; if ( reg_set_p ( target , p ) ) { rtx set = single_set ( p ) ; rtx dest ; if ( ! set ) return false ;


<s> p = prev_nonnote_insn ( first_insn ) ; while ( p ) { if ( GET_CODE ( p ) != INSN ) return false ; if ( reg_set_p ( target , p ) ) { rtx set = single_set ( p ) ; rtx dest ; if ( ! set ) return false ; dest = SET_DEST ( set ) ; if ( rtx_equal_p ( dest , target ) && SET_SRC ( set ) == const0_rtx ) return true ; else if ( GET_CODE ( dest ) == STRICT_LOW_PART && GET_CODE ( XEXP ( dest , <NUM_LIT> ) ) == REG && REGNO ( XEXP ( dest , <NUM_LIT> ) ) == REGNO ( target ) && ( GET_MODE_SIZE ( GET_MODE ( XEXP ( dest , <NUM_LIT> ) ) ) <= GET_MODE_SIZE ( mode ) ) ) ;


<s> m68k_compute_frame_layout ( ) ; return current_frame . reg_no ? false : true ;


<s> case EQ : case NE : case GTU : case LTU : case GEU : case LEU : return <NUM_LIT> ;


<s> int i ; if ( TARGET_CFV4 && GET_CODE ( constant ) == CONST_INT ) { i = INTVAL ( constant ) ; if ( ( i == - <NUM_LIT> ) || ( i >= <NUM_LIT> && i <= <NUM_LIT> ) ) return <NUM_LIT> ;


<s> int valid_mov3q_const ( rtx constant ) { int i ; if ( TARGET_CFV4 && GET_CODE ( constant ) == CONST_INT ) { i = INTVAL ( constant ) ; if ( ( i == - <NUM_LIT> ) || ( i >= <NUM_LIT> && i <= <NUM_LIT> ) ) return <NUM_LIT> ; } return <NUM_LIT> ;


<s> gcc_assert ( GET_MODE ( reg1 ) == SImode && - <NUM_LIT> <= n && n != <NUM_LIT> && n <= <NUM_LIT> ) ; reg1 = copy_rtx ( reg1 ) ; reg2 = copy_rtx ( reg1 ) ; if ( n < <NUM_LIT> ) emit_insn ( gen_subsi3 ( reg1 , reg2 , GEN_INT ( - n ) ) ) ; else if ( n > <NUM_LIT> ) emit_insn ( gen_addsi3 ( reg1 , reg2 , GEN_INT ( n ) ) ) ;


<s> if ( n < <NUM_LIT> ) emit_insn ( gen_subsi3 ( reg1 , reg2 , GEN_INT ( - n ) ) ) ; else if ( n > <NUM_LIT> ) emit_insn ( gen_addsi3 ( reg1 , reg2 , GEN_INT ( n ) ) ) ; else gcc_unreachable ( ) ;


<s> if ( REAL_VALUES_LESS ( r , dconst1 ) ) return <NUM_LIT> ; exp = real_exponent ( & r ) ; real_2expN ( & r1 , exp , DFmode ) ;


<s> int exp ; REAL_VALUE_FROM_CONST_DOUBLE ( r , x ) ; if ( REAL_VALUES_LESS ( r , dconst1 ) ) return <NUM_LIT> ;


<s> rtx_insn * insns ; rtx dest ; start_sequence ( ) ; m68k_libcall_value_in_a0_p = true ; a0 = emit_library_call_value ( m68k_get_m68k_read_tp ( ) , NULL_RTX , LCT_PURE , Pmode , <NUM_LIT> ) ; m68k_libcall_value_in_a0_p = false ; insns = get_insns ( ) ; end_sequence ( ) ; eqv = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , const1_rtx ) , UNSPEC_RELOC32 ) ; gcc_assert ( can_create_pseudo_p ( ) ) ; dest = gen_reg_rtx ( Pmode ) ;

emit_libcall_block ( insns , dest , a0 , eqv ) ;


<s> insns = get_insns ( ) ; end_sequence ( ) ; eqv = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , const1_rtx ) , UNSPEC_RELOC32 ) ;

gcc_assert ( can_create_pseudo_p ( ) ) ;


<s> static rtx m68k_call_tls_get_addr ( rtx x , rtx eqv , enum m68k_reloc reloc ) { rtx a0 ; rtx_insn * insns ; rtx dest ; start_sequence ( ) ;

x = m68k_wrap_symbol ( x , reloc , m68k_get_gp ( ) , NULL_RTX ) ;


<s> if ( ! TARGET_HARD_FLOAT ) { COPY_HARD_REG_SET ( x , reg_class_contents [ ( int ) FP_REGS ] ) ;

for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( TEST_HARD_REG_BIT ( x , i ) ) fixed_regs [ i ] = call_used_regs [ i ] = <NUM_LIT> ;


<s> for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( TEST_HARD_REG_BIT ( x , i ) ) fixed_regs [ i ] = call_used_regs [ i ] = <NUM_LIT> ; }


<s> operands [ ! store_p ] = gen_frame_mem ( mode , addr ) ; operands [ store_p ] = gen_rtx_REG ( mode , regno ) ; XVECEXP ( body , <NUM_LIT> , i ++ ) = gen_rtx_SET ( VOIDmode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; offset += GET_MODE_SIZE ( mode ) ; } gcc_assert ( i == XVECLEN ( body , <NUM_LIT> ) ) ;


<s> if ( TARGET_COLDFIRE && restore_from_sp ) { if ( current_frame . reg_no >= MIN_MOVEM_REGS ) fsize_with_regs += current_frame . reg_no * GET_MODE_SIZE ( SImode ) ; if ( current_frame . fpu_no >= MIN_FMOVEM_REGS ) fsize_with_regs += current_frame . fpu_no * GET_MODE_SIZE ( DFmode ) ; } if ( current_frame . offset + fsize >= <NUM_LIT> && ! restore_from_sp && ( current_frame . reg_mask || current_frame . fpu_mask ) ) { if ( TARGET_COLDFIRE && ( current_frame . reg_no >= MIN_MOVEM_REGS || current_frame . fpu_no >= MIN_FMOVEM_REGS ) ) { emit_move_insn ( gen_rtx_REG ( Pmode , A1_REG ) , GEN_INT ( - ( current_frame . offset + fsize ) ) ) ; emit_insn ( gen_addsi3 ( stack_pointer_rtx , gen_rtx_REG ( Pmode , A1_REG ) , frame_pointer_rtx ) ) ; restore_from_sp = true ; } else { emit_move_insn ( gen_rtx_REG ( Pmode , A1_REG ) , GEN_INT ( - fsize ) ) ; fsize = <NUM_LIT> ; big = true ; } } if ( current_frame . reg_no < MIN_MOVEM_REGS ) { int i ; HOST_WIDE_INT offset ; offset = current_frame . offset + fsize ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( current_frame . reg_mask & ( <NUM_LIT> << i ) ) { rtx addr ; if ( big ) {


<s> CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ;

* cum += ( mode != BLKmode ? ( GET_MODE_SIZE ( mode ) + <NUM_LIT> ) & ~ <NUM_LIT> : ( int_size_in_bytes ( type ) + <NUM_LIT> ) & ~ <NUM_LIT> ) ;


<s> * cum += ( mode != BLKmode ? ( GET_MODE_SIZE ( mode ) + <NUM_LIT> ) & ~ <NUM_LIT> : ( int_size_in_bytes ( type ) + <NUM_LIT> ) & ~ <NUM_LIT> ) ;


<s> gcc_assert ( MOTOROLA || reloc == RELOC_GOT ) ; switch ( reloc ) { case RELOC_GOT : if ( MOTOROLA ) { if ( flag_pic == <NUM_LIT> && TARGET_68020 ) return <STR_LIT> ; else return <STR_LIT> ; } else { if ( TARGET_68020 ) { switch ( flag_pic ) { case <NUM_LIT> : return <STR_LIT> ;


<s> switch ( mode ) { case SFmode : case DFmode : case XFmode : if ( TARGET_68881 ) return gen_rtx_REG ( mode , FP0_REG ) ; break ; default : break ; }


<s> case SFmode : case DFmode : case XFmode : if ( TARGET_68881 ) return gen_rtx_REG ( mode , FP0_REG ) ; break ; default : break ; } return gen_rtx_REG ( mode , m68k_libcall_value_in_a0_p ? A0_REG : D0_REG ) ;


<s> if ( ( m68k_cpu_flags & ( FL_68881 | FL_CF_FPU ) ) != <NUM_LIT> ) target_mask |= MASK_HARD_FLOAT ; target_flags |= target_mask & ~ target_flags_explicit ; m68k_cpu = entry -> device ; if ( m68k_tune_entry ) { m68k_tune = m68k_tune_entry -> microarch ; m68k_tune_flags = m68k_tune_entry -> flags ; } else if ( ! m68k_cpu_entry && ! m68k_arch_entry ) { enum target_device dev ; dev = all_microarchs [ M68K_DEFAULT_TUNE ] . device ; m68k_tune_flags = all_devices [ dev ] . flags ; } else { m68k_tune = entry -> microarch ; m68k_tune_flags = entry -> flags ; } m68k_fpu = ( ! TARGET_HARD_FLOAT ? FPUTYPE_NONE : ( m68k_cpu_flags & FL_COLDFIRE ) != <NUM_LIT> ? FPUTYPE_COLDFIRE : FPUTYPE_68881 ) ; if ( TARGET_SEP_DATA && TARGET_ID_SHARED_LIBRARY ) error ( <STR_LIT> ) ; if ( TARGET_SEP_DATA || TARGET_ID_SHARED_LIBRARY ) flag_pic = <NUM_LIT> ; if ( TARGET_PCREL && ! TARGET_68020 && flag_pic == <NUM_LIT> ) error ( <STR_LIT> ) ; if ( TARGET_PCREL && flag_pic == <NUM_LIT> ) flag_pic = <NUM_LIT> ; if ( ! flag_pic ) { m68k_symbolic_call_var = M68K_SYMBOLIC_CALL_JSR ; m68k_symbolic_jump = <STR_LIT> ; } else if ( TARGET_ID_SHARED_LIBRARY ) ; else if ( TARGET_68020 || TARGET_ISAB || TARGET_ISAC ) { if ( TARGET_PCREL ) m68k_symbolic_call_var = M68K_SYMBOLIC_CALL_BSR_C ; else m68k_symbolic_call_var = M68K_SYMBOLIC_CALL_BSR_P ; if ( TARGET_ISAC ) ; else if ( TARGET_PCREL ) m68k_symbolic_jump = <STR_LIT> ; else m68k_symbolic_jump = <STR_LIT> ; flag_no_function_cse = <NUM_LIT> ; } switch ( m68k_symbolic_call_var ) { case M68K_SYMBOLIC_CALL_JSR : m68k_symbolic_call = <STR_LIT> ; break ; case M68K_SYMBOLIC_CALL_BSR_C : m68k_symbolic_call = <STR_LIT> ;


<s> offset = GEN_INT ( delta ) ; if ( ( delta < - <NUM_LIT> || delta > <NUM_LIT> ) && ( TARGET_COLDFIRE || USE_MOVQ ( delta ) ) ) { emit_move_insn ( gen_rtx_REG ( Pmode , D0_REG ) , offset ) ; offset = gen_rtx_REG ( Pmode , D0_REG ) ; } emit_insn ( gen_add3_insn ( copy_rtx ( this_slot ) , copy_rtx ( this_slot ) , offset ) ) ; } if ( vcall_offset != <NUM_LIT> ) { emit_move_insn ( tmp , this_slot ) ; emit_move_insn ( tmp , gen_rtx_MEM ( Pmode , tmp ) ) ; addr = plus_constant ( Pmode , tmp , vcall_offset ) ; if ( ! m68k_legitimate_address_p ( Pmode , addr , true ) ) { emit_insn ( gen_rtx_SET ( VOIDmode , tmp , addr ) ) ; addr = tmp ; }

emit_move_insn ( gen_rtx_REG ( Pmode , D0_REG ) , gen_rtx_MEM ( Pmode , addr ) ) ;


<s> else if ( FP_REGNO_P ( regno ) ) { if ( ( GET_MODE_CLASS ( mode ) == MODE_FLOAT || GET_MODE_CLASS ( mode ) == MODE_COMPLEX_FLOAT ) && GET_MODE_UNIT_SIZE ( mode ) <= TARGET_FP_REG_SIZE ) return true ; } return false ;


<s> return ( ( TARGET_RTD && ( ! fundecl || TREE_CODE ( fundecl ) != IDENTIFIER_NODE ) && ( ! stdarg_p ( funtype ) ) ) ? size : <NUM_LIT> ) ;


<s> } if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT && ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) == <NUM_LIT> ) ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT && ! ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) > <NUM_LIT> && INTVAL ( XEXP ( x , <NUM_LIT> ) ) <= <NUM_LIT> ) ) { * total = COSTS_N_INSNS ( TARGET_COLDFIRE ? <NUM_LIT> : <NUM_LIT> ) ; return true ; } return false ; case MULT : if ( ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == ZERO_EXTEND || GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == SIGN_EXTEND ) && GET_MODE ( x ) == SImode ) * total = COSTS_N_INSNS ( MULW_COST ) ; else if ( GET_MODE ( x ) == QImode || GET_MODE ( x ) == HImode ) * total = COSTS_N_INSNS ( MULW_COST ) ; else * total = COSTS_N_INSNS ( MULL_COST ) ; return true ; case DIV : case UDIV : case MOD : case UMOD : if ( GET_MODE ( x ) == QImode || GET_MODE ( x ) == HImode ) * total = COSTS_N_INSNS ( DIVW_COST ) ; else if ( TARGET_CF_HWDIV ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case ZERO_EXTRACT : if ( outer_code == COMPARE ) * total = <NUM_LIT> ; return false ; default : return false ; }


<s> return true ; case CONST : case LABEL_REF : case SYMBOL_REF : * total = <NUM_LIT> ; return true ; case CONST_DOUBLE : if ( outer_code == COMPARE && ( x == CONST0_RTX ( SFmode ) || x == CONST0_RTX ( DFmode ) ) ) * total = <NUM_LIT> ; else * total = <NUM_LIT> ; return true ; ( TUNE_68060 ? <NUM_LIT> \ : TUNE_68040 ? <NUM_LIT> \ : ( TUNE_CFV2 && TUNE_EMAC ) ? <NUM_LIT> \ : ( TUNE_CFV2 && TUNE_MAC ) ? <NUM_LIT> \ : TUNE_CFV2 ? <NUM_LIT> \ : TARGET_COLDFIRE ? <NUM_LIT> : <NUM_LIT> ) ( TUNE_68060 ? <NUM_LIT> \ : TUNE_68040 ? <NUM_LIT> \ : TUNE_68000_10 ? <NUM_LIT> \ : ( TUNE_CFV2 && TUNE_EMAC ) ? <NUM_LIT> \ : ( TUNE_CFV2 && TUNE_MAC ) ? <NUM_LIT> \ : TUNE_CFV2 ? <NUM_LIT> \ : TARGET_COLDFIRE ? <NUM_LIT> : <NUM_LIT> ) ( TARGET_CF_HWDIV ? <NUM_LIT> \ : TUNE_68000_10 || TARGET_COLDFIRE ? <NUM_LIT> : <NUM_LIT> ) case PLUS : if ( GET_MODE ( x ) == SImode && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == REG && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == MULT && GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == REG && GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == CONST_INT && ( INTVAL ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == <NUM_LIT> || INTVAL ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == <NUM_LIT> || INTVAL ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == <NUM_LIT> ) ) { * total = COSTS_N_INSNS ( TARGET_COLDFIRE ? <NUM_LIT> : <NUM_LIT> ) ; return true ; } return false ; case ASHIFT : case ASHIFTRT : case LSHIFTRT : if ( TUNE_68060 ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } if ( TUNE_68000_10 ) { if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) { if ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) < <NUM_LIT> ) * total = COSTS_N_INSNS ( <NUM_LIT> ) + INTVAL ( XEXP ( x , <NUM_LIT> ) ) / <NUM_LIT> ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) + ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) - <NUM_LIT> ) / <NUM_LIT> ; } else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT && ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) == <NUM_LIT> ) ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ;


<s> static bool m68k_save_reg ( unsigned int regno , bool interrupt_handler ) { if ( flag_pic && regno == PIC_REG ) { if ( crtl -> saves_all_registers ) return true ; if ( crtl -> uses_pic_offset_table ) return true ; if ( crtl -> uses_const_pool ) return true ; } if ( crtl -> calls_eh_return ) { unsigned int i ; for ( i = <NUM_LIT> ; ; i ++ ) {

unsigned int test = EH_RETURN_DATA_REGNO ( i ) ;


<s> for ( i = <NUM_LIT> ; ; i ++ ) { unsigned int test = EH_RETURN_DATA_REGNO ( i ) ; if ( test == INVALID_REGNUM ) break ; if ( test == regno ) return true ; } } if ( fixed_regs [ regno ] ) return false ; if ( regno == FRAME_POINTER_REGNUM && frame_pointer_needed ) return false ; if ( interrupt_handler ) {

if ( df_regs_ever_live_p ( regno ) ) return true ;


<s> sched_cfv4_bypass_data . con = NULL ; sched_cfv4_bypass_data . scale = <NUM_LIT> ; } else gcc_assert ( sched_cfv4_bypass_data . pro == NULL && sched_cfv4_bypass_data . con == NULL && sched_cfv4_bypass_data . scale == <NUM_LIT> ) ; delay = min_insn_conflict_delay ( sched_adjust_cost_state , def_insn , insn ) ; if ( delay > cost ) cost = delay ;


<s> else if ( ! FP_REG_P ( SET_DEST ( exp ) ) && ! FP_REG_P ( SET_SRC ( exp ) ) && GET_MODE_SIZE ( GET_MODE ( SET_SRC ( exp ) ) ) > <NUM_LIT> && ( GET_CODE ( SET_SRC ( exp ) ) == REG || GET_CODE ( SET_SRC ( exp ) ) == MEM || GET_CODE ( SET_SRC ( exp ) ) == CONST_DOUBLE ) ) CC_STATUS_INIT ; else if ( SET_DEST ( exp ) != pc_rtx ) { cc_status . flags = <NUM_LIT> ; cc_status . value1 = SET_DEST ( exp ) ; cc_status . value2 = SET_SRC ( exp ) ; } } else if ( GET_CODE ( exp ) == PARALLEL && GET_CODE ( XVECEXP ( exp , <NUM_LIT> , <NUM_LIT> ) ) == SET ) { rtx dest = SET_DEST ( XVECEXP ( exp , <NUM_LIT> , <NUM_LIT> ) ) ; rtx src = SET_SRC ( XVECEXP ( exp , <NUM_LIT> , <NUM_LIT> ) ) ; if ( ADDRESS_REG_P ( dest ) ) CC_STATUS_INIT ; else if ( dest != pc_rtx ) { cc_status . flags = <NUM_LIT> ; cc_status . value1 = dest ; cc_status . value2 = src ; } } else CC_STATUS_INIT ; if ( cc_status . value2 != <NUM_LIT> && ADDRESS_REG_P ( cc_status . value2 ) && GET_MODE ( cc_status . value2 ) == QImode ) CC_STATUS_INIT ; if ( cc_status . value2 != <NUM_LIT> ) switch ( GET_CODE ( cc_status . value2 ) ) { case ASHIFT : case ASHIFTRT : case LSHIFTRT : case ROTATE : case ROTATERT : cc_status . flags |= CC_OVERFLOW_UNUSABLE | CC_NO_CARRY ; break ;


<s> cc_status . value1 = SET_DEST ( exp ) ; cc_status . value2 = SET_SRC ( exp ) ; } } else if ( GET_CODE ( exp ) == PARALLEL && GET_CODE ( XVECEXP ( exp , <NUM_LIT> , <NUM_LIT> ) ) == SET ) { rtx dest = SET_DEST ( XVECEXP ( exp , <NUM_LIT> , <NUM_LIT> ) ) ; rtx src = SET_SRC ( XVECEXP ( exp , <NUM_LIT> , <NUM_LIT> ) ) ; if ( ADDRESS_REG_P ( dest ) ) CC_STATUS_INIT ; else if ( dest != pc_rtx ) { cc_status . flags = <NUM_LIT> ; cc_status . value1 = dest ; cc_status . value2 = src ; } } else CC_STATUS_INIT ; if ( cc_status . value2 != <NUM_LIT> && ADDRESS_REG_P ( cc_status . value2 ) && GET_MODE ( cc_status . value2 ) == QImode ) CC_STATUS_INIT ; if ( cc_status . value2 != <NUM_LIT> ) switch ( GET_CODE ( cc_status . value2 ) ) { case ASHIFT : case ASHIFTRT : case LSHIFTRT : case ROTATE : case ROTATERT : cc_status . flags |= CC_OVERFLOW_UNUSABLE | CC_NO_CARRY ; break ; case PLUS : case MINUS : case MULT : case DIV : case UDIV : case MOD : case UMOD : case NEG : if ( GET_MODE ( cc_status . value2 ) != VOIDmode ) cc_status . flags |= CC_NO_OVERFLOW ; break ; case ZERO_EXTEND : cc_status . flags |= CC_NOT_NEGATIVE ; default : break ; } if ( cc_status . value1 && GET_CODE ( cc_status . value1 ) == REG && cc_status . value2 && reg_overlap_mentioned_p ( cc_status . value1 , cc_status . value2 ) ) cc_status . value2 = <NUM_LIT> ; if ( cc_status . value1 && GET_CODE ( cc_status . value1 ) == MEM && GET_CODE ( XEXP ( cc_status . value1 , <NUM_LIT> ) ) == PRE_DEC && cc_status . value2 && reg_overlap_mentioned_p ( XEXP ( XEXP ( cc_status . value1 , <NUM_LIT> ) , <NUM_LIT> ) , cc_status . value2 ) ) cc_status . value2 = <NUM_LIT> ; if ( ( ( cc_status . value1 && FP_REG_P ( cc_status . value1 ) ) || ( cc_status . value2 && FP_REG_P ( cc_status . value2 ) ) ) ) cc_status . flags = CC_IN_68881 ; if ( cc_status . value2 && GET_CODE ( cc_status . value2 ) == COMPARE && GET_MODE_CLASS ( GET_MODE ( XEXP ( cc_status . value2 , <NUM_LIT> ) ) ) == MODE_FLOAT ) { cc_status . flags = CC_IN_68881 ; if ( ! FP_REG_P ( XEXP ( cc_status . value2 , <NUM_LIT> ) ) && FP_REG_P ( XEXP ( cc_status . value2 , <NUM_LIT> ) ) ) cc_status . flags |= CC_REVERSED ; }


<s> operands [ <NUM_LIT> ] = GEN_INT ( INTVAL ( operands [ <NUM_LIT> ] ) & <NUM_LIT> ) ; CC_STATUS_INIT ; if ( operands [ <NUM_LIT> ] == const0_rtx ) return <STR_LIT> ; return <STR_LIT> ; } if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT && ( logval = exact_log2 ( ~ INTVAL ( operands [ <NUM_LIT> ] ) & <NUM_LIT> ) ) >= <NUM_LIT> && ( DATA_REG_P ( operands [ <NUM_LIT> ] ) || offsettable_memref_p ( operands [ <NUM_LIT> ] ) ) ) { if ( DATA_REG_P ( operands [ <NUM_LIT> ] ) ) operands [ <NUM_LIT> ] = GEN_INT ( logval ) ; else { operands [ <NUM_LIT> ] = adjust_address ( operands [ <NUM_LIT> ] , SImode , <NUM_LIT> - ( logval / <NUM_LIT> ) ) ; operands [ <NUM_LIT> ] = GEN_INT ( logval % <NUM_LIT> ) ; } CC_STATUS_INIT ; return <STR_LIT> ;


<s> CC_STATUS_INIT ; if ( operands [ <NUM_LIT> ] == const0_rtx ) return <STR_LIT> ; return <STR_LIT> ; } if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT && ( logval = exact_log2 ( ~ INTVAL ( operands [ <NUM_LIT> ] ) & <NUM_LIT> ) ) >= <NUM_LIT> && ( DATA_REG_P ( operands [ <NUM_LIT> ] ) || offsettable_memref_p ( operands [ <NUM_LIT> ] ) ) ) { if ( DATA_REG_P ( operands [ <NUM_LIT> ] ) ) operands [ <NUM_LIT> ] = GEN_INT ( logval ) ; else { operands [ <NUM_LIT> ] = adjust_address ( operands [ <NUM_LIT> ] , SImode , <NUM_LIT> - ( logval / <NUM_LIT> ) ) ; operands [ <NUM_LIT> ] = GEN_INT ( logval % <NUM_LIT> ) ;


<s> const char * output_btst ( rtx * operands , rtx countop , rtx dataop , rtx_insn * insn , int signpos ) { operands [ <NUM_LIT> ] = countop ; operands [ <NUM_LIT> ] = dataop ; if ( GET_CODE ( countop ) == CONST_INT ) { register int count = INTVAL ( countop ) ; if ( count > signpos ) { int offset = ( count & ~ signpos ) / <NUM_LIT> ; count = count & signpos ; operands [ <NUM_LIT> ] = dataop = adjust_address ( dataop , QImode , offset ) ; } if ( count == signpos ) cc_status . flags = CC_NOT_POSITIVE | CC_Z_IN_NOT_N ; else cc_status . flags = CC_NOT_NEGATIVE | CC_Z_IN_NOT_N ; if ( count == <NUM_LIT> && next_insn_tests_no_inequality ( insn ) ) return <STR_LIT> ; if ( count == <NUM_LIT> && next_insn_tests_no_inequality ( insn ) ) return <STR_LIT> ; if ( count == <NUM_LIT> && next_insn_tests_no_inequality ( insn ) ) return <STR_LIT> ; if ( TUNE_CPU32 || TARGET_COLDFIRE || optimize_size ) { if ( count == <NUM_LIT> && DATA_REG_P ( operands [ <NUM_LIT> ] ) && next_insn_tests_no_inequality ( insn ) ) { cc_status . flags = CC_NOT_NEGATIVE | CC_Z_IN_NOT_N | CC_NO_OVERFLOW ; return <STR_LIT> ; } if ( count == <NUM_LIT> && DATA_REG_P ( operands [ <NUM_LIT> ] ) && next_insn_tests_no_inequality ( insn ) ) {


<s> break ; case LT : output_asm_insn ( <STR_LIT> , operands ) ; break ; case LTU : output_asm_insn ( <STR_LIT> , operands ) ; break ; case GE : output_asm_insn ( <STR_LIT> , operands ) ; break ; case GEU : output_asm_insn ( <STR_LIT> , operands ) ; break ; case LE : output_asm_insn ( <STR_LIT> , operands ) ; break ; case LEU : output_asm_insn ( <STR_LIT> , operands ) ; break ; default : gcc_unreachable ( ) ; } switch ( GET_MODE ( operands [ <NUM_LIT> ] ) ) { case SImode : output_asm_insn ( <STR_LIT> , operands ) ; break ; case HImode : break ; default :


<s> break ; case GTU : output_asm_insn ( <STR_LIT> , operands ) ; break ; case LT : output_asm_insn ( <STR_LIT> , operands ) ; break ; case LTU : output_asm_insn ( <STR_LIT> , operands ) ; break ; case GE : output_asm_insn ( <STR_LIT> , operands ) ; break ; case GEU : output_asm_insn ( <STR_LIT> , operands ) ; break ; case LE : output_asm_insn ( <STR_LIT> , operands ) ; break ; case LEU : output_asm_insn ( <STR_LIT> , operands ) ; break ;


<s> if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT && INTVAL ( operands [ <NUM_LIT> ] ) >> <NUM_LIT> == <NUM_LIT> && ( DATA_REG_P ( operands [ <NUM_LIT> ] ) || offsettable_memref_p ( operands [ <NUM_LIT> ] ) ) && ! TARGET_COLDFIRE ) { if ( GET_CODE ( operands [ <NUM_LIT> ] ) != REG ) operands [ <NUM_LIT> ] = adjust_address ( operands [ <NUM_LIT> ] , HImode , <NUM_LIT> ) ; CC_STATUS_INIT ; if ( INTVAL ( operands [ <NUM_LIT> ] ) == <NUM_LIT> ) return <STR_LIT> ;


<s> else if ( DATA_REG_P ( operands [ <NUM_LIT> ] ) && INTVAL ( operands [ <NUM_LIT> ] ) < <NUM_LIT> && INTVAL ( operands [ <NUM_LIT> ] ) >= - <NUM_LIT> ) return <STR_LIT> ; else if ( INTVAL ( operands [ <NUM_LIT> ] ) < <NUM_LIT> && INTVAL ( operands [ <NUM_LIT> ] ) >= - <NUM_LIT> ) return <STR_LIT> ;


<s> if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT && DATA_REG_P ( operands [ <NUM_LIT> ] ) && INTVAL ( operands [ <NUM_LIT> ] ) < <NUM_LIT> && INTVAL ( operands [ <NUM_LIT> ] ) >= - <NUM_LIT> ) return <STR_LIT> ; if ( operands [ <NUM_LIT> ] == const0_rtx && ADDRESS_REG_P ( operands [ <NUM_LIT> ] ) ) return <STR_LIT> ; if ( GET_CODE ( operands [ <NUM_LIT> ] ) != CONST_INT && CONSTANT_P ( operands [ <NUM_LIT> ] ) ) return <STR_LIT> ;

if ( ADDRESS_REG_P ( operands [ <NUM_LIT> ] ) || ADDRESS_REG_P ( operands [ <NUM_LIT> ] ) ) return <STR_LIT> ;


<s> if ( ( ! TARGET_COLDFIRE || DATA_REG_P ( operands [ <NUM_LIT> ] ) ) && GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT && ( INTVAL ( operands [ <NUM_LIT> ] ) & <NUM_LIT> ) == <NUM_LIT> ) { CC_STATUS_INIT ; return <STR_LIT> ; } } if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT && DATA_REG_P ( operands [ <NUM_LIT> ] ) && INTVAL ( operands [ <NUM_LIT> ] ) < <NUM_LIT> && INTVAL ( operands [ <NUM_LIT> ] ) >= - <NUM_LIT> ) return <STR_LIT> ;

if ( operands [ <NUM_LIT> ] == const0_rtx && ADDRESS_REG_P ( operands [ <NUM_LIT> ] ) ) return <STR_LIT> ;


<s> case <NUM_LIT> : s = <STR_LIT> ; break ; case <NUM_LIT> : s = <STR_LIT> ; break ; case <NUM_LIT> : s = <STR_LIT> ; break ; case - <NUM_LIT> : s = <STR_LIT> ; break ;


<s> break ; case - <NUM_LIT> : s = <STR_LIT> ; break ; case - <NUM_LIT> : s = <STR_LIT> ; break ; case - <NUM_LIT> : s = <STR_LIT> ; break ; default : gcc_unreachable ( ) ; s = NULL ; } output_asm_insn ( s , & reg ) ;


<s> } if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT && ( logval = exact_log2 ( INTVAL ( operands [ <NUM_LIT> ] ) & <NUM_LIT> ) ) >= <NUM_LIT> && ( DATA_REG_P ( operands [ <NUM_LIT> ] ) || offsettable_memref_p ( operands [ <NUM_LIT> ] ) ) ) { if ( DATA_REG_P ( operands [ <NUM_LIT> ] ) ) operands [ <NUM_LIT> ] = GEN_INT ( logval ) ; else { operands [ <NUM_LIT> ] = adjust_address ( operands [ <NUM_LIT> ] , SImode , <NUM_LIT> - ( logval / <NUM_LIT> ) ) ; operands [ <NUM_LIT> ] = GEN_INT ( logval % <NUM_LIT> ) ; }


<s> } else if ( GET_CODE ( op ) == MEM ) { output_address ( XEXP ( op , <NUM_LIT> ) ) ; if ( letter == 'd' && ! TARGET_68020 && CONSTANT_ADDRESS_P ( XEXP ( op , <NUM_LIT> ) ) && ! ( GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == CONST_INT && INTVAL ( XEXP ( op , <NUM_LIT> ) ) < <NUM_LIT> && INTVAL ( XEXP ( op , <NUM_LIT> ) ) >= - <NUM_LIT> ) ) fprintf ( file , MOTOROLA ? <STR_LIT> : <STR_LIT> ) ; } else if ( GET_CODE ( op ) == CONST_DOUBLE && GET_MODE ( op ) == SFmode ) { REAL_VALUE_TYPE r ; long l ; REAL_VALUE_FROM_CONST_DOUBLE ( r , op ) ; REAL_VALUE_TO_TARGET_SINGLE ( r , l ) ; asm_fprintf ( file , <STR_LIT> , l & <NUM_LIT> ) ; } else if ( GET_CODE ( op ) == CONST_DOUBLE && GET_MODE ( op ) == XFmode ) { REAL_VALUE_TYPE r ; long l [ <NUM_LIT> ] ; REAL_VALUE_FROM_CONST_DOUBLE ( r , op ) ; REAL_VALUE_TO_TARGET_LONG_DOUBLE ( r , l ) ; asm_fprintf ( file , <STR_LIT> , l [ <NUM_LIT> ] & <NUM_LIT> , l [ <NUM_LIT> ] & <NUM_LIT> , l [ <NUM_LIT> ] & <NUM_LIT> ) ; } else if ( GET_CODE ( op ) == CONST_DOUBLE && GET_MODE ( op ) == DFmode ) {


<s> break ; default : break ; } if ( IN_RANGE ( ival , - <NUM_LIT> , <NUM_LIT> ) ) return OP_TYPE_IMM_W ; return OP_TYPE_IMM_L ; } if ( GET_CODE ( op ) == CONST_DOUBLE ) { switch ( GET_MODE ( op ) ) { case SFmode : return OP_TYPE_IMM_W ; case VOIDmode : case DFmode : return OP_TYPE_IMM_L ; default : gcc_unreachable ( ) ; } } if ( GET_CODE ( op ) == CONST || symbolic_operand ( op , VOIDmode ) || LABEL_P ( op ) ) { switch ( GET_MODE ( op ) ) { case QImode : return OP_TYPE_IMM_Q ; case HImode : return OP_TYPE_IMM_W ; case SImode : return OP_TYPE_IMM_L ; default : if ( symbolic_operand ( m68k_unwrap_symbol ( op , false ) , VOIDmode ) ) return OP_TYPE_IMM_W ; return OP_TYPE_IMM_L ; } } gcc_assert ( ! reload_completed ) ;

if ( FLOAT_MODE_P ( GET_MODE ( op ) ) ) return OP_TYPE_FPN ;


<s> if ( GET_CODE ( op ) == CONST_INT ) { int ival ; ival = INTVAL ( op ) ; switch ( get_attr_type ( insn ) ) { case TYPE_ALUQ_L : if ( IN_RANGE ( ival , <NUM_LIT> , <NUM_LIT> ) || IN_RANGE ( ival , - <NUM_LIT> , - <NUM_LIT> ) ) return OP_TYPE_IMM_Q ; gcc_assert ( ! reload_completed ) ; break ; case TYPE_MOVEQ_L : if ( USE_MOVQ ( ival ) ) return OP_TYPE_IMM_Q ; gcc_assert ( ! reload_completed ) ; break ; case TYPE_MOV3Q_L : if ( valid_mov3q_const ( ival ) ) return OP_TYPE_IMM_Q ; gcc_assert ( ! reload_completed ) ; break ; default : break ; } if ( IN_RANGE ( ival , - <NUM_LIT> , <NUM_LIT> ) ) return OP_TYPE_IMM_W ; return OP_TYPE_IMM_L ; } if ( GET_CODE ( op ) == CONST_DOUBLE ) { switch ( GET_MODE ( op ) ) { case SFmode : return OP_TYPE_IMM_W ; case VOIDmode : case DFmode : return OP_TYPE_IMM_L ; default : gcc_unreachable ( ) ; } } if ( GET_CODE ( op ) == CONST || symbolic_operand ( op , VOIDmode ) || LABEL_P ( op ) ) { switch ( GET_MODE ( op ) ) { case QImode : return OP_TYPE_IMM_Q ; case HImode :


<s> if ( TUNE_68040_60 ) return <NUM_LIT> ; if ( ! inited_68881_table ) init_68881_table ( ) ; REAL_VALUE_FROM_CONST_DOUBLE ( r , x ) ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { if ( REAL_VALUES_IDENTICAL ( r , values_68881 [ i ] ) ) return ( codes_68881 [ i ] ) ; }


<s> switch ( GET_CODE ( x ) ) { case EQ : case NE : case GTU : case LTU : case GEU : case LEU : return <NUM_LIT> ; case GT : case LT : case GE : case LE : return ! ( cc_prev_status . flags & CC_NO_OVERFLOW ) ; default :


<s> case EQ : case NE : case GTU : case LTU : case GEU : case LEU : return <NUM_LIT> ; case GT : case LT : case GE : case LE :

return ! ( cc_prev_status . flags & CC_NO_OVERFLOW ) ;


<s> addr = plus_constant ( Pmode , tmp , vcall_offset ) ; if ( ! m68k_legitimate_address_p ( Pmode , addr , true ) ) { emit_insn ( gen_rtx_SET ( tmp , addr ) ) ; addr = tmp ; } emit_move_insn ( gen_rtx_REG ( Pmode , D0_REG ) , gen_rtx_MEM ( Pmode , addr ) ) ; emit_insn ( gen_add3_insn ( copy_rtx ( this_slot ) , copy_rtx ( this_slot ) , gen_rtx_REG ( Pmode , D0_REG ) ) ) ; } mem = DECL_RTL ( function ) ; if ( ! sibcall_operand ( XEXP ( mem , <NUM_LIT> ) , VOIDmode ) ) { gcc_assert ( flag_pic ) ; if ( ! TARGET_SEP_DATA ) { SET_REGNO ( pic_offset_table_rtx , STATIC_CHAIN_REGNUM ) ; emit_insn ( gen_load_got ( pic_offset_table_rtx ) ) ; } legitimize_pic_address ( XEXP ( mem , <NUM_LIT> ) , Pmode , tmp ) ; mem = replace_equiv_address ( mem , tmp ) ; } insn = emit_call_insn ( gen_sibcall ( mem , const0_rtx ) ) ; SIBLING_CALL_P ( insn ) = <NUM_LIT> ; insn = get_insns ( ) ; split_all_insns_noflow ( ) ; final_start_function ( insn , file , <NUM_LIT> ) ; final ( insn , file , <NUM_LIT> ) ; final_end_function ( ) ; reload_completed = <NUM_LIT> ;


<s> if ( mode == SImode && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == REG && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == MULT && GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == REG && GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == CONST_INT && ( INTVAL ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == <NUM_LIT> || INTVAL ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == <NUM_LIT> || INTVAL ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == <NUM_LIT> ) ) { * total = COSTS_N_INSNS ( TARGET_COLDFIRE ? <NUM_LIT> : <NUM_LIT> ) ; return true ; } return false ; case ASHIFT : case ASHIFTRT : case LSHIFTRT : if ( TUNE_68060 ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } if ( TUNE_68000_10 ) { if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) { if ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) < <NUM_LIT> ) * total = COSTS_N_INSNS ( <NUM_LIT> ) + INTVAL ( XEXP ( x , <NUM_LIT> ) ) / <NUM_LIT> ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) + ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) - <NUM_LIT> ) / <NUM_LIT> ; } else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT && ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) == <NUM_LIT> ) ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT && ! ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) > <NUM_LIT> && INTVAL ( XEXP ( x , <NUM_LIT> ) ) <= <NUM_LIT> ) ) { * total = COSTS_N_INSNS ( TARGET_COLDFIRE ? <NUM_LIT> : <NUM_LIT> ) ; return true ; } return false ; case MULT : if ( ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == ZERO_EXTEND || GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == SIGN_EXTEND ) && mode == SImode ) * total = COSTS_N_INSNS ( MULW_COST ) ; else if ( mode == QImode || mode == HImode ) * total = COSTS_N_INSNS ( MULW_COST ) ; else * total = COSTS_N_INSNS ( MULL_COST ) ; return true ; case DIV : case UDIV : case MOD : case UMOD : if ( mode == QImode || mode == HImode ) * total = COSTS_N_INSNS ( DIVW_COST ) ; else if ( TARGET_CF_HWDIV ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case ZERO_EXTRACT : if ( outer_code == COMPARE ) * total = <NUM_LIT> ; return false ; default :


<s> output_address ( GET_MODE ( op ) , XEXP ( op , <NUM_LIT> ) ) ; if ( letter == 'd' && ! TARGET_68020 && CONSTANT_ADDRESS_P ( XEXP ( op , <NUM_LIT> ) ) && ! ( GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == CONST_INT && INTVAL ( XEXP ( op , <NUM_LIT> ) ) < <NUM_LIT> && INTVAL ( XEXP ( op , <NUM_LIT> ) ) >= - <NUM_LIT> ) ) fprintf ( file , MOTOROLA ? <STR_LIT> : <STR_LIT> ) ; } else if ( GET_CODE ( op ) == CONST_DOUBLE && GET_MODE ( op ) == SFmode ) { long l ; REAL_VALUE_TO_TARGET_SINGLE ( * CONST_DOUBLE_REAL_VALUE ( op ) , l ) ; asm_fprintf ( file , <STR_LIT> , l & <NUM_LIT> ) ; } else if ( GET_CODE ( op ) == CONST_DOUBLE && GET_MODE ( op ) == XFmode ) { long l [ <NUM_LIT> ] ; REAL_VALUE_TO_TARGET_LONG_DOUBLE ( * CONST_DOUBLE_REAL_VALUE ( op ) , l ) ; asm_fprintf ( file , <STR_LIT> , l [ <NUM_LIT> ] & <NUM_LIT> , l [ <NUM_LIT> ] & <NUM_LIT> , l [ <NUM_LIT> ] & <NUM_LIT> ) ; } else if ( GET_CODE ( op ) == CONST_DOUBLE && GET_MODE ( op ) == DFmode ) { long l [ <NUM_LIT> ] ; REAL_VALUE_TO_TARGET_DOUBLE ( * CONST_DOUBLE_REAL_VALUE ( op ) , l ) ; asm_fprintf ( file , <STR_LIT> , l [ <NUM_LIT> ] & <NUM_LIT> , l [ <NUM_LIT> ] & <NUM_LIT> ) ; } else { asm_fprintf ( file , <STR_LIT> ) ; if ( TARGET_PCREL && ( GET_CODE ( op ) == SYMBOL_REF || GET_CODE ( op ) == CONST ) ) print_operand_address ( file , op ) ; else output_addr_const ( file , op ) ;


<s> output_address ( GET_MODE ( op ) , XEXP ( op , <NUM_LIT> ) ) ; if ( letter == 'd' && ! TARGET_68020 && CONSTANT_ADDRESS_P ( XEXP ( op , <NUM_LIT> ) ) && ! ( GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == CONST_INT && INTVAL ( XEXP ( op , <NUM_LIT> ) ) < <NUM_LIT> && INTVAL ( XEXP ( op , <NUM_LIT> ) ) >= - <NUM_LIT> ) ) fprintf ( file , MOTOROLA ? <STR_LIT> : <STR_LIT> ) ; } else if ( GET_CODE ( op ) == CONST_DOUBLE && GET_MODE ( op ) == SFmode ) { long l ; REAL_VALUE_TO_TARGET_SINGLE ( * CONST_DOUBLE_REAL_VALUE ( op ) , l ) ; asm_fprintf ( file , <STR_LIT> , l & <NUM_LIT> ) ; } else if ( GET_CODE ( op ) == CONST_DOUBLE && GET_MODE ( op ) == XFmode ) { long l [ <NUM_LIT> ] ; REAL_VALUE_TO_TARGET_LONG_DOUBLE ( * CONST_DOUBLE_REAL_VALUE ( op ) , l ) ; asm_fprintf ( file , <STR_LIT> , l [ <NUM_LIT> ] & <NUM_LIT> , l [ <NUM_LIT> ] & <NUM_LIT> , l [ <NUM_LIT> ] & <NUM_LIT> ) ; } else if ( GET_CODE ( op ) == CONST_DOUBLE && GET_MODE ( op ) == DFmode ) { long l [ <NUM_LIT> ] ; REAL_VALUE_TO_TARGET_DOUBLE ( * CONST_DOUBLE_REAL_VALUE ( op ) , l ) ; asm_fprintf ( file , <STR_LIT> , l [ <NUM_LIT> ] & <NUM_LIT> , l [ <NUM_LIT> ] & <NUM_LIT> ) ; } else {


<s> m68k_tune_flags = entry -> flags ; } m68k_fpu = ( ! TARGET_HARD_FLOAT ? FPUTYPE_NONE : ( m68k_cpu_flags & FL_COLDFIRE ) != <NUM_LIT> ? FPUTYPE_COLDFIRE : FPUTYPE_68881 ) ; if ( TARGET_SEP_DATA && TARGET_ID_SHARED_LIBRARY ) error ( <STR_LIT> ) ; if ( TARGET_SEP_DATA || TARGET_ID_SHARED_LIBRARY ) flag_pic = <NUM_LIT> ; if ( TARGET_PCREL && ! TARGET_68020 && flag_pic == <NUM_LIT> ) error ( <STR_LIT> ) ; if ( TARGET_PCREL && flag_pic == <NUM_LIT> ) flag_pic = <NUM_LIT> ; if ( ! flag_pic ) { m68k_symbolic_call_var = M68K_SYMBOLIC_CALL_JSR ; m68k_symbolic_jump = <STR_LIT> ; } else if ( TARGET_ID_SHARED_LIBRARY ) ; else if ( TARGET_68020 || TARGET_ISAB || TARGET_ISAC ) { if ( TARGET_PCREL ) m68k_symbolic_call_var = M68K_SYMBOLIC_CALL_BSR_C ; else m68k_symbolic_call_var = M68K_SYMBOLIC_CALL_BSR_P ; if ( TARGET_ISAC ) ; else if ( TARGET_PCREL ) m68k_symbolic_jump = <STR_LIT> ; else m68k_symbolic_jump = <STR_LIT> ; flag_no_function_cse = <NUM_LIT> ; } switch ( m68k_symbolic_call_var ) { case M68K_SYMBOLIC_CALL_JSR : m68k_symbolic_call = <STR_LIT> ; break ; case M68K_SYMBOLIC_CALL_BSR_C : m68k_symbolic_call = <STR_LIT> ; break ; case M68K_SYMBOLIC_CALL_BSR_P : m68k_symbolic_call = <STR_LIT> ; break ; case M68K_SYMBOLIC_CALL_NONE : gcc_assert ( m68k_symbolic_call == NULL ) ; break ; default : gcc_unreachable ( ) ; } if ( align_labels > <NUM_LIT> ) { warning ( <NUM_LIT> , <STR_LIT> , align_labels ) ; align_labels = <NUM_LIT> ; } if ( align_loops > <NUM_LIT> ) { warning ( <NUM_LIT> , <STR_LIT> , align_loops ) ; align_loops = <NUM_LIT> ; } if ( ( opt_fstack_limit_symbol_arg != NULL || opt_fstack_limit_register_no >= <NUM_LIT> ) && ! TARGET_68020 ) { warning ( <NUM_LIT> , <STR_LIT> ) ; opt_fstack_limit_symbol_arg = NULL ; opt_fstack_limit_register_no = - <NUM_LIT> ; } SUBTARGET_OVERRIDE_OPTIONS ; if ( TUNE_CFV1 ) m68k_sched_cpu = CPU_CFV1 ; else if ( TUNE_CFV2 ) m68k_sched_cpu = CPU_CFV2 ; else if ( TUNE_CFV3 ) m68k_sched_cpu = CPU_CFV3 ; else if ( TUNE_CFV4 ) m68k_sched_cpu = CPU_CFV4 ; else { m68k_sched_cpu = CPU_UNKNOWN ; flag_schedule_insns = <NUM_LIT> ; flag_schedule_insns_after_reload = <NUM_LIT> ;


<s> output_asm_insn ( <STR_LIT> , operands ) ; break ; case LTU : output_asm_insn ( <STR_LIT> , operands ) ; break ; case GE : output_asm_insn ( <STR_LIT> , operands ) ; break ; case GEU : output_asm_insn ( <STR_LIT> , operands ) ; break ; case LE : output_asm_insn ( <STR_LIT> , operands ) ; break ; case LEU : output_asm_insn ( <STR_LIT> , operands ) ;


<s> case NOTB : case NOTW : case NEGW : case SWAP : return <NUM_LIT> ;


<s> if ( REG_P ( op ) ) op = gen_rtx_REG ( mode , REGNO ( op ) ) ; else {


<s> if ( REG_P ( op ) ) op = gen_rtx_REG ( mode , REGNO ( op ) ) ; else { op = copy_rtx ( op ) ; PUT_MODE ( op , mode ) ;


<s> static void emit_movsi ( rtx operands [ <NUM_LIT> ] ) { operands [ <NUM_LIT> ] = copy_operand ( operands [ <NUM_LIT> ] , SImode ) ; operands [ <NUM_LIT> ] = copy_operand ( operands [ <NUM_LIT> ] , SImode ) ; emit_insn ( gen_movsi ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ;


<s> reg2 = copy_rtx ( reg1 ) ; if ( n < <NUM_LIT> ) emit_insn ( gen_subsi3 ( reg1 , reg2 , GEN_INT ( - n ) ) ) ;

else if ( n > <NUM_LIT> ) emit_insn ( gen_addsi3 ( reg1 , reg2 , GEN_INT ( n ) ) ) ;


<s> static rtx find_addr_reg ( rtx addr ) { while ( GET_CODE ( addr ) == PLUS ) { if ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == REG ) addr = XEXP ( addr , <NUM_LIT> ) ;

else if ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == REG ) addr = XEXP ( addr , <NUM_LIT> ) ;


<s> static rtx find_addr_reg ( rtx addr ) { while ( GET_CODE ( addr ) == PLUS ) { if ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == REG ) addr = XEXP ( addr , <NUM_LIT> ) ; else if ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == REG ) addr = XEXP ( addr , <NUM_LIT> ) ; else if ( CONSTANT_P ( XEXP ( addr , <NUM_LIT> ) ) ) addr = XEXP ( addr , <NUM_LIT> ) ; else if ( CONSTANT_P ( XEXP ( addr , <NUM_LIT> ) ) ) addr = XEXP ( addr , <NUM_LIT> ) ; else gcc_unreachable ( ) ; }

gcc_assert ( GET_CODE ( addr ) == REG ) ;


<s> if ( real_less ( r , & dconst1 ) ) return <NUM_LIT> ; exp = real_exponent ( r ) ;


<s> if ( REGNO ( orig ) >= FIRST_PSEUDO_REGISTER ) abort ( ) ; return gen_rtx_REG ( mode , REGNO ( orig ) ) ;


<s> if ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL ( x ) != <NUM_LIT> ) return true ; if ( m68k_tls_reference_p ( x , true ) ) iter . skip_subrtxes ( ) ;


<s> rtx x = * iter ; if ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL ( x ) != <NUM_LIT> ) return true ; if ( m68k_tls_reference_p ( x , true ) ) iter . skip_subrtxes ( ) ;


<s> flags_valid = FLAGS_VALID_MOVE ; flags_operand1 = side_effects_p ( operands [ <NUM_LIT> ] ) ? NULL_RTX : operands [ <NUM_LIT> ] ; if ( side_effects_p ( operands [ <NUM_LIT> ] ) || modified_in_p ( operands [ <NUM_LIT> ] , current_output_insn ) ) flags_operand2 = NULL_RTX ; else flags_operand2 = operands [ <NUM_LIT> ] ; return ; } if ( flags_operand1 != NULL_RTX && modified_in_p ( flags_operand1 , current_output_insn ) ) flags_operand1 = NULL_RTX ;


<s> if ( side_effects_p ( operands [ <NUM_LIT> ] ) || modified_in_p ( operands [ <NUM_LIT> ] , current_output_insn ) ) flags_operand2 = NULL_RTX ; else flags_operand2 = operands [ <NUM_LIT> ] ; return ; } if ( flags_operand1 != NULL_RTX && modified_in_p ( flags_operand1 , current_output_insn ) ) flags_operand1 = NULL_RTX ; if ( flags_operand2 != NULL_RTX && modified_in_p ( flags_operand2 , current_output_insn ) ) flags_operand2 = NULL_RTX ;


<s> r = REAL_VALUE_ATOF ( strings_68881 [ i ] , mode ) ; values_68881 [ i ] = r ; }


<s> gcc_assert ( reg ) ; gcc_assert ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == PLUS ) ; base = legitimize_pic_address ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) , Pmode , reg ) ; orig = legitimize_pic_address ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) , Pmode , base == reg ? <NUM_LIT> : reg ) ; if ( GET_CODE ( orig ) == CONST_INT ) pic_ref = plus_constant ( Pmode , base , INTVAL ( orig ) ) ; else pic_ref = gen_rtx_PLUS ( Pmode , base , orig ) ;


<s> } else if ( GET_CODE ( orig ) == CONST ) { rtx base ; if ( m68k_unwrap_symbol ( orig , true ) != orig ) return orig ; gcc_assert ( reg ) ; gcc_assert ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == PLUS ) ; base = legitimize_pic_address ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) , Pmode , reg ) ; orig = legitimize_pic_address ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) , Pmode , base == reg ? <NUM_LIT> : reg ) ;

if ( GET_CODE ( orig ) == CONST_INT ) pic_ref = plus_constant ( Pmode , base , INTVAL ( orig ) ) ;


<s> gcc_assert ( GET_CODE ( x ) == CONST ) ; plus = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( plus ) == PLUS || GET_CODE ( plus ) == MINUS ) { rtx unspec ; rtx addend ; unspec = XEXP ( plus , <NUM_LIT> ) ; gcc_assert ( GET_CODE ( unspec ) == UNSPEC ) ; addend = XEXP ( plus , <NUM_LIT> ) ;


<s> rtx unspec ; rtx addend ; unspec = XEXP ( plus , <NUM_LIT> ) ; gcc_assert ( GET_CODE ( unspec ) == UNSPEC ) ; addend = XEXP ( plus , <NUM_LIT> ) ; gcc_assert ( CONST_INT_P ( addend ) ) ; XEXP ( plus , <NUM_LIT> ) = XVECEXP ( unspec , <NUM_LIT> , <NUM_LIT> ) ; XVECEXP ( unspec , <NUM_LIT> , <NUM_LIT> ) = plus ; XEXP ( x , <NUM_LIT> ) = unspec ; }


<s> rtx dest = SET_DEST ( set ) ; rtx src = SET_SRC ( set ) ; if ( side_effects_p ( dest ) ) dest = NULL_RTX ; switch ( v ) { case FLAGS_VALID_YES : case FLAGS_VALID_NOOV : flags_operand1 = dest ; flags_operand2 = NULL_RTX ; break ; case FLAGS_VALID_MOVE : if ( dest != NULL_RTX && ! FP_REG_P ( dest ) && ( FP_REG_P ( src ) || GET_CODE ( src ) == FIX || FLOAT_MODE_P ( GET_MODE ( dest ) ) ) ) flags_operand1 = flags_operand2 = NULL_RTX ; else { flags_operand1 = dest ; if ( GET_MODE ( src ) != VOIDmode && ! side_effects_p ( src ) && ! modified_in_p ( src , insn ) ) flags_operand2 = src ; else flags_operand2 = NULL_RTX ; } break ;


<s> case FLAGS_VALID_YES : case FLAGS_VALID_NOOV : flags_operand1 = dest ; flags_operand2 = NULL_RTX ; break ; case FLAGS_VALID_MOVE : if ( dest != NULL_RTX && ! FP_REG_P ( dest ) && ( FP_REG_P ( src ) || GET_CODE ( src ) == FIX || FLOAT_MODE_P ( GET_MODE ( dest ) ) ) ) flags_operand1 = flags_operand2 = NULL_RTX ; else { flags_operand1 = dest ; if ( GET_MODE ( src ) != VOIDmode && ! side_effects_p ( src ) && ! modified_in_p ( src , insn ) ) flags_operand2 = src ; else flags_operand2 = NULL_RTX ; } break ; default : gcc_unreachable ( ) ;


<s> start_sequence ( ) ; m68k_libcall_value_in_a0_p = true ; a0 = emit_library_call_value ( m68k_get_m68k_read_tp ( ) , NULL_RTX , LCT_PURE , Pmode ) ; m68k_libcall_value_in_a0_p = false ; insns = get_insns ( ) ; end_sequence ( ) ; eqv = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , const1_rtx ) , UNSPEC_RELOC32 ) ; gcc_assert ( can_create_pseudo_p ( ) ) ; dest = gen_reg_rtx ( Pmode ) ;


<s> x = m68k_wrap_symbol ( x , reloc , m68k_get_gp ( ) , NULL_RTX ) ; m68k_libcall_value_in_a0_p = true ; a0 = emit_library_call_value ( m68k_get_tls_get_addr ( ) , NULL_RTX , LCT_PURE , Pmode , x , Pmode ) ;


<s> rtx dest ; start_sequence ( ) ; x = m68k_wrap_symbol ( x , reloc , m68k_get_gp ( ) , NULL_RTX ) ; m68k_libcall_value_in_a0_p = true ; a0 = emit_library_call_value ( m68k_get_tls_get_addr ( ) , NULL_RTX , LCT_PURE , Pmode , x , Pmode ) ; m68k_libcall_value_in_a0_p = false ; insns = get_insns ( ) ; end_sequence ( ) ; gcc_assert ( can_create_pseudo_p ( ) ) ; dest = gen_reg_rtx ( Pmode ) ;


<s> return m68k_illegitimate_symbolic_constant_p ( x ) ;


<s> current_frame . size = ( get_frame_size ( ) + <NUM_LIT> ) & - <NUM_LIT> ; mask = saved = <NUM_LIT> ; if ( ! interrupt_thread ) for ( regno = <NUM_LIT> ; regno < <NUM_LIT> ; regno ++ ) if ( m68k_save_reg ( regno , interrupt_handler ) ) { mask |= <NUM_LIT> << ( regno - D0_REG ) ; saved ++ ; } current_frame . offset = saved * <NUM_LIT> ; current_frame . reg_no = saved ; current_frame . reg_mask = mask ; current_frame . foffset = <NUM_LIT> ; mask = saved = <NUM_LIT> ; if ( TARGET_HARD_FLOAT ) { if ( ! interrupt_thread ) for ( regno = <NUM_LIT> ; regno < <NUM_LIT> ; regno ++ ) if ( m68k_save_reg ( regno , interrupt_handler ) ) { mask |= <NUM_LIT> << ( regno - FP0_REG ) ; saved ++ ;


<s> HARD_REG_SET x ; if ( ! TARGET_HARD_FLOAT ) { x = reg_class_contents [ FP_REGS ] ; for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( TEST_HARD_REG_BIT ( x , i ) ) fixed_regs [ i ] = call_used_regs [ i ] = <NUM_LIT> ; } if ( flag_pic ) fixed_regs [ PIC_REG ] = call_used_regs [ PIC_REG ] = <NUM_LIT> ;


<s> const char * m68k_cpp_cpu_ident ( const char * prefix ) {


<s> } if ( TARGET_68020 ) { if ( GET_CODE ( x ) == PLUS && m68k_legitimate_constant_address_p ( XEXP ( x , <NUM_LIT> ) , reach , strict_p ) ) { address -> offset = XEXP ( x , <NUM_LIT> ) ; x = XEXP ( x , <NUM_LIT> ) ; } if ( m68k_legitimate_base_reg_p ( x , strict_p ) ) { address -> base = x ; return true ; } if ( address -> offset && symbolic_operand ( address -> offset , VOIDmode ) && m68k_decompose_index ( x , strict_p , address ) ) return true ; } else { if ( GET_CODE ( x ) == PLUS && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT && IN_RANGE ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) , - <NUM_LIT> , <NUM_LIT> - reach ) ) { address -> offset = XEXP ( x , <NUM_LIT> ) ; x = XEXP ( x , <NUM_LIT> ) ; } } if ( GET_CODE ( x ) == PLUS ) { if ( m68k_legitimate_base_reg_p ( XEXP ( x , <NUM_LIT> ) , strict_p ) && m68k_decompose_index ( XEXP ( x , <NUM_LIT> ) , strict_p , address ) ) { address -> base = XEXP ( x , <NUM_LIT> ) ; return true ; } if ( m68k_legitimate_base_reg_p ( XEXP ( x , <NUM_LIT> ) , strict_p ) && m68k_decompose_index ( XEXP ( x , <NUM_LIT> ) , strict_p , address ) ) { address -> base = XEXP ( x , <NUM_LIT> ) ; return true ; } }


<s> return true ; } if ( GET_CODE ( x ) == PLUS && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT && IN_RANGE ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) , - <NUM_LIT> , <NUM_LIT> - reach ) && m68k_legitimate_base_reg_p ( XEXP ( x , <NUM_LIT> ) , strict_p ) ) { address -> base = XEXP ( x , <NUM_LIT> ) ; address -> offset = XEXP ( x , <NUM_LIT> ) ; return true ; } if ( GET_CODE ( x ) == PLUS && XEXP ( x , <NUM_LIT> ) == pic_offset_table_rtx ) { if ( m68k_unwrap_symbol ( XEXP ( x , <NUM_LIT> ) , false ) != XEXP ( x , <NUM_LIT> ) ) { address -> base = XEXP ( x , <NUM_LIT> ) ; address -> offset = XEXP ( x , <NUM_LIT> ) ; return true ; } } if ( TARGET_COLDFIRE_FPU && GET_MODE_CLASS ( mode ) == MODE_FLOAT ) return false ; if ( m68k_legitimate_constant_address_p ( x , reach , strict_p ) ) { address -> offset = x ; return true ; } if ( GET_CODE ( x ) == PLUS && m68k_jump_table_ref_p ( XEXP ( x , <NUM_LIT> ) ) && m68k_decompose_index ( XEXP ( x , <NUM_LIT> ) , strict_p , address ) ) { address -> offset = XEXP ( x , <NUM_LIT> ) ; return true ; } if ( TARGET_68020 ) { if ( GET_CODE ( x ) == PLUS && m68k_legitimate_constant_address_p ( XEXP ( x , <NUM_LIT> ) , reach , strict_p ) ) { address -> offset = XEXP ( x , <NUM_LIT> ) ; x = XEXP ( x , <NUM_LIT> ) ; } if ( m68k_legitimate_base_reg_p ( x , strict_p ) ) { address -> base = x ;


<s> int scale ; scale = <NUM_LIT> ; if ( ( TARGET_68020 || TARGET_COLDFIRE ) && GET_CODE ( x ) == MULT && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT && ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) == <NUM_LIT> || INTVAL ( XEXP ( x , <NUM_LIT> ) ) == <NUM_LIT> || ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) == <NUM_LIT> && ( TARGET_COLDFIRE_FPU || ! TARGET_COLDFIRE ) ) ) ) { scale = INTVAL ( XEXP ( x , <NUM_LIT> ) ) ; x = XEXP ( x , <NUM_LIT> ) ; } if ( ! TARGET_COLDFIRE && GET_CODE ( x ) == SIGN_EXTEND && GET_MODE ( XEXP ( x , <NUM_LIT> ) ) == HImode ) x = XEXP ( x , <NUM_LIT> ) ; if ( m68k_legitimate_index_reg_p ( x , strict_p ) ) { address -> scale = scale ; address -> index = x ; return true ; }


<s> gcc_assert ( GET_CODE ( x ) == SYMBOL_REF || GET_CODE ( x ) == LABEL_REF ) ; if ( unspec != XEXP ( addr . offset , <NUM_LIT> ) ) x = gen_rtx_PLUS ( Pmode , x , XEXP ( XEXP ( addr . offset , <NUM_LIT> ) , <NUM_LIT> ) ) ; if ( addr . index ) { rtx idx = addr . index ; if ( addr . scale != <NUM_LIT> ) idx = gen_rtx_MULT ( Pmode , idx , GEN_INT ( addr . scale ) ) ; x = gen_rtx_PLUS ( Pmode , idx , x ) ;


<s> static rtx_insn * m68k_emit_movem ( rtx base , HOST_WIDE_INT offset , unsigned int count , unsigned int regno , unsigned int mask , bool store_p , bool adjust_stack_p ) { int i ; rtx body , addr , src , operands [ <NUM_LIT> ] ; machine_mode mode ; body = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( adjust_stack_p + count ) ) ; mode = reg_raw_mode [ regno ] ; i = <NUM_LIT> ;


<s> if ( TARGET_68040 || ! TARGET_68881 ) return FLT_EVAL_METHOD_PROMOTE_TO_FLOAT ; return FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE ; case EXCESS_PRECISION_TYPE_FLOAT16 : error ( <STR_LIT> ) ; break ; default : gcc_unreachable ( ) ; } return FLT_EVAL_METHOD_UNPREDICTABLE ;


<s> if ( TARGET_68040 || ! TARGET_68881 ) return FLT_EVAL_METHOD_PROMOTE_TO_FLOAT ; return FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE ; case EXCESS_PRECISION_TYPE_FLOAT16 : error ( <STR_LIT> ) ; break ; default : gcc_unreachable ( ) ; }


<s> emit_insn ( gen_blockage ( ) ) ; emit_insn ( gen_addsi3 ( stack_pointer_rtx , gen_rtx_REG ( Pmode , A1_REG ) , frame_pointer_rtx ) ) ; restore_from_sp = true ; } else { emit_move_insn ( gen_rtx_REG ( Pmode , A1_REG ) , GEN_INT ( - fsize ) ) ; fsize = <NUM_LIT> ; big = true ; } } if ( current_frame . reg_no < MIN_MOVEM_REGS ) { int i ; HOST_WIDE_INT offset ; offset = current_frame . offset + fsize ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( current_frame . reg_mask & ( <NUM_LIT> << i ) ) { rtx addr ; if ( big ) { addr = gen_rtx_REG ( Pmode , A1_REG ) ; addr = gen_rtx_PLUS ( Pmode , addr , frame_pointer_rtx ) ; addr = plus_constant ( Pmode , addr , - offset ) ; } else if ( restore_from_sp ) addr = gen_rtx_POST_INC ( Pmode , stack_pointer_rtx ) ; else addr = plus_constant ( Pmode , frame_pointer_rtx , - offset ) ; emit_move_insn ( gen_rtx_REG ( SImode , D0_REG + i ) , gen_frame_mem ( SImode , addr ) ) ; offset -= GET_MODE_SIZE ( SImode ) ; } } else if ( current_frame . reg_mask ) { if ( big ) m68k_emit_movem ( gen_rtx_PLUS ( Pmode , gen_rtx_REG ( Pmode , A1_REG ) , frame_pointer_rtx ) , - ( current_frame . offset + fsize ) , current_frame . reg_no , D0_REG , current_frame . reg_mask , false , false ) ; else if ( restore_from_sp ) m68k_emit_movem ( stack_pointer_rtx , <NUM_LIT> , current_frame . reg_no , D0_REG , current_frame . reg_mask , false , ! TARGET_COLDFIRE ) ; else m68k_emit_movem ( frame_pointer_rtx , - ( current_frame . offset + fsize ) , current_frame . reg_no , D0_REG , current_frame . reg_mask , false , false ) ; } if ( current_frame . fpu_no > <NUM_LIT> ) { if ( big ) m68k_emit_movem ( gen_rtx_PLUS ( Pmode , gen_rtx_REG ( Pmode , A1_REG ) , frame_pointer_rtx ) , - ( current_frame . foffset + fsize ) , current_frame . fpu_no , FP0_REG , current_frame . fpu_mask , false , false ) ; else if ( restore_from_sp ) { if ( TARGET_COLDFIRE ) { int offset ;

if ( current_frame . reg_no < MIN_MOVEM_REGS ) offset = <NUM_LIT> ;


<s> rtx_code m68k_find_flags_value ( rtx op0 , rtx op1 , rtx_code code ) { if ( flags_compare_op0 != NULL_RTX ) { if ( rtx_equal_p ( op0 , flags_compare_op0 ) && rtx_equal_p ( op1 , flags_compare_op1 ) ) return code ; if ( rtx_equal_p ( op0 , flags_compare_op1 ) && rtx_equal_p ( op1 , flags_compare_op0 ) ) return swap_condition ( code ) ; return UNKNOWN ; } machine_mode mode = GET_MODE ( op0 ) ; if ( op1 != CONST0_RTX ( mode ) ) return UNKNOWN ; gcc_assert ( code != LTU && code != GEU ) ; if ( flags_valid == FLAGS_VALID_NOOV && ( code == GT || code == LE ) ) return UNKNOWN ; if ( rtx_equal_p ( flags_operand1 , op0 ) || rtx_equal_p ( flags_operand2 , op0 ) ) return ( FLOAT_MODE_P ( mode ) ? code : code == GE ? PLUS : code == LT ? MINUS : code ) ; if ( code != GE && code != LT ) return UNKNOWN ; if ( mode == SImode && flags_operand1 != NULL_RTX && GET_MODE ( flags_operand1 ) == DImode && REG_P ( flags_operand1 ) && REG_P ( op0 ) && hard_regno_nregs ( REGNO ( flags_operand1 ) , DImode ) == <NUM_LIT> && REGNO ( flags_operand1 ) == REGNO ( op0 ) ) return code == GE ? PLUS : MINUS ;

if ( mode == SImode && flags_operand2 != NULL_RTX && GET_MODE ( flags_operand2 ) == DImode && REG_P ( flags_operand2 ) && REG_P ( op0 ) && hard_regno_nregs ( REGNO ( flags_operand2 ) , DImode ) == <NUM_LIT> && REGNO ( flags_operand2 ) == REGNO ( op0 ) ) return code == GE ? PLUS : MINUS ;


<s> static rtx m68k_function_arg ( cumulative_args_t , const function_arg_info & ) { return NULL_RTX ;


<s> static void m68k_function_arg_advance ( cumulative_args_t cum_v , const function_arg_info & arg ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ;

* cum += ( arg . promoted_size_in_bytes ( ) + <NUM_LIT> ) & ~ <NUM_LIT> ;


<s> break ; } if ( func && POINTER_TYPE_P ( TREE_TYPE ( TREE_TYPE ( func ) ) ) ) return gen_rtx_PARALLEL ( mode , gen_rtvec ( <NUM_LIT> , gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( mode , A0_REG ) , const0_rtx ) , gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( mode , D0_REG ) , const0_rtx ) ) ) ; else if ( POINTER_TYPE_P ( valtype ) ) return gen_rtx_REG ( mode , A0_REG ) ; else return gen_rtx_REG ( mode , D0_REG ) ;


<s> a = lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( func ) ) ; if ( a != NULL_TREE ) return m68k_fk_interrupt_handler ; a = lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( func ) ) ; if ( a != NULL_TREE ) return m68k_fk_interrupt_thread ;


<s> static rtx m68k_get_gp ( void ) { if ( pic_offset_table_rtx == NULL_RTX ) pic_offset_table_rtx = gen_rtx_REG ( Pmode , PIC_REG ) ; crtl -> uses_pic_offset_table = <NUM_LIT> ; return pic_offset_table_rtx ;


<s> } } } gcc_unreachable ( ) ; case RELOC_TLSGD : return <STR_LIT> ; case RELOC_TLSLDM : return <STR_LIT> ; case RELOC_TLSLDO : return <STR_LIT> ; case RELOC_TLSIE : return <STR_LIT> ; case RELOC_TLSLE : return <STR_LIT> ;


<s> else return <STR_LIT> ; } else { if ( TARGET_68020 ) { switch ( flag_pic ) { case <NUM_LIT> : return <STR_LIT> ; case <NUM_LIT> : return <STR_LIT> ; default : return <STR_LIT> ; } } } gcc_unreachable ( ) ; case RELOC_TLSGD : return <STR_LIT> ; case RELOC_TLSLDM : return <STR_LIT> ; case RELOC_TLSLDO : return <STR_LIT> ;


<s> * no_add_attrs = true ; } if ( m68k_get_function_kind ( * node ) != m68k_fk_normal_function ) { error ( <STR_LIT> ) ; * no_add_attrs = true ; } if ( ! TARGET_FIDOA && ! strcmp ( IDENTIFIER_POINTER ( name ) , <STR_LIT> ) ) { error ( <STR_LIT> ) ; * no_add_attrs = true ; }


<s> } else if ( ADDRESS_REGNO_P ( regno ) ) { if ( regno + GET_MODE_SIZE ( mode ) / <NUM_LIT> <= <NUM_LIT> ) return true ; }


<s> if ( ( GET_MODE_CLASS ( mode ) == MODE_FLOAT || GET_MODE_CLASS ( mode ) == MODE_COMPLEX_FLOAT ) && GET_MODE_UNIT_SIZE ( mode ) <= TARGET_FP_REG_SIZE ) return true ; }


<s> return CEIL ( GET_MODE_SIZE ( mode ) , UNITS_PER_WORD ) ;


<s> static unsigned int m68k_hard_regno_nregs ( unsigned int regno , machine_mode mode ) { if ( regno >= <NUM_LIT> ) return GET_MODE_NUNITS ( mode ) ;

return CEIL ( GET_MODE_SIZE ( mode ) , UNITS_PER_WORD ) ;


<s> int m68k_hard_regno_rename_ok ( unsigned int old_reg ATTRIBUTE_UNUSED , unsigned int new_reg ) { if ( ( m68k_get_function_kind ( current_function_decl ) == m68k_fk_interrupt_handler ) && ! df_regs_ever_live_p ( new_reg ) ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> gcc_assert ( to == STACK_POINTER_REGNUM ) ; switch ( from ) { case ARG_POINTER_REGNUM : return current_frame . offset + current_frame . size - argptr_offset ; case FRAME_POINTER_REGNUM : return current_frame . offset + current_frame . size ; default :


<s> static bool m68k_jump_table_ref_p ( rtx x ) { if ( GET_CODE ( x ) != LABEL_REF ) return false ;

rtx_insn * insn = as_a < rtx_insn * > ( XEXP ( x , <NUM_LIT> ) ) ;


<s> if ( GET_CODE ( x ) != LABEL_REF ) return false ; rtx_insn * insn = as_a < rtx_insn * > ( XEXP ( x , <NUM_LIT> ) ) ; if ( ! NEXT_INSN ( insn ) && ! PREV_INSN ( insn ) ) return true ; insn = next_nonnote_insn ( insn ) ; return insn && JUMP_TABLE_DATA_P ( insn ) ;


<s> return m68k_decompose_address ( mode , x , strict_p , & address ) ;


return m68k_decompose_address ( mode , x , strict_p , & address ) ;


<s> if ( ! strict_p && GET_CODE ( x ) == SUBREG ) x = SUBREG_REG ( x ) ;

return ( REG_P ( x ) && ( strict_p ? REGNO_OK_FOR_BASE_P ( REGNO ( x ) ) : REGNO_OK_FOR_BASE_NONSTRICT_P ( REGNO ( x ) ) ) ) ;


<s> if ( ! CONSTANT_ADDRESS_P ( x ) ) return false ; if ( flag_pic && ! ( strict_p && TARGET_PCREL ) && symbolic_operand ( x , VOIDmode ) ) return false ;

if ( M68K_OFFSETS_MUST_BE_WITHIN_SECTIONS_P && reach > <NUM_LIT> ) {


<s> if ( flag_pic && ! ( strict_p && TARGET_PCREL ) && symbolic_operand ( x , VOIDmode ) ) return false ; if ( M68K_OFFSETS_MUST_BE_WITHIN_SECTIONS_P && reach > <NUM_LIT> ) {


<s> bool m68k_legitimate_constant_p ( machine_mode mode , rtx x ) {

return mode != XFmode && ! m68k_illegitimate_symbolic_constant_p ( x ) ;


<s> bool m68k_legitimate_constant_p ( machine_mode mode , rtx x ) { return mode != XFmode && ! m68k_illegitimate_symbolic_constant_p ( x ) ;


<s> static bool m68k_legitimate_mem_p ( rtx x , struct m68k_address * address ) {

return ( MEM_P ( x ) && m68k_decompose_address ( GET_MODE ( x ) , XEXP ( x , <NUM_LIT> ) , reload_in_progress || reload_completed , address ) ) ;


<s> } if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == REG || ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == SIGN_EXTEND && GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == REG && GET_MODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == HImode ) ) { rtx temp = gen_reg_rtx ( Pmode ) ; rtx val = force_operand ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ; emit_move_insn ( temp , val ) ; COPY_ONCE ( x ) ; XEXP ( x , <NUM_LIT> ) = temp ; if ( TARGET_COLDFIRE_FPU && GET_MODE_CLASS ( mode ) == MODE_FLOAT && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == REG ) x = force_operand ( x , <NUM_LIT> ) ; } else if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == REG || ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == SIGN_EXTEND && GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == REG && GET_MODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == HImode ) ) {


<s> rtx m68k_legitimize_call_address ( rtx x ) { gcc_assert ( MEM_P ( x ) ) ;

if ( call_operand ( XEXP ( x , <NUM_LIT> ) , VOIDmode ) ) return x ;


<s> if ( sibcall_operand ( XEXP ( x , <NUM_LIT> ) , VOIDmode ) ) return x ; emit_move_insn ( gen_rtx_REG ( Pmode , STATIC_CHAIN_REGNUM ) , XEXP ( x , <NUM_LIT> ) ) ;

return replace_equiv_address ( x , gen_rtx_REG ( Pmode , STATIC_CHAIN_REGNUM ) ) ;


<s> rtx m68k_legitimize_tls_address ( rtx orig ) { switch ( SYMBOL_REF_TLS_MODEL ( orig ) ) { case TLS_MODEL_GLOBAL_DYNAMIC : orig = m68k_call_tls_get_addr ( orig , orig , RELOC_TLSGD ) ; break ; case TLS_MODEL_LOCAL_DYNAMIC : { rtx eqv ; rtx a0 ; rtx x ; eqv = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , const0_rtx ) , UNSPEC_RELOC32 ) ; a0 = m68k_call_tls_get_addr ( orig , eqv , RELOC_TLSLDM ) ; x = m68k_wrap_symbol ( orig , RELOC_TLSLDO , a0 , NULL_RTX ) ; if ( can_create_pseudo_p ( ) ) x = m68k_move_to_reg ( x , orig , NULL_RTX ) ; orig = x ; break ; } case TLS_MODEL_INITIAL_EXEC : { rtx a0 ; rtx x ;


<s> rtx x ; eqv = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , const0_rtx ) , UNSPEC_RELOC32 ) ; a0 = m68k_call_tls_get_addr ( orig , eqv , RELOC_TLSLDM ) ; x = m68k_wrap_symbol ( orig , RELOC_TLSLDO , a0 , NULL_RTX ) ; if ( can_create_pseudo_p ( ) ) x = m68k_move_to_reg ( x , orig , NULL_RTX ) ; orig = x ; break ; } case TLS_MODEL_INITIAL_EXEC : { rtx a0 ; rtx x ; a0 = m68k_call_m68k_read_tp ( ) ; x = m68k_wrap_symbol_into_got_ref ( orig , RELOC_TLSIE , NULL_RTX ) ; x = gen_rtx_PLUS ( Pmode , x , a0 ) ; if ( can_create_pseudo_p ( ) ) x = m68k_move_to_reg ( x , orig , NULL_RTX ) ;


<s> rtx m68k_libcall_value ( machine_mode mode ) { switch ( mode ) { case E_SFmode : case E_DFmode :


<s> return ( m68k_legitimate_mem_p ( x , & address ) && address . code == UNKNOWN && address . base && ! address . offset && ! address . index ) ;


<s> struct m68k_address address ; return ( m68k_legitimate_mem_p ( x , & address ) && address . code == UNKNOWN && address . base && address . offset && ! address . index ) ;


<s> return ( ! TARGET_HARD_FLOAT || ( ( GET_MODE_CLASS ( mode1 ) == MODE_FLOAT || GET_MODE_CLASS ( mode1 ) == MODE_COMPLEX_FLOAT ) == ( GET_MODE_CLASS ( mode2 ) == MODE_FLOAT || GET_MODE_CLASS ( mode2 ) == MODE_COMPLEX_FLOAT ) ) ) ;


<s> base = automod_base ; offset = ( automod_offset < <NUM_LIT> ? automod_offset : <NUM_LIT> ) ; } else { base = NULL ; offset = <NUM_LIT> ; } last_reg = NULL ; rclass = NO_REGS ; for ( i = first ; i < len ; i ++ ) { set = XVECEXP ( pattern , <NUM_LIT> , i ) ; if ( GET_CODE ( set ) != SET ) return false ; mem = XEXP ( set , ! store_p ) ; if ( ! MEM_P ( mem ) || ! memory_operand ( mem , VOIDmode ) ) return false ; if ( base == NULL ) { m68k_split_offset ( XEXP ( mem , <NUM_LIT> ) , & base , & offset ) ; if ( TARGET_COLDFIRE && ! m68k_legitimate_base_reg_p ( base , reload_completed ) ) return false ;


<s> } else { m68k_split_offset ( XEXP ( mem , <NUM_LIT> ) , & mem_base , & mem_offset ) ; if ( ! rtx_equal_p ( base , mem_base ) || offset != mem_offset ) return false ; } reg = XEXP ( set , store_p ) ; if ( ! REG_P ( reg ) || ! HARD_REGISTER_P ( reg ) || GET_MODE ( reg ) != reg_raw_mode [ REGNO ( reg ) ] ) return false ; if ( last_reg ) { if ( ! TEST_HARD_REG_BIT ( reg_class_contents [ rclass ] , REGNO ( reg ) ) || REGNO ( last_reg ) >= REGNO ( reg ) ) return false ; } else { if ( INT_REGNO_P ( REGNO ( reg ) ) ) rclass = GENERAL_REGS ; else if ( FP_REGNO_P ( REGNO ( reg ) ) ) rclass = FP_REGS ; else return false ; }


<s> if ( reg == NULL_RTX ) { gcc_assert ( can_create_pseudo_p ( ) ) ; reg = gen_reg_rtx ( Pmode ) ; }


<s> rtx_insn * insn ; if ( reg == NULL_RTX ) { gcc_assert ( can_create_pseudo_p ( ) ) ; reg = gen_reg_rtx ( Pmode ) ; } insn = emit_move_insn ( reg , x ) ; set_unique_reg_note ( insn , REG_EQUAL , orig ) ; return reg ;


<s> rtx cfun_value ; rtx call_value ; cfun_value = FUNCTION_VALUE ( TREE_TYPE ( DECL_RESULT ( cfun -> decl ) ) , cfun -> decl ) ; call_value = FUNCTION_VALUE ( TREE_TYPE ( exp ) , decl ) ; if ( ! ( rtx_equal_p ( cfun_value , call_value ) || ( REG_P ( cfun_value ) && m68k_reg_present_p ( call_value , REGNO ( cfun_value ) ) ) ) ) return false ;


<s> fputs ( m68k_get_reloc_decoration ( ( enum m68k_reloc ) INTVAL ( XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ) ) , file ) ; return true ; default :


<s> case UNSPEC_RELOC16 : case UNSPEC_RELOC32 : output_addr_const ( file , XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ) ; fputs ( m68k_get_reloc_decoration ( ( enum m68k_reloc ) INTVAL ( XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ) ) , file ) ; return true ; default : break ;


<s> int width = GET_CODE ( zxop0 ) == REG ? <NUM_LIT> : <NUM_LIT> ; return m68k_output_btst ( GEN_INT ( width - INTVAL ( zxop2 ) ) , zxop0 , code , <NUM_LIT> ) ;


<s> return <STR_LIT> ; case UNORDERED : return <STR_LIT> ; case UNEQ : return <STR_LIT> ; case UNGE : return <STR_LIT> ; case UNGT : return <STR_LIT> ; case UNLE : return <STR_LIT> ; case UNLT : return <STR_LIT> ;


<s> return <STR_LIT> ; case LT : return <STR_LIT> ; case GE : return <STR_LIT> ; case LE : return <STR_LIT> ; case ORDERED : return <STR_LIT> ; case UNORDERED : return <STR_LIT> ; case UNEQ : return <STR_LIT> ; case UNGE : return <STR_LIT> ; case UNGT : return <STR_LIT> ; case UNLE : return <STR_LIT> ; case UNLT : return <STR_LIT> ; case LTGT :


<s> return <STR_LIT> ; case LTU : return <STR_LIT> ; case GE : return <STR_LIT> ; case GEU : return <STR_LIT> ; case LE : return <STR_LIT> ; case LEU : return <STR_LIT> ; case PLUS : return <STR_LIT> ; case MINUS : return <STR_LIT> ; default : gcc_unreachable ( ) ; }


<s> return <STR_LIT> ; case GT : return <STR_LIT> ; case GTU : return <STR_LIT> ; case LT : return <STR_LIT> ; case LTU : return <STR_LIT> ; case GE : return <STR_LIT> ; case GEU : return <STR_LIT> ; case LE : return <STR_LIT> ;


<s> case GEU : return <STR_LIT> ; case LE : return <STR_LIT> ; case LEU : return <STR_LIT> ; case PLUS : return <STR_LIT> ; case MINUS : return <STR_LIT> ; default : gcc_unreachable ( ) ; }


<s> } else output_asm_insn ( ( <STR_LIT> + prec + <STR_LIT> ) . c_str ( ) , ops ) ; return code ; } switch ( which_alternative ) { case <NUM_LIT> : if ( TARGET_COLDFIRE_FPU ) output_asm_insn ( <STR_LIT> , ops ) ; else output_asm_insn ( <STR_LIT> , ops ) ; break ; case <NUM_LIT> : output_asm_insn ( ( <STR_LIT> + prec + <STR_LIT> ) . c_str ( ) , ops ) ; break ; case <NUM_LIT> : output_asm_insn ( ( <STR_LIT> + prec + <STR_LIT> ) . c_str ( ) , ops ) ;

std :: swap ( flags_compare_op0 , flags_compare_op1 ) ;


<s> if ( op1 == const0_rtx ) output_asm_insn ( <STR_LIT> , ops ) ; else if ( GET_CODE ( op0 ) == MEM && GET_CODE ( op1 ) == MEM ) output_asm_insn ( <STR_LIT> , ops ) ;

else if ( ( REG_P ( op1 ) && ! ADDRESS_REG_P ( op1 ) ) || ( ! REG_P ( op0 ) && GET_CODE ( op0 ) != MEM ) ) {


<s> rtx_code tmp = m68k_find_flags_value ( op0 , op1 , code ) ; if ( tmp != UNKNOWN ) return tmp ; remember_compare_flags ( op0 , op1 ) ; rtx ops [ <NUM_LIT> ] ; ops [ <NUM_LIT> ] = op0 ; ops [ <NUM_LIT> ] = op1 ; if ( op1 == const0_rtx ) output_asm_insn ( <STR_LIT> , ops ) ; else if ( GET_CODE ( op0 ) == MEM && GET_CODE ( op1 ) == MEM ) output_asm_insn ( <STR_LIT> , ops ) ; else if ( ( REG_P ( op1 ) && ! ADDRESS_REG_P ( op1 ) ) || ( ! REG_P ( op0 ) && GET_CODE ( op0 ) != MEM ) ) { output_asm_insn ( <STR_LIT> , ops ) ;


<s> ops [ <NUM_LIT> ] = op1 ; if ( op1 == const0_rtx ) output_asm_insn ( <STR_LIT> , ops ) ; else if ( GET_CODE ( op0 ) == MEM && GET_CODE ( op1 ) == MEM ) output_asm_insn ( <STR_LIT> , ops ) ; else if ( REG_P ( op1 ) || ( ! REG_P ( op0 ) && GET_CODE ( op0 ) != MEM ) ) { output_asm_insn ( <STR_LIT> , ops ) ; std :: swap ( flags_compare_op0 , flags_compare_op1 ) ;


<s> else if ( GET_CODE ( op0 ) == MEM && GET_CODE ( op1 ) == MEM ) output_asm_insn ( <STR_LIT> , ops ) ; else if ( REG_P ( op1 ) || ( ! REG_P ( op0 ) && GET_CODE ( op0 ) != MEM ) ) { output_asm_insn ( <STR_LIT> , ops ) ; std :: swap ( flags_compare_op0 , flags_compare_op1 ) ; return swap_condition ( code ) ; } else output_asm_insn ( <STR_LIT> , ops ) ; return code ;


<s> ops [ <NUM_LIT> ] = op1 ; if ( op1 == const0_rtx && ( TARGET_68020 || TARGET_COLDFIRE || ! ADDRESS_REG_P ( op0 ) ) ) output_asm_insn ( <STR_LIT> , ops ) ; else if ( GET_CODE ( op0 ) == MEM && GET_CODE ( op1 ) == MEM ) output_asm_insn ( <STR_LIT> , ops ) ; else if ( REG_P ( op1 ) || ( ! REG_P ( op0 ) && GET_CODE ( op0 ) != MEM ) ) { output_asm_insn ( <STR_LIT> , ops ) ; std :: swap ( flags_compare_op0 , flags_compare_op1 ) ; return swap_condition ( code ) ;


<s> ops [ <NUM_LIT> ] = op0 ; ops [ <NUM_LIT> ] = op1 ; if ( op1 == const0_rtx && ( TARGET_68020 || TARGET_COLDFIRE || ! ADDRESS_REG_P ( op0 ) ) ) output_asm_insn ( <STR_LIT> , ops ) ; else if ( GET_CODE ( op0 ) == MEM && GET_CODE ( op1 ) == MEM ) output_asm_insn ( <STR_LIT> , ops ) ; else if ( REG_P ( op1 ) || ( ! REG_P ( op0 ) && GET_CODE ( op0 ) != MEM ) ) { output_asm_insn ( <STR_LIT> , ops ) ; std :: swap ( flags_compare_op0 , flags_compare_op1 ) ; return swap_condition ( code ) ;


<s> fputs ( <STR_LIT> , file ) ; output_addr_const ( file , x ) ; fputs ( <STR_LIT> , file ) ;