<s> if ( num_regs == <NUM_LIT> && ! arm_arch6 ) { if ( first_reg == <NUM_LIT> ) first_reg -- ; num_regs ++ ; } if ( num_regs > <NUM_LIT> ) { arm_emit_vfp_multi_reg_pop ( first_reg , <NUM_LIT> , base_reg ) ; arm_emit_vfp_multi_reg_pop ( first_reg + <NUM_LIT> , num_regs - <NUM_LIT> , base_reg ) ; return ; } par = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( num_regs + <NUM_LIT> ) ) ; tmp = gen_rtx_SET ( VOIDmode , base_reg , plus_constant ( Pmode , base_reg , <NUM_LIT> * num_regs ) ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = tmp ; for ( j = <NUM_LIT> , i = first_reg ; j < num_regs ; i += <NUM_LIT> ) { reg = gen_rtx_REG ( DFmode , i ) ; tmp = gen_rtx_SET ( VOIDmode , reg , gen_frame_mem ( DFmode , plus_constant ( Pmode , base_reg , <NUM_LIT> * j ) ) ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( par , <NUM_LIT> , j + <NUM_LIT> ) = tmp ; dwarf = alloc_reg_note ( REG_CFA_RESTORE , reg , dwarf ) ; j ++ ; } par = emit_insn ( par ) ; REG_NOTES ( par ) = dwarf ; if ( TARGET_VFP && REGNO ( base_reg ) == IP_REGNUM ) { RTX_FRAME_RELATED_P ( par ) = <NUM_LIT> ;

add_reg_note ( par , REG_CFA_DEF_CFA , hard_frame_pointer_rtx ) ;


XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = tmp ;


<s> static bool arm_evpc_neon_vext ( struct expand_vec_perm_d * d ) { unsigned int i , nelt = d -> nelt ; rtx ( * gen ) ( rtx , rtx , rtx , rtx ) ; rtx offset ; unsigned int location ; unsigned int next = d -> perm [ <NUM_LIT> ] + <NUM_LIT> ; if ( BYTES_BIG_ENDIAN ) return false ; for ( i = <NUM_LIT> ; i < nelt ; next ++ , i ++ ) { if ( next == <NUM_LIT> * nelt ) return false ; if ( d -> one_vector_p && ( next == nelt ) ) { if ( ( nelt == <NUM_LIT> ) && ( d -> vmode != V2DImode ) ) return false ; else next = <NUM_LIT> ; } if ( d -> perm [ i ] != next ) return false ; } location = d -> perm [ <NUM_LIT> ] ; switch ( d -> vmode ) { case V16QImode : gen = gen_neon_vextv16qi ; break ; case V8QImode : gen = gen_neon_vextv8qi ; break ; case V4HImode : gen = gen_neon_vextv4hi ; break ; case V8HImode : gen = gen_neon_vextv8hi ; break ; case V2SImode : gen = gen_neon_vextv2si ; break ; case V4SImode : gen = gen_neon_vextv4si ; break ; case V2SFmode : gen = gen_neon_vextv2sf ; break ; case V4SFmode : gen = gen_neon_vextv4sf ; break ; case V2DImode : gen = gen_neon_vextv2di ; break ; default : return false ; } if ( d -> testing_p ) return true ;


<s> rtx ( * gen ) ( rtx , rtx , rtx , rtx ) ; rtx offset ; unsigned int location ; unsigned int next = d -> perm [ <NUM_LIT> ] + <NUM_LIT> ; if ( BYTES_BIG_ENDIAN ) return false ; for ( i = <NUM_LIT> ; i < nelt ; next ++ , i ++ ) { if ( next == <NUM_LIT> * nelt ) return false ; if ( d -> one_vector_p && ( next == nelt ) ) { if ( ( nelt == <NUM_LIT> ) && ( d -> vmode != V2DImode ) ) return false ; else next = <NUM_LIT> ; } if ( d -> perm [ i ] != next ) return false ; } location = d -> perm [ <NUM_LIT> ] ; switch ( d -> vmode ) { case V16QImode : gen = gen_neon_vextv16qi ; break ; case V8QImode : gen = gen_neon_vextv8qi ; break ; case V4HImode : gen = gen_neon_vextv4hi ; break ; case V8HImode : gen = gen_neon_vextv8hi ; break ; case V2SImode : gen = gen_neon_vextv2si ; break ; case V4SImode : gen = gen_neon_vextv4si ; break ; case V2SFmode : gen = gen_neon_vextv2sf ; break ; case V4SFmode : gen = gen_neon_vextv4sf ; break ; case V2DImode : gen = gen_neon_vextv2di ; break ;


<s> unsigned int i , j , diff , nelt = d -> nelt ; rtx ( * gen ) ( rtx , rtx ) ; if ( ! d -> one_vector_p ) return false ; diff = d -> perm [ <NUM_LIT> ] ; switch ( diff ) { case <NUM_LIT> : switch ( d -> vmode ) { case V16QImode : gen = gen_neon_vrev64v16qi ; break ; case V8QImode : gen = gen_neon_vrev64v8qi ; break ; default : return false ; } break ; case <NUM_LIT> : switch ( d -> vmode ) { case V16QImode : gen = gen_neon_vrev32v16qi ; break ; case V8QImode : gen = gen_neon_vrev32v8qi ; break ; case V8HImode : gen = gen_neon_vrev64v8hi ; break ; case V4HImode : gen = gen_neon_vrev64v4hi ; break ; default : return false ;


<s> if ( BYTES_BIG_ENDIAN ) return false ; if ( d -> testing_p ) return true ; if ( vmode != V8QImode && vmode != V16QImode ) return false ; for ( i = <NUM_LIT> ; i < nelt ; ++ i ) rperm [ i ] = GEN_INT ( d -> perm [ i ] ) ; sel = gen_rtx_CONST_VECTOR ( vmode , gen_rtvec_v ( nelt , rperm ) ) ; sel = force_reg ( vmode , sel ) ; arm_expand_vec_perm_1 ( d -> target , d -> op0 , d -> op1 , sel ) ; return true ;


<s> mask = ( d -> one_vector_p ? nelt - <NUM_LIT> : <NUM_LIT> * nelt - <NUM_LIT> ) ; for ( i = <NUM_LIT> ; i < nelt ; i += <NUM_LIT> ) { if ( d -> perm [ i ] != i + odd ) return false ; if ( d -> perm [ i + <NUM_LIT> ] != ( ( i + nelt + odd ) & mask ) ) return false ; } if ( d -> testing_p ) return true ; switch ( d -> vmode ) { case V16QImode : gen = gen_neon_vtrnv16qi_internal ; break ; case V8QImode : gen = gen_neon_vtrnv8qi_internal ; break ; case V8HImode : gen = gen_neon_vtrnv8hi_internal ; break ; case V4HImode : gen = gen_neon_vtrnv4hi_internal ; break ; case V4SImode : gen = gen_neon_vtrnv4si_internal ; break ; case V2SImode : gen = gen_neon_vtrnv2si_internal ; break ; case V2SFmode : gen = gen_neon_vtrnv2sf_internal ; break ; case V4SFmode : gen = gen_neon_vtrnv4sf_internal ; break ; default : gcc_unreachable ( ) ; } in0 = d -> op0 ; in1 = d -> op1 ; if ( BYTES_BIG_ENDIAN ) { x = in0 , in0 = in1 , in1 = x ; odd = ! odd ; } out0 = d -> target ; out1 = gen_reg_rtx ( d -> vmode ) ; if ( odd ) x = out0 , out0 = out1 , out1 = x ; emit_insn ( gen ( out0 , in0 , in1 , out1 ) ) ;


<s> for ( i = <NUM_LIT> ; i < nelt ; i ++ ) { unsigned elt = ( i * <NUM_LIT> + odd ) & mask ; if ( d -> perm [ i ] != elt ) return false ; } if ( d -> testing_p ) return true ; switch ( d -> vmode ) { case V16QImode : gen = gen_neon_vuzpv16qi_internal ; break ; case V8QImode : gen = gen_neon_vuzpv8qi_internal ; break ; case V8HImode : gen = gen_neon_vuzpv8hi_internal ; break ; case V4HImode : gen = gen_neon_vuzpv4hi_internal ; break ; case V4SImode : gen = gen_neon_vuzpv4si_internal ; break ; case V2SImode : gen = gen_neon_vuzpv2si_internal ; break ; case V2SFmode : gen = gen_neon_vuzpv2sf_internal ; break ; case V4SFmode : gen = gen_neon_vuzpv4sf_internal ; break ; default : gcc_unreachable ( ) ; }


<s> else if ( d -> perm [ <NUM_LIT> ] == <NUM_LIT> ) high = <NUM_LIT> ; else return false ; mask = ( d -> one_vector_p ? nelt - <NUM_LIT> : <NUM_LIT> * nelt - <NUM_LIT> ) ; for ( i = <NUM_LIT> ; i < nelt / <NUM_LIT> ; i ++ ) { unsigned elt = ( i + high ) & mask ; if ( d -> perm [ i * <NUM_LIT> ] != elt ) return false ; elt = ( elt + nelt ) & mask ; if ( d -> perm [ i * <NUM_LIT> + <NUM_LIT> ] != elt ) return false ; } if ( d -> testing_p ) return true ; switch ( d -> vmode ) { case V16QImode : gen = gen_neon_vzipv16qi_internal ; break ; case V8QImode : gen = gen_neon_vzipv8qi_internal ; break ; case V8HImode : gen = gen_neon_vzipv8hi_internal ; break ; case V4HImode : gen = gen_neon_vzipv4hi_internal ; break ; case V4SImode : gen = gen_neon_vzipv4si_internal ; break ; case V2SImode : gen = gen_neon_vzipv2si_internal ; break ;

case V2SFmode : gen = gen_neon_vzipv2sf_internal ; break ;


<s> mode = GET_MODE ( mem ) ; if ( TARGET_HAVE_LDACQ && INTVAL ( mod_f ) == MEMMODEL_ACQUIRE && INTVAL ( mod_s ) == MEMMODEL_RELEASE ) mod_s = GEN_INT ( MEMMODEL_ACQ_REL ) ; switch ( mode ) { case QImode : case HImode : rval = gen_reg_rtx ( SImode ) ; oldval = convert_modes ( SImode , mode , oldval , true ) ; case SImode : if ( ! arm_add_operand ( oldval , SImode ) ) oldval = force_reg ( SImode , oldval ) ; break ; case DImode : if ( ! cmpdi_operand ( oldval , mode ) ) oldval = force_reg ( mode , oldval ) ; break ; default : gcc_unreachable ( ) ; } switch ( mode ) { case QImode : gen = gen_atomic_compare_and_swapqi_1 ; break ; case HImode : gen = gen_atomic_compare_and_swaphi_1 ; break ; case SImode : gen = gen_atomic_compare_and_swapsi_1 ; break ; case DImode : gen = gen_atomic_compare_and_swapdi_1 ; break ; default : gcc_unreachable ( ) ; } emit_insn ( gen ( rval , mem , oldval , newval , is_weak , mod_s , mod_f ) ) ; if ( mode == QImode || mode == HImode ) emit_move_insn ( operands [ <NUM_LIT> ] , gen_lowpart ( mode , rval ) ) ; x = gen_rtx_REG ( CCmode , CC_REGNUM ) ; x = gen_rtx_EQ ( SImode , x , const0_rtx ) ; emit_insn ( gen_rtx_SET ( VOIDmode , bval , x ) ) ;


<s> rtx insn ; bool return_in_pc = false ; if ( ARM_FUNC_TYPE ( func_type ) != ARM_FT_INTERWORKED && ( TARGET_ARM || ARM_FUNC_TYPE ( func_type ) == ARM_FT_NORMAL ) && ! IS_STACKALIGN ( func_type ) && really_return && crtl -> args . pretend_args_size == <NUM_LIT> && saved_regs_mask & ( <NUM_LIT> << LR_REGNUM ) && ! crtl -> calls_eh_return ) { saved_regs_mask &= ~ ( <NUM_LIT> << LR_REGNUM ) ; saved_regs_mask |= ( <NUM_LIT> << PC_REGNUM ) ; return_in_pc = true ; } if ( num_regs == <NUM_LIT> && ( ! IS_INTERRUPT ( func_type ) || ! return_in_pc ) ) { for ( i = <NUM_LIT> ; i <= LAST_ARM_REGNUM ; i ++ ) if ( saved_regs_mask & ( <NUM_LIT> << i ) ) { rtx addr = gen_rtx_MEM ( SImode , gen_rtx_POST_INC ( SImode , stack_pointer_rtx ) ) ; set_mem_alias_set ( addr , get_frame_alias_set ( ) ) ; if ( i == PC_REGNUM ) { insn = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( <NUM_LIT> ) ) ; XVECEXP ( insn , <NUM_LIT> , <NUM_LIT> ) = ret_rtx ; XVECEXP ( insn , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_SET ( SImode , gen_rtx_REG ( SImode , i ) , addr ) ; RTX_FRAME_RELATED_P ( XVECEXP ( insn , <NUM_LIT> , <NUM_LIT> ) ) = <NUM_LIT> ; insn = emit_jump_insn ( insn ) ; } else { insn = emit_insn ( gen_movsi ( gen_rtx_REG ( SImode , i ) , addr ) ) ; REG_NOTES ( insn ) = alloc_reg_note ( REG_CFA_RESTORE , gen_rtx_REG ( SImode , i ) , NULL_RTX ) ; arm_add_cfa_adjust_cfa_note ( insn , UNITS_PER_WORD , stack_pointer_rtx , stack_pointer_rtx ) ; } } } else { if ( TARGET_LDRD && current_tune -> prefer_ldrd_strd && ! optimize_function_for_size_p ( cfun ) ) { if ( TARGET_THUMB2 ) thumb2_emit_ldrd_pop ( saved_regs_mask ) ; else if ( TARGET_ARM && ! IS_INTERRUPT ( func_type ) ) arm_emit_ldrd_pop ( saved_regs_mask ) ; else arm_emit_multi_reg_pop ( saved_regs_mask ) ; } else arm_emit_multi_reg_pop ( saved_regs_mask ) ; } if ( return_in_pc ) return ; } if ( crtl -> args . pretend_args_size ) { int i , j ; rtx dwarf = NULL_RTX ; rtx_insn * tmp = emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( crtl -> args . pretend_args_size ) ) ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; if ( cfun -> machine -> uses_anonymous_args ) { int num_regs = crtl -> args . pretend_args_size / <NUM_LIT> ; saved_regs_mask = ( <NUM_LIT> >> num_regs ) & <NUM_LIT> ; for ( j = <NUM_LIT> , i = <NUM_LIT> ; j < num_regs ; i ++ ) if ( saved_regs_mask & ( <NUM_LIT> << i ) ) { rtx reg = gen_rtx_REG ( SImode , i ) ; dwarf = alloc_reg_note ( REG_CFA_RESTORE , reg , dwarf ) ; j ++ ; } REG_NOTES ( tmp ) = dwarf ; }

arm_add_cfa_adjust_cfa_note ( tmp , crtl -> args . pretend_args_size , stack_pointer_rtx , stack_pointer_rtx ) ;


<s> if ( ( offsets -> outgoing_args != ( <NUM_LIT> + num_regs ) ) || cfun -> calls_alloca ) { rtx_insn * insn ; emit_insn ( gen_blockage ( ) ) ; insn = emit_insn ( gen_addsi3 ( stack_pointer_rtx , hard_frame_pointer_rtx , GEN_INT ( - <NUM_LIT> * num_regs ) ) ) ; arm_add_cfa_adjust_cfa_note ( insn , - <NUM_LIT> * num_regs , stack_pointer_rtx , hard_frame_pointer_rtx ) ; } arm_emit_multi_reg_pop ( saved_regs_mask ) ; if ( IS_INTERRUPT ( func_type ) ) { rtx_insn * insn ; rtx addr = gen_rtx_MEM ( SImode , gen_rtx_POST_INC ( SImode , stack_pointer_rtx ) ) ; set_mem_alias_set ( addr , get_frame_alias_set ( ) ) ; insn = emit_insn ( gen_movsi ( gen_rtx_REG ( SImode , IP_REGNUM ) , addr ) ) ; REG_NOTES ( insn ) = alloc_reg_note ( REG_CFA_RESTORE , gen_rtx_REG ( SImode , IP_REGNUM ) , NULL_RTX ) ; } if ( ! really_return || ( saved_regs_mask & ( <NUM_LIT> << PC_REGNUM ) ) ) return ; if ( crtl -> calls_eh_return ) emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , gen_rtx_REG ( SImode , ARM_EH_STACKADJ_REGNUM ) ) ) ; if ( IS_STACKALIGN ( func_type ) ) emit_insn ( gen_movsi ( stack_pointer_rtx , gen_rtx_REG ( SImode , R0_REGNUM ) ) ) ;


<s> rtx rmask [ MAX_VECT_LEN ] , mask ; gcc_checking_assert ( ! BYTES_BIG_ENDIAN ) ; mask = GEN_INT ( one_vector_p ? nelt - <NUM_LIT> : <NUM_LIT> * nelt - <NUM_LIT> ) ; for ( i = <NUM_LIT> ; i < nelt ; ++ i ) rmask [ i ] = mask ; mask = gen_rtx_CONST_VECTOR ( vmode , gen_rtvec_v ( nelt , rmask ) ) ;

sel = expand_simple_binop ( vmode , AND , sel , mask , NULL , <NUM_LIT> , OPTAB_LIB_WIDEN ) ;


<s> unsigned int i , nelt = GET_MODE_NUNITS ( vmode ) ; bool one_vector_p = rtx_equal_p ( op0 , op1 ) ; rtx rmask [ MAX_VECT_LEN ] , mask ; gcc_checking_assert ( ! BYTES_BIG_ENDIAN ) ; mask = GEN_INT ( one_vector_p ? nelt - <NUM_LIT> : <NUM_LIT> * nelt - <NUM_LIT> ) ;

for ( i = <NUM_LIT> ; i < nelt ; ++ i ) rmask [ i ] = mask ;


<s> bool arm_expand_vec_perm_const ( rtx target , rtx op0 , rtx op1 , rtx sel ) { struct expand_vec_perm_d d ; int i , nelt , which ; d . target = target ; d . op0 = op0 ; d . op1 = op1 ; d . vmode = GET_MODE ( target ) ; gcc_assert ( VECTOR_MODE_P ( d . vmode ) ) ; d . nelt = nelt = GET_MODE_NUNITS ( d . vmode ) ; d . testing_p = false ; for ( i = which = <NUM_LIT> ; i < nelt ; ++ i ) { rtx e = XVECEXP ( sel , <NUM_LIT> , i ) ; int ei = INTVAL ( e ) & ( <NUM_LIT> * nelt - <NUM_LIT> ) ; which |= ( ei < nelt ? <NUM_LIT> : <NUM_LIT> ) ;


<s> for ( i = which = <NUM_LIT> ; i < nelt ; ++ i ) { rtx e = XVECEXP ( sel , <NUM_LIT> , i ) ; int ei = INTVAL ( e ) & ( <NUM_LIT> * nelt - <NUM_LIT> ) ; which |= ( ei < nelt ? <NUM_LIT> : <NUM_LIT> ) ; d . perm [ i ] = ei ; } switch ( which ) { default : gcc_unreachable ( ) ;


<s> rtx x ; for ( i = <NUM_LIT> ; i < nelt ; ++ i ) d -> perm [ i ] = ( d -> perm [ i ] + nelt ) & ( <NUM_LIT> * nelt - <NUM_LIT> ) ; x = d -> op0 ; d -> op0 = d -> op1 ; d -> op1 = x ; } if ( TARGET_NEON ) { if ( arm_evpc_neon_vuzp ( d ) ) return true ; if ( arm_evpc_neon_vzip ( d ) ) return true ; if ( arm_evpc_neon_vrev ( d ) ) return true ; if ( arm_evpc_neon_vtrn ( d ) ) return true ; return arm_evpc_neon_vtbl ( d ) ;


<s> 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 ) { arm_ccfsm_state = <NUM_LIT> ; succeed = TRUE ; } else if ( GET_CODE ( SET_SRC ( scanbody ) ) == IF_THEN_ELSE ) fail = TRUE ; } else if ( GET_CODE ( scanbody ) == return_code && ! use_return_insn ( TRUE , NULL ) && ! optimize_size ) fail = TRUE ; else if ( GET_CODE ( scanbody ) == return_code ) { arm_ccfsm_state = <NUM_LIT> ; succeed = TRUE ; } else if ( GET_CODE ( scanbody ) == PARALLEL ) { switch ( get_attr_conds ( this_insn ) ) { case CONDS_NOCOND : break ; default : fail = TRUE ; break ; } } else fail = TRUE ; break ; case INSN : scanbody = PATTERN ( this_insn ) ; if ( ! ( GET_CODE ( scanbody ) == SET || GET_CODE ( scanbody ) == PARALLEL ) || get_attr_conds ( this_insn ) != CONDS_NOCOND ) fail = TRUE ; break ; default : break ; } } if ( succeed ) { if ( ( ! seeking_return ) && ( arm_ccfsm_state == <NUM_LIT> || reverse ) ) arm_target_label = CODE_LABEL_NUMBER ( label ) ; else { gcc_assert ( seeking_return || arm_ccfsm_state == <NUM_LIT> ) ; while ( this_insn && GET_CODE ( PATTERN ( this_insn ) ) == USE ) { this_insn = next_nonnote_insn ( this_insn ) ; gcc_assert ( ! this_insn || ( ! BARRIER_P ( this_insn ) && ! LABEL_P ( this_insn ) ) ) ; } if ( ! this_insn ) { extract_constrain_insn_cached ( insn ) ;


<s> if ( pcum -> iwmmxt_nregs <= <NUM_LIT> ) return gen_rtx_REG ( mode , pcum -> iwmmxt_nregs + FIRST_IWMMXT_REGNUM ) ; else { pcum -> can_split = false ; return NULL_RTX ; } } if ( pcum -> nregs & <NUM_LIT> && ARM_DOUBLEWORD_ALIGN && arm_needs_doubleword_align ( mode , type ) ) pcum -> nregs ++ ; if ( pcum -> can_split ) nregs = <NUM_LIT> ; else nregs = ARM_NUM_REGS2 ( mode , type ) ; if ( ! named || pcum -> nregs + nregs > NUM_ARG_REGS ) return NULL_RTX ;

return gen_rtx_REG ( mode , pcum -> nregs ) ;


<s> aapcs_cp_arg_layout [ pcum -> aapcs_cprc_slot ] . advance ( pcum , mode , type ) ; pcum -> aapcs_cprc_slot = - <NUM_LIT> ; } pcum -> aapcs_arg_processed = false ; pcum -> aapcs_ncrn = pcum -> aapcs_next_ncrn ; pcum -> aapcs_reg = NULL_RTX ; pcum -> aapcs_partial = <NUM_LIT> ; } else { pcum -> nargs += <NUM_LIT> ; if ( arm_vector_mode_supported_p ( mode ) && pcum -> named_count > pcum -> nargs && TARGET_IWMMXT_ABI ) pcum -> iwmmxt_nregs += <NUM_LIT> ;

else pcum -> nregs += ARM_NUM_REGS2 ( mode , type ) ;


<s> if ( IS_INTERRUPT ( func_type ) ) return false ; if ( ! VOID_TYPE_P ( TREE_TYPE ( DECL_RESULT ( cfun -> decl ) ) ) ) { rtx a , b ; a = arm_function_value ( TREE_TYPE ( exp ) , decl , false ) ;

b = arm_function_value ( TREE_TYPE ( DECL_RESULT ( cfun -> decl ) ) , cfun -> decl , false ) ;


<s> if ( TARGET_AAPCS_BASED ) return aapcs_allocate_return_reg ( mode , type , func ) ; if ( INTEGRAL_TYPE_P ( type ) ) mode = arm_promote_function_mode ( type , mode , & unsignedp , func , <NUM_LIT> ) ; if ( arm_return_in_msb ( type ) ) { HOST_WIDE_INT size = int_size_in_bytes ( type ) ; if ( size % UNITS_PER_WORD != <NUM_LIT> ) { size += UNITS_PER_WORD - size % UNITS_PER_WORD ; mode = mode_for_size ( size * BITS_PER_UNIT , MODE_INT , <NUM_LIT> ) ; }


<s> mode = TYPE_MODE ( type ) ; if ( TARGET_AAPCS_BASED ) return aapcs_allocate_return_reg ( mode , type , func ) ; if ( INTEGRAL_TYPE_P ( type ) ) mode = arm_promote_function_mode ( type , mode , & unsignedp , func , <NUM_LIT> ) ; if ( arm_return_in_msb ( type ) ) { HOST_WIDE_INT size = int_size_in_bytes ( type ) ;

if ( size % UNITS_PER_WORD != <NUM_LIT> ) {


<s> static bool arm_function_value_regno_p ( const unsigned int regno ) { if ( regno == ARG_REGISTER ( <NUM_LIT> ) || ( TARGET_32BIT && TARGET_AAPCS_BASED && TARGET_VFP && TARGET_HARD_FLOAT && regno == FIRST_VFP_REGNUM ) || ( TARGET_IWMMXT_ABI && regno == FIRST_IWMMXT_REGNUM ) ) return true ;


<s> if ( regno == ARG_REGISTER ( <NUM_LIT> ) || ( TARGET_32BIT && TARGET_AAPCS_BASED && TARGET_VFP && TARGET_HARD_FLOAT && regno == FIRST_VFP_REGNUM ) || ( TARGET_IWMMXT_ABI && regno == FIRST_IWMMXT_REGNUM ) ) return true ; return false ;


<s> rtx arm_gen_compare_reg ( enum rtx_code code , rtx x , rtx y , rtx scratch ) { machine_mode mode ; rtx cc_reg ; int dimode_comparison = GET_MODE ( x ) == DImode || GET_MODE ( y ) == DImode ; if ( dimode_comparison && ! REG_P ( x ) ) x = force_reg ( DImode , x ) ; mode = SELECT_CC_MODE ( code , x , y ) ; cc_reg = gen_rtx_REG ( mode , CC_REGNUM ) ; if ( dimode_comparison && mode != CC_CZmode ) { rtx clobber , set ; if ( mode == CC_Zmode && y != const0_rtx ) { gcc_assert ( ! reload_completed ) ; x = expand_binop ( DImode , xor_optab , x , y , NULL_RTX , <NUM_LIT> , OPTAB_WIDEN ) ; y = const0_rtx ; } if ( reload_completed ) gcc_assert ( scratch != NULL && GET_MODE ( scratch ) == SImode ) ; else scratch = gen_rtx_SCRATCH ( SImode ) ; clobber = gen_rtx_CLOBBER ( VOIDmode , scratch ) ; set = gen_rtx_SET ( VOIDmode , cc_reg , gen_rtx_COMPARE ( mode , x , y ) ) ;

emit_insn ( gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , set , clobber ) ) ) ;


<s> x = expand_binop ( DImode , xor_optab , x , y , NULL_RTX , <NUM_LIT> , OPTAB_WIDEN ) ; y = const0_rtx ; } if ( reload_completed ) gcc_assert ( scratch != NULL && GET_MODE ( scratch ) == SImode ) ; else scratch = gen_rtx_SCRATCH ( SImode ) ; clobber = gen_rtx_CLOBBER ( VOIDmode , scratch ) ; set = gen_rtx_SET ( VOIDmode , cc_reg , gen_rtx_COMPARE ( mode , x , y ) ) ;


<s> end_sequence ( ) ; return seq ; } result = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( count + ( wback_offset != <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ) ) ) ; if ( wback_offset != <NUM_LIT> ) { XVECEXP ( result , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_SET ( VOIDmode , basereg , plus_constant ( Pmode , basereg , wback_offset ) ) ; i = <NUM_LIT> ; count ++ ; } for ( j = <NUM_LIT> ; i < count ; i ++ , j ++ ) XVECEXP ( result , <NUM_LIT> , i ) = gen_rtx_SET ( VOIDmode , gen_rtx_REG ( SImode , regs [ j ] ) , mems [ j ] ) ; return result ;


<s> if ( ! multiple_operation_profitable_p ( false , count , <NUM_LIT> ) ) { rtx seq ; start_sequence ( ) ; for ( i = <NUM_LIT> ; i < count ; i ++ ) emit_move_insn ( gen_rtx_REG ( SImode , regs [ i ] ) , mems [ i ] ) ; if ( wback_offset != <NUM_LIT> ) emit_move_insn ( basereg , plus_constant ( Pmode , basereg , wback_offset ) ) ; seq = get_insns ( ) ; end_sequence ( ) ; return seq ; }

result = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( count + ( wback_offset != <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ) ) ) ;


<s> if ( out_words_to_go > <NUM_LIT> ) emit_insn ( arm_gen_store_multiple ( arm_regs_in_sequence , <NUM_LIT> , dst , TRUE , dstbase , & dstoffset ) ) ; else if ( out_words_to_go != <NUM_LIT> ) emit_insn ( arm_gen_store_multiple ( arm_regs_in_sequence , out_words_to_go , dst , ( last_bytes == <NUM_LIT> ? FALSE : TRUE ) , dstbase , & dstoffset ) ) ; else { mem = adjust_automodify_address ( dstbase , SImode , dst , dstoffset ) ; emit_move_insn ( mem , gen_rtx_REG ( SImode , R0_REGNUM ) ) ; if ( last_bytes != <NUM_LIT> ) { emit_insn ( gen_addsi3 ( dst , dst , GEN_INT ( <NUM_LIT> ) ) ) ; dstoffset += <NUM_LIT> ; } } } in_words_to_go -= in_words_to_go < <NUM_LIT> ? in_words_to_go : <NUM_LIT> ; out_words_to_go -= out_words_to_go < <NUM_LIT> ? out_words_to_go : <NUM_LIT> ; } if ( out_words_to_go ) { rtx sreg ; mem = adjust_automodify_address ( srcbase , SImode , src , srcoffset ) ; sreg = copy_to_reg ( mem ) ; mem = adjust_automodify_address ( dstbase , SImode , dst , dstoffset ) ; emit_move_insn ( mem , sreg ) ; in_words_to_go -- ; gcc_assert ( ! in_words_to_go ) ; } if ( in_words_to_go ) { gcc_assert ( in_words_to_go > <NUM_LIT> ) ; mem = adjust_automodify_address ( srcbase , SImode , src , srcoffset ) ; part_bytes_reg = copy_to_mode_reg ( SImode , mem ) ; } gcc_assert ( ! last_bytes || part_bytes_reg ) ; if ( BYTES_BIG_ENDIAN && last_bytes ) { rtx tmp = gen_reg_rtx ( SImode ) ; emit_insn ( gen_lshrsi3 ( tmp , part_bytes_reg , GEN_INT ( <NUM_LIT> * ( <NUM_LIT> - last_bytes ) ) ) ) ; part_bytes_reg = tmp ; while ( last_bytes ) { mem = adjust_automodify_address ( dstbase , QImode , plus_constant ( Pmode , dst , last_bytes - <NUM_LIT> ) , dstoffset + last_bytes - <NUM_LIT> ) ; emit_move_insn ( mem , gen_lowpart ( QImode , part_bytes_reg ) ) ; if ( -- last_bytes ) { tmp = gen_reg_rtx ( SImode ) ; emit_insn ( gen_lshrsi3 ( tmp , part_bytes_reg , GEN_INT ( <NUM_LIT> ) ) ) ; part_bytes_reg = tmp ; } } } else { if ( last_bytes > <NUM_LIT> ) { mem = adjust_automodify_address ( dstbase , HImode , dst , dstoffset ) ; emit_move_insn ( mem , gen_lowpart ( HImode , part_bytes_reg ) ) ;


<s> func_type = arm_current_func_type ( ) ; if ( ! IS_VOLATILE ( func_type ) && TARGET_HARD_FLOAT && TARGET_VFP ) saved += arm_get_vfp_saved_size ( ) ; } else { offsets -> saved_regs_mask = thumb1_compute_save_reg_mask ( ) ; core_saved = bit_count ( offsets -> saved_regs_mask ) * <NUM_LIT> ; saved = core_saved ; if ( TARGET_BACKTRACE ) saved += <NUM_LIT> ; } offsets -> saved_regs = offsets -> saved_args + arm_compute_static_chain_stack_bytes ( ) + saved ; offsets -> soft_frame = offsets -> saved_regs + CALLER_INTERWORKING_SLOT_SIZE ; if ( leaf && frame_size == <NUM_LIT> && ! cfun -> calls_alloca ) { offsets -> outgoing_args = offsets -> soft_frame ; offsets -> locals_base = offsets -> soft_frame ; return offsets ; } if ( ARM_DOUBLEWORD_ALIGN && ( offsets -> soft_frame & <NUM_LIT> ) ) { offsets -> soft_frame += <NUM_LIT> ; if ( frame_size + crtl -> outgoing_args_size == <NUM_LIT> ) { int reg = - <NUM_LIT> ; bool prefer_callee_reg_p = false ; if ( ! any_sibcall_could_use_r3 ( ) && arm_size_return_regs ( ) <= <NUM_LIT> && ( offsets -> saved_regs_mask & ( <NUM_LIT> << <NUM_LIT> ) ) == <NUM_LIT> && ( TARGET_THUMB2 || ! ( TARGET_LDRD && current_tune -> prefer_ldrd_strd ) ) ) { reg = <NUM_LIT> ; if ( ! TARGET_THUMB2 ) prefer_callee_reg_p = true ; } if ( reg == - <NUM_LIT> || prefer_callee_reg_p ) { for ( i = <NUM_LIT> ; i <= ( TARGET_THUMB1 ? LAST_LO_REGNUM : <NUM_LIT> ) ; i ++ ) { if ( ! fixed_regs [ i ] && ( offsets -> saved_regs_mask & ( <NUM_LIT> << i ) ) == <NUM_LIT> ) { reg = i ;


<s> tree attr ; gcc_assert ( type ) ; attr = lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type ) ) ; if ( attr ) { user_pcs = arm_pcs_from_attribute ( TREE_VALUE ( attr ) ) ; user_convention = true ; } if ( TARGET_AAPCS_BASED ) { bool base_rules = stdarg_p ( type ) ; if ( user_convention ) { if ( user_pcs > ARM_PCS_AAPCS_LOCAL ) sorry ( <STR_LIT> ) ; else if ( base_rules && user_pcs != ARM_PCS_AAPCS ) error ( <STR_LIT> ) ; } if ( base_rules ) return ARM_PCS_AAPCS ; else if ( user_convention ) return user_pcs ; else if ( decl && flag_unit_at_a_time ) { cgraph_local_info * i = cgraph_node :: local_info ( CONST_CAST_TREE ( decl ) ) ; if ( i && i -> local ) return ARM_PCS_AAPCS_LOCAL ; } }

else if ( user_convention && user_pcs != arm_pcs_default ) sorry ( <STR_LIT> ) ;


<s> static enum arm_pcs arm_get_pcs_model ( const_tree type , const_tree decl ) { bool user_convention = false ; enum arm_pcs user_pcs = arm_pcs_default ; tree attr ; gcc_assert ( type ) ; attr = lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type ) ) ; if ( attr ) { user_pcs = arm_pcs_from_attribute ( TREE_VALUE ( attr ) ) ; user_convention = true ; } if ( TARGET_AAPCS_BASED ) {


<s> count = <NUM_LIT> ; for ( regno = FIRST_VFP_REGNUM ; regno < LAST_VFP_REGNUM ; regno += <NUM_LIT> ) { if ( ( ! df_regs_ever_live_p ( regno ) || call_used_regs [ regno ] ) && ( ! df_regs_ever_live_p ( regno + <NUM_LIT> ) || call_used_regs [ regno + <NUM_LIT> ] ) ) { if ( count > <NUM_LIT> ) { if ( count == <NUM_LIT> && ! arm_arch6 ) count ++ ; saved += count * <NUM_LIT> ;


<s> if ( mode == DFmode ) return VFP_REGNO_OK_FOR_DOUBLE ( regno ) ; if ( mode == HFmode ) return TARGET_FP16 && VFP_REGNO_OK_FOR_SINGLE ( regno ) ; if ( TARGET_NEON ) return ( VALID_NEON_DREG_MODE ( mode ) && VFP_REGNO_OK_FOR_DOUBLE ( regno ) ) || ( VALID_NEON_QREG_MODE ( mode ) && NEON_REGNO_OK_FOR_QUAD ( regno ) ) || ( mode == TImode && NEON_REGNO_OK_FOR_NREGS ( regno , <NUM_LIT> ) ) || ( mode == EImode && NEON_REGNO_OK_FOR_NREGS ( regno , <NUM_LIT> ) ) || ( mode == OImode && NEON_REGNO_OK_FOR_NREGS ( regno , <NUM_LIT> ) ) || ( mode == CImode && NEON_REGNO_OK_FOR_NREGS ( regno , <NUM_LIT> ) ) || ( mode == XImode && NEON_REGNO_OK_FOR_NREGS ( regno , <NUM_LIT> ) ) ; return FALSE ; }


<s> static struct machine_function * arm_init_machine_status ( void ) {


<s> if ( SCALAR_FLOAT_TYPE_P ( t ) && TYPE_PRECISION ( t ) == <NUM_LIT> ) return N_ ( <STR_LIT> ) ; return NULL ;


<s> case cortexr4f : case cortexr5 : case genericv7a : case cortexa5 : case cortexa7 : case cortexa8 : case cortexa9 : case cortexa12 : case cortexa17 : case cortexa53 : case fa726te : case marvell_pj4 : return <NUM_LIT> ; default : return <NUM_LIT> ; }


<s> case xgene1 : return <NUM_LIT> ; case cortexa15 : case cortexa57 : case exynosm1 : return <NUM_LIT> ; case cortexm7 : case cortexr4 :


<s> enum rtx_code code = GET_CODE ( x ) ; if ( arm_address_register_rtx_p ( x , strict_p ) ) return <NUM_LIT> ; use_ldrd = ( TARGET_LDRD && ( mode == DImode || ( mode == DFmode && ( TARGET_SOFT_FLOAT || TARGET_VFP ) ) ) ) ; if ( code == POST_INC || code == PRE_DEC || ( ( code == PRE_INC || code == POST_DEC ) && ( use_ldrd || GET_MODE_SIZE ( mode ) <= <NUM_LIT> ) ) ) return arm_address_register_rtx_p ( XEXP ( x , <NUM_LIT> ) , strict_p ) ; else if ( ( code == POST_MODIFY || code == PRE_MODIFY ) && arm_address_register_rtx_p ( XEXP ( x , <NUM_LIT> ) , strict_p ) && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS && rtx_equal_p ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) , XEXP ( x , <NUM_LIT> ) ) ) { rtx addend = XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ; if ( use_ldrd && GET_CODE ( x ) == POST_MODIFY && REG_P ( addend ) ) return <NUM_LIT> ; return ( ( use_ldrd || GET_MODE_SIZE ( mode ) <= <NUM_LIT> ) && arm_legitimate_index_p ( mode , addend , outer , strict_p ) ) ; } else if ( reload_completed && ( code == LABEL_REF || ( code == CONST && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == LABEL_REF && CONST_INT_P ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) ) ) ) return <NUM_LIT> ; else if ( mode == TImode || ( TARGET_NEON && VALID_NEON_STRUCT_MODE ( mode ) ) ) return <NUM_LIT> ; else if ( code == PLUS ) { rtx xop0 = XEXP ( x , <NUM_LIT> ) ; rtx xop1 = XEXP ( x , <NUM_LIT> ) ; return ( ( arm_address_register_rtx_p ( xop0 , strict_p ) && ( ( CONST_INT_P ( xop1 ) && arm_legitimate_index_p ( mode , xop1 , outer , strict_p ) ) || ( ! strict_p && will_be_in_index_register ( xop1 ) ) ) ) || ( arm_address_register_rtx_p ( xop1 , strict_p ) && arm_legitimate_index_p ( mode , xop0 , outer , strict_p ) ) ) ; }


<s> else if ( code == PLUS ) { rtx xop0 = XEXP ( x , <NUM_LIT> ) ; rtx xop1 = XEXP ( x , <NUM_LIT> ) ; return ( ( arm_address_register_rtx_p ( xop0 , strict_p ) && ( ( CONST_INT_P ( xop1 ) && arm_legitimate_index_p ( mode , xop1 , outer , strict_p ) ) || ( ! strict_p && will_be_in_index_register ( xop1 ) ) ) ) || ( arm_address_register_rtx_p ( xop1 , strict_p ) && arm_legitimate_index_p ( mode , xop0 , outer , strict_p ) ) ) ; } else if ( GET_CODE ( x ) == MINUS ) { rtx xop0 = XEXP ( x , <NUM_LIT> ) ; rtx xop1 = XEXP ( x , <NUM_LIT> ) ; return ( arm_address_register_rtx_p ( xop0 , strict_p ) && arm_legitimate_index_p ( mode , xop1 , outer , strict_p ) ) ; } else if ( GET_MODE_CLASS ( mode ) != MODE_FLOAT && code == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P ( x ) && ! ( flag_pic && symbol_mentioned_p ( get_pool_constant ( x ) ) && ! pcrel_constant_p ( get_pool_constant ( x ) ) ) ) return <NUM_LIT> ;


<s> val = force_operand ( plus_constant ( Pmode , xop0 , n ) , NULL_RTX ) ; emit_move_insn ( base_reg , val ) ; x = plus_constant ( Pmode , base_reg , low_n ) ; } else if ( xop0 != XEXP ( x , <NUM_LIT> ) || xop1 != XEXP ( x , <NUM_LIT> ) ) x = gen_rtx_PLUS ( SImode , xop0 , xop1 ) ; } else if ( GET_CODE ( x ) == MINUS ) { rtx xop0 = XEXP ( x , <NUM_LIT> ) ; rtx xop1 = XEXP ( x , <NUM_LIT> ) ; if ( CONSTANT_P ( xop0 ) ) xop0 = force_reg ( SImode , xop0 ) ; if ( CONSTANT_P ( xop1 ) && ! symbol_mentioned_p ( xop1 ) ) xop1 = force_reg ( SImode , xop1 ) ; if ( xop0 != XEXP ( x , <NUM_LIT> ) || xop1 != XEXP ( x , <NUM_LIT> ) ) x = gen_rtx_MINUS ( SImode , xop0 , xop1 ) ; } else if ( CONST_INT_P ( x ) && optimize > <NUM_LIT> ) { unsigned int bits ; HOST_WIDE_INT mask , base , index ; rtx base_reg ; bits = ( mode == SImode ) ? <NUM_LIT> : <NUM_LIT> ; mask = ( <NUM_LIT> << bits ) - <NUM_LIT> ; base = INTVAL ( x ) & ~ mask ; index = INTVAL ( x ) & mask ; if ( bit_count ( base & <NUM_LIT> ) > ( <NUM_LIT> - bits ) / <NUM_LIT> ) { base |= mask ; index -= mask ; }

base_reg = force_reg ( SImode , GEN_INT ( base ) ) ;


<s> add_libcall ( libcall_htab , convert_optab_libfunc ( sfix_optab , SImode , DFmode ) ) ; add_libcall ( libcall_htab , convert_optab_libfunc ( ufix_optab , SImode , DFmode ) ) ; add_libcall ( libcall_htab , convert_optab_libfunc ( sfix_optab , DImode , DFmode ) ) ; add_libcall ( libcall_htab , convert_optab_libfunc ( ufix_optab , DImode , DFmode ) ) ; add_libcall ( libcall_htab , convert_optab_libfunc ( sfix_optab , DImode , SFmode ) ) ; add_libcall ( libcall_htab , convert_optab_libfunc ( ufix_optab , DImode , SFmode ) ) ; add_libcall ( libcall_htab , optab_libfunc ( add_optab , DFmode ) ) ; add_libcall ( libcall_htab , optab_libfunc ( sdiv_optab , DFmode ) ) ; add_libcall ( libcall_htab , optab_libfunc ( smul_optab , DFmode ) ) ;

add_libcall ( libcall_htab , optab_libfunc ( neg_optab , DFmode ) ) ;


<s> emit_insn ( gen_rtx_SET ( Pmode , pic_reg , gen_rtx_MEM ( Pmode , pic_reg ) ) ) ; pic_tmp = gen_rtx_SYMBOL_REF ( Pmode , VXWORKS_GOTT_INDEX ) ; emit_insn ( gen_pic_offset_arm ( pic_reg , pic_reg , pic_tmp ) ) ; } else { labelno = GEN_INT ( pic_labelno ++ ) ; l1 = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , labelno ) , UNSPEC_PIC_LABEL ) ; l1 = gen_rtx_CONST ( VOIDmode , l1 ) ; pic_rtx = plus_constant ( Pmode , l1 , TARGET_ARM ? <NUM_LIT> : <NUM_LIT> ) ; pic_rtx = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , pic_rtx ) , UNSPEC_GOTSYM_OFF ) ; pic_rtx = gen_rtx_CONST ( Pmode , pic_rtx ) ; if ( TARGET_32BIT ) { emit_insn ( gen_pic_load_addr_unified ( pic_reg , pic_rtx , labelno ) ) ; } else { if ( arm_pic_register != INVALID_REGNUM && REGNO ( pic_reg ) > LAST_LO_REGNUM ) { pic_tmp = gen_rtx_REG ( SImode , thumb_find_work_register ( saved_regs ) ) ; emit_insn ( gen_pic_load_addr_thumb1 ( pic_tmp , pic_rtx ) ) ; emit_insn ( gen_movsi ( pic_offset_table_rtx , pic_tmp ) ) ; emit_insn ( gen_pic_add_dot_plus_four ( pic_reg , pic_reg , labelno ) ) ; } else if ( arm_pic_register != INVALID_REGNUM && arm_pic_register > LAST_LO_REGNUM && REGNO ( pic_reg ) <= LAST_LO_REGNUM ) { emit_insn ( gen_pic_load_addr_unified ( pic_reg , pic_rtx , labelno ) ) ; emit_move_insn ( gen_rtx_REG ( Pmode , arm_pic_register ) , pic_reg ) ; emit_use ( gen_rtx_REG ( Pmode , arm_pic_register ) ) ; } else emit_insn ( gen_pic_load_addr_unified ( pic_reg , pic_rtx , labelno ) ) ; } } emit_use ( pic_reg ) ;


<s> } else { rtx tmp ; emit_insn ( gen_load_tp_soft ( ) ) ; tmp = gen_rtx_REG ( SImode , R0_REGNUM ) ; emit_move_insn ( target , tmp ) ;


<s> static bool arm_macro_fusion_p ( void ) { return current_tune -> fuseable_ops != ARM_FUSE_NOTHING ;


<s> static bool arm_macro_fusion_p ( void ) {


<s> if ( TARGET_AAPCS_BASED && lang_hooks . types_compatible_p ( CONST_CAST_TREE ( type ) , va_list_type ) ) return <STR_LIT> ; if ( TREE_CODE ( type ) == REAL_TYPE && TYPE_PRECISION ( type ) == <NUM_LIT> ) return <STR_LIT> ; if ( TYPE_NAME ( type ) != NULL ) return arm_mangle_builtin_type ( type ) ; return NULL ;


<s> const char * arm_mangle_type ( const_tree type ) {

if ( TARGET_AAPCS_BASED && lang_hooks . types_compatible_p ( CONST_CAST_TREE ( type ) , va_list_type ) ) return <STR_LIT> ;


<s> if ( TARGET_NEON && ( VALID_NEON_DREG_MODE ( mode1 ) || VALID_NEON_QREG_MODE ( mode1 ) || VALID_NEON_STRUCT_MODE ( mode1 ) ) && ( VALID_NEON_DREG_MODE ( mode2 ) || VALID_NEON_QREG_MODE ( mode2 ) || VALID_NEON_STRUCT_MODE ( mode2 ) ) ) return true ;


<s> bool arm_modes_tieable_p ( machine_mode mode1 , machine_mode mode2 ) { if ( GET_MODE_CLASS ( mode1 ) == GET_MODE_CLASS ( mode2 ) ) return true ; if ( TARGET_NEON && ( VALID_NEON_DREG_MODE ( mode1 ) || VALID_NEON_QREG_MODE ( mode1 ) || VALID_NEON_STRUCT_MODE ( mode1 ) ) && ( VALID_NEON_DREG_MODE ( mode2 ) || VALID_NEON_QREG_MODE ( mode2 ) || VALID_NEON_STRUCT_MODE ( mode2 ) ) ) return true ;


<s> else arm_block_move_unaligned_straight ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , length , interleave_factor ) ; } else { if ( length > <NUM_LIT> ) arm_block_move_unaligned_loop ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , length , <NUM_LIT> , <NUM_LIT> ) ;

else arm_block_move_unaligned_straight ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , length , <NUM_LIT> ) ;


<s> bool dst_aligned = MEM_ALIGN ( operands [ <NUM_LIT> ] ) >= BITS_PER_WORD ; unsigned int interleave_factor = ( src_aligned || dst_aligned ) ? <NUM_LIT> : <NUM_LIT> ; HOST_WIDE_INT bytes_per_iter = ( src_aligned || dst_aligned ) ? <NUM_LIT> : <NUM_LIT> ; if ( length > <NUM_LIT> ) arm_block_move_unaligned_loop ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , length , interleave_factor , bytes_per_iter ) ; else arm_block_move_unaligned_straight ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , length , interleave_factor ) ; } else { if ( length > <NUM_LIT> ) arm_block_move_unaligned_loop ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , length , <NUM_LIT> , <NUM_LIT> ) ; else arm_block_move_unaligned_straight ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , length , <NUM_LIT> ) ; } return <NUM_LIT> ;


