<s> if ( TARGET_VFP_BASE && IS_VFP_REGNUM ( regno ) ) { if ( mode == DFmode || mode == DImode ) return VFP_REGNO_OK_FOR_DOUBLE ( regno ) ; if ( mode == HFmode || mode == BFmode || mode == HImode || mode == SFmode || mode == SImode ) return VFP_REGNO_OK_FOR_SINGLE ( regno ) ; if ( TARGET_NEON ) return ( VALID_NEON_DREG_MODE ( mode ) && VFP_REGNO_OK_FOR_DOUBLE ( regno ) ) || ( VALID_NEON_QREG_MODE ( mode ) && NEON_REGNO_OK_FOR_QUAD ( regno ) ) || ( mode == TImode && NEON_REGNO_OK_FOR_NREGS ( regno , <NUM_LIT> ) ) || ( mode == EImode && NEON_REGNO_OK_FOR_NREGS ( regno , <NUM_LIT> ) ) || ( mode == OImode && NEON_REGNO_OK_FOR_NREGS ( regno , <NUM_LIT> ) ) || ( mode == CImode && NEON_REGNO_OK_FOR_NREGS ( regno , <NUM_LIT> ) ) || ( mode == XImode && NEON_REGNO_OK_FOR_NREGS ( regno , <NUM_LIT> ) ) ; if ( TARGET_HAVE_MVE ) return ( ( VALID_MVE_MODE ( mode ) && NEON_REGNO_OK_FOR_QUAD ( regno ) ) || ( mode == OImode && NEON_REGNO_OK_FOR_NREGS ( regno , <NUM_LIT> ) ) || ( mode == XImode && NEON_REGNO_OK_FOR_NREGS ( regno , <NUM_LIT> ) ) ) ; return false ; } if ( TARGET_REALLY_IWMMXT ) { if ( IS_IWMMXT_GR_REGNUM ( regno ) ) return mode == SImode ; if ( IS_IWMMXT_REGNUM ( regno ) ) return VALID_IWMMXT_REG_MODE ( mode ) ; }


