<s> for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( x & ( ( unsigned short ) <NUM_LIT> << ( <NUM_LIT> - i ) ) ) break ;


for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( x & ( ( unsigned short ) <NUM_LIT> << i ) ) break ;


<s> int i ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( x & ( ( unsigned short ) <NUM_LIT> << i ) ) break ; return i ;


<s> if ( a >= ( float ) <NUM_LIT> ) return ( long ) ( a - <NUM_LIT> ) + <NUM_LIT> ; return ( long ) a ;


<s> gcc_unreachable ( ) ; } gcc_assert ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT ) ; n = INTVAL ( operands [ <NUM_LIT> ] ) ; if ( n < <NUM_LIT> ) n = <NUM_LIT> ; else if ( ( unsigned int ) n > GET_MODE_BITSIZE ( mode ) ) n = GET_MODE_BITSIZE ( mode ) ; get_shift_alg ( shift_type , shift_mode , n , & info ) ; switch ( info . alg ) { case SHIFT_SPECIAL : if ( info . remainder == <NUM_LIT> ) return info . cc_special ; case SHIFT_INLINE : return info . cc_inline ; case SHIFT_ROT_AND : return OLD_CC_SET_ZNV ; case SHIFT_LOOP : if ( info . shift2 != NULL ) { if ( n % <NUM_LIT> ) return info . cc_inline ;


<s> n = n % <NUM_LIT> ; } wlength += h8300_asm_insn_count ( info . shift1 ) * n ; return <NUM_LIT> * wlength ; case SHIFT_ROT_AND : { int m = GET_MODE_BITSIZE ( mode ) - n ; gcc_assert ( info . shift1 ) ; if ( info . shift2 != NULL ) { wlength += h8300_asm_insn_count ( info . shift2 ) * ( m / <NUM_LIT> ) ; m = m % <NUM_LIT> ; } wlength += h8300_asm_insn_count ( info . shift1 ) * m ; switch ( mode ) { case E_QImode : wlength += <NUM_LIT> ; break ; case E_HImode : wlength += <NUM_LIT> ; break ; case E_SImode : wlength += <NUM_LIT> ; break ; default : gcc_unreachable ( ) ; } return <NUM_LIT> * wlength ; } case SHIFT_LOOP : if ( info . shift2 != NULL ) { wlength += <NUM_LIT> + h8300_asm_insn_count ( info . shift2 ) ; if ( n % <NUM_LIT> ) wlength += h8300_asm_insn_count ( info . shift1 ) ; }


<s> const unsigned HOST_WIDE_INT intval = ( unsigned HOST_WIDE_INT ) ( ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT ) && register_operand ( operands [ <NUM_LIT> ] , VOIDmode ) ? INTVAL ( operands [ <NUM_LIT> ] ) : <NUM_LIT> ) ; const unsigned HOST_WIDE_INT det = ( code != AND ) ? intval : ~ intval ; const unsigned HOST_WIDE_INT b0 = ( det >> <NUM_LIT> ) & <NUM_LIT> ; const unsigned HOST_WIDE_INT b1 = ( det >> <NUM_LIT> ) & <NUM_LIT> ; const unsigned HOST_WIDE_INT w0 = ( det >> <NUM_LIT> ) & <NUM_LIT> ; const unsigned HOST_WIDE_INT w1 = ( det >> <NUM_LIT> ) & <NUM_LIT> ; int lower_half_easy_p = <NUM_LIT> ; int upper_half_easy_p = <NUM_LIT> ; enum attr_old_cc cc = OLD_CC_CLOBBER ; switch ( mode ) { case E_HImode : if ( b0 != <NUM_LIT> && b1 != <NUM_LIT> ) { cc = OLD_CC_SET_ZNV ; } break ; case E_SImode : lower_half_easy_p = ( b0 == <NUM_LIT> || b1 == <NUM_LIT> || ( code != IOR && w0 == <NUM_LIT> ) ) ;

upper_half_easy_p = ( ( code != IOR && w1 == <NUM_LIT> ) || ( code == AND && w1 == <NUM_LIT> ) ) ;


<s> const unsigned HOST_WIDE_INT b0 = ( det >> <NUM_LIT> ) & <NUM_LIT> ; const unsigned HOST_WIDE_INT b1 = ( det >> <NUM_LIT> ) & <NUM_LIT> ; const unsigned HOST_WIDE_INT w0 = ( det >> <NUM_LIT> ) & <NUM_LIT> ; const unsigned HOST_WIDE_INT w1 = ( det >> <NUM_LIT> ) & <NUM_LIT> ; int lower_half_easy_p = <NUM_LIT> ; int upper_half_easy_p = <NUM_LIT> ; enum attr_old_cc cc = OLD_CC_CLOBBER ; switch ( mode ) { case E_HImode : if ( b0 != <NUM_LIT> && b1 != <NUM_LIT> ) { cc = OLD_CC_SET_ZNV ; } break ;


<s> break ; case E_SImode : lower_half_easy_p = ( b0 == <NUM_LIT> || b1 == <NUM_LIT> || ( code != IOR && w0 == <NUM_LIT> ) ) ; upper_half_easy_p = ( ( code != IOR && w1 == <NUM_LIT> ) || ( code == AND && w1 == <NUM_LIT> ) ) ; if ( w0 != <NUM_LIT> && w1 != <NUM_LIT> && ! ( lower_half_easy_p && upper_half_easy_p ) && ! ( code == IOR && w1 == <NUM_LIT> && ( w0 & <NUM_LIT> ) != <NUM_LIT> && lower_half_easy_p ) ) { length = h8300_length_from_table ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , & logicl_length_table ) ; } else { if ( w0 == <NUM_LIT> && ( code != IOR ) ) { length += <NUM_LIT> ; } else if ( ( b0 != <NUM_LIT> ) && ( b1 != <NUM_LIT> ) ) { length += <NUM_LIT> ; } else { if ( b0 != <NUM_LIT> ) length += <NUM_LIT> ; if ( b1 != <NUM_LIT> ) length += <NUM_LIT> ; } if ( w1 == <NUM_LIT> && ( code != IOR ) ) { length += <NUM_LIT> ;


<s> static void h8300_emit_stack_adjustment ( int sign , HOST_WIDE_INT size , bool in_prologue ) { if ( size == <NUM_LIT> ) return ; if ( Pmode == HImode ) {

rtx_insn * x = emit_insn ( gen_addhi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( sign * size ) ) ) ;


<s> rtx_insn * x = emit_insn ( gen_addhi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( sign * size ) ) ) ; if ( size < <NUM_LIT> ) F ( x , <NUM_LIT> ) ; }

else F ( emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( sign * size ) ) ) , <NUM_LIT> ) ;


