<s> FOR_EACH_SUBRTX ( iter , array , op , ALL ) { const_rtx x = * iter ; 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 ; } return false ;


<s> const_rtx u0 = ( const_rtx ) x ; const_rtx u1 = ( const_rtx ) y ; const_rtx s01 = XVECEXP ( u0 , <NUM_LIT> , <NUM_LIT> ) ; const_rtx s11 = XVECEXP ( u1 , <NUM_LIT> , <NUM_LIT> ) ; return ( ! strcmp ( XSTR ( XVECEXP ( u0 , <NUM_LIT> , <NUM_LIT> ) , <NUM_LIT> ) , XSTR ( XVECEXP ( u1 , <NUM_LIT> , <NUM_LIT> ) , <NUM_LIT> ) ) && rtx_equal_p ( s01 , s11 ) ) ;


<s> return ( ! strcmp ( XSTR ( XVECEXP ( u0 , <NUM_LIT> , <NUM_LIT> ) , <NUM_LIT> ) , XSTR ( XVECEXP ( u1 , <NUM_LIT> , <NUM_LIT> ) , <NUM_LIT> ) ) && rtx_equal_p ( s01 , s11 ) ) ;


<s> if ( GET_CODE ( x ) == COND_EXEC ) x = COND_EXEC_CODE ( x ) ; if ( GET_CODE ( x ) == SET || GET_CODE ( x ) == CLOBBER ) { rtx dest = SET_DEST ( x ) ; while ( ( GET_CODE ( dest ) == SUBREG && ( ! REG_P ( SUBREG_REG ( dest ) ) || REGNO ( SUBREG_REG ( dest ) ) >= FIRST_PSEUDO_REGISTER ) ) || GET_CODE ( dest ) == ZERO_EXTRACT || GET_CODE ( dest ) == STRICT_LOW_PART ) dest = XEXP ( dest , <NUM_LIT> ) ; if ( GET_CODE ( dest ) == PARALLEL ) { for ( i = XVECLEN ( dest , <NUM_LIT> ) - <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) if ( XEXP ( XVECEXP ( dest , <NUM_LIT> , i ) , <NUM_LIT> ) != <NUM_LIT> ) ( * fun ) ( XEXP ( XVECEXP ( dest , <NUM_LIT> , i ) , <NUM_LIT> ) , x , data ) ; } else ( * fun ) ( dest , x , data ) ; } else if ( GET_CODE ( x ) == PARALLEL ) for ( i = XVECLEN ( x , <NUM_LIT> ) - <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) walk_stores ( XVECEXP ( x , <NUM_LIT> , i ) , fun , data ) ;


<s> if ( GET_CODE ( x ) == SET || GET_CODE ( x ) == CLOBBER ) { rtx dest = SET_DEST ( x ) ; while ( ( GET_CODE ( dest ) == SUBREG && ( ! REG_P ( SUBREG_REG ( dest ) ) || REGNO ( SUBREG_REG ( dest ) ) >= FIRST_PSEUDO_REGISTER ) ) || GET_CODE ( dest ) == ZERO_EXTRACT || GET_CODE ( dest ) == STRICT_LOW_PART ) dest = XEXP ( dest , <NUM_LIT> ) ; if ( GET_CODE ( dest ) == PARALLEL ) {

for ( i = XVECLEN ( dest , <NUM_LIT> ) - <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) if ( XEXP ( XVECEXP ( dest , <NUM_LIT> , i ) , <NUM_LIT> ) != <NUM_LIT> ) ( * fun ) ( XEXP ( XVECEXP ( dest , <NUM_LIT> , i ) , <NUM_LIT> ) , x , data ) ;


<s> output_asm_insn ( <STR_LIT> <STR_LIT> , & XVECEXP ( src , <NUM_LIT> , <NUM_LIT> ) ) ; } slot = ( rtx * ) htab_find_slot ( htab , src , INSERT ) ; if ( * slot == HTAB_EMPTY_ENTRY ) { static int count_nr ; char buf [ <NUM_LIT> ] ; rtx count ; * slot = src ; sprintf ( buf , <STR_LIT> , count_nr ++ ) ; count = gen_rtx_SYMBOL_REF ( Pmode , xstrdup ( buf ) ) ;

XVECEXP ( src , <NUM_LIT> , <NUM_LIT> ) = count ;


<s> slot = ( rtx * ) htab_find_slot ( htab , src , INSERT ) ; if ( * slot == HTAB_EMPTY_ENTRY ) { static int count_nr ; char buf [ <NUM_LIT> ] ; rtx count ; * slot = src ; sprintf ( buf , <STR_LIT> , count_nr ++ ) ; count = gen_rtx_SYMBOL_REF ( Pmode , xstrdup ( buf ) ) ; XVECEXP ( src , <NUM_LIT> , <NUM_LIT> ) = count ; output_asm_insn ( <STR_LIT> <STR_LIT> <STR_LIT> <STR_LIT> <STR_LIT> <STR_LIT> , & XVECEXP ( src , <NUM_LIT> , <NUM_LIT> ) ) ; * srcp = count ; } else * srcp = XVECEXP ( * slot , <NUM_LIT> , <NUM_LIT> ) ;


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


<s> enum arc_function_type arc_compute_function_type ( struct function * fun ) { tree decl = fun -> decl ; tree a ; enum arc_function_type fn_type = fun -> machine -> fn_type ; if ( fn_type != ARC_FUNCTION_UNKNOWN ) return fn_type ; 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> ) || ! 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> XVECEXP ( p , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_REG ( SImode , regno ) ;

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


<s> rtx op0 = expand_expr ( arg0 , NULL_RTX , VOIDmode , EXPAND_NORMAL ) ; rtx op1 = expand_expr ( arg1 , NULL_RTX , VOIDmode , EXPAND_NORMAL ) ; if ( ! CONST_INT_P ( op1 ) ) { if ( optimize ) warning ( <NUM_LIT> , <STR_LIT> ) ; } else { HOST_WIDE_INT alignTest = INTVAL ( op1 ) ; if ( alignTest <= <NUM_LIT> || alignTest != ( alignTest & - alignTest ) ) { error ( <STR_LIT> ) ; return NULL_RTX ;


<s> } if ( millicode_p ) { int sibthunk_p = ( ! sibcall_p && fn_type == ARC_FUNCTION_NORMAL && ! cfun -> machine -> frame_info . pretend_size ) ; gcc_assert ( ! ( cfun -> machine -> frame_info . gmask & ( FRAME_POINTER_MASK | RETURN_ADDR_MASK ) ) ) ; arc_save_restore ( stack_pointer_rtx , cfun -> machine -> frame_info . gmask , <NUM_LIT> + sibthunk_p , & first_offset ) ; if ( sibthunk_p ) return ; } 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 ) ; HOST_WIDE_INT cfa_adjust = <NUM_LIT> ; 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 ) ; cfa_adjust = ra_offs ; 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 ) ;


<s> 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 ) ; HOST_WIDE_INT cfa_adjust = <NUM_LIT> ; 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 ) ; cfa_adjust = ra_offs ; 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 ) ; cfa_adjust = GET_MODE_SIZE ( Pmode ) ; size_to_deallocate = <NUM_LIT> ; } insn = frame_move_inc ( ra , gen_frame_mem ( Pmode , addr ) , stack_pointer_rtx , addr ) ; if ( cfa_adjust ) { enum reg_note note = REG_CFA_ADJUST_CFA ; add_reg_note ( insn , note , gen_rtx_SET ( stack_pointer_rtx , plus_constant ( SImode , stack_pointer_rtx , cfa_adjust ) ) ) ; } add_reg_note ( insn , REG_CFA_RESTORE , ra ) ; } if ( ! millicode_p ) { if ( cfun -> machine -> frame_info . reg_size ) arc_save_restore ( stack_pointer_rtx , cfun -> machine -> frame_info . gmask & ~ ( FRAME_POINTER_MASK | RETURN_ADDR_MASK ) , <NUM_LIT> , & first_offset ) ; } size_to_deallocate += first_offset ; restored = size - size_to_deallocate ; if ( size > restored ) frame_stack_add ( size - restored ) ;

if ( sibcall_p == FALSE ) emit_jump_insn ( gen_simple_return ( ) ) ;


<s> while ( piece > size ) piece >>= <NUM_LIT> ; 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 ) ;


<s> if ( crtl -> uses_pic_offset_table == <NUM_LIT> ) return ; gcc_assert ( flag_pic != <NUM_LIT> ) ; 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 ( baseptr_rtx , pat ) ;