<s> static struct machine_function * arm_init_machine_status ( void ) { struct machine_function * machine ; machine = ggc_cleared_alloc < machine_function > ( ) ; machine -> func_type = ARM_FT_UNKNOWN ; machine -> static_chain_stack_bytes = - <NUM_LIT> ;

machine -> pacspval_needed = <NUM_LIT> ;


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

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


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


<s> case <NUM_LIT> : return V8BImode ; case <NUM_LIT> : return V4BImode ;


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


<s> if ( TARGET_IWMMXT_ABI && ! TARGET_IWMMXT ) error ( <STR_LIT> ) ; if ( TARGET_INTERWORK && ! TARGET_BPABI && ! bitmap_bit_p ( arm_active_target . isa , isa_bit_thumb ) ) { warning ( <NUM_LIT> , <STR_LIT> ) ; target_flags &= ~ MASK_INTERWORK ; } if ( TARGET_SOFT_FLOAT ) arm_fpu_attr = FPU_NONE ; else arm_fpu_attr = FPU_VFP ; if ( TARGET_AAPCS_BASED ) { if ( TARGET_CALLER_INTERWORKING ) error ( <STR_LIT> ) ; else if ( TARGET_CALLEE_INTERWORKING ) error ( <STR_LIT> ) ; } if ( ! arm_arch4 && arm_fp16_format != ARM_FP16_FORMAT_NONE ) sorry ( <STR_LIT> ) ; if ( use_cmse && ! arm_arch_cmse ) error ( <STR_LIT> ) ; if ( use_cmse && TARGET_HARD_FLOAT && 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 ; else if ( TARGET_HARD_FLOAT_ABI ) { arm_pcs_default = ARM_PCS_AAPCS_VFP ; if ( ! bitmap_bit_p ( arm_active_target . isa , isa_bit_vfpv2 ) && ! bitmap_bit_p ( arm_active_target . isa , isa_bit_mve ) ) error ( <STR_LIT> ) ; } else arm_pcs_default = ARM_PCS_AAPCS ;


<s> 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 ; if ( arm_stack_protector_guard == SSP_GLOBAL && opts -> x_arm_stack_protector_guard_offset_str ) { error ( <STR_LIT> <STR_LIT> , arm_stack_protector_guard_offset_str ) ; } if ( opts -> x_arm_stack_protector_guard_offset_str ) { char * end ; const char * str = arm_stack_protector_guard_offset_str ; errno = <NUM_LIT> ; long offs = strtol ( arm_stack_protector_guard_offset_str , & end , <NUM_LIT> ) ; if ( ! * str || * end || errno ) error ( <STR_LIT> , str , <STR_LIT> ) ;

arm_stack_protector_guard_offset = offs ;


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

if ( arm_stack_protector_guard == SSP_GLOBAL && opts -> x_arm_stack_protector_guard_offset_str ) {


int cde_bit = bitmap_bit_p ( arm_active_target . isa , cde_bits [ i ] ) ;


if ( arm_fp16_format == ARM_FP16_FORMAT_ALTERNATIVE ) error ( <STR_LIT> ) ;


<s> if ( regno == CC_REGNUM || regno == VFPCC_REGNUM ) return TARGET_THUMB2 ? CC_REG : NO_REGS ; if ( IS_VFP_REGNUM ( regno ) ) { if ( regno <= D7_VFP_REGNUM ) return VFP_D0_D7_REGS ; else if ( regno <= LAST_LO_VFP_REGNUM ) return VFP_LO_REGS ; else return VFP_HI_REGS ; } if ( IS_IWMMXT_REGNUM ( regno ) ) return IWMMXT_REGS ;

if ( IS_IWMMXT_GR_REGNUM ( regno ) ) return IWMMXT_GR_REGS ;


<s> cfun -> machine -> uses_anonymous_args = <NUM_LIT> ; if ( pcum -> pcs_variant <= ARM_PCS_AAPCS_LOCAL ) { nregs = pcum -> aapcs_ncrn ; if ( ! TYPE_NO_NAMED_ARGS_STDARG_P ( TREE_TYPE ( current_function_decl ) ) && ( nregs & <NUM_LIT> ) ) { int res = arm_needs_doubleword_align ( arg . mode , arg . type ) ; if ( res < <NUM_LIT> && warn_psabi ) inform ( input_location , <STR_LIT> <STR_LIT> , arg . type ) ; else if ( res > <NUM_LIT> ) { nregs ++ ; if ( res > <NUM_LIT> && warn_psabi ) inform ( input_location , <STR_LIT> <STR_LIT> , arg . type ) ; } } } else nregs = pcum -> nregs ; if ( nregs < NUM_ARG_REGS ) * pretend_size = ( NUM_ARG_REGS - nregs ) * UNITS_PER_WORD ;


<s> if ( res < <NUM_LIT> && warn_psabi ) inform ( input_location , <STR_LIT> <STR_LIT> , arg . type ) ; else if ( res > <NUM_LIT> ) { nregs ++ ;

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


<s> bool handled_one = false ; if ( arm_except_unwind_info ( & global_options ) != UI_TARGET ) return ; if ( ! ( flag_unwind_tables || crtl -> uses_eh_lsda ) && ( TREE_NOTHROW ( current_function_decl ) || crtl -> all_throwers_are_sibcalls ) ) return ; if ( NOTE_P ( insn ) || ! RTX_FRAME_RELATED_P ( insn ) ) return ; for ( note = REG_NOTES ( insn ) ; note ; note = XEXP ( note , <NUM_LIT> ) ) { switch ( REG_NOTE_KIND ( note ) ) { case REG_FRAME_RELATED_EXPR : pat = XEXP ( note , <NUM_LIT> ) ; goto found ; case REG_CFA_REGISTER : pat = XEXP ( note , <NUM_LIT> ) ; if ( pat == NULL ) { pat = PATTERN ( insn ) ; if ( GET_CODE ( pat ) == PARALLEL ) pat = XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ; } { rtx dest , src ; unsigned reg ; src = SET_SRC ( pat ) ; dest = SET_DEST ( pat ) ; gcc_assert ( src == stack_pointer_rtx || IS_PAC_REGNUM ( REGNO ( src ) ) ) ; reg = REGNO ( dest ) ;

if ( IS_PAC_REGNUM ( REGNO ( src ) ) ) arm_unwind_emit_set ( out_file , PATTERN ( insn ) ) ;


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


<s> unsigned reg ; e0 = XEXP ( p , <NUM_LIT> ) ; e1 = XEXP ( p , <NUM_LIT> ) ; switch ( GET_CODE ( e0 ) ) { case MEM : if ( GET_CODE ( XEXP ( e0 , <NUM_LIT> ) ) != PRE_DEC || ! REG_P ( XEXP ( XEXP ( e0 , <NUM_LIT> ) , <NUM_LIT> ) ) || REGNO ( XEXP ( XEXP ( e0 , <NUM_LIT> ) , <NUM_LIT> ) ) != SP_REGNUM ) abort ( ) ; asm_fprintf ( out_file , <STR_LIT> ) ; if ( IS_VFP_REGNUM ( REGNO ( e1 ) ) ) asm_fprintf ( out_file , <STR_LIT> , ( REGNO ( e1 ) - FIRST_VFP_REGNUM ) / <NUM_LIT> ) ; else asm_fprintf ( out_file , <STR_LIT> , REGNO ( e1 ) ) ; break ; case REG : if ( REGNO ( e0 ) == SP_REGNUM ) { if ( GET_CODE ( e1 ) != PLUS || ! REG_P ( XEXP ( e1 , <NUM_LIT> ) ) || REGNO ( XEXP ( e1 , <NUM_LIT> ) ) != SP_REGNUM || ! CONST_INT_P ( XEXP ( e1 , <NUM_LIT> ) ) ) abort ( ) ; asm_fprintf ( out_file , <STR_LIT> , - INTVAL ( XEXP ( e1 , <NUM_LIT> ) ) ) ; } else if ( REGNO ( e0 ) == HARD_FRAME_POINTER_REGNUM ) { HOST_WIDE_INT offset ; if ( GET_CODE ( e1 ) == PLUS ) { if ( ! REG_P ( XEXP ( e1 , <NUM_LIT> ) ) || ! CONST_INT_P ( XEXP ( e1 , <NUM_LIT> ) ) ) abort ( ) ; reg = REGNO ( XEXP ( e1 , <NUM_LIT> ) ) ; offset = INTVAL ( XEXP ( e1 , <NUM_LIT> ) ) ; asm_fprintf ( out_file , <STR_LIT> , HARD_FRAME_POINTER_REGNUM , reg , offset ) ;


<s> if ( GET_CODE ( XEXP ( e0 , <NUM_LIT> ) ) != PRE_DEC || ! REG_P ( XEXP ( XEXP ( e0 , <NUM_LIT> ) , <NUM_LIT> ) ) || REGNO ( XEXP ( XEXP ( e0 , <NUM_LIT> ) , <NUM_LIT> ) ) != SP_REGNUM ) abort ( ) ; asm_fprintf ( out_file , <STR_LIT> ) ; if ( IS_VFP_REGNUM ( REGNO ( e1 ) ) ) asm_fprintf ( out_file , <STR_LIT> , ( REGNO ( e1 ) - FIRST_VFP_REGNUM ) / <NUM_LIT> ) ; else asm_fprintf ( out_file , <STR_LIT> , REGNO ( e1 ) ) ; break ; case REG : if ( REGNO ( e0 ) == SP_REGNUM ) { if ( GET_CODE ( e1 ) != PLUS || ! REG_P ( XEXP ( e1 , <NUM_LIT> ) ) || REGNO ( XEXP ( e1 , <NUM_LIT> ) ) != SP_REGNUM || ! CONST_INT_P ( XEXP ( e1 , <NUM_LIT> ) ) ) abort ( ) ; asm_fprintf ( out_file , <STR_LIT> , - INTVAL ( XEXP ( e1 , <NUM_LIT> ) ) ) ; } else if ( REGNO ( e0 ) == HARD_FRAME_POINTER_REGNUM ) { HOST_WIDE_INT offset ; if ( GET_CODE ( e1 ) == PLUS ) { if ( ! REG_P ( XEXP ( e1 , <NUM_LIT> ) ) || ! CONST_INT_P ( XEXP ( e1 , <NUM_LIT> ) ) ) abort ( ) ; reg = REGNO ( XEXP ( e1 , <NUM_LIT> ) ) ; offset = INTVAL ( XEXP ( e1 , <NUM_LIT> ) ) ; asm_fprintf ( out_file , <STR_LIT> , HARD_FRAME_POINTER_REGNUM , reg , offset ) ; } else if ( REG_P ( e1 ) ) { reg = REGNO ( e1 ) ; asm_fprintf ( out_file , <STR_LIT> , HARD_FRAME_POINTER_REGNUM , reg ) ; } else abort ( ) ; } else if ( REG_P ( e1 ) && REGNO ( e1 ) == SP_REGNUM ) { asm_fprintf ( out_file , <STR_LIT> , REGNO ( e0 ) ) ; } else if ( GET_CODE ( e1 ) == PLUS && REG_P ( XEXP ( e1 , <NUM_LIT> ) ) && REGNO ( XEXP ( e1 , <NUM_LIT> ) ) == SP_REGNUM && CONST_INT_P ( XEXP ( e1 , <NUM_LIT> ) ) ) { asm_fprintf ( out_file , <STR_LIT> , REGNO ( e0 ) , ( int ) INTVAL ( XEXP ( e1 , <NUM_LIT> ) ) ) ; } else if ( REGNO ( e0 ) == IP_REGNUM && arm_current_function_pac_enabled_p ( ) ) { if ( cfun -> machine -> pacspval_needed ) asm_fprintf ( out_file , <STR_LIT> ) ;


<s> cl_target_option_save ( & cl_opts , opts , opts_set ) ; arm_configure_build_target ( & arm_active_target , & cl_opts , opts_set , false ) ; arm_option_check_internal ( opts ) ; arm_option_reconfigure_globals ( ) ; arm_options_perform_arch_sanity_checks ( ) ; arm_option_override_internal ( opts , opts_set ) ;

return build_target_option_node ( opts , opts_set ) ;


<s> static bool arm_vectorize_vec_perm_const ( machine_mode vmode , machine_mode op_mode , rtx target , rtx op0 , rtx op1 , const vec_perm_indices & sel ) { if ( vmode != op_mode ) return false ; struct expand_vec_perm_d d ; int i , nelt , which ; if ( ! VALID_NEON_DREG_MODE ( vmode ) && ! VALID_NEON_QREG_MODE ( vmode ) ) return false ; d . target = target ; if ( op0 ) { rtx nop0 = force_reg ( vmode , op0 ) ; if ( op0 == op1 ) op1 = nop0 ; op0 = nop0 ; } if ( op1 ) op1 = force_reg ( vmode , op1 ) ; d . op0 = op0 ; d . op1 = op1 ; d . vmode = vmode ; gcc_assert ( VECTOR_MODE_P ( d . vmode ) ) ; d . testing_p = ! target ; nelt = GET_MODE_NUNITS ( d . vmode ) ; for ( i = which = <NUM_LIT> ; i < nelt ; ++ i ) { int ei = sel [ i ] & ( <NUM_LIT> * nelt - <NUM_LIT> ) ; which |= ( ei < nelt ? <NUM_LIT> : <NUM_LIT> ) ; } switch ( which ) { default : gcc_unreachable ( ) ; case <NUM_LIT> : d . one_vector_p = false ;

if ( d . testing_p || ! rtx_equal_p ( op0 , op1 ) ) break ;


<s> bool arm_vector_mode_supported_p ( machine_mode mode ) { if ( TARGET_NEON && ( mode == V2SFmode || mode == V4SImode || mode == V8HImode || mode == V4HFmode || mode == V16QImode || mode == V4SFmode || mode == V2DImode || mode == V8HFmode || mode == V4BFmode || mode == V8BFmode ) ) return true ; if ( ( TARGET_NEON || TARGET_IWMMXT ) && ( ( mode == V2SImode ) || ( mode == V4HImode ) || ( mode == V8QImode ) ) ) return true ; if ( TARGET_INT_SIMD && ( mode == V4UQQmode || mode == V4QQmode || mode == V2UHQmode || mode == V2HQmode || mode == V2UHAmode || mode == V2HAmode ) ) return true ;

if ( TARGET_HAVE_MVE && ( VALID_MVE_SI_MODE ( mode ) || VALID_MVE_PRED_MODE ( mode ) ) ) return true ;


<s> bool arm_vector_mode_supported_p ( machine_mode mode ) { if ( TARGET_NEON && ( mode == V2SFmode || mode == V4SImode || mode == V8HImode || mode == V4HFmode || mode == V16QImode || mode == V4SFmode || mode == V2DImode || mode == V8HFmode || mode == V4BFmode || mode == V8BFmode ) ) return true ;

if ( ( TARGET_NEON || TARGET_IWMMXT ) && ( ( mode == V2SImode ) || ( mode == V4HImode ) || ( mode == V8QImode ) ) ) return true ;


<s> if ( dwarf_regs_mask & ( <NUM_LIT> << i ) ) num_dwarf_regs ++ ; } gcc_assert ( num_regs && num_regs <= <NUM_LIT> ) ; gcc_assert ( ( dwarf_regs_mask & ~ mask ) == <NUM_LIT> ) ; par = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( num_regs ) ) ; dwarf = gen_rtx_SEQUENCE ( VOIDmode , rtvec_alloc ( num_dwarf_regs + <NUM_LIT> ) ) ; dwarf_par_index = <NUM_LIT> ; for ( i = <NUM_LIT> ; i <= LAST_ARM_REGNUM ; i ++ ) { if ( mask & ( <NUM_LIT> << i ) ) { rtx dwarf_reg = reg = gen_rtx_REG ( SImode , i ) ; if ( arm_current_function_pac_enabled_p ( ) && i == IP_REGNUM ) dwarf_reg = gen_rtx_REG ( SImode , RA_AUTH_CODE ) ;

XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_SET ( gen_frame_mem ( BLKmode , gen_rtx_PRE_MODIFY ( Pmode , stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - <NUM_LIT> * num_regs ) ) ) , gen_rtx_UNSPEC ( BLKmode , gen_rtvec ( <NUM_LIT> , reg ) , UNSPEC_PUSH_MULT ) ) ;


<s> unsigned HOST_WIDE_INT len ; HOST_WIDE_INT align ; rtx src , dst , base ; rtx reg0 ; bool src_aligned , dst_aligned ; bool src_volatile , dst_volatile ; gcc_assert ( CONST_INT_P ( operands [ <NUM_LIT> ] ) ) ; gcc_assert ( CONST_INT_P ( operands [ <NUM_LIT> ] ) ) ; len = UINTVAL ( operands [ <NUM_LIT> ] ) ; if ( len > <NUM_LIT> ) return false ; align = INTVAL ( operands [ <NUM_LIT> ] ) ; if ( ( ! unaligned_access ) && ( len >= <NUM_LIT> ) && ( ( align & <NUM_LIT> ) != <NUM_LIT> ) ) return false ; dst = operands [ <NUM_LIT> ] ; dst_volatile = MEM_VOLATILE_P ( dst ) ; dst_aligned = MEM_ALIGN ( dst ) >= BITS_PER_WORD ; base = copy_to_mode_reg ( SImode , XEXP ( dst , <NUM_LIT> ) ) ; dst = adjust_automodify_address ( dst , VOIDmode , base , <NUM_LIT> ) ; src = operands [ <NUM_LIT> ] ; src_volatile = MEM_VOLATILE_P ( src ) ; src_aligned = MEM_ALIGN ( src ) >= BITS_PER_WORD ; base = copy_to_mode_reg ( SImode , XEXP ( src , <NUM_LIT> ) ) ; src = adjust_automodify_address ( src , VOIDmode , base , <NUM_LIT> ) ; if ( ! unaligned_access && ! ( src_aligned && dst_aligned ) ) return false ; if ( src_volatile || dst_volatile ) return false ; if ( ! ( dst_aligned || src_aligned ) ) return arm_gen_cpymemqi ( operands ) ; src = adjust_address ( src , src_aligned ? DImode : SImode , <NUM_LIT> ) ; dst = adjust_address ( dst , dst_aligned ? DImode : SImode , <NUM_LIT> ) ; while ( len >= <NUM_LIT> ) {


<s> unsigned shift_c = <NUM_LIT> / n_elts ; unsigned i ; int hi_val = <NUM_LIT> ; for ( i = <NUM_LIT> ; i < n_elts ; i ++ ) { rtx el = CONST_VECTOR_ELT ( const_vec , i ) ; unsigned HOST_WIDE_INT elpart ; gcc_assert ( CONST_INT_P ( el ) ) ; elpart = INTVAL ( el ) & ( ( <NUM_LIT> << el_prec ) - <NUM_LIT> ) ;

unsigned index = BYTES_BIG_ENDIAN ? n_elts - i - <NUM_LIT> : i ;


<s> elpart = INTVAL ( el ) & ( ( <NUM_LIT> << el_prec ) - <NUM_LIT> ) ; unsigned index = BYTES_BIG_ENDIAN ? n_elts - i - <NUM_LIT> : i ; hi_val |= elpart << ( index * shift_c ) ; }

return gen_int_mode ( hi_val , SImode ) ;


<s> return ( ( ( mode == E_V8QImode || mode == E_V4QImode || mode == E_V4HImode ) ? reg_no <= LAST_LO_REGNUM : ( reg_no < LAST_ARM_REGNUM && reg_no != SP_REGNUM ) ) || ( ! strict && reg_no >= FIRST_PSEUDO_REGISTER ) ) ; } else if ( ( ( code == POST_MODIFY || code == PRE_MODIFY ) && GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == PLUS && XEXP ( op , <NUM_LIT> ) == XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) && REG_P ( XEXP ( op , <NUM_LIT> ) ) && GET_CODE ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) == CONST_INT ) || ( reload_completed && code == PLUS && REG_P ( XEXP ( op , <NUM_LIT> ) ) && GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == CONST_INT ) ) { reg_no = arm_effective_regno ( XEXP ( op , <NUM_LIT> ) , strict ) ; if ( code == PLUS ) val = INTVAL ( XEXP ( op , <NUM_LIT> ) ) ; else val = INTVAL ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) ; switch ( mode ) { case E_V16QImode : case E_V8QImode : case E_V4QImode : if ( abs ( val ) > <NUM_LIT> ) return FALSE ; break ; case E_V8HImode : case E_V8HFmode : case E_V4HImode : case E_V4HFmode : if ( val % <NUM_LIT> != <NUM_LIT> || abs ( val ) > <NUM_LIT> ) return FALSE ; break ; case E_V4SImode : case E_V4SFmode : if ( val % <NUM_LIT> != <NUM_LIT> || abs ( val ) > <NUM_LIT> ) return FALSE ; break ; default :


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

else if ( TARGET_HAVE_MVE && VALID_MVE_PRED_MODE ( mode ) ) return mve_bool_vec_to_const ( const_vec ) ;


<s> int n_const = <NUM_LIT> ; int i ; if ( GET_CODE ( vals ) == CONST_VECTOR ) const_vec = vals ; else if ( GET_CODE ( vals ) == PARALLEL ) { for ( i = <NUM_LIT> ; i < n_elts ; ++ i ) { rtx x = XVECEXP ( vals , <NUM_LIT> , i ) ; if ( CONST_INT_P ( x ) || CONST_DOUBLE_P ( x ) ) n_const ++ ; } if ( n_const == n_elts ) const_vec = gen_rtx_CONST_VECTOR ( mode , XVEC ( vals , <NUM_LIT> ) ) ; } else gcc_unreachable ( ) ; if ( const_vec != NULL && simd_immediate_valid_for_move ( const_vec , mode , NULL , NULL ) ) return const_vec ; else if ( TARGET_HAVE_MVE && VALID_MVE_PRED_MODE ( mode ) ) return mve_bool_vec_to_const ( const_vec ) ;

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


<s> rtx_insn * thumb1_md_asm_adjust ( vec < rtx > & outputs , vec < rtx > & , vec < machine_mode > & , vec < const char * > & constraints , vec < rtx > & , HARD_REG_SET & ) { for ( unsigned i = <NUM_LIT> , n = outputs . length ( ) ; i < n ; ++ i ) if ( strncmp ( constraints [ i ] , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) { sorry ( <STR_LIT> ) ; break ;


<s> else if ( num_regs == <NUM_LIT> ) { rtx par = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( <NUM_LIT> ) ) ; rtx reg = gen_rtx_REG ( SImode , PC_REGNUM ) ; rtx addr = gen_rtx_MEM ( SImode , gen_rtx_POST_INC ( SImode , stack_pointer_rtx ) ) ; set_mem_alias_set ( addr , get_frame_alias_set ( ) ) ; XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = ret_rtx ; XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_SET ( reg , addr ) ; RTX_FRAME_RELATED_P ( XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) ) = <NUM_LIT> ; emit_jump_insn ( par ) ; } else { saved_regs_mask &= ~ ( <NUM_LIT> << LR_REGNUM ) ;


<s> for ( i = <NUM_LIT> , num_regs = <NUM_LIT> ; i <= LAST_ARM_REGNUM ; i ++ ) if ( saved_regs_mask & ( <NUM_LIT> << i ) ) num_regs ++ ; if ( ! simple_return && saved_regs_mask ) { gcc_assert ( ! IS_CMSE_ENTRY ( arm_current_func_type ( ) ) ) ; if ( arm_current_function_pac_enabled_p ( ) ) { gcc_assert ( ! ( saved_regs_mask & ( <NUM_LIT> << PC_REGNUM ) ) ) ; arm_emit_multi_reg_pop ( saved_regs_mask ) ; emit_insn ( gen_aut_nop ( ) ) ; emit_jump_insn ( simple_return_rtx ) ; } else if ( num_regs == <NUM_LIT> ) { rtx par = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( <NUM_LIT> ) ) ; rtx reg = gen_rtx_REG ( SImode , PC_REGNUM ) ; rtx addr = gen_rtx_MEM ( SImode , gen_rtx_POST_INC ( SImode , stack_pointer_rtx ) ) ; set_mem_alias_set ( addr , get_frame_alias_set ( ) ) ; XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = ret_rtx ; XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_SET ( reg , addr ) ; RTX_FRAME_RELATED_P ( XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) ) = <NUM_LIT> ; emit_jump_insn ( par ) ; } else { saved_regs_mask &= ~ ( <NUM_LIT> << LR_REGNUM ) ; saved_regs_mask |= ( <NUM_LIT> << PC_REGNUM ) ; arm_emit_multi_reg_pop ( saved_regs_mask ) ; } } else {


<s> 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 ) ) || ( TARGET_HAVE_MVE && VALID_MVE_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> 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_or_fixed_reg_p ( <NUM_LIT> ) ) return <NUM_LIT> ; if ( arm_size_return_regs ( ) >= ( <NUM_LIT> * UNITS_PER_WORD ) ) return <NUM_LIT> ; if ( sibling ) { gcc_assert ( CALL_P ( sibling ) ) ; if ( find_regno_fusage ( sibling , USE , <NUM_LIT> ) ) return <NUM_LIT> ; } if ( saved_int_regs & <NUM_LIT> ) return <NUM_LIT> ; } if ( TARGET_INTERWORK && saved_int_regs != <NUM_LIT> && ! IS_INTERRUPT ( func_type ) ) return <NUM_LIT> ; if ( iscond && arm_tune_strongarm ) { if ( saved_int_regs != <NUM_LIT> && saved_int_regs != ( <NUM_LIT> << LR_REGNUM ) ) return <NUM_LIT> ; if ( flag_pic && arm_pic_register != INVALID_REGNUM && df_regs_ever_live_p ( PIC_OFFSET_TABLE_REGNUM ) ) return <NUM_LIT> ;


<s> char * aof_data_section ( ) { static char buf [ <NUM_LIT> ] ; sprintf ( buf , <STR_LIT> , arm_data_section_count ++ ) ;


<s> static char buf [ <NUM_LIT> ] ; sprintf ( buf , <STR_LIT> , arm_data_section_count ++ ) ; return buf ;


<s> sprintf ( buf , <STR_LIT> , arm_text_section_count ++ ) ; if ( flag_pic ) strcat ( buf , <STR_LIT> ) ; return buf ;


minipool_startobj = ( char * ) obstack_alloc ( & minipool_obstack , <NUM_LIT> ) ;


<s> gcc_obstack_init ( & minipool_obstack ) ; minipool_startobj = ( char * ) obstack_alloc ( & minipool_obstack , <NUM_LIT> ) ;


<s> static unsigned long arm_compute_func_type ( ) { unsigned long type = ARM_FT_UNKNOWN ; tree a ; tree attr ; if ( TREE_CODE ( current_function_decl ) != FUNCTION_DECL ) abort ( ) ; if ( optimize > <NUM_LIT> && current_function_nothrow && TREE_THIS_VOLATILE ( current_function_decl ) ) type |= ARM_FT_VOLATILE ;

if ( current_function_needs_context ) type |= ARM_FT_NESTED ;


<s> unsigned int save_reg_mask = <NUM_LIT> ; unsigned int reg ; if ( IS_INTERRUPT ( func_type ) ) { unsigned int max_reg ; if ( ARM_FUNC_TYPE ( func_type ) == ARM_FT_FIQ ) max_reg = <NUM_LIT> ; else max_reg = <NUM_LIT> ; for ( reg = <NUM_LIT> ; reg <= max_reg ; reg ++ ) if ( regs_ever_live [ reg ] || ( ! current_function_is_leaf && call_used_regs [ reg ] ) ) save_reg_mask |= ( <NUM_LIT> << reg ) ; } else { for ( reg = <NUM_LIT> ; reg <= <NUM_LIT> ; reg ++ ) if ( regs_ever_live [ reg ] && ! call_used_regs [ reg ] ) save_reg_mask |= ( <NUM_LIT> << reg ) ;


<s> unsigned int max_reg ; if ( ARM_FUNC_TYPE ( func_type ) == ARM_FT_FIQ ) max_reg = <NUM_LIT> ; else max_reg = <NUM_LIT> ; for ( reg = <NUM_LIT> ; reg <= max_reg ; reg ++ ) if ( regs_ever_live [ reg ] || ( ! current_function_is_leaf && call_used_regs [ reg ] ) ) save_reg_mask |= ( <NUM_LIT> << reg ) ; } else { for ( reg = <NUM_LIT> ; reg <= <NUM_LIT> ; reg ++ ) if ( regs_ever_live [ reg ] && ! call_used_regs [ reg ] ) save_reg_mask |= ( <NUM_LIT> << reg ) ; if ( ! TARGET_APCS_FRAME && ! frame_pointer_needed && regs_ever_live [ HARD_FRAME_POINTER_REGNUM ] && ! call_used_regs [ HARD_FRAME_POINTER_REGNUM ] ) save_reg_mask |= <NUM_LIT> << HARD_FRAME_POINTER_REGNUM ; if ( flag_pic && ! TARGET_SINGLE_PIC_BASE && regs_ever_live [ PIC_OFFSET_TABLE_REGNUM ] ) save_reg_mask |= <NUM_LIT> << PIC_OFFSET_TABLE_REGNUM ;


<s> unsigned long func_type = arm_current_func_type ( ) ; if ( IS_NAKED ( func_type ) ) return <NUM_LIT> ; if ( frame_pointer_needed ) save_reg_mask |= ( <NUM_LIT> << ARM_HARD_FRAME_POINTER_REGNUM ) | ( <NUM_LIT> << IP_REGNUM ) | ( <NUM_LIT> << LR_REGNUM ) | ( <NUM_LIT> << PC_REGNUM ) ; if ( IS_VOLATILE ( func_type ) ) return save_reg_mask ;

save_reg_mask |= arm_compute_save_reg0_reg12_mask ( ) ;


<s> unsigned long arm_current_func_type ( ) {

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


<s> insn = emit_insn ( gen_rtx_SET ( VOIDmode , insn , gen_rtx_REG ( XFmode , reg ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } } else { int start_reg = LAST_ARM_FP_REGNUM ; for ( reg = LAST_ARM_FP_REGNUM ; reg >= FIRST_ARM_FP_REGNUM ; reg -- ) { if ( regs_ever_live [ reg ] && ! call_used_regs [ reg ] ) { if ( start_reg - reg == <NUM_LIT> ) { insn = emit_sfm ( reg , <NUM_LIT> ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; start_reg = reg - <NUM_LIT> ; } } else { if ( start_reg != reg ) { insn = emit_sfm ( reg + <NUM_LIT> , start_reg - reg ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } start_reg = reg - <NUM_LIT> ; } } if ( start_reg != reg ) { insn = emit_sfm ( reg + <NUM_LIT> , start_reg - reg ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } } } if ( frame_pointer_needed ) { insn = GEN_INT ( - ( <NUM_LIT> + args_to_push + fp_offset ) ) ; insn = emit_insn ( gen_addsi3 ( hard_frame_pointer_rtx , ip_rtx , insn ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; if ( IS_NESTED ( func_type ) ) { if ( regs_ever_live [ <NUM_LIT> ] == <NUM_LIT> || saved_pretend_args ) insn = gen_rtx_REG ( SImode , <NUM_LIT> ) ; else { insn = gen_rtx_PLUS ( SImode , hard_frame_pointer_rtx , GEN_INT ( <NUM_LIT> ) ) ; insn = gen_rtx_MEM ( SImode , insn ) ; } emit_insn ( gen_rtx_SET ( SImode , ip_rtx , insn ) ) ; emit_insn ( gen_prologue_use ( ip_rtx ) ) ; } } amount = GEN_INT ( - ( get_frame_size ( ) + current_function_outgoing_args_size ) ) ; if ( amount != const0_rtx ) { rtx last = get_last_insn ( ) ; insn = emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , amount ) ) ;


<s> dwarf = gen_rtx_SET ( VOIDmode , stack_pointer_rtx , gen_rtx_PLUS ( SImode , stack_pointer_rtx , GEN_INT ( - fp_offset ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; REG_NOTES ( insn ) = gen_rtx_EXPR_LIST ( REG_FRAME_RELATED_EXPR , dwarf , REG_NOTES ( insn ) ) ; } else { if ( cfun -> machine -> uses_anonymous_args ) insn = emit_multi_reg_push ( ( <NUM_LIT> >> ( args_to_push / <NUM_LIT> ) ) & <NUM_LIT> ) ; else insn = emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - args_to_push ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; saved_pretend_args = <NUM_LIT> ; fp_offset = args_to_push ; args_to_push = <NUM_LIT> ; insn = gen_rtx_REG ( SImode , <NUM_LIT> ) ; insn = gen_rtx_SET ( SImode , insn , ip_rtx ) ; ( void ) emit_insn ( insn ) ; } } if ( fp_offset ) { insn = gen_rtx_PLUS ( SImode , stack_pointer_rtx , GEN_INT ( fp_offset ) ) ; insn = gen_rtx_SET ( SImode , ip_rtx , insn ) ; } else insn = gen_movsi ( ip_rtx , stack_pointer_rtx ) ; insn = emit_insn ( insn ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } if ( args_to_push ) { if ( cfun -> machine -> uses_anonymous_args ) insn = emit_multi_reg_push ( ( <NUM_LIT> >> ( args_to_push / <NUM_LIT> ) ) & <NUM_LIT> ) ; else insn = emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - args_to_push ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } if ( ( func_type == ARM_FT_ISR || func_type == ARM_FT_FIQ ) && ( live_regs_mask & ( <NUM_LIT> << LR_REGNUM ) ) != <NUM_LIT> ) { emit_insn ( gen_rtx_SET ( SImode , gen_rtx_REG ( SImode , LR_REGNUM ) , gen_rtx_PLUS ( SImode , gen_rtx_REG ( SImode , LR_REGNUM ) , GEN_INT ( - <NUM_LIT> ) ) ) ) ;


<s> static int arm_get_strip_length ( char c ) { switch ( c ) { ARM_NAME_ENCODING_LENGTHS default : return <NUM_LIT> ;


ARM_NAME_ENCODING_LENGTHS default : return <NUM_LIT> ;


<s> target_flags |= ARM_FLAG_APCS_32 ; } if ( TARGET_APCS_STACK && ! TARGET_APCS_FRAME ) { warning ( <STR_LIT> ) ; target_flags |= ARM_FLAG_APCS_FRAME ; } if ( TARGET_POKE_FUNCTION_NAME ) target_flags |= ARM_FLAG_APCS_FRAME ; if ( TARGET_APCS_REENT && flag_pic ) error ( <STR_LIT> ) ; if ( TARGET_APCS_REENT ) warning ( <STR_LIT> ) ; if ( TARGET_ARM && write_symbols != NO_DEBUG && ! TARGET_APCS_FRAME && ( TARGET_DEFAULT & ARM_FLAG_APCS_FRAME ) ) warning ( <STR_LIT> ) ; if ( flag_pic ) arm_pic_register = TARGET_APCS_STACK ? <NUM_LIT> : <NUM_LIT> ; if ( TARGET_APCS_FLOAT ) warning ( <STR_LIT> ) ; arm_fast_multiply = ( insn_flags & FL_FAST_MULT ) != <NUM_LIT> ; arm_arch4 = ( insn_flags & FL_ARCH4 ) != <NUM_LIT> ; arm_arch5 = ( insn_flags & FL_ARCH5 ) != <NUM_LIT> ; arm_arch5e = ( insn_flags & FL_ARCH5E ) != <NUM_LIT> ; arm_is_xscale = ( insn_flags & FL_XSCALE ) != <NUM_LIT> ; arm_ld_sched = ( tune_flags & FL_LDSCHED ) != <NUM_LIT> ; arm_is_strong = ( tune_flags & FL_STRONG ) != <NUM_LIT> ; thumb_code = ( TARGET_ARM == <NUM_LIT> ) ; arm_is_6_or_7 = ( ( ( tune_flags & ( FL_MODE26 | FL_MODE32 ) ) && ! ( tune_flags & FL_ARCH4 ) ) ) != <NUM_LIT> ; arm_fpu = ( tune_flags & FL_CO_PROC ) ? FP_HARD : FP_SOFT3 ; if ( target_fp_name ) { if ( streq ( target_fp_name , <STR_LIT> ) ) arm_fpu_arch = FP_SOFT2 ; else if ( streq ( target_fp_name , <STR_LIT> ) ) arm_fpu_arch = FP_SOFT3 ; else error ( <STR_LIT> , target_fp_name ) ; } else arm_fpu_arch = FP_DEFAULT ; if ( TARGET_FPE && arm_fpu != FP_HARD ) arm_fpu = FP_SOFT2 ; if ( ( TARGET_SOFT_FLOAT || arm_fpu != FP_HARD ) && ( tune_flags & FL_MODE32 ) == <NUM_LIT> ) flag_schedule_insns = flag_schedule_insns_after_reload = <NUM_LIT> ; arm_prgmode = TARGET_APCS_32 ? PROG_MODE_PROG32 : PROG_MODE_PROG26 ; if ( structure_size_string != NULL ) { int size = strtol ( structure_size_string , NULL , <NUM_LIT> ) ; if ( size == <NUM_LIT> || size == <NUM_LIT> ) arm_structure_size_boundary = size ; else warning ( <STR_LIT> ) ; } if ( arm_pic_register_string != NULL ) { int pic_register = decode_reg_name ( arm_pic_register_string ) ; if ( ! flag_pic ) warning ( <STR_LIT> ) ; else if ( pic_register < <NUM_LIT> || call_used_regs [ pic_register ] || pic_register == HARD_FRAME_POINTER_REGNUM || pic_register == STACK_POINTER_REGNUM || pic_register >= PC_REGNUM ) error ( <STR_LIT> , arm_pic_register_string ) ; else arm_pic_register = pic_register ; } if ( TARGET_THUMB && flag_schedule_insns ) {


<s> while ( ( skip = arm_get_strip_length ( * name ) ) ) name += skip ;


<s> int end ; if ( i <= <NUM_LIT> ) i += <NUM_LIT> ; if ( remainder & ( <NUM_LIT> << ( i - <NUM_LIT> ) ) ) { end = i - <NUM_LIT> ; if ( end < <NUM_LIT> ) end += <NUM_LIT> ; temp1 = remainder & ( ( <NUM_LIT> << end ) | ( ( i < end ) ? ( <NUM_LIT> >> ( <NUM_LIT> - end ) ) : <NUM_LIT> ) ) ;


<s> static int count_insns_for_constant ( HOST_WIDE_INT remainder , int i ) { HOST_WIDE_INT temp1 ; int num_insns = <NUM_LIT> ; do { int end ; if ( i <= <NUM_LIT> ) i += <NUM_LIT> ; if ( remainder & ( <NUM_LIT> << ( i - <NUM_LIT> ) ) ) { end = i - <NUM_LIT> ; if ( end < <NUM_LIT> ) end += <NUM_LIT> ; temp1 = remainder & ( ( <NUM_LIT> << end ) | ( ( i < end ) ? ( <NUM_LIT> >> ( <NUM_LIT> - end ) ) : <NUM_LIT> ) ) ; remainder &= ~ temp1 ; num_insns ++ ; i -= <NUM_LIT> ; } i -= <NUM_LIT> ; } while ( remainder ) ; return num_insns ;


<s> r = REAL_VALUE_ATOF ( strings_fpa [ i ] , DFmode ) ; values_fpa [ i ] = r ; }


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


<s> void thumb_expand_epilogue ( ) { HOST_WIDE_INT amount = ( get_frame_size ( ) + current_function_outgoing_args_size ) ; if ( IS_NAKED ( arm_current_func_type ( ) ) ) return ; if ( frame_pointer_needed ) emit_insn ( gen_movsi ( stack_pointer_rtx , hard_frame_pointer_rtx ) ) ; else if ( amount ) { amount = ROUND_UP ( amount ) ; if ( amount < <NUM_LIT> ) emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( amount ) ) ) ; else { rtx reg = gen_rtx ( REG , SImode , LAST_ARG_REGNUM ) ; emit_insn ( gen_movsi ( reg , GEN_INT ( amount ) ) ) ;

emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , reg ) ) ;


<s> amount = ROUND_UP ( amount ) ; if ( amount < <NUM_LIT> ) emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( amount ) ) ) ; else { rtx reg = gen_rtx ( REG , SImode , LAST_ARG_REGNUM ) ; emit_insn ( gen_movsi ( reg , GEN_INT ( amount ) ) ) ; emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , reg ) ) ; } } emit_insn ( gen_prologue_use ( stack_pointer_rtx ) ) ; if ( current_function_profile || TARGET_NO_SCHED_PRO ) emit_insn ( gen_blockage ( ) ) ;


<s> if ( IS_INTERRUPT ( func_type ) ) { error ( <STR_LIT> ) ; return ; } if ( frame_pointer_needed ) emit_insn ( gen_movsi ( hard_frame_pointer_rtx , stack_pointer_rtx ) ) ; if ( amount ) { amount = ROUND_UP ( amount ) ; if ( amount < <NUM_LIT> ) emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - amount ) ) ) ; else { int regno ; rtx reg ; for ( regno = LAST_ARG_REGNUM + <NUM_LIT> ; regno <= LAST_LO_REGNUM ; regno ++ ) if ( regs_ever_live [ regno ] && ! call_used_regs [ regno ] && ! ( TARGET_SINGLE_PIC_BASE && ( regno == arm_pic_register ) ) && ! ( frame_pointer_needed && ( regno == THUMB_HARD_FRAME_POINTER_REGNUM ) ) ) break ; if ( regno > LAST_LO_REGNUM ) { rtx spare = gen_rtx ( REG , SImode , IP_REGNUM ) ; reg = gen_rtx ( REG , SImode , LAST_LO_REGNUM ) ;

emit_insn ( gen_movsi ( spare , reg ) ) ;


<s> amount = ROUND_UP ( amount ) ; if ( amount < <NUM_LIT> ) emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - amount ) ) ) ; else { int regno ; rtx reg ; for ( regno = LAST_ARG_REGNUM + <NUM_LIT> ; regno <= LAST_LO_REGNUM ; regno ++ ) if ( regs_ever_live [ regno ] && ! call_used_regs [ regno ] && ! ( TARGET_SINGLE_PIC_BASE && ( regno == arm_pic_register ) ) && ! ( frame_pointer_needed && ( regno == THUMB_HARD_FRAME_POINTER_REGNUM ) ) ) break ; if ( regno > LAST_LO_REGNUM ) { rtx spare = gen_rtx ( REG , SImode , IP_REGNUM ) ; reg = gen_rtx ( REG , SImode , LAST_LO_REGNUM ) ; emit_insn ( gen_movsi ( spare , reg ) ) ; emit_insn ( gen_prologue_use ( spare ) ) ; emit_insn ( gen_movsi ( reg , GEN_INT ( - amount ) ) ) ; emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , reg ) ) ; emit_insn ( gen_movsi ( reg , spare ) ) ; emit_insn ( gen_prologue_use ( reg ) ) ; } else { reg = gen_rtx ( REG , SImode , regno ) ; emit_insn ( gen_movsi ( reg , GEN_INT ( - amount ) ) ) ; emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , reg ) ) ; }


<s> rtx insn ; if ( cfun -> machine -> far_jump_used ) return <NUM_LIT> ; if ( ! in_prologue ) { if ( regs_ever_live [ ARG_POINTER_REGNUM ] ) cfun -> machine -> arg_pointer_live = <NUM_LIT> ; else if ( ! cfun -> machine -> arg_pointer_live ) return <NUM_LIT> ;


<s> } for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) { if ( GET_CODE ( insn ) == JUMP_INSN && GET_CODE ( PATTERN ( insn ) ) != ADDR_VEC && GET_CODE ( PATTERN ( insn ) ) != ADDR_DIFF_VEC && get_attr_far_jump ( insn ) == FAR_JUMP_YES ) {

cfun -> machine -> far_jump_used = <NUM_LIT> ;


<s> int had_to_push_lr ; rtx eh_ofs = cfun -> machine -> eh_epilogue_sp_ofs ; if ( return_used_this_function ) return <STR_LIT> ; for ( regno = <NUM_LIT> ; regno <= LAST_LO_REGNUM ; regno ++ ) if ( regs_ever_live [ regno ] && ! call_used_regs [ regno ] && ! ( TARGET_SINGLE_PIC_BASE && ( regno == arm_pic_register ) ) ) live_regs_mask |= <NUM_LIT> << regno ; for ( regno = <NUM_LIT> ; regno < <NUM_LIT> ; regno ++ ) { if ( regs_ever_live [ regno ] && ! call_used_regs [ regno ] && ! ( TARGET_SINGLE_PIC_BASE && ( regno == arm_pic_register ) ) ) high_regs_pushed ++ ; } if ( high_regs_pushed ) { int mask = live_regs_mask ; int next_hi_reg ; int size ; int mode ; if ( current_function_return_rtx != <NUM_LIT> ) mode = GET_MODE ( current_function_return_rtx ) ; else mode = DECL_MODE ( DECL_RESULT ( current_function_decl ) ) ; size = GET_MODE_SIZE ( mode ) ; if ( size < <NUM_LIT> ) mask |= <NUM_LIT> << <NUM_LIT> ; if ( mask == <NUM_LIT> ) internal_error ( <STR_LIT> ) ; for ( next_hi_reg = <NUM_LIT> ; next_hi_reg < <NUM_LIT> ; next_hi_reg ++ ) if ( regs_ever_live [ next_hi_reg ] && ! call_used_regs [ next_hi_reg ] && ! ( TARGET_SINGLE_PIC_BASE && ( next_hi_reg == arm_pic_register ) ) ) break ;


<s> static Mnode * add_minipool_backward_ref ( Mfix * fix ) { Mnode * min_mp = NULL ; HOST_WIDE_INT min_address = fix -> address - fix -> backwards ; Mnode * mp ; if ( min_address >= minipool_barrier -> address || ( minipool_vector_tail -> min_address + fix -> fix_size >= minipool_barrier -> address ) ) return NULL ; for ( mp = minipool_vector_tail ; mp != NULL ; mp = mp -> prev ) { if ( GET_CODE ( fix -> value ) == GET_CODE ( mp -> value ) && fix -> mode == mp -> mode && ( GET_CODE ( fix -> value ) != CODE_LABEL || ( CODE_LABEL_NUMBER ( fix -> value ) == CODE_LABEL_NUMBER ( mp -> value ) ) ) && rtx_equal_p ( fix -> value , mp -> value ) && ( mp -> max_address > ( minipool_barrier -> address + minipool_vector_tail -> offset + minipool_vector_tail -> fix_size ) ) ) { mp -> refcount ++ ; return move_minipool_fix_backward_ref ( mp , min_mp , min_address ) ; } if ( min_mp != NULL ) mp -> min_address += fix -> fix_size ; else { if ( mp -> min_address < min_address ) { if ( ARM_DOUBLEWORD_ALIGN && fix -> fix_size == <NUM_LIT> && mp -> fix_size != <NUM_LIT> ) return NULL ; else min_mp = mp ; } else if ( mp -> max_address < minipool_barrier -> address + mp -> offset + fix -> fix_size ) { min_mp = mp ; min_address = mp -> min_address + fix -> fix_size ; } else if ( ARM_DOUBLEWORD_ALIGN && min_mp == NULL && fix -> fix_size == <NUM_LIT> && mp -> fix_size < <NUM_LIT> ) { min_mp = mp ; min_address = mp -> min_address + fix -> fix_size ;


<s> 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 ; else minipool_vector_head = mp ; }


<s> int adjacent_mem_locations ( rtx a , rtx b ) { if ( volatile_refs_p ( a ) || volatile_refs_p ( b ) ) return <NUM_LIT> ; if ( ( GET_CODE ( XEXP ( a , <NUM_LIT> ) ) == REG || ( GET_CODE ( XEXP ( a , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( a , <NUM_LIT> ) , <NUM_LIT> ) ) == CONST_INT ) ) && ( GET_CODE ( XEXP ( b , <NUM_LIT> ) ) == REG || ( GET_CODE ( XEXP ( b , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( b , <NUM_LIT> ) , <NUM_LIT> ) ) == CONST_INT ) ) ) { 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 ( PLUS , val0 ) || ! const_ok_for_op ( PLUS , val1 ) ) return <NUM_LIT> ;


<s> for ( new = imports_list ; new ; new = new -> next ) if ( new -> name == name ) return ; new = ( struct import * ) xmalloc ( sizeof ( struct import ) ) ; new -> next = imports_list ; imports_list = new ;


<s> struct import * new ; for ( new = imports_list ; new ; new = new -> next ) if ( new -> name == name ) return ;

new = ( struct import * ) xmalloc ( sizeof ( struct import ) ) ;


<s> sprintf ( buf , <STR_LIT> , arm_data_section_count ++ ) ;


sprintf ( buf , <STR_LIT> , arm_data_section_count ++ ) ;


<s> if ( ( * old ) -> name == name ) { * old = ( * old ) -> next ;


<s> fputs ( <STR_LIT> , f ) ; } while ( imports_list ) { fprintf ( f , <STR_LIT> ) ; assemble_name ( f , imports_list -> name ) ; fputc ( '\n' , f ) ;


<s> struct pic_chain * chain ; if ( aof_pic_chain == NULL ) return ; asm_fprintf ( f , <STR_LIT> , PIC_OFFSET_TABLE_REGNUM , PIC_OFFSET_TABLE_REGNUM ) ;


<s> arm_file_end ( ) ; aof_dump_imports ( asm_out_file ) ;


<s> fputs ( <STR_LIT> , asm_out_file ) ; fputs ( <STR_LIT> , asm_out_file ) ; fputs ( <STR_LIT> , asm_out_file ) ; fputs ( <STR_LIT> , asm_out_file ) ; fputs ( <STR_LIT> , asm_out_file ) ; fputs ( <STR_LIT> , asm_out_file ) ; fputs ( <STR_LIT> , asm_out_file ) ; fputs ( <STR_LIT> , asm_out_file ) ; fputs ( <STR_LIT> , asm_out_file ) ;


<s> default_globalize_label ( stream , name ) ;

if ( ! strcmp ( name , <STR_LIT> ) ) arm_main_function = <NUM_LIT> ;


<s> static void aof_globalize_label ( FILE * stream , const char * name ) {

default_globalize_label ( stream , name ) ;


<s> if ( aof_pic_label == NULL_RTX ) { aof_pic_label = gen_rtx_SYMBOL_REF ( Pmode , <STR_LIT> ) ; } for ( offset = <NUM_LIT> , chainp = & aof_pic_chain ; * chainp ; offset += <NUM_LIT> , chainp = & ( * chainp ) -> next ) if ( ( * chainp ) -> symname == XSTR ( x , <NUM_LIT> ) ) return plus_constant ( aof_pic_label , offset ) ; * chainp = ( struct pic_chain * ) xmalloc ( sizeof ( struct pic_chain ) ) ; ( * chainp ) -> next = NULL ; ( * chainp ) -> symname = XSTR ( x , <NUM_LIT> ) ; return plus_constant ( aof_pic_label , offset ) ;


<s> for ( offset = <NUM_LIT> , chainp = & aof_pic_chain ; * chainp ; offset += <NUM_LIT> , chainp = & ( * chainp ) -> next ) if ( ( * chainp ) -> symname == XSTR ( x , <NUM_LIT> ) ) return plus_constant ( aof_pic_label , offset ) ; * chainp = ( struct pic_chain * ) xmalloc ( sizeof ( struct pic_chain ) ) ; ( * chainp ) -> next = NULL ; ( * chainp ) -> symname = XSTR ( x , <NUM_LIT> ) ;


<s> if ( flag_pic ) strcat ( buf , <STR_LIT> ) ; return buf ;


<s> static char buf [ <NUM_LIT> ] ; sprintf ( buf , <STR_LIT> , arm_text_section_count ++ ) ;

if ( flag_pic ) strcat ( buf , <STR_LIT> ) ;


<s> switch ( GET_CODE ( op ) ) { case PLUS : return <STR_LIT> ; case MINUS :


<s> int cost ; if ( TARGET_THUMB ) { switch ( code ) { case MULT : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; default : * total = thumb_rtx_costs ( x , code , outer_code ) ; return true ; } } switch ( code ) { case MULT : if ( mode == DImode && ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == GET_CODE ( XEXP ( x , <NUM_LIT> ) ) ) && ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == ZERO_EXTEND || GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == SIGN_EXTEND ) ) { * total = <NUM_LIT> ; return true ; } if ( GET_MODE_CLASS ( mode ) == MODE_FLOAT ) { * total = <NUM_LIT> ; return true ; } if ( mode == DImode ) { cost = <NUM_LIT> ; nonreg_cost = <NUM_LIT> ; } else { cost = <NUM_LIT> ;


<s> static int arm_address_cost ( rtx x ) { return TARGET_ARM ? arm_arm_address_cost ( x ) : arm_thumb_address_cost ( x ) ;


<s> if ( GET_CODE ( x ) != REG ) return <NUM_LIT> ;


<s> if ( REG_NOTE_KIND ( link ) == REG_DEP_ANTI || REG_NOTE_KIND ( link ) == REG_DEP_OUTPUT ) return <NUM_LIT> ; if ( REG_NOTE_KIND ( link ) == <NUM_LIT> && GET_CODE ( insn ) == CALL_INSN ) return <NUM_LIT> ; if ( ( i_pat = single_set ( insn ) ) != NULL && GET_CODE ( SET_SRC ( i_pat ) ) == MEM && ( d_pat = single_set ( dep ) ) != NULL && GET_CODE ( SET_DEST ( d_pat ) ) == MEM ) { rtx src_mem = XEXP ( SET_SRC ( i_pat ) , <NUM_LIT> ) ; if ( ( GET_CODE ( src_mem ) == SYMBOL_REF && 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> ;


<s> if ( TARGET_ARM ) { if ( TARGET_HARD_FLOAT_ABI ) { if ( TARGET_FPA ) size += <NUM_LIT> ; if ( TARGET_MAVERICK ) size += <NUM_LIT> ; } if ( TARGET_IWMMXT_ABI ) size += <NUM_LIT> ; }


<s> if ( TARGET_MAVERICK ) size += <NUM_LIT> ; } if ( TARGET_IWMMXT_ABI ) size += <NUM_LIT> ; } return size ;


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


<s> if ( NUM_ARG_REGS > nregs && ( NUM_ARG_REGS < nregs + ARM_NUM_REGS2 ( mode , type ) ) && pcum -> can_split ) return ( NUM_ARG_REGS - nregs ) * UNITS_PER_WORD ; return <NUM_LIT> ;


<s> if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) return <NUM_LIT> ; if ( ARITHMETIC_P ( XEXP ( x , <NUM_LIT> ) ) || ARITHMETIC_P ( XEXP ( x , <NUM_LIT> ) ) ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> else if ( GET_CODE ( x ) == LABEL_REF ) fputs ( <STR_LIT> , asm_out_file ) ; else fputs ( <STR_LIT> , asm_out_file ) ; } fputc ( '\n' , asm_out_file ) ; return true ; } if ( arm_vector_mode_supported_p ( GET_MODE ( x ) ) ) { int i , units ; gcc_assert ( GET_CODE ( x ) == CONST_VECTOR ) ; units = CONST_VECTOR_NUNITS ( x ) ; switch ( GET_MODE ( x ) ) { case V2SImode : size = <NUM_LIT> ; break ; case V4HImode : size = <NUM_LIT> ; break ; case V8QImode : size = <NUM_LIT> ; break ; default : gcc_unreachable ( ) ; }

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


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


<s> reg = load_tls_operand ( sum , reg ) ; if ( TARGET_ARM ) emit_insn ( gen_pic_add_dot_plus_eight ( reg , reg , labelno ) ) ; else emit_insn ( gen_pic_add_dot_plus_four ( reg , reg , labelno ) ) ; * valuep = emit_library_call_value ( get_tls_get_addr ( ) , NULL_RTX , LCT_PURE , Pmode , <NUM_LIT> , reg , Pmode ) ; insns = get_insns ( ) ; end_sequence ( ) ;


<s> rtx rhs = SET_SRC ( XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ) ; if ( GET_CODE ( rhs ) == UNSPEC && XINT ( rhs , <NUM_LIT> ) == UNSPEC_PIC_BASE ) return TRUE ;

if ( GET_CODE ( rhs ) == MEM && GET_CODE ( XEXP ( rhs , <NUM_LIT> ) ) == UNSPEC && XINT ( XEXP ( rhs , <NUM_LIT> ) , <NUM_LIT> ) == UNSPEC_PIC_BASE ) return TRUE ;


<s> if ( GET_CODE ( rhs ) == UNSPEC && XINT ( rhs , <NUM_LIT> ) == UNSPEC_PIC_BASE ) return TRUE ; if ( GET_CODE ( rhs ) == MEM && GET_CODE ( XEXP ( rhs , <NUM_LIT> ) ) == UNSPEC && XINT ( XEXP ( rhs , <NUM_LIT> ) , <NUM_LIT> ) == UNSPEC_PIC_BASE ) return TRUE ; }


<s> case GT : case LE : if ( i != maxval && ( const_ok_for_arm ( i + <NUM_LIT> ) || const_ok_for_arm ( - ( i + <NUM_LIT> ) ) ) ) { * op1 = GEN_INT ( i + <NUM_LIT> ) ; return code == GT ? GE : LT ; } break ; case GE : case LT : if ( i != ~ maxval && ( const_ok_for_arm ( i - <NUM_LIT> ) || const_ok_for_arm ( - ( i - <NUM_LIT> ) ) ) ) { * op1 = GEN_INT ( i - <NUM_LIT> ) ; return code == GE ? GT : LE ; } break ; case GTU : case LEU : if ( i != ~ ( ( unsigned HOST_WIDE_INT ) <NUM_LIT> ) && ( const_ok_for_arm ( i + <NUM_LIT> ) || const_ok_for_arm ( - ( i + <NUM_LIT> ) ) ) ) { * op1 = GEN_INT ( i + <NUM_LIT> ) ; return code == GTU ? GEU : LTU ; } break ; case GEU : case LTU : if ( i != <NUM_LIT> && ( const_ok_for_arm ( i - <NUM_LIT> ) || const_ok_for_arm ( - ( i - <NUM_LIT> ) ) ) ) { * op1 = GEN_INT ( i - <NUM_LIT> ) ; return code == GEU ? GTU : LEU ;


<s> static bool arm_cirrus_insn_p ( rtx insn ) { enum attr_cirrus attr ; if ( ! insn || GET_CODE ( insn ) != INSN || GET_CODE ( PATTERN ( insn ) ) == USE || GET_CODE ( PATTERN ( insn ) ) == CLOBBER ) return <NUM_LIT> ; attr = get_attr_cirrus ( insn ) ; return attr != CIRRUS_NOT ;


<s> tree a ; tree attr ; gcc_assert ( TREE_CODE ( current_function_decl ) == FUNCTION_DECL ) ; if ( optimize > <NUM_LIT> && ( TREE_NOTHROW ( current_function_decl ) || ! ( flag_unwind_tables || ( flag_exceptions && ! USING_SJLJ_EXCEPTIONS ) ) ) && TREE_THIS_VOLATILE ( current_function_decl ) ) type |= ARM_FT_VOLATILE ; if ( cfun -> static_chain_decl != NULL ) type |= ARM_FT_NESTED ; attr = DECL_ATTRIBUTES ( current_function_decl ) ;

a = lookup_attribute ( <STR_LIT> , attr ) ;


<s> switch ( to ) { case THUMB_HARD_FRAME_POINTER_REGNUM : return <NUM_LIT> ; case FRAME_POINTER_REGNUM : return offsets -> soft_frame - offsets -> saved_args ; case ARM_HARD_FRAME_POINTER_REGNUM : if ( offsets -> frame == offsets -> saved_regs ) return <NUM_LIT> ; return ( frame_pointer_needed && cfun -> static_chain_decl != NULL && ! cfun -> machine -> uses_anonymous_args ) ? <NUM_LIT> : <NUM_LIT> ; case STACK_POINTER_REGNUM : return offsets -> outgoing_args - ( offsets -> saved_args + <NUM_LIT> ) ; default : gcc_unreachable ( ) ; } gcc_unreachable ( ) ; case FRAME_POINTER_REGNUM : switch ( to ) { case THUMB_HARD_FRAME_POINTER_REGNUM : return <NUM_LIT> ;


<s> unsigned int reg ; if ( IS_INTERRUPT ( func_type ) ) { unsigned int max_reg ; if ( ARM_FUNC_TYPE ( func_type ) == ARM_FT_FIQ ) max_reg = <NUM_LIT> ; else max_reg = <NUM_LIT> ; for ( reg = <NUM_LIT> ; reg <= max_reg ; reg ++ ) if ( regs_ever_live [ reg ] || ( ! current_function_is_leaf && call_used_regs [ reg ] ) ) save_reg_mask |= ( <NUM_LIT> << reg ) ; if ( flag_pic && ! TARGET_SINGLE_PIC_BASE && current_function_uses_pic_offset_table ) save_reg_mask |= <NUM_LIT> << PIC_OFFSET_TABLE_REGNUM ;


<s> unsigned int save_reg_mask = <NUM_LIT> ; unsigned long func_type = arm_current_func_type ( ) ; if ( IS_NAKED ( func_type ) ) return <NUM_LIT> ; if ( frame_pointer_needed ) save_reg_mask |= ( <NUM_LIT> << ARM_HARD_FRAME_POINTER_REGNUM ) | ( <NUM_LIT> << IP_REGNUM ) | ( <NUM_LIT> << LR_REGNUM ) | ( <NUM_LIT> << PC_REGNUM ) ; if ( IS_VOLATILE ( func_type ) ) return save_reg_mask ;

save_reg_mask |= arm_compute_save_reg0_reg12_mask ( ) ;


<s> if ( frame_pointer_needed ) save_reg_mask |= ( <NUM_LIT> << ARM_HARD_FRAME_POINTER_REGNUM ) | ( <NUM_LIT> << IP_REGNUM ) | ( <NUM_LIT> << LR_REGNUM ) | ( <NUM_LIT> << PC_REGNUM ) ; if ( IS_VOLATILE ( func_type ) ) return save_reg_mask ; save_reg_mask |= arm_compute_save_reg0_reg12_mask ( ) ; if ( regs_ever_live [ LR_REGNUM ] || ( save_reg_mask && optimize_size && ARM_FUNC_TYPE ( func_type ) == ARM_FT_NORMAL && ! current_function_calls_eh_return ) ) save_reg_mask |= <NUM_LIT> << LR_REGNUM ; if ( cfun -> machine -> lr_save_eliminated ) save_reg_mask &= ~ ( <NUM_LIT> << LR_REGNUM ) ; if ( TARGET_REALLY_IWMMXT && ( ( bit_count ( save_reg_mask ) + ARM_NUM_INTS ( current_function_pretend_args_size ) ) % <NUM_LIT> ) != <NUM_LIT> ) { unsigned int reg ; for ( reg = <NUM_LIT> ; reg <= <NUM_LIT> ; reg ++ ) if ( ( save_reg_mask & ( <NUM_LIT> << reg ) ) == <NUM_LIT> ) break ; if ( reg <= <NUM_LIT> ) save_reg_mask |= ( <NUM_LIT> << reg ) ; else { cfun -> machine -> sibcall_blocked = <NUM_LIT> ; save_reg_mask |= ( <NUM_LIT> << <NUM_LIT> ) ; }


<s> if ( const_ok_for_arm ( INTVAL ( part ) ) || const_ok_for_arm ( ~ INTVAL ( part ) ) ) return true ; part = gen_lowpart ( SImode , val ) ; gcc_assert ( GET_CODE ( part ) == CONST_INT ) ; if ( const_ok_for_arm ( INTVAL ( part ) ) || const_ok_for_arm ( ~ INTVAL ( part ) ) ) return true ;


<s> gcc_assert ( GET_CODE ( part ) == CONST_INT ) ; if ( const_ok_for_arm ( INTVAL ( part ) ) || const_ok_for_arm ( ~ INTVAL ( part ) ) ) return true ; part = gen_lowpart ( SImode , val ) ; gcc_assert ( GET_CODE ( part ) == CONST_INT ) ;


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

gcc_assert ( GET_CODE ( lowpart ) == CONST_INT ) ;


<s> REAL_VALUE_TYPE r ; int i ; if ( ! fp_consts_inited ) init_fp_table ( ) ; REAL_VALUE_FROM_CONST_DOUBLE ( r , x ) ; if ( REAL_VALUE_MINUS_ZERO ( r ) ) return <NUM_LIT> ; for ( i = <NUM_LIT> ; i < fp_consts_inited ; i ++ ) if ( REAL_VALUES_EQUAL ( r , values_fp [ i ] ) ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> if ( GET_CODE ( ind ) == REG ) return arm_address_register_rtx_p ( ind , <NUM_LIT> ) ; if ( wb && ( GET_CODE ( ind ) == PRE_INC || GET_CODE ( ind ) == POST_INC || GET_CODE ( ind ) == PRE_DEC || GET_CODE ( ind ) == POST_DEC ) ) return arm_address_register_rtx_p ( XEXP ( ind , <NUM_LIT> ) , <NUM_LIT> ) ;

if ( wb && ( GET_CODE ( ind ) == POST_MODIFY || GET_CODE ( ind ) == PRE_MODIFY ) && arm_address_register_rtx_p ( XEXP ( ind , <NUM_LIT> ) , <NUM_LIT> ) && GET_CODE ( XEXP ( ind , <NUM_LIT> ) ) == PLUS && rtx_equal_p ( XEXP ( XEXP ( ind , <NUM_LIT> ) , <NUM_LIT> ) , XEXP ( ind , <NUM_LIT> ) ) ) ind = XEXP ( ind , <NUM_LIT> ) ;


<s> if ( wb && ( GET_CODE ( ind ) == PRE_INC || GET_CODE ( ind ) == POST_INC || GET_CODE ( ind ) == PRE_DEC || GET_CODE ( ind ) == POST_DEC ) ) return arm_address_register_rtx_p ( XEXP ( ind , <NUM_LIT> ) , <NUM_LIT> ) ; if ( wb && ( GET_CODE ( ind ) == POST_MODIFY || GET_CODE ( ind ) == PRE_MODIFY ) && arm_address_register_rtx_p ( XEXP ( ind , <NUM_LIT> ) , <NUM_LIT> ) && GET_CODE ( XEXP ( ind , <NUM_LIT> ) ) == PLUS && rtx_equal_p ( XEXP ( XEXP ( ind , <NUM_LIT> ) , <NUM_LIT> ) , XEXP ( ind , <NUM_LIT> ) ) ) ind = XEXP ( ind , <NUM_LIT> ) ;

if ( GET_CODE ( ind ) == PLUS && GET_CODE ( XEXP ( ind , <NUM_LIT> ) ) == REG && REG_MODE_OK_FOR_BASE_P ( XEXP ( ind , <NUM_LIT> ) , VOIDmode ) && GET_CODE ( XEXP ( ind , <NUM_LIT> ) ) == CONST_INT && INTVAL ( XEXP ( ind , <NUM_LIT> ) ) > - <NUM_LIT> && INTVAL ( XEXP ( ind , <NUM_LIT> ) ) < <NUM_LIT> && ( INTVAL ( XEXP ( ind , <NUM_LIT> ) ) & <NUM_LIT> ) == <NUM_LIT> ) return TRUE ;


<s> if ( ! TARGET_AAPCS_BASED ) return ; if ( ! TARGET_ARM_DYNAMIC_VAGUE_LINKAGE_P && DECL_COMDAT ( decl ) ) DECL_VISIBILITY ( decl ) = VISIBILITY_HIDDEN ;

else DECL_VISIBILITY ( decl ) = VISIBILITY_DEFAULT ;


<s> if ( ! TARGET_ARM_DYNAMIC_VAGUE_LINKAGE_P && DECL_COMDAT ( decl ) ) DECL_VISIBILITY ( decl ) = VISIBILITY_HIDDEN ; else DECL_VISIBILITY ( decl ) = VISIBILITY_DEFAULT ;

DECL_VISIBILITY_SPECIFIED ( decl ) = <NUM_LIT> ;


<s> unsigned int arm_dbx_register_number ( unsigned int regno ) { if ( regno < <NUM_LIT> ) return regno ; if ( IS_FPA_REGNUM ( regno ) ) return ( TARGET_AAPCS_BASED ? <NUM_LIT> : <NUM_LIT> ) + regno - FIRST_FPA_REGNUM ;

if ( IS_VFP_REGNUM ( regno ) ) return <NUM_LIT> + regno - FIRST_VFP_REGNUM ;


<s> unsigned int arm_dbx_register_number ( unsigned int regno ) { if ( regno < <NUM_LIT> ) return regno ; if ( IS_FPA_REGNUM ( regno ) ) return ( TARGET_AAPCS_BASED ? <NUM_LIT> : <NUM_LIT> ) + regno - FIRST_FPA_REGNUM ; if ( IS_VFP_REGNUM ( regno ) ) return <NUM_LIT> + regno - FIRST_VFP_REGNUM ; if ( IS_IWMMXT_GR_REGNUM ( regno ) ) return <NUM_LIT> + regno - FIRST_IWMMXT_GR_REGNUM ;

if ( IS_IWMMXT_REGNUM ( regno ) ) return <NUM_LIT> + regno - FIRST_IWMMXT_REGNUM ;


<s> int arm_debugger_arg_offset ( int value , rtx addr ) { rtx insn ; if ( value != <NUM_LIT> ) return <NUM_LIT> ; if ( GET_CODE ( addr ) != REG ) return <NUM_LIT> ; if ( REGNO ( addr ) == ( unsigned ) HARD_FRAME_POINTER_REGNUM ) return <NUM_LIT> ; if ( ( TARGET_THUMB || ! frame_pointer_needed ) && REGNO ( addr ) == SP_REGNUM ) return <NUM_LIT> ; for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) { if ( GET_CODE ( insn ) == INSN && GET_CODE ( PATTERN ( insn ) ) == SET && REGNO ( XEXP ( PATTERN ( insn ) , <NUM_LIT> ) ) == REGNO ( addr ) && GET_CODE ( XEXP ( PATTERN ( insn ) , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( PATTERN ( insn ) , <NUM_LIT> ) , <NUM_LIT> ) ) == REG && REGNO ( XEXP ( XEXP ( PATTERN ( insn ) , <NUM_LIT> ) , <NUM_LIT> ) ) == ( unsigned ) HARD_FRAME_POINTER_REGNUM && GET_CODE ( XEXP ( XEXP ( PATTERN ( insn ) , <NUM_LIT> ) , <NUM_LIT> ) ) == CONST_INT ) { value = INTVAL ( XEXP ( XEXP ( PATTERN ( insn ) , <NUM_LIT> ) , <NUM_LIT> ) ) ; break ; } } if ( value == <NUM_LIT> ) {


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


<s> ctors_section ( ) ; assemble_align ( POINTER_SIZE ) ; fputs ( <STR_LIT> , asm_out_file ) ;

output_addr_const ( asm_out_file , symbol ) ;


<s> case TLS_LDO32 : fputs ( <STR_LIT> , fp ) ; break ; case TLS_IE32 : fputs ( <STR_LIT> , fp ) ; break ; case TLS_LE32 : fputs ( <STR_LIT> , fp ) ; break ; default : gcc_unreachable ( ) ; } switch ( reloc ) { case TLS_GD32 : case TLS_LDM32 : case TLS_IE32 : fputs ( <STR_LIT> , fp ) ; output_addr_const ( fp , XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ) ; fputs ( <STR_LIT> , fp ) ; output_addr_const ( fp , XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ) ; fputc ( ')' , fp ) ; break ;


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


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


<s> char * newstr ; if ( DECL_WEAK ( decl ) && flag == SHORT_CALL_FLAG_CHAR ) return ; newstr = alloca ( len + <NUM_LIT> ) ; newstr [ <NUM_LIT> ] = flag ; strcpy ( newstr + <NUM_LIT> , str ) ;

newstr = ( char * ) ggc_alloc_string ( newstr , len + <NUM_LIT> ) ;


<s> if ( TREE_CODE ( decl ) == FUNCTION_DECL && DECL_WEAK ( decl ) ) arm_encode_call_attribute ( decl , LONG_CALL_FLAG_CHAR ) ; else if ( ! TREE_PUBLIC ( decl ) ) arm_encode_call_attribute ( decl , SHORT_CALL_FLAG_CHAR ) ;


<s> static void arm_encode_section_info ( tree decl , rtx rtl , int first ) { if ( optimize > <NUM_LIT> && TREE_CONSTANT ( decl ) ) SYMBOL_REF_FLAG ( XEXP ( rtl , <NUM_LIT> ) ) = <NUM_LIT> ; if ( first && DECL_P ( decl ) ) { if ( TREE_CODE ( decl ) == FUNCTION_DECL && DECL_WEAK ( decl ) ) arm_encode_call_attribute ( decl , LONG_CALL_FLAG_CHAR ) ; else if ( ! TREE_PUBLIC ( decl ) ) arm_encode_call_attribute ( decl , SHORT_CALL_FLAG_CHAR ) ;


<s> if ( ! target || GET_MODE ( target ) != tmode || ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( target , tmode ) ) target = gen_reg_rtx ( tmode ) ; gcc_assert ( GET_MODE ( op0 ) == mode0 && GET_MODE ( op1 ) == mode1 ) ; if ( ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( op0 , mode0 ) ) op0 = copy_to_mode_reg ( mode0 , op0 ) ; if ( ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( op1 , mode1 ) ) op1 = copy_to_mode_reg ( mode1 , op1 ) ; pat = GEN_FCN ( icode ) ( target , op0 , op1 ) ; if ( ! pat ) return <NUM_LIT> ;


<s> insn = gen_rtx_PLUS ( SImode , stack_pointer_rtx , GEN_INT ( fp_offset ) ) ; insn = gen_rtx_SET ( SImode , ip_rtx , insn ) ; } else insn = gen_movsi ( ip_rtx , stack_pointer_rtx ) ; insn = emit_insn ( insn ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } if ( args_to_push ) { if ( cfun -> machine -> uses_anonymous_args ) insn = emit_multi_reg_push ( ( <NUM_LIT> >> ( args_to_push / <NUM_LIT> ) ) & <NUM_LIT> ) ; else insn = emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - args_to_push ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } if ( ( func_type == ARM_FT_ISR || func_type == ARM_FT_FIQ ) && ( live_regs_mask & ( <NUM_LIT> << LR_REGNUM ) ) != <NUM_LIT> && ! frame_pointer_needed ) emit_insn ( gen_rtx_SET ( SImode , gen_rtx_REG ( SImode , LR_REGNUM ) , gen_rtx_PLUS ( SImode , gen_rtx_REG ( SImode , LR_REGNUM ) , GEN_INT ( - <NUM_LIT> ) ) ) ) ; if ( live_regs_mask ) { insn = emit_multi_reg_push ( live_regs_mask ) ; saved_regs += bit_count ( live_regs_mask ) * <NUM_LIT> ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } if ( TARGET_IWMMXT ) for ( reg = LAST_IWMMXT_REGNUM ; reg >= FIRST_IWMMXT_REGNUM ; reg -- ) if ( regs_ever_live [ reg ] && ! call_used_regs [ reg ] ) { insn = gen_rtx_PRE_DEC ( V2SImode , stack_pointer_rtx ) ; insn = gen_frame_mem ( V2SImode , insn ) ; insn = emit_insn ( gen_rtx_SET ( VOIDmode , insn , gen_rtx_REG ( V2SImode , reg ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; saved_regs += <NUM_LIT> ; } if ( ! IS_VOLATILE ( func_type ) ) { int start_reg ; if ( arm_fpu_arch == FPUTYPE_FPA_EMU2 ) { for ( reg = LAST_FPA_REGNUM ; reg >= FIRST_FPA_REGNUM ; reg -- ) if ( regs_ever_live [ reg ] && ! call_used_regs [ reg ] ) { insn = gen_rtx_PRE_DEC ( XFmode , stack_pointer_rtx ) ; insn = gen_frame_mem ( XFmode , insn ) ; insn = emit_insn ( gen_rtx_SET ( VOIDmode , insn , gen_rtx_REG ( XFmode , reg ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; saved_regs += <NUM_LIT> ; } } else { start_reg = LAST_FPA_REGNUM ; for ( reg = LAST_FPA_REGNUM ; reg >= FIRST_FPA_REGNUM ; reg -- ) { if ( regs_ever_live [ reg ] && ! call_used_regs [ reg ] ) { if ( start_reg - reg == <NUM_LIT> ) { insn = emit_sfm ( reg , <NUM_LIT> ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; saved_regs += <NUM_LIT> ; start_reg = reg - <NUM_LIT> ;


<s> rtx op0 = expand_expr ( arg0 , NULL_RTX , VOIDmode , <NUM_LIT> ) ; enum machine_mode tmode = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; enum machine_mode mode0 = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; if ( ! target || GET_MODE ( target ) != tmode || ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( target , tmode ) ) target = gen_reg_rtx ( tmode ) ;

if ( do_load ) op0 = gen_rtx_MEM ( mode0 , copy_to_mode_reg ( Pmode , op0 ) ) ;


<s> if ( TARGET_THUMB ) { * total = thumb_rtx_costs ( x , code , outer_code ) ; return true ; } switch ( code ) { case MULT : if ( mode == DImode && ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == GET_CODE ( XEXP ( x , <NUM_LIT> ) ) ) && ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == ZERO_EXTEND || GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == SIGN_EXTEND ) ) { * total = <NUM_LIT> ; return true ; } if ( GET_MODE_CLASS ( mode ) == MODE_FLOAT || mode == DImode ) { * total = <NUM_LIT> ; return true ; } if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) { unsigned HOST_WIDE_INT i = ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) & ( unsigned HOST_WIDE_INT ) <NUM_LIT> ) ; int cost , const_ok = const_ok_for_arm ( i ) ; int j , booth_unit_size ; cost = const_ok ? <NUM_LIT> : <NUM_LIT> ; booth_unit_size = <NUM_LIT> ; for ( j = <NUM_LIT> ; i && j < <NUM_LIT> ; j += booth_unit_size ) { i >>= booth_unit_size ; cost += <NUM_LIT> ; } * total = cost ; return true ; } * total = <NUM_LIT> + ( REG_OR_SUBREG_REG ( XEXP ( x , <NUM_LIT> ) ) ? <NUM_LIT> : <NUM_LIT> ) + ( REG_OR_SUBREG_REG ( XEXP ( x , <NUM_LIT> ) ) ? <NUM_LIT> : <NUM_LIT> ) ; return true ; default : * total = arm_rtx_costs_1 ( x , code , outer_code ) ; return true ; }


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


<s> } return ; } if ( arm_ccfsm_state == <NUM_LIT> ) { if ( simplejump_p ( insn ) ) { start_insn = next_nonnote_insn ( start_insn ) ; if ( GET_CODE ( start_insn ) == BARRIER ) { start_insn = next_nonnote_insn ( start_insn ) ; } if ( GET_CODE ( start_insn ) == CODE_LABEL && CODE_LABEL_NUMBER ( start_insn ) == arm_target_label && LABEL_NUSES ( start_insn ) == <NUM_LIT> ) reverse = TRUE ; else return ; } else if ( GET_CODE ( body ) == RETURN ) { start_insn = next_nonnote_insn ( start_insn ) ; if ( GET_CODE ( start_insn ) == BARRIER ) start_insn = next_nonnote_insn ( start_insn ) ; if ( GET_CODE ( start_insn ) == CODE_LABEL && CODE_LABEL_NUMBER ( start_insn ) == arm_target_label && LABEL_NUSES ( start_insn ) == <NUM_LIT> ) { reverse = TRUE ; seeking_return = <NUM_LIT> ; } else return ; } else return ; } gcc_assert ( ! arm_ccfsm_state || reverse ) ; if ( GET_CODE ( insn ) != JUMP_INSN ) return ; if ( GET_CODE ( body ) == PARALLEL && XVECLEN ( body , <NUM_LIT> ) > <NUM_LIT> ) body = XVECEXP ( body , <NUM_LIT> , <NUM_LIT> ) ; if ( reverse || ( GET_CODE ( body ) == SET && GET_CODE ( SET_DEST ( body ) ) == PC && GET_CODE ( SET_SRC ( body ) ) == IF_THEN_ELSE ) ) { int insns_skipped ; int fail = FALSE , succeed = FALSE ; int then_not_else = TRUE ; rtx this_insn = start_insn , label = <NUM_LIT> ; if ( get_attr_conds ( insn ) == CONDS_JUMP_CLOB ) { jump_clobbers = <NUM_LIT> ; return ; } if ( reverse ) { if ( ! seeking_return ) label = XEXP ( SET_SRC ( body ) , <NUM_LIT> ) ; } else if ( GET_CODE ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) ) == LABEL_REF ) label = XEXP ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) , <NUM_LIT> ) ; else if ( GET_CODE ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) ) == LABEL_REF ) { label = XEXP ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) , <NUM_LIT> ) ; then_not_else = FALSE ; } else if ( GET_CODE ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) ) == RETURN ) seeking_return = <NUM_LIT> ; else if ( GET_CODE ( XEXP ( SET_SRC ( body ) , <NUM_LIT> ) ) == RETURN ) { seeking_return = <NUM_LIT> ; then_not_else = FALSE ; } else gcc_unreachable ( ) ; for ( insns_skipped = <NUM_LIT> ; ! fail && ! succeed && insns_skipped ++ < max_insns_skipped ; ) { rtx scanbody ; this_insn = next_nonnote_insn ( this_insn ) ; if ( ! this_insn ) break ; switch ( GET_CODE ( this_insn ) ) {


if ( TARGET_VFP ) return ( TARGET_BIG_END ? <NUM_LIT> : <NUM_LIT> ) ;


<s> if ( TARGET_IWMMXT_ABI && arm_vector_mode_supported_p ( mode ) && pcum -> named_count > pcum -> nargs + <NUM_LIT> ) { if ( pcum -> iwmmxt_nregs <= <NUM_LIT> ) return gen_rtx_REG ( mode , pcum -> iwmmxt_nregs + FIRST_IWMMXT_REGNUM ) ; else {


<s> if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( TREE_TYPE ( decl ) ) ) ) call_type = CALL_SHORT ; else if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( TREE_TYPE ( decl ) ) ) ) call_type = CALL_LONG ; if ( call_type == CALL_LONG && ( flag_pic || ! TREE_ASM_WRITTEN ( decl ) ) ) return false ;

if ( TARGET_INTERWORK && TREE_PUBLIC ( decl ) && ! TREE_ASM_WRITTEN ( decl ) ) return false ;


<s> int call_type = TARGET_LONG_CALLS ? CALL_LONG : CALL_NORMAL ; if ( cfun -> machine -> sibcall_blocked ) return false ; if ( decl == NULL || TARGET_THUMB ) return false ; if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( TREE_TYPE ( decl ) ) ) ) call_type = CALL_SHORT ; else if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( TREE_TYPE ( decl ) ) ) ) call_type = CALL_LONG ; if ( call_type == CALL_LONG && ( flag_pic || ! TREE_ASM_WRITTEN ( decl ) ) ) return false ; if ( TARGET_INTERWORK && TREE_PUBLIC ( decl ) && ! TREE_ASM_WRITTEN ( decl ) ) return false ; if ( IS_INTERRUPT ( arm_current_func_type ( ) ) ) return false ;


<s> mode = TYPE_MODE ( type ) ; if ( INTEGRAL_TYPE_P ( type ) ) PROMOTE_FUNCTION_MODE ( mode , unsignedp , type ) ; if ( arm_return_in_msb ( type ) ) { HOST_WIDE_INT size = int_size_in_bytes ( type ) ;

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


<s> int unsignedp ATTRIBUTE_UNUSED ; rtx r ATTRIBUTE_UNUSED ; mode = TYPE_MODE ( type ) ; if ( INTEGRAL_TYPE_P ( type ) ) PROMOTE_FUNCTION_MODE ( mode , unsignedp , type ) ; if ( arm_return_in_msb ( type ) ) { HOST_WIDE_INT size = int_size_in_bytes ( type ) ; if ( size % UNITS_PER_WORD != <NUM_LIT> ) { size += UNITS_PER_WORD - size % UNITS_PER_WORD ; mode = mode_for_size ( size * BITS_PER_UNIT , MODE_INT , <NUM_LIT> ) ;


<s> enum machine_mode mode = SELECT_CC_MODE ( code , x , y ) ; rtx cc_reg = gen_rtx_REG ( mode , CC_REGNUM ) ;

emit_insn ( gen_rtx_SET ( VOIDmode , cc_reg , gen_rtx_COMPARE ( mode , x , y ) ) ) ;


<s> rtx cc_reg = gen_rtx_REG ( mode , CC_REGNUM ) ; emit_insn ( gen_rtx_SET ( VOIDmode , cc_reg , gen_rtx_COMPARE ( mode , x , y ) ) ) ;


<s> int i ; rtx src , dst , srcbase , dstbase ; rtx part_bytes_reg = NULL ; rtx mem ; if ( GET_CODE ( operands [ <NUM_LIT> ] ) != CONST_INT || GET_CODE ( operands [ <NUM_LIT> ] ) != CONST_INT || INTVAL ( operands [ <NUM_LIT> ] ) > <NUM_LIT> || INTVAL ( operands [ <NUM_LIT> ] ) & <NUM_LIT> ) return <NUM_LIT> ; dstbase = operands [ <NUM_LIT> ] ; srcbase = operands [ <NUM_LIT> ] ; dst = copy_to_mode_reg ( SImode , XEXP ( dstbase , <NUM_LIT> ) ) ; src = copy_to_mode_reg ( SImode , XEXP ( srcbase , <NUM_LIT> ) ) ; in_words_to_go = ARM_NUM_INTS ( INTVAL ( operands [ <NUM_LIT> ] ) ) ; out_words_to_go = INTVAL ( operands [ <NUM_LIT> ] ) / <NUM_LIT> ; last_bytes = INTVAL ( operands [ <NUM_LIT> ] ) & <NUM_LIT> ; dstoffset = srcoffset = <NUM_LIT> ; if ( out_words_to_go != in_words_to_go && ( ( in_words_to_go - <NUM_LIT> ) & <NUM_LIT> ) != <NUM_LIT> ) part_bytes_reg = gen_rtx_REG ( SImode , ( in_words_to_go - <NUM_LIT> ) & <NUM_LIT> ) ; for ( i = <NUM_LIT> ; in_words_to_go >= <NUM_LIT> ; i += <NUM_LIT> ) { if ( in_words_to_go > <NUM_LIT> ) emit_insn ( arm_gen_load_multiple ( <NUM_LIT> , <NUM_LIT> , src , TRUE , TRUE , srcbase , & srcoffset ) ) ; else emit_insn ( arm_gen_load_multiple ( <NUM_LIT> , in_words_to_go , src , TRUE , FALSE , srcbase , & srcoffset ) ) ; if ( out_words_to_go ) { if ( out_words_to_go > <NUM_LIT> ) emit_insn ( arm_gen_store_multiple ( <NUM_LIT> , <NUM_LIT> , dst , TRUE , TRUE , dstbase , & dstoffset ) ) ; else if ( out_words_to_go != <NUM_LIT> ) emit_insn ( arm_gen_store_multiple ( <NUM_LIT> , out_words_to_go , dst , TRUE , ( last_bytes == <NUM_LIT> ? FALSE : TRUE ) , dstbase , & dstoffset ) ) ; else { mem = adjust_automodify_address ( dstbase , SImode , dst , dstoffset ) ; emit_move_insn ( mem , gen_rtx_REG ( SImode , <NUM_LIT> ) ) ; if ( last_bytes != <NUM_LIT> ) { emit_insn ( gen_addsi3 ( dst , dst , GEN_INT ( <NUM_LIT> ) ) ) ; dstoffset += <NUM_LIT> ; } } } in_words_to_go -= in_words_to_go < <NUM_LIT> ? in_words_to_go : <NUM_LIT> ; out_words_to_go -= out_words_to_go < <NUM_LIT> ? out_words_to_go : <NUM_LIT> ; } if ( out_words_to_go ) { rtx sreg ; mem = adjust_automodify_address ( srcbase , SImode , src , srcoffset ) ; sreg = copy_to_reg ( mem ) ; mem = adjust_automodify_address ( dstbase , SImode , dst , dstoffset ) ; emit_move_insn ( mem , sreg ) ; in_words_to_go -- ; gcc_assert ( ! in_words_to_go ) ; } if ( in_words_to_go ) { gcc_assert ( in_words_to_go > <NUM_LIT> ) ;


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


<s> for ( i = <NUM_LIT> ; i < count ; i ++ ) { addr = plus_constant ( to , i * <NUM_LIT> * sign ) ; mem = adjust_automodify_address ( basemem , SImode , addr , offset ) ; emit_move_insn ( mem , gen_rtx_REG ( SImode , base_regno + i ) ) ; offset += <NUM_LIT> * sign ; } if ( write_back ) { emit_move_insn ( to , plus_constant ( to , count * <NUM_LIT> * sign ) ) ; * offsetp = offset ; } seq = get_insns ( ) ; end_sequence ( ) ; return seq ; } result = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( count + ( write_back ? <NUM_LIT> : <NUM_LIT> ) ) ) ; if ( write_back ) { XVECEXP ( result , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_SET ( GET_MODE ( to ) , to , plus_constant ( to , count * <NUM_LIT> * sign ) ) ; i = <NUM_LIT> ; count ++ ; } for ( j = <NUM_LIT> ; i < count ; i ++ , j ++ ) {

addr = plus_constant ( to , j * <NUM_LIT> * sign ) ;


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


<s> static tree arm_handle_fndecl_attribute ( tree * node , tree name , tree args ATTRIBUTE_UNUSED , int flags ATTRIBUTE_UNUSED , bool * no_add_attrs ) { if ( TREE_CODE ( * node ) != FUNCTION_DECL ) { warning ( OPT_Wattributes , <STR_LIT> , IDENTIFIER_POINTER ( name ) ) ; * no_add_attrs = true ; }


<s> warning ( OPT_Wattributes , <STR_LIT> , IDENTIFIER_POINTER ( name ) ) ; * no_add_attrs = true ; }


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

return tree_cons ( name , args , NULL_TREE ) ;


<s> return true ; case OPT_msoft_float : target_float_abi_name = <STR_LIT> ; return true ; case OPT_mtune_ : arm_select [ <NUM_LIT> ] . string = arg ; return true ;


<s> if ( TARGET_HARD_FLOAT && TARGET_MAVERICK && IS_CIRRUS_REGNUM ( regno ) ) return ( GET_MODE_CLASS ( mode ) == MODE_FLOAT ) || ( mode == DImode ) ; if ( TARGET_HARD_FLOAT && TARGET_VFP && IS_VFP_REGNUM ( regno ) ) { if ( mode == SFmode || mode == SImode ) return TRUE ;

if ( mode == DFmode ) return ( ( regno - FIRST_VFP_REGNUM ) & <NUM_LIT> ) == <NUM_LIT> ;


<s> static void arm_init_builtins ( void ) {


<s> pcum -> can_split = true ; pcum -> call_cookie = CALL_NORMAL ; if ( TARGET_LONG_CALLS ) pcum -> call_cookie = CALL_LONG ; if ( fntype ) { if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( fntype ) ) ) pcum -> call_cookie = CALL_SHORT ; else if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( fntype ) ) ) pcum -> call_cookie = CALL_LONG ; } pcum -> named_count = <NUM_LIT> ; pcum -> nargs = <NUM_LIT> ; if ( TARGET_REALLY_IWMMXT && fntype ) { tree fn_arg ; for ( fn_arg = TYPE_ARG_TYPES ( fntype ) ; fn_arg ; fn_arg = TREE_CHAIN ( fn_arg ) ) pcum -> named_count += <NUM_LIT> ; if ( ! pcum -> named_count ) pcum -> named_count = INT_MAX ; }


<s> set_conv_libfunc ( sfix_optab , DImode , DFmode , <STR_LIT> ) ; set_conv_libfunc ( ufix_optab , DImode , DFmode , <STR_LIT> ) ; set_conv_libfunc ( sfix_optab , SImode , SFmode , <STR_LIT> ) ; set_conv_libfunc ( ufix_optab , SImode , SFmode , <STR_LIT> ) ; set_conv_libfunc ( sfix_optab , DImode , SFmode , <STR_LIT> ) ; set_conv_libfunc ( ufix_optab , DImode , SFmode , <STR_LIT> ) ; set_conv_libfunc ( trunc_optab , SFmode , DFmode , <STR_LIT> ) ; set_conv_libfunc ( sext_optab , DFmode , SFmode , <STR_LIT> ) ; set_conv_libfunc ( sfloat_optab , DFmode , SImode , <STR_LIT> ) ; set_conv_libfunc ( ufloat_optab , DFmode , SImode , <STR_LIT> ) ; set_conv_libfunc ( sfloat_optab , DFmode , DImode , <STR_LIT> ) ; set_conv_libfunc ( ufloat_optab , DFmode , DImode , <STR_LIT> ) ; set_conv_libfunc ( sfloat_optab , SFmode , SImode , <STR_LIT> ) ; set_conv_libfunc ( ufloat_optab , SFmode , SImode , <STR_LIT> ) ; set_conv_libfunc ( sfloat_optab , SFmode , DImode , <STR_LIT> ) ; set_conv_libfunc ( ufloat_optab , SFmode , DImode , <STR_LIT> ) ; set_optab_libfunc ( smul_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( sdivmod_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( udivmod_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( ashl_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( lshr_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( ashr_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( cmp_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( ucmp_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( sdivmod_optab , SImode , <STR_LIT> ) ; set_optab_libfunc ( udivmod_optab , SImode , <STR_LIT> ) ; set_optab_libfunc ( sdiv_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( udiv_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( sdiv_optab , SImode , <STR_LIT> ) ; set_optab_libfunc ( udiv_optab , SImode , <STR_LIT> ) ;

set_optab_libfunc ( smod_optab , DImode , NULL ) ;


<s> machine = ( machine_function * ) ggc_alloc_cleared ( sizeof ( machine_function ) ) ;


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


<s> tree const_nothrow = tree_cons ( get_identifier ( <STR_LIT> ) , NULL , nothrow ) ; ftype = build_function_type ( ptr_type_node , void_list_node ) ; lang_hooks . builtin_function ( <STR_LIT> , ftype , ARM_BUILTIN_THREAD_POINTER , BUILT_IN_MD , NULL , const_nothrow ) ;


<s> for ( ptr = isr_attribute_args ; ptr -> arg != NULL ; ptr ++ ) if ( streq ( arg , ptr -> arg ) ) return ptr -> return_value ;


<s> for ( ptr = isr_attribute_args ; ptr -> arg != NULL ; ptr ++ ) if ( streq ( arg , ptr -> arg ) ) return ptr -> return_value ; return ARM_FT_UNKNOWN ;


<s> if ( call_cookie & CALL_SHORT ) return <NUM_LIT> ; if ( TARGET_LONG_CALLS ) { if ( flag_function_sections || DECL_SECTION_NAME ( current_function_decl ) ) return <NUM_LIT> ; } if ( current_file_function_operand ( sym_ref ) ) return <NUM_LIT> ;

return ( call_cookie & CALL_LONG ) || ENCODED_LONG_CALL_ATTR_P ( XSTR ( sym_ref , <NUM_LIT> ) ) || TARGET_LONG_CALLS ;


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


<s> if ( use_ldrd && GET_CODE ( x ) == POST_MODIFY && GET_CODE ( addend ) == REG ) return <NUM_LIT> ; return ( ( use_ldrd || GET_MODE_SIZE ( mode ) <= <NUM_LIT> ) && arm_legitimate_index_p ( mode , addend , outer , strict_p ) ) ; } else if ( reload_completed && ( code == LABEL_REF || ( code == CONST && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == LABEL_REF && GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == CONST_INT ) ) ) return <NUM_LIT> ; else if ( mode == TImode ) return <NUM_LIT> ; else if ( code == PLUS ) { rtx xop0 = XEXP ( x , <NUM_LIT> ) ;


<s> if ( TARGET_LDRD ) return val > - <NUM_LIT> && val < <NUM_LIT> ; else return val > - <NUM_LIT> && val < <NUM_LIT> ; } return TARGET_LDRD && arm_address_register_rtx_p ( index , strict_p ) ; } if ( GET_MODE_SIZE ( mode ) <= <NUM_LIT> && ! ( arm_arch4 && ( mode == HImode || ( mode == QImode && outer == SIGN_EXTEND ) ) ) ) { if ( code == MULT ) { rtx xiop0 = XEXP ( index , <NUM_LIT> ) ; rtx xiop1 = XEXP ( index , <NUM_LIT> ) ; return ( ( arm_address_register_rtx_p ( xiop0 , strict_p ) && power_of_two_operand ( xiop1 , SImode ) ) || ( arm_address_register_rtx_p ( xiop1 , strict_p ) && power_of_two_operand ( xiop0 , SImode ) ) ) ; } else if ( code == LSHIFTRT || code == ASHIFTRT || code == ASHIFT || code == ROTATERT ) { rtx op = XEXP ( index , <NUM_LIT> ) ; return ( arm_address_register_rtx_p ( XEXP ( index , <NUM_LIT> ) , strict_p ) && GET_CODE ( op ) == CONST_INT && INTVAL ( op ) > <NUM_LIT> && INTVAL ( op ) <= <NUM_LIT> ) ; } } if ( arm_arch4 ) { if ( mode == HImode || ( outer == SIGN_EXTEND && mode == QImode ) ) range = <NUM_LIT> ;


<s> 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 ( gen_rtx_PLUS ( SImode , xop0 , GEN_INT ( n ) ) , NULL_RTX ) ; emit_move_insn ( base_reg , val ) ; x = ( low_n == <NUM_LIT> ? base_reg : gen_rtx_PLUS ( SImode , base_reg , GEN_INT ( 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 ( GET_CODE ( x ) == CONST_INT && 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 ) ) ;

x = gen_rtx_PLUS ( SImode , base_reg , GEN_INT ( index ) ) ;


<s> rtx l1 , labelno , pic_tmp , pic_tmp2 , pic_rtx ; rtx global_offset_table ; if ( current_function_uses_pic_offset_table == <NUM_LIT> || TARGET_SINGLE_PIC_BASE ) return ; gcc_assert ( flag_pic ) ; labelno = GEN_INT ( pic_labelno ++ ) ; l1 = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , labelno ) , UNSPEC_PIC_LABEL ) ; l1 = gen_rtx_CONST ( VOIDmode , l1 ) ; global_offset_table = gen_rtx_SYMBOL_REF ( Pmode , <STR_LIT> ) ; pic_tmp = plus_constant ( l1 , TARGET_ARM ? <NUM_LIT> : <NUM_LIT> ) ; if ( GOT_PCREL ) pic_tmp2 = gen_rtx_CONST ( VOIDmode , gen_rtx_PLUS ( Pmode , global_offset_table , pc_rtx ) ) ; else pic_tmp2 = gen_rtx_CONST ( VOIDmode , global_offset_table ) ; pic_rtx = gen_rtx_CONST ( Pmode , gen_rtx_MINUS ( Pmode , pic_tmp2 , pic_tmp ) ) ;


<s> } else { rtx tmp ; emit_insn ( gen_load_tp_soft ( ) ) ;

tmp = gen_rtx_REG ( SImode , <NUM_LIT> ) ;


<s> static rtx arm_load_tp ( rtx target ) { if ( ! target ) target = gen_reg_rtx ( SImode ) ; if ( TARGET_HARD_TP ) {

emit_insn ( gen_load_tp_hard ( target ) ) ;


<s> static bool arm_memory_load_p ( rtx insn ) { rtx body , lhs , rhs ; ; if ( insn == NULL_RTX || GET_CODE ( insn ) != INSN ) return false ;


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

else return must_pass_in_stack_var_size_or_pad ( mode , type ) ;


<s> static bool arm_must_pass_in_stack ( enum machine_mode mode , tree type ) { if ( TARGET_AAPCS_BASED ) return must_pass_in_stack_var_size ( mode , type ) ; else return must_pass_in_stack_var_size_or_pad ( mode , type ) ;


<s> bool arm_needs_doubleword_align ( enum machine_mode mode , tree type ) { return ( GET_MODE_ALIGNMENT ( mode ) > PARM_BOUNDARY || ( type && TYPE_ALIGN ( type ) > PARM_BOUNDARY ) ) ;


<s> rtx op = PATTERN ( consumer ) ; rtx early_op ; if ( GET_CODE ( value ) == COND_EXEC ) value = COND_EXEC_CODE ( value ) ; if ( GET_CODE ( value ) == PARALLEL ) value = XVECEXP ( value , <NUM_LIT> , <NUM_LIT> ) ; value = XEXP ( value , <NUM_LIT> ) ; if ( GET_CODE ( op ) == COND_EXEC ) op = COND_EXEC_CODE ( op ) ;

if ( GET_CODE ( op ) == PARALLEL ) op = XVECEXP ( op , <NUM_LIT> , <NUM_LIT> ) ;


<s> if ( GET_CODE ( op ) == PARALLEL ) op = XVECEXP ( op , <NUM_LIT> , <NUM_LIT> ) ; op = XEXP ( op , <NUM_LIT> ) ; early_op = XEXP ( op , <NUM_LIT> ) ; if ( GET_CODE ( early_op ) == REG ) early_op = op ; return ! reg_overlap_mentioned_p ( value , early_op ) ;


<s> rtx value = PATTERN ( producer ) ; rtx op = PATTERN ( consumer ) ; rtx early_op ; if ( GET_CODE ( value ) == COND_EXEC ) value = COND_EXEC_CODE ( value ) ; if ( GET_CODE ( value ) == PARALLEL ) value = XVECEXP ( value , <NUM_LIT> , <NUM_LIT> ) ; value = XEXP ( value , <NUM_LIT> ) ; if ( GET_CODE ( op ) == COND_EXEC ) op = COND_EXEC_CODE ( op ) ; if ( GET_CODE ( op ) == PARALLEL ) op = XVECEXP ( op , <NUM_LIT> , <NUM_LIT> ) ; op = XEXP ( op , <NUM_LIT> ) ; early_op = XEXP ( op , <NUM_LIT> ) ; if ( GET_CODE ( early_op ) != REG ) early_op = XEXP ( early_op , <NUM_LIT> ) ;

return ! reg_overlap_mentioned_p ( value , early_op ) ;


<s> rtx op = PATTERN ( consumer ) ; if ( GET_CODE ( value ) == COND_EXEC ) value = COND_EXEC_CODE ( value ) ;

if ( GET_CODE ( value ) == PARALLEL ) value = XVECEXP ( value , <NUM_LIT> , <NUM_LIT> ) ;


<s> if ( GET_CODE ( value ) == COND_EXEC ) value = COND_EXEC_CODE ( value ) ; if ( GET_CODE ( value ) == PARALLEL ) value = XVECEXP ( value , <NUM_LIT> , <NUM_LIT> ) ; value = XEXP ( value , <NUM_LIT> ) ; if ( GET_CODE ( addr ) == COND_EXEC ) addr = COND_EXEC_CODE ( addr ) ; if ( GET_CODE ( addr ) == PARALLEL ) addr = XVECEXP ( addr , <NUM_LIT> , <NUM_LIT> ) ; addr = XEXP ( addr , <NUM_LIT> ) ; return ! reg_overlap_mentioned_p ( value , addr ) ;


<s> if ( GET_CODE ( addr ) == PARALLEL ) addr = XVECEXP ( addr , <NUM_LIT> , <NUM_LIT> ) ; addr = XEXP ( addr , <NUM_LIT> ) ; return ! reg_overlap_mentioned_p ( value , addr ) ;


<s> bool arm_output_addr_const_extra ( FILE * fp , rtx x ) { if ( GET_CODE ( x ) == UNSPEC && XINT ( x , <NUM_LIT> ) == UNSPEC_TLS ) return arm_emit_tls_decoration ( fp , x ) ; else if ( GET_CODE ( x ) == UNSPEC && XINT ( x , <NUM_LIT> ) == UNSPEC_PIC_LABEL ) { char label [ <NUM_LIT> ] ; int labelno = INTVAL ( XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ) ; ASM_GENERATE_INTERNAL_LABEL ( label , <STR_LIT> , labelno ) ; assemble_name_raw ( fp , label ) ;


<s> if ( saved_size > <NUM_LIT> ) { floats_offset += saved_size ; asm_fprintf ( f , <STR_LIT> , IP_REGNUM , FP_REGNUM , floats_offset - vfp_offset ) ; } start_reg = FIRST_VFP_REGNUM ; for ( reg = FIRST_VFP_REGNUM ; reg < LAST_VFP_REGNUM ; reg += <NUM_LIT> ) { if ( ( ! regs_ever_live [ reg ] || call_used_regs [ reg ] ) && ( ! regs_ever_live [ reg + <NUM_LIT> ] || call_used_regs [ reg + <NUM_LIT> ] ) ) { if ( start_reg != reg ) arm_output_fldmx ( f , IP_REGNUM , ( start_reg - FIRST_VFP_REGNUM ) / <NUM_LIT> , ( reg - start_reg ) / <NUM_LIT> ) ; start_reg = reg + <NUM_LIT> ; } } if ( start_reg != reg ) arm_output_fldmx ( f , IP_REGNUM , ( start_reg - FIRST_VFP_REGNUM ) / <NUM_LIT> , ( reg - start_reg ) / <NUM_LIT> ) ; } if ( TARGET_IWMMXT ) { lrm_count += ( lrm_count % <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ) ; for ( reg = LAST_IWMMXT_REGNUM ; reg >= FIRST_IWMMXT_REGNUM ; reg -- ) if ( regs_ever_live [ reg ] && ! call_used_regs [ reg ] ) { asm_fprintf ( f , <STR_LIT> , reg , FP_REGNUM , lrm_count * <NUM_LIT> ) ; lrm_count += <NUM_LIT> ; } } gcc_assert ( saved_regs_mask & ( <NUM_LIT> << IP_REGNUM ) ) ; saved_regs_mask &= ~ ( <NUM_LIT> << IP_REGNUM ) ; saved_regs_mask |= ( <NUM_LIT> << SP_REGNUM ) ; if ( really_return && ARM_FUNC_TYPE ( func_type ) == ARM_FT_NORMAL && ! current_function_calls_eh_return ) saved_regs_mask &= ~ ( <NUM_LIT> << LR_REGNUM ) ; else saved_regs_mask &= ~ ( <NUM_LIT> << PC_REGNUM ) ; if ( offsets -> outgoing_args != ( <NUM_LIT> + ( int ) bit_count ( saved_regs_mask ) ) || current_function_calls_alloca ) asm_fprintf ( f , <STR_LIT> , SP_REGNUM , FP_REGNUM , <NUM_LIT> * bit_count ( saved_regs_mask ) ) ; print_multi_reg ( f , <STR_LIT> , SP_REGNUM , saved_regs_mask ) ; if ( IS_INTERRUPT ( func_type ) ) print_multi_reg ( f , <STR_LIT> , SP_REGNUM , <NUM_LIT> << IP_REGNUM ) ; } else { if ( offsets -> outgoing_args != offsets -> saved_regs ) { operands [ <NUM_LIT> ] = operands [ <NUM_LIT> ] = stack_pointer_rtx ; operands [ <NUM_LIT> ] = GEN_INT ( offsets -> outgoing_args - offsets -> saved_regs ) ; output_add_immediate ( operands ) ; } if ( arm_fpu_arch == FPUTYPE_FPA_EMU2 ) { for ( reg = FIRST_FPA_REGNUM ; reg <= LAST_FPA_REGNUM ; reg ++ ) if ( regs_ever_live [ reg ] && ! call_used_regs [ reg ] ) asm_fprintf ( f , <STR_LIT> , reg , SP_REGNUM ) ;


<s> for ( i = reg ; i < reg + count ; i ++ ) { if ( i > reg ) fputs ( <STR_LIT> , stream ) ; asm_fprintf ( stream , <STR_LIT> , i ) ;


<s> void arm_output_fn_unwind ( FILE * f , bool prologue ) { if ( ! ARM_EABI_UNWIND_TABLES ) return ; if ( prologue ) fputs ( <STR_LIT> , f ) ; else fputs ( <STR_LIT> , f ) ;


<s> if ( prologue ) fputs ( <STR_LIT> , f ) ;


<s> if ( GET_CODE ( operands [ <NUM_LIT> ] ) != MEM || GET_CODE ( sum = XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) != PLUS || GET_CODE ( reg = XEXP ( sum , <NUM_LIT> ) ) != REG || GET_CODE ( offset = XEXP ( sum , <NUM_LIT> ) ) != CONST_INT || ( ( INTVAL ( offset ) < <NUM_LIT> ) && ( INTVAL ( offset ) > - <NUM_LIT> ) ) ) return <STR_LIT> ; output_asm_insn ( <STR_LIT> , & reg ) ; wcgr = operands [ <NUM_LIT> ] ;


<s> assemble_name ( file , label ) ; fputc ( '\n' , file ) ; } while ( mi_delta != <NUM_LIT> ) { if ( ( mi_delta & ( <NUM_LIT> << shift ) ) == <NUM_LIT> ) shift += <NUM_LIT> ; else { asm_fprintf ( file , <STR_LIT> , mi_op , this_regno , this_regno , mi_delta & ( <NUM_LIT> << shift ) ) ; mi_delta &= ~ ( <NUM_LIT> << shift ) ; shift += <NUM_LIT> ; } } if ( TARGET_THUMB ) { fprintf ( file , <STR_LIT> ) ; ASM_OUTPUT_ALIGN ( file , <NUM_LIT> ) ; assemble_name ( file , label ) ; fputs ( <STR_LIT> , file ) ; assemble_integer ( XEXP ( DECL_RTL ( function ) , <NUM_LIT> ) , <NUM_LIT> , BITS_PER_WORD , <NUM_LIT> ) ; } else { fputs ( <STR_LIT> , file ) ; assemble_name ( file , XSTR ( XEXP ( DECL_RTL ( function ) , <NUM_LIT> ) , <NUM_LIT> ) ) ; if ( NEED_PLT_RELOC ) fputs ( <STR_LIT> , file ) ;


<s> static bool arm_output_ttype ( rtx x ) {


<s> bool arm_pad_arg_upward ( enum machine_mode mode , tree type ) { if ( ! TARGET_AAPCS_BASED ) return DEFAULT_FUNCTION_ARG_PADDING ( mode , type ) == upward ; if ( type && BYTES_BIG_ENDIAN && INTEGRAL_TYPE_P ( type ) ) return false ;


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


<s> bool arm_pad_reg_upward ( enum machine_mode mode ATTRIBUTE_UNUSED , tree type , int first ATTRIBUTE_UNUSED ) { if ( TARGET_AAPCS_BASED && BYTES_BIG_ENDIAN && ( AGGREGATE_TYPE_P ( type ) || TREE_CODE ( type ) == COMPLEX_TYPE ) && int_size_in_bytes ( type ) <= <NUM_LIT> ) return true ; return ! BYTES_BIG_ENDIAN ;


<s> switch ( GET_CODE ( x ) ) { case CONST_INT : fprintf ( f , HOST_WIDE_INT_PRINT_HEX , INTVAL ( x ) ) ; return ; case CONST_DOUBLE : fprintf ( f , <STR_LIT> , ( long ) XWINT ( x , <NUM_LIT> ) , ( long ) XWINT ( x , <NUM_LIT> ) ) ; return ; case CONST_VECTOR : { int i ; fprintf ( f , <STR_LIT> ) ; for ( i = <NUM_LIT> ; i < CONST_VECTOR_NUNITS ( x ) ; i ++ ) { fprintf ( f , HOST_WIDE_INT_PRINT_HEX , INTVAL ( CONST_VECTOR_ELT ( x , i ) ) ) ; if ( i < ( CONST_VECTOR_NUNITS ( x ) - <NUM_LIT> ) ) fputc ( ',' , f ) ; } fprintf ( f , <STR_LIT> ) ; }


<s> return HI_REGS ; } if ( regno <= LAST_ARM_REGNUM || regno == FRAME_POINTER_REGNUM || regno == ARG_POINTER_REGNUM ) return GENERAL_REGS ; if ( regno == CC_REGNUM || regno == VFPCC_REGNUM ) return NO_REGS ; if ( IS_CIRRUS_REGNUM ( regno ) ) return CIRRUS_REGS ;

if ( IS_VFP_REGNUM ( regno ) ) return VFP_REGS ;


<s> if ( regno < <NUM_LIT> ) return LO_REGS ; return HI_REGS ; } if ( regno <= LAST_ARM_REGNUM || regno == FRAME_POINTER_REGNUM || regno == ARG_POINTER_REGNUM ) return GENERAL_REGS ;

if ( regno == CC_REGNUM || regno == VFPCC_REGNUM ) return NO_REGS ;


<s> if ( lo == <NUM_LIT> ) lo &= <NUM_LIT> ; hi = ( ( ( ( offset - lo ) & ( HOST_WIDE_INT ) <NUM_LIT> ) ^ ( HOST_WIDE_INT ) <NUM_LIT> ) - ( HOST_WIDE_INT ) <NUM_LIT> ) ; gcc_assert ( hi + lo == offset ) ; if ( hi != <NUM_LIT> ) { rtx base_plus = gen_rtx_REG ( SImode , REGNO ( operands [ <NUM_LIT> ] ) + <NUM_LIT> ) ; if ( reg_overlap_mentioned_p ( base_plus , outval ) ) { if ( ! reg_overlap_mentioned_p ( scratch , outval ) ) { rtx tmp = scratch ; scratch = base_plus ; base_plus = tmp ; } else { rtx scratch_hi = gen_rtx_REG ( HImode , REGNO ( operands [ <NUM_LIT> ] ) ) ; emit_insn ( gen_movhi ( scratch_hi , outval ) ) ; outval = scratch_hi ; } } emit_insn ( gen_addsi3 ( base_plus , base , GEN_INT ( hi ) ) ) ; base = base_plus ; offset = lo ; } } if ( BYTES_BIG_ENDIAN ) { emit_insn ( gen_movqi ( gen_rtx_MEM ( QImode , plus_constant ( base , offset + <NUM_LIT> ) ) , gen_lowpart ( QImode , outval ) ) ) ; emit_insn ( gen_lshrsi3 ( scratch , gen_rtx_SUBREG ( SImode , outval , <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) ) ) ; emit_insn ( gen_movqi ( gen_rtx_MEM ( QImode , plus_constant ( base , offset ) ) , gen_lowpart ( QImode , scratch ) ) ) ;