<s> } func_type = arm_current_func_type ( ) ; if ( ! IS_VOLATILE ( func_type ) && TARGET_VFP_BASE ) saved += arm_get_vfp_saved_size ( ) ; if ( TARGET_HAVE_FPCXT_CMSE && IS_CMSE_ENTRY ( func_type ) ) saved += <NUM_LIT> ; } 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 ;


<s> if ( a == NULL_TREE ) a = lookup_attribute ( <STR_LIT> , attr ) ; if ( a == NULL_TREE ) type |= TARGET_INTERWORK ? ARM_FT_INTERWORKED : ARM_FT_NORMAL ; else type |= arm_isr_value ( TREE_VALUE ( a ) ) ; if ( lookup_attribute ( <STR_LIT> , attr ) ) type |= ARM_FT_CMSE_ENTRY ;


<s> default : gcc_unreachable ( ) ; } gcc_unreachable ( ) ; case FRAME_POINTER_REGNUM : switch ( to ) { case THUMB_HARD_FRAME_POINTER_REGNUM : return <NUM_LIT> ; case ARM_HARD_FRAME_POINTER_REGNUM : return offsets -> frame - offsets -> soft_frame ; case STACK_POINTER_REGNUM : return offsets -> outgoing_args - offsets -> soft_frame ; default : gcc_unreachable ( ) ;


<s> case THUMB_HARD_FRAME_POINTER_REGNUM : return <NUM_LIT> ; case FRAME_POINTER_REGNUM : return offsets -> soft_frame - offsets -> saved_args ; case ARM_HARD_FRAME_POINTER_REGNUM : return offsets -> frame - offsets -> saved_args - <NUM_LIT> ; case STACK_POINTER_REGNUM : return offsets -> outgoing_args - ( offsets -> saved_args + <NUM_LIT> ) ;


<s> if ( TARGET_APCS_FRAME && frame_pointer_needed && TARGET_ARM ) save_reg_mask |= ( <NUM_LIT> << ARM_HARD_FRAME_POINTER_REGNUM ) | ( <NUM_LIT> << IP_REGNUM ) | ( <NUM_LIT> << LR_REGNUM ) | ( <NUM_LIT> << PC_REGNUM ) ; save_reg_mask |= arm_compute_save_reg0_reg12_mask ( ) ; if ( df_regs_ever_live_p ( LR_REGNUM ) || ( save_reg_mask && optimize_size && ARM_FUNC_TYPE ( func_type ) == ARM_FT_NORMAL && ! crtl -> tail_call_emit && ! crtl -> calls_eh_return ) ) save_reg_mask |= <NUM_LIT> << LR_REGNUM ; if ( cfun -> machine -> lr_save_eliminated ) save_reg_mask &= ~ ( <NUM_LIT> << LR_REGNUM ) ; if ( TARGET_REALLY_IWMMXT && ( ( bit_count ( save_reg_mask ) + ARM_NUM_INTS ( crtl -> args . pretend_args_size + arm_compute_static_chain_stack_bytes ( ) ) ) % <NUM_LIT> ) != <NUM_LIT> ) { for ( reg = <NUM_LIT> ; reg <= <NUM_LIT> ; reg ++ ) if ( ( save_reg_mask & ( <NUM_LIT> << reg ) ) == <NUM_LIT> ) break ; if ( reg <= <NUM_LIT> ) save_reg_mask |= ( <NUM_LIT> << reg ) ; else { cfun -> machine -> sibcall_blocked = <NUM_LIT> ;


<s> unsigned long save_reg_mask = <NUM_LIT> ; unsigned int reg ; if ( IS_INTERRUPT ( func_type ) ) { unsigned int max_reg ; if ( ARM_FUNC_TYPE ( func_type ) == ARM_FT_FIQ ) max_reg = <NUM_LIT> ; else max_reg = <NUM_LIT> ; for ( reg = <NUM_LIT> ; reg <= max_reg ; reg ++ ) if ( reg_needs_saving_p ( reg ) ) save_reg_mask |= ( <NUM_LIT> << reg ) ; if ( PIC_REGISTER_MAY_NEED_SAVING && crtl -> uses_pic_offset_table ) save_reg_mask |= <NUM_LIT> << PIC_OFFSET_TABLE_REGNUM ; } else if ( IS_VOLATILE ( func_type ) ) { if ( frame_pointer_needed ) save_reg_mask |= <NUM_LIT> << HARD_FRAME_POINTER_REGNUM ; if ( df_regs_ever_live_p ( ARM_HARD_FRAME_POINTER_REGNUM ) ) save_reg_mask |= <NUM_LIT> << ARM_HARD_FRAME_POINTER_REGNUM ; if ( df_regs_ever_live_p ( THUMB_HARD_FRAME_POINTER_REGNUM ) ) save_reg_mask |= <NUM_LIT> << THUMB_HARD_FRAME_POINTER_REGNUM ; } else { for ( reg = <NUM_LIT> ; reg <= <NUM_LIT> ; reg ++ ) if ( df_regs_ever_live_p ( reg ) && callee_saved_reg_p ( reg ) ) save_reg_mask |= ( <NUM_LIT> << reg ) ; if ( frame_pointer_needed ) save_reg_mask |= <NUM_LIT> << HARD_FRAME_POINTER_REGNUM ; if ( PIC_REGISTER_MAY_NEED_SAVING && ( df_regs_ever_live_p ( PIC_OFFSET_TABLE_REGNUM ) || crtl -> uses_pic_offset_table ) ) save_reg_mask |= <NUM_LIT> << PIC_OFFSET_TABLE_REGNUM ; if ( IS_STACKALIGN ( func_type ) ) save_reg_mask |= <NUM_LIT> ; } if ( crtl -> calls_eh_return ) { unsigned int i ; for ( i = <NUM_LIT> ; ; i ++ ) { reg = EH_RETURN_DATA_REGNO ( i ) ; if ( reg == INVALID_REGNUM ) break ; save_reg_mask |= <NUM_LIT> << reg ;


<s> if ( frame_pointer_needed ) save_reg_mask |= <NUM_LIT> << HARD_FRAME_POINTER_REGNUM ; if ( df_regs_ever_live_p ( ARM_HARD_FRAME_POINTER_REGNUM ) ) save_reg_mask |= <NUM_LIT> << ARM_HARD_FRAME_POINTER_REGNUM ; if ( df_regs_ever_live_p ( THUMB_HARD_FRAME_POINTER_REGNUM ) ) save_reg_mask |= <NUM_LIT> << THUMB_HARD_FRAME_POINTER_REGNUM ; } else { for ( reg = <NUM_LIT> ; reg <= <NUM_LIT> ; reg ++ ) if ( df_regs_ever_live_p ( reg ) && callee_saved_reg_p ( reg ) ) save_reg_mask |= ( <NUM_LIT> << reg ) ; if ( frame_pointer_needed ) save_reg_mask |= <NUM_LIT> << HARD_FRAME_POINTER_REGNUM ; if ( PIC_REGISTER_MAY_NEED_SAVING && ( df_regs_ever_live_p ( PIC_OFFSET_TABLE_REGNUM ) || crtl -> uses_pic_offset_table ) ) save_reg_mask |= <NUM_LIT> << PIC_OFFSET_TABLE_REGNUM ; if ( IS_STACKALIGN ( func_type ) ) save_reg_mask |= <NUM_LIT> ; } if ( crtl -> calls_eh_return ) { unsigned int i ; for ( i = <NUM_LIT> ; ; i ++ ) { reg = EH_RETURN_DATA_REGNO ( i ) ; if ( reg == INVALID_REGNUM ) break ; save_reg_mask |= <NUM_LIT> << reg ; }


<s> if ( cfun -> machine -> static_chain_stack_bytes != - <NUM_LIT> ) return cfun -> machine -> static_chain_stack_bytes ; if ( IS_NESTED ( arm_current_func_type ( ) ) && ( ( TARGET_APCS_FRAME && frame_pointer_needed && TARGET_ARM ) || ( ( flag_stack_check == STATIC_BUILTIN_STACK_CHECK || flag_stack_clash_protection ) && ! df_regs_ever_live_p ( LR_REGNUM ) ) ) && arm_r3_live_at_start_p ( ) && crtl -> args . pretend_args_size == <NUM_LIT> ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> for ( regno = FIRST_IWMMXT_REGNUM ; regno <= LAST_IWMMXT_REGNUM ; ++ regno ) { fixed_regs [ regno ] = <NUM_LIT> ; call_used_regs [ regno ] = regno < FIRST_IWMMXT_REGNUM + <NUM_LIT> ; } } if ( ( unsigned ) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM ) { fixed_regs [ PIC_OFFSET_TABLE_REGNUM ] = <NUM_LIT> ; call_used_regs [ PIC_OFFSET_TABLE_REGNUM ] = <NUM_LIT> ; } else if ( TARGET_APCS_STACK ) { fixed_regs [ <NUM_LIT> ] = <NUM_LIT> ; call_used_regs [ <NUM_LIT> ] = <NUM_LIT> ; }


<s> } if ( opts -> x_arm_tune_string ) { arm_selected_tune = arm_parse_cpu_option_name ( all_cores , <STR_LIT> , opts -> x_arm_tune_string ) ; tune_opts = strchr ( opts -> x_arm_tune_string , '+' ) ; } if ( arm_selected_arch ) { arm_initialize_isa ( target -> isa , arm_selected_arch -> common . isa_bits ) ; arm_parse_option_features ( target -> isa , & arm_selected_arch -> common , arch_opts ) ; if ( arm_selected_cpu ) { auto_sbitmap cpu_isa ( isa_num_bits ) ; auto_sbitmap isa_delta ( isa_num_bits ) ; arm_initialize_isa ( cpu_isa , arm_selected_cpu -> common . isa_bits ) ; arm_parse_option_features ( cpu_isa , & arm_selected_cpu -> common , cpu_opts ) ; bitmap_xor ( isa_delta , cpu_isa , target -> isa ) ; bitmap_and_compl ( isa_delta , isa_delta , isa_quirkbits ) ; if ( opts -> x_arm_fpu_index != TARGET_FPU_auto || arm_float_abi == ARM_FLOAT_ABI_SOFT ) bitmap_and_compl ( isa_delta , isa_delta , isa_all_fpbits ) ; if ( ! bitmap_empty_p ( isa_delta ) ) { if ( warn_compatible ) warning ( <NUM_LIT> , <STR_LIT> <STR_LIT> , opts -> x_arm_cpu_string , opts -> x_arm_arch_string ) ; if ( ! arm_selected_tune ) arm_selected_tune = arm_selected_cpu ; arm_selected_cpu = all_cores + arm_selected_arch -> tune_id ; target -> arch_name = arm_selected_arch -> common . name ; } else { arm_selected_arch = all_architectures + arm_selected_cpu -> arch ; target -> core_name = arm_selected_cpu -> common . name ; bitmap_copy ( target -> isa , cpu_isa ) ; } } else { arm_selected_cpu = all_cores + arm_selected_arch -> tune_id ; target -> arch_name = arm_selected_arch -> common . name ; } } else if ( arm_selected_cpu ) { target -> core_name = arm_selected_cpu -> common . name ; arm_initialize_isa ( target -> isa , arm_selected_cpu -> common . isa_bits ) ; arm_parse_option_features ( target -> isa , & arm_selected_cpu -> common , cpu_opts ) ; arm_selected_arch = all_architectures + arm_selected_cpu -> arch ; } else { const cpu_option * sel ; auto_sbitmap sought_isa ( isa_num_bits ) ; bitmap_clear ( sought_isa ) ;


<s> unsigned int factor = ( TARGET_THUMB || ! arm_tune_xscale ? <NUM_LIT> : <NUM_LIT> ) ; if ( TREE_CODE ( exp ) == STRING_CST && ! optimize_size ) return MAX ( align , BITS_PER_WORD * factor ) ;


<s> static HOST_WIDE_INT arm_constant_alignment ( const_tree exp , HOST_WIDE_INT align ) { unsigned int factor = ( TARGET_THUMB || ! arm_tune_xscale ? <NUM_LIT> : <NUM_LIT> ) ; if ( TREE_CODE ( exp ) == STRING_CST && ! optimize_size ) return MAX ( align , BITS_PER_WORD * factor ) ;


<s> void arm_const_bounds ( rtx operand , HOST_WIDE_INT low , HOST_WIDE_INT high ) {

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


<s> void arm_const_bounds ( rtx operand , HOST_WIDE_INT low , HOST_WIDE_INT high ) { bounds_check ( operand , low , high , NULL_TREE , <STR_LIT> ) ;


<s> part = gen_lowpart ( SImode , val ) ; gcc_assert ( CONST_INT_P ( part ) ) ; if ( ! const_ok_for_arm ( INTVAL ( part ) ) ) return false ;


<s> if ( optimize_size || arm_ld_sched ) return true ; if ( mode == VOIDmode ) mode = DImode ; part = gen_highpart_mode ( SImode , mode , val ) ; gcc_assert ( CONST_INT_P ( part ) ) ; if ( const_ok_for_arm ( INTVAL ( part ) ) || const_ok_for_arm ( ~ INTVAL ( part ) ) ) return true ; part = gen_lowpart ( SImode , val ) ;


<s> if ( mode == VOIDmode ) mode = DImode ; gcc_assert ( GET_MODE_SIZE ( mode ) == <NUM_LIT> ) ; lowpart = gen_lowpart ( SImode , val ) ; highpart = gen_highpart_mode ( SImode , mode , val ) ; gcc_assert ( CONST_INT_P ( lowpart ) ) ;

gcc_assert ( CONST_INT_P ( highpart ) ) ;


<s> lo = UINTVAL ( op ) & <NUM_LIT> ; hi = UINTVAL ( op ) >> <NUM_LIT> ;

return const_ok_for_arm ( lo ) && const_ok_for_arm ( hi ) ;


<s> if ( ! fp_consts_inited ) init_fp_table ( ) ; r = CONST_DOUBLE_REAL_VALUE ( x ) ; if ( REAL_VALUE_MINUS_ZERO ( * r ) ) return <NUM_LIT> ; if ( real_equal ( r , & value_fp0 ) ) return <NUM_LIT> ;


<s> r = CONST_DOUBLE_REAL_VALUE ( x ) ; if ( REAL_VALUE_MINUS_ZERO ( * r ) ) return <NUM_LIT> ;

if ( real_equal ( r , & value_fp0 ) ) return <NUM_LIT> ;


<s> if ( GET_CODE ( XEXP ( p , <NUM_LIT> ) ) == SYMBOL_REF ) { decl_op1 = SYMBOL_REF_DECL ( XEXP ( p , <NUM_LIT> ) ) ; if ( decl_op1 && GET_CODE ( XEXP ( p , <NUM_LIT> ) ) == SYMBOL_REF && ( decl_op0 = SYMBOL_REF_DECL ( XEXP ( p , <NUM_LIT> ) ) ) ) { if ( ( VAR_P ( decl_op1 ) || TREE_CODE ( decl_op1 ) == CONST_DECL ) && ( VAR_P ( decl_op0 ) || TREE_CODE ( decl_op0 ) == CONST_DECL ) ) return ( get_variable_section ( decl_op1 , false ) != get_variable_section ( decl_op0 , false ) ) ; if ( TREE_CODE ( decl_op1 ) == LABEL_DECL && TREE_CODE ( decl_op0 ) == LABEL_DECL ) return ( DECL_CONTEXT ( decl_op1 ) != DECL_CONTEXT ( decl_op0 ) ) ; } return true ; } } return false ;


<s> static bool arm_cookie_has_size ( void ) {


<s> bool arm_coproc_builtin_available ( enum unspecv builtin ) { if ( TARGET_THUMB1 ) return false ; switch ( builtin ) { case VUNSPEC_CDP : 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 :


<s> 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_arch5t ) return true ; break ; case VUNSPEC_MCRR : case VUNSPEC_MRRC : if ( arm_arch6 || arm_arch5te ) return true ; break ;


<s> op = XEXP ( op , <NUM_LIT> ) ; if ( REG_P ( op ) ) return true ; switch GET_CODE ( op ) { case PLUS : { if ( ! REG_P ( XEXP ( op , <NUM_LIT> ) ) ) return false ; op = XEXP ( op , <NUM_LIT> ) ; if ( ! CONST_INT_P ( op ) ) return false ; range = INTVAL ( op ) ; if ( ! IN_RANGE ( range , - <NUM_LIT> , <NUM_LIT> ) ) return false ; return ( range % <NUM_LIT> ) == <NUM_LIT> ; } case PRE_INC :


<s> if ( ! MEM_P ( op ) ) return false ; op = XEXP ( op , <NUM_LIT> ) ; if ( REG_P ( op ) ) return true ; switch GET_CODE ( op ) { case PLUS : { if ( ! REG_P ( XEXP ( op , <NUM_LIT> ) ) ) return false ; op = XEXP ( op , <NUM_LIT> ) ; if ( ! CONST_INT_P ( op ) ) return false ; range = INTVAL ( op ) ; if ( ! IN_RANGE ( range , - <NUM_LIT> , <NUM_LIT> ) ) return false ; return ( range % <NUM_LIT> ) == <NUM_LIT> ; } case PRE_INC : case POST_INC : case PRE_DEC : case POST_DEC : return REG_P ( XEXP ( op , <NUM_LIT> ) ) ;


<s> return arm_coproc_mem_operand_wb ( op , wb ? <NUM_LIT> : <NUM_LIT> ) ;


<s> if ( ! MEM_P ( op ) ) return FALSE ; ind = XEXP ( op , <NUM_LIT> ) ; if ( reload_completed && ( LABEL_REF_P ( ind ) || ( GET_CODE ( ind ) == CONST && GET_CODE ( XEXP ( ind , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( ind , <NUM_LIT> ) , <NUM_LIT> ) ) == LABEL_REF && CONST_INT_P ( XEXP ( XEXP ( ind , <NUM_LIT> ) , <NUM_LIT> ) ) ) ) ) return TRUE ; if ( REG_P ( ind ) ) return arm_address_register_rtx_p ( ind , <NUM_LIT> ) ; if ( wb_level > <NUM_LIT> && ( GET_CODE ( ind ) == POST_INC || GET_CODE ( ind ) == PRE_DEC || ( wb_level > <NUM_LIT> && ( GET_CODE ( ind ) == PRE_INC || GET_CODE ( ind ) == POST_DEC ) ) ) ) return arm_address_register_rtx_p ( XEXP ( ind , <NUM_LIT> ) , <NUM_LIT> ) ; if ( wb_level > <NUM_LIT> && ( GET_CODE ( ind ) == POST_MODIFY || GET_CODE ( ind ) == PRE_MODIFY ) && arm_address_register_rtx_p ( XEXP ( ind , <NUM_LIT> ) , <NUM_LIT> ) && GET_CODE ( XEXP ( ind , <NUM_LIT> ) ) == PLUS && rtx_equal_p ( XEXP ( XEXP ( ind , <NUM_LIT> ) , <NUM_LIT> ) , XEXP ( ind , <NUM_LIT> ) ) ) ind = XEXP ( ind , <NUM_LIT> ) ; int factor = MIN ( GET_MODE_SIZE ( GET_MODE ( op ) ) , <NUM_LIT> ) ;

if ( GET_CODE ( ind ) == PLUS && REG_P ( XEXP ( ind , <NUM_LIT> ) ) && REG_MODE_OK_FOR_BASE_P ( XEXP ( ind , <NUM_LIT> ) , VOIDmode ) && CONST_INT_P ( XEXP ( ind , <NUM_LIT> ) ) && IN_RANGE ( INTVAL ( XEXP ( ind , <NUM_LIT> ) ) , - <NUM_LIT> * factor , <NUM_LIT> * factor ) && ( INTVAL ( XEXP ( ind , <NUM_LIT> ) ) & ( factor - <NUM_LIT> ) ) == <NUM_LIT> ) return TRUE ;


<s> ind = XEXP ( op , <NUM_LIT> ) ; if ( reload_completed && ( LABEL_REF_P ( ind ) || ( GET_CODE ( ind ) == CONST && GET_CODE ( XEXP ( ind , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( ind , <NUM_LIT> ) , <NUM_LIT> ) ) == LABEL_REF && CONST_INT_P ( XEXP ( XEXP ( ind , <NUM_LIT> ) , <NUM_LIT> ) ) ) ) ) return TRUE ; if ( REG_P ( ind ) ) return arm_address_register_rtx_p ( ind , <NUM_LIT> ) ; if ( wb_level > <NUM_LIT> && ( GET_CODE ( ind ) == POST_INC || GET_CODE ( ind ) == PRE_DEC || ( wb_level > <NUM_LIT> && ( GET_CODE ( ind ) == PRE_INC || GET_CODE ( ind ) == POST_DEC ) ) ) ) return arm_address_register_rtx_p ( XEXP ( ind , <NUM_LIT> ) , <NUM_LIT> ) ; if ( wb_level > <NUM_LIT> && ( GET_CODE ( ind ) == POST_MODIFY || GET_CODE ( ind ) == PRE_MODIFY ) && arm_address_register_rtx_p ( XEXP ( ind , <NUM_LIT> ) , <NUM_LIT> ) && GET_CODE ( XEXP ( ind , <NUM_LIT> ) ) == PLUS && rtx_equal_p ( XEXP ( XEXP ( ind , <NUM_LIT> ) , <NUM_LIT> ) , XEXP ( ind , <NUM_LIT> ) ) ) ind = XEXP ( ind , <NUM_LIT> ) ; int factor = MIN ( GET_MODE_SIZE ( GET_MODE ( op ) ) , <NUM_LIT> ) ; if ( GET_CODE ( ind ) == PLUS && REG_P ( XEXP ( ind , <NUM_LIT> ) ) && REG_MODE_OK_FOR_BASE_P ( XEXP ( ind , <NUM_LIT> ) , VOIDmode ) && CONST_INT_P ( XEXP ( ind , <NUM_LIT> ) ) && IN_RANGE ( INTVAL ( XEXP ( ind , <NUM_LIT> ) ) , - <NUM_LIT> * factor , <NUM_LIT> * factor ) && ( INTVAL ( XEXP ( ind , <NUM_LIT> ) ) & ( factor - <NUM_LIT> ) ) == <NUM_LIT> ) return TRUE ; return FALSE ;


<s> static int arm_cortex_m7_branch_cost ( bool speed_p , bool predictable_p ) {


<s> rtx ops [ <NUM_LIT> ] ; int regnum , memnum ; if ( load ) regnum = <NUM_LIT> , memnum = <NUM_LIT> ; else regnum = <NUM_LIT> , memnum = <NUM_LIT> ; ops [ regnum ] = gen_rtx_REG ( DImode , REGNO ( operands [ <NUM_LIT> ] ) ) ; ops [ memnum ] = adjust_address ( operands [ <NUM_LIT> ] , DImode , <NUM_LIT> ) ; output_move_double ( ops , false , & count ) ; return count ;


<s> ops [ memnum ] = adjust_address ( operands [ <NUM_LIT> ] , DImode , <NUM_LIT> ) ; output_move_double ( ops , false , & count ) ;


<s> ops [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; ops [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; output_move_double ( ops , false , & count ) ;


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


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

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


<s> if ( ARM_FUNC_TYPE ( cfun -> machine -> func_type ) == ARM_FT_UNKNOWN ) cfun -> machine -> func_type = arm_compute_func_type ( ) ;


<s> static bool arm_cxx_class_data_always_comdat ( void ) { return ! TARGET_AAPCS_BASED ;


<s> static bool arm_cxx_guard_mask_bit ( void ) {


<s> static tree arm_cxx_guard_type ( void ) { return TARGET_AAPCS_BASED ? integer_type_node : long_long_integer_type_node ;


<s> } if ( IS_IWMMXT_GR_REGNUM ( regno ) ) return <NUM_LIT> + regno - FIRST_IWMMXT_GR_REGNUM ; if ( IS_IWMMXT_REGNUM ( regno ) ) return <NUM_LIT> + regno - FIRST_IWMMXT_REGNUM ; return DWARF_FRAME_REGISTERS ;


<s> if ( regno < <NUM_LIT> ) return regno ; if ( IS_VFP_REGNUM ( regno ) ) { if ( VFP_REGNO_OK_FOR_SINGLE ( regno ) ) return <NUM_LIT> + regno - FIRST_VFP_REGNUM ; else return <NUM_LIT> + ( regno - FIRST_VFP_REGNUM ) / <NUM_LIT> ; }

if ( IS_IWMMXT_GR_REGNUM ( regno ) ) return <NUM_LIT> + regno - FIRST_IWMMXT_GR_REGNUM ;


<s> if ( value != <NUM_LIT> ) return <NUM_LIT> ; if ( ! REG_P ( addr ) ) return <NUM_LIT> ; if ( REGNO ( addr ) == ( unsigned ) HARD_FRAME_POINTER_REGNUM ) return <NUM_LIT> ; if ( ( TARGET_THUMB || ! frame_pointer_needed ) && REGNO ( addr ) == SP_REGNUM ) return <NUM_LIT> ; for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) { if ( NONJUMP_INSN_P ( insn ) && GET_CODE ( PATTERN ( insn ) ) == SET && REGNO ( XEXP ( PATTERN ( insn ) , <NUM_LIT> ) ) == REGNO ( addr ) && GET_CODE ( XEXP ( PATTERN ( insn ) , <NUM_LIT> ) ) == PLUS && REG_P ( XEXP ( XEXP ( PATTERN ( insn ) , <NUM_LIT> ) , <NUM_LIT> ) ) && REGNO ( XEXP ( XEXP ( PATTERN ( insn ) , <NUM_LIT> ) , <NUM_LIT> ) ) == ( unsigned ) HARD_FRAME_POINTER_REGNUM && CONST_INT_P ( XEXP ( XEXP ( PATTERN ( insn ) , <NUM_LIT> ) , <NUM_LIT> ) ) ) { value = INTVAL ( XEXP ( XEXP ( PATTERN ( insn ) , <NUM_LIT> ) , <NUM_LIT> ) ) ; break ; } }


<s> if ( ! REG_P ( addr ) ) return <NUM_LIT> ; if ( REGNO ( addr ) == ( unsigned ) HARD_FRAME_POINTER_REGNUM ) return <NUM_LIT> ; if ( ( TARGET_THUMB || ! frame_pointer_needed ) && REGNO ( addr ) == SP_REGNUM ) return <NUM_LIT> ; for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) { if ( NONJUMP_INSN_P ( insn ) && GET_CODE ( PATTERN ( insn ) ) == SET && REGNO ( XEXP ( PATTERN ( insn ) , <NUM_LIT> ) ) == REGNO ( addr ) && GET_CODE ( XEXP ( PATTERN ( insn ) , <NUM_LIT> ) ) == PLUS && REG_P ( XEXP ( XEXP ( PATTERN ( insn ) , <NUM_LIT> ) , <NUM_LIT> ) ) && REGNO ( XEXP ( XEXP ( PATTERN ( insn ) , <NUM_LIT> ) , <NUM_LIT> ) ) == ( unsigned ) HARD_FRAME_POINTER_REGNUM && CONST_INT_P ( XEXP ( XEXP ( PATTERN ( insn ) , <NUM_LIT> ) , <NUM_LIT> ) ) ) { value = INTVAL ( XEXP ( XEXP ( PATTERN ( insn ) , <NUM_LIT> ) , <NUM_LIT> ) ) ; break ; } } if ( value == <NUM_LIT> ) { debug_rtx ( addr ) ; warning ( <NUM_LIT> , <STR_LIT> ) ; value = <NUM_LIT> ; }


<s> if ( target_parts ) targ_options = TREE_TARGET_OPTION ( target_parts ) ; else targ_options = TREE_TARGET_OPTION ( target_option_current_node ) ; gcc_assert ( targ_options ) ; arm_print_asm_arch_directives ( stream , targ_options ) ; 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> ) ; }


<s> arm_print_asm_arch_directives ( stream , targ_options ) ; 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> ) ; }


<s> * hi_op1 = gen_highpart ( SImode , op1 ) ;

* lo_op2 = simplify_gen_subreg ( SImode , op2 , DImode , subreg_lowpart_offset ( SImode , DImode ) ) ;


<s> if ( TARGET_32BIT ) return ( TARGET_THUMB2 && ! speed_p ) ? <NUM_LIT> : <NUM_LIT> ;

else return ( optimize > <NUM_LIT> ) ? <NUM_LIT> : <NUM_LIT> ;


<s> static int arm_default_branch_cost ( bool speed_p , bool predictable_p ATTRIBUTE_UNUSED ) {

if ( TARGET_32BIT ) return ( TARGET_THUMB2 && ! speed_p ) ? <NUM_LIT> : <NUM_LIT> ;


<s> if ( GET_MODE_SIZE ( mode ) < <NUM_LIT> ) return NULL_RTX ; if ( VFP_REGNO_OK_FOR_SINGLE ( regno ) ) { nregs = GET_MODE_SIZE ( mode ) / <NUM_LIT> ; for ( i = <NUM_LIT> ; i < nregs ; i += <NUM_LIT> ) if ( TARGET_BIG_END ) { parts [ i ] = gen_rtx_REG ( SImode , regno + i + <NUM_LIT> ) ; parts [ i + <NUM_LIT> ] = gen_rtx_REG ( SImode , regno + i ) ; } else { parts [ i ] = gen_rtx_REG ( SImode , regno + i ) ; parts [ i + <NUM_LIT> ] = gen_rtx_REG ( SImode , regno + i + <NUM_LIT> ) ; }


<s> static void arm_elf_asm_constructor ( rtx symbol , int priority ) {

arm_elf_asm_cdtor ( symbol , priority , true ) ;


<s> arm_elf_asm_cdtor ( symbol , priority , true ) ;


<s> static void arm_elf_asm_destructor ( rtx symbol , int priority ) {

arm_elf_asm_cdtor ( symbol , priority , false ) ;


<s> unsigned int flags = default_section_type_flags ( decl , name , reloc ) ;

if ( decl && TREE_CODE ( decl ) == FUNCTION_DECL && target_pure_code ) flags |= SECTION_ARM_PURECODE ;


<s> return REG_P ( x ) && ( REGNO ( x ) == FRAME_POINTER_REGNUM || REGNO ( x ) == ARG_POINTER_REGNUM || ( REGNO ( x ) >= FIRST_VIRTUAL_REGISTER && REGNO ( x ) <= LAST_VIRTUAL_REGISTER ) ) ;


<s> int arm_eliminable_register ( rtx x ) {

return REG_P ( x ) && ( REGNO ( x ) == FRAME_POINTER_REGNUM || REGNO ( x ) == ARG_POINTER_REGNUM || ( REGNO ( x ) >= FIRST_VIRTUAL_REGISTER && REGNO ( x ) <= LAST_VIRTUAL_REGISTER ) ) ;


<s> require_pic_register ( NULL_RTX , false ) ; use_reg ( & CALL_INSN_FUNCTION_USAGE ( insn ) , cfun -> machine -> pic_reg ) ; } if ( TARGET_FDPIC ) { rtx fdpic_reg = gen_rtx_REG ( Pmode , FDPIC_REGNUM ) ; use_reg ( & CALL_INSN_FUNCTION_USAGE ( insn ) , fdpic_reg ) ; } if ( TARGET_AAPCS_BASED ) { rtx * fusage = & CALL_INSN_FUNCTION_USAGE ( insn ) ;

clobber_reg ( fusage , gen_rtx_REG ( word_mode , IP_REGNUM ) ) ;


<s> void arm_emit_eabi_attribute ( const char * name , int num , int val ) {

asm_fprintf ( asm_out_file , <STR_LIT> , num , val ) ;


<s> asm_fprintf ( asm_out_file , <STR_LIT> , num , val ) ;


<s> void arm_emit_fp16_const ( rtx c ) { long bits ; bits = real_to_target ( NULL , CONST_DOUBLE_REAL_VALUE ( c ) , HFmode ) ;

if ( WORDS_BIG_ENDIAN ) assemble_zeros ( <NUM_LIT> ) ;


<s> rtx dwarf = NULL_RTX ; rtx tmp , mem ; gcc_assert ( ! ( ( saved_regs_mask & ( <NUM_LIT> << SP_REGNUM ) ) ) ) ; j = <NUM_LIT> ; while ( j <= LAST_ARM_REGNUM ) if ( saved_regs_mask & ( <NUM_LIT> << j ) ) { if ( ( j % <NUM_LIT> ) == <NUM_LIT> && ( saved_regs_mask & ( <NUM_LIT> << ( j + <NUM_LIT> ) ) ) && ( j + <NUM_LIT> ) != PC_REGNUM ) { if ( offset > <NUM_LIT> ) mem = gen_frame_mem ( DImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) ; else mem = gen_frame_mem ( DImode , stack_pointer_rtx ) ; tmp = gen_rtx_SET ( gen_rtx_REG ( DImode , j ) , mem ) ; tmp = emit_insn ( tmp ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; dwarf = alloc_reg_note ( REG_CFA_RESTORE , gen_rtx_REG ( SImode , j ) , NULL_RTX ) ; dwarf = alloc_reg_note ( REG_CFA_RESTORE , gen_rtx_REG ( SImode , j + <NUM_LIT> ) , dwarf ) ; REG_NOTES ( tmp ) = dwarf ; offset += <NUM_LIT> ; j += <NUM_LIT> ; } else if ( j != PC_REGNUM ) { if ( offset > <NUM_LIT> ) mem = gen_frame_mem ( SImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) ; else mem = gen_frame_mem ( SImode , stack_pointer_rtx ) ; tmp = gen_rtx_SET ( gen_rtx_REG ( SImode , j ) , mem ) ; tmp = emit_insn ( tmp ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; REG_NOTES ( tmp ) = alloc_reg_note ( REG_CFA_RESTORE , gen_rtx_REG ( SImode , j ) , NULL_RTX ) ; offset += <NUM_LIT> ; j += <NUM_LIT> ; }


<s> j += <NUM_LIT> ; } else if ( j != PC_REGNUM ) { if ( offset > <NUM_LIT> ) mem = gen_frame_mem ( SImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) ; else mem = gen_frame_mem ( SImode , stack_pointer_rtx ) ; tmp = gen_rtx_SET ( gen_rtx_REG ( SImode , j ) , mem ) ; tmp = emit_insn ( tmp ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; REG_NOTES ( tmp ) = alloc_reg_note ( REG_CFA_RESTORE , gen_rtx_REG ( SImode , j ) , NULL_RTX ) ; offset += <NUM_LIT> ; j += <NUM_LIT> ; } else j ++ ; } else j ++ ; if ( offset > <NUM_LIT> ) { tmp = gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) ; tmp = emit_insn ( tmp ) ; arm_add_cfa_adjust_cfa_note ( tmp , offset , stack_pointer_rtx , stack_pointer_rtx ) ; offset = <NUM_LIT> ; } if ( saved_regs_mask & ( <NUM_LIT> << PC_REGNUM ) ) { par = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( <NUM_LIT> ) ) ;

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


<s> case E_DImode : gen = gen_arm_load_acquire_exclusivedi ; break ; default : gcc_unreachable ( ) ; } } else { switch ( mode ) { case E_QImode : gen = gen_arm_load_exclusiveqi ; break ; case E_HImode : gen = gen_arm_load_exclusivehi ; break ; case E_SImode : gen = gen_arm_load_exclusivesi ; break ; case E_DImode : gen = gen_arm_load_exclusivedi ; break ; default :


<s> if ( CONST_INT_P ( src ) ) { HOST_WIDE_INT val = INTVAL ( src ) ; emit_set_insn ( dest , GEN_INT ( val & <NUM_LIT> ) ) ; if ( ( val >> <NUM_LIT> ) & <NUM_LIT> ) { emit_set_insn ( gen_rtx_ZERO_EXTRACT ( SImode , dest , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) ) , GEN_INT ( ( val >> <NUM_LIT> ) & <NUM_LIT> ) ) ; rtx_insn * insn = get_last_insn ( ) ; set_unique_reg_note ( insn , REG_EQUAL , copy_rtx ( src ) ) ; } return ; }

emit_set_insn ( dest , gen_rtx_HIGH ( SImode , src ) ) ;


<s> bool return_in_pc = saved_regs_mask & ( <NUM_LIT> << PC_REGNUM ) ; int offset_adj ; int emit_update ; offset_adj = return_in_pc ? <NUM_LIT> : <NUM_LIT> ; for ( i = <NUM_LIT> ; i <= LAST_ARM_REGNUM ; i ++ ) if ( saved_regs_mask & ( <NUM_LIT> << i ) ) num_regs ++ ; gcc_assert ( num_regs && num_regs <= <NUM_LIT> ) ; emit_update = ( saved_regs_mask & ( <NUM_LIT> << SP_REGNUM ) ) ? <NUM_LIT> : <NUM_LIT> ; par = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( num_regs + emit_update + offset_adj ) ) ; if ( return_in_pc ) XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = ret_rtx ; if ( emit_update ) { tmp = gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> * num_regs ) ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( par , <NUM_LIT> , offset_adj ) = tmp ; } for ( j = <NUM_LIT> , i = <NUM_LIT> ; j < num_regs ; i ++ ) if ( saved_regs_mask & ( <NUM_LIT> << i ) ) { reg = gen_rtx_REG ( SImode , i ) ; if ( ( num_regs == <NUM_LIT> ) && emit_update && ! return_in_pc ) { tmp = gen_frame_mem ( SImode , gen_rtx_POST_INC ( Pmode , stack_pointer_rtx ) ) ; tmp = emit_insn ( gen_rtx_SET ( reg , tmp ) ) ; REG_NOTES ( tmp ) = alloc_reg_note ( REG_CFA_RESTORE , reg , dwarf ) ; return ; } tmp = gen_rtx_SET ( reg , gen_frame_mem ( SImode , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> * j ) ) ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( par , <NUM_LIT> , j + emit_update + offset_adj ) = tmp ; if ( i != PC_REGNUM ) dwarf = alloc_reg_note ( REG_CFA_RESTORE , reg , dwarf ) ; j ++ ; } if ( return_in_pc ) par = emit_jump_insn ( par ) ; else par = emit_insn ( par ) ; REG_NOTES ( par ) = dwarf ; if ( ! return_in_pc ) arm_add_cfa_adjust_cfa_note ( par , UNITS_PER_WORD * num_regs , stack_pointer_rtx , stack_pointer_rtx ) ;


<s> emit_update = ( saved_regs_mask & ( <NUM_LIT> << SP_REGNUM ) ) ? <NUM_LIT> : <NUM_LIT> ; par = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( num_regs + emit_update + offset_adj ) ) ; if ( return_in_pc ) XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = ret_rtx ; if ( emit_update ) { tmp = gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> * num_regs ) ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( par , <NUM_LIT> , offset_adj ) = tmp ; } for ( j = <NUM_LIT> , i = <NUM_LIT> ; j < num_regs ; i ++ ) if ( saved_regs_mask & ( <NUM_LIT> << i ) ) { reg = gen_rtx_REG ( SImode , i ) ; if ( ( num_regs == <NUM_LIT> ) && emit_update && ! return_in_pc ) { tmp = gen_frame_mem ( SImode , gen_rtx_POST_INC ( Pmode , stack_pointer_rtx ) ) ; tmp = emit_insn ( gen_rtx_SET ( reg , tmp ) ) ; REG_NOTES ( tmp ) = alloc_reg_note ( REG_CFA_RESTORE , reg , dwarf ) ; return ; } tmp = gen_rtx_SET ( reg , gen_frame_mem ( SImode , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> * j ) ) ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( par , <NUM_LIT> , j + emit_update + offset_adj ) = tmp ; if ( i != PC_REGNUM ) dwarf = alloc_reg_note ( REG_CFA_RESTORE , reg , dwarf ) ; j ++ ; }

if ( return_in_pc ) par = emit_jump_insn ( par ) ;


<s> if ( rem > <NUM_LIT> || ( TARGET_THUMB2 && rem > <NUM_LIT> ) ) { emit_set_insn ( reg1 , plus_constant ( Pmode , reg1 , - PROBE_INTERVAL ) ) ; emit_stack_probe ( plus_constant ( Pmode , reg1 , PROBE_INTERVAL - rem ) ) ; } else emit_stack_probe ( plus_constant ( Pmode , reg1 , - rem ) ) ; } else { HOST_WIDE_INT rounded_size ; struct scratch_reg sr ; get_scratch_register_on_entry ( & sr , regno1 , live_regs ) ; emit_move_insn ( reg1 , GEN_INT ( first ) ) ; rounded_size = size & - PROBE_INTERVAL ; emit_move_insn ( sr . reg , GEN_INT ( rounded_size ) ) ; emit_set_insn ( reg1 , gen_rtx_MINUS ( Pmode , stack_pointer_rtx , reg1 ) ) ; emit_set_insn ( sr . reg , gen_rtx_MINUS ( Pmode , reg1 , sr . reg ) ) ; emit_insn ( gen_probe_stack_range ( reg1 , reg1 , sr . reg ) ) ; if ( size != rounded_size ) { HOST_WIDE_INT rem = size - rounded_size ; if ( rem > <NUM_LIT> || ( TARGET_THUMB2 && rem > <NUM_LIT> ) ) {

emit_set_insn ( sr . reg , plus_constant ( Pmode , sr . reg , - PROBE_INTERVAL ) ) ;


<s> get_scratch_register_on_entry ( & sr , regno1 , live_regs ) ; emit_move_insn ( reg1 , GEN_INT ( first ) ) ; rounded_size = size & - PROBE_INTERVAL ; emit_move_insn ( sr . reg , GEN_INT ( rounded_size ) ) ; emit_set_insn ( reg1 , gen_rtx_MINUS ( Pmode , stack_pointer_rtx , reg1 ) ) ; emit_set_insn ( sr . reg , gen_rtx_MINUS ( Pmode , reg1 , sr . reg ) ) ; emit_insn ( gen_probe_stack_range ( reg1 , reg1 , sr . reg ) ) ; if ( size != rounded_size ) { HOST_WIDE_INT rem = size - rounded_size ; if ( rem > <NUM_LIT> || ( TARGET_THUMB2 && rem > <NUM_LIT> ) ) { emit_set_insn ( sr . reg , plus_constant ( Pmode , sr . reg , - PROBE_INTERVAL ) ) ; emit_stack_probe ( plus_constant ( Pmode , sr . reg , PROBE_INTERVAL - rem ) ) ; } else emit_stack_probe ( plus_constant ( Pmode , sr . reg , - rem ) ) ; } release_scratch_register_on_entry ( & sr ) ; }


<s> emit_library_call ( speculation_barrier_libfunc , LCT_NORMAL , VOIDmode ) ;


<s> switch ( mode ) { case E_QImode : gen = gen_arm_store_exclusiveqi ; break ; case E_HImode : gen = gen_arm_store_exclusivehi ; break ; case E_SImode : gen = gen_arm_store_exclusivesi ; break ; case E_DImode : gen = gen_arm_store_exclusivedi ; break ; default : gcc_unreachable ( ) ; } } emit_insn ( gen ( bval , rval , mem ) ) ;


<s> gcc_unreachable ( ) ; } } else { switch ( mode ) { case E_QImode : gen = gen_arm_store_exclusiveqi ; break ; case E_HImode : gen = gen_arm_store_exclusivehi ; break ; case E_SImode : gen = gen_arm_store_exclusivesi ; break ;

case E_DImode : gen = gen_arm_store_exclusivedi ; break ;


<s> if ( dwarf_index == <NUM_LIT> ) insn = tmp ; mem = gen_frame_mem ( SImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) ; tmp = gen_rtx_SET ( mem , gen_rtx_REG ( SImode , j ) ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( dwarf , <NUM_LIT> , dwarf_index ++ ) = tmp ; mem = gen_frame_mem ( SImode , plus_constant ( Pmode , stack_pointer_rtx , offset + <NUM_LIT> ) ) ; tmp = gen_rtx_SET ( mem , gen_rtx_REG ( SImode , j + <NUM_LIT> ) ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( dwarf , <NUM_LIT> , dwarf_index ++ ) = tmp ; offset += <NUM_LIT> ; j += <NUM_LIT> ; } else { if ( offset < <NUM_LIT> ) { tmp = plus_constant ( Pmode , stack_pointer_rtx , offset ) ; tmp = gen_rtx_PRE_MODIFY ( Pmode , stack_pointer_rtx , tmp ) ; mem = gen_frame_mem ( SImode , tmp ) ; offset = <NUM_LIT> ; } else if ( offset > <NUM_LIT> ) mem = gen_frame_mem ( SImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) ; else mem = gen_frame_mem ( SImode , stack_pointer_rtx ) ; tmp = gen_rtx_SET ( mem , gen_rtx_REG ( SImode , j ) ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; tmp = emit_insn ( tmp ) ;


<s> default : gcc_unreachable ( ) ; } fprintf ( file , <STR_LIT> ) ; for ( i = CONST_VECTOR_NUNITS ( x ) ; i -- ; ) { rtx element ; element = CONST_VECTOR_ELT ( x , i ) ; fprintf ( file , pattern , INTVAL ( element ) ) ;


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


<s> if ( optimize > <NUM_LIT> && TREE_CONSTANT ( decl ) ) SYMBOL_REF_FLAG ( XEXP ( rtl , <NUM_LIT> ) ) = <NUM_LIT> ;

default_encode_section_info ( decl , rtl , first ) ;


<s> if ( d -> one_vector_p && ( next == nelt ) ) { if ( ( nelt == <NUM_LIT> ) && ( d -> vmode != V2DImode ) ) return false ; else next = <NUM_LIT> ; } if ( d -> perm [ i ] != next ) return false ; } location = d -> perm [ <NUM_LIT> ] ; if ( d -> testing_p ) return true ; offset = GEN_INT ( location ) ; if ( d -> vmode == E_DImode ) return false ;

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


<s> case E_V8HImode : case E_V4HImode : gen = gen_neon_vrev32 ; break ; case E_V4SImode : case E_V2SImode : case E_V4SFmode : case E_V2SFmode : gen = gen_neon_vrev64 ; 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> machine_mode vmode = d -> vmode ; unsigned int i , nelt = d -> perm . length ( ) ; if ( BYTES_BIG_ENDIAN ) return false ; if ( d -> testing_p ) return true ; if ( vmode != V8QImode && vmode != V16QImode ) return false ; for ( i = <NUM_LIT> ; i < nelt ; ++ i ) rperm [ i ] = GEN_INT ( d -> perm [ i ] ) ; sel = gen_rtx_CONST_VECTOR ( vmode , gen_rtvec_v ( nelt , rperm ) ) ; sel = force_reg ( vmode , sel ) ; arm_expand_vec_perm_1 ( d -> target , d -> op0 , d -> op1 , sel ) ; return true ;


<s> static bool arm_evpc_neon_vtbl ( struct expand_vec_perm_d * d ) { rtx rperm [ MAX_VECT_LEN ] , sel ; machine_mode vmode = d -> vmode ; unsigned int i , nelt = d -> perm . length ( ) ;


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


<s> mask = ( d -> one_vector_p ? nelt - <NUM_LIT> : <NUM_LIT> * nelt - <NUM_LIT> ) ; for ( i = <NUM_LIT> ; i < nelt ; i += <NUM_LIT> ) { if ( d -> perm [ i ] != i + odd ) return false ; if ( d -> perm [ i + <NUM_LIT> ] != ( ( i + nelt + odd ) & mask ) ) return false ; } if ( d -> testing_p ) return true ; in0 = d -> op0 ; in1 = d -> op1 ; if ( BYTES_BIG_ENDIAN ) { std :: swap ( in0 , in1 ) ;


<s> static bool arm_evpc_neon_vuzp ( struct expand_vec_perm_d * d ) { unsigned int i , odd , mask , nelt = d -> perm . length ( ) ; rtx out0 , out1 , in0 , in1 ; 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> ? 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 ; in0 = d -> op0 ; in1 = d -> op1 ;

if ( swap_nelt != <NUM_LIT> ) std :: swap ( in0 , in1 ) ;


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


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


<s> case EXCESS_PRECISION_TYPE_STANDARD : return ( TARGET_VFP_FP16INST ? FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16 : FLT_EVAL_METHOD_PROMOTE_TO_FLOAT ) ; case EXCESS_PRECISION_TYPE_IMPLICIT : case EXCESS_PRECISION_TYPE_FLOAT16 : return FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16 ; default :


<s> valist = arm_extract_valist_ptr ( valist ) ;

std_expand_builtin_va_start ( valist , nextarg ) ;


<s> machine_mode mode , cmp_mode ; bval = operands [ <NUM_LIT> ] ; rval = operands [ <NUM_LIT> ] ; mem = operands [ <NUM_LIT> ] ; oldval = operands [ <NUM_LIT> ] ; newval = operands [ <NUM_LIT> ] ; is_weak = operands [ <NUM_LIT> ] ; 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 ) cmp_mode = E_SImode ;


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


<s> scalar_int_mode libval_mode = smallest_int_mode_for_size ( <NUM_LIT> * GET_MODE_BITSIZE ( mode ) ) ; rtx libval = emit_library_call_value ( libfunc , NULL_RTX , LCT_CONST , libval_mode , op0 , mode , op1 , mode ) ; 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 ) ;


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


<s> floats_from_frame = ( offsets -> saved_args + arm_compute_static_chain_stack_bytes ( ) - offsets -> frame ) ; for ( i = <NUM_LIT> ; i <= LAST_ARM_REGNUM ; i ++ ) if ( saved_regs_mask & ( <NUM_LIT> << i ) ) { num_regs ++ ; floats_from_frame += <NUM_LIT> ; } if ( TARGET_VFP_BASE ) { int start_reg ; rtx ip_rtx = gen_rtx_REG ( SImode , IP_REGNUM ) ; int saved_size = arm_get_vfp_saved_size ( ) ; if ( saved_size > <NUM_LIT> ) { rtx_insn * insn ; floats_from_frame += saved_size ; insn = emit_insn ( gen_addsi3 ( ip_rtx , hard_frame_pointer_rtx , GEN_INT ( - floats_from_frame ) ) ) ; arm_add_cfa_adjust_cfa_note ( insn , - floats_from_frame , ip_rtx , hard_frame_pointer_rtx ) ; } start_reg = FIRST_VFP_REGNUM ; for ( i = FIRST_VFP_REGNUM ; i < LAST_VFP_REGNUM ; i += <NUM_LIT> ) if ( ! reg_needs_saving_p ( i ) && ! reg_needs_saving_p ( i + <NUM_LIT> ) ) { if ( start_reg != i ) arm_emit_vfp_multi_reg_pop ( start_reg , ( i - start_reg ) / <NUM_LIT> , gen_rtx_REG ( SImode , IP_REGNUM ) ) ; start_reg = i + <NUM_LIT> ; } if ( start_reg != i ) arm_emit_vfp_multi_reg_pop ( start_reg , ( i - start_reg ) / <NUM_LIT> , gen_rtx_REG ( SImode , IP_REGNUM ) ) ; } 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 ( reg_needs_saving_p ( 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 ) ;


<s> if ( TARGET_HAVE_MVE ) mask = gen_reg_rtx ( arm_mode_to_pred_mode ( cmp_result_mode ) . require ( ) ) ; else mask = gen_reg_rtx ( cmp_result_mode ) ; bool inverted = arm_expand_vector_compare ( mask , GET_CODE ( operands [ <NUM_LIT> ] ) , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , true ) ; if ( inverted ) std :: swap ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; if ( TARGET_NEON ) emit_insn ( gen_neon_vbsl ( GET_MODE ( operands [ <NUM_LIT> ] ) , operands [ <NUM_LIT> ] , mask , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; else { machine_mode cmp_mode = GET_MODE ( operands [ <NUM_LIT> ] ) ; switch ( GET_MODE_CLASS ( cmp_mode ) ) { case MODE_VECTOR_INT : emit_insn ( gen_mve_vpselq ( VPSELQ_S , cmp_mode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , mask ) ) ; break ; case MODE_VECTOR_FLOAT : if ( TARGET_HAVE_MVE_FLOAT ) emit_insn ( gen_mve_vpselq_f ( cmp_mode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , mask ) ) ;


<s> case MODE_VECTOR_FLOAT : if ( TARGET_HAVE_MVE_FLOAT ) emit_insn ( gen_mve_vcmpq_f ( code , cmp_mode , target , op0 , force_reg ( cmp_mode , op1 ) ) ) ; else gcc_unreachable ( ) ; break ; default : gcc_unreachable ( ) ; } } else emit_insn ( gen_neon_vc ( code , cmp_mode , target , op0 , op1 ) ) ; return inverted ; case GEU : case GTU : if ( TARGET_HAVE_MVE ) emit_insn ( gen_mve_vcmpq ( code , cmp_mode , target , op0 , force_reg ( cmp_mode , op1 ) ) ) ; else emit_insn ( gen_neon_vc ( code , cmp_mode , target , op0 , force_reg ( cmp_mode , op1 ) ) ) ; return inverted ; case LEU : case LTU : if ( TARGET_HAVE_MVE ) emit_insn ( gen_mve_vcmpq ( swap_condition ( code ) , cmp_mode , target , force_reg ( cmp_mode , op1 ) , op0 ) ) ; else emit_insn ( gen_neon_vc ( swap_condition ( code ) , cmp_mode , target , force_reg ( cmp_mode , op1 ) , op0 ) ) ; return inverted ; case LTGT :


<s> rtx mask ; gcc_checking_assert ( ! BYTES_BIG_ENDIAN ) ; mask = GEN_INT ( one_vector_p ? nelt - <NUM_LIT> : <NUM_LIT> * nelt - <NUM_LIT> ) ;

mask = gen_const_vec_duplicate ( vmode , mask ) ;


<s> gcc_checking_assert ( GET_MODE ( op0 ) == vmode ) ; gcc_checking_assert ( GET_MODE ( op1 ) == vmode ) ; gcc_checking_assert ( GET_MODE ( sel ) == vmode ) ; gcc_checking_assert ( TARGET_NEON ) ; if ( one_vector_p ) { if ( vmode == V8QImode ) emit_insn ( gen_neon_vtbl1v8qi ( target , op0 , sel ) ) ; else emit_insn ( gen_neon_vtbl1v16qi ( target , op0 , sel ) ) ; } else { rtx pair ; if ( vmode == V8QImode ) { pair = gen_reg_rtx ( V16QImode ) ; emit_insn ( gen_neon_vcombinev8qi ( pair , op0 , op1 ) ) ; pair = gen_lowpart ( TImode , pair ) ; emit_insn ( gen_neon_vtbl2v8qi ( target , pair , sel ) ) ; } else { pair = gen_reg_rtx ( OImode ) ; emit_insn ( gen_neon_vcombinev16qi ( pair , op0 , op1 ) ) ; emit_insn ( gen_neon_vtbl2v16qi ( target , pair , sel ) ) ; } }


<s> if ( arm_evpc_neon_vuzp ( d ) ) return true ; if ( arm_evpc_neon_vzip ( d ) ) return true ; if ( arm_evpc_neon_vrev ( d ) ) return true ; if ( arm_evpc_neon_vtrn ( d ) ) return true ; return arm_evpc_neon_vtbl ( d ) ; } return false ;


<s> tree ap_field = TYPE_FIELDS ( TREE_TYPE ( valist ) ) ; valist = build3 ( COMPONENT_REF , TREE_TYPE ( ap_field ) , valist , ap_field , NULL_TREE ) ; } return valist ;


<s> if ( TARGET_AAPCS_BASED ) { tree ap_field = TYPE_FIELDS ( TREE_TYPE ( valist ) ) ; valist = build3 ( COMPONENT_REF , TREE_TYPE ( ap_field ) , valist , ap_field , NULL_TREE ) ;


<s> static bool arm_fdpic_local_funcdesc_p ( rtx fnx ) { tree fn ; enum symbol_visibility vis ; bool ret ; if ( ! TARGET_FDPIC ) return true ;

if ( ! SYMBOL_REF_LOCAL_P ( fnx ) ) return false ;


<s> if ( label != <NUM_LIT> ) { targetm . asm_out . internal_label ( asm_out_file , <STR_LIT> , CODE_LABEL_NUMBER ( label ) ) ; asm_fprintf ( asm_out_file , <STR_LIT> , regno ) ; }


if ( arm_lang_output_object_attributes_hook ) arm_lang_output_object_attributes_hook ( ) ;


<s> } else return ; } else return ; } gcc_assert ( ! arm_ccfsm_state || reverse ) ; if ( ! JUMP_P ( insn ) ) return ; if ( GET_CODE ( body ) == PARALLEL && XVECLEN ( body , <NUM_LIT> ) > <NUM_LIT> ) body = XVECEXP ( body , <NUM_LIT> , <NUM_LIT> ) ; if ( reverse || ( GET_CODE ( body ) == SET && GET_CODE ( SET_DEST ( body ) ) == PC && GET_CODE ( SET_SRC ( body ) ) == IF_THEN_ELSE ) ) { int insns_skipped ; int fail = FALSE , succeed = FALSE ; int then_not_else = TRUE ; rtx_insn * this_insn = start_insn ; rtx label = <NUM_LIT> ; if ( reverse ) { if ( ! seeking_return ) label = XEXP ( SET_SRC ( body ) , <NUM_LIT> ) ; } else if ( GET_CODE ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) ) == LABEL_REF ) label = XEXP ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) , <NUM_LIT> ) ; else if ( GET_CODE ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) ) == LABEL_REF ) { label = XEXP ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) , <NUM_LIT> ) ; then_not_else = FALSE ; } else if ( ANY_RETURN_P ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) ) ) { seeking_return = <NUM_LIT> ; return_code = GET_CODE ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) ) ; } else if ( ANY_RETURN_P ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) ) ) { seeking_return = <NUM_LIT> ; return_code = GET_CODE ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) ) ; then_not_else = FALSE ; } else gcc_unreachable ( ) ; for ( insns_skipped = <NUM_LIT> ; ! fail && ! succeed && insns_skipped ++ < max_insns_skipped ; ) { rtx scanbody ; this_insn = next_nonnote_insn ( this_insn ) ; if ( ! this_insn ) break ; switch ( GET_CODE ( this_insn ) ) { case CODE_LABEL : if ( this_insn == label ) { arm_ccfsm_state = <NUM_LIT> ; succeed = TRUE ; } else fail = TRUE ; break ; case BARRIER : this_insn = next_nonnote_insn ( this_insn ) ; if ( this_insn && this_insn == label ) { arm_ccfsm_state = <NUM_LIT> ; succeed = TRUE ; } else fail = TRUE ; break ; case CALL_INSN : if ( arm_arch5t ) { fail = TRUE ; break ; } this_insn = next_nonnote_insn ( this_insn ) ; if ( this_insn && BARRIER_P ( this_insn ) ) this_insn = next_nonnote_insn ( this_insn ) ; if ( this_insn && this_insn == label && insns_skipped < max_insns_skipped ) { arm_ccfsm_state = <NUM_LIT> ; succeed = TRUE ; } else fail = TRUE ; break ; case JUMP_INSN : scanbody = PATTERN ( this_insn ) ;

if ( GET_CODE ( scanbody ) == SET && GET_CODE ( SET_DEST ( scanbody ) ) == PC ) {


<s> static int arm_first_cycle_multipass_dfa_lookahead ( void ) { int issue_rate = arm_issue_rate ( ) ; return issue_rate > <NUM_LIT> && ! sched_fusion ? issue_rate : <NUM_LIT> ;


<s> return autopref_multipass_dfa_lookahead_guard ( insn , ready_index ) ;


<s> if ( ! TARGET_32BIT ) return false ;


<s> static opt_scalar_float_mode arm_floatn_mode ( int n , bool extended ) { if ( ! extended && n == <NUM_LIT> ) {

if ( arm_fp16_format == ARM_FP16_FORMAT_IEEE ) return HFmode ;


<s> if ( ! IS_INTERRUPT ( arm_current_func_type ( ) ) && ( flag_stack_check == STATIC_BUILTIN_STACK_CHECK || flag_stack_clash_protection ) && 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 ) { size += <NUM_LIT> * UNITS_PER_WORD ;

if ( size > PROBE_INTERVAL && size > get_stack_check_protect ( ) ) return true ;


<s> } } if ( ( pcum -> nregs & <NUM_LIT> ) && ARM_DOUBLEWORD_ALIGN ) { int res = arm_needs_doubleword_align ( arg . mode , arg . type ) ; if ( res < <NUM_LIT> && warn_psabi ) inform ( input_location , <STR_LIT> <STR_LIT> , arg . type ) ; else if ( res > <NUM_LIT> ) { pcum -> nregs ++ ; if ( res > <NUM_LIT> && warn_psabi ) inform ( input_location , <STR_LIT> <STR_LIT> , arg . type ) ;


<s> } if ( ( pcum -> nregs & <NUM_LIT> ) && ARM_DOUBLEWORD_ALIGN ) { int res = arm_needs_doubleword_align ( arg . mode , arg . type ) ; if ( res < <NUM_LIT> && warn_psabi ) inform ( input_location , <STR_LIT> <STR_LIT> , arg . type ) ; else if ( res > <NUM_LIT> ) { pcum -> nregs ++ ; if ( res > <NUM_LIT> && warn_psabi ) inform ( input_location , <STR_LIT> <STR_LIT> , arg . type ) ;


<s> pcum -> nargs += <NUM_LIT> ; if ( arm_vector_mode_supported_p ( arg . mode ) && pcum -> named_count > pcum -> nargs && TARGET_IWMMXT_ABI ) pcum -> iwmmxt_nregs += <NUM_LIT> ; else pcum -> nregs += ARM_NUM_REGS2 ( arg . mode , arg . type ) ; }


<s> if ( res < <NUM_LIT> && warn_psabi ) inform ( input_location , <STR_LIT> <STR_LIT> , type ) ; if ( res > <NUM_LIT> && warn_psabi ) inform ( input_location , <STR_LIT> <STR_LIT> , type ) ;


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


<s> if ( type && BYTES_BIG_ENDIAN && INTEGRAL_TYPE_P ( type ) ) return PAD_DOWNWARD ; return PAD_UPWARD ;


<s> if ( ! decl_binds_to_current_def_p ( decl ) ) return false ; if ( ! DECL_SECTION_NAME ( decl ) ) { if ( flag_function_sections || DECL_COMDAT_GROUP ( decl ) ) return false ;


<s> if ( size % UNITS_PER_WORD != <NUM_LIT> ) { size += UNITS_PER_WORD - size % UNITS_PER_WORD ; mode = int_mode_for_size ( size * BITS_PER_UNIT , <NUM_LIT> ) . require ( ) ; } }


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


<s> static bool arm_function_value_regno_p ( const unsigned int regno ) {

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


<s> bool arm_fusion_enabled_p ( tune_params :: fuse_ops op ) {

return current_tune -> fusible_ops & op ;


<s> rtx arm_gen_compare_reg ( rtx_code code , rtx x , rtx y , rtx scratch ) {

if ( GET_MODE ( x ) == DImode || GET_MODE ( y ) == DImode ) return arm_gen_dicompare_reg ( code , x , y , scratch ) ;


<s> if ( mode == CC_RSBmode ) { if ( ! scratch ) scratch = gen_rtx_SCRATCH ( SImode ) ; emit_insn ( gen_rsb_imm_compare_scratch ( scratch , GEN_INT ( ~ UINTVAL ( x ) ) , y ) ) ; } else emit_set_insn ( cc_reg , gen_rtx_COMPARE ( mode , x , y ) ) ; return cc_reg ;


<s> gcc_assert ( ! last_bytes || part_bytes_reg ) ; if ( BYTES_BIG_ENDIAN && last_bytes ) { rtx tmp = gen_reg_rtx ( SImode ) ; emit_insn ( gen_lshrsi3 ( tmp , part_bytes_reg , GEN_INT ( <NUM_LIT> * ( <NUM_LIT> - last_bytes ) ) ) ) ; part_bytes_reg = tmp ; while ( last_bytes ) { mem = adjust_automodify_address ( dstbase , QImode , plus_constant ( Pmode , dst , last_bytes - <NUM_LIT> ) , dstoffset + last_bytes - <NUM_LIT> ) ; emit_move_insn ( mem , gen_lowpart ( QImode , part_bytes_reg ) ) ; if ( -- last_bytes ) { tmp = gen_reg_rtx ( SImode ) ; emit_insn ( gen_lshrsi3 ( tmp , part_bytes_reg , GEN_INT ( <NUM_LIT> ) ) ) ; part_bytes_reg = tmp ; } } } else { if ( last_bytes > <NUM_LIT> ) { mem = adjust_automodify_address ( dstbase , HImode , dst , dstoffset ) ; emit_move_insn ( mem , gen_lowpart ( HImode , part_bytes_reg ) ) ; last_bytes -= <NUM_LIT> ; if ( last_bytes ) { rtx tmp = gen_reg_rtx ( SImode ) ; emit_insn ( gen_addsi3 ( dst , dst , const2_rtx ) ) ; emit_insn ( gen_lshrsi3 ( tmp , part_bytes_reg , GEN_INT ( <NUM_LIT> ) ) ) ; part_bytes_reg = tmp ; dstoffset += <NUM_LIT> ; } } if ( last_bytes ) {

mem = adjust_automodify_address ( dstbase , QImode , dst , dstoffset ) ;


<s> rtx scratch2 = scratch ? scratch : gen_reg_rtx ( SImode ) ; y_hi = gen_int_mode ( - INTVAL ( y_hi ) , SImode ) ; if ( ! arm_add_operand ( y_hi , SImode ) ) y_hi = force_reg ( SImode , y_hi ) ; emit_insn ( gen_addsi3 ( scratch2 , x_hi , y_hi ) ) ; x_hi = scratch2 ; } if ( ! scratch ) { gcc_assert ( ! reload_completed ) ; scratch = gen_rtx_SCRATCH ( SImode ) ; } rtx clobber = gen_rtx_CLOBBER ( VOIDmode , scratch ) ; cc_reg = gen_rtx_REG ( CC_NZmode , CC_REGNUM ) ; rtx set = gen_rtx_SET ( cc_reg , gen_rtx_COMPARE ( CC_NZmode , gen_rtx_IOR ( SImode , x_lo , x_hi ) , const0_rtx ) ) ; emit_insn ( gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , set , clobber ) ) ) ; return cc_reg ; } if ( ! arm_add_operand ( y_lo , SImode ) ) y_lo = force_reg ( SImode , y_lo ) ; if ( ! arm_add_operand ( y_hi , SImode ) ) y_hi = force_reg ( SImode , y_hi ) ; rtx cmp1 = gen_rtx_NE ( SImode , x_lo , y_lo ) ; rtx cmp2 = gen_rtx_NE ( SImode , x_hi , y_hi ) ; rtx conjunction = gen_rtx_IOR ( SImode , cmp1 , cmp2 ) ; mode = SELECT_CC_MODE ( code , conjunction , const0_rtx ) ; cc_reg = gen_rtx_REG ( mode , CC_REGNUM ) ; emit_insn ( gen_rtx_SET ( cc_reg , gen_rtx_COMPARE ( mode , conjunction , const0_rtx ) ) ) ; return cc_reg ; } case LT : case GE : { if ( y_lo == const0_rtx ) { if ( ! arm_add_operand ( y_hi , SImode ) ) y_hi = force_reg ( SImode , y_hi ) ; return arm_gen_compare_reg ( code , x_hi , y_hi , NULL_RTX ) ; } if ( ! arm_add_operand ( y_lo , SImode ) ) y_lo = force_reg ( SImode , y_lo ) ; rtx cmp1 = gen_rtx_LTU ( DImode , arm_gen_compare_reg ( LTU , x_lo , y_lo , NULL_RTX ) , const0_rtx ) ; if ( ! scratch ) scratch = gen_rtx_SCRATCH ( SImode ) ; if ( ! arm_not_operand ( y_hi , SImode ) ) y_hi = force_reg ( SImode , y_hi ) ; rtx_insn * insn ; if ( y_hi == const0_rtx ) insn = emit_insn ( gen_cmpsi3_0_carryin_CC_NVout ( scratch , x_hi , cmp1 ) ) ; else if ( CONST_INT_P ( y_hi ) ) insn = emit_insn ( gen_cmpsi3_imm_carryin_CC_NVout ( scratch , x_hi , y_hi , cmp1 ) ) ;

else insn = emit_insn ( gen_cmpsi3_carryin_CC_NVout ( scratch , x_hi , y_hi , cmp1 ) ) ;


<s> else if ( CONST_INT_P ( y_hi ) ) insn = emit_insn ( gen_cmpsi3_imm_carryin_CC_NVout ( scratch , x_hi , y_hi , cmp1 ) ) ; else insn = emit_insn ( gen_cmpsi3_carryin_CC_NVout ( scratch , x_hi , y_hi , cmp1 ) ) ; return SET_DEST ( single_set ( insn ) ) ; } case LE : case GT : { gcc_assert ( arm_const_double_prefer_rsbs_rsc ( y ) ) ; if ( ! const_ok_for_arm ( INTVAL ( y_lo ) ) ) y_lo = force_reg ( SImode , y_lo ) ; rtx cmp1 = gen_rtx_LTU ( DImode , arm_gen_compare_reg ( LTU , y_lo , x_lo , scratch ) , const0_rtx ) ; rtx_insn * insn = emit_insn ( gen_rscsi3_CC_NVout_scratch ( scratch , y_hi , x_hi , cmp1 ) ) ; return SET_DEST ( single_set ( insn ) ) ; } case LTU : case GEU : { if ( y_lo == const0_rtx ) { if ( ! arm_add_operand ( y_hi , SImode ) ) y_hi = force_reg ( SImode , y_hi ) ; return arm_gen_compare_reg ( code , x_hi , y_hi , NULL_RTX ) ; } if ( ! arm_add_operand ( y_lo , SImode ) ) y_lo = force_reg ( SImode , y_lo ) ; rtx cmp1 = gen_rtx_LTU ( DImode , arm_gen_compare_reg ( LTU , x_lo , y_lo , NULL_RTX ) , const0_rtx ) ; if ( ! scratch ) scratch = gen_rtx_SCRATCH ( SImode ) ; if ( ! arm_not_operand ( y_hi , SImode ) ) y_hi = force_reg ( SImode , y_hi ) ; rtx_insn * insn ; if ( y_hi == const0_rtx ) insn = emit_insn ( gen_cmpsi3_0_carryin_CC_Bout ( scratch , x_hi , cmp1 ) ) ; else if ( CONST_INT_P ( y_hi ) ) { y_hi = GEN_INT ( UINTVAL ( y_hi ) & <NUM_LIT> ) ; insn = emit_insn ( gen_cmpsi3_imm_carryin_CC_Bout ( scratch , x_hi , y_hi , cmp1 ) ) ; } else insn = emit_insn ( gen_cmpsi3_carryin_CC_Bout ( scratch , x_hi , y_hi , cmp1 ) ) ; return SET_DEST ( single_set ( insn ) ) ; } case LEU : case GTU : { gcc_assert ( arm_const_double_prefer_rsbs_rsc ( y ) ) ; if ( ! const_ok_for_arm ( INTVAL ( y_lo ) ) ) y_lo = force_reg ( SImode , y_lo ) ;


<s> const char * arm_gen_far_branch ( rtx * operands , int pos_label , const char * dest , const char * branch_format ) { rtx_code_label * tmp_label = gen_label_rtx ( ) ; char label_buf [ <NUM_LIT> ] ; char buffer [ <NUM_LIT> ] ; ASM_GENERATE_INTERNAL_LABEL ( label_buf , dest , \ CODE_LABEL_NUMBER ( tmp_label ) ) ; const char * label_ptr = arm_strip_name_encoding ( label_buf ) ; rtx dest_label = operands [ pos_label ] ; operands [ pos_label ] = tmp_label ; snprintf ( buffer , sizeof ( buffer ) , <STR_LIT> , branch_format , label_ptr ) ; output_asm_insn ( buffer , operands ) ; snprintf ( buffer , sizeof ( buffer ) , <STR_LIT> , pos_label , label_ptr ) ;


<s> XVECEXP ( result , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_SET ( basereg , plus_constant ( Pmode , basereg , wback_offset ) ) ; i = <NUM_LIT> ; count ++ ; }

for ( j = <NUM_LIT> ; i < count ; i ++ , j ++ ) XVECEXP ( result , <NUM_LIT> , i ) = gen_rtx_SET ( gen_rtx_REG ( SImode , regs [ j ] ) , mems [ j ] ) ;


<s> HOST_WIDE_INT offset = * offsetp ; int i ; gcc_assert ( count <= MAX_LDM_STM_OPS ) ; if ( GET_CODE ( basereg ) == PLUS ) basereg = XEXP ( basereg , <NUM_LIT> ) ; for ( i = <NUM_LIT> ; i < count ; i ++ ) { rtx addr = plus_constant ( Pmode , basereg , i * <NUM_LIT> ) ; mems [ i ] = adjust_automodify_address_nv ( basemem , SImode , addr , offset ) ; offset += <NUM_LIT> ;


<s> rtx reg = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_return_addr_mask ( reg ) ) ; return reg ;


<s> rtx reg = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_return_addr_mask ( reg ) ) ;


<s> if ( length > <NUM_LIT> ) return false ; value = ( UINTVAL ( operands [ <NUM_LIT> ] ) & <NUM_LIT> ) ; align = UINTVAL ( operands [ <NUM_LIT> ] ) ; if ( TARGET_NEON && length >= <NUM_LIT> && current_tune -> string_ops_prefer_neon && arm_block_set_vect ( dstbase , length , value , align ) ) return true ;

if ( ! unaligned_access && ( align & <NUM_LIT> ) != <NUM_LIT> ) return arm_block_set_unaligned_non_vect ( dstbase , length , value , align ) ;


<s> return arm_gen_multiple_op ( FALSE , regs , count , basereg , write_back , basemem , offsetp ) ;


<s> rtx result ; if ( GET_CODE ( basereg ) == PLUS ) basereg = XEXP ( basereg , <NUM_LIT> ) ; if ( ! multiple_operation_profitable_p ( false , count , <NUM_LIT> ) ) { rtx seq ; start_sequence ( ) ; for ( i = <NUM_LIT> ; i < count ; i ++ ) emit_move_insn ( mems [ i ] , gen_rtx_REG ( SImode , regs [ i ] ) ) ;

if ( wback_offset != <NUM_LIT> ) emit_move_insn ( basereg , plus_constant ( Pmode , basereg , wback_offset ) ) ;


<s> seq = get_insns ( ) ; end_sequence ( ) ; return seq ; } result = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( count + ( wback_offset != <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ) ) ) ; if ( wback_offset != <NUM_LIT> ) { XVECEXP ( result , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_SET ( basereg , plus_constant ( Pmode , basereg , wback_offset ) ) ; i = <NUM_LIT> ; count ++ ;


<s> x = gen_rtx_IF_THEN_ELSE ( VOIDmode , x , gen_rtx_LABEL_REF ( VOIDmode , label_ref ) , pc_rtx ) ; emit_unlikely_jump ( gen_rtx_SET ( pc_rtx , x ) ) ;


<s> x = gen_rtx_fmt_ee ( code , VOIDmode , gen_rtx_REG ( cc_mode , CC_REGNUM ) , const0_rtx ) ;

x = gen_rtx_IF_THEN_ELSE ( VOIDmode , x , gen_rtx_LABEL_REF ( VOIDmode , label_ref ) , pc_rtx ) ;


<s> size = build_int_cst ( sizetype , <NUM_LIT> ) ;


<s> static arm_stack_offsets * arm_get_frame_offsets ( void ) { struct arm_stack_offsets * offsets ;

offsets = & cfun -> machine -> stack_offsets ;


<s> if ( TARGET_HAVE_MVE ) return arm_mode_to_pred_mode ( mode ) ; return default_get_mask_mode ( mode ) ;


if ( TARGET_HAVE_MVE ) return arm_mode_to_pred_mode ( mode ) ;


<s> else if ( decl && flag_unit_at_a_time ) { cgraph_node * local_info_node = cgraph_node :: local_info_node ( CONST_CAST_TREE ( decl ) ) ; if ( local_info_node && local_info_node -> local ) return ARM_PCS_AAPCS_LOCAL ; } } else if ( user_convention && user_pcs != arm_pcs_default ) sorry ( <STR_LIT> ) ; return arm_pcs_default ;


<s> ARM_NAME_ENCODING_LENGTHS default : return <NUM_LIT> ;


<s> static int arm_get_strip_length ( int c ) {


<s> if ( ! reg_needs_saving_p ( regno ) && ! reg_needs_saving_p ( regno + <NUM_LIT> ) ) { if ( count > <NUM_LIT> ) { if ( count == <NUM_LIT> && ! arm_arch6 ) count ++ ; saved += count * <NUM_LIT> ; } count = <NUM_LIT> ; } else count ++ ; } if ( count > <NUM_LIT> ) { if ( count == <NUM_LIT> && ! arm_arch6 ) count ++ ; saved += count * <NUM_LIT> ; } }


if ( cfun && cfun -> decl ) return lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( cfun -> decl ) ) ;


<s> static tree arm_handle_cmse_nonsecure_call ( tree * node , tree name , tree , int , bool * no_add_attrs ) { tree decl = NULL_TREE , fntype = NULL_TREE ; tree type ; if ( ! use_cmse ) { * no_add_attrs = true ; warning ( OPT_Wattributes , <STR_LIT> <STR_LIT> , name ) ; return NULL_TREE ; } if ( TREE_CODE ( * node ) == VAR_DECL || TREE_CODE ( * node ) == TYPE_DECL ) { decl = * node ; fntype = TREE_TYPE ( decl ) ; } while ( fntype != NULL_TREE && TREE_CODE ( fntype ) == POINTER_TYPE ) fntype = TREE_TYPE ( fntype ) ; 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 ) ;


<s> * 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 ; return NULL_TREE ;


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


<s> if ( TREE_CODE ( * node ) != FUNCTION_DECL ) {

warning ( OPT_Wattributes , <STR_LIT> , name ) ;


<s> warning ( OPT_Wattributes , <STR_LIT> , name ) ; } } else { if ( TREE_CODE ( * node ) == FUNCTION_TYPE || TREE_CODE ( * node ) == METHOD_TYPE ) { if ( arm_isr_value ( args ) == ARM_FT_UNKNOWN ) { warning ( OPT_Wattributes , <STR_LIT> , name ) ; * no_add_attrs = true ; } } else if ( TREE_CODE ( * node ) == POINTER_TYPE && ( TREE_CODE ( TREE_TYPE ( * node ) ) == FUNCTION_TYPE || TREE_CODE ( TREE_TYPE ( * node ) ) == METHOD_TYPE ) && arm_isr_value ( args ) != ARM_FT_UNKNOWN ) { * node = build_variant_type_copy ( * node ) ; TREE_TYPE ( * node ) = build_type_attribute_variant ( TREE_TYPE ( * node ) , tree_cons ( name , args , TYPE_ATTRIBUTES ( TREE_TYPE ( * node ) ) ) ) ; * no_add_attrs = true ; } else { if ( flags & ( ( int ) ATTR_FLAG_DECL_NEXT | ( int ) ATTR_FLAG_FUNCTION_NEXT | ( int ) ATTR_FLAG_ARRAY_NEXT ) ) { * no_add_attrs = true ; return tree_cons ( name , args , NULL_TREE ) ; } else {


<s> tree decl = TYPE_NAME ( * node ) ; if ( decl ) { DECL_VISIBILITY ( decl ) = VISIBILITY_HIDDEN ;

DECL_VISIBILITY_SPECIFIED ( decl ) = <NUM_LIT> ;


<s> if ( regno == CC_REGNUM && GET_MODE_CLASS ( mode ) != MODE_CC ) return false ; if ( IS_VPR_REGNUM ( regno ) ) return mode == HImode || mode == V16BImode || mode == V8BImode || mode == V4BImode ; if ( TARGET_THUMB1 ) return ( ARM_NUM_REGS ( mode ) < <NUM_LIT> ) || ( regno < LAST_LO_REGNUM ) ; if ( TARGET_VFP_BASE && IS_VFP_REGNUM ( regno ) ) { if ( mode == DFmode || mode == DImode ) return VFP_REGNO_OK_FOR_DOUBLE ( regno ) ; if ( mode == HFmode || mode == BFmode || mode == HImode || mode == SFmode || mode == SImode ) 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> ) ) ; if ( TARGET_HAVE_MVE ) return ( ( VALID_MVE_MODE ( mode ) && NEON_REGNO_OK_FOR_QUAD ( regno ) ) || ( mode == OImode && NEON_REGNO_OK_FOR_NREGS ( regno , <NUM_LIT> ) ) || ( mode == XImode && NEON_REGNO_OK_FOR_NREGS ( regno , <NUM_LIT> ) ) ) ;


<s> if ( IS_VPR_REGNUM ( regno ) ) return CEIL ( GET_MODE_SIZE ( mode ) , <NUM_LIT> ) ; if ( TARGET_32BIT && regno > PC_REGNUM && regno != FRAME_POINTER_REGNUM && regno != ARG_POINTER_REGNUM && ! IS_VFP_REGNUM ( regno ) ) return <NUM_LIT> ; return ARM_NUM_REGS ( mode ) ;


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

if ( bitmap_equal_p ( fpubits , cand_fpubits ) ) return all_fpus [ i ] . name ;


<s> aapcs_cp_arg_layout [ i ] . cum_init ( pcum , fntype , libname , fndecl ) ; } } return ; } pcum -> nregs = <NUM_LIT> ; pcum -> iwmmxt_nregs = <NUM_LIT> ; pcum -> can_split = true ; pcum -> named_count = <NUM_LIT> ; pcum -> nargs = <NUM_LIT> ; if ( TARGET_REALLY_IWMMXT && fntype ) { tree fn_arg ; for ( fn_arg = TYPE_ARG_TYPES ( fntype ) ;


<s> aapcs_cp_arg_layout [ i ] . cum_init ( pcum , fntype , libname , fndecl ) ; } } return ; } pcum -> nregs = <NUM_LIT> ; pcum -> iwmmxt_nregs = <NUM_LIT> ; pcum -> can_split = true ; pcum -> named_count = <NUM_LIT> ; pcum -> nargs = <NUM_LIT> ; if ( TARGET_REALLY_IWMMXT && fntype ) { tree fn_arg ; for ( fn_arg = TYPE_ARG_TYPES ( fntype ) ; fn_arg ; fn_arg = TREE_CHAIN ( fn_arg ) ) pcum -> named_count += <NUM_LIT> ; if ( ! pcum -> named_count ) pcum -> named_count = INT_MAX ;


<s> void arm_init_expanders ( void ) { init_machine_status = arm_init_machine_status ;

if ( cfun ) mark_reg_pointer ( arg_pointer_rtx , PARM_BOUNDARY ) ;


<s> void arm_init_expanders ( void ) { init_machine_status = arm_init_machine_status ; if ( cfun ) mark_reg_pointer ( arg_pointer_rtx , PARM_BOUNDARY ) ;


<s> struct machine_function * machine ; machine = ggc_cleared_alloc < machine_function > ( ) ; machine -> func_type = ARM_FT_UNKNOWN ; machine -> static_chain_stack_bytes = - <NUM_LIT> ; return machine ;


<s> struct machine_function * machine ; machine = ggc_cleared_alloc < machine_function > ( ) ; machine -> func_type = ARM_FT_UNKNOWN ;

machine -> static_chain_stack_bytes = - <NUM_LIT> ;


<s> if ( ! TARGET_FLIP_THUMB ) return ; if ( TREE_CODE ( fndecl ) != FUNCTION_DECL || DECL_EXTERNAL ( fndecl ) || fndecl_built_in_p ( fndecl ) || DECL_ARTIFICIAL ( fndecl ) ) return ; if ( current_function_decl ) { mode = TARGET_THUMB ? <STR_LIT> : <STR_LIT> ; add_attribute ( mode , attributes ) ; return ; } if ( lookup_attribute ( <STR_LIT> , * attributes ) != NULL ) return ; mode = thumb_flipper ? <STR_LIT> : <STR_LIT> ; add_attribute ( mode , attributes ) ;


<s> const char * mode ; if ( ! TARGET_FLIP_THUMB ) return ; if ( TREE_CODE ( fndecl ) != FUNCTION_DECL || DECL_EXTERNAL ( fndecl ) || fndecl_built_in_p ( fndecl ) || DECL_ARTIFICIAL ( fndecl ) ) return ; if ( current_function_decl ) { mode = TARGET_THUMB ? <STR_LIT> : <STR_LIT> ; add_attribute ( mode , attributes ) ; return ;


<s> static int arm_insn_cost ( rtx_insn * insn , bool speed ) { int cost ; if ( ! reload_completed && GET_CODE ( PATTERN ( insn ) ) == SET && REG_P ( SET_DEST ( PATTERN ( insn ) ) ) && REG_P ( SET_SRC ( PATTERN ( insn ) ) ) ) return <NUM_LIT> ; cost = pattern_cost ( PATTERN ( insn ) , speed ) ; return cost ? cost : COSTS_N_INSNS ( <NUM_LIT> ) ;


<s> if ( ! reload_completed && GET_CODE ( PATTERN ( insn ) ) == SET && REG_P ( SET_DEST ( PATTERN ( insn ) ) ) && REG_P ( SET_SRC ( PATTERN ( insn ) ) ) ) return <NUM_LIT> ; cost = pattern_cost ( PATTERN ( insn ) , speed ) ; return cost ? cost : COSTS_N_INSNS ( <NUM_LIT> ) ;


<s> arm_ccfsm_state = <NUM_LIT> ; arm_target_insn = NULL ; } default_internal_label ( stream , prefix , labelno ) ;


<s> if ( arm_ccfsm_state == <NUM_LIT> && ( unsigned ) arm_target_label == labelno && ! strcmp ( prefix , <STR_LIT> ) ) {


<s> static const char * arm_invalid_binary_op ( int op ATTRIBUTE_UNUSED , const_tree type1 , const_tree type2 ) { if ( element_mode ( type1 ) == BFmode || element_mode ( type2 ) == BFmode ) return N_ ( <STR_LIT> ) ; return NULL ;


<s> if ( element_mode ( type1 ) == BFmode || element_mode ( type2 ) == BFmode ) return N_ ( <STR_LIT> ) ; return NULL ;


<s> if ( element_mode ( fromtype ) != element_mode ( totype ) ) { if ( TYPE_MODE ( fromtype ) == BFmode ) return N_ ( <STR_LIT> ) ;

if ( TYPE_MODE ( totype ) == BFmode ) return N_ ( <STR_LIT> ) ;


<s> static const char * arm_invalid_unary_op ( int op , const_tree type ) {

if ( element_mode ( type ) == BFmode && op != ADDR_EXPR ) return N_ ( <STR_LIT> ) ;


<s> if ( reg_mentioned_p ( gen_rtx_REG ( SImode , LR_REGNUM ) , insn ) ) return <STR_LIT> ; return NULL ;


<s> if ( CALL_P ( insn ) ) return <STR_LIT> ;

if ( reg_mentioned_p ( gen_rtx_REG ( SImode , LR_REGNUM ) , insn ) ) return <STR_LIT> ;


<s> if ( ! arm_arch_notm ) return ARM_FT_NORMAL | ARM_FT_STACKALIGN ; if ( argument == NULL_TREE ) return ARM_FT_ISR ; if ( TREE_VALUE ( argument ) == NULL_TREE || TREE_CODE ( TREE_VALUE ( argument ) ) != STRING_CST ) return ARM_FT_UNKNOWN ; arg = TREE_STRING_POINTER ( TREE_VALUE ( argument ) ) ; for ( ptr = isr_attribute_args ; ptr -> arg != NULL ; ptr ++ ) if ( streq ( arg , ptr -> arg ) ) return ptr -> return_value ; return ARM_FT_UNKNOWN ;


<s> extern bool arm_is_constant_pool_ref ( rtx x ) { return ( MEM_P ( x ) && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P ( XEXP ( x , <NUM_LIT> ) ) ) ;


<s> tree attrs ; if ( ! decl ) return TARGET_LONG_CALLS ; attrs = TYPE_ATTRIBUTES ( TREE_TYPE ( decl ) ) ; if ( lookup_attribute ( <STR_LIT> , attrs ) ) return false ; if ( ! flag_reorder_blocks_and_partition && TREE_CODE ( decl ) == FUNCTION_DECL && arm_function_in_section_p ( decl , current_function_section ( ) ) ) return false ; if ( lookup_attribute ( <STR_LIT> , attrs ) ) return true ;


<s> if ( LABEL_REF_P ( orig ) ) { * is_readonly = true ; return true ; } if ( SYMBOL_REF_P ( orig ) ) { if ( CONSTANT_POOL_ADDRESS_P ( orig ) ) { * is_readonly = true ; return true ; } if ( SYMBOL_REF_LOCAL_P ( orig ) && ! SYMBOL_REF_EXTERNAL_P ( orig ) && SYMBOL_REF_DECL ( orig ) && ( ! DECL_P ( SYMBOL_REF_DECL ( orig ) ) || ! DECL_COMMON ( SYMBOL_REF_DECL ( orig ) ) ) ) { tree decl = SYMBOL_REF_DECL ( orig ) ; tree init = ( TREE_CODE ( decl ) == VAR_DECL ) ? DECL_INITIAL ( decl ) : ( TREE_CODE ( decl ) == CONSTRUCTOR ) ? decl : <NUM_LIT> ; int reloc = <NUM_LIT> ; bool named_section , readonly ; if ( init && init != error_mark_node ) reloc = compute_reloc_for_constant ( init ) ;

named_section = TREE_CODE ( decl ) == VAR_DECL && lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ;


<s> static bool arm_is_segment_info_known ( rtx orig , bool * is_readonly ) { * is_readonly = false ; if ( LABEL_REF_P ( orig ) ) { * is_readonly = true ; return true ; } if ( SYMBOL_REF_P ( orig ) ) { if ( CONSTANT_POOL_ADDRESS_P ( orig ) ) { * is_readonly = true ; return true ; } if ( SYMBOL_REF_LOCAL_P ( orig ) && ! SYMBOL_REF_EXTERNAL_P ( orig ) && SYMBOL_REF_DECL ( orig ) && ( ! DECL_P ( SYMBOL_REF_DECL ( orig ) ) || ! DECL_COMMON ( SYMBOL_REF_DECL ( orig ) ) ) ) { tree decl = SYMBOL_REF_DECL ( orig ) ; tree init = ( TREE_CODE ( decl ) == VAR_DECL ) ? DECL_INITIAL ( decl ) : ( TREE_CODE ( decl ) == CONSTRUCTOR ) ? decl : <NUM_LIT> ; int reloc = <NUM_LIT> ;


<s> if ( TARGET_ARM ) return arm_legitimate_address_outer_p ( mode , x , SET , strict_p ) ;

else if ( TARGET_THUMB2 ) return thumb2_legitimate_address_p ( mode , x , strict_p ) ;


<s> static bool arm_legitimate_constant_p ( machine_mode mode , rtx x ) { return ( ! arm_cannot_force_const_mem ( mode , x ) && ( TARGET_32BIT ? arm_legitimate_constant_p_1 ( mode , x ) : thumb_legitimate_constant_p ( mode , x ) ) ) ;


<s> return ( ! arm_cannot_force_const_mem ( mode , x ) && ( TARGET_32BIT ? arm_legitimate_constant_p_1 ( mode , x ) : thumb_legitimate_constant_p ( mode , x ) ) ) ;


<s> static bool arm_legitimate_constant_p_1 ( machine_mode , rtx x ) { if ( GET_CODE ( x ) == CONST_VECTOR && ! neon_make_constant ( x , false ) ) return false ;

return flag_pic || ! label_mentioned_p ( x ) ;


<s> enum rtx_code code = GET_CODE ( index ) ; if ( TARGET_HARD_FLOAT && ( mode == SFmode || mode == DFmode ) ) return ( code == CONST_INT && INTVAL ( index ) < <NUM_LIT> && INTVAL ( index ) > - <NUM_LIT> && ( INTVAL ( index ) & <NUM_LIT> ) == <NUM_LIT> ) ; if ( TARGET_NEON && VALID_NEON_QREG_MODE ( mode ) ) return ( code == CONST_INT && INTVAL ( index ) < <NUM_LIT> && INTVAL ( index ) > - <NUM_LIT> && ( INTVAL ( index ) & <NUM_LIT> ) == <NUM_LIT> ) ; if ( TARGET_NEON && VALID_NEON_DREG_MODE ( mode ) ) return ( code == CONST_INT && INTVAL ( index ) < <NUM_LIT> && INTVAL ( index ) > - <NUM_LIT> && ( INTVAL ( index ) & <NUM_LIT> ) == <NUM_LIT> ) ; if ( TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE ( mode ) ) return ( code == CONST_INT && INTVAL ( index ) < <NUM_LIT> && INTVAL ( index ) > - <NUM_LIT> && ( INTVAL ( index ) & <NUM_LIT> ) == <NUM_LIT> ) ; if ( arm_address_register_rtx_p ( index , strict_p ) && ( GET_MODE_SIZE ( mode ) <= <NUM_LIT> ) ) return <NUM_LIT> ;

if ( mode == DImode || mode == DFmode ) {


<s> if ( TARGET_NEON && VALID_NEON_QREG_MODE ( mode ) ) return ( code == CONST_INT && INTVAL ( index ) < <NUM_LIT> && INTVAL ( index ) > - <NUM_LIT> && ( INTVAL ( index ) & <NUM_LIT> ) == <NUM_LIT> ) ; if ( TARGET_NEON && VALID_NEON_DREG_MODE ( mode ) ) return ( code == CONST_INT && INTVAL ( index ) < <NUM_LIT> && INTVAL ( index ) > - <NUM_LIT> && ( INTVAL ( index ) & <NUM_LIT> ) == <NUM_LIT> ) ; if ( TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE ( mode ) ) return ( code == CONST_INT && INTVAL ( index ) < <NUM_LIT> && INTVAL ( index ) > - <NUM_LIT> && ( INTVAL ( index ) & <NUM_LIT> ) == <NUM_LIT> ) ; if ( arm_address_register_rtx_p ( index , strict_p ) && ( GET_MODE_SIZE ( mode ) <= <NUM_LIT> ) ) return <NUM_LIT> ; if ( mode == DImode || mode == DFmode ) { if ( code == CONST_INT ) { HOST_WIDE_INT val = INTVAL ( index ) ; if ( TARGET_LDRD ) return val > - <NUM_LIT> && val < <NUM_LIT> ; else return val > - <NUM_LIT> && val < <NUM_LIT> ; } return TARGET_LDRD && arm_address_register_rtx_p ( index , strict_p ) ; } if ( GET_MODE_SIZE ( mode ) <= <NUM_LIT> && ! ( arm_arch4 && ( mode == HImode || mode == HFmode || ( mode == QImode && outer == SIGN_EXTEND ) ) ) ) { if ( code == MULT ) { rtx xiop0 = XEXP ( index , <NUM_LIT> ) ; rtx xiop1 = XEXP ( index , <NUM_LIT> ) ; return ( ( arm_address_register_rtx_p ( xiop0 , strict_p ) && power_of_two_operand ( xiop1 , SImode ) ) || ( arm_address_register_rtx_p ( xiop1 , strict_p ) && power_of_two_operand ( xiop0 , SImode ) ) ) ; } else if ( code == LSHIFTRT || code == ASHIFTRT || code == ASHIFT || code == ROTATERT ) { rtx op = XEXP ( index , <NUM_LIT> ) ; return ( arm_address_register_rtx_p ( XEXP ( index , <NUM_LIT> ) , strict_p ) && CONST_INT_P ( op ) && INTVAL ( op ) > <NUM_LIT> && INTVAL ( op ) <= <NUM_LIT> ) ; } }


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


<s> add_libcall ( libcall_htab , optab_libfunc ( sdiv_optab , SFmode ) ) ; add_libcall ( libcall_htab , optab_libfunc ( smul_optab , SFmode ) ) ; add_libcall ( libcall_htab , optab_libfunc ( neg_optab , SFmode ) ) ; add_libcall ( libcall_htab , optab_libfunc ( sub_optab , SFmode ) ) ; add_libcall ( libcall_htab , optab_libfunc ( eq_optab , SFmode ) ) ; add_libcall ( libcall_htab , optab_libfunc ( lt_optab , SFmode ) ) ; add_libcall ( libcall_htab , optab_libfunc ( le_optab , SFmode ) ) ; add_libcall ( libcall_htab , optab_libfunc ( ge_optab , SFmode ) ) ; add_libcall ( libcall_htab , optab_libfunc ( gt_optab , SFmode ) ) ; add_libcall ( libcall_htab , optab_libfunc ( unord_optab , 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 ) ) ; add_libcall ( libcall_htab , optab_libfunc ( sub_optab , DFmode ) ) ; add_libcall ( libcall_htab , optab_libfunc ( eq_optab , DFmode ) ) ; add_libcall ( libcall_htab , optab_libfunc ( lt_optab , DFmode ) ) ; add_libcall ( libcall_htab , optab_libfunc ( le_optab , DFmode ) ) ; add_libcall ( libcall_htab , optab_libfunc ( ge_optab , DFmode ) ) ;

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


<s> if ( TARGET_AAPCS_BASED && arm_pcs_default != ARM_PCS_AAPCS && GET_MODE_CLASS ( mode ) == MODE_FLOAT ) {

if ( arm_libcall_uses_aapcs_base ( libcall ) ) return gen_rtx_REG ( mode , ARG_REGISTER ( <NUM_LIT> ) ) ;


<s> if ( TARGET_AAPCS_BASED && arm_pcs_default != ARM_PCS_AAPCS && GET_MODE_CLASS ( mode ) == MODE_FLOAT ) { if ( arm_libcall_uses_aapcs_base ( libcall ) ) return gen_rtx_REG ( mode , ARG_REGISTER ( <NUM_LIT> ) ) ; } return arm_libcall_value_1 ( mode ) ;


<s> if ( TARGET_AAPCS_BASED ) return aapcs_libcall_value ( mode ) ; else if ( TARGET_IWMMXT_ABI && arm_vector_mode_supported_p ( mode ) ) return gen_rtx_REG ( mode , FIRST_IWMMXT_REGNUM ) ;

else return gen_rtx_REG ( mode , ARG_REGISTER ( <NUM_LIT> ) ) ;


<s> else if ( TARGET_IWMMXT_ABI && arm_vector_mode_supported_p ( mode ) ) return gen_rtx_REG ( mode , FIRST_IWMMXT_REGNUM ) ; else return gen_rtx_REG ( mode , ARG_REGISTER ( <NUM_LIT> ) ) ;


<s> rtx arm_load_function_descriptor ( rtx funcdesc ) { rtx fnaddr_reg = gen_reg_rtx ( Pmode ) ; rtx pic_reg = gen_rtx_REG ( Pmode , FDPIC_REGNUM ) ;

rtx fnaddr = gen_rtx_MEM ( Pmode , funcdesc ) ;


<s> rtx fdpic_reg = gen_rtx_REG ( Pmode , FDPIC_REGNUM ) ; rtx initial_fdpic_reg = get_hard_reg_initial_val ( Pmode , FDPIC_REGNUM ) ; emit_insn ( gen_load_tp_soft_fdpic ( ) ) ; emit_insn ( gen_restore_pic_register_after_call ( fdpic_reg , initial_fdpic_reg ) ) ;


<s> static bool arm_macro_fusion_p ( void ) {


<s> int arm_max_conditional_execute ( void ) { return max_insns_skipped ;


<s> int arm_max_const_double_inline_cost ( ) { return ( ( optimize_size || arm_ld_sched ) ? <NUM_LIT> : <NUM_LIT> ) ;


<s> else { if ( GET_MODE_SIZE ( mode ) < <NUM_LIT> ) return <NUM_LIT> ; else return ( ( <NUM_LIT> * GET_MODE_SIZE ( mode ) ) * ( rclass == LO_REGS ? <NUM_LIT> : <NUM_LIT> ) ) ;


<s> } if ( VECTOR_MODE_P ( mode ) ) * cost += current_tune -> addr_mode_costs -> vector [ op_type ] ; else if ( FLOAT_MODE_P ( mode ) ) * cost += current_tune -> addr_mode_costs -> fp [ op_type ] ; else * cost += current_tune -> addr_mode_costs -> integer [ op_type ] ; } if ( speed_p ) { if ( FLOAT_MODE_P ( mode ) ) { if ( GET_MODE_SIZE ( mode ) == <NUM_LIT> ) * cost += extra_cost -> ldst . loadd ; else * cost += extra_cost -> ldst . loadf ; } else if ( VECTOR_MODE_P ( mode ) ) * cost += extra_cost -> ldst . loadv ; else { if ( GET_MODE_SIZE ( mode ) == <NUM_LIT> ) * cost += extra_cost -> ldst . ldrd ; else * cost += extra_cost -> ldst . load ; } }


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


<s> if ( GET_MODE_CLASS ( mode1 ) == GET_MODE_CLASS ( mode2 ) ) return true ; if ( ( TARGET_NEON && ( VALID_NEON_DREG_MODE ( mode1 ) || VALID_NEON_QREG_MODE ( mode1 ) || VALID_NEON_STRUCT_MODE ( mode1 ) ) && ( VALID_NEON_DREG_MODE ( mode2 ) || VALID_NEON_QREG_MODE ( mode2 ) || VALID_NEON_STRUCT_MODE ( mode2 ) ) ) || ( TARGET_HAVE_MVE && ( VALID_MVE_MODE ( mode1 ) || VALID_MVE_STRUCT_MODE ( mode1 ) ) && ( VALID_MVE_MODE ( mode2 ) || VALID_MVE_STRUCT_MODE ( mode2 ) ) ) ) return true ; return false ;


<s> if ( TARGET_HAVE_MVE && ( mode == E_V8QImode || mode == E_V4QImode || mode == E_V4HImode ) ) return LO_REGS ; return MODE_BASE_REG_REG_CLASS ( mode ) ;


<s> switch ( GET_MODE_NUNITS ( mode ) ) { case <NUM_LIT> : return V16BImode ; case <NUM_LIT> : return V8BImode ; case <NUM_LIT> : return V4BImode ; } return opt_machine_mode ( ) ;


<s> switch ( GET_MODE_NUNITS ( mode ) ) { case <NUM_LIT> : return V16BImode ; case <NUM_LIT> : return V8BImode ;


<s> static bool arm_must_pass_in_stack ( const function_arg_info & arg ) { if ( TARGET_AAPCS_BASED ) return must_pass_in_stack_var_size ( arg ) ;

else return must_pass_in_stack_var_size_or_pad ( arg ) ;


<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 ; int ret = <NUM_LIT> ; int ret2 = <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> ; else ret = - <NUM_LIT> ; } else if ( TREE_CODE ( field ) == FIELD_DECL && DECL_BIT_FIELD_TYPE ( field ) && TYPE_ALIGN ( DECL_BIT_FIELD_TYPE ( field ) ) > PARM_BOUNDARY ) ret2 = <NUM_LIT> ; if ( ret2 ) return <NUM_LIT> ; return ret ;


<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 ; int ret = <NUM_LIT> ; int ret2 = <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 ( 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 && TARGET_HARD_FLOAT && LAST_VFP_REGNUM > LAST_LO_VFP_REGNUM ) error ( <STR_LIT> ) ;


<s> if ( TARGET_THUMB1 ) { 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> 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> : TARGET_THUMB_P ( flags ) ? <STR_LIT> : <STR_LIT> ) ;

if ( ptr -> x_arm_arch_string ) fprintf ( file , <STR_LIT> , indent , <STR_LIT> , ptr -> x_arm_arch_string ) ;


<s> fprintf ( file , <STR_LIT> , indent , <STR_LIT> , TARGET_THUMB2_P ( flags ) ? <STR_LIT> : TARGET_THUMB_P ( flags ) ? <STR_LIT> : <STR_LIT> ) ; if ( ptr -> x_arm_arch_string ) fprintf ( file , <STR_LIT> , indent , <STR_LIT> , ptr -> x_arm_arch_string ) ; if ( ptr -> x_arm_cpu_string ) fprintf ( file , <STR_LIT> , indent , <STR_LIT> , ptr -> x_arm_cpu_string ) ; if ( ptr -> x_arm_tune_string ) fprintf ( file , <STR_LIT> , indent , <STR_LIT> , ptr -> x_arm_tune_string ) ; fprintf ( file , <STR_LIT> , indent , <STR_LIT> , fpu_name ) ;


<s> arm_configure_build_target ( & arm_active_target , ptr , false ) ;


<s> ptr -> x_arm_arch_string = opts -> x_arm_arch_string ; ptr -> x_arm_cpu_string = opts -> x_arm_cpu_string ; ptr -> x_arm_tune_string = opts -> x_arm_tune_string ;


<s> static void arm_option_save ( struct cl_target_option * ptr , struct gcc_options * opts ) { ptr -> x_arm_arch_string = opts -> x_arm_arch_string ;

ptr -> x_arm_cpu_string = opts -> x_arm_cpu_string ;


<s> memcpy ( reg_alloc_order , arm_reg_alloc_order , sizeof ( reg_alloc_order ) ) ;

if ( TARGET_THUMB ) memcpy ( reg_alloc_order , thumb_core_reg_alloc_order , sizeof ( thumb_core_reg_alloc_order ) ) ;


<s> else if ( GET_CODE ( x ) == UNSPEC && XINT ( x , <NUM_LIT> ) == UNSPEC_GOTSYM_OFF ) { assemble_name ( fp , <STR_LIT> ) ; if ( GOT_PCREL ) fputs ( <STR_LIT> , fp ) ; fputs ( <STR_LIT> , fp ) ; output_addr_const ( fp , XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ) ; fputc ( ')' , fp ) ; return TRUE ; }

else if ( GET_CODE ( x ) == UNSPEC && XINT ( x , <NUM_LIT> ) == UNSPEC_SYMBOL_OFFSET ) {


<s> output_addr_const ( file , x ) ; fputs ( <STR_LIT> , file ) ;


<s> static void arm_output_dwarf_dtprel ( FILE * file , int size , rtx x ) { gcc_assert ( size == <NUM_LIT> ) ; fputs ( <STR_LIT> , file ) ;


<s> if ( prologue ) fputs ( <STR_LIT> , f ) ; else { if ( ! ( flag_unwind_tables || crtl -> uses_eh_lsda ) && ( TREE_NOTHROW ( current_function_decl ) || crtl -> all_throwers_are_sibcalls ) ) fputs ( <STR_LIT> , f ) ;


<s> void arm_output_fn_unwind ( FILE * f , bool prologue ) {

if ( arm_except_unwind_info ( & global_options ) != UI_TARGET ) return ;


<s> cfun -> machine -> return_used_this_function = <NUM_LIT> ; } else { offsets = arm_get_frame_offsets ( ) ;

gcc_assert ( ! use_return_insn ( FALSE , NULL ) || ( cfun -> machine -> return_used_this_function != <NUM_LIT> ) || offsets -> saved_regs == offsets -> outgoing_args || frame_pointer_needed ) ;


<s> } cfun -> machine -> return_used_this_function = <NUM_LIT> ; } else { offsets = arm_get_frame_offsets ( ) ;


<s> if ( IS_CMSE_ENTRY ( func_type ) ) asm_fprintf ( f , <STR_LIT> ) ; asm_fprintf ( f , <STR_LIT> , ( HOST_WIDE_INT ) crtl -> args . size , crtl -> args . pretend_args_size , ( HOST_WIDE_INT ) get_frame_size ( ) ) ; asm_fprintf ( f , <STR_LIT> , frame_pointer_needed , cfun -> machine -> uses_anonymous_args ) ; if ( cfun -> machine -> lr_save_eliminated ) asm_fprintf ( f , <STR_LIT> ) ;

if ( crtl -> calls_eh_return ) asm_fprintf ( f , <STR_LIT> ) ;


<s> 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> ) ; asm_fprintf ( f , <STR_LIT> , ( HOST_WIDE_INT ) crtl -> args . size , crtl -> args . pretend_args_size , ( HOST_WIDE_INT ) get_frame_size ( ) ) ; asm_fprintf ( f , <STR_LIT> , frame_pointer_needed , cfun -> machine -> uses_anonymous_args ) ;

if ( cfun -> machine -> lr_save_eliminated ) asm_fprintf ( f , <STR_LIT> ) ;


<s> else { sprintf ( templ , <STR_LIT> ) ; output_asm_insn ( templ , operands ) ; } return <STR_LIT> ; } if ( ( opmode == DImode ) && ( shift > <NUM_LIT> ) ) { sprintf ( templ , <STR_LIT> , insn_name , <NUM_LIT> ) ; output_asm_insn ( templ , operands ) ; sprintf ( templ , <STR_LIT> , insn_name , shift - <NUM_LIT> ) ; output_asm_insn ( templ , operands ) ; } else { sprintf ( templ , <STR_LIT> , insn_name , shift ) ; output_asm_insn ( templ , operands ) ; } return <STR_LIT> ;


<s> } mask >>= <NUM_LIT> ; } gcc_assert ( i < units ) ; { switch ( GET_MODE ( operands [ <NUM_LIT> ] ) ) { case E_V8QImode : sprintf ( templ , <STR_LIT> , i ) ; break ; case E_V4HImode : sprintf ( templ , <STR_LIT> , i ) ; break ; case E_V2SImode : sprintf ( templ , <STR_LIT> , i ) ; break ; default : gcc_unreachable ( ) ;


<s> rtx reg ; rtx offset ; rtx wcgr ; rtx sum ;

if ( ! MEM_P ( operands [ <NUM_LIT> ] ) || GET_CODE ( sum = XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) != PLUS || ! REG_P ( reg = XEXP ( sum , <NUM_LIT> ) ) || ! CONST_INT_P ( offset = XEXP ( sum , <NUM_LIT> ) ) || ( ( INTVAL ( offset ) < <NUM_LIT> ) && ( INTVAL ( offset ) > - <NUM_LIT> ) ) ) return <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> void arm_output_multireg_pop ( rtx * operands , bool return_pc , rtx cond , bool reverse , bool update ) { int i ; char pattern [ <NUM_LIT> ] ; int offset ; const char * conditional ; int num_saves = XVECLEN ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ; unsigned int regno ; unsigned int regno_base = REGNO ( operands [ <NUM_LIT> ] ) ; bool interrupt_p = IS_INTERRUPT ( arm_current_func_type ( ) ) ; offset = <NUM_LIT> ; offset += update ? <NUM_LIT> : <NUM_LIT> ; offset += return_pc ? <NUM_LIT> : <NUM_LIT> ; for ( i = offset ; i < num_saves ; i ++ ) { regno = REGNO ( XEXP ( XVECEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> , i ) , <NUM_LIT> ) ) ; gcc_assert ( ( regno != SP_REGNUM ) || ( regno_base == SP_REGNUM ) ) ; if ( regno == regno_base ) gcc_assert ( ! update ) ; } conditional = reverse ? <STR_LIT> : <STR_LIT> ; if ( ( regno_base == SP_REGNUM ) && update && ! ( interrupt_p && return_pc ) ) sprintf ( pattern , <STR_LIT> , conditional ) ; else { if ( regno_base == SP_REGNUM ) sprintf ( pattern , <STR_LIT> , conditional ) ; else if ( update ) sprintf ( pattern , <STR_LIT> , conditional ) ; else sprintf ( pattern , <STR_LIT> , conditional ) ; strcat ( pattern , reg_names [ regno_base ] ) ; if ( update ) strcat ( pattern , <STR_LIT> ) ;


<s> if ( shift ) { if ( val != - <NUM_LIT> ) operands [ <NUM_LIT> ] = GEN_INT ( val ) ; sprintf ( pattern , <STR_LIT> , shift , c ) ; }

else sprintf ( pattern , <STR_LIT> , c ) ;


<s> if ( ! CONST_INT_P ( x ) ) fputs ( <STR_LIT> , asm_out_file ) ;


<s> static void arm_override_options_after_change_1 ( struct gcc_options * opts , struct gcc_options * opts_set ) {

if ( opts -> x_flag_align_functions && ! opts_set -> x_str_align_functions ) opts -> x_str_align_functions = TARGET_THUMB_P ( opts -> x_target_flags ) && opts -> x_optimize_size ? <STR_LIT> : <STR_LIT> ;


<s> if ( TARGET_AAPCS_BASED && BYTES_BIG_ENDIAN ) { if ( type ) { if ( ( AGGREGATE_TYPE_P ( type ) || TREE_CODE ( type ) == COMPLEX_TYPE || FIXED_POINT_TYPE_P ( type ) ) && int_size_in_bytes ( type ) <= <NUM_LIT> ) return true ; }


<s> if ( type ) { if ( ( AGGREGATE_TYPE_P ( type ) || TREE_CODE ( type ) == COMPLEX_TYPE || FIXED_POINT_TYPE_P ( type ) ) && int_size_in_bytes ( type ) <= <NUM_LIT> ) return true ; }


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


<s> static bool arm_pass_by_reference ( cumulative_args_t , const function_arg_info & arg ) { return arg . type && TREE_CODE ( TYPE_SIZE ( arg . type ) ) != INTEGER_CST ;


if ( TREE_VALUE ( attr ) == NULL_TREE || TREE_CODE ( TREE_VALUE ( attr ) ) != STRING_CST ) return ARM_PCS_UNKNOWN ;


<s> arg = TREE_STRING_POINTER ( TREE_VALUE ( attr ) ) ;

for ( ptr = pcs_attribute_args ; ptr -> arg != NULL ; ptr ++ ) if ( streq ( arg , ptr -> arg ) ) return ptr -> value ;


<s> gcc_assert ( flag_pic ) ; bool is_readonly = false ; bool info_known = false ; if ( TARGET_FDPIC && SYMBOL_REF_P ( orig ) && ! SYMBOL_REF_FUNCTION_P ( orig ) ) info_known = arm_is_segment_info_known ( orig , & is_readonly ) ; if ( TARGET_FDPIC && SYMBOL_REF_P ( orig ) && ! SYMBOL_REF_FUNCTION_P ( orig ) && ! info_known ) { rtx pic_reg = gen_rtx_REG ( Pmode , FDPIC_REGNUM ) ; insn = calculate_pic_address_constant ( reg , pic_reg , orig ) ; }

else if ( TARGET_FDPIC && SYMBOL_REF_P ( orig ) && ( SYMBOL_REF_FUNCTION_P ( orig ) || ! is_readonly ) ) {


<s> void arm_poke_function_name ( FILE * stream , const char * name ) { unsigned long alignlength ; unsigned long length ; rtx x ; length = strlen ( name ) + <NUM_LIT> ; alignlength = ROUND_UP_WORD ( length ) ; ASM_OUTPUT_ASCII ( stream , name , length ) ; ASM_OUTPUT_ALIGN ( stream , <NUM_LIT> ) ; x = GEN_INT ( ( unsigned HOST_WIDE_INT ) <NUM_LIT> + alignlength ) ; assemble_aligned_integer ( UNITS_PER_WORD , x ) ;


<s> unsigned long length ; rtx x ; length = strlen ( name ) + <NUM_LIT> ; alignlength = ROUND_UP_WORD ( length ) ; ASM_OUTPUT_ASCII ( stream , name , length ) ; ASM_OUTPUT_ALIGN ( stream , <NUM_LIT> ) ; x = GEN_INT ( ( unsigned HOST_WIDE_INT ) <NUM_LIT> + alignlength ) ;

assemble_aligned_integer ( UNITS_PER_WORD , x ) ;


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


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


<s> static reg_class_t arm_preferred_reload_class ( rtx x ATTRIBUTE_UNUSED , reg_class_t rclass ) {


<s> static reg_class_t arm_preferred_reload_class ( rtx x ATTRIBUTE_UNUSED , reg_class_t rclass ) { if ( TARGET_32BIT ) return rclass ; else { if ( rclass == GENERAL_REGS ) return LO_REGS ; else return rclass ; }


<s> if ( TARGET_THUMB2 && rclass == GENERAL_REGS ) return LO_REGS ; else return NO_REGS ;


<s> static reg_class_t arm_preferred_rename_class ( reg_class_t rclass ) { if ( TARGET_THUMB2 && rclass == GENERAL_REGS ) return LO_REGS ;


<s> case E_HImode : return TARGET_NEON_VECTORIZE_DOUBLE ? V4HImode : V8HImode ; case E_QImode : return TARGET_NEON_VECTORIZE_DOUBLE ? V8QImode : V16QImode ; case E_DImode : if ( ! TARGET_NEON_VECTORIZE_DOUBLE ) return V2DImode ; break ; default : ; } if ( TARGET_REALLY_IWMMXT ) switch ( mode ) { case E_SImode : return V2SImode ; case E_HImode : return V4HImode ;