<s> next_cum = * get_cumulative_args ( cum ) ; if ( ! TYPE_NO_NAMED_ARGS_STDARG_P ( TREE_TYPE ( current_function_decl ) ) ) next_cum = ( ROUND_ADVANCE_CUM ( next_cum , arg . mode , arg . type ) + ROUND_ADVANCE_ARG ( arg . mode , arg . type ) ) ; first_anon_arg = next_cum ; if ( first_anon_arg < MAX_EPIPHANY_PARM_REGS && ! no_rtl ) { int first_reg_offset = first_anon_arg ; * pretend_size = ( ( MAX_EPIPHANY_PARM_REGS - first_reg_offset ) * UNITS_PER_WORD ) ; } mf -> args_parsed = <NUM_LIT> ; mf -> pretend_args_odd = ( ( * pretend_size & UNITS_PER_WORD ) ? <NUM_LIT> : <NUM_LIT> ) ;


<s> next_cum = * get_cumulative_args ( cum ) ; if ( ! TYPE_NO_NAMED_ARGS_STDARG_P ( TREE_TYPE ( current_function_decl ) ) ) next_cum = ( ROUND_ADVANCE_CUM ( next_cum , arg . mode , arg . type ) + ROUND_ADVANCE_ARG ( arg . mode , arg . type ) ) ; first_anon_arg = next_cum ; if ( first_anon_arg < MAX_EPIPHANY_PARM_REGS && ! no_rtl ) {


<s> dep_set = single_set ( dep_insn ) ; if ( dep_set && MEM_P ( SET_SRC ( dep_set ) ) && cost > <NUM_LIT> ) { rtx set = single_set ( insn ) ;

if ( set && ! reg_overlap_mentioned_p ( SET_DEST ( dep_set ) , SET_SRC ( set ) ) && ( ! MEM_P ( SET_DEST ( set ) ) || ! reg_overlap_mentioned_p ( SET_DEST ( dep_set ) , XEXP ( SET_DEST ( set ) , <NUM_LIT> ) ) ) ) cost = <NUM_LIT> ;


<s> unsigned epiphany_adjust_field_align ( tree field , unsigned computed ) {

if ( computed == <NUM_LIT> && TREE_CODE ( TREE_TYPE ( field ) ) == ARRAY_TYPE ) {


<s> unsigned epiphany_adjust_field_align ( tree field , unsigned computed ) { if ( computed == <NUM_LIT> && TREE_CODE ( TREE_TYPE ( field ) ) == ARRAY_TYPE ) { tree elmsz = TYPE_SIZE ( TREE_TYPE ( TREE_TYPE ( field ) ) ) ; if ( ! tree_fits_uhwi_p ( elmsz ) || tree_to_uhwi ( elmsz ) >= <NUM_LIT> ) return <NUM_LIT> ;


<s> int words = <NUM_LIT> , rounded_cum ; gcc_assert ( ! epiphany_pass_by_reference ( cum , mode , type , true ) ) ; rounded_cum = ROUND_ADVANCE_CUM ( * get_cumulative_args ( cum ) , mode , type ) ; if ( rounded_cum < MAX_EPIPHANY_PARM_REGS ) { words = MAX_EPIPHANY_PARM_REGS - rounded_cum ;

if ( words >= ROUND_ADVANCE_ARG ( mode , type ) ) words = <NUM_LIT> ;


<s> if ( MUST_SAVE_REGISTER ( regno , interrupt_p ) ) { gcc_assert ( ! TEST_HARD_REG_BIT ( gmask , regno ) ) ; reg_size += UNITS_PER_WORD ; SET_HARD_REG_BIT ( gmask , regno ) ; if ( regno == first_slot ) gcc_assert ( regno == GPR_FP && frame_pointer_needed ) ; else if ( ! interrupt_p && first_slot < <NUM_LIT> ) first_slot = regno ; else if ( last_slot < <NUM_LIT> && ( first_slot ^ regno ) != <NUM_LIT> && ( ! interrupt_p || regno > GPR_1 ) ) last_slot = regno ; } } if ( TEST_HARD_REG_BIT ( gmask , GPR_LR ) ) MACHINE_FUNCTION ( cfun ) -> lr_clobbered = <NUM_LIT> ; current_frame_info . small_threshold = ( optimize >= <NUM_LIT> || interrupt_p ? <NUM_LIT> : pretend_size ? small_slots : <NUM_LIT> + small_slots - ( first_slot == GPR_FP ) ) ; if ( var_size >= <NUM_LIT> * UNITS_PER_WORD || ( reg_size > <NUM_LIT> && optimize ) ) reg_size = EPIPHANY_STACK_ALIGN ( reg_size ) ; if ( ( ( total_size + reg_size + EPIPHANY_STACK_ALIGN ( <NUM_LIT> ) ) <= ( unsigned ) epiphany_stack_offset ) && ! interrupt_p && crtl -> is_leaf && ! frame_pointer_needed ) { first_slot = - <NUM_LIT> ; last_slot = - <NUM_LIT> ; goto alloc_done ; } else if ( reg_size && ! interrupt_p && reg_size < ( unsigned HOST_WIDE_INT ) epiphany_stack_offset ) reg_size = epiphany_stack_offset ; if ( interrupt_p ) { if ( total_size + reg_size < <NUM_LIT> ) { first_slot_offset = EPIPHANY_STACK_ALIGN ( total_size + reg_size ) ; first_slot_offset += EPIPHANY_STACK_ALIGN ( epiphany_stack_offset ) ; last_slot = - <NUM_LIT> ; } else { first_slot_offset = EPIPHANY_STACK_ALIGN ( reg_size ) ; last_slot_offset = EPIPHANY_STACK_ALIGN ( total_size ) ; last_slot_offset += EPIPHANY_STACK_ALIGN ( epiphany_stack_offset ) ; if ( last_slot >= <NUM_LIT> ) CLEAR_HARD_REG_BIT ( gmask , last_slot ) ; } } else if ( total_size + reg_size < <NUM_LIT> && first_slot >= <NUM_LIT> ) { first_slot_offset = EPIPHANY_STACK_ALIGN ( total_size + reg_size ) ; last_slot = - <NUM_LIT> ; } else {

if ( total_size + reg_size <= ( unsigned ) epiphany_stack_offset ) {


<s> for ( regno = MAX_EPIPHANY_PARM_REGS - <NUM_LIT> ; pretend_size > reg_size ; regno -- ) { reg_size += UNITS_PER_WORD ; SET_HARD_REG_BIT ( gmask , regno ) ; if ( epiphany_stack_offset - reg_size == <NUM_LIT> ) first_slot = regno ; } if ( interrupt_p ) reg_size += <NUM_LIT> * UNITS_PER_WORD ; else small_slots = epiphany_stack_offset / UNITS_PER_WORD ; if ( frame_pointer_needed ) { current_frame_info . need_fp = <NUM_LIT> ; if ( ! interrupt_p && first_slot < <NUM_LIT> ) first_slot = GPR_FP ; } else current_frame_info . need_fp = <NUM_LIT> ; for ( regno = <NUM_LIT> ; regno <= GPR_LAST ; regno ++ ) { if ( MUST_SAVE_REGISTER ( regno , interrupt_p ) ) { gcc_assert ( ! TEST_HARD_REG_BIT ( gmask , regno ) ) ; reg_size += UNITS_PER_WORD ; SET_HARD_REG_BIT ( gmask , regno ) ; if ( regno == first_slot ) gcc_assert ( regno == GPR_FP && frame_pointer_needed ) ; else if ( ! interrupt_p && first_slot < <NUM_LIT> ) first_slot = regno ; else if ( last_slot < <NUM_LIT> && ( first_slot ^ regno ) != <NUM_LIT> && ( ! interrupt_p || regno > GPR_1 ) ) last_slot = regno ; } } if ( TEST_HARD_REG_BIT ( gmask , GPR_LR ) ) MACHINE_FUNCTION ( cfun ) -> lr_clobbered = <NUM_LIT> ; current_frame_info . small_threshold = ( optimize >= <NUM_LIT> || interrupt_p ? <NUM_LIT> : pretend_size ? small_slots : <NUM_LIT> + small_slots - ( first_slot == GPR_FP ) ) ; if ( var_size >= <NUM_LIT> * UNITS_PER_WORD || ( reg_size > <NUM_LIT> && optimize ) ) reg_size = EPIPHANY_STACK_ALIGN ( reg_size ) ; if ( ( ( total_size + reg_size + EPIPHANY_STACK_ALIGN ( <NUM_LIT> ) ) <= ( unsigned ) epiphany_stack_offset ) && ! interrupt_p && crtl -> is_leaf && ! frame_pointer_needed ) { first_slot = - <NUM_LIT> ; last_slot = - <NUM_LIT> ; goto alloc_done ; } else if ( reg_size && ! interrupt_p && reg_size < ( unsigned HOST_WIDE_INT ) epiphany_stack_offset ) reg_size = epiphany_stack_offset ; if ( interrupt_p ) { if ( total_size + reg_size < <NUM_LIT> ) { first_slot_offset = EPIPHANY_STACK_ALIGN ( total_size + reg_size ) ; first_slot_offset += EPIPHANY_STACK_ALIGN ( epiphany_stack_offset ) ; last_slot = - <NUM_LIT> ; } else { first_slot_offset = EPIPHANY_STACK_ALIGN ( reg_size ) ; last_slot_offset = EPIPHANY_STACK_ALIGN ( total_size ) ; last_slot_offset += EPIPHANY_STACK_ALIGN ( epiphany_stack_offset ) ; if ( last_slot >= <NUM_LIT> ) CLEAR_HARD_REG_BIT ( gmask , last_slot ) ; } } else if ( total_size + reg_size < <NUM_LIT> && first_slot >= <NUM_LIT> ) { first_slot_offset = EPIPHANY_STACK_ALIGN ( total_size + reg_size ) ; last_slot = - <NUM_LIT> ; } else { if ( total_size + reg_size <= ( unsigned ) epiphany_stack_offset ) { gcc_assert ( first_slot < <NUM_LIT> ) ; gcc_assert ( reg_size == <NUM_LIT> || ( int ) reg_size == epiphany_stack_offset ) ; last_slot_offset = EPIPHANY_STACK_ALIGN ( total_size + reg_size ) ;


<s> fixed_regs [ i ] = <NUM_LIT> ; call_used_regs [ i ] = <NUM_LIT> ; } } if ( epiphany_m1reg >= <NUM_LIT> ) { fixed_regs [ epiphany_m1reg ] = <NUM_LIT> ; call_used_regs [ epiphany_m1reg ] = <NUM_LIT> ; } if ( ! TARGET_PREFER_SHORT_INSN_REGS ) CLEAR_HARD_REG_SET ( reg_class_contents [ SHORT_INSN_REGS ] ) ; COPY_HARD_REG_SET ( reg_class_contents [ SIBCALL_REGS ] , reg_class_contents [ GENERAL_REGS ] ) ;

for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( ! call_used_regs [ i ] ) CLEAR_HARD_REG_BIT ( reg_class_contents [ SIBCALL_REGS ] , i ) ;


<s> int interrupt_p ; enum epiphany_function_type fn_type ; rtx addr , mem , off , reg ; if ( ! current_frame_info . initialized ) epiphany_compute_frame_size ( get_frame_size ( ) ) ; if ( flag_stack_usage_info ) current_function_static_stack_size = current_frame_info . total_size ; fn_type = epiphany_compute_function_type ( current_function_decl ) ; interrupt_p = EPIPHANY_INTERRUPT_P ( fn_type ) ; if ( interrupt_p ) { addr = plus_constant ( Pmode , stack_pointer_rtx , - ( HOST_WIDE_INT ) <NUM_LIT> * UNITS_PER_WORD ) ; if ( ! lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( current_function_decl ) ) || ! epiphany_is_long_call_p ( XEXP ( DECL_RTL ( current_function_decl ) , <NUM_LIT> ) ) ) frame_move_insn ( gen_frame_mem ( DImode , addr ) , gen_rtx_REG ( DImode , GPR_0 ) ) ; frame_move_insn ( gen_rtx_REG ( SImode , GPR_0 ) , gen_rtx_REG ( word_mode , STATUS_REGNUM ) ) ; frame_move_insn ( gen_rtx_REG ( SImode , GPR_1 ) , gen_rtx_REG ( word_mode , IRET_REGNUM ) ) ; mem = gen_frame_mem ( BLKmode , stack_pointer_rtx ) ; off = GEN_INT ( - current_frame_info . first_slot_offset ) ; frame_insn ( gen_stack_adjust_add ( off , mem ) ) ; if ( ! epiphany_uninterruptible_p ( current_function_decl ) ) emit_insn ( gen_gie ( ) ) ; addr = plus_constant ( Pmode , stack_pointer_rtx , current_frame_info . first_slot_offset - ( HOST_WIDE_INT ) <NUM_LIT> * UNITS_PER_WORD ) ; } else { addr = plus_constant ( Pmode , stack_pointer_rtx , epiphany_stack_offset - ( HOST_WIDE_INT ) UNITS_PER_WORD ) ; epiphany_emit_save_restore ( <NUM_LIT> , current_frame_info . small_threshold , addr , <NUM_LIT> ) ; if ( current_frame_info . first_slot >= <NUM_LIT> ) { machine_mode mode = ( current_frame_info . first_slot_size == UNITS_PER_WORD ? word_mode : DImode ) ; off = GEN_INT ( - current_frame_info . first_slot_offset ) ; mem = gen_frame_mem ( BLKmode , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , off ) ) ; frame_insn ( gen_stack_adjust_str ( gen_frame_mem ( mode , stack_pointer_rtx ) , gen_rtx_REG ( mode , current_frame_info . first_slot ) , off , mem ) ) ; addr = plus_constant ( Pmode , addr , current_frame_info . first_slot_offset ) ; } } epiphany_emit_save_restore ( current_frame_info . small_threshold , FIRST_PSEUDO_REGISTER , addr , <NUM_LIT> ) ; if ( current_frame_info . need_fp ) frame_move_insn ( hard_frame_pointer_rtx , stack_pointer_rtx ) ; if ( current_frame_info . last_slot >= <NUM_LIT> ) { rtx ip , mem2 , note ; rtx_insn * insn ; gcc_assert ( current_frame_info . last_slot != GPR_FP || ( ! current_frame_info . need_fp && current_frame_info . first_slot < <NUM_LIT> ) ) ;

off = GEN_INT ( - current_frame_info . last_slot_offset ) ;


<s> fn_type = epiphany_compute_function_type ( current_function_decl ) ; interrupt_p = EPIPHANY_INTERRUPT_P ( fn_type ) ; if ( interrupt_p ) { addr = plus_constant ( Pmode , stack_pointer_rtx , - ( HOST_WIDE_INT ) <NUM_LIT> * UNITS_PER_WORD ) ; if ( ! lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( current_function_decl ) ) || ! epiphany_is_long_call_p ( XEXP ( DECL_RTL ( current_function_decl ) , <NUM_LIT> ) ) ) frame_move_insn ( gen_frame_mem ( DImode , addr ) , gen_rtx_REG ( DImode , GPR_0 ) ) ; frame_move_insn ( gen_rtx_REG ( SImode , GPR_0 ) , gen_rtx_REG ( word_mode , STATUS_REGNUM ) ) ; frame_move_insn ( gen_rtx_REG ( SImode , GPR_1 ) , gen_rtx_REG ( word_mode , IRET_REGNUM ) ) ; mem = gen_frame_mem ( BLKmode , stack_pointer_rtx ) ; off = GEN_INT ( - current_frame_info . first_slot_offset ) ; frame_insn ( gen_stack_adjust_add ( off , mem ) ) ; if ( ! epiphany_uninterruptible_p ( current_function_decl ) ) emit_insn ( gen_gie ( ) ) ; addr = plus_constant ( Pmode , stack_pointer_rtx , current_frame_info . first_slot_offset - ( HOST_WIDE_INT ) <NUM_LIT> * UNITS_PER_WORD ) ; } else { addr = plus_constant ( Pmode , stack_pointer_rtx , epiphany_stack_offset - ( HOST_WIDE_INT ) UNITS_PER_WORD ) ; epiphany_emit_save_restore ( <NUM_LIT> , current_frame_info . small_threshold , addr , <NUM_LIT> ) ; if ( current_frame_info . first_slot >= <NUM_LIT> ) { machine_mode mode = ( current_frame_info . first_slot_size == UNITS_PER_WORD ? word_mode : DImode ) ; off = GEN_INT ( - current_frame_info . first_slot_offset ) ; mem = gen_frame_mem ( BLKmode , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , off ) ) ; frame_insn ( gen_stack_adjust_str ( gen_frame_mem ( mode , stack_pointer_rtx ) , gen_rtx_REG ( mode , current_frame_info . first_slot ) , off , mem ) ) ;

addr = plus_constant ( Pmode , addr , current_frame_info . first_slot_offset ) ;


<s> static rtx epiphany_function_arg ( cumulative_args_t cum_v , machine_mode mode , const_tree type , bool named ATTRIBUTE_UNUSED ) {

CUMULATIVE_ARGS cum = * get_cumulative_args ( cum_v ) ;


<s> static rtx epiphany_function_arg ( cumulative_args_t cum_v , machine_mode mode , const_tree type , bool named ATTRIBUTE_UNUSED ) { CUMULATIVE_ARGS cum = * get_cumulative_args ( cum_v ) ;

if ( PASS_IN_REG_P ( cum , mode , type ) ) return gen_rtx_REG ( mode , ROUND_ADVANCE_CUM ( cum , mode , type ) ) ;


<s> static void epiphany_function_arg_advance ( cumulative_args_t cum_v , machine_mode mode , const_tree type , bool named ATTRIBUTE_UNUSED ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; * cum = ROUND_ADVANCE_CUM ( * cum , mode , type ) + ROUND_ADVANCE_ARG ( mode , type ) ;


<s> else if ( i <= <NUM_LIT> && TARGET_PREFER_SHORT_INSN_REGS ) epiphany_regno_reg_class [ i ] = SHORT_INSN_REGS ; else if ( call_used_regs [ i ] && TEST_HARD_REG_BIT ( reg_class_contents [ GENERAL_REGS ] , i ) ) epiphany_regno_reg_class [ i ] = SIBCALL_REGS ; else if ( i >= CORE_CONTROL_FIRST && i <= CORE_CONTROL_LAST ) epiphany_regno_reg_class [ i ] = CORE_CONTROL_REGS ; else if ( i < ( GPR_LAST + <NUM_LIT> ) || i == ARG_POINTER_REGNUM || i == FRAME_POINTER_REGNUM ) epiphany_regno_reg_class [ i ] = GENERAL_REGS ; else if ( i == CC_REGNUM ) epiphany_regno_reg_class [ i ] = NO_REGS ;

else epiphany_regno_reg_class [ i ] = NO_REGS ;


<s> const char * this_name = reg_names [ this_regno ] ; const char * fname ; gcc_assert ( call_used_regs [ GPR_IP ] ) ; gcc_assert ( call_used_regs [ GPR_16 ] ) ; if ( delta == <NUM_LIT> ) ; else if ( SIMM11 ( delta ) ) asm_fprintf ( file , <STR_LIT> , this_name , this_name , ( int ) delta ) ; else if ( delta < <NUM_LIT> && delta >= - <NUM_LIT> ) { asm_fprintf ( file , <STR_LIT> , ( int ) - delta ) ; asm_fprintf ( file , <STR_LIT> , this_name , this_name ) ; } else { asm_fprintf ( file , <STR_LIT> , ( long ) delta ) ; if ( delta & ~ <NUM_LIT> ) asm_fprintf ( file , <STR_LIT> , ( long ) delta ) ;


if ( AGGREGATE_TYPE_P ( type ) && ( mode == BLKmode || TYPE_NEEDS_CONSTRUCTING ( type ) ) ) return true ;


<s> return TARGET_VECT_DOUBLE ? DImode : SImode ;


<s> fputs ( REG_P ( x ) ? <STR_LIT> : <STR_LIT> , file ) ; break ; case '-' : fprintf ( file , <STR_LIT> , epiphany_m1reg ) ; return ; case <NUM_LIT> : break ; default : output_operand_lossage ( <STR_LIT> ) ; } switch ( GET_CODE ( x ) ) { rtx addr ; rtx offset ; case REG : fputs ( reg_names [ REGNO ( x ) ] , file ) ; break ; case MEM : if ( code == <NUM_LIT> ) current_frame_info . stld_sz = <NUM_LIT> ; fputc ( '[' , file ) ; addr = XEXP ( x , <NUM_LIT> ) ; switch ( GET_CODE ( addr ) ) { case POST_INC : offset = GEN_INT ( GET_MODE_SIZE ( GET_MODE ( x ) ) ) ; addr = XEXP ( addr , <NUM_LIT> ) ; break ; case POST_DEC : offset = GEN_INT ( - GET_MODE_SIZE ( GET_MODE ( x ) ) ) ; addr = XEXP ( addr , <NUM_LIT> ) ; break ; case POST_MODIFY : offset = XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ; addr = XEXP ( addr , <NUM_LIT> ) ; break ; default : offset = <NUM_LIT> ; break ; } output_address ( addr ) ; fputc ( ']' , file ) ; if ( offset ) {


<s> else if ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == CONST_INT ) offset = INTVAL ( XEXP ( addr , <NUM_LIT> ) ) , base = XEXP ( addr , <NUM_LIT> ) ; else base = XEXP ( addr , <NUM_LIT> ) , index = XEXP ( addr , <NUM_LIT> ) ; gcc_assert ( GET_CODE ( base ) == REG ) ; fputs ( reg_names [ REGNO ( base ) ] , file ) ; if ( index == <NUM_LIT> ) { fprintf ( file , <STR_LIT> , IMMEDIATE_PREFIX , offset / current_frame_info . stld_sz ) ; } else { switch ( GET_CODE ( index ) ) { case REG : fprintf ( file , <STR_LIT> , reg_names [ REGNO ( index ) ] ) ; break ; case SYMBOL_REF : fputc ( ',' , file ) , output_addr_const ( file , index ) ;


<s> * total = outer_code == SET ? <NUM_LIT> : COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } case CONST : case LABEL_REF : case SYMBOL_REF : * total = COSTS_N_INSNS ( ( epiphany_small16 ( x ) ? <NUM_LIT> : <NUM_LIT> ) + ( outer_code == SET ? <NUM_LIT> : <NUM_LIT> ) ) ; return true ; case CONST_DOUBLE : { rtx high , low ; split_double ( x , & high , & low ) ; * total = COSTS_N_INSNS ( ! IMM16 ( INTVAL ( high ) ) + ! IMM16 ( INTVAL ( low ) ) ) ; return true ; } case ASHIFT : case ASHIFTRT : case LSHIFTRT : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case COMPARE : switch ( GET_MODE ( x ) ) { case CC_N_NEmode : case CC_C_LTUmode : case CC_C_GTUmode : return true ; default : return false ; } case SET : { rtx src = SET_SRC ( x ) ; if ( BINARY_P ( src ) ) * total = <NUM_LIT> ; return false ; }


<s> * pretend_size = ( ( MAX_EPIPHANY_PARM_REGS - first_reg_offset ) * UNITS_PER_WORD ) ; } mf -> args_parsed = <NUM_LIT> ; mf -> pretend_args_odd = ( ( * pretend_size & UNITS_PER_WORD ) ? <NUM_LIT> : <NUM_LIT> ) ;


<s> char buf [ <NUM_LIT> ] ; int_name = TREE_VALUE ( int_names ) ; sprintf ( buf , <STR_LIT> , TREE_STRING_POINTER ( int_name ) ) ; switch_to_section ( get_section ( buf , SECTION_CODE , decl ) ) ; fputs ( <STR_LIT> , file ) ; assemble_name ( file , name ) ; fputc ( '\n' , file ) ; } forwarder_attr = lookup_attribute ( <STR_LIT> , attrs ) ; if ( forwarder_attr ) { const char * prefix = <STR_LIT> ; char * dst_name = ( char * ) alloca ( strlen ( prefix ) + strlen ( name ) + <NUM_LIT> ) ;


<s> int_names = TREE_CHAIN ( int_names ) ) { char buf [ <NUM_LIT> ] ; int_name = TREE_VALUE ( int_names ) ; sprintf ( buf , <STR_LIT> , TREE_STRING_POINTER ( int_name ) ) ; switch_to_section ( get_section ( buf , SECTION_CODE , decl ) ) ; fputs ( <STR_LIT> , file ) ; assemble_name ( file , name ) ; fputc ( '\n' , file ) ; } forwarder_attr = lookup_attribute ( <STR_LIT> , attrs ) ; if ( forwarder_attr ) { const char * prefix = <STR_LIT> ; char * dst_name = ( char * ) alloca ( strlen ( prefix ) + strlen ( name ) + <NUM_LIT> ) ; strcpy ( dst_name , prefix ) ; strcat ( dst_name , name ) ; forwarder_attr = TREE_VALUE ( TREE_VALUE ( forwarder_attr ) ) ; switch_to_section ( get_section ( TREE_STRING_POINTER ( forwarder_attr ) , SECTION_CODE , decl ) ) ; ASM_OUTPUT_FUNCTION_LABEL ( file , name , decl ) ; if ( epiphany_is_long_call_p ( XEXP ( DECL_RTL ( decl ) , <NUM_LIT> ) ) ) { int tmp = GPR_0 ; if ( int_attr ) fputs ( <STR_LIT> , file ) ; else tmp = GPR_16 ; gcc_assert ( call_used_regs [ tmp ] ) ; fprintf ( file , <STR_LIT> , tmp ) ; assemble_name ( file , dst_name ) ; fprintf ( file , <STR_LIT> <STR_LIT> , tmp ) ; assemble_name ( file , dst_name ) ;


<s> return frame_insn ( gen_rtx_SET ( VOIDmode , to , from ) ) ;


<s> rtx dst = simplify_gen_subreg ( SImode , SET_DEST ( set ) , DImode , offset ) ; set = gen_rtx_SET ( VOIDmode , dst , src ) ;

RTX_FRAME_RELATED_P ( set ) = <NUM_LIT> ;


<s> rtx src = simplify_gen_subreg ( SImode , SET_SRC ( set ) , DImode , offset ) ; rtx dst = simplify_gen_subreg ( SImode , SET_DEST ( set ) , DImode , offset ) ; set = gen_rtx_SET ( VOIDmode , dst , src ) ; RTX_FRAME_RELATED_P ( set ) = <NUM_LIT> ; return set ;


<s> if ( in_mode == VOIDmode ) in_mode = GET_MODE ( x ) ; if ( in_mode == VOIDmode ) in_mode = GET_MODE ( y ) ; if ( mode == CC_FPmode ) { if ( code == GT || code == GE || code == UNLE || code == UNLT ) { rtx tmp = x ; x = y ; y = tmp ; code = swap_condition ( code ) ; } cc_reg = gen_rtx_REG ( mode , CCFP_REGNUM ) ; y = force_reg ( in_mode , y ) ; } else { if ( mode == CC_FP_GTEmode && ( code == LE || code == LT || code == UNGT || code == UNGE ) ) { if ( flag_finite_math_only && ( ( REG_P ( x ) && REGNO ( x ) == GPR_0 ) || ( REG_P ( y ) && REGNO ( y ) == GPR_1 ) ) ) switch ( code ) { case LE : code = UNLE ; break ; case LT : code = UNLT ; break ; case UNGT : code = GT ; break ; case UNGE : code = GE ; break ;


<s> switch ( GET_CODE ( comparison ) ) { case EQ : return <NUM_LIT> ; case NE : return <NUM_LIT> ; case LT : return <NUM_LIT> ; case LE : return <NUM_LIT> ; default : gcc_unreachable ( ) ; } case CC_FP_EQmode : switch ( GET_CODE ( comparison ) ) { case EQ : return <NUM_LIT> ; case NE : return <NUM_LIT> ; default : gcc_unreachable ( ) ; } case CC_FP_GTEmode : switch ( GET_CODE ( comparison ) ) { case EQ : return <NUM_LIT> ; case NE : return <NUM_LIT> ; case GT : return <NUM_LIT> ; case GE : return <NUM_LIT> ; case UNLE : return <NUM_LIT> ; case UNLT : return <NUM_LIT> ; default : gcc_unreachable ( ) ; } case CC_FP_ORDmode : switch ( GET_CODE ( comparison ) ) { case ORDERED : return <NUM_LIT> ; case UNORDERED : return <NUM_LIT> ;


<s> case NE : return <NUM_LIT> ; case LTU : return <NUM_LIT> ; case GEU : return <NUM_LIT> ; case GT : return <NUM_LIT> ; case LE : return <NUM_LIT> ; case GE : return <NUM_LIT> ; case LT : return <NUM_LIT> ; case GTU : return <NUM_LIT> ; case LEU : return <NUM_LIT> ; default : gcc_unreachable ( ) ; } case CC_N_NEmode : switch ( GET_CODE ( comparison ) ) { case EQ : return <NUM_LIT> ; case NE : return <NUM_LIT> ; default : gcc_unreachable ( ) ; } case CC_C_LTUmode : switch ( GET_CODE ( comparison ) ) { case GEU : return <NUM_LIT> ; case LTU : return <NUM_LIT> ; default : gcc_unreachable ( ) ; } case CC_C_GTUmode : switch ( GET_CODE ( comparison ) ) { case LEU : return <NUM_LIT> ; case GTU : return <NUM_LIT> ; default : gcc_unreachable ( ) ; } case CC_FPmode : switch ( GET_CODE ( comparison ) ) { case EQ : return <NUM_LIT> ; case NE : return <NUM_LIT> ; case LT : return <NUM_LIT> ; case LE : return <NUM_LIT> ; default : gcc_unreachable ( ) ; } case CC_FP_EQmode : switch ( GET_CODE ( comparison ) ) { case EQ : return <NUM_LIT> ; case NE : return <NUM_LIT> ; default : gcc_unreachable ( ) ; } case CC_FP_GTEmode : switch ( GET_CODE ( comparison ) ) { case EQ : return <NUM_LIT> ; case NE : return <NUM_LIT> ; case GT : return <NUM_LIT> ; case GE : return <NUM_LIT> ; case UNLE : return <NUM_LIT> ; case UNLT : return <NUM_LIT> ; default : gcc_unreachable ( ) ; } case CC_FP_ORDmode : switch ( GET_CODE ( comparison ) ) { case ORDERED : return <NUM_LIT> ; case UNORDERED : return <NUM_LIT> ; default : gcc_unreachable ( ) ;


<s> int hard_regno_mode_ok ( int regno , machine_mode mode ) { if ( GET_MODE_SIZE ( mode ) > UNITS_PER_WORD ) return ( regno & <NUM_LIT> ) == <NUM_LIT> && GPR_P ( regno ) ; else return <NUM_LIT> ;


<s> } if ( entity == EPIPHANY_MSW_ENTITY_AND ) { gcc_assert ( mode >= <NUM_LIT> && mode <= <NUM_LIT> ) ; if ( mode == <NUM_LIT> ) emit_move_insn ( MACHINE_FUNCTION ( cfun ) -> and_mask , gen_int_mode ( <NUM_LIT> , SImode ) ) ; return ; } else if ( entity == EPIPHANY_MSW_ENTITY_OR ) { gcc_assert ( mode >= <NUM_LIT> && mode <= <NUM_LIT> ) ; if ( mode == <NUM_LIT> ) emit_move_insn ( MACHINE_FUNCTION ( cfun ) -> or_mask , GEN_INT ( <NUM_LIT> ) ) ; return ; } else if ( entity == EPIPHANY_MSW_ENTITY_CONFIG ) { gcc_assert ( mode >= <NUM_LIT> && mode <= <NUM_LIT> ) ; rtx save = get_hard_reg_initial_val ( SImode , CONFIG_REGNUM ) ; if ( mode == <NUM_LIT> ) emit_insn ( gen_save_config ( save ) ) ; return ; } fp_mode = ( enum attr_fp_mode ) mode ; src = NULL_RTX ; switch ( fp_mode ) { case FP_MODE_CALLER : gcc_assert ( entity > EPIPHANY_MSW_ENTITY_CONFIG ) ; src = get_hard_reg_initial_val ( SImode , CONFIG_REGNUM ) ; mask = MACHINE_FUNCTION ( cfun ) -> and_mask ; break ; case FP_MODE_ROUND_UNKNOWN : MACHINE_FUNCTION ( cfun ) -> unknown_mode_sets ++ ; mask = MACHINE_FUNCTION ( cfun ) -> and_mask ; break ; case FP_MODE_ROUND_NEAREST : if ( entity == EPIPHANY_MSW_ENTITY_TRUNC ) return ; mask = MACHINE_FUNCTION ( cfun ) -> and_mask ; break ; case FP_MODE_ROUND_TRUNC : if ( entity == EPIPHANY_MSW_ENTITY_NEAREST ) return ; mask = MACHINE_FUNCTION ( cfun ) -> and_mask ; break ; case FP_MODE_INT : mask = MACHINE_FUNCTION ( cfun ) -> or_mask ; break ; case FP_MODE_NONE : default : gcc_unreachable ( ) ; } save_cc = gen_reg_rtx ( CCmode ) ; cc_reg = gen_rtx_REG ( CCmode , CC_REGNUM ) ; emit_move_insn ( save_cc , cc_reg ) ;


<s> static int epiphany_adjust_cost ( rtx_insn * insn , int dep_type , rtx_insn * dep_insn , int cost , unsigned int ) { if ( dep_type == <NUM_LIT> ) { rtx dep_set ;

if ( recog_memoized ( insn ) < <NUM_LIT> || recog_memoized ( dep_insn ) < <NUM_LIT> ) return cost ;


<s> unsigned epiphany_adjust_field_align ( tree type , unsigned computed ) {

if ( computed == <NUM_LIT> && TREE_CODE ( type ) == ARRAY_TYPE ) {


<s> rounded_cum = ROUND_ADVANCE_CUM ( * get_cumulative_args ( cum ) , arg . mode , arg . type ) ; if ( rounded_cum < MAX_EPIPHANY_PARM_REGS ) { words = MAX_EPIPHANY_PARM_REGS - rounded_cum ; if ( words >= ROUND_ADVANCE_ARG ( arg . mode , arg . type ) ) words = <NUM_LIT> ;


<s> if ( GET_CODE ( addr ) == SYMBOL_REF ) t = SYMBOL_REF_DECL ( addr ) ;


current_frame_info . initialized = reload_completed ;


<s> int regno ; unsigned int total_size , var_size , args_size , pretend_size , reg_size ; HARD_REG_SET gmask ; enum epiphany_function_type fn_type ; int interrupt_p ; int first_slot , last_slot , first_slot_offset , last_slot_offset ; int first_slot_size ; int small_slots = <NUM_LIT> ; var_size = size ; args_size = crtl -> outgoing_args_size ; pretend_size = crtl -> args . pretend_args_size ; total_size = args_size + var_size ; reg_size = <NUM_LIT> ; CLEAR_HARD_REG_SET ( gmask ) ; first_slot = - <NUM_LIT> ; first_slot_offset = <NUM_LIT> ; last_slot = - <NUM_LIT> ; last_slot_offset = <NUM_LIT> ; first_slot_size = UNITS_PER_WORD ; fn_type = epiphany_compute_function_type ( current_function_decl ) ; interrupt_p = EPIPHANY_INTERRUPT_P ( fn_type ) ; for ( regno = MAX_EPIPHANY_PARM_REGS - <NUM_LIT> ; pretend_size > reg_size ; regno -- ) { reg_size += UNITS_PER_WORD ; SET_HARD_REG_BIT ( gmask , regno ) ; if ( epiphany_stack_offset - reg_size == <NUM_LIT> ) first_slot = regno ; } if ( interrupt_p ) reg_size += <NUM_LIT> * UNITS_PER_WORD ; else small_slots = epiphany_stack_offset / UNITS_PER_WORD ; if ( frame_pointer_needed ) { current_frame_info . need_fp = <NUM_LIT> ; if ( ! interrupt_p && first_slot < <NUM_LIT> ) first_slot = GPR_FP ; } else current_frame_info . need_fp = <NUM_LIT> ; for ( regno = <NUM_LIT> ; regno <= GPR_LAST ; regno ++ ) { if ( MUST_SAVE_REGISTER ( regno , interrupt_p ) ) { gcc_assert ( ! TEST_HARD_REG_BIT ( gmask , regno ) ) ; reg_size += UNITS_PER_WORD ; SET_HARD_REG_BIT ( gmask , regno ) ; if ( regno == first_slot ) gcc_assert ( regno == GPR_FP && frame_pointer_needed ) ; else if ( ! interrupt_p && first_slot < <NUM_LIT> ) first_slot = regno ; else if ( last_slot < <NUM_LIT> && ( first_slot ^ regno ) != <NUM_LIT> && ( ! interrupt_p || regno > GPR_1 ) ) last_slot = regno ; } } if ( TEST_HARD_REG_BIT ( gmask , GPR_LR ) ) MACHINE_FUNCTION ( cfun ) -> lr_clobbered = <NUM_LIT> ; current_frame_info . small_threshold = ( optimize >= <NUM_LIT> || interrupt_p ? <NUM_LIT> : pretend_size ? small_slots : <NUM_LIT> + small_slots - ( first_slot == GPR_FP ) ) ; if ( var_size >= <NUM_LIT> * UNITS_PER_WORD || ( reg_size > <NUM_LIT> && optimize ) ) reg_size = EPIPHANY_STACK_ALIGN ( reg_size ) ; if ( ( ( total_size + reg_size + EPIPHANY_STACK_ALIGN ( <NUM_LIT> ) ) <= ( unsigned ) epiphany_stack_offset ) && ! interrupt_p && crtl -> is_leaf && ! frame_pointer_needed ) { first_slot = - <NUM_LIT> ; last_slot = - <NUM_LIT> ; goto alloc_done ;


<s> fn_type = EPIPHANY_FUNCTION_NORMAL ; for ( a = DECL_ATTRIBUTES ( decl ) ; a ; a = TREE_CHAIN ( a ) ) { tree name = TREE_PURPOSE ( a ) ; if ( name == get_identifier ( <STR_LIT> ) ) fn_type = EPIPHANY_FUNCTION_INTERRUPT ; } last_fn = decl ; return fn_type ;


<s> } if ( ! TARGET_PREFER_SHORT_INSN_REGS ) CLEAR_HARD_REG_SET ( reg_class_contents [ SHORT_INSN_REGS ] ) ; reg_class_contents [ SIBCALL_REGS ] = reg_class_contents [ GENERAL_REGS ] ;


<s> if ( TREE_CODE ( exp ) == STRING_CST ) return MAX ( align , FASTEST_ALIGNMENT ) ; return align ;


<s> if ( fixed_regs [ regno ] && regno != STATUS_REGNUM && regno != IRET_REGNUM && regno != FP_NEAREST_REGNUM && regno != FP_TRUNCATE_REGNUM ) return false ; return true ;


<s> off = GEN_INT ( current_frame_info . first_slot_offset ) ; mem = gen_frame_mem ( BLKmode , stack_pointer_rtx ) ; if ( ! SIMM11 ( INTVAL ( off ) ) || current_frame_info . last_slot >= <NUM_LIT> ) { emit_insn ( gen_stack_adjust_ldr ( gen_rtx_REG ( word_mode , ( current_frame_info . last_slot >= <NUM_LIT> ? current_frame_info . last_slot : GPR_IP ) ) , gen_frame_mem ( word_mode , stack_pointer_rtx ) , off , mem ) ) ; } else if ( INTVAL ( off ) ) { emit_insn ( gen_stack_adjust_add ( off , mem ) ) ; } if ( interrupt_p ) { emit_move_insn ( gen_rtx_REG ( word_mode , STATUS_REGNUM ) , gen_rtx_REG ( SImode , GPR_0 ) ) ; emit_move_insn ( gen_rtx_REG ( word_mode , IRET_REGNUM ) , gen_rtx_REG ( SImode , GPR_1 ) ) ; addr = plus_constant ( Pmode , stack_pointer_rtx , - ( HOST_WIDE_INT ) <NUM_LIT> * UNITS_PER_WORD ) ; emit_move_insn ( gen_rtx_REG ( DImode , GPR_0 ) , gen_frame_mem ( DImode , addr ) ) ; } addr = plus_constant ( Pmode , stack_pointer_rtx , epiphany_stack_offset - ( HOST_WIDE_INT ) UNITS_PER_WORD ) ; epiphany_emit_save_restore ( <NUM_LIT> , current_frame_info . small_threshold , addr , <NUM_LIT> ) ; if ( ! sibcall_p ) {

if ( interrupt_p ) emit_jump_insn ( gen_return_internal_interrupt ( ) ) ;


<s> addr = plus_constant ( Pmode , stack_pointer_rtx , ( current_frame_info . first_slot_offset + restore_offset ) ) ; epiphany_emit_save_restore ( current_frame_info . small_threshold , FIRST_PSEUDO_REGISTER , addr , <NUM_LIT> ) ; if ( interrupt_p && ! epiphany_uninterruptible_p ( current_function_decl ) ) emit_insn ( gen_gid ( ) ) ; off = GEN_INT ( current_frame_info . first_slot_offset ) ; mem = gen_frame_mem ( BLKmode , stack_pointer_rtx ) ; if ( ! SIMM11 ( INTVAL ( off ) ) || current_frame_info . last_slot >= <NUM_LIT> ) { emit_insn ( gen_stack_adjust_ldr ( gen_rtx_REG ( word_mode , ( current_frame_info . last_slot >= <NUM_LIT> ? current_frame_info . last_slot : GPR_IP ) ) , gen_frame_mem ( word_mode , stack_pointer_rtx ) , off , mem ) ) ; } else if ( INTVAL ( off ) ) { emit_insn ( gen_stack_adjust_add ( off , mem ) ) ; } if ( interrupt_p ) {


<s> addr = plus_constant ( Pmode , stack_pointer_rtx , epiphany_stack_offset - ( HOST_WIDE_INT ) UNITS_PER_WORD ) ; epiphany_emit_save_restore ( <NUM_LIT> , current_frame_info . small_threshold , addr , <NUM_LIT> ) ; if ( current_frame_info . first_slot >= <NUM_LIT> ) { machine_mode mode = ( current_frame_info . first_slot_size == UNITS_PER_WORD ? word_mode : DImode ) ; off = GEN_INT ( - current_frame_info . first_slot_offset ) ; mem = gen_frame_mem ( BLKmode , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , off ) ) ; frame_insn ( gen_stack_adjust_str ( gen_frame_mem ( mode , stack_pointer_rtx ) , gen_rtx_REG ( mode , current_frame_info . first_slot ) , off , mem ) ) ; addr = plus_constant ( Pmode , addr , current_frame_info . first_slot_offset ) ; } } epiphany_emit_save_restore ( current_frame_info . small_threshold , FIRST_PSEUDO_REGISTER , addr , <NUM_LIT> ) ; if ( current_frame_info . need_fp ) frame_move_insn ( hard_frame_pointer_rtx , stack_pointer_rtx ) ; if ( current_frame_info . last_slot >= <NUM_LIT> ) { rtx ip , mem2 , note ; rtx_insn * insn ;


<s> if ( current_frame_info . last_slot >= <NUM_LIT> ) { rtx ip , mem2 , note ; rtx_insn * insn ; gcc_assert ( current_frame_info . last_slot != GPR_FP || ( ! current_frame_info . need_fp && current_frame_info . first_slot < <NUM_LIT> ) ) ; off = GEN_INT ( - current_frame_info . last_slot_offset ) ; mem = gen_frame_mem ( BLKmode , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , off ) ) ; ip = gen_rtx_REG ( Pmode , GPR_IP ) ; frame_move_insn ( ip , off ) ; reg = gen_rtx_REG ( word_mode , current_frame_info . last_slot ) , mem2 = gen_frame_mem ( word_mode , stack_pointer_rtx ) , insn = frame_insn ( gen_stack_adjust_str ( mem2 , reg , ip , mem ) ) ; note = gen_rtx_SET ( stack_pointer_rtx , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , off ) ) ; note = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , gen_rtx_SET ( mem2 , reg ) , note ) ) ; add_reg_note ( insn , REG_FRAME_RELATED_EXPR , note ) ; } else if ( current_frame_info . last_slot_offset ) { mem = gen_frame_mem ( BLKmode , plus_constant ( Pmode , stack_pointer_rtx , current_frame_info . last_slot_offset ) ) ; off = GEN_INT ( - current_frame_info . last_slot_offset ) ; if ( ! SIMM11 ( INTVAL ( off ) ) ) { reg = gen_rtx_REG ( Pmode , GPR_IP ) ; frame_move_insn ( reg , off ) ;


<s> emit_move_insn ( scratch , ctrl ) ; if ( GET_CODE ( src ) == REG ) { emit_insn ( gen_xorsi3 ( scratch , scratch , src ) ) ; emit_insn ( gen_andsi3 ( scratch , scratch , mask_reg ) ) ; emit_insn ( gen_xorsi3 ( scratch , scratch , src ) ) ; } else { gcc_assert ( GET_CODE ( src ) == CONST ) ; src = XEXP ( src , <NUM_LIT> ) ; fp_mode = ( enum attr_fp_mode ) INTVAL ( XVECEXP ( src , <NUM_LIT> , <NUM_LIT> ) ) ; switch ( fp_mode ) { case FP_MODE_ROUND_NEAREST : emit_insn ( gen_andsi3 ( scratch , scratch , mask_reg ) ) ; break ; case FP_MODE_ROUND_TRUNC : emit_insn ( gen_andsi3 ( scratch , scratch , mask_reg ) ) ; emit_insn ( gen_add2_insn ( scratch , const1_rtx ) ) ; break ; case FP_MODE_INT : emit_insn ( gen_iorsi3 ( scratch , scratch , mask_reg ) ) ; break ;


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

if ( PASS_IN_REG_P ( cum , arg . mode , arg . type ) ) return gen_rtx_REG ( arg . mode , ROUND_ADVANCE_CUM ( cum , arg . mode , arg . type ) ) ;


<s> if ( ( type ? TYPE_ALIGN ( type ) : GET_MODE_BITSIZE ( mode ) ) <= PARM_BOUNDARY ) return PARM_BOUNDARY ; return <NUM_LIT> * PARM_BOUNDARY ;


<s> if ( ( type ? TYPE_ALIGN ( type ) : GET_MODE_BITSIZE ( mode ) ) <= PARM_BOUNDARY ) return PARM_BOUNDARY ;


<s> static bool epiphany_function_ok_for_sibcall ( tree decl , tree exp ) { bool cfun_interrupt_p , call_interrupt_p ; cfun_interrupt_p = EPIPHANY_INTERRUPT_P ( epiphany_compute_function_type ( current_function_decl ) ) ; if ( decl ) call_interrupt_p = EPIPHANY_INTERRUPT_P ( epiphany_compute_function_type ( decl ) ) ; else { tree fn_type = TREE_TYPE ( CALL_EXPR_FN ( exp ) ) ; gcc_assert ( POINTER_TYPE_P ( fn_type ) ) ; fn_type = TREE_TYPE ( fn_type ) ; gcc_assert ( TREE_CODE ( fn_type ) == FUNCTION_TYPE || TREE_CODE ( fn_type ) == METHOD_TYPE ) ; call_interrupt_p = lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( fn_type ) ) != NULL ; } if ( cfun_interrupt_p || call_interrupt_p ) return false ;


if ( cfun_interrupt_p || call_interrupt_p ) return false ;


<s> machine_mode mode ; mode = TYPE_MODE ( ret_type ) ; if ( GET_MODE_CLASS ( mode ) == MODE_INT && GET_MODE_SIZE ( mode ) < <NUM_LIT> && ( TREE_CODE ( ret_type ) == INTEGER_TYPE || TREE_CODE ( ret_type ) == ENUMERAL_TYPE || TREE_CODE ( ret_type ) == BOOLEAN_TYPE || TREE_CODE ( ret_type ) == OFFSET_TYPE ) ) mode = SImode ;

return gen_rtx_REG ( mode , <NUM_LIT> ) ;


<s> mode = TYPE_MODE ( ret_type ) ; if ( GET_MODE_CLASS ( mode ) == MODE_INT && GET_MODE_SIZE ( mode ) < <NUM_LIT> && ( TREE_CODE ( ret_type ) == INTEGER_TYPE || TREE_CODE ( ret_type ) == ENUMERAL_TYPE || TREE_CODE ( ret_type ) == BOOLEAN_TYPE || TREE_CODE ( ret_type ) == OFFSET_TYPE ) ) mode = SImode ;


<s> static bool epiphany_function_value_regno_p ( const unsigned int regno ATTRIBUTE_UNUSED ) {


<s> else if ( TYPE_ARG_TYPES ( t ) && TREE_VALUE ( TYPE_ARG_TYPES ( t ) ) != void_type_node ) error_at ( DECL_SOURCE_LOCATION ( * node ) , <STR_LIT> ) ; return NULL_TREE ; } value = TREE_VALUE ( args ) ; if ( TREE_CODE ( value ) != STRING_CST ) { warning ( OPT_Wattributes , <STR_LIT> , name ) ; * no_add_attrs = true ; } else if ( strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) && strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) && strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) && strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) && strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) && strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) && strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) && strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) && strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) && strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) ) { warning ( OPT_Wattributes , <STR_LIT> <STR_LIT> , name , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> ) ; * no_add_attrs = true ; return NULL_TREE ;


<s> if ( from == FRAME_POINTER_REGNUM && to == STACK_POINTER_REGNUM ) return current_frame_info . total_size - current_frame_info . reg_size ; if ( from == FRAME_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM ) return current_frame_info . first_slot_offset - current_frame_info . reg_size ; if ( from == ARG_POINTER_REGNUM && to == STACK_POINTER_REGNUM ) return ( current_frame_info . total_size - ( ( current_frame_info . pretend_size + <NUM_LIT> ) & - <NUM_LIT> ) ) ; if ( from == ARG_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM ) return ( current_frame_info . first_slot_offset - ( ( current_frame_info . pretend_size + <NUM_LIT> ) & - <NUM_LIT> ) ) ; gcc_unreachable ( ) ;


<s> static struct machine_function * epiphany_init_machine_status ( void ) { struct machine_function * machine ; current_frame_info = zero_frame_info ; machine = ggc_cleared_alloc < machine_function_t > ( ) ; return machine ;


<s> struct machine_function * machine ; current_frame_info = zero_frame_info ; machine = ggc_cleared_alloc < machine_function_t > ( ) ;


<s> else if ( i < ( GPR_LAST + <NUM_LIT> ) || i == ARG_POINTER_REGNUM || i == FRAME_POINTER_REGNUM ) epiphany_regno_reg_class [ i ] = GENERAL_REGS ; else if ( i == CC_REGNUM ) epiphany_regno_reg_class [ i ] = NO_REGS ;


<s> else if ( i < ( GPR_LAST + <NUM_LIT> ) || i == ARG_POINTER_REGNUM || i == FRAME_POINTER_REGNUM ) epiphany_regno_reg_class [ i ] = GENERAL_REGS ; else if ( i == CC_REGNUM ) epiphany_regno_reg_class [ i ] = NO_REGS ; else epiphany_regno_reg_class [ i ] = NO_REGS ;


<s> near = gen_rtx_USE ( VOIDmode , near ) ; trunc = gen_rtx_USE ( VOIDmode , trunc ) ; break ; case FP_MODE_NONE : gcc_unreachable ( ) ; } gcc_assert ( GET_CODE ( pat ) == PARALLEL ) ; len = XVECLEN ( pat , <NUM_LIT> ) ; v = rtvec_alloc ( len + <NUM_LIT> ) ; for ( i = <NUM_LIT> ; i < len ; i ++ ) RTVEC_ELT ( v , i ) = XVECEXP ( pat , <NUM_LIT> , i ) ;


<s> tree attrs ; attrs = DECL_ATTRIBUTES ( decl ) ;

if ( lookup_attribute ( <STR_LIT> , attrs ) ) return true ;


<s> bool epiphany_is_long_call_p ( rtx x ) { tree decl = SYMBOL_REF_DECL ( x ) ; bool ret_val = ! TARGET_SHORT_CALLS ; tree attrs ; if ( decl ) { attrs = TYPE_ATTRIBUTES ( TREE_TYPE ( decl ) ) ; if ( lookup_attribute ( <STR_LIT> , attrs ) ) ret_val = true ; else if ( lookup_attribute ( <STR_LIT> , attrs ) ) ret_val = false ; } return ret_val ;


<s> ( strict ? GPR_P ( REGNO ( X ) ) : GPR_AP_OR_PSEUDO_P ( REGNO ( X ) ) ) if ( RTX_OK_FOR_BASE_P ( x ) ) return true ; if ( RTX_FRAME_OFFSET_P ( x ) ) return true ; if ( LEGITIMATE_OFFSET_ADDRESS_P ( mode , x ) ) return true ;

if ( GET_MODE_SIZE ( mode ) == <NUM_LIT> && GET_CODE ( x ) == PLUS && XEXP ( x , <NUM_LIT> ) == stack_pointer_rtx && ! ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) & <NUM_LIT> ) && INTVAL ( XEXP ( x , <NUM_LIT> ) ) >= - <NUM_LIT> * <NUM_LIT> && INTVAL ( XEXP ( x , <NUM_LIT> ) ) <= <NUM_LIT> * <NUM_LIT> ) return true ;


<s> if ( TARGET_POST_INC && ( GET_CODE ( x ) == POST_DEC || GET_CODE ( x ) == POST_INC ) && RTX_OK_FOR_BASE_P ( XEXP ( ( x ) , <NUM_LIT> ) ) ) return true ; if ( ( TARGET_POST_MODIFY || reload_completed ) && GET_CODE ( x ) == POST_MODIFY && GET_CODE ( XEXP ( ( x ) , <NUM_LIT> ) ) == PLUS && rtx_equal_p ( XEXP ( ( x ) , <NUM_LIT> ) , XEXP ( XEXP ( ( x ) , <NUM_LIT> ) , <NUM_LIT> ) ) && LEGITIMATE_OFFSET_ADDRESS_P ( mode , XEXP ( ( x ) , <NUM_LIT> ) ) ) return true ; if ( mode == BLKmode ) return epiphany_legitimate_address_p ( SImode , x , strict ) ; return false ;


<s> static rtx epiphany_libcall_value ( machine_mode mode , const_rtx fun ATTRIBUTE_UNUSED ) {


<s> static int epiphany_memory_move_cost ( machine_mode mode , reg_class_t rclass ATTRIBUTE_UNUSED , bool in ATTRIBUTE_UNUSED ) { return GET_MODE_CLASS ( mode ) == MODE_INT ? <NUM_LIT> : <NUM_LIT> ;


<s> if ( flag_reciprocal_math && mode == SFmode ) return <NUM_LIT> ;

return default_min_divisions_for_recip_mul ( mode ) ;


<s> } if ( entity == EPIPHANY_MSW_ENTITY_CONFIG && NONJUMP_INSN_P ( insn ) && GET_CODE ( PATTERN ( insn ) ) == PARALLEL && GET_CODE ( XVECEXP ( PATTERN ( insn ) , <NUM_LIT> , <NUM_LIT> ) ) == SET && SET_DEST ( XVECEXP ( PATTERN ( insn ) , <NUM_LIT> , <NUM_LIT> ) ) == frame_pointer_rtx ) { gcc_assert ( cfun -> has_nonlocal_label ) ; return <NUM_LIT> ; } if ( recog_memoized ( insn ) < <NUM_LIT> ) return last_mode ; if ( get_attr_fp_mode ( insn ) == FP_MODE_ROUND_UNKNOWN && last_mode != FP_MODE_ROUND_NEAREST && last_mode != FP_MODE_ROUND_TRUNC ) { if ( entity == EPIPHANY_MSW_ENTITY_NEAREST ) return FP_MODE_ROUND_NEAREST ; if ( entity == EPIPHANY_MSW_ENTITY_TRUNC ) return FP_MODE_ROUND_TRUNC ; }

if ( recog_memoized ( insn ) == CODE_FOR_set_fp_mode ) {


<s> static int epiphany_mode_entry ( int entity ) { return epiphany_mode_entry_exit ( entity , false ) ;


<s> static int epiphany_mode_entry_exit ( int entity , bool exit ) { int normal_mode = epiphany_normal_fp_mode ; MACHINE_FUNCTION ( cfun ) -> sw_entities_processed |= ( <NUM_LIT> << entity ) ; if ( epiphany_is_interrupt_p ( current_function_decl ) ) normal_mode = FP_MODE_CALLER ; switch ( entity ) { case EPIPHANY_MSW_ENTITY_AND : if ( exit ) return normal_mode != FP_MODE_INT ? <NUM_LIT> : <NUM_LIT> ;


<s> return epiphany_mode_entry_exit ( entity , true ) ;


<s> mode = get_attr_fp_mode ( insn ) ; switch ( entity ) { case EPIPHANY_MSW_ENTITY_AND : return mode != FP_MODE_NONE && mode != FP_MODE_INT ? <NUM_LIT> : <NUM_LIT> ; case EPIPHANY_MSW_ENTITY_OR : return mode == FP_MODE_INT ? <NUM_LIT> : <NUM_LIT> ; case EPIPHANY_MSW_ENTITY_CONFIG : if ( mode != FP_MODE_NONE && mode != FP_MODE_CALLER ) return <NUM_LIT> ; if ( CALL_P ( insn ) && find_reg_note ( insn , REG_EH_REGION , NULL_RTX ) ) return <NUM_LIT> ; return <NUM_LIT> ; case EPIPHANY_MSW_ENTITY_ROUND_KNOWN : if ( recog_memoized ( insn ) == CODE_FOR_set_fp_mode ) mode = ( enum attr_fp_mode ) epiphany_mode_after ( entity , mode , insn ) ; case EPIPHANY_MSW_ENTITY_NEAREST : case EPIPHANY_MSW_ENTITY_TRUNC :


<s> if ( priority > <NUM_LIT> ) switch ( priority ) { case <NUM_LIT> : return FP_MODE_ROUND_UNKNOWN ; case <NUM_LIT> : return FP_MODE_NONE ; default : gcc_unreachable ( ) ; } switch ( ( enum attr_fp_mode ) epiphany_normal_fp_mode ) { case FP_MODE_INT : switch ( priority ) { case <NUM_LIT> : return FP_MODE_INT ; case <NUM_LIT> : return epiphany_normal_fp_rounding ; case <NUM_LIT> : return ( epiphany_normal_fp_rounding == FP_MODE_ROUND_NEAREST ? FP_MODE_ROUND_TRUNC : FP_MODE_ROUND_NEAREST ) ; case <NUM_LIT> : return FP_MODE_CALLER ; default : gcc_unreachable ( ) ; } case FP_MODE_ROUND_NEAREST : case FP_MODE_CALLER : switch ( priority ) { case <NUM_LIT> : return FP_MODE_ROUND_NEAREST ; case <NUM_LIT> : return FP_MODE_ROUND_TRUNC ; case <NUM_LIT> : return FP_MODE_INT ;


<s> case EPIPHANY_MSW_ENTITY_NEAREST : case EPIPHANY_MSW_ENTITY_TRUNC : return optimize > <NUM_LIT> ; case EPIPHANY_MSW_ENTITY_ROUND_UNKNOWN : return MACHINE_FUNCTION ( cfun ) -> unknown_mode_uses != <NUM_LIT> ; case EPIPHANY_MSW_ENTITY_ROUND_KNOWN : return ( MACHINE_FUNCTION ( cfun ) -> sw_entities_processed & ( <NUM_LIT> << EPIPHANY_MSW_ENTITY_ROUND_UNKNOWN ) ) != <NUM_LIT> ; case EPIPHANY_MSW_ENTITY_FPU_OMNIBUS : return optimize == <NUM_LIT> || current_pass == pass_mode_switch_use ; } gcc_unreachable ( ) ;


<s> case EPIPHANY_MSW_ENTITY_OR : case EPIPHANY_MSW_ENTITY_CONFIG : return true ; case EPIPHANY_MSW_ENTITY_NEAREST : case EPIPHANY_MSW_ENTITY_TRUNC : return optimize > <NUM_LIT> ; case EPIPHANY_MSW_ENTITY_ROUND_UNKNOWN : return MACHINE_FUNCTION ( cfun ) -> unknown_mode_uses != <NUM_LIT> ; case EPIPHANY_MSW_ENTITY_ROUND_KNOWN : return ( MACHINE_FUNCTION ( cfun ) -> sw_entities_processed & ( <NUM_LIT> << EPIPHANY_MSW_ENTITY_ROUND_UNKNOWN ) ) != <NUM_LIT> ; case EPIPHANY_MSW_ENTITY_FPU_OMNIBUS : return optimize == <NUM_LIT> || current_pass == pass_mode_switch_use ;


<s> if ( epiphany_stack_offset < <NUM_LIT> ) error ( <STR_LIT> ) ; if ( epiphany_stack_offset & <NUM_LIT> ) error ( <STR_LIT> ) ; epiphany_stack_offset = ( epiphany_stack_offset + <NUM_LIT> ) & - <NUM_LIT> ; if ( ! TARGET_SOFT_CMPSF ) flag_finite_math_only = <NUM_LIT> ; epiphany_init ( ) ;


<s> epiphany_stack_offset = ( epiphany_stack_offset + <NUM_LIT> ) & - <NUM_LIT> ; if ( ! TARGET_SOFT_CMPSF ) flag_finite_math_only = <NUM_LIT> ; epiphany_init ( ) ;


<s> if ( tree type = arg . type ) { if ( AGGREGATE_TYPE_P ( type ) && ( arg . mode == BLKmode || TYPE_NEEDS_CONSTRUCTING ( type ) ) ) return true ;


<s> return TARGET_VECT_DOUBLE ? DImode : SImode ;


return TARGET_VECT_DOUBLE ? DImode : SImode ;


<s> if ( code == <NUM_LIT> ) current_frame_info . stld_sz = <NUM_LIT> ; fputc ( '[' , file ) ; addr = XEXP ( x , <NUM_LIT> ) ; switch ( GET_CODE ( addr ) ) { case POST_INC : offset = GEN_INT ( GET_MODE_SIZE ( GET_MODE ( x ) ) ) ; addr = XEXP ( addr , <NUM_LIT> ) ; break ; case POST_DEC : offset = GEN_INT ( - GET_MODE_SIZE ( GET_MODE ( x ) ) ) ; addr = XEXP ( addr , <NUM_LIT> ) ; break ; case POST_MODIFY : offset = XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ; addr = XEXP ( addr , <NUM_LIT> ) ; break ; default : offset = <NUM_LIT> ; break ; } output_address ( GET_MODE ( x ) , addr ) ; fputc ( ']' , file ) ; if ( offset ) { fputc ( ',' , file ) ; if ( CONST_INT_P ( offset ) ) switch ( GET_MODE_SIZE ( GET_MODE ( x ) ) ) { default : gcc_unreachable ( ) ; case <NUM_LIT> : offset = GEN_INT ( INTVAL ( offset ) >> <NUM_LIT> ) ; break ; case <NUM_LIT> : offset = GEN_INT ( INTVAL ( offset ) >> <NUM_LIT> ) ; break ; case <NUM_LIT> : offset = GEN_INT ( INTVAL ( offset ) >> <NUM_LIT> ) ; break ; case <NUM_LIT> : break ; } output_address ( GET_MODE ( x ) , offset ) ; } break ; case CONST_DOUBLE : if ( GET_MODE ( x ) == SFmode ) { long l ; REAL_VALUE_TO_TARGET_SINGLE ( * CONST_DOUBLE_REAL_VALUE ( x ) , l ) ; fprintf ( file , <STR_LIT> , IMMEDIATE_PREFIX , l ) ; break ; } case CONST_INT : fprintf ( file , <STR_LIT> , IMMEDIATE_PREFIX ) ; if ( code == 'C' || code == 'X' ) { fprintf ( file , <STR_LIT> , ( long ) ( INTVAL ( x ) / current_frame_info . stld_sz ) ) ; break ; } default : output_addr_const ( file , x ) ; break ; }


<s> static void epiphany_print_operand ( FILE * file , rtx x , int code ) { switch ( code ) { case 'd' : fputs ( epiphany_condition_codes [ get_epiphany_condition_code ( x ) ] , file ) ; return ; case 'D' : fputs ( epiphany_condition_codes [ EPIPHANY_INVERSE_CONDITION_CODE ( get_epiphany_condition_code ( x ) ) ] , file ) ; return ; case 'X' : current_frame_info . stld_sz = <NUM_LIT> ; break ; case 'C' : current_frame_info . stld_sz = <NUM_LIT> ; break ; case 'c' : current_frame_info . stld_sz = <NUM_LIT> ; break ; case 'f' : fputs ( REG_P ( x ) ? <STR_LIT> : <STR_LIT> , file ) ; break ; case '-' : fprintf ( file , <STR_LIT> , epiphany_m1reg ) ; return ; case <NUM_LIT> : break ; default : output_operand_lossage ( <STR_LIT> ) ; } switch ( GET_CODE ( x ) ) { rtx addr ; rtx offset ; case REG : fputs ( reg_names [ REGNO ( x ) ] , file ) ; break ; case MEM : if ( code == <NUM_LIT> ) current_frame_info . stld_sz = <NUM_LIT> ; fputc ( '[' , file ) ; addr = XEXP ( x , <NUM_LIT> ) ; switch ( GET_CODE ( addr ) ) { case POST_INC : offset = GEN_INT ( GET_MODE_SIZE ( GET_MODE ( x ) ) ) ; addr = XEXP ( addr , <NUM_LIT> ) ; break ; case POST_DEC : offset = GEN_INT ( - GET_MODE_SIZE ( GET_MODE ( x ) ) ) ; addr = XEXP ( addr , <NUM_LIT> ) ; break ;


<s> fputs ( reg_names [ REGNO ( addr ) ] , file ) ; break ; case SYMBOL_REF : if ( <NUM_LIT> && SYMBOL_REF_FUNCTION_P ( addr ) ) { output_addr_const ( file , addr ) ; } else { output_addr_const ( file , addr ) ; } break ; case PLUS : if ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == CONST_INT ) offset = INTVAL ( XEXP ( addr , <NUM_LIT> ) ) , base = XEXP ( addr , <NUM_LIT> ) ; else if ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == CONST_INT ) offset = INTVAL ( XEXP ( addr , <NUM_LIT> ) ) , base = XEXP ( addr , <NUM_LIT> ) ; else base = XEXP ( addr , <NUM_LIT> ) , index = XEXP ( addr , <NUM_LIT> ) ; gcc_assert ( GET_CODE ( base ) == REG ) ; fputs ( reg_names [ REGNO ( base ) ] , file ) ; if ( index == <NUM_LIT> ) { fprintf ( file , <STR_LIT> , IMMEDIATE_PREFIX , offset / current_frame_info . stld_sz ) ; } else {


return promote_mode ( type , mode , & dummy ) ;


<s> enum epiphany_function_type fn_type ; fn_type = epiphany_compute_function_type ( current_function_decl ) ; if ( ! EPIPHANY_INTERRUPT_P ( fn_type ) ) return true ; if ( df_regs_ever_live_p ( dst ) ) return true ; return false ;


<s> HOST_WIDE_INT size = int_size_in_bytes ( type ) ; if ( AGGREGATE_TYPE_P ( type ) && ( TYPE_MODE ( type ) == BLKmode || TYPE_NEEDS_CONSTRUCTING ( type ) ) ) return true ; return ( size == - <NUM_LIT> || size > <NUM_LIT> ) ;


<s> if ( AGGREGATE_TYPE_P ( type ) && ( TYPE_MODE ( type ) == BLKmode || TYPE_NEEDS_CONSTRUCTING ( type ) ) ) return true ;

return ( size == - <NUM_LIT> || size > <NUM_LIT> ) ;


<s> * total = COSTS_N_INSNS ( ( epiphany_small16 ( x ) ? <NUM_LIT> : <NUM_LIT> ) + ( outer_code == SET ? <NUM_LIT> : <NUM_LIT> ) ) ; return true ; case CONST_DOUBLE : { rtx high , low ; split_double ( x , & high , & low ) ; * total = COSTS_N_INSNS ( ! IMM16 ( INTVAL ( high ) ) + ! IMM16 ( INTVAL ( low ) ) ) ; return true ; } case ASHIFT : case ASHIFTRT : case LSHIFTRT : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case COMPARE : switch ( mode ) { case E_CC_N_NEmode : case E_CC_C_LTUmode : case E_CC_C_GTUmode : return true ; default : return false ; } case SET : { rtx src = SET_SRC ( x ) ; if ( BINARY_P ( src ) ) * total = <NUM_LIT> ; return false ; } default : return false ;


<s> { rtx high , low ; split_double ( x , & high , & low ) ; * total = COSTS_N_INSNS ( ! IMM16 ( INTVAL ( high ) ) + ! IMM16 ( INTVAL ( low ) ) ) ; return true ; } case ASHIFT : case ASHIFTRT : case LSHIFTRT : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case COMPARE : switch ( mode ) { case E_CC_N_NEmode : case E_CC_C_LTUmode : case E_CC_C_GTUmode : return true ; default : return false ; } case SET : { rtx src = SET_SRC ( x ) ; if ( BINARY_P ( src ) ) * total = <NUM_LIT> ; return false ; } default : return false ;


<s> if ( <NUM_LIT> ) if ( in_p && GET_CODE ( x ) == UNSPEC && satisfies_constraint_Sra ( x ) && ! satisfies_constraint_Rra ( x ) ) { gcc_assert ( rclass == GENERAL_REGS ) ;

sri -> icode = CODE_FOR_reload_insi_ra ;


<s> if ( <NUM_LIT> ) if ( in_p && GET_CODE ( x ) == UNSPEC && satisfies_constraint_Sra ( x ) && ! satisfies_constraint_Rra ( x ) ) { gcc_assert ( rclass == GENERAL_REGS ) ; sri -> icode = CODE_FOR_reload_insi_ra ;


<s> return CC_FP_GTEmode ; } return CC_FPmode ; } else if ( ( op == EQ || op == NE ) && GET_CODE ( x ) == ZERO_EXTRACT && XEXP ( x , <NUM_LIT> ) == const1_rtx && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) ) return CC_N_NEmode ; else if ( ( op == GEU || op == LTU ) && GET_CODE ( x ) == PLUS ) return CC_C_LTUmode ;

else if ( ( op == LEU || op == GTU ) && GET_CODE ( x ) == MINUS ) return CC_C_GTUmode ;


<s> next_cum = ( ROUND_ADVANCE_CUM ( next_cum , arg . mode , arg . type ) + ROUND_ADVANCE_ARG ( arg . mode , arg . type ) ) ; first_anon_arg = next_cum ; if ( first_anon_arg < MAX_EPIPHANY_PARM_REGS && ! no_rtl ) { int first_reg_offset = first_anon_arg ; * pretend_size = ( ( MAX_EPIPHANY_PARM_REGS - first_reg_offset ) * UNITS_PER_WORD ) ; } mf -> args_parsed = <NUM_LIT> ; mf -> pretend_args_odd = ( ( * pretend_size & UNITS_PER_WORD ) ? <NUM_LIT> : <NUM_LIT> ) ;


<s> bool epiphany_small16 ( rtx x ) { rtx base = x ; rtx offs ATTRIBUTE_UNUSED = const0_rtx ; if ( GET_CODE ( x ) == CONST && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS ) { base = XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ; offs = XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ;


<s> offs = XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ; } if ( GET_CODE ( base ) == SYMBOL_REF && SYMBOL_REF_FUNCTION_P ( base ) && epiphany_is_long_call_p ( base ) ) return false ;


<s> tree offset , size ; if ( TREE_CODE ( field ) != FIELD_DECL || TREE_TYPE ( field ) == error_mark_node ) continue ; offset = bit_position ( field ) ; size = DECL_SIZE ( field ) ; if ( ! tree_fits_uhwi_p ( offset ) || ! tree_fits_uhwi_p ( size ) || tree_to_uhwi ( offset ) >= try_align || tree_to_uhwi ( size ) >= try_align ) return try_align ;

total = tree_to_uhwi ( offset ) + tree_to_uhwi ( size ) ;


<s> HOST_WIDE_INT total , max ; unsigned try_align = FASTEST_ALIGNMENT ; if ( maximum_field_alignment && try_align > maximum_field_alignment ) try_align = maximum_field_alignment ; if ( align >= try_align ) return align ; for ( max = <NUM_LIT> , field = TYPE_FIELDS ( type ) ; field ; field = DECL_CHAIN ( field ) ) { tree offset , size ; if ( TREE_CODE ( field ) != FIELD_DECL || TREE_TYPE ( field ) == error_mark_node ) continue ; offset = bit_position ( field ) ; size = DECL_SIZE ( field ) ; if ( ! tree_fits_uhwi_p ( offset ) || ! tree_fits_uhwi_p ( size ) || tree_to_uhwi ( offset ) >= try_align || tree_to_uhwi ( size ) >= try_align ) return try_align ; total = tree_to_uhwi ( offset ) + tree_to_uhwi ( size ) ; if ( total > max ) max = total ; } if ( max >= ( HOST_WIDE_INT ) try_align ) align = try_align ; else if ( try_align > <NUM_LIT> && max >= <NUM_LIT> ) align = max > <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ; return align ;


<s> static HOST_WIDE_INT epiphany_starting_frame_offset ( void ) {


<s> int_attr = lookup_attribute ( <STR_LIT> , attrs ) ; if ( int_attr ) for ( int_names = TREE_VALUE ( int_attr ) ; int_names ; int_names = TREE_CHAIN ( int_names ) ) { char buf [ <NUM_LIT> ] ; int_name = TREE_VALUE ( int_names ) ; sprintf ( buf , <STR_LIT> , TREE_STRING_POINTER ( int_name ) ) ; switch_to_section ( get_section ( buf , SECTION_CODE , decl ) ) ; fputs ( <STR_LIT> , file ) ; assemble_name ( file , name ) ; fputc ( '\n' , file ) ; } forwarder_attr = lookup_attribute ( <STR_LIT> , attrs ) ; if ( forwarder_attr ) { const char * prefix = <STR_LIT> ; char * dst_name = ( char * ) alloca ( strlen ( prefix ) + strlen ( name ) + <NUM_LIT> ) ; strcpy ( dst_name , prefix ) ; strcat ( dst_name , name ) ; forwarder_attr = TREE_VALUE ( TREE_VALUE ( forwarder_attr ) ) ; switch_to_section ( get_section ( TREE_STRING_POINTER ( forwarder_attr ) , SECTION_CODE , decl ) ) ; ASM_OUTPUT_FUNCTION_LABEL ( file , name , decl ) ; if ( epiphany_is_long_call_p ( XEXP ( DECL_RTL ( decl ) , <NUM_LIT> ) ) ) { int tmp = GPR_0 ; if ( int_attr ) fputs ( <STR_LIT> , file ) ; else tmp = GPR_16 ; gcc_assert ( call_used_or_fixed_reg_p ( tmp ) ) ; fprintf ( file , <STR_LIT> , tmp ) ; assemble_name ( file , dst_name ) ; fprintf ( file , <STR_LIT> <STR_LIT> , tmp ) ; assemble_name ( file , dst_name ) ; fprintf ( file , <STR_LIT> <STR_LIT> , tmp ) ; } else { fputs ( <STR_LIT> , file ) ; assemble_name ( file , dst_name ) ; fputc ( '\n' , file ) ; } name = dst_name ; } switch_to_section ( function_section ( decl ) ) ; ASM_OUTPUT_FUNCTION_LABEL ( file , name , decl ) ;


<s> strcpy ( dst_name , prefix ) ; strcat ( dst_name , name ) ; forwarder_attr = TREE_VALUE ( TREE_VALUE ( forwarder_attr ) ) ; switch_to_section ( get_section ( TREE_STRING_POINTER ( forwarder_attr ) , SECTION_CODE , decl ) ) ; ASM_OUTPUT_FUNCTION_LABEL ( file , name , decl ) ; if ( epiphany_is_long_call_p ( XEXP ( DECL_RTL ( decl ) , <NUM_LIT> ) ) ) { int tmp = GPR_0 ; if ( int_attr ) fputs ( <STR_LIT> , file ) ; else tmp = GPR_16 ; gcc_assert ( call_used_or_fixed_reg_p ( tmp ) ) ; fprintf ( file , <STR_LIT> , tmp ) ; assemble_name ( file , dst_name ) ; fprintf ( file , <STR_LIT> <STR_LIT> , tmp ) ; assemble_name ( file , dst_name ) ; fprintf ( file , <STR_LIT> <STR_LIT> , tmp ) ; }


<s> static bool epiphany_support_vector_misalignment ( machine_mode mode , const_tree type , int misalignment , bool is_packed ) { if ( GET_MODE_SIZE ( mode ) == <NUM_LIT> && misalignment % <NUM_LIT> == <NUM_LIT> ) return true ;


<s> if ( GET_MODE_SIZE ( mode ) == <NUM_LIT> && misalignment % <NUM_LIT> == <NUM_LIT> ) return true ;


<s> rtx fnaddr = XEXP ( DECL_RTL ( fndecl ) , <NUM_LIT> ) ; rtx tramp = force_reg ( Pmode , XEXP ( tramp_mem , <NUM_LIT> ) ) ;

emit_move_insn ( gen_rtx_MEM ( SImode , plus_constant ( Pmode , tramp , <NUM_LIT> ) ) , gen_rtx_IOR ( SImode , GEN_INT ( <NUM_LIT> ) , EPIPHANY_LOW_RTX ( fnaddr ) ) ) ;


<s> emit_move_insn ( gen_rtx_MEM ( SImode , plus_constant ( Pmode , tramp , <NUM_LIT> ) ) , gen_rtx_IOR ( SImode , GEN_INT ( <NUM_LIT> ) , EPIPHANY_LOW_RTX ( fnaddr ) ) ) ; emit_move_insn ( gen_rtx_MEM ( SImode , plus_constant ( Pmode , tramp , <NUM_LIT> ) ) , gen_rtx_IOR ( SImode , GEN_INT ( <NUM_LIT> ) , EPIPHANY_HIGH_RTX ( fnaddr ) ) ) ; emit_move_insn ( gen_rtx_MEM ( SImode , plus_constant ( Pmode , tramp , <NUM_LIT> ) ) , gen_rtx_IOR ( SImode , GEN_INT ( <NUM_LIT> ) , EPIPHANY_LOW_RTX ( cxt ) ) ) ;

emit_move_insn ( gen_rtx_MEM ( SImode , plus_constant ( Pmode , tramp , <NUM_LIT> ) ) , gen_rtx_IOR ( SImode , GEN_INT ( <NUM_LIT> ) , EPIPHANY_HIGH_RTX ( cxt ) ) ) ;


<s> if ( t ) { attrs = TYPE_ATTRIBUTES ( TREE_TYPE ( t ) ) ; if ( lookup_attribute ( <STR_LIT> , attrs ) ) return true ; } return false ;


<s> attrs = TYPE_ATTRIBUTES ( TREE_TYPE ( t ) ) ; if ( lookup_attribute ( <STR_LIT> , attrs ) ) return true ; } return false ;


<s> static bool epiphany_vector_alignment_reachable ( const_tree type , bool is_packed ) {

if ( TYPE_ALIGN_UNIT ( type ) == <NUM_LIT> ) return ! is_packed ;


<s> if ( TYPE_ALIGN_UNIT ( type ) == <NUM_LIT> ) return ! is_packed ;


<s> if ( GET_MODE_CLASS ( mode ) == MODE_VECTOR_INT && ( GET_MODE_SIZE ( mode ) == <NUM_LIT> || GET_MODE_SIZE ( mode ) == <NUM_LIT> ) ) return true ; return false ;


<s> if ( GET_CODE ( part ) == SET ) RTX_FRAME_RELATED_P ( part ) = <NUM_LIT> ; XVECEXP ( note , <NUM_LIT> , i + <NUM_LIT> ) = part ; } } else { for ( i = XVECLEN ( x , <NUM_LIT> ) - <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) { part = XVECEXP ( x , <NUM_LIT> , i ) ; if ( GET_CODE ( part ) == SET ) RTX_FRAME_RELATED_P ( part ) = <NUM_LIT> ; } } }

else if ( GET_CODE ( x ) == SET && GET_MODE ( SET_DEST ( x ) ) == DImode ) note = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , frame_subreg_note ( x , <NUM_LIT> ) , frame_subreg_note ( x , UNITS_PER_WORD ) ) ) ;


<s> static rtx_insn * frame_move_insn ( rtx to , rtx from ) { return frame_insn ( gen_rtx_SET ( to , from ) ) ;


<s> set = gen_rtx_SET ( dst , src ) ; RTX_FRAME_RELATED_P ( set ) = <NUM_LIT> ; return set ;


<s> static rtx frame_subreg_note ( rtx set , int offset ) { rtx src = simplify_gen_subreg ( SImode , SET_SRC ( set ) , DImode , offset ) ;

rtx dst = simplify_gen_subreg ( SImode , SET_DEST ( set ) , DImode , offset ) ;


<s> } } cc_reg = gen_rtx_REG ( mode , CC_REGNUM ) ; } if ( ( mode == CC_FP_EQmode || mode == CC_FP_GTEmode || mode == CC_FP_ORDmode || mode == CC_FP_UNEQmode ) && ( ! REG_P ( x ) || REGNO ( x ) != GPR_0 || ! REG_P ( y ) || REGNO ( y ) != GPR_1 ) ) { rtx reg ; gcc_assert ( currently_expanding_to_rtl ) ; reg = gen_rtx_REG ( in_mode , GPR_0 ) ; if ( reg_overlap_mentioned_p ( reg , y ) ) return <NUM_LIT> ; emit_move_insn ( reg , x ) ; x = reg ; reg = gen_rtx_REG ( in_mode , GPR_1 ) ; emit_move_insn ( reg , y ) ; y = reg ; } else x = force_reg ( in_mode , x ) ; pat = gen_rtx_SET ( cc_reg , gen_rtx_COMPARE ( mode , x , y ) ) ; if ( mode == CC_FP_EQmode || mode == CC_FP_GTEmode ) { const char * name = mode == CC_FP_EQmode ? <STR_LIT> : <STR_LIT> ; rtx use = gen_rtx_USE ( VOIDmode , sfunc_symbol ( name ) ) ; clob0 = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( SImode , GPR_IP ) ) ; clob1 = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( SImode , GPR_LR ) ) ;

pat = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , pat , use , clob0 , clob1 ) ) ;


<s> MEM_NOTRAP_P ( mem ) = <NUM_LIT> ; set_mem_alias_set ( mem , get_varargs_alias_set ( ) ) ; return mem ;


<s> case E_CC_FPmode : switch ( GET_CODE ( comparison ) ) { case EQ : return <NUM_LIT> ; case NE : return <NUM_LIT> ; case LT : return <NUM_LIT> ; case LE : return <NUM_LIT> ; default : gcc_unreachable ( ) ; } case E_CC_FP_EQmode : switch ( GET_CODE ( comparison ) ) { case EQ : return <NUM_LIT> ; case NE : return <NUM_LIT> ; default : gcc_unreachable ( ) ; } case E_CC_FP_GTEmode : switch ( GET_CODE ( comparison ) ) { case EQ : return <NUM_LIT> ; case NE : return <NUM_LIT> ; case GT : return <NUM_LIT> ; case GE : return <NUM_LIT> ; case UNLE : return <NUM_LIT> ; case UNLT : return <NUM_LIT> ;


else if ( can_create_pseudo_p ( ) ) sym = copy_to_mode_reg ( Pmode , sym ) ;


<s> rtx sfunc_symbol ( const char * name ) { rtx sym = gen_rtx_SYMBOL_REF ( Pmode , name ) ; SYMBOL_REF_FLAGS ( sym ) = SYMBOL_FLAG_FUNCTION | SYMBOL_FLAG_LOCAL ; if ( TARGET_SHORT_CALLS ) ; else if ( can_create_pseudo_p ( ) ) sym = copy_to_mode_reg ( Pmode , sym ) ;

else gcc_assert ( ! reload_in_progress || reload_completed ) ;


<s> virtual unsigned int execute ( function * ) {


<s> rtx_insn * insn ; int mode ; if ( ! OPTIMIZE_MODE_SWITCHING ( e ) ) continue ; for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) { if ( ! INSN_P ( insn ) ) continue ; mode = epiphany_mode_needed ( e , insn ) ; if ( mode == no_mode ) continue ; if ( target_insert_mode_switch_use ) { target_insert_mode_switch_use ( insn , e , mode ) ; df_insn_rescan ( insn ) ; } } }


<s> return new pass_mode_switch_use ( ctxt ) ;


<s> pass_mode_switch_use ( gcc :: context * ctxt ) : rtl_opt_pass ( pass_data_mode_switch_use , ctxt ) {


<s> enum attr_fp_mode selected_mode ; if ( ! NONJUMP_INSN_P ( insn ) || recog_memoized ( insn ) != CODE_FOR_set_fp_mode ) continue ; src = SET_SRC ( XVECEXP ( PATTERN ( insn ) , <NUM_LIT> , <NUM_LIT> ) ) ; if ( finalize_fp_sets ) { SET_SRC ( XVECEXP ( PATTERN ( insn ) , <NUM_LIT> , <NUM_LIT> ) ) = copy_rtx ( src ) ; if ( REG_P ( src ) ) df_insn_rescan ( insn ) ; continue ; } if ( REG_P ( src ) || XINT ( XVECEXP ( XEXP ( src , <NUM_LIT> ) , <NUM_LIT> , <NUM_LIT> ) , <NUM_LIT> ) != FP_MODE_ROUND_UNKNOWN ) continue ; if ( find_regno_note ( insn , REG_UNUSED , FP_TRUNCATE_REGNUM ) ) selected_mode = FP_MODE_ROUND_NEAREST ; else if ( find_regno_note ( insn , REG_UNUSED , FP_NEAREST_REGNUM ) ) selected_mode = FP_MODE_ROUND_TRUNC ; else { selected_mode = ( enum attr_fp_mode ) epiphany_normal_fp_rounding ; todo . quick_push ( bb ) ; bitmap_set_bit ( pushed , bb -> index ) ; } XVECEXP ( XEXP ( src , <NUM_LIT> ) , <NUM_LIT> , <NUM_LIT> ) = GEN_INT ( selected_mode ) ; SET_SRC ( XVECEXP ( PATTERN ( insn ) , <NUM_LIT> , <NUM_LIT> ) ) = copy_rtx ( src ) ; SET_SRC ( XVECEXP ( PATTERN ( insn ) , <NUM_LIT> , <NUM_LIT> ) ) = copy_rtx ( src ) ; df_insn_rescan ( insn ) ; } while ( todo . length ( ) ) { basic_block bb = todo . pop ( ) ; int selected_reg , jilted_reg ; enum attr_fp_mode jilted_mode ; edge e ; edge_iterator ei ; bitmap_set_bit ( pushed , bb -> index ) ; bitmap_set_bit ( pushed , bb -> index ) ; if ( epiphany_normal_fp_rounding == FP_MODE_ROUND_NEAREST ) { selected_reg = FP_NEAREST_REGNUM ; jilted_reg = FP_TRUNCATE_REGNUM ; jilted_mode = FP_MODE_ROUND_TRUNC ; } else { selected_reg = FP_TRUNCATE_REGNUM ; jilted_reg = FP_NEAREST_REGNUM ; jilted_mode = FP_MODE_ROUND_NEAREST ; } FOR_EACH_EDGE ( e , ei , bb -> succs ) { basic_block succ = e -> dest ; rtx_insn * seq ; if ( ! REGNO_REG_SET_P ( DF_LIVE_IN ( succ ) , jilted_reg ) ) continue ; if ( REGNO_REG_SET_P ( DF_LIVE_IN ( succ ) , selected_reg ) ) { if ( bitmap_bit_p ( pushed , succ -> index ) ) continue ; todo . quick_push ( succ ) ; bitmap_set_bit ( pushed , bb -> index ) ; continue ; } start_sequence ( ) ; emit_set_fp_mode ( EPIPHANY_MSW_ENTITY_ROUND_UNKNOWN , jilted_mode , FP_MODE_NONE , reg_class_contents [ NO_REGS ] ) ; seq = get_insns ( ) ;


<s> todo . quick_push ( bb ) ; bitmap_set_bit ( pushed , bb -> index ) ; } XVECEXP ( XEXP ( src , <NUM_LIT> ) , <NUM_LIT> , <NUM_LIT> ) = GEN_INT ( selected_mode ) ; SET_SRC ( XVECEXP ( PATTERN ( insn ) , <NUM_LIT> , <NUM_LIT> ) ) = copy_rtx ( src ) ; SET_SRC ( XVECEXP ( PATTERN ( insn ) , <NUM_LIT> , <NUM_LIT> ) ) = copy_rtx ( src ) ; df_insn_rescan ( insn ) ;


<s> src = SET_SRC ( XVECEXP ( PATTERN ( insn ) , <NUM_LIT> , <NUM_LIT> ) ) ; if ( finalize_fp_sets ) { SET_SRC ( XVECEXP ( PATTERN ( insn ) , <NUM_LIT> , <NUM_LIT> ) ) = copy_rtx ( src ) ; if ( REG_P ( src ) ) df_insn_rescan ( insn ) ; continue ; } if ( REG_P ( src ) || XINT ( XVECEXP ( XEXP ( src , <NUM_LIT> ) , <NUM_LIT> , <NUM_LIT> ) , <NUM_LIT> ) != FP_MODE_ROUND_UNKNOWN ) continue ; if ( find_regno_note ( insn , REG_UNUSED , FP_TRUNCATE_REGNUM ) ) selected_mode = FP_MODE_ROUND_NEAREST ; else if ( find_regno_note ( insn , REG_UNUSED , FP_NEAREST_REGNUM ) ) selected_mode = FP_MODE_ROUND_TRUNC ; else { selected_mode = ( enum attr_fp_mode ) epiphany_normal_fp_rounding ; todo . quick_push ( bb ) ; bitmap_set_bit ( pushed , bb -> index ) ; } XVECEXP ( XEXP ( src , <NUM_LIT> ) , <NUM_LIT> , <NUM_LIT> ) = GEN_INT ( selected_mode ) ; SET_SRC ( XVECEXP ( PATTERN ( insn ) , <NUM_LIT> , <NUM_LIT> ) ) = copy_rtx ( src ) ; SET_SRC ( XVECEXP ( PATTERN ( insn ) , <NUM_LIT> , <NUM_LIT> ) ) = copy_rtx ( src ) ; df_insn_rescan ( insn ) ;


<s> return new pass_resolve_sw_modes ( ctxt ) ;


<s> pass_resolve_sw_modes ( gcc :: context * ctxt ) : rtl_opt_pass ( pass_data_resolve_sw_modes , ctxt ) {