<s> gcc_assert ( GET_MODE_SIZE ( mode ) == UNITS_PER_HWFPVALUE ) ; high = mips_subword ( reg , true ) ; low = mips_subword ( reg , false ) ; return gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , high , low ) ) ; } return NULL_RTX ;


<s> else { if ( cfun -> machine -> global_pointer == regno ) return true ; }


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

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


<s> emit_insn ( gen_rtx_SET ( target , gen_rtx_fmt_ee ( code , GET_MODE ( target ) , op0 , op1 ) ) ) ;


<s> insn = emit_call_insn ( pattern ) ; if ( TARGET_MIPS16 && mips_use_pic_fn_addr_reg_p ( orig_addr ) ) { reg = gen_rtx_REG ( Pmode , PIC_FUNCTION_ADDR_REGNUM ) ; emit_insn_before ( gen_move_insn ( reg , addr ) , insn ) ; use_reg ( & CALL_INSN_FUNCTION_USAGE ( insn ) , reg ) ; } if ( lazy_p ) use_reg ( & CALL_INSN_FUNCTION_USAGE ( insn ) , pic_offset_table_rtx ) ; if ( TARGET_USE_GOT ) { use_reg ( & CALL_INSN_FUNCTION_USAGE ( insn ) , gen_rtx_REG ( Pmode , GOT_VERSION_REGNUM ) ) ; emit_insn ( gen_update_got_version ( ) ) ; }

if ( TARGET_MIPS16 && TARGET_EXPLICIT_RELOCS && TARGET_CALL_CLOBBERED_GP ) {


<s> static void mips_emit_loadgp ( void ) { rtx addr , offset , incoming_address , base , index , pic_reg ; pic_reg = TARGET_MIPS16 ? MIPS16_PIC_TEMP : pic_offset_table_rtx ; switch ( mips_current_loadgp_style ( ) ) { case LOADGP_ABSOLUTE : if ( mips_gnu_local_gp == NULL ) { mips_gnu_local_gp = gen_rtx_SYMBOL_REF ( Pmode , <STR_LIT> ) ; SYMBOL_REF_FLAGS ( mips_gnu_local_gp ) |= SYMBOL_FLAG_LOCAL ; } emit_insn ( PMODE_INSN ( gen_loadgp_absolute , ( pic_reg , mips_gnu_local_gp ) ) ) ; break ; case LOADGP_OLDABI : break ; case LOADGP_NEWABI : addr = XEXP ( DECL_RTL ( current_function_decl ) , <NUM_LIT> ) ; offset = mips_unspec_address ( addr , SYMBOL_GOTOFF_LOADGP ) ; incoming_address = gen_rtx_REG ( Pmode , PIC_FUNCTION_ADDR_REGNUM ) ; emit_insn ( PMODE_INSN ( gen_loadgp_newabi , ( pic_reg , offset , incoming_address ) ) ) ; break ; case LOADGP_RTP : base = gen_rtx_SYMBOL_REF ( Pmode , ggc_strdup ( VXWORKS_GOTT_BASE ) ) ;

index = gen_rtx_SYMBOL_REF ( Pmode , ggc_strdup ( VXWORKS_GOTT_INDEX ) ) ;


<s> rtx_insn * mips_emit_move ( rtx dest , rtx src ) {

return ( can_create_pseudo_p ( ) ? emit_move_insn ( dest , src ) : emit_move_insn_1 ( dest , src ) ) ;


<s> return ( can_create_pseudo_p ( ) ? emit_move_insn ( dest , src ) : emit_move_insn_1 ( dest , src ) ) ;


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


<s> 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 ) ; gcc_assert ( first <= <NUM_LIT> ) ; rounded_size = ROUND_DOWN ( size , PROBE_INTERVAL ) ; emit_insn ( gen_rtx_SET ( 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 ( r12 , gen_rtx_MINUS ( Pmode , r3 , r12 ) ) ) ; } else emit_insn ( gen_rtx_SET ( r12 , plus_constant ( Pmode , r3 , - rounded_size ) ) ) ; emit_insn ( PMODE_INSN ( gen_probe_stack_range , ( r3 , r3 , r12 ) ) ) ; if ( size != rounded_size ) emit_stack_probe ( plus_constant ( Pmode , r12 , rounded_size - size ) ) ; } emit_insn ( gen_blockage ( ) ) ;


<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 = ROUND_DOWN ( size , PROBE_INTERVAL ) ; emit_insn ( gen_rtx_SET ( r3 , plus_constant ( Pmode , stack_pointer_rtx , - first ) ) ) ; if ( rounded_size > <NUM_LIT> ) {


<s> 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_mthidi_ti ( 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 ) ) ) ; } else { if ( TARGET_64BIT ) emit_insn ( gen_mfhidi_ti ( temp , gen_rtx_REG ( TImode , MD_REG_FIRST ) ) ) ; else emit_insn ( gen_mfhisi_di ( temp , gen_rtx_REG ( DImode , MD_REG_FIRST ) ) ) ; mips_emit_move ( dest , temp ) ; } } else if ( mips_direct_save_slot_move_p ( regno , mem , mem == src ) ) mips_emit_move ( dest , src ) ; else {

gcc_assert ( ! reg_overlap_mentioned_p ( dest , temp ) ) ;


<s> emit_insn ( gen_rtx_SET ( target , gen_rtx_fmt_e ( code , GET_MODE ( op0 ) , op0 ) ) ) ;


<s> static void mips_end_function_definition ( const char * name ) {


<s> RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; REG_NOTES ( insn ) = mips_epilogue . cfa_restores ;


<s> if ( reg != mips_epilogue . cfa_reg || offset != mips_epilogue . cfa_offset ) { RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; REG_NOTES ( insn ) = alloc_reg_note ( REG_CFA_DEF_CFA , plus_constant ( Pmode , reg , offset ) , REG_NOTES ( insn ) ) ; mips_epilogue . cfa_reg = reg ;


<s> rtx_insn * insn ; insn = mips_epilogue_emit_cfa_restores ( ) ; if ( reg != mips_epilogue . cfa_reg || offset != mips_epilogue . cfa_offset ) { RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; REG_NOTES ( insn ) = alloc_reg_note ( REG_CFA_DEF_CFA , plus_constant ( Pmode , reg , offset ) , REG_NOTES ( insn ) ) ;


<s> if ( regno == RETURN_ADDR_REGNUM ) return true ; if ( TARGET_USE_GOT && ( regno ) == GOT_VERSION_REGNUM ) return true ; if ( cfun -> machine -> interrupt_handler_p && mips_interrupt_extra_call_saved_reg_p ( regno ) ) return true ; return false ;


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


<s> 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 ) ; else si_op = generator . fn_4 ( memsi , mask , inverted_mask , oldval ) ;


<s> if ( TARGET_CALL_CLOBBERED_GP ) emit_clobber ( pic_offset_table_rtx ) ;


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


<s> fcode = DECL_MD_FUNCTION_CODE ( fndecl ) ; gcc_assert ( fcode < ARRAY_SIZE ( mips_builtins ) ) ; d = & mips_builtins [ fcode ] ; avail = d -> avail ( ) ; 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 : case MIPS_BUILTIN_CMP_ALL :


<s> unsigned int fcode , avail ; const struct mips_builtin_description * d ; fndecl = TREE_OPERAND ( CALL_EXPR_FN ( exp ) , <NUM_LIT> ) ; fcode = DECL_MD_FUNCTION_CODE ( fndecl ) ; gcc_assert ( fcode < ARRAY_SIZE ( mips_builtins ) ) ; d = & mips_builtins [ fcode ] ; avail = d -> avail ( ) ; 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 : case MIPS_BUILTIN_CMP_ALL : case MIPS_BUILTIN_CMP_UPPER : case MIPS_BUILTIN_CMP_LOWER : case MIPS_BUILTIN_CMP_SINGLE : return mips_expand_builtin_compare ( d -> builtin_type , d -> icode , d -> cond , target , exp ) ; case MIPS_BUILTIN_MSA_TEST_BRANCH : return mips_expand_builtin_msa_test_branch ( d -> icode , exp ) ; case MIPS_BUILTIN_BPOSGE32 : return mips_expand_builtin_bposge ( d -> builtin_type , target ) ;


<s> rtx condition , cmp_result ; int cmp_value ; if ( target == <NUM_LIT> || GET_MODE ( target ) != SImode ) target = gen_reg_rtx ( SImode ) ; cmp_result = gen_rtx_REG ( CCDSPmode , CCDSP_PO_REGNUM ) ; if ( builtin_type == MIPS_BUILTIN_BPOSGE32 ) cmp_value = <NUM_LIT> ; else gcc_assert ( <NUM_LIT> ) ;

condition = gen_rtx_GE ( VOIDmode , cmp_result , GEN_INT ( cmp_value ) ) ;


<s> cmp_result = mips_expand_builtin_compare_1 ( icode , cond , exp , call_expr_nargs ( exp ) ) ; switch ( builtin_type ) { case MIPS_BUILTIN_CMP_ALL : condition = gen_rtx_NE ( VOIDmode , cmp_result , constm1_rtx ) ; return mips_builtin_branch_and_move ( condition , target , const0_rtx , const1_rtx ) ; case MIPS_BUILTIN_CMP_UPPER : case MIPS_BUILTIN_CMP_LOWER : offset = GEN_INT ( builtin_type == MIPS_BUILTIN_CMP_UPPER ) ; condition = gen_single_cc ( cmp_result , offset ) ;

return mips_builtin_branch_and_move ( condition , target , const1_rtx , const0_rtx ) ;


<s> static rtx mips_expand_builtin_compare_1 ( enum insn_code icode , enum mips_fp_condition cond , tree exp , int nargs ) { struct expand_operand ops [ MAX_RECOG_OPERANDS ] ; rtx output ; int opno , argno ; gcc_assert ( nargs + <NUM_LIT> == insn_data [ ( int ) icode ] . n_generator_args ) ; output = mips_allocate_fcc ( insn_data [ ( int ) icode ] . operand [ <NUM_LIT> ] . mode ) ;


<s> if ( has_target_p ) create_output_operand ( & ops [ opno ++ ] , target , TYPE_MODE ( TREE_TYPE ( exp ) ) ) ; gcc_assert ( opno + call_expr_nargs ( exp ) == insn_data [ icode ] . n_generator_args ) ;

for ( argno = <NUM_LIT> ; argno < call_expr_nargs ( exp ) ; argno ++ ) mips_prepare_builtin_arg ( & ops [ opno ++ ] , exp , argno ) ;


<s> static rtx mips_expand_builtin_direct ( enum insn_code icode , rtx target , tree exp , bool has_target_p ) { struct expand_operand ops [ MAX_RECOG_OPERANDS ] ; int opno , argno ; opno = <NUM_LIT> ; if ( has_target_p ) create_output_operand ( & ops [ opno ++ ] , target , TYPE_MODE ( TREE_TYPE ( exp ) ) ) ; gcc_assert ( opno + call_expr_nargs ( exp ) == insn_data [ icode ] . n_generator_args ) ; for ( argno = <NUM_LIT> ; argno < call_expr_nargs ( exp ) ; argno ++ ) mips_prepare_builtin_arg ( & ops [ opno ++ ] , exp , argno ) ;

return mips_expand_builtin_insn ( icode , opno , ops , has_target_p ) ;


<s> rtx cmp_result ; cmp_result = mips_expand_builtin_compare_1 ( icode , cond , exp , <NUM_LIT> ) ; create_output_operand ( & ops [ <NUM_LIT> ] , target , TYPE_MODE ( TREE_TYPE ( exp ) ) ) ; if ( type == MIPS_BUILTIN_MOVT ) { mips_prepare_builtin_arg ( & ops [ <NUM_LIT> ] , exp , <NUM_LIT> ) ; mips_prepare_builtin_arg ( & ops [ <NUM_LIT> ] , exp , <NUM_LIT> ) ; } else {


<s> mips_prepare_builtin_arg ( & ops [ <NUM_LIT> ] , exp , <NUM_LIT> ) ; } else { mips_prepare_builtin_arg ( & ops [ <NUM_LIT> ] , exp , <NUM_LIT> ) ; mips_prepare_builtin_arg ( & ops [ <NUM_LIT> ] , exp , <NUM_LIT> ) ; } create_fixed_operand ( & ops [ <NUM_LIT> ] , cmp_result ) ; return mips_expand_builtin_insn ( CODE_FOR_mips_cond_move_tf_ps , <NUM_LIT> , ops , true ) ;


<s> rtx_code_label * true_label , * done_label ; rtx cmp_result ; true_label = gen_label_rtx ( ) ; done_label = gen_label_rtx ( ) ; create_input_operand ( & ops [ <NUM_LIT> ] , true_label , TYPE_MODE ( TREE_TYPE ( exp ) ) ) ; mips_prepare_builtin_arg ( & ops [ <NUM_LIT> ] , exp , <NUM_LIT> ) ; create_fixed_operand ( & ops [ <NUM_LIT> ] , const0_rtx ) ; if ( GET_CODE ( ops [ <NUM_LIT> ] . value ) != REG ) ops [ <NUM_LIT> ] . value = force_reg ( ops [ <NUM_LIT> ] . mode , ops [ <NUM_LIT> ] . value ) ; if ( ( cbranch = maybe_gen_insn ( icode , <NUM_LIT> , ops ) ) == NULL_RTX ) error ( <STR_LIT> ) ;


<s> mips_prepare_builtin_arg ( & ops [ <NUM_LIT> ] , exp , <NUM_LIT> ) ; create_fixed_operand ( & ops [ <NUM_LIT> ] , const0_rtx ) ; if ( GET_CODE ( ops [ <NUM_LIT> ] . value ) != REG ) ops [ <NUM_LIT> ] . value = force_reg ( ops [ <NUM_LIT> ] . mode , ops [ <NUM_LIT> ] . value ) ; if ( ( cbranch = maybe_gen_insn ( icode , <NUM_LIT> , ops ) ) == NULL_RTX ) error ( <STR_LIT> ) ; cmp_result = gen_reg_rtx ( SImode ) ; mips_emit_move ( cmp_result , const0_rtx ) ; emit_jump_insn ( cbranch ) ; emit_jump_insn ( gen_jump ( done_label ) ) ; emit_barrier ( ) ;


<s> else fn = gen_call_internal ; pattern = fn ( addr , args_size ) ; } else if ( GET_CODE ( result ) == PARALLEL && XVECLEN ( result , <NUM_LIT> ) == <NUM_LIT> ) { rtx ( * fn ) ( rtx , rtx , rtx , rtx ) ; rtx reg1 , reg2 ; if ( type == MIPS_CALL_SIBCALL ) fn = gen_sibcall_value_multiple_internal ; else fn = gen_call_value_multiple_internal ; reg1 = XEXP ( XVECEXP ( result , <NUM_LIT> , <NUM_LIT> ) , <NUM_LIT> ) ; reg2 = XEXP ( XVECEXP ( result , <NUM_LIT> , <NUM_LIT> ) , <NUM_LIT> ) ; pattern = fn ( reg1 , addr , args_size , reg2 ) ; } else { rtx ( * fn ) ( rtx , rtx , rtx ) ; if ( type == MIPS_CALL_SIBCALL ) fn = gen_sibcall_value_internal ; else fn = gen_call_value_internal ; if ( GET_CODE ( result ) == PARALLEL && XVECLEN ( result , <NUM_LIT> ) == <NUM_LIT> ) result = XEXP ( XVECEXP ( result , <NUM_LIT> , <NUM_LIT> ) , <NUM_LIT> ) ; pattern = fn ( result , addr , args_size ) ; } return mips_emit_call_insn ( pattern , orig_addr , addr , lazy_p ) ;


<s> condition = gen_rtx_fmt_ee ( code , VOIDmode , op0 , op1 ) ; emit_jump_insn ( gen_condjump ( condition , operands [ <NUM_LIT> ] ) ) ;


<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> ] ) ; rtx temp = gen_reg_rtx ( mode ) ; rtx temp2 = gen_reg_rtx ( mode ) ; emit_insn ( gen_rtx_SET ( temp , gen_rtx_IF_THEN_ELSE ( mode , cond , operands [ <NUM_LIT> ] , const0_rtx ) ) ) ; cond = gen_rtx_fmt_ee ( ( code == EQ ) ? NE : EQ , GET_MODE ( op0 ) , op0 , op1 ) ; emit_insn ( gen_rtx_SET ( temp2 , gen_rtx_IF_THEN_ELSE ( mode , cond , operands [ <NUM_LIT> ] , const0_rtx ) ) ) ; emit_insn ( gen_rtx_SET ( operands [ <NUM_LIT> ] , gen_rtx_IOR ( mode , temp , temp2 ) ) ) ; } else { if ( FLOAT_MODE_P ( GET_MODE ( operands [ <NUM_LIT> ] ) ) && ! ISA_HAS_SEL ) { operands [ <NUM_LIT> ] = force_reg ( GET_MODE ( operands [ <NUM_LIT> ] ) , operands [ <NUM_LIT> ] ) ;


<s> break ; } mode = GET_MODE ( XEXP ( comparison , <NUM_LIT> ) ) ; op0 = force_reg ( mode , op0 ) ; if ( ! ( ISA_HAS_COND_TRAPI ? arith_operand ( op1 , mode ) : reg_or_0_operand ( op1 , mode ) ) ) op1 = force_reg ( mode , op1 ) ;

emit_insn ( gen_rtx_TRAP_IF ( VOIDmode , gen_rtx_fmt_ee ( code , mode , op0 , op1 ) , const0_rtx ) ) ;


<s> } mode = GET_MODE ( XEXP ( comparison , <NUM_LIT> ) ) ; op0 = force_reg ( mode , op0 ) ;

if ( ! ( ISA_HAS_COND_TRAPI ? arith_operand ( op1 , mode ) : reg_or_0_operand ( op1 , mode ) ) ) op1 = force_reg ( mode , op1 ) ;


<s> if ( ! mips_get_unaligned_mem ( src , width , bitpos , & left , & right ) ) return false ; temp = gen_reg_rtx ( GET_MODE ( dest ) ) ; if ( GET_MODE ( dest ) == DImode ) { emit_insn ( gen_mov_ldl ( temp , src , left ) ) ; emit_insn ( gen_mov_ldr ( dest , copy_rtx ( src ) , right , temp ) ) ; } else { emit_insn ( gen_mov_lwl ( temp , src , left ) ) ; emit_insn ( gen_mov_lwr ( dest , copy_rtx ( src ) , right , temp ) ) ; } if ( dest1 ) {

if ( unsigned_p ) emit_insn ( gen_zero_extendsidi2 ( dest1 , dest ) ) ;


<s> if ( ! TARGET_USE_GOT || cfun -> machine -> global_pointer == INVALID_REGNUM || mips_must_initialize_gp_p ( ) ) return false ; if ( ! mips_has_long_branch_p ( ) ) return false ; cfun -> machine -> must_initialize_gp_p = true ;


<s> if ( ! TARGET_USE_GOT || cfun -> machine -> global_pointer == INVALID_REGNUM || mips_must_initialize_gp_p ( ) ) return false ; if ( ! mips_has_long_branch_p ( ) ) return false ; cfun -> machine -> must_initialize_gp_p = true ; split_all_insns_noflow ( ) ; return true ;


<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 = int_mode_for_size ( width , <NUM_LIT> ) . require ( ) ; 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 ) ) ; } else { emit_insn ( gen_mov_swl ( dest , src , left ) ) ; emit_insn ( gen_mov_swr ( copy_rtx ( dest ) , copy_rtx ( src ) , right ) ) ; } return true ;


