<s> bitmap_xor ( cpu_isa , cpu_isa , target -> isa ) ; bitmap_and_compl ( cpu_isa , cpu_isa , isa_quirkbits ) ; bitmap_and_compl ( cpu_isa , cpu_isa , isa_all_fpubits ) ; if ( ! bitmap_empty_p ( cpu_isa ) ) { if ( warn_compatible ) warning ( <NUM_LIT> , <STR_LIT> , arm_selected_cpu -> name , arm_selected_arch -> name ) ; if ( ! arm_selected_tune ) arm_selected_tune = arm_selected_cpu ; arm_selected_cpu = arm_selected_arch ; target -> arch_name = arm_selected_arch -> name ; } else { arm_selected_arch = NULL ; target -> core_name = arm_selected_cpu -> name ; } } else { arm_selected_cpu = arm_selected_arch ; target -> arch_name = arm_selected_arch -> name ; } } else if ( arm_selected_cpu ) { target -> core_name = arm_selected_cpu -> name ; arm_initialize_isa ( target -> isa , arm_selected_cpu -> isa_bits ) ; } else { const struct processors * sel ; auto_sbitmap sought_isa ( isa_num_bits ) ; bitmap_clear ( sought_isa ) ; auto_sbitmap default_isa ( isa_num_bits ) ; arm_selected_cpu = & all_cores [ TARGET_CPU_DEFAULT ] ; gcc_assert ( arm_selected_cpu -> name ) ; sel = arm_selected_cpu ; arm_initialize_isa ( default_isa , sel -> isa_bits ) ; if ( TARGET_INTERWORK || TARGET_THUMB ) { bitmap_set_bit ( sought_isa , isa_bit_thumb ) ; bitmap_set_bit ( sought_isa , isa_bit_mode32 ) ; bitmap_clear_bit ( default_isa , isa_bit_mode26 ) ; } if ( ! bitmap_empty_p ( sought_isa ) && ! bitmap_subset_p ( sought_isa , default_isa ) ) { auto_sbitmap candidate_isa ( isa_num_bits ) ; bitmap_ior ( default_isa , default_isa , sought_isa ) ; for ( sel = all_cores ; sel -> name != NULL ; sel ++ ) { arm_initialize_isa ( candidate_isa , sel -> isa_bits ) ; if ( bitmap_equal_p ( default_isa , candidate_isa ) ) break ; } if ( sel -> name == NULL ) { unsigned current_bit_count = isa_num_bits ; const struct processors * best_fit = NULL ;


<s> case VUNSPEC_LDC : case VUNSPEC_LDCL : case VUNSPEC_STC : case VUNSPEC_STCL : case VUNSPEC_MCR : case VUNSPEC_MRC : if ( arm_arch4 ) return true ; break ; case VUNSPEC_CDP2 : case VUNSPEC_LDC2 : case VUNSPEC_LDC2L : case VUNSPEC_STC2 : case VUNSPEC_STC2L : case VUNSPEC_MCR2 : case VUNSPEC_MRC2 : if ( arm_arch5 ) return true ; break ; case VUNSPEC_MCRR : case VUNSPEC_MRRC : if ( arm_arch6 || arm_arch5te ) return true ; break ; case VUNSPEC_MCRR2 : case VUNSPEC_MRRC2 : if ( arm_arch6 ) return true ;


<s> void arm_declare_function_name ( FILE * stream , const char * name , tree decl ) { fprintf ( stream , <STR_LIT> ) ; if ( TARGET_THUMB ) { if ( is_called_in_ARM_mode ( decl ) || ( TARGET_THUMB1 && ! TARGET_THUMB1_ONLY && cfun -> is_thunk ) ) fprintf ( stream , <STR_LIT> ) ; else if ( TARGET_THUMB1 ) fprintf ( stream , <STR_LIT> ) ; else fprintf ( stream , <STR_LIT> ) ; } else fprintf ( stream , <STR_LIT> ) ; asm_fprintf ( asm_out_file , <STR_LIT> , ( TARGET_SOFT_FLOAT ? <STR_LIT> : arm_identify_fpu_from_isa ( arm_active_target . isa ) ) ) ; if ( TARGET_POKE_FUNCTION_NAME ) arm_poke_function_name ( stream , ( const char * ) name ) ;


<s> 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 V4HFmode : gen = gen_neon_vextv4hf ; break ; case V8HFmode : gen = gen_neon_vextv8hf ; 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 ; offset = GEN_INT ( location ) ; emit_insn ( gen ( d -> target , d -> op0 , d -> op1 , offset ) ) ;


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


<s> case V4HImode : gen = gen_neon_vrev64v4hi ; break ; case V8HFmode : gen = gen_neon_vrev64v8hf ; break ; case V4HFmode : gen = gen_neon_vrev64v4hf ; break ; default : return false ; } break ; case <NUM_LIT> : switch ( d -> vmode ) { case V16QImode : gen = gen_neon_vrev16v16qi ; break ; case V8QImode : gen = gen_neon_vrev16v8qi ; break ; case V8HImode : gen = gen_neon_vrev32v8hi ; break ; case V4HImode : gen = gen_neon_vrev32v4hi ; break ; case V4SImode : gen = gen_neon_vrev64v4si ; break ; case V2SImode : gen = gen_neon_vrev64v2si ; break ; case V4SFmode : gen = gen_neon_vrev64v4sf ; break ; case V2SFmode : gen = gen_neon_vrev64v2sf ; break ; default :


<s> 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 ; case V8HFmode : gen = gen_neon_vrev64v8hf ; break ; case V4HFmode : gen = gen_neon_vrev64v4hf ; break ; default : return false ; } break ; case <NUM_LIT> : switch ( d -> vmode ) { case V16QImode : gen = gen_neon_vrev16v16qi ; break ; case V8QImode : gen = gen_neon_vrev16v8qi ; break ; case V8HImode : gen = gen_neon_vrev32v8hi ; break ; case V4HImode : gen = gen_neon_vrev32v4hi ; break ; case V4SImode : gen = gen_neon_vrev64v4si ; break ; case V2SImode : gen = gen_neon_vrev64v2si ; break ;

case V4SFmode : gen = gen_neon_vrev64v4sf ; break ;


<s> 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 V8HFmode : gen = gen_neon_vtrnv8hf_internal ; break ; case V4HFmode : gen = gen_neon_vtrnv4hf_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 ( ) ; }


<s> rtx out0 , out1 , in0 , in1 ; rtx ( * gen ) ( rtx , rtx , rtx , rtx ) ; if ( GET_MODE_UNIT_SIZE ( d -> vmode ) >= <NUM_LIT> ) return false ; if ( d -> perm [ <NUM_LIT> ] == <NUM_LIT> ) odd = <NUM_LIT> ; else if ( d -> perm [ <NUM_LIT> ] == <NUM_LIT> ) odd = <NUM_LIT> ; else return false ; 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 V8HFmode : gen = gen_neon_vtrnv8hf_internal ; break ; case V4HFmode : gen = gen_neon_vtrnv4hf_internal ; break ; case V4SImode : gen = gen_neon_vtrnv4si_internal ; break ;

case V2SImode : gen = gen_neon_vtrnv2si_internal ; break ;


<s> rtx ( * gen ) ( rtx , rtx , rtx , rtx ) ; int first_elem ; int swap_nelt ; if ( GET_MODE_UNIT_SIZE ( d -> vmode ) >= <NUM_LIT> ) return false ; swap_nelt = BYTES_BIG_ENDIAN && ! d -> one_vector_p && GET_MODE_SIZE ( d -> vmode ) == <NUM_LIT> ? d -> nelt : <NUM_LIT> ; first_elem = d -> perm [ neon_endian_lane_map ( d -> vmode , <NUM_LIT> ) ] ^ swap_nelt ; if ( first_elem == neon_endian_lane_map ( d -> vmode , <NUM_LIT> ) ) odd = <NUM_LIT> ; else if ( first_elem == neon_endian_lane_map ( d -> vmode , <NUM_LIT> ) ) odd = <NUM_LIT> ; else return false ; mask = ( d -> one_vector_p ? nelt - <NUM_LIT> : <NUM_LIT> * nelt - <NUM_LIT> ) ; for ( i = <NUM_LIT> ; i < nelt ; i ++ ) { unsigned elt = ( neon_pair_endian_lane_map ( d -> vmode , i ) * <NUM_LIT> + odd ) & mask ; if ( ( d -> perm [ i ] ^ swap_nelt ) != neon_pair_endian_lane_map ( d -> vmode , 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 ;


<s> bool is_swapped ; if ( GET_MODE_UNIT_SIZE ( d -> vmode ) >= <NUM_LIT> ) return false ; is_swapped = BYTES_BIG_ENDIAN ; first_elem = d -> perm [ neon_endian_lane_map ( d -> vmode , <NUM_LIT> ) ^ is_swapped ] ; high = nelt / <NUM_LIT> ; if ( first_elem == neon_endian_lane_map ( d -> vmode , high ) ) ; else if ( first_elem == neon_endian_lane_map ( d -> vmode , <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 = neon_pair_endian_lane_map ( d -> vmode , i + high ) & mask ; if ( d -> perm [ neon_pair_endian_lane_map ( d -> vmode , <NUM_LIT> * i + is_swapped ) ] != elt ) return false ; elt = neon_pair_endian_lane_map ( d -> vmode , i + nelt + high ) & mask ; if ( d -> perm [ neon_pair_endian_lane_map ( d -> vmode , <NUM_LIT> * i + ! is_swapped ) ] != 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 V8HFmode : gen = gen_neon_vzipv8hf_internal ; break ; case V4HFmode : gen = gen_neon_vzipv4hf_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 ; case V4SFmode : gen = gen_neon_vzipv4sf_internal ; break ; default : gcc_unreachable ( ) ; } in0 = d -> op0 ;


<s> static bool arm_evpc_neon_vzip ( struct expand_vec_perm_d * d ) { unsigned int i , high , mask , nelt = d -> nelt ; rtx out0 , out1 , in0 , in1 ; rtx ( * gen ) ( rtx , rtx , rtx , rtx ) ; int first_elem ; bool is_swapped ; if ( GET_MODE_UNIT_SIZE ( d -> vmode ) >= <NUM_LIT> ) return false ; is_swapped = BYTES_BIG_ENDIAN ; first_elem = d -> perm [ neon_endian_lane_map ( d -> vmode , <NUM_LIT> ) ^ is_swapped ] ; high = nelt / <NUM_LIT> ; if ( first_elem == neon_endian_lane_map ( d -> vmode , high ) ) ; else if ( first_elem == neon_endian_lane_map ( d -> vmode , <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 = neon_pair_endian_lane_map ( d -> vmode , i + high ) & mask ; if ( d -> perm [ neon_pair_endian_lane_map ( d -> vmode , <NUM_LIT> * i + is_swapped ) ] != elt ) return false ; elt = neon_pair_endian_lane_map ( d -> vmode , i + nelt + high ) & mask ; if ( d -> perm [ neon_pair_endian_lane_map ( d -> vmode , <NUM_LIT> * i + ! is_swapped ) ] != 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 V8HFmode : gen = gen_neon_vzipv8hf_internal ; break ; case V4HFmode : gen = gen_neon_vzipv4hf_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 ; case V4SFmode : gen = gen_neon_vzipv4sf_internal ; break ; default : gcc_unreachable ( ) ; }


<s> mod_s = operands [ <NUM_LIT> ] ; mod_f = operands [ <NUM_LIT> ] ; mode = GET_MODE ( mem ) ; if ( TARGET_HAVE_LDACQ && is_mm_acquire ( memmodel_from_int ( INTVAL ( mod_f ) ) ) && is_mm_release ( memmodel_from_int ( INTVAL ( mod_s ) ) ) ) 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 ( ) ; } bdst = TARGET_THUMB1 ? bval : gen_rtx_REG ( CCmode , CC_REGNUM ) ;

emit_insn ( gen ( bdst , rval , mem , oldval , newval , is_weak , mod_s , mod_f ) ) ;


<s> 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 ( ) ; } bdst = TARGET_THUMB1 ? bval : gen_rtx_REG ( CCmode , CC_REGNUM ) ; emit_insn ( gen ( bdst , 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 ) ) ; if ( TARGET_THUMB1 ) emit_insn ( gen_cstoresi_eq0_thumb1 ( bval , bdst ) ) ; else { x = gen_rtx_EQ ( SImode , bdst , const0_rtx ) ; emit_insn ( gen_rtx_SET ( bval , x ) ) ; }


<s> if ( mode == SImode ) gcc_assert ( ! TARGET_IDIV ) ; machine_mode libval_mode = smallest_mode_for_size ( <NUM_LIT> * GET_MODE_BITSIZE ( mode ) , MODE_INT ) ; rtx libval = emit_library_call_value ( libfunc , NULL_RTX , LCT_CONST , libval_mode , <NUM_LIT> , op0 , GET_MODE ( op0 ) , op1 , GET_MODE ( op1 ) ) ;

rtx quotient = simplify_gen_subreg ( mode , libval , libval_mode , <NUM_LIT> ) ;


<s> if ( mode == SImode ) gcc_assert ( ! TARGET_IDIV ) ; machine_mode libval_mode = smallest_mode_for_size ( <NUM_LIT> * GET_MODE_BITSIZE ( mode ) , MODE_INT ) ; rtx libval = emit_library_call_value ( libfunc , NULL_RTX , LCT_CONST , libval_mode , <NUM_LIT> , op0 , GET_MODE ( op0 ) , op1 , GET_MODE ( op1 ) ) ; rtx quotient = simplify_gen_subreg ( mode , libval , libval_mode , <NUM_LIT> ) ; rtx remainder = simplify_gen_subreg ( mode , libval , libval_mode , GET_MODE_SIZE ( mode ) ) ; gcc_assert ( quotient ) ; gcc_assert ( remainder ) ; * quot_p = quotient ; * rem_p = remainder ;


<s> if ( TARGET_IWMMXT ) { rtx_insn * insn ; int lrm_count = ( num_regs % <NUM_LIT> ) ? ( num_regs + <NUM_LIT> ) : ( num_regs + <NUM_LIT> ) ; for ( i = LAST_IWMMXT_REGNUM ; i >= FIRST_IWMMXT_REGNUM ; i -- ) if ( df_regs_ever_live_p ( i ) && ! call_used_regs [ i ] ) { rtx addr = gen_frame_mem ( V2SImode , plus_constant ( Pmode , hard_frame_pointer_rtx , - lrm_count * <NUM_LIT> ) ) ; insn = emit_insn ( gen_movsi ( gen_rtx_REG ( V2SImode , i ) , addr ) ) ; REG_NOTES ( insn ) = alloc_reg_note ( REG_CFA_RESTORE , gen_rtx_REG ( V2SImode , i ) , NULL_RTX ) ; lrm_count += <NUM_LIT> ; } } gcc_assert ( saved_regs_mask & ( <NUM_LIT> << IP_REGNUM ) ) ; saved_regs_mask &= ~ ( <NUM_LIT> << IP_REGNUM ) ; saved_regs_mask |= ( <NUM_LIT> << SP_REGNUM ) ; if ( really_return && ARM_FUNC_TYPE ( func_type ) == ARM_FT_NORMAL && ! crtl -> calls_eh_return ) saved_regs_mask &= ~ ( <NUM_LIT> << LR_REGNUM ) ; else saved_regs_mask &= ~ ( <NUM_LIT> << PC_REGNUM ) ; num_regs = bit_count ( saved_regs_mask ) ; 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 ) ;


<s> if ( frame && n * <NUM_LIT> >= frame ) { n = frame / <NUM_LIT> ; live_regs_mask |= ( <NUM_LIT> << n ) - <NUM_LIT> ; saved_regs += frame ; } } if ( TARGET_LDRD && current_tune -> prefer_ldrd_strd && ! optimize_function_for_size_p ( cfun ) ) { gcc_checking_assert ( live_regs_mask == dwarf_regs_mask ) ; if ( TARGET_THUMB2 ) thumb2_emit_strd_push ( live_regs_mask ) ; else if ( TARGET_ARM && ! TARGET_APCS_FRAME && ! IS_INTERRUPT ( func_type ) ) arm_emit_strd_push ( live_regs_mask ) ; else { insn = emit_multi_reg_push ( live_regs_mask , live_regs_mask ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } } else { insn = emit_multi_reg_push ( live_regs_mask , dwarf_regs_mask ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } } if ( ! IS_VOLATILE ( func_type ) ) saved_regs += arm_save_coproc_regs ( ) ; if ( frame_pointer_needed && TARGET_ARM ) { if ( TARGET_APCS_FRAME ) { insn = GEN_INT ( - ( <NUM_LIT> + args_to_push + fp_offset ) ) ; insn = emit_insn ( gen_addsi3 ( hard_frame_pointer_rtx , ip_rtx , insn ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } else { insn = GEN_INT ( saved_regs - ( <NUM_LIT> + fp_offset ) ) ; insn = emit_insn ( gen_addsi3 ( hard_frame_pointer_rtx , stack_pointer_rtx , insn ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } } size = offsets -> outgoing_args - offsets -> saved_args ; if ( flag_stack_usage_info ) current_function_static_stack_size = size ; if ( ! IS_INTERRUPT ( func_type ) && flag_stack_check == STATIC_BUILTIN_STACK_CHECK ) { unsigned int regno ; if ( ! IS_NESTED ( func_type ) || clobber_ip ) regno = IP_REGNUM ; else if ( df_regs_ever_live_p ( LR_REGNUM ) ) regno = LR_REGNUM ; else regno = <NUM_LIT> ; if ( crtl -> is_leaf && ! cfun -> calls_alloca ) { if ( size > PROBE_INTERVAL && size > STACK_CHECK_PROTECT ) arm_emit_probe_stack_range ( STACK_CHECK_PROTECT , size - STACK_CHECK_PROTECT , regno , live_regs_mask ) ; } else if ( size > <NUM_LIT> ) arm_emit_probe_stack_range ( STACK_CHECK_PROTECT , size , regno , live_regs_mask ) ; } if ( clobber_ip ) { if ( ! arm_r3_live_at_start_p ( ) || saved_pretend_args ) insn = gen_rtx_REG ( SImode , <NUM_LIT> ) ; else { insn = plus_constant ( Pmode , hard_frame_pointer_rtx , <NUM_LIT> ) ; insn = gen_frame_mem ( SImode , insn ) ; } emit_set_insn ( ip_rtx , insn ) ; emit_insn ( gen_force_register_use ( ip_rtx ) ) ; } if ( offsets -> outgoing_args != offsets -> saved_args + saved_regs ) { rtx_insn * last = get_last_insn ( ) ; amount = GEN_INT ( offsets -> saved_args + saved_regs - offsets -> outgoing_args ) ; insn = emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , amount ) ) ; do { last = last ? NEXT_INSN ( last ) : get_insns ( ) ; RTX_FRAME_RELATED_P ( last ) = <NUM_LIT> ; } while ( last != insn ) ; if ( frame_pointer_needed ) insn = emit_insn ( gen_stack_tie ( stack_pointer_rtx , hard_frame_pointer_rtx ) ) ;


<s> if ( ! extended && n == <NUM_LIT> ) return arm_fp16_format == ARM_FP16_FORMAT_IEEE ? HFmode : VOIDmode ;

return default_floatn_mode ( n , extended ) ;


<s> if ( SUBTARGET_FRAME_POINTER_REQUIRED ) return true ; if ( cfun -> has_nonlocal_label ) return true ; if ( TARGET_ARM && TARGET_APCS_FRAME && ! crtl -> is_leaf ) return true ; if ( ! IS_INTERRUPT ( arm_current_func_type ( ) ) && flag_stack_check == STATIC_BUILTIN_STACK_CHECK && arm_except_unwind_info ( & global_options ) == UI_TARGET && cfun -> can_throw_non_call_exceptions ) { HOST_WIDE_INT size = get_frame_size ( ) ; if ( size <= <NUM_LIT> ) return false ; if ( crtl -> is_leaf && ! cfun -> calls_alloca ) {


<s> if ( crtl -> is_leaf && ! cfun -> calls_alloca ) { size += <NUM_LIT> * UNITS_PER_WORD ; if ( size > PROBE_INTERVAL && size > STACK_CHECK_PROTECT ) return true ; } else return true ; }


<s> int nregs ; if ( mode == VOIDmode ) return const0_rtx ; if ( pcum -> pcs_variant <= ARM_PCS_AAPCS_LOCAL ) { aapcs_layout_arg ( pcum , mode , type , named ) ; return pcum -> aapcs_reg ; } if ( TARGET_IWMMXT_ABI && arm_vector_mode_supported_p ( mode ) && pcum -> named_count > pcum -> nargs + <NUM_LIT> ) { 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 ;


<s> if ( res < <NUM_LIT> && warn_psabi ) inform ( input_location , <STR_LIT> <STR_LIT> , type ) ; return res > <NUM_LIT> ? DOUBLEWORD_ALIGNMENT : PARM_BOUNDARY ;


<s> int res = arm_needs_doubleword_align ( mode , type ) ; if ( res < <NUM_LIT> && warn_psabi ) inform ( input_location , <STR_LIT> <STR_LIT> , type ) ; return res > <NUM_LIT> ? DOUBLEWORD_ALIGNMENT : PARM_BOUNDARY ;


<s> if ( cfun -> machine -> sibcall_blocked ) return false ; if ( TARGET_THUMB1 ) return false ; if ( TARGET_VXWORKS_RTP && flag_pic && decl && ! targetm . binds_local_p ( decl ) ) return false ; if ( TARGET_APCS_FRAME && TARGET_ARM && TARGET_HARD_FLOAT && decl && arm_is_long_call_p ( decl ) ) return false ; if ( TARGET_INTERWORK && decl && TREE_PUBLIC ( decl ) && ! TREE_ASM_WRITTEN ( decl ) ) return false ; func_type = arm_current_func_type ( ) ; if ( IS_INTERRUPT ( func_type ) ) return false ; if ( IS_CMSE_ENTRY ( arm_current_func_type ( ) ) ) return false ; if ( TREE_CODE ( exp ) == CALL_EXPR ) { tree fntype = TREE_TYPE ( TREE_TYPE ( CALL_EXPR_FN ( exp ) ) ) ; if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( fntype ) ) ) return false ; } if ( ! VOID_TYPE_P ( TREE_TYPE ( DECL_RESULT ( cfun -> decl ) ) ) ) { rtx a , b ; tree decl_or_type = decl ; if ( ! decl ) decl_or_type = TREE_TYPE ( TREE_TYPE ( CALL_EXPR_FN ( exp ) ) ) ; a = arm_function_value ( TREE_TYPE ( exp ) , decl_or_type , false ) ; b = arm_function_value ( TREE_TYPE ( DECL_RESULT ( cfun -> decl ) ) , cfun -> decl , false ) ; if ( ! rtx_equal_p ( a , b ) ) return false ; } if ( IS_STACKALIGN ( func_type ) ) return false ;

if ( TARGET_AAPCS_BASED && arm_abi == ARM_ABI_AAPCS && decl && DECL_WEAK ( decl ) ) return false ;


<s> offsets -> saved_regs_mask = arm_compute_save_reg_mask ( ) ; core_saved = bit_count ( offsets -> saved_regs_mask ) * <NUM_LIT> ; saved = core_saved ; if ( TARGET_REALLY_IWMMXT ) { for ( regno = FIRST_IWMMXT_REGNUM ; regno <= LAST_IWMMXT_REGNUM ; regno ++ ) if ( df_regs_ever_live_p ( regno ) && ! call_used_regs [ regno ] ) saved += <NUM_LIT> ; } func_type = arm_current_func_type ( ) ; if ( ! IS_VOLATILE ( func_type ) && TARGET_HARD_FLOAT ) 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 ( crtl -> is_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> ) {


<s> if ( TARGET_HARD_FLOAT ) { 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> ; } count = <NUM_LIT> ;


<s> if ( ! decl || TREE_CODE ( fntype ) != FUNCTION_TYPE ) { warning ( OPT_Wattributes , <STR_LIT> <STR_LIT> , name ) ; * no_add_attrs = true ; return NULL_TREE ; } * no_add_attrs |= cmse_func_args_or_return_in_stack ( NULL , name , fntype ) ; if ( * no_add_attrs ) return NULL_TREE ; type = TREE_TYPE ( decl ) ; type = build_distinct_type_copy ( type ) ; TREE_TYPE ( decl ) = type ; fntype = type ; while ( TREE_CODE ( fntype ) != FUNCTION_TYPE ) {


<s> if ( ! use_cmse ) { * no_add_attrs = true ; warning ( OPT_Wattributes , <STR_LIT> , name ) ; return NULL_TREE ; } if ( TREE_CODE ( * node ) != FUNCTION_DECL ) { warning ( OPT_Wattributes , <STR_LIT> , name ) ; * no_add_attrs = true ; return NULL_TREE ; } fndecl = * node ; if ( ! TREE_PUBLIC ( fndecl ) ) { warning ( OPT_Wattributes , <STR_LIT> <STR_LIT> , name ) ; * no_add_attrs = true ;


<s> warning ( OPT_Wattributes , <STR_LIT> , name ) ; return NULL_TREE ; } if ( TREE_CODE ( * node ) != FUNCTION_DECL ) { warning ( OPT_Wattributes , <STR_LIT> , name ) ; * no_add_attrs = true ; return NULL_TREE ; } fndecl = * node ; if ( ! TREE_PUBLIC ( fndecl ) ) { warning ( OPT_Wattributes , <STR_LIT> <STR_LIT> , name ) ;


<s> if ( regno == CC_REGNUM && GET_MODE_CLASS ( mode ) != MODE_CC ) return false ; if ( TARGET_THUMB1 ) return ( ARM_NUM_REGS ( mode ) < <NUM_LIT> ) || ( regno < LAST_LO_REGNUM ) ; if ( TARGET_HARD_FLOAT && IS_VFP_REGNUM ( regno ) ) { if ( mode == SFmode || mode == SImode ) return VFP_REGNO_OK_FOR_SINGLE ( regno ) ; if ( mode == DFmode ) return VFP_REGNO_OK_FOR_DOUBLE ( regno ) ; if ( mode == HFmode ) return VFP_REGNO_OK_FOR_SINGLE ( regno ) ; if ( mode == HImode ) return 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 ; } if ( TARGET_REALLY_IWMMXT ) { if ( IS_IWMMXT_GR_REGNUM ( regno ) ) return mode == SImode ;

if ( IS_IWMMXT_REGNUM ( regno ) ) return VALID_IWMMXT_REG_MODE ( mode ) ;


<s> auto_sbitmap cand_fpubits ( isa_num_bits ) ; bitmap_and ( fpubits , isa , isa_all_fpubits ) ; if ( bitmap_empty_p ( fpubits ) ) return <STR_LIT> ; for ( unsigned int i = <NUM_LIT> ; i < ARRAY_SIZE ( all_fpus ) ; i ++ ) {

arm_initialize_isa ( cand_fpubits , all_fpus [ i ] . isa_bits ) ;


<s> static const char * arm_identify_fpu_from_isa ( sbitmap isa ) { auto_sbitmap fpubits ( isa_num_bits ) ; auto_sbitmap cand_fpubits ( isa_num_bits ) ; bitmap_and ( fpubits , isa , isa_all_fpubits ) ; if ( bitmap_empty_p ( fpubits ) ) return <STR_LIT> ; for ( unsigned int i = <NUM_LIT> ; i < ARRAY_SIZE ( all_fpus ) ; i ++ ) {


<s> static void arm_initialize_isa ( sbitmap isa , const enum isa_feature * isa_bits ) {


<s> rtx base_reg , val ; n = INTVAL ( xop1 ) ; if ( mode == DImode || mode == DFmode ) { low_n = n & <NUM_LIT> ; n &= ~ <NUM_LIT> ; if ( low_n > <NUM_LIT> ) { n += <NUM_LIT> ; low_n -= <NUM_LIT> ; } } else { low_n = ( ( mode ) == TImode ? <NUM_LIT> : n >= <NUM_LIT> ? ( n & <NUM_LIT> ) : - ( ( - n ) & <NUM_LIT> ) ) ; n -= low_n ; } base_reg = gen_reg_rtx ( SImode ) ; 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 ) ;


<s> if ( addend ) { x = gen_rtx_PLUS ( SImode , x , addend ) ; orig_x = x ; } else return x ; } if ( ! TARGET_ARM ) { if ( TARGET_THUMB2 ) return x ; return thumb_legitimize_address ( x , orig_x , mode ) ; } if ( GET_CODE ( x ) == PLUS ) { rtx xop0 = XEXP ( x , <NUM_LIT> ) ; rtx xop1 = XEXP ( x , <NUM_LIT> ) ; if ( CONSTANT_P ( xop0 ) && ! symbol_mentioned_p ( xop0 ) ) xop0 = force_reg ( SImode , xop0 ) ; if ( CONSTANT_P ( xop1 ) && ! CONST_INT_P ( xop1 ) && ! symbol_mentioned_p ( xop1 ) ) xop1 = force_reg ( SImode , xop1 ) ; if ( ARM_BASE_REGISTER_RTX_P ( xop0 ) && CONST_INT_P ( xop1 ) ) { HOST_WIDE_INT n , low_n ; rtx base_reg , val ; n = INTVAL ( xop1 ) ; if ( mode == DImode || mode == DFmode ) { low_n = n & <NUM_LIT> ; n &= ~ <NUM_LIT> ; if ( low_n > <NUM_LIT> ) { n += <NUM_LIT> ; low_n -= <NUM_LIT> ; } } else { low_n = ( ( mode ) == TImode ? <NUM_LIT> : n >= <NUM_LIT> ? ( n & <NUM_LIT> ) : - ( ( - n ) & <NUM_LIT> ) ) ; n -= low_n ; } base_reg = gen_reg_rtx ( SImode ) ; 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 ) ;


<s> add_libcall ( libcall_htab , convert_optab_libfunc ( sfloat_optab , SFmode , DImode ) ) ; add_libcall ( libcall_htab , convert_optab_libfunc ( sfloat_optab , DFmode , DImode ) ) ; add_libcall ( libcall_htab , convert_optab_libfunc ( ufloat_optab , SFmode , SImode ) ) ; add_libcall ( libcall_htab , convert_optab_libfunc ( ufloat_optab , DFmode , SImode ) ) ; add_libcall ( libcall_htab , convert_optab_libfunc ( ufloat_optab , SFmode , DImode ) ) ; add_libcall ( libcall_htab , convert_optab_libfunc ( ufloat_optab , DFmode , DImode ) ) ; add_libcall ( libcall_htab , convert_optab_libfunc ( sext_optab , SFmode , HFmode ) ) ; add_libcall ( libcall_htab , convert_optab_libfunc ( trunc_optab , HFmode , SFmode ) ) ; 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> if ( TREE_CODE ( type ) == ARRAY_TYPE ) return TYPE_ALIGN ( TREE_TYPE ( type ) ) > PARM_BOUNDARY ; int ret = <NUM_LIT> ; for ( tree field = TYPE_FIELDS ( type ) ; field ; field = DECL_CHAIN ( field ) ) if ( DECL_ALIGN ( field ) > PARM_BOUNDARY ) { if ( TREE_CODE ( field ) == FIELD_DECL ) return <NUM_LIT> ;


<s> if ( ! type ) return GET_MODE_ALIGNMENT ( mode ) > PARM_BOUNDARY ; if ( ! AGGREGATE_TYPE_P ( type ) ) return TYPE_ALIGN ( TYPE_MAIN_VARIANT ( type ) ) > PARM_BOUNDARY ; if ( TREE_CODE ( type ) == ARRAY_TYPE ) return TYPE_ALIGN ( TREE_TYPE ( type ) ) > PARM_BOUNDARY ;


<s> if ( TARGET_ARM_P ( flags ) && write_symbols != NO_DEBUG && ! TARGET_APCS_FRAME && ( TARGET_DEFAULT & MASK_APCS_FRAME ) ) warning ( <NUM_LIT> , <STR_LIT> ) ; if ( TARGET_THUMB_P ( flags ) && TARGET_IWMMXT ) error ( <STR_LIT> ) ; if ( TARGET_HARD_TP && TARGET_THUMB1_P ( flags ) ) error ( <STR_LIT> ) ; if ( TARGET_THUMB_P ( flags ) && TARGET_VXWORKS_RTP && flag_pic ) { error ( <STR_LIT> ) ; flag_pic = <NUM_LIT> ;


<s> if ( TARGET_ARM_P ( flags ) && write_symbols != NO_DEBUG && ! TARGET_APCS_FRAME && ( TARGET_DEFAULT & MASK_APCS_FRAME ) ) warning ( <NUM_LIT> , <STR_LIT> ) ; if ( TARGET_THUMB_P ( flags ) && TARGET_IWMMXT ) error ( <STR_LIT> ) ; if ( TARGET_HARD_TP && TARGET_THUMB1_P ( flags ) ) error ( <STR_LIT> ) ; if ( TARGET_THUMB_P ( flags ) && TARGET_VXWORKS_RTP && flag_pic ) {


<s> opts -> x_target_flags &= ~ MASK_INTERWORK ; } if ( TARGET_THUMB_P ( opts -> x_target_flags ) && ! bitmap_bit_p ( arm_active_target . isa , isa_bit_thumb ) ) { warning ( <NUM_LIT> , <STR_LIT> ) ; opts -> x_target_flags &= ~ MASK_THUMB ; } if ( TARGET_APCS_FRAME && TARGET_THUMB_P ( opts -> x_target_flags ) ) { opts -> x_target_flags &= ~ MASK_APCS_FRAME ; } if ( TARGET_THUMB_P ( opts -> x_target_flags ) && TARGET_CALLEE_INTERWORKING ) opts -> x_target_flags |= MASK_INTERWORK ; cl_optimization * to = TREE_OPTIMIZATION ( init_optimize ) ; if ( ! opts_set -> x_arm_restrict_it ) opts -> x_arm_restrict_it = arm_arch8 ; if ( ! TARGET_THUMB2_P ( opts -> x_target_flags ) || ! arm_arch_notm ) opts -> x_arm_restrict_it = <NUM_LIT> ; if ( ! opts_set -> x_unaligned_access ) { opts -> x_unaligned_access = ( TARGET_32BIT_P ( opts -> x_target_flags ) && arm_arch6 && ( arm_arch_notm || arm_arch7 ) ) ;


<s> fpu_name = ( ptr -> x_arm_fpu_index == TARGET_FPU_auto ? <STR_LIT> : all_fpus [ ptr -> x_arm_fpu_index ] . name ) ; fprintf ( file , <STR_LIT> , indent , <STR_LIT> , TARGET_THUMB2_P ( flags ) ? <STR_LIT> :


<s> const char * fpu_name ; fpu_name = ( ptr -> x_arm_fpu_index == TARGET_FPU_auto ? <STR_LIT> : all_fpus [ ptr -> x_arm_fpu_index ] . name ) ;

fprintf ( file , <STR_LIT> , indent , <STR_LIT> , TARGET_THUMB2_P ( flags ) ? <STR_LIT> :


<s> static void arm_option_restore ( struct gcc_options * , struct cl_target_option * ptr ) { arm_configure_build_target ( & arm_active_target , ptr , & global_options_set , false ) ;


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

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


<s> if ( TARGET_32BIT ) arm32_output_mi_thunk ( file , thunk , delta , vcall_offset , function ) ;

else arm_thumb1_mi_thunk ( file , thunk , delta , vcall_offset , function ) ;


<s> static void arm_output_mi_thunk ( FILE * file , tree thunk , HOST_WIDE_INT delta , HOST_WIDE_INT vcall_offset , tree function ) { if ( TARGET_32BIT ) arm32_output_mi_thunk ( file , thunk , delta , vcall_offset , function ) ; else arm_thumb1_mi_thunk ( file , thunk , delta , vcall_offset , function ) ;


<s> static rtx_insn * arm_pic_static_addr ( rtx orig , rtx reg ) { rtx l1 , labelno , offset_rtx ; gcc_assert ( flag_pic ) ; labelno = GEN_INT ( pic_labelno ++ ) ; l1 = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , labelno ) , UNSPEC_PIC_LABEL ) ; l1 = gen_rtx_CONST ( VOIDmode , l1 ) ;


<s> rtx l1 , labelno , offset_rtx ; gcc_assert ( flag_pic ) ; 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> if ( TARGET_THUMB1 ) thumb1_reorg ( ) ; else if ( TARGET_THUMB2 ) thumb2_reorg ( ) ; if ( ! optimize ) split_all_insns_noflow ( ) ; minipool_fix_head = minipool_fix_tail = NULL ; insn = get_insns ( ) ; gcc_assert ( NOTE_P ( insn ) ) ; minipool_pad = <NUM_LIT> ; for ( insn = next_nonnote_insn ( insn ) ; insn ; insn = next_nonnote_insn ( insn ) ) { if ( BARRIER_P ( insn ) ) push_minipool_barrier ( insn , address ) ; else if ( INSN_P ( insn ) ) { rtx_jump_table_data * table ; note_invalid_constants ( insn , address , true ) ; address += get_attr_length ( insn ) ; if ( tablejump_p ( insn , NULL , & table ) ) { 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 ;


<s> result = arm_rtx_costs_internal ( x , ( enum rtx_code ) code , ( enum rtx_code ) outer_code , current_tune -> insn_extra_cost , total , speed ) ;

if ( dump_file && ( dump_flags & TDF_DETAILS ) ) {


<s> 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> ) ; start_reg = reg + <NUM_LIT> ; }


<s> } if ( TARGET_HARD_FLOAT ) { 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> ) ; start_reg = reg + <NUM_LIT> ; } } if ( start_reg != reg ) saved_size += vfp_emit_fstmd ( start_reg , ( reg - start_reg ) / <NUM_LIT> ) ;


<s> if ( nregs & <NUM_LIT> ) { int res = arm_needs_doubleword_align ( mode , type ) ; if ( res < <NUM_LIT> && warn_psabi ) inform ( input_location , <STR_LIT> <STR_LIT> , type ) ;


<s> value = simplify_gen_subreg ( wmode , value , mode , <NUM_LIT> ) ; arm_emit_load_exclusive ( mode , old_out , mem , use_acquire ) ; gcc_assert ( ! new_out || REG_P ( new_out ) ) ; all_low_regs = REG_P ( value ) && REGNO_REG_CLASS ( REGNO ( value ) ) == LO_REGS && new_out && REGNO_REG_CLASS ( REGNO ( new_out ) ) == LO_REGS && REGNO_REG_CLASS ( REGNO ( old_out ) ) == LO_REGS ; bind_old_new = ( TARGET_THUMB1 && code != SET && code != MINUS && ( code != PLUS || ( ! all_low_regs && ! satisfies_constraint_L ( value ) ) ) ) ; if ( old_out && bind_old_new ) { emit_move_insn ( new_out , old_out ) ; old_out = new_out ; } switch ( code ) { case SET : new_out = value ; break ; case NOT : x = gen_rtx_AND ( wmode , old_out , value ) ; emit_insn ( gen_rtx_SET ( new_out , x ) ) ; x = gen_rtx_NOT ( wmode , new_out ) ; emit_insn ( gen_rtx_SET ( new_out , x ) ) ; break ; case MINUS : if ( CONST_INT_P ( value ) ) { value = GEN_INT ( - INTVAL ( value ) ) ; code = PLUS ; } case PLUS : if ( mode == DImode ) { emit_move_insn ( new_out , old_out ) ; if ( code == PLUS ) x = gen_adddi3 ( new_out , new_out , value ) ; else x = gen_subdi3 ( new_out , new_out , value ) ; emit_insn ( x ) ; break ; } default : x = gen_rtx_fmt_ee ( code , wmode , old_out , value ) ; emit_insn ( gen_rtx_SET ( new_out , x ) ) ; break ; } arm_emit_store_exclusive ( mode , cond , mem , gen_lowpart ( mode , new_out ) , use_release ) ; x = gen_rtx_NE ( VOIDmode , cond , const0_rtx ) ; emit_unlikely_jump ( gen_cbranchsi4 ( x , cond , const0_rtx , label ) ) ; if ( is_armv8_sync || ! ( use_acquire || use_release ) ) arm_post_atomic_barrier ( model ) ;


<s> label = gen_label_rtx ( ) ; emit_label ( label ) ; if ( new_out ) new_out = gen_lowpart ( wmode , new_out ) ; if ( old_out ) old_out = gen_lowpart ( wmode , old_out ) ; else old_out = new_out ; value = simplify_gen_subreg ( wmode , value , mode , <NUM_LIT> ) ; arm_emit_load_exclusive ( mode , old_out , mem , use_acquire ) ; gcc_assert ( ! new_out || REG_P ( new_out ) ) ; all_low_regs = REG_P ( value ) && REGNO_REG_CLASS ( REGNO ( value ) ) == LO_REGS && new_out && REGNO_REG_CLASS ( REGNO ( new_out ) ) == LO_REGS && REGNO_REG_CLASS ( REGNO ( old_out ) ) == LO_REGS ; bind_old_new = ( TARGET_THUMB1 && code != SET && code != MINUS && ( code != PLUS || ( ! all_low_regs && ! satisfies_constraint_L ( value ) ) ) ) ; if ( old_out && bind_old_new ) { emit_move_insn ( new_out , old_out ) ; old_out = new_out ; } switch ( code ) { case SET : new_out = value ; break ; case NOT : x = gen_rtx_AND ( wmode , old_out , value ) ; emit_insn ( gen_rtx_SET ( new_out , x ) ) ; x = gen_rtx_NOT ( wmode , new_out ) ; emit_insn ( gen_rtx_SET ( new_out , x ) ) ; break ; case MINUS : if ( CONST_INT_P ( value ) ) { value = GEN_INT ( - INTVAL ( value ) ) ; code = PLUS ; } case PLUS : if ( mode == DImode ) { emit_move_insn ( new_out , old_out ) ; if ( code == PLUS ) x = gen_adddi3 ( new_out , new_out , value ) ; else x = gen_subdi3 ( new_out , new_out , value ) ; emit_insn ( x ) ;


<s> mod_f = memmodel_from_int ( INTVAL ( operands [ <NUM_LIT> ] ) ) ; neg_bval = TARGET_THUMB1 ? operands [ <NUM_LIT> ] : operands [ <NUM_LIT> ] ; mode = GET_MODE ( mem ) ; bool is_armv8_sync = arm_arch8 && is_mm_sync ( mod_s ) ; bool use_acquire = TARGET_HAVE_LDACQ && ! ( is_mm_relaxed ( mod_s ) || is_mm_consume ( mod_s ) || is_mm_release ( mod_s ) ) ; bool use_release = TARGET_HAVE_LDACQ && ! ( is_mm_relaxed ( mod_s ) || is_mm_consume ( mod_s ) || is_mm_acquire ( mod_s ) ) ; if ( is_armv8_sync ) use_acquire = false ; 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 ) ; if ( TARGET_32BIT ) { cond = arm_gen_compare_reg ( NE , rval , oldval , neg_bval ) ; x = gen_rtx_NE ( VOIDmode , cond , const0_rtx ) ; x = gen_rtx_IF_THEN_ELSE ( VOIDmode , x , gen_rtx_LABEL_REF ( Pmode , label2 ) , pc_rtx ) ; emit_unlikely_jump ( gen_rtx_SET ( pc_rtx , x ) ) ;


<s> rtx rval , mem , oldval , newval , neg_bval ; machine_mode mode ; enum memmodel mod_s , mod_f ; bool is_weak ; rtx_code_label * label1 , * label2 ; rtx x , cond ; rval = operands [ <NUM_LIT> ] ; mem = operands [ <NUM_LIT> ] ; oldval = operands [ <NUM_LIT> ] ; newval = operands [ <NUM_LIT> ] ; is_weak = ( operands [ <NUM_LIT> ] != const0_rtx ) ; mod_s = memmodel_from_int ( INTVAL ( operands [ <NUM_LIT> ] ) ) ; mod_f = memmodel_from_int ( INTVAL ( operands [ <NUM_LIT> ] ) ) ; neg_bval = TARGET_THUMB1 ? operands [ <NUM_LIT> ] : operands [ <NUM_LIT> ] ; mode = GET_MODE ( mem ) ; bool is_armv8_sync = arm_arch8 && is_mm_sync ( mod_s ) ; bool use_acquire = TARGET_HAVE_LDACQ && ! ( is_mm_relaxed ( mod_s ) || is_mm_consume ( mod_s ) || is_mm_release ( mod_s ) ) ; bool use_release = TARGET_HAVE_LDACQ && ! ( is_mm_relaxed ( mod_s ) || is_mm_consume ( mod_s ) || is_mm_acquire ( mod_s ) ) ; if ( is_armv8_sync ) use_acquire = false ; if ( ! ( use_acquire || use_release ) ) arm_pre_atomic_barrier ( mod_s ) ; label1 = NULL ; if ( ! is_weak ) { label1 = gen_label_rtx ( ) ; emit_label ( label1 ) ; }


<s> if ( TARGET_THUMB1 ) { int labelno = thunk_label ++ ; ASM_GENERATE_INTERNAL_LABEL ( label , <STR_LIT> , labelno ) ; if ( TARGET_THUMB1_ONLY ) { fputs ( <STR_LIT> , file ) ; fputs ( <STR_LIT> , file ) ; } else { 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 ) ;


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


<s> 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 HFmode : if ( ! TARGET_VFP_FP16INST ) break ; mode = SFmode ; * op1 = convert_to_mode ( mode , * op1 , <NUM_LIT> ) ; * op2 = convert_to_mode ( mode , * op2 , <NUM_LIT> ) ; case SFmode : case DFmode : if ( ! vfp_compare_operand ( * op1 , mode ) ) * op1 = force_reg ( mode , * op1 ) ; if ( ! vfp_compare_operand ( * op2 , mode ) ) * op2 = force_reg ( mode , * op2 ) ; return true ;


<s> while ( ( q = strtok ( argstr , <STR_LIT> ) ) != NULL ) { while ( ISSPACE ( * q ) ) ++ q ; argstr = NULL ; if ( ! strncmp ( q , <STR_LIT> , <NUM_LIT> ) ) opts -> x_target_flags |= MASK_THUMB ; else if ( ! strncmp ( q , <STR_LIT> , <NUM_LIT> ) ) opts -> x_target_flags &= ~ MASK_THUMB ; else if ( ! strncmp ( q , <STR_LIT> , <NUM_LIT> ) ) { int fpu_index ;

if ( ! opt_enum_arg_to_value ( OPT_mfpu_ , q + <NUM_LIT> , & fpu_index , CL_TARGET ) ) {


<s> else if ( TREE_CODE ( args ) != STRING_CST ) { error ( <STR_LIT> ) ; return false ; } char * argstr = ASTRDUP ( TREE_STRING_POINTER ( args ) ) ; char * q ; while ( ( q = strtok ( argstr , <STR_LIT> ) ) != NULL ) { while ( ISSPACE ( * q ) ) ++ q ; argstr = NULL ; if ( ! strncmp ( q , <STR_LIT> , <NUM_LIT> ) ) opts -> x_target_flags |= MASK_THUMB ; else if ( ! strncmp ( q , <STR_LIT> , <NUM_LIT> ) ) opts -> x_target_flags &= ~ MASK_THUMB ; else if ( ! strncmp ( q , <STR_LIT> , <NUM_LIT> ) ) { int fpu_index ; if ( ! opt_enum_arg_to_value ( OPT_mfpu_ , q + <NUM_LIT> , & fpu_index , CL_TARGET ) ) {


<s> tree arm_valid_target_attribute_tree ( tree args , struct gcc_options * opts , struct gcc_options * opts_set ) { struct cl_target_option cl_opts ; if ( ! arm_valid_target_attribute_rec ( args , opts ) ) return NULL_TREE ; cl_target_option_save ( & cl_opts , opts ) ; arm_configure_build_target ( & arm_active_target , & cl_opts , opts_set , false ) ; arm_option_check_internal ( opts ) ;

arm_option_override_internal ( opts , opts_set ) ;


<s> rtx arg_rtx ; machine_mode arg_mode = TYPE_MODE ( arg_type ) ; prev_arg_type = arg_type ; if ( VOID_TYPE_P ( arg_type ) ) continue ; if ( ! first_param ) arm_function_arg_advance ( args_so_far , arg_mode , arg_type , true ) ; arg_rtx = arm_function_arg ( args_so_far , arg_mode , arg_type , true ) ; if ( ! arg_rtx || arm_arg_partial_bytes ( args_so_far , arg_mode , arg_type , true ) ) { error ( <STR_LIT> <STR_LIT> , name ) ; return true ; } first_param = false ;


<s> gcc_assert ( ( to_clear_mask [ <NUM_LIT> ] & <NUM_LIT> ) == <NUM_LIT> ) ; reg_rtx = gen_rtx_REG ( SImode , R1_REGNUM ) ; emit_move_insn ( reg_rtx , GEN_INT ( ( ( ( ~ padding_bits_to_clear ) << <NUM_LIT> ) >> <NUM_LIT> ) ) ) ; if ( ( ( ~ padding_bits_to_clear ) >> <NUM_LIT> ) > <NUM_LIT> ) emit_insn ( gen_rtx_SET ( gen_rtx_ZERO_EXTRACT ( SImode , reg_rtx , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) ) , GEN_INT ( ( ~ padding_bits_to_clear ) >> <NUM_LIT> ) ) ) ; emit_insn ( gen_andsi3 ( gen_rtx_REG ( SImode , R0_REGNUM ) , gen_rtx_REG ( SImode , R0_REGNUM ) , reg_rtx ) ) ; } for ( regno = R0_REGNUM ; regno <= maxregno ; regno ++ ) { if ( ! ( to_clear_mask [ regno / <NUM_LIT> ] & ( <NUM_LIT> << ( regno % <NUM_LIT> ) ) ) ) continue ; if ( IS_VFP_REGNUM ( regno ) ) { if ( TARGET_VFP_DOUBLE && VFP_REGNO_OK_FOR_DOUBLE ( regno ) && to_clear_mask [ regno / <NUM_LIT> ] & ( <NUM_LIT> << ( ( regno % <NUM_LIT> ) + <NUM_LIT> ) ) ) { emit_move_insn ( gen_rtx_REG ( DFmode , regno ) , CONST1_RTX ( DFmode ) ) ; emit_use ( gen_rtx_REG ( DFmode , regno ) ) ; regno ++ ; } else { emit_move_insn ( gen_rtx_REG ( SFmode , regno ) , CONST1_RTX ( SFmode ) ) ; emit_use ( gen_rtx_REG ( SFmode , regno ) ) ; } } else { if ( TARGET_THUMB1 ) { if ( regno == R0_REGNUM ) emit_move_insn ( gen_rtx_REG ( SImode , regno ) , const0_rtx ) ; else emit_move_insn ( gen_rtx_REG ( SImode , regno ) , gen_rtx_REG ( SImode , R0_REGNUM ) ) ; emit_use ( gen_rtx_REG ( SImode , regno ) ) ; } else { emit_move_insn ( gen_rtx_REG ( SImode , regno ) , gen_rtx_REG ( SImode , LR_REGNUM ) ) ; emit_use ( gen_rtx_REG ( SImode , regno ) ) ; }


<s> int regno , maxregno = IP_REGNUM ; tree result_type ; rtx result_rtl ; to_clear_mask [ <NUM_LIT> ] = ( <NUM_LIT> << ( NUM_ARG_REGS ) ) - <NUM_LIT> ; to_clear_mask [ <NUM_LIT> ] |= ( <NUM_LIT> << IP_REGNUM ) ; if ( TARGET_HARD_FLOAT && ! TARGET_THUMB1 ) { uint64_t float_mask = ( <NUM_LIT> << ( D7_VFP_REGNUM + <NUM_LIT> ) ) - <NUM_LIT> ; maxregno = LAST_VFP_REGNUM ; float_mask &= ~ ( ( <NUM_LIT> << FIRST_VFP_REGNUM ) - <NUM_LIT> ) ; to_clear_mask [ <NUM_LIT> ] |= float_mask ; float_mask = ( <NUM_LIT> << ( maxregno - <NUM_LIT> ) ) - <NUM_LIT> ; to_clear_mask [ <NUM_LIT> ] = float_mask ; emit_use ( gen_rtx_REG ( SImode , IP_REGNUM ) ) ; to_clear_mask [ <NUM_LIT> ] &= ~ ( <NUM_LIT> << IP_REGNUM ) ; emit_use ( gen_rtx_REG ( SImode , <NUM_LIT> ) ) ; to_clear_mask [ <NUM_LIT> ] &= ~ ( <NUM_LIT> << <NUM_LIT> ) ; } for ( regno = NUM_ARG_REGS ; regno < LAST_VFP_REGNUM ; regno ++ ) { if ( IN_RANGE ( regno , FIRST_VFP_REGNUM , D7_VFP_REGNUM ) ) continue ; if ( IN_RANGE ( regno , IP_REGNUM , PC_REGNUM ) ) continue ; if ( call_used_regs [ regno ] ) to_clear_mask [ regno / <NUM_LIT> ] |= ( <NUM_LIT> << ( regno % <NUM_LIT> ) ) ; }


<s> static void emit_unlikely_jump ( rtx insn ) { int very_unlikely = REG_BR_PROB_BASE / <NUM_LIT> - <NUM_LIT> ; rtx_insn * jump = emit_jump_insn ( insn ) ; add_int_reg_note ( jump , REG_BR_PROB , very_unlikely ) ;


<s> cumulative_args_t args_so_far ; tree arg_type , fntype ; bool using_r4 , first_param = true ; function_args_iterator args_iter ; uint32_t padding_bits_to_clear [ <NUM_LIT> ] = { <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> } ; uint32_t * padding_bits_to_clear_ptr = & padding_bits_to_clear [ <NUM_LIT> ] ; if ( ! NONDEBUG_INSN_P ( insn ) ) continue ; if ( ! CALL_P ( insn ) ) continue ; pat = PATTERN ( insn ) ; gcc_assert ( GET_CODE ( pat ) == PARALLEL && XVECLEN ( pat , <NUM_LIT> ) > <NUM_LIT> ) ; call = XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ; if ( GET_CODE ( call ) == SET ) call = SET_SRC ( call ) ; unspec = XEXP ( call , <NUM_LIT> ) ; if ( GET_CODE ( unspec ) != UNSPEC || XINT ( unspec , <NUM_LIT> ) != UNSPEC_NONSECURE_MEM ) continue ; to_clear_mask = ( <NUM_LIT> << ( NUM_ARG_REGS ) ) - <NUM_LIT> ; maxregno = NUM_ARG_REGS - <NUM_LIT> ; if ( TARGET_HARD_FLOAT_ABI ) { float_mask = ( <NUM_LIT> << ( D7_VFP_REGNUM + <NUM_LIT> ) ) - <NUM_LIT> ; float_mask &= ~ ( ( <NUM_LIT> << FIRST_VFP_REGNUM ) - <NUM_LIT> ) ; to_clear_mask |= float_mask ; maxregno = D7_VFP_REGNUM ; } address = RTVEC_ELT ( XVEC ( unspec , <NUM_LIT> ) , <NUM_LIT> ) ; gcc_assert ( MEM_P ( address ) ) ; gcc_assert ( REG_P ( XEXP ( address , <NUM_LIT> ) ) ) ; to_clear_mask &= ~ ( <NUM_LIT> << REGNO ( XEXP ( address , <NUM_LIT> ) ) ) ; set_block_for_insn ( insn , bb ) ; df_set_flags ( DF_DEFER_INSN_RESCAN ) ;


<s> set_block_for_insn ( insn , bb ) ; df_set_flags ( DF_DEFER_INSN_RESCAN ) ; start_sequence ( ) ; emit_insn ( gen_blockage ( ) ) ; fntype = TREE_TYPE ( MEM_EXPR ( address ) ) ; arm_init_cumulative_args ( & args_so_far_v , fntype , NULL_RTX , NULL_TREE ) ; args_so_far = pack_cumulative_args ( & args_so_far_v ) ; FOREACH_FUNCTION_ARGS ( fntype , arg_type , args_iter ) { rtx arg_rtx ; machine_mode arg_mode = TYPE_MODE ( arg_type ) ; if ( VOID_TYPE_P ( arg_type ) ) continue ; if ( ! first_param ) arm_function_arg_advance ( args_so_far , arg_mode , arg_type , true ) ; arg_rtx = arm_function_arg ( args_so_far , arg_mode , arg_type , true ) ; gcc_assert ( REG_P ( arg_rtx ) ) ; to_clear_mask &= ~ compute_not_to_clear_mask ( arg_type , arg_rtx , REGNO ( arg_rtx ) , padding_bits_to_clear_ptr ) ; first_param = false ; } cleared_reg = XEXP ( address , <NUM_LIT> ) ; reg = gen_rtx_REG ( SImode , IP_REGNUM ) ; using_r4 = false ; for ( regno = R0_REGNUM ; regno < NUM_ARG_REGS ; regno ++ ) { if ( padding_bits_to_clear [ regno ] == <NUM_LIT> ) continue ; if ( TARGET_THUMB1 && ! using_r4 ) { using_r4 = true ; reg = cleared_reg ; emit_move_insn ( gen_rtx_REG ( SImode , IP_REGNUM ) , reg ) ; } tmp = GEN_INT ( ( ( ( ~ padding_bits_to_clear [ regno ] ) << <NUM_LIT> ) >> <NUM_LIT> ) ) ; emit_move_insn ( reg , tmp ) ; if ( ( ( ~ padding_bits_to_clear [ regno ] ) >> <NUM_LIT> ) > <NUM_LIT> ) { tmp = GEN_INT ( ( ~ padding_bits_to_clear [ regno ] ) >> <NUM_LIT> ) ; emit_insn ( gen_rtx_SET ( gen_rtx_ZERO_EXTRACT ( SImode , reg , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) ) , tmp ) ) ; } emit_insn ( gen_andsi3 ( gen_rtx_REG ( SImode , regno ) , gen_rtx_REG ( SImode , regno ) , reg ) ) ; } if ( using_r4 ) emit_move_insn ( cleared_reg , gen_rtx_REG ( SImode , IP_REGNUM ) ) ; tmp = gen_rtx_LSHIFTRT ( SImode , cleared_reg , const1_rtx ) ; emit_insn ( gen_rtx_SET ( cleared_reg , tmp ) ) ; tmp = gen_rtx_ASHIFT ( SImode , cleared_reg , const1_rtx ) ; emit_insn ( gen_rtx_SET ( cleared_reg , tmp ) ) ; for ( regno = R0_REGNUM ; regno <= maxregno ; regno ++ ) { if ( ! ( to_clear_mask & ( <NUM_LIT> << regno ) ) ) continue ; if ( IS_VFP_REGNUM ( regno ) ) { if ( TARGET_VFP_DOUBLE && VFP_REGNO_OK_FOR_DOUBLE ( regno ) && to_clear_mask & ( <NUM_LIT> << ( regno + <NUM_LIT> ) ) ) emit_move_insn ( gen_rtx_REG ( DFmode , regno ++ ) , CONST0_RTX ( DFmode ) ) ;

else emit_move_insn ( gen_rtx_REG ( SFmode , regno ) , CONST0_RTX ( SFmode ) ) ;


<s> tmp = peep2_find_free_register ( <NUM_LIT> , <NUM_LIT> , <STR_LIT> , SImode , & regset ) ; if ( tmp == NULL_RTX ) return false ; operands [ <NUM_LIT> ] = tmp ; } else { CLEAR_HARD_REG_SET ( regset ) ; tmp = peep2_find_free_register ( <NUM_LIT> , <NUM_LIT> , <STR_LIT> , DImode , & regset ) ; if ( tmp != NULL_RTX ) { operands [ <NUM_LIT> ] = simplify_gen_subreg ( SImode , tmp , DImode , <NUM_LIT> ) ; operands [ <NUM_LIT> ] = simplify_gen_subreg ( SImode , tmp , DImode , <NUM_LIT> ) ; } else { SET_HARD_REG_SET ( regset ) ; CLEAR_HARD_REG_BIT ( regset , regno % <NUM_LIT> == <NUM_LIT> ? regno + <NUM_LIT> : regno - <NUM_LIT> ) ; tmp = peep2_find_free_register ( <NUM_LIT> , <NUM_LIT> , <STR_LIT> , SImode , & regset ) ; if ( tmp == NULL_RTX ) return false ; operands [ regno % <NUM_LIT> == <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ] = tmp ; } } gcc_assert ( operands [ <NUM_LIT> ] != NULL_RTX ) ; gcc_assert ( operands [ <NUM_LIT> ] != NULL_RTX ) ; gcc_assert ( REGNO ( operands [ <NUM_LIT> ] ) % <NUM_LIT> == <NUM_LIT> ) ; gcc_assert ( REGNO ( operands [ <NUM_LIT> ] ) == REGNO ( operands [ <NUM_LIT> ] ) + <NUM_LIT> ) ; } } if ( offsets [ <NUM_LIT> ] > offsets [ <NUM_LIT> ] ) { gap = offsets [ <NUM_LIT> ] - offsets [ <NUM_LIT> ] ; offset = offsets [ <NUM_LIT> ] ; std :: swap ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; std :: swap ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; if ( const_store ) std :: swap ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; } else { gap = offsets [ <NUM_LIT> ] - offsets [ <NUM_LIT> ] ; offset = offsets [ <NUM_LIT> ] ; } if ( gap != <NUM_LIT> ) return false ; if ( operands_ok_ldrd_strd ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , base , offset , false , load ) ) return true ; if ( TARGET_THUMB2 ) return false ; if ( load && commute ) { std :: swap ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ;


<s> MEM_READONLY_P ( mem ) = <NUM_LIT> ; MEM_NOTRAP_P ( mem ) = <NUM_LIT> ; insn = emit_insn ( pat ) ; } set_unique_reg_note ( insn , REG_EQUAL , orig ) ; return reg ; } 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 ; } 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 ) ) ; return reg ; }

return gen_rtx_PLUS ( Pmode , base , offset ) ;


<s> 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 : tp = arm_load_tp ( NULL_RTX ) ; reg = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , x , GEN_INT ( TLS_LE32 ) ) , UNSPEC_TLS ) ;

reg = force_reg ( SImode , gen_rtx_CONST ( SImode , reg ) ) ;


<s> 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> else { if ( stack_adjust ) live_regs_mask |= <NUM_LIT> << <NUM_LIT> ; sprintf ( instr , <STR_LIT> , conditional ) ; } } else if ( IS_INTERRUPT ( func_type ) ) sprintf ( instr , <STR_LIT> , conditional ) ; else sprintf ( instr , <STR_LIT> , conditional ) ; p = instr + strlen ( instr ) ; for ( reg = <NUM_LIT> ; reg <= SP_REGNUM ; reg ++ ) if ( live_regs_mask & ( <NUM_LIT> << reg ) ) { int l = strlen ( reg_names [ reg ] ) ; if ( first ) first = <NUM_LIT> ; else { memcpy ( p , <STR_LIT> , <NUM_LIT> ) ; p += <NUM_LIT> ; } memcpy ( p , <STR_LIT> , <NUM_LIT> ) ; memcpy ( p + <NUM_LIT> , reg_names [ reg ] , l ) ; p += l + <NUM_LIT> ; } if ( live_regs_mask & ( <NUM_LIT> << LR_REGNUM ) ) { sprintf ( p , <STR_LIT> , first ? <STR_LIT> : <STR_LIT> , return_reg ) ; if ( IS_INTERRUPT ( func_type ) ) strcat ( p , <STR_LIT> ) ; } else strcpy ( p , <STR_LIT> ) ; } output_asm_insn ( instr , & operand ) ; if ( really_return && func_type != ARM_FT_INTERWORKED && ( live_regs_mask & ( <NUM_LIT> << LR_REGNUM ) ) != <NUM_LIT> ) { return <STR_LIT> ; } } if ( really_return ) { switch ( ( int ) ARM_FUNC_TYPE ( func_type ) ) { case ARM_FT_ISR : case ARM_FT_FIQ : sprintf ( instr , <STR_LIT> , conditional ) ; break ; case ARM_FT_INTERWORKED : gcc_assert ( arm_arch5 || arm_arch4t ) ; sprintf ( instr , <STR_LIT> , conditional ) ; break ; case ARM_FT_EXCEPTION : sprintf ( instr , <STR_LIT> , conditional ) ; break ; default :


<s> if ( frame_pointer_needed ) mask |= <NUM_LIT> << HARD_FRAME_POINTER_REGNUM ; if ( flag_pic && ! TARGET_SINGLE_PIC_BASE && arm_pic_register != INVALID_REGNUM && crtl -> uses_pic_offset_table ) mask |= <NUM_LIT> << PIC_OFFSET_TABLE_REGNUM ; if ( ! frame_pointer_needed && CALLER_INTERWORKING_SLOT_SIZE > <NUM_LIT> ) mask |= <NUM_LIT> << ARM_HARD_FRAME_POINTER_REGNUM ; if ( mask & <NUM_LIT> || thumb_force_lr_save ( ) ) mask |= ( <NUM_LIT> << LR_REGNUM ) ; if ( ( mask & <NUM_LIT> ) == <NUM_LIT> && ( ( mask & <NUM_LIT> ) || TARGET_BACKTRACE ) ) { reg = thumb_find_work_register ( <NUM_LIT> << LAST_LO_REGNUM ) ; if ( reg * UNITS_PER_WORD <= ( unsigned ) arm_size_return_regs ( ) ) reg = LAST_LO_REGNUM ; if ( callee_saved_reg_p ( reg ) ) mask |= <NUM_LIT> << reg ; } if ( ( CALLER_INTERWORKING_SLOT_SIZE + ROUND_UP_WORD ( get_frame_size ( ) ) + crtl -> outgoing_args_size ) >= <NUM_LIT> ) { for ( reg = LAST_ARG_REGNUM + <NUM_LIT> ; reg <= LAST_LO_REGNUM ; reg ++ ) if ( mask & ( <NUM_LIT> << reg ) ) break ; if ( reg > LAST_LO_REGNUM ) { mask |= <NUM_LIT> << LAST_LO_REGNUM ; } }


<s> unsigned reg ; mask = <NUM_LIT> ; for ( reg = <NUM_LIT> ; reg < <NUM_LIT> ; reg ++ ) if ( df_regs_ever_live_p ( reg ) && callee_saved_reg_p ( reg ) ) mask |= <NUM_LIT> << reg ; if ( frame_pointer_needed ) mask |= <NUM_LIT> << HARD_FRAME_POINTER_REGNUM ; if ( flag_pic && ! TARGET_SINGLE_PIC_BASE && arm_pic_register != INVALID_REGNUM && crtl -> uses_pic_offset_table ) mask |= <NUM_LIT> << PIC_OFFSET_TABLE_REGNUM ; if ( ! frame_pointer_needed && CALLER_INTERWORKING_SLOT_SIZE > <NUM_LIT> ) mask |= <NUM_LIT> << ARM_HARD_FRAME_POINTER_REGNUM ; if ( mask & <NUM_LIT> || thumb_force_lr_save ( ) ) mask |= ( <NUM_LIT> << LR_REGNUM ) ; if ( ( mask & <NUM_LIT> ) == <NUM_LIT> && ( ( mask & <NUM_LIT> ) || TARGET_BACKTRACE ) ) { reg = thumb_find_work_register ( <NUM_LIT> << LAST_LO_REGNUM ) ; if ( reg * UNITS_PER_WORD <= ( unsigned ) arm_size_return_regs ( ) ) reg = LAST_LO_REGNUM ; if ( callee_saved_reg_p ( reg ) ) mask |= <NUM_LIT> << reg ; } if ( ( CALLER_INTERWORKING_SLOT_SIZE + ROUND_UP_WORD ( get_frame_size ( ) ) + crtl -> outgoing_args_size ) >= <NUM_LIT> ) { for ( reg = LAST_ARG_REGNUM + <NUM_LIT> ; reg <= LAST_LO_REGNUM ; reg ++ ) if ( mask & ( <NUM_LIT> << reg ) ) break ; if ( reg > LAST_LO_REGNUM ) { mask |= <NUM_LIT> << LAST_LO_REGNUM ;


<s> amount = offsets -> outgoing_args - offsets -> saved_regs ; if ( frame_pointer_needed ) { emit_insn ( gen_movsi ( stack_pointer_rtx , hard_frame_pointer_rtx ) ) ; amount = offsets -> locals_base - offsets -> saved_regs ; } amount -= <NUM_LIT> * thumb1_extra_regs_pushed ( offsets , false ) ; gcc_assert ( amount >= <NUM_LIT> ) ; if ( amount ) { emit_insn ( gen_blockage ( ) ) ; if ( amount < <NUM_LIT> ) emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( amount ) ) ) ;


<s> emit_insn ( gen_force_register_use ( stack_pointer_rtx ) ) ; if ( crtl -> profile || ! TARGET_SCHED_PROLOG ) emit_insn ( gen_blockage ( ) ) ; for ( regno = <NUM_LIT> ; regno < <NUM_LIT> ; regno ++ ) if ( df_regs_ever_live_p ( regno ) && ! call_used_regs [ regno ] ) emit_clobber ( gen_rtx_REG ( SImode , regno ) ) ; if ( ! df_regs_ever_live_p ( LR_REGNUM ) ) emit_use ( gen_rtx_REG ( SImode , LR_REGNUM ) ) ;


<s> } else if ( outer == ASHIFT || outer == ASHIFTRT || outer == LSHIFTRT ) return <NUM_LIT> ; return COSTS_N_INSNS ( <NUM_LIT> ) ; case CONST : case CONST_DOUBLE : case LABEL_REF : case SYMBOL_REF : return COSTS_N_INSNS ( <NUM_LIT> ) ; case UDIV : case UMOD : case DIV : case MOD : return <NUM_LIT> ; case TRUNCATE : return <NUM_LIT> ; case AND : case XOR : case IOR : return <NUM_LIT> ; case MEM : return ( <NUM_LIT> + <NUM_LIT> * ( ( GET_MODE_SIZE ( mode ) - <NUM_LIT> ) / UNITS_PER_WORD ) + ( ( GET_CODE ( x ) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P ( x ) ) ? <NUM_LIT> : <NUM_LIT> ) ) ; case IF_THEN_ELSE : if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PC || GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PC ) return <NUM_LIT> ; return <NUM_LIT> ; case SIGN_EXTEND : case ZERO_EXTEND : total = mode == DImode ? COSTS_N_INSNS ( <NUM_LIT> ) : <NUM_LIT> ; total += thumb1_rtx_costs ( XEXP ( x , <NUM_LIT> ) , GET_CODE ( XEXP ( x , <NUM_LIT> ) ) , code ) ; if ( mode == SImode ) return total ; if ( arm_arch6 ) return total + COSTS_N_INSNS ( <NUM_LIT> ) ; return total + <NUM_LIT> + COSTS_N_INSNS ( <NUM_LIT> ) ; default : return <NUM_LIT> ; }


<s> int i ; for ( i = <NUM_LIT> ; i <= <NUM_LIT> ; i ++ ) if ( ( HOST_WIDE_INT_1 << i ) - <NUM_LIT> == INTVAL ( x ) || ( HOST_WIDE_INT_1 << i ) - <NUM_LIT> == ~ INTVAL ( x ) ) return COSTS_N_INSNS ( <NUM_LIT> ) ; } else if ( outer == ASHIFT || outer == ASHIFTRT || outer == LSHIFTRT ) return <NUM_LIT> ; return COSTS_N_INSNS ( <NUM_LIT> ) ; case CONST : case CONST_DOUBLE : case LABEL_REF : case SYMBOL_REF : return COSTS_N_INSNS ( <NUM_LIT> ) ; case UDIV : case UMOD : case DIV : case MOD : return <NUM_LIT> ; case TRUNCATE : return <NUM_LIT> ; case AND : case XOR : case IOR : return <NUM_LIT> ; case MEM : return ( <NUM_LIT> + <NUM_LIT> * ( ( GET_MODE_SIZE ( mode ) - <NUM_LIT> ) / UNITS_PER_WORD ) + ( ( GET_CODE ( x ) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P ( x ) ) ? <NUM_LIT> : <NUM_LIT> ) ) ; case IF_THEN_ELSE : if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PC || GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PC ) return <NUM_LIT> ; return <NUM_LIT> ; case SIGN_EXTEND : case ZERO_EXTEND : total = mode == DImode ? COSTS_N_INSNS ( <NUM_LIT> ) : <NUM_LIT> ; total += thumb1_rtx_costs ( XEXP ( x , <NUM_LIT> ) , GET_CODE ( XEXP ( x , <NUM_LIT> ) ) , code ) ;


<s> 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> ) ; HOST_WIDE_INT offset ; if ( ! CONST_INT_P ( addend ) ) return <NUM_LIT> ; offset = INTVAL ( addend ) ; if ( GET_MODE_SIZE ( mode ) <= <NUM_LIT> ) return ( offset > - <NUM_LIT> && offset < <NUM_LIT> ) ; return ( use_ldrd && offset > - <NUM_LIT> && offset < <NUM_LIT> && ( offset & <NUM_LIT> ) == <NUM_LIT> ) ; } 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> ;


<s> pops_needed = <NUM_LIT> ; if ( reg_containing_return_addr == - <NUM_LIT> ) { regs_to_pop |= <NUM_LIT> << LR_REGNUM ; ++ pops_needed ; } if ( TARGET_BACKTRACE ) { regs_to_pop |= ( <NUM_LIT> << ARM_HARD_FRAME_POINTER_REGNUM ) | ( <NUM_LIT> << SP_REGNUM ) ; pops_needed += <NUM_LIT> ; } if ( pops_needed == <NUM_LIT> ) { if ( crtl -> calls_eh_return ) asm_fprintf ( f , <STR_LIT> , SP_REGNUM , ARM_EH_STACKADJ_REGNUM ) ; if ( IS_CMSE_ENTRY ( arm_current_func_type ( ) ) ) { asm_fprintf ( f , <STR_LIT> , reg_containing_return_addr ) ; asm_fprintf ( f , <STR_LIT> , reg_containing_return_addr ) ; } else asm_fprintf ( f , <STR_LIT> , reg_containing_return_addr ) ; return ; } else if ( ! TARGET_INTERWORK && ! TARGET_BACKTRACE && ! is_called_in_ARM_mode ( current_function_decl ) && ! crtl -> calls_eh_return && ! IS_CMSE_ENTRY ( arm_current_func_type ( ) ) ) { asm_fprintf ( f , <STR_LIT> , PC_REGNUM ) ; return ; } regs_available_for_popping = <NUM_LIT> ; if ( crtl -> calls_eh_return ) size = <NUM_LIT> ; else { if ( crtl -> return_rtx != <NUM_LIT> ) mode = GET_MODE ( crtl -> return_rtx ) ; else mode = DECL_MODE ( DECL_RESULT ( current_function_decl ) ) ; size = GET_MODE_SIZE ( mode ) ; if ( size == <NUM_LIT> ) { if ( mode == VOIDmode ) regs_available_for_popping = ( <NUM_LIT> << ARG_REGISTER ( <NUM_LIT> ) ) | ( <NUM_LIT> << ARG_REGISTER ( <NUM_LIT> ) ) | ( <NUM_LIT> << ARG_REGISTER ( <NUM_LIT> ) ) ; else regs_available_for_popping = ( <NUM_LIT> << ARG_REGISTER ( <NUM_LIT> ) ) | ( <NUM_LIT> << ARG_REGISTER ( <NUM_LIT> ) ) ; } else if ( size <= <NUM_LIT> ) regs_available_for_popping = ( <NUM_LIT> << ARG_REGISTER ( <NUM_LIT> ) ) | ( <NUM_LIT> << ARG_REGISTER ( <NUM_LIT> ) ) ; else if ( size <= <NUM_LIT> ) regs_available_for_popping = ( <NUM_LIT> << ARG_REGISTER ( <NUM_LIT> ) ) ; } for ( available = regs_available_for_popping , required = regs_to_pop ; required != <NUM_LIT> && available != <NUM_LIT> ; available &= ~ ( available & - available ) , required &= ~ ( required & - required ) ) -- pops_needed ; if ( available > <NUM_LIT> ) regs_available_for_popping &= ~ available ; else if ( pops_needed ) {


<s> } for ( available = regs_available_for_popping , required = regs_to_pop ; required != <NUM_LIT> && available != <NUM_LIT> ; available &= ~ ( available & - available ) , required &= ~ ( required & - required ) ) -- pops_needed ; if ( available > <NUM_LIT> ) regs_available_for_popping &= ~ available ; else if ( pops_needed ) { if ( regs_available_for_popping == <NUM_LIT> && reg_containing_return_addr == LAST_ARG_REGNUM ) { asm_fprintf ( f , <STR_LIT> , LR_REGNUM , LAST_ARG_REGNUM ) ; reg_containing_return_addr = LR_REGNUM ; } else if ( size > <NUM_LIT> ) { restore_a4 = TRUE ; asm_fprintf ( f , <STR_LIT> , IP_REGNUM , LAST_ARG_REGNUM ) ; } if ( reg_containing_return_addr != LAST_ARG_REGNUM ) { regs_available_for_popping |= <NUM_LIT> << LAST_ARG_REGNUM ; -- pops_needed ; } } thumb_pop ( f , regs_available_for_popping ) ; if ( reg_containing_return_addr == - <NUM_LIT> ) { regs_to_pop &= ~ ( <NUM_LIT> << LR_REGNUM ) ; reg_containing_return_addr = number_of_first_bit_set ( regs_available_for_popping ) ; regs_available_for_popping &= ~ ( <NUM_LIT> << reg_containing_return_addr ) ; } if ( regs_available_for_popping ) { int frame_pointer ; frame_pointer = number_of_first_bit_set ( regs_available_for_popping ) ; asm_fprintf ( f , <STR_LIT> , ARM_HARD_FRAME_POINTER_REGNUM , frame_pointer ) ; regs_available_for_popping &= ~ ( <NUM_LIT> << frame_pointer ) ; regs_to_pop &= ~ ( <NUM_LIT> << ARM_HARD_FRAME_POINTER_REGNUM ) ; if ( regs_available_for_popping ) { int stack_pointer ; stack_pointer = number_of_first_bit_set ( regs_available_for_popping ) ; asm_fprintf ( f , <STR_LIT> , SP_REGNUM , stack_pointer ) ; } else { regs_available_for_popping |= ( <NUM_LIT> << frame_pointer ) ; } } if ( regs_available_for_popping == <NUM_LIT> && pops_needed > <NUM_LIT> ) { regs_available_for_popping |= <NUM_LIT> << reg_containing_return_addr ; asm_fprintf ( f , <STR_LIT> , LR_REGNUM , reg_containing_return_addr ) ; reg_containing_return_addr = LR_REGNUM ; } if ( pops_needed > <NUM_LIT> ) { int popped_into ; int move_to ; thumb_pop ( f , regs_available_for_popping ) ; popped_into = number_of_first_bit_set ( regs_available_for_popping ) ; move_to = number_of_first_bit_set ( regs_to_pop ) ; asm_fprintf ( f , <STR_LIT> , move_to , popped_into ) ; regs_to_pop &= ~ ( <NUM_LIT> << move_to ) ; -- pops_needed ; } if ( pops_needed > <NUM_LIT> ) { int popped_into ; thumb_pop ( f , regs_available_for_popping ) ; popped_into = number_of_first_bit_set ( regs_available_for_popping ) ; asm_fprintf ( f , <STR_LIT> , SP_REGNUM , popped_into ) ; } if ( restore_a4 ) {

if ( reg_containing_return_addr != LR_REGNUM ) {


<s> return ( CONST_INT_P ( x ) || CONST_DOUBLE_P ( x ) || CONSTANT_ADDRESS_P ( x ) || flag_pic ) ;


<s> if ( lo_mask & <NUM_LIT> ) { asm_fprintf ( f , <STR_LIT> , regno ) ; if ( ( lo_mask & ~ <NUM_LIT> ) != <NUM_LIT> ) fprintf ( f , <STR_LIT> ) ; pushed_words ++ ; } } if ( mask & ( <NUM_LIT> << PC_REGNUM ) ) { if ( TARGET_INTERWORK || TARGET_BACKTRACE || crtl -> calls_eh_return || IS_CMSE_ENTRY ( arm_current_func_type ( ) ) ) { fprintf ( f , <STR_LIT> ) ; thumb_exit ( f , - <NUM_LIT> ) ; return ; } else { if ( mask & <NUM_LIT> ) fprintf ( f , <STR_LIT> ) ; asm_fprintf ( f , <STR_LIT> , PC_REGNUM ) ; } } fprintf ( f , <STR_LIT> ) ;


<s> fprintf ( f , <STR_LIT> ) ; for ( regno = <NUM_LIT> ; regno <= LAST_LO_REGNUM ; regno ++ , lo_mask >>= <NUM_LIT> ) { if ( lo_mask & <NUM_LIT> ) { asm_fprintf ( f , <STR_LIT> , regno ) ; if ( ( lo_mask & ~ <NUM_LIT> ) != <NUM_LIT> ) fprintf ( f , <STR_LIT> ) ; pushed_words ++ ; } } if ( mask & ( <NUM_LIT> << PC_REGNUM ) ) { if ( TARGET_INTERWORK || TARGET_BACKTRACE || crtl -> calls_eh_return || IS_CMSE_ENTRY ( arm_current_func_type ( ) ) ) { fprintf ( f , <STR_LIT> ) ; thumb_exit ( f , - <NUM_LIT> ) ; return ; } else { if ( mask & <NUM_LIT> ) fprintf ( f , <STR_LIT> ) ; asm_fprintf ( f , <STR_LIT> , PC_REGNUM ) ;


<s> unsigned HOST_WIDE_INT stack_adjust ; arm_stack_offsets * offsets ; if ( ! reload_completed ) return <NUM_LIT> ; func_type = arm_current_func_type ( ) ; if ( func_type & ( ARM_FT_VOLATILE | ARM_FT_NAKED | ARM_FT_STACKALIGN ) ) return <NUM_LIT> ; if ( IS_INTERRUPT ( func_type ) && ( frame_pointer_needed || TARGET_THUMB ) ) return <NUM_LIT> ; if ( TARGET_LDRD && current_tune -> prefer_ldrd_strd && ! optimize_function_for_size_p ( cfun ) ) return <NUM_LIT> ; offsets = arm_get_frame_offsets ( ) ; stack_adjust = offsets -> outgoing_args - offsets -> saved_regs ; if ( crtl -> args . pretend_args_size || cfun -> machine -> uses_anonymous_args || crtl -> calls_eh_return || cfun -> calls_alloca || ! ( stack_adjust == <NUM_LIT> || ( TARGET_APCS_FRAME && frame_pointer_needed && stack_adjust == <NUM_LIT> ) ) || ( ! ( TARGET_APCS_FRAME && frame_pointer_needed ) && arm_compute_static_chain_stack_bytes ( ) != <NUM_LIT> ) ) return <NUM_LIT> ; saved_int_regs = offsets -> saved_regs_mask ; if ( stack_adjust == <NUM_LIT> && ! arm_arch5 && TARGET_ARM ) {

if ( ! call_used_regs [ <NUM_LIT> ] ) return <NUM_LIT> ;


<s> unsigned long saved_int_regs ; unsigned HOST_WIDE_INT stack_adjust ; arm_stack_offsets * offsets ; if ( ! reload_completed ) return <NUM_LIT> ; func_type = arm_current_func_type ( ) ; if ( func_type & ( ARM_FT_VOLATILE | ARM_FT_NAKED | ARM_FT_STACKALIGN ) ) return <NUM_LIT> ; if ( IS_INTERRUPT ( func_type ) && ( frame_pointer_needed || TARGET_THUMB ) ) return <NUM_LIT> ; if ( TARGET_LDRD && current_tune -> prefer_ldrd_strd && ! optimize_function_for_size_p ( cfun ) ) return <NUM_LIT> ; offsets = arm_get_frame_offsets ( ) ; stack_adjust = offsets -> outgoing_args - offsets -> saved_regs ; if ( crtl -> args . pretend_args_size || cfun -> machine -> uses_anonymous_args || crtl -> calls_eh_return || cfun -> calls_alloca || ! ( stack_adjust == <NUM_LIT> || ( TARGET_APCS_FRAME && frame_pointer_needed && stack_adjust == <NUM_LIT> ) ) || ( ! ( TARGET_APCS_FRAME && frame_pointer_needed ) && arm_compute_static_chain_stack_bytes ( ) != <NUM_LIT> ) ) return <NUM_LIT> ; saved_int_regs = offsets -> saved_regs_mask ; if ( stack_adjust == <NUM_LIT> && ! arm_arch5 && TARGET_ARM ) { if ( ! call_used_regs [ <NUM_LIT> ] ) return <NUM_LIT> ; if ( arm_size_return_regs ( ) >= ( <NUM_LIT> * UNITS_PER_WORD ) ) return <NUM_LIT> ; if ( sibling ) { gcc_assert ( CALL_P ( sibling ) ) ; if ( find_regno_fusage ( sibling , USE , <NUM_LIT> ) ) return <NUM_LIT> ; } if ( saved_int_regs & <NUM_LIT> ) return <NUM_LIT> ; } if ( TARGET_INTERWORK && saved_int_regs != <NUM_LIT> && ! IS_INTERRUPT ( func_type ) ) return <NUM_LIT> ; if ( iscond && arm_tune_strongarm ) { if ( saved_int_regs != <NUM_LIT> && saved_int_regs != ( <NUM_LIT> << LR_REGNUM ) ) return <NUM_LIT> ; if ( flag_pic && arm_pic_register != INVALID_REGNUM && df_regs_ever_live_p ( PIC_OFFSET_TABLE_REGNUM ) ) return <NUM_LIT> ; } if ( saved_int_regs && IS_CMSE_ENTRY ( func_type ) ) return <NUM_LIT> ; if ( saved_int_regs && ! ( saved_int_regs & ( <NUM_LIT> << LR_REGNUM ) ) ) return <NUM_LIT> ; if ( TARGET_HARD_FLOAT ) for ( regno = FIRST_VFP_REGNUM ; regno <= LAST_VFP_REGNUM ; regno ++ ) if ( df_regs_ever_live_p ( regno ) && ! call_used_regs [ regno ] ) return <NUM_LIT> ; if ( TARGET_REALLY_IWMMXT ) for ( regno = FIRST_IWMMXT_REGNUM ; regno <= LAST_IWMMXT_REGNUM ; regno ++ ) if ( df_regs_ever_live_p ( regno ) && ! call_used_regs [ regno ] ) return <NUM_LIT> ;


<s> break ; case <NUM_LIT> : mode = V4SImode ; break ; default : return - <NUM_LIT> ; } if ( * modep == VOIDmode ) * modep = mode ; if ( * modep == mode ) return <NUM_LIT> ; break ; case ARRAY_TYPE : { int count ; tree index = TYPE_DOMAIN ( type ) ; if ( ! COMPLETE_TYPE_P ( type ) || TREE_CODE ( TYPE_SIZE ( type ) ) != INTEGER_CST ) return - <NUM_LIT> ; count = aapcs_vfp_sub_candidate ( TREE_TYPE ( type ) , modep ) ; if ( count == - <NUM_LIT> || ! index || ! TYPE_MAX_VALUE ( index ) || ! tree_fits_uhwi_p ( TYPE_MAX_VALUE ( index ) ) || ! TYPE_MIN_VALUE ( index ) || ! tree_fits_uhwi_p ( TYPE_MIN_VALUE ( index ) ) || count < <NUM_LIT> ) return - <NUM_LIT> ; count *= ( <NUM_LIT> + tree_to_uhwi ( TYPE_MAX_VALUE ( index ) ) - tree_to_uhwi ( TYPE_MIN_VALUE ( index ) ) ) ; if ( wi :: to_wide ( TYPE_SIZE ( type ) ) != count * GET_MODE_BITSIZE ( * modep ) ) return - <NUM_LIT> ; return count ; } case RECORD_TYPE : { int count = <NUM_LIT> ; int sub_count ; tree field ; if ( ! COMPLETE_TYPE_P ( type ) || TREE_CODE ( TYPE_SIZE ( type ) ) != INTEGER_CST ) return - <NUM_LIT> ; for ( field = TYPE_FIELDS ( type ) ; field ; field = DECL_CHAIN ( field ) ) { if ( TREE_CODE ( field ) != FIELD_DECL ) continue ; sub_count = aapcs_vfp_sub_candidate ( TREE_TYPE ( field ) , modep ) ; if ( sub_count < <NUM_LIT> ) return - <NUM_LIT> ; count += sub_count ; } if ( wi :: to_wide ( TYPE_SIZE ( type ) ) != count * GET_MODE_BITSIZE ( * modep ) ) return - <NUM_LIT> ; return count ; } case UNION_TYPE :


<s> if ( size == UNITS_PER_WORD && aligned_p ) { fputs ( <STR_LIT> , asm_out_file ) ; output_addr_const ( asm_out_file , x ) ; if ( NEED_GOT_RELOC && flag_pic && making_const_table && ( GET_CODE ( x ) == SYMBOL_REF || GET_CODE ( x ) == LABEL_REF ) ) { if ( ! arm_pic_data_is_text_relative || ( GET_CODE ( x ) == SYMBOL_REF && ( ! SYMBOL_REF_LOCAL_P ( x ) || ( SYMBOL_REF_DECL ( x ) ? DECL_WEAK ( SYMBOL_REF_DECL ( x ) ) : <NUM_LIT> ) ) ) ) fputs ( <STR_LIT> , asm_out_file ) ; else fputs ( <STR_LIT> , asm_out_file ) ; } fputc ( '\n' , asm_out_file ) ; return true ; } mode = GET_MODE ( x ) ; if ( arm_vector_mode_supported_p ( mode ) ) { int i , units ; gcc_assert ( GET_CODE ( x ) == CONST_VECTOR ) ; units = CONST_VECTOR_NUNITS ( x ) ; size = GET_MODE_UNIT_SIZE ( mode ) ; if ( GET_MODE_CLASS ( mode ) == MODE_VECTOR_INT ) for ( i = <NUM_LIT> ; i < units ; i ++ ) { rtx elt = CONST_VECTOR_ELT ( x , i ) ; assemble_integer ( elt , size , i == <NUM_LIT> ? BIGGEST_ALIGNMENT : size * BITS_PER_UNIT , <NUM_LIT> ) ; }

else for ( i = <NUM_LIT> ; i < units ; i ++ ) {


<s> if ( ! TARGET_NEON_VECTORIZE_DOUBLE ) { sizes -> safe_push ( <NUM_LIT> ) ; sizes -> safe_push ( <NUM_LIT> ) ; }


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


<s> label = gen_rtx_CONST ( VOIDmode , label ) ; sum = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , x , GEN_INT ( reloc ) , label , GEN_INT ( TARGET_ARM ? <NUM_LIT> : <NUM_LIT> ) ) , UNSPEC_TLS ) ; reg = load_tls_operand ( sum , reg ) ;

if ( TARGET_ARM ) emit_insn ( gen_pic_add_dot_plus_eight ( reg , reg , labelno ) ) ;


<s> sum = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , x , GEN_INT ( reloc ) , label , GEN_INT ( TARGET_ARM ? <NUM_LIT> : <NUM_LIT> ) ) , UNSPEC_TLS ) ; reg = load_tls_operand ( sum , reg ) ; if ( TARGET_ARM ) emit_insn ( gen_pic_add_dot_plus_eight ( reg , reg , labelno ) ) ; else emit_insn ( gen_pic_add_dot_plus_four ( reg , reg , labelno ) ) ; * valuep = emit_library_call_value ( get_tls_get_addr ( ) , NULL_RTX , LCT_PURE , Pmode , reg , Pmode ) ; rtx_insn * insns = get_insns ( ) ; end_sequence ( ) ; return insns ;


<s> 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 ( crtl -> is_leaf && frame_size == <NUM_LIT> && ! cfun -> calls_alloca ) { offsets -> outgoing_args = offsets -> soft_frame ; offsets -> locals_base = offsets -> soft_frame ; return ; } 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> ) {


<s> static void arm_compute_frame_layout ( void ) { struct arm_stack_offsets * offsets ; unsigned long func_type ; int saved ; int core_saved ; HOST_WIDE_INT frame_size ; int i ; offsets = & cfun -> machine -> stack_offsets ; frame_size = ROUND_UP_WORD ( get_frame_size ( ) ) ; offsets -> saved_args = crtl -> args . pretend_args_size ; offsets -> frame = ( offsets -> saved_args + arm_compute_static_chain_stack_bytes ( ) + ( frame_pointer_needed ? <NUM_LIT> : <NUM_LIT> ) ) ; if ( TARGET_32BIT ) { unsigned int regno ; offsets -> saved_regs_mask = arm_compute_save_core_reg_mask ( ) ; core_saved = bit_count ( offsets -> saved_regs_mask ) * <NUM_LIT> ; saved = core_saved ; if ( TARGET_REALLY_IWMMXT ) { for ( regno = FIRST_IWMMXT_REGNUM ; regno <= LAST_IWMMXT_REGNUM ; regno ++ ) if ( df_regs_ever_live_p ( regno ) && ! call_used_regs [ regno ] ) saved += <NUM_LIT> ; } func_type = arm_current_func_type ( ) ; if ( ! IS_VOLATILE ( func_type ) && TARGET_HARD_FLOAT ) saved += arm_get_vfp_saved_size ( ) ; } else { offsets -> saved_regs_mask = thumb1_compute_save_core_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 ( crtl -> is_leaf && frame_size == <NUM_LIT> && ! cfun -> calls_alloca ) { offsets -> outgoing_args = offsets -> soft_frame ; offsets -> locals_base = offsets -> soft_frame ; return ; } 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 ; break ;


if ( cfun -> machine -> lr_save_eliminated ) save_reg_mask &= ~ ( <NUM_LIT> << LR_REGNUM ) ;


<s> for ( const struct cpu_arch_extension * opt = arch -> common . extensions ; opt -> name != NULL ; opt ++ ) { if ( ! opt -> remove ) { arm_initialize_isa ( opt_bits , opt -> isa_bits ) ; if ( bitmap_subset_p ( opt_bits , arm_active_target . isa ) && ! bitmap_subset_p ( opt_bits , isa_all_fpubits ) ) asm_fprintf ( asm_out_file , <STR_LIT> , opt -> name ) ; } } } arm_last_printed_arch_string = arch_to_print ; } fprintf ( stream , <STR_LIT> ) ; if ( TARGET_THUMB ) { if ( is_called_in_ARM_mode ( decl ) || ( TARGET_THUMB1 && ! TARGET_THUMB1_ONLY && cfun -> is_thunk ) ) fprintf ( stream , <STR_LIT> ) ; else if ( TARGET_THUMB1 ) fprintf ( stream , <STR_LIT> ) ; else fprintf ( stream , <STR_LIT> ) ; } else fprintf ( stream , <STR_LIT> ) ; std :: string fpu_to_print = TARGET_SOFT_FLOAT ? <STR_LIT> : arm_identify_fpu_from_isa ( arm_active_target . isa ) ; if ( fpu_to_print != arm_last_printed_arch_string ) { asm_fprintf ( asm_out_file , <STR_LIT> , fpu_to_print . c_str ( ) ) ; arm_last_printed_fpu_string = fpu_to_print ; } if ( TARGET_POKE_FUNCTION_NAME ) arm_poke_function_name ( stream , ( const char * ) name ) ;


<s> if ( d -> perm [ i ] != next ) return false ; } location = d -> perm [ <NUM_LIT> ] ; switch ( d -> vmode ) { case E_V16QImode : gen = gen_neon_vextv16qi ; break ; case E_V8QImode : gen = gen_neon_vextv8qi ; break ; case E_V4HImode : gen = gen_neon_vextv4hi ; break ; case E_V8HImode : gen = gen_neon_vextv8hi ; break ; case E_V2SImode : gen = gen_neon_vextv2si ; break ; case E_V4SImode : gen = gen_neon_vextv4si ; break ; case E_V4HFmode : gen = gen_neon_vextv4hf ; break ; case E_V8HFmode : gen = gen_neon_vextv8hf ; break ; case E_V2SFmode : gen = gen_neon_vextv2sf ; break ; case E_V4SFmode : gen = gen_neon_vextv4sf ; break ; case E_V2DImode : gen = gen_neon_vextv2di ; break ; default : return false ; } if ( d -> testing_p ) return true ; offset = GEN_INT ( location ) ;

emit_insn ( gen ( d -> target , d -> op0 , d -> op1 , offset ) ) ;


<s> default : return false ; } break ; case <NUM_LIT> : switch ( d -> vmode ) { case E_V16QImode : gen = gen_neon_vrev32v16qi ; break ; case E_V8QImode : gen = gen_neon_vrev32v8qi ; break ; case E_V8HImode : gen = gen_neon_vrev64v8hi ; break ; case E_V4HImode : gen = gen_neon_vrev64v4hi ; break ; case E_V8HFmode : gen = gen_neon_vrev64v8hf ; break ; case E_V4HFmode : gen = gen_neon_vrev64v4hf ; break ; default : return false ; } break ; case <NUM_LIT> : switch ( d -> vmode ) { case E_V16QImode : gen = gen_neon_vrev16v16qi ; break ; case E_V8QImode : gen = gen_neon_vrev16v8qi ; break ; case E_V8HImode : gen = gen_neon_vrev32v8hi ; break ; case E_V4HImode : gen = gen_neon_vrev32v4hi ; break ; case E_V4SImode : gen = gen_neon_vrev64v4si ; break ; case E_V2SImode : gen = gen_neon_vrev64v2si ; break ; case E_V4SFmode : gen = gen_neon_vrev64v4sf ; break ; case E_V2SFmode : gen = gen_neon_vrev64v2sf ; break ; default : return false ; } break ; default : return false ; } for ( i = <NUM_LIT> ; i < nelt ; i += diff + <NUM_LIT> ) for ( j = <NUM_LIT> ; j <= diff ; j += <NUM_LIT> ) { gcc_assert ( i + j < nelt ) ;

if ( d -> perm [ i + j ] != i + diff - j ) return false ;


<s> case E_V8QImode : gen = gen_neon_vrev16v8qi ; break ; case E_V8HImode : gen = gen_neon_vrev32v8hi ; break ; case E_V4HImode : gen = gen_neon_vrev32v4hi ; break ; case E_V4SImode : gen = gen_neon_vrev64v4si ; break ; case E_V2SImode : gen = gen_neon_vrev64v2si ; break ; case E_V4SFmode : gen = gen_neon_vrev64v4sf ; break ; case E_V2SFmode : gen = gen_neon_vrev64v2sf ; break ; default : return false ; } break ; default : return false ; } for ( i = <NUM_LIT> ; i < nelt ; i += diff + <NUM_LIT> ) for ( j = <NUM_LIT> ; j <= diff ; j += <NUM_LIT> ) {


<s> static bool arm_evpc_neon_vtrn ( struct expand_vec_perm_d * d ) { unsigned int i , odd , mask , nelt = d -> perm . length ( ) ; rtx out0 , out1 , in0 , in1 ; rtx ( * gen ) ( rtx , rtx , rtx , rtx ) ; if ( GET_MODE_UNIT_SIZE ( d -> vmode ) >= <NUM_LIT> ) return false ; if ( d -> perm [ <NUM_LIT> ] == <NUM_LIT> ) odd = <NUM_LIT> ; else if ( d -> perm [ <NUM_LIT> ] == <NUM_LIT> ) odd = <NUM_LIT> ; else return false ; 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 E_V16QImode : gen = gen_neon_vtrnv16qi_internal ; break ; case E_V8QImode : gen = gen_neon_vtrnv8qi_internal ; break ; case E_V8HImode : gen = gen_neon_vtrnv8hi_internal ; break ; case E_V4HImode : gen = gen_neon_vtrnv4hi_internal ; break ; case E_V8HFmode : gen = gen_neon_vtrnv8hf_internal ; break ;

case E_V4HFmode : gen = gen_neon_vtrnv4hf_internal ; break ;


<s> if ( GET_MODE_UNIT_SIZE ( d -> vmode ) >= <NUM_LIT> ) return false ; if ( d -> perm [ <NUM_LIT> ] == <NUM_LIT> ) odd = <NUM_LIT> ; else if ( d -> perm [ <NUM_LIT> ] == <NUM_LIT> ) odd = <NUM_LIT> ; else return false ; 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 E_V16QImode : gen = gen_neon_vtrnv16qi_internal ; break ; case E_V8QImode : gen = gen_neon_vtrnv8qi_internal ; break ; case E_V8HImode : gen = gen_neon_vtrnv8hi_internal ; break ; case E_V4HImode : gen = gen_neon_vtrnv4hi_internal ; break ; case E_V8HFmode : gen = gen_neon_vtrnv8hf_internal ; break ; case E_V4HFmode : gen = gen_neon_vtrnv4hf_internal ; break ; case E_V4SImode : gen = gen_neon_vtrnv4si_internal ; break ; case E_V2SImode : gen = gen_neon_vtrnv2si_internal ; break ; case E_V2SFmode : gen = gen_neon_vtrnv2sf_internal ; break ; case E_V4SFmode : gen = gen_neon_vtrnv4sf_internal ; break ; default : gcc_unreachable ( ) ; } in0 = d -> op0 ;


<s> unsigned int i , high , mask , nelt = d -> perm . length ( ) ; rtx out0 , out1 , in0 , in1 ; rtx ( * gen ) ( rtx , rtx , rtx , rtx ) ; int first_elem ; bool is_swapped ; if ( GET_MODE_UNIT_SIZE ( d -> vmode ) >= <NUM_LIT> ) return false ; is_swapped = BYTES_BIG_ENDIAN ; first_elem = d -> perm [ neon_endian_lane_map ( d -> vmode , <NUM_LIT> ) ^ is_swapped ] ; high = nelt / <NUM_LIT> ; if ( first_elem == neon_endian_lane_map ( d -> vmode , high ) ) ; else if ( first_elem == neon_endian_lane_map ( d -> vmode , <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 = neon_pair_endian_lane_map ( d -> vmode , i + high ) & mask ; if ( d -> perm [ neon_pair_endian_lane_map ( d -> vmode , <NUM_LIT> * i + is_swapped ) ] != elt ) return false ; elt = neon_pair_endian_lane_map ( d -> vmode , i + nelt + high ) & mask ; if ( d -> perm [ neon_pair_endian_lane_map ( d -> vmode , <NUM_LIT> * i + ! is_swapped ) ] != elt ) return false ; } if ( d -> testing_p ) return true ; switch ( d -> vmode ) {

case E_V16QImode : gen = gen_neon_vzipv16qi_internal ; break ;


<s> mod_s = operands [ <NUM_LIT> ] ; mod_f = operands [ <NUM_LIT> ] ; mode = GET_MODE ( mem ) ; if ( TARGET_HAVE_LDACQ && is_mm_acquire ( memmodel_from_int ( INTVAL ( mod_f ) ) ) && is_mm_release ( memmodel_from_int ( INTVAL ( mod_s ) ) ) ) mod_s = GEN_INT ( MEMMODEL_ACQ_REL ) ; switch ( mode ) { case E_QImode : case E_HImode : rval = gen_reg_rtx ( SImode ) ; oldval = convert_modes ( SImode , mode , oldval , true ) ; case E_SImode : if ( ! arm_add_operand ( oldval , SImode ) ) oldval = force_reg ( SImode , oldval ) ; break ; case E_DImode : if ( ! cmpdi_operand ( oldval , mode ) ) oldval = force_reg ( mode , oldval ) ; break ; default : gcc_unreachable ( ) ; } if ( TARGET_THUMB1 ) { switch ( mode ) { case E_QImode : gen = gen_atomic_compare_and_swapt1qi_1 ; break ; case E_HImode : gen = gen_atomic_compare_and_swapt1hi_1 ; break ; case E_SImode : gen = gen_atomic_compare_and_swapt1si_1 ; break ; case E_DImode : gen = gen_atomic_compare_and_swapt1di_1 ; break ; default : gcc_unreachable ( ) ; } } else { switch ( mode ) { case E_QImode : gen = gen_atomic_compare_and_swap32qi_1 ; break ; case E_HImode : gen = gen_atomic_compare_and_swap32hi_1 ; break ; case E_SImode : gen = gen_atomic_compare_and_swap32si_1 ; break ; case E_DImode : gen = gen_atomic_compare_and_swap32di_1 ; break ; default : gcc_unreachable ( ) ; } } bdst = TARGET_THUMB1 ? bval : gen_rtx_REG ( CC_Zmode , CC_REGNUM ) ; emit_insn ( gen ( bdst , 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 ) ) ; if ( TARGET_THUMB1 ) emit_insn ( gen_cstoresi_eq0_thumb1 ( bval , bdst ) ) ; else {

x = gen_rtx_EQ ( SImode , bdst , const0_rtx ) ;


if ( arm_lang_output_object_attributes_hook ) arm_lang_output_object_attributes_hook ( ) ;


<s> if ( ! TARGET_32BIT ) return false ; * p1 = CC_REGNUM ;


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


<s> auto_sbitmap cand_fpubits ( isa_num_bits ) ; bitmap_and ( fpubits , isa , isa_all_fpubits ) ; if ( bitmap_empty_p ( fpubits ) ) return <STR_LIT> ; for ( unsigned int i = <NUM_LIT> ; i < TARGET_FPU_auto ; i ++ ) {

arm_initialize_isa ( cand_fpubits , all_fpus [ i ] . isa_bits ) ;


<s> for ( unsigned int i = <NUM_LIT> ; i < TARGET_FPU_auto ; i ++ ) {


if ( GET_MODE_CLASS ( mode1 ) == GET_MODE_CLASS ( mode2 ) ) return true ;


<s> if ( TARGET_IWMMXT_ABI && ! TARGET_IWMMXT ) error ( <STR_LIT> ) ; if ( TARGET_INTERWORK && ! TARGET_BPABI && ! bitmap_bit_p ( arm_active_target . isa , isa_bit_thumb ) ) { warning ( <NUM_LIT> , <STR_LIT> ) ; target_flags &= ~ MASK_INTERWORK ; } if ( TARGET_SOFT_FLOAT ) arm_fpu_attr = FPU_NONE ; else arm_fpu_attr = FPU_VFP ; if ( TARGET_AAPCS_BASED ) { if ( TARGET_CALLER_INTERWORKING ) error ( <STR_LIT> ) ; else if ( TARGET_CALLEE_INTERWORKING ) error ( <STR_LIT> ) ; } if ( ! arm_arch4 && arm_fp16_format != ARM_FP16_FORMAT_NONE ) sorry ( <STR_LIT> ) ; if ( use_cmse && ! arm_arch_cmse ) error ( <STR_LIT> ) ; if ( use_cmse && LAST_VFP_REGNUM > LAST_LO_VFP_REGNUM ) error ( <STR_LIT> ) ;


<s> if ( TARGET_ARM_P ( flags ) && TARGET_CALLEE_INTERWORKING ) warning ( <NUM_LIT> , <STR_LIT> ) ; if ( TARGET_ARM_P ( flags ) && write_symbols != NO_DEBUG && ! TARGET_APCS_FRAME && ( TARGET_DEFAULT & MASK_APCS_FRAME ) ) warning ( <NUM_LIT> , <STR_LIT> ) ; if ( TARGET_THUMB_P ( flags ) && TARGET_IWMMXT ) error ( <STR_LIT> ) ; if ( TARGET_HARD_TP && TARGET_THUMB1_P ( flags ) ) error ( <STR_LIT> ) ; if ( TARGET_THUMB_P ( flags ) && TARGET_VXWORKS_RTP && flag_pic ) { error ( <STR_LIT> ) ; flag_pic = <NUM_LIT> ; }

if ( ( target_pure_code || target_slow_flash_data ) && ( ! TARGET_HAVE_MOVT || arm_arch_notm || flag_pic || TARGET_NEON ) ) {


<s> targetm . min_anchor_offset = <NUM_LIT> ; targetm . max_anchor_offset = <NUM_LIT> ; } else if ( TARGET_THUMB2 ) { targetm . min_anchor_offset = - <NUM_LIT> ; targetm . max_anchor_offset = <NUM_LIT> ;


<s> auto_sbitmap opt_bits ( isa_num_bits ) ; gcc_assert ( arch ) ; asm_fprintf ( asm_out_file , <STR_LIT> , arm_active_target . arch_name ) ; arm_last_printed_arch_string = arm_active_target . arch_name ; if ( ! arch -> common . extensions ) return ; for ( const struct cpu_arch_extension * opt = arch -> common . extensions ; opt -> name != NULL ; opt ++ ) { if ( ! opt -> remove ) { arm_initialize_isa ( opt_bits , opt -> isa_bits ) ; if ( bitmap_subset_p ( opt_bits , arm_active_target . isa ) && ! bitmap_subset_p ( opt_bits , isa_all_fpubits ) ) asm_fprintf ( asm_out_file , <STR_LIT> , opt -> name ) ;


<s> asm_fprintf ( asm_out_file , <STR_LIT> , arm_active_target . arch_name ) ; arm_last_printed_arch_string = arm_active_target . arch_name ; if ( ! arch -> common . extensions ) return ; for ( const struct cpu_arch_extension * opt = arch -> common . extensions ;