<s> func_ptr * p ; for ( p = __DTOR_LIST__ + <NUM_LIT> ; * p ; p ++ ) (


<s> static void m32r_setup_incoming_varargs ( cumulative_args_t cum , const function_arg_info & arg , int * pretend_size , int no_rtl ) { int first_anon_arg ; if ( no_rtl ) return ; if ( ! TYPE_NO_NAMED_ARGS_STDARG_P ( TREE_TYPE ( current_function_decl ) ) ) gcc_assert ( arg . mode != BLKmode ) ; if ( ! TYPE_NO_NAMED_ARGS_STDARG_P ( TREE_TYPE ( current_function_decl ) ) ) first_anon_arg = ( ROUND_ADVANCE_CUM ( * get_cumulative_args ( cum ) , arg . mode , arg . type ) + ROUND_ADVANCE_ARG ( arg . mode , arg . type ) ) ; else first_anon_arg = * get_cumulative_args ( cum ) ; if ( first_anon_arg < M32R_MAX_PARM_REGS ) { int first_reg_offset


<s> HOST_WIDE_INT pretend_size = current_frame_info . pretend_size ; emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - pretend_size ) ) ) ; } if ( current_frame_info . save_fp ) emit_insn ( gen_movsi_push ( stack_pointer_rtx , frame_pointer_rtx ) ) ; gmask &= ~ ( FRAME_POINTER_MASK | RETURN_ADDR_MASK ) ; for ( regno = <NUM_LIT> ; regno <= M32R_MAX_INT_REGS ; ++ regno ) { if ( ( gmask & ( <NUM_LIT> << regno ) ) != <NUM_LIT> ) emit_insn ( gen_movsi_push ( stack_pointer_rtx , gen_rtx_REG ( Pmode , regno ) ) ) ; } if ( current_frame_info . save_lr ) emit_insn ( gen_movsi_push ( stack_pointer_rtx , gen_rtx_REG ( Pmode , RETURN_ADDR_REGNUM ) ) ) ; frame_size = ( current_frame_info . total_size - ( current_frame_info . pretend_size + current_frame_info . reg_size ) ) ; if ( frame_size == <NUM_LIT> ) ; else if ( frame_size <= <NUM_LIT> ) emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - frame_size ) ) ) ; else { rtx tmp = gen_rtx_REG ( Pmode , PROLOGUE_TMP_REGNUM ) ; emit_insn ( gen_movsi ( tmp , GEN_INT ( frame_size ) ) ) ; emit_insn ( gen_subsi3 ( stack_pointer_rtx , stack_pointer_rtx


<s> if ( ! current_frame_info . initialized ) m32r_compute_frame_size ( get_frame_size ( ) ) ; return


<s> static int m32r_issue_rate ( ) { return ( ( TARGET_LOW_ISSUE_RATE ) ? <NUM_LIT> :


<s> if ( flag_pic ) return <NUM_LIT> ; if ( GET_CODE ( op ) == LABEL_REF ) return TARGET_ADDR24 ; if ( GET_CODE ( op ) == SYMBOL_REF ) sym = op ; else if ( GET_CODE ( op ) == CONST && GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF && GET_CODE ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) == CONST_INT && UINT24_P ( INTVAL ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) ) ) sym = XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ; else return


<s> if ( GET_CODE ( op ) == LABEL_REF ) return TARGET_ADDR32 ; if ( GET_CODE ( op ) == SYMBOL_REF ) sym = op ; else if ( GET_CODE ( op ) == CONST && GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF && GET_CODE ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) == CONST_INT && ! flag_pic ) sym = XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ; else return <NUM_LIT> ; return ( ! addr24_operand ( sym , mode ) && !


<s> if ( GET_CODE ( op ) == SYMBOL_REF ) sym = op ; else if ( GET_CODE ( op ) == CONST && GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF && GET_CODE ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) == CONST_INT && ! flag_pic ) sym = XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ; else return <NUM_LIT>


<s> static void block_move_call ( rtx dest_reg , rtx src_reg , rtx bytes_rtx ) { if ( GET_MODE ( bytes_rtx ) != VOIDmode && GET_MODE ( bytes_rtx ) != Pmode ) bytes_rtx = convert_to_mode ( Pmode , bytes_rtx , <NUM_LIT> ) ; emit_library_call ( m32r_function_symbol ( <STR_LIT> ) , <NUM_LIT> , VOIDmode , <NUM_LIT> , dest_reg , Pmode , src_reg , Pmode , convert_to_mode (

TYPE_MODE ( sizetype ) , bytes_rtx , TYPE_UNSIGNED ( sizetype ) ) , TYPE_MODE ( sizetype ) ) ;


<s> int call26_operand ( rtx op , enum machine_mode mode ATTRIBUTE_UNUSED ) { if ( flag_pic ) return <NUM_LIT> ; if ( GET_CODE ( op ) == SYMBOL_REF ) return SYMBOL_REF_MODEL ( op )


<s> if ( GET_CODE ( op ) != MEM ) return <NUM_LIT> ; op = XEXP ( op , <NUM_LIT> ) ; return call_address_operand ( op


<s> int easy_df_const ( rtx op ) { REAL_VALUE_TYPE r ; long l [ <NUM_LIT> ] ; REAL_VALUE_FROM_CONST_DOUBLE ( r , op ) ; REAL_VALUE_TO_TARGET_DOUBLE ( r , l


<s> buffer [ <NUM_LIT> ] = <NUM_LIT> ; gcc_assert ( GET_CODE ( operands [ <NUM_LIT> ] ) == REG ) ; gcc_assert ( conditional_move_operand ( operands [ <NUM_LIT> ] , SImode ) ) ; gcc_assert ( conditional_move_operand ( operands [ <NUM_LIT> ] , SImode ) ) ; if ( GET_CODE ( operands [ <NUM_LIT> ] ) == NE ) { rtx tmp = operands [


<s> return gen_rtx_fmt_ee ( code , CCmode , cc_reg , const0_rtx ) ; } break ; case LT : if ( register_operand ( y , SImode ) || ( GET_CODE ( y ) == CONST_INT && CMP_INT16_P ( INTVAL ( y ) ) ) ) { rtx tmp = gen_reg_rtx ( SImode ) ; switch ( code ) { case LT : emit_insn ( gen_cmp_ltsi_insn ( x , y ) ) ; code = EQ ; break ; case LE : if ( y == const0_rtx ) tmp = const1_rtx ; else emit_insn ( gen_addsi3 ( tmp , y , constm1_rtx ) ) ; emit_insn ( gen_cmp_ltsi_insn ( x , tmp ) ) ; code = EQ ; break ; case GT : if ( GET_CODE ( y ) == CONST_INT ) tmp = gen_rtx_PLUS ( SImode , y , const1_rtx ) ; else emit_insn ( gen_addsi3 ( tmp , y , constm1_rtx ) ) ; emit_insn ( gen_cmp_ltsi_insn ( x , tmp ) ) ; code = NE ; break ; case GE : emit_insn ( gen_cmp_ltsi_insn ( x , y ) ) ; code = NE ; break ; default : gcc_unreachable ( ) ; } return gen_rtx_fmt_ee ( code , CCmode , cc_reg , const0_rtx ) ; } break ; case LTU : if ( register_operand ( y , SImode ) || ( GET_CODE ( y ) == CONST_INT && CMP_INT16_P ( INTVAL ( y ) ) ) ) { rtx tmp = gen_reg_rtx ( SImode ) ; switch ( code ) { case LTU : emit_insn ( gen_cmp_ltusi_insn ( x , y ) ) ; code = EQ ; break ; case LEU : if ( y == const0_rtx ) tmp = const1_rtx ; else emit_insn ( gen_addsi3 ( tmp , y , constm1_rtx ) ) ; emit_insn ( gen_cmp_ltusi_insn ( x , tmp ) ) ; code = EQ ; break ; case GTU : if ( GET_CODE ( y ) == CONST_INT ) tmp = gen_rtx_PLUS ( SImode , y , const1_rtx ) ; else emit_insn ( gen_addsi3 ( tmp , y , constm1_rtx ) ) ; emit_insn ( gen_cmp_ltusi_insn ( x , tmp ) ) ; code = NE ; break ; case GEU : emit_insn ( gen_cmp_ltusi_insn ( x , y ) ) ; code = NE ; break ; default : gcc_unreachable ( ) ; } return gen_rtx_fmt_ee ( code , CCmode , cc_reg , const0_rtx ) ; } break ; default : gcc_unreachable (


<s> static void init_reg_tables ( void ) { int i ; for ( i = <NUM_LIT> ; i < NUM_MACHINE_MODES ; i ++ ) { switch ( GET_MODE_CLASS ( i ) ) { case MODE_INT : case MODE_PARTIAL_INT : case MODE_COMPLEX_INT : if ( GET_MODE_SIZE ( i ) <= <NUM_LIT> ) m32r_mode_class [ i ] = <NUM_LIT> << ( int ) S_MODE ; else if ( GET_MODE_SIZE ( i ) == <NUM_LIT> ) m32r_mode_class [ i ] = <NUM_LIT> << ( int ) D_MODE ; else if ( GET_MODE_SIZE ( i ) == <NUM_LIT> ) m32r_mode_class [ i ] = <NUM_LIT> << ( int ) T_MODE ; else if ( GET_MODE_SIZE ( i ) == <NUM_LIT> ) m32r_mode_class [ i ] = <NUM_LIT> << ( int ) O_MODE ; else m32r_mode_class [ i ] = <NUM_LIT> ; break ; case MODE_FLOAT : case MODE_COMPLEX_FLOAT : if ( GET_MODE_SIZE ( i ) <= <NUM_LIT> ) m32r_mode_class [ i ] = <NUM_LIT> << ( int ) SF_MODE ; else if ( GET_MODE_SIZE ( i ) == <NUM_LIT> ) m32r_mode_class [ i ] = <NUM_LIT> << ( int ) DF_MODE ; else if ( GET_MODE_SIZE ( i ) == <NUM_LIT> ) m32r_mode_class [ i ] = <NUM_LIT> << ( int ) TF_MODE ; else if ( GET_MODE_SIZE ( i ) == <NUM_LIT> ) m32r_mode_class [ i ] = <NUM_LIT> << ( int ) OF_MODE ; else m32r_mode_class [ i ] = <NUM_LIT> ; break ; case MODE_CC : m32r_mode_class [ i ] = <NUM_LIT> << ( int ) C_MODE ; break ; default : m32r_mode_class [ i ] = <NUM_LIT> ; break ; } } for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++


<s> static int m32r_adjust_priority ( rtx insn


<s> if ( * cum >= M32R_MAX_PARM_REGS ) words = <NUM_LIT> ; else if ( * cum + size > M32R_MAX_PARM_REGS ) words = ( * cum + size ) - M32R_MAX_PARM_REGS ; else words =


<s> int words ; unsigned int size = ( ( ( mode == BLKmode && type ) ? ( unsigned int ) int_size_in_bytes ( type ) : GET_MODE_SIZE ( mode ) ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ; if ( * cum >= M32R_MAX_PARM_REGS ) words = <NUM_LIT> ; else if ( * cum + size > M32R_MAX_PARM_REGS ) words = ( * cum + size ) - M32R_MAX_PARM_REGS ; else words =


<s> rtx align_rtx = operands [ <NUM_LIT> ] ; int constp = GET_CODE ( bytes_rtx ) == CONST_INT ; HOST_WIDE_INT bytes = constp ? INTVAL ( bytes_rtx ) : <NUM_LIT> ; int align = INTVAL ( align_rtx ) ; int leftover ; rtx src_reg ; rtx dst_reg ; if ( constp && bytes <= <NUM_LIT> ) return <NUM_LIT> ; dst_reg = copy_addr_to_reg ( XEXP ( orig_dst , <NUM_LIT> ) ) ; src_reg = copy_addr_to_reg ( XEXP ( orig_src , <NUM_LIT> ) ) ; if ( align > UNITS_PER_WORD ) align = UNITS_PER_WORD ; if ( optimize_size || ! constp || align != UNITS_PER_WORD ) { block_move_call ( dst_reg , src_reg , bytes_rtx ) ; return <NUM_LIT> ; } leftover = bytes %


<s> int align = INTVAL ( align_rtx ) ; int leftover ; rtx src_reg ; rtx dst_reg ; if ( constp && bytes <= <NUM_LIT> ) return <NUM_LIT> ; dst_reg = copy_addr_to_reg ( XEXP ( orig_dst , <NUM_LIT> ) ) ; src_reg = copy_addr_to_reg ( XEXP ( orig_src , <NUM_LIT> ) ) ; if ( align > UNITS_PER_WORD ) align = UNITS_PER_WORD ; if ( optimize_size || ! constp || align != UNITS_PER_WORD ) { block_move_call ( dst_reg , src_reg , bytes_rtx ) ; return <NUM_LIT> ; } leftover = bytes % MAX_MOVE_BYTES ; bytes -= leftover ; if ( bytes ) { rtx label = NULL_RTX ; rtx final_src = NULL_RTX ; rtx at_a_time = GEN_INT


<s> static void m32r_file_start ( void ) { default_file_start ( ) ; if ( flag_verbose_asm ) fprintf ( asm_out_file , <STR_LIT> HOST_WIDE_INT_PRINT_UNSIGNED <STR_LIT> , ASM_COMMENT_START , g_switch_value ) ; if ( TARGET_LITTLE_ENDIAN ) fprintf ( asm_out_file , <STR_LIT>


<s> case OPT_mmodel_ : if ( strcmp ( arg , <STR_LIT> ) == <NUM_LIT> ) m32r_model = M32R_MODEL_SMALL ; else if ( strcmp ( arg , <STR_LIT> ) == <NUM_LIT> ) m32r_model = M32R_MODEL_MEDIUM ; else if ( strcmp ( arg , <STR_LIT> ) == <NUM_LIT> ) m32r_model = M32R_MODEL_LARGE ; else return false ; return true ; case OPT_msdata_ : if ( strcmp ( arg , <STR_LIT> ) == <NUM_LIT> ) m32r_sdata = M32R_SDATA_NONE ; else if ( strcmp ( arg , <STR_LIT> ) == <NUM_LIT> ) m32r_sdata = M32R_SDATA_SDATA ; else if ( strcmp ( arg , <STR_LIT> ) == <NUM_LIT> ) m32r_sdata = M32R_SDATA_USE ; else return false ; return true ; case OPT_mno_flush_func : m32r_cache_flush_func = NULL ; return true ; case OPT_mflush_trap_ : return value <= <NUM_LIT> ; case OPT_mno_flush_trap : m32r_cache_flush_trap = - <NUM_LIT> ; return true


<s> if ( lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( current_function_decl ) ) && ! regs_ever_live [ new_reg ] ) return <NUM_LIT> ; if ( current_function_is_leaf && new_reg == RETURN_ADDR_REGNUM ) return <NUM_LIT> ; return


<s> init_reg_tables ( ) ; memset ( m32r_punct_chars , <NUM_LIT> , sizeof ( m32r_punct_chars ) ) ; m32r_punct_chars [ '#' ] = <NUM_LIT> ; m32r_punct_chars [ '@' ] = <NUM_LIT>


<s> if ( TREE_CODE ( decl ) != VAR_DECL ) return false ; if ( lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ) return false ; section = DECL_SECTION_NAME ( decl ) ; if ( section ) { char * name = ( char * ) TREE_STRING_POINTER ( section ) ; if ( strcmp ( name , <STR_LIT> ) == <NUM_LIT> || strcmp ( name , <STR_LIT> ) == <NUM_LIT>


<s> return ( INSN_P ( insn ) && GET_CODE ( PATTERN ( insn ) ) != USE && GET_CODE ( PATTERN ( insn ) ) != CLOBBER

&& GET_CODE ( PATTERN ( insn ) ) != ADDR_VEC ) ;


<s> reg = gen_reg_rtx ( Pmode ) ; subregs = <NUM_LIT> ; } if ( subregs ) address = gen_reg_rtx ( Pmode ) ; else address = reg ; current_function_uses_pic_offset_table = <NUM_LIT> ; if ( GET_CODE ( orig ) == LABEL_REF || ( GET_CODE ( orig ) == SYMBOL_REF && SYMBOL_REF_LOCAL_P ( orig ) ) ) { emit_insn ( gen_gotoff_load_addr ( reg , orig ) ) ; emit_insn ( gen_addsi3 ( reg , reg , pic_offset_table_rtx ) ) ; return reg ; } emit_insn ( gen_pic_load_addr ( address , orig ) ) ; emit_insn ( gen_addsi3 ( address , address , pic_offset_table_rtx ) ) ; pic_ref = gen_const_mem ( Pmode , address ) ; insn = emit_move_insn ( reg , pic_ref ) ; REG_NOTES ( insn ) = gen_rtx_EXPR_LIST ( REG_EQUAL , orig , REG_NOTES ( insn ) ) ; return reg ; } else if ( GET_CODE ( orig ) == CONST ) { rtx base , offset ; if ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == PLUS && XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) == pic_offset_table_rtx ) return orig ; if ( reg == <NUM_LIT> ) { gcc_assert ( ! reload_in_progress && ! reload_completed ) ; reg = gen_reg_rtx ( Pmode ) ; } if ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == PLUS ) { base = m32r_legitimize_pic_address ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) , reg ) ; if ( base == reg ) offset = m32r_legitimize_pic_address ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) , NULL_RTX ) ; else offset = m32r_legitimize_pic_address ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) , reg ) ; } else return orig ; if ( GET_CODE ( offset ) == CONST_INT ) { if ( INT16_P ( INTVAL ( offset ) ) ) return plus_constant ( base , INTVAL (


<s> int reg_a = - <NUM_LIT> ; int reg_b = - <NUM_LIT> ; while ( GET_CODE ( a ) == SUBREG ) a = SUBREG_REG ( a ) ; if ( GET_CODE ( a ) == REG ) reg_a = REGNO ( a ) ; while ( GET_CODE ( b ) == SUBREG ) b = SUBREG_REG ( b ) ; if ( GET_CODE ( b ) == REG ) reg_b = REGNO ( b ) ; return reg_a != reg_b


<s> bytes -= <NUM_LIT> ; } else { int dst_offset = first_time ? <NUM_LIT> : <NUM_LIT> ; int dst_inc_amount = dst_offset + bytes - <NUM_LIT> ; int src_inc_amount = bytes ; int last_shift ; rtx my_operands [ <NUM_LIT> ] ; if ( ! got_extra ) output_asm_insn ( <STR_LIT> , operands ) ; if ( bytes >= <NUM_LIT> ) { bytes -= <NUM_LIT> ; output_asm_insn ( <STR_LIT> , operands ) ; my_operands [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; my_operands [ <NUM_LIT> ] = GEN_INT ( dst_offset ) ; my_operands [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; output_asm_insn ( <STR_LIT> , my_operands ) ; if ( bytes > <NUM_LIT> ) { dst_offset += <NUM_LIT> ; last_shift = <NUM_LIT> ; } } else last_shift = <NUM_LIT> ; if ( bytes > <NUM_LIT> ) { my_operands [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; my_operands [ <NUM_LIT> ] = GEN_INT ( last_shift ) ; output_asm_insn ( <STR_LIT> ,


<s> } if ( ! noepilogue ) { unsigned int var_size = current_frame_info . var_size ; unsigned int args_size = current_frame_info . args_size ; unsigned int gmask = current_frame_info . gmask ; int can_trust_sp_p = ! current_function_calls_alloca ; const char * sp_str = reg_names [ STACK_POINTER_REGNUM ] ; const char * fp_str = reg_names [ FRAME_POINTER_REGNUM ] ; if ( can_trust_sp_p ) { unsigned int reg_offset = var_size + args_size ; if ( reg_offset == <NUM_LIT> ) ; else if ( reg_offset < <NUM_LIT> ) fprintf ( file , <STR_LIT> , sp_str , IMMEDIATE_PREFIX , reg_offset ) ; else if ( reg_offset < <NUM_LIT> ) fprintf ( file , <STR_LIT> , sp_str , sp_str , IMMEDIATE_PREFIX , reg_offset ) ; else if ( reg_offset < ( <NUM_LIT> << <NUM_LIT> ) ) fprintf ( file , <STR_LIT> , reg_names [ PROLOGUE_TMP_REGNUM ] , IMMEDIATE_PREFIX , reg_offset , sp_str , reg_names [ PROLOGUE_TMP_REGNUM ] ) ; else fprintf ( file , <STR_LIT> , reg_names [ PROLOGUE_TMP_REGNUM ] , IMMEDIATE_PREFIX , reg_offset >> <NUM_LIT> , reg_names [ PROLOGUE_TMP_REGNUM ] , reg_names [ PROLOGUE_TMP_REGNUM ] , IMMEDIATE_PREFIX , reg_offset & <NUM_LIT> , sp_str , reg_names [ PROLOGUE_TMP_REGNUM ] ) ; } else if ( frame_pointer_needed ) { unsigned int reg_offset = var_size + args_size ; if ( reg_offset == <NUM_LIT> ) fprintf ( file , <STR_LIT> , sp_str , fp_str ) ; else if ( reg_offset < <NUM_LIT> ) fprintf ( file , <STR_LIT> , sp_str , fp_str , IMMEDIATE_PREFIX , reg_offset ) ; else if ( reg_offset < ( <NUM_LIT> << <NUM_LIT> ) ) fprintf ( file , <STR_LIT> , reg_names [ PROLOGUE_TMP_REGNUM ] , IMMEDIATE_PREFIX , reg_offset , sp_str , reg_names [ PROLOGUE_TMP_REGNUM ] ) ; else fprintf ( file , <STR_LIT> , reg_names [ PROLOGUE_TMP_REGNUM ] , IMMEDIATE_PREFIX , reg_offset >> <NUM_LIT> , reg_names [ PROLOGUE_TMP_REGNUM ] , reg_names [ PROLOGUE_TMP_REGNUM ] , IMMEDIATE_PREFIX , reg_offset & <NUM_LIT> , sp_str , reg_names [ PROLOGUE_TMP_REGNUM ] ) ; } else gcc_unreachable ( ) ; if ( current_frame_info . save_lr ) fprintf ( file , <STR_LIT> , reg_names [ RETURN_ADDR_REGNUM ] ) ; gmask &= ~ ( FRAME_POINTER_MASK | RETURN_ADDR_MASK ) ; for ( regno = M32R_MAX_INT_REGS - <NUM_LIT> ; regno >= <NUM_LIT> ; -- regno ) { if ( ( gmask & ( <NUM_LIT> << regno ) ) != <NUM_LIT> ) fprintf ( file , <STR_LIT> , reg_names [ regno ] ) ; } if ( current_frame_info . save_fp ) fprintf (


<s> enum m32r_function_type fn_type = m32r_compute_function_type ( current_function_decl ) ; if ( M32R_INTERRUPT_P ( fn_type ) ) fprintf ( file , <STR_LIT> , ASM_COMMENT_START ) ; if ( ! current_frame_info . initialized ) m32r_compute_frame_size ( size ) ; fprintf ( file , <STR_LIT> , ASM_COMMENT_START , current_frame_info . var_size , current_frame_info . reg_size / <NUM_LIT> , current_frame_info . args_size , current_frame_info


<s> rtx lr = gen_rtx_REG ( Pmode , RETURN_ADDR_REGNUM ) ; if ( size == <NUM_LIT> ) emit_insn ( gen_movsi ( lr , gen_rtx_MEM ( Pmode , sp ) ) ) ; else if ( size < <NUM_LIT> ) emit_insn ( gen_movsi ( lr , gen_rtx_MEM ( Pmode , gen_rtx_PLUS ( Pmode , sp , GEN_INT ( size ) ) ) ) ) ; else { rtx tmp = gen_rtx_REG ( Pmode , PROLOGUE_TMP_REGNUM ) ; emit_insn ( gen_movsi ( tmp , GEN_INT ( size ) ) ) ; emit_insn ( gen_addsi3 ( tmp , tmp , sp ) ) ; emit_insn ( gen_movsi ( lr , gen_rtx_MEM ( Pmode , tmp ) ) ) ; } emit_insn ( gen_rtx_USE ( VOIDmode ,


<s> static bool m32r_return_in_memory ( tree type , tree fntype ATTRIBUTE_UNUSED


<s> { rtx high , low ; split_double ( x , & high , & low ) ; * total = COSTS_N_INSNS ( ! INT16_P ( INTVAL ( high ) ) + ! INT16_P ( INTVAL ( low ) ) ) ; return true ; } case MULT : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case DIV : case UDIV : case MOD


<s> if ( no_rtl ) return ; gcc_assert ( mode != BLKmode ) ; first_anon_arg = ( ROUND_ADVANCE_CUM ( * cum , mode , type ) + ROUND_ADVANCE_ARG ( mode , type ) ) ; if ( first_anon_arg < M32R_MAX_PARM_REGS ) { int first_reg_offset


<s> return GET_CODE ( op ) == MEM && GET_CODE ( XEXP ( op , <NUM_LIT> ) )


<s> if ( ! TARGET_SDATA_USE ) return <NUM_LIT> ; if ( GET_CODE ( op ) == SYMBOL_REF ) return SYMBOL_REF_SMALL_P ( op ) ; if ( GET_CODE ( op ) == CONST && GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF && GET_CODE ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) == CONST_INT && INT16_P ( INTVAL ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) )

) return SYMBOL_REF_SMALL_P ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) ;


<s> if ( ! TARGET_SDATA_USE ) return <NUM_LIT> ; if ( GET_CODE ( op ) == SYMBOL_REF ) return SYMBOL_REF_SMALL_P ( op ) ; if ( GET_CODE ( op ) == CONST && GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF && GET_CODE ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) == CONST_INT && INT16_P ( INTVAL ( XEXP ( XEXP (

op , <NUM_LIT> ) , <NUM_LIT> ) ) ) ) return SYMBOL_REF_SMALL_P ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) ;


<s> int zero_and_one ( rtx operand1 , rtx operand2 ) { return GET_CODE ( operand1 ) == CONST_INT && GET_CODE ( operand2 ) == CONST_INT && ( ( ( INTVAL ( operand1 ) == <NUM_LIT> ) && ( INTVAL ( operand2 ) == <NUM_LIT> ) ) || ( ( INTVAL ( operand1 )

== <NUM_LIT> ) && ( INTVAL ( operand2 ) == <NUM_LIT> ) ) ) ;


<s> if ( GET_MODE ( bytes_rtx ) != VOIDmode && GET_MODE ( bytes_rtx ) != Pmode ) bytes_rtx = convert_to_mode ( Pmode , bytes_rtx , <NUM_LIT> ) ; emit_library_call ( m32r_function_symbol ( <STR_LIT> ) , LCT_NORMAL , VOIDmode , <NUM_LIT> , dest_reg , Pmode , src_reg , Pmode , convert_to_mode ( TYPE_MODE ( sizetype ) , bytes_rtx , TYPE_UNSIGNED ( sizetype ) )


<s> emit_library_call ( m32r_function_symbol ( <STR_LIT> ) , LCT_NORMAL , VOIDmode , <NUM_LIT> , dest_reg , Pmode , src_reg , Pmode , convert_to_mode ( TYPE_MODE ( sizetype ) ,

bytes_rtx , TYPE_UNSIGNED ( sizetype ) ) , TYPE_MODE ( sizetype ) ) ;


<s> else if ( MEM_P ( src ) ) { int reverse = refers_to_regno_p ( dregno , XEXP ( src , <NUM_LIT> ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , operand_subword ( dest , reverse , TRUE , mode ) , adjust_address ( src , SImode , reverse * UNITS_PER_WORD ) ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , operand_subword ( dest , ! reverse , TRUE , mode ) , adjust_address ( src , SImode , ! reverse * UNITS_PER_WORD ) ) ) ; } else gcc_unreachable ( ) ; } else if ( MEM_P ( dest ) && REG_P ( src ) ) { emit_insn ( gen_rtx_SET ( VOIDmode , adjust_address ( dest , SImode , <NUM_LIT> ) , operand_subword ( src , <NUM_LIT> , TRUE , mode ) ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , adjust_address ( dest , SImode , UNITS_PER_WORD ) , operand_subword ( src , <NUM_LIT> , TRUE , mode ) ) ) ; } else gcc_unreachable ( ) ; val = get_insns ( )


<s> CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; int words ; unsigned int size = ( ( ( mode == BLKmode && type ) ? ( unsigned int ) int_size_in_bytes ( type ) : GET_MODE_SIZE ( mode ) ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ; if ( * cum >= M32R_MAX_PARM_REGS )


<s> int words ; unsigned int size = ( ( ( mode == BLKmode && type ) ? ( unsigned int ) int_size_in_bytes ( type ) : GET_MODE_SIZE ( mode ) ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ; if ( * cum >= M32R_MAX_PARM_REGS ) words = <NUM_LIT> ; else if ( * cum + size > M32R_MAX_PARM_REGS ) words = ( * cum + size ) - M32R_MAX_PARM_REGS ; else words = <NUM_LIT> ; return words * UNITS_PER_WORD


<s> int pic_reg_used = flag_pic && ( crtl -> uses_pic_offset_table | crtl -> profile ) ; var_size = M32R_STACK_ALIGN ( size ) ; args_size = M32R_STACK_ALIGN ( crtl -> outgoing_args_size ) ; pretend_size = crtl -> args . pretend_args_size ; extra_size = FIRST_PARM_OFFSET ( <NUM_LIT> ) ; total_size = extra_size + pretend_size + args_size + var_size ; reg_size = <NUM_LIT> ; gmask = <NUM_LIT> ; fn_type = m32r_compute_function_type ( current_function_decl ) ; interrupt_p = M32R_INTERRUPT_P ( fn_type ) ; for ( regno = <NUM_LIT> ; regno < M32R_MAX_INT_REGS ; regno ++ ) { if ( MUST_SAVE_REGISTER ( regno , interrupt_p ) || ( regno == PIC_OFFSET_TABLE_REGNUM && pic_reg_used ) ) { reg_size +=


<s> int m32r_expand_block_move ( rtx operands [ ] ) { rtx orig_dst = operands [ <NUM_LIT> ] ; rtx orig_src = operands [ <NUM_LIT> ] ; rtx bytes_rtx = operands [ <NUM_LIT> ] ; rtx align_rtx = operands [ <NUM_LIT> ] ; int constp = CONST_INT_P ( bytes_rtx ) ; HOST_WIDE_INT bytes = constp ? INTVAL ( bytes_rtx ) : <NUM_LIT> ; int align = INTVAL ( align_rtx ) ; int leftover ; rtx src_reg ; rtx dst_reg ; if ( constp && bytes <= <NUM_LIT> ) return <NUM_LIT> ; dst_reg = copy_addr_to_reg ( XEXP ( orig_dst , <NUM_LIT> ) ) ; src_reg = copy_addr_to_reg ( XEXP ( orig_src , <NUM_LIT> ) ) ; if ( align > UNITS_PER_WORD ) align = UNITS_PER_WORD ; if ( optimize_size || ! constp || align != UNITS_PER_WORD ) { block_move_call ( dst_reg , src_reg , bytes_rtx ) ; return <NUM_LIT> ; } leftover = bytes % MAX_MOVE_BYTES ; bytes -= leftover ; if ( bytes ) { rtx_code_label * label = NULL ; rtx final_src = NULL_RTX ; rtx at_a_time = GEN_INT ( MAX_MOVE_BYTES ) ; rtx rounded_total = GEN_INT (


<s> int m32r_expand_block_move ( rtx operands [ ] ) { rtx orig_dst = operands [ <NUM_LIT> ] ; rtx orig_src = operands [ <NUM_LIT> ] ; rtx bytes_rtx = operands [ <NUM_LIT> ] ; rtx align_rtx = operands [ <NUM_LIT> ] ; int constp = CONST_INT_P ( bytes_rtx ) ; HOST_WIDE_INT bytes = constp ? INTVAL ( bytes_rtx ) : <NUM_LIT> ; int align = INTVAL ( align_rtx ) ; int leftover ; rtx src_reg ; rtx dst_reg ; if ( constp && bytes <= <NUM_LIT> ) return <NUM_LIT> ; dst_reg = copy_addr_to_reg ( XEXP ( orig_dst , <NUM_LIT> ) ) ; src_reg = copy_addr_to_reg ( XEXP ( orig_src , <NUM_LIT> ) ) ; if ( align > UNITS_PER_WORD ) align = UNITS_PER_WORD ; if ( optimize_size || ! constp || align != UNITS_PER_WORD ) { block_move_call ( dst_reg , src_reg , bytes_rtx ) ; return <NUM_LIT>


<s> } } else if ( frame_pointer_needed ) { unsigned int reg_offset = var_size + args_size ; if ( reg_offset == <NUM_LIT> ) emit_insn ( gen_movsi ( stack_pointer_rtx , frame_pointer_rtx ) ) ; else if ( reg_offset < <NUM_LIT> ) emit_insn ( gen_addsi3 ( stack_pointer_rtx , frame_pointer_rtx , GEN_INT ( reg_offset ) ) ) ; else { rtx tmp = gen_rtx_REG ( Pmode , PROLOGUE_TMP_REGNUM ) ; emit_insn ( gen_movsi ( tmp , GEN_INT ( reg_offset ) ) ) ; emit_insn ( gen_movsi ( stack_pointer_rtx , frame_pointer_rtx ) ) ; emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , tmp ) ) ; } } else gcc_unreachable ( ) ; if ( current_frame_info . save_lr ) pop ( RETURN_ADDR_REGNUM ) ; gmask &= ~ ( FRAME_POINTER_MASK | RETURN_ADDR_MASK ) ; for ( regno = M32R_MAX_INT_REGS - <NUM_LIT> ; regno >= <NUM_LIT> ; -- regno ) { if ( ( gmask & ( <NUM_LIT> << regno ) ) != <NUM_LIT> ) pop ( regno ) ; } if ( current_frame_info . save_fp )


<s> unsigned int gmask = current_frame_info . gmask ; int can_trust_sp_p = ! cfun -> calls_alloca ; if ( flag_exceptions ) emit_insn ( gen_blockage ( ) ) ; if ( can_trust_sp_p ) { unsigned int reg_offset = var_size + args_size ; if ( reg_offset == <NUM_LIT> ) ; else if ( reg_offset < <NUM_LIT> ) emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( reg_offset ) ) ) ; else { rtx tmp = gen_rtx_REG ( Pmode , PROLOGUE_TMP_REGNUM ) ; emit_insn ( gen_movsi ( tmp , GEN_INT ( reg_offset ) ) ) ; emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , tmp ) ) ; } } else if ( frame_pointer_needed ) { unsigned int reg_offset = var_size + args_size ; if ( reg_offset == <NUM_LIT> ) emit_insn ( gen_movsi ( stack_pointer_rtx , frame_pointer_rtx ) ) ; else if ( reg_offset < <NUM_LIT> ) emit_insn ( gen_addsi3 ( stack_pointer_rtx , frame_pointer_rtx , GEN_INT ( reg_offset ) ) ) ; else { rtx tmp = gen_rtx_REG ( Pmode , PROLOGUE_TMP_REGNUM


<s> if ( current_frame_info . save_fp ) emit_insn ( gen_movsi_push ( stack_pointer_rtx , frame_pointer_rtx ) ) ; gmask &= ~ ( FRAME_POINTER_MASK | RETURN_ADDR_MASK ) ; for ( regno = <NUM_LIT> ; regno <= M32R_MAX_INT_REGS ; ++ regno ) { if ( ( gmask & ( <NUM_LIT> << regno ) ) != <NUM_LIT> ) emit_insn ( gen_movsi_push ( stack_pointer_rtx , gen_rtx_REG ( Pmode , regno ) ) ) ; } if ( current_frame_info . save_lr ) emit_insn ( gen_movsi_push ( stack_pointer_rtx , gen_rtx_REG ( Pmode , RETURN_ADDR_REGNUM ) ) ) ; frame_size = ( current_frame_info . total_size - ( current_frame_info . pretend_size + current_frame_info . reg_size ) ) ; if ( frame_size == <NUM_LIT> ) ; else if ( frame_size <= <NUM_LIT> ) emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - frame_size ) ) ) ; else { rtx tmp = gen_rtx_REG ( Pmode , PROLOGUE_TMP_REGNUM ) ; emit_insn ( gen_movsi ( tmp , GEN_INT ( frame_size ) ) ) ; emit_insn ( gen_subsi3 ( stack_pointer_rtx , stack_pointer_rtx , tmp ) ) ; } if ( frame_pointer_needed ) emit_insn ( gen_movsi ( frame_pointer_rtx


<s> CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; * cum = ( ROUND_ADVANCE_CUM ( * cum , mode , type ) + ROUND_ADVANCE_ARG


<s> int size ; if ( type ) size = int_size_in_bytes ( type ) ; else size = GET_MODE_SIZE ( mode ) ; return ( size < <NUM_LIT> || size > <NUM_LIT>


<s> static bool m32r_pass_by_reference ( cumulative_args_t ca ATTRIBUTE_UNUSED , machine_mode mode , const_tree type , bool named ATTRIBUTE_UNUSED ) { int size ; if ( type ) size


<s> case 'N' : if ( CONST_INT_P ( x ) ) output_addr_const ( file , GEN_INT ( - INTVAL ( x ) ) ) ; else output_operand_lossage ( <STR_LIT> ) ; return ; case 'X' : if ( CONST_INT_P ( x ) ) fprintf ( file , HOST_WIDE_INT_PRINT_HEX , INTVAL ( x ) ) ; return ; case '#' : fputs ( IMMEDIATE_PREFIX , file ) ; return ; case <NUM_LIT> : break ; default : output_operand_lossage ( <STR_LIT> ) ; } switch ( GET_CODE ( x ) ) { case REG : fputs ( reg_names [ REGNO ( x ) ] , file ) ; break ; case MEM : addr = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( addr ) == PRE_INC ) { if ( ! REG_P ( XEXP ( addr , <NUM_LIT> ) ) ) fatal_insn ( <STR_LIT> , x ) ; fprintf ( file , <STR_LIT> , reg_names [ REGNO ( XEXP ( addr , <NUM_LIT> ) ) ] ) ; } else if ( GET_CODE ( addr ) == PRE_DEC ) { if ( ! REG_P ( XEXP ( addr , <NUM_LIT> ) ) ) fatal_insn ( <STR_LIT> , x ) ; fprintf ( file , <STR_LIT> , reg_names [ REGNO ( XEXP ( addr , <NUM_LIT> ) ) ] ) ; } else if ( GET_CODE ( addr ) == POST_INC ) { if ( ! REG_P ( XEXP ( addr , <NUM_LIT> ) ) ) fatal_insn ( <STR_LIT> , x ) ; fprintf ( file , <STR_LIT> , reg_names [ REGNO ( XEXP ( addr , <NUM_LIT> ) ) ] ) ; } else { fputs ( <STR_LIT> , file ) ; output_address ( XEXP ( x , <NUM_LIT> ) ) ; fputc ( ')' , file ) ; } break ; case CONST_DOUBLE : if ( GET_MODE ( x ) == SFmode ) { REAL_VALUE_TYPE d ; long l ; REAL_VALUE_FROM_CONST_DOUBLE ( d , x ) ; REAL_VALUE_TO_TARGET_SINGLE ( d , l ) ; fprintf ( file ,


<s> static bool m32r_return_in_memory ( const_tree type , const_tree fntype ATTRIBUTE_UNUSED ) { cumulative_args_t dummy = pack_cumulative_args (


<s> cumulative_args_t dummy = pack_cumulative_args ( NULL ) ; return m32r_pass_by_reference ( dummy , TYPE_MODE ( type )


<s> if ( first_anon_arg < M32R_MAX_PARM_REGS ) { int first_reg_offset = first_anon_arg ; int size = M32R_MAX_PARM_REGS - first_reg_offset ; rtx regblock ; regblock = gen_frame_mem ( BLKmode , plus_constant ( Pmode , arg_pointer_rtx , FIRST_PARM_OFFSET ( <NUM_LIT> ) ) ) ; set_mem_alias_set ( regblock , get_varargs_alias_set ( ) ) ; move_block_from_reg ( first_reg_offset , regblock , size


<s> emit_move_insn ( adjust_address ( m_tramp , SImode , <NUM_LIT> ) , gen_int_mode ( TARGET_LITTLE_ENDIAN ? <NUM_LIT> : <NUM_LIT> , SImode ) ) ; emit_move_insn ( adjust_address ( m_tramp , SImode , <NUM_LIT> ) , chain_value ) ; emit_move_insn ( adjust_address ( m_tramp , SImode , <NUM_LIT> ) , XEXP ( DECL_RTL ( fndecl ) , <NUM_LIT> ) ) ; if ( m32r_cache_flush_trap >= <NUM_LIT> ) emit_insn ( gen_flush_icache ( validize_mem ( adjust_address ( m_tramp , SImode , <NUM_LIT> ) ) ,

gen_int_mode ( m32r_cache_flush_trap , SImode ) ) ) ;


<s> if ( GET_CODE ( op ) == LABEL_REF ) return TARGET_ADDR24 ; if ( GET_CODE ( op ) == SYMBOL_REF ) sym = op ; else if ( GET_CODE ( op ) == CONST && GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF

&& satisfies_constraint_M ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) ) sym = XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ;


<s> static void block_move_call ( rtx dest_reg , rtx src_reg , rtx bytes_rtx ) { if ( GET_MODE ( bytes_rtx ) != VOIDmode && GET_MODE ( bytes_rtx ) !=

Pmode ) bytes_rtx = convert_to_mode ( Pmode , bytes_rtx , <NUM_LIT> ) ;


<s> if ( flag_pic ) return <NUM_LIT> ; if ( GET_CODE ( op ) == SYMBOL_REF ) return

SYMBOL_REF_MODEL ( op ) != M32R_MODEL_LARGE ;


<s> long l [ <NUM_LIT> ] ; REAL_VALUE_TO_TARGET_DOUBLE ( * CONST_DOUBLE_REAL_VALUE ( op ) , l ) ; if ( l [ <NUM_LIT> ] == <NUM_LIT> && l

[ <NUM_LIT> ] == <NUM_LIT> ) return <NUM_LIT> ;


<s> long l [ <NUM_LIT> ] ; REAL_VALUE_TO_TARGET_DOUBLE ( * CONST_DOUBLE_REAL_VALUE ( op ) , l ) ; if ( l [ <NUM_LIT> ] == <NUM_LIT> && l [ <NUM_LIT> ] == <NUM_LIT> ) return <NUM_LIT> ; if ( ( l [ <NUM_LIT> ] & <NUM_LIT> ) == <NUM_LIT> && l [ <NUM_LIT> ] == <NUM_LIT>


<s> int easy_di_const ( rtx op ) { rtx high_rtx , low_rtx ; HOST_WIDE_INT high , low ; split_double ( op , & high_rtx , & low_rtx ) ; high = INTVAL ( high_rtx


<s> emit_insn ( gen_rtx_SET ( operand_subword ( dest , ! reverse , TRUE , mode ) , operand_subword ( src , ! reverse , TRUE , mode ) ) ) ; } else if ( CONST_INT_P ( src ) || GET_CODE ( src ) == CONST_DOUBLE ) { rtx words [ <NUM_LIT> ] ; split_double ( src , & words [ <NUM_LIT> ] , & words [ <NUM_LIT> ] ) ; emit_insn ( gen_rtx_SET ( operand_subword ( dest , <NUM_LIT> , TRUE , mode ) , words [ <NUM_LIT> ] ) ) ; emit_insn ( gen_rtx_SET ( operand_subword ( dest , <NUM_LIT> , TRUE , mode ) , words [ <NUM_LIT> ] ) ) ; } else if ( MEM_P ( src ) ) { int reverse = refers_to_regno_p ( dregno , XEXP ( src , <NUM_LIT> ) ) ; emit_insn ( gen_rtx_SET ( operand_subword ( dest , reverse , TRUE , mode ) , adjust_address ( src , SImode , reverse * UNITS_PER_WORD ) ) ) ; emit_insn ( gen_rtx_SET ( operand_subword ( dest , ! reverse , TRUE , mode ) , adjust_address ( src , SImode , ! reverse * UNITS_PER_WORD ) ) ) ; } else gcc_unreachable ( ) ; } else if ( MEM_P ( dest ) &&


<s> else if ( GET_MODE_SIZE ( m ) == <NUM_LIT> ) m32r_mode_class [ i ] = <NUM_LIT> << ( int ) DF_MODE ; else if ( GET_MODE_SIZE ( m ) == <NUM_LIT> ) m32r_mode_class [ i ] = <NUM_LIT> << ( int ) TF_MODE ; else if ( GET_MODE_SIZE ( m ) == <NUM_LIT> ) m32r_mode_class [ i ] = <NUM_LIT> << ( int ) OF_MODE ; else m32r_mode_class [ i ] = <NUM_LIT> ; break ; case MODE_CC : m32r_mode_class [ i ] = <NUM_LIT> << ( int ) C_MODE ; break ; default : m32r_mode_class [ i ] = <NUM_LIT> ; break ; } } for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) { if ( GPR_P ( i ) ) m32r_regno_reg_class [ i ]


<s> static int m32r_adjust_priority ( rtx_insn * insn , int priority ) { if ( m32r_is_insn ( insn ) && get_attr_insn_size ( insn )

!= INSN_SIZE_SHORT ) priority <<= <NUM_LIT> ;


<s> unsigned int size = ( arg . promoted_size_in_bytes ( ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ; if ( * cum >= M32R_MAX_PARM_REGS ) words = <NUM_LIT> ; else if ( * cum + size > M32R_MAX_PARM_REGS ) words = ( * cum + size ) - M32R_MAX_PARM_REGS ; else words


<s> static void m32r_conditional_register_usage ( void ) { if ( flag_pic ) fixed_regs [ PIC_OFFSET_TABLE_REGNUM


<s> int m32r_expand_block_move ( rtx operands [ ] ) { rtx orig_dst = operands [ <NUM_LIT> ] ; rtx orig_src = operands [ <NUM_LIT> ] ; rtx bytes_rtx = operands [ <NUM_LIT> ] ; rtx align_rtx = operands [ <NUM_LIT> ] ; int constp = CONST_INT_P ( bytes_rtx ) ; HOST_WIDE_INT bytes = constp ? INTVAL ( bytes_rtx ) : <NUM_LIT> ; int align = INTVAL ( align_rtx ) ; int leftover ; rtx src_reg ; rtx dst_reg ; if ( constp && bytes <= <NUM_LIT> ) return <NUM_LIT> ; dst_reg = copy_addr_to_reg ( XEXP ( orig_dst , <NUM_LIT> ) ) ; src_reg = copy_addr_to_reg ( XEXP ( orig_src , <NUM_LIT> ) ) ; if ( align > UNITS_PER_WORD ) align = UNITS_PER_WORD ; if ( optimize_size || ! constp || align != UNITS_PER_WORD ) { block_move_call ( dst_reg , src_reg , bytes_rtx ) ; return <NUM_LIT> ; } leftover = bytes % MAX_MOVE_BYTES ; bytes -= leftover ; if ( bytes ) { rtx_code_label * label = NULL ; rtx final_src = NULL_RTX ; rtx at_a_time = GEN_INT ( MAX_MOVE_BYTES ) ; rtx rounded_total = GEN_INT ( bytes ) ; rtx new_dst_reg = gen_reg_rtx ( SImode ) ; rtx new_src_reg = gen_reg_rtx ( SImode ) ; if ( bytes > MAX_MOVE_BYTES ) { final_src = gen_reg_rtx ( Pmode ) ; if ( INT16_P ( bytes ) ) emit_insn ( gen_addsi3 ( final_src , src_reg , rounded_total ) ) ; else { emit_insn ( gen_movsi ( final_src , rounded_total ) ) ; emit_insn ( gen_addsi3 ( final_src , final_src , src_reg ) ) ; } label = gen_label_rtx ( ) ; emit_label ( label ) ; } emit_insn ( gen_cpymemsi_internal ( dst_reg , src_reg , at_a_time , new_dst_reg , new_src_reg ) ) ; emit_move_insn ( dst_reg , new_dst_reg ) ; emit_move_insn ( src_reg , new_src_reg ) ; emit_insn ( gen_addsi3 ( dst_reg , dst_reg , GEN_INT ( <NUM_LIT> )


<s> rtx tmp = gen_rtx_REG ( Pmode , PROLOGUE_TMP_REGNUM ) ; emit_insn ( gen_movsi ( tmp , GEN_INT ( reg_offset ) ) ) ; emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , tmp ) ) ; } } else if ( frame_pointer_needed ) { unsigned int reg_offset = var_size + args_size ; if ( reg_offset == <NUM_LIT> ) emit_insn ( gen_movsi ( stack_pointer_rtx , frame_pointer_rtx ) ) ; else if ( reg_offset < <NUM_LIT> ) emit_insn ( gen_addsi3 ( stack_pointer_rtx , frame_pointer_rtx , GEN_INT ( reg_offset ) ) ) ; else { rtx tmp = gen_rtx_REG ( Pmode , PROLOGUE_TMP_REGNUM ) ; emit_insn ( gen_movsi ( tmp , GEN_INT ( reg_offset ) ) ) ; emit_insn ( gen_movsi ( stack_pointer_rtx , frame_pointer_rtx ) ) ; emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , tmp ) ) ; } } else gcc_unreachable ( ) ; if ( current_frame_info . save_lr ) pop ( RETURN_ADDR_REGNUM ) ; gmask &= ~ ( FRAME_POINTER_MASK |


<s> if ( insn && BARRIER_P ( insn ) ) noepilogue = TRUE ; } if ( ! noepilogue ) { unsigned int var_size = current_frame_info . var_size ; unsigned int args_size = current_frame_info . args_size ; unsigned int gmask = current_frame_info . gmask ; int can_trust_sp_p = ! cfun -> calls_alloca ; if ( flag_exceptions ) emit_insn ( gen_blockage ( ) ) ; if ( can_trust_sp_p ) { unsigned int reg_offset = var_size + args_size ; if ( reg_offset == <NUM_LIT> ) ; else if ( reg_offset < <NUM_LIT> ) emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( reg_offset ) ) ) ; else { rtx tmp = gen_rtx_REG ( Pmode , PROLOGUE_TMP_REGNUM ) ; emit_insn ( gen_movsi ( tmp , GEN_INT ( reg_offset ) ) ) ; emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , tmp ) ) ; } } else if ( frame_pointer_needed ) { unsigned int reg_offset = var_size + args_size ; if ( reg_offset == <NUM_LIT> ) emit_insn ( gen_movsi ( stack_pointer_rtx , frame_pointer_rtx ) ) ; else if ( reg_offset < <NUM_LIT> ) emit_insn ( gen_addsi3 ( stack_pointer_rtx , frame_pointer_rtx , GEN_INT ( reg_offset ) ) ) ; else { rtx tmp = gen_rtx_REG ( Pmode , PROLOGUE_TMP_REGNUM ) ; emit_insn ( gen_movsi ( tmp , GEN_INT ( reg_offset ) ) ) ; emit_insn ( gen_movsi ( stack_pointer_rtx , frame_pointer_rtx ) ) ; emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , tmp ) ) ; } } else gcc_unreachable ( ) ; if ( current_frame_info . save_lr ) pop ( RETURN_ADDR_REGNUM ) ; gmask &= ~ ( FRAME_POINTER_MASK | RETURN_ADDR_MASK


<s> } if ( current_frame_info . save_lr ) emit_insn ( gen_movsi_push ( stack_pointer_rtx , gen_rtx_REG ( Pmode , RETURN_ADDR_REGNUM ) ) ) ; frame_size = ( current_frame_info . total_size - ( current_frame_info . pretend_size + current_frame_info . reg_size ) ) ; if ( frame_size == <NUM_LIT> ) ; else if ( frame_size <= <NUM_LIT> ) emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - frame_size ) ) ) ; else { rtx tmp = gen_rtx_REG ( Pmode , PROLOGUE_TMP_REGNUM ) ; emit_insn ( gen_movsi ( tmp , GEN_INT ( frame_size ) ) ) ; emit_insn ( gen_subsi3 ( stack_pointer_rtx , stack_pointer_rtx , tmp ) ) ; } if ( frame_pointer_needed ) emit_insn ( gen_movsi ( frame_pointer_rtx , stack_pointer_rtx ) ) ; if ( crtl -> profile ) emit_insn ( gen_movsi_push ( stack_pointer_rtx , gen_rtx_REG ( Pmode , RETURN_ADDR_REGNUM ) ) ) ; if ( pic_reg_used ) { m32r_load_pic_register (


<s> void m32r_expand_prologue ( void ) { int regno ; int frame_size ; unsigned int gmask ; int pic_reg_used = flag_pic && ( crtl -> uses_pic_offset_table | crtl -> profile ) ; if ( ! current_frame_info . initialized ) m32r_compute_frame_size ( get_frame_size ( ) ) ; if ( flag_stack_usage_info ) current_function_static_stack_size = current_frame_info . total_size ; gmask = current_frame_info . gmask ; gcc_assert ( current_frame_info . total_size || ! gmask ) ; if ( current_frame_info . pretend_size != <NUM_LIT> ) { HOST_WIDE_INT pretend_size = current_frame_info . pretend_size ; emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - pretend_size ) ) ) ; } if ( current_frame_info . save_fp ) emit_insn ( gen_movsi_push ( stack_pointer_rtx , frame_pointer_rtx ) ) ; gmask &= ~ ( FRAME_POINTER_MASK | RETURN_ADDR_MASK ) ; for ( regno = <NUM_LIT> ; regno <= M32R_MAX_INT_REGS ; ++ regno ) { if ( ( gmask & ( <NUM_LIT> << regno ) ) != <NUM_LIT> ) emit_insn ( gen_movsi_push ( stack_pointer_rtx , gen_rtx_REG ( Pmode , regno ) ) ) ; } if ( current_frame_info . save_lr ) emit_insn ( gen_movsi_push ( stack_pointer_rtx , gen_rtx_REG ( Pmode , RETURN_ADDR_REGNUM ) ) ) ; frame_size = ( current_frame_info . total_size - ( current_frame_info . pretend_size + current_frame_info . reg_size ) ) ; if ( frame_size == <NUM_LIT> ) ; else if ( frame_size <= <NUM_LIT> ) emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - frame_size ) ) ) ; else { rtx tmp = gen_rtx_REG ( Pmode , PROLOGUE_TMP_REGNUM ) ; emit_insn ( gen_movsi ( tmp ,


<s> static void m32r_file_start ( void ) { default_file_start ( ) ; if ( flag_verbose_asm ) fprintf ( asm_out_file , <STR_LIT> , ASM_COMMENT_START , g_switch_value ) ; if ( TARGET_LITTLE_ENDIAN ) fprintf ( asm_out_file , <STR_LIT>


<s> return ( PASS_IN_REG_P ( * cum , arg . mode , arg . type ) ? gen_rtx_REG ( arg . mode , ROUND_ADVANCE_CUM ( * cum

, arg . mode , arg . type ) ) : NULL_RTX ) ;


<s> * cum = ( ROUND_ADVANCE_CUM ( * cum , arg . mode , arg .

type ) + ROUND_ADVANCE_ARG ( arg . mode , arg . type ) ) ;


<s> * cum = ( ROUND_ADVANCE_CUM ( * cum , arg . mode , arg . type )

+ ROUND_ADVANCE_ARG ( arg . mode , arg . type ) ) ;


<s> enum m32r_model model ; rtx sym = gen_rtx_SYMBOL_REF ( Pmode , name ) ; if ( TARGET_MODEL_SMALL ) model = M32R_MODEL_SMALL ; else if ( TARGET_MODEL_MEDIUM ) model = M32R_MODEL_MEDIUM ; else if ( TARGET_MODEL_LARGE ) model = M32R_MODEL_LARGE ; else gcc_unreachable


<s> static rtx m32r_function_value ( const_tree valtype , const_tree fn_decl_or_type ATTRIBUTE_UNUSED , bool outgoing ATTRIBUTE_UNUSED ) { return gen_rtx_REG ( TYPE_MODE ( valtype ) ,


<s> static bool m32r_function_value_regno_p ( const unsigned int regno ) { return ( regno ==


<s> return ( m32r_hard_regno_modes [ regno ] & m32r_mode_class [ mode ] )


<s> if ( lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( current_function_decl ) ) && !


<s> int m32r_hard_regno_rename_ok ( unsigned int old_reg ATTRIBUTE_UNUSED , unsigned


<s> memset ( m32r_punct_chars , <NUM_LIT> , sizeof ( m32r_punct_chars ) ) ; m32r_punct_chars [ '#' ] = <NUM_LIT> ; m32r_punct_chars [ '@' ] = <NUM_LIT>


<s> if ( section ) { if ( strcmp ( section , <STR_LIT> ) == <NUM_LIT> || strcmp ( section , <STR_LIT> ) == <NUM_LIT> ) return true ; } else { if ( ! TREE_READONLY ( decl ) && ! TARGET_SDATA_NONE ) { int size = int_size_in_bytes ( TREE_TYPE


<s> static int m32r_issue_rate ( void ) { return ( ( TARGET_LOW_ISSUE_RATE ) ? <NUM_LIT> : <NUM_LIT>


<s> if ( m32r_rtx_ok_for_base_p ( x , strict ) || m32r_legitimate_offset_addres_p ( mode , x , strict ) || m32r_legitimate_lo_sum_addres_p ( mode , x , strict ) || m32r_load_postinc_p ( mode , x , strict ) || m32r_store_preinc_predec_p ( mode , x , strict ) ) return true ; return false


<s> return ! ( GET_CODE ( x ) == CONST && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS && ( GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF || GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == LABEL_REF ) && CONST_INT_P ( XEXP

( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) && UINTVAL ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) > <NUM_LIT> ) ;


<s> if ( GET_CODE ( x ) == LO_SUM && ( mode != BLKmode && GET_MODE_SIZE ( mode ) <= UNITS_PER_WORD ) && m32r_rtx_ok_for_base_p ( XEXP ( x , <NUM_LIT> ) , strict ) && CONSTANT_P ( XEXP ( x , <NUM_LIT>


<s> if ( GET_CODE ( x ) == LO_SUM && ( mode != BLKmode && GET_MODE_SIZE ( mode ) <= UNITS_PER_WORD ) && m32r_rtx_ok_for_base_p (

XEXP ( x , <NUM_LIT> ) , strict ) && CONSTANT_P ( XEXP ( x , <NUM_LIT> ) ) ) return true ;


<s> if ( GET_CODE ( x ) == PLUS && m32r_rtx_ok_for_base_p ( XEXP ( x , <NUM_LIT> ) , strict ) && m32r_rtx_ok_for_offset_p ( XEXP ( x ,


<s> if ( GET_CODE ( x ) == PLUS && m32r_rtx_ok_for_base_p ( XEXP ( x , <NUM_LIT> ) , strict ) && m32r_rtx_ok_for_offset_p ( XEXP ( x , <NUM_LIT> ) ) ) return true ; return


<s> if ( GET_CODE ( x ) == CONST && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS && ( GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF || GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == LABEL_REF ) && ( CONST_INT_P ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) ) ) return <NUM_LIT> ; return


<s> static rtx m32r_legitimize_address ( rtx x , rtx orig_x ATTRIBUTE_UNUSED

, machine_mode mode ATTRIBUTE_UNUSED ) {


<s> subregs = <NUM_LIT> ; } if ( subregs ) address = gen_reg_rtx ( Pmode ) ; else address = reg ; crtl -> uses_pic_offset_table = <NUM_LIT> ; if ( GET_CODE ( orig ) == LABEL_REF || ( GET_CODE ( orig ) == SYMBOL_REF && SYMBOL_REF_LOCAL_P ( orig ) ) ) { emit_insn ( gen_gotoff_load_addr ( reg , orig ) ) ; emit_insn ( gen_addsi3 ( reg , reg , pic_offset_table_rtx ) ) ; return reg ; } emit_insn ( gen_pic_load_addr ( address , orig ) ) ; emit_insn ( gen_addsi3 ( address , address , pic_offset_table_rtx ) ) ; pic_ref = gen_const_mem ( Pmode , address ) ; emit_move_insn ( reg , pic_ref ) ; return reg ; } else if ( GET_CODE ( orig ) == CONST ) { rtx base , offset ; if ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == PLUS && XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) == pic_offset_table_rtx ) return orig ; if ( reg == <NUM_LIT> ) { gcc_assert ( ! reload_in_progress && ! reload_completed ) ; reg = gen_reg_rtx ( Pmode ) ; } if ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == PLUS ) { base = m32r_legitimize_pic_address ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) , reg ) ; if ( base == reg ) offset = m32r_legitimize_pic_address ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) , NULL_RTX ) ; else offset = m32r_legitimize_pic_address ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) , reg ) ; } else return orig ; if ( CONST_INT_P ( offset ) ) { if ( INT16_P ( INTVAL ( offset ) ) ) return plus_constant ( Pmode , base , INTVAL ( offset ) ) ; else { gcc_assert ( ! reload_in_progress && ! reload_completed ) ; offset = force_reg ( Pmode , offset ) ; } } return gen_rtx_PLUS ( Pmode ,


<s> if ( ( mode == SImode || mode == SFmode ) && GET_CODE ( x ) == POST_INC && REG_P ( XEXP ( x

, <NUM_LIT> ) ) && m32r_rtx_ok_for_base_p ( XEXP ( x , <NUM_LIT> ) , strict ) ) return true ;


<s> if ( GET_MODE_SIZE ( mode ) <= UNITS_PER_WORD )


<s> while ( GET_CODE ( a ) == SUBREG ) a = SUBREG_REG ( a ) ; if ( REG_P ( a ) ) reg_a = REGNO ( a ) ; while ( GET_CODE ( b ) == SUBREG ) b = SUBREG_REG ( b ) ; if ( REG_P ( b ) ) reg_b = REGNO ( b ) ; return reg_a !=


<s> int dst_offset = first_time ? <NUM_LIT> : <NUM_LIT> ; int dst_inc_amount = dst_offset + bytes - <NUM_LIT> ; int src_inc_amount = bytes - ( got_extra ? <NUM_LIT> : <NUM_LIT> ) ; int last_shift ; rtx my_operands [ <NUM_LIT> ] ; if ( ! got_extra ) output_asm_insn ( <STR_LIT> , operands ) ; if ( bytes >= <NUM_LIT> ) { bytes -= <NUM_LIT> ; output_asm_insn ( <STR_LIT> , operands ) ; my_operands [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; my_operands [ <NUM_LIT> ] = GEN_INT ( dst_offset ) ; my_operands [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; output_asm_insn ( <STR_LIT> , my_operands ) ; if ( bytes > <NUM_LIT> ) { dst_offset += <NUM_LIT> ; last_shift = <NUM_LIT> ; } } else last_shift = <NUM_LIT> ; if ( bytes > <NUM_LIT> ) { my_operands [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; my_operands [ <NUM_LIT> ] = GEN_INT ( last_shift ) ; output_asm_insn ( <STR_LIT> , my_operands ) ; my_operands [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; my_operands [ <NUM_LIT> ] = GEN_INT ( dst_offset ) ; my_operands [ <NUM_LIT> ] =


<s> static void m32r_output_function_epilogue ( FILE * ) { current_frame_info = zero_frame_info ; m32r_compute_function_type ( NULL_TREE )


<s> else if ( CONST_INT_P ( XEXP ( addr , <NUM_LIT> ) ) ) offset = INTVAL ( XEXP ( addr , <NUM_LIT> ) ) , base = XEXP ( addr , <NUM_LIT> ) ; else base = XEXP ( addr , <NUM_LIT> ) , index = XEXP ( addr , <NUM_LIT> ) ; if ( REG_P ( base ) ) { if ( index == <NUM_LIT> ) { if ( offset != <NUM_LIT> ) fprintf ( file , <STR_LIT> , offset ) ; fputs ( reg_names [ REGNO ( base ) ] , file ) ; } else if ( REG_P ( index ) ) fprintf ( file , <STR_LIT> , reg_names [ REGNO ( base ) ] , reg_names [ REGNO ( index ) ] ) ; else if ( GET_CODE ( index ) == SYMBOL_REF ) { output_addr_const ( file , index ) ; fputc ( ',' , file ) ; fputs ( reg_names [ REGNO ( base ) ] , file ) ; } else fatal_insn ( <STR_LIT> , addr ) ; } else if ( GET_CODE ( base ) == LO_SUM ) { gcc_assert ( ! index && REG_P ( XEXP ( base , <NUM_LIT> ) ) ) ; if ( small_data_operand ( XEXP ( base , <NUM_LIT> ) , VOIDmode ) ) fputs ( <STR_LIT> , file ) ; else fputs ( <STR_LIT> , file ) ; output_addr_const ( file , plus_constant ( Pmode , XEXP ( base , <NUM_LIT> ) , offset ) ) ; fputs ( <STR_LIT> , file ) ; fputs ( reg_names [ REGNO ( XEXP ( base , <NUM_LIT> ) ) ] , file ) ; } else fatal_insn ( <STR_LIT> , addr ) ; break ; case LO_SUM : if ( ! REG_P ( XEXP ( addr , <NUM_LIT> ) ) ) fatal_insn ( <STR_LIT> ,


<s> if ( size == <NUM_LIT> ) emit_insn ( gen_movsi ( lr , gen_frame_mem ( Pmode , sp ) ) ) ; else if ( size < <NUM_LIT> ) emit_insn ( gen_movsi ( lr , gen_frame_mem ( Pmode , gen_rtx_PLUS ( Pmode , sp , GEN_INT ( size ) ) ) ) ) ; else { rtx tmp = gen_rtx_REG ( Pmode , PROLOGUE_TMP_REGNUM ) ; emit_insn ( gen_movsi ( tmp , GEN_INT ( size ) ) ) ; emit_insn ( gen_addsi3 ( tmp , tmp , sp ) ) ; emit_insn ( gen_movsi ( lr , gen_frame_mem ( Pmode , tmp


<s> rtx m32r_return_addr ( int count ) { if ( count != <NUM_LIT>


<s> return get_hard_reg_initial_val ( Pmode ,


<s> cumulative_args_t dummy = pack_cumulative_args ( NULL ) ; function_arg_info arg ( const_cast < tree > ( type ) , false


<s> else { if ( GPR_P ( REGNO ( x ) ) || REGNO ( x ) == ARG_POINTER_REGNUM || ! HARD_REGISTER_P ( x ) ) return true ; } return false


<s> else { if ( GPR_P ( REGNO ( x ) ) || REGNO ( x ) == ARG_POINTER_REGNUM || !


<s> static inline bool m32r_rtx_ok_for_offset_p ( const_rtx x ) { return ( CONST_INT_P ( x ) && INT16_P (


<s> return ( CONST_INT_P ( x ) && INT16_P ( INTVAL ( x


<s> if ( no_rtl ) return ; gcc_assert ( arg . mode != BLKmode ) ; first_anon_arg = ( ROUND_ADVANCE_CUM ( * get_cumulative_args ( cum ) , arg . mode , arg . type ) + ROUND_ADVANCE_ARG ( arg . mode , arg . type ) ) ; if ( first_anon_arg < M32R_MAX_PARM_REGS ) { int first_reg_offset = first_anon_arg ; int size = M32R_MAX_PARM_REGS - first_reg_offset ; rtx regblock


<s> gcc_assert ( arg . mode != BLKmode ) ; first_anon_arg = ( ROUND_ADVANCE_CUM ( * get_cumulative_args ( cum ) , arg . mode , arg . type ) + ROUND_ADVANCE_ARG ( arg . mode , arg . type ) ) ; if ( first_anon_arg < M32R_MAX_PARM_REGS ) { int first_reg_offset =


<s> static HOST_WIDE_INT m32r_starting_frame_offset ( void ) { return M32R_STACK_ALIGN ( crtl -> outgoing_args_size


<s> if ( ( mode == SImode || mode == SFmode ) && ( GET_CODE ( x ) == PRE_INC || GET_CODE ( x ) == PRE_DEC ) && REG_P ( XEXP ( x , <NUM_LIT> ) ) \ && m32r_rtx_ok_for_base_p (

XEXP ( x , <NUM_LIT> ) , strict ) ) return true ;


<s> if ( ( mode == SImode || mode == SFmode ) && ( GET_CODE ( x ) == PRE_INC || GET_CODE ( x ) == PRE_DEC ) && REG_P ( XEXP ( x , <NUM_LIT> ) ) \ && m32r_rtx_ok_for_base_p ( XEXP ( x , <NUM_LIT> ) , strict ) ) return true ; return false


<s> bool memreg_operand ( rtx op , machine_mode mode ATTRIBUTE_UNUSED ) { return MEM_P ( op ) && REG_P ( XEXP ( op , <NUM_LIT>


<s> rtx x ; x = emit_insn ( gen_movsi_pop ( gen_rtx_REG ( Pmode , regno )


<s> if ( GET_CODE ( op ) == SYMBOL_REF ) return SYMBOL_REF_SMALL_P ( op ) ; if ( GET_CODE ( op ) == CONST && GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF && satisfies_constraint_J ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) ) return SYMBOL_REF_SMALL_P ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) ; return


<s> return CONST_INT_P ( operand1 ) && CONST_INT_P ( operand2 ) && ( ( ( INTVAL ( operand1 ) == <NUM_LIT> ) && ( INTVAL ( operand2 ) == <NUM_LIT> ) ) || ( ( INTVAL

( operand1 ) == <NUM_LIT> ) && ( INTVAL ( operand2 ) == <NUM_LIT> ) ) ) ;