<s> else if ( strstr ( buf , <STR_LIT> ) != NULL || strstr ( buf , <STR_LIT> ) != NULL || strstr ( buf , <STR_LIT> ) != NULL ) cpu = <STR_LIT> ; else if ( strstr ( buf , <STR_LIT> ) != NULL || strstr ( buf , <STR_LIT> ) != NULL || strstr ( buf , <STR_LIT> ) != NULL ) cpu = <STR_LIT> ; else if ( strstr ( buf , <STR_LIT> ) != NULL ) cpu = <STR_LIT> ; else if ( strstr ( buf , <STR_LIT> ) != NULL ) cpu = <STR_LIT> ; else if ( strstr ( buf , <STR_LIT> ) != NULL ) cpu = <STR_LIT> ; else if ( strstr ( buf , <STR_LIT> ) != NULL ) cpu = <STR_LIT> ; break ; } fclose ( f ) ; fallback_cpu : ret = reconcat ( ret , <STR_LIT> , NULL ) ;

if ( cpu == NULL ) cpu = ( const char * ) getauxval ( AT_BASE_PLATFORM ) ;


<s> if ( f == NULL ) goto fallback_cpu ; while ( fgets ( buf , sizeof ( buf ) , f ) != NULL ) if ( startswith ( buf , <STR_LIT> ) ) { if ( strstr ( buf , <STR_LIT> ) != NULL || strstr ( buf , <STR_LIT> ) != NULL || strstr ( buf , <STR_LIT> ) != NULL ) cpu = <STR_LIT> ; else if ( strstr ( buf , <STR_LIT> ) != NULL || strstr ( buf , <STR_LIT> ) != NULL || strstr ( buf , <STR_LIT> ) != NULL ) cpu = <STR_LIT> ; else if ( strstr ( buf , <STR_LIT> ) != NULL || strstr ( buf , <STR_LIT> ) != NULL || strstr ( buf , <STR_LIT> ) != NULL ) cpu = <STR_LIT> ; else if ( strstr ( buf , <STR_LIT> ) != NULL ) cpu = <STR_LIT> ; else if ( strstr ( buf , <STR_LIT> ) != NULL ) cpu = <STR_LIT> ;


<s> static struct register_pass_info f = { p , <STR_LIT> , <NUM_LIT> , PASS_POS_INSERT_AFTER } ;


<s> opt_pass * p = make_pass_ipa_frame_header_opt ( g ) ; static struct register_pass_info f = { p , <STR_LIT> , <NUM_LIT> , PASS_POS_INSERT_AFTER } ; register_pass ( & f ) ;


<s> FOR_EACH_BB_FN ( bb , fn ) { for ( gsi = gsi_start_bb ( bb ) ; ! gsi_end_p ( gsi ) ; gsi_next ( & gsi ) ) { stmt = gsi_stmt ( gsi ) ; if ( is_gimple_call ( stmt ) ) { called_fn_tree = gimple_call_fndecl ( stmt ) ;


<s> stmt = gsi_stmt ( gsi ) ; if ( is_gimple_call ( stmt ) ) { called_fn_tree = gimple_call_fndecl ( stmt ) ; if ( called_fn_tree != NULL ) { called_fn = DECL_STRUCT_FUNCTION ( called_fn_tree ) ; if ( called_fn != NULL ) called_fn -> machine -> callers_may_not_allocate_frame = true ; }


<s> if ( is_gimple_call ( stmt ) ) { called_fn_tree = gimple_call_fndecl ( stmt ) ; if ( called_fn_tree != NULL ) { called_fn = DECL_STRUCT_FUNCTION ( called_fn_tree ) ; if ( called_fn != NULL ) called_fn -> machine -> callers_may_not_allocate_frame = true ; } } }


<s> struct cgraph_node * node ; function * fn ; FOR_EACH_DEFINED_FUNCTION ( node ) { fn = node -> get_fun ( ) ; if ( fn != NULL ) fn -> machine -> does_not_use_frame_header = ! needs_frame_header_p ( fn ) ; } FOR_EACH_DEFINED_FUNCTION ( node ) { fn = node -> get_fun ( ) ; if ( fn != NULL ) fn -> machine -> optimize_call_stack = ! callees_functions_use_frame_header ( fn ) && ! is_leaf_function ( fn ) ; } FOR_EACH_DEFINED_FUNCTION ( node ) {


<s> return TARGET_OLDABI && flag_frame_header_optimization && optimize > <NUM_LIT> ;


<s> if ( fn -> cfg == NULL ) return true ; FOR_EACH_BB_FN ( bb , fn ) for ( gsi = gsi_start_bb ( bb ) ; ! gsi_end_p ( gsi ) ; gsi_next ( & gsi ) ) if ( gimple_code ( gsi_stmt ( gsi ) ) == GIMPLE_ASM ) return true ; return false ;


<s> static bool is_leaf_function ( function * fn ) { basic_block bb ; gimple_stmt_iterator gsi ;


<s> basic_block bb ; gimple_stmt_iterator gsi ; if ( fn -> cfg == NULL ) return false ; FOR_EACH_BB_FN ( bb , fn ) for ( gsi = gsi_start_bb ( bb ) ; ! gsi_end_p ( gsi ) ; gsi_next ( & gsi ) ) if ( is_gimple_call ( gsi_stmt ( gsi ) ) ) return false ;


<s> opt_pass * p = make_pass_ipa_frame_header_opt ( g ) ; struct register_pass_info f = { p , <STR_LIT> , <NUM_LIT> , PASS_POS_INSERT_AFTER } ; register_pass ( & f ) ;


<s> struct register_pass_info f = { p , <STR_LIT> , <NUM_LIT> , PASS_POS_INSERT_AFTER } ;


<s> if ( fn -> decl == NULL ) return true ; if ( fn -> stdarg ) return true ; for ( t = DECL_ARGUMENTS ( fn -> decl ) ; t ; t = TREE_CHAIN ( t ) ) { if ( ! use_register_for_decl ( t ) ) return true ; if ( DECL_MODE ( t ) != SImode ) return true ; }


<s> pass_ipa_frame_header_opt ( gcc :: context * ctxt ) : ipa_opt_pass_d ( pass_data_ipa_frame_header_opt , ctxt , NULL , NULL , NULL , NULL , NULL , NULL , <NUM_LIT> , NULL , NULL ) {


<s> for ( gsi = gsi_start_bb ( bb ) ; ! gsi_end_p ( gsi ) ; gsi_next ( & gsi ) ) { stmt = gsi_stmt ( gsi ) ; if ( is_gimple_call ( stmt ) ) { called_fn_tree = gimple_call_fndecl ( stmt ) ; if ( called_fn_tree != NULL ) { called_fn = DECL_STRUCT_FUNCTION ( called_fn_tree ) ; if ( called_fn != NULL ) called_fn -> machine -> callers_may_not_allocate_frame = true ;


<s> return _inet_lnaof ( in << SHIFT_BITS ) ;


<s> return _inet_makeaddr ( net , lna ) >> SHIFT_BITS ;


<s> machreg_t inet_netof ( machreg_t in ) { return _inet_netof ( in << SHIFT_BITS ) ;


<s> return _inet_netof ( in << SHIFT_BITS ) ;


<s> return _semctl ( semid , semnum , cmd , arg << SHIFT_BITS ) ;


<s> else return _URC_END_OF_STACK ; new_cfa = ( _Unwind_Ptr ) sc ; fs -> cfa_how = CFA_REG_OFFSET ; fs -> cfa_reg = STACK_POINTER_REGNUM ; fs -> cfa_offset = new_cfa - ( _Unwind_Ptr ) context -> cfa ; new_cfa -= <NUM_LIT> ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { fs -> regs . reg [ i ] . how = REG_SAVED_OFFSET ; fs -> regs . reg [ i ] . loc . offset = ( _Unwind_Ptr ) & ( sc -> sc_regs [ i ] ) - new_cfa ; } fs -> regs . reg [ SIGNAL_UNWIND_RETURN_COLUMN ] . how = REG_SAVED_OFFSET ;

fs -> regs . reg [ SIGNAL_UNWIND_RETURN_COLUMN ] . loc . offset = ( _Unwind_Ptr ) & ( sc -> sc_pc ) - new_cfa ;


<s> biadd ( uint8x8_t s ) { return __builtin_loongson_biadd ( s ) ;


<s> return __builtin_loongson_packsshb ( s , t ) ;


<s> packsswh ( int32x2_t s , int32x2_t t ) { return __builtin_loongson_packsswh ( s , t ) ;


<s> return __builtin_loongson_packushb ( s , t ) ;


<s> paddb_s ( int8x8_t s , int8x8_t t ) {

return __builtin_loongson_paddb_s ( s , t ) ;


<s> paddb_u ( uint8x8_t s , uint8x8_t t ) { return __builtin_loongson_paddb_u ( s , t ) ;


<s> paddd_s ( int64_t s , int64_t t ) { return __builtin_loongson_paddd_s ( s , t ) ;


return __builtin_loongson_paddd_s ( s , t ) ;


<s> return __builtin_loongson_paddd_u ( s , t ) ;


<s> paddh_s ( int16x4_t s , int16x4_t t ) {

return __builtin_loongson_paddh_s ( s , t ) ;


<s> paddh_u ( uint16x4_t s , uint16x4_t t ) {

return __builtin_loongson_paddh_u ( s , t ) ;


<s> paddsh ( int16x4_t s , int16x4_t t ) { return __builtin_loongson_paddsh ( s , t ) ;


<s> return __builtin_loongson_paddush ( s , t ) ;


<s> return __builtin_loongson_paddw_s ( s , t ) ;


<s> paddw_s ( int32x2_t s , int32x2_t t ) {

return __builtin_loongson_paddw_s ( s , t ) ;


<s> paddw_u ( uint32x2_t s , uint32x2_t t ) { return __builtin_loongson_paddw_u ( s , t ) ;


<s> pandn_sb ( int8x8_t s , int8x8_t t ) { return __builtin_loongson_pandn_sb ( s , t ) ;


<s> return __builtin_loongson_pandn_sd ( s , t ) ;


<s> return __builtin_loongson_pandn_sh ( s , t ) ;


<s> pandn_sh ( int16x4_t s , int16x4_t t ) {

return __builtin_loongson_pandn_sh ( s , t ) ;


<s> pandn_sw ( int32x2_t s , int32x2_t t ) {

return __builtin_loongson_pandn_sw ( s , t ) ;


<s> return __builtin_loongson_pandn_ub ( s , t ) ;


<s> pandn_uw ( uint32x2_t s , uint32x2_t t ) {

return __builtin_loongson_pandn_uw ( s , t ) ;


<s> pasubub ( uint8x8_t s , uint8x8_t t ) {

return __builtin_loongson_pasubub ( s , t ) ;


<s> pavgb ( uint8x8_t s , uint8x8_t t ) {

return __builtin_loongson_pavgb ( s , t ) ;


<s> pavgh ( uint16x4_t s , uint16x4_t t ) { return __builtin_loongson_pavgh ( s , t ) ;


<s> pcmpeqh_s ( int16x4_t s , int16x4_t t ) {

return __builtin_loongson_pcmpeqh_s ( s , t ) ;


<s> return __builtin_loongson_pcmpeqh_s ( s , t ) ;


<s> pcmpeqh_u ( uint16x4_t s , uint16x4_t t ) { return __builtin_loongson_pcmpeqh_u ( s , t ) ;


<s> pcmpeqw_s ( int32x2_t s , int32x2_t t ) {

return __builtin_loongson_pcmpeqw_s ( s , t ) ;


<s> pcmpeqw_u ( uint32x2_t s , uint32x2_t t ) { return __builtin_loongson_pcmpeqw_u ( s , t ) ;


<s> pcmpgtb_s ( int8x8_t s , int8x8_t t ) { return __builtin_loongson_pcmpgtb_s ( s , t ) ;


<s> pcmpgtb_u ( uint8x8_t s , uint8x8_t t ) {

return __builtin_loongson_pcmpgtb_u ( s , t ) ;


<s> return __builtin_loongson_pcmpgtb_u ( s , t ) ;


<s> pcmpgth_s ( int16x4_t s , int16x4_t t ) {

return __builtin_loongson_pcmpgth_s ( s , t ) ;


<s> return __builtin_loongson_pcmpgth_s ( s , t ) ;


<s> pcmpgth_u ( uint16x4_t s , uint16x4_t t ) {

return __builtin_loongson_pcmpgth_u ( s , t ) ;


<s> pextrh_s ( int16x4_t s , int field ) {

return __builtin_loongson_pextrh_s ( s , field ) ;


<s> pextrh_u ( uint16x4_t s , int field ) {

return __builtin_loongson_pextrh_u ( s , field ) ;


<s> pinsrh_0_s ( int16x4_t s , int16x4_t t ) {

return __builtin_loongson_pinsrh_0_s ( s , t ) ;


<s> return __builtin_loongson_pinsrh_0_u ( s , t ) ;


<s> return __builtin_loongson_pinsrh_1_s ( s , t ) ;


<s> return __builtin_loongson_pinsrh_1_u ( s , t ) ;


<s> pinsrh_1_u ( uint16x4_t s , uint16x4_t t ) {

return __builtin_loongson_pinsrh_1_u ( s , t ) ;


<s> return __builtin_loongson_pinsrh_2_u ( s , t ) ;


<s> pinsrh_3_s ( int16x4_t s , int16x4_t t ) {

return __builtin_loongson_pinsrh_3_s ( s , t ) ;


<s> return __builtin_loongson_pinsrh_3_s ( s , t ) ;


<s> pinsrh_3_u ( uint16x4_t s , uint16x4_t t ) { return __builtin_loongson_pinsrh_3_u ( s , t ) ;


<s> pinsrh_3_u ( uint16x4_t s , uint16x4_t t ) {

return __builtin_loongson_pinsrh_3_u ( s , t ) ;


<s> return __builtin_loongson_pmaddhw ( s , t ) ;


<s> pmaxsh ( int16x4_t s , int16x4_t t ) { return __builtin_loongson_pmaxsh ( s , t ) ;


<s> return __builtin_loongson_pmaxsh ( s , t ) ;


<s> return __builtin_loongson_pmaxub ( s , t ) ;


<s> pminsh ( int16x4_t s , int16x4_t t ) { return __builtin_loongson_pminsh ( s , t ) ;


<s> pminub ( uint8x8_t s , uint8x8_t t ) {

return __builtin_loongson_pminub ( s , t ) ;


<s> return __builtin_loongson_pminub ( s , t ) ;


<s> pmulhh ( int16x4_t s , int16x4_t t ) { return __builtin_loongson_pmulhh ( s , t ) ;


<s> pmullh ( int16x4_t s , int16x4_t t ) { return __builtin_loongson_pmullh ( s , t ) ;


<s> pmuluw ( uint32x2_t s , uint32x2_t t ) {

return __builtin_loongson_pmuluw ( s , t ) ;


<s> psadbh ( uint8x8_t s , uint8x8_t t ) {

return __builtin_loongson_psadbh ( s , t ) ;


<s> return __builtin_loongson_pshufh_s ( s , order ) ;


<s> return __builtin_loongson_pshufh_u ( s , order ) ;


<s> pshufh_u ( uint16x4_t dest , uint16x4_t s , uint8_t order ) {

return __builtin_loongson_pshufh_u ( s , order ) ;


<s> return __builtin_loongson_psllh_s ( s , amount ) ;


<s> psllh_u ( uint16x4_t s , uint8_t amount ) {

return __builtin_loongson_psllh_u ( s , amount ) ;


<s> psllw_s ( int32x2_t s , uint8_t amount ) { return __builtin_loongson_psllw_s ( s , amount ) ;


<s> return __builtin_loongson_psrah_s ( s , amount ) ;


<s> psrah_u ( uint16x4_t s , uint8_t amount ) {

return __builtin_loongson_psrah_u ( s , amount ) ;


<s> return __builtin_loongson_psraw_s ( s , amount ) ;


<s> psraw_u ( uint32x2_t s , uint8_t amount ) { return __builtin_loongson_psraw_u ( s , amount ) ;


<s> psrlh_s ( int16x4_t s , uint8_t amount ) {

return __builtin_loongson_psrlh_s ( s , amount ) ;


<s> psrlh_s ( int16x4_t s , uint8_t amount ) { return __builtin_loongson_psrlh_s ( s , amount ) ;


<s> psrlh_u ( uint16x4_t s , uint8_t amount ) {

return __builtin_loongson_psrlh_u ( s , amount ) ;


<s> psrlw_s ( int32x2_t s , uint8_t amount ) {

return __builtin_loongson_psrlw_s ( s , amount ) ;


<s> psrlw_s ( int32x2_t s , uint8_t amount ) { return __builtin_loongson_psrlw_s ( s , amount ) ;


<s> psrlw_u ( uint32x2_t s , uint8_t amount ) {

return __builtin_loongson_psrlw_u ( s , amount ) ;


<s> return __builtin_loongson_psubb_s ( s , t ) ;


<s> return __builtin_loongson_psubb_u ( s , t ) ;


<s> return __builtin_loongson_psubd_s ( s , t ) ;


return __builtin_loongson_psubd_s ( s , t ) ;


<s> return __builtin_loongson_psubd_u ( s , t ) ;


<s> return __builtin_loongson_psubh_s ( s , t ) ;


<s> return __builtin_loongson_psubsb ( s , t ) ;


<s> return __builtin_loongson_psubsh ( s , t ) ;


<s> psubusb ( uint8x8_t s , uint8x8_t t ) { return __builtin_loongson_psubusb ( s , t ) ;


<s> psubush ( uint16x4_t s , uint16x4_t t ) { return __builtin_loongson_psubush ( s , t ) ;


<s> psubw_u ( uint32x2_t s , uint32x2_t t ) { return __builtin_loongson_psubw_u ( s , t ) ;


<s> punpckhbh_s ( int8x8_t s , int8x8_t t ) { return __builtin_loongson_punpckhbh_s ( s , t ) ;


<s> return __builtin_loongson_punpckhhw_s ( s , t ) ;


<s> punpckhwd_s ( int32x2_t s , int32x2_t t ) { return __builtin_loongson_punpckhwd_s ( s , t ) ;


<s> return __builtin_loongson_punpckhwd_s ( s , t ) ;


<s> punpckhwd_u ( uint32x2_t s , uint32x2_t t ) {

return __builtin_loongson_punpckhwd_u ( s , t ) ;


<s> return __builtin_loongson_punpcklbh_s ( s , t ) ;


<s> punpcklbh_u ( uint8x8_t s , uint8x8_t t ) { return __builtin_loongson_punpcklbh_u ( s , t ) ;


<s> punpcklbh_u ( uint8x8_t s , uint8x8_t t ) {

return __builtin_loongson_punpcklbh_u ( s , t ) ;


<s> punpcklhw_s ( int16x4_t s , int16x4_t t ) { return __builtin_loongson_punpcklhw_s ( s , t ) ;


<s> return __builtin_loongson_punpcklwd_s ( s , t ) ;


<s> punpcklwd_s ( int32x2_t s , int32x2_t t ) { return __builtin_loongson_punpcklwd_s ( s , t ) ;


<s> punpcklwd_u ( uint32x2_t s , uint32x2_t t ) {

return __builtin_loongson_punpcklwd_u ( s , t ) ;


<s> else if ( TARGET_SOFT_FLOAT_ABI ) abi = <STR_LIT> ; else abi = <STR_LIT> ;

return build_string_literal ( strlen ( abi ) + <NUM_LIT> , abi ) ;


<s> void mips_d_register_target_info ( void ) { const struct d_target_info_spec handlers [ ] = {

{ <STR_LIT> , mips_d_handle_target_float_abi } , { NULL , NULL } , } ;


<s> void mips_d_register_target_info ( void ) { const struct d_target_info_spec handlers [ ] = { { <STR_LIT> , mips_d_handle_target_float_abi } , { NULL , NULL } , } ; d_add_target_info_handlers ( handlers ) ;


<s> else d_add_builtin_version ( <STR_LIT> ) ; if ( mips_abi == ABI_32 ) d_add_builtin_version ( <STR_LIT> ) ; else if ( mips_abi == ABI_EABI ) d_add_builtin_version ( <STR_LIT> ) ;

else if ( mips_abi == ABI_N32 ) d_add_builtin_version ( <STR_LIT> ) ;


<s> else if ( mips_abi == ABI_64 ) d_add_builtin_version ( <STR_LIT> ) ; else if ( mips_abi == ABI_O64 ) d_add_builtin_version ( <STR_LIT> ) ; if ( TARGET_HARD_FLOAT_ABI ) { d_add_builtin_version ( <STR_LIT> ) ; d_add_builtin_version ( <STR_LIT> ) ; } else if ( TARGET_SOFT_FLOAT_ABI ) { d_add_builtin_version ( <STR_LIT> ) ;


<s> if ( POINTER_SIZE == <NUM_LIT> ) return ( HOST_WIDE_INT_1 << <NUM_LIT> ) ; else return HOST_WIDE_INT_C ( <NUM_LIT> ) ;


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


<s> output_quoted_string ( stream , name ) ; putc ( '\n' , stream ) ; } else if ( name != current_function_file && strcmp ( name , current_function_file ) != <NUM_LIT> ) { num_source_filenames += <NUM_LIT> ; current_function_file = name ;

fprintf ( stream , <STR_LIT> , num_source_filenames ) ;


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


<s> case <NUM_LIT> : for ( i = <NUM_LIT> ; i < nelt ; ++ i ) d . perm [ i ] &= nelt - <NUM_LIT> ; d . op0 = d . op1 ; d . one_vector_p = true ; break ; case <NUM_LIT> : d . op1 = d . op0 ; d . one_vector_p = true ; break ; } if ( d . testing_p ) { d . target = gen_raw_REG ( d . vmode , LAST_VIRTUAL_REGISTER + <NUM_LIT> ) ; d . op1 = d . op0 = gen_raw_REG ( d . vmode , LAST_VIRTUAL_REGISTER + <NUM_LIT> ) ; if ( ! d . one_vector_p ) d . op1 = gen_raw_REG ( d . vmode , LAST_VIRTUAL_REGISTER + <NUM_LIT> ) ; start_sequence ( ) ; ok = mips_expand_vec_perm_const_1 ( & d ) ; end_sequence ( ) ; return ok ;


<s> for ( scan = get_insns ( ) ; scan != NULL_RTX ; scan = NEXT_INSN ( scan ) ) if ( GET_CODE ( scan ) == NOTE && NOTE_LINE_NUMBER ( scan ) == NOTE_INSN_FUNCTION_BEG ) break ; if ( scan == NULL_RTX ) scan = get_insns ( ) ; insn = emit_insn_after ( insn , scan ) ;


ggc_add_rtx_root ( branch_cmp , sizeof ( branch_cmp ) / sizeof ( rtx ) ) ;


<s> ggc_add_rtx_root ( & mips_load_reg , <NUM_LIT> ) ; ggc_add_rtx_root ( & mips_load_reg2 , <NUM_LIT> ) ; ggc_add_rtx_root ( & mips_load_reg3 , <NUM_LIT> ) ; ggc_add_rtx_root ( & mips_load_reg4 , <NUM_LIT> ) ; ggc_add_rtx_root ( branch_cmp , sizeof ( branch_cmp ) / sizeof ( rtx ) ) ;


DECL_FIELD_CONTEXT ( f_foff ) = record ;


<s> if ( TARGET_MIPS16 && mips16_hard_float && ! aggregate_value_p ( DECL_RESULT ( current_function_decl ) ) && ( GET_MODE_CLASS ( DECL_MODE ( DECL_RESULT ( current_function_decl ) ) ) == MODE_FLOAT ) && ( ! TARGET_SINGLE_FLOAT || ( GET_MODE_SIZE ( DECL_MODE ( DECL_RESULT ( current_function_decl ) ) ) <= <NUM_LIT> ) ) ) return <NUM_LIT> ;

if ( current_frame_info . initialized ) return current_frame_info . total_size == <NUM_LIT> ;


<s> emit_insn ( gen_blockage ( ) ) ; if ( TARGET_MIPS16 ) { tsize -= current_function_outgoing_args_size ; if ( orig_tsize > <NUM_LIT> ) { rtx g6_rtx = gen_rtx ( REG , Pmode , GP_REG_FIRST + <NUM_LIT> ) ; emit_move_insn ( g6_rtx , GEN_INT ( tsize ) ) ; if ( Pmode == DImode ) emit_insn ( gen_adddi3 ( hard_frame_pointer_rtx , hard_frame_pointer_rtx , g6_rtx ) ) ; else emit_insn ( gen_addsi3 ( hard_frame_pointer_rtx , hard_frame_pointer_rtx , g6_rtx ) ) ; tsize = <NUM_LIT> ; } if ( tsize && tsize != orig_tsize ) tsize_rtx = GEN_INT ( tsize ) ; } if ( Pmode == DImode ) emit_insn ( gen_movdi ( stack_pointer_rtx , hard_frame_pointer_rtx ) ) ; else emit_insn ( gen_movsi ( stack_pointer_rtx , hard_frame_pointer_rtx ) ) ; } else if ( TARGET_ABICALLS && mips_abi != ABI_32 && mips_abi != ABI_O64 && ( current_frame_info . mask & ( <NUM_LIT> << ( PIC_OFFSET_TABLE_REGNUM - GP_REG_FIRST ) ) ) ) emit_insn ( gen_blockage ( ) ) ; save_restore_insns ( <NUM_LIT> , tmp_rtx , orig_tsize , ( FILE * ) <NUM_LIT> ) ; if ( tsize > <NUM_LIT> && TARGET_MIPS16 ) abort ( ) ; if ( current_function_calls_eh_return ) { rtx eh_ofs = EH_RETURN_STACKADJ_RTX ; if ( Pmode == DImode ) emit_insn ( gen_adddi3 ( eh_ofs , eh_ofs , tsize_rtx ) ) ; else emit_insn ( gen_addsi3 ( eh_ofs , eh_ofs , tsize_rtx ) ) ; tsize_rtx = eh_ofs ; } emit_insn ( gen_blockage ( ) ) ; if ( tsize != <NUM_LIT> || current_function_calls_eh_return ) { if ( ! TARGET_MIPS16 ) { if ( Pmode == DImode ) emit_insn ( gen_adddi3 ( stack_pointer_rtx , stack_pointer_rtx , tsize_rtx ) ) ; else emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , tsize_rtx ) ) ; } else { rtx g6_rtx = gen_rtx ( REG , Pmode , GP_REG_FIRST + <NUM_LIT> ) ; if ( Pmode == DImode ) { emit_insn ( gen_movdi ( g6_rtx , stack_pointer_rtx ) ) ; emit_insn ( gen_adddi3 ( g6_rtx , g6_rtx , tsize_rtx ) ) ; emit_insn ( gen_movdi ( stack_pointer_rtx , g6_rtx ) ) ; }


<s> rtx eh_ofs = EH_RETURN_STACKADJ_RTX ; if ( Pmode == DImode ) emit_insn ( gen_adddi3 ( eh_ofs , eh_ofs , tsize_rtx ) ) ; else emit_insn ( gen_addsi3 ( eh_ofs , eh_ofs , tsize_rtx ) ) ; tsize_rtx = eh_ofs ; } emit_insn ( gen_blockage ( ) ) ; if ( tsize != <NUM_LIT> || current_function_calls_eh_return ) { if ( ! TARGET_MIPS16 ) { if ( Pmode == DImode ) emit_insn ( gen_adddi3 ( stack_pointer_rtx , stack_pointer_rtx , tsize_rtx ) ) ; else emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , tsize_rtx ) ) ; } else { rtx g6_rtx = gen_rtx ( REG , Pmode , GP_REG_FIRST + <NUM_LIT> ) ; if ( Pmode == DImode ) { emit_insn ( gen_movdi ( g6_rtx , stack_pointer_rtx ) ) ; emit_insn ( gen_adddi3 ( g6_rtx , g6_rtx , tsize_rtx ) ) ; emit_insn ( gen_movdi ( stack_pointer_rtx , g6_rtx ) ) ; } else { emit_insn ( gen_movsi ( g6_rtx , stack_pointer_rtx ) ) ; emit_insn ( gen_addsi3 ( g6_rtx , g6_rtx , tsize_rtx ) ) ;


<s> } } else { regno = GP_ARG_LAST + <NUM_LIT> ; break ; } } next_arg_reg = FUNCTION_ARG ( args_so_far , VOIDmode , void_type_node , <NUM_LIT> ) ; if ( next_arg_reg != <NUM_LIT> && GET_CODE ( next_arg_reg ) == PARALLEL ) { rtvec adjust = XVEC ( next_arg_reg , <NUM_LIT> ) ; int num = GET_NUM_ELEM ( adjust ) ; for ( i = <NUM_LIT> ; i < num ; i ++ ) { rtx insn , pattern ; pattern = RTVEC_ELT ( adjust , i ) ; if ( GET_CODE ( pattern ) != SET || GET_CODE ( SET_SRC ( pattern ) ) != ASHIFT ) abort_with_insn ( pattern , <STR_LIT> ) ; PUT_CODE ( SET_SRC ( pattern ) , ASHIFTRT ) ; insn = emit_insn ( pattern ) ; REG_NOTES ( insn ) = gen_rtx_EXPR_LIST ( REG_MAYBE_DEAD , NULL_RTX , REG_NOTES ( insn ) ) ; } } tsize = compute_frame_size ( get_frame_size ( ) ) ; if ( store_args_on_stack && ( ( TYPE_ARG_TYPES ( fntype ) != <NUM_LIT> && ( TREE_VALUE ( tree_last ( TYPE_ARG_TYPES ( fntype ) ) ) != void_type_node ) ) || last_arg_is_vararg_marker ) ) { int offset = ( regno - GP_ARG_FIRST ) * UNITS_PER_WORD ; rtx ptr = stack_pointer_rtx ; if ( TARGET_ABICALLS ) offset += tsize ; for ( ; regno <= GP_ARG_LAST ; regno ++ ) { if ( offset != <NUM_LIT> ) ptr = gen_rtx ( PLUS , Pmode , stack_pointer_rtx , GEN_INT ( offset ) ) ; emit_move_insn ( gen_rtx ( MEM , gpr_mode , ptr ) , gen_rtx ( REG , gpr_mode , regno ) ) ; offset += GET_MODE_SIZE ( gpr_mode ) ; } } if ( mips_entry && ! mips_can_use_return_insn ( ) ) { if ( tsize > <NUM_LIT> && tsize <= <NUM_LIT> && frame_pointer_needed ) { rtx insn ; if ( TARGET_MIPS16 && current_function_outgoing_args_size != <NUM_LIT> ) { rtx incr = GEN_INT ( current_function_outgoing_args_size ) ; if ( Pmode == DImode ) insn = emit_insn ( gen_adddi3 ( hard_frame_pointer_rtx , stack_pointer_rtx , incr ) ) ; else insn = emit_insn ( gen_addsi3 ( hard_frame_pointer_rtx , stack_pointer_rtx , incr ) ) ; } else if ( Pmode == DImode ) insn = emit_insn ( gen_movdi ( hard_frame_pointer_rtx , stack_pointer_rtx ) ) ; else insn = emit_insn ( gen_movsi ( hard_frame_pointer_rtx , stack_pointer_rtx ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } if ( TARGET_MIPS16 && BITSET_P ( current_frame_info . mask , <NUM_LIT> ) ) { rtx reg_rtx = gen_rtx ( REG , gpr_mode , GP_REG_FIRST + <NUM_LIT> ) ; long gp_offset , base_offset ; gp_offset = current_frame_info . gp_sp_offset ; if ( BITSET_P ( current_frame_info . mask , <NUM_LIT> ) ) gp_offset -= UNITS_PER_WORD ; if ( BITSET_P ( current_frame_info . mask , <NUM_LIT> ) ) gp_offset -= UNITS_PER_WORD ; if ( BITSET_P ( current_frame_info . mask , <NUM_LIT> ) ) gp_offset -= UNITS_PER_WORD ; if ( tsize > <NUM_LIT> ) base_offset = tsize ; else base_offset = <NUM_LIT> ;


<s> register int i ; for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) reg_alloc_order [ i ] = i ; if ( TARGET_MIPS16 ) {


<s> for ( p = & pool -> first ; * p != <NUM_LIT> ; p = & ( * p ) -> next ) { if ( mode == ( * p ) -> mode && rtx_equal_p ( value , ( * p ) -> value ) ) return ( * p ) -> label ; if ( GET_MODE_SIZE ( mode ) < GET_MODE_SIZE ( ( * p ) -> mode ) ) break ; if ( GET_MODE_SIZE ( mode ) == GET_MODE_SIZE ( ( * p ) -> mode ) ) first_of_size_p = false ; } if ( pool -> first == <NUM_LIT> ) pool -> highest_address = pool -> insn_address - ( UNITS_PER_WORD - <NUM_LIT> ) + <NUM_LIT> ; pool -> highest_address -= GET_MODE_SIZE ( mode ) ; if ( first_of_size_p ) pool -> highest_address -= GET_MODE_SIZE ( mode ) - <NUM_LIT> ; c = ( struct mips16_constant * ) xmalloc ( sizeof * c ) ; c -> value = value ; c -> mode = mode ; c -> label = gen_label_rtx ( ) ; c -> next = * p ; * p = c ; return c -> label ;


<s> stubid = get_identifier ( stubname ) ; stubdecl = build_decl ( FUNCTION_DECL , stubid , build_function_type ( void_type_node , NULL_TREE ) ) ; DECL_SECTION_NAME ( stubdecl ) = build_string ( strlen ( secname ) , secname ) ; fprintf ( asm_out_file , <STR_LIT> , ( fpret ? ( GET_MODE ( retval ) == SFmode ? <STR_LIT> : <STR_LIT> ) : <STR_LIT> ) , fnname ) ; need_comma = <NUM_LIT> ; for ( f = ( unsigned int ) fp_code ; f != <NUM_LIT> ; f >>= <NUM_LIT> ) { fprintf ( asm_out_file , <STR_LIT> , need_comma ? <STR_LIT> : <STR_LIT> , ( f & <NUM_LIT> ) == <NUM_LIT> ? <STR_LIT> : <STR_LIT> ) ; need_comma = <NUM_LIT> ; } fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; assemble_start_function ( stubdecl , stubname ) ; if ( ! FUNCTION_NAME_ALREADY_DECLARED ) { fputs ( <STR_LIT> , asm_out_file ) ; assemble_name ( asm_out_file , stubname ) ; fputs ( <STR_LIT> , asm_out_file ) ; assemble_name ( asm_out_file , stubname ) ; fputs ( <STR_LIT> , asm_out_file ) ; } fprintf ( asm_out_file , <STR_LIT> ) ; mips16_fp_args ( asm_out_file , fp_code , <NUM_LIT> ) ; if ( ! fpret ) { fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> , reg_names [ GP_REG_FIRST + <NUM_LIT> ] , fnname ) ; fprintf ( asm_out_file , <STR_LIT> , reg_names [ GP_REG_FIRST + <NUM_LIT> ] ) ; fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; } else { fprintf ( asm_out_file , <STR_LIT> , reg_names [ GP_REG_FIRST + <NUM_LIT> ] , reg_names [ GP_REG_FIRST + <NUM_LIT> ] ) ; fprintf ( asm_out_file , <STR_LIT> , fnname ) ; fprintf ( asm_out_file , <STR_LIT> ) ; if ( GET_MODE ( retval ) == SFmode ) fprintf ( asm_out_file , <STR_LIT> , reg_names [ GP_REG_FIRST + <NUM_LIT> ] , reg_names [ FP_REG_FIRST + <NUM_LIT> ] ) ; else { if ( TARGET_BIG_ENDIAN ) { fprintf ( asm_out_file , <STR_LIT> , reg_names [ GP_REG_FIRST + <NUM_LIT> ] , reg_names [ FP_REG_FIRST + <NUM_LIT> ] ) ; fprintf ( asm_out_file , <STR_LIT> , reg_names [ GP_REG_FIRST + <NUM_LIT> ] , reg_names [ FP_REG_FIRST + <NUM_LIT> ] ) ; } else { fprintf ( asm_out_file , <STR_LIT> , reg_names [ GP_REG_FIRST + <NUM_LIT> ] , reg_names [ FP_REG_FIRST + <NUM_LIT> ] ) ; fprintf ( asm_out_file , <STR_LIT> , reg_names [ GP_REG_FIRST + <NUM_LIT> ] , reg_names [ FP_REG_FIRST + <NUM_LIT> ] ) ; } } fprintf ( asm_out_file , <STR_LIT> , reg_names [ GP_REG_FIRST + <NUM_LIT> ] ) ; fprintf ( asm_out_file , <STR_LIT> ) ; } fprintf ( asm_out_file , <STR_LIT> ) ; ASM_DECLARE_FUNCTION_SIZE ( asm_out_file , stubname , stubdecl ) ; if ( ! FUNCTION_NAME_ALREADY_DECLARED ) {


<s> const char * fnname ; char * secname , * stubname ; tree stubid , stubdecl ; int need_comma ; unsigned int f ; fnname = XSTR ( XEXP ( DECL_RTL ( current_function_decl ) , <NUM_LIT> ) , <NUM_LIT> ) ; secname = ( char * ) alloca ( strlen ( fnname ) + <NUM_LIT> ) ; sprintf ( secname , <STR_LIT> , fnname ) ; stubname = ( char * ) alloca ( strlen ( fnname ) + <NUM_LIT> ) ; sprintf ( stubname , <STR_LIT> , fnname ) ; stubid = get_identifier ( stubname ) ; stubdecl = build_decl ( FUNCTION_DECL , stubid , build_function_type ( void_type_node , NULL_TREE ) ) ; DECL_SECTION_NAME ( stubdecl ) = build_string ( strlen ( secname ) , secname ) ; fprintf ( file , <STR_LIT> , current_function_name ( ) ) ; need_comma = <NUM_LIT> ; for ( f = ( unsigned int ) current_function_args_info . fp_code ; f != <NUM_LIT> ; f >>= <NUM_LIT> ) { fprintf ( file , <STR_LIT> , need_comma ? <STR_LIT> : <STR_LIT> , ( f & <NUM_LIT> ) == <NUM_LIT> ? <STR_LIT> : <STR_LIT> ) ; need_comma = <NUM_LIT> ; } fprintf ( file , <STR_LIT> ) ; fprintf ( file , <STR_LIT> ) ; function_section ( stubdecl ) ; ASM_OUTPUT_ALIGN ( file , floor_log2 ( FUNCTION_BOUNDARY / BITS_PER_UNIT ) ) ; if ( ! FUNCTION_NAME_ALREADY_DECLARED ) { fputs ( <STR_LIT> , file ) ; assemble_name ( file , stubname ) ; fputs ( <STR_LIT> , file ) ; } assemble_name ( file , stubname ) ; fputs ( <STR_LIT> , file ) ; fprintf ( file , <STR_LIT> ) ; mips16_fp_args ( file , current_function_args_info . fp_code , <NUM_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> , reg_names [ GP_REG_FIRST + <NUM_LIT> ] ) ; assemble_name ( file , fnname ) ; fprintf ( file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> , reg_names [ GP_REG_FIRST + <NUM_LIT> ] ) ; fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( file , <STR_LIT> ) ; fprintf ( file , <STR_LIT> ) ; if ( ! FUNCTION_NAME_ALREADY_DECLARED ) { fputs ( <STR_LIT> , file ) ; assemble_name ( file , stubname ) ; fputs ( <STR_LIT> , file ) ; } fprintf ( file , <STR_LIT> ) ;


<s> char * secname , * stubname ; tree stubid , stubdecl ; int need_comma ; unsigned int f ; fnname = XSTR ( XEXP ( DECL_RTL ( current_function_decl ) , <NUM_LIT> ) , <NUM_LIT> ) ; secname = ( char * ) alloca ( strlen ( fnname ) + <NUM_LIT> ) ; sprintf ( secname , <STR_LIT> , fnname ) ; stubname = ( char * ) alloca ( strlen ( fnname ) + <NUM_LIT> ) ; sprintf ( stubname , <STR_LIT> , fnname ) ; stubid = get_identifier ( stubname ) ; stubdecl = build_decl ( FUNCTION_DECL , stubid , build_function_type ( void_type_node , NULL_TREE ) ) ; DECL_SECTION_NAME ( stubdecl ) = build_string ( strlen ( secname ) , secname ) ; fprintf ( file , <STR_LIT> , current_function_name ( ) ) ; need_comma = <NUM_LIT> ; for ( f = ( unsigned int ) current_function_args_info . fp_code ; f != <NUM_LIT> ; f >>= <NUM_LIT> ) { fprintf ( file , <STR_LIT> , need_comma ? <STR_LIT> : <STR_LIT> , ( f & <NUM_LIT> ) == <NUM_LIT> ? <STR_LIT> : <STR_LIT> ) ; need_comma = <NUM_LIT> ; } fprintf ( file , <STR_LIT> ) ; fprintf ( file , <STR_LIT> ) ; function_section ( stubdecl ) ; ASM_OUTPUT_ALIGN ( file , floor_log2 ( FUNCTION_BOUNDARY / BITS_PER_UNIT ) ) ; if ( ! FUNCTION_NAME_ALREADY_DECLARED ) { fputs ( <STR_LIT> , file ) ; assemble_name ( file , stubname ) ; fputs ( <STR_LIT> , file ) ; } assemble_name ( file , stubname ) ; fputs ( <STR_LIT> , file ) ; fprintf ( file , <STR_LIT> ) ; mips16_fp_args ( file , current_function_args_info . fp_code , <NUM_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> , reg_names [ GP_REG_FIRST + <NUM_LIT> ] ) ; assemble_name ( file , fnname ) ; fprintf ( file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> , reg_names [ GP_REG_FIRST + <NUM_LIT> ] ) ; fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( file , <STR_LIT> ) ; fprintf ( file , <STR_LIT> ) ; if ( ! FUNCTION_NAME_ALREADY_DECLARED ) {


<s> fmask |= ( ( <NUM_LIT> << FP_INC ) - <NUM_LIT> ) << ( regno - FP_REG_FIRST ) ; } } gp_reg_rounded = MIPS_STACK_ALIGN ( gp_reg_size ) ; total_size += gp_reg_rounded + MIPS_STACK_ALIGN ( fp_reg_size ) ; total_size += current_function_pretend_args_size ; total_size += MIPS_STACK_ALIGN ( cfun -> machine -> varargs_size ) ; cfun -> machine -> frame . total_size = total_size ; cfun -> machine -> frame . var_size = var_size ; cfun -> machine -> frame . args_size = args_size ; cfun -> machine -> frame . cprestore_size = cprestore_size ; cfun -> machine -> frame . gp_reg_size = gp_reg_size ; cfun -> machine -> frame . fp_reg_size = fp_reg_size ; cfun -> machine -> frame . mask = mask ; cfun -> machine -> frame . fmask = fmask ; cfun -> machine -> frame . initialized = reload_completed ; cfun -> machine -> frame . num_gp = gp_reg_size / UNITS_PER_WORD ; cfun -> machine -> frame . num_fp = fp_reg_size / ( FP_INC * UNITS_PER_FPREG ) ;


<s> gp_reg_rounded = MIPS_STACK_ALIGN ( gp_reg_size ) ; total_size += gp_reg_rounded + MIPS_STACK_ALIGN ( fp_reg_size ) ; total_size += current_function_pretend_args_size ; total_size += MIPS_STACK_ALIGN ( cfun -> machine -> varargs_size ) ; cfun -> machine -> frame . total_size = total_size ; cfun -> machine -> frame . var_size = var_size ; cfun -> machine -> frame . args_size = args_size ; cfun -> machine -> frame . cprestore_size = cprestore_size ; cfun -> machine -> frame . gp_reg_size = gp_reg_size ; cfun -> machine -> frame . fp_reg_size = fp_reg_size ; cfun -> machine -> frame . mask = mask ; cfun -> machine -> frame . fmask = fmask ; cfun -> machine -> frame . initialized = reload_completed ; cfun -> machine -> frame . num_gp = gp_reg_size / UNITS_PER_WORD ; cfun -> machine -> frame . num_fp = fp_reg_size / ( FP_INC * UNITS_PER_FPREG ) ; if ( mask ) { HOST_WIDE_INT offset ; offset = ( args_size + cprestore_size + var_size + gp_reg_size - GET_MODE_SIZE ( gpr_mode ) ) ; cfun -> machine -> frame . gp_sp_offset = offset ; cfun -> machine -> frame . gp_save_offset = offset - total_size ; } else { cfun -> machine -> frame . gp_sp_offset = <NUM_LIT> ; cfun -> machine -> frame . gp_save_offset = <NUM_LIT> ; } if ( fmask ) { HOST_WIDE_INT offset ; offset = ( args_size + cprestore_size + var_size + gp_reg_rounded + fp_reg_size - FP_INC * UNITS_PER_FPREG ) ; cfun -> machine -> frame . fp_sp_offset = offset ; cfun -> machine -> frame . fp_save_offset = offset - total_size ; } else { cfun -> machine -> frame . fp_sp_offset = <NUM_LIT> ; cfun -> machine -> frame . fp_save_offset = <NUM_LIT> ;


<s> align = <NUM_LIT> ; for ( c = constants ; c != NULL ; c = next ) { if ( align < GET_MODE_SIZE ( c -> mode ) ) { int align_log = floor_log2 ( GET_MODE_SIZE ( c -> mode ) ) ; insn = emit_insn_after ( gen_align ( GEN_INT ( align_log ) ) , insn ) ; } align = GET_MODE_SIZE ( c -> mode ) ; insn = emit_label_after ( c -> label , insn ) ; insn = dump_constants_1 ( c -> mode , c -> value , insn ) ; next = c -> next ;


<s> rtx size = GEN_INT ( GET_MODE_SIZE ( mode ) ) ; return emit_insn_after ( gen_consttable_int ( value , size ) , insn ) ; } case MODE_FLOAT : return emit_insn_after ( gen_consttable_float ( value ) , insn ) ;


<s> for ( ; field ; field = TREE_CHAIN ( field ) ) if ( TREE_CODE ( field ) == FIELD_DECL && int_bit_position ( field ) >= bitpos ) break ; if ( field && int_bit_position ( field ) == bitpos && TREE_CODE ( TREE_TYPE ( field ) ) == REAL_TYPE && ! TARGET_SOFT_FLOAT && 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 ) ; 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 ( mode ) == MODE_COMPLEX_FLOAT ) { rtx real , imag ; enum machine_mode inner ; int reg ; inner = GET_MODE_INNER ( mode ) ; reg = FP_ARG_FIRST + info . reg_offset ; real = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( inner , reg ) , const0_rtx ) ; imag = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( inner , reg + info . reg_words / <NUM_LIT> ) , GEN_INT ( GET_MODE_SIZE ( inner ) ) ) ; return gen_rtx_PARALLEL ( mode , gen_rtvec ( <NUM_LIT> , real , imag ) ) ; } if ( ! info . fpr_p ) return gen_rtx_REG ( mode , GP_ARG_FIRST + info . reg_offset ) ; else if ( info . reg_offset == <NUM_LIT> ) return gen_rtx_REG ( mode , FP_ARG_FIRST + FP_INC ) ; else return gen_rtx_REG ( mode , FP_ARG_FIRST + info . reg_offset ) ;


<s> if ( cum -> arg_number < <NUM_LIT> && info . fpr_p ) cum -> fp_code += ( mode == SFmode ? <NUM_LIT> : <NUM_LIT> ) << ( ( cum -> arg_number - <NUM_LIT> ) * <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 += FP_INC ; if ( info . stack_words > <NUM_LIT> ) cum -> stack_words = info . stack_offset + info . stack_words ; cum -> arg_number ++ ;


<s> void function_arg_advance ( CUMULATIVE_ARGS * cum , enum machine_mode mode , tree type , int named ) { struct mips_arg_info info ; mips_arg_info ( cum , mode , type , named , & info ) ; if ( ! info . fpr_p ) cum -> gp_reg_found = true ; if ( cum -> arg_number < <NUM_LIT> && info . fpr_p ) cum -> fp_code += ( mode == SFmode ? <NUM_LIT> : <NUM_LIT> ) << ( ( cum -> arg_number - <NUM_LIT> ) * <NUM_LIT> ) ;

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


<s> if ( alignment < PARM_BOUNDARY ) alignment = PARM_BOUNDARY ; if ( alignment > STACK_BOUNDARY ) alignment = STACK_BOUNDARY ;


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


<s> mips_emit_compare ( & code , & op0 , & op1 , TARGET_MIPS16 ) ; target = gen_rtx_IF_THEN_ELSE ( VOIDmode , gen_rtx_fmt_ee ( code , GET_MODE ( op0 ) , op0 , op1 ) , gen_rtx_LABEL_REF ( VOIDmode , operands [ <NUM_LIT> ] ) , pc_rtx ) ; emit_jump_insn ( gen_rtx_SET ( VOIDmode , pc_rtx , target ) ) ;


<s> rtx op0 , op1 , target ; mips_emit_compare ( & code , & op0 , & op1 , TARGET_MIPS16 ) ;

target = gen_rtx_IF_THEN_ELSE ( VOIDmode , gen_rtx_fmt_ee ( code , GET_MODE ( op0 ) , op0 , op1 ) , gen_rtx_LABEL_REF ( VOIDmode , operands [ <NUM_LIT> ] ) , pc_rtx ) ;


<s> code = GET_CODE ( operands [ <NUM_LIT> ] ) ; mips_emit_compare ( & code , & op0 , & op1 , true ) ; emit_insn ( gen_rtx_SET ( VOIDmode , operands [ <NUM_LIT> ] , gen_rtx_IF_THEN_ELSE ( GET_MODE ( operands [ <NUM_LIT> ] ) , gen_rtx_fmt_ee ( code , GET_MODE ( op0 ) , op0 , op1 ) , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ) ;


<s> rtx op0 , op1 ; code = GET_CODE ( operands [ <NUM_LIT> ] ) ; mips_emit_compare ( & code , & op0 , & op1 , true ) ;

emit_insn ( gen_rtx_SET ( VOIDmode , operands [ <NUM_LIT> ] , gen_rtx_IF_THEN_ELSE ( GET_MODE ( operands [ <NUM_LIT> ] ) , gen_rtx_fmt_ee ( code , GET_MODE ( op0 ) , op0 , op1 ) , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ) ;


<s> param != <NUM_LIT> ; param = next_param ) { next_param = TREE_CHAIN ( param ) ; if ( next_param == <NUM_LIT> && TREE_VALUE ( param ) != void_type_node ) cum -> gp_reg_found = <NUM_LIT> ; }


<s> p -> next = extern_head ; p -> name = XSTR ( fun , <NUM_LIT> ) ; p -> size = - <NUM_LIT> ; extern_head = p ; }


<s> p -> next = extern_head ; p -> name = XSTR ( fun , <NUM_LIT> ) ; p -> size = - <NUM_LIT> ; extern_head = p ;


<s> static int m16_check_op ( rtx op , int low , int high , int mask ) { return ( GET_CODE ( op ) == CONST_INT && INTVAL ( op ) >= low && INTVAL ( op ) <= high && ( INTVAL ( op ) & mask ) == <NUM_LIT> ) ;


<s> return m16_check_op ( op , - <NUM_LIT> , <NUM_LIT> , <NUM_LIT> ) ;


<s> int m16_nsimm5_1 ( rtx op , enum machine_mode mode ATTRIBUTE_UNUSED ) { return m16_check_op ( op , - <NUM_LIT> , <NUM_LIT> , <NUM_LIT> ) ;


<s> return m16_check_op ( op , ( - <NUM_LIT> ) << <NUM_LIT> , <NUM_LIT> << <NUM_LIT> , <NUM_LIT> ) ;


<s> int m16_nsimm8_8 ( rtx op , enum machine_mode mode ATTRIBUTE_UNUSED ) {

return m16_check_op ( op , ( - <NUM_LIT> ) << <NUM_LIT> , <NUM_LIT> << <NUM_LIT> , <NUM_LIT> ) ;


<s> int m16_nuimm5_4 ( rtx op , enum machine_mode mode ATTRIBUTE_UNUSED ) { return m16_check_op ( op , ( - <NUM_LIT> ) << <NUM_LIT> , <NUM_LIT> << <NUM_LIT> , <NUM_LIT> ) ;


<s> int m16_nuimm8_1 ( rtx op , enum machine_mode mode ATTRIBUTE_UNUSED ) {

return m16_check_op ( op , - <NUM_LIT> , <NUM_LIT> , <NUM_LIT> ) ;


<s> int m16_nuimm8_1 ( rtx op , enum machine_mode mode ATTRIBUTE_UNUSED ) { return m16_check_op ( op , - <NUM_LIT> , <NUM_LIT> , <NUM_LIT> ) ;


<s> int m16_simm5_1 ( rtx op , enum machine_mode mode ATTRIBUTE_UNUSED ) { return m16_check_op ( op , - <NUM_LIT> , <NUM_LIT> , <NUM_LIT> ) ;


<s> int m16_simm8_1 ( rtx op , enum machine_mode mode ATTRIBUTE_UNUSED ) { return m16_check_op ( op , - <NUM_LIT> , <NUM_LIT> , <NUM_LIT> ) ;


<s> int m16_simm8_8 ( rtx op , enum machine_mode mode ATTRIBUTE_UNUSED ) {


<s> return m16_check_op ( op , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> ) ;


<s> return m16_check_op ( op , <NUM_LIT> , <NUM_LIT> << <NUM_LIT> , <NUM_LIT> ) ;


<s> else if ( ( f & <NUM_LIT> ) == <NUM_LIT> ) { if ( TARGET_64BIT ) fprintf ( file , <STR_LIT> , s , reg_names [ gparg ] , reg_names [ fparg ] ) ; else { if ( ( fparg & <NUM_LIT> ) != <NUM_LIT> ) ++ fparg ; if ( TARGET_BIG_ENDIAN ) fprintf ( file , <STR_LIT> , s , reg_names [ gparg ] , reg_names [ fparg + <NUM_LIT> ] , s , reg_names [ gparg + <NUM_LIT> ] , reg_names [ fparg ] ) ; else fprintf ( file , <STR_LIT> , s , reg_names [ gparg ] , reg_names [ fparg ] , s , reg_names [ gparg + <NUM_LIT> ] , reg_names [ fparg + <NUM_LIT> ] ) ; ++ gparg ; ++ fparg ; } } else gcc_unreachable ( ) ; ++ gparg ; ++ fparg ;


<s> gcc_assert ( TARGET_OLDABI ) ; if ( from_fp_p ) s = <STR_LIT> ; else s = <STR_LIT> ; gparg = GP_ARG_FIRST ; fparg = FP_ARG_FIRST ; for ( f = ( unsigned int ) fp_code ; f != <NUM_LIT> ; f >>= <NUM_LIT> ) { if ( ( f & <NUM_LIT> ) == <NUM_LIT> ) { if ( ( fparg & <NUM_LIT> ) != <NUM_LIT> ) ++ fparg ; fprintf ( file , <STR_LIT> , s , reg_names [ gparg ] , reg_names [ fparg ] ) ; } else if ( ( f & <NUM_LIT> ) == <NUM_LIT> ) { if ( TARGET_64BIT ) fprintf ( file , <STR_LIT> , s , reg_names [ gparg ] , reg_names [ fparg ] ) ; else { if ( ( fparg & <NUM_LIT> ) != <NUM_LIT> ) ++ fparg ; if ( TARGET_BIG_ENDIAN ) fprintf ( file , <STR_LIT> , s , reg_names [ gparg ] , reg_names [ fparg + <NUM_LIT> ] , s , reg_names [ gparg + <NUM_LIT> ] , reg_names [ fparg ] ) ; else fprintf ( file , <STR_LIT> , s , reg_names [ gparg ] , reg_names [ fparg ] , s , reg_names [ gparg + <NUM_LIT> ] , reg_names [ fparg + <NUM_LIT> ] ) ;


<s> end_sequence ( ) ; push_topmost_sequence ( ) ; for ( scan = get_insns ( ) ; scan != NULL_RTX ; scan = NEXT_INSN ( scan ) ) if ( NOTE_P ( scan ) && NOTE_LINE_NUMBER ( scan ) == NOTE_INSN_FUNCTION_BEG ) break ; if ( scan == NULL_RTX ) scan = get_insns ( ) ; insn = emit_insn_after ( insn , scan ) ; pop_topmost_sequence ( ) ; }

return cfun -> machine -> mips16_gp_pseudo_rtx ;


<s> rtx body = PATTERN ( insn ) ; if ( GET_CODE ( body ) == ADDR_VEC ) return GET_MODE_SIZE ( GET_MODE ( body ) ) * XVECLEN ( body , <NUM_LIT> ) ; if ( GET_CODE ( body ) == ADDR_DIFF_VEC ) return GET_MODE_SIZE ( GET_MODE ( body ) ) * XVECLEN ( body , <NUM_LIT> ) ; }


<s> rtx body = PATTERN ( insn ) ; if ( GET_CODE ( body ) == ADDR_VEC ) return GET_MODE_SIZE ( GET_MODE ( body ) ) * XVECLEN ( body , <NUM_LIT> ) ;

if ( GET_CODE ( body ) == ADDR_DIFF_VEC ) return GET_MODE_SIZE ( GET_MODE ( body ) ) * XVECLEN ( body , <NUM_LIT> ) ;


<s> static int mips16_rewrite_pool_refs ( rtx * x , void * data ) { struct mips16_constant_pool * pool = data ;

if ( GET_CODE ( * x ) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P ( * x ) ) * x = gen_rtx_LABEL_REF ( Pmode , add_constant ( pool , get_pool_constant ( * x ) , get_pool_mode ( * x ) ) ) ;


<s> if ( GET_CODE ( * x ) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P ( * x ) ) * x = gen_rtx_LABEL_REF ( Pmode , add_constant ( pool , get_pool_constant ( * x ) , get_pool_mode ( * x ) ) ) ;


<s> static int mips_address_cost ( rtx addr ) { return mips_address_insns ( addr , SImode ) ;


<s> if ( REG_NOTE_KIND ( link ) != <NUM_LIT> ) return <NUM_LIT> ; return cost ;


<s> static int mips_adjust_cost ( rtx insn ATTRIBUTE_UNUSED , rtx link , rtx dep ATTRIBUTE_UNUSED , int cost ) { if ( REG_NOTE_KIND ( link ) != <NUM_LIT> ) return <NUM_LIT> ;


<s> static void mips_arg_info ( const CUMULATIVE_ARGS * cum , enum machine_mode mode , tree type , int named , struct mips_arg_info * info ) { bool doubleword_aligned_p ; unsigned int num_bytes , num_words , max_regs ; num_bytes = type ? int_size_in_bytes ( type ) : GET_MODE_SIZE ( mode ) ; num_words = ( num_bytes + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ; switch ( mips_abi ) { case ABI_EABI : info -> fpr_p = ( ( GET_MODE_CLASS ( mode ) == MODE_FLOAT || GET_MODE_CLASS ( mode ) == MODE_VECTOR_FLOAT ) && GET_MODE_SIZE ( mode ) <= UNITS_PER_FPVALUE ) ; break ; case ABI_32 : case ABI_O64 : 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 || GET_MODE_CLASS ( mode ) == MODE_VECTOR_FLOAT ) && GET_MODE_SIZE ( mode ) <= UNITS_PER_FPVALUE ) ; break ; case ABI_N32 : case ABI_64 : info -> fpr_p = ( named && ( type == <NUM_LIT> || FLOAT_TYPE_P ( type ) ) && ( GET_MODE_CLASS ( mode ) == MODE_FLOAT || GET_MODE_CLASS ( mode ) == MODE_COMPLEX_FLOAT || GET_MODE_CLASS ( mode ) == MODE_VECTOR_FLOAT ) && 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 ) { if ( cum -> num_gprs >= MAX_ARGS_IN_REGISTERS - <NUM_LIT> ) info -> fpr_p = false ; else num_words = <NUM_LIT> ; } break ; default : gcc_unreachable ( ) ;


<s> mips_arg_info ( cum , mode , type , named , & info ) ; return info . stack_words > <NUM_LIT> ? info . reg_words * UNITS_PER_WORD : <NUM_LIT> ;


<s> if ( GET_CODE ( pattern ) == ASM_INPUT || asm_noperands ( pattern ) >= <NUM_LIT> ) cfun -> machine -> all_noreorder_p = false ; ninsns = get_attr_length ( insn ) / <NUM_LIT> ; if ( ninsns == <NUM_LIT> ) return ; if ( * hilo_delay < <NUM_LIT> && reg_set_p ( lo_reg , pattern ) ) nops = <NUM_LIT> - * hilo_delay ; else if ( * delayed_reg != <NUM_LIT> && reg_referenced_p ( * delayed_reg , pattern ) ) nops = <NUM_LIT> ; else nops = <NUM_LIT> ; * hilo_delay += nops ; while ( nops -- > <NUM_LIT> ) emit_insn_after ( gen_hazard_nop ( ) , after ) ; * hilo_delay += ninsns ; * delayed_reg = <NUM_LIT> ;

if ( INSN_CODE ( insn ) >= <NUM_LIT> ) switch ( get_attr_hazard ( insn ) ) {


<s> int hilo_delay , i ; split_all_insns_noflow ( ) ; cfun -> machine -> ignore_hazard_length_p = true ; shorten_branches ( get_insns ( ) ) ; cfun -> machine -> all_noreorder_p = true ; if ( current_function_profile ) cfun -> machine -> all_noreorder_p = false ; if ( TARGET_FIX_VR4120 ) cfun -> machine -> all_noreorder_p = false ; if ( TARGET_FIX_VR4130 && ! ISA_HAS_MACCHI ) cfun -> machine -> all_noreorder_p = false ; last_insn = <NUM_LIT> ; hilo_delay = <NUM_LIT> ; delayed_reg = <NUM_LIT> ; lo_reg = gen_rtx_REG ( SImode , LO_REGNUM ) ; for ( insn = get_insns ( ) ; insn != <NUM_LIT> ; insn = NEXT_INSN ( insn ) ) if ( INSN_P ( insn ) ) { if ( GET_CODE ( PATTERN ( insn ) ) == SEQUENCE ) for ( i = <NUM_LIT> ; i < XVECLEN ( PATTERN ( insn ) , <NUM_LIT> ) ; i ++ ) mips_avoid_hazard ( last_insn , XVECEXP ( PATTERN ( insn ) , <NUM_LIT> , i ) , & hilo_delay , & delayed_reg , lo_reg ) ; else mips_avoid_hazard ( last_insn , insn , & hilo_delay , & delayed_reg , lo_reg ) ;


<s> mips_adjust_block_mem ( dest , MAX_MOVE_BYTES , & dest_reg , & dest ) ; final_src = expand_simple_binop ( Pmode , PLUS , src_reg , GEN_INT ( length ) , <NUM_LIT> , <NUM_LIT> , OPTAB_WIDEN ) ; label = gen_label_rtx ( ) ; emit_label ( label ) ; mips_block_move_straight ( dest , src , MAX_MOVE_BYTES ) ; emit_move_insn ( src_reg , plus_constant ( src_reg , MAX_MOVE_BYTES ) ) ; emit_move_insn ( dest_reg , plus_constant ( dest_reg , MAX_MOVE_BYTES ) ) ; if ( Pmode == DImode ) emit_insn ( gen_cmpdi ( src_reg , final_src ) ) ; else emit_insn ( gen_cmpsi ( src_reg , final_src ) ) ;


<s> int i ; enum machine_mode mode ; rtx * regs ; if ( MEM_ALIGN ( src ) == BITS_PER_WORD / <NUM_LIT> && MEM_ALIGN ( dest ) == BITS_PER_WORD / <NUM_LIT> ) bits = BITS_PER_WORD / <NUM_LIT> ; else bits = BITS_PER_WORD ; mode = mode_for_size ( bits , MODE_INT , <NUM_LIT> ) ; delta = bits / BITS_PER_UNIT ; regs = alloca ( sizeof ( rtx ) * length / delta ) ; for ( offset = <NUM_LIT> , i = <NUM_LIT> ; offset + delta <= length ; offset += delta , i ++ ) { regs [ i ] = gen_reg_rtx ( mode ) ; if ( MEM_ALIGN ( src ) >= bits ) emit_move_insn ( regs [ i ] , adjust_address ( src , mode , offset ) ) ; else { rtx part = adjust_address ( src , BLKmode , offset ) ; if ( ! mips_expand_unaligned_load ( regs [ i ] , part , bits , <NUM_LIT> ) ) gcc_unreachable ( ) ; } } for ( offset = <NUM_LIT> , i = <NUM_LIT> ; offset + delta <= length ; offset += delta , i ++ ) if ( MEM_ALIGN ( dest ) >= bits ) emit_move_insn ( adjust_address ( dest , mode , offset ) , regs [ i ] ) ;


<s> delta = bits / BITS_PER_UNIT ; regs = alloca ( sizeof ( rtx ) * length / delta ) ; for ( offset = <NUM_LIT> , i = <NUM_LIT> ; offset + delta <= length ; offset += delta , i ++ ) { regs [ i ] = gen_reg_rtx ( mode ) ; if ( MEM_ALIGN ( src ) >= bits ) emit_move_insn ( regs [ i ] , adjust_address ( src , mode , offset ) ) ; else { rtx part = adjust_address ( src , BLKmode , offset ) ; if ( ! mips_expand_unaligned_load ( regs [ i ] , part , bits , <NUM_LIT> ) ) gcc_unreachable ( ) ; } }

for ( offset = <NUM_LIT> , i = <NUM_LIT> ; offset + delta <= length ; offset += delta , i ++ ) if ( MEM_ALIGN ( dest ) >= bits ) emit_move_insn ( adjust_address ( dest , mode , offset ) , regs [ i ] ) ;


<s> if ( reg_classes_intersect_p ( ACC_REGS , class ) ) return true ; } } if ( TARGET_FLOAT64 && from == SImode && GET_MODE_SIZE ( to ) >= UNITS_PER_WORD && reg_classes_intersect_p ( FP_REGS , class ) ) return true ;


<s> bool mips_cannot_change_mode_class ( enum machine_mode from , enum machine_mode to , enum reg_class class ) { if ( MIN ( GET_MODE_SIZE ( from ) , GET_MODE_SIZE ( to ) ) <= UNITS_PER_WORD && MAX ( GET_MODE_SIZE ( from ) , GET_MODE_SIZE ( to ) ) > UNITS_PER_WORD ) { if ( TARGET_BIG_ENDIAN ) { if ( FP_INC > <NUM_LIT> && reg_classes_intersect_p ( FP_REGS , class ) ) return true ; } else {

if ( reg_classes_intersect_p ( ACC_REGS , class ) ) return true ;


<s> case LE : if ( original < plus_one ) { * code = LT ; * cmp1 = force_reg ( mode , GEN_INT ( plus_one ) ) ; return true ; } break ; case LEU : if ( plus_one != <NUM_LIT> ) { * code = LTU ; * cmp1 = force_reg ( mode , GEN_INT ( plus_one ) ) ; return true ;


<s> static bool mips_canonicalize_comparison ( enum rtx_code * code , rtx * cmp1 , enum machine_mode mode ) { HOST_WIDE_INT original , plus_one ; if ( GET_CODE ( * cmp1 ) != CONST_INT ) return false ; original = INTVAL ( * cmp1 ) ; plus_one = trunc_int_for_mode ( ( unsigned HOST_WIDE_INT ) original + <NUM_LIT> , mode ) ; switch ( * code ) {


<s> return_type = DECL_RESULT ( current_function_decl ) ; if ( TARGET_MIPS16 && mips16_hard_float && ! aggregate_value_p ( return_type , current_function_decl ) && GET_MODE_CLASS ( DECL_MODE ( return_type ) ) == MODE_FLOAT && GET_MODE_SIZE ( DECL_MODE ( return_type ) ) <= UNITS_PER_FPVALUE ) return <NUM_LIT> ; if ( cfun -> machine -> frame . initialized ) return cfun -> machine -> frame . total_size == <NUM_LIT> ;

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


<s> if ( TARGET_MIPS16 && mips16_hard_float && ! aggregate_value_p ( return_type , current_function_decl ) && GET_MODE_CLASS ( DECL_MODE ( return_type ) ) == MODE_FLOAT && GET_MODE_SIZE ( DECL_MODE ( return_type ) ) <= UNITS_PER_FPVALUE ) return <NUM_LIT> ; if ( cfun -> machine -> frame . initialized ) return cfun -> machine -> frame . total_size == <NUM_LIT> ; return compute_frame_size ( get_frame_size ( ) ) == <NUM_LIT> ;


<s> else return ( GET_MODE_SIZE ( mode ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ;


<s> for ( p = mips_cpu_info_table ; p -> name != <NUM_LIT> ; p ++ ) if ( p -> isa == isa ) return p ; return <NUM_LIT> ;


<s> for ( p = mips_cpu_info_table ; p -> name != <NUM_LIT> ; p ++ ) if ( p -> isa == isa ) return p ;


<s> if ( TARGET_EXPLICIT_RELOCS ) return false ; mips_split_const ( x , & x , & offset ) ; return global_got_operand ( x , VOIDmode ) ;


<s> if ( TARGET_EXPLICIT_RELOCS ) return false ; mips_split_const ( x , & x , & offset ) ;

return global_got_operand ( x , VOIDmode ) ;


<s> if ( reg == stack_pointer_rtx || reg == frame_pointer_rtx || reg == hard_frame_pointer_rtx ) { HOST_WIDE_INT frame_size = ( ! cfun -> machine -> frame . initialized ) ? compute_frame_size ( get_frame_size ( ) ) : cfun -> machine -> frame . total_size ; if ( frame_pointer_needed && TARGET_MIPS16 ) frame_size -= cfun -> machine -> frame . args_size ; offset = offset - frame_size ;


<s> HOST_WIDE_INT size ; size_directive_output = <NUM_LIT> ; size = int_size_in_bytes ( TREE_TYPE ( decl ) ) ;

ASM_OUTPUT_SIZE_DIRECTIVE ( stream , name , size ) ;


<s> ASM_OUTPUT_TYPE_DIRECTIVE ( stream , name , <STR_LIT> ) ; size_directive_output = <NUM_LIT> ; if ( ! flag_inhibit_size_directive && DECL_SIZE ( decl ) ) { HOST_WIDE_INT size ;


<s> * op1 = cmp_operands [ <NUM_LIT> ] ; } else if ( * code == EQ || * code == NE ) { if ( need_eq_ne_p ) { * op0 = mips_zero_if_equal ( cmp_operands [ <NUM_LIT> ] , cmp_operands [ <NUM_LIT> ] ) ; * op1 = const0_rtx ; } else { * op0 = cmp_operands [ <NUM_LIT> ] ; * op1 = force_reg ( GET_MODE ( * op0 ) , cmp_operands [ <NUM_LIT> ] ) ; } } else { bool invert = false ; * op0 = gen_reg_rtx ( GET_MODE ( cmp_operands [ <NUM_LIT> ] ) ) ; * op1 = const0_rtx ; mips_emit_int_relational ( * code , & invert , * op0 , cmp_operands [ <NUM_LIT> ] , cmp_operands [ <NUM_LIT> ] ) ; * code = ( invert ? EQ : NE ) ; } } else { enum rtx_code cmp_code ;


<s> else if ( REG_P ( src ) || GET_CODE ( src ) == SUBREG ) src = gen_rtx_REG ( SFmode , true_regnum ( src ) ) ; fp1 = gen_rtx_REG ( SFmode , REGNO ( scratch ) ) ; fp2 = gen_rtx_REG ( SFmode , REGNO ( scratch ) + FP_INC ) ; emit_move_insn ( copy_rtx ( fp1 ) , src ) ;

emit_move_insn ( copy_rtx ( fp2 ) , CONST0_RTX ( SFmode ) ) ;


<s> if ( mips_relational_operand_ok_p ( code , cmp1 ) ) mips_emit_binary ( code , target , cmp0 , cmp1 ) ; else if ( mips_canonicalize_comparison ( & code , & cmp1 , GET_MODE ( target ) ) ) mips_emit_binary ( code , target , cmp0 , cmp1 ) ; else { enum rtx_code inv_code = reverse_condition ( code ) ; if ( ! mips_relational_operand_ok_p ( inv_code , cmp1 ) ) { cmp1 = force_reg ( GET_MODE ( cmp0 ) , cmp1 ) ; mips_emit_int_relational ( code , invert_ptr , target , cmp0 , cmp1 ) ; } else if ( invert_ptr == <NUM_LIT> ) { rtx inv_target = gen_reg_rtx ( GET_MODE ( target ) ) ; mips_emit_binary ( inv_code , inv_target , cmp0 , cmp1 ) ; mips_emit_binary ( XOR , target , inv_target , const1_rtx ) ; }


<s> incoming_address = gen_rtx_REG ( Pmode , PIC_FUNCTION_ADDR_REGNUM ) ; emit_insn ( gen_loadgp ( offset , incoming_address ) ) ; if ( ! TARGET_EXPLICIT_RELOCS ) emit_insn ( gen_loadgp_blockage ( ) ) ;


<s> if ( code == EQ || code == NE ) { rtx zie = mips_zero_if_equal ( cmp_operands [ <NUM_LIT> ] , cmp_operands [ <NUM_LIT> ] ) ;

mips_emit_binary ( code , target , zie , const0_rtx ) ;


<s> target = gen_lowpart ( GET_MODE ( cmp_operands [ <NUM_LIT> ] ) , target ) ; if ( code == EQ || code == NE ) { rtx zie = mips_zero_if_equal ( cmp_operands [ <NUM_LIT> ] , cmp_operands [ <NUM_LIT> ] ) ; mips_emit_binary ( code , target , zie , const0_rtx ) ; }

else mips_emit_int_relational ( code , <NUM_LIT> , target , cmp_operands [ <NUM_LIT> ] , cmp_operands [ <NUM_LIT> ] ) ;


<s> static void mips_encode_section_info ( tree decl , rtx rtl , int first ) { default_encode_section_info ( decl , rtl , first ) ; if ( TREE_CODE ( decl ) == FUNCTION_DECL && lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( TREE_TYPE ( decl ) ) ) ) { rtx symbol = XEXP ( rtl , <NUM_LIT> ) ; SYMBOL_REF_FLAGS ( symbol ) |= SYMBOL_FLAG_LONG_CALL ;


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


<s> bool mips_expand_block_move ( rtx dest , rtx src , rtx length ) { if ( GET_CODE ( length ) == CONST_INT ) { if ( INTVAL ( length ) <= <NUM_LIT> * MAX_MOVE_BYTES ) { mips_block_move_straight ( dest , src , INTVAL ( length ) ) ; return true ; } else if ( optimize ) { mips_block_move_loop ( dest , src , INTVAL ( length ) ) ;


<s> icode = bdesc [ fcode ] . icode ; type = bdesc [ fcode ] . builtin_type ; break ; } fcode -= m -> size ; } if ( bdesc == NULL ) return <NUM_LIT> ; switch ( type ) { case MIPS_BUILTIN_DIRECT : return mips_expand_builtin_direct ( icode , target , arglist , true ) ; case MIPS_BUILTIN_DIRECT_NO_TARGET : return mips_expand_builtin_direct ( icode , target , arglist , false ) ; case MIPS_BUILTIN_MOVT : case MIPS_BUILTIN_MOVF : return mips_expand_builtin_movtf ( type , icode , bdesc [ fcode ] . cond , target , arglist ) ; 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 ( type , icode , bdesc [ fcode ] . cond , target , arglist ) ; case MIPS_BUILTIN_BPOSGE32 : return mips_expand_builtin_bposge ( type , target ) ; default :


<s> else gcc_assert ( <NUM_LIT> ) ; emit_move_insn ( target , const0_rtx ) ; label1 = gen_label_rtx ( ) ; label2 = gen_label_rtx ( ) ; if_then_else = gen_rtx_IF_THEN_ELSE ( VOIDmode , gen_rtx_fmt_ee ( GE , CCDSPmode , cmp_result , GEN_INT ( cmp_value ) ) , gen_rtx_LABEL_REF ( VOIDmode , label1 ) , pc_rtx ) ; emit_jump_insn ( gen_rtx_SET ( VOIDmode , pc_rtx , if_then_else ) ) ; emit_jump_insn ( gen_rtx_SET ( VOIDmode , pc_rtx , gen_rtx_LABEL_REF ( VOIDmode , label2 ) ) ) ; emit_barrier ( ) ; emit_label ( label1 ) ; emit_move_insn ( target , const1_rtx ) ; emit_label ( label2 ) ;


<s> case <NUM_LIT> : pat = GEN_FCN ( icode ) ( cmp_result , ops [ <NUM_LIT> ] , ops [ <NUM_LIT> ] , GEN_INT ( cond ) ) ; break ; case <NUM_LIT> : pat = GEN_FCN ( icode ) ( cmp_result , ops [ <NUM_LIT> ] , ops [ <NUM_LIT> ] , ops [ <NUM_LIT> ] , ops [ <NUM_LIT> ] , GEN_INT ( cond ) ) ; break ; default : gcc_unreachable ( ) ; } if ( builtin_type == MIPS_BUILTIN_CMP_ALL ) { cmp_value = - <NUM_LIT> ; target_if_equal = const1_rtx ; target_if_unequal = const0_rtx ; } else { cmp_value = <NUM_LIT> ; target_if_equal = const0_rtx ; target_if_unequal = const1_rtx ; if ( builtin_type == MIPS_BUILTIN_CMP_UPPER ) cmp_result = simplify_gen_subreg ( CCmode , cmp_result , CCV2mode , <NUM_LIT> ) ; else if ( builtin_type == MIPS_BUILTIN_CMP_LOWER ) cmp_result = simplify_gen_subreg ( CCmode , cmp_result , CCV2mode , <NUM_LIT> ) ; } emit_move_insn ( target , target_if_equal ) ; emit_insn ( pat ) ; label1 = gen_label_rtx ( ) ; label2 = gen_label_rtx ( ) ;

if_then_else = gen_rtx_IF_THEN_ELSE ( VOIDmode , gen_rtx_fmt_ee ( NE , GET_MODE ( cmp_result ) , cmp_result , GEN_INT ( cmp_value ) ) , gen_rtx_LABEL_REF ( VOIDmode , label1 ) , pc_rtx ) ;


<s> emit_insn ( GEN_FCN ( icode ) ( ops [ <NUM_LIT> ] , ops [ <NUM_LIT> ] , ops [ <NUM_LIT> ] ) ) ; break ; case <NUM_LIT> : emit_insn ( GEN_FCN ( icode ) ( ops [ <NUM_LIT> ] , ops [ <NUM_LIT> ] , ops [ <NUM_LIT> ] , ops [ <NUM_LIT> ] ) ) ; break ; default : gcc_unreachable ( ) ;


<s> } for ( ; i < insn_data [ icode ] . n_operands && arglist != <NUM_LIT> ; i ++ ) ops [ i ] = mips_prepare_builtin_arg ( icode , i , & arglist ) ; switch ( i ) { case <NUM_LIT> : emit_insn ( GEN_FCN ( icode ) ( ops [ <NUM_LIT> ] , ops [ <NUM_LIT> ] ) ) ; break ;


<s> static rtx mips_expand_builtin_movtf ( enum mips_builtin_type type , enum insn_code icode , enum mips_fp_condition cond , rtx target , tree arglist ) { rtx cmp_result , op0 , op1 ; cmp_result = mips_prepare_builtin_target ( icode , <NUM_LIT> , <NUM_LIT> ) ; op0 = mips_prepare_builtin_arg ( icode , <NUM_LIT> , & arglist ) ; op1 = mips_prepare_builtin_arg ( icode , <NUM_LIT> , & arglist ) ;

emit_insn ( GEN_FCN ( icode ) ( cmp_result , op0 , op1 , GEN_INT ( cond ) ) ) ;


<s> rtx reg1 , reg2 ; reg1 = XEXP ( XVECEXP ( result , <NUM_LIT> , <NUM_LIT> ) , <NUM_LIT> ) ; reg2 = XEXP ( XVECEXP ( result , <NUM_LIT> , <NUM_LIT> ) , <NUM_LIT> ) ; pattern = ( sibcall_p ? gen_sibcall_value_multiple_internal ( reg1 , addr , args_size , reg2 ) : gen_call_value_multiple_internal ( reg1 , addr , args_size , reg2 ) ) ; } else pattern = ( sibcall_p ? gen_sibcall_value_internal ( result , addr , args_size ) : gen_call_value_internal ( result , addr , args_size ) ) ;


<s> if ( ! SMALL_OPERAND ( step1 ) ) { emit_move_insn ( MIPS_EPILOGUE_TEMP ( Pmode ) , adjust ) ; adjust = MIPS_EPILOGUE_TEMP ( Pmode ) ; } if ( ! TARGET_MIPS16 ) target = stack_pointer_rtx ; emit_insn ( gen_add3_insn ( target , base , adjust ) ) ; } if ( target != stack_pointer_rtx ) emit_move_insn ( stack_pointer_rtx , target ) ; if ( TARGET_ABICALLS && TARGET_NEWABI && ! TARGET_EXPLICIT_RELOCS ) emit_insn ( gen_blockage ( ) ) ; mips_for_each_saved_reg ( cfun -> machine -> frame . total_size - step2 , mips_restore_reg ) ; if ( step2 > <NUM_LIT> ) emit_insn ( gen_add3_insn ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( step2 ) ) ) ; if ( current_function_calls_eh_return ) { if ( TARGET_MIPS16 ) { emit_move_insn ( MIPS_EPILOGUE_TEMP ( Pmode ) , stack_pointer_rtx ) ; emit_insn ( gen_add3_insn ( MIPS_EPILOGUE_TEMP ( Pmode ) , MIPS_EPILOGUE_TEMP ( Pmode ) , EH_RETURN_STACKADJ_RTX ) ) ; emit_move_insn ( stack_pointer_rtx , MIPS_EPILOGUE_TEMP ( Pmode ) ) ; }


<s> if ( cfun -> machine -> global_pointer > <NUM_LIT> ) REGNO ( pic_offset_table_rtx ) = cfun -> machine -> global_pointer ; size = compute_frame_size ( get_frame_size ( ) ) ; if ( ( cfun -> machine -> frame . mask | cfun -> machine -> frame . fmask ) != <NUM_LIT> ) { HOST_WIDE_INT step1 ; step1 = MIN ( size , MIPS_MAX_FIRST_STACK_STEP ) ; RTX_FRAME_RELATED_P ( emit_insn ( gen_add3_insn ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - step1 ) ) ) ) = <NUM_LIT> ; size -= step1 ; mips_for_each_saved_reg ( size , mips_save_reg ) ; } if ( size > <NUM_LIT> ) { if ( SMALL_OPERAND ( - size ) ) RTX_FRAME_RELATED_P ( emit_insn ( gen_add3_insn ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - size ) ) ) ) = <NUM_LIT> ; else { emit_move_insn ( MIPS_PROLOGUE_TEMP ( Pmode ) , GEN_INT ( size ) ) ; if ( TARGET_MIPS16 ) { gcc_assert ( frame_pointer_needed ) ; emit_move_insn ( hard_frame_pointer_rtx , stack_pointer_rtx ) ; emit_insn ( gen_sub3_insn ( hard_frame_pointer_rtx , hard_frame_pointer_rtx , MIPS_PROLOGUE_TEMP ( Pmode ) ) ) ; emit_move_insn ( stack_pointer_rtx , hard_frame_pointer_rtx ) ; } else emit_insn ( gen_sub3_insn ( stack_pointer_rtx , stack_pointer_rtx , MIPS_PROLOGUE_TEMP ( Pmode ) ) ) ; mips_set_frame_expr ( gen_rtx_SET ( VOIDmode , stack_pointer_rtx , plus_constant ( stack_pointer_rtx , - size ) ) ) ; } } if ( frame_pointer_needed ) { if ( TARGET_MIPS16 && cfun -> machine -> frame . args_size != <NUM_LIT> ) { rtx offset = GEN_INT ( cfun -> machine -> frame . args_size ) ; if ( SMALL_OPERAND ( cfun -> machine -> frame . args_size ) ) RTX_FRAME_RELATED_P ( emit_insn ( gen_add3_insn ( hard_frame_pointer_rtx , stack_pointer_rtx , offset ) ) ) = <NUM_LIT> ; else { emit_move_insn ( MIPS_PROLOGUE_TEMP ( Pmode ) , offset ) ; emit_move_insn ( hard_frame_pointer_rtx , stack_pointer_rtx ) ; emit_insn ( gen_add3_insn ( hard_frame_pointer_rtx , hard_frame_pointer_rtx , MIPS_PROLOGUE_TEMP ( Pmode ) ) ) ;

mips_set_frame_expr ( gen_rtx_SET ( VOIDmode , hard_frame_pointer_rtx , plus_constant ( stack_pointer_rtx , cfun -> machine -> frame . args_size ) ) ) ;


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


<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 ) ) ; } return true ;


<s> rtx left , right ; if ( ! mips_get_unaligned_mem ( & dest , width , bitpos , & left , & right ) ) return false ; src = gen_lowpart ( mode_for_size ( width , MODE_INT , <NUM_LIT> ) , src ) ; if ( GET_MODE ( src ) == 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 ) ) ;


<s> static void mips_file_end ( void ) { tree name_tree ; struct extern_list * p ; if ( extern_head ) { fputs ( <STR_LIT> , asm_out_file ) ; for ( p = extern_head ; p != <NUM_LIT> ; p = p -> next ) { name_tree = get_identifier ( p -> name ) ; if ( ! TREE_ASM_WRITTEN ( name_tree ) && TREE_SYMBOL_REFERENCED ( name_tree ) ) { TREE_ASM_WRITTEN ( name_tree ) = <NUM_LIT> ; if ( TARGET_IRIX && mips_abi == ABI_32 && p -> size == - <NUM_LIT> ) { fputs ( <STR_LIT> , asm_out_file ) ;

assemble_name ( asm_out_file , p -> name ) ;


<s> mips_save_restore_reg ( gpr_mode , regno , offset , fn ) ; offset -= GET_MODE_SIZE ( gpr_mode ) ; } offset = cfun -> machine -> frame . fp_sp_offset - sp_offset ; fpr_mode = ( TARGET_SINGLE_FLOAT ? SFmode : DFmode ) ; for ( regno = ( FP_REG_LAST - FP_INC + <NUM_LIT> ) ;


<s> static int mips_fpr_return_fields ( tree valtype , tree * fields ) { 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 = TREE_CHAIN ( field ) ) {

if ( TREE_CODE ( field ) != FIELD_DECL ) continue ;


<s> if ( REGNO ( reg ) == GP_REG_FIRST + <NUM_LIT> && DWARF_FRAME_RETURN_COLUMN != GP_REG_FIRST + <NUM_LIT> ) reg = gen_rtx_REG ( GET_MODE ( reg ) , DWARF_FRAME_RETURN_COLUMN ) ;

set = gen_rtx_SET ( VOIDmode , mem , reg ) ;


<s> static bool mips_function_has_gp_insn ( void ) { if ( ! cfun -> machine -> has_gp_insn_p ) { rtx insn ; push_topmost_sequence ( ) ; for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) if ( INSN_P ( insn ) && GET_CODE ( PATTERN ( insn ) ) != USE && GET_CODE ( PATTERN ( insn ) ) != CLOBBER && ( get_attr_got ( insn ) != GOT_UNSET || small_data_pattern ( PATTERN ( insn ) , VOIDmode ) ) ) break ; pop_topmost_sequence ( ) ; cfun -> machine -> has_gp_insn_p = ( insn != <NUM_LIT> ) ; }

return cfun -> machine -> has_gp_insn_p ;


<s> if ( ! cfun -> machine -> has_gp_insn_p ) { rtx insn ; push_topmost_sequence ( ) ;

for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) if ( INSN_P ( insn ) && GET_CODE ( PATTERN ( insn ) ) != USE && GET_CODE ( PATTERN ( insn ) ) != CLOBBER && ( get_attr_got ( insn ) != GOT_UNSET || small_data_pattern ( PATTERN ( insn ) , VOIDmode ) ) ) break ;


<s> static bool mips_function_ok_for_sibcall ( tree decl ATTRIBUTE_UNUSED , tree exp ATTRIBUTE_UNUSED ) {


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

named_section_flags ( rname , SECTION_WRITE ) ;


<s> 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> ) ; named_section_flags ( rname , SECTION_WRITE ) ; } else data_section ( ) ; } else data_section ( ) ;


<s> if ( size % UNITS_PER_WORD != <NUM_LIT> ) { size += UNITS_PER_WORD - size % UNITS_PER_WORD ; mode = mode_for_size ( size * BITS_PER_UNIT , MODE_INT , <NUM_LIT> ) ; } } if ( mips_abi != ABI_EABI && ! FLOAT_TYPE_P ( valtype ) ) return gen_rtx_REG ( mode , GP_RETURN ) ; } if ( ( GET_MODE_CLASS ( mode ) == MODE_FLOAT || GET_MODE_CLASS ( mode ) == MODE_VECTOR_FLOAT ) && GET_MODE_SIZE ( mode ) <= UNITS_PER_HWFPVALUE ) return gen_rtx_REG ( mode , FP_RETURN ) ; if ( mode == TFmode ) return mips_return_fpr_pair ( mode , DImode , <NUM_LIT> , DImode , GET_MODE_SIZE ( mode ) / <NUM_LIT> ) ; if ( GET_MODE_CLASS ( mode ) == MODE_COMPLEX_FLOAT && GET_MODE_SIZE ( mode ) <= UNITS_PER_HWFPVALUE * <NUM_LIT> ) return mips_return_fpr_pair ( mode , GET_MODE_INNER ( mode ) , <NUM_LIT> , GET_MODE_INNER ( mode ) , GET_MODE_SIZE ( mode ) / <NUM_LIT> ) ;


<s> enum rtx_code cmp_code = GET_CODE ( operands [ <NUM_LIT> ] ) ; enum machine_mode mode = GET_MODE ( cmp_operands [ <NUM_LIT> ] ) ; switch ( cmp_code ) { case GT : cmp_code = LT ; break ; case LE : cmp_code = GE ; break ; case GTU : cmp_code = LTU ; break ; case LEU : cmp_code = GEU ; break ; default : break ; } if ( cmp_code == GET_CODE ( operands [ <NUM_LIT> ] ) ) { op0 = cmp_operands [ <NUM_LIT> ] ; op1 = cmp_operands [ <NUM_LIT> ] ; } else {


<s> static bool mips_get_unaligned_mem ( rtx * op , unsigned int width , int bitpos , rtx * left , rtx * right ) { rtx first , last ; if ( ! MEM_P ( * op ) ) return false ; 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 ; * op = adjust_address ( * op , BLKmode , <NUM_LIT> ) ;

set_mem_size ( * op , GEN_INT ( width / BITS_PER_UNIT ) ) ;


<s> u = fold_convert ( TREE_TYPE ( t ) , build_int_cst ( NULL_TREE , rsize - size ) ) ; t = build ( PLUS_EXPR , TREE_TYPE ( t ) , t , u ) ; } COND_EXPR_THEN ( addr ) = t ; if ( osize > UNITS_PER_WORD ) { u = fold_convert ( TREE_TYPE ( ovfl ) , build_int_cst ( NULL_TREE , osize - <NUM_LIT> ) ) ; t = build ( PLUS_EXPR , TREE_TYPE ( ovfl ) , ovfl , u ) ; u = fold_convert ( TREE_TYPE ( ovfl ) , build_int_cst ( NULL_TREE , - osize ) ) ; t = build ( BIT_AND_EXPR , TREE_TYPE ( ovfl ) , t , u ) ; align = build ( MODIFY_EXPR , TREE_TYPE ( ovfl ) , ovfl , t ) ; } else align = NULL ; u = fold_convert ( TREE_TYPE ( ovfl ) , build_int_cst ( NULL_TREE , osize ) ) ; t = build ( POSTINCREMENT_EXPR , TREE_TYPE ( ovfl ) , ovfl , u ) ; if ( BYTES_BIG_ENDIAN && osize > size ) { u = fold_convert ( TREE_TYPE ( t ) , build_int_cst ( NULL_TREE , osize - size ) ) ; t = build ( PLUS_EXPR , TREE_TYPE ( t ) , t , u ) ; } if ( align ) t = build ( COMPOUND_EXPR , TREE_TYPE ( t ) , align , t ) ; COND_EXPR_ELSE ( addr ) = t ; addr = fold_convert ( build_pointer_type ( type ) , addr ) ; addr = build_va_arg_indirect_ref ( addr ) ; } if ( indirect ) addr = build_va_arg_indirect_ref ( addr ) ;


<s> if ( current_function_profile ) return GLOBAL_POINTER_REGNUM ; if ( current_function_has_nonlocal_goto ) return GLOBAL_POINTER_REGNUM ; if ( ! regs_ever_live [ GLOBAL_POINTER_REGNUM ] && ! current_function_uses_const_pool && ! mips_function_has_gp_insn ( ) ) return <NUM_LIT> ; if ( TARGET_NEWABI && current_function_is_leaf ) for ( regno = GP_REG_FIRST ; regno <= GP_REG_LAST ; regno ++ ) if ( ! regs_ever_live [ regno ] && call_used_regs [ regno ] && ! fixed_regs [ regno ] && regno != PIC_FUNCTION_ADDR_REGNUM ) return regno ; return GLOBAL_POINTER_REGNUM ;


<s> if ( ! regs_ever_live [ GLOBAL_POINTER_REGNUM ] && ! current_function_uses_const_pool && ! mips_function_has_gp_insn ( ) ) return <NUM_LIT> ; if ( TARGET_NEWABI && current_function_is_leaf ) for ( regno = GP_REG_FIRST ; regno <= GP_REG_LAST ; regno ++ ) if ( ! regs_ever_live [ regno ] && call_used_regs [ regno ] && ! fixed_regs [ regno ] && regno != PIC_FUNCTION_ADDR_REGNUM ) return regno ;


<s> switch ( code ) { case OPT_mabi_ : if ( strcmp ( arg , <STR_LIT> ) == <NUM_LIT> ) mips_abi = ABI_32 ; else if ( strcmp ( arg , <STR_LIT> ) == <NUM_LIT> ) mips_abi = ABI_O64 ;

else if ( strcmp ( arg , <STR_LIT> ) == <NUM_LIT> ) mips_abi = ABI_N32 ;


<s> else if ( strcmp ( arg , <STR_LIT> ) == <NUM_LIT> ) mips_abi = ABI_64 ; else if ( strcmp ( arg , <STR_LIT> ) == <NUM_LIT> ) mips_abi = ABI_EABI ; else return false ; return true ; case OPT_march_ : case OPT_mtune_ : return mips_parse_cpu ( arg ) != <NUM_LIT> ;


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


<s> if ( ST_REG_P ( regno ) ) return ( ( GET_MODE_SIZE ( mode ) + <NUM_LIT> ) / <NUM_LIT> ) ; else if ( ! FP_REG_P ( regno ) ) return ( ( GET_MODE_SIZE ( mode ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ) ; else return ( ( GET_MODE_SIZE ( mode ) + UNITS_PER_FPREG - <NUM_LIT> ) / UNITS_PER_FPREG ) ;


<s> HOST_WIDE_INT mips_initial_elimination_offset ( int from , int to ) { HOST_WIDE_INT offset ; compute_frame_size ( get_frame_size ( ) ) ; switch ( from ) { case FRAME_POINTER_REGNUM :


<s> case FRAME_POINTER_REGNUM : offset = <NUM_LIT> ; break ; case ARG_POINTER_REGNUM : offset = ( cfun -> machine -> frame . total_size - current_function_pretend_args_size ) ; break ; default : gcc_unreachable ( ) ; } if ( TARGET_MIPS16 && to == HARD_FRAME_POINTER_REGNUM ) offset -= cfun -> machine -> frame . args_size ;


<s> types [ MIPS_SI_FTYPE_V4QI ] = build_function_type_list ( intSI_type_node , V4QI_type_node , NULL_TREE ) ; types [ MIPS_V2HI_FTYPE_V2HI ] = build_function_type_list ( V2HI_type_node , V2HI_type_node , NULL_TREE ) ; types [ MIPS_SI_FTYPE_SI ] = build_function_type_list ( intSI_type_node , intSI_type_node , NULL_TREE ) ; types [ MIPS_V4QI_FTYPE_V2HI_V2HI ] = build_function_type_list ( V4QI_type_node , V2HI_type_node , V2HI_type_node , NULL_TREE ) ; types [ MIPS_V2HI_FTYPE_SI_SI ] = build_function_type_list ( V2HI_type_node , intSI_type_node , intSI_type_node , NULL_TREE ) ; types [ MIPS_SI_FTYPE_V2HI ] = build_function_type_list ( intSI_type_node , V2HI_type_node , NULL_TREE ) ; types [ MIPS_V2HI_FTYPE_V4QI ] = build_function_type_list ( V2HI_type_node , V4QI_type_node , NULL_TREE ) ; types [ MIPS_V4QI_FTYPE_V4QI_SI ] = build_function_type_list ( V4QI_type_node , V4QI_type_node , intSI_type_node , NULL_TREE ) ; types [ MIPS_V2HI_FTYPE_V2HI_SI ] = build_function_type_list ( V2HI_type_node , V2HI_type_node , intSI_type_node , NULL_TREE ) ; types [ MIPS_V2HI_FTYPE_V4QI_V2HI ] = build_function_type_list ( V2HI_type_node , V4QI_type_node , V2HI_type_node , NULL_TREE ) ; types [ MIPS_SI_FTYPE_V2HI_V2HI ] = build_function_type_list ( intSI_type_node , V2HI_type_node , V2HI_type_node , NULL_TREE ) ; types [ MIPS_DI_FTYPE_DI_V4QI_V4QI ] = build_function_type_list ( intDI_type_node , intDI_type_node , V4QI_type_node , V4QI_type_node , NULL_TREE ) ; types [ MIPS_DI_FTYPE_DI_V2HI_V2HI ] = build_function_type_list ( intDI_type_node , intDI_type_node , V2HI_type_node , V2HI_type_node , NULL_TREE ) ; types [ MIPS_DI_FTYPE_DI_SI_SI ] = build_function_type_list ( intDI_type_node , intDI_type_node , intSI_type_node , intSI_type_node , NULL_TREE ) ; types [ MIPS_V4QI_FTYPE_SI ] = build_function_type_list ( V4QI_type_node , intSI_type_node , NULL_TREE ) ; types [ MIPS_V2HI_FTYPE_SI ] = build_function_type_list ( V2HI_type_node , intSI_type_node , NULL_TREE ) ; types [ MIPS_VOID_FTYPE_V4QI_V4QI ] = build_function_type_list ( void_type_node , V4QI_type_node , V4QI_type_node , NULL_TREE ) ; types [ MIPS_SI_FTYPE_V4QI_V4QI ] = build_function_type_list ( intSI_type_node , V4QI_type_node , V4QI_type_node , NULL_TREE ) ; types [ MIPS_VOID_FTYPE_V2HI_V2HI ] = build_function_type_list ( void_type_node , V2HI_type_node , V2HI_type_node , NULL_TREE ) ; types [ MIPS_SI_FTYPE_DI_SI ] = build_function_type_list ( intSI_type_node , intDI_type_node , intSI_type_node , NULL_TREE ) ; types [ MIPS_DI_FTYPE_DI_SI ] = build_function_type_list ( intDI_type_node , intDI_type_node , intSI_type_node , NULL_TREE ) ; types [ MIPS_VOID_FTYPE_SI_SI ] = build_function_type_list ( void_type_node , intSI_type_node , intSI_type_node , NULL_TREE ) ; types [ MIPS_SI_FTYPE_PTR_SI ] = build_function_type_list ( intSI_type_node , ptr_type_node , intSI_type_node , NULL_TREE ) ; types [ MIPS_SI_FTYPE_VOID ] = build_function_type ( intSI_type_node , void_list_node ) ; } offset = <NUM_LIT> ; for ( m = bdesc_arrays ; m < & bdesc_arrays [ ARRAY_SIZE ( bdesc_arrays ) ] ; m ++ ) { if ( m -> proc == PROCESSOR_MAX || ( m -> proc == mips_arch ) ) for ( d = m -> bdesc ; d < & m -> bdesc [ m -> size ] ; d ++ ) if ( ( d -> target_flags & target_flags ) == d -> target_flags ) lang_hooks . builtin_function ( d -> name , types [ d -> function_type ] , d - m -> bdesc + offset , BUILT_IN_MD , NULL , NULL ) ; offset += m -> size ;


<s> set_optab_libfunc ( le_optab , SFmode , <STR_LIT> ) ; set_conv_libfunc ( sfix_optab , SImode , SFmode , <STR_LIT> ) ; set_conv_libfunc ( sfloat_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> ) ;


<s> set_conv_libfunc ( sfloat_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_conv_libfunc ( sext_optab , DFmode , SFmode , <STR_LIT> ) ; set_conv_libfunc ( trunc_optab , SFmode , DFmode , <STR_LIT> ) ; set_conv_libfunc ( sfix_optab , SImode , DFmode , <STR_LIT> ) ; set_conv_libfunc ( sfloat_optab , DFmode , SImode , <STR_LIT> ) ; } } else gofast_maybe_init_libfuncs ( ) ;


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


<s> name = TREE_STRING_POINTER ( DECL_SECTION_NAME ( decl ) ) ; if ( strcmp ( name , <STR_LIT> ) != <NUM_LIT> && strcmp ( name , <STR_LIT> ) != <NUM_LIT> ) return false ; if ( TARGET_EXPLICIT_RELOCS || ! DECL_EXTERNAL ( decl ) ) return true ; } 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 ;


<s> static int mips_issue_rate ( void ) { switch ( mips_tune ) { case PROCESSOR_R4130 : case PROCESSOR_R5400 : case PROCESSOR_R5500 : case PROCESSOR_R7000 : case PROCESSOR_R9000 :


<s> case PROCESSOR_R5500 : case PROCESSOR_R7000 : case PROCESSOR_R9000 : return <NUM_LIT> ;


<s> * xloc = mips_split_symbol ( <NUM_LIT> , * xloc ) ; return true ; } if ( GET_CODE ( * xloc ) == PLUS && GET_CODE ( XEXP ( * xloc , <NUM_LIT> ) ) == CONST_INT ) { rtx reg ;


<s> mips_split_const ( src , & base , & offset ) ; if ( ! TARGET_MIPS16 && offset != <NUM_LIT> && ( ! no_new_pseudos || SMALL_OPERAND ( offset ) ) ) { base = mips_force_temporary ( dest , base ) ; emit_move_insn ( dest , mips_add_offset ( <NUM_LIT> , base , offset ) ) ; return ; } src = force_const_mem ( mode , src ) ; if ( ! memory_operand ( src , VOIDmode ) ) src = replace_equiv_address ( src , mips_split_symbol ( dest , XEXP ( src , <NUM_LIT> ) ) ) ; emit_move_insn ( dest , src ) ;


<s> emit_insn ( gen_tls_get_tp_di ( v1 ) ) ; emit_insn ( gen_load_gotdi ( tmp1 , pic_offset_table_rtx , tmp2 ) ) ; } else { emit_insn ( gen_tls_get_tp_si ( v1 ) ) ; emit_insn ( gen_load_gotsi ( tmp1 , pic_offset_table_rtx , tmp2 ) ) ; } dest = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_add3_insn ( dest , tmp1 , v1 ) ) ; break ; case TLS_MODEL_LOCAL_EXEC : if ( Pmode == DImode ) emit_insn ( gen_tls_get_tp_di ( v1 ) ) ; else emit_insn ( gen_tls_get_tp_si ( v1 ) ) ; tmp1 = mips_unspec_offset_high ( NULL , v1 , loc , SYMBOL_TPREL ) ; dest = gen_rtx_LO_SUM ( Pmode , tmp1 , mips_unspec_address ( loc , SYMBOL_TPREL ) ) ; break ; default : gcc_unreachable ( ) ;


<s> 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 : 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 ) ; tmp2 = mips_unspec_offset_high ( NULL , tmp1 , loc , SYMBOL_DTPREL ) ; dest = gen_rtx_LO_SUM ( Pmode , tmp2 , mips_unspec_address ( loc , SYMBOL_DTPREL ) ) ; break ;


<s> bool mips_linked_madd_p ( rtx prev , rtx insn ) { rtx x ; x = single_set ( insn ) ; if ( x == <NUM_LIT> ) return false ; x = SET_SRC ( x ) ; if ( GET_CODE ( x ) == PLUS && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == MULT && reg_set_p ( XEXP ( x , <NUM_LIT> ) , prev ) ) return true ; if ( GET_CODE ( x ) == MINUS && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == MULT && reg_set_p ( XEXP ( x , <NUM_LIT> ) , prev ) ) return true ; return false ;


<s> static void mips_load_call_address ( rtx dest , rtx addr , int sibcall_p ) { if ( TARGET_EXPLICIT_RELOCS && ! ( sibcall_p && TARGET_NEWABI ) && global_got_operand ( addr , VOIDmode ) ) { rtx high , lo_sum_symbol ; high = mips_unspec_offset_high ( dest , pic_offset_table_rtx , addr , SYMBOL_GOTOFF_CALL ) ; lo_sum_symbol = mips_unspec_address ( addr , SYMBOL_GOTOFF_CALL ) ; if ( Pmode == SImode ) emit_insn ( gen_load_callsi ( dest , high , lo_sum_symbol ) ) ; else emit_insn ( gen_load_calldi ( dest , high , lo_sum_symbol ) ) ; } else emit_move_insn ( dest , addr ) ;


<s> static void mips_macc_chains_record ( rtx insn ) { if ( get_attr_may_clobber_hilo ( insn ) ) mips_macc_chains_last_hilo = insn ;


<s> if ( get_attr_may_clobber_hilo ( insn ) ) mips_macc_chains_last_hilo = insn ;


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


<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 ; } break ;


<s> if ( TOLOWER ( canonical [ <NUM_LIT> ] ) == 'v' && TOLOWER ( canonical [ <NUM_LIT> ] ) == 'r' ) canonical += <NUM_LIT> ; else if ( TOLOWER ( canonical [ <NUM_LIT> ] ) == 'r' && TOLOWER ( canonical [ <NUM_LIT> ] ) == 'm' ) canonical += <NUM_LIT> ;

else if ( TOLOWER ( canonical [ <NUM_LIT> ] ) == 'r' ) canonical += <NUM_LIT> ;


<s> static bool mips_matching_cpu_name_p ( const char * canonical , const char * given ) { if ( mips_strict_matching_cpu_name_p ( canonical , given ) ) return true ; if ( TOLOWER ( * given ) == 'r' ) given ++ ; if ( ! ISDIGIT ( * given ) ) return false ; if ( TOLOWER ( canonical [ <NUM_LIT> ] ) == 'v' && TOLOWER ( canonical [ <NUM_LIT> ] ) == 'r' ) canonical += <NUM_LIT> ;

else if ( TOLOWER ( canonical [ <NUM_LIT> ] ) == 'r' && TOLOWER ( canonical [ <NUM_LIT> ] ) == 'm' ) canonical += <NUM_LIT> ;


<s> x = GEN_INT ( codes [ <NUM_LIT> ] . value ) ; for ( i = <NUM_LIT> ; i < cost ; i ++ ) { if ( no_new_pseudos ) emit_move_insn ( dest , x ) , x = dest ;


<s> if ( mips_tune == PROCESSOR_SB1 ) return <NUM_LIT> ;


<s> last_assemble_variable_decl = decl ; ASM_DECLARE_OBJECT_NAME ( stream , name , decl ) ; ASM_OUTPUT_SKIP ( stream , size != <NUM_LIT> ? size : <NUM_LIT> ) ;


<s> void mips_output_aligned_bss ( FILE * stream , tree decl , const char * name , unsigned HOST_WIDE_INT size , int align ) { extern tree last_assemble_variable_decl ;

if ( mips_in_small_data_p ( decl ) ) named_section ( <NUM_LIT> , <STR_LIT> , <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 ) ; 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> int cur_pos = <NUM_LIT> ; register const unsigned char * string = ( const unsigned char * ) string_param ; fprintf ( stream , <STR_LIT> , prefix ) ; for ( i = <NUM_LIT> ; i < len ; i ++ ) { register int c = string [ i ] ; if ( ISPRINT ( c ) ) { if ( c == '\\' || c == '\"' ) { putc ( '\\' , stream ) ; cur_pos ++ ; } putc ( c , stream ) ; cur_pos ++ ; } else { fprintf ( stream , <STR_LIT> , c ) ; cur_pos += <NUM_LIT> ; } if ( cur_pos > <NUM_LIT> && i + <NUM_LIT> < len ) {


<s> code = NE ; break ; case LEU : code = EQ ; break ; case GEU : code = EQ ; op1 = <STR_LIT> ; break ; case LTU : code = NE ; op1 = <STR_LIT> ; break ; default : break ; } } need_z_p = ( ! float_p && code != EQ && code != NE ) ; if ( need_z_p ) op2 = <STR_LIT> ; buffer [ <NUM_LIT> ] = '\0' ; switch ( length ) { case <NUM_LIT> : case <NUM_LIT> : if ( float_p ) sprintf ( buffer , <STR_LIT> , inverted_p ? inverted_comp : comp ) ; else sprintf ( buffer , <STR_LIT> , inverted_p ? inverted_comp : comp , need_z_p ? <STR_LIT> : <STR_LIT> , op1 , op2 ) ; return buffer ; case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : { rtx orig_target ; rtx target = gen_label_rtx ( ) ; orig_target = operands [ <NUM_LIT> ] ; operands [ <NUM_LIT> ] = target ; if ( float_p ) sprintf ( buffer , <STR_LIT> , inverted_p ? comp : inverted_comp ) ; else sprintf ( buffer , <STR_LIT> , inverted_p ? comp : inverted_comp , need_z_p ? <STR_LIT> : <STR_LIT> , op1 , op2 ) ; output_asm_insn ( buffer , operands ) ; if ( length != <NUM_LIT> && length != <NUM_LIT> && ! mips_branch_likely ) { rtx insn = final_sequence ; final_scan_insn ( XVECEXP ( insn , <NUM_LIT> , <NUM_LIT> ) , asm_out_file , optimize , <NUM_LIT> , NULL ) ; INSN_DELETED_P ( XVECEXP ( insn , <NUM_LIT> , <NUM_LIT> ) ) = <NUM_LIT> ; } else output_asm_insn ( <STR_LIT> , <NUM_LIT> ) ; if ( length <= <NUM_LIT> ) output_asm_insn ( <STR_LIT> , & orig_target ) ; else { output_asm_insn ( mips_output_load_label ( ) , & orig_target ) ; output_asm_insn ( <STR_LIT> , <NUM_LIT> ) ; } if ( length != <NUM_LIT> && length != <NUM_LIT> && mips_branch_likely ) { rtx insn = final_sequence ; final_scan_insn ( XVECEXP ( insn , <NUM_LIT> , <NUM_LIT> ) , asm_out_file , optimize , <NUM_LIT> , NULL ) ; INSN_DELETED_P ( XVECEXP ( insn , <NUM_LIT> , <NUM_LIT> ) ) = <NUM_LIT> ; } else output_asm_insn ( <STR_LIT> , <NUM_LIT> ) ; ( * targetm . asm_out . internal_label ) ( asm_out_file , <STR_LIT> , CODE_LABEL_NUMBER ( target ) ) ; return <STR_LIT> ;


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

output_quoted_string ( stream , name ) ;


<s> } assemble_name ( file , fnname ) ; fputs ( <STR_LIT> , file ) ; } if ( TARGET_IRIX && mips_abi == ABI_32 ) TREE_ASM_WRITTEN ( DECL_NAME ( cfun -> decl ) ) = <NUM_LIT> ; if ( ! flag_inhibit_size_directive ) { fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , ( reg_names [ ( frame_pointer_needed ) ? HARD_FRAME_POINTER_REGNUM : STACK_POINTER_REGNUM ] ) , ( ( frame_pointer_needed && TARGET_MIPS16 ) ? tsize - cfun -> machine -> frame . args_size : tsize ) , reg_names [ GP_REG_FIRST + <NUM_LIT> ] , cfun -> machine -> frame . var_size , cfun -> machine -> frame . num_gp , cfun -> machine -> frame . num_fp , cfun -> machine -> frame . args_size , cfun -> machine -> frame . cprestore_size ) ; fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , cfun -> machine -> frame . mask , cfun -> machine -> frame . gp_save_offset ) ; fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , cfun -> machine -> frame . fmask , cfun -> machine -> frame . fp_save_offset ) ; } if ( TARGET_ABICALLS && ! TARGET_NEWABI && cfun -> machine -> global_pointer > <NUM_LIT> ) { if ( ! cfun -> machine -> all_noreorder_p ) output_asm_insn ( <STR_LIT> , <NUM_LIT> ) ; else output_asm_insn ( <STR_LIT> , <NUM_LIT> ) ; } else if ( cfun -> machine -> all_noreorder_p ) output_asm_insn ( <STR_LIT> , <NUM_LIT> ) ; mips_output_cplocal ( ) ;


<s> const char * fnname ; HOST_WIDE_INT tsize = cfun -> machine -> frame . total_size ; if ( debug_info_level != DINFO_LEVEL_TERSE && write_symbols == SDB_DEBUG ) SDB_OUTPUT_SOURCE_LINE ( file , DECL_SOURCE_LINE ( current_function_decl ) ) ; if ( TARGET_MIPS16 && ! TARGET_SOFT_FLOAT && current_function_args_info . fp_code != <NUM_LIT> ) build_mips16_function_stub ( file ) ; if ( ! FUNCTION_NAME_ALREADY_DECLARED ) { fnname = XSTR ( XEXP ( DECL_RTL ( current_function_decl ) , <NUM_LIT> ) , <NUM_LIT> ) ; if ( ! flag_inhibit_size_directive ) { fputs ( <STR_LIT> , file ) ; assemble_name ( file , fnname ) ; fputs ( <STR_LIT> , file ) ; }


<s> return <STR_LIT> ; default : if ( ISA_HAS_LOAD_DELAY ) return <STR_LIT> ; return <STR_LIT> ; } else { if ( Pmode == DImode ) return <STR_LIT> ; else return <STR_LIT> ;


<s> const char * mips_output_load_label ( void ) { if ( TARGET_EXPLICIT_RELOCS ) switch ( mips_abi ) { case ABI_N32 : return <STR_LIT> ; case ABI_64 : return <STR_LIT> ;


<s> else this = gen_rtx_REG ( Pmode , GP_ARG_FIRST ) ; if ( delta != <NUM_LIT> ) { rtx offset = GEN_INT ( delta ) ; if ( ! SMALL_OPERAND ( delta ) ) { emit_move_insn ( temp1 , offset ) ; offset = temp1 ; } emit_insn ( gen_add3_insn ( this , this , offset ) ) ; } if ( vcall_offset != <NUM_LIT> ) { rtx addr ; emit_move_insn ( temp1 , gen_rtx_MEM ( Pmode , this ) ) ; addr = mips_add_offset ( temp2 , temp1 , vcall_offset ) ; emit_move_insn ( temp1 , gen_rtx_MEM ( Pmode , addr ) ) ; emit_insn ( gen_add3_insn ( this , this , temp1 ) ) ; } fnaddr = XEXP ( DECL_RTL ( function ) , <NUM_LIT> ) ; if ( TARGET_MIPS16 || TARGET_ABICALLS || TARGET_LONG_CALLS ) { if ( TARGET_ABICALLS && ! mips_dangerous_for_la25_p ( fnaddr ) ) temp1 = gen_rtx_REG ( Pmode , PIC_FUNCTION_ADDR_REGNUM ) ;

mips_load_call_address ( temp1 , fnaddr , true ) ;


<s> if ( dest_code == REG && GP_REG_P ( REGNO ( dest ) ) ) { if ( src_code == REG ) { if ( DSP_ACC_REG_P ( REGNO ( src ) ) ) { static char retval [ ] = <STR_LIT> ; retval [ <NUM_LIT> ] = reg_names [ REGNO ( src ) ] [ <NUM_LIT> ] ; retval [ <NUM_LIT> ] = reg_names [ REGNO ( src ) ] [ <NUM_LIT> ] ; return retval ; } if ( ST_REG_P ( REGNO ( src ) ) && ISA_HAS_8CC ) return <STR_LIT> ; if ( FP_REG_P ( REGNO ( src ) ) ) return ( dbl_p ? <STR_LIT> : <STR_LIT> ) ; if ( ALL_COP_REG_P ( REGNO ( src ) ) ) { static char retval [ ] = <STR_LIT> ; retval [ <NUM_LIT> ] = COPNUM_AS_CHAR_FROM_REGNUM ( REGNO ( src ) ) ; return ( dbl_p ? retval : retval + <NUM_LIT> ) ; } } if ( src_code == MEM ) return ( dbl_p ? <STR_LIT> : <STR_LIT> ) ; if ( src_code == CONST_INT ) { if ( ! TARGET_MIPS16 ) return <STR_LIT> ; if ( INTVAL ( src ) >= <NUM_LIT> && INTVAL ( src ) <= <NUM_LIT> ) return <STR_LIT> ; if ( INTVAL ( src ) < <NUM_LIT> && INTVAL ( src ) >= - <NUM_LIT> ) return <STR_LIT> ; } if ( src_code == HIGH ) return <STR_LIT> ; if ( CONST_GP_P ( src ) ) return <STR_LIT> ;

if ( symbolic_operand ( src , VOIDmode ) ) return ( dbl_p ? <STR_LIT> : <STR_LIT> ) ;


<s> if ( type != <NUM_LIT> ? INTEGRAL_TYPE_P ( type ) || POINTER_TYPE_P ( type ) : GET_MODE_CLASS ( mode ) == MODE_INT ) return false ; if ( mips_abi == ABI_O64 ) if ( type != <NUM_LIT> ? FLOAT_TYPE_P ( type ) : GET_MODE_CLASS ( mode ) == MODE_FLOAT ) return false ;

if ( mips_abi != ABI_EABI ) return true ;


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

return mips_pad_arg_upward ( mode , type ) ;


<s> const struct mips_cpu_info * p ; const char * s ; for ( s = cpu_string ; * s != <NUM_LIT> ; s ++ ) if ( ISUPPER ( * s ) ) {


<s> for ( s = cpu_string ; * s != <NUM_LIT> ; s ++ ) if ( ISUPPER ( * s ) ) { warning ( <NUM_LIT> , <STR_LIT> ) ; break ; } if ( strcasecmp ( cpu_string , <STR_LIT> ) == <NUM_LIT> ) return mips_cpu_info_from_isa ( ABI_NEEDS_32BIT_REGS ? <NUM_LIT> : ABI_NEEDS_64BIT_REGS ? <NUM_LIT> : ( TARGET_64BIT ? <NUM_LIT> : <NUM_LIT> ) ) ;

if ( strcasecmp ( cpu_string , <STR_LIT> ) == <NUM_LIT> ) return <NUM_LIT> ;


<s> enum reg_class mips_preferred_reload_class ( rtx x , enum reg_class class ) { if ( mips_dangerous_for_la25_p ( x ) && reg_class_subset_p ( LEA_REGS , class ) ) return LEA_REGS ;

if ( TARGET_HARD_FLOAT && FLOAT_MODE_P ( GET_MODE ( x ) ) && reg_class_subset_p ( FP_REGS , class ) ) return FP_REGS ;


<s> enum reg_class mips_preferred_reload_class ( rtx x , enum reg_class class ) {

if ( mips_dangerous_for_la25_p ( x ) && reg_class_subset_p ( LEA_REGS , class ) ) return LEA_REGS ;


<s> if ( ! insn_data [ icode ] . operand [ op ] . predicate ( value , mode ) ) { value = copy_to_mode_reg ( mode , value ) ; if ( ! insn_data [ icode ] . operand [ op ] . predicate ( value , mode ) ) { error ( <STR_LIT> ) ; return const0_rtx ; }


<s> enum machine_mode mode ; mode = insn_data [ icode ] . operand [ op ] . mode ;

if ( target == <NUM_LIT> || ! insn_data [ icode ] . operand [ op ] . predicate ( target , mode ) ) target = gen_reg_rtx ( mode ) ;


<s> static rtx mips_prepare_builtin_target ( enum insn_code icode , unsigned int op , rtx target ) { enum machine_mode mode ; mode = insn_data [ icode ] . operand [ op ] . mode ;


<s> for ( i = lower ; i < higher ; i ++ ) ready [ i ] = ready [ i + <NUM_LIT> ] ;


<s> for ( i = lower ; i < higher ; i ++ ) ready [ i ] = ready [ i + <NUM_LIT> ] ; ready [ i ] = new_head ;


<s> if ( GR_REG_CLASS_P ( to ) ) return <NUM_LIT> ; else if ( to == FP_REGS ) return <NUM_LIT> ; else if ( to == ST_REGS ) return <NUM_LIT> ; } else if ( reg_class_subset_p ( from , ACC_REGS ) ) { if ( GR_REG_CLASS_P ( to ) ) { if ( TARGET_MIPS16 ) return <NUM_LIT> ; else return <NUM_LIT> ; } } else if ( from == ST_REGS && GR_REG_CLASS_P ( to ) ) return <NUM_LIT> ; else if ( COP_REG_CLASS_P ( from ) ) { return <NUM_LIT> ;


<s> case GTU : return reg_or_0_operand ( cmp1 , VOIDmode ) ; case GE : case GEU : return ! TARGET_MIPS16 && cmp1 == const1_rtx ; case LT :


<s> static void mips_reorg ( void ) { if ( TARGET_MIPS16 ) mips16_lay_out_constants ( ) ; else if ( TARGET_EXPLICIT_RELOCS ) { if ( mips_flag_delayed_branch ) dbr_schedule ( get_insns ( ) , dump_file ) ;


<s> if ( TARGET_MIPS16 && REGNO ( reg ) == GP_REG_FIRST + <NUM_LIT> ) reg = gen_rtx_REG ( GET_MODE ( reg ) , <NUM_LIT> ) ; if ( TARGET_MIPS16 && ! M16_REG_P ( REGNO ( reg ) ) ) { emit_move_insn ( MIPS_EPILOGUE_TEMP ( GET_MODE ( reg ) ) , mem ) ; emit_move_insn ( reg , MIPS_EPILOGUE_TEMP ( GET_MODE ( reg ) ) ) ; } else emit_move_insn ( reg , mem ) ;


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

return get_hard_reg_initial_val ( Pmode , GP_REG_FIRST + <NUM_LIT> ) ;


<s> return gen_rtx_PARALLEL ( mode , gen_rtvec ( <NUM_LIT> , gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( mode1 , FP_RETURN ) , GEN_INT ( offset1 ) ) , gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_REG ( mode2 , FP_RETURN + inc ) , GEN_INT ( offset2 ) ) ) ) ;


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

else return ( ( int_size_in_bytes ( type ) > ( <NUM_LIT> * UNITS_PER_WORD ) ) || ( int_size_in_bytes ( type ) == - <NUM_LIT> ) ) ;


<s> static bool mips_return_in_memory ( tree type , tree fndecl ATTRIBUTE_UNUSED ) { if ( TARGET_OLDABI ) return ( TYPE_MODE ( type ) == BLKmode ) ; else return ( ( int_size_in_bytes ( type ) > ( <NUM_LIT> * UNITS_PER_WORD ) ) || ( int_size_in_bytes ( type ) == - <NUM_LIT> ) ) ;


<s> static bool mips_return_in_msb ( tree valtype ) { tree fields [ <NUM_LIT> ] ; return ( TARGET_NEWABI && TARGET_BIG_ENDIAN && AGGREGATE_TYPE_P ( valtype ) && mips_fpr_return_fields ( valtype , fields ) == <NUM_LIT> ) ;


return ( TARGET_NEWABI && TARGET_BIG_ENDIAN && AGGREGATE_TYPE_P ( valtype ) && mips_fpr_return_fields ( valtype , fields ) == <NUM_LIT> ) ;


<s> op = copy_insn ( op ) ; for_each_rtx ( & op , mips_rewrite_small_data_1 , <NUM_LIT> ) ;


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


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


<s> rtx x1 , x2 ; if ( mips_split_64bit_move_p ( mem , reg ) ) mips_split_64bit_move ( mem , reg ) ; else emit_move_insn ( mem , reg ) ; x1 = mips_frame_set ( mips_subword ( mem , <NUM_LIT> ) , mips_subword ( reg , <NUM_LIT> ) ) ; x2 = mips_frame_set ( mips_subword ( mem , <NUM_LIT> ) , mips_subword ( reg , <NUM_LIT> ) ) ; mips_set_frame_expr ( gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , x1 , x2 ) ) ) ;


<s> if ( regno == GP_REG_FIRST + <NUM_LIT> && regs_ever_live [ regno ] ) return true ; if ( TARGET_MIPS16 ) { tree return_type ; return_type = DECL_RESULT ( current_function_decl ) ; if ( regno == GP_REG_FIRST + <NUM_LIT> && regs_ever_live [ regno ] ) return true ; if ( regno == GP_REG_FIRST + <NUM_LIT> && mips16_hard_float && ! aggregate_value_p ( return_type , current_function_decl ) && GET_MODE_CLASS ( DECL_MODE ( return_type ) ) == MODE_FLOAT && GET_MODE_SIZE ( DECL_MODE ( return_type ) ) <= UNITS_PER_FPVALUE ) return true ; }


<s> tree return_type ; return_type = DECL_RESULT ( current_function_decl ) ; if ( regno == GP_REG_FIRST + <NUM_LIT> && regs_ever_live [ regno ] ) return true ; if ( regno == GP_REG_FIRST + <NUM_LIT> && mips16_hard_float && ! aggregate_value_p ( return_type , current_function_decl ) && GET_MODE_CLASS ( DECL_MODE ( return_type ) ) == MODE_FLOAT && GET_MODE_SIZE ( DECL_MODE ( return_type ) ) <= UNITS_PER_FPVALUE ) return true ; } return false ;


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


<s> rtx mem ; mem = gen_rtx_MEM ( mode , plus_constant ( stack_pointer_rtx , offset ) ) ;

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


<s> else if ( TARGET_EMBEDDED_DATA ) { mergeable_constant_section ( mode , align , <NUM_LIT> ) ; } else {

if ( GET_MODE_SIZE ( mode ) <= ( unsigned ) mips_section_threshold && mips_section_threshold > <NUM_LIT> ) named_section ( <NUM_LIT> , <STR_LIT> , <NUM_LIT> ) ;


<s> else if ( TARGET_EMBEDDED_DATA ) { mergeable_constant_section ( mode , align , <NUM_LIT> ) ; } else { if ( GET_MODE_SIZE ( mode ) <= ( unsigned ) mips_section_threshold && mips_section_threshold > <NUM_LIT> ) named_section ( <NUM_LIT> , <STR_LIT> , <NUM_LIT> ) ;

else if ( flag_pic && symbolic_expression_p ( x ) ) named_section ( <NUM_LIT> , <STR_LIT> , <NUM_LIT> ) ;