<s> if ( TARGET_NEON ) switch ( mode ) { case E_HFmode : return TARGET_NEON_VECTORIZE_DOUBLE ? V4HFmode : V8HFmode ; case E_SFmode : return TARGET_NEON_VECTORIZE_DOUBLE ? V2SFmode : V4SFmode ; case E_SImode : return TARGET_NEON_VECTORIZE_DOUBLE ? V2SImode : V4SImode ; case E_HImode : return TARGET_NEON_VECTORIZE_DOUBLE ? V4HImode : V8HImode ; case E_QImode : return TARGET_NEON_VECTORIZE_DOUBLE ? V8QImode : V16QImode ; case E_DImode : if ( ! TARGET_NEON_VECTORIZE_DOUBLE ) return V2DImode ; break ; default : ; } if ( TARGET_REALLY_IWMMXT ) switch ( mode ) {


<s> build_target . isa = sbitmap_alloc ( isa_num_bits ) ; arm_configure_build_target ( & build_target , targ_options , false ) ; if ( build_target . core_name && ! bitmap_bit_p ( build_target . isa , isa_bit_quirk_no_asmcpu ) ) { const char * truncated_name = arm_rewrite_selected_cpu ( build_target . core_name ) ; asm_fprintf ( stream , <STR_LIT> , truncated_name ) ; } const arch_option * arch = arm_parse_arch_option_name ( all_architectures , <STR_LIT> , build_target . arch_name ) ; auto_sbitmap opt_bits ( isa_num_bits ) ; gcc_assert ( arch ) ; if ( strcmp ( build_target . arch_name , <STR_LIT> ) == <NUM_LIT> ) { asm_fprintf ( stream , <STR_LIT> ) ; asm_fprintf ( stream , <STR_LIT> ) ; asm_fprintf ( stream , <STR_LIT> ) ; asm_fprintf ( stream , <STR_LIT> ) ; asm_fprintf ( stream , <STR_LIT> ) ; } else asm_fprintf ( stream , <STR_LIT> , build_target . arch_name ) ; const char * fpu_name = ( TARGET_SOFT_FLOAT ? <STR_LIT> : arm_identify_fpu_from_isa ( build_target . isa ) ) ; asm_fprintf ( stream , <STR_LIT> , fpu_name ) ; if ( ! arch -> common . extensions ) return ; for ( const struct cpu_arch_extension * opt = arch -> common . extensions ; opt -> name != NULL ; opt ++ ) {


<s> } fputs ( arm_condition_codes [ arm_current_cc ] , stream ) ; } else if ( current_insn_predicate ) { enum arm_cond_code code ; if ( TARGET_THUMB1 ) {


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

if ( CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) ) asm_fprintf ( stream , <STR_LIT> , REGNO ( XEXP ( x , <NUM_LIT> ) ) , INTVAL ( XEXP ( x , <NUM_LIT> ) ) ) ;


<s> fprintf ( f , <STR_LIT> ) ; } return ; case CONST_STRING : fprintf ( f , <STR_LIT> , XSTR ( x , <NUM_LIT> ) ) ; return ; case SYMBOL_REF : fprintf ( f , <STR_LIT> , XSTR ( x , <NUM_LIT> ) ) ; return ; case LABEL_REF : fprintf ( f , <STR_LIT> , INSN_UID ( XEXP ( x , <NUM_LIT> ) ) ) ; return ; case CONST : arm_print_value ( f , XEXP ( x , <NUM_LIT> ) ) ; return ; case PLUS : arm_print_value ( f , XEXP ( x , <NUM_LIT> ) ) ; fprintf ( f , <STR_LIT> ) ; arm_print_value ( f , XEXP ( x , <NUM_LIT> ) ) ; return ; case PC : fprintf ( f , <STR_LIT> ) ; return ; default : fprintf ( f , <STR_LIT> ) ; return ;