<s> if ( TARGET_H8300S ) { if ( ( TARGET_H8300SX || ( regno & <NUM_LIT> ) == <NUM_LIT> ) && ( ( saved_regs >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) n_regs = <NUM_LIT> ; else if ( ( TARGET_H8300SX || ( regno & <NUM_LIT> ) == <NUM_LIT> ) && ( ( saved_regs >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) n_regs = <NUM_LIT> ;


<s> if ( saved_regs & ( <NUM_LIT> << regno ) ) { if ( TARGET_H8300S ) { if ( ( TARGET_H8300SX || ( regno & <NUM_LIT> ) == <NUM_LIT> ) && ( ( saved_regs >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) n_regs = <NUM_LIT> ; else if ( ( TARGET_H8300SX || ( regno & <NUM_LIT> ) == <NUM_LIT> ) && ( ( saved_regs >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) n_regs = <NUM_LIT> ; else if ( ( TARGET_H8300SX || ( regno & <NUM_LIT> ) == <NUM_LIT> ) && ( ( saved_regs >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) n_regs = <NUM_LIT> ; } h8300_push_pop ( regno , n_regs , false , false ) ; }


<s> cpu_type = ( int ) CPU_H8300H ; h8_reg_names = names_extended ; h8_push_op = h8_push_ops [ cpu_type ] ; h8_pop_op = h8_pop_ops [ cpu_type ] ; h8_mov_op = h8_mov_ops [ cpu_type ] ; if ( TARGET_H8300S ) target_flags &= ~ MASK_H8300H ; if ( ! TARGET_H8300S && TARGET_MAC ) { error ( <STR_LIT> ) ; target_flags |= MASK_H8300S_1 ; } if ( ! TARGET_H8300S && TARGET_EXR ) { error ( <STR_LIT> ) ; target_flags |= MASK_H8300S_1 ; } if ( ( ! TARGET_H8300S && TARGET_EXR ) && ( ! TARGET_H8300SX && TARGET_EXR ) ) { error ( <STR_LIT> ) ; target_flags |= MASK_H8300S_1 ; } if ( ( ! TARGET_H8300S && TARGET_NEXR ) && ( ! TARGET_H8300SX && TARGET_NEXR ) ) { warning ( OPT_mno_exr , <STR_LIT> <STR_LIT> ) ; } if ( ( TARGET_NORMAL_MODE ) ) { error ( <STR_LIT> ) ; target_flags ^= MASK_NORMAL_MODE ; } if ( optimize_size ) { shift_alg_hi [ H8_300H ] [ SHIFT_ASHIFT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_300H ] [ SHIFT_ASHIFT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_300H ] [ SHIFT_LSHIFTRT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_300H ] [ SHIFT_LSHIFTRT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_300H ] [ SHIFT_ASHIFTRT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_300H ] [ SHIFT_ASHIFTRT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_300H ] [ SHIFT_ASHIFTRT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_300H ] [ SHIFT_ASHIFTRT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_S ] [ SHIFT_ASHIFTRT ] [ <NUM_LIT> ] = SHIFT_LOOP ; } if ( ! TARGET_H8300SX ) { h8300_move_ratio = <NUM_LIT> ; } else if ( flag_omit_frame_pointer ) { h8300_move_ratio = <NUM_LIT> ; }


<s> h8_reg_names = names_extended ; h8_push_op = h8_push_ops [ cpu_type ] ; h8_pop_op = h8_pop_ops [ cpu_type ] ; h8_mov_op = h8_mov_ops [ cpu_type ] ; if ( TARGET_H8300S ) target_flags &= ~ MASK_H8300H ; if ( ! TARGET_H8300S && TARGET_MAC ) { error ( <STR_LIT> ) ; target_flags |= MASK_H8300S_1 ; } if ( ! TARGET_H8300S && TARGET_EXR ) { error ( <STR_LIT> ) ; target_flags |= MASK_H8300S_1 ; } if ( ( ! TARGET_H8300S && TARGET_EXR ) && ( ! TARGET_H8300SX && TARGET_EXR ) ) { error ( <STR_LIT> ) ; target_flags |= MASK_H8300S_1 ; } if ( ( ! TARGET_H8300S && TARGET_NEXR ) && ( ! TARGET_H8300SX && TARGET_NEXR ) ) { warning ( OPT_mno_exr , <STR_LIT> <STR_LIT> ) ; } if ( ( TARGET_NORMAL_MODE ) ) { error ( <STR_LIT> ) ; target_flags ^= MASK_NORMAL_MODE ; } if ( optimize_size ) { shift_alg_hi [ H8_300H ] [ SHIFT_ASHIFT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_300H ] [ SHIFT_ASHIFT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_300H ] [ SHIFT_LSHIFTRT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_300H ] [ SHIFT_LSHIFTRT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_300H ] [ SHIFT_ASHIFTRT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_300H ] [ SHIFT_ASHIFTRT ] [ <NUM_LIT> ] = SHIFT_LOOP ;


<s> static int h8300_register_move_cost ( machine_mode mode ATTRIBUTE_UNUSED , reg_class_t from , reg_class_t to ) { if ( from == MAC_REGS || to == MAC_REGS ) return <NUM_LIT> ; else return <NUM_LIT> ;


<s> if ( op1 == const0_rtx && ( cond == EQ || cond == NE || cond == LT || cond == GE ) && ( GET_CODE ( op0 ) == PLUS || GET_CODE ( op0 ) == MINUS || GET_CODE ( op0 ) == NEG || GET_CODE ( op0 ) == AND || GET_CODE ( op0 ) == IOR || GET_CODE ( op0 ) == XOR || GET_CODE ( op0 ) == NOT || GET_CODE ( op0 ) == ASHIFT || GET_CODE ( op0 ) == REG || GET_CODE ( op0 ) == MULT ) ) return CCZNmode ; return CCmode ;


<s> a = shift_alg_qi [ cpu ] [ SHIFT_ASHIFT ] [ count ] ; lr = shift_alg_qi [ cpu ] [ SHIFT_LSHIFTRT ] [ count ] ; ar = shift_alg_qi [ cpu ] [ SHIFT_ASHIFTRT ] [ count ] ; break ; case E_HImode : a = shift_alg_hi [ cpu ] [ SHIFT_ASHIFT ] [ count ] ; lr = shift_alg_hi [ cpu ] [ SHIFT_LSHIFTRT ] [ count ] ; ar = shift_alg_hi [ cpu ] [ SHIFT_ASHIFTRT ] [ count ] ; break ; case E_SImode : a = shift_alg_si [ cpu ] [ SHIFT_ASHIFT ] [ count ] ;

lr = shift_alg_si [ cpu ] [ SHIFT_LSHIFTRT ] [ count ] ;


<s> shift_mode = SIshift ; break ; default : gcc_unreachable ( ) ; } switch ( code ) { case ASHIFTRT : shift_type = SHIFT_ASHIFTRT ; break ; case LSHIFTRT : shift_type = SHIFT_LSHIFTRT ; break ; case ASHIFT : shift_type = SHIFT_ASHIFT ; break ; default : gcc_unreachable ( ) ; } gcc_assert ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT ) ; n = INTVAL ( operands [ <NUM_LIT> ] ) ; if ( n < <NUM_LIT> ) n = <NUM_LIT> ; else if ( ( unsigned int ) n > GET_MODE_BITSIZE ( mode ) ) n = GET_MODE_BITSIZE ( mode ) ; get_shift_alg ( shift_type , shift_mode , n , & info ) ; switch ( info . alg ) { case SHIFT_SPECIAL : output_asm_insn ( info . special , operands ) ; case SHIFT_INLINE : n = info . remainder ; if ( info . shift2 != NULL ) { for ( ; n > <NUM_LIT> ; n -= <NUM_LIT> ) output_asm_insn ( info . shift2 , operands ) ; } for ( ; n > <NUM_LIT> ; n -- ) output_asm_insn ( info . shift1 , operands ) ; return <STR_LIT> ; case SHIFT_ROT_AND : { int m = GET_MODE_BITSIZE ( mode ) - n ; const int mask = ( shift_type == SHIFT_ASHIFT ? ( ( <NUM_LIT> << m ) - <NUM_LIT> ) << n : ( <NUM_LIT> << m ) - <NUM_LIT> ) ; char insn_buf [ <NUM_LIT> ] ; gcc_assert ( info . shift1 ) ; if ( info . shift2 != NULL ) { for ( ; m > <NUM_LIT> ; m -= <NUM_LIT> ) output_asm_insn ( info . shift2 , operands ) ; } for ( ; m > <NUM_LIT> ; m -- ) output_asm_insn ( info . shift1 , operands ) ; switch ( mode ) { case E_QImode : sprintf ( insn_buf , <STR_LIT> , mask ) ; break ; case E_HImode : sprintf ( insn_buf , <STR_LIT> , mask ) ; break ; default : gcc_unreachable ( ) ; } output_asm_insn ( insn_buf , operands ) ; return <STR_LIT> ; } case SHIFT_LOOP : if ( info . shift2 != NULL ) { fprintf ( asm_out_file , <STR_LIT> , n / <NUM_LIT> , names_big [ REGNO ( operands [ <NUM_LIT> ] ) ] ) ; fprintf ( asm_out_file , <STR_LIT> , loopend_lab ) ; output_asm_insn ( info . shift2 , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; fprintf ( asm_out_file , <STR_LIT> , loopend_lab ) ; if ( n % <NUM_LIT> ) output_asm_insn ( info . shift1 , operands ) ; } else { fprintf ( asm_out_file , <STR_LIT> , n , names_big [ REGNO ( operands [ <NUM_LIT> ] ) ] ) ; fprintf ( asm_out_file , <STR_LIT> , loopend_lab ) ; output_asm_insn ( info . shift1 , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; fprintf ( asm_out_file , <STR_LIT> , loopend_lab ) ; } return <STR_LIT> ;


<s> gcc_unreachable ( ) ; } switch ( mode ) { case E_HImode : if ( b0 != <NUM_LIT> && b1 != <NUM_LIT> ) { sprintf ( insn_buf , <STR_LIT> , opname ) ; output_asm_insn ( insn_buf , operands ) ; } else { if ( b0 != <NUM_LIT> ) { sprintf ( insn_buf , <STR_LIT> , opname ) ; output_asm_insn ( insn_buf , operands ) ; } if ( b1 != <NUM_LIT> ) { sprintf ( insn_buf , <STR_LIT> , opname ) ; output_asm_insn ( insn_buf , operands ) ; } } break ; case E_SImode : lower_half_easy_p = ( b0 == <NUM_LIT> || b1 == <NUM_LIT> || ( code != IOR && w0 == <NUM_LIT> ) ) ; upper_half_easy_p = ( ( code != IOR && w1 == <NUM_LIT> ) || ( code == AND && w1 == <NUM_LIT> ) ) ; if ( w0 != <NUM_LIT> && w1 != <NUM_LIT> && ! ( lower_half_easy_p && upper_half_easy_p ) && ! ( code == IOR && w1 == <NUM_LIT> && ( w0 & <NUM_LIT> ) != <NUM_LIT> && lower_half_easy_p ) ) { sprintf ( insn_buf , <STR_LIT> , opname ) ; output_asm_insn ( insn_buf , operands ) ; } else { if ( w0 == <NUM_LIT> && ( code != IOR ) ) output_asm_insn ( ( code == AND ) ? <STR_LIT> : <STR_LIT> , operands ) ; else if ( ( b0 != <NUM_LIT> ) && ( b1 != <NUM_LIT> ) ) { sprintf ( insn_buf , <STR_LIT> , opname ) ; output_asm_insn ( insn_buf , operands ) ;


<s> if ( GET_CODE ( op ) != PRE_DEC && GET_CODE ( op ) != PRE_INC ) return false ; op = XEXP ( op , <NUM_LIT> ) ;


<s> op = XEXP ( op , <NUM_LIT> ) ; if ( GET_CODE ( op ) != PRE_DEC && GET_CODE ( op ) != PRE_INC ) return false ;


<s> rtx reg = gen_rtx_REG ( word_mode , rn ) ; rtx x ; if ( ! TARGET_NORMAL_MODE ) x = gen_push_h8300hs_advanced ( reg ) ; else x = gen_push_h8300hs_normal ( reg ) ; x = F ( emit_insn ( x ) , <NUM_LIT> ) ;

add_reg_note ( x , REG_INC , stack_pointer_rtx ) ;


<s> x = F ( emit_insn ( x ) , <NUM_LIT> ) ;


<s> if ( WORD_REG_USED ( regno ) ) saved_regs |= <NUM_LIT> << regno ; } if ( frame_pointer_needed ) saved_regs &= ~ ( <NUM_LIT> << FRAME_POINTER_REGNUM ) ; return saved_regs ;


<s> unsigned int length = <NUM_LIT> ; gcc_assert ( GET_CODE ( amount_rtx ) == CONST_INT ) ; amount = INTVAL ( amount_rtx ) ; if ( amount < <NUM_LIT> ) amount = <NUM_LIT> ; if ( ( unsigned int ) amount > GET_MODE_BITSIZE ( mode ) ) amount = GET_MODE_BITSIZE ( mode ) ; if ( ( unsigned int ) amount > GET_MODE_BITSIZE ( mode ) / ( unsigned ) <NUM_LIT> ) amount = GET_MODE_BITSIZE ( mode ) - amount ; if ( ( mode == HImode && TARGET_H8300 && amount >= <NUM_LIT> ) || ( mode == HImode && TARGET_H8300H && amount >= <NUM_LIT> ) || ( mode == HImode && TARGET_H8300S && amount == <NUM_LIT> ) || ( mode == SImode && TARGET_H8300H && amount >= <NUM_LIT> ) || ( mode == SImode && TARGET_H8300S && amount >= <NUM_LIT> ) ) { amount = GET_MODE_BITSIZE ( mode ) / <NUM_LIT> - amount ; length += <NUM_LIT> ; }

if ( TARGET_H8300S ) amount = amount / <NUM_LIT> + amount % <NUM_LIT> ;


<s> if ( ( unsigned int ) amount > GET_MODE_BITSIZE ( mode ) ) amount = GET_MODE_BITSIZE ( mode ) ; if ( ( unsigned int ) amount > GET_MODE_BITSIZE ( mode ) / ( unsigned ) <NUM_LIT> ) amount = GET_MODE_BITSIZE ( mode ) - amount ; if ( ( mode == HImode && TARGET_H8300 && amount >= <NUM_LIT> ) || ( mode == HImode && TARGET_H8300H && amount >= <NUM_LIT> ) || ( mode == HImode && TARGET_H8300S && amount == <NUM_LIT> ) || ( mode == SImode && TARGET_H8300H && amount >= <NUM_LIT> ) || ( mode == SImode && TARGET_H8300S && amount >= <NUM_LIT> ) ) { amount = GET_MODE_BITSIZE ( mode ) / <NUM_LIT> - amount ;


<s> enum rtx_code code = GET_CODE ( shift ) ; enum shift_type shift_type ; enum shift_mode shift_mode ; struct shift_info info ; int n ; switch ( mode ) { case QImode : shift_mode = QIshift ; break ; case HImode : shift_mode = HIshift ; break ; case SImode : shift_mode = SIshift ; break ; default : gcc_unreachable ( ) ; } switch ( code ) { case ASHIFTRT : shift_type = SHIFT_ASHIFTRT ; break ; case LSHIFTRT :


<s> gcc_unreachable ( ) ; } if ( GET_CODE ( operands [ <NUM_LIT> ] ) != CONST_INT ) { get_shift_alg ( shift_type , shift_mode , <NUM_LIT> , & info ) ; return ( <NUM_LIT> + h8300_asm_insn_count ( info . shift1 ) ) * <NUM_LIT> ; } else { int n = INTVAL ( operands [ <NUM_LIT> ] ) ; if ( n < <NUM_LIT> ) n = <NUM_LIT> ; else if ( ( unsigned int ) n > GET_MODE_BITSIZE ( mode ) ) n = GET_MODE_BITSIZE ( mode ) ; get_shift_alg ( shift_type , shift_mode , n , & info ) ; switch ( info . alg ) { case SHIFT_SPECIAL : wlength += h8300_asm_insn_count ( info . special ) ; if ( strstr ( info . special , <STR_LIT> ) != NULL ) wlength ++ ; case SHIFT_INLINE : n = info . remainder ; if ( info . shift2 != NULL ) { wlength += h8300_asm_insn_count ( info . shift2 ) * ( n / <NUM_LIT> ) ; n = n % <NUM_LIT> ; } wlength += h8300_asm_insn_count ( info . shift1 ) * n ; return <NUM_LIT> * wlength ; case SHIFT_ROT_AND : { int m = GET_MODE_BITSIZE ( mode ) - n ; gcc_assert ( info . shift1 ) ; if ( info . shift2 != NULL ) { wlength += h8300_asm_insn_count ( info . shift2 ) * ( m / <NUM_LIT> ) ; m = m % <NUM_LIT> ; } wlength += h8300_asm_insn_count ( info . shift1 ) * m ; switch ( mode ) { case QImode : wlength += <NUM_LIT> ; break ;


<s> } else { if ( w0 == <NUM_LIT> && ( TARGET_H8300 ? ( code == AND ) : ( code != IOR ) ) ) { length += <NUM_LIT> ; } else if ( ( TARGET_H8300H || TARGET_H8300S ) && ( b0 != <NUM_LIT> ) && ( b1 != <NUM_LIT> ) ) { length += <NUM_LIT> ; } else { if ( b0 != <NUM_LIT> ) length += <NUM_LIT> ; if ( b1 != <NUM_LIT> ) length += <NUM_LIT> ; } if ( w1 == <NUM_LIT> && ( TARGET_H8300 ? ( code == AND ) : ( code != IOR ) ) ) { length += <NUM_LIT> ; } else if ( ( TARGET_H8300H || TARGET_H8300S ) && code == IOR && w1 == <NUM_LIT> && ( w0 & <NUM_LIT> ) != <NUM_LIT> ) { length += <NUM_LIT> ; } else if ( ( TARGET_H8300H || TARGET_H8300S ) && code == AND && w1 == <NUM_LIT> ) { length += <NUM_LIT> ; } else if ( TARGET_H8300H || TARGET_H8300S ) { if ( w1 != <NUM_LIT> ) length += <NUM_LIT> ; } else { if ( b2 != <NUM_LIT> ) length += <NUM_LIT> ; if ( b3 != <NUM_LIT> ) length += <NUM_LIT> ; } } break ;


<s> if ( val == ( val & <NUM_LIT> ) || val == ( val & <NUM_LIT> ) ) return <NUM_LIT> ; switch ( val & <NUM_LIT> ) { case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : return <NUM_LIT> ; } } return <NUM_LIT> ; } base_length = <NUM_LIT> ; break ; case SFmode : if ( addr == NULL_RTX ) { if ( REG_P ( src ) ) return <NUM_LIT> ; if ( CONST_DOUBLE_OK_FOR_LETTER_P ( src , 'G' ) ) return <NUM_LIT> ; return <NUM_LIT> ; } base_length = <NUM_LIT> ; break ; default : gcc_unreachable ( ) ; } if ( GET_CODE ( addr ) == PRE_DEC || GET_CODE ( addr ) == POST_INC ) return base_length - <NUM_LIT> ; if ( GET_CODE ( addr ) == REG ) return base_length - <NUM_LIT> ; if ( GET_CODE ( addr ) == PLUS && GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == REG && GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == CONST_INT && INTVAL ( XEXP ( addr , <NUM_LIT> ) ) > - <NUM_LIT> && INTVAL ( XEXP ( addr , <NUM_LIT> ) ) < <NUM_LIT> ) return base_length - <NUM_LIT> ; if ( h8300_tiny_constant_address_p ( addr ) ) return base_length - <NUM_LIT> ; if ( CONSTANT_P ( addr ) ) return base_length - <NUM_LIT> ; return base_length ;


<s> if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT ) { HOST_WIDE_INT n = INTVAL ( operands [ <NUM_LIT> ] ) ; if ( ( n & <NUM_LIT> ) == <NUM_LIT> ) return <NUM_LIT> ; if ( ( n & <NUM_LIT> ) == <NUM_LIT> ) return <NUM_LIT> ; if ( ( n & <NUM_LIT> ) == <NUM_LIT> ) return <NUM_LIT> ; } return <NUM_LIT> ; } else { if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT && register_operand ( operands [ <NUM_LIT> ] , VOIDmode ) ) { HOST_WIDE_INT intval = INTVAL ( operands [ <NUM_LIT> ] ) ; if ( TARGET_H8300SX && ( intval >= <NUM_LIT> && intval <= <NUM_LIT> ) ) return <NUM_LIT> ; if ( TARGET_H8300SX && ( intval >= - <NUM_LIT> && intval <= - <NUM_LIT> ) ) return <NUM_LIT> ; switch ( ( unsigned int ) intval & <NUM_LIT> ) { case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : return <NUM_LIT> ; case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : return <NUM_LIT> ; case <NUM_LIT> : case <NUM_LIT> : return <NUM_LIT> ; case <NUM_LIT> : case <NUM_LIT> : return <NUM_LIT> ; }

if ( ( intval & <NUM_LIT> ) == <NUM_LIT> ) return <NUM_LIT> ;


<s> emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; emit_insn ( gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , gen_rtx_SET ( VOIDmode , operands [ <NUM_LIT> ] , gen_rtx_fmt_ee ( code , mode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) , gen_rtx_CLOBBER ( VOIDmode , gen_rtx_SCRATCH ( QImode ) ) ) ) ) ; return true ;


<s> emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ;

emit_insn ( gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , gen_rtx_SET ( VOIDmode , operands [ <NUM_LIT> ] , gen_rtx_fmt_ee ( code , mode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) , gen_rtx_CLOBBER ( VOIDmode , gen_rtx_SCRATCH ( QImode ) ) ) ) ) ;


<s> const int uid = INSN_UID ( insn ) ; if ( TARGET_ADDRESSES ) { fprintf ( asm_out_file , <STR_LIT> , INSN_ADDRESSES ( uid ) , INSN_ADDRESSES ( uid ) - last_insn_address ) ; last_insn_address = INSN_ADDRESSES ( uid ) ;


<s> if ( TARGET_ADDRESSES ) { fprintf ( asm_out_file , <STR_LIT> , INSN_ADDRESSES ( uid ) , INSN_ADDRESSES ( uid ) - last_insn_address ) ;

last_insn_address = INSN_ADDRESSES ( uid ) ;


<s> rtx mem = gen_rtx_MEM ( GET_MODE ( operands [ <NUM_LIT> ] ) , copy_to_mode_reg ( Pmode , XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) ) ; MEM_COPY_ATTRIBUTES ( mem , operands [ <NUM_LIT> ] ) ; operands [ <NUM_LIT> ] = mem ; } return <NUM_LIT> ; } operands [ <NUM_LIT> ] = force_reg ( QImode , operands [ <NUM_LIT> ] ) ; { rtx res = gen_reg_rtx ( QImode ) ; switch ( code ) { case AND : emit_insn ( gen_andqi3_1 ( res , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; break ; case IOR : emit_insn ( gen_iorqi3_1 ( res , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ;


<s> <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <NUM_LIT> , } ; rtx result = NULL_RTX ; const char * fname ; int regpass = <NUM_LIT> ; if ( ! named ) return NULL_RTX ; if ( TARGET_QUICKCALL ) regpass = <NUM_LIT> ; if ( cum -> libcall ) { const char * const * p ;

fname = XSTR ( cum -> libcall , <NUM_LIT> ) ;


<s> const char * fname ; int regpass = <NUM_LIT> ; if ( ! named ) return NULL_RTX ; if ( TARGET_QUICKCALL ) regpass = <NUM_LIT> ; if ( cum -> libcall ) { const char * const * p ; fname = XSTR ( cum -> libcall , <NUM_LIT> ) ; for ( p = hand_list ; * p && strcmp ( * p , fname ) != <NUM_LIT> ; p ++ ) ;


<s> for ( ; * template ; template ++ ) if ( * template == '\n' ) count ++ ;


<s> unsigned int count = <NUM_LIT> ; for ( ; * template ; template ++ ) if ( * template == '\n' ) count ++ ; return count ;


<s> else if ( GET_CODE ( op ) == PLUS && CONSTANT_P ( XEXP ( op , <NUM_LIT> ) ) ) { * class = H8OP_MEM_COMPLEX ; return h8300_displacement_length ( op , size ) ; } else if ( GET_RTX_CLASS ( GET_CODE ( op ) ) == RTX_AUTOINC ) { * class = H8OP_MEM_COMPLEX ; return <NUM_LIT> ; } else if ( register_operand ( op , VOIDmode ) ) { * class = H8OP_MEM_BASE ; return <NUM_LIT> ;


<s> if ( CONSTANT_P ( op ) ) { * class = H8OP_MEM_ABSOLUTE ; return h8300_constant_length ( op ) ; } else if ( GET_CODE ( op ) == PLUS && CONSTANT_P ( XEXP ( op , <NUM_LIT> ) ) ) { * class = H8OP_MEM_COMPLEX ; return h8300_displacement_length ( op , size ) ; } else if ( GET_RTX_CLASS ( GET_CODE ( op ) ) == RTX_AUTOINC ) { * class = H8OP_MEM_COMPLEX ; return <NUM_LIT> ; } else if ( register_operand ( op , VOIDmode ) ) {


<s> return ( h8300_interrupt_function_p ( current_function_decl ) || h8300_monitor_function_p ( current_function_decl ) ) ;


<s> if ( GET_CODE ( x ) == SYMBOL_REF ) return ( SYMBOL_REF_FLAGS ( x ) & SYMBOL_FLAG_EIGHTBIT_DATA ) != <NUM_LIT> ; if ( GET_CODE ( x ) != CONST_INT ) return <NUM_LIT> ; addr = INTVAL ( x ) ; return ( <NUM_LIT> || ( ( TARGET_H8300 || TARGET_NORMAL_MODE ) && IN_RANGE ( addr , n1 , n2 ) ) || ( TARGET_H8300H && IN_RANGE ( addr , h1 , h2 ) ) || ( TARGET_H8300S && IN_RANGE ( addr , s1 , s2 ) ) ) ;


<s> const unsigned HOST_WIDE_INT h2 = trunc_int_for_mode ( <NUM_LIT> , SImode ) ; const unsigned HOST_WIDE_INT s1 = trunc_int_for_mode ( <NUM_LIT> , SImode ) ; const unsigned HOST_WIDE_INT s2 = trunc_int_for_mode ( <NUM_LIT> , SImode ) ; unsigned HOST_WIDE_INT addr ;

if ( GET_CODE ( x ) == SYMBOL_REF ) return ( SYMBOL_REF_FLAGS ( x ) & SYMBOL_FLAG_EIGHTBIT_DATA ) != <NUM_LIT> ;


<s> void h8300_expand_branch ( enum rtx_code code , rtx label ) { rtx tmp ; tmp = gen_rtx_fmt_ee ( code , VOIDmode , cc0_rtx , const0_rtx ) ; tmp = gen_rtx_IF_THEN_ELSE ( VOIDmode , tmp , gen_rtx_LABEL_REF ( VOIDmode , label ) , pc_rtx ) ; emit_jump_insn ( gen_rtx_SET ( VOIDmode , pc_rtx , tmp ) ) ;


<s> frame_size = round_frame_size ( get_frame_size ( ) ) ; returned_p = false ; h8300_emit_stack_adjustment ( <NUM_LIT> , frame_size ) ; saved_regs = compute_saved_regs ( ) ; for ( regno = FIRST_PSEUDO_REGISTER - <NUM_LIT> ; regno >= <NUM_LIT> ; regno -= n_regs ) { n_regs = <NUM_LIT> ; if ( saved_regs & ( <NUM_LIT> << regno ) ) { if ( TARGET_H8300S ) { if ( ( TARGET_H8300SX || ( regno & <NUM_LIT> ) == <NUM_LIT> ) && ( ( saved_regs << <NUM_LIT> >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) n_regs = <NUM_LIT> ; else if ( ( TARGET_H8300SX || ( regno & <NUM_LIT> ) == <NUM_LIT> ) && ( ( saved_regs << <NUM_LIT> >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) n_regs = <NUM_LIT> ; else if ( ( TARGET_H8300SX || ( regno & <NUM_LIT> ) == <NUM_LIT> ) && ( ( saved_regs << <NUM_LIT> >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) n_regs = <NUM_LIT> ; } if ( TARGET_H8300SX && ! frame_pointer_needed && frame_size == <NUM_LIT> && ( saved_regs & ( ( <NUM_LIT> << ( regno - n_regs + <NUM_LIT> ) ) - <NUM_LIT> ) ) == <NUM_LIT> ) returned_p = true ; h8300_push_pop ( regno - n_regs + <NUM_LIT> , n_regs , <NUM_LIT> , returned_p ) ; }


<s> int n_regs ; if ( h8300_os_task_function_p ( current_function_decl ) ) return ; if ( h8300_monitor_function_p ( current_function_decl ) ) emit_insn ( gen_monitor_prologue ( ) ) ; if ( frame_pointer_needed ) { push ( HARD_FRAME_POINTER_REGNUM ) ; emit_move_insn ( hard_frame_pointer_rtx , stack_pointer_rtx ) ; } saved_regs = compute_saved_regs ( ) ; for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno += n_regs ) { n_regs = <NUM_LIT> ; if ( saved_regs & ( <NUM_LIT> << regno ) ) { if ( TARGET_H8300S ) { if ( ( ! TARGET_H8300SX || ( regno & <NUM_LIT> ) == <NUM_LIT> ) && ( ( saved_regs >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) n_regs = <NUM_LIT> ; else if ( ( ! TARGET_H8300SX || ( regno & <NUM_LIT> ) == <NUM_LIT> ) && ( ( saved_regs >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) n_regs = <NUM_LIT> ; else if ( ( ! TARGET_H8300SX || ( regno & <NUM_LIT> ) == <NUM_LIT> ) && ( ( saved_regs >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) n_regs = <NUM_LIT> ; } h8300_push_pop ( regno , n_regs , <NUM_LIT> , <NUM_LIT> ) ; } }

h8300_emit_stack_adjustment ( - <NUM_LIT> , round_frame_size ( get_frame_size ( ) ) ) ;


<s> if ( TARGET_H8300H ) fputs ( TARGET_NORMAL_MODE ? <STR_LIT> : <STR_LIT> , asm_out_file ) ;

else if ( TARGET_H8300SX ) fputs ( TARGET_NORMAL_MODE ? <STR_LIT> : <STR_LIT> , asm_out_file ) ;


<s> static void h8300_file_start ( void ) { default_file_start ( ) ; if ( TARGET_H8300H ) fputs ( TARGET_NORMAL_MODE ? <STR_LIT> : <STR_LIT> , asm_out_file ) ; else if ( TARGET_H8300SX ) fputs ( TARGET_NORMAL_MODE ? <STR_LIT> : <STR_LIT> , asm_out_file ) ; else if ( TARGET_H8300S ) fputs ( TARGET_NORMAL_MODE ? <STR_LIT> : <STR_LIT> , asm_out_file ) ;


<s> if ( GET_CODE ( x ) == AND && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT && ( factor == <NUM_LIT> || INTVAL ( XEXP ( x , <NUM_LIT> ) ) == <NUM_LIT> * factor || INTVAL ( XEXP ( x , <NUM_LIT> ) ) == <NUM_LIT> * factor ) ) { index = XEXP ( x , <NUM_LIT> ) ; * size = ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) >= <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ) ; } else { index = x ;


<s> if ( TREE_CODE ( * node ) != FUNCTION_DECL ) { warning ( OPT_Wattributes , <STR_LIT> , IDENTIFIER_POINTER ( name ) ) ; * no_add_attrs = true ; } return NULL_TREE ;


<s> if ( TREE_STATIC ( decl ) || DECL_EXTERNAL ( decl ) ) { DECL_SECTION_NAME ( decl ) = build_string ( <NUM_LIT> , <STR_LIT> ) ; } else { warning ( OPT_Wattributes , <STR_LIT> , IDENTIFIER_POINTER ( name ) ) ; * no_add_attrs = true ;


<s> if ( TARGET_H8300 ) return ( ( regno & <NUM_LIT> ) == <NUM_LIT> ) || ( mode == HImode ) || ( mode == QImode ) ; else return regno == MAC_REG ? mode == SImode : <NUM_LIT> ;


<s> return ( GET_MODE_SIZE ( mode ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ;


<s> if ( GET_CODE ( x ) == PLUS && CONSTANT_ADDRESS_P ( XEXP ( x , <NUM_LIT> ) ) && h8300_rtx_ok_for_base_p ( h8300_get_index ( XEXP ( x , <NUM_LIT> ) , mode , <NUM_LIT> ) , strict ) ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> int h8300_legitimate_constant_p ( rtx x ATTRIBUTE_UNUSED ) { return <NUM_LIT> ;


<s> if ( pop_p ) pop ( regno ) ; else push ( regno ) ; return ; } vec = rtvec_alloc ( ( return_p != <NUM_LIT> ) + nregs + <NUM_LIT> ) ; sp = stack_pointer_rtx ; i = <NUM_LIT> ; if ( return_p ) { RTVEC_ELT ( vec , i ) = gen_rtx_RETURN ( VOIDmode ) ; i ++ ; } for ( j = <NUM_LIT> ; j < nregs ; j ++ ) { rtx lhs , rhs ; if ( pop_p ) { lhs = gen_rtx_REG ( SImode , regno + j ) ; rhs = gen_rtx_MEM ( SImode , plus_constant ( sp , ( nregs - j - <NUM_LIT> ) * <NUM_LIT> ) ) ; } else { lhs = gen_rtx_MEM ( SImode , plus_constant ( sp , ( j + <NUM_LIT> ) * - <NUM_LIT> ) ) ;

rhs = gen_rtx_REG ( SImode , regno + j ) ;


<s> case 'c' : return COUNTER_REGS ; case 'd' : if ( ! flag_omit_frame_pointer && ! reload_completed ) return NO_REGS ; if ( frame_pointer_needed && reload_in_progress ) return NO_REGS ;


<s> rtx ret ; if ( count == <NUM_LIT> ) ret = gen_rtx_MEM ( Pmode , gen_rtx_REG ( Pmode , RETURN_ADDRESS_POINTER_REGNUM ) ) ; else if ( flag_omit_frame_pointer ) return ( rtx ) <NUM_LIT> ;

else ret = gen_rtx_MEM ( Pmode , memory_address ( Pmode , plus_constant ( frame , UNITS_PER_WORD ) ) ) ;


<s> return ( TYPE_MODE ( type ) == BLKmode || GET_MODE_SIZE ( TYPE_MODE ( type ) ) > ( TARGET_H8300 ? <NUM_LIT> : <NUM_LIT> ) ) ;


<s> switch ( ( int ) n ) { case <NUM_LIT> : * total = <NUM_LIT> ; return true ; case <NUM_LIT> : case <NUM_LIT> : case - <NUM_LIT> : case - <NUM_LIT> : * total = <NUM_LIT> + ( outer_code == SET ) ; return true ; case <NUM_LIT> : case - <NUM_LIT> : if ( TARGET_H8300H || TARGET_H8300S ) * total = <NUM_LIT> + ( outer_code == SET ) ; else * total = <NUM_LIT> ; return true ; } } * total = <NUM_LIT> ; return true ; } case CONST : case LABEL_REF : case SYMBOL_REF : if ( TARGET_H8300SX ) { * total = <NUM_LIT> ; return true ; } * total = <NUM_LIT> ; return true ; case CONST_DOUBLE : * total = <NUM_LIT> ; return true ; case AND : if ( ! h8300_dst_operand ( XEXP ( x , <NUM_LIT> ) , VOIDmode ) || ! h8300_src_operand ( XEXP ( x , <NUM_LIT> ) , VOIDmode ) ) return false ; * total = COSTS_N_INSNS ( h8300_and_costs ( x ) ) ; return true ; case MOD : case DIV : case UMOD : case UDIV : if ( TARGET_H8300SX ) switch ( GET_MODE ( x ) ) { case QImode : case HImode : * total = COSTS_N_INSNS ( optimize_size ? <NUM_LIT> : <NUM_LIT> ) ; return false ; case SImode : * total = COSTS_N_INSNS ( optimize_size ? <NUM_LIT> : <NUM_LIT> ) ; return false ; default : break ; } * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case MULT : if ( TARGET_H8300SX ) switch ( GET_MODE ( x ) ) { case QImode : case HImode : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return false ; case SImode : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return false ; default : break ; } * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case ASHIFT : case ASHIFTRT : case LSHIFTRT : if ( h8sx_binary_shift_operator ( x , VOIDmode ) ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return false ; } else if ( h8sx_unary_shift_operator ( x , VOIDmode ) ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return false ; } * total = COSTS_N_INSNS ( h8300_shift_costs ( x ) ) ; return true ; case ROTATE :


<s> case - <NUM_LIT> : if ( TARGET_H8300H || TARGET_H8300S ) * total = <NUM_LIT> + ( outer_code == SET ) ; else * total = <NUM_LIT> ; return true ; } } * total = <NUM_LIT> ; return true ; } case CONST : case LABEL_REF : case SYMBOL_REF : if ( TARGET_H8300SX ) { * total = <NUM_LIT> ; return true ; } * total = <NUM_LIT> ; return true ; case CONST_DOUBLE : * total = <NUM_LIT> ; return true ; case AND : if ( ! h8300_dst_operand ( XEXP ( x , <NUM_LIT> ) , VOIDmode ) || ! h8300_src_operand ( XEXP ( x , <NUM_LIT> ) , VOIDmode ) ) return false ; * total = COSTS_N_INSNS ( h8300_and_costs ( x ) ) ; return true ; case MOD : case DIV : case UMOD : case UDIV : if ( TARGET_H8300SX ) switch ( GET_MODE ( x ) ) { case QImode : case HImode : * total = COSTS_N_INSNS ( optimize_size ? <NUM_LIT> : <NUM_LIT> ) ; return false ; case SImode : * total = COSTS_N_INSNS ( optimize_size ? <NUM_LIT> : <NUM_LIT> ) ; return false ; default : break ; } * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case MULT : if ( TARGET_H8300SX ) switch ( GET_MODE ( x ) ) { case QImode : case HImode : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return false ; case SImode : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return false ; default : break ; } * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case ASHIFT : case ASHIFTRT : case LSHIFTRT : if ( h8sx_binary_shift_operator ( x , VOIDmode ) ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return false ; } else if ( h8sx_unary_shift_operator ( x , VOIDmode ) ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return false ; } * total = COSTS_N_INSNS ( h8300_shift_costs ( x ) ) ; return true ; case ROTATE : case ROTATERT : if ( GET_MODE ( x ) == HImode ) * total = <NUM_LIT> ; else * total = <NUM_LIT> ; return true ;


<s> case HImode : a = shift_alg_hi [ cpu ] [ SHIFT_ASHIFT ] [ count ] ; lr = shift_alg_hi [ cpu ] [ SHIFT_LSHIFTRT ] [ count ] ; ar = shift_alg_hi [ cpu ] [ SHIFT_ASHIFTRT ] [ count ] ; break ; case SImode : a = shift_alg_si [ cpu ] [ SHIFT_ASHIFT ] [ count ] ; lr = shift_alg_si [ cpu ] [ SHIFT_LSHIFTRT ] [ count ] ; ar = shift_alg_si [ cpu ] [ SHIFT_ASHIFTRT ] [ count ] ; break ;


<s> push ( HARD_FRAME_POINTER_REGNUM ) ; emit_move_insn ( hard_frame_pointer_rtx , addr ) ; if ( REGNO ( addr ) == SP_REG ) emit_move_insn ( hard_frame_pointer_rtx , plus_constant ( hard_frame_pointer_rtx , GET_MODE_SIZE ( word_mode ) ) ) ;


<s> push ( HARD_FRAME_POINTER_REGNUM ) ; emit_move_insn ( hard_frame_pointer_rtx , addr ) ;

if ( REGNO ( addr ) == SP_REG ) emit_move_insn ( hard_frame_pointer_rtx , plus_constant ( hard_frame_pointer_rtx , GET_MODE_SIZE ( word_mode ) ) ) ;


<s> void h8300_swap_out_of_er6 ( rtx addr ) { if ( REGNO ( addr ) != SP_REG ) emit_move_insn ( addr , hard_frame_pointer_rtx ) ;


<s> case H8OP_REGISTER : return <NUM_LIT> ; case H8OP_MEM_BASE : return ( size == <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ) ; case H8OP_MEM_ABSOLUTE : return operand_length + ( size == <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ) ; case H8OP_MEM_COMPLEX : return operand_length + <NUM_LIT> ; default : gcc_unreachable ( ) ; } } static unsigned int h8300_short_immediate_length ( rtx op ) { enum h8300_operand_class class ; unsigned int size , operand_length ;

size = GET_MODE_SIZE ( GET_MODE ( op ) ) ;


<s> return operand_length + <NUM_LIT> ; default : gcc_unreachable ( ) ; } } static unsigned int h8300_short_immediate_length ( rtx op ) { enum h8300_operand_class class ; unsigned int size , operand_length ; size = GET_MODE_SIZE ( GET_MODE ( op ) ) ; operand_length = h8300_classify_operand ( op , size , & class ) ;


<s> if ( GET_CODE ( op ) == CONST_INT && ( INTVAL ( op ) == <NUM_LIT> || INTVAL ( op ) == <NUM_LIT> || INTVAL ( op ) == GET_MODE_BITSIZE ( mode ) - <NUM_LIT> || INTVAL ( op ) == GET_MODE_BITSIZE ( mode ) - <NUM_LIT> ) ) return H8SX_SHIFT_UNARY ; return H8SX_SHIFT_NONE ; default :


<s> emit_insn ( gen_movmd ( first_dest , first_src , length , GEN_INT ( factor ) ) ) ; if ( ( n & - factor ) != n ) { dest = adjust_address ( dest , BLKmode , n & - factor ) ; src = adjust_address ( src , BLKmode , n & - factor ) ; dest = replace_equiv_address ( dest , dest_reg ) ; src = replace_equiv_address ( src , src_reg ) ; if ( n & <NUM_LIT> ) emit_move_insn ( adjust_address ( dest , HImode , <NUM_LIT> ) , adjust_address ( src , HImode , <NUM_LIT> ) ) ; if ( n & <NUM_LIT> ) emit_move_insn ( adjust_address ( dest , QImode , n & <NUM_LIT> ) , adjust_address ( src , QImode , n & <NUM_LIT> ) ) ; } return true ; }


<s> first_dest = replace_equiv_address ( dest , dest_reg ) ; first_src = replace_equiv_address ( src , src_reg ) ; set_mem_size ( first_dest , GEN_INT ( n & - factor ) ) ; set_mem_size ( first_src , GEN_INT ( n & - factor ) ) ; length = copy_to_mode_reg ( HImode , gen_int_mode ( n / factor , HImode ) ) ; emit_insn ( gen_movmd ( first_dest , first_src , length , GEN_INT ( factor ) ) ) ; if ( ( n & - factor ) != n ) { dest = adjust_address ( dest , BLKmode , n & - factor ) ; src = adjust_address ( src , BLKmode , n & - factor ) ; dest = replace_equiv_address ( dest , dest_reg ) ; src = replace_equiv_address ( src , src_reg ) ; if ( n & <NUM_LIT> ) emit_move_insn ( adjust_address ( dest , HImode , <NUM_LIT> ) , adjust_address ( src , HImode , <NUM_LIT> ) ) ; if ( n & <NUM_LIT> ) emit_move_insn ( adjust_address ( dest , QImode , n & <NUM_LIT> ) , adjust_address ( src , QImode , n & <NUM_LIT> ) ) ; } return true ; } return false ;


<s> set = single_set ( insn ) ; cc_status . value1 = SET_SRC ( set ) ; if ( SET_DEST ( set ) != cc0_rtx ) { if ( GET_CODE ( SET_DEST ( set ) ) == STRICT_LOW_PART ) cc_status . value2 = XEXP ( SET_DEST ( set ) , <NUM_LIT> ) ; else cc_status . value2 = SET_DEST ( set ) ; } break ; case CC_COMPARE : CC_STATUS_INIT ; cc_status . value1 = SET_SRC ( body ) ; break ; case CC_CLOBBER : CC_STATUS_INIT ; break ; }


<s> rotate_mode = QIshift ; break ; case HImode : rotate_mode = HIshift ; break ; case SImode : rotate_mode = SIshift ; break ; default : gcc_unreachable ( ) ; } switch ( code ) { case ROTATERT : rotate_type = SHIFT_ASHIFT ; break ; case ROTATE : rotate_type = SHIFT_LSHIFTRT ; break ; default : gcc_unreachable ( ) ; } amount = INTVAL ( rotate_amount ) ; if ( amount < <NUM_LIT> ) amount = <NUM_LIT> ; if ( ( unsigned int ) amount > GET_MODE_BITSIZE ( mode ) ) amount = GET_MODE_BITSIZE ( mode ) ; if ( ( unsigned int ) amount > GET_MODE_BITSIZE ( mode ) / ( unsigned ) <NUM_LIT> ) { amount = GET_MODE_BITSIZE ( mode ) - amount ; rotate_type = ( rotate_type == SHIFT_ASHIFT ) ? SHIFT_LSHIFTRT : SHIFT_ASHIFT ; } if ( ( mode == HImode && TARGET_H8300 && amount >= <NUM_LIT> ) || ( mode == HImode && TARGET_H8300H && amount >= <NUM_LIT> ) || ( mode == HImode && TARGET_H8300S && amount == <NUM_LIT> ) || ( mode == SImode && TARGET_H8300H && amount >= <NUM_LIT> ) || ( mode == SImode && TARGET_H8300S && amount >= <NUM_LIT> ) ) { switch ( mode ) { case HImode : insn_buf = <STR_LIT> ; output_asm_insn ( insn_buf , operands ) ; break ; case SImode : insn_buf = <STR_LIT> ; output_asm_insn ( insn_buf , operands ) ; break ; default : gcc_unreachable ( ) ; }

amount = GET_MODE_BITSIZE ( mode ) / <NUM_LIT> - amount ;


<s> case LSHIFTRT : shift_type = SHIFT_LSHIFTRT ; break ; case ASHIFT : shift_type = SHIFT_ASHIFT ; break ; default : gcc_unreachable ( ) ; } gcc_assert ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT ) ; n = INTVAL ( operands [ <NUM_LIT> ] ) ; if ( n < <NUM_LIT> ) n = <NUM_LIT> ; else if ( ( unsigned int ) n > GET_MODE_BITSIZE ( mode ) ) n = GET_MODE_BITSIZE ( mode ) ; get_shift_alg ( shift_type , shift_mode , n , & info ) ; switch ( info . alg ) { case SHIFT_SPECIAL : output_asm_insn ( info . special , operands ) ; case SHIFT_INLINE : n = info . remainder ; if ( info . shift2 != NULL ) { for ( ; n > <NUM_LIT> ; n -= <NUM_LIT> ) output_asm_insn ( info . shift2 , operands ) ; } for ( ; n > <NUM_LIT> ; n -- ) output_asm_insn ( info . shift1 , operands ) ; return <STR_LIT> ; case SHIFT_ROT_AND : { int m = GET_MODE_BITSIZE ( mode ) - n ;

const int mask = ( shift_type == SHIFT_ASHIFT ? ( ( <NUM_LIT> << m ) - <NUM_LIT> ) << n : ( <NUM_LIT> << m ) - <NUM_LIT> ) ;


<s> if ( b1 != <NUM_LIT> ) { sprintf ( insn_buf , <STR_LIT> , opname ) ; output_asm_insn ( insn_buf , operands ) ; } } break ; case SImode : if ( TARGET_H8300H || TARGET_H8300S ) { lower_half_easy_p = ( b0 == <NUM_LIT> || b1 == <NUM_LIT> || ( code != IOR && w0 == <NUM_LIT> ) ) ; upper_half_easy_p = ( ( code != IOR && w1 == <NUM_LIT> ) || ( code == AND && w1 == <NUM_LIT> ) ) ; } if ( ( TARGET_H8300H || TARGET_H8300S ) && w0 != <NUM_LIT> && w1 != <NUM_LIT> && ! ( lower_half_easy_p && upper_half_easy_p ) && ! ( code == IOR && w1 == <NUM_LIT> && ( w0 & <NUM_LIT> ) != <NUM_LIT> && lower_half_easy_p ) ) { sprintf ( insn_buf , <STR_LIT> , opname ) ; output_asm_insn ( insn_buf , operands ) ; } else { if ( w0 == <NUM_LIT> && ( TARGET_H8300 ? ( code == AND ) : ( code != IOR ) ) ) output_asm_insn ( ( code == AND ) ? <STR_LIT> : <STR_LIT> , operands ) ; else if ( ( TARGET_H8300H || TARGET_H8300S ) && ( b0 != <NUM_LIT> ) && ( b1 != <NUM_LIT> ) ) { sprintf ( insn_buf , <STR_LIT> , opname ) ; output_asm_insn ( insn_buf , operands ) ; } else { if ( b0 != <NUM_LIT> ) { sprintf ( insn_buf , <STR_LIT> , opname ) ;


<s> else { if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT && register_operand ( operands [ <NUM_LIT> ] , VOIDmode ) ) { HOST_WIDE_INT intval = INTVAL ( operands [ <NUM_LIT> ] ) ; if ( TARGET_H8300SX && ( intval >= <NUM_LIT> && intval <= <NUM_LIT> ) ) return <STR_LIT> ; if ( TARGET_H8300SX && ( intval >= - <NUM_LIT> && intval <= - <NUM_LIT> ) ) return <STR_LIT> ; switch ( ( unsigned int ) intval & <NUM_LIT> ) { case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : return <STR_LIT> ; case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : return <STR_LIT> ; case <NUM_LIT> : case <NUM_LIT> : operands [ <NUM_LIT> ] = GEN_INT ( intval >> <NUM_LIT> ) ; return <STR_LIT> ; case <NUM_LIT> : case <NUM_LIT> :


<s> else x = gen_pop_h8300hs_normal ( reg ) ; x = emit_insn ( x ) ;


<s> break ; case <NUM_LIT> : print_operand ( file , index , 'T' ) ; fputs ( <STR_LIT> , file ) ; break ; case <NUM_LIT> : print_operand ( file , index , 'S' ) ; fputs ( <STR_LIT> , file ) ; break ; } } else { print_operand_address ( file , XEXP ( addr , <NUM_LIT> ) ) ; fprintf ( file , <STR_LIT> ) ; print_operand_address ( file , XEXP ( addr , <NUM_LIT> ) ) ; } fprintf ( file , <STR_LIT> ) ; break ; case CONST_INT : { int n = INTVAL ( addr ) ; if ( TARGET_H8300 ) n = ( int ) ( short ) n ; fprintf ( file , <STR_LIT> , n ) ; break ; }


<s> rtx index ; int size ; switch ( GET_CODE ( addr ) ) { case REG : fprintf ( file , <STR_LIT> , h8_reg_names [ REGNO ( addr ) ] ) ; break ; case PRE_DEC : fprintf ( file , <STR_LIT> , h8_reg_names [ REGNO ( XEXP ( addr , <NUM_LIT> ) ) ] ) ; break ; case POST_INC : fprintf ( file , <STR_LIT> , h8_reg_names [ REGNO ( XEXP ( addr , <NUM_LIT> ) ) ] ) ; break ; case PRE_INC : fprintf ( file , <STR_LIT> , h8_reg_names [ REGNO ( XEXP ( addr , <NUM_LIT> ) ) ] ) ; break ; case POST_DEC : fprintf ( file , <STR_LIT> , h8_reg_names [ REGNO ( XEXP ( addr , <NUM_LIT> ) ) ] ) ; break ; case PLUS : fprintf ( file , <STR_LIT> ) ; index = h8300_get_index ( XEXP ( addr , <NUM_LIT> ) , VOIDmode , & size ) ; if ( GET_CODE ( index ) == REG ) { print_operand_address ( file , XEXP ( addr , <NUM_LIT> ) ) ; fprintf ( file , <STR_LIT> ) ; switch ( size ) { case <NUM_LIT> : print_operand_address ( file , index ) ; break ; case <NUM_LIT> : print_operand ( file , index , 'X' ) ; fputs ( <STR_LIT> , file ) ; break ; case <NUM_LIT> : print_operand ( file , index , 'T' ) ; fputs ( <STR_LIT> , file ) ; break ; case <NUM_LIT> : print_operand ( file , index , 'S' ) ; fputs ( <STR_LIT> , file ) ; break ; } } else { print_operand_address ( file , XEXP ( addr , <NUM_LIT> ) ) ; fprintf ( file , <STR_LIT> ) ;


<s> else if ( ! TARGET_NORMAL_MODE ) x = gen_push_h8300hs_advanced ( reg ) ; else x = gen_push_h8300hs_normal ( reg ) ; x = emit_insn ( x ) ; REG_NOTES ( x ) = gen_rtx_EXPR_LIST ( REG_INC , stack_pointer_rtx , <NUM_LIT> ) ;


<s> static int round_frame_size ( int size ) {

return ( ( size + STACK_BOUNDARY / BITS_PER_UNIT - <NUM_LIT> ) & - STACK_BOUNDARY / BITS_PER_UNIT ) ;


if ( i3 == NULL_RTX ) return <NUM_LIT> ;


return ( INSN_P ( i1 ) && rtx_equal_p ( PATTERN ( i1 ) , PATTERN ( i3 ) ) && any_condjump_p ( i2 ) && onlyjump_p ( i2 ) ) ;


if ( i1 == NULL_RTX ) return <NUM_LIT> ;


<s> rtx reg = operands [ <NUM_LIT> ] ; HOST_WIDE_INT sign = <NUM_LIT> ; HOST_WIDE_INT amount ; rtx ( * gen_add ) ( rtx , rtx , rtx ) ; if ( val < <NUM_LIT> ) { val = - val ; sign = - <NUM_LIT> ; } switch ( mode ) { case HImode : gen_add = gen_addhi3 ; break ; case SImode : gen_add = gen_addsi3 ; break ; default :


<s> enum shift_mode shift_mode ; struct shift_info info ; int n ; switch ( mode ) { case QImode : shift_mode = QIshift ; break ; case HImode : shift_mode = HIshift ; break ; case SImode : shift_mode = SIshift ; break ; default : gcc_unreachable ( ) ; } switch ( code ) { case ASHIFTRT : shift_type = SHIFT_ASHIFTRT ; break ; case LSHIFTRT : shift_type = SHIFT_LSHIFTRT ; break ; case ASHIFT : shift_type = SHIFT_ASHIFT ; break ; default : gcc_unreachable ( ) ; } gcc_assert ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT ) ; n = INTVAL ( operands [ <NUM_LIT> ] ) ; if ( n < <NUM_LIT> ) n = <NUM_LIT> ; else if ( ( unsigned int ) n > GET_MODE_BITSIZE ( mode ) ) n = GET_MODE_BITSIZE ( mode ) ; get_shift_alg ( shift_type , shift_mode , n , & info ) ; switch ( info . alg ) { case SHIFT_SPECIAL : if ( info . remainder == <NUM_LIT> ) return info . cc_special ; case SHIFT_INLINE : return info . cc_inline ; case SHIFT_ROT_AND : return CC_SET_ZNV ; case SHIFT_LOOP : if ( info . shift2 != NULL ) {

if ( n % <NUM_LIT> ) return info . cc_inline ;


<s> machine_mode mode = GET_MODE ( shift ) ; enum rtx_code code = GET_CODE ( shift ) ; enum shift_type shift_type ; enum shift_mode shift_mode ; struct shift_info info ; int n ; switch ( mode ) { case QImode : shift_mode = QIshift ; break ; case HImode : shift_mode = HIshift ; break ; case SImode : shift_mode = SIshift ; break ; default : gcc_unreachable ( ) ; } switch ( code ) { case ASHIFTRT : shift_type = SHIFT_ASHIFTRT ; break ; case LSHIFTRT : shift_type = SHIFT_LSHIFTRT ; break ; case ASHIFT : shift_type = SHIFT_ASHIFT ; break ; default : gcc_unreachable ( ) ; } gcc_assert ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT ) ; n = INTVAL ( operands [ <NUM_LIT> ] ) ; if ( n < <NUM_LIT> ) n = <NUM_LIT> ; else if ( ( unsigned int ) n > GET_MODE_BITSIZE ( mode ) ) n = GET_MODE_BITSIZE ( mode ) ; get_shift_alg ( shift_type , shift_mode , n , & info ) ; switch ( info . alg ) {


<s> int n = INTVAL ( operands [ <NUM_LIT> ] ) ; if ( n < <NUM_LIT> ) n = <NUM_LIT> ; else if ( ( unsigned int ) n > GET_MODE_BITSIZE ( mode ) ) n = GET_MODE_BITSIZE ( mode ) ; get_shift_alg ( shift_type , shift_mode , n , & info ) ; switch ( info . alg ) { case SHIFT_SPECIAL : wlength += h8300_asm_insn_count ( info . special ) ; if ( strstr ( info . special , <STR_LIT> ) != NULL ) wlength ++ ; case SHIFT_INLINE : n = info . remainder ; if ( info . shift2 != NULL ) { wlength += h8300_asm_insn_count ( info . shift2 ) * ( n / <NUM_LIT> ) ; n = n % <NUM_LIT> ; } wlength += h8300_asm_insn_count ( info . shift1 ) * n ; return <NUM_LIT> * wlength ; case SHIFT_ROT_AND : { int m = GET_MODE_BITSIZE ( mode ) - n ; gcc_assert ( info . shift1 ) ; if ( info . shift2 != NULL ) { wlength += h8300_asm_insn_count ( info . shift2 ) * ( m / <NUM_LIT> ) ; m = m % <NUM_LIT> ;


<s> const unsigned HOST_WIDE_INT intval = ( unsigned HOST_WIDE_INT ) ( ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT ) && register_operand ( operands [ <NUM_LIT> ] , VOIDmode ) ? INTVAL ( operands [ <NUM_LIT> ] ) : <NUM_LIT> ) ; const unsigned HOST_WIDE_INT det = ( code != AND ) ? intval : ~ intval ; const unsigned HOST_WIDE_INT b0 = ( det >> <NUM_LIT> ) & <NUM_LIT> ; const unsigned HOST_WIDE_INT b1 = ( det >> <NUM_LIT> ) & <NUM_LIT> ; const unsigned HOST_WIDE_INT w0 = ( det >> <NUM_LIT> ) & <NUM_LIT> ; const unsigned HOST_WIDE_INT w1 = ( det >> <NUM_LIT> ) & <NUM_LIT> ; int lower_half_easy_p = <NUM_LIT> ; int upper_half_easy_p = <NUM_LIT> ; enum attr_cc cc = CC_CLOBBER ; switch ( mode ) { case HImode : if ( ( TARGET_H8300H || TARGET_H8300S ) && b0 != <NUM_LIT> && b1 != <NUM_LIT> ) { cc = CC_SET_ZNV ; } break ; case SImode : if ( TARGET_H8300H || TARGET_H8300S ) { lower_half_easy_p = ( b0 == <NUM_LIT> || b1 == <NUM_LIT> || ( code != IOR && w0 == <NUM_LIT> ) ) ; upper_half_easy_p = ( ( code != IOR && w1 == <NUM_LIT> ) || ( code == AND && w1 == <NUM_LIT> ) ) ; } if ( ( TARGET_H8300H || TARGET_H8300S ) && w0 != <NUM_LIT> && w1 != <NUM_LIT> && ! ( lower_half_easy_p && upper_half_easy_p ) && ! ( code == IOR && w1 == <NUM_LIT> && ( w0 & <NUM_LIT> ) != <NUM_LIT> && lower_half_easy_p ) ) { cc = CC_SET_ZNV ; } else { if ( ( TARGET_H8300H || TARGET_H8300S ) && code == IOR && w1 == <NUM_LIT> && ( w0 & <NUM_LIT> ) != <NUM_LIT> ) {


<s> else { if ( b0 != <NUM_LIT> ) length += <NUM_LIT> ; if ( b1 != <NUM_LIT> ) length += <NUM_LIT> ; } break ; case SImode : if ( TARGET_H8300H || TARGET_H8300S ) { lower_half_easy_p = ( b0 == <NUM_LIT> || b1 == <NUM_LIT> || ( code != IOR && w0 == <NUM_LIT> ) ) ; upper_half_easy_p = ( ( code != IOR && w1 == <NUM_LIT> ) || ( code == AND && w1 == <NUM_LIT> ) ) ; } if ( ( TARGET_H8300H || TARGET_H8300S ) && w0 != <NUM_LIT> && w1 != <NUM_LIT> && ! ( lower_half_easy_p && upper_half_easy_p ) && ! ( code == IOR && w1 == <NUM_LIT> && ( w0 & <NUM_LIT> ) != <NUM_LIT> && lower_half_easy_p ) ) { length = h8300_length_from_table ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , & logicl_length_table ) ; } else { if ( w0 == <NUM_LIT> && ( TARGET_H8300 ? ( code == AND ) : ( code != IOR ) ) ) { length += <NUM_LIT> ; } else if ( ( TARGET_H8300H || TARGET_H8300S ) && ( b0 != <NUM_LIT> ) && ( b1 != <NUM_LIT> ) ) { length += <NUM_LIT> ;


<s> if ( ( TARGET_H8300H || TARGET_H8300S ) && w0 != <NUM_LIT> && w1 != <NUM_LIT> && ! ( lower_half_easy_p && upper_half_easy_p ) && ! ( code == IOR && w1 == <NUM_LIT> && ( w0 & <NUM_LIT> ) != <NUM_LIT> && lower_half_easy_p ) ) { length = h8300_length_from_table ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , & logicl_length_table ) ; } else { if ( w0 == <NUM_LIT> && ( TARGET_H8300 ? ( code == AND ) : ( code != IOR ) ) ) { length += <NUM_LIT> ; } else if ( ( TARGET_H8300H || TARGET_H8300S ) && ( b0 != <NUM_LIT> ) && ( b1 != <NUM_LIT> ) ) { length += <NUM_LIT> ; } else { if ( b0 != <NUM_LIT> ) length += <NUM_LIT> ; if ( b1 != <NUM_LIT> ) length += <NUM_LIT> ; } if ( w1 == <NUM_LIT> && ( TARGET_H8300 ? ( code == AND ) : ( code != IOR ) ) ) { length += <NUM_LIT> ; } else if ( ( TARGET_H8300H || TARGET_H8300S ) && code == IOR && w1 == <NUM_LIT> && ( w0 & <NUM_LIT> ) != <NUM_LIT> ) { length += <NUM_LIT> ; } else if ( ( TARGET_H8300H || TARGET_H8300S ) && code == AND && w1 == <NUM_LIT> ) { length += <NUM_LIT> ; }

else if ( TARGET_H8300H || TARGET_H8300S ) {


<s> return <NUM_LIT> ; } base_length = <NUM_LIT> ; break ; case SFmode : if ( addr == NULL_RTX ) { if ( REG_P ( src ) ) return <NUM_LIT> ; if ( satisfies_constraint_G ( src ) ) return <NUM_LIT> ; return <NUM_LIT> ; } base_length = <NUM_LIT> ; break ; default : gcc_unreachable ( ) ; } if ( GET_CODE ( addr ) == PRE_DEC || GET_CODE ( addr ) == POST_INC ) { if ( mode == QImode || mode == HImode ) return base_length - <NUM_LIT> ; else return base_length - <NUM_LIT> ; } if ( GET_CODE ( addr ) == REG ) return base_length - <NUM_LIT> ; return base_length ; } else { unsigned int base_length ; switch ( mode ) { case QImode : if ( addr == NULL_RTX ) return <NUM_LIT> ; if ( h8300_eightbit_constant_address_p ( addr ) ) return <NUM_LIT> ; base_length = <NUM_LIT> ; break ; case HImode : if ( addr == NULL_RTX ) { if ( REG_P ( src ) ) return <NUM_LIT> ; if ( src == const0_rtx ) return <NUM_LIT> ; return <NUM_LIT> ; } base_length = <NUM_LIT> ; break ; case SImode : if ( addr == NULL_RTX ) { if ( REG_P ( src ) ) { if ( REGNO ( src ) == MAC_REG || REGNO ( dest ) == MAC_REG ) return <NUM_LIT> ; else return <NUM_LIT> ; } if ( GET_CODE ( src ) == CONST_INT ) { int val = INTVAL ( src ) ; if ( val == <NUM_LIT> ) return <NUM_LIT> ; if ( val == ( val & <NUM_LIT> ) || val == ( val & <NUM_LIT> ) ) return <NUM_LIT> ; switch ( val & <NUM_LIT> ) {


<s> unsigned int base_length ; switch ( mode ) { case QImode : if ( addr == NULL_RTX ) return <NUM_LIT> ; if ( h8300_eightbit_constant_address_p ( addr ) ) return <NUM_LIT> ; base_length = <NUM_LIT> ; break ; case HImode : if ( addr == NULL_RTX ) { if ( REG_P ( src ) ) return <NUM_LIT> ; if ( src == const0_rtx ) return <NUM_LIT> ; return <NUM_LIT> ; } base_length = <NUM_LIT> ; break ; case SImode : if ( addr == NULL_RTX ) { if ( REG_P ( src ) ) return <NUM_LIT> ; if ( GET_CODE ( src ) == CONST_INT ) { if ( src == const0_rtx ) return <NUM_LIT> ; if ( ( INTVAL ( src ) & <NUM_LIT> ) == <NUM_LIT> ) return <NUM_LIT> ; if ( ( INTVAL ( src ) & <NUM_LIT> ) == <NUM_LIT> ) return <NUM_LIT> ; if ( ( INTVAL ( src ) & <NUM_LIT> ) == ( ( INTVAL ( src ) >> <NUM_LIT> ) & <NUM_LIT> ) ) return <NUM_LIT> ; } return <NUM_LIT> ; } base_length = <NUM_LIT> ; break ; case SFmode : if ( addr == NULL_RTX ) { if ( REG_P ( src ) ) return <NUM_LIT> ; if ( satisfies_constraint_G ( src ) ) return <NUM_LIT> ; return <NUM_LIT> ; } base_length = <NUM_LIT> ; break ; default : gcc_unreachable ( ) ; } if ( GET_CODE ( addr ) == PRE_DEC || GET_CODE ( addr ) == POST_INC ) { if ( mode == QImode || mode == HImode ) return base_length - <NUM_LIT> ; else return base_length - <NUM_LIT> ; } if ( GET_CODE ( addr ) == REG ) return base_length - <NUM_LIT> ; return base_length ; } else { unsigned int base_length ; switch ( mode ) { case QImode : if ( addr == NULL_RTX ) return <NUM_LIT> ; if ( h8300_eightbit_constant_address_p ( addr ) ) return <NUM_LIT> ; base_length = <NUM_LIT> ; break ; case HImode : if ( addr == NULL_RTX ) { if ( REG_P ( src ) ) return <NUM_LIT> ; if ( src == const0_rtx ) return <NUM_LIT> ; return <NUM_LIT> ; } base_length = <NUM_LIT> ; break ; case SImode : if ( addr == NULL_RTX ) { if ( REG_P ( src ) ) { if ( REGNO ( src ) == MAC_REG || REGNO ( dest ) == MAC_REG ) return <NUM_LIT> ; else return <NUM_LIT> ;


<s> emit_insn ( gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , gen_rtx_SET ( VOIDmode , copy_rtx ( operands [ <NUM_LIT> ] ) , gen_rtx_fmt_ee ( code , mode , copy_rtx ( operands [ <NUM_LIT> ] ) , operands [ <NUM_LIT> ] ) ) , gen_rtx_CLOBBER ( VOIDmode , gen_rtx_SCRATCH ( QImode ) ) ) ) ) ;


<s> return false ; case H8SX_SHIFT_NONE : break ; } emit_move_insn ( copy_rtx ( operands [ <NUM_LIT> ] ) , operands [ <NUM_LIT> ] ) ; emit_insn ( gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , gen_rtx_SET ( VOIDmode , copy_rtx ( operands [ <NUM_LIT> ] ) , gen_rtx_fmt_ee ( code , mode , copy_rtx ( operands [ <NUM_LIT> ] ) , operands [ <NUM_LIT> ] ) ) , gen_rtx_CLOBBER ( VOIDmode , gen_rtx_SCRATCH ( QImode ) ) ) ) ) ;


<s> void h8300_expand_branch ( rtx operands [ ] ) { enum rtx_code code = GET_CODE ( operands [ <NUM_LIT> ] ) ; rtx op0 = operands [ <NUM_LIT> ] ; rtx op1 = operands [ <NUM_LIT> ] ; rtx label = operands [ <NUM_LIT> ] ; rtx tmp ; tmp = gen_rtx_COMPARE ( VOIDmode , op0 , op1 ) ; emit_insn ( gen_rtx_SET ( VOIDmode , cc0_rtx , tmp ) ) ; tmp = gen_rtx_fmt_ee ( code , VOIDmode , cc0_rtx , const0_rtx ) ; tmp = gen_rtx_IF_THEN_ELSE ( VOIDmode , tmp , gen_rtx_LABEL_REF ( VOIDmode , label ) , pc_rtx ) ; emit_jump_insn ( gen_rtx_SET ( VOIDmode , pc_rtx , tmp ) ) ;


<s> rtx op0 = operands [ <NUM_LIT> ] ; rtx op1 = operands [ <NUM_LIT> ] ; rtx label = operands [ <NUM_LIT> ] ; rtx tmp ; tmp = gen_rtx_COMPARE ( VOIDmode , op0 , op1 ) ;

emit_insn ( gen_rtx_SET ( VOIDmode , cc0_rtx , tmp ) ) ;


<s> for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno += n_regs ) { n_regs = <NUM_LIT> ; if ( saved_regs & ( <NUM_LIT> << regno ) ) { if ( TARGET_H8300S ) { if ( ( ! TARGET_H8300SX || ( regno & <NUM_LIT> ) == <NUM_LIT> ) && ( ( saved_regs >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) n_regs = <NUM_LIT> ;

else if ( ( ! TARGET_H8300SX || ( regno & <NUM_LIT> ) == <NUM_LIT> ) && ( ( saved_regs >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) n_regs = <NUM_LIT> ;


<s> int saved_regs ; int n_regs ; if ( h8300_os_task_function_p ( current_function_decl ) ) return ; if ( h8300_monitor_function_p ( current_function_decl ) ) emit_insn ( gen_monitor_prologue ( ) ) ; if ( frame_pointer_needed ) { push ( HARD_FRAME_POINTER_REGNUM , true ) ; F ( emit_move_insn ( hard_frame_pointer_rtx , stack_pointer_rtx ) , true ) ; } saved_regs = compute_saved_regs ( ) ; for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno += n_regs ) { n_regs = <NUM_LIT> ; if ( saved_regs & ( <NUM_LIT> << regno ) ) { if ( TARGET_H8300S ) { if ( ( ! TARGET_H8300SX || ( regno & <NUM_LIT> ) == <NUM_LIT> ) && ( ( saved_regs >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) n_regs = <NUM_LIT> ; else if ( ( ! TARGET_H8300SX || ( regno & <NUM_LIT> ) == <NUM_LIT> ) && ( ( saved_regs >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) n_regs = <NUM_LIT> ; else if ( ( ! TARGET_H8300SX || ( regno & <NUM_LIT> ) == <NUM_LIT> ) && ( ( saved_regs >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) n_regs = <NUM_LIT> ; } h8300_push_pop ( regno , n_regs , false , false ) ; }


<s> enum rtx_code code = GET_CODE ( operands [ <NUM_LIT> ] ) ; rtx op0 = operands [ <NUM_LIT> ] ; rtx op1 = operands [ <NUM_LIT> ] ;


<s> emit_insn ( gen_rtx_SET ( VOIDmode , cc0_rtx , tmp ) ) ; tmp = gen_rtx_fmt_ee ( code , GET_MODE ( dest ) , cc0_rtx , const0_rtx ) ;

emit_insn ( gen_rtx_SET ( VOIDmode , dest , tmp ) ) ;


<s> static rtx h8300_function_arg ( cumulative_args_t cum_v , machine_mode mode , const_tree type , bool named ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; static const char * const hand_list [ ] = { <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <NUM_LIT> , } ; rtx result = NULL_RTX ; const char * fname ;


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

cum -> nbytes += ( mode != BLKmode ? ( GET_MODE_SIZE ( mode ) + UNITS_PER_WORD - <NUM_LIT> ) & - UNITS_PER_WORD : ( int_size_in_bytes ( type ) + UNITS_PER_WORD - <NUM_LIT> ) & - UNITS_PER_WORD ) ;


<s> int h8300_hard_regno_mode_ok ( int regno , machine_mode mode ) { if ( TARGET_H8300 ) return ( ( regno & <NUM_LIT> ) == <NUM_LIT> ) || ( mode == HImode ) || ( mode == QImode ) ;

else return regno == MAC_REG ? mode == SImode : <NUM_LIT> ;


<s> break ; case 'Z' : bitint = INTVAL ( x ) ; fprintf ( file , <STR_LIT> , bitint & <NUM_LIT> ) ; break ; case 'c' : switch ( GET_CODE ( x ) ) { case IOR : fprintf ( file , <STR_LIT> ) ; break ; case XOR : fprintf ( file , <STR_LIT> ) ; break ; case AND : fprintf ( file , <STR_LIT> ) ; break ; default : break ; } break ; case 'e' : switch ( GET_CODE ( x ) ) { case REG : if ( TARGET_H8300 ) fprintf ( file , <STR_LIT> , names_big [ REGNO ( x ) ] ) ; else fprintf ( file , <STR_LIT> , names_upper_extended [ REGNO ( x ) ] ) ; break ; case MEM : h8300_print_operand ( file , x , <NUM_LIT> ) ; break ; case CONST_INT : fprintf ( file , <STR_LIT> , ( ( INTVAL ( x ) >> <NUM_LIT> ) & <NUM_LIT> ) ) ; break ; case CONST_DOUBLE : { long val ; REAL_VALUE_TYPE rv ; REAL_VALUE_FROM_CONST_DOUBLE ( rv , x ) ; REAL_VALUE_TO_TARGET_SINGLE ( rv , val ) ; fprintf ( file , <STR_LIT> , ( ( val >> <NUM_LIT> ) & <NUM_LIT> ) ) ; break ; } default : gcc_unreachable ( ) ; break ; } break ; case 'f' : switch ( GET_CODE ( x ) ) { case REG : if ( TARGET_H8300 ) fprintf ( file , <STR_LIT> , names_big [ REGNO ( x ) + <NUM_LIT> ] ) ; else fprintf ( file , <STR_LIT> , names_big [ REGNO ( x ) ] ) ; break ; case MEM : x = adjust_address ( x , HImode , <NUM_LIT> ) ; h8300_print_operand ( file , x , <NUM_LIT> ) ; break ; case CONST_INT : fprintf ( file , <STR_LIT> , INTVAL ( x ) & <NUM_LIT> ) ; break ; case CONST_DOUBLE : { long val ; REAL_VALUE_TYPE rv ; REAL_VALUE_FROM_CONST_DOUBLE ( rv , x ) ; REAL_VALUE_TO_TARGET_SINGLE ( rv , val ) ; fprintf ( file , <STR_LIT> , ( val & <NUM_LIT> ) ) ; break ; } default : gcc_unreachable ( ) ; } break ; case 'j' : fputs ( cond_string ( GET_CODE ( x ) ) , file ) ; break ; case 'k' : fputs ( cond_string ( reverse_condition ( GET_CODE ( x ) ) ) , file ) ; break ; case 'm' : gcc_assert ( GET_CODE ( x ) == CONST_INT ) ; switch ( INTVAL ( x ) ) { case <NUM_LIT> : fputs ( <STR_LIT> , file ) ; break ; case <NUM_LIT> : fputs ( <STR_LIT> , file ) ; break ; case <NUM_LIT> : fputs ( <STR_LIT> , file ) ; break ; default : gcc_unreachable ( ) ; } break ; case 'o' :

h8300_print_operand_address ( file , x ) ;


<s> fprintf ( file , <STR_LIT> , h8_reg_names [ REGNO ( XEXP ( addr , <NUM_LIT> ) ) ] ) ; break ; case PLUS : fprintf ( file , <STR_LIT> ) ; index = h8300_get_index ( XEXP ( addr , <NUM_LIT> ) , VOIDmode , & size ) ; if ( GET_CODE ( index ) == REG ) { h8300_print_operand_address ( file , XEXP ( addr , <NUM_LIT> ) ) ; fprintf ( file , <STR_LIT> ) ; switch ( size ) { case <NUM_LIT> : h8300_print_operand_address ( file , index ) ; break ; case <NUM_LIT> : h8300_print_operand ( file , index , 'X' ) ; fputs ( <STR_LIT> , file ) ; break ; case <NUM_LIT> : h8300_print_operand ( file , index , 'T' ) ; fputs ( <STR_LIT> , file ) ; break ; case <NUM_LIT> : h8300_print_operand ( file , index , 'S' ) ; fputs ( <STR_LIT> , file ) ; break ; } } else { h8300_print_operand_address ( file , XEXP ( addr , <NUM_LIT> ) ) ;


<s> fputs ( <STR_LIT> , file ) ; break ; case <NUM_LIT> : h8300_print_operand ( file , index , 'T' ) ; fputs ( <STR_LIT> , file ) ; break ; case <NUM_LIT> : h8300_print_operand ( file , index , 'S' ) ; fputs ( <STR_LIT> , file ) ; break ; } } else { h8300_print_operand_address ( file , XEXP ( addr , <NUM_LIT> ) ) ; fprintf ( file , <STR_LIT> ) ; h8300_print_operand_address ( file , XEXP ( addr , <NUM_LIT> ) ) ; } fprintf ( file , <STR_LIT> ) ; break ; case CONST_INT : { int n = INTVAL ( addr ) ; if ( TARGET_H8300 ) n = ( int ) ( short ) n ;


<s> int i , j ; rtvec vec ; rtx sp , offset , x ; if ( ! return_p && nregs == <NUM_LIT> ) { if ( pop_p ) pop ( regno ) ; else push ( regno , false ) ; return ; } vec = rtvec_alloc ( ( return_p ? <NUM_LIT> : <NUM_LIT> ) + nregs + <NUM_LIT> ) ; sp = stack_pointer_rtx ; i = <NUM_LIT> ; if ( return_p ) { RTVEC_ELT ( vec , i ) = ret_rtx ; i ++ ; } for ( j = <NUM_LIT> ; j < nregs ; j ++ ) { rtx lhs , rhs ;


<s> sp = stack_pointer_rtx ; i = <NUM_LIT> ; if ( return_p ) { RTVEC_ELT ( vec , i ) = ret_rtx ; i ++ ; } for ( j = <NUM_LIT> ; j < nregs ; j ++ ) { rtx lhs , rhs ; if ( pop_p ) { lhs = gen_rtx_REG ( SImode , regno + j ) ; rhs = gen_rtx_MEM ( SImode , plus_constant ( Pmode , sp , ( nregs - j - <NUM_LIT> ) * <NUM_LIT> ) ) ; } else { lhs = gen_rtx_MEM ( SImode , plus_constant ( Pmode , sp , ( j + <NUM_LIT> ) * - <NUM_LIT> ) ) ; rhs = gen_rtx_REG ( SImode , regno + j ) ; } RTVEC_ELT ( vec , i + j ) = gen_rtx_SET ( VOIDmode , lhs , rhs ) ; } offset = GEN_INT ( ( pop_p ? nregs : - nregs ) * <NUM_LIT> ) ; RTVEC_ELT ( vec , i + j ) = gen_rtx_SET ( VOIDmode , sp , gen_rtx_PLUS ( Pmode , sp , offset ) ) ; x = gen_rtx_PARALLEL ( VOIDmode , vec ) ; if ( ! pop_p ) x = Fpa ( x ) ; if ( return_p ) emit_jump_insn ( x ) ; else emit_insn ( x ) ;


<s> { HOST_WIDE_INT n = INTVAL ( x ) ; if ( TARGET_H8300SX ) { * total = <NUM_LIT> ; return true ; } if ( - <NUM_LIT> <= n && n <= <NUM_LIT> ) { switch ( ( int ) n ) { case <NUM_LIT> : * total = <NUM_LIT> ; return true ; case <NUM_LIT> : case <NUM_LIT> : case - <NUM_LIT> : case - <NUM_LIT> : * total = <NUM_LIT> + ( outer_code == SET ) ; return true ; case <NUM_LIT> : case - <NUM_LIT> : if ( TARGET_H8300H || TARGET_H8300S ) * total = <NUM_LIT> + ( outer_code == SET ) ; else * total = <NUM_LIT> ; return true ; } } * total = <NUM_LIT> ; return true ; } case CONST : case LABEL_REF : case SYMBOL_REF : if ( TARGET_H8300SX ) { * total = <NUM_LIT> ; return true ; } * total = <NUM_LIT> ; return true ; case CONST_DOUBLE : * total = <NUM_LIT> ; return true ; case COMPARE : if ( XEXP ( x , <NUM_LIT> ) == const0_rtx ) * total = <NUM_LIT> ; return false ; case AND : if ( ! h8300_dst_operand ( XEXP ( x , <NUM_LIT> ) , VOIDmode ) || ! h8300_src_operand ( XEXP ( x , <NUM_LIT> ) , VOIDmode ) ) return false ; * total = COSTS_N_INSNS ( h8300_and_costs ( x ) ) ; return true ; case MOD : case DIV : case UMOD : case UDIV : if ( TARGET_H8300SX ) switch ( GET_MODE ( x ) ) { case QImode : case HImode : * total = COSTS_N_INSNS ( ! speed ? <NUM_LIT> : <NUM_LIT> ) ; return false ; case SImode : * total = COSTS_N_INSNS ( ! speed ? <NUM_LIT> : <NUM_LIT> ) ; return false ; default : break ; } * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case MULT :


<s> * total = <NUM_LIT> ; return true ; } case CONST : case LABEL_REF : case SYMBOL_REF : if ( TARGET_H8300SX ) { * total = <NUM_LIT> ; return true ; } * total = <NUM_LIT> ; return true ; case CONST_DOUBLE : * total = <NUM_LIT> ; return true ; case COMPARE : if ( XEXP ( x , <NUM_LIT> ) == const0_rtx ) * total = <NUM_LIT> ; return false ; case AND : if ( ! h8300_dst_operand ( XEXP ( x , <NUM_LIT> ) , VOIDmode ) || ! h8300_src_operand ( XEXP ( x , <NUM_LIT> ) , VOIDmode ) ) return false ; * total = COSTS_N_INSNS ( h8300_and_costs ( x ) ) ; return true ; case MOD : case DIV : case UMOD : case UDIV : if ( TARGET_H8300SX ) switch ( GET_MODE ( x ) ) { case QImode : case HImode : * total = COSTS_N_INSNS ( ! speed ? <NUM_LIT> : <NUM_LIT> ) ; return false ; case SImode : * total = COSTS_N_INSNS ( ! speed ? <NUM_LIT> : <NUM_LIT> ) ; return false ; default : break ; } * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case MULT :


<s> int h8300_shift_needs_scratch_p ( int count , machine_mode mode ) { enum h8_cpu cpu ; int a , lr , ar ; if ( GET_MODE_BITSIZE ( mode ) <= count ) return <NUM_LIT> ; if ( TARGET_H8300 ) cpu = H8_300 ; else if ( TARGET_H8300H ) cpu = H8_300H ; else cpu = H8_S ; switch ( mode ) { case QImode : a = shift_alg_qi [ cpu ] [ SHIFT_ASHIFT ] [ count ] ; lr = shift_alg_qi [ cpu ] [ SHIFT_LSHIFTRT ] [ count ] ; ar = shift_alg_qi [ cpu ] [ SHIFT_ASHIFTRT ] [ count ] ; break ; case HImode : a = shift_alg_hi [ cpu ] [ SHIFT_ASHIFT ] [ count ] ; lr = shift_alg_hi [ cpu ] [ SHIFT_LSHIFTRT ] [ count ] ; ar = shift_alg_hi [ cpu ] [ SHIFT_ASHIFTRT ] [ count ] ; break ; case SImode : a = shift_alg_si [ cpu ] [ SHIFT_ASHIFT ] [ count ] ; lr = shift_alg_si [ cpu ] [ SHIFT_LSHIFTRT ] [ count ] ; ar = shift_alg_si [ cpu ] [ SHIFT_ASHIFTRT ] [ count ] ; break ; default : gcc_unreachable ( ) ; } return ( a == SHIFT_LOOP || lr == SHIFT_LOOP || ar == SHIFT_LOOP || ( TARGET_H8300H && mode == SImode && count == <NUM_LIT> ) ) ;


<s> rtx insn = push ( HARD_FRAME_POINTER_REGNUM , false ) ; if ( frame_pointer_needed ) add_reg_note ( insn , REG_CFA_DEF_CFA , plus_constant ( Pmode , gen_rtx_MEM ( Pmode , stack_pointer_rtx ) , <NUM_LIT> * UNITS_PER_WORD ) ) ; else add_reg_note ( insn , REG_CFA_ADJUST_CFA , gen_rtx_SET ( VOIDmode , stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> ) ) ) ;

emit_move_insn ( hard_frame_pointer_rtx , addr ) ;


<s> void h8300_swap_into_er6 ( rtx addr ) { rtx insn = push ( HARD_FRAME_POINTER_REGNUM , false ) ; if ( frame_pointer_needed ) add_reg_note ( insn , REG_CFA_DEF_CFA , plus_constant ( Pmode , gen_rtx_MEM ( Pmode , stack_pointer_rtx ) , <NUM_LIT> * UNITS_PER_WORD ) ) ; else add_reg_note ( insn , REG_CFA_ADJUST_CFA , gen_rtx_SET ( VOIDmode , stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> ) ) ) ;


<s> void h8300_swap_out_of_er6 ( rtx addr ) { rtx insn ; if ( REGNO ( addr ) != SP_REG ) emit_move_insn ( addr , hard_frame_pointer_rtx ) ; insn = pop ( HARD_FRAME_POINTER_REGNUM ) ; if ( frame_pointer_needed ) add_reg_note ( insn , REG_CFA_DEF_CFA , plus_constant ( Pmode , hard_frame_pointer_rtx , <NUM_LIT> * UNITS_PER_WORD ) ) ; else add_reg_note ( insn , REG_CFA_ADJUST_CFA , gen_rtx_SET ( VOIDmode , stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - <NUM_LIT> ) ) ) ;


<s> if ( frame_pointer_needed ) add_reg_note ( insn , REG_CFA_DEF_CFA , plus_constant ( Pmode , hard_frame_pointer_rtx , <NUM_LIT> * UNITS_PER_WORD ) ) ; else add_reg_note ( insn , REG_CFA_ADJUST_CFA , gen_rtx_SET ( VOIDmode , stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - <NUM_LIT> ) ) ) ;


<s> dest_reg = copy_addr_to_reg ( XEXP ( dest , <NUM_LIT> ) ) ; src_reg = copy_addr_to_reg ( XEXP ( src , <NUM_LIT> ) ) ; first_dest = replace_equiv_address ( dest , dest_reg ) ; first_src = replace_equiv_address ( src , src_reg ) ; set_mem_size ( first_dest , n & - factor ) ; set_mem_size ( first_src , n & - factor ) ; length = copy_to_mode_reg ( HImode , gen_int_mode ( n / factor , HImode ) ) ; emit_insn ( gen_movmd ( first_dest , first_src , length , GEN_INT ( factor ) ) ) ;


<s> first_src = replace_equiv_address ( src , src_reg ) ; set_mem_size ( first_dest , n & - factor ) ; set_mem_size ( first_src , n & - factor ) ; length = copy_to_mode_reg ( HImode , gen_int_mode ( n / factor , HImode ) ) ; emit_insn ( gen_movmd ( first_dest , first_src , length , GEN_INT ( factor ) ) ) ; if ( ( n & - factor ) != n ) { dest = adjust_address ( dest , BLKmode , n & - factor ) ; src = adjust_address ( src , BLKmode , n & - factor ) ; dest = replace_equiv_address ( dest , dest_reg ) ; src = replace_equiv_address ( src , src_reg ) ; if ( n & <NUM_LIT> ) emit_move_insn ( adjust_address ( dest , HImode , <NUM_LIT> ) , adjust_address ( src , HImode , <NUM_LIT> ) ) ; if ( n & <NUM_LIT> ) emit_move_insn ( adjust_address ( dest , QImode , n & <NUM_LIT> ) , adjust_address ( src , QImode , n & <NUM_LIT> ) ) ; } return true ;


<s> if ( amount < <NUM_LIT> ) amount = <NUM_LIT> ; if ( ( unsigned int ) amount > GET_MODE_BITSIZE ( mode ) ) amount = GET_MODE_BITSIZE ( mode ) ; if ( ( unsigned int ) amount > GET_MODE_BITSIZE ( mode ) / ( unsigned ) <NUM_LIT> ) { amount = GET_MODE_BITSIZE ( mode ) - amount ; rotate_type = ( rotate_type == SHIFT_ASHIFT ) ? SHIFT_LSHIFTRT : SHIFT_ASHIFT ; } if ( ( mode == HImode && TARGET_H8300 && amount >= <NUM_LIT> ) || ( mode == HImode && TARGET_H8300H && amount >= <NUM_LIT> ) || ( mode == HImode && TARGET_H8300S && amount == <NUM_LIT> ) || ( mode == SImode && TARGET_H8300H && amount >= <NUM_LIT> ) || ( mode == SImode && TARGET_H8300S && amount >= <NUM_LIT> ) ) { switch ( mode ) { case HImode : insn_buf = <STR_LIT> ; output_asm_insn ( insn_buf , operands ) ; break ; case SImode : insn_buf = <STR_LIT> ; output_asm_insn ( insn_buf , operands ) ; break ;


<s> switch ( code ) { case ROTATERT : rotate_type = SHIFT_ASHIFT ; break ; case ROTATE : rotate_type = SHIFT_LSHIFTRT ; break ; default : gcc_unreachable ( ) ; } amount = INTVAL ( rotate_amount ) ; if ( amount < <NUM_LIT> ) amount = <NUM_LIT> ; if ( ( unsigned int ) amount > GET_MODE_BITSIZE ( mode ) ) amount = GET_MODE_BITSIZE ( mode ) ; if ( ( unsigned int ) amount > GET_MODE_BITSIZE ( mode ) / ( unsigned ) <NUM_LIT> ) { amount = GET_MODE_BITSIZE ( mode ) - amount ; rotate_type = ( rotate_type == SHIFT_ASHIFT ) ? SHIFT_LSHIFTRT : SHIFT_ASHIFT ; } if ( ( mode == HImode && TARGET_H8300 && amount >= <NUM_LIT> ) || ( mode == HImode && TARGET_H8300H && amount >= <NUM_LIT> ) || ( mode == HImode && TARGET_H8300S && amount == <NUM_LIT> ) || ( mode == SImode && TARGET_H8300H && amount >= <NUM_LIT> ) || ( mode == SImode && TARGET_H8300S && amount >= <NUM_LIT> ) ) { switch ( mode ) { case HImode :


<s> if ( n < <NUM_LIT> ) n = <NUM_LIT> ; else if ( ( unsigned int ) n > GET_MODE_BITSIZE ( mode ) ) n = GET_MODE_BITSIZE ( mode ) ; get_shift_alg ( shift_type , shift_mode , n , & info ) ; switch ( info . alg ) { case SHIFT_SPECIAL : output_asm_insn ( info . special , operands ) ; case SHIFT_INLINE : n = info . remainder ; if ( info . shift2 != NULL ) { for ( ; n > <NUM_LIT> ; n -= <NUM_LIT> ) output_asm_insn ( info . shift2 , operands ) ; } for ( ; n > <NUM_LIT> ; n -- ) output_asm_insn ( info . shift1 , operands ) ; return <STR_LIT> ; case SHIFT_ROT_AND : { int m = GET_MODE_BITSIZE ( mode ) - n ; const int mask = ( shift_type == SHIFT_ASHIFT ? ( ( <NUM_LIT> << m ) - <NUM_LIT> ) << n : ( <NUM_LIT> << m ) - <NUM_LIT> ) ; char insn_buf [ <NUM_LIT> ] ; gcc_assert ( info . shift1 ) ; if ( info . shift2 != NULL ) { for ( ; m > <NUM_LIT> ; m -= <NUM_LIT> ) output_asm_insn ( info . shift2 , operands ) ; } for ( ; m > <NUM_LIT> ; m -- ) output_asm_insn ( info . shift1 , operands ) ; switch ( mode ) { case QImode : sprintf ( insn_buf , <STR_LIT> , mask ) ; break ; case HImode : gcc_assert ( TARGET_H8300H || TARGET_H8300S ) ; sprintf ( insn_buf , <STR_LIT> , mask ) ; break ; default : gcc_unreachable ( ) ; } output_asm_insn ( insn_buf , operands ) ; return <STR_LIT> ; } case SHIFT_LOOP : if ( info . shift2 != NULL ) { fprintf ( asm_out_file , <STR_LIT> , n / <NUM_LIT> , names_big [ REGNO ( operands [ <NUM_LIT> ] ) ] ) ; fprintf ( asm_out_file , <STR_LIT> , loopend_lab ) ; output_asm_insn ( info . shift2 , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; fprintf ( asm_out_file , <STR_LIT> , loopend_lab ) ; if ( n % <NUM_LIT> ) output_asm_insn ( info . shift1 , operands ) ; } else { fprintf ( asm_out_file , <STR_LIT> , n , names_big [ REGNO ( operands [ <NUM_LIT> ] ) ] ) ; fprintf ( asm_out_file , <STR_LIT> , loopend_lab ) ; output_asm_insn ( info . shift1 , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; fprintf ( asm_out_file , <STR_LIT> , loopend_lab ) ;


<s> case ASHIFTRT : shift_type = SHIFT_ASHIFTRT ; break ; case LSHIFTRT : shift_type = SHIFT_LSHIFTRT ; break ; case ASHIFT : shift_type = SHIFT_ASHIFT ; break ; default : gcc_unreachable ( ) ; } gcc_assert ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT ) ; n = INTVAL ( operands [ <NUM_LIT> ] ) ; if ( n < <NUM_LIT> ) n = <NUM_LIT> ; else if ( ( unsigned int ) n > GET_MODE_BITSIZE ( mode ) ) n = GET_MODE_BITSIZE ( mode ) ; get_shift_alg ( shift_type , shift_mode , n , & info ) ; switch ( info . alg ) { case SHIFT_SPECIAL : output_asm_insn ( info . special , operands ) ; case SHIFT_INLINE : n = info . remainder ; if ( info . shift2 != NULL ) { for ( ; n > <NUM_LIT> ; n -= <NUM_LIT> ) output_asm_insn ( info . shift2 , operands ) ; } for ( ; n > <NUM_LIT> ; n -- ) output_asm_insn ( info . shift1 , operands ) ; return <STR_LIT> ; case SHIFT_ROT_AND : { int m = GET_MODE_BITSIZE ( mode ) - n ; const int mask = ( shift_type == SHIFT_ASHIFT ? ( ( <NUM_LIT> << m ) - <NUM_LIT> ) << n : ( <NUM_LIT> << m ) - <NUM_LIT> ) ; char insn_buf [ <NUM_LIT> ] ; gcc_assert ( info . shift1 ) ; if ( info . shift2 != NULL ) { for ( ; m > <NUM_LIT> ; m -= <NUM_LIT> ) output_asm_insn ( info . shift2 , operands ) ; } for ( ; m > <NUM_LIT> ; m -- ) output_asm_insn ( info . shift1 , operands ) ; switch ( mode ) { case QImode : sprintf ( insn_buf , <STR_LIT> , mask ) ; break ; case HImode : gcc_assert ( TARGET_H8300H || TARGET_H8300S ) ; sprintf ( insn_buf , <STR_LIT> , mask ) ; break ; default : gcc_unreachable ( ) ; } output_asm_insn ( insn_buf , operands ) ; return <STR_LIT> ; } case SHIFT_LOOP : if ( info . shift2 != NULL ) { fprintf ( asm_out_file , <STR_LIT> , n / <NUM_LIT> , names_big [ REGNO ( operands [ <NUM_LIT> ] ) ] ) ; fprintf ( asm_out_file , <STR_LIT> , loopend_lab ) ; output_asm_insn ( info . shift2 , operands ) ;

output_asm_insn ( <STR_LIT> , operands ) ;


<s> rtx_insn * i1 , * i2 ; i2 = prev_nonnote_insn ( i3 ) ; if ( i2 == NULL ) return <NUM_LIT> ; i1 = prev_nonnote_insn ( i2 ) ; if ( i1 == NULL ) return <NUM_LIT> ; return ( INSN_P ( i1 ) && rtx_equal_p ( PATTERN ( i1 ) , PATTERN ( i3 ) ) && any_condjump_p ( i2 ) && onlyjump_p ( i2 ) ) ;


<s> rtx ( * gen_add ) ( rtx , rtx , rtx ) ; if ( val < <NUM_LIT> ) { val = - val ; sign = - <NUM_LIT> ; } switch ( mode ) { case HImode : gen_add = gen_addhi3 ; break ; case SImode : gen_add = gen_addsi3 ; break ; default : gcc_unreachable ( ) ; } for ( amount = ( TARGET_H8300H || TARGET_H8300S ) ? <NUM_LIT> : <NUM_LIT> ; amount > <NUM_LIT> ; amount /= <NUM_LIT> ) { for ( ; val >= amount ; val -= amount ) emit_insn ( gen_add ( reg , reg , GEN_INT ( sign * amount ) ) ) ; } return ;


<s> n_regs = <NUM_LIT> ; if ( saved_regs & ( <NUM_LIT> << regno ) ) { if ( TARGET_H8300S ) { if ( ( ! TARGET_H8300SX || ( regno & <NUM_LIT> ) == <NUM_LIT> ) && ( ( saved_regs >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) n_regs = <NUM_LIT> ; else if ( ( ! TARGET_H8300SX || ( regno & <NUM_LIT> ) == <NUM_LIT> ) && ( ( saved_regs >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) n_regs = <NUM_LIT> ; else if ( ( ! TARGET_H8300SX || ( regno & <NUM_LIT> ) == <NUM_LIT> ) && ( ( saved_regs >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) n_regs = <NUM_LIT> ; } h8300_push_pop ( regno , n_regs , false , false ) ; } } h8300_emit_stack_adjustment ( - <NUM_LIT> , round_frame_size ( get_frame_size ( ) ) , true ) ; if ( flag_stack_usage_info ) current_function_static_stack_size = round_frame_size ( get_frame_size ( ) ) + ( __builtin_popcount ( saved_regs ) * UNITS_PER_WORD ) + ( frame_pointer_needed ? UNITS_PER_WORD : <NUM_LIT> ) ;


<s> if ( TARGET_H8300SX ) { error ( <STR_LIT> ) ; target_flags |= MASK_H8300S ; } if ( TARGET_H8300 ) { cpu_type = ( int ) CPU_H8300 ; h8_reg_names = names_big ; } else { cpu_type = ( int ) CPU_H8300H ; h8_reg_names = names_extended ; } h8_push_op = h8_push_ops [ cpu_type ] ; h8_pop_op = h8_pop_ops [ cpu_type ] ; h8_mov_op = h8_mov_ops [ cpu_type ] ; if ( ! TARGET_H8300S && TARGET_MAC ) { error ( <STR_LIT> ) ; target_flags |= MASK_H8300S_1 ; } if ( TARGET_H8300 && TARGET_NORMAL_MODE ) { error ( <STR_LIT> ) ; target_flags ^= MASK_NORMAL_MODE ; } if ( ! TARGET_H8300S && TARGET_EXR ) { error ( <STR_LIT> ) ; target_flags |= MASK_H8300S_1 ; } if ( TARGET_H8300 && TARGET_INT32 ) { error ( <STR_LIT> ) ; target_flags ^= MASK_INT32 ; } if ( ( ! TARGET_H8300S && TARGET_EXR ) && ( ! TARGET_H8300SX && TARGET_EXR ) ) { error ( <STR_LIT> ) ; target_flags |= MASK_H8300S_1 ; } if ( ( ! TARGET_H8300S && TARGET_NEXR ) && ( ! TARGET_H8300SX && TARGET_NEXR ) ) { warning ( OPT_mno_exr , <STR_LIT> ) ; } if ( ( TARGET_NORMAL_MODE ) ) { error ( <STR_LIT> ) ; target_flags ^= MASK_NORMAL_MODE ; } if ( optimize_size ) { shift_alg_hi [ H8_300 ] [ SHIFT_ASHIFT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_300 ] [ SHIFT_ASHIFT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_300 ] [ SHIFT_ASHIFT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_300 ] [ SHIFT_ASHIFT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_300 ] [ SHIFT_LSHIFTRT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_300 ] [ SHIFT_LSHIFTRT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_300 ] [ SHIFT_ASHIFTRT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_300 ] [ SHIFT_ASHIFTRT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_300H ] [ SHIFT_ASHIFT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_300H ] [ SHIFT_ASHIFT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_300H ] [ SHIFT_LSHIFTRT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_300H ] [ SHIFT_LSHIFTRT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_300H ] [ SHIFT_ASHIFTRT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_300H ] [ SHIFT_ASHIFTRT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_300H ] [ SHIFT_ASHIFTRT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_300H ] [ SHIFT_ASHIFTRT ] [ <NUM_LIT> ] = SHIFT_LOOP ; shift_alg_hi [ H8_S ] [ SHIFT_ASHIFTRT ] [ <NUM_LIT> ] = SHIFT_LOOP ; } if ( ! TARGET_H8300SX ) { h8300_move_ratio = <NUM_LIT> ;


<s> case - <NUM_LIT> : * total = <NUM_LIT> + ( outer_code == SET ) ; return true ; case <NUM_LIT> : case - <NUM_LIT> : if ( TARGET_H8300H || TARGET_H8300S ) * total = <NUM_LIT> + ( outer_code == SET ) ; else * total = <NUM_LIT> ; return true ; } } * total = <NUM_LIT> ; return true ; } case CONST : case LABEL_REF : case SYMBOL_REF : if ( TARGET_H8300SX ) { * total = <NUM_LIT> ; return true ; } * total = <NUM_LIT> ; return true ; case CONST_DOUBLE : * total = <NUM_LIT> ; return true ; case COMPARE : if ( XEXP ( x , <NUM_LIT> ) == const0_rtx ) * total = <NUM_LIT> ; return false ; case AND : if ( ! h8300_dst_operand ( XEXP ( x , <NUM_LIT> ) , VOIDmode ) || ! h8300_src_operand ( XEXP ( x , <NUM_LIT> ) , VOIDmode ) ) return false ; * total = COSTS_N_INSNS ( h8300_and_costs ( x ) ) ; return true ; case MOD : case DIV : case UMOD : case UDIV : if ( TARGET_H8300SX ) switch ( GET_MODE ( x ) ) { case QImode : case HImode : * total = COSTS_N_INSNS ( ! speed ? <NUM_LIT> : <NUM_LIT> ) ; return false ; case SImode : * total = COSTS_N_INSNS ( ! speed ? <NUM_LIT> : <NUM_LIT> ) ; return false ; default : break ; } * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case MULT : if ( TARGET_H8300SX ) switch ( GET_MODE ( x ) ) { case QImode : case HImode : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return false ; case SImode : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return false ; default : break ; } * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case ASHIFT : case ASHIFTRT : case LSHIFTRT : if ( h8sx_binary_shift_operator ( x , VOIDmode ) ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return false ; } else if ( h8sx_unary_shift_operator ( x , VOIDmode ) ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return false ; } * total = COSTS_N_INSNS ( h8300_shift_costs ( x ) ) ; return true ; case ROTATE : case ROTATERT : if ( GET_MODE ( x ) == HImode ) * total = <NUM_LIT> ; else * total = <NUM_LIT> ; return true ; default :


<s> void h8300_swap_into_er6 ( rtx addr ) { rtx insn = push ( HARD_FRAME_POINTER_REGNUM , false ) ;

if ( frame_pointer_needed ) add_reg_note ( insn , REG_CFA_DEF_CFA , plus_constant ( Pmode , gen_rtx_MEM ( Pmode , stack_pointer_rtx ) , <NUM_LIT> * UNITS_PER_WORD ) ) ;


<s> void h8300_swap_into_er6 ( rtx addr ) { rtx insn = push ( HARD_FRAME_POINTER_REGNUM , false ) ; if ( frame_pointer_needed ) add_reg_note ( insn , REG_CFA_DEF_CFA , plus_constant ( Pmode , gen_rtx_MEM ( Pmode , stack_pointer_rtx ) , <NUM_LIT> * UNITS_PER_WORD ) ) ; else add_reg_note ( insn , REG_CFA_ADJUST_CFA , gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> ) ) ) ; emit_move_insn ( hard_frame_pointer_rtx , addr ) ; if ( REGNO ( addr ) == SP_REG ) emit_move_insn ( hard_frame_pointer_rtx , plus_constant ( Pmode , hard_frame_pointer_rtx , GET_MODE_SIZE ( word_mode ) ) ) ;


<s> rtx insn ; if ( REGNO ( addr ) != SP_REG ) emit_move_insn ( addr , hard_frame_pointer_rtx ) ; insn = pop ( HARD_FRAME_POINTER_REGNUM ) ; if ( frame_pointer_needed ) add_reg_note ( insn , REG_CFA_DEF_CFA , plus_constant ( Pmode , hard_frame_pointer_rtx , <NUM_LIT> * UNITS_PER_WORD ) ) ; else add_reg_note ( insn , REG_CFA_ADJUST_CFA , gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - <NUM_LIT> ) ) ) ;


<s> else add_reg_note ( insn , REG_CFA_ADJUST_CFA , gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - <NUM_LIT> ) ) ) ;


<s> else if ( GET_CODE ( addr1 ) == PLUS && REG_P ( XEXP ( addr1 , <NUM_LIT> ) ) && GET_CODE ( XEXP ( addr1 , <NUM_LIT> ) ) == CONST_INT ) { reg1 = XEXP ( addr1 , <NUM_LIT> ) ; offset1 = INTVAL ( XEXP ( addr1 , <NUM_LIT> ) ) ; } else return <NUM_LIT> ; if ( REG_P ( addr2 ) ) { reg2 = addr2 ; offset2 = <NUM_LIT> ; } else if ( GET_CODE ( addr2 ) == PLUS && REG_P ( XEXP ( addr2 , <NUM_LIT> ) ) && GET_CODE ( XEXP ( addr2 , <NUM_LIT> ) ) == CONST_INT ) { reg2 = XEXP ( addr2 , <NUM_LIT> ) ;

offset2 = INTVAL ( XEXP ( addr2 , <NUM_LIT> ) ) ;


<s> reg1 = XEXP ( addr1 , <NUM_LIT> ) ; offset1 = INTVAL ( XEXP ( addr1 , <NUM_LIT> ) ) ; } else return <NUM_LIT> ; if ( REG_P ( addr2 ) ) { reg2 = addr2 ; offset2 = <NUM_LIT> ; } else if ( GET_CODE ( addr2 ) == PLUS && REG_P ( XEXP ( addr2 , <NUM_LIT> ) ) && GET_CODE ( XEXP ( addr2 , <NUM_LIT> ) ) == CONST_INT ) { reg2 = XEXP ( addr2 , <NUM_LIT> ) ;


return names_small [ REGNO ( x ) * <NUM_LIT> + b ] ;


<s> if ( ( mode == HImode && TARGET_H8300H && amount >= <NUM_LIT> ) || ( mode == HImode && TARGET_H8300S && amount == <NUM_LIT> ) || ( mode == SImode && TARGET_H8300H && amount >= <NUM_LIT> ) || ( mode == SImode && TARGET_H8300S && amount >= <NUM_LIT> ) ) { amount = GET_MODE_BITSIZE ( mode ) / <NUM_LIT> - amount ; length += <NUM_LIT> ; } if ( TARGET_H8300S ) amount = amount / <NUM_LIT> + amount % <NUM_LIT> ;


<s> break ; case E_HImode : shift_mode = HIshift ; break ; case E_SImode : shift_mode = SIshift ; break ; default : gcc_unreachable ( ) ; } switch ( code ) { case ASHIFTRT : shift_type = SHIFT_ASHIFTRT ; break ; case LSHIFTRT : shift_type = SHIFT_LSHIFTRT ; break ; case ASHIFT : shift_type = SHIFT_ASHIFT ; break ; default : gcc_unreachable ( ) ; } gcc_assert ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT ) ; n = INTVAL ( operands [ <NUM_LIT> ] ) ; if ( n < <NUM_LIT> ) n = <NUM_LIT> ; else if ( ( unsigned int ) n > GET_MODE_BITSIZE ( mode ) ) n = GET_MODE_BITSIZE ( mode ) ; get_shift_alg ( shift_type , shift_mode , n , & info ) ; switch ( info . alg ) { case SHIFT_SPECIAL : if ( info . remainder == <NUM_LIT> ) return ( info . cc_special == OLD_CC_SET_ZN || info . cc_special == OLD_CC_SET_ZNV ) ; case SHIFT_INLINE : return ( info . cc_inline == OLD_CC_SET_ZN || info . cc_inline == OLD_CC_SET_ZNV ) ; case SHIFT_ROT_AND :


<s> n = info . remainder ; if ( info . shift2 != NULL ) { wlength += h8300_asm_insn_count ( info . shift2 ) * ( n / <NUM_LIT> ) ; n = n % <NUM_LIT> ; } wlength += h8300_asm_insn_count ( info . shift1 ) * n ; return <NUM_LIT> * wlength ; case SHIFT_ROT_AND : { int m = GET_MODE_BITSIZE ( mode ) - n ; gcc_assert ( info . shift1 ) ; if ( info . shift2 != NULL ) { wlength += h8300_asm_insn_count ( info . shift2 ) * ( m / <NUM_LIT> ) ; m = m % <NUM_LIT> ; } wlength += h8300_asm_insn_count ( info . shift1 ) * m ; switch ( mode ) { case E_QImode : wlength += <NUM_LIT> ; break ; case E_HImode : wlength += <NUM_LIT> ; break ; case E_SImode : wlength += <NUM_LIT> ; break ; default : gcc_unreachable ( ) ; } return <NUM_LIT> * wlength ; }


<s> if ( ( TARGET_H8300H || TARGET_H8300S ) && b0 != <NUM_LIT> && b1 != <NUM_LIT> ) { cc = CC_SET_ZNV ; } break ; case E_SImode : if ( TARGET_H8300H || TARGET_H8300S ) { lower_half_easy_p = ( b0 == <NUM_LIT> || b1 == <NUM_LIT> || ( code != IOR && w0 == <NUM_LIT> ) ) ; upper_half_easy_p = ( ( code != IOR && w1 == <NUM_LIT> ) || ( code == AND && w1 == <NUM_LIT> ) ) ; } if ( ( TARGET_H8300H || TARGET_H8300S ) && w0 != <NUM_LIT> && w1 != <NUM_LIT> && ! ( lower_half_easy_p && upper_half_easy_p ) && ! ( code == IOR && w1 == <NUM_LIT> && ( w0 & <NUM_LIT> ) != <NUM_LIT> && lower_half_easy_p ) ) { cc = CC_SET_ZNV ; } else {

if ( ( TARGET_H8300H || TARGET_H8300S ) && code == IOR && w1 == <NUM_LIT> && ( w0 & <NUM_LIT> ) != <NUM_LIT> ) {


<s> const unsigned HOST_WIDE_INT b0 = ( det >> <NUM_LIT> ) & <NUM_LIT> ; const unsigned HOST_WIDE_INT b1 = ( det >> <NUM_LIT> ) & <NUM_LIT> ; const unsigned HOST_WIDE_INT w0 = ( det >> <NUM_LIT> ) & <NUM_LIT> ; const unsigned HOST_WIDE_INT w1 = ( det >> <NUM_LIT> ) & <NUM_LIT> ; int lower_half_easy_p = <NUM_LIT> ; int upper_half_easy_p = <NUM_LIT> ; enum attr_cc cc = CC_CLOBBER ; switch ( mode ) { case E_HImode : if ( ( TARGET_H8300H || TARGET_H8300S ) && b0 != <NUM_LIT> && b1 != <NUM_LIT> ) { cc = CC_SET_ZNV ; } break ; case E_SImode : if ( TARGET_H8300H || TARGET_H8300S ) { lower_half_easy_p = ( b0 == <NUM_LIT> || b1 == <NUM_LIT> || ( code != IOR && w0 == <NUM_LIT> ) ) ; upper_half_easy_p = ( ( code != IOR && w1 == <NUM_LIT> ) || ( code == AND && w1 == <NUM_LIT> ) ) ; } if ( ( TARGET_H8300H || TARGET_H8300S ) && w0 != <NUM_LIT> && w1 != <NUM_LIT> && ! ( lower_half_easy_p && upper_half_easy_p ) && ! ( code == IOR && w1 == <NUM_LIT> && ( w0 & <NUM_LIT> ) != <NUM_LIT> && lower_half_easy_p ) ) { cc = CC_SET_ZNV ;


<s> cc_meaningful = ( GET_CODE ( second_op ) != CLOBBER ) ; } switch ( mode ) { case E_QImode : return <NUM_LIT> ; case E_HImode : if ( cc_meaningful || ( b0 != <NUM_LIT> && b1 != <NUM_LIT> ) ) { length = h8300_length_from_table ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , & logicw_length_table ) ; } else { if ( b0 != <NUM_LIT> ) length += <NUM_LIT> ; if ( b1 != <NUM_LIT> ) length += <NUM_LIT> ; } break ; case E_SImode : lower_half_easy_p = ( b0 == <NUM_LIT> || b1 == <NUM_LIT> || ( code != IOR && w0 == <NUM_LIT> ) ) ; upper_half_easy_p = ( ( code != IOR && w1 == <NUM_LIT> ) || ( code == AND && w1 == <NUM_LIT> ) ) ; if ( cc_meaningful || ( w0 != <NUM_LIT> && w1 != <NUM_LIT> && ! ( lower_half_easy_p && upper_half_easy_p ) && ! ( code == IOR && w1 == <NUM_LIT> && ( w0 & <NUM_LIT> ) != <NUM_LIT> && lower_half_easy_p ) ) ) { length = h8300_length_from_table ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , & logicl_length_table ) ; } else { if ( w0 == <NUM_LIT> && ( code != IOR ) ) { length += <NUM_LIT> ;


<s> machine_mode mode = GET_MODE ( operands [ <NUM_LIT> ] ) ; rtx dest = operands [ <NUM_LIT> ] ; rtx src = operands [ <NUM_LIT> ] ; rtx addr ; if ( GET_CODE ( src ) == MEM ) addr = XEXP ( src , <NUM_LIT> ) ; else if ( GET_CODE ( dest ) == MEM ) addr = XEXP ( dest , <NUM_LIT> ) ; else addr = NULL_RTX ; unsigned int base_length ; switch ( mode ) { case E_QImode : if ( addr == NULL_RTX ) return <NUM_LIT> ; if ( h8300_eightbit_constant_address_p ( addr ) ) return <NUM_LIT> ; base_length = <NUM_LIT> ; break ; case E_HImode : if ( addr == NULL_RTX ) { if ( REG_P ( src ) ) return <NUM_LIT> ; if ( src == const0_rtx ) return <NUM_LIT> ; return <NUM_LIT> ; } base_length = <NUM_LIT> ; break ; case E_SImode : if ( addr == NULL_RTX ) { if ( REG_P ( src ) ) { if ( REGNO ( src ) == MAC_REG || REGNO ( dest ) == MAC_REG ) return <NUM_LIT> ; else return <NUM_LIT> ; } if ( GET_CODE ( src ) == CONST_INT ) { int val = INTVAL ( src ) ; if ( val == <NUM_LIT> ) return <NUM_LIT> ; if ( val == ( val & <NUM_LIT> ) || val == ( val & <NUM_LIT> ) ) return <NUM_LIT> ; switch ( val & <NUM_LIT> ) { case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : return <NUM_LIT> ; } } return <NUM_LIT> ;


<s> unsigned int compute_plussi_length ( rtx * operands , bool need_flags ) { machine_mode mode = GET_MODE ( operands [ <NUM_LIT> ] ) ; gcc_assert ( mode == SImode ) ; if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT && register_operand ( operands [ <NUM_LIT> ] , VOIDmode ) ) { HOST_WIDE_INT intval = INTVAL ( operands [ <NUM_LIT> ] ) ;

if ( TARGET_H8300SX && ( intval >= <NUM_LIT> && intval <= <NUM_LIT> ) ) return <NUM_LIT> ;


<s> unsigned int saved_regs = <NUM_LIT> ; int regno ; for ( regno = <NUM_LIT> ; regno <= HARD_FRAME_POINTER_REGNUM ; regno ++ ) {

if ( WORD_REG_USED ( regno ) ) saved_regs |= <NUM_LIT> << regno ;


<s> return <STR_LIT> ; case LE : return <STR_LIT> ; case LT : return <STR_LIT> ; case GEU : return <STR_LIT> ; case GTU : return <STR_LIT> ; case LEU : return <STR_LIT> ;


<s> rtx dst = operands [ <NUM_LIT> ] ; rtx src = operands [ <NUM_LIT> ] ; rtx rotate_amount = operands [ <NUM_LIT> ] ; machine_mode mode = GET_MODE ( dst ) ; if ( h8sx_classify_shift ( mode , ROTATE , rotate_amount ) == H8SX_SHIFT_UNARY ) return false ; emit_move_insn ( dst , src ) ; if ( GET_CODE ( rotate_amount ) != CONST_INT ) { rtx counter = gen_reg_rtx ( QImode ) ; rtx_code_label * start_label = gen_label_rtx ( ) ; rtx_code_label * end_label = gen_label_rtx ( ) ; emit_cmp_and_jump_insns ( rotate_amount , const0_rtx , LE , NULL_RTX , QImode , <NUM_LIT> , end_label ) ; emit_move_insn ( counter , rotate_amount ) ;


<s> return false ; case H8SX_SHIFT_UNARY : return false ; case H8SX_SHIFT_NONE : break ; } emit_move_insn ( copy_rtx ( operands [ <NUM_LIT> ] ) , operands [ <NUM_LIT> ] ) ; if ( operands [ <NUM_LIT> ] == CONST0_RTX ( QImode ) ) ;

else if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT && ! h8300_shift_needs_scratch_p ( INTVAL ( operands [ <NUM_LIT> ] ) , mode , code ) ) emit_insn ( gen_rtx_SET ( copy_rtx ( operands [ <NUM_LIT> ] ) , gen_rtx_fmt_ee ( code , mode , copy_rtx ( operands [ <NUM_LIT> ] ) , operands [ <NUM_LIT> ] ) ) ) ;


<s> emit_move_insn ( copy_rtx ( operands [ <NUM_LIT> ] ) , operands [ <NUM_LIT> ] ) ; if ( operands [ <NUM_LIT> ] == CONST0_RTX ( QImode ) ) ; else if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT && ! h8300_shift_needs_scratch_p ( INTVAL ( operands [ <NUM_LIT> ] ) , mode , code ) ) emit_insn ( gen_rtx_SET ( copy_rtx ( operands [ <NUM_LIT> ] ) , gen_rtx_fmt_ee ( code , mode , copy_rtx ( operands [ <NUM_LIT> ] ) , operands [ <NUM_LIT> ] ) ) ) ; else emit_insn ( gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , gen_rtx_SET ( copy_rtx ( operands [ <NUM_LIT> ] ) , gen_rtx_fmt_ee ( code , mode , copy_rtx ( operands [ <NUM_LIT> ] ) , operands [ <NUM_LIT> ] ) ) , gen_rtx_CLOBBER ( VOIDmode , gen_rtx_SCRATCH ( QImode ) ) ) ) ) ; return true ;


<s> static int last_insn_address = <NUM_LIT> ; const int uid = INSN_UID ( insn ) ; if ( TARGET_ADDRESSES ) { fprintf ( asm_out_file , <STR_LIT> , INSN_ADDRESSES ( uid ) , INSN_ADDRESSES ( uid ) - last_insn_address ) ;

last_insn_address = INSN_ADDRESSES ( uid ) ;


<s> if ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM && ! satisfies_constraint_U ( operands [ <NUM_LIT> ] ) ) { rtx mem = gen_rtx_MEM ( GET_MODE ( operands [ <NUM_LIT> ] ) , copy_to_mode_reg ( Pmode , XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) ) ; MEM_COPY_ATTRIBUTES ( mem , operands [ <NUM_LIT> ] ) ; operands [ <NUM_LIT> ] = mem ; } return <NUM_LIT> ; } operands [ <NUM_LIT> ] = force_reg ( QImode , operands [ <NUM_LIT> ] ) ; { rtx res = gen_reg_rtx ( QImode ) ; switch ( code ) { case AND : emit_insn ( gen_andqi3_1 ( res , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ;


<s> int len = XVECLEN ( par , <NUM_LIT> ) ; int i ; for ( i = <NUM_LIT> ; i < len ; i ++ ) RTX_FRAME_RELATED_P ( XVECEXP ( par , <NUM_LIT> , i ) ) = <NUM_LIT> ;


<s> goto end ; } } else if ( ( count >= <NUM_LIT> && count <= <NUM_LIT> ) || ( TARGET_H8300S && count == <NUM_LIT> ) ) { info -> remainder = count - <NUM_LIT> ; switch ( shift_type ) { case SHIFT_ASHIFT : info -> special = <STR_LIT> ; goto end ; case SHIFT_LSHIFTRT : info -> special = <STR_LIT> ; info -> cc_special = OLD_CC_SET_ZNV ; goto end ; case SHIFT_ASHIFTRT : info -> special = <STR_LIT> ; info -> cc_special = OLD_CC_SET_ZNV ; goto end ; } } else if ( count == <NUM_LIT> ) { switch ( shift_type ) { case SHIFT_ASHIFT : case SHIFT_LSHIFTRT : goto end ; goto end ; case SHIFT_ASHIFTRT : if ( TARGET_H8300H ) { info -> special = <STR_LIT> ; info -> cc_special = OLD_CC_SET_ZNV ; } else gcc_unreachable ( ) ; goto end ; } } else if ( count == <NUM_LIT> ) { switch ( shift_type ) { case SHIFT_ASHIFT : info -> special = <STR_LIT> ; goto end ; case SHIFT_LSHIFTRT : info -> special = <STR_LIT> ; goto end ; case SHIFT_ASHIFTRT : info -> special = <STR_LIT> ; goto end ; } } gcc_unreachable ( ) ; case SIshift : if ( count == <NUM_LIT> ) { switch ( shift_type ) { case SHIFT_ASHIFT : info -> special = <STR_LIT> ; goto end ; case SHIFT_LSHIFTRT : info -> special = <STR_LIT> ; goto end ; case SHIFT_ASHIFTRT : info -> special = <STR_LIT> ; goto end ; } } else if ( count == <NUM_LIT> ) { switch ( shift_type ) { case SHIFT_ASHIFT : info -> special = <STR_LIT> ; info -> cc_special = OLD_CC_SET_ZNV ; goto end ; case SHIFT_LSHIFTRT : info -> special = <STR_LIT> ; info -> cc_special = OLD_CC_SET_ZNV ; goto end ; case SHIFT_ASHIFTRT : info -> special = <STR_LIT> ; info -> cc_special = OLD_CC_SET_ZNV ; goto end ; } } else if ( count >= <NUM_LIT> && count <= <NUM_LIT> ) { info -> remainder = count - <NUM_LIT> ; switch ( shift_type ) { case SHIFT_ASHIFT : info -> special = <STR_LIT> ; goto end ; case SHIFT_LSHIFTRT : info -> special = <STR_LIT> ; info -> cc_special = OLD_CC_SET_ZNV ; goto end ; case SHIFT_ASHIFTRT : info -> special = <STR_LIT> ; info -> cc_special = OLD_CC_SET_ZNV ; goto end ; } }

else if ( TARGET_H8300S && count == <NUM_LIT> ) {


<s> operands [ <NUM_LIT> ] = NULL ; operands [ <NUM_LIT> ] = XEXP ( x , <NUM_LIT> ) ; operands [ <NUM_LIT> ] = XEXP ( x , <NUM_LIT> ) ; operands [ <NUM_LIT> ] = x ;

return compute_logical_op_length ( GET_MODE ( x ) , AND , operands , NULL ) / <NUM_LIT> ;


<s> operands [ <NUM_LIT> ] = XEXP ( x , <NUM_LIT> ) ; operands [ <NUM_LIT> ] = XEXP ( x , <NUM_LIT> ) ; operands [ <NUM_LIT> ] = x ;


<s> static unsigned int h8300_asm_insn_count ( const char * templ ) {


<s> static void h8300_asm_named_section ( const char * name , unsigned int flags ATTRIBUTE_UNUSED , tree decl ) { fprintf ( asm_out_file , <STR_LIT> , name ) ;


<s> rtx pattern ; if ( GET_CODE ( insn ) != INSN ) gcc_unreachable ( ) ; pattern = PATTERN ( insn ) ; if ( GET_CODE ( pattern ) == PARALLEL && GET_CODE ( XVECEXP ( pattern , <NUM_LIT> , <NUM_LIT> ) ) == SET && GET_CODE ( SET_SRC ( XVECEXP ( pattern , <NUM_LIT> , <NUM_LIT> ) ) ) == COMPARE ) set = XVECEXP ( pattern , <NUM_LIT> , <NUM_LIT> ) ; else set = single_set ( insn ) ; gcc_assert ( set ) ; if ( BINARY_P ( SET_SRC ( set ) ) ) return h8300_length_from_table ( XEXP ( SET_SRC ( set ) , <NUM_LIT> ) , XEXP ( SET_SRC ( set ) , <NUM_LIT> ) , table ) ;


<s> size = GET_MODE_SIZE ( GET_MODE ( op ) ) ; operand_length = h8300_classify_operand ( op , size , & opclass ) ; switch ( opclass ) { case H8OP_MEM_BASE :


<s> if ( GET_CODE ( op ) == REG ) op = op2 ; gcc_assert ( GET_CODE ( op ) != REG ) ; size = GET_MODE_SIZE ( GET_MODE ( op ) ) ; operand_length = h8300_classify_operand ( op , size , & opclass ) ; switch ( opclass ) { case H8OP_MEM_BASE : case H8OP_MEM_ABSOLUTE : case H8OP_MEM_COMPLEX :


<s> return ( to == STACK_POINTER_REGNUM ? ! frame_pointer_needed : true ) ;


<s> return ( reload_completed && ! frame_pointer_needed && get_frame_size ( ) == <NUM_LIT> && compute_saved_regs ( ) == <NUM_LIT> ) ;


<s> * opclass = H8OP_IMMEDIATE ; if ( size == <NUM_LIT> ) return <NUM_LIT> ; if ( TARGET_H8300SX && size == <NUM_LIT> && GET_CODE ( op ) == CONST_INT && IN_RANGE ( INTVAL ( op ) , <NUM_LIT> , <NUM_LIT> ) ) return <NUM_LIT> ; return size ; } else if ( GET_CODE ( op ) == MEM ) { op = XEXP ( op , <NUM_LIT> ) ; if ( CONSTANT_P ( op ) ) { * opclass = H8OP_MEM_ABSOLUTE ; return h8300_constant_length ( op ) ; } else if ( GET_CODE ( op ) == PLUS && CONSTANT_P ( XEXP ( op , <NUM_LIT> ) ) ) { * opclass = H8OP_MEM_COMPLEX ; return h8300_displacement_length ( op , size ) ; } else if ( GET_RTX_CLASS ( GET_CODE ( op ) ) == RTX_AUTOINC ) { * opclass = H8OP_MEM_COMPLEX ; return <NUM_LIT> ; } else if ( register_operand ( op , VOIDmode ) ) { * opclass = H8OP_MEM_BASE ; return <NUM_LIT> ;


<s> if ( GET_CODE ( constant ) == CONST_INT && IN_RANGE ( INTVAL ( constant ) , - <NUM_LIT> , <NUM_LIT> ) ) return <NUM_LIT> ; if ( Pmode == HImode || h8300_tiny_constant_address_p ( constant ) ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> if ( Pmode == HImode || h8300_tiny_constant_address_p ( constant ) ) return <NUM_LIT> ; return <NUM_LIT> ;


return ( h8300_monitor_function_p ( current_function_decl ) ) ;


<s> if ( GET_CODE ( x ) == SYMBOL_REF ) return ( SYMBOL_REF_FLAGS ( x ) & SYMBOL_FLAG_EIGHTBIT_DATA ) != <NUM_LIT> ; if ( GET_CODE ( x ) == CONST && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF && ( SYMBOL_REF_FLAGS ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) & SYMBOL_FLAG_EIGHTBIT_DATA ) != <NUM_LIT> ) return <NUM_LIT> ;

if ( GET_CODE ( x ) != CONST_INT ) return <NUM_LIT> ;


<s> unsigned HOST_WIDE_INT addr ; if ( GET_CODE ( x ) == SYMBOL_REF ) return ( SYMBOL_REF_FLAGS ( x ) & SYMBOL_FLAG_EIGHTBIT_DATA ) != <NUM_LIT> ; if ( GET_CODE ( x ) == CONST && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF && ( SYMBOL_REF_FLAGS ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) & SYMBOL_FLAG_EIGHTBIT_DATA ) != <NUM_LIT> ) return <NUM_LIT> ; if ( GET_CODE ( x ) != CONST_INT ) return <NUM_LIT> ; addr = INTVAL ( x ) ;

return ( <NUM_LIT> || ( TARGET_NORMAL_MODE && IN_RANGE ( addr , n1 , n2 ) ) || ( TARGET_H8300H && IN_RANGE ( addr , h1 , h2 ) ) || ( TARGET_H8300S && IN_RANGE ( addr , s1 , s2 ) ) ) ;