<s> static bool arm_must_pass_in_stack ( machine_mode mode , const_tree type ) { if ( TARGET_AAPCS_BASED ) return must_pass_in_stack_var_size ( mode , type ) ;

else return must_pass_in_stack_var_size_or_pad ( mode , type ) ;


<s> else return must_pass_in_stack_var_size_or_pad ( mode , type ) ;


<s> return ( GET_MODE_ALIGNMENT ( mode ) > PARM_BOUNDARY || ( type && TYPE_ALIGN ( type ) > PARM_BOUNDARY ) ) ;


<s> switch ( ( int ) ARM_FUNC_TYPE ( func_type ) ) { default : case ARM_FT_NORMAL : break ; case ARM_FT_INTERWORKED : asm_fprintf ( f , <STR_LIT> ) ; break ; case ARM_FT_ISR : asm_fprintf ( f , <STR_LIT> ) ; break ; case ARM_FT_FIQ : asm_fprintf ( f , <STR_LIT> ) ; break ; case ARM_FT_EXCEPTION : asm_fprintf ( f , <STR_LIT> ) ; break ; } if ( IS_NAKED ( func_type ) ) asm_fprintf ( f , <STR_LIT> ) ; if ( IS_VOLATILE ( func_type ) ) asm_fprintf ( f , <STR_LIT> ) ; if ( IS_NESTED ( func_type ) ) asm_fprintf ( f , <STR_LIT> ) ;

if ( IS_STACKALIGN ( func_type ) ) asm_fprintf ( f , <STR_LIT> ) ;


<s> case ARM_FT_ISR : asm_fprintf ( f , <STR_LIT> ) ; break ; case ARM_FT_FIQ : asm_fprintf ( f , <STR_LIT> ) ; break ; case ARM_FT_EXCEPTION : asm_fprintf ( f , <STR_LIT> ) ; break ; } if ( IS_NAKED ( func_type ) ) asm_fprintf ( f , <STR_LIT> ) ; if ( IS_VOLATILE ( func_type ) ) asm_fprintf ( f , <STR_LIT> ) ; if ( IS_NESTED ( func_type ) ) asm_fprintf ( f , <STR_LIT> ) ; if ( IS_STACKALIGN ( func_type ) ) asm_fprintf ( f , <STR_LIT> ) ; asm_fprintf ( f , <STR_LIT> , crtl -> args . size , crtl -> args . pretend_args_size , frame_size ) ;

