<s> if ( num >= den ) { num -= den ; res |= bit ; } bit >>= <NUM_LIT> ; den >>= <NUM_LIT> ; } if ( modwanted ) return num ; return res ;


<s> USItype res = <NUM_LIT> ; while ( den < num && bit && ! ( den & ( <NUM_LIT> << <NUM_LIT> ) ) ) { den <<= <NUM_LIT> ; bit <<= <NUM_LIT> ; } while ( bit ) { if ( num >= den ) {


<s> if ( a < <NUM_LIT> ) { a = - a ; neg = ! neg ; } if ( b < <NUM_LIT> ) { b = - b ;


<s> word_type neg = <NUM_LIT> ; SItype res ; if ( a < <NUM_LIT> ) { a = - a ;


<s> neg = <NUM_LIT> ; } if ( b < <NUM_LIT> ) b = - b ; res = udivmodsi4 ( a , b , <NUM_LIT> ) ;


<s> return udivmodsi4 ( a , b , <NUM_LIT> ) ;


<s> SItype __umodsi3 ( SItype a , SItype b ) {

return udivmodsi4 ( a , b , <NUM_LIT> ) ;


<s> void m32c_register_pragmas ( void ) { c_register_pragma ( <STR_LIT> , <STR_LIT> , m32c_pragma_memregs ) ;


<s> void m32c_register_pragmas ( void ) {


<s> static int classes_intersect ( int class1 , int class2 ) {


<s> if ( results [ class ] [ mode ] == <NUM_LIT> ) { int r , n , i ; results [ class ] [ mode ] = <NUM_LIT> ;

for ( r = <NUM_LIT> ; r < FIRST_PSEUDO_REGISTER ; r ++ ) if ( class_contents [ class ] [ <NUM_LIT> ] & ( <NUM_LIT> << r ) && HARD_REGNO_MODE_OK ( r , mode ) ) {


<s> case LO_SUM : * patternp ++ = 'L' ; encode_pattern_1 ( XEXP ( x , <NUM_LIT> ) ) ; encode_pattern_1 ( XEXP ( x , <NUM_LIT> ) ) ; break ; case HIGH : * patternp ++ = 'H' ; encode_pattern_1 ( XEXP ( x , <NUM_LIT> ) ) ; break ; case SYMBOL_REF : * patternp ++ = 's' ; break ; case LABEL_REF : * patternp ++ = 'l' ; break ; case CODE_LABEL : * patternp ++ = 'c' ; break ; case CONST_INT : case CONST_DOUBLE : * patternp ++ = 'i' ; break ; case UNSPEC : * patternp ++ = 'u' ; * patternp ++ = '0' + XCINT ( x , <NUM_LIT> , UNSPEC ) ; for ( i = <NUM_LIT> ; i < XVECLEN ( x , <NUM_LIT> ) ; i ++ ) encode_pattern_1 ( XVECEXP ( x , <NUM_LIT> , i ) ) ; break ; case USE : * patternp ++ = 'U' ; break ; case PARALLEL : * patternp ++ = '|' ; for ( i = <NUM_LIT> ; i < XVECLEN ( x , <NUM_LIT> ) ; i ++ ) encode_pattern_1 ( XVECEXP ( x , <NUM_LIT> , i ) ) ;


<s> break ; case SYMBOL_REF : * patternp ++ = 's' ; break ; case LABEL_REF : * patternp ++ = 'l' ; break ; case CODE_LABEL : * patternp ++ = 'c' ; break ; case CONST_INT : case CONST_DOUBLE : * patternp ++ = 'i' ; break ; case UNSPEC : * patternp ++ = 'u' ; * patternp ++ = '0' + XCINT ( x , <NUM_LIT> , UNSPEC ) ; for ( i = <NUM_LIT> ; i < XVECLEN ( x , <NUM_LIT> ) ; i ++ ) encode_pattern_1 ( XVECEXP ( x , <NUM_LIT> , i ) ) ; break ; case USE : * patternp ++ = 'U' ; break ; case PARALLEL : * patternp ++ = '|' ; for ( i = <NUM_LIT> ; i < XVECLEN ( x , <NUM_LIT> ) ; i ++ ) encode_pattern_1 ( XVECEXP ( x , <NUM_LIT> , i ) ) ; break ; case EXPR_LIST : * patternp ++ = 'E' ;

encode_pattern_1 ( XEXP ( x , <NUM_LIT> ) ) ;


<s> if ( to == QImode ) return ( class_contents [ rclass ] [ <NUM_LIT> ] & <NUM_LIT> ) ; if ( class_contents [ rclass ] [ <NUM_LIT> ] & <NUM_LIT> && GET_MODE_SIZE ( from ) > <NUM_LIT> ) return <NUM_LIT> ; if ( GET_MODE_SIZE ( from ) > <NUM_LIT> ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> if ( regclass == A_REGS ) return <NUM_LIT> ; return reg_class_size [ regclass ] == <NUM_LIT> ;


<s> int m32c_class_likely_spilled_p ( int regclass ) { if ( regclass == A_REGS ) return <NUM_LIT> ;

return reg_class_size [ regclass ] == <NUM_LIT> ;


<s> for ( rn = <NUM_LIT> ; rn < FIRST_PSEUDO_REGISTER ; rn ++ ) if ( class_contents [ regclass ] [ <NUM_LIT> ] & ( <NUM_LIT> << rn ) ) { int n = m32c_hard_regno_nregs ( rn , mode ) ; if ( max < n ) max = n ; }


<s> if ( <NUM_LIT> <= target_memregs && target_memregs <= <NUM_LIT> ) { for ( i = target_memregs / <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) {

fixed_regs [ MEM0_REGNO + i ] = <NUM_LIT> ;


<s> if ( memcmp ( str , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) { return ( <NUM_LIT> <= value && value <= <NUM_LIT> ) ; } if ( memcmp ( str , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) { return ( - <NUM_LIT> <= value && value && value <= <NUM_LIT> ) ; } if ( memcmp ( str , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) { return ( - <NUM_LIT> <= value && value && value <= <NUM_LIT> ) ; } if ( memcmp ( str , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) { return ( - <NUM_LIT> <= value && value && value <= - <NUM_LIT> ) ; } if ( memcmp ( str , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) { int b = exact_log2 ( value ) ; return ( b >= <NUM_LIT> && b <= <NUM_LIT> ) ; } if ( memcmp ( str , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) {


<s> int m32c_eh_return_data_regno ( int n ) { switch ( n ) { case <NUM_LIT> : return A0_REGNO ; case <NUM_LIT> : return A1_REGNO ;


<s> rtx sa ; sa = gen_reg_rtx ( Pmode ) ; cfun -> machine -> eh_stack_adjust = sa ; }

return cfun -> machine -> eh_stack_adjust ;


<s> cfun -> machine -> eh_stack_adjust = sa ; }


<s> if ( TARGET_A16 ) emit_insn ( gen_pophi_16 ( gen_rtx_REG ( HImode , FP_REGNO ) ) ) ; else emit_insn ( gen_poppsi ( gen_rtx_REG ( PSImode , FP_REGNO ) ) ) ; emit_insn ( gen_popm ( GEN_INT ( cfun -> machine -> intr_pushm ) ) ) ;


<s> if ( extra_frame_size ) { complex_prologue = <NUM_LIT> ; if ( TARGET_A16 ) F ( emit_insn ( gen_addhi3 ( gen_rtx_REG ( HImode , SP_REGNO ) , gen_rtx_REG ( HImode , SP_REGNO ) , GEN_INT ( - extra_frame_size ) ) ) ) ; else F ( emit_insn ( gen_addpsi3 ( gen_rtx_REG ( PSImode , SP_REGNO ) , gen_rtx_REG ( PSImode , SP_REGNO ) , GEN_INT ( - extra_frame_size ) ) ) ) ; } complex_prologue += m32c_pushm_popm ( PP_pushm ) ;

if ( complex_prologue ) emit_insn ( gen_prologue_end ( ) ) ;


<s> if ( interrupt_p ( cfun -> decl ) ) emit_insn ( gen_pushm ( GEN_INT ( cfun -> machine -> intr_pushm ) ) ) ; frame_size = m32c_initial_elimination_offset ( FB_REGNO , SP_REGNO ) - reg_save_size ; if ( frame_size == <NUM_LIT> && ! cfun -> machine -> is_interrupt && ! m32c_function_needs_enter ( ) ) cfun -> machine -> use_rts = <NUM_LIT> ; if ( frame_size > <NUM_LIT> ) { extra_frame_size = frame_size - <NUM_LIT> ; frame_size = <NUM_LIT> ; } if ( cfun -> machine -> use_rts == <NUM_LIT> ) F ( emit_insn ( m32c_all_frame_related ( TARGET_A16 ? gen_prologue_enter_16 ( GEN_INT ( frame_size ) ) : gen_prologue_enter_24 ( GEN_INT ( frame_size ) ) ) ) ) ; if ( extra_frame_size ) { complex_prologue = <NUM_LIT> ; if ( TARGET_A16 ) F ( emit_insn ( gen_addhi3 ( gen_rtx_REG ( HImode , SP_REGNO ) , gen_rtx_REG ( HImode , SP_REGNO ) , GEN_INT ( - extra_frame_size ) ) ) ) ; else F ( emit_insn ( gen_addpsi3 ( gen_rtx_REG ( PSImode , SP_REGNO ) , gen_rtx_REG ( PSImode , SP_REGNO ) , GEN_INT ( - extra_frame_size ) ) ) ) ;


<s> int m32c_extra_address_constraint ( char c , const char * str ATTRIBUTE_UNUSED ) {


<s> int m32c_extra_address_constraint ( char c , const char * str ATTRIBUTE_UNUSED ) { return c == 'A' ;


<s> fprintf ( stderr , <STR_LIT> , CONSTRAINT_LEN ( c , str ) , str , rv ) ; debug_rtx ( value ) ;


<s> return ( RTX_IS ( <STR_LIT> ) || RTX_IS ( <STR_LIT> ) || RTX_IS ( <STR_LIT> ) ) ; } else if ( memcmp ( str , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) { return ( ( RTX_IS ( <STR_LIT> ) && ( IS_REG ( patternr [ <NUM_LIT> ] , SP_REGNO ) ) ) || ( RTX_IS ( <STR_LIT> ) && ( IS_REG ( patternr [ <NUM_LIT> ] , SP_REGNO ) ) ) ) ; } else if ( memcmp ( str , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) { return ( ( RTX_IS ( <STR_LIT> ) && ( IS_REG ( patternr [ <NUM_LIT> ] , FB_REGNO ) ) ) || ( RTX_IS ( <STR_LIT> ) && ( IS_REG ( patternr [ <NUM_LIT> ] , FB_REGNO ) ) ) ) ; } else if ( memcmp ( str , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) { return ( ( RTX_IS ( <STR_LIT> ) && ( IS_REG ( patternr [ <NUM_LIT> ] , SB_REGNO ) ) ) || ( RTX_IS ( <STR_LIT> ) && ( IS_REG ( patternr [ <NUM_LIT> ] , SB_REGNO ) ) ) ) ; } else if ( memcmp ( str , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) {


<s> int m32c_extra_memory_constraint ( char c , const char * str ATTRIBUTE_UNUSED ) { return c == 'S' ;


<s> if ( mode == VOIDmode ) return GEN_INT ( <NUM_LIT> ) ; if ( ca -> force_mem || ! named ) { fprintf ( stderr , <STR_LIT> , ca -> force_mem , named ) ; return NULL_RTX ; } if ( type && INTEGRAL_TYPE_P ( type ) && POINTER_TYPE_P ( type ) ) return NULL_RTX ;


<s> fprintf ( stderr , <STR_LIT> , ca -> parm_num , mode_name [ mode ] , named ) ; debug_tree ( type ) ; if ( mode == VOIDmode ) return GEN_INT ( <NUM_LIT> ) ; if ( ca -> force_mem || ! named ) { fprintf ( stderr , <STR_LIT> , ca -> force_mem , named ) ; return NULL_RTX ; } if ( type && INTEGRAL_TYPE_P ( type ) && POINTER_TYPE_P ( type ) ) return NULL_RTX ; switch ( ca -> parm_num ) { case <NUM_LIT> : if ( GET_MODE_SIZE ( mode ) == <NUM_LIT> || GET_MODE_SIZE ( mode ) == <NUM_LIT> ) rv = gen_rtx_REG ( mode , TARGET_A16 ? R1_REGNO : R0_REGNO ) ;


<s> rtx sp = gen_rtx_REG ( Pmode , SP_REGNO ) ; rtx fb = gen_rtx_REG ( Pmode , FB_REGNO ) ; insn = get_insns ( ) ; for ( seq = cfun -> emit -> sequence_stack ; seq ; insn = seq -> first , seq = seq -> next ) ; while ( insn ) { if ( reg_mentioned_p ( sp , insn ) ) return true ; if ( reg_mentioned_p ( fb , insn ) ) return true ;


<s> for ( seq = cfun -> emit -> sequence_stack ; seq ; insn = seq -> first , seq = seq -> next ) ; while ( insn ) { if ( reg_mentioned_p ( sp , insn ) ) return true ; if ( reg_mentioned_p ( fb , insn ) ) return true ;


<s> enum machine_mode mode = TYPE_MODE ( valtype ) ;


<s> static bool m32c_handle_option ( size_t code , const char * arg ATTRIBUTE_UNUSED , int value ATTRIBUTE_UNUSED ) { if ( code == OPT_memregs_ ) { target_memregs_set = TRUE ; target_memregs = atoi ( arg ) ; } return TRUE ;


<s> static bool m32c_handle_option ( size_t code , const char * arg ATTRIBUTE_UNUSED , int value ATTRIBUTE_UNUSED ) { if ( code == OPT_memregs_ ) { target_memregs_set = TRUE ;


<s> if ( GET_MODE_SIZE ( mode ) <= <NUM_LIT> ) return nregs_table [ regno ] . hi_regs ; if ( regno == A0_REGNO && mode == PSImode && TARGET_A16 ) return <NUM_LIT> ;

if ( ( GET_MODE_SIZE ( mode ) <= <NUM_LIT> || mode == PSImode ) && TARGET_A24 ) return nregs_table [ regno ] . pi_regs ;


<s> int m32c_hard_regno_ok ( int regno , enum machine_mode mode ) { return m32c_hard_regno_nregs ( regno , mode ) != <NUM_LIT> ;


<s> int m32c_hard_regno_ok ( int regno , enum machine_mode mode ) {

return m32c_hard_regno_nregs ( regno , mode ) != <NUM_LIT> ;


<s> emit_move_insn ( A0 ( HImode , <NUM_LIT> ) , chainval ) ; emit_move_insn ( A0 ( QImode , <NUM_LIT> ) , GEN_INT ( <NUM_LIT> - <NUM_LIT> ) ) ; emit_move_insn ( A0 ( HImode , <NUM_LIT> ) , function ) ; emit_move_insn ( A0 ( QImode , <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) ) ;


<s> void m32c_init_cumulative_args ( CUMULATIVE_ARGS * ca , tree fntype ATTRIBUTE_UNUSED , rtx libname ATTRIBUTE_UNUSED , tree fndecl ATTRIBUTE_UNUSED , int n_named_args ATTRIBUTE_UNUSED ) { ca -> force_mem = <NUM_LIT> ; ca -> parm_num = <NUM_LIT> ;


<s> machine = ( machine_function * ) ggc_alloc_cleared ( sizeof ( machine_function ) ) ;


<s> static void m32c_insert_attributes ( tree node ATTRIBUTE_UNUSED , tree * attr_ptr ATTRIBUTE_UNUSED ) {


<s> case FB_REGNO : case SP_REGNO : return <NUM_LIT> ; default : if ( IS_PSEUDO ( patternr [ <NUM_LIT> ] , strict ) ) return <NUM_LIT> ; return <NUM_LIT> ; } } if ( RTX_IS ( <STR_LIT> ) ) { int rn = REGNO ( patternr [ <NUM_LIT> ] ) ; HOST_WIDE_INT offs = INTVAL ( patternr [ <NUM_LIT> ] ) ; switch ( rn ) { case A0_REGNO : case A1_REGNO : case SB_REGNO : if ( TARGET_A16 ) return ( offs >= - <NUM_LIT> && offs <= <NUM_LIT> - mode_adjust ) ; if ( rn == SB_REGNO ) return ( offs >= <NUM_LIT> && offs <= <NUM_LIT> - mode_adjust ) ; return ( offs >= - <NUM_LIT> && offs <= <NUM_LIT> ) ; case FB_REGNO : if ( TARGET_A16 ) return ( offs >= - <NUM_LIT> && offs <= <NUM_LIT> - mode_adjust ) ; return ( offs >= - <NUM_LIT> && offs <= <NUM_LIT> - mode_adjust ) ; case SP_REGNO : return ( offs >= - <NUM_LIT> && offs <= <NUM_LIT> - mode_adjust ) ; default : if ( IS_PSEUDO ( patternr [ <NUM_LIT> ] , strict ) ) return <NUM_LIT> ; return <NUM_LIT> ; } } if ( RTX_IS ( <STR_LIT> ) || RTX_IS ( <STR_LIT> ) ) { rtx reg = patternr [ <NUM_LIT> ] ; switch ( REGNO ( reg ) ) { case A0_REGNO : case A1_REGNO : return <NUM_LIT> ; default : if ( IS_PSEUDO ( reg , strict ) ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> if ( CONSTANT_P ( x ) ) return <NUM_LIT> ; mode_adjust = GET_MODE_SIZE ( mode ) - <NUM_LIT> ; if ( GET_CODE ( x ) == PRE_DEC || GET_CODE ( x ) == POST_INC || GET_CODE ( x ) == PRE_MODIFY ) { return ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == REG && REGNO ( XEXP ( x , <NUM_LIT> ) ) == SP_REGNO ) ; } if ( TARGET_A24 && GET_CODE ( x ) == MEM && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) != PLUS ) { fprintf ( stderr , <STR_LIT> ) ; x = XEXP ( x , <NUM_LIT> ) ; } encode_pattern ( x ) ; if ( RTX_IS ( <STR_LIT> ) ) { switch ( REGNO ( patternr [ <NUM_LIT> ] ) ) { case A0_REGNO : case A1_REGNO : case SB_REGNO : case FB_REGNO : case SP_REGNO : return <NUM_LIT> ; default : if ( IS_PSEUDO ( patternr [ <NUM_LIT> ] , strict ) ) return <NUM_LIT> ; return <NUM_LIT> ; } } if ( RTX_IS ( <STR_LIT> ) ) { int rn = REGNO ( patternr [ <NUM_LIT> ] ) ; HOST_WIDE_INT offs = INTVAL ( patternr [ <NUM_LIT> ] ) ; switch ( rn ) { case A0_REGNO : case A1_REGNO : case SB_REGNO : if ( TARGET_A16 ) return ( offs >= - <NUM_LIT> && offs <= <NUM_LIT> - mode_adjust ) ; if ( rn == SB_REGNO ) return ( offs >= <NUM_LIT> && offs <= <NUM_LIT> - mode_adjust ) ;

return ( offs >= - <NUM_LIT> && offs <= <NUM_LIT> ) ;


<s> fprintf ( stderr , <STR_LIT> , mode_name [ mode ] ) ; debug_rtx ( * x ) ; return <NUM_LIT> ;


<s> XVECEXP ( rv , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( HImode , R2_REGNO ) , GEN_INT ( <NUM_LIT> ) ) ; XVECEXP ( rv , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( HImode , R3_REGNO ) , GEN_INT ( <NUM_LIT> ) ) ; return rv ; } if ( TARGET_A24 && GET_MODE_SIZE ( mode ) > <NUM_LIT> ) { rtx rv ; rv = gen_rtx_PARALLEL ( mode , rtvec_alloc ( <NUM_LIT> ) ) ;

XVECEXP ( rv , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( mode , R0_REGNO ) , GEN_INT ( <NUM_LIT> ) ) ;


<s> fprintf ( stderr , <STR_LIT> , mode_name [ mode ] , class_names [ rclass ] ) ; if ( mode == QImode ) rclass = reduce_class ( rclass , HL_REGS , rclass ) ; else if ( mode == HImode ) rclass = reduce_class ( rclass , HI_REGS , rclass ) ; else if ( mode == SImode ) rclass = reduce_class ( rclass , SI_REGS , rclass ) ; if ( rclass != A_REGS ) rclass = reduce_class ( rclass , DI_REGS , rclass ) ; fprintf ( stderr , <STR_LIT> , class_names [ rclass ] ) ;


<s> fprintf ( stderr , <STR_LIT> , mode_name [ mode ] , class_names [ rclass ] ) ; if ( mode == QImode ) rclass = reduce_class ( rclass , HL_REGS , rclass ) ; else if ( mode == HImode ) rclass = reduce_class ( rclass , HI_REGS , rclass ) ; else if ( mode == SImode ) rclass = reduce_class ( rclass , SI_REGS , rclass ) ;

if ( rclass != A_REGS ) rclass = reduce_class ( rclass , DI_REGS , rclass ) ;


<s> if ( m1 == QImode || m2 == QImode ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> int m32c_mode_dependent_address ( rtx addr ) {

if ( GET_CODE ( addr ) == POST_INC || GET_CODE ( addr ) == PRE_DEC ) return <NUM_LIT> ;


<s> rtx op1 = operands [ <NUM_LIT> ] ; if ( TARGET_A24 ) return true ; fprintf ( stderr , <STR_LIT> , mode_name [ mode ] ) ; debug_rtx ( op0 ) ; debug_rtx ( op1 ) ;

if ( GET_CODE ( op0 ) == SUBREG ) op0 = XEXP ( op0 , <NUM_LIT> ) ;


<s> if ( regno == FLG_REGNO ) fprintf ( s , <STR_LIT> ) ; else fprintf ( s , <STR_LIT> , <STR_LIT> [ reg_push_size ( regno ) ] , reg_names [ regno ] ) ;


<s> void m32c_override_options ( void ) { if ( target_memregs_set ) { if ( target_memregs < <NUM_LIT> || target_memregs > <NUM_LIT> ) error ( <STR_LIT> , target_memregs ) ; } else target_memregs = <STR_LIT> ;


<s> return m32c_preferred_reload_class ( x , rclass ) ;


<s> default : break ; } } else if ( newclass == QI_REGS && GET_MODE_SIZE ( GET_MODE ( x ) ) > <NUM_LIT> ) newclass = SI_REGS ; else if ( GET_MODE_SIZE ( GET_MODE ( x ) ) > <NUM_LIT> && ~ class_contents [ rclass ] [ <NUM_LIT> ] & <NUM_LIT> ) newclass = DI_REGS ; rclass = reduce_class ( rclass , newclass , rclass ) ; if ( GET_MODE ( x ) == QImode ) rclass = reduce_class ( rclass , HL_REGS , rclass ) ; fprintf ( stderr , <STR_LIT> , class_names [ rclass ] ) ; debug_rtx ( x ) ; if ( GET_CODE ( x ) == MEM && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == PLUS ) fprintf ( stderr , <STR_LIT> ) ;


<s> if ( TARGET_A16 && mode == PSImode ) return m32c_split_move ( operands , mode , <NUM_LIT> ) ; if ( ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM ) && ( GET_CODE ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) == PRE_MODIFY ) ) { rtx pmv = XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ; rtx dest_reg = XEXP ( pmv , <NUM_LIT> ) ; rtx dest_mod = XEXP ( pmv , <NUM_LIT> ) ;

emit_insn ( gen_rtx_SET ( Pmode , dest_reg , dest_mod ) ) ;


<s> if ( TARGET_A16 && mode == PSImode ) return m32c_split_move ( operands , mode , <NUM_LIT> ) ; if ( ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM ) && ( GET_CODE ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) == PRE_MODIFY ) ) {

rtx pmv = XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ;


<s> return <NUM_LIT> ; } if ( scale < <NUM_LIT> ) { temp = gen_reg_rtx ( QImode ) ; if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT ) temp = GEN_INT ( - INTVAL ( operands [ <NUM_LIT> ] ) ) ; else emit_move_insn ( temp , gen_rtx_NEG ( QImode , operands [ <NUM_LIT> ] ) ) ; }


<s> return <NUM_LIT> ; } if ( scale < <NUM_LIT> ) { temp = gen_reg_rtx ( QImode ) ; if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT ) temp = GEN_INT ( - INTVAL ( operands [ <NUM_LIT> ] ) ) ; else emit_move_insn ( temp , gen_rtx_NEG ( QImode , operands [ <NUM_LIT> ] ) ) ; } else temp = operands [ <NUM_LIT> ] ; operands [ <NUM_LIT> ] = temp ;


<s> gcc_assert ( GET_CODE ( address ) == MEM ) ; m32c_print_operand ( stream , XEXP ( address , <NUM_LIT> ) , <NUM_LIT> ) ;


<s> void m32c_print_operand_address ( FILE * stream , rtx address ) { gcc_assert ( GET_CODE ( address ) == MEM ) ;

m32c_print_operand ( stream , XEXP ( address , <NUM_LIT> ) , <NUM_LIT> ) ;


<s> static bool m32c_promote_prototypes ( tree fntype ATTRIBUTE_UNUSED ) {


<s> reg_mask = <NUM_LIT> ; byte_count = <NUM_LIT> ; } if ( cfun -> machine -> is_interrupt ) for ( i = MEM0_REGNO ; i <= MEM7_REGNO ; i ++ ) if ( need_to_save ( i ) ) { byte_count += <NUM_LIT> ; cfun -> machine -> intr_pushmem [ i - MEM0_REGNO ] = <NUM_LIT> ; } if ( ppt == PP_pushm && byte_count ) { rtx note = gen_rtx_SEQUENCE ( VOIDmode , rtvec_alloc ( n_dwarfs + <NUM_LIT> ) ) ; rtx pushm ; if ( reg_mask ) { XVECEXP ( note , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_SET ( VOIDmode , stack_pointer_rtx , gen_rtx_PLUS ( GET_MODE ( stack_pointer_rtx ) , stack_pointer_rtx , GEN_INT ( - byte_count ) ) ) ; F ( XVECEXP ( note , <NUM_LIT> , <NUM_LIT> ) ) ; for ( i = <NUM_LIT> ; i < n_dwarfs ; i ++ ) XVECEXP ( note , <NUM_LIT> , i + <NUM_LIT> ) = dwarf_set [ i ] ; pushm = F ( emit_insn ( gen_pushm ( GEN_INT ( reg_mask ) ) ) ) ; REG_NOTES ( pushm ) = gen_rtx_EXPR_LIST ( REG_FRAME_RELATED_EXPR , note , REG_NOTES ( pushm ) ) ; }

if ( cfun -> machine -> is_interrupt ) for ( i = MEM0_REGNO ; i <= MEM7_REGNO ; i ++ ) if ( cfun -> machine -> intr_pushmem [ i - MEM0_REGNO ] ) {


<s> rtx pushm ; if ( reg_mask ) { XVECEXP ( note , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_SET ( VOIDmode , stack_pointer_rtx , gen_rtx_PLUS ( GET_MODE ( stack_pointer_rtx ) , stack_pointer_rtx , GEN_INT ( - byte_count ) ) ) ; F ( XVECEXP ( note , <NUM_LIT> , <NUM_LIT> ) ) ; for ( i = <NUM_LIT> ; i < n_dwarfs ; i ++ ) XVECEXP ( note , <NUM_LIT> , i + <NUM_LIT> ) = dwarf_set [ i ] ; pushm = F ( emit_insn ( gen_pushm ( GEN_INT ( reg_mask ) ) ) ) ; REG_NOTES ( pushm ) = gen_rtx_EXPR_LIST ( REG_FRAME_RELATED_EXPR , note , REG_NOTES ( pushm ) ) ; } if ( cfun -> machine -> is_interrupt ) for ( i = MEM0_REGNO ; i <= MEM7_REGNO ; i ++ ) if ( cfun -> machine -> intr_pushmem [ i - MEM0_REGNO ] ) { if ( TARGET_A16 ) pushm = emit_insn ( gen_pushhi_16 ( gen_rtx_REG ( HImode , i ) ) ) ; else pushm = emit_insn ( gen_pushhi_24 ( gen_rtx_REG ( HImode , i ) ) ) ; F ( pushm ) ; } } if ( ppt == PP_popm && byte_count ) { if ( cfun -> machine -> is_interrupt ) for ( i = MEM7_REGNO ; i >= MEM0_REGNO ; i -- ) if ( cfun -> machine -> intr_pushmem [ i - MEM0_REGNO ] ) { if ( TARGET_A16 ) emit_insn ( gen_pophi_16 ( gen_rtx_REG ( HImode , i ) ) ) ; else emit_insn ( gen_pophi_24 ( gen_rtx_REG ( HImode , i ) ) ) ;


<s> int m32c_push_rounding ( int n ) { if ( TARGET_R8C || TARGET_M16C ) return n ;

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


<s> if ( ! ( cc & ~ class_contents [ R23_REGS ] [ <NUM_LIT> ] ) ) cost = COSTS_N_INSNS ( <NUM_LIT> ) ; else cost = COSTS_N_INSNS ( <NUM_LIT> ) ; } if ( ! class_can_hold_mode ( from , mode ) || ! class_can_hold_mode ( to , mode ) ) cost = COSTS_N_INSNS ( <NUM_LIT> ) ; if ( classes_intersect ( from , CR_REGS ) ) cost += COSTS_N_INSNS ( <NUM_LIT> ) ; if ( classes_intersect ( to , CR_REGS ) ) cost += COSTS_N_INSNS ( <NUM_LIT> ) ; if ( from == MEM_REGS || to == MEM_REGS ) cost += COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( classes_intersect ( from , MEM_REGS ) || classes_intersect ( to , MEM_REGS ) ) cost += COSTS_N_INSNS ( <NUM_LIT> ) ; fprintf ( stderr , <STR_LIT> , mode_name [ mode ] , class_names [ from ] , class_names [ to ] , cost ) ;


<s> case FB_REGNO : return FB_REGS ; case SP_REGNO : return SP_REGS ; case FLG_REGNO : return FLG_REGS ; default : if ( IS_MEM_REGNO ( regno ) ) return MEM_REGS ;


<s> if ( memcmp ( s , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) return FB_REGS ; if ( memcmp ( s , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) return SB_REGS ; if ( memcmp ( s , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> && TARGET_A16 ) return CR_REGS ; if ( memcmp ( s , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> && TARGET_A24 ) return CR_REGS ; if ( memcmp ( s , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) return R0_REGS ; if ( memcmp ( s , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) return R1_REGS ; if ( memcmp ( s , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) return R2_REGS ; if ( memcmp ( s , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) return R3_REGS ; if ( memcmp ( s , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) return R02_REGS ; if ( memcmp ( s , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) return R03_REGS ; if ( memcmp ( s , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) return DI_REGS ;

if ( memcmp ( s , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) return HL_REGS ;


<s> ra_mem = gen_rtx_MEM ( mode , plus_constant ( gen_rtx_REG ( Pmode , FP_REGNO ) , offset ) ) ; return copy_to_mode_reg ( mode , ra_mem ) ;


<s> if ( classes_intersect ( rclass , CR_REGS ) && GET_CODE ( x ) == REG && REGNO ( x ) >= SB_REGNO && REGNO ( x ) <= SP_REGNO ) return TARGET_A16 ? HI_REGS : A_REGS ; return NO_REGS ;


<s> debug_rtx ( x ) ; if ( mode == QImode && GET_CODE ( x ) == MEM && ( cc & ~ class_contents [ R23_REGS ] [ <NUM_LIT> ] ) == <NUM_LIT> ) return QI_REGS ;

if ( classes_intersect ( rclass , CR_REGS ) && GET_CODE ( x ) == REG && REGNO ( x ) >= SB_REGNO && REGNO ( x ) <= SP_REGNO ) return TARGET_A16 ? HI_REGS : A_REGS ;


<s> static rtx m32c_subreg ( enum machine_mode outer , rtx x , enum machine_mode inner , int byte ) { int r , nr = - <NUM_LIT> ; if ( GET_CODE ( x ) == SUBREG && SUBREG_BYTE ( x ) == <NUM_LIT> && GET_CODE ( SUBREG_REG ( x ) ) == MEM && ( GET_MODE_SIZE ( GET_MODE ( x ) ) == GET_MODE_SIZE ( GET_MODE ( SUBREG_REG ( x ) ) ) ) ) { rtx oldx = x ; x = gen_rtx_MEM ( GET_MODE ( x ) , XEXP ( SUBREG_REG ( x ) , <NUM_LIT> ) ) ; MEM_COPY_ATTRIBUTES ( x , SUBREG_REG ( oldx ) ) ; } if ( GET_CODE ( x ) == MEM && ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PRE_DEC || GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == POST_INC ) ) return gen_rtx_MEM ( outer , XEXP ( x , <NUM_LIT> ) ) ; if ( GET_CODE ( x ) == SUBREG && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == MEM && ( GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == PRE_DEC || GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == POST_INC ) ) return gen_rtx_MEM ( outer , XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) ; if ( GET_CODE ( x ) != REG ) return simplify_gen_subreg ( outer , x , inner , byte ) ; r = REGNO ( x ) ; if ( r >= FIRST_PSEUDO_REGISTER || r == AP_REGNO ) return simplify_gen_subreg ( outer , x , inner , byte ) ; if ( IS_MEM_REGNO ( r ) ) return simplify_gen_subreg ( outer , x , inner , byte ) ; if ( byte == <NUM_LIT> ) nr = r ; else if ( outer == HImode ) {

if ( r == R0_REGNO && byte == <NUM_LIT> ) nr = R2_REGNO ;


<s> bool m32c_valid_pointer_mode ( enum machine_mode mode ) {

if ( mode == HImode || mode == PSImode || mode == SImode ) return <NUM_LIT> ;


<s> if ( cfun -> machine -> is_interrupt && ( ! cfun -> machine -> is_leaf || regno == A0_REGNO ) ) return <NUM_LIT> ; if ( regs_ever_live [ regno ] && ( ! call_used_regs [ regno ] || cfun -> machine -> is_interrupt ) ) return <NUM_LIT> ;


<s> if ( regno == FP_REGNO ) return <NUM_LIT> ;

if ( cfun -> machine -> is_interrupt && ( ! cfun -> machine -> is_leaf || regno == A0_REGNO ) ) return <NUM_LIT> ;


<s> cc &= class_contents [ limiting_class ] [ <NUM_LIT> ] ; for ( i = <NUM_LIT> ; i < LIM_REG_CLASSES ; i ++ ) { int ic = class_contents [ i ] [ <NUM_LIT> ] ; if ( ( ~ cc & ic ) == <NUM_LIT> ) if ( best_size < class_sizes [ i ] ) { best = i ; best_size = class_sizes [ i ] ; } } if ( best == NO_REGS ) return returned_if_empty ;


<s> int mlen = GET_MODE_SIZE ( mode ) ; if ( regno == R0_REGNO && mlen == <NUM_LIT> ) return <STR_LIT> ; if ( regno == R0_REGNO && ( mlen == <NUM_LIT> || mlen == <NUM_LIT> ) ) return <STR_LIT> ; if ( regno == R0_REGNO && mlen == <NUM_LIT> ) return <STR_LIT> ;


<s> for ( r = <NUM_LIT> ; r < FIRST_PSEUDO_REGISTER ; r ++ ) if ( in_hard_reg_set_p ( reg_class_contents [ ( int ) rclass ] , mode , r ) && HARD_REGNO_MODE_OK ( r , mode ) ) { results [ rclass ] [ mode ] = <NUM_LIT> ; break ; }


<s> static bool equal_keys ( const char * a , const char * b ) { return ! strcmp ( a , b ) ;


<s> static hashval_t hash ( const char * str ) { return htab_hash_string ( str ) ;


<s> static machine_mode m32c_addr_space_address_mode ( addr_space_t addrspace ) { switch ( addrspace ) { case ADDR_SPACE_GENERIC : return TARGET_A24 ? PSImode : HImode ; case ADDR_SPACE_FAR : return SImode ; default :


<s> static machine_mode m32c_addr_space_pointer_mode ( addr_space_t addrspace ) { switch ( addrspace ) { case ADDR_SPACE_GENERIC : return TARGET_A24 ? PSImode : HImode ; case ADDR_SPACE_FAR : return SImode ; default : gcc_unreachable ( ) ;


<s> case ADDR_SPACE_GENERIC : return TARGET_A24 ? PSImode : HImode ;


<s> for ( rn = <NUM_LIT> ; rn < FIRST_PSEUDO_REGISTER ; rn ++ ) if ( class_contents [ rclass ] [ <NUM_LIT> ] & ( <NUM_LIT> << rn ) ) if ( ! m32c_hard_regno_ok ( rn , to ) ) return <NUM_LIT> ;

if ( to == QImode ) return ( class_contents [ rclass ] [ <NUM_LIT> ] & <NUM_LIT> ) ;


<s> fprintf ( stderr , <STR_LIT> , mode_name [ from ] , mode_name [ to ] , class_names [ rclass ] ) ; for ( rn = <NUM_LIT> ; rn < FIRST_PSEUDO_REGISTER ; rn ++ ) if ( class_contents [ rclass ] [ <NUM_LIT> ] & ( <NUM_LIT> << rn ) ) if ( ! m32c_hard_regno_ok ( rn , to ) ) return <NUM_LIT> ; if ( to == QImode ) return ( class_contents [ rclass ] [ <NUM_LIT> ] & <NUM_LIT> ) ; if ( class_contents [ rclass ] [ <NUM_LIT> ] & <NUM_LIT> && GET_MODE_SIZE ( from ) > <NUM_LIT> ) return <NUM_LIT> ; if ( GET_MODE_SIZE ( from ) > <NUM_LIT> ) return <NUM_LIT> ;


<s> void m32c_emit_prologue ( void ) { int frame_size , extra_frame_size = <NUM_LIT> , reg_save_size ; int complex_prologue = <NUM_LIT> ; cfun -> machine -> is_leaf = m32c_leaf_function_p ( ) ; if ( interrupt_p ( cfun -> decl ) ) { cfun -> machine -> is_interrupt = <NUM_LIT> ; complex_prologue = <NUM_LIT> ; } else if ( bank_switch_p ( cfun -> decl ) ) warning ( OPT_Wattributes , <STR_LIT> ) ; reg_save_size = m32c_pushm_popm ( PP_justcount ) ; if ( interrupt_p ( cfun -> decl ) ) { if ( bank_switch_p ( cfun -> decl ) ) emit_insn ( gen_fset_b ( ) ) ;

else if ( cfun -> machine -> intr_pushm ) emit_insn ( gen_pushm ( GEN_INT ( cfun -> machine -> intr_pushm ) ) ) ;


<s> reg_save_size = m32c_pushm_popm ( PP_justcount ) ; if ( interrupt_p ( cfun -> decl ) ) { if ( bank_switch_p ( cfun -> decl ) ) emit_insn ( gen_fset_b ( ) ) ; else if ( cfun -> machine -> intr_pushm ) emit_insn ( gen_pushm ( GEN_INT ( cfun -> machine -> intr_pushm ) ) ) ; } frame_size = m32c_initial_elimination_offset ( FB_REGNO , SP_REGNO ) - reg_save_size ; if ( frame_size == <NUM_LIT> && ! m32c_function_needs_enter ( ) ) cfun -> machine -> use_rts = <NUM_LIT> ; if ( frame_size > <NUM_LIT> ) { extra_frame_size = frame_size - <NUM_LIT> ; frame_size = <NUM_LIT> ; } if ( cfun -> machine -> use_rts == <NUM_LIT> ) F ( emit_insn ( m32c_all_frame_related ( TARGET_A16 ? gen_prologue_enter_16 ( GEN_INT ( frame_size + <NUM_LIT> ) ) : gen_prologue_enter_24 ( GEN_INT ( frame_size + <NUM_LIT> ) ) ) ) ) ; if ( extra_frame_size ) { complex_prologue = <NUM_LIT> ; if ( TARGET_A16 ) F ( emit_insn ( gen_addhi3 ( gen_rtx_REG ( HImode , SP_REGNO ) , gen_rtx_REG ( HImode , SP_REGNO ) , GEN_INT ( - extra_frame_size ) ) ) ) ; else F ( emit_insn ( gen_addpsi3 ( gen_rtx_REG ( PSImode , SP_REGNO ) , gen_rtx_REG ( PSImode , SP_REGNO ) , GEN_INT ( - extra_frame_size ) ) ) ) ; } complex_prologue += m32c_pushm_popm ( PP_pushm ) ; if ( complex_prologue ) emit_insn ( gen_prologue_end ( ) ) ;


<s> count = copy_to_mode_reg ( HImode , GEN_INT ( INTVAL ( count ) / <NUM_LIT> ) ) ; if ( TARGET_A16 ) emit_insn ( gen_movmemhi_whi_op ( desto , srco , counto , desta , srca , count ) ) ; else emit_insn ( gen_movmemhi_wpsi_op ( desto , srco , counto , desta , srca , count ) ) ; return <NUM_LIT> ; }

if ( GET_CODE ( count ) != REG || REGNO ( count ) < FIRST_PSEUDO_REGISTER ) count = copy_to_mode_reg ( HImode , count ) ;


<s> if ( TARGET_A16 ) emit_insn ( gen_movmemhi_whi_op ( desto , srco , counto , desta , srca , count ) ) ; else emit_insn ( gen_movmemhi_wpsi_op ( desto , srco , counto , desta , srca , count ) ) ; return <NUM_LIT> ; } if ( GET_CODE ( count ) != REG || REGNO ( count ) < FIRST_PSEUDO_REGISTER ) count = copy_to_mode_reg ( HImode , count ) ; if ( TARGET_A16 ) emit_insn ( gen_movmemhi_bhi_op ( desto , srco , counto , desta , srca , count ) ) ; else emit_insn ( gen_movmemhi_bpsi_op ( desto , srco , counto , desta , srca , count ) ) ; return <NUM_LIT> ;


<s> CUMULATIVE_ARGS * ca = get_cumulative_args ( ca_v ) ; rtx rv = NULL_RTX ; fprintf ( stderr , <STR_LIT> , ca -> parm_num , mode_name [ mode ] , named ) ; debug_tree ( ( tree ) type ) ; if ( mode == VOIDmode ) return GEN_INT ( <NUM_LIT> ) ; if ( ca -> force_mem || ! named ) { fprintf ( stderr , <STR_LIT> , ca -> force_mem , named ) ;


<s> CUMULATIVE_ARGS * ca = get_cumulative_args ( ca_v ) ; if ( ca -> force_mem ) ca -> force_mem = <NUM_LIT> ; else ca -> parm_num ++ ;


<s> rtx_insn * insn ; struct sequence_stack * seq ; rtx sp = gen_rtx_REG ( Pmode , SP_REGNO ) ; rtx fb = gen_rtx_REG ( Pmode , FB_REGNO ) ;


<s> int rv = m32c_hard_regno_nregs_1 ( regno , mode ) ;


<s> if ( GET_MODE_SIZE ( mode ) <= <NUM_LIT> ) return nregs_table [ regno ] . hi_regs ; if ( regno == A0_REGNO && mode == SImode && TARGET_A16 ) return <NUM_LIT> ; if ( ( GET_MODE_SIZE ( mode ) <= <NUM_LIT> || mode == PSImode ) && TARGET_A24 ) return nregs_table [ regno ] . pi_regs ; if ( GET_MODE_SIZE ( mode ) <= <NUM_LIT> ) return nregs_table [ regno ] . si_regs ;

if ( GET_MODE_SIZE ( mode ) <= <NUM_LIT> ) return nregs_table [ regno ] . di_regs ;


<s> if ( regno == A0_REGNO && mode == SImode && TARGET_A16 ) return <NUM_LIT> ; if ( ( GET_MODE_SIZE ( mode ) <= <NUM_LIT> || mode == PSImode ) && TARGET_A24 ) return nregs_table [ regno ] . pi_regs ;

if ( GET_MODE_SIZE ( mode ) <= <NUM_LIT> ) return nregs_table [ regno ] . si_regs ;


<s> int m32c_hard_regno_ok ( int regno , machine_mode mode ) { return m32c_hard_regno_nregs_1 ( regno , mode ) != <NUM_LIT> ;


<s> if ( seq ) { crtl -> emit . x_first_insn = seq -> first ; crtl -> emit . x_last_insn = seq -> last ; } rv = leaf_function_p ( ) ; crtl -> emit . x_first_insn = saved_first ; crtl -> emit . x_last_insn = saved_last ; return rv ;


<s> int rv ; saved_first = crtl -> emit . x_first_insn ; saved_last = crtl -> emit . x_last_insn ; for ( seq = crtl -> emit . sequence_stack ; seq && seq -> next ; seq = seq -> next ) ; if ( seq ) { crtl -> emit . x_first_insn = seq -> first ;

crtl -> emit . x_last_insn = seq -> last ;


<s> fprintf ( stderr , <STR_LIT> , mode_name [ mode ] ) ; debug_rtx ( x ) ; fprintf ( stderr , <STR_LIT> ) ; if ( GET_CODE ( x ) == PLUS && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == REG && REGNO ( XEXP ( x , <NUM_LIT> ) ) == FB_REGNO && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT && ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) < - <NUM_LIT> || INTVAL ( XEXP ( x , <NUM_LIT> ) ) > ( <NUM_LIT> - GET_MODE_SIZE ( mode ) ) ) ) { rtx temp = gen_reg_rtx ( Pmode ) ;


<s> if ( GET_MODE_SIZE ( m1 ) == GET_MODE_SIZE ( m2 ) ) return <NUM_LIT> ; if ( m1 == QImode || m2 == QImode ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> int m32c_modes_tieable_p ( machine_mode m1 , machine_mode m2 ) { if ( GET_MODE_SIZE ( m1 ) == GET_MODE_SIZE ( m2 ) ) return <NUM_LIT> ; if ( m1 == QImode || m2 == QImode ) return <NUM_LIT> ;


<s> if ( ! pragma_htab ) pragma_htab = hash_map < const char * , unsigned , pragma_traits > :: create_ggc ( <NUM_LIT> ) ; const char * name = ggc_strdup ( varname ) ; unsigned int * slot = & pragma_htab -> get_or_insert ( name ) ; * slot = address ;


<s> static void m32c_option_override ( void ) { if ( global_options_set . x_target_memregs ) { if ( target_memregs < <NUM_LIT> || target_memregs > <NUM_LIT> ) error ( <STR_LIT> , target_memregs ) ;


<s> default : break ; } } else if ( newclass == QI_REGS && GET_MODE_SIZE ( GET_MODE ( x ) ) > <NUM_LIT> ) newclass = SI_REGS ; else if ( GET_MODE_SIZE ( GET_MODE ( x ) ) > <NUM_LIT> && ! reg_class_subset_p ( R03_REGS , rclass ) ) newclass = DI_REGS ; rclass = reduce_class ( rclass , newclass , rclass ) ; if ( GET_MODE ( x ) == QImode ) rclass = reduce_class ( rclass , HL_REGS , rclass ) ; fprintf ( stderr , <STR_LIT> , class_names [ rclass ] ) ; debug_rtx ( x ) ; if ( GET_CODE ( x ) == MEM && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == PLUS ) fprintf ( stderr , <STR_LIT> ) ;


<s> operands [ <NUM_LIT> ] = force_reg ( GET_MODE ( operands [ <NUM_LIT> ] ) , operands [ <NUM_LIT> ] ) ; } if ( TARGET_A16 && mode == PSImode ) return m32c_split_move ( operands , mode , <NUM_LIT> ) ; if ( ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM ) && ( GET_CODE ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) == PRE_MODIFY ) ) { rtx pmv = XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ; rtx dest_reg = XEXP ( pmv , <NUM_LIT> ) ; rtx dest_mod = XEXP ( pmv , <NUM_LIT> ) ; emit_insn ( gen_rtx_SET ( Pmode , dest_reg , dest_mod ) ) ; operands [ <NUM_LIT> ] = gen_rtx_MEM ( mode , dest_reg ) ; }

if ( can_create_pseudo_p ( ) && MEM_P ( operands [ <NUM_LIT> ] ) && MEM_P ( operands [ <NUM_LIT> ] ) ) operands [ <NUM_LIT> ] = copy_to_mode_reg ( mode , operands [ <NUM_LIT> ] ) ;


<s> } if ( TARGET_A16 && mode == PSImode ) return m32c_split_move ( operands , mode , <NUM_LIT> ) ; if ( ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM ) && ( GET_CODE ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) == PRE_MODIFY ) ) {

rtx pmv = XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ;


<s> else gcc_assert ( GET_CODE ( address ) == REG ) ;

m32c_print_operand ( stream , address , <NUM_LIT> ) ;


<s> else gcc_assert ( GET_CODE ( address ) == REG ) ; m32c_print_operand ( stream , address , <NUM_LIT> ) ;


<s> cfun -> machine -> intr_pushmem [ i - MEM0_REGNO ] = <NUM_LIT> ; } if ( ppt == PP_pushm && byte_count ) { rtx note = gen_rtx_SEQUENCE ( VOIDmode , rtvec_alloc ( n_dwarfs + <NUM_LIT> ) ) ; rtx pushm ; if ( reg_mask ) { XVECEXP ( note , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_SET ( VOIDmode , stack_pointer_rtx , gen_rtx_PLUS ( GET_MODE ( stack_pointer_rtx ) , stack_pointer_rtx , GEN_INT ( - byte_count ) ) ) ; F ( XVECEXP ( note , <NUM_LIT> , <NUM_LIT> ) ) ; for ( i = <NUM_LIT> ; i < n_dwarfs ; i ++ ) XVECEXP ( note , <NUM_LIT> , i + <NUM_LIT> ) = dwarf_set [ i ] ; pushm = F ( emit_insn ( gen_pushm ( GEN_INT ( reg_mask ) ) ) ) ; add_reg_note ( pushm , REG_FRAME_RELATED_EXPR , note ) ; } if ( cfun -> machine -> is_interrupt ) for ( i = MEM0_REGNO ; i <= MEM7_REGNO ; i ++ ) if ( cfun -> machine -> intr_pushmem [ i - MEM0_REGNO ] ) { if ( TARGET_A16 ) pushm = emit_insn ( gen_pushhi_16 ( gen_rtx_REG ( HImode , i ) ) ) ; else pushm = emit_insn ( gen_pushhi_24 ( gen_rtx_REG ( HImode , i ) ) ) ; F ( pushm ) ; } } if ( ppt == PP_popm && byte_count ) { if ( cfun -> machine -> is_interrupt ) for ( i = MEM7_REGNO ; i >= MEM0_REGNO ; i -- ) if ( cfun -> machine -> intr_pushmem [ i - MEM0_REGNO ] ) { if ( TARGET_A16 ) emit_insn ( gen_pophi_16 ( gen_rtx_REG ( HImode , i ) ) ) ; else emit_insn ( gen_pophi_24 ( gen_rtx_REG ( HImode , i ) ) ) ; }

if ( reg_mask ) emit_insn ( gen_popm ( GEN_INT ( reg_mask ) ) ) ;


<s> if ( TARGET_R8C || TARGET_M16C ) return n ;

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


<s> if ( reg_classes_intersect_p ( from , CR_REGS ) ) cost += COSTS_N_INSNS ( <NUM_LIT> ) ; if ( reg_classes_intersect_p ( to , CR_REGS ) ) cost += COSTS_N_INSNS ( <NUM_LIT> ) ; if ( from == MEM_REGS || to == MEM_REGS ) cost += COSTS_N_INSNS ( <NUM_LIT> ) ;

else if ( reg_classes_intersect_p ( from , MEM_REGS ) || reg_classes_intersect_p ( to , MEM_REGS ) ) cost += COSTS_N_INSNS ( <NUM_LIT> ) ;


<s> if ( reg_classes_intersect_p ( from , CR_REGS ) ) cost += COSTS_N_INSNS ( <NUM_LIT> ) ; if ( reg_classes_intersect_p ( to , CR_REGS ) ) cost += COSTS_N_INSNS ( <NUM_LIT> ) ; if ( from == MEM_REGS || to == MEM_REGS ) cost += COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( reg_classes_intersect_p ( from , MEM_REGS ) || reg_classes_intersect_p ( to , MEM_REGS ) ) cost += COSTS_N_INSNS ( <NUM_LIT> ) ; fprintf ( stderr , <STR_LIT> , mode_name [ mode ] , class_names [ ( int ) from ] , class_names [ ( int ) to ] , cost ) ; return cost ;


<s> return true ; } if ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) > <NUM_LIT> || INTVAL ( XEXP ( x , <NUM_LIT> ) ) < - <NUM_LIT> ) { * total += COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } return true ; case LE : case LEU : case LT : case LTU : case GT : case GTU : case GE : case GEU : case NE : case EQ : if ( outer_code == SET ) { * total += COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } break ; case ZERO_EXTRACT : { rtx dest = XEXP ( x , <NUM_LIT> ) ; rtx addr = XEXP ( dest , <NUM_LIT> ) ; switch ( GET_CODE ( addr ) ) { case CONST_INT : * total += COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case SYMBOL_REF : * total += COSTS_N_INSNS ( <NUM_LIT> ) ; break ;


<s> static bool m32c_valid_pointer_mode ( machine_mode mode ) {


<s> static int need_to_save ( int regno ) { if ( fixed_regs [ regno ] ) return <NUM_LIT> ; if ( crtl -> calls_eh_return ) return <NUM_LIT> ; if ( regno == FP_REGNO ) return <NUM_LIT> ;

if ( cfun -> machine -> is_interrupt && ( ! cfun -> machine -> is_leaf || ( regno == A0_REGNO && m32c_function_needs_enter ( ) ) ) ) return <NUM_LIT> ;


<s> cc = reg_class_contents [ original_class ] ; AND_HARD_REG_SET ( cc , reg_class_contents [ limiting_class ] ) ; for ( i = <NUM_LIT> ; i < LIM_REG_CLASSES ; i ++ ) { if ( hard_reg_set_subset_p ( reg_class_contents [ i ] , cc ) ) if ( best_size < reg_class_size [ i ] ) { best = ( reg_class_t ) i ; best_size = reg_class_size [ i ] ; } } if ( best == NO_REGS ) return returned_if_empty ;


<s> if ( original_class == limiting_class ) return original_class ; cc = reg_class_contents [ original_class ] ; AND_HARD_REG_SET ( cc , reg_class_contents [ limiting_class ] ) ;

for ( i = <NUM_LIT> ; i < LIM_REG_CLASSES ; i ++ ) {


<s> if ( is_attribute_p ( <STR_LIT> , TREE_PURPOSE ( list ) ) ) return <NUM_LIT> ; list = TREE_CHAIN ( list ) ;


<s> tree list = M32C_ATTRIBUTES ( node ) ; while ( list ) { if ( is_attribute_p ( <STR_LIT> , TREE_PURPOSE ( list ) ) ) return <NUM_LIT> ; list = TREE_CHAIN ( list ) ;


<s> for ( r = <NUM_LIT> ; r < FIRST_PSEUDO_REGISTER ; r ++ ) if ( in_hard_reg_set_p ( reg_class_contents [ ( int ) rclass ] , mode , r ) && m32c_hard_regno_mode_ok ( r , mode ) ) { results [ rclass ] [ mode ] = <NUM_LIT> ;


<s> if ( is_attribute_p ( <STR_LIT> , TREE_PURPOSE ( list ) ) ) { num = TREE_INT_CST_LOW ( TREE_VALUE ( TREE_VALUE ( list ) ) ) ; return num ; } list = TREE_CHAIN ( list ) ; } return <NUM_LIT> ;


<s> int current_function_special_page_vector ( rtx x ) { int num ; if ( ( GET_CODE ( x ) == SYMBOL_REF ) && ( SYMBOL_REF_FLAGS ( x ) & SYMBOL_FLAG_FUNCVEC_FUNCTION ) ) { tree list ; tree t = SYMBOL_REF_DECL ( x ) ; if ( TREE_CODE ( t ) != FUNCTION_DECL ) return <NUM_LIT> ; list = M32C_ATTRIBUTES ( t ) ; while ( list ) { if ( is_attribute_p ( <STR_LIT> , TREE_PURPOSE ( list ) ) ) { num = TREE_INT_CST_LOW ( TREE_VALUE ( TREE_VALUE ( list ) ) ) ; return num ; } list = TREE_CHAIN ( list ) ;


<s> static void encode_pattern ( rtx x ) {


<s> if ( GET_MODE ( x ) == PSImode && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == REG ) * patternp ++ = 'S' ; encode_pattern_1 ( XEXP ( x , <NUM_LIT> ) ) ; break ; case MEM : * patternp ++ = 'm' ; case CONST : encode_pattern_1 ( XEXP ( x , <NUM_LIT> ) ) ; break ; case SIGN_EXTEND : * patternp ++ = '^' ; * patternp ++ = 'S' ; encode_pattern_1 ( XEXP ( x , <NUM_LIT> ) ) ; break ; case ZERO_EXTEND : * patternp ++ = '^' ; * patternp ++ = 'Z' ; encode_pattern_1 ( XEXP ( x , <NUM_LIT> ) ) ; break ; case PLUS : * patternp ++ = '+' ; encode_pattern_1 ( XEXP ( x , <NUM_LIT> ) ) ; encode_pattern_1 ( XEXP ( x , <NUM_LIT> ) ) ; break ; case PRE_DEC : * patternp ++ = '>' ; encode_pattern_1 ( XEXP ( x , <NUM_LIT> ) ) ; break ; case POST_INC : * patternp ++ = '<' ; encode_pattern_1 ( XEXP ( x , <NUM_LIT> ) ) ; break ; case LO_SUM : * patternp ++ = 'L' ; encode_pattern_1 ( XEXP ( x , <NUM_LIT> ) ) ; encode_pattern_1 ( XEXP ( x , <NUM_LIT> ) ) ; break ; case HIGH : * patternp ++ = 'H' ; encode_pattern_1 ( XEXP ( x , <NUM_LIT> ) ) ; break ; case SYMBOL_REF : * patternp ++ = 's' ; break ; case LABEL_REF : * patternp ++ = 'l' ; break ; case CODE_LABEL : * patternp ++ = 'c' ; break ; case CONST_INT : case CONST_DOUBLE : * patternp ++ = 'i' ; break ; case UNSPEC : * patternp ++ = 'u' ; * patternp ++ = '0' + XCINT ( x , <NUM_LIT> , UNSPEC ) ; for ( i = <NUM_LIT> ; i < XVECLEN ( x , <NUM_LIT> ) ; i ++ ) encode_pattern_1 ( XVECEXP ( x , <NUM_LIT> , i ) ) ; break ; case USE : * patternp ++ = 'U' ; break ; case PARALLEL : * patternp ++ = '|' ; for ( i = <NUM_LIT> ; i < XVECLEN ( x , <NUM_LIT> ) ; i ++ ) encode_pattern_1 ( XVECEXP ( x , <NUM_LIT> , i ) ) ; break ; case EXPR_LIST : * patternp ++ = 'E' ; encode_pattern_1 ( XEXP ( x , <NUM_LIT> ) ) ; if ( XEXP ( x , <NUM_LIT> ) ) encode_pattern_1 ( XEXP ( x , <NUM_LIT> ) ) ; break ; default : * patternp ++ = '?' ;

fprintf ( stderr , <STR_LIT> , GET_RTX_NAME ( GET_CODE ( x ) ) ) ;


<s> static rtx F ( rtx x ) { RTX_FRAME_RELATED_P ( x ) = <NUM_LIT> ;


<s> static rtx F ( rtx x ) { RTX_FRAME_RELATED_P ( x ) = <NUM_LIT> ; return x ;


<s> static int far_addr_space_p ( rtx x ) { if ( GET_CODE ( x ) != MEM ) return <NUM_LIT> ; fprintf ( stderr , <STR_LIT> ) ; debug_rtx ( x ) ; fprintf ( stderr , <STR_LIT> , MEM_ADDR_SPACE ( x ) == ADDR_SPACE_FAR ) ; return MEM_ADDR_SPACE ( x ) == ADDR_SPACE_FAR ;


<s> static int far_addr_space_p ( rtx x ) { if ( GET_CODE ( x ) != MEM ) return <NUM_LIT> ;

fprintf ( stderr , <STR_LIT> ) ; debug_rtx ( x ) ;


<s> case LT : case GE : return FLAGS_OS ; case LTU : case GEU : return FLAGS_C ; case EQ : case NE : return FLAGS_Z ;


<s> int i ; switch ( GET_CODE ( addr ) ) { case CONST_INT : i = INTVAL ( addr ) ; if ( i == <NUM_LIT> ) return COSTS_N_INSNS ( <NUM_LIT> ) ; if ( i > <NUM_LIT> && i <= <NUM_LIT> ) return COSTS_N_INSNS ( <NUM_LIT> ) ; if ( i > <NUM_LIT> && i <= <NUM_LIT> ) return COSTS_N_INSNS ( <NUM_LIT> ) ; return COSTS_N_INSNS ( <NUM_LIT> ) ; case SYMBOL_REF : return COSTS_N_INSNS ( <NUM_LIT> ) ; case REG : return COSTS_N_INSNS ( <NUM_LIT> ) ; case PLUS : if ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == CONST_INT ) { i = INTVAL ( XEXP ( addr , <NUM_LIT> ) ) ; if ( i == <NUM_LIT> ) return COSTS_N_INSNS ( <NUM_LIT> ) ; if ( i > <NUM_LIT> && i <= <NUM_LIT> ) return COSTS_N_INSNS ( <NUM_LIT> ) ; if ( i > <NUM_LIT> && i <= <NUM_LIT> ) return COSTS_N_INSNS ( <NUM_LIT> ) ; } return COSTS_N_INSNS ( <NUM_LIT> ) ;


<s> if ( i > <NUM_LIT> && i <= <NUM_LIT> ) return COSTS_N_INSNS ( <NUM_LIT> ) ; if ( i > <NUM_LIT> && i <= <NUM_LIT> ) return COSTS_N_INSNS ( <NUM_LIT> ) ; return COSTS_N_INSNS ( <NUM_LIT> ) ; case SYMBOL_REF : return COSTS_N_INSNS ( <NUM_LIT> ) ; case REG : return COSTS_N_INSNS ( <NUM_LIT> ) ; case PLUS : if ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == CONST_INT ) { i = INTVAL ( XEXP ( addr , <NUM_LIT> ) ) ; if ( i == <NUM_LIT> ) return COSTS_N_INSNS ( <NUM_LIT> ) ; if ( i > <NUM_LIT> && i <= <NUM_LIT> ) return COSTS_N_INSNS ( <NUM_LIT> ) ; if ( i > <NUM_LIT> && i <= <NUM_LIT> ) return COSTS_N_INSNS ( <NUM_LIT> ) ; } return COSTS_N_INSNS ( <NUM_LIT> ) ; default : return <NUM_LIT> ; }


<s> return TARGET_A24 ? PSImode : HImode ; case ADDR_SPACE_FAR : return SImode ; default : gcc_unreachable ( ) ; }


<s> case ADDR_SPACE_GENERIC : return TARGET_A24 ? PSImode : HImode ;


<s> int rn = REGNO ( patternr [ <NUM_LIT> ] ) ; HOST_WIDE_INT offs = INTVAL ( patternr [ <NUM_LIT> ] ) ; if ( GET_MODE ( patternr [ <NUM_LIT> ] ) != HImode ) return <NUM_LIT> ; switch ( rn ) { case A0_REGNO : return ( offs >= <NUM_LIT> && offs <= <NUM_LIT> ) ; default : if ( IS_PSEUDO ( patternr [ <NUM_LIT> ] , strict ) ) return <NUM_LIT> ; return <NUM_LIT> ; } } if ( RTX_IS ( <STR_LIT> ) ) { int rn = REGNO ( patternr [ <NUM_LIT> ] ) ; if ( GET_MODE ( patternr [ <NUM_LIT> ] ) != HImode ) return <NUM_LIT> ; switch ( rn ) { case A0_REGNO : return <NUM_LIT> ; default : if ( IS_PSEUDO ( patternr [ <NUM_LIT> ] , strict ) ) return <NUM_LIT> ; return <NUM_LIT> ; } } if ( RTX_IS ( <STR_LIT> ) ) { int rn = REGNO ( patternr [ <NUM_LIT> ] ) ;


<s> switch ( rn ) { case A0_REGNO : return ( offs >= <NUM_LIT> && offs <= <NUM_LIT> ) ; default : if ( IS_PSEUDO ( patternr [ <NUM_LIT> ] , strict ) ) return <NUM_LIT> ; return <NUM_LIT> ; } } if ( RTX_IS ( <STR_LIT> ) ) { int rn = REGNO ( patternr [ <NUM_LIT> ] ) ; if ( GET_MODE ( patternr [ <NUM_LIT> ] ) != HImode ) return <NUM_LIT> ; switch ( rn ) { case A0_REGNO : return <NUM_LIT> ; default : if ( IS_PSEUDO ( patternr [ <NUM_LIT> ] , strict ) ) return <NUM_LIT> ; return <NUM_LIT> ; }


<s> if ( GET_CODE ( x ) != REG ) { x = force_reg ( SImode , x ) ; } return x ; }

return m32c_legitimize_address ( x , oldx , mode ) ;


<s> switch ( addrspace ) { case ADDR_SPACE_GENERIC : return TARGET_A24 ? PSImode : HImode ; case ADDR_SPACE_FAR :


<s> if ( subset == superset ) return true ;

else return ( subset == ADDR_SPACE_GENERIC && superset == ADDR_SPACE_FAR ) ;


<s> if ( subset == superset ) return true ; else return ( subset == ADDR_SPACE_GENERIC && superset == ADDR_SPACE_FAR ) ;


for ( i = <NUM_LIT> ; i < len ; i ++ ) F ( XVECEXP ( par , <NUM_LIT> , i ) ) ;


<s> case <NUM_LIT> : if ( GET_CODE ( x ) == SYMBOL_REF ) { fprintf ( asm_out_file , <STR_LIT> ) ; output_addr_const ( asm_out_file , x ) ; fputc ( '\n' , asm_out_file ) ; return true ;


<s> static bool m32c_can_change_mode_class ( machine_mode from , machine_mode to , reg_class_t rclass ) { int rn ; fprintf ( stderr , <STR_LIT> , mode_name [ from ] , mode_name [ to ] , class_names [ rclass ] ) ; for ( rn = <NUM_LIT> ; rn < FIRST_PSEUDO_REGISTER ; rn ++ ) if ( class_contents [ rclass ] [ <NUM_LIT> ] & ( <NUM_LIT> << rn ) ) if ( ! m32c_hard_regno_mode_ok ( rn , to ) ) return false ; if ( to == QImode ) return ( class_contents [ rclass ] [ <NUM_LIT> ] & <NUM_LIT> ) == <NUM_LIT> ; if ( class_contents [ rclass ] [ <NUM_LIT> ] & <NUM_LIT> && GET_MODE_SIZE ( from ) > <NUM_LIT> ) return true ; if ( GET_MODE_SIZE ( from ) > <NUM_LIT> ) return true ; return false ;


<s> for ( rn = <NUM_LIT> ; rn < FIRST_PSEUDO_REGISTER ; rn ++ ) if ( class_contents [ rclass ] [ <NUM_LIT> ] & ( <NUM_LIT> << rn ) ) if ( ! m32c_hard_regno_mode_ok ( rn , to ) ) return false ;

if ( to == QImode ) return ( class_contents [ rclass ] [ <NUM_LIT> ] & <NUM_LIT> ) == <NUM_LIT> ;


<s> static bool m32c_class_likely_spilled_p ( reg_class_t regclass ) { if ( regclass == A_REGS ) return true ;

return ( reg_class_size [ ( int ) regclass ] == <NUM_LIT> ) ;


<s> return ( reg_class_size [ ( int ) regclass ] == <NUM_LIT> ) ;


<s> fixed_regs [ MEM0_REGNO + i ] = <NUM_LIT> ; CLEAR_HARD_REG_BIT ( reg_class_contents [ MEM_REGS ] , MEM0_REGNO + i ) ; } } if ( TARGET_A24 ) { call_used_regs [ R1_REGNO ] = <NUM_LIT> ;


<s> case R1_REGNO : return <NUM_LIT> ; case R2_REGNO : return <NUM_LIT> ; case R3_REGNO : return <NUM_LIT> ; case A0_REGNO : return <NUM_LIT> ; case A1_REGNO : return <NUM_LIT> ; case FB_REGNO : return <NUM_LIT> ; case SB_REGNO : return <NUM_LIT> ; case SP_REGNO : return <NUM_LIT> ; case PC_REGNO : return <NUM_LIT> ; default :


<s> int m32c_eh_return_data_regno ( int n ) { switch ( n ) { case <NUM_LIT> : return MEM0_REGNO ; case <NUM_LIT> :


<s> if ( ! cfun -> machine -> eh_stack_adjust ) { rtx sa ; sa = gen_rtx_REG ( Pmode , R0_REGNO ) ; cfun -> machine -> eh_stack_adjust = sa ; }

return cfun -> machine -> eh_stack_adjust ;


<s> cfun -> machine -> eh_stack_adjust = sa ; }


<s> if ( popm_count > <NUM_LIT> ) m32c_pushm_popm ( PP_popm ) ; if ( cfun -> machine -> is_interrupt ) { machine_mode spmode = TARGET_A16 ? HImode : PSImode ; if ( ! cfun -> machine -> use_rts ) { emit_move_insn ( gen_rtx_REG ( spmode , A0_REGNO ) , gen_rtx_REG ( spmode , FP_REGNO ) ) ; emit_move_insn ( gen_rtx_REG ( spmode , SP_REGNO ) , gen_rtx_REG ( spmode , A0_REGNO ) ) ; if ( TARGET_A16 ) emit_insn ( gen_pophi_16 ( gen_rtx_REG ( HImode , FP_REGNO ) ) ) ; else emit_insn ( gen_poppsi ( gen_rtx_REG ( PSImode , FP_REGNO ) ) ) ; } if ( ! bank_switch_p ( cfun -> decl ) && cfun -> machine -> intr_pushm ) emit_insn ( gen_popm ( GEN_INT ( cfun -> machine -> intr_pushm ) ) ) ; if ( fast_interrupt_p ( cfun -> decl ) ) {


<s> if ( cfun -> machine -> use_rts == <NUM_LIT> ) F ( emit_insn ( m32c_all_frame_related ( TARGET_A16 ? gen_prologue_enter_16 ( GEN_INT ( frame_size + <NUM_LIT> ) ) : gen_prologue_enter_24 ( GEN_INT ( frame_size + <NUM_LIT> ) ) ) ) ) ; if ( extra_frame_size ) { complex_prologue = <NUM_LIT> ; if ( TARGET_A16 ) F ( emit_insn ( gen_addhi3 ( gen_rtx_REG ( HImode , SP_REGNO ) , gen_rtx_REG ( HImode , SP_REGNO ) , GEN_INT ( - extra_frame_size ) ) ) ) ; else F ( emit_insn ( gen_addpsi3 ( gen_rtx_REG ( PSImode , SP_REGNO ) , gen_rtx_REG ( PSImode , SP_REGNO ) , GEN_INT ( - extra_frame_size ) ) ) ) ; }


<s> default_encode_section_info ( decl , rtl , first ) ; if ( TREE_CODE ( decl ) == FUNCTION_DECL && m32c_special_page_vector_p ( decl ) ) extra_flags = SYMBOL_FLAG_FUNCVEC_FUNCTION ;

if ( extra_flags ) SYMBOL_REF_FLAGS ( XEXP ( rtl , <NUM_LIT> ) ) |= extra_flags ;


<s> if ( TREE_CODE ( decl ) == FUNCTION_DECL && m32c_special_page_vector_p ( decl ) ) extra_flags = SYMBOL_FLAG_FUNCVEC_FUNCTION ;


<s> if ( cfun -> machine -> is_interrupt ) return <NUM_LIT> ;


<s> rtx src1a , src2a ; src1a = XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ; src2a = XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ; if ( GET_CODE ( src1a ) != REG || REGNO ( src1a ) < FIRST_PSEUDO_REGISTER ) src1a = copy_to_mode_reg ( Pmode , src1a ) ; if ( GET_CODE ( src2a ) != REG || REGNO ( src2a ) < FIRST_PSEUDO_REGISTER ) src2a = copy_to_mode_reg ( Pmode , src2a ) ; emit_insn ( gen_cmpstrhi_op ( src1a , src2a , src1a , src2a ) ) ; emit_insn ( gen_cond_to_int ( operands [ <NUM_LIT> ] ) ) ;


<s> rtx desta , srca , count ; rtx desto , srco , counto ; desta = XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ; srca = XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ; count = operands [ <NUM_LIT> ] ; desto = gen_reg_rtx ( Pmode ) ; srco = gen_reg_rtx ( Pmode ) ; counto = gen_reg_rtx ( HImode ) ; if ( GET_CODE ( desta ) != REG || REGNO ( desta ) < FIRST_PSEUDO_REGISTER ) desta = copy_to_mode_reg ( Pmode , desta ) ; if ( GET_CODE ( srca ) != REG || REGNO ( srca ) < FIRST_PSEUDO_REGISTER ) srca = copy_to_mode_reg ( Pmode , srca ) ; if ( GET_CODE ( count ) == CONST_INT && ! ( INTVAL ( count ) & <NUM_LIT> ) && ( INTVAL ( count ) > <NUM_LIT> ) ) { count = copy_to_mode_reg ( HImode , GEN_INT ( INTVAL ( count ) / <NUM_LIT> ) ) ; if ( TARGET_A16 ) emit_insn ( gen_cpymemhi_whi_op ( desto , srco , counto , desta , srca , count ) ) ; else emit_insn ( gen_cpymemhi_wpsi_op ( desto , srco , counto , desta , srca , count ) ) ; return <NUM_LIT> ; } if ( GET_CODE ( count ) != REG || REGNO ( count ) < FIRST_PSEUDO_REGISTER ) count = copy_to_mode_reg ( HImode , count ) ; if ( TARGET_A16 ) emit_insn ( gen_cpymemhi_bhi_op ( desto , srco , counto , desta , srca , count ) ) ;

else emit_insn ( gen_cpymemhi_bpsi_op ( desto , srco , counto , desta , srca , count ) ) ;


<s> rtx new_mem = gen_rtx_MEM ( QImode , plus_constant ( Pmode , XEXP ( op0 , <NUM_LIT> ) , <NUM_LIT> ) ) ; MEM_COPY_ATTRIBUTES ( new_mem , op0 ) ; mask >>= <NUM_LIT> ; } if ( INTVAL ( operands [ <NUM_LIT> ] ) == <NUM_LIT> ) { if ( GET_MODE ( op0 ) == HImode ) mask ^= <NUM_LIT> ; else mask ^= <NUM_LIT> ; } if ( GET_MODE ( op0 ) == HImode ) { if ( mask & <NUM_LIT> ) mask -= <NUM_LIT> ; } else { if ( mask & <NUM_LIT> ) mask -= <NUM_LIT> ; } switch ( ( INTVAL ( operands [ <NUM_LIT> ] ) ? <NUM_LIT> : <NUM_LIT> ) + ( ( GET_MODE ( op0 ) == HImode ) ? <NUM_LIT> : <NUM_LIT> ) + ( TARGET_A24 ? <NUM_LIT> : <NUM_LIT> ) ) { case <NUM_LIT> : p = gen_andqi3_16 ( op0 , src0 , GEN_INT ( mask ) ) ; break ; case <NUM_LIT> : p = gen_andqi3_24 ( op0 , src0 , GEN_INT ( mask ) ) ; break ; case <NUM_LIT> : p = gen_andhi3_16 ( op0 , src0 , GEN_INT ( mask ) ) ; break ; case <NUM_LIT> : p = gen_andhi3_24 ( op0 , src0 , GEN_INT ( mask ) ) ; break ;

case <NUM_LIT> : p = gen_iorqi3_16 ( op0 , src0 , GEN_INT ( mask ) ) ; break ;


<s> src0 = gen_reg_rtx ( GET_MODE ( op0 ) ) ; emit_move_insn ( src0 , op0 ) ; } if ( GET_MODE ( op0 ) == HImode && INTVAL ( operands [ <NUM_LIT> ] ) >= <NUM_LIT> && GET_CODE ( op0 ) == MEM ) { rtx new_mem = gen_rtx_MEM ( QImode , plus_constant ( Pmode , XEXP ( op0 , <NUM_LIT> ) , <NUM_LIT> ) ) ; MEM_COPY_ATTRIBUTES ( new_mem , op0 ) ; mask >>= <NUM_LIT> ; } if ( INTVAL ( operands [ <NUM_LIT> ] ) == <NUM_LIT> ) { if ( GET_MODE ( op0 ) == HImode ) mask ^= <NUM_LIT> ; else mask ^= <NUM_LIT> ; } if ( GET_MODE ( op0 ) == HImode ) { if ( mask & <NUM_LIT> ) mask -= <NUM_LIT> ; } else { if ( mask & <NUM_LIT> ) mask -= <NUM_LIT> ; }

switch ( ( INTVAL ( operands [ <NUM_LIT> ] ) ? <NUM_LIT> : <NUM_LIT> ) + ( ( GET_MODE ( op0 ) == HImode ) ? <NUM_LIT> : <NUM_LIT> ) + ( TARGET_A24 ? <NUM_LIT> : <NUM_LIT> ) ) {


<s> if ( GET_CODE ( rel ) == NE ) { rtx tmp = operands [ <NUM_LIT> ] ; operands [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; operands [ <NUM_LIT> ] = tmp ; rel = gen_rtx_EQ ( GET_MODE ( rel ) , XEXP ( rel , <NUM_LIT> ) , XEXP ( rel , <NUM_LIT> ) ) ; } emit_move_insn ( operands [ <NUM_LIT> ] , gen_rtx_IF_THEN_ELSE ( GET_MODE ( operands [ <NUM_LIT> ] ) , rel , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; return <NUM_LIT> ;


<s> srco = gen_reg_rtx ( Pmode ) ; if ( GET_CODE ( desta ) != REG || REGNO ( desta ) < FIRST_PSEUDO_REGISTER ) desta = copy_to_mode_reg ( Pmode , desta ) ;

if ( GET_CODE ( srca ) != REG || REGNO ( srca ) < FIRST_PSEUDO_REGISTER ) srca = copy_to_mode_reg ( Pmode , srca ) ;


<s> else scale = copy_to_mode_reg ( SImode , operands [ <NUM_LIT> ] ) ; emit_insn ( gen_zero_extendpsisi2 ( temp1 , operands [ <NUM_LIT> ] ) ) ; temp2 = expand_simple_binop ( SImode , MULT , temp1 , scale , temp2 , <NUM_LIT> , OPTAB_LIB ) ;

emit_insn ( gen_truncsipsi2 ( operands [ <NUM_LIT> ] , temp2 ) ) ;


<s> rtx scale ; rtx temp2 ; temp1 = gen_reg_rtx ( SImode ) ; temp2 = gen_reg_rtx ( SImode ) ; if ( GET_CODE ( operands [ <NUM_LIT> ] ) != CONST_INT ) { scale = gen_reg_rtx ( SImode ) ; emit_insn ( gen_zero_extendpsisi2 ( scale , operands [ <NUM_LIT> ] ) ) ; } else scale = copy_to_mode_reg ( SImode , operands [ <NUM_LIT> ] ) ;

emit_insn ( gen_zero_extendpsisi2 ( temp1 , operands [ <NUM_LIT> ] ) ) ;


<s> val = operands [ <NUM_LIT> ] ; desto = gen_reg_rtx ( Pmode ) ; counto = gen_reg_rtx ( HImode ) ; if ( GET_CODE ( desta ) != REG || REGNO ( desta ) < FIRST_PSEUDO_REGISTER ) desta = copy_to_mode_reg ( Pmode , desta ) ;

if ( GET_CODE ( count ) == CONST_INT && GET_CODE ( val ) == CONST_INT && ! ( INTVAL ( count ) & <NUM_LIT> ) && ( INTVAL ( count ) > <NUM_LIT> ) && ( INTVAL ( val ) <= <NUM_LIT> && INTVAL ( val ) >= - <NUM_LIT> ) ) {


<s> * p1 = FLG_REGNO ; * p2 = INVALID_REGNUM ; return true ;


<s> CUMULATIVE_ARGS * ca = get_cumulative_args ( ca_v ) ; rtx rv = NULL_RTX ; fprintf ( stderr , <STR_LIT> , ca -> parm_num , mode_name [ arg . mode ] , arg . named ) ; debug_tree ( arg . type ) ; if ( arg . end_marker_p ( ) ) return GEN_INT ( <NUM_LIT> ) ; if ( ca -> force_mem || ! arg . named ) { fprintf ( stderr , <STR_LIT> , ca -> force_mem , arg . named ) ; return NULL_RTX ; } if ( arg . type && INTEGRAL_TYPE_P ( arg . type ) && POINTER_TYPE_P ( arg . type ) ) return NULL_RTX ; if ( arg . aggregate_type_p ( ) ) return NULL_RTX ; switch ( ca -> parm_num ) { case <NUM_LIT> : if ( GET_MODE_SIZE ( arg . mode ) == <NUM_LIT> || GET_MODE_SIZE ( arg . mode ) == <NUM_LIT> ) rv = gen_rtx_REG ( arg . mode , TARGET_A16 ? R1_REGNO : R0_REGNO ) ; break ; case <NUM_LIT> : if ( TARGET_A16 && GET_MODE_SIZE ( arg . mode ) == <NUM_LIT> ) rv = gen_rtx_REG ( arg . mode , R2_REGNO ) ; break ; }


<s> static rtx m32c_function_arg ( cumulative_args_t ca_v , const function_arg_info & arg ) { CUMULATIVE_ARGS * ca = get_cumulative_args ( ca_v ) ; rtx rv = NULL_RTX ; fprintf ( stderr , <STR_LIT> , ca -> parm_num , mode_name [ arg . mode ] , arg . named ) ; debug_tree ( arg . type ) ; if ( arg . end_marker_p ( ) ) return GEN_INT ( <NUM_LIT> ) ; if ( ca -> force_mem || ! arg . named ) { fprintf ( stderr , <STR_LIT> , ca -> force_mem , arg . named ) ; return NULL_RTX ; } if ( arg . type && INTEGRAL_TYPE_P ( arg . type ) && POINTER_TYPE_P ( arg . type ) ) return NULL_RTX ; if ( arg . aggregate_type_p ( ) ) return NULL_RTX ; switch ( ca -> parm_num ) { case <NUM_LIT> : if ( GET_MODE_SIZE ( arg . mode ) == <NUM_LIT> || GET_MODE_SIZE ( arg . mode ) == <NUM_LIT> ) rv = gen_rtx_REG ( arg . mode , TARGET_A16 ? R1_REGNO : R0_REGNO ) ; break ;


<s> CUMULATIVE_ARGS * ca = get_cumulative_args ( ca_v ) ; if ( ca -> force_mem ) ca -> force_mem = <NUM_LIT> ;


<s> return ( TARGET_A16 ? <NUM_LIT> : <NUM_LIT> ) ;


<s> int m32c_function_arg_regno_p ( int r ) { if ( TARGET_A24 ) return ( r == R0_REGNO ) ;

return ( r == R1_REGNO || r == R2_REGNO ) ;


<s> return ( r == R1_REGNO || r == R2_REGNO ) ;


<s> rtx sp = gen_rtx_REG ( Pmode , SP_REGNO ) ; rtx fb = gen_rtx_REG ( Pmode , FB_REGNO ) ; for ( insn = get_topmost_sequence ( ) -> first ; insn ; insn = NEXT_INSN ( insn ) ) if ( NONDEBUG_INSN_P ( insn ) ) { if ( reg_mentioned_p ( sp , insn ) ) return true ; if ( reg_mentioned_p ( fb , insn ) ) return true ;


<s> const machine_mode mode = TYPE_MODE ( valtype ) ;

return m32c_libcall_value ( mode , NULL_RTX ) ;


<s> static bool m32c_function_value_regno_p ( const unsigned int regno ) { return ( regno == R0_REGNO || regno == MEM0_REGNO ) ;


<s> return ( regno == R0_REGNO || regno == MEM0_REGNO ) ;


<s> if ( slot ) { * address = * slot ; return true ; } return false ;


<s> if ( ! pragma_htab ) return false ; unsigned int * slot = pragma_htab -> get ( varname ) ;


<s> unsigned int rv = m32c_hard_regno_nregs_1 ( regno , mode ) ;


<s> static unsigned int m32c_hard_regno_nregs ( unsigned int regno , machine_mode mode ) { unsigned int rv = m32c_hard_regno_nregs_1 ( regno , mode ) ; return rv ? rv : <NUM_LIT> ;


<s> if ( regno == FLG_REGNO && mode == CCmode ) return <NUM_LIT> ; if ( regno >= FIRST_PSEUDO_REGISTER ) return ( ( GET_MODE_SIZE ( mode ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ) ; if ( regno >= MEM0_REGNO && regno <= MEM7_REGNO ) return ( GET_MODE_SIZE ( mode ) + <NUM_LIT> ) / <NUM_LIT> ; if ( GET_MODE_SIZE ( mode ) <= <NUM_LIT> ) return nregs_table [ regno ] . qi_regs ;

if ( GET_MODE_SIZE ( mode ) <= <NUM_LIT> ) return nregs_table [ regno ] . hi_regs ;


<s> offset = SUBREG_BYTE ( op ) ; op = SUBREG_REG ( op ) ; src_mode = GET_MODE ( op ) ; if ( GET_MODE_SIZE ( dest_mode ) == GET_MODE_SIZE ( src_mode ) ) return false ; if ( GET_CODE ( op ) != REG ) return false ; if ( REGNO ( op ) >= MEM0_REGNO ) return false ; offset = ( <NUM_LIT> << offset ) ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( legal_subregs ) ; i ++ ) if ( legal_subregs [ i ] . outer_mode_size == GET_MODE_SIZE ( dest_mode ) && legal_subregs [ i ] . regno == REGNO ( op ) && legal_subregs [ i ] . inner_mode_size == GET_MODE_SIZE ( src_mode ) && legal_subregs [ i ] . byte_mask & offset ) { switch ( legal_subregs [ i ] . legal_when ) { case <NUM_LIT> : return false ; case <NUM_LIT> : if ( TARGET_A16 ) return false ; break ; case <NUM_LIT> :


<s> rtx m32c_incoming_return_addr_rtx ( void ) {

return gen_rtx_MEM ( PSImode , gen_rtx_REG ( PSImode , SP_REGNO ) ) ;


<s> else ofs += <NUM_LIT> ; } if ( to == SP_REGNO ) { ofs += m32c_pushm_popm ( PP_justcount ) ; ofs += get_frame_size ( ) ; }

if ( TARGET_A24 ) ofs = ( ofs + <NUM_LIT> ) & ~ <NUM_LIT> ;


<s> if ( TARGET_A24 ) ofs = ( ofs + <NUM_LIT> ) & ~ <NUM_LIT> ; fprintf ( stderr , <STR_LIT> , from , to , ofs ) ;


<s> void m32c_init_cumulative_args ( CUMULATIVE_ARGS * ca , tree fntype , rtx libname ATTRIBUTE_UNUSED , tree fndecl , int n_named_args ATTRIBUTE_UNUSED ) { if ( fntype && aggregate_value_p ( TREE_TYPE ( fntype ) , fndecl ) ) ca -> force_mem = <NUM_LIT> ; else ca -> force_mem = <NUM_LIT> ;


<s> void m32c_init_expanders ( void ) { init_machine_status = m32c_init_machine_status ;


<s> const char * name = IDENTIFIER_POINTER ( DECL_NAME ( node ) ) ;

if ( m32c_get_pragma_address ( name , & addr ) ) {


<s> static void m32c_insert_attributes ( tree node ATTRIBUTE_UNUSED , tree * attr_ptr ATTRIBUTE_UNUSED ) { unsigned addr ; if ( TREE_CODE ( node ) == VAR_DECL ) { const char * name = IDENTIFIER_POINTER ( DECL_NAME ( node ) ) ;


<s> fprintf ( stderr , <STR_LIT> ) ; if ( GET_CODE ( x ) == PLUS && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == REG && REGNO ( XEXP ( x , <NUM_LIT> ) ) == FB_REGNO && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT && ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) < - <NUM_LIT> || INTVAL ( XEXP ( x , <NUM_LIT> ) ) > ( <NUM_LIT> - GET_MODE_SIZE ( mode ) ) ) ) { rtx temp = gen_reg_rtx ( Pmode ) ; x = copy_rtx ( x ) ; emit_insn ( gen_rtx_SET ( temp , XEXP ( x , <NUM_LIT> ) ) ) ; XEXP ( x , <NUM_LIT> ) = temp ; } return x ;


<s> fprintf ( stderr , <STR_LIT> , mode_name [ mode ] ) ; debug_rtx ( * x ) ; if ( GET_CODE ( * x ) == PLUS && GET_CODE ( XEXP ( * x , <NUM_LIT> ) ) == REG && REGNO ( XEXP ( * x , <NUM_LIT> ) ) == FB_REGNO && GET_CODE ( XEXP ( * x , <NUM_LIT> ) ) == CONST_INT && ( INTVAL ( XEXP ( * x , <NUM_LIT> ) ) < - <NUM_LIT> || INTVAL ( XEXP ( * x , <NUM_LIT> ) ) > ( <NUM_LIT> - GET_MODE_SIZE ( mode ) ) ) ) { rtx sum ; int offset = INTVAL ( XEXP ( * x , <NUM_LIT> ) ) ; int adjustment = - BIG_FB_ADJ ; sum = gen_rtx_PLUS ( Pmode , XEXP ( * x , <NUM_LIT> ) , GEN_INT ( adjustment ) ) ; * x = gen_rtx_PLUS ( Pmode , sum , GEN_INT ( offset - adjustment ) ) ; if ( type == RELOAD_OTHER ) type = RELOAD_FOR_OTHER_ADDRESS ; push_reload ( sum , NULL_RTX , & XEXP ( * x , <NUM_LIT> ) , NULL , A_REGS , Pmode , VOIDmode , <NUM_LIT> , <NUM_LIT> , opnum , ( enum reload_type ) type ) ; return <NUM_LIT> ; } if ( GET_CODE ( * x ) == PLUS && GET_CODE ( XEXP ( * x , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( * x , <NUM_LIT> ) , <NUM_LIT> ) ) == REG && REGNO ( XEXP ( XEXP ( * x , <NUM_LIT> ) , <NUM_LIT> ) ) == FB_REGNO && GET_CODE ( XEXP ( XEXP ( * x , <NUM_LIT> ) , <NUM_LIT> ) ) == CONST_INT && GET_CODE ( XEXP ( * x , <NUM_LIT> ) ) == CONST_INT ) { if ( type == RELOAD_OTHER ) type = RELOAD_FOR_OTHER_ADDRESS ; push_reload ( XEXP ( * x , <NUM_LIT> ) , NULL_RTX , & XEXP ( * x , <NUM_LIT> ) , NULL , A_REGS , Pmode , VOIDmode , <NUM_LIT> , <NUM_LIT> , opnum , ( enum reload_type ) type ) ; return <NUM_LIT> ; } if ( TARGET_A24 && GET_MODE ( * x ) == PSImode ) { push_reload ( * x , NULL_RTX , x , NULL , A_REGS , PSImode , VOIDmode , <NUM_LIT> , <NUM_LIT> , opnum , ( enum reload_type ) type ) ; return <NUM_LIT> ; } return <NUM_LIT> ;


<s> XVECEXP ( rv , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( HImode , R2_REGNO ) , GEN_INT ( <NUM_LIT> ) ) ; XVECEXP ( rv , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( HImode , R3_REGNO ) , GEN_INT ( <NUM_LIT> ) ) ; return rv ; } if ( TARGET_A24 && GET_MODE_SIZE ( mode ) > <NUM_LIT> ) { rtx rv ; rv = gen_rtx_PARALLEL ( mode , rtvec_alloc ( <NUM_LIT> ) ) ; XVECEXP ( rv , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( mode , R0_REGNO ) , GEN_INT ( <NUM_LIT> ) ) ;


<s> fprintf ( stderr , <STR_LIT> , mode_name [ mode ] , class_names [ rclass ] ) ; if ( mode == QImode ) rclass = reduce_class ( rclass , HL_REGS , rclass ) ; else if ( mode == HImode ) rclass = reduce_class ( rclass , HI_REGS , rclass ) ; else if ( mode == SImode ) rclass = reduce_class ( rclass , SI_REGS , rclass ) ;

if ( rclass != A_REGS ) rclass = reduce_class ( rclass , DI_REGS , rclass ) ;


<s> if ( mode == QImode ) rclass = reduce_class ( rclass , HL_REGS , rclass ) ; else if ( mode == HImode ) rclass = reduce_class ( rclass , HI_REGS , rclass ) ; else if ( mode == SImode ) rclass = reduce_class ( rclass , SI_REGS , rclass ) ;


<s> return ( RTX_IS ( <STR_LIT> ) || RTX_IS ( <STR_LIT> ) || RTX_IS ( <STR_LIT> ) ) ; case CONSTRAINT_Ss : return ( ( RTX_IS ( <STR_LIT> ) && ( IS_REG ( patternr [ <NUM_LIT> ] , SP_REGNO ) ) ) || ( RTX_IS ( <STR_LIT> ) && ( IS_REG ( patternr [ <NUM_LIT> ] , SP_REGNO ) ) ) ) ; case CONSTRAINT_Sf : return ( ( RTX_IS ( <STR_LIT> ) && ( IS_REG ( patternr [ <NUM_LIT> ] , FB_REGNO ) ) ) || ( RTX_IS ( <STR_LIT> ) && ( IS_REG ( patternr [ <NUM_LIT> ] , FB_REGNO ) ) ) ) ; case CONSTRAINT_Sb : return ( ( RTX_IS ( <STR_LIT> ) && ( IS_REG ( patternr [ <NUM_LIT> ] , SB_REGNO ) ) ) || ( RTX_IS ( <STR_LIT> ) && ( IS_REG ( patternr [ <NUM_LIT> ] , SB_REGNO ) ) ) ) ; case CONSTRAINT_Sp : return ( RTX_IS ( <STR_LIT> ) && ! ( INTVAL ( patternr [ <NUM_LIT> ] ) & ~ <NUM_LIT> ) ) ; case CONSTRAINT_S1 :


<s> case CONSTRAINT_Sa : { rtx r ; if ( RTX_IS ( <STR_LIT> ) ) r = patternr [ <NUM_LIT> ] ; else if ( RTX_IS ( <STR_LIT> ) ) r = patternr [ <NUM_LIT> ] ; else return false ; return ( IS_REG ( r , A0_REGNO ) || IS_REG ( r , A1_REGNO ) ) ; } case CONSTRAINT_Si : return ( RTX_IS ( <STR_LIT> ) || RTX_IS ( <STR_LIT> ) || RTX_IS ( <STR_LIT> ) ) ; case CONSTRAINT_Ss : return ( ( RTX_IS ( <STR_LIT> ) && ( IS_REG ( patternr [ <NUM_LIT> ] , SP_REGNO ) ) ) || ( RTX_IS ( <STR_LIT> ) && ( IS_REG ( patternr [ <NUM_LIT> ] , SP_REGNO ) ) ) ) ; case CONSTRAINT_Sf : return ( ( RTX_IS ( <STR_LIT> ) && ( IS_REG ( patternr [ <NUM_LIT> ] , FB_REGNO ) ) ) || ( RTX_IS ( <STR_LIT> ) && ( IS_REG ( patternr [ <NUM_LIT> ] , FB_REGNO ) ) ) ) ; case CONSTRAINT_Sb : return ( ( RTX_IS ( <STR_LIT> ) && ( IS_REG ( patternr [ <NUM_LIT> ] , SB_REGNO ) ) ) || ( RTX_IS ( <STR_LIT> ) && ( IS_REG ( patternr [ <NUM_LIT> ] , SB_REGNO ) ) ) ) ; case CONSTRAINT_Sp : return ( RTX_IS ( <STR_LIT> ) && ! ( INTVAL ( patternr [ <NUM_LIT> ] ) & ~ <NUM_LIT> ) ) ;


<s> if ( m1 == QImode || m2 == QImode ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> if ( GET_CODE ( op1 ) == SUBREG ) op1 = XEXP ( op1 , <NUM_LIT> ) ; if ( GET_CODE ( op0 ) == MEM && GET_CODE ( op1 ) == MEM && ! reload_completed ) { fprintf ( stderr , <STR_LIT> ) ; return false ;


<s> void m32c_note_pragma_address ( const char * varname , unsigned address ) {

if ( ! pragma_htab ) pragma_htab = hash_map < nofree_string_hash , unsigned > :: create_ggc ( <NUM_LIT> ) ;


<s> return ; } if ( ! global ) { fprintf ( stream , <STR_LIT> ) ; assemble_name ( stream , name ) ; fprintf ( stream , <STR_LIT> ) ; }


<s> if ( m32c_compare_redundant ( insn , operands ) ) { fprintf ( stderr , <STR_LIT> ) ; return templ ; }

fprintf ( stderr , <STR_LIT> , templ + <NUM_LIT> ) ;


<s> else fprintf ( s , <STR_LIT> , <STR_LIT> [ reg_push_size ( regno ) ] , reg_names [ regno ] ) ;


<s> if ( regno == FLG_REGNO ) fprintf ( s , <STR_LIT> ) ; else fprintf ( s , <STR_LIT> , <STR_LIT> [ reg_push_size ( regno ) ] , reg_names [ regno ] ) ;


<s> static reg_class_t m32c_preferred_output_reload_class ( rtx x , reg_class_t rclass ) { return m32c_preferred_reload_class ( x , rclass ) ;


<s> static reg_class_t m32c_preferred_output_reload_class ( rtx x , reg_class_t rclass ) {

return m32c_preferred_reload_class ( x , rclass ) ;


<s> if ( reg_classes_intersect_p ( rclass , CR_REGS ) ) { switch ( GET_MODE ( x ) ) { case E_QImode : newclass = HL_REGS ; break ; default : break ; } } else if ( newclass == QI_REGS && GET_MODE_SIZE ( GET_MODE ( x ) ) > <NUM_LIT> ) newclass = SI_REGS ;

else if ( GET_MODE_SIZE ( GET_MODE ( x ) ) > <NUM_LIT> && ! reg_class_subset_p ( R03_REGS , rclass ) ) newclass = DI_REGS ;


<s> if ( far_addr_space_p ( operands [ <NUM_LIT> ] ) && CONSTANT_P ( operands [ <NUM_LIT> ] ) ) { operands [ <NUM_LIT> ] = force_reg ( GET_MODE ( operands [ <NUM_LIT> ] ) , operands [ <NUM_LIT> ] ) ; } if ( TARGET_A16 && mode == PSImode ) return m32c_split_move ( operands , mode , <NUM_LIT> ) ;

if ( ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM ) && ( GET_CODE ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) == PRE_MODIFY ) ) {


<s> if ( far_addr_space_p ( operands [ <NUM_LIT> ] ) && CONSTANT_P ( operands [ <NUM_LIT> ] ) ) { operands [ <NUM_LIT> ] = force_reg ( GET_MODE ( operands [ <NUM_LIT> ] ) , operands [ <NUM_LIT> ] ) ; } if ( TARGET_A16 && mode == PSImode ) return m32c_split_move ( operands , mode , <NUM_LIT> ) ; if ( ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM ) && ( GET_CODE ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) == PRE_MODIFY ) ) { rtx pmv = XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ; rtx dest_reg = XEXP ( pmv , <NUM_LIT> ) ; rtx dest_mod = XEXP ( pmv , <NUM_LIT> ) ; emit_insn ( gen_rtx_SET ( dest_reg , dest_mod ) ) ; operands [ <NUM_LIT> ] = gen_rtx_MEM ( mode , dest_reg ) ;


<s> } while ( count < - maxc ) { temp = gen_reg_rtx ( mode ) ; emit_insn ( func ( temp , operands [ <NUM_LIT> ] , GEN_INT ( - maxc ) ) ) ; operands [ <NUM_LIT> ] = temp ; count += maxc ; } emit_insn ( func ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , GEN_INT ( count ) ) ) ; return <NUM_LIT> ; } temp = gen_reg_rtx ( QImode ) ; if ( scale < <NUM_LIT> ) emit_move_insn ( temp , gen_rtx_NEG ( QImode , operands [ <NUM_LIT> ] ) ) ; else if ( TARGET_A16 && mode == SImode ) emit_move_insn ( temp , operands [ <NUM_LIT> ] ) ; else temp = operands [ <NUM_LIT> ] ; if ( TARGET_A16 && GET_MODE_SIZE ( mode ) == <NUM_LIT> ) { rtx count ; rtx tempvar ; rtx_insn * insn ; emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; count = temp ;

rtx_code_label * label = gen_label_rtx ( ) ;


<s> if ( c == '&' || c == '!' ) return true ; return false ;


<s> static int m32c_pushm_popm ( Push_Pop_Type ppt ) { int reg_mask = <NUM_LIT> ; int byte_count = <NUM_LIT> , bytes ; int i ; rtx dwarf_set [ PUSHM_N ] ; int n_dwarfs = <NUM_LIT> ; int nosave_mask = <NUM_LIT> ; if ( crtl -> return_rtx && GET_CODE ( crtl -> return_rtx ) == PARALLEL && ! ( crtl -> calls_eh_return || cfun -> machine -> is_interrupt ) ) { rtx exp = XVECEXP ( crtl -> return_rtx , <NUM_LIT> , <NUM_LIT> ) ; rtx rv = XEXP ( exp , <NUM_LIT> ) ; int rv_bytes = GET_MODE_SIZE ( GET_MODE ( rv ) ) ; if ( rv_bytes > <NUM_LIT> ) nosave_mask |= <NUM_LIT> ; else nosave_mask |= <NUM_LIT> ; if ( rv_bytes > <NUM_LIT> ) nosave_mask |= <NUM_LIT> ; } for ( i = <NUM_LIT> ; i < ( int ) PUSHM_N ; i ++ ) { if ( ! need_to_save ( pushm_info [ i ] . reg1 ) ) continue ; if ( pushm_info [ i ] . bit & nosave_mask ) continue ; reg_mask |= pushm_info [ i ] . bit ; bytes = TARGET_A16 ? pushm_info [ i ] . a16_bytes : pushm_info [ i ] . a24_bytes ; if ( ppt == PP_pushm ) { machine_mode mode = ( bytes == <NUM_LIT> ) ? HImode : SImode ; rtx addr ; addr = stack_pointer_rtx ; if ( byte_count != <NUM_LIT> ) addr = gen_rtx_PLUS ( GET_MODE ( addr ) , addr , GEN_INT ( byte_count ) ) ; dwarf_set [ n_dwarfs ++ ] = gen_rtx_SET ( gen_rtx_MEM ( mode , addr ) , gen_rtx_REG ( mode , pushm_info [ i ] . reg1 ) ) ; F ( dwarf_set [ n_dwarfs - <NUM_LIT> ] ) ; } byte_count += bytes ; } if ( cfun -> machine -> is_interrupt ) { cfun -> machine -> intr_pushm = reg_mask & <NUM_LIT> ; reg_mask = <NUM_LIT> ; byte_count = <NUM_LIT> ; } if ( cfun -> machine -> is_interrupt ) for ( i = MEM0_REGNO ; i <= MEM7_REGNO ; i ++ ) if ( need_to_save ( i ) ) { byte_count += <NUM_LIT> ; cfun -> machine -> intr_pushmem [ i - MEM0_REGNO ] = <NUM_LIT> ; } if ( ppt == PP_pushm && byte_count ) { rtx note = gen_rtx_SEQUENCE ( VOIDmode , rtvec_alloc ( n_dwarfs + <NUM_LIT> ) ) ; rtx pushm ; if ( reg_mask ) { XVECEXP ( note , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_SET ( stack_pointer_rtx , gen_rtx_PLUS ( GET_MODE ( stack_pointer_rtx ) , stack_pointer_rtx , GEN_INT ( - byte_count ) ) ) ; F ( XVECEXP ( note , <NUM_LIT> , <NUM_LIT> ) ) ; for ( i = <NUM_LIT> ; i < n_dwarfs ; i ++ ) XVECEXP ( note , <NUM_LIT> , i + <NUM_LIT> ) = dwarf_set [ i ] ;

pushm = F ( emit_insn ( gen_pushm ( GEN_INT ( reg_mask ) ) ) ) ;


<s> return ( n + <NUM_LIT> ) & ~ <NUM_LIT> ;


<s> if ( ! class_can_hold_mode ( from , mode ) || ! class_can_hold_mode ( to , mode ) ) cost = COSTS_N_INSNS ( <NUM_LIT> ) ; if ( reg_classes_intersect_p ( from , CR_REGS ) ) cost += COSTS_N_INSNS ( <NUM_LIT> ) ; if ( reg_classes_intersect_p ( to , CR_REGS ) ) cost += COSTS_N_INSNS ( <NUM_LIT> ) ; if ( from == MEM_REGS || to == MEM_REGS ) cost += COSTS_N_INSNS ( <NUM_LIT> ) ;

else if ( reg_classes_intersect_p ( from , MEM_REGS ) || reg_classes_intersect_p ( to , MEM_REGS ) ) cost += COSTS_N_INSNS ( <NUM_LIT> ) ;


<s> if ( hard_reg_set_subset_p ( cc , reg_class_contents [ R23_REGS ] ) ) cost = COSTS_N_INSNS ( <NUM_LIT> ) ; else cost = COSTS_N_INSNS ( <NUM_LIT> ) ; } if ( ! class_can_hold_mode ( from , mode ) || ! class_can_hold_mode ( to , mode ) ) cost = COSTS_N_INSNS ( <NUM_LIT> ) ; if ( reg_classes_intersect_p ( from , CR_REGS ) ) cost += COSTS_N_INSNS ( <NUM_LIT> ) ; if ( reg_classes_intersect_p ( to , CR_REGS ) ) cost += COSTS_N_INSNS ( <NUM_LIT> ) ; if ( from == MEM_REGS || to == MEM_REGS ) cost += COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( reg_classes_intersect_p ( from , MEM_REGS ) || reg_classes_intersect_p ( to , MEM_REGS ) ) cost += COSTS_N_INSNS ( <NUM_LIT> ) ;

fprintf ( stderr , <STR_LIT> , mode_name [ mode ] , class_names [ ( int ) from ] , class_names [ ( int ) to ] , cost ) ;


<s> int m32c_regno_ok_for_base_p ( int regno ) { if ( regno == A0_REGNO || regno == A1_REGNO || regno >= FIRST_PSEUDO_REGISTER ) return <NUM_LIT> ;


<s> int m32c_regno_ok_for_base_p ( int regno ) { if ( regno == A0_REGNO || regno == A1_REGNO || regno >= FIRST_PSEUDO_REGISTER ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> return A0_REGS ; case A1_REGNO : return A1_REGS ; case SB_REGNO : return SB_REGS ; case FB_REGNO : return FB_REGS ; case SP_REGNO : return SP_REGS ; case FLG_REGNO : return FLG_REGS ; default : if ( IS_MEM_REGNO ( regno ) ) return MEM_REGS ;


<s> int m32c_reg_ok_for_base_p ( rtx x , int strict ) { if ( GET_CODE ( x ) != REG ) return <NUM_LIT> ; switch ( REGNO ( x ) ) {


<s> ra_mem = gen_rtx_MEM ( mode , plus_constant ( Pmode , gen_rtx_REG ( Pmode , FP_REGNO ) , offset ) ) ;

return copy_to_mode_reg ( mode , ra_mem ) ;


<s> if ( count ) return NULL_RTX ; if ( TARGET_A24 ) { mode = PSImode ; offset = <NUM_LIT> ; } else { mode = HImode ; offset = <NUM_LIT> ;


<s> switch ( code ) { case REG : if ( REGNO ( x ) >= MEM0_REGNO && REGNO ( x ) <= MEM7_REGNO ) * total += COSTS_N_INSNS ( <NUM_LIT> ) ; else * total += COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case ASHIFT : case LSHIFTRT : case ASHIFTRT : if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) != CONST_INT ) { * total += COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } if ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) > <NUM_LIT> || INTVAL ( XEXP ( x , <NUM_LIT> ) ) < - <NUM_LIT> ) { * total += COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } return true ; case LE : case LEU : case LT : case LTU : case GT : case GTU : case GE : case GEU : case NE : case EQ : if ( outer_code == SET ) { * total += COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; }


<s> if ( GET_CODE ( operands [ <NUM_LIT> ] ) == REG && REGNO ( operands [ <NUM_LIT> ] ) == R0_REGNO ) { if ( code == EQ ) return <STR_LIT> ; if ( code == NE ) return <STR_LIT> ; }

sprintf ( buf , <STR_LIT> , GET_RTX_NAME ( code ) ) ;


<s> fprintf ( stderr , <STR_LIT> , class_names [ rclass ] , mode_name [ mode ] ) ; debug_rtx ( x ) ; if ( mode == QImode && GET_CODE ( x ) == MEM && ( cc & ~ class_contents [ R23_REGS ] [ <NUM_LIT> ] ) == <NUM_LIT> ) return QI_REGS ; if ( reg_classes_intersect_p ( rclass , CR_REGS ) && GET_CODE ( x ) == REG && REGNO ( x ) >= SB_REGNO && REGNO ( x ) <= SP_REGNO ) return ( TARGET_A16 || mode == HImode ) ? HI_REGS : A_REGS ;


<s> int m32c_secondary_reload_class ( int rclass , machine_mode mode , rtx x ) { int cc = class_contents [ rclass ] [ <NUM_LIT> ] ; fprintf ( stderr , <STR_LIT> , class_names [ rclass ] , mode_name [ mode ] ) ; debug_rtx ( x ) ;

if ( mode == QImode && GET_CODE ( x ) == MEM && ( cc & ~ class_contents [ R23_REGS ] [ <NUM_LIT> ] ) == <NUM_LIT> ) return QI_REGS ;


<s> int m32c_special_page_vector_p ( tree func ) { tree list ; if ( TREE_CODE ( func ) != FUNCTION_DECL ) return <NUM_LIT> ; list = M32C_ATTRIBUTES ( func ) ; while ( list ) { if ( is_attribute_p ( <STR_LIT> , TREE_PURPOSE ( list ) ) ) return <NUM_LIT> ; list = TREE_CHAIN ( list ) ; } return <NUM_LIT> ;


<s> tree list ; if ( TREE_CODE ( func ) != FUNCTION_DECL ) return <NUM_LIT> ; list = M32C_ATTRIBUTES ( func ) ; while ( list ) { if ( is_attribute_p ( <STR_LIT> , TREE_PURPOSE ( list ) ) ) return <NUM_LIT> ; list = TREE_CHAIN ( list ) ; } return <NUM_LIT> ;


<s> operands [ <NUM_LIT> ] = force_reg ( mode , operands [ <NUM_LIT> ] ) ; debug_rtx ( operands [ <NUM_LIT> ] ) ; } parts = <NUM_LIT> ; fprintf ( stderr , <STR_LIT> , ! can_create_pseudo_p ( ) , split_all ) ; debug_rtx ( operands [ <NUM_LIT> ] ) ; debug_rtx ( operands [ <NUM_LIT> ] ) ; if ( satisfies_constraint_Ss ( operands [ <NUM_LIT> ] ) ) split_all = <NUM_LIT> ; if ( TARGET_A16 && ( far_addr_space_p ( operands [ <NUM_LIT> ] ) || far_addr_space_p ( operands [ <NUM_LIT> ] ) ) ) split_all |= <NUM_LIT> ; if ( TARGET_A24 && split_all != <NUM_LIT> && ( mode == SImode || mode == PSImode ) && ! ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM && GET_CODE ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) == POST_INC ) ) return <NUM_LIT> ; for ( si = <NUM_LIT> ; si < parts ; si ++ ) { d [ si ] = m32c_subreg ( submode , operands [ <NUM_LIT> ] , mode , si * GET_MODE_SIZE ( submode ) ) ; s [ si ] = m32c_subreg ( submode , operands [ <NUM_LIT> ] , mode , si * GET_MODE_SIZE ( submode ) ) ; } if ( GET_CODE ( d [ <NUM_LIT> ] ) == MEM && GET_CODE ( XEXP ( d [ <NUM_LIT> ] , <NUM_LIT> ) ) == PRE_DEC ) { for ( si = parts - <NUM_LIT> ; si >= <NUM_LIT> ; si -- ) { ops [ opi ++ ] = gen_rtx_MEM ( submode , gen_rtx_PRE_DEC ( Pmode , gen_rtx_REG ( Pmode , SP_REGNO ) ) ) ; ops [ opi ++ ] = s [ si ] ; } rv = <NUM_LIT> ; } else if ( GET_CODE ( s [ <NUM_LIT> ] ) == MEM && GET_CODE ( XEXP ( s [ <NUM_LIT> ] , <NUM_LIT> ) ) == POST_INC ) { for ( di = <NUM_LIT> ; di < parts ; di ++ ) { ops [ opi ++ ] = d [ di ] ; ops [ opi ++ ] = gen_rtx_MEM ( submode , gen_rtx_POST_INC ( Pmode , gen_rtx_REG ( Pmode , SP_REGNO ) ) ) ; }


<s> int m32c_split_psi_p ( rtx * operands ) { fprintf ( stderr , <STR_LIT> ) ; debug_rtx ( operands [ <NUM_LIT> ] ) ; debug_rtx ( operands [ <NUM_LIT> ] ) ; if ( TARGET_A16 ) { fprintf ( stderr , <STR_LIT> ) ; return <NUM_LIT> ; } if ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM && GET_CODE ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) == POST_INC ) { fprintf ( stderr , <STR_LIT> ) ; return <NUM_LIT> ;


<s> static bool m32c_strict_argument_naming ( cumulative_args_t ca ATTRIBUTE_UNUSED ) {


<s> static rtx m32c_struct_value_rtx ( tree fndecl ATTRIBUTE_UNUSED , int incoming ATTRIBUTE_UNUSED ) {


<s> } if ( GET_CODE ( x ) == MEM && ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PRE_DEC || GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == POST_INC ) ) return gen_rtx_MEM ( outer , XEXP ( x , <NUM_LIT> ) ) ; if ( GET_CODE ( x ) == SUBREG && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == MEM && ( GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == PRE_DEC || GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == POST_INC ) ) return gen_rtx_MEM ( outer , XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) ; if ( GET_CODE ( x ) != REG ) { rtx r = simplify_gen_subreg ( outer , x , inner , byte ) ; if ( GET_CODE ( r ) == SUBREG && GET_CODE ( x ) == MEM && MEM_VOLATILE_P ( x ) ) { r = adjust_address_nv ( x , outer , byte ) ; } return r ; } r = REGNO ( x ) ; if ( r >= FIRST_PSEUDO_REGISTER || r == AP_REGNO ) return simplify_gen_subreg ( outer , x , inner , byte ) ; if ( IS_MEM_REGNO ( r ) ) return simplify_gen_subreg ( outer , x , inner , byte ) ; if ( byte == <NUM_LIT> ) nr = r ; else if ( outer == HImode ) { if ( r == R0_REGNO && byte == <NUM_LIT> ) nr = R2_REGNO ; else if ( r == R0_REGNO && byte == <NUM_LIT> ) nr = R1_REGNO ; else if ( r == R0_REGNO && byte == <NUM_LIT> ) nr = R3_REGNO ; else if ( r == R1_REGNO && byte == <NUM_LIT> ) nr = R3_REGNO ; else if ( r == A0_REGNO && byte == <NUM_LIT> ) nr = A1_REGNO ; } else if ( outer == SImode ) { if ( r == R0_REGNO && byte == <NUM_LIT> ) nr = R0_REGNO ; else if ( r == R0_REGNO && byte == <NUM_LIT> ) nr = R1_REGNO ;


<s> emit_move_insn ( A0 ( HImode , <NUM_LIT> ) , GEN_INT ( <NUM_LIT> - <NUM_LIT> ) ) ; emit_move_insn ( A0 ( HImode , <NUM_LIT> ) , chainval ) ; emit_move_insn ( A0 ( QImode , <NUM_LIT> ) , GEN_INT ( <NUM_LIT> - <NUM_LIT> ) ) ; emit_move_insn ( A0 ( HImode , <NUM_LIT> ) , function ) ; emit_move_insn ( A0 ( QImode , <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) ) ;


<s> int m32c_trampoline_size ( void ) { return TARGET_A16 ? <NUM_LIT> : <NUM_LIT> ;


<s> if ( mode == HImode || mode == PSImode || mode == SImode ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> static int need_to_save ( int regno ) { if ( fixed_regs [ regno ] ) return <NUM_LIT> ; if ( crtl -> calls_eh_return ) return <NUM_LIT> ; if ( regno == FP_REGNO ) return <NUM_LIT> ; if ( cfun -> machine -> is_interrupt && ( ! cfun -> machine -> is_leaf || ( regno == A0_REGNO && m32c_function_needs_enter ( ) ) ) ) return <NUM_LIT> ; if ( df_regs_ever_live_p ( regno ) && ( ! call_used_or_fixed_reg_p ( regno ) || cfun -> machine -> is_interrupt ) ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> HARD_REG_SET cc ; int i ; reg_class_t best = NO_REGS ; unsigned int best_size = <NUM_LIT> ; if ( original_class == limiting_class ) return original_class ; cc = reg_class_contents [ original_class ] & reg_class_contents [ limiting_class ] ; for ( i = <NUM_LIT> ; i < LIM_REG_CLASSES ; i ++ ) { if ( hard_reg_set_subset_p ( reg_class_contents [ i ] , cc ) ) if ( best_size < reg_class_size [ i ] ) { best = ( reg_class_t ) i ; best_size = reg_class_size [ i ] ; } }

if ( best == NO_REGS ) return returned_if_empty ;


<s> static const char * reg_name_with_mode ( int regno , machine_mode mode ) { int mlen = GET_MODE_SIZE ( mode ) ; if ( regno == R0_REGNO && mlen == <NUM_LIT> ) return <STR_LIT> ; if ( regno == R0_REGNO && ( mlen == <NUM_LIT> || mlen == <NUM_LIT> ) ) return <STR_LIT> ; if ( regno == R0_REGNO && mlen == <NUM_LIT> ) return <STR_LIT> ;


<s> case A0_REGNO : case A1_REGNO : case SB_REGNO : case FB_REGNO : case SP_REGNO : if ( TARGET_A16 ) return <NUM_LIT> ;


<s> GFF ( PSImode , ASHIFT , gen_ashlpsi3_i ) ; GFF ( PSImode , ASHIFTRT , gen_ashrpsi3_i ) ; GFF ( PSImode , LSHIFTRT , gen_lshrpsi3_i ) ; GFF ( SImode , ASHIFT , TARGET_A16 ? gen_ashlsi3_16 : gen_ashlsi3_24 ) ; GFF ( SImode , ASHIFTRT , TARGET_A16 ? gen_ashrsi3_16 : gen_ashrsi3_24 ) ; GFF ( SImode , LSHIFTRT , TARGET_A16 ? gen_lshrsi3_16 : gen_lshrsi3_24 ) ; gcc_unreachable ( ) ;