<s> static tree arm_promoted_type ( const_tree t ) { if ( SCALAR_FLOAT_TYPE_P ( t ) && TYPE_PRECISION ( t ) == <NUM_LIT> && TYPE_MAIN_VARIANT ( t ) == arm_fp16_type_node ) return float_type_node ; return NULL_TREE ;


<s> if ( GET_MODE_CLASS ( mode ) == MODE_INT && GET_MODE_SIZE ( mode ) < <NUM_LIT> ) return SImode ;


<s> static bool arm_promote_prototypes ( const_tree t ATTRIBUTE_UNUSED ) { return ! TARGET_AAPCS_BASED ;


<s> void arm_pr_long_calls ( struct cpp_reader * pfile ATTRIBUTE_UNUSED ) { arm_pragma_long_calls = LONG ;


<s> void arm_pr_long_calls_off ( struct cpp_reader * pfile ATTRIBUTE_UNUSED ) { arm_pragma_long_calls = OFF ;


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


<s> return REGNO_REG_SET_P ( df_get_live_out ( ENTRY_BLOCK_PTR_FOR_FN ( cfun ) ) , <NUM_LIT> ) ;


<s> static bool arm_r3_live_at_start_p ( void ) { return REGNO_REG_SET_P ( df_get_live_out ( ENTRY_BLOCK_PTR_FOR_FN ( cfun ) ) , <NUM_LIT> ) ;


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

else if ( regno <= LAST_LO_VFP_REGNUM ) return VFP_LO_REGS ;


<s> struct cl_target_option * opts = TREE_TARGET_OPTION ( callee_tree ) ; SET_DECL_ALIGN ( fndecl , FUNCTION_ALIGNMENT ( FUNCTION_BOUNDARY_P ( opts -> x_target_flags ) ) ) ;


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

if ( REGNO ( operands [ <NUM_LIT> ] ) == REGNO ( operands [ <NUM_LIT> ] ) ) scratch = gen_rtx_REG ( SImode , REGNO ( operands [ <NUM_LIT> ] ) + <NUM_LIT> ) ;


<s> emit_insn ( gen_movhi ( scratch_hi , outval ) ) ; outval = scratch_hi ; } } emit_set_insn ( base_plus , base ) ; base = base_plus ; } else if ( GET_CODE ( base ) == PLUS ) { HOST_WIDE_INT hi , lo ; offset += INTVAL ( XEXP ( base , <NUM_LIT> ) ) ; base = XEXP ( base , <NUM_LIT> ) ; lo = ( offset >= <NUM_LIT> ? ( offset & <NUM_LIT> ) : - ( ( - offset ) & <NUM_LIT> ) ) ; if ( lo == <NUM_LIT> ) lo &= <NUM_LIT> ; hi = ( ( ( ( offset - lo ) & ( HOST_WIDE_INT ) <NUM_LIT> ) ^ ( HOST_WIDE_INT ) <NUM_LIT> ) - ( HOST_WIDE_INT ) <NUM_LIT> ) ; gcc_assert ( hi + lo == offset ) ; if ( hi != <NUM_LIT> ) { rtx base_plus = gen_rtx_REG ( SImode , REGNO ( operands [ <NUM_LIT> ] ) + <NUM_LIT> ) ; if ( reg_overlap_mentioned_p ( base_plus , outval ) ) { if ( ! reg_overlap_mentioned_p ( scratch , outval ) ) std :: swap ( scratch , base_plus ) ; else { rtx scratch_hi = gen_rtx_REG ( HImode , REGNO ( operands [ <NUM_LIT> ] ) ) ; emit_insn ( gen_movhi ( scratch_hi , outval ) ) ; outval = scratch_hi ; } } 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 ( Pmode , 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 ( Pmode , base , offset ) ) , gen_lowpart ( QImode , scratch ) ) ) ; } else { emit_insn ( gen_movqi ( gen_rtx_MEM ( QImode , plus_constant ( Pmode , base , offset ) ) , gen_lowpart ( QImode , outval ) ) ) ;


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

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


<s> for ( fdel = last_barrier -> next ; fdel && fdel != ftmp ; fdel = fdel -> next ) { fdel -> minipool -> refcount -- ; fdel -> minipool = NULL ; } ftmp = last_barrier ; } else { HOST_WIDE_INT max_address ; gcc_assert ( ftmp ) ; max_address = minipool_vector_head -> max_address ; if ( ftmp -> address < max_address ) max_address = ftmp -> address + <NUM_LIT> ; last_barrier = create_fix_barrier ( last_added_fix , max_address ) ; } assign_minipool_offsets ( last_barrier ) ; while ( ftmp ) { if ( ! BARRIER_P ( ftmp -> insn ) && ( ( ftmp -> minipool = add_minipool_backward_ref ( ftmp ) ) == NULL ) ) break ; ftmp = ftmp -> next ; } for ( this_fix = fix ; this_fix && ftmp != this_fix ; this_fix = this_fix -> next ) if ( ! BARRIER_P ( this_fix -> insn ) ) { rtx addr = plus_constant ( Pmode , gen_rtx_LABEL_REF ( VOIDmode , minipool_vector_label ) , this_fix -> minipool -> offset ) ; * this_fix -> loc = gen_rtx_MEM ( this_fix -> mode , addr ) ;


<s> void arm_reset_previous_fndecl ( void ) { arm_previous_fndecl = NULL_TREE ;


<s> rtx arm_return_addr ( int count , rtx frame ATTRIBUTE_UNUSED ) { if ( count != <NUM_LIT> ) return NULL_RTX ;

return get_hard_reg_initial_val ( Pmode , LR_REGNUM ) ;


<s> if ( count != <NUM_LIT> ) return NULL_RTX ;


<s> size = int_size_in_bytes ( type ) ; if ( TARGET_AAPCS_BASED ) { if ( ! AGGREGATE_TYPE_P ( type ) && TREE_CODE ( type ) != VECTOR_TYPE && TREE_CODE ( type ) != COMPLEX_TYPE ) return false ; if ( ( ( unsigned HOST_WIDE_INT ) size ) <= UNITS_PER_WORD ) return false ; if ( aapcs_select_return_coproc ( type , fntype ) >= <NUM_LIT> ) return false ; if ( TREE_CODE ( type ) == VECTOR_TYPE ) return ( size < <NUM_LIT> || size > ( <NUM_LIT> * UNITS_PER_WORD ) ) ; return true ; } if ( TREE_CODE ( type ) == VECTOR_TYPE ) return ( size < <NUM_LIT> || size > ( <NUM_LIT> * UNITS_PER_WORD ) ) ; if ( ! AGGREGATE_TYPE_P ( type ) && ( TREE_CODE ( type ) != VECTOR_TYPE ) ) return false ; if ( arm_abi != ARM_ABI_APCS ) { return ( size < <NUM_LIT> || size > UNITS_PER_WORD ) ; } if ( size < <NUM_LIT> || size > UNITS_PER_WORD ) return true ; if ( TREE_CODE ( type ) == RECORD_TYPE ) { tree field ; for ( field = TYPE_FIELDS ( type ) ; field && TREE_CODE ( field ) != FIELD_DECL ; field = DECL_CHAIN ( field ) ) continue ; if ( field == NULL ) return false ; if ( FLOAT_TYPE_P ( TREE_TYPE ( field ) ) ) return true ;

if ( arm_return_in_memory ( TREE_TYPE ( field ) , NULL_TREE ) ) return true ;


<s> return ( TARGET_AAPCS_BASED && BYTES_BIG_ENDIAN && ( AGGREGATE_TYPE_P ( valtype ) || TREE_CODE ( valtype ) == COMPLEX_TYPE || FIXED_POINT_TYPE_P ( valtype ) ) ) ;


<s> static bool arm_return_in_msb ( const_tree valtype ) { return ( TARGET_AAPCS_BASED && BYTES_BIG_ENDIAN && ( AGGREGATE_TYPE_P ( valtype ) || TREE_CODE ( valtype ) == COMPLEX_TYPE || FIXED_POINT_TYPE_P ( valtype ) ) ) ;


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


<s> bool result ; int code = GET_CODE ( x ) ; gcc_assert ( current_tune -> insn_extra_cost ) ; result = arm_rtx_costs_internal ( x , ( enum rtx_code ) code , ( enum rtx_code ) outer_code , current_tune -> insn_extra_cost , total , speed ) ; if ( dump_file && arm_verbose_cost ) { print_rtl_single ( dump_file , x ) ; fprintf ( dump_file , <STR_LIT> , speed ? <STR_LIT> : <STR_LIT> , * total , result ? <STR_LIT> : <STR_LIT> ) ; }


<s> static void arm_run_selftests ( void ) {


<s> int log = exact_log2 ( INTVAL ( hi_bound ) + <NUM_LIT> ) ; if ( log == - <NUM_LIT> ) return false ; if ( INTVAL ( lo_bound ) == <NUM_LIT> ) { if ( mask ) * mask = log ; if ( signed_sat ) * signed_sat = false ; return true ; }

if ( INTVAL ( lo_bound ) == - INTVAL ( hi_bound ) - <NUM_LIT> ) {


<s> rtx insn ; if ( TARGET_REALLY_IWMMXT ) for ( reg = LAST_IWMMXT_REGNUM ; reg >= FIRST_IWMMXT_REGNUM ; reg -- ) if ( reg_needs_saving_p ( reg ) ) { insn = gen_rtx_PRE_DEC ( Pmode , stack_pointer_rtx ) ; insn = gen_rtx_MEM ( V2SImode , insn ) ; insn = emit_set_insn ( insn , gen_rtx_REG ( V2SImode , reg ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; saved_size += <NUM_LIT> ; } if ( TARGET_VFP_BASE ) { start_reg = FIRST_VFP_REGNUM ;

for ( reg = FIRST_VFP_REGNUM ; reg < LAST_VFP_REGNUM ; reg += <NUM_LIT> ) {


<s> static int arm_save_coproc_regs ( void ) { int saved_size = <NUM_LIT> ; unsigned reg ; unsigned start_reg ; rtx insn ; if ( TARGET_REALLY_IWMMXT ) for ( reg = LAST_IWMMXT_REGNUM ; reg >= FIRST_IWMMXT_REGNUM ; reg -- ) if ( reg_needs_saving_p ( reg ) ) { insn = gen_rtx_PRE_DEC ( Pmode , stack_pointer_rtx ) ; insn = gen_rtx_MEM ( V2SImode , insn ) ;

insn = emit_set_insn ( insn , gen_rtx_REG ( V2SImode , reg ) ) ;


<s> static bool arm_scalar_mode_supported_p ( scalar_mode mode ) {

if ( mode == HFmode ) return ( arm_fp16_format != ARM_FP16_FORMAT_NONE ) ;


<s> case TYPE_FSQRTS : case TYPE_FSQRTD : case TYPE_NEON_FP_SQRT_S : case TYPE_NEON_FP_SQRT_D : case TYPE_NEON_FP_SQRT_S_Q : case TYPE_NEON_FP_SQRT_D_Q : case TYPE_NEON_FP_DIV_S : case TYPE_NEON_FP_DIV_D : case TYPE_NEON_FP_DIV_S_Q :


<s> if ( is_load ) * fusion_pri = tmp - <NUM_LIT> ; else * fusion_pri = tmp - <NUM_LIT> ; tmp /= <NUM_LIT> ; tmp -= ( ( REGNO ( base ) & <NUM_LIT> ) << <NUM_LIT> ) ; off_val = ( int ) ( INTVAL ( offset ) ) ; if ( off_val >= <NUM_LIT> ) tmp -= ( off_val & <NUM_LIT> ) ; else tmp += ( ( - off_val ) & <NUM_LIT> ) ; * pri = tmp ; return ;


<s> switch ( arm_tune ) { case TARGET_CPU_cortexa7 :

cortexa7_sched_reorder ( file , verbose , ready , n_readyp , clock ) ;


<s> if ( DEBUG_INSN_P ( insn ) ) return more ; rtx_code code = GET_CODE ( PATTERN ( insn ) ) ; if ( code == USE || code == CLOBBER ) return more ; if ( get_attr_type ( insn ) == TYPE_NO_INSN ) return more ;


<s> rtx_code code = GET_CODE ( PATTERN ( insn ) ) ;

if ( code == USE || code == CLOBBER ) return more ;


<s> if ( GET_MODE ( x ) == QImode && ( op == EQ || op == NE ) ) return CC_Zmode ; if ( GET_MODE ( x ) == SImode && ( op == LTU || op == GEU ) && GET_CODE ( x ) == PLUS && ( rtx_equal_p ( XEXP ( x , <NUM_LIT> ) , y ) || rtx_equal_p ( XEXP ( x , <NUM_LIT> ) , y ) ) ) return CC_Cmode ; if ( GET_MODE ( x ) == DImode && GET_CODE ( x ) == PLUS && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == ZERO_EXTEND && CONST_INT_P ( y ) && UINTVAL ( y ) == <NUM_LIT> && ( op == GEU || op == LTU ) ) return CC_ADCmode ; if ( GET_MODE ( x ) == DImode && ( op == GE || op == LT ) && GET_CODE ( x ) == SIGN_EXTEND && ( ( GET_CODE ( y ) == PLUS && arm_borrow_operation ( XEXP ( y , <NUM_LIT> ) , DImode ) ) || arm_borrow_operation ( y , DImode ) ) ) return CC_NVmode ; if ( GET_MODE ( x ) == DImode && ( op == GEU || op == LTU ) && GET_CODE ( x ) == ZERO_EXTEND && ( ( GET_CODE ( y ) == PLUS && arm_borrow_operation ( XEXP ( y , <NUM_LIT> ) , DImode ) ) || arm_borrow_operation ( y , DImode ) ) ) return CC_Bmode ; if ( GET_MODE ( x ) == DImode && ( op == EQ || op == NE ) && ( GET_CODE ( x ) == PLUS || GET_CODE ( x ) == MINUS ) && ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == SIGN_EXTEND || GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == SIGN_EXTEND ) && GET_CODE ( y ) == SIGN_EXTEND && GET_CODE ( XEXP ( y , <NUM_LIT> ) ) == GET_CODE ( x ) ) return CC_Vmode ;

if ( GET_MODE_CLASS ( GET_MODE ( x ) ) == MODE_CC ) return GET_MODE ( x ) ;


<s> } case GT : if ( cond_or == DOM_CC_X_AND_Y ) return CC_DGTmode ; switch ( cond2 ) { case GT : return CC_DGTmode ; case GE : return CC_DGEmode ; case NE : return CC_DNEmode ; default : gcc_unreachable ( ) ; } case LTU : if ( cond_or == DOM_CC_X_AND_Y ) return CC_DLTUmode ; switch ( cond2 ) { case LTU : return CC_DLTUmode ; case LEU : return CC_DLEUmode ; case NE : return CC_DNEmode ; default : gcc_unreachable ( ) ; } case GTU : if ( cond_or == DOM_CC_X_AND_Y ) return CC_DGTUmode ; switch ( cond2 ) { case GTU : return CC_DGTUmode ; case GEU : return CC_DGEUmode ; case NE : return CC_DNEmode ; default : gcc_unreachable ( ) ; } case NE :


<s> if ( ( arm_select_cc_mode ( cond1 = GET_CODE ( x ) , XEXP ( x , <NUM_LIT> ) , XEXP ( x , <NUM_LIT> ) ) != CCmode ) || ( arm_select_cc_mode ( cond2 = GET_CODE ( y ) , XEXP ( y , <NUM_LIT> ) , XEXP ( y , <NUM_LIT> ) ) != CCmode ) ) return CCmode ; if ( cond_or == DOM_CC_NX_OR_Y ) cond1 = reverse_condition ( cond1 ) ; if ( cond1 != cond2 && ! comparison_dominates_p ( cond1 , cond2 ) && ( swapped = <NUM_LIT> , ! comparison_dominates_p ( cond2 , cond1 ) ) ) return CCmode ; if ( swapped ) std :: swap ( cond1 , cond2 ) ; switch ( cond1 ) { case EQ : if ( cond_or == DOM_CC_X_AND_Y ) return CC_DEQmode ; switch ( cond2 ) { case EQ : return CC_DEQmode ; case LE : return CC_DLEmode ; case LEU : return CC_DLEUmode ; case GE : return CC_DGEmode ; case GEU : return CC_DGEUmode ; default : gcc_unreachable ( ) ; } case LT : if ( cond_or == DOM_CC_X_AND_Y ) return CC_DLTmode ; switch ( cond2 ) { case LT : return CC_DLTmode ; case LE : return CC_DLEmode ; case NE : return CC_DNEmode ; default : gcc_unreachable ( ) ; } case GT : if ( cond_or == DOM_CC_X_AND_Y ) return CC_DGTmode ; switch ( cond2 ) { case GT : return CC_DGTmode ; case GE : return CC_DGEmode ; case NE : return CC_DNEmode ; default : gcc_unreachable ( ) ; } case LTU : if ( cond_or == DOM_CC_X_AND_Y ) return CC_DLTUmode ; switch ( cond2 ) { case LTU : return CC_DLTUmode ; case LEU : return CC_DLEUmode ; case NE : return CC_DNEmode ; default : gcc_unreachable ( ) ; } case GTU : if ( cond_or == DOM_CC_X_AND_Y ) return CC_DGTUmode ;


<s> if ( GET_CODE ( set_dest ) == ZERO_EXTRACT ) { if ( CONST_INT_P ( SET_SRC ( curr_set ) ) && CONST_INT_P ( SET_SRC ( prev_set ) ) && REG_P ( XEXP ( set_dest , <NUM_LIT> ) ) && REG_P ( SET_DEST ( prev_set ) ) && REGNO ( XEXP ( set_dest , <NUM_LIT> ) ) == REGNO ( SET_DEST ( prev_set ) ) ) return true ; }

else if ( GET_CODE ( SET_SRC ( curr_set ) ) == LO_SUM && REG_P ( SET_DEST ( curr_set ) ) && REG_P ( SET_DEST ( prev_set ) ) && GET_CODE ( SET_SRC ( prev_set ) ) == HIGH && REGNO ( SET_DEST ( curr_set ) ) == REGNO ( SET_DEST ( prev_set ) ) ) return true ;


<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> static void arm_set_current_function ( tree fndecl ) { if ( ! fndecl || fndecl == arm_previous_fndecl ) return ; tree old_tree = ( arm_previous_fndecl ? DECL_FUNCTION_SPECIFIC_TARGET ( arm_previous_fndecl ) : NULL_TREE ) ; tree new_tree = DECL_FUNCTION_SPECIFIC_TARGET ( fndecl ) ; if ( ! new_tree && old_tree ) new_tree = target_option_default_node ; if ( old_tree == new_tree ) return ; arm_previous_fndecl = fndecl ; cl_target_option_restore ( & global_options , & global_options_set , TREE_TARGET_OPTION ( new_tree ) ) ; save_restore_target_globals ( new_tree ) ;

arm_override_options_after_change_1 ( & global_options , & global_options_set ) ;


<s> arm_previous_fndecl = fndecl ; cl_target_option_restore ( & global_options , & global_options_set , TREE_TARGET_OPTION ( new_tree ) ) ; save_restore_target_globals ( new_tree ) ;


<s> const char * maybe_suffix_2 = <STR_LIT> ; if ( ALL_FIXED_POINT_MODE_P ( from ) && ALL_FIXED_POINT_MODE_P ( to ) && UNSIGNED_FIXED_POINT_MODE_P ( from ) == UNSIGNED_FIXED_POINT_MODE_P ( to ) && ALL_FRACT_MODE_P ( from ) == ALL_FRACT_MODE_P ( to ) ) maybe_suffix_2 = <STR_LIT> ; sprintf ( buffer , <STR_LIT> , funcname , fromname , toname , maybe_suffix_2 ) ;

set_conv_libfunc ( optable , to , from , buffer ) ;


<s> static void arm_set_fixed_conv_libfunc ( convert_optab optable , machine_mode to , machine_mode from , const char * funcname , const char * toname , const char * fromname ) { char buffer [ <NUM_LIT> ] ;

const char * maybe_suffix_2 = <STR_LIT> ;


<s> if ( num_suffix == <NUM_LIT> ) sprintf ( buffer , <STR_LIT> , funcname , modename ) ;

else sprintf ( buffer , <STR_LIT> , funcname , modename , num_suffix ) ;


<s> if ( num_suffix == <NUM_LIT> ) sprintf ( buffer , <STR_LIT> , funcname , modename ) ; else sprintf ( buffer , <STR_LIT> , funcname , modename , num_suffix ) ;

set_optab_libfunc ( optable , mode , buffer ) ;


<s> else { if ( frame_pointer_needed ) addr = plus_constant ( Pmode , hard_frame_pointer_rtx , - <NUM_LIT> ) ; else { delta = offsets -> outgoing_args - ( offsets -> frame + <NUM_LIT> ) ; if ( delta >= <NUM_LIT> ) { emit_insn ( gen_addsi3 ( scratch , stack_pointer_rtx , GEN_INT ( delta & ~ <NUM_LIT> ) ) ) ; addr = scratch ; delta &= <NUM_LIT> ;


<s> return <STR_LIT> ; case ROTATERT : return <STR_LIT> ; default : abort ( ) ; }


<s> static unsigned HOST_WIDE_INT arm_shift_truncation_mask ( machine_mode mode ) { return mode == SImode ? <NUM_LIT> : <NUM_LIT> ;


<s> rtx elt_op = XVECEXP ( op , <NUM_LIT> , i ) ; rtx elt_ideal = XVECEXP ( ideal , <NUM_LIT> , i ) ; if ( ! CONST_INT_P ( elt_op ) || INTVAL ( elt_ideal ) != INTVAL ( elt_op ) ) return false ; } return true ;


<s> else base = high ? high_base : low_base ;

for ( i = <NUM_LIT> ; i < nunits / <NUM_LIT> ; i ++ ) RTVEC_ELT ( v , i ) = GEN_INT ( base + i ) ;


<s> else mode = DECL_MODE ( DECL_RESULT ( current_function_decl ) ) ; return GET_MODE_SIZE ( mode ) ;


<s> machine_mode mode ; if ( crtl -> return_rtx != <NUM_LIT> ) mode = GET_MODE ( crtl -> return_rtx ) ; else mode = DECL_MODE ( DECL_RESULT ( current_function_decl ) ) ;


<s> bool arm_small_register_classes_for_mode_p ( machine_mode mode ATTRIBUTE_UNUSED ) {


<s> void arm_split_atomic_op ( enum rtx_code code , rtx old_out , rtx new_out , rtx mem , rtx value , rtx model_rtx , rtx cond ) { enum memmodel model = memmodel_from_int ( INTVAL ( model_rtx ) ) ; machine_mode mode = GET_MODE ( mem ) ; machine_mode wmode = ( mode == DImode ? DImode : SImode ) ; rtx_code_label * label ; bool all_low_regs , bind_old_new ; rtx x ; bool is_armv8_sync = arm_arch8 && is_mm_sync ( model ) ; bool use_acquire = TARGET_HAVE_LDACQ && aarch_mm_needs_acquire ( model_rtx ) ; bool use_release = TARGET_HAVE_LDACQ && aarch_mm_needs_release ( model_rtx ) ; if ( is_armv8_sync ) use_acquire = false ; if ( ! ( use_acquire || use_release ) ) arm_pre_atomic_barrier ( model ) ; label = gen_label_rtx ( ) ; emit_label ( label ) ; if ( new_out ) new_out = gen_lowpart ( wmode , new_out ) ;

if ( old_out ) old_out = gen_lowpart ( wmode , old_out ) ;


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


<s> rtx rval , mem , oldval , newval , neg_bval , mod_s_rtx ; machine_mode mode ; enum memmodel mod_s , mod_f ; bool is_weak ; rtx_code_label * label1 , * label2 ; rtx x , cond ; rval = operands [ <NUM_LIT> ] ; mem = operands [ <NUM_LIT> ] ; oldval = operands [ <NUM_LIT> ] ; newval = operands [ <NUM_LIT> ] ; is_weak = ( operands [ <NUM_LIT> ] != const0_rtx ) ; mod_s_rtx = operands [ <NUM_LIT> ] ; mod_s = memmodel_from_int ( INTVAL ( mod_s_rtx ) ) ; mod_f = memmodel_from_int ( INTVAL ( operands [ <NUM_LIT> ] ) ) ; neg_bval = TARGET_THUMB1 ? operands [ <NUM_LIT> ] : operands [ <NUM_LIT> ] ; mode = GET_MODE ( mem ) ; bool is_armv8_sync = arm_arch8 && is_mm_sync ( mod_s ) ; bool use_acquire = TARGET_HAVE_LDACQ && aarch_mm_needs_acquire ( mod_s_rtx ) ; bool use_release = TARGET_HAVE_LDACQ && aarch_mm_needs_release ( mod_s_rtx ) ; if ( is_armv8_sync ) use_acquire = false ; if ( ! ( use_acquire || use_release ) ) arm_pre_atomic_barrier ( mod_s ) ; label1 = NULL ; if ( ! is_weak ) { label1 = gen_label_rtx ( ) ; emit_label ( label1 ) ; } label2 = gen_label_rtx ( ) ; arm_emit_load_exclusive ( mode , rval , mem , use_acquire ) ; if ( TARGET_32BIT ) { cond = arm_gen_compare_reg ( NE , rval , oldval , neg_bval ) ; x = gen_rtx_NE ( VOIDmode , cond , const0_rtx ) ; x = gen_rtx_IF_THEN_ELSE ( VOIDmode , x , gen_rtx_LABEL_REF ( Pmode , label2 ) , pc_rtx ) ; emit_unlikely_jump ( gen_rtx_SET ( pc_rtx , x ) ) ; } else { cond = gen_rtx_NE ( VOIDmode , rval , oldval ) ; if ( thumb1_cmpneg_operand ( oldval , SImode ) ) { rtx src = rval ; if ( ! satisfies_constraint_L ( oldval ) ) { gcc_assert ( satisfies_constraint_J ( oldval ) ) ; emit_move_insn ( neg_bval , rval ) ; src = neg_bval ; } emit_unlikely_jump ( gen_cbranchsi4_neg_late ( neg_bval , src , oldval , label2 , cond ) ) ; } else { emit_move_insn ( neg_bval , const1_rtx ) ; emit_unlikely_jump ( gen_cbranchsi4_insn ( cond , rval , oldval , label2 ) ) ; } } arm_emit_store_exclusive ( mode , neg_bval , mem , newval , use_release ) ; if ( TARGET_32BIT ) { cond = gen_rtx_REG ( CCmode , CC_REGNUM ) ; x = gen_rtx_COMPARE ( CCmode , neg_bval , const0_rtx ) ; emit_insn ( gen_rtx_SET ( cond , x ) ) ; } if ( ! is_weak ) { x = gen_rtx_NE ( VOIDmode , neg_bval , const0_rtx ) ;


<s> return <NUM_LIT> ; } else { rtx temp = subtargets ? gen_reg_rtx ( mode ) : target ; if ( TARGET_USE_MOVT ) arm_emit_movpair ( temp , GEN_INT ( val ) ) ; else emit_set_insn ( temp , GEN_INT ( val ) ) ; if ( code == MINUS ) emit_set_insn ( target , gen_rtx_MINUS ( mode , temp , source ) ) ; else emit_set_insn ( target , gen_rtx_fmt_ee ( code , mode , source , temp ) ) ; return <NUM_LIT> ; } }


<s> else cond = NULL_RTX ; if ( subtargets || code == SET || ( REG_P ( target ) && REG_P ( source ) && REGNO ( target ) != REGNO ( source ) ) ) { if ( ! cfun -> machine -> after_arm_reorg && ! cond && ( arm_gen_constant ( code , mode , NULL_RTX , val , target , source , <NUM_LIT> , <NUM_LIT> ) > ( arm_constant_limit ( optimize_function_for_size_p ( cfun ) ) + ( code != SET ) ) ) ) { if ( code == SET ) { if ( TARGET_USE_MOVT ) arm_emit_movpair ( target , GEN_INT ( val ) ) ; else emit_set_insn ( target , GEN_INT ( val ) ) ; return <NUM_LIT> ; } else {

rtx temp = subtargets ? gen_reg_rtx ( mode ) : target ;


<s> rtx arm_stack_protect_tls_canary_mem ( bool reload ) { rtx tp = gen_reg_rtx ( SImode ) ; if ( reload ) emit_insn ( gen_reload_tp_hard ( tp ) ) ; else emit_insn ( gen_load_tp_hard ( tp ) ) ;


<s> else emit_insn ( gen_load_tp_hard ( tp ) ) ; rtx reg = gen_reg_rtx ( SImode ) ; rtx offset = GEN_INT ( arm_stack_protector_guard_offset ) ;

emit_set_insn ( reg , gen_rtx_PLUS ( SImode , tp , offset ) ) ;


<s> const char * arm_strip_name_encoding ( const char * name ) { int skip ;

while ( ( skip = arm_get_strip_length ( * name ) ) ) name += skip ;


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


<s> bool arm_target_insn_ok_for_lob ( rtx insn ) { basic_block bb = BLOCK_FOR_INSN ( insn ) ; return single_succ_p ( bb ) && single_pred_p ( bb ) && single_succ_edge ( bb ) -> dest == single_pred_edge ( bb ) -> src && contains_no_active_insn_p ( bb ) ;


<s> if ( arch -> common . extensions == NULL ) continue ; arm_initialize_isa ( target_isa , arch -> common . isa_bits ) ; for ( ext1 = arch -> common . extensions ; ext1 -> name != NULL ; ++ ext1 ) { if ( ext1 -> alias ) continue ; arm_initialize_isa ( isa1 , ext1 -> isa_bits ) ; for ( ext2 = ext1 + <NUM_LIT> ; ext2 -> name != NULL ; ++ ext2 ) { if ( ext2 -> alias || ext1 -> remove != ext2 -> remove ) continue ; arm_initialize_isa ( isa2 , ext2 -> isa_bits ) ; ASSERT_TRUE ( ! bitmap_subset_p ( isa2 , isa1 ) ) ; ASSERT_TRUE ( ! bitmap_intersect_p ( isa2 , target_isa ) ) ; } } }

for ( cpu = all_cores ; cpu -> common . name != NULL ; ++ cpu ) {


<s> const cpu_option * cpu ; auto_sbitmap target_isa ( isa_num_bits ) ; auto_sbitmap isa1 ( isa_num_bits ) ; auto_sbitmap isa2 ( isa_num_bits ) ; for ( arch = all_architectures ; arch -> common . name != NULL ; ++ arch ) { const cpu_arch_extension * ext1 , * ext2 ; if ( arch -> common . extensions == NULL ) continue ; arm_initialize_isa ( target_isa , arch -> common . isa_bits ) ; for ( ext1 = arch -> common . extensions ; ext1 -> name != NULL ; ++ ext1 ) { if ( ext1 -> alias ) continue ; arm_initialize_isa ( isa1 , ext1 -> isa_bits ) ; for ( ext2 = ext1 + <NUM_LIT> ; ext2 -> name != NULL ; ++ ext2 ) { if ( ext2 -> alias || ext1 -> remove != ext2 -> remove ) continue ; arm_initialize_isa ( isa2 , ext2 -> isa_bits ) ; ASSERT_TRUE ( ! bitmap_subset_p ( isa2 , isa1 ) ) ; ASSERT_TRUE ( ! bitmap_intersect_p ( isa2 , target_isa ) ) ;


<s> arm_initialize_isa ( isa_all_fpubits_internal , fpu_bitlist_internal ) ; for ( unsigned int i = <NUM_LIT> ; i < TARGET_FPU_auto ; i ++ ) { arm_initialize_isa ( fpubits , all_fpus [ i ] . isa_bits ) ; bitmap_and_compl ( tmpset , isa_all_fpubits_internal , fpubits ) ; bitmap_clear ( isa_all_fpubits_internal ) ; bitmap_copy ( isa_all_fpubits_internal , tmpset ) ; } if ( ! bitmap_empty_p ( isa_all_fpubits_internal ) ) { fprintf ( stderr , <STR_LIT> <STR_LIT> <STR_LIT> ) ; ASSERT_TRUE ( bitmap_empty_p ( isa_all_fpubits_internal ) ) ;


<s> for ( unsigned int i = <NUM_LIT> ; i < TARGET_FPU_auto ; i ++ ) { arm_initialize_isa ( fpubits , all_fpus [ i ] . isa_bits ) ; bitmap_and_compl ( tmpset , isa_all_fpubits_internal , fpubits ) ; bitmap_clear ( isa_all_fpubits_internal ) ; bitmap_copy ( isa_all_fpubits_internal , tmpset ) ; } if ( ! bitmap_empty_p ( isa_all_fpubits_internal ) ) { fprintf ( stderr , <STR_LIT> <STR_LIT> <STR_LIT> ) ;


<s> enum rtx_code c = GET_CODE ( x ) ; if ( c == REG ) return <NUM_LIT> ; if ( c == PLUS && REG_P ( XEXP ( x , <NUM_LIT> ) ) && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> if ( c == PLUS && REG_P ( XEXP ( x , <NUM_LIT> ) ) && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> static rtx arm_tls_descseq_addr ( rtx x , rtx reg ) { rtx labelno = GEN_INT ( pic_labelno ++ ) ; rtx label = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , labelno ) , UNSPEC_PIC_LABEL ) ; rtx sum = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , x , GEN_INT ( TLS_DESCSEQ ) , gen_rtx_CONST ( VOIDmode , label ) , GEN_INT ( ! TARGET_ARM ) ) , UNSPEC_TLS ) ; rtx reg0 = load_tls_operand ( sum , gen_rtx_REG ( SImode , R0_REGNUM ) ) ; emit_insn ( gen_tlscall ( x , labelno ) ) ; if ( ! reg ) reg = gen_reg_rtx ( SImode ) ; else gcc_assert ( REGNO ( reg ) != R0_REGNUM ) ; emit_move_insn ( reg , reg0 ) ; return reg ;


<s> rtx labelno = GEN_INT ( pic_labelno ++ ) ; rtx label = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , labelno ) , UNSPEC_PIC_LABEL ) ; rtx sum = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , x , GEN_INT ( TLS_DESCSEQ ) , gen_rtx_CONST ( VOIDmode , label ) , GEN_INT ( ! TARGET_ARM ) ) , UNSPEC_TLS ) ; rtx reg0 = load_tls_operand ( sum , gen_rtx_REG ( SImode , R0_REGNUM ) ) ; emit_insn ( gen_tlscall ( x , labelno ) ) ; if ( ! reg ) reg = gen_reg_rtx ( SImode ) ; else gcc_assert ( REGNO ( reg ) != R0_REGNUM ) ;


<s> const_rtx x = * iter ; if ( SYMBOL_REF_P ( x ) && SYMBOL_REF_TLS_MODEL ( x ) != <NUM_LIT> ) { if ( arm_disable_literal_pool ) sorry ( <STR_LIT> <STR_LIT> ) ; return true ; } if ( GET_CODE ( x ) == UNSPEC && XINT ( x , <NUM_LIT> ) == UNSPEC_TLS ) iter . skip_subrtxes ( ) ;


<s> rtx funcdesc = XEXP ( DECL_RTL ( fndecl ) , <NUM_LIT> ) ; rtx fnaddr = gen_rtx_MEM ( Pmode , funcdesc ) ; rtx gotaddr = gen_rtx_MEM ( Pmode , plus_constant ( Pmode , funcdesc , <NUM_LIT> ) ) ; rtx trampoline_code_start = plus_constant ( Pmode , XEXP ( m_tramp , <NUM_LIT> ) , TARGET_THUMB2 ? <NUM_LIT> : <NUM_LIT> ) ; mem = adjust_address ( m_tramp , SImode , <NUM_LIT> ) ; emit_move_insn ( mem , trampoline_code_start ) ; mem = adjust_address ( m_tramp , SImode , <NUM_LIT> ) ; emit_move_insn ( mem , gen_rtx_REG ( Pmode , PIC_OFFSET_TABLE_REGNUM ) ) ; mem = adjust_address ( m_tramp , SImode , <NUM_LIT> ) ; emit_move_insn ( mem , chain_value ) ; mem = adjust_address ( m_tramp , SImode , <NUM_LIT> ) ; emit_move_insn ( mem , gotaddr ) ; mem = adjust_address ( m_tramp , SImode , <NUM_LIT> ) ; emit_move_insn ( mem , fnaddr ) ; } else { mem = adjust_address ( m_tramp , SImode , TARGET_32BIT ? <NUM_LIT> : <NUM_LIT> ) ; emit_move_insn ( mem , chain_value ) ; mem = adjust_address ( m_tramp , SImode , TARGET_32BIT ? <NUM_LIT> : <NUM_LIT> ) ; fnaddr = XEXP ( DECL_RTL ( fndecl ) , <NUM_LIT> ) ; emit_move_insn ( mem , fnaddr ) ;


<s> switch ( XINT ( x , <NUM_LIT> ) ) { case UNSPEC_UNALIGNED_LOAD : * cost = COSTS_N_INSNS ( ARM_NUM_REGS ( GET_MODE ( x ) ) ) ; if ( speed_p ) * cost += ( ARM_NUM_REGS ( GET_MODE ( x ) ) * extra_cost -> ldst . load + extra_cost -> ldst . load_unaligned ) ; * cost += arm_address_cost ( XEXP ( XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) , <NUM_LIT> ) , GET_MODE ( x ) , ADDR_SPACE_GENERIC , speed_p ) ; return true ; case UNSPEC_UNALIGNED_STORE : * cost = COSTS_N_INSNS ( ARM_NUM_REGS ( GET_MODE ( x ) ) ) ; if ( speed_p ) * cost += ( ARM_NUM_REGS ( GET_MODE ( x ) ) * extra_cost -> ldst . store + extra_cost -> ldst . store_unaligned ) ; * cost += rtx_cost ( XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) , VOIDmode , UNSPEC , <NUM_LIT> , speed_p ) ; * cost += arm_address_cost ( XEXP ( XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) , <NUM_LIT> ) , GET_MODE ( x ) , ADDR_SPACE_GENERIC , speed_p ) ;


<s> const struct cpu_cost_table * extra_cost = current_tune -> insn_extra_cost ; rtx_code code = GET_CODE ( x ) ; gcc_assert ( code == UNSPEC || code == UNSPEC_VOLATILE ) ; switch ( XINT ( x , <NUM_LIT> ) ) { case UNSPEC_UNALIGNED_LOAD : * cost = COSTS_N_INSNS ( ARM_NUM_REGS ( GET_MODE ( x ) ) ) ; if ( speed_p ) * cost += ( ARM_NUM_REGS ( GET_MODE ( x ) ) * extra_cost -> ldst . load + extra_cost -> ldst . load_unaligned ) ; * cost += arm_address_cost ( XEXP ( XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) , <NUM_LIT> ) , GET_MODE ( x ) , ADDR_SPACE_GENERIC , speed_p ) ; return true ; case UNSPEC_UNALIGNED_STORE : * cost = COSTS_N_INSNS ( ARM_NUM_REGS ( GET_MODE ( x ) ) ) ; if ( speed_p ) * cost += ( ARM_NUM_REGS ( GET_MODE ( x ) ) * extra_cost -> ldst . store + extra_cost -> ldst . store_unaligned ) ; * cost += rtx_cost ( XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) , VOIDmode , UNSPEC , <NUM_LIT> , speed_p ) ; * cost += arm_address_cost ( XEXP ( XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) , <NUM_LIT> ) , GET_MODE ( x ) , ADDR_SPACE_GENERIC , speed_p ) ; return true ; case UNSPEC_VRINTZ : case UNSPEC_VRINTP : case UNSPEC_VRINTM : case UNSPEC_VRINTR : case UNSPEC_VRINTX : case UNSPEC_VRINTA : if ( speed_p ) * cost += extra_cost -> fp [ GET_MODE ( x ) == DFmode ] . roundint ; return true ; default : * cost = COSTS_N_INSNS ( <NUM_LIT> ) ; break ; } return true ;


<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 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 ) ; offset += reg_size ; } } fprintf ( out_file , <STR_LIT> ) ;

if ( padfirst ) fprintf ( out_file , <STR_LIT> , padfirst ) ;


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


<s> rtx e0 ; rtx e1 ; 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 ) ; } 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> ) ) ) ; }


<s> PUT_CODE ( * comparison , ( enum rtx_code ) code_int ) ; switch ( mode ) { case E_SImode : if ( ! arm_add_operand ( * op1 , mode ) ) * op1 = force_reg ( mode , * op1 ) ; if ( ! arm_add_operand ( * op2 , mode ) ) * op2 = force_reg ( mode , * op2 ) ; return true ; case E_DImode : return true ; case E_HFmode : if ( ! TARGET_VFP_FP16INST ) break ; mode = SFmode ; * op1 = convert_to_mode ( mode , * op1 , <NUM_LIT> ) ; * op2 = convert_to_mode ( mode , * op2 , <NUM_LIT> ) ; case E_SFmode : case E_DFmode : if ( ! vfp_compare_operand ( * op1 , mode ) ) * op1 = force_reg ( mode , * op1 ) ; if ( ! vfp_compare_operand ( * op2 , mode ) ) * op2 = force_reg ( mode , * op2 ) ; return true ; default :


<s> bool arm_valid_symbolic_address_p ( rtx addr ) { rtx xop0 , xop1 = NULL_RTX ; rtx tmp = addr ; if ( target_word_relocations ) return false ; if ( SYMBOL_REF_P ( tmp ) || LABEL_REF_P ( tmp ) ) return true ; if ( GET_CODE ( addr ) == CONST ) tmp = XEXP ( addr , <NUM_LIT> ) ;


<s> tree cur_tree , new_optimize ; gcc_assert ( ( fndecl != NULL_TREE ) && ( args != NULL_TREE ) ) ; tree func_optimize = DECL_FUNCTION_SPECIFIC_OPTIMIZATION ( fndecl ) ; if ( ! func_optimize ) func_optimize = optimization_default_node ; memset ( & func_options , <NUM_LIT> , sizeof ( func_options ) ) ; init_options_struct ( & func_options , NULL ) ; lang_hooks . init_options_struct ( & func_options ) ;

memset ( & func_options_set , <NUM_LIT> , sizeof ( func_options_set ) ) ;


<s> if ( ! arm_valid_target_attribute_rec ( args , opts ) ) return NULL_TREE ; cl_target_option_save ( & cl_opts , opts , opts_set ) ; arm_configure_build_target ( & arm_active_target , & cl_opts , false ) ; arm_option_check_internal ( opts ) ;


<s> break ; case <NUM_LIT> : d . op1 = op0 ; d . one_vector_p = true ; break ; } d . perm . new_vector ( sel . encoding ( ) , d . one_vector_p ? <NUM_LIT> : <NUM_LIT> , nelt ) ; if ( ! d . testing_p ) return arm_expand_vec_perm_const_1 ( & d ) ; d . target = gen_raw_REG ( d . vmode , LAST_VIRTUAL_REGISTER + <NUM_LIT> ) ; d . op1 = d . op0 = gen_raw_REG ( d . vmode , LAST_VIRTUAL_REGISTER + <NUM_LIT> ) ; if ( ! d . one_vector_p ) d . op1 = gen_raw_REG ( d . vmode , LAST_VIRTUAL_REGISTER + <NUM_LIT> ) ;


<s> if ( TARGET_AAPCS_BASED ) align = MIN ( align , <NUM_LIT> ) ; return align ;


<s> static HOST_WIDE_INT arm_vector_alignment ( const_tree type ) { HOST_WIDE_INT align = tree_to_shwi ( TYPE_SIZE ( type ) ) ;

if ( TARGET_AAPCS_BASED ) align = MIN ( align , <NUM_LIT> ) ;


<s> if ( TARGET_NEON && ! BYTES_BIG_ENDIAN && unaligned_access ) return ! is_packed ;


<s> if ( TARGET_INT_SIMD && ( mode == V4UQQmode || mode == V4QQmode || mode == V2UHQmode || mode == V2HQmode || mode == V2UHAmode || mode == V2HAmode ) ) return true ; if ( TARGET_HAVE_MVE && ( mode == V2DImode || mode == V4SImode || mode == V8HImode || mode == V16QImode || mode == V16BImode || mode == V8BImode || mode == V4BImode ) ) return true ; if ( TARGET_HAVE_MVE_FLOAT && ( mode == V2DFmode || mode == V4SFmode || mode == V8HFmode ) ) return true ; return false ;


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


<s> void ashift ( HOST_WIDE_INT shift ) { asm_fprintf ( t_file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , dst_regname , shift ) ;


<s> Mnode * mp ; minipool_barrier = barrier ; for ( mp = minipool_vector_head ; mp != NULL ; mp = mp -> next ) {


<s> HOST_WIDE_INT offset = <NUM_LIT> ; Mnode * mp ; minipool_barrier = barrier ; for ( mp = minipool_vector_head ; mp != NULL ; mp = mp -> next ) {


<s> return __builtin_neon_vbfcvtbf ( __a ) ;


return __builtin_neon_vbfcvtbf ( __a ) ;


<s> return __builtin_neon_vbfcvtsf ( __a ) ;


<s> static unsigned bitmap_popcount ( const sbitmap bmap ) {


<s> static unsigned bitmap_popcount ( const sbitmap bmap ) { unsigned int count = <NUM_LIT> ; unsigned int n = <NUM_LIT> ;


<s> unsigned long count = <NUM_LIT> ; while ( value ) {


<s> while ( value ) { count ++ ; value &= value - <NUM_LIT> ; } return count ;


<s> HOST_WIDE_INT lane ; gcc_assert ( CONST_INT_P ( operand ) ) ; lane = INTVAL ( operand ) ; if ( lane < low || lane >= high ) { if ( exp ) error_at ( EXPR_LOCATION ( exp ) , <STR_LIT> , desc , lane , low , high - <NUM_LIT> ) ; else error ( <STR_LIT> , desc , lane , low , high - <NUM_LIT> ) ;


if ( exp ) error_at ( EXPR_LOCATION ( exp ) , <STR_LIT> , desc , lane , low , high - <NUM_LIT> ) ;


<s> pat = gen_calculate_pic_address ( reg , pic_reg , orig ) ; mem = SET_SRC ( pat ) ; gcc_assert ( MEM_P ( mem ) && ! MEM_VOLATILE_P ( mem ) ) ; MEM_READONLY_P ( mem ) = <NUM_LIT> ; MEM_NOTRAP_P ( mem ) = <NUM_LIT> ;


<s> static rtx_insn * calculate_pic_address_constant ( rtx reg , rtx pic_reg , rtx orig ) { rtx pat ; rtx mem ; pat = gen_calculate_pic_address ( reg , pic_reg , orig ) ; mem = SET_SRC ( pat ) ; gcc_assert ( MEM_P ( mem ) && ! MEM_VOLATILE_P ( mem ) ) ; MEM_READONLY_P ( mem ) = <NUM_LIT> ; MEM_NOTRAP_P ( mem ) = <NUM_LIT> ;


<s> static bool can_avoid_literal_pool_for_label_p ( rtx x ) {

if ( arm_disable_literal_pool && SYMBOL_REF_P ( x ) && CONSTANT_POOL_ADDRESS_P ( x ) ) return <NUM_LIT> ;


<s> int count = XVECLEN ( op , <NUM_LIT> ) ; int first_set = vfp ? <NUM_LIT> : <NUM_LIT> ; machine_mode expected_mode = vfp ? E_SFmode : E_SImode ; for ( int i = first_set ; i < count ; i ++ ) { elt = XVECEXP ( op , <NUM_LIT> , i ) ; if ( ! vfp && GET_CODE ( elt ) == UNSPEC_VOLATILE ) { if ( XINT ( elt , <NUM_LIT> ) != VUNSPEC_CLRM_APSR || XVECLEN ( elt , <NUM_LIT> ) != <NUM_LIT> || XVECEXP ( elt , <NUM_LIT> , <NUM_LIT> ) != CONST0_RTX ( SImode ) || i != count - <NUM_LIT> ) return false ; continue ; } if ( GET_CODE ( elt ) == CLOBBER ) continue ; if ( GET_CODE ( elt ) != SET ) return false ; reg = SET_DEST ( elt ) ; zero = SET_SRC ( elt ) ; if ( ! REG_P ( reg ) || GET_MODE ( reg ) != expected_mode || zero != CONST0_RTX ( SImode ) ) return false ; regno = REGNO ( reg ) ; if ( vfp ) { if ( i != first_set && regno != last_regno + <NUM_LIT> ) return false ; } else { if ( regno == SP_REGNUM || regno == PC_REGNUM ) return false ;

if ( i != first_set && regno <= last_regno ) return false ;


<s> zero = SET_SRC ( elt ) ; if ( ! REG_P ( reg ) || GET_MODE ( reg ) != expected_mode || zero != CONST0_RTX ( SImode ) ) return false ; regno = REGNO ( reg ) ; if ( vfp ) { if ( i != first_set && regno != last_regno + <NUM_LIT> ) return false ; } else { if ( regno == SP_REGNUM || regno == PC_REGNUM ) return false ;


<s> static __inline int __attribute__ ( ( __always_inline__ ) ) cmse_nonsecure_caller ( void ) {

return __builtin_arm_cmse_nonsecure_caller ( ) ;


<s> if ( bitmap_empty_p ( to_clear_core_bitmap ) ) return ; nb_regs = bitmap_count_bits ( to_clear_core_bitmap ) ; par = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( nb_regs + <NUM_LIT> ) ) ; start_sequence ( ) ; for ( j = <NUM_LIT> , i = minregno ; j < nb_regs ; i ++ ) { if ( ! bitmap_bit_p ( to_clear_core_bitmap , i ) ) continue ; reg = gen_rtx_REG ( SImode , i ) ; set = gen_rtx_SET ( reg , const0_rtx ) ; XVECEXP ( par , <NUM_LIT> , j ++ ) = set ; emit_use ( reg ) ; } vunspec_vec = gen_rtvec ( <NUM_LIT> , gen_int_mode ( <NUM_LIT> , SImode ) ) ; vunspec = gen_rtx_UNSPEC_VOLATILE ( SImode , vunspec_vec , VUNSPEC_CLRM_APSR ) ; XVECEXP ( par , <NUM_LIT> , j ++ ) = vunspec ; rtx ccreg = gen_rtx_REG ( CCmode , CC_REGNUM ) ; rtx clobber = gen_rtx_CLOBBER ( VOIDmode , ccreg ) ; XVECEXP ( par , <NUM_LIT> , j ) = clobber ; use_seq = get_insns ( ) ; end_sequence ( ) ; emit_insn_after ( use_seq , emit_insn ( par ) ) ; } else { if ( clearing_regno <= maxregno && bitmap_bit_p ( to_clear_bitmap , clearing_regno ) ) { emit_move_insn ( clearing_reg , const0_rtx ) ; emit_use ( clearing_reg ) ; bitmap_clear_bit ( to_clear_bitmap , clearing_regno ) ; } for ( regno = minregno ; regno <= maxregno ; regno ++ ) { if ( ! bitmap_bit_p ( to_clear_bitmap , regno ) ) continue ; if ( IS_VFP_REGNUM ( regno ) ) { if ( TARGET_VFP_DOUBLE && VFP_REGNO_OK_FOR_DOUBLE ( regno ) && bitmap_bit_p ( to_clear_bitmap , regno + <NUM_LIT> ) ) { emit_move_insn ( gen_rtx_REG ( DFmode , regno ) , CONST1_RTX ( DFmode ) ) ; emit_use ( gen_rtx_REG ( DFmode , regno ) ) ;


<s> scratch_reg = clearing_reg ; } mask = ( ~ padding_bits_to_clear [ i ] ) & <NUM_LIT> ; emit_move_insn ( scratch_reg , gen_int_mode ( mask , SImode ) ) ; mask = ( ~ padding_bits_to_clear [ i ] ) >> <NUM_LIT> ; rtx16 = gen_int_mode ( <NUM_LIT> , SImode ) ; dest = gen_rtx_ZERO_EXTRACT ( SImode , scratch_reg , rtx16 , rtx16 ) ; if ( mask ) emit_insn ( gen_rtx_SET ( dest , gen_int_mode ( mask , SImode ) ) ) ; emit_insn ( gen_andsi3 ( cleared_reg , cleared_reg , scratch_reg ) ) ; } if ( saved_clearing ) emit_move_insn ( clearing_reg , saved_clearing_reg ) ; if ( TARGET_HAVE_FPCXT_CMSE ) { rtvec vunspec_vec ; int i , j , k , nb_regs ; rtx use_seq , par , reg , set , vunspec ; int to_clear_bitmap_size = SBITMAP_SIZE ( to_clear_bitmap ) ; auto_sbitmap core_regs_bitmap ( to_clear_bitmap_size ) ; auto_sbitmap to_clear_core_bitmap ( to_clear_bitmap_size ) ; for ( i = FIRST_VFP_REGNUM ; i <= maxregno ; i += nb_regs ) { for ( ; i <= maxregno && ! bitmap_bit_p ( to_clear_bitmap , i ) ; i ++ ) ; if ( i > maxregno ) break ; for ( j = i ; j <= maxregno && bitmap_bit_p ( to_clear_bitmap , j ) ; j ++ ) ; nb_regs = j - i ; par = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( nb_regs + <NUM_LIT> ) ) ; vunspec_vec = gen_rtvec ( <NUM_LIT> , gen_int_mode ( <NUM_LIT> , SImode ) ) ; vunspec = gen_rtx_UNSPEC_VOLATILE ( SImode , vunspec_vec , VUNSPEC_VSCCLRM_VPR ) ; XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = vunspec ; start_sequence ( ) ; for ( k = <NUM_LIT> , j = i ; j <= maxregno && k < nb_regs + <NUM_LIT> ; j ++ ) {

if ( ! bitmap_bit_p ( to_clear_bitmap , j ) ) continue ;


<s> static __inline int __attribute__ ( ( __always_inline__ ) ) __attribute__ ( ( warn_unused_result ) ) cmse_nonsecure_caller ( void ) {


<s> static bool cmse_func_args_or_return_in_stack ( tree fndecl , tree name , tree fntype ) { function_args_iterator args_iter ; CUMULATIVE_ARGS args_so_far_v ; cumulative_args_t args_so_far ; bool first_param = true ; tree arg_type , prev_arg_type = NULL_TREE , ret_type ; arm_init_cumulative_args ( & args_so_far_v , fntype , NULL_RTX , fndecl ) ; args_so_far = pack_cumulative_args ( & args_so_far_v ) ; FOREACH_FUNCTION_ARGS ( fntype , arg_type , args_iter ) { rtx arg_rtx ; prev_arg_type = arg_type ; if ( VOID_TYPE_P ( arg_type ) ) continue ; function_arg_info arg ( arg_type , true ) ; if ( ! first_param ) arm_function_arg_advance ( args_so_far , arg ) ; arg_rtx = arm_function_arg ( args_so_far , arg ) ; if ( ! arg_rtx || arm_arg_partial_bytes ( args_so_far , arg ) ) { error ( <STR_LIT> <STR_LIT> , name ) ;


<s> args_so_far = pack_cumulative_args ( & args_so_far_v ) ; FOREACH_FUNCTION_ARGS ( fntype , arg_type , args_iter ) { rtx arg_rtx ; prev_arg_type = arg_type ; if ( VOID_TYPE_P ( arg_type ) ) continue ; function_arg_info arg ( arg_type , true ) ; if ( ! first_param ) arm_function_arg_advance ( args_so_far , arg ) ; arg_rtx = arm_function_arg ( args_so_far , arg ) ;

if ( ! arg_rtx || arm_arg_partial_bytes ( args_so_far , arg ) ) {


<s> if ( ! NONDEBUG_INSN_P ( insn ) ) continue ; if ( ! CALL_P ( insn ) ) continue ; pat = PATTERN ( insn ) ; gcc_assert ( GET_CODE ( pat ) == PARALLEL && XVECLEN ( pat , <NUM_LIT> ) > <NUM_LIT> ) ; call = XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ; if ( GET_CODE ( call ) == SET ) call = SET_SRC ( call ) ; unspec = XEXP ( call , <NUM_LIT> ) ; if ( GET_CODE ( unspec ) != UNSPEC || XINT ( unspec , <NUM_LIT> ) != UNSPEC_NONSECURE_MEM ) continue ; bitmap_clear ( to_clear_bitmap ) ; bitmap_set_range ( to_clear_bitmap , R0_REGNUM , max_int_regno - R0_REGNUM + <NUM_LIT> ) ; if ( ! lazy_fpclear ) { auto_sbitmap float_bitmap ( maxregno + <NUM_LIT> ) ; bitmap_clear ( float_bitmap ) ; bitmap_set_range ( float_bitmap , FIRST_VFP_REGNUM , max_fp_regno - FIRST_VFP_REGNUM + <NUM_LIT> ) ; bitmap_ior ( to_clear_bitmap , to_clear_bitmap , float_bitmap ) ; } address = RTVEC_ELT ( XVEC ( unspec , <NUM_LIT> ) , <NUM_LIT> ) ; gcc_assert ( MEM_P ( address ) ) ; gcc_assert ( REG_P ( XEXP ( address , <NUM_LIT> ) ) ) ; address_regnum = REGNO ( XEXP ( address , <NUM_LIT> ) ) ; if ( address_regnum <= max_int_regno ) bitmap_clear_bit ( to_clear_bitmap , address_regnum ) ; set_block_for_insn ( insn , bb ) ; df_set_flags ( DF_DEFER_INSN_RESCAN ) ; start_sequence ( ) ; emit_insn ( gen_blockage ( ) ) ; fntype = TREE_TYPE ( MEM_EXPR ( address ) ) ; arm_init_cumulative_args ( & args_so_far_v , fntype , NULL_RTX , NULL_TREE ) ; args_so_far = pack_cumulative_args ( & args_so_far_v ) ; FOREACH_FUNCTION_ARGS ( fntype , arg_type , args_iter ) { rtx arg_rtx ; uint64_t to_clear_args_mask ;

if ( VOID_TYPE_P ( arg_type ) ) continue ;


<s> emit_use ( gen_rtx_REG ( SImode , IP_REGNUM ) ) ; bitmap_clear_bit ( to_clear_bitmap , IP_REGNUM ) ; emit_use ( gen_rtx_REG ( SImode , <NUM_LIT> ) ) ; bitmap_clear_bit ( to_clear_bitmap , <NUM_LIT> ) ; } } for ( regno = NUM_ARG_REGS ; regno <= maxregno ; regno ++ ) { if ( IN_RANGE ( regno , FIRST_VFP_REGNUM , D7_VFP_REGNUM ) ) continue ; if ( IN_RANGE ( regno , IP_REGNUM , PC_REGNUM ) ) continue ; if ( ! callee_saved_reg_p ( regno ) && ( ! IN_RANGE ( regno , FIRST_VFP_REGNUM , LAST_VFP_REGNUM ) || TARGET_HARD_FLOAT ) ) bitmap_set_bit ( to_clear_bitmap , regno ) ; } result_type = TREE_TYPE ( DECL_RESULT ( current_function_decl ) ) ; if ( ! VOID_TYPE_P ( result_type ) ) { uint64_t to_clear_return_mask ; result_rtl = arm_function_value ( result_type , current_function_decl , <NUM_LIT> ) ; gcc_assert ( REG_P ( result_rtl ) ) ; to_clear_return_mask = compute_not_to_clear_mask ( result_type , result_rtl , <NUM_LIT> , & padding_bits_to_clear ) ; if ( to_clear_return_mask ) { gcc_assert ( ( unsigned ) maxregno < sizeof ( long long ) * __CHAR_BIT__ ) ; for ( regno = R0_REGNUM ; regno <= maxregno ; regno ++ ) {

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


<s> bitmap_clear_bit ( to_clear_bitmap , IP_REGNUM ) ; emit_use ( gen_rtx_REG ( SImode , <NUM_LIT> ) ) ; bitmap_clear_bit ( to_clear_bitmap , <NUM_LIT> ) ; } } for ( regno = NUM_ARG_REGS ; regno <= maxregno ; regno ++ ) { if ( IN_RANGE ( regno , FIRST_VFP_REGNUM , D7_VFP_REGNUM ) ) continue ; if ( IN_RANGE ( regno , IP_REGNUM , PC_REGNUM ) ) continue ; if ( ! callee_saved_reg_p ( regno ) && ( ! IN_RANGE ( regno , FIRST_VFP_REGNUM , LAST_VFP_REGNUM ) || TARGET_HARD_FLOAT ) ) bitmap_set_bit ( to_clear_bitmap , regno ) ; } result_type = TREE_TYPE ( DECL_RESULT ( current_function_decl ) ) ; if ( ! VOID_TYPE_P ( result_type ) ) { uint64_t to_clear_return_mask ; result_rtl = arm_function_value ( result_type , current_function_decl , <NUM_LIT> ) ; gcc_assert ( REG_P ( result_rtl ) ) ; to_clear_return_mask = compute_not_to_clear_mask ( result_type , result_rtl , <NUM_LIT> , & padding_bits_to_clear ) ; if ( to_clear_return_mask ) { gcc_assert ( ( unsigned ) maxregno < sizeof ( long long ) * __CHAR_BIT__ ) ; for ( regno = R0_REGNUM ; regno <= maxregno ; regno ++ ) {


<s> not_to_clear_mask = comp_not_to_clear_mask_str_un ( arg_type , & regno , padding_bits_to_clear , <NUM_LIT> , & last_used_bit ) ; if ( last_used_bit != <NUM_LIT> ) padding_bits_to_clear [ regno ] |= ( ( uint32_t ) - <NUM_LIT> ) - ( ( uint32_t ) <NUM_LIT> << last_used_bit ) + <NUM_LIT> ; else not_to_clear_mask &= ~ ( HOST_WIDE_INT_1U << regno ) ; } else { not_to_clear_mask = <NUM_LIT> ; if ( GET_MODE ( arg_rtx ) == BLKmode ) { int i , arg_regs ; rtx reg ; gcc_assert ( TARGET_HARD_FLOAT_ABI ) ; for ( i = <NUM_LIT> ; i < XVECLEN ( arg_rtx , <NUM_LIT> ) ; i ++ ) { reg = XEXP ( XVECEXP ( arg_rtx , <NUM_LIT> , i ) , <NUM_LIT> ) ; gcc_assert ( REG_P ( reg ) ) ; not_to_clear_mask |= HOST_WIDE_INT_1U << REGNO ( reg ) ; arg_regs = ARM_NUM_REGS ( GET_MODE ( reg ) ) ; if ( arg_regs > <NUM_LIT> ) { unsigned HOST_WIDE_INT mask ; mask = HOST_WIDE_INT_1U << ( REGNO ( reg ) + arg_regs ) ; mask -= HOST_WIDE_INT_1U << REGNO ( reg ) ; not_to_clear_mask |= mask ; } } } else { int arg_regs = ARM_NUM_REGS ( GET_MODE ( arg_rtx ) ) ;

not_to_clear_mask |= HOST_WIDE_INT_1U << REGNO ( arg_rtx ) ;


<s> for ( i = <NUM_LIT> ; i < nops ; i ++ ) { int j ; order [ i ] = order [ i - <NUM_LIT> ] ; for ( j = <NUM_LIT> ; j < nops ; j ++ ) if ( unsorted_offsets [ j ] == unsorted_offsets [ order [ i - <NUM_LIT> ] ] + <NUM_LIT> ) { if ( order [ i ] != order [ i - <NUM_LIT> ] ) return false ; order [ i ] = j ; } if ( order [ i ] == order [ i - <NUM_LIT> ] ) return false ; if ( unsorted_regs != NULL && unsorted_regs [ order [ i ] ] <= unsorted_regs [ order [ i - <NUM_LIT> ] ] ) return false ; }


<s> if ( TARGET_ARM ) lowbit &= ~ <NUM_LIT> ; if ( ( i & ~ ( ( ( unsigned HOST_WIDE_INT ) <NUM_LIT> ) << lowbit ) ) == <NUM_LIT> ) return TRUE ; if ( TARGET_ARM ) { if ( lowbit <= <NUM_LIT> && ( ( i & ~ <NUM_LIT> ) == <NUM_LIT> || ( i & ~ <NUM_LIT> ) == <NUM_LIT> || ( i & ~ <NUM_LIT> ) == <NUM_LIT> ) ) return TRUE ; } else if ( TARGET_THUMB2 ) { HOST_WIDE_INT v ; v = i & <NUM_LIT> ; v |= v << <NUM_LIT> ; if ( i == v || i == ( v | ( v << <NUM_LIT> ) ) ) return TRUE ; v = i & <NUM_LIT> ; v |= v << <NUM_LIT> ;


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


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


<s> case GE : case GEU : case LTU : case GTU : case LEU : case UNORDERED : case ORDERED : case UNEQ : case UNGE : case UNLT : case UNGT : case UNLE : return const_ok_for_arm ( ARM_SIGN_EXTEND ( - i ) ) ; case MINUS : case XOR : return <NUM_LIT> ; case IOR : if ( TARGET_THUMB2 ) return const_ok_for_arm ( ARM_SIGN_EXTEND ( ~ i ) ) ; return <NUM_LIT> ;


<s> case SET : if ( TARGET_HAVE_MOVT && ( i & <NUM_LIT> ) == <NUM_LIT> ) return <NUM_LIT> ; else return const_ok_for_arm ( ARM_SIGN_EXTEND ( ~ i ) ) ; case PLUS : if ( TARGET_THUMB2 && ( ( i & <NUM_LIT> ) == <NUM_LIT> || ( ( - i ) & <NUM_LIT> ) == <NUM_LIT> ) ) return <NUM_LIT> ; case COMPARE : case EQ : case NE : case GT : case LE : case LT : case GE : case GEU : case LTU :


<s> if ( s_register_operand ( x , mode ) || neon_vector_mem_operand ( x , <NUM_LIT> , true ) ) return NO_REGS ; return GENERAL_REGS ; }

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


<s> static void cortexa7_sched_reorder ( FILE * file , int verbose , rtx_insn * * ready , int * n_readyp , int clock ) { int i ; int first_older_only = - <NUM_LIT> , first_younger = - <NUM_LIT> ; if ( verbose > <NUM_LIT> ) fprintf ( file , <STR_LIT> , clock , * n_readyp ) ; for ( i = * n_readyp - <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) { rtx_insn * insn = ready [ i ] ; if ( cortexa7_older_only ( insn ) ) { first_older_only = i ; if ( verbose > <NUM_LIT> ) fprintf ( file , <STR_LIT> , INSN_UID ( insn ) ) ; break ; }

else if ( cortexa7_younger ( file , verbose , insn ) && first_younger == - <NUM_LIT> ) first_younger = i ;


<s> else if ( cortexa7_younger ( file , verbose , insn ) && first_younger == - <NUM_LIT> ) first_younger = i ; } if ( first_younger == - <NUM_LIT> ) { if ( verbose > <NUM_LIT> ) fprintf ( file , <STR_LIT> ) ; return ; } if ( first_older_only == - <NUM_LIT> ) { if ( verbose > <NUM_LIT> ) fprintf ( file , <STR_LIT> ) ; return ; } if ( verbose > <NUM_LIT> ) fprintf ( file , <STR_LIT> , INSN_UID ( ready [ first_older_only ] ) , INSN_UID ( ready [ first_younger ] ) ) ;

rtx_insn * first_older_only_insn = ready [ first_older_only ] ;


<s> case TYPE_ALUS_IMM : case TYPE_LOGIC_IMM : case TYPE_LOGICS_IMM : case TYPE_EXTEND : case TYPE_MVN_IMM : case TYPE_MOV_IMM : case TYPE_MOV_REG : case TYPE_MOV_SHIFT : case TYPE_MOV_SHIFT_REG : case TYPE_BRANCH : case TYPE_CALL : return true ; default : return false ; }


<s> static bool cortexa7_younger ( FILE * file , int verbose , rtx_insn * insn ) { if ( recog_memoized ( insn ) < <NUM_LIT> ) { if ( verbose > <NUM_LIT> ) fprintf ( file , <STR_LIT> , INSN_UID ( insn ) ) ; return false ; } switch ( get_attr_type ( insn ) ) { case TYPE_ALU_IMM : case TYPE_ALUS_IMM : case TYPE_LOGIC_IMM : case TYPE_LOGICS_IMM : case TYPE_EXTEND : case TYPE_MVN_IMM : case TYPE_MOV_IMM : case TYPE_MOV_REG : case TYPE_MOV_SHIFT : case TYPE_MOV_SHIFT_REG : case TYPE_BRANCH : case TYPE_CALL : return true ; default : return false ; }


<s> return false ; case REG_DEP_TRUE : case REG_DEP_OUTPUT : if ( recog_memoized ( insn ) >= <NUM_LIT> && recog_memoized ( dep ) >= <NUM_LIT> ) { if ( GET_CODE ( PATTERN ( insn ) ) == SET ) { if ( GET_MODE_CLASS ( GET_MODE ( SET_DEST ( PATTERN ( insn ) ) ) ) == MODE_FLOAT || GET_MODE_CLASS ( GET_MODE ( SET_SRC ( PATTERN ( insn ) ) ) ) == MODE_FLOAT ) {

enum attr_type attr_type_insn = get_attr_type ( insn ) ;


<s> if ( REG_P ( SET_DEST ( PATTERN ( insn ) ) ) && reg_set_p ( SET_DEST ( PATTERN ( insn ) ) , dep ) ) { if ( ( attr_type_insn == TYPE_FMACS || attr_type_insn == TYPE_FMACD ) && ( attr_type_dep == TYPE_FMACS || attr_type_dep == TYPE_FMACD ) ) { if ( dep_type == REG_DEP_OUTPUT ) * cost = insn_default_latency ( dep ) - <NUM_LIT> ; else * cost = insn_default_latency ( dep ) ; return false ; } else { if ( dep_type == REG_DEP_OUTPUT ) * cost = insn_default_latency ( dep ) + <NUM_LIT> ; else * cost = insn_default_latency ( dep ) ; }


<s> rtx_jump_table_data * tmp ; int new_cost ; gcc_assert ( ! BARRIER_P ( from ) ) ; if ( LABEL_P ( from ) ) count += get_label_padding ( from ) ; else count += get_attr_length ( from ) ; if ( tablejump_p ( from , NULL , & tmp ) ) { count += get_jump_table_size ( tmp ) ; new_cost = arm_barrier_cost ( from ) ; if ( count < max_count && ( ! selected || new_cost <= selected_cost ) ) { selected = tmp ; selected_cost = new_cost ; selected_address = fix -> address + count ; } from = NEXT_INSN ( tmp ) ; continue ; } new_cost = arm_barrier_cost ( from ) ; if ( count < max_count && ( ! selected || new_cost <= selected_cost ) ) { selected = from ; selected_cost = new_cost ; selected_address = fix -> address + count ; } from = NEXT_INSN ( from ) ; } gcc_assert ( selected ) ; from = emit_jump_insn_after ( gen_jump ( label ) , selected ) ;


<s> if ( ARM_DOUBLEWORD_ALIGN ) for ( mp = minipool_vector_head ; mp != NULL ; mp = mp -> next ) if ( mp -> refcount > <NUM_LIT> && mp -> fix_size >= <NUM_LIT> ) { align64 = <NUM_LIT> ; break ; } if ( dump_file ) fprintf ( dump_file , <STR_LIT> , INSN_UID ( scan ) , ( unsigned long ) minipool_barrier -> address , align64 ? <NUM_LIT> : <NUM_LIT> ) ; scan = emit_label_after ( gen_label_rtx ( ) , scan ) ; scan = emit_insn_after ( align64 ? gen_align_8 ( ) : gen_align_4 ( ) , scan ) ; scan = emit_label_after ( minipool_vector_label , scan ) ; for ( mp = minipool_vector_head ; mp != NULL ; mp = nmp ) { if ( mp -> refcount > <NUM_LIT> ) { if ( dump_file ) { fprintf ( dump_file , <STR_LIT> , ( unsigned ) mp -> offset , ( unsigned long ) mp -> min_address , ( unsigned long ) mp -> max_address ) ; arm_print_value ( dump_file , mp -> value ) ; fputc ( '\n' , dump_file ) ; } rtx val = copy_rtx ( mp -> value ) ; switch ( GET_MODE_SIZE ( mp -> mode ) ) { case <NUM_LIT> : scan = emit_insn_after ( gen_consttable_1 ( val ) , scan ) ; break ; case <NUM_LIT> : scan = emit_insn_after ( gen_consttable_2 ( val ) , scan ) ; break ; case <NUM_LIT> :

scan = emit_insn_after ( gen_consttable_4 ( val ) , scan ) ;


<s> if ( cond ) pattern = gen_rtx_COND_EXEC ( VOIDmode , copy_rtx ( cond ) , pattern ) ; emit_insn ( pattern ) ;


<s> static void emit_constant_insn ( rtx cond , rtx pattern ) {

if ( cond ) pattern = gen_rtx_COND_EXEC ( VOIDmode , copy_rtx ( cond ) , pattern ) ;


<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 ) ) { reg = gen_rtx_REG ( SImode , i ) ; 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 ) ) ; if ( dwarf_regs_mask & ( <NUM_LIT> << i ) ) { tmp = gen_rtx_SET ( gen_frame_mem ( SImode , stack_pointer_rtx ) , reg ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( dwarf , <NUM_LIT> , dwarf_par_index ++ ) = tmp ; } break ; } } for ( j = <NUM_LIT> , i ++ ; j < num_regs ; i ++ ) { if ( mask & ( <NUM_LIT> << i ) ) { reg = gen_rtx_REG ( SImode , i ) ; XVECEXP ( par , <NUM_LIT> , j ) = gen_rtx_USE ( VOIDmode , reg ) ; if ( dwarf_regs_mask & ( <NUM_LIT> << i ) ) { tmp = gen_rtx_SET ( gen_frame_mem ( SImode , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> * j ) ) , reg ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( dwarf , <NUM_LIT> , dwarf_par_index ++ ) = tmp ; }


<s> for ( i = <NUM_LIT> ; i <= LAST_ARM_REGNUM ; i ++ ) { if ( mask & ( <NUM_LIT> << i ) ) num_regs ++ ; 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 ) ) { reg = gen_rtx_REG ( SImode , i ) ; 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 ) ) ; if ( dwarf_regs_mask & ( <NUM_LIT> << i ) ) { tmp = gen_rtx_SET ( gen_frame_mem ( SImode , stack_pointer_rtx ) , reg ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( dwarf , <NUM_LIT> , dwarf_par_index ++ ) = tmp ; } break ; } } for ( j = <NUM_LIT> , i ++ ; j < num_regs ; i ++ ) { if ( mask & ( <NUM_LIT> << i ) ) { reg = gen_rtx_REG ( SImode , i ) ; XVECEXP ( par , <NUM_LIT> , j ) = gen_rtx_USE ( VOIDmode , reg ) ; if ( dwarf_regs_mask & ( <NUM_LIT> << i ) ) { tmp = gen_rtx_SET ( gen_frame_mem ( SImode , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> * j ) ) , reg ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( dwarf , <NUM_LIT> , dwarf_par_index ++ ) = tmp ; } j ++ ; } } par = emit_insn ( par ) ; tmp = gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - <NUM_LIT> * num_regs ) ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( dwarf , <NUM_LIT> , <NUM_LIT> ) = tmp ; add_reg_note ( par , REG_FRAME_RELATED_EXPR , dwarf ) ; return par ;


<s> return emit_insn ( gen_rtx_SET ( x , y ) ) ;


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

return emit_insn ( gen_rtx_SET ( x , y ) ) ;


<s> static void emit_unlikely_jump ( rtx insn ) {

rtx_insn * jump = emit_jump_insn ( insn ) ;


<s> static bool extract_base_offset_in_addr ( rtx mem , rtx * base , rtx * offset ) { rtx addr ; gcc_assert ( MEM_P ( mem ) ) ; addr = XEXP ( mem , <NUM_LIT> ) ; if ( GET_CODE ( addr ) == CONST ) addr = XEXP ( addr , <NUM_LIT> ) ; if ( REG_P ( addr ) ) { * base = addr ; * offset = const0_rtx ;


<s> return true ; } if ( GET_CODE ( addr ) == PLUS && GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == REG && CONST_INT_P ( XEXP ( addr , <NUM_LIT> ) ) ) {


<s> * cost = <NUM_LIT> ; return false ; } if ( GET_CODE ( PATTERN ( insn ) ) == COND_EXEC || get_attr_conds ( insn ) == CONDS_USE ) { * cost = <NUM_LIT> ;


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


<s> if ( VOID_TYPE_P ( arg_type ) ) continue ; function_arg_info arg ( arg_type , true ) ; if ( ! first_param ) arm_function_arg_advance ( args_so_far , arg ) ; arg_rtx = arm_function_arg ( args_so_far , arg ) ; gcc_assert ( REG_P ( arg_rtx ) ) ;


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


<s> if ( ! optimize_size ) break ; case AND : case IOR : case XOR : if ( rtx_equal_p ( dst , op0 ) && low_register_operand ( op1 , SImode ) ) action = action_for_partial_flag_setting ; else if ( rtx_equal_p ( dst , op1 ) && low_register_operand ( op0 , SImode ) ) action = action_for_partial_flag_setting == SKIP ? SKIP : SWAP_CONV ; break ; case ASHIFTRT : case ASHIFT : case LSHIFTRT : if ( rtx_equal_p ( dst , op0 ) && low_register_operand ( op1 , SImode ) ) action = action_for_partial_flag_setting ; else if ( low_register_operand ( op0 , SImode ) && CONST_INT_P ( op1 ) && IN_RANGE ( INTVAL ( op1 ) , <NUM_LIT> , <NUM_LIT> ) ) action = action_for_partial_flag_setting ; break ; case ROTATERT : if ( rtx_equal_p ( dst , op0 ) && low_register_operand ( op1 , SImode ) ) action = action_for_partial_flag_setting ; break ; case NOT : if ( low_register_operand ( op0 , SImode ) ) action = action_for_partial_flag_setting ; break ; case NEG : if ( low_register_operand ( op0 , SImode ) ) action = CONV ; break ; case CONST_INT : if ( CONST_INT_P ( src ) && IN_RANGE ( INTVAL ( src ) , <NUM_LIT> , <NUM_LIT> ) ) action = action_for_partial_flag_setting ; break ; case REG : break ; default : break ; } } if ( action != SKIP ) { rtx ccreg = gen_rtx_REG ( CCmode , CC_REGNUM ) ; rtx clobber = gen_rtx_CLOBBER ( VOIDmode , ccreg ) ; rtvec vec ; if ( action == SWAP_CONV ) { src = copy_rtx ( src ) ; XEXP ( src , <NUM_LIT> ) = op1 ; XEXP ( src , <NUM_LIT> ) = op0 ; pat = gen_rtx_SET ( dst , src ) ;

vec = gen_rtvec ( <NUM_LIT> , pat , clobber ) ;


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


<s> set_conv_libfunc ( sext_optab , mode_iter , BFmode , NULL ) ;

set_conv_libfunc ( sext_optab , BFmode , mode_iter , NULL ) ;


<s> return __builtin_neon_vabshf ( __a ) ;


return __builtin_neon_vcvtahssi ( __a ) ;


return __builtin_neon_vcvtahusi ( __a ) ;


<s> return __builtin_neon_vcvthuhf ( __a ) ;


<s> return __builtin_neon_vcvths_nhf ( __a , __b ) ;


<s> return __builtin_neon_vcvthu_nhf ( ( int32_t ) __a , __b ) ;


return __builtin_neon_vcvtmhssi ( __a ) ;


<s> return __builtin_neon_vcvtmhssi ( __a ) ;


<s> return __builtin_neon_vcvtnhssi ( __a ) ;


return __builtin_neon_vcvtnhusi ( __a ) ;


<s> return __builtin_neon_vcvtnhusi ( __a ) ;


<s> return __builtin_neon_vcvtphusi ( __a ) ;


<s> return __builtin_neon_vminnmhf ( __a , __b ) ;


<s> return __builtin_neon_vrndahf ( __a ) ;


<s> return __builtin_neon_vrndhf ( __a ) ;


<s> return __builtin_neon_vrndihf ( __a ) ;


<s> return __builtin_neon_vrndphf ( __a ) ;


<s> return __builtin_neon_vrndxhf ( __a ) ;


<s> if ( ! fp_consts_inited ) init_fp_table ( ) ; gcc_assert ( real_equal ( r , & value_fp0 ) ) ; return <STR_LIT> ;


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

gcc_assert ( real_equal ( r , & value_fp0 ) ) ;


<s> extract_base_offset_in_addr ( dest , base , offset ) ; } else if ( MEM_P ( src ) && REG_P ( dest ) ) { * is_load = true ; extract_base_offset_in_addr ( src , base , offset ) ; } else return false ;

return ( * base != NULL_RTX && * offset != NULL_RTX ) ;


<s> static bool fusion_load_store ( rtx_insn * insn , rtx * base , rtx * offset , bool * is_load ) { rtx x , dest , src ; gcc_assert ( INSN_P ( insn ) ) ; x = PATTERN ( insn ) ; if ( GET_CODE ( x ) != SET ) return false ; src = SET_SRC ( x ) ; dest = SET_DEST ( x ) ; if ( REG_P ( src ) && MEM_P ( dest ) ) { * is_load = false ;

extract_base_offset_in_addr ( dest , base , offset ) ;


<s> for ( j = i + <NUM_LIT> ; j < nops ; j ++ ) if ( regs [ i ] == regs [ j ] ) { rtx t = peep2_find_free_register ( <NUM_LIT> , nops * <NUM_LIT> , TARGET_THUMB1 ? <STR_LIT> : <STR_LIT> , SImode , & allocated ) ; if ( t == NULL_RTX ) return false ; reg_rtxs [ i ] = t ; regs [ i ] = REGNO ( t ) ; } } reg_order [ <NUM_LIT> ] = <NUM_LIT> ; for ( i = <NUM_LIT> ; i < nops ; i ++ ) if ( regs [ i ] < regs [ reg_order [ <NUM_LIT> ] ] ) reg_order [ <NUM_LIT> ] = i ; for ( i = <NUM_LIT> ; i < nops ; i ++ ) { int this_order = reg_order [ i - <NUM_LIT> ] ; for ( j = <NUM_LIT> ; j < nops ; j ++ ) if ( regs [ j ] > regs [ reg_order [ i - <NUM_LIT> ] ] && ( this_order == reg_order [ i - <NUM_LIT> ] || regs [ j ] < regs [ this_order ] ) ) this_order = j ; reg_order [ i ] = this_order ; } for ( i = <NUM_LIT> ; i < nops ; i ++ ) { int this_order = reg_order [ i ] ; if ( ( this_order != mem_order [ i ] || orig_reg_rtxs [ this_order ] != reg_rtxs [ this_order ] ) && ! peep2_reg_dead_p ( nops * <NUM_LIT> , orig_reg_rtxs [ this_order ] ) ) return false ; } for ( i = <NUM_LIT> ; i < nops ; i ++ ) { rtx op = operands [ <NUM_LIT> * nops + mem_order [ i ] ] ; sorted_regs [ i ] = regs [ reg_order [ i ] ] ;

emit_move_insn ( reg_rtxs [ reg_order [ i ] ] , op ) ;


<s> rtx low_reg = NULL_RTX ; rtx hi_reg = NULL_RTX ; if ( ! src_aligned || ! dst_aligned ) { low_reg = gen_lowpart ( SImode , reg0 ) ; hi_reg = gen_highpart_mode ( SImode , DImode , reg0 ) ; } if ( MEM_ALIGN ( src ) >= <NUM_LIT> * BITS_PER_WORD ) emit_move_insn ( reg0 , src ) ; else if ( src_aligned ) emit_insn ( gen_unaligned_loaddi ( reg0 , src ) ) ; else { emit_insn ( gen_unaligned_loadsi ( low_reg , src ) ) ; src = next_consecutive_mem ( src ) ; emit_insn ( gen_unaligned_loadsi ( hi_reg , src ) ) ; } if ( MEM_ALIGN ( dst ) >= <NUM_LIT> * BITS_PER_WORD ) emit_move_insn ( dst , reg0 ) ; else if ( dst_aligned ) emit_insn ( gen_unaligned_storedi ( dst , reg0 ) ) ; else { emit_insn ( gen_unaligned_storesi ( dst , low_reg ) ) ; dst = next_consecutive_mem ( dst ) ; emit_insn ( gen_unaligned_storesi ( dst , hi_reg ) ) ; } src = next_consecutive_mem ( src ) ; dst = next_consecutive_mem ( dst ) ; } gcc_assert ( len < <NUM_LIT> ) ; if ( len >= <NUM_LIT> ) { reg0 = gen_reg_rtx ( SImode ) ; src = adjust_address ( src , SImode , <NUM_LIT> ) ; dst = adjust_address ( dst , SImode , <NUM_LIT> ) ; if ( src_aligned ) emit_move_insn ( reg0 , src ) ; else emit_insn ( gen_unaligned_loadsi ( reg0 , src ) ) ; if ( dst_aligned ) emit_move_insn ( dst , reg0 ) ; else emit_insn ( gen_unaligned_storesi ( dst , reg0 ) ) ; src = next_consecutive_mem ( src ) ; dst = next_consecutive_mem ( dst ) ;


<s> int regs [ MAX_LDM_STM_OPS ] , mem_order [ MAX_LDM_STM_OPS ] ; rtx mems [ MAX_LDM_STM_OPS ] ; int i , j , base_reg ; rtx base_reg_rtx ; HOST_WIDE_INT offset ; int write_back = FALSE ; int ldm_case ; rtx addr ; ldm_case = load_multiple_sequence ( operands , nops , regs , mem_order , & base_reg , & offset , ! sort_regs ) ; if ( ldm_case == <NUM_LIT> ) return false ;

if ( sort_regs ) for ( i = <NUM_LIT> ; i < nops - <NUM_LIT> ; i ++ ) for ( j = i + <NUM_LIT> ; j < nops ; j ++ ) if ( regs [ i ] > regs [ j ] ) {


<s> if ( load && REGNO ( operands [ <NUM_LIT> ] ) == REGNO ( operands [ <NUM_LIT> ] ) ) return false ; if ( const_store && REGNO ( operands [ <NUM_LIT> ] ) == REGNO ( operands [ <NUM_LIT> ] ) && INTVAL ( operands [ <NUM_LIT> ] ) != INTVAL ( operands [ <NUM_LIT> ] ) ) { if ( TARGET_THUMB2 ) { CLEAR_HARD_REG_SET ( regset ) ; tmp = peep2_find_free_register ( <NUM_LIT> , <NUM_LIT> , <STR_LIT> , SImode , & regset ) ; if ( tmp == NULL_RTX ) return false ; operands [ <NUM_LIT> ] = tmp ; } else if ( TARGET_ARM ) { int regno = REGNO ( operands [ <NUM_LIT> ] ) ; if ( ! peep2_reg_dead_p ( <NUM_LIT> , operands [ <NUM_LIT> ] ) ) { if ( regno % <NUM_LIT> == <NUM_LIT> ) return false ; SET_HARD_REG_SET ( regset ) ; CLEAR_HARD_REG_BIT ( regset , regno - <NUM_LIT> ) ; tmp = peep2_find_free_register ( <NUM_LIT> , <NUM_LIT> , <STR_LIT> , SImode , & regset ) ; if ( tmp == NULL_RTX ) return false ; operands [ <NUM_LIT> ] = tmp ; } else { CLEAR_HARD_REG_SET ( regset ) ; tmp = peep2_find_free_register ( <NUM_LIT> , <NUM_LIT> , <STR_LIT> , DImode , & regset ) ; if ( tmp != NULL_RTX ) { operands [ <NUM_LIT> ] = simplify_gen_subreg ( SImode , tmp , DImode , <NUM_LIT> ) ; operands [ <NUM_LIT> ] = simplify_gen_subreg ( SImode , tmp , DImode , <NUM_LIT> ) ; } else { SET_HARD_REG_SET ( regset ) ; CLEAR_HARD_REG_BIT ( regset , regno % <NUM_LIT> == <NUM_LIT> ? regno + <NUM_LIT> : regno - <NUM_LIT> ) ; tmp = peep2_find_free_register ( <NUM_LIT> , <NUM_LIT> , <STR_LIT> , SImode , & regset ) ; if ( tmp == NULL_RTX ) return false ; operands [ regno % <NUM_LIT> == <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ] = tmp ; } }

gcc_assert ( operands [ <NUM_LIT> ] != NULL_RTX ) ;


<s> gcc_assert ( base_reg_dies ) ; emit_insn ( gen_addsi3 ( base_reg_rtx , base_reg_rtx , GEN_INT ( offset ) ) ) ; offset = <NUM_LIT> ; } addr = plus_constant ( Pmode , base_reg_rtx , offset ) ; for ( i = <NUM_LIT> ; i < nops ; i ++ ) { addr = plus_constant ( Pmode , base_reg_rtx , offset + i * <NUM_LIT> ) ; mems [ i ] = adjust_automodify_address_nv ( operands [ nops + mem_order [ i ] ] , SImode , addr , <NUM_LIT> ) ; } emit_insn ( arm_gen_store_multiple_1 ( nops , regs , mems , base_reg_rtx , write_back ? offset + i * <NUM_LIT> : <NUM_LIT> ) ) ;


<s> rtx addr ; bool base_reg_dies ; stm_case = store_multiple_sequence ( operands , nops , nops , regs , NULL , mem_order , & base_reg , & offset , true ) ; if ( stm_case == <NUM_LIT> ) return false ; base_reg_rtx = gen_rtx_REG ( Pmode , base_reg ) ; base_reg_dies = peep2_reg_dead_p ( nops , base_reg_rtx ) ; if ( TARGET_THUMB1 ) { gcc_assert ( base_reg_dies ) ; write_back = TRUE ; } if ( stm_case == <NUM_LIT> ) { gcc_assert ( base_reg_dies ) ; emit_insn ( gen_addsi3 ( base_reg_rtx , base_reg_rtx , GEN_INT ( offset ) ) ) ; offset = <NUM_LIT> ; } addr = plus_constant ( Pmode , base_reg_rtx , offset ) ; for ( i = <NUM_LIT> ; i < nops ; i ++ ) { addr = plus_constant ( Pmode , base_reg_rtx , offset + i * <NUM_LIT> ) ; mems [ i ] = adjust_automodify_address_nv ( operands [ nops + mem_order [ i ] ] , SImode , addr , <NUM_LIT> ) ; } emit_insn ( arm_gen_store_multiple_1 ( nops , regs , mems , base_reg_rtx , write_back ? offset + i * <NUM_LIT> : <NUM_LIT> ) ) ; return true ;


<s> gcc_assert ( code != ARM_NV ) ; return code ;


<s> static enum arm_cond_code get_arm_condition_code ( rtx comparison ) {

enum arm_cond_code code = maybe_get_arm_condition_code ( comparison ) ;


<s> range = INTVAL ( op ) ; if ( ! IN_RANGE ( range , - <NUM_LIT> , <NUM_LIT> ) ) return false ; return ( range % <NUM_LIT> ) == <NUM_LIT> ; } case PRE_INC : case POST_INC : case PRE_DEC : case POST_DEC : return REG_P ( XEXP ( op , <NUM_LIT> ) ) ; default :


<s> static HOST_WIDE_INT get_jump_table_size ( rtx_jump_table_data * insn ) { if ( JUMP_TABLES_IN_TEXT_SECTION || readonly_data_section == text_section ) { rtx body = PATTERN ( insn ) ; int elt = GET_CODE ( body ) == ADDR_DIFF_VEC ? <NUM_LIT> : <NUM_LIT> ; HOST_WIDE_INT size ; HOST_WIDE_INT modesize ; modesize = GET_MODE_SIZE ( GET_MODE ( body ) ) ; size = modesize * XVECLEN ( body , elt ) ; switch ( modesize ) { case <NUM_LIT> : size = ( size + <NUM_LIT> ) & ~ HOST_WIDE_INT_1 ; break ; case <NUM_LIT> : break ; case <NUM_LIT> : if ( TARGET_THUMB ) size += <NUM_LIT> ; break ; default : gcc_unreachable ( ) ;


<s> align = <NUM_LIT> << label_to_alignment ( label ) . levels [ <NUM_LIT> ] . log ; min_insn_size = TARGET_THUMB ? <NUM_LIT> : <NUM_LIT> ; return align > min_insn_size ? align - min_insn_size : <NUM_LIT> ;


<s> static void get_scratch_register_on_entry ( struct scratch_reg * sr , unsigned int regno1 , unsigned long live_regs ) { int regno = - <NUM_LIT> ; sr -> saved = false ; if ( regno1 != LR_REGNUM && ( live_regs & ( <NUM_LIT> << LR_REGNUM ) ) != <NUM_LIT> ) regno = LR_REGNUM ; else { unsigned int i ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( regno1 != i && ( live_regs & ( <NUM_LIT> << i ) ) != <NUM_LIT> ) { regno = i ; break ; } if ( regno < <NUM_LIT> ) { if ( regno1 == IP_REGNUM && IS_NESTED ( arm_current_func_type ( ) ) ) regno1 = <NUM_LIT> ; regno = ( regno1 == <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ) ; sr -> saved = REGNO_REG_SET_P ( df_get_live_out ( ENTRY_BLOCK_PTR_FOR_FN ( cfun ) ) , regno ) ; } } sr -> reg = gen_rtx_REG ( SImode , regno ) ; if ( sr -> saved ) { rtx addr = gen_rtx_PRE_DEC ( Pmode , stack_pointer_rtx ) ; rtx insn = emit_set_insn ( gen_frame_mem ( SImode , addr ) , sr -> reg ) ;

rtx x = gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - <NUM_LIT> ) ) ;


<s> if ( regno1 != LR_REGNUM && ( live_regs & ( <NUM_LIT> << LR_REGNUM ) ) != <NUM_LIT> ) regno = LR_REGNUM ; else { unsigned int i ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( regno1 != i && ( live_regs & ( <NUM_LIT> << i ) ) != <NUM_LIT> ) { regno = i ; break ; } if ( regno < <NUM_LIT> ) {


<s> static rtx get_tls_get_addr ( void ) { if ( ! tls_get_addr_libfunc ) tls_get_addr_libfunc = init_one_libfunc ( <STR_LIT> ) ;


<s> if ( ! tls_get_addr_libfunc ) tls_get_addr_libfunc = init_one_libfunc ( <STR_LIT> ) ;


<s> r = REAL_VALUE_ATOF ( <STR_LIT> , DFmode ) ; value_fp0 = r ; fp_consts_inited = true ;


<s> r = REAL_VALUE_ATOF ( <STR_LIT> , DFmode ) ; value_fp0 = r ;


<s> if ( GET_CODE ( pat ) == SET ) pat = SET_SRC ( pat ) ; pat = XEXP ( XEXP ( pat , <NUM_LIT> ) , <NUM_LIT> ) ; return REG_P ( pat ) ;


<s> const char * fmt ; int i ; if ( LABEL_REF_P ( x ) ) return <NUM_LIT> ; if ( GET_CODE ( x ) == UNSPEC && XINT ( x , <NUM_LIT> ) == UNSPEC_TLS ) return <NUM_LIT> ; fmt = GET_RTX_FORMAT ( GET_CODE ( x ) ) ; for ( i = GET_RTX_LENGTH ( GET_CODE ( x ) ) - <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) {


<s> fmt = GET_RTX_FORMAT ( GET_CODE ( x ) ) ; for ( i = GET_RTX_LENGTH ( GET_CODE ( x ) ) - <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) { if ( fmt [ i ] == 'E' ) { int j ; for ( j = XVECLEN ( x , i ) - <NUM_LIT> ; j >= <NUM_LIT> ; j -- ) if ( label_mentioned_p ( XVECEXP ( x , i , j ) ) ) return <NUM_LIT> ; } else if ( fmt [ i ] == 'e' && label_mentioned_p ( XEXP ( x , i ) ) ) return <NUM_LIT> ;


<s> int reg_increment ; int offset_adj ; int regs_per_val ; gcc_assert ( ( mode == SImode ) || consecutive ) ; gcc_assert ( ! return_pc || load ) ; reg_increment = GET_MODE_SIZE ( mode ) ; regs_per_val = reg_increment / <NUM_LIT> ; offset_adj = return_pc ? <NUM_LIT> : <NUM_LIT> ; if ( count <= <NUM_LIT> || GET_CODE ( XVECEXP ( op , <NUM_LIT> , offset_adj ) ) != SET || ( load && ! REG_P ( SET_DEST ( XVECEXP ( op , <NUM_LIT> , offset_adj ) ) ) ) ) return false ; elt = XVECEXP ( op , <NUM_LIT> , offset_adj ) ; if ( GET_CODE ( SET_SRC ( elt ) ) == PLUS ) { i ++ ; base = <NUM_LIT> ; update = true ; if ( ! REG_P ( SET_DEST ( elt ) ) || ! REG_P ( XEXP ( SET_SRC ( elt ) , <NUM_LIT> ) ) || ( REGNO ( SET_DEST ( elt ) ) != REGNO ( XEXP ( SET_SRC ( elt ) , <NUM_LIT> ) ) ) || ! CONST_INT_P ( XEXP ( SET_SRC ( elt ) , <NUM_LIT> ) ) || INTVAL ( XEXP ( SET_SRC ( elt ) , <NUM_LIT> ) ) != ( ( count - <NUM_LIT> - offset_adj ) * reg_increment ) ) return false ; } i = i + offset_adj ; base = base + offset_adj ; if ( ( count <= i ) && ( mode == SImode ) ) return false ; elt = XVECEXP ( op , <NUM_LIT> , i - <NUM_LIT> ) ;

if ( GET_CODE ( elt ) != SET ) return false ;


<s> reg_increment = GET_MODE_SIZE ( mode ) ; regs_per_val = reg_increment / <NUM_LIT> ; offset_adj = return_pc ? <NUM_LIT> : <NUM_LIT> ; if ( count <= <NUM_LIT> || GET_CODE ( XVECEXP ( op , <NUM_LIT> , offset_adj ) ) != SET || ( load && ! REG_P ( SET_DEST ( XVECEXP ( op , <NUM_LIT> , offset_adj ) ) ) ) ) return false ; elt = XVECEXP ( op , <NUM_LIT> , offset_adj ) ; if ( GET_CODE ( SET_SRC ( elt ) ) == PLUS ) { i ++ ; base = <NUM_LIT> ; update = true ; if ( ! REG_P ( SET_DEST ( elt ) ) || ! REG_P ( XEXP ( SET_SRC ( elt ) , <NUM_LIT> ) ) || ( REGNO ( SET_DEST ( elt ) ) != REGNO ( XEXP ( SET_SRC ( elt ) , <NUM_LIT> ) ) ) || ! CONST_INT_P ( XEXP ( SET_SRC ( elt ) , <NUM_LIT> ) ) || INTVAL ( XEXP ( SET_SRC ( elt ) , <NUM_LIT> ) ) != ( ( count - <NUM_LIT> - offset_adj ) * reg_increment ) ) return false ; } i = i + offset_adj ; base = base + offset_adj ; if ( ( count <= i ) && ( mode == SImode ) ) return false ; elt = XVECEXP ( op , <NUM_LIT> , i - <NUM_LIT> ) ; if ( GET_CODE ( elt ) != SET ) return false ; if ( load ) { reg = SET_DEST ( elt ) ; mem = SET_SRC ( elt ) ; } else { reg = SET_SRC ( elt ) ; mem = SET_DEST ( elt ) ; } if ( ! REG_P ( reg ) || ! MEM_P ( mem ) ) return false ;


<s> if ( SYMBOL_REF_P ( x ) || ( GET_CODE ( x ) == CONST && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF ) ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> if ( SYMBOL_REF_P ( x ) || ( GET_CODE ( x ) == CONST && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF ) ) return <NUM_LIT> ;


<s> gcc_assert ( compute_now == ( pic_reg != NULL_RTX ) ) ; if ( SYMBOL_REF_P ( orig ) || LABEL_REF_P ( orig ) ) { if ( reg == <NUM_LIT> ) { gcc_assert ( can_create_pseudo_p ( ) ) ; reg = gen_reg_rtx ( Pmode ) ; } rtx_insn * insn ; if ( ( LABEL_REF_P ( orig ) || ( SYMBOL_REF_P ( orig ) && SYMBOL_REF_LOCAL_P ( orig ) && ( SYMBOL_REF_DECL ( orig ) ? ! DECL_WEAK ( SYMBOL_REF_DECL ( orig ) ) : <NUM_LIT> ) && ( ! SYMBOL_REF_FUNCTION_P ( orig ) || arm_fdpic_local_funcdesc_p ( orig ) ) ) ) && NEED_GOT_RELOC && arm_pic_data_is_text_relative ) insn = arm_pic_static_addr ( orig , reg ) ; else { require_pic_register ( pic_reg , compute_now ) ; if ( pic_reg == NULL_RTX ) pic_reg = cfun -> machine -> pic_reg ; insn = calculate_pic_address_constant ( reg , pic_reg , orig ) ; } set_unique_reg_note ( insn , REG_EQUAL , orig ) ; return reg ; } else if ( GET_CODE ( orig ) == CONST ) { rtx base , offset ; if ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == PLUS && XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) == cfun -> machine -> pic_reg ) return orig ; if ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == UNSPEC && XINT ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) == UNSPEC_TLS ) return orig ; if ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) ) == UNSPEC && XINT ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) , <NUM_LIT> ) == UNSPEC_TLS ) { gcc_assert ( CONST_INT_P ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) ) ) ; return orig ; }


<s> if ( reg == <NUM_LIT> ) { gcc_assert ( can_create_pseudo_p ( ) ) ; reg = gen_reg_rtx ( Pmode ) ; } rtx_insn * insn ; if ( ( LABEL_REF_P ( orig ) || ( SYMBOL_REF_P ( orig ) && SYMBOL_REF_LOCAL_P ( orig ) && ( SYMBOL_REF_DECL ( orig ) ? ! DECL_WEAK ( SYMBOL_REF_DECL ( orig ) ) : <NUM_LIT> ) && ( ! SYMBOL_REF_FUNCTION_P ( orig ) || arm_fdpic_local_funcdesc_p ( orig ) ) ) ) && NEED_GOT_RELOC && arm_pic_data_is_text_relative ) insn = arm_pic_static_addr ( orig , reg ) ; else { require_pic_register ( pic_reg , compute_now ) ; if ( pic_reg == NULL_RTX ) pic_reg = cfun -> machine -> pic_reg ; insn = calculate_pic_address_constant ( reg , pic_reg , orig ) ; } set_unique_reg_note ( insn , REG_EQUAL , orig ) ; return reg ; } else if ( GET_CODE ( orig ) == CONST ) { rtx base , offset ; if ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == PLUS && XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) == cfun -> machine -> pic_reg ) return orig ; if ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == UNSPEC && XINT ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) == UNSPEC_TLS ) return orig ; if ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) ) == UNSPEC && XINT ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) , <NUM_LIT> ) == UNSPEC_TLS ) {

gcc_assert ( CONST_INT_P ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) ) ) ;


<s> gcc_assert ( ! TARGET_FDPIC ) ; reg = arm_tls_descseq_addr ( x , reg ) ; tp = arm_load_tp ( NULL_RTX ) ; dest = gen_rtx_PLUS ( Pmode , tp , reg ) ; } else { if ( TARGET_FDPIC ) insns = arm_call_tls_get_addr ( x , reg , & ret , TLS_LDM32_FDPIC ) ; else insns = arm_call_tls_get_addr ( x , reg , & ret , TLS_LDM32 ) ; eqv = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , const1_rtx ) , UNSPEC_TLS ) ; dest = gen_reg_rtx ( Pmode ) ; emit_libcall_block ( insns , dest , ret , eqv ) ; addend = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , x , GEN_INT ( TLS_LDO32 ) ) , UNSPEC_TLS ) ; addend = force_reg ( SImode , gen_rtx_CONST ( SImode , addend ) ) ; dest = gen_rtx_PLUS ( Pmode , dest , addend ) ; } return dest ; case TLS_MODEL_INITIAL_EXEC : if ( TARGET_FDPIC ) { sum = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , x , GEN_INT ( TLS_IE32_FDPIC ) ) , UNSPEC_TLS ) ; reg = load_tls_operand ( sum , reg ) ; emit_insn ( gen_addsi3 ( reg , reg , gen_rtx_REG ( Pmode , FDPIC_REGNUM ) ) ) ; emit_move_insn ( reg , gen_rtx_MEM ( Pmode , reg ) ) ; } else { labelno = GEN_INT ( pic_labelno ++ ) ; label = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , labelno ) , UNSPEC_PIC_LABEL ) ; label = gen_rtx_CONST ( VOIDmode , label ) ; sum = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , x , GEN_INT ( TLS_IE32 ) , label , GEN_INT ( TARGET_ARM ? <NUM_LIT> : <NUM_LIT> ) ) , UNSPEC_TLS ) ; reg = load_tls_operand ( sum , reg ) ; if ( TARGET_ARM ) emit_insn ( gen_tls_load_dot_plus_eight ( reg , reg , labelno ) ) ; else if ( TARGET_THUMB2 ) emit_insn ( gen_tls_load_dot_plus_four ( reg , NULL , reg , labelno ) ) ; else { emit_insn ( gen_pic_add_dot_plus_four ( reg , reg , labelno ) ) ; emit_move_insn ( reg , gen_const_mem ( SImode , reg ) ) ; } } tp = arm_load_tp ( NULL_RTX ) ; return gen_rtx_PLUS ( Pmode , tp , reg ) ; case TLS_MODEL_LOCAL_EXEC : tp = arm_load_tp ( NULL_RTX ) ;

reg = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , x , GEN_INT ( TLS_LE32 ) ) , UNSPEC_TLS ) ;


<s> memset ( order , <NUM_LIT> , MAX_LDM_STM_OPS * sizeof ( int ) ) ; for ( i = <NUM_LIT> ; i < nops ; i ++ ) { rtx reg ; rtx offset ; if ( GET_CODE ( operands [ nops + i ] ) == SUBREG ) operands [ nops + i ] = alter_subreg ( operands + ( nops + i ) , true ) ; gcc_assert ( MEM_P ( operands [ nops + i ] ) ) ; if ( MEM_VOLATILE_P ( operands [ nops + i ] ) ) return <NUM_LIT> ; offset = const0_rtx ; if ( ( REG_P ( reg = XEXP ( operands [ nops + i ] , <NUM_LIT> ) ) || ( SUBREG_P ( reg ) && REG_P ( reg = SUBREG_REG ( reg ) ) ) ) || ( GET_CODE ( XEXP ( operands [ nops + i ] , <NUM_LIT> ) ) == PLUS && ( ( REG_P ( reg = XEXP ( XEXP ( operands [ nops + i ] , <NUM_LIT> ) , <NUM_LIT> ) ) ) || ( SUBREG_P ( reg ) && REG_P ( reg = SUBREG_REG ( reg ) ) ) ) && ( CONST_INT_P ( offset = XEXP ( XEXP ( operands [ nops + i ] , <NUM_LIT> ) , <NUM_LIT> ) ) ) ) ) { if ( i == <NUM_LIT> ) { base_reg = REGNO ( reg ) ; if ( TARGET_THUMB1 && base_reg > LAST_LO_REGNUM ) return <NUM_LIT> ;


<s> if ( reg == NULL_RTX ) reg = gen_reg_rtx ( SImode ) ; tmp = gen_rtx_CONST ( SImode , x ) ; emit_move_insn ( reg , tmp ) ; return reg ;


<s> * align = MEM_ALIGN ( mem ) ; addr = XEXP ( mem , <NUM_LIT> ) ; if ( ! arm_legitimate_address_p ( DImode , addr , reload_in_progress || reload_completed ) ) return false ; if ( REG_P ( addr ) ) { * base = addr ; return true ; } else if ( GET_CODE ( addr ) == PLUS ) { * base = XEXP ( addr , <NUM_LIT> ) ; * offset = XEXP ( addr , <NUM_LIT> ) ; return ( REG_P ( * base ) && CONST_INT_P ( * offset ) ) ; } return false ;


<s> enum rtx_code minmax_code ( rtx x ) { enum rtx_code code = GET_CODE ( x ) ; switch ( code ) { case SMAX : return GE ; case SMIN : return LE ; case UMIN : return LEU ; case UMAX :


<s> gcc_assert ( mp != min_mp ) ; if ( min_mp == NULL ) { if ( min_address > mp -> min_address ) mp -> min_address = min_address ; } else { mp -> min_address = min_address ; mp -> next -> prev = mp -> prev ; if ( mp -> prev != NULL ) mp -> prev -> next = mp -> next ; else minipool_vector_head = mp -> next ; mp -> prev = min_mp ; mp -> next = min_mp -> next ; min_mp -> next = mp ; if ( mp -> next != NULL ) mp -> next -> prev = mp ; else minipool_vector_tail = mp ;