asm_fprintf ( f , <STR_LIT> , frame_pointer_needed , cfun -> machine -> uses_anonymous_args ) ;


<s> for ( i = <NUM_LIT> ; i < units ; ++ i ) { if ( ( mask & <NUM_LIT> ) == <NUM_LIT> ) { break ; } mask >>= <NUM_LIT> ; } gcc_assert ( i < units ) ; { switch ( GET_MODE ( operands [ <NUM_LIT> ] ) ) { case V8QImode : sprintf ( templ , <STR_LIT> , i ) ; break ; case V4HImode : sprintf ( templ , <STR_LIT> , i ) ; break ; case V2SImode : sprintf ( templ , <STR_LIT> , i ) ; break ; default : gcc_unreachable ( ) ; break ; } output_asm_insn ( templ , operands ) ;


<s> fputs ( <STR_LIT> , file ) ; } assemble_name ( file , label ) ; fputc ( '\n' , file ) ; if ( flag_pic ) { ASM_GENERATE_INTERNAL_LABEL ( labelpc , <STR_LIT> , labelno ) ; assemble_name ( file , labelpc ) ; fputs ( <STR_LIT> , file ) ; if ( TARGET_THUMB1_ONLY ) { fputs ( <STR_LIT> , file ) ; fputs ( <STR_LIT> , file ) ; } else fputs ( <STR_LIT> , file ) ; } else if ( TARGET_THUMB1_ONLY ) fputs ( <STR_LIT> , file ) ; } if ( TARGET_THUMB1_ONLY ) { if ( mi_delta > <NUM_LIT> ) { fputs ( <STR_LIT> , file ) ; assemble_name ( file , label ) ; fputs ( <STR_LIT> , file ) ; asm_fprintf ( file , <STR_LIT> , mi_op , this_regno , this_regno ) ; } else if ( mi_delta != <NUM_LIT> ) { asm_fprintf ( file , <STR_LIT> , mi_op , this_regno , this_regno , mi_delta ) ; } } else { while ( mi_delta != <NUM_LIT> ) { if ( ( mi_delta & ( <NUM_LIT> << shift ) ) == <NUM_LIT> ) shift += <NUM_LIT> ; else {

asm_fprintf ( file , <STR_LIT> , mi_op , this_regno , this_regno , mi_delta & ( <NUM_LIT> << shift ) ) ;


<s> if ( ( regno_base == SP_REGNUM ) && TARGET_UNIFIED_ASM ) { gcc_assert ( update ) ; sprintf ( pattern , <STR_LIT> , conditional ) ; } else { if ( regno_base == SP_REGNUM ) sprintf ( pattern , <STR_LIT> , conditional ) ; else if ( TARGET_UNIFIED_ASM ) sprintf ( pattern , <STR_LIT> , conditional ) ; else sprintf ( pattern , <STR_LIT> , conditional ) ; strcat ( pattern , reg_names [ regno_base ] ) ; if ( update ) strcat ( pattern , <STR_LIT> ) ; else strcat ( pattern , <STR_LIT> ) ; } strcat ( pattern , reg_names [ REGNO ( XEXP ( XVECEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> , offset ) , <NUM_LIT> ) ) ] ) ; for ( i = offset + <NUM_LIT> ; i < num_saves ; i ++ ) { strcat ( pattern , <STR_LIT> ) ; strcat ( pattern , reg_names [ REGNO ( XEXP ( XVECEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> , i ) , <NUM_LIT> ) ) ] ) ;


<s> if ( type && BYTES_BIG_ENDIAN && INTEGRAL_TYPE_P ( type ) ) return false ; return true ;


<s> if ( ! TARGET_AAPCS_BASED ) return DEFAULT_FUNCTION_ARG_PADDING ( mode , type ) == upward ; if ( type && BYTES_BIG_ENDIAN && INTEGRAL_TYPE_P ( type ) ) return false ;


<s> return type && TREE_CODE ( TYPE_SIZE ( type ) ) != INTEGER_CST ;


<s> labelno = GEN_INT ( pic_labelno ++ ) ; l1 = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , labelno ) , UNSPEC_PIC_LABEL ) ; l1 = gen_rtx_CONST ( VOIDmode , l1 ) ; offset_rtx = plus_constant ( Pmode , l1 , TARGET_ARM ? <NUM_LIT> : <NUM_LIT> ) ;

