<s> default_elf_asm_output_external ( file , decl , name ) ; if ( TREE_SYMBOL_REFERENCED ( DECL_ASSEMBLER_NAME ( decl ) ) ) { if ( ! TARGET_EXPLICIT_RELOCS && mips_in_small_data_p ( decl ) ) { fputs ( <STR_LIT> , file ) ; assemble_name ( file , name ) ; fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , int_size_in_bytes ( TREE_TYPE ( decl ) ) ) ; } }


<s> void mips_output_external ( FILE * file , tree decl , const char * name ) { default_elf_asm_output_external ( file , decl , name ) ; if ( TREE_SYMBOL_REFERENCED ( DECL_ASSEMBLER_NAME ( decl ) ) ) { if ( ! TARGET_EXPLICIT_RELOCS && mips_in_small_data_p ( decl ) ) { fputs ( <STR_LIT> , file ) ;


<s> else if ( write_symbols == DBX_DEBUG ) return ; else if ( name != current_function_file && strcmp ( name , current_function_file ) != <NUM_LIT> ) { num_source_filenames += <NUM_LIT> ; current_function_file = name ; fprintf ( stream , <STR_LIT> , num_source_filenames ) ; output_quoted_string ( stream , name ) ;


<s> } else if ( write_symbols == DBX_DEBUG ) return ; else if ( name != current_function_file && strcmp ( name , current_function_file ) != <NUM_LIT> ) { num_source_filenames += <NUM_LIT> ; current_function_file = name ; fprintf ( stream , <STR_LIT> , num_source_filenames ) ;

output_quoted_string ( stream , name ) ;


<s> mips_pop_asm_switch ( & mips_noreorder ) ; } fnname = XSTR ( XEXP ( DECL_RTL ( current_function_decl ) , <NUM_LIT> ) , <NUM_LIT> ) ; mips_end_function_definition ( fnname ) ;


<s> mips_pop_asm_switch ( & mips_noreorder ) ; }

fnname = XSTR ( XEXP ( DECL_RTL ( current_function_decl ) , <NUM_LIT> ) , <NUM_LIT> ) ;


<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 ) {


<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 ) ;


<s> } else { if ( Pmode == DImode ) output_asm_insn ( <STR_LIT> , & target ) ; else output_asm_insn ( <STR_LIT> , & target ) ;


<s> emit_note ( NOTE_INSN_PROLOGUE_END ) ; fnaddr = XEXP ( DECL_RTL ( function ) , <NUM_LIT> ) ; use_sibcall_p = ( mips_function_ok_for_sibcall ( function , NULL ) && const_call_insn_operand ( fnaddr , Pmode ) ) ; if ( ! use_sibcall_p && ( mips_got_symbol_type_p ( mips_classify_symbol ( fnaddr , SYMBOL_CONTEXT_LEA ) ) ) ) { cfun -> machine -> global_pointer = TARGET_CALL_SAVED_GP ? <NUM_LIT> : GLOBAL_POINTER_REGNUM ; cfun -> machine -> must_initialize_gp_p = true ; SET_REGNO ( pic_offset_table_rtx , cfun -> machine -> global_pointer ) ; mips_emit_loadgp ( ) ; } temp1 = gen_rtx_REG ( Pmode , <NUM_LIT> ) ; temp2 = gen_rtx_REG ( Pmode , <NUM_LIT> ) ; if ( aggregate_value_p ( TREE_TYPE ( TREE_TYPE ( function ) ) , function ) ) this_rtx = gen_rtx_REG ( Pmode , GP_ARG_FIRST + <NUM_LIT> ) ; else this_rtx = gen_rtx_REG ( Pmode , GP_ARG_FIRST ) ; if ( delta != <NUM_LIT> ) { rtx offset = GEN_INT ( delta ) ; if ( ! SMALL_OPERAND ( delta ) ) { mips_emit_move ( temp1 , offset ) ; offset = temp1 ; } emit_insn ( gen_add3_insn ( this_rtx , this_rtx , offset ) ) ; } if ( vcall_offset != <NUM_LIT> ) { rtx addr ; mips_emit_move ( temp1 , gen_rtx_MEM ( Pmode , this_rtx ) ) ; addr = mips_add_offset ( temp2 , temp1 , vcall_offset ) ; mips_emit_move ( temp1 , gen_rtx_MEM ( Pmode , addr ) ) ; emit_insn ( gen_add3_insn ( this_rtx , this_rtx , temp1 ) ) ; } if ( use_sibcall_p ) { 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 ) ; assemble_start_function ( thunk_fndecl , fnname ) ; final_start_function ( insn , file , <NUM_LIT> ) ;


<s> use_sibcall_p = ( mips_function_ok_for_sibcall ( function , NULL ) && const_call_insn_operand ( fnaddr , Pmode ) ) ; if ( ! use_sibcall_p && ( mips_got_symbol_type_p ( mips_classify_symbol ( fnaddr , SYMBOL_CONTEXT_LEA ) ) ) ) { cfun -> machine -> global_pointer = TARGET_CALL_SAVED_GP ? <NUM_LIT> : GLOBAL_POINTER_REGNUM ; cfun -> machine -> must_initialize_gp_p = true ; SET_REGNO ( pic_offset_table_rtx , cfun -> machine -> global_pointer ) ; mips_emit_loadgp ( ) ; } temp1 = gen_rtx_REG ( Pmode , <NUM_LIT> ) ; temp2 = gen_rtx_REG ( Pmode , <NUM_LIT> ) ; if ( aggregate_value_p ( TREE_TYPE ( TREE_TYPE ( function ) ) , function ) ) this_rtx = gen_rtx_REG ( Pmode , GP_ARG_FIRST + <NUM_LIT> ) ; else this_rtx = gen_rtx_REG ( Pmode , GP_ARG_FIRST ) ; if ( delta != <NUM_LIT> ) { rtx offset = GEN_INT ( delta ) ; if ( ! SMALL_OPERAND ( delta ) ) { mips_emit_move ( temp1 , offset ) ; offset = temp1 ; } emit_insn ( gen_add3_insn ( this_rtx , this_rtx , offset ) ) ; } if ( vcall_offset != <NUM_LIT> ) { rtx addr ; mips_emit_move ( temp1 , gen_rtx_MEM ( Pmode , this_rtx ) ) ;


<s> case LT : case LTU : inverted_p = ! inverted_p ; case GE : case GEU : branch [ ! inverted_p ] = MIPS_BRANCH_C ( <STR_LIT> , <STR_LIT> ) ; branch [ inverted_p ] = <STR_LIT> ; break ; default : gcc_unreachable ( ) ; } } else { branch [ ! inverted_p ] = MIPS_BRANCH_C ( <STR_LIT> , <STR_LIT> ) ; branch [ inverted_p ] = MIPS_BRANCH_C ( <STR_LIT> , <STR_LIT> ) ; } } else { switch ( GET_CODE ( operands [ <NUM_LIT> ] ) ) { case LEU : inverted_p = ! inverted_p ; case GTU : if ( TARGET_CB_MAYBE ) { branch [ ! inverted_p ] = MIPS_BRANCH_C ( <STR_LIT> , <STR_LIT> ) ; branch [ inverted_p ] = MIPS_BRANCH_C ( <STR_LIT> , <STR_LIT> ) ; } else { branch [ ! inverted_p ] = MIPS_BRANCH ( <STR_LIT> , <STR_LIT> ) ; branch [ inverted_p ] = MIPS_BRANCH ( <STR_LIT> , <STR_LIT> ) ; } break ; case LTU : inverted_p = ! inverted_p ; case GEU : if ( TARGET_CB_MAYBE ) { branch [ ! inverted_p ] = MIPS_BRANCH_C ( <STR_LIT> , <STR_LIT> ) ; branch [ inverted_p ] = <STR_LIT> ; } else { branch [ ! inverted_p ] = MIPS_BRANCH ( <STR_LIT> , <STR_LIT> ) ; branch [ inverted_p ] = MIPS_BRANCH ( <STR_LIT> , <STR_LIT> ) ; } break ; default : if ( TARGET_CB_MAYBE ) { branch [ ! inverted_p ] = MIPS_BRANCH_C ( <STR_LIT> , <STR_LIT> ) ; branch [ inverted_p ] = MIPS_BRANCH_C ( <STR_LIT> , <STR_LIT> ) ; }


<s> if ( TARGET_64BIT && TARGET_LONG64 ) output_asm_insn ( <STR_LIT> , xops ) ; else output_asm_insn ( <STR_LIT> , xops ) ; xops [ <NUM_LIT> ] = reg2 ; strcpy ( tmp , <STR_LIT> ) ; output_asm_insn ( strcat ( tmp , & loop_lab [ <NUM_LIT> ] ) , xops ) ;

if ( TARGET_64BIT ) output_asm_insn ( <STR_LIT> , xops ) ;


<s> mips_start_ll_sc_sync_block ( ) ; output_asm_insn ( <STR_LIT> , <NUM_LIT> ) ;


<s> mips_push_asm_switch ( & mips_noat ) ; mips_start_ll_sc_sync_block ( ) ; mips_multi_write ( ) ; mips_end_ll_sc_sync_block ( ) ; mips_pop_asm_switch ( & mips_noat ) ; mips_pop_asm_switch ( & mips_nomacro ) ; mips_pop_asm_switch ( & mips_noreorder ) ; return <STR_LIT> ;


<s> mips_end_ll_sc_sync_block ( ) ; mips_pop_asm_switch ( & mips_noat ) ; mips_pop_asm_switch ( & mips_nomacro ) ; mips_pop_asm_switch ( & mips_noreorder ) ; return <STR_LIT> ;


<s> switch ( type ) { case SYMBOL_DTPREL : return Pmode == SImode ? <STR_LIT> : <STR_LIT> ; case SYMBOL_TPREL : return Pmode == SImode ? <STR_LIT> : <STR_LIT> ;


<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_function_arg_padding ( mode , type ) == PAD_UPWARD ;


<s> rtx mips_pic_base_register ( rtx temp ) { if ( ! TARGET_MIPS16 ) return pic_offset_table_rtx ; if ( currently_expanding_to_rtl ) return mips16_gp_pseudo_reg ( ) ;

if ( can_create_pseudo_p ( ) ) temp = gen_reg_rtx ( Pmode ) ;


<s> return symbol ; } note = find_reg_equal_equiv_note ( def_insn ) ; if ( note && GET_CODE ( XEXP ( note , <NUM_LIT> ) ) == SYMBOL_REF ) return XEXP ( note , <NUM_LIT> ) ; if ( recurse_p && REG_P ( src ) ) return mips_find_pic_call_symbol ( def_insn , src , false ) ; }


<s> void mips_pop_asm_switch ( struct mips_asm_switch * asm_switch ) {


if ( asm_switch -> nesting_level == <NUM_LIT> ) fprintf ( asm_out_file , <STR_LIT> , prefix , asm_switch -> name , suffix ) ;


<s> static reg_class_t mips_preferred_reload_class ( rtx x , reg_class_t rclass ) { if ( mips_dangerous_for_la25_p ( x ) && reg_class_subset_p ( LEA_REGS , rclass ) ) return LEA_REGS ;

if ( reg_class_subset_p ( FP_REGS , rclass ) && mips_mode_ok_for_mov_fmt_p ( GET_MODE ( x ) ) ) return FP_REGS ;


<s> case E_QImode : return V16QImode ; case E_HImode : return V8HImode ; case E_SImode : return V4SImode ; case E_DImode : return V2DImode ; case E_SFmode : return V4SFmode ;


<s> if ( INTVAL ( locality ) <= <NUM_LIT> ) return GEN_INT ( INTVAL ( write ) + <NUM_LIT> ) ;

if ( INTVAL ( locality ) <= <NUM_LIT> ) return write ;


<s> static void mips_prepare_builtin_arg ( struct expand_operand * op , tree exp , unsigned int argno ) { tree arg ; rtx value ;


<s> rtx value ; arg = CALL_EXPR_ARG ( exp , argno ) ; value = expand_normal ( arg ) ; create_input_operand ( op , value , TYPE_MODE ( TREE_TYPE ( arg ) ) ) ;


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


<s> static void mips_print_float_branch_condition ( FILE * file , enum rtx_code code , int letter ) { switch ( code ) { case EQ : if ( ISA_HAS_CCF ) fputs ( <STR_LIT> , file ) ;


<s> case EQ : case NE : case GT : case GE : case LT : case LE : case GTU : case GEU :


<s> switch ( code ) { case EQ : case NE : case GT : case GE : case LT : case LE : case GTU : case GEU : case LTU : case LEU : fputs ( GET_RTX_NAME ( code ) , file ) ; break ; default : output_operand_lossage ( <STR_LIT> , letter ) ; break ;


<s> 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 ] ) ; return ; case ADDRESS_SYMBOLIC : output_addr_const ( file , mips_strip_unspec_address ( x ) ) ; return ; }


<s> return mips_print_operand_punct [ code ] ;


<s> const char * p ; symbol_type = mips_classify_symbolic_expression ( op , context ) ; gcc_assert ( relocs [ symbol_type ] ) ; fputs ( relocs [ symbol_type ] , file ) ;

output_addr_const ( file , mips_strip_unspec_address ( op ) ) ;


<s> const char * p ; symbol_type = mips_classify_symbolic_expression ( op , context ) ; gcc_assert ( relocs [ symbol_type ] ) ; fputs ( relocs [ symbol_type ] , file ) ; output_addr_const ( file , mips_strip_unspec_address ( op ) ) ;

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


<s> mips_multi_add_insn ( <STR_LIT> , gp , base , <NUM_LIT> ) ; base = gp ; offset = CONST_LOW_PART ( offset ) ; } intop = GEN_INT ( offset ) ; if ( ISA_HAS_LOAD_DELAY ) mips_multi_add_insn ( <STR_LIT> , gp , intop , base , <NUM_LIT> ) ; else mips_multi_add_insn ( <STR_LIT> , gp , intop , base , <NUM_LIT> ) ; } if ( ISA_HAS_LOAD_DELAY ) mips_multi_add_insn ( <STR_LIT> , target , gp , <NUM_LIT> ) ; else mips_multi_add_insn ( <STR_LIT> , target , gp , <NUM_LIT> ) ; mips_multi_add_insn ( <STR_LIT> , target , <NUM_LIT> ) ; break ;


<s> mips_multi_start ( ) ; switch ( mips_abi ) { case ABI_N32 : mips_multi_add_insn ( <STR_LIT> , target , <NUM_LIT> ) ; mips_multi_add_insn ( <STR_LIT> , target , <NUM_LIT> ) ; break ; case ABI_64 : mips_multi_add_insn ( <STR_LIT> , target , <NUM_LIT> ) ; mips_multi_add_insn ( <STR_LIT> , target , <NUM_LIT> ) ; break ; default : gp = pic_offset_table_rtx ; if ( mips_cfun_has_cprestore_slot_p ( ) ) { gp = gen_rtx_REG ( Pmode , AT_REGNUM ) ; mips_get_cprestore_base_and_offset ( & base , & offset , true ) ; if ( ! SMALL_OPERAND ( offset ) ) { intop = GEN_INT ( CONST_HIGH_PART ( offset ) ) ; mips_multi_add_insn ( <STR_LIT> , gp , intop , <NUM_LIT> ) ; mips_multi_add_insn ( <STR_LIT> , gp , base , <NUM_LIT> ) ;


<s> break ; default : model = memmodel_from_int ( 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 ; } if ( TARGET_CB_NEVER ) mips_multi_add_insn ( <STR_LIT> , tmp1 , required_oldval , NULL ) ; if ( cmp ) mips_multi_add_insn ( <STR_LIT> , cmp , NULL ) ; if ( TARGET_CB_MAYBE && required_oldval == const0_rtx ) mips_multi_add_insn ( <STR_LIT> , tmp1 , NULL ) ; else if ( TARGET_CB_MAYBE ) mips_multi_add_insn ( <STR_LIT> , tmp1 , required_oldval , 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 ; } tmp3_insn = mips_multi_last_index ( ) ; if ( tmp1 == const0_rtx || tmp3 == const0_rtx ) { mips_multi_set_operand ( tmp3_insn , <NUM_LIT> , at ) ; tmp3 = at ; } else { gcc_assert ( tmp1 != tmp3 ) ; mips_multi_add_insn ( <STR_LIT> , at , tmp1 , tmp3 , NULL ) ;


<s> static machine_mode mips_promote_function_mode ( const_tree type ATTRIBUTE_UNUSED , machine_mode mode , int * punsignedp ATTRIBUTE_UNUSED , const_tree fntype ATTRIBUTE_UNUSED , int for_return ATTRIBUTE_UNUSED ) { int unsignedp ; if ( type != NULL_TREE ) return promote_mode ( type , mode , punsignedp ) ; unsignedp = * punsignedp ;

PROMOTE_MODE ( mode , unsignedp , type ) ;


<s> int unsignedp ; if ( type != NULL_TREE ) return promote_mode ( type , mode , punsignedp ) ;


<s> static void mips_promote_ready ( rtx_insn * * ready , int lower , int higher ) { rtx_insn * new_head ;


<s> if ( asm_switch -> nesting_level == <NUM_LIT> ) fprintf ( asm_out_file , <STR_LIT> , prefix , asm_switch -> name , suffix ) ; asm_switch -> nesting_level ++ ;


<s> subrtx_iterator :: array_type array ; FOR_EACH_SUBRTX ( iter , array , x , NONCONST ) if ( GET_CODE ( * iter ) == LO_SUM ) mips_lo_sum_offset_lookup ( htab , XEXP ( * iter , <NUM_LIT> ) , INSERT ) ;


<s> static bool mips_refers_to_kernel_reg_p ( const_rtx x ) { subrtx_iterator :: array_type array ; FOR_EACH_SUBRTX ( iter , array , x , NONCONST ) if ( REG_P ( * iter ) && KERNEL_REG_P ( REGNO ( * iter ) ) ) return true ;


<s> subrtx_iterator :: array_type array ;

FOR_EACH_SUBRTX ( iter , array , x , NONCONST ) if ( REG_P ( * iter ) && KERNEL_REG_P ( REGNO ( * iter ) ) ) return true ;


<s> to = mips_canonicalize_move_class ( to ) ; if ( from == FP_REGS ) { if ( to == FP_REGS && mips_mode_ok_for_mov_fmt_p ( mode ) ) return <NUM_LIT> ; } dregs = TARGET_MIPS16 ? M16_REGS : GENERAL_REGS ;

if ( from == dregs ) return mips_move_from_gpr_cost ( to ) ;


<s> dregs = TARGET_MIPS16 ? M16_REGS : GENERAL_REGS ; if ( from == dregs ) return mips_move_from_gpr_cost ( to ) ; if ( to == dregs ) return mips_move_to_gpr_cost ( from ) ;

cost1 = mips_move_to_gpr_cost ( from ) ;


<s> if ( TARGET_MIPS16 && TEST_HARD_REG_BIT ( reg_class_contents [ M16_REGS ] , hard_regno ) ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> static int mips_register_priority ( int hard_regno ) {


<s> regno = reg_renumber [ regno ] ; } if ( regno == ARG_POINTER_REGNUM || regno == FRAME_POINTER_REGNUM ) return true ;

if ( TARGET_MIPS16 && regno == STACK_POINTER_REGNUM ) return GET_MODE_SIZE ( mode ) == <NUM_LIT> || GET_MODE_SIZE ( mode ) == <NUM_LIT> ;


<s> mips16_lay_out_constants ( true ) ; if ( mips_cfg_in_reorg ( ) ) { mips_df_reorg ( ) ;


<s> if ( mips_cfg_in_reorg ( ) ) { mips_df_reorg ( ) ;


<s> CLEAR_HARD_REG_SET ( sets ) ; note_stores ( prev , record_hard_reg_sets , & sets ) ; if ( ! hard_reg_set_intersect_p ( delay_sets , uses ) && hard_reg_set_intersect_p ( uses , sets ) ) { next_insn = mips_break_sequence ( insn ) ; continue ; } } if ( mips_orphaned_high_part_p ( & htab , SEQ_END ( insn ) ) ) { next_insn = mips_break_sequence ( insn ) ; continue ; } } FOR_EACH_SUBINSN ( subinsn , insn ) if ( INSN_P ( subinsn ) ) { if ( mips_orphaned_high_part_p ( & htab , subinsn ) ) { PATTERN ( subinsn ) = gen_nop ( ) ; INSN_CODE ( subinsn ) = CODE_FOR_nop ; } mips_avoid_hazard ( last_insn , subinsn , & hilo_delay , & delayed_reg , lo_reg , & fs_delay ) ; } last_insn = insn ; } else { if ( mips_orphaned_high_part_p ( & htab , insn ) ) delete_insn ( insn ) ; else if ( recog_memoized ( insn ) == CODE_FOR_r10k_cache_barrier && last_insn && JUMP_P ( SEQ_BEGIN ( last_insn ) ) && INSN_ANNULLED_BRANCH_P ( SEQ_BEGIN ( last_insn ) ) ) delete_insn ( insn ) ; else { mips_avoid_hazard ( last_insn , insn , & hilo_delay , & delayed_reg , lo_reg , & fs_delay ) ; if ( fs_delay || ( TUNE_P6600 && TARGET_CB_MAYBE && mips_classify_branch_p6600 ( insn ) == UC_BALC ) ) { rtx_insn * next = next_active_insn ( insn ) ; if ( next && USEFUL_INSN_P ( next ) && GET_CODE ( PATTERN ( next ) ) == SEQUENCE && mips_breakable_sequence_p ( next ) ) { last_insn = insn ; next_insn = mips_break_sequence ( next ) ; continue ; } } last_insn = insn ; }


<s> return ; } if ( TARGET_MIPS16 ) { mips_emit_move ( temp , mips_cprestore_slot ( temp , true ) ) ; mips_emit_move ( pic_offset_table_rtx , temp ) ; }

else mips_emit_move ( pic_offset_table_rtx , mips_cprestore_slot ( temp , true ) ) ;


<s> return ; } if ( TARGET_MIPS16 ) { mips_emit_move ( temp , mips_cprestore_slot ( temp , true ) ) ;

mips_emit_move ( pic_offset_table_rtx , temp ) ;


<s> mips_emit_save_slot_move ( reg , mem , MIPS_EPILOGUE_TEMP ( GET_MODE ( reg ) ) ) ; if ( REGNO ( reg ) == REGNO ( mips_epilogue . cfa_reg ) ) mips_epilogue_set_cfa ( stack_pointer_rtx , mips_epilogue . cfa_restore_sp_offset ) ;


<s> } else mips_add_cfa_restore ( reg ) ; mips_emit_save_slot_move ( reg , mem , MIPS_EPILOGUE_TEMP ( GET_MODE ( reg ) ) ) ; if ( REGNO ( reg ) == REGNO ( mips_epilogue . cfa_reg ) ) mips_epilogue_set_cfa ( stack_pointer_rtx , mips_epilogue . cfa_restore_sp_offset ) ;


<s> if ( count != <NUM_LIT> ) return const0_rtx ;

return get_hard_reg_initial_val ( Pmode , RETURN_ADDR_REGNUM ) ;


<s> x = gen_rtx_REG ( value_mode , FP_RETURN ) ; if ( type_mode != value_mode ) {

x = gen_rtx_EXPR_LIST ( VOIDmode , x , const0_rtx ) ;


<s> x = gen_rtx_EXPR_LIST ( VOIDmode , x , const0_rtx ) ; x = gen_rtx_PARALLEL ( type_mode , gen_rtvec ( <NUM_LIT> , x ) ) ; }


<s> static bool mips_return_in_memory ( const_tree type , const_tree fndecl ATTRIBUTE_UNUSED ) { if ( TARGET_OLDABI ) return ( VECTOR_FLOAT_TYPE_P ( type ) || TYPE_MODE ( type ) == BLKmode ) ;

return ( ! IN_RANGE ( int_size_in_bytes ( type ) , <NUM_LIT> , <NUM_LIT> * UNITS_PER_WORD ) ) ;


<s> if ( TARGET_OLDABI ) return ( VECTOR_FLOAT_TYPE_P ( type ) || TYPE_MODE ( type ) == BLKmode ) ;


<s> bool has_cxx_zero_width_bf = false ; bool has_cxx17_empty_base = false ; return ( mips_fpr_return_fields ( valtype , fields , & has_cxx_zero_width_bf , & has_cxx17_empty_base ) == <NUM_LIT> || has_cxx_zero_width_bf ) ;


return ( mips_fpr_return_fields ( valtype , fields , & has_cxx_zero_width_bf , & has_cxx17_empty_base ) == <NUM_LIT> || has_cxx_zero_width_bf ) ;


<s> return ( ( GET_MODE_CLASS ( mode ) == MODE_FLOAT || mode == V2SFmode || GET_MODE_CLASS ( mode ) == MODE_COMPLEX_FLOAT ) && GET_MODE_UNIT_SIZE ( mode ) <= UNITS_PER_HWFPVALUE ) ;


<s> case NE : case LTGT : case ORDERED : * code = reverse_condition_maybe_unordered ( * code ) ; return true ; default :


<s> case ORDERED : * code = reverse_condition_maybe_unordered ( * code ) ;


<s> mips_rewrite_small_data_1 ( & pattern , SYMBOL_CONTEXT_LEA ) ; return pattern ;


<s> rtx * loc = * iter ; if ( MEM_P ( * loc ) ) { mips_rewrite_small_data_1 ( & XEXP ( * loc , <NUM_LIT> ) , SYMBOL_CONTEXT_MEM ) ; iter . skip_subrtxes ( ) ; } else if ( mips_rewrite_small_data_p ( * loc , context ) ) { * loc = gen_rtx_LO_SUM ( Pmode , pic_offset_table_rtx , * loc ) ; iter . skip_subrtxes ( ) ; } else if ( GET_CODE ( * loc ) == LO_SUM ) iter . skip_subrtxes ( ) ;


return ( mips_lo_relocs [ SYMBOL_GP_RELATIVE ] && ! mips_split_p [ SYMBOL_GP_RELATIVE ] && mips_symbolic_constant_p ( x , context , & symbol_type ) && symbol_type == SYMBOL_GP_RELATIVE ) ;


<s> static bool mips_rtx_constant_in_small_data_p ( machine_mode mode ) { return ( ! TARGET_EMBEDDED_DATA && TARGET_LOCAL_SDATA && GET_MODE_SIZE ( mode ) <= mips_small_data_threshold ) ;


<s> gcc_assert ( gp == pic_offset_table_rtx ) ; emit_insn ( PMODE_INSN ( gen_cprestore , ( mem , offset ) ) ) ;


<s> mips_emit_move_or_split ( mem , reg , SPLIT_IF_NECESSARY ) ; x1 = mips_frame_set ( mips_subword ( mem , false ) , mips_subword ( reg , false ) ) ; x2 = mips_frame_set ( mips_subword ( mem , true ) , mips_subword ( reg , true ) ) ; mips_set_frame_expr ( gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , x1 , x2 ) ) ) ; } else mips_emit_save_slot_move ( mem , reg , MIPS_PROLOGUE_TEMP ( GET_MODE ( reg ) ) ) ;


<s> rtx x1 , x2 ; mips_emit_move_or_split ( mem , reg , SPLIT_IF_NECESSARY ) ; x1 = mips_frame_set ( mips_subword ( mem , false ) , mips_subword ( reg , false ) ) ; x2 = mips_frame_set ( mips_subword ( mem , true ) , mips_subword ( reg , true ) ) ; mips_set_frame_expr ( gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , x1 , x2 ) ) ) ; }

else mips_emit_save_slot_move ( mem , reg , MIPS_PROLOGUE_TEMP ( GET_MODE ( reg ) ) ) ;


<s> mem = gen_frame_mem ( mode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) ;

fn ( gen_rtx_REG ( mode , regno ) , mem ) ;


<s> rtx mem ; mem = gen_frame_mem ( mode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) ; fn ( gen_rtx_REG ( mode , regno ) , mem ) ;


<s> static bool mips_scalar_mode_supported_p ( scalar_mode mode ) { 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 ( ALL_FIXED_POINT_MODE_P ( mode ) && GET_MODE_PRECISION ( mode ) <= <NUM_LIT> * BITS_PER_WORD ) return true ;


<s> if ( MSA_SUPPORTED_MODE_P ( mode ) ) return <NUM_LIT> ;


<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 ; return false ;


<s> static bool mips_secondary_memory_needed ( machine_mode mode , reg_class_t class1 , reg_class_t class2 ) { if ( lra_in_progress && ( class1 == NO_REGS || class2 == NO_REGS ) ) return false ; if ( ( ( class1 == FP_REGS ) != ( class2 == FP_REGS ) ) && ( ( TARGET_FLOATXX && ! ISA_HAS_MXHC1 ) || TARGET_O32_FP64A_ABI ) && GET_MODE_SIZE ( mode ) >= <NUM_LIT> ) return true ; return false ;


<s> enum reg_class mips_secondary_reload_class ( enum reg_class rclass , machine_mode mode , rtx x , bool ) { int regno ; 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 ( MEM_P ( x ) && MSA_SUPPORTED_MODE_P ( mode ) ) 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 ; if ( FP_REG_P ( regno ) && mips_mode_ok_for_mov_fmt_p ( mode ) ) return NO_REGS ; return GR_REGS ;


<s> mips_sim_reset ( state ) ; for ( rtx_insn * insn = seq ; insn ; insn = NEXT_INSN ( insn ) ) { mips_sim_wait_insn ( state , insn ) ;


<s> static void mips_setup_incoming_varargs ( cumulative_args_t cum , const function_arg_info & arg , int * pretend_size ATTRIBUTE_UNUSED , int no_rtl ) { CUMULATIVE_ARGS local_cum ; int gp_saved , fp_saved ; local_cum = * get_cumulative_args ( cum ) ; mips_function_arg_advance ( pack_cumulative_args ( & local_cum ) , arg ) ; 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 = ROUND_DOWN ( - 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 ) ) ;


<s> off = ROUND_DOWN ( - 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> if ( info != <NUM_LIT> ) { mips_arch_info = info ; mips_arch = info -> cpu ; mips_isa = info -> isa ; if ( mips_isa < MIPS_ISA_MIPS32 ) mips_isa_rev = <NUM_LIT> ; else mips_isa_rev = ( mips_isa & <NUM_LIT> ) + <NUM_LIT> ; }


if ( TARGET_XGOT ) sorry ( <STR_LIT> ) ;


<s> mips_set_compression_mode ( mips_get_compress_mode ( fndecl ) ) ;


<s> else { unsigned int true_time = mips_mult_zero_zero_cost ( state , true ) ; unsigned int false_time = mips_mult_zero_zero_cost ( state , false ) ; mips_tuning_info . fast_mult_zero_zero_p = ( true_time <= false_time ) ;


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


<s> rtx_insn * insn ; insn = get_last_insn ( ) ;

RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ;


<s> case MODE_FLOAT : case MODE_COMPLEX_FLOAT : case MODE_VECTOR_FLOAT : if ( TARGET_HARD_FLOAT ) return mips_set_reg_reg_piece_cost ( mode , UNITS_PER_HWFPVALUE ) ; default : return mips_set_reg_reg_piece_cost ( mode , UNITS_PER_WORD ) ; }


<s> gcc_assert ( BITSET_P ( cfun -> machine -> frame . mask , RETURN_ADDR_REGNUM ) ) ; slot_address = mips_add_offset ( scratch , stack_pointer_rtx , cfun -> machine -> frame . gp_sp_offset ) ; mips_emit_move ( gen_frame_mem ( GET_MODE ( address ) , slot_address ) , address ) ;


<s> slot_address = mips_add_offset ( scratch , stack_pointer_rtx , cfun -> machine -> frame . gp_sp_offset ) ; mips_emit_move ( gen_frame_mem ( GET_MODE ( address ) , slot_address ) , address ) ;


<s> static void mips_set_tune ( const struct mips_cpu_info * info ) { if ( info != <NUM_LIT> ) { mips_tune_info = info ; mips_tune = info -> cpu ; }


<s> static void mips_set_tune ( const struct mips_cpu_info * info ) { if ( info != <NUM_LIT> ) { mips_tune_info = info ;


<s> static void mips_set_tuning_info ( void ) { if ( mips_tuning_info . initialized_p && mips_tuning_info . arch == mips_arch && mips_tuning_info . tune == mips_tune && mips_tuning_info . mips16_p == TARGET_MIPS16 ) return ; mips_tuning_info . arch = mips_arch ; mips_tuning_info . tune = mips_tune ; mips_tuning_info . mips16_p = TARGET_MIPS16 ; mips_tuning_info . initialized_p = true ; dfa_start ( ) ; struct mips_sim state ;

mips_sim_init ( & state , alloca ( state_size ( ) ) ) ;


<s> if ( TARGET_LOONGSON_MMI && VECTOR_MODE_P ( mode ) ) return <NUM_LIT> ;

return GET_MODE_BITSIZE ( mode ) - <NUM_LIT> ;


<s> static int mips_sign_extend_cost ( machine_mode mode , rtx op ) { if ( MEM_P ( op ) ) return <NUM_LIT> ; if ( TARGET_64BIT && mode == DImode && GET_MODE ( op ) == SImode ) return <NUM_LIT> ;

if ( ISA_HAS_SEB_SEH || GENERATE_MIPS16E ) return COSTS_N_INSNS ( <NUM_LIT> ) ;


<s> if ( ISA_HAS_SEB_SEH || GENERATE_MIPS16E ) return COSTS_N_INSNS ( <NUM_LIT> ) ;


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


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


<s> if ( targetm . sched . init_dfa_post_cycle_insn ) targetm . sched . init_dfa_post_cycle_insn ( ) ; state -> issue_rate = mips_issue_rate ( ) ; state -> dfa_state = dfa_state ;


<s> state -> issue_rate = mips_issue_rate ( ) ; state -> dfa_state = dfa_state ; mips_sim_reset ( state ) ;


<s> curr_state = state -> dfa_state ; 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 ( insn , mips_sim_record_set , state ) ;


<s> if ( state -> insns_left == <NUM_LIT> ) mips_sim_next_cycle ( state ) ;


<s> if ( state -> insns_left == <NUM_LIT> ) mips_sim_next_cycle ( state ) ; state -> insns_left -- ;


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


<s> for ( regno = REGNO ( x ) ; regno < end_regno ; regno ++ ) { state -> last_set [ regno ] . insn = mips_sim_insn ; state -> last_set [ regno ] . time = state -> time ;


<s> if ( REG_P ( x ) ) { unsigned int regno , end_regno ; end_regno = END_REGNO ( x ) ; for ( regno = REGNO ( x ) ; regno < end_regno ; regno ++ ) { state -> last_set [ regno ] . insn = mips_sim_insn ; state -> last_set [ regno ] . time = state -> time ; }


<s> state_reset ( curr_state ) ; targetm . sched . init ( <NUM_LIT> , false , <NUM_LIT> ) ;


<s> mips_sim_wait_regs ( state , insn ) ; mips_sim_wait_units ( state , insn ) ;


<s> static void mips_sim_wait_insn ( struct mips_sim * state , rtx_insn * insn ) { mips_sim_wait_regs ( state , insn ) ; mips_sim_wait_units ( state , insn ) ;


<s> unsigned int t ; t = ( state -> last_set [ regno ] . time + insn_latency ( state -> last_set [ regno ] . insn , insn ) ) ;

while ( state -> time < t ) mips_sim_next_cycle ( state ) ;


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


<s> static void mips_sim_wait_regs ( struct mips_sim * state , rtx_insn * insn ) { mips_sim_insn = insn ;

note_uses ( & PATTERN ( insn ) , mips_sim_wait_regs_1 , state ) ;


<s> subrtx_var_iterator :: array_type array ; FOR_EACH_SUBRTX_VAR ( iter , array , * x , NONCONST ) if ( REG_P ( * iter ) ) mips_sim_wait_reg ( ( struct mips_sim * ) data , mips_sim_insn , * iter ) ;


<s> static int mips_small_data_pattern_1 ( rtx x , enum mips_symbol_context context ) { subrtx_var_iterator :: array_type array ; FOR_EACH_SUBRTX_VAR ( iter , array , x , ALL ) { rtx x = * iter ; if ( GET_CODE ( x ) == LO_SUM || GET_CODE ( x ) == ASM_OPERANDS ) iter . skip_subrtxes ( ) ;


<s> bool mips_small_data_pattern_p ( rtx op ) {

return mips_small_data_pattern_1 ( op , SYMBOL_CONTEXT_LEA ) ;


<s> return mips_small_data_pattern_1 ( op , SYMBOL_CONTEXT_LEA ) ;


if ( TARGET_MIPS16 ) return SPILL_REGS ;


<s> rtx new_dest = dest ; if ( ! TARGET_64BIT ) { if ( GET_MODE ( dest ) != V4SImode ) new_dest = simplify_gen_subreg ( V4SImode , dest , GET_MODE ( dest ) , <NUM_LIT> ) ; } else { if ( GET_MODE ( dest ) != V2DImode ) new_dest = simplify_gen_subreg ( V2DImode , dest , GET_MODE ( dest ) , <NUM_LIT> ) ; } for ( byte = <NUM_LIT> , index = <NUM_LIT> ; byte < GET_MODE_SIZE ( TImode ) ; byte += UNITS_PER_WORD , index ++ ) { s = mips_subword_at_byte ( src , byte ) ; if ( ! TARGET_64BIT ) emit_insn ( gen_msa_insert_w ( new_dest , s , new_dest , GEN_INT ( <NUM_LIT> << index ) ) ) ; else emit_insn ( gen_msa_insert_d ( new_dest , s , new_dest , GEN_INT ( <NUM_LIT> << index ) ) ) ; } } else if ( FP_REG_RTX_P ( src ) ) { gcc_assert ( ! MEM_P ( dest ) ) ; rtx new_src = src ; if ( ! TARGET_64BIT ) { if ( GET_MODE ( src ) != V4SImode ) new_src = simplify_gen_subreg ( V4SImode , src , GET_MODE ( src ) , <NUM_LIT> ) ; } else { if ( GET_MODE ( src ) != V2DImode ) new_src = simplify_gen_subreg ( V2DImode , src , GET_MODE ( src ) , <NUM_LIT> ) ; } for ( byte = <NUM_LIT> , index = <NUM_LIT> ; byte < GET_MODE_SIZE ( TImode ) ; byte += UNITS_PER_WORD , index ++ ) { d = mips_subword_at_byte ( dest , byte ) ; if ( ! TARGET_64BIT ) emit_insn ( gen_msa_copy_s_w ( d , new_src , GEN_INT ( index ) ) ) ; else emit_insn ( gen_msa_copy_s_d ( d , new_src , GEN_INT ( index ) ) ) ; } }


<s> rtx new_dest = dest ; if ( ! TARGET_64BIT ) { if ( GET_MODE ( dest ) != V4SImode ) new_dest = simplify_gen_subreg ( V4SImode , dest , GET_MODE ( dest ) , <NUM_LIT> ) ; } else { if ( GET_MODE ( dest ) != V2DImode ) new_dest = simplify_gen_subreg ( V2DImode , dest , GET_MODE ( dest ) , <NUM_LIT> ) ; } for ( byte = <NUM_LIT> , index = <NUM_LIT> ; byte < GET_MODE_SIZE ( TImode ) ; byte += UNITS_PER_WORD , index ++ ) { s = mips_subword_at_byte ( src , byte ) ; if ( ! TARGET_64BIT ) emit_insn ( gen_msa_insert_w ( new_dest , s , new_dest , GEN_INT ( <NUM_LIT> << index ) ) ) ; else emit_insn ( gen_msa_insert_d ( new_dest , s , new_dest , GEN_INT ( <NUM_LIT> << index ) ) ) ; } } else if ( FP_REG_RTX_P ( src ) ) { gcc_assert ( ! MEM_P ( dest ) ) ; rtx new_src = src ; if ( ! TARGET_64BIT ) { if ( GET_MODE ( src ) != V4SImode ) new_src = simplify_gen_subreg ( V4SImode , src , GET_MODE ( src ) , <NUM_LIT> ) ; } else { if ( GET_MODE ( src ) != V2DImode ) new_src = simplify_gen_subreg ( V2DImode , src , GET_MODE ( src ) , <NUM_LIT> ) ; } for ( byte = <NUM_LIT> , index = <NUM_LIT> ; byte < GET_MODE_SIZE ( TImode ) ; byte += UNITS_PER_WORD , index ++ ) { d = mips_subword_at_byte ( dest , byte ) ; if ( ! TARGET_64BIT ) emit_insn ( gen_msa_copy_s_w ( d , new_src , GEN_INT ( index ) ) ) ; else emit_insn ( gen_msa_copy_s_d ( d , new_src , GEN_INT ( index ) ) ) ; } } else { low_dest = mips_subword_at_byte ( dest , <NUM_LIT> ) ; low_src = mips_subword_at_byte ( src , <NUM_LIT> ) ; gcc_assert ( REG_P ( low_dest ) && REG_P ( low_src ) ) ; if ( REGNO ( low_dest ) <= REGNO ( low_src ) ) { for ( byte = <NUM_LIT> ; byte < GET_MODE_SIZE ( TImode ) ; byte += UNITS_PER_WORD ) { d = mips_subword_at_byte ( dest , byte ) ; s = mips_subword_at_byte ( src , byte ) ; mips_emit_move ( d , s ) ; } }


<s> if ( FP_REG_RTX_P ( src ) && MEM_P ( dest ) ) return false ; if ( FP_REG_RTX_P ( dest ) && mips_const_vector_same_int_p ( src , GET_MODE ( src ) , - <NUM_LIT> , <NUM_LIT> ) ) return false ;

if ( FP_REG_RTX_P ( dest ) && src == CONST0_RTX ( GET_MODE ( src ) ) ) return false ;


<s> static bool mips_split_addresses_p ( void ) { return ( TARGET_SPLIT_ADDRESSES && optimize && ! TARGET_MIPS16 && ! flag_pic && ! ABI_HAS_64BIT_SYMBOLS ) ;


<s> return ( TARGET_SPLIT_ADDRESSES && optimize && ! TARGET_MIPS16 && ! flag_pic && ! ABI_HAS_64BIT_SYMBOLS ) ;


<s> void mips_split_call ( rtx insn , rtx call_pattern ) {


<s> if ( ! find_reg_note ( insn , REG_NORETURN , <NUM_LIT> ) ) mips_restore_gp_from_cprestore_slot ( gen_rtx_REG ( Pmode , POST_CALL_TMP_REG ) ) ;


<s> low = mips_const_insns ( mips_subword ( x , false ) ) ; high = mips_const_insns ( mips_subword ( x , true ) ) ; gcc_assert ( low > <NUM_LIT> && high > <NUM_LIT> ) ;


<s> unsigned int low , high ; low = mips_const_insns ( mips_subword ( x , false ) ) ; high = mips_const_insns ( mips_subword ( x , true ) ) ;

gcc_assert ( low > <NUM_LIT> && high > <NUM_LIT> ) ;


<s> else gcc_unreachable ( ) ; } else if ( REG_P ( dest ) && REGNO ( dest ) == MD_REG_FIRST ) { low_dest = mips_subword ( dest , false ) ; mips_emit_move ( low_dest , mips_subword ( src , false ) ) ; if ( TARGET_64BIT ) emit_insn ( gen_mthidi_ti ( dest , mips_subword ( src , true ) , low_dest ) ) ; else emit_insn ( gen_mthisi_di ( dest , mips_subword ( src , true ) , low_dest ) ) ; } 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 ) ) ; } } rtx_insn * insn = ( rtx_insn * ) insn_ ; struct mips_address_info addr = { } ; if ( insn ) { rtx_insn * next = next_nonnote_nondebug_insn_bb ( insn ) ; if ( next ) { rtx set = single_set ( next ) ; if ( set && SET_SRC ( set ) == dest ) { if ( MEM_P ( src ) ) {


<s> mips_split_move ( dest , src , mips_insn_split_type ( insn ) , 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 ; } if ( MSA_SUPPORTED_MODE_P ( GET_MODE ( dest ) ) ) return mips_split_128bit_move_p ( dest , src ) ;


<s> rtx new_src = simplify_gen_subreg ( V4SImode , src , GET_MODE ( src ) , <NUM_LIT> ) ; emit_insn ( gen_fn ( low , new_src , GEN_INT ( INTVAL ( index ) * <NUM_LIT> ) ) ) ; emit_insn ( gen_fn ( high , new_src , GEN_INT ( INTVAL ( index ) * <NUM_LIT> + <NUM_LIT> ) ) ) ;


<s> low = mips_subword ( src , false ) ; high = mips_subword ( src , true ) ; } rtx new_dest = simplify_gen_subreg ( V4SImode , dest , GET_MODE ( dest ) , <NUM_LIT> ) ; emit_insn ( gen_msa_fill_w ( new_dest , low ) ) ; emit_insn ( gen_msa_insert_w ( new_dest , high , new_dest , GEN_INT ( <NUM_LIT> << <NUM_LIT> ) ) ) ; emit_insn ( gen_msa_insert_w ( new_dest , high , new_dest , GEN_INT ( <NUM_LIT> << <NUM_LIT> ) ) ) ;


<s> gcc_assert ( ( GET_MODE ( dest ) == V2DImode && ( GET_MODE ( src ) == DImode || src == const0_rtx ) ) || ( GET_MODE ( dest ) == V2DFmode && GET_MODE ( src ) == DFmode ) ) ; rtx low , high ; if ( src == const0_rtx ) { low = src ; high = src ; } else { low = mips_subword ( src , false ) ; high = mips_subword ( src , true ) ; } rtx new_dest = simplify_gen_subreg ( V4SImode , dest , GET_MODE ( dest ) , <NUM_LIT> ) ; emit_insn ( gen_msa_fill_w ( new_dest , low ) ) ; emit_insn ( gen_msa_insert_w ( new_dest , high , new_dest , GEN_INT ( <NUM_LIT> << <NUM_LIT> ) ) ) ; emit_insn ( gen_msa_insert_w ( new_dest , high , new_dest , GEN_INT ( <NUM_LIT> << <NUM_LIT> ) ) ) ;


<s> * offset_ptr = INTVAL ( XEXP ( x , <NUM_LIT> ) ) ; } else { * base_ptr = x ; * offset_ptr = <NUM_LIT> ; }


<s> break ; default : gcc_unreachable ( ) ; } return true ; } } else { if ( mips_symbolic_constant_p ( addr , context , & symbol_type ) && mips_symbol_insns ( symbol_type , mode ) > <NUM_LIT> && mips_split_p [ symbol_type ] ) { if ( low_out ) switch ( symbol_type ) { case SYMBOL_GOT_DISP : * low_out = mips_got_load ( temp , addr , SYMBOL_GOTOFF_DISP ) ; break ; case SYMBOL_GP_RELATIVE : high = mips_pic_base_register ( temp ) ; * low_out = gen_rtx_LO_SUM ( Pmode , high , addr ) ; break ; default : high = gen_rtx_HIGH ( Pmode , copy_rtx ( addr ) ) ; high = mips_force_temporary ( temp , high ) ; * low_out = gen_rtx_LO_SUM ( Pmode , high , addr ) ;


<s> case SYMBOL_GOT_DISP : * low_out = mips_got_load ( temp , addr , SYMBOL_GOTOFF_DISP ) ; break ; case SYMBOL_GP_RELATIVE : high = mips_pic_base_register ( temp ) ; * low_out = gen_rtx_LO_SUM ( Pmode , high , addr ) ; break ; default : high = gen_rtx_HIGH ( Pmode , copy_rtx ( addr ) ) ; high = mips_force_temporary ( temp , high ) ; * low_out = gen_rtx_LO_SUM ( Pmode , high , addr ) ; break ; } return true ; }


<s> bool mips_stack_address_p ( rtx x , machine_mode mode ) { struct mips_address_info addr ; return ( mips_classify_address ( & addr , x , mode , false ) && addr . type == ADDRESS_REG && addr . reg == stack_pointer_rtx ) ;


<s> bool mips_stack_address_p ( rtx x , machine_mode mode ) { struct mips_address_info addr ;

return ( mips_classify_address ( & addr , x , mode , false ) && addr . type == ADDRESS_REG && addr . reg == stack_pointer_rtx ) ;


<s> static HOST_WIDE_INT mips_starting_frame_offset ( void ) { if ( FRAME_GROWS_DOWNWARD ) return <NUM_LIT> ; return crtl -> outgoing_args_size + MIPS_GP_SAVE_AREA_SIZE ;


<s> return crtl -> outgoing_args_size + MIPS_GP_SAVE_AREA_SIZE ;


<s> if ( TARGET_MICROMIPS ) fprintf ( asm_out_file , <STR_LIT> ) ; else fprintf ( asm_out_file , <STR_LIT> ) ; if ( ! flag_inhibit_size_directive ) { fputs ( <STR_LIT> , asm_out_file ) ;


<s> static void mips_start_ll_sc_sync_block ( void ) {


<s> cgraph_node :: create ( decl ) -> set_comdat_group ( DECL_ASSEMBLER_NAME ( decl ) ) ; targetm . asm_out . unique_section ( decl , <NUM_LIT> ) ; switch_to_section ( get_named_section ( decl , NULL , <NUM_LIT> ) ) ; targetm . asm_out . globalize_label ( asm_out_file , name ) ;


<s> if ( boundary < TYPE_ALIGN ( type ) ) { type = build_variant_type_copy ( type ) ; SET_TYPE_ALIGN ( type , boundary ) ; } type_size = size_in_bytes ( type ) ; rounded_size = round_up ( type_size , align ) ; gimplify_expr ( & rounded_size , pre_p , post_p , is_gimple_val , fb_rvalue ) ; addr = valist_tmp ; if ( PAD_VARARGS_DOWN && ! integer_zerop ( rounded_size ) ) { t = fold_build2_loc ( input_location , GT_EXPR , sizetype , rounded_size , size_int ( align ) ) ; t = fold_build3 ( COND_EXPR , sizetype , t , size_zero_node , size_binop ( MINUS_EXPR , rounded_size , type_size ) ) ; addr = fold_build_pointer_plus ( addr , t ) ; } t = fold_build_pointer_plus ( valist_tmp , rounded_size ) ;

t = build2 ( MODIFY_EXPR , TREE_TYPE ( valist ) , valist , t ) ;


<s> bool mips_store_by_pieces_p ( unsigned HOST_WIDE_INT size , unsigned int align ) {

if ( align <= BITS_PER_UNIT ) return size < <NUM_LIT> ;


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


<s> rtx mips_strip_unspec_address ( rtx op ) { rtx base , offset ; split_const ( op , & base , & offset ) ;

if ( UNSPEC_ADDRESS_P ( base ) ) op = plus_constant ( Pmode , UNSPEC_ADDRESS ( base ) , INTVAL ( offset ) ) ;


<s> split_const ( op , & base , & offset ) ; if ( UNSPEC_ADDRESS_P ( base ) ) op = plus_constant ( Pmode , UNSPEC_ADDRESS ( base ) , INTVAL ( offset ) ) ;


<s> if ( GET_CODE ( src ) == UNSPEC && XINT ( src , <NUM_LIT> ) == UNSPEC_LOAD_CALL ) return mips_strip_unspec_address ( XVECEXP ( src , <NUM_LIT> , <NUM_LIT> ) ) ; return NULL_RTX ;


<s> static rtx mips_strip_unspec_call ( rtx src ) {

if ( GET_CODE ( src ) == UNSPEC && XINT ( src , <NUM_LIT> ) == UNSPEC_LOAD_CALL ) return mips_strip_unspec_address ( XVECEXP ( src , <NUM_LIT> , <NUM_LIT> ) ) ;


<s> mode = GET_MODE ( op ) ; if ( mode == VOIDmode ) mode = TARGET_64BIT ? TImode : DImode ; if ( TARGET_BIG_ENDIAN ? ! high_p : high_p ) byte = UNITS_PER_WORD ; else byte = <NUM_LIT> ; if ( FP_REG_RTX_P ( op ) ) { offset = ( UNITS_PER_WORD < UNITS_PER_HWFPVALUE ? high_p : byte != <NUM_LIT> ) ;

return gen_rtx_REG ( word_mode , REGNO ( op ) + offset ) ;


<s> if ( mode == VOIDmode ) mode = TImode ; gcc_assert ( ! FP_REG_RTX_P ( op ) ) ;

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


<s> const char * tmps ; SWAP_INT ( fixed_regs [ i ] , fixed_regs [ i + <NUM_LIT> ] ) ;

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


<s> } else return false ; if ( offset == const0_rtx ) return true ; switch ( * symbol_type ) { case SYMBOL_ABSOLUTE : case SYMBOL_64_HIGH : case SYMBOL_64_MID : case SYMBOL_64_LOW : if ( Pmode == DImode && ! ABI_HAS_64BIT_SYMBOLS ) return offset_within_block_p ( x , INTVAL ( offset ) ) ; return true ; case SYMBOL_PC_RELATIVE : if ( GET_CODE ( x ) == LABEL_REF ) return true ; case SYMBOL_GP_RELATIVE : return offset_within_block_p ( x , INTVAL ( offset ) ) ; case SYMBOL_GOT_PAGE_OFST : case SYMBOL_GOTOFF_PAGE : return SMALL_INT ( offset ) ; case SYMBOL_TPREL : case SYMBOL_DTPREL : return mips_offset_within_alignment_p ( x , INTVAL ( offset ) ) ; case SYMBOL_GOT_DISP : case SYMBOL_GOTOFF_DISP : case SYMBOL_GOTOFF_CALL : case SYMBOL_GOTOFF_LOADGP : case SYMBOL_TLSGD : case SYMBOL_TLSLDM : case SYMBOL_GOTTPREL : case SYMBOL_TLS : case SYMBOL_HALF : return false ; } gcc_unreachable ( ) ;


<s> static bool mips_symbol_binds_local_p ( const_rtx x ) {

return ( SYMBOL_REF_DECL ( x ) ? targetm . binds_local_p ( SYMBOL_REF_DECL ( x ) ) : SYMBOL_REF_LOCAL_P ( x ) ) ;


<s> return ( SYMBOL_REF_DECL ( x ) ? targetm . binds_local_p ( SYMBOL_REF_DECL ( x ) ) : SYMBOL_REF_LOCAL_P ( x ) ) ;


<s> static int mips_symbol_insns ( enum mips_symbol_type type , machine_mode mode ) { if ( mode != MAX_MACHINE_MODE && MSA_SUPPORTED_MODE_P ( mode ) ) return <NUM_LIT> ;

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


<s> if ( mode != MAX_MACHINE_MODE && MSA_SUPPORTED_MODE_P ( mode ) ) return <NUM_LIT> ;


<s> mips_process_sync_loop ( insn , operands ) ; return mips_multi_num_insns ;


<s> return GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL ( x ) != <NUM_LIT> ;


<s> else if ( ptr_mode == DImode ) return <NUM_LIT> * <NUM_LIT> ; else if ( ISA_HAS_LOAD_DELAY ) return <NUM_LIT> * <NUM_LIT> ;


<s> else if ( ISA_HAS_LOAD_DELAY ) return <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> ) ) ; 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 ) ;


<s> 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 ) ; } } if ( TARGET_CB_ALWAYS ) { rtx temp ; temp = trampoline [ i - <NUM_LIT> ] ; trampoline [ i - <NUM_LIT> ] = trampoline [ i - <NUM_LIT> ] ; trampoline [ i - <NUM_LIT> ] = temp ; } for ( j = <NUM_LIT> ; j < i ; j ++ ) { mem = adjust_address ( m_tramp , SImode , j * GET_MODE_SIZE ( SImode ) ) ; mips_emit_move ( mem , trampoline [ j ] ) ;


<s> static bool mips_truly_noop_truncation ( poly_uint64 outprec , poly_uint64 inprec ) {

return ! TARGET_64BIT || inprec <= <NUM_LIT> || outprec > <NUM_LIT> ;


<s> bool mips_unsigned_immediate_p ( unsigned HOST_WIDE_INT x , int bits , int shift = <NUM_LIT> ) { return ( x & ( ( <NUM_LIT> << shift ) - <NUM_LIT> ) ) == <NUM_LIT> && x < ( ( unsigned ) <NUM_LIT> << ( shift + bits ) ) ;


<s> rtx base , offset ; split_const ( address , & base , & offset ) ;

return mips_unspec_address_offset ( base , offset , symbol_type ) ;


<s> rtx base , offset ; split_const ( address , & base , & offset ) ; return mips_unspec_address_offset ( base , offset , symbol_type ) ;


<s> static rtx mips_unspec_address_offset ( rtx base , rtx offset , enum mips_symbol_type symbol_type ) { base = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , base ) , UNSPEC_ADDRESS_FIRST + symbol_type ) ;

if ( offset != const0_rtx ) base = gen_rtx_PLUS ( Pmode , base , offset ) ;


<s> rtvec vec ; vec = gen_rtvec ( <NUM_LIT> , reg , symbol , gen_rtx_REG ( SImode , GOT_VERSION_REGNUM ) ) ; return gen_rtx_UNSPEC ( Pmode , vec , UNSPEC_LOAD_CALL ) ;


<s> static rtx mips_unspec_call ( rtx reg , rtx symbol ) {


<s> if ( mips_split_p [ symbol_type ] ) { addr = gen_rtx_HIGH ( Pmode , mips_unspec_address ( addr , symbol_type ) ) ; addr = mips_force_temporary ( temp , addr ) ;

base = mips_force_temporary ( temp , gen_rtx_PLUS ( Pmode , addr , base ) ) ;


<s> static rtx mips_unspec_offset_high ( rtx temp , rtx base , rtx addr , enum mips_symbol_type symbol_type ) { if ( mips_split_p [ symbol_type ] ) { addr = gen_rtx_HIGH ( Pmode , mips_unspec_address ( addr , symbol_type ) ) ; addr = mips_force_temporary ( temp , addr ) ; base = mips_force_temporary ( temp , gen_rtx_PLUS ( Pmode , addr , base ) ) ; } return base ;


<s> static bool mips_use_anchors_for_symbol_p ( const_rtx symbol ) { switch ( mips_classify_symbol ( symbol , SYMBOL_CONTEXT_MEM ) ) { case SYMBOL_PC_RELATIVE : case SYMBOL_GP_RELATIVE :


<s> if ( op == STORE_BY_PIECES ) return mips_store_by_pieces_p ( size , align ) ; if ( op == MOVE_BY_PIECES && HAVE_cpymemsi ) { if ( currently_expanding_to_rtl ) return false ; if ( align < BITS_PER_WORD ) return size < UNITS_PER_WORD ; return size <= MIPS_MAX_MOVE_BYTES_STRAIGHT ;


<s> bool mips_use_by_pieces_infrastructure_p ( unsigned HOST_WIDE_INT size , unsigned int align , enum by_pieces_operation op , bool speed_p ) { if ( op == STORE_BY_PIECES ) return mips_store_by_pieces_p ( size , align ) ; if ( op == MOVE_BY_PIECES && HAVE_cpymemsi ) { if ( currently_expanding_to_rtl ) return false ; if ( align < BITS_PER_WORD ) return size < UNITS_PER_WORD ; return size <= MIPS_MAX_MOVE_BYTES_STRAIGHT ; }

return default_use_by_pieces_infrastructure_p ( size , align , op , speed_p ) ;


<s> static bool mips_use_debug_exception_return_p ( tree type ) { return lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type ) ) != NULL ;


<s> bool mips_use_ins_ext_p ( rtx op , HOST_WIDE_INT width , HOST_WIDE_INT bitpos ) { if ( ! ISA_HAS_EXT_INS || ! register_operand ( op , VOIDmode ) || GET_MODE_BITSIZE ( GET_MODE ( op ) ) > BITS_PER_WORD ) return false ; if ( ! IN_RANGE ( width , <NUM_LIT> , GET_MODE_BITSIZE ( GET_MODE ( op ) ) - <NUM_LIT> ) ) return false ; if ( bitpos < <NUM_LIT> || bitpos + width > GET_MODE_BITSIZE ( GET_MODE ( op ) ) ) return false ; return true ;


<s> if ( GET_CODE ( x ) == SYMBOL_REF ) { if ( TARGET_ABICALLS_PIC0 ) return false ;

if ( TARGET_ABSOLUTE_ABICALLS && mips_symbol_binds_local_p ( x ) && ! SYMBOL_REF_EXTERNAL_P ( x ) ) return false ;


<s> static enum mips_shadow_set mips_use_shadow_register_set ( tree type ) { tree attr = lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type ) ) ; tree args ; if ( attr == NULL ) return SHADOW_SET_NO ; args = TREE_VALUE ( attr ) ;

if ( args == NULL ) return SHADOW_SET_YES ;


<s> tree attr = lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type ) ) ; tree args ; if ( attr == NULL ) return SHADOW_SET_NO ; args = TREE_VALUE ( attr ) ;


<s> if ( ! strict_p && GET_CODE ( x ) == SUBREG ) x = SUBREG_REG ( x ) ; return ( REG_P ( x ) && mips_regno_mode_ok_for_base_p ( REGNO ( x ) , mode , strict_p ) ) ;


<s> static bool mips_valid_base_register_p ( rtx x , machine_mode mode , bool strict_p ) { if ( ! strict_p && GET_CODE ( x ) == SUBREG ) x = SUBREG_REG ( x ) ; return ( REG_P ( x ) && mips_regno_mode_ok_for_base_p ( REGNO ( x ) , mode , strict_p ) ) ;


<s> if ( GET_MODE_SIZE ( mode ) > UNITS_PER_WORD && GET_MODE_BITSIZE ( mode ) > GET_MODE_ALIGNMENT ( mode ) ) return false ;

if ( MSA_SUPPORTED_MODE_P ( mode ) ) return false ;


<s> static bool mips_valid_lo_sum_p ( enum mips_symbol_type symbol_type , machine_mode mode ) { 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 ;


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


<s> static bool mips_valid_pointer_mode ( scalar_int_mode mode ) {

return mode == SImode || ( TARGET_64BIT && mode == DImode ) ;


<s> f_gtop = DECL_CHAIN ( f_ovfl ) ; f_ftop = DECL_CHAIN ( f_gtop ) ; f_goff = DECL_CHAIN ( f_ftop ) ; f_foff = DECL_CHAIN ( f_goff ) ; ovfl = build3 ( COMPONENT_REF , TREE_TYPE ( f_ovfl ) , valist , f_ovfl , NULL_TREE ) ; gtop = build3 ( COMPONENT_REF , TREE_TYPE ( f_gtop ) , valist , f_gtop , NULL_TREE ) ; ftop = build3 ( COMPONENT_REF , TREE_TYPE ( f_ftop ) , valist , f_ftop , NULL_TREE ) ; goff = build3 ( COMPONENT_REF , TREE_TYPE ( f_goff ) , valist , f_goff , NULL_TREE ) ; foff = build3 ( 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 = fold_build_pointer_plus_hwi ( t , cum -> stack_words * UNITS_PER_WORD ) ; t = build2 ( 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 = build2 ( 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 ; if ( fpr_offset ) t = fold_build_pointer_plus_hwi ( t , - fpr_offset ) ; t = build2 ( MODIFY_EXPR , TREE_TYPE ( ftop ) , ftop , t ) ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; t = build2 ( MODIFY_EXPR , TREE_TYPE ( goff ) , goff , build_int_cst ( TREE_TYPE ( goff ) , gpr_save_area_size ) ) ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; t = build2 ( MODIFY_EXPR , TREE_TYPE ( foff ) , foff , build_int_cst ( TREE_TYPE ( foff ) , fpr_save_area_size ) ) ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; }


<s> for ( i = which = <NUM_LIT> ; i < nelt ; ++ i ) { int ei = sel [ i ] & ( <NUM_LIT> * nelt - <NUM_LIT> ) ; which |= ( ei < nelt ? <NUM_LIT> : <NUM_LIT> ) ; orig_perm [ i ] = ei ; } memcpy ( d . perm , orig_perm , MAX_VECT_LEN ) ; switch ( which ) { default : gcc_unreachable ( ) ; case <NUM_LIT> : d . one_vector_p = false ; if ( d . testing_p || ! rtx_equal_p ( d . op0 , d . op1 ) ) break ; case <NUM_LIT> : for ( i = <NUM_LIT> ; i < nelt ; ++ i ) d . perm [ i ] &= nelt - <NUM_LIT> ; d . op0 = d . op1 ; d . one_vector_p = true ; break ; case <NUM_LIT> : d . op1 = d . op0 ; d . one_vector_p = true ; break ; } if ( d . testing_p ) { d . target = gen_raw_REG ( d . vmode , LAST_VIRTUAL_REGISTER + <NUM_LIT> ) ; d . op1 = d . op0 = gen_raw_REG ( d . vmode , LAST_VIRTUAL_REGISTER + <NUM_LIT> ) ; if ( ! d . one_vector_p ) d . op1 = gen_raw_REG ( d . vmode , LAST_VIRTUAL_REGISTER + <NUM_LIT> ) ;


<s> break ; } if ( d . testing_p ) { d . target = gen_raw_REG ( d . vmode , LAST_VIRTUAL_REGISTER + <NUM_LIT> ) ; d . op1 = d . op0 = gen_raw_REG ( d . vmode , LAST_VIRTUAL_REGISTER + <NUM_LIT> ) ; if ( ! d . one_vector_p ) d . op1 = gen_raw_REG ( d . vmode , LAST_VIRTUAL_REGISTER + <NUM_LIT> ) ; start_sequence ( ) ; ok = mips_expand_vec_perm_const_1 ( & d ) ; end_sequence ( ) ; return ok ; } ok = mips_expand_vec_perm_const_1 ( & d ) ; if ( ! ok && which == <NUM_LIT> ) { d . op0 = op0 ; d . op1 = op1 ; d . one_vector_p = false ; memcpy ( d . perm , orig_perm , MAX_VECT_LEN ) ; ok = mips_expand_vec_perm_const_1 ( & d ) ; } return ok ;


<s> case E_V4QQmode : case E_V4UQQmode : return TARGET_DSP ; case E_V2SImode : case E_V4HImode : case E_V8QImode : return TARGET_LOONGSON_MMI ; default :


<s> case E_V4QQmode : case E_V4UQQmode : return TARGET_DSP ; case E_V2SImode : case E_V4HImode : case E_V8QImode : return TARGET_LOONGSON_MMI ;


<s> static int mips_zero_extend_cost ( machine_mode mode , rtx op ) { if ( MEM_P ( op ) ) return <NUM_LIT> ; if ( TARGET_64BIT && mode == DImode && GET_MODE ( op ) == SImode ) return COSTS_N_INSNS ( TARGET_MIPS16 ? <NUM_LIT> : <NUM_LIT> ) ; if ( GENERATE_MIPS16E ) return COSTS_N_INSNS ( <NUM_LIT> ) ; if ( TARGET_MIPS16 ) return COSTS_N_INSNS ( GET_MODE ( op ) == QImode ? <NUM_LIT> : <NUM_LIT> ) ; return COSTS_N_INSNS ( <NUM_LIT> ) ;


<s> if ( cmp1 == const0_rtx ) return cmp0 ;


<s> pass_mips_machine_reorg2 ( gcc :: context * ctxt ) : rtl_opt_pass ( pass_data_mips_machine_reorg2 , ctxt ) {


<s> rtx unprotected_region ; if ( TARGET_MIPS16 ) { 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 ) ) { 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 ( ) , as_a < rtx_insn * > ( unprotected_region ) ) ; unprotected_region = NULL_RTX ; } }


<s> sbitmap protected_bbs ; rtx_insn * insn , * end ; rtx unprotected_region ; if ( TARGET_MIPS16 ) { 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 ) ) { 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 ( ) , as_a < rtx_insn * > ( unprotected_region ) ) ;


<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 ( insn , r10k_needs_protection_p_store , & insn ) ; return insn == NULL_RTX ;


<s> if ( CALL_P ( insn ) ) return r10k_needs_protection_p_call ( PATTERN ( insn ) ) ; if ( mips_r10k_cache_barrier == R10K_CACHE_BARRIER_STORE ) { note_stores ( insn , r10k_needs_protection_p_store , & insn ) ; return insn == NULL_RTX ; } return r10k_needs_protection_p_1 ( PATTERN ( insn ) , insn ) ;


if ( ( MEM_EXPR ( mem ) && MEM_OFFSET_KNOWN_P ( mem ) && r10k_safe_mem_expr_p ( MEM_EXPR ( mem ) , MEM_OFFSET ( mem ) ) ) || r10k_safe_address_p ( XEXP ( mem , <NUM_LIT> ) , insn ) ) iter . skip_subrtxes ( ) ;


<s> static bool r10k_needs_protection_p_call ( const_rtx x ) { subrtx_iterator :: array_type array ; FOR_EACH_SUBRTX ( iter , array , x , NONCONST ) {


<s> static bool r10k_protected_bb_p ( basic_block bb , sbitmap protected_bbs ) { edge_iterator ei ; edge e ; FOR_EACH_EDGE ( e , ei , bb -> preds ) if ( ! single_succ_p ( e -> src ) || ! bitmap_bit_p ( protected_bbs , e -> src -> index ) || ( e -> flags & EDGE_COMPLEX ) != <NUM_LIT> ) return false ; return true ;


<s> static bool r10k_protected_bb_p ( basic_block bb , sbitmap protected_bbs ) { edge_iterator ei ; edge e ;

FOR_EACH_EDGE ( e , ei , bb -> preds ) if ( ! single_succ_p ( e -> src ) || ! bitmap_bit_p ( protected_bbs , e -> src -> index ) || ( e -> flags & EDGE_COMPLEX ) != <NUM_LIT> ) return false ;


<s> int unsigned_p , reverse_p , volatile_p ; inner = get_inner_reference ( expr , & bitsize , & bitoffset , & var_offset , & mode , & unsigned_p , & reverse_p , & volatile_p ) ;

if ( ! DECL_P ( inner ) || ! DECL_SIZE_UNIT ( inner ) || var_offset ) return false ;


<s> static bool r10k_simplified_address_p ( rtx x ) { if ( GET_CODE ( x ) == PLUS && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) ) x = XEXP ( x , <NUM_LIT> ) ;

return x == virtual_incoming_args_rtx || CONSTANT_P ( x ) ;


<s> static bool r10k_simplified_address_p ( rtx x ) {

if ( GET_CODE ( x ) == PLUS && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) ) x = XEXP ( x , <NUM_LIT> ) ;


<s> rtx_insn * def_insn ; df_ref use , def ; struct df_link * defs ; newx = NULL_RTX ; if ( UNARY_P ( x ) ) { op0 = r10k_simplify_address ( XEXP ( x , <NUM_LIT> ) , insn ) ; if ( op0 != XEXP ( x , <NUM_LIT> ) ) newx = simplify_gen_unary ( GET_CODE ( x ) , GET_MODE ( x ) , op0 , GET_MODE ( XEXP ( x , <NUM_LIT> ) ) ) ; } else if ( BINARY_P ( x ) ) { op0 = r10k_simplify_address ( XEXP ( x , <NUM_LIT> ) , insn ) ; op1 = r10k_simplify_address ( XEXP ( x , <NUM_LIT> ) , insn ) ; if ( op0 != XEXP ( x , <NUM_LIT> ) || op1 != XEXP ( x , <NUM_LIT> ) ) newx = simplify_gen_binary ( GET_CODE ( x ) , GET_MODE ( x ) , op0 , op1 ) ; } else if ( GET_CODE ( x ) == LO_SUM ) { op0 = r10k_simplify_address ( XEXP ( x , <NUM_LIT> ) , insn ) ; if ( GET_CODE ( op0 ) == HIGH ) newx = XEXP ( x , <NUM_LIT> ) ; } else if ( REG_P ( x ) ) { use = df_find_use ( insn , regno_reg_rtx [ REGNO ( x ) ] ) ; gcc_assert ( use ) ; defs = DF_REF_CHAIN ( use ) ; if ( defs && defs -> next == NULL ) { def = defs -> ref ; if ( DF_REF_IS_ARTIFICIAL ( def ) ) { if ( x == stack_pointer_rtx && DF_REF_BB ( def ) == ENTRY_BLOCK_PTR_FOR_FN ( cfun ) ) newx = virtual_incoming_args_rtx ; } else if ( dominated_by_p ( CDI_DOMINATORS , DF_REF_BB ( use ) , DF_REF_BB ( def ) ) ) { def_insn = DF_REF_INSN ( def ) ; if ( NONJUMP_INSN_P ( def_insn ) ) { set = single_set ( def_insn ) ; if ( set && rtx_equal_p ( SET_DEST ( set ) , x ) ) { note = find_reg_equal_equiv_note ( def_insn ) ; if ( note ) newx = XEXP ( note , <NUM_LIT> ) ; else newx = SET_SRC ( set ) ;

newx = r10k_simplify_address ( newx , def_insn ) ;


<s> if ( Pmode == DImode ) { upper = ( address >> <NUM_LIT> ) & <NUM_LIT> ; if ( upper == <NUM_LIT> || upper == <NUM_LIT> ) return true ; }


<s> if ( upper == <NUM_LIT> || upper == <NUM_LIT> ) return true ; } return false ;


<s> return ( mips_classify_address ( & addr , x , mode , false ) && addr . type == ADDRESS_REG && CONST_INT_P ( addr . offset ) && UMIPS_12BIT_OFFSET_P ( INTVAL ( addr . offset ) ) ) ;


<s> nregs = ( umips_swm_encoding [ i ] & <NUM_LIT> ) + ( umips_swm_encoding [ i ] >> <NUM_LIT> ) ; this_offset = * offset - UNITS_PER_WORD * ( nregs - <NUM_LIT> ) ; if ( ! UMIPS_12BIT_OFFSET_P ( this_offset ) ) return false ; pattern = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( nregs ) ) ; this_base = stack_pointer_rtx ; for ( j = <NUM_LIT> ; j < ( umips_swm_encoding [ i ] & <NUM_LIT> ) ; j ++ ) { HOST_WIDE_INT offset = this_offset + j * UNITS_PER_WORD ; mem = gen_frame_mem ( SImode , plus_constant ( Pmode , this_base , offset ) ) ; unsigned int regno = ( j != <NUM_LIT> ) ? <NUM_LIT> + j : <NUM_LIT> ; * mask &= ~ ( <NUM_LIT> << regno ) ; reg = gen_rtx_REG ( SImode , regno ) ; if ( fn == mips_save_reg ) set = mips_frame_set ( mem , reg ) ; else { set = gen_rtx_SET ( reg , mem ) ; mips_add_cfa_restore ( reg ) ;


<s> mem1 = operands [ <NUM_LIT> ] ; mem2 = operands [ <NUM_LIT> ] ; } if ( REGNO ( reg2 ) == REGNO ( reg1 ) + <NUM_LIT> ) return umips_load_store_pair_p_1 ( load_p , false , reg1 , mem1 , mem2 ) ;

if ( REGNO ( reg1 ) == REGNO ( reg2 ) + <NUM_LIT> ) return umips_load_store_pair_p_1 ( load_p , true , reg2 , mem2 , mem1 ) ;


<s> HOST_WIDE_INT offset1 , offset2 ; if ( ! MEM_P ( mem1 ) || ! MEM_P ( mem2 ) ) return false ; mips_split_plus ( XEXP ( mem1 , <NUM_LIT> ) , & base1 , & offset1 ) ; mips_split_plus ( XEXP ( mem2 , <NUM_LIT> ) , & base2 , & offset2 ) ; if ( ! REG_P ( base1 ) || ! rtx_equal_p ( base1 , base2 ) ) return false ; if ( load_p && REGNO ( first_reg ) == REGNO ( base1 ) ) return false ; if ( load_p && swap_p && REGNO ( first_reg ) + <NUM_LIT> == REGNO ( base1 ) ) return false ; if ( offset2 != offset1 + <NUM_LIT> ) return false ;

if ( ! UMIPS_12BIT_OFFSET_P ( offset1 ) ) return false ;


<s> if ( ! REG_P ( reg1 ) || ! REG_P ( reg2 ) ) return false ; regno1 = REGNO ( reg1 ) ; regno2 = REGNO ( reg2 ) ; if ( ! GP_REG_P ( regno1 ) || ! GP_REG_P ( regno2 ) ) return false ; pair = ( <NUM_LIT> << regno1 ) | ( <NUM_LIT> << regno2 ) ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( match ) ; i ++ ) if ( pair == match [ i ] ) return true ;


<s> regno2 = REGNO ( reg2 ) ; if ( ! GP_REG_P ( regno1 ) || ! GP_REG_P ( regno2 ) ) return false ; pair = ( <NUM_LIT> << regno1 ) | ( <NUM_LIT> << regno2 ) ;

for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( match ) ; i ++ ) if ( pair == match [ i ] ) return true ;


<s> mem2 = operands [ <NUM_LIT> ] ; } else { reg1 = operands [ <NUM_LIT> ] ; reg2 = operands [ <NUM_LIT> ] ; mem1 = operands [ <NUM_LIT> ] ; mem2 = operands [ <NUM_LIT> ] ; } if ( REGNO ( reg2 ) == REGNO ( reg1 ) + <NUM_LIT> ) { umips_output_load_store_pair_1 ( load_p , reg1 , mem1 ) ; return ; } gcc_assert ( REGNO ( reg1 ) == REGNO ( reg2 ) + <NUM_LIT> ) ;


<s> static void umips_output_load_store_pair_1 ( bool load_p , rtx reg , rtx mem ) { rtx ops [ ] = { reg , mem } ; if ( load_p ) output_asm_insn ( <STR_LIT> , ops ) ;

else output_asm_insn ( <STR_LIT> , ops ) ;


<s> s += strlen ( s ) ; n = XVECLEN ( pattern , <NUM_LIT> ) ; set = XVECEXP ( pattern , <NUM_LIT> , <NUM_LIT> ) ; mem = save_p ? SET_DEST ( set ) : SET_SRC ( set ) ; mips_split_plus ( XEXP ( mem , <NUM_LIT> ) , & base , & offset ) ; last_set = XVECEXP ( pattern , <NUM_LIT> , n - <NUM_LIT> ) ; last_reg = save_p ? SET_SRC ( last_set ) : SET_DEST ( last_set ) ; if ( REGNO ( last_reg ) == <NUM_LIT> ) n -- ; gcc_assert ( n <= <NUM_LIT> ) ; if ( n == <NUM_LIT> ) ; else if ( n == <NUM_LIT> ) s += sprintf ( s , <STR_LIT> , reg_names [ <NUM_LIT> ] ) ; else if ( n < <NUM_LIT> ) s += sprintf ( s , <STR_LIT> , reg_names [ <NUM_LIT> ] , reg_names [ <NUM_LIT> + n ] ) ; else if ( n == <NUM_LIT> ) s += sprintf ( s , <STR_LIT> , reg_names [ <NUM_LIT> ] , reg_names [ <NUM_LIT> ] , reg_names [ <NUM_LIT> ] ) ; if ( REGNO ( last_reg ) == <NUM_LIT> ) s += sprintf ( s , <STR_LIT> , reg_names [ <NUM_LIT> ] ) ; s += sprintf ( s , <STR_LIT> , ( int ) offset , reg_names [ REGNO ( base ) ] ) ;


<s> if ( GET_CODE ( set ) != SET ) return false ; mem = save_p ? SET_DEST ( set ) : SET_SRC ( set ) ; if ( ! MEM_P ( mem ) || MEM_VOLATILE_P ( mem ) ) return false ; mips_split_plus ( XEXP ( mem , <NUM_LIT> ) , & this_base , & this_offset ) ; if ( ! REG_P ( this_base ) ) return false ; if ( n == <NUM_LIT> ) { if ( ! UMIPS_12BIT_OFFSET_P ( this_offset ) ) return false ; first_base = this_base ; first_offset = this_offset ; } else { if ( REGNO ( this_base ) != REGNO ( first_base ) || this_offset != first_offset + UNITS_PER_WORD * n ) return false ; }

reg = save_p ? SET_SRC ( set ) : SET_DEST ( set ) ;


<s> 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 ) ;


<s> first = SEQ_BEGIN ( insn ) ; 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 ) ) ) { rtx tmp = XEXP ( cond , <NUM_LIT> ) ; XEXP ( cond , <NUM_LIT> ) = XEXP ( cond , <NUM_LIT> ) ; XEXP ( cond , <NUM_LIT> ) = tmp ;


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


<s> static void vr4130_true_reg_dependence_p_1 ( rtx x , const_rtx pat ATTRIBUTE_UNUSED , void * data ) { rtx * insn_ptr ; insn_ptr = ( rtx * ) data ;

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


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