<s> cfun -> machine -> total_size = total_size ; cfun -> machine -> var_size = var_size ; cfun -> machine -> args_size = args_size ; cfun -> machine -> extra_size = extra_size ; cfun -> machine -> gp_reg_size = gp_reg_size ; cfun -> machine -> fp_reg_size = fp_reg_size ; cfun -> machine -> mask = mask ; cfun -> machine -> initialized = reload_completed ; cfun -> machine -> num_gp = gp_reg_size / UNITS_PER_WORD ; if ( mask ) { unsigned long offset ; offset = ( args_size + extra_size + var_size + gp_reg_size - GET_MODE_SIZE ( gpr_mode ) ) ; cfun -> machine -> gp_sp_offset = offset ; cfun -> machine -> gp_save_offset = offset - total_size ; } else { cfun -> machine -> gp_sp_offset = <NUM_LIT> ; cfun -> machine -> gp_save_offset = <NUM_LIT> ; } cfun -> machine -> fp_sp_offset = <NUM_LIT> ;

cfun -> machine -> fp_save_offset = <NUM_LIT> ;


<s> long mask ; int fp_inc ; long fp_bits ; gp_reg_size = <NUM_LIT> ; fp_reg_size = <NUM_LIT> ; mask = <NUM_LIT> ; extra_size = IQ2000_STACK_ALIGN ( ( <NUM_LIT> ) ) ; var_size = IQ2000_STACK_ALIGN ( size ) ; args_size = IQ2000_STACK_ALIGN ( current_function_outgoing_args_size ) ; if ( args_size == <NUM_LIT> && current_function_calls_alloca ) args_size = <NUM_LIT> * UNITS_PER_WORD ; total_size = var_size + args_size + extra_size ; for ( regno = GP_REG_FIRST ; regno <= GP_REG_LAST ; regno ++ ) { if ( MUST_SAVE_REGISTER ( regno ) ) { gp_reg_size += GET_MODE_SIZE ( gpr_mode ) ; mask |= <NUM_LIT> << ( regno - GP_REG_FIRST ) ; } } if ( current_function_calls_eh_return ) { unsigned int i ; for ( i = <NUM_LIT> ; ; ++ i ) { regno = EH_RETURN_DATA_REGNO ( i ) ; if ( regno == ( int ) INVALID_REGNUM ) break ; gp_reg_size += GET_MODE_SIZE ( gpr_mode ) ; mask |= <NUM_LIT> << ( regno - GP_REG_FIRST ) ; } } fp_inc = <NUM_LIT> ; fp_bits = <NUM_LIT> ; gp_reg_rounded = IQ2000_STACK_ALIGN ( gp_reg_size ) ; total_size += gp_reg_rounded + IQ2000_STACK_ALIGN ( fp_reg_size ) ; if ( total_size == extra_size && ! profile_flag ) total_size = extra_size = <NUM_LIT> ; total_size += IQ2000_STACK_ALIGN ( current_function_pretend_args_size ) ; cfun -> machine -> total_size = total_size ; cfun -> machine -> var_size = var_size ; cfun -> machine -> args_size = args_size ; cfun -> machine -> extra_size = extra_size ; cfun -> machine -> gp_reg_size = gp_reg_size ; cfun -> machine -> fp_reg_size = fp_reg_size ;