offset_rtx = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , orig , offset_rtx ) , UNSPEC_SYMBOL_OFFSET ) ;


<s> l1 = gen_rtx_CONST ( VOIDmode , l1 ) ; offset_rtx = plus_constant ( Pmode , l1 , TARGET_ARM ? <NUM_LIT> : <NUM_LIT> ) ; offset_rtx = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , orig , offset_rtx ) , UNSPEC_SYMBOL_OFFSET ) ; offset_rtx = gen_rtx_CONST ( Pmode , offset_rtx ) ; insn = emit_insn ( gen_pic_load_addr_unified ( reg , offset_rtx , labelno ) ) ;


<s> case LSHIFTRT : case ASHIFT : case ROTATERT : { asm_fprintf ( stream , <STR_LIT> , REGNO ( base ) , is_minus ? <STR_LIT> : <STR_LIT> , REGNO ( XEXP ( index , <NUM_LIT> ) ) ) ; arm_print_operand ( stream , index , 'S' ) ; fputs ( <STR_LIT> , stream ) ; break ; } default : gcc_unreachable ( ) ; } } else if ( GET_CODE ( x ) == PRE_INC || GET_CODE ( x ) == POST_INC || GET_CODE ( x ) == PRE_DEC || GET_CODE ( x ) == POST_DEC ) { extern machine_mode output_memory_reference_mode ; gcc_assert ( REG_P ( XEXP ( x , <NUM_LIT> ) ) ) ; if ( GET_CODE ( x ) == PRE_DEC || GET_CODE ( x ) == PRE_INC ) asm_fprintf ( stream , <STR_LIT> , REGNO ( XEXP ( x , <NUM_LIT> ) ) , GET_CODE ( x ) == PRE_DEC ? <STR_LIT> : <STR_LIT> , GET_MODE_SIZE ( output_memory_reference_mode ) ) ; else asm_fprintf ( stream , <STR_LIT> , REGNO ( XEXP ( x , <NUM_LIT> ) ) , GET_CODE ( x ) == POST_DEC ? <STR_LIT> : <STR_LIT> , GET_MODE_SIZE ( output_memory_reference_mode ) ) ; } else if ( GET_CODE ( x ) == PRE_MODIFY ) { asm_fprintf ( stream , <STR_LIT> , REGNO ( XEXP ( x , <NUM_LIT> ) ) ) ; if ( CONST_INT_P ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) ) asm_fprintf ( stream , <STR_LIT> , INTVAL ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) ) ; else asm_fprintf ( stream , <STR_LIT> , REGNO ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) ) ; } else if ( GET_CODE ( x ) == POST_MODIFY ) { asm_fprintf ( stream , <STR_LIT> , REGNO ( XEXP ( x , <NUM_LIT> ) ) ) ; if ( CONST_INT_P ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) ) asm_fprintf ( stream , <STR_LIT> , INTVAL ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) ) ; else asm_fprintf ( stream , <STR_LIT> , REGNO ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) ) ;