<s> case GTU : std :: swap ( op0 , op1 ) ; cond = swap_condition ( cond ) ; break ; default : gcc_unreachable ( ) ; } mips_emit_binary ( cond , dest , op0 , op1 ) ; if ( negate ) emit_move_insn ( dest , gen_rtx_NOT ( GET_MODE ( dest ) , dest ) ) ; break ; case E_V4SFmode : case E_V2DFmode : switch ( cond ) { case UNORDERED : case ORDERED : case EQ : case NE : case UNEQ : case UNLE : case UNLT : break ; case LTGT : cond = NE ; break ; case UNGE : cond = UNLE ; std :: swap ( op0 , op1 ) ; break ; case UNGT : cond = UNLT ; std :: swap ( op0 , op1 ) ; break ; case LE : unspec = UNSPEC_MSA_FSLE ; break ; case LT : unspec = UNSPEC_MSA_FSLT ; break ; case GE : unspec = UNSPEC_MSA_FSLE ; std :: swap ( op0 , op1 ) ; break ; case GT : unspec = UNSPEC_MSA_FSLT ; std :: swap ( op0 , op1 ) ; break ; default : gcc_unreachable ( ) ; } if ( unspec < <NUM_LIT> ) mips_emit_binary ( cond , dest , op0 , op1 ) ; else {

rtx x = gen_rtx_UNSPEC ( GET_MODE ( dest ) , gen_rtvec ( <NUM_LIT> , op0 , op1 ) , unspec ) ;


<s> rtx_insn * insn ; unsigned i ; if ( ! ISA_HAS_MSA ) return false ; for ( i = <NUM_LIT> ; i < d -> nelt ; i ++ ) elts [ i ] = GEN_INT ( d -> perm [ i ] ) ; v = gen_rtvec_v ( d -> nelt , elts ) ; x = gen_rtx_PARALLEL ( VOIDmode , v ) ;

if ( ! mips_const_vector_shuffle_set_p ( x , d -> vmode ) ) return false ;


<s> void mips_expand_scc ( rtx operands [ ] ) { rtx target = operands [ <NUM_LIT> ] ; enum rtx_code code = GET_CODE ( operands [ <NUM_LIT> ] ) ; rtx op0 = operands [ <NUM_LIT> ] ; rtx op1 = operands [ <NUM_LIT> ] ; gcc_assert ( GET_MODE_CLASS ( GET_MODE ( op0 ) ) == MODE_INT ) ; if ( code == EQ || code == NE ) { if ( ISA_HAS_SEQ_SNE && reg_imm10_operand ( op1 , GET_MODE ( op1 ) ) ) mips_emit_binary ( code , target , op0 , op1 ) ; else { rtx zie = mips_zero_if_equal ( op0 , op1 ) ; mips_emit_binary ( code , target , zie , const0_rtx ) ; } } else mips_emit_int_order_test ( code , <NUM_LIT> , target , op0 , op1 ) ;


<s> rtx_code_label * label , * end_label ; end_label = gen_label_rtx ( ) ; cmp_result = gen_rtx_EQ ( VOIDmode , begin , end ) ; emit_jump_insn ( gen_condjump ( cmp_result , end_label ) ) ; inc = gen_reg_rtx ( Pmode ) ; emit_insn ( PMODE_INSN ( gen_rdhwr_synci_step , ( inc ) ) ) ; cmp_result = gen_rtx_EQ ( VOIDmode , inc , const0_rtx ) ; emit_jump_insn ( gen_condjump ( cmp_result , end_label ) ) ; mask = mips_force_unary ( Pmode , NEG , inc ) ; begin = mips_force_binary ( Pmode , AND , begin , mask ) ; length = mips_force_binary ( Pmode , MINUS , end , begin ) ; label = gen_label_rtx ( ) ; emit_label ( label ) ;


<s> begin = mips_force_binary ( Pmode , AND , begin , mask ) ; length = mips_force_binary ( Pmode , MINUS , end , begin ) ; label = gen_label_rtx ( ) ; emit_label ( label ) ; emit_insn ( gen_synci ( begin ) ) ; mips_emit_binary ( MINUS , length , length , inc ) ;

mips_emit_binary ( PLUS , begin , begin , inc ) ;


<s> rtx mips_expand_thread_pointer ( rtx tp ) { rtx fn ; if ( TARGET_MIPS16 ) { if ( ! mips16_rdhwr_stub ) mips16_rdhwr_stub = new mips16_rdhwr_one_only_stub ( ) ; fn = mips16_stub_call_address ( mips16_rdhwr_stub ) ; emit_insn ( PMODE_INSN ( gen_tls_get_tp_mips16 , ( tp , fn ) ) ) ; }

else emit_insn ( PMODE_INSN ( gen_tls_get_tp , ( tp ) ) ) ;


<s> if ( TARGET_MIPS16 ) { if ( ! mips16_rdhwr_stub ) mips16_rdhwr_stub = new mips16_rdhwr_one_only_stub ( ) ; fn = mips16_stub_call_address ( mips16_rdhwr_stub ) ; emit_insn ( PMODE_INSN ( gen_tls_get_tp_mips16 , ( tp , fn ) ) ) ; } else emit_insn ( PMODE_INSN ( gen_tls_get_tp , ( tp ) ) ) ;


<s> static void mips_expand_to_rtl_hook ( void ) { mips_set_tuning_info ( ) ;


<s> reversed_p = mips_reversed_fp_cond ( & cond ) ; cmp_result = mips_allocate_fcc ( CCV2mode ) ;

emit_insn ( gen_scc_ps ( cmp_result , gen_rtx_fmt_ee ( cond , VOIDmode , cmp_op0 , cmp_op1 ) ) ) ;


<s> return ; default : gcc_unreachable ( ) ; } } temp = gen_reg_rtx ( imode ) ; if ( imode == GET_MODE ( same ) ) temp2 = same ; else if ( GET_MODE_SIZE ( imode ) >= UNITS_PER_WORD ) temp2 = simplify_gen_subreg ( imode , same , GET_MODE ( same ) , <NUM_LIT> ) ; else temp2 = lowpart_subreg ( imode , same , GET_MODE ( same ) ) ; emit_move_insn ( temp , temp2 ) ; switch ( vmode ) { case E_V16QImode : case E_V8HImode : case E_V4SImode : case E_V2DImode : mips_emit_move ( target , gen_rtx_VEC_DUPLICATE ( vmode , temp ) ) ; break ; case E_V4SFmode : emit_insn ( gen_msa_splati_w_f_scalar ( target , temp ) ) ; break ; case E_V2DFmode : emit_insn ( gen_msa_splati_d_f_scalar ( target , temp ) ) ; break ; default : gcc_unreachable ( ) ; } } else { emit_move_insn ( target , CONST0_RTX ( vmode ) ) ; for ( i = <NUM_LIT> ; i < nelt ; ++ i ) { rtx temp = gen_reg_rtx ( imode ) ; emit_move_insn ( temp , XVECEXP ( vals , <NUM_LIT> , i ) ) ; switch ( vmode ) { case E_V16QImode : emit_insn ( gen_vec_setv16qi ( target , temp , GEN_INT ( i ) ) ) ; break ; case E_V8HImode : emit_insn ( gen_vec_setv8hi ( target , temp , GEN_INT ( i ) ) ) ; break ; case E_V4SImode : emit_insn ( gen_vec_setv4si ( target , temp , GEN_INT ( i ) ) ) ; break ; case E_V2DImode : emit_insn ( gen_vec_setv2di ( target , temp , GEN_INT ( i ) ) ) ; break ; case E_V4SFmode : emit_insn ( gen_vec_setv4sf ( target , temp , GEN_INT ( i ) ) ) ; break ; case E_V2DFmode : emit_insn ( gen_vec_setv2df ( target , temp , GEN_INT ( i ) ) ) ; break ; default : gcc_unreachable ( ) ; } } } return ;


<s> rtx op0 = operands [ <NUM_LIT> ] ; rtx op1 = operands [ <NUM_LIT> ] ; rtx res = operands [ <NUM_LIT> ] ;

mips_expand_msa_cmp ( res , GET_CODE ( cond ) , op0 , op1 ) ;


<s> if ( operands [ <NUM_LIT> ] == CONSTM1_RTX ( vimode ) && operands [ <NUM_LIT> ] == CONST0_RTX ( vimode ) ) emit_move_insn ( operands [ <NUM_LIT> ] , cmp_res ) ; else { rtx src1 = gen_reg_rtx ( vimode ) ; rtx src2 = gen_reg_rtx ( vimode ) ; rtx mask = gen_reg_rtx ( vimode ) ; rtx bsel ; emit_move_insn ( mask , cmp_res ) ; if ( register_operand ( operands [ <NUM_LIT> ] , mode ) ) { rtx xop1 = operands [ <NUM_LIT> ] ; if ( mode != vimode ) { xop1 = gen_reg_rtx ( vimode ) ; emit_move_insn ( xop1 , gen_lowpart ( vimode , operands [ <NUM_LIT> ] ) ) ; } emit_move_insn ( src1 , xop1 ) ;


<s> rtx bsel ; emit_move_insn ( mask , cmp_res ) ; if ( register_operand ( operands [ <NUM_LIT> ] , mode ) ) { rtx xop1 = operands [ <NUM_LIT> ] ; if ( mode != vimode ) { xop1 = gen_reg_rtx ( vimode ) ; emit_move_insn ( xop1 , gen_lowpart ( vimode , operands [ <NUM_LIT> ] ) ) ; } emit_move_insn ( src1 , xop1 ) ; } else { gcc_assert ( operands [ <NUM_LIT> ] == CONSTM1_RTX ( vimode ) ) ; emit_move_insn ( src1 , mask ) ; } if ( register_operand ( operands [ <NUM_LIT> ] , mode ) ) { rtx xop2 = operands [ <NUM_LIT> ] ; if ( mode != vimode ) { xop2 = gen_reg_rtx ( vimode ) ; emit_move_insn ( xop2 , gen_lowpart ( vimode , operands [ <NUM_LIT> ] ) ) ; } emit_move_insn ( src2 , xop2 ) ; } else { gcc_assert ( operands [ <NUM_LIT> ] == CONST0_RTX ( mode ) ) ; emit_move_insn ( src2 , mask ) ;


<s> void mips_expand_vec_minmax ( rtx target , rtx op0 , rtx op1 , rtx ( * cmp ) ( rtx , rtx , rtx ) , bool min_p ) { machine_mode vmode = GET_MODE ( target ) ; 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 ( t0 , x ) ) ; x = gen_rtx_NOT ( vmode , tc ) ; x = gen_rtx_AND ( vmode , x , ( min_p ? op0 : op1 ) ) ;


<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 ( t0 , x ) ) ; x = gen_rtx_NOT ( vmode , tc ) ; x = gen_rtx_AND ( vmode , x , ( min_p ? op0 : op1 ) ) ; emit_insn ( gen_rtx_SET ( t1 , x ) ) ;


<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 ; if ( mips_expand_msa_shuffle ( d ) ) return true ;


<s> } else { 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 ;


<s> rtx last , next , fold , x ; bool ok ; last = in ; fold = gen_reg_rtx ( vmode ) ; switch ( vmode ) { case E_V2SFmode : perm2 [ <NUM_LIT> ] = <NUM_LIT> ; perm2 [ <NUM_LIT> ] = <NUM_LIT> ; ok = mips_expand_vselect_vconcat ( fold , last , last , perm2 , <NUM_LIT> ) ; gcc_assert ( ok ) ; break ; case E_V2SImode : emit_insn ( gen_loongson_punpckhwd ( fold , last , last ) ) ; break ; case E_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 E_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 ;


<s> break ; } if ( ! unsigned_p ) { tmp = gen_reg_rtx ( imode ) ; emit_insn ( cmpFunc ( tmp , operands [ <NUM_LIT> ] , CONST0_RTX ( imode ) ) ) ; } else tmp = force_reg ( imode , CONST0_RTX ( imode ) ) ; 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 ) ) ; return ; } switch ( imode ) { case E_V8QImode : if ( high_p ) unpack = gen_loongson_punpckhbh ; else unpack = gen_loongson_punpcklbh ; cmpFunc = gen_loongson_pcmpgtb ; break ; case E_V4HImode : if ( high_p ) unpack = gen_loongson_punpckhhw ;


<s> if ( MSA_SUPPORTED_MODE_P ( imode ) ) { switch ( imode ) { case E_V4SImode : if ( BYTES_BIG_ENDIAN != high_p ) unpack = gen_msa_ilvl_w ; else unpack = gen_msa_ilvr_w ; cmpFunc = gen_msa_clt_s_w ; break ; case E_V8HImode : if ( BYTES_BIG_ENDIAN != high_p ) unpack = gen_msa_ilvl_h ; else unpack = gen_msa_ilvr_h ; cmpFunc = gen_msa_clt_s_h ; break ; case E_V16QImode : if ( BYTES_BIG_ENDIAN != high_p ) unpack = gen_msa_ilvl_b ; else unpack = gen_msa_ilvr_b ; cmpFunc = gen_msa_clt_s_b ; break ; default : gcc_unreachable ( ) ; break ; } if ( ! unsigned_p ) { tmp = gen_reg_rtx ( imode ) ; emit_insn ( cmpFunc ( tmp , operands [ <NUM_LIT> ] , CONST0_RTX ( imode ) ) ) ; } else tmp = force_reg ( imode , CONST0_RTX ( imode ) ) ;


<s> case E_V8QImode : emit_insn ( gen_loongson_vec_init1_v8qi ( t1 , elt ) ) ; break ; case E_V4HImode : emit_insn ( gen_loongson_vec_init1_v4hi ( t1 , elt ) ) ; break ; default : gcc_unreachable ( ) ; } memset ( & d , <NUM_LIT> , sizeof ( d ) ) ; d . target = target ;


if ( ! mips_constant_elt_p ( elem ) ) RTVEC_ELT ( vec , i ) = CONST0_RTX ( GET_MODE ( elem ) ) ;


<s> unsigned int i , isize = GET_MODE_SIZE ( imode ) ; if ( nvar < nelt ) mips_expand_vi_constant ( vmode , nelt , mem , vals ) ; for ( i = <NUM_LIT> ; i < nelt ; ++ i ) {

rtx x = XVECEXP ( vals , <NUM_LIT> , i ) ;


<s> for ( i = <NUM_LIT> ; i < nelt ; ++ i ) { rtx x = XVECEXP ( vals , <NUM_LIT> , i ) ; if ( ! mips_constant_elt_p ( x ) ) emit_move_insn ( adjust_address ( mem , imode , i * isize ) , x ) ; } emit_move_insn ( target , mem ) ;


<s> mips_expand_vi_constant ( V4HImode , <NUM_LIT> , target , vals ) ;

emit_insn ( gen_vec_setv4hi ( target , target , XVECEXP ( vals , <NUM_LIT> , one_var ) , GEN_INT ( one_var ) ) ) ;


<s> static void mips_expand_vi_loongson_one_pinsrh ( rtx target , rtx vals , unsigned one_var ) { mips_expand_vi_constant ( V4HImode , <NUM_LIT> , target , vals ) ; emit_insn ( gen_vec_setv4hi ( target , target , XVECEXP ( vals , <NUM_LIT> , one_var ) , GEN_INT ( one_var ) ) ) ;


<s> unsigned i , elt ; rtx t0 , t1 ; if ( ! ( TARGET_HARD_FLOAT && TARGET_LOONGSON_MMI ) ) 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 ; if ( d -> testing_p ) return true ; t0 = gen_reg_rtx ( V8QImode ) ; if ( elt < <NUM_LIT> ) emit_insn ( gen_loongson_punpcklbh ( t0 , d -> op0 , d -> op0 ) ) ; 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> 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 ( odd ) emit_insn ( gen_loongson_punpckhhw ( d -> target , t1 , t0 ) ) ; else emit_insn ( gen_loongson_punpcklhw ( d -> target , t1 , t0 ) ) ; break ; case E_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 ) ) ; break ; default :


<s> static bool mips_expand_vpc_loongson_pshufh ( struct expand_vec_perm_d * d ) { unsigned i , mask ; rtx rmask ; if ( ! ( TARGET_HARD_FLOAT && TARGET_LOONGSON_MMI ) ) return false ; if ( d -> vmode != V4HImode ) return false ; 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> ] ; 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 ) ; emit_insn ( gen_rtx_SET ( t1 , x ) ) ;


