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

rtx addr = plus_constant ( Pmode , gen_rtx_LABEL_REF ( VOIDmode , minipool_vector_label ) , this_fix -> minipool -> offset ) ;


<s> static const enum isa_feature fpu_bitlist [ ] = { ISA_ALL_FPU_INTERNAL , isa_nobit } ; arm_initialize_isa ( isa_all_fpubits , fpu_bitlist ) ; for ( unsigned int i = <NUM_LIT> ; i < TARGET_FPU_auto ; i ++ ) { arm_initialize_isa ( fpubits , all_fpus [ i ] . isa_bits ) ; bitmap_and_compl ( tmpset , isa_all_fpubits , fpubits ) ; bitmap_clear ( isa_all_fpubits ) ; bitmap_copy ( isa_all_fpubits , tmpset ) ; } if ( ! bitmap_empty_p ( isa_all_fpubits ) ) { fprintf ( stderr , <STR_LIT> <STR_LIT> <STR_LIT> ) ; ASSERT_TRUE ( bitmap_empty_p ( isa_all_fpubits ) ) ; }


<s> auto_sbitmap tmpset ( isa_num_bits ) ; static const enum isa_feature fpu_bitlist [ ] = { ISA_ALL_FPU_INTERNAL , isa_nobit } ; arm_initialize_isa ( isa_all_fpubits , fpu_bitlist ) ; for ( unsigned int i = <NUM_LIT> ; i < TARGET_FPU_auto ; i ++ ) { arm_initialize_isa ( fpubits , all_fpus [ i ] . isa_bits ) ; bitmap_and_compl ( tmpset , isa_all_fpubits , fpubits ) ; bitmap_clear ( isa_all_fpubits ) ;

bitmap_copy ( isa_all_fpubits , tmpset ) ;


<s> if ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL ( x ) != <NUM_LIT> ) { if ( arm_disable_literal_pool ) sorry ( <STR_LIT> <STR_LIT> ) ; return true ; }

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


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


<s> emit_block_move ( m_tramp , assemble_trampoline_template ( ) , GEN_INT ( TRAMPOLINE_SIZE ) , BLOCK_OP_NORMAL ) ; mem = adjust_address ( m_tramp , SImode , TARGET_32BIT ? <NUM_LIT> : <NUM_LIT> ) ; emit_move_insn ( mem , chain_value ) ; mem = adjust_address ( m_tramp , SImode , TARGET_32BIT ? <NUM_LIT> : <NUM_LIT> ) ; fnaddr = XEXP ( DECL_RTL ( fndecl ) , <NUM_LIT> ) ; emit_move_insn ( mem , fnaddr ) ; a_tramp = XEXP ( m_tramp , <NUM_LIT> ) ;

emit_library_call ( gen_rtx_SYMBOL_REF ( Pmode , <STR_LIT> ) , LCT_NORMAL , VOIDmode , a_tramp , Pmode , plus_constant ( Pmode , a_tramp , TRAMPOLINE_SIZE ) , Pmode ) ;


<s> int code_int ; machine_mode mode = ( GET_MODE ( * op1 ) == VOIDmode ) ? GET_MODE ( * op2 ) : GET_MODE ( * op1 ) ; gcc_assert ( GET_MODE ( * op1 ) != VOIDmode || GET_MODE ( * op2 ) != VOIDmode ) ; if ( code == UNEQ || code == LTGT ) return false ; code_int = ( int ) code ; arm_canonicalize_comparison ( & code_int , op1 , op2 , <NUM_LIT> ) ; PUT_CODE ( * comparison , ( enum rtx_code ) code_int ) ; switch ( mode ) { case E_SImode : if ( ! arm_add_operand ( * op1 , mode ) ) * op1 = force_reg ( mode , * op1 ) ; if ( ! arm_add_operand ( * op2 , mode ) ) * op2 = force_reg ( mode , * op2 ) ; return true ; case E_DImode : if ( ! cmpdi_operand ( * op1 , mode ) ) * op1 = force_reg ( mode , * op1 ) ; if ( ! cmpdi_operand ( * op2 , mode ) ) * op2 = force_reg ( mode , * op2 ) ; return true ; case E_HFmode : if ( ! TARGET_VFP_FP16INST ) break ; mode = SFmode ; * op1 = convert_to_mode ( mode , * op1 , <NUM_LIT> ) ; * op2 = convert_to_mode ( mode , * op2 , <NUM_LIT> ) ; case E_SFmode : case E_DFmode : if ( ! vfp_compare_operand ( * op1 , mode ) ) * op1 = force_reg ( mode , * op1 ) ; if ( ! vfp_compare_operand ( * op2 , mode ) ) * op2 = force_reg ( mode , * op2 ) ; return true ; default : break ; } return false ;


<s> else if ( ! strncmp ( q , <STR_LIT> , <NUM_LIT> ) ) opts -> x_target_flags &= ~ MASK_THUMB ; else if ( ! strncmp ( q , <STR_LIT> , <NUM_LIT> ) ) { int fpu_index ; if ( ! opt_enum_arg_to_value ( OPT_mfpu_ , q + <NUM_LIT> , & fpu_index , CL_TARGET ) ) { error ( <STR_LIT> , q ) ; return false ; } if ( fpu_index == TARGET_FPU_auto ) { sorry ( <STR_LIT> ) ; return false ; } opts -> x_arm_fpu_index = ( enum fpu_type ) fpu_index ; } else if ( ! strncmp ( q , <STR_LIT> , <NUM_LIT> ) ) { char * arch = q + <NUM_LIT> ; const arch_option * arm_selected_arch = arm_parse_arch_option_name ( all_architectures , <STR_LIT> , arch ) ; if ( ! arm_selected_arch ) { error ( <STR_LIT> , q ) ; return false ; } opts -> x_arm_arch_string = xstrndup ( arch , strlen ( arch ) ) ;


<s> dest = gen_rtx_ZERO_EXTRACT ( SImode , scratch_reg , rtx16 , rtx16 ) ; if ( mask ) emit_insn ( gen_rtx_SET ( dest , gen_int_mode ( mask , SImode ) ) ) ; emit_insn ( gen_andsi3 ( cleared_reg , cleared_reg , scratch_reg ) ) ; } if ( saved_clearing ) emit_move_insn ( clearing_reg , saved_clearing_reg ) ; if ( clearing_regno <= maxregno && bitmap_bit_p ( to_clear_bitmap , clearing_regno ) ) { emit_move_insn ( clearing_reg , const0_rtx ) ; emit_use ( clearing_reg ) ; bitmap_clear_bit ( to_clear_bitmap , clearing_regno ) ; } for ( regno = minregno ; regno <= maxregno ; regno ++ ) { if ( ! bitmap_bit_p ( to_clear_bitmap , regno ) ) continue ; if ( IS_VFP_REGNUM ( regno ) ) { if ( TARGET_VFP_DOUBLE && VFP_REGNO_OK_FOR_DOUBLE ( regno ) && bitmap_bit_p ( to_clear_bitmap , regno + <NUM_LIT> ) ) { emit_move_insn ( gen_rtx_REG ( DFmode , regno ) , CONST1_RTX ( DFmode ) ) ; emit_use ( gen_rtx_REG ( DFmode , regno ) ) ; regno ++ ; } else { emit_move_insn ( gen_rtx_REG ( SFmode , regno ) , CONST1_RTX ( SFmode ) ) ; emit_use ( gen_rtx_REG ( SFmode , regno ) ) ; } } else { emit_move_insn ( gen_rtx_REG ( SImode , regno ) , clearing_reg ) ;

emit_use ( gen_rtx_REG ( SImode , regno ) ) ;


<s> if ( saved_clearing ) emit_move_insn ( clearing_reg , saved_clearing_reg ) ; if ( clearing_regno <= maxregno && bitmap_bit_p ( to_clear_bitmap , clearing_regno ) ) { emit_move_insn ( clearing_reg , const0_rtx ) ; emit_use ( clearing_reg ) ; bitmap_clear_bit ( to_clear_bitmap , clearing_regno ) ; } for ( regno = minregno ; regno <= maxregno ; regno ++ ) { if ( ! bitmap_bit_p ( to_clear_bitmap , regno ) ) continue ; if ( IS_VFP_REGNUM ( regno ) ) { if ( TARGET_VFP_DOUBLE && VFP_REGNO_OK_FOR_DOUBLE ( regno ) && bitmap_bit_p ( to_clear_bitmap , regno + <NUM_LIT> ) ) { emit_move_insn ( gen_rtx_REG ( DFmode , regno ) , CONST1_RTX ( DFmode ) ) ; emit_use ( gen_rtx_REG ( DFmode , regno ) ) ; regno ++ ; } else { emit_move_insn ( gen_rtx_REG ( SFmode , regno ) , CONST1_RTX ( SFmode ) ) ; emit_use ( gen_rtx_REG ( SFmode , regno ) ) ; } } else { emit_move_insn ( gen_rtx_REG ( SImode , regno ) , clearing_reg ) ;


<s> bitmap_set_range ( to_clear_bitmap , R0_REGNUM , NUM_ARG_REGS ) ; if ( TARGET_HARD_FLOAT_ABI ) { auto_sbitmap float_bitmap ( maxregno + <NUM_LIT> ) ; bitmap_clear ( float_bitmap ) ; bitmap_set_range ( float_bitmap , FIRST_VFP_REGNUM , D7_VFP_REGNUM - FIRST_VFP_REGNUM + <NUM_LIT> ) ; bitmap_ior ( to_clear_bitmap , to_clear_bitmap , float_bitmap ) ; } address = RTVEC_ELT ( XVEC ( unspec , <NUM_LIT> ) , <NUM_LIT> ) ; gcc_assert ( MEM_P ( address ) ) ; gcc_assert ( REG_P ( XEXP ( address , <NUM_LIT> ) ) ) ; address_regnum = REGNO ( XEXP ( address , <NUM_LIT> ) ) ; if ( address_regnum < R0_REGNUM + NUM_ARG_REGS ) bitmap_clear_bit ( to_clear_bitmap , address_regnum ) ; set_block_for_insn ( insn , bb ) ; df_set_flags ( DF_DEFER_INSN_RESCAN ) ; start_sequence ( ) ; emit_insn ( gen_blockage ( ) ) ; fntype = TREE_TYPE ( MEM_EXPR ( address ) ) ; arm_init_cumulative_args ( & args_so_far_v , fntype , NULL_RTX , NULL_TREE ) ; args_so_far = pack_cumulative_args ( & args_so_far_v ) ; FOREACH_FUNCTION_ARGS ( fntype , arg_type , args_iter ) { rtx arg_rtx ; uint64_t to_clear_args_mask ; machine_mode arg_mode = TYPE_MODE ( arg_type ) ; if ( VOID_TYPE_P ( arg_type ) ) continue ; if ( ! first_param ) arm_function_arg_advance ( args_so_far , arg_mode , arg_type , true ) ; arg_rtx = arm_function_arg ( args_so_far , arg_mode , arg_type , true ) ; gcc_assert ( REG_P ( arg_rtx ) ) ; to_clear_args_mask = compute_not_to_clear_mask ( arg_type , arg_rtx , REGNO ( arg_rtx ) , & padding_bits_to_clear [ <NUM_LIT> ] ) ; if ( to_clear_args_mask ) { for ( regno = R0_REGNUM ; regno <= maxregno ; regno ++ ) { if ( to_clear_args_mask & ( <NUM_LIT> << regno ) ) bitmap_clear_bit ( to_clear_bitmap , regno ) ;


<s> auto_sbitmap to_clear_bitmap ( maxregno + <NUM_LIT> ) ; rtx r1_reg , result_rtl , clearing_reg = NULL_RTX ; tree result_type ; bitmap_clear ( to_clear_bitmap ) ; bitmap_set_range ( to_clear_bitmap , R0_REGNUM , NUM_ARG_REGS ) ; bitmap_set_bit ( to_clear_bitmap , IP_REGNUM ) ; if ( TARGET_HARD_FLOAT ) { int float_bits = D7_VFP_REGNUM - FIRST_VFP_REGNUM + <NUM_LIT> ; bitmap_set_range ( to_clear_bitmap , FIRST_VFP_REGNUM , float_bits ) ; emit_use ( gen_rtx_REG ( SImode , IP_REGNUM ) ) ; bitmap_clear_bit ( to_clear_bitmap , IP_REGNUM ) ; emit_use ( gen_rtx_REG ( SImode , <NUM_LIT> ) ) ; bitmap_clear_bit ( to_clear_bitmap , <NUM_LIT> ) ; } for ( regno = NUM_ARG_REGS ; regno <= maxregno ; regno ++ ) { if ( IN_RANGE ( regno , FIRST_VFP_REGNUM , D7_VFP_REGNUM ) ) continue ; if ( IN_RANGE ( regno , IP_REGNUM , PC_REGNUM ) ) continue ; if ( call_used_regs [ regno ] ) bitmap_set_bit ( to_clear_bitmap , regno ) ; } result_type = TREE_TYPE ( DECL_RESULT ( current_function_decl ) ) ; if ( ! VOID_TYPE_P ( result_type ) ) { uint64_t to_clear_return_mask ; result_rtl = arm_function_value ( result_type , current_function_decl , <NUM_LIT> ) ; gcc_assert ( REG_P ( result_rtl ) ) ; to_clear_return_mask = compute_not_to_clear_mask ( result_type , result_rtl , <NUM_LIT> , & padding_bits_to_clear ) ; if ( to_clear_return_mask ) { gcc_assert ( ( unsigned ) maxregno < sizeof ( long long ) * __CHAR_BIT__ ) ; for ( regno = R0_REGNUM ; regno <= maxregno ; regno ++ ) { if ( to_clear_return_mask & ( <NUM_LIT> << regno ) ) bitmap_clear_bit ( to_clear_bitmap , regno ) ; } } } if ( padding_bits_to_clear != <NUM_LIT> ) { int to_clear_bitmap_size = SBITMAP_SIZE ( ( sbitmap ) to_clear_bitmap ) ; auto_sbitmap to_clear_arg_regs_bitmap ( to_clear_bitmap_size ) ; bitmap_clear ( to_clear_arg_regs_bitmap ) ; bitmap_set_range ( to_clear_arg_regs_bitmap , R1_REGNUM , NUM_ARG_REGS - <NUM_LIT> ) ; gcc_assert ( bitmap_subset_p ( to_clear_arg_regs_bitmap , to_clear_bitmap ) ) ; } clearing_reg = gen_rtx_REG ( SImode , TARGET_THUMB1 ? R0_REGNUM : LR_REGNUM ) ;


<s> bitmap_clear ( to_clear_bitmap ) ; bitmap_set_range ( to_clear_bitmap , R0_REGNUM , NUM_ARG_REGS ) ; bitmap_set_bit ( to_clear_bitmap , IP_REGNUM ) ; if ( TARGET_HARD_FLOAT ) { int float_bits = D7_VFP_REGNUM - FIRST_VFP_REGNUM + <NUM_LIT> ; bitmap_set_range ( to_clear_bitmap , FIRST_VFP_REGNUM , float_bits ) ; emit_use ( gen_rtx_REG ( SImode , IP_REGNUM ) ) ; bitmap_clear_bit ( to_clear_bitmap , IP_REGNUM ) ; emit_use ( gen_rtx_REG ( SImode , <NUM_LIT> ) ) ; bitmap_clear_bit ( to_clear_bitmap , <NUM_LIT> ) ; } for ( regno = NUM_ARG_REGS ; regno <= maxregno ; regno ++ ) { if ( IN_RANGE ( regno , FIRST_VFP_REGNUM , D7_VFP_REGNUM ) ) continue ; if ( IN_RANGE ( regno , IP_REGNUM , PC_REGNUM ) ) continue ; if ( call_used_regs [ regno ] ) bitmap_set_bit ( to_clear_bitmap , regno ) ; } result_type = TREE_TYPE ( DECL_RESULT ( current_function_decl ) ) ;


<s> gcc_assert ( REG_P ( arg_rtx ) ) ; to_clear_args_mask = compute_not_to_clear_mask ( arg_type , arg_rtx , REGNO ( arg_rtx ) , & padding_bits_to_clear [ <NUM_LIT> ] ) ; if ( to_clear_args_mask ) { for ( regno = R0_REGNUM ; regno <= maxregno ; regno ++ ) {

if ( to_clear_args_mask & ( <NUM_LIT> << regno ) ) bitmap_clear_bit ( to_clear_bitmap , regno ) ;


<s> CUMULATIVE_ARGS args_so_far_v ; cumulative_args_t args_so_far ; tree arg_type , fntype ; bool first_param = true ; function_args_iterator args_iter ; uint32_t padding_bits_to_clear [ <NUM_LIT> ] = { <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> } ; if ( ! NONDEBUG_INSN_P ( insn ) ) continue ; if ( ! CALL_P ( insn ) ) continue ; pat = PATTERN ( insn ) ; gcc_assert ( GET_CODE ( pat ) == PARALLEL && XVECLEN ( pat , <NUM_LIT> ) > <NUM_LIT> ) ; call = XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ; if ( GET_CODE ( call ) == SET ) call = SET_SRC ( call ) ; unspec = XEXP ( call , <NUM_LIT> ) ; if ( GET_CODE ( unspec ) != UNSPEC || XINT ( unspec , <NUM_LIT> ) != UNSPEC_NONSECURE_MEM ) continue ; bitmap_clear ( to_clear_bitmap ) ; bitmap_set_range ( to_clear_bitmap , R0_REGNUM , NUM_ARG_REGS ) ; if ( TARGET_HARD_FLOAT_ABI ) { auto_sbitmap float_bitmap ( maxregno + <NUM_LIT> ) ; bitmap_clear ( float_bitmap ) ; bitmap_set_range ( float_bitmap , FIRST_VFP_REGNUM , D7_VFP_REGNUM - FIRST_VFP_REGNUM + <NUM_LIT> ) ; bitmap_ior ( to_clear_bitmap , to_clear_bitmap , float_bitmap ) ; } address = RTVEC_ELT ( XVEC ( unspec , <NUM_LIT> ) , <NUM_LIT> ) ; gcc_assert ( MEM_P ( address ) ) ; gcc_assert ( REG_P ( XEXP ( address , <NUM_LIT> ) ) ) ; address_regnum = REGNO ( XEXP ( address , <NUM_LIT> ) ) ; if ( address_regnum < R0_REGNUM + NUM_ARG_REGS ) bitmap_clear_bit ( to_clear_bitmap , address_regnum ) ; set_block_for_insn ( insn , bb ) ; df_set_flags ( DF_DEFER_INSN_RESCAN ) ; start_sequence ( ) ; emit_insn ( gen_blockage ( ) ) ; fntype = TREE_TYPE ( MEM_EXPR ( address ) ) ; arm_init_cumulative_args ( & args_so_far_v , fntype , NULL_RTX , NULL_TREE ) ; args_so_far = pack_cumulative_args ( & args_so_far_v ) ; FOREACH_FUNCTION_ARGS ( fntype , arg_type , args_iter ) { rtx arg_rtx ; uint64_t to_clear_args_mask ; machine_mode arg_mode = TYPE_MODE ( arg_type ) ; if ( VOID_TYPE_P ( arg_type ) ) continue ; if ( ! first_param ) arm_function_arg_advance ( args_so_far , arg_mode , arg_type , true ) ; arg_rtx = arm_function_arg ( args_so_far , arg_mode , arg_type , true ) ; gcc_assert ( REG_P ( arg_rtx ) ) ; to_clear_args_mask = compute_not_to_clear_mask ( arg_type , arg_rtx , REGNO ( arg_rtx ) , & padding_bits_to_clear [ <NUM_LIT> ] ) ; if ( to_clear_args_mask ) { for ( regno = R0_REGNUM ; regno <= maxregno ; regno ++ ) {


<s> rtx address ; CUMULATIVE_ARGS args_so_far_v ; cumulative_args_t args_so_far ; tree arg_type , fntype ; bool first_param = true ; function_args_iterator args_iter ; uint32_t padding_bits_to_clear [ <NUM_LIT> ] = { <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> } ; if ( ! NONDEBUG_INSN_P ( insn ) ) continue ; if ( ! CALL_P ( insn ) ) continue ; pat = PATTERN ( insn ) ; gcc_assert ( GET_CODE ( pat ) == PARALLEL && XVECLEN ( pat , <NUM_LIT> ) > <NUM_LIT> ) ; call = XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ; if ( GET_CODE ( call ) == SET ) call = SET_SRC ( call ) ; unspec = XEXP ( call , <NUM_LIT> ) ; if ( GET_CODE ( unspec ) != UNSPEC || XINT ( unspec , <NUM_LIT> ) != UNSPEC_NONSECURE_MEM ) continue ; bitmap_clear ( to_clear_bitmap ) ; bitmap_set_range ( to_clear_bitmap , R0_REGNUM , NUM_ARG_REGS ) ; if ( TARGET_HARD_FLOAT_ABI ) { auto_sbitmap float_bitmap ( maxregno + <NUM_LIT> ) ; bitmap_clear ( float_bitmap ) ; bitmap_set_range ( float_bitmap , FIRST_VFP_REGNUM , D7_VFP_REGNUM - FIRST_VFP_REGNUM + <NUM_LIT> ) ; bitmap_ior ( to_clear_bitmap , to_clear_bitmap , float_bitmap ) ; } address = RTVEC_ELT ( XVEC ( unspec , <NUM_LIT> ) , <NUM_LIT> ) ; gcc_assert ( MEM_P ( address ) ) ; gcc_assert ( REG_P ( XEXP ( address , <NUM_LIT> ) ) ) ;

address_regnum = REGNO ( XEXP ( address , <NUM_LIT> ) ) ;


<s> } address = RTVEC_ELT ( XVEC ( unspec , <NUM_LIT> ) , <NUM_LIT> ) ; gcc_assert ( MEM_P ( address ) ) ; gcc_assert ( REG_P ( XEXP ( address , <NUM_LIT> ) ) ) ; address_regnum = REGNO ( XEXP ( address , <NUM_LIT> ) ) ; if ( address_regnum < R0_REGNUM + NUM_ARG_REGS ) bitmap_clear_bit ( to_clear_bitmap , address_regnum ) ; set_block_for_insn ( insn , bb ) ; df_set_flags ( DF_DEFER_INSN_RESCAN ) ; start_sequence ( ) ; emit_insn ( gen_blockage ( ) ) ; fntype = TREE_TYPE ( MEM_EXPR ( address ) ) ; arm_init_cumulative_args ( & args_so_far_v , fntype , NULL_RTX , NULL_TREE ) ; args_so_far = pack_cumulative_args ( & args_so_far_v ) ; FOREACH_FUNCTION_ARGS ( fntype , arg_type , args_iter ) { rtx arg_rtx ; uint64_t to_clear_args_mask ; machine_mode arg_mode = TYPE_MODE ( arg_type ) ; if ( VOID_TYPE_P ( arg_type ) ) continue ; if ( ! first_param ) arm_function_arg_advance ( args_so_far , arg_mode , arg_type , true ) ; arg_rtx = arm_function_arg ( args_so_far , arg_mode , arg_type , true ) ; gcc_assert ( REG_P ( arg_rtx ) ) ; to_clear_args_mask = compute_not_to_clear_mask ( arg_type , arg_rtx , REGNO ( arg_rtx ) , & padding_bits_to_clear [ <NUM_LIT> ] ) ; if ( to_clear_args_mask ) { for ( regno = R0_REGNUM ; regno <= maxregno ; regno ++ ) { if ( to_clear_args_mask & ( <NUM_LIT> << regno ) ) bitmap_clear_bit ( to_clear_bitmap , regno ) ; } } first_param = false ; } clearing_reg = XEXP ( address , <NUM_LIT> ) ; shift = gen_rtx_LSHIFTRT ( SImode , clearing_reg , const1_rtx ) ; emit_insn ( gen_rtx_SET ( clearing_reg , shift ) ) ; shift = gen_rtx_ASHIFT ( SImode , clearing_reg , const1_rtx ) ; emit_insn ( gen_rtx_SET ( clearing_reg , shift ) ) ; ip_reg = gen_rtx_REG ( SImode , IP_REGNUM ) ;


<s> const_rtx x = * iter ; if ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL ( x ) != <NUM_LIT> ) { if ( arm_disable_literal_pool ) sorry ( <STR_LIT> <STR_LIT> ) ;


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


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

if ( operands_ok_ldrd_strd ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , base , offset , false , load ) ) return true ;


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


<s> if ( GET_CODE ( mem ) == SUBREG ) return false ; gcc_assert ( MEM_P ( mem ) ) ; * offset = const0_rtx ; * align = MEM_ALIGN ( mem ) ; addr = XEXP ( mem , <NUM_LIT> ) ;

if ( ! arm_legitimate_address_p ( DImode , addr , reload_in_progress || reload_completed ) ) return false ;


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

return ( REG_P ( * base ) && CONST_INT_P ( * offset ) ) ;


<s> x = XVECEXP ( vals , <NUM_LIT> , i ) ; if ( ! CONSTANT_P ( x ) ) ++ n_var , one_var = i ; if ( i > <NUM_LIT> && ! rtx_equal_p ( x , XVECEXP ( vals , <NUM_LIT> , <NUM_LIT> ) ) ) all_same = false ; } if ( n_var == <NUM_LIT> ) { rtx constant = neon_make_constant ( vals ) ; if ( constant != NULL_RTX ) { emit_move_insn ( target , constant ) ; return ; } } if ( all_same && GET_MODE_SIZE ( inner_mode ) <= <NUM_LIT> ) { x = copy_to_mode_reg ( inner_mode , XVECEXP ( vals , <NUM_LIT> , <NUM_LIT> ) ) ; emit_insn ( gen_rtx_SET ( target , gen_vec_duplicate ( mode , x ) ) ) ; return ; } if ( n_var == <NUM_LIT> ) { rtx copy = copy_rtx ( vals ) ; rtx index = GEN_INT ( one_var ) ; XVECEXP ( copy , <NUM_LIT> , one_var ) = XVECEXP ( vals , <NUM_LIT> , ( one_var + <NUM_LIT> ) % n_elts ) ; neon_expand_vector_init ( target , copy ) ; x = copy_to_mode_reg ( inner_mode , XVECEXP ( vals , <NUM_LIT> , one_var ) ) ; switch ( mode ) { case E_V8QImode : emit_insn ( gen_neon_vset_lanev8qi ( target , x , target , index ) ) ; break ; case E_V16QImode : emit_insn ( gen_neon_vset_lanev16qi ( target , x , target , index ) ) ; break ; case E_V4HImode : emit_insn ( gen_neon_vset_lanev4hi ( target , x , target , index ) ) ; break ; case E_V8HImode : emit_insn ( gen_neon_vset_lanev8hi ( target , x , target , index ) ) ; break ; case E_V2SImode : emit_insn ( gen_neon_vset_lanev2si ( target , x , target , index ) ) ; break ; case E_V4SImode : emit_insn ( gen_neon_vset_lanev4si ( target , x , target , index ) ) ; break ; case E_V2SFmode : emit_insn ( gen_neon_vset_lanev2sf ( target , x , target , index ) ) ; break ; case E_V4SFmode : emit_insn ( gen_neon_vset_lanev4sf ( target , x , target , index ) ) ; break ; case E_V2DImode : emit_insn ( gen_neon_vset_lanev2di ( target , x , target , index ) ) ; break ;


<s> } if ( all_same && GET_MODE_SIZE ( inner_mode ) <= <NUM_LIT> ) { x = copy_to_mode_reg ( inner_mode , XVECEXP ( vals , <NUM_LIT> , <NUM_LIT> ) ) ; emit_insn ( gen_rtx_SET ( target , gen_vec_duplicate ( mode , x ) ) ) ; return ; } if ( n_var == <NUM_LIT> ) { rtx copy = copy_rtx ( vals ) ; rtx index = GEN_INT ( one_var ) ; XVECEXP ( copy , <NUM_LIT> , one_var ) = XVECEXP ( vals , <NUM_LIT> , ( one_var + <NUM_LIT> ) % n_elts ) ; neon_expand_vector_init ( target , copy ) ; x = copy_to_mode_reg ( inner_mode , XVECEXP ( vals , <NUM_LIT> , one_var ) ) ; switch ( mode ) { case E_V8QImode : emit_insn ( gen_neon_vset_lanev8qi ( target , x , target , index ) ) ; break ; case E_V16QImode : emit_insn ( gen_neon_vset_lanev16qi ( target , x , target , index ) ) ; break ; case E_V4HImode : emit_insn ( gen_neon_vset_lanev4hi ( target , x , target , index ) ) ; break ; case E_V8HImode : emit_insn ( gen_neon_vset_lanev8hi ( target , x , target , index ) ) ; break ; case E_V2SImode : emit_insn ( gen_neon_vset_lanev2si ( target , x , target , index ) ) ; break ; case E_V4SImode : emit_insn ( gen_neon_vset_lanev4si ( target , x , target , index ) ) ; break ; case E_V2SFmode : emit_insn ( gen_neon_vset_lanev2sf ( target , x , target , index ) ) ; break ; case E_V4SFmode : emit_insn ( gen_neon_vset_lanev4sf ( target , x , target , index ) ) ; break ; case E_V2DImode : emit_insn ( gen_neon_vset_lanev2di ( target , x , target , index ) ) ; break ; default : gcc_unreachable ( ) ; } return ; }

mem = assign_stack_temp ( mode , GET_MODE_SIZE ( mode ) ) ;


<s> gcc_assert ( REG_P ( reg ) ) ; regno = REGNO ( reg ) ; nregs = REG_NREGS ( reg ) / <NUM_LIT> ; gcc_assert ( VFP_REGNO_OK_FOR_DOUBLE ( regno ) || NEON_REGNO_OK_FOR_QUAD ( regno ) ) ; gcc_assert ( VALID_NEON_DREG_MODE ( mode ) || VALID_NEON_QREG_MODE ( mode ) || VALID_NEON_STRUCT_MODE ( mode ) ) ; gcc_assert ( MEM_P ( mem ) ) ; addr = XEXP ( mem , <NUM_LIT> ) ; if ( GET_CODE ( addr ) == CONST && GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == PLUS ) addr = XEXP ( addr , <NUM_LIT> ) ; switch ( GET_CODE ( addr ) ) { case POST_INC : if ( nregs > <NUM_LIT> ) { templ = <STR_LIT> ; ops [ <NUM_LIT> ] = XEXP ( addr , <NUM_LIT> ) ; } else { templ = <STR_LIT> ; ops [ <NUM_LIT> ] = mem ; } ops [ <NUM_LIT> ] = reg ; break ; case PRE_DEC : templ = <STR_LIT> ; ops [ <NUM_LIT> ] = XEXP ( addr , <NUM_LIT> ) ; ops [ <NUM_LIT> ] = reg ; break ; case POST_MODIFY : gcc_unreachable ( ) ; case REG : if ( nregs > <NUM_LIT> ) { if ( nregs > <NUM_LIT> ) templ = <STR_LIT> ;


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


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


<s> unsigned long live_regs_mask ; unsigned long l_mask ; unsigned high_regs_pushed = <NUM_LIT> ; bool lr_needs_saving ; func_type = arm_current_func_type ( ) ; if ( IS_NAKED ( func_type ) ) { if ( flag_stack_usage_info ) current_function_static_stack_size = <NUM_LIT> ; return ; } if ( IS_INTERRUPT ( func_type ) ) { error ( <STR_LIT> ) ; return ; } if ( is_called_in_ARM_mode ( current_function_decl ) ) emit_insn ( gen_prologue_thumb1_interwork ( ) ) ; offsets = arm_get_frame_offsets ( ) ; live_regs_mask = offsets -> saved_regs_mask ; lr_needs_saving = live_regs_mask & ( <NUM_LIT> << LR_REGNUM ) ; l_mask = live_regs_mask & <NUM_LIT> ; high_regs_pushed = bit_count ( live_regs_mask & <NUM_LIT> ) ; if ( crtl -> args . pretend_args_size ) { rtx x = GEN_INT ( - crtl -> args . pretend_args_size ) ; if ( cfun -> machine -> uses_anonymous_args ) { int num_pushes = ARM_NUM_INTS ( crtl -> args . pretend_args_size ) ; unsigned long mask ; mask = <NUM_LIT> << ( LAST_ARG_REGNUM + <NUM_LIT> ) ; mask -= <NUM_LIT> << ( LAST_ARG_REGNUM + <NUM_LIT> - num_pushes ) ; insn = thumb1_emit_multi_reg_push ( mask , <NUM_LIT> ) ; } else { insn = emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , x ) ) ; } RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } if ( TARGET_BACKTRACE ) { HOST_WIDE_INT offset = <NUM_LIT> ; unsigned work_register ; rtx work_reg , x , arm_hfp_rtx ; work_register = thumb_find_work_register ( live_regs_mask ) ; work_reg = gen_rtx_REG ( SImode , work_register ) ; arm_hfp_rtx = gen_rtx_REG ( SImode , ARM_HARD_FRAME_POINTER_REGNUM ) ; insn = emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - <NUM_LIT> ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; if ( l_mask ) { insn = thumb1_emit_multi_reg_push ( l_mask , l_mask ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; lr_needs_saving = false ; offset = bit_count ( l_mask ) * UNITS_PER_WORD ; } x = GEN_INT ( offset + <NUM_LIT> + crtl -> args . pretend_args_size ) ; emit_insn ( gen_addsi3 ( work_reg , stack_pointer_rtx , x ) ) ; x = plus_constant ( Pmode , stack_pointer_rtx , offset + <NUM_LIT> ) ; x = gen_frame_mem ( SImode , x ) ; emit_move_insn ( x , work_reg ) ; if ( l_mask ) { x = gen_rtx_REG ( SImode , PC_REGNUM ) ; emit_move_insn ( work_reg , x ) ; x = plus_constant ( Pmode , stack_pointer_rtx , offset + <NUM_LIT> ) ; x = gen_frame_mem ( SImode , x ) ; emit_move_insn ( x , work_reg ) ; emit_move_insn ( work_reg , arm_hfp_rtx ) ; x = plus_constant ( Pmode , stack_pointer_rtx , offset ) ;


<s> if ( GET_MODE_SIZE ( mode ) <= <NUM_LIT> && XEXP ( x , <NUM_LIT> ) != frame_pointer_rtx && XEXP ( x , <NUM_LIT> ) != frame_pointer_rtx && thumb1_index_register_rtx_p ( XEXP ( x , <NUM_LIT> ) , strict_p ) && ( thumb1_index_register_rtx_p ( XEXP ( x , <NUM_LIT> ) , strict_p ) || ( ! strict_p && will_be_in_index_register ( XEXP ( x , <NUM_LIT> ) ) ) ) ) return <NUM_LIT> ; else if ( ( thumb1_index_register_rtx_p ( XEXP ( x , <NUM_LIT> ) , strict_p ) || XEXP ( x , <NUM_LIT> ) == arg_pointer_rtx ) && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) && thumb_legitimate_offset_p ( mode , INTVAL ( XEXP ( x , <NUM_LIT> ) ) ) ) return <NUM_LIT> ; else if ( REG_P ( XEXP ( x , <NUM_LIT> ) ) && REGNO ( XEXP ( x , <NUM_LIT> ) ) == STACK_POINTER_REGNUM && GET_MODE_SIZE ( mode ) >= <NUM_LIT> && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) && INTVAL ( XEXP ( x , <NUM_LIT> ) ) >= <NUM_LIT> && INTVAL ( XEXP ( x , <NUM_LIT> ) ) + GET_MODE_SIZE ( mode ) <= <NUM_LIT> && ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) & <NUM_LIT> ) == <NUM_LIT> ) return <NUM_LIT> ; else if ( REG_P ( XEXP ( x , <NUM_LIT> ) ) && ( REGNO ( XEXP ( x , <NUM_LIT> ) ) == FRAME_POINTER_REGNUM || REGNO ( XEXP ( x , <NUM_LIT> ) ) == ARG_POINTER_REGNUM || ( REGNO ( XEXP ( x , <NUM_LIT> ) ) >= FIRST_VIRTUAL_REGISTER && REGNO ( XEXP ( x , <NUM_LIT> ) ) <= LAST_VIRTUAL_POINTER_REGISTER ) ) && GET_MODE_SIZE ( mode ) >= <NUM_LIT> && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) && ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) & <NUM_LIT> ) == <NUM_LIT> ) return <NUM_LIT> ; } else if ( GET_MODE_CLASS ( mode ) != MODE_FLOAT && GET_MODE_SIZE ( mode ) == <NUM_LIT> && GET_CODE ( x ) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P ( x ) && ! ( flag_pic && symbol_mentioned_p ( get_pool_constant ( x ) ) && ! pcrel_constant_p ( get_pool_constant ( x ) ) ) ) return <NUM_LIT> ;


<s> if ( GET_MODE_SIZE ( mode ) < <NUM_LIT> && ! ( reload_in_progress || reload_completed ) && ( reg_mentioned_p ( frame_pointer_rtx , x ) || reg_mentioned_p ( arg_pointer_rtx , x ) || reg_mentioned_p ( virtual_incoming_args_rtx , x ) || reg_mentioned_p ( virtual_outgoing_args_rtx , x ) || reg_mentioned_p ( virtual_stack_dynamic_rtx , x ) || reg_mentioned_p ( virtual_stack_vars_rtx , x ) ) ) return <NUM_LIT> ; else if ( thumb1_base_register_rtx_p ( x , mode , strict_p ) ) return <NUM_LIT> ; else if ( GET_MODE_SIZE ( mode ) >= <NUM_LIT> && CONSTANT_P ( x ) && GET_CODE ( x ) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P ( x ) && ! flag_pic ) return <NUM_LIT> ; else if ( ( GET_MODE_SIZE ( mode ) >= <NUM_LIT> || mode == HFmode ) && reload_completed && ( GET_CODE ( x ) == LABEL_REF || ( GET_CODE ( x ) == CONST && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == LABEL_REF && CONST_INT_P ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) ) ) ) return <NUM_LIT> ; else if ( GET_CODE ( x ) == POST_INC && GET_MODE_SIZE ( mode ) >= <NUM_LIT> && thumb1_index_register_rtx_p ( XEXP ( x , <NUM_LIT> ) , strict_p ) ) return <NUM_LIT> ; else if ( GET_CODE ( x ) == PLUS ) {

if ( GET_MODE_SIZE ( mode ) <= <NUM_LIT> && XEXP ( x , <NUM_LIT> ) != frame_pointer_rtx && XEXP ( x , <NUM_LIT> ) != frame_pointer_rtx && thumb1_index_register_rtx_p ( XEXP ( x , <NUM_LIT> ) , strict_p ) && ( thumb1_index_register_rtx_p ( XEXP ( x , <NUM_LIT> ) , strict_p ) || ( ! strict_p && will_be_in_index_register ( XEXP ( x , <NUM_LIT> ) ) ) ) ) return <NUM_LIT> ;


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


<s> static int thumb2_legitimate_address_p ( machine_mode mode , rtx x , int strict_p ) { bool use_ldrd ; enum rtx_code code = GET_CODE ( x ) ; if ( arm_address_register_rtx_p ( x , strict_p ) ) return <NUM_LIT> ; use_ldrd = ( TARGET_LDRD && ( mode == DImode || mode == DFmode ) ) ; if ( code == POST_INC || code == PRE_DEC || ( ( code == PRE_INC || code == POST_DEC ) && ( use_ldrd || GET_MODE_SIZE ( mode ) <= <NUM_LIT> ) ) ) return arm_address_register_rtx_p ( XEXP ( x , <NUM_LIT> ) , strict_p ) ; else if ( ( code == POST_MODIFY || code == PRE_MODIFY ) && arm_address_register_rtx_p ( XEXP ( x , <NUM_LIT> ) , strict_p ) && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS && rtx_equal_p ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) , XEXP ( x , <NUM_LIT> ) ) ) { rtx addend = XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ; HOST_WIDE_INT offset ; if ( ! CONST_INT_P ( addend ) ) return <NUM_LIT> ; offset = INTVAL ( addend ) ; if ( GET_MODE_SIZE ( mode ) <= <NUM_LIT> ) return ( offset > - <NUM_LIT> && offset < <NUM_LIT> ) ; return ( use_ldrd && offset > - <NUM_LIT> && offset < <NUM_LIT> && ( offset & <NUM_LIT> ) == <NUM_LIT> ) ; } else if ( reload_completed && ( code == LABEL_REF || ( code == CONST && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == LABEL_REF && CONST_INT_P ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) ) ) ) return <NUM_LIT> ; else if ( mode == TImode || ( TARGET_NEON && VALID_NEON_STRUCT_MODE ( mode ) ) ) return <NUM_LIT> ; else if ( code == PLUS ) { rtx xop0 = XEXP ( x , <NUM_LIT> ) ; rtx xop1 = XEXP ( x , <NUM_LIT> ) ; return ( ( arm_address_register_rtx_p ( xop0 , strict_p ) && ( thumb2_legitimate_index_p ( mode , xop1 , strict_p ) || ( ! strict_p && will_be_in_index_register ( xop1 ) ) ) ) || ( arm_address_register_rtx_p ( xop1 , strict_p ) && thumb2_legitimate_index_p ( mode , xop0 , strict_p ) ) ) ;


<s> else if ( mode == TImode || ( TARGET_NEON && VALID_NEON_STRUCT_MODE ( mode ) ) ) return <NUM_LIT> ; else if ( code == PLUS ) { rtx xop0 = XEXP ( x , <NUM_LIT> ) ; rtx xop1 = XEXP ( x , <NUM_LIT> ) ; return ( ( arm_address_register_rtx_p ( xop0 , strict_p ) && ( thumb2_legitimate_index_p ( mode , xop1 , strict_p ) || ( ! strict_p && will_be_in_index_register ( xop1 ) ) ) ) || ( arm_address_register_rtx_p ( xop1 , strict_p ) && thumb2_legitimate_index_p ( mode , xop0 , strict_p ) ) ) ; } else if ( can_avoid_literal_pool_for_label_p ( x ) ) return <NUM_LIT> ;

else if ( GET_MODE_CLASS ( mode ) != MODE_FLOAT && code == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P ( x ) && ! ( flag_pic && symbol_mentioned_p ( get_pool_constant ( x ) ) && ! pcrel_constant_p ( get_pool_constant ( x ) ) ) ) return <NUM_LIT> ;


<s> 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 IN_RANGE ( val , - <NUM_LIT> , <NUM_LIT> ) && ( val & <NUM_LIT> ) == <NUM_LIT> ; else return IN_RANGE ( val , - <NUM_LIT> , <NUM_LIT> - <NUM_LIT> ) ; } else return <NUM_LIT> ; } if ( code == MULT ) { rtx xiop0 = XEXP ( index , <NUM_LIT> ) ; rtx xiop1 = XEXP ( index , <NUM_LIT> ) ; return ( ( arm_address_register_rtx_p ( xiop0 , strict_p ) && thumb2_index_mul_operand ( xiop1 ) ) || ( arm_address_register_rtx_p ( xiop1 , strict_p ) && thumb2_index_mul_operand ( xiop0 ) ) ) ; }


<s> } else return <NUM_LIT> ; } if ( code == MULT ) { rtx xiop0 = XEXP ( index , <NUM_LIT> ) ; rtx xiop1 = XEXP ( index , <NUM_LIT> ) ; return ( ( arm_address_register_rtx_p ( xiop0 , strict_p ) && thumb2_index_mul_operand ( xiop1 ) ) || ( arm_address_register_rtx_p ( xiop1 , strict_p ) && thumb2_index_mul_operand ( xiop0 ) ) ) ; } else if ( code == ASHIFT ) { 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> ) ; }

return ( code == CONST_INT && INTVAL ( index ) < <NUM_LIT> && INTVAL ( index ) > - <NUM_LIT> ) ;


<s> machine_mode new_mode = VOIDmode ; if ( type ) { int ag_count = aapcs_vfp_sub_candidate ( type , & new_mode ) ; if ( ag_count > <NUM_LIT> && ag_count <= <NUM_LIT> ) * count = ag_count ; else return false ; } else if ( GET_MODE_CLASS ( mode ) == MODE_FLOAT || GET_MODE_CLASS ( mode ) == MODE_VECTOR_INT || GET_MODE_CLASS ( mode ) == MODE_VECTOR_FLOAT ) { * count = <NUM_LIT> ; new_mode = mode ; } else if ( GET_MODE_CLASS ( mode ) == MODE_COMPLEX_FLOAT ) { * count = <NUM_LIT> ; new_mode = ( mode == DCmode ? DFmode : SFmode ) ; }


<s> unsigned int i , nelt_v8 , nelt_v16 , nelt_mode ; rtx dst , addr , mem ; rtx val_vec , reg ; machine_mode mode ; unsigned int offset = <NUM_LIT> ; gcc_assert ( ( align & <NUM_LIT> ) == <NUM_LIT> ) ; nelt_v8 = GET_MODE_NUNITS ( V8QImode ) ; nelt_v16 = GET_MODE_NUNITS ( V16QImode ) ; if ( length >= nelt_v16 && unaligned_access && ! BYTES_BIG_ENDIAN ) mode = V16QImode ; else mode = V8QImode ; nelt_mode = GET_MODE_NUNITS ( mode ) ; gcc_assert ( length >= nelt_mode ) ; if ( ! arm_block_set_vect_profit_p ( length , align , mode ) ) return false ; dst = copy_addr_to_reg ( XEXP ( dstbase , <NUM_LIT> ) ) ; reg = gen_reg_rtx ( mode ) ; val_vec = gen_const_vec_duplicate ( mode , gen_int_mode ( value , QImode ) ) ; emit_move_insn ( reg , val_vec ) ; i = <NUM_LIT> ; if ( mode == V16QImode ) { mem = adjust_automodify_address ( dstbase , mode , dst , offset ) ; emit_insn ( gen_movmisalignv16qi ( mem , reg ) ) ; i += nelt_mode ; if ( i + nelt_v8 < length && i + nelt_v16 > length ) { emit_insn ( gen_add2_insn ( dst , GEN_INT ( length - nelt_mode ) ) ) ; offset += length - nelt_mode ; mem = adjust_automodify_address ( dstbase , mode , dst , offset ) ; if ( ( length & <NUM_LIT> ) == <NUM_LIT> ) set_mem_align ( mem , BITS_PER_UNIT * <NUM_LIT> ) ; else if ( ( length & <NUM_LIT> ) == <NUM_LIT> ) set_mem_align ( mem , BITS_PER_UNIT * <NUM_LIT> ) ; else set_mem_align ( mem , BITS_PER_UNIT ) ;


<s> rtx insn ; insn = emit_call_insn ( pat ) ;

if ( TARGET_VXWORKS_RTP && flag_pic && ! sibcall && GET_CODE ( addr ) == SYMBOL_REF && ( SYMBOL_REF_DECL ( addr ) ? ! targetm . binds_local_p ( SYMBOL_REF_DECL ( addr ) ) : ! SYMBOL_REF_LOCAL_P ( addr ) ) ) {


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

if ( ! named || pcum -> nregs + nregs > NUM_ARG_REGS ) return NULL_RTX ;


<s> if ( ( pcum -> nregs & <NUM_LIT> ) && ARM_DOUBLEWORD_ALIGN ) { int res = arm_needs_doubleword_align ( mode , type ) ; if ( res < <NUM_LIT> && warn_psabi ) inform ( input_location , <STR_LIT> <STR_LIT> , type ) ; else if ( res > <NUM_LIT> ) { pcum -> nregs ++ ; if ( res > <NUM_LIT> && warn_psabi ) inform ( input_location , <STR_LIT> <STR_LIT> , type ) ; } } if ( pcum -> can_split ) nregs = <NUM_LIT> ; else nregs = ARM_NUM_REGS2 ( mode , type ) ; if ( ! named || pcum -> nregs + nregs > NUM_ARG_REGS ) return NULL_RTX ;

return gen_rtx_REG ( mode , pcum -> nregs ) ;


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

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


<s> void arm_load_pic_register ( unsigned long saved_regs ATTRIBUTE_UNUSED , rtx pic_reg ) { rtx l1 , labelno , pic_tmp , pic_rtx ; if ( crtl -> uses_pic_offset_table == <NUM_LIT> || TARGET_SINGLE_PIC_BASE ) return ; gcc_assert ( flag_pic ) ; if ( pic_reg == NULL_RTX ) pic_reg = cfun -> machine -> pic_reg ; if ( TARGET_VXWORKS_RTP ) { pic_rtx = gen_rtx_SYMBOL_REF ( Pmode , VXWORKS_GOTT_BASE ) ; pic_rtx = gen_rtx_CONST ( Pmode , pic_rtx ) ; emit_insn ( gen_pic_load_addr_32bit ( pic_reg , pic_rtx ) ) ; emit_insn ( gen_rtx_SET ( pic_reg , gen_rtx_MEM ( Pmode , pic_reg ) ) ) ; pic_tmp = gen_rtx_SYMBOL_REF ( Pmode , VXWORKS_GOTT_INDEX ) ; emit_insn ( gen_pic_offset_arm ( pic_reg , pic_reg , pic_tmp ) ) ; } else { labelno = GEN_INT ( pic_labelno ++ ) ; l1 = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , labelno ) , UNSPEC_PIC_LABEL ) ;


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


<s> target_flags &= ~ MASK_INTERWORK ; } if ( TARGET_SOFT_FLOAT ) arm_fpu_attr = FPU_NONE ; else arm_fpu_attr = FPU_VFP ; if ( TARGET_AAPCS_BASED ) { if ( TARGET_CALLER_INTERWORKING ) error ( <STR_LIT> ) ; else if ( TARGET_CALLEE_INTERWORKING ) error ( <STR_LIT> ) ; } if ( ! arm_arch4 && arm_fp16_format != ARM_FP16_FORMAT_NONE ) sorry ( <STR_LIT> ) ; if ( use_cmse && ! arm_arch_cmse ) error ( <STR_LIT> ) ; if ( use_cmse && LAST_VFP_REGNUM > LAST_LO_VFP_REGNUM ) error ( <STR_LIT> ) ; if ( TARGET_AAPCS_BASED ) { if ( arm_abi == ARM_ABI_IWMMXT ) arm_pcs_default = ARM_PCS_AAPCS_IWMMXT ;


<s> if ( ( TARGET_TPCS_FRAME || TARGET_TPCS_LEAF_FRAME ) && TARGET_ARM_P ( flags ) ) warning ( <NUM_LIT> , <STR_LIT> ) ; if ( TARGET_ARM_P ( flags ) && TARGET_CALLEE_INTERWORKING ) warning ( <NUM_LIT> , <STR_LIT> ) ; if ( TARGET_ARM_P ( flags ) && write_symbols != NO_DEBUG && ! TARGET_APCS_FRAME && ( TARGET_DEFAULT & MASK_APCS_FRAME ) ) warning ( <NUM_LIT> , <STR_LIT> <STR_LIT> ) ; if ( TARGET_THUMB_P ( flags ) && TARGET_IWMMXT ) error ( <STR_LIT> ) ; if ( TARGET_HARD_TP && TARGET_THUMB1_P ( flags ) ) error ( <STR_LIT> ) ; if ( TARGET_THUMB_P ( flags ) && TARGET_VXWORKS_RTP && flag_pic ) { error ( <STR_LIT> ) ; flag_pic = <NUM_LIT> ; } if ( target_pure_code || target_slow_flash_data ) { const char * flag = ( target_pure_code ? <STR_LIT> : <STR_LIT> ) ; if ( ! TARGET_HAVE_MOVT || arm_arch_notm || flag_pic || TARGET_NEON ) error ( <STR_LIT> <STR_LIT> , flag ) ; if ( target_word_relocations ) error ( <STR_LIT> , flag ) ; }


<s> opts -> x_target_flags &= ~ MASK_APCS_FRAME ; } if ( TARGET_THUMB_P ( opts -> x_target_flags ) && TARGET_CALLEE_INTERWORKING ) opts -> x_target_flags |= MASK_INTERWORK ; cl_optimization * to = TREE_OPTIMIZATION ( init_optimize ) ; if ( ! opts_set -> x_arm_restrict_it ) opts -> x_arm_restrict_it = arm_arch8 ; if ( ! TARGET_THUMB2_P ( opts -> x_target_flags ) || ! arm_arch_notm ) opts -> x_arm_restrict_it = <NUM_LIT> ; if ( ! opts_set -> x_unaligned_access ) { opts -> x_unaligned_access = ( TARGET_32BIT_P ( opts -> x_target_flags ) && arm_arch6 && ( arm_arch_notm || arm_arch7 ) ) ; } else if ( opts -> x_unaligned_access == <NUM_LIT> && ! ( arm_arch6 && ( arm_arch_notm || arm_arch7 ) ) ) { warning ( <NUM_LIT> , <STR_LIT> ) ; opts -> x_unaligned_access = <NUM_LIT> ; } if ( TARGET_THUMB1_P ( opts -> x_target_flags ) ) opts -> x_flag_schedule_insns = <NUM_LIT> ; else opts -> x_flag_schedule_insns = to -> x_flag_schedule_insns ; if ( optimize_function_for_size_p ( cfun ) && TARGET_THUMB2_P ( opts -> x_target_flags ) ) opts -> x_flag_shrink_wrap = false ; else opts -> x_flag_shrink_wrap = to -> x_flag_shrink_wrap ; if ( TARGET_THUMB1_P ( opts -> x_target_flags ) ) opts -> x_flag_ipa_ra = <NUM_LIT> ; else opts -> x_flag_ipa_ra = to -> x_flag_ipa_ra ; if ( TARGET_THUMB2_P ( opts -> x_target_flags ) ) opts -> x_inline_asm_unified = true ; SUBTARGET_OVERRIDE_INTERNAL_OPTIONS ;


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


<s> reg = gen_reg_rtx ( Pmode ) ; } rtx_insn * insn ; if ( ( GET_CODE ( orig ) == LABEL_REF || ( GET_CODE ( orig ) == SYMBOL_REF && SYMBOL_REF_LOCAL_P ( orig ) && ( SYMBOL_REF_DECL ( orig ) ? ! DECL_WEAK ( SYMBOL_REF_DECL ( orig ) ) : <NUM_LIT> ) ) ) && NEED_GOT_RELOC && arm_pic_data_is_text_relative ) insn = arm_pic_static_addr ( orig , reg ) ; else { rtx pat ; rtx mem ; require_pic_register ( pic_reg , compute_now ) ; if ( pic_reg == NULL_RTX ) pic_reg = cfun -> machine -> pic_reg ; pat = gen_calculate_pic_address ( reg , pic_reg , orig ) ; mem = SET_SRC ( pat ) ; gcc_assert ( MEM_P ( mem ) && ! MEM_VOLATILE_P ( mem ) ) ; MEM_READONLY_P ( mem ) = <NUM_LIT> ; MEM_NOTRAP_P ( mem ) = <NUM_LIT> ; insn = emit_insn ( pat ) ; } set_unique_reg_note ( insn , REG_EQUAL , orig ) ; return reg ; } else if ( GET_CODE ( orig ) == CONST ) { rtx base , offset ; if ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == PLUS && XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) == cfun -> machine -> pic_reg ) return orig ; if ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == UNSPEC && XINT ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) == UNSPEC_TLS ) return orig ; if ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) ) == UNSPEC && XINT ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) , <NUM_LIT> ) == UNSPEC_TLS ) { gcc_assert ( CONST_INT_P ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) ) ) ; return orig ; } if ( reg == <NUM_LIT> ) { gcc_assert ( can_create_pseudo_p ( ) ) ; reg = gen_reg_rtx ( Pmode ) ; } gcc_assert ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == PLUS ) ; base = legitimize_pic_address ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) , Pmode , reg , pic_reg , compute_now ) ; offset = legitimize_pic_address ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) , Pmode , base == reg ? <NUM_LIT> : reg , pic_reg , compute_now ) ; if ( CONST_INT_P ( offset ) ) {

if ( ! arm_legitimate_index_p ( mode , offset , SET , <NUM_LIT> ) ) {


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


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

if ( arm_size_return_regs ( ) >= ( <NUM_LIT> * UNITS_PER_WORD ) ) return <NUM_LIT> ;


<s> if ( type && INTEGRAL_TYPE_P ( type ) ) mode = arm_promote_function_mode ( type , mode , & unsignedp , fntype , <NUM_LIT> ) ; if ( pcs_variant != ARM_PCS_AAPCS ) { int i ; for ( i = <NUM_LIT> ; i < ARM_NUM_COPROC_SLOTS ; i ++ ) if ( aapcs_cp_arg_layout [ i ] . is_return_candidate ( pcs_variant , mode , type ) ) return aapcs_cp_arg_layout [ i ] . allocate_return_reg ( pcs_variant , mode , type ) ; } if ( type && arm_return_in_msb ( type ) ) { HOST_WIDE_INT size = int_size_in_bytes ( type ) ; if ( size % UNITS_PER_WORD != <NUM_LIT> ) { size += UNITS_PER_WORD - size % UNITS_PER_WORD ; mode = int_mode_for_size ( size * BITS_PER_UNIT , <NUM_LIT> ) . require ( ) ;


<s> if ( aapcs_cp_arg_layout [ slot ] . allocate ( pcum , mode , type ) ) return ; pcum -> aapcs_cprc_failed [ slot ] = true ; pcum -> can_split = false ; } gcc_assert ( pcum -> can_split == false ) ; return ; } } ncrn = pcum -> aapcs_ncrn ; if ( ncrn & <NUM_LIT> ) { int res = arm_needs_doubleword_align ( mode , type ) ; if ( res < <NUM_LIT> && warn_psabi && currently_expanding_gimple_stmt ) inform ( input_location , <STR_LIT> <STR_LIT> , type ) ; else if ( res > <NUM_LIT> ) ncrn ++ ; } nregs = ARM_NUM_REGS2 ( mode , type ) ; gcc_assert ( nregs >= <NUM_LIT> ) ; nregs2 = nregs ? nregs : <NUM_LIT> ; if ( ncrn + nregs2 <= NUM_ARG_REGS ) { pcum -> aapcs_reg = gen_rtx_REG ( mode , ncrn ) ; pcum -> aapcs_next_ncrn = ncrn + nregs ; return ; } if ( ncrn < NUM_ARG_REGS && pcum -> can_split ) {


<s> if ( pcum -> aapcs_arg_processed ) return ; pcum -> aapcs_arg_processed = true ; if ( ! named ) return ; if ( pcum -> pcs_variant != ARM_PCS_AAPCS ) { int slot = aapcs_select_call_coproc ( pcum , mode , type ) ; pcum -> aapcs_cprc_slot = slot ; if ( slot >= <NUM_LIT> ) { if ( ! pcum -> aapcs_cprc_failed [ slot ] ) { if ( aapcs_cp_arg_layout [ slot ] . allocate ( pcum , mode , type ) ) return ; pcum -> aapcs_cprc_failed [ slot ] = true ; pcum -> can_split = false ; } gcc_assert ( pcum -> can_split == false ) ; return ; } } ncrn = pcum -> aapcs_ncrn ; if ( ncrn & <NUM_LIT> ) {

int res = arm_needs_doubleword_align ( mode , type ) ;


<s> static rtx aapcs_libcall_value ( machine_mode mode ) { if ( BYTES_BIG_ENDIAN && ALL_FIXED_POINT_MODE_P ( mode ) && GET_MODE_SIZE ( mode ) <= <NUM_LIT> ) mode = SImode ;

return aapcs_allocate_return_reg ( mode , NULL_TREE , NULL_TREE ) ;


<s> for ( i = <NUM_LIT> ; i < ARM_NUM_COPROC_SLOTS ; i ++ ) if ( aapcs_cp_arg_layout [ i ] . is_call_candidate ( pcum , mode , type ) ) return i ;


<s> static int aapcs_select_call_coproc ( CUMULATIVE_ARGS * pcum , machine_mode mode , const_tree type ) { int i ;

for ( i = <NUM_LIT> ; i < ARM_NUM_COPROC_SLOTS ; i ++ ) if ( aapcs_cp_arg_layout [ i ] . is_call_candidate ( pcum , mode , type ) ) return i ;


<s> enum arm_pcs pcs_variant ; if ( fntype ) { const_tree fndecl = NULL_TREE ; if ( TREE_CODE ( fntype ) == FUNCTION_DECL ) { fndecl = fntype ; fntype = TREE_TYPE ( fntype ) ; } pcs_variant = arm_get_pcs_model ( fntype , fndecl ) ; } else pcs_variant = arm_pcs_default ; if ( pcs_variant != ARM_PCS_AAPCS ) { int i ; for ( i = <NUM_LIT> ; i < ARM_NUM_COPROC_SLOTS ; i ++ ) if ( aapcs_cp_arg_layout [ i ] . is_return_candidate ( pcs_variant , TYPE_MODE ( type ) , type ) ) return i ;


<s> if ( pcs_variant != ARM_PCS_AAPCS ) { int i ; for ( i = <NUM_LIT> ; i < ARM_NUM_COPROC_SLOTS ; i ++ ) if ( aapcs_cp_arg_layout [ i ] . is_return_candidate ( pcs_variant , TYPE_MODE ( type ) , type ) ) return i ; }


<s> int rcount = pcum -> aapcs_vfp_rcount ; int rshift = shift ; machine_mode rmode = pcum -> aapcs_vfp_rmode ; rtx par ; if ( ! ( TARGET_NEON || TARGET_HAVE_MVE ) ) { if ( rmode == V2SImode ) rmode = DImode ; else if ( rmode == V4SImode ) { rmode = DImode ; rcount *= <NUM_LIT> ; rshift /= <NUM_LIT> ; } } par = gen_rtx_PARALLEL ( mode , rtvec_alloc ( rcount ) ) ; for ( i = <NUM_LIT> ; i < rcount ; i ++ ) {

rtx tmp = gen_rtx_REG ( rmode , FIRST_VFP_REGNUM + regno + i * rshift ) ;


<s> rtx par ; int shift ; aapcs_vfp_is_call_or_return_candidate ( pcs_variant , mode , type , & ag_mode , & count ) ; if ( ! ( TARGET_NEON || TARGET_HAVE_MVE ) ) { if ( ag_mode == V2SImode ) ag_mode = DImode ; else if ( ag_mode == V4SImode ) { ag_mode = DImode ; count *= <NUM_LIT> ; } } shift = GET_MODE_SIZE ( ag_mode ) / GET_MODE_SIZE ( SFmode ) ; par = gen_rtx_PARALLEL ( mode , rtvec_alloc ( count ) ) ; for ( i = <NUM_LIT> ; i < count ; i ++ ) { rtx tmp = gen_rtx_REG ( ag_mode , FIRST_VFP_REGNUM + i * shift ) ; tmp = gen_rtx_EXPR_LIST ( VOIDmode , tmp , GEN_INT ( i * GET_MODE_SIZE ( ag_mode ) ) ) ; XVECEXP ( par , <NUM_LIT> , i ) = tmp ; }


<s> if ( ! use_vfp_abi ( pcs_variant , false ) ) return NULL ; if ( mode == BLKmode || ( GET_MODE_CLASS ( mode ) == MODE_INT && GET_MODE_SIZE ( mode ) >= GET_MODE_SIZE ( TImode ) && ! ( TARGET_NEON || TARGET_HAVE_MVE ) ) ) { int count ; machine_mode ag_mode ; int i ; rtx par ; int shift ; aapcs_vfp_is_call_or_return_candidate ( pcs_variant , mode , type , & ag_mode , & count ) ; if ( ! ( TARGET_NEON || TARGET_HAVE_MVE ) ) { if ( ag_mode == V2SImode ) ag_mode = DImode ; else if ( ag_mode == V4SImode ) { ag_mode = DImode ; count *= <NUM_LIT> ; } } shift = GET_MODE_SIZE ( ag_mode ) / GET_MODE_SIZE ( SFmode ) ; par = gen_rtx_PARALLEL ( mode , rtvec_alloc ( count ) ) ;

for ( i = <NUM_LIT> ; i < count ; i ++ ) {


<s> if ( ! use_vfp_abi ( pcum -> pcs_variant , false ) ) return false ;

return aapcs_vfp_is_call_or_return_candidate ( pcum -> pcs_variant , mode , type , & pcum -> aapcs_vfp_rmode , & pcum -> aapcs_vfp_rcount ) ;


<s> return aapcs_vfp_is_call_or_return_candidate ( pcum -> pcs_variant , mode , type , & pcum -> aapcs_vfp_rmode , & pcum -> aapcs_vfp_rcount ) ;


<s> else if ( warn_psabi_flags & WARN_PSABI_ZERO_WIDTH_BITFIELD ) inform ( input_location , <STR_LIT> <STR_LIT> , TYPE_MAIN_VARIANT ( type ) , url12 ) ; } * count = ag_count ; } else return false ; } else if ( GET_MODE_CLASS ( mode ) == MODE_FLOAT || GET_MODE_CLASS ( mode ) == MODE_VECTOR_INT || GET_MODE_CLASS ( mode ) == MODE_VECTOR_FLOAT ) { * count = <NUM_LIT> ; new_mode = mode ; } else if ( GET_MODE_CLASS ( mode ) == MODE_COMPLEX_FLOAT ) { * count = <NUM_LIT> ; new_mode = ( mode == DCmode ? DFmode : SFmode ) ; } else return false ; if ( ! use_vfp_abi ( pcs_variant , ARM_NUM_REGS ( new_mode ) > <NUM_LIT> ) ) return false ; * base_mode = new_mode ; if ( TARGET_GENERAL_REGS_ONLY ) error ( <STR_LIT> , type ) ;


<s> int count ATTRIBUTE_UNUSED ; machine_mode ag_mode ATTRIBUTE_UNUSED ; if ( ! use_vfp_abi ( pcs_variant , false ) ) return false ; return aapcs_vfp_is_call_or_return_candidate ( pcs_variant , mode , type , & ag_mode , & count ) ;


<s> int count ATTRIBUTE_UNUSED ; machine_mode ag_mode ATTRIBUTE_UNUSED ; if ( ! use_vfp_abi ( pcs_variant , false ) ) return false ;

return aapcs_vfp_is_call_or_return_candidate ( pcs_variant , mode , type , & ag_mode , & count ) ;


<s> int count = <NUM_LIT> ; int sub_count ; tree field ; if ( ! COMPLETE_TYPE_P ( type ) || TREE_CODE ( TYPE_SIZE ( type ) ) != INTEGER_CST ) return - <NUM_LIT> ; for ( field = TYPE_FIELDS ( type ) ; field ; field = DECL_CHAIN ( field ) ) { if ( TREE_CODE ( field ) != FIELD_DECL ) continue ; if ( DECL_FIELD_ABI_IGNORED ( field ) ) { unsigned int flag ; if ( lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( field ) ) ) flag = WARN_PSABI_NO_UNIQUE_ADDRESS ; else if ( cxx17_empty_base_field_p ( field ) ) flag = WARN_PSABI_EMPTY_CXX17_BASE ; else continue ; if ( warn_psabi_flags ) { * warn_psabi_flags |= flag ; continue ; } } else if ( DECL_BIT_FIELD ( field ) && integer_zerop ( DECL_SIZE ( field ) ) ) { if ( DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD ( field ) ) continue ; if ( warn_psabi_flags ) { * warn_psabi_flags |= WARN_PSABI_ZERO_WIDTH_BITFIELD ; continue ; } } sub_count = aapcs_vfp_sub_candidate ( TREE_TYPE ( field ) , modep , warn_psabi_flags ) ; if ( sub_count < <NUM_LIT> ) return - <NUM_LIT> ; count += sub_count ; } if ( wi :: to_wide ( TYPE_SIZE ( type ) ) != count * GET_MODE_BITSIZE ( * modep ) ) return - <NUM_LIT> ; return count ; } case UNION_TYPE : case QUAL_UNION_TYPE : { int count = <NUM_LIT> ; int sub_count ; tree field ;


<s> if ( ! prev_set || ! curr_set ) return false ; if ( any_condjump_p ( curr ) ) return false ; if ( ! arm_macro_fusion_p ( ) ) return false ; if ( current_tune -> fusible_ops & tune_params :: FUSE_MOVW_MOVT && arm_sets_movw_movt_fusible_p ( prev_set , curr_set ) ) return true ;


<s> rtx prev_set = single_set ( prev ) ; rtx curr_set = single_set ( curr ) ; if ( ! prev_set || ! curr_set ) return false ; if ( any_condjump_p ( curr ) ) return false ; if ( ! arm_macro_fusion_p ( ) ) return false ; if ( current_tune -> fusible_ops & tune_params :: FUSE_MOVW_MOVT && arm_sets_movw_movt_fusible_p ( prev_set , curr_set ) ) return true ;


<s> __arm_cdp ( const unsigned int __coproc , const unsigned int __opc1 , const unsigned int __CRd , const unsigned int __CRn , const unsigned int __CRm , const unsigned int __opc2 ) { return __builtin_arm_cdp ( __coproc , __opc1 , __CRd , __CRn , __CRm , __opc2 ) ;


<s> __arm_cdp ( const unsigned int __coproc , const unsigned int __opc1 , const unsigned int __CRd , const unsigned int __CRn , const unsigned int __CRm , const unsigned int __opc2 ) {


<s> __arm_ldc ( const unsigned int __coproc , const unsigned int __CRd , const void * __p ) {


<s> __arm_ldc2 ( const unsigned int __coproc , const unsigned int __CRd , const void * __p ) {


<s> __arm_ldcl ( const unsigned int __coproc , const unsigned int __CRd , const void * __p ) { return __builtin_arm_ldcl ( __coproc , __CRd , __p ) ;


<s> __arm_mcr2 ( const unsigned int __coproc , const unsigned int __opc1 , uint32_t __value , const unsigned int __CRn , const unsigned int __CRm , const unsigned int __opc2 ) { return __builtin_arm_mcr2 ( __coproc , __opc1 , __value , __CRn , __CRm , __opc2 ) ;


<s> __arm_mcrr ( const unsigned int __coproc , const unsigned int __opc1 , uint64_t __value , const unsigned int __CRm ) { return __builtin_arm_mcrr ( __coproc , __opc1 , __value , __CRm ) ;


<s> __arm_mcrr2 ( const unsigned int __coproc , const unsigned int __opc1 , uint64_t __value , const unsigned int __CRm ) {


<s> __arm_stc ( const unsigned int __coproc , const unsigned int __CRd , void * __p ) { return __builtin_arm_stc ( __coproc , __CRd , __p ) ;


<s> __arm_stc2 ( const unsigned int __coproc , const unsigned int __CRd , void * __p ) { return __builtin_arm_stc2 ( __coproc , __CRd , __p ) ;


<s> __arm_stc2l ( const unsigned int __coproc , const unsigned int __CRd , void * __p ) {


<s> __arm_cdp ( const unsigned int __coproc , const unsigned int __opc1 , const unsigned int __CRd , const unsigned int __CRn , const unsigned int __CRm , const unsigned int __opc2 ) { __builtin_arm_cdp ( __coproc , __opc1 , __CRd , __CRn , __CRm , __opc2 ) ;


<s> __arm_cdp2 ( const unsigned int __coproc , const unsigned int __opc1 , const unsigned int __CRd , const unsigned int __CRn , const unsigned int __CRm , const unsigned int __opc2 ) { __builtin_arm_cdp2 ( __coproc , __opc1 , __CRd , __CRn , __CRm , __opc2 ) ;


<s> __arm_mcr ( const unsigned int __coproc , const unsigned int __opc1 , uint32_t __value , const unsigned int __CRn , const unsigned int __CRm , const unsigned int __opc2 ) { __builtin_arm_mcr ( __coproc , __opc1 , __value , __CRn , __CRm , __opc2 ) ;


<s> __arm_mrc2 ( const unsigned int __coproc , const unsigned int __opc1 , const unsigned int __CRn , const unsigned int __CRm , const unsigned int __opc2 ) { return __builtin_arm_mrc2 ( __coproc , __opc1 , __CRn , __CRm , __opc2 ) ;


<s> __arm_stc2 ( const unsigned int __coproc , const unsigned int __CRd , void * __p ) { __builtin_arm_stc2 ( __coproc , __CRd , __p ) ;


<s> return __builtin_arm_crc32ch ( __a , __b ) ;


<s> return __builtin_arm_crc32cw ( __a , __b ) ;


<s> __attribute__ ( ( __always_inline__ , __gnu_inline__ , __artificial__ ) ) __ignore_saturation ( void ) {


<s> return __builtin_arm_qadd ( __a , __b ) ;


<s> return __builtin_arm_qadd8 ( __a , __b ) ;


<s> return __builtin_arm_qasx ( __a , __b ) ;


<s> return __builtin_arm_sel ( __a , __b ) ;


<s> return __builtin_arm_shadd16 ( __a , __b ) ;


<s> return __builtin_arm_shadd8 ( __a , __b ) ;


<s> return __builtin_arm_shsub16 ( __a , __b ) ;


<s> return __builtin_arm_smuadx ( __a , __b ) ;


<s> return __builtin_arm_smusdx ( __a , __b ) ;


<s> return __builtin_arm_ssax ( __a , __b ) ;


<s> return __builtin_arm_ssub8 ( __a , __b ) ;


<s> return __builtin_arm_sxtab16 ( __a , __b ) ;


<s> return __builtin_arm_uadd8 ( __a , __b ) ;


<s> return __builtin_arm_uhasx ( __a , __b ) ;


<s> return __builtin_arm_uhsax ( __a , __b ) ;


<s> return __builtin_arm_usad8 ( __a , __b ) ;


<s> return __builtin_arm_usub16 ( __a , __b ) ;


<s> TREE_TYPE ( value ) = build_array_type ( char_type_node , build_index_type ( size_int ( len ) ) ) ; * attributes = tree_cons ( get_identifier ( <STR_LIT> ) , build_tree_list ( NULL_TREE , value ) , * attributes ) ;


<s> * htab -> find_slot ( libcall , INSERT ) = libcall ;


<s> min_mp = mp ; min_address = mp -> min_address + fix -> fix_size ; } } } mp = XNEW ( Mnode ) ; mp -> fix_size = fix -> fix_size ; mp -> mode = fix -> mode ; mp -> value = fix -> value ; mp -> refcount = <NUM_LIT> ; mp -> max_address = minipool_barrier -> address + <NUM_LIT> ; mp -> min_address = min_address ; if ( min_mp == NULL ) { mp -> prev = NULL ; mp -> next = minipool_vector_head ; if ( mp -> next == NULL ) { minipool_vector_tail = mp ; minipool_vector_label = gen_label_rtx ( ) ; } else mp -> next -> prev = mp ; minipool_vector_head = mp ; } else { mp -> next = min_mp -> next ; mp -> prev = min_mp ; min_mp -> next = mp ; if ( mp -> next != NULL ) mp -> next -> prev = mp ; else minipool_vector_tail = mp ; } min_mp = mp ; if ( mp -> prev ) mp = mp -> prev ; else mp -> offset = <NUM_LIT> ; while ( mp -> next != NULL ) { if ( mp -> next -> min_address < mp -> min_address + mp -> fix_size ) mp -> next -> min_address = mp -> min_address + mp -> fix_size ; if ( mp -> refcount ) mp -> next -> offset = mp -> offset + mp -> fix_size ; else mp -> next -> offset = mp -> offset ; mp = mp -> next ; }


<s> mp -> value = fix -> value ; mp -> refcount = <NUM_LIT> ; mp -> min_address = - <NUM_LIT> ; if ( max_mp == NULL ) { mp -> max_address = max_address ; mp -> next = NULL ; mp -> prev = minipool_vector_tail ; if ( mp -> prev == NULL ) { minipool_vector_head = mp ; minipool_vector_label = gen_label_rtx ( ) ; } else mp -> prev -> next = mp ; minipool_vector_tail = mp ; } else { if ( max_address > max_mp -> max_address - mp -> fix_size ) mp -> max_address = max_mp -> max_address - mp -> fix_size ; else mp -> max_address = max_address ; mp -> next = max_mp ; mp -> prev = max_mp -> prev ; max_mp -> prev = mp ; if ( mp -> prev != NULL ) mp -> prev -> next = mp ;


<s> if ( volatile_refs_p ( a ) || volatile_refs_p ( b ) ) return <NUM_LIT> ; if ( ( REG_P ( XEXP ( a , <NUM_LIT> ) ) || ( GET_CODE ( XEXP ( a , <NUM_LIT> ) ) == PLUS && CONST_INT_P ( XEXP ( XEXP ( a , <NUM_LIT> ) , <NUM_LIT> ) ) ) ) && ( REG_P ( XEXP ( b , <NUM_LIT> ) ) || ( GET_CODE ( XEXP ( b , <NUM_LIT> ) ) == PLUS && CONST_INT_P ( XEXP ( XEXP ( b , <NUM_LIT> ) , <NUM_LIT> ) ) ) ) ) { HOST_WIDE_INT val0 = <NUM_LIT> , val1 = <NUM_LIT> ; rtx reg0 , reg1 ; int val_diff ; if ( GET_CODE ( XEXP ( a , <NUM_LIT> ) ) == PLUS ) { reg0 = XEXP ( XEXP ( a , <NUM_LIT> ) , <NUM_LIT> ) ; val0 = INTVAL ( XEXP ( XEXP ( a , <NUM_LIT> ) , <NUM_LIT> ) ) ; } else reg0 = XEXP ( a , <NUM_LIT> ) ; if ( GET_CODE ( XEXP ( b , <NUM_LIT> ) ) == PLUS ) { reg1 = XEXP ( XEXP ( b , <NUM_LIT> ) , <NUM_LIT> ) ; val1 = INTVAL ( XEXP ( XEXP ( b , <NUM_LIT> ) , <NUM_LIT> ) ) ; } else reg1 = XEXP ( b , <NUM_LIT> ) ; if ( ! const_ok_for_op ( val0 , PLUS ) || ! const_ok_for_op ( val1 , PLUS ) ) return <NUM_LIT> ; if ( arm_eliminable_register ( reg0 ) ) return <NUM_LIT> ; val_diff = val1 - val0 ;


<s> HOST_WIDE_INT val0 = <NUM_LIT> , val1 = <NUM_LIT> ; rtx reg0 , reg1 ; int val_diff ; if ( GET_CODE ( XEXP ( a , <NUM_LIT> ) ) == PLUS ) { reg0 = XEXP ( XEXP ( a , <NUM_LIT> ) , <NUM_LIT> ) ; val0 = INTVAL ( XEXP ( XEXP ( a , <NUM_LIT> ) , <NUM_LIT> ) ) ; } else reg0 = XEXP ( a , <NUM_LIT> ) ; if ( GET_CODE ( XEXP ( b , <NUM_LIT> ) ) == PLUS ) { reg1 = XEXP ( XEXP ( b , <NUM_LIT> ) , <NUM_LIT> ) ; val1 = INTVAL ( XEXP ( XEXP ( b , <NUM_LIT> ) , <NUM_LIT> ) ) ; } else reg1 = XEXP ( b , <NUM_LIT> ) ; if ( ! const_ok_for_op ( val0 , PLUS ) || ! const_ok_for_op ( val1 , PLUS ) ) return <NUM_LIT> ; if ( arm_eliminable_register ( reg0 ) ) return <NUM_LIT> ;


<s> return ( unaligned_access ? ( align >= BITS_PER_WORD && ( offset & <NUM_LIT> ) == <NUM_LIT> ) : ( align >= <NUM_LIT> * BITS_PER_WORD && ( offset & <NUM_LIT> ) == <NUM_LIT> ) ) ;


<s> edge e ; if ( ! crtl -> tail_call_emit ) return false ; FOR_EACH_EDGE ( e , ei , EXIT_BLOCK_PTR_FOR_FN ( cfun ) -> preds ) if ( e -> flags & EDGE_SIBCALL ) { rtx_insn * call = BB_END ( e -> src ) ; if ( ! CALL_P ( call ) ) call = prev_nonnote_nondebug_insn ( call ) ; gcc_assert ( CALL_P ( call ) && SIBLING_CALL_P ( call ) ) ; if ( find_regno_fusage ( call , USE , <NUM_LIT> ) || is_indirect_tailcall_p ( call ) ) return true ; } return false ;


<s> edge e ; if ( ! crtl -> tail_call_emit ) return false ; FOR_EACH_EDGE ( e , ei , EXIT_BLOCK_PTR_FOR_FN ( cfun ) -> preds ) if ( e -> flags & EDGE_SIBCALL ) { rtx_insn * call = BB_END ( e -> src ) ; if ( ! CALL_P ( call ) ) call = prev_nonnote_nondebug_insn ( call ) ; gcc_assert ( CALL_P ( call ) && SIBLING_CALL_P ( call ) ) ; if ( find_regno_fusage ( call , USE , <NUM_LIT> ) || is_indirect_tailcall_p ( call ) ) return true ; }


<s> case AND : return <STR_LIT> ; case ASHIFT : case ASHIFTRT : case LSHIFTRT : case ROTATERT : return arm_shift_nmem ( GET_CODE ( op ) ) ; default : gcc_unreachable ( ) ; }


<s> if ( vcall_offset != <NUM_LIT> ) { emit_move_insn ( temp , gen_rtx_MEM ( Pmode , this_rtx ) ) ; arm_split_constant ( PLUS , Pmode , NULL_RTX , vcall_offset , temp , temp , false ) ; emit_move_insn ( temp , gen_rtx_MEM ( Pmode , temp ) ) ; emit_insn ( gen_add3_insn ( this_rtx , this_rtx , temp ) ) ; } if ( ! TREE_USED ( function ) ) { assemble_external ( function ) ; TREE_USED ( function ) = <NUM_LIT> ; } rtx funexp = XEXP ( DECL_RTL ( function ) , <NUM_LIT> ) ; if ( long_call_p ) { emit_move_insn ( temp , funexp ) ; funexp = temp ; } funexp = gen_rtx_MEM ( FUNCTION_MODE , funexp ) ; rtx_insn * insn = emit_call_insn ( gen_sibcall ( funexp , const0_rtx , NULL_RTX ) ) ; SIBLING_CALL_P ( insn ) = <NUM_LIT> ; emit_barrier ( ) ;


<s> return TARGET_32BIT ? arm_arm_address_cost ( x ) : arm_thumb_address_cost ( x ) ;


if ( REG_P ( addr ) || ( GET_CODE ( addr ) == PLUS && REG_P ( XEXP ( addr , <NUM_LIT> ) ) && CONST_INT_P ( XEXP ( addr , <NUM_LIT> ) ) ) ) return <NUM_LIT> ;


<s> int arm_address_offset_is_imm ( rtx_insn * insn ) { rtx mem , addr ; extract_insn_cached ( insn ) ; if ( REG_P ( recog_data . operand [ <NUM_LIT> ] ) ) return <NUM_LIT> ;

mem = recog_data . operand [ <NUM_LIT> ] ;


<s> if ( ! REG_P ( x ) ) return <NUM_LIT> ; regno = REGNO ( x ) ; if ( strict_p ) return ARM_REGNO_OK_FOR_BASE_P ( regno ) ; return ( regno <= LAST_ARM_REGNUM || regno >= FIRST_PSEUDO_REGISTER || regno == FRAME_POINTER_REGNUM || regno == ARG_POINTER_REGNUM ) ;


<s> if ( strict_p ) return ARM_REGNO_OK_FOR_BASE_P ( regno ) ; return ( regno <= LAST_ARM_REGNUM || regno >= FIRST_PSEUDO_REGISTER || regno == FRAME_POINTER_REGNUM || regno == ARG_POINTER_REGNUM ) ;


<s> static void arm_add_cfa_adjust_cfa_note ( rtx insn , int size , rtx dest , rtx src ) { rtx dwarf ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ;

dwarf = gen_rtx_SET ( dest , plus_constant ( Pmode , src , size ) ) ;


<s> RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; dwarf = gen_rtx_SET ( dest , plus_constant ( Pmode , src , size ) ) ;

add_reg_note ( insn , REG_CFA_ADJUST_CFA , dwarf ) ;


<s> unsigned retval = <NUM_LIT> ; if ( flag_vect_cost_model ) { tree vectype = stmt_info ? stmt_vectype ( stmt_info ) : NULL_TREE ; int stmt_cost = arm_builtin_vectorization_cost ( kind , vectype , misalign ) ; if ( where == vect_body && stmt_info && stmt_in_inner_loop_p ( stmt_info ) ) count *= <NUM_LIT> ; retval = ( unsigned ) ( count * stmt_cost ) ; cost [ where ] += retval ; }


<s> static void arm_adjust_block_mem ( rtx mem , HOST_WIDE_INT length , rtx * loop_reg , rtx * loop_mem ) { * loop_reg = copy_addr_to_reg ( XEXP ( mem , <NUM_LIT> ) ) ; * loop_mem = change_address ( mem , BLKmode , * loop_reg ) ; set_mem_align ( * loop_mem , MIN ( MEM_ALIGN ( mem ) , length * BITS_PER_UNIT ) ) ;


<s> * loop_mem = change_address ( mem , BLKmode , * loop_reg ) ; set_mem_align ( * loop_mem , MIN ( MEM_ALIGN ( mem ) , length * BITS_PER_UNIT ) ) ;


<s> rtx i_pat , d_pat ; if ( TARGET_THUMB1 && dep_type == <NUM_LIT> && recog_memoized ( insn ) == CODE_FOR_cbranchsi4_insn && recog_memoized ( dep ) >= <NUM_LIT> && get_attr_conds ( dep ) == CONDS_SET ) return <NUM_LIT> ; if ( current_tune -> sched_adjust_cost != NULL ) { if ( ! current_tune -> sched_adjust_cost ( insn , dep_type , dep , & cost ) ) return cost ; }


<s> static int arm_adjust_cost ( rtx_insn * insn , int dep_type , rtx_insn * dep , int cost , unsigned int ) { rtx i_pat , d_pat ; if ( TARGET_THUMB1 && dep_type == <NUM_LIT> && recog_memoized ( insn ) == CODE_FOR_cbranchsi4_insn && recog_memoized ( dep ) >= <NUM_LIT> && get_attr_conds ( dep ) == CONDS_SET ) return <NUM_LIT> ; if ( current_tune -> sched_adjust_cost != NULL ) { if ( ! current_tune -> sched_adjust_cost ( insn , dep_type , dep , & cost ) ) return cost ; } if ( dep_type == REG_DEP_ANTI || dep_type == REG_DEP_OUTPUT ) return <NUM_LIT> ; if ( dep_type == <NUM_LIT> && CALL_P ( insn ) ) return <NUM_LIT> ; if ( ( i_pat = single_set ( insn ) ) != NULL && MEM_P ( SET_SRC ( i_pat ) ) && ( d_pat = single_set ( dep ) ) != NULL && MEM_P ( SET_DEST ( d_pat ) ) ) { rtx src_mem = XEXP ( SET_SRC ( i_pat ) , <NUM_LIT> ) ; if ( ( SYMBOL_REF_P ( src_mem ) && CONSTANT_POOL_ADDRESS_P ( src_mem ) ) || reg_mentioned_p ( stack_pointer_rtx , src_mem ) || reg_mentioned_p ( frame_pointer_rtx , src_mem ) || reg_mentioned_p ( hard_frame_pointer_rtx , src_mem ) ) return <NUM_LIT> ; } return cost ;


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


<s> bool arm_allocate_stack_slots_for_args ( void ) { return ! IS_NAKED ( arm_current_func_type ( ) ) ;


<s> int arm_apply_result_size ( void ) { int size = <NUM_LIT> ; if ( TARGET_32BIT ) { if ( TARGET_HARD_FLOAT_ABI ) size += <NUM_LIT> ; if ( TARGET_IWMMXT_ABI ) size += <NUM_LIT> ;


<s> return pcum -> aapcs_partial ; } if ( TARGET_IWMMXT_ABI && arm_vector_mode_supported_p ( arg . mode ) ) return <NUM_LIT> ; if ( NUM_ARG_REGS > nregs && ( NUM_ARG_REGS < nregs + ARM_NUM_REGS2 ( arg . mode , arg . type ) ) && pcum -> can_split ) return ( NUM_ARG_REGS - nregs ) * UNITS_PER_WORD ;


<s> if ( c == PLUS ) { if ( CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) ) return <NUM_LIT> ; if ( ARITHMETIC_P ( XEXP ( x , <NUM_LIT> ) ) || ARITHMETIC_P ( XEXP ( x , <NUM_LIT> ) ) ) return <NUM_LIT> ; return <NUM_LIT> ; }


<s> static bool arm_array_mode_supported_p ( machine_mode mode , unsigned HOST_WIDE_INT nelems ) { if ( TARGET_NEON && ! BYTES_BIG_ENDIAN && ( VALID_NEON_DREG_MODE ( mode ) || VALID_NEON_QREG_MODE ( mode ) ) && ( nelems >= <NUM_LIT> && nelems <= <NUM_LIT> ) ) return true ;

if ( TARGET_HAVE_MVE && ! BYTES_BIG_ENDIAN && VALID_MVE_MODE ( mode ) && ( nelems == <NUM_LIT> || nelems == <NUM_LIT> ) ) return true ;


<s> return HOST_WIDE_INT_1U << <NUM_LIT> ;


<s> void arm_asm_declare_function_name ( FILE * file , const char * name , tree decl ) { size_t cmse_name_len ; char * cmse_name = <NUM_LIT> ; char cmse_prefix [ ] = <STR_LIT> ; if ( use_cmse && lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ) { cmse_name_len = sizeof ( cmse_prefix ) + strlen ( name ) ; cmse_name = XALLOCAVEC ( char , cmse_name_len ) ;

snprintf ( cmse_name , cmse_name_len , <STR_LIT> , cmse_prefix , name ) ;


<s> char cmse_prefix [ ] = <STR_LIT> ; if ( use_cmse && lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ) { cmse_name_len = sizeof ( cmse_prefix ) + strlen ( name ) ; cmse_name = XALLOCAVEC ( char , cmse_name_len ) ; snprintf ( cmse_name , cmse_name_len , <STR_LIT> , cmse_prefix , name ) ; targetm . asm_out . globalize_label ( file , cmse_name ) ; ARM_DECLARE_FUNCTION_NAME ( file , cmse_name , decl ) ; ASM_OUTPUT_TYPE_DIRECTIVE ( file , cmse_name , <STR_LIT> ) ; } ARM_DECLARE_FUNCTION_NAME ( file , name , decl ) ; ASM_OUTPUT_TYPE_DIRECTIVE ( file , name , <STR_LIT> ) ; ASM_DECLARE_RESULT ( file , DECL_RESULT ( decl ) ) ; ASM_OUTPUT_LABEL ( file , name ) ; if ( cmse_name ) ASM_OUTPUT_LABEL ( file , cmse_name ) ;


<s> if ( flags & SECTION_ARM_PURECODE ) { * num = <NUM_LIT> ; if ( ! ( flags & SECTION_DEBUG ) ) * num |= <NUM_LIT> ; if ( flags & SECTION_EXCLUDE ) * num |= <NUM_LIT> ; if ( flags & SECTION_WRITE ) * num |= <NUM_LIT> ; if ( flags & SECTION_CODE ) * num |= <NUM_LIT> ; if ( flags & SECTION_MERGE ) * num |= <NUM_LIT> ; if ( flags & SECTION_STRINGS ) * num |= <NUM_LIT> ; if ( flags & SECTION_TLS ) * num |= <NUM_LIT> ; if ( HAVE_COMDAT_GROUP && ( flags & SECTION_LINKONCE ) ) * num |= <NUM_LIT> ; return true ; }


<s> * num = <NUM_LIT> ; if ( ! ( flags & SECTION_DEBUG ) ) * num |= <NUM_LIT> ; if ( flags & SECTION_EXCLUDE ) * num |= <NUM_LIT> ; if ( flags & SECTION_WRITE ) * num |= <NUM_LIT> ; if ( flags & SECTION_CODE ) * num |= <NUM_LIT> ; if ( flags & SECTION_MERGE ) * num |= <NUM_LIT> ; if ( flags & SECTION_STRINGS ) * num |= <NUM_LIT> ; if ( flags & SECTION_TLS ) * num |= <NUM_LIT> ;

if ( HAVE_COMDAT_GROUP && ( flags & SECTION_LINKONCE ) ) * num |= <NUM_LIT> ;


<s> static void arm_asm_emit_except_personality ( rtx personality ) {


<s> static void arm_asm_emit_except_personality ( rtx personality ) { fputs ( <STR_LIT> , asm_out_file ) ; output_addr_const ( asm_out_file , personality ) ;


<s> exception_section = get_unnamed_section ( <NUM_LIT> , output_section_asm_op , <STR_LIT> ) ; if ( target_pure_code ) text_section -> unnamed . data = <STR_LIT> ;


<s> if ( target_pure_code ) text_section -> unnamed . data = <STR_LIT> ;


<s> name += skip ; } if ( verbatim ) fputs ( name , stream ) ;

else asm_fprintf ( stream , <STR_LIT> , name ) ;


<s> int verbatim = <NUM_LIT> ; while ( ( skip = arm_get_strip_length ( * name ) ) ) { verbatim |= ( * name == '*' ) ; name += skip ; }

if ( verbatim ) fputs ( name , stream ) ;


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


<s> gcc_assert ( MEM_P ( mem ) ) ; addr = XEXP ( mem , <NUM_LIT> ) ; if ( GET_CODE ( addr ) == CONST && GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == PLUS ) addr = XEXP ( addr , <NUM_LIT> ) ; if ( LABEL_REF_P ( addr ) || GET_CODE ( addr ) == PLUS ) { int insns = REG_NREGS ( reg ) / <NUM_LIT> ; return insns * <NUM_LIT> ; } else return <NUM_LIT> ;


<s> int arm_attr_length_move_neon ( rtx_insn * insn ) { rtx reg , mem , addr ; int load ; machine_mode mode ; extract_insn_cached ( insn ) ; if ( REG_P ( recog_data . operand [ <NUM_LIT> ] ) && REG_P ( recog_data . operand [ <NUM_LIT> ] ) ) { mode = GET_MODE ( recog_data . operand [ <NUM_LIT> ] ) ; switch ( mode ) { case E_EImode : case E_OImode : return <NUM_LIT> ; case E_CImode : return <NUM_LIT> ; case E_XImode : return <NUM_LIT> ; default : gcc_unreachable ( ) ; } } load = REG_P ( recog_data . operand [ <NUM_LIT> ] ) ; reg = recog_data . operand [ ! load ] ;


<s> if ( ldm_p && REGNO_REG_CLASS ( regno ) == HI_REGS ) return <NUM_LIT> ; for ( ; indx >= first_indx ; indx -- ) { regno = REGNO ( XEXP ( XVECEXP ( parallel_op , <NUM_LIT> , indx ) , <NUM_LIT> ) ) ; if ( REGNO_REG_CLASS ( regno ) == HI_REGS && ( regno != PC_REGNUM || ldm_p ) ) return <NUM_LIT> ; }


<s> int i , regno , hi_reg ; int num_saves = XVECLEN ( parallel_op , <NUM_LIT> ) ; if ( TARGET_ARM ) return <NUM_LIT> ; if ( TARGET_THUMB1 ) return <NUM_LIT> ; regno = REGNO ( first_op ) ; hi_reg = ( REGNO_REG_CLASS ( regno ) == HI_REGS ) && ( regno != LR_REGNUM ) ; for ( i = <NUM_LIT> ; i < num_saves && ! hi_reg ; i ++ ) { regno = REGNO ( XEXP ( XVECEXP ( parallel_op , <NUM_LIT> , i ) , <NUM_LIT> ) ) ; hi_reg |= ( REGNO_REG_CLASS ( regno ) == HI_REGS ) && ( regno != LR_REGNUM ) ;


<s> int num_saves = XVECLEN ( parallel_op , <NUM_LIT> ) ; if ( TARGET_ARM ) return <NUM_LIT> ; if ( TARGET_THUMB1 ) return <NUM_LIT> ; regno = REGNO ( first_op ) ; hi_reg = ( REGNO_REG_CLASS ( regno ) == HI_REGS ) && ( regno != LR_REGNUM ) ;

for ( i = <NUM_LIT> ; i < num_saves && ! hi_reg ; i ++ ) {


<s> case ARM_PRE_INC : if ( ! TARGET_LDRD && GET_MODE_SIZE ( mode ) > <NUM_LIT> ) return false ; if ( FLOAT_MODE_P ( mode ) || VECTOR_MODE_P ( mode ) ) return false ; return true ;


<s> if ( TARGET_SOFT_FLOAT && ( TARGET_LDRD || GET_MODE_SIZE ( mode ) <= <NUM_LIT> ) ) return true ; switch ( code ) { case ARM_POST_INC : case ARM_PRE_DEC : if ( VECTOR_MODE_P ( mode ) ) { if ( code != ARM_PRE_DEC ) return true ; else return false ; } return true ;


<s> static unsigned int arm_autovectorize_vector_modes ( vector_modes * modes , bool ) { if ( ! TARGET_NEON_VECTORIZE_DOUBLE ) { modes -> safe_push ( V16QImode ) ;


<s> modes -> safe_push ( V8QImode ) ; } return <NUM_LIT> ;


<s> case CODE_LABEL : return <NUM_LIT> ; case INSN : case CALL_INSN : return base_cost ; case JUMP_INSN : return base_cost - <NUM_LIT> ; default : return base_cost + <NUM_LIT> ;


<s> set_optab_libfunc ( sub_optab , mode , NULL ) ; set_optab_libfunc ( eq_optab , mode , NULL ) ; set_optab_libfunc ( ne_optab , mode , NULL ) ; set_optab_libfunc ( lt_optab , mode , NULL ) ; set_optab_libfunc ( le_optab , mode , NULL ) ; set_optab_libfunc ( ge_optab , mode , NULL ) ; set_optab_libfunc ( gt_optab , mode , NULL ) ;

set_optab_libfunc ( unord_optab , mode , NULL ) ;


<s> set_optab_libfunc ( ne_optab , mode , NULL ) ; set_optab_libfunc ( lt_optab , mode , NULL ) ; set_optab_libfunc ( le_optab , mode , NULL ) ;

set_optab_libfunc ( ge_optab , mode , NULL ) ;


<s> leftover = length % bytes_per_iter ; length -= leftover ; arm_adjust_block_mem ( src , bytes_per_iter , & src_reg , & src ) ; arm_adjust_block_mem ( dest , bytes_per_iter , & dest_reg , & dest ) ; final_src = expand_simple_binop ( Pmode , PLUS , src_reg , GEN_INT ( length ) , <NUM_LIT> , <NUM_LIT> , OPTAB_WIDEN ) ; rtx_code_label * label = gen_label_rtx ( ) ; emit_label ( label ) ; arm_block_move_unaligned_straight ( dest , src , bytes_per_iter , interleave_factor ) ; emit_move_insn ( src_reg , plus_constant ( Pmode , src_reg , bytes_per_iter ) ) ; emit_move_insn ( dest_reg , plus_constant ( Pmode , dest_reg , bytes_per_iter ) ) ; test = gen_rtx_NE ( VOIDmode , src_reg , final_src ) ;

emit_jump_insn ( gen_cbranchsi4 ( test , src_reg , final_src , label ) ) ;


<s> emit_label ( label ) ; arm_block_move_unaligned_straight ( dest , src , bytes_per_iter , interleave_factor ) ; emit_move_insn ( src_reg , plus_constant ( Pmode , src_reg , bytes_per_iter ) ) ; emit_move_insn ( dest_reg , plus_constant ( Pmode , dest_reg , bytes_per_iter ) ) ; test = gen_rtx_NE ( VOIDmode , src_reg , final_src ) ; emit_jump_insn ( gen_cbranchsi4 ( test , src_reg , final_src , label ) ) ; if ( leftover ) arm_block_move_unaligned_straight ( dest , src , leftover , interleave_factor ) ;


<s> addr = plus_constant ( Pmode , dst , i ) ; mem = adjust_automodify_address ( dstbase , SImode , addr , i ) ; if ( ( align & <NUM_LIT> ) == <NUM_LIT> ) emit_move_insn ( mem , reg ) ; else emit_insn ( gen_unaligned_storesi ( mem , reg ) ) ; } if ( unaligned_access && i > <NUM_LIT> && ( i + <NUM_LIT> ) == length ) { addr = plus_constant ( Pmode , dst , i - <NUM_LIT> ) ; mem = adjust_automodify_address ( dstbase , SImode , addr , i - <NUM_LIT> ) ; if ( ( align & <NUM_LIT> ) == <NUM_LIT> ) set_mem_align ( mem , BITS_PER_UNIT ) ; emit_insn ( gen_unaligned_storesi ( mem , reg ) ) ; return true ; } if ( i + <NUM_LIT> <= length ) { reg = gen_lowpart ( HImode , val_reg ) ; addr = plus_constant ( Pmode , dst , i ) ; mem = adjust_automodify_address ( dstbase , HImode , addr , i ) ; if ( ( align & <NUM_LIT> ) == <NUM_LIT> ) emit_move_insn ( mem , reg ) ; else emit_insn ( gen_unaligned_storehi ( mem , reg ) ) ; i += <NUM_LIT> ; } if ( i + <NUM_LIT> == length ) { reg = gen_lowpart ( QImode , val_reg ) ;


<s> i = <NUM_LIT> ; if ( mode == V16QImode ) { mem = adjust_automodify_address ( dstbase , mode , dst , offset ) ; emit_insn ( gen_movmisalignv16qi ( mem , reg ) ) ; i += nelt_mode ; if ( i + nelt_v8 < length && i + nelt_v16 > length ) { emit_insn ( gen_add2_insn ( dst , GEN_INT ( length - nelt_mode ) ) ) ; offset += length - nelt_mode ; mem = adjust_automodify_address ( dstbase , mode , dst , offset ) ; if ( ( length & <NUM_LIT> ) == <NUM_LIT> ) set_mem_align ( mem , BITS_PER_UNIT * <NUM_LIT> ) ; else if ( ( length & <NUM_LIT> ) == <NUM_LIT> ) set_mem_align ( mem , BITS_PER_UNIT * <NUM_LIT> ) ; else set_mem_align ( mem , BITS_PER_UNIT ) ; emit_insn ( gen_movmisalignv16qi ( mem , reg ) ) ; return true ; } mode = V8QImode ; nelt_mode = GET_MODE_NUNITS ( mode ) ; reg = gen_lowpart ( V8QImode , reg ) ; } for ( ; ( i + nelt_mode <= length ) ; i += nelt_mode ) { addr = plus_constant ( Pmode , dst , i ) ; mem = adjust_automodify_address ( dstbase , mode , addr , offset + i ) ; if ( MEM_ALIGN ( mem ) >= <NUM_LIT> * BITS_PER_WORD ) emit_move_insn ( mem , reg ) ; else emit_insn ( gen_unaligned_storev8qi ( mem , reg ) ) ; } if ( i + UNITS_PER_WORD == length ) { addr = plus_constant ( Pmode , dst , i - UNITS_PER_WORD ) ; offset += i - UNITS_PER_WORD ; mem = adjust_automodify_address ( dstbase , mode , addr , offset ) ; if ( align > UNITS_PER_WORD ) set_mem_align ( mem , BITS_PER_UNIT * UNITS_PER_WORD ) ; emit_insn ( gen_unaligned_storev8qi ( mem , reg ) ) ; } else if ( i < length ) { emit_insn ( gen_add2_insn ( dst , GEN_INT ( length - nelt_mode ) ) ) ; offset += length - nelt_mode ; mem = adjust_automodify_address ( dstbase , mode , dst , offset ) ;


<s> nelt_v16 = GET_MODE_NUNITS ( V16QImode ) ; if ( length >= nelt_v16 && unaligned_access && ! BYTES_BIG_ENDIAN ) mode = V16QImode ; else mode = V8QImode ; nelt_mode = GET_MODE_NUNITS ( mode ) ; gcc_assert ( length >= nelt_mode ) ; if ( ! arm_block_set_vect_profit_p ( length , align , mode ) ) return false ; dst = copy_addr_to_reg ( XEXP ( dstbase , <NUM_LIT> ) ) ; reg = gen_reg_rtx ( mode ) ; val_vec = gen_const_vec_duplicate ( mode , gen_int_mode ( value , QImode ) ) ; emit_move_insn ( reg , val_vec ) ; i = <NUM_LIT> ; if ( mode == V16QImode ) { mem = adjust_automodify_address ( dstbase , mode , dst , offset ) ; emit_insn ( gen_movmisalignv16qi ( mem , reg ) ) ; i += nelt_mode ; if ( i + nelt_v8 < length && i + nelt_v16 > length ) { emit_insn ( gen_add2_insn ( dst , GEN_INT ( length - nelt_mode ) ) ) ; offset += length - nelt_mode ; mem = adjust_automodify_address ( dstbase , mode , dst , offset ) ; if ( ( length & <NUM_LIT> ) == <NUM_LIT> ) set_mem_align ( mem , BITS_PER_UNIT * <NUM_LIT> ) ;

else if ( ( length & <NUM_LIT> ) == <NUM_LIT> ) set_mem_align ( mem , BITS_PER_UNIT * <NUM_LIT> ) ;


<s> } else { num = arm_const_inline_cost ( SET , val ) ; num += ( length >> <NUM_LIT> ) + leftover [ length & <NUM_LIT> ] ; } if ( unaligned_access && length > <NUM_LIT> && ( length & <NUM_LIT> ) == <NUM_LIT> ) num -- ; return ( num <= arm_block_set_max_insns ( ) ) ;


<s> static bool arm_block_set_unaligned_non_vect ( rtx dstbase , unsigned HOST_WIDE_INT length , unsigned HOST_WIDE_INT value , unsigned HOST_WIDE_INT align ) { unsigned int i ; rtx dst , addr , mem ; rtx val_exp , val_reg , reg ; machine_mode mode ; HOST_WIDE_INT v = value ; gcc_assert ( align == <NUM_LIT> || align == <NUM_LIT> ) ; if ( align == <NUM_LIT> ) v |= ( value << BITS_PER_UNIT ) ; v = sext_hwi ( v , BITS_PER_WORD ) ; val_exp = GEN_INT ( v ) ;

if ( ! arm_block_set_non_vect_profit_p ( val_exp , length , align , true , false ) ) return false ;


<s> gcc_assert ( ( i + nelt_v8 ) > length || mode == V16QImode ) ; if ( i + nelt_v8 < length ) { emit_insn ( gen_add2_insn ( dst , GEN_INT ( length - i ) ) ) ; offset += length - i ; mem = adjust_automodify_address ( dstbase , mode , dst , offset ) ; if ( ( length & <NUM_LIT> ) != <NUM_LIT> && align >= <NUM_LIT> ) set_mem_align ( mem , BITS_PER_UNIT ) ; emit_insn ( gen_movmisalignv16qi ( mem , reg ) ) ; } else if ( i < length && i + nelt_v8 >= length ) { if ( mode == V16QImode ) reg = gen_lowpart ( V8QImode , reg ) ; emit_insn ( gen_add2_insn ( dst , GEN_INT ( ( length - i ) + ( nelt_mode - nelt_v8 ) ) ) ) ; offset += ( length - i ) + ( nelt_mode - nelt_v8 ) ; mem = adjust_automodify_address ( dstbase , V8QImode , dst , offset ) ; if ( ( length & <NUM_LIT> ) != <NUM_LIT> && align >= <NUM_LIT> ) set_mem_align ( mem , BITS_PER_UNIT ) ; emit_insn ( gen_movmisalignv8qi ( mem , reg ) ) ; } return true ;


<s> nelt_v16 = GET_MODE_NUNITS ( V16QImode ) ; if ( length >= nelt_v16 ) { mode = V16QImode ; gen_func = gen_movmisalignv16qi ; } else { mode = V8QImode ; gen_func = gen_movmisalignv8qi ; } nelt_mode = GET_MODE_NUNITS ( mode ) ; gcc_assert ( length >= nelt_mode ) ; if ( ! arm_block_set_vect_profit_p ( length , align , mode ) ) return false ; dst = copy_addr_to_reg ( XEXP ( dstbase , <NUM_LIT> ) ) ; mem = adjust_automodify_address ( dstbase , mode , dst , offset ) ; v = sext_hwi ( v , BITS_PER_WORD ) ; reg = gen_reg_rtx ( mode ) ; val_vec = gen_const_vec_duplicate ( mode , GEN_INT ( v ) ) ; emit_move_insn ( reg , val_vec ) ; for ( i = <NUM_LIT> ; ( i + nelt_mode <= length ) ; i += nelt_mode ) { emit_insn ( ( * gen_func ) ( mem , reg ) ) ; if ( i + <NUM_LIT> * nelt_mode <= length ) { emit_insn ( gen_add2_insn ( dst , GEN_INT ( nelt_mode ) ) ) ; offset += nelt_mode ; mem = adjust_automodify_address ( dstbase , mode , dst , offset ) ; } } gcc_assert ( ( i + nelt_v8 ) > length || mode == V16QImode ) ; if ( i + nelt_v8 < length ) { emit_insn ( gen_add2_insn ( dst , GEN_INT ( length - i ) ) ) ; offset += length - i ; mem = adjust_automodify_address ( dstbase , mode , dst , offset ) ;

if ( ( length & <NUM_LIT> ) != <NUM_LIT> && align >= <NUM_LIT> ) set_mem_align ( mem , BITS_PER_UNIT ) ;


<s> if ( ( ( align & <NUM_LIT> ) != <NUM_LIT> || ( length & <NUM_LIT> ) != <NUM_LIT> ) && ( ! unaligned_access || BYTES_BIG_ENDIAN ) ) return false ; if ( ( align & <NUM_LIT> ) == <NUM_LIT> ) return arm_block_set_aligned_vect ( dstbase , length , value , align ) ;

else return arm_block_set_unaligned_vect ( dstbase , length , value , align ) ;


<s> static bool arm_block_set_vect ( rtx dstbase , unsigned HOST_WIDE_INT length , unsigned HOST_WIDE_INT value , unsigned HOST_WIDE_INT align ) { if ( ( ( align & <NUM_LIT> ) != <NUM_LIT> || ( length & <NUM_LIT> ) != <NUM_LIT> ) && ( ! unaligned_access || BYTES_BIG_ENDIAN ) ) return false ; if ( ( align & <NUM_LIT> ) == <NUM_LIT> ) return arm_block_set_aligned_vect ( dstbase , length , value , align ) ; else return arm_block_set_unaligned_vect ( dstbase , length , value , align ) ;


<s> if ( ! unaligned_p && ( length & <NUM_LIT> ) != <NUM_LIT> ) num ++ ; if ( ! unaligned_p && mode == V16QImode ) num -- ;

return ( num <= arm_block_set_max_insns ( ) ) ;


<s> case vector_scatter_store : return current_tune -> vec_costs -> vec_unalign_store_cost ; case cond_branch_taken : return current_tune -> vec_costs -> cond_taken_branch_cost ; case cond_branch_not_taken : return current_tune -> vec_costs -> cond_not_taken_branch_cost ; case vec_perm : case vec_promote_demote : return current_tune -> vec_costs -> vec_stmt_cost ; case vec_construct : elements = TYPE_VECTOR_SUBPARTS ( vectype ) ; return elements / <NUM_LIT> + <NUM_LIT> ; default : gcc_unreachable ( ) ;


<s> labelno = GEN_INT ( pic_labelno ++ ) ; label = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , labelno ) , UNSPEC_PIC_LABEL ) ; label = gen_rtx_CONST ( VOIDmode , label ) ; sum = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , x , GEN_INT ( reloc ) , label , GEN_INT ( TARGET_ARM ? <NUM_LIT> : <NUM_LIT> ) ) , UNSPEC_TLS ) ; }


<s> if ( recog_memoized ( insn ) == CODE_FOR_tlscall ) return true ; subrtx_iterator :: array_type array ; FOR_EACH_SUBRTX ( iter , array , PATTERN ( insn ) , ALL ) { const_rtx x = * iter ; if ( GET_CODE ( x ) == UNSPEC && ( XINT ( x , <NUM_LIT> ) == UNSPEC_PIC_BASE || XINT ( x , <NUM_LIT> ) == UNSPEC_PIC_UNIFIED ) ) return true ; } rtx set = single_set ( insn ) ;


<s> split_const ( x , & base , & offset ) ; if ( SYMBOL_REF_P ( base ) ) { if ( ( SYMBOL_REF_FLAGS ( base ) & SYMBOL_FLAG_FUNCTION ) && INTVAL ( offset ) != <NUM_LIT> ) return true ; if ( ARM_OFFSETS_MUST_BE_WITHIN_SECTIONS_P && ! offset_within_block_p ( base , INTVAL ( offset ) ) ) return true ;


<s> static bool arm_can_change_mode_class ( machine_mode from , machine_mode to , reg_class_t rclass ) { if ( TARGET_BIG_END && ! ( GET_MODE_SIZE ( from ) == <NUM_LIT> && GET_MODE_SIZE ( to ) == <NUM_LIT> ) && ( GET_MODE_SIZE ( from ) > UNITS_PER_WORD || GET_MODE_SIZE ( to ) > UNITS_PER_WORD ) && reg_classes_intersect_p ( VFP_REGS , rclass ) ) return false ;


<s> if ( TARGET_BIG_END && ! ( GET_MODE_SIZE ( from ) == <NUM_LIT> && GET_MODE_SIZE ( to ) == <NUM_LIT> ) && ( GET_MODE_SIZE ( from ) > UNITS_PER_WORD || GET_MODE_SIZE ( to ) > UNITS_PER_WORD ) && reg_classes_intersect_p ( VFP_REGS , rclass ) ) return false ; return true ;


<s> ( to == STACK_POINTER_REGNUM && frame_pointer_needed ) ? false :

( to == ARM_HARD_FRAME_POINTER_REGNUM && TARGET_THUMB ) ? false :


<s> if ( callee_opts == caller_opts ) return true ; struct arm_build_target caller_target ; struct arm_build_target callee_target ; caller_target . isa = sbitmap_alloc ( isa_num_bits ) ; callee_target . isa = sbitmap_alloc ( isa_num_bits ) ; arm_configure_build_target ( & caller_target , caller_opts , false ) ; arm_configure_build_target ( & callee_target , callee_opts , false ) ;

if ( ! bitmap_subset_p ( callee_target . isa , caller_target . isa ) ) can_inline = false ;


if ( vcall_offset && TARGET_THUMB1 ) return false ;


<s> tree callee_tree = DECL_FUNCTION_SPECIFIC_TARGET ( func ) ; if ( ! callee_tree ) callee_tree = target_option_default_node ; struct cl_target_option * callee_opts = TREE_TARGET_OPTION ( callee_tree ) ;

int flags = callee_opts -> x_target_flags ;


<s> if ( ( TARGET_THUMB1 && rclass == LO_REGS ) || rclass == CC_REG ) return true ; return default_class_likely_spilled_p ( rclass ) ;