<s> if ( mips16_local_function_p ( fn ) ) { * fn_ptr = mips16_local_alias ( fn ) ; return NULL ; } if ( fp_ret_p ) sprintf ( buf , <STR_LIT> , mips16_call_stub_mode_suffix ( GET_MODE ( retval ) ) , fp_code ) ; else sprintf ( buf , <STR_LIT> , fp_code ) ; stub_fn = mips16_stub_function ( buf ) ; SYMBOL_REF_FLAGS ( stub_fn ) |= SYMBOL_FLAG_BIND_NOW ; addr = gen_rtx_REG ( Pmode , GP_REG_FIRST + <NUM_LIT> ) ; lazy_p = mips_load_call_address ( MIPS_CALL_NORMAL , addr , fn ) ; insn = mips_expand_call ( MIPS_CALL_NORMAL , retval , stub_fn , args_size , NULL_RTX , lazy_p ) ; use_reg ( & CALL_INSN_FUNCTION_USAGE ( insn ) , addr ) ; if ( fp_ret_p ) CALL_INSN_FUNCTION_USAGE ( insn ) = gen_rtx_EXPR_LIST ( VOIDmode , gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( word_mode , <NUM_LIT> ) ) , CALL_INSN_FUNCTION_USAGE ( insn ) ) ; return insn ; } fnname = targetm . strip_name_encoding ( XSTR ( fn , <NUM_LIT> ) ) ; for ( l = mips16_stubs ; l != NULL ; l = l -> next ) if ( strcmp ( l -> name , fnname ) == <NUM_LIT> ) break ; if ( l == NULL ) { const char * separator ; char * secname , * stubname ; tree stubid , stubdecl ; unsigned int f ; secname = ACONCAT ( ( <STR_LIT> , fp_ret_p ? <STR_LIT> : <STR_LIT> , fnname , NULL ) ) ; stubname = ACONCAT ( ( <STR_LIT> , fp_ret_p ? <STR_LIT> : <STR_LIT> , fnname , NULL ) ) ; stubid = get_identifier ( stubname ) ; stubdecl = build_decl ( BUILTINS_LOCATION , FUNCTION_DECL , stubid , build_function_type_list ( void_type_node , NULL_TREE ) ) ; set_decl_section_name ( stubdecl , secname ) ; DECL_RESULT ( stubdecl ) = build_decl ( BUILTINS_LOCATION , RESULT_DECL , NULL_TREE , void_type_node ) ; fprintf ( asm_out_file , <STR_LIT> , ( fp_ret_p ? ( GET_MODE ( retval ) == SFmode ? <STR_LIT> : <STR_LIT> ) : <STR_LIT> ) , fnname ) ; separator = <STR_LIT> ; for ( f = ( unsigned int ) fp_code ; f != <NUM_LIT> ; f >>= <NUM_LIT> ) { fprintf ( asm_out_file , <STR_LIT> , separator , ( f & <NUM_LIT> ) == <NUM_LIT> ? <STR_LIT> : <STR_LIT> ) ; separator = <STR_LIT> ; } fprintf ( asm_out_file , <STR_LIT> ) ; assemble_start_function ( stubdecl , stubname ) ; mips_start_function_definition ( stubname , false ) ; if ( fp_ret_p ) { fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> , reg_names [ GP_REG_FIRST + <NUM_LIT> ] , reg_names [ RETURN_ADDR_REGNUM ] ) ; } else { if ( TARGET_EXPLICIT_RELOCS ) { output_asm_insn ( <STR_LIT> , & fn ) ; output_asm_insn ( <STR_LIT> , & fn ) ; } else output_asm_insn ( <STR_LIT> , & fn ) ;


<s> 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 if ( * fs_delay && get_attr_can_delay ( insn ) == CAN_DELAY_NO && GET_CODE ( PATTERN ( after ) ) != SEQUENCE && GET_CODE ( pattern ) != ASM_INPUT && asm_noperands ( pattern ) < <NUM_LIT> ) nops = <NUM_LIT> ; else nops = <NUM_LIT> ; * hilo_delay += nops ; while ( nops -- > <NUM_LIT> ) emit_insn_after ( gen_hazard_nop ( ) , after ) ;


<s> rtx pattern , set ; int nops , ninsns ; pattern = PATTERN ( insn ) ; 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 if ( * fs_delay && get_attr_can_delay ( insn ) == CAN_DELAY_NO && GET_CODE ( PATTERN ( after ) ) != SEQUENCE && GET_CODE ( pattern ) != ASM_INPUT && asm_noperands ( pattern ) < <NUM_LIT> ) nops = <NUM_LIT> ;


<s> mode = mode_for_size ( bits , MODE_INT , <NUM_LIT> ) ; delta = bits / BITS_PER_UNIT ; regs = XALLOCAVEC ( 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 ) mips_emit_move ( regs [ i ] , adjust_address ( src , mode , offset ) ) ; else { rtx part = adjust_address ( src , BLKmode , offset ) ; set_mem_size ( part , delta ) ; if ( ! mips_expand_ext_as_unaligned_load ( regs [ i ] , part , bits , <NUM_LIT> , <NUM_LIT> ) ) gcc_unreachable ( ) ; } } for ( offset = <NUM_LIT> , i = <NUM_LIT> ; offset + delta <= length ; offset += delta , i ++ ) if ( MEM_ALIGN ( dest ) >= bits ) mips_emit_move ( adjust_address ( dest , mode , offset ) , regs [ i ] ) ; else { rtx part = adjust_address ( dest , BLKmode , offset ) ; set_mem_size ( part , delta ) ; if ( ! mips_expand_ins_as_unaligned_store ( part , regs [ i ] , bits , <NUM_LIT> ) ) gcc_unreachable ( ) ;


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

use_reg ( & CALL_INSN_FUNCTION_USAGE ( insn ) , a0 ) ;


<s> if ( TARGET_MIPS16 ) sorry ( <STR_LIT> ) ; if ( first + size <= <NUM_LIT> ) { HOST_WIDE_INT i ; for ( i = PROBE_INTERVAL ; i < size ; i += PROBE_INTERVAL ) emit_stack_probe ( plus_constant ( Pmode , stack_pointer_rtx , - ( first + i ) ) ) ; emit_stack_probe ( plus_constant ( Pmode , stack_pointer_rtx , - ( first + size ) ) ) ; } else { HOST_WIDE_INT rounded_size ; rtx r3 = MIPS_PROLOGUE_TEMP ( Pmode ) ; rtx r12 = MIPS_PROLOGUE_TEMP2 ( Pmode ) ; gcc_assert ( first <= <NUM_LIT> ) ; rounded_size = ROUND_DOWN ( size , PROBE_INTERVAL ) ; emit_insn ( gen_rtx_SET ( r3 , plus_constant ( Pmode , stack_pointer_rtx , - first ) ) ) ; if ( rounded_size > <NUM_LIT> ) { emit_move_insn ( r12 , GEN_INT ( rounded_size ) ) ; emit_insn ( gen_rtx_SET ( r12 , gen_rtx_MINUS ( Pmode , r3 , r12 ) ) ) ; } else emit_insn ( gen_rtx_SET ( r12 , plus_constant ( Pmode , r3 , - rounded_size ) ) ) ; emit_insn ( PMODE_INSN ( gen_probe_stack_range , ( r3 , r3 , r12 ) ) ) ; if ( size != rounded_size ) emit_stack_probe ( plus_constant ( Pmode , r12 , rounded_size - size ) ) ; } emit_insn ( gen_blockage ( ) ) ;


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

emit_insn ( gen_rtx_SET ( r3 , plus_constant ( Pmode , stack_pointer_rtx , - first ) ) ) ;


<s> return ; } if ( nelt == <NUM_LIT> ) { rtx op0 = force_reg ( imode , XVECEXP ( vals , <NUM_LIT> , <NUM_LIT> ) ) ; rtx op1 = force_reg ( imode , XVECEXP ( vals , <NUM_LIT> , <NUM_LIT> ) ) ; x = gen_rtx_VEC_CONCAT ( vmode , op0 , op1 ) ; emit_insn ( gen_rtx_SET ( target , x ) ) ; return ; } gcc_assert ( TARGET_HARD_FLOAT && TARGET_LOONGSON_VECTORS ) ; if ( all_same ) { mips_expand_vi_broadcast ( vmode , target , XVECEXP ( vals , <NUM_LIT> , <NUM_LIT> ) ) ; return ; } if ( nvar == <NUM_LIT> && vmode == V4HImode ) { mips_expand_vi_loongson_one_pinsrh ( target , vals , one_var ) ; return ; } mips_expand_vi_general ( vmode , imode , nelt , nvar , target , vals ) ;


<s> if ( d -> one_vector_p ) emit_insn ( gen_loongson_pshufh ( d -> target , d -> op0 , rmask ) ) ; else { rtx t0 , t1 , x , merge , rmerge [ <NUM_LIT> ] ; t0 = gen_reg_rtx ( V4HImode ) ; t1 = gen_reg_rtx ( V4HImode ) ; emit_insn ( gen_loongson_pshufh ( t1 , d -> op1 , rmask ) ) ; emit_insn ( gen_loongson_pshufh ( t0 , d -> op0 , rmask ) ) ;

for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) rmerge [ i ] = ( d -> perm [ i ] & <NUM_LIT> ? constm1_rtx : const0_rtx ) ;


<s> emit_insn ( gen_loongson_pshufh ( t1 , d -> op1 , rmask ) ) ; emit_insn ( gen_loongson_pshufh ( t0 , d -> op0 , rmask ) ) ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; ++ i ) rmerge [ i ] = ( d -> perm [ i ] & <NUM_LIT> ? constm1_rtx : const0_rtx ) ; merge = gen_rtx_CONST_VECTOR ( V4HImode , gen_rtvec_v ( <NUM_LIT> , rmerge ) ) ; merge = force_reg ( V4HImode , merge ) ; x = gen_rtx_AND ( V4HImode , merge , t1 ) ; emit_insn ( gen_rtx_SET ( t1 , x ) ) ; x = gen_rtx_NOT ( V4HImode , merge ) ; x = gen_rtx_AND ( V4HImode , x , t0 ) ; emit_insn ( gen_rtx_SET ( t0 , x ) ) ; x = gen_rtx_IOR ( V4HImode , t0 , t1 ) ; emit_insn ( gen_rtx_SET ( d -> target , x ) ) ; } return true ;


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


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