<s> static tree arm_promoted_type ( const_tree t ) {

if ( SCALAR_FLOAT_TYPE_P ( t ) && TYPE_PRECISION ( t ) == <NUM_LIT> ) return float_type_node ;


<s> } if ( TARGET_THUMB2 && regno < <NUM_LIT> ) return LO_REGS ; if ( regno <= LAST_ARM_REGNUM || regno == FRAME_POINTER_REGNUM || regno == ARG_POINTER_REGNUM ) return TARGET_THUMB2 ? HI_REGS : GENERAL_REGS ; if ( regno == CC_REGNUM || regno == VFPCC_REGNUM ) return TARGET_THUMB2 ? CC_REG : NO_REGS ; if ( IS_VFP_REGNUM ( regno ) ) { if ( regno <= D7_VFP_REGNUM ) return VFP_D0_D7_REGS ; else if ( regno <= LAST_LO_VFP_REGNUM ) return VFP_LO_REGS ;


<s> if ( TARGET_THUMB2 && regno < <NUM_LIT> ) return LO_REGS ; if ( regno <= LAST_ARM_REGNUM || regno == FRAME_POINTER_REGNUM || regno == ARG_POINTER_REGNUM ) return TARGET_THUMB2 ? HI_REGS : GENERAL_REGS ; if ( regno == CC_REGNUM || regno == VFPCC_REGNUM ) return TARGET_THUMB2 ? CC_REG : NO_REGS ; if ( IS_VFP_REGNUM ( regno ) ) { if ( regno <= D7_VFP_REGNUM ) return VFP_D0_D7_REGS ; else if ( regno <= LAST_LO_VFP_REGNUM ) return VFP_LO_REGS ; else return VFP_HI_REGS ;


<s> rtx ref = operands [ <NUM_LIT> ] ; rtx base , scratch ; HOST_WIDE_INT offset = <NUM_LIT> ; if ( GET_CODE ( ref ) == SUBREG ) { offset = SUBREG_BYTE ( ref ) ; ref = SUBREG_REG ( ref ) ; } if ( REG_P ( ref ) ) { if ( reg_equiv_mem ( REGNO ( ref ) ) ) { ref = reg_equiv_mem ( REGNO ( ref ) ) ; base = find_replacement ( & XEXP ( ref , <NUM_LIT> ) ) ; } else base = reg_equiv_address ( REGNO ( ref ) ) ; } else base = find_replacement ( & XEXP ( ref , <NUM_LIT> ) ) ; if ( GET_CODE ( base ) == MINUS || ( GET_CODE ( base ) == PLUS && ! CONST_INT_P ( XEXP ( base , <NUM_LIT> ) ) ) ) { rtx base_plus = gen_rtx_REG ( SImode , REGNO ( operands [ <NUM_LIT> ] ) + <NUM_LIT> ) ; emit_set_insn ( base_plus , base ) ; base = base_plus ; } else if ( GET_CODE ( base ) == PLUS ) { HOST_WIDE_INT hi , lo ; offset += INTVAL ( XEXP ( base , <NUM_LIT> ) ) ; base = XEXP ( base , <NUM_LIT> ) ; lo = ( offset >= <NUM_LIT> ? ( offset & <NUM_LIT> ) : - ( ( - offset ) & <NUM_LIT> ) ) ; if ( lo == <NUM_LIT> ) lo &= <NUM_LIT> ; hi = ( ( ( ( offset - lo ) & ( HOST_WIDE_INT ) <NUM_LIT> ) ^ ( HOST_WIDE_INT ) <NUM_LIT> ) - ( HOST_WIDE_INT ) <NUM_LIT> ) ; gcc_assert ( hi + lo == offset ) ; if ( hi != <NUM_LIT> ) { rtx base_plus = gen_rtx_REG ( SImode , REGNO ( operands [ <NUM_LIT> ] ) + <NUM_LIT> ) ;

emit_insn ( gen_addsi3 ( base_plus , base , GEN_INT ( hi ) ) ) ;


<s> rtx ref = operands [ <NUM_LIT> ] ; rtx outval = operands [ <NUM_LIT> ] ; rtx base , scratch ; HOST_WIDE_INT offset = <NUM_LIT> ; if ( GET_CODE ( ref ) == SUBREG ) { offset = SUBREG_BYTE ( ref ) ; ref = SUBREG_REG ( ref ) ; } if ( REG_P ( ref ) ) { if ( reg_equiv_mem ( REGNO ( ref ) ) ) { ref = reg_equiv_mem ( REGNO ( ref ) ) ; base = find_replacement ( & XEXP ( ref , <NUM_LIT> ) ) ; } else base = reg_equiv_address ( REGNO ( ref ) ) ; } else base = find_replacement ( & XEXP ( ref , <NUM_LIT> ) ) ; scratch = gen_rtx_REG ( SImode , REGNO ( operands [ <NUM_LIT> ] ) ) ; if ( GET_CODE ( base ) == MINUS || ( GET_CODE ( base ) == PLUS && ! CONST_INT_P ( XEXP ( base , <NUM_LIT> ) ) ) ) { rtx base_plus = gen_rtx_REG ( SImode , REGNO ( operands [ <NUM_LIT> ] ) + <NUM_LIT> ) ; if ( reg_overlap_mentioned_p ( base_plus , outval ) ) { if ( ! reg_overlap_mentioned_p ( scratch , outval ) ) std :: swap ( scratch , base_plus ) ; else { rtx scratch_hi = gen_rtx_REG ( HImode , REGNO ( operands [ <NUM_LIT> ] ) ) ; emit_insn ( gen_movhi ( scratch_hi , outval ) ) ; outval = scratch_hi ; } } emit_set_insn ( base_plus , base ) ; base = base_plus ; } else if ( GET_CODE ( base ) == PLUS ) { HOST_WIDE_INT hi , lo ; offset += INTVAL ( XEXP ( base , <NUM_LIT> ) ) ; base = XEXP ( base , <NUM_LIT> ) ; lo = ( offset >= <NUM_LIT> ? ( offset & <NUM_LIT> ) : - ( ( - offset ) & <NUM_LIT> ) ) ; if ( lo == <NUM_LIT> ) lo &= <NUM_LIT> ; hi = ( ( ( ( offset - lo ) & ( HOST_WIDE_INT ) <NUM_LIT> ) ^ ( HOST_WIDE_INT ) <NUM_LIT> ) - ( HOST_WIDE_INT ) <NUM_LIT> ) ; gcc_assert ( hi + lo == offset ) ; if ( hi != <NUM_LIT> ) { rtx base_plus = gen_rtx_REG ( SImode , REGNO ( operands [ <NUM_LIT> ] ) + <NUM_LIT> ) ; if ( reg_overlap_mentioned_p ( base_plus , outval ) ) { if ( ! reg_overlap_mentioned_p ( scratch , outval ) ) std :: swap ( scratch , base_plus ) ; else { rtx scratch_hi = gen_rtx_REG ( HImode , REGNO ( operands [ <NUM_LIT> ] ) ) ; emit_insn ( gen_movhi ( scratch_hi , outval ) ) ; outval = scratch_hi ; }


<s> fix = minipool_fix_head ; while ( fix ) { Mfix * ftmp ; Mfix * fdel ; Mfix * last_added_fix ; Mfix * last_barrier = NULL ; Mfix * this_fix ; while ( fix && BARRIER_P ( fix -> insn ) ) fix = fix -> next ; if ( fix == NULL ) break ; last_added_fix = NULL ; for ( ftmp = fix ; ftmp ; ftmp = ftmp -> next ) { if ( BARRIER_P ( ftmp -> insn ) ) { if ( ftmp -> address >= minipool_vector_head -> max_address ) break ; last_barrier = ftmp ; } else if ( ( ftmp -> minipool = add_minipool_forward_ref ( ftmp ) ) == NULL ) break ; last_added_fix = ftmp ; } if ( last_barrier != NULL ) { for ( fdel = last_barrier -> next ; fdel && fdel != ftmp ; fdel = fdel -> next ) { fdel -> minipool -> refcount -- ; fdel -> minipool = NULL ; } ftmp = last_barrier ; } else { HOST_WIDE_INT max_address ; gcc_assert ( ftmp ) ; max_address = minipool_vector_head -> max_address ; if ( ftmp -> address < max_address ) max_address = ftmp -> address + <NUM_LIT> ; last_barrier = create_fix_barrier ( last_added_fix , max_address ) ; } assign_minipool_offsets ( last_barrier ) ;


<s> address += get_jump_table_size ( table ) ; insn = table ; } } else if ( LABEL_P ( insn ) ) address += get_label_padding ( insn ) ; } fix = minipool_fix_head ; while ( fix ) { Mfix * ftmp ; Mfix * fdel ; Mfix * last_added_fix ; Mfix * last_barrier = NULL ; Mfix * this_fix ; while ( fix && BARRIER_P ( fix -> insn ) ) fix = fix -> next ; if ( fix == NULL ) break ; last_added_fix = NULL ; for ( ftmp = fix ; ftmp ; ftmp = ftmp -> next ) { if ( BARRIER_P ( ftmp -> insn ) ) { if ( ftmp -> address >= minipool_vector_head -> max_address ) break ; last_barrier = ftmp ; } else if ( ( ftmp -> minipool = add_minipool_forward_ref ( ftmp ) ) == NULL ) break ; last_added_fix = ftmp ; } if ( last_barrier != NULL ) { for ( fdel = last_barrier -> next ; fdel && fdel != ftmp ; fdel = fdel -> next ) { fdel -> minipool -> refcount -- ; fdel -> minipool = NULL ; } ftmp = last_barrier ; } else { HOST_WIDE_INT max_address ; gcc_assert ( ftmp ) ; max_address = minipool_vector_head -> max_address ; if ( ftmp -> address < max_address ) max_address = ftmp -> address + <NUM_LIT> ; last_barrier = create_fix_barrier ( last_added_fix , max_address ) ; } assign_minipool_offsets ( last_barrier ) ; while ( ftmp ) { if ( ! BARRIER_P ( ftmp -> insn ) && ( ( ftmp -> minipool = add_minipool_backward_ref ( ftmp ) ) == NULL ) ) break ; ftmp = ftmp -> next ; } for ( this_fix = fix ; this_fix && ftmp != this_fix ;

this_fix = this_fix -> next ) if ( ! BARRIER_P ( this_fix -> insn ) ) {


<s> if ( current_tune -> insn_extra_cost ) result = arm_new_rtx_costs ( x , ( enum rtx_code ) code , ( enum rtx_code ) outer_code , current_tune -> insn_extra_cost , total , speed ) ; else result = arm_new_rtx_costs ( x , ( enum rtx_code ) code , ( enum rtx_code ) outer_code , & generic_extra_costs , total , speed ) ; } if ( dump_file && ( dump_flags & TDF_DETAILS ) ) { print_rtl_single ( dump_file , x ) ; fprintf ( dump_file , <STR_LIT> , speed ? <STR_LIT> : <STR_LIT> , * total , result ? <STR_LIT> : <STR_LIT> ) ;


<s> RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; saved_size += <NUM_LIT> ; } if ( TARGET_HARD_FLOAT && TARGET_VFP ) { start_reg = FIRST_VFP_REGNUM ; for ( reg = FIRST_VFP_REGNUM ; reg < LAST_VFP_REGNUM ; reg += <NUM_LIT> ) { if ( ( ! df_regs_ever_live_p ( reg ) || call_used_regs [ reg ] ) && ( ! df_regs_ever_live_p ( reg + <NUM_LIT> ) || call_used_regs [ reg + <NUM_LIT> ] ) ) {

if ( start_reg != reg ) saved_size += vfp_emit_fstmd ( start_reg , ( reg - start_reg ) / <NUM_LIT> ) ;


<s> if ( mode == HFmode ) return ( arm_fp16_format != ARM_FP16_FORMAT_NONE ) ; else if ( ALL_FIXED_POINT_MODE_P ( mode ) ) return true ; else return default_scalar_mode_supported_p ( mode ) ;


<s> if ( mode == HFmode ) return ( arm_fp16_format != ARM_FP16_FORMAT_NONE ) ; else if ( ALL_FIXED_POINT_MODE_P ( mode ) ) return true ;

else return default_scalar_mode_supported_p ( mode ) ;


<s> switch ( arm_tune ) { case cortexa7 : cortexa7_sched_reorder ( file , verbose , ready , n_readyp , clock ) ; break ;


<s> static int arm_sched_reorder ( FILE * file , int verbose , rtx_insn * * ready , int * n_readyp , int clock ) { switch ( arm_tune ) { case cortexa7 : cortexa7_sched_reorder ( file , verbose , ready , n_readyp , clock ) ; break ; default : break ;


<s> if ( GET_CODE ( x ) == AND && ( op == EQ || op == NE ) && COMPARISON_P ( XEXP ( x , <NUM_LIT> ) ) && COMPARISON_P ( XEXP ( x , <NUM_LIT> ) ) ) return arm_select_dominance_cc_mode ( XEXP ( x , <NUM_LIT> ) , XEXP ( x , <NUM_LIT> ) , DOM_CC_X_AND_Y ) ; if ( GET_CODE ( x ) == IOR && ( op == EQ || op == NE ) && COMPARISON_P ( XEXP ( x , <NUM_LIT> ) ) && COMPARISON_P ( XEXP ( x , <NUM_LIT> ) ) ) return arm_select_dominance_cc_mode ( XEXP ( x , <NUM_LIT> ) , XEXP ( x , <NUM_LIT> ) , DOM_CC_X_OR_Y ) ; if ( TARGET_THUMB1 && GET_MODE ( x ) == SImode && ( op == EQ || op == NE ) && GET_CODE ( x ) == ZERO_EXTRACT && XEXP ( x , <NUM_LIT> ) == const1_rtx ) return CC_Nmode ; if ( GET_MODE ( x ) == SImode && y == const0_rtx && ( op == EQ || op == NE || op == LT || op == GE ) && ( GET_CODE ( x ) == PLUS || GET_CODE ( x ) == MINUS || GET_CODE ( x ) == AND || GET_CODE ( x ) == IOR || GET_CODE ( x ) == XOR || GET_CODE ( x ) == MULT || GET_CODE ( x ) == NOT || GET_CODE ( x ) == NEG || GET_CODE ( x ) == LSHIFTRT || GET_CODE ( x ) == ASHIFT || GET_CODE ( x ) == ASHIFTRT || GET_CODE ( x ) == ROTATERT || ( TARGET_32BIT && GET_CODE ( x ) == ZERO_EXTRACT ) ) ) return CC_NOOVmode ; if ( GET_MODE ( x ) == QImode && ( op == EQ || op == NE ) ) return CC_Zmode ; if ( GET_MODE ( x ) == SImode && ( op == LTU || op == GEU ) && GET_CODE ( x ) == PLUS && ( rtx_equal_p ( XEXP ( x , <NUM_LIT> ) , y ) || rtx_equal_p ( XEXP ( x , <NUM_LIT> ) , y ) ) ) return CC_Cmode ; if ( GET_MODE ( x ) == DImode || GET_MODE ( y ) == DImode ) { switch ( op ) { case EQ : case NE : if ( y == const0_rtx ) return CC_Zmode ; if ( ! TARGET_32BIT ) return CC_Zmode ; case LTU : case LEU : case GTU : case GEU : if ( TARGET_32BIT ) return CC_CZmode ; case LT : case LE :


<s> CUMULATIVE_ARGS * pcum = get_cumulative_args ( pcum_v ) ; int nregs ; cfun -> machine -> uses_anonymous_args = <NUM_LIT> ; if ( pcum -> pcs_variant <= ARM_PCS_AAPCS_LOCAL ) { nregs = pcum -> aapcs_ncrn ; if ( ( nregs & <NUM_LIT> ) && arm_needs_doubleword_align ( mode , type ) ) nregs ++ ;


<s> nregs = pcum -> aapcs_ncrn ; if ( ( nregs & <NUM_LIT> ) && arm_needs_doubleword_align ( mode , type ) ) nregs ++ ; } else nregs = pcum -> nregs ;

if ( nregs < NUM_ARG_REGS ) * pretend_size = ( NUM_ARG_REGS - nregs ) * UNITS_PER_WORD ;


<s> rtx addr ; unsigned long saved_regs ; offsets = arm_get_frame_offsets ( ) ; saved_regs = offsets -> saved_regs_mask ; if ( ( saved_regs & ( <NUM_LIT> << LR_REGNUM ) ) == <NUM_LIT> ) emit_move_insn ( gen_rtx_REG ( Pmode , LR_REGNUM ) , source ) ; else { if ( frame_pointer_needed ) addr = plus_constant ( Pmode , hard_frame_pointer_rtx , - <NUM_LIT> ) ; else { delta = offsets -> outgoing_args - ( offsets -> frame + <NUM_LIT> ) ; if ( delta >= <NUM_LIT> ) { emit_insn ( gen_addsi3 ( scratch , stack_pointer_rtx , GEN_INT ( delta & ~ <NUM_LIT> ) ) ) ; addr = scratch ; delta &= <NUM_LIT> ; } else addr = stack_pointer_rtx ;

addr = plus_constant ( Pmode , addr , delta ) ;


<s> rtx addr ; unsigned long saved_regs ; offsets = arm_get_frame_offsets ( ) ; saved_regs = offsets -> saved_regs_mask ; if ( ( saved_regs & ( <NUM_LIT> << LR_REGNUM ) ) == <NUM_LIT> ) emit_move_insn ( gen_rtx_REG ( Pmode , LR_REGNUM ) , source ) ; else {

if ( frame_pointer_needed ) addr = plus_constant ( Pmode , hard_frame_pointer_rtx , - <NUM_LIT> ) ;


<s> if ( CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) ) { unsigned HOST_WIDE_INT i = ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) & ( unsigned HOST_WIDE_INT ) <NUM_LIT> ) ; int cost , const_ok = const_ok_for_arm ( i ) ; int j , booth_unit_size ; cost = const_ok ? <NUM_LIT> : <NUM_LIT> ; booth_unit_size = <NUM_LIT> ; for ( j = <NUM_LIT> ; i && j < <NUM_LIT> ; j += booth_unit_size ) { i >>= booth_unit_size ; cost ++ ; }


<s> is_weak = ( operands [ <NUM_LIT> ] != const0_rtx ) ; mod_s = ( enum memmodel ) INTVAL ( operands [ <NUM_LIT> ] ) ; mod_f = ( enum memmodel ) INTVAL ( operands [ <NUM_LIT> ] ) ; scratch = operands [ <NUM_LIT> ] ; mode = GET_MODE ( mem ) ; bool use_acquire = TARGET_HAVE_LDACQ && ! ( mod_s == MEMMODEL_RELAXED || mod_s == MEMMODEL_CONSUME || mod_s == MEMMODEL_RELEASE ) ; bool use_release = TARGET_HAVE_LDACQ && ! ( mod_s == MEMMODEL_RELAXED || mod_s == MEMMODEL_CONSUME || mod_s == MEMMODEL_ACQUIRE ) ; if ( ! ( use_acquire || use_release ) ) arm_pre_atomic_barrier ( mod_s ) ; label1 = NULL ; if ( ! is_weak ) { label1 = gen_label_rtx ( ) ; emit_label ( label1 ) ; } label2 = gen_label_rtx ( ) ; arm_emit_load_exclusive ( mode , rval , mem , use_acquire ) ; cond = arm_gen_compare_reg ( NE , rval , oldval , scratch ) ; x = gen_rtx_NE ( VOIDmode , cond , const0_rtx ) ; x = gen_rtx_IF_THEN_ELSE ( VOIDmode , x , gen_rtx_LABEL_REF ( Pmode , label2 ) , pc_rtx ) ; emit_unlikely_jump ( gen_rtx_SET ( VOIDmode , pc_rtx , x ) ) ; arm_emit_store_exclusive ( mode , scratch , mem , newval , use_release ) ;

cond = gen_rtx_REG ( CCmode , CC_REGNUM ) ;


<s> oldval = operands [ <NUM_LIT> ] ; newval = operands [ <NUM_LIT> ] ; is_weak = ( operands [ <NUM_LIT> ] != const0_rtx ) ; mod_s = ( enum memmodel ) INTVAL ( operands [ <NUM_LIT> ] ) ; mod_f = ( enum memmodel ) INTVAL ( operands [ <NUM_LIT> ] ) ; scratch = operands [ <NUM_LIT> ] ; mode = GET_MODE ( mem ) ; bool use_acquire = TARGET_HAVE_LDACQ && ! ( mod_s == MEMMODEL_RELAXED || mod_s == MEMMODEL_CONSUME || mod_s == MEMMODEL_RELEASE ) ; bool use_release = TARGET_HAVE_LDACQ && ! ( mod_s == MEMMODEL_RELAXED || mod_s == MEMMODEL_CONSUME || mod_s == MEMMODEL_ACQUIRE ) ; if ( ! ( use_acquire || use_release ) ) arm_pre_atomic_barrier ( mod_s ) ; label1 = NULL ; if ( ! is_weak ) { label1 = gen_label_rtx ( ) ; emit_label ( label1 ) ; } label2 = gen_label_rtx ( ) ; arm_emit_load_exclusive ( mode , rval , mem , use_acquire ) ; cond = arm_gen_compare_reg ( NE , rval , oldval , scratch ) ; x = gen_rtx_NE ( VOIDmode , cond , const0_rtx ) ; x = gen_rtx_IF_THEN_ELSE ( VOIDmode , x , gen_rtx_LABEL_REF ( Pmode , label2 ) , pc_rtx ) ; emit_unlikely_jump ( gen_rtx_SET ( VOIDmode , pc_rtx , x ) ) ; arm_emit_store_exclusive ( mode , scratch , mem , newval , use_release ) ; cond = gen_rtx_REG ( CCmode , CC_REGNUM ) ; x = gen_rtx_COMPARE ( CCmode , scratch , const0_rtx ) ; emit_insn ( gen_rtx_SET ( VOIDmode , cond , x ) ) ; if ( ! is_weak ) { x = gen_rtx_NE ( VOIDmode , cond , const0_rtx ) ; x = gen_rtx_IF_THEN_ELSE ( VOIDmode , x , gen_rtx_LABEL_REF ( Pmode , label1 ) , pc_rtx ) ; emit_unlikely_jump ( gen_rtx_SET ( VOIDmode , pc_rtx , x ) ) ; } if ( mod_f != MEMMODEL_RELAXED ) emit_label ( label2 ) ;

if ( ! ( use_acquire || use_release ) ) arm_post_atomic_barrier ( mod_s ) ;


<s> bool arm_tls_referenced_p ( rtx x ) { if ( ! TARGET_HAVE_TLS ) return false ; subrtx_iterator :: array_type array ; FOR_EACH_SUBRTX ( iter , array , x , ALL ) { const_rtx x = * iter ; if ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL ( x ) != <NUM_LIT> ) return true ;

if ( GET_CODE ( x ) == UNSPEC && XINT ( x , <NUM_LIT> ) == UNSPEC_TLS ) iter . skip_subrtxes ( ) ;


<s> static rtx arm_trampoline_adjust_address ( rtx addr ) { if ( TARGET_THUMB ) addr = expand_simple_binop ( Pmode , IOR , addr , const1_rtx , NULL , <NUM_LIT> , OPTAB_LIB_WIDEN ) ; return addr ;


<s> mem = adjust_address ( m_tramp , SImode , TARGET_32BIT ? <NUM_LIT> : <NUM_LIT> ) ; fnaddr = XEXP ( DECL_RTL ( fndecl ) , <NUM_LIT> ) ; emit_move_insn ( mem , fnaddr ) ;

a_tramp = XEXP ( m_tramp , <NUM_LIT> ) ;


<s> if ( speed_p ) * cost += ( ARM_NUM_REGS ( GET_MODE ( x ) ) * extra_cost -> ldst . store + extra_cost -> ldst . store_unaligned ) ; * cost += rtx_cost ( XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) , UNSPEC , <NUM_LIT> , speed_p ) ; * cost += arm_address_cost ( XEXP ( XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) , <NUM_LIT> ) , GET_MODE ( x ) , ADDR_SPACE_GENERIC , speed_p ) ; return true ; case UNSPEC_VRINTZ : case UNSPEC_VRINTP : case UNSPEC_VRINTM : case UNSPEC_VRINTR : case UNSPEC_VRINTX : case UNSPEC_VRINTA : * cost = COSTS_N_INSNS ( <NUM_LIT> ) ; if ( speed_p ) * cost += extra_cost -> fp [ GET_MODE ( x ) == DFmode ] . roundint ; return true ; default : * cost = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; } return false ;


<s> * cost = COSTS_N_INSNS ( ARM_NUM_REGS ( GET_MODE ( x ) ) ) ; if ( speed_p ) * cost += ( ARM_NUM_REGS ( GET_MODE ( x ) ) * extra_cost -> ldst . load + extra_cost -> ldst . load_unaligned ) ; * cost += arm_address_cost ( XEXP ( XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) , <NUM_LIT> ) , GET_MODE ( x ) , ADDR_SPACE_GENERIC , speed_p ) ; return true ; case UNSPEC_UNALIGNED_STORE :


<s> lastreg = <NUM_LIT> ; for ( i = <NUM_LIT> ; i <= nregs ; i ++ ) { e = XVECEXP ( p , <NUM_LIT> , i ) ; gcc_assert ( GET_CODE ( e ) == SET && MEM_P ( SET_DEST ( e ) ) && REG_P ( SET_SRC ( e ) ) ) ; reg = REGNO ( SET_SRC ( e ) ) ; gcc_assert ( reg >= lastreg ) ; if ( i != <NUM_LIT> ) fprintf ( asm_out_file , <STR_LIT> ) ; if ( IS_VFP_REGNUM ( reg ) ) asm_fprintf ( asm_out_file , <STR_LIT> , ( reg - FIRST_VFP_REGNUM ) / <NUM_LIT> ) ; else asm_fprintf ( asm_out_file , <STR_LIT> , reg ) ; e = XEXP ( SET_DEST ( e ) , <NUM_LIT> ) ; if ( GET_CODE ( e ) == PLUS ) gcc_assert ( REG_P ( XEXP ( e , <NUM_LIT> ) ) && REGNO ( XEXP ( e , <NUM_LIT> ) ) == SP_REGNUM && CONST_INT_P ( XEXP ( e , <NUM_LIT> ) ) && offset == INTVAL ( XEXP ( e , <NUM_LIT> ) ) ) ; else gcc_assert ( i == <NUM_LIT> && REG_P ( e ) && REGNO ( e ) == SP_REGNUM ) ; offset += reg_size ;


<s> bool arm_validize_comparison ( rtx * comparison , rtx * op1 , rtx * op2 ) { enum rtx_code code = GET_CODE ( * comparison ) ; int code_int ; machine_mode mode = ( GET_MODE ( * op1 ) == VOIDmode ) ? GET_MODE ( * op2 ) : GET_MODE ( * op1 ) ; gcc_assert ( GET_MODE ( * op1 ) != VOIDmode || GET_MODE ( * op2 ) != VOIDmode ) ; if ( code == UNEQ || code == LTGT ) return false ; code_int = ( int ) code ; arm_canonicalize_comparison ( & code_int , op1 , op2 , <NUM_LIT> ) ; PUT_CODE ( * comparison , ( enum rtx_code ) code_int ) ; switch ( mode ) { case SImode : if ( ! arm_add_operand ( * op1 , mode ) ) * op1 = force_reg ( mode , * op1 ) ; if ( ! arm_add_operand ( * op2 , mode ) ) * op2 = force_reg ( mode , * op2 ) ; return true ; case DImode : if ( ! cmpdi_operand ( * op1 , mode ) ) * op1 = force_reg ( mode , * op1 ) ; if ( ! cmpdi_operand ( * op2 , mode ) ) * op2 = force_reg ( mode , * op2 ) ; return true ; case SFmode :


<s> d . one_vector_p = ( which != <NUM_LIT> ) ; d . target = gen_raw_REG ( d . vmode , LAST_VIRTUAL_REGISTER + <NUM_LIT> ) ; d . op1 = d . op0 = gen_raw_REG ( d . vmode , LAST_VIRTUAL_REGISTER + <NUM_LIT> ) ; if ( ! d . one_vector_p ) d . op1 = gen_raw_REG ( d . vmode , LAST_VIRTUAL_REGISTER + <NUM_LIT> ) ; start_sequence ( ) ; ret = arm_expand_vec_perm_const_1 ( & d ) ; end_sequence ( ) ;


<s> if ( TARGET_INT_SIMD && ( mode == V4UQQmode || mode == V4QQmode || mode == V2UHQmode || mode == V2HQmode || mode == V2UHAmode || mode == V2HAmode ) ) return true ; return false ;


<s> if ( TARGET_NEON && ( mode == V2SFmode || mode == V4SImode || mode == V8HImode || mode == V4HFmode || mode == V16QImode || mode == V4SFmode || mode == V2DImode ) ) return true ; if ( ( TARGET_NEON || TARGET_IWMMXT ) && ( ( mode == V2SImode ) || ( mode == V4HImode ) || ( mode == V8QImode ) ) ) return true ;

if ( TARGET_INT_SIMD && ( mode == V4UQQmode || mode == V4QQmode || mode == V2UHQmode || mode == V2HQmode || mode == V2UHAmode || mode == V2HAmode ) ) return true ;


<s> static void bounds_check ( rtx operand , HOST_WIDE_INT low , HOST_WIDE_INT high , const char * err ) {


<s> int const_ok_for_arm ( HOST_WIDE_INT i ) { int lowbit ; if ( ( i & ~ ( unsigned HOST_WIDE_INT ) <NUM_LIT> ) != <NUM_LIT> && ( ( i & ~ ( unsigned HOST_WIDE_INT ) <NUM_LIT> ) != ( ( ~ ( unsigned HOST_WIDE_INT ) <NUM_LIT> ) & ~ ( unsigned HOST_WIDE_INT ) <NUM_LIT> ) ) ) return FALSE ; i &= ( unsigned HOST_WIDE_INT ) <NUM_LIT> ; if ( ( i & ~ ( unsigned HOST_WIDE_INT ) <NUM_LIT> ) == <NUM_LIT> ) return TRUE ; lowbit = ffs ( ( int ) i ) - <NUM_LIT> ; if ( TARGET_ARM ) lowbit &= ~ <NUM_LIT> ; if ( ( i & ~ ( ( ( unsigned HOST_WIDE_INT ) <NUM_LIT> ) << lowbit ) ) == <NUM_LIT> ) return TRUE ; if ( TARGET_ARM ) { if ( lowbit <= <NUM_LIT> && ( ( i & ~ <NUM_LIT> ) == <NUM_LIT> || ( i & ~ <NUM_LIT> ) == <NUM_LIT> || ( i & ~ <NUM_LIT> ) == <NUM_LIT> ) ) return TRUE ; } else { HOST_WIDE_INT v ; v = i & <NUM_LIT> ; v |= v << <NUM_LIT> ; if ( i == v || i == ( v | ( v << <NUM_LIT> ) ) ) return TRUE ; v = i & <NUM_LIT> ; v |= v << <NUM_LIT> ; if ( i == v ) return TRUE ;


<s> case AND : case IOR : case XOR : return ( const_ok_for_op ( hi_val , code ) || hi_val == <NUM_LIT> ) && ( const_ok_for_op ( lo_val , code ) || lo_val == <NUM_LIT> ) ; case PLUS : return arm_not_operand ( hi , SImode ) && arm_add_operand ( lo , SImode ) ;


<s> rtx lo = GEN_INT ( lo_val ) ; if ( TARGET_THUMB1 ) return <NUM_LIT> ; switch ( code ) { case AND : case IOR : case XOR : return ( const_ok_for_op ( hi_val , code ) || hi_val == <NUM_LIT> ) && ( const_ok_for_op ( lo_val , code ) || lo_val == <NUM_LIT> ) ; case PLUS : return arm_not_operand ( hi , SImode ) && arm_add_operand ( lo , SImode ) ; default :


<s> if ( const_ok_for_arm ( i ) ) return <NUM_LIT> ; switch ( code ) { case SET : if ( arm_arch_thumb2 && ( i & <NUM_LIT> ) == <NUM_LIT> ) return <NUM_LIT> ; else return const_ok_for_arm ( ARM_SIGN_EXTEND ( ~ i ) ) ; case PLUS : if ( TARGET_THUMB2 && ( ( i & <NUM_LIT> ) == <NUM_LIT> || ( ( - i ) & <NUM_LIT> ) == <NUM_LIT> ) ) return <NUM_LIT> ; case COMPARE : case EQ : case NE : case GT : case LE : case LT : case GE : case GEU : case LTU : case GTU : case LEU : case UNORDERED : case ORDERED : case UNEQ : case UNGE : case UNLT : case UNGT : case UNLE : return const_ok_for_arm ( ARM_SIGN_EXTEND ( - i ) ) ; case MINUS : case XOR : return <NUM_LIT> ; case IOR : if ( TARGET_THUMB2 ) return const_ok_for_arm ( ARM_SIGN_EXTEND ( ~ i ) ) ; return <NUM_LIT> ; case AND : return const_ok_for_arm ( ARM_SIGN_EXTEND ( ~ i ) ) ; default : gcc_unreachable ( ) ; }


<s> int const_ok_for_op ( HOST_WIDE_INT i , enum rtx_code code ) { if ( const_ok_for_arm ( i ) ) return <NUM_LIT> ; switch ( code ) { case SET : if ( arm_arch_thumb2 && ( i & <NUM_LIT> ) == <NUM_LIT> ) return <NUM_LIT> ; else return const_ok_for_arm ( ARM_SIGN_EXTEND ( ~ i ) ) ; case PLUS : if ( TARGET_THUMB2 && ( ( i & <NUM_LIT> ) == <NUM_LIT> || ( ( - i ) & <NUM_LIT> ) == <NUM_LIT> ) ) return <NUM_LIT> ; case COMPARE : case EQ : case NE : case GT : case LE : case LT : case GE : case GEU : case LTU : case GTU : case LEU :


<s> if ( TARGET_NEON && ( MEM_P ( x ) || GET_CODE ( x ) == CONST_VECTOR ) && ( GET_MODE_CLASS ( mode ) == MODE_VECTOR_INT || GET_MODE_CLASS ( mode ) == MODE_VECTOR_FLOAT || VALID_NEON_STRUCT_MODE ( mode ) ) ) return NO_REGS ;

if ( arm_coproc_mem_operand ( x , wb ) || s_register_operand ( x , mode ) ) return NO_REGS ;


<s> if ( ! TARGET_NEON_FP16 ) return GENERAL_REGS ; if ( s_register_operand ( x , mode ) || neon_vector_mem_operand ( x , <NUM_LIT> , true ) ) return NO_REGS ; return GENERAL_REGS ; } if ( TARGET_NEON && ( MEM_P ( x ) || GET_CODE ( x ) == CONST_VECTOR ) && ( GET_MODE_CLASS ( mode ) == MODE_VECTOR_INT || GET_MODE_CLASS ( mode ) == MODE_VECTOR_FLOAT || VALID_NEON_STRUCT_MODE ( mode ) ) ) return NO_REGS ; if ( arm_coproc_mem_operand ( x , wb ) || s_register_operand ( x , mode ) ) return NO_REGS ;


<s> case TYPE_FCMPD : case TYPE_FCONSTS : case TYPE_FCONSTD : case TYPE_FMULS : case TYPE_FMACS : case TYPE_FMULD : case TYPE_FMACD : case TYPE_FDIVS : case TYPE_FDIVD : case TYPE_F_MRC : case TYPE_F_MRRC : case TYPE_F_FLAG : case TYPE_F_LOADS : case TYPE_F_STORES : return true ; default :


<s> case REG_DEP_OUTPUT : if ( recog_memoized ( insn ) >= <NUM_LIT> && recog_memoized ( dep ) >= <NUM_LIT> ) { if ( GET_CODE ( PATTERN ( insn ) ) == SET ) { if ( GET_MODE_CLASS ( GET_MODE ( SET_DEST ( PATTERN ( insn ) ) ) ) == MODE_FLOAT || GET_MODE_CLASS ( GET_MODE ( SET_SRC ( PATTERN ( insn ) ) ) ) == MODE_FLOAT ) { enum attr_type attr_type_insn = get_attr_type ( insn ) ; enum attr_type attr_type_dep = get_attr_type ( dep ) ; if ( REG_P ( SET_DEST ( PATTERN ( insn ) ) ) && REG_P ( SET_DEST ( PATTERN ( dep ) ) ) && reg_overlap_mentioned_p ( SET_DEST ( PATTERN ( insn ) ) , SET_DEST ( PATTERN ( dep ) ) ) ) { if ( ( attr_type_insn == TYPE_FMACS || attr_type_insn == TYPE_FMACD ) && ( attr_type_dep == TYPE_FMACS || attr_type_dep == TYPE_FMACD ) ) { if ( REG_NOTE_KIND ( link ) == REG_DEP_OUTPUT ) * cost = insn_default_latency ( dep ) - <NUM_LIT> ;

else * cost = insn_default_latency ( dep ) ;


<s> rtx_insn * from = fix -> insn ; rtx_insn * selected = NULL ; int selected_cost ; HOST_WIDE_INT selected_address ; Mfix * new_fix ; HOST_WIDE_INT max_count = max_address - fix -> address ; rtx_code_label * label = gen_label_rtx ( ) ; selected_cost = arm_barrier_cost ( from ) ; selected_address = fix -> address ; while ( from && count < max_count ) { rtx_jump_table_data * tmp ; int new_cost ; gcc_assert ( ! BARRIER_P ( from ) ) ; if ( LABEL_P ( from ) ) count += get_label_padding ( from ) ; else count += get_attr_length ( from ) ; if ( tablejump_p ( from , NULL , & tmp ) ) { count += get_jump_table_size ( tmp ) ; new_cost = arm_barrier_cost ( from ) ; if ( count < max_count && ( ! selected || new_cost <= selected_cost ) ) { selected = tmp ; selected_cost = new_cost ; selected_address = fix -> address + count ; } from = NEXT_INSN ( tmp ) ; continue ; } new_cost = arm_barrier_cost ( from ) ; if ( count < max_count && ( ! selected || new_cost <= selected_cost ) ) { selected = from ; selected_cost = new_cost ; selected_address = fix -> address + count ;


<s> fprintf ( dump_file , <STR_LIT> , ( unsigned ) mp -> offset , ( unsigned long ) mp -> min_address , ( unsigned long ) mp -> max_address ) ; arm_print_value ( dump_file , mp -> value ) ; fputc ( '\n' , dump_file ) ; } switch ( GET_MODE_SIZE ( mp -> mode ) ) { case <NUM_LIT> : scan = emit_insn_after ( gen_consttable_1 ( mp -> value ) , scan ) ; break ; case <NUM_LIT> : scan = emit_insn_after ( gen_consttable_2 ( mp -> value ) , scan ) ; break ; case <NUM_LIT> : scan = emit_insn_after ( gen_consttable_4 ( mp -> value ) , scan ) ; break ; case <NUM_LIT> : scan = emit_insn_after ( gen_consttable_8 ( mp -> value ) , scan ) ; break ; case <NUM_LIT> : scan = emit_insn_after ( gen_consttable_16 ( mp -> value ) , scan ) ; break ; default : gcc_unreachable ( ) ; } } nmp = mp -> next ; free ( mp ) ; }


<s> XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_SET ( VOIDmode , gen_frame_mem ( BLKmode , gen_rtx_PRE_MODIFY ( Pmode , stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - <NUM_LIT> * num_regs ) ) ) , gen_rtx_UNSPEC ( BLKmode , gen_rtvec ( <NUM_LIT> , reg ) , UNSPEC_PUSH_MULT ) ) ; if ( dwarf_regs_mask & ( <NUM_LIT> << i ) ) { tmp = gen_rtx_SET ( VOIDmode , gen_frame_mem ( SImode , stack_pointer_rtx ) , reg ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( dwarf , <NUM_LIT> , dwarf_par_index ++ ) = tmp ; } break ; } } for ( j = <NUM_LIT> , i ++ ; j < num_regs ; i ++ ) { if ( mask & ( <NUM_LIT> << i ) ) { reg = gen_rtx_REG ( SImode , i ) ; XVECEXP ( par , <NUM_LIT> , j ) = gen_rtx_USE ( VOIDmode , reg ) ; if ( dwarf_regs_mask & ( <NUM_LIT> << i ) ) { tmp = gen_rtx_SET ( VOIDmode , gen_frame_mem ( SImode , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> * j ) ) , reg ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( dwarf , <NUM_LIT> , dwarf_par_index ++ ) = tmp ; } j ++ ; } } par = emit_insn ( par ) ; tmp = gen_rtx_SET ( VOIDmode , stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - <NUM_LIT> * num_regs ) ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( dwarf , <NUM_LIT> , <NUM_LIT> ) = tmp ; add_reg_note ( par , REG_FRAME_RELATED_EXPR , dwarf ) ; return par ;


<s> inline static rtx_insn * emit_set_insn ( rtx x , rtx y ) {

return emit_insn ( gen_rtx_SET ( VOIDmode , x , y ) ) ;


<s> static bool fa726te_sched_adjust_cost ( rtx_insn * insn , rtx link , rtx_insn * dep , int * cost ) { if ( REG_NOTE_KIND ( link ) == REG_DEP_TRUE && recog_memoized ( insn ) >= <NUM_LIT> && recog_memoized ( dep ) >= <NUM_LIT> && get_attr_conds ( dep ) == CONDS_SET ) { if ( get_attr_conds ( insn ) == CONDS_USE && get_attr_type ( insn ) != TYPE_BRANCH ) { * cost = <NUM_LIT> ; return false ; } if ( GET_CODE ( PATTERN ( insn ) ) == COND_EXEC || get_attr_conds ( insn ) == CONDS_USE ) { * cost = <NUM_LIT> ;


<s> if ( low_register_operand ( op0 , SImode ) ) { if ( low_register_operand ( op1 , SImode ) ) action = CONV ; else if ( rtx_equal_p ( dst , op0 ) && CONST_INT_P ( op1 ) && IN_RANGE ( INTVAL ( op1 ) , - <NUM_LIT> , <NUM_LIT> ) ) action = CONV ; else if ( CONST_INT_P ( op1 ) && IN_RANGE ( INTVAL ( op1 ) , - <NUM_LIT> , <NUM_LIT> ) ) action = CONV ; } else if ( GET_CODE ( XEXP ( src , <NUM_LIT> ) ) == PLUS && rtx_equal_p ( XEXP ( XEXP ( src , <NUM_LIT> ) , <NUM_LIT> ) , dst ) && low_register_operand ( XEXP ( XEXP ( src , <NUM_LIT> ) , <NUM_LIT> ) , SImode ) && COMPARISON_P ( op1 ) && cc_register ( XEXP ( op1 , <NUM_LIT> ) , VOIDmode ) && maybe_get_arm_condition_code ( op1 ) == ARM_CS && XEXP ( op1 , <NUM_LIT> ) == const0_rtx ) action = CONV ; break ; case MINUS : if ( low_register_operand ( op0 , SImode ) && low_register_operand ( op1 , SImode ) ) action = CONV ; break ; case MULT : if ( ! optimize_size ) break ; case AND : case IOR : case XOR : if ( rtx_equal_p ( dst , op0 ) && low_register_operand ( op1 , SImode ) ) action = action_for_partial_flag_setting ; else if ( rtx_equal_p ( dst , op1 ) && low_register_operand ( op0 , SImode ) ) action = action_for_partial_flag_setting == SKIP ? SKIP : SWAP_CONV ; break ; case ASHIFTRT : case ASHIFT : case LSHIFTRT : if ( rtx_equal_p ( dst , op0 ) && low_register_operand ( op1 , SImode ) ) action = action_for_partial_flag_setting ; else if ( low_register_operand ( op0 , SImode ) && CONST_INT_P ( op1 ) && IN_RANGE ( INTVAL ( op1 ) , <NUM_LIT> , <NUM_LIT> ) ) action = action_for_partial_flag_setting ; break ; case ROTATERT : if ( rtx_equal_p ( dst , op0 ) && low_register_operand ( op1 , SImode ) ) action = action_for_partial_flag_setting ; break ; case NOT : if ( low_register_operand ( op0 , SImode ) ) action = action_for_partial_flag_setting ; break ; case NEG : if ( low_register_operand ( op0 , SImode ) ) action = CONV ; break ; case CONST_INT : if ( CONST_INT_P ( src ) && IN_RANGE ( INTVAL ( src ) , <NUM_LIT> , <NUM_LIT> ) ) action = action_for_partial_flag_setting ; break ; case REG : break ; default : break ; } }


<s> if ( low_register_operand ( op0 , SImode ) && low_register_operand ( op1 , SImode ) ) action = CONV ; break ; case MULT : if ( ! optimize_size ) break ; case AND : case IOR : case XOR : if ( rtx_equal_p ( dst , op0 ) && low_register_operand ( op1 , SImode ) ) action = action_for_partial_flag_setting ; else if ( rtx_equal_p ( dst , op1 ) && low_register_operand ( op0 , SImode ) ) action = action_for_partial_flag_setting == SKIP ? SKIP : SWAP_CONV ; break ; case ASHIFTRT : case ASHIFT : case LSHIFTRT : if ( rtx_equal_p ( dst , op0 ) && low_register_operand ( op1 , SImode ) ) action = action_for_partial_flag_setting ; else if ( low_register_operand ( op0 , SImode ) && CONST_INT_P ( op1 ) && IN_RANGE ( INTVAL ( op1 ) , <NUM_LIT> , <NUM_LIT> ) ) action = action_for_partial_flag_setting ; break ; case ROTATERT : if ( rtx_equal_p ( dst , op0 ) && low_register_operand ( op1 , SImode ) ) action = action_for_partial_flag_setting ; break ; case NOT : if ( low_register_operand ( op0 , SImode ) ) action = action_for_partial_flag_setting ; break ; case NEG : if ( low_register_operand ( op0 , SImode ) ) action = CONV ; break ; case CONST_INT : if ( CONST_INT_P ( src ) && IN_RANGE ( INTVAL ( src ) , <NUM_LIT> , <NUM_LIT> ) ) action = action_for_partial_flag_setting ; break ; case REG : break ; default : break ; } }


<s> if ( rtx_equal_p ( dst , op0 ) && register_operand ( op1 , SImode ) ) break ; if ( low_register_operand ( op0 , SImode ) ) { if ( low_register_operand ( op1 , SImode ) ) action = CONV ; else if ( rtx_equal_p ( dst , op0 ) && CONST_INT_P ( op1 ) && IN_RANGE ( INTVAL ( op1 ) , - <NUM_LIT> , <NUM_LIT> ) ) action = CONV ; else if ( CONST_INT_P ( op1 ) && IN_RANGE ( INTVAL ( op1 ) , - <NUM_LIT> , <NUM_LIT> ) ) action = CONV ; } else if ( GET_CODE ( XEXP ( src , <NUM_LIT> ) ) == PLUS && rtx_equal_p ( XEXP ( XEXP ( src , <NUM_LIT> ) , <NUM_LIT> ) , dst ) && low_register_operand ( XEXP ( XEXP ( src , <NUM_LIT> ) , <NUM_LIT> ) , SImode ) && COMPARISON_P ( op1 ) && cc_register ( XEXP ( op1 , <NUM_LIT> ) , VOIDmode ) && maybe_get_arm_condition_code ( op1 ) == ARM_CS && XEXP ( op1 , <NUM_LIT> ) == const0_rtx ) action = CONV ; break ; case MINUS : if ( low_register_operand ( op0 , SImode ) && low_register_operand ( op1 , SImode ) ) action = CONV ; break ; case MULT : if ( ! optimize_size ) break ; case AND : case IOR : case XOR : if ( rtx_equal_p ( dst , op0 ) && low_register_operand ( op1 , SImode ) ) action = action_for_partial_flag_setting ; else if ( rtx_equal_p ( dst , op1 ) && low_register_operand ( op0 , SImode ) ) action = action_for_partial_flag_setting == SKIP ? SKIP : SWAP_CONV ; break ; case ASHIFTRT : case ASHIFT : case LSHIFTRT : if ( rtx_equal_p ( dst , op0 ) && low_register_operand ( op1 , SImode ) ) action = action_for_partial_flag_setting ; else if ( low_register_operand ( op0 , SImode ) && CONST_INT_P ( op1 ) && IN_RANGE ( INTVAL ( op1 ) , <NUM_LIT> , <NUM_LIT> ) ) action = action_for_partial_flag_setting ; break ; case ROTATERT : if ( rtx_equal_p ( dst , op0 ) && low_register_operand ( op1 , SImode ) ) action = action_for_partial_flag_setting ; break ; case NOT : if ( low_register_operand ( op0 , SImode ) ) action = action_for_partial_flag_setting ; break ; case NEG : if ( low_register_operand ( op0 , SImode ) ) action = CONV ; break ; case CONST_INT : if ( CONST_INT_P ( src ) && IN_RANGE ( INTVAL ( src ) , <NUM_LIT> , <NUM_LIT> ) ) action = action_for_partial_flag_setting ;


<s> FOR_EACH_SUBRTX ( iter , array , x , ALL ) { const_rtx x = * iter ; if ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL ( x ) != <NUM_LIT> ) return true ; if ( GET_CODE ( x ) == UNSPEC && XINT ( x , <NUM_LIT> ) == UNSPEC_TLS ) iter . skip_subrtxes ( ) ;


<s> if ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL ( x ) != <NUM_LIT> ) return true ; if ( GET_CODE ( x ) == UNSPEC && XINT ( x , <NUM_LIT> ) == UNSPEC_TLS ) iter . skip_subrtxes ( ) ;


<s> static const char * fp_const_from_val ( REAL_VALUE_TYPE * r ) { if ( ! fp_consts_inited ) init_fp_table ( ) ; gcc_assert ( REAL_VALUES_EQUAL ( * r , value_fp0 ) ) ; return <STR_LIT> ;


<s> if ( ! fp_consts_inited ) init_fp_table ( ) ;

gcc_assert ( REAL_VALUES_EQUAL ( * r , value_fp0 ) ) ;


<s> if ( ldm_case == <NUM_LIT> ) return false ; if ( sort_regs ) for ( i = <NUM_LIT> ; i < nops - <NUM_LIT> ; i ++ ) for ( j = i + <NUM_LIT> ; j < nops ; j ++ ) if ( regs [ i ] > regs [ j ] ) { int t = regs [ i ] ; regs [ i ] = regs [ j ] ; regs [ j ] = t ; } base_reg_rtx = gen_rtx_REG ( Pmode , base_reg ) ; if ( TARGET_THUMB1 ) { gcc_assert ( peep2_reg_dead_p ( nops , base_reg_rtx ) ) ; gcc_assert ( ldm_case == <NUM_LIT> || ldm_case == <NUM_LIT> ) ; write_back = TRUE ; } if ( ldm_case == <NUM_LIT> ) { rtx newbase = TARGET_THUMB1 ? base_reg_rtx : gen_rtx_REG ( SImode , regs [ <NUM_LIT> ] ) ; emit_insn ( gen_addsi3 ( newbase , base_reg_rtx , GEN_INT ( offset ) ) ) ; offset = <NUM_LIT> ; if ( ! TARGET_THUMB1 ) {


<s> reg0 = gen_reg_rtx ( DImode ) ; if ( src_aligned ) emit_move_insn ( reg0 , src ) ; else emit_insn ( gen_unaligned_loaddi ( reg0 , src ) ) ; if ( dst_aligned ) emit_move_insn ( dst , reg0 ) ; else emit_insn ( gen_unaligned_storedi ( dst , reg0 ) ) ; src = next_consecutive_mem ( src ) ; dst = next_consecutive_mem ( dst ) ; } gcc_assert ( len < <NUM_LIT> ) ; if ( len >= <NUM_LIT> ) { reg0 = gen_reg_rtx ( SImode ) ; src = adjust_address ( src , SImode , <NUM_LIT> ) ; dst = adjust_address ( dst , SImode , <NUM_LIT> ) ; if ( src_aligned ) emit_move_insn ( reg0 , src ) ; else emit_insn ( gen_unaligned_loadsi ( reg0 , src ) ) ; if ( dst_aligned ) emit_move_insn ( dst , reg0 ) ; else emit_insn ( gen_unaligned_storesi ( dst , reg0 ) ) ; src = next_consecutive_mem ( src ) ; dst = next_consecutive_mem ( dst ) ; len -= <NUM_LIT> ; } if ( len == <NUM_LIT> ) return true ; if ( len >= <NUM_LIT> ) { dst = adjust_address ( dst , HImode , <NUM_LIT> ) ; src = adjust_address ( src , HImode , <NUM_LIT> ) ; reg0 = gen_reg_rtx ( SImode ) ; if ( src_aligned ) emit_insn ( gen_zero_extendhisi2 ( reg0 , src ) ) ; else emit_insn ( gen_unaligned_loadhiu ( reg0 , src ) ) ;

if ( dst_aligned ) emit_insn ( gen_movhi ( dst , gen_lowpart ( HImode , reg0 ) ) ) ;


<s> if ( JUMP_TABLES_IN_TEXT_SECTION || readonly_data_section == text_section ) { rtx body = PATTERN ( insn ) ; int elt = GET_CODE ( body ) == ADDR_DIFF_VEC ? <NUM_LIT> : <NUM_LIT> ; HOST_WIDE_INT size ; HOST_WIDE_INT modesize ; modesize = GET_MODE_SIZE ( GET_MODE ( body ) ) ; size = modesize * XVECLEN ( body , elt ) ;


return align > min_insn_size ? align - min_insn_size : <NUM_LIT> ;


<s> static HOST_WIDE_INT get_label_padding ( rtx label ) { HOST_WIDE_INT align , min_insn_size ; align = <NUM_LIT> << label_to_alignment ( label ) ;


<s> inline hashval_t libcall_hasher :: hash ( const value_type * p1 ) { return hash_rtx ( p1 , VOIDmode , NULL , NULL , FALSE ) ;


<s> return hash_rtx ( p1 , VOIDmode , NULL , NULL , FALSE ) ;


<s> if ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == UNSPEC && XINT ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) == UNSPEC_TLS ) return orig ; if ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) ) == UNSPEC && XINT ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) , <NUM_LIT> ) == UNSPEC_TLS ) { gcc_assert ( CONST_INT_P ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) ) ) ; return orig ; } if ( reg == <NUM_LIT> ) { gcc_assert ( can_create_pseudo_p ( ) ) ; reg = gen_reg_rtx ( Pmode ) ; } gcc_assert ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == PLUS ) ; base = legitimize_pic_address ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) , Pmode , reg ) ; offset = legitimize_pic_address ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) , Pmode , base == reg ? <NUM_LIT> : reg ) ; if ( CONST_INT_P ( offset ) ) { if ( ! arm_legitimate_index_p ( mode , offset , SET , <NUM_LIT> ) ) { gcc_assert ( can_create_pseudo_p ( ) ) ; offset = force_reg ( Pmode , offset ) ; } if ( CONST_INT_P ( offset ) ) return plus_constant ( Pmode , base , INTVAL ( offset ) ) ; } if ( GET_MODE_SIZE ( mode ) > <NUM_LIT> && ( GET_MODE_CLASS ( mode ) == MODE_INT || TARGET_SOFT_FLOAT ) ) { emit_insn ( gen_addsi3 ( reg , base , offset ) ) ;


<s> else if ( GET_CODE ( orig ) == CONST ) { rtx base , offset ; if ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == PLUS && XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) == cfun -> machine -> pic_reg ) return orig ; if ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == UNSPEC && XINT ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) == UNSPEC_TLS ) return orig ; if ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) ) == UNSPEC && XINT ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) , <NUM_LIT> ) == UNSPEC_TLS ) { gcc_assert ( CONST_INT_P ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) ) ) ; return orig ; }


<s> rtx dest , tp , label , labelno , sum , insns , ret , eqv , addend ; unsigned int model = SYMBOL_REF_TLS_MODEL ( x ) ; switch ( model ) { case TLS_MODEL_GLOBAL_DYNAMIC : if ( TARGET_GNU2_TLS ) { reg = arm_tls_descseq_addr ( x , reg ) ; tp = arm_load_tp ( NULL_RTX ) ; dest = gen_rtx_PLUS ( Pmode , tp , reg ) ; } else { insns = arm_call_tls_get_addr ( x , reg , & ret , TLS_GD32 ) ; dest = gen_reg_rtx ( Pmode ) ; emit_libcall_block ( insns , dest , ret , x ) ; } return dest ; case TLS_MODEL_LOCAL_DYNAMIC : if ( TARGET_GNU2_TLS ) { reg = arm_tls_descseq_addr ( x , reg ) ; tp = arm_load_tp ( NULL_RTX ) ; dest = gen_rtx_PLUS ( Pmode , tp , reg ) ; } else { insns = arm_call_tls_get_addr ( x , reg , & ret , TLS_LDM32 ) ; eqv = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , const1_rtx ) , UNSPEC_TLS ) ; dest = gen_reg_rtx ( Pmode ) ; emit_libcall_block ( insns , dest , ret , eqv ) ;

addend = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , x , GEN_INT ( TLS_LDO32 ) ) , UNSPEC_TLS ) ;


<s> unsigned int model = SYMBOL_REF_TLS_MODEL ( x ) ; switch ( model ) { case TLS_MODEL_GLOBAL_DYNAMIC : if ( TARGET_GNU2_TLS ) { reg = arm_tls_descseq_addr ( x , reg ) ; tp = arm_load_tp ( NULL_RTX ) ; dest = gen_rtx_PLUS ( Pmode , tp , reg ) ; } else { insns = arm_call_tls_get_addr ( x , reg , & ret , TLS_GD32 ) ; dest = gen_reg_rtx ( Pmode ) ; emit_libcall_block ( insns , dest , ret , x ) ; } return dest ; case TLS_MODEL_LOCAL_DYNAMIC : if ( TARGET_GNU2_TLS ) { reg = arm_tls_descseq_addr ( x , reg ) ; tp = arm_load_tp ( NULL_RTX ) ; dest = gen_rtx_PLUS ( Pmode , tp , reg ) ; } else { insns = arm_call_tls_get_addr ( x , reg , & ret , TLS_LDM32 ) ; eqv = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , const1_rtx ) , UNSPEC_TLS ) ; dest = gen_reg_rtx ( Pmode ) ; emit_libcall_block ( insns , dest , ret , eqv ) ; addend = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , x , GEN_INT ( TLS_LDO32 ) ) , UNSPEC_TLS ) ; addend = force_reg ( SImode , gen_rtx_CONST ( SImode , addend ) ) ; dest = gen_rtx_PLUS ( Pmode , dest , addend ) ; } return dest ; case TLS_MODEL_INITIAL_EXEC : labelno = GEN_INT ( pic_labelno ++ ) ; label = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , labelno ) , UNSPEC_PIC_LABEL ) ; label = gen_rtx_CONST ( VOIDmode , label ) ; sum = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , x , GEN_INT ( TLS_IE32 ) , label , GEN_INT ( TARGET_ARM ? <NUM_LIT> : <NUM_LIT> ) ) , UNSPEC_TLS ) ; reg = load_tls_operand ( sum , reg ) ; if ( TARGET_ARM ) emit_insn ( gen_tls_load_dot_plus_eight ( reg , reg , labelno ) ) ; else if ( TARGET_THUMB2 ) emit_insn ( gen_tls_load_dot_plus_four ( reg , NULL , reg , labelno ) ) ; else { emit_insn ( gen_pic_add_dot_plus_four ( reg , reg , labelno ) ) ; emit_move_insn ( reg , gen_const_mem ( SImode , reg ) ) ; } tp = arm_load_tp ( NULL_RTX ) ; return gen_rtx_PLUS ( Pmode , tp , reg ) ; case TLS_MODEL_LOCAL_EXEC :


