<s> builtin_define ( <STR_LIT> ) ; def_or_undef_macro ( pfile , NAME , CONDITION ) ; builtin_define_with_int_value ( <STR_LIT> , arc_tp_regno ) ;


if ( TARGET_BIG_ENDIAN ) builtin_define ( <STR_LIT> ) ;


<s> builtin_assert ( <STR_LIT> ) ; builtin_assert ( <STR_LIT> ) ; builtin_define ( <STR_LIT> ) ; def_or_undef_macro ( pfile , NAME , CONDITION ) ; builtin_define_with_int_value ( <STR_LIT> , arc_tp_regno ) ;


<s> builtin_define ( <STR_LIT> ) ; def_or_undef_macro ( pfile , NAME , CONDITION ) ; builtin_define_with_int_value ( <STR_LIT> , arc_tp_regno ) ; builtin_define_with_int_value ( <STR_LIT> , arc_lpcwidth ) ; builtin_define ( TARGET_BIG_ENDIAN ? <STR_LIT> : <STR_LIT> ) ; if ( TARGET_BIG_ENDIAN ) builtin_define ( <STR_LIT> ) ; if ( TARGET_HARD_FLOAT ) { builtin_define ( <STR_LIT> ) ; builtin_define ( <STR_LIT> ) ; } else {


<s> if ( def_p ) cpp_define ( pfile , name ) ;


<s> static void def_or_undef_macro ( cpp_reader * pfile , const char * name , bool def_p ) { if ( def_p ) cpp_define ( pfile , name ) ;


<s> case PRE_INC : case PRE_DEC : case POST_INC : case POST_DEC : case PRE_MODIFY : case POST_MODIFY : return ! speed ; case LABEL_REF : case SYMBOL_REF : case CONST : if ( TARGET_NPS_CMEM && cmem_address ( addr , SImode ) ) return <NUM_LIT> ; return COSTS_N_INSNS ( <NUM_LIT> ) ; case PLUS : { rtx plus0 = XEXP ( addr , <NUM_LIT> ) ; 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> : ( arc_check_short_reg_p ( plus0 ) && satisfies_constraint_O ( plus1 ) ) ? <NUM_LIT> : <NUM_LIT> ) ; case REG : return ( speed < <NUM_LIT> ? <NUM_LIT> : ( arc_check_short_reg_p ( plus0 ) && arc_check_short_reg_p ( plus1 ) ) ? <NUM_LIT> : <NUM_LIT> ) ; case CONST : case SYMBOL_REF : case LABEL_REF : return COSTS_N_INSNS ( <NUM_LIT> ) ; default : break ;


<s> case LABEL_REF : case SYMBOL_REF : case CONST : if ( TARGET_NPS_CMEM && cmem_address ( addr , SImode ) ) return <NUM_LIT> ; return COSTS_N_INSNS ( <NUM_LIT> ) ; case PLUS : { rtx plus0 = XEXP ( addr , <NUM_LIT> ) ; 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 ;


<s> if ( TARGET_HS && ( arc_tune == ARC_TUNE_ARCHS4X_REL31A ) ) switch ( get_attr_type ( pred ) ) { case TYPE_STORE : switch ( get_attr_type ( succ ) ) { case TYPE_BRCC : case TYPE_BRCC_NO_DELAY_SLOT : case TYPE_LOOP_END : return <NUM_LIT> ; default : break ; } break ;


<s> if ( IN_RANGE ( REGNO ( op ) ^ <NUM_LIT> , <NUM_LIT> , <NUM_LIT> ) ) return true ;


<s> if ( ! REG_P ( op ) ) return false ; if ( IN_RANGE ( REGNO ( op ) ^ <NUM_LIT> , <NUM_LIT> , <NUM_LIT> ) ) return true ; return false ;


<s> if ( ARC_NAKED_P ( fn_type ) ) return ; size = arc_compute_frame_size ( ) ; size_to_deallocate = size ; first_offset = size - ( frame -> pretend_size + frame -> reg_size + frame -> extra_size ) ; if ( ! can_trust_sp_p ) gcc_assert ( arc_frame_pointer_needed ( ) ) ; if ( size ) emit_insn ( gen_blockage ( ) ) ; if ( ARC_INTERRUPT_P ( fn_type ) ) { size_to_deallocate -= arc_restore_callee_saves ( <NUM_LIT> , false , restore_fp , first_offset , size_to_deallocate ) ; restore_fp = false ; first_offset = <NUM_LIT> ; } if ( arc_must_save_register ( R58_REG , cfun , true ) ) { rtx insn ; rtx reg0 = gen_rtx_REG ( SImode , R0_REG ) ; rtx reg1 = gen_rtx_REG ( SImode , R1_REG ) ; size_to_deallocate -= pop_reg ( reg0 ) ; size_to_deallocate -= pop_reg ( reg1 ) ; insn = emit_insn ( gen_mulu64 ( reg0 , const1_rtx ) ) ; add_reg_note ( insn , REG_CFA_RESTORE , gen_rtx_REG ( SImode , R58_REG ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; emit_insn ( gen_arc600_stall ( ) ) ; insn = emit_insn ( gen_rtx_UNSPEC_VOLATILE ( VOIDmode , gen_rtvec ( <NUM_LIT> , reg1 , GEN_INT ( AUX_MULHI ) ) , VUNSPEC_ARC_SR ) ) ; add_reg_note ( insn , REG_CFA_RESTORE , gen_rtx_REG ( SImode , R59_REG ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } if ( arc_must_save_register ( TARGET_BIG_ENDIAN ? R41_REG : R40_REG , cfun , TARGET_DPFP ) ) { rtx reg0 = gen_rtx_REG ( SImode , R0_REG ) ; int i ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { size_to_deallocate -= pop_reg ( reg0 ) ; emit_insn ( gen_rtx_UNSPEC_VOLATILE ( VOIDmode , gen_rtvec ( <NUM_LIT> , reg0 , GEN_INT ( AUX_DPFP_START + i ) ) , VUNSPEC_ARC_SR ) ) ; } } if ( arc_lpcwidth != <NUM_LIT> && arc_must_save_register ( LP_COUNT , cfun , true ) ) { rtx reg0 = gen_rtx_REG ( SImode , R0_REG ) ; size_to_deallocate -= pop_reg ( reg0 ) ; emit_move_insn ( gen_rtx_REG ( SImode , LP_COUNT ) , reg0 ) ;


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


<s> int regno , indx , off , nregs ; rtx insn , reg , mem ; int frame_allocated = <NUM_LIT> ; for ( regno = start_reg ; regno <= end_reg && ( gmask & ( <NUM_LIT> << regno ) ) ; ) regno ++ ; end_reg = regno - <NUM_LIT> ; nregs = end_reg - start_reg + <NUM_LIT> ; nregs += save_blink ? <NUM_LIT> : <NUM_LIT> ; nregs += save_fp ? <NUM_LIT> : <NUM_LIT> ; if ( offset ) frame_stack_add ( offset ) ; 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 ) ; }


<s> 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 ) ; RTX_FRAME_RELATED_P ( XVECEXP ( insn , <NUM_LIT> , indx ++ ) ) = <NUM_LIT> ; save_fp = false ;


<s> case ARC_TUNE_ARCHS4X : case ARC_TUNE_ARCHS4XD : return <NUM_LIT> ; default : break ;


<s> next_cum = * get_cumulative_args ( args_so_far ) ; if ( ! TYPE_NO_NAMED_ARGS_STDARG_P ( TREE_TYPE ( current_function_decl ) ) ) arc_function_arg_advance ( pack_cumulative_args ( & next_cum ) , arg ) ; first_anon_arg = next_cum ; 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> ) ) ) ; move_block_from_reg ( first_reg_offset , regblock , MAX_ARC_PARM_REGS - first_reg_offset ) ; } * pretend_size = ( ( MAX_ARC_PARM_REGS - first_reg_offset ) * UNITS_PER_WORD ) ;


<s> } 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> ) ) ) { rtx addr = XEXP ( operands [ i ] , <NUM_LIT> ) ; rtx r , o ; enum rtx_code code ; gcc_assert ( ! reg_overlap_mentioned_p ( operands [ <NUM_LIT> ] , addr ) ) ; switch ( GET_CODE ( addr ) ) { case PRE_DEC : o = GEN_INT ( - <NUM_LIT> ) ; goto pre_modify ; case PRE_INC : o = GEN_INT ( <NUM_LIT> ) ; goto pre_modify ; case PRE_MODIFY : o = XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ; pre_modify : code = PRE_MODIFY ; break ; case POST_DEC : o = GEN_INT ( - <NUM_LIT> ) ; goto post_modify ; case POST_INC : o = GEN_INT ( <NUM_LIT> ) ; goto post_modify ; case POST_MODIFY : o = XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ; post_modify : code = POST_MODIFY ; swap = <NUM_LIT> ; break ; default : gcc_unreachable ( ) ; } r = XEXP ( addr , <NUM_LIT> ) ; xop [ <NUM_LIT> + i ] = adjust_automodify_address_nv ( operands [ i ] , SImode , gen_rtx_fmt_ee ( code , Pmode , r , gen_rtx_PLUS ( Pmode , r , o ) ) , <NUM_LIT> ) ; xop [ <NUM_LIT> + i ] = adjust_automodify_address_nv ( operands [ i ] , SImode , plus_constant ( Pmode , r , <NUM_LIT> ) , <NUM_LIT> ) ; } else { xop [ <NUM_LIT> + i ] = operand_subword ( operands [ i ] , <NUM_LIT> , <NUM_LIT> , mode ) ; xop [ <NUM_LIT> + i ] = operand_subword ( operands [ i ] , <NUM_LIT> , <NUM_LIT> , mode ) ; } } if ( reg_overlap_mentioned_p ( xop [ <NUM_LIT> ] , xop [ <NUM_LIT> ] ) ) { swap = <NUM_LIT> ;

gcc_assert ( ! reg_overlap_mentioned_p ( xop [ <NUM_LIT> ] , xop [ <NUM_LIT> ] ) ) ;


<s> 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> ) ) ) { rtx addr = XEXP ( operands [ i ] , <NUM_LIT> ) ; rtx r , o ; enum rtx_code code ; gcc_assert ( ! reg_overlap_mentioned_p ( operands [ <NUM_LIT> ] , addr ) ) ; switch ( GET_CODE ( addr ) ) { case PRE_DEC : o = GEN_INT ( - <NUM_LIT> ) ; goto pre_modify ; case PRE_INC : o = GEN_INT ( <NUM_LIT> ) ; goto pre_modify ; case PRE_MODIFY : o = XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ; pre_modify : code = PRE_MODIFY ; break ; case POST_DEC : o = GEN_INT ( - <NUM_LIT> ) ; goto post_modify ; case POST_INC : o = GEN_INT ( <NUM_LIT> ) ; goto post_modify ; case POST_MODIFY : o = XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ; post_modify : code = POST_MODIFY ; swap = <NUM_LIT> ; break ; default : gcc_unreachable ( ) ; } r = XEXP ( addr , <NUM_LIT> ) ; xop [ <NUM_LIT> + i ] = adjust_automodify_address_nv ( operands [ i ] , SImode , gen_rtx_fmt_ee ( code , Pmode , r , gen_rtx_PLUS ( Pmode , r , o ) ) , <NUM_LIT> ) ; xop [ <NUM_LIT> + i ] = adjust_automodify_address_nv ( operands [ i ] , SImode , plus_constant ( Pmode , r , <NUM_LIT> ) , <NUM_LIT> ) ; } else { xop [ <NUM_LIT> + i ] = operand_subword ( operands [ i ] , <NUM_LIT> , <NUM_LIT> , mode ) ;


<s> operands [ <NUM_LIT> ] = gen_rtx_PLUS ( SImode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; } else { operands [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; operands [ <NUM_LIT> ] = gen_rtx_PLUS ( SImode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ;


<s> operands [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; operands [ <NUM_LIT> ] = gen_rtx_PLUS ( SImode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; }


<s> operands [ <NUM_LIT> ] = gen_rtx_NEG ( SImode , operands [ <NUM_LIT> ] ) ; operands [ <NUM_LIT> ] = gen_rtx_PLUS ( SImode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; return ; } else if ( val >= <NUM_LIT> && val < <NUM_LIT> ) { operands [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; operands [ <NUM_LIT> ] = gen_rtx_MINUS ( SImode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; return ; }


<s> int val = INTVAL ( operands [ <NUM_LIT> ] ) ; if ( arc_check_short_reg_p ( operands [ <NUM_LIT> ] ) && arc_check_short_reg_p ( operands [ <NUM_LIT> ] ) ) { if ( val >= - <NUM_LIT> && val <= <NUM_LIT> ) { operands [ <NUM_LIT> ] = gen_rtx_NEG ( SImode , operands [ <NUM_LIT> ] ) ; operands [ <NUM_LIT> ] = gen_rtx_PLUS ( SImode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; return ; } else if ( val >= <NUM_LIT> && val < <NUM_LIT> ) { operands [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; operands [ <NUM_LIT> ] = gen_rtx_MINUS ( SImode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; return ; } } operands [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; operands [ <NUM_LIT> ] = gen_rtx_MINUS ( SImode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ;


<s> static void workaround_arc_anomaly ( void ) { rtx_insn * insn , * succ0 ; for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) { succ0 = next_real_insn ( insn ) ; if ( arc_hazard ( insn , succ0 ) || arc_check_release31a ( insn , succ0 ) ) emit_insn_before ( gen_nopv ( ) , succ0 ) ; } if ( ! TARGET_ARC700 ) return ;

if ( arc_tune != ARC_TUNE_ARC7XX ) check_store_cacheline_hazard ( ) ;


<s> if ( arc_hazard ( insn , succ0 ) || arc_check_release31a ( insn , succ0 ) ) emit_insn_before ( gen_nopv ( ) , succ0 ) ; } if ( ! TARGET_ARC700 ) return ;


<s> int arc_ccfsm_branch_deleted_p ( ) { if ( arc_ccfsm_state == <NUM_LIT> || arc_ccfsm_state == <NUM_LIT> ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> void arc_ccfsm_record_branch_deleted ( ) { arc_ccfsm_state += <NUM_LIT> ;


<s> if ( arc_compute_function_type ( current_function_decl ) != ARC_FUNCTION_NORMAL ) return <NUM_LIT> ; if ( ! current_frame_info . initialized ) ( void ) arc_compute_frame_size ( get_frame_size ( ) ) ;


<s> if ( arc_compute_function_type ( current_function_decl ) != ARC_FUNCTION_NORMAL ) return <NUM_LIT> ; if ( ! current_frame_info . initialized ) ( void ) arc_compute_frame_size ( get_frame_size ( ) ) ; if ( current_frame_info . total_size == <NUM_LIT> ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> arc_cpu_string = <STR_LIT> ; arc_cpu_type = <NUM_LIT> ; arc_mangle_cpu = NULL ; } arc_text_section = tmp = xmalloc ( strlen ( arc_text_string ) + sizeof ( ARC_SECTION_FORMAT ) + <NUM_LIT> ) ; sprintf ( tmp , ARC_SECTION_FORMAT , arc_text_string ) ; arc_data_section = tmp = xmalloc ( strlen ( arc_data_string ) + sizeof ( ARC_SECTION_FORMAT ) + <NUM_LIT> ) ; sprintf ( tmp , ARC_SECTION_FORMAT , arc_data_string ) ; arc_rodata_section = tmp = xmalloc ( strlen ( arc_rodata_string ) + sizeof ( ARC_SECTION_FORMAT ) + <NUM_LIT> ) ; sprintf ( tmp , ARC_SECTION_FORMAT , arc_rodata_string ) ; 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> ;


<s> case REG : return <NUM_LIT> ; case LABEL_REF : case SYMBOL_REF : case CONST : return <NUM_LIT> ; case PLUS : { register rtx plus0 = XEXP ( addr , <NUM_LIT> ) ; register rtx plus1 = XEXP ( addr , <NUM_LIT> ) ; if ( GET_CODE ( plus0 ) != REG ) break ; switch ( GET_CODE ( plus1 ) ) { case CONST_INT : return SMALL_INT ( plus1 ) ? <NUM_LIT> : <NUM_LIT> ; case CONST : case SYMBOL_REF : case LABEL_REF : return <NUM_LIT> ; default : break ;


<s> case PLUS : { register rtx plus0 = XEXP ( addr , <NUM_LIT> ) ; register rtx plus1 = XEXP ( addr , <NUM_LIT> ) ; if ( GET_CODE ( plus0 ) != REG ) break ; switch ( GET_CODE ( plus1 ) ) { case CONST_INT : return SMALL_INT ( plus1 ) ? <NUM_LIT> : <NUM_LIT> ; case CONST : case SYMBOL_REF : case LABEL_REF : return <NUM_LIT> ; default : break ; } break ; } default : break ; } return <NUM_LIT> ;


<s> if ( size == UNITS_PER_WORD && aligned_p && ( ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_FUNCTION_P ( x ) ) || GET_CODE ( x ) == LABEL_REF ) ) { fputs ( <STR_LIT> , asm_out_file ) ; output_addr_const ( asm_out_file , x ) ; fputs ( <STR_LIT> , asm_out_file ) ; return true ; } return default_assemble_integer ( x , size , aligned_p ) ;


<s> fputs ( <STR_LIT> , asm_out_file ) ; output_addr_const ( asm_out_file , x ) ; fputs ( <STR_LIT> , asm_out_file ) ; return true ; } return default_assemble_integer ( x , size , aligned_p ) ;


<s> void arc_ccfsm_at_label ( const char * prefix , int num ) { if ( arc_ccfsm_state == <NUM_LIT> && arc_ccfsm_target_label == num && ! strcmp ( prefix , <STR_LIT> ) ) { arc_ccfsm_state = <NUM_LIT> ; arc_ccfsm_target_insn = NULL_RTX ; }


<s> return fn_type ; } if ( decl == last_fn && fn_type != ARC_FUNCTION_UNKNOWN ) return fn_type ; fn_type = ARC_FUNCTION_NORMAL ; for ( a = DECL_ATTRIBUTES ( current_function_decl ) ; a ; a = TREE_CHAIN ( a ) ) { tree name = TREE_PURPOSE ( a ) , args = TREE_VALUE ( a ) ; if ( name == get_identifier ( <STR_LIT> ) && list_length ( args ) == <NUM_LIT> && TREE_CODE ( TREE_VALUE ( args ) ) == STRING_CST ) {


<s> if ( ! current_frame_info . initialized ) ( void ) arc_compute_frame_size ( get_frame_size ( ) ) ; if ( current_frame_info . total_size == <NUM_LIT> ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> HOST_WIDE_INT low , high ; gcc_assert ( GET_CODE ( value ) == CONST_DOUBLE ) ; 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> if ( get_attr_length ( trial ) == <NUM_LIT> && current_frame_info . gmask == <NUM_LIT> && ! reg_mentioned_p ( stack_pointer_rtx , PATTERN ( trial ) ) && ! reg_mentioned_p ( frame_pointer_rtx , PATTERN ( trial ) ) ) return <NUM_LIT> ;


<s> fprintf ( FILE , <STR_LIT> , XSTR ( SYMREF , <NUM_LIT> ) , XSTR ( SYMREF , <NUM_LIT> ) , arc_mangle_suffix ) ;


fprintf ( asm_out_file , <STR_LIT> , arc_cpu_string ) ;


<s> static void arc_file_start ( void ) { default_file_start ( ) ; fprintf ( asm_out_file , <STR_LIT> , arc_cpu_string ) ;


<s> int insns_skipped = <NUM_LIT> , fail = FALSE , succeed = FALSE ; int then_not_else = TRUE ; int next_must_be_target_label_p ; rtx this_insn = start_insn , label = <NUM_LIT> ; if ( reverse ) { if ( ! seeking_return ) label = XEXP ( SET_SRC ( body ) , <NUM_LIT> ) ; } else if ( GET_CODE ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) ) == LABEL_REF ) label = XEXP ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) , <NUM_LIT> ) ; else if ( GET_CODE ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) ) == LABEL_REF ) { label = XEXP ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) , <NUM_LIT> ) ; then_not_else = FALSE ; } else if ( GET_CODE ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) ) == RETURN ) seeking_return = <NUM_LIT> ; else if ( GET_CODE ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) ) == RETURN ) { seeking_return = <NUM_LIT> ; then_not_else = FALSE ; } else gcc_unreachable ( ) ; for ( insns_skipped = <NUM_LIT> , next_must_be_target_label_p = FALSE ; ! fail && ! succeed && insns_skipped < MAX_INSNS_SKIPPED ; insns_skipped ++ ) { rtx scanbody ; this_insn = next_nonnote_insn ( this_insn ) ; if ( ! this_insn ) break ; if ( next_must_be_target_label_p ) { if ( GET_CODE ( this_insn ) == BARRIER ) continue ; if ( GET_CODE ( this_insn ) == CODE_LABEL && this_insn == label ) { arc_ccfsm_state = <NUM_LIT> ; succeed = TRUE ; } else fail = TRUE ; break ; } scanbody = PATTERN ( this_insn ) ; switch ( GET_CODE ( this_insn ) ) { case CODE_LABEL : if ( this_insn == label ) { arc_ccfsm_state = <NUM_LIT> ; succeed = TRUE ; } else fail = TRUE ; break ; case BARRIER : next_must_be_target_label_p = TRUE ; break ; case CALL_INSN : if ( get_attr_cond ( this_insn ) == COND_CANUSE ) next_must_be_target_label_p = TRUE ; else fail = TRUE ; break ;


<s> case OPT_mcpu_ : return strcmp ( arg , <STR_LIT> ) == <NUM_LIT> || ARC_EXTENSION_CPU ( arg ) ;


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


<s> void arc_initialize_trampoline ( rtx tramp ATTRIBUTE_UNUSED , rtx fnaddr ATTRIBUTE_UNUSED , rtx cxt ATTRIBUTE_UNUSED ) {


<s> else if ( GET_MODE_SIZE ( i ) == <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) D_MODE ; else if ( GET_MODE_SIZE ( i ) == <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) T_MODE ; else if ( GET_MODE_SIZE ( i ) == <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 ( i ) <= <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) SF_MODE ; else if ( GET_MODE_SIZE ( i ) == <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) DF_MODE ; else if ( GET_MODE_SIZE ( i ) == <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) TF_MODE ; else if ( GET_MODE_SIZE ( i ) == <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) OF_MODE ; else arc_mode_class [ i ] = <NUM_LIT> ; break ; case MODE_CC : arc_mode_class [ i ] = <NUM_LIT> << ( int ) C_MODE ; break ; default :


<s> case MODE_COMPLEX_INT : if ( GET_MODE_SIZE ( i ) <= <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) S_MODE ; else if ( GET_MODE_SIZE ( i ) == <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) D_MODE ; else if ( GET_MODE_SIZE ( i ) == <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) T_MODE ; else if ( GET_MODE_SIZE ( i ) == <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 ( i ) <= <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) SF_MODE ; else if ( GET_MODE_SIZE ( i ) == <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) DF_MODE ; else if ( GET_MODE_SIZE ( i ) == <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) TF_MODE ; else if ( GET_MODE_SIZE ( i ) == <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) OF_MODE ; else arc_mode_class [ i ] = <NUM_LIT> ; break ; case MODE_CC : arc_mode_class [ i ] = <NUM_LIT> << ( int ) C_MODE ; break ; default : arc_mode_class [ i ] = <NUM_LIT> ;


<s> static void arc_internal_label ( FILE * stream , const char * prefix , unsigned long labelno ) {

arc_ccfsm_at_label ( prefix , labelno ) ;


<s> final_scan_insn ( XEXP ( epilogue_delay , <NUM_LIT> ) , file , <NUM_LIT> , <NUM_LIT> , NULL ) ; } } { static const int regs [ <NUM_LIT> ] = { <NUM_LIT> , RETURN_ADDR_REGNUM , ILINK1_REGNUM , ILINK2_REGNUM } ; if ( ARC_INTERRUPT_P ( fn_type ) ) fprintf ( file , <STR_LIT> , reg_names [ regs [ fn_type ] ] ) ; else fprintf ( file , <STR_LIT> , reg_names [ regs [ fn_type ] ] ) ; } if ( ARC_INTERRUPT_P ( fn_type ) ) fprintf ( file , <STR_LIT> , sp_str , sp_str ) ; else if ( epilogue_delay != NULL_RTX ) { gcc_assert ( ! frame_pointer_needed || fp_restored_p ) ; gcc_assert ( restored >= size ) ; final_scan_insn ( XEXP ( epilogue_delay , <NUM_LIT> ) , file , <NUM_LIT> , <NUM_LIT> , NULL ) ; } else if ( frame_pointer_needed && ! fp_restored_p ) { gcc_assert ( SMALL_INT ( frame_size ) ) ; fprintf ( file , <STR_LIT> , fp_str , sp_str , frame_size ) ; } else if ( restored < size ) { gcc_assert ( SMALL_INT ( size - restored ) ) ;

fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , sp_str , sp_str , size - restored ) ;


<s> fprintf ( file , <STR_LIT> , ASM_COMMENT_START , ASM_COMMENT_START , current_frame_info . var_size , current_frame_info . reg_size / <NUM_LIT> , current_frame_info . args_size , current_frame_info . extra_size ) ; size = ARC_STACK_ALIGN ( size ) ; size = ( ! current_frame_info . initialized ? arc_compute_frame_size ( size ) : current_frame_info . total_size ) ; gcc_assert ( size || ! gmask ) ; if ( current_frame_info . pretend_size != <NUM_LIT> ) fprintf ( file , <STR_LIT> , sp_str , sp_str , current_frame_info . pretend_size ) ; if ( MUST_SAVE_RETURN_ADDR ) fprintf ( file , <STR_LIT> , reg_names [ RETURN_ADDR_REGNUM ] , sp_str , UNITS_PER_WORD ) ; if ( frame_pointer_needed ) { fprintf ( file , <STR_LIT> , fp_str , sp_str ) ;


<s> fputs ( reg_names [ REGNO ( addr ) ] , file ) ; break ; case SYMBOL_REF : if ( <NUM_LIT> && SYMBOL_REF_FUNCTION_P ( addr ) ) { fprintf ( file , <STR_LIT> ) ; output_addr_const ( file , addr ) ; fprintf ( file , <STR_LIT> ) ; } else output_addr_const ( file , addr ) ; break ; case PLUS : if ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == CONST_INT ) offset = INTVAL ( XEXP ( addr , <NUM_LIT> ) ) , base = XEXP ( addr , <NUM_LIT> ) ; else if ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == CONST_INT ) offset = INTVAL ( XEXP ( addr , <NUM_LIT> ) ) , base = XEXP ( addr , <NUM_LIT> ) ; else base = XEXP ( addr , <NUM_LIT> ) , index = XEXP ( addr , <NUM_LIT> ) ; gcc_assert ( GET_CODE ( base ) == REG ) ; fputs ( reg_names [ REGNO ( base ) ] , file ) ;


<s> if ( AGGREGATE_TYPE_P ( type ) ) return true ; else { HOST_WIDE_INT size = int_size_in_bytes ( type ) ;

return ( size == - <NUM_LIT> || size > <NUM_LIT> ) ;


<s> if ( AGGREGATE_TYPE_P ( type ) ) return true ; else {

HOST_WIDE_INT size = int_size_in_bytes ( type ) ;


<s> * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case CONST_DOUBLE : { rtx high , low ; split_double ( x , & high , & low ) ; * total = COSTS_N_INSNS ( ! SMALL_INT ( INTVAL ( high ) ) + ! SMALL_INT ( INTVAL ( low ) ) ) ; return true ; } case ASHIFT : case ASHIFTRT :


<s> for ( regno = <NUM_LIT> ; regno <= <NUM_LIT> ; regno ++ ) { if ( ( gmask & ( <NUM_LIT> << regno ) ) != <NUM_LIT> ) { fprintf ( file , <STR_LIT> , op , reg_names [ regno ] , base_reg , offset ) ;


<s> if ( ( gmask & ( <NUM_LIT> << regno ) ) != <NUM_LIT> ) { fprintf ( file , <STR_LIT> , op , reg_names [ regno ] , base_reg , offset ) ;


<s> return CCZNmode ; case ASHIFT : case ASHIFTRT : case LSHIFTRT : return CCZNCmode ; default : break ; } } return CCmode ;


<s> int first_anon_arg ; gcc_assert ( mode != BLKmode ) ; first_anon_arg = * cum + ( ( GET_MODE_SIZE ( mode ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ) ; if ( first_anon_arg < MAX_ARC_PARM_REGS && ! no_rtl ) { int first_reg_offset = first_anon_arg ; int size = MAX_ARC_PARM_REGS - first_reg_offset ;


<s> void arc_va_start ( tree valist , rtx nextarg ) { if ( current_function_args_info < <NUM_LIT> && ( current_function_args_info & <NUM_LIT> ) ) nextarg = plus_constant ( nextarg , UNITS_PER_WORD ) ;

std_expand_builtin_va_start ( valist , nextarg ) ;


<s> return ( symbolic_operand ( op , mode ) || ( GET_CODE ( op ) == CONST_INT && LEGITIMATE_CONSTANT_P ( op ) ) || ( GET_CODE ( op ) == REG ) ) ;


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

if ( GET_CODE ( op ) != MEM ) return <NUM_LIT> ;


<s> if ( GET_CODE ( op ) != MEM ) return <NUM_LIT> ; op = XEXP ( op , <NUM_LIT> ) ; return call_address_operand ( op , mode ) ;


<s> return ( GET_CODE ( op ) == CONST_INT && ( INTVAL ( op ) >= ( - <NUM_LIT> - <NUM_LIT> ) && INTVAL ( op ) <= <NUM_LIT> ) ) ;


<s> return ( GET_CODE ( op ) == CONST_INT && ( INTVAL ( op ) >= <NUM_LIT> && INTVAL ( op ) <= <NUM_LIT> ) ) ;

return ( ( GET_CODE ( op ) == CONST_INT && INTVAL ( op ) >= <NUM_LIT> ) || ( GET_CODE ( op ) == CONST_DOUBLE && CONST_DOUBLE_HIGH ( op ) == <NUM_LIT> ) ) ;


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

return ( GET_CODE ( op ) == CONST_INT && ( INTVAL ( op ) >= <NUM_LIT> && INTVAL ( op ) <= <NUM_LIT> ) ) ;


<s> rtx cc_reg ; cc_reg = gen_rtx_REG ( mode , <NUM_LIT> ) ; emit_insn ( gen_rtx_SET ( VOIDmode , cc_reg , gen_rtx_COMPARE ( mode , x , y ) ) ) ;


<s> static int get_arc_condition_code ( rtx comparison ) { switch ( GET_CODE ( comparison ) ) { case EQ : return <NUM_LIT> ; case NE : return <NUM_LIT> ; case GT : return <NUM_LIT> ; case LE : return <NUM_LIT> ; case GE : return <NUM_LIT> ; case LT : return <NUM_LIT> ;


<s> case LEU : return <NUM_LIT> ; case LTU : return <NUM_LIT> ; case GEU : return <NUM_LIT> ; default : gcc_unreachable ( ) ; } return ( <NUM_LIT> ) ;


if ( GET_CODE ( op ) != PLUS || GET_MODE ( op ) != Pmode || ! register_operand ( XEXP ( op , <NUM_LIT> ) , Pmode ) || ! nonmemory_operand ( XEXP ( op , <NUM_LIT> ) , Pmode ) ) return <NUM_LIT> ;


<s> return <NUM_LIT> ; case CONST_INT : return <NUM_LIT> ; case CONST_DOUBLE : return <NUM_LIT> ; case REG : return <NUM_LIT> ; case PLUS : if ( GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == CONST_INT && ! SMALL_INT ( INTVAL ( XEXP ( op , <NUM_LIT> ) ) ) ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> int long_immediate_loadstore_operand ( rtx op , enum machine_mode mode ATTRIBUTE_UNUSED ) { if ( GET_CODE ( op ) != MEM ) return <NUM_LIT> ; op = XEXP ( op , <NUM_LIT> ) ; switch ( GET_CODE ( op ) ) { case SYMBOL_REF : case LABEL_REF : case CONST : return <NUM_LIT> ; case CONST_INT : return <NUM_LIT> ;


<s> int long_immediate_operand ( rtx op , enum machine_mode mode ATTRIBUTE_UNUSED ) { switch ( GET_CODE ( op ) ) { case SYMBOL_REF : case LABEL_REF : case CONST : return <NUM_LIT> ; case CONST_INT : return ! SMALL_INT ( INTVAL ( op ) ) ; case CONST_DOUBLE :


<s> else return register_operand ( op , mode ) ; case MEM : return address_operand ( XEXP ( op , <NUM_LIT> ) , mode ) ; default : return <NUM_LIT> ;


<s> if ( GET_CODE ( SUBREG_REG ( op ) ) == MEM ) return move_double_src_operand ( SUBREG_REG ( op ) , mode ) ; else return register_operand ( op , mode ) ; case MEM : if ( GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == PRE_DEC || GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == PRE_INC ) return <NUM_LIT> ; return address_operand ( XEXP ( op , <NUM_LIT> ) , mode ) ;


<s> case LABEL_REF : case CONST : return <NUM_LIT> ; case CONST_INT : return ( LARGE_INT ( INTVAL ( op ) ) ) ; case CONST_DOUBLE : if ( mode == SImode ) return arc_double_limm_p ( op ) ; if ( mode == SFmode ) return GET_MODE ( op ) == SFmode ; return <NUM_LIT> ; case REG : return register_operand ( op , mode ) ; case SUBREG : if ( GET_CODE ( SUBREG_REG ( op ) ) == MEM ) return address_operand ( XEXP ( SUBREG_REG ( op ) , <NUM_LIT> ) , mode ) ; else return register_operand ( op , mode ) ; case MEM : return address_operand ( XEXP ( op , <NUM_LIT> ) , mode ) ; default : return <NUM_LIT> ;


<s> case LABEL_REF : case CONST : return <NUM_LIT> ; case CONST_INT : return ( LARGE_INT ( INTVAL ( op ) ) ) ; case CONST_DOUBLE : if ( mode == SImode ) return arc_double_limm_p ( op ) ; if ( mode == SFmode ) return GET_MODE ( op ) == SFmode ; return <NUM_LIT> ; case REG : return register_operand ( op , mode ) ; case SUBREG : if ( GET_CODE ( SUBREG_REG ( op ) ) == MEM ) return address_operand ( XEXP ( SUBREG_REG ( op ) , <NUM_LIT> ) , mode ) ; else return register_operand ( op , mode ) ; case MEM : return address_operand ( XEXP ( op , <NUM_LIT> ) , mode ) ; default : return <NUM_LIT> ; }


<s> if ( GET_CODE ( op ) == MEM && MEM_VOLATILE_P ( op ) ) return <NUM_LIT> ; return nonimmediate_operand ( op , mode ) ;


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

if ( GET_CODE ( op ) == MEM && MEM_VOLATILE_P ( op ) ) return <NUM_LIT> ;


<s> output_asm_insn ( <STR_LIT> , operands ) ; } else output_asm_insn ( <STR_LIT> , operands ) ; goto shiftloop ; } else { int n = INTVAL ( operands [ <NUM_LIT> ] ) ; if ( n < <NUM_LIT> ) n = <NUM_LIT> ; else if ( n > GET_MODE_BITSIZE ( mode ) ) n = GET_MODE_BITSIZE ( mode ) ; if ( n <= <NUM_LIT> ) { while ( -- n >= <NUM_LIT> ) output_asm_insn ( shift_one , operands ) ; } else if ( n == BITS_PER_WORD - <NUM_LIT> ) { switch ( code ) { case ASHIFT : output_asm_insn ( <STR_LIT> , operands ) ; break ; case ASHIFTRT : output_asm_insn ( <STR_LIT> , operands ) ; break ; case LSHIFTRT : output_asm_insn ( <STR_LIT> , operands ) ; break ; default : break ; } } else { char buf [ <NUM_LIT> ] ; if ( optimize ) output_asm_insn ( <STR_LIT> , operands ) ; else output_asm_insn ( <STR_LIT> , operands ) ; shiftloop : if ( optimize ) { if ( flag_pic ) sprintf ( buf , <STR_LIT> , ASM_COMMENT_START ) ; else sprintf ( buf , <STR_LIT> , ASM_COMMENT_START ) ; output_asm_insn ( buf , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; if ( flag_pic ) fprintf ( asm_out_file , <STR_LIT> , ASM_COMMENT_START ) ; else fprintf ( asm_out_file , <STR_LIT> , ASM_COMMENT_START ) ; output_asm_insn ( shift_one , operands ) ; fprintf ( asm_out_file , <STR_LIT> , ASM_COMMENT_START ) ; } else { fprintf ( asm_out_file , <STR_LIT> , ASM_COMMENT_START ) ; output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( shift_one , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; fprintf ( asm_out_file , <STR_LIT> , ASM_COMMENT_START ) ; }


<s> if ( GET_MODE ( XEXP ( op , <NUM_LIT> ) ) == CCZNmode ) return ( code == EQ || code == NE ) ; if ( GET_MODE ( XEXP ( op , <NUM_LIT> ) ) == CCZNCmode ) return ( code == EQ || code == NE || code == LTU || code == GEU || code == GTU || code == LEU ) ;


<s> static void record_cc_ref ( rtx insn ) { last_insn_set_cc_p = current_insn_set_cc_p ; switch ( get_attr_cond ( insn ) ) { case COND_SET : case COND_SET_ZN :


<s> static void record_cc_ref ( rtx insn ) { last_insn_set_cc_p = current_insn_set_cc_p ; switch ( get_attr_cond ( insn ) ) { case COND_SET : case COND_SET_ZN : case COND_SET_ZNC : if ( get_attr_length ( insn ) == <NUM_LIT> ) current_insn_set_cc_p = <NUM_LIT> ; else current_insn_set_cc_p = <NUM_LIT> ;


<s> int short_immediate_operand ( rtx op , enum machine_mode mode ATTRIBUTE_UNUSED ) { if ( GET_CODE ( op ) != CONST_INT ) return <NUM_LIT> ;


if ( GET_CODE ( op ) != PLUS || GET_MODE ( op ) != Pmode || ! register_operand ( XEXP ( op , <NUM_LIT> ) , Pmode ) || ! ( GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == CONST_INT && SMALL_INT ( INTVAL ( XEXP ( op , <NUM_LIT> ) ) ) ) ) return <NUM_LIT> ;


<s> if ( GET_CODE ( op ) != PLUS || GET_MODE ( op ) != Pmode || ! register_operand ( XEXP ( op , <NUM_LIT> ) , Pmode ) || ! ( GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == CONST_INT && SMALL_INT ( INTVAL ( XEXP ( op , <NUM_LIT> ) ) ) ) ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> int symbolic_memory_operand ( rtx op , enum machine_mode mode ATTRIBUTE_UNUSED ) { if ( GET_CODE ( op ) == SUBREG ) op = SUBREG_REG ( op ) ; if ( GET_CODE ( op ) != MEM ) return <NUM_LIT> ; op = XEXP ( op , <NUM_LIT> ) ;

return ( GET_CODE ( op ) == SYMBOL_REF || GET_CODE ( op ) == CONST || GET_CODE ( op ) == LABEL_REF ) ;


<s> case LABEL_REF : case CONST : return <NUM_LIT> ; default : return <NUM_LIT> ; }


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


<s> case PLUS : { register rtx plus0 = XEXP ( addr , <NUM_LIT> ) ; register 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> ) ;


<s> rtx_insn * prev = prev_nonnote_insn ( insn ) ; return ( ( LABEL_P ( prev ) || ( TARGET_ARC600 && ( JUMP_P ( prev ) || CALL_P ( prev ) || ( NONJUMP_INSN_P ( prev ) && GET_CODE ( PATTERN ( prev ) ) == SEQUENCE ) ) ) ) ? len + <NUM_LIT> : len ) ; } if ( TARGET_PAD_RETURN && JUMP_P ( insn ) && GET_CODE ( PATTERN ( insn ) ) != ADDR_VEC && GET_CODE ( PATTERN ( insn ) ) != ADDR_DIFF_VEC && get_attr_type ( insn ) == TYPE_RETURN ) { rtx_insn * prev = prev_active_insn ( insn ) ; if ( ! prev || ! ( prev = prev_active_insn ( prev ) ) || ( ( NONJUMP_INSN_P ( prev ) && GET_CODE ( PATTERN ( prev ) ) == SEQUENCE ) ? CALL_ATTR ( as_a < rtx_sequence * > ( PATTERN ( prev ) ) -> insn ( <NUM_LIT> ) , NON_SIBCALL ) : CALL_ATTR ( prev , NON_SIBCALL ) ) ) return len + <NUM_LIT> ; } if ( TARGET_ARC600 ) { rtx_insn * succ = next_real_insn ( insn ) ; if ( succ && INSN_P ( succ ) ) len += arc600_corereg_hazard ( insn , succ ) ; }

extract_constrain_insn_cached ( insn ) ;


<s> if ( recog_memoized ( insn ) == CODE_FOR_doloop_end_i ) { rtx_insn * prev = prev_nonnote_insn ( insn ) ; return ( ( LABEL_P ( prev ) || ( TARGET_ARC600 && ( JUMP_P ( prev ) || CALL_P ( prev ) || ( NONJUMP_INSN_P ( prev ) && GET_CODE ( PATTERN ( prev ) ) == SEQUENCE ) ) ) ) ? len + <NUM_LIT> : len ) ; } if ( TARGET_PAD_RETURN && JUMP_P ( insn ) && GET_CODE ( PATTERN ( insn ) ) != ADDR_VEC && GET_CODE ( PATTERN ( insn ) ) != ADDR_DIFF_VEC && get_attr_type ( insn ) == TYPE_RETURN ) {

rtx_insn * prev = prev_active_insn ( insn ) ;


<s> static int arc_arg_partial_bytes ( cumulative_args_t cum_v , machine_mode mode , tree type , bool named ATTRIBUTE_UNUSED ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; int bytes = ( mode == BLKmode ? int_size_in_bytes ( type ) : ( int ) GET_MODE_SIZE ( mode ) ) ;

int words = ( bytes + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ;


<s> int words = ( bytes + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ; int arg_num = * cum ; int ret ; arg_num = ROUND_ADVANCE_CUM ( arg_num , mode , type ) ;


<s> int in_small_data = arc_in_small_data_p ( decl ) ; if ( in_small_data ) switch_to_section ( get_named_section ( NULL , <STR_LIT> , <NUM_LIT> ) ) ; else switch_to_section ( bss_section ) ; 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> int in_small_data = arc_in_small_data_p ( decl ) ; if ( in_small_data ) switch_to_section ( get_named_section ( NULL , <STR_LIT> , <NUM_LIT> ) ) ; else switch_to_section ( bss_section ) ; if ( globalize_p ) ( * targetm . asm_out . globalize_label ) ( stream , name ) ;

ASM_OUTPUT_ALIGN ( stream , floor_log2 ( ( align ) / BITS_PER_UNIT ) ) ;


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


<s> union { const rtx_insn * c ; rtx_insn * r ; } u ; u . c = follower ; if ( CROSSING_JUMP_P ( followee ) ) switch ( get_attr_type ( u . r ) ) { case TYPE_BRCC : case TYPE_BRCC_NO_DELAY_SLOT : return false ; default : return true ; } return true ;


<s> static bool arc_can_use_doloop_p ( const widest_int & iterations , const widest_int & , unsigned int loop_depth , bool entered_at_top ) { if ( loop_depth > <NUM_LIT> ) return false ;

if ( TARGET_ARC700 && ! entered_at_top && wi :: gtu_p ( iterations , <NUM_LIT> ) && wi :: leu_p ( iterations , flag_pic ? <NUM_LIT> : <NUM_LIT> ) ) return false ;


<s> if ( TARGET_ARC700 && ! entered_at_top && wi :: gtu_p ( iterations , <NUM_LIT> ) && wi :: leu_p ( iterations , flag_pic ? <NUM_LIT> : <NUM_LIT> ) ) return false ;


<s> 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> fn_type = ARC_FUNCTION_NORMAL ; for ( a = DECL_ATTRIBUTES ( decl ) ; a ; a = TREE_CHAIN ( a ) ) { tree name = TREE_PURPOSE ( a ) , args = TREE_VALUE ( a ) ; if ( name == get_identifier ( <STR_LIT> ) && list_length ( args ) == <NUM_LIT> && TREE_CODE ( TREE_VALUE ( args ) ) == STRING_CST ) { tree value = TREE_VALUE ( args ) ; if ( ! 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 gcc_unreachable ( ) ; break ; } }

return fun -> machine -> fn_type = fn_type ;


<s> fn_type = ARC_FUNCTION_NORMAL ; for ( a = DECL_ATTRIBUTES ( decl ) ; a ; a = TREE_CHAIN ( a ) ) { tree name = TREE_PURPOSE ( a ) , args = TREE_VALUE ( a ) ; if ( name == get_identifier ( <STR_LIT> ) && list_length ( args ) == <NUM_LIT> && TREE_CODE ( TREE_VALUE ( args ) ) == STRING_CST ) { tree value = TREE_VALUE ( args ) ; if ( ! 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 gcc_unreachable ( ) ; break ; } } return fun -> machine -> fn_type = fn_type ;


<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> static bool arc_decl_anon_ns_mem_p ( const_tree decl ) { while ( <NUM_LIT> ) { if ( decl == NULL_TREE || decl == error_mark_node ) return false ;

if ( TREE_CODE ( decl ) == NAMESPACE_DECL && DECL_NAME ( decl ) == NULL_TREE ) return true ;


<s> int arc_decl_pretend_args ( tree decl ) {

gcc_assert ( decl == current_function_decl ) ;


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


<s> } else if ( GET_CODE ( x ) == PLUS && ( ( REG_P ( gp = XEXP ( x , <NUM_LIT> ) ) && REGNO ( gp ) == PIC_OFFSET_TABLE_REGNUM ) || ( GET_CODE ( gp ) == CONST && GET_CODE ( u = XEXP ( gp , <NUM_LIT> ) ) == UNSPEC && XINT ( u , <NUM_LIT> ) == ARC_UNSPEC_GOT && GET_CODE ( XVECEXP ( u , <NUM_LIT> , <NUM_LIT> ) ) == SYMBOL_REF && ! strcmp ( XSTR ( XVECEXP ( u , <NUM_LIT> , <NUM_LIT> ) , <NUM_LIT> ) , <STR_LIT> ) ) ) && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST && GET_CODE ( u = XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == UNSPEC && XINT ( u , <NUM_LIT> ) == ARC_UNSPEC_GOTOFF ) return XVECEXP ( u , <NUM_LIT> , <NUM_LIT> ) ; else if ( GET_CODE ( x ) == PLUS && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS && ( ( REG_P ( gp = XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) && REGNO ( gp ) == PIC_OFFSET_TABLE_REGNUM ) || ( GET_CODE ( gp ) == CONST && GET_CODE ( u = XEXP ( gp , <NUM_LIT> ) ) == UNSPEC && XINT ( u , <NUM_LIT> ) == ARC_UNSPEC_GOT && GET_CODE ( XVECEXP ( u , <NUM_LIT> , <NUM_LIT> ) ) == SYMBOL_REF && ! strcmp ( XSTR ( XVECEXP ( u , <NUM_LIT> , <NUM_LIT> ) , <NUM_LIT> ) , <STR_LIT> ) ) ) && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST && GET_CODE ( u = XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == UNSPEC && XINT ( u , <NUM_LIT> ) == ARC_UNSPEC_GOTOFF ) return gen_rtx_PLUS ( GET_MODE ( x ) , XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) , XVECEXP ( u , <NUM_LIT> , <NUM_LIT> ) ) ;

else if ( GET_CODE ( x ) == PLUS && ( u = arc_delegitimize_address_0 ( XEXP ( x , <NUM_LIT> ) ) ) ) return gen_rtx_PLUS ( GET_MODE ( x ) , XEXP ( x , <NUM_LIT> ) , u ) ;


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


<s> if ( reload_completed ) { if ( ARC_INTERRUPT_P ( cfun -> machine -> fn_type ) ) { if ( ! fixed_regs [ regno ] ) return true ;

return regno == arc_return_address_regs [ cfun -> machine -> fn_type ] ;


<s> if ( sibthunk_p ) goto epilogue_done ; } if ( ( ! SMALL_INT ( first_offset ) && cfun -> machine -> frame_info . gmask && ( ( TARGET_ARC700 && ! optimize_size ) ? first_offset <= <NUM_LIT> : satisfies_constraint_C2a ( GEN_INT ( first_offset ) ) ) ) || ( MUST_SAVE_RETURN_ADDR && ! SMALL_INT ( ( cfun -> machine -> frame_info . reg_size + first_offset ) >> <NUM_LIT> ) && cfun -> machine -> frame_info . gmask ) ) { frame_stack_add ( first_offset ) ; first_offset = <NUM_LIT> ; } if ( MUST_SAVE_RETURN_ADDR ) { rtx ra = gen_rtx_REG ( Pmode , RETURN_ADDR_REGNUM ) ; int ra_offs = cfun -> machine -> frame_info . reg_size + first_offset ; rtx addr = plus_constant ( Pmode , stack_pointer_rtx , ra_offs ) ; if ( ! SMALL_INT ( ra_offs >> <NUM_LIT> ) && ! cfun -> machine -> frame_info . gmask && ( ( TARGET_ARC700 && ! optimize_size ) ? ra_offs <= <NUM_LIT> : satisfies_constraint_C2a ( GEN_INT ( ra_offs ) ) ) ) { size_to_deallocate -= ra_offs - first_offset ; first_offset = <NUM_LIT> ; frame_stack_add ( ra_offs ) ; ra_offs = <NUM_LIT> ; addr = stack_pointer_rtx ; } if ( ra_offs && ! cfun -> machine -> frame_info . gmask && ( SMALL_INT ( ra_offs ) || ! SMALL_INT ( ra_offs >> <NUM_LIT> ) ) ) { addr = gen_rtx_PRE_MODIFY ( Pmode , stack_pointer_rtx , addr ) ; first_offset = <NUM_LIT> ; size_to_deallocate -= cfun -> machine -> frame_info . reg_size ; } else if ( ! ra_offs && size_to_deallocate == UNITS_PER_WORD ) { addr = gen_rtx_POST_INC ( Pmode , addr ) ; size_to_deallocate = <NUM_LIT> ; }

frame_move_inc ( ra , gen_frame_mem ( Pmode , addr ) , stack_pointer_rtx , addr ) ;


<s> unsigned n_pieces ; int piece = align ; rtx store [ <NUM_LIT> ] ; rtx tmpx [ <NUM_LIT> ] ; int i ; if ( ! CONST_INT_P ( operands [ <NUM_LIT> ] ) ) return false ; size = INTVAL ( operands [ <NUM_LIT> ] ) ; if ( align >= <NUM_LIT> ) n_pieces = ( size + <NUM_LIT> ) / <NUM_LIT> + ( size & <NUM_LIT> ) ; else if ( align == <NUM_LIT> ) n_pieces = ( size + <NUM_LIT> ) / <NUM_LIT> ; else n_pieces = size ; if ( n_pieces >= ( unsigned int ) ( optimize_size ? <NUM_LIT> : <NUM_LIT> ) ) return false ; if ( piece > <NUM_LIT> ) piece = <NUM_LIT> ; dst_addr = force_offsettable ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) , size , <NUM_LIT> ) ; src_addr = force_offsettable ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) , size , <NUM_LIT> ) ; store [ <NUM_LIT> ] = store [ <NUM_LIT> ] = NULL_RTX ; tmpx [ <NUM_LIT> ] = tmpx [ <NUM_LIT> ] = NULL_RTX ; for ( i = <NUM_LIT> ; size > <NUM_LIT> ; i ^= <NUM_LIT> , size -= piece ) { rtx tmp ; machine_mode mode ; if ( piece > size ) piece = size & - size ; mode = smallest_mode_for_size ( piece * BITS_PER_UNIT , MODE_INT ) ; if ( <NUM_LIT> && tmpx [ i ] && GET_MODE ( tmpx [ i ] ) == mode ) tmp = tmpx [ i ] ; else tmpx [ i ] = tmp = gen_reg_rtx ( mode ) ; dst_addr = force_offsettable ( dst_addr , piece , <NUM_LIT> ) ; src_addr = force_offsettable ( src_addr , piece , <NUM_LIT> ) ; if ( store [ i ] ) emit_insn ( store [ i ] ) ; emit_move_insn ( tmp , change_address ( src , mode , src_addr ) ) ; store [ i ] = gen_move_insn ( change_address ( dst , mode , dst_addr ) , tmp ) ; dst_addr = plus_constant ( Pmode , dst_addr , piece ) ; src_addr = plus_constant ( Pmode , src_addr , piece ) ; } if ( store [ i ] ) emit_insn ( store [ i ] ) ; if ( store [ i ^ <NUM_LIT> ] ) emit_insn ( store [ i ^ <NUM_LIT> ] ) ;


<s> rtx dst = operands [ <NUM_LIT> ] ; rtx src = operands [ <NUM_LIT> ] ; rtx dst_addr , src_addr ; HOST_WIDE_INT size ; int align = INTVAL ( operands [ <NUM_LIT> ] ) ; unsigned n_pieces ; int piece = align ; rtx store [ <NUM_LIT> ] ; rtx tmpx [ <NUM_LIT> ] ; int i ; if ( ! CONST_INT_P ( operands [ <NUM_LIT> ] ) ) return false ; size = INTVAL ( operands [ <NUM_LIT> ] ) ; if ( align >= <NUM_LIT> ) n_pieces = ( size + <NUM_LIT> ) / <NUM_LIT> + ( size & <NUM_LIT> ) ; else if ( align == <NUM_LIT> ) n_pieces = ( size + <NUM_LIT> ) / <NUM_LIT> ; else n_pieces = size ; if ( n_pieces >= ( unsigned int ) ( optimize_size ? <NUM_LIT> : <NUM_LIT> ) ) return false ;

if ( piece > <NUM_LIT> ) piece = <NUM_LIT> ;


<s> unsigned int gmask = cfun -> machine -> frame_info . gmask ; unsigned int frame_size_to_allocate ; int first_offset = <NUM_LIT> ; size = ARC_STACK_ALIGN ( size ) ; size = ( ! cfun -> machine -> frame_info . initialized ? arc_compute_frame_size ( size ) : cfun -> machine -> frame_info . total_size ) ; if ( flag_stack_usage_info ) current_function_static_stack_size = size ; frame_size_to_allocate = size ; gcc_assert ( ! ( size == <NUM_LIT> && gmask ) ) ; if ( cfun -> machine -> frame_info . pretend_size != <NUM_LIT> ) { gcc_assert ( cfun -> machine -> frame_info . pretend_size <= <NUM_LIT> ) ; frame_stack_add ( - ( HOST_WIDE_INT ) cfun -> machine -> frame_info . pretend_size ) ; frame_size_to_allocate -= cfun -> machine -> frame_info . pretend_size ; } if ( MUST_SAVE_RETURN_ADDR ) { rtx ra = gen_rtx_REG ( SImode , RETURN_ADDR_REGNUM ) ; rtx mem = gen_frame_mem ( Pmode , gen_rtx_PRE_DEC ( Pmode , stack_pointer_rtx ) ) ; frame_move_inc ( mem , ra , stack_pointer_rtx , <NUM_LIT> ) ; frame_size_to_allocate -= UNITS_PER_WORD ; } if ( cfun -> machine -> frame_info . reg_size ) { first_offset = - cfun -> machine -> frame_info . reg_size ; arc_save_restore ( stack_pointer_rtx , gmask , <NUM_LIT> , & first_offset ) ; frame_size_to_allocate -= cfun -> machine -> frame_info . reg_size ; } if ( frame_pointer_needed ) {

rtx addr = gen_rtx_PLUS ( Pmode , stack_pointer_rtx , GEN_INT ( - UNITS_PER_WORD + first_offset ) ) ;


<s> pat = gen_rtx_SYMBOL_REF ( Pmode , <STR_LIT> ) ; pat = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , pat ) , ARC_UNSPEC_GOT ) ; pat = gen_rtx_CONST ( Pmode , pat ) ;

pat = gen_rtx_SET ( VOIDmode , baseptr_rtx , pat ) ;


<s> if ( PREV_INSN ( insn ) && PREV_INSN ( NEXT_INSN ( insn ) ) == insn && arc_hazard ( prev_real_insn ( insn ) , insn ) ) { current_output_insn = emit_insn_before ( gen_nop ( ) , NEXT_INSN ( PREV_INSN ( insn ) ) ) ; final_scan_insn ( current_output_insn , asm_out_file , optimize , <NUM_LIT> , NULL ) ;


<s> extract_constrain_insn_cached ( insn ) ; if ( ! cfun -> machine -> prescan_initialized ) { memset ( & arc_ccfsm_current , <NUM_LIT> , sizeof arc_ccfsm_current ) ; cfun -> machine -> prescan_initialized = <NUM_LIT> ; } arc_ccfsm_advance ( insn , & arc_ccfsm_current ) ; cfun -> machine -> size_reason = <NUM_LIT> ;


<s> static bool arc_frame_pointer_required ( void ) {


<s> const char * debstr ATTRIBUTE_UNUSED ; arg_num = ROUND_ADVANCE_CUM ( arg_num , mode , type ) ; if ( mode == VOIDmode ) { ret = const0_rtx ; debstr = <STR_LIT> ; } else if ( GPR_REST_ARG_REGS ( arg_num ) > <NUM_LIT> ) { ret = gen_rtx_REG ( mode , arg_num ) ; debstr = reg_names [ arg_num ] ; } else { ret = NULL_RTX ; debstr = <STR_LIT> ; }


<s> ret = const0_rtx ; debstr = <STR_LIT> ; } else if ( GPR_REST_ARG_REGS ( arg_num ) > <NUM_LIT> ) { ret = gen_rtx_REG ( mode , arg_num ) ; debstr = reg_names [ arg_num ] ; } else { ret = NULL_RTX ; debstr = <STR_LIT> ;


<s> int words = ( bytes + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ; int i ; if ( words ) * cum = ROUND_ADVANCE_CUM ( * cum , mode , type ) ; for ( i = <NUM_LIT> ; i < words ; i ++ ) * cum = ARC_NEXT_ARG_REG ( * cum ) ;


<s> static void arc_function_arg_advance ( cumulative_args_t cum_v , machine_mode mode , const_tree type , bool named ATTRIBUTE_UNUSED ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; int bytes = ( mode == BLKmode ? int_size_in_bytes ( type ) : ( int ) GET_MODE_SIZE ( mode ) ) ; int words = ( bytes + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ; int i ;

if ( words ) * cum = ROUND_ADVANCE_CUM ( * cum , mode , type ) ;


<s> if ( ARC_INTERRUPT_P ( arc_compute_function_type ( cfun ) ) ) return false ; return true ;


<s> static bool arc_function_ok_for_sibcall ( tree decl ATTRIBUTE_UNUSED , tree exp ATTRIBUTE_UNUSED ) { if ( ARC_INTERRUPT_P ( arc_compute_function_type ( cfun ) ) ) return false ; return true ;


<s> } else if ( strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) && strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) ) { warning ( OPT_Wattributes , <STR_LIT> , name ) ;


<s> if ( TREE_CODE ( value ) != STRING_CST ) { warning ( OPT_Wattributes , <STR_LIT> , name ) ; * no_add_attrs = true ; } else if ( 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 ( ! TARGET_ARC600 ) return <NUM_LIT> ; if ( ! pred || ! INSN_P ( pred ) || ! succ || ! INSN_P ( succ ) ) return <NUM_LIT> ; if ( recog_memoized ( succ ) == CODE_FOR_doloop_end_i && ( JUMP_P ( pred ) || CALL_P ( pred ) || GET_CODE ( PATTERN ( pred ) ) == SEQUENCE ) ) return <NUM_LIT> ; return arc600_corereg_hazard ( pred , succ ) ;


<s> const char * name = LABEL_NAME ( insn ) ; PUT_CODE ( insn , NOTE ) ; NOTE_KIND ( insn ) = NOTE_INSN_DELETED_LABEL ; NOTE_DELETED_LABEL_NAME ( insn ) = name ; } merge_bb = <NUM_LIT> ; 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 ( VOIDmode , 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 ) ; if ( GET_CODE ( next ) == BARRIER ) delete_insn ( next ) ; if ( statep -> state == <NUM_LIT> ) continue ; } break ;


<s> break ; } default : arc_multcost = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; } if ( TARGET_MUL64_SET && TARGET_ARC700 ) error ( <STR_LIT> ) ; if ( TARGET_NOMPY_SET && ! TARGET_ARC700 ) error ( <STR_LIT> ) ; if ( TARGET_MULMAC_32BY16_SET && ! ( TARGET_ARC600 || TARGET_ARC601 ) ) 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 || TARGET_ARC601 ) ) error ( <STR_LIT> ) ; if ( ( TARGET_DPFP || TARGET_SPFP ) && ! ( TARGET_ARC600 || TARGET_ARC601 || TARGET_ARC700 ) ) error ( <STR_LIT> ) ; if ( flag_pic && ! TARGET_ARC700 ) { warning ( DK_WARNING , <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> ; if ( optimize > <NUM_LIT> && ! TARGET_NO_COND_EXEC ) { opt_pass * pass_arc_ifcvt_4 = make_pass_arc_ifcvt ( g ) ; struct register_pass_info arc_ifcvt4_info = { pass_arc_ifcvt_4 , <STR_LIT> , <NUM_LIT> , PASS_POS_INSERT_AFTER } ; struct register_pass_info arc_ifcvt5_info = { pass_arc_ifcvt_4 -> clone ( ) , <STR_LIT> , <NUM_LIT> , PASS_POS_INSERT_BEFORE } ; register_pass ( & arc_ifcvt4_info ) ; register_pass ( & arc_ifcvt5_info ) ; } if ( flag_delayed_branch ) {

opt_pass * pass_arc_predicate_delay_insns = make_pass_arc_predicate_delay_insns ( g ) ;


<s> static void arc_initialize_trampoline ( rtx tramp , tree fndecl , rtx cxt ) { rtx fnaddr = XEXP ( DECL_RTL ( fndecl ) , <NUM_LIT> ) ; emit_store_direct ( tramp , <NUM_LIT> , TARGET_BIG_ENDIAN ? <NUM_LIT> : <NUM_LIT> ) ; emit_store_direct ( tramp , <NUM_LIT> , TARGET_BIG_ENDIAN ? <NUM_LIT> : <NUM_LIT> ) ; emit_store_direct ( tramp , <NUM_LIT> , TARGET_BIG_ENDIAN ? <NUM_LIT> : <NUM_LIT> ) ; emit_move_insn ( adjust_address ( tramp , SImode , <NUM_LIT> ) , fnaddr ) ; emit_move_insn ( adjust_address ( tramp , SImode , <NUM_LIT> ) , cxt ) ; emit_insn ( gen_flush_icache ( adjust_address ( tramp , SImode , <NUM_LIT> ) ) ) ;


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


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


<s> machine -> fn_type = ARC_FUNCTION_UNKNOWN ; machine -> force_short_suffix = - <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 ; machine -> force_short_suffix = - <NUM_LIT> ;


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


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


<s> static void arc_insn_length_parameters ( insn_length_parameters_t * ilp ) { ilp -> align_unit_log = <NUM_LIT> ; ilp -> align_base_log = <NUM_LIT> ; ilp -> max_variants = <NUM_LIT> ; ilp -> get_variants = arc_get_insn_variants ;


<s> name = DECL_SECTION_NAME ( decl ) ; if ( strcmp ( name , <STR_LIT> ) != <NUM_LIT> && strcmp ( name , <STR_LIT> ) != <NUM_LIT> ) return false ; if ( ! DECL_EXTERNAL ( decl ) ) return true ; } else if ( <NUM_LIT> ) { if ( TREE_CODE ( decl ) != VAR_DECL ) return false ; if ( TREE_READONLY ( decl ) && ! TREE_SIDE_EFFECTS ( decl ) && ( ! DECL_INITIAL ( decl ) || TREE_CONSTANT ( DECL_INITIAL ( decl ) ) ) ) return false ; if ( default_binds_local_p_1 ( decl , <NUM_LIT> ) || arc_decl_anon_ns_mem_p ( decl ) ) return false ;

if ( TREE_THIS_VOLATILE ( decl ) ) return false ;


<s> if ( prev && NONJUMP_INSN_P ( prev ) && GET_CODE ( PATTERN ( prev ) ) == PARALLEL && recog_memoized ( prev ) == CODE_FOR_doloop_begin_i ) return loop_align ; } if ( align_labels_log < <NUM_LIT> ) { rtx_insn * next = next_nonnote_nondebug_insn ( label ) ; if ( INSN_P ( next ) && recog_memoized ( next ) >= <NUM_LIT> ) return <NUM_LIT> ; }


<s> rtx_insn * prev = prev_nonnote_insn ( label ) ; if ( prev && NONJUMP_INSN_P ( prev ) && GET_CODE ( PATTERN ( prev ) ) == PARALLEL && recog_memoized ( prev ) == CODE_FOR_doloop_begin_i ) return loop_align ; } if ( align_labels_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_log ;


<s> 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 ) ) return true ; if ( GET_CODE ( x ) == CONST_INT && LARGE_INT ( INTVAL ( x ) ) ) return true ; if ( ( GET_MODE_SIZE ( mode ) != <NUM_LIT> ) && ( GET_CODE ( x ) == SYMBOL_REF || GET_CODE ( x ) == LABEL_REF || GET_CODE ( x ) == CONST ) ) { if ( ! flag_pic || arc_legitimate_pic_addr_p ( x ) ) return true ; } if ( ( GET_CODE ( x ) == PRE_DEC || GET_CODE ( x ) == PRE_INC || GET_CODE ( x ) == POST_DEC || GET_CODE ( x ) == POST_INC ) && RTX_OK_FOR_BASE_P ( XEXP ( x , <NUM_LIT> ) , strict ) ) return true ; if ( ( GET_CODE ( x ) == PRE_MODIFY || GET_CODE ( x ) == POST_MODIFY ) && GET_CODE ( XEXP ( ( x ) , <NUM_LIT> ) ) == PLUS && rtx_equal_p ( XEXP ( ( x ) , <NUM_LIT> ) , XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) && LEGITIMATE_OFFSET_ADDRESS_P ( QImode , XEXP ( x , <NUM_LIT> ) , TARGET_AUTO_MODIFY_REG , strict ) ) return true ;


<s> case ARC_UNSPEC_PLT : case ARC_UNSPEC_GOTOFF : case ARC_UNSPEC_GOT : case UNSPEC_PROF : return true ; default : gcc_unreachable ( ) ; } if ( arc_raw_symbolic_reference_mentioned_p ( x , false ) ) return false ; break ; case LABEL_REF : case SYMBOL_REF :


return ( GET_CODE ( addr ) == UNSPEC && XVECLEN ( addr , <NUM_LIT> ) == <NUM_LIT> && XINT ( addr , <NUM_LIT> ) == ARC_UNSPEC_GOT && GET_CODE ( XVECEXP ( addr , <NUM_LIT> , <NUM_LIT> ) ) == SYMBOL_REF ) ;


<s> } return ( GET_CODE ( addr ) == UNSPEC && XVECLEN ( addr , <NUM_LIT> ) == <NUM_LIT> && XINT ( addr , <NUM_LIT> ) == ARC_UNSPEC_GOT && GET_CODE ( XVECEXP ( addr , <NUM_LIT> , <NUM_LIT> ) ) == SYMBOL_REF ) ;


<s> return ! arc_raw_symbolic_reference_mentioned_p ( x , true ) ;


<s> if ( flag_pic && SYMBOLIC_CONST ( x ) ) ( x ) = arc_legitimize_pic_address ( x , <NUM_LIT> ) ; 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> ) ) ) ) { HOST_WIDE_INT offs , upper ; 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 ) ;


<s> if ( oldx == orig ) oldx = NULL ; if ( GET_CODE ( addr ) == LABEL_REF ) ; else if ( GET_CODE ( addr ) == SYMBOL_REF && ( CONSTANT_POOL_ADDRESS_P ( addr ) || SYMBOL_REF_LOCAL_P ( addr ) ) ) { crtl -> uses_pic_offset_table = <NUM_LIT> ; pat = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , addr ) , ARC_UNSPEC_GOTOFF ) ; pat = gen_rtx_CONST ( Pmode , pat ) ; pat = gen_rtx_PLUS ( Pmode , pic_offset_table_rtx , pat ) ; if ( oldx == NULL ) oldx = gen_reg_rtx ( Pmode ) ; if ( oldx != <NUM_LIT> ) { emit_move_insn ( oldx , pat ) ; pat = oldx ; } } else if ( GET_CODE ( addr ) == SYMBOL_REF ) { pat = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , addr ) , ARC_UNSPEC_GOT ) ; pat = gen_rtx_CONST ( Pmode , pat ) ; pat = gen_const_mem ( Pmode , pat ) ; if ( oldx == <NUM_LIT> ) oldx = gen_reg_rtx ( Pmode ) ; emit_move_insn ( oldx , pat ) ; pat = oldx ; } else { if ( GET_CODE ( addr ) == CONST ) { addr = XEXP ( addr , <NUM_LIT> ) ;


<s> if ( oldx == <NUM_LIT> ) oldx = gen_reg_rtx ( Pmode ) ; emit_move_insn ( oldx , pat ) ; pat = oldx ; } else { if ( GET_CODE ( addr ) == CONST ) { addr = XEXP ( addr , <NUM_LIT> ) ; if ( GET_CODE ( addr ) == UNSPEC ) { } else gcc_assert ( GET_CODE ( addr ) == PLUS ) ; } if ( GET_CODE ( addr ) == PLUS ) { rtx op0 = XEXP ( addr , <NUM_LIT> ) , op1 = XEXP ( addr , <NUM_LIT> ) ; if ( ( GET_CODE ( op0 ) == LABEL_REF || ( GET_CODE ( op0 ) == SYMBOL_REF && ( CONSTANT_POOL_ADDRESS_P ( op0 ) || SYMBOL_REF_LOCAL_P ( op0 ) ) ) ) && GET_CODE ( op1 ) == CONST_INT ) { crtl -> uses_pic_offset_table = <NUM_LIT> ; pat = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , op0 ) , ARC_UNSPEC_GOTOFF ) ; pat = gen_rtx_PLUS ( Pmode , pat , op1 ) ; pat = gen_rtx_CONST ( Pmode , pat ) ; pat = gen_rtx_PLUS ( Pmode , pic_offset_table_rtx , pat ) ; if ( oldx != <NUM_LIT> ) { emit_move_insn ( oldx , pat ) ; pat = oldx ; } } else { base = arc_legitimize_pic_address ( XEXP ( addr , <NUM_LIT> ) , oldx ) ; pat = arc_legitimize_pic_address ( XEXP ( addr , <NUM_LIT> ) , base == oldx ? NULL_RTX : oldx ) ; if ( GET_CODE ( pat ) == CONST_INT ) pat = plus_constant ( Pmode , base , INTVAL ( pat ) ) ; else { if ( GET_CODE ( pat ) == PLUS && CONSTANT_P ( XEXP ( pat , <NUM_LIT> ) ) ) { base = gen_rtx_PLUS ( Pmode , base , XEXP ( pat , <NUM_LIT> ) ) ; pat = XEXP ( pat , <NUM_LIT> ) ; } pat = gen_rtx_PLUS ( Pmode , base , pat ) ; } }


<s> rtx reg , sum , sum2 ; if ( scale > <NUM_LIT> ) scale = <NUM_LIT> ; if ( ( scale - <NUM_LIT> ) & offset ) scale = <NUM_LIT> ; shift = scale >> <NUM_LIT> ; offset_base = ( offset + ( <NUM_LIT> << shift ) ) & ( - <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 ; }


<s> shift = scale >> <NUM_LIT> ; offset_base = ( offset + ( <NUM_LIT> << shift ) ) & ( - <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 ;


<s> static bool arc_lra_p ( void ) { return ! TARGET_NO_LRA ;


<s> if ( GET_CODE ( addr ) == PLUS && ( GET_CODE ( XEXP ( ( addr ) , <NUM_LIT> ) ) == MULT || ( CONST_INT_P ( XEXP ( ( addr ) , <NUM_LIT> ) ) && ! SMALL_INT ( INTVAL ( XEXP ( ( addr ) , <NUM_LIT> ) ) ) ) ) ) return true ; return false ;


<s> static rtx_insn * arc_next_active_insn ( rtx_insn * insn , struct arc_ccfsm * statep ) { rtx pat ; do { if ( statep ) arc_ccfsm_post_advance ( insn , statep ) ; insn = NEXT_INSN ( insn ) ; if ( ! insn || BARRIER_P ( insn ) ) return NULL ; if ( statep ) arc_ccfsm_advance ( insn , statep ) ; } while ( NOTE_P ( insn ) || ( cfun -> machine -> arc_reorg_started && LABEL_P ( insn ) && ! label_to_alignment ( insn ) ) || ( NONJUMP_INSN_P ( insn ) && ( GET_CODE ( PATTERN ( insn ) ) == USE || GET_CODE ( PATTERN ( insn ) ) == CLOBBER ) ) ) ; if ( ! LABEL_P ( insn ) ) { gcc_assert ( INSN_P ( insn ) ) ; pat = PATTERN ( insn ) ; if ( GET_CODE ( pat ) == ADDR_VEC || GET_CODE ( pat ) == ADDR_DIFF_VEC ) return NULL ; if ( GET_CODE ( pat ) == SEQUENCE ) return as_a < rtx_insn * > ( XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ) ; } return insn ;


<s> do { if ( statep ) arc_ccfsm_post_advance ( insn , statep ) ; insn = NEXT_INSN ( insn ) ; if ( ! insn || BARRIER_P ( insn ) ) return NULL ; if ( statep ) arc_ccfsm_advance ( insn , statep ) ; } while ( NOTE_P ( insn ) || ( cfun -> machine -> arc_reorg_started && LABEL_P ( insn ) && ! label_to_alignment ( insn ) ) || ( NONJUMP_INSN_P ( insn ) && ( GET_CODE ( PATTERN ( insn ) ) == USE || GET_CODE ( PATTERN ( insn ) ) == CLOBBER ) ) ) ; if ( ! LABEL_P ( insn ) ) { gcc_assert ( INSN_P ( insn ) ) ; pat = PATTERN ( insn ) ; if ( GET_CODE ( pat ) == ADDR_VEC || GET_CODE ( pat ) == ADDR_DIFF_VEC ) return NULL ; if ( GET_CODE ( pat ) == SEQUENCE ) return as_a < rtx_insn * > ( XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ) ; }


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

if ( output_p ) \ output_asm_insn ( FORMAT , operands ) ; \ return ret ; \ }


<s> 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> if ( flag_pic ) sprintf ( buf , <STR_LIT> , fname ) ; else sprintf ( buf , <STR_LIT> , fname ) ; }


<s> while ( mi_delta != <NUM_LIT> ) { if ( ( mi_delta & ( <NUM_LIT> << shift ) ) == <NUM_LIT> ) shift += <NUM_LIT> ; else { asm_fprintf ( file , <STR_LIT> , mi_op , reg_names [ this_regno ] , reg_names [ this_regno ] , mi_delta & ( <NUM_LIT> << shift ) ) ; mi_delta &= ~ ( <NUM_LIT> << shift ) ; shift += <NUM_LIT> ; } } if ( vcall_offset != <NUM_LIT> ) { asm_fprintf ( file , <STR_LIT> , ARC_TEMP_SCRATCH_REG , reg_names [ this_regno ] ) ; asm_fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , ARC_TEMP_SCRATCH_REG , ARC_TEMP_SCRATCH_REG , vcall_offset ) ; 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> ) ;


<s> } else output_operand_lossage ( <STR_LIT> ) ; break ; case PLUS : if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) { arc_output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; fprintf ( file , <STR_LIT> ) ; arc_output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; } else if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) { arc_output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; 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 : gcc_assert ( XVECLEN ( x , <NUM_LIT> ) == <NUM_LIT> ) ; if ( XINT ( x , <NUM_LIT> ) == ARC_UNSPEC_GOT ) fputs ( <STR_LIT> , file ) ; arc_output_pic_addr_const ( file , XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) , code ) ; switch ( XINT ( x , <NUM_LIT> ) ) { case ARC_UNSPEC_GOT : fputs ( <STR_LIT> , file ) ; break ; case ARC_UNSPEC_GOTOFF : fputs ( <STR_LIT> , file ) ; break ; case ARC_UNSPEC_PLT : fputs ( <STR_LIT> , file ) ;


<s> case PC : if ( flag_pic ) putc ( '.' , file ) ; else gcc_unreachable ( ) ; break ; case SYMBOL_REF : output_addr_const ( file , x ) ; if ( code == 'P' && ! SYMBOL_REF_LOCAL_P ( x ) ) fputs ( <STR_LIT> , file ) ; break ; case LABEL_REF : ASM_GENERATE_INTERNAL_LABEL ( buf , <STR_LIT> , CODE_LABEL_NUMBER ( XEXP ( x , <NUM_LIT> ) ) ) ; assemble_name ( file , buf ) ; break ; case CODE_LABEL : ASM_GENERATE_INTERNAL_LABEL ( buf , <STR_LIT> , CODE_LABEL_NUMBER ( x ) ) ; assemble_name ( file , buf ) ; break ; case CONST_INT : fprintf ( file , HOST_WIDE_INT_PRINT_DEC , INTVAL ( x ) ) ; break ; case CONST : arc_output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; break ; case CONST_DOUBLE : if ( GET_MODE ( x ) == VOIDmode ) { if ( CONST_DOUBLE_HIGH ( x ) ) fprintf ( file , HOST_WIDE_INT_PRINT_DOUBLE_HEX , CONST_DOUBLE_HIGH ( x ) , CONST_DOUBLE_LOW ( x ) ) ; else if ( CONST_DOUBLE_LOW ( x ) < <NUM_LIT> ) fprintf ( file , HOST_WIDE_INT_PRINT_HEX , CONST_DOUBLE_LOW ( x ) ) ; else fprintf ( file , HOST_WIDE_INT_PRINT_DEC , CONST_DOUBLE_LOW ( x ) ) ; } else output_operand_lossage ( <STR_LIT> ) ; break ; case PLUS : if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) { arc_output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; fprintf ( file , <STR_LIT> ) ; arc_output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; } else if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) { arc_output_pic_addr_const ( file , XEXP ( x , <NUM_LIT> ) , code ) ; 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 ) ;


<s> want_long = <NUM_LIT> ; } if ( final_sequence && ! INSN_ANNULLED_BRANCH_P ( insn ) && ( get_attr_cond ( insn ) != COND_USE || ! reg_set_p ( gen_rtx_REG ( CCmode , CC_REG ) , XVECEXP ( final_sequence , <NUM_LIT> , <NUM_LIT> ) ) ) ) { prev = as_a < rtx_insn * > ( XVECEXP ( final_sequence , <NUM_LIT> , <NUM_LIT> ) ) ; gcc_assert ( ! prev_real_insn ( insn ) || ! arc_hazard ( prev_real_insn ( insn ) , prev ) ) ; cfun -> machine -> force_short_suffix = ! want_long ; rtx save_pred = current_insn_predicate ; final_scan_insn ( prev , asm_out_file , optimize , <NUM_LIT> , NULL ) ; cfun -> machine -> force_short_suffix = - <NUM_LIT> ; prev -> set_deleted ( ) ; current_output_insn = insn ; current_insn_predicate = save_pred ; }

else if ( want_long ) fputs ( <STR_LIT> , asm_out_file ) ;


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

if ( ( cl ) == CHEAP_CORE_REGS || ( cl ) == WRITABLE_CORE_REGS ) return GENERAL_REGS ;


<s> 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 ; case CONST : { rtx c = XEXP ( addr , <NUM_LIT> ) ; gcc_assert ( GET_CODE ( XEXP ( c , <NUM_LIT> ) ) == SYMBOL_REF ) ; gcc_assert ( GET_CODE ( XEXP ( c , <NUM_LIT> ) ) == CONST_INT ) ; output_address ( XEXP ( addr , <NUM_LIT> ) ) ; break ;


<s> rtx destHigh = simplify_gen_subreg ( SImode , dest , DFmode , <NUM_LIT> ) ; rtx destLow = simplify_gen_subreg ( SImode , dest , DFmode , <NUM_LIT> ) ; emit_insn ( gen_rtx_SET ( VOIDmode , destHigh , gen_rtx_UNSPEC_VOLATILE ( Pmode , gen_rtvec ( <NUM_LIT> , src ) , VUNSPEC_LR_HIGH ) ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , destLow , gen_rtx_UNSPEC_VOLATILE ( Pmode , gen_rtvec ( <NUM_LIT> , src ) , VUNSPEC_LR ) ) ) ; } } else if ( state == destDx ) { rtx srcHigh = simplify_gen_subreg ( SImode , src , DFmode , <NUM_LIT> ) ; rtx srcLow = simplify_gen_subreg ( SImode , src , DFmode , <NUM_LIT> ) ; emit_insn ( gen_rtx_UNSPEC_VOLATILE ( Pmode , gen_rtvec ( <NUM_LIT> , dest , srcHigh , srcLow ) , VUNSPEC_DEXCL_NORES ) ) ; } else gcc_unreachable ( ) ;


<s> if ( GET_CODE ( op ) == SYMBOL_REF ) { 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' ) { register 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 ;


<s> register const char * fmt ; register int i ; if ( GET_CODE ( op ) == UNSPEC ) return false ; if ( GET_CODE ( op ) == SYMBOL_REF ) { 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' ) { register 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> else if ( to_class == LPCOUNT_REG ) return <NUM_LIT> ; else if ( to_class == WRITABLE_CORE_REGS ) return <NUM_LIT> ; } if ( TARGET_ARC700 && ( from_class == LPCOUNT_REG || from_class == ALL_CORE_REGS || from_class == WRITABLE_CORE_REGS ) ) return <NUM_LIT> ;


<s> HOST_WIDE_INT size = int_size_in_bytes ( type ) ; return ( size == - <NUM_LIT> || size > <NUM_LIT> ) ; }


<s> struct arc_frame_info * afi = & cfun -> machine -> frame_info ;

return ( afi -> save_return_addr ? afi -> total_size - afi -> pretend_size - afi -> extra_size : - <NUM_LIT> ) ;


<s> int arc_return_slot_offset ( ) { struct arc_frame_info * afi = & cfun -> machine -> frame_info ; return ( afi -> save_return_addr ? afi -> total_size - afi -> pretend_size - afi -> extra_size : - <NUM_LIT> ) ;


<s> if ( loc != & op ) { if ( GET_CODE ( op ) == MEM && & XEXP ( op , <NUM_LIT> ) == loc ) ; else if ( GET_CODE ( op ) == MEM && GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) == MULT ) * loc = force_reg ( Pmode , * loc ) ;


<s> if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) x = XEXP ( x , <NUM_LIT> ) ; } return ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_SMALL_P ( x ) ) ;


if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) x = XEXP ( x , <NUM_LIT> ) ;


<s> * total = COSTS_N_INSNS ( INTVAL ( XEXP ( ( x ) , <NUM_LIT> ) ) ) ; if ( * total < <NUM_LIT> ) * total = <NUM_LIT> ; } return false ; case DIV : case UDIV : if ( speed ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return false ; case MULT : if ( ( TARGET_DPFP && GET_MODE ( x ) == DFmode ) ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( speed ) * total = arc_multcost ; else if ( TARGET_MUL64_SET || ( TARGET_ARC700 && ! TARGET_NOMPY_SET ) ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return false ; case PLUS : if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == MULT && _2_4_8_operand ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) , VOIDmode ) ) { * total += ( rtx_cost ( XEXP ( x , <NUM_LIT> ) , PLUS , <NUM_LIT> , speed ) + rtx_cost ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) , PLUS , <NUM_LIT> , speed ) ) ; return true ; } return false ; case MINUS : if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == MULT && _2_4_8_operand ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) , VOIDmode ) ) { * total += ( rtx_cost ( XEXP ( x , <NUM_LIT> ) , PLUS , <NUM_LIT> , speed ) + rtx_cost ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) , PLUS , <NUM_LIT> , speed ) ) ; return true ; } return false ; case COMPARE : { rtx op0 = XEXP ( x , <NUM_LIT> ) ; rtx op1 = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( op0 ) == ZERO_EXTRACT && op1 == const0_rtx && XEXP ( op0 , <NUM_LIT> ) == const1_rtx ) { * total = ( rtx_cost ( XEXP ( op0 , <NUM_LIT> ) , SET , <NUM_LIT> , speed ) + rtx_cost ( XEXP ( op0 , <NUM_LIT> ) , SET , <NUM_LIT> , speed ) ) ;


<s> rtx sibthunk_insn = NULL_RTX ; if ( gmask ) { if ( epilogue_p == <NUM_LIT> || frame -> millicode_end_reg > <NUM_LIT> ) { int start_call = frame -> millicode_start_reg ; int end_call = frame -> millicode_end_reg ; int n_regs = end_call - start_call + <NUM_LIT> ; int i = <NUM_LIT> , r , off = <NUM_LIT> ; rtx insn ; rtx ret_addr = gen_rtx_REG ( Pmode , RETURN_ADDR_REGNUM ) ; if ( * first_offset ) { gcc_assert ( epilogue_p || abs ( * first_offset ) <= <NUM_LIT> ) ; frame_add ( base_reg , * first_offset ) ; * first_offset = <NUM_LIT> ; } insn = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( ( epilogue_p == <NUM_LIT> ) + n_regs + <NUM_LIT> ) ) ; if ( epilogue_p == <NUM_LIT> ) i += <NUM_LIT> ; else XVECEXP ( insn , <NUM_LIT> , n_regs ) = gen_rtx_CLOBBER ( VOIDmode , ret_addr ) ; for ( r = start_call ; r <= end_call ; r ++ , off += UNITS_PER_WORD , i ++ ) { rtx reg = gen_rtx_REG ( SImode , r ) ; rtx mem = gen_frame_mem ( SImode , plus_constant ( Pmode , base_reg , off ) ) ; if ( epilogue_p ) XVECEXP ( insn , <NUM_LIT> , i ) = gen_rtx_SET ( VOIDmode , reg , mem ) ; else XVECEXP ( insn , <NUM_LIT> , i ) = gen_rtx_SET ( VOIDmode , mem , reg ) ; gmask = gmask & ~ ( <NUM_LIT> << r ) ; } if ( epilogue_p == <NUM_LIT> ) sibthunk_insn = insn ; else frame_insn ( insn ) ; offset += off ; } for ( regno = <NUM_LIT> ; regno <= <NUM_LIT> ; regno ++ ) { if ( ( gmask & ( <NUM_LIT> << regno ) ) != <NUM_LIT> ) { rtx reg = gen_rtx_REG ( SImode , regno ) ; rtx addr , mem ; if ( * first_offset ) { gcc_assert ( ! offset ) ; addr = plus_constant ( Pmode , base_reg , * first_offset ) ; addr = gen_rtx_PRE_MODIFY ( Pmode , base_reg , addr ) ; * first_offset = <NUM_LIT> ; } else {


<s> if ( * first_offset ) { gcc_assert ( epilogue_p || abs ( * first_offset ) <= <NUM_LIT> ) ; frame_add ( base_reg , * first_offset ) ; * first_offset = <NUM_LIT> ; } insn = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( ( epilogue_p == <NUM_LIT> ) + n_regs + <NUM_LIT> ) ) ; if ( epilogue_p == <NUM_LIT> ) i += <NUM_LIT> ; else XVECEXP ( insn , <NUM_LIT> , n_regs ) = gen_rtx_CLOBBER ( VOIDmode , ret_addr ) ; for ( r = start_call ; r <= end_call ; r ++ , off += UNITS_PER_WORD , i ++ ) { rtx reg = gen_rtx_REG ( SImode , r ) ; rtx mem = gen_frame_mem ( SImode , plus_constant ( Pmode , base_reg , off ) ) ; if ( epilogue_p ) XVECEXP ( insn , <NUM_LIT> , i ) = gen_rtx_SET ( VOIDmode , reg , mem ) ; else XVECEXP ( insn , <NUM_LIT> , i ) = gen_rtx_SET ( VOIDmode , mem , reg ) ; gmask = gmask & ~ ( <NUM_LIT> << r ) ; } if ( epilogue_p == <NUM_LIT> ) sibthunk_insn = insn ; else frame_insn ( insn ) ; offset += off ; } for ( regno = <NUM_LIT> ; regno <= <NUM_LIT> ; regno ++ ) { if ( ( gmask & ( <NUM_LIT> << regno ) ) != <NUM_LIT> ) { rtx reg = gen_rtx_REG ( SImode , regno ) ; rtx addr , mem ; if ( * first_offset ) { gcc_assert ( ! offset ) ; addr = plus_constant ( Pmode , base_reg , * first_offset ) ; addr = gen_rtx_PRE_MODIFY ( Pmode , base_reg , addr ) ; * first_offset = <NUM_LIT> ; } else {


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


<s> next_cum = * get_cumulative_args ( args_so_far ) ; arc_function_arg_advance ( pack_cumulative_args ( & next_cum ) , mode , type , <NUM_LIT> ) ; first_anon_arg = next_cum ; if ( first_anon_arg < MAX_ARC_PARM_REGS ) { int first_reg_offset = first_anon_arg ;


<s> if ( ! no_rtl ) { rtx regblock = gen_rtx_MEM ( BLKmode , plus_constant ( Pmode , arg_pointer_rtx , FIRST_PARM_OFFSET ( <NUM_LIT> ) ) ) ; move_block_from_reg ( first_reg_offset , regblock , MAX_ARC_PARM_REGS - first_reg_offset ) ; } * pretend_size = ( ( MAX_ARC_PARM_REGS - first_reg_offset ) * UNITS_PER_WORD ) ; }


<s> void arc_set_default_type_attributes ( tree type ATTRIBUTE_UNUSED ) { gcc_unreachable ( ) ;


<s> case POST_MODIFY : o = XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ; post_modify : code = POST_MODIFY ; swap = <NUM_LIT> ; break ; default : gcc_unreachable ( ) ; } r = XEXP ( addr , <NUM_LIT> ) ; xop [ <NUM_LIT> + i ] = adjust_automodify_address_nv ( operands [ i ] , SImode , gen_rtx_fmt_ee ( code , Pmode , r , gen_rtx_PLUS ( Pmode , r , o ) ) , <NUM_LIT> ) ; xop [ <NUM_LIT> + i ] = adjust_automodify_address_nv ( operands [ i ] , SImode , plus_constant ( Pmode , r , <NUM_LIT> ) , <NUM_LIT> ) ; } else { xop [ <NUM_LIT> + i ] = operand_subword ( operands [ i ] , <NUM_LIT> , <NUM_LIT> , mode ) ; xop [ <NUM_LIT> + i ] = operand_subword ( operands [ i ] , <NUM_LIT> , <NUM_LIT> , mode ) ; } } if ( reg_overlap_mentioned_p ( xop [ <NUM_LIT> ] , xop [ <NUM_LIT> ] ) ) { swap = <NUM_LIT> ; gcc_assert ( ! reg_overlap_mentioned_p ( xop [ <NUM_LIT> ] , xop [ <NUM_LIT> ] ) ) ; } operands [ <NUM_LIT> + swap ] = xop [ <NUM_LIT> ] ; operands [ <NUM_LIT> + swap ] = xop [ <NUM_LIT> ] ; operands [ <NUM_LIT> - swap ] = xop [ <NUM_LIT> ] ; operands [ <NUM_LIT> - swap ] = xop [ <NUM_LIT> ] ; start_sequence ( ) ; emit_insn ( gen_rtx_SET ( VOIDmode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ;


<s> enum rtx_code code ; gcc_assert ( ! reg_overlap_mentioned_p ( operands [ <NUM_LIT> ] , addr ) ) ; switch ( GET_CODE ( addr ) ) { case PRE_DEC : o = GEN_INT ( - <NUM_LIT> ) ; goto pre_modify ; case PRE_INC : o = GEN_INT ( <NUM_LIT> ) ; goto pre_modify ; case PRE_MODIFY : o = XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ; pre_modify : code = PRE_MODIFY ; break ; case POST_DEC : o = GEN_INT ( - <NUM_LIT> ) ; goto post_modify ; case POST_INC : o = GEN_INT ( <NUM_LIT> ) ; goto post_modify ; case POST_MODIFY : o = XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ; post_modify : code = POST_MODIFY ; swap = <NUM_LIT> ; break ; default : gcc_unreachable ( ) ; } r = XEXP ( addr , <NUM_LIT> ) ; xop [ <NUM_LIT> + i ] = adjust_automodify_address_nv ( operands [ i ] , SImode , gen_rtx_fmt_ee ( code , Pmode , r , gen_rtx_PLUS ( Pmode , r , o ) ) , <NUM_LIT> ) ; xop [ <NUM_LIT> + i ] = adjust_automodify_address_nv ( operands [ i ] , SImode , plus_constant ( Pmode , r , <NUM_LIT> ) , <NUM_LIT> ) ; } else { xop [ <NUM_LIT> + i ] = operand_subword ( operands [ i ] , <NUM_LIT> , <NUM_LIT> , mode ) ; xop [ <NUM_LIT> + i ] = operand_subword ( operands [ i ] , <NUM_LIT> , <NUM_LIT> , mode ) ; } } if ( reg_overlap_mentioned_p ( xop [ <NUM_LIT> ] , xop [ <NUM_LIT> ] ) ) { swap = <NUM_LIT> ; gcc_assert ( ! reg_overlap_mentioned_p ( xop [ <NUM_LIT> ] , xop [ <NUM_LIT> ] ) ) ; } operands [ <NUM_LIT> + swap ] = xop [ <NUM_LIT> ] ; operands [ <NUM_LIT> + swap ] = xop [ <NUM_LIT> ] ; operands [ <NUM_LIT> - swap ] = xop [ <NUM_LIT> ] ; operands [ <NUM_LIT> - swap ] = xop [ <NUM_LIT> ] ; start_sequence ( ) ; emit_insn ( gen_rtx_SET ( VOIDmode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; val = get_insns ( ) ; end_sequence ( ) ; return val ;


<s> return plus_constant ( Pmode , addr , <NUM_LIT> ) ;


<s> static rtx arc_trampoline_adjust_address ( rtx addr ) {

return plus_constant ( Pmode , addr , <NUM_LIT> ) ;


<s> enum attr_iscompact iscompact ; struct machine_function * machine ; if ( check_attr > <NUM_LIT> ) { iscompact = get_attr_iscompact ( insn ) ;

if ( iscompact == ISCOMPACT_FALSE ) return <NUM_LIT> ;


<s> int branch_dest ( rtx branch ) { rtx pat = PATTERN ( branch ) ;

rtx dest = ( GET_CODE ( pat ) == PARALLEL ? SET_SRC ( XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ) : SET_SRC ( pat ) ) ;


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


<s> bool check_if_valid_regno_const ( rtx * operands , int opno ) { switch ( GET_CODE ( operands [ opno ] ) ) {


<s> switch ( GET_CODE ( operands [ opno ] ) ) { case SYMBOL_REF : case CONST : case CONST_INT :


<s> case CONST : case CONST_INT : if ( UNSIGNED_INT6 ( INTVAL ( operands [ opno ] ) ) ) return true ; default :


<s> rtx addr ; int size ; if ( GET_CODE ( op ) != MEM ) return false ; if ( mode == VOIDmode ) mode = GET_MODE ( op ) ;


<s> size = GET_MODE_SIZE ( mode ) ; if ( size > UNITS_PER_WORD ) return false ; addr = XEXP ( op , <NUM_LIT> ) ; return LEGITIMATE_SMALL_DATA_ADDRESS_P ( addr ) ;


<s> 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 ( VOIDmode , dst , gen_rtx_fmt_ee ( GET_CODE ( src ) , GET_MODE ( src ) , src1 , src0 ) ) ; } } if ( RTX_FRAME_RELATED_P ( insn ) ) {


<s> void emit_pic_move ( rtx * operands , machine_mode ) { rtx temp = reload_in_progress ? operands [ <NUM_LIT> ] : gen_reg_rtx ( Pmode ) ;

if ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM && SYMBOLIC_CONST ( operands [ <NUM_LIT> ] ) ) operands [ <NUM_LIT> ] = force_reg ( Pmode , operands [ <NUM_LIT> ] ) ;


<s> rtx temp = reload_in_progress ? operands [ <NUM_LIT> ] : gen_reg_rtx ( Pmode ) ; if ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM && SYMBOLIC_CONST ( operands [ <NUM_LIT> ] ) ) operands [ <NUM_LIT> ] = force_reg ( Pmode , operands [ <NUM_LIT> ] ) ;

else operands [ <NUM_LIT> ] = arc_legitimize_pic_address ( operands [ <NUM_LIT> ] , temp ) ;


<s> static void emit_store_direct ( rtx block , int offset , int value ) {

emit_insn ( gen_store_direct ( adjust_address ( block , SImode , offset ) , force_reg ( SImode , gen_int_mode ( value , SImode ) ) ) ) ;


<s> } if ( ! REG_P ( base ) || ( REGNO ( base ) != STACK_POINTER_REGNUM && REGNO_PTR_FRAME_P ( REGNO ( addr ) ) ) || ! CONST_INT_P ( offs ) || ! SMALL_INT ( INTVAL ( offs ) ) || ! SMALL_INT ( INTVAL ( offs ) + size ) ) { if ( reuse ) emit_insn ( gen_add2_insn ( addr , offs ) ) ; else addr = copy_to_mode_reg ( Pmode , addr ) ;


<s> FOR_EACH_SUBRTX ( iter , array , op , ALL ) {


<s> if ( ! register_operand ( x , SImode ) ) { if ( register_operand ( y , SImode ) ) { tmp = x ; x = y ; y = tmp ; code = swap_condition ( code ) ; } else x = copy_to_mode_reg ( SImode , x ) ; } if ( GET_CODE ( y ) == SYMBOL_REF && flag_pic ) y = copy_to_mode_reg ( SImode , y ) ; } else { x = force_reg ( cmode , x ) ; y = force_reg ( cmode , y ) ; } mode = SELECT_CC_MODE ( code , x , y ) ; cc_reg = gen_rtx_REG ( mode , CC_REG ) ; if ( TARGET_ARGONAUT_SET && ( ( cmode == SFmode && TARGET_SPFP ) || ( cmode == DFmode && TARGET_DPFP ) ) ) { switch ( code ) { case NE : case EQ : case LT : case UNGE : case LE : case UNGT : case UNEQ : case LTGT : case ORDERED : case UNORDERED : break ; case GT : case UNLE : case GE : case UNLT : code = swap_condition ( code ) ; tmp = x ; x = y ; y = tmp ; break ; default : gcc_unreachable ( ) ; } if ( cmode == SFmode ) { emit_insn ( gen_cmpsfpx_raw ( x , y ) ) ; } else { emit_insn ( gen_cmpdfpx_raw ( x , y ) ) ; } if ( mode != CC_FPXmode ) emit_insn ( gen_rtx_SET ( VOIDmode , cc_reg , gen_rtx_COMPARE ( mode , gen_rtx_REG ( CC_FPXmode , <NUM_LIT> ) , const0_rtx ) ) ) ; } else if ( GET_MODE_CLASS ( cmode ) == MODE_FLOAT && TARGET_OPTFPE ) { rtx op0 = gen_rtx_REG ( cmode , <NUM_LIT> ) ; rtx op1 = gen_rtx_REG ( cmode , GET_MODE_SIZE ( cmode ) / UNITS_PER_WORD ) ; switch ( code ) { case NE : case EQ : case GT : case UNLE : case GE : case UNLT : case UNEQ : case LTGT : case ORDERED : case UNORDERED : break ; case LT : case UNGE : case LE : case UNGT : code = swap_condition ( code ) ; tmp = x ; x = y ;


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


<s> default : gcc_unreachable ( ) ; } case 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 CC_FP_GEmode : switch ( GET_CODE ( comparison ) ) { case GE : return ARC_CC_HS ; case UNLT : return ARC_CC_LO ; default : gcc_unreachable ( ) ; } case CC_FP_UNEQmode : switch ( GET_CODE ( comparison ) ) { case UNEQ : return ARC_CC_EQ ; case LTGT : return ARC_CC_NE ; default : gcc_unreachable ( ) ; } case CC_FP_ORDmode : switch ( GET_CODE ( comparison ) ) { case UNORDERED : return ARC_CC_C ; case ORDERED : return ARC_CC_NC ; default : gcc_unreachable ( ) ; } case CC_FPXmode : switch ( GET_CODE ( comparison ) ) { case EQ : return ARC_CC_EQ ; case NE : return ARC_CC_NE ; case UNORDERED : return ARC_CC_C ; case ORDERED : return ARC_CC_NC ; case LTGT : return ARC_CC_HI ; case UNEQ : return ARC_CC_LS ; default : gcc_unreachable ( ) ; } default : gcc_unreachable ( ) ;


<s> if ( arc_verify_short ( insn , cfun -> machine -> unalign , <NUM_LIT> ) ) { fprintf ( file , <STR_LIT> ) ; cfun -> machine -> unalign ^= <NUM_LIT> ;


<s> pass_arc_ifcvt ( gcc :: context * ctxt ) : rtl_opt_pass ( pass_data_arc_ifcvt , ctxt ) {


<s> else if ( mode == SImode && flag_pic && SYMBOLIC_CONST ( operands [ <NUM_LIT> ] ) ) { emit_pic_move ( operands , SImode ) ; } else if ( GET_CODE ( operands [ <NUM_LIT> ] ) != MEM && ! TARGET_NO_SDATA_SET && small_data_pattern ( operands [ <NUM_LIT> ] , Pmode ) ) { operands [ <NUM_LIT> ] = arc_rewrite_small_data ( operands [ <NUM_LIT> ] ) ; emit_insn ( gen_rtx_SET ( mode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; set_unique_reg_note ( get_last_insn ( ) , REG_EQUAL , operands [ <NUM_LIT> ] ) ; emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; return true ; } } 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> ) ;


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


<s> if ( GET_CODE ( x ) == PLUS && rtx_equal_p ( XEXP ( x , <NUM_LIT> ) , pic_offset_table_rtx ) ) iter . skip_subrtxes ( ) ; else if ( arc_rewrite_small_data_p ( x ) ) return true ;