<s> return false ; case USE : * total = <NUM_LIT> ; break ; case CONST_INT : if ( outer_code == SET ) { if ( satisfies_constraint_Is05 ( x ) ) * total = COSTS_N_INSNS ( <NUM_LIT> ) - <NUM_LIT> ; else if ( satisfies_constraint_Is20 ( x ) ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; } else if ( outer_code == PLUS || outer_code == MINUS ) { if ( satisfies_constraint_Iu05 ( x ) ) * total = COSTS_N_INSNS ( <NUM_LIT> ) - <NUM_LIT> ; else * total = COSTS_N_INSNS


<s> case CONST_INT : if ( outer_code == SET ) { if ( satisfies_constraint_Is05 ( x ) ) * total = COSTS_N_INSNS ( <NUM_LIT> ) - <NUM_LIT> ; else if ( satisfies_constraint_Is20 ( x ) ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; } else if ( outer_code == PLUS || outer_code == MINUS ) { if ( satisfies_constraint_Iu05 ( x ) ) * total = COSTS_N_INSNS ( <NUM_LIT> ) - <NUM_LIT> ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; } else if ( outer_code == ASHIFT ) { if ( satisfies_constraint_Iu03 ( x ) ) * total = COSTS_N_INSNS ( <NUM_LIT> ) - <NUM_LIT> ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; } else if ( outer_code == ASHIFTRT || outer_code == LSHIFTRT ) { if ( satisfies_constraint_Iu05 ( x ) ) * total = COSTS_N_INSNS ( <NUM_LIT> ) - <NUM_LIT> ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; } else { * total = COSTS_N_INSNS ( <NUM_LIT> ) ; } break ; case CONST_DOUBLE : * total = COSTS_N_INSNS (


<s> if ( speed ) goto performance_cost ; else goto size_cost ; performance_cost : switch ( code ) { case SET : return false ; case USE : * total = <NUM_LIT> ; break ; case MULT : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case DIV : case UDIV : case MOD : case UMOD : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; default : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; } return true ; size_cost : switch ( code ) { case SET : return false ; case USE : * total = <NUM_LIT> ; break ; case CONST_INT : if ( outer_code ==


<s> if ( speed_p ) { if ( current_pass -> tv_id == TV_FWPROP ) return nds32_address_cost_speed_fwprop ( address


<s> plus0 = XEXP ( address , <NUM_LIT> ) ; plus1 = XEXP ( address , <NUM_LIT> ) ; if ( REG_P ( plus0 ) && CONST_INT_P ( plus1 ) ) { if ( satisfies_constraint_Iu03 ( plus1 ) ) return ( COSTS_N_INSNS ( <NUM_LIT> ) - <NUM_LIT> ) ; else return COSTS_N_INSNS ( <NUM_LIT>


<s> return COSTS_N_INSNS ( <NUM_LIT> ) - <NUM_LIT> ; case SYMBOL_REF : return COSTS_N_INSNS ( <NUM_LIT> ) ; case CONST : return COSTS_N_INSNS ( <NUM_LIT> ) ; case REG : return COSTS_N_INSNS ( <NUM_LIT> ) - <NUM_LIT> ; case PLUS : plus0 = XEXP ( address , <NUM_LIT> ) ; plus1 = XEXP ( address , <NUM_LIT> ) ; if ( REG_P ( plus0 ) && CONST_INT_P ( plus1 ) ) return COSTS_N_INSNS ( <NUM_LIT> )


<s> void nds32_init_rtx_costs ( void ) { rtx_cost_model . speed_prefer


<s> bool nds32_rtx_costs_impl ( rtx x , machine_mode mode ATTRIBUTE_UNUSED , int outer_code , int opno , int * total , bool speed ) { int code = GET_CODE ( x ) ; if ( speed ) return rtx_cost_model . speed_prefer ( x ,


<s> else if ( outer_code == ASHIFT ) { if ( satisfies_constraint_Iu03 ( x ) ) * total = insn_size_16bit ; else * total = insn_size_32bit ; } else if ( outer_code == ASHIFTRT || outer_code == LSHIFTRT ) { if ( satisfies_constraint_Iu05 ( x ) ) * total = insn_size_16bit ; else * total = insn_size_32bit ; } else { * total = insn_size_32bit ; } break ; case CONST_DOUBLE : * total = insn_size_32bit * <NUM_LIT> ; break ; case CONST : case SYMBOL_REF : * total = insn_size_32bit * <NUM_LIT> ; break ; default : * total = insn_size_32bit ; break ; } return true


<s> int nds32_fp_as_gp_check_available (


<s> if ( single_set ( insn ) && nds32_symbol_load_store_p ( insn ) ) { rtx pattern = PATTERN ( insn ) ; rtx mem ; gcc_assert ( GET_CODE ( pattern ) == SET ) ; if ( GET_CODE ( SET_SRC ( pattern ) ) == REG ) mem = SET_DEST ( pattern ) ; else mem = SET_SRC ( pattern ) ; if ( GET_CODE ( mem ) == MEM ) symbol_count


<s> if ( ! dominated_by_p ( CDI_POST_DOMINATORS , bb ,


<s> if ( ! first_exit_blocks_p ) return false ; exit_bb = e -> src ; first_exit_blocks_p = false


<s> return ! TARGET_LINUX_ABI && TARGET_16_BIT &&


<s> bool gate ( function * ) { return ! TARGET_LINUX_ABI &&


<s> if ( ! first_exit_blocks_p ) return false ; exit_bb = e -> src ; first_exit_blocks_p = false ; } if ( ! exit_bb ) return false ; FOR_EACH_BB_FN ( bb , cfun ) { if ( ! dominated_by_p ( CDI_POST_DOMINATORS , bb , exit_bb ) ) return false ; } if ( TARGET_FORCE_FP_AS_GP ) { return true ; } else { bool good_gain = false ; int symbol_count ; int threshold ; if ( flag_pic || nds32_have_prologue_p ( ) ) { threshold = <NUM_LIT> ; } else { threshold = <NUM_LIT> + ( TARGET_V3PUSH ? <NUM_LIT> : <NUM_LIT> ) ; } symbol_count = nds32_get_symbol_count ( )


<s> FOR_EACH_BB_FN ( bb , cfun ) { FOR_BB_INSNS ( bb , insn ) { if ( single_set ( insn ) && nds32_symbol_load_store_p ( insn ) ) { rtx pattern = PATTERN ( insn ) ; rtx mem ; gcc_assert ( GET_CODE ( pattern ) == SET ) ; if ( GET_CODE ( SET_SRC ( pattern ) ) == REG ) mem = SET_DEST ( pattern ) ; else mem = SET_SRC ( pattern ) ; if ( GET_CODE ( mem ) == MEM ) symbol_count ++ ; } } } return


<s> emit_insn ( gen_unspec_volatile_isb ( ) ) ; return target ; case NDS32_BUILTIN_MFSR : return nds32_expand_builtin_reg_ftype_imm ( CODE_FOR_unspec_volatile_mfsr , exp , target ) ; case NDS32_BUILTIN_MFUSR : return nds32_expand_builtin_reg_ftype_imm ( CODE_FOR_unspec_volatile_mfusr , exp , target ) ; case NDS32_BUILTIN_MTSR : return nds32_expand_builtin_null_ftype_reg_imm ( CODE_FOR_unspec_volatile_mtsr , exp , target ) ; case NDS32_BUILTIN_MTUSR : return nds32_expand_builtin_null_ftype_reg_imm ( CODE_FOR_unspec_volatile_mtusr , exp , target ) ; case NDS32_BUILTIN_SETGIE_EN : emit_insn ( gen_unspec_volatile_setgie_en ( ) ) ; return target ; case NDS32_BUILTIN_SETGIE_DIS : emit_insn ( gen_unspec_volatile_setgie_dis ( ) ) ; return target ; default : gcc_unreachable (


<s> return nds32_expand_builtin_null_ftype_reg ( CODE_FOR_unspec_volatile_isync , exp , target ) ; case NDS32_BUILTIN_ISB : emit_insn ( gen_unspec_volatile_isb ( ) ) ; return target ; case NDS32_BUILTIN_MFSR : return nds32_expand_builtin_reg_ftype_imm ( CODE_FOR_unspec_volatile_mfsr , exp , target ) ; case NDS32_BUILTIN_MFUSR : return nds32_expand_builtin_reg_ftype_imm ( CODE_FOR_unspec_volatile_mfusr , exp , target ) ; case NDS32_BUILTIN_MTSR : return nds32_expand_builtin_null_ftype_reg_imm ( CODE_FOR_unspec_volatile_mtsr , exp , target ) ; case NDS32_BUILTIN_MTUSR : return nds32_expand_builtin_null_ftype_reg_imm ( CODE_FOR_unspec_volatile_mtusr , exp , target ) ; case NDS32_BUILTIN_SETGIE_EN : emit_insn ( gen_unspec_volatile_setgie_en ( ) ) ; return target ; case NDS32_BUILTIN_SETGIE_DIS : emit_insn ( gen_unspec_volatile_setgie_dis ( ) ) ; return target ; default : gcc_unreachable ( )


<s> value0 = expand_normal ( arg0 ) ; create_input_operand ( & ops [ <NUM_LIT> ] , value0 , TYPE_MODE ( TREE_TYPE ( arg0 ) ) ) ; if ( ! maybe_expand_insn ( icode , <NUM_LIT> , ops ) ) error ( <STR_LIT> ) ; return target


<s> create_input_operand ( & ops [ <NUM_LIT> ] , value0 , TYPE_MODE ( TREE_TYPE ( arg0 ) ) ) ; if ( ! maybe_expand_insn ( icode , <NUM_LIT> , ops ) ) error


<s> rtx value0 ; arg0 = CALL_EXPR_ARG ( exp , <NUM_LIT> ) ; value0 = expand_normal ( arg0 ) ; create_output_operand ( & ops [ <NUM_LIT> ] , target , TYPE_MODE ( TREE_TYPE ( exp ) ) ) ; create_input_operand ( & ops [ <NUM_LIT> ] , value0 , TYPE_MODE ( TREE_TYPE ( arg0 )


<s> ADD_NDS32_BUILTIN1 ( <STR_LIT> , unsigned , integer , GET_PENDING_INT ) ; ADD_NDS32_BUILTIN1 ( <STR_LIT> , unsigned , integer , GET_INT_PRIORITY ) ; ADD_NDS32_BUILTIN2 ( <STR_LIT> , void , integer , integer , SET_INT_PRIORITY ) ; ADD_NDS32_BUILTIN1 ( <STR_LIT> , void , integer , CLR_PENDING_HWINT ) ; ADD_NDS32_BUILTIN1 ( <STR_LIT> , void , integer , SET_TRIG_LEVEL ) ; ADD_NDS32_BUILTIN1 ( <STR_LIT> , void , integer , SET_TRIG_EDGE ) ; ADD_NDS32_BUILTIN1 ( <STR_LIT> , unsigned , integer , GET_TRIG_TYPE ) ; ADD_NDS32_BUILTIN1 ( <STR_LIT> , unsigned , ptr_uint , LLW ) ; ADD_NDS32_BUILTIN1 ( <STR_LIT> , unsigned , ptr_uint , LWUP ) ; ADD_NDS32_BUILTIN1 ( <STR_LIT> , char , ptr_uchar , LBUP ) ; ADD_NDS32_BUILTIN2 ( <STR_LIT> , unsigned , ptr_uint , unsigned , SCW ) ; ADD_NDS32_BUILTIN2 ( <STR_LIT> , void , ptr_uint , unsigned , SWUP ) ; ADD_NDS32_BUILTIN2 ( <STR_LIT> , void , ptr_uchar , char , SBUP ) ; ADD_NDS32_BUILTIN0 ( <STR_LIT> , void , CCTL_L1D_INVALALL ) ; ADD_NDS32_BUILTIN0 ( <STR_LIT> , void , CCTL_L1D_WBALL_ALVL ) ; ADD_NDS32_BUILTIN0 ( <STR_LIT> , void , CCTL_L1D_WBALL_ONE_LVL ) ; ADD_NDS32_BUILTIN2 ( <STR_LIT> , void , integer , ptr_uint , CCTL_VA_LCK ) ; ADD_NDS32_BUILTIN2 ( <STR_LIT> , void , integer , unsigned , CCTL_IDX_WBINVAL ) ; ADD_NDS32_BUILTIN2 ( <STR_LIT> , void , integer , ptr_uint , CCTL_VA_WBINVAL_L1 ) ; ADD_NDS32_BUILTIN2 ( <STR_LIT> , void , integer , ptr_uint , CCTL_VA_WBINVAL_LA ) ; ADD_NDS32_BUILTIN2 ( <STR_LIT> , unsigned , integer , unsigned , CCTL_IDX_READ ) ; ADD_NDS32_BUILTIN3 ( <STR_LIT> , void , integer , unsigned , unsigned , CCTL_IDX_WRITE ) ; ADD_NDS32_BUILTIN3 ( <STR_LIT> , void , ptr_uchar , unsigned , integer , DPREF_QW ) ; ADD_NDS32_BUILTIN3 ( <STR_LIT> , void , ptr_ushort , unsigned , integer , DPREF_HW ) ; ADD_NDS32_BUILTIN3 ( <STR_LIT> , void , ptr_uint , unsigned , integer , DPREF_W ) ; ADD_NDS32_BUILTIN3 ( <STR_LIT> , void , ptr_ulong , unsigned , integer , DPREF_DW ) ; ADD_NDS32_BUILTIN1 ( <STR_LIT> , integer , integer , ABS ) ; ADD_NDS32_BUILTIN2 ( <STR_LIT> , integer , integer , integer , AVE ) ; ADD_NDS32_BUILTIN2 ( <STR_LIT> , unsigned , unsigned , unsigned , BCLR ) ; ADD_NDS32_BUILTIN2 ( <STR_LIT> , unsigned , unsigned , unsigned , BSET ) ; ADD_NDS32_BUILTIN2 ( <STR_LIT> , unsigned , unsigned , unsigned , BTGL ) ; ADD_NDS32_BUILTIN2 ( <STR_LIT> , unsigned , unsigned , unsigned , BTST ) ; ADD_NDS32_BUILTIN2 ( <STR_LIT> , unsigned , integer , unsigned , CLIP ) ; ADD_NDS32_BUILTIN2 ( <STR_LIT> , integer , integer , unsigned , CLIPS ) ; ADD_NDS32_BUILTIN1 ( <STR_LIT> , unsigned , unsigned , CLZ ) ; ADD_NDS32_BUILTIN1 ( <STR_LIT> , unsigned , unsigned , CLO ) ; ADD_NDS32_BUILTIN3 ( <STR_LIT> , void , ptr_uint ,


<s> tree nds32_builtin_decl_impl ( unsigned code , bool initialize_p ATTRIBUTE_UNUSED ) { if ( code >= NDS32_BUILTIN_COUNT ) return error_mark_node ; return nds32_builtin_decls [


<s> return false ; } if ( ! ( * insn_data [ icode ] . operand [ opnum ] . predicate ) ( opval , VOIDmode ) ) { error ( <STR_LIT> , name ) ; return


<s> int op0_num = return_p ? <NUM_LIT> : <NUM_LIT> ; int op1_num = return_p ? <NUM_LIT> : <NUM_LIT> ; if ( return_p ) target = nds32_legitimize_target ( icode , target ) ; if ( ! nds32_check_constant_argument ( icode , op1_num , op1 , name ) ) return NULL_RTX ; op0 = nds32_legitimize_argument ( icode , op0_num , op0 ) ; op1 = nds32_legitimize_argument ( icode , op1_num , op1 ) ; if ( return_p ) pat = GEN_FCN ( icode ) ( target , op0 , op1 ) ; else pat = GEN_FCN ( icode ) ( op0 , op1 ) ; if ( ! pat ) return NULL_RTX ; emit_insn (


<s> int op0_num = return_p ? <NUM_LIT> : <NUM_LIT> ; int op1_num = return_p ? <NUM_LIT> : <NUM_LIT> ; if ( return_p ) target = nds32_legitimize_target ( icode , target ) ; op0 = nds32_legitimize_argument ( icode , op0_num , op0 ) ; op1 = nds32_legitimize_argument ( icode , op1_num , op1 ) ; if ( return_p ) pat = GEN_FCN ( icode ) ( target


<s> rtx pat ; rtx op0 = nds32_read_argument ( exp , <NUM_LIT> ) ; rtx op1 = nds32_read_argument ( exp , <NUM_LIT> ) ; int op0_num = return_p ? <NUM_LIT> : <NUM_LIT> ; int op1_num = return_p ? <NUM_LIT> : <NUM_LIT> ; if ( return_p ) target = nds32_legitimize_target ( icode , target ) ; op0 = nds32_legitimize_argument ( icode , op0_num , op0 ) ; op1 = nds32_legitimize_argument ( icode , op1_num , op1 ) ; if ( return_p ) pat = GEN_FCN ( icode ) ( target , op0 , op1 ) ; else pat = GEN_FCN ( icode ) ( op0 , op1 ) ; if ( ! pat )


<s> rtx op0 = nds32_read_argument ( exp , <NUM_LIT> ) ; rtx addr_helper = gen_reg_rtx ( insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ) ; target = nds32_legitimize_target ( icode , target ) ; op0 = nds32_legitimize_argument ( icode , <NUM_LIT> , op0 ) ; pat = GEN_FCN ( icode ) ( target , op0 , addr_helper ) ; if ( ! pat ) return NULL_RTX ; emit_move_insn ( addr_helper , GEN_INT ( <NUM_LIT> ) ) ; emit_insn ( pat ) ; return target


<s> op0 = nds32_legitimize_argument ( icode , <NUM_LIT> , op0 ) ; pat = GEN_FCN ( icode ) ( target , op0 , addr_helper ) ; if ( ! pat


<s> pat = GEN_FCN ( icode ) ( op0 , addr_helper , op1 ) ; if ( ! pat ) return NULL_RTX ; emit_move_insn ( addr_helper , GEN_INT ( <NUM_LIT> ) ) ; emit_insn ( pat )


<s> rtx op0 = nds32_read_argument ( exp , <NUM_LIT> ) ; rtx op1 = nds32_read_argument ( exp , <NUM_LIT> ) ; rtx addr_helper = gen_reg_rtx ( insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ) ; op0 = nds32_legitimize_argument ( icode , <NUM_LIT> , op0 ) ; op1 = nds32_legitimize_argument ( icode ,


<s> int op1_num = return_p ? <NUM_LIT> : <NUM_LIT> ; if ( return_p ) target = nds32_legitimize_target ( icode , target ) ; if ( ! nds32_check_constant_argument ( icode , op0_num , op0 , name ) ) return NULL_RTX ; op0 = nds32_legitimize_argument ( icode , op0_num , op0 ) ; op1 = nds32_legitimize_argument ( icode , op1_num , op1 ) ; if ( icode == CODE_FOR_cctl_idx_write ) { rtx op2 = nds32_read_argument ( exp , <NUM_LIT> ) ; op2 = nds32_legitimize_argument ( icode , <NUM_LIT> ,


<s> rtx op0 = nds32_read_argument ( exp , <NUM_LIT> ) ; rtx op1 = nds32_read_argument ( exp , <NUM_LIT> ) ; int op0_num = return_p ? <NUM_LIT> : <NUM_LIT> ; int op1_num = return_p ? <NUM_LIT> : <NUM_LIT> ; if ( return_p ) target = nds32_legitimize_target ( icode , target ) ; if ( ! nds32_check_constant_argument ( icode , op0_num , op0 , name )


<s> target = nds32_legitimize_target ( icode , target ) ; pat = GEN_FCN ( icode ) (


<s> if ( ! nds32_check_constant_argument ( icode , <NUM_LIT> , op1 , name ) ) return NULL_RTX ; op0 = nds32_legitimize_argument ( icode , <NUM_LIT> , op0 ) ; op1 = nds32_legitimize_argument ( icode , <NUM_LIT> , op1 ) ; pat = GEN_FCN ( icode ) ( op0 , op1 ) ; if ( ! pat ) return NULL_RTX ; emit_insn ( pat ) ; return


<s> pat = GEN_FCN ( icode ) ( target , op0 , addr_helper , target ) ; if ( ! pat ) return NULL_RTX ; emit_move_insn ( addr_helper , GEN_INT ( <NUM_LIT> ) ) ; emit_move_insn ( target , op1 ) ; emit_insn ( pat


<s> rtx op0 = nds32_read_argument ( exp , <NUM_LIT> ) ; rtx op1 = nds32_read_argument ( exp , <NUM_LIT> ) ; rtx op2 = nds32_read_argument ( exp , <NUM_LIT> ) ; int op0_num = return_p ? <NUM_LIT> : <NUM_LIT> ; int op1_num = return_p ? <NUM_LIT> : <NUM_LIT> ; int op2_num = return_p ? <NUM_LIT> : <NUM_LIT> ; if ( return_p ) target = nds32_legitimize_target ( icode , target ) ; if ( ! nds32_check_constant_argument ( icode , op2_num , op2 , name ) ) return NULL_RTX ; op0 = nds32_legitimize_argument ( icode , op0_num ,


<s> if ( return_p ) pat = GEN_FCN ( icode ) ( target , op0 ) ; else pat = GEN_FCN ( icode ) ( op0 ) ; if ( ! pat ) return NULL_RTX ; emit_insn (


<s> if ( return_p ) pat = GEN_FCN ( icode ) ( target , op0 ) ; else pat = GEN_FCN ( icode ) ( op0 ) ; if ( ! pat ) return


<s> enum machine_mode mode = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; if ( ! target || GET_MODE ( target ) != mode || ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate )

( target , mode ) ) return gen_reg_rtx ( mode ) ;


<s> return expand_normal ( CALL_EXPR_ARG (


<s> fprintf ( asm_out_file , <STR_LIT> ) ; } for ( i = <NUM_LIT> ; i < NDS32_N_ISR_VECTORS ; i ++ ) { if ( nds32_isr_vectors [ i ] . category == NDS32_ISR_INTERRUPT || nds32_isr_vectors [ i ] . category == NDS32_ISR_EXCEPTION ) { fprintf ( asm_out_file , <STR_LIT> , i ) ; fprintf ( asm_out_file , <STR_LIT> ) ; nds32_emit_isr_jmptbl_section ( i ) ; fprintf ( asm_out_file , <STR_LIT> ) ; nds32_emit_isr_vector_section (


<s> nds32_isr_vectors [ i ] . category = NDS32_ISR_NONE ; strcpy ( nds32_isr_vectors [ i ] . func_name , <STR_LIT> ) ; nds32_isr_vectors [ i ] . save_reg = NDS32_PARTIAL_SAVE ; nds32_isr_vectors [ i ] . nested_type = NDS32_NOT_NESTED ; nds32_isr_vectors [ i ]


<s> nds32_isr_vectors [ i ] . nested_type = NDS32_NOT_NESTED ; nds32_isr_vectors [ i ] . total_n_vectors = <NUM_LIT> ; strcpy ( nds32_isr_vectors [ i ] . nmi_name ,


<s> excp = lookup_attribute ( <STR_LIT> , func_attrs ) ; reset = lookup_attribute ( <STR_LIT> , func_attrs ) ; if ( ! intr && ! excp && ! reset ) return ; if ( intr || excp ) { tree id_list ; id_list = ( intr ) ? ( TREE_VALUE ( intr ) ) : ( TREE_VALUE ( excp ) ) ; while ( id_list ) { tree id ; int vector_id ; unsigned int vector_number_offset ; vector_number_offset = ( intr ) ? ( <NUM_LIT> ) : ( <NUM_LIT> ) ; id = TREE_VALUE ( id_list ) ; vector_id = TREE_INT_CST_LOW ( id ) + vector_number_offset ; nds32_isr_vectors [ vector_id ] . category = ( intr ) ? ( NDS32_ISR_INTERRUPT ) : ( NDS32_ISR_EXCEPTION ) ; strcpy ( nds32_isr_vectors [ vector_id ] . func_name , func_name ) ; if ( save_all ) nds32_isr_vectors [ vector_id ] . save_reg = NDS32_SAVE_ALL ; else if ( partial_save ) nds32_isr_vectors [ vector_id ] . save_reg = NDS32_PARTIAL_SAVE ; if ( nested ) nds32_isr_vectors [ vector_id ] . nested_type = NDS32_NESTED ; else if ( not_nested ) nds32_isr_vectors [ vector_id ] . nested_type = NDS32_NOT_NESTED ; else if ( nested_ready ) nds32_isr_vectors [ vector_id ] . nested_type = NDS32_NESTED_READY ; id_list = TREE_CHAIN ( id_list ) ; } } else { tree id_list ; tree id ; tree nmi , warm ; nds32_isr_vectors [ <NUM_LIT> ] . category = NDS32_ISR_RESET ; id_list = TREE_VALUE ( reset ) ; id = TREE_VALUE ( id_list ) ; nds32_isr_vectors [ <NUM_LIT> ] . total_n_vectors = TREE_INT_CST_LOW ( id ) + <NUM_LIT> + <NUM_LIT> ; strcpy ( nds32_isr_vectors [ <NUM_LIT> ] . func_name , func_name ) ; nmi = lookup_attribute ( <STR_LIT> , func_attrs ) ; warm = lookup_attribute ( <STR_LIT> , func_attrs


<s> if ( ! intr && ! excp && ! reset ) return ; if ( intr || excp ) { tree id_list ; id_list = ( intr ) ? ( TREE_VALUE ( intr ) ) : ( TREE_VALUE ( excp ) ) ; while ( id_list ) { tree id ; int vector_id ; unsigned int vector_number_offset ; vector_number_offset = ( intr ) ? ( <NUM_LIT> ) : ( <NUM_LIT> ) ; id = TREE_VALUE ( id_list ) ; vector_id = TREE_INT_CST_LOW ( id ) + vector_number_offset ; nds32_isr_vectors [ vector_id ] . category = ( intr ) ? ( NDS32_ISR_INTERRUPT ) : ( NDS32_ISR_EXCEPTION ) ; strcpy ( nds32_isr_vectors [ vector_id ] . func_name , func_name ) ; if ( save_all ) nds32_isr_vectors [ vector_id ] . save_reg = NDS32_SAVE_ALL ; else if ( partial_save ) nds32_isr_vectors [ vector_id ] . save_reg = NDS32_PARTIAL_SAVE ; if ( nested ) nds32_isr_vectors [ vector_id ] . nested_type = NDS32_NESTED ; else if ( not_nested ) nds32_isr_vectors [ vector_id ] . nested_type = NDS32_NOT_NESTED ; else if ( nested_ready ) nds32_isr_vectors [ vector_id ] . nested_type = NDS32_NESTED_READY ; id_list = TREE_CHAIN ( id_list ) ; } } else { tree id_list ; tree id ; tree nmi , warm ; nds32_isr_vectors [ <NUM_LIT> ] . category = NDS32_ISR_RESET ; id_list = TREE_VALUE ( reset ) ; id = TREE_VALUE ( id_list ) ; nds32_isr_vectors [ <NUM_LIT> ] . total_n_vectors = TREE_INT_CST_LOW ( id ) + <NUM_LIT> + <NUM_LIT> ; strcpy ( nds32_isr_vectors [ <NUM_LIT> ] . func_name , func_name ) ; nmi = lookup_attribute ( <STR_LIT> , func_attrs ) ; warm = lookup_attribute ( <STR_LIT> , func_attrs ) ; if ( nmi != NULL_TREE ) { tree nmi_func_list ; tree nmi_func ; nmi_func_list = TREE_VALUE ( nmi ) ; nmi_func = TREE_VALUE ( nmi_func_list ) ; strcpy ( nds32_isr_vectors [ <NUM_LIT> ] . nmi_name , IDENTIFIER_POINTER ( nmi_func ) ) ; } if ( warm != NULL_TREE ) { tree


<s> snprintf ( section_name , sizeof ( section_name ) , <STR_LIT> ) ; snprintf ( symbol_name , sizeof ( symbol_name ) , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; nds32_emit_section_head_template ( section_name , symbol_name , <NUM_LIT> , true ) ; fprintf ( asm_out_file , <STR_LIT> , ( strlen ( nds32_isr_vectors [ <NUM_LIT> ] . nmi_name ) == <NUM_LIT> ) ? <STR_LIT> : nds32_isr_vectors [ <NUM_LIT> ] . nmi_name ) ; nds32_emit_section_tail_template ( symbol_name ) ; snprintf ( section_name , sizeof ( section_name ) , <STR_LIT> ) ; snprintf ( symbol_name , sizeof ( symbol_name ) , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; nds32_emit_section_head_template ( section_name , symbol_name , <NUM_LIT> , true ) ; fprintf ( asm_out_file , <STR_LIT> , ( strlen ( nds32_isr_vectors [ <NUM_LIT> ] . warm_name ) == <NUM_LIT> ) ? <STR_LIT> : nds32_isr_vectors [ <NUM_LIT> ] . warm_name ) ; nds32_emit_section_tail_template ( symbol_name


<s> fprintf ( asm_out_file , <STR_LIT> ) ; nds32_emit_section_head_template ( section_name , symbol_name , floor_log2 ( nds32_isr_vector_size ) , false ) ; fprintf ( asm_out_file , <STR_LIT> , reset_handler_name ) ; nds32_emit_section_tail_template ( symbol_name ) ; snprintf ( section_name , sizeof ( section_name ) , <STR_LIT> ) ; snprintf ( symbol_name , sizeof ( symbol_name ) , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; nds32_emit_section_head_template ( section_name , symbol_name , <NUM_LIT> , true ) ; fprintf ( asm_out_file , <STR_LIT> , ( strlen ( nds32_isr_vectors [ <NUM_LIT> ] . nmi_name ) == <NUM_LIT> ) ? <STR_LIT> : nds32_isr_vectors [ <NUM_LIT> ] . nmi_name ) ; nds32_emit_section_tail_template ( symbol_name ) ; snprintf ( section_name , sizeof ( section_name ) , <STR_LIT> ) ; snprintf ( symbol_name , sizeof ( symbol_name )


<s> sr_str = <STR_LIT> ; break ; case NDS32_PARTIAL_SAVE : sr_str = <STR_LIT> ; break ; } switch ( nds32_isr_vectors [ vector_id ] . nested_type ) { case NDS32_NESTED : nt_str = <STR_LIT> ; break ; case NDS32_NOT_NESTED : nt_str = <STR_LIT> ; break ; case NDS32_NESTED_READY : nt_str = <STR_LIT> ; break ; } vs_str = ( nds32_isr_vector_size == <NUM_LIT> ) ? <STR_LIT> : <STR_LIT> ; snprintf ( first_level_handler_name , sizeof ( first_level_handler_name ) , <STR_LIT> , c_str , sr_str , nt_str , vs_str ) ; snprintf ( section_name , sizeof ( section_name ) , <STR_LIT> , vector_id ) ; snprintf ( symbol_name , sizeof ( symbol_name ) , <STR_LIT> , vector_id , vs_str ) ; nds32_emit_section_head_template ( section_name , symbol_name , floor_log2 ( nds32_isr_vector_size ) , false ) ; if ( nds32_isr_vector_size == <NUM_LIT> ) { fprintf ( asm_out_file , <STR_LIT> , first_level_handler_name ) ; } else { if ( TARGET_REDUCED_REGS ) { if ( nds32_isr_vectors [ vector_id ] . save_reg == NDS32_SAVE_ALL ) { fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file ,


<s> } else { s_level = nds32_isr_secure_level ; } if ( intr != NULL_TREE && TREE_CODE ( TREE_VALUE ( TREE_VALUE ( intr ) ) ) == STRING_CST ) { tree string_arg = TREE_VALUE ( TREE_VALUE ( intr ) ) ; nds32_interrupt_attribute_parse_string ( TREE_STRING_POINTER ( string_arg ) , func_name , s_level ) ; return ; } if ( excp != NULL_TREE && TREE_CODE ( TREE_VALUE ( TREE_VALUE ( excp ) ) ) == STRING_CST ) { tree string_arg = TREE_VALUE ( TREE_VALUE ( excp ) ) ; nds32_exception_attribute_parse_string ( TREE_STRING_POINTER ( string_arg ) , func_name , s_level ) ; return ; } if ( reset != NULL_TREE && TREE_CODE ( TREE_VALUE ( TREE_VALUE ( reset ) ) ) == STRING_CST ) { tree string_arg = TREE_VALUE ( TREE_VALUE ( reset ) ) ; nds32_reset_attribute_parse_string ( TREE_STRING_POINTER ( string_arg ) , func_name ) ; return ; } if ( intr || excp ) { tree id_list ; id_list = ( intr ) ? ( TREE_VALUE ( intr ) ) : ( TREE_VALUE ( excp ) ) ; while ( id_list ) { tree id ; int vector_id ; unsigned int vector_number_offset ; vector_number_offset = ( intr ) ? ( <NUM_LIT> ) : ( <NUM_LIT> ) ; id = TREE_VALUE ( id_list ) ; vector_id = TREE_INT_CST_LOW ( id ) + vector_number_offset ; nds32_isr_vectors [ vector_id ] . security_level = s_level ; nds32_isr_vectors [ vector_id ] . category = ( intr ) ? ( NDS32_ISR_INTERRUPT ) : ( NDS32_ISR_EXCEPTION ) ; strcpy ( nds32_isr_vectors [ vector_id ] . func_name , func_name ) ; if ( save_all ) nds32_isr_vectors [ vector_id ] . save_reg = NDS32_SAVE_ALL ; else if ( partial_save ) nds32_isr_vectors [ vector_id ] . save_reg = NDS32_PARTIAL_SAVE ; if ( nested ) nds32_isr_vectors [ vector_id ] . nested_type = NDS32_NESTED ; else if ( not_nested ) nds32_isr_vectors [ vector_id ] . nested_type = NDS32_NOT_NESTED ; else if ( nested_ready ) nds32_isr_vectors [ vector_id ] . nested_type = NDS32_NESTED_READY ; else if ( critical ) nds32_isr_vectors [ vector_id ] . nested_type = NDS32_CRITICAL ; id_list = TREE_CHAIN ( id_list ) ; } } else { tree id_list ; tree id ; tree nmi , warm ; nds32_isr_vectors [ <NUM_LIT> ] . category = NDS32_ISR_RESET ; id_list = TREE_VALUE ( reset ) ; id = TREE_VALUE ( id_list ) ; nds32_isr_vectors [ <NUM_LIT> ] . total_n_vectors = TREE_INT_CST_LOW ( id


<s> static void nds32_emit_isr_jmptbl_section ( int vector_id ) { char section_name [ <NUM_LIT> ] ; char symbol_name [ <NUM_LIT> ] ; if ( nds32_isr_vectors [ vector_id ] .


<s> char symbol_name [ <NUM_LIT> ] ; total_n_vectors = nds32_isr_vectors [ <NUM_LIT> ] . total_n_vectors ; fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; for ( i = <NUM_LIT> ; i < total_n_vectors ; i ++ ) fprintf ( asm_out_file , <STR_LIT> , i ) ; fprintf ( asm_out_file , <STR_LIT> ) ; for ( i = <NUM_LIT> ; i < total_n_vectors ; i ++ ) fprintf ( asm_out_file , <STR_LIT> , i ) ; snprintf ( section_name , sizeof ( section_name ) , <STR_LIT> ) ; snprintf ( symbol_name , sizeof ( symbol_name ) , <STR_LIT> ) ; fprintf ( asm_out_file ,


<s> else if ( ready_nested_str ) nested_type = NDS32_NESTED_READY ; else if ( nested_str ) nested_type = NDS32_NESTED ; else if ( critical_str ) nested_type = NDS32_CRITICAL ; else nested_type = NDS32_NOT_NESTED ; id_str = strstr ( target_str , <STR_LIT> ) ; if ( id_str == NULL ) error ( <STR_LIT> ) ; id_str = strtok ( id_str , <STR_LIT> ) ; value_str = strtok ( NULL , <STR_LIT> ) ; value_str = strtok ( value_str , <STR_LIT> ) ; while ( value_str != NULL ) { int i ; i = atoi ( value_str ) ; if ( i < <NUM_LIT> || i > <NUM_LIT> ) error ( <STR_LIT> ) ; nds32_isr_vectors [ i ] . category


<s> tree t_excp ; tree t_reset ; tree attrs ; if ( TREE_CODE ( func ) != FUNCTION_DECL ) abort ( ) ; attrs = DECL_ATTRIBUTES ( func ) ; t_intr = lookup_attribute ( <STR_LIT> , attrs


<s> strcpy ( target_str , original_str ) ; vectors_str = strstr ( target_str , <STR_LIT> ) ; if ( vectors_str != NULL ) { vectors_str = strtok ( vectors_str , <STR_LIT> ) ; value_str = strtok ( NULL , <STR_LIT> ) ; nds32_isr_vectors [ <NUM_LIT> ] . total_n_vectors = atoi ( value_str ) + <NUM_LIT> + <NUM_LIT> ; } else nds32_isr_vectors [ <NUM_LIT> ] . total_n_vectors = <NUM_LIT> + <NUM_LIT> + <NUM_LIT> ; strcpy ( nds32_isr_vectors [ <NUM_LIT> ] . func_name , func_name ) ; strcpy ( target_str , original_str ) ; nmi_str = strstr ( target_str , <STR_LIT> ) ; if ( nmi_str != NULL ) { nmi_str = strtok ( nmi_str , <STR_LIT> ) ; value_str = strtok ( NULL , <STR_LIT> ) ; strcpy ( nds32_isr_vectors [ <NUM_LIT> ] . nmi_name , value_str


<s> unsigned char size ; rtx code = XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ; size = nds32_byte_to_size ( byte ) ; switch ( nds32_mem_format ( operands [ <NUM_LIT> ] ) ) { case ADDRESS_REG : operands [ <NUM_LIT> ] = code ; output_asm_insn ( <STR_LIT> , operands ) ; break ; case ADDRESS_LO_REG_IMM3U : snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> , size ) ; output_asm_insn ( pattern , operands ) ; break ; case


<s> rtx code = XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ; size = nds32_byte_to_size ( byte ) ; switch ( nds32_mem_format ( operands [ <NUM_LIT> ] ) ) { case ADDRESS_REG : operands [ <NUM_LIT> ] = code ; output_asm_insn ( <STR_LIT> , operands ) ; break ; case ADDRESS_LO_REG_IMM3U : snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> , size ) ; output_asm_insn ( pattern ,


<s> char pattern [ <NUM_LIT> ] ; char size ; rtx code = XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ; size = nds32_byte_to_size ( byte ) ; switch ( nds32_mem_format ( operands [ <NUM_LIT> ] ) ) { case ADDRESS_REG : operands [ <NUM_LIT> ] = code ; output_asm_insn ( <STR_LIT> , operands ) ; break ; case ADDRESS_LO_REG_IMM3U : snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> , size ) ; output_asm_insn ( pattern , operands ) ; break ; case ADDRESS_POST_INC_LO_REG_IMM3U : snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> , size ) ; output_asm_insn ( pattern , operands ) ; break ; case ADDRESS_FP_IMM7U : output_asm_insn ( <STR_LIT> ,


<s> output_asm_insn ( <STR_LIT> , operands ) ; if ( TARGET_16_BIT ) return <STR_LIT> ; else return


<s> operands [ <NUM_LIT> ] = gen_rtx_REG ( SImode , re_callee_saved ) ; if ( ! cfun -> machine -> fp_size && ! cfun -> machine -> gp_size && ! cfun -> machine -> lp_size && REGNO ( operands [ <NUM_LIT> ] ) == SP_REGNUM && REGNO ( operands [ <NUM_LIT> ] ) == SP_REGNUM ) { return <STR_LIT> ; } else { if ( REGNO ( operands [ <NUM_LIT> ] ) == SP_REGNUM && REGNO ( operands [ <NUM_LIT> ] ) == SP_REGNUM ) pop_en4_only_p = <NUM_LIT> ; snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> , pop_en4_only_p ? <STR_LIT> : <STR_LIT> , cfun -> machine -> fp_size ? <STR_LIT> : <STR_LIT> , cfun -> machine -> gp_size ? <STR_LIT> : <STR_LIT> , cfun -> machine -> lp_size ? <STR_LIT> : <STR_LIT> ) ; } } output_asm_insn ( pattern , operands


<s> emit_insn ( gen_zero_extendqisi2 ( reg [ <NUM_LIT> ] , sub_reg ) ) ; while ( width > <NUM_LIT> ) { offset = offset + offset_adj ; shift ++ ; width -- ; mem [ <NUM_LIT> ] = gen_rtx_MEM ( QImode , plus_constant ( Pmode , operands [ <NUM_LIT> ] , offset ) ) ; emit_move_insn ( temp_sub_reg , mem [ <NUM_LIT> ] ) ; emit_insn ( gen_ashlsi3 ( temp_reg , temp_reg , GEN_INT ( shift * <NUM_LIT> ) ) ) ; emit_insn ( gen_iorsi3 ( reg [ <NUM_LIT> ] , reg [ <NUM_LIT> ] , temp_reg ) ) ; } if ( mode == DImode ) { reg [ <NUM_LIT> ] = reg [ <NUM_LIT> ] ; shift = <NUM_LIT>


<s> } else { reg [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; } for ( num_reg = ( mode == DImode ) ? <NUM_LIT> : <NUM_LIT> ; num_reg > <NUM_LIT> ; num_reg -- ) { sub_reg = gen_lowpart ( QImode , reg [ <NUM_LIT> ] ) ; mem [ <NUM_LIT> ] = gen_rtx_MEM ( QImode , plus_constant ( Pmode , operands [ <NUM_LIT> ] , offset ) ) ; emit_move_insn ( mem [ <NUM_LIT> ] , sub_reg ) ; while ( width > <NUM_LIT> ) { offset = offset + offset_adj ; shift ++ ; width -- ; mem [ <NUM_LIT> ] = gen_rtx_MEM ( QImode , plus_constant ( Pmode , operands [ <NUM_LIT> ] , offset ) ) ; emit_insn ( gen_lshrsi3 ( temp_reg , reg [ <NUM_LIT> ] , GEN_INT ( shift * <NUM_LIT> ) ) ) ; emit_move_insn ( mem [ <NUM_LIT> ] , temp_sub_reg ) ; } if ( mode == DImode ) { reg [ <NUM_LIT> ] = reg [ <NUM_LIT> ] ; shift = <NUM_LIT> ; width = GET_MODE_SIZE ( SImode ) - <NUM_LIT> ; offset = offset +


<s> bool nds32_long_call_p ( rtx symbol )


<s> diff_vec = PATTERN ( NEXT_INSN ( as_a < rtx_insn * > ( operands [ <NUM_LIT> ] ) ) ) ; gcc_assert ( GET_CODE ( diff_vec ) == ADDR_DIFF_VEC ) ; output_asm_insn ( <STR_LIT> , operands ) ; mode = GET_MODE (


<s> int last_argument_regno = NDS32_FIRST_GPR_REGNUM + NDS32_MAX_GPR_REGS_FOR_ARGS - <NUM_LIT> ; int rb_eh_data = cfun -> machine -> eh_return_data_first_regno ; int re_eh_data = cfun -> machine -> eh_return_data_last_regno ; int first_eh_data_regno = EH_RETURN_DATA_REGNO ( <NUM_LIT> ) ; int rb_callee_saved = cfun -> machine -> callee_saved_first_gpr_regno ; int re_callee_saved = cfun -> machine -> callee_saved_last_gpr_regno ; if ( reg_mentioned_p ( gen_rtx_REG ( SImode , last_argument_regno ) , par_rtx ) ) { operands [ <NUM_LIT> ] = gen_rtx_REG ( SImode , rb_va_args ) ; operands [ <NUM_LIT> ] = gen_rtx_REG ( SImode , re_va_args ) ; snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> , <STR_LIT> ) ; output_asm_insn ( pattern , operands ) ; return <STR_LIT> ; } if ( reg_mentioned_p ( gen_rtx_REG ( SImode , first_eh_data_regno ) , par_rtx ) ) { operands [ <NUM_LIT> ] = gen_rtx_REG ( SImode , rb_eh_data ) ; operands [ <NUM_LIT> ] = gen_rtx_REG ( SImode , re_eh_data ) ; snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> , <STR_LIT> ) ; output_asm_insn ( pattern , operands ) ; return <STR_LIT> ; } if ( TARGET_V3PUSH && ! nds32_isr_function_p ( current_function_decl ) && ( cfun -> machine -> va_args_size == <NUM_LIT> ) ) { int sp_adjust


<s> else if ( GET_CODE ( sub_mem ) == POST_MODIFY ) { rtx post_mem = XEXP ( sub_mem , <NUM_LIT> ) ; rtx plus_op = XEXP ( sub_mem , <NUM_LIT> ) ; rtx post_val = XEXP ( plus_op , <NUM_LIT> ) ; low_part [ mem ] = gen_frame_mem ( SImode , gen_rtx_POST_MODIFY ( Pmode , post_mem , gen_rtx_PLUS ( Pmode , post_mem , post_val ) ) ) ; high_part [ mem ] = gen_frame_mem ( SImode , plus_constant ( Pmode , post_mem , <NUM_LIT> ) ) ; } else { low_part [ mem ] = adjust_address ( mem_rtx , SImode , <NUM_LIT> ) ; high_part [ mem ] = adjust_address ( mem_rtx , SImode , <NUM_LIT> ) ; } if ( ( load_p && reg_overlap_mentioned_p ( low_part [ <NUM_LIT> ] , high_part [ <NUM_LIT> ] ) )

|| GET_CODE ( sub_mem ) == POST_MODIFY ) {


<s> case <NUM_LIT> : return 'w' ; case <NUM_LIT> : return


<s> return 'w' ; case <NUM_LIT> : return 'h' ; case <NUM_LIT> : return 'b'


<s> static const char * nds32_cond_code_str ( int code ) { switch ( code ) { case NE : return


<s> unsigned high_part_offset = subreg_highpart_offset ( SImode , DImode ) ; return simplify_gen_subreg ( SImode , reg , DImode , high_part_offset


<s> unsigned high_part_offset = subreg_highpart_offset (


<s> unsigned low_part_offset = subreg_lowpart_offset ( SImode ,


<s> int padding = <NUM_LIT> ; while ( regno <= last_fpr ) { if ( ( regno + <NUM_LIT> ) >= last_fpr ) padding = gpr_padding_size ; reg = gen_rtx_REG ( DFmode , ( regno ) ) ; addr = gen_rtx_POST_MODIFY ( Pmode , stack_pointer_rtx , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , GEN_INT ( <NUM_LIT> + padding ) ) ) ; mem = gen_frame_mem ( DFmode , addr ) ; regno +=


<s> addr = gen_rtx_POST_MODIFY ( Pmode , stack_pointer_rtx , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , GEN_INT ( <NUM_LIT> + padding ) ) ) ; mem = gen_frame_mem ( DFmode , addr ) ; regno += <NUM_LIT> ; fpu_insn = emit_move_insn ( reg , mem ) ; adjust_sp_rtx = gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> + padding ) ) ; dwarf = alloc_reg_note ( REG_CFA_RESTORE


<s> rtx fpu_insn ; rtx reg , mem ; unsigned int regno = cfun -> machine -> callee_saved_first_fpr_regno ; unsigned int last_fpr = cfun -> machine -> callee_saved_last_fpr_regno ; while ( regno <= last_fpr ) { reg = gen_rtx_REG ( DFmode , regno ) ; mem = gen_frame_mem ( DFmode , plus_constant ( Pmode , stack_pointer_rtx , base_offset ) ) ; base_offset += <NUM_LIT> ; regno += <NUM_LIT> ; fpu_insn = emit_move_insn ( mem , reg ) ; RTX_FRAME_RELATED_P ( fpu_insn ) =


<s> regno += <NUM_LIT> ; fpu_insn = emit_move_insn ( reg , mem ) ; dwarf = alloc_reg_note ( REG_CFA_RESTORE , reg , NULL_RTX ) ; RTX_FRAME_RELATED_P ( fpu_insn ) = <NUM_LIT> ; REG_NOTES ( fpu_insn


<s> int fpu_base_addr = base ; int regno ; rtx fpu_insn ; rtx reg , mem ; rtx dwarf ; regno = cfun -> machine -> callee_saved_first_fpr_regno ; while ( regno <= cfun -> machine -> callee_saved_last_fpr_regno ) { reg = gen_rtx_REG ( DFmode , regno ) ; mem = gen_frame_mem ( DFmode , plus_constant ( Pmode , stack_pointer_rtx , fpu_base_addr ) ) ; fpu_base_addr += <NUM_LIT>


<s> } else if ( clear_zero_bit_copies > <NUM_LIT> && clear_sign_bit_copies < <NUM_LIT> && ( remainder | zero_shift_mask ) == <NUM_LIT> ) { rtx shift = GEN_INT ( clear_zero_bit_copies ) ; emit_insn ( gen_lshrsi3 ( temp , source , shift ) ) ; emit_insn ( gen_ashlsi3 ( target , temp , shift ) ) ; } else { emit_move_insn ( temp , GEN_INT ( val )


<s> rtx cmp_op0 = operands [ <NUM_LIT> ] ; rtx cmp_op1 = operands [ <NUM_LIT> ] ; rtx tmp_reg ; rtx tmp ; int reverse = <NUM_LIT> ; switch ( code ) { case GT : case GE : tmp = cmp_op0 ; cmp_op0 = cmp_op1 ; cmp_op1 = tmp ; new_code = swap_condition ( new_code ) ; break ; case UNORDERED : case LT : case LE : case EQ : break ; case ORDERED : case


<s> cmp_op1 = tmp ; new_code = swap_condition ( new_code ) ; break ; case UNORDERED : case LT : case LE : case EQ : break ; case ORDERED : if ( mode == SFmode ) emit_insn ( gen_cmpsf_un ( operands [ <NUM_LIT> ] , cmp_op0 , cmp_op1 ) ) ; else emit_insn ( gen_cmpdf_un ( operands [ <NUM_LIT> ] , cmp_op0 , cmp_op1 ) ) ; emit_insn ( gen_xorsi3 ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT>


<s> HOST_WIDE_INT bitpos = INTVAL ( operands [ <NUM_LIT> ] ) ; rtx dst = operands [ <NUM_LIT> ] ; rtx src = operands [ <NUM_LIT> ] ; if ( MEM_P ( dst ) && width == <NUM_LIT> && ( bitpos % BITS_PER_UNIT ) == <NUM_LIT> && GET_MODE_BITSIZE ( GET_MODE ( src ) ) == width ) { rtx newmem = adjust_address ( dst , GET_MODE ( src ) , bitpos / BITS_PER_UNIT ) ; rtx base_addr = force_reg ( Pmode , XEXP ( newmem , <NUM_LIT> ) ) ; emit_insn ( gen_unaligned_storesi ( base_addr , src ) ) ; return EXPAND_DONE


<s> enum rtx_code new_code = code ; machine_mode cmp0_mode = GET_MODE ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) ; rtx cmp_op0 = XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ; rtx cmp_op1 = XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ; rtx tmp ; if ( ( GET_CODE ( operands [ <NUM_LIT> ] ) == EQ || GET_CODE ( operands [ <NUM_LIT> ] ) == NE ) && XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) == const0_rtx ) { return EXPAND_CREATE_TEMPLATE ; } else if ( ( TARGET_FPU_SINGLE && cmp0_mode == SFmode ) || ( TARGET_FPU_DOUBLE &&


<s> rtx src ; src = nds32_legitimize_pic_address ( operands [ <NUM_LIT>


<s> else reg [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; } for ( num_reg = ( mode == DImode ) ? <NUM_LIT> : <NUM_LIT> ; num_reg > <NUM_LIT> ; num_reg -- ) { sub_reg = gen_lowpart ( QImode , reg [ <NUM_LIT> ] ) ; mem [ <NUM_LIT> ] = gen_rtx_MEM ( QImode , plus_constant ( Pmode , operands [ <NUM_LIT> ] , offset ) ) ; emit_move_insn ( sub_reg , mem [ <NUM_LIT> ] ) ; emit_insn ( gen_zero_extendqisi2 ( reg [ <NUM_LIT> ] , sub_reg ) ) ; while ( width > <NUM_LIT> ) { offset = offset + offset_adj ; shift ++ ; width -- ; mem [ <NUM_LIT> ] = gen_rtx_MEM ( QImode , plus_constant ( Pmode , operands [ <NUM_LIT> ] , offset ) ) ; emit_move_insn ( temp_sub_reg , mem [ <NUM_LIT> ] ) ; emit_insn ( gen_ashlsi3 ( temp_reg , temp_reg , GEN_INT ( shift * <NUM_LIT> ) ) ) ; emit_insn ( gen_iorsi3 ( reg [ <NUM_LIT> ] , reg [ <NUM_LIT> ] , temp_reg ) ) ; } if ( mode == DImode ) { reg [ <NUM_LIT> ] = reg [ <NUM_LIT> ] ; shift = <NUM_LIT> ; width = GET_MODE_SIZE ( SImode )


<s> tree decl = SYMBOL_REF_DECL ( x ) ; return decl && ( lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) != NULL ) ; } return


<s> return EQ ; case EQ : return NE ; case GT : return LE ; case LE : return GT


<s> gcc_assert ( GET_CODE ( x ) == SYMBOL_REF && nds32_indirect_call_referenced_p ( x ) ) ; addr = gen_rtx_UNSPEC ( SImode , gen_rtvec ( <NUM_LIT> , symbol ) , UNSPEC_ICT ) ; addr = gen_rtx_CONST ( SImode , addr ) ; emit_insn ( gen_sethi ( reg , addr ) ) ; x = gen_const_mem ( SImode , gen_rtx_LO_SUM ( Pmode


<s> if ( GET_CODE ( x ) == SYMBOL_REF ) switch ( SYMBOL_REF_TLS_MODEL ( x ) ) { case TLS_MODEL_GLOBAL_DYNAMIC : case TLS_MODEL_LOCAL_DYNAMIC : if ( SYMBOL_REF_TLS_MODEL ( x ) == TLS_MODEL_GLOBAL_DYNAMIC ) pat = gen_rtx_UNSPEC ( SImode , gen_rtvec ( <NUM_LIT> , x ) , UNSPEC_TLSGD ) ; else pat = gen_rtx_UNSPEC ( SImode , gen_rtvec ( <NUM_LIT> , x ) , UNSPEC_TLSLD ) ; pat = gen_rtx_CONST ( SImode , pat ) ; reg0 = gen_rtx_REG ( Pmode , <NUM_LIT> ) ; insns = emit_call_insn ( gen_tls_desc ( pat , GEN_INT ( relax_group_id ) ) ) ; use_reg ( & CALL_INSN_FUNCTION_USAGE ( insns ) , pic_offset_table_rtx ) ; RTL_CONST_CALL_P ( insns ) = <NUM_LIT> ; tmp_reg = gen_reg_rtx ( SImode ) ; emit_move_insn ( tmp_reg , reg0 ) ; x = tmp_reg ; break ; case TLS_MODEL_INITIAL_EXEC : pat = gen_rtx_UNSPEC ( SImode , gen_rtvec ( <NUM_LIT>


<s> rtx tmp_reg ; rtx tp_reg = gen_rtx_REG ( Pmode , TP_REGNUM ) ; rtx pat , insns , reg0 ; int relax_group_id = nds32_alloc_relax_group_id ( ) ; if ( GET_CODE ( x ) == SYMBOL_REF ) switch ( SYMBOL_REF_TLS_MODEL ( x ) ) { case TLS_MODEL_GLOBAL_DYNAMIC : case TLS_MODEL_LOCAL_DYNAMIC : if ( SYMBOL_REF_TLS_MODEL ( x ) == TLS_MODEL_GLOBAL_DYNAMIC ) pat = gen_rtx_UNSPEC ( SImode , gen_rtvec ( <NUM_LIT> , x ) , UNSPEC_TLSGD ) ; else pat = gen_rtx_UNSPEC ( SImode , gen_rtvec ( <NUM_LIT> , x ) , UNSPEC_TLSLD ) ; pat = gen_rtx_CONST ( SImode , pat ) ; reg0 = gen_rtx_REG ( Pmode , <NUM_LIT> ) ; insns = emit_call_insn ( gen_tls_desc ( pat , GEN_INT ( relax_group_id ) ) ) ; use_reg ( & CALL_INSN_FUNCTION_USAGE ( insns ) , pic_offset_table_rtx ) ; RTL_CONST_CALL_P ( insns ) = <NUM_LIT> ; tmp_reg = gen_reg_rtx ( SImode ) ; emit_move_insn ( tmp_reg , reg0 ) ; x = tmp_reg ; break ; case TLS_MODEL_INITIAL_EXEC : pat = gen_rtx_UNSPEC ( SImode , gen_rtvec ( <NUM_LIT> , x ) , UNSPEC_TLSIE ) ; tmp_reg = gen_reg_rtx ( SImode ) ; pat = gen_rtx_CONST ( SImode , pat ) ; emit_insn ( gen_tls_ie ( tmp_reg , pat , GEN_INT ( relax_group_id ) ) ) ; if ( flag_pic ) emit_use ( pic_offset_table_rtx ) ; x = gen_rtx_PLUS ( Pmode , tmp_reg , tp_reg ) ; break ; case TLS_MODEL_LOCAL_EXEC : tmp_reg = gen_reg_rtx ( SImode ) ; pat = gen_rtx_UNSPEC ( SImode , gen_rtvec ( <NUM_LIT> , x ) , UNSPEC_TLSLE ) ; pat = gen_rtx_CONST ( SImode , pat ) ; emit_insn ( gen_tls_le ( tmp_reg , pat , GEN_INT ( relax_group_id ) ) ) ; x = gen_rtx_PLUS ( Pmode , tmp_reg , tp_reg ) ; break ; default : gcc_unreachable ( ) ; } else if ( GET_CODE ( x ) == CONST ) { rtx base , addend ; split_const ( x , & base , & addend ) ; if ( SYMBOL_REF_TLS_MODEL ( base ) == TLS_MODEL_LOCAL_EXEC ) { tmp_reg = gen_reg_rtx (


<s> regno = REGNO ( XEXP ( op , <NUM_LIT> ) ) ; if ( regno > <NUM_LIT> && regno != SP_REGNUM && regno != FP_REGNUM ) return ADDRESS_NOT_16BIT_FORMAT ; switch ( mode_test ) { case E_QImode : if ( val >= <NUM_LIT> && val < <NUM_LIT> && regno < <NUM_LIT> ) return ADDRESS_LO_REG_IMM3U ; break ; case E_HImode : if ( val >= <NUM_LIT> && val < <NUM_LIT> && ( val % <NUM_LIT> == <NUM_LIT> ) && regno < <NUM_LIT> ) return ADDRESS_LO_REG_IMM3U ; break ; case E_SImode : case E_SFmode : case E_DFmode : if ( ( regno == <NUM_LIT> ) && ( val >= - <NUM_LIT> && val <= - <NUM_LIT> && ( val % <NUM_LIT> == <NUM_LIT> ) ) ) return ADDRESS_R8_IMM7U ; if ( ( regno == FP_REGNUM ) && ( val >= <NUM_LIT> && val < <NUM_LIT> && ( val % <NUM_LIT> == <NUM_LIT> ) ) ) return ADDRESS_FP_IMM7U ; else if ( ( regno == SP_REGNUM ) && ( val >= <NUM_LIT> && val < <NUM_LIT> && ( val % <NUM_LIT> == <NUM_LIT> ) ) ) return ADDRESS_SP_IMM7U ; else if ( val >= <NUM_LIT> && val < <NUM_LIT> && ( val %


<s> if ( INTVAL ( in0_idx0 ) == INTVAL ( in1_idx0 ) && INTVAL ( in0_idx1 ) == INTVAL ( in1_idx1 ) && INTVAL ( in0_idx0 ) != INTVAL ( in0_idx1 ) ) return false ; if ( INTVAL ( in0_idx0 ) != INTVAL ( in0_idx1 ) && INTVAL ( in1_idx0 ) != INTVAL ( in1_idx1 ) ) return false ; return true


<s> if ( INTVAL ( in0_idx0 ) != INTVAL ( in0_idx1 ) && INTVAL ( in1_idx0

) != INTVAL ( in1_idx1 ) ) return false ;


<s> break ; case ADDRESS_POST_INC_LO_REG_IMM3U : snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> ) ; output_asm_insn ( pattern , operands ) ; break ; case ADDRESS_POST_MODIFY_LO_REG_IMM3U : snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> ) ; output_asm_insn ( pattern , operands ) ; break ; case ADDRESS_FP_IMM7U : output_asm_insn ( <STR_LIT> , operands ) ; break ; case ADDRESS_SP_IMM7U


<s> case ADDRESS_LO_REG_IMM3U : snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> , size ) ; output_asm_insn ( pattern , operands ) ; break ; case ADDRESS_POST_INC_LO_REG_IMM3U : snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> ) ; output_asm_insn ( pattern , operands ) ; break ; case ADDRESS_POST_MODIFY_LO_REG_IMM3U : snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> ) ; output_asm_insn ( pattern , operands ) ; break ; case ADDRESS_FP_IMM7U : output_asm_insn ( <STR_LIT> , operands )


<s> case POST_MODIFY : switch ( GET_CODE ( XEXP ( XEXP ( code , <NUM_LIT> ) , <NUM_LIT> ) ) ) { case REG : case SUBREG : snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> , size ) ; break ; case CONST_INT : snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> , size ) ; break ; default : abort ( ) ; } break ; case PLUS : switch ( GET_CODE ( XEXP ( code , <NUM_LIT> ) ) ) { case REG : case SUBREG : snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> , size ) ; break ; case


<s> if ( align_p ) strcat ( pattern , <STR_LIT> ) ; noreturn_p = find_reg_note ( insn , REG_NORETURN , NULL_RTX ) != NULL_RTX ; if ( noreturn_p ) { if ( TARGET_16_BIT ) strcat ( pattern , <STR_LIT> ) ; else strcat ( pattern ,


<s> bool noreturn_p ; if ( nds32_long_call_p ( symbol ) ) strcpy ( pattern , long_call ) ; else strcpy ( pattern , call ) ; if ( flag_pic && CONSTANT_P ( symbol ) && ! nds32_symbol_binds_local_p ( symbol ) ) strcat ( pattern , <STR_LIT> ) ; if ( align_p ) strcat ( pattern , <STR_LIT> ) ; noreturn_p = find_reg_note ( insn , REG_NORETURN , NULL_RTX


<s> output_asm_insn ( <STR_LIT> , operands ) ; } else output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; if ( TARGET_16_BIT


<s> insn_length = get_attr_length ( insn ) ; long_jump_p = ( insn_length == <NUM_LIT> || insn_length == <NUM_LIT> ) ? true : false ; r5_p = ( insn_length == <NUM_LIT> || insn_length == <NUM_LIT> ) ? true : false ; code = GET_CODE ( operands [ <NUM_LIT> ] ) ; switch ( code


<s> insn_length = get_attr_length ( insn ) ; long_jump_p = ( insn_length == <NUM_LIT> || insn_length == <NUM_LIT> ) ? true : false ; r5_p = ( insn_length == <NUM_LIT> || insn_length == <NUM_LIT> ) ? true : false ; code = GET_CODE ( operands [ <NUM_LIT> ] ) ; switch ( code ) { case EQ


<s> gcc_assert ( insn_length == <NUM_LIT> || insn_length == <NUM_LIT> ) ; long_jump_p = ( insn_length == <NUM_LIT> ) ? true : false ; code = GET_CODE ( operands [ <NUM_LIT> ] ) ; switch ( code ) { case GT : case GE : case LT


<s> gcc_assert ( insn_length == <NUM_LIT> || insn_length == <NUM_LIT> ) ; long_jump_p = ( insn_length == <NUM_LIT> ) ? true : false ; code = GET_CODE ( operands [ <NUM_LIT> ] ) ; switch ( code ) { case GT : case GE : case LT : case LE : output_cond_branch_compare_zero ( code , <STR_LIT> , long_jump_p , operands , false ) ; break ; default : gcc_unreachable ( ) ; } return


<s> int reg = load_p ? <NUM_LIT> : <NUM_LIT> ; int mem = load_p ? <NUM_LIT> : <NUM_LIT> ; rtx otherops [ <NUM_LIT> ] ; rtx addr = XEXP ( operands [ mem ] , <NUM_LIT> ) ; otherops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , REGNO ( operands [ reg ] ) ) ; otherops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , REGNO ( operands [ reg ] ) + <NUM_LIT> ) ; if ( GET_CODE ( addr ) == POST_INC ) { otherops [ <NUM_LIT> ] = XEXP ( addr , <NUM_LIT> ) ; snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> , load_p ? 'l' : 's' ) ; } else { otherops [ <NUM_LIT> ] = addr ; snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> , load_p ? 'l' : 's' ) ; } output_asm_insn ( pattern , otherops )


<s> else if ( REG_P ( addr_op0 ) && CONST_INT_P ( addr_op1 ) ) pattern = <STR_LIT> ; else if ( GET_CODE ( addr_op0 ) == MULT && REG_P ( addr_op1 ) && REG_P ( XEXP ( addr_op0 , <NUM_LIT> ) ) && CONST_INT_P ( XEXP ( addr_op0 , <NUM_LIT> ) ) ) pattern = <STR_LIT> ; else gcc_unreachable ( ) ; break ; case POST_MODIFY : addr_op0 = XEXP ( addr , <NUM_LIT> ) ; addr_op1 = XEXP ( addr , <NUM_LIT> ) ; if ( REG_P ( addr_op0 ) && GET_CODE ( addr_op1 ) == PLUS && REG_P ( XEXP ( addr_op1 , <NUM_LIT> ) ) ) pattern = <STR_LIT> ; else if ( REG_P ( addr_op0 ) && GET_CODE ( addr_op1 ) == PLUS && CONST_INT_P ( XEXP ( addr_op1 , <NUM_LIT> ) ) ) pattern = <STR_LIT> ; else gcc_unreachable ( ) ; break ; case POST_INC : if ( REG_P ( XEXP ( addr , <NUM_LIT> ) ) ) { if ( dp ) pattern = <STR_LIT> ; else pattern = <STR_LIT> ; } else gcc_unreachable ( ) ; break ; case POST_DEC : if ( REG_P ( XEXP ( addr , <NUM_LIT>


<s> update_base_p = true ; base_reg = XEXP ( XEXP ( base_addr , <NUM_LIT> ) , <NUM_LIT> ) ; } const char * update_base = update_base_p ? <STR_LIT> : <STR_LIT> ; regno = REGNO ( operands [ <NUM_LIT> ] ) ; otherops [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; otherops [ <NUM_LIT> ] = base_reg ; if ( regno >= <NUM_LIT> ) { enable4 = nds32_regno_to_enable4 ( regno ) ; sprintf ( buff , <STR_LIT> , update_base , enable4 ) ; } else { sprintf ( buff , <STR_LIT> , update_base ) ; } output_asm_insn ( buff , otherops ) ; return


<s> if ( satisfies_constraint_Iu08 ( GEN_INT ( sp_adjust ) ) && NDS32_DOUBLE_WORD_ALIGN_P ( sp_adjust ) && ! cfun -> calls_alloca ) operands [ <NUM_LIT> ] = GEN_INT ( sp_adjust ) ; else operands [ <NUM_LIT> ] = GEN_INT ( <NUM_LIT> ) ; snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> ) ; output_asm_insn ( pattern , operands ) ; return <STR_LIT>


<s> else return <STR_LIT> ; } else { if ( TARGET_BIG_ENDIAN ) return <STR_LIT> ; else return <STR_LIT> ; } } if ( INTVAL ( in0_idx0 ) != INTVAL ( in0_idx1 ) && INTVAL ( in1_idx0 ) != INTVAL ( in1_idx1 ) ) { if ( INTVAL ( in0_idx0 ) == <NUM_LIT> ) { if ( TARGET_BIG_ENDIAN ) return <STR_LIT> ; else return <STR_LIT> ; } else { if ( TARGET_BIG_ENDIAN ) return <STR_LIT> ; else return <STR_LIT> ; } } gcc_unreachable ( ) ; return <STR_LIT>


<s> if ( REG_P ( XEXP ( base_addr , <NUM_LIT> ) ) ) { update_base_p = false ; base_reg = XEXP ( base_addr , <NUM_LIT> ) ; } else { update_base_p = true ; base_reg = XEXP ( XEXP ( base_addr , <NUM_LIT> ) , <NUM_LIT> ) ; } const char * update_base = update_base_p ? <STR_LIT> : <STR_LIT> ; regno = REGNO ( operands [ <NUM_LIT> ] ) ; otherops [ <NUM_LIT> ] = base_reg ; otherops [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; otherops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , REGNO ( operands [ <NUM_LIT> ] ) + <NUM_LIT> ) ; ; if ( regno >= <NUM_LIT> ) { enable4 = nds32_regno_to_enable4 ( regno ) | nds32_regno_to_enable4 ( regno + <NUM_LIT> ) ; sprintf ( buff , <STR_LIT> , update_base , enable4 ) ; } else if ( regno == <NUM_LIT> ) { enable4 = nds32_regno_to_enable4 ( regno


<s> otherops [ <NUM_LIT> ] = base_reg ; otherops [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; otherops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , REGNO ( operands [ <NUM_LIT> ] ) + <NUM_LIT> ) ; ; if ( regno >= <NUM_LIT> ) { enable4 = nds32_regno_to_enable4 ( regno ) | nds32_regno_to_enable4 ( regno + <NUM_LIT> ) ; sprintf ( buff , <STR_LIT> , update_base , enable4 ) ; } else if ( regno == <NUM_LIT> ) { enable4 = nds32_regno_to_enable4 ( regno + <NUM_LIT> ) ; sprintf ( buff , <STR_LIT> , update_base , enable4 ) ; } else { sprintf ( buff , <STR_LIT>


<s> const char * nds32_output_smw_single_word ( rtx * operands ) { char buff [ <NUM_LIT> ] ; unsigned regno ; int enable4 ; bool update_base_p ; rtx base_addr = operands [ <NUM_LIT> ] ; rtx base_reg ; rtx otherops [ <NUM_LIT> ] ; if ( REG_P ( XEXP ( base_addr , <NUM_LIT> ) ) ) { update_base_p = false ; base_reg = XEXP ( base_addr , <NUM_LIT> ) ; } else { update_base_p = true ; base_reg = XEXP ( XEXP ( base_addr , <NUM_LIT> ) , <NUM_LIT> ) ; } const char * update_base = update_base_p ? <STR_LIT> : <STR_LIT> ; regno = REGNO ( operands [ <NUM_LIT> ] ) ; otherops [ <NUM_LIT> ] = base_reg ; otherops [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; if ( regno >= <NUM_LIT> ) { enable4 = nds32_regno_to_enable4 ( regno ) ; sprintf ( buff , <STR_LIT> , update_base


<s> else { update_base_p = true ; base_reg = XEXP ( XEXP ( base_addr , <NUM_LIT> ) , <NUM_LIT> ) ; } const char * update_base = update_base_p ? <STR_LIT> : <STR_LIT> ; regno = REGNO ( operands [ <NUM_LIT> ] ) ; otherops [ <NUM_LIT> ] = base_reg ; otherops [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; if ( regno >= <NUM_LIT> ) { enable4 = nds32_regno_to_enable4 ( regno ) ; sprintf ( buff , <STR_LIT> , update_base ,


<s> else { if ( cfun -> machine -> callee_saved_first_fpr_regno != SP_REGNUM ) { sp_adjust = cfun -> machine -> callee_saved_area_gpr_padding_bytes + cfun -> machine -> callee_saved_fpr_regs_size ; operands [ <NUM_LIT> ] = GEN_INT ( sp_adjust ) ; } else { operands [ <NUM_LIT> ] = GEN_INT ( <NUM_LIT> ) ; } } snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> ) ; } else { int pop_en4_only_p = <NUM_LIT> ; operands [ <NUM_LIT> ] = gen_rtx_REG ( SImode , rb_callee_saved ) ; operands [ <NUM_LIT> ] = gen_rtx_REG ( SImode , re_callee_saved ) ; if ( ! cfun -> machine -> fp_size && ! cfun -> machine -> gp_size && ! cfun -> machine -> lp_size && REGNO ( operands [ <NUM_LIT> ] ) == SP_REGNUM && REGNO ( operands [ <NUM_LIT> ] ) == SP_REGNUM ) { return <STR_LIT> ; } else { if ( REGNO ( operands [ <NUM_LIT> ] ) == SP_REGNUM && REGNO ( operands [ <NUM_LIT> ] ) == SP_REGNUM ) pop_en4_only_p = <NUM_LIT> ; snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> , pop_en4_only_p ? <STR_LIT> : <STR_LIT> , cfun -> machine -> fp_size ? <STR_LIT> : <STR_LIT> , cfun -> machine -> gp_size ? <STR_LIT> : <STR_LIT> , cfun -> machine -> lp_size ? <STR_LIT> : <STR_LIT> ) ; } } output_asm_insn ( pattern ,


<s> char pattern [ <NUM_LIT> ] ; rtx operands [ <NUM_LIT> ] ; int rb_va_args = cfun -> machine -> va_args_first_regno ; int re_va_args = cfun -> machine -> va_args_last_regno ; int last_argument_regno = NDS32_FIRST_GPR_REGNUM + NDS32_MAX_GPR_REGS_FOR_ARGS - <NUM_LIT> ; int rb_eh_data = cfun -> machine -> eh_return_data_first_regno ; int re_eh_data = cfun -> machine -> eh_return_data_last_regno ; int first_eh_data_regno = EH_RETURN_DATA_REGNO ( <NUM_LIT> ) ; int rb_callee_saved = cfun -> machine -> callee_saved_first_gpr_regno ; int re_callee_saved = cfun -> machine -> callee_saved_last_gpr_regno ; if ( reg_mentioned_p ( gen_rtx_REG ( SImode , last_argument_regno ) , par_rtx ) ) { operands [ <NUM_LIT> ] = gen_rtx_REG ( SImode , rb_va_args ) ; operands [ <NUM_LIT> ] = gen_rtx_REG ( SImode , re_va_args ) ; snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> , <STR_LIT> ) ; output_asm_insn ( pattern , operands ) ; return <STR_LIT> ; } if ( reg_mentioned_p ( gen_rtx_REG ( SImode , first_eh_data_regno ) , par_rtx ) ) { operands [ <NUM_LIT> ] = gen_rtx_REG ( SImode , rb_eh_data ) ; operands [ <NUM_LIT> ] = gen_rtx_REG ( SImode , re_eh_data ) ; snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> , <STR_LIT> ) ; output_asm_insn ( pattern , operands ) ; return <STR_LIT> ; } if ( NDS32_V3PUSH_AVAILABLE_P ) { int sp_adjust ; operands [ <NUM_LIT> ] = gen_rtx_REG ( SImode , re_callee_saved ) ; sp_adjust = cfun -> machine -> local_size + cfun -> machine -> out_args_size + cfun -> machine -> callee_saved_area_gpr_padding_bytes + cfun -> machine -> callee_saved_fpr_regs_size ; if ( satisfies_constraint_Iu08 ( GEN_INT ( sp_adjust ) ) && NDS32_DOUBLE_WORD_ALIGN_P ( sp_adjust ) ) operands [ <NUM_LIT> ] = GEN_INT ( sp_adjust ) ; else { if ( cfun -> machine -> callee_saved_first_fpr_regno != SP_REGNUM ) { sp_adjust = cfun -> machine -> callee_saved_area_gpr_padding_bytes + cfun -> machine -> callee_saved_fpr_regs_size ; operands [ <NUM_LIT> ] = GEN_INT ( sp_adjust ) ; } else { operands [ <NUM_LIT> ] = GEN_INT ( <NUM_LIT> ) ; } } snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> ) ; } else { int push_en4_only_p = <NUM_LIT> ; operands [ <NUM_LIT> ] = gen_rtx_REG ( SImode , rb_callee_saved ) ; operands [ <NUM_LIT> ] = gen_rtx_REG ( SImode , re_callee_saved ) ; if ( ! cfun -> machine -> fp_size && ! cfun -> machine -> gp_size && ! cfun -> machine -> lp_size && REGNO ( operands [ <NUM_LIT> ] ) == SP_REGNUM && REGNO ( operands [ <NUM_LIT> ] ) == SP_REGNUM ) { return <STR_LIT>


<s> else snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> <STR_LIT> ) ; output_asm_insn ( pattern , operands ) ; return <STR_LIT>


<s> char pattern [ <NUM_LIT> ] ; if ( TARGET_RELAX_HINT ) snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> <STR_LIT> <STR_LIT> <STR_LIT> <STR_LIT> ) ; else snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> <STR_LIT> <STR_LIT> <STR_LIT> <STR_LIT> ) ; output_asm_insn ( pattern ,


<s> else snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> <STR_LIT> <STR_LIT> ) ; } else { if ( TARGET_RELAX_HINT ) snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> <STR_LIT> ) ; else snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> <STR_LIT> ) ; } output_asm_insn ( pattern ,


<s> rtx src_high_part , src_low_part ; rtx dst_high_part , dst_low_part ; dst_high_part = nds32_di_high_part_subreg ( dst ) ; dst_low_part = nds32_di_low_part_subreg ( dst ) ; src_high_part = nds32_di_high_part_subreg ( src ) ; src_low_part = nds32_di_low_part_subreg ( src ) ; if ( CONST_INT_P ( shiftamount ) ) { if ( INTVAL ( shiftamount ) < <NUM_LIT> ) { rtx ext_start ; ext_start = gen_int_mode ( <NUM_LIT> - INTVAL ( shiftamount ) , SImode ) ; emit_insn ( gen_wext ( dst_high_part , src , ext_start ) ) ; emit_insn ( gen_ashlsi3 ( dst_low_part , src_low_part , shiftamount ) ) ; } else { rtx new_shift_amout = gen_int_mode ( INTVAL ( shiftamount ) - <NUM_LIT> , SImode ) ; emit_insn ( gen_ashlsi3 ( dst_high_part , src_low_part , new_shift_amout ) ) ; emit_move_insn ( dst_low_part , GEN_INT ( <NUM_LIT> ) ) ; } } else { rtx dst_low_part_l32 , dst_high_part_l32 ; rtx dst_low_part_g32 , dst_high_part_g32 ; rtx new_shift_amout , select_reg ; dst_low_part_l32 = gen_reg_rtx ( SImode ) ; dst_high_part_l32 = gen_reg_rtx ( SImode ) ; dst_low_part_g32 = gen_reg_rtx ( SImode ) ; dst_high_part_g32 = gen_reg_rtx ( SImode ) ; new_shift_amout = gen_reg_rtx ( SImode ) ; select_reg = gen_reg_rtx ( SImode ) ; rtx ext_start ; ext_start = gen_reg_rtx ( SImode ) ; emit_insn ( gen_subsi3 ( ext_start , gen_int_mode ( <NUM_LIT> , SImode ) , shiftamount ) ) ; emit_insn ( gen_wext ( dst_high_part_l32 , src , ext_start ) ) ; emit_insn ( gen_cmovzsi ( dst_high_part_l32 , shiftamount , src_high_part , dst_high_part_l32 )


<s> nds32_split_shiftrtdi3 ( dst , src , shiftamount ,


<s> void nds32_split_ashiftrtdi3 ( rtx dst , rtx src ,


<s> nds32_split_shiftrtdi3 ( dst , src , shiftamount , true


<s> void nds32_split_sms ( rtx out , rtx in0 , rtx in1 , rtx in0_idx0 , rtx in1_idx0 , rtx in0_idx1 , rtx in1_idx1 ) { rtx result0 = gen_reg_rtx ( SImode ) ; rtx result1 = gen_reg_rtx ( SImode


<s> static bool nds32_symbol_binds_local_p ( const_rtx x ) { return ( SYMBOL_REF_DECL ( x ) ? targetm . binds_local_p ( SYMBOL_REF_DECL ( x )


<s> if ( ! targetm . have_tls ) return false ; if ( GET_CODE ( x ) == CONST && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS ) x = XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ; if ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (


<s> else { if ( GET_CODE ( base_addr ) == POST_INC && REG_P ( XEXP ( base_addr , <NUM_LIT> ) ) ) return true ; } return false


<s> const char * cond_code ; bool align_p = NDS32_ALIGN_P ( ) ; const char * align = align_p ? <STR_LIT> : <STR_LIT> ; if ( long_jump_p ) { int inverse_code = nds32_inverse_cond_code ( code ) ; cond_code = nds32_cond_code_str ( inverse_code ) ; if ( ta_implied_p && TARGET_16_BIT ) { snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> , cond_code , suffix , align ) ; } else { snprintf ( pattern , sizeof ( pattern ) , <STR_LIT> , cond_code , suffix , align ) ; } } else { cond_code = nds32_cond_code_str (


<s> fmt = GET_RTX_FORMAT ( GET_CODE ( op ) ) ; for ( i = GET_RTX_LENGTH ( GET_CODE ( op ) ) - <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) { if ( fmt [ i ] == 'E' ) { int j ; for ( j = XVECLEN ( op , i ) - <NUM_LIT> ; j >= <NUM_LIT> ; j -- ) if ( symbolic_reference_mentioned_p ( XVECEXP ( op , i , j ) ) ) return true ; } else if ( fmt [ i ] == 'e' && symbolic_reference_mentioned_p ( XEXP ( op , i ) ) ) return true ; } return false


<s> mem = adjust_automodify_address_nv ( basemem , SImode , new_addr , offset ) ; reg = gen_rtx_REG ( SImode , base_regno + par_index ) ; XVECEXP ( result , <NUM_LIT> , par_index ) = gen_rtx_SET (


<s> int maximum_bytes ; if ( TARGET_REDUCED_REGS ) maximum_bytes = <NUM_LIT> ; else maximum_bytes = <NUM_LIT> ; if ( GET_CODE ( total_bytes ) != CONST_INT || GET_CODE ( alignment ) != CONST_INT || INTVAL ( total_bytes ) > maximum_bytes || INTVAL ( total_bytes ) & <NUM_LIT> || INTVAL ( alignment ) & <NUM_LIT> ) return <NUM_LIT> ; dst_base_reg = copy_to_mode_reg ( SImode , XEXP ( dstmem , <NUM_LIT> ) ) ; src_base_reg = copy_to_mode_reg ( SImode , XEXP ( srcmem , <NUM_LIT> ) ) ; out_words = in_words = INTVAL ( total_bytes ) /


<s> mem = adjust_automodify_address_nv ( basemem , SImode , new_addr , offset ) ; reg = gen_rtx_REG ( SImode , base_regno + par_index ) ; XVECEXP ( result , <NUM_LIT> , par_index ) = gen_rtx_SET ( VOIDmode , mem , reg


<s> offset = par_index * <NUM_LIT> ; new_addr = plus_constant ( Pmode , base_addr , offset ) ; mem = adjust_automodify_address_nv ( basemem , SImode , new_addr , offset ) ; reg = gen_rtx_REG ( SImode , base_regno + par_index ) ; XVECEXP ( result , <NUM_LIT> , par_index ) = gen_rtx_SET (


<s> rtx nds32_expand_load_multiple ( int base_regno , int count , rtx base_addr , rtx basemem ) { int par_index ; int offset ; rtx result ; rtx new_addr , mem , reg ; result = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( count ) ) ; for ( par_index = <NUM_LIT> ; par_index < count ; par_index ++ ) { offset = par_index * <NUM_LIT> ; new_addr = plus_constant ( Pmode , base_addr , offset ) ; mem = adjust_automodify_address_nv ( basemem , SImode , new_addr , offset ) ; reg = gen_rtx_REG ( SImode , base_regno + par_index ) ; XVECEXP ( result , <NUM_LIT> , par_index ) = gen_rtx_SET ( reg , mem ) ; } return


<s> mem = adjust_automodify_address_nv ( basemem , SImode , new_addr , offset ) ; reg = gen_rtx_REG ( SImode , base_regno + par_index ) ; XVECEXP ( result , <NUM_LIT> , par_index ) = gen_rtx_SET


<s> rtx nds32_expand_store_multiple ( int base_regno , int count , rtx base_addr , rtx basemem ) { int par_index ; int offset ; rtx result ; rtx new_addr , mem , reg ; result = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( count ) ) ; for ( par_index = <NUM_LIT> ; par_index < count ; par_index ++ ) { offset = par_index * <NUM_LIT> ; new_addr = plus_constant ( Pmode , base_addr , offset ) ; mem = adjust_automodify_address_nv ( basemem , SImode , new_addr , offset ) ; reg = gen_rtx_REG ( SImode , base_regno + par_index ) ; XVECEXP ( result , <NUM_LIT> , par_index ) = gen_rtx_SET ( mem , reg ) ; } return result


<s> if ( ! optimize_size && optimize > <NUM_LIT> ) return nds32_expand_movmemsi_loop ( dstmem , srcmem , total_bytes , alignment ) ; return


<s> bool nds32_expand_movmemsi ( rtx dstmem , rtx srcmem , rtx total_bytes , rtx alignment ) { if ( nds32_expand_movmemsi_unroll ( dstmem , srcmem , total_bytes , alignment ) ) return true ; if ( ! optimize_size && optimize > <NUM_LIT> ) return nds32_expand_movmemsi_loop ( dstmem , srcmem ,


<s> if ( CONST_INT_P ( size ) ) return nds32_expand_movmemsi_loop_known_size ( dstmem , srcmem , size , alignment ) ; else return nds32_expand_movmemsi_loop_unknown_size ( dstmem , srcmem


<s> static bool nds32_expand_movmemsi_loop_known_size ( rtx dstmem , rtx srcmem , rtx


<s> static bool nds32_expand_movmemsi_loop_unknown_size ( rtx dstmem , rtx srcmem , rtx size , rtx alignment ) { rtx dst_base_reg , src_base_reg ; rtx dst_itr , src_itr ; rtx dstmem_m , srcmem_m , dst_itr_m , src_itr_m ; rtx dst_end ; rtx size_least_3_bit ; rtx double_word_end ; rtx double_word_mode_loop , byte_mode_entry , byte_mode_loop , end_label ; rtx tmp ; rtx mask_least_3_bit ; int start_regno ; bool align_to_4_bytes = ( INTVAL ( alignment ) & <NUM_LIT> ) == <NUM_LIT> ; if ( TARGET_ISA_V3M && ! align_to_4_bytes ) return <NUM_LIT> ; if ( TARGET_REDUCED_REGS ) start_regno = <NUM_LIT> ; else start_regno = <NUM_LIT> ; dst_itr = gen_reg_rtx ( Pmode ) ; src_itr = gen_reg_rtx ( Pmode ) ; dst_end = gen_reg_rtx ( Pmode ) ; tmp = gen_reg_rtx ( QImode ) ; mask_least_3_bit = GEN_INT ( ~ <NUM_LIT> ) ; double_word_mode_loop = gen_label_rtx ( ) ; byte_mode_entry = gen_label_rtx ( ) ; byte_mode_loop = gen_label_rtx ( ) ; end_label = gen_label_rtx ( ) ; dst_base_reg = copy_to_mode_reg ( Pmode , XEXP ( dstmem , <NUM_LIT> ) ) ; src_base_reg = copy_to_mode_reg ( Pmode , XEXP ( srcmem , <NUM_LIT> ) ) ; size_least_3_bit = expand_binop ( SImode , and_optab , size , mask_least_3_bit , NULL_RTX , <NUM_LIT> , OPTAB_WIDEN ) ; dst_end = expand_binop ( Pmode , add_optab , dst_base_reg , size , NULL_RTX , <NUM_LIT> , OPTAB_WIDEN ) ; emit_move_insn ( dst_itr , dst_base_reg ) ; emit_move_insn ( src_itr , src_base_reg ) ; emit_cmp_and_jump_insns ( size_least_3_bit , const0_rtx , EQ , NULL , SImode , <NUM_LIT> , byte_mode_entry ) ; double_word_end = expand_binop ( Pmode , add_optab , dst_base_reg , size_least_3_bit , NULL_RTX , <NUM_LIT> , OPTAB_WIDEN ) ; emit_label ( double_word_mode_loop )


<s> rtx value4word ; rtx value4byte ; rtx dst ; rtx byte_mode_size ; dst = copy_to_mode_reg ( SImode , XEXP ( dstmem , <NUM_LIT> ) ) ; value4word = nds32_gen_dup_4_byte_to_word_value ( value ) ; byte_mode_size = emit_setmem_word_loop ( dst , size , value4word ) ; value4byte = simplify_gen_subreg ( QImode , value4word , SImode , subreg_lowpart_offset ( QImode , SImode ) ) ; emit_setmem_byte_loop ( dst , byte_mode_size ,


<s> byte_mode_size = emit_setmem_word_loop ( dst , size , value4word ) ; value4byte = simplify_gen_subreg ( QImode , value4word , SImode , subreg_lowpart_offset ( QImode , SImode ) ) ; emit_setmem_byte_loop ( dst , byte_mode_size , value4byte , false ) ; return true


<s> rtx last_2_bit = gen_reg_rtx ( SImode ) ; rtx byte_loop_base = gen_reg_rtx ( SImode ) ; rtx byte_loop_size = gen_reg_rtx ( SImode ) ; rtx remain_size = gen_reg_rtx ( SImode ) ; rtx new_base_reg ; rtx value4byte , value4word ; rtx byte_mode_size ; rtx last_byte_loop_label = gen_label_rtx ( ) ; size = force_reg ( SImode , size ) ; value4word = nds32_gen_dup_4_byte_to_word_value ( value ) ; value4byte = simplify_gen_subreg ( QImode , value4word , SImode , <NUM_LIT> ) ; emit_move_insn ( byte_loop_size , size ) ; emit_move_insn ( byte_loop_base , base_reg ) ; emit_cmp_and_jump_insns ( size , gen_int_mode ( <NUM_LIT> , SImode ) , LE , NULL , SImode , <NUM_LIT> , last_byte_loop_label ) ; emit_insn ( gen_andsi3 ( last_2_bit , base_reg , gen_int_mode ( <NUM_LIT> , SImode ) ) ) ; emit_insn ( gen_subsi3 ( need_align_bytes , gen_int_mode ( <NUM_LIT> , SImode ) , last_2_bit ) ) ; new_base_reg = emit_setmem_byte_loop ( base_reg , need_align_bytes , value4byte , true ) ; emit_insn ( gen_subsi3 ( remain_size , size , need_align_bytes ) ) ; byte_mode_size = emit_setmem_word_loop ( new_base_reg , remain_size , value4word ) ; emit_move_insn ( byte_loop_base , new_base_reg ) ; emit_move_insn ( byte_loop_size , byte_mode_size ) ; emit_label ( last_byte_loop_label


<s> src_base_reg = copy_to_mode_reg ( Pmode , XEXP ( srcmem , <NUM_LIT> ) ) ; if ( total_bytes < <NUM_LIT> ) { dst_end = expand_binop ( Pmode , add_optab , dst_base_reg , size , NULL_RTX , <NUM_LIT> , OPTAB_WIDEN ) ; emit_move_insn ( dst_itr , dst_base_reg ) ; emit_move_insn ( src_itr , src_base_reg ) ; emit_label ( byte_mode_loop ) ; nds32_emit_post_inc_load_store ( tmp , src_itr , QImode , true ) ; nds32_emit_post_inc_load_store ( tmp , dst_itr , QImode , false ) ; emit_cmp_and_jump_insns ( dst_itr , dst_end , NE , NULL , SImode , <NUM_LIT> , byte_mode_loop ) ; return true ; } else if ( total_bytes % <NUM_LIT> == <NUM_LIT> ) { dst_end = expand_binop ( Pmode , add_optab , dst_base_reg , size , NULL_RTX , <NUM_LIT> , OPTAB_WIDEN ) ; emit_move_insn ( dst_itr , dst_base_reg ) ; emit_move_insn ( src_itr , src_base_reg ) ; emit_label ( double_word_mode_loop ) ; src_itr_m = src_itr ; dst_itr_m = dst_itr ; srcmem_m = srcmem ; dstmem_m = dstmem ; nds32_emit_mem_move_block ( start_regno , <NUM_LIT> , & dst_itr_m , &

dstmem_m , & src_itr_m , & srcmem_m , true ) ;


<s> rtx end_label = gen_label_rtx ( ) ; value = force_reg ( QImode , value ) ; if ( need_end ) end = expand_binop ( Pmode , add_optab , itr , size , NULL_RTX , <NUM_LIT> , OPTAB_WIDEN ) ; emit_cmp_and_jump_insns ( size , const0_rtx , EQ , NULL , SImode , <NUM_LIT> , end_label ) ; if ( ! need_end ) end = expand_binop ( Pmode , add_optab , itr , size , NULL_RTX , <NUM_LIT> , OPTAB_WIDEN ) ; emit_label ( byte_mode_label ) ; nds32_emit_post_inc_load_store ( value , itr , QImode , false ) ; emit_cmp_and_jump_insns ( end , itr , NE , NULL , Pmode , <NUM_LIT> , byte_mode_label ) ; emit_label (


<s> rtx end_label = gen_label_rtx ( ) ; value = force_reg ( QImode , value ) ; if ( need_end ) end = expand_binop ( Pmode , add_optab , itr , size , NULL_RTX , <NUM_LIT> , OPTAB_WIDEN ) ; emit_cmp_and_jump_insns ( size , const0_rtx , EQ , NULL , SImode , <NUM_LIT> , end_label ) ; if ( ! need_end ) end = expand_binop ( Pmode , add_optab , itr , size , NULL_RTX , <NUM_LIT> , OPTAB_WIDEN ) ; emit_label ( byte_mode_label ) ; nds32_emit_post_inc_load_store ( value , itr , QImode ,


<s> static void nds32_emit_load_store ( rtx reg , rtx mem , enum machine_mode mode , int offset , bool load_p ) { rtx new_mem ; new_mem = adjust_address ( mem , mode , offset ) ; if ( load_p ) emit_move_insn ( reg , new_mem ) ; else emit_move_insn ( new_mem , reg


<s> static void nds32_emit_load_store ( rtx reg , rtx mem , enum machine_mode mode , int offset


<s> gcc_assert ( MEM_P ( src ) && MEM_P ( dst ) ) ; rtx tmp_reg = gen_reg_rtx ( mode ) ; nds32_emit_load_store ( tmp_reg , src , mode , addr_offset , true ) ; nds32_emit_load_store ( tmp_reg , dst , mode ,


<s> static void nds32_emit_mem_move ( rtx src , rtx dst , enum machine_mode mode , int addr_offset ) { gcc_assert ( MEM_P ( src ) && MEM_P ( dst ) ) ; rtx tmp_reg = gen_reg_rtx ( mode ) ; nds32_emit_load_store ( tmp_reg , src , mode , addr_offset , true ) ; nds32_emit_load_store ( tmp_reg , dst , mode , addr_offset


<s> emit_insn ( nds32_expand_store_multiple ( base_regno , count , * dst_base_reg , * dst_mem , update_base_reg_p , & new_base_reg ) ) ; if ( update_base_reg_p ) { * dst_base_reg = new_base_reg ; * dst_mem = gen_rtx_MEM ( SImode , *


<s> if ( update_base_reg_p ) { * src_base_reg = new_base_reg ; * src_mem = gen_rtx_MEM ( SImode , * src_base_reg ) ; } emit_insn ( nds32_expand_store_multiple ( base_regno , count , * dst_base_reg , * dst_mem , update_base_reg_p , & new_base_reg ) ) ; if ( update_base_reg_p )


<s> gcc_assert ( GET_MODE ( reg ) == mode ) ; gcc_assert ( GET_MODE ( base_reg ) == Pmode ) ; if ( load_p ) emit_move_insn ( reg , gen_rtx_MEM ( mode , base_reg ) ) ; else emit_move_insn ( gen_rtx_MEM ( mode , base_reg ) , reg ) ; emit_move_insn ( base_reg , plus_constant ( Pmode , base_reg


<s> if ( ! optimize_size && optimize > <NUM_LIT> ) return nds32_expand_cpymemsi_loop ( dstmem , srcmem


<s> if ( CONST_INT_P ( size ) ) return nds32_expand_cpymemsi_loop_known_size ( dstmem , srcmem , size , alignment


<s> static bool nds32_expand_cpymemsi_loop ( rtx dstmem , rtx srcmem , rtx size , rtx alignment ) { if ( CONST_INT_P ( size ) ) return nds32_expand_cpymemsi_loop_known_size (


<s> rtx dst_itr , src_itr ; rtx dstmem_m , srcmem_m , dst_itr_m , src_itr_m ; rtx dst_end ; rtx double_word_mode_loop , byte_mode_loop ; rtx tmp ; int start_regno ; bool align_to_4_bytes = ( INTVAL ( alignment ) & <NUM_LIT> ) == <NUM_LIT> ; unsigned HOST_WIDE_INT total_bytes = UINTVAL ( size ) ; if ( TARGET_ISA_V3M && ! align_to_4_bytes ) return <NUM_LIT> ; if ( TARGET_REDUCED_REGS ) start_regno = <NUM_LIT> ; else start_regno = <NUM_LIT> ; dst_itr = gen_reg_rtx ( Pmode ) ; src_itr = gen_reg_rtx ( Pmode ) ; dst_end = gen_reg_rtx ( Pmode ) ; tmp = gen_reg_rtx ( QImode ) ; double_word_mode_loop = gen_label_rtx ( ) ; byte_mode_loop = gen_label_rtx ( ) ; dst_base_reg = copy_to_mode_reg ( Pmode , XEXP ( dstmem , <NUM_LIT> ) ) ; src_base_reg = copy_to_mode_reg ( Pmode , XEXP ( srcmem , <NUM_LIT> ) ) ; if ( total_bytes < <NUM_LIT> ) { dst_end = expand_binop ( Pmode , add_optab , dst_base_reg , size , NULL_RTX , <NUM_LIT> , OPTAB_WIDEN ) ; emit_move_insn ( dst_itr , dst_base_reg ) ; emit_move_insn ( src_itr , src_base_reg ) ; emit_label ( byte_mode_loop ) ; nds32_emit_post_inc_load_store ( tmp , src_itr , QImode , true ) ; nds32_emit_post_inc_load_store ( tmp , dst_itr , QImode , false ) ; emit_cmp_and_jump_insns ( dst_itr , dst_end , NE , NULL , SImode , <NUM_LIT> , byte_mode_loop ) ; return true ; } else if ( total_bytes % <NUM_LIT> == <NUM_LIT> ) { dst_end = expand_binop ( Pmode , add_optab , dst_base_reg , size , NULL_RTX , <NUM_LIT> , OPTAB_WIDEN ) ; emit_move_insn ( dst_itr , dst_base_reg ) ; emit_move_insn ( src_itr , src_base_reg ) ; emit_label ( double_word_mode_loop ) ; src_itr_m = src_itr ; dst_itr_m = dst_itr ; srcmem_m = srcmem ; dstmem_m = dstmem ; nds32_emit_mem_move_block ( start_regno , <NUM_LIT> , & dst_itr_m , & dstmem_m , &


<s> else start_regno = <NUM_LIT> ; dst_itr = gen_reg_rtx ( Pmode ) ; src_itr = gen_reg_rtx ( Pmode ) ; dst_end = gen_reg_rtx ( Pmode ) ; tmp = gen_reg_rtx ( QImode ) ; double_word_mode_loop = gen_label_rtx ( ) ; byte_mode_loop = gen_label_rtx ( ) ; dst_base_reg = copy_to_mode_reg ( Pmode , XEXP ( dstmem , <NUM_LIT> ) ) ; src_base_reg = copy_to_mode_reg ( Pmode , XEXP ( srcmem , <NUM_LIT> ) ) ; if ( total_bytes < <NUM_LIT> ) { dst_end = expand_binop ( Pmode , add_optab , dst_base_reg , size , NULL_RTX , <NUM_LIT> , OPTAB_WIDEN ) ; emit_move_insn ( dst_itr , dst_base_reg ) ; emit_move_insn ( src_itr , src_base_reg ) ; emit_label ( byte_mode_loop ) ; nds32_emit_post_inc_load_store ( tmp , src_itr , QImode , true ) ; nds32_emit_post_inc_load_store ( tmp , dst_itr , QImode ,


<s> int start_regno ; bool align_to_4_bytes = ( INTVAL ( alignment ) & <NUM_LIT> ) == <NUM_LIT> ; if ( TARGET_ISA_V3M && ! align_to_4_bytes ) return <NUM_LIT> ; if ( TARGET_REDUCED_REGS ) start_regno = <NUM_LIT> ; else start_regno = <NUM_LIT> ; dst_itr = gen_reg_rtx ( Pmode ) ; src_itr = gen_reg_rtx ( Pmode ) ; dst_end = gen_reg_rtx ( Pmode ) ; tmp = gen_reg_rtx ( QImode ) ; mask_least_3_bit = GEN_INT ( ~ <NUM_LIT> ) ; double_word_mode_loop = gen_label_rtx ( ) ; byte_mode_entry = gen_label_rtx ( ) ; byte_mode_loop = gen_label_rtx ( ) ; end_label = gen_label_rtx ( ) ; dst_base_reg = copy_to_mode_reg ( Pmode , XEXP ( dstmem , <NUM_LIT> ) ) ; src_base_reg = copy_to_mode_reg ( Pmode , XEXP ( srcmem , <NUM_LIT> ) ) ; size_least_3_bit = expand_binop ( SImode , and_optab , size , mask_least_3_bit , NULL_RTX , <NUM_LIT> , OPTAB_WIDEN ) ; dst_end = expand_binop ( Pmode , add_optab , dst_base_reg , size , NULL_RTX , <NUM_LIT> , OPTAB_WIDEN ) ; emit_move_insn ( dst_itr , dst_base_reg ) ; emit_move_insn ( src_itr , src_base_reg ) ; emit_cmp_and_jump_insns ( size_least_3_bit , const0_rtx , EQ , NULL , SImode , <NUM_LIT> , byte_mode_entry ) ; double_word_end = expand_binop ( Pmode , add_optab , dst_base_reg , size_least_3_bit , NULL_RTX , <NUM_LIT> , OPTAB_WIDEN ) ; emit_label ( double_word_mode_loop ) ; src_itr_m = src_itr ; dst_itr_m = dst_itr ; srcmem_m =


<s> src_base_reg = copy_to_mode_reg ( SImode , XEXP ( srcmem , <NUM_LIT> ) ) ; remain_bytes = INTVAL ( total_bytes ) ; inst_num = ( ( INTVAL ( total_bytes ) + ( maximum_bytes_per_inst - <NUM_LIT> ) ) / maximum_bytes_per_inst ) - <NUM_LIT> ; for ( i = <NUM_LIT> ; i < inst_num ; i ++ ) { nds32_emit_mem_move_block ( start_regno , maximum_regs , & dst_base_reg , & dstmem , & src_base_reg , & srcmem , true ) ; } remain_bytes -= maximum_bytes_per_inst * inst_num ; remain_words = remain_bytes / UNITS_PER_WORD ; remain_bytes = remain_bytes - ( remain_words * UNITS_PER_WORD ) ; if ( remain_words != <NUM_LIT> ) { if ( remain_bytes != <NUM_LIT> ) nds32_emit_mem_move_block ( start_regno , remain_words , & dst_base_reg , & dstmem , & src_base_reg , & srcmem , true ) ; else { if ( remain_words == <NUM_LIT> ) { if ( align_to_4_bytes ) nds32_emit_mem_move ( srcmem , dstmem , SImode , <NUM_LIT> ) ; else { tmp_reg = gen_reg_rtx ( SImode ) ; emit_insn ( gen_unaligned_load_w ( tmp_reg , gen_rtx_MEM ( SImode , src_base_reg ) ) ) ; emit_insn ( gen_unaligned_store_w ( gen_rtx_MEM ( SImode , dst_base_reg ) , tmp_reg ) ) ; } } else nds32_emit_mem_move_block ( start_regno , remain_words , & dst_base_reg , & dstmem , & src_base_reg , & srcmem , false ) ; } } switch ( remain_bytes ) { case <NUM_LIT> : case <NUM_LIT> : { if ( align_to_2_bytes ) nds32_emit_mem_move ( srcmem , dstmem , HImode , <NUM_LIT> ) ; else { nds32_emit_mem_move ( srcmem , dstmem , QImode , <NUM_LIT> ) ; nds32_emit_mem_move ( srcmem , dstmem , QImode , <NUM_LIT> ) ; } if ( remain_bytes == <NUM_LIT> ) nds32_emit_mem_move ( srcmem , dstmem , QImode , <NUM_LIT> ) ; break ; } case <NUM_LIT>


<s> if ( optimize_size || optimize < <NUM_LIT> ) return false ; if ( TARGET_ISA_V3M && ! align_to_4_bytes ) return nds32_expand_setmem_loop_v3m ( dstmem , size , value ) ; if ( nds32_expand_setmem_unroll ( dstmem , size , value ,

align , expected_align , expected_size ) ) return true ;


<s> if ( nds32_expand_setmem_unroll ( dstmem , size , value , align , expected_align , expected_size ) ) return true ; return nds32_expand_setmem_loop ( dstmem , size ,


, subreg_lowpart_offset ( QImode , DImode ) ) ;


<s> unsigned maximum_regs , maximum_bytes , start_regno , regno ; rtx value4word ; rtx dst_base_reg , new_base_reg ; unsigned HOST_WIDE_INT remain_bytes , remain_words , prepare_regs , fill_per_smw ; unsigned HOST_WIDE_INT real_size ; if ( TARGET_REDUCED_REGS ) { maximum_regs = <NUM_LIT> ; maximum_bytes = <NUM_LIT> ; start_regno = <NUM_LIT> ; } else { maximum_regs = <NUM_LIT> ; maximum_bytes = <NUM_LIT> ; start_regno = <NUM_LIT> ; } real_size = UINTVAL ( size ) & GET_MODE_MASK ( SImode ) ; if ( ! ( CONST_INT_P ( size ) && real_size <= maximum_bytes ) ) return false ; remain_bytes = real_size ; gcc_assert ( GET_MODE ( value ) == QImode || CONST_INT_P ( value ) ) ; value4word = nds32_gen_dup_4_byte_to_word_value ( value ) ; prepare_regs = remain_bytes / UNITS_PER_WORD ; dst_base_reg = copy_to_mode_reg ( SImode , XEXP ( dstmem , <NUM_LIT> ) ) ; if ( prepare_regs > maximum_regs ) prepare_regs = maximum_regs ; fill_per_smw = prepare_regs * UNITS_PER_WORD ; regno = start_regno ; switch ( prepare_regs ) { case <NUM_LIT> : default : { rtx reg0 = gen_rtx_REG ( SImode , regno ) ; rtx reg1 = gen_rtx_REG ( SImode , regno + <NUM_LIT> ) ; unsigned last_regno = start_regno + prepare_regs - <NUM_LIT> ; emit_move_insn ( reg0 , value4word ) ; emit_move_insn ( reg1 , value4word ) ; rtx regd = gen_rtx_REG ( DImode , regno ) ; regno += <NUM_LIT> ; while ( regno <= last_regno ) { if ( ( regno + <NUM_LIT> ) <= last_regno ) { rtx reg = gen_rtx_REG ( DImode , regno ) ; emit_move_insn ( reg , regd ) ; regno += <NUM_LIT> ; } else { rtx reg = gen_rtx_REG ( SImode , regno ) ; emit_move_insn ( reg , reg0 ) ; regno += <NUM_LIT> ; } } break ; } case <NUM_LIT> : { rtx reg = gen_rtx_REG ( SImode , regno ++ ) ; emit_move_insn ( reg , value4word ) ; } break ; case <NUM_LIT> : break ; } if ( fill_per_smw ) for ( ; remain_bytes >= fill_per_smw ; remain_bytes -= fill_per_smw ) { emit_insn ( nds32_expand_store_multiple ( start_regno , prepare_regs , dst_base_reg , dstmem , true , & new_base_reg ) ) ; dst_base_reg = new_base_reg ; dstmem = gen_rtx_MEM ( SImode , dst_base_reg ) ; } remain_words = remain_bytes / UNITS_PER_WORD ; if ( remain_words ) { emit_insn ( nds32_expand_store_multiple ( start_regno , remain_words , dst_base_reg , dstmem , true , & new_base_reg ) ) ; dst_base_reg = new_base_reg ; dstmem = gen_rtx_MEM ( SImode


<s> rtx loop_label , tmp ; if ( optimize_size || optimize < <NUM_LIT> ) return false ; gcc_assert ( MEM_P ( str ) ) ; gcc_assert ( CONST_INT_P ( target_char ) || REG_P ( target_char ) ) ; base_reg = copy_to_mode_reg ( SImode , XEXP ( str , <NUM_LIT> ) ) ; loop_label = gen_label_rtx ( ) ; ffb_result = gen_reg_rtx ( Pmode ) ; tmp = gen_reg_rtx ( SImode ) ; backup_base_reg = gen_reg_rtx ( SImode ) ; emit_move_insn ( backup_base_reg , base_reg ) ; emit_label ( loop_label ) ; emit_insn ( gen_unaligned_load_update_base_w ( base_reg , tmp , base_reg ) ) ; emit_insn ( gen_unspec_ffb ( ffb_result , tmp , target_char ) ) ; emit_cmp_and_jump_insns ( ffb_result , const0_rtx , EQ , NULL , SImode , <NUM_LIT> , loop_label ) ; target_char_ptr = expand_binop ( Pmode , add_optab , base_reg , ffb_result , NULL_RTX , <NUM_LIT> , OPTAB_WIDEN ) ; length = expand_binop ( Pmode , sub_optab , target_char_ptr , backup_base_reg , NULL_RTX , <NUM_LIT> , OPTAB_WIDEN ) ; emit_move_insn ( result , length


<s> rtx value4doubleword = gen_reg_rtx ( DImode ) ; nds32_gen_dup_4_byte_to_word_value_aux ( value , nds32_di_low_part_subreg ( value4doubleword ) ) ; emit_move_insn ( nds32_di_high_part_subreg ( value4doubleword ) , nds32_di_low_part_subreg ( value4doubleword ) ) ; return


<s> case TYPE_MUL : use_rtx = SET_SRC ( PATTERN ( consumer ) ) ; break ; case TYPE_MAC : use_rtx = extract_mac_non_acc_rtx ( consumer ) ; break ; case TYPE_DIV : if ( INSN_CODE ( consumer ) == CODE_FOR_divmodsi4 || INSN_CODE ( consumer ) == CODE_FOR_udivmodsi4 ) use_rtx = SET_SRC ( parallel_element ( consumer , <NUM_LIT> ) ) ; else use_rtx = SET_SRC ( PATTERN ( consumer ) ) ; break ; case TYPE_BRANCH : use_rtx = extract_branch_condition_rtx ( consumer ) ; break ; case TYPE_STORE : if ( ! post_update_insn_p ( consumer ) && ! immed_offset_p ( extract_mem_rtx ( consumer ) ) ) return false ; use_rtx = SET_SRC ( PATTERN ( consumer ) ) ; break ; case TYPE_STORE_MULTIPLE : use_rtx = extract_nth_access_rtx ( consumer , <NUM_LIT> ) ; break ; default : gcc_unreachable (


<s> if ( GET_CODE ( PATTERN ( consumer ) ) == SET ) use_rtx = SET_SRC ( PATTERN ( consumer ) ) ; else return true ; break ; case TYPE_LOAD : if ( post_update_insn_p ( consumer ) ) use_rtx = extract_base_reg ( consumer ) ; else use_rtx = extract_mem_rtx ( consumer ) ; break ; case TYPE_STORE : if ( post_update_insn_p ( consumer ) ) use_rtx = extract_base_reg ( consumer ) ; else use_rtx = extract_mem_rtx ( consumer ) ; if ( reg_overlap_p ( def_reg , use_rtx ) ) return true ; if ( ! post_update_insn_p ( consumer ) && ! immed_offset_p ( extract_mem_rtx ( consumer ) ) ) return false ; use_rtx = SET_SRC ( PATTERN ( consumer ) ) ; break ; case


<s> use_rtx = extract_mac_non_acc_rtx ( consumer ) ; break ; case TYPE_DIV : if ( INSN_CODE ( consumer ) == CODE_FOR_divmodsi4 || INSN_CODE ( consumer ) == CODE_FOR_udivmodsi4 ) use_rtx = SET_SRC ( parallel_element ( consumer , <NUM_LIT> ) ) ; else use_rtx = SET_SRC ( PATTERN ( consumer ) ) ; break ; case TYPE_MMU : if ( GET_CODE ( PATTERN ( consumer ) ) == SET ) use_rtx = SET_SRC ( PATTERN ( consumer ) ) ; else return true ; break ; case TYPE_LOAD : case TYPE_STORE : use_rtx = extract_mem_rtx ( consumer ) ; break ; case TYPE_LOAD_MULTIPLE : case TYPE_STORE_MULTIPLE : use_rtx = extract_base_reg ( consumer ) ; break ; case TYPE_BRANCH : use_rtx = PATTERN ( consumer ) ; break ; default : gcc_unreachable ( )


<s> bool nds32_n8_ex_to_ii_p ( rtx_insn * producer , rtx_insn * consumer ) { rtx def_reg ; switch ( get_attr_type ( producer ) ) { case TYPE_ALU : if ( movd44_insn_p ( producer ) ) def_reg = extract_movd44_odd_reg ( producer ) ; else def_reg = SET_DEST ( PATTERN ( producer ) ) ; break ; case TYPE_MUL : case TYPE_MAC : def_reg = SET_DEST ( PATTERN ( producer ) ) ; break ; case TYPE_DIV : if ( INSN_CODE ( producer ) == CODE_FOR_divmodsi4 || INSN_CODE ( producer ) == CODE_FOR_udivmodsi4 ) def_reg = SET_DEST ( parallel_element ( producer , <NUM_LIT> ) ) ; else def_reg = SET_DEST ( PATTERN ( producer ) ) ; break ; case TYPE_LOAD : case TYPE_STORE : case TYPE_LOAD_MULTIPLE : case TYPE_STORE_MULTIPLE : if ( ! post_update_insn_p ( producer


<s> case TYPE_ALU : if ( movd44_insn_p ( producer ) ) def_reg = extract_movd44_odd_reg ( producer ) ; else def_reg = SET_DEST ( PATTERN ( producer ) ) ; break ; case TYPE_MUL : case TYPE_MAC : def_reg = SET_DEST ( PATTERN ( producer ) ) ; break ; case TYPE_DIV : if ( INSN_CODE ( producer ) == CODE_FOR_divmodsi4 || INSN_CODE ( producer ) == CODE_FOR_udivmodsi4 ) def_reg = SET_DEST ( parallel_element ( producer , <NUM_LIT> ) ) ; else def_reg = SET_DEST ( PATTERN ( producer ) ) ; break ; case TYPE_LOAD


<s> return n8_consumed_by_addr_in_p ( consumer


<s> bool e8_consumed_by_ex_p ( rtx_insn * consumer , rtx def_reg ) { rtx use_rtx ; switch ( get_attr_type ( consumer ) ) { case TYPE_ALU : case TYPE_STORE : use_rtx = SET_SRC ( PATTERN ( consumer ) ) ; break ; case TYPE_MUL : case TYPE_MAC : case


<s> rtx extract_nth_access_reg ( rtx_insn * insn , int index ) { switch ( GET_CODE ( PATTERN ( insn ) ) ) { case


<s> rtx extract_nth_access_rtx ( rtx_insn * insn , int n ) { int n_elems = parallel_elements ( insn ) ; int post_update_rtx_index = find_post_update_rtx ( insn ) ; memory_access_direction direction = determine_access_direction ( insn ) ; gcc_assert ( direction != MEM_ACCESS_DIR_UNKNOWN ) ; if ( direction == MEM_ACCESS_DIR_NEG ) n = - <NUM_LIT> * n


<s> memory_access_direction direction = determine_access_direction ( insn ) ; gcc_assert ( direction != MEM_ACCESS_DIR_UNKNOWN ) ; if ( direction == MEM_ACCESS_DIR_NEG ) n = - <NUM_LIT> * n - <NUM_LIT> ; if ( post_update_rtx_index != - <NUM_LIT> ) { if ( n >= <NUM_LIT> && post_update_rtx_index <= n ) ++ n ; else if ( n < <NUM_LIT> && post_update_rtx_index >= n + n_elems ) -- n ; } return parallel_element ( insn , n


<s> rtx nth_rtx = extract_nth_access_rtx ( insn , n ) ; if ( nth_rtx == NULL_RTX ) return NULL_RTX ; switch ( get_attr_type ( insn ) ) { case TYPE_LOAD_MULTIPLE : return SET_DEST ( nth_rtx ) ; case TYPE_STORE_MULTIPLE


<s> if ( direction == MEM_ACCESS_DIR_NEG ) n = - <NUM_LIT> * n - <NUM_LIT> ; } if ( n < - <NUM_LIT> || n > <NUM_LIT> ) return NULL_RTX ; if ( n < <NUM_LIT> ) n = <NUM_LIT> + n ; switch ( get_attr_type ( insn ) ) { case TYPE_LOAD : reg = SET_DEST ( PATTERN ( insn ) ) ; break ; case TYPE_STORE : reg = SET_SRC ( PATTERN ( insn ) ) ; break ; default : gcc_unreachable ( ) ; } gcc_assert ( REG_P ( reg ) || GET_CODE


<s> case TYPE_DPACK : case TYPE_DINSB : case TYPE_DCMP : case TYPE_DCLIP : case TYPE_DALUROUND : use_rtx = SET_SRC ( PATTERN ( consumer ) ) ; break ; case TYPE_ALU_SHIFT : use_rtx = extract_shift_reg ( consumer ) ; break ; case TYPE_PBSADA : return pbsada_insn_ra_rb_dep_reg_p ( consumer , def_reg ) ; case TYPE_MAC : case TYPE_DMAC : use_rtx = extract_mac_non_acc_rtx ( consumer ) ; break ; case TYPE_DIV : if ( divmod_p ( consumer ) ) use_rtx = SET_SRC ( parallel_element ( consumer , <NUM_LIT> ) ) ; else use_rtx = SET_SRC ( PATTERN


<s> if ( REG_P ( def_reg ) ) { return rtx_equal_p ( def_reg , use_rtx ) ; } else if ( GET_CODE ( def_reg ) == SUBREG && GET_MODE ( def_reg ) == SImode && rtx_equal_p ( SUBREG_REG ( def_reg ) , use_rtx ) ) { if ( TARGET_BIG_ENDIAN && SUBREG_BYTE ( def_reg ) ==


<s> case TYPE_ALU_SHIFT : use_rtx = extract_shift_reg ( consumer ) ; break ; case TYPE_PBSADA : return pbsada_insn_ra_rb_dep_reg_p ( consumer , def_reg ) ; case TYPE_MAC : case TYPE_DMAC : use_rtx = extract_mac_non_acc_rtx ( consumer ) ; break ; case TYPE_DIV : if ( divmod_p ( consumer ) ) use_rtx = SET_SRC ( parallel_element ( consumer , <NUM_LIT> ) ) ; else use_rtx = SET_SRC ( PATTERN ( consumer ) ) ; break ; case TYPE_DWEXT : return wext_odd_dep_p ( consumer , def_reg ) ; case TYPE_DBPICK : return bpick_ra_rb_dep_p ( consumer , def_reg ) ; case TYPE_MMU : if ( GET_CODE ( PATTERN ( consumer ) ) == SET ) use_rtx = SET_SRC ( PATTERN ( consumer ) ) ; else return true ; break ; case TYPE_LOAD : case TYPE_STORE : use_rtx = extract_mem_rtx ( consumer


<s> gcc_assert ( GET_CODE ( unspec_rtx ) == UNSPEC ) ; operand_ra = XVECEXP ( unspec_rtx , <NUM_LIT> , <NUM_LIT> ) ; operand_rb = XVECEXP ( unspec_rtx , <NUM_LIT> , <NUM_LIT> ) ; if ( rtx_equal_p ( def_reg , operand_ra ) || rtx_equal_p ( def_reg , operand_rb ) ) return true ; return false


<s> use_rtx = SET_SRC ( PATTERN ( consumer ) ) ; break ; case TYPE_MAC : use_rtx = extract_mac_non_acc_rtx ( consumer ) ; break ; case TYPE_DIV : if ( divmod_p ( consumer ) ) use_rtx = SET_SRC ( parallel_element ( consumer , <NUM_LIT> ) ) ; else use_rtx = SET_SRC ( PATTERN ( consumer ) ) ; break ; case TYPE_MMU : if ( GET_CODE ( PATTERN ( consumer ) ) == SET ) use_rtx = SET_SRC ( PATTERN ( consumer ) ) ; else return true ; break ; case TYPE_BRANCH


<s> case TYPE_DIV : if ( divmod_p ( consumer ) ) use_rtx = SET_SRC ( parallel_element ( consumer , <NUM_LIT> ) ) ; else use_rtx = SET_SRC ( PATTERN ( consumer ) ) ; break ; case TYPE_MMU : if ( GET_CODE ( PATTERN ( consumer ) ) == SET ) use_rtx = SET_SRC ( PATTERN ( consumer ) ) ; else return true ; break ; case TYPE_BRANCH : use_rtx = extract_branch_target_rtx (


<s> bool n13_consumed_by_e2_dep_p ( rtx_insn * consumer , rtx def_reg ) { rtx use_rtx ; switch ( get_attr_type ( consumer ) ) { case TYPE_ALU : case TYPE_STORE : use_rtx = SET_SRC ( PATTERN ( consumer ) ) ; break ; case TYPE_ALU_SHIFT : use_rtx = extract_shift_reg ( consumer ) ; break ; case TYPE_PBSADA : return pbsada_insn_rt_dep_reg_p ( consumer , def_reg ) ; case TYPE_STORE_MULTIPLE : use_rtx = extract_nth_access_rtx ( consumer , <NUM_LIT> ) ; break ; case TYPE_BRANCH : use_rtx = extract_branch_condition_rtx ( consumer ) ; break ; default : gcc_unreachable ( )


<s> if ( post_update_insn_p ( consumer ) ) use_rtx = extract_base_reg ( consumer ) ; else use_rtx = extract_mem_rtx ( consumer ) ; break ; case TYPE_STORE : if ( post_update_insn_p ( consumer ) ) use_rtx = extract_base_reg ( consumer ) ; else use_rtx = extract_mem_rtx ( consumer ) ; if ( reg_overlap_p ( def_reg , use_rtx ) ) return true ; if ( ! post_update_insn_p ( consumer ) && ! immed_offset_p ( extract_mem_rtx ( consumer ) ) ) return false ; use_rtx = SET_SRC ( PATTERN ( consumer ) ) ; break ; case TYPE_LOAD_MULTIPLE : use_rtx = extract_base_reg


<s> case TYPE_STORE : if ( post_update_insn_p ( consumer ) ) use_rtx = extract_base_reg ( consumer ) ; else use_rtx = extract_mem_rtx ( consumer ) ; if ( reg_overlap_p ( def_reg , use_rtx ) ) return true ; if ( ! post_update_insn_p ( consumer ) && ! immed_offset_p ( extract_mem_rtx ( consumer ) ) ) return false ; use_rtx = SET_SRC ( PATTERN ( consumer ) ) ; break ; case TYPE_LOAD_MULTIPLE : use_rtx = extract_base_reg ( consumer ) ; break ; case TYPE_STORE_MULTIPLE : use_rtx = extract_base_reg ( consumer ) ; if ( reg_overlap_p ( def_reg , use_rtx ) ) return true ; use_rtx = extract_nth_access_rtx ( consumer , <NUM_LIT> ) ; break ; case TYPE_BRANCH : use_rtx = PATTERN ( consumer ) ; break ; default : gcc_unreachable ( ) ; } if ( reg_overlap_p ( def_reg , use_rtx ) ) return


<s> gcc_assert ( REG_P ( last_def_reg ) || GET_CODE ( last_def_reg ) == SUBREG ) ; return e8_consumed_by_addr_in_p ( consumer , last_def_reg


<s> rtx def_reg = SET_DEST ( PATTERN ( producer ) ) ; return e8_consumed_by_ex_p ( consumer , def_reg


<s> bool nds32_e8_load_to_ii_p ( rtx_insn * producer , rtx_insn * consumer ) { rtx def_reg = SET_DEST ( PATTERN ( producer


<s> return nds32_n10_ex_to_ex_p ( producer ,


<s> bool nds32_gw_last_load_to_ex_p ( rtx_insn * producer , rtx_insn * consumer ) { rtx last_def_reg = extract_nth_access_reg ( producer , - <NUM_LIT> ) ; return gw_consumed_by_ex_dep_p ( consumer , last_def_reg )


<s> rtx last_def_reg = extract_nth_access_reg ( producer , - <NUM_LIT> ) ; return gw_consumed_by_ex_dep_p ( consumer ,


<s> case TYPE_DMAC : case TYPE_DALUROUND : case TYPE_DBPICK : case TYPE_DWEXT : def_reg = SET_DEST ( PATTERN ( producer ) ) ; break ; case TYPE_DIV : if ( divmod_p ( producer ) ) { rtx def_reg1 = SET_DEST ( parallel_element ( producer , <NUM_LIT> ) ) ; rtx def_reg2 = SET_DEST ( parallel_element ( producer , <NUM_LIT> ) ) ; return ( gw_consumed_by_ex_dep_p ( consumer , def_reg1 ) || gw_consumed_by_ex_dep_p ( consumer , def_reg2 ) ) ; } def_reg = SET_DEST ( PATTERN ( producer ) ) ; break ; default : gcc_unreachable (


<s> if ( ! post_update_insn_p ( producer ) ) return false ; return reg_overlap_p ( extract_base_reg ( producer ) ,


<s> bool nds32_n10_last_load_to_ex_p ( rtx_insn * producer


<s> bool nds32_n13_last_load_to_e1_p ( rtx_insn * producer , rtx_insn * consumer ) { rtx last_def_reg = extract_nth_access_reg ( producer , - <NUM_LIT> ) ; return n13_consumed_by_e1_dep_p ( consumer , last_def_reg


<s> bool nds32_n13_last_load_to_e2_p ( rtx_insn * producer , rtx_insn * consumer ) { rtx last_def_reg = extract_nth_access_reg ( producer , - <NUM_LIT>


<s> bool nds32_n13_last_load_to_e2_p ( rtx_insn * producer , rtx_insn * consumer ) { rtx last_def_reg = extract_nth_access_reg ( producer , -


<s> rtx last_two_def_reg = extract_nth_access_reg ( producer , - <NUM_LIT> ) ; if ( last_two_def_reg == NULL_RTX ) return false ; return n13_consumed_by_e1_dep_p ( consumer


<s> rtx def_reg = SET_DEST ( PATTERN ( producer ) ) ; gcc_assert ( get_attr_type ( producer


<s> bool nds32_n13_load_to_e2_p ( rtx_insn * producer , rtx_insn * consumer ) { rtx def_reg = SET_DEST ( PATTERN ( producer ) ) ; gcc_assert ( get_attr_type ( producer ) == TYPE_LOAD ) ; gcc_assert ( REG_P ( def_reg ) || GET_CODE ( def_reg ) == SUBREG ) ; return n13_consumed_by_e2_dep_p ( consumer , def_reg


<s> bool nds32_n7_last_load_to_ii_p ( rtx_insn * producer , rtx_insn * consumer ) { if ( post_update_insn_p ( producer ) ) return false ; rtx last_def_reg = extract_nth_access_reg ( producer , - <NUM_LIT> ) ; if ( last_def_reg == NULL_RTX ) return false ; gcc_assert ( REG_P ( last_def_reg ) || GET_CODE ( last_def_reg


<s> bool nds32_n7_load_to_ii_p ( rtx_insn * producer , rtx_insn * consumer ) { if ( post_update_insn_p ( producer ) )


<s> break ; case TYPE_MUL : case TYPE_MAC : def_reg = SET_DEST ( PATTERN ( producer ) ) ; break ; case TYPE_DIV : if ( divmod_p ( producer ) ) def_reg = SET_DEST ( parallel_element ( producer , <NUM_LIT> ) ) ; else def_reg = SET_DEST ( PATTERN ( producer ) ) ; break ; case TYPE_LOAD : case TYPE_STORE


<s> case TYPE_DIV : if ( divmod_p ( producer ) ) def_reg = SET_DEST ( parallel_element ( producer , <NUM_LIT> ) ) ; else def_reg = SET_DEST ( PATTERN ( producer ) ) ; break ; case TYPE_LOAD : case TYPE_STORE : case TYPE_LOAD_MULTIPLE : case TYPE_STORE_MULTIPLE : if ( ! post_update_insn_p ( producer )


<s> rtx last_def_reg = extract_nth_access_reg ( producer , - <NUM_LIT> ) ; if ( last_def_reg == NULL_RTX )


<s> if ( post_update_insn_p ( producer ) ) return false ; rtx last_def_reg = extract_nth_access_reg ( producer


<s> if ( last_two_def_reg == NULL_RTX ) return false ; gcc_assert ( REG_P ( last_two_def_reg ) || GET_CODE ( last_two_def_reg ) == SUBREG ) ; return n8_consumed_by_addr_in_p ( consumer


<s> int index = - <NUM_LIT> ; if ( post_update_insn_p ( producer ) ) index = - <NUM_LIT> ; rtx last_two_def_reg = extract_nth_access_reg ( producer ,


<s> if ( post_update_insn_p ( producer ) ) return false ; rtx def_reg = SET_DEST ( PATTERN ( producer ) ) ; return n8_consumed_by_ex_p ( consumer ,


<s> break ; case TYPE_DIV : if ( divmod_p ( producer ) ) { rtx def_reg1 = SET_DEST ( parallel_element ( producer , <NUM_LIT> ) ) ; rtx def_reg2 = SET_DEST ( parallel_element ( producer , <NUM_LIT> ) ) ; return ( n9_3r2w_consumed_by_ex_dep_p ( consumer , def_reg1 ) || n9_3r2w_consumed_by_ex_dep_p ( consumer , def_reg2


<s> if ( GET_MODE ( def_reg ) == DImode ) return reg_overlap_p ( def_reg , use_reg ) ; gcc_assert ( REG_P ( def_reg ) || GET_CODE ( def_reg ) == SUBREG ) ; gcc_assert ( REG_P ( use_reg ) || GET_CODE ( use_reg ) == SUBREG ) ; if ( REG_P ( def_reg ) ) { if REG_P ( use_reg ) { if ( ! TARGET_BIG_ENDIAN ) return REGNO ( def_reg ) == REGNO ( use_reg ) + <NUM_LIT> ; else return REGNO ( def_reg ) == REGNO ( use_reg ) ; } else return true


<s> return ( TARGET_ISA_V3 && ( ival < <NUM_LIT> ) && satisfies_constraint_Iu15 ( gen_int_mode (


<s> return ( TARGET_PERF_EXT && ( one_bit_count == <NUM_LIT> )


<s> int nds32_can_use_btgl_p ( int ival ) { int one_bit_count ; one_bit_count = popcount_hwi ( ( unsigned HOST_WIDE_INT ) ( ival ) ) ; return ( TARGET_PERF_EXT && ( one_bit_count == <NUM_LIT>


<s> int first_elt_regno ; rtx elt ; count = XVECLEN ( op , <NUM_LIT> ) ; elt = XVECEXP ( op , <NUM_LIT> , <NUM_LIT> ) ; if ( GET_CODE ( elt ) != SET || count <= <NUM_LIT> || count > <NUM_LIT> ) return false ; if ( load_p ) { if ( GET_CODE ( SET_DEST ( elt ) ) != REG || GET_CODE ( SET_SRC ( elt ) ) != MEM ) return false ; first_elt_regno = REGNO ( SET_DEST


<s> int one_bit_count ; one_bit_count = popcount_hwi ( ( unsigned HOST_WIDE_INT ) ( ~ ival ) ) ; return ( TARGET_EXT_PERF && ( one_bit_count ==


<s> int nds32_can_use_bclr_p ( int ival ) { int one_bit_count ; one_bit_count = popcount_hwi ( ( unsigned HOST_WIDE_INT ) ( ~


<s> int one_bit_count ; one_bit_count = popcount_hwi ( ( unsigned


<s> return ( TARGET_EXT_PERF && ( one_bit_count ==


<s> int shift_adv ; int shift = <NUM_LIT> ; int nelem ; switch ( GET_MODE ( op ) ) { case E_V2HImode : mask = <NUM_LIT> ; shift_adv = <NUM_LIT> ; nelem = <NUM_LIT> ; break ; case E_V4QImode : mask = <NUM_LIT> ; shift_adv = <NUM_LIT> ; nelem = <NUM_LIT> ; break ; default : gcc_unreachable ( ) ; } if ( TARGET_BIG_ENDIAN ) { for ( i = <NUM_LIT> ; i < nelem ; ++ i ) { HOST_WIDE_INT val = XINT ( XVECEXP ( op , <NUM_LIT> , nelem - i - <NUM_LIT> ) , <NUM_LIT> ) ; hwint |= ( val & mask ) << shift ; shift = shift


<s> bool nds32_can_use_bclr_p ( HOST_WIDE_INT ival ) { int one_bit_count ; unsigned HOST_WIDE_INT mask = GET_MODE_MASK ( SImode ) ; one_bit_count = popcount_hwi ( ( unsigned HOST_WIDE_INT ) ( ~ ival ) & mask ) ; return ( TARGET_EXT_PERF && ( one_bit_count == <NUM_LIT>


<s> bool nds32_can_use_bitci_p ( HOST_WIDE_INT ival ) { return ( TARGET_ISA_V3 && ( ival < <NUM_LIT> ) && satisfies_constraint_Iu15 ( gen_int_mode ( ~


<s> bool nds32_can_use_bitci_p ( HOST_WIDE_INT ival ) { return ( TARGET_ISA_V3 && ( ival < <NUM_LIT> ) && satisfies_constraint_Iu15 ( gen_int_mode ( ~ ival


<s> one_bit_count = popcount_hwi ( ( unsigned HOST_WIDE_INT ) ( ival ) & mask ) ; return ( TARGET_EXT_PERF && ( one_bit_count ==


<s> int one_bit_count ; unsigned HOST_WIDE_INT mask = GET_MODE_MASK ( SImode ) ; one_bit_count = popcount_hwi ( ( unsigned HOST_WIDE_INT ) ( ival


<s> machine_mode cmp0_mode = GET_MODE ( XEXP ( cmp_rtx , <NUM_LIT> ) ) ; machine_mode cmp1_mode = GET_MODE ( XEXP ( cmp_rtx , <NUM_LIT> ) ) ; enum rtx_code cond = GET_CODE ( cmp_rtx ) ; if ( ( cmp0_mode == DFmode || cmp0_mode == SFmode ) && ( cmp1_mode == DFmode || cmp1_mode == SFmode ) && ( cond == ORDERED || cond == UNORDERED ) ) return true ; return false


<s> int i ; int check_regno ; rtx elt ; rtx elt_reg ; rtx elt_mem ; for ( i = <NUM_LIT> ; i < count ; i ++ ) { elt = XVECEXP ( op , <NUM_LIT> , i + par_index ) ; if ( GET_CODE ( elt ) != SET ) return false ; elt_reg = load_p ? SET_DEST ( elt ) : SET_SRC ( elt ) ; elt_mem = load_p ? SET_SRC ( elt ) : SET_DEST ( elt ) ; if ( GET_CODE ( elt_reg ) != REG || GET_MODE ( elt_reg ) != SImode ) return false ; if ( GET_CODE ( elt_mem ) != MEM || GET_MODE ( elt_mem )


<s> int check_regno ; rtx elt ; rtx elt_reg ; rtx elt_mem ; for ( i = <NUM_LIT> ; i < count ; i ++ ) { elt = XVECEXP ( op , <NUM_LIT> , i + par_index ) ; if ( GET_CODE ( elt ) != SET ) return false ; elt_reg = load_p ? SET_DEST ( elt ) : SET_SRC ( elt ) ; elt_mem = load_p ? SET_SRC ( elt ) : SET_DEST ( elt ) ; if ( GET_CODE ( elt_reg ) != REG || GET_MODE ( elt_reg ) != SImode ) return false ; if ( GET_CODE ( elt_mem ) != MEM || GET_MODE ( elt_mem ) != SImode ) return false ; check_regno = first_elt_regno + i ; if ( REGNO ( elt_reg ) != ( unsigned int ) check_regno


<s> const REAL_VALUE_TYPE * rv ; long val ; rv = CONST_DOUBLE_REAL_VALUE ( op ) ; REAL_VALUE_TO_TARGET_SINGLE ( * rv ,


<s> bool nds32_valid_CVhi_p ( rtx op ) { HOST_WIDE_INT ival = const_vector_to_hwint (


<s> bool nds32_valid_CVp5_p ( rtx op ) { HOST_WIDE_INT ival = const_vector_to_hwint ( op ) ; return ( ival < ( ( <NUM_LIT> << <NUM_LIT> ) + <NUM_LIT> ) ) && (


REG || REGNO ( elt_reg ) != GP_REGNUM ) return false ;