<s> if ( unsorted_regs [ i ] < <NUM_LIT> || ( TARGET_THUMB1 && unsorted_regs [ i ] > LAST_LO_REGNUM ) || unsorted_regs [ i ] > <NUM_LIT> || ( i != nops - <NUM_LIT> && unsorted_regs [ i ] == base_reg ) ) return <NUM_LIT> ; if ( unsorted_regs [ i ] == SP_REGNUM && base_reg != SP_REGNUM ) return <NUM_LIT> ; unsorted_offsets [ i ] = INTVAL ( offset ) ; if ( i == <NUM_LIT> || unsorted_offsets [ i ] < unsorted_offsets [ order [ <NUM_LIT> ] ] ) order [ <NUM_LIT> ] = i ; } else return <NUM_LIT> ; } if ( ! compute_offset_order ( nops , unsorted_offsets , order , check_regs ? unsorted_regs : NULL ) ) return <NUM_LIT> ; if ( saved_order ) memcpy ( saved_order , order , sizeof order ) ; if ( base ) { * base = base_reg ; for ( i = <NUM_LIT> ; i < nops ; i ++ ) regs [ i ] = unsorted_regs [ check_regs ? order [ i ] : i ] ; * load_offset = unsorted_offsets [ order [ <NUM_LIT> ] ] ; } if ( TARGET_THUMB1 && ! peep2_reg_dead_p ( nops , base_reg_rtx ) ) return <NUM_LIT> ; if ( unsorted_offsets [ order [ <NUM_LIT> ] ] == <NUM_LIT> ) ldm_case = <NUM_LIT> ; else if ( TARGET_ARM && unsorted_offsets [ order [ <NUM_LIT> ] ] == <NUM_LIT> ) ldm_case = <NUM_LIT> ; else if ( TARGET_ARM && unsorted_offsets [ order [ nops - <NUM_LIT> ] ] == <NUM_LIT> ) ldm_case = <NUM_LIT> ; else if ( TARGET_32BIT && unsorted_offsets [ order [ nops - <NUM_LIT> ] ] == - <NUM_LIT> ) ldm_case = <NUM_LIT> ; else if ( const_ok_for_arm ( unsorted_offsets [ order [ <NUM_LIT> ] ] ) || const_ok_for_arm ( - unsorted_offsets [ order [ <NUM_LIT> ] ] ) ) ldm_case = <NUM_LIT> ; else return <NUM_LIT> ;

