<s> int named_size = <NUM_LIT> ; if ( ! TYPE_NO_NAMED_ARGS_STDARG_P ( TREE_TYPE ( current_function_decl ) ) ) named_size = GET_MODE_SIZE ( SImode ) * ( * cum - FT32_R0 ) + GET_MODE_SIZE ( arg . mode ) ;


<s> static enum machine_mode ft32_addr_space_address_mode ( addr_space_t addrspace ATTRIBUTE_UNUSED ) { return Pmode ;


<s> op2 = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( op1 ) == REG && CONST_INT_P ( op2 ) && INTVAL ( op2 ) >= - <NUM_LIT> && INTVAL ( op2 ) < <NUM_LIT> && reg_ok_for_base_p ( op1 , strict ) ) goto yes ; if ( GET_CODE ( op1 ) == SYMBOL_REF && CONST_INT_P ( op2 ) ) goto yes ; } if ( REG_P ( x ) && reg_ok_for_base_p ( x , strict ) ) goto yes ; if ( GET_CODE ( x ) == SYMBOL_REF || GET_CODE ( x ) == LABEL_REF || CONST_INT_P ( x ) ) goto yes ; } else { if ( REG_P ( x ) && reg_ok_for_base_p ( x , strict ) ) goto yes ; } return <NUM_LIT> ; yes :