<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 ( target , x ) ;


<s> x = gen_rtx_VEC_CONCAT ( v2mode , op0 , op1 ) ; return mips_expand_vselect ( target , x , perm , nelt ) ;


<s> if ( ! TARGET_ABSOLUTE_ABICALLS ) bitmap_set_bit ( regs , PIC_FUNCTION_ADDR_REGNUM ) ; if ( TARGET_MIPS16 ) bitmap_set_bit ( regs , MIPS16_PIC_TEMP_REGNUM ) ; bitmap_set_bit ( regs , GOT_VERSION_REGNUM ) ; }


<s> static bool mips_far_type_p ( const_tree type ) {

return ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type ) ) != NULL || lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type ) ) != NULL ) ;


<s> 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 ) ; if ( TARGET_ODD_SPREG ) fputs ( <STR_LIT> , asm_out_file ) ; else fputs ( <STR_LIT> , asm_out_file ) ; fprintf ( asm_out_file , <STR_LIT> , mips_arch_info -> name ) ; if ( TARGET_DSPR2 ) fputs ( <STR_LIT> , asm_out_file ) ; else if ( TARGET_DSP ) fputs ( <STR_LIT> , asm_out_file ) ; if ( TARGET_EVA ) fputs ( <STR_LIT> , asm_out_file ) ; if ( TARGET_MCU ) fputs ( <STR_LIT> , asm_out_file ) ; if ( TARGET_MDMX ) fputs ( <STR_LIT> , asm_out_file ) ; if ( TARGET_MIPS3D ) fputs ( <STR_LIT> , asm_out_file ) ; if ( TARGET_MT ) fputs ( <STR_LIT> , asm_out_file ) ; if ( TARGET_SMARTMIPS ) fputs ( <STR_LIT> , asm_out_file ) ; if ( TARGET_VIRT ) fputs ( <STR_LIT> , asm_out_file ) ; if ( TARGET_MSA ) fputs ( <STR_LIT> , asm_out_file ) ; if ( TARGET_XPA ) fputs ( <STR_LIT> , asm_out_file ) ; if ( TARGET_CRC ) fputs ( <STR_LIT> , asm_out_file ) ;

if ( TARGET_GINV ) fputs ( <STR_LIT> , asm_out_file ) ;


<s> if ( INSN_P ( insn ) && GET_CODE ( PATTERN ( insn ) ) == UNSPEC_VOLATILE && XINT ( PATTERN ( insn ) , <NUM_LIT> ) == UNSPEC_CONSTTABLE ) mips_set_text_contents_type ( asm_out_file , <STR_LIT> , INTVAL ( XVECEXP ( PATTERN ( insn ) , <NUM_LIT> , <NUM_LIT> ) ) , FALSE ) ;

if ( mips_need_noat_wrapper_p ( insn , opvec , noperands ) ) mips_push_asm_switch ( & mips_noat ) ;


<s> void mips_final_prescan_insn ( rtx_insn * insn , rtx * opvec , int noperands ) { if ( INSN_P ( insn ) && GET_CODE ( PATTERN ( insn ) ) == UNSPEC_VOLATILE && XINT ( PATTERN ( insn ) , <NUM_LIT> ) == UNSPEC_CONSTTABLE ) mips_set_text_contents_type ( asm_out_file , <STR_LIT> , INTVAL ( XVECEXP ( PATTERN ( insn ) , <NUM_LIT> , <NUM_LIT> ) ) , FALSE ) ; if ( mips_need_noat_wrapper_p ( insn , opvec , noperands ) ) mips_push_asm_switch ( & mips_noat ) ;


<s> for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) FOR_EACH_SUBINSN ( subinsn , insn ) if ( USEFUL_INSN_P ( subinsn ) && pred ( subinsn ) ) { * cache = true ; break ; }


<s> mips_start_unique_function ( name ) ; mips_start_function_definition ( name , false ) ; stub -> output_body ( ) ; mips_end_function_definition ( name ) ;


<s> mips_start_function_definition ( name , false ) ; stub -> output_body ( ) ; mips_end_function_definition ( name ) ; delete stub ;


<s> gcc_assert ( get_attr_type ( out_insn ) == TYPE_FMADD ) ; extract_insn ( in_insn ) ; dst_reg = REG_P ( recog_data . operand [ <NUM_LIT> ] ) ; extract_insn ( out_insn ) ; src_reg = REG_P ( recog_data . operand [ <NUM_LIT> ] ) ; if ( dst_reg == src_reg ) return true ;


<s> if ( ! mips_legitimate_address_p ( mode , x , false ) ) x = force_reg ( Pmode , x ) ; return x ;