if ( ! multiple_operation_profitable_p ( false , nops , ldm_case == <NUM_LIT> ? unsorted_offsets [ order [ <NUM_LIT> ] ] : <NUM_LIT> ) ) return <NUM_LIT> ;


<s> case CC_DLTUmode : code = ARM_CC ; dominance : if ( comp_code == EQ ) return ARM_INVERSE_CONDITION_CODE ( code ) ; if ( comp_code == NE ) return code ; return ARM_NV ; case CC_NOOVmode : switch ( comp_code ) { case NE : return ARM_NE ; case EQ : return ARM_EQ ; case GE : return ARM_PL ; case LT : return ARM_MI ; default : return ARM_NV ; } case CC_Zmode : switch ( comp_code ) { case NE : return ARM_NE ; case EQ : return ARM_EQ ; default : return ARM_NV ; } case CC_Nmode : switch ( comp_code ) { case NE : return ARM_MI ; case EQ : return ARM_PL ; default : return ARM_NV ; } case CCFPEmode : case CCFPmode : switch ( comp_code ) { case GE : return ARM_GE ; case GT : return ARM_GT ; case LE : return ARM_LS ; case LT : return ARM_MI ; case NE : return ARM_NE ; case EQ : return ARM_EQ ; case ORDERED : return ARM_VC ; case UNORDERED : return ARM_VS ; case UNLT : return ARM_LT ; case UNLE : return ARM_LE ; case UNGT : return ARM_HI ; case UNGE : return ARM_PL ; case UNEQ : case LTGT : default : return ARM_NV ; } case CC_SWPmode : switch ( comp_code ) { case NE : return ARM_NE ; case EQ : return ARM_EQ ; case GE : return ARM_LE ; case GT : return ARM_LT ; case LE : return ARM_GE ; case LT : return ARM_GT ; case GEU : return ARM_LS ; case GTU : return ARM_CC ; case LEU : return ARM_CS ; case LTU : return ARM_HI ; default : return ARM_NV ;


<s> } else if ( GET_CODE ( addr ) == PLUS || GET_CODE ( addr ) == MINUS ) { * base = XEXP ( addr , <NUM_LIT> ) ; * offset = XEXP ( addr , <NUM_LIT> ) ; return ( REG_P ( * base ) && CONST_INT_P ( * offset ) ) ;


<s> HOST_WIDE_INT neon_element_bits ( machine_mode mode ) { if ( mode == DImode ) return GET_MODE_BITSIZE ( mode ) ; else return GET_MODE_BITSIZE ( GET_MODE_INNER ( mode ) ) ;


<s> x = copy_to_mode_reg ( inner_mode , XVECEXP ( vals , <NUM_LIT> , one_var ) ) ; switch ( mode ) { case V8QImode : emit_insn ( gen_neon_vset_lanev8qi ( target , x , target , index ) ) ; break ; case V16QImode : emit_insn ( gen_neon_vset_lanev16qi ( target , x , target , index ) ) ; break ; case V4HImode : emit_insn ( gen_neon_vset_lanev4hi ( target , x , target , index ) ) ; break ; case V8HImode : emit_insn ( gen_neon_vset_lanev8hi ( target , x , target , index ) ) ; break ; case V2SImode : emit_insn ( gen_neon_vset_lanev2si ( target , x , target , index ) ) ; break ; case V4SImode : emit_insn ( gen_neon_vset_lanev4si ( target , x , target , index ) ) ; break ; case V2SFmode : emit_insn ( gen_neon_vset_lanev2sf ( target , x , target , index ) ) ; break ; case V4SFmode : emit_insn ( gen_neon_vset_lanev4sf ( target , x , target , index ) ) ; break ; case V2DImode : emit_insn ( gen_neon_vset_lanev2di ( target , x , target , index ) ) ; break ; default : gcc_unreachable ( ) ; }


<s> int neon_immediate_valid_for_logic ( rtx op , machine_mode mode , int inverse , rtx * modconst , int * elementwidth ) { rtx tmpconst ; int tmpwidth ;

int retval = neon_valid_immediate ( op , mode , inverse , & tmpconst , & tmpwidth ) ;


<s> } maxshift = innersize * <NUM_LIT> ; if ( isleftshift ) { if ( last_elt >= maxshift ) return <NUM_LIT> ; } else { if ( last_elt == <NUM_LIT> || last_elt > maxshift ) return <NUM_LIT> ; } if ( elementwidth ) * elementwidth = innersize * <NUM_LIT> ; if ( modconst ) * modconst = CONST_VECTOR_ELT ( op , <NUM_LIT> ) ;


<s> bounds_check ( operand , low , high , <STR_LIT> ) ;


<s> if ( n_const == n_elts ) const_vec = gen_rtx_CONST_VECTOR ( mode , XVEC ( vals , <NUM_LIT> ) ) ; } else gcc_unreachable ( ) ; if ( const_vec != NULL && neon_immediate_valid_for_move ( const_vec , mode , NULL , NULL ) ) return const_vec ;

else if ( ( target = neon_vdup_constant ( vals ) ) != NULL_RTX ) return target ;


<s> } else gcc_unreachable ( ) ; if ( const_vec != NULL && neon_immediate_valid_for_move ( const_vec , mode , NULL , NULL ) ) return const_vec ; else if ( ( target = neon_vdup_constant ( vals ) ) != NULL_RTX ) return target ; else if ( const_vec != NULL_RTX ) return const_vec ; else return NULL_RTX ;


