<s> machine_mode save_mode = SImode ; if ( TARGET_LL64 && ( ( i - <NUM_LIT> ) % <NUM_LIT> == <NUM_LIT> ) && ( ( gmask & ( <NUM_LIT> << i ) ) != <NUM_LIT> ) && ( ( gmask & ( <NUM_LIT> << ( i - <NUM_LIT> ) ) ) != <NUM_LIT> ) ) { save_mode = DImode ; -- i ; }

else if ( ( gmask & ( <NUM_LIT> << i ) ) == <NUM_LIT> ) continue ;


<s> if ( GET_CODE ( op ) != MEM ) return false ; if ( mode == VOIDmode ) mode = GET_MODE ( op ) ; size = GET_MODE_SIZE ( mode ) ; if ( size > UNITS_PER_WORD ) return false ; addr = XEXP ( op , <NUM_LIT> ) ; if ( ! legitimate_small_data_address_p ( addr ) ) return false ; if ( ! short_p || size == <NUM_LIT> ) return true ; align = get_symbol_alignment ( addr ) ; switch ( mode ) { case E_HImode : mask = <NUM_LIT> ; break ; default :


<s> case <NUM_LIT> : if ( INTVAL ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) != <NUM_LIT> ) return false ; default : return false ; } if ( RTX_OK_FOR_BASE_P ( XEXP ( op , <NUM_LIT> ) , ( strict ) ) ) return true ; if ( flag_pic ) { if ( CONST_INT_P ( XEXP ( op , <NUM_LIT> ) ) ) return true ; return false ; } if ( legitimate_small_data_address_p ( op ) ) return false ; if ( CONSTANT_P ( XEXP ( op , <NUM_LIT> ) ) ) return true ; return false ;


<s> switch ( GET_CODE ( x ) ) { case CONST : return legitimate_small_data_address_p ( XEXP ( x , <NUM_LIT> ) ) ; case SYMBOL_REF : return SYMBOL_REF_SMALL_P ( x ) ; case PLUS : { bool p0 = ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == SYMBOL_REF ) && SYMBOL_REF_SMALL_P ( XEXP ( x , <NUM_LIT> ) ) ; bool p1 = CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) && ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) <= g_switch_value ) ; return p0 && p1 ; } default :


<s> static bool legitimate_small_data_address_p ( rtx x ) { switch ( GET_CODE ( x ) ) { case CONST : return legitimate_small_data_address_p ( XEXP ( x , <NUM_LIT> ) ) ; case SYMBOL_REF : return SYMBOL_REF_SMALL_P ( x ) ; case PLUS : { bool p0 = ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == SYMBOL_REF ) && SYMBOL_REF_SMALL_P ( XEXP ( x , <NUM_LIT> ) ) ; bool p1 = CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) && ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) <= g_switch_value ) ; return p0 && p1 ; } default : return false ; }


<s> } if ( MEM_P ( operands [ <NUM_LIT> ] ) && arc_is_aux_reg_p ( operands [ <NUM_LIT> ] ) ) { if ( arc_get_aux_arg ( operands [ <NUM_LIT> ] , & auxr ) ) { tmp = gen_reg_rtx ( SImode ) ; emit_move_insn ( tmp , GEN_INT ( auxr ) ) ; } else { tmp = XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ; gcc_assert ( GET_CODE ( tmp ) == SYMBOL_REF ) ; } gcc_assert ( REG_P ( operands [ <NUM_LIT> ] ) ) ; emit_insn ( gen_rtx_SET ( operands [ <NUM_LIT> ] , gen_rtx_UNSPEC_VOLATILE ( SImode , gen_rtvec ( <NUM_LIT> , tmp ) , VUNSPEC_ARC_LR ) ) ) ; return true ; } } if ( mode == SImode && SYMBOLIC_CONST ( operands [ <NUM_LIT> ] ) ) { prepare_pic_move ( operands , SImode ) ; } if ( MEM_P ( operands [ <NUM_LIT> ] ) && ! ( reload_in_progress || reload_completed ) ) { operands [ <NUM_LIT> ] = force_reg ( mode , operands [ <NUM_LIT> ] ) ; if ( ! move_dest_operand ( operands [ <NUM_LIT> ] , mode ) ) { rtx addr = copy_to_mode_reg ( Pmode , XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) ; rtx pat = change_address ( operands [ <NUM_LIT> ] , mode , addr ) ; MEM_COPY_ATTRIBUTES ( pat , operands [ <NUM_LIT> ] ) ; operands [ <NUM_LIT> ] = pat ; } if ( ! cse_not_expected ) { rtx pat = XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ; pat = arc_legitimize_address_0 ( pat , pat , mode ) ; if ( pat ) { pat = change_address ( operands [ <NUM_LIT> ] , mode , pat ) ; MEM_COPY_ATTRIBUTES ( pat , operands [ <NUM_LIT> ] ) ; operands [ <NUM_LIT> ] = pat ; } } } if ( MEM_P ( operands [ <NUM_LIT> ] ) && ! cse_not_expected ) { rtx pat = XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ; pat = arc_legitimize_address_0 ( pat , pat , mode ) ;


<s> return GEN_FCN ( icode ) ( arg [ <NUM_LIT> ] ) ; case <NUM_LIT> : return GEN_FCN ( icode ) ( arg [ <NUM_LIT> ] , arg [ <NUM_LIT> ] ) ; case <NUM_LIT> :

return GEN_FCN ( icode ) ( arg [ <NUM_LIT> ] , arg [ <NUM_LIT> ] , arg [ <NUM_LIT> ] ) ;


<s> return GEN_FCN ( icode ) ( arg [ <NUM_LIT> ] , arg [ <NUM_LIT> ] ) ; case <NUM_LIT> : return GEN_FCN ( icode ) ( arg [ <NUM_LIT> ] , arg [ <NUM_LIT> ] , arg [ <NUM_LIT> ] ) ; case <NUM_LIT> : return GEN_FCN ( icode ) ( arg [ <NUM_LIT> ] , arg [ <NUM_LIT> ] , arg [ <NUM_LIT> ] , arg [ <NUM_LIT> ] ) ; case <NUM_LIT> : return GEN_FCN ( icode ) ( arg [ <NUM_LIT> ] , arg [ <NUM_LIT> ] , arg [ <NUM_LIT> ] , arg [ <NUM_LIT> ] , arg [ <NUM_LIT> ] ) ; default : gcc_unreachable ( ) ;


<s> static int arc600_corereg_hazard ( rtx_insn * pred , rtx_insn * succ ) { if ( ! TARGET_ARC600 ) return <NUM_LIT> ; if ( GET_CODE ( PATTERN ( pred ) ) == SEQUENCE ) pred = as_a < rtx_sequence * > ( PATTERN ( pred ) ) -> insn ( <NUM_LIT> ) ; if ( GET_CODE ( PATTERN ( succ ) ) == SEQUENCE ) succ = as_a < rtx_sequence * > ( PATTERN ( succ ) ) -> insn ( <NUM_LIT> ) ; if ( recog_memoized ( pred ) == CODE_FOR_mulsi_600 || recog_memoized ( pred ) == CODE_FOR_umul_600 || recog_memoized ( pred ) == CODE_FOR_mac_600 || recog_memoized ( pred ) == CODE_FOR_mul64_600 || recog_memoized ( pred ) == CODE_FOR_mac64_600 || recog_memoized ( pred ) == CODE_FOR_umul64_600 || recog_memoized ( pred ) == CODE_FOR_umac64_600 ) return <NUM_LIT> ; subrtx_iterator :: array_type array ; FOR_EACH_SUBRTX ( iter , array , PATTERN ( pred ) , NONCONST ) { const_rtx x = * iter ; switch ( GET_CODE ( x ) ) { case SET : case POST_INC : case POST_DEC : case PRE_INC : case PRE_DEC : break ; default : continue ; } rtx dest = XEXP ( x , <NUM_LIT> ) ; if ( REG_P ( dest ) && REGNO ( dest ) >= <NUM_LIT> && REGNO ( dest ) < <NUM_LIT> && ( refers_to_regno_p ( REGNO ( dest ) , REGNO ( dest ) + ( GET_MODE_SIZE ( GET_MODE ( dest ) ) + <NUM_LIT> ) / <NUM_LIT> , PATTERN ( succ ) , <NUM_LIT> ) ) ) return <NUM_LIT> ;


<s> insn = NEXT_INSN ( insn ) ; if ( insn == <NUM_LIT> || ( active_insn_p ( insn ) && NONDEBUG_INSN_P ( insn ) && ! NOTE_P ( insn ) && GET_CODE ( PATTERN ( insn ) ) != UNSPEC_VOLATILE && GET_CODE ( PATTERN ( insn ) ) != PARALLEL ) ) break ; }


<s> rtx plus1 = XEXP ( addr , <NUM_LIT> ) ; if ( GET_CODE ( plus0 ) != REG && ( GET_CODE ( plus0 ) != MULT || ! CONST_INT_P ( XEXP ( plus0 , <NUM_LIT> ) ) || ( INTVAL ( XEXP ( plus0 , <NUM_LIT> ) ) != <NUM_LIT> && INTVAL ( XEXP ( plus0 , <NUM_LIT> ) ) != <NUM_LIT> ) ) ) break ; switch ( GET_CODE ( plus1 ) ) { case CONST_INT : return ( ! RTX_OK_FOR_OFFSET_P ( SImode , plus1 ) ? COSTS_N_INSNS ( <NUM_LIT> ) : speed ? <NUM_LIT> : ( satisfies_constraint_Rcq ( plus0 ) && satisfies_constraint_O ( plus1 ) ) ? <NUM_LIT> : <NUM_LIT> ) ; case REG : return ( speed < <NUM_LIT> ? <NUM_LIT> : ( satisfies_constraint_Rcq ( plus0 ) && satisfies_constraint_Rcq ( plus1 ) ) ? <NUM_LIT> : <NUM_LIT> ) ; case CONST : case SYMBOL_REF : case LABEL_REF : return COSTS_N_INSNS ( <NUM_LIT> ) ; default : break ; } break ;


<s> arc_jli_section * sec = arc_jli_sections , * new_section ; tree decl = SYMBOL_REF_DECL ( pat ) ; if ( ! pat ) return ; if ( decl ) { attrs = TYPE_ATTRIBUTES ( TREE_TYPE ( decl ) ) ; if ( lookup_attribute ( <STR_LIT> , attrs ) ) return ; } name = XSTR ( pat , <NUM_LIT> ) ; while ( sec != NULL ) { if ( strcmp ( name , sec -> name ) == <NUM_LIT> ) return ; sec = sec -> next ; } new_section = ( arc_jli_section * ) xmalloc ( sizeof ( arc_jli_section ) ) ;


<s> if ( strcmp ( name , sec -> name ) == <NUM_LIT> ) return ; sec = sec -> next ; } new_section = ( arc_jli_section * ) xmalloc ( sizeof ( arc_jli_section ) ) ; gcc_assert ( new_section != NULL ) ; new_section -> name = name ;

new_section -> next = arc_jli_sections ;


<s> void arc_adjust_reg_alloc_order ( void ) { const int arc_default_alloc_order [ ] = REG_ALLOC_ORDER ; memcpy ( reg_alloc_order , arc_default_alloc_order , sizeof ( reg_alloc_order ) ) ;

if ( optimize_size ) memcpy ( reg_alloc_order , size_alloc_order , sizeof ( size_alloc_order ) ) ;


<s> void arc_adjust_reg_alloc_order ( void ) {

const int arc_default_alloc_order [ ] = REG_ALLOC_ORDER ;


<s> static bool arc_allocate_stack_slots_for_args ( void ) {

unsigned int fn_type = arc_compute_function_type ( cfun ) ;


<s> int bytes = arg . promoted_size_in_bytes ( ) ; int words = ( bytes + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ; int arg_num = * cum ; int ret ; arg_num = ROUND_ADVANCE_CUM ( arg_num , arg . mode , arg . type ) ; ret = GPR_REST_ARG_REGS ( arg_num ) ; ret = ( ret >= words ? <NUM_LIT> : ret * UNITS_PER_WORD ) ;


<s> return <NUM_LIT> ; case SET : return arc_asm_insn_p ( SET_SRC ( x ) ) ; case PARALLEL : j = <NUM_LIT> ; for ( i = XVECLEN ( x , <NUM_LIT> ) - <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) j += arc_asm_insn_p ( XVECEXP ( x , <NUM_LIT> , i ) ) ; if ( j > <NUM_LIT> ) return <NUM_LIT> ; break ;


<s> for ( i = XVECLEN ( x , <NUM_LIT> ) - <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) j += arc_asm_insn_p ( XVECEXP ( x , <NUM_LIT> , i ) ) ; if ( j > <NUM_LIT> ) return <NUM_LIT> ; break ;


<s> if ( globalize_p ) ( * targetm . asm_out . globalize_label ) ( stream , name ) ; ASM_OUTPUT_ALIGN ( stream , floor_log2 ( ( align ) / BITS_PER_UNIT ) ) ; ASM_OUTPUT_TYPE_DIRECTIVE ( stream , name , <STR_LIT> ) ; ASM_OUTPUT_SIZE_DIRECTIVE ( stream , name , size ) ; ASM_OUTPUT_LABEL ( stream , name ) ; if ( size != <NUM_LIT> ) ASM_OUTPUT_SKIP ( stream , size ) ;


<s> static void arc_asm_trampoline_template ( FILE * f ) { asm_fprintf ( f , <STR_LIT> , ARC_TEMP_SCRATCH_REG ) ; asm_fprintf ( f , <STR_LIT> , reg_names [ STATIC_CHAIN_REGNUM ] ) ; asm_fprintf ( f , <STR_LIT> , ARC_TEMP_SCRATCH_REG ) ; assemble_aligned_integer ( UNITS_PER_WORD , const0_rtx ) ;


<s> static int arc_attr_type ( rtx_insn * insn ) { if ( NONJUMP_INSN_P ( insn ) ? ( GET_CODE ( PATTERN ( insn ) ) == USE || GET_CODE ( PATTERN ( insn ) ) == CLOBBER ) : JUMP_P ( insn ) ? ( GET_CODE ( PATTERN ( insn ) ) == ADDR_VEC || GET_CODE ( PATTERN ( insn ) ) == ADDR_DIFF_VEC ) : ! CALL_P ( insn ) ) return - <NUM_LIT> ; return get_attr_type ( insn ) ;


<s> static unsigned int arc_autovectorize_vector_modes ( vector_modes * modes , bool ) { if ( TARGET_PLUS_QMACW ) { modes -> quick_push ( V4HImode ) ; modes -> quick_push ( V2HImode ) ; }


<s> return ! optimize_size && arc_reorg_in_progress ;


<s> if ( ! arc_tls_symbol ) arc_tls_symbol = init_one_libfunc ( <STR_LIT> ) ; emit_move_insn ( arg , ti ) ; fn = gen_rtx_MEM ( SImode , arc_tls_symbol ) ; insn = emit_call_insn ( gen_call_value ( ret , fn , const0_rtx ) ) ; RTL_CONST_CALL_P ( insn ) = <NUM_LIT> ; use_reg ( & CALL_INSN_FUNCTION_USAGE ( insn ) , ret ) ; use_reg ( & CALL_INSN_FUNCTION_USAGE ( insn ) , arg ) ; return ret ;


<s> emit_move_insn ( arg , ti ) ; fn = gen_rtx_MEM ( SImode , arc_tls_symbol ) ; insn = emit_call_insn ( gen_call_value ( ret , fn , const0_rtx ) ) ; RTL_CONST_CALL_P ( insn ) = <NUM_LIT> ; use_reg ( & CALL_INSN_FUNCTION_USAGE ( insn ) , ret ) ; use_reg ( & CALL_INSN_FUNCTION_USAGE ( insn ) , arg ) ;


<s> return ! arc_legitimate_constant_p ( mode , x ) ;


<s> static bool arc_cannot_substitute_mem_equiv_p ( rtx ) {


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


<s> if ( CROSSING_JUMP_P ( followee ) ) switch ( get_attr_type ( u . r ) ) { case TYPE_BRANCH : if ( get_attr_length ( u . r ) != <NUM_LIT> ) break ; case TYPE_BRCC : case TYPE_BRCC_NO_DELAY_SLOT :


<s> if ( loop_depth > <NUM_LIT> || ! entered_at_top ) return false ; if ( arc_lpcwidth != <NUM_LIT> && ( wi :: gtu_p ( iterations_max , ( ( <NUM_LIT> << arc_lpcwidth ) - <NUM_LIT> ) ) || wi :: eq_p ( iterations_max , <NUM_LIT> ) ) ) return false ;


<s> bool arc_can_use_return_insn ( void ) {

return ( reload_completed && cfun -> machine -> frame_info . total_size == <NUM_LIT> && ! ARC_INTERRUPT_P ( arc_compute_function_type ( cfun ) ) ) ;


<s> int reverse = <NUM_LIT> ; int seeking_return = <NUM_LIT> ; rtx_insn * start_insn = insn ; enum attr_type jump_insn_type ; if ( optimize < <NUM_LIT> || TARGET_NO_COND_EXEC ) return ; if ( ! INSN_P ( insn ) ) return ; body = PATTERN ( insn ) ; if ( state -> state == <NUM_LIT> ) { if ( insn == state -> target_insn ) { state -> target_insn = NULL ; state -> state = <NUM_LIT> ; } return ; } if ( state -> state == <NUM_LIT> ) { if ( simplejump_p ( insn ) ) { start_insn = next_nonnote_insn ( start_insn ) ; if ( GET_CODE ( start_insn ) == BARRIER ) { start_insn = next_nonnote_insn ( start_insn ) ; } if ( GET_CODE ( start_insn ) == CODE_LABEL && CODE_LABEL_NUMBER ( start_insn ) == state -> target_label && LABEL_NUSES ( start_insn ) == <NUM_LIT> ) reverse = TRUE ; else return ; } else if ( GET_CODE ( body ) == SIMPLE_RETURN ) { start_insn = next_nonnote_insn ( start_insn ) ; if ( GET_CODE ( start_insn ) == BARRIER ) start_insn = next_nonnote_insn ( start_insn ) ; if ( GET_CODE ( start_insn ) == CODE_LABEL && CODE_LABEL_NUMBER ( start_insn ) == state -> target_label && LABEL_NUSES ( start_insn ) == <NUM_LIT> ) { reverse = TRUE ; seeking_return = <NUM_LIT> ; } else return ; } else return ; } if ( GET_CODE ( insn ) != JUMP_INSN || GET_CODE ( PATTERN ( insn ) ) == ADDR_VEC || GET_CODE ( PATTERN ( insn ) ) == ADDR_DIFF_VEC ) return ; jump_insn_type = get_attr_type ( insn ) ; if ( jump_insn_type == TYPE_BRCC || jump_insn_type == TYPE_BRCC_NO_DELAY_SLOT || jump_insn_type == TYPE_LOOP_END || ( jump_insn_type == TYPE_CALL && ! get_attr_predicable ( insn ) ) ) return ; if ( GET_CODE ( body ) == PARALLEL && XVECLEN ( body , <NUM_LIT> ) > <NUM_LIT> ) body = XVECEXP ( body , <NUM_LIT> , <NUM_LIT> ) ; if ( reverse || ( GET_CODE ( body ) == SET && GET_CODE ( SET_DEST ( body ) ) == PC && GET_CODE ( SET_SRC ( body ) ) == IF_THEN_ELSE ) ) { int insns_skipped = <NUM_LIT> , fail = FALSE , succeed = FALSE ; int then_not_else = TRUE ; int next_must_be_target_label_p ; rtx_insn * this_insn = start_insn ;


<s> static void arc_ccfsm_at_label ( const char * prefix , int num , struct arc_ccfsm * state ) {

if ( state -> state == <NUM_LIT> && state -> target_label == num && ! strcmp ( prefix , <STR_LIT> ) ) {


<s> bool arc_ccfsm_branch_deleted_p ( void ) { return ARC_CCFSM_BRANCH_DELETED_P ( & arc_ccfsm_current ) ;


<s> bool arc_ccfsm_cond_exec_p ( void ) {

return ( cfun -> machine -> prescan_initialized && ARC_CCFSM_COND_EXEC_P ( & arc_ccfsm_current ) ) ;


<s> enum attr_type type ; if ( LABEL_P ( insn ) ) arc_ccfsm_at_label ( <STR_LIT> , CODE_LABEL_NUMBER ( insn ) , state ) ;

else if ( JUMP_P ( insn ) && GET_CODE ( PATTERN ( insn ) ) != ADDR_VEC && GET_CODE ( PATTERN ( insn ) ) != ADDR_DIFF_VEC && ( ( type = get_attr_type ( insn ) ) == TYPE_BRANCH || ( ( type == TYPE_UNCOND_BRANCH || type == TYPE_RETURN ) && ARC_CCFSM_BRANCH_DELETED_P ( state ) ) ) ) {


<s> if ( ARC_CCFSM_BRANCH_DELETED_P ( state ) ) ARC_CCFSM_RECORD_BRANCH_DELETED ( state ) ; else { rtx src = SET_SRC ( PATTERN ( insn ) ) ; arc_ccfsm_record_condition ( XEXP ( src , <NUM_LIT> ) , XEXP ( src , <NUM_LIT> ) == pc_rtx , insn , state ) ; } }

else if ( arc_ccfsm_current . state == <NUM_LIT> ) arc_ccfsm_current . state = <NUM_LIT> ;


<s> ARC_CCFSM_RECORD_BRANCH_DELETED ( & arc_ccfsm_current ) ;


<s> if ( ! as_a < rtx_insn * > ( insn ) -> deleted ( ) && INSN_ANNULLED_BRANCH_P ( jump ) && ( TARGET_AT_DBR_CONDEXEC || INSN_FROM_TARGET_P ( insn ) ) ) { state -> cond = cond ; state -> cc = get_arc_condition_code ( cond ) ; if ( ! reverse ) arc_ccfsm_current . cc = ARC_INVERSE_CONDITION_CODE ( state -> cc ) ; rtx pat = PATTERN ( insn ) ; if ( GET_CODE ( pat ) == COND_EXEC ) gcc_assert ( ( INSN_FROM_TARGET_P ( insn ) ? ARC_INVERSE_CONDITION_CODE ( state -> cc ) : state -> cc ) == get_arc_condition_code ( XEXP ( pat , <NUM_LIT> ) ) ) ; else state -> state = <NUM_LIT> ;


<s> if ( ! reverse ) arc_ccfsm_current . cc = ARC_INVERSE_CONDITION_CODE ( state -> cc ) ; rtx pat = PATTERN ( insn ) ; if ( GET_CODE ( pat ) == COND_EXEC ) gcc_assert ( ( INSN_FROM_TARGET_P ( insn ) ? ARC_INVERSE_CONDITION_CODE ( state -> cc ) : state -> cc ) == get_arc_condition_code ( XEXP ( pat , <NUM_LIT> ) ) ) ; else state -> state = <NUM_LIT> ; }


<s> bool arc_check_ior_const ( HOST_WIDE_INT ival ) { unsigned int mask = ( unsigned int ) ( ival & <NUM_LIT> ) ; if ( UNSIGNED_INT6 ( ival ) || IS_POWEROF2_P ( mask ) ) return false ; if ( __builtin_popcount ( mask ) <= <NUM_LIT> ) return true ;

if ( __builtin_popcount ( mask & ~ <NUM_LIT> ) <= <NUM_LIT> ) return true ;


<s> if ( load_p == <NUM_LIT> ) { if ( len < <NUM_LIT> || len > <NUM_LIT> ) return <NUM_LIT> ; load_p = <NUM_LIT> ; } else { rtx elt = XVECEXP ( op , <NUM_LIT> , -- len ) ; if ( GET_CODE ( elt ) != CLOBBER || ! REG_P ( XEXP ( elt , <NUM_LIT> ) ) || REGNO ( XEXP ( elt , <NUM_LIT> ) ) != RETURN_ADDR_REGNUM || len < <NUM_LIT> || len > <NUM_LIT> ) return <NUM_LIT> ; } for ( i = <NUM_LIT> ; i < len ; i ++ ) { rtx elt = XVECEXP ( op , <NUM_LIT> , i + offset ) ; rtx reg , mem , addr ; if ( GET_CODE ( elt ) != SET ) return <NUM_LIT> ; mem = XEXP ( elt , load_p ) ; reg = XEXP ( elt , <NUM_LIT> - load_p ) ; if ( ! REG_P ( reg ) || REGNO ( reg ) != <NUM_LIT> + i || ! MEM_P ( mem ) ) return <NUM_LIT> ;


<s> ival = ival & <NUM_LIT> ; if ( SIGNED_INT12 ( ival ) ) return false ; if ( ( ival & ~ <NUM_LIT> ) == <NUM_LIT> ) return true ; if ( IS_POWEROF2_P ( ival + <NUM_LIT> ) ) return true ; if ( ! TARGET_BARREL_SHIFTER ) return false ; if ( ( ( ival >> ( __builtin_ffs ( ival ) - <NUM_LIT> ) ) & <NUM_LIT> ) == <NUM_LIT> ) return true ; if ( ( ival & ~ <NUM_LIT> ) == <NUM_LIT> ) return true ;


<s> if ( ( ival & ~ <NUM_LIT> ) == <NUM_LIT> ) return true ; if ( ( ival & ~ <NUM_LIT> ) == <NUM_LIT> ) return true ; if ( ( ival & ~ <NUM_LIT> ) == <NUM_LIT> ) return true ;


<s> HOST_WIDE_INT len = XVECLEN ( op , <NUM_LIT> ) ; unsigned int regno , i , start ; unsigned int memp = push_p ? <NUM_LIT> : <NUM_LIT> ; rtx elt ; if ( len <= <NUM_LIT> ) return false ; start = <NUM_LIT> ; elt = XVECEXP ( op , <NUM_LIT> , <NUM_LIT> ) ; if ( ! push_p && GET_CODE ( elt ) == RETURN ) start = <NUM_LIT> ; for ( i = start , regno = ENTER_LEAVE_START_REG ; i < len ; i ++ , regno ++ ) { rtx elt = XVECEXP ( op , <NUM_LIT> , i ) ; rtx reg , mem , addr ; if ( GET_CODE ( elt ) != SET ) return false ; mem = XEXP ( elt , memp ) ; reg = XEXP ( elt , <NUM_LIT> - memp ) ; if ( ! REG_P ( reg ) || ! MEM_P ( mem ) ) return false ; if ( REGNO ( reg ) == RETURN_ADDR_REGNUM && i == start ) regno = <NUM_LIT> ; else if ( REGNO ( reg ) == HARD_FRAME_POINTER_REGNUM ) ++ i ; else if ( REGNO ( reg ) != regno ) return false ; addr = XEXP ( mem , <NUM_LIT> ) ; if ( GET_CODE ( addr ) == PLUS ) { if ( ! rtx_equal_p ( stack_pointer_rtx , XEXP ( addr , <NUM_LIT> ) ) || ! CONST_INT_P ( XEXP ( addr , <NUM_LIT> ) ) ) return false ;


if ( cfun ) cfun -> machine -> unalign = <NUM_LIT> ;


<s> reg_size += UNITS_PER_WORD ; gmask |= <NUM_LIT> << regno ; } frame_info -> save_return_addr = ( ! crtl -> is_leaf || df_regs_ever_live_p ( RETURN_ADDR_REGNUM ) || crtl -> calls_eh_return ) ; if ( TARGET_MILLICODE_THUNK_SET && ! ARC_INTERRUPT_P ( fn_type ) && ! crtl -> calls_eh_return ) { if ( arc_compute_millicode_save_restore_regs ( gmask , frame_info ) ) frame_info -> save_return_addr = true ; } if ( arc_lpcwidth != <NUM_LIT> && arc_must_save_register ( LP_COUNT , cfun , true ) ) reg_size += UNITS_PER_WORD * <NUM_LIT> ; if ( arc_must_save_register ( TARGET_BIG_ENDIAN ? R41_REG : R40_REG , cfun , TARGET_DPFP ) ) reg_size += UNITS_PER_WORD * <NUM_LIT> ; if ( arc_must_save_register ( TARGET_BIG_ENDIAN ? R43_REG : R42_REG , cfun , TARGET_DPFP ) ) reg_size += UNITS_PER_WORD * <NUM_LIT> ; if ( arc_must_save_register ( R58_REG , cfun , true ) ) reg_size += UNITS_PER_WORD * <NUM_LIT> ; extra_size = <NUM_LIT> ; if ( arc_must_save_return_addr ( cfun ) ) extra_size = <NUM_LIT> ; if ( arc_frame_pointer_needed ( ) && ! ARC_AUTOFP_IRQ_P ( fn_type ) ) extra_size += <NUM_LIT> ; pretend_size = crtl -> args . pretend_args_size ; extra_plus_reg_size = extra_size + reg_size ;


<s> tree value , args = TREE_VALUE ( attr ) ; gcc_assert ( list_length ( args ) == <NUM_LIT> ) ; value = TREE_VALUE ( args ) ; gcc_assert ( TREE_CODE ( value ) == STRING_CST ) ; if ( ! strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) || ! strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) ) fn_type |= ARC_FUNCTION_ILINK1 ; else if ( ! strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) ) fn_type |= ARC_FUNCTION_ILINK2 ; else if ( ! strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) ) fn_type |= ARC_FUNCTION_FIRQ ; else gcc_unreachable ( ) ;


<s> tree value , args = TREE_VALUE ( attr ) ; gcc_assert ( list_length ( args ) == <NUM_LIT> ) ; value = TREE_VALUE ( args ) ; gcc_assert ( TREE_CODE ( value ) == STRING_CST ) ; if ( ! strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) || ! strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) ) fn_type |= ARC_FUNCTION_ILINK1 ; else if ( ! strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) ) fn_type |= ARC_FUNCTION_ILINK2 ; else if ( ! strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) ) fn_type |= ARC_FUNCTION_FIRQ ; else gcc_unreachable ( ) ; }

return fun -> machine -> fn_type = fn_type ;


<s> int regno ; int start_reg = <NUM_LIT> , end_reg = <NUM_LIT> ; for ( regno = start_reg ; regno <= end_reg && ( gmask & ( <NUM_LIT> << regno ) ) ; ) regno ++ ; end_reg = regno - <NUM_LIT> ; if ( regno - start_reg >= <NUM_LIT> - ( crtl -> is_leaf == <NUM_LIT> ) ) { frame -> millicode_start_reg = <NUM_LIT> ;

frame -> millicode_end_reg = regno - <NUM_LIT> ;


<s> for ( regno = start_reg ; regno <= end_reg && ( gmask & ( <NUM_LIT> << regno ) ) ; ) regno ++ ; end_reg = regno - <NUM_LIT> ; if ( regno - start_reg >= <NUM_LIT> - ( crtl -> is_leaf == <NUM_LIT> ) ) { frame -> millicode_start_reg = <NUM_LIT> ; frame -> millicode_end_reg = regno - <NUM_LIT> ; return <NUM_LIT> ; }


<s> arc_regno_reg_class [ R30_REG ] = GENERAL_REGS ; } } if ( TARGET_MUL64_SET ) { fix_start = R57_REG ; fix_end = R59_REG ; strcpy ( rname57 , <STR_LIT> ) ; strcpy ( rname58 , <STR_LIT> ) ; strcpy ( rname59 , <STR_LIT> ) ; } if ( arc_tp_regno != - <NUM_LIT> ) fixed_regs [ arc_tp_regno ] = call_used_regs [ arc_tp_regno ] = <NUM_LIT> ; if ( TARGET_MULMAC_32BY16_SET ) { fix_start = MUL32x16_REG ; fix_end = fix_end > R57_REG ? fix_end : R57_REG ; strcpy ( rname56 , TARGET_BIG_ENDIAN ? <STR_LIT> : <STR_LIT> ) ; strcpy ( rname57 , TARGET_BIG_ENDIAN ? <STR_LIT> : <STR_LIT> ) ; } for ( regno = fix_start ; regno <= fix_end ; regno ++ ) { if ( ! fixed_regs [ regno ] ) warning ( <NUM_LIT> , <STR_LIT> , regno ) ; fixed_regs [ regno ] = call_used_regs [ regno ] = <NUM_LIT> ; } if ( TARGET_RF16 ) { for ( i = R4_REG ; i <= R9_REG ; i ++ ) fixed_regs [ i ] = call_used_regs [ i ] = <NUM_LIT> ; for ( i = R16_REG ; i <= R25_REG ; i ++ ) fixed_regs [ i ] = call_used_regs [ i ] = <NUM_LIT> ; } if ( TARGET_HS ) for ( regno = R1_REG ; regno < R32_REG ; regno += <NUM_LIT> ) arc_hard_regno_modes [ regno ] = S_MODES ; for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( i < ILINK1_REG ) { if ( ( i <= R3_REG ) || ( ( i >= R12_REG ) && ( i <= R15_REG ) ) ) arc_regno_reg_class [ i ] = ARCOMPACT16_REGS ; else arc_regno_reg_class [ i ] = GENERAL_REGS ; } else if ( i < LP_COUNT ) arc_regno_reg_class [ i ] = GENERAL_REGS ; else arc_regno_reg_class [ i ] = NO_REGS ; arc_regno_reg_class [ CC_REG ] = NO_REGS ; arc_regno_reg_class [ FRAME_POINTER_REGNUM ] = GENERAL_REGS ; arc_regno_reg_class [ ARG_POINTER_REGNUM ] = GENERAL_REGS ; if ( TARGET_DPFP ) for ( i = R40_REG ; i < R44_REG ; ++ i ) { arc_regno_reg_class [ i ] = DOUBLE_REGS ; if ( ! TARGET_ARGONAUT_SET ) CLEAR_HARD_REG_BIT ( reg_class_contents [ GENERAL_REGS ] , i ) ; } else { arc_regno_reg_class [ R40_REG ] = ALL_REGS ; arc_regno_reg_class [ R41_REG ] = ALL_REGS ; arc_regno_reg_class [ R42_REG ] = ALL_REGS ; arc_regno_reg_class [ R43_REG ] = ALL_REGS ; fixed_regs [ R40_REG ] = <NUM_LIT> ; fixed_regs [ R41_REG ] = <NUM_LIT> ; fixed_regs [ R42_REG ] = <NUM_LIT> ; fixed_regs [ R43_REG ] = <NUM_LIT> ; arc_hard_regno_modes [ R40_REG ] = <NUM_LIT> ; arc_hard_regno_modes [ R42_REG ] = <NUM_LIT> ; } if ( TARGET_SIMD_SET ) { gcc_assert ( ARC_FIRST_SIMD_VR_REG == <NUM_LIT> ) ; gcc_assert ( ARC_LAST_SIMD_VR_REG == <NUM_LIT> ) ; for ( i = ARC_FIRST_SIMD_VR_REG ; i <= ARC_LAST_SIMD_VR_REG ; i ++ ) arc_regno_reg_class [ i ] = SIMD_VR_REGS ;


<s> if ( MEM_P ( x ) ) x = XEXP ( x , <NUM_LIT> ) ; x = arc_delegitimize_address_0 ( x ) ; if ( ! x ) return orig_x ; if ( MEM_P ( orig_x ) ) x = replace_equiv_address_nv ( orig_x , x ) ;


<s> if ( ! x ) return orig_x ; if ( MEM_P ( orig_x ) ) x = replace_equiv_address_nv ( orig_x , x ) ; return x ;


<s> rtx t1 = arc_delegitimize_address_0 ( XEXP ( op , <NUM_LIT> ) ) ; rtx t2 = XEXP ( op , <NUM_LIT> ) ; if ( t1 && t2 ) return gen_rtx_PLUS ( GET_MODE ( op ) , t1 , t2 ) ; break ; } default : break ; }


<s> case ARC_UNSPEC_GOTOFFPC : return XVECEXP ( op , <NUM_LIT> , <NUM_LIT> ) ; default : break ; } break ; case PLUS : { rtx t1 = arc_delegitimize_address_0 ( XEXP ( op , <NUM_LIT> ) ) ; rtx t2 = XEXP ( op , <NUM_LIT> ) ; if ( t1 && t2 ) return gen_rtx_PLUS ( GET_MODE ( op ) , t1 , t2 ) ; break ; }


<s> if ( TARGET_DPFP ) return true ; low = CONST_DOUBLE_LOW ( value ) ; high = CONST_DOUBLE_HIGH ( value ) ; if ( low & <NUM_LIT> ) { return ( ( ( unsigned HOST_WIDE_INT ) low <= <NUM_LIT> && high == <NUM_LIT> ) || ( ( ( low & - ( unsigned HOST_WIDE_INT ) <NUM_LIT> ) == - ( unsigned HOST_WIDE_INT ) <NUM_LIT> ) && high == - <NUM_LIT> ) ) ; }


<s> offset = UNITS_PER_WORD * ( irq_ctrl_saved . irq_save_last_reg + <NUM_LIT> + irq_ctrl_saved . irq_save_blink + irq_ctrl_saved . irq_save_lpcount ) ; tmp = plus_constant ( Pmode , stack_pointer_rtx , - <NUM_LIT> * offset ) ; tmp = gen_rtx_SET ( stack_pointer_rtx , tmp ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( par , <NUM_LIT> , j ++ ) = tmp ; offset -= UNITS_PER_WORD ; if ( irq_ctrl_saved . irq_save_lpcount ) { reg = gen_rtx_REG ( SImode , <NUM_LIT> ) ; tmp = plus_constant ( Pmode , stack_pointer_rtx , offset ) ; tmp = gen_frame_mem ( SImode , tmp ) ;


<s> static rtx arc_dwarf_register_span ( rtx rtl ) { machine_mode mode = GET_MODE ( rtl ) ; unsigned regno ; rtx p ; if ( GET_MODE_SIZE ( mode ) != <NUM_LIT> ) return NULL_RTX ; p = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( <NUM_LIT> ) ) ;


<s> machine_mode mode = GET_MODE ( rtl ) ; unsigned regno ; rtx p ; if ( GET_MODE_SIZE ( mode ) != <NUM_LIT> ) return NULL_RTX ; p = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( <NUM_LIT> ) ) ; regno = REGNO ( rtl ) ; XVECEXP ( p , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_REG ( SImode , regno ) ;

XVECEXP ( p , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_REG ( SImode , regno + <NUM_LIT> ) ;


<s> afi = & cfun -> machine -> frame_info ; gcc_assert ( crtl -> calls_eh_return ) ; gcc_assert ( afi -> save_return_addr ) ; gcc_assert ( afi -> extra_size >= <NUM_LIT> ) ; offset = afi -> reg_size + afi -> extra_size - <NUM_LIT> ; mem = gen_frame_mem ( Pmode , plus_constant ( Pmode , hard_frame_pointer_rtx , offset ) ) ; MEM_VOLATILE_P ( mem ) = true ;


<s> rtx mem ; int offset ; struct arc_frame_info * afi ; arc_compute_frame_size ( ) ; afi = & cfun -> machine -> frame_info ; gcc_assert ( crtl -> calls_eh_return ) ; gcc_assert ( afi -> save_return_addr ) ;

gcc_assert ( afi -> extra_size >= <NUM_LIT> ) ;


<s> static void arc_encode_section_info ( tree decl , rtx rtl , int first ) { default_encode_section_info ( decl , rtl , first ) ; if ( TREE_CODE ( decl ) == FUNCTION_DECL ) { rtx symbol = XEXP ( rtl , <NUM_LIT> ) ; int flags = SYMBOL_REF_FLAGS ( symbol ) ; tree attr = ( TREE_TYPE ( decl ) != error_mark_node ? TYPE_ATTRIBUTES ( TREE_TYPE ( decl ) ) : NULL_TREE ) ; tree long_call_attr = lookup_attribute ( <STR_LIT> , attr ) ; tree medium_call_attr = lookup_attribute ( <STR_LIT> , attr ) ; tree short_call_attr = lookup_attribute ( <STR_LIT> , attr ) ; if ( long_call_attr != NULL_TREE ) flags |= SYMBOL_FLAG_LONG_CALL ; else if ( medium_call_attr != NULL_TREE ) flags |= SYMBOL_FLAG_MEDIUM_CALL ; else if ( short_call_attr != NULL_TREE ) flags |= SYMBOL_FLAG_SHORT_CALL ; SYMBOL_REF_FLAGS ( symbol ) = flags ; } else if ( TREE_CODE ( decl ) == VAR_DECL ) { rtx symbol = XEXP ( rtl , <NUM_LIT> ) ; tree attr = ( TREE_TYPE ( decl ) != error_mark_node ? DECL_ATTRIBUTES ( decl ) : NULL_TREE ) ; tree sec_attr = lookup_attribute ( <STR_LIT> , attr ) ; if ( sec_attr ) { const char * sec_name = TREE_STRING_POINTER ( TREE_VALUE ( TREE_VALUE ( sec_attr ) ) ) ;

if ( strcmp ( sec_name , <STR_LIT> ) == <NUM_LIT> || strcmp ( sec_name , <STR_LIT> ) == <NUM_LIT> || strcmp ( sec_name , <STR_LIT> ) == <NUM_LIT> ) SYMBOL_REF_FLAGS ( symbol ) |= SYMBOL_FLAG_CMEM ;


<s> int regno ; unsigned int rmask = <NUM_LIT> ; if ( ! gmask ) return false ; for ( regno = ENTER_LEAVE_START_REG ;

regno <= ENTER_LEAVE_END_REG && ( gmask & ( <NUM_LIT> << regno ) ) ; regno ++ ) rmask |= <NUM_LIT> << regno ;


<s> static bool arc_enter_leave_p ( uint64_t gmask ) { int regno ; unsigned int rmask = <NUM_LIT> ; if ( ! gmask ) return false ; for ( regno = ENTER_LEAVE_START_REG ;


<s> if ( regno == arc_tp_regno ) return true ; if ( regno == RETURN_ADDR_REGNUM ) return true ; if ( regno == arc_return_address_register ( fn_type ) ) return true ; if ( epilogue_completed && ARC_INTERRUPT_P ( fn_type ) ) { if ( df_regs_ever_live_p ( regno ) || call_used_or_fixed_reg_p ( regno ) ) return true ; }


<s> emit_label ( label ) ; label = gen_rtx_LABEL_REF ( VOIDmode , label ) ; if ( before == NULL_RTX ) before = gen_reg_rtx ( mode ) ; if ( after == NULL_RTX ) after = gen_reg_rtx ( mode ) ; emit_insn ( gen_arc_load_exclusivesi ( before , mem ) ) ; switch ( code ) { case NOT : x = gen_rtx_AND ( mode , before , val ) ; emit_insn ( gen_rtx_SET ( after , x ) ) ; x = gen_rtx_NOT ( mode , after ) ; emit_insn ( gen_rtx_SET ( after , x ) ) ; break ; case MINUS : if ( CONST_INT_P ( val ) ) { val = GEN_INT ( - INTVAL ( val ) ) ; code = PLUS ; } default : x = gen_rtx_fmt_ee ( code , mode , before , val ) ; emit_insn ( gen_rtx_SET ( after , x ) ) ; break ; } emit_insn ( gen_arc_store_exclusivesi ( mem , after ) ) ; cond = gen_rtx_REG ( CC_Zmode , CC_REG ) ; x = gen_rtx_NE ( VOIDmode , cond , const0_rtx ) ; x = gen_rtx_IF_THEN_ELSE ( VOIDmode , x , label , pc_rtx ) ; emit_unlikely_jump ( gen_rtx_SET ( pc_rtx , x ) ) ;


<s> HOST_WIDE_INT alignTest = INTVAL ( op1 ) ; if ( alignTest <= <NUM_LIT> || alignTest != ( alignTest & - alignTest ) ) { error ( <STR_LIT> ) ; return NULL_RTX ; } if ( CONST_INT_P ( op0 ) ) { HOST_WIDE_INT pnt = INTVAL ( op0 ) ; if ( ( pnt & ( alignTest - <NUM_LIT> ) ) == <NUM_LIT> ) return const1_rtx ; } else {

unsigned align = get_pointer_alignment ( arg0 ) ;


<s> if ( GET_MODE ( mem ) == QImode ) mask = force_reg ( SImode , GEN_INT ( <NUM_LIT> ) ) ; else mask = force_reg ( SImode , GEN_INT ( <NUM_LIT> ) ) ; emit_insn ( gen_rtx_SET ( mask , gen_rtx_ASHIFT ( SImode , mask , off ) ) ) ; emit_insn ( gen_rtx_SET ( val , gen_rtx_AND ( SImode , gen_rtx_NOT ( SImode , mask ) , val ) ) ) ; oldval = gen_lowpart ( SImode , oldval ) ; emit_insn ( gen_rtx_SET ( oldv , gen_rtx_ASHIFT ( SImode , oldval , off ) ) ) ; newval = gen_lowpart_common ( SImode , newval ) ; emit_insn ( gen_rtx_SET ( newv , gen_rtx_ASHIFT ( SImode , newval , off ) ) ) ; emit_insn ( gen_rtx_SET ( oldv , gen_rtx_AND ( SImode , oldv , mask ) ) ) ; emit_insn ( gen_rtx_SET ( newv , gen_rtx_AND ( SImode , newv , mask ) ) ) ; if ( ! is_weak ) { end_label = gen_label_rtx ( ) ; loop_label = gen_label_rtx ( ) ; emit_label ( loop_label ) ; } emit_insn ( gen_rtx_SET ( oldvalue , gen_rtx_IOR ( SImode , oldv , val ) ) ) ; emit_insn ( gen_rtx_SET ( newvalue , gen_rtx_IOR ( SImode , newv , val ) ) ) ; emit_insn ( gen_atomic_compare_and_swapsi_1 ( res , memsi , oldvalue , newvalue , weak , mod_s , mod_f ) ) ;


<s> emit_insn ( gen_rtx_SET ( off , gen_rtx_AND ( SImode , addr1 , GEN_INT ( <NUM_LIT> ) ) ) ) ; if ( TARGET_BIG_ENDIAN ) emit_insn ( gen_rtx_SET ( off , gen_rtx_MINUS ( SImode , ( GET_MODE ( mem ) == QImode ) ? GEN_INT ( <NUM_LIT> ) : GEN_INT ( <NUM_LIT> ) , off ) ) ) ; memsi = gen_rtx_MEM ( SImode , addr ) ; set_mem_alias_set ( memsi , ALIAS_SET_MEMORY_BARRIER ) ; MEM_VOLATILE_P ( memsi ) = MEM_VOLATILE_P ( mem ) ; val = copy_to_reg ( memsi ) ; emit_insn ( gen_rtx_SET ( off , gen_rtx_ASHIFT ( SImode , off , GEN_INT ( <NUM_LIT> ) ) ) ) ; if ( GET_MODE ( mem ) == QImode ) mask = force_reg ( SImode , GEN_INT ( <NUM_LIT> ) ) ; else mask = force_reg ( SImode , GEN_INT ( <NUM_LIT> ) ) ; emit_insn ( gen_rtx_SET ( mask , gen_rtx_ASHIFT ( SImode , mask , off ) ) ) ; emit_insn ( gen_rtx_SET ( val , gen_rtx_AND ( SImode , gen_rtx_NOT ( SImode , mask ) , val ) ) ) ; oldval = gen_lowpart ( SImode , oldval ) ; emit_insn ( gen_rtx_SET ( oldv , gen_rtx_ASHIFT ( SImode , oldval , off ) ) ) ; newval = gen_lowpart_common ( SImode , newval ) ; emit_insn ( gen_rtx_SET ( newv , gen_rtx_ASHIFT ( SImode , newval , off ) ) ) ; emit_insn ( gen_rtx_SET ( oldv , gen_rtx_AND ( SImode , oldv , mask ) ) ) ; emit_insn ( gen_rtx_SET ( newv , gen_rtx_AND ( SImode , newv , mask ) ) ) ;


<s> fprintf ( asm_out_file , <STR_LIT> <STR_LIT> ) ; assemble_name ( asm_out_file , sec -> name ) ; fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; assemble_name ( asm_out_file , sec -> name ) ; fprintf ( asm_out_file , <STR_LIT> ) ; assemble_name ( asm_out_file , sec -> name ) ; fprintf ( asm_out_file , <STR_LIT> ) ; assemble_name ( asm_out_file , sec -> name ) ; fprintf ( asm_out_file , <STR_LIT> ) ; sec = sec -> next ; }


<s> if ( TARGET_DUMPISIZE ) fprintf ( asm_out_file , <STR_LIT> , INSN_ADDRESSES ( INSN_UID ( insn ) ) ) ; if ( ! cfun -> machine -> prescan_initialized ) {

memset ( & arc_ccfsm_current , <NUM_LIT> , sizeof arc_ccfsm_current ) ;


<s> if ( TARGET_DUMPISIZE ) fprintf ( asm_out_file , <STR_LIT> , INSN_ADDRESSES ( INSN_UID ( insn ) ) ) ; if ( ! cfun -> machine -> prescan_initialized ) { memset ( & arc_ccfsm_current , <NUM_LIT> , sizeof arc_ccfsm_current ) ; cfun -> machine -> prescan_initialized = <NUM_LIT> ;


<s> static bool arc_frame_pointer_needed ( void ) {

return ( frame_pointer_needed || crtl -> calls_eh_return ) ;


<s> rtx ret ; const char * debstr ATTRIBUTE_UNUSED ; arg_num = ROUND_ADVANCE_CUM ( arg_num , arg . mode , arg . type ) ; if ( arg . end_marker_p ( ) ) { ret = const0_rtx ;


<s> if ( words ) * cum = ROUND_ADVANCE_CUM ( * cum , arg . mode , arg . type ) ;

for ( i = <NUM_LIT> ; i < words ; i ++ ) * cum = ARC_NEXT_ARG_REG ( * cum ) ;


<s> if ( decl ) { attrs = TYPE_ATTRIBUTES ( TREE_TYPE ( decl ) ) ; if ( lookup_attribute ( <STR_LIT> , attrs ) ) return false ;


<s> int unsignedp ATTRIBUTE_UNUSED ; unsignedp = TYPE_UNSIGNED ( valtype ) ; if ( INTEGRAL_TYPE_P ( valtype ) || TREE_CODE ( valtype ) == OFFSET_TYPE ) PROMOTE_MODE ( mode , unsignedp , valtype ) ; return gen_rtx_REG ( mode , <NUM_LIT> ) ;


<s> unsignedp = TYPE_UNSIGNED ( valtype ) ; if ( INTEGRAL_TYPE_P ( valtype ) || TREE_CODE ( valtype ) == OFFSET_TYPE ) PROMOTE_MODE ( mode , unsignedp , valtype ) ;

return gen_rtx_REG ( mode , <NUM_LIT> ) ;


<s> gcc_assert ( ARC_INVERSE_CONDITION_CODE ( raw_cc ) == statep -> cc ) ; machine_mode ccm = GET_MODE ( XEXP ( cond , <NUM_LIT> ) ) ; enum rtx_code code = reverse_condition ( GET_CODE ( cond ) ) ; if ( code == UNKNOWN || ccm == CC_FP_GTmode || ccm == CC_FP_GEmode ) code = reverse_condition_maybe_unordered ( GET_CODE ( cond ) ) ; return gen_rtx_fmt_ee ( code , GET_MODE ( cond ) , copy_rtx ( XEXP ( cond , <NUM_LIT> ) ) , copy_rtx ( XEXP ( cond , <NUM_LIT> ) ) ) ;


<s> machine_mode ccm = GET_MODE ( XEXP ( cond , <NUM_LIT> ) ) ; enum rtx_code code = reverse_condition ( GET_CODE ( cond ) ) ;

if ( code == UNKNOWN || ccm == CC_FP_GTmode || ccm == CC_FP_GEmode ) code = reverse_condition_maybe_unordered ( GET_CODE ( cond ) ) ;


<s> if ( TREE_CODE ( arg ) != INTEGER_CST ) { warning ( OPT_Wattributes , <STR_LIT> <STR_LIT> , name ) ; * no_add_attrs = true ; } } if ( TREE_CODE ( * node ) == VAR_DECL ) { tree fntype = TREE_TYPE ( * node ) ; if ( fntype && TREE_CODE ( fntype ) == POINTER_TYPE ) { tree attrs = tree_cons ( get_identifier ( <STR_LIT> ) , NULL_TREE , TYPE_ATTRIBUTES ( fntype ) ) ; TYPE_ATTRIBUTES ( fntype ) = attrs ; } } }


<s> } else if ( args ) { if ( TREE_CODE ( TREE_VALUE ( args ) ) == NON_LVALUE_EXPR ) TREE_VALUE ( args ) = TREE_OPERAND ( TREE_VALUE ( args ) , <NUM_LIT> ) ; tree arg = TREE_VALUE ( args ) ; if ( TREE_CODE ( arg ) != INTEGER_CST ) { warning ( OPT_Wattributes , <STR_LIT> <STR_LIT> , name ) ; * no_add_attrs = true ; } } if ( TREE_CODE ( * node ) == VAR_DECL ) { tree fntype = TREE_TYPE ( * node ) ; if ( fntype && TREE_CODE ( fntype ) == POINTER_TYPE ) { tree attrs = tree_cons ( get_identifier ( <STR_LIT> ) , NULL_TREE , TYPE_ATTRIBUTES ( fntype ) ) ; TYPE_ATTRIBUTES ( fntype ) = attrs ; }


<s> static tree arc_handle_fndecl_attribute ( tree * node , tree name , tree args ATTRIBUTE_UNUSED , int flags ATTRIBUTE_UNUSED , bool * no_add_attrs ) { if ( TREE_CODE ( * node ) != FUNCTION_DECL ) {

warning ( OPT_Wattributes , <STR_LIT> , name ) ;


<s> static tree arc_handle_fndecl_attribute ( tree * node , tree name , tree args ATTRIBUTE_UNUSED , int flags ATTRIBUTE_UNUSED , bool * no_add_attrs ) {

if ( TREE_CODE ( * node ) != FUNCTION_DECL ) {


<s> * no_add_attrs = true ; } else if ( ! TARGET_V2 && strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) && strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) ) { warning ( OPT_Wattributes , <STR_LIT> , name ) ; * no_add_attrs = true ;


<s> if ( DECL_P ( * node ) && TREE_CODE ( * node ) != TYPE_DECL ) { error ( <STR_LIT> , name ) ;


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

return ( arc_hard_regno_modes [ regno ] & arc_mode_class [ mode ] ) != <NUM_LIT> ;


<s> if ( GET_MODE_SIZE ( mode ) == <NUM_LIT> && regno >= ARC_FIRST_SIMD_VR_REG && regno <= ARC_LAST_SIMD_VR_REG ) return <NUM_LIT> ;

return CEIL ( GET_MODE_SIZE ( mode ) , UNITS_PER_WORD ) ;


<s> int arc_hazard ( rtx_insn * pred , rtx_insn * succ ) { if ( ! pred || ! INSN_P ( pred ) || ! succ || ! INSN_P ( succ ) ) return <NUM_LIT> ; if ( TARGET_ARC600 ) return arc600_corereg_hazard ( pred , succ ) ; return <NUM_LIT> ;


<s> gcc_assert ( ! IN_RANGE ( statep -> state , <NUM_LIT> , <NUM_LIT> ) ) ; rtx_insn * seq = NEXT_INSN ( PREV_INSN ( insn ) ) ; if ( GET_CODE ( PATTERN ( seq ) ) == SEQUENCE ) { rtx slot = XVECEXP ( PATTERN ( seq ) , <NUM_LIT> , <NUM_LIT> ) ; rtx pat = PATTERN ( slot ) ; if ( INSN_ANNULLED_BRANCH_P ( insn ) ) { rtx cond = arc_get_ccfsm_cond ( statep , INSN_FROM_TARGET_P ( slot ) ) ; pat = gen_rtx_COND_EXEC ( VOIDmode , cond , pat ) ; } if ( ! validate_change ( seq , & PATTERN ( seq ) , pat , <NUM_LIT> ) ) gcc_unreachable ( ) ; PUT_CODE ( slot , NOTE ) ; NOTE_KIND ( slot ) = NOTE_INSN_DELETED ; } else { set_insn_deleted ( insn ) ; } continue ; } case <NUM_LIT> : if ( LABEL_P ( insn ) && statep -> target_label == CODE_LABEL_NUMBER ( insn ) ) { arc_ccfsm_post_advance ( insn , statep ) ; if ( -- LABEL_NUSES ( insn ) == <NUM_LIT> ) delete_insn ( insn ) ; continue ; } case <NUM_LIT> : case <NUM_LIT> : if ( ! NONDEBUG_INSN_P ( insn ) ) break ; rtx_insn * prev , * pprev ; rtx * patp , pat , cond ; bool annulled ; annulled = false ; prev = PREV_INSN ( insn ) ; pprev = PREV_INSN ( prev ) ; if ( pprev && NEXT_INSN ( NEXT_INSN ( pprev ) ) == NEXT_INSN ( insn ) && JUMP_P ( prev ) && get_attr_cond ( prev ) == COND_USE ) { if ( ! INSN_ANNULLED_BRANCH_P ( prev ) ) break ; annulled = true ; } patp = & PATTERN ( insn ) ; pat = * patp ; cond = arc_get_ccfsm_cond ( statep , INSN_FROM_TARGET_P ( insn ) ) ; if ( NONJUMP_INSN_P ( insn ) || CALL_P ( insn ) ) { pat = conditionalize_nonjump ( pat , cond , insn , annulled ) ; } else if ( simplejump_p ( insn ) ) { patp = & SET_SRC ( pat ) ; pat = gen_rtx_IF_THEN_ELSE ( VOIDmode , cond , * patp , pc_rtx ) ; } else if ( JUMP_P ( insn ) && ANY_RETURN_P ( PATTERN ( insn ) ) ) { pat = gen_rtx_IF_THEN_ELSE ( VOIDmode , cond , pat , pc_rtx ) ; pat = gen_rtx_SET ( pc_rtx , pat ) ; } else gcc_unreachable ( ) ; validate_change ( insn , patp , pat , <NUM_LIT> ) ; if ( ! apply_change_group ( ) ) gcc_unreachable ( ) ; if ( JUMP_P ( insn ) ) {

rtx_insn * next = next_nonnote_insn ( insn ) ;


<s> if ( TARGET_NOMPY_SET && TARGET_ARC600_FAMILY ) error ( <STR_LIT> ) ; if ( ! TARGET_DPFP && TARGET_DPFP_DISABLE_LRSR ) error ( <STR_LIT> ) ; if ( ( TARGET_DPFP_FAST_SET && TARGET_DPFP_COMPACT_SET ) || ( TARGET_SPFP_FAST_SET && TARGET_SPFP_COMPACT_SET ) ) error ( <STR_LIT> ) ; if ( TARGET_SPFP_FAST_SET && TARGET_ARC600_FAMILY ) error ( <STR_LIT> ) ; if ( ( TARGET_DPFP_FAST_SET || TARGET_DPFP_COMPACT_SET || TARGET_SPFP ) && TARGET_HARD_FLOAT ) error ( <STR_LIT> ) ; if ( flag_pic && TARGET_ARC600_FAMILY ) { warning ( <NUM_LIT> , <STR_LIT> , arc_cpu_string ) ; flag_pic = <NUM_LIT> ; } arc_init_reg_tables ( ) ; memset ( arc_punct_chars , <NUM_LIT> , sizeof ( arc_punct_chars ) ) ; arc_punct_chars [ '#' ] = <NUM_LIT> ; arc_punct_chars [ '*' ] = <NUM_LIT> ; arc_punct_chars [ '?' ] = <NUM_LIT> ; arc_punct_chars [ '!' ] = <NUM_LIT> ; arc_punct_chars [ '^' ] = <NUM_LIT> ; arc_punct_chars [ '&' ] = <NUM_LIT> ;


<s> arc_multcost = COSTS_N_INSNS ( <NUM_LIT> ) ; if ( TARGET_NOMPY_SET ) arc_multcost = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case ARC_TUNE_ARC600 : if ( TARGET_MUL64_SET ) { arc_multcost = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; } default : arc_multcost = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; } if ( TARGET_NOMPY_SET && TARGET_ARC600_FAMILY ) error ( <STR_LIT> ) ; if ( ! TARGET_DPFP && TARGET_DPFP_DISABLE_LRSR ) error ( <STR_LIT> ) ; if ( ( TARGET_DPFP_FAST_SET && TARGET_DPFP_COMPACT_SET ) || ( TARGET_SPFP_FAST_SET && TARGET_SPFP_COMPACT_SET ) ) error ( <STR_LIT> ) ; if ( TARGET_SPFP_FAST_SET && TARGET_ARC600_FAMILY ) error ( <STR_LIT> ) ; if ( ( TARGET_DPFP_FAST_SET || TARGET_DPFP_COMPACT_SET || TARGET_SPFP ) && TARGET_HARD_FLOAT ) error ( <STR_LIT> ) ;

if ( flag_pic && TARGET_ARC600_FAMILY ) {


<s> rtx fnaddr = XEXP ( DECL_RTL ( fndecl ) , <NUM_LIT> ) ; emit_block_move ( tramp , assemble_trampoline_template ( ) , GEN_INT ( TRAMPOLINE_SIZE ) , BLOCK_OP_NORMAL ) ;

emit_move_insn ( adjust_address ( tramp , SImode , <NUM_LIT> ) , fnaddr ) ;


<s> if ( from == ARG_POINTER_REGNUM && to == STACK_POINTER_REGNUM ) { return ( cfun -> machine -> frame_info . total_size - cfun -> machine -> frame_info . pretend_size ) ; } if ( ( from == FRAME_POINTER_REGNUM ) && ( to == STACK_POINTER_REGNUM ) ) { return ( cfun -> machine -> frame_info . total_size - ( cfun -> machine -> frame_info . pretend_size + cfun -> machine -> frame_info . extra_size + cfun -> machine -> frame_info . reg_size ) ) ; } if ( ( from == FRAME_POINTER_REGNUM ) && ( to == HARD_FRAME_POINTER_REGNUM ) ) return <NUM_LIT> ;


<s> static struct machine_function * arc_init_machine_status ( void ) { struct machine_function * machine ; machine = ggc_cleared_alloc < machine_function > ( ) ; machine -> fn_type = ARC_FUNCTION_UNKNOWN ; return machine ;


<s> for ( i = <NUM_LIT> ; i < NUM_MACHINE_MODES ; i ++ ) { machine_mode m = ( machine_mode ) i ; switch ( GET_MODE_CLASS ( m ) ) { case MODE_INT : case MODE_PARTIAL_INT : case MODE_COMPLEX_INT : if ( GET_MODE_SIZE ( m ) <= <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) S_MODE ; else if ( GET_MODE_SIZE ( m ) == <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) D_MODE ; else if ( GET_MODE_SIZE ( m ) == <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) T_MODE ; else if ( GET_MODE_SIZE ( m ) == <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) O_MODE ; else arc_mode_class [ i ] = <NUM_LIT> ; break ; case MODE_FLOAT : case MODE_COMPLEX_FLOAT : if ( GET_MODE_SIZE ( m ) <= <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) SF_MODE ; else if ( GET_MODE_SIZE ( m ) == <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) DF_MODE ; else if ( GET_MODE_SIZE ( m ) == <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) TF_MODE ; else if ( GET_MODE_SIZE ( m ) == <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) OF_MODE ; else arc_mode_class [ i ] = <NUM_LIT> ; break ; case MODE_VECTOR_INT : if ( GET_MODE_SIZE ( m ) == <NUM_LIT> ) arc_mode_class [ i ] = ( <NUM_LIT> << ( int ) S_MODE ) ; else if ( GET_MODE_SIZE ( m ) == <NUM_LIT> ) arc_mode_class [ i ] = ( <NUM_LIT> << ( int ) D_MODE ) ; else arc_mode_class [ i ] = ( <NUM_LIT> << ( int ) V_MODE ) ; break ; case MODE_CC : default : if ( i == ( int ) CCmode || i == ( int ) CC_ZNmode || i == ( int ) CC_Zmode || i == ( int ) CC_Cmode || i == CC_FP_GTmode || i == CC_FP_GEmode || i == CC_FP_ORDmode || i == CC_FPUmode || i == CC_FPUEmode || i == CC_FPU_UNEQmode ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) C_MODE ; else arc_mode_class [ i ] = <NUM_LIT> ; break ; } }


<s> static int arc_insn_cost ( rtx_insn * insn , bool speed ) { int cost ; if ( recog_memoized ( insn ) < <NUM_LIT> ) return <NUM_LIT> ; if ( ! speed ) return get_attr_length ( insn ) ; cost = get_attr_cost ( insn ) ; if ( cost > <NUM_LIT> ) return cost ; enum attr_type type = get_attr_type ( insn ) ;


<s> static void arc_internal_label ( FILE * stream , const char * prefix , unsigned long labelno ) { if ( cfun ) arc_ccfsm_at_label ( prefix , labelno , & arc_ccfsm_current ) ;

default_internal_label ( stream , prefix , labelno ) ;


<s> if ( cfun ) arc_ccfsm_at_label ( prefix , labelno , & arc_ccfsm_current ) ; default_internal_label ( stream , prefix , labelno ) ;


<s> static const char * arc_invalid_within_doloop ( const rtx_insn * insn ) { if ( CALL_P ( insn ) ) return <STR_LIT> ; return NULL ;


<s> static bool arc_in_small_data_p ( const_tree decl ) { HOST_WIDE_INT size ; tree attr ; if ( TREE_CODE ( decl ) != VAR_DECL ) return false ; if ( TARGET_NO_SDATA_SET ) return false ; if ( DECL_WEAK ( decl ) ) return false ; if ( TREE_READONLY ( decl ) ) return false ; if ( ! TARGET_VOLATILE_CACHE_SET && TREE_THIS_VOLATILE ( decl ) ) return false ; attr = TYPE_ATTRIBUTES ( TREE_TYPE ( decl ) ) ; if ( lookup_attribute ( <STR_LIT> , attr ) ) return false ; attr = DECL_ATTRIBUTES ( decl ) ; if ( lookup_attribute ( <STR_LIT> , attr ) ) return false ;

if ( DECL_SECTION_NAME ( decl ) != <NUM_LIT> ) {


<s> if ( TREE_READONLY ( decl ) ) return false ; if ( ! TARGET_VOLATILE_CACHE_SET && TREE_THIS_VOLATILE ( decl ) ) return false ; attr = TYPE_ATTRIBUTES ( TREE_TYPE ( decl ) ) ; if ( lookup_attribute ( <STR_LIT> , attr ) ) return false ; attr = DECL_ATTRIBUTES ( decl ) ; if ( lookup_attribute ( <STR_LIT> , attr ) ) return false ; if ( DECL_SECTION_NAME ( decl ) != <NUM_LIT> ) {

const char * name = DECL_SECTION_NAME ( decl ) ;


<s> else if ( TREE_CODE ( addr ) == MEM_REF ) attrs = TYPE_ATTRIBUTES ( TREE_TYPE ( TREE_OPERAND ( addr , <NUM_LIT> ) ) ) ; else return false ; if ( lookup_attribute ( <STR_LIT> , attrs ) ) return true ; return false ;


<s> if ( ! addr ) return false ; if ( TREE_CODE ( addr ) == VAR_DECL ) attrs = DECL_ATTRIBUTES ( addr ) ; else if ( TREE_CODE ( addr ) == MEM_REF ) attrs = TYPE_ATTRIBUTES ( TREE_TYPE ( TREE_OPERAND ( addr , <NUM_LIT> ) ) ) ; else return false ; if ( lookup_attribute ( <STR_LIT> , attrs ) ) return true ; return false ;


<s> if ( lookup_attribute ( <STR_LIT> , attrs ) ) return true ; if ( lookup_attribute ( <STR_LIT> , attrs ) ) return true ; return TARGET_JLI_ALWAYS ;


<s> if ( GET_CODE ( sym_ref ) != SYMBOL_REF ) return false ; return ( SYMBOL_REF_LONG_CALL_P ( sym_ref ) || ( TARGET_LONG_CALLS_SET && ! SYMBOL_REF_SHORT_CALL_P ( sym_ref ) && ! SYMBOL_REF_MEDIUM_CALL_P ( sym_ref ) ) ) ;


<s> if ( GET_CODE ( sym_ref ) != SYMBOL_REF ) return false ;

return ( SYMBOL_REF_LONG_CALL_P ( sym_ref ) || ( TARGET_LONG_CALLS_SET && ! SYMBOL_REF_SHORT_CALL_P ( sym_ref ) && ! SYMBOL_REF_MEDIUM_CALL_P ( sym_ref ) ) ) ;


<s> attrs = TYPE_ATTRIBUTES ( TREE_TYPE ( decl ) ) ; if ( lookup_attribute ( <STR_LIT> , attrs ) ) return true ;


<s> if ( ! decl ) return false ; attrs = TYPE_ATTRIBUTES ( TREE_TYPE ( decl ) ) ;

if ( lookup_attribute ( <STR_LIT> , attrs ) ) return true ;


<s> bool arc_is_shortcall_p ( rtx sym_ref ) { if ( GET_CODE ( sym_ref ) != SYMBOL_REF ) return false ; return ( SYMBOL_REF_SHORT_CALL_P ( sym_ref ) || ( ! TARGET_LONG_CALLS_SET && ! TARGET_MEDIUM_CALLS && ! SYMBOL_REF_LONG_CALL_P ( sym_ref ) && ! SYMBOL_REF_MEDIUM_CALL_P ( sym_ref ) ) ) ;


<s> tree addr ; if ( ! MEM_P ( pat ) ) return false ; addr = MEM_EXPR ( pat ) ; if ( ! addr ) return false ; if ( TREE_CODE ( addr ) == MEM_REF || TREE_CODE ( addr ) == VAR_DECL ) { attrs = TYPE_ATTRIBUTES ( TREE_TYPE ( addr ) ) ; if ( lookup_attribute ( <STR_LIT> , attrs ) ) return true ; } if ( TREE_CODE ( addr ) == MEM_REF ) { attrs = TYPE_ATTRIBUTES ( TREE_TYPE ( TREE_OPERAND ( addr , <NUM_LIT> ) ) ) ; if ( lookup_attribute ( <STR_LIT> , attrs ) ) return true ; attrs = TYPE_ATTRIBUTES ( TREE_TYPE ( TREE_OPERAND ( addr , <NUM_LIT> ) ) ) ; if ( lookup_attribute ( <STR_LIT> , attrs ) ) return true ;


<s> if ( TREE_CODE ( addr ) == COMPONENT_REF ) { attrs = TYPE_ATTRIBUTES ( TREE_TYPE ( addr ) ) ; if ( lookup_attribute ( <STR_LIT> , attrs ) ) return true ; attrs = TYPE_ATTRIBUTES ( TREE_TYPE ( TREE_OPERAND ( addr , <NUM_LIT> ) ) ) ; if ( lookup_attribute ( <STR_LIT> , attrs ) ) return true ; attrs = TYPE_ATTRIBUTES ( TREE_TYPE ( TREE_OPERAND ( addr , <NUM_LIT> ) ) ) ; if ( lookup_attribute ( <STR_LIT> , attrs ) ) return true ;


<s> if ( align_labels . levels [ <NUM_LIT> ] . log < <NUM_LIT> ) { rtx_insn * next = next_nonnote_nondebug_insn ( label ) ; if ( INSN_P ( next ) && recog_memoized ( next ) >= <NUM_LIT> ) return <NUM_LIT> ; }

return align_labels . levels [ <NUM_LIT> ] . log ;


<s> int arc_label_align ( rtx_insn * label ) { if ( align_labels . levels [ <NUM_LIT> ] . log < <NUM_LIT> ) { rtx_insn * next = next_nonnote_nondebug_insn ( label ) ; if ( INSN_P ( next ) && recog_memoized ( next ) >= <NUM_LIT> ) return <NUM_LIT> ; } return align_labels . levels [ <NUM_LIT> ] . log ;


<s> static bool arc_legitimate_address_p ( machine_mode mode , rtx x , bool strict ) { if ( RTX_OK_FOR_BASE_P ( x , strict ) ) return true ; if ( legitimate_offset_address_p ( mode , x , TARGET_INDEXED_LOADS , strict ) ) return true ; if ( legitimate_scaled_address_p ( mode , x , strict ) ) return true ; if ( legitimate_small_data_address_p ( x , mode ) ) return true ; if ( GET_CODE ( x ) == CONST_INT && LARGE_INT ( INTVAL ( x ) ) ) return true ; if ( ! flag_pic && optimize_size && ! reload_completed && ( GET_CODE ( x ) == CONST ) && ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS ) && ( GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF ) && SYMBOL_REF_TLS_MODEL ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == <NUM_LIT> && ! SYMBOL_REF_FUNCTION_P ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) ) {

rtx addend = XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ;


<s> case CONST_DOUBLE : return true ; case NEG : return arc_legitimate_constant_p ( mode , XEXP ( x , <NUM_LIT> ) ) ; case PLUS : case MINUS : { bool t1 = arc_legitimate_constant_p ( mode , XEXP ( x , <NUM_LIT> ) ) ; bool t2 = arc_legitimate_constant_p ( mode , XEXP ( x , <NUM_LIT> ) ) ; return ( t1 && t2 ) ; } case CONST_VECTOR : switch ( mode ) { case E_V2HImode : return TARGET_PLUS_DMPY ;


<s> if ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) != CONST_INT ) return false ; addr = XEXP ( addr , <NUM_LIT> ) ; } if ( GET_CODE ( addr ) != UNSPEC || XVECLEN ( addr , <NUM_LIT> ) != <NUM_LIT> ) return false ; if ( XINT ( addr , <NUM_LIT> ) != ARC_UNSPEC_GOT && XINT ( addr , <NUM_LIT> ) != ARC_UNSPEC_GOTOFF && XINT ( addr , <NUM_LIT> ) != ARC_UNSPEC_GOTOFFPC && XINT ( addr , <NUM_LIT> ) != UNSPEC_TLS_GD && XINT ( addr , <NUM_LIT> ) != UNSPEC_TLS_IE ) return false ;

if ( GET_CODE ( XVECEXP ( addr , <NUM_LIT> , <NUM_LIT> ) ) != SYMBOL_REF && GET_CODE ( XVECEXP ( addr , <NUM_LIT> , <NUM_LIT> ) ) != LABEL_REF ) return false ;


<s> static rtx arc_legitimize_address ( rtx orig_x , rtx oldx , machine_mode mode ) {

rtx new_x = arc_legitimize_address_0 ( orig_x , oldx , mode ) ;


<s> static rtx arc_legitimize_address ( rtx orig_x , rtx oldx , machine_mode mode ) { rtx new_x = arc_legitimize_address_0 ( orig_x , oldx , mode ) ; if ( new_x ) return new_x ;


<s> int size = GET_MODE_SIZE ( mode ) ; offs = INTVAL ( XEXP ( addr , <NUM_LIT> ) ) ; upper = ( offs + <NUM_LIT> * size ) & ~ <NUM_LIT> * size ; inner = plus_constant ( Pmode , XEXP ( addr , <NUM_LIT> ) , upper ) ; if ( GET_CODE ( x ) == CONST ) inner = gen_rtx_CONST ( Pmode , inner ) ; addr = plus_constant ( Pmode , force_reg ( Pmode , inner ) , offs - upper ) ; x = addr ; }

else if ( GET_CODE ( addr ) == SYMBOL_REF && ! SYMBOL_REF_FUNCTION_P ( addr ) ) x = force_reg ( Pmode , x ) ;


<s> addr = x ; if ( GET_CODE ( addr ) == CONST ) addr = XEXP ( addr , <NUM_LIT> ) ; if ( GET_CODE ( addr ) == PLUS && CONST_INT_P ( XEXP ( addr , <NUM_LIT> ) ) && ( ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == SYMBOL_REF && ! SYMBOL_REF_FUNCTION_P ( XEXP ( addr , <NUM_LIT> ) ) ) || ( REG_P ( XEXP ( addr , <NUM_LIT> ) ) && ( INTVAL ( XEXP ( addr , <NUM_LIT> ) ) & <NUM_LIT> ) ) ) ) {


<s> case SYMBOL_REF : if ( SYMBOL_REF_TLS_MODEL ( addr ) ) return addr ; if ( ! arc_symbol_binds_local_p ( addr ) ) return gen_const_mem ( Pmode , arc_unspec_offset ( addr , ARC_UNSPEC_GOT ) ) ; case LABEL_REF : return arc_unspec_offset ( addr , ARC_UNSPEC_GOTOFFPC ) ; default : break ; } return addr ;


<s> offset_base = ( ( offset + ( <NUM_LIT> << shift ) ) & ( ( HOST_WIDE_INT ) ( ( unsigned HOST_WIDE_INT ) - <NUM_LIT> << shift ) ) ) ; if ( GET_MODE_SIZE ( mode ) + offset - offset_base <= ( <NUM_LIT> << shift ) ) { int regno ; reg = XEXP ( x , <NUM_LIT> ) ; regno = REGNO ( reg ) ; sum2 = sum = plus_constant ( Pmode , reg , offset_base ) ; if ( reg_equiv_constant ( regno ) ) { sum2 = plus_constant ( Pmode , reg_equiv_constant ( regno ) , offset_base ) ; if ( GET_CODE ( sum2 ) == PLUS ) sum2 = gen_rtx_CONST ( Pmode , sum2 ) ; } * p = gen_rtx_PLUS ( Pmode , sum , GEN_INT ( offset - offset_base ) ) ; push_reload ( sum2 , NULL_RTX , & XEXP ( * p , <NUM_LIT> ) , NULL , BASE_REG_CLASS , Pmode , VOIDmode , <NUM_LIT> , <NUM_LIT> , opnum , type ) ; return true ; } } else if ( GET_CODE ( x ) == PLUS && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS && CONST_INT_P ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) && REG_P ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) ) { push_reload ( XEXP ( x , <NUM_LIT> ) , NULL_RTX , & XEXP ( x , <NUM_LIT> ) , NULL , BASE_REG_CLASS , Pmode , VOIDmode , <NUM_LIT> , <NUM_LIT> , opnum , type ) ; return true ; }


<s> if ( ! flag_pic && model == TLS_MODEL_LOCAL_DYNAMIC ) model = TLS_MODEL_LOCAL_EXEC ; gcc_assert ( arc_tp_regno != - <NUM_LIT> ) ; switch ( model ) { case TLS_MODEL_GLOBAL_DYNAMIC : tmp = gen_reg_rtx ( Pmode ) ; emit_move_insn ( tmp , arc_unspec_offset ( addr , UNSPEC_TLS_GD ) ) ; return arc_call_tls_get_addr ( tmp ) ; case TLS_MODEL_LOCAL_DYNAMIC : rtx base ; tree decl ; const char * base_name ; decl = SYMBOL_REF_DECL ( addr ) ; base_name = DTPOFF_ZERO_SYM ; if ( decl && bss_initializer_p ( decl ) ) base_name = <STR_LIT> ; base = gen_rtx_SYMBOL_REF ( Pmode , base_name ) ; tmp = gen_reg_rtx ( Pmode ) ; emit_move_insn ( tmp , arc_unspec_offset ( base , UNSPEC_TLS_GD ) ) ;


<s> return gen_rtx_PLUS ( Pmode , force_reg ( Pmode , base ) , arc_unspec_offset ( addr , UNSPEC_TLS_OFF ) ) ; case TLS_MODEL_INITIAL_EXEC : addr = arc_unspec_offset ( addr , UNSPEC_TLS_IE ) ; addr = copy_to_mode_reg ( Pmode , gen_const_mem ( Pmode , addr ) ) ; return gen_rtx_PLUS ( Pmode , gen_rtx_REG ( Pmode , arc_tp_regno ) , addr ) ; case TLS_MODEL_LOCAL_EXEC : addr = arc_unspec_offset ( addr , UNSPEC_TLS_OFF ) ;


<s> static int arc_memory_move_cost ( machine_mode mode , reg_class_t rclass ATTRIBUTE_UNUSED , bool in ATTRIBUTE_UNUSED ) { if ( ( GET_MODE_SIZE ( mode ) <= UNITS_PER_WORD ) || ( ( GET_MODE_SIZE ( mode ) <= UNITS_PER_WORD * <NUM_LIT> ) && TARGET_LL64 ) ) return <NUM_LIT> ;

return ( <NUM_LIT> * GET_MODE_SIZE ( mode ) ) ;


<s> if ( GET_CODE ( addr ) == PLUS && GET_CODE ( XEXP ( ( addr ) , <NUM_LIT> ) ) == MULT ) return true ; return false ;


<s> static bool arc_must_save_return_addr ( struct function * func ) { if ( func -> machine -> frame_info . save_return_addr ) return true ; return false ;


<s> bool arc_need_delay ( rtx_insn * insn ) { rtx_insn * next ; if ( ! flag_delayed_branch ) return false ;

if ( NONJUMP_INSN_P ( insn ) && GET_CODE ( PATTERN ( insn ) ) == USE && ( ! ( next = next_active_insn ( insn ) ) || ( ( ! NONJUMP_INSN_P ( next ) || GET_CODE ( PATTERN ( next ) ) != SEQUENCE ) && arc_attr_type ( next ) == TYPE_RETURN ) ) && ( ! TARGET_PAD_RETURN || ( prev_active_insn ( insn ) && prev_active_insn ( prev_active_insn ( insn ) ) && prev_active_insn ( prev_active_insn ( prev_active_insn ( insn ) ) ) ) ) ) return true ;


<s> int match = operands_match_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; int match2 = operands_match_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; int intval = ( REG_P ( operands [ <NUM_LIT> ] ) ? <NUM_LIT> : CONST_INT_P ( operands [ <NUM_LIT> ] ) ? INTVAL ( operands [ <NUM_LIT> ] ) : <NUM_LIT> ) ; int neg_intval = - intval ; int short_0 = satisfies_constraint_Rcq ( operands [ <NUM_LIT> ] ) ; int short_p = ( ! cond_p && short_0 && satisfies_constraint_Rcq ( operands [ <NUM_LIT> ] ) ) ; int ret = <NUM_LIT> ;

&& REGNO ( OP ) != <NUM_LIT> ) \ || ! TARGET_V2 ) ) if ( output_p ) \ output_asm_insn ( FORMAT , operands ) ; \ return ret ; \ }


<s> int match2 = operands_match_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; int intval = ( REG_P ( operands [ <NUM_LIT> ] ) ? <NUM_LIT> : CONST_INT_P ( operands [ <NUM_LIT> ] ) ? INTVAL ( operands [ <NUM_LIT> ] ) : <NUM_LIT> ) ; int neg_intval = - intval ;

int short_0 = satisfies_constraint_Rcq ( operands [ <NUM_LIT> ] ) ;


<s> unsigned len = strlen ( fname ) ; static char buf [ <NUM_LIT> ] ; gcc_assert ( len < sizeof buf - <NUM_LIT> ) ; if ( TARGET_LONG_CALLS_SET || ( TARGET_MEDIUM_CALLS && arc_ccfsm_cond_exec_p ( ) ) ) { if ( flag_pic ) sprintf ( buf , <STR_LIT> , fname ) ; else sprintf ( buf , <STR_LIT> , fname ) ;


<s> const char * arc_output_libcall ( const char * fname ) { unsigned len = strlen ( fname ) ; static char buf [ <NUM_LIT> ] ; gcc_assert ( len < sizeof buf - <NUM_LIT> ) ; if ( TARGET_LONG_CALLS_SET || ( TARGET_MEDIUM_CALLS && arc_ccfsm_cond_exec_p ( ) ) ) { if ( flag_pic ) sprintf ( buf , <STR_LIT> , fname ) ; else sprintf ( buf , <STR_LIT> , fname ) ; } else sprintf ( buf , <STR_LIT> , fname ) ;


<s> asm_fprintf ( file , <STR_LIT> , ARC_TEMP_SCRATCH_REG , ARC_TEMP_SCRATCH_REG ) ; asm_fprintf ( file , <STR_LIT> , reg_names [ this_regno ] , reg_names [ this_regno ] , ARC_TEMP_SCRATCH_REG ) ; } fnaddr = XEXP ( DECL_RTL ( function ) , <NUM_LIT> ) ; if ( arc_is_longcall_p ( fnaddr ) ) { if ( flag_pic ) { asm_fprintf ( file , <STR_LIT> , ARC_TEMP_SCRATCH_REG ) ; assemble_name ( file , XSTR ( fnaddr , <NUM_LIT> ) ) ; fputs ( <STR_LIT> , file ) ; asm_fprintf ( file , <STR_LIT> , ARC_TEMP_SCRATCH_REG ) ; } else { fputs ( <STR_LIT> , file ) ; assemble_name ( file , XSTR ( fnaddr , <NUM_LIT> ) ) ;


<s> if ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) >= <NUM_LIT> ) fprintf ( file , <STR_LIT> ) ; arc_output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; } else gcc_unreachable ( ) ; break ; case MINUS : x = simplify_subtraction ( x ) ; if ( GET_CODE ( x ) != MINUS ) goto restart ; arc_output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; fprintf ( file , <STR_LIT> ) ; if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT && INTVAL ( XEXP ( x , <NUM_LIT> ) ) < <NUM_LIT> ) { fprintf ( file , <STR_LIT> ) ; arc_output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; fprintf ( file , <STR_LIT> ) ; } else arc_output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; break ; case ZERO_EXTEND : case SIGN_EXTEND : arc_output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; break ; case UNSPEC : const char * suffix ; bool pcrel ; pcrel = false ; rtx base ; base = NULL ; gcc_assert ( XVECLEN ( x , <NUM_LIT> ) >= <NUM_LIT> ) ; switch ( XINT ( x , <NUM_LIT> ) ) { case ARC_UNSPEC_GOT : suffix = <STR_LIT> , pcrel = true ; break ; case ARC_UNSPEC_GOTOFF : suffix = <STR_LIT> ; break ; case ARC_UNSPEC_GOTOFFPC : suffix = <STR_LIT> , pcrel = true ; break ; case ARC_UNSPEC_PLT : suffix = <STR_LIT> ; break ; case UNSPEC_TLS_GD : suffix = <STR_LIT> , pcrel = true ; break ; case UNSPEC_TLS_IE : suffix = <STR_LIT> , pcrel = true ; break ; case UNSPEC_TLS_OFF : if ( XVECLEN ( x , <NUM_LIT> ) == <NUM_LIT> ) base = XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ; if ( SYMBOL_REF_TLS_MODEL ( XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ) == TLS_MODEL_LOCAL_EXEC || ( ! flag_pic && ! base ) ) suffix = <STR_LIT> ; else suffix = <STR_LIT> ; break ; default : suffix = <STR_LIT> ; output_operand_lossage ( <STR_LIT> , XINT ( x , <NUM_LIT> ) ) ;


<s> static bool arc_pass_by_reference ( cumulative_args_t , const function_arg_info & arg ) {

return ( arg . type != <NUM_LIT> && ( TREE_CODE ( TYPE_SIZE ( arg . type ) ) != INTEGER_CST || TREE_ADDRESSABLE ( arg . type ) ) ) ;


<s> static void arc_post_atomic_barrier ( enum memmodel model ) {

if ( need_atomic_barrier_p ( model , false ) ) emit_insn ( gen_memory_barrier ( ) ) ;


<s> static void arc_post_atomic_barrier ( enum memmodel model ) { if ( need_atomic_barrier_p ( model , false ) ) emit_insn ( gen_memory_barrier ( ) ) ;


<s> jump = XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ; dlay = XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ; if ( ! JUMP_P ( jump ) || ! INSN_ANNULLED_BRANCH_P ( jump ) ) continue ; if ( ! TARGET_AT_DBR_CONDEXEC && ! INSN_FROM_TARGET_P ( dlay ) ) continue ; gcc_assert ( GET_CODE ( PATTERN ( jump ) ) == SET ) ; gcc_assert ( SET_DEST ( PATTERN ( jump ) ) == pc_rtx ) ; src = SET_SRC ( PATTERN ( jump ) ) ; gcc_assert ( GET_CODE ( src ) == IF_THEN_ELSE ) ; cond = XEXP ( src , <NUM_LIT> ) ; if ( XEXP ( src , <NUM_LIT> ) == pc_rtx ) reverse = <NUM_LIT> ; else if ( XEXP ( src , <NUM_LIT> ) == pc_rtx ) reverse = <NUM_LIT> ; else gcc_unreachable ( ) ; if ( reverse != ! INSN_FROM_TARGET_P ( dlay ) ) { machine_mode ccm = GET_MODE ( XEXP ( cond , <NUM_LIT> ) ) ;

enum rtx_code code = reverse_condition ( GET_CODE ( cond ) ) ;


<s> enum reg_class arc_preferred_reload_class ( rtx , enum reg_class cl ) {


<s> static machine_mode arc_preferred_simd_mode ( scalar_mode mode ) {


<s> static void arc_pre_atomic_barrier ( enum memmodel model ) { if ( need_atomic_barrier_p ( model , true ) ) emit_insn ( gen_memory_barrier ( ) ) ;


<s> if ( need_atomic_barrier_p ( model , true ) ) emit_insn ( gen_memory_barrier ( ) ) ;


<s> if ( output_sdata ) fputs ( <STR_LIT> , file ) ; output_sdata = <NUM_LIT> ; break ; case PLUS : if ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == MULT ) index = XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) , base = XEXP ( addr , <NUM_LIT> ) ; else if ( CONST_INT_P ( XEXP ( addr , <NUM_LIT> ) ) ) index = XEXP ( addr , <NUM_LIT> ) , base = XEXP ( addr , <NUM_LIT> ) ; else base = XEXP ( addr , <NUM_LIT> ) , index = XEXP ( addr , <NUM_LIT> ) ; gcc_assert ( OBJECT_P ( base ) ) ; arc_print_operand_address ( file , base ) ; if ( CONSTANT_P ( base ) && CONST_INT_P ( index ) ) fputc ( '+' , file ) ; else fputc ( ',' , file ) ; gcc_assert ( OBJECT_P ( index ) ) ; arc_print_operand_address ( file , index ) ; break ;


<s> if ( refers_to_regno_p ( <NUM_LIT> , <NUM_LIT> , dest , <NUM_LIT> ) ) { gcc_assert ( REG_P ( src ) ) ; gcc_assert ( state == none ) ; state = destDx ; } if ( state == none ) return false ; if ( state == srcDx ) { if ( TARGET_DPFP_DISABLE_LRSR ) { rtx set = gen_rtx_SET ( dest , src ) ; rtx use1 = gen_rtx_USE ( VOIDmode , const1_rtx ) ; emit_insn ( gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , set , use1 ) ) ) ; } else { rtx destHigh = simplify_gen_subreg ( SImode , dest , DFmode , TARGET_BIG_ENDIAN ? <NUM_LIT> : <NUM_LIT> ) ; rtx destLow = simplify_gen_subreg ( SImode , dest , DFmode , TARGET_BIG_ENDIAN ? <NUM_LIT> : <NUM_LIT> ) ; emit_insn ( gen_rtx_SET ( destHigh , gen_rtx_UNSPEC_VOLATILE ( Pmode , gen_rtvec ( <NUM_LIT> , src ) , VUNSPEC_ARC_LR_HIGH ) ) ) ; emit_insn ( gen_rtx_SET ( destLow , gen_rtx_UNSPEC_VOLATILE ( Pmode , gen_rtvec ( <NUM_LIT> , src ) , VUNSPEC_ARC_LR ) ) ) ;


<s> if ( SYMBOL_REF_TLS_MODEL ( op ) ) return true ; if ( ! flag_pic ) return false ; tree decl = SYMBOL_REF_DECL ( op ) ; return ! skip_local || ! decl || ! default_binds_local_p ( decl ) ; } 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 ( arc_raw_symbolic_reference_mentioned_p ( XVECEXP ( op , i , j ) , skip_local ) ) return true ; } else if ( fmt [ i ] == 'e' && arc_raw_symbolic_reference_mentioned_p ( XEXP ( op , i ) , skip_local ) ) return true ;


<s> return ( ( ( ( r & <NUM_LIT> ) ^ <NUM_LIT> ) - <NUM_LIT> ) & <NUM_LIT> ) == r ; default : gcc_unreachable ( ) ;


<s> if ( REG_P ( x ) && refers_to_regno_p ( regno , x ) ) return x ; fmt = GET_RTX_FORMAT ( GET_CODE ( x ) ) ; for ( i = GET_RTX_LENGTH ( GET_CODE ( x ) ) - <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) { if ( fmt [ i ] == 'e' ) { if ( ( tem = regno_use_in ( regno , XEXP ( x , i ) ) ) ) return tem ; } else if ( fmt [ i ] == 'E' ) for ( j = XVECLEN ( x , i ) - <NUM_LIT> ; j >= <NUM_LIT> ; j -- ) if ( ( tem = regno_use_in ( regno , XVECEXP ( x , i , j ) ) ) ) return tem ; } return NULL_RTX ;


<s> int i , j ; rtx tem ; if ( REG_P ( x ) && refers_to_regno_p ( regno , x ) ) return x ; fmt = GET_RTX_FORMAT ( GET_CODE ( x ) ) ; for ( i = GET_RTX_LENGTH ( GET_CODE ( x ) ) - <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) { if ( fmt [ i ] == 'e' ) { if ( ( tem = regno_use_in ( regno , XEXP ( x , i ) ) ) ) return tem ; } else if ( fmt [ i ] == 'E' ) for ( j = XVECLEN ( x , i ) - <NUM_LIT> ; j >= <NUM_LIT> ; j -- ) if ( ( tem = regno_use_in ( regno , XVECEXP ( x , i , j ) ) ) ) return tem ; }


<s> if ( ! link_insn ) continue ; else { rtx op , cc_clob_rtx , op0 , op1 , brcc_insn , note ; rtx cmp0 , cmp1 ; if ( find_reg_note ( link_insn , REG_SAVE_NOTE , GEN_INT ( <NUM_LIT> ) ) ) continue ; op = XEXP ( pc_target , <NUM_LIT> ) ; op0 = cmp0 = XEXP ( SET_SRC ( pat ) , <NUM_LIT> ) ; op1 = cmp1 = XEXP ( SET_SRC ( pat ) , <NUM_LIT> ) ; if ( GET_CODE ( op0 ) == ZERO_EXTRACT && XEXP ( op0 , <NUM_LIT> ) == const1_rtx && ( GET_CODE ( op ) == EQ || GET_CODE ( op ) == NE ) ) { op0 = XEXP ( cmp0 , <NUM_LIT> ) ; op1 = XEXP ( cmp0 , <NUM_LIT> ) ; } else if ( ! register_operand ( op0 , VOIDmode ) || ! general_operand ( op1 , VOIDmode ) ) continue ; else if ( TARGET_SPFP && GET_MODE ( op0 ) == SFmode && GET_MODE ( op1 ) == SFmode ) continue ; if ( reg_set_between_p ( op0 , link_insn , insn ) ) continue ; if ( reg_set_between_p ( op1 , link_insn , insn ) ) continue ; if ( ( reg_set_between_p ( SET_DEST ( pat ) , link_insn , insn ) ) || ( reg_used_between_p ( SET_DEST ( pat ) , link_insn , insn ) ) ) continue ; if ( ! find_regno_note ( insn , REG_DEAD , CC_REG ) ) continue ; op = gen_rtx_fmt_ee ( GET_CODE ( op ) , GET_MODE ( op ) , cmp0 , cmp1 ) ; if ( ! brcc_nolimm_operator ( op , VOIDmode ) && ! long_immediate_operand ( op1 , VOIDmode ) && ( TARGET_ARC700 || ( TARGET_V2 && optimize_size ) || next_active_insn ( link_insn ) != insn ) ) continue ; if ( op0 != cmp0 ) cc_clob_rtx = gen_rtx_REG ( CC_ZNmode , CC_REG ) ; else if ( ( offset >= - <NUM_LIT> && offset < <NUM_LIT> ) && rtx_equal_p ( op1 , const0_rtx ) && compact_register_operand ( op0 , VOIDmode ) && ( GET_CODE ( op ) == EQ || GET_CODE ( op ) == NE ) ) cc_clob_rtx = gen_rtx_REG ( CC_Zmode , CC_REG ) ;

else cc_clob_rtx = gen_rtx_REG ( CCmode , CC_REG ) ;


<s> static void arc_reorg_loops ( void ) {

reorg_loops ( true , & arc_doloop_hooks ) ;


<s> reorg_loops ( true , & arc_doloop_hooks ) ;


<s> gcc_assert ( end_reg > <NUM_LIT> ) ; if ( arc_frame_pointer_needed ( ) && offset ) { frame_move ( stack_pointer_rtx , hard_frame_pointer_rtx ) ; frame_allocated = offset ; offset = <NUM_LIT> ; } if ( restore_fp ) frame_allocated += frame_restore_reg ( hard_frame_pointer_rtx , <NUM_LIT> ) ; if ( offset ) { frame_stack_add ( offset ) ; frame_allocated += offset ; offset = <NUM_LIT> ; } insn = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( ( return_p ? <NUM_LIT> : <NUM_LIT> ) + nregs + <NUM_LIT> ) ) ; indx = <NUM_LIT> ; if ( return_p ) { reg = gen_rtx_REG ( Pmode , <NUM_LIT> ) ; XVECEXP ( insn , <NUM_LIT> , indx ++ ) = ret_rtx ; XVECEXP ( insn , <NUM_LIT> , indx ++ ) = gen_rtx_SET ( stack_pointer_rtx , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , reg ) ) ; frame_allocated += UNITS_PER_WORD ; } else { XVECEXP ( insn , <NUM_LIT> , nregs ) = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( Pmode , RETURN_ADDR_REGNUM ) ) ; } for ( regno = start_reg , off = <NUM_LIT> ; regno <= end_reg ; regno ++ , indx ++ , off += UNITS_PER_WORD ) { reg = gen_rtx_REG ( SImode , regno ) ; mem = gen_frame_mem ( SImode , plus_constant ( Pmode , stack_pointer_rtx , off ) ) ;

XVECEXP ( insn , <NUM_LIT> , indx ) = gen_rtx_SET ( reg , mem ) ;


<s> if ( early_blink_restore ) { rtx addr = plus_constant ( Pmode , stack_pointer_rtx , offs ) ; reg = gen_rtx_REG ( Pmode , RETURN_ADDR_REGNUM ) ; rtx insn = frame_move_inc ( reg , gen_frame_mem ( Pmode , addr ) , stack_pointer_rtx , NULL_RTX ) ; add_reg_note ( insn , REG_CFA_RESTORE , reg ) ; restore_blink = false ; } if ( gmask ) for ( i = <NUM_LIT> ; i <= GMASK_LEN ; i ++ ) { machine_mode restore_mode = SImode ; if ( TARGET_LL64 && ( ( i % <NUM_LIT> ) == <NUM_LIT> ) && ( ( gmask & ( <NUM_LIT> << i ) ) != <NUM_LIT> ) && ( ( gmask & ( <NUM_LIT> << ( i + <NUM_LIT> ) ) ) != <NUM_LIT> ) ) restore_mode = DImode ; else if ( ( gmask & ( <NUM_LIT> << i ) ) == <NUM_LIT> ) continue ; reg = gen_rtx_REG ( restore_mode , i ) ; offs = <NUM_LIT> ; switch ( restore_mode ) { case E_DImode : if ( ( GMASK_LEN - __builtin_clzll ( gmask ) ) == ( i + <NUM_LIT> ) && early_blink_restore ) offs = <NUM_LIT> ; break ; case E_SImode : if ( ( GMASK_LEN - __builtin_clzll ( gmask ) ) == i && early_blink_restore ) offs = <NUM_LIT> ; break ;


<s> else if ( ( fn_type & ARC_FUNCTION_ILINK2 ) != <NUM_LIT> ) regno = ILINK2_REG ; else gcc_unreachable ( ) ; } else if ( ARC_NORMAL_P ( fn_type ) || ARC_NAKED_P ( fn_type ) ) regno = RETURN_ADDR_REGNUM ; gcc_assert ( regno != <NUM_LIT> ) ;


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

return get_hard_reg_initial_val ( Pmode , RETURN_ADDR_REGNUM ) ;


<s> rtx arc_return_addr_rtx ( int count , ATTRIBUTE_UNUSED rtx frame ) {

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


<s> else { HOST_WIDE_INT size = int_size_in_bytes ( type ) ; return ( size == - <NUM_LIT> || size > ( TARGET_V2 ? <NUM_LIT> : <NUM_LIT> ) ) ; }


<s> insn = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( nregs + ( save_fp ? <NUM_LIT> : <NUM_LIT> ) + <NUM_LIT> ) ) ; indx = <NUM_LIT> ; reg = gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - nregs * UNITS_PER_WORD ) ) ; RTX_FRAME_RELATED_P ( reg ) = <NUM_LIT> ; XVECEXP ( insn , <NUM_LIT> , indx ++ ) = reg ; off = nregs * UNITS_PER_WORD ; if ( save_blink ) { reg = gen_rtx_REG ( Pmode , RETURN_ADDR_REGNUM ) ; mem = gen_frame_mem ( Pmode , plus_constant ( Pmode , stack_pointer_rtx , off ) ) ; XVECEXP ( insn , <NUM_LIT> , indx ) = gen_rtx_SET ( mem , reg ) ; RTX_FRAME_RELATED_P ( XVECEXP ( insn , <NUM_LIT> , indx ++ ) ) = <NUM_LIT> ; off -= UNITS_PER_WORD ; save_blink = false ; } for ( regno = start_reg ; regno <= end_reg ; regno ++ , indx ++ , off -= UNITS_PER_WORD ) { reg = gen_rtx_REG ( SImode , regno ) ; mem = gen_frame_mem ( SImode , plus_constant ( Pmode , stack_pointer_rtx , off ) ) ; XVECEXP ( insn , <NUM_LIT> , indx ) = gen_rtx_SET ( mem , reg ) ; RTX_FRAME_RELATED_P ( XVECEXP ( insn , <NUM_LIT> , indx ) ) = <NUM_LIT> ; gmask = gmask & ~ ( <NUM_LIT> << regno ) ; } if ( save_fp ) { mem = gen_frame_mem ( Pmode , plus_constant ( Pmode , stack_pointer_rtx , off ) ) ; XVECEXP ( insn , <NUM_LIT> , indx ) = gen_rtx_SET ( mem , hard_frame_pointer_rtx ) ; RTX_FRAME_RELATED_P ( XVECEXP ( insn , <NUM_LIT> , indx ++ ) ) = <NUM_LIT> ; off -= UNITS_PER_WORD ; XVECEXP ( insn , <NUM_LIT> , indx ) = gen_rtx_SET ( hard_frame_pointer_rtx , stack_pointer_rtx ) ;


<s> if ( save_blink ) { reg = gen_rtx_REG ( Pmode , RETURN_ADDR_REGNUM ) ; frame_allocated += frame_save_reg ( reg , offset ) ; offset = <NUM_LIT> ; } if ( reg_size || offset ) { frame_stack_add ( offset - reg_size ) ; frame_allocated += nregs * UNITS_PER_WORD - offset ; offset = <NUM_LIT> ; } insn = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( nregs + <NUM_LIT> ) ) ; indx = <NUM_LIT> ; XVECEXP ( insn , <NUM_LIT> , nregs ) = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( Pmode , RETURN_ADDR_REGNUM ) ) ; for ( regno = start_reg , indx = <NUM_LIT> , off = <NUM_LIT> ; regno <= end_reg ; regno ++ , indx ++ , off += UNITS_PER_WORD ) { reg = gen_rtx_REG ( SImode , regno ) ; mem = gen_frame_mem ( SImode , plus_constant ( Pmode , stack_pointer_rtx , off ) ) ; XVECEXP ( insn , <NUM_LIT> , indx ) = gen_rtx_SET ( mem , reg ) ; RTX_FRAME_RELATED_P ( XVECEXP ( insn , <NUM_LIT> , indx ) ) = <NUM_LIT> ; gmask = gmask & ~ ( <NUM_LIT> << regno ) ; } insn = frame_insn ( insn ) ; for ( regno = start_reg , off = <NUM_LIT> ; regno <= end_reg ; regno ++ , off += UNITS_PER_WORD ) { reg = gen_rtx_REG ( SImode , regno ) ; mem = gen_rtx_MEM ( SImode , plus_constant ( Pmode , stack_pointer_rtx , off ) ) ; add_reg_note ( insn , REG_CFA_OFFSET , gen_rtx_SET ( mem , reg ) ) ; } if ( arc_must_save_return_addr ( cfun ) ) { emit_insn ( gen_rtx_SET ( gen_rtx_REG ( Pmode , RETURN_ADDR_REGNUM ) , gen_rtx_MEM ( Pmode , plus_constant ( Pmode , stack_pointer_rtx , reg_size ) ) ) ) ; } for ( regno = <NUM_LIT> ; regno <= GMASK_LEN ; regno ++ ) {

if ( ( gmask & ( <NUM_LIT> << regno ) ) == <NUM_LIT> ) continue ;


<s> int frame_allocated = <NUM_LIT> ; int i ; if ( save_blink ) { reg = gen_rtx_REG ( Pmode , RETURN_ADDR_REGNUM ) ; frame_allocated += frame_save_reg ( reg , offset ) ; offset = <NUM_LIT> ; } if ( gmask ) for ( i = GMASK_LEN ; i >= <NUM_LIT> ; i -- ) { machine_mode save_mode = SImode ; if ( TARGET_LL64 && ( ( i - <NUM_LIT> ) % <NUM_LIT> == <NUM_LIT> ) && ( ( gmask & ( <NUM_LIT> << i ) ) != <NUM_LIT> ) && ( ( gmask & ( <NUM_LIT> << ( i - <NUM_LIT> ) ) ) != <NUM_LIT> ) ) { save_mode = DImode ; -- i ; } else if ( ( gmask & ( <NUM_LIT> << i ) ) == <NUM_LIT> ) continue ;


<s> if ( gmask ) for ( i = GMASK_LEN ; i >= <NUM_LIT> ; i -- ) { machine_mode save_mode = SImode ;

if ( TARGET_LL64 && ( ( i - <NUM_LIT> ) % <NUM_LIT> == <NUM_LIT> ) && ( ( gmask & ( <NUM_LIT> << i ) ) != <NUM_LIT> ) && ( ( gmask & ( <NUM_LIT> << ( i - <NUM_LIT> ) ) ) != <NUM_LIT> ) ) {


<s> bool arc_scheduling_not_expected ( void ) { return cfun -> machine -> arc_reorg_started ;


<s> rtx set = single_set ( insn ) ; if ( set && GET_MODE ( SET_SRC ( set ) ) == DFmode && GET_CODE ( SET_SRC ( set ) ) == REG ) { return priority + <NUM_LIT> ; }


<s> if ( set && GET_MODE ( SET_SRC ( set ) ) == DFmode && GET_CODE ( SET_SRC ( set ) ) == REG ) { return priority + <NUM_LIT> ; }


<s> case TUNE_ARCHS4XD : return <NUM_LIT> ; default : break ; }


<s> addr = find_replacement ( & XEXP ( mem , <NUM_LIT> ) ) ; } } else { gcc_assert ( MEM_P ( x ) ) ; addr = XEXP ( x , <NUM_LIT> ) ; addr = simplify_rtx ( addr ) ; } if ( addr && GET_CODE ( addr ) == PLUS && CONST_INT_P ( XEXP ( addr , <NUM_LIT> ) ) && ( ! RTX_OK_FOR_OFFSET_P ( mode , XEXP ( addr , <NUM_LIT> ) ) ) ) { switch ( mode ) { case E_QImode : sri -> icode = in_p ? CODE_FOR_reload_qi_load : CODE_FOR_reload_qi_store ; break ; case E_HImode : sri -> icode = in_p ? CODE_FOR_reload_hi_load : CODE_FOR_reload_hi_store ; break ;


<s> void arc_secondary_reload_conv ( rtx reg , rtx mem , rtx scratch , bool store_p ) { rtx addr ; gcc_assert ( GET_CODE ( mem ) == MEM ) ; addr = XEXP ( mem , <NUM_LIT> ) ;


<s> gcc_assert ( GET_CODE ( mem ) == MEM ) ; addr = XEXP ( mem , <NUM_LIT> ) ; emit_move_insn ( scratch , addr ) ; mem = replace_equiv_address_nv ( mem , scratch ) ; if ( store_p ) emit_insn ( gen_rtx_SET ( mem , reg ) ) ;

else emit_insn ( gen_rtx_SET ( reg , mem ) ) ;


<s> machine_mode arc_select_cc_mode ( enum rtx_code op , rtx x , rtx y ) { machine_mode mode = GET_MODE ( x ) ; rtx x1 ; if ( GET_MODE_CLASS ( mode ) == MODE_INT && y == const0_rtx && ( op == EQ || op == NE || ( ( op == LT || op == GE ) && GET_MODE_SIZE ( GET_MODE ( x ) ) <= <NUM_LIT> ) ) ) return CC_ZNmode ; if ( mode == SImode && GET_CODE ( y ) == NEG && ( op == EQ || op == NE ) ) return CC_ZNmode ; if ( mode == SImode && ( op == EQ || op == NE ) && CONST_INT_P ( y ) && ( ( INTVAL ( y ) - <NUM_LIT> ) & INTVAL ( y ) ) == <NUM_LIT> && INTVAL ( y ) ) return CC_Zmode ; if ( mode == SImode && ( op == EQ || op == NE ) && CONST_INT_P ( y ) && GET_CODE ( x ) == AND && CONST_INT_P ( ( x1 = XEXP ( x , <NUM_LIT> ) ) ) && ( ( INTVAL ( x1 ) + <NUM_LIT> ) & INTVAL ( x1 ) ) == <NUM_LIT> && ( ~ INTVAL ( x1 ) | INTVAL ( y ) ) < <NUM_LIT> && ( ~ INTVAL ( x1 ) | INTVAL ( y ) ) > - <NUM_LIT> ) return CC_Zmode ; if ( GET_MODE ( x ) == SImode && ( op == LTU || op == GEU ) && GET_CODE ( x ) == PLUS && ( rtx_equal_p ( XEXP ( x , <NUM_LIT> ) , y ) || rtx_equal_p ( XEXP ( x , <NUM_LIT> ) , y ) ) ) return CC_Cmode ; if ( TARGET_ARGONAUT_SET && ( ( mode == SFmode && TARGET_SPFP ) || ( mode == DFmode && TARGET_DPFP ) ) ) switch ( op ) { case EQ : case NE : case UNEQ : case LTGT : case ORDERED : case UNORDERED : return CC_FPXmode ; case LT : case UNGE : case GT : case UNLE : return CC_FP_GTmode ; case LE : case UNGT : case GE : case UNLT : return CC_FP_GEmode ; default : gcc_unreachable ( ) ; } else if ( TARGET_HARD_FLOAT && ( ( mode == SFmode && TARGET_FP_SP_BASE ) || ( mode == DFmode && TARGET_FP_DP_BASE ) ) ) switch ( op ) { case EQ : case NE : case UNORDERED : case ORDERED : case UNLT : case UNLE : case UNGT : case UNGE : return CC_FPUmode ; case LT : case LE : case GT : case GE : return CC_FPUEmode ; case LTGT : case UNEQ : return CC_FPU_UNEQmode ; default : gcc_unreachable ( ) ; } else if ( GET_MODE_CLASS ( mode ) == MODE_FLOAT && TARGET_OPTFPE ) { switch ( op ) { case EQ : case NE : return CC_Zmode ; case LT : case UNGE :


<s> bool arc_sets_cc_p ( rtx_insn * insn ) { if ( NONJUMP_INSN_P ( insn ) ) if ( rtx_sequence * seq = dyn_cast < rtx_sequence * > ( PATTERN ( insn ) ) ) insn = seq -> insn ( seq -> len ( ) - <NUM_LIT> ) ; return arc_attr_type ( insn ) == TYPE_COMPARE ;


<s> if ( FUNCTION_ARG_REGNO_P ( first_anon_arg ) ) { int first_reg_offset = first_anon_arg ; if ( ! no_rtl ) { rtx regblock = gen_rtx_MEM ( BLKmode , plus_constant ( Pmode , arg_pointer_rtx , FIRST_PARM_OFFSET ( <NUM_LIT> ) ) ) ;


<s> switch ( get_arc_condition_code ( comparison ) ) { case ARC_CC_EQ : case ARC_CC_NE : return offset >= - <NUM_LIT> && offset <= <NUM_LIT> ;

case ARC_CC_GT : case ARC_CC_LE : case ARC_CC_GE : case ARC_CC_LT :


<s> int is_short = arc_verify_short ( insn , cfun -> machine -> unalign , - <NUM_LIT> ) ;

extract_constrain_insn_cached ( insn ) ;


<s> const char * arc_short_long ( rtx_insn * insn , const char * s_tmpl , const char * l_tmpl ) {

int is_short = arc_verify_short ( insn , cfun -> machine -> unalign , - <NUM_LIT> ) ;


<s> label1 = gen_label_rtx ( ) ; emit_label ( label1 ) ; } label2 = gen_label_rtx ( ) ; emit_insn ( gen_arc_load_exclusivesi ( rval , mem ) ) ; mode = SELECT_CC_MODE ( NE , rval , oldval ) ; cond = gen_rtx_REG ( mode , CC_REG ) ; emit_insn ( gen_rtx_SET ( cond , gen_rtx_COMPARE ( mode , rval , oldval ) ) ) ; x = gen_rtx_NE ( VOIDmode , cond , const0_rtx ) ; x = gen_rtx_IF_THEN_ELSE ( VOIDmode , x , gen_rtx_LABEL_REF ( Pmode , label2 ) , pc_rtx ) ; emit_unlikely_jump ( gen_rtx_SET ( pc_rtx , x ) ) ; emit_insn ( gen_arc_store_exclusivesi ( mem , newval ) ) ; if ( ! is_weak ) { cond = gen_rtx_REG ( CC_Zmode , CC_REG ) ; x = gen_rtx_NE ( VOIDmode , cond , const0_rtx ) ; x = gen_rtx_IF_THEN_ELSE ( VOIDmode , x , gen_rtx_LABEL_REF ( Pmode , label1 ) , pc_rtx ) ; emit_unlikely_jump ( gen_rtx_SET ( pc_rtx , x ) ) ; } if ( mod_f != MEMMODEL_RELAXED ) emit_label ( label2 ) ; arc_post_atomic_barrier ( mod_s ) ; if ( mod_f == MEMMODEL_RELAXED ) emit_label ( label2 ) ;


<s> case <NUM_LIT> : maskx = <NUM_LIT> << ( __builtin_ffs ( mask ) - <NUM_LIT> ) ; emit_insn ( gen_rtx_SET ( operands [ <NUM_LIT> ] , gen_rtx_IOR ( SImode , op1 , GEN_INT ( maskx ) ) ) ) ; mask &= ~ maskx ; op1 = operands [ <NUM_LIT> ] ; case <NUM_LIT> : maskx = <NUM_LIT> << ( __builtin_ffs ( mask ) - <NUM_LIT> ) ; emit_insn ( gen_rtx_SET ( operands [ <NUM_LIT> ] , gen_rtx_IOR ( SImode , op1 , GEN_INT ( maskx ) ) ) ) ; break ; case <NUM_LIT> :


<s> if ( GET_MODE ( operands [ <NUM_LIT> ] ) == V2SImode ) { intval0 = INTVAL ( XVECEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> , <NUM_LIT> ) ) ; intval1 = INTVAL ( XVECEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> , <NUM_LIT> ) ) ; } else { intval1 = INTVAL ( XVECEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> , <NUM_LIT> ) ) << <NUM_LIT> ; intval1 |= INTVAL ( XVECEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> , <NUM_LIT> ) ) & <NUM_LIT> ; intval0 = INTVAL ( XVECEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> , <NUM_LIT> ) ) << <NUM_LIT> ; intval0 |= INTVAL ( XVECEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> , <NUM_LIT> ) ) & <NUM_LIT> ; } xop [ <NUM_LIT> ] = gen_rtx_REG ( SImode , REGNO ( operands [ <NUM_LIT> ] ) ) ; xop [ <NUM_LIT> ] = gen_rtx_REG ( SImode , REGNO ( operands [ <NUM_LIT> ] ) + <NUM_LIT> ) ; xop [ <NUM_LIT> ] = GEN_INT ( trunc_int_for_mode ( intval0 , SImode ) ) ; xop [ <NUM_LIT> ] = GEN_INT ( trunc_int_for_mode ( intval1 , SImode ) ) ; emit_move_insn ( xop [ <NUM_LIT> ] , xop [ <NUM_LIT> ] ) ; emit_move_insn ( xop [ <NUM_LIT> ] , xop [ <NUM_LIT> ] ) ; return ; } for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) {

if ( MEM_P ( operands [ i ] ) && auto_inc_p ( XEXP ( operands [ i ] , <NUM_LIT> ) ) ) {


<s> HOST_WIDE_INT shift = __builtin_ffs ( ival ) ; shimm = ( ival >> ( shift - <NUM_LIT> ) ) & <NUM_LIT> ; emit_insn ( gen_rtx_SET ( operands [ <NUM_LIT> ] , GEN_INT ( shimm ) ) ) ; emit_insn ( gen_rtx_SET ( operands [ <NUM_LIT> ] , gen_rtx_ASHIFT ( mode , operands [ <NUM_LIT> ] , GEN_INT ( shift - <NUM_LIT> ) ) ) ) ; return true ; } if ( ( ival & ~ <NUM_LIT> ) == <NUM_LIT> ) { shimm = ( ival * <NUM_LIT> + <NUM_LIT> ) & <NUM_LIT> ; emit_insn ( gen_rtx_SET ( operands [ <NUM_LIT> ] , gen_rtx_ROTATERT ( mode , GEN_INT ( shimm ) , const1_rtx ) ) ) ; return true ; } if ( IS_POWEROF2_P ( ival + <NUM_LIT> ) ) {

emit_insn ( gen_rtx_SET ( operands [ <NUM_LIT> ] , constm1_rtx ) ) ;


<s> rtx out_addr , in_addr ; if ( ! producer ) return false ; if ( ! consumer ) return false ; out_set = single_set ( producer ) ; if ( out_set ) { out_addr = SET_DEST ( out_set ) ; if ( ! out_addr ) return false ; if ( GET_CODE ( out_addr ) == ZERO_EXTEND || GET_CODE ( out_addr ) == SIGN_EXTEND ) out_addr = XEXP ( out_addr , <NUM_LIT> ) ;

if ( ! MEM_P ( out_addr ) ) return false ;


<s> if ( out_set ) { out_addr = SET_DEST ( out_set ) ; if ( ! out_addr ) return false ; if ( GET_CODE ( out_addr ) == ZERO_EXTEND || GET_CODE ( out_addr ) == SIGN_EXTEND ) out_addr = XEXP ( out_addr , <NUM_LIT> ) ; if ( ! MEM_P ( out_addr ) ) return false ; in_set = single_set ( consumer ) ; if ( in_set ) { in_addr = SET_SRC ( in_set ) ; if ( ! in_addr ) return false ; if ( GET_CODE ( in_addr ) == ZERO_EXTEND || GET_CODE ( in_addr ) == SIGN_EXTEND ) in_addr = XEXP ( in_addr , <NUM_LIT> ) ; if ( ! MEM_P ( in_addr ) ) return false ; in_addr = XEXP ( in_addr , <NUM_LIT> ) ; out_addr = XEXP ( out_addr , <NUM_LIT> ) ; return exp_equiv_p ( in_addr , out_addr , <NUM_LIT> , true ) ;


<s> bool arc_store_addr_hazard_p ( rtx_insn * producer , rtx_insn * consumer ) { if ( TARGET_ARC700 && ( arc_tune != ARC_TUNE_ARC7XX ) ) return true ;

return arc_store_addr_hazard_internal_p ( producer , consumer ) ;


<s> static bool arc_symbol_binds_local_p ( const_rtx x ) {

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


<s> next = next_nonnote_insn ( label ) ;

if ( next ) return ( ! JUMP_TABLE_DATA_P ( next ) || GET_CODE ( PATTERN ( next ) ) != ADDR_VEC ) ;


<s> gcc_assert ( GET_CODE ( label ) == CODE_LABEL || ( GET_CODE ( label ) == NOTE && NOTE_KIND ( label ) == NOTE_INSN_DELETED_LABEL ) ) ;


cfun -> machine -> unalign ^= <NUM_LIT> ;


<s> char * lo0 = lo ; for ( ; * up ; up ++ , lo ++ ) * lo = TOLOWER ( * up ) ; * lo = '\0' ; return lo0 ;


<s> int arc_unalign_branch_p ( rtx branch ) { rtx note ; if ( ! TARGET_UNALIGN_BRANCH ) return <NUM_LIT> ; if ( get_attr_delay_slot_filled ( branch ) == DELAY_SLOT_FILLED_YES && ! NEXT_INSN ( branch ) -> deleted ( ) ) return <NUM_LIT> ; note = find_reg_note ( branch , REG_BR_PROB , <NUM_LIT> ) ;

return ( ! note || ( arc_unalign_prob_threshold && ! br_prob_note_reliable_p ( note ) ) || INTVAL ( XEXP ( note , <NUM_LIT> ) ) < arc_unalign_prob_threshold ) ;


<s> static rtx arc_unspec_offset ( rtx loc , int unspec ) { return gen_rtx_CONST ( Pmode , gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , loc ) , unspec ) ) ;


<s> if ( flag_pic ) return false ; if ( SYMBOL_REF_SMALL_P ( symbol ) ) return false ; return default_use_anchors_for_symbol_p ( symbol ) ;


<s> if ( op == MOVE_BY_PIECES ) return false ;

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


<s> if ( op == MOVE_BY_PIECES ) return false ; return default_use_by_pieces_infrastructure_p ( size , align , op , speed_p ) ;


<s> case E_V2SImode : return TARGET_PLUS_QMACW ; case E_V4SImode : case E_V8HImode : return TARGET_SIMD_SET ; default : return false ;


<s> static bool arc_vector_mode_supported_p ( machine_mode mode ) { switch ( mode ) { case E_V2HImode : return TARGET_PLUS_DMPY ; case E_V4HImode : case E_V2SImode : return TARGET_PLUS_QMACW ; case E_V4SImode :


<s> static int arc_verify_short ( rtx_insn * insn , int , int check_attr ) { enum attr_iscompact iscompact ; if ( check_attr > <NUM_LIT> ) { iscompact = get_attr_iscompact ( insn ) ; if ( iscompact == ISCOMPACT_FALSE ) return <NUM_LIT> ; } return ( get_attr_length ( insn ) & <NUM_LIT> ) != <NUM_LIT> ;


<s> static bool arc_warn_func_return ( tree decl ) {

struct function * func = DECL_STRUCT_FUNCTION ( decl ) ;


<s> int arc_write_ext_corereg ( rtx insn ) { subrtx_iterator :: array_type array ; FOR_EACH_SUBRTX ( iter , array , PATTERN ( insn ) , NONCONST ) { const_rtx x = * iter ; switch ( GET_CODE ( x ) ) {

case SET : case POST_INC : case POST_DEC : case PRE_INC : case PRE_DEC :


<s> if ( GET_CODE ( dest ) == IF_THEN_ELSE ) dest = XEXP ( dest , XEXP ( dest , <NUM_LIT> ) == pc_rtx ? <NUM_LIT> : <NUM_LIT> ) ;


<s> rtx dest = ( GET_CODE ( pat ) == PARALLEL ? SET_SRC ( XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ) : SET_SRC ( pat ) ) ; int dest_uid ; if ( GET_CODE ( dest ) == IF_THEN_ELSE ) dest = XEXP ( dest , XEXP ( dest , <NUM_LIT> ) == pc_rtx ? <NUM_LIT> : <NUM_LIT> ) ;


<s> case CONST : case CONST_INT : return true ; default : error ( <STR_LIT> <STR_LIT> ) ; break ; }


<s> return new pass_arc_ifcvt ( m_ctxt ) ;


<s> addr = XEXP ( op , <NUM_LIT> ) ; if ( ! legitimate_small_data_address_p ( addr , mode ) ) return false ; if ( ! short_p || size == <NUM_LIT> ) return true ; align = get_symbol_alignment ( addr ) ; switch ( mode ) {


<s> if ( GET_CODE ( pat ) == SET ) { rtx src = SET_SRC ( pat ) ; if ( COMMUTATIVE_P ( src ) ) { rtx src0 = XEXP ( src , <NUM_LIT> ) ; rtx src1 = XEXP ( src , <NUM_LIT> ) ; rtx dst = SET_DEST ( pat ) ; if ( rtx_equal_p ( src1 , dst ) && ! rtx_equal_p ( src0 , dst ) && REG_P ( src0 ) ) pat = gen_rtx_SET ( dst , gen_rtx_fmt_ee ( GET_CODE ( src ) , GET_MODE ( src ) , src1 , src0 ) ) ; } } if ( RTX_FRAME_RELATED_P ( insn ) ) { gcc_assert ( annulled ) ; rtx note = alloc_reg_note ( REG_FRAME_RELATED_EXPR , pat , REG_NOTES ( insn ) ) ; validate_change ( insn , & REG_NOTES ( insn ) , note , <NUM_LIT> ) ;


<s> return simplify_gen_subreg ( SImode , in , DImode , TARGET_BIG_ENDIAN ? <NUM_LIT> : <NUM_LIT> ) ;


return simplify_gen_subreg ( SImode , in , DImode , TARGET_BIG_ENDIAN ? <NUM_LIT> : <NUM_LIT> ) ;


<s> void emit_shift ( enum rtx_code code , rtx op0 , rtx op1 , rtx op2 ) {

rtx shift = gen_rtx_fmt_ee ( code , SImode , op1 , op2 ) ;


<s> void emit_shift ( enum rtx_code code , rtx op0 , rtx op1 , rtx op2 ) { rtx shift = gen_rtx_fmt_ee ( code , SImode , op1 , op2 ) ; rtx pat = ( ( shift4_operator ( shift , SImode ) ? gen_shift_si3 : gen_shift_si3_loop ) ( op0 , op1 , op2 , shift ) ) ;


<s> add_reg_br_prob_note ( jump , profile_probability :: very_unlikely ( ) ) ;


<s> return arc_predicate_delay_insns ( ) ;


<s> virtual unsigned int execute ( function * ) { return arc_predicate_delay_insns ( ) ;


<s> const_rtx dest = XEXP ( x , <NUM_LIT> ) ;

if ( REG_P ( dest ) && REGNO ( dest ) >= <NUM_LIT> && REGNO ( dest ) < <NUM_LIT> ) return <NUM_LIT> ;


<s> if ( ( reg = decode_reg_name_and_count ( opt -> arg , & nregs ) ) >= <NUM_LIT> ) for ( j = reg ; j < reg + nregs ; j ++ ) SET_HARD_REG_BIT ( overrideregs , j ) ; break ;


<s> gcc_assert ( ( offset & <NUM_LIT> ) == <NUM_LIT> ) ; if ( ! offset ) return NULL_RTX ;

return frame_move ( reg , plus_constant ( Pmode , reg , offset ) ) ;


<s> gcc_assert ( ( offset & <NUM_LIT> ) == <NUM_LIT> ) ; if ( ! offset ) return NULL_RTX ; return frame_move ( reg , plus_constant ( Pmode , reg , offset ) ) ;


<s> x = emit_insn ( x ) ; RTX_FRAME_RELATED_P ( x ) = <NUM_LIT> ; return x ;


<s> RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ;


<s> if ( ! addr || GET_CODE ( addr ) == PRE_DEC || GET_CODE ( addr ) == POST_INC || GET_CODE ( addr ) == PRE_MODIFY || GET_CODE ( addr ) == POST_MODIFY ) add_reg_note ( insn , REG_INC , reg ) ; return insn ;


<s> } else addr = gen_frame_mem ( GET_MODE ( reg ) , gen_rtx_POST_INC ( Pmode , stack_pointer_rtx ) ) ; insn = frame_move_inc ( reg , addr , stack_pointer_rtx , <NUM_LIT> ) ; add_reg_note ( insn , REG_CFA_RESTORE , reg ) ; if ( reg == hard_frame_pointer_rtx ) add_reg_note ( insn , REG_CFA_DEF_CFA , plus_constant ( Pmode , stack_pointer_rtx , GET_MODE_SIZE ( GET_MODE ( reg ) ) + offset ) ) ;

else add_reg_note ( insn , REG_CFA_ADJUST_CFA , gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , GET_MODE_SIZE ( GET_MODE ( reg ) ) + offset ) ) ) ;


<s> rtx tmp = plus_constant ( Pmode , stack_pointer_rtx , offset + GET_MODE_SIZE ( GET_MODE ( reg ) ) ) ; addr = gen_frame_mem ( GET_MODE ( reg ) , gen_rtx_POST_MODIFY ( Pmode , stack_pointer_rtx , tmp ) ) ; } else addr = gen_frame_mem ( GET_MODE ( reg ) , gen_rtx_POST_INC ( Pmode , stack_pointer_rtx ) ) ; insn = frame_move_inc ( reg , addr , stack_pointer_rtx , <NUM_LIT> ) ; add_reg_note ( insn , REG_CFA_RESTORE , reg ) ; if ( reg == hard_frame_pointer_rtx ) add_reg_note ( insn , REG_CFA_DEF_CFA , plus_constant ( Pmode , stack_pointer_rtx , GET_MODE_SIZE ( GET_MODE ( reg ) ) + offset ) ) ; else add_reg_note ( insn , REG_CFA_ADJUST_CFA , gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , GET_MODE_SIZE ( GET_MODE ( reg ) ) + offset ) ) ) ;

return GET_MODE_SIZE ( GET_MODE ( reg ) ) + offset ;


<s> rtx tmp = plus_constant ( Pmode , stack_pointer_rtx , offset - GET_MODE_SIZE ( GET_MODE ( reg ) ) ) ; addr = gen_frame_mem ( GET_MODE ( reg ) , gen_rtx_PRE_MODIFY ( Pmode , stack_pointer_rtx , tmp ) ) ; } else addr = gen_frame_mem ( GET_MODE ( reg ) , gen_rtx_PRE_DEC ( Pmode , stack_pointer_rtx ) ) ;

frame_move_inc ( addr , reg , stack_pointer_rtx , <NUM_LIT> ) ;


<s> static int frame_save_reg ( rtx reg , HOST_WIDE_INT offset ) { rtx addr ; if ( offset ) { rtx tmp = plus_constant ( Pmode , stack_pointer_rtx , offset - GET_MODE_SIZE ( GET_MODE ( reg ) ) ) ; addr = gen_frame_mem ( GET_MODE ( reg ) , gen_rtx_PRE_MODIFY ( Pmode , stack_pointer_rtx , tmp ) ) ; } else addr = gen_frame_mem ( GET_MODE ( reg ) , gen_rtx_PRE_DEC ( Pmode , stack_pointer_rtx ) ) ;


<s> return frame_add ( stack_pointer_rtx , offset ) ;


<s> static rtx frame_stack_add ( HOST_WIDE_INT offset ) {

return frame_add ( stack_pointer_rtx , offset ) ;


<s> virtual bool gate ( function * ) { return flag_delayed_branch ;


<s> return gen_rtx_REG ( SImode , TARGET_BIG_ENDIAN ? <NUM_LIT> : <NUM_LIT> ) ;


<s> rtx gen_acc2 ( void ) { return gen_rtx_REG ( SImode , TARGET_BIG_ENDIAN ? <NUM_LIT> : <NUM_LIT> ) ;


<s> if ( GET_CODE ( operands [ i ] ) == SUBREG ) { tmp = SUBREG_REG ( operands [ i ] ) ; gcc_assert ( GET_MODE ( operands [ i ] ) == GET_MODE ( tmp ) ) ; operands [ i ] = tmp ; } } if ( load && REGNO ( operands [ <NUM_LIT> ] ) == REGNO ( base ) ) return false ; if ( load && REGNO ( operands [ <NUM_LIT> ] ) == REGNO ( operands [ <NUM_LIT> ] ) ) return false ; if ( offsets [ <NUM_LIT> ] > offsets [ <NUM_LIT> ] ) { gap = offsets [ <NUM_LIT> ] - offsets [ <NUM_LIT> ] ; offset = offsets [ <NUM_LIT> ] ; std :: swap ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; std :: swap ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; } else { gap = offsets [ <NUM_LIT> ] - offsets [ <NUM_LIT> ] ; offset = offsets [ <NUM_LIT> ] ; }


<s> rtx cur_base , cur_offset , tmp ; rtx base = NULL_RTX ; for ( i = <NUM_LIT> ; i < nops ; i ++ ) { if ( ! mem_ok_for_ldd_std ( operands [ nops + i ] , & cur_base , & cur_offset ) ) return false ; if ( i == <NUM_LIT> ) base = cur_base ; else if ( REGNO ( base ) != REGNO ( cur_base ) ) return false ; offsets [ i ] = INTVAL ( cur_offset ) ; if ( GET_CODE ( operands [ i ] ) == SUBREG ) { tmp = SUBREG_REG ( operands [ i ] ) ; gcc_assert ( GET_MODE ( operands [ i ] ) == GET_MODE ( tmp ) ) ; operands [ i ] = tmp ; } } if ( load && REGNO ( operands [ <NUM_LIT> ] ) == REGNO ( base ) ) return false ;

if ( load && REGNO ( operands [ <NUM_LIT> ] ) == REGNO ( operands [ <NUM_LIT> ] ) ) return false ;


<s> case GEU : return ARC_CC_HS ; default : gcc_unreachable ( ) ; } case E_CC_ZNmode : switch ( GET_CODE ( comparison ) ) { case EQ : return ARC_CC_EQ ; case NE : return ARC_CC_NE ; case GE : return ARC_CC_P ; case LT : return ARC_CC_N ; case GT : return ARC_CC_PNZ ; default : gcc_unreachable ( ) ; } case E_CC_Zmode : switch ( GET_CODE ( comparison ) ) { case EQ : return ARC_CC_EQ ; case NE : return ARC_CC_NE ; default : gcc_unreachable ( ) ; } case E_CC_Cmode : switch ( GET_CODE ( comparison ) ) { case LTU : return ARC_CC_C ; case GEU : return ARC_CC_NC ; default : gcc_unreachable ( ) ; } case E_CC_FP_GTmode : if ( TARGET_ARGONAUT_SET && TARGET_SPFP ) switch ( GET_CODE ( comparison ) ) { case GT : return ARC_CC_N ; case UNLE : return ARC_CC_P ; default : gcc_unreachable ( ) ; } else switch ( GET_CODE ( comparison ) ) { case GT : return ARC_CC_HI ; case UNLE : return ARC_CC_LS ; default : gcc_unreachable ( ) ; } case E_CC_FP_GEmode : switch ( GET_CODE ( comparison ) ) { case GE : return ARC_CC_HS ; case UNLT : return ARC_CC_LO ; default : gcc_unreachable ( ) ; } case E_CC_FP_UNEQmode : switch ( GET_CODE ( comparison ) ) { case UNEQ : return ARC_CC_EQ ; case LTGT : return ARC_CC_NE ; default : gcc_unreachable ( ) ;


<s> case CONST : return get_symbol_alignment ( XEXP ( x , <NUM_LIT> ) ) ; case PLUS : gcc_assert ( CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) ) ; return get_symbol_alignment ( XEXP ( x , <NUM_LIT> ) ) ; default : return <NUM_LIT> ; } if ( decl ) align = DECL_ALIGN ( decl ) ;


<s> switch ( GET_CODE ( x ) ) { case SYMBOL_REF : decl = SYMBOL_REF_DECL ( x ) ; break ; case CONST : return get_symbol_alignment ( XEXP ( x , <NUM_LIT> ) ) ; case PLUS :

gcc_assert ( CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) ) ;


<s> else { emit_insn_before ( gen_addsi3 ( loop -> iter_reg , loop -> iter_reg , constm1_rtx ) , loop -> loop_end ) ; test = gen_rtx_NE ( VOIDmode , loop -> iter_reg , const0_rtx ) ; insn = emit_jump_insn_before ( gen_cbranchsi4 ( test , loop -> iter_reg , const0_rtx , loop -> start_label ) , loop -> loop_end ) ; } JUMP_LABEL ( insn ) = loop -> start_label ;

LABEL_NUSES ( loop -> start_label ) ++ ;


<s> last_insn = emit_insn_after ( gen_nopv ( ) , last_insn ) ; } add_reg_note ( last_insn , REG_SAVE_NOTE , GEN_INT ( <NUM_LIT> ) ) ; loop -> last_insn = last_insn ; iter_reg = loop -> iter_reg ; gcc_assert ( REG_P ( iter_reg ) ) ; entry_edge = NULL ; FOR_EACH_VEC_SAFE_ELT ( loop -> incoming , i , entry_edge ) if ( entry_edge -> flags & EDGE_FALLTHRU ) break ; if ( entry_edge == NULL ) { if ( dump_file ) fprintf ( dump_file , <STR_LIT> <STR_LIT> , loop -> loop_no ) ; return false ; } end_label = gen_label_rtx ( ) ; loop -> end_label = end_label ; entry_bb = entry_edge -> src ; start_sequence ( ) ; if ( need_fix ) { emit_insn ( gen_rtx_SET ( lp_reg , iter_reg ) ) ; SET_HARD_REG_BIT ( loop -> regs_set_in_loop , LP_COUNT ) ; iter_reg = lp_reg ; if ( dump_file ) { fprintf ( dump_file , <STR_LIT> , loop -> loop_no ) ; } } insn = emit_insn ( gen_arc_lp ( loop -> start_label , loop -> end_label ) ) ; seq = get_insns ( ) ; end_sequence ( ) ; entry_after = BB_END ( entry_bb ) ; if ( ! single_succ_p ( entry_bb ) || vec_safe_length ( loop -> incoming ) > <NUM_LIT> || ! entry_after ) { basic_block new_bb ; edge e ; edge_iterator ei ; emit_insn_before ( seq , BB_HEAD ( loop -> head ) ) ; seq = emit_label_before ( gen_label_rtx ( ) , seq ) ; new_bb = create_basic_block ( seq , insn , entry_bb ) ; FOR_EACH_EDGE ( e , ei , loop -> incoming ) { if ( ! ( e -> flags & EDGE_FALLTHRU ) ) redirect_edge_and_branch_force ( e , new_bb ) ; else redirect_edge_succ ( e , new_bb ) ; } make_edge ( new_bb , loop -> head , <NUM_LIT> ) ; } else { while ( DEBUG_INSN_P ( entry_after ) || ( NOTE_P ( entry_after ) && NOTE_KIND ( entry_after ) != NOTE_INSN_BASIC_BLOCK && NOTE_KIND ( entry_after ) != NOTE_INSN_CALL_ARG_LOCATION ) ) entry_after = NEXT_INSN ( entry_after ) ; entry_after = next_nonnote_insn_bb ( entry_after ) ;


<s> rtx reg ; if ( ! JUMP_P ( insn ) || recog_memoized ( insn ) != CODE_FOR_loop_end ) return NULL_RTX ; reg = SET_DEST ( XVECEXP ( PATTERN ( insn ) , <NUM_LIT> , <NUM_LIT> ) ) ; if ( ! REG_P ( reg ) ) return NULL_RTX ;


<s> if ( ! JUMP_P ( insn ) || recog_memoized ( insn ) != CODE_FOR_loop_end ) return NULL_RTX ; reg = SET_DEST ( XVECEXP ( PATTERN ( insn ) , <NUM_LIT> , <NUM_LIT> ) ) ;

if ( ! REG_P ( reg ) ) return NULL_RTX ;


<s> i = strlen ( cstr ) ; str = ( char * ) alloca ( i + <NUM_LIT> ) ; memcpy ( str , cstr , i + <NUM_LIT> ) ; blink = - <NUM_LIT> ; lpcount = - <NUM_LIT> ; dash = strchr ( str , '-' ) ; if ( ! dash ) { warning ( OPT_mirq_ctrl_saved_ , <STR_LIT> ) ; return ; } * dash = '\0' ; comma = strchr ( dash + <NUM_LIT> , ',' ) ; if ( comma ) * comma = '\0' ; first = decode_reg_name ( str ) ; if ( first != <NUM_LIT> ) { warning ( OPT_mirq_ctrl_saved_ , <STR_LIT> ) ; return ; } if ( ! strcmp ( dash + <NUM_LIT> , <STR_LIT> ) ) last = <NUM_LIT> ; else last = decode_reg_name ( dash + <NUM_LIT> ) ; if ( last < <NUM_LIT> ) { warning ( OPT_mirq_ctrl_saved_ , <STR_LIT> , dash + <NUM_LIT> ) ; return ; } if ( ! ( last & <NUM_LIT> ) ) { warning ( OPT_mirq_ctrl_saved_ , <STR_LIT> , dash + <NUM_LIT> ) ; return ; } * dash = '-' ; if ( first > last ) { warning ( OPT_mirq_ctrl_saved_ , <STR_LIT> , str , dash + <NUM_LIT> ) ; return ; } while ( comma ) { * comma = ',' ; str = comma + <NUM_LIT> ; comma = strchr ( str , ',' ) ; if ( comma ) * comma = '\0' ; xreg = decode_reg_name ( str ) ; switch ( xreg ) { case <NUM_LIT> : blink = <NUM_LIT> ; break ;


<s> if ( ! strcmp ( dash + <NUM_LIT> , <STR_LIT> ) ) last = <NUM_LIT> ; else last = decode_reg_name ( dash + <NUM_LIT> ) ; if ( last < <NUM_LIT> ) { warning ( OPT_mirq_ctrl_saved_ , <STR_LIT> , dash + <NUM_LIT> ) ; return ; } if ( ! ( last & <NUM_LIT> ) ) { warning ( OPT_mirq_ctrl_saved_ , <STR_LIT> , dash + <NUM_LIT> ) ; return ; } * dash = '-' ; if ( first > last ) { warning ( OPT_mirq_ctrl_saved_ , <STR_LIT> , str , dash + <NUM_LIT> ) ; return ; } while ( comma ) { * comma = ',' ; str = comma + <NUM_LIT> ; comma = strchr ( str , ',' ) ; if ( comma ) * comma = '\0' ; xreg = decode_reg_name ( str ) ; switch ( xreg ) { case <NUM_LIT> : blink = <NUM_LIT> ; break ; case <NUM_LIT> : lpcount = <NUM_LIT> ; break ; default : warning ( OPT_mirq_ctrl_saved_ , <STR_LIT> , str ) ;