<s> if ( GP_REG_P ( regno ) && cfun -> machine -> use_shadow_register_set == SHADOW_SET_NO ) { if ( regno == GP_REG_FIRST ) return false ; if ( KERNEL_REG_P ( regno ) ) return false ; if ( regno == STACK_POINTER_REGNUM ) return false ; return call_really_used_regs [ regno ] ;


<s> return <NUM_LIT> ; case PROCESSOR_SB1 : case PROCESSOR_SB1A : return <NUM_LIT> ; case PROCESSOR_LOONGSON_2E : case PROCESSOR_LOONGSON_2F : case PROCESSOR_LOONGSON_3A : case PROCESSOR_P5600 : return <NUM_LIT> ; case PROCESSOR_XLP : return ( reload_completed ? <NUM_LIT> : <NUM_LIT> ) ;


<s> static int mips_issue_rate ( void ) { switch ( mips_tune ) { case PROCESSOR_74KC : case PROCESSOR_74KF2_1 : case PROCESSOR_74KF1_1 : case PROCESSOR_74KF3_2 : case PROCESSOR_R10000 : return <NUM_LIT> ; case PROCESSOR_20KC : case PROCESSOR_R4130 : case PROCESSOR_R5400 : case PROCESSOR_R5500 : case PROCESSOR_R5900 : case PROCESSOR_R7000 : case PROCESSOR_R9000 : case PROCESSOR_OCTEON : case PROCESSOR_OCTEON2 : case PROCESSOR_OCTEON3 : case PROCESSOR_I6400 : return <NUM_LIT> ; case PROCESSOR_SB1 : case PROCESSOR_SB1A : return <NUM_LIT> ; case PROCESSOR_LOONGSON_2E : case PROCESSOR_LOONGSON_2F : case PROCESSOR_LOONGSON_3A :


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

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


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


<s> const char * insn_name = TARGET_CB_NEVER || reg_p ? <STR_LIT> : <STR_LIT> ; if ( ! final_sequence && ( TARGET_CB_MAYBE || ( ISA_HAS_JRC && ! link_p && reg_p ) ) ) { compact = <STR_LIT> ; nop = <STR_LIT> ; } if ( TARGET_USE_GOT && ! TARGET_EXPLICIT_RELOCS ) sprintf ( s , <STR_LIT> , insn_name , and_link , target_opno ) ; else { if ( ! reg_p && TARGET_ABICALLS_PIC2 ) s += sprintf ( s , <STR_LIT> ) ; if ( reg_p && mips_get_pic_call_symbol ( operands , size_opno ) ) { s += sprintf ( s , <STR_LIT> , size_opno ) ;


<s> const char * mips_output_jump ( rtx * operands , int target_opno , int size_opno , bool link_p ) { static char buffer [ <NUM_LIT> ] ; char * s = buffer ; bool reg_p = REG_P ( operands [ target_opno ] ) ; const char * and_link = link_p ? <STR_LIT> : <STR_LIT> ; const char * reg = reg_p ? <STR_LIT> : <STR_LIT> ; const char * compact = <STR_LIT> ; const char * nop = <STR_LIT> ; const char * short_delay = link_p ? <STR_LIT> : <STR_LIT> ; const char * insn_name = TARGET_CB_NEVER || reg_p ? <STR_LIT> : <STR_LIT> ; if ( ! final_sequence && ( TARGET_CB_MAYBE || ( ISA_HAS_JRC && ! link_p && reg_p ) ) ) { compact = <STR_LIT> ; nop = <STR_LIT> ; } if ( TARGET_USE_GOT && ! TARGET_EXPLICIT_RELOCS ) sprintf ( s , <STR_LIT> , insn_name , and_link , target_opno ) ; else { if ( ! reg_p && TARGET_ABICALLS_PIC2 ) s += sprintf ( s , <STR_LIT> ) ; if ( reg_p && mips_get_pic_call_symbol ( operands , size_opno ) ) { s += sprintf ( s , <STR_LIT> , size_opno ) ; short_delay = <STR_LIT> ; } else s += sprintf ( s , <STR_LIT> ) ; s += sprintf ( s , <STR_LIT> , insn_name , and_link , reg , compact , short_delay , target_opno , nop ) ;


<s> fputc ( <STR_LIT> [ truth * <NUM_LIT> + ST_REG_P ( REGNO ( XEXP ( op , <NUM_LIT> ) ) ) ] , file ) ; } break ; case 'Y' : if ( code == CONST_INT && UINTVAL ( op ) < ARRAY_SIZE ( mips_fp_conditions ) ) fputs ( mips_fp_conditions [ UINTVAL ( op ) ] , file ) ; else output_operand_lossage ( <STR_LIT> , letter ) ; break ; case 'Z' : if ( ISA_HAS_8CC || ISA_HAS_CCF ) { mips_print_operand ( file , op , <NUM_LIT> ) ; fputc ( ',' , file ) ; } break ; case 'q' : if ( code == REG && MD_REG_P ( REGNO ( op ) ) ) fprintf ( file , <STR_LIT> ) ; else if ( code == REG && DSP_ACC_REG_P ( REGNO ( op ) ) ) fprintf ( file , <STR_LIT> , reg_names [ REGNO ( op ) ] [ <NUM_LIT> ] ) ; else output_operand_lossage ( <STR_LIT> , letter ) ; break ; default : switch ( code ) { case REG : { unsigned int regno = REGNO ( op ) ; if ( ( letter == 'M' && TARGET_LITTLE_ENDIAN ) || ( letter == 'L' && TARGET_BIG_ENDIAN ) || letter == 'D' ) regno ++ ; else if ( letter && letter != 'z' && letter != 'M' && letter != 'L' ) output_operand_lossage ( <STR_LIT> , letter ) ; if ( COP0_REG_P ( regno ) ) fprintf ( file , <STR_LIT> , & reg_names [ regno ] [ <NUM_LIT> ] ) ; else fprintf ( file , <STR_LIT> , reg_names [ regno ] ) ; } break ; case MEM :

if ( letter == 'D' ) output_address ( GET_MODE ( op ) , plus_constant ( Pmode , XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) ;


<s> case 't' : { int truth = ( code == NE ) == ( letter == 'T' ) ; fputc ( <STR_LIT> [ truth * <NUM_LIT> + ST_REG_P ( REGNO ( XEXP ( op , <NUM_LIT> ) ) ) ] , file ) ; } break ; case 'Y' : if ( code == CONST_INT && UINTVAL ( op ) < ARRAY_SIZE ( mips_fp_conditions ) ) fputs ( mips_fp_conditions [ UINTVAL ( op ) ] , file ) ; else output_operand_lossage ( <STR_LIT> , letter ) ; break ; case 'Z' : if ( ISA_HAS_8CC || ISA_HAS_CCF ) { mips_print_operand ( file , op , <NUM_LIT> ) ; fputc ( ',' , file ) ; } break ; case 'q' : if ( code == REG && MD_REG_P ( REGNO ( op ) ) ) fprintf ( file , <STR_LIT> ) ; else if ( code == REG && DSP_ACC_REG_P ( REGNO ( op ) ) ) fprintf ( file , <STR_LIT> , reg_names [ REGNO ( op ) ] [ <NUM_LIT> ] ) ; else output_operand_lossage ( <STR_LIT> , letter ) ; break ; default : switch ( code ) { case REG : { unsigned int regno = REGNO ( op ) ; if ( ( letter == 'M' && TARGET_LITTLE_ENDIAN ) || ( letter == 'L' && TARGET_BIG_ENDIAN ) || letter == 'D' ) regno ++ ; else if ( letter && letter != 'z' && letter != 'M' && letter != 'L' ) output_operand_lossage ( <STR_LIT> , letter ) ; if ( COP0_REG_P ( regno ) ) fprintf ( file , <STR_LIT> , & reg_names [ regno ] [ <NUM_LIT> ] ) ; else fprintf ( file , <STR_LIT> , reg_names [ regno ] ) ; } break ; case MEM : if ( letter == 'D' ) output_address ( GET_MODE ( op ) , plus_constant ( Pmode , XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) ; else if ( letter == 'b' ) { gcc_assert ( REG_P ( XEXP ( op , <NUM_LIT> ) ) ) ; mips_print_operand ( file , XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ; } else if ( letter && letter != 'z' ) output_operand_lossage ( <STR_LIT> , letter ) ; else output_address ( GET_MODE ( op ) , XEXP ( op , <NUM_LIT> ) ) ; break ; default : if ( letter == 'z' && op == CONST0_RTX ( GET_MODE ( op ) ) ) fputs ( reg_names [ GP_REG_FIRST ] , file ) ; else if ( letter && letter != 'z' ) output_operand_lossage ( <STR_LIT> , letter ) ; else if ( CONST_GP_P ( op ) ) fputs ( reg_names [ GLOBAL_POINTER_REGNUM ] , file ) ; else output_addr_const ( file , mips_strip_unspec_address ( op ) ) ; break ; }


<s> lo_reg = gen_rtx_REG ( SImode , LO_REGNUM ) ; fs_delay = false ; for ( insn = get_insns ( ) ; insn != <NUM_LIT> ; insn = next_insn ) { next_insn = NEXT_INSN ( insn ) ; if ( USEFUL_INSN_P ( insn ) ) { if ( GET_CODE ( PATTERN ( insn ) ) == SEQUENCE ) { rtx_insn * next_active = next_active_insn ( insn ) ; if ( TARGET_CB_MAYBE && mips_breakable_sequence_p ( insn ) && INSN_P ( SEQ_BEGIN ( insn ) ) && INSN_P ( SEQ_END ( insn ) ) && ( ( next_active && INSN_P ( next_active ) && GET_CODE ( PATTERN ( next_active ) ) != SEQUENCE && get_attr_can_delay ( next_active ) == CAN_DELAY_YES ) || ! optimize_size ) ) { HARD_REG_SET uses ; CLEAR_HARD_REG_SET ( uses ) ; note_uses ( & PATTERN ( SEQ_BEGIN ( insn ) ) , record_hard_reg_uses , & uses ) ; HARD_REG_SET delay_sets ; CLEAR_HARD_REG_SET ( delay_sets ) ; note_stores ( PATTERN ( SEQ_END ( insn ) ) , record_hard_reg_sets , & delay_sets ) ; rtx_insn * prev = prev_active_insn ( insn ) ; if ( prev && GET_CODE ( PATTERN ( prev ) ) == SET && MEM_P ( SET_SRC ( PATTERN ( prev ) ) ) ) { HARD_REG_SET sets ; CLEAR_HARD_REG_SET ( sets ) ; note_stores ( PATTERN ( prev ) , record_hard_reg_sets , & sets ) ; if ( ! hard_reg_set_intersect_p ( delay_sets , uses ) && hard_reg_set_intersect_p ( uses , sets ) ) { next_insn = mips_break_sequence ( insn ) ; continue ; } } if ( mips_orphaned_high_part_p ( & htab , SEQ_END ( insn ) ) ) { next_insn = mips_break_sequence ( insn ) ; continue ; } } FOR_EACH_SUBINSN ( subinsn , insn ) if ( INSN_P ( subinsn ) ) { if ( mips_orphaned_high_part_p ( & htab , subinsn ) ) { PATTERN ( subinsn ) = gen_nop ( ) ; INSN_CODE ( subinsn ) = CODE_FOR_nop ; } mips_avoid_hazard ( last_insn , subinsn , & hilo_delay , & delayed_reg , lo_reg , & fs_delay ) ; } last_insn = insn ; } else { if ( mips_orphaned_high_part_p ( & htab , insn ) ) delete_insn ( insn ) ; else if ( recog_memoized ( insn ) == CODE_FOR_r10k_cache_barrier && last_insn && JUMP_P ( SEQ_BEGIN ( last_insn ) ) && INSN_ANNULLED_BRANCH_P ( SEQ_BEGIN ( last_insn ) ) ) delete_insn ( insn ) ; else { mips_avoid_hazard ( last_insn , insn , & hilo_delay , & delayed_reg , lo_reg , & fs_delay ) ; if ( fs_delay ) { rtx_insn * next = next_active_insn ( insn ) ; if ( next && USEFUL_INSN_P ( next ) && GET_CODE ( PATTERN ( next ) ) == SEQUENCE && mips_breakable_sequence_p ( next ) ) { last_insn = insn ; next_insn = mips_break_sequence ( next ) ; continue ; }


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


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


<s> target_flags |= MASK_EXPLICIT_RELOCS ; targetm . min_anchor_offset = <NUM_LIT> ; targetm . max_anchor_offset = <NUM_LIT> ; targetm . const_anchor = <NUM_LIT> ; target_flags &= ~ MASK_RELAX_PIC_CALLS ; target_flags &= ~ MASK_FIX_R4000 ; if ( flag_pic && ! TARGET_OLDABI ) sorry ( <STR_LIT> ) ; if ( TARGET_XGOT ) sorry ( <STR_LIT> ) ; if ( TARGET_HARD_FLOAT_ABI && ! TARGET_OLDABI ) sorry ( <STR_LIT> ) ; } else { if ( TARGET_MICROMIPS ) target_flags &= ~ MASK_BRANCHLIKELY ; if ( TARGET_64BIT ) { if ( align_loops == <NUM_LIT> ) align_loops = <NUM_LIT> ; if ( align_jumps == <NUM_LIT> ) align_jumps = <NUM_LIT> ; if ( align_functions == <NUM_LIT> ) align_functions = <NUM_LIT> ; }

targetm . min_anchor_offset = - <NUM_LIT> ;


inner = get_inner_reference ( expr , & bitsize , & bitoffset , & var_offset , & mode , & unsigned_p , & reverse_p , & volatile_p , false ) ;


<s> for ( f = ( unsigned int ) fp_code ; f != <NUM_LIT> ; f >>= <NUM_LIT> ) { fprintf ( asm_out_file , <STR_LIT> , separator , ( f & <NUM_LIT> ) == <NUM_LIT> ? <STR_LIT> : <STR_LIT> ) ; separator = <STR_LIT> ; } fprintf ( asm_out_file , <STR_LIT> ) ; assemble_start_function ( stubdecl , stubname ) ; mips_start_function_definition ( stubname , false ) ; if ( fp_ret_p ) { fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> , reg_names [ GP_REG_FIRST + <NUM_LIT> ] , reg_names [ RETURN_ADDR_REGNUM ] ) ; } else { if ( TARGET_EXPLICIT_RELOCS ) { output_asm_insn ( <STR_LIT> , & fn ) ; output_asm_insn ( <STR_LIT> , & fn ) ; } else output_asm_insn ( <STR_LIT> , & fn ) ; } mips_output_args_xfer ( fp_code , 't' ) ; if ( fp_ret_p ) { output_asm_insn ( mips_output_jump ( & fn , <NUM_LIT> , - <NUM_LIT> , true ) , & fn ) ; fprintf ( asm_out_file , <STR_LIT> ) ; switch ( GET_MODE ( retval ) ) { case SCmode : mips_output_32bit_xfer ( 'f' , GP_RETURN + TARGET_BIG_ENDIAN , TARGET_BIG_ENDIAN ? FP_REG_FIRST + <NUM_LIT> : FP_REG_FIRST ) ; mips_output_32bit_xfer ( 'f' , GP_RETURN + TARGET_LITTLE_ENDIAN , TARGET_LITTLE_ENDIAN ? FP_REG_FIRST + <NUM_LIT> : FP_REG_FIRST ) ; if ( GET_MODE ( retval ) == SCmode && TARGET_64BIT ) { fprintf ( asm_out_file , <STR_LIT> , reg_names [ GP_RETURN + TARGET_BIG_ENDIAN ] , reg_names [ GP_RETURN + TARGET_BIG_ENDIAN ] ) ; fprintf ( asm_out_file , <STR_LIT> , reg_names [ GP_RETURN + TARGET_LITTLE_ENDIAN ] , reg_names [ GP_RETURN + TARGET_LITTLE_ENDIAN ] ) ; fprintf ( asm_out_file , <STR_LIT> , reg_names [ GP_RETURN + TARGET_BIG_ENDIAN ] , reg_names [ GP_RETURN + TARGET_BIG_ENDIAN ] ) ; fprintf ( asm_out_file , <STR_LIT> , reg_names [ GP_RETURN ] , reg_names [ GP_RETURN ] , reg_names [ GP_RETURN + <NUM_LIT> ] ) ; } break ; case SFmode : mips_output_32bit_xfer ( 'f' , GP_RETURN , FP_REG_FIRST ) ;


<s> static unsigned int mips_autovectorize_vector_sizes ( void ) { return ISA_HAS_MSA ? <NUM_LIT> : <NUM_LIT> ;


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

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


<s> HARD_REG_SET left ; size = <NUM_LIT> ; COPY_HARD_REG_SET ( left , reg_class_contents [ ( int ) rclass ] ) ; if ( hard_reg_set_intersect_p ( left , reg_class_contents [ ( int ) ST_REGS ] ) ) { if ( HARD_REGNO_MODE_OK ( ST_REG_FIRST , mode ) ) size = MIN ( size , <NUM_LIT> ) ; AND_COMPL_HARD_REG_SET ( left , reg_class_contents [ ( int ) ST_REGS ] ) ; } if ( hard_reg_set_intersect_p ( left , reg_class_contents [ ( int ) FP_REGS ] ) ) { if ( HARD_REGNO_MODE_OK ( FP_REG_FIRST , mode ) ) { if ( MSA_SUPPORTED_MODE_P ( mode ) ) size = MIN ( size , UNITS_PER_MSA_REG ) ;

else size = MIN ( size , UNITS_PER_FPREG ) ;


<s> const struct mips_builtin_description * d ; fndecl = TREE_OPERAND ( CALL_EXPR_FN ( exp ) , <NUM_LIT> ) ; fcode = DECL_FUNCTION_CODE ( fndecl ) ; gcc_assert ( fcode < ARRAY_SIZE ( mips_builtins ) ) ; d = & mips_builtins [ fcode ] ; avail = d -> avail ( ) ; gcc_assert ( avail != <NUM_LIT> ) ; if ( TARGET_MIPS16 && ! ( avail & BUILTIN_AVAIL_MIPS16 ) ) { error ( <STR_LIT> , DECL_NAME ( fndecl ) ) ; return ignore ? const0_rtx : CONST0_RTX ( mode ) ; } switch ( d -> builtin_type ) { case MIPS_BUILTIN_DIRECT : return mips_expand_builtin_direct ( d -> icode , target , exp , true ) ; case MIPS_BUILTIN_DIRECT_NO_TARGET : return mips_expand_builtin_direct ( d -> icode , target , exp , false ) ; case MIPS_BUILTIN_MOVT : case MIPS_BUILTIN_MOVF : return mips_expand_builtin_movtf ( d -> builtin_type , d -> icode , d -> cond , target , exp ) ; case MIPS_BUILTIN_CMP_ANY : case MIPS_BUILTIN_CMP_ALL : case MIPS_BUILTIN_CMP_UPPER : case MIPS_BUILTIN_CMP_LOWER : case MIPS_BUILTIN_CMP_SINGLE : return mips_expand_builtin_compare ( d -> builtin_type , d -> icode , d -> cond , target , exp ) ; case MIPS_BUILTIN_MSA_TEST_BRANCH : return mips_expand_builtin_msa_test_branch ( d -> icode , exp ) ; case MIPS_BUILTIN_BPOSGE32 : return mips_expand_builtin_bposge ( d -> builtin_type , target ) ;


<s> return mips_expand_builtin_direct ( d -> icode , target , exp , false ) ; case MIPS_BUILTIN_MOVT : case MIPS_BUILTIN_MOVF : return mips_expand_builtin_movtf ( d -> builtin_type , d -> icode , d -> cond , target , exp ) ; case MIPS_BUILTIN_CMP_ANY : case MIPS_BUILTIN_CMP_ALL : case MIPS_BUILTIN_CMP_UPPER : case MIPS_BUILTIN_CMP_LOWER : case MIPS_BUILTIN_CMP_SINGLE : return mips_expand_builtin_compare ( d -> builtin_type , d -> icode , d -> cond , target , exp ) ;


<s> static void mips_expand_msa_cmp ( rtx dest , enum rtx_code cond , rtx op0 , rtx op1 ) { machine_mode cmp_mode = GET_MODE ( op0 ) ; int unspec = - <NUM_LIT> ; bool negate = false ; switch ( cmp_mode ) { case V16QImode : case V8HImode : case V4SImode : case V2DImode : switch ( cond ) { case NE : cond = reverse_condition ( cond ) ; negate = true ; break ; case EQ : case LT : case LE : case LTU : case LEU : break ; case GE : case GT : case GEU : case GTU : std :: swap ( op0 , op1 ) ; cond = swap_condition ( cond ) ; break ; default : gcc_unreachable ( ) ; } mips_emit_binary ( cond , dest , op0 , op1 ) ; if ( negate ) emit_move_insn ( dest , gen_rtx_NOT ( GET_MODE ( dest ) , dest ) ) ; break ; case V4SFmode : case V2DFmode : switch ( cond ) { case UNORDERED : case ORDERED : case EQ : case NE : case UNEQ : case UNLE : case UNLT : break ; case LTGT : cond = NE ; break ; case UNGE : cond = UNLE ; std :: swap ( op0 , op1 ) ; break ; case UNGT : cond = UNLT ; std :: swap ( op0 , op1 ) ; break ; case LE : unspec = UNSPEC_MSA_FSLE ; break ; case LT : unspec = UNSPEC_MSA_FSLT ; break ; case GE : unspec = UNSPEC_MSA_FSLE ; std :: swap ( op0 , op1 ) ; break ; case GT : unspec = UNSPEC_MSA_FSLT ; std :: swap ( op0 , op1 ) ; break ; default : gcc_unreachable ( ) ; } if ( unspec < <NUM_LIT> ) mips_emit_binary ( cond , dest , op0 , op1 ) ; else { rtx x = gen_rtx_UNSPEC ( GET_MODE ( dest ) , gen_rtvec ( <NUM_LIT> , op0 , op1 ) , unspec ) ; emit_insn ( gen_rtx_SET ( dest , x ) ) ; } break ; default : gcc_unreachable ( ) ; break ;


<s> case GEU : case GTU : std :: swap ( op0 , op1 ) ; cond = swap_condition ( cond ) ; break ; default : gcc_unreachable ( ) ; } mips_emit_binary ( cond , dest , op0 , op1 ) ; if ( negate ) emit_move_insn ( dest , gen_rtx_NOT ( GET_MODE ( dest ) , dest ) ) ; break ; case V4SFmode : case V2DFmode : switch ( cond ) { case UNORDERED : case ORDERED : case EQ : case NE : case UNEQ : case UNLE : case UNLT : break ; case LTGT : cond = NE ; break ;

case UNGE : cond = UNLE ; std :: swap ( op0 , op1 ) ; break ;


<s> for ( i = <NUM_LIT> ; i < nelt ; ++ i ) { x = XVECEXP ( vals , <NUM_LIT> , i ) ; if ( ! mips_constant_elt_p ( x ) ) nvar ++ , one_var = i ; if ( i > <NUM_LIT> && ! rtx_equal_p ( x , XVECEXP ( vals , <NUM_LIT> , <NUM_LIT> ) ) ) all_same = false ; } if ( ISA_HAS_MSA ) { if ( all_same ) { rtx same = XVECEXP ( vals , <NUM_LIT> , <NUM_LIT> ) ; rtx temp , temp2 ; if ( CONST_INT_P ( same ) && nvar == <NUM_LIT> && mips_signed_immediate_p ( INTVAL ( same ) , <NUM_LIT> , <NUM_LIT> ) ) { switch ( vmode ) { case V16QImode : case V8HImode : case V4SImode : case V2DImode : temp = gen_rtx_CONST_VECTOR ( vmode , XVEC ( vals , <NUM_LIT> ) ) ; emit_move_insn ( target , temp ) ; return ; default : gcc_unreachable ( ) ; } } temp = gen_reg_rtx ( imode ) ; if ( imode == GET_MODE ( same ) ) temp2 = same ; else if ( GET_MODE_SIZE ( imode ) >= UNITS_PER_WORD ) temp2 = simplify_gen_subreg ( imode , same , GET_MODE ( same ) , <NUM_LIT> ) ; else temp2 = lowpart_subreg ( imode , same , GET_MODE ( same ) ) ; emit_move_insn ( temp , temp2 ) ; switch ( vmode ) { case V16QImode : case V8HImode : case V4SImode : case V2DImode : mips_emit_move ( target , gen_rtx_VEC_DUPLICATE ( vmode , temp ) ) ; break ; case V4SFmode : emit_insn ( gen_msa_splati_w_f_scalar ( target , temp ) ) ; break ; case V2DFmode : emit_insn ( gen_msa_splati_d_f_scalar ( target , temp ) ) ; break ; default : gcc_unreachable ( ) ; } } else { rtvec vec = shallow_copy_rtvec ( XVEC ( vals , <NUM_LIT> ) ) ; for ( i = <NUM_LIT> ; i < nelt ; ++ i ) RTVEC_ELT ( vec , i ) = CONST0_RTX ( imode ) ; emit_move_insn ( target , gen_rtx_CONST_VECTOR ( vmode , vec ) ) ; for ( i = <NUM_LIT> ; i < nelt ; ++ i ) { rtx temp = gen_reg_rtx ( imode ) ; emit_move_insn ( temp , XVECEXP ( vals , <NUM_LIT> , i ) ) ;


<s> void mips_expand_vec_cond_expr ( machine_mode mode , machine_mode vimode , rtx * operands ) { rtx cond = operands [ <NUM_LIT> ] ; rtx cmp_op0 = operands [ <NUM_LIT> ] ; rtx cmp_op1 = operands [ <NUM_LIT> ] ; rtx cmp_res = gen_reg_rtx ( vimode ) ; mips_expand_msa_cmp ( cmp_res , GET_CODE ( cond ) , cmp_op0 , cmp_op1 ) ; if ( operands [ <NUM_LIT> ] == CONSTM1_RTX ( vimode ) && operands [ <NUM_LIT> ] == CONST0_RTX ( vimode ) ) emit_move_insn ( operands [ <NUM_LIT> ] , cmp_res ) ; else { rtx src1 = gen_reg_rtx ( vimode ) ; rtx src2 = gen_reg_rtx ( vimode ) ; rtx mask = gen_reg_rtx ( vimode ) ; rtx bsel ; emit_move_insn ( mask , cmp_res ) ; if ( register_operand ( operands [ <NUM_LIT> ] , mode ) ) { rtx xop1 = operands [ <NUM_LIT> ] ; if ( mode != vimode ) { xop1 = gen_reg_rtx ( vimode ) ; emit_move_insn ( xop1 , gen_rtx_SUBREG ( vimode , operands [ <NUM_LIT> ] , <NUM_LIT> ) ) ; } emit_move_insn ( src1 , xop1 ) ; } else { gcc_assert ( operands [ <NUM_LIT> ] == CONSTM1_RTX ( vimode ) ) ; emit_move_insn ( src1 , mask ) ; } if ( register_operand ( operands [ <NUM_LIT> ] , mode ) ) { rtx xop2 = operands [ <NUM_LIT> ] ; if ( mode != vimode ) { xop2 = gen_reg_rtx ( vimode ) ; emit_move_insn ( xop2 , gen_rtx_SUBREG ( vimode , operands [ <NUM_LIT> ] , <NUM_LIT> ) ) ; } emit_move_insn ( src2 , xop2 ) ; } else { gcc_assert ( operands [ <NUM_LIT> ] == CONST0_RTX ( mode ) ) ;


<s> } if ( register_operand ( operands [ <NUM_LIT> ] , mode ) ) { rtx xop2 = operands [ <NUM_LIT> ] ; if ( mode != vimode ) { xop2 = gen_reg_rtx ( vimode ) ; emit_move_insn ( xop2 , gen_rtx_SUBREG ( vimode , operands [ <NUM_LIT> ] , <NUM_LIT> ) ) ; } emit_move_insn ( src2 , xop2 ) ; } else { gcc_assert ( operands [ <NUM_LIT> ] == CONST0_RTX ( mode ) ) ; emit_move_insn ( src2 , mask ) ; } bsel = gen_rtx_IOR ( vimode , gen_rtx_AND ( vimode , gen_rtx_NOT ( vimode , mask ) , src2 ) , gen_rtx_AND ( vimode , mask , src1 ) ) ;

emit_insn ( gen_rtx_SET ( mask , bsel ) ) ;


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

if ( ! rtx_equal_p ( d . op0 , d . op1 ) ) break ;


<s> break ; default : gcc_unreachable ( ) ; break ; } if ( ! unsigned_p ) { tmp = gen_reg_rtx ( imode ) ; emit_insn ( cmpFunc ( tmp , operands [ <NUM_LIT> ] , CONST0_RTX ( imode ) ) ) ; } else tmp = force_reg ( imode , CONST0_RTX ( imode ) ) ; dest = gen_reg_rtx ( imode ) ; emit_insn ( unpack ( dest , operands [ <NUM_LIT> ] , tmp ) ) ; emit_move_insn ( operands [ <NUM_LIT> ] , gen_lowpart ( GET_MODE ( operands [ <NUM_LIT> ] ) , dest ) ) ; return ; } switch ( imode ) { case V8QImode : if ( high_p ) unpack = gen_loongson_punpckhbh ; else unpack = gen_loongson_punpcklbh ; cmpFunc = gen_loongson_pcmpgtb ; break ;


<s> int nunits = GET_MODE_NUNITS ( mode ) ; rtvec v = rtvec_alloc ( nunits ) ; int i ; for ( i = <NUM_LIT> ; i < nunits ; i ++ ) RTVEC_ELT ( v , i ) = gen_int_mode ( val , GET_MODE_INNER ( mode ) ) ;

return gen_rtx_CONST_VECTOR ( mode , v ) ;


<s> mclass = GET_MODE_CLASS ( mode ) ; if ( GP_REG_P ( regno ) && mode != CCFmode && ! MSA_SUPPORTED_MODE_P ( mode ) ) return ( ( regno - GP_REG_FIRST ) & <NUM_LIT> ) == <NUM_LIT> || size <= UNITS_PER_WORD ; if ( FP_REG_P ( regno ) && MSA_SUPPORTED_MODE_P ( mode ) ) return true ; if ( FP_REG_P ( regno ) && ( ( ( regno - FP_REG_FIRST ) % MAX_FPRS_PER_FMT ) == <NUM_LIT> || ( MIN_FPRS_PER_FMT == <NUM_LIT> && size <= UNITS_PER_FPREG ) ) ) { if ( TARGET_O32_FP64A_ABI && size <= <NUM_LIT> && ( regno & <NUM_LIT> ) != <NUM_LIT> ) return false ; if ( mode == CCFmode ) return ! ( TARGET_FLOATXX && ( regno & <NUM_LIT> ) != <NUM_LIT> ) ; if ( TARGET_LOONGSON_VECTORS && ( mode == V2SImode || mode == V4HImode || mode == V8QImode || mode == DImode ) ) return true ; if ( mclass == MODE_FLOAT || mclass == MODE_COMPLEX_FLOAT || mclass == MODE_VECTOR_FLOAT ) return size <= UNITS_PER_FPVALUE ;

if ( mclass == MODE_INT ) return size >= MIN_UNITS_PER_WORD && size <= UNITS_PER_FPREG ;


<s> if ( FP_REG_P ( regno ) ) { if ( MSA_SUPPORTED_MODE_P ( mode ) ) return <NUM_LIT> ;

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


<s> const struct mips_builtin_description * d ; unsigned int i ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( mips_builtins ) ; i ++ ) { d = & mips_builtins [ i ] ; if ( d -> avail ( ) ) { mips_builtin_decls [ i ] = add_builtin_function ( d -> name , mips_build_function_type ( d -> function_type ) , i , BUILT_IN_MD , NULL , NULL ) ; mips_get_builtin_decl_index [ d -> icode ] = i ;


<s> for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( mips_builtins ) ; i ++ ) { d = & mips_builtins [ i ] ; if ( d -> avail ( ) ) { mips_builtin_decls [ i ] = add_builtin_function ( d -> name , mips_build_function_type ( d -> function_type ) , i , BUILT_IN_MD , NULL , NULL ) ; mips_get_builtin_decl_index [ d -> icode ] = i ; }


<s> case DFmode : return TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT ; case V2SFmode : return TARGET_HARD_FLOAT && TARGET_PAIRED_SINGLE_FLOAT ; default : return MSA_SUPPORTED_MODE_P ( mode ) ;


<s> switch ( mode ) { case QImode : return V16QImode ; case HImode : return V8HImode ; case SImode : return V4SImode ;


<s> if ( MSA_SUPPORTED_MODE_P ( GET_MODE ( dest ) ) ) mips_split_128bit_move ( dest , src ) ; else if ( FP_REG_RTX_P ( dest ) || FP_REG_RTX_P ( src ) ) { if ( ! TARGET_64BIT && GET_MODE ( dest ) == DImode ) emit_insn ( gen_move_doubleword_fprdi ( dest , src ) ) ; else if ( ! TARGET_64BIT && GET_MODE ( dest ) == DFmode ) emit_insn ( gen_move_doubleword_fprdf ( dest , src ) ) ; else if ( ! TARGET_64BIT && GET_MODE ( dest ) == V2SFmode ) emit_insn ( gen_move_doubleword_fprv2sf ( dest , src ) ) ; else if ( ! TARGET_64BIT && GET_MODE ( dest ) == V2SImode ) emit_insn ( gen_move_doubleword_fprv2si ( dest , src ) ) ; else if ( ! TARGET_64BIT && GET_MODE ( dest ) == V4HImode ) emit_insn ( gen_move_doubleword_fprv4hi ( dest , src ) ) ; else if ( ! TARGET_64BIT && GET_MODE ( dest ) == V8QImode ) emit_insn ( gen_move_doubleword_fprv8qi ( dest , src ) ) ; else if ( TARGET_64BIT && GET_MODE ( dest ) == TFmode ) emit_insn ( gen_move_doubleword_fprtf ( dest , src ) ) ; else gcc_unreachable ( ) ; } else if ( REG_P ( dest ) && REGNO ( dest ) == MD_REG_FIRST ) { low_dest = mips_subword ( dest , false ) ; mips_emit_move ( low_dest , mips_subword ( src , false ) ) ; if ( TARGET_64BIT ) emit_insn ( gen_mthidi_ti ( dest , mips_subword ( src , true ) , low_dest ) ) ; else emit_insn ( gen_mthisi_di ( dest , mips_subword ( src , true ) , low_dest ) ) ;


<s> tree addr , t , type_size , rounded_size , valist_tmp ; unsigned HOST_WIDE_INT align , boundary ; bool indirect ; indirect = pass_by_reference ( NULL , TYPE_MODE ( type ) , type , false ) ; if ( indirect ) type = build_pointer_type ( type ) ; align = PARM_BOUNDARY / BITS_PER_UNIT ; boundary = targetm . calls . function_arg_boundary ( TYPE_MODE ( type ) , type ) ; if ( boundary > MAX_SUPPORTED_STACK_ALIGNMENT ) boundary = MAX_SUPPORTED_STACK_ALIGNMENT ; boundary /= BITS_PER_UNIT ; valist_tmp = get_initialized_tmp_var ( valist , pre_p , NULL ) ; if ( boundary > align ) { t = build2 ( MODIFY_EXPR , TREE_TYPE ( valist ) , valist_tmp , fold_build_pointer_plus_hwi ( valist_tmp , boundary - <NUM_LIT> ) ) ; gimplify_and_add ( t , pre_p ) ; t = build2 ( MODIFY_EXPR , TREE_TYPE ( valist ) , valist_tmp , fold_build2 ( BIT_AND_EXPR , TREE_TYPE ( valist ) , valist_tmp , build_int_cst ( TREE_TYPE ( valist ) , - boundary ) ) ) ; gimplify_and_add ( t , pre_p ) ; } else boundary = align ; boundary *= BITS_PER_UNIT ; if ( boundary < TYPE_ALIGN ( type ) ) { type = build_variant_type_copy ( type ) ; SET_TYPE_ALIGN ( type , boundary ) ; } type_size = size_in_bytes ( type ) ; rounded_size = round_up ( type_size , align ) ; gimplify_expr ( & rounded_size , pre_p , post_p , is_gimple_val , fb_rvalue ) ; addr = valist_tmp ;

if ( PAD_VARARGS_DOWN && ! integer_zerop ( rounded_size ) ) {


<s> return TARGET_DSP ; case V2SImode : case V4HImode : case V8QImode : return TARGET_LOONGSON_VECTORS ; default :


<s> case V4QQmode : case V4UQQmode : return TARGET_DSP ; case V2SImode : case V4HImode : case V8QImode : return TARGET_LOONGSON_VECTORS ; default : return MSA_SUPPORTED_MODE_P ( mode ) ; }


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


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

return offset < tree_to_uhwi ( DECL_SIZE_UNIT ( inner ) ) ;


<s> static void mips_autovectorize_vector_sizes ( vector_sizes * sizes ) { if ( ISA_HAS_MSA ) sizes -> safe_push ( <NUM_LIT> ) ;


<s> int i ; machine_mode mode ; rtx * regs ; if ( ! ISA_HAS_LWL_LWR ) bits = MIN ( BITS_PER_WORD , MIN ( MEM_ALIGN ( src ) , MEM_ALIGN ( dest ) ) ) ; else { 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 = int_mode_for_size ( bits , <NUM_LIT> ) . require ( ) ; delta = bits / BITS_PER_UNIT ; regs = XALLOCAVEC ( 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 ) mips_emit_move ( regs [ i ] , adjust_address ( src , mode , offset ) ) ; else { rtx part = adjust_address ( src , BLKmode , offset ) ; set_mem_size ( part , delta ) ; if ( ! mips_expand_ext_as_unaligned_load ( regs [ i ] , part , bits , <NUM_LIT> , <NUM_LIT> ) ) gcc_unreachable ( ) ; } } for ( offset = <NUM_LIT> , i = <NUM_LIT> ; offset + delta <= length ; offset += delta , i ++ ) if ( MEM_ALIGN ( dest ) >= bits ) mips_emit_move ( adjust_address ( dest , mode , offset ) , regs [ i ] ) ; else { rtx part = adjust_address ( dest , BLKmode , offset ) ; set_mem_size ( part , delta ) ;

if ( ! mips_expand_ins_as_unaligned_store ( part , regs [ i ] , bits , <NUM_LIT> ) ) gcc_unreachable ( ) ;


<s> else bits = BITS_PER_WORD ; } mode = int_mode_for_size ( bits , <NUM_LIT> ) . require ( ) ; delta = bits / BITS_PER_UNIT ; regs = XALLOCAVEC ( 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 ) mips_emit_move ( regs [ i ] , adjust_address ( src , mode , offset ) ) ; else { rtx part = adjust_address ( src , BLKmode , offset ) ; set_mem_size ( part , delta ) ; if ( ! mips_expand_ext_as_unaligned_load ( regs [ i ] , part , bits , <NUM_LIT> , <NUM_LIT> ) ) gcc_unreachable ( ) ; }


<s> } if ( hard_reg_set_intersect_p ( left , reg_class_contents [ ( int ) FP_REGS ] ) ) { if ( mips_hard_regno_mode_ok ( FP_REG_FIRST , mode ) ) { if ( MSA_SUPPORTED_MODE_P ( mode ) ) size = MIN ( size , UNITS_PER_MSA_REG ) ; else size = MIN ( size , UNITS_PER_FPREG ) ; }

AND_COMPL_HARD_REG_SET ( left , reg_class_contents [ ( int ) FP_REGS ] ) ;


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

emit_insn ( gen_vec_setv8hi ( target , temp , GEN_INT ( i ) ) ) ;


<s> break ; case E_V8QImode : t2 = gen_reg_rtx ( d -> vmode ) ; t3 = gen_reg_rtx ( d -> vmode ) ; emit_insn ( gen_loongson_punpckhbh ( t0 , d -> op0 , d -> op1 ) ) ; emit_insn ( gen_loongson_punpcklbh ( t1 , d -> op0 , d -> op1 ) ) ; emit_insn ( gen_loongson_punpckhbh ( t2 , t1 , t0 ) ) ; emit_insn ( gen_loongson_punpcklbh ( t3 , t1 , t0 ) ) ; if ( odd ) emit_insn ( gen_loongson_punpckhbh ( d -> target , t3 , t2 ) ) ; else emit_insn ( gen_loongson_punpcklbh ( d -> target , t3 , t2 ) ) ;


<s> emit_insn ( gen_loongson_punpckhbh ( t0 , d -> op0 , d -> op1 ) ) ; emit_insn ( gen_loongson_punpcklbh ( t1 , d -> op0 , d -> op1 ) ) ; emit_insn ( gen_loongson_punpckhbh ( t2 , t1 , t0 ) ) ; emit_insn ( gen_loongson_punpcklbh ( t3 , t1 , t0 ) ) ; if ( odd ) emit_insn ( gen_loongson_punpckhbh ( d -> target , t3 , t2 ) ) ; else emit_insn ( gen_loongson_punpcklbh ( d -> target , t3 , t2 ) ) ; break ; default : gcc_unreachable ( ) ; } return true ;


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

if ( TARGET_FLOATXX && hard_regno_nregs ( regno , mode ) == <NUM_LIT> && FP_REG_P ( regno ) && ( regno & <NUM_LIT> ) != <NUM_LIT> ) return true ;


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


<s> if ( FP_REG_P ( regno ) && MSA_SUPPORTED_MODE_P ( mode ) ) return true ; if ( FP_REG_P ( regno ) && ( ( ( regno - FP_REG_FIRST ) % MAX_FPRS_PER_FMT ) == <NUM_LIT> || ( MIN_FPRS_PER_FMT == <NUM_LIT> && size <= UNITS_PER_FPREG ) ) ) { if ( TARGET_O32_FP64A_ABI && size <= <NUM_LIT> && ( regno & <NUM_LIT> ) != <NUM_LIT> ) return false ; if ( mode == CCFmode ) return ! ( TARGET_FLOATXX && ( regno & <NUM_LIT> ) != <NUM_LIT> ) ; if ( TARGET_LOONGSON_VECTORS && ( mode == V2SImode || mode == V4HImode || mode == V8QImode || mode == DImode ) ) return true ;

if ( mclass == MODE_FLOAT || mclass == MODE_COMPLEX_FLOAT || mclass == MODE_VECTOR_FLOAT ) return size <= UNITS_PER_FPVALUE ;


<s> case E_V4QImode : case E_V2HQmode : case E_V2UHQmode : case E_V2HAmode : case E_V2UHAmode : case E_V4QQmode :


<s> else emit_insn ( gen_mthisi_di ( dest , mips_subword ( src , true ) , low_dest ) ) ; } else if ( REG_P ( src ) && REGNO ( src ) == MD_REG_FIRST ) { mips_emit_move ( mips_subword ( dest , false ) , mips_subword ( src , false ) ) ; if ( TARGET_64BIT ) emit_insn ( gen_mfhidi_ti ( mips_subword ( dest , true ) , src ) ) ; else emit_insn ( gen_mfhisi_di ( mips_subword ( dest , true ) , src ) ) ; } else { low_dest = mips_subword ( dest , false ) ; if ( REG_P ( low_dest ) && reg_overlap_mentioned_p ( low_dest , src ) ) { mips_emit_move ( mips_subword ( dest , true ) , mips_subword ( src , true ) ) ; mips_emit_move ( low_dest , mips_subword ( src , false ) ) ; } else { mips_emit_move ( low_dest , mips_subword ( src , false ) ) ; mips_emit_move ( mips_subword ( dest , true ) , mips_subword ( src , true ) ) ; } } rtx_insn * insn = ( rtx_insn * ) insn_ ; if ( insn ) { rtx_insn * next = next_nonnote_nondebug_insn_bb ( insn ) ; if ( next ) { rtx set = single_set ( next ) ; if ( set && SET_SRC ( set ) == dest ) validate_change ( next , & SET_SRC ( set ) , src , false ) ; }


<s> bool and_operands_ok ( machine_mode mode , rtx op1 , rtx op2 ) { if ( memory_operand ( op1 , mode ) ) { if ( TARGET_MIPS16 ) { struct mips_address_info addr ; if ( ! mips_classify_address ( & addr , op1 , mode , false ) ) return false ; }

return and_load_operand ( op2 , mode ) ;


<s> FOR_BB_INSNS ( bb , insn ) { rtx call , reg , symbol , second_call ; second_call = <NUM_LIT> ; call = mips_call_expr_from_insn ( insn , & second_call ) ; if ( ! call ) continue ; gcc_assert ( MEM_P ( XEXP ( call , <NUM_LIT> ) ) ) ; reg = XEXP ( XEXP ( call , <NUM_LIT> ) , <NUM_LIT> ) ; if ( ! REG_P ( reg ) ) continue ; symbol = mips_find_pic_call_symbol ( insn , reg , true ) ; if ( symbol ) { mips_annotate_pic_call_expr ( call , symbol ) ;

if ( second_call ) mips_annotate_pic_call_expr ( second_call , symbol ) ;


<s> second_call = <NUM_LIT> ; call = mips_call_expr_from_insn ( insn , & second_call ) ; if ( ! call ) continue ; gcc_assert ( MEM_P ( XEXP ( call , <NUM_LIT> ) ) ) ; reg = XEXP ( XEXP ( call , <NUM_LIT> ) , <NUM_LIT> ) ; if ( ! REG_P ( reg ) ) continue ; symbol = mips_find_pic_call_symbol ( insn , reg , true ) ; if ( symbol ) {

mips_annotate_pic_call_expr ( call , symbol ) ;


<s> const_rtx addr = XEXP ( mem , <NUM_LIT> ) ; if ( GET_CODE ( addr ) == SYMBOL_REF && SYMBOL_REF_DECL ( addr ) ) iter . skip_subrtxes ( ) ; else return true ; }


<s> if ( GET_CODE ( addr ) == SYMBOL_REF && SYMBOL_REF_DECL ( addr ) ) iter . skip_subrtxes ( ) ; else return true ; }


<s> * loc = gen_rtx_LO_SUM ( Pmode , pic_offset_table_rtx , * loc ) ; iter . skip_subrtxes ( ) ; } else if ( GET_CODE ( * loc ) == LO_SUM ) iter . skip_subrtxes ( ) ;


<s> FOR_EACH_SUBRTX_PTR ( iter , array , loc , ALL ) { rtx * loc = * iter ; if ( MEM_P ( * loc ) ) { mips_rewrite_small_data_1 ( & XEXP ( * loc , <NUM_LIT> ) , SYMBOL_CONTEXT_MEM ) ;


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


<s> FOR_EACH_SUBRTX_VAR ( iter , array , x , NONCONST ) { rtx mem = * iter ; if ( MEM_P ( mem ) ) { if ( ( MEM_EXPR ( mem ) && MEM_OFFSET_KNOWN_P ( mem ) && r10k_safe_mem_expr_p ( MEM_EXPR ( mem ) , MEM_OFFSET ( mem ) ) ) || r10k_safe_address_p ( XEXP ( mem , <NUM_LIT> ) , insn ) ) iter . skip_subrtxes ( ) ; else return true ;


<s> static rtx gen_load_const_gp ( rtx reg ) {

return PMODE_INSN ( gen_load_const_gp , ( reg ) ) ;


<s> const char * mips16_set_fcsr_one_only_stub :: get_name ( ) {


<s> inline hashval_t mips_lo_sum_offset_hasher :: hash ( const mips_lo_sum_offset * entry ) { return mips_hash_base ( entry -> base ) ;


<s> inline hashval_t mips_lo_sum_offset_hasher :: hash ( const mips_lo_sum_offset * entry ) {

return mips_hash_base ( entry -> base ) ;


<s> bool lwsp_swsp_address_p ( rtx x , machine_mode mode ) { struct mips_address_info addr ; return ( mips_classify_address ( & addr , x , mode , false ) && addr . type == ADDRESS_REG && REGNO ( addr . reg ) == STACK_POINTER_REGNUM && uw5_operand ( addr . offset , mode ) ) ;


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

return ( mips_classify_address ( & addr , x , mode , false ) && addr . type == ADDRESS_REG && M16_REG_P ( REGNO ( addr . reg ) ) && offset_predicate ( addr . offset , mode ) ) ;


<s> int mask_low_and_shift_len ( machine_mode mode , rtx mask , rtx shift ) { HOST_WIDE_INT shval ;

shval = INTVAL ( shift ) & ( GET_MODE_BITSIZE ( mode ) - <NUM_LIT> ) ;


<s> bool mask_low_and_shift_p ( machine_mode mode , rtx mask , rtx shift , int maxlen ) {

return IN_RANGE ( mask_low_and_shift_len ( mode , mask , shift ) , <NUM_LIT> , maxlen ) ;


<s> return IN_RANGE ( mask_low_and_shift_len ( mode , mask , shift ) , <NUM_LIT> , maxlen ) ;


<s> if ( ! DECL_NAME ( decl ) ) return ! base_is_mips16 ; if ( ! mflip_mips16_htab ) mflip_mips16_htab = hash_map < nofree_string_hash , bool > :: create_ggc ( <NUM_LIT> ) ;

name = IDENTIFIER_POINTER ( DECL_NAME ( decl ) ) ;


<s> static char * mips16e_add_register_range ( char * s , unsigned int min_reg , unsigned int max_reg ) { if ( min_reg != max_reg ) s += sprintf ( s , <STR_LIT> , reg_names [ min_reg ] , reg_names [ max_reg ] ) ; else s += sprintf ( s , <STR_LIT> , reg_names [ min_reg ] ) ; return s ;


<s> XVECEXP ( pattern , <NUM_LIT> , n ++ ) = set ; top_offset = restore_p ? size : <NUM_LIT> ; for ( i = <NUM_LIT> ; i < nargs ; i ++ ) { offset = top_offset + i * UNITS_PER_WORD ; set = mips16e_save_restore_reg ( restore_p , true , offset , GP_ARG_FIRST + i ) ; XVECEXP ( pattern , <NUM_LIT> , n ++ ) = set ; } offset = top_offset ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( mips16e_save_restore_regs ) ; i ++ ) { regno = mips16e_save_restore_regs [ i ] ; if ( BITSET_P ( * mask_ptr , regno ) ) { offset -= UNITS_PER_WORD ; set = mips16e_save_restore_reg ( restore_p , false , offset , regno ) ; XVECEXP ( pattern , <NUM_LIT> , n ++ ) = set ; * mask_ptr &= ~ ( <NUM_LIT> << regno ) ; }


<s> static rtx mips16e_build_save_restore ( bool restore_p , unsigned int * mask_ptr , HOST_WIDE_INT * offset_ptr , unsigned int nargs , HOST_WIDE_INT size ) { rtx pattern , set ; HOST_WIDE_INT offset , top_offset ; unsigned int i , regno ; int n ; gcc_assert ( cfun -> machine -> frame . num_fp == <NUM_LIT> ) ; n = <NUM_LIT> + nargs ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( mips16e_save_restore_regs ) ; i ++ ) if ( BITSET_P ( * mask_ptr , mips16e_save_restore_regs [ i ] ) ) n ++ ; pattern = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( n ) ) ; n = <NUM_LIT> ; set = gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , restore_p ? size : - size ) ) ; RTX_FRAME_RELATED_P ( set ) = <NUM_LIT> ; XVECEXP ( pattern , <NUM_LIT> , n ++ ) = set ;


<s> unsigned int nargs , regno ; push_topmost_sequence ( ) ; nargs = <NUM_LIT> ; memset ( reg_values , <NUM_LIT> , sizeof ( reg_values ) ) ; for ( insn = get_insns ( ) ; insn ; insn = next ) { next = NEXT_INSN ( insn ) ; if ( NOTE_P ( insn ) || DEBUG_INSN_P ( insn ) ) continue ; if ( ! INSN_P ( insn ) ) break ; set = PATTERN ( insn ) ; if ( GET_CODE ( set ) != SET ) break ; dest = SET_DEST ( set ) ; src = SET_SRC ( set ) ; if ( mips16e_collect_argument_save_p ( dest , src , reg_values , & regno ) ) {

if ( ! BITSET_P ( cfun -> machine -> frame . mask , regno ) ) {


<s> addr = mips16e_collect_propagate_value ( XEXP ( dest , <NUM_LIT> ) , reg_values ) ; mips_split_plus ( addr , & base , & offset ) ; required_offset = cfun -> machine -> frame . total_size + argno * UNITS_PER_WORD ; if ( base == hard_frame_pointer_rtx ) required_offset -= cfun -> machine -> frame . hard_frame_pointer_offset ;

else if ( base != stack_pointer_rtx ) return false ;


<s> HOST_WIDE_INT offset , required_offset ; rtx addr , base ; if ( ! MEM_P ( dest ) || ! REG_P ( src ) || GET_MODE ( dest ) != word_mode ) return false ; regno = REGNO ( src ) ; if ( ! IN_RANGE ( regno , GP_ARG_FIRST , GP_ARG_LAST ) || reg_values [ regno ] ) return false ;


<s> x = avoid_constant_pool_reference ( x ) ; if ( UNARY_P ( x ) ) { rtx x0 = mips16e_collect_propagate_value ( XEXP ( x , <NUM_LIT> ) , reg_values ) ; return simplify_gen_unary ( GET_CODE ( x ) , GET_MODE ( x ) , x0 , GET_MODE ( XEXP ( x , <NUM_LIT> ) ) ) ; } if ( ARITHMETIC_P ( x ) ) {


<s> if ( ARITHMETIC_P ( x ) ) { rtx x0 = mips16e_collect_propagate_value ( XEXP ( x , <NUM_LIT> ) , reg_values ) ; rtx x1 = mips16e_collect_propagate_value ( XEXP ( x , <NUM_LIT> ) , reg_values ) ; return simplify_gen_binary ( GET_CODE ( x ) , GET_MODE ( x ) , x0 , x1 ) ; } if ( REG_P ( x ) && reg_values [ REGNO ( x ) ] && ! rtx_unstable_p ( reg_values [ REGNO ( x ) ] ) ) return reg_values [ REGNO ( x ) ] ;


<s> static unsigned int mips16e_find_first_register ( unsigned int mask , const unsigned char * regs , unsigned int size ) { unsigned int i ;

for ( i = <NUM_LIT> ; i < size ; i ++ ) if ( BITSET_P ( mask , regs [ i ] ) ) break ;


<s> unsigned int i ; i = mips16e_find_first_register ( * mask_ptr , regs , size ) ; for ( i ++ ; i < size ; i ++ ) if ( ! BITSET_P ( * mask_ptr , regs [ i ] ) ) { * num_regs_ptr += <NUM_LIT> ; * mask_ptr |= <NUM_LIT> << regs [ i ] ;


<s> i = mips16e_find_first_register ( * mask_ptr , regs , size ) ; for ( i ++ ; i < size ; i ++ ) if ( ! BITSET_P ( * mask_ptr , regs [ i ] ) ) { * num_regs_ptr += <NUM_LIT> ;


<s> struct mips16e_save_restore_info info ; unsigned int i , end ; char * s ; if ( ! mips16e_save_restore_pattern_p ( pattern , adjust , & info ) ) gcc_unreachable ( ) ; s = strcpy ( buffer , adjust > <NUM_LIT> ? <STR_LIT> : <STR_LIT> ) ; s += strlen ( s ) ; if ( info . nargs > <NUM_LIT> ) s += sprintf ( s , <STR_LIT> , reg_names [ GP_ARG_FIRST ] , reg_names [ GP_ARG_FIRST + info . nargs - <NUM_LIT> ] ) ; else if ( info . nargs == <NUM_LIT> ) s += sprintf ( s , <STR_LIT> , reg_names [ GP_ARG_FIRST ] ) ; s += sprintf ( s , <STR_LIT> , ( int ) info . size ) ; if ( BITSET_P ( info . mask , <NUM_LIT> ) ) s += sprintf ( s , <STR_LIT> , reg_names [ GP_REG_FIRST + <NUM_LIT> ] ) ; if ( BITSET_P ( info . mask , <NUM_LIT> ) ) s += sprintf ( s , <STR_LIT> , reg_names [ GP_REG_FIRST + <NUM_LIT> ] ) ; end = ARRAY_SIZE ( mips16e_s2_s8_regs ) ; i = mips16e_find_first_register ( info . mask , mips16e_s2_s8_regs , end ) ; if ( i < end ) s = mips16e_add_register_range ( s , mips16e_s2_s8_regs [ end - <NUM_LIT> ] , mips16e_s2_s8_regs [ i ] ) ; end = ARRAY_SIZE ( mips16e_a0_a3_regs ) ;

i = mips16e_find_first_register ( info . mask , mips16e_a0_a3_regs , end ) ;


<s> if ( BITSET_P ( info . mask , <NUM_LIT> ) ) s += sprintf ( s , <STR_LIT> , reg_names [ GP_REG_FIRST + <NUM_LIT> ] ) ; end = ARRAY_SIZE ( mips16e_s2_s8_regs ) ; i = mips16e_find_first_register ( info . mask , mips16e_s2_s8_regs , end ) ; if ( i < end ) s = mips16e_add_register_range ( s , mips16e_s2_s8_regs [ end - <NUM_LIT> ] , mips16e_s2_s8_regs [ i ] ) ; end = ARRAY_SIZE ( mips16e_a0_a3_regs ) ; i = mips16e_find_first_register ( info . mask , mips16e_a0_a3_regs , end ) ; if ( i < end ) s = mips16e_add_register_range ( s , mips16e_a0_a3_regs [ i ] , mips16e_a0_a3_regs [ end - <NUM_LIT> ] ) ; if ( BITSET_P ( info . mask , RETURN_ADDR_REGNUM ) ) s += sprintf ( s , <STR_LIT> , reg_names [ RETURN_ADDR_REGNUM ] ) ; return buffer ;


<s> mips_split_plus ( XEXP ( mem , <NUM_LIT> ) , & base , & offset ) ; if ( base != stack_pointer_rtx ) return false ; reg = adjust > <NUM_LIT> ? SET_DEST ( set ) : SET_SRC ( set ) ; if ( ! REG_P ( reg ) ) return false ; if ( offset == top_offset + nargs * UNITS_PER_WORD && REGNO ( reg ) == GP_ARG_FIRST + nargs ) nargs ++ ; else if ( offset == save_offset ) { while ( mips16e_save_restore_regs [ i ++ ] != REGNO ( reg ) ) if ( i == ARRAY_SIZE ( mips16e_save_restore_regs ) ) return false ; mask |= <NUM_LIT> << REGNO ( reg ) ; save_offset -= UNITS_PER_WORD ; } else return false ; } extra = <NUM_LIT> ; mips16e_mask_registers ( & mask , mips16e_s2_s8_regs , ARRAY_SIZE ( mips16e_s2_s8_regs ) , & extra ) ; mips16e_mask_registers ( & mask , mips16e_a0_a3_regs , ARRAY_SIZE ( mips16e_a0_a3_regs ) , & extra ) ; if ( extra != <NUM_LIT> ) return false ;

if ( nargs > <NUM_LIT> && BITSET_P ( mask , GP_ARG_FIRST + nargs - <NUM_LIT> ) ) return false ;


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


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


<s> fnname = targetm . strip_name_encoding ( XSTR ( fn , <NUM_LIT> ) ) ; for ( l = mips16_stubs ; l != NULL ; l = l -> next ) if ( strcmp ( l -> name , fnname ) == <NUM_LIT> ) break ; if ( l == NULL ) { const char * separator ; char * secname , * stubname ; tree stubid , stubdecl ; unsigned int f ; secname = ACONCAT ( ( <STR_LIT> , fp_ret_p ? <STR_LIT> : <STR_LIT> , fnname , NULL ) ) ; stubname = ACONCAT ( ( <STR_LIT> , fp_ret_p ? <STR_LIT> : <STR_LIT> , fnname , NULL ) ) ; stubid = get_identifier ( stubname ) ; stubdecl = build_decl ( BUILTINS_LOCATION , FUNCTION_DECL , stubid , build_function_type_list ( void_type_node , NULL_TREE ) ) ; set_decl_section_name ( stubdecl , secname ) ; DECL_RESULT ( stubdecl ) = build_decl ( BUILTINS_LOCATION , RESULT_DECL , NULL_TREE , void_type_node ) ; fprintf ( asm_out_file , <STR_LIT> , ( fp_ret_p ? ( GET_MODE ( retval ) == SFmode ? <STR_LIT> : <STR_LIT> ) : <STR_LIT> ) , fnname ) ; separator = <STR_LIT> ; for ( f = ( unsigned int ) fp_code ; f != <NUM_LIT> ; f >>= <NUM_LIT> ) { fprintf ( asm_out_file , <STR_LIT> , separator , ( f & <NUM_LIT> ) == <NUM_LIT> ? <STR_LIT> : <STR_LIT> ) ; separator = <STR_LIT> ; } fprintf ( asm_out_file , <STR_LIT> ) ; assemble_start_function ( stubdecl , stubname ) ; mips_start_function_definition ( stubname , false ) ; if ( fp_ret_p ) { fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> , reg_names [ GP_REG_FIRST + <NUM_LIT> ] , reg_names [ RETURN_ADDR_REGNUM ] ) ; } else { if ( TARGET_EXPLICIT_RELOCS ) { output_asm_insn ( <STR_LIT> , & fn ) ; output_asm_insn ( <STR_LIT> , & fn ) ; } else output_asm_insn ( <STR_LIT> , & fn ) ; } mips_output_args_xfer ( fp_code , 't' ) ; if ( fp_ret_p ) { output_asm_insn ( mips_output_jump ( & fn , <NUM_LIT> , - <NUM_LIT> , true ) , & fn ) ; fprintf ( asm_out_file , <STR_LIT> ) ; switch ( GET_MODE ( retval ) ) { case E_SCmode : mips_output_32bit_xfer ( 'f' , GP_RETURN + TARGET_BIG_ENDIAN , TARGET_BIG_ENDIAN ? FP_REG_FIRST + <NUM_LIT> : FP_REG_FIRST ) ; mips_output_32bit_xfer ( 'f' , GP_RETURN + TARGET_LITTLE_ENDIAN , TARGET_LITTLE_ENDIAN ? FP_REG_FIRST + <NUM_LIT> : FP_REG_FIRST ) ;

if ( GET_MODE ( retval ) == SCmode && TARGET_64BIT ) {


<s> static const char * mips16_call_stub_mode_suffix ( machine_mode mode ) { if ( mode == SFmode ) return <STR_LIT> ; else if ( mode == DFmode ) return <STR_LIT> ;

else if ( mode == SCmode ) return <STR_LIT> ;


<s> tree return_type = DECL_RESULT ( current_function_decl ) ;


<s> if ( SMALL_OPERAND ( x ) ) return COSTS_N_INSNS ( <NUM_LIT> ) ; return - <NUM_LIT> ; case LEU : if ( x == - <NUM_LIT> ) return - <NUM_LIT> ; case LE : x += <NUM_LIT> ; case XOR : case LT : case LTU : if ( IN_RANGE ( x , <NUM_LIT> , <NUM_LIT> ) ) return <NUM_LIT> ; if ( SMALL_OPERAND_UNSIGNED ( x ) ) return COSTS_N_INSNS ( <NUM_LIT> ) ; return - <NUM_LIT> ; case EQ : case NE : if ( x == <NUM_LIT> ) return <NUM_LIT> ; return - <NUM_LIT> ; default : return - <NUM_LIT> ;


<s> return COSTS_N_INSNS ( <NUM_LIT> ) ; case PLUS : if ( IN_RANGE ( x , - <NUM_LIT> , <NUM_LIT> ) ) return <NUM_LIT> ; if ( SMALL_OPERAND ( x ) ) return COSTS_N_INSNS ( <NUM_LIT> ) ; return - <NUM_LIT> ; case LEU : if ( x == - <NUM_LIT> ) return - <NUM_LIT> ; case LE : x += <NUM_LIT> ; case XOR : case LT : case LTU : if ( IN_RANGE ( x , <NUM_LIT> , <NUM_LIT> ) ) return <NUM_LIT> ; if ( SMALL_OPERAND_UNSIGNED ( x ) ) return COSTS_N_INSNS ( <NUM_LIT> ) ; return - <NUM_LIT> ; case EQ : case NE : if ( x == <NUM_LIT> ) return <NUM_LIT> ; return - <NUM_LIT> ;


<s> rtx fn , insn , retval ; tree return_type ; machine_mode return_mode ; const char * name ; return_type = DECL_RESULT ( current_function_decl ) ; return_mode = DECL_MODE ( return_type ) ; name = ACONCAT ( ( <STR_LIT> , mips16_call_stub_mode_suffix ( return_mode ) , NULL ) ) ;


<s> insn = emit_label_after ( c -> label , insn ) ; insn = mips16_emit_constants_1 ( c -> mode , c -> value , insn ) ; next = c -> next ; free ( c ) ; } if ( constants ) insn = emit_insn_after ( gen_consttable_end ( GEN_INT ( label_num ) ) , insn ) ; emit_barrier_after ( insn ) ;


<s> int label_num = constants ? CODE_LABEL_NUMBER ( constants -> label ) : <NUM_LIT> ; struct mips16_constant * c , * next ; int align ; align = <NUM_LIT> ; if ( constants ) insn = emit_insn_after ( gen_consttable ( GEN_INT ( label_num ) ) , insn ) ; for ( c = constants ; c != NULL ; c = next ) {

if ( align < GET_MODE_SIZE ( c -> mode ) ) {


<s> if ( SCALAR_INT_MODE_P ( mode ) || ALL_SCALAR_FIXED_POINT_MODE_P ( mode ) ) { rtx size = GEN_INT ( GET_MODE_SIZE ( mode ) ) ; return emit_insn_after ( gen_consttable_int ( value , size ) , insn ) ; }

if ( SCALAR_FLOAT_MODE_P ( mode ) ) return emit_insn_after ( gen_consttable_float ( value ) , insn ) ;


<s> static rtx_insn * mips16_emit_constants_1 ( machine_mode mode , rtx value , rtx_insn * insn ) { if ( SCALAR_INT_MODE_P ( mode ) || ALL_SCALAR_FIXED_POINT_MODE_P ( mode ) ) { rtx size = GEN_INT ( GET_MODE_SIZE ( mode ) ) ; return emit_insn_after ( gen_consttable_int ( value , size ) , insn ) ; }


<s> rtx fn = mips16_stub_call_address ( mips16_get_fcsr_stub ) ;

emit_insn ( PMODE_INSN ( gen_mips_get_fcsr_mips16 , ( fn ) ) ) ;


<s> void mips16_expand_set_fcsr ( rtx newval ) { if ( ! mips16_set_fcsr_stub ) mips16_set_fcsr_stub = new mips16_set_fcsr_one_only_stub ( ) ;

rtx fn = mips16_stub_call_address ( mips16_set_fcsr_stub ) ;


<s> rtx_insn * scan ; cfun -> machine -> mips16_gp_pseudo_rtx = gen_reg_rtx ( Pmode ) ; push_topmost_sequence ( ) ; scan = get_insns ( ) ; while ( NEXT_INSN ( scan ) && ! INSN_P ( NEXT_INSN ( scan ) ) ) scan = NEXT_INSN ( scan ) ; rtx set = gen_load_const_gp ( cfun -> machine -> mips16_gp_pseudo_rtx ) ; rtx_insn * insn = emit_insn_after ( set , scan ) ; INSN_LOCATION ( insn ) = <NUM_LIT> ; pop_topmost_sequence ( ) ; } return cfun -> machine -> mips16_gp_pseudo_rtx ;


<s> rtx set = gen_load_const_gp ( cfun -> machine -> mips16_gp_pseudo_rtx ) ; rtx_insn * insn = emit_insn_after ( set , scan ) ; INSN_LOCATION ( insn ) = <NUM_LIT> ; pop_topmost_sequence ( ) ;


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

else 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> ) ; else if ( GET_CODE ( body ) == ADDR_DIFF_VEC ) return GET_MODE_SIZE ( GET_MODE ( body ) ) * XVECLEN ( body , <NUM_LIT> ) ; else gcc_unreachable ( ) ; }


<s> rtx_insn * insn , * barrier ; if ( ! TARGET_MIPS16_PCREL_LOADS ) return ; if ( split_p ) { if ( mips_cfg_in_reorg ( ) ) split_all_insns ( ) ; else split_all_insns_noflow ( ) ; } barrier = <NUM_LIT> ; memset ( & pool , <NUM_LIT> , sizeof ( pool ) ) ; for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) { if ( USEFUL_INSN_P ( insn ) ) mips16_rewrite_pool_refs ( insn , & pool ) ; pool . insn_address += mips16_insn_length ( insn ) ; if ( pool . first != NULL ) { if ( barrier == <NUM_LIT> && pool . insn_address + <NUM_LIT> > pool . highest_address ) { rtx_code_label * label ; rtx_insn * jump ; label = gen_label_rtx ( ) ; jump = emit_jump_insn_before ( gen_jump ( label ) , insn ) ; JUMP_LABEL ( jump ) = label ; LABEL_NUSES ( label ) = <NUM_LIT> ; barrier = emit_barrier_after ( jump ) ; emit_label_after ( label , barrier ) ; pool . insn_address += <NUM_LIT> ;


<s> low = mips_unspec_address ( src , SYMBOL_GOT_PAGE_OFST ) ; emit_insn ( gen_rtx_SET ( dest , PMODE_INSN ( gen_unspec_got , ( dest , page ) ) ) ) ; emit_insn ( gen_rtx_SET ( dest , gen_rtx_LO_SUM ( Pmode , dest , low ) ) ) ;


<s> if ( ! existed ) { rtx local ; func_name = targetm . strip_name_encoding ( XSTR ( func , <NUM_LIT> ) ) ; const char * local_name = ACONCAT ( ( <STR_LIT> , func_name , NULL ) ) ;

local = gen_rtx_SYMBOL_REF ( Pmode , ggc_strdup ( local_name ) ) ;


<s> bool existed ; const char * func_name = XSTR ( func , <NUM_LIT> ) ; rtx * slot = & mips16_local_aliases -> get_or_insert ( func_name , & existed ) ; gcc_assert ( slot != NULL ) ; if ( ! existed ) {


<s> return ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_LOCAL_P ( x ) && ! SYMBOL_REF_EXTERNAL_P ( x ) && ( mips_get_compress_mode ( SYMBOL_REF_DECL ( x ) ) & MASK_MIPS16 ) ) ;


<s> split_const ( * x , & base , & offset ) ; if ( GET_CODE ( base ) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P ( base ) ) { label = mips16_add_constant ( pool , copy_rtx ( get_pool_constant ( base ) ) , get_pool_mode ( base ) ) ;

base = gen_rtx_LABEL_REF ( Pmode , label ) ;


<s> } if ( MEM_P ( * loc ) ) { mips16_rewrite_pool_constant ( pool , & XEXP ( * loc , <NUM_LIT> ) ) ; iter . skip_subrtxes ( ) ; } else { if ( TARGET_MIPS16_TEXT_LOADS ) mips16_rewrite_pool_constant ( pool , loc ) ; if ( GET_CODE ( * loc ) == CONST || ( GET_CODE ( * loc ) == UNSPEC && XINT ( * loc , <NUM_LIT> ) == UNSPEC_TLS_GET_TP ) ) iter . skip_subrtxes ( ) ; } }


<s> rtx_insn * insn ; rtx_jump_insn * jump_insn ; shorten_branches ( get_insns ( ) ) ; something_changed = false ; for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) if ( ( jump_insn = dyn_cast < rtx_jump_insn * > ( insn ) ) && get_attr_length ( jump_insn ) > <NUM_LIT> && ( any_condjump_p ( jump_insn ) || any_uncondjump_p ( jump_insn ) ) ) { rtx old_label , temp , saved_temp ; rtx_code_label * new_label ; rtx target ; rtx_insn * jump , * jump_sequence ; start_sequence ( ) ; saved_temp = gen_rtx_REG ( Pmode , AT_REGNUM ) ; temp = gen_rtx_REG ( Pmode , GP_REG_FIRST + <NUM_LIT> ) ; emit_move_insn ( saved_temp , temp ) ; old_label = JUMP_LABEL ( jump_insn ) ; target = gen_rtx_LABEL_REF ( Pmode , old_label ) ; mips16_load_branch_target ( temp , target ) ; jump = emit_jump_insn ( PMODE_INSN ( gen_indirect_jump_and_restore , ( temp , temp , saved_temp ) ) ) ;


<s> if ( ! TARGET_MIPS16 ) return ; do { rtx_insn * insn ; rtx_jump_insn * jump_insn ; shorten_branches ( get_insns ( ) ) ; something_changed = false ; for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) if ( ( jump_insn = dyn_cast < rtx_jump_insn * > ( insn ) ) && get_attr_length ( jump_insn ) > <NUM_LIT> && ( any_condjump_p ( jump_insn ) || any_uncondjump_p ( jump_insn ) ) ) { rtx old_label , temp , saved_temp ; rtx_code_label * new_label ;


<s> rtx fn = mips16_stub_function ( stub -> get_name ( ) ) ; SYMBOL_REF_FLAGS ( fn ) |= SYMBOL_FLAG_LOCAL ; if ( ! call_insn_operand ( fn , VOIDmode ) ) fn = force_reg ( Pmode , fn ) ;


<s> static rtx mips16_stub_function ( const char * name ) { rtx x ; x = gen_rtx_SYMBOL_REF ( Pmode , ggc_strdup ( name ) ) ; SYMBOL_REF_FLAGS ( x ) |= ( SYMBOL_FLAG_EXTERNAL | SYMBOL_FLAG_FUNCTION ) ; return x ;


<s> rtx x ; x = gen_rtx_SYMBOL_REF ( Pmode , ggc_strdup ( name ) ) ; SYMBOL_REF_FLAGS ( x ) |= ( SYMBOL_FLAG_EXTERNAL | SYMBOL_FLAG_FUNCTION ) ;


<s> return ( GET_CODE ( x ) == SYMBOL_REF && startswith ( XSTR ( x , <NUM_LIT> ) , <STR_LIT> ) ) ;


<s> if ( GET_MODE_SIZE ( mode ) == <NUM_LIT> && base == stack_pointer_rtx ) return offset < <NUM_LIT> * GET_MODE_SIZE ( mode ) ; return offset < <NUM_LIT> * GET_MODE_SIZE ( mode ) ; } return false ;


<s> else { enum attr_type type = get_attr_type ( insn ) ;

if ( type == TYPE_LOAD || type == TYPE_STORE ) mips_last_74k_agen_insn = type ;


<s> if ( ! insn || CALL_P ( insn ) || JUMP_P ( insn ) ) mips_last_74k_agen_insn = TYPE_UNKNOWN ; else { enum attr_type type = get_attr_type ( insn ) ; if ( type == TYPE_LOAD || type == TYPE_STORE ) mips_last_74k_agen_insn = type ;


<s> store_pos = - <NUM_LIT> ; load_pos = - <NUM_LIT> ; for ( i = nready - <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) { rtx_insn * insn = ready [ i ] ; if ( USEFUL_INSN_P ( insn ) ) switch ( get_attr_type ( insn ) ) { case TYPE_STORE : if ( store_pos == - <NUM_LIT> ) store_pos = i ; break ;


<s> load_pos = - <NUM_LIT> ; for ( i = nready - <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) { rtx_insn * insn = ready [ i ] ; if ( USEFUL_INSN_P ( insn ) ) switch ( get_attr_type ( insn ) ) { case TYPE_STORE : if ( store_pos == - <NUM_LIT> ) store_pos = i ;


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

return ( mips_classify_address ( & addr , x , mode , false ) && addr . type == ADDRESS_REG && CONST_INT_P ( addr . offset ) && MIPS_9BIT_OFFSET_P ( INTVAL ( addr . offset ) ) ) ;


<s> return mips_address_insns ( addr , mode , false ) ;


<s> if ( mips_classify_address ( & addr , x , mode , false ) ) switch ( addr . type ) { case ADDRESS_REG : if ( msa_p ) { if ( mips_signed_immediate_p ( INTVAL ( addr . offset ) , <NUM_LIT> , mips_ldst_scaled_shift ( mode ) ) ) return <NUM_LIT> ; else return <NUM_LIT> ; } if ( TARGET_MIPS16 && ! mips16_unextended_reference_p ( mode , addr . reg , UINTVAL ( addr . offset ) ) ) return factor * <NUM_LIT> ;


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


<s> static void mips_add_cfa_restore ( rtx reg ) {


<s> rtx high ; if ( TARGET_MIPS16 ) { high = GEN_INT ( offset ) ; offset = <NUM_LIT> ; } else { high = gen_int_mode ( CONST_HIGH_PART ( offset ) , Pmode ) ; offset = CONST_LOW_PART ( offset ) ;


<s> } else { high = gen_int_mode ( CONST_HIGH_PART ( offset ) , Pmode ) ; offset = CONST_LOW_PART ( offset ) ; } high = mips_force_temporary ( temp , high ) ; reg = mips_force_temporary ( temp , gen_rtx_PLUS ( Pmode , high , reg ) ) ; } return plus_constant ( Pmode , reg , offset ) ;


<s> static void mips_adjust_block_mem ( rtx mem , HOST_WIDE_INT length , rtx * loop_reg , rtx * loop_mem ) {

* loop_reg = copy_addr_to_reg ( XEXP ( mem , <NUM_LIT> ) ) ;


<s> if ( dep_type != <NUM_LIT> && ( dep_type != REG_DEP_OUTPUT || ! TUNE_20KC ) ) return <NUM_LIT> ; return cost ;


<s> if ( dep_type != <NUM_LIT> && ( dep_type != REG_DEP_OUTPUT || ! TUNE_20KC ) ) return <NUM_LIT> ;


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


<s> else if ( mode == CCV2mode ) count = <NUM_LIT> ; else if ( mode == CCV4mode ) count = <NUM_LIT> ; else gcc_unreachable ( ) ; cfun -> machine -> next_fcc += - cfun -> machine -> next_fcc & ( count - <NUM_LIT> ) ; if ( cfun -> machine -> next_fcc > ST_REG_LAST - ST_REG_FIRST ) cfun -> machine -> next_fcc = <NUM_LIT> ;

regno = ST_REG_FIRST + cfun -> machine -> next_fcc ;


<s> unsigned int regno , count ; gcc_assert ( TARGET_HARD_FLOAT && ISA_HAS_8CC ) ; if ( mode == CCmode ) count = <NUM_LIT> ; else if ( mode == CCV2mode ) count = <NUM_LIT> ; else if ( mode == CCV4mode ) count = <NUM_LIT> ; else gcc_unreachable ( ) ;

cfun -> machine -> next_fcc += - cfun -> machine -> next_fcc & ( count - <NUM_LIT> ) ;


<s> static void mips_annotate_pic_calls ( void ) { basic_block bb ; rtx_insn * insn ; FOR_EACH_BB_FN ( bb , cfun ) FOR_BB_INSNS ( bb , insn ) { rtx call , reg , symbol , second_call ; second_call = <NUM_LIT> ; call = mips_call_expr_from_insn ( insn , & second_call ) ; if ( ! call ) continue ; gcc_assert ( MEM_P ( XEXP ( call , <NUM_LIT> ) ) ) ; reg = XEXP ( XEXP ( call , <NUM_LIT> ) , <NUM_LIT> ) ; if ( ! REG_P ( reg ) ) continue ; symbol = mips_find_pic_call_symbol ( insn , reg , true ) ; if ( symbol ) { mips_annotate_pic_call_expr ( call , symbol ) ;

if ( second_call ) mips_annotate_pic_call_expr ( second_call , symbol ) ;


<s> XEXP ( call , <NUM_LIT> ) = gen_rtx_UNSPEC ( GET_MODE ( args_size ) , gen_rtvec ( <NUM_LIT> , args_size , symbol ) , UNSPEC_CALL_ATTR ) ;


<s> static int mips_arg_partial_bytes ( cumulative_args_t cum , const function_arg_info & arg ) { struct mips_arg_info info ; mips_get_arg_info ( & info , get_cumulative_args ( cum ) , arg . mode , arg . type , arg . named ) ; return info . stack_words > <NUM_LIT> ? info . reg_words * UNITS_PER_WORD : <NUM_LIT> ;


<s> if ( ! info -> fpr_p || ! hard_float_p ) return GP_ARG_FIRST + info -> reg_offset ; else if ( mips_abi == ABI_32 && TARGET_DOUBLE_FLOAT && info -> reg_offset > <NUM_LIT> ) return FP_ARG_FIRST + <NUM_LIT> ; else return FP_ARG_FIRST + info -> reg_offset ;


<s> static unsigned int mips_autovectorize_vector_modes ( vector_modes * modes , bool ) {

if ( ISA_HAS_MSA ) modes -> safe_push ( V16QImode ) ;


<s> else if ( * fs_delay && get_attr_can_delay ( insn ) == CAN_DELAY_NO && GET_CODE ( PATTERN ( after ) ) != SEQUENCE && GET_CODE ( pattern ) != ASM_INPUT && asm_noperands ( pattern ) < <NUM_LIT> ) nops = <NUM_LIT> ; else if ( TUNE_P6600 && TARGET_CB_MAYBE && ! optimize_size && ( ( mips_classify_branch_p6600 ( after ) == UC_BALC && mips_classify_branch_p6600 ( insn ) == UC_OTHER ) || ( mips_classify_branch_p6600 ( insn ) == UC_BALC && mips_classify_branch_p6600 ( after ) == UC_OTHER ) ) ) nops = <NUM_LIT> ; else nops = <NUM_LIT> ; * hilo_delay += nops ; rtx_insn * real_after = after ; if ( real_after && nops && CALL_P ( real_after ) ) while ( real_after && ( NOTE_P ( NEXT_INSN ( real_after ) ) || BARRIER_P ( NEXT_INSN ( real_after ) ) ) ) real_after = NEXT_INSN ( real_after ) ; while ( nops -- > <NUM_LIT> ) emit_insn_after ( gen_hazard_nop ( ) , real_after ) ; * hilo_delay += ninsns ; * delayed_reg = <NUM_LIT> ; * fs_delay = false ; if ( INSN_CODE ( insn ) >= <NUM_LIT> ) switch ( get_attr_hazard ( insn ) ) { case HAZARD_NONE : if ( TUNE_P6600 && ! optimize_size && TARGET_CB_MAYBE && mips_classify_branch_p6600 ( insn ) == UC_OTHER ) * fs_delay = true ; break ; case HAZARD_FORBIDDEN_SLOT : if ( TARGET_CB_MAYBE ) * fs_delay = true ; break ; case HAZARD_HILO : * hilo_delay = <NUM_LIT> ; break ; case HAZARD_DELAY : set = single_set ( insn ) ; gcc_assert ( set ) ;


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


<s> if ( GET_MODE_SIZE ( GET_MODE ( x ) ) == UNITS_PER_WORD * <NUM_LIT> ) cost = double_cost ; else cost = single_cost ; return ( cost + set_src_cost ( XEXP ( x , <NUM_LIT> ) , GET_MODE ( x ) , speed ) + rtx_cost ( XEXP ( x , <NUM_LIT> ) , GET_MODE ( x ) , GET_CODE ( x ) , <NUM_LIT> , speed ) ) ;


<s> static void mips_block_move_loop ( rtx dest , rtx src , HOST_WIDE_INT length , HOST_WIDE_INT bytes_per_iter ) { rtx_code_label * label ; rtx src_reg , dest_reg , final_src , test ; HOST_WIDE_INT leftover ; leftover = length % bytes_per_iter ; length -= leftover ; mips_adjust_block_mem ( src , bytes_per_iter , & src_reg , & src ) ;

mips_adjust_block_mem ( dest , bytes_per_iter , & dest_reg , & dest ) ;


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

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


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


<s> static bool mips_breakable_sequence_p ( rtx_insn * insn ) {

return ( insn && GET_CODE ( PATTERN ( insn ) ) == SEQUENCE && TARGET_CB_MAYBE && get_attr_compact_form ( SEQ_BEGIN ( insn ) ) != COMPACT_FORM_NEVER ) ;


<s> remove_insn ( insn ) ; add_insn_after ( ds , before , NULL ) ;


if ( cache == NULL_TREE ) cache = build_pointer_type ( build_qualified_type ( void_type_node , TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE ) ) ;


<s> unsigned int cost , alt_cost ; cost = mips_build_shift ( codes , value ) ; alt_cost = mips_build_lower ( alt_codes , value ) ; if ( alt_cost < cost ) { memcpy ( codes , alt_codes , alt_cost * sizeof ( codes [ <NUM_LIT> ] ) ) ; cost = alt_cost ; }


<s> unsigned HOST_WIDE_INT high ; unsigned int i ; high = value & ~ ( unsigned HOST_WIDE_INT ) <NUM_LIT> ; if ( ! LUI_OPERAND ( high ) && ( value & <NUM_LIT> ) == <NUM_LIT> ) { i = mips_build_integer ( codes , CONST_HIGH_PART ( value ) ) ;


<s> codes [ i ] . code = PLUS ; codes [ i ] . value = CONST_LOW_PART ( value ) ; } else { i = mips_build_integer ( codes , high ) ;


<s> i = mips_build_integer ( codes , value ) ; codes [ i ] . code = ASHIFT ; codes [ i ] . value = shift ; return i + <NUM_LIT> ;


<s> i = mips_build_integer ( codes , value ) ; codes [ i ] . code = ASHIFT ;


<s> emit_jump_insn ( gen_condjump ( condition , true_label ) ) ; emit_jump_insn ( gen_jump ( done_label ) ) ; emit_barrier ( ) ; emit_label ( true_label ) ; mips_emit_move ( target , value_if_true ) ; emit_label ( done_label ) ;


<s> static tree mips_builtin_decl ( unsigned int code , bool initialize_p ATTRIBUTE_UNUSED ) {

if ( code >= ARRAY_SIZE ( mips_builtins ) ) return error_mark_node ;


<s> case BUILT_IN_SQRT : if ( out_mode == DFmode && out_n == <NUM_LIT> && in_mode == DFmode && in_n == <NUM_LIT> ) return MIPS_GET_BUILTIN ( msa_fsqrt_d ) ; break ; case BUILT_IN_SQRTF :

if ( out_mode == SFmode && out_n == <NUM_LIT> && in_mode == SFmode && in_n == <NUM_LIT> ) return MIPS_GET_BUILTIN ( msa_fsqrt_w ) ;


<s> out_n = TYPE_VECTOR_SUBPARTS ( type_out ) ; in_mode = TYPE_MODE ( TREE_TYPE ( type_in ) ) ; in_n = TYPE_VECTOR_SUBPARTS ( type_in ) ; mips_builtin_decls [ mips_get_builtin_decl_index [ CODE_FOR_ ## INSN ] ] switch ( fn ) { case BUILT_IN_SQRT : if ( out_mode == DFmode && out_n == <NUM_LIT> && in_mode == DFmode && in_n == <NUM_LIT> ) return MIPS_GET_BUILTIN ( msa_fsqrt_d ) ;


<s> static tree types [ <NUM_LIT> * ( int ) MAX_MACHINE_MODE ] ; int mode_index ; mode_index = ( int ) mode ; if ( TREE_CODE ( type ) == INTEGER_TYPE && TYPE_UNSIGNED ( type ) ) mode_index += MAX_MACHINE_MODE ;

if ( types [ mode_index ] == NULL_TREE ) types [ mode_index ] = build_vector_type_for_mode ( type , mode ) ;


<s> static bool mips_callee_copies ( cumulative_args_t , const function_arg_info & arg ) { return mips_abi == ABI_EABI && arg . named ;


<s> if ( TARGET_INTERLINK_COMPRESSED ) { if ( ! TARGET_COMPRESSION && mips_get_compress_off_flags ( DECL_ATTRIBUTES ( decl ) ) == <NUM_LIT> ) return true ; if ( TARGET_COMPRESSION && mips_get_compress_on_flags ( DECL_ATTRIBUTES ( decl ) ) == <NUM_LIT> ) return true ; }


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


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


<s> break ; case LEU : plus_one = trunc_int_for_mode ( UINTVAL ( * cmp1 ) + <NUM_LIT> , mode ) ; if ( plus_one != <NUM_LIT> ) { * code = LTU ; * cmp1 = force_reg ( mode , GEN_INT ( plus_one ) ) ; return true ; } break ; default : break ; }


<s> if ( TARGET_MIPS16 && reg_class_subset_p ( rclass , M16_REGS ) ) rclass = M16_REGS ; else if ( reg_class_subset_p ( rclass , GENERAL_REGS ) ) rclass = GENERAL_REGS ;


<s> if ( reg_class_subset_p ( rclass , ACC_REGS ) ) rclass = ACC_REGS ; if ( TARGET_MIPS16 && reg_class_subset_p ( rclass , M16_REGS ) ) rclass = M16_REGS ; else if ( reg_class_subset_p ( rclass , GENERAL_REGS ) ) rclass = GENERAL_REGS ;


<s> static bool mips_can_change_mode_class ( machine_mode from , machine_mode to , reg_class_t rclass ) {

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


<s> return ( to == HARD_FRAME_POINTER_REGNUM || to == STACK_POINTER_REGNUM ) ;


<s> static bool mips_can_eliminate ( const int from ATTRIBUTE_UNUSED , const int to ) {

return ( to == HARD_FRAME_POINTER_REGNUM || to == STACK_POINTER_REGNUM ) ;


<s> static bool mips_can_inline_p ( tree caller , tree callee ) { if ( mips_get_compress_mode ( callee ) != mips_get_compress_mode ( caller ) ) return false ;

return default_target_can_inline_p ( caller , callee ) ;


<s> if ( crtl -> profile ) return false ; if ( mips16_cfun_returns_in_fpr_p ( ) ) return false ;

return ( cfun -> machine -> frame . total_size == <NUM_LIT> && ! cfun -> machine -> use_frame_header_for_callee_saved_regs ) ;


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


<s> unsigned int mips_case_values_threshold ( void ) {

if ( TARGET_MIPS16 && optimize_size ) return <NUM_LIT> ;


<s> return ( mips_r10k_cache_barrier != R10K_CACHE_BARRIER_NONE || TARGET_RELAX_PIC_CALLS ) ;


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

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


<s> if ( cfun -> machine -> interrupt_handler_p && mips_interrupt_extra_call_saved_reg_p ( regno ) ) return true ; return ( regno == GLOBAL_POINTER_REGNUM ? TARGET_CALL_SAVED_GP : ! call_used_regs [ regno ] ) ;


<s> return ( cfun -> machine -> global_pointer != INVALID_REGNUM && cfun -> machine -> frame . cprestore_size > <NUM_LIT> ) ;


<s> if ( TARGET_ABICALLS_PIC2 && ! reload_completed && crtl -> uses_const_pool ) return true ;

return mips_find_gp_ref ( & cfun -> machine -> has_flexible_gp_insn_p , mips_insn_has_flexible_gp_ref_p ) ;


<s> static bool mips_cfun_has_flexible_gp_ref_p ( void ) { if ( TARGET_ABICALLS_PIC2 && ! reload_completed && crtl -> uses_const_pool ) return true ; return mips_find_gp_ref ( & cfun -> machine -> has_flexible_gp_insn_p , mips_insn_has_flexible_gp_ref_p ) ;


<s> static bool mips_cfun_has_inflexible_gp_ref_p ( void ) { if ( crtl -> has_nonlocal_goto ) return true ; if ( TARGET_ABICALLS_PIC2 ) { if ( ! TARGET_EXPLICIT_RELOCS ) return true ; if ( crtl -> profile ) return true ; if ( mips16_cfun_returns_in_fpr_p ( ) ) return true ; }

return mips_find_gp_ref ( & cfun -> machine -> has_inflexible_gp_insn_p , mips_insn_has_inflexible_gp_ref_p ) ;


<s> if ( regno == RETURN_ADDR_REGNUM && mips16_cfun_returns_in_fpr_p ( ) ) return true ; if ( cfun -> machine -> interrupt_handler_p && ! crtl -> is_leaf && mips_interrupt_extra_call_saved_reg_p ( regno ) ) return true ;


<s> if ( cfun -> machine -> global_pointer == regno ) return true ; if ( regno == HARD_FRAME_POINTER_REGNUM && frame_pointer_needed ) return true ; if ( regno == RETURN_ADDR_REGNUM && mips16_cfun_returns_in_fpr_p ( ) ) return true ; if ( cfun -> machine -> interrupt_handler_p && ! crtl -> is_leaf && mips_interrupt_extra_call_saved_reg_p ( regno ) ) return true ;


<s> case SUBREG : info -> type = ADDRESS_REG ; info -> reg = x ; info -> offset = const0_rtx ; return mips_valid_base_register_p ( info -> reg , mode , strict_p ) ; case PLUS : info -> type = ADDRESS_REG ; info -> reg = XEXP ( x , <NUM_LIT> ) ; info -> offset = XEXP ( x , <NUM_LIT> ) ; return ( mips_valid_base_register_p ( info -> reg , mode , strict_p ) && mips_valid_offset_p ( info -> offset , mode ) ) ; case LO_SUM : info -> type = ADDRESS_LO_SUM ; info -> reg = XEXP ( x , <NUM_LIT> ) ; info -> offset = XEXP ( x , <NUM_LIT> ) ; info -> symbol_type = mips_classify_symbolic_expression ( info -> offset , SYMBOL_CONTEXT_MEM ) ; return ( mips_valid_base_register_p ( info -> reg , mode , strict_p ) && mips_valid_lo_sum_p ( info -> symbol_type , mode ) ) ; case CONST_INT : info -> type = ADDRESS_CONST_INT ; return ! TARGET_MIPS16 && SMALL_INT ( x ) ; case CONST : case LABEL_REF : case SYMBOL_REF : info -> type = ADDRESS_SYMBOLIC ; return ( mips_symbolic_constant_p ( x , SYMBOL_CONTEXT_MEM , & info -> symbol_type ) && mips_symbol_insns ( info -> symbol_type , mode ) > <NUM_LIT> && ! mips_split_p [ info -> symbol_type ] ) ;


<s> if ( get_attr_jal ( insn ) == JAL_INDIRECT || get_attr_type ( insn ) == TYPE_JUMP ) return UC_OTHER ; if ( CALL_P ( insn ) && get_attr_jal ( insn ) == JAL_DIRECT ) return UC_BALC ; return UC_UNDEFINED ;


<s> if ( TARGET_MIPS16_PCREL_LOADS && context == SYMBOL_CONTEXT_MEM ) return SYMBOL_PC_RELATIVE ; if ( mips_rtx_constant_in_small_data_p ( get_pool_mode ( x ) ) ) return SYMBOL_GP_RELATIVE ; } if ( TARGET_GPOPT && SYMBOL_REF_SMALL_P ( x ) && ! SYMBOL_REF_WEAK ( x ) ) return SYMBOL_GP_RELATIVE ; if ( TARGET_ABICALLS_PIC2 && ! ( TARGET_ABSOLUTE_ABICALLS && mips_symbol_binds_local_p ( x ) ) ) { if ( mips_global_symbol_p ( x ) ) return SYMBOL_GOT_DISP ; return SYMBOL_GOT_PAGE_OFST ; }


<s> static enum mips_symbol_type mips_classify_symbolic_expression ( rtx x , enum mips_symbol_context context ) {


<s> if ( mips_hard_regno_mode_ok ( ST_REG_FIRST , mode ) ) size = MIN ( size , <NUM_LIT> ) ; left &= ~ reg_class_contents [ ST_REGS ] ; } if ( hard_reg_set_intersect_p ( left , reg_class_contents [ ( int ) FP_REGS ] ) ) { if ( mips_hard_regno_mode_ok ( FP_REG_FIRST , mode ) ) { if ( MSA_SUPPORTED_MODE_P ( mode ) ) size = MIN ( size , UNITS_PER_MSA_REG ) ; else size = MIN ( size , UNITS_PER_FPREG ) ; } left &= ~ reg_class_contents [ FP_REGS ] ; } if ( ! hard_reg_set_empty_p ( left ) ) size = MIN ( size , UNITS_PER_WORD ) ;

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


<s> static void mips_code_end ( void ) { mips_finish_stub ( & mips16_rdhwr_stub ) ; mips_finish_stub ( & mips16_get_fcsr_stub ) ; mips_finish_stub ( & mips16_set_fcsr_stub ) ;


<s> static void mips_code_end ( void ) {

mips_finish_stub ( & mips16_rdhwr_stub ) ;


<s> if ( mips_far_type_p ( type1 ) && mips_near_type_p ( type2 ) ) return <NUM_LIT> ; if ( mips_near_type_p ( type1 ) && mips_far_type_p ( type2 ) ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> static HOST_WIDE_INT mips_constant_alignment ( const_tree exp , HOST_WIDE_INT align ) { if ( TREE_CODE ( exp ) == STRING_CST || TREE_CODE ( exp ) == CONSTRUCTOR ) return MAX ( align , BITS_PER_WORD ) ;


<s> if ( TREE_CODE ( exp ) == STRING_CST || TREE_CODE ( exp ) == CONSTRUCTOR ) return MAX ( align , BITS_PER_WORD ) ; return align ;


<s> static inline bool mips_constant_elt_p ( rtx x ) { return CONST_INT_P ( x ) || GET_CODE ( x ) == CONST_DOUBLE ;


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


<s> bool mips_const_vector_bitimm_clr_p ( rtx op , machine_mode mode ) { if ( GET_CODE ( op ) == CONST_VECTOR && op != CONSTM1_RTX ( mode ) ) { unsigned HOST_WIDE_INT val = ~ UINTVAL ( CONST_VECTOR_ELT ( op , <NUM_LIT> ) ) ; int vlog2 = exact_log2 ( val & GET_MODE_MASK ( GET_MODE_INNER ( mode ) ) ) ; if ( vlog2 != - <NUM_LIT> ) {

gcc_assert ( GET_MODE_CLASS ( mode ) == MODE_VECTOR_INT ) ;


<s> int vlog2 = exact_log2 ( val & GET_MODE_MASK ( GET_MODE_INNER ( mode ) ) ) ; if ( vlog2 != - <NUM_LIT> ) { gcc_assert ( GET_MODE_CLASS ( mode ) == MODE_VECTOR_INT ) ; gcc_assert ( vlog2 >= <NUM_LIT> && vlog2 <= GET_MODE_UNIT_BITSIZE ( mode ) - <NUM_LIT> ) ; return mips_const_vector_same_val_p ( op , mode ) ; } } return false ;


<s> val = INTVAL ( first ) ; first_byte = val & <NUM_LIT> ; for ( i = <NUM_LIT> ; i < bytes ; i ++ ) { val >>= <NUM_LIT> ; if ( ( val & <NUM_LIT> ) != first_byte ) return false ; }


<s> if ( ! mips_const_vector_same_val_p ( op , mode ) ) return false ; elem0 = CONST_VECTOR_ELT ( op , <NUM_LIT> ) ;

if ( ! CONST_INT_P ( elem0 ) ) return false ;


<s> if ( GET_CODE ( op ) != CONST_VECTOR || GET_MODE ( op ) != mode ) return false ; first = CONST_VECTOR_ELT ( op , <NUM_LIT> ) ; for ( i = <NUM_LIT> ; i < nunits ; i ++ ) if ( ! rtx_equal_p ( first , CONST_VECTOR_ELT ( op , i ) ) ) return false ;


<s> int set = <NUM_LIT> ; int i , j ; for ( j = <NUM_LIT> ; j < nsets ; j ++ , set = <NUM_LIT> * j ) for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( ( INTVAL ( XVECEXP ( op , <NUM_LIT> , i ) ) != ( INTVAL ( XVECEXP ( op , <NUM_LIT> , set + i ) ) - set ) ) || ! IN_RANGE ( INTVAL ( XVECEXP ( op , <NUM_LIT> , set + i ) ) , <NUM_LIT> , set + <NUM_LIT> ) ) return false ; return true ;


<s> int nunits = GET_MODE_NUNITS ( mode ) ; int nsets = nunits / <NUM_LIT> ; int set = <NUM_LIT> ; int i , j ;

for ( j = <NUM_LIT> ; j < nsets ; j ++ , set = <NUM_LIT> * j ) for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( ( INTVAL ( XVECEXP ( op , <NUM_LIT> , i ) ) != ( INTVAL ( XVECEXP ( op , <NUM_LIT> , set + i ) ) - set ) ) || ! IN_RANGE ( INTVAL ( XVECEXP ( op , <NUM_LIT> , set + i ) ) , <NUM_LIT> , set + <NUM_LIT> ) ) return false ;


<s> mips_split_plus ( x , & given_base , & given_offset ) ; mips_get_cprestore_base_and_offset ( & required_base , & required_offset , load_p ) ;


mips_split_plus ( x , & given_base , & given_offset ) ;


mips_get_cprestore_base_and_offset ( & base , & offset , load_p ) ;


<s> return gen_frame_mem ( Pmode , mips_add_offset ( temp , base , offset ) ) ;


<s> static const struct mips_cpu_info * mips_cpu_info_from_isa ( int isa ) { unsigned int i ;

for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( mips_cpu_info_table ) ; i ++ ) if ( mips_cpu_info_table [ i ] . isa == isa ) return mips_cpu_info_table + i ;


<s> for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( mips_cpu_info_table ) ; i ++ ) if ( mips_cpu_info_table [ i ] . isa == isa ) return mips_cpu_info_table + i ; return NULL ;


<s> case MIPS_ARCH_OPTION_FROM_ABI : return mips_cpu_info_from_isa ( ABI_NEEDS_32BIT_REGS ? <NUM_LIT> : ABI_NEEDS_64BIT_REGS ? <NUM_LIT> : ( TARGET_64BIT ? <NUM_LIT> : <NUM_LIT> ) ) ; case MIPS_ARCH_OPTION_NATIVE : gcc_unreachable ( ) ; default : return & mips_cpu_info_table [ opt ] ; }


<s> if ( TARGET_RTP_PIC ) return LOADGP_RTP ; if ( TARGET_ABSOLUTE_ABICALLS ) return LOADGP_ABSOLUTE ; return TARGET_NEWABI ? LOADGP_NEWABI : LOADGP_OLDABI ;


<s> if ( ! TARGET_USE_GOT || cfun -> machine -> global_pointer == INVALID_REGNUM ) return LOADGP_NONE ; if ( TARGET_RTP_PIC ) return LOADGP_RTP ; if ( TARGET_ABSOLUTE_ABICALLS ) return LOADGP_ABSOLUTE ; return TARGET_NEWABI ? LOADGP_NEWABI : LOADGP_OLDABI ;


<s> static void mips_deallocate_stack ( rtx base , rtx offset , HOST_WIDE_INT new_frame_size ) { if ( base == stack_pointer_rtx && offset == const0_rtx ) return ; mips_frame_barrier ( ) ; if ( offset == const0_rtx ) { emit_move_insn ( stack_pointer_rtx , base ) ; mips_epilogue_set_cfa ( stack_pointer_rtx , new_frame_size ) ; } else if ( TARGET_MIPS16 && base != stack_pointer_rtx ) { emit_insn ( gen_add3_insn ( base , base , offset ) ) ; mips_epilogue_set_cfa ( base , new_frame_size ) ; emit_move_insn ( stack_pointer_rtx , base ) ; } else { emit_insn ( gen_add3_insn ( stack_pointer_rtx , base , offset ) ) ;


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

offset -= cfun -> machine -> frame . total_size ;


<s> size -= size % ( align / BITS_PER_UNIT ) ; mips_declare_object ( stream , name , init_string , <STR_LIT> HOST_WIDE_INT_PRINT_UNSIGNED <STR_LIT> , size ) ; } else mips_declare_object ( stream , name , init_string , <STR_LIT> HOST_WIDE_INT_PRINT_UNSIGNED <STR_LIT> , size , align / BITS_PER_UNIT ) ;


<s> assemble_name ( stream , name ) ; va_start ( ap , final_string ) ; vfprintf ( stream , final_string , ap ) ; va_end ( ap ) ; if ( ! TARGET_EXPLICIT_RELOCS ) { tree name_tree = get_identifier ( name ) ; TREE_ASM_WRITTEN ( name_tree ) = <NUM_LIT> ;


<s> static const struct mips_cpu_info * mips_default_arch ( void ) { unsigned int i ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( mips_cpu_info_table ) ; i ++ ) if ( strcmp ( mips_cpu_info_table [ i ] . name , MIPS_CPU_STRING_DEFAULT ) == <NUM_LIT> ) return mips_cpu_info_table + i ;


<s> static void mips_dfa_post_advance_cycle ( void ) { if ( TUNE_LOONGSON_2EF ) mips_ls2_dfa_post_advance_cycle ( curr_state ) ;


<s> static void mips_dfa_post_advance_cycle ( void ) {

if ( TUNE_LOONGSON_2EF ) mips_ls2_dfa_post_advance_cycle ( curr_state ) ;


<s> if ( mips_r10k_cache_barrier != R10K_CACHE_BARRIER_NONE ) r10k_insert_cache_barriers ( ) ; df_finish_pass ( false ) ;


<s> if ( TARGET_MIPS16 && ! load_p && regno == RETURN_ADDR_REGNUM ) return false ; return mips_secondary_reload_class ( REGNO_REG_CLASS ( regno ) , GET_MODE ( mem ) , mem , load_p ) == NO_REGS ;


<s> int mips_dspalu_bypass_p ( rtx out_insn , rtx in_insn ) { int i ; int num_bypass = ARRAY_SIZE ( dspalu_bypass_table ) ; enum insn_code out_icode = ( enum insn_code ) INSN_CODE ( out_insn ) ;


<s> enum insn_code in_icode = ( enum insn_code ) INSN_CODE ( in_insn ) ; for ( i = <NUM_LIT> ; i < num_bypass ; i ++ ) { if ( out_icode == dspalu_bypass_table [ i ] [ <NUM_LIT> ] && in_icode == dspalu_bypass_table [ i ] [ <NUM_LIT> ] ) return true ; }


<s> machine_mode mode = default_dwarf_frame_reg_mode ( regno ) ; if ( FP_REG_P ( regno ) && mips_abi == ABI_32 && ! TARGET_FLOAT32 ) mode = SImode ; return mode ;