<s> machine_mode inner = GET_MODE_INNER ( mode ) ; unsigned int i , parts = GET_MODE_SIZE ( mode ) / GET_MODE_SIZE ( inner ) ; rtx tmpsum = op1 ; for ( i = parts / <NUM_LIT> ; i >= <NUM_LIT> ; i /= <NUM_LIT> ) {

rtx dest = ( i == <NUM_LIT> ) ? op0 : gen_reg_rtx ( mode ) ;


<s> rtx dest = ( i == <NUM_LIT> ) ? op0 : gen_reg_rtx ( mode ) ; emit_insn ( reduc ( dest , tmpsum , tmpsum ) ) ;


<s> void neon_reinterpret ( rtx dest , rtx src ) {

emit_move_insn ( dest , gen_lowpart ( GET_MODE ( dest ) , src ) ) ;


<s> emit_note ( NOTE_INSN_DELETED ) ; return ; } destlo = gen_rtx_REG_offset ( operands [ <NUM_LIT> ] , halfmode , dest , <NUM_LIT> ) ; desthi = gen_rtx_REG_offset ( operands [ <NUM_LIT> ] , halfmode , dest + halfregs , GET_MODE_SIZE ( halfmode ) ) ; if ( src2 == dest && src1 == dest + halfregs ) { rtx x = gen_rtx_SET ( VOIDmode , destlo , operands [ <NUM_LIT> ] ) ; rtx y = gen_rtx_SET ( VOIDmode , desthi , operands [ <NUM_LIT> ] ) ;

emit_insn ( gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , x , y ) ) ) ;


<s> CHECK ( <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , bytes [ i ] == <NUM_LIT> && bytes [ i + <NUM_LIT> ] == <NUM_LIT> && bytes [ i + <NUM_LIT> ] == bytes [ <NUM_LIT> ] && bytes [ i + <NUM_LIT> ] == <NUM_LIT> ) ; CHECK ( <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , bytes [ i ] == <NUM_LIT> && bytes [ i + <NUM_LIT> ] == <NUM_LIT> && bytes [ i + <NUM_LIT> ] == <NUM_LIT> && bytes [ i + <NUM_LIT> ] == bytes [ <NUM_LIT> ] ) ; CHECK ( <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , bytes [ i ] == bytes [ <NUM_LIT> ] && bytes [ i + <NUM_LIT> ] == <NUM_LIT> ) ; CHECK ( <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , bytes [ i ] == <NUM_LIT> && bytes [ i + <NUM_LIT> ] == bytes [ <NUM_LIT> ] ) ; CHECK ( <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , bytes [ i ] == <NUM_LIT> && bytes [ i + <NUM_LIT> ] == bytes [ <NUM_LIT> ] && bytes [ i + <NUM_LIT> ] == <NUM_LIT> && bytes [ i + <NUM_LIT> ] == <NUM_LIT> ) ; CHECK ( <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , bytes [ i ] == <NUM_LIT> && bytes [ i + <NUM_LIT> ] == bytes [ <NUM_LIT> ] && bytes [ i + <NUM_LIT> ] == <NUM_LIT> && bytes [ i + <NUM_LIT> ] == <NUM_LIT> ) ; CHECK ( <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , bytes [ i ] == <NUM_LIT> && bytes [ i + <NUM_LIT> ] == <NUM_LIT> && bytes [ i + <NUM_LIT> ] == bytes [ <NUM_LIT> ] && bytes [ i + <NUM_LIT> ] == <NUM_LIT> ) ; CHECK ( <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , bytes [ i ] == <NUM_LIT> && bytes [ i + <NUM_LIT> ] == <NUM_LIT> && bytes [ i + <NUM_LIT> ] == bytes [ <NUM_LIT> ] && bytes [ i + <NUM_LIT> ] == <NUM_LIT> ) ; CHECK ( <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , bytes [ i ] == bytes [ <NUM_LIT> ] ) ; CHECK ( <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , ( bytes [ i ] == <NUM_LIT> || bytes [ i ] == <NUM_LIT> ) && bytes [ i ] == bytes [ ( i + <NUM_LIT> ) % idx ] ) ; } while ( <NUM_LIT> ) ; if ( immtype == - <NUM_LIT> ) return - <NUM_LIT> ; if ( elementwidth ) * elementwidth = elsize ; if ( modconst ) { unsigned HOST_WIDE_INT imm = <NUM_LIT> ; if ( invmask != <NUM_LIT> ) for ( i = <NUM_LIT> ; i < idx ; i ++ ) bytes [ i ] ^= invmask ;


<s> if ( GET_CODE ( vals ) != CONST_VECTOR || GET_MODE_SIZE ( inner_mode ) > <NUM_LIT> ) return NULL_RTX ; for ( i = <NUM_LIT> ; i < n_elts ; ++ i ) { x = XVECEXP ( vals , <NUM_LIT> , i ) ; if ( i > <NUM_LIT> && ! rtx_equal_p ( x , XVECEXP ( vals , <NUM_LIT> , <NUM_LIT> ) ) ) all_same = false ; } if ( ! all_same ) return NULL_RTX ; x = copy_to_mode_reg ( inner_mode , XVECEXP ( vals , <NUM_LIT> , <NUM_LIT> ) ) ; return gen_rtx_VEC_DUPLICATE ( mode , x ) ;


<s> int neon_vector_mem_operand ( rtx op , int type , bool strict ) { rtx ind ; if ( ! ( reload_in_progress || reload_completed ) && ( reg_mentioned_p ( frame_pointer_rtx , op ) || reg_mentioned_p ( arg_pointer_rtx , op ) || reg_mentioned_p ( virtual_incoming_args_rtx , op ) || reg_mentioned_p ( virtual_outgoing_args_rtx , op ) || reg_mentioned_p ( virtual_stack_dynamic_rtx , op ) || reg_mentioned_p ( virtual_stack_vars_rtx , op ) ) ) return ! strict ; if ( ! MEM_P ( op ) ) return FALSE ; ind = XEXP ( op , <NUM_LIT> ) ; if ( reload_completed && ( GET_CODE ( ind ) == LABEL_REF || ( GET_CODE ( ind ) == CONST && GET_CODE ( XEXP ( ind , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( ind , <NUM_LIT> ) , <NUM_LIT> ) ) == LABEL_REF && CONST_INT_P ( XEXP ( XEXP ( ind , <NUM_LIT> ) , <NUM_LIT> ) ) ) ) ) return TRUE ; if ( REG_P ( ind ) ) return arm_address_register_rtx_p ( ind , <NUM_LIT> ) ; if ( ( type != <NUM_LIT> && GET_CODE ( ind ) == POST_INC ) || ( type == <NUM_LIT> && GET_CODE ( ind ) == PRE_DEC ) ) return arm_address_register_rtx_p ( XEXP ( ind , <NUM_LIT> ) , <NUM_LIT> ) ; if ( type == <NUM_LIT> && GET_CODE ( ind ) == POST_MODIFY && GET_CODE ( XEXP ( ind , <NUM_LIT> ) ) == PLUS && REG_P ( XEXP ( XEXP ( ind , <NUM_LIT> ) , <NUM_LIT> ) ) ) return true ; if ( type == <NUM_LIT> && GET_CODE ( ind ) == PLUS && REG_P ( XEXP ( ind , <NUM_LIT> ) ) && REG_MODE_OK_FOR_BASE_P ( XEXP ( ind , <NUM_LIT> ) , VOIDmode ) && CONST_INT_P ( XEXP ( ind , <NUM_LIT> ) ) && INTVAL ( XEXP ( ind , <NUM_LIT> ) ) > - <NUM_LIT> && ( INTVAL ( XEXP ( ind , <NUM_LIT> ) ) < ( VALID_NEON_QREG_MODE ( GET_MODE ( op ) ) ? <NUM_LIT> : <NUM_LIT> ) ) && ( INTVAL ( XEXP ( ind , <NUM_LIT> ) ) & <NUM_LIT> ) == <NUM_LIT> ) return TRUE ;


<s> i -= <NUM_LIT> ; } } } insns1 = optimal_immediate_sequence_1 ( code , val , return_sequence , best_start ) ; if ( best_start != <NUM_LIT> && ( ( ( ( unsigned HOST_WIDE_INT ) <NUM_LIT> ) << best_start ) < val ) ) { insns2 = optimal_immediate_sequence_1 ( code , val , & tmp_sequence , <NUM_LIT> ) ; if ( insns2 <= insns1 ) { * return_sequence = tmp_sequence ; insns1 = insns2 ;


<s> int consecutive_zeros = <NUM_LIT> ; if ( ! ( val & ( <NUM_LIT> << i ) ) ) { while ( ( i < <NUM_LIT> ) && ! ( val & ( <NUM_LIT> << i ) ) ) { consecutive_zeros += <NUM_LIT> ; i += <NUM_LIT> ; } if ( consecutive_zeros > best_consecutive_zeros ) { best_consecutive_zeros = consecutive_zeros ; best_start = i - consecutive_zeros ; } i -= <NUM_LIT> ; } } } insns1 = optimal_immediate_sequence_1 ( code , val , return_sequence , best_start ) ; if ( best_start != <NUM_LIT> && ( ( ( ( unsigned HOST_WIDE_INT ) <NUM_LIT> ) << best_start ) < val ) ) { insns2 = optimal_immediate_sequence_1 ( code , val , & tmp_sequence , <NUM_LIT> ) ;


<s> const char * output_call_mem ( rtx * operands ) { gcc_assert ( ! arm_arch5 ) ; if ( TARGET_INTERWORK ) { output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; } else if ( regno_use_in ( LR_REGNUM , operands [ <NUM_LIT> ] ) ) { output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ;

if ( arm_arch4t ) output_asm_insn ( <STR_LIT> , operands ) ;


<s> output_asm_insn ( <STR_LIT> , operands ) ; } else if ( regno_use_in ( LR_REGNUM , operands [ <NUM_LIT> ] ) ) { output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ;


<s> else { templ = <STR_LIT> ; ops [ <NUM_LIT> ] = mem ; } ops [ <NUM_LIT> ] = reg ; break ; case PRE_DEC : templ = <STR_LIT> ; ops [ <NUM_LIT> ] = XEXP ( addr , <NUM_LIT> ) ; ops [ <NUM_LIT> ] = reg ; break ; case POST_MODIFY : gcc_unreachable ( ) ; case REG : if ( nregs > <NUM_LIT> ) { if ( nregs > <NUM_LIT> ) templ = <STR_LIT> ; else templ = <STR_LIT> ; ops [ <NUM_LIT> ] = mem ; ops [ <NUM_LIT> ] = reg ; break ; } case LABEL_REF : case PLUS : { int i ; int overlap = - <NUM_LIT> ; for ( i = <NUM_LIT> ; i < nregs ; i ++ ) { ops [ <NUM_LIT> ] = gen_rtx_REG ( DImode , REGNO ( reg ) + <NUM_LIT> * i ) ; ops [ <NUM_LIT> ] = adjust_address ( mem , DImode , <NUM_LIT> * i ) ; if ( reg_overlap_mentioned_p ( ops [ <NUM_LIT> ] , mem ) ) { gcc_assert ( overlap == - <NUM_LIT> ) ; overlap = i ; } else { sprintf ( buff , <STR_LIT> , load ? <STR_LIT> : <STR_LIT> ) ; output_asm_insn ( buff , ops ) ; } } if ( overlap != - <NUM_LIT> ) { ops [ <NUM_LIT> ] = gen_rtx_REG ( DImode , REGNO ( reg ) + <NUM_LIT> * overlap ) ; ops [ <NUM_LIT> ] = adjust_address ( mem , SImode , <NUM_LIT> * overlap ) ; sprintf ( buff , <STR_LIT> , load ? <STR_LIT> : <STR_LIT> ) ; output_asm_insn ( buff , ops ) ; } return <STR_LIT> ; } default :


<s> } else for ( i = <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) { ops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , dest + i ) ; ops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , src + i ) ; output_asm_insn ( <STR_LIT> , ops ) ; } } } else { gcc_assert ( MEM_P ( operands [ <NUM_LIT> ] ) ) ; gcc_assert ( REG_P ( operands [ <NUM_LIT> ] ) ) ; gcc_assert ( ! reg_overlap_mentioned_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; switch ( GET_CODE ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) ) {