<s> static rtx mips_force_binary ( machine_mode mode , enum rtx_code code , rtx op0 , rtx op1 ) { rtx reg ; reg = gen_reg_rtx ( mode ) ; mips_emit_binary ( code , reg , op0 , op1 ) ;


<s> static rtx mips_force_temporary ( rtx dest , rtx value ) { if ( can_create_pseudo_p ( ) ) return force_reg ( Pmode , value ) ;


<s> static rtx mips_force_unary ( machine_mode mode , enum rtx_code code , rtx op0 ) { rtx reg ; reg = gen_reg_rtx ( mode ) ;


for ( regno = DSP_ACC_REG_FIRST ; regno <= DSP_ACC_REG_LAST ; regno ++ ) if ( BITSET_P ( cfun -> machine -> frame . acc_mask , ( ( regno - DSP_ACC_REG_FIRST ) / <NUM_LIT> ) + <NUM_LIT> ) ) {


<s> offset = cfun -> machine -> frame . acc_sp_offset - sp_offset ; if ( BITSET_P ( cfun -> machine -> frame . acc_mask , <NUM_LIT> ) ) { mips_save_restore_reg ( word_mode , LO_REGNUM , offset , fn ) ; offset -= UNITS_PER_WORD ;

mips_save_restore_reg ( word_mode , HI_REGNUM , offset , fn ) ;


<s> offset = cfun -> machine -> frame . fp_sp_offset - sp_offset ; fpr_mode = ( TARGET_SINGLE_FLOAT ? SFmode : DFmode ) ; for ( regno = FP_REG_LAST - MAX_FPRS_PER_FMT + <NUM_LIT> ; regno >= FP_REG_FIRST ; regno -= MAX_FPRS_PER_FMT ) if ( BITSET_P ( cfun -> machine -> frame . fmask , regno - FP_REG_FIRST ) ) { if ( ! TARGET_FLOAT64 && TARGET_DOUBLE_FLOAT && ( fixed_regs [ regno ] || fixed_regs [ regno + <NUM_LIT> ] ) ) {

if ( fixed_regs [ regno ] ) mips_save_restore_reg ( SFmode , regno + <NUM_LIT> , offset , fn ) ;


<s> offset = cfun -> machine -> frame . fp_sp_offset - sp_offset ; fpr_mode = ( TARGET_SINGLE_FLOAT ? SFmode : DFmode ) ; for ( regno = FP_REG_LAST - MAX_FPRS_PER_FMT + <NUM_LIT> ; regno >= FP_REG_FIRST ; regno -= MAX_FPRS_PER_FMT ) if ( BITSET_P ( cfun -> machine -> frame . fmask , regno - FP_REG_FIRST ) ) { if ( ! TARGET_FLOAT64 && TARGET_DOUBLE_FLOAT && ( fixed_regs [ regno ] || fixed_regs [ regno + <NUM_LIT> ] ) ) { if ( fixed_regs [ regno ] ) mips_save_restore_reg ( SFmode , regno + <NUM_LIT> , offset , fn ) ; else mips_save_restore_reg ( SFmode , regno , offset , fn ) ;


<s> if ( TREE_CODE ( valtype ) != RECORD_TYPE ) return <NUM_LIT> ; i = <NUM_LIT> ; for ( field = TYPE_FIELDS ( valtype ) ; field != <NUM_LIT> ; field = DECL_CHAIN ( field ) ) { if ( TREE_CODE ( field ) != FIELD_DECL ) continue ; if ( cxx17_empty_base_field_p ( field ) ) { * has_cxx17_empty_base = true ; continue ; } if ( DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD ( field ) ) { * has_cxx_zero_width_bf = true ; continue ; } if ( ! SCALAR_FLOAT_TYPE_P ( TREE_TYPE ( field ) ) ) return <NUM_LIT> ;

if ( i == <NUM_LIT> ) return <NUM_LIT> ;


<s> static int mips_fpr_return_fields ( const_tree valtype , tree * fields , bool * has_cxx_zero_width_bf , bool * has_cxx17_empty_base ) { tree field ; int i ; if ( ! TARGET_NEWABI ) return <NUM_LIT> ; if ( TREE_CODE ( valtype ) != RECORD_TYPE ) return <NUM_LIT> ; i = <NUM_LIT> ; for ( field = TYPE_FIELDS ( valtype ) ; field != <NUM_LIT> ; field = DECL_CHAIN ( field ) ) { if ( TREE_CODE ( field ) != FIELD_DECL ) continue ; if ( cxx17_empty_base_field_p ( field ) ) { * has_cxx17_empty_base = true ; continue ; } if ( DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD ( field ) ) { * has_cxx_zero_width_bf = true ; continue ; }

if ( ! SCALAR_FLOAT_TYPE_P ( TREE_TYPE ( field ) ) ) return <NUM_LIT> ;


<s> static int mips_fp_div_cost ( machine_mode mode ) { return mode == DFmode ? mips_cost -> fp_div_df : mips_cost -> fp_div_sf ;


<s> static int mips_fp_mult_cost ( machine_mode mode ) { return mode == DFmode ? mips_cost -> fp_mult_df : mips_cost -> fp_mult_sf ;


<s> static void mips_frame_barrier ( void ) { emit_clobber ( gen_frame_mem ( BLKmode , stack_pointer_rtx ) ) ;


<s> if ( cfun -> calls_alloca ) return true ; if ( TARGET_MIPS16 ) { mips_compute_frame_info ( ) ; if ( ! SMALL_OPERAND ( cfun -> machine -> frame . total_size ) ) return true ; }


<s> static rtx mips_frame_set ( rtx mem , rtx reg ) { rtx set ; set = gen_rtx_SET ( mem , reg ) ; RTX_FRAME_RELATED_P ( set ) = <NUM_LIT> ;


<s> RTX_FRAME_RELATED_P ( set ) = <NUM_LIT> ; return set ;


<s> HOST_WIDE_INT bitpos ; rtx ret ; ret = gen_rtx_PARALLEL ( arg . mode , rtvec_alloc ( info . reg_words ) ) ; bitpos = <NUM_LIT> ; field = TYPE_FIELDS ( arg . type ) ; for ( i = <NUM_LIT> ; i < info . reg_words ; i ++ ) { rtx reg ; bool zero_width_field_abi_change = false ; for ( ; field ; field = DECL_CHAIN ( field ) ) { if ( TREE_CODE ( field ) != FIELD_DECL ) continue ; if ( DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD ( field ) ) continue ; if ( DECL_SIZE ( field ) && integer_zerop ( DECL_SIZE ( field ) ) ) { zero_width_field_abi_change = true ; continue ; } if ( int_bit_position ( field ) >= bitpos ) break ; } if ( field && int_bit_position ( field ) == bitpos && SCALAR_FLOAT_TYPE_P ( TREE_TYPE ( field ) ) && TYPE_PRECISION ( TREE_TYPE ( field ) ) == BITS_PER_WORD ) reg = gen_rtx_REG ( DFmode , FP_ARG_FIRST + info . reg_offset + i ) ; else { reg = gen_rtx_REG ( DImode , GP_ARG_FIRST + info . reg_offset + i ) ; zero_width_field_abi_change = false ; } if ( zero_width_field_abi_change && warn_psabi ) { static unsigned last_reported_type_uid ; unsigned uid = TYPE_UID ( TYPE_MAIN_VARIANT ( arg . type ) ) ; if ( uid != last_reported_type_uid ) { static const char * url = CHANGES_ROOT_URL <STR_LIT> ; inform ( input_location , <STR_LIT> <STR_LIT> <STR_LIT> <STR_LIT> , url ) ; last_reported_type_uid = uid ; } } XVECEXP ( ret , <NUM_LIT> , i ) = gen_rtx_EXPR_LIST ( VOIDmode , reg , GEN_INT ( bitpos / BITS_PER_UNIT ) ) ; bitpos += BITS_PER_WORD ; } return ret ; } } if ( TARGET_NEWABI && info . fpr_p && GET_MODE_CLASS ( arg . mode ) == MODE_COMPLEX_FLOAT ) {


<s> mips_get_arg_info ( & info , cum , arg . mode , arg . type , arg . named ) ; if ( info . reg_offset == MAX_ARGS_IN_REGISTERS ) return NULL ; if ( TARGET_NEWABI && TARGET_HARD_FLOAT && arg . named && arg . type != <NUM_LIT> && TREE_CODE ( arg . type ) == RECORD_TYPE && TYPE_SIZE_UNIT ( arg . type ) && tree_fits_uhwi_p ( TYPE_SIZE_UNIT ( arg . type ) ) ) { tree field ; for ( field = TYPE_FIELDS ( arg . type ) ; field ; field = DECL_CHAIN ( field ) ) if ( TREE_CODE ( field ) == FIELD_DECL && SCALAR_FLOAT_TYPE_P ( TREE_TYPE ( field ) ) && TYPE_PRECISION ( TREE_TYPE ( field ) ) == BITS_PER_WORD && tree_fits_shwi_p ( bit_position ( field ) ) && int_bit_position ( field ) % BITS_PER_WORD == <NUM_LIT> ) break ; if ( field != <NUM_LIT> ) { unsigned int i ; HOST_WIDE_INT bitpos ; rtx ret ; ret = gen_rtx_PARALLEL ( arg . mode , rtvec_alloc ( info . reg_words ) ) ; bitpos = <NUM_LIT> ; field = TYPE_FIELDS ( arg . type ) ; for ( i = <NUM_LIT> ; i < info . reg_words ; i ++ ) { rtx reg ; bool zero_width_field_abi_change = false ; for ( ; field ; field = DECL_CHAIN ( field ) ) { if ( TREE_CODE ( field ) != FIELD_DECL ) continue ; if ( DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD ( field ) ) continue ; if ( DECL_SIZE ( field ) && integer_zerop ( DECL_SIZE ( field ) ) ) { zero_width_field_abi_change = true ; continue ; } if ( int_bit_position ( field ) >= bitpos ) break ; } if ( field && int_bit_position ( field ) == bitpos && SCALAR_FLOAT_TYPE_P ( TREE_TYPE ( field ) ) && TYPE_PRECISION ( TREE_TYPE ( field ) ) == BITS_PER_WORD ) reg = gen_rtx_REG ( DFmode , FP_ARG_FIRST + info . reg_offset + i ) ; else { reg = gen_rtx_REG ( DImode , GP_ARG_FIRST + info . reg_offset + i ) ; zero_width_field_abi_change = false ; } if ( zero_width_field_abi_change && warn_psabi ) { static unsigned last_reported_type_uid ; unsigned uid = TYPE_UID ( TYPE_MAIN_VARIANT ( arg . type ) ) ; if ( uid != last_reported_type_uid ) { static const char * url = CHANGES_ROOT_URL <STR_LIT> ; inform ( input_location , <STR_LIT> <STR_LIT> <STR_LIT> <STR_LIT> , url ) ; last_reported_type_uid = uid ; } }

XVECEXP ( ret , <NUM_LIT> , i ) = gen_rtx_EXPR_LIST ( VOIDmode , reg , GEN_INT ( bitpos / BITS_PER_UNIT ) ) ;


<s> mips_get_arg_info ( & info , cum , arg . mode , arg . type , arg . named ) ; if ( ! info . fpr_p ) cum -> gp_reg_found = true ; if ( cum -> arg_number < <NUM_LIT> && info . fpr_p ) cum -> fp_code += ( arg . 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 ; cum -> arg_number ++ ;


<s> alignment = type ? TYPE_ALIGN ( type ) : GET_MODE_ALIGNMENT ( mode ) ; if ( alignment < PARM_BOUNDARY ) alignment = PARM_BOUNDARY ; if ( alignment > STACK_BOUNDARY ) alignment = STACK_BOUNDARY ; return alignment ;


<s> static unsigned int mips_function_arg_boundary ( machine_mode mode , const_tree type ) { unsigned int alignment ; alignment = type ? TYPE_ALIGN ( type ) : GET_MODE_ALIGNMENT ( mode ) ;

if ( alignment < PARM_BOUNDARY ) alignment = PARM_BOUNDARY ;


<s> static pad_direction mips_function_arg_padding ( machine_mode mode , const_tree type ) { if ( ! BYTES_BIG_ENDIAN ) return PAD_UPWARD ; 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 PAD_DOWNWARD ;

if ( mips_abi == ABI_O64 ) if ( type != <NUM_LIT> ? FLOAT_TYPE_P ( type ) : GET_MODE_CLASS ( mode ) == MODE_FLOAT ) return PAD_DOWNWARD ;


<s> if ( mips_abi != ABI_EABI ) return PAD_UPWARD ; if ( mode != BLKmode ? GET_MODE_BITSIZE ( mode ) >= PARM_BOUNDARY : int_size_in_bytes ( type ) >= ( PARM_BOUNDARY / BITS_PER_UNIT ) ) return PAD_UPWARD ; return PAD_DOWNWARD ;


<s> if ( decl && const_call_insn_operand ( XEXP ( DECL_RTL ( decl ) , <NUM_LIT> ) , VOIDmode ) && mips_call_may_need_jalx_p ( decl ) ) return false ;

if ( decl && TARGET_CALL_SAVED_GP && ! TARGET_ABICALLS_PIC0 && ! targetm . binds_local_p ( decl ) ) return false ;


<s> if ( cfun -> static_chain_decl != NULL ) fprintf ( file , <STR_LIT> , reg_names [ <NUM_LIT> ] , reg_names [ STATIC_CHAIN_REGNUM ] ) ; if ( TARGET_MCOUNT_RA_ADDRESS ) { if ( cfun -> machine -> frame . ra_fp_offset == <NUM_LIT> ) fprintf ( file , <STR_LIT> , reg_names [ <NUM_LIT> ] , reg_names [ <NUM_LIT> ] ) ; else fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , Pmode == DImode ? <STR_LIT> : <STR_LIT> , reg_names [ <NUM_LIT> ] , cfun -> machine -> frame . ra_fp_offset , reg_names [ STACK_POINTER_REGNUM ] ) ; } if ( ! TARGET_NEWABI ) fprintf ( file , <STR_LIT> , TARGET_64BIT ? <STR_LIT> : <STR_LIT> , reg_names [ STACK_POINTER_REGNUM ] , reg_names [ STACK_POINTER_REGNUM ] , Pmode == DImode ? <NUM_LIT> : <NUM_LIT> ) ; if ( TARGET_LONG_CALLS ) fprintf ( file , <STR_LIT> , reg_names [ <NUM_LIT> ] ) ; else fprintf ( file , <STR_LIT> ) ; mips_pop_asm_switch ( & mips_noat ) ;

if ( cfun -> static_chain_decl != NULL ) fprintf ( file , <STR_LIT> , reg_names [ STATIC_CHAIN_REGNUM ] , reg_names [ <NUM_LIT> ] ) ;


<s> if ( TARGET_MCOUNT_RA_ADDRESS ) { if ( cfun -> machine -> frame . ra_fp_offset == <NUM_LIT> ) fprintf ( file , <STR_LIT> , reg_names [ <NUM_LIT> ] , reg_names [ <NUM_LIT> ] ) ; else fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , Pmode == DImode ? <STR_LIT> : <STR_LIT> , reg_names [ <NUM_LIT> ] , cfun -> machine -> frame . ra_fp_offset , reg_names [ STACK_POINTER_REGNUM ] ) ; } if ( ! TARGET_NEWABI ) fprintf ( file , <STR_LIT> , TARGET_64BIT ? <STR_LIT> : <STR_LIT> , reg_names [ STACK_POINTER_REGNUM ] , reg_names [ STACK_POINTER_REGNUM ] , Pmode == DImode ? <NUM_LIT> : <NUM_LIT> ) ; if ( TARGET_LONG_CALLS ) fprintf ( file , <STR_LIT> , reg_names [ <NUM_LIT> ] ) ; else fprintf ( file , <STR_LIT> ) ; mips_pop_asm_switch ( & mips_noat ) ;


<s> if ( decl && DECL_SECTION_NAME ( decl ) ) { const char * name = DECL_SECTION_NAME ( decl ) ; if ( DECL_COMDAT_GROUP ( decl ) && strncmp ( name , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) { char * rname = ASTRDUP ( name ) ; rname [ <NUM_LIT> ] = 'd' ; return get_section ( rname , SECTION_LINKONCE | SECTION_WRITE , decl ) ; } else if ( flag_function_sections && flag_data_sections && strncmp ( name , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) { char * rname = ASTRDUP ( name ) ; memcpy ( rname + <NUM_LIT> , <STR_LIT> , <NUM_LIT> ) ; return get_section ( rname , SECTION_WRITE , decl ) ; } }


<s> static rtx mips_function_value ( const_tree valtype , const_tree fn_decl_or_type , bool outgoing ATTRIBUTE_UNUSED ) {

return mips_function_value_1 ( valtype , fn_decl_or_type , VOIDmode ) ;


<s> return mips_function_value_1 ( valtype , fn_decl_or_type , VOIDmode ) ;


<s> 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> ) ; bool has_cxx_zero_width_bf = false ; bool has_cxx17_empty_base = false ; int use_fpr = mips_fpr_return_fields ( valtype , fields , & has_cxx_zero_width_bf , & has_cxx17_empty_base ) ; if ( TARGET_HARD_FLOAT && warn_psabi && has_cxx_zero_width_bf && ! has_cxx17_empty_base && use_fpr != <NUM_LIT> ) { static unsigned last_reported_type_uid ; unsigned uid = TYPE_UID ( TYPE_MAIN_VARIANT ( valtype ) ) ; if ( uid != last_reported_type_uid ) { static const char * url = CHANGES_ROOT_URL <STR_LIT> ; inform ( input_location , <STR_LIT> <STR_LIT> <STR_LIT> <STR_LIT> , url ) ; last_reported_type_uid = uid ; } } if ( has_cxx_zero_width_bf ) use_fpr = <NUM_LIT> ; if ( TARGET_HARD_FLOAT && warn_psabi && use_fpr != <NUM_LIT> && has_cxx17_empty_base ) { static unsigned last_reported_type_uid ; unsigned uid = TYPE_UID ( TYPE_MAIN_VARIANT ( valtype ) ) ; if ( uid != last_reported_type_uid ) { static const char * url = CHANGES_ROOT_URL <STR_LIT> ; inform ( input_location , <STR_LIT> <STR_LIT> <STR_LIT> <STR_LIT> , url ) ; last_reported_type_uid = uid ; } } switch ( use_fpr ) { case <NUM_LIT> : return mips_return_fpr_single ( mode , TYPE_MODE ( TREE_TYPE ( fields [ <NUM_LIT> ] ) ) ) ;


<s> if ( regno == GP_RETURN || regno == FP_RETURN || ( FP_RETURN != GP_RETURN && regno == FP_RETURN + <NUM_LIT> ) ) return true ; if ( ( mips_abi == ABI_32 && TARGET_FLOAT32 ) && FP_RETURN != GP_RETURN && ( regno == FP_RETURN + <NUM_LIT> || regno == FP_RETURN + <NUM_LIT> ) ) return true ;


<s> rtx mips_gen_const_int_vector ( machine_mode mode , HOST_WIDE_INT val ) { rtx c = gen_int_mode ( val , GET_MODE_INNER ( mode ) ) ; return gen_const_vec_duplicate ( mode , c ) ;


<s> static rtx mips_gen_const_int_vector_shuffle ( machine_mode mode , int val ) { int nunits = GET_MODE_NUNITS ( mode ) ; int nsets = nunits / <NUM_LIT> ; rtx elts [ MAX_VECT_LEN ] ; int set = <NUM_LIT> ;


<s> gcc_assert ( TARGET_PAIRED_SINGLE_FLOAT || mode != V2SFmode ) ; info -> fpr_p = ( ! cum -> gp_reg_found && cum -> arg_number < <NUM_LIT> && ( type == <NUM_LIT> || SCALAR_FLOAT_TYPE_P ( type ) || VECTOR_FLOAT_TYPE_P ( type ) ) && ( GET_MODE_CLASS ( mode ) == MODE_FLOAT || mode == V2SFmode ) && GET_MODE_SIZE ( mode ) <= UNITS_PER_FPVALUE ) ; break ; case ABI_N32 : case ABI_64 : gcc_assert ( TARGET_PAIRED_SINGLE_FLOAT || mode != V2SFmode ) ; info -> fpr_p = ( named && ( type == <NUM_LIT> || FLOAT_TYPE_P ( type ) ) && ( GET_MODE_CLASS ( mode ) == MODE_FLOAT || GET_MODE_CLASS ( mode ) == MODE_COMPLEX_FLOAT || mode == V2SFmode ) && GET_MODE_UNIT_SIZE ( mode ) <= UNITS_PER_FPVALUE ) ;

if ( info -> fpr_p && GET_MODE_CLASS ( mode ) == MODE_COMPLEX_FLOAT && GET_MODE_UNIT_SIZE ( mode ) < UNITS_PER_FPVALUE ) {


<s> tree parent = decl_function_context ( decl ) ; if ( parent ) decl = parent ; force_on = mips_get_compress_on_flags ( DECL_ATTRIBUTES ( decl ) ) ; if ( force_on ) return force_on ;

flags &= ~ mips_get_compress_off_flags ( DECL_ATTRIBUTES ( decl ) ) ;


if ( lookup_attribute ( <STR_LIT> , attributes ) != NULL ) flags |= MASK_MIPS16 | MASK_MICROMIPS ;


<s> if ( flags == MASK_MICROMIPS ) return <STR_LIT> ; return <STR_LIT> ;


<s> if ( flags == MASK_MIPS16 ) return <STR_LIT> ; if ( flags == MASK_MICROMIPS ) return <STR_LIT> ; return <STR_LIT> ;


<s> if ( lookup_attribute ( <STR_LIT> , attributes ) != NULL ) flags |= MASK_MICROMIPS ; return flags ;


<s> if ( flags == MASK_MIPS16 ) return <STR_LIT> ; return <STR_LIT> ;


<s> frame = & cfun -> machine -> frame ; if ( frame_pointer_needed && ! ( TARGET_CPRESTORE_DIRECTIVE && ! load_p ) ) { * base = hard_frame_pointer_rtx ; * offset = frame -> args_size - frame -> hard_frame_pointer_offset ; } else { * base = stack_pointer_rtx ; * offset = frame -> args_size ; }


<s> static void mips_get_cprestore_base_and_offset ( rtx * base , HOST_WIDE_INT * offset , bool load_p ) { const struct mips_frame_info * frame ; frame = & cfun -> machine -> frame ; if ( frame_pointer_needed && ! ( TARGET_CPRESTORE_DIRECTIVE && ! load_p ) ) {


<s> if ( ! TARGET_RELAX_PIC_CALLS || args_size_opno == - <NUM_LIT> ) return false ; args_size = operands [ args_size_opno ] ; if ( GET_CODE ( args_size ) != UNSPEC ) return false ; gcc_assert ( XINT ( args_size , <NUM_LIT> ) == UNSPEC_CALL_ATTR ) ; symbol = XVECEXP ( args_size , <NUM_LIT> , <NUM_LIT> ) ;

gcc_assert ( GET_CODE ( symbol ) == SYMBOL_REF ) ;


<s> static fixed_size_mode mips_get_reg_raw_mode ( int regno ) {

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


<s> static rtx mips_get_sync_operand ( rtx * operands , int index , rtx default_value ) { if ( index > <NUM_LIT> ) default_value = operands [ index - <NUM_LIT> ] ; return default_value ;


<s> return mips_expand_thread_pointer ( gen_reg_rtx ( Pmode ) ) ;


return mips_expand_thread_pointer ( gen_reg_rtx ( Pmode ) ) ;


<s> if ( width != <NUM_LIT> && ( ! TARGET_64BIT || width != <NUM_LIT> ) ) return false ; if ( bitpos % BITS_PER_UNIT != <NUM_LIT> ) return false ;

if ( MEM_ALIGN ( op ) >= width ) return false ;


<s> last = adjust_address ( op , QImode , width / BITS_PER_UNIT - <NUM_LIT> ) ; if ( TARGET_BIG_ENDIAN ) * left = first , * right = last ; else * left = last , * right = first ;


<s> 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_used_regs [ regno ] && ! fixed_regs [ regno ] && regno != PIC_FUNCTION_ADDR_REGNUM ) return regno ;


<s> 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_used_regs [ regno ] && ! fixed_regs [ regno ] && regno != PIC_FUNCTION_ADDR_REGNUM ) return regno ; return GLOBAL_POINTER_REGNUM ;


<s> if ( ! decl ) return ! SYMBOL_REF_LOCAL_P ( x ) || SYMBOL_REF_EXTERNAL_P ( x ) ;

return DECL_P ( decl ) && ( TREE_PUBLIC ( decl ) || DECL_WEAK ( decl ) ) ;


<s> lo_sum_symbol = mips_unspec_address ( addr , type ) ; if ( type == SYMBOL_GOTOFF_CALL ) return mips_unspec_call ( high , lo_sum_symbol ) ;

else return PMODE_INSN ( gen_unspec_got , ( high , lo_sum_symbol ) ) ;


<s> rtx mips_got_load ( rtx temp , rtx addr , enum mips_symbol_type type ) { rtx base , high , lo_sum_symbol ; base = mips_pic_base_register ( temp ) ; if ( temp != NULL && reg_overlap_mentioned_p ( base , temp ) ) temp = NULL ;

high = mips_unspec_offset_high ( temp , base , addr , type ) ;


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


<s> if ( ISA_HAS_MSA && FP_REG_P ( regno ) && GET_MODE_SIZE ( mode ) > <NUM_LIT> ) return true ;


<s> static bool mips_hard_regno_mode_ok ( unsigned int regno , machine_mode mode ) { return mips_hard_regno_mode_ok_p [ mode ] [ regno ] ;


<s> static bool mips_hard_regno_mode_ok_uncached ( unsigned int regno , machine_mode mode ) { unsigned int size ; enum mode_class mclass ; 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 && ! MSA_SUPPORTED_MODE_P ( mode ) ) return ( ( regno - GP_REG_FIRST ) & <NUM_LIT> ) == <NUM_LIT> || size <= UNITS_PER_WORD ; if ( FP_REG_P ( regno ) && MSA_SUPPORTED_MODE_P ( mode ) ) return true ; 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_MMI && ( 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 ) ; }


<s> 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_MMI && ( 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 ;


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


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

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


<s> if ( cfun -> machine -> interrupt_handler_p && ! df_regs_ever_live_p ( new_reg ) ) return false ;


<s> bool mips_hard_regno_rename_ok ( unsigned int old_reg ATTRIBUTE_UNUSED , unsigned int new_reg ) { if ( cfun -> machine -> interrupt_handler_p && ! df_regs_ever_live_p ( new_reg ) ) return false ;


<s> if ( cfun -> machine -> interrupt_handler_p && ! df_regs_ever_live_p ( regno ) ) return false ;


<s> int do_not_record_p ; return hash_rtx ( base , GET_MODE ( base ) , & do_not_record_p , NULL , false ) ;


<s> static hashval_t mips_hash_base ( rtx base ) { int do_not_record_p ; return hash_rtx ( base , GET_MODE ( base ) , & do_not_record_p , NULL , false ) ;


for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) FOR_EACH_SUBINSN ( subinsn , insn ) if ( JUMP_P ( subinsn ) && get_attr_length ( subinsn ) > normal_length && ( any_condjump_p ( subinsn ) || any_uncondjump_p ( subinsn ) ) ) return true ;


<s> for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) FOR_EACH_SUBINSN ( subinsn , insn ) if ( JUMP_P ( subinsn ) && get_attr_length ( subinsn ) > normal_length && ( any_condjump_p ( subinsn ) || any_uncondjump_p ( subinsn ) ) ) return true ;


if ( GENERATE_DIVIDE_TRAPS && ! MSA_SUPPORTED_MODE_P ( mode ) ) count ++ ;


<s> case PLUS : case LT : case LTU : return SMALL_OPERAND ( x ) ; case EQ : case NE : case GT : case GTU : return x == <NUM_LIT> ; case GE : case GEU : return x == <NUM_LIT> ; case LE : return SMALL_OPERAND ( x + <NUM_LIT> ) ; case LEU : return SMALL_OPERAND ( x + <NUM_LIT> ) && x + <NUM_LIT> != <NUM_LIT> ; case SIGN_EXTRACT : case ZERO_EXTRACT : return ISA_HAS_EXT_INS ; default : return x == <NUM_LIT> ; }


<s> offset = cfun -> machine -> frame . arg_pointer_offset ; break ; default : gcc_unreachable ( ) ; }

if ( to == HARD_FRAME_POINTER_REGNUM ) offset -= cfun -> machine -> frame . hard_frame_pointer_offset ;


<s> mips_compute_frame_info ( ) ; switch ( from ) { case FRAME_POINTER_REGNUM : if ( FRAME_GROWS_DOWNWARD ) offset = ( cfun -> machine -> frame . args_size + cfun -> machine -> frame . cprestore_size + cfun -> machine -> frame . var_size ) ; else offset = <NUM_LIT> ; break ; case ARG_POINTER_REGNUM : offset = cfun -> machine -> frame . arg_pointer_offset ; break ; default : gcc_unreachable ( ) ; } if ( to == HARD_FRAME_POINTER_REGNUM ) offset -= cfun -> machine -> frame . hard_frame_pointer_offset ; return offset ;


<s> for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( mips_builtins ) ; i ++ ) { d = & mips_builtins [ i ] ; 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 ) ; if ( mips_builtin_decls [ i ] && d -> is_pure ) DECL_PURE_P ( mips_builtin_decls [ i ] ) = <NUM_LIT> ; mips_get_builtin_decl_index [ d -> icode ] = i ; } }


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


<s> void mips_init_cumulative_args ( CUMULATIVE_ARGS * cum , tree fntype ) { memset ( cum , <NUM_LIT> , sizeof ( * cum ) ) ; cum -> prototype = ( fntype && prototype_p ( fntype ) ) ;

cum -> gp_reg_found = ( cum -> prototype && stdarg_p ( fntype ) ) ;


<s> memset ( cum , <NUM_LIT> , sizeof ( * cum ) ) ;

cum -> prototype = ( fntype && prototype_p ( fntype ) ) ;


<s> static void mips_init_dfa_post_cycle_insn ( void ) { if ( TUNE_LOONGSON_2EF ) mips_ls2_init_dfa_post_cycle_insn ( ) ;


<s> } if ( TARGET_MIPS16 && TARGET_HARD_FLOAT_ABI ) { set_optab_libfunc ( add_optab , SFmode , <STR_LIT> ) ; set_optab_libfunc ( sub_optab , SFmode , <STR_LIT> ) ; set_optab_libfunc ( smul_optab , SFmode , <STR_LIT> ) ; set_optab_libfunc ( sdiv_optab , SFmode , <STR_LIT> ) ; set_optab_libfunc ( eq_optab , SFmode , <STR_LIT> ) ; set_optab_libfunc ( ne_optab , SFmode , <STR_LIT> ) ; set_optab_libfunc ( gt_optab , SFmode , <STR_LIT> ) ; set_optab_libfunc ( ge_optab , SFmode , <STR_LIT> ) ; set_optab_libfunc ( lt_optab , SFmode , <STR_LIT> ) ; set_optab_libfunc ( le_optab , SFmode , <STR_LIT> ) ; set_optab_libfunc ( unord_optab , SFmode , <STR_LIT> ) ; set_conv_libfunc ( sfix_optab , SImode , SFmode , <STR_LIT> ) ; set_conv_libfunc ( sfloat_optab , SFmode , SImode , <STR_LIT> ) ; set_conv_libfunc ( ufloat_optab , SFmode , SImode , <STR_LIT> ) ; if ( TARGET_DOUBLE_FLOAT ) { set_optab_libfunc ( add_optab , DFmode , <STR_LIT> ) ; set_optab_libfunc ( sub_optab , DFmode , <STR_LIT> ) ; set_optab_libfunc ( smul_optab , DFmode , <STR_LIT> ) ; set_optab_libfunc ( sdiv_optab , DFmode , <STR_LIT> ) ; set_optab_libfunc ( eq_optab , DFmode , <STR_LIT> ) ; set_optab_libfunc ( ne_optab , DFmode , <STR_LIT> ) ; set_optab_libfunc ( gt_optab , DFmode , <STR_LIT> ) ; set_optab_libfunc ( ge_optab , DFmode , <STR_LIT> ) ; set_optab_libfunc ( lt_optab , DFmode , <STR_LIT> ) ; set_optab_libfunc ( le_optab , DFmode , <STR_LIT> ) ;

set_optab_libfunc ( unord_optab , DFmode , <STR_LIT> ) ;


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


<s> static void mips_init_print_operand_punct ( void ) {


<s> mips_lo_relocs [ SYMBOL_64_MID ] = <STR_LIT> ; mips_split_p [ SYMBOL_64_LOW ] = true ; mips_hi_relocs [ SYMBOL_64_LOW ] = <STR_LIT> ; mips_lo_relocs [ SYMBOL_64_LOW ] = <STR_LIT> ; mips_split_p [ SYMBOL_ABSOLUTE ] = true ; mips_lo_relocs [ SYMBOL_ABSOLUTE ] = <STR_LIT> ; } } else { if ( TARGET_EXPLICIT_RELOCS || mips_split_addresses_p ( ) || TARGET_MIPS16 ) { mips_split_p [ SYMBOL_ABSOLUTE ] = true ; mips_hi_relocs [ SYMBOL_ABSOLUTE ] = <STR_LIT> ; mips_lo_relocs [ SYMBOL_ABSOLUTE ] = <STR_LIT> ; } } } if ( TARGET_MIPS16 ) { mips_split_p [ SYMBOL_GP_RELATIVE ] = true ; mips_lo_relocs [ SYMBOL_GP_RELATIVE ] = <STR_LIT> ; } else if ( TARGET_EXPLICIT_RELOCS ) mips_lo_relocs [ SYMBOL_GP_RELATIVE ] = <STR_LIT> ; if ( TARGET_EXPLICIT_RELOCS ) { mips_split_p [ SYMBOL_GOT_PAGE_OFST ] = true ; if ( TARGET_NEWABI ) { mips_lo_relocs [ SYMBOL_GOTOFF_PAGE ] = <STR_LIT> ; mips_lo_relocs [ SYMBOL_GOT_PAGE_OFST ] = <STR_LIT> ; } else { mips_lo_relocs [ SYMBOL_GOTOFF_PAGE ] = <STR_LIT> ; mips_lo_relocs [ SYMBOL_GOT_PAGE_OFST ] = <STR_LIT> ; } if ( TARGET_MIPS16 ) mips_split_hi_p [ SYMBOL_GOT_PAGE_OFST ] = true ; if ( TARGET_XGOT ) { mips_split_p [ SYMBOL_GOT_DISP ] = true ; mips_split_p [ SYMBOL_GOTOFF_DISP ] = true ; mips_hi_relocs [ SYMBOL_GOTOFF_DISP ] = <STR_LIT> ; mips_lo_relocs [ SYMBOL_GOTOFF_DISP ] = <STR_LIT> ; mips_split_p [ SYMBOL_GOTOFF_CALL ] = true ; mips_hi_relocs [ SYMBOL_GOTOFF_CALL ] = <STR_LIT> ; mips_lo_relocs [ SYMBOL_GOTOFF_CALL ] = <STR_LIT> ; } else { if ( TARGET_NEWABI ) mips_lo_relocs [ SYMBOL_GOTOFF_DISP ] = <STR_LIT> ; else mips_lo_relocs [ SYMBOL_GOTOFF_DISP ] = <STR_LIT> ; mips_lo_relocs [ SYMBOL_GOTOFF_CALL ] = <STR_LIT> ; if ( TARGET_MIPS16 ) mips_split_p [ SYMBOL_GOT_DISP ] = true ; } } if ( TARGET_NEWABI ) { mips_split_p [ SYMBOL_GOTOFF_LOADGP ] = true ; mips_hi_relocs [ SYMBOL_GOTOFF_LOADGP ] = <STR_LIT> ; mips_lo_relocs [ SYMBOL_GOTOFF_LOADGP ] = <STR_LIT> ; } mips_lo_relocs [ SYMBOL_TLSGD ] = <STR_LIT> ; mips_lo_relocs [ SYMBOL_TLSLDM ] = <STR_LIT> ; if ( TARGET_MIPS16_PCREL_LOADS ) { mips_use_pcrel_pool_p [ SYMBOL_DTPREL ] = true ; mips_use_pcrel_pool_p [ SYMBOL_TPREL ] = true ; } else { mips_split_p [ SYMBOL_DTPREL ] = true ; mips_hi_relocs [ SYMBOL_DTPREL ] = <STR_LIT> ; mips_lo_relocs [ SYMBOL_DTPREL ] = <STR_LIT> ; mips_split_p [ SYMBOL_TPREL ] = true ; mips_hi_relocs [ SYMBOL_TPREL ] = <STR_LIT> ;


<s> unsigned int compression_flags , nocompression_flags ; compression_flags = mips_get_compress_on_flags ( * attributes ) ; nocompression_flags = mips_get_compress_off_flags ( * attributes ) ; if ( TREE_CODE ( decl ) != FUNCTION_DECL ) { if ( nocompression_flags ) error ( <STR_LIT> , mips_get_compress_off_name ( nocompression_flags ) ) ; if ( compression_flags ) error ( <STR_LIT> , mips_get_compress_on_name ( nocompression_flags ) ) ; } else { compression_flags |= mips_get_compress_on_flags ( DECL_ATTRIBUTES ( decl ) ) ; nocompression_flags |= mips_get_compress_off_flags ( DECL_ATTRIBUTES ( decl ) ) ; if ( compression_flags && nocompression_flags ) error ( <STR_LIT> , DECL_NAME ( decl ) , mips_get_compress_on_name ( compression_flags ) , mips_get_compress_off_name ( nocompression_flags ) ) ; if ( compression_flags & MASK_MIPS16 && compression_flags & MASK_MICROMIPS ) error ( <STR_LIT> , DECL_NAME ( decl ) , <STR_LIT> , <STR_LIT> ) ; if ( TARGET_FLIP_MIPS16 && ! DECL_ARTIFICIAL ( decl ) && compression_flags == <NUM_LIT> && nocompression_flags == <NUM_LIT> ) { name = mflip_mips16_use_mips16_p ( decl ) ? <STR_LIT> : <STR_LIT> ;

* attributes = tree_cons ( get_identifier ( name ) , NULL , * attributes ) ;


<s> compression_flags = mips_get_compress_on_flags ( * attributes ) ; nocompression_flags = mips_get_compress_off_flags ( * attributes ) ; if ( TREE_CODE ( decl ) != FUNCTION_DECL ) { if ( nocompression_flags ) error ( <STR_LIT> , mips_get_compress_off_name ( nocompression_flags ) ) ; if ( compression_flags ) error ( <STR_LIT> , mips_get_compress_on_name ( nocompression_flags ) ) ; } else { compression_flags |= mips_get_compress_on_flags ( DECL_ATTRIBUTES ( decl ) ) ; nocompression_flags |= mips_get_compress_off_flags ( DECL_ATTRIBUTES ( decl ) ) ; if ( compression_flags && nocompression_flags ) error ( <STR_LIT> , DECL_NAME ( decl ) , mips_get_compress_on_name ( compression_flags ) , mips_get_compress_off_name ( nocompression_flags ) ) ; if ( compression_flags & MASK_MIPS16 && compression_flags & MASK_MICROMIPS ) error ( <STR_LIT> , DECL_NAME ( decl ) , <STR_LIT> , <STR_LIT> ) ; if ( TARGET_FLIP_MIPS16 && ! DECL_ARTIFICIAL ( decl ) && compression_flags == <NUM_LIT> && nocompression_flags == <NUM_LIT> ) { name = mflip_mips16_use_mips16_p ( decl ) ? <STR_LIT> : <STR_LIT> ;


<s> static void mips_insert_insn_pseudos ( void ) { bool insn_pseudo_needed = TRUE ; rtx_insn * insn ;

for ( insn = get_last_insn ( ) ; insn != NULL_RTX ; insn = PREV_INSN ( insn ) ) switch ( GET_CODE ( insn ) ) {


<s> return ( get_attr_got ( insn ) != GOT_UNSET || mips_small_data_pattern_p ( PATTERN ( insn ) ) || reg_overlap_mentioned_p ( pic_offset_table_rtx , PATTERN ( insn ) ) ) ;


<s> static bool mips_insn_has_inflexible_gp_ref_p ( rtx_insn * insn ) { return find_reg_fusage ( insn , USE , pic_offset_table_rtx ) ;


<s> return find_reg_fusage ( insn , USE , pic_offset_table_rtx ) ;


<s> if ( bb ) { if ( optimize_bb_for_speed_p ( bb ) ) return SPLIT_FOR_SPEED ; else return SPLIT_FOR_SIZE ;


<s> static enum mips_split_type mips_insn_split_type ( rtx insn ) { basic_block bb = BLOCK_FOR_INSN ( insn ) ; if ( bb ) {

if ( optimize_bb_for_speed_p ( bb ) ) return SPLIT_FOR_SPEED ;


<s> if ( ( ISA_HAS_HILO || TARGET_DSP ) && MD_REG_P ( regno ) ) return true ;

if ( TARGET_DSP && DSP_ACC_REG_P ( regno ) ) return true ;


<s> args = TREE_VALUE ( attr ) ; if ( args == NULL ) return INT_MASK_EIC ; cst = TREE_VALUE ( args ) ; if ( strcmp ( TREE_STRING_POINTER ( cst ) , <STR_LIT> ) == <NUM_LIT> ) return INT_MASK_EIC ; str = TREE_STRING_POINTER ( cst ) ; gcc_assert ( strlen ( str ) == strlen ( <STR_LIT> ) ) ; if ( str [ <NUM_LIT> ] == 's' ) return ( enum mips_int_mask ) ( INT_MASK_SW0 + ( str [ <NUM_LIT> ] - '0' ) ) ; return ( enum mips_int_mask ) ( INT_MASK_HW0 + ( str [ <NUM_LIT> ] - '0' ) ) ;


<s> if ( attr == NULL ) return INT_MASK_EIC ; args = TREE_VALUE ( attr ) ; if ( args == NULL ) return INT_MASK_EIC ; cst = TREE_VALUE ( args ) ; if ( strcmp ( TREE_STRING_POINTER ( cst ) , <STR_LIT> ) == <NUM_LIT> ) return INT_MASK_EIC ; str = TREE_STRING_POINTER ( cst ) ; gcc_assert ( strlen ( str ) == strlen ( <STR_LIT> ) ) ; if ( str [ <NUM_LIT> ] == 's' ) return ( enum mips_int_mask ) ( INT_MASK_SW0 + ( str [ <NUM_LIT> ] - '0' ) ) ;

return ( enum mips_int_mask ) ( INT_MASK_HW0 + ( str [ <NUM_LIT> ] - '0' ) ) ;


<s> return lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type ) ) != NULL ;


<s> return arith_operand ( cmp1 , VOIDmode ) ; case LE : return sle_operand ( cmp1 , VOIDmode ) ; case LEU : return sleu_operand ( cmp1 , VOIDmode ) ; default : gcc_unreachable ( ) ; }


<s> else if ( TARGET_EMBEDDED_DATA ) { if ( TREE_CODE ( decl ) != VAR_DECL ) return false ; if ( TREE_READONLY ( decl ) && ! TREE_SIDE_EFFECTS ( decl ) && ( ! DECL_INITIAL ( decl ) || TREE_CONSTANT ( DECL_INITIAL ( decl ) ) ) ) return false ; } if ( ! TARGET_LOCAL_SDATA && ! TREE_PUBLIC ( decl ) ) return false ; if ( ! TARGET_EXTERN_SDATA && DECL_P ( decl ) ) { if ( DECL_EXTERNAL ( decl ) ) return false ; if ( DECL_COMMON ( decl ) && DECL_INITIAL ( decl ) == NULL ) return false ;


if ( INTEGRAL_MODE_P ( PSEUDO_REGNO_MODE ( regno ) ) && allocno_class == ALL_REGS ) return GR_REGS ;


<s> case PROCESSOR_OCTEON2 : case PROCESSOR_OCTEON3 : case PROCESSOR_I6400 : case PROCESSOR_GS264E : return <NUM_LIT> ; case PROCESSOR_SB1 : case PROCESSOR_SB1A : return <NUM_LIT> ; case PROCESSOR_LOONGSON_2E : case PROCESSOR_LOONGSON_2F : case PROCESSOR_GS464 : case PROCESSOR_GS464E : case PROCESSOR_P5600 : case PROCESSOR_P6600 : return <NUM_LIT> ; case PROCESSOR_XLP : return ( reload_completed ? <NUM_LIT> : <NUM_LIT> ) ; default : return <NUM_LIT> ;


<s> if ( shift < <NUM_LIT> || shift > <NUM_LIT> ) gcc_unreachable ( ) ;


<s> static bool mips_legitimate_address_p ( machine_mode mode , rtx x , bool strict_p ) {


<s> static bool mips_legitimate_address_p ( machine_mode mode , rtx x , bool strict_p ) { struct mips_address_info addr ; return mips_classify_address ( & addr , x , mode , strict_p ) ;


<s> return mips_const_insns ( x ) > <NUM_LIT> ;


<s> static bool mips_legitimate_constant_p ( machine_mode mode ATTRIBUTE_UNUSED , rtx x ) {

return mips_const_insns ( x ) > <NUM_LIT> ;


<s> if ( offset != <NUM_LIT> ) { if ( ! mips_valid_base_register_p ( base , mode , false ) ) base = copy_to_mode_reg ( Pmode , base ) ; addr = mips_add_offset ( NULL , base , offset ) ; return mips_force_address ( addr , mode ) ; } return x ;


<s> if ( offset != <NUM_LIT> ) { if ( ! mips_valid_base_register_p ( base , mode , false ) ) base = copy_to_mode_reg ( Pmode , base ) ; addr = mips_add_offset ( NULL , base , offset ) ; return mips_force_address ( addr , mode ) ;


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

base = mips_force_temporary ( dest , base ) ;


<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> { v0 = gen_rtx_REG ( Pmode , GP_RETURN ) ; rtx_insn * insn = mips_call_tls_get_addr ( loc , SYMBOL_TLSGD , v0 ) ; dest = gen_reg_rtx ( Pmode ) ; emit_libcall_block ( insn , dest , v0 , loc ) ; break ; } case TLS_MODEL_LOCAL_DYNAMIC : { v0 = gen_rtx_REG ( Pmode , GP_RETURN ) ; rtx_insn * insn = mips_call_tls_get_addr ( loc , SYMBOL_TLSLDM , v0 ) ; tmp1 = gen_reg_rtx ( Pmode ) ; eqv = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , const0_rtx ) , UNSPEC_TLS_LDM ) ; emit_libcall_block ( insn , tmp1 , v0 , eqv ) ; offset = mips_unspec_address ( loc , SYMBOL_DTPREL ) ; if ( mips_split_p [ SYMBOL_DTPREL ] ) { tmp2 = mips_unspec_offset_high ( NULL , tmp1 , loc , SYMBOL_DTPREL ) ; dest = gen_rtx_LO_SUM ( Pmode , tmp2 , offset ) ; } else dest = expand_binop ( Pmode , add_optab , tmp1 , offset , <NUM_LIT> , <NUM_LIT> , OPTAB_DIRECT ) ; break ; } case TLS_MODEL_INITIAL_EXEC : tp = mips_get_tp ( ) ; tmp1 = gen_reg_rtx ( Pmode ) ; tmp2 = mips_unspec_address ( loc , SYMBOL_GOTTPREL ) ; if ( Pmode == DImode ) emit_insn ( gen_load_gotdi ( tmp1 , pic_offset_table_rtx , tmp2 ) ) ; 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 ) ;


<s> static rtx mips_libcall_value ( machine_mode mode , const_rtx fun ATTRIBUTE_UNUSED ) { return mips_function_value_1 ( NULL_TREE , NULL_TREE , mode ) ;


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


<s> if ( cfun -> machine -> load_label_num_insns == <NUM_LIT> ) {


<s> if ( cfun -> machine -> load_label_num_insns == <NUM_LIT> ) { mips_process_load_label ( pc_rtx ) ; cfun -> machine -> load_label_num_insns = mips_multi_num_insns ; }

return cfun -> machine -> load_label_num_insns ;


<s> gcc_assert ( MEM_P ( mem ) ) ; mode = GET_MODE ( mem ) ; might_split_p = GET_MODE_SIZE ( mode ) > UNITS_PER_WORD ; if ( might_split_p ) { set = single_set ( insn ) ; if ( set && ! mips_split_move_insn_p ( SET_DEST ( set ) , SET_SRC ( set ) , insn ) ) might_split_p = false ; }

return mips_address_insns ( XEXP ( mem , <NUM_LIT> ) , mode , might_split_p ) ;


<s> rtx mips_loongson_ext2_prefetch_cookie ( rtx write , rtx ) { if ( INTVAL ( write ) == <NUM_LIT> ) return GEN_INT ( INTVAL ( write ) ) ;


<s> if ( UNSPEC_ADDRESS_P ( base ) ) base = UNSPEC_ADDRESS ( base ) ; slot = htab -> find_slot_with_hash ( base , mips_hash_base ( base ) , option ) ; if ( slot == NULL ) return false ; entry = ( struct mips_lo_sum_offset * ) * slot ; if ( option == INSERT ) { if ( entry == NULL ) { entry = XNEW ( struct mips_lo_sum_offset ) ; entry -> base = base ; entry -> offset = INTVAL ( offset ) ;


<s> if ( slot == NULL ) return false ; entry = ( struct mips_lo_sum_offset * ) * slot ; if ( option == INSERT ) { if ( entry == NULL ) { entry = XNEW ( struct mips_lo_sum_offset ) ; entry -> base = base ; entry -> offset = INTVAL ( offset ) ; * slot = entry ; } else {

if ( INTVAL ( offset ) > entry -> offset ) entry -> offset = INTVAL ( offset ) ;


<s> static bool mips_lra_p ( void ) { return mips_lra_flag ;


<s> else { if ( state_transition ( state , mips_ls2 . alu2_turn_enabled_insn ) >= <NUM_LIT> ) gcc_unreachable ( ) ; } if ( cpu_unit_reservation_p ( state , mips_ls2 . falu1_core_unit_code ) ) { gcc_unreachable ( ) ; mips_ls2 . falu1_turn_p = false ; } if ( cpu_unit_reservation_p ( state , mips_ls2 . falu2_core_unit_code ) ) mips_ls2 . falu1_turn_p = true ; if ( mips_ls2 . falu1_turn_p ) { if ( state_transition ( state , mips_ls2 . falu1_turn_enabled_insn ) >= <NUM_LIT> ) gcc_unreachable ( ) ;


<s> else { if ( state_transition ( state , mips_ls2 . alu2_turn_enabled_insn ) >= <NUM_LIT> ) gcc_unreachable ( ) ; } if ( cpu_unit_reservation_p ( state , mips_ls2 . falu1_core_unit_code ) ) { gcc_unreachable ( ) ; mips_ls2 . falu1_turn_p = false ; } if ( cpu_unit_reservation_p ( state , mips_ls2 . falu2_core_unit_code ) ) mips_ls2 . falu1_turn_p = true ; if ( mips_ls2 . falu1_turn_p ) { if ( state_transition ( state , mips_ls2 . falu1_turn_enabled_insn ) >= <NUM_LIT> ) gcc_unreachable ( ) ; }


<s> start_sequence ( ) ; emit_insn ( gen_ls2_alu1_turn_enabled_insn ( ) ) ; mips_ls2 . alu1_turn_enabled_insn = get_insns ( ) ; end_sequence ( ) ; start_sequence ( ) ; emit_insn ( gen_ls2_alu2_turn_enabled_insn ( ) ) ; mips_ls2 . alu2_turn_enabled_insn = get_insns ( ) ; end_sequence ( ) ; start_sequence ( ) ; emit_insn ( gen_ls2_falu1_turn_enabled_insn ( ) ) ; mips_ls2 . falu1_turn_enabled_insn = get_insns ( ) ; end_sequence ( ) ; start_sequence ( ) ; emit_insn ( gen_ls2_falu2_turn_enabled_insn ( ) ) ; mips_ls2 . falu2_turn_enabled_insn = get_insns ( ) ; end_sequence ( ) ; mips_ls2 . alu1_core_unit_code = get_cpu_unit_code ( <STR_LIT> ) ;


<s> if ( mips_ls2 . alu1_turn_p ) { if ( cpu_unit_reservation_p ( curr_state , mips_ls2 . alu1_core_unit_code ) ) mips_ls2 . alu1_turn_p = false ; } else { if ( cpu_unit_reservation_p ( curr_state , mips_ls2 . alu2_core_unit_code ) ) mips_ls2 . alu1_turn_p = true ; } if ( mips_ls2 . falu1_turn_p ) { if ( cpu_unit_reservation_p ( curr_state , mips_ls2 . falu1_core_unit_code ) ) mips_ls2 . falu1_turn_p = false ; } else {


<s> } if ( mips_ls2 . falu1_turn_p ) { if ( cpu_unit_reservation_p ( curr_state , mips_ls2 . falu1_core_unit_code ) ) mips_ls2 . falu1_turn_p = false ; } else { if ( cpu_unit_reservation_p ( curr_state , mips_ls2 . falu2_core_unit_code ) ) mips_ls2 . falu1_turn_p = true ; } if ( recog_memoized ( insn ) >= <NUM_LIT> ) mips_ls2 . cycle_has_multi_p |= ( get_attr_type ( insn ) == TYPE_MULTI ) ;


<s> static bool mips_lwxs_address_p ( rtx addr ) { if ( ISA_HAS_LWXS && GET_CODE ( addr ) == PLUS && REG_P ( XEXP ( addr , <NUM_LIT> ) ) ) { rtx offset = XEXP ( addr , <NUM_LIT> ) ; if ( GET_CODE ( offset ) == MULT && REG_P ( XEXP ( offset , <NUM_LIT> ) ) && CONST_INT_P ( XEXP ( offset , <NUM_LIT> ) ) && INTVAL ( XEXP ( offset , <NUM_LIT> ) ) == <NUM_LIT> ) return true ; }


<s> static bool mips_lwxs_address_p ( rtx addr ) { if ( ISA_HAS_LWXS && GET_CODE ( addr ) == PLUS && REG_P ( XEXP ( addr , <NUM_LIT> ) ) ) { rtx offset = XEXP ( addr , <NUM_LIT> ) ; if ( GET_CODE ( offset ) == MULT && REG_P ( XEXP ( offset , <NUM_LIT> ) ) && CONST_INT_P ( XEXP ( offset , <NUM_LIT> ) ) && INTVAL ( XEXP ( offset , <NUM_LIT> ) ) == <NUM_LIT> ) return true ;


<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> if ( get_attr_may_clobber_hilo ( insn ) ) mips_macc_chains_last_hilo = insn ;


<s> if ( mips_macc_chains_last_hilo != <NUM_LIT> ) for ( i = nready - <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) if ( mips_linked_madd_p ( mips_macc_chains_last_hilo , ready [ i ] ) ) {

for ( j = nready - <NUM_LIT> ; j > i ; j -- ) if ( recog_memoized ( ready [ j ] ) >= <NUM_LIT> && get_attr_may_clobber_hilo ( ready [ j ] ) ) {


<s> int i , j ; if ( mips_macc_chains_last_hilo != <NUM_LIT> ) for ( i = nready - <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) if ( mips_linked_madd_p ( mips_macc_chains_last_hilo , ready [ i ] ) ) { for ( j = nready - <NUM_LIT> ; j > i ; j -- ) if ( recog_memoized ( ready [ j ] ) >= <NUM_LIT> && get_attr_may_clobber_hilo ( ready [ j ] ) ) { mips_promote_ready ( ready , i , j ) ; break ;


<s> mips_reorg_process_insns ( ) ; if ( ! TARGET_MIPS16 && TARGET_EXPLICIT_RELOCS && TUNE_MIPS4130 && TARGET_VR4130_ALIGN ) vr4130_align_insns ( ) ;

if ( mips_expand_ghost_gp_insns ( ) ) mips_reorg_process_insns ( ) ;


<s> static void mips_maybe_swap_ready ( rtx_insn * * ready , int pos1 , int pos2 , int limit ) { if ( pos1 < pos2 && INSN_PRIORITY ( ready [ pos1 ] ) + limit >= INSN_PRIORITY ( ready [ pos2 ] ) ) {


<s> case ABI_EABI : return TARGET_64BIT ? <STR_LIT> : <STR_LIT> ; default : gcc_unreachable ( ) ;


<s> static int mips_memory_move_cost ( machine_mode mode , reg_class_t rclass , bool in ) {

return ( mips_cost -> memory_latency + memory_move_secondary_cost ( mode , rclass , in ) ) ;


<s> bool mips_mem_fits_mode_p ( machine_mode mode , rtx x ) {

return ( MEM_P ( x ) && MEM_SIZE_KNOWN_P ( x ) && MEM_SIZE ( x ) == GET_MODE_SIZE ( mode ) ) ;


<s> diff = ( mips_get_compress_off_flags ( DECL_ATTRIBUTES ( olddecl ) ) ^ mips_get_compress_off_flags ( DECL_ATTRIBUTES ( newdecl ) ) ) ; if ( diff ) error ( <STR_LIT> , DECL_NAME ( newdecl ) , mips_get_compress_off_name ( diff ) ) ;

return merge_attributes ( DECL_ATTRIBUTES ( olddecl ) , DECL_ATTRIBUTES ( newdecl ) ) ;


<s> diff = ( mips_get_compress_on_flags ( DECL_ATTRIBUTES ( olddecl ) ) ^ mips_get_compress_on_flags ( DECL_ATTRIBUTES ( newdecl ) ) ) ; if ( diff ) error ( <STR_LIT> , DECL_NAME ( newdecl ) , mips_get_compress_on_name ( diff ) ) ; diff = ( mips_get_compress_off_flags ( DECL_ATTRIBUTES ( olddecl ) ) ^ mips_get_compress_off_flags ( DECL_ATTRIBUTES ( newdecl ) ) ) ; if ( diff ) error ( <STR_LIT> , DECL_NAME ( newdecl ) , mips_get_compress_off_name ( diff ) ) ; return merge_attributes ( DECL_ATTRIBUTES ( olddecl ) , DECL_ATTRIBUTES ( newdecl ) ) ;


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


<s> switch ( mode ) { case E_CCFmode : case E_SFmode : return TARGET_HARD_FLOAT ; case E_DFmode : return TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT ; case E_V2SFmode : return TARGET_HARD_FLOAT && TARGET_PAIRED_SINGLE_FLOAT ;


<s> switch ( mode ) { case E_CCFmode : case E_SFmode : return TARGET_HARD_FLOAT ; case E_DFmode : return TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT ;


<s> static int mips_mode_rep_extended ( scalar_int_mode mode , scalar_int_mode mode_rep ) { if ( TARGET_64BIT && mode == SImode && mode_rep == DImode ) return SIGN_EXTEND ;


<s> case FP_REGS : return <NUM_LIT> ; case COP0_REGS : case COP2_REGS : case COP3_REGS : return <NUM_LIT> ;


<s> return <NUM_LIT> ; case ACC_REGS : return <NUM_LIT> ; case FP_REGS : return <NUM_LIT> ; case COP0_REGS : case COP2_REGS : case COP3_REGS : return <NUM_LIT> ;


<s> 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 ( 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> case M16_REGS : case GENERAL_REGS : return <NUM_LIT> ; case ACC_REGS : return <NUM_LIT> ;


<s> case COP0_REGS : case COP2_REGS : case COP3_REGS : return <NUM_LIT> ; default : return <NUM_LIT> ;


<s> if ( TARGET_CHECK_ZERO_DIV ) { output_asm_insn ( <STR_LIT> , operands ) ;


<s> machine_mode mode = amount -> mode ; unsigned val = UINTVAL ( CONST_VECTOR_ELT ( amount , <NUM_LIT> ) ) ; val &= GET_MODE_UNIT_BITSIZE ( mode ) - <NUM_LIT> ; if ( ! val ) return <STR_LIT> ; rtx c = gen_int_mode ( val , GET_MODE_INNER ( mode ) ) ;

operands [ <NUM_LIT> ] = gen_const_vec_duplicate ( mode , c ) ;


<s> if ( BYTES_BIG_ENDIAN ) base = high_p ? <NUM_LIT> : nunits / <NUM_LIT> ; else base = high_p ? nunits / <NUM_LIT> : <NUM_LIT> ;

for ( i = <NUM_LIT> ; i < nunits / <NUM_LIT> ; i ++ ) RTVEC_ELT ( v , i ) = GEN_INT ( base + i ) ;


<s> if ( TUNE_P5600 || TUNE_P6600 || TUNE_I6400 ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> if ( TUNE_SB1 ) return <NUM_LIT> ; if ( TUNE_LOONGSON_2EF || TUNE_GS464 || TUNE_GS464E ) return <NUM_LIT> ; if ( TUNE_OCTEON || TUNE_GS264E ) return <NUM_LIT> ; if ( TUNE_P5600 || TUNE_P6600 || TUNE_I6400 ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> memset ( & empty , <NUM_LIT> , sizeof ( empty ) ) ;

return mips_multi_members . safe_push ( empty ) ;


<s> mips_multi_member empty ; memset ( & empty , <NUM_LIT> , sizeof ( empty ) ) ; return mips_multi_members . safe_push ( empty ) ;


<s> member = mips_multi_add ( ) ; member -> is_label_p = false ; member -> format = format ; va_start ( ap , format ) ;


<s> static void mips_multi_add_label ( const char * label ) { struct mips_multi_member * member ; member = mips_multi_add ( ) ; member -> is_label_p = true ;


<s> memcpy ( member , & mips_multi_members [ i ] , sizeof ( * member ) ) ; gcc_assert ( ! member -> is_label_p ) ;


<s> static unsigned int mips_multi_last_index ( void ) { return mips_multi_members . length ( ) - <NUM_LIT> ;


<s> static void mips_multi_set_operand ( unsigned int i , unsigned int op , rtx x ) {

mips_multi_members [ i ] . operands [ op ] = x ;


<s> static void mips_multi_start ( void ) {

mips_multi_members . truncate ( <NUM_LIT> ) ;


<s> FOR_EACH_VEC_ELT ( mips_multi_members , i , member ) if ( member -> is_label_p ) fprintf ( asm_out_file , <STR_LIT> , member -> format ) ;

else output_asm_insn ( member -> format , member -> operands ) ;


<s> unsigned int i ; FOR_EACH_VEC_ELT ( mips_multi_members , i , member ) if ( member -> is_label_p ) fprintf ( asm_out_file , <STR_LIT> , member -> format ) ;


<s> static bool mips_mult_move_p ( rtx dest , rtx src , enum mips_split_type split_type ) { return ( ( split_type != SPLIT_FOR_SPEED || mips_tuning_info . fast_mult_zero_zero_p ) && src == const0_rtx && REG_P ( dest ) && GET_MODE_SIZE ( GET_MODE ( dest ) ) == <NUM_LIT> * UNITS_PER_WORD && ( ISA_HAS_DSP_MULT ? ACC_REG_P ( REGNO ( dest ) ) : MD_REG_P ( REGNO ( dest ) ) ) ) ;


<s> emit_insn ( gen_maddsidi4 ( hilo , gpr , gpr , hilo ) ) ; } unsigned int time = mips_seq_time ( state , get_insns ( ) ) ; end_sequence ( ) ; return time ;


<s> machine_mode dword_mode = TARGET_64BIT ? TImode : DImode ; rtx hilo = gen_rtx_REG ( dword_mode , MD_REG_FIRST ) ; mips_emit_move_or_split ( hilo , const0_rtx , SPLIT_FOR_SPEED ) ; if ( dword_mode == DImode && HAVE_maddsidi4 ) {

rtx gpr = gen_rtx_REG ( SImode , GP_REG_FIRST + <NUM_LIT> ) ;


<s> bool mips_must_initialize_gp_p ( void ) {

return cfun -> machine -> must_initialize_gp_p ;


<s> static bool mips_near_type_p ( const_tree type ) {

return ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type ) ) != NULL || lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type ) ) != NULL ) ;


<s> subrtx_iterator :: array_type array ; for ( int i = <NUM_LIT> ; i < noperands ; i ++ ) FOR_EACH_SUBRTX ( iter , array , opvec [ i ] , NONCONST ) if ( REG_P ( * iter ) && REGNO ( * iter ) == AT_REGNUM ) return true ; } return false ;


<s> static bool mips_no_speculation_in_delay_slots_p ( ) {


<s> align = SYMBOL_REF_DECL ( x ) ? DECL_ALIGN_UNIT ( SYMBOL_REF_DECL ( x ) ) : <NUM_LIT> ;

return IN_RANGE ( offset , <NUM_LIT> , align - <NUM_LIT> ) ;


<s> HOST_WIDE_INT align ; align = SYMBOL_REF_DECL ( x ) ? DECL_ALIGN_UNIT ( SYMBOL_REF_DECL ( x ) ) : <NUM_LIT> ;


<s> return ( TARGET_USE_GOT && GET_CODE ( x ) == SYMBOL_REF && ! SYMBOL_REF_BIND_NOW_P ( x ) && ! mips_symbol_binds_local_p ( x ) ) ;


<s> static bool mips_ok_for_lazy_binding_p ( rtx x ) { return ( TARGET_USE_GOT && GET_CODE ( x ) == SYMBOL_REF && ! SYMBOL_REF_BIND_NOW_P ( x ) && ! mips_symbol_binds_local_p ( x ) ) ;


<s> static bool mips_orphaned_high_part_p ( mips_offset_table * htab , rtx_insn * insn ) { enum mips_symbol_type type ; rtx x , set ; set = single_set ( insn ) ; if ( set ) { x = SET_SRC ( set ) ; if ( GET_CODE ( x ) == HIGH && absolute_symbolic_operand ( XEXP ( x , <NUM_LIT> ) , VOIDmode ) ) return ! mips_lo_sum_offset_lookup ( htab , XEXP ( x , <NUM_LIT> ) , NO_INSERT ) ; if ( GET_CODE ( x ) == UNSPEC && XINT ( x , <NUM_LIT> ) == UNSPEC_LOAD_GOT && mips_symbolic_constant_p ( XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) , SYMBOL_CONTEXT_LEA , & type ) && type == SYMBOL_GOTOFF_PAGE ) return ! mips_lo_sum_offset_lookup ( htab , XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) , NO_INSERT ) ; } return false ;


if ( GET_CODE ( x ) == HIGH && absolute_symbolic_operand ( XEXP ( x , <NUM_LIT> ) , VOIDmode ) ) return ! mips_lo_sum_offset_lookup ( htab , XEXP ( x , <NUM_LIT> ) , NO_INSERT ) ;


<s> static void mips_output_32bit_xfer ( char direction , unsigned int gpreg , unsigned int fpreg ) {

fprintf ( asm_out_file , <STR_LIT> , direction , reg_names [ gpreg ] , reg_names [ fpreg ] ) ;


<s> if ( TARGET_64BIT ) fprintf ( asm_out_file , <STR_LIT> , direction , reg_names [ gpreg ] , reg_names [ fpreg ] ) ; else if ( ISA_HAS_MXHC1 ) { fprintf ( asm_out_file , <STR_LIT> , direction , reg_names [ gpreg + TARGET_BIG_ENDIAN ] , reg_names [ fpreg ] ) ; fprintf ( asm_out_file , <STR_LIT> , direction , reg_names [ gpreg + TARGET_LITTLE_ENDIAN ] , reg_names [ fpreg ] ) ; } else if ( TARGET_FLOATXX && direction == 't' ) { fprintf ( asm_out_file , <STR_LIT> , reg_names [ gpreg ] ) ; fprintf ( asm_out_file , <STR_LIT> , reg_names [ gpreg + <NUM_LIT> ] ) ; fprintf ( asm_out_file , <STR_LIT> , reg_names [ fpreg ] ) ; } else if ( TARGET_FLOATXX && direction == 'f' ) { fprintf ( asm_out_file , <STR_LIT> , reg_names [ fpreg ] ) ; fprintf ( asm_out_file , <STR_LIT> , reg_names [ gpreg ] ) ; fprintf ( asm_out_file , <STR_LIT> , reg_names [ gpreg + <NUM_LIT> ] ) ; } else {


<s> fprintf ( asm_out_file , <STR_LIT> , reg_names [ gpreg ] ) ; fprintf ( asm_out_file , <STR_LIT> , reg_names [ gpreg + <NUM_LIT> ] ) ; fprintf ( asm_out_file , <STR_LIT> , reg_names [ fpreg ] ) ; } else if ( TARGET_FLOATXX && direction == 'f' ) { fprintf ( asm_out_file , <STR_LIT> , reg_names [ fpreg ] ) ; fprintf ( asm_out_file , <STR_LIT> , reg_names [ gpreg ] ) ; fprintf ( asm_out_file , <STR_LIT> , reg_names [ gpreg + <NUM_LIT> ] ) ;


<s> if ( TARGET_EMBEDDED_DATA && TARGET_UNINIT_CONST_IN_RODATA && TREE_CODE ( decl ) == VAR_DECL && TREE_READONLY ( decl ) && ( DECL_INITIAL ( decl ) == <NUM_LIT> || DECL_INITIAL ( decl ) == error_mark_node ) ) { if ( TREE_PUBLIC ( decl ) && DECL_NAME ( decl ) ) targetm . asm_out . globalize_label ( stream , name ) ; switch_to_section ( readonly_data_section ) ; ASM_OUTPUT_ALIGN ( stream , floor_log2 ( align / BITS_PER_UNIT ) ) ; mips_declare_object ( stream , name , <STR_LIT> , <STR_LIT> HOST_WIDE_INT_PRINT_UNSIGNED <STR_LIT> , size ) ; }

else mips_declare_common_object ( stream , name , <STR_LIT> , size , align , true ) ;


<s> void mips_output_aligned_decl_common ( FILE * stream , tree decl , const char * name , unsigned HOST_WIDE_INT size , unsigned int align ) { if ( TARGET_EMBEDDED_DATA && TARGET_UNINIT_CONST_IN_RODATA && TREE_CODE ( decl ) == VAR_DECL && TREE_READONLY ( decl ) && ( DECL_INITIAL ( decl ) == <NUM_LIT> || DECL_INITIAL ( decl ) == error_mark_node ) ) { if ( TREE_PUBLIC ( decl ) && DECL_NAME ( decl ) ) targetm . asm_out . globalize_label ( stream , name ) ;


<s> fparg = mips_arg_regno ( & info , true ) ; if ( mode == SFmode ) mips_output_32bit_xfer ( direction , gparg , fparg ) ; else mips_output_64bit_xfer ( direction , gparg , fparg ) ; function_arg_info arg ( mode , true ) ; mips_function_arg_advance ( pack_cumulative_args ( & cum ) , arg ) ;


<s> int cur_pos ; cur_pos = <NUM_LIT> ; fprintf ( stream , <STR_LIT> ) ; for ( i = <NUM_LIT> ; i < len ; i ++ ) { int c ; c = ( unsigned char ) string [ i ] ; if ( ISPRINT ( c ) ) { if ( c == '\\' || c == '\"' ) { putc ( '\\' , stream ) ;


<s> cur_pos ++ ; } else { fprintf ( stream , <STR_LIT> , c ) ; cur_pos += <NUM_LIT> ; } if ( cur_pos > <NUM_LIT> && i + <NUM_LIT> < len ) { cur_pos = <NUM_LIT> ; fprintf ( stream , <STR_LIT> ) ; }


<s> const char * mips_output_conditional_branch ( rtx_insn * insn , rtx * operands , const char * branch_if_true , const char * branch_if_false ) { unsigned int length ; rtx taken ; gcc_assert ( LABEL_P ( operands [ <NUM_LIT> ] ) ) ; length = get_attr_length ( insn ) ; if ( length <= <NUM_LIT> ) { mips_branch_likely = ( final_sequence && INSN_ANNULLED_BRANCH_P ( insn ) ) ; 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> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; } if ( TARGET_ABSOLUTE_JUMPS && TARGET_CB_MAYBE ) { if ( ! final_sequence ) { output_asm_insn ( <STR_LIT> , <NUM_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; } output_asm_insn ( MIPS_ABSOLUTE_JUMP ( <STR_LIT> ) , & taken ) ; } else if ( TARGET_ABSOLUTE_JUMPS ) output_asm_insn ( MIPS_ABSOLUTE_JUMP ( <STR_LIT> ) , & taken ) ; else { mips_output_load_label ( taken ) ; if ( TARGET_CB_MAYBE ) output_asm_insn ( <STR_LIT> , <NUM_LIT> ) ; else output_asm_insn ( <STR_LIT> , <NUM_LIT> ) ; } 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 if ( TARGET_CB_NEVER ) output_asm_insn ( <STR_LIT> , <NUM_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; } targetm . asm_out . internal_label ( asm_out_file , <STR_LIT> , CODE_LABEL_NUMBER ( not_taken ) ) ; return <STR_LIT> ;


<s> static void mips_output_cplocal ( void ) { if ( ! TARGET_EXPLICIT_RELOCS && mips_must_initialize_gp_p ( ) && cfun -> machine -> global_pointer != GLOBAL_POINTER_REGNUM ) output_asm_insn ( <STR_LIT> , <NUM_LIT> ) ;


<s> if ( ! TARGET_EXPLICIT_RELOCS && mips_must_initialize_gp_p ( ) && cfun -> machine -> global_pointer != GLOBAL_POINTER_REGNUM ) output_asm_insn ( <STR_LIT> , <NUM_LIT> ) ;


<s> const char * mips_output_division ( const char * division , rtx * operands ) { const char * 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 { if ( flag_delayed_branch ) { output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( s , operands ) ; s = <STR_LIT> ; }


<s> branch [ ! inverted_p ] = MIPS_BRANCH_C ( <STR_LIT> , <STR_LIT> ) ; branch [ inverted_p ] = MIPS_BRANCH_C ( <STR_LIT> , <STR_LIT> ) ; } else if ( REGNO ( operands [ <NUM_LIT> ] ) != REGNO ( operands [ <NUM_LIT> ] ) ) { branch [ ! inverted_p ] = MIPS_BRANCH_C ( <STR_LIT> , <STR_LIT> ) ; branch [ inverted_p ] = MIPS_BRANCH_C ( <STR_LIT> , <STR_LIT> ) ; } else {

if ( GET_CODE ( operands [ <NUM_LIT> ] ) == NE ) inverted_p = ! inverted_p ;


<s> branch [ inverted_p ] = <STR_LIT> ; } else { branch [ ! inverted_p ] = <STR_LIT> ; branch [ inverted_p ] = <STR_LIT> ; } } else if ( TARGET_CB_MAYBE ) { if ( operands [ <NUM_LIT> ] == const0_rtx ) { branch [ ! inverted_p ] = MIPS_BRANCH_C ( <STR_LIT> , <STR_LIT> ) ; branch [ inverted_p ] = MIPS_BRANCH_C ( <STR_LIT> , <STR_LIT> ) ; } else if ( REGNO ( operands [ <NUM_LIT> ] ) != REGNO ( operands [ <NUM_LIT> ] ) ) { branch [ ! inverted_p ] = MIPS_BRANCH_C ( <STR_LIT> , <STR_LIT> ) ; branch [ inverted_p ] = MIPS_BRANCH_C ( <STR_LIT> , <STR_LIT> ) ; } else { if ( GET_CODE ( operands [ <NUM_LIT> ] ) == NE ) inverted_p = ! inverted_p ; branch [ ! inverted_p ] = MIPS_BRANCH_C ( <STR_LIT> , <STR_LIT> ) ; branch [ inverted_p ] = <STR_LIT> ; }