<s> mode = TARGET_SINGLE_FLOAT ? SFmode : DFmode ; for ( i = local_cum . num_fprs ; i < MAX_ARGS_IN_REGISTERS ; i += FP_INC ) { rtx ptr , mem ; ptr = plus_constant ( virtual_incoming_args_rtx , off ) ; mem = gen_rtx_MEM ( mode , ptr ) ; set_mem_alias_set ( mem , get_varargs_alias_set ( ) ) ; emit_move_insn ( mem , gen_rtx_REG ( mode , FP_ARG_FIRST + i ) ) ; off += UNITS_PER_HWFPVALUE ; } } }

if ( REG_PARM_STACK_SPACE ( cfun -> decl ) == <NUM_LIT> ) cfun -> machine -> varargs_size = ( gp_saved * UNITS_PER_WORD + fp_saved * UNITS_PER_FPREG ) ;


<s> if ( info != <NUM_LIT> ) { mips_arch_info = info ;


<s> static void mips_set_frame_expr ( rtx frame_pattern ) { rtx insn ; insn = get_last_insn ( ) ;

RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ;


<s> rtx insn ; insn = get_last_insn ( ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; REG_NOTES ( insn ) = alloc_EXPR_LIST ( REG_FRAME_RELATED_EXPR , frame_pattern , REG_NOTES ( insn ) ) ;


<s> void mips_set_return_address ( rtx address , rtx scratch ) { rtx slot_address ; compute_frame_size ( get_frame_size ( ) ) ;

gcc_assert ( ( cfun -> machine -> frame . mask >> <NUM_LIT> ) & <NUM_LIT> ) ;


<s> void mips_set_return_address ( rtx address , rtx scratch ) { rtx slot_address ; compute_frame_size ( get_frame_size ( ) ) ; gcc_assert ( ( cfun -> machine -> frame . mask >> <NUM_LIT> ) & <NUM_LIT> ) ; slot_address = mips_add_offset ( scratch , stack_pointer_rtx , cfun -> machine -> frame . gp_sp_offset ) ;

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


<s> case JUMP_INSN : if ( INSN_ANNULLED_BRANCH_P ( SEQ_BEGIN ( insn ) ) ) mips_sim_reset ( state ) ; break ; default : break ;


<s> case CODE_LABEL : case CALL_INSN : mips_sim_reset ( state ) ; break ; case JUMP_INSN : if ( INSN_ANNULLED_BRANCH_P ( SEQ_BEGIN ( insn ) ) ) mips_sim_reset ( state ) ;


<s> static void mips_sim_init ( struct mips_sim * state , state_t dfa_state ) {

state -> issue_rate = mips_issue_rate ( ) ;


<s> static void mips_sim_issue_insn ( struct mips_sim * state , rtx insn ) {

state_transition ( state -> dfa_state , insn ) ;


<s> state -> insns_left = state -> issue_rate ;

state_transition ( state -> dfa_state , <NUM_LIT> ) ;


<s> state -> time ++ ; state -> insns_left = state -> issue_rate ;


<s> unsigned int i ; state = data ; if ( REG_P ( x ) ) for ( i = <NUM_LIT> ; i < HARD_REGNO_NREGS ( REGNO ( x ) , GET_MODE ( x ) ) ; i ++ ) {

state -> last_set [ REGNO ( x ) + i ] . insn = mips_sim_insn ;


if ( REG_P ( x ) ) for ( i = <NUM_LIT> ; i < HARD_REGNO_NREGS ( REGNO ( x ) , GET_MODE ( x ) ) ; i ++ ) {


<s> memset ( & state -> last_set , <NUM_LIT> , sizeof ( state -> last_set ) ) ; state_reset ( state -> dfa_state ) ;


<s> state -> insns_left = state -> issue_rate ; memset ( & state -> last_set , <NUM_LIT> , sizeof ( state -> last_set ) ) ;


<s> t = state -> last_set [ REGNO ( reg ) + i ] . time ; t += insn_latency ( state -> last_set [ REGNO ( reg ) + i ] . insn , insn ) ; while ( state -> time < t ) mips_sim_next_cycle ( state ) ;


<s> unsigned int i ; for ( i = <NUM_LIT> ; i < HARD_REGNO_NREGS ( REGNO ( reg ) , GET_MODE ( reg ) ) ; i ++ ) if ( state -> last_set [ REGNO ( reg ) + i ] . insn != <NUM_LIT> ) { unsigned int t ;

t = state -> last_set [ REGNO ( reg ) + i ] . time ;


<s> note_uses ( & PATTERN ( insn ) , mips_sim_wait_regs_1 , state ) ;


<s> for_each_rtx ( x , mips_sim_wait_regs_2 , data ) ;


<s> if ( REG_P ( * x ) ) mips_sim_wait_reg ( data , mips_sim_insn , * x ) ;


<s> state_t tmp_state ; tmp_state = alloca ( state_size ( ) ) ; while ( state -> insns_left == <NUM_LIT> || ( memcpy ( tmp_state , state -> dfa_state , state_size ( ) ) , state_transition ( tmp_state , insn ) >= <NUM_LIT> ) ) mips_sim_next_cycle ( state ) ;


<s> if ( GET_CODE ( * loc ) == LO_SUM ) return - <NUM_LIT> ; return mips_rewrite_small_data_p ( * loc ) ;


<s> return for_each_rtx ( & op , mips_small_data_pattern_1 , <NUM_LIT> ) ;


<s> emit_insn ( gen_store_df_high ( mips_subword ( dest , <NUM_LIT> ) , src ) ) ; } else { rtx low_dest ; low_dest = mips_subword ( dest , <NUM_LIT> ) ; if ( REG_P ( low_dest ) && reg_overlap_mentioned_p ( low_dest , src ) ) {

emit_move_insn ( mips_subword ( dest , <NUM_LIT> ) , mips_subword ( src , <NUM_LIT> ) ) ;


<s> if ( TARGET_64BIT ) return false ; if ( FP_REG_RTX_P ( src ) && FP_REG_RTX_P ( dest ) ) return false ; if ( mips_isa > <NUM_LIT> ) {

if ( FP_REG_RTX_P ( dest ) && MEM_P ( src ) ) return false ;


<s> while ( * given != <NUM_LIT> && TOLOWER ( * given ) == TOLOWER ( * canonical ) ) given ++ , canonical ++ ; return ( ( * given == <NUM_LIT> && * canonical == <NUM_LIT> ) || ( strcmp ( canonical , <STR_LIT> ) == <NUM_LIT> && strcasecmp ( given , <STR_LIT> ) == <NUM_LIT> ) ) ;


<s> enum machine_mode mode ; mode = GET_MODE ( op ) ; if ( mode == VOIDmode ) mode = DImode ; if ( TARGET_BIG_ENDIAN ? ! high_p : high_p ) byte = UNITS_PER_WORD ; else byte = <NUM_LIT> ; if ( REG_P ( op ) ) { if ( FP_REG_P ( REGNO ( op ) ) ) return gen_rtx_REG ( word_mode , high_p ? REGNO ( op ) + <NUM_LIT> : REGNO ( op ) ) ; if ( ACC_HI_REG_P ( REGNO ( op ) ) ) return gen_rtx_REG ( word_mode , high_p ? REGNO ( op ) : REGNO ( op ) + <NUM_LIT> ) ; }

if ( MEM_P ( op ) ) return mips_rewrite_small_data ( adjust_address ( op , word_mode , byte ) ) ;


<s> else byte = <NUM_LIT> ; if ( REG_P ( op ) ) { if ( FP_REG_P ( REGNO ( op ) ) ) return gen_rtx_REG ( word_mode , high_p ? REGNO ( op ) + <NUM_LIT> : REGNO ( op ) ) ; if ( ACC_HI_REG_P ( REGNO ( op ) ) ) return gen_rtx_REG ( word_mode , high_p ? REGNO ( op ) : REGNO ( op ) + <NUM_LIT> ) ; } if ( MEM_P ( op ) ) return mips_rewrite_small_data ( adjust_address ( op , word_mode , byte ) ) ;

return simplify_gen_subreg ( word_mode , op , mode , byte ) ;


<s> if ( ! ISA_HAS_EXT_INS || ! register_operand ( op , VOIDmode ) || GET_MODE_BITSIZE ( GET_MODE ( op ) ) > BITS_PER_WORD ) return false ; len = INTVAL ( size ) ; pos = INTVAL ( position ) ;

if ( len <= <NUM_LIT> || len >= GET_MODE_BITSIZE ( GET_MODE ( op ) ) || pos < <NUM_LIT> || pos + len > GET_MODE_BITSIZE ( GET_MODE ( op ) ) ) return false ;


<s> HOST_WIDE_INT len , pos ; if ( ! ISA_HAS_EXT_INS || ! register_operand ( op , VOIDmode ) || GET_MODE_BITSIZE ( GET_MODE ( op ) ) > BITS_PER_WORD ) return false ; len = INTVAL ( size ) ; pos = INTVAL ( position ) ;


<s> static bool mips_valid_pointer_mode ( enum machine_mode mode ) { return ( mode == SImode || ( TARGET_64BIT && mode == DImode ) ) ;


<s> tree ovfl , gtop , ftop , goff , foff ; tree t ; int gpr_save_area_size ; int fpr_save_area_size ; int fpr_offset ; cum = & current_function_args_info ; gpr_save_area_size = ( MAX_ARGS_IN_REGISTERS - cum -> num_gprs ) * UNITS_PER_WORD ; fpr_save_area_size = ( MAX_ARGS_IN_REGISTERS - cum -> num_fprs ) * UNITS_PER_FPREG ; f_ovfl = TYPE_FIELDS ( va_list_type_node ) ; f_gtop = TREE_CHAIN ( f_ovfl ) ; f_ftop = TREE_CHAIN ( f_gtop ) ; f_goff = TREE_CHAIN ( f_ftop ) ; f_foff = TREE_CHAIN ( f_goff ) ; ovfl = build ( COMPONENT_REF , TREE_TYPE ( f_ovfl ) , valist , f_ovfl , NULL_TREE ) ; gtop = build ( COMPONENT_REF , TREE_TYPE ( f_gtop ) , valist , f_gtop , NULL_TREE ) ; ftop = build ( COMPONENT_REF , TREE_TYPE ( f_ftop ) , valist , f_ftop , NULL_TREE ) ; goff = build ( COMPONENT_REF , TREE_TYPE ( f_goff ) , valist , f_goff , NULL_TREE ) ; foff = build ( COMPONENT_REF , TREE_TYPE ( f_foff ) , valist , f_foff , NULL_TREE ) ; t = make_tree ( TREE_TYPE ( ovfl ) , virtual_incoming_args_rtx ) ;

if ( cum -> stack_words > <NUM_LIT> ) t = build ( PLUS_EXPR , TREE_TYPE ( ovfl ) , t , build_int_cst ( NULL_TREE , cum -> stack_words * UNITS_PER_WORD ) ) ;


<s> gtop = build ( COMPONENT_REF , TREE_TYPE ( f_gtop ) , valist , f_gtop , NULL_TREE ) ; ftop = build ( COMPONENT_REF , TREE_TYPE ( f_ftop ) , valist , f_ftop , NULL_TREE ) ; goff = build ( COMPONENT_REF , TREE_TYPE ( f_goff ) , valist , f_goff , NULL_TREE ) ; foff = build ( COMPONENT_REF , TREE_TYPE ( f_foff ) , valist , f_foff , NULL_TREE ) ; t = make_tree ( TREE_TYPE ( ovfl ) , virtual_incoming_args_rtx ) ; if ( cum -> stack_words > <NUM_LIT> ) t = build ( PLUS_EXPR , TREE_TYPE ( ovfl ) , t , build_int_cst ( NULL_TREE , cum -> stack_words * UNITS_PER_WORD ) ) ; t = build ( MODIFY_EXPR , TREE_TYPE ( ovfl ) , ovfl , t ) ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; t = make_tree ( TREE_TYPE ( gtop ) , virtual_incoming_args_rtx ) ; t = build ( MODIFY_EXPR , TREE_TYPE ( gtop ) , gtop , t ) ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; t = make_tree ( TREE_TYPE ( ftop ) , virtual_incoming_args_rtx ) ; fpr_offset = gpr_save_area_size + UNITS_PER_FPVALUE - <NUM_LIT> ; fpr_offset &= ~ ( UNITS_PER_FPVALUE - <NUM_LIT> ) ; if ( fpr_offset ) t = build ( PLUS_EXPR , TREE_TYPE ( ftop ) , t , build_int_cst ( NULL_TREE , - fpr_offset ) ) ;

t = build ( MODIFY_EXPR , TREE_TYPE ( ftop ) , ftop , t ) ;


<s> static bool mips_vector_mode_supported_p ( enum machine_mode mode ) { switch ( mode ) { case V2SFmode : return TARGET_PAIRED_SINGLE_FLOAT ; case V2HImode : case V4QImode :


<s> switch ( mode ) { case V2SFmode : return TARGET_PAIRED_SINGLE_FLOAT ;


<s> fprintf ( file , <STR_LIT> , reg_names [ REGNO ( addr . reg ) ] ) ; return ; case ADDRESS_CONST_INT : output_addr_const ( file , x ) ; fprintf ( file , <STR_LIT> , reg_names [ <NUM_LIT> ] ) ; return ;


<s> if ( UNSPEC_ADDRESS_P ( base ) ) op = plus_constant ( UNSPEC_ADDRESS ( base ) , offset ) ; fputs ( relocs [ symbol_type ] , file ) ; output_addr_const ( file , op ) ;

for ( p = relocs [ symbol_type ] ; * p != <NUM_LIT> ; p ++ ) if ( * p == '(' ) fputc ( ')' , file ) ;


<s> static int symbolic_expression_p ( rtx x ) { if ( GET_CODE ( x ) == SYMBOL_REF ) return <NUM_LIT> ; if ( GET_CODE ( x ) == CONST ) return symbolic_expression_p ( XEXP ( x , <NUM_LIT> ) ) ; 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> ) ) ) ; return <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> ) ) ) ; return <NUM_LIT> ;


<s> aligned_p = true ; mips_sim_init ( & state , alloca ( state_size ( ) ) ) ; for ( insn = get_insns ( ) ; insn != <NUM_LIT> ; insn = next ) { unsigned int length ; next = NEXT_INSN ( insn ) ; vr4130_avoid_branch_rt_conflict ( insn ) ; if ( USEFUL_INSN_P ( insn ) ) FOR_EACH_SUBINSN ( subinsn , insn ) { mips_sim_wait_insn ( & state , subinsn ) ; if ( state . insns_left != state . issue_rate && ! CALL_P ( subinsn ) ) { if ( subinsn == SEQ_BEGIN ( insn ) && aligned_p ) { emit_insn_after ( gen_nop ( ) , last2 ) ; aligned_p = false ; }

else if ( subinsn != SEQ_BEGIN ( insn ) && ! aligned_p ) {


<s> second = SEQ_END ( insn ) ; if ( JUMP_P ( first ) && NONJUMP_INSN_P ( second ) && GET_CODE ( PATTERN ( first ) ) == SET && GET_CODE ( SET_DEST ( PATTERN ( first ) ) ) == PC && GET_CODE ( SET_SRC ( PATTERN ( first ) ) ) == IF_THEN_ELSE ) { rtx cond = XEXP ( SET_SRC ( PATTERN ( first ) ) , <NUM_LIT> ) ;

if ( ( GET_CODE ( cond ) == EQ || GET_CODE ( cond ) == NE ) && REG_P ( XEXP ( cond , <NUM_LIT> ) ) && REG_P ( XEXP ( cond , <NUM_LIT> ) ) && reg_referenced_p ( XEXP ( cond , <NUM_LIT> ) , PATTERN ( second ) ) && ! reg_referenced_p ( XEXP ( cond , <NUM_LIT> ) , PATTERN ( second ) ) ) {


<s> second = SEQ_END ( insn ) ; if ( JUMP_P ( first ) && NONJUMP_INSN_P ( second ) && GET_CODE ( PATTERN ( first ) ) == SET && GET_CODE ( SET_DEST ( PATTERN ( first ) ) ) == PC && GET_CODE ( SET_SRC ( PATTERN ( first ) ) ) == IF_THEN_ELSE ) { rtx cond = XEXP ( SET_SRC ( PATTERN ( first ) ) , <NUM_LIT> ) ; if ( ( GET_CODE ( cond ) == EQ || GET_CODE ( cond ) == NE ) && REG_P ( XEXP ( cond , <NUM_LIT> ) ) && REG_P ( XEXP ( cond , <NUM_LIT> ) ) && reg_referenced_p ( XEXP ( cond , <NUM_LIT> ) , PATTERN ( second ) ) && ! reg_referenced_p ( XEXP ( cond , <NUM_LIT> ) , PATTERN ( second ) ) ) {


<s> static void vr4130_reorder ( rtx * ready , int nready ) {

if ( vr4130_swap_insns_p ( ready [ nready - <NUM_LIT> ] , ready [ nready - <NUM_LIT> ] ) ) mips_promote_ready ( ready , nready - <NUM_LIT> , nready - <NUM_LIT> ) ;


<s> note_stores ( PATTERN ( vr4130_last_insn ) , vr4130_true_reg_dependence_p_1 , & insn ) ;


<s> static bool vr4130_true_reg_dependence_p ( rtx insn ) { note_stores ( PATTERN ( vr4130_last_insn ) , vr4130_true_reg_dependence_p_1 , & insn ) ;


<s> if ( REG_P ( x ) && * insn_ptr != <NUM_LIT> && reg_referenced_p ( x , PATTERN ( * insn_ptr ) ) ) * insn_ptr = <NUM_LIT> ;


<s> bool and_operands_ok ( machine_mode mode , rtx op1 , rtx op2 ) { return ( memory_operand ( op1 , mode ) ? and_load_operand ( op2 , mode ) : and_reg_operand ( op2 , mode ) ) ;


<s> bool and_operands_ok ( machine_mode mode , rtx op1 , rtx op2 ) {

return ( memory_operand ( op1 , mode ) ? and_load_operand ( op2 , mode ) : and_reg_operand ( op2 , mode ) ) ;


<s> inline bool mips_lo_sum_offset_hasher :: equal ( const value_type * entry , const compare_type * value ) {

return rtx_equal_p ( entry -> base , value ) ;


<s> bool local_alias_traits :: equal_keys ( rtx func1 , rtx func2 ) { return rtx_equal_p ( func1 , func2 ) ;


<s> bool local_alias_traits :: equal_keys ( rtx func1 , rtx func2 ) {


<s> bool existed ; bool * slot = & mflip_mips16_htab -> get_or_insert ( name , & existed ) ; if ( ! existed ) { mips16_flipper = ! mips16_flipper ; * slot = mips16_flipper ? ! base_is_mips16 : base_is_mips16 ; } return * slot ;


<s> pattern = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( n ) ) ; n = <NUM_LIT> ; set = gen_rtx_SET ( VOIDmode , stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , restore_p ? size : - size ) ) ; RTX_FRAME_RELATED_P ( set ) = <NUM_LIT> ; XVECEXP ( pattern , <NUM_LIT> , n ++ ) = set ; top_offset = restore_p ? size : <NUM_LIT> ; for ( i = <NUM_LIT> ; i < nargs ; i ++ ) { offset = top_offset + i * UNITS_PER_WORD ; set = mips16e_save_restore_reg ( restore_p , true , offset , GP_ARG_FIRST + i ) ; XVECEXP ( pattern , <NUM_LIT> , n ++ ) = set ; } offset = top_offset ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( mips16e_save_restore_regs ) ; i ++ ) { regno = mips16e_save_restore_regs [ i ] ;

if ( BITSET_P ( * mask_ptr , regno ) ) {


<s> mem = gen_frame_mem ( SImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) ; reg = gen_rtx_REG ( SImode , regno ) ; if ( restore_p ) { mips_add_cfa_restore ( reg ) ; return gen_rtx_SET ( VOIDmode , reg , mem ) ; }

if ( reg_parm_p ) return gen_rtx_SET ( VOIDmode , mem , reg ) ;


<s> unsigned int f ; secname = ACONCAT ( ( <STR_LIT> , fp_ret_p ? <STR_LIT> : <STR_LIT> , fnname , NULL ) ) ; stubname = ACONCAT ( ( <STR_LIT> , fp_ret_p ? <STR_LIT> : <STR_LIT> , fnname , NULL ) ) ; stubid = get_identifier ( stubname ) ; stubdecl = build_decl ( BUILTINS_LOCATION , FUNCTION_DECL , stubid , build_function_type_list ( void_type_node , NULL_TREE ) ) ; set_decl_section_name ( stubdecl , secname ) ; DECL_RESULT ( stubdecl ) = build_decl ( BUILTINS_LOCATION , RESULT_DECL , NULL_TREE , void_type_node ) ; fprintf ( asm_out_file , <STR_LIT> , ( fp_ret_p ? ( GET_MODE ( retval ) == SFmode ? <STR_LIT> : <STR_LIT> ) : <STR_LIT> ) , fnname ) ; separator = <STR_LIT> ; for ( f = ( unsigned int ) fp_code ; f != <NUM_LIT> ; f >>= <NUM_LIT> ) { fprintf ( asm_out_file , <STR_LIT> , separator , ( f & <NUM_LIT> ) == <NUM_LIT> ? <STR_LIT> : <STR_LIT> ) ; separator = <STR_LIT> ; } fprintf ( asm_out_file , <STR_LIT> ) ; assemble_start_function ( stubdecl , stubname ) ; mips_start_function_definition ( stubname , false ) ; if ( fp_ret_p ) { fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> , reg_names [ GP_REG_FIRST + <NUM_LIT> ] , reg_names [ RETURN_ADDR_REGNUM ] ) ; } else { if ( TARGET_EXPLICIT_RELOCS ) { output_asm_insn ( <STR_LIT> , & fn ) ; output_asm_insn ( <STR_LIT> , & fn ) ; } else output_asm_insn ( <STR_LIT> , & fn ) ; } mips_output_args_xfer ( fp_code , 't' ) ; if ( fp_ret_p ) { output_asm_insn ( MIPS_CALL ( <STR_LIT> , & fn , <NUM_LIT> , - <NUM_LIT> ) , & fn ) ; fprintf ( asm_out_file , <STR_LIT> ) ; switch ( GET_MODE ( retval ) ) { case SCmode : mips_output_32bit_xfer ( 'f' , GP_RETURN + TARGET_BIG_ENDIAN , TARGET_BIG_ENDIAN ? FP_REG_FIRST + <NUM_LIT> : FP_REG_FIRST ) ; mips_output_32bit_xfer ( 'f' , GP_RETURN + TARGET_LITTLE_ENDIAN , TARGET_LITTLE_ENDIAN ? FP_REG_FIRST + <NUM_LIT> : FP_REG_FIRST ) ; if ( GET_MODE ( retval ) == SCmode && TARGET_64BIT ) { fprintf ( asm_out_file , <STR_LIT> , reg_names [ GP_RETURN + TARGET_BIG_ENDIAN ] , reg_names [ GP_RETURN + TARGET_BIG_ENDIAN ] ) ;


<s> int align_log = floor_log2 ( GET_MODE_SIZE ( c -> mode ) ) ; insn = emit_insn_after ( gen_align ( GEN_INT ( align_log ) ) , insn ) ; } align = GET_MODE_SIZE ( c -> mode ) ; insn = emit_label_after ( c -> label , insn ) ; insn = mips16_emit_constants_1 ( c -> mode , c -> value , insn ) ; next = c -> next ; free ( c ) ; }


<s> static rtx mips16_local_alias ( rtx func ) { if ( mips16_local_aliases == NULL ) mips16_local_aliases = hash_map < rtx , rtx , local_alias_traits > :: create_ggc ( <NUM_LIT> ) ; bool existed ; rtx * slot = & mips16_local_aliases -> get_or_insert ( func , & existed ) ; gcc_assert ( slot != NULL ) ;


<s> old_label = JUMP_LABEL ( insn ) ; target = gen_rtx_LABEL_REF ( Pmode , old_label ) ; mips16_load_branch_target ( temp , target ) ; jump = emit_jump_insn ( PMODE_INSN ( gen_indirect_jump_and_restore , ( temp , temp , saved_temp ) ) ) ; JUMP_LABEL ( jump ) = old_label ; LABEL_NUSES ( old_label ) ++ ; mips16_lay_out_constants ( false ) ; if ( simplejump_p ( insn ) ) new_label = NULL ; else { new_label = gen_label_rtx ( ) ;


<s> if ( mips_classify_address ( & addr , x , mode , false ) ) switch ( addr . type ) { case ADDRESS_REG : if ( TARGET_MIPS16 && ! mips16_unextended_reference_p ( mode , addr . reg , UINTVAL ( addr . offset ) ) ) return factor * <NUM_LIT> ; return factor ; case ADDRESS_LO_SUM : return TARGET_MIPS16 ? factor * <NUM_LIT> : factor ; case ADDRESS_CONST_INT : return factor ; case ADDRESS_SYMBOLIC :

return factor * mips_symbol_insns ( addr . symbol_type , mode ) ;


<s> if ( CALL_P ( insn ) || ( TARGET_MIPS16 ? simplejump_p ( insn ) : JUMP_P ( insn ) ) ) length += TARGET_MIPS16 ? <NUM_LIT> : <NUM_LIT> ; if ( ! cfun -> machine -> ignore_hazard_length_p && INSN_P ( insn ) && INSN_CODE ( insn ) >= <NUM_LIT> ) switch ( get_attr_hazard ( insn ) ) { case HAZARD_NONE : break ; case HAZARD_DELAY : length += NOP_INSN_LENGTH ;


mips_get_arg_info ( & info , get_cumulative_args ( cum ) , mode , type , named ) ;


<s> static int mips_arg_partial_bytes ( cumulative_args_t cum , machine_mode mode , tree type , bool named ) {


* clear = build_call_expr ( set_fcsr , <NUM_LIT> , fcsr_mod_var ) ;


<s> if ( * hilo_delay < <NUM_LIT> && reg_set_p ( lo_reg , pattern ) ) nops = <NUM_LIT> - * hilo_delay ; else if ( * delayed_reg != <NUM_LIT> && reg_referenced_p ( * delayed_reg , pattern ) ) nops = <NUM_LIT> ; else nops = <NUM_LIT> ; * hilo_delay += nops ; while ( nops -- > <NUM_LIT> ) emit_insn_after ( gen_hazard_nop ( ) , after ) ; * hilo_delay += ninsns ; * delayed_reg = <NUM_LIT> ; if ( INSN_CODE ( insn ) >= <NUM_LIT> ) switch ( get_attr_hazard ( insn ) ) { case HAZARD_NONE : break ; case HAZARD_HILO : * hilo_delay = <NUM_LIT> ; break ; case HAZARD_DELAY : set = single_set ( insn ) ; gcc_assert ( set ) ; * delayed_reg = SET_DEST ( set ) ;


<s> static int mips_binary_cost ( rtx x , int single_cost , int double_cost , bool speed ) { int cost ; if ( GET_MODE_SIZE ( GET_MODE ( x ) ) == UNITS_PER_WORD * <NUM_LIT> ) cost = double_cost ; else cost = single_cost ;

return ( cost + set_src_cost ( XEXP ( x , <NUM_LIT> ) , speed ) + rtx_cost ( XEXP ( x , <NUM_LIT> ) , GET_CODE ( x ) , <NUM_LIT> , speed ) ) ;


<s> mips_block_move_straight ( dest , src , bytes_per_iter ) ; mips_emit_move ( src_reg , plus_constant ( Pmode , src_reg , bytes_per_iter ) ) ; mips_emit_move ( dest_reg , plus_constant ( Pmode , dest_reg , bytes_per_iter ) ) ; test = gen_rtx_NE ( VOIDmode , src_reg , final_src ) ; if ( Pmode == DImode ) emit_jump_insn ( gen_cbranchdi4 ( test , src_reg , final_src , label ) ) ; else emit_jump_insn ( gen_cbranchsi4 ( test , src_reg , final_src , label ) ) ;

if ( leftover ) mips_block_move_straight ( dest , src , leftover ) ;


<s> if ( MEM_ALIGN ( src ) >= bits ) mips_emit_move ( regs [ i ] , adjust_address ( src , mode , offset ) ) ; else { rtx part = adjust_address ( src , BLKmode , offset ) ; set_mem_size ( part , delta ) ; if ( ! mips_expand_ext_as_unaligned_load ( regs [ i ] , part , bits , <NUM_LIT> , <NUM_LIT> ) ) gcc_unreachable ( ) ; } } for ( offset = <NUM_LIT> , i = <NUM_LIT> ; offset + delta <= length ; offset += delta , i ++ ) if ( MEM_ALIGN ( dest ) >= bits ) mips_emit_move ( adjust_address ( dest , mode , offset ) , regs [ i ] ) ; else { rtx part = adjust_address ( dest , BLKmode , offset ) ; set_mem_size ( part , delta ) ; if ( ! mips_expand_ins_as_unaligned_store ( part , regs [ i ] , bits , <NUM_LIT> ) ) gcc_unreachable ( ) ; } if ( offset < length ) { src = adjust_address ( src , BLKmode , offset ) ; dest = adjust_address ( dest , BLKmode , offset ) ; move_by_pieces ( dest , src , length - offset , MIN ( MEM_ALIGN ( src ) , MEM_ALIGN ( dest ) ) , <NUM_LIT> ) ;


<s> if ( ! mips_expand_ext_as_unaligned_load ( regs [ i ] , part , bits , <NUM_LIT> , <NUM_LIT> ) ) gcc_unreachable ( ) ; } } for ( offset = <NUM_LIT> , i = <NUM_LIT> ; offset + delta <= length ; offset += delta , i ++ ) if ( MEM_ALIGN ( dest ) >= bits ) mips_emit_move ( adjust_address ( dest , mode , offset ) , regs [ i ] ) ; else { rtx part = adjust_address ( dest , BLKmode , offset ) ; set_mem_size ( part , delta ) ; if ( ! mips_expand_ins_as_unaligned_store ( part , regs [ i ] , bits , <NUM_LIT> ) ) gcc_unreachable ( ) ; } if ( offset < length ) { src = adjust_address ( src , BLKmode , offset ) ;

dest = adjust_address ( dest , BLKmode , offset ) ;


<s> static bool mips_callee_copies ( cumulative_args_t cum ATTRIBUTE_UNUSED , machine_mode mode ATTRIBUTE_UNUSED , const_tree type ATTRIBUTE_UNUSED , bool named ) {


<s> a0 = gen_rtx_REG ( Pmode , GP_ARG_FIRST ) ; if ( ! mips_tls_symbol ) mips_tls_symbol = init_one_libfunc ( <STR_LIT> ) ; loc = mips_unspec_address ( sym , type ) ; start_sequence ( ) ; emit_insn ( gen_rtx_SET ( Pmode , a0 , gen_rtx_LO_SUM ( Pmode , pic_offset_table_rtx , loc ) ) ) ; insn = mips_expand_call ( MIPS_CALL_NORMAL , v0 , mips_tls_symbol , const0_rtx , NULL_RTX , false ) ; RTL_CONST_CALL_P ( insn ) = <NUM_LIT> ; use_reg ( & CALL_INSN_FUNCTION_USAGE ( insn ) , a0 ) ;


<s> bool mips_cannot_change_mode_class ( machine_mode from , machine_mode to , enum reg_class rclass ) {

if ( GET_MODE_SIZE ( from ) == <NUM_LIT> && GET_MODE_SIZE ( to ) == <NUM_LIT> && INTEGRAL_MODE_P ( from ) && INTEGRAL_MODE_P ( to ) ) return false ;


<s> bool mips_cannot_change_mode_class ( machine_mode from , machine_mode to , enum reg_class rclass ) { if ( GET_MODE_SIZE ( from ) == <NUM_LIT> && GET_MODE_SIZE ( to ) == <NUM_LIT> && INTEGRAL_MODE_P ( from ) && INTEGRAL_MODE_P ( to ) ) return false ;

return reg_classes_intersect_p ( FP_REGS , rclass ) ;


<s> split_const ( x , & base , & offset ) ; if ( mips_symbolic_constant_p ( base , SYMBOL_CONTEXT_LEA , & type ) ) { if ( mips_use_pcrel_pool_p [ ( int ) type ] ) return false ; if ( SMALL_INT ( offset ) && mips_symbol_insns ( type , MAX_MACHINE_MODE ) > <NUM_LIT> ) return true ; if ( TARGET_MIPS16_PCREL_LOADS && mips_got_symbol_type_p ( type ) ) return true ; } if ( tls_referenced_p ( x ) ) return true ; return false ;


<s> if ( CONST_INT_P ( x ) && mips_legitimate_constant_p ( mode , x ) ) return true ; split_const ( x , & base , & offset ) ; if ( mips_symbolic_constant_p ( base , SYMBOL_CONTEXT_LEA , & type ) ) { if ( mips_use_pcrel_pool_p [ ( int ) type ] ) return false ;

if ( SMALL_INT ( offset ) && mips_symbol_insns ( type , MAX_MACHINE_MODE ) > <NUM_LIT> ) return true ;


<s> if ( cfun -> machine -> interrupt_handler_p ) return false ; if ( ! reload_completed ) return false ; if ( crtl -> profile ) return false ; if ( mips16_cfun_returns_in_fpr_p ( ) ) return false ;

return cfun -> machine -> frame . total_size == <NUM_LIT> ;


<s> if ( cfun -> machine -> interrupt_handler_p && mips_interrupt_extra_call_saved_reg_p ( regno ) ) return true ;

return ( regno == GLOBAL_POINTER_REGNUM ? TARGET_CALL_SAVED_GP : ! call_really_used_regs [ regno ] ) ;


<s> if ( HARD_REGNO_MODE_OK ( FP_REG_FIRST , mode ) ) size = MIN ( size , UNITS_PER_FPREG ) ; AND_COMPL_HARD_REG_SET ( left , reg_class_contents [ ( int ) FP_REGS ] ) ; } if ( ! hard_reg_set_empty_p ( left ) ) size = MIN ( size , UNITS_PER_WORD ) ;

return ( GET_MODE_SIZE ( mode ) + size - <NUM_LIT> ) / size ;


<s> frame -> var_size = MIPS_STACK_ALIGN ( size ) ; offset += frame -> var_size ; for ( regno = GP_REG_FIRST ; regno <= GP_REG_LAST ; regno ++ ) if ( mips_save_reg_p ( regno ) ) { frame -> num_gp ++ ; frame -> mask |= <NUM_LIT> << ( regno - GP_REG_FIRST ) ; } if ( crtl -> calls_eh_return ) for ( i = <NUM_LIT> ; EH_RETURN_DATA_REGNO ( i ) != INVALID_REGNUM ; i ++ ) { frame -> num_gp ++ ; frame -> mask |= <NUM_LIT> << ( EH_RETURN_DATA_REGNO ( i ) - GP_REG_FIRST ) ; } if ( GENERATE_MIPS16E_SAVE_RESTORE ) { mips16e_mask_registers ( & frame -> mask , mips16e_s2_s8_regs , ARRAY_SIZE ( mips16e_s2_s8_regs ) , & frame -> num_gp ) ; mips16e_mask_registers ( & frame -> mask , mips16e_a0_a3_regs , ARRAY_SIZE ( mips16e_a0_a3_regs ) , & frame -> num_gp ) ; } if ( frame -> num_gp > <NUM_LIT> ) { offset += MIPS_STACK_ALIGN ( frame -> num_gp * UNITS_PER_WORD ) ; frame -> gp_sp_offset = offset - UNITS_PER_WORD ; } if ( TARGET_HARD_FLOAT ) for ( regno = FP_REG_FIRST ; regno <= FP_REG_LAST ; regno += MAX_FPRS_PER_FMT ) if ( mips_save_reg_p ( regno ) ) { frame -> num_fp += MAX_FPRS_PER_FMT ; frame -> fmask |= ~ ( ~ <NUM_LIT> << MAX_FPRS_PER_FMT ) << ( regno - FP_REG_FIRST ) ; } if ( frame -> num_fp > <NUM_LIT> ) {

offset += MIPS_STACK_ALIGN ( frame -> num_fp * UNITS_PER_FPREG ) ;


AND_COMPL_HARD_REG_SET ( operand_reg_set , reg_class_contents [ ( int ) MD_REGS ] ) ;


<s> enum mips_symbol_type symbol_type ; rtx offset ; switch ( GET_CODE ( x ) ) { case HIGH : if ( ! mips_symbolic_constant_p ( XEXP ( x , <NUM_LIT> ) , SYMBOL_CONTEXT_LEA , & symbol_type ) || ! mips_split_p [ symbol_type ] ) return <NUM_LIT> ; return TARGET_MIPS16 ? <NUM_LIT> : <NUM_LIT> ; case CONST_INT : if ( TARGET_MIPS16 ) return ( IN_RANGE ( INTVAL ( x ) , <NUM_LIT> , <NUM_LIT> ) ? <NUM_LIT> : SMALL_OPERAND_UNSIGNED ( INTVAL ( x ) ) ? <NUM_LIT> : IN_RANGE ( - INTVAL ( x ) , <NUM_LIT> , <NUM_LIT> ) ? <NUM_LIT> : SMALL_OPERAND_UNSIGNED ( - INTVAL ( x ) ) ? <NUM_LIT> : <NUM_LIT> ) ; return mips_build_integer ( codes , INTVAL ( x ) ) ; case CONST_DOUBLE : case CONST_VECTOR : return ! TARGET_MIPS16 && x == CONST0_RTX ( GET_MODE ( x ) ) ? <NUM_LIT> : <NUM_LIT> ; case CONST : if ( CONST_GP_P ( x ) ) return <NUM_LIT> ; if ( mips_symbolic_constant_p ( x , SYMBOL_CONTEXT_LEA , & symbol_type ) ) return mips_symbol_insns ( symbol_type , MAX_MACHINE_MODE ) ; split_const ( x , & x , & offset ) ; if ( offset != <NUM_LIT> ) { int n = mips_const_insns ( x ) ; if ( n != <NUM_LIT> ) { if ( SMALL_INT ( offset ) ) return n + <NUM_LIT> ; else if ( ! targetm . cannot_force_const_mem ( GET_MODE ( x ) , x ) ) return n + <NUM_LIT> + mips_build_integer ( codes , INTVAL ( offset ) ) ; } } return <NUM_LIT> ; case SYMBOL_REF : case LABEL_REF : return mips_symbol_insns ( mips_classify_symbol ( x , SYMBOL_CONTEXT_LEA ) , MAX_MACHINE_MODE ) ; default : return <NUM_LIT> ; }


<s> case CONST : if ( CONST_GP_P ( x ) ) return <NUM_LIT> ; if ( mips_symbolic_constant_p ( x , SYMBOL_CONTEXT_LEA , & symbol_type ) ) return mips_symbol_insns ( symbol_type , MAX_MACHINE_MODE ) ; split_const ( x , & x , & offset ) ; if ( offset != <NUM_LIT> ) { int n = mips_const_insns ( x ) ; if ( n != <NUM_LIT> ) { if ( SMALL_INT ( offset ) ) return n + <NUM_LIT> ; else if ( ! targetm . cannot_force_const_mem ( GET_MODE ( x ) , x ) ) return n + <NUM_LIT> + mips_build_integer ( codes , INTVAL ( offset ) ) ; } } return <NUM_LIT> ; case SYMBOL_REF : case LABEL_REF : return mips_symbol_insns ( mips_classify_symbol ( x , SYMBOL_CONTEXT_LEA ) , MAX_MACHINE_MODE ) ;


<s> static machine_mode mips_dwarf_frame_reg_mode ( int regno ) { machine_mode mode = default_dwarf_frame_reg_mode ( regno ) ;

if ( FP_REG_P ( regno ) && mips_abi == ABI_32 && TARGET_FLOAT64 ) mode = SImode ;


<s> static machine_mode mips_dwarf_frame_reg_mode ( int regno ) { machine_mode mode = default_dwarf_frame_reg_mode ( regno ) ; if ( FP_REG_P ( regno ) && mips_abi == ABI_32 && TARGET_FLOAT64 ) mode = SImode ;


<s> void mips_emit_binary ( enum rtx_code code , rtx target , rtx op0 , rtx op1 ) {

emit_insn ( gen_rtx_SET ( VOIDmode , target , gen_rtx_fmt_ee ( code , GET_MODE ( target ) , op0 , op1 ) ) ) ;


<s> void mips_emit_binary ( enum rtx_code code , rtx target , rtx op0 , rtx op1 ) { emit_insn ( gen_rtx_SET ( VOIDmode , target , gen_rtx_fmt_ee ( code , GET_MODE ( target ) , op0 , op1 ) ) ) ;


<s> rtx cmp_op1 = * op1 ; if ( GET_MODE_CLASS ( GET_MODE ( * op0 ) ) == MODE_INT ) { if ( ! need_eq_ne_p && * op1 == const0_rtx ) ; else if ( * code == EQ || * code == NE ) { if ( need_eq_ne_p ) { * op0 = mips_zero_if_equal ( cmp_op0 , cmp_op1 ) ; * op1 = const0_rtx ; } else * op1 = force_reg ( GET_MODE ( cmp_op0 ) , cmp_op1 ) ; } else { bool invert = false ; * op0 = gen_reg_rtx ( GET_MODE ( cmp_op0 ) ) ; mips_emit_int_order_test ( * code , & invert , * op0 , cmp_op0 , cmp_op1 ) ; * code = ( invert ? EQ : NE ) ; * op1 = const0_rtx ; } } else if ( ALL_FIXED_POINT_MODE_P ( GET_MODE ( cmp_op0 ) ) ) { * op0 = gen_rtx_REG ( CCDSPmode , CCDSP_CC_REGNUM ) ; mips_emit_binary ( * code , * op0 , cmp_op0 , cmp_op1 ) ; * code = NE ; * op1 = const0_rtx ; } else { enum rtx_code cmp_code ; cmp_code = * code ; if ( ISA_HAS_CCF ) { * code = NE ; * op0 = gen_reg_rtx ( CCFmode ) ; } else { * code = mips_reversed_fp_cond ( & cmp_code ) ? EQ : NE ;

if ( ISA_HAS_8CC ) * op0 = mips_allocate_fcc ( CCmode ) ;


<s> else if ( ALL_FIXED_POINT_MODE_P ( GET_MODE ( cmp_op0 ) ) ) { * op0 = gen_rtx_REG ( CCDSPmode , CCDSP_CC_REGNUM ) ; mips_emit_binary ( * code , * op0 , cmp_op0 , cmp_op1 ) ; * code = NE ; * op1 = const0_rtx ; } else { enum rtx_code cmp_code ; cmp_code = * code ; if ( ISA_HAS_CCF ) { * code = NE ; * op0 = gen_reg_rtx ( CCFmode ) ; } else { * code = mips_reversed_fp_cond ( & cmp_code ) ? EQ : NE ; if ( ISA_HAS_8CC ) * op0 = mips_allocate_fcc ( CCmode ) ; else * op0 = gen_rtx_REG ( CCmode , FPSW_REGNUM ) ; } * op1 = const0_rtx ;


<s> static void mips_emit_move_or_split ( rtx dest , rtx src , enum mips_split_type split_type ) { if ( mips_split_move_p ( dest , src , split_type ) ) mips_split_move ( dest , src , split_type ) ;


<s> static void mips_emit_probe_stack_range ( HOST_WIDE_INT first , HOST_WIDE_INT size ) { if ( TARGET_MIPS16 ) sorry ( <STR_LIT> ) ; if ( first + size <= <NUM_LIT> ) { HOST_WIDE_INT i ; for ( i = PROBE_INTERVAL ; i < size ; i += PROBE_INTERVAL ) emit_stack_probe ( plus_constant ( Pmode , stack_pointer_rtx , - ( first + i ) ) ) ; emit_stack_probe ( plus_constant ( Pmode , stack_pointer_rtx , - ( first + size ) ) ) ; } else { HOST_WIDE_INT rounded_size ; rtx r3 = MIPS_PROLOGUE_TEMP ( Pmode ) ; rtx r12 = MIPS_PROLOGUE_TEMP2 ( Pmode ) ;


<s> else { HOST_WIDE_INT rounded_size ; rtx r3 = MIPS_PROLOGUE_TEMP ( Pmode ) ; rtx r12 = MIPS_PROLOGUE_TEMP2 ( Pmode ) ; gcc_assert ( first <= <NUM_LIT> ) ; rounded_size = size & - PROBE_INTERVAL ; emit_insn ( gen_rtx_SET ( VOIDmode , r3 , plus_constant ( Pmode , stack_pointer_rtx , - first ) ) ) ; if ( rounded_size > <NUM_LIT> ) { emit_move_insn ( r12 , GEN_INT ( rounded_size ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , r12 , gen_rtx_MINUS ( Pmode , r3 , r12 ) ) ) ;


<s> } if ( regno == cfun -> machine -> global_pointer && ! mips_must_initialize_gp_p ( ) ) { if ( TARGET_64BIT ) emit_insn ( gen_move_gpdi ( dest , src ) ) ; else emit_insn ( gen_move_gpsi ( dest , src ) ) ; return ; } if ( regno == HI_REGNUM ) { if ( REG_P ( dest ) ) { mips_emit_move ( temp , src ) ; if ( TARGET_64BIT ) emit_insn ( gen_mthisi_di ( gen_rtx_REG ( TImode , MD_REG_FIRST ) , temp , gen_rtx_REG ( DImode , LO_REGNUM ) ) ) ;

else emit_insn ( gen_mthisi_di ( gen_rtx_REG ( DImode , MD_REG_FIRST ) , temp , gen_rtx_REG ( SImode , LO_REGNUM ) ) ) ;


<s> gcc_assert ( insn && ! REG_NOTES ( insn ) ) ; if ( mips_epilogue . cfa_restores ) { RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; REG_NOTES ( insn ) = mips_epilogue . cfa_restores ; mips_epilogue . cfa_restores = <NUM_LIT> ; }


<s> unshifted_mask_reg = force_reg ( SImode , unshifted_mask ) ; mask = mips_force_binary ( SImode , ASHIFT , unshifted_mask_reg , shiftsi ) ; inverted_mask = gen_reg_rtx ( SImode ) ; emit_insn ( gen_rtx_SET ( VOIDmode , inverted_mask , gen_rtx_NOT ( SImode , mask ) ) ) ; if ( oldval != const0_rtx ) { oldval = convert_modes ( SImode , mode , oldval , true ) ; oldval = force_reg ( SImode , oldval ) ; oldval = mips_force_binary ( SImode , ASHIFT , oldval , shiftsi ) ; } if ( newval && newval != const0_rtx ) { newval = convert_modes ( SImode , mode , newval , true ) ; newval = force_reg ( SImode , newval ) ; newval = mips_force_binary ( SImode , ASHIFT , newval , shiftsi ) ; } if ( result ) res = gen_reg_rtx ( SImode ) ; if ( newval ) si_op = generator . fn_6 ( res , memsi , mask , inverted_mask , oldval , newval ) ;

else if ( result ) si_op = generator . fn_5 ( res , memsi , mask , inverted_mask , oldval ) ;


<s> return true ; } else if ( optimize ) { mips_block_move_loop ( dest , src , INTVAL ( length ) , MIPS_MAX_MOVE_BYTES_PER_LOOP_ITER ) ; return true ; } } return false ;


<s> gcc_assert ( avail != <NUM_LIT> ) ; if ( TARGET_MIPS16 && ! ( avail & BUILTIN_AVAIL_MIPS16 ) ) { error ( <STR_LIT> , DECL_NAME ( fndecl ) ) ; return ignore ? const0_rtx : CONST0_RTX ( mode ) ; } switch ( d -> builtin_type ) { case MIPS_BUILTIN_DIRECT : return mips_expand_builtin_direct ( d -> icode , target , exp , true ) ; case MIPS_BUILTIN_DIRECT_NO_TARGET : return mips_expand_builtin_direct ( d -> icode , target , exp , false ) ; case MIPS_BUILTIN_MOVT : case MIPS_BUILTIN_MOVF : return mips_expand_builtin_movtf ( d -> builtin_type , d -> icode , d -> cond , target , exp ) ; case MIPS_BUILTIN_CMP_ANY :


<s> error ( <STR_LIT> ) ; return has_target_p ? gen_reg_rtx ( ops [ <NUM_LIT> ] . mode ) : const0_rtx ; } return has_target_p ? ops [ <NUM_LIT> ] . value : const0_rtx ;


<s> rtx op0 = XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ; rtx op1 = XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ; mips_emit_compare ( & code , & op0 , & op1 , true ) ; cond = gen_rtx_fmt_ee ( code , GET_MODE ( op0 ) , op0 , op1 ) ; if ( ISA_HAS_SEL && INTEGRAL_MODE_P ( GET_MODE ( operands [ <NUM_LIT> ] ) ) && register_operand ( operands [ <NUM_LIT> ] , VOIDmode ) && register_operand ( operands [ <NUM_LIT> ] , VOIDmode ) ) {

machine_mode mode = GET_MODE ( operands [ <NUM_LIT> ] ) ;


<s> return ; } if ( mips16_cfun_returns_in_fpr_p ( ) ) mips16_copy_fpr_return_value ( ) ; frame = & cfun -> machine -> frame ; step1 = frame -> total_size ; step2 = <NUM_LIT> ; if ( ! frame_pointer_needed ) base = stack_pointer_rtx ; else { base = hard_frame_pointer_rtx ; step1 -= frame -> hard_frame_pointer_offset ; } mips_epilogue . cfa_reg = base ; mips_epilogue . cfa_offset = step1 ; mips_epilogue . cfa_restores = NULL_RTX ; if ( ( frame -> mask | frame -> fmask | frame -> acc_mask ) != <NUM_LIT> || frame -> num_cop0_regs > <NUM_LIT> ) { step2 = MIN ( step1 , MIPS_MAX_FIRST_STACK_STEP ) ; step1 -= step2 ; } adjust = GEN_INT ( step1 ) ; if ( ! SMALL_OPERAND ( step1 ) ) { mips_emit_move ( MIPS_EPILOGUE_TEMP ( Pmode ) , adjust ) ; adjust = MIPS_EPILOGUE_TEMP ( Pmode ) ; } mips_deallocate_stack ( base , adjust , step2 ) ; if ( TARGET_CALL_SAVED_GP && ! TARGET_EXPLICIT_RELOCS ) emit_insn ( gen_blockage ( ) ) ; mips_epilogue . cfa_restore_sp_offset = step2 ; if ( GENERATE_MIPS16E_SAVE_RESTORE && frame -> mask != <NUM_LIT> ) { unsigned int regno , mask ; HOST_WIDE_INT offset ; rtx restore ; mask = frame -> mask ; restore = mips16e_build_save_restore ( true , & mask , & offset , <NUM_LIT> , step2 ) ; for ( regno = GP_REG_FIRST ; regno < GP_REG_LAST ; regno ++ ) if ( BITSET_P ( mask , regno - GP_REG_FIRST ) ) { offset -= UNITS_PER_WORD ; mips_save_restore_reg ( word_mode , regno , offset , mips_restore_reg ) ; } mips_frame_barrier ( ) ; emit_insn ( restore ) ; mips_epilogue_set_cfa ( stack_pointer_rtx , <NUM_LIT> ) ; } else { mips_for_each_saved_acc ( frame -> total_size - step2 , mips_restore_reg ) ; mips_for_each_saved_gpr_and_fpr ( frame -> total_size - step2 , mips_restore_reg ) ; if ( cfun -> machine -> interrupt_handler_p ) { HOST_WIDE_INT offset ; rtx mem ; offset = frame -> cop0_sp_offset - ( frame -> total_size - step2 ) ; if ( ! cfun -> machine -> keep_interrupts_masked_p ) { mem = gen_frame_mem ( word_mode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) ; mips_emit_move ( gen_rtx_REG ( word_mode , K0_REG_NUM ) , mem ) ; offset -= UNITS_PER_WORD ;

emit_insn ( gen_cop0_move ( gen_rtx_REG ( SImode , COP0_EPC_REG_NUM ) , gen_rtx_REG ( SImode , K0_REG_NUM ) ) ) ;


<s> machine_mode mode ; if ( ! mips_get_unaligned_mem ( dest , width , bitpos , & left , & right ) ) return false ; mode = mode_for_size ( width , MODE_INT , <NUM_LIT> ) ; src = gen_lowpart ( mode , src ) ; if ( mode == DImode ) { emit_insn ( gen_mov_sdl ( dest , src , left ) ) ; emit_insn ( gen_mov_sdr ( copy_rtx ( dest ) , copy_rtx ( src ) , right ) ) ; }


<s> bool mips_expand_ins_as_unaligned_store ( rtx dest , rtx src , HOST_WIDE_INT width , HOST_WIDE_INT bitpos ) { rtx left , right ; machine_mode mode ; if ( ! mips_get_unaligned_mem ( dest , width , bitpos , & left , & right ) ) return false ; mode = mode_for_size ( width , MODE_INT , <NUM_LIT> ) ; src = gen_lowpart ( mode , src ) ; if ( mode == DImode ) {

emit_insn ( gen_mov_sdl ( dest , src , left ) ) ;


<s> offset = frame -> cop0_sp_offset - size ; if ( ! cfun -> machine -> keep_interrupts_masked_p ) { mem = gen_frame_mem ( word_mode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) ; mips_emit_move ( mem , gen_rtx_REG ( word_mode , K1_REG_NUM ) ) ; offset -= UNITS_PER_WORD ; } emit_insn ( gen_cop0_move ( gen_rtx_REG ( SImode , K1_REG_NUM ) , gen_rtx_REG ( SImode , COP0_STATUS_REG_NUM ) ) ) ; if ( ! cfun -> machine -> keep_interrupts_masked_p ) emit_insn ( gen_lshrsi3 ( gen_rtx_REG ( SImode , K0_REG_NUM ) , gen_rtx_REG ( SImode , K0_REG_NUM ) , GEN_INT ( CAUSE_IPL ) ) ) ; mem = gen_frame_mem ( word_mode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) ; mips_emit_move ( mem , gen_rtx_REG ( word_mode , K1_REG_NUM ) ) ; offset -= UNITS_PER_WORD ; if ( ! cfun -> machine -> keep_interrupts_masked_p ) emit_insn ( gen_insvsi ( gen_rtx_REG ( SImode , K1_REG_NUM ) , GEN_INT ( <NUM_LIT> ) , GEN_INT ( SR_IPL ) , gen_rtx_REG ( SImode , K0_REG_NUM ) ) ) ; if ( ! cfun -> machine -> keep_interrupts_masked_p ) emit_insn ( gen_insvsi ( gen_rtx_REG ( SImode , K1_REG_NUM ) , GEN_INT ( <NUM_LIT> ) , GEN_INT ( SR_EXL ) , gen_rtx_REG ( SImode , GP_REG_FIRST ) ) ) ; else emit_insn ( gen_insvsi ( gen_rtx_REG ( SImode , K1_REG_NUM ) , GEN_INT ( <NUM_LIT> ) , GEN_INT ( SR_IE ) , gen_rtx_REG ( SImode , GP_REG_FIRST ) ) ) ; } else { rtx insn = gen_add3_insn ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - step1 ) ) ; RTX_FRAME_RELATED_P ( emit_insn ( insn ) ) = <NUM_LIT> ; mips_frame_barrier ( ) ; size -= step1 ; } mips_for_each_saved_acc ( size , mips_save_reg ) ; mips_for_each_saved_gpr_and_fpr ( size , mips_save_reg ) ; } } if ( size > <NUM_LIT> ) { if ( SMALL_OPERAND ( - size ) ) RTX_FRAME_RELATED_P ( emit_insn ( gen_add3_insn ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - size ) ) ) ) = <NUM_LIT> ; else { mips_emit_move ( MIPS_PROLOGUE_TEMP ( Pmode ) , GEN_INT ( size ) ) ; if ( TARGET_MIPS16 ) { gcc_assert ( frame_pointer_needed ) ; mips_emit_move ( hard_frame_pointer_rtx , stack_pointer_rtx ) ; emit_insn ( gen_sub3_insn ( hard_frame_pointer_rtx , hard_frame_pointer_rtx , MIPS_PROLOGUE_TEMP ( Pmode ) ) ) ; mips_emit_move ( stack_pointer_rtx , hard_frame_pointer_rtx ) ; } else emit_insn ( gen_sub3_insn ( stack_pointer_rtx , stack_pointer_rtx , MIPS_PROLOGUE_TEMP ( Pmode ) ) ) ;

mips_set_frame_expr ( gen_rtx_SET ( VOIDmode , stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - size ) ) ) ;


<s> rtx tc , t0 , t1 , x ; tc = gen_reg_rtx ( vmode ) ; t0 = gen_reg_rtx ( vmode ) ; t1 = gen_reg_rtx ( vmode ) ; emit_insn ( cmp ( tc , op0 , op1 ) ) ; x = gen_rtx_AND ( vmode , tc , ( min_p ? op1 : op0 ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , t0 , x ) ) ; x = gen_rtx_NOT ( vmode , tc ) ;

x = gen_rtx_AND ( vmode , x , ( min_p ? op0 : op1 ) ) ;


<s> d . op1 = operands [ <NUM_LIT> ] ; sel = operands [ <NUM_LIT> ] ; d . vmode = GET_MODE ( d . target ) ; gcc_assert ( VECTOR_MODE_P ( d . vmode ) ) ; d . nelt = nelt = GET_MODE_NUNITS ( d . vmode ) ; d . testing_p = false ; for ( i = which = <NUM_LIT> ; i < nelt ; ++ i ) { rtx e = XVECEXP ( sel , <NUM_LIT> , i ) ; int ei = INTVAL ( e ) & ( <NUM_LIT> * nelt - <NUM_LIT> ) ; which |= ( ei < nelt ? <NUM_LIT> : <NUM_LIT> ) ; orig_perm [ i ] = ei ; }

memcpy ( d . perm , orig_perm , MAX_VECT_LEN ) ;


<s> if ( mips_expand_vselect_vconcat ( d -> target , d -> op0 , d -> op1 , d -> perm , nelt ) ) return true ; for ( i = <NUM_LIT> ; i < nelt ; ++ i ) perm2 [ i ] = ( d -> perm [ i ] + nelt ) & ( <NUM_LIT> * nelt - <NUM_LIT> ) ; if ( mips_expand_vselect_vconcat ( d -> target , d -> op1 , d -> op0 , perm2 , nelt ) ) return true ; } if ( mips_expand_vpc_loongson_even_odd ( d ) ) return true ; if ( mips_expand_vpc_loongson_pshufh ( d ) ) return true ; if ( mips_expand_vpc_loongson_bcast ( d ) ) return true ;


<s> case V2SImode : emit_insn ( gen_loongson_punpckhwd ( fold , last , last ) ) ; break ; case V4HImode : emit_insn ( gen_loongson_punpckhwd_hi ( fold , last , last ) ) ; next = gen_reg_rtx ( vmode ) ; emit_insn ( gen ( next , last , fold ) ) ; last = next ; fold = gen_reg_rtx ( vmode ) ; x = force_reg ( SImode , GEN_INT ( <NUM_LIT> ) ) ; emit_insn ( gen_vec_shr_v4hi ( fold , last , x ) ) ; break ; case V8QImode : emit_insn ( gen_loongson_punpckhwd_qi ( fold , last , last ) ) ; next = gen_reg_rtx ( vmode ) ; emit_insn ( gen ( next , last , fold ) ) ; last = next ; fold = gen_reg_rtx ( vmode ) ; x = force_reg ( SImode , GEN_INT ( <NUM_LIT> ) ) ; emit_insn ( gen_vec_shr_v8qi ( fold , last , x ) ) ; next = gen_reg_rtx ( vmode ) ; emit_insn ( gen ( next , last , fold ) ) ; last = next ; fold = gen_reg_rtx ( vmode ) ; x = force_reg ( SImode , GEN_INT ( <NUM_LIT> ) ) ; emit_insn ( gen_vec_shr_v8qi ( fold , last , x ) ) ; break ; default : gcc_unreachable ( ) ; }

emit_insn ( gen ( target , last , fold ) ) ;


<s> } zero = force_reg ( imode , CONST0_RTX ( imode ) ) ; if ( unsigned_p ) tmp = zero ; else { tmp = gen_reg_rtx ( imode ) ; emit_insn ( cmpgt ( tmp , zero , operands [ <NUM_LIT> ] ) ) ; } dest = gen_reg_rtx ( imode ) ; emit_insn ( unpack ( dest , operands [ <NUM_LIT> ] , tmp ) ) ; emit_move_insn ( operands [ <NUM_LIT> ] , gen_lowpart ( GET_MODE ( operands [ <NUM_LIT> ] ) , dest ) ) ;


<s> } memset ( & d , <NUM_LIT> , sizeof ( d ) ) ; d . target = target ; d . op0 = t1 ; d . op1 = t1 ; d . vmode = vmode ; d . nelt = GET_MODE_NUNITS ( vmode ) ;


<s> struct expand_vec_perm_d d ; rtx t1 ; bool ok ; if ( elt != const0_rtx ) elt = force_reg ( GET_MODE_INNER ( vmode ) , elt ) ; if ( REG_P ( elt ) ) elt = gen_lowpart ( DImode , elt ) ; t1 = gen_reg_rtx ( vmode ) ; switch ( vmode ) {


<s> for ( i = <NUM_LIT> ; i < nelt ; ++ i ) { if ( ! mips_constant_elt_p ( RTVEC_ELT ( vec , i ) ) ) RTVEC_ELT ( vec , i ) = const0_rtx ; } emit_move_insn ( target , gen_rtx_CONST_VECTOR ( vmode , vec ) ) ;


<s> if ( ! ( TARGET_HARD_FLOAT && TARGET_LOONGSON_VECTORS ) ) return false ; if ( d -> vmode != V8QImode ) return false ; if ( ! d -> one_vector_p ) return false ; elt = d -> perm [ <NUM_LIT> ] ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) if ( d -> perm [ i ] != elt ) return false ;


<s> else emit_insn ( gen_loongson_punpckhbh ( t0 , d -> op0 , d -> op0 ) ) ; elt &= <NUM_LIT> ; elt *= <NUM_LIT> ; t1 = gen_reg_rtx ( V4HImode ) ; emit_insn ( gen_loongson_pshufh ( t1 , gen_lowpart ( V4HImode , t0 ) , force_reg ( SImode , GEN_INT ( elt ) ) ) ) ;

emit_move_insn ( d -> target , gen_lowpart ( V8QImode , t1 ) ) ;


<s> if ( d -> testing_p ) return true ; t0 = gen_reg_rtx ( d -> vmode ) ; t1 = gen_reg_rtx ( d -> vmode ) ; switch ( d -> vmode ) { case V4HImode : emit_insn ( gen_loongson_punpckhhw ( t0 , d -> op0 , d -> op1 ) ) ; emit_insn ( gen_loongson_punpcklhw ( t1 , d -> op0 , d -> op1 ) ) ; if ( odd ) emit_insn ( gen_loongson_punpckhhw ( d -> target , t1 , t0 ) ) ; else emit_insn ( gen_loongson_punpcklhw ( d -> target , t1 , t0 ) ) ; break ; case V8QImode : t2 = gen_reg_rtx ( d -> vmode ) ; t3 = gen_reg_rtx ( d -> vmode ) ; emit_insn ( gen_loongson_punpckhbh ( t0 , d -> op0 , d -> op1 ) ) ; emit_insn ( gen_loongson_punpcklbh ( t1 , d -> op0 , d -> op1 ) ) ; emit_insn ( gen_loongson_punpckhbh ( t2 , t1 , t0 ) ) ; emit_insn ( gen_loongson_punpcklbh ( t3 , t1 , t0 ) ) ; if ( odd ) emit_insn ( gen_loongson_punpckhbh ( d -> target , t3 , t2 ) ) ;

else emit_insn ( gen_loongson_punpcklbh ( d -> target , t3 , t2 ) ) ;


<s> if ( d -> testing_p ) return true ; for ( i = mask = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) mask |= ( d -> perm [ i ] & <NUM_LIT> ) << ( i * <NUM_LIT> ) ; rmask = force_reg ( SImode , GEN_INT ( mask ) ) ; if ( d -> one_vector_p ) emit_insn ( gen_loongson_pshufh ( d -> target , d -> op0 , rmask ) ) ; else { rtx t0 , t1 , x , merge , rmerge [ <NUM_LIT> ] ;


<s> rtx t0 , t1 , x , merge , rmerge [ <NUM_LIT> ] ; t0 = gen_reg_rtx ( V4HImode ) ; t1 = gen_reg_rtx ( V4HImode ) ; emit_insn ( gen_loongson_pshufh ( t1 , d -> op1 , rmask ) ) ; emit_insn ( gen_loongson_pshufh ( t0 , d -> op0 , rmask ) ) ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) rmerge [ i ] = ( d -> perm [ i ] & <NUM_LIT> ? constm1_rtx : const0_rtx ) ; merge = gen_rtx_CONST_VECTOR ( V4HImode , gen_rtvec_v ( <NUM_LIT> , rmerge ) ) ; merge = force_reg ( V4HImode , merge ) ;

x = gen_rtx_AND ( V4HImode , merge , t1 ) ;


<s> rtx rperm [ MAX_VECT_LEN ] , x ; rtx_insn * insn ; unsigned i ; for ( i = <NUM_LIT> ; i < nelt ; ++ i ) rperm [ i ] = GEN_INT ( perm [ i ] ) ; x = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec_v ( nelt , rperm ) ) ; x = gen_rtx_VEC_SELECT ( GET_MODE ( target ) , op0 , x ) ; x = gen_rtx_SET ( VOIDmode , target , x ) ; insn = emit_insn ( x ) ;

if ( recog_memoized ( insn ) < <NUM_LIT> ) {


<s> rtx x ; v2mode = GET_MODE_2XWIDER_MODE ( GET_MODE ( op0 ) ) ; x = gen_rtx_VEC_CONCAT ( v2mode , op0 , op1 ) ;

return mips_expand_vselect ( target , x , perm , nelt ) ;


<s> static void mips_file_start ( void ) { default_file_start ( ) ; fprintf ( asm_out_file , <STR_LIT> , mips_mdebug_abi_name ( ) ) ; if ( mips_abi == ABI_EABI || mips_abi == ABI_O64 ) fprintf ( asm_out_file , <STR_LIT> <STR_LIT> , TARGET_LONG64 ? <NUM_LIT> : <NUM_LIT> ) ; if ( HAVE_AS_NAN || mips_nan != MIPS_IEEE_754_DEFAULT ) fprintf ( asm_out_file , <STR_LIT> , mips_nan == MIPS_IEEE_754_2008 ? <STR_LIT> : <STR_LIT> ) ; if ( TARGET_NO_FLOAT ) fputs ( <STR_LIT> , asm_out_file ) ; ; else if ( ! TARGET_HARD_FLOAT_ABI ) fputs ( <STR_LIT> , asm_out_file ) ; else if ( ! TARGET_DOUBLE_FLOAT ) fputs ( <STR_LIT> , asm_out_file ) ; else if ( TARGET_FLOATXX ) fputs ( <STR_LIT> , asm_out_file ) ; else if ( TARGET_FLOAT64 ) fputs ( <STR_LIT> , asm_out_file ) ;

else fputs ( <STR_LIT> , asm_out_file ) ;


<s> void mips_final_prescan_insn ( rtx_insn * insn , rtx * opvec , int noperands ) { if ( mips_need_noat_wrapper_p ( insn , opvec , noperands ) ) mips_push_asm_switch ( & mips_noat ) ;


<s> static bool mips_find_gp_ref ( bool * cache , bool ( * pred ) ( rtx_insn * ) ) { rtx_insn * insn ; if ( ! * cache ) { push_topmost_sequence ( ) ; for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) if ( USEFUL_INSN_P ( insn ) && pred ( insn ) ) { * cache = true ; break ; } pop_topmost_sequence ( ) ;


<s> rtx set ; set = gen_rtx_SET ( VOIDmode , mem , reg ) ; RTX_FRAME_RELATED_P ( set ) = <NUM_LIT> ;


<s> struct mips_arg_info info ; mips_get_arg_info ( & info , cum , mode , type , named ) ; if ( ! info . fpr_p ) cum -> gp_reg_found = true ; if ( cum -> arg_number < <NUM_LIT> && info . fpr_p ) cum -> fp_code += ( mode == SFmode ? <NUM_LIT> : <NUM_LIT> ) << ( cum -> arg_number * <NUM_LIT> ) ; if ( mips_abi != ABI_EABI || ! info . fpr_p ) cum -> num_gprs = info . reg_offset + info . reg_words ; else if ( info . reg_words > <NUM_LIT> ) cum -> num_fprs += MAX_FPRS_PER_FMT ;

if ( info . stack_words > <NUM_LIT> ) cum -> stack_words = info . stack_offset + info . stack_words ;


<s> static void mips_function_arg_advance ( cumulative_args_t cum_v , machine_mode mode , const_tree type , bool named ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; struct mips_arg_info info ; mips_get_arg_info ( & info , cum , mode , type , named ) ; if ( ! info . fpr_p ) cum -> gp_reg_found = true ; if ( cum -> arg_number < <NUM_LIT> && info . fpr_p ) cum -> fp_code += ( mode == SFmode ? <NUM_LIT> : <NUM_LIT> ) << ( cum -> arg_number * <NUM_LIT> ) ;

if ( mips_abi != ABI_EABI || ! info . fpr_p ) cum -> num_gprs = info . reg_offset + info . reg_words ;


<s> return mips_return_fpr_pair ( mode , TYPE_MODE ( TREE_TYPE ( fields [ <NUM_LIT> ] ) ) , int_byte_position ( fields [ <NUM_LIT> ] ) , TYPE_MODE ( TREE_TYPE ( fields [ <NUM_LIT> ] ) ) , int_byte_position ( fields [ <NUM_LIT> ] ) ) ; } if ( mips_return_in_msb ( valtype ) ) { HOST_WIDE_INT size = int_size_in_bytes ( valtype ) ; if ( size % UNITS_PER_WORD != <NUM_LIT> ) { size += UNITS_PER_WORD - size % UNITS_PER_WORD ; mode = mode_for_size ( size * BITS_PER_UNIT , MODE_INT , <NUM_LIT> ) ; } } if ( mips_abi != ABI_EABI && ! FLOAT_TYPE_P ( valtype ) ) return gen_rtx_REG ( mode , GP_RETURN ) ; } if ( ! TARGET_MIPS16 ) { if ( mode == TFmode ) return mips_return_fpr_pair ( mode , DImode , <NUM_LIT> , DImode , GET_MODE_SIZE ( mode ) / <NUM_LIT> ) ;

if ( mips_return_mode_in_fpr_p ( mode ) ) {


<s> static rtx mips_function_value_1 ( const_tree valtype , const_tree fn_decl_or_type , machine_mode mode ) { if ( valtype ) { tree fields [ <NUM_LIT> ] ; int unsigned_p ; const_tree func ; if ( fn_decl_or_type && DECL_P ( fn_decl_or_type ) ) func = fn_decl_or_type ; else func = NULL ; mode = TYPE_MODE ( valtype ) ; unsigned_p = TYPE_UNSIGNED ( valtype ) ; mode = promote_function_mode ( valtype , mode , & unsigned_p , func , <NUM_LIT> ) ; switch ( mips_fpr_return_fields ( valtype , fields ) ) { case <NUM_LIT> : return mips_return_fpr_single ( mode , TYPE_MODE ( TREE_TYPE ( fields [ <NUM_LIT> ] ) ) ) ; case <NUM_LIT> : return mips_return_fpr_pair ( mode , TYPE_MODE ( TREE_TYPE ( fields [ <NUM_LIT> ] ) ) , int_byte_position ( fields [ <NUM_LIT> ] ) , TYPE_MODE ( TREE_TYPE ( fields [ <NUM_LIT> ] ) ) , int_byte_position ( fields [ <NUM_LIT> ] ) ) ; } if ( mips_return_in_msb ( valtype ) ) { HOST_WIDE_INT size = int_size_in_bytes ( valtype ) ; if ( size % UNITS_PER_WORD != <NUM_LIT> ) { size += UNITS_PER_WORD - size % UNITS_PER_WORD ;

mode = mode_for_size ( size * BITS_PER_UNIT , MODE_INT , <NUM_LIT> ) ;


<s> static machine_mode mips_get_reg_raw_mode ( int regno ) {

if ( TARGET_FLOATXX && FP_REG_P ( regno ) ) return DFmode ;


<s> static machine_mode mips_get_reg_raw_mode ( int regno ) { if ( TARGET_FLOATXX && FP_REG_P ( regno ) ) return DFmode ;

return default_get_reg_raw_mode ( regno ) ;


<s> off = build3 ( COMPONENT_REF , TREE_TYPE ( f_foff ) , unshare_expr ( valist ) , f_foff , NULL_TREE ) ; rsize = UNITS_PER_HWFPVALUE ; osize = MAX ( GET_MODE_SIZE ( TYPE_MODE ( type ) ) , UNITS_PER_WORD ) ; } else { top = build3 ( COMPONENT_REF , TREE_TYPE ( f_gtop ) , unshare_expr ( valist ) , f_gtop , NULL_TREE ) ; off = build3 ( COMPONENT_REF , TREE_TYPE ( f_goff ) , unshare_expr ( valist ) , f_goff , NULL_TREE ) ; rsize = ( size + UNITS_PER_WORD - <NUM_LIT> ) & - UNITS_PER_WORD ; if ( rsize > UNITS_PER_WORD ) { t = build2 ( BIT_AND_EXPR , TREE_TYPE ( off ) , unshare_expr ( off ) , build_int_cst ( TREE_TYPE ( off ) , - rsize ) ) ; gimplify_assign ( unshare_expr ( off ) , t , pre_p ) ; } osize = rsize ; } t = build2 ( NE_EXPR , boolean_type_node , unshare_expr ( off ) , build_int_cst ( TREE_TYPE ( off ) , <NUM_LIT> ) ) ; addr = build3 ( COND_EXPR , ptr_type_node , t , NULL_TREE , NULL_TREE ) ; t = fold_convert ( TREE_TYPE ( off ) , build_int_cst ( NULL_TREE , rsize ) ) ; t = build2 ( POSTDECREMENT_EXPR , TREE_TYPE ( off ) , off , t ) ; t = fold_convert ( sizetype , t ) ; t = fold_build1 ( NEGATE_EXPR , sizetype , t ) ; t = fold_build_pointer_plus ( top , t ) ; if ( BYTES_BIG_ENDIAN && rsize > size ) t = fold_build_pointer_plus_hwi ( t , rsize - size ) ; COND_EXPR_THEN ( addr ) = t ; if ( osize > UNITS_PER_WORD ) { t = fold_build_pointer_plus_hwi ( unshare_expr ( ovfl ) , osize - <NUM_LIT> ) ; u = build_int_cst ( TREE_TYPE ( t ) , - osize ) ;

t = build2 ( BIT_AND_EXPR , TREE_TYPE ( t ) , t , u ) ;


<s> } t = build2 ( NE_EXPR , boolean_type_node , unshare_expr ( off ) , build_int_cst ( TREE_TYPE ( off ) , <NUM_LIT> ) ) ; addr = build3 ( COND_EXPR , ptr_type_node , t , NULL_TREE , NULL_TREE ) ; t = fold_convert ( TREE_TYPE ( off ) , build_int_cst ( NULL_TREE , rsize ) ) ; t = build2 ( POSTDECREMENT_EXPR , TREE_TYPE ( off ) , off , t ) ; t = fold_convert ( sizetype , t ) ; t = fold_build1 ( NEGATE_EXPR , sizetype , t ) ; t = fold_build_pointer_plus ( top , t ) ; if ( BYTES_BIG_ENDIAN && rsize > size ) t = fold_build_pointer_plus_hwi ( t , rsize - size ) ; COND_EXPR_THEN ( addr ) = t ; if ( osize > UNITS_PER_WORD ) { t = fold_build_pointer_plus_hwi ( unshare_expr ( ovfl ) , osize - <NUM_LIT> ) ; u = build_int_cst ( TREE_TYPE ( t ) , - osize ) ; t = build2 ( BIT_AND_EXPR , TREE_TYPE ( t ) , t , u ) ; align = build2 ( MODIFY_EXPR , TREE_TYPE ( ovfl ) , unshare_expr ( ovfl ) , t ) ; } else align = NULL ; u = fold_convert ( TREE_TYPE ( ovfl ) , build_int_cst ( NULL_TREE , osize ) ) ; t = build2 ( POSTINCREMENT_EXPR , TREE_TYPE ( ovfl ) , ovfl , u ) ; if ( BYTES_BIG_ENDIAN && osize > size ) t = fold_build_pointer_plus_hwi ( t , osize - size ) ; if ( align ) t = build2 ( COMPOUND_EXPR , TREE_TYPE ( t ) , align , t ) ; COND_EXPR_ELSE ( addr ) = t ; addr = fold_convert ( build_pointer_type ( type ) , addr ) ; addr = build_va_arg_indirect_ref ( addr ) ; }

if ( indirect_p ) addr = build_va_arg_indirect_ref ( addr ) ;


<s> static unsigned int mips_global_pointer ( void ) { unsigned int regno ; if ( ! TARGET_USE_GOT ) return GLOBAL_POINTER_REGNUM ; if ( mips_cfun_has_inflexible_gp_ref_p ( ) ) return GLOBAL_POINTER_REGNUM ; if ( TARGET_ABSOLUTE_JUMPS && ! mips_cfun_has_flexible_gp_ref_p ( ) ) return INVALID_REGNUM ; if ( TARGET_CALL_SAVED_GP && crtl -> is_leaf ) for ( regno = GP_REG_FIRST ; regno <= GP_REG_LAST ; regno ++ ) if ( ! df_regs_ever_live_p ( regno ) && call_really_used_regs [ regno ] && ! fixed_regs [ regno ] && regno != PIC_FUNCTION_ADDR_REGNUM ) return regno ; return GLOBAL_POINTER_REGNUM ;


<s> if ( mode == VOIDmode ) return choose_hard_reg_mode ( regno , nregs , false ) ; else return mode ;


<s> machine_mode mips_hard_regno_caller_save_mode ( unsigned int regno , unsigned int nregs , machine_mode mode ) {

if ( mode == VOIDmode ) return choose_hard_reg_mode ( regno , nregs , false ) ;


<s> if ( mode == CCV2mode ) return ( ISA_HAS_8CC && ST_REG_P ( regno ) && ( regno - ST_REG_FIRST ) % <NUM_LIT> == <NUM_LIT> ) ; if ( mode == CCV4mode ) return ( ISA_HAS_8CC && ST_REG_P ( regno ) && ( regno - ST_REG_FIRST ) % <NUM_LIT> == <NUM_LIT> ) ; if ( mode == CCmode ) return ISA_HAS_8CC ? ST_REG_P ( regno ) : regno == FPSW_REGNUM ; size = GET_MODE_SIZE ( mode ) ; mclass = GET_MODE_CLASS ( mode ) ; if ( GP_REG_P ( regno ) && mode != CCFmode ) return ( ( regno - GP_REG_FIRST ) & <NUM_LIT> ) == <NUM_LIT> || size <= UNITS_PER_WORD ;

if ( FP_REG_P ( regno ) && ( ( ( regno - FP_REG_FIRST ) % MAX_FPRS_PER_FMT ) == <NUM_LIT> || ( MIN_FPRS_PER_FMT == <NUM_LIT> && size <= UNITS_PER_FPREG ) ) ) {


<s> if ( mode == CCV2mode ) return ( ISA_HAS_8CC && ST_REG_P ( regno ) && ( regno - ST_REG_FIRST ) % <NUM_LIT> == <NUM_LIT> ) ; if ( mode == CCV4mode ) return ( ISA_HAS_8CC && ST_REG_P ( regno ) && ( regno - ST_REG_FIRST ) % <NUM_LIT> == <NUM_LIT> ) ; if ( mode == CCmode ) return ISA_HAS_8CC ? ST_REG_P ( regno ) : regno == FPSW_REGNUM ; size = GET_MODE_SIZE ( mode ) ; mclass = GET_MODE_CLASS ( mode ) ; if ( GP_REG_P ( regno ) && mode != CCFmode ) return ( ( regno - GP_REG_FIRST ) & <NUM_LIT> ) == <NUM_LIT> || size <= UNITS_PER_WORD ; if ( FP_REG_P ( regno ) && ( ( ( regno - FP_REG_FIRST ) % MAX_FPRS_PER_FMT ) == <NUM_LIT> || ( MIN_FPRS_PER_FMT == <NUM_LIT> && size <= UNITS_PER_FPREG ) ) ) { if ( TARGET_O32_FP64A_ABI && size <= <NUM_LIT> && ( regno & <NUM_LIT> ) != <NUM_LIT> ) return false ; if ( mode == CCFmode ) return ! ( TARGET_FLOATXX && ( regno & <NUM_LIT> ) != <NUM_LIT> ) ; if ( TARGET_LOONGSON_VECTORS && ( mode == V2SImode || mode == V4HImode || mode == V8QImode || mode == DImode ) ) return true ; if ( mclass == MODE_FLOAT || mclass == MODE_COMPLEX_FLOAT || mclass == MODE_VECTOR_FLOAT ) return size <= UNITS_PER_FPVALUE ; if ( mclass == MODE_INT ) return size >= MIN_UNITS_PER_WORD && size <= UNITS_PER_FPREG ; } if ( ACC_REG_P ( regno ) && ! VECTOR_MODE_P ( mode ) && ( INTEGRAL_MODE_P ( mode ) || ALL_FIXED_POINT_MODE_P ( mode ) ) ) { if ( MD_REG_P ( regno ) ) { if ( size <= UNITS_PER_WORD * <NUM_LIT> ) return regno == ( size <= UNITS_PER_WORD ? LO_REGNUM : MD_REG_FIRST ) ; } else { if ( size <= UNITS_PER_WORD ) return true ; if ( size <= UNITS_PER_WORD * <NUM_LIT> && ( ( regno - DSP_ACC_REG_FIRST ) & <NUM_LIT> ) == <NUM_LIT> ) return true ; } }

if ( ALL_COP_REG_P ( regno ) ) return mclass == MODE_INT && size <= UNITS_PER_WORD ;


<s> if ( ST_REG_P ( regno ) ) return ( GET_MODE_SIZE ( mode ) + <NUM_LIT> ) / <NUM_LIT> ;

if ( FP_REG_P ( regno ) ) return ( GET_MODE_SIZE ( mode ) + UNITS_PER_FPREG - <NUM_LIT> ) / UNITS_PER_FPREG ;


<s> unsigned int mips_hard_regno_nregs ( int regno , machine_mode mode ) { if ( ST_REG_P ( regno ) ) return ( GET_MODE_SIZE ( mode ) + <NUM_LIT> ) / <NUM_LIT> ; if ( FP_REG_P ( regno ) ) return ( GET_MODE_SIZE ( mode ) + UNITS_PER_FPREG - <NUM_LIT> ) / UNITS_PER_FPREG ; return ( GET_MODE_SIZE ( mode ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ;


<s> count = <NUM_LIT> ; if ( TARGET_CHECK_ZERO_DIV ) { if ( GENERATE_DIVIDE_TRAPS ) count ++ ;


if ( d -> avail ( ) ) mips_builtin_decls [ i ] = add_builtin_function ( d -> name , mips_build_function_type ( d -> function_type ) , i , BUILT_IN_MD , NULL , NULL ) ;


<s> const struct mips_builtin_description * d ; unsigned int i ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( mips_builtins ) ; i ++ ) {


<s> static bool mips_interrupt_extra_call_saved_reg_p ( unsigned int regno ) { if ( ( ISA_HAS_HILO || TARGET_DSP ) && MD_REG_P ( regno ) ) return true ; if ( TARGET_DSP && DSP_ACC_REG_P ( regno ) ) return true ; if ( GP_REG_P ( regno ) && ! cfun -> machine -> use_shadow_register_set_p ) { if ( regno == GP_REG_FIRST ) return false ; if ( KERNEL_REG_P ( regno ) ) return false ; if ( regno == STACK_POINTER_REGNUM ) return false ;

return call_really_used_regs [ regno ] ;


<s> return <NUM_LIT> ; case PROCESSOR_20KC : case PROCESSOR_R4130 : case PROCESSOR_R5400 : case PROCESSOR_R5500 : case PROCESSOR_R5900 : case PROCESSOR_R7000 : case PROCESSOR_R9000 : case PROCESSOR_OCTEON : case PROCESSOR_OCTEON2 : case PROCESSOR_OCTEON3 : return <NUM_LIT> ; case PROCESSOR_SB1 : case PROCESSOR_SB1A : return <NUM_LIT> ; case PROCESSOR_LOONGSON_2E : case PROCESSOR_LOONGSON_2F : case PROCESSOR_LOONGSON_3A :


<s> rtx base , offset ; if ( splittable_const_int_operand ( src , mode ) ) { mips_move_integer ( dest , dest , INTVAL ( src ) ) ; return ; } if ( mips_split_symbol ( dest , src , MAX_MACHINE_MODE , & src ) ) { emit_insn ( gen_rtx_SET ( VOIDmode , dest , src ) ) ; return ; } if ( mips_tls_symbol_p ( src ) ) { mips_emit_move ( dest , mips_legitimize_tls_address ( src ) ) ; return ; } split_const ( src , & base , & offset ) ;

if ( offset != const0_rtx && ( targetm . cannot_force_const_mem ( mode , src ) || ( ! TARGET_MIPS16 && can_create_pseudo_p ( ) ) ) ) {


<s> if ( splittable_const_int_operand ( src , mode ) ) { mips_move_integer ( dest , dest , INTVAL ( src ) ) ; return ; } if ( mips_split_symbol ( dest , src , MAX_MACHINE_MODE , & src ) ) { emit_insn ( gen_rtx_SET ( VOIDmode , dest , src ) ) ; return ; } if ( mips_tls_symbol_p ( src ) ) { mips_emit_move ( dest , mips_legitimize_tls_address ( src ) ) ; return ;


<s> } if ( CONSTANT_P ( src ) && ! move_operand ( src , mode ) ) { mips_legitimize_const_move ( mode , dest , src ) ; set_unique_reg_note ( get_last_insn ( ) , REG_EQUAL , copy_rtx ( src ) ) ; return true ; } return false ;


<s> if ( CONSTANT_P ( src ) && ! move_operand ( src , mode ) ) { mips_legitimize_const_move ( mode , dest , src ) ; set_unique_reg_note ( get_last_insn ( ) , REG_EQUAL , copy_rtx ( src ) ) ; return true ; }


<s> else emit_insn ( gen_load_gotsi ( tmp1 , pic_offset_table_rtx , tmp2 ) ) ; dest = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_add3_insn ( dest , tmp1 , tp ) ) ; break ; case TLS_MODEL_LOCAL_EXEC : tmp1 = mips_get_tp ( ) ; offset = mips_unspec_address ( loc , SYMBOL_TPREL ) ; if ( mips_split_p [ SYMBOL_TPREL ] ) { tmp2 = mips_unspec_offset_high ( NULL , tmp1 , loc , SYMBOL_TPREL ) ; dest = gen_rtx_LO_SUM ( Pmode , tmp2 , offset ) ; } else dest = expand_binop ( Pmode , add_optab , tmp1 , offset , <NUM_LIT> , <NUM_LIT> , OPTAB_DIRECT ) ; break ; default : gcc_unreachable ( ) ; } return dest ;


<s> emit_insn ( gen_rtx_SET ( VOIDmode , dest , addr ) ) ; return true ; } else { mips_emit_move ( dest , addr ) ; return false ; }


<s> if ( GET_CODE ( addr ) != PLUS || ! REG_P ( XEXP ( addr , <NUM_LIT> ) ) || ! REG_P ( XEXP ( addr , <NUM_LIT> ) ) ) return false ;

if ( ISA_HAS_LBX && mode == QImode ) return true ;


<s> static unsigned int mips_machine_reorg2 ( void ) { mips_reorg_process_insns ( ) ;

if ( ! TARGET_MIPS16 && TARGET_EXPLICIT_RELOCS && TUNE_MIPS4130 && TARGET_VR4130_ALIGN ) vr4130_align_insns ( ) ;


<s> return ( mode1 == mode2 || ( ! mips_mode_ok_for_mov_fmt_p ( mode1 ) && ! mips_mode_ok_for_mov_fmt_p ( mode2 ) ) ) ;


return ( mode1 == mode2 || ( ! mips_mode_ok_for_mov_fmt_p ( mode1 ) && ! mips_mode_ok_for_mov_fmt_p ( mode2 ) ) ) ;


<s> case DFmode : return TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT ; case V2SFmode : return TARGET_HARD_FLOAT && TARGET_PAIRED_SINGLE_FLOAT ;


<s> if ( TARGET_64BIT && mode == SImode && mode_rep == DImode ) return SIGN_EXTEND ;


<s> if ( TARGET_64BIT && mode == SImode && mode_rep == DImode ) return SIGN_EXTEND ; return UNKNOWN ;


<s> num_ops = mips_build_integer ( codes , value ) ; x = GEN_INT ( codes [ <NUM_LIT> ] . value ) ; for ( i = <NUM_LIT> ; i < num_ops ; i ++ ) { if ( ! can_create_pseudo_p ( ) ) { emit_insn ( gen_rtx_SET ( VOIDmode , temp , x ) ) ; x = temp ; } else x = force_reg ( mode , x ) ;

x = gen_rtx_fmt_ee ( codes [ i ] . code , mode , x , GEN_INT ( codes [ i ] . value ) ) ;


<s> if ( TUNE_LOONGSON_2EF || TUNE_LOONGSON_3A ) return <NUM_LIT> ; if ( TUNE_OCTEON ) return <NUM_LIT> ; if ( TUNE_P5600 ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> if ( TUNE_OCTEON ) return <NUM_LIT> ; if ( TUNE_P5600 ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> return mips_multi_members . safe_push ( empty ) ;


<s> static struct mips_multi_member * mips_multi_add ( void ) {


<s> struct mips_arg_info info ; if ( ( f & <NUM_LIT> ) == <NUM_LIT> ) mode = SFmode ; else if ( ( f & <NUM_LIT> ) == <NUM_LIT> ) mode = DFmode ; else gcc_unreachable ( ) ; mips_get_arg_info ( & info , & cum , mode , NULL , true ) ; gparg = mips_arg_regno ( & info , false ) ; fparg = mips_arg_regno ( & info , true ) ; if ( mode == SFmode ) mips_output_32bit_xfer ( direction , gparg , fparg ) ; else mips_output_64bit_xfer ( direction , gparg , fparg ) ;

mips_function_arg_advance ( pack_cumulative_args ( & cum ) , mode , NULL , true ) ;


<s> mips_init_cumulative_args ( & cum , NULL ) ; for ( f = ( unsigned int ) fp_code ; f != <NUM_LIT> ; f >>= <NUM_LIT> ) { machine_mode mode ; struct mips_arg_info info ; if ( ( f & <NUM_LIT> ) == <NUM_LIT> ) mode = SFmode ; else if ( ( f & <NUM_LIT> ) == <NUM_LIT> ) mode = DFmode ;


<s> return branch_if_true ; } mips_branch_likely = false ; rtx_code_label * not_taken = gen_label_rtx ( ) ; taken = operands [ <NUM_LIT> ] ; operands [ <NUM_LIT> ] = not_taken ; output_asm_insn ( branch_if_false , operands ) ; if ( final_sequence ) { if ( ! INSN_ANNULLED_BRANCH_P ( insn ) ) { final_scan_insn ( final_sequence -> insn ( <NUM_LIT> ) , asm_out_file , optimize , <NUM_LIT> , NULL ) ; final_sequence -> insn ( <NUM_LIT> ) -> set_deleted ( ) ; } else output_asm_insn ( <STR_LIT> , <NUM_LIT> ) ;


<s> s = division ; if ( TARGET_FIX_R4000 || TARGET_FIX_R4400 ) { output_asm_insn ( s , operands ) ; s = <STR_LIT> ; } if ( TARGET_CHECK_ZERO_DIV ) { if ( TARGET_MIPS16 ) { output_asm_insn ( s , operands ) ; s = <STR_LIT> ; } else if ( GENERATE_DIVIDE_TRAPS ) { if ( TUNE_74K ) output_asm_insn ( <STR_LIT> , operands ) ; else { output_asm_insn ( s , operands ) ; s = <STR_LIT> ; } } else { output_asm_insn ( <STR_LIT> , operands ) ;


<s> s = division ; if ( TARGET_FIX_R4000 || TARGET_FIX_R4400 ) { output_asm_insn ( s , operands ) ; s = <STR_LIT> ; } if ( TARGET_CHECK_ZERO_DIV ) { if ( TARGET_MIPS16 ) { output_asm_insn ( s , operands ) ; s = <STR_LIT> ; } else if ( GENERATE_DIVIDE_TRAPS ) { if ( TUNE_74K ) output_asm_insn ( <STR_LIT> , operands ) ; else { output_asm_insn ( s , operands ) ; s = <STR_LIT> ; } } else { output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( s , operands ) ;


<s> fnname = XSTR ( XEXP ( DECL_RTL ( current_function_decl ) , <NUM_LIT> ) , <NUM_LIT> ) ; mips_start_function_definition ( fnname , TARGET_MIPS16 ) ; if ( ! flag_inhibit_size_directive ) { const struct mips_frame_info * frame ; frame = & cfun -> machine -> frame ; fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , reg_names [ frame_pointer_needed ? HARD_FRAME_POINTER_REGNUM : STACK_POINTER_REGNUM ] , ( frame_pointer_needed ? frame -> total_size - frame -> hard_frame_pointer_offset : frame -> total_size ) , reg_names [ RETURN_ADDR_REGNUM ] , frame -> var_size , frame -> num_gp , frame -> num_fp , frame -> args_size , frame -> cprestore_size ) ; fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , frame -> mask , frame -> gp_save_offset ) ; fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , frame -> fmask , frame -> fp_save_offset ) ; } if ( mips_must_initialize_gp_p ( ) && mips_current_loadgp_style ( ) == LOADGP_OLDABI ) { if ( TARGET_MIPS16 ) { output_asm_insn ( <STR_LIT> , <NUM_LIT> ) ; output_asm_insn ( <STR_LIT> , <NUM_LIT> ) ; output_asm_insn ( <STR_LIT> , <NUM_LIT> ) ; output_asm_insn ( <STR_LIT> , <NUM_LIT> ) ; } else { mips_push_asm_switch ( & mips_noreorder ) ; output_asm_insn ( <STR_LIT> , <NUM_LIT> ) ; if ( ! cfun -> machine -> all_noreorder_p ) mips_pop_asm_switch ( & mips_noreorder ) ; else mips_push_asm_switch ( & mips_nomacro ) ; } } else if ( cfun -> machine -> all_noreorder_p ) { mips_push_asm_switch ( & mips_noreorder ) ;


<s> insn = emit_call_insn ( gen_sibcall_internal ( fnaddr , const0_rtx ) ) ; SIBLING_CALL_P ( insn ) = <NUM_LIT> ; } else { if ( TARGET_USE_PIC_FN_ADDR_REG && ! TARGET_MIPS16 && ! mips_dangerous_for_la25_p ( fnaddr ) ) temp1 = gen_rtx_REG ( Pmode , PIC_FUNCTION_ADDR_REGNUM ) ; mips_load_call_address ( MIPS_CALL_SIBCALL , temp1 , fnaddr ) ; if ( TARGET_USE_PIC_FN_ADDR_REG && REGNO ( temp1 ) != PIC_FUNCTION_ADDR_REGNUM ) mips_emit_move ( gen_rtx_REG ( Pmode , PIC_FUNCTION_ADDR_REGNUM ) , temp1 ) ; emit_jump_insn ( gen_indirect_jump ( temp1 ) ) ; } insn = get_insns ( ) ; split_all_insns_noflow ( ) ; mips16_lay_out_constants ( true ) ; shorten_branches ( insn ) ; final_start_function ( insn , file , <NUM_LIT> ) ; final ( insn , file , <NUM_LIT> ) ; final_end_function ( ) ;


<s> case GEU : branch [ ! inverted_p ] = MIPS_BRANCH ( <STR_LIT> , <STR_LIT> ) ; branch [ inverted_p ] = MIPS_BRANCH ( <STR_LIT> , <STR_LIT> ) ; break ; default : branch [ ! inverted_p ] = MIPS_BRANCH ( <STR_LIT> , <STR_LIT> ) ; branch [ inverted_p ] = MIPS_BRANCH ( <STR_LIT> , <STR_LIT> ) ; break ;


<s> ASM_GENERATE_INTERNAL_LABEL ( loop_lab , <STR_LIT> , labelno ) ; ASM_GENERATE_INTERNAL_LABEL ( end_lab , <STR_LIT> , labelno ++ ) ; ASM_OUTPUT_INTERNAL_LABEL ( asm_out_file , loop_lab ) ; xops [ <NUM_LIT> ] = reg1 ; xops [ <NUM_LIT> ] = reg2 ; strcpy ( tmp , <STR_LIT> ) ; output_asm_insn ( strcat ( tmp , & end_lab [ <NUM_LIT> ] ) , xops ) ; xops [ <NUM_LIT> ] = GEN_INT ( - PROBE_INTERVAL ) ; if ( TARGET_64BIT && TARGET_LONG64 ) output_asm_insn ( <STR_LIT> , xops ) ; else output_asm_insn ( <STR_LIT> , xops ) ; fprintf ( asm_out_file , <STR_LIT> ) ; assemble_name_raw ( asm_out_file , loop_lab ) ; fputc ( '\n' , asm_out_file ) ; if ( TARGET_64BIT ) output_asm_insn ( <STR_LIT> , xops ) ; else output_asm_insn ( <STR_LIT> , xops ) ;


<s> if ( type != <NUM_LIT> ? ( INTEGRAL_TYPE_P ( type ) || POINTER_TYPE_P ( type ) || FIXED_POINT_TYPE_P ( type ) ) : ( SCALAR_INT_MODE_P ( mode ) || ALL_SCALAR_FIXED_POINT_MODE_P ( mode ) ) ) return false ; if ( mips_abi == ABI_O64 ) if ( type != <NUM_LIT> ? FLOAT_TYPE_P ( type ) : GET_MODE_CLASS ( mode ) == MODE_FLOAT ) return false ; if ( mips_abi != ABI_EABI ) return true ; if ( mode != BLKmode ) return GET_MODE_BITSIZE ( mode ) >= PARM_BOUNDARY ; else return int_size_in_bytes ( type ) >= ( PARM_BOUNDARY / BITS_PER_UNIT ) ;


<s> bool mips_pad_arg_upward ( machine_mode mode , const_tree type ) { if ( ! BYTES_BIG_ENDIAN ) return true ; if ( type != <NUM_LIT> ? ( INTEGRAL_TYPE_P ( type ) || POINTER_TYPE_P ( type ) || FIXED_POINT_TYPE_P ( type ) ) : ( SCALAR_INT_MODE_P ( mode ) || ALL_SCALAR_FIXED_POINT_MODE_P ( mode ) ) ) return false ; if ( mips_abi == ABI_O64 ) if ( type != <NUM_LIT> ? FLOAT_TYPE_P ( type ) : GET_MODE_CLASS ( mode ) == MODE_FLOAT ) return false ;

if ( mips_abi != ABI_EABI ) return true ;


<s> bool mips_pad_reg_upward ( machine_mode mode , tree type ) { if ( type != <NUM_LIT> ? FLOAT_TYPE_P ( type ) : GET_MODE_CLASS ( mode ) == MODE_FLOAT ) return ! BYTES_BIG_ENDIAN ; return mips_pad_arg_upward ( mode , type ) ;


<s> if ( type != <NUM_LIT> ? FLOAT_TYPE_P ( type ) : GET_MODE_CLASS ( mode ) == MODE_FLOAT ) return ! BYTES_BIG_ENDIAN ; return mips_pad_arg_upward ( mode , type ) ;


<s> static bool mips_pass_by_reference ( cumulative_args_t cum ATTRIBUTE_UNUSED , machine_mode mode , const_tree type , bool named ATTRIBUTE_UNUSED ) { if ( mips_abi == ABI_EABI ) { int size ; if ( mode == DImode || mode == DFmode || mode == DQmode || mode == UDQmode || mode == DAmode || mode == UDAmode ) return <NUM_LIT> ; size = type ? int_size_in_bytes ( type ) : GET_MODE_SIZE ( mode ) ; return size == - <NUM_LIT> || size > UNITS_PER_WORD ; } else {

return targetm . calls . must_pass_in_stack ( mode , type ) ;


<s> static machine_mode mips_preferred_simd_mode ( machine_mode mode ATTRIBUTE_UNUSED ) { if ( TARGET_PAIRED_SINGLE_FLOAT && mode == SFmode ) return V2SFmode ;


<s> static void mips_prepare_pch_save ( void ) { mips_set_compression_mode ( <NUM_LIT> ) ; mips16_globals = <NUM_LIT> ;


<s> case 'd' : if ( CONST_INT_P ( op ) ) fprintf ( file , HOST_WIDE_INT_PRINT_DEC , INTVAL ( op ) ) ; else output_operand_lossage ( <STR_LIT> , letter ) ; break ; case 'm' : if ( CONST_INT_P ( op ) ) fprintf ( file , HOST_WIDE_INT_PRINT_DEC , INTVAL ( op ) - <NUM_LIT> ) ; else output_operand_lossage ( <STR_LIT> , letter ) ; break ; case 'y' : if ( CONST_INT_P ( op ) ) { int val = exact_log2 ( INTVAL ( op ) ) ; if ( val != - <NUM_LIT> ) fprintf ( file , <STR_LIT> , val ) ; else output_operand_lossage ( <STR_LIT> , letter ) ; } else output_operand_lossage ( <STR_LIT> , letter ) ; break ; case 'h' : if ( code == HIGH ) op = XEXP ( op , <NUM_LIT> ) ; mips_print_operand_reloc ( file , op , SYMBOL_CONTEXT_LEA , mips_hi_relocs ) ; break ; case 'R' : mips_print_operand_reloc ( file , op , SYMBOL_CONTEXT_LEA , mips_lo_relocs ) ; break ; case 'C' : mips_print_int_branch_condition ( file , code , letter ) ; break ; case 'N' : mips_print_int_branch_condition ( file , reverse_condition ( code ) , letter ) ; break ; case 'F' : mips_print_float_branch_condition ( file , code , letter ) ; break ; case 'W' : mips_print_float_branch_condition ( file , reverse_condition ( code ) , letter ) ; break ; case 'T' : case 't' : { int truth = ( code == NE ) == ( letter == 'T' ) ; fputc ( <STR_LIT> [ truth * <NUM_LIT> + ST_REG_P ( REGNO ( XEXP ( op , <NUM_LIT> ) ) ) ] , file ) ; } break ; case 'Y' : if ( code == CONST_INT && UINTVAL ( op ) < ARRAY_SIZE ( mips_fp_conditions ) ) fputs ( mips_fp_conditions [ UINTVAL ( op ) ] , file ) ; else output_operand_lossage ( <STR_LIT> , letter ) ; break ; case 'Z' : if ( ISA_HAS_8CC || ISA_HAS_CCF ) { mips_print_operand ( file , op , <NUM_LIT> ) ; fputc ( ',' , file ) ; } break ; case 'q' : if ( code == REG && MD_REG_P ( REGNO ( op ) ) ) fprintf ( file , <STR_LIT> ) ; else if ( code == REG && DSP_ACC_REG_P ( REGNO ( op ) ) ) fprintf ( file , <STR_LIT> , reg_names [ REGNO ( op ) ] [ <NUM_LIT> ] ) ; else output_operand_lossage ( <STR_LIT> , letter ) ; break ; default : switch ( code ) { case REG : { unsigned int regno = REGNO ( op ) ; if ( ( letter == 'M' && TARGET_LITTLE_ENDIAN ) || ( letter == 'L' && TARGET_BIG_ENDIAN ) || letter == 'D' ) regno ++ ; else if ( letter && letter != 'z' && letter != 'M' && letter != 'L' ) output_operand_lossage ( <STR_LIT> , letter ) ;

if ( COP0_REG_P ( regno ) ) fprintf ( file , <STR_LIT> , & reg_names [ regno ] [ <NUM_LIT> ] ) ;


<s> fprintf ( file , <STR_LIT> , reg_names [ REGNO ( addr . reg ) ] ) ; return ; case ADDRESS_LO_SUM : mips_print_operand_reloc ( file , addr . offset , SYMBOL_CONTEXT_MEM , mips_lo_relocs ) ; fprintf ( file , <STR_LIT> , reg_names [ REGNO ( addr . reg ) ] ) ; return ; case ADDRESS_CONST_INT :


<s> case ADDRESS_REG : mips_print_operand ( file , addr . offset , <NUM_LIT> ) ; fprintf ( file , <STR_LIT> , reg_names [ REGNO ( addr . reg ) ] ) ; return ; case ADDRESS_LO_SUM : mips_print_operand_reloc ( file , addr . offset , SYMBOL_CONTEXT_MEM , mips_lo_relocs ) ; fprintf ( file , <STR_LIT> , reg_names [ REGNO ( addr . reg ) ] ) ; return ; case ADDRESS_CONST_INT : output_addr_const ( file , x ) ; fprintf ( file , <STR_LIT> , reg_names [ GP_REG_FIRST ] ) ;


<s> if ( cmp && find_reg_note ( insn , REG_UNUSED , cmp ) ) cmp = <NUM_LIT> ; memmodel_attr = get_attr_sync_memmodel ( insn ) ; switch ( memmodel_attr ) { case <NUM_LIT> : model = MEMMODEL_ACQ_REL ; break ; case <NUM_LIT> : model = MEMMODEL_ACQUIRE ; break ; default : model = ( enum memmodel ) INTVAL ( operands [ memmodel_attr ] ) ; } mips_multi_start ( ) ; if ( need_atomic_barrier_p ( model , true ) ) { if ( required_oldval == <NUM_LIT> && TARGET_OCTEON ) { mips_multi_add_insn ( <STR_LIT> , NULL ) ; mips_multi_add_insn ( <STR_LIT> , NULL ) ; } else mips_multi_add_insn ( <STR_LIT> , NULL ) ; } mips_multi_add_label ( <STR_LIT> ) ; mips_multi_add_insn ( is_64bit_p ? <STR_LIT> : <STR_LIT> , oldval , mem , NULL ) ; if ( required_oldval ) { if ( inclusive_mask == <NUM_LIT> ) tmp1 = oldval ; else { gcc_assert ( oldval != at ) ; mips_multi_add_insn ( <STR_LIT> , at , oldval , inclusive_mask , NULL ) ; tmp1 = at ; } mips_multi_add_insn ( <STR_LIT> , tmp1 , required_oldval , NULL ) ; if ( cmp ) mips_multi_add_insn ( <STR_LIT> , cmp , NULL ) ; } if ( exclusive_mask == <NUM_LIT> ) tmp1 = const0_rtx ; else { gcc_assert ( oldval != at ) ; mips_multi_add_insn ( <STR_LIT> , at , oldval , exclusive_mask , NULL ) ; tmp1 = at ; } if ( insn1 == SYNC_INSN1_MOVE && ( tmp1 != const0_rtx || insn2 != SYNC_INSN2_NOP ) ) tmp2 = insn1_op2 ; else { mips_multi_add_insn ( mips_sync_insn1_template ( insn1 , is_64bit_p ) , newval , oldval , insn1_op2 , NULL ) ; tmp2 = newval ; }


<s> enum attr_sync_insn1 insn1 ; enum attr_sync_insn2 insn2 ; bool is_64bit_p ; int memmodel_attr ; enum memmodel model ; WHAT = mips_get_sync_operand ( operands , ( int ) get_attr_sync_ ## WHAT ( insn ) , \ DEFAULT ) READ_OPERAND ( mem , <NUM_LIT> ) ; gcc_assert ( mem ) ; is_64bit_p = ( GET_MODE_BITSIZE ( GET_MODE ( mem ) ) == <NUM_LIT> ) ; at = gen_rtx_REG ( GET_MODE ( mem ) , AT_REGNUM ) ; READ_OPERAND ( oldval , at ) ; READ_OPERAND ( cmp , <NUM_LIT> ) ; READ_OPERAND ( newval , at ) ; READ_OPERAND ( inclusive_mask , <NUM_LIT> ) ; READ_OPERAND ( exclusive_mask , <NUM_LIT> ) ; READ_OPERAND ( required_oldval , <NUM_LIT> ) ; READ_OPERAND ( insn1_op2 , <NUM_LIT> ) ; insn1 = get_attr_sync_insn1 ( insn ) ; insn2 = get_attr_sync_insn2 ( insn ) ; if ( cmp && find_reg_note ( insn , REG_UNUSED , cmp ) ) cmp = <NUM_LIT> ; memmodel_attr = get_attr_sync_memmodel ( insn ) ; switch ( memmodel_attr ) { case <NUM_LIT> : model = MEMMODEL_ACQ_REL ; break ; case <NUM_LIT> : model = MEMMODEL_ACQUIRE ; break ; default : model = ( enum memmodel ) INTVAL ( operands [ memmodel_attr ] ) ; } mips_multi_start ( ) ; if ( need_atomic_barrier_p ( model , true ) ) { if ( required_oldval == <NUM_LIT> && TARGET_OCTEON ) { mips_multi_add_insn ( <STR_LIT> , NULL ) ; mips_multi_add_insn ( <STR_LIT> , NULL ) ; } else mips_multi_add_insn ( <STR_LIT> , NULL ) ; } mips_multi_add_label ( <STR_LIT> ) ; mips_multi_add_insn ( is_64bit_p ? <STR_LIT> : <STR_LIT> , oldval , mem , NULL ) ; if ( required_oldval ) { if ( inclusive_mask == <NUM_LIT> ) tmp1 = oldval ; else { gcc_assert ( oldval != at ) ; mips_multi_add_insn ( <STR_LIT> , at , oldval , inclusive_mask , NULL ) ; tmp1 = at ; } mips_multi_add_insn ( <STR_LIT> , tmp1 , required_oldval , NULL ) ; if ( cmp ) mips_multi_add_insn ( <STR_LIT> , cmp , NULL ) ; } if ( exclusive_mask == <NUM_LIT> ) tmp1 = const0_rtx ; else { gcc_assert ( oldval != at ) ; mips_multi_add_insn ( <STR_LIT> , at , oldval , exclusive_mask , NULL ) ; tmp1 = at ; } if ( insn1 == SYNC_INSN1_MOVE && ( tmp1 != const0_rtx || insn2 != SYNC_INSN2_NOP ) ) tmp2 = insn1_op2 ; else { mips_multi_add_insn ( mips_sync_insn1_template ( insn1 , is_64bit_p ) , newval , oldval , insn1_op2 , NULL ) ; tmp2 = newval ; } if ( insn2 == SYNC_INSN2_NOP ) tmp3 = tmp2 ; else { mips_multi_add_insn ( mips_sync_insn2_template ( insn2 ) , newval , tmp2 , inclusive_mask , NULL ) ; tmp3 = newval ;


<s> if ( crtl -> profile ) cfun -> machine -> all_noreorder_p = false ; if ( TARGET_FIX_VR4120 || TARGET_FIX_RM7000 || TARGET_FIX_24K || TARGET_MIPS5900 ) cfun -> machine -> all_noreorder_p = false ; if ( TARGET_FIX_VR4130 && ! ISA_HAS_MACCHI ) cfun -> machine -> all_noreorder_p = false ; mips_offset_table htab ( <NUM_LIT> ) ; for ( insn = get_insns ( ) ; insn != <NUM_LIT> ; insn = NEXT_INSN ( insn ) ) FOR_EACH_SUBINSN ( subinsn , insn ) if ( USEFUL_INSN_P ( subinsn ) ) { rtx body = PATTERN ( insn ) ; int noperands = asm_noperands ( body ) ; if ( noperands >= <NUM_LIT> ) { rtx * ops = XALLOCAVEC ( rtx , noperands ) ; bool * used = XALLOCAVEC ( bool , noperands ) ; const char * string = decode_asm_operands ( body , ops , NULL , NULL , NULL , NULL ) ; get_referenced_operands ( string , used , noperands ) ; for ( int i = <NUM_LIT> ; i < noperands ; ++ i ) if ( used [ i ] ) mips_record_lo_sums ( ops [ i ] , & htab ) ; } else mips_record_lo_sums ( PATTERN ( subinsn ) , & htab ) ; } last_insn = <NUM_LIT> ; hilo_delay = <NUM_LIT> ; delayed_reg = <NUM_LIT> ; lo_reg = gen_rtx_REG ( SImode , LO_REGNUM ) ; for ( insn = get_insns ( ) ; insn != <NUM_LIT> ; insn = next_insn ) { next_insn = NEXT_INSN ( insn ) ; if ( USEFUL_INSN_P ( insn ) ) { if ( GET_CODE ( PATTERN ( insn ) ) == SEQUENCE ) { FOR_EACH_SUBINSN ( subinsn , insn ) if ( INSN_P ( subinsn ) ) { if ( mips_orphaned_high_part_p ( & htab , subinsn ) ) {


<s> static bool mips_return_in_memory ( const_tree type , const_tree fndecl ATTRIBUTE_UNUSED ) {

return ( TARGET_OLDABI ? TYPE_MODE ( type ) == BLKmode : ! IN_RANGE ( int_size_in_bytes ( type ) , <NUM_LIT> , <NUM_LIT> * UNITS_PER_WORD ) ) ;


<s> static bool mips_return_in_memory ( const_tree type , const_tree fndecl ATTRIBUTE_UNUSED ) { return ( TARGET_OLDABI ? TYPE_MODE ( type ) == BLKmode : ! IN_RANGE ( int_size_in_bytes ( type ) , <NUM_LIT> , <NUM_LIT> * UNITS_PER_WORD ) ) ;


<s> if ( ALL_FIXED_POINT_MODE_P ( mode ) && GET_MODE_PRECISION ( mode ) <= <NUM_LIT> * BITS_PER_WORD ) return true ;

return default_scalar_mode_supported_p ( mode ) ;


<s> if ( ( ( class1 == FP_REGS ) != ( class2 == FP_REGS ) ) && ( ( TARGET_FLOATXX && ! ISA_HAS_MXHC1 ) || TARGET_O32_FP64A_ABI ) && GET_MODE_SIZE ( mode ) >= <NUM_LIT> ) return true ;


<s> if ( mips_dangerous_for_la25_p ( x ) ) return reg_class_subset_p ( rclass , LEA_REGS ) ? NO_REGS : LEA_REGS ; regno = true_regnum ( x ) ; if ( TARGET_MIPS16 ) { if ( ! reg_class_subset_p ( rclass , M16_REGS ) && ! M16_REG_P ( regno ) ) return M16_REGS ; return NO_REGS ; } if ( reg_class_subset_p ( rclass , ACC_REGS ) ) return GP_REG_P ( regno ) ? NO_REGS : GR_REGS ; if ( ACC_REG_P ( regno ) ) return reg_class_subset_p ( rclass , GR_REGS ) ? NO_REGS : GR_REGS ; if ( reg_class_subset_p ( rclass , FP_REGS ) ) { if ( regno < <NUM_LIT> || ( MEM_P ( x ) && ( GET_MODE_SIZE ( mode ) == <NUM_LIT> || GET_MODE_SIZE ( mode ) == <NUM_LIT> ) ) ) return NO_REGS ; if ( GP_REG_P ( regno ) || x == CONST0_RTX ( mode ) ) return NO_REGS ;

if ( CONSTANT_P ( x ) && ! targetm . cannot_force_const_mem ( mode , x ) ) return NO_REGS ;


<s> CUMULATIVE_ARGS local_cum ; int gp_saved , fp_saved ; local_cum = * get_cumulative_args ( cum ) ; mips_function_arg_advance ( pack_cumulative_args ( & local_cum ) , mode , type , true ) ; gp_saved = MAX_ARGS_IN_REGISTERS - local_cum . num_gprs ; fp_saved = ( EABI_FLOAT_VARARGS_P ? MAX_ARGS_IN_REGISTERS - local_cum . num_fprs : <NUM_LIT> ) ; if ( ! no_rtl ) { if ( gp_saved > <NUM_LIT> ) { rtx ptr , mem ; ptr = plus_constant ( Pmode , virtual_incoming_args_rtx , REG_PARM_STACK_SPACE ( cfun -> decl ) - gp_saved * UNITS_PER_WORD ) ; mem = gen_frame_mem ( BLKmode , ptr ) ; set_mem_alias_set ( mem , get_varargs_alias_set ( ) ) ; move_block_from_reg ( local_cum . num_gprs + GP_ARG_FIRST , mem , gp_saved ) ; } if ( fp_saved > <NUM_LIT> ) { machine_mode mode ; int off , i ; off = ( - gp_saved * UNITS_PER_WORD ) & - UNITS_PER_FPVALUE ; off -= fp_saved * UNITS_PER_FPREG ; mode = TARGET_SINGLE_FLOAT ? SFmode : DFmode ; for ( i = local_cum . num_fprs ; i < MAX_ARGS_IN_REGISTERS ; i += MAX_FPRS_PER_FMT ) { rtx ptr , mem ; ptr = plus_constant ( Pmode , virtual_incoming_args_rtx , off ) ; mem = gen_frame_mem ( mode , ptr ) ; set_mem_alias_set ( mem , get_varargs_alias_set ( ) ) ; mips_emit_move ( mem , gen_rtx_REG ( mode , FP_ARG_FIRST + i ) ) ; off += UNITS_PER_HWFPVALUE ; } }


<s> target_flags |= MASK_MIPS16 ; target_flags &= ~ MASK_SYNCI ; flag_schedule_insns = <NUM_LIT> ; flag_reorder_blocks_and_partition = <NUM_LIT> ; flag_move_loop_invariants = <NUM_LIT> ; target_flags |= MASK_EXPLICIT_RELOCS ; targetm . min_anchor_offset = <NUM_LIT> ; targetm . max_anchor_offset = <NUM_LIT> ; targetm . const_anchor = <NUM_LIT> ; target_flags &= ~ MASK_RELAX_PIC_CALLS ; target_flags &= ~ MASK_FIX_R4000 ; if ( flag_pic && ! TARGET_OLDABI ) sorry ( <STR_LIT> ) ; if ( TARGET_XGOT ) sorry ( <STR_LIT> ) ; if ( TARGET_HARD_FLOAT_ABI && ! TARGET_OLDABI ) sorry ( <STR_LIT> ) ; } else { if ( TARGET_MICROMIPS ) target_flags &= ~ MASK_BRANCHLIKELY ; if ( TARGET_64BIT ) { if ( align_loops == <NUM_LIT> ) align_loops = <NUM_LIT> ; if ( align_jumps == <NUM_LIT> ) align_jumps = <NUM_LIT> ; if ( align_functions == <NUM_LIT> ) align_functions = <NUM_LIT> ; } targetm . min_anchor_offset = - <NUM_LIT> ; targetm . max_anchor_offset = <NUM_LIT> ; targetm . const_anchor = <NUM_LIT> ; } mips_init_relocs ( ) ; if ( compression_mode & MASK_MIPS16 ) { if ( ! mips16_globals ) mips16_globals = save_target_globals_default_opts ( ) ; else restore_target_globals ( mips16_globals ) ; } else restore_target_globals ( & default_target_globals ) ; old_compression_mode = compression_mode ;


<s> static unsigned HOST_WIDE_INT mips_shift_truncation_mask ( machine_mode mode ) { if ( TARGET_LOONGSON_VECTORS && VECTOR_MODE_P ( mode ) ) return <NUM_LIT> ;

return GET_MODE_BITSIZE ( mode ) - <NUM_LIT> ;


<s> state_transition ( curr_state , insn ) ; state -> insns_left = targetm . sched . variable_issue ( <NUM_LIT> , false , insn , state -> insns_left ) ; mips_sim_insn = insn ; note_stores ( PATTERN ( insn ) , mips_sim_record_set , state ) ;


<s> state_transition ( curr_state , insn ) ;

state -> insns_left = targetm . sched . variable_issue ( <NUM_LIT> , false , insn , state -> insns_left ) ;


<s> else if ( REG_P ( src ) && REGNO ( src ) == MD_REG_FIRST ) { mips_emit_move ( mips_subword ( dest , false ) , mips_subword ( src , false ) ) ; if ( TARGET_64BIT ) emit_insn ( gen_mfhidi_ti ( mips_subword ( dest , true ) , src ) ) ; else emit_insn ( gen_mfhisi_di ( mips_subword ( dest , true ) , src ) ) ; } else { low_dest = mips_subword ( dest , false ) ; if ( REG_P ( low_dest ) && reg_overlap_mentioned_p ( low_dest , src ) ) { mips_emit_move ( mips_subword ( dest , true ) , mips_subword ( src , true ) ) ; mips_emit_move ( low_dest , mips_subword ( src , false ) ) ; } else { mips_emit_move ( low_dest , mips_subword ( src , false ) ) ; mips_emit_move ( mips_subword ( dest , true ) , mips_subword ( src , true ) ) ;


<s> void mips_split_move_insn ( rtx dest , rtx src , rtx insn ) {

mips_split_move ( dest , src , mips_insn_split_type ( insn ) ) ;


<s> bool mips_split_move_p ( rtx dest , rtx src , enum mips_split_type split_type ) { if ( mips_mult_move_p ( dest , src , split_type ) ) return false ; unsigned int size = GET_MODE_SIZE ( GET_MODE ( dest ) ) ; if ( size == <NUM_LIT> && FP_REG_RTX_P ( src ) && FP_REG_RTX_P ( dest ) ) return false ; if ( size == <NUM_LIT> && ISA_HAS_LDC1_SDC1 ) { if ( FP_REG_RTX_P ( dest ) && MEM_P ( src ) ) return false ; if ( FP_REG_RTX_P ( src ) && MEM_P ( dest ) ) return false ; } return size > UNITS_PER_WORD ;


<s> tree addr , t , type_size , rounded_size , valist_tmp ; unsigned HOST_WIDE_INT align , boundary ; bool indirect ; indirect = pass_by_reference ( NULL , TYPE_MODE ( type ) , type , false ) ; if ( indirect ) type = build_pointer_type ( type ) ; align = PARM_BOUNDARY / BITS_PER_UNIT ; boundary = targetm . calls . function_arg_boundary ( TYPE_MODE ( type ) , type ) ; if ( boundary > MAX_SUPPORTED_STACK_ALIGNMENT ) boundary = MAX_SUPPORTED_STACK_ALIGNMENT ; boundary /= BITS_PER_UNIT ; valist_tmp = get_initialized_tmp_var ( valist , pre_p , NULL ) ; if ( boundary > align ) { t = build2 ( MODIFY_EXPR , TREE_TYPE ( valist ) , valist_tmp , fold_build_pointer_plus_hwi ( valist_tmp , boundary - <NUM_LIT> ) ) ;


<s> if ( GET_CODE ( PATTERN ( in_insn ) ) == UNSPEC_VOLATILE ) return false ;

return ! store_data_bypass_p ( out_insn , in_insn ) ;


<s> SWAP_INT ( call_used_regs [ i ] , call_used_regs [ i + <NUM_LIT> ] ) ; SWAP_INT ( call_really_used_regs [ i ] , call_really_used_regs [ i + <NUM_LIT> ] ) ;

SWAP_STRING ( reg_names [ i ] , reg_names [ i + <NUM_LIT> ] ) ;


<s> SWAP_INT ( fixed_regs [ i ] , fixed_regs [ i + <NUM_LIT> ] ) ; SWAP_INT ( call_used_regs [ i ] , call_used_regs [ i + <NUM_LIT> ] ) ; SWAP_INT ( call_really_used_regs [ i ] , call_really_used_regs [ i + <NUM_LIT> ] ) ;


<s> return mips_symbol_insns_1 ( type , mode ) * ( TARGET_MIPS16 ? <NUM_LIT> : <NUM_LIT> ) ;


<s> static int mips_symbol_insns ( enum mips_symbol_type type , machine_mode mode ) {

return mips_symbol_insns_1 ( type , mode ) * ( TARGET_MIPS16 ? <NUM_LIT> : <NUM_LIT> ) ;


<s> static void mips_trampoline_init ( rtx m_tramp , tree fndecl , rtx chain_value ) { rtx addr , end_addr , high , low , opcode , mem ; rtx trampoline [ <NUM_LIT> ] ; unsigned int i , j ; HOST_WIDE_INT end_addr_offset , static_chain_offset , target_function_offset ; end_addr_offset = mips_trampoline_code_size ( ) ; static_chain_offset = end_addr_offset ; target_function_offset = static_chain_offset + GET_MODE_SIZE ( ptr_mode ) ; addr = force_reg ( Pmode , XEXP ( m_tramp , <NUM_LIT> ) ) ; end_addr = mips_force_binary ( Pmode , PLUS , addr , GEN_INT ( end_addr_offset ) ) ; i = <NUM_LIT> ; if ( TARGET_USE_PIC_FN_ADDR_REG ) { trampoline [ i ++ ] = OP ( MIPS_LOAD_PTR ( AT_REGNUM , target_function_offset , PIC_FUNCTION_ADDR_REGNUM ) ) ; trampoline [ i ++ ] = OP ( MIPS_LOAD_PTR ( STATIC_CHAIN_REGNUM , static_chain_offset , PIC_FUNCTION_ADDR_REGNUM ) ) ; trampoline [ i ++ ] = OP ( MIPS_JR ( AT_REGNUM ) ) ; trampoline [ i ++ ] = OP ( MIPS_MOVE ( PIC_FUNCTION_ADDR_REGNUM , AT_REGNUM ) ) ; } else if ( ptr_mode == DImode ) { trampoline [ i ++ ] = OP ( MIPS_MOVE ( AT_REGNUM , RETURN_ADDR_REGNUM ) ) ;

trampoline [ i ++ ] = OP ( MIPS_BAL ( <NUM_LIT> ) ) ;


<s> i = <NUM_LIT> ; if ( TARGET_USE_PIC_FN_ADDR_REG ) { trampoline [ i ++ ] = OP ( MIPS_LOAD_PTR ( AT_REGNUM , target_function_offset , PIC_FUNCTION_ADDR_REGNUM ) ) ; trampoline [ i ++ ] = OP ( MIPS_LOAD_PTR ( STATIC_CHAIN_REGNUM , static_chain_offset , PIC_FUNCTION_ADDR_REGNUM ) ) ; trampoline [ i ++ ] = OP ( MIPS_JR ( AT_REGNUM ) ) ; trampoline [ i ++ ] = OP ( MIPS_MOVE ( PIC_FUNCTION_ADDR_REGNUM , AT_REGNUM ) ) ; } else if ( ptr_mode == DImode ) { trampoline [ i ++ ] = OP ( MIPS_MOVE ( AT_REGNUM , RETURN_ADDR_REGNUM ) ) ; trampoline [ i ++ ] = OP ( MIPS_BAL ( <NUM_LIT> ) ) ; trampoline [ i ++ ] = OP ( MIPS_NOP ) ; trampoline [ i ++ ] = OP ( MIPS_LOAD_PTR ( PIC_FUNCTION_ADDR_REGNUM , target_function_offset - <NUM_LIT> , RETURN_ADDR_REGNUM ) ) ; trampoline [ i ++ ] = OP ( MIPS_LOAD_PTR ( STATIC_CHAIN_REGNUM , static_chain_offset - <NUM_LIT> , RETURN_ADDR_REGNUM ) ) ; trampoline [ i ++ ] = OP ( MIPS_JR ( PIC_FUNCTION_ADDR_REGNUM ) ) ; trampoline [ i ++ ] = OP ( MIPS_MOVE ( RETURN_ADDR_REGNUM , AT_REGNUM ) ) ; } else { high = expand_simple_binop ( SImode , PLUS , end_addr , GEN_INT ( <NUM_LIT> ) , NULL , false , OPTAB_WIDEN ) ; high = expand_simple_binop ( SImode , LSHIFTRT , high , GEN_INT ( <NUM_LIT> ) , NULL , false , OPTAB_WIDEN ) ; low = convert_to_mode ( SImode , gen_lowpart ( HImode , end_addr ) , true ) ; opcode = OP ( MIPS_LUI ( AT_REGNUM , <NUM_LIT> ) ) ; trampoline [ i ++ ] = expand_simple_binop ( SImode , IOR , opcode , high , NULL , false , OPTAB_WIDEN ) ; opcode = OP ( MIPS_LOAD_PTR ( PIC_FUNCTION_ADDR_REGNUM , target_function_offset - end_addr_offset , AT_REGNUM ) ) ; trampoline [ i ++ ] = expand_simple_binop ( SImode , IOR , opcode , low , NULL , false , OPTAB_WIDEN ) ; if ( ! ISA_HAS_LOAD_DELAY ) trampoline [ i ++ ] = OP ( MIPS_JR ( PIC_FUNCTION_ADDR_REGNUM ) ) ; opcode = OP ( MIPS_LOAD_PTR ( STATIC_CHAIN_REGNUM , static_chain_offset - end_addr_offset , AT_REGNUM ) ) ; trampoline [ i ++ ] = expand_simple_binop ( SImode , IOR , opcode , low , NULL , false , OPTAB_WIDEN ) ; if ( ISA_HAS_LOAD_DELAY ) { trampoline [ i ++ ] = OP ( MIPS_JR ( PIC_FUNCTION_ADDR_REGNUM ) ) ; trampoline [ i ++ ] = OP ( MIPS_NOP ) ; } } for ( j = <NUM_LIT> ; j < i ; j ++ ) { mem = adjust_address ( m_tramp , SImode , j * GET_MODE_SIZE ( SImode ) ) ; mips_emit_move ( mem , trampoline [ j ] ) ; } mem = adjust_address ( m_tramp , ptr_mode , static_chain_offset ) ; mips_emit_move ( mem , chain_value ) ;


<s> if ( mips_symbol_insns ( symbol_type , mode ) == <NUM_LIT> ) return false ; if ( mips_lo_relocs [ symbol_type ] == NULL ) return false ; if ( GET_MODE_SIZE ( mode ) > UNITS_PER_WORD && GET_MODE_BITSIZE ( mode ) > GET_MODE_ALIGNMENT ( mode ) ) return false ; return true ;


<s> if ( mips_lo_relocs [ symbol_type ] == NULL ) return false ; if ( GET_MODE_SIZE ( mode ) > UNITS_PER_WORD && GET_MODE_BITSIZE ( mode ) > GET_MODE_ALIGNMENT ( mode ) ) return false ;


<s> if ( ! const_arith_operand ( x , Pmode ) ) return false ; if ( GET_MODE_SIZE ( mode ) > UNITS_PER_WORD && ! SMALL_OPERAND ( INTVAL ( x ) + GET_MODE_SIZE ( mode ) - UNITS_PER_WORD ) ) return false ; return true ;


<s> return mode == SImode || ( TARGET_64BIT && mode == DImode ) ;


<s> unsigned int i , nelt , which ; bool ret ; d . vmode = vmode ; d . nelt = nelt = GET_MODE_NUNITS ( d . vmode ) ; d . testing_p = true ; memcpy ( d . perm , sel , nelt ) ; for ( i = which = <NUM_LIT> ; i < nelt ; ++ i ) {


<s> static bool mips_vector_mode_supported_p ( machine_mode mode ) { switch ( mode ) { case V2SFmode : return TARGET_PAIRED_SINGLE_FLOAT ; case V2HImode : case V4QImode : case V2HQmode : case V2UHQmode :


<s> case V2HAmode : case V2UHAmode : case V4QQmode : case V4UQQmode : return TARGET_DSP ; case V2SImode : case V4HImode : case V8QImode : return TARGET_LOONGSON_VECTORS ;


<s> return ; } calculate_dominance_info ( CDI_DOMINATORS ) ; protected_bbs = sbitmap_alloc ( last_basic_block_for_fn ( cfun ) ) ; bitmap_clear ( protected_bbs ) ; rev_post_order = XNEWVEC ( int , last_basic_block_for_fn ( cfun ) ) ; n = pre_and_rev_post_order_compute ( NULL , rev_post_order , false ) ; for ( i = <NUM_LIT> ; i < n ; i ++ ) { bb = BASIC_BLOCK_FOR_FN ( cfun , rev_post_order [ i ] ) ; if ( r10k_protected_bb_p ( bb , protected_bbs ) ) unprotected_region = NULL_RTX ; else unprotected_region = pc_rtx ; end = NEXT_INSN ( BB_END ( bb ) ) ; for ( insn = BB_HEAD ( bb ) ; insn != end ; insn = NEXT_INSN ( insn ) ) { if ( unprotected_region && USEFUL_INSN_P ( insn ) ) { if ( recog_memoized ( insn ) == CODE_FOR_mips_cache ) unprotected_region = NULL_RTX ; else { if ( unprotected_region == pc_rtx ) unprotected_region = insn ; if ( r10k_needs_protection_p ( insn ) ) {

emit_insn_before ( gen_r10k_cache_barrier ( ) , unprotected_region ) ;


<s> sorry ( <STR_LIT> , <STR_LIT> ) ; return ; } calculate_dominance_info ( CDI_DOMINATORS ) ; protected_bbs = sbitmap_alloc ( last_basic_block_for_fn ( cfun ) ) ; bitmap_clear ( protected_bbs ) ; rev_post_order = XNEWVEC ( int , last_basic_block_for_fn ( cfun ) ) ; n = pre_and_rev_post_order_compute ( NULL , rev_post_order , false ) ; for ( i = <NUM_LIT> ; i < n ; i ++ ) { bb = BASIC_BLOCK_FOR_FN ( cfun , rev_post_order [ i ] ) ; if ( r10k_protected_bb_p ( bb , protected_bbs ) ) unprotected_region = NULL_RTX ; else unprotected_region = pc_rtx ; end = NEXT_INSN ( BB_END ( bb ) ) ;

for ( insn = BB_HEAD ( bb ) ; insn != end ; insn = NEXT_INSN ( insn ) ) {


<s> note_stores ( PATTERN ( insn ) , r10k_needs_protection_p_store , & insn ) ; return insn == NULL_RTX ; } return r10k_needs_protection_p_1 ( PATTERN ( insn ) , insn ) ;


<s> static bool r10k_needs_protection_p ( rtx_insn * insn ) { if ( CALL_P ( insn ) ) return r10k_needs_protection_p_call ( PATTERN ( insn ) ) ; if ( mips_r10k_cache_barrier == R10K_CACHE_BARRIER_STORE ) {

note_stores ( PATTERN ( insn ) , r10k_needs_protection_p_store , & insn ) ;


<s> tree inner , var_offset ; machine_mode mode ; int unsigned_p , volatile_p ; inner = get_inner_reference ( expr , & bitsize , & bitoffset , & var_offset , & mode , & unsigned_p , & volatile_p , false ) ; if ( ! DECL_P ( inner ) || ! DECL_SIZE_UNIT ( inner ) || var_offset ) return false ; offset += bitoffset / BITS_PER_UNIT ; return offset < tree_to_uhwi ( DECL_SIZE_UNIT ( inner ) ) ;


<s> } XVECEXP ( pattern , <NUM_LIT> , j ) = set ; } if ( umips_swm_encoding [ i ] >> <NUM_LIT> ) { HOST_WIDE_INT offset = this_offset + j * UNITS_PER_WORD ; * mask &= ~ ( <NUM_LIT> << <NUM_LIT> ) ; mem = gen_frame_mem ( SImode , plus_constant ( Pmode , this_base , offset ) ) ; reg = gen_rtx_REG ( SImode , <NUM_LIT> ) ; if ( fn == mips_save_reg ) set = mips_frame_set ( mem , reg ) ; else { set = gen_rtx_SET ( VOIDmode , reg , mem ) ; mips_add_cfa_restore ( reg ) ; } XVECEXP ( pattern , <NUM_LIT> , j ) = set ; } pattern = emit_insn ( pattern ) ; if ( fn == mips_save_reg ) RTX_FRAME_RELATED_P ( pattern ) = <NUM_LIT> ;


<s> if ( state . insns_left != state . issue_rate && ! CALL_P ( subinsn ) ) { if ( subinsn == SEQ_BEGIN ( insn ) && aligned_p ) { gcc_assert ( last2 ) ; emit_insn_after ( gen_nop ( ) , last2 ) ; aligned_p = false ; } else if ( subinsn != SEQ_BEGIN ( insn ) && ! aligned_p ) { gcc_assert ( last ) ; emit_insn_after ( gen_nop ( ) , last ) ; aligned_p = true ; } } mips_sim_issue_insn ( & state , subinsn ) ; } mips_sim_finish_insn ( & state , insn ) ; length = get_attr_length ( insn ) ; if ( length > <NUM_LIT> ) { if ( NONJUMP_INSN_P ( SEQ_BEGIN ( insn ) ) && ( recog_memoized ( insn ) < <NUM_LIT> || length >= <NUM_LIT> ) ) { next = emit_insn_after ( gen_align ( GEN_INT ( <NUM_LIT> ) ) , insn ) ; next = NEXT_INSN ( next ) ; mips_sim_next_cycle ( & state ) ; aligned_p = true ; } else if ( length & <NUM_LIT> ) aligned_p = ! aligned_p ; last2 = last ; last = insn ; }

if ( LABEL_P ( insn ) && label_to_alignment ( insn ) >= <NUM_LIT> ) aligned_p = true ;


<s> last2 = <NUM_LIT> ; aligned_p = true ; mips_sim_init ( & state , alloca ( state_size ( ) ) ) ; for ( insn = get_insns ( ) ; insn != <NUM_LIT> ; insn = next ) { unsigned int length ; next = NEXT_INSN ( insn ) ; vr4130_avoid_branch_rt_conflict ( insn ) ; length = get_attr_length ( insn ) ; if ( length > <NUM_LIT> && USEFUL_INSN_P ( insn ) ) FOR_EACH_SUBINSN ( subinsn , insn ) { mips_sim_wait_insn ( & state , subinsn ) ; if ( state . insns_left != state . issue_rate && ! CALL_P ( subinsn ) ) { if ( subinsn == SEQ_BEGIN ( insn ) && aligned_p ) { gcc_assert ( last2 ) ; emit_insn_after ( gen_nop ( ) , last2 ) ; aligned_p = false ; } else if ( subinsn != SEQ_BEGIN ( insn ) && ! aligned_p ) { gcc_assert ( last ) ; emit_insn_after ( gen_nop ( ) , last ) ; aligned_p = true ; } } mips_sim_issue_insn ( & state , subinsn ) ; }

mips_sim_finish_insn ( & state , insn ) ;