<s> if ( GET_CODE ( op1 ) == SYMBOL_REF && CONST_INT_P ( op2 ) ) goto yes ; } if ( REG_P ( x ) && reg_ok_for_base_p ( x , strict ) ) goto yes ; if ( GET_CODE ( x ) == SYMBOL_REF || GET_CODE ( x ) == LABEL_REF || CONST_INT_P ( x ) ) goto yes ; } else {


<s> if ( * cum >= <NUM_LIT> ) return <NUM_LIT> ; if ( ft32_pass_by_reference ( cum_v , mode , type , named ) ) size = <NUM_LIT> ; else if ( type ) {

if ( AGGREGATE_TYPE_P ( type ) ) return <NUM_LIT> ;


<s> if ( ft32_pass_by_reference ( cum_v , mode , type , named ) ) size = <NUM_LIT> ; else if ( type ) { if ( AGGREGATE_TYPE_P ( type ) ) return <NUM_LIT> ;


<s> int padding_locals ; int regno ; cfun -> machine -> local_vars_size = get_frame_size ( ) ; padding_locals = cfun -> machine -> local_vars_size % stack_alignment ; if ( padding_locals ) padding_locals = stack_alignment - padding_locals ; cfun -> machine -> local_vars_size += padding_locals ; cfun -> machine -> callee_saved_reg_size = <NUM_LIT> ; for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( df_regs_ever_live_p ( regno ) && ( ! call_used_regs [ regno ] ) ) cfun -> machine -> callee_saved_reg_size += <NUM_LIT> ;

cfun -> machine -> size_for_adjusting_sp = crtl -> args . pretend_args_size + cfun -> machine -> local_vars_size + ( ACCUMULATE_OUTGOING_ARGS ? crtl -> outgoing_args_size : <NUM_LIT> ) ;


<s> int regno ; if ( ! must_link ( ) && ( cfun -> machine -> size_for_adjusting_sp == <NUM_LIT> ) && ( cfun -> machine -> callee_saved_reg_size == <NUM_LIT> ) ) { emit_jump_insn ( gen_returner24 ( ) ) ; return ; } int epilog24 = ( ! must_link ( ) && ( cfun -> machine -> size_for_adjusting_sp == <NUM_LIT> ) && optimize_size ) ; if ( must_link ( ) ) { emit_insn ( gen_unlink ( ) ) ; } else if ( ! epilog24 && ( cfun -> machine -> size_for_adjusting_sp > <NUM_LIT> ) ) { emit_insn ( gen_addsi3 ( gen_rtx_REG ( SImode , FT32_SP ) , gen_rtx_REG ( SImode , FT32_SP ) , GEN_INT ( cfun -> machine -> size_for_adjusting_sp ) ) ) ; } if ( cfun -> machine -> callee_saved_reg_size != <NUM_LIT> ) { for ( regno = FIRST_PSEUDO_REGISTER ; regno -- > <NUM_LIT> ; ) { if ( ! fixed_regs [ regno ] && ! call_used_regs [ regno ] && df_regs_ever_live_p ( regno ) ) { rtx preg = gen_rtx_REG ( Pmode , regno ) ; if ( optimize_size ) { if ( epilog24 ) emit_insn ( gen_jump_epilog24 ( preg ) ) ; else emit_insn ( gen_jump_epilog ( preg ) ) ; return ; } emit_insn ( gen_movsi_pop ( preg ) ) ;


<s> int regno ; rtx insn ; ft32_compute_frame ( ) ; if ( flag_stack_usage_info ) current_function_static_stack_size = cfun -> machine -> size_for_adjusting_sp ; if ( ! must_link ( ) && ( cfun -> machine -> callee_saved_reg_size == <NUM_LIT> ) ) { insn = emit_insn ( gen_link ( gen_rtx_REG ( Pmode , FT32_R13 ) , GEN_INT ( - cfun -> machine -> size_for_adjusting_sp ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; return ; } if ( optimize_size ) { for ( regno = FIRST_PSEUDO_REGISTER ; regno -- > <NUM_LIT> ; ) { if ( ! fixed_regs [ regno ] && ! call_used_regs [ regno ] && df_regs_ever_live_p ( regno ) ) { rtx preg = gen_rtx_REG ( Pmode , regno ) ; emit_insn ( gen_call_prolog ( preg ) ) ; break ; } } } else { for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) {

if ( ! fixed_regs [ regno ] && df_regs_ever_live_p ( regno ) && ! call_used_regs [ regno ] ) {


<s> static rtx ft32_function_arg ( cumulative_args_t cum_v , enum machine_mode mode , const_tree type ATTRIBUTE_UNUSED , bool named ATTRIBUTE_UNUSED ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; if ( * cum < <NUM_LIT> ) return gen_rtx_REG ( mode , * cum ) ; else return NULL_RTX ;


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

* cum = ( * cum < FT32_R6 ? * cum + ( ( <NUM_LIT> + FT32_FUNCTION_ARG_SIZE ( mode , type ) ) / <NUM_LIT> ) : * cum ) ;


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


<s> for ( rd = <NUM_LIT> ; rd < <NUM_LIT> ; rd ++ ) { u = ( ( u >> <NUM_LIT> ) & <NUM_LIT> ) | ( u << <NUM_LIT> ) ; if ( ( - <NUM_LIT> <= ( int32_t ) u ) && ( ( int32_t ) u <= <NUM_LIT> ) ) { ft32_load_immediate ( dst , ( int32_t ) u ) ; sprintf ( pattern , <STR_LIT> , rd ) ; output_asm_insn ( pattern , & dst ) ; return <STR_LIT> ; } } ft32_load_immediate ( dst , i >> <NUM_LIT> ) ;

sprintf ( pattern , <STR_LIT> , i & <NUM_LIT> ) ;


<s> else { int rd ; uint32_t u = i ; for ( rd = <NUM_LIT> ; rd < <NUM_LIT> ; rd ++ ) { u = ( ( u >> <NUM_LIT> ) & <NUM_LIT> ) | ( u << <NUM_LIT> ) ; if ( ( - <NUM_LIT> <= ( int32_t ) u ) && ( ( int32_t ) u <= <NUM_LIT> ) ) { ft32_load_immediate ( dst , ( int32_t ) u ) ; sprintf ( pattern , <STR_LIT> , rd ) ; output_asm_insn ( pattern , & dst ) ; return <STR_LIT> ; } } ft32_load_immediate ( dst , i >> <NUM_LIT> ) ; sprintf ( pattern , <STR_LIT> , i & <NUM_LIT> ) ;


<s> if ( AGGREGATE_TYPE_P ( type ) ) return true ; size = int_size_in_bytes ( type ) ; } else size = GET_MODE_SIZE ( mode ) ; return size > <NUM_LIT> * <NUM_LIT> ;


<s> static bool ft32_pass_by_reference ( cumulative_args_t cum ATTRIBUTE_UNUSED , enum machine_mode mode , const_tree type , bool named ATTRIBUTE_UNUSED ) { unsigned HOST_WIDE_INT size ; if ( type ) { if ( AGGREGATE_TYPE_P ( type ) ) return true ; size = int_size_in_bytes ( type ) ; }


<s> fprintf ( file , <STR_LIT> , dwspec ) ; return ; } case 'f' : { int bf = ft32_as_bitfield ( INTVAL ( x ) ) ; fprintf ( file , <STR_LIT> , bf >> <NUM_LIT> , bf & <NUM_LIT> ) ; return ; } case 'g' : { int bf = ft32_as_bitfield ( <NUM_LIT> ^ INTVAL ( x ) ) ; fprintf ( file , <STR_LIT> , bf >> <NUM_LIT> , bf & <NUM_LIT> ) ; return ; } case 'b' : { ft32_print_operand ( file , XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ; return ; } default : LOSE_AND_RETURN ( <STR_LIT> , x ) ; } switch ( GET_CODE ( operand ) ) { case REG : fprintf ( file , <STR_LIT> , reg_names [ REGNO ( operand ) ] ) ; return ; case MEM :

output_address ( GET_MODE ( XEXP ( operand , <NUM_LIT> ) ) , XEXP ( operand , <NUM_LIT> ) ) ;


<s> rtx operand = x ; switch ( code ) { case <NUM_LIT> : break ; case 'h' : if ( GET_CODE ( operand ) != REG ) internal_error ( <STR_LIT> ) ; fprintf ( file , <STR_LIT> , reg_names [ REGNO ( operand ) + <NUM_LIT> ] ) ; return ; case 'm' : fprintf ( file , <STR_LIT> , ( long ) ( - INTVAL ( x ) ) ) ; return ; case 'd' : { int i = INTVAL ( x ) ; char dwspec ; switch ( i ) { case <NUM_LIT> : dwspec = 'b' ; break ; case <NUM_LIT> : dwspec = 's' ; break ; case <NUM_LIT> : dwspec = 'l' ; break ; default : if ( ( i % <NUM_LIT> ) != <NUM_LIT> ) internal_error ( <STR_LIT> , i ) ; else dwspec = 'l' ; break ; } fprintf ( file , <STR_LIT> , dwspec ) ; return ; } case 'f' : { int bf = ft32_as_bitfield ( INTVAL ( x ) ) ; fprintf ( file , <STR_LIT> , bf >> <NUM_LIT> , bf & <NUM_LIT> ) ; return ; } case 'g' : { int bf = ft32_as_bitfield ( <NUM_LIT> ^ INTVAL ( x ) ) ;


<s> int regs = <NUM_LIT> - * cum ; * pretend_size = regs < <NUM_LIT> ? <NUM_LIT> : GET_MODE_SIZE ( SImode ) * regs ; if ( no_rtl ) return ; for ( regno = * cum ; regno < <NUM_LIT> ; regno ++ ) { rtx reg = gen_rtx_REG ( SImode , regno ) ; rtx slot = gen_rtx_PLUS ( Pmode , gen_rtx_REG ( SImode , ARG_POINTER_REGNUM ) , GEN_INT ( UNITS_PER_WORD * ( regno - FT32_R0 ) ) ) ; emit_move_insn ( gen_rtx_MEM ( SImode , slot ) , reg ) ;


<s> rtx reg = gen_rtx_REG ( SImode , regno ) ; rtx slot = gen_rtx_PLUS ( Pmode , gen_rtx_REG ( SImode , ARG_POINTER_REGNUM ) , GEN_INT ( UNITS_PER_WORD * ( regno - FT32_R0 ) ) ) ; emit_move_insn ( gen_rtx_MEM ( SImode , slot ) , reg ) ; }


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


<s> cfun -> machine -> local_vars_size += padding_locals ; cfun -> machine -> callee_saved_reg_size = <NUM_LIT> ; for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( df_regs_ever_live_p ( regno ) && ( ! call_used_regs [ regno ] ) ) cfun -> machine -> callee_saved_reg_size += <NUM_LIT> ; cfun -> machine -> size_for_adjusting_sp = <NUM_LIT> + cfun -> machine -> local_vars_size + ( ACCUMULATE_OUTGOING_ARGS ? crtl -> outgoing_args_size : <NUM_LIT> ) ;


<s> void ft32_expand_epilogue ( void ) { int regno ; int pretend = crtl -> args . pretend_args_size ; if ( ! must_link ( ) && ( cfun -> machine -> size_for_adjusting_sp == <NUM_LIT> ) && ( cfun -> machine -> callee_saved_reg_size == <NUM_LIT> ) ) { emit_jump_insn ( gen_returner24 ( ) ) ; return ; } int epilog24 = ( ! must_link ( ) && ( cfun -> machine -> size_for_adjusting_sp == <NUM_LIT> ) && optimize_size ) ; if ( must_link ( ) ) { emit_insn ( gen_unlink ( ) ) ; } else if ( ! epilog24 && ( cfun -> machine -> size_for_adjusting_sp > <NUM_LIT> ) ) { emit_insn ( gen_addsi3 ( gen_rtx_REG ( SImode , FT32_SP ) , gen_rtx_REG ( SImode , FT32_SP ) , GEN_INT ( cfun -> machine -> size_for_adjusting_sp ) ) ) ; } if ( cfun -> machine -> callee_saved_reg_size != <NUM_LIT> ) { for ( regno = FIRST_PSEUDO_REGISTER ; regno -- > <NUM_LIT> ; ) { if ( ! fixed_regs [ regno ] && ! call_used_regs [ regno ] && df_regs_ever_live_p ( regno ) ) { rtx preg = gen_rtx_REG ( Pmode , regno ) ; if ( optimize_size && ( pretend == <NUM_LIT> ) ) { if ( epilog24 ) emit_insn ( gen_jump_epilog24 ( preg ) ) ; else emit_insn ( gen_jump_epilog ( preg ) ) ; return ; } emit_insn ( gen_movsi_pop ( preg ) ) ; } } } if ( pretend != <NUM_LIT> ) emit_jump_insn ( gen_pretend_returner ( GEN_INT ( pretend ) ) ) ; else emit_jump_insn ( gen_returner ( ) ) ;


<s> int pretend = crtl -> args . pretend_args_size ; if ( ! must_link ( ) && ( cfun -> machine -> size_for_adjusting_sp == <NUM_LIT> ) && ( cfun -> machine -> callee_saved_reg_size == <NUM_LIT> ) ) { emit_jump_insn ( gen_returner24 ( ) ) ; return ; } int epilog24 = ( ! must_link ( ) && ( cfun -> machine -> size_for_adjusting_sp == <NUM_LIT> ) && optimize_size ) ; if ( must_link ( ) ) { emit_insn ( gen_unlink ( ) ) ; } else if ( ! epilog24 && ( cfun -> machine -> size_for_adjusting_sp > <NUM_LIT> ) ) { emit_insn ( gen_addsi3 ( gen_rtx_REG ( SImode , FT32_SP ) , gen_rtx_REG ( SImode , FT32_SP ) , GEN_INT ( cfun -> machine -> size_for_adjusting_sp ) ) ) ; } if ( cfun -> machine -> callee_saved_reg_size != <NUM_LIT> ) { for ( regno = FIRST_PSEUDO_REGISTER ; regno -- > <NUM_LIT> ; ) { if ( ! fixed_regs [ regno ] && ! call_used_regs [ regno ] && df_regs_ever_live_p ( regno ) ) { rtx preg = gen_rtx_REG ( Pmode , regno ) ; if ( optimize_size && ( pretend == <NUM_LIT> ) ) { if ( epilog24 ) emit_insn ( gen_jump_epilog24 ( preg ) ) ; else emit_insn ( gen_jump_epilog ( preg ) ) ; return ; } emit_insn ( gen_movsi_pop ( preg ) ) ; } } } if ( pretend != <NUM_LIT> ) emit_jump_insn ( gen_pretend_returner ( GEN_INT ( pretend ) ) ) ;

else emit_jump_insn ( gen_returner ( ) ) ;


<s> insn = emit_insn ( gen_movsi_pop ( ( gen_rtx_REG ( Pmode , FT32_R29 ) ) ) ) ; for ( i = <NUM_LIT> ; i < ( args_to_push / <NUM_LIT> ) ; i ++ ) { insn = emit_insn ( gen_movsi_push ( ( gen_rtx_REG ( Pmode , FT32_R5 - i ) ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } insn = emit_insn ( gen_movsi_push ( ( gen_rtx_REG ( Pmode , FT32_R29 ) ) ) ) ; } if ( flag_stack_usage_info ) current_function_static_stack_size = cfun -> machine -> size_for_adjusting_sp ; if ( ! must_link ( ) && ( cfun -> machine -> callee_saved_reg_size == <NUM_LIT> ) ) { insn = emit_insn ( gen_link ( gen_rtx_REG ( Pmode , FT32_R13 ) , GEN_INT ( - cfun -> machine -> size_for_adjusting_sp ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; return ; } if ( optimize_size ) { for ( regno = FIRST_PSEUDO_REGISTER ; regno -- > <NUM_LIT> ; ) { if ( ! fixed_regs [ regno ] && ! call_used_regs [ regno ] && df_regs_ever_live_p ( regno ) ) { rtx preg = gen_rtx_REG ( Pmode , regno ) ; emit_insn ( gen_call_prolog ( preg ) ) ; break ;


int named_size = GET_MODE_SIZE ( SImode ) * ( * cum - FT32_R0 ) + GET_MODE_SIZE ( mode ) ;


<s> static void ft32_setup_incoming_varargs ( cumulative_args_t cum_v , enum machine_mode mode , tree type ATTRIBUTE_UNUSED , int * pretend_size , int no_rtl ATTRIBUTE_UNUSED ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ;


<s> int bytes_left , size ; if ( * cum >= <NUM_LIT> ) return <NUM_LIT> ; if ( ft32_pass_by_reference ( cum_v , mode , type , named ) ) size = <NUM_LIT> ; else if ( type ) { if ( AGGREGATE_TYPE_P ( type ) ) return <NUM_LIT> ; size = int_size_in_bytes ( type ) ; } else size = GET_MODE_SIZE ( mode ) ; bytes_left = ( <NUM_LIT> * <NUM_LIT> ) - ( ( * cum - <NUM_LIT> ) * <NUM_LIT> ) ;

if ( size > bytes_left ) return bytes_left ;


<s> cfun -> machine -> local_vars_size += padding_locals ; cfun -> machine -> callee_saved_reg_size = <NUM_LIT> ;

for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( df_regs_ever_live_p ( regno ) && ( ! call_used_regs [ regno ] ) ) cfun -> machine -> callee_saved_reg_size += <NUM_LIT> ;


<s> } if ( optimize_size ) { for ( regno = FIRST_PSEUDO_REGISTER ; regno -- > <NUM_LIT> ; ) { if ( ! fixed_regs [ regno ] && ! call_used_regs [ regno ] && df_regs_ever_live_p ( regno ) ) { rtx preg = gen_rtx_REG ( Pmode , regno ) ; emit_insn ( gen_call_prolog ( preg ) ) ; break ; } } } else { for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) { if ( ! fixed_regs [ regno ] && df_regs_ever_live_p ( regno ) && ! call_used_regs [ regno ] ) { insn = emit_insn ( gen_movsi_push ( gen_rtx_REG ( Pmode , regno ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } } } if ( cfun -> machine -> size_for_adjusting_sp >= <NUM_LIT> ) { error ( <STR_LIT> ) ; return ; } if ( must_link ( ) ) { insn = emit_insn ( gen_link ( gen_rtx_REG ( Pmode , FT32_FP ) , GEN_INT ( - cfun -> machine -> size_for_adjusting_sp ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } else if ( cfun -> machine -> size_for_adjusting_sp > <NUM_LIT> ) { int adj = cfun -> machine -> size_for_adjusting_sp ;

insn = emit_insn ( gen_addsi3 ( gen_rtx_REG ( SImode , FT32_SP ) , gen_rtx_REG ( SImode , FT32_SP ) , GEN_INT ( - adj ) ) ) ;


<s> if ( ! must_link ( ) && ( cfun -> machine -> callee_saved_reg_size == <NUM_LIT> ) ) { insn = emit_insn ( gen_link ( gen_rtx_REG ( Pmode , FT32_R13 ) , GEN_INT ( - cfun -> machine -> size_for_adjusting_sp ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; return ; } if ( optimize_size ) { for ( regno = FIRST_PSEUDO_REGISTER ; regno -- > <NUM_LIT> ; ) { if ( ! fixed_regs [ regno ] && ! call_used_regs [ regno ] && df_regs_ever_live_p ( regno ) ) { rtx preg = gen_rtx_REG ( Pmode , regno ) ; emit_insn ( gen_call_prolog ( preg ) ) ; break ; } } } else { for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) { if ( ! fixed_regs [ regno ] && df_regs_ever_live_p ( regno ) && ! call_used_regs [ regno ] ) { insn = emit_insn ( gen_movsi_push ( gen_rtx_REG ( Pmode , regno ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } } } if ( cfun -> machine -> size_for_adjusting_sp >= <NUM_LIT> ) { error ( <STR_LIT> ) ; return ; } if ( must_link ( ) ) { insn = emit_insn ( gen_link ( gen_rtx_REG ( Pmode , FT32_FP ) , GEN_INT ( - cfun -> machine -> size_for_adjusting_sp ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } else if ( cfun -> machine -> size_for_adjusting_sp > <NUM_LIT> ) {

int adj = cfun -> machine -> size_for_adjusting_sp ;


<s> static rtx ft32_function_arg ( cumulative_args_t cum_v , machine_mode mode , const_tree type ATTRIBUTE_UNUSED , bool named ATTRIBUTE_UNUSED ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; if ( * cum < <NUM_LIT> ) return gen_rtx_REG ( mode , * cum ) ; else return NULL_RTX ;


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


<s> CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; * cum = ( * cum < FT32_R6 ? * cum + ( ( <NUM_LIT> + FT32_FUNCTION_ARG_SIZE ( mode , type ) ) / <NUM_LIT> ) : * cum ) ;


<s> static void ft32_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 = ( * cum < FT32_R6 ? * cum + ( ( <NUM_LIT> + FT32_FUNCTION_ARG_SIZE ( mode , type ) ) / <NUM_LIT> ) : * cum ) ;


<s> size = int_size_in_bytes ( type ) ; } else size = GET_MODE_SIZE ( mode ) ;


<s> int named_size = GET_MODE_SIZE ( SImode ) * ( * cum - FT32_R0 ) + GET_MODE_SIZE ( mode ) ; if ( named_size < <NUM_LIT> ) * pretend_size = <NUM_LIT> - named_size ; else * pretend_size = <NUM_LIT> ;


<s> if ( REG_P ( x ) && reg_ok_for_base_p ( x , strict ) ) goto yes ; if ( GET_CODE ( x ) == SYMBOL_REF || GET_CODE ( x ) == LABEL_REF || CONST_INT_P ( x ) ) goto yes ; } else { if ( REG_P ( x ) && reg_ok_for_base_p ( x , strict ) ) goto yes ;


<s> static bool ft32_addr_space_subset_p ( addr_space_t subset ATTRIBUTE_UNUSED , addr_space_t superset ATTRIBUTE_UNUSED ) { return false ;


<s> int bytes_left , size ; if ( * cum >= <NUM_LIT> ) return <NUM_LIT> ; if ( ft32_pass_by_reference ( cum_v , arg ) ) size = <NUM_LIT> ; else if ( arg . type ) { if ( AGGREGATE_TYPE_P ( arg . type ) ) return <NUM_LIT> ; size = int_size_in_bytes ( arg . type ) ; } else size = GET_MODE_SIZE ( arg . mode ) ; bytes_left = ( <NUM_LIT> * <NUM_LIT> ) - ( ( * cum - <NUM_LIT> ) * <NUM_LIT> ) ; if ( size > bytes_left ) return bytes_left ;


<s> int bytes_left , size ; if ( * cum >= <NUM_LIT> ) return <NUM_LIT> ; if ( ft32_pass_by_reference ( cum_v , arg ) ) size = <NUM_LIT> ; else if ( arg . type ) {

if ( AGGREGATE_TYPE_P ( arg . type ) ) return <NUM_LIT> ;


<s> int lobit , hibit ; if ( x == <NUM_LIT> ) return - <NUM_LIT> ; for ( lobit = <NUM_LIT> ; lobit < <NUM_LIT> ; lobit ++ ) if ( x & ( <NUM_LIT> << lobit ) ) break ; for ( hibit = <NUM_LIT> ; hibit >= <NUM_LIT> ; hibit -- ) if ( x & ( <NUM_LIT> << hibit ) ) break ; int width = <NUM_LIT> + hibit - lobit ; if ( width > <NUM_LIT> ) return - <NUM_LIT> ; if ( x != ( NBITS ( width ) << lobit ) ) return - <NUM_LIT> ; return ( ( width & <NUM_LIT> ) << <NUM_LIT> ) | lobit ;


<s> int ft32_as_bitfield ( unsigned int x ) { int lobit , hibit ; if ( x == <NUM_LIT> ) return - <NUM_LIT> ; for ( lobit = <NUM_LIT> ; lobit < <NUM_LIT> ; lobit ++ ) if ( x & ( <NUM_LIT> << lobit ) ) break ; for ( hibit = <NUM_LIT> ; hibit >= <NUM_LIT> ; hibit -- ) if ( x & ( <NUM_LIT> << hibit ) ) break ;


<s> return ( to == FRAME_POINTER_REGNUM ) || ! ft32_frame_pointer_required ( ) ;


<s> static bool ft32_can_eliminate ( const int from ATTRIBUTE_UNUSED , const int to ) { return <NUM_LIT> ; return ( to == FRAME_POINTER_REGNUM ) || ! ft32_frame_pointer_required ( ) ;


<s> cfun -> machine -> callee_saved_reg_size = <NUM_LIT> ;

for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( df_regs_ever_live_p ( regno ) && ! call_used_or_fixed_reg_p ( regno ) ) cfun -> machine -> callee_saved_reg_size += <NUM_LIT> ;


<s> int regno ; cfun -> machine -> local_vars_size = get_frame_size ( ) ; padding_locals = cfun -> machine -> local_vars_size % stack_alignment ; if ( padding_locals ) padding_locals = stack_alignment - padding_locals ; cfun -> machine -> local_vars_size += padding_locals ; cfun -> machine -> callee_saved_reg_size = <NUM_LIT> ; for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( df_regs_ever_live_p ( regno ) && ! call_used_or_fixed_reg_p ( regno ) ) cfun -> machine -> callee_saved_reg_size += <NUM_LIT> ; cfun -> machine -> size_for_adjusting_sp = <NUM_LIT> + cfun -> machine -> local_vars_size + ( ACCUMULATE_OUTGOING_ARGS ? ( HOST_WIDE_INT ) crtl -> outgoing_args_size : <NUM_LIT> ) ;


<s> int is_flash = ( type && TYPE_P ( type ) && ! ADDR_SPACE_GENERIC_P ( TYPE_ADDR_SPACE ( type ) ) ) ; if ( ( code == VAR_DECL ) && ! is_flash ) SYMBOL_REF_FLAGS ( symbol ) |= <NUM_LIT> ; } break ; case tcc_constant : case tcc_exceptional :

if ( code == STRING_CST ) SYMBOL_REF_FLAGS ( symbol ) |= <NUM_LIT> ;


<s> if ( ( code == VAR_DECL ) && ! is_flash ) SYMBOL_REF_FLAGS ( symbol ) |= <NUM_LIT> ; } break ; case tcc_constant : case tcc_exceptional : if ( code == STRING_CST ) SYMBOL_REF_FLAGS ( symbol ) |= <NUM_LIT> ; break ; default : break ; }


<s> if ( must_link ( ) ) { emit_insn ( gen_unlink ( ) ) ; } else if ( ! epilog24 && ( cfun -> machine -> size_for_adjusting_sp > <NUM_LIT> ) ) { emit_insn ( gen_addsi3 ( gen_rtx_REG ( SImode , FT32_SP ) , gen_rtx_REG ( SImode , FT32_SP ) , GEN_INT ( cfun -> machine -> size_for_adjusting_sp ) ) ) ; } if ( cfun -> machine -> callee_saved_reg_size != <NUM_LIT> ) { for ( regno = FIRST_PSEUDO_REGISTER ; regno -- > <NUM_LIT> ; ) { if ( ! call_used_or_fixed_reg_p ( regno ) && df_regs_ever_live_p ( regno ) ) { rtx preg = gen_rtx_REG ( Pmode , regno ) ; if ( optimize_size && ( pretend == <NUM_LIT> ) ) { if ( epilog24 ) emit_insn ( gen_jump_epilog24 ( preg ) ) ; else emit_insn ( gen_jump_epilog ( preg ) ) ; return ;


<s> void ft32_expand_epilogue ( void ) { int regno ; int pretend = crtl -> args . pretend_args_size ; if ( ! must_link ( ) && ( cfun -> machine -> size_for_adjusting_sp == <NUM_LIT> ) && ( cfun -> machine -> callee_saved_reg_size == <NUM_LIT> ) ) { emit_jump_insn ( gen_returner24 ( ) ) ; return ; } int epilog24 = ( ! must_link ( ) && ( cfun -> machine -> size_for_adjusting_sp == <NUM_LIT> ) && optimize_size ) ; if ( must_link ( ) ) { emit_insn ( gen_unlink ( ) ) ; }

else if ( ! epilog24 && ( cfun -> machine -> size_for_adjusting_sp > <NUM_LIT> ) ) {


<s> insn = emit_insn ( gen_movsi_push ( ( gen_rtx_REG ( Pmode , FT32_R5 - i ) ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } insn = emit_insn ( gen_movsi_push ( ( gen_rtx_REG ( Pmode , FT32_R29 ) ) ) ) ; } if ( flag_stack_usage_info ) current_function_static_stack_size = cfun -> machine -> size_for_adjusting_sp ; if ( ! must_link ( ) && ( cfun -> machine -> callee_saved_reg_size == <NUM_LIT> ) ) { insn = emit_insn ( gen_link ( gen_rtx_REG ( Pmode , FT32_R13 ) , GEN_INT ( - cfun -> machine -> size_for_adjusting_sp ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; return ; } if ( optimize_size ) { for ( regno = FIRST_PSEUDO_REGISTER ; regno -- > <NUM_LIT> ; ) { if ( ! call_used_or_fixed_reg_p ( regno ) && df_regs_ever_live_p ( regno ) ) { rtx preg = gen_rtx_REG ( Pmode , regno ) ; emit_insn ( gen_call_prolog ( preg ) ) ; break ; } } } else { for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) { if ( df_regs_ever_live_p ( regno ) && ! call_used_or_fixed_reg_p ( regno ) ) { insn = emit_insn ( gen_movsi_push ( gen_rtx_REG ( Pmode , regno ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } } } if ( cfun -> machine -> size_for_adjusting_sp >= <NUM_LIT> ) { error ( <STR_LIT> ) ; return ; } if ( must_link ( ) ) { insn = emit_insn ( gen_link ( gen_rtx_REG ( Pmode , FT32_FP ) , GEN_INT ( - cfun -> machine -> size_for_adjusting_sp ) ) ) ;


<s> static bool ft32_frame_pointer_required ( void ) {


<s> CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; if ( * cum < <NUM_LIT> ) return gen_rtx_REG ( arg . mode , * cum ) ;


return gen_rtx_REG ( TYPE_MODE ( valtype ) , FT32_R0 ) ;


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


<s> if ( from == ARG_POINTER_REGNUM && to == STACK_POINTER_REGNUM ) { int arg_offset ; arg_offset = must_link ( ) ? <NUM_LIT> : <NUM_LIT> ;

return ( ( cfun -> machine -> callee_saved_reg_size + arg_offset * UNITS_PER_WORD ) + cfun -> machine -> size_for_adjusting_sp ) ;


<s> return ( MEM_P ( o ) && ! ADDR_SPACE_GENERIC_P ( MEM_ADDR_SPACE ( o ) ) ) ;


<s> int ft32_is_mem_pm ( rtx o ) { return ( MEM_P ( o ) && ! ADDR_SPACE_GENERIC_P ( MEM_ADDR_SPACE ( o ) ) ) ;


<s> return gen_rtx_REG ( mode , FT32_R0 ) ;


<s> uint32_t u = i ; for ( rd = <NUM_LIT> ; rd < <NUM_LIT> ; rd ++ ) { u = ( ( u >> <NUM_LIT> ) & <NUM_LIT> ) | ( u << <NUM_LIT> ) ; if ( ( int32_t ) u >= - <NUM_LIT> && ( int32_t ) u <= <NUM_LIT> ) { ft32_load_immediate ( dst , ( int32_t ) u ) ; sprintf ( pattern , <STR_LIT> , rd ) ; output_asm_insn ( pattern , & dst ) ; return <STR_LIT> ; } } ft32_load_immediate ( dst , i >> <NUM_LIT> ) ; sprintf ( pattern , <STR_LIT> , i & <NUM_LIT> ) ; output_asm_insn ( pattern , & dst ) ; } return <STR_LIT> ;


<s> sprintf ( pattern , <STR_LIT> , i ) ; output_asm_insn ( pattern , & dst ) ; } else if ( i >= - <NUM_LIT> && i <= <NUM_LIT> ) { ft32_load_immediate ( dst , i >> <NUM_LIT> ) ; sprintf ( pattern , <STR_LIT> , i & <NUM_LIT> ) ; output_asm_insn ( pattern , & dst ) ; } else { int rd ;


<s> ft32_addr_space_legitimate_address_p static bool ft32_lra_p ( void ) { return ft32_lra_flag ;


<s> debug_rtx ( op ) ; output_operand_lossage ( <STR_LIT> , msgid ) ;


<s> output_operand_lossage ( <STR_LIT> , msgid ) ;


<s> static void ft32_option_override ( void ) { init_machine_status = ft32_init_machine_status ;


<s> { int i = INTVAL ( x ) ; char dwspec ; switch ( i ) { case <NUM_LIT> : dwspec = 'b' ; break ; case <NUM_LIT> : dwspec = 's' ; break ; case <NUM_LIT> : dwspec = 'l' ; break ; default : if ( ( i % <NUM_LIT> ) != <NUM_LIT> ) internal_error ( <STR_LIT> , i ) ; else dwspec = 'l' ; break ; } fprintf ( file , <STR_LIT> , dwspec ) ; return ; } case 'f' : { int bf = ft32_as_bitfield ( INTVAL ( x ) ) ; fprintf ( file , <STR_LIT> , bf >> <NUM_LIT> , bf & <NUM_LIT> ) ;


<s> break ; default : if ( ( i % <NUM_LIT> ) != <NUM_LIT> ) internal_error ( <STR_LIT> , i ) ; else dwspec = 'l' ; break ; } fprintf ( file , <STR_LIT> , dwspec ) ; return ; } case 'f' : { int bf = ft32_as_bitfield ( INTVAL ( x ) ) ; fprintf ( file , <STR_LIT> , bf >> <NUM_LIT> , bf & <NUM_LIT> ) ; return ; } case 'g' : { int bf = ft32_as_bitfield ( <NUM_LIT> ^ INTVAL ( x ) ) ; fprintf ( file , <STR_LIT> , bf >> <NUM_LIT> , bf & <NUM_LIT> ) ; return ; } case 'b' : { ft32_print_operand ( file , XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ; return ; } default : LOSE_AND_RETURN ( <STR_LIT> , x ) ; } switch ( GET_CODE ( operand ) ) { case REG : fprintf ( file , <STR_LIT> , reg_names [ REGNO ( operand ) ] ) ; return ; case MEM : output_address ( GET_MODE ( XEXP ( operand , <NUM_LIT> ) ) , XEXP ( operand , <NUM_LIT> ) ) ;


<s> fprintf ( file , <STR_LIT> , reg_names [ REGNO ( XEXP ( x , <NUM_LIT> ) ) ] , INTVAL ( XEXP ( x , <NUM_LIT> ) ) ) ; break ; case SYMBOL_REF : output_addr_const ( file , XEXP ( x , <NUM_LIT> ) ) ; fprintf ( file , <STR_LIT> , reg_names [ REGNO ( XEXP ( x , <NUM_LIT> ) ) ] ) ; break ; case CONST : { rtx plus = XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ; if ( GET_CODE ( XEXP ( plus , <NUM_LIT> ) ) == SYMBOL_REF && CONST_INT_P ( XEXP ( plus , <NUM_LIT> ) ) ) { output_addr_const ( file , XEXP ( plus , <NUM_LIT> ) ) ; fprintf ( file , <STR_LIT> , INTVAL ( XEXP ( plus , <NUM_LIT> ) ) , reg_names [ REGNO ( XEXP ( x , <NUM_LIT> ) ) ] ) ; } else abort ( ) ; } break ; default : abort ( ) ;


<s> switch ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) ) { case CONST_INT : fprintf ( file , <STR_LIT> , reg_names [ REGNO ( XEXP ( x , <NUM_LIT> ) ) ] , INTVAL ( XEXP ( x , <NUM_LIT> ) ) ) ; break ; case SYMBOL_REF : output_addr_const ( file , XEXP ( x , <NUM_LIT> ) ) ; fprintf ( file , <STR_LIT> , reg_names [ REGNO ( XEXP ( x , <NUM_LIT> ) ) ] ) ; break ; case CONST : { rtx plus = XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ; if ( GET_CODE ( XEXP ( plus , <NUM_LIT> ) ) == SYMBOL_REF && CONST_INT_P ( XEXP ( plus , <NUM_LIT> ) ) ) {

output_addr_const ( file , XEXP ( plus , <NUM_LIT> ) ) ;


<s> const HOST_WIDE_INT size = int_size_in_bytes ( type ) ; return ( size == - <NUM_LIT> || size > <NUM_LIT> * UNITS_PER_WORD ) ;


<s> return ( size == - <NUM_LIT> || size > <NUM_LIT> * UNITS_PER_WORD ) ;


<s> if ( TREE_TYPE ( decl ) != error_mark_node && TYPE_ADDR_SPACE ( TREE_TYPE ( decl ) ) == ADDR_SPACE_PM ) { if ( ! DECL_P ( decl ) ) return get_section ( <STR_LIT> , SECTION_WRITE | SECTION_DEBUG , NULL ) ; return get_named_section ( decl , <STR_LIT> , reloc ) ; }

return default_elf_select_section ( decl , reloc , align ) ;


<s> int named_size = GET_MODE_SIZE ( SImode ) * ( * cum - FT32_R0 ) + GET_MODE_SIZE ( arg . mode ) ;


<s> static unsigned int ft32_target_case_values_threshold ( void ) { return <NUM_LIT> ;


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


<s> return ( bigframe || frame_pointer_needed || df_regs_ever_live_p ( FT32_FP ) || df_regs_ever_live_p ( FT32_FP ) ) ;


int bigframe = ( cfun -> machine -> size_for_adjusting_sp >= <NUM_LIT> ) ;


<s> static bool reg_ok_for_base_p ( rtx r , bool strict ) {


<s> static bool reg_ok_for_base_p ( rtx r , bool strict ) { int NUM = REGNO ( r ) ; if ( strict ) return ( HARD_REGNO_OK_FOR_BASE_P ( NUM ) || HARD_REGNO_OK_FOR_BASE_P ( reg_renumber [ ( NUM ) ] ) ) ; else return ( ( NUM ) >= FIRST_PSEUDO_REGISTER || HARD_REGNO_OK_FOR_BASE_P ( NUM ) ) ;