<s> if ( code [ i ] == REG && ! ( * insn_data [ icode ] . operand [ i ] . predicate ) ( op [ i ] , mode [ i ] ) ) op [ i ] = copy_to_mode_reg ( mode [ i ] , op [ i ] ) ; } if ( insn_data [ icode ] . operand [ <NUM_LIT> ] . constraint [ <NUM_LIT> ] == '=' ) { if ( target == <NUM_LIT> || GET_MODE ( target ) != mode [ <NUM_LIT> ] || ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( target , mode [ <NUM_LIT> ] ) ) target = gen_reg_rtx ( mode [ <NUM_LIT> ] ) ; } else target = <NUM_LIT> ; switch ( argcount ) { case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target ) ; case <NUM_LIT> : if ( target ) pat = GEN_FCN ( icode ) ( target , op [ <NUM_LIT> ] ) ; else pat = GEN_FCN ( icode ) ( op [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> : if ( target ) pat = GEN_FCN ( icode ) ( target , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; else pat = GEN_FCN ( icode ) ( op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> : if ( target ) pat = GEN_FCN ( icode ) ( target , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; else pat = GEN_FCN ( icode ) ( op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ;


<s> iq2000_load_reg = <NUM_LIT> ; iq2000_load_reg2 = <NUM_LIT> ; iq2000_load_reg3 = <NUM_LIT> ; iq2000_load_reg4 = <NUM_LIT> ; } if ( ( GET_CODE ( insn ) == JUMP_INSN || GET_CODE ( insn ) == CALL_INSN || ( GET_CODE ( PATTERN ( insn ) ) == RETURN ) ) && NEXT_INSN ( PREV_INSN ( insn ) ) == insn ) { rtx nop_insn = emit_insn_after ( gen_nop ( ) , insn ) ; INSN_ADDRESSES_NEW ( nop_insn , - <NUM_LIT> ) ;


<s> tree field ; for ( field = TYPE_FIELDS ( type ) ; field ; field = TREE_CHAIN ( field ) ) if ( TREE_CODE ( field ) == FIELD_DECL && TREE_CODE ( TREE_TYPE ( field ) ) == REAL_TYPE && TYPE_PRECISION ( TREE_TYPE ( field ) ) == BITS_PER_WORD && host_integerp ( bit_position ( field ) , <NUM_LIT> ) && int_bit_position ( field ) % BITS_PER_WORD == <NUM_LIT> ) break ; if ( ! field || mode == DFmode ) ret = gen_rtx_REG ( mode , regbase + * arg_words + bias ) ; else { unsigned int chunks ; HOST_WIDE_INT bitpos ; unsigned int regno ; unsigned int i ; chunks = tree_low_cst ( TYPE_SIZE_UNIT ( type ) , <NUM_LIT> ) / UNITS_PER_WORD ; if ( chunks + * arg_words + bias > ( unsigned ) MAX_ARGS_IN_REGISTERS ) chunks = MAX_ARGS_IN_REGISTERS - * arg_words - bias ; ret = gen_rtx_PARALLEL ( mode , rtvec_alloc ( chunks ) ) ; bitpos = <NUM_LIT> ; regno = regbase + * arg_words + bias ; field = TYPE_FIELDS ( type ) ; for ( i = <NUM_LIT> ; i < chunks ; i ++ ) { rtx reg ; for ( ; field ; field = TREE_CHAIN ( field ) ) if ( TREE_CODE ( field ) == FIELD_DECL && int_bit_position ( field ) >= bitpos ) break ; if ( field && int_bit_position ( field ) == bitpos && TREE_CODE ( TREE_TYPE ( field ) ) == REAL_TYPE && TYPE_PRECISION ( TREE_TYPE ( field ) ) == BITS_PER_WORD ) reg = gen_rtx_REG ( DFmode , regno ++ ) ; else reg = gen_rtx_REG ( word_mode , regno ) ; XVECEXP ( ret , <NUM_LIT> , i ) = gen_rtx_EXPR_LIST ( VOIDmode , reg , GEN_INT ( bitpos / BITS_PER_UNIT ) ) ; bitpos += <NUM_LIT> ; regno ++ ;


<s> void function_arg_advance ( CUMULATIVE_ARGS * cum , enum machine_mode mode , tree type , int named ) { if ( TARGET_DEBUG_D_MODE ) { fprintf ( stderr , <STR_LIT> , cum -> gp_reg_found , cum -> arg_number , cum -> arg_words , GET_MODE_NAME ( mode ) ) ; fprintf ( stderr , <STR_LIT> , ( void * ) type ) ; fprintf ( stderr , <STR_LIT> , named ) ; } cum -> arg_number ++ ; switch ( mode ) { case VOIDmode : break ; default : gcc_assert ( GET_MODE_CLASS ( mode ) == MODE_COMPLEX_INT || GET_MODE_CLASS ( mode ) == MODE_COMPLEX_FLOAT ) ; cum -> gp_reg_found = <NUM_LIT> ; cum -> arg_words += ( ( GET_MODE_SIZE ( mode ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ) ; break ; case BLKmode : cum -> gp_reg_found = <NUM_LIT> ; cum -> arg_words += ( ( int_size_in_bytes ( type ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ) ; break ; case SFmode : cum -> arg_words ++ ; if ( ! cum -> gp_reg_found && cum -> arg_number <= <NUM_LIT> ) cum -> fp_code += <NUM_LIT> << ( ( cum -> arg_number - <NUM_LIT> ) * <NUM_LIT> ) ; break ; case DFmode : cum -> arg_words += <NUM_LIT> ; if ( ! cum -> gp_reg_found && cum -> arg_number <= <NUM_LIT> ) cum -> fp_code += <NUM_LIT> << ( ( cum -> arg_number - <NUM_LIT> ) * <NUM_LIT> ) ; break ; case DImode : cum -> gp_reg_found = <NUM_LIT> ; cum -> arg_words += <NUM_LIT> ;


<s> mode = type == CMP_SI ? SImode : DImode ; invert = <NUM_LIT> ; reg = gen_int_relational ( test_code , NULL_RTX , cmp0 , cmp1 , & invert ) ; if ( reg ) { cmp0 = reg ; cmp1 = const0_rtx ; test_code = NE ; } else if ( GET_CODE ( cmp1 ) == CONST_INT && INTVAL ( cmp1 ) != <NUM_LIT> ) cmp1 = force_reg ( mode , cmp1 ) ; break ; case CMP_SF : case CMP_DF : reg = gen_reg_rtx ( CCmode ) ; emit_insn ( gen_rtx_SET ( VOIDmode , reg , gen_rtx_fmt_ee ( test_code == NE ? EQ : test_code , CCmode , cmp0 , cmp1 ) ) ) ; test_code = test_code == NE ? EQ : NE ; mode = CCmode ; cmp0 = reg ; cmp1 = const0_rtx ; invert = <NUM_LIT> ;


<s> reg = gen_reg_rtx ( CCmode ) ; emit_insn ( gen_rtx_SET ( VOIDmode , reg , gen_rtx_fmt_ee ( test_code == NE ? EQ : test_code , CCmode , cmp0 , cmp1 ) ) ) ; test_code = test_code == NE ? EQ : NE ; mode = CCmode ; cmp0 = reg ; cmp1 = const0_rtx ; invert = <NUM_LIT> ; break ; default : abort_with_insn ( gen_rtx_fmt_ee ( test_code , VOIDmode , cmp0 , cmp1 ) , <STR_LIT> ) ; } label1 = gen_rtx_LABEL_REF ( VOIDmode , operands [ <NUM_LIT> ] ) ; label2 = pc_rtx ; if ( invert ) { label2 = label1 ; label1 = pc_rtx ; }

emit_jump_insn ( gen_rtx_SET ( VOIDmode , pc_rtx , gen_rtx_IF_THEN_ELSE ( VOIDmode , gen_rtx_fmt_ee ( test_code , mode , cmp0 , cmp1 ) , label1 , label2 ) ) ) ;


<s> int gp_reg_size ; int fp_reg_size ; long mask ; long gp_save_offset ; long fp_save_offset ; long gp_sp_offset ; long fp_sp_offset ; int initialized ;


<s> void init_cumulative_args ( CUMULATIVE_ARGS * cum , tree fntype , rtx libname ATTRIBUTE_UNUSED ) { static CUMULATIVE_ARGS zero_cum ; tree param ; tree next_param ; if ( TARGET_DEBUG_D_MODE ) { fprintf ( stderr , <STR_LIT> , ( long ) fntype ) ; if ( ! fntype ) fputc ( '\n' , stderr ) ; else { tree ret_type = TREE_TYPE ( fntype ) ; fprintf ( stderr , <STR_LIT> , tree_code_name [ ( int ) TREE_CODE ( fntype ) ] , tree_code_name [ ( int ) TREE_CODE ( ret_type ) ] ) ;


<s> if ( TARGET_DEBUG_D_MODE ) { fprintf ( stderr , <STR_LIT> , ( long ) fntype ) ; if ( ! fntype ) fputc ( '\n' , stderr ) ; else { tree ret_type = TREE_TYPE ( fntype ) ; fprintf ( stderr , <STR_LIT> , tree_code_name [ ( int ) TREE_CODE ( fntype ) ] , tree_code_name [ ( int ) TREE_CODE ( ret_type ) ] ) ;


<s> } case SYMBOL_REF : return SYMBOL_REF_FLAG ( addr ) ? <NUM_LIT> : <NUM_LIT> ; case PLUS : { rtx plus0 = XEXP ( addr , <NUM_LIT> ) ; rtx plus1 = XEXP ( addr , <NUM_LIT> ) ; if ( GET_CODE ( plus0 ) != REG && GET_CODE ( plus1 ) == REG ) plus0 = XEXP ( addr , <NUM_LIT> ) , plus1 = XEXP ( addr , <NUM_LIT> ) ; if ( GET_CODE ( plus0 ) != REG ) break ; switch ( GET_CODE ( plus1 ) ) { case CONST_INT : return SMALL_INT ( plus1 ) ? <NUM_LIT> : <NUM_LIT> ; case CONST : case SYMBOL_REF : case LABEL_REF : case HIGH : case LO_SUM : return iq2000_address_cost ( plus1 ) + <NUM_LIT> ;


<s> if ( GET_CODE ( plus0 ) != REG && GET_CODE ( plus1 ) == REG ) plus0 = XEXP ( addr , <NUM_LIT> ) , plus1 = XEXP ( addr , <NUM_LIT> ) ; if ( GET_CODE ( plus0 ) != REG ) break ; switch ( GET_CODE ( plus1 ) ) { case CONST_INT : return SMALL_INT ( plus1 ) ? <NUM_LIT> : <NUM_LIT> ; case CONST : case SYMBOL_REF : case LABEL_REF : case HIGH : case LO_SUM : return iq2000_address_cost ( plus1 ) + <NUM_LIT> ; default : break ;


<s> int iq2000_adjust_insn_length ( rtx insn , int length ) {

if ( simplejump_p ( insn ) || ( ( GET_CODE ( insn ) == JUMP_INSN || GET_CODE ( insn ) == CALL_INSN ) ) ) length += <NUM_LIT> ;


<s> static void iq2000_annotate_frame_insn ( rtx insn , rtx dwarf_pattern ) { RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ;

REG_NOTES ( insn ) = alloc_EXPR_LIST ( REG_FRAME_RELATED_EXPR , dwarf_pattern , REG_NOTES ( insn ) ) ;


<s> RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; REG_NOTES ( insn ) = alloc_EXPR_LIST ( REG_FRAME_RELATED_EXPR , dwarf_pattern , REG_NOTES ( insn ) ) ;


<s> static int iq2000_arg_partial_bytes ( CUMULATIVE_ARGS * cum , enum machine_mode mode , tree type ATTRIBUTE_UNUSED , bool named ATTRIBUTE_UNUSED ) { if ( mode == DImode && cum -> arg_words == MAX_ARGS_IN_REGISTERS - <NUM_LIT> ) {

if ( TARGET_DEBUG_D_MODE ) fprintf ( stderr , <STR_LIT> , UNITS_PER_WORD ) ;


<s> if ( ! reload_completed ) return <NUM_LIT> ; if ( regs_ever_live [ <NUM_LIT> ] || profile_flag ) return <NUM_LIT> ; if ( cfun -> machine -> initialized ) return cfun -> machine -> total_size == <NUM_LIT> ;

return compute_frame_size ( get_frame_size ( ) ) == <NUM_LIT> ;


<s> int iq2000_can_use_return_insn ( void ) { if ( ! reload_completed ) return <NUM_LIT> ;

if ( regs_ever_live [ <NUM_LIT> ] || profile_flag ) return <NUM_LIT> ;


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


<s> static void iq2000_emit_frame_related_store ( rtx mem , rtx reg , HOST_WIDE_INT offset ) { rtx dwarf_address = plus_constant ( stack_pointer_rtx , offset ) ;

rtx dwarf_mem = gen_rtx_MEM ( GET_MODE ( reg ) , dwarf_address ) ;


<s> rtx scratch ; scratch = plus_constant ( stack_pointer_rtx , gp_offset ) ;

emit_move_insn ( gen_rtx_MEM ( GET_MODE ( address ) , scratch ) , address ) ;


<s> void iq2000_expand_eh_return ( rtx address ) {

HOST_WIDE_INT gp_offset = cfun -> machine -> gp_sp_offset ;


<s> HOST_WIDE_INT tsize = cfun -> machine -> total_size ; rtx tsize_rtx = GEN_INT ( tsize ) ; rtx tmp_rtx = ( rtx ) <NUM_LIT> ; if ( iq2000_can_use_return_insn ( ) ) { emit_jump_insn ( gen_return ( ) ) ; return ; } if ( tsize > <NUM_LIT> ) { tmp_rtx = gen_rtx_REG ( Pmode , IQ2000_TEMP1_REGNUM ) ; emit_move_insn ( tmp_rtx , tsize_rtx ) ; tsize_rtx = tmp_rtx ; } if ( tsize > <NUM_LIT> ) { if ( frame_pointer_needed ) { emit_insn ( gen_blockage ( ) ) ; emit_insn ( gen_movsi ( stack_pointer_rtx , hard_frame_pointer_rtx ) ) ; } save_restore_insns ( <NUM_LIT> ) ; if ( current_function_calls_eh_return ) { rtx eh_ofs = EH_RETURN_STACKADJ_RTX ; emit_insn ( gen_addsi3 ( eh_ofs , eh_ofs , tsize_rtx ) ) ; tsize_rtx = eh_ofs ;


<s> } } else { regno = GP_ARG_LAST + <NUM_LIT> ; break ; } } next_arg_reg = FUNCTION_ARG ( args_so_far , VOIDmode , void_type_node , <NUM_LIT> ) ; if ( next_arg_reg != <NUM_LIT> && GET_CODE ( next_arg_reg ) == PARALLEL ) { rtvec adjust = XVEC ( next_arg_reg , <NUM_LIT> ) ; int num = GET_NUM_ELEM ( adjust ) ; for ( i = <NUM_LIT> ; i < num ; i ++ ) { rtx insn , pattern ; pattern = RTVEC_ELT ( adjust , i ) ; if ( GET_CODE ( pattern ) != SET || GET_CODE ( SET_SRC ( pattern ) ) != ASHIFT ) abort_with_insn ( pattern , <STR_LIT> ) ; PUT_CODE ( SET_SRC ( pattern ) , ASHIFTRT ) ; insn = emit_insn ( pattern ) ; REG_NOTES ( insn ) = gen_rtx_EXPR_LIST ( REG_MAYBE_DEAD , NULL_RTX , REG_NOTES ( insn ) ) ; } } tsize = compute_frame_size ( get_frame_size ( ) ) ; if ( store_args_on_stack && ( ( TYPE_ARG_TYPES ( fntype ) != <NUM_LIT> && ( TREE_VALUE ( tree_last ( TYPE_ARG_TYPES ( fntype ) ) ) != void_type_node ) ) || last_arg_is_vararg_marker ) ) { int offset = ( regno - GP_ARG_FIRST ) * UNITS_PER_WORD ; rtx ptr = stack_pointer_rtx ; for ( ; regno <= GP_ARG_LAST ; regno ++ ) { if ( offset != <NUM_LIT> ) ptr = gen_rtx_PLUS ( Pmode , stack_pointer_rtx , GEN_INT ( offset ) ) ;

emit_move_insn ( gen_rtx_MEM ( gpr_mode , ptr ) , gen_rtx_REG ( gpr_mode , regno ) ) ;


<s> next_arg_reg = FUNCTION_ARG ( args_so_far , VOIDmode , void_type_node , <NUM_LIT> ) ; if ( next_arg_reg != <NUM_LIT> && GET_CODE ( next_arg_reg ) == PARALLEL ) { rtvec adjust = XVEC ( next_arg_reg , <NUM_LIT> ) ; int num = GET_NUM_ELEM ( adjust ) ; for ( i = <NUM_LIT> ; i < num ; i ++ ) { rtx insn , pattern ; pattern = RTVEC_ELT ( adjust , i ) ; if ( GET_CODE ( pattern ) != SET || GET_CODE ( SET_SRC ( pattern ) ) != ASHIFT ) abort_with_insn ( pattern , <STR_LIT> ) ; PUT_CODE ( SET_SRC ( pattern ) , ASHIFTRT ) ; insn = emit_insn ( pattern ) ; REG_NOTES ( insn ) = gen_rtx_EXPR_LIST ( REG_MAYBE_DEAD , NULL_RTX , REG_NOTES ( insn ) ) ; } } tsize = compute_frame_size ( get_frame_size ( ) ) ; if ( store_args_on_stack && ( ( TYPE_ARG_TYPES ( fntype ) != <NUM_LIT> && ( TREE_VALUE ( tree_last ( TYPE_ARG_TYPES ( fntype ) ) ) != void_type_node ) ) || last_arg_is_vararg_marker ) ) { int offset = ( regno - GP_ARG_FIRST ) * UNITS_PER_WORD ; rtx ptr = stack_pointer_rtx ; for ( ; regno <= GP_ARG_LAST ; regno ++ ) { if ( offset != <NUM_LIT> ) ptr = gen_rtx_PLUS ( Pmode , stack_pointer_rtx , GEN_INT ( offset ) ) ; emit_move_insn ( gen_rtx_MEM ( gpr_mode , ptr ) , gen_rtx_REG ( gpr_mode , regno ) ) ; offset += GET_MODE_SIZE ( gpr_mode ) ; } } if ( tsize > <NUM_LIT> ) { rtx tsize_rtx = GEN_INT ( tsize ) ; rtx adjustment_rtx , insn , dwarf_pattern ; if ( tsize > <NUM_LIT> ) { adjustment_rtx = gen_rtx_REG ( Pmode , IQ2000_TEMP1_REGNUM ) ; emit_move_insn ( adjustment_rtx , tsize_rtx ) ; } else adjustment_rtx = tsize_rtx ; insn = emit_insn ( gen_subsi3 ( stack_pointer_rtx , stack_pointer_rtx , adjustment_rtx ) ) ; dwarf_pattern = gen_rtx_SET ( Pmode , stack_pointer_rtx , plus_constant ( stack_pointer_rtx , - tsize ) ) ; iq2000_annotate_frame_insn ( insn , dwarf_pattern ) ; save_restore_insns ( <NUM_LIT> ) ; if ( frame_pointer_needed ) { rtx insn = <NUM_LIT> ; insn = emit_insn ( gen_movsi ( hard_frame_pointer_rtx , stack_pointer_rtx ) ) ; if ( insn ) RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ;


<s> dslots_load_total += num_nops ; if ( TARGET_DEBUG_C_MODE || type == DELAY_NONE || operands == <NUM_LIT> || cur_insn == <NUM_LIT> || next_insn == <NUM_LIT> || GET_CODE ( next_insn ) == CODE_LABEL || ( set_reg = operands [ <NUM_LIT> ] ) == <NUM_LIT> ) { dslots_number_nops = <NUM_LIT> ; iq2000_load_reg = <NUM_LIT> ; iq2000_load_reg2 = <NUM_LIT> ; iq2000_load_reg3 = <NUM_LIT> ; iq2000_load_reg4 = <NUM_LIT> ; return ret ; } set_reg = operands [ <NUM_LIT> ] ; if ( set_reg == <NUM_LIT> ) return ret ; while ( GET_CODE ( set_reg ) == SUBREG ) set_reg = SUBREG_REG ( set_reg ) ; mode = GET_MODE ( set_reg ) ; dslots_number_nops = num_nops ; iq2000_load_reg = set_reg ; if ( GET_MODE_SIZE ( mode ) > ( unsigned ) ( UNITS_PER_WORD ) ) iq2000_load_reg2 = gen_rtx_REG ( SImode , REGNO ( set_reg ) + <NUM_LIT> ) ; else iq2000_load_reg2 = <NUM_LIT> ; return ret ;


<s> mode = promote_mode ( valtype , mode , & unsignedp , <NUM_LIT> ) ; return gen_rtx_REG ( mode , reg ) ;


<s> int unsignedp = TYPE_UNSIGNED ( valtype ) ; mode = promote_mode ( valtype , mode , & unsignedp , <NUM_LIT> ) ; return gen_rtx_REG ( mode , reg ) ;


<s> return ( strcmp ( arg , <STR_LIT> ) == <NUM_LIT> || strcmp ( arg , <STR_LIT> ) == <NUM_LIT> || strcmp ( arg , <STR_LIT> ) == <NUM_LIT> ) ;


<s> compute_frame_size ( get_frame_size ( ) ) ; if ( ( from ) == FRAME_POINTER_REGNUM ) ( offset ) = <NUM_LIT> ; else if ( ( from ) == ARG_POINTER_REGNUM ) ( offset ) = ( cfun -> machine -> total_size ) ; else if ( ( from ) == RETURN_ADDRESS_POINTER_REGNUM ) { if ( leaf_function_p ( ) ) ( offset ) = <NUM_LIT> ; else ( offset ) = cfun -> machine -> gp_sp_offset + ( ( UNITS_PER_WORD - ( POINTER_SIZE / BITS_PER_UNIT ) ) * ( BYTES_BIG_ENDIAN != <NUM_LIT> ) ) ; }


<s> if ( leaf_function_p ( ) ) ( offset ) = <NUM_LIT> ;

else ( offset ) = cfun -> machine -> gp_sp_offset + ( ( UNITS_PER_WORD - ( POINTER_SIZE / BITS_PER_UNIT ) ) * ( BYTES_BIG_ENDIAN != <NUM_LIT> ) ) ;


<s> struct machine_function * f ; f = ggc_alloc_cleared ( sizeof ( struct machine_function ) ) ; return f ;


<s> GO_PRINTF2 ( <STR_LIT> , strict ? <STR_LIT> : <STR_LIT> ) ; GO_DEBUG_RTX ( xinsn ) ; } if ( CONSTANT_ADDRESS_P ( xinsn ) && ! ( iq2000_check_split ( xinsn , mode ) ) && ! ( GET_CODE ( xinsn ) == CONST_INT && ! SMALL_INT ( xinsn ) ) ) return <NUM_LIT> ; while ( GET_CODE ( xinsn ) == SUBREG ) xinsn = SUBREG_REG ( xinsn ) ; if ( GET_CODE ( xinsn ) == REG && iq2000_reg_mode_ok_for_base_p ( xinsn , mode , strict ) ) return <NUM_LIT> ; if ( GET_CODE ( xinsn ) == LO_SUM ) { rtx xlow0 = XEXP ( xinsn , <NUM_LIT> ) ; rtx xlow1 = XEXP ( xinsn , <NUM_LIT> ) ; while ( GET_CODE ( xlow0 ) == SUBREG ) xlow0 = SUBREG_REG ( xlow0 ) ; if ( GET_CODE ( xlow0 ) == REG && iq2000_reg_mode_ok_for_base_p ( xlow0 , mode , strict ) && iq2000_check_split ( xlow1 , mode ) ) return <NUM_LIT> ; } if ( GET_CODE ( xinsn ) == PLUS ) { rtx xplus0 = XEXP ( xinsn , <NUM_LIT> ) ; rtx xplus1 = XEXP ( xinsn , <NUM_LIT> ) ; enum rtx_code code0 ; enum rtx_code code1 ; while ( GET_CODE ( xplus0 ) == SUBREG ) xplus0 = SUBREG_REG ( xplus0 ) ; code0 = GET_CODE ( xplus0 ) ;

while ( GET_CODE ( xplus1 ) == SUBREG ) xplus1 = SUBREG_REG ( xplus1 ) ;


<s> if ( SMALL_INT_UNSIGNED ( op1 ) ) ret = <STR_LIT> ; else if ( SMALL_INT ( op1 ) ) ret = <STR_LIT> ; else ret = <STR_LIT> ; } } else if ( code1 == CONST_DOUBLE && mode == SFmode ) { if ( op1 == CONST0_RTX ( SFmode ) ) { if ( GP_REG_P ( regno0 ) ) ret = <STR_LIT> ; } else { delay = DELAY_LOAD ; ret = <STR_LIT> ; } } else if ( code1 == LABEL_REF ) { if ( TARGET_STATS ) iq2000_count_memory_refs ( op1 , <NUM_LIT> ) ; ret = <STR_LIT> ; } else if ( code1 == SYMBOL_REF || code1 == CONST ) { if ( TARGET_STATS ) iq2000_count_memory_refs ( op1 , <NUM_LIT> ) ; ret = <STR_LIT> ; } else if ( code1 == PLUS ) { rtx add_op0 = XEXP ( op1 , <NUM_LIT> ) ; rtx add_op1 = XEXP ( op1 , <NUM_LIT> ) ; if ( GET_CODE ( XEXP ( op1 , <NUM_LIT> ) ) == REG && GET_CODE ( XEXP ( op1 , <NUM_LIT> ) ) == CONST_INT ) add_op0 = XEXP ( op1 , <NUM_LIT> ) , add_op1 = XEXP ( op1 , <NUM_LIT> ) ; operands [ <NUM_LIT> ] = add_op0 ; operands [ <NUM_LIT> ] = add_op1 ; ret = <STR_LIT> ; } else if ( code1 == HIGH ) { operands [ <NUM_LIT> ] = XEXP ( op1 , <NUM_LIT> ) ; ret = <STR_LIT> ; } } else if ( code0 == MEM ) { if ( TARGET_STATS ) iq2000_count_memory_refs ( op0 , <NUM_LIT> ) ; if ( code1 == REG ) { int regno1 = REGNO ( op1 ) + subreg_offset1 ; if ( GP_REG_P ( regno1 ) ) { switch ( mode ) { case SFmode : ret = <STR_LIT> ; break ; case SImode : ret = <STR_LIT> ; break ; case HImode : ret = <STR_LIT> ; break ; case QImode : ret = <STR_LIT> ; break ; default : break ; } } } else if ( code1 == CONST_INT && INTVAL ( op1 ) == <NUM_LIT> ) { switch ( mode ) { case SFmode : ret = <STR_LIT> ; break ; case SImode : ret = <STR_LIT> ; break ; case HImode : ret = <STR_LIT> ; break ; case QImode : ret = <STR_LIT> ; break ; default : break ; } } else if ( code1 == CONST_DOUBLE && op1 == CONST0_RTX ( mode ) ) { switch ( mode ) { case SFmode : ret = <STR_LIT> ; break ;


<s> case <NUM_LIT> : { const char * target = ( ( iq2000_branch_likely || length == <NUM_LIT> ) ? <STR_LIT> : <STR_LIT> ) ; char * c ; c = strchr ( buffer , '\0' ) ; if ( float_p ) sprintf ( c , <STR_LIT> , inverted_p ? comp : inverted_comp , target ) ; else sprintf ( c , <STR_LIT> , inverted_p ? comp : inverted_comp , need_z_p ? <STR_LIT> : <STR_LIT> , op1 , op2 , target ) ; strcat ( c , <STR_LIT> ) ; if ( length == <NUM_LIT> ) strcat ( buffer , <STR_LIT> ) ; return buffer ; } default : gcc_unreachable ( ) ;


<s> int size ; if ( cum && targetm . calls . must_pass_in_stack ( mode , type ) ) { CUMULATIVE_ARGS temp ; temp = * cum ; if ( FUNCTION_ARG ( temp , mode , type , named ) != <NUM_LIT> ) return <NUM_LIT> ;


<s> static bool iq2000_pass_by_reference ( CUMULATIVE_ARGS * cum , enum machine_mode mode , tree type , bool named ATTRIBUTE_UNUSED ) { int size ; if ( cum && targetm . calls . must_pass_in_stack ( mode , type ) ) { CUMULATIVE_ARGS temp ;


<s> return ( strict ? REGNO_MODE_OK_FOR_BASE_P ( REGNO ( reg ) , mode ) : GP_REG_OR_PSEUDO_NONSTRICT_P ( REGNO ( reg ) , mode ) ) ;


<s> int iq2000_reg_mode_ok_for_base_p ( rtx reg , enum machine_mode mode ATTRIBUTE_UNUSED , int strict ) { return ( strict ? REGNO_MODE_OK_FOR_BASE_P ( REGNO ( reg ) , mode ) : GP_REG_OR_PSEUDO_NONSTRICT_P ( REGNO ( reg ) , mode ) ) ;


<s> case AND : case IOR : case XOR : case NOT : * total = COSTS_N_INSNS ( mode == DImode ? <NUM_LIT> : <NUM_LIT> ) ; break ; case ASHIFT : case ASHIFTRT : case LSHIFTRT : if ( mode == DImode ) * total = COSTS_N_INSNS ( ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) ? <NUM_LIT> : <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case ABS : if ( mode == SFmode || mode == DFmode ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case PLUS : case MINUS : if ( mode == SFmode || mode == DFmode ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( mode == DImode ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case NEG : * total = ( mode == DImode ) ? <NUM_LIT> : <NUM_LIT> ; break ; case MULT : if ( mode == SFmode ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( mode == DFmode ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; break ;


<s> mergeable_constant_section ( mode , align , <NUM_LIT> ) ;


if ( ( TREE_CODE ( decl ) == VAR_DECL && TREE_READONLY ( decl ) && ! TREE_SIDE_EFFECTS ( decl ) && DECL_INITIAL ( decl ) && ( DECL_INITIAL ( decl ) == error_mark_node || TREE_CONSTANT ( DECL_INITIAL ( decl ) ) ) ) || TREE_CODE ( decl ) != VAR_DECL ) readonly_data_section ( ) ;


<s> static void iq2000_setup_incoming_varargs ( CUMULATIVE_ARGS * cum , enum machine_mode mode ATTRIBUTE_UNUSED , tree type ATTRIBUTE_UNUSED , int * pretend_size , int no_rtl ) { unsigned int iq2000_off = ! cum -> last_arg_fp ; unsigned int iq2000_fp_off = cum -> last_arg_fp ; if ( ( cum -> arg_words < MAX_ARGS_IN_REGISTERS - iq2000_off ) ) { int iq2000_save_gp_regs = MAX_ARGS_IN_REGISTERS - cum -> arg_words - iq2000_off ; int iq2000_save_fp_regs = ( MAX_ARGS_IN_REGISTERS - cum -> fp_arg_words - iq2000_fp_off ) ; if ( iq2000_save_gp_regs < <NUM_LIT> ) iq2000_save_gp_regs = <NUM_LIT> ; if ( iq2000_save_fp_regs < <NUM_LIT> ) iq2000_save_fp_regs = <NUM_LIT> ; * pretend_size = ( ( iq2000_save_gp_regs * UNITS_PER_WORD ) + ( iq2000_save_fp_regs * UNITS_PER_FPREG ) ) ; if ( ! ( no_rtl ) ) { if ( cum -> arg_words < MAX_ARGS_IN_REGISTERS - iq2000_off ) { rtx ptr , mem ; ptr = plus_constant ( virtual_incoming_args_rtx , - ( iq2000_save_gp_regs * UNITS_PER_WORD ) ) ;


<s> target_flags &= ~ MASK_GPOPT ; iq2000_isa = IQ2000_ISA_DEFAULT ; iq2000_print_operand_punct [ '?' ] = <NUM_LIT> ; iq2000_print_operand_punct [ '#' ] = <NUM_LIT> ; iq2000_print_operand_punct [ '&' ] = <NUM_LIT> ; iq2000_print_operand_punct [ '!' ] = <NUM_LIT> ; iq2000_print_operand_punct [ '*' ] = <NUM_LIT> ; iq2000_print_operand_punct [ '@' ] = <NUM_LIT> ; iq2000_print_operand_punct [ '.' ] = <NUM_LIT> ; iq2000_print_operand_punct [ '(' ] = <NUM_LIT> ; iq2000_print_operand_punct [ ')' ] = <NUM_LIT> ; iq2000_print_operand_punct [ '[' ] = <NUM_LIT> ; iq2000_print_operand_punct [ ']' ] = <NUM_LIT> ; iq2000_print_operand_punct [ '<' ] = <NUM_LIT> ; iq2000_print_operand_punct [ '>' ] = <NUM_LIT> ; iq2000_print_operand_punct [ '{' ] = <NUM_LIT> ; iq2000_print_operand_punct [ '}' ] = <NUM_LIT> ; iq2000_print_operand_punct [ '^' ] = <NUM_LIT> ; iq2000_print_operand_punct [ '$' ] = <NUM_LIT> ; iq2000_print_operand_punct [ '+' ] = <NUM_LIT> ; iq2000_print_operand_punct [ '~' ] = <NUM_LIT> ; gpr_mode = SImode ;


<s> target_flags &= ~ MASK_GPOPT ; iq2000_isa = IQ2000_ISA_DEFAULT ; iq2000_print_operand_punct [ '?' ] = <NUM_LIT> ; iq2000_print_operand_punct [ '#' ] = <NUM_LIT> ; iq2000_print_operand_punct [ '&' ] = <NUM_LIT> ; iq2000_print_operand_punct [ '!' ] = <NUM_LIT> ; iq2000_print_operand_punct [ '*' ] = <NUM_LIT> ; iq2000_print_operand_punct [ '@' ] = <NUM_LIT> ; iq2000_print_operand_punct [ '.' ] = <NUM_LIT> ; iq2000_print_operand_punct [ '(' ] = <NUM_LIT> ; iq2000_print_operand_punct [ ')' ] = <NUM_LIT> ;

iq2000_print_operand_punct [ '[' ] = <NUM_LIT> ;


<s> else if ( CONSTANT_P ( arg0 ) && CONSTANT_P ( arg1 ) ) { output_addr_const ( file , addr ) ; break ; } else abort_with_insn ( addr , <STR_LIT> ) ; if ( ! CONSTANT_P ( offset ) ) abort_with_insn ( addr , <STR_LIT> ) ; if ( REGNO ( reg ) == ARG_POINTER_REGNUM ) abort_with_insn ( addr , <STR_LIT> ) ; output_addr_const ( file , offset ) ; fprintf ( file , <STR_LIT> , reg_names [ REGNO ( reg ) ] ) ; } break ; case LABEL_REF : case SYMBOL_REF : case CONST_INT : case CONST : output_addr_const ( file , addr ) ;

if ( GET_CODE ( addr ) == CONST_INT ) fprintf ( file , <STR_LIT> , reg_names [ <NUM_LIT> ] ) ;


<s> if ( UNARY_P ( x ) ) return symbolic_expression_p ( XEXP ( x , <NUM_LIT> ) ) ;

if ( ARITHMETIC_P ( x ) ) return ( symbolic_expression_p ( XEXP ( x , <NUM_LIT> ) ) || symbolic_expression_p ( XEXP ( x , <NUM_LIT> ) ) ) ;


<s> if ( ARITHMETIC_P ( x ) ) return ( symbolic_expression_p ( XEXP ( x , <NUM_LIT> ) ) || symbolic_expression_p ( XEXP ( x , <NUM_LIT> ) ) ) ;


<s> mode [ <NUM_LIT> ] = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; for ( i = <NUM_LIT> ; i < argcount ; i ++ ) { arg [ i ] = CALL_EXPR_ARG ( exp , i ) ; op [ i ] = expand_normal ( arg [ i ] ) ; mode [ i ] = insn_data [ icode ] . operand [ i ] . mode ; if ( code [ i ] == CONST_INT && GET_CODE ( op [ i ] ) != CONST_INT ) error ( <STR_LIT> , i + <NUM_LIT> ) ; if ( code [ i ] == REG && ! ( * insn_data [ icode ] . operand [ i ] . predicate ) ( op [ i ] , mode [ i ] ) ) op [ i ] = copy_to_mode_reg ( mode [ i ] , op [ i ] ) ; } if ( insn_data [ icode ] . operand [ <NUM_LIT> ] . constraint [ <NUM_LIT> ] == '=' ) { if ( target == <NUM_LIT> || GET_MODE ( target ) != mode [ <NUM_LIT> ] || ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( target , mode [ <NUM_LIT> ] ) ) target = gen_reg_rtx ( mode [ <NUM_LIT> ] ) ; } else target = <NUM_LIT> ; switch ( argcount ) { case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target ) ; case <NUM_LIT> : if ( target ) pat = GEN_FCN ( icode ) ( target , op [ <NUM_LIT> ] ) ; else pat = GEN_FCN ( icode ) ( op [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> : if ( target ) pat = GEN_FCN ( icode ) ( target , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; else pat = GEN_FCN ( icode ) ( op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> : if ( target ) pat = GEN_FCN ( icode ) ( target , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; else pat = GEN_FCN ( icode ) ( op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> : if ( target ) pat = GEN_FCN ( icode ) ( target , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; else pat = GEN_FCN ( icode ) ( op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; break ; default : gcc_unreachable ( ) ; } if ( ! pat ) return <NUM_LIT> ;


<s> int invert ; rtx label1 , label2 ; invert = <NUM_LIT> ; reg = gen_int_relational ( test_code , NULL_RTX , cmp0 , cmp1 , & invert ) ; if ( reg ) { cmp0 = reg ; cmp1 = const0_rtx ; test_code = NE ; } else if ( GET_CODE ( cmp1 ) == CONST_INT && INTVAL ( cmp1 ) != <NUM_LIT> ) cmp1 = force_reg ( mode , cmp1 ) ; label1 = gen_rtx_LABEL_REF ( VOIDmode , operands [ <NUM_LIT> ] ) ; label2 = pc_rtx ; if ( invert ) { label2 = label1 ; label1 = pc_rtx ; }

emit_jump_insn ( gen_rtx_SET ( VOIDmode , pc_rtx , gen_rtx_IF_THEN_ELSE ( VOIDmode , gen_rtx_fmt_ee ( test_code , VOIDmode , cmp0 , cmp1 ) , label1 , label2 ) ) ) ;


<s> if ( reg ) { cmp0 = reg ; cmp1 = const0_rtx ; test_code = NE ; } else if ( GET_CODE ( cmp1 ) == CONST_INT && INTVAL ( cmp1 ) != <NUM_LIT> ) cmp1 = force_reg ( mode , cmp1 ) ; label1 = gen_rtx_LABEL_REF ( VOIDmode , operands [ <NUM_LIT> ] ) ; label2 = pc_rtx ;


<s> static int iq2000_arg_partial_bytes ( cumulative_args_t cum_v , machine_mode mode , tree type ATTRIBUTE_UNUSED , bool named ATTRIBUTE_UNUSED ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; if ( mode == DImode && cum -> arg_words == MAX_ARGS_IN_REGISTERS - <NUM_LIT> ) { if ( TARGET_DEBUG_D_MODE ) fprintf ( stderr , <STR_LIT> , UNITS_PER_WORD ) ;


<s> return expand_one_builtin ( CODE_FOR_rx , target , exp , code , <NUM_LIT> ) ; case IQ2000_BUILTIN_SRRD : return expand_one_builtin ( CODE_FOR_srrd , target , exp , code , <NUM_LIT> ) ; case IQ2000_BUILTIN_SRWR : return expand_one_builtin ( CODE_FOR_srwr , target , exp , code , <NUM_LIT> ) ; case IQ2000_BUILTIN_WB : return expand_one_builtin ( CODE_FOR_wb , target , exp , code , <NUM_LIT> ) ; case IQ2000_BUILTIN_WX : return expand_one_builtin ( CODE_FOR_wx , target , exp , code , <NUM_LIT> ) ; case IQ2000_BUILTIN_LUC32L : return expand_one_builtin ( CODE_FOR_luc32l , target , exp , code , <NUM_LIT> ) ; case IQ2000_BUILTIN_LUC64 : return expand_one_builtin ( CODE_FOR_luc64 , target , exp , code , <NUM_LIT> ) ; case IQ2000_BUILTIN_LUC64L : return expand_one_builtin ( CODE_FOR_luc64l , target , exp , code , <NUM_LIT> ) ; case IQ2000_BUILTIN_LUK : return expand_one_builtin ( CODE_FOR_luk , target , exp , code , <NUM_LIT> ) ; case IQ2000_BUILTIN_LULCK : return expand_one_builtin ( CODE_FOR_lulck , target , exp , code , <NUM_LIT> ) ; case IQ2000_BUILTIN_LUM32 : return expand_one_builtin ( CODE_FOR_lum32 , target , exp , code , <NUM_LIT> ) ; case IQ2000_BUILTIN_LUM32L : return expand_one_builtin ( CODE_FOR_lum32l , target , exp , code , <NUM_LIT> ) ; case IQ2000_BUILTIN_LUM64 : return expand_one_builtin ( CODE_FOR_lum64 , target , exp , code , <NUM_LIT> ) ; case IQ2000_BUILTIN_LUM64L : return expand_one_builtin ( CODE_FOR_lum64l , target , exp , code , <NUM_LIT> ) ; case IQ2000_BUILTIN_LURL : return expand_one_builtin ( CODE_FOR_lurl , target , exp , code , <NUM_LIT> ) ; case IQ2000_BUILTIN_MRGB : code [ <NUM_LIT> ] = CONST_INT ; return expand_one_builtin ( CODE_FOR_mrgb , target , exp , code , <NUM_LIT> ) ; case IQ2000_BUILTIN_SRRDL : return expand_one_builtin ( CODE_FOR_srrdl , target , exp , code , <NUM_LIT> ) ; case IQ2000_BUILTIN_SRULCK : return expand_one_builtin ( CODE_FOR_srulck , target , exp , code , <NUM_LIT> ) ;


<s> int regno ; HOST_WIDE_INT tsize ; int last_arg_is_vararg_marker = <NUM_LIT> ; tree fndecl = current_function_decl ; tree fntype = TREE_TYPE ( fndecl ) ; tree fnargs = DECL_ARGUMENTS ( fndecl ) ; rtx next_arg_reg ; int i ; tree next_arg ; tree cur_arg ; CUMULATIVE_ARGS args_so_far_v ; cumulative_args_t args_so_far ; int store_args_on_stack = ( iq2000_can_use_return_insn ( ) ) ; if ( aggregate_value_p ( DECL_RESULT ( fndecl ) , fndecl ) && ! cfun -> returns_pcc_struct && targetm . calls . struct_value_rtx ( TREE_TYPE ( fndecl ) , <NUM_LIT> ) == <NUM_LIT> ) { tree type = build_pointer_type ( fntype ) ; tree function_result_decl = build_decl ( BUILTINS_LOCATION , PARM_DECL , NULL_TREE , type ) ; DECL_ARG_TYPE ( function_result_decl ) = type ; DECL_CHAIN ( function_result_decl ) = fnargs ; fnargs = function_result_decl ; } INIT_CUMULATIVE_ARGS ( args_so_far_v , fntype , NULL_RTX , <NUM_LIT> , <NUM_LIT> ) ; args_so_far = pack_cumulative_args ( & args_so_far_v ) ; regno = GP_ARG_FIRST ; for ( cur_arg = fnargs ; cur_arg != <NUM_LIT> ; cur_arg = next_arg ) { tree passed_type = DECL_ARG_TYPE ( cur_arg ) ; machine_mode passed_mode = TYPE_MODE ( passed_type ) ; rtx entry_parm ; if ( TREE_ADDRESSABLE ( passed_type ) ) { passed_type = build_pointer_type ( passed_type ) ; passed_mode = Pmode ; } entry_parm = iq2000_function_arg ( args_so_far , passed_mode , passed_type , true ) ; iq2000_function_arg_advance ( args_so_far , passed_mode , passed_type , true ) ; next_arg = DECL_CHAIN ( cur_arg ) ; if ( entry_parm && store_args_on_stack ) { if ( next_arg == <NUM_LIT> && DECL_NAME ( cur_arg ) && ( ( <NUM_LIT> == strcmp ( IDENTIFIER_POINTER ( DECL_NAME ( cur_arg ) ) , <STR_LIT> ) ) || ( <NUM_LIT> == strcmp ( IDENTIFIER_POINTER ( DECL_NAME ( cur_arg ) ) , <STR_LIT> ) ) ) ) { last_arg_is_vararg_marker = <NUM_LIT> ; break ; } else { int words ; gcc_assert ( GET_CODE ( entry_parm ) == REG ) ; if ( GET_MODE ( entry_parm ) == BLKmode ) words = ( int_size_in_bytes ( passed_type ) + <NUM_LIT> ) / <NUM_LIT> ; else words = ( GET_MODE_SIZE ( GET_MODE ( entry_parm ) ) + <NUM_LIT> ) / <NUM_LIT> ; regno = REGNO ( entry_parm ) + words - <NUM_LIT> ; } } else { regno = GP_ARG_LAST + <NUM_LIT> ; break ; } } next_arg_reg = iq2000_function_arg ( args_so_far , VOIDmode , void_type_node , true ) ; if ( next_arg_reg != <NUM_LIT> && GET_CODE ( next_arg_reg ) == PARALLEL ) { rtvec adjust = XVEC ( next_arg_reg , <NUM_LIT> ) ; int num = GET_NUM_ELEM ( adjust ) ; for ( i = <NUM_LIT> ; i < num ; i ++ ) { rtx pattern ; pattern = RTVEC_ELT ( adjust , i ) ; if ( GET_CODE ( pattern ) != SET || GET_CODE ( SET_SRC ( pattern ) ) != ASHIFT ) abort_with_insn ( pattern , <STR_LIT> ) ; PUT_CODE ( SET_SRC ( pattern ) , ASHIFTRT ) ;


<s> } } next_arg_reg = iq2000_function_arg ( args_so_far , VOIDmode , void_type_node , true ) ; if ( next_arg_reg != <NUM_LIT> && GET_CODE ( next_arg_reg ) == PARALLEL ) { rtvec adjust = XVEC ( next_arg_reg , <NUM_LIT> ) ; int num = GET_NUM_ELEM ( adjust ) ; for ( i = <NUM_LIT> ; i < num ; i ++ ) { rtx pattern ; pattern = RTVEC_ELT ( adjust , i ) ; if ( GET_CODE ( pattern ) != SET || GET_CODE ( SET_SRC ( pattern ) ) != ASHIFT ) abort_with_insn ( pattern , <STR_LIT> ) ; PUT_CODE ( SET_SRC ( pattern ) , ASHIFTRT ) ; emit_insn ( pattern ) ; } } tsize = compute_frame_size ( get_frame_size ( ) ) ; if ( store_args_on_stack && ( stdarg_p ( fntype ) || last_arg_is_vararg_marker ) ) { int offset = ( regno - GP_ARG_FIRST ) * UNITS_PER_WORD ; rtx ptr = stack_pointer_rtx ; for ( ; regno <= GP_ARG_LAST ; regno ++ ) { if ( offset != <NUM_LIT> ) ptr = gen_rtx_PLUS ( Pmode , stack_pointer_rtx , GEN_INT ( offset ) ) ; emit_move_insn ( gen_rtx_MEM ( gpr_mode , ptr ) , gen_rtx_REG ( gpr_mode , regno ) ) ; offset += GET_MODE_SIZE ( gpr_mode ) ; } } if ( tsize > <NUM_LIT> ) { rtx tsize_rtx = GEN_INT ( tsize ) ; rtx adjustment_rtx , dwarf_pattern ; rtx_insn * insn ; if ( tsize > <NUM_LIT> ) { adjustment_rtx = gen_rtx_REG ( Pmode , IQ2000_TEMP1_REGNUM ) ; emit_move_insn ( adjustment_rtx , tsize_rtx ) ; } else adjustment_rtx = tsize_rtx ; insn = emit_insn ( gen_subsi3 ( stack_pointer_rtx , stack_pointer_rtx , adjustment_rtx ) ) ; dwarf_pattern = gen_rtx_SET ( Pmode , stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - tsize ) ) ; iq2000_annotate_frame_insn ( insn , dwarf_pattern ) ; save_restore_insns ( <NUM_LIT> ) ; if ( frame_pointer_needed ) { rtx_insn * insn = <NUM_LIT> ; insn = emit_insn ( gen_movsi ( hard_frame_pointer_rtx , stack_pointer_rtx ) ) ;

if ( insn ) RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ;


<s> break ; case VOIDmode : case QImode : case HImode : case SImode : regbase = GP_ARG_FIRST ; break ; case DImode : cum -> arg_words += ( cum -> arg_words & <NUM_LIT> ) ; regbase = GP_ARG_FIRST ; break ; case TImode : cum -> arg_words += ( cum -> arg_words & <NUM_LIT> ) ; regbase = GP_ARG_FIRST ; break ; } if ( * arg_words >= ( unsigned ) MAX_ARGS_IN_REGISTERS ) { if ( TARGET_DEBUG_D_MODE ) fprintf ( stderr , <STR_LIT> , struct_p ? <STR_LIT> : <STR_LIT> ) ; ret = <NUM_LIT> ; } else { gcc_assert ( regbase != - <NUM_LIT> ) ; if ( ! type || TREE_CODE ( type ) != RECORD_TYPE || ! named || ! TYPE_SIZE_UNIT ( type ) || ! tree_fits_uhwi_p ( TYPE_SIZE_UNIT ( type ) ) ) ret = gen_rtx_REG ( mode , regbase + * arg_words + bias ) ; else { tree field ; for ( field = TYPE_FIELDS ( type ) ; field ; field = DECL_CHAIN ( field ) ) if ( TREE_CODE ( field ) == FIELD_DECL && TREE_CODE ( TREE_TYPE ( field ) ) == REAL_TYPE && TYPE_PRECISION ( TREE_TYPE ( field ) ) == BITS_PER_WORD && tree_fits_shwi_p ( bit_position ( field ) ) && int_bit_position ( field ) % BITS_PER_WORD == <NUM_LIT> ) break ; if ( ! field || mode == DFmode ) ret = gen_rtx_REG ( mode , regbase + * arg_words + bias ) ; else { unsigned int chunks ; HOST_WIDE_INT bitpos ; unsigned int regno ; unsigned int i ; chunks = tree_to_uhwi ( TYPE_SIZE_UNIT ( type ) ) / UNITS_PER_WORD ; if ( chunks + * arg_words + bias > ( unsigned ) MAX_ARGS_IN_REGISTERS ) chunks = MAX_ARGS_IN_REGISTERS - * arg_words - bias ; ret = gen_rtx_PARALLEL ( mode , rtvec_alloc ( chunks ) ) ; bitpos = <NUM_LIT> ; regno = regbase + * arg_words + bias ; field = TYPE_FIELDS ( type ) ;

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


<s> fprintf ( stderr , <STR_LIT> , cum -> gp_reg_found , cum -> arg_number , cum -> arg_words , GET_MODE_NAME ( mode ) ) ; fprintf ( stderr , <STR_LIT> , ( const void * ) type ) ; fprintf ( stderr , <STR_LIT> , named ) ; } cum -> arg_number ++ ; switch ( mode ) { case VOIDmode : break ; default : gcc_assert ( GET_MODE_CLASS ( mode ) == MODE_COMPLEX_INT || GET_MODE_CLASS ( mode ) == MODE_COMPLEX_FLOAT ) ; cum -> gp_reg_found = <NUM_LIT> ; cum -> arg_words += ( ( GET_MODE_SIZE ( mode ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ) ; break ; case BLKmode : cum -> gp_reg_found = <NUM_LIT> ; cum -> arg_words += ( ( int_size_in_bytes ( type ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ) ;


<s> if ( TARGET_DEBUG_B_MODE ) { GO_PRINTF ( <STR_LIT> ) ; GO_DEBUG_RTX ( xinsn ) ; } if ( iq2000_check_split ( xinsn , mode ) ) { return gen_rtx_LO_SUM ( Pmode , copy_to_mode_reg ( Pmode , gen_rtx_HIGH ( Pmode , xinsn ) ) , xinsn ) ; } if ( GET_CODE ( xinsn ) == PLUS ) { rtx xplus0 = XEXP ( xinsn , <NUM_LIT> ) ; rtx xplus1 = XEXP ( xinsn , <NUM_LIT> ) ; enum rtx_code code0 = GET_CODE ( xplus0 ) ; enum rtx_code code1 = GET_CODE ( xplus1 ) ; if ( code0 != REG && code1 == REG ) { xplus0 = XEXP ( xinsn , <NUM_LIT> ) ; xplus1 = XEXP ( xinsn , <NUM_LIT> ) ; code0 = GET_CODE ( xplus0 ) ; code1 = GET_CODE ( xplus1 ) ; } if ( code0 == REG && REG_MODE_OK_FOR_BASE_P ( xplus0 , mode ) && code1 == CONST_INT && ! SMALL_INT ( xplus1 ) ) { rtx int_reg = gen_reg_rtx ( Pmode ) ; rtx ptr_reg = gen_reg_rtx ( Pmode ) ; emit_move_insn ( int_reg , GEN_INT ( INTVAL ( xplus1 ) & ~ <NUM_LIT> ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , ptr_reg , gen_rtx_PLUS ( Pmode , xplus0 , int_reg ) ) ) ;

return plus_constant ( Pmode , ptr_reg , INTVAL ( xplus1 ) & <NUM_LIT> ) ;


<s> rtx add_op1 = XEXP ( op1 , <NUM_LIT> ) ; if ( GET_CODE ( XEXP ( op1 , <NUM_LIT> ) ) == REG && GET_CODE ( XEXP ( op1 , <NUM_LIT> ) ) == CONST_INT ) add_op0 = XEXP ( op1 , <NUM_LIT> ) , add_op1 = XEXP ( op1 , <NUM_LIT> ) ; operands [ <NUM_LIT> ] = add_op0 ; operands [ <NUM_LIT> ] = add_op1 ; ret = <STR_LIT> ; } else if ( code1 == HIGH ) { operands [ <NUM_LIT> ] = XEXP ( op1 , <NUM_LIT> ) ; ret = <STR_LIT> ; } } else if ( code0 == MEM ) { if ( TARGET_STATS ) iq2000_count_memory_refs ( op0 , <NUM_LIT> ) ; if ( code1 == REG ) { int regno1 = REGNO ( op1 ) + subreg_offset1 ; if ( GP_REG_P ( regno1 ) ) { switch ( mode ) { case SFmode : ret = <STR_LIT> ; break ; case SImode : ret = <STR_LIT> ; break ; case HImode : ret = <STR_LIT> ; break ; case QImode : ret = <STR_LIT> ; break ; default : break ; } } } else if ( code1 == CONST_INT && INTVAL ( op1 ) == <NUM_LIT> ) { switch ( mode ) { case SFmode : ret = <STR_LIT> ; break ; case SImode : ret = <STR_LIT> ; break ; case HImode : ret = <STR_LIT> ; break ; case QImode : ret = <STR_LIT> ; break ; default : break ; } } else if ( code1 == CONST_DOUBLE && op1 == CONST0_RTX ( mode ) ) { switch ( mode ) { case SFmode : ret = <STR_LIT> ; break ; case SImode : ret = <STR_LIT> ; break ; case HImode : ret = <STR_LIT> ; break ; case QImode : ret = <STR_LIT> ; break ; default : break ; } } }


<s> int size ; if ( cum && targetm . calls . must_pass_in_stack ( mode , type ) ) { CUMULATIVE_ARGS temp ; temp = * cum ; if ( iq2000_function_arg ( pack_cumulative_args ( & temp ) , mode , type , named ) != <NUM_LIT> ) return <NUM_LIT> ; } if ( type == NULL_TREE || mode == DImode || mode == DFmode ) return <NUM_LIT> ; size = int_size_in_bytes ( type ) ; return size == - <NUM_LIT> || size > UNITS_PER_WORD ;


<s> temp = * cum ; if ( iq2000_function_arg ( pack_cumulative_args ( & temp ) , mode , type , named ) != <NUM_LIT> ) return <NUM_LIT> ; } if ( type == NULL_TREE || mode == DImode || mode == DFmode ) return <NUM_LIT> ;


<s> case GTU : fputs ( <STR_LIT> , file ) ; break ; case GEU : fputs ( <STR_LIT> , file ) ; break ; case LTU : fputs ( <STR_LIT> , file ) ; break ; case LEU : fputs ( <STR_LIT> , file ) ; break ; default : abort_with_insn ( op , <STR_LIT> ) ; } else if ( letter == 'F' ) switch ( code ) { case EQ : fputs ( <STR_LIT> , file ) ; break ; case NE : fputs ( <STR_LIT> , file ) ; break ; default : abort_with_insn ( op , <STR_LIT> ) ; } else if ( letter == 'W' ) switch ( code ) { case EQ : fputs ( <STR_LIT> , file ) ; break ; case NE : fputs ( <STR_LIT> , file ) ; break ; default : abort_with_insn ( op , <STR_LIT> ) ; } else if ( letter == 'A' ) fputs ( code == LABEL_REF ? <STR_LIT> : <STR_LIT> , file ) ; else if ( letter == 'P' ) { if ( code == LABEL_REF ) output_addr_const ( file , op ) ; else if ( code != PC ) output_operand_lossage ( <STR_LIT> ) ; } else if ( letter == 'p' ) { int value ; if ( code != CONST_INT || ( value = exact_log2 ( INTVAL ( op ) ) ) < <NUM_LIT> ) output_operand_lossage ( <STR_LIT> ) ; else fprintf ( file , <STR_LIT> , value ) ; } else if ( letter == 'Z' ) { gcc_unreachable ( ) ; } else if ( code == REG || code == SUBREG ) { int regnum ; if ( code == REG ) regnum = REGNO ( op ) ; else regnum = true_regnum ( op ) ; if ( ( letter == 'M' && ! WORDS_BIG_ENDIAN ) || ( letter == 'L' && WORDS_BIG_ENDIAN ) || letter == 'D' ) regnum ++ ; fprintf ( file , <STR_LIT> , reg_names [ regnum ] ) ; } else if ( code == MEM ) { if ( letter == 'D' ) output_address ( plus_constant ( Pmode , XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) ; else output_address ( XEXP ( op , <NUM_LIT> ) ) ; } else if ( code == CONST_DOUBLE && GET_MODE_CLASS ( GET_MODE ( op ) ) == MODE_FLOAT ) {


<s> offset = arg1 ; if ( GET_CODE ( offset ) == REG ) abort_with_insn ( addr , <STR_LIT> ) ; } else if ( GET_CODE ( arg1 ) == REG ) reg = arg1 , offset = arg0 ; else if ( CONSTANT_P ( arg0 ) && CONSTANT_P ( arg1 ) ) { output_addr_const ( file , addr ) ; break ; } else abort_with_insn ( addr , <STR_LIT> ) ; if ( ! CONSTANT_P ( offset ) ) abort_with_insn ( addr , <STR_LIT> ) ; if ( REGNO ( reg ) == ARG_POINTER_REGNUM ) abort_with_insn ( addr , <STR_LIT> ) ; output_addr_const ( file , offset ) ; fprintf ( file , <STR_LIT> , reg_names [ REGNO ( reg ) ] ) ; } break ; case LABEL_REF : case SYMBOL_REF : case CONST_INT : case CONST : output_addr_const ( file , addr ) ; if ( GET_CODE ( addr ) == CONST_INT ) fprintf ( file , <STR_LIT> , reg_names [ <NUM_LIT> ] ) ; break ; default : abort_with_insn ( addr , <STR_LIT> ) ;


<s> break ; case ABS : if ( mode == SFmode || mode == DFmode ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case PLUS : case MINUS : if ( mode == SFmode || mode == DFmode ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( mode == DImode ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case NEG : * total = ( mode == DImode ) ? <NUM_LIT> : <NUM_LIT> ; break ; case MULT : if ( mode == SFmode ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( mode == DFmode ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case DIV : case MOD : if ( mode == SFmode ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( mode == DFmode ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case UDIV : case UMOD : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case SIGN_EXTEND : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case ZERO_EXTEND : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case CONST_INT : * total = <NUM_LIT> ; break ; case LABEL_REF : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case CONST : { rtx offset = const0_rtx ; rtx symref = eliminate_constant_term ( XEXP ( x , <NUM_LIT> ) , & offset ) ; if ( GET_CODE ( symref ) == LABEL_REF ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( GET_CODE ( symref ) != SYMBOL_REF ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( INTVAL ( offset ) < - <NUM_LIT> || INTVAL ( offset ) > <NUM_LIT> ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( SYMBOL_REF_FLAG ( symref ) ? <NUM_LIT> : <NUM_LIT> ) ; break ; } case SYMBOL_REF : * total = COSTS_N_INSNS ( SYMBOL_REF_FLAG ( x ) ? <NUM_LIT> : <NUM_LIT> ) ; break ; case CONST_DOUBLE : { rtx high , low ; split_double ( x , & high , & low ) ; * total = COSTS_N_INSNS ( ( high == CONST0_RTX ( GET_MODE ( high ) ) || low == CONST0_RTX ( GET_MODE ( low ) ) ) ? <NUM_LIT> : <NUM_LIT> ) ; break ; }


<s> if ( ( TREE_CODE ( decl ) == VAR_DECL && TREE_READONLY ( decl ) && ! TREE_SIDE_EFFECTS ( decl ) && DECL_INITIAL ( decl ) && ( DECL_INITIAL ( decl ) == error_mark_node || TREE_CONSTANT ( DECL_INITIAL ( decl ) ) ) ) || TREE_CODE ( decl ) != VAR_DECL ) return readonly_data_section ; else return data_section ; } else { if ( ( TREE_CODE ( decl ) == VAR_DECL && TREE_READONLY ( decl ) && ! TREE_SIDE_EFFECTS ( decl ) && DECL_INITIAL ( decl ) && ( DECL_INITIAL ( decl ) == error_mark_node || TREE_CONSTANT ( DECL_INITIAL ( decl ) ) ) ) || TREE_CODE ( decl ) != VAR_DECL ) return readonly_data_section ; else return data_section ; }


<s> else { regno = GP_ARG_LAST + <NUM_LIT> ; break ; } } next_arg_reg = iq2000_function_arg ( args_so_far , VOIDmode , void_type_node , true ) ; if ( next_arg_reg != <NUM_LIT> && GET_CODE ( next_arg_reg ) == PARALLEL ) { rtvec adjust = XVEC ( next_arg_reg , <NUM_LIT> ) ; int num = GET_NUM_ELEM ( adjust ) ; for ( i = <NUM_LIT> ; i < num ; i ++ ) { rtx pattern ; pattern = RTVEC_ELT ( adjust , i ) ; if ( GET_CODE ( pattern ) != SET || GET_CODE ( SET_SRC ( pattern ) ) != ASHIFT ) abort_with_insn ( pattern , <STR_LIT> ) ; PUT_CODE ( SET_SRC ( pattern ) , ASHIFTRT ) ; emit_insn ( pattern ) ; } } tsize = compute_frame_size ( get_frame_size ( ) ) ; if ( store_args_on_stack && ( stdarg_p ( fntype ) || last_arg_is_vararg_marker ) ) { int offset = ( regno - GP_ARG_FIRST ) * UNITS_PER_WORD ; rtx ptr = stack_pointer_rtx ; for ( ; regno <= GP_ARG_LAST ; regno ++ ) { if ( offset != <NUM_LIT> ) ptr = gen_rtx_PLUS ( Pmode , stack_pointer_rtx , GEN_INT ( offset ) ) ; emit_move_insn ( gen_rtx_MEM ( gpr_mode , ptr ) , gen_rtx_REG ( gpr_mode , regno ) ) ; offset += GET_MODE_SIZE ( gpr_mode ) ; } } if ( tsize > <NUM_LIT> ) { rtx tsize_rtx = GEN_INT ( tsize ) ; rtx adjustment_rtx , dwarf_pattern ; rtx_insn * insn ; if ( tsize > <NUM_LIT> ) { adjustment_rtx = gen_rtx_REG ( Pmode , IQ2000_TEMP1_REGNUM ) ; emit_move_insn ( adjustment_rtx , tsize_rtx ) ; } else adjustment_rtx = tsize_rtx ; insn = emit_insn ( gen_subsi3 ( stack_pointer_rtx , stack_pointer_rtx , adjustment_rtx ) ) ; dwarf_pattern = gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - tsize ) ) ; iq2000_annotate_frame_insn ( insn , dwarf_pattern ) ;


<s> case UDIV : case UMOD : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case SIGN_EXTEND : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case ZERO_EXTEND : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case CONST_INT : * total = <NUM_LIT> ; break ; case LABEL_REF : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case CONST : { rtx offset = const0_rtx ; rtx symref = eliminate_constant_term ( XEXP ( x , <NUM_LIT> ) , & offset ) ; if ( GET_CODE ( symref ) == LABEL_REF ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( GET_CODE ( symref ) != SYMBOL_REF ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( INTVAL ( offset ) < - <NUM_LIT> || INTVAL ( offset ) > <NUM_LIT> ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( SYMBOL_REF_FLAG ( symref ) ? <NUM_LIT> : <NUM_LIT> ) ; break ; } case SYMBOL_REF : * total = COSTS_N_INSNS ( SYMBOL_REF_FLAG ( x ) ? <NUM_LIT> : <NUM_LIT> ) ; break ; case CONST_DOUBLE : { rtx high , low ; split_double ( x , & high , & low ) ; * total = COSTS_N_INSNS ( ( high == CONST0_RTX ( GET_MODE ( high ) ) || low == CONST0_RTX ( GET_MODE ( low ) ) ) ? <NUM_LIT> : <NUM_LIT> ) ; break ; } default : return false ; }


<s> iq2000_load_reg4 = <NUM_LIT> ; } if ( ( JUMP_P ( insn ) || CALL_P ( insn ) || ( GET_CODE ( PATTERN ( insn ) ) == RETURN ) ) && NEXT_INSN ( PREV_INSN ( insn ) ) == insn ) { rtx_insn * tmp = insn ; while ( NEXT_INSN ( tmp ) && NOTE_P ( NEXT_INSN ( tmp ) ) && NOTE_KIND ( NEXT_INSN ( tmp ) ) == NOTE_INSN_CALL_ARG_LOCATION ) tmp = NEXT_INSN ( tmp ) ; rtx_insn * nop_insn = emit_insn_after ( gen_nop ( ) , tmp ) ; INSN_ADDRESSES_NEW ( nop_insn , - <NUM_LIT> ) ; } if ( TARGET_STATS && ( JUMP_P ( insn ) || CALL_P ( insn ) ) ) dslots_jump_total ++ ;


<s> args_so_far = pack_cumulative_args ( & args_so_far_v ) ; regno = GP_ARG_FIRST ; for ( cur_arg = fnargs ; cur_arg != <NUM_LIT> ; cur_arg = next_arg ) { tree passed_type = DECL_ARG_TYPE ( cur_arg ) ; machine_mode passed_mode = TYPE_MODE ( passed_type ) ; rtx entry_parm ; if ( TREE_ADDRESSABLE ( passed_type ) ) { passed_type = build_pointer_type ( passed_type ) ; passed_mode = Pmode ; } entry_parm = iq2000_function_arg ( args_so_far , passed_mode , passed_type , true ) ; iq2000_function_arg_advance ( args_so_far , passed_mode , passed_type , true ) ; next_arg = DECL_CHAIN ( cur_arg ) ; if ( entry_parm && store_args_on_stack ) { if ( next_arg == <NUM_LIT> && DECL_NAME ( cur_arg ) && ( strcmp ( IDENTIFIER_POINTER ( DECL_NAME ( cur_arg ) ) , <STR_LIT> ) == <NUM_LIT> || strcmp ( IDENTIFIER_POINTER ( DECL_NAME ( cur_arg ) ) , <STR_LIT> ) == <NUM_LIT> ) ) { last_arg_is_vararg_marker = <NUM_LIT> ; break ; } else { int words ; gcc_assert ( GET_CODE ( entry_parm ) == REG ) ; if ( GET_MODE ( entry_parm ) == BLKmode ) words = ( int_size_in_bytes ( passed_type ) + <NUM_LIT> ) / <NUM_LIT> ; else words = ( GET_MODE_SIZE ( GET_MODE ( entry_parm ) ) + <NUM_LIT> ) / <NUM_LIT> ; regno = REGNO ( entry_parm ) + words - <NUM_LIT> ; } } else { regno = GP_ARG_LAST + <NUM_LIT> ; break ; } } next_arg_reg = iq2000_function_arg ( args_so_far , VOIDmode , void_type_node , true ) ; if ( next_arg_reg != <NUM_LIT> && GET_CODE ( next_arg_reg ) == PARALLEL ) { rtvec adjust = XVEC ( next_arg_reg , <NUM_LIT> ) ; int num = GET_NUM_ELEM ( adjust ) ; for ( i = <NUM_LIT> ; i < num ; i ++ ) { rtx pattern ; pattern = RTVEC_ELT ( adjust , i ) ; if ( GET_CODE ( pattern ) != SET || GET_CODE ( SET_SRC ( pattern ) ) != ASHIFT ) abort_with_insn ( pattern , <STR_LIT> ) ; PUT_CODE ( SET_SRC ( pattern ) , ASHIFTRT ) ; emit_insn ( pattern ) ; } } tsize = compute_frame_size ( get_frame_size ( ) ) ; if ( store_args_on_stack && ( stdarg_p ( fntype ) || last_arg_is_vararg_marker ) ) { int offset = ( regno - GP_ARG_FIRST ) * UNITS_PER_WORD ; rtx ptr = stack_pointer_rtx ; for ( ; regno <= GP_ARG_LAST ; regno ++ ) { if ( offset != <NUM_LIT> ) ptr = gen_rtx_PLUS ( Pmode , stack_pointer_rtx , GEN_INT ( offset ) ) ; emit_move_insn ( gen_rtx_MEM ( gpr_mode , ptr ) , gen_rtx_REG ( gpr_mode , regno ) ) ; offset += GET_MODE_SIZE ( gpr_mode ) ; } } if ( tsize > <NUM_LIT> ) { rtx tsize_rtx = GEN_INT ( tsize ) ; rtx adjustment_rtx , dwarf_pattern ; rtx_insn * insn ;


<s> unsigned int regno ; unsigned int i ; chunks = tree_to_uhwi ( TYPE_SIZE_UNIT ( type ) ) / UNITS_PER_WORD ; if ( chunks + * arg_words + bias > ( unsigned ) MAX_ARGS_IN_REGISTERS ) chunks = MAX_ARGS_IN_REGISTERS - * arg_words - bias ; ret = gen_rtx_PARALLEL ( mode , rtvec_alloc ( chunks ) ) ; bitpos = <NUM_LIT> ; regno = regbase + * arg_words + bias ; field = TYPE_FIELDS ( type ) ; for ( i = <NUM_LIT> ; i < chunks ; i ++ ) { rtx reg ; for ( ; field ; field = DECL_CHAIN ( field ) ) if ( TREE_CODE ( field ) == FIELD_DECL && int_bit_position ( field ) >= bitpos ) break ; if ( field && int_bit_position ( field ) == bitpos && TREE_CODE ( TREE_TYPE ( field ) ) == REAL_TYPE && TYPE_PRECISION ( TREE_TYPE ( field ) ) == BITS_PER_WORD ) reg = gen_rtx_REG ( DFmode , regno ++ ) ; else reg = gen_rtx_REG ( word_mode , regno ) ; XVECEXP ( ret , <NUM_LIT> , i ) = gen_rtx_EXPR_LIST ( VOIDmode , reg , GEN_INT ( bitpos / BITS_PER_UNIT ) ) ; bitpos += <NUM_LIT> ; regno ++ ; } } } if ( TARGET_DEBUG_D_MODE ) fprintf ( stderr , <STR_LIT> , reg_names [ regbase + * arg_words + bias ] , struct_p ? <STR_LIT> : <STR_LIT> ) ; }


<s> int regbase = - <NUM_LIT> ; int bias = <NUM_LIT> ; unsigned int * arg_words = & cum -> arg_words ; int struct_p = ( type != <NUM_LIT> && ( TREE_CODE ( type ) == RECORD_TYPE || TREE_CODE ( type ) == UNION_TYPE || TREE_CODE ( type ) == QUAL_UNION_TYPE ) ) ; if ( TARGET_DEBUG_D_MODE ) { fprintf ( stderr , <STR_LIT> , cum -> gp_reg_found , cum -> arg_number , cum -> arg_words , GET_MODE_NAME ( mode ) ) ; fprintf ( stderr , <STR_LIT> , ( const void * ) type ) ; fprintf ( stderr , <STR_LIT> , named ) ; } cum -> last_arg_fp = <NUM_LIT> ; switch ( mode ) { case E_SFmode : regbase = GP_ARG_FIRST ; break ; case E_DFmode : cum -> arg_words += cum -> arg_words & <NUM_LIT> ; regbase = GP_ARG_FIRST ; break ; default : gcc_assert ( GET_MODE_CLASS ( mode ) == MODE_COMPLEX_INT || GET_MODE_CLASS ( mode ) == MODE_COMPLEX_FLOAT ) ; case E_BLKmode : if ( type != NULL_TREE && TYPE_ALIGN ( type ) > ( unsigned ) BITS_PER_WORD ) cum -> arg_words += ( cum -> arg_words & <NUM_LIT> ) ; regbase = GP_ARG_FIRST ; break ; case E_VOIDmode : case E_QImode : case E_HImode : case E_SImode : regbase = GP_ARG_FIRST ; break ; case E_DImode : cum -> arg_words += ( cum -> arg_words & <NUM_LIT> ) ; regbase = GP_ARG_FIRST ; break ; case E_TImode : cum -> arg_words += ( cum -> arg_words & <NUM_LIT> ) ; regbase = GP_ARG_FIRST ; break ; } if ( * arg_words >= ( unsigned ) MAX_ARGS_IN_REGISTERS ) { if ( TARGET_DEBUG_D_MODE ) fprintf ( stderr , <STR_LIT> , struct_p ? <STR_LIT> : <STR_LIT> ) ; ret = <NUM_LIT> ; } else { gcc_assert ( regbase != - <NUM_LIT> ) ; if ( ! type || TREE_CODE ( type ) != RECORD_TYPE || ! named || ! TYPE_SIZE_UNIT ( type ) || ! tree_fits_uhwi_p ( TYPE_SIZE_UNIT ( type ) ) ) ret = gen_rtx_REG ( mode , regbase + * arg_words + bias ) ; else { tree field ; for ( field = TYPE_FIELDS ( type ) ; field ; field = DECL_CHAIN ( field ) ) if ( TREE_CODE ( field ) == FIELD_DECL && TREE_CODE ( TREE_TYPE ( field ) ) == REAL_TYPE && TYPE_PRECISION ( TREE_TYPE ( field ) ) == BITS_PER_WORD && tree_fits_shwi_p ( bit_position ( field ) ) && int_bit_position ( field ) % BITS_PER_WORD == <NUM_LIT> ) break ;

if ( ! field || mode == DFmode ) ret = gen_rtx_REG ( mode , regbase + * arg_words + bias ) ;


<s> cum -> arg_words += ( ( int_size_in_bytes ( type ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ) ; break ; case E_SFmode : cum -> arg_words ++ ; if ( ! cum -> gp_reg_found && cum -> arg_number <= <NUM_LIT> ) cum -> fp_code += <NUM_LIT> << ( ( cum -> arg_number - <NUM_LIT> ) * <NUM_LIT> ) ; break ; case E_DFmode : cum -> arg_words += <NUM_LIT> ; if ( ! cum -> gp_reg_found && cum -> arg_number <= <NUM_LIT> ) cum -> fp_code += <NUM_LIT> << ( ( cum -> arg_number - <NUM_LIT> ) * <NUM_LIT> ) ; break ;


<s> static void abort_with_insn ( rtx insn , const char * reason ) { error ( reason ) ; debug_rtx ( insn ) ;


<s> debug_rtx ( insn ) ; fancy_abort ( __FILE__ , __LINE__ , __FUNCTION__ ) ;


<s> HOST_WIDE_INT gp_reg_size ; HOST_WIDE_INT fp_reg_size ; long mask ; gp_reg_size = <NUM_LIT> ; fp_reg_size = <NUM_LIT> ; mask = <NUM_LIT> ; extra_size = IQ2000_STACK_ALIGN ( ( <NUM_LIT> ) ) ; var_size = IQ2000_STACK_ALIGN ( size ) ; args_size = IQ2000_STACK_ALIGN ( crtl -> outgoing_args_size ) ; if ( args_size == <NUM_LIT> && cfun -> calls_alloca ) args_size = <NUM_LIT> * UNITS_PER_WORD ; total_size = var_size + args_size + extra_size ; for ( regno = GP_REG_FIRST ; regno <= GP_REG_LAST ; regno ++ ) { if ( MUST_SAVE_REGISTER ( regno ) ) { gp_reg_size += GET_MODE_SIZE ( gpr_mode ) ; mask |= <NUM_LIT> << ( regno - GP_REG_FIRST ) ; } } if ( crtl -> calls_eh_return ) { unsigned int i ; for ( i = <NUM_LIT> ; ; ++ i ) { regno = EH_RETURN_DATA_REGNO ( i ) ; if ( regno == ( int ) INVALID_REGNUM ) break ; gp_reg_size += GET_MODE_SIZE ( gpr_mode ) ; mask |= <NUM_LIT> << ( regno - GP_REG_FIRST ) ; } } gp_reg_rounded = IQ2000_STACK_ALIGN ( gp_reg_size ) ; total_size += gp_reg_rounded + IQ2000_STACK_ALIGN ( fp_reg_size ) ; if ( total_size == extra_size && ! profile_flag ) total_size = extra_size = <NUM_LIT> ; total_size += IQ2000_STACK_ALIGN ( crtl -> args . pretend_args_size ) ; cfun -> machine -> total_size = total_size ; cfun -> machine -> var_size = var_size ; cfun -> machine -> args_size = args_size ; cfun -> machine -> extra_size = extra_size ; cfun -> machine -> gp_reg_size = gp_reg_size ; cfun -> machine -> fp_reg_size = fp_reg_size ; cfun -> machine -> mask = mask ; cfun -> machine -> initialized = reload_completed ; cfun -> machine -> num_gp = gp_reg_size / UNITS_PER_WORD ; if ( mask ) { unsigned long offset ; offset = ( args_size + extra_size + var_size + gp_reg_size - GET_MODE_SIZE ( gpr_mode ) ) ; cfun -> machine -> gp_sp_offset = offset ;

cfun -> machine -> gp_save_offset = offset - total_size ;


<s> rtx op [ <NUM_LIT> ] ; machine_mode mode [ <NUM_LIT> ] ; int i ; mode [ <NUM_LIT> ] = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; for ( i = <NUM_LIT> ; i < argcount ; i ++ ) { arg [ i ] = CALL_EXPR_ARG ( exp , i ) ; op [ i ] = expand_normal ( arg [ i ] ) ; mode [ i ] = insn_data [ icode ] . operand [ i ] . mode ; if ( code [ i ] == CONST_INT && GET_CODE ( op [ i ] ) != CONST_INT ) error ( <STR_LIT> , i + <NUM_LIT> ) ; if ( code [ i ] == REG && ! ( * insn_data [ icode ] . operand [ i ] . predicate ) ( op [ i ] , mode [ i ] ) ) op [ i ] = copy_to_mode_reg ( mode [ i ] , op [ i ] ) ; } if ( insn_data [ icode ] . operand [ <NUM_LIT> ] . constraint [ <NUM_LIT> ] == '=' ) { if ( target == <NUM_LIT> || GET_MODE ( target ) != mode [ <NUM_LIT> ] || ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( target , mode [ <NUM_LIT> ] ) ) target = gen_reg_rtx ( mode [ <NUM_LIT> ] ) ; } else target = <NUM_LIT> ; switch ( argcount ) { case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target ) ; break ; case <NUM_LIT> : if ( target ) pat = GEN_FCN ( icode ) ( target , op [ <NUM_LIT> ] ) ; else pat = GEN_FCN ( icode ) ( op [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> : if ( target ) pat = GEN_FCN ( icode ) ( target , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; else pat = GEN_FCN ( icode ) ( op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> : if ( target ) pat = GEN_FCN ( icode ) ( target , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; else pat = GEN_FCN ( icode ) ( op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> :

if ( target ) pat = GEN_FCN ( icode ) ( target , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ;


<s> if ( dslots_number_nops > <NUM_LIT> ) { rtx pattern = PATTERN ( insn ) ; int length = get_attr_length ( insn ) ; if ( length == <NUM_LIT> || ( iq2000_load_reg != <NUM_LIT> && reg_mentioned_p ( iq2000_load_reg , pattern ) ) || ( iq2000_load_reg2 != <NUM_LIT> && reg_mentioned_p ( iq2000_load_reg2 , pattern ) ) || ( iq2000_load_reg3 != <NUM_LIT> && reg_mentioned_p ( iq2000_load_reg3 , pattern ) ) || ( iq2000_load_reg4 != <NUM_LIT> && reg_mentioned_p ( iq2000_load_reg4 , pattern ) ) ) fputs ( <STR_LIT> , asm_out_file ) ; else dslots_load_filled ++ ; while ( -- dslots_number_nops > <NUM_LIT> ) fputs ( <STR_LIT> , asm_out_file ) ; iq2000_load_reg = <NUM_LIT> ; iq2000_load_reg2 = <NUM_LIT> ; iq2000_load_reg3 = <NUM_LIT> ; iq2000_load_reg4 = <NUM_LIT> ; }

if ( ( JUMP_P ( insn ) || CALL_P ( insn ) || ( GET_CODE ( PATTERN ( insn ) ) == RETURN ) ) && NEXT_INSN ( PREV_INSN ( insn ) ) == insn ) {


<s> cmp0 = reg ; cmp1 = const0_rtx ; test_code = NE ; } else if ( GET_CODE ( cmp1 ) == CONST_INT && INTVAL ( cmp1 ) != <NUM_LIT> ) cmp1 = force_reg ( mode , cmp1 ) ; label1 = gen_rtx_LABEL_REF ( VOIDmode , operands [ <NUM_LIT> ] ) ;


<s> if ( TARGET_DEBUG_D_MODE ) { fprintf ( stderr , <STR_LIT> , ( long ) fntype ) ; if ( ! fntype ) fputc ( '\n' , stderr ) ; else { tree ret_type = TREE_TYPE ( fntype ) ;

fprintf ( stderr , <STR_LIT> , get_tree_code_name ( TREE_CODE ( fntype ) ) , get_tree_code_name ( TREE_CODE ( ret_type ) ) ) ;


<s> static CUMULATIVE_ARGS zero_cum ; tree param ; tree next_param ; if ( TARGET_DEBUG_D_MODE ) { fprintf ( stderr , <STR_LIT> , ( long ) fntype ) ; if ( ! fntype ) fputc ( '\n' , stderr ) ; else { tree ret_type = TREE_TYPE ( fntype ) ; fprintf ( stderr , <STR_LIT> , get_tree_code_name ( TREE_CODE ( fntype ) ) , get_tree_code_name ( TREE_CODE ( ret_type ) ) ) ; } }


<s> return SYMBOL_REF_FLAG ( addr ) ? <NUM_LIT> : <NUM_LIT> ; case PLUS : { rtx plus0 = XEXP ( addr , <NUM_LIT> ) ; rtx plus1 = XEXP ( addr , <NUM_LIT> ) ; if ( GET_CODE ( plus0 ) != REG && GET_CODE ( plus1 ) == REG ) plus0 = XEXP ( addr , <NUM_LIT> ) , plus1 = XEXP ( addr , <NUM_LIT> ) ; if ( GET_CODE ( plus0 ) != REG ) break ; switch ( GET_CODE ( plus1 ) ) { case CONST_INT : return SMALL_INT ( plus1 ) ? <NUM_LIT> : <NUM_LIT> ; case CONST : case SYMBOL_REF : case LABEL_REF : case HIGH : case LO_SUM : return iq2000_address_cost ( plus1 , mode , as , speed ) + <NUM_LIT> ; default : break ; } }


<s> rtx reg = gen_rtx_REG ( Pmode , IQ2000_TEMP2_REGNUM ) ; rtx offset_rtx = GEN_INT ( offset ) ; emit_move_insn ( reg , offset_rtx ) ;

emit_insn ( gen_addsi3 ( reg , reg , stack_pointer_rtx ) ) ;


<s> emit_move_insn ( reg , offset_rtx ) ; emit_insn ( gen_addsi3 ( reg , reg , stack_pointer_rtx ) ) ;


<s> if ( simplejump_p ( insn ) || ( ( JUMP_P ( insn ) || CALL_P ( insn ) ) ) ) length += <NUM_LIT> ; return length ;


<s> RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ;

REG_NOTES ( insn ) = alloc_EXPR_LIST ( REG_FRAME_RELATED_EXPR , dwarf_pattern , REG_NOTES ( insn ) ) ;


<s> REG_NOTES ( insn ) = alloc_EXPR_LIST ( REG_FRAME_RELATED_EXPR , dwarf_pattern , REG_NOTES ( insn ) ) ;


<s> CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; if ( arg . mode == DImode && cum -> arg_words == MAX_ARGS_IN_REGISTERS - <NUM_LIT> ) { if ( TARGET_DEBUG_D_MODE ) fprintf ( stderr , <STR_LIT> , UNITS_PER_WORD ) ; return UNITS_PER_WORD ; } return <NUM_LIT> ;


<s> fprintf ( f , <STR_LIT> ) ; } fprintf ( f , <STR_LIT> ) ; fprintf ( f , <STR_LIT> ) ; fprintf ( f , <STR_LIT> ) ;


<s> if ( df_regs_ever_live_p ( <NUM_LIT> ) || profile_flag ) return <NUM_LIT> ;

if ( cfun -> machine -> initialized ) return cfun -> machine -> total_size == <NUM_LIT> ;


<s> if ( ! reload_completed ) return <NUM_LIT> ; if ( df_regs_ever_live_p ( <NUM_LIT> ) || profile_flag ) return <NUM_LIT> ; if ( cfun -> machine -> initialized ) return cfun -> machine -> total_size == <NUM_LIT> ; return compute_frame_size ( get_frame_size ( ) ) == <NUM_LIT> ;


<s> int iq2000_check_split ( rtx address , machine_mode mode ) { if ( GET_MODE_SIZE ( mode ) > ( unsigned ) UNITS_PER_WORD ) return <NUM_LIT> ;

if ( ( GET_CODE ( address ) == SYMBOL_REF ) || ( GET_CODE ( address ) == CONST && GET_CODE ( XEXP ( XEXP ( address , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF ) || GET_CODE ( address ) == LABEL_REF ) return <NUM_LIT> ;


<s> fprintf ( stderr , <STR_LIT> ) ; debug_rtx ( op ) ; } addr = ( GET_CODE ( op ) != MEM ) ? op : XEXP ( op , <NUM_LIT> ) ; do { looping = FALSE ; switch ( GET_CODE ( addr ) ) { case REG : case CONST_INT : case LO_SUM : break ; case PLUS : plus0 = XEXP ( addr , <NUM_LIT> ) ; plus1 = XEXP ( addr , <NUM_LIT> ) ; code0 = GET_CODE ( plus0 ) ; code1 = GET_CODE ( plus1 ) ; if ( code0 == REG ) { additional ++ ; addr = plus1 ; looping = <NUM_LIT> ; continue ; } if ( code0 == CONST_INT ) { addr = plus1 ; looping = <NUM_LIT> ; continue ; } if ( code1 == REG ) { additional ++ ; addr = plus0 ; looping = <NUM_LIT> ; continue ; } if ( code1 == CONST_INT ) { addr = plus0 ; looping = <NUM_LIT> ; continue ; }

if ( code0 == SYMBOL_REF || code0 == LABEL_REF || code0 == CONST ) {


<s> HOST_WIDE_INT iq2000_debugger_offset ( rtx addr , HOST_WIDE_INT offset ) { rtx offset2 = const0_rtx ; rtx reg = eliminate_constant_term ( addr , & offset2 ) ; if ( offset == <NUM_LIT> ) offset = INTVAL ( offset2 ) ; if ( reg == stack_pointer_rtx || reg == frame_pointer_rtx || reg == hard_frame_pointer_rtx ) { HOST_WIDE_INT frame_size = ( ! cfun -> machine -> initialized ) ? compute_frame_size ( get_frame_size ( ) ) : cfun -> machine -> total_size ;


<s> rtx offset2 = const0_rtx ; rtx reg = eliminate_constant_term ( addr , & offset2 ) ; if ( offset == <NUM_LIT> ) offset = INTVAL ( offset2 ) ; if ( reg == stack_pointer_rtx || reg == frame_pointer_rtx || reg == hard_frame_pointer_rtx ) {

HOST_WIDE_INT frame_size = ( ! cfun -> machine -> initialized ) ? compute_frame_size ( get_frame_size ( ) ) : cfun -> machine -> total_size ;


<s> static void iq2000_emit_frame_related_store ( rtx mem , rtx reg , HOST_WIDE_INT offset ) { rtx dwarf_address = plus_constant ( Pmode , stack_pointer_rtx , offset ) ;

rtx dwarf_mem = gen_rtx_MEM ( GET_MODE ( reg ) , dwarf_address ) ;


<s> emit_move_insn ( gen_rtx_MEM ( GET_MODE ( address ) , scratch ) , address ) ;


<s> void iq2000_expand_eh_return ( rtx address ) { HOST_WIDE_INT gp_offset = cfun -> machine -> gp_sp_offset ; rtx scratch ;

scratch = plus_constant ( Pmode , stack_pointer_rtx , gp_offset ) ;


<s> } save_restore_insns ( <NUM_LIT> ) ; if ( crtl -> calls_eh_return ) { rtx eh_ofs = EH_RETURN_STACKADJ_RTX ; emit_insn ( gen_addsi3 ( eh_ofs , eh_ofs , tsize_rtx ) ) ; tsize_rtx = eh_ofs ; } emit_insn ( gen_blockage ( ) ) ; if ( tsize != <NUM_LIT> || crtl -> calls_eh_return ) { emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , tsize_rtx ) ) ; } } if ( crtl -> calls_eh_return ) { emit_move_insn ( gen_rtx_REG ( Pmode , HARD_FRAME_POINTER_REGNUM ) , stack_pointer_rtx ) ; emit_use ( gen_rtx_REG ( Pmode , HARD_FRAME_POINTER_REGNUM ) ) ;

emit_jump_insn ( gen_eh_return_internal ( ) ) ;


<s> tree fndecl = current_function_decl ; tree fntype = TREE_TYPE ( fndecl ) ; tree fnargs = DECL_ARGUMENTS ( fndecl ) ; rtx next_arg_reg ; int i ; tree next_arg ; tree cur_arg ; CUMULATIVE_ARGS args_so_far_v ; cumulative_args_t args_so_far ; int store_args_on_stack = ( iq2000_can_use_return_insn ( ) ) ; if ( aggregate_value_p ( DECL_RESULT ( fndecl ) , fndecl ) && ! cfun -> returns_pcc_struct && targetm . calls . struct_value_rtx ( TREE_TYPE ( fndecl ) , <NUM_LIT> ) == <NUM_LIT> ) { tree type = build_pointer_type ( fntype ) ; tree function_result_decl = build_decl ( BUILTINS_LOCATION , PARM_DECL , NULL_TREE , type ) ; DECL_ARG_TYPE ( function_result_decl ) = type ; DECL_CHAIN ( function_result_decl ) = fnargs ; fnargs = function_result_decl ; } INIT_CUMULATIVE_ARGS ( args_so_far_v , fntype , NULL_RTX , <NUM_LIT> , <NUM_LIT> ) ; args_so_far = pack_cumulative_args ( & args_so_far_v ) ; regno = GP_ARG_FIRST ; for ( cur_arg = fnargs ; cur_arg != <NUM_LIT> ; cur_arg = next_arg ) { tree passed_type = DECL_ARG_TYPE ( cur_arg ) ; machine_mode passed_mode = TYPE_MODE ( passed_type ) ; rtx entry_parm ; if ( TREE_ADDRESSABLE ( passed_type ) ) { passed_type = build_pointer_type ( passed_type ) ; passed_mode = Pmode ; } function_arg_info arg ( passed_type , passed_mode , true ) ; entry_parm = iq2000_function_arg ( args_so_far , arg ) ; iq2000_function_arg_advance ( args_so_far , arg ) ; next_arg = DECL_CHAIN ( cur_arg ) ; if ( entry_parm && store_args_on_stack ) { if ( next_arg == <NUM_LIT> && DECL_NAME ( cur_arg ) && ( strcmp ( IDENTIFIER_POINTER ( DECL_NAME ( cur_arg ) ) , <STR_LIT> ) == <NUM_LIT> || strcmp ( IDENTIFIER_POINTER ( DECL_NAME ( cur_arg ) ) , <STR_LIT> ) == <NUM_LIT> ) ) { last_arg_is_vararg_marker = <NUM_LIT> ; break ; } else {


if ( GET_MODE_SIZE ( mode ) > ( unsigned ) ( UNITS_PER_WORD ) ) iq2000_load_reg2 = gen_rtx_REG ( SImode , REGNO ( set_reg ) + <NUM_LIT> ) ;


<s> regbase = GP_ARG_FIRST ; break ; case E_DFmode : cum -> arg_words += cum -> arg_words & <NUM_LIT> ; regbase = GP_ARG_FIRST ; break ; default : gcc_assert ( GET_MODE_CLASS ( mode ) == MODE_COMPLEX_INT || GET_MODE_CLASS ( mode ) == MODE_COMPLEX_FLOAT ) ; case E_BLKmode : if ( type != NULL_TREE && TYPE_ALIGN ( type ) > ( unsigned ) BITS_PER_WORD ) cum -> arg_words += ( cum -> arg_words & <NUM_LIT> ) ; regbase = GP_ARG_FIRST ; break ; case E_VOIDmode : case E_QImode : case E_HImode : case E_SImode : regbase = GP_ARG_FIRST ; break ; case E_DImode : cum -> arg_words += ( cum -> arg_words & <NUM_LIT> ) ; regbase = GP_ARG_FIRST ; break ; case E_TImode : cum -> arg_words += ( cum -> arg_words & <NUM_LIT> ) ; regbase = GP_ARG_FIRST ; break ; } if ( * arg_words >= ( unsigned ) MAX_ARGS_IN_REGISTERS ) { if ( TARGET_DEBUG_D_MODE ) fprintf ( stderr , <STR_LIT> , struct_p ? <STR_LIT> : <STR_LIT> ) ; ret = <NUM_LIT> ; } else { gcc_assert ( regbase != - <NUM_LIT> ) ; if ( ! type || TREE_CODE ( type ) != RECORD_TYPE || ! arg . named || ! TYPE_SIZE_UNIT ( type ) || ! tree_fits_uhwi_p ( TYPE_SIZE_UNIT ( type ) ) ) ret = gen_rtx_REG ( mode , regbase + * arg_words + bias ) ; else { tree field ; for ( field = TYPE_FIELDS ( type ) ; field ; field = DECL_CHAIN ( field ) ) if ( TREE_CODE ( field ) == FIELD_DECL && TREE_CODE ( TREE_TYPE ( field ) ) == REAL_TYPE && TYPE_PRECISION ( TREE_TYPE ( field ) ) == BITS_PER_WORD && tree_fits_shwi_p ( bit_position ( field ) ) && int_bit_position ( field ) % BITS_PER_WORD == <NUM_LIT> ) break ; if ( ! field || mode == DFmode ) ret = gen_rtx_REG ( mode , regbase + * arg_words + bias ) ; else { unsigned int chunks ;


<s> break ; case E_BLKmode : cum -> gp_reg_found = <NUM_LIT> ; cum -> arg_words += ( ( int_size_in_bytes ( arg . type ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ) ; break ; case E_SFmode : cum -> arg_words ++ ; if ( ! cum -> gp_reg_found && cum -> arg_number <= <NUM_LIT> ) cum -> fp_code += <NUM_LIT> << ( ( cum -> arg_number - <NUM_LIT> ) * <NUM_LIT> ) ; break ; case E_DFmode : cum -> arg_words += <NUM_LIT> ; if ( ! cum -> gp_reg_found && cum -> arg_number <= <NUM_LIT> ) cum -> fp_code += <NUM_LIT> << ( ( cum -> arg_number - <NUM_LIT> ) * <NUM_LIT> ) ; break ; case E_DImode : cum -> gp_reg_found = <NUM_LIT> ; cum -> arg_words += <NUM_LIT> ; break ;


<s> static unsigned int iq2000_function_arg_boundary ( machine_mode mode , const_tree type ) {

return ( type != NULL_TREE ? ( TYPE_ALIGN ( type ) <= PARM_BOUNDARY ? PARM_BOUNDARY : TYPE_ALIGN ( type ) ) : ( GET_MODE_ALIGNMENT ( mode ) <= PARM_BOUNDARY ? PARM_BOUNDARY : GET_MODE_ALIGNMENT ( mode ) ) ) ;


<s> static pad_direction iq2000_function_arg_padding ( machine_mode mode , const_tree type ) { return ( ! BYTES_BIG_ENDIAN ? PAD_UPWARD : ( ( mode == BLKmode ? ( type && TREE_CODE ( TYPE_SIZE ( type ) ) == INTEGER_CST && int_size_in_bytes ( type ) < ( PARM_BOUNDARY / BITS_PER_UNIT ) ) : ( GET_MODE_BITSIZE ( mode ) < PARM_BOUNDARY && GET_MODE_CLASS ( mode ) == MODE_INT ) ) ? PAD_DOWNWARD : PAD_UPWARD ) ) ;


<s> static rtx iq2000_function_value ( const_tree valtype , const_tree fn_decl_or_type , bool outgoing ATTRIBUTE_UNUSED ) { int reg = GP_RETURN ; machine_mode mode = TYPE_MODE ( valtype ) ;

int unsignedp = TYPE_UNSIGNED ( valtype ) ;


<s> bool iq2000_function_value_regno_p ( const unsigned int regno ) { return ( regno == GP_RETURN ) ;


<s> static bool iq2000_hard_regno_mode_ok ( unsigned int regno , machine_mode mode ) {

return ( REGNO_REG_CLASS ( regno ) == GR_REGS ? ( regno & <NUM_LIT> ) == <NUM_LIT> || GET_MODE_SIZE ( mode ) <= <NUM_LIT> : ( regno & <NUM_LIT> ) == <NUM_LIT> || GET_MODE_SIZE ( mode ) == <NUM_LIT> ) ;


<s> static bool iq2000_hard_regno_mode_ok ( unsigned int regno , machine_mode mode ) { return ( REGNO_REG_CLASS ( regno ) == GR_REGS ? ( regno & <NUM_LIT> ) == <NUM_LIT> || GET_MODE_SIZE ( mode ) <= <NUM_LIT> : ( regno & <NUM_LIT> ) == <NUM_LIT> || GET_MODE_SIZE ( mode ) == <NUM_LIT> ) ;


<s> else if ( ( from ) == ARG_POINTER_REGNUM ) ( offset ) = ( cfun -> machine -> total_size ) ; else if ( ( from ) == RETURN_ADDRESS_POINTER_REGNUM ) {

if ( leaf_function_p ( ) ) ( offset ) = <NUM_LIT> ;


<s> static struct machine_function * iq2000_init_machine_status ( void ) { return ggc_cleared_alloc < machine_function > ( ) ;


<s> if ( GET_CODE ( xinsn ) == PLUS ) { rtx xplus0 = XEXP ( xinsn , <NUM_LIT> ) ; rtx xplus1 = XEXP ( xinsn , <NUM_LIT> ) ; enum rtx_code code0 ; enum rtx_code code1 ; while ( GET_CODE ( xplus0 ) == SUBREG ) xplus0 = SUBREG_REG ( xplus0 ) ; code0 = GET_CODE ( xplus0 ) ; while ( GET_CODE ( xplus1 ) == SUBREG ) xplus1 = SUBREG_REG ( xplus1 ) ; code1 = GET_CODE ( xplus1 ) ; if ( code0 == REG && iq2000_reg_mode_ok_for_base_p ( xplus0 , mode , strict ) ) { if ( code1 == CONST_INT && SMALL_INT ( xplus1 ) && SMALL_INT_UNSIGNED ( xplus1 ) ) return <NUM_LIT> ; } } if ( TARGET_DEBUG_A_MODE ) GO_PRINTF ( <STR_LIT> ) ;


<s> rtx xplus0 = XEXP ( xinsn , <NUM_LIT> ) ; rtx xplus1 = XEXP ( xinsn , <NUM_LIT> ) ; enum rtx_code code0 = GET_CODE ( xplus0 ) ; enum rtx_code code1 = GET_CODE ( xplus1 ) ; if ( code0 != REG && code1 == REG ) { xplus0 = XEXP ( xinsn , <NUM_LIT> ) ; xplus1 = XEXP ( xinsn , <NUM_LIT> ) ; code0 = GET_CODE ( xplus0 ) ;


<s> if ( code0 == REG && REG_MODE_OK_FOR_BASE_P ( xplus0 , mode ) && code1 == CONST_INT && ! SMALL_INT ( xplus1 ) ) { rtx int_reg = gen_reg_rtx ( Pmode ) ; rtx ptr_reg = gen_reg_rtx ( Pmode ) ; emit_move_insn ( int_reg , GEN_INT ( INTVAL ( xplus1 ) & ~ <NUM_LIT> ) ) ; emit_insn ( gen_rtx_SET ( ptr_reg , gen_rtx_PLUS ( Pmode , xplus0 , int_reg ) ) ) ; return plus_constant ( Pmode , ptr_reg , INTVAL ( xplus1 ) & <NUM_LIT> ) ;


<s> return gen_rtx_REG ( ( ( GET_MODE_CLASS ( mode ) != MODE_INT || GET_MODE_SIZE ( mode ) >= <NUM_LIT> ) ? mode : SImode ) , GP_RETURN ) ;


<s> return ( ( GET_MODE_CLASS ( mode1 ) == MODE_FLOAT || GET_MODE_CLASS ( mode1 ) == MODE_COMPLEX_FLOAT ) == ( GET_MODE_CLASS ( mode2 ) == MODE_FLOAT || GET_MODE_CLASS ( mode2 ) == MODE_COMPLEX_FLOAT ) ) ;


<s> if ( op1 == CONST0_RTX ( SFmode ) ) { if ( GP_REG_P ( regno0 ) ) ret = <STR_LIT> ; } else { delay = DELAY_LOAD ; ret = <STR_LIT> ; } } else if ( code1 == LABEL_REF ) { if ( TARGET_STATS ) iq2000_count_memory_refs ( op1 , <NUM_LIT> ) ; ret = <STR_LIT> ; } else if ( code1 == SYMBOL_REF || code1 == CONST ) { if ( TARGET_STATS ) iq2000_count_memory_refs ( op1 , <NUM_LIT> ) ; ret = <STR_LIT> ; } else if ( code1 == PLUS ) { rtx add_op0 = XEXP ( op1 , <NUM_LIT> ) ; rtx add_op1 = XEXP ( op1 , <NUM_LIT> ) ; if ( GET_CODE ( XEXP ( op1 , <NUM_LIT> ) ) == REG && GET_CODE ( XEXP ( op1 , <NUM_LIT> ) ) == CONST_INT ) add_op0 = XEXP ( op1 , <NUM_LIT> ) , add_op1 = XEXP ( op1 , <NUM_LIT> ) ; operands [ <NUM_LIT> ] = add_op0 ; operands [ <NUM_LIT> ] = add_op1 ; ret = <STR_LIT> ; } else if ( code1 == HIGH ) { operands [ <NUM_LIT> ] = XEXP ( op1 , <NUM_LIT> ) ; ret = <STR_LIT> ; } } else if ( code0 == MEM ) { if ( TARGET_STATS ) iq2000_count_memory_refs ( op0 , <NUM_LIT> ) ; if ( code1 == REG ) { int regno1 = REGNO ( op1 ) + subreg_offset1 ; if ( GP_REG_P ( regno1 ) ) { switch ( mode ) { case E_SFmode : ret = <STR_LIT> ; break ; case E_SImode : ret = <STR_LIT> ; break ; case E_HImode : ret = <STR_LIT> ; break ; case E_QImode : ret = <STR_LIT> ; break ; default : break ; } } } else if ( code1 == CONST_INT && INTVAL ( op1 ) == <NUM_LIT> ) { switch ( mode ) { case E_SFmode : ret = <STR_LIT> ; break ; case E_SImode : ret = <STR_LIT> ; break ; case E_HImode : ret = <STR_LIT> ; break ; case E_QImode : ret = <STR_LIT> ; break ; default : break ; } } else if ( code1 == CONST_DOUBLE && op1 == CONST0_RTX ( mode ) ) { switch ( mode ) { case E_SFmode : ret = <STR_LIT> ; break ; case E_SImode : ret = <STR_LIT> ; break ; case E_HImode : ret = <STR_LIT> ; break ; case E_QImode : ret = <STR_LIT> ; break ; default : break ; } } } if ( ret == <NUM_LIT> ) { abort_with_insn ( insn , <STR_LIT> ) ; return <NUM_LIT> ; }

if ( delay != DELAY_NONE ) return iq2000_fill_delay_slot ( ret , delay , operands , insn ) ;


<s> else sprintf ( buffer , <STR_LIT> , inverted_p ? inverted_comp : comp , need_z_p ? <STR_LIT> : <STR_LIT> , op1 , op2 ) ; return buffer ; case <NUM_LIT> : case <NUM_LIT> : { const char * target = ( ( iq2000_branch_likely || length == <NUM_LIT> ) ? <STR_LIT> : <STR_LIT> ) ; char * c ; c = strchr ( buffer , '\0' ) ; if ( float_p ) sprintf ( c , <STR_LIT> , inverted_p ? comp : inverted_comp , target ) ;

else sprintf ( c , <STR_LIT> , inverted_p ? comp : inverted_comp , need_z_p ? <STR_LIT> : <STR_LIT> , op1 , op2 , target ) ;


<s> if ( arg . type == NULL_TREE || arg . mode == DImode || arg . mode == DFmode ) return <NUM_LIT> ; size = int_size_in_bytes ( arg . type ) ; return size == - <NUM_LIT> || size > UNITS_PER_WORD ;


<s> reg = arg0 ; offset = arg1 ; if ( GET_CODE ( offset ) == REG ) abort_with_insn ( addr , <STR_LIT> ) ; } else if ( GET_CODE ( arg1 ) == REG ) reg = arg1 , offset = arg0 ; else if ( CONSTANT_P ( arg0 ) && CONSTANT_P ( arg1 ) ) { output_addr_const ( file , addr ) ; break ; } else abort_with_insn ( addr , <STR_LIT> ) ; if ( ! CONSTANT_P ( offset ) ) abort_with_insn ( addr , <STR_LIT> ) ; if ( REGNO ( reg ) == ARG_POINTER_REGNUM ) abort_with_insn ( addr , <STR_LIT> ) ; output_addr_const ( file , offset ) ; fprintf ( file , <STR_LIT> , reg_names [ REGNO ( reg ) ] ) ; } break ; case LABEL_REF : case SYMBOL_REF : case CONST_INT : case CONST : output_addr_const ( file , addr ) ; if ( GET_CODE ( addr ) == CONST_INT ) fprintf ( file , <STR_LIT> , reg_names [ <NUM_LIT> ] ) ; break ; default : abort_with_insn ( addr , <STR_LIT> ) ; break ;


<s> static void iq2000_print_operand_address ( FILE * file , machine_mode mode , rtx addr ) { if ( ! addr ) error ( <STR_LIT> ) ; else switch ( GET_CODE ( addr ) ) { case REG : if ( REGNO ( addr ) == ARG_POINTER_REGNUM ) abort_with_insn ( addr , <STR_LIT> ) ; fprintf ( file , <STR_LIT> , reg_names [ REGNO ( addr ) ] ) ; break ; case LO_SUM : { rtx arg0 = XEXP ( addr , <NUM_LIT> ) ; rtx arg1 = XEXP ( addr , <NUM_LIT> ) ; if ( GET_CODE ( arg0 ) != REG ) abort_with_insn ( addr , <STR_LIT> ) ; fprintf ( file , <STR_LIT> ) ; iq2000_print_operand_address ( file , mode , arg1 ) ; fprintf ( file , <STR_LIT> , reg_names [ REGNO ( arg0 ) ] ) ; } break ; case PLUS : {


<s> static bool iq2000_print_operand_punct_valid_p ( unsigned char code ) {

return iq2000_print_operand_punct [ code ] ;


<s> case MOD : if ( mode == SFmode ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( mode == DFmode ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case UDIV : case UMOD : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case SIGN_EXTEND : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case ZERO_EXTEND : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case CONST_INT : * total = <NUM_LIT> ; break ; case LABEL_REF : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case CONST : { rtx offset = const0_rtx ; rtx symref = eliminate_constant_term ( XEXP ( x , <NUM_LIT> ) , & offset ) ; if ( GET_CODE ( symref ) == LABEL_REF ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( GET_CODE ( symref ) != SYMBOL_REF ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( INTVAL ( offset ) < - <NUM_LIT> || INTVAL ( offset ) > <NUM_LIT> ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( SYMBOL_REF_FLAG ( symref ) ? <NUM_LIT> : <NUM_LIT> ) ; break ; } case SYMBOL_REF :

* total = COSTS_N_INSNS ( SYMBOL_REF_FLAG ( x ) ? <NUM_LIT> : <NUM_LIT> ) ;


<s> case LABEL_REF : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case CONST : { rtx offset = const0_rtx ; rtx symref = eliminate_constant_term ( XEXP ( x , <NUM_LIT> ) , & offset ) ; if ( GET_CODE ( symref ) == LABEL_REF ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( GET_CODE ( symref ) != SYMBOL_REF ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( INTVAL ( offset ) < - <NUM_LIT> || INTVAL ( offset ) > <NUM_LIT> ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( SYMBOL_REF_FLAG ( symref ) ? <NUM_LIT> : <NUM_LIT> ) ; break ; } case SYMBOL_REF : * total = COSTS_N_INSNS ( SYMBOL_REF_FLAG ( x ) ? <NUM_LIT> : <NUM_LIT> ) ; break ; case CONST_DOUBLE : { rtx high , low ; split_double ( x , & high , & low ) ; * total = COSTS_N_INSNS ( ( high == CONST0_RTX ( GET_MODE ( high ) ) || low == CONST0_RTX ( GET_MODE ( low ) ) ) ? <NUM_LIT> : <NUM_LIT> ) ;


<s> return mergeable_constant_section ( mode , align , <NUM_LIT> ) ;


<s> static section * iq2000_select_rtx_section ( machine_mode mode , rtx x ATTRIBUTE_UNUSED , unsigned HOST_WIDE_INT align ) {

return mergeable_constant_section ( mode , align , <NUM_LIT> ) ;


<s> static void iq2000_setup_incoming_varargs ( cumulative_args_t cum_v , const function_arg_info & , int * pretend_size , int no_rtl ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; unsigned int iq2000_off = ! cum -> last_arg_fp ; unsigned int iq2000_fp_off = cum -> last_arg_fp ; if ( ( cum -> arg_words < MAX_ARGS_IN_REGISTERS - iq2000_off ) ) { int iq2000_save_gp_regs = MAX_ARGS_IN_REGISTERS - cum -> arg_words - iq2000_off ;


<s> int iq2000_save_fp_regs = ( MAX_ARGS_IN_REGISTERS - cum -> fp_arg_words - iq2000_fp_off ) ; if ( iq2000_save_gp_regs < <NUM_LIT> ) iq2000_save_gp_regs = <NUM_LIT> ; if ( iq2000_save_fp_regs < <NUM_LIT> ) iq2000_save_fp_regs = <NUM_LIT> ; * pretend_size = ( ( iq2000_save_gp_regs * UNITS_PER_WORD ) + ( iq2000_save_fp_regs * UNITS_PER_FPREG ) ) ; if ( ! ( no_rtl ) ) { if ( cum -> arg_words < MAX_ARGS_IN_REGISTERS - iq2000_off ) { rtx ptr , mem ;

ptr = plus_constant ( Pmode , virtual_incoming_args_rtx , - ( iq2000_save_gp_regs * UNITS_PER_WORD ) ) ;


<s> static HOST_WIDE_INT iq2000_starting_frame_offset ( void ) { return crtl -> outgoing_args_size ;


<s> static void iq2000_trampoline_init ( rtx m_tramp , tree fndecl , rtx chain_value ) { rtx fnaddr = XEXP ( DECL_RTL ( fndecl ) , <NUM_LIT> ) ; rtx mem ; emit_block_move ( m_tramp , assemble_trampoline_template ( ) , GEN_INT ( TRAMPOLINE_CODE_SIZE ) , BLOCK_OP_NORMAL ) ; mem = adjust_address ( m_tramp , Pmode , TRAMPOLINE_CODE_SIZE ) ; emit_move_insn ( mem , fnaddr ) ; mem = adjust_address ( m_tramp , Pmode , TRAMPOLINE_CODE_SIZE + GET_MODE_SIZE ( Pmode ) ) ;


<s> rtx mem ; emit_block_move ( m_tramp , assemble_trampoline_template ( ) , GEN_INT ( TRAMPOLINE_CODE_SIZE ) , BLOCK_OP_NORMAL ) ; mem = adjust_address ( m_tramp , Pmode , TRAMPOLINE_CODE_SIZE ) ;


<s> int_arg_words = crtl -> args . info . arg_words ; if ( int_arg_words < <NUM_LIT> ) gpr_save_area_size = ( <NUM_LIT> - int_arg_words ) * UNITS_PER_WORD ; else gpr_save_area_size = <NUM_LIT> ; nextarg = plus_constant ( Pmode , nextarg , - gpr_save_area_size ) ; std_expand_builtin_va_start ( valist , nextarg ) ;


<s> int int_arg_words ; int gpr_save_area_size ; int_arg_words = crtl -> args . info . arg_words ; if ( int_arg_words < <NUM_LIT> ) gpr_save_area_size = ( <NUM_LIT> - int_arg_words ) * UNITS_PER_WORD ; else gpr_save_area_size = <NUM_LIT> ; nextarg = plus_constant ( Pmode , nextarg , - gpr_save_area_size ) ; std_expand_builtin_va_start ( valist , nextarg ) ;


<s> case GTU : test = ITEST_GTU ; break ; case GEU : test = ITEST_GEU ; break ; case LTU : test = ITEST_LTU ; break ; case LEU : test = ITEST_LEU ; break ; default : break ; } return test ;


<s> int regno ; int reg_save_count = <NUM_LIT> ; for ( regno = GP_REG_LAST ; regno >= GP_REG_FIRST ; regno -- ) if ( BITSET_P ( mask , regno - GP_REG_FIRST ) ) reg_save_count += <NUM_LIT> ; base_offset = gp_offset - ( ( reg_save_count - <NUM_LIT> ) * <NUM_LIT> ) ; base_reg_rtx = iq2000_add_large_offset_to_sp ( base_offset ) ; } for ( regno = GP_REG_LAST ; regno >= GP_REG_FIRST ; regno -- ) { if ( BITSET_P ( mask , regno - GP_REG_FIRST ) ) { rtx reg_rtx ; rtx mem_rtx = gen_rtx_MEM ( gpr_mode , gen_rtx_PLUS ( Pmode , base_reg_rtx , GEN_INT ( gp_offset - base_offset ) ) ) ; reg_rtx = gen_rtx_REG ( gpr_mode , regno ) ;


<s> if ( a & <NUM_LIT> ) c += b ; a >>= <NUM_LIT> ; b <<= <NUM_LIT> ; }