<s> regno = REGNO ( XEXP ( XVECEXP ( pattern , <NUM_LIT> , i ) , store_p ) ) ; if ( automod_offset < <NUM_LIT> ) { if ( FP_REGNO_P ( regno ) ) mask |= <NUM_LIT> << ( regno - FP0_REG ) ; else mask |= <NUM_LIT> << ( <NUM_LIT> - ( regno - D0_REG ) ) ; } else { if ( FP_REGNO_P ( regno ) ) mask |= <NUM_LIT> << ( <NUM_LIT> - ( regno - FP0_REG ) ) ; else mask |= <NUM_LIT> << ( regno - D0_REG ) ; } } CC_STATUS_INIT ; if ( automod_offset == <NUM_LIT> ) operands [ <NUM_LIT> ] = XEXP ( XEXP ( XVECEXP ( pattern , <NUM_LIT> , first ) , ! store_p ) , <NUM_LIT> ) ; else if ( automod_offset < <NUM_LIT> ) operands [ <NUM_LIT> ] = gen_rtx_PRE_DEC ( Pmode , SET_DEST ( XVECEXP ( pattern , <NUM_LIT> , <NUM_LIT> ) ) ) ; else operands [ <NUM_LIT> ] = gen_rtx_POST_INC ( Pmode , SET_DEST ( XVECEXP ( pattern , <NUM_LIT> , <NUM_LIT> ) ) ) ; operands [ <NUM_LIT> ] = GEN_INT ( mask ) ; if ( FP_REGNO_P ( REGNO ( XEXP ( XVECEXP ( pattern , <NUM_LIT> , first ) , store_p ) ) ) ) {


<s> gcc_assert ( GET_CODE ( pattern ) == PARALLEL ) ; mask = <NUM_LIT> ; first = ( automod_offset != <NUM_LIT> ) ; for ( i = first ; i < XVECLEN ( pattern , <NUM_LIT> ) ; i ++ ) { unsigned int regno ; gcc_assert ( MEM_P ( XEXP ( XVECEXP ( pattern , <NUM_LIT> , i ) , ! store_p ) ) ) ; gcc_assert ( REG_P ( XEXP ( XVECEXP ( pattern , <NUM_LIT> , i ) , store_p ) ) ) ; regno = REGNO ( XEXP ( XVECEXP ( pattern , <NUM_LIT> , i ) , store_p ) ) ; if ( automod_offset < <NUM_LIT> ) { if ( FP_REGNO_P ( regno ) ) mask |= <NUM_LIT> << ( regno - FP0_REG ) ; else mask |= <NUM_LIT> << ( <NUM_LIT> - ( regno - D0_REG ) ) ; } else { if ( FP_REGNO_P ( regno ) ) mask |= <NUM_LIT> << ( <NUM_LIT> - ( regno - FP0_REG ) ) ; else mask |= <NUM_LIT> << ( regno - D0_REG ) ;


<s> return <STR_LIT> ; case NE : 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> ; case LEU : return <STR_LIT> ; case PLUS : return <STR_LIT> ; case MINUS :


<s> 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 : 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 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> if ( secondary_class != NO_REGS && reg_class_subset_p ( secondary_class , rclass ) ) return secondary_class ;

if ( GET_CODE ( x ) == CONST_INT && reg_class_subset_p ( DATA_REGS , rclass ) && IN_RANGE ( INTVAL ( x ) , - <NUM_LIT> , <NUM_LIT> ) ) return DATA_REGS ;


<s> enum reg_class m68k_preferred_reload_class ( rtx x , enum reg_class rclass ) { enum reg_class secondary_class ; secondary_class = m68k_secondary_reload_class ( rclass , GET_MODE ( x ) , x ) ; if ( secondary_class != NO_REGS && reg_class_subset_p ( secondary_class , rclass ) ) return secondary_class ; if ( GET_CODE ( x ) == CONST_INT && reg_class_subset_p ( DATA_REGS , rclass ) && IN_RANGE ( INTVAL ( x ) , - <NUM_LIT> , <NUM_LIT> ) ) return DATA_REGS ;

if ( GET_CODE ( x ) == CONST_DOUBLE && GET_MODE_CLASS ( GET_MODE ( x ) ) == MODE_FLOAT ) {


<s> static machine_mode m68k_promote_function_mode ( const_tree type , machine_mode mode , int * punsignedp ATTRIBUTE_UNUSED , const_tree fntype ATTRIBUTE_UNUSED , int for_return ) {

if ( type == NULL_TREE && ! for_return && ( mode == QImode || mode == HImode ) ) return SImode ;


<s> static machine_mode m68k_promote_function_mode ( const_tree type , machine_mode mode , int * punsignedp ATTRIBUTE_UNUSED , const_tree fntype ATTRIBUTE_UNUSED , int for_return ) { if ( type == NULL_TREE && ! for_return && ( mode == QImode || mode == HImode ) ) return SImode ;


<s> if ( TARGET_COLDFIRE ) return bytes ; return ( bytes + <NUM_LIT> ) & ~ <NUM_LIT> ;


<s> if ( TARGET_COLDFIRE ) return bytes ;

return ( bytes + <NUM_LIT> ) & ~ <NUM_LIT> ;


<s> for ( i = <NUM_LIT> ; i < XVECLEN ( parallel , <NUM_LIT> ) ; ++ i ) { const_rtx x ; x = XEXP ( XVECEXP ( parallel , <NUM_LIT> , i ) , <NUM_LIT> ) ;

if ( REG_P ( x ) && REGNO ( x ) == regno ) return true ;


<s> if ( mode == BLKmode ) return true ; if ( AGGREGATE_TYPE_P ( type ) && TYPE_ALIGN ( type ) < GET_MODE_ALIGNMENT ( mode ) ) return true ; return false ;


<s> static poly_int64 m68k_return_pops_args ( tree fundecl , tree funtype , poly_int64 size ) { return ( ( TARGET_RTD && ( ! fundecl || TREE_CODE ( fundecl ) != IDENTIFIER_NODE ) && ( ! stdarg_p ( funtype ) ) ) ? ( HOST_WIDE_INT ) size : <NUM_LIT> ) ;


<s> } if ( crtl -> 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> if ( pro_x == NULL ) return <NUM_LIT> ; con_mem_read = sched_get_mem_operand ( con , true , false ) ;


<s> gcc_assert ( con_mem_read != NULL ) ; if ( reg_mentioned_p ( pro_x , con_mem_read ) ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> gcc_assert ( sched_cfv4_bypass_data . pro == def_insn && sched_cfv4_bypass_data . con == insn ) ; if ( cost < <NUM_LIT> ) cost = <NUM_LIT> ; sched_cfv4_bypass_data . pro = NULL ; 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 ; return cost ;


<s> 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 ; return cost ;


<s> return OPY_TYPE_FPN ; case OP_TYPE_MEM1 : return OPY_TYPE_MEM1 ; case OP_TYPE_MEM234 : return OPY_TYPE_MEM234 ; case OP_TYPE_MEM5 : return OPY_TYPE_MEM5 ; case OP_TYPE_MEM6 : return OPY_TYPE_MEM6 ; case OP_TYPE_MEM7 : return OPY_TYPE_MEM7 ; case OP_TYPE_IMM_Q : return OPY_TYPE_IMM_Q ; case OP_TYPE_IMM_W : return OPY_TYPE_IMM_W ; case OP_TYPE_IMM_L : return OPY_TYPE_IMM_L ; default : gcc_unreachable ( ) ; }


<s> return OP_MEM_11 ; default : gcc_unreachable ( ) ; } } if ( opy == OP_TYPE_RN && opx == OP_TYPE_MEM6 ) { switch ( get_attr_opx_access ( insn ) ) { case OPX_ACCESS_R : return OP_MEM_I0 ; case OPX_ACCESS_W : return OP_MEM_0I ; case OPX_ACCESS_RW : return OP_MEM_I1 ; default : gcc_unreachable ( ) ; } } if ( opy == OP_TYPE_MEM1 && opx == OP_TYPE_RN ) return OP_MEM_10 ; if ( opy == OP_TYPE_MEM1 && opx == OP_TYPE_MEM1 ) { switch ( get_attr_opx_access ( insn ) ) { case OPX_ACCESS_W : return OP_MEM_11 ; default : gcc_assert ( ! reload_completed ) ; return OP_MEM_11 ; } } if ( opy == OP_TYPE_MEM1 && opx == OP_TYPE_MEM6 ) { switch ( get_attr_opx_access ( insn ) ) { case OPX_ACCESS_W : return OP_MEM_1I ; default :


<s> return SIZE_1 ; case <NUM_LIT> : return SIZE_2 ; case <NUM_LIT> : return SIZE_3 ; default : gcc_unreachable ( ) ; }


<s> enum attr_size m68k_sched_attr_size ( rtx_insn * insn ) { switch ( sched_get_attr_size_int ( insn ) ) { case <NUM_LIT> : return SIZE_1 ;


<s> if ( ! sched_ib . enabled_p ) return ;


<s> static void m68k_sched_dfa_pre_advance_cycle ( void ) { if ( ! sched_ib . enabled_p ) return ; if ( ! cpu_unit_reservation_p ( curr_state , sched_mem_unit_code ) ) { sched_ib . filled += <NUM_LIT> ;

if ( sched_ib . filled > sched_ib . size ) sched_ib . filled = sched_ib . size ;


<s> sched_ib . filled += <NUM_LIT> ; if ( sched_ib . filled > sched_ib . size ) sched_ib . filled = sched_ib . size ;


return m68k_sched_issue_rate ( ) - <NUM_LIT> ;


<s> static int m68k_sched_issue_rate ( void ) { switch ( m68k_sched_cpu ) { case CPU_CFV1 : case CPU_CFV2 : case CPU_CFV3 : return <NUM_LIT> ; case CPU_CFV4 : return <NUM_LIT> ; default : gcc_unreachable ( ) ; return <NUM_LIT> ;


if ( GET_MODE_SIZE ( mode ) == <NUM_LIT> && reg_classes_intersect_p ( rclass , ADDR_REGS ) && ! ( INT_REGNO_P ( regno ) || CONSTANT_P ( x ) ) ) return DATA_REGS ;


<s> rtx body ; int i ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; body = PATTERN ( insn ) ;

if ( GET_CODE ( body ) == PARALLEL ) for ( i = <NUM_LIT> ; i < XVECLEN ( body , <NUM_LIT> ) ; i ++ ) RTX_FRAME_RELATED_P ( XVECEXP ( body , <NUM_LIT> , i ) ) = <NUM_LIT> ;


<s> * offset = <NUM_LIT> ; if ( GET_CODE ( x ) == PLUS && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) {

* offset += INTVAL ( XEXP ( x , <NUM_LIT> ) ) ;


<s> static rtx m68k_struct_value_rtx ( tree fntype ATTRIBUTE_UNUSED , int incoming ATTRIBUTE_UNUSED ) {

return gen_rtx_REG ( Pmode , M68K_STRUCT_VALUE_REGNUM ) ;


<s> static rtx m68k_struct_value_rtx ( tree fntype ATTRIBUTE_UNUSED , int incoming ATTRIBUTE_UNUSED ) { return gen_rtx_REG ( Pmode , M68K_STRUCT_VALUE_REGNUM ) ;


<s> subrtx_var_iterator :: array_type array ; FOR_EACH_SUBRTX_VAR ( iter , array , x , ALL ) { 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 ( ) ; } return false ; } else {


<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 ( ) ; } return false ; }


<s> if ( GET_CODE ( x ) != SYMBOL_REF ) return false ;

return SYMBOL_REF_TLS_MODEL ( x ) != <NUM_LIT> ;


<s> emit_move_insn ( mem , GEN_INT ( <NUM_LIT> + ( ( STATIC_CHAIN_REGNUM - <NUM_LIT> ) << <NUM_LIT> ) ) ) ; mem = adjust_address ( m_tramp , SImode , <NUM_LIT> ) ; emit_move_insn ( mem , chain_value ) ; mem = adjust_address ( m_tramp , HImode , <NUM_LIT> ) ;

emit_move_insn ( mem , GEN_INT ( <NUM_LIT> ) ) ;


<s> return m68k_unwrap_symbol_1 ( orig , unwrap_reloc32_p , NULL ) ;


<s> switch ( XINT ( x , <NUM_LIT> ) ) { case UNSPEC_RELOC16 : orig = XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ; * reloc_ptr = ( enum m68k_reloc ) INTVAL ( XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ) ; break ; case UNSPEC_RELOC32 : if ( unwrap_reloc32_p ) { orig = XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ; * reloc_ptr = ( enum m68k_reloc ) INTVAL ( XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ) ; } break ; default : break ;


<s> bool m68k_use_return_insn ( void ) { if ( ! reload_completed || frame_pointer_needed || get_frame_size ( ) != <NUM_LIT> ) return false ;


<s> if ( ! reload_completed || frame_pointer_needed || get_frame_size ( ) != <NUM_LIT> ) return false ;


<s> x = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , x , GEN_INT ( reloc ) ) , UNSPEC_RELOC32 ) ; x = gen_rtx_CONST ( Pmode , x ) ; if ( temp_reg == NULL ) { gcc_assert ( can_create_pseudo_p ( ) ) ; temp_reg = gen_reg_rtx ( Pmode ) ;


<s> use_x_p = ( base_reg == pic_offset_table_rtx ) ? TARGET_XGOT : TARGET_XTLS ; if ( TARGET_COLDFIRE && use_x_p ) { x = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , x , GEN_INT ( reloc ) ) , UNSPEC_RELOC32 ) ; x = gen_rtx_CONST ( Pmode , x ) ; if ( temp_reg == NULL ) { gcc_assert ( can_create_pseudo_p ( ) ) ;


<s> x = m68k_wrap_symbol ( x , reloc , m68k_get_gp ( ) , temp_reg ) ; x = gen_rtx_MEM ( Pmode , x ) ; MEM_READONLY_P ( x ) = <NUM_LIT> ; return x ;


<s> x = m68k_wrap_symbol ( x , reloc , m68k_get_gp ( ) , temp_reg ) ;


<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 ( TUNE_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> ; }


<s> const char * output_addsi3 ( rtx * operands ) { if ( ! operands_match_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) { if ( ! ADDRESS_REG_P ( operands [ <NUM_LIT> ] ) ) { rtx tmp = operands [ <NUM_LIT> ] ; 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> ] ) ) ; return <STR_LIT> ; } if ( TUNE_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> ;


<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> ) ; } return <STR_LIT> ; } if ( ! side_effects_p ( operands [ <NUM_LIT> ] ) ) flags_operand1 = operands [ <NUM_LIT> ] ; flags_valid = FLAGS_VALID_YES ;


<s> const char * output_call ( rtx x ) { if ( symbolic_operand ( x , VOIDmode ) ) return m68k_symbolic_call ;


<s> 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 ; case PLUS : output_asm_insn ( <STR_LIT> , operands ) ; break ; case MINUS : output_asm_insn ( <STR_LIT> , operands ) ; break ; default : gcc_unreachable ( ) ; }

switch ( GET_MODE ( operands [ <NUM_LIT> ] ) ) {


<s> 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> ) ) >= <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> ) ; } return <STR_LIT> ; } if ( ! side_effects_p ( operands [ <NUM_LIT> ] ) ) flags_operand1 = operands [ <NUM_LIT> ] ; flags_valid = FLAGS_VALID_YES ;


<s> if ( GET_CODE ( operands [ <NUM_LIT> ] ) != REG ) operands [ <NUM_LIT> ] = adjust_address ( operands [ <NUM_LIT> ] , HImode , <NUM_LIT> ) ; 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> ) ) >= <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> ) ; } return <STR_LIT> ; } if ( ! side_effects_p ( operands [ <NUM_LIT> ] ) ) flags_operand1 = operands [ <NUM_LIT> ] ;


<s> const char * output_move_const_double ( rtx * operands ) { int code = standard_68881_constant_p ( operands [ <NUM_LIT> ] ) ; if ( code != <NUM_LIT> ) { static char buf [ <NUM_LIT> ] ; sprintf ( buf , <STR_LIT> , code & <NUM_LIT> ) ; return buf ; } return <STR_LIT> ;


<s> static char buf [ <NUM_LIT> ] ; sprintf ( buf , <STR_LIT> , code & <NUM_LIT> ) ; return buf ; }


<s> 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> ;


<s> static char buf [ <NUM_LIT> ] ; sprintf ( buf , <STR_LIT> , code & <NUM_LIT> ) ; return buf ;


<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 ) return output_move_simode_const ( operands ) ; 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> 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> dest = operands [ <NUM_LIT> ] ; src = INTVAL ( operands [ <NUM_LIT> ] ) ; if ( src == <NUM_LIT> && ( DATA_REG_P ( dest ) || MEM_P ( dest ) ) && ( ( TARGET_68010 || TARGET_COLDFIRE ) || ! ( MEM_P ( dest ) && MEM_VOLATILE_P ( dest ) ) ) ) return <STR_LIT> ; else if ( GET_MODE ( dest ) == SImode && valid_mov3q_const ( src ) ) return <STR_LIT> ; else if ( src == <NUM_LIT> && ADDRESS_REG_P ( dest ) ) return <STR_LIT> ; else if ( DATA_REG_P ( dest ) ) return output_move_const_into_data_reg ( operands ) ; else if ( ADDRESS_REG_P ( dest ) && IN_RANGE ( src , - <NUM_LIT> , <NUM_LIT> ) ) { if ( valid_mov3q_const ( src ) ) return <STR_LIT> ; return <STR_LIT> ; } else if ( MEM_P ( dest ) && GET_CODE ( XEXP ( dest , <NUM_LIT> ) ) == PRE_DEC && REGNO ( XEXP ( XEXP ( dest , <NUM_LIT> ) , <NUM_LIT> ) ) == STACK_POINTER_REGNUM && IN_RANGE ( src , - <NUM_LIT> , <NUM_LIT> ) ) { if ( valid_mov3q_const ( src ) ) return <STR_LIT> ; return <STR_LIT> ; } return <STR_LIT> ;


<s> const char * output_move_stricthi ( rtx * operands ) {

if ( operands [ <NUM_LIT> ] == const0_rtx && ( ( TARGET_68010 || TARGET_COLDFIRE ) || ! ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM && MEM_VOLATILE_P ( operands [ <NUM_LIT> ] ) ) ) ) return <STR_LIT> ;


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


<s> if ( operands [ <NUM_LIT> ] == const0_rtx && ( ( TARGET_68010 || TARGET_COLDFIRE ) || ! ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM && MEM_VOLATILE_P ( operands [ <NUM_LIT> ] ) ) ) ) return <STR_LIT> ; return <STR_LIT> ;


<s> static void output_reg_adjust ( rtx reg , int n ) { const char * s ; gcc_assert ( GET_MODE ( reg ) == SImode && n >= - <NUM_LIT> && n != <NUM_LIT> && n <= <NUM_LIT> ) ; switch ( n ) { case <NUM_LIT> : s = <STR_LIT> ; break ;


<s> gcc_assert ( GET_MODE ( reg ) == SImode && n >= - <NUM_LIT> && n != <NUM_LIT> && n <= <NUM_LIT> ) ; switch ( n ) { 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> const char * output_sibcall ( rtx x ) { if ( symbolic_operand ( x , VOIDmode ) ) return m68k_symbolic_jump ;


<s> } if ( address . index ) { if ( address . base ) putc ( ',' , file ) ; fprintf ( file , <STR_LIT> , M68K_REGNAME ( REGNO ( address . index ) ) , GET_MODE ( address . index ) == HImode ? 'w' : 'l' ) ; if ( address . scale != <NUM_LIT> ) fprintf ( file , <STR_LIT> , address . scale ) ; } putc ( ')' , file ) ; } else { if ( ! address . offset && ! address . index ) fprintf ( file , <STR_LIT> , M68K_REGNAME ( REGNO ( address . base ) ) ) ; else { if ( labelno >= <NUM_LIT> ) asm_fprintf ( file , <STR_LIT> , labelno ) ; else { if ( address . base ) fputs ( M68K_REGNAME ( REGNO ( address . base ) ) , file ) ; fprintf ( file , <STR_LIT> ) ; if ( address . offset ) output_addr_const ( file , address . offset ) ; } if ( address . index ) { fprintf ( file , <STR_LIT> , M68K_REGNAME ( REGNO ( address . index ) ) , GET_MODE ( address . index ) == HImode ? 'w' : 'l' ) ; if ( address . scale != <NUM_LIT> ) fprintf ( file , <STR_LIT> , address . scale ) ; } putc ( ')' , file ) ; } }


<s> struct m68k_address address ; if ( symbolic_operand ( addr_rtx , VOIDmode ) ) return OP_TYPE_MEM7 ; if ( ! m68k_decompose_address ( mode , addr_rtx , reload_completed , & address ) ) { gcc_assert ( ! reload_completed ) ; return OP_TYPE_MEM234 ; } if ( address . scale != <NUM_LIT> ) return OP_TYPE_MEM6 ;


<s> return OP_TYPE_MEM234 ; } if ( address . scale != <NUM_LIT> ) return OP_TYPE_MEM6 ; if ( address . base != NULL_RTX ) { if ( address . offset == NULL_RTX ) return OP_TYPE_MEM234 ; return OP_TYPE_MEM5 ;


<s> case OPY_TYPE_IMM_L : size += <NUM_LIT> ; break ; default : gcc_unreachable ( ) ; } switch ( get_attr_opy_type ( insn ) ) { case OPY_TYPE_NONE : case OPY_TYPE_RN : case OPY_TYPE_FPN : case OPY_TYPE_MEM1 : case OPY_TYPE_MEM234 : case OPY_TYPE_IMM_Q : break ; case OPY_TYPE_MEM5 : case OPY_TYPE_MEM6 : case OPY_TYPE_MEM7 : case OPY_TYPE_IMM_W : ++ size ; break ; case OPY_TYPE_IMM_L : size += <NUM_LIT> ; break ; default : gcc_unreachable ( ) ; }


<s> switch ( get_attr_opy_type ( insn ) ) { case OPY_TYPE_NONE : case OPY_TYPE_RN : case OPY_TYPE_FPN : case OPY_TYPE_MEM1 : case OPY_TYPE_MEM234 : case OPY_TYPE_IMM_Q : break ; case OPY_TYPE_MEM5 : case OPY_TYPE_MEM6 : case OPY_TYPE_MEM7 : case OPY_TYPE_IMM_W : ++ size ; break ; case OPY_TYPE_IMM_L : size += <NUM_LIT> ; break ; default : gcc_unreachable ( ) ; }


<s> struct m68k_address address ; reg = sched_get_reg_operand ( pro , true ) ; if ( reg == NULL ) return <NUM_LIT> ; mem = sched_get_mem_operand ( con , true , false ) ; gcc_assert ( mem != NULL && MEM_P ( mem ) ) ; if ( ! m68k_decompose_address ( GET_MODE ( mem ) , XEXP ( mem , <NUM_LIT> ) , reload_completed , & address ) ) gcc_unreachable ( ) ; if ( REGNO ( reg ) == REGNO ( address . index ) ) {

gcc_assert ( address . scale != <NUM_LIT> ) ;


<s> opy_p = true ; } if ( must_write_p ) { opx_p = true ; opy_p = false ; } if ( opy_p && sched_mem_operand_p ( insn , false ) ) return sched_get_operand ( insn , false ) ;

if ( opx_p && sched_mem_operand_p ( insn , true ) ) return sched_get_operand ( insn , true ) ;


<s> int i ; if ( recog_memoized ( insn ) < <NUM_LIT> ) gcc_unreachable ( ) ; extract_constrain_insn_cached ( insn ) ; if ( opx_p ) i = get_attr_opx ( insn ) ; else i = get_attr_opy ( insn ) ;

if ( i >= recog_data . n_operands ) return NULL ;


<s> case OPX_TYPE_MEM234 : case OPX_TYPE_MEM5 : case OPX_TYPE_MEM7 : return OP_TYPE_MEM1 ; case OPX_TYPE_MEM6 : return OP_TYPE_MEM6 ; default : gcc_unreachable ( ) ; } } else { switch ( get_attr_opy_type ( insn ) ) { case OPY_TYPE_NONE : case OPY_TYPE_RN :


<s> gcc_assert ( op != NULL ) ; if ( ! reload_completed && ! REG_P ( op ) ) return NULL ; } } else { if ( get_attr_opy_type ( insn ) == OPY_TYPE_RN ) { op = sched_get_operand ( insn , false ) ; gcc_assert ( op != NULL ) ; if ( ! reload_completed && ! REG_P ( op ) ) return NULL ;


<s> if ( ! reload_completed && ! REG_P ( op ) ) return NULL ; } } else { if ( get_attr_opy_type ( insn ) == OPY_TYPE_RN ) { op = sched_get_operand ( insn , false ) ; gcc_assert ( op != NULL ) ; if ( ! reload_completed && ! REG_P ( op ) ) return NULL ; } }


<s> static const char * singlemove_string ( rtx * operands ) { if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT ) return output_move_simode_const ( operands ) ; return <STR_LIT> ;


<s> if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT ) return output_move_simode_const ( operands ) ;


<s> hi_half [ num ] = adjust_address ( op , SImode , <NUM_LIT> ) ; } else {

lo_half [ num ] = simplify_gen_subreg ( SImode , op , GET_MODE ( op ) == VOIDmode ? DImode : GET_MODE ( op ) , <NUM_LIT> ) ;


<s> if ( GET_MODE ( x ) == SFmode ) return <NUM_LIT> ; if ( real_equal ( r , & values_68881 [ <NUM_LIT> ] ) ) return ( codes_68881 [ <NUM_LIT> ] ) ;


<s> 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 ) ) ) ; else return false ; } } return false ;


<s> 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 ) ) ) ; else return false ;


<s> bool valid_mov3q_const ( HOST_WIDE_INT i ) { return TARGET_ISAB && ( i == - <NUM_LIT> || IN_RANGE ( i , <NUM_LIT> , <NUM_LIT> ) ) ;


<s> __inline static double modf ( double x , double * ip ) { double temp ; __asm ( <STR_LIT> : <STR_LIT> ( temp ) : <STR_LIT> ( x ) ) ; * ip = temp ;


__asm ( <STR_LIT> : <STR_LIT> ( temp ) : <STR_LIT> ( x ) ) ;


<s> const double sin ( double x ) { double value ;

__asm ( <STR_LIT> : <STR_LIT> ( value ) : <STR_LIT> ( x ) ) ;


<s> __inline extern double frexp ( double x , int * exp ) { double float_exponent ; int int_exponent ; double mantissa ; __asm ( <STR_LIT> : <STR_LIT> ( float_exponent ) : <STR_LIT> ( x ) ) ; int_exponent = ( int ) float_exponent ;

__asm ( <STR_LIT> : <STR_LIT> ( mantissa ) : <STR_LIT> ( x ) ) ;