<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> ) && ! TARGET_V2 ) {


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


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


<s> merge_blocks ( merge_bb , succ_bb ) ; } else { PUT_CODE ( insn , NOTE ) ; NOTE_KIND ( insn ) = NOTE_INSN_DELETED ; } continue ; } case <NUM_LIT> : if ( LABEL_P ( insn ) && statep -> target_label == CODE_LABEL_NUMBER ( insn ) ) { arc_ccfsm_post_advance ( insn , statep ) ; basic_block succ_bb = BLOCK_FOR_INSN ( insn ) ; if ( merge_bb && succ_bb ) merge_blocks ( merge_bb , succ_bb ) ; else if ( -- LABEL_NUSES ( insn ) == <NUM_LIT> ) { 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 ( 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 ; default :


<s> 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 ( 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 ; default : gcc_unreachable ( ) ; } arc_ccfsm_post_advance ( insn , statep ) ; } return <NUM_LIT> ;


<s> case PROCESSOR_ARC601 : arc_cpu_string = <STR_LIT> ; tune_dflt = TUNE_ARC600 ; break ; case PROCESSOR_ARC700 : arc_cpu_string = <STR_LIT> ; tune_dflt = TUNE_ARC700_4_2_STD ; break ; case PROCESSOR_ARCEM : arc_cpu_string = <STR_LIT> ; break ; case PROCESSOR_ARCHS : arc_cpu_string = <STR_LIT> ; break ; default : gcc_unreachable ( ) ; } if ( arc_tune == TUNE_NONE ) arc_tune = tune_dflt ; if ( arc_multcost < <NUM_LIT> ) switch ( arc_tune ) { case TUNE_ARC700_4_2_STD : arc_multcost = COSTS_N_INSNS ( <NUM_LIT> ) ; if ( TARGET_NOMPY_SET ) arc_multcost = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case TUNE_ARC700_4_2_XMAC : arc_multcost = COSTS_N_INSNS ( <NUM_LIT> ) ; if ( TARGET_NOMPY_SET ) arc_multcost = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case TUNE_ARC600 : if ( TARGET_MUL64_SET ) { arc_multcost = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; } default : arc_multcost = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; } if ( TARGET_MUL64_SET && ( ! TARGET_ARC600_FAMILY ) ) error ( <STR_LIT> ) ; if ( TARGET_NOMPY_SET && TARGET_ARC600_FAMILY ) error ( <STR_LIT> ) ; if ( TARGET_MULMAC_32BY16_SET && ( ! TARGET_ARC600_FAMILY ) ) error ( <STR_LIT> ) ; if ( ! TARGET_DPFP && TARGET_DPFP_DISABLE_LRSR ) error ( <STR_LIT> ) ; if ( ( TARGET_DPFP_FAST_SET && TARGET_DPFP_COMPACT_SET ) || ( TARGET_SPFP_FAST_SET && TARGET_SPFP_COMPACT_SET ) ) error ( <STR_LIT> ) ; if ( TARGET_SPFP_FAST_SET && TARGET_ARC600_FAMILY ) error ( <STR_LIT> ) ; if ( ( TARGET_DPFP || TARGET_SPFP ) && ( ! TARGET_ARCOMPACT_FAMILY && ! TARGET_EM ) ) error ( <STR_LIT> ) ; if ( ( TARGET_DPFP || TARGET_SPFP ) && TARGET_HARD_FLOAT && TARGET_HS ) error ( <STR_LIT> ) ; if ( TARGET_HS && ( ( arc_mpy_option > <NUM_LIT> && arc_mpy_option < <NUM_LIT> ) || ( arc_mpy_option == <NUM_LIT> ) ) ) error ( <STR_LIT> ) ; if ( flag_pic && TARGET_ARC600_FAMILY ) { warning ( DK_WARNING , <STR_LIT> , arc_cpu_string ) ; flag_pic = <NUM_LIT> ; } if ( TARGET_ATOMIC && ! ( TARGET_ARC700 || TARGET_HS ) ) error ( <STR_LIT> ) ; if ( TARGET_LL64 && ! TARGET_HS ) error ( <STR_LIT> ) ; if ( TARGET_HARD_FLOAT ) { if ( TARGET_EM && ( arc_fpu_build & ~ ( FPU_SP | FPU_SF | FPU_SC | FPU_SD | FPX_DP ) ) ) error ( <STR_LIT> ) ; if ( TARGET_HS && ( arc_fpu_build & FPX_DP ) ) error ( <STR_LIT> <STR_LIT> ) ; if ( ! TARGET_HS && ! TARGET_EM ) error ( <STR_LIT> ) ; } arc_init_reg_tables ( ) ; memset ( arc_punct_chars , <NUM_LIT> , sizeof ( arc_punct_chars ) ) ; arc_punct_chars [ '#' ] = <NUM_LIT> ;


<s> else if ( GET_MODE_SIZE ( m ) == <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) OF_MODE ; else arc_mode_class [ i ] = <NUM_LIT> ; break ; case MODE_VECTOR_INT : arc_mode_class [ i ] = ( <NUM_LIT> << ( int ) V_MODE ) ; break ; case MODE_CC : default : if ( i == ( int ) CCmode || i == ( int ) CC_ZNmode || i == ( int ) CC_Zmode || i == ( int ) CC_Cmode || i == CC_FP_GTmode || i == CC_FP_GEmode || i == CC_FP_ORDmode || i == CC_FPUmode || i == CC_FPU_UNEQmode ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) C_MODE ; else arc_mode_class [ i ] = <NUM_LIT> ; break ; } }


<s> else return false ; if ( ( GET_CODE ( PATTERN ( jump ) ) == PARALLEL ) && ( XVECEXP ( PATTERN ( jump ) , <NUM_LIT> , <NUM_LIT> ) == ret_rtx ) ) return false ; label_rtx = JUMP_LABEL ( jump ) ; if ( ! label_rtx ) return false ; if ( ANY_RETURN_P ( label_rtx ) ) return false ; label = safe_as_a < rtx_insn * > ( label_rtx ) ; succ_bb = BLOCK_FOR_INSN ( label ) ; if ( ! succ_bb ) { gcc_assert ( NEXT_INSN ( label ) ) ; if ( NOTE_INSN_BASIC_BLOCK_P ( NEXT_INSN ( label ) ) ) succ_bb = NOTE_BASIC_BLOCK ( NEXT_INSN ( label ) ) ; else succ_bb = BLOCK_FOR_INSN ( NEXT_INSN ( label ) ) ;


<s> case SYMBOL_REF : output_addr_const ( file , addr ) ; if ( SYMBOL_REF_SMALL_P ( addr ) ) fprintf ( file , <STR_LIT> ) ; break ; case PLUS : if ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == MULT ) index = XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) , base = XEXP ( addr , <NUM_LIT> ) ; else if ( CONST_INT_P ( XEXP ( addr , <NUM_LIT> ) ) ) index = XEXP ( addr , <NUM_LIT> ) , base = XEXP ( addr , <NUM_LIT> ) ; else base = XEXP ( addr , <NUM_LIT> ) , index = XEXP ( addr , <NUM_LIT> ) ;


<s> output_addr_const ( file , addr ) ; if ( SYMBOL_REF_SMALL_P ( addr ) ) fprintf ( file , <STR_LIT> ) ; break ; case PLUS : if ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == MULT ) index = XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) , base = XEXP ( addr , <NUM_LIT> ) ; else if ( CONST_INT_P ( XEXP ( addr , <NUM_LIT> ) ) ) index = XEXP ( addr , <NUM_LIT> ) , base = XEXP ( addr , <NUM_LIT> ) ;

else base = XEXP ( addr , <NUM_LIT> ) , index = XEXP ( addr , <NUM_LIT> ) ;


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

rtx srcLow = simplify_gen_subreg ( SImode , src , DFmode , <NUM_LIT> ) ;


<s> if ( refers_to_regno_p ( <NUM_LIT> , <NUM_LIT> , src , <NUM_LIT> ) ) state = srcDx ; if ( refers_to_regno_p ( <NUM_LIT> , <NUM_LIT> , dest , <NUM_LIT> ) ) { gcc_assert ( state == none ) ; state = destDx ; } if ( state == none ) return false ; if ( state == srcDx ) { if ( TARGET_DPFP_DISABLE_LRSR ) { rtx set = gen_rtx_SET ( dest , src ) ; rtx use1 = gen_rtx_USE ( VOIDmode , const1_rtx ) ; emit_insn ( gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , set , use1 ) ) ) ; }


<s> struct arc_frame_info * frame = & cfun -> machine -> frame_info ; 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 ( reg , mem ) ; else XVECEXP ( insn , <NUM_LIT> , i ) = gen_rtx_SET ( mem , reg ) ; gmask = gmask & ~ ( <NUM_LIT> << r ) ; } if ( epilogue_p == <NUM_LIT> ) sibthunk_insn = insn ; else { insn = frame_insn ( insn ) ; if ( epilogue_p ) for ( r = start_call ; r <= end_call ; r ++ ) { rtx reg = gen_rtx_REG ( SImode , r ) ; add_reg_note ( insn , REG_CFA_RESTORE , reg ) ;


<s> CUMULATIVE_ARGS next_cum ; next_cum = * get_cumulative_args ( args_so_far ) ; arc_function_arg_advance ( pack_cumulative_args ( & next_cum ) , mode , type , true ) ; 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 ) ;


add_int_reg_note ( insn , REG_BR_PROB , very_unlikely ) ;


<s> static void emit_unlikely_jump ( rtx insn ) {


<s> 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 ( cc_reg , gen_rtx_COMPARE ( mode , gen_rtx_REG ( CC_FPXmode , <NUM_LIT> ) , const0_rtx ) ) ) ; } else if ( TARGET_HARD_FLOAT && ( ( cmode == SFmode && TARGET_FP_SP_BASE ) || ( cmode == DFmode && TARGET_FP_DP_BASE ) ) ) emit_insn ( gen_rtx_SET ( cc_reg , gen_rtx_COMPARE ( mode , x , y ) ) ) ; 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 ) ; bool swap = false ; 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 ) ; swap = true ; break ; default : gcc_unreachable ( ) ;


<s> operands [ <NUM_LIT> ] = gen_rtx_fmt_e ( code , omode , arc_rewrite_small_data ( operands [ <NUM_LIT> ] ) ) ; emit_insn ( gen_rtx_SET ( 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 ; }


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


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


<s> for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) { succ0 = next_real_insn ( insn ) ; if ( arc_hazard ( insn , succ0 ) ) { emit_insn_before ( gen_nopv ( ) , succ0 ) ;


<s> if ( arc_hazard ( insn , succ0 ) ) { emit_insn_before ( gen_nopv ( ) , succ0 ) ;


<s> case SYMBOL_REF : case CONST : if ( TARGET_NPS_CMEM && cmem_address ( addr , SImode ) ) return <NUM_LIT> ; return COSTS_N_INSNS ( <NUM_LIT> ) ; 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 ;


<s> 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> ) ) == SIMPLE_RETURN ) seeking_return = <NUM_LIT> ; else if ( GET_CODE ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) ) == SIMPLE_RETURN ) { seeking_return = <NUM_LIT> ; then_not_else = FALSE ; } else gcc_unreachable ( ) ; if ( NEXT_INSN ( PREV_INSN ( insn ) ) != insn && state -> state == <NUM_LIT> && ! INSN_ANNULLED_BRANCH_P ( insn ) ) { this_insn = NEXT_INSN ( this_insn ) ; gcc_assert ( NEXT_INSN ( NEXT_INSN ( PREV_INSN ( start_insn ) ) ) == NEXT_INSN ( this_insn ) ) ; } 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 ) { state -> state = <NUM_LIT> ; succeed = TRUE ; } else fail = TRUE ; break ; } switch ( GET_CODE ( this_insn ) ) { case CODE_LABEL : if ( this_insn == label ) { state -> 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 ; case JUMP_INSN : scanbody = PATTERN ( this_insn ) ; if ( GET_CODE ( scanbody ) == SET && GET_CODE ( SET_DEST ( scanbody ) ) == PC ) { if ( GET_CODE ( SET_SRC ( scanbody ) ) == LABEL_REF && XEXP ( SET_SRC ( scanbody ) , <NUM_LIT> ) == label && ! reverse ) { state -> state = <NUM_LIT> ; succeed = TRUE ; } else if ( GET_CODE ( SET_SRC ( scanbody ) ) == IF_THEN_ELSE ) fail = TRUE ;

else if ( get_attr_cond ( this_insn ) != COND_CANUSE ) fail = TRUE ;


<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> RTL_PURE_CALL_P ( call_insn ) = <NUM_LIT> ; add_function_usage_to ( call_insn , call_fusage ) ; rtx_insn * insns = get_insns ( ) ; end_sequence ( ) ; rtx dest = gen_reg_rtx ( Pmode ) ;

emit_libcall_block ( insns , dest , r0 , eqv ) ;


<s> pat = gen_rtx_SYMBOL_REF ( Pmode , <STR_LIT> ) ; pat = arc_unspec_offset ( pat , ARC_UNSPEC_GOT ) ; pat = gen_rtx_SET ( baseptr_rtx , pat ) ; emit_insn ( pat ) ;


<s> pat = arc_unspec_offset ( pat , ARC_UNSPEC_GOT ) ; pat = gen_rtx_SET ( baseptr_rtx , pat ) ;


<s> static rtx arc_get_tp ( void ) { if ( arc_tp_regno != - <NUM_LIT> ) return gen_rtx_REG ( Pmode , arc_tp_regno ) ; rtx reg = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_tls_load_tp_soft ( ) ) ; emit_move_insn ( reg , gen_rtx_REG ( Pmode , R0_REG ) ) ; return reg ;


<s> rtx reg = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_tls_load_tp_soft ( ) ) ; emit_move_insn ( reg , gen_rtx_REG ( Pmode , R0_REG ) ) ; return reg ;


<s> if ( ! TARGET_DPFP && TARGET_DPFP_DISABLE_LRSR ) error ( <STR_LIT> ) ; if ( ( TARGET_DPFP_FAST_SET && TARGET_DPFP_COMPACT_SET ) || ( TARGET_SPFP_FAST_SET && TARGET_SPFP_COMPACT_SET ) ) error ( <STR_LIT> ) ; if ( TARGET_SPFP_FAST_SET && TARGET_ARC600_FAMILY ) error ( <STR_LIT> ) ; if ( ( TARGET_DPFP_FAST_SET || TARGET_DPFP_COMPACT_SET || TARGET_SPFP ) && TARGET_HARD_FLOAT ) error ( <STR_LIT> ) ; if ( flag_pic && TARGET_ARC600_FAMILY ) { warning ( 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> ; 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 } ;


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


<s> case MODE_COMPLEX_INT : if ( GET_MODE_SIZE ( m ) <= <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) S_MODE ; else if ( GET_MODE_SIZE ( m ) == <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) D_MODE ; else if ( GET_MODE_SIZE ( m ) == <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) T_MODE ; else if ( GET_MODE_SIZE ( m ) == <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) O_MODE ; else arc_mode_class [ i ] = <NUM_LIT> ; break ; case MODE_FLOAT : case MODE_COMPLEX_FLOAT : if ( GET_MODE_SIZE ( m ) <= <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) SF_MODE ; else if ( GET_MODE_SIZE ( m ) == <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) DF_MODE ; else if ( GET_MODE_SIZE ( m ) == <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) TF_MODE ; else if ( GET_MODE_SIZE ( m ) == <NUM_LIT> ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) OF_MODE ; else arc_mode_class [ i ] = <NUM_LIT> ; break ; case MODE_VECTOR_INT : if ( GET_MODE_SIZE ( m ) == <NUM_LIT> ) arc_mode_class [ i ] = ( <NUM_LIT> << ( int ) S_MODE ) ; else if ( GET_MODE_SIZE ( m ) == <NUM_LIT> ) arc_mode_class [ i ] = ( <NUM_LIT> << ( int ) D_MODE ) ;

else arc_mode_class [ i ] = ( <NUM_LIT> << ( int ) V_MODE ) ;


<s> if ( GET_MODE_SIZE ( m ) == <NUM_LIT> ) arc_mode_class [ i ] = ( <NUM_LIT> << ( int ) S_MODE ) ; else if ( GET_MODE_SIZE ( m ) == <NUM_LIT> ) arc_mode_class [ i ] = ( <NUM_LIT> << ( int ) D_MODE ) ; else arc_mode_class [ i ] = ( <NUM_LIT> << ( int ) V_MODE ) ; break ; case MODE_CC : default : if ( i == ( int ) CCmode || i == ( int ) CC_ZNmode || i == ( int ) CC_Zmode || i == ( int ) CC_Cmode || i == CC_FP_GTmode || i == CC_FP_GEmode || i == CC_FP_ORDmode || i == CC_FPUmode || i == CC_FPU_UNEQmode ) arc_mode_class [ i ] = <NUM_LIT> << ( int ) C_MODE ; else arc_mode_class [ i ] = <NUM_LIT> ; break ; } }


<s> int arc_label_align ( rtx_insn * label ) { int loop_align = LOOP_ALIGN ( LABEL ) ; if ( loop_align > align_labels_log ) { 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> ;


<s> if ( LEGITIMATE_SMALL_DATA_ADDRESS_P ( x ) ) return true ; if ( GET_CODE ( x ) == CONST_INT && LARGE_INT ( INTVAL ( x ) ) ) return true ; if ( ! flag_pic && optimize_size && ! reload_completed && ( GET_CODE ( x ) == CONST ) && ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS ) && ( GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF ) && SYMBOL_REF_TLS_MODEL ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == <NUM_LIT> && ! SYMBOL_REF_FUNCTION_P ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) ) { rtx addend = XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ; gcc_assert ( CONST_INT_P ( addend ) ) ; HOST_WIDE_INT offset = INTVAL ( addend ) ; return ! ( offset > - <NUM_LIT> && offset < <NUM_LIT> ) ; } if ( ( GET_MODE_SIZE ( mode ) != <NUM_LIT> ) && CONSTANT_P ( x ) ) {

if ( flag_pic ? arc_legitimate_pic_addr_p ( x ) : arc_legitimate_constant_p ( Pmode , x ) ) return true ;


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


<s> if ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL ( x ) ) return false ; if ( ! flag_pic && mode != Pmode ) return true ; switch ( GET_CODE ( x ) ) { case CONST : x = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( x ) == PLUS ) { if ( flag_pic ? GET_CODE ( XEXP ( x , <NUM_LIT> ) ) != CONST_INT : ! arc_legitimate_constant_p ( mode , XEXP ( x , <NUM_LIT> ) ) ) return false ;


<s> switch ( GET_CODE ( x ) ) { case CONST : x = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( x ) == PLUS ) { if ( flag_pic ? GET_CODE ( XEXP ( x , <NUM_LIT> ) ) != CONST_INT : ! arc_legitimate_constant_p ( mode , XEXP ( x , <NUM_LIT> ) ) ) return false ; x = XEXP ( x , <NUM_LIT> ) ; } if ( GET_CODE ( x ) == UNSPEC ) switch ( XINT ( x , <NUM_LIT> ) ) { case ARC_UNSPEC_PLT : case ARC_UNSPEC_GOTOFF : case ARC_UNSPEC_GOTOFFPC :


<s> bool arc_legitimate_pc_offset_p ( rtx addr ) { if ( GET_CODE ( addr ) != CONST ) return false ;


<s> bool arc_legitimate_pc_offset_p ( rtx addr ) { if ( GET_CODE ( addr ) != CONST ) return false ; return arc_needs_pcl_p ( addr ) ;


<s> if ( GET_CODE ( addr ) != UNSPEC || XVECLEN ( addr , <NUM_LIT> ) != <NUM_LIT> ) return false ;

if ( XINT ( addr , <NUM_LIT> ) != ARC_UNSPEC_GOT && XINT ( addr , <NUM_LIT> ) != ARC_UNSPEC_GOTOFF && XINT ( addr , <NUM_LIT> ) != ARC_UNSPEC_GOTOFFPC && XINT ( addr , <NUM_LIT> ) != UNSPEC_TLS_GD && XINT ( addr , <NUM_LIT> ) != UNSPEC_TLS_IE ) return false ;


<s> static rtx arc_legitimize_address ( rtx orig_x , rtx oldx , machine_mode mode ) { if ( GET_CODE ( orig_x ) == SYMBOL_REF ) { enum tls_model model = SYMBOL_REF_TLS_MODEL ( orig_x ) ; if ( model != <NUM_LIT> ) return arc_legitimize_tls_address ( orig_x , model ) ; } rtx new_x = arc_legitimize_address_0 ( orig_x , oldx , mode ) ;


<s> static rtx arc_legitimize_address ( rtx orig_x , rtx oldx , machine_mode mode ) { if ( GET_CODE ( orig_x ) == SYMBOL_REF ) { enum tls_model model = SYMBOL_REF_TLS_MODEL ( orig_x ) ; if ( model != <NUM_LIT> ) return arc_legitimize_tls_address ( orig_x , model ) ;


<s> emit_insn ( gen_rtx_SET ( oldx , gen_rtx_MINUS ( SImode , op0 , oldx ) ) ) ; return oldx ; } else if ( GET_CODE ( addr ) != PLUS ) { rtx tmp = XEXP ( addr , <NUM_LIT> ) ; enum rtx_code code = GET_CODE ( addr ) ; gcc_assert ( UNARY_P ( addr ) ) ; gcc_assert ( GET_CODE ( tmp ) == UNSPEC ) ; gcc_assert ( oldx ) ; emit_move_insn ( oldx , gen_rtx_CONST ( SImode , arc_legitimize_pic_address ( tmp , NULL_RTX ) ) ) ; emit_insn ( gen_rtx_SET ( oldx , gen_rtx_fmt_ee ( code , SImode , oldx , const0_rtx ) ) ) ; return oldx ; } else { gcc_assert ( GET_CODE ( addr ) == PLUS ) ; if ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == UNSPEC ) return orig ; } } if ( GET_CODE ( addr ) == PLUS ) { rtx op0 = XEXP ( addr , <NUM_LIT> ) , op1 = XEXP ( addr , <NUM_LIT> ) ; base = arc_legitimize_pic_address ( op0 , oldx ) ; pat = arc_legitimize_pic_address ( op1 , base == oldx ? NULL_RTX : oldx ) ; if ( base == op0 && pat == op1 ) return orig ; if ( GET_CODE ( pat ) == CONST_INT ) pat = plus_constant ( Pmode , base , INTVAL ( pat ) ) ;


<s> base_name = DTPOFF_ZERO_SYM ; if ( decl && bss_initializer_p ( decl ) ) base_name = <STR_LIT> ; base = gen_rtx_SYMBOL_REF ( Pmode , base_name ) ; if ( strcmp ( base_name , DTPOFF_ZERO_SYM ) == <NUM_LIT> ) { if ( ! flag_pic ) goto local_exec ; v = gen_rtvec ( <NUM_LIT> , addr ) ; } else v = gen_rtvec ( <NUM_LIT> , addr , base ) ;

addr = gen_rtx_UNSPEC ( Pmode , v , UNSPEC_TLS_OFF ) ;


<s> if ( recog_memoized ( succ ) != CODE_FOR_doloop_end_i ) return false ; if ( TARGET_ARC600 || TARGET_HS ) if ( JUMP_P ( pred ) || CALL_P ( pred ) || arc_asm_insn_p ( PATTERN ( pred ) ) || GET_CODE ( PATTERN ( pred ) ) == SEQUENCE ) return true ; if ( JUMP_P ( pred ) ) jump = pred ; else if ( GET_CODE ( PATTERN ( pred ) ) == SEQUENCE && JUMP_P ( XVECEXP ( PATTERN ( pred ) , <NUM_LIT> , <NUM_LIT> ) ) ) jump = as_a < rtx_insn * > ( XVECEXP ( PATTERN ( pred ) , <NUM_LIT> , <NUM_LIT> ) ) ; else return false ; if ( ( GET_CODE ( PATTERN ( jump ) ) == PARALLEL ) && ( XVECEXP ( PATTERN ( jump ) , <NUM_LIT> , <NUM_LIT> ) == ret_rtx ) ) return false ; label_rtx = JUMP_LABEL ( jump ) ; if ( ! label_rtx ) return false ; if ( ANY_RETURN_P ( label_rtx ) ) return false ; label = safe_as_a < rtx_insn * > ( label_rtx ) ; succ_bb = BLOCK_FOR_INSN ( label ) ; if ( ! succ_bb ) { gcc_assert ( NEXT_INSN ( label ) ) ; if ( NOTE_INSN_BASIC_BLOCK_P ( NEXT_INSN ( label ) ) ) succ_bb = NOTE_BASIC_BLOCK ( NEXT_INSN ( label ) ) ;

else succ_bb = BLOCK_FOR_INSN ( NEXT_INSN ( label ) ) ;


<s> register int i , j ; if ( ( GET_CODE ( x ) == UNSPEC ) && ( XVECLEN ( x , <NUM_LIT> ) == <NUM_LIT> ) && ( GET_CODE ( XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ) == SYMBOL_REF ) ) switch ( XINT ( x , <NUM_LIT> ) ) { case ARC_UNSPEC_GOT : case ARC_UNSPEC_GOTOFFPC : case UNSPEC_TLS_GD :


<s> register int i , j ; if ( ( GET_CODE ( x ) == UNSPEC ) && ( XVECLEN ( x , <NUM_LIT> ) == <NUM_LIT> ) && ( GET_CODE ( XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ) == SYMBOL_REF ) ) switch ( XINT ( x , <NUM_LIT> ) ) { case ARC_UNSPEC_GOT : case ARC_UNSPEC_GOTOFFPC : case UNSPEC_TLS_GD : case UNSPEC_TLS_IE : return true ; default : break ; } fmt = GET_RTX_FORMAT ( GET_CODE ( x ) ) ; for ( i = GET_RTX_LENGTH ( GET_CODE ( x ) ) - <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) { if ( fmt [ i ] == 'e' ) { if ( arc_needs_pcl_p ( XEXP ( x , i ) ) ) return true ; } else if ( fmt [ i ] == 'E' ) for ( j = XVECLEN ( x , i ) - <NUM_LIT> ; j >= <NUM_LIT> ; j -- ) if ( arc_needs_pcl_p ( XVECEXP ( x , i , j ) ) ) return true ; }


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


<s> gcc_assert ( ! CONSTANT_P ( operands [ <NUM_LIT> ] ) ) ; switch ( commutative_op ) { case AND : if ( satisfies_constraint_C1p ( operands [ <NUM_LIT> ] ) ) pat = <STR_LIT> ; else if ( satisfies_constraint_C2p ( operands [ <NUM_LIT> ] ) ) { operands [ <NUM_LIT> ] = GEN_INT ( ( ~ INTVAL ( operands [ <NUM_LIT> ] ) ) ) ; pat = <STR_LIT> ; }

else if ( satisfies_constraint_Ccp ( operands [ <NUM_LIT> ] ) ) pat = <STR_LIT> ;


<s> 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 : const char * suffix ; bool pcrel ; pcrel = false ; rtx base ; base = NULL ; gcc_assert ( XVECLEN ( x , <NUM_LIT> ) >= <NUM_LIT> ) ; switch ( XINT ( x , <NUM_LIT> ) ) { case ARC_UNSPEC_GOT : suffix = <STR_LIT> , pcrel = true ; break ; case ARC_UNSPEC_GOTOFF : suffix = <STR_LIT> ; break ; case ARC_UNSPEC_GOTOFFPC : suffix = <STR_LIT> , pcrel = true ; break ; case ARC_UNSPEC_PLT : suffix = <STR_LIT> ; break ; case UNSPEC_TLS_GD : suffix = <STR_LIT> , pcrel = true ; break ; case UNSPEC_TLS_IE : suffix = <STR_LIT> , pcrel = true ; break ; case UNSPEC_TLS_OFF : if ( XVECLEN ( x , <NUM_LIT> ) == <NUM_LIT> ) base = XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ; if ( SYMBOL_REF_TLS_MODEL ( XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ) == TLS_MODEL_LOCAL_EXEC || ( ! flag_pic && ! base ) ) suffix = <STR_LIT> ; else suffix = <STR_LIT> ; break ;


<s> return TARGET_PLUS_QMACW ? V4HImode : V2HImode ; case SImode : return V2SImode ; default : return word_mode ; }


<s> if ( ( GET_CODE ( c ) == UNSPEC && ( XINT ( c , <NUM_LIT> ) == UNSPEC_TLS_OFF || XINT ( c , <NUM_LIT> ) == UNSPEC_TLS_IE ) ) || ( GET_CODE ( c ) == PLUS && GET_CODE ( XEXP ( c , <NUM_LIT> ) ) == UNSPEC && ( XINT ( XEXP ( c , <NUM_LIT> ) , <NUM_LIT> ) == UNSPEC_TLS_OFF || XINT ( XEXP ( c , <NUM_LIT> ) , <NUM_LIT> ) == ARC_UNSPEC_GOTOFFPC ) ) ) { arc_output_pic_addr_const ( file , c , <NUM_LIT> ) ; break ; } gcc_assert ( GET_CODE ( c ) == PLUS ) ; gcc_assert ( GET_CODE ( XEXP ( c , <NUM_LIT> ) ) == SYMBOL_REF ) ; gcc_assert ( GET_CODE ( XEXP ( c , <NUM_LIT> ) ) == CONST_INT ) ;

output_address ( VOIDmode , XEXP ( addr , <NUM_LIT> ) ) ;


<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> ) ; if ( ( GET_CODE ( c ) == UNSPEC && ( XINT ( c , <NUM_LIT> ) == UNSPEC_TLS_OFF || XINT ( c , <NUM_LIT> ) == UNSPEC_TLS_IE ) ) || ( GET_CODE ( c ) == PLUS && GET_CODE ( XEXP ( c , <NUM_LIT> ) ) == UNSPEC && ( XINT ( XEXP ( c , <NUM_LIT> ) , <NUM_LIT> ) == UNSPEC_TLS_OFF || XINT ( XEXP ( c , <NUM_LIT> ) , <NUM_LIT> ) == ARC_UNSPEC_GOTOFFPC ) ) ) { arc_output_pic_addr_const ( file , c , <NUM_LIT> ) ; break ;


<s> else { rtx destHigh = simplify_gen_subreg ( SImode , dest , DFmode , TARGET_BIG_ENDIAN ? <NUM_LIT> : <NUM_LIT> ) ; rtx destLow = simplify_gen_subreg ( SImode , dest , DFmode , TARGET_BIG_ENDIAN ? <NUM_LIT> : <NUM_LIT> ) ; emit_insn ( gen_rtx_SET ( destHigh , gen_rtx_UNSPEC_VOLATILE ( Pmode , gen_rtvec ( <NUM_LIT> , src ) , VUNSPEC_ARC_LR_HIGH ) ) ) ; emit_insn ( gen_rtx_SET ( destLow , gen_rtx_UNSPEC_VOLATILE ( Pmode , gen_rtvec ( <NUM_LIT> , src ) , VUNSPEC_ARC_LR ) ) ) ; } } else if ( state == destDx ) { rtx srcHigh = simplify_gen_subreg ( SImode , src , DFmode , TARGET_BIG_ENDIAN ? <NUM_LIT> : <NUM_LIT> ) ;

rtx srcLow = simplify_gen_subreg ( SImode , src , DFmode , TARGET_BIG_ENDIAN ? <NUM_LIT> : <NUM_LIT> ) ;


<s> if ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_SMALL_P ( x ) ) { gcc_assert ( SYMBOL_REF_TLS_MODEL ( x ) == <NUM_LIT> ) ; return true ; } return false ;


<s> static bool arc_rewrite_small_data_p ( const_rtx x ) { if ( GET_CODE ( x ) == CONST ) x = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( x ) == PLUS ) { if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) x = XEXP ( x , <NUM_LIT> ) ; } if ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_SMALL_P ( x ) ) { gcc_assert ( SYMBOL_REF_TLS_MODEL ( x ) == <NUM_LIT> ) ; return true ; } return false ;


<s> case SYMBOL_REF : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case CONST_DOUBLE : { rtx first , second ; if ( TARGET_DPFP ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } split_double ( x , & first , & second ) ; * total = COSTS_N_INSNS ( ! SMALL_INT ( INTVAL ( first ) ) + ! SMALL_INT ( INTVAL ( second ) ) ) ; return true ; } case ASHIFT : case ASHIFTRT : case LSHIFTRT : if ( TARGET_BARREL_SHIFTER ) { if ( CONSTANT_P ( XEXP ( x , <NUM_LIT> ) ) ) { * total += ( COSTS_N_INSNS ( <NUM_LIT> ) + rtx_cost ( XEXP ( x , <NUM_LIT> ) , mode , ( enum rtx_code ) code , <NUM_LIT> , speed ) ) ; return true ; } * total = COSTS_N_INSNS ( <NUM_LIT> ) ; } else if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) != CONST_INT ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else { * 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_MPY ) * 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> ) , mode , PLUS , <NUM_LIT> , speed ) + rtx_cost ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) , mode , 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 ) ) {


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


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


<s> case V2HImode : return TARGET_PLUS_DMPY ; case V4HImode : case V2SImode : return TARGET_PLUS_QMACW ; case V4SImode : case V8HImode : return TARGET_SIMD_SET ; default : return false ;


<s> static void emit_unlikely_jump ( rtx insn ) {


<s> rtx_insn * jump = emit_jump_insn ( insn ) ;

add_int_reg_note ( jump , REG_BR_PROB , very_unlikely ) ;


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


<s> static void prepare_pic_move ( rtx * operands , machine_mode ) { if ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM && SYMBOLIC_CONST ( operands [ <NUM_LIT> ] ) && flag_pic ) operands [ <NUM_LIT> ] = force_reg ( Pmode , operands [ <NUM_LIT> ] ) ; else { rtx temp = ( reload_in_progress ? operands [ <NUM_LIT> ] : flag_pic ? gen_reg_rtx ( Pmode ) : NULL_RTX ) ;

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


<s> emit_insn_after ( gen_nopv ( ) , insn ) ; emit_insn_after ( gen_nopv ( ) , insn ) ; continue ; } succ1 = next_real_insn ( succ0 ) ; if ( succ0 && ! JUMP_P ( succ0 ) && ! CALL_P ( succ0 ) && arc_store_addr_hazard_p ( insn , succ1 ) ) emit_insn_after ( gen_nopv ( ) , insn ) ; } }


<s> static void arc_autovectorize_vector_sizes ( vector_sizes * sizes ) { if ( TARGET_PLUS_QMACW ) { sizes -> quick_push ( <NUM_LIT> ) ; sizes -> quick_push ( <NUM_LIT> ) ; }


<s> sizes -> quick_push ( <NUM_LIT> ) ; sizes -> quick_push ( <NUM_LIT> ) ;


<s> static rtx arc_builtin_setjmp_frame_value ( void ) { return gen_raw_REG ( Pmode , FRAME_POINTER_REGNUM ) ;


<s> static rtx arc_builtin_setjmp_frame_value ( void ) {

return gen_raw_REG ( Pmode , FRAME_POINTER_REGNUM ) ;


<s> return ( ( to == FRAME_POINTER_REGNUM ) || ! arc_frame_pointer_needed ( ) ) ;


<s> static bool arc_can_eliminate ( const int from ATTRIBUTE_UNUSED , const int to ) { return ( ( to == FRAME_POINTER_REGNUM ) || ! arc_frame_pointer_needed ( ) ) ;


<s> int size ; if ( cfun -> machine -> frame_info . initialized ) return cfun -> machine -> frame_info . total_size ; frame_info = & cfun -> machine -> frame_info ; size = ARC_STACK_ALIGN ( get_frame_size ( ) ) ; var_size = size ; args_size = crtl -> outgoing_args_size ; reg_size = <NUM_LIT> ; gmask = <NUM_LIT> ; for ( regno = <NUM_LIT> ; regno <= <NUM_LIT> ; regno ++ ) { if ( arc_must_save_register ( regno , cfun ) ) { reg_size += UNITS_PER_WORD ; gmask |= <NUM_LIT> << regno ; } } if ( crtl -> calls_eh_return ) for ( regno = <NUM_LIT> ; EH_RETURN_DATA_REGNO ( regno ) != INVALID_REGNUM ; regno ++ ) { reg_size += UNITS_PER_WORD ; gmask |= <NUM_LIT> << regno ; } frame_info -> save_return_addr = ( ! crtl -> is_leaf || df_regs_ever_live_p ( RETURN_ADDR_REGNUM ) || crtl -> calls_eh_return ) ; if ( optimize_size && ! TARGET_NO_MILLICODE_THUNK_SET && ! crtl -> calls_eh_return ) { if ( arc_compute_millicode_save_restore_regs ( gmask , frame_info ) ) frame_info -> save_return_addr = true ; } extra_size = <NUM_LIT> ; if ( arc_must_save_return_addr ( cfun ) ) extra_size = <NUM_LIT> ; if ( arc_frame_pointer_needed ( ) ) extra_size += <NUM_LIT> ; pretend_size = crtl -> args . pretend_args_size ; { unsigned int extra_plus_reg_size ; unsigned int extra_plus_reg_size_aligned ; extra_plus_reg_size = extra_size + reg_size ; extra_plus_reg_size_aligned = ARC_STACK_ALIGN ( extra_plus_reg_size ) ; reg_size = extra_plus_reg_size_aligned - extra_size ; } total_size = var_size + args_size + extra_size + pretend_size + reg_size ; gcc_assert ( total_size == ARC_STACK_ALIGN ( total_size ) ) ; reg_offset = ( total_size - ( pretend_size + reg_size + extra_size ) + ( arc_frame_pointer_needed ( ) ? <NUM_LIT> : <NUM_LIT> ) ) ; frame_info -> total_size = total_size ; frame_info -> extra_size = extra_size ; frame_info -> pretend_size = pretend_size ; frame_info -> var_size = var_size ; frame_info -> args_size = args_size ; frame_info -> reg_size = reg_size ; frame_info -> reg_offset = reg_offset ;


<s> value = TREE_VALUE ( args ) ; gcc_assert ( TREE_CODE ( value ) == STRING_CST ) ; if ( ! strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) || ! strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) ) fn_type |= ARC_FUNCTION_ILINK1 ; else if ( ! strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) ) fn_type |= ARC_FUNCTION_ILINK2 ; else if ( ! strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) ) fn_type |= ARC_FUNCTION_FIRQ ; else gcc_unreachable ( ) ; } return fun -> machine -> fn_type = fn_type ;


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

gcc_assert ( crtl -> calls_eh_return ) ;


<s> if ( reload_completed ) { if ( ARC_INTERRUPT_P ( cfun -> machine -> fn_type ) ) {

if ( ! fixed_regs [ regno ] ) return true ;


<s> if ( ! fixed_regs [ regno ] ) return true ; return ( ( regno == arc_return_address_register ( fn_type ) ) || ( regno == RETURN_ADDR_REGNUM ) ) ; } else return regno == RETURN_ADDR_REGNUM ;


<s> if ( ! can_trust_sp_p ) gcc_assert ( arc_frame_pointer_needed ( ) ) ; if ( frame_size ) { if ( arc_frame_pointer_needed ( ) ) frame_move ( stack_pointer_rtx , frame_pointer_rtx ) ; else first_offset = frame_size ; size_to_deallocate -= frame_size ; } else if ( ! can_trust_sp_p ) frame_stack_add ( - frame_size ) ; if ( arc_frame_pointer_needed ( ) && ! ARC_AUTOFP_IRQ_P ( fn_type ) ) { rtx addr = gen_rtx_POST_INC ( Pmode , stack_pointer_rtx ) ; insn = frame_move_inc ( frame_pointer_rtx , gen_frame_mem ( Pmode , addr ) , stack_pointer_rtx , <NUM_LIT> ) ; add_reg_note ( insn , REG_CFA_RESTORE , frame_pointer_rtx ) ; add_reg_note ( insn , REG_CFA_DEF_CFA , plus_constant ( SImode , stack_pointer_rtx , <NUM_LIT> ) ) ; size_to_deallocate -= UNITS_PER_WORD ; } if ( millicode_p ) { int sibthunk_p = ( ! sibcall_p && fn_type == ARC_FUNCTION_NORMAL && ! cfun -> machine -> frame_info . pretend_size ) ; gcc_assert ( ! ( cfun -> machine -> frame_info . gmask & ( FRAME_POINTER_MASK | RETURN_ADDR_MASK ) ) ) ; arc_save_restore ( stack_pointer_rtx , cfun -> machine -> frame_info . gmask , <NUM_LIT> + sibthunk_p , & first_offset ) ; if ( sibthunk_p ) return ; } 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 ) ) ) ) || ( arc_must_save_return_addr ( cfun ) && ! 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 ( arc_must_save_return_addr ( cfun ) && ! ARC_AUTOBLINK_IRQ_P ( fn_type ) ) { 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 ) ; HOST_WIDE_INT cfa_adjust = <NUM_LIT> ; 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> ;


<s> 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> ) { if ( TARGET_LL64 ) n_pieces = ( size + <NUM_LIT> ) / <NUM_LIT> + ( ( size >> <NUM_LIT> ) & <NUM_LIT> ) + ( size & <NUM_LIT> ) ; else 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 ( TARGET_LL64 && ( piece >= <NUM_LIT> ) && ( size >= <NUM_LIT> ) ) piece = <NUM_LIT> ; else 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> ) ;


<s> 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 ; while ( piece > size ) piece >>= <NUM_LIT> ; mode = smallest_int_mode_for_size ( piece * BITS_PER_UNIT ) ; 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 ) ;


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


<s> } if ( TREE_CODE ( * node ) == VAR_DECL ) { tree fntype = TREE_TYPE ( * node ) ; if ( fntype && TREE_CODE ( fntype ) == POINTER_TYPE ) { tree attrs = tree_cons ( get_identifier ( <STR_LIT> ) , NULL_TREE , TYPE_ATTRIBUTES ( fntype ) ) ; TYPE_ATTRIBUTES ( fntype ) = attrs ; } } }


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


<s> if ( from == ARG_POINTER_REGNUM && to == FRAME_POINTER_REGNUM ) { return ( cfun -> machine -> frame_info . extra_size + cfun -> machine -> frame_info . reg_size ) ; } 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 ) ) {


<s> if ( from == ARG_POINTER_REGNUM && to == STACK_POINTER_REGNUM ) { return ( cfun -> machine -> frame_info . total_size - cfun -> machine -> frame_info . pretend_size ) ; }


<s> struct mem_attrs * refattrs ; if ( ! MEM_P ( pat ) ) return false ; refattrs = MEM_ATTRS ( pat ) ; if ( ! refattrs || ! refattrs -> expr ) return false ; ttype = TREE_TYPE ( refattrs -> expr ) ; if ( ! ttype ) return false ; attrs = TYPE_ATTRIBUTES ( ttype ) ; if ( lookup_attribute ( <STR_LIT> , attrs ) ) return true ;


<s> if ( INSN_P ( next ) && recog_memoized ( next ) >= <NUM_LIT> ) return <NUM_LIT> ; }


<s> if ( align_labels_log < <NUM_LIT> ) {

rtx_insn * next = next_nonnote_nondebug_insn ( label ) ;


<s> } 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> gcc_assert ( CONST_INT_P ( addend ) ) ; HOST_WIDE_INT offset = INTVAL ( addend ) ; return ! ( offset > - <NUM_LIT> && offset < <NUM_LIT> ) ; } if ( ( GET_MODE_SIZE ( mode ) != <NUM_LIT> ) && CONSTANT_P ( x ) ) { return arc_legitimate_constant_p ( mode , x ) ; } 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 ; return false ;


<s> break ; case <NUM_LIT> : firq_auto_save_p &= ( ( regno < <NUM_LIT> ) || ( ( regno > <NUM_LIT> ) && ( regno < <NUM_LIT> ) ) || ( ( regno > <NUM_LIT> ) && ( regno < <NUM_LIT> ) ) || ( ( regno > <NUM_LIT> ) && ( regno < <NUM_LIT> ) ) ) ; break ; case <NUM_LIT> : firq_auto_save_p &= ( regno != <NUM_LIT> ) && ( regno < <NUM_LIT> ) ; break ; default : firq_auto_save_p = false ;


<s> int shift = <NUM_LIT> ; int this_regno = aggregate_value_p ( TREE_TYPE ( TREE_TYPE ( function ) ) , function ) ? <NUM_LIT> : <NUM_LIT> ; rtx fnaddr ; if ( mi_delta < <NUM_LIT> ) mi_delta = - mi_delta ; 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> ) ; if ( arc_is_longcall_p ( fnaddr ) ) { if ( flag_pic ) { asm_fprintf ( file , <STR_LIT> , ARC_TEMP_SCRATCH_REG ) ; assemble_name ( file , XSTR ( fnaddr , <NUM_LIT> ) ) ; fputs ( <STR_LIT> , file ) ; asm_fprintf ( file , <STR_LIT> , ARC_TEMP_SCRATCH_REG ) ; } else { fputs ( <STR_LIT> , file ) ; assemble_name ( file , XSTR ( fnaddr , <NUM_LIT> ) ) ; } }


else if ( to_class == LPCOUNT_REG ) return <NUM_LIT> ;


<s> else { rtx op , cc_clob_rtx , op0 , op1 , brcc_insn , note ; rtx cmp0 , cmp1 ; op = XEXP ( pc_target , <NUM_LIT> ) ; op0 = cmp0 = XEXP ( SET_SRC ( pat ) , <NUM_LIT> ) ; op1 = cmp1 = XEXP ( SET_SRC ( pat ) , <NUM_LIT> ) ; if ( GET_CODE ( op0 ) == ZERO_EXTRACT && XEXP ( op0 , <NUM_LIT> ) == const1_rtx && ( GET_CODE ( op ) == EQ || GET_CODE ( op ) == NE ) ) { op0 = XEXP ( cmp0 , <NUM_LIT> ) ; op1 = XEXP ( cmp0 , <NUM_LIT> ) ; } else if ( ! register_operand ( op0 , VOIDmode ) || ! general_operand ( op1 , VOIDmode ) ) continue ; else if ( TARGET_SPFP && GET_MODE ( op0 ) == SFmode && GET_MODE ( op1 ) == SFmode ) continue ; if ( reg_set_between_p ( op0 , link_insn , insn ) ) continue ; if ( reg_set_between_p ( op1 , link_insn , insn ) ) continue ; if ( ( reg_set_between_p ( SET_DEST ( pat ) , link_insn , insn ) ) || ( reg_used_between_p ( SET_DEST ( pat ) , link_insn , insn ) ) ) continue ; if ( ! find_regno_note ( insn , REG_DEAD , CC_REG ) ) continue ; op = gen_rtx_fmt_ee ( GET_CODE ( op ) , GET_MODE ( op ) , cmp0 , cmp1 ) ; if ( ! brcc_nolimm_operator ( op , VOIDmode ) && ! long_immediate_operand ( op1 , VOIDmode ) && ( TARGET_ARC700 || next_active_insn ( link_insn ) != insn ) ) continue ; if ( op0 != cmp0 ) cc_clob_rtx = gen_rtx_REG ( CC_ZNmode , CC_REG ) ; else if ( ( offset >= - <NUM_LIT> && offset < <NUM_LIT> ) && rtx_equal_p ( op1 , const0_rtx ) && compact_register_operand ( op0 , VOIDmode ) && ( GET_CODE ( op ) == EQ || GET_CODE ( op ) == NE ) ) cc_clob_rtx = gen_rtx_REG ( CC_Zmode , CC_REG ) ; else cc_clob_rtx = gen_rtx_REG ( CCmode , CC_REG ) ; brcc_insn = gen_rtx_IF_THEN_ELSE ( VOIDmode , op , label , pc_rtx ) ; brcc_insn = gen_rtx_SET ( pc_rtx , brcc_insn ) ; cc_clob_rtx = gen_rtx_CLOBBER ( VOIDmode , cc_clob_rtx ) ; brcc_insn = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , brcc_insn , cc_clob_rtx ) ) ; brcc_insn = emit_jump_insn_before ( brcc_insn , insn ) ; JUMP_LABEL ( brcc_insn ) = JUMP_LABEL ( insn ) ; note = find_reg_note ( insn , REG_BR_PROB , <NUM_LIT> ) ; if ( note ) { XEXP ( note , <NUM_LIT> ) = REG_NOTES ( brcc_insn ) ; REG_NOTES ( brcc_insn ) = note ;


<s> if ( ( ( fn_type & ARC_FUNCTION_ILINK1 ) | ARC_FUNCTION_FIRQ ) != <NUM_LIT> ) regno = ILINK1_REGNUM ; else if ( ( fn_type & ARC_FUNCTION_ILINK2 ) != <NUM_LIT> ) regno = ILINK2_REGNUM ; else gcc_unreachable ( ) ;


<s> rtx arc_rewrite_small_data ( rtx op ) { op = arc_rewrite_small_data_1 ( op ) ; if ( MEM_P ( op ) && ! LEGITIMATE_SMALL_DATA_ADDRESS_P ( XEXP ( op , <NUM_LIT> ) ) ) { rtx addr = XEXP ( op , <NUM_LIT> ) ; rtx tmp = gen_reg_rtx ( Pmode ) ; emit_move_insn ( tmp , addr ) ; op = replace_equiv_address_nv ( op , tmp ) ; } return op ;


<s> iter . skip_subrtxes ( ) ; } else if ( GET_CODE ( * loc ) == PLUS && rtx_equal_p ( XEXP ( * loc , <NUM_LIT> ) , rgp ) ) iter . skip_subrtxes ( ) ; }


<s> rtx addr = NULL_RTX ; x = SUBREG_REG ( x ) ; if ( REG_P ( x ) ) { int regno = REGNO ( x ) ; if ( regno >= FIRST_PSEUDO_REGISTER ) regno = reg_renumber [ regno ] ; if ( regno != - <NUM_LIT> ) return NO_REGS ; if ( reg_equiv_mem ( REGNO ( x ) ) ) { rtx mem = reg_equiv_mem ( REGNO ( x ) ) ; addr = find_replacement ( & XEXP ( mem , <NUM_LIT> ) ) ; } } else { gcc_assert ( MEM_P ( x ) ) ; addr = XEXP ( x , <NUM_LIT> ) ; addr = simplify_rtx ( addr ) ; } if ( addr && GET_CODE ( addr ) == PLUS && CONST_INT_P ( XEXP ( addr , <NUM_LIT> ) ) && ( ! RTX_OK_FOR_OFFSET_P ( mode , XEXP ( addr , <NUM_LIT> ) ) ) ) { switch ( mode ) { case E_QImode : sri -> icode = in_p ? CODE_FOR_reload_qi_load : CODE_FOR_reload_qi_store ;


<s> machine = cfun -> machine ; if ( machine -> force_short_suffix >= <NUM_LIT> ) return machine -> force_short_suffix ; return ( get_attr_length ( insn ) & <NUM_LIT> ) != <NUM_LIT> ;


<s> static int arc_verify_short ( rtx_insn * insn , int , int check_attr ) { 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> size = GET_MODE_SIZE ( mode ) ; if ( size > UNITS_PER_WORD ) return false ; addr = XEXP ( op , <NUM_LIT> ) ; if ( ! LEGITIMATE_SMALL_DATA_ADDRESS_P ( addr ) ) return false ; if ( ! short_p || size == <NUM_LIT> ) return true ; if ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == SYMBOL_REF ) decl = SYMBOL_REF_DECL ( XEXP ( addr , <NUM_LIT> ) ) ; else if ( GET_CODE ( XEXP ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF ) decl = SYMBOL_REF_DECL ( XEXP ( XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) , <NUM_LIT> ) ) ; if ( decl ) align = DECL_ALIGN ( decl ) ; align = align / BITS_PER_UNIT ; switch ( mode ) { case E_HImode : mask = <NUM_LIT> ; break ; default : mask = <NUM_LIT> ;


<s> FOR_EACH_SUBRTX ( iter , array , op , ALL ) { const_rtx x = * iter ;

if ( GET_CODE ( x ) == PLUS && rtx_equal_p ( XEXP ( x , <NUM_LIT> ) , rgp ) ) iter . skip_subrtxes ( ) ;


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


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


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


<s> static void parse_mrgf_banked_regs_option ( const char * arg ) { long int val ; char * end_ptr ; errno = <NUM_LIT> ; val = strtol ( arg , & end_ptr , <NUM_LIT> ) ; if ( errno != <NUM_LIT> || * arg == '\0' || * end_ptr != '\0' || ( val != <NUM_LIT> && val != <NUM_LIT> && val != <NUM_LIT> && val != <NUM_LIT> && val != <NUM_LIT> ) ) { error ( <STR_LIT> <STR_LIT> , arg ) ;


<s> val = strtol ( arg , & end_ptr , <NUM_LIT> ) ; if ( errno != <NUM_LIT> || * arg == '\0' || * end_ptr != '\0' || ( val != <NUM_LIT> && val != <NUM_LIT> && val != <NUM_LIT> && val != <NUM_LIT> && val != <NUM_LIT> ) ) { error ( <STR_LIT> <STR_LIT> , arg ) ;


<s> tmp = XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ; } operands [ <NUM_LIT> ] = force_reg ( SImode , operands [ <NUM_LIT> ] ) ; emit_insn ( gen_rtx_UNSPEC_VOLATILE ( VOIDmode , gen_rtvec ( <NUM_LIT> , operands [ <NUM_LIT> ] , tmp ) , VUNSPEC_ARC_SR ) ) ; return true ; } if ( MEM_P ( operands [ <NUM_LIT> ] ) && arc_is_aux_reg_p ( operands [ <NUM_LIT> ] ) ) { if ( arc_get_aux_arg ( operands [ <NUM_LIT> ] , & auxr ) ) { tmp = gen_reg_rtx ( SImode ) ; emit_move_insn ( tmp , GEN_INT ( auxr ) ) ; } else { tmp = XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ; gcc_assert ( GET_CODE ( tmp ) == SYMBOL_REF ) ; } gcc_assert ( REG_P ( operands [ <NUM_LIT> ] ) ) ; emit_insn ( gen_rtx_SET ( operands [ <NUM_LIT> ] , gen_rtx_UNSPEC_VOLATILE ( SImode , gen_rtvec ( <NUM_LIT> , tmp ) , VUNSPEC_ARC_LR ) ) ) ; return true ; } } if ( ! TARGET_NO_SDATA_SET && small_data_pattern ( operands [ <NUM_LIT> ] , Pmode ) ) operands [ <NUM_LIT> ] = arc_rewrite_small_data ( operands [ <NUM_LIT> ] ) ; if ( mode == SImode && SYMBOLIC_CONST ( operands [ <NUM_LIT> ] ) ) { prepare_pic_move ( operands , SImode ) ; } 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 ( 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 ) {


<s> if ( ! TARGET_NO_SDATA_SET && small_data_pattern ( operands [ <NUM_LIT> ] , Pmode ) ) operands [ <NUM_LIT> ] = arc_rewrite_small_data ( operands [ <NUM_LIT> ] ) ; if ( mode == SImode && SYMBOLIC_CONST ( operands [ <NUM_LIT> ] ) ) { prepare_pic_move ( operands , SImode ) ; } 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 ( 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 ; }


<s> static rtx arc_builtin_setjmp_frame_value ( void ) {

return gen_raw_REG ( Pmode , HARD_FRAME_POINTER_REGNUM ) ;


<s> if ( cfun -> machine -> frame_info . initialized ) return cfun -> machine -> frame_info . total_size ; frame_info = & cfun -> machine -> frame_info ; size = ARC_STACK_ALIGN ( get_frame_size ( ) ) ; var_size = size ; args_size = crtl -> outgoing_args_size ; reg_size = <NUM_LIT> ; gmask = <NUM_LIT> ; for ( regno = <NUM_LIT> ; regno <= <NUM_LIT> ; regno ++ ) { if ( arc_must_save_register ( regno , cfun ) ) { reg_size += UNITS_PER_WORD ; gmask |= <NUM_LIT> << regno ; } } if ( crtl -> calls_eh_return ) for ( regno = <NUM_LIT> ; EH_RETURN_DATA_REGNO ( regno ) != INVALID_REGNUM ; regno ++ ) { reg_size += UNITS_PER_WORD ; gmask |= <NUM_LIT> << regno ; } frame_info -> save_return_addr = ( ! crtl -> is_leaf || df_regs_ever_live_p ( RETURN_ADDR_REGNUM ) || crtl -> calls_eh_return ) ; if ( TARGET_MILLICODE_THUNK_SET && ! crtl -> calls_eh_return ) { if ( arc_compute_millicode_save_restore_regs ( gmask , frame_info ) ) frame_info -> save_return_addr = true ; } extra_size = <NUM_LIT> ; if ( arc_must_save_return_addr ( cfun ) ) extra_size = <NUM_LIT> ;

if ( arc_frame_pointer_needed ( ) ) extra_size += <NUM_LIT> ;


<s> for ( i = R16_REG ; i <= R25_REG ; i ++ ) fixed_regs [ i ] = call_used_regs [ i ] = <NUM_LIT> ; } if ( TARGET_HS ) for ( regno = R1_REG ; regno < R32_REG ; regno += <NUM_LIT> ) arc_hard_regno_modes [ regno ] = S_MODES ; for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( i < ILINK1_REG ) { if ( ( TARGET_Q_CLASS || TARGET_RRQ_CLASS ) && ( ( i <= R3_REG ) || ( ( i >= R12_REG ) && ( i <= R15_REG ) ) ) ) arc_regno_reg_class [ i ] = ARCOMPACT16_REGS ; else arc_regno_reg_class [ i ] = GENERAL_REGS ; } else if ( i < LP_COUNT ) arc_regno_reg_class [ i ] = GENERAL_REGS ; else arc_regno_reg_class [ i ] = NO_REGS ; arc_regno_reg_class [ CC_REG ] = NO_REGS ; arc_regno_reg_class [ FRAME_POINTER_REGNUM ] = GENERAL_REGS ; arc_regno_reg_class [ ARG_POINTER_REGNUM ] = GENERAL_REGS ; if ( TARGET_DPFP ) for ( i = R40_REG ; i < R44_REG ; ++ i ) { arc_regno_reg_class [ i ] = DOUBLE_REGS ; if ( ! TARGET_ARGONAUT_SET ) CLEAR_HARD_REG_BIT ( reg_class_contents [ GENERAL_REGS ] , i ) ; } else { arc_regno_reg_class [ R40_REG ] = ALL_REGS ; arc_regno_reg_class [ R41_REG ] = ALL_REGS ; arc_regno_reg_class [ R42_REG ] = ALL_REGS ; arc_regno_reg_class [ R43_REG ] = ALL_REGS ; fixed_regs [ R40_REG ] = <NUM_LIT> ; fixed_regs [ R41_REG ] = <NUM_LIT> ; fixed_regs [ R42_REG ] = <NUM_LIT> ; fixed_regs [ R43_REG ] = <NUM_LIT> ; arc_hard_regno_modes [ R40_REG ] = <NUM_LIT> ; arc_hard_regno_modes [ R42_REG ] = <NUM_LIT> ; } if ( TARGET_SIMD_SET ) { gcc_assert ( ARC_FIRST_SIMD_VR_REG == <NUM_LIT> ) ; gcc_assert ( ARC_LAST_SIMD_VR_REG == <NUM_LIT> ) ; for ( i = ARC_FIRST_SIMD_VR_REG ; i <= ARC_LAST_SIMD_VR_REG ; i ++ ) arc_regno_reg_class [ i ] = SIMD_VR_REGS ; gcc_assert ( ARC_FIRST_SIMD_DMA_CONFIG_REG == <NUM_LIT> ) ; gcc_assert ( ARC_FIRST_SIMD_DMA_CONFIG_IN_REG == <NUM_LIT> ) ; gcc_assert ( ARC_FIRST_SIMD_DMA_CONFIG_OUT_REG == <NUM_LIT> ) ; gcc_assert ( ARC_LAST_SIMD_DMA_CONFIG_REG == <NUM_LIT> ) ; for ( i = ARC_FIRST_SIMD_DMA_CONFIG_REG ; i <= ARC_LAST_SIMD_DMA_CONFIG_REG ; i ++ ) arc_regno_reg_class [ i ] = SIMD_DMA_CONFIG_REGS ; } arc_regno_reg_class [ PCL_REG ] = NO_REGS ;

if ( ( TARGET_V2 && ( TARGET_FP_DP_FUSED || TARGET_FP_SP_FUSED ) ) || TARGET_PLUS_DMPY ) {


<s> static bool arc_enter_leave_p ( unsigned int gmask ) { int regno ; unsigned int rmask = <NUM_LIT> ; if ( ! gmask ) return false ; for ( regno = ENTER_LEAVE_START_REG ; regno <= ENTER_LEAVE_END_REG && ( gmask & ( <NUM_LIT> << regno ) ) ; regno ++ ) rmask |= <NUM_LIT> << regno ; if ( rmask ^ gmask ) return false ; return true ;


<s> if ( ! gmask ) return false ; for ( regno = ENTER_LEAVE_START_REG ; regno <= ENTER_LEAVE_END_REG && ( gmask & ( <NUM_LIT> << regno ) ) ; regno ++ ) rmask |= <NUM_LIT> << regno ; if ( rmask ^ gmask ) return false ;


<s> int can_trust_sp_p = ! cfun -> calls_alloca ; int first_offset ; bool restore_fp = arc_frame_pointer_needed ( ) && ! ARC_AUTOFP_IRQ_P ( fn_type ) ; bool restore_blink = arc_must_save_return_addr ( cfun ) && ! ARC_AUTOBLINK_IRQ_P ( fn_type ) ; unsigned int gmask = cfun -> machine -> frame_info . gmask ; bool return_p = ! sibcall_p && fn_type == ARC_FUNCTION_NORMAL && ! cfun -> machine -> frame_info . pretend_size ; struct arc_frame_info * frame = & cfun -> machine -> frame_info ; 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 ( TARGET_CODE_DENSITY && TARGET_CODE_DENSITY_FRAME && ! ARC_AUTOFP_IRQ_P ( fn_type ) && ! ARC_AUTOBLINK_IRQ_P ( fn_type ) && ! ARC_INTERRUPT_P ( fn_type ) && arc_enter_leave_p ( gmask ) ) { size_to_deallocate -= arc_restore_callee_leave ( gmask , restore_blink , restore_fp , return_p , first_offset ) ; if ( return_p ) { gcc_assert ( size_to_deallocate == <NUM_LIT> ) ; return ; } } else if ( frame -> millicode_end_reg > <NUM_LIT> ) { size_to_deallocate -= arc_restore_callee_milli ( gmask , restore_blink , restore_fp , return_p , first_offset ) ; if ( return_p ) { gcc_assert ( size_to_deallocate == <NUM_LIT> ) ; return ; }


<s> if ( TARGET_CODE_DENSITY && TARGET_CODE_DENSITY_FRAME && ! ARC_AUTOFP_IRQ_P ( fn_type ) && ! ARC_AUTOBLINK_IRQ_P ( fn_type ) && ! ARC_INTERRUPT_P ( fn_type ) && arc_enter_leave_p ( gmask ) ) { size_to_deallocate -= arc_restore_callee_leave ( gmask , restore_blink , restore_fp , return_p , first_offset ) ; if ( return_p ) { gcc_assert ( size_to_deallocate == <NUM_LIT> ) ; return ; } } else if ( frame -> millicode_end_reg > <NUM_LIT> ) { size_to_deallocate -= arc_restore_callee_milli ( gmask , restore_blink , restore_fp , return_p , first_offset ) ; if ( return_p ) { gcc_assert ( size_to_deallocate == <NUM_LIT> ) ; return ; }


<s> frame_size_to_allocate = size ; gcc_assert ( ! ( size == <NUM_LIT> && gmask ) ) ; if ( frame -> pretend_size != <NUM_LIT> ) first_offset = - frame -> pretend_size ; if ( ARC_AUTO_IRQ_P ( fn_type ) && ! ARC_FAST_INTERRUPT_P ( fn_type ) ) { frame_stack_add ( first_offset ) ; first_offset = <NUM_LIT> ; arc_dwarf_emit_irq_save_regs ( ) ; } save_blink = arc_must_save_return_addr ( cfun ) && ! ARC_AUTOBLINK_IRQ_P ( fn_type ) ; save_fp = arc_frame_pointer_needed ( ) && ! ARC_AUTOFP_IRQ_P ( fn_type ) ; if ( TARGET_CODE_DENSITY && TARGET_CODE_DENSITY_FRAME && ! ARC_AUTOFP_IRQ_P ( fn_type ) && ! ARC_AUTOBLINK_IRQ_P ( fn_type ) && ! ARC_INTERRUPT_P ( fn_type ) && arc_enter_leave_p ( gmask ) ) frame_size_to_allocate -= arc_save_callee_enter ( gmask , save_blink , save_fp , first_offset ) ; else if ( frame -> millicode_end_reg > <NUM_LIT> ) frame_size_to_allocate -= arc_save_callee_milli ( gmask , save_blink , save_fp , first_offset , frame -> reg_size ) ; else frame_size_to_allocate -= arc_save_callee_saves ( gmask , save_blink , save_fp , first_offset ) ; if ( frame_size_to_allocate > <NUM_LIT> ) frame_stack_add ( ( HOST_WIDE_INT ) <NUM_LIT> - frame_size_to_allocate ) ;


<s> 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> arc_multcost = COSTS_N_INSNS ( <NUM_LIT> ) ; if ( TARGET_NOMPY_SET ) arc_multcost = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case ARC_TUNE_ARC700_4_2_XMAC : arc_multcost = COSTS_N_INSNS ( <NUM_LIT> ) ; if ( TARGET_NOMPY_SET ) arc_multcost = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case ARC_TUNE_ARC600 : if ( TARGET_MUL64_SET ) { arc_multcost = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; } default : arc_multcost = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; } if ( TARGET_NOMPY_SET && TARGET_ARC600_FAMILY ) error ( <STR_LIT> ) ; if ( ! TARGET_DPFP && TARGET_DPFP_DISABLE_LRSR ) error ( <STR_LIT> ) ; if ( ( TARGET_DPFP_FAST_SET && TARGET_DPFP_COMPACT_SET ) || ( TARGET_SPFP_FAST_SET && TARGET_SPFP_COMPACT_SET ) ) error ( <STR_LIT> ) ; if ( TARGET_SPFP_FAST_SET && TARGET_ARC600_FAMILY ) error ( <STR_LIT> ) ; if ( ( TARGET_DPFP_FAST_SET || TARGET_DPFP_COMPACT_SET || TARGET_SPFP ) && TARGET_HARD_FLOAT ) error ( <STR_LIT> ) ; if ( flag_pic && TARGET_ARC600_FAMILY ) { warning ( <NUM_LIT> , <STR_LIT> , arc_cpu_string ) ; flag_pic = <NUM_LIT> ; } arc_init_reg_tables ( ) ; memset ( arc_punct_chars , <NUM_LIT> , sizeof ( arc_punct_chars ) ) ; arc_punct_chars [ '#' ] = <NUM_LIT> ; arc_punct_chars [ '*' ] = <NUM_LIT> ; arc_punct_chars [ '?' ] = <NUM_LIT> ; arc_punct_chars [ '!' ] = <NUM_LIT> ; arc_punct_chars [ '^' ] = <NUM_LIT> ; arc_punct_chars [ '&' ] = <NUM_LIT> ; arc_punct_chars [ '+' ] = <NUM_LIT> ; arc_punct_chars [ '_' ] = <NUM_LIT> ;

if ( optimize > <NUM_LIT> && ! TARGET_NO_COND_EXEC ) {


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


<s> if ( ( GET_MODE_SIZE ( mode ) != <NUM_LIT> ) && CONSTANT_P ( x ) ) { return arc_legitimate_constant_p ( mode , x ) ; } 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> HOST_WIDE_INT offset = INTVAL ( addend ) ; return ! ( offset > - <NUM_LIT> && offset < <NUM_LIT> ) ; } if ( ( GET_MODE_SIZE ( mode ) != <NUM_LIT> ) && CONSTANT_P ( x ) ) { return arc_legitimate_constant_p ( mode , x ) ; } 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> bool firq_auto_save_p = ARC_FAST_INTERRUPT_P ( fn_type ) ; switch ( rgf_banked_register_count ) { case <NUM_LIT> : firq_auto_save_p &= ( regno < <NUM_LIT> ) ; break ; case <NUM_LIT> : firq_auto_save_p &= ( ( regno < <NUM_LIT> ) || ( ( regno > <NUM_LIT> ) && ( regno < <NUM_LIT> ) ) ) ; break ; case <NUM_LIT> :

firq_auto_save_p &= ( ( regno < <NUM_LIT> ) || ( ( regno > <NUM_LIT> ) && ( regno < <NUM_LIT> ) ) || ( ( regno > <NUM_LIT> ) && ( regno < <NUM_LIT> ) ) || ( ( regno > <NUM_LIT> ) && ( regno < <NUM_LIT> ) ) ) ;


<s> reg = gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , offset + nregs * UNITS_PER_WORD ) ) ; RTX_FRAME_RELATED_P ( reg ) = <NUM_LIT> ; XVECEXP ( insn , <NUM_LIT> , indx ++ ) = reg ; off = nregs * UNITS_PER_WORD ; if ( restore_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 ( reg , mem ) ; RTX_FRAME_RELATED_P ( XVECEXP ( insn , <NUM_LIT> , indx ++ ) ) = <NUM_LIT> ; off -= UNITS_PER_WORD ; } 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 ( reg , mem ) ; RTX_FRAME_RELATED_P ( XVECEXP ( insn , <NUM_LIT> , indx ) ) = <NUM_LIT> ; gmask = gmask & ~ ( <NUM_LIT> << regno ) ; } if ( restore_fp ) { mem = gen_frame_mem ( Pmode , plus_constant ( Pmode , stack_pointer_rtx , off ) ) ; XVECEXP ( insn , <NUM_LIT> , indx ) = gen_rtx_SET ( hard_frame_pointer_rtx , mem ) ; RTX_FRAME_RELATED_P ( XVECEXP ( insn , <NUM_LIT> , indx ++ ) ) = <NUM_LIT> ; off -= UNITS_PER_WORD ; } gcc_assert ( off == <NUM_LIT> ) ; if ( return_p ) { insn = emit_jump_insn ( insn ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } else insn = frame_insn ( insn ) ; add_reg_note ( insn , REG_INC , stack_pointer_rtx ) ; if ( restore_fp ) { add_reg_note ( insn , REG_CFA_RESTORE , hard_frame_pointer_rtx ) ; add_reg_note ( insn , REG_CFA_DEF_CFA , plus_constant ( Pmode , stack_pointer_rtx , offset + nregs * UNITS_PER_WORD ) ) ; } else { add_reg_note ( insn , REG_CFA_ADJUST_CFA , gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , nregs * UNITS_PER_WORD ) ) ) ;


<s> regno <= end_reg ; regno ++ , indx ++ , off += UNITS_PER_WORD ) { reg = gen_rtx_REG ( SImode , regno ) ; mem = gen_frame_mem ( SImode , plus_constant ( Pmode , stack_pointer_rtx , off ) ) ; XVECEXP ( insn , <NUM_LIT> , indx ) = gen_rtx_SET ( reg , mem ) ; RTX_FRAME_RELATED_P ( XVECEXP ( insn , <NUM_LIT> , indx ) ) = <NUM_LIT> ; gmask = gmask & ~ ( <NUM_LIT> << regno ) ; } for ( regno = <NUM_LIT> ; regno <= <NUM_LIT> ; regno ++ ) { if ( ( gmask & ( <NUM_LIT> << regno ) ) == <NUM_LIT> ) continue ; reg = gen_rtx_REG ( SImode , regno ) ; mem = gen_frame_mem ( SImode , plus_constant ( Pmode , stack_pointer_rtx , off ) ) ; rtx tmp = frame_move_inc ( reg , mem , stack_pointer_rtx , <NUM_LIT> ) ; add_reg_note ( tmp , REG_CFA_RESTORE , reg ) ; off += UNITS_PER_WORD ; } if ( return_p ) { reg = gen_rtx_REG ( Pmode , <NUM_LIT> ) ; frame_insn ( gen_rtx_SET ( reg , GEN_INT ( off ) ) ) ; frame_allocated += off ; insn = emit_jump_insn ( insn ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } else insn = frame_insn ( insn ) ; for ( regno = start_reg ; regno <= end_reg ; regno ++ ) { reg = gen_rtx_REG ( SImode , regno ) ; add_reg_note ( insn , REG_CFA_RESTORE , reg ) ; } if ( restore_blink && ! return_p ) { reg = gen_rtx_REG ( Pmode , RETURN_ADDR_REGNUM ) ; mem = gen_frame_mem ( Pmode , plus_constant ( Pmode , stack_pointer_rtx , off ) ) ; insn = frame_insn ( gen_rtx_SET ( reg , mem ) ) ; add_reg_note ( insn , REG_CFA_RESTORE , reg ) ;


<s> HOST_WIDE_INT offs = cfun -> machine -> frame_info . reg_size ; bool early_blink_restore ; if ( arc_frame_pointer_needed ( ) && offset ) { frame_move ( stack_pointer_rtx , hard_frame_pointer_rtx ) ; frame_deallocated += offset ; offset = <NUM_LIT> ; } if ( restore_fp ) { gcc_assert ( offset == <NUM_LIT> ) ; frame_deallocated += frame_restore_reg ( hard_frame_pointer_rtx , <NUM_LIT> ) ; } if ( offset ) { frame_stack_add ( offset ) ; frame_deallocated += offset ; offset = <NUM_LIT> ; } early_blink_restore = restore_blink && ! optimize_size && offs ; if ( early_blink_restore ) { rtx addr = plus_constant ( Pmode , stack_pointer_rtx , offs ) ; reg = gen_rtx_REG ( Pmode , RETURN_ADDR_REGNUM ) ; rtx insn = frame_move_inc ( reg , gen_frame_mem ( Pmode , addr ) , stack_pointer_rtx , NULL_RTX ) ; add_reg_note ( insn , REG_CFA_RESTORE , reg ) ; restore_blink = false ; } if ( gmask ) for ( int i = <NUM_LIT> ; i <= GMASK_LEN ; i ++ ) { machine_mode restore_mode = SImode ; if ( TARGET_LL64 && ( ( i % <NUM_LIT> ) == <NUM_LIT> ) && ( ( gmask & ( <NUM_LIT> << i ) ) != <NUM_LIT> ) && ( ( gmask & ( <NUM_LIT> << ( i + <NUM_LIT> ) ) ) != <NUM_LIT> ) ) restore_mode = DImode ; else if ( ( gmask & ( <NUM_LIT> << i ) ) == <NUM_LIT> ) continue ; reg = gen_rtx_REG ( restore_mode , i ) ; offs = <NUM_LIT> ; switch ( restore_mode ) { case E_DImode : if ( ( GMASK_LEN - __builtin_clz ( gmask ) ) == ( i + <NUM_LIT> ) && early_blink_restore ) offs = <NUM_LIT> ; break ; case E_SImode : if ( ( GMASK_LEN - __builtin_clz ( gmask ) ) == i && early_blink_restore ) offs = <NUM_LIT> ; break ; default : offs = <NUM_LIT> ; } frame_deallocated += frame_restore_reg ( reg , offs ) ;


<s> gcc_assert ( offset == <NUM_LIT> ) ; frame_deallocated += frame_restore_reg ( hard_frame_pointer_rtx , <NUM_LIT> ) ; } if ( offset ) { frame_stack_add ( offset ) ; frame_deallocated += offset ; offset = <NUM_LIT> ; } early_blink_restore = restore_blink && ! optimize_size && offs ; if ( early_blink_restore ) { rtx addr = plus_constant ( Pmode , stack_pointer_rtx , offs ) ; reg = gen_rtx_REG ( Pmode , RETURN_ADDR_REGNUM ) ; rtx insn = frame_move_inc ( reg , gen_frame_mem ( Pmode , addr ) , stack_pointer_rtx , NULL_RTX ) ; add_reg_note ( insn , REG_CFA_RESTORE , reg ) ; restore_blink = false ; } if ( gmask ) for ( int i = <NUM_LIT> ; i <= GMASK_LEN ; i ++ ) { machine_mode restore_mode = SImode ; if ( TARGET_LL64 && ( ( i % <NUM_LIT> ) == <NUM_LIT> ) && ( ( gmask & ( <NUM_LIT> << i ) ) != <NUM_LIT> ) && ( ( gmask & ( <NUM_LIT> << ( i + <NUM_LIT> ) ) ) != <NUM_LIT> ) ) restore_mode = DImode ; else if ( ( gmask & ( <NUM_LIT> << i ) ) == <NUM_LIT> ) continue ; reg = gen_rtx_REG ( restore_mode , i ) ;


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


<s> else gcc_unreachable ( ) ; } else if ( ARC_NORMAL_P ( fn_type ) || ARC_NAKED_P ( fn_type ) ) regno = RETURN_ADDR_REGNUM ;


<s> int start_reg = ENTER_LEAVE_START_REG ; int end_reg = ENTER_LEAVE_END_REG ; 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 ;


<s> int end_reg = <NUM_LIT> ; 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> ; gcc_assert ( end_reg > <NUM_LIT> ) ; if ( save_blink ) { reg = gen_rtx_REG ( Pmode , RETURN_ADDR_REGNUM ) ; frame_allocated += frame_save_reg ( reg , offset ) ; offset = <NUM_LIT> ; } if ( reg_size || offset ) { frame_stack_add ( offset - reg_size ) ; frame_allocated += nregs * UNITS_PER_WORD - offset ; offset = <NUM_LIT> ; } insn = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( nregs + <NUM_LIT> ) ) ; indx = <NUM_LIT> ; XVECEXP ( insn , <NUM_LIT> , nregs ) = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( Pmode , RETURN_ADDR_REGNUM ) ) ; for ( regno = start_reg , indx = <NUM_LIT> , off = <NUM_LIT> ; regno <= end_reg ; regno ++ , indx ++ , off += UNITS_PER_WORD ) { reg = gen_rtx_REG ( SImode , regno ) ; mem = gen_frame_mem ( SImode , plus_constant ( Pmode , stack_pointer_rtx , off ) ) ; XVECEXP ( insn , <NUM_LIT> , indx ) = gen_rtx_SET ( mem , reg ) ;

RTX_FRAME_RELATED_P ( XVECEXP ( insn , <NUM_LIT> , indx ) ) = <NUM_LIT> ;


<s> RTX_FRAME_RELATED_P ( XVECEXP ( insn , <NUM_LIT> , indx ) ) = <NUM_LIT> ; gmask = gmask & ~ ( <NUM_LIT> << regno ) ; } insn = frame_insn ( insn ) ; for ( regno = start_reg , off = <NUM_LIT> ; regno <= end_reg ; regno ++ , off += UNITS_PER_WORD ) { reg = gen_rtx_REG ( SImode , regno ) ; mem = gen_rtx_MEM ( SImode , plus_constant ( Pmode , stack_pointer_rtx , off ) ) ; add_reg_note ( insn , REG_CFA_OFFSET , gen_rtx_SET ( mem , reg ) ) ; } if ( arc_must_save_return_addr ( cfun ) ) { emit_insn ( gen_rtx_SET ( gen_rtx_REG ( Pmode , RETURN_ADDR_REGNUM ) , gen_rtx_MEM ( Pmode , plus_constant ( Pmode , stack_pointer_rtx , reg_size ) ) ) ) ; } for ( regno = <NUM_LIT> ; regno <= <NUM_LIT> ; regno ++ ) {

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


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

frame_allocated += frame_save_reg ( hard_frame_pointer_rtx , offset ) ;