<s> mode = GET_MODE ( reg ) ; gcc_assert ( REG_P ( reg ) ) ; gcc_assert ( IS_VFP_REGNUM ( REGNO ( reg ) ) ) ; gcc_assert ( mode == SFmode || mode == DFmode || mode == SImode || mode == DImode || ( TARGET_NEON && VALID_NEON_DREG_MODE ( mode ) ) ) ; gcc_assert ( MEM_P ( mem ) ) ; addr = XEXP ( mem , <NUM_LIT> ) ; switch ( GET_CODE ( addr ) ) { case PRE_DEC : templ = <STR_LIT> ; ops [ <NUM_LIT> ] = XEXP ( addr , <NUM_LIT> ) ; ops [ <NUM_LIT> ] = reg ; break ; case POST_INC : templ = <STR_LIT> ; ops [ <NUM_LIT> ] = XEXP ( addr , <NUM_LIT> ) ; ops [ <NUM_LIT> ] = reg ; break ; default : templ = <STR_LIT> ; ops [ <NUM_LIT> ] = reg ; ops [ <NUM_LIT> ] = mem ; break ; } sprintf ( buff , templ , load ? <STR_LIT> : <STR_LIT> , dp ? <STR_LIT> : <STR_LIT> , dp ? <STR_LIT> : <STR_LIT> , integer_p ? <STR_LIT> : <STR_LIT> ) ; output_asm_insn ( buff , ops ) ;


<s> addr = XEXP ( mem , <NUM_LIT> ) ; switch ( GET_CODE ( addr ) ) { case PRE_DEC : templ = <STR_LIT> ; ops [ <NUM_LIT> ] = XEXP ( addr , <NUM_LIT> ) ; ops [ <NUM_LIT> ] = reg ; break ; case POST_INC : templ = <STR_LIT> ; ops [ <NUM_LIT> ] = XEXP ( addr , <NUM_LIT> ) ; ops [ <NUM_LIT> ] = reg ; break ; default : templ = <STR_LIT> ; ops [ <NUM_LIT> ] = reg ; ops [ <NUM_LIT> ] = mem ; break ;


<s> fix -> minipool = NULL ; gcc_assert ( fix -> forwards || fix -> backwards ) ; if ( ARM_DOUBLEWORD_ALIGN && fix -> fix_size >= <NUM_LIT> ) minipool_pad = <NUM_LIT> ; if ( dump_file ) { fprintf ( dump_file , <STR_LIT> , GET_MODE_NAME ( mode ) , INSN_UID ( insn ) , ( unsigned long ) address , - <NUM_LIT> * ( long ) fix -> backwards , ( long ) fix -> forwards ) ; arm_print_value ( dump_file , fix -> value ) ; fprintf ( dump_file , <STR_LIT> ) ; } fix -> next = NULL ; if ( minipool_fix_head != NULL ) minipool_fix_tail -> next = fix ; else minipool_fix_head = fix ;


<s> rtx_insn * seq , * insn ; if ( ! cfun -> machine -> pic_reg ) cfun -> machine -> pic_reg = gen_reg_rtx ( Pmode ) ; if ( current_ir_type ( ) != IR_GIMPLE || currently_expanding_to_rtl ) { crtl -> uses_pic_offset_table = <NUM_LIT> ; start_sequence ( ) ; if ( TARGET_THUMB1 && arm_pic_register != INVALID_REGNUM && arm_pic_register > LAST_LO_REGNUM ) emit_move_insn ( cfun -> machine -> pic_reg , gen_rtx_REG ( Pmode , arm_pic_register ) ) ; else arm_load_pic_register ( <NUM_LIT> ) ; seq = get_insns ( ) ; end_sequence ( ) ; for ( insn = seq ; insn ; insn = NEXT_INSN ( insn ) ) if ( INSN_P ( insn ) ) INSN_LOCATION ( insn ) = prologue_location ;

insert_insn_on_edge ( seq , single_succ_edge ( ENTRY_BLOCK_PTR_FOR_FN ( cfun ) ) ) ;


<s> code = ROTATERT ; * amountp = <NUM_LIT> - INTVAL ( XEXP ( op , <NUM_LIT> ) ) ; mnem = <STR_LIT> ; break ; case ASHIFT : case ASHIFTRT : case LSHIFTRT : case ROTATERT : mnem = arm_shift_nmem ( code ) ; if ( CONST_INT_P ( XEXP ( op , <NUM_LIT> ) ) ) { * amountp = INTVAL ( XEXP ( op , <NUM_LIT> ) ) ; } else if ( REG_P ( XEXP ( op , <NUM_LIT> ) ) ) { * amountp = - <NUM_LIT> ; return mnem ; } else { output_operand_lossage ( <STR_LIT> ) ; return NULL ; } break ; case MULT : if ( ! CONST_INT_P ( XEXP ( op , <NUM_LIT> ) ) ) { output_operand_lossage ( <STR_LIT> ) ; return NULL ; } * amountp = INTVAL ( XEXP ( op , <NUM_LIT> ) ) & <NUM_LIT> ; if ( * amountp & ( * amountp - <NUM_LIT> ) ) { output_operand_lossage ( <STR_LIT> ) ; return NULL ; }


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

if ( callee_saved_reg_p ( reg ) ) mask |= <NUM_LIT> << reg ;


<s> tmp = gen_rtx_PRE_MODIFY ( Pmode , stack_pointer_rtx , tmp ) ; tmp = gen_frame_mem ( BLKmode , tmp ) ; tmp = gen_rtx_SET ( VOIDmode , tmp , par [ <NUM_LIT> ] ) ; par [ <NUM_LIT> ] = tmp ; tmp = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec_v ( i , par ) ) ; insn = emit_insn ( tmp ) ; tmp = plus_constant ( Pmode , stack_pointer_rtx , - <NUM_LIT> * i ) ; tmp = gen_rtx_SET ( VOIDmode , stack_pointer_rtx , tmp ) ; par [ <NUM_LIT> ] = tmp ; for ( j = <NUM_LIT> ; real_regs ; ++ j , real_regs &= real_regs - <NUM_LIT> ) { regno = ctz_hwi ( real_regs ) ; reg = gen_rtx_REG ( SImode , regno ) ; tmp = plus_constant ( Pmode , stack_pointer_rtx , j * <NUM_LIT> ) ; tmp = gen_frame_mem ( SImode , tmp ) ;

tmp = gen_rtx_SET ( VOIDmode , tmp , reg ) ;


<s> tmp = plus_constant ( Pmode , stack_pointer_rtx , - <NUM_LIT> * i ) ; tmp = gen_rtx_PRE_MODIFY ( Pmode , stack_pointer_rtx , tmp ) ; tmp = gen_frame_mem ( BLKmode , tmp ) ; tmp = gen_rtx_SET ( VOIDmode , tmp , par [ <NUM_LIT> ] ) ; par [ <NUM_LIT> ] = tmp ; tmp = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec_v ( i , par ) ) ; insn = emit_insn ( tmp ) ; tmp = plus_constant ( Pmode , stack_pointer_rtx , - <NUM_LIT> * i ) ; tmp = gen_rtx_SET ( VOIDmode , stack_pointer_rtx , tmp ) ; par [ <NUM_LIT> ] = tmp ; for ( j = <NUM_LIT> ; real_regs ; ++ j , real_regs &= real_regs - <NUM_LIT> ) { regno = ctz_hwi ( real_regs ) ; reg = gen_rtx_REG ( SImode , regno ) ; tmp = plus_constant ( Pmode , stack_pointer_rtx , j * <NUM_LIT> ) ; tmp = gen_frame_mem ( SImode , tmp ) ; tmp = gen_rtx_SET ( VOIDmode , tmp , reg ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; par [ j + <NUM_LIT> ] = tmp ; } if ( j == <NUM_LIT> ) tmp = par [ <NUM_LIT> ] ; else { RTX_FRAME_RELATED_P ( par [ <NUM_LIT> ] ) = <NUM_LIT> ;

tmp = gen_rtx_SEQUENCE ( VOIDmode , gen_rtvec_v ( j + <NUM_LIT> , par ) ) ;


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


<s> int num_pushes = ARM_NUM_INTS ( crtl -> args . pretend_args_size ) ; unsigned long mask ; mask = <NUM_LIT> << ( LAST_ARG_REGNUM + <NUM_LIT> ) ; mask -= <NUM_LIT> << ( LAST_ARG_REGNUM + <NUM_LIT> - num_pushes ) ; insn = thumb1_emit_multi_reg_push ( mask , <NUM_LIT> ) ; } else { insn = emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , x ) ) ; } RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } if ( TARGET_BACKTRACE ) { HOST_WIDE_INT offset = <NUM_LIT> ; unsigned work_register ; rtx work_reg , x , arm_hfp_rtx ; work_register = thumb_find_work_register ( live_regs_mask ) ; work_reg = gen_rtx_REG ( SImode , work_register ) ; arm_hfp_rtx = gen_rtx_REG ( SImode , ARM_HARD_FRAME_POINTER_REGNUM ) ; insn = emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - <NUM_LIT> ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; if ( l_mask ) { insn = thumb1_emit_multi_reg_push ( l_mask , l_mask ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; offset = bit_count ( l_mask ) * UNITS_PER_WORD ; } x = GEN_INT ( offset + <NUM_LIT> + crtl -> args . pretend_args_size ) ; emit_insn ( gen_addsi3 ( work_reg , stack_pointer_rtx , x ) ) ; x = plus_constant ( Pmode , stack_pointer_rtx , offset + <NUM_LIT> ) ; x = gen_frame_mem ( SImode , x ) ; emit_move_insn ( x , work_reg ) ; if ( l_mask ) { x = gen_rtx_REG ( SImode , PC_REGNUM ) ; emit_move_insn ( work_reg , x ) ; x = plus_constant ( Pmode , stack_pointer_rtx , offset + <NUM_LIT> ) ; x = gen_frame_mem ( SImode , x ) ; emit_move_insn ( x , work_reg ) ; emit_move_insn ( work_reg , arm_hfp_rtx ) ; x = plus_constant ( Pmode , stack_pointer_rtx , offset ) ; x = gen_frame_mem ( SImode , x ) ; emit_move_insn ( x , work_reg ) ; } else { emit_move_insn ( work_reg , arm_hfp_rtx ) ; x = plus_constant ( Pmode , stack_pointer_rtx , offset ) ; x = gen_frame_mem ( SImode , x ) ; emit_move_insn ( x , work_reg ) ; x = gen_rtx_REG ( SImode , PC_REGNUM ) ; emit_move_insn ( work_reg , x ) ; x = plus_constant ( Pmode , stack_pointer_rtx , offset + <NUM_LIT> ) ; x = gen_frame_mem ( SImode , x ) ; emit_move_insn ( x , work_reg ) ; }

x = gen_rtx_REG ( SImode , LR_REGNUM ) ;


<s> if ( ! optimize_size && amount != <NUM_LIT> ) return <NUM_LIT> ; if ( high_regs_pushed != <NUM_LIT> ) return <NUM_LIT> ; if ( l_mask == <NUM_LIT> && ( for_prologue || TARGET_BACKTRACE || ( live_regs_mask & <NUM_LIT> << LR_REGNUM ) == <NUM_LIT> || TARGET_INTERWORK || crtl -> args . pretend_args_size != <NUM_LIT> ) ) return <NUM_LIT> ; if ( for_prologue && ( ( flag_pic && arm_pic_register != INVALID_REGNUM ) || ( ! frame_pointer_needed && CALLER_INTERWORKING_SLOT_SIZE > <NUM_LIT> ) ) ) return <NUM_LIT> ; reg_base = <NUM_LIT> ; n_free = <NUM_LIT> ; if ( ! for_prologue ) { size = arm_size_return_regs ( ) ; reg_base = ARM_NUM_INTS ( size ) ; live_regs_mask >>= reg_base ; } while ( reg_base + n_free < <NUM_LIT> && ! ( live_regs_mask & <NUM_LIT> ) && ( for_prologue || call_used_regs [ reg_base + n_free ] ) ) { live_regs_mask >>= <NUM_LIT> ; n_free ++ ; } if ( n_free == <NUM_LIT> ) return <NUM_LIT> ; gcc_assert ( amount / <NUM_LIT> * <NUM_LIT> == amount ) ; if ( amount >= <NUM_LIT> && ( amount - n_free * <NUM_LIT> ) < <NUM_LIT> ) return ( amount - <NUM_LIT> ) / <NUM_LIT> ;

if ( amount <= n_free * <NUM_LIT> ) return amount / <NUM_LIT> ;


<s> cfun -> machine -> thumb1_cc_mode = CC_NOOVmode ; if ( INSN_CODE ( insn ) == CODE_FOR_thumb1_subsi3_insn ) { rtx src1 = XEXP ( SET_SRC ( set ) , <NUM_LIT> ) ; if ( src1 == const0_rtx ) cfun -> machine -> thumb1_cc_mode = CCmode ; } else if ( REG_P ( SET_DEST ( set ) ) && REG_P ( SET_SRC ( set ) ) ) { cfun -> machine -> thumb1_cc_op0 = SET_SRC ( set ) ; } }

else if ( conds != CONDS_NOCOND ) cfun -> machine -> thumb1_cc_insn = NULL_RTX ;


<s> else if ( REG_P ( XEXP ( x , <NUM_LIT> ) ) && REGNO ( XEXP ( x , <NUM_LIT> ) ) == STACK_POINTER_REGNUM && GET_MODE_SIZE ( mode ) >= <NUM_LIT> && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) && INTVAL ( XEXP ( x , <NUM_LIT> ) ) >= <NUM_LIT> && INTVAL ( XEXP ( x , <NUM_LIT> ) ) + GET_MODE_SIZE ( mode ) <= <NUM_LIT> && ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) & <NUM_LIT> ) == <NUM_LIT> ) return <NUM_LIT> ; else if ( REG_P ( XEXP ( x , <NUM_LIT> ) ) && ( REGNO ( XEXP ( x , <NUM_LIT> ) ) == FRAME_POINTER_REGNUM || REGNO ( XEXP ( x , <NUM_LIT> ) ) == ARG_POINTER_REGNUM || ( REGNO ( XEXP ( x , <NUM_LIT> ) ) >= FIRST_VIRTUAL_REGISTER && REGNO ( XEXP ( x , <NUM_LIT> ) ) <= LAST_VIRTUAL_POINTER_REGISTER ) ) && GET_MODE_SIZE ( mode ) >= <NUM_LIT> && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) && ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) & <NUM_LIT> ) == <NUM_LIT> ) return <NUM_LIT> ; }

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


<s> case HImode : return ( ADDR_DIFF_VEC_FLAGS ( diff_vec ) . offset_unsigned ? <STR_LIT> : <STR_LIT> ) ; case SImode : return <STR_LIT> ; default : gcc_unreachable ( ) ; }


<s> FOR_EACH_BB_FN ( bb , cfun ) { rtx dest , src ; rtx pat , op0 , set = NULL ; rtx_insn * prev , * insn = BB_END ( bb ) ; bool insn_clobbered = false ; while ( insn != BB_HEAD ( bb ) && ! NONDEBUG_INSN_P ( insn ) ) insn = PREV_INSN ( insn ) ; if ( insn == BB_HEAD ( bb ) || INSN_CODE ( insn ) != CODE_FOR_cbranchsi4_insn ) continue ; pat = PATTERN ( insn ) ; op0 = XEXP ( XEXP ( SET_SRC ( pat ) , <NUM_LIT> ) , <NUM_LIT> ) ; gcc_assert ( insn != BB_HEAD ( bb ) ) ; for ( prev = PREV_INSN ( insn ) ; ( ! insn_clobbered && prev != BB_HEAD ( bb ) && ( NOTE_P ( prev ) || DEBUG_INSN_P ( prev ) || ( ( set = single_set ( prev ) ) != NULL && get_attr_conds ( prev ) == CONDS_NOCOND ) ) ) ; prev = PREV_INSN ( prev ) ) { if ( reg_set_p ( op0 , prev ) ) insn_clobbered = true ; } if ( insn_clobbered ) continue ; if ( ! set ) continue ; dest = SET_DEST ( set ) ; src = SET_SRC ( set ) ; if ( ! low_register_operand ( dest , SImode ) || ! low_register_operand ( src , SImode ) ) continue ; if ( REGNO ( op0 ) == REGNO ( src ) || REGNO ( op0 ) == REGNO ( dest ) ) { dest = copy_rtx ( dest ) ; src = copy_rtx ( src ) ; src = gen_rtx_MINUS ( SImode , src , const0_rtx ) ;

PATTERN ( prev ) = gen_rtx_SET ( VOIDmode , dest , src ) ;


<s> while ( insn != BB_HEAD ( bb ) && ! NONDEBUG_INSN_P ( insn ) ) insn = PREV_INSN ( insn ) ; if ( insn == BB_HEAD ( bb ) || INSN_CODE ( insn ) != CODE_FOR_cbranchsi4_insn ) continue ; pat = PATTERN ( insn ) ; op0 = XEXP ( XEXP ( SET_SRC ( pat ) , <NUM_LIT> ) , <NUM_LIT> ) ; gcc_assert ( insn != BB_HEAD ( bb ) ) ; for ( prev = PREV_INSN ( insn ) ; ( ! insn_clobbered && prev != BB_HEAD ( bb ) && ( NOTE_P ( prev ) || DEBUG_INSN_P ( prev ) || ( ( set = single_set ( prev ) ) != NULL && get_attr_conds ( prev ) == CONDS_NOCOND ) ) ) ; prev = PREV_INSN ( prev ) ) { if ( reg_set_p ( op0 , prev ) ) insn_clobbered = true ; } if ( insn_clobbered ) continue ; if ( ! set ) continue ; dest = SET_DEST ( set ) ; src = SET_SRC ( set ) ; if ( ! low_register_operand ( dest , SImode ) || ! low_register_operand ( src , SImode ) ) continue ; if ( REGNO ( op0 ) == REGNO ( src ) || REGNO ( op0 ) == REGNO ( dest ) ) { dest = copy_rtx ( dest ) ; src = copy_rtx ( src ) ; src = gen_rtx_MINUS ( SImode , src , const0_rtx ) ; PATTERN ( prev ) = gen_rtx_SET ( VOIDmode , dest , src ) ; INSN_CODE ( prev ) = - <NUM_LIT> ; XEXP ( XEXP ( SET_SRC ( pat ) , <NUM_LIT> ) , <NUM_LIT> ) = copy_rtx ( dest ) ; INSN_CODE ( insn ) = - <NUM_LIT> ; } }


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


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

if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PC || GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PC ) return <NUM_LIT> ;


<s> case ROTATERT : return ( mode == SImode ) ? COSTS_N_INSNS ( <NUM_LIT> ) : COSTS_N_INSNS ( <NUM_LIT> ) ; case PLUS : case MINUS : if ( ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == MULT && power_of_two_operand ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) , SImode ) ) || ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == MULT && power_of_two_operand ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) , SImode ) ) ) return COSTS_N_INSNS ( <NUM_LIT> ) ; case COMPARE : case NEG : case NOT : return COSTS_N_INSNS ( <NUM_LIT> ) ; case MULT : if ( CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) ) { int const_size = thumb1_size_rtx_costs ( XEXP ( x , <NUM_LIT> ) , CONST_INT , SET ) ; if ( arm_arch6m && arm_m_profile_small_mul ) return COSTS_N_INSNS ( <NUM_LIT> ) ; else return COSTS_N_INSNS ( <NUM_LIT> ) + const_size ; } return COSTS_N_INSNS ( <NUM_LIT> ) ; case SET : words = ARM_NUM_INTS ( GET_MODE_SIZE ( GET_MODE ( SET_DEST ( x ) ) ) ) ; return COSTS_N_INSNS ( words ) + COSTS_N_INSNS ( <NUM_LIT> ) * ( satisfies_constraint_J ( SET_SRC ( x ) ) || satisfies_constraint_K ( SET_SRC ( x ) ) || ( ( words > <NUM_LIT> ) && MEM_P ( SET_SRC ( x ) ) ) ) ; case CONST_INT : if ( outer == SET ) { if ( ( unsigned HOST_WIDE_INT ) INTVAL ( x ) < <NUM_LIT> ) return COSTS_N_INSNS ( <NUM_LIT> ) ; if ( INTVAL ( x ) >= - <NUM_LIT> && INTVAL ( x ) <= - <NUM_LIT> ) return COSTS_N_INSNS ( <NUM_LIT> ) ; if ( thumb_shiftable_const ( INTVAL ( x ) ) ) return COSTS_N_INSNS ( <NUM_LIT> ) ; return COSTS_N_INSNS ( <NUM_LIT> ) ; } else if ( ( outer == PLUS || outer == COMPARE ) && INTVAL ( x ) < <NUM_LIT> && INTVAL ( x ) > - <NUM_LIT> ) return <NUM_LIT> ; else if ( ( outer == IOR || outer == XOR || outer == AND ) && INTVAL ( x ) < <NUM_LIT> && INTVAL ( x ) >= - <NUM_LIT> ) return COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( outer == AND ) { int i ; for ( i = <NUM_LIT> ; i <= <NUM_LIT> ; i ++ ) if ( ( ( ( HOST_WIDE_INT ) <NUM_LIT> ) << i ) - <NUM_LIT> == INTVAL ( x ) || ( ( ( HOST_WIDE_INT ) <NUM_LIT> ) << i ) - <NUM_LIT> == ~ INTVAL ( x ) ) return COSTS_N_INSNS ( <NUM_LIT> ) ; } else if ( outer == ASHIFT || outer == ASHIFTRT || outer == LSHIFTRT ) return <NUM_LIT> ; return COSTS_N_INSNS ( <NUM_LIT> ) ; case CONST : case CONST_DOUBLE : case LABEL_REF : case SYMBOL_REF : return COSTS_N_INSNS ( <NUM_LIT> ) ; case UDIV : case UMOD : case DIV : case MOD : return <NUM_LIT> ;


<s> if ( extra_pop > <NUM_LIT> ) { unsigned long extra_mask = ( <NUM_LIT> << extra_pop ) - <NUM_LIT> ; live_regs_mask |= extra_mask << ARM_NUM_INTS ( size ) ; } if ( high_regs_pushed ) { unsigned long mask = live_regs_mask & <NUM_LIT> ; int next_hi_reg ; if ( size <= <NUM_LIT> ) mask |= <NUM_LIT> << <NUM_LIT> ; if ( size <= <NUM_LIT> ) mask |= <NUM_LIT> << <NUM_LIT> ; if ( mask == <NUM_LIT> ) internal_error ( <STR_LIT> ) ; for ( next_hi_reg = <NUM_LIT> ; next_hi_reg < <NUM_LIT> ; next_hi_reg ++ ) if ( live_regs_mask & ( <NUM_LIT> << next_hi_reg ) ) break ; while ( high_regs_pushed ) { for ( regno = <NUM_LIT> ; regno <= LAST_LO_REGNUM ; regno ++ ) { if ( mask & ( <NUM_LIT> << regno ) ) high_regs_pushed -- ; if ( high_regs_pushed == <NUM_LIT> ) break ; } mask &= ( <NUM_LIT> << regno ) - <NUM_LIT> ; thumb_pop ( asm_out_file , mask ) ; for ( regno = <NUM_LIT> ; regno <= LAST_LO_REGNUM ; regno ++ ) { if ( mask & ( <NUM_LIT> << regno ) ) { asm_fprintf ( asm_out_file , <STR_LIT> , next_hi_reg , regno ) ; for ( next_hi_reg ++ ; next_hi_reg < <NUM_LIT> ; next_hi_reg ++ ) if ( live_regs_mask & ( <NUM_LIT> << next_hi_reg ) ) break ; } } } live_regs_mask &= ~ <NUM_LIT> ; } had_to_push_lr = ( live_regs_mask & ( <NUM_LIT> << LR_REGNUM ) ) != <NUM_LIT> ; live_regs_mask &= <NUM_LIT> ; if ( crtl -> args . pretend_args_size == <NUM_LIT> || TARGET_BACKTRACE ) { if ( had_to_push_lr ) live_regs_mask |= <NUM_LIT> << PC_REGNUM ; if ( live_regs_mask ) thumb_pop ( asm_out_file , live_regs_mask ) ; if ( ! had_to_push_lr ) thumb_exit ( asm_out_file , LR_REGNUM ) ; } else { if ( live_regs_mask ) thumb_pop ( asm_out_file , live_regs_mask ) ; if ( had_to_push_lr ) { if ( size > <NUM_LIT> ) { asm_fprintf ( asm_out_file , <STR_LIT> , IP_REGNUM , LAST_ARG_REGNUM ) ; } thumb_pop ( asm_out_file , <NUM_LIT> << LAST_ARG_REGNUM ) ; if ( size > <NUM_LIT> ) { asm_fprintf ( asm_out_file , <STR_LIT> , LR_REGNUM , LAST_ARG_REGNUM ) ; asm_fprintf ( asm_out_file , <STR_LIT> , LAST_ARG_REGNUM , IP_REGNUM ) ; regno = LR_REGNUM ; } else regno = LAST_ARG_REGNUM ; }


<s> if ( ( i % <NUM_LIT> ) == <NUM_LIT> ) { par = emit_insn ( par ) ; REG_NOTES ( par ) = dwarf ; RTX_FRAME_RELATED_P ( par ) = <NUM_LIT> ; } i ++ ; } tmp = gen_rtx_SET ( VOIDmode , stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> * i ) ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; tmp = emit_insn ( tmp ) ; if ( ! return_in_pc ) { arm_add_cfa_adjust_cfa_note ( tmp , UNITS_PER_WORD * i , stack_pointer_rtx , stack_pointer_rtx ) ; } dwarf = NULL_RTX ; if ( ( ( num_regs % <NUM_LIT> ) == <NUM_LIT> && ! return_in_pc ) || ( ( num_regs % <NUM_LIT> ) == <NUM_LIT> && return_in_pc ) ) { for ( ; ( saved_regs_mask & ( <NUM_LIT> << j ) ) == <NUM_LIT> ; j ++ ) ; tmp1 = gen_rtx_MEM ( SImode , gen_rtx_POST_INC ( SImode , stack_pointer_rtx ) ) ; set_mem_alias_set ( tmp1 , get_frame_alias_set ( ) ) ; reg = gen_rtx_REG ( SImode , j ) ; tmp = gen_rtx_SET ( SImode , reg , tmp1 ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; dwarf = alloc_reg_note ( REG_CFA_RESTORE , reg , dwarf ) ; if ( return_in_pc ) { gcc_assert ( j == PC_REGNUM ) ; par = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( <NUM_LIT> ) ) ; XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = ret_rtx ; XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = tmp ; par = emit_jump_insn ( par ) ; } else { par = emit_insn ( tmp ) ; REG_NOTES ( par ) = dwarf ; arm_add_cfa_adjust_cfa_note ( par , UNITS_PER_WORD , stack_pointer_rtx , stack_pointer_rtx ) ; } } else if ( ( num_regs % <NUM_LIT> ) == <NUM_LIT> && return_in_pc ) { arm_emit_multi_reg_pop ( saved_regs_mask & ( ~ ( ( <NUM_LIT> << j ) - <NUM_LIT> ) ) ) ;


<s> int regno2 ; for ( regno2 = regno + <NUM_LIT> ; ( saved_regs_mask & ( <NUM_LIT> << regno2 ) ) == <NUM_LIT> ; regno2 ++ ) ; reg1 = gen_rtx_REG ( SImode , regno ) ; reg2 = gen_rtx_REG ( SImode , regno2 ) ; if ( first ) { rtx insn ; first = false ; mem1 = gen_frame_mem ( Pmode , plus_constant ( Pmode , stack_pointer_rtx , - <NUM_LIT> * num_regs ) ) ; mem2 = gen_frame_mem ( Pmode , plus_constant ( Pmode , stack_pointer_rtx , - <NUM_LIT> * ( num_regs - <NUM_LIT> ) ) ) ; tmp0 = gen_rtx_SET ( VOIDmode , stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - <NUM_LIT> * ( num_regs ) ) ) ; tmp1 = gen_rtx_SET ( VOIDmode , mem1 , reg1 ) ; tmp2 = gen_rtx_SET ( VOIDmode , mem2 , reg2 ) ; RTX_FRAME_RELATED_P ( tmp0 ) = <NUM_LIT> ; RTX_FRAME_RELATED_P ( tmp1 ) = <NUM_LIT> ; RTX_FRAME_RELATED_P ( tmp2 ) = <NUM_LIT> ; par = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( <NUM_LIT> ) ) ; XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = tmp0 ; XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = tmp1 ; XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = tmp2 ; insn = emit_insn ( par ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; add_reg_note ( insn , REG_FRAME_RELATED_EXPR , dwarf ) ; } else { mem1 = gen_frame_mem ( Pmode , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> * i ) ) ; mem2 = gen_frame_mem ( Pmode , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> * ( i + <NUM_LIT> ) ) ) ; tmp1 = gen_rtx_SET ( VOIDmode , mem1 , reg1 ) ; tmp2 = gen_rtx_SET ( VOIDmode , mem2 , reg2 ) ; RTX_FRAME_RELATED_P ( tmp1 ) = <NUM_LIT> ; RTX_FRAME_RELATED_P ( tmp2 ) = <NUM_LIT> ; par = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( <NUM_LIT> ) ) ; XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = tmp1 ; XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = tmp2 ; emit_insn ( par ) ; } tmp1 = gen_rtx_SET ( VOIDmode , gen_frame_mem ( Pmode , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> * i ) ) , reg1 ) ; tmp2 = gen_rtx_SET ( VOIDmode , gen_frame_mem ( Pmode , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> * ( i + <NUM_LIT> ) ) ) , reg2 ) ; RTX_FRAME_RELATED_P ( tmp1 ) = <NUM_LIT> ;


<s> for ( i = <NUM_LIT> , num_regs = <NUM_LIT> ; i <= LAST_ARM_REGNUM ; i ++ ) if ( saved_regs_mask & ( <NUM_LIT> << i ) ) num_regs ++ ; if ( ! simple_return && saved_regs_mask ) { if ( num_regs == <NUM_LIT> ) { rtx par = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( <NUM_LIT> ) ) ; rtx reg = gen_rtx_REG ( SImode , PC_REGNUM ) ; rtx addr = gen_rtx_MEM ( SImode , gen_rtx_POST_INC ( SImode , stack_pointer_rtx ) ) ; set_mem_alias_set ( addr , get_frame_alias_set ( ) ) ; XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = ret_rtx ; XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_SET ( SImode , reg , addr ) ; RTX_FRAME_RELATED_P ( XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) ) = <NUM_LIT> ; emit_jump_insn ( par ) ; }


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


<s> if ( ! CONST_INT_P ( addend ) ) return <NUM_LIT> ; offset = INTVAL ( addend ) ; if ( GET_MODE_SIZE ( mode ) <= <NUM_LIT> ) return ( offset > - <NUM_LIT> && offset < <NUM_LIT> ) ; return ( use_ldrd && offset > - <NUM_LIT> && offset < <NUM_LIT> && ( offset & <NUM_LIT> ) == <NUM_LIT> ) ; } else if ( reload_completed && ( code == LABEL_REF || ( code == CONST && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == LABEL_REF && CONST_INT_P ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) ) ) ) return <NUM_LIT> ; else if ( mode == TImode || ( TARGET_NEON && VALID_NEON_STRUCT_MODE ( mode ) ) ) return <NUM_LIT> ; else if ( code == PLUS ) {


<s> if ( ! TARGET_LDRD || mode != DImode ) return ( code == CONST_INT && INTVAL ( index ) < <NUM_LIT> && INTVAL ( index ) > - <NUM_LIT> && ( INTVAL ( index ) & <NUM_LIT> ) == <NUM_LIT> ) ; } if ( TARGET_NEON && VALID_NEON_QREG_MODE ( mode ) ) return ( code == CONST_INT && INTVAL ( index ) < <NUM_LIT> && INTVAL ( index ) > - <NUM_LIT> && ( INTVAL ( index ) & <NUM_LIT> ) == <NUM_LIT> ) ; if ( TARGET_NEON && VALID_NEON_DREG_MODE ( mode ) ) return ( code == CONST_INT && INTVAL ( index ) < <NUM_LIT> && INTVAL ( index ) > - <NUM_LIT> && ( INTVAL ( index ) & <NUM_LIT> ) == <NUM_LIT> ) ; if ( arm_address_register_rtx_p ( index , strict_p ) && ( GET_MODE_SIZE ( mode ) <= <NUM_LIT> ) ) return <NUM_LIT> ; if ( mode == DImode || mode == DFmode ) { if ( code == CONST_INT ) { HOST_WIDE_INT val = INTVAL ( index ) ; return val > - <NUM_LIT> && val < <NUM_LIT> && ( val & <NUM_LIT> ) == <NUM_LIT> ; } else return <NUM_LIT> ; } if ( code == MULT ) { rtx xiop0 = XEXP ( index , <NUM_LIT> ) ; rtx xiop1 = XEXP ( index , <NUM_LIT> ) ; return ( ( arm_address_register_rtx_p ( xiop0 , strict_p ) && thumb2_index_mul_operand ( xiop1 ) ) || ( arm_address_register_rtx_p ( xiop1 , strict_p ) && thumb2_index_mul_operand ( xiop0 ) ) ) ; } else if ( code == ASHIFT ) { rtx op = XEXP ( index , <NUM_LIT> ) ;

return ( arm_address_register_rtx_p ( XEXP ( index , <NUM_LIT> ) , strict_p ) && CONST_INT_P ( op ) && INTVAL ( op ) > <NUM_LIT> && INTVAL ( op ) <= <NUM_LIT> ) ;


<s> const char * thumb2_output_casesi ( rtx * operands ) { rtx diff_vec = PATTERN ( NEXT_INSN ( as_a < rtx_insn * > ( operands [ <NUM_LIT> ] ) ) ) ; gcc_assert ( GET_CODE ( diff_vec ) == ADDR_DIFF_VEC ) ; output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; switch ( GET_MODE ( diff_vec ) ) { case QImode : return <STR_LIT> ; case HImode : return <STR_LIT> ;


<s> 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 ( VOIDmode , dst , src ) ; vec = gen_rtvec ( <NUM_LIT> , pat , clobber ) ; } else vec = gen_rtvec ( <NUM_LIT> , pat , clobber ) ; PATTERN ( insn ) = gen_rtx_PARALLEL ( VOIDmode , vec ) ; INSN_CODE ( insn ) = - <NUM_LIT> ;


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


<s> } if ( len >= <NUM_LIT> ) { rtx reg = gen_reg_rtx ( HImode ) ; emit_insn ( gen_movhi ( reg , gen_rtx_MEM ( HImode , plus_constant ( Pmode , in , offset ) ) ) ) ; emit_insn ( gen_movhi ( gen_rtx_MEM ( HImode , plus_constant ( Pmode , out , offset ) ) , reg ) ) ; len -= <NUM_LIT> ; offset += <NUM_LIT> ; } if ( len ) { rtx reg = gen_reg_rtx ( QImode ) ; emit_insn ( gen_movqi ( reg , gen_rtx_MEM ( QImode , plus_constant ( Pmode , in , offset ) ) ) ) ; emit_insn ( gen_movqi ( gen_rtx_MEM ( QImode , plus_constant ( Pmode , out , offset ) ) , reg ) ) ; }


<s> if ( ! cfun -> machine -> uses_anonymous_args && crtl -> args . size >= <NUM_LIT> && crtl -> args . size <= ( LAST_ARG_REGNUM * UNITS_PER_WORD ) && ( TARGET_AAPCS_BASED ? crtl -> args . info . aapcs_ncrn < <NUM_LIT> : crtl -> args . info . nregs < <NUM_LIT> ) ) return LAST_ARG_REGNUM ; for ( reg = LAST_LO_REGNUM ; reg > LAST_ARG_REGNUM ; reg -- ) if ( pushed_regs_mask & ( <NUM_LIT> << reg ) ) return reg ; if ( TARGET_THUMB2 ) { for ( reg = FIRST_HI_REGNUM ; reg < <NUM_LIT> ; reg ++ ) if ( pushed_regs_mask & ( <NUM_LIT> << reg ) ) return reg ; } gcc_unreachable ( ) ;


<s> static bool thumb_force_lr_save ( void ) {

return ! cfun -> machine -> lr_save_eliminated && ( ! leaf_function_p ( ) || thumb_far_jump_used_p ( ) || df_regs_ever_live_p ( LR_REGNUM ) ) ;


<s> return ! cfun -> machine -> lr_save_eliminated && ( ! leaf_function_p ( ) || thumb_far_jump_used_p ( ) || df_regs_ever_live_p ( LR_REGNUM ) ) ;


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


<s> else if ( offset < <NUM_LIT> * GET_MODE_SIZE ( mode ) + <NUM_LIT> ) delta = <NUM_LIT> * GET_MODE_SIZE ( mode ) ; else delta = offset & ( ~ <NUM_LIT> * GET_MODE_SIZE ( mode ) ) ; xop0 = force_operand ( plus_constant ( Pmode , xop0 , offset - delta ) , NULL_RTX ) ; x = plus_constant ( Pmode , xop0 , delta ) ; } else if ( offset < <NUM_LIT> && offset > - <NUM_LIT> ) x = force_operand ( x , NULL_RTX ) ; else { xop1 = force_reg ( SImode , xop1 ) ; x = gen_rtx_PLUS ( SImode , xop0 , xop1 ) ; } } else if ( GET_CODE ( x ) == PLUS && s_register_operand ( XEXP ( x , <NUM_LIT> ) , SImode ) && ! s_register_operand ( XEXP ( x , <NUM_LIT> ) , SImode ) ) { rtx xop0 = force_operand ( XEXP ( x , <NUM_LIT> ) , NULL_RTX ) ; x = gen_rtx_PLUS ( SImode , xop0 , XEXP ( x , <NUM_LIT> ) ) ;


<s> } else if ( offset < <NUM_LIT> && offset > - <NUM_LIT> ) x = force_operand ( x , NULL_RTX ) ; else { xop1 = force_reg ( SImode , xop1 ) ; x = gen_rtx_PLUS ( SImode , xop0 , xop1 ) ; } } else if ( GET_CODE ( x ) == PLUS && s_register_operand ( XEXP ( x , <NUM_LIT> ) , SImode ) && ! s_register_operand ( XEXP ( x , <NUM_LIT> ) , SImode ) ) { rtx xop0 = force_operand ( XEXP ( x , <NUM_LIT> ) , NULL_RTX ) ; x = gen_rtx_PLUS ( SImode , xop0 , XEXP ( x , <NUM_LIT> ) ) ; }


<s> x = copy_rtx ( x ) ; push_reload ( orig_x , NULL_RTX , x_p , NULL , MODE_BASE_REG_CLASS ( mode ) , Pmode , VOIDmode , <NUM_LIT> , <NUM_LIT> , opnum , ( enum reload_type ) type ) ; return x ; } if ( GET_CODE ( x ) == PLUS && REG_P ( XEXP ( x , <NUM_LIT> ) ) && REG_P ( XEXP ( x , <NUM_LIT> ) ) && ! REG_MODE_OK_FOR_REG_BASE_P ( XEXP ( x , <NUM_LIT> ) , mode ) && ! REG_MODE_OK_FOR_REG_BASE_P ( XEXP ( x , <NUM_LIT> ) , mode ) ) { rtx orig_x = x ; x = copy_rtx ( x ) ; push_reload ( orig_x , NULL_RTX , x_p , NULL , MODE_BASE_REG_CLASS ( mode ) , Pmode , VOIDmode , <NUM_LIT> , <NUM_LIT> , opnum , ( enum reload_type ) type ) ; return x ; } return NULL ;


<s> if ( GET_CODE ( x ) == PLUS && GET_MODE_SIZE ( mode ) < <NUM_LIT> && REG_P ( XEXP ( x , <NUM_LIT> ) ) && XEXP ( x , <NUM_LIT> ) == stack_pointer_rtx && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) && ! thumb_legitimate_offset_p ( mode , INTVAL ( XEXP ( x , <NUM_LIT> ) ) ) ) { rtx orig_x = x ; x = copy_rtx ( x ) ; push_reload ( orig_x , NULL_RTX , x_p , NULL , MODE_BASE_REG_CLASS ( mode ) , Pmode , VOIDmode , <NUM_LIT> , <NUM_LIT> , opnum , ( enum reload_type ) type ) ; return x ; } if ( GET_CODE ( x ) == PLUS && REG_P ( XEXP ( x , <NUM_LIT> ) ) && REG_P ( XEXP ( x , <NUM_LIT> ) ) && ! REG_MODE_OK_FOR_REG_BASE_P ( XEXP ( x , <NUM_LIT> ) , mode ) && ! REG_MODE_OK_FOR_REG_BASE_P ( XEXP ( x , <NUM_LIT> ) , mode ) ) { rtx orig_x = x ; x = copy_rtx ( x ) ; push_reload ( orig_x , NULL_RTX , x_p , NULL , MODE_BASE_REG_CLASS ( mode ) , Pmode , VOIDmode , <NUM_LIT> , <NUM_LIT> , opnum , ( enum reload_type ) type ) ; return x ; } return NULL ;


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


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


<s> rtx insn , dwarf ; amount = offsets -> outgoing_args - offsets -> locals_base ; if ( amount < <NUM_LIT> ) insn = emit_insn ( gen_addsi3 ( hard_frame_pointer_rtx , stack_pointer_rtx , GEN_INT ( amount ) ) ) ; else { emit_insn ( gen_movsi ( hard_frame_pointer_rtx , GEN_INT ( amount ) ) ) ; if ( TARGET_THUMB2 ) { insn = emit_insn ( gen_addsi3 ( hard_frame_pointer_rtx , stack_pointer_rtx , hard_frame_pointer_rtx ) ) ; } else { insn = emit_insn ( gen_addsi3 ( hard_frame_pointer_rtx , hard_frame_pointer_rtx , stack_pointer_rtx ) ) ; } dwarf = gen_rtx_SET ( VOIDmode , hard_frame_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , amount ) ) ; RTX_FRAME_RELATED_P ( dwarf ) = <NUM_LIT> ;

add_reg_note ( insn , REG_FRAME_RELATED_EXPR , dwarf ) ;


<s> rtx insn , dwarf ; amount = offsets -> outgoing_args - offsets -> locals_base ; if ( amount < <NUM_LIT> ) insn = emit_insn ( gen_addsi3 ( hard_frame_pointer_rtx , stack_pointer_rtx , GEN_INT ( amount ) ) ) ; else { emit_insn ( gen_movsi ( hard_frame_pointer_rtx , GEN_INT ( amount ) ) ) ; if ( TARGET_THUMB2 ) { insn = emit_insn ( gen_addsi3 ( hard_frame_pointer_rtx , stack_pointer_rtx , hard_frame_pointer_rtx ) ) ; } else { insn = emit_insn ( gen_addsi3 ( hard_frame_pointer_rtx , hard_frame_pointer_rtx , stack_pointer_rtx ) ) ; } dwarf = gen_rtx_SET ( VOIDmode , hard_frame_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , amount ) ) ; RTX_FRAME_RELATED_P ( dwarf ) = <NUM_LIT> ; add_reg_note ( insn , REG_FRAME_RELATED_EXPR , dwarf ) ; } RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ;


<s> void thumb_set_return_address ( rtx source , rtx scratch ) { arm_stack_offsets * offsets ; HOST_WIDE_INT delta ; HOST_WIDE_INT limit ; int reg ; rtx addr ; unsigned long mask ; emit_use ( source ) ; offsets = arm_get_frame_offsets ( ) ; mask = offsets -> saved_regs_mask ; if ( mask & ( <NUM_LIT> << LR_REGNUM ) ) { limit = <NUM_LIT> ; if ( frame_pointer_needed ) { delta = offsets -> soft_frame - offsets -> saved_args ; reg = THUMB_HARD_FRAME_POINTER_REGNUM ; if ( TARGET_THUMB1 ) limit = <NUM_LIT> ; } else { delta = offsets -> outgoing_args - offsets -> saved_args ; reg = SP_REGNUM ; } if ( TARGET_THUMB1 && TARGET_BACKTRACE ) delta -= <NUM_LIT> ; delta -= <NUM_LIT> ; addr = gen_rtx_REG ( SImode , reg ) ;


<s> if ( IS_INTERRUPT ( func_type ) && ( frame_pointer_needed || TARGET_THUMB ) ) return <NUM_LIT> ; if ( TARGET_LDRD && current_tune -> prefer_ldrd_strd && ! optimize_function_for_size_p ( cfun ) ) return <NUM_LIT> ; offsets = arm_get_frame_offsets ( ) ; stack_adjust = offsets -> outgoing_args - offsets -> saved_regs ; if ( crtl -> args . pretend_args_size || cfun -> machine -> uses_anonymous_args || crtl -> calls_eh_return || cfun -> calls_alloca || ! ( stack_adjust == <NUM_LIT> || ( TARGET_APCS_FRAME && frame_pointer_needed && stack_adjust == <NUM_LIT> ) ) ) return <NUM_LIT> ; saved_int_regs = offsets -> saved_regs_mask ; if ( stack_adjust == <NUM_LIT> && ! arm_arch5 && TARGET_ARM ) { if ( ! call_used_regs [ <NUM_LIT> ] ) return <NUM_LIT> ; if ( arm_size_return_regs ( ) >= ( <NUM_LIT> * UNITS_PER_WORD ) ) return <NUM_LIT> ; if ( sibling ) { gcc_assert ( CALL_P ( sibling ) ) ; if ( find_regno_fusage ( sibling , USE , <NUM_LIT> ) ) return <NUM_LIT> ; } if ( saved_int_regs & <NUM_LIT> ) return <NUM_LIT> ; } if ( TARGET_INTERWORK && saved_int_regs != <NUM_LIT> && ! IS_INTERRUPT ( func_type ) ) return <NUM_LIT> ;


<s> offsets = arm_get_frame_offsets ( ) ;

return offsets -> outgoing_args != <NUM_LIT> ;


<s> static bool use_vfp_abi ( enum arm_pcs pcs_variant , bool is_double ) { if ( pcs_variant == ARM_PCS_AAPCS_VFP ) { static bool seen_thumb1_vfp = false ;

if ( TARGET_THUMB1 && ! seen_thumb1_vfp ) {


<s> } if ( pcs_variant != ARM_PCS_AAPCS_LOCAL ) return false ;

return ( TARGET_32BIT && TARGET_VFP && TARGET_HARD_FLOAT && ( TARGET_VFP_DOUBLE || ! is_double ) ) ;


<s> REAL_VALUE_TYPE r0 ; if ( ! CONST_DOUBLE_P ( operand ) ) return <NUM_LIT> ; REAL_VALUE_FROM_CONST_DOUBLE ( r0 , operand ) ; if ( exact_real_truncate ( DFmode , & r0 ) ) { HOST_WIDE_INT value = real_to_integer ( & r0 ) ; value = value & <NUM_LIT> ; if ( ( value != <NUM_LIT> ) && ( ( value & ( value - <NUM_LIT> ) ) == <NUM_LIT> ) ) return int_log2 ( value ) ; } return <NUM_LIT> ;


<s> int vfp3_const_double_for_bits ( rtx operand ) { REAL_VALUE_TYPE r0 ; if ( ! CONST_DOUBLE_P ( operand ) ) return <NUM_LIT> ; REAL_VALUE_FROM_CONST_DOUBLE ( r0 , operand ) ; if ( exact_real_truncate ( DFmode , & r0 ) ) { HOST_WIDE_INT value = real_to_integer ( & r0 ) ; value = value & <NUM_LIT> ;

if ( ( value != <NUM_LIT> ) && ( ( value & ( value - <NUM_LIT> ) ) == <NUM_LIT> ) ) return int_log2 ( value ) ;


<s> if ( exact_real_inverse ( DFmode , & r0 ) ) { if ( exact_real_truncate ( DFmode , & r0 ) ) {

HOST_WIDE_INT value = real_to_integer ( & r0 ) ;


<s> static int vfp3_const_double_index ( rtx x ) { REAL_VALUE_TYPE r , m ; int sign , exponent ; unsigned HOST_WIDE_INT mantissa , mant_hi ; unsigned HOST_WIDE_INT mask ; int point_pos = <NUM_LIT> * HOST_BITS_PER_WIDE_INT - <NUM_LIT> ; bool fail ; if ( ! TARGET_VFP3 || ! CONST_DOUBLE_P ( x ) ) return - <NUM_LIT> ; REAL_VALUE_FROM_CONST_DOUBLE ( r , x ) ; if ( REAL_VALUE_ISINF ( r ) || REAL_VALUE_ISNAN ( r ) || REAL_VALUE_MINUS_ZERO ( r ) ) return - <NUM_LIT> ; sign = REAL_VALUE_NEGATIVE ( r ) ? <NUM_LIT> : <NUM_LIT> ; r = real_value_abs ( & r ) ; exponent = REAL_EXP ( & r ) ; real_ldexp ( & m , & r , point_pos - exponent ) ; wide_int w = real_to_integer ( & m , & fail , HOST_BITS_PER_WIDE_INT * <NUM_LIT> ) ; mantissa = w . elt ( <NUM_LIT> ) ;


<s> wide_int w = real_to_integer ( & m , & fail , HOST_BITS_PER_WIDE_INT * <NUM_LIT> ) ; mantissa = w . elt ( <NUM_LIT> ) ; mant_hi = w . elt ( <NUM_LIT> ) ; if ( mantissa != <NUM_LIT> ) return - <NUM_LIT> ; point_pos -= HOST_BITS_PER_WIDE_INT ; mantissa = mant_hi ; mask = ( ( unsigned HOST_WIDE_INT ) <NUM_LIT> << ( point_pos - <NUM_LIT> ) ) - <NUM_LIT> ; if ( ( mantissa & mask ) != <NUM_LIT> ) return - <NUM_LIT> ;


<s> XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_SET ( VOIDmode , gen_frame_mem ( BLKmode , gen_rtx_PRE_MODIFY ( Pmode , stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - ( count * <NUM_LIT> ) ) ) ) , gen_rtx_UNSPEC ( BLKmode , gen_rtvec ( <NUM_LIT> , reg ) , UNSPEC_PUSH_MULT ) ) ; tmp = gen_rtx_SET ( VOIDmode , stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - ( count * <NUM_LIT> ) ) ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( dwarf , <NUM_LIT> , <NUM_LIT> ) = tmp ; tmp = gen_rtx_SET ( VOIDmode , gen_frame_mem ( DFmode , stack_pointer_rtx ) , reg ) ;


<s> shifted_operand = recog_data . operand [ shift_opnum ] ; extract_insn ( dep ) ; preprocess_constraints ( dep ) ; for ( opno = <NUM_LIT> ; opno < recog_data . n_operands ; opno ++ ) { if ( recog_data . operand_type [ opno ] == OP_IN ) continue ; if ( reg_overlap_mentioned_p ( recog_data . operand [ opno ] , shifted_operand ) ) { * cost = <NUM_LIT> ; return false ; } }


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

rtx tmp = gen_rtx_REG ( ag_mode , FIRST_VFP_REGNUM + i * shift ) ;


<s> if ( GET_MODE ( set_dest ) != SImode ) return false ; 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 ( any_condjump_p ( curr ) ) return false ; if ( ! arm_macro_fusion_p ( ) ) return false ; if ( current_tune -> fusible_ops & tune_params :: FUSE_AES_AESMC && aarch_crypto_can_dual_issue ( prev , curr ) ) return true ; if ( current_tune -> fusible_ops & tune_params :: FUSE_MOVW_MOVT ) { set_dest = SET_DEST ( curr_set ) ; if ( GET_MODE ( set_dest ) != SImode ) return false ; 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 ;


<s> fprintf ( f , <STR_LIT> ) ; asm_fprintf ( f , <STR_LIT> , STATIC_CHAIN_REGNUM , PC_REGNUM ) ; asm_fprintf ( f , <STR_LIT> , PC_REGNUM , PC_REGNUM ) ; } else if ( TARGET_THUMB2 ) { fprintf ( f , <STR_LIT> ) ; asm_fprintf ( f , <STR_LIT> , STATIC_CHAIN_REGNUM , PC_REGNUM ) ; asm_fprintf ( f , <STR_LIT> , PC_REGNUM , PC_REGNUM ) ; }


<s> asm_fprintf ( f , <STR_LIT> , PC_REGNUM , PC_REGNUM ) ; } else if ( TARGET_THUMB2 ) { fprintf ( f , <STR_LIT> ) ; asm_fprintf ( f , <STR_LIT> , STATIC_CHAIN_REGNUM , PC_REGNUM ) ; asm_fprintf ( f , <STR_LIT> , PC_REGNUM , PC_REGNUM ) ; } else { ASM_OUTPUT_ALIGN ( f , <NUM_LIT> ) ; fprintf ( f , <STR_LIT> ) ;


<s> int i , units ; gcc_assert ( GET_CODE ( x ) == CONST_VECTOR ) ; units = CONST_VECTOR_NUNITS ( x ) ; size = GET_MODE_UNIT_SIZE ( mode ) ; if ( GET_MODE_CLASS ( mode ) == MODE_VECTOR_INT ) for ( i = <NUM_LIT> ; i < units ; i ++ ) { rtx elt = CONST_VECTOR_ELT ( x , i ) ; assemble_integer ( elt , size , i == <NUM_LIT> ? BIGGEST_ALIGNMENT : size * BITS_PER_UNIT , <NUM_LIT> ) ; } else for ( i = <NUM_LIT> ; i < units ; i ++ ) { rtx elt = CONST_VECTOR_ELT ( x , i ) ; assemble_real ( * CONST_DOUBLE_REAL_VALUE ( elt ) , GET_MODE_INNER ( mode ) , i == <NUM_LIT> ? BIGGEST_ALIGNMENT : size * BITS_PER_UNIT ) ; } return true ; }

return default_assemble_integer ( x , size , aligned_p ) ;


<s> if ( ! arm_pic_data_is_text_relative || ( GET_CODE ( x ) == SYMBOL_REF && ! SYMBOL_REF_LOCAL_P ( x ) ) ) fputs ( <STR_LIT> , asm_out_file ) ; else fputs ( <STR_LIT> , asm_out_file ) ; } fputc ( '\n' , asm_out_file ) ; return true ; } mode = GET_MODE ( x ) ; if ( arm_vector_mode_supported_p ( mode ) ) { int i , units ; gcc_assert ( GET_CODE ( x ) == CONST_VECTOR ) ; units = CONST_VECTOR_NUNITS ( x ) ;


<s> const struct arm_fpu_desc * callee_fpu = & all_fpus [ callee_opts -> x_arm_fpu_index ] ; if ( ( caller_fpu -> features & callee_fpu -> features ) != callee_fpu -> features ) return false ; if ( callee_fpu -> model != caller_fpu -> model || callee_fpu -> regs != callee_fpu -> regs ) return false ; return true ;


<s> tree callee_tree = DECL_FUNCTION_SPECIFIC_TARGET ( callee ) ; struct cl_target_option * caller_opts = TREE_TARGET_OPTION ( caller_tree ? caller_tree : target_option_default_node ) ; struct cl_target_option * callee_opts = TREE_TARGET_OPTION ( callee_tree ? callee_tree : target_option_default_node ) ; const struct arm_fpu_desc * caller_fpu = & all_fpus [ caller_opts -> x_arm_fpu_index ] ; const struct arm_fpu_desc * callee_fpu = & all_fpus [ callee_opts -> x_arm_fpu_index ] ; if ( ( caller_fpu -> features & callee_fpu -> features ) != callee_fpu -> features ) return false ; if ( callee_fpu -> model != caller_fpu -> model || callee_fpu -> regs != callee_fpu -> regs ) return false ; return true ;


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


<s> static int arm_compute_static_chain_stack_bytes ( void ) {

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


<s> if ( is_called_in_ARM_mode ( decl ) || ( TARGET_THUMB1 && ! TARGET_THUMB1_ONLY && cfun -> is_thunk ) ) fprintf ( stream , <STR_LIT> ) ; else if ( TARGET_THUMB1 ) fprintf ( stream , <STR_LIT> ) ; else fprintf ( stream , <STR_LIT> ) ; }


<s> else if ( TARGET_THUMB1 ) fprintf ( stream , <STR_LIT> ) ; else fprintf ( stream , <STR_LIT> ) ; } else fprintf ( stream , <STR_LIT> ) ;


<s> gcc_assert ( scratch2 == NULL || ( GET_CODE ( scratch2 ) == SCRATCH ) || ( GET_MODE ( scratch2 ) == SImode && REG_P ( scratch2 ) ) ) ; gcc_assert ( ! REG_P ( out ) || ! REG_P ( amount ) || ! HARD_REGISTER_P ( out ) || ( REGNO ( out ) != REGNO ( amount ) && REGNO ( out ) + <NUM_LIT> != REGNO ( amount ) ) ) ; gen_addsi3 ( ( DEST ) , ( SRC ) , GEN_INT ( - <NUM_LIT> ) ) gen_subsi3 ( ( DEST ) , GEN_INT ( <NUM_LIT> ) , ( SRC ) ) gen_addsi3_compare0 ( ( DEST ) , ( SRC ) , \ GEN_INT ( - <NUM_LIT> ) ) gen_rtx_SET ( ( DEST ) , ( SRC ) ) gen_rtx_fmt_ee ( ( CODE ) , SImode , ( SRC ) , ( AMOUNT ) ) gen_rtx_fmt_ee ( ( CODE ) == ASHIFT ? ASHIFT : LSHIFTRT , \ SImode , ( SRC ) , ( AMOUNT ) ) gen_rtx_fmt_ee ( ( CODE ) == ASHIFT ? LSHIFTRT : ASHIFT , \ SImode , ( SRC ) , ( AMOUNT ) ) gen_rtx_IOR ( SImode , ( A ) , ( B ) ) gen_arm_cond_branch ( ( LABEL ) , \ gen_rtx_ ## COND ( CCmode , cc_reg , \ const0_rtx ) , \ cc_reg ) if ( CONST_INT_P ( amount ) ) { if ( INTVAL ( amount ) <= <NUM_LIT> ) emit_insn ( gen_movdi ( out , in ) ) ; else if ( INTVAL ( amount ) >= <NUM_LIT> ) { if ( code == ASHIFTRT ) { rtx const31_rtx = GEN_INT ( <NUM_LIT> ) ; emit_insn ( SET ( out_down , SHIFT ( code , in_up , const31_rtx ) ) ) ; emit_insn ( SET ( out_up , SHIFT ( code , in_up , const31_rtx ) ) ) ; } else emit_insn ( gen_movdi ( out , const0_rtx ) ) ; } else if ( INTVAL ( amount ) < <NUM_LIT> ) { rtx reverse_amount = GEN_INT ( <NUM_LIT> - INTVAL ( amount ) ) ; emit_insn ( SET ( out_down , LSHIFT ( code , in_down , amount ) ) ) ; emit_insn ( SET ( out_down , ORR ( REV_LSHIFT ( code , in_up , reverse_amount ) , out_down ) ) ) ; emit_insn ( SET ( out_up , SHIFT ( code , in_up , amount ) ) ) ; } else { rtx adj_amount = GEN_INT ( INTVAL ( amount ) - <NUM_LIT> ) ;

emit_insn ( SET ( out_down , SHIFT ( code , in_up , adj_amount ) ) ) ;


<s> rtx in_down = code == ASHIFT ? in_high : in_low ; gcc_assert ( code == ASHIFT || code == ASHIFTRT || code == LSHIFTRT ) ; gcc_assert ( out && ( REG_P ( out ) || GET_CODE ( out ) == SUBREG ) && GET_MODE ( out ) == DImode ) ; gcc_assert ( in && ( REG_P ( in ) || GET_CODE ( in ) == SUBREG ) && GET_MODE ( in ) == DImode ) ; gcc_assert ( amount && ( ( ( REG_P ( amount ) || GET_CODE ( amount ) == SUBREG ) && GET_MODE ( amount ) == SImode ) || CONST_INT_P ( amount ) ) ) ; gcc_assert ( scratch1 == NULL || ( GET_CODE ( scratch1 ) == SCRATCH ) || ( GET_MODE ( scratch1 ) == SImode && REG_P ( scratch1 ) ) ) ; gcc_assert ( scratch2 == NULL || ( GET_CODE ( scratch2 ) == SCRATCH ) || ( GET_MODE ( scratch2 ) == SImode && REG_P ( scratch2 ) ) ) ; gcc_assert ( ! REG_P ( out ) || ! REG_P ( amount ) || ! HARD_REGISTER_P ( out ) || ( REGNO ( out ) != REGNO ( amount ) && REGNO ( out ) + <NUM_LIT> != REGNO ( amount ) ) ) ; gen_addsi3 ( ( DEST ) , ( SRC ) , GEN_INT ( - <NUM_LIT> ) ) gen_subsi3 ( ( DEST ) , GEN_INT ( <NUM_LIT> ) , ( SRC ) ) gen_addsi3_compare0 ( ( DEST ) , ( SRC ) , \ GEN_INT ( - <NUM_LIT> ) ) gen_rtx_SET ( ( DEST ) , ( SRC ) ) gen_rtx_fmt_ee ( ( CODE ) , SImode , ( SRC ) , ( AMOUNT ) ) gen_rtx_fmt_ee ( ( CODE ) == ASHIFT ? ASHIFT : LSHIFTRT , \ SImode , ( SRC ) , ( AMOUNT ) ) gen_rtx_fmt_ee ( ( CODE ) == ASHIFT ? LSHIFTRT : ASHIFT , \ SImode , ( SRC ) , ( AMOUNT ) ) gen_rtx_IOR ( SImode , ( A ) , ( B ) ) gen_arm_cond_branch ( ( LABEL ) , \ gen_rtx_ ## COND ( CCmode , cc_reg , \ const0_rtx ) , \ cc_reg ) if ( CONST_INT_P ( amount ) ) {

if ( INTVAL ( amount ) <= <NUM_LIT> ) emit_insn ( gen_movdi ( out , in ) ) ;


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

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


<s> return ; } par = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( num_regs + <NUM_LIT> ) ) ; tmp = gen_rtx_SET ( base_reg , plus_constant ( Pmode , base_reg , <NUM_LIT> * num_regs ) ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = tmp ; for ( j = <NUM_LIT> , i = first_reg ; j < num_regs ; i += <NUM_LIT> ) { reg = gen_rtx_REG ( DFmode , i ) ; tmp = gen_rtx_SET ( reg , gen_frame_mem ( DFmode , plus_constant ( Pmode , base_reg , <NUM_LIT> * j ) ) ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ;

XVECEXP ( par , <NUM_LIT> , j + <NUM_LIT> ) = tmp ;


<s> if ( GET_MODE_UNIT_SIZE ( d -> vmode ) >= <NUM_LIT> ) return false ; if ( d -> perm [ <NUM_LIT> ] == <NUM_LIT> ) odd = <NUM_LIT> ; else if ( d -> perm [ <NUM_LIT> ] == <NUM_LIT> ) odd = <NUM_LIT> ; else return false ; mask = ( d -> one_vector_p ? nelt - <NUM_LIT> : <NUM_LIT> * nelt - <NUM_LIT> ) ; for ( i = <NUM_LIT> ; i < nelt ; i += <NUM_LIT> ) { if ( d -> perm [ i ] != i + odd ) return false ; if ( d -> perm [ i + <NUM_LIT> ] != ( ( i + nelt + odd ) & mask ) ) return false ; } if ( d -> testing_p ) return true ; switch ( d -> vmode ) { case V16QImode : gen = gen_neon_vtrnv16qi_internal ; break ; case V8QImode : gen = gen_neon_vtrnv8qi_internal ; break ; case V8HImode : gen = gen_neon_vtrnv8hi_internal ; break ; case V4HImode : gen = gen_neon_vtrnv4hi_internal ; break ; case V4SImode : gen = gen_neon_vtrnv4si_internal ; break ;

case V2SImode : gen = gen_neon_vtrnv2si_internal ; break ;


<s> swap_nelt = BYTES_BIG_ENDIAN && ! d -> one_vector_p && GET_MODE_SIZE ( d -> vmode ) == <NUM_LIT> ? d -> nelt : <NUM_LIT> ; first_elem = d -> perm [ neon_endian_lane_map ( d -> vmode , <NUM_LIT> ) ] ^ swap_nelt ; if ( first_elem == neon_endian_lane_map ( d -> vmode , <NUM_LIT> ) ) odd = <NUM_LIT> ; else if ( first_elem == neon_endian_lane_map ( d -> vmode , <NUM_LIT> ) ) odd = <NUM_LIT> ; else return false ; mask = ( d -> one_vector_p ? nelt - <NUM_LIT> : <NUM_LIT> * nelt - <NUM_LIT> ) ; for ( i = <NUM_LIT> ; i < nelt ; i ++ ) {

unsigned elt = ( neon_pair_endian_lane_map ( d -> vmode , i ) * <NUM_LIT> + odd ) & mask ;


<s> rval = gen_reg_rtx ( SImode ) ; oldval = convert_modes ( SImode , mode , oldval , true ) ; case SImode : if ( ! arm_add_operand ( oldval , SImode ) ) oldval = force_reg ( SImode , oldval ) ; break ; case DImode : if ( ! cmpdi_operand ( oldval , mode ) ) oldval = force_reg ( mode , oldval ) ; break ; default : gcc_unreachable ( ) ; } switch ( mode ) { case QImode : gen = gen_atomic_compare_and_swapqi_1 ; break ; case HImode : gen = gen_atomic_compare_and_swaphi_1 ; break ; case SImode : gen = gen_atomic_compare_and_swapsi_1 ; break ; case DImode : gen = gen_atomic_compare_and_swapdi_1 ; break ; default : gcc_unreachable ( ) ; }

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


<s> } switch ( mode ) { case QImode : gen = gen_atomic_compare_and_swapqi_1 ; break ; case HImode : gen = gen_atomic_compare_and_swaphi_1 ; break ; case SImode : gen = gen_atomic_compare_and_swapsi_1 ; break ; case DImode : gen = gen_atomic_compare_and_swapdi_1 ; break ; default : gcc_unreachable ( ) ; } emit_insn ( gen ( rval , mem , oldval , newval , is_weak , mod_s , mod_f ) ) ; if ( mode == QImode || mode == HImode ) emit_move_insn ( operands [ <NUM_LIT> ] , gen_lowpart ( mode , rval ) ) ; x = gen_rtx_REG ( CCmode , CC_REGNUM ) ;

x = gen_rtx_EQ ( SImode , x , const0_rtx ) ;


<s> if ( d -> perm [ <NUM_LIT> ] >= d -> nelt ) { unsigned i , nelt = d -> nelt ; for ( i = <NUM_LIT> ; i < nelt ; ++ i ) d -> perm [ i ] = ( d -> perm [ i ] + nelt ) & ( <NUM_LIT> * nelt - <NUM_LIT> ) ; std :: swap ( d -> op0 , d -> op1 ) ;


<s> if ( ! IS_INTERRUPT ( arm_current_func_type ( ) ) && flag_stack_check == STATIC_BUILTIN_STACK_CHECK && arm_except_unwind_info ( & global_options ) == UI_TARGET && cfun -> can_throw_non_call_exceptions ) { HOST_WIDE_INT size = get_frame_size ( ) ; if ( size <= <NUM_LIT> ) return false ;

if ( crtl -> is_leaf && ! cfun -> calls_alloca ) {


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


<s> if ( TARGET_INTERWORK && decl && TREE_PUBLIC ( decl ) && ! TREE_ASM_WRITTEN ( decl ) ) return false ; func_type = arm_current_func_type ( ) ; if ( IS_INTERRUPT ( func_type ) ) return false ; if ( ! VOID_TYPE_P ( TREE_TYPE ( DECL_RESULT ( cfun -> decl ) ) ) ) { rtx a , b ; tree decl_or_type = decl ; if ( ! decl ) decl_or_type = TREE_TYPE ( TREE_TYPE ( CALL_EXPR_FN ( exp ) ) ) ; a = arm_function_value ( TREE_TYPE ( exp ) , decl_or_type , false ) ; b = arm_function_value ( TREE_TYPE ( DECL_RESULT ( cfun -> decl ) ) , cfun -> decl , false ) ; if ( ! rtx_equal_p ( a , b ) ) return false ; } if ( IS_STACKALIGN ( func_type ) ) return false ; if ( TARGET_AAPCS_BASED && arm_abi == ARM_ABI_AAPCS && decl && DECL_WEAK ( decl ) ) return false ; return true ;


<s> if ( IS_INTERRUPT ( func_type ) ) return false ; if ( ! VOID_TYPE_P ( TREE_TYPE ( DECL_RESULT ( cfun -> decl ) ) ) ) { rtx a , b ; tree decl_or_type = decl ; if ( ! decl ) decl_or_type = TREE_TYPE ( TREE_TYPE ( CALL_EXPR_FN ( exp ) ) ) ; a = arm_function_value ( TREE_TYPE ( exp ) , decl_or_type , false ) ; b = arm_function_value ( TREE_TYPE ( DECL_RESULT ( cfun -> decl ) ) , cfun -> decl , false ) ; if ( ! rtx_equal_p ( a , b ) ) return false ; } if ( IS_STACKALIGN ( func_type ) ) return false ;

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


<s> int dimode_comparison = GET_MODE ( x ) == DImode || GET_MODE ( y ) == DImode ; if ( dimode_comparison && ! REG_P ( x ) ) x = force_reg ( DImode , x ) ; mode = SELECT_CC_MODE ( code , x , y ) ; cc_reg = gen_rtx_REG ( mode , CC_REGNUM ) ; if ( dimode_comparison && mode != CC_CZmode ) { rtx clobber , set ; if ( mode == CC_Zmode && y != const0_rtx ) { gcc_assert ( ! reload_completed ) ; x = expand_binop ( DImode , xor_optab , x , y , NULL_RTX , <NUM_LIT> , OPTAB_WIDEN ) ;


<s> if ( current_function_decl ) { mode = TARGET_THUMB ? <STR_LIT> : <STR_LIT> ; add_attribute ( mode , attributes ) ; return ; } if ( lookup_attribute ( <STR_LIT> , * attributes ) != NULL ) return ; mode = thumb_flipper ? <STR_LIT> : <STR_LIT> ; add_attribute ( mode , attributes ) ;


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


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


<s> l1 = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , labelno ) , UNSPEC_PIC_LABEL ) ; l1 = gen_rtx_CONST ( VOIDmode , l1 ) ; pic_rtx = plus_constant ( Pmode , l1 , TARGET_ARM ? <NUM_LIT> : <NUM_LIT> ) ; pic_rtx = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , pic_rtx ) , UNSPEC_GOTSYM_OFF ) ; pic_rtx = gen_rtx_CONST ( Pmode , pic_rtx ) ; if ( TARGET_32BIT ) { emit_insn ( gen_pic_load_addr_unified ( pic_reg , pic_rtx , labelno ) ) ; } else { if ( arm_pic_register != INVALID_REGNUM && REGNO ( pic_reg ) > LAST_LO_REGNUM ) {

pic_tmp = gen_rtx_REG ( SImode , thumb_find_work_register ( saved_regs ) ) ;


<s> if ( ! AGGREGATE_TYPE_P ( type ) ) return TYPE_ALIGN ( TYPE_MAIN_VARIANT ( type ) ) > PARM_BOUNDARY ; if ( TREE_CODE ( type ) == ARRAY_TYPE ) return TYPE_ALIGN ( TREE_TYPE ( type ) ) > PARM_BOUNDARY ; for ( tree field = TYPE_FIELDS ( type ) ; field ; field = DECL_CHAIN ( field ) ) if ( DECL_ALIGN ( field ) > PARM_BOUNDARY ) return true ;


<s> int flags = opts -> x_target_flags ; const struct arm_fpu_desc * fpu_desc = & all_fpus [ opts -> x_arm_fpu_index ] ; if ( TARGET_IWMMXT && TARGET_VFP && ARM_FPU_FSET_HAS ( fpu_desc -> features , FPU_FL_NEON ) ) error ( <STR_LIT> ) ; if ( TARGET_ARM_P ( flags ) && ! ARM_FSET_HAS_CPU1 ( insn_flags , FL_NOTM ) ) error ( <STR_LIT> ) ; if ( ( TARGET_TPCS_FRAME || TARGET_TPCS_LEAF_FRAME ) && TARGET_ARM_P ( flags ) ) warning ( <NUM_LIT> , <STR_LIT> ) ; if ( TARGET_ARM_P ( flags ) && TARGET_CALLEE_INTERWORKING ) warning ( <NUM_LIT> , <STR_LIT> ) ; if ( TARGET_ARM_P ( flags ) && write_symbols != NO_DEBUG && ! TARGET_APCS_FRAME && ( TARGET_DEFAULT & MASK_APCS_FRAME ) ) warning ( <NUM_LIT> , <STR_LIT> ) ;

if ( TARGET_THUMB_P ( flags ) && TARGET_IWMMXT ) error ( <STR_LIT> ) ;


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

else opts -> x_flag_shrink_wrap = to -> x_flag_shrink_wrap ;


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


<s> const struct arm_fpu_desc * fpu_desc = & all_fpus [ ptr -> x_arm_fpu_index ] ; fprintf ( file , <STR_LIT> , indent , <STR_LIT> , TARGET_THUMB2_P ( flags ) ? <STR_LIT> : TARGET_THUMB_P ( flags ) ? <STR_LIT> : <STR_LIT> ) ;

fprintf ( file , <STR_LIT> , indent , <STR_LIT> , fpu_desc -> name ) ;


<s> int flags = ptr -> x_target_flags ; const struct arm_fpu_desc * fpu_desc = & all_fpus [ ptr -> x_arm_fpu_index ] ;

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


<s> } else { if ( regno_base == SP_REGNUM ) sprintf ( pattern , <STR_LIT> , conditional ) ; if ( update ) sprintf ( pattern , <STR_LIT> , conditional ) ; else sprintf ( pattern , <STR_LIT> , conditional ) ; strcat ( pattern , reg_names [ regno_base ] ) ; if ( update ) strcat ( pattern , <STR_LIT> ) ; else strcat ( pattern , <STR_LIT> ) ; } strcat ( pattern , reg_names [ REGNO ( XEXP ( XVECEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> , offset ) , <NUM_LIT> ) ) ] ) ; for ( i = offset + <NUM_LIT> ; i < num_saves ; i ++ ) { strcat ( pattern , <STR_LIT> ) ; strcat ( pattern , reg_names [ REGNO ( XEXP ( XVECEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> , i ) , <NUM_LIT> ) ) ] ) ; } strcat ( pattern , <STR_LIT> ) ; if ( IS_INTERRUPT ( arm_current_func_type ( ) ) && return_pc ) strcat ( pattern , <STR_LIT> ) ;


<s> static void arm_override_options_after_change ( void ) { arm_override_options_after_change_1 ( & global_options ) ;


<s> if ( opts -> x_align_functions <= <NUM_LIT> ) opts -> x_align_functions = TARGET_THUMB_P ( opts -> x_target_flags ) && opts -> x_optimize_size ? <NUM_LIT> : <NUM_LIT> ;


<s> } switch ( GET_CODE ( index ) ) { case CONST_INT : offset = INTVAL ( index ) ; if ( is_minus ) offset = - offset ; asm_fprintf ( stream , <STR_LIT> , REGNO ( base ) , offset ) ; break ; case REG : asm_fprintf ( stream , <STR_LIT> , REGNO ( base ) , is_minus ? <STR_LIT> : <STR_LIT> , REGNO ( index ) ) ; 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 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> ) ) ) ;


<s> if ( DECL_USER_ALIGN ( fndecl ) ) return ; tree callee_tree = DECL_FUNCTION_SPECIFIC_TARGET ( fndecl ) ; if ( ! callee_tree ) callee_tree = target_option_default_node ;

DECL_ALIGN ( fndecl ) = FUNCTION_BOUNDARY_P ( TREE_TARGET_OPTION ( callee_tree ) -> x_target_flags ) ;


<s> DECL_ALIGN ( fndecl ) = FUNCTION_BOUNDARY_P ( TREE_TARGET_OPTION ( callee_tree ) -> x_target_flags ) ;


<s> else result = arm_new_rtx_costs ( x , ( enum rtx_code ) code , ( enum rtx_code ) outer_code , & generic_extra_costs , total , speed ) ; } if ( dump_file && ( dump_flags & TDF_DETAILS ) ) { print_rtl_single ( dump_file , x ) ; fprintf ( dump_file , <STR_LIT> , speed ? <STR_LIT> : <STR_LIT> , * total , result ? <STR_LIT> : <STR_LIT> ) ; } return result ;


<s> int cost , const_ok = const_ok_for_arm ( i ) ; int j , booth_unit_size ; cost = const_ok ? <NUM_LIT> : <NUM_LIT> ; booth_unit_size = <NUM_LIT> ; for ( j = <NUM_LIT> ; i && j < <NUM_LIT> ; j += booth_unit_size ) { i >>= booth_unit_size ; cost ++ ; } * total = COSTS_N_INSNS ( cost ) ; * total += rtx_cost ( XEXP ( x , <NUM_LIT> ) , mode , code , <NUM_LIT> , speed ) ; return true ; }


<s> rtx_code_label * label ; rtx x ; bool is_armv8_sync = arm_arch8 && is_mm_sync ( model ) ; bool use_acquire = TARGET_HAVE_LDACQ && ! ( is_mm_relaxed ( model ) || is_mm_consume ( model ) || is_mm_release ( model ) ) ; bool use_release = TARGET_HAVE_LDACQ && ! ( is_mm_relaxed ( model ) || is_mm_consume ( model ) || is_mm_acquire ( model ) ) ; 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 ) ; switch ( code ) { case SET : new_out = value ; break ; case NOT : x = gen_rtx_AND ( wmode , old_out , value ) ; emit_insn ( gen_rtx_SET ( new_out , x ) ) ; x = gen_rtx_NOT ( wmode , new_out ) ; emit_insn ( gen_rtx_SET ( new_out , x ) ) ; break ; case MINUS : if ( CONST_INT_P ( value ) ) { value = GEN_INT ( - INTVAL ( value ) ) ; code = PLUS ; } case PLUS : if ( mode == DImode ) { emit_move_insn ( new_out , old_out ) ; if ( code == PLUS ) x = gen_adddi3 ( new_out , new_out , value ) ; else x = gen_subdi3 ( new_out , new_out , value ) ; emit_insn ( x ) ; break ; } default : x = gen_rtx_fmt_ee ( code , wmode , old_out , value ) ; emit_insn ( gen_rtx_SET ( new_out , x ) ) ;


<s> cond = arm_gen_compare_reg ( NE , rval , oldval , scratch ) ; 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 ) ) ; arm_emit_store_exclusive ( mode , scratch , mem , newval , use_release ) ; cond = gen_rtx_REG ( CCmode , CC_REGNUM ) ; x = gen_rtx_COMPARE ( CCmode , scratch , const0_rtx ) ; emit_insn ( gen_rtx_SET ( cond , x ) ) ; if ( ! is_weak ) { x = gen_rtx_NE ( VOIDmode , cond , const0_rtx ) ; x = gen_rtx_IF_THEN_ELSE ( VOIDmode , x , gen_rtx_LABEL_REF ( Pmode , label1 ) , pc_rtx ) ; emit_unlikely_jump ( gen_rtx_SET ( pc_rtx , x ) ) ; } if ( ! is_mm_relaxed ( mod_f ) ) emit_label ( label2 ) ;

if ( is_armv8_sync || ! ( use_acquire || use_release ) ) arm_post_atomic_barrier ( mod_s ) ;


<s> newval = operands [ <NUM_LIT> ] ; is_weak = ( operands [ <NUM_LIT> ] != const0_rtx ) ; mod_s = memmodel_from_int ( INTVAL ( operands [ <NUM_LIT> ] ) ) ; mod_f = memmodel_from_int ( INTVAL ( operands [ <NUM_LIT> ] ) ) ; scratch = operands [ <NUM_LIT> ] ; mode = GET_MODE ( mem ) ; bool is_armv8_sync = arm_arch8 && is_mm_sync ( mod_s ) ; bool use_acquire = TARGET_HAVE_LDACQ && ! ( is_mm_relaxed ( mod_s ) || is_mm_consume ( mod_s ) || is_mm_release ( mod_s ) ) ; bool use_release = TARGET_HAVE_LDACQ && ! ( is_mm_relaxed ( mod_s ) || is_mm_consume ( mod_s ) || is_mm_acquire ( mod_s ) ) ; if ( is_armv8_sync ) use_acquire = false ; if ( ! ( use_acquire || use_release ) ) arm_pre_atomic_barrier ( mod_s ) ; label1 = NULL ; if ( ! is_weak ) { label1 = gen_label_rtx ( ) ; emit_label ( label1 ) ; } label2 = gen_label_rtx ( ) ; arm_emit_load_exclusive ( mode , rval , mem , use_acquire ) ; cond = arm_gen_compare_reg ( NE , rval , oldval , scratch ) ; x = gen_rtx_NE ( VOIDmode , cond , const0_rtx ) ; x = gen_rtx_IF_THEN_ELSE ( VOIDmode , x , gen_rtx_LABEL_REF ( Pmode , label2 ) , pc_rtx ) ;

emit_unlikely_jump ( gen_rtx_SET ( pc_rtx , x ) ) ;


<s> rtx tmp = addr ; if ( GET_CODE ( tmp ) == SYMBOL_REF || GET_CODE ( tmp ) == LABEL_REF ) return true ; if ( GET_CODE ( addr ) == CONST ) tmp = XEXP ( addr , <NUM_LIT> ) ;


<s> rtx xop0 , xop1 = NULL_RTX ; rtx tmp = addr ; if ( GET_CODE ( tmp ) == SYMBOL_REF || GET_CODE ( tmp ) == LABEL_REF ) return true ; if ( GET_CODE ( addr ) == CONST ) tmp = XEXP ( addr , <NUM_LIT> ) ;


<s> 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 ) ; cl_optimization_restore ( & func_options , TREE_OPTIMIZATION ( func_optimize ) ) ; cl_target_option_restore ( & func_options , TREE_TARGET_OPTION ( target_option_default_node ) ) ; cur_tree = arm_valid_target_attribute_tree ( args , & func_options , & global_options_set ) ; if ( cur_tree == NULL_TREE ) ret = false ; new_optimize = build_optimization_node ( & func_options ) ;

DECL_FUNCTION_SPECIFIC_TARGET ( fndecl ) = cur_tree ;


<s> 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 ) ; cl_optimization_restore ( & func_options , TREE_OPTIMIZATION ( func_optimize ) ) ; cl_target_option_restore ( & func_options , TREE_TARGET_OPTION ( target_option_default_node ) ) ; cur_tree = arm_valid_target_attribute_tree ( args , & func_options , & global_options_set ) ; if ( cur_tree == NULL_TREE ) ret = false ; new_optimize = build_optimization_node ( & func_options ) ; DECL_FUNCTION_SPECIFIC_TARGET ( fndecl ) = cur_tree ; DECL_FUNCTION_SPECIFIC_OPTIMIZATION ( fndecl ) = new_optimize ; finalize_options_struct ( & func_options ) ; return ret ;


<s> else if ( ! strncmp ( q , <STR_LIT> , <NUM_LIT> ) ) opts -> x_target_flags &= ~ MASK_THUMB ; else if ( ! strncmp ( q , <STR_LIT> , <NUM_LIT> ) ) { if ( ! opt_enum_arg_to_value ( OPT_mfpu_ , q + <NUM_LIT> , & opts -> x_arm_fpu_index , CL_TARGET ) ) { error ( <STR_LIT> , q ) ; return false ; } } else { error ( <STR_LIT> , q ) ; return false ; } arm_option_check_internal ( opts ) ; }


<s> while ( ISSPACE ( * q ) ) ++ q ; argstr = NULL ; if ( ! strncmp ( q , <STR_LIT> , <NUM_LIT> ) ) opts -> x_target_flags |= MASK_THUMB ; else if ( ! strncmp ( q , <STR_LIT> , <NUM_LIT> ) ) opts -> x_target_flags &= ~ MASK_THUMB ; else if ( ! strncmp ( q , <STR_LIT> , <NUM_LIT> ) ) { if ( ! opt_enum_arg_to_value ( OPT_mfpu_ , q + <NUM_LIT> , & opts -> x_arm_fpu_index , CL_TARGET ) ) { error ( <STR_LIT> , q ) ; return false ; }


<s> tree arm_valid_target_attribute_tree ( tree args , struct gcc_options * opts , struct gcc_options * opts_set ) { if ( ! arm_valid_target_attribute_rec ( args , opts ) ) return NULL_TREE ; arm_option_override_internal ( opts , opts_set ) ;

return build_target_option_node ( opts ) ;


<s> tree arm_valid_target_attribute_tree ( tree args , struct gcc_options * opts , struct gcc_options * opts_set ) {

if ( ! arm_valid_target_attribute_rec ( args , opts ) ) return NULL_TREE ;


<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 ) ) return true ;


<s> if ( TARGET_NEON && ( mode == V2SFmode || mode == V4SImode || mode == V8HImode || mode == V4HFmode || mode == V16QImode || mode == V4SFmode || mode == V2DImode || mode == V8HFmode ) ) 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 ; return false ;


<s> enum attr_type attr_type_insn = get_attr_type ( insn ) ; enum attr_type attr_type_dep = get_attr_type ( dep ) ; 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 ( REG_NOTE_KIND ( link ) == REG_DEP_OUTPUT ) * cost = insn_default_latency ( dep ) - <NUM_LIT> ; else * cost = insn_default_latency ( dep ) ; return false ; } else { if ( REG_NOTE_KIND ( link ) == REG_DEP_OUTPUT ) * cost = insn_default_latency ( dep ) + <NUM_LIT> ;


<s> return ( bit_count ( ARM_FSET_CPU1 ( * set ) ) + bit_count ( ARM_FSET_CPU2 ( * set ) ) ) ;


<s> } if ( src_aligned ) emit_move_insn ( 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 ( dst_aligned ) emit_move_insn ( 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 ) ; len -= <NUM_LIT> ; } if ( len == <NUM_LIT> ) return true ; if ( len >= <NUM_LIT> ) { dst = adjust_address ( dst , HImode , <NUM_LIT> ) ; src = adjust_address ( src , HImode , <NUM_LIT> ) ; reg0 = gen_reg_rtx ( SImode ) ; if ( src_aligned ) emit_insn ( gen_zero_extendhisi2 ( reg0 , src ) ) ; else emit_insn ( gen_unaligned_loadhiu ( reg0 , src ) ) ; if ( dst_aligned ) emit_insn ( gen_movhi ( dst , gen_lowpart ( HImode , reg0 ) ) ) ; else emit_insn ( gen_unaligned_storehi ( dst , gen_lowpart ( HImode , reg0 ) ) ) ; src = next_consecutive_mem ( src ) ; dst = next_consecutive_mem ( dst ) ; if ( len == <NUM_LIT> ) return true ; } dst = adjust_address ( dst , QImode , <NUM_LIT> ) ;

src = adjust_address ( src , QImode , <NUM_LIT> ) ;


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


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


<s> emit_note ( NOTE_INSN_DELETED ) ; return ; } destlo = gen_rtx_REG_offset ( operands [ <NUM_LIT> ] , halfmode , dest , <NUM_LIT> ) ; desthi = gen_rtx_REG_offset ( operands [ <NUM_LIT> ] , halfmode , dest + halfregs , GET_MODE_SIZE ( halfmode ) ) ; if ( src2 == dest && src1 == dest + halfregs ) { rtx x = gen_rtx_SET ( destlo , operands [ <NUM_LIT> ] ) ; rtx y = gen_rtx_SET ( desthi , operands [ <NUM_LIT> ] ) ; emit_insn ( gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , x , y ) ) ) ; return ;


<s> rtx el = vector ? CONST_VECTOR_ELT ( op , i ) : op ; unsigned HOST_WIDE_INT elpart ; gcc_assert ( CONST_INT_P ( el ) ) ; elpart = INTVAL ( el ) ; for ( unsigned int byte = <NUM_LIT> ; byte < innersize ; byte ++ ) { bytes [ idx ++ ] = ( elpart & <NUM_LIT> ) ^ invmask ; elpart >>= BITS_PER_UNIT ; } } gcc_assert ( idx == GET_MODE_SIZE ( mode ) ) ; do { CHECK ( <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , bytes [ i ] == bytes [ <NUM_LIT> ] && bytes [ i + <NUM_LIT> ] == <NUM_LIT> && bytes [ i + <NUM_LIT> ] == <NUM_LIT> && bytes [ i + <NUM_LIT> ] == <NUM_LIT> ) ; CHECK ( <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , bytes [ i ] == <NUM_LIT> && bytes [ i + <NUM_LIT> ] == bytes [ <NUM_LIT> ] && bytes [ i + <NUM_LIT> ] == <NUM_LIT> && bytes [ i + <NUM_LIT> ] == <NUM_LIT> ) ; CHECK ( <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , bytes [ i ] == <NUM_LIT> && bytes [ i + <NUM_LIT> ] == <NUM_LIT> && bytes [ i + <NUM_LIT> ] == bytes [ <NUM_LIT> ] && bytes [ i + <NUM_LIT> ] == <NUM_LIT> ) ; CHECK ( <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , bytes [ i ] == <NUM_LIT> && bytes [ i + <NUM_LIT> ] == <NUM_LIT> && bytes [ i + <NUM_LIT> ] == <NUM_LIT> && bytes [ i + <NUM_LIT> ] == bytes [ <NUM_LIT> ] ) ; CHECK ( <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , bytes [ i ] == bytes [ <NUM_LIT> ] && bytes [ i + <NUM_LIT> ] == <NUM_LIT> ) ; CHECK ( <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , bytes [ i ] == <NUM_LIT> && bytes [ i + <NUM_LIT> ] == bytes [ <NUM_LIT> ] ) ; CHECK ( <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , bytes [ i ] == bytes [ <NUM_LIT> ] && bytes [ i + <NUM_LIT> ] == <NUM_LIT> && bytes [ i + <NUM_LIT> ] == <NUM_LIT> && bytes [ i + <NUM_LIT> ] == <NUM_LIT> ) ;


<s> if ( GET_CODE ( vals ) != CONST_VECTOR || GET_MODE_SIZE ( inner_mode ) > <NUM_LIT> ) return NULL_RTX ; if ( ! const_vec_duplicate_p ( vals , & x ) ) return NULL_RTX ; x = copy_to_mode_reg ( inner_mode , x ) ;

return gen_rtx_VEC_DUPLICATE ( mode , x ) ;


<s> if ( ! const_vec_duplicate_p ( vals , & x ) ) return NULL_RTX ; x = copy_to_mode_reg ( inner_mode , x ) ; return gen_rtx_VEC_DUPLICATE ( mode , x ) ;


<s> rtx ind ; if ( strict && ! ( reload_in_progress || reload_completed ) && ( reg_mentioned_p ( frame_pointer_rtx , op ) || reg_mentioned_p ( arg_pointer_rtx , op ) || reg_mentioned_p ( virtual_incoming_args_rtx , op ) || reg_mentioned_p ( virtual_outgoing_args_rtx , op ) || reg_mentioned_p ( virtual_stack_dynamic_rtx , op ) || reg_mentioned_p ( virtual_stack_vars_rtx , op ) ) ) return FALSE ; if ( ! MEM_P ( op ) ) return FALSE ; ind = XEXP ( op , <NUM_LIT> ) ; if ( reload_completed && ( GET_CODE ( ind ) == LABEL_REF || ( GET_CODE ( ind ) == CONST && GET_CODE ( XEXP ( ind , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( ind , <NUM_LIT> ) , <NUM_LIT> ) ) == LABEL_REF && CONST_INT_P ( XEXP ( XEXP ( ind , <NUM_LIT> ) , <NUM_LIT> ) ) ) ) ) return TRUE ; if ( REG_P ( ind ) ) return arm_address_register_rtx_p ( ind , <NUM_LIT> ) ; if ( ( type != <NUM_LIT> && GET_CODE ( ind ) == POST_INC ) || ( type == <NUM_LIT> && GET_CODE ( ind ) == PRE_DEC ) ) return arm_address_register_rtx_p ( XEXP ( ind , <NUM_LIT> ) , <NUM_LIT> ) ; if ( type == <NUM_LIT> && GET_CODE ( ind ) == POST_MODIFY && GET_CODE ( XEXP ( ind , <NUM_LIT> ) ) == PLUS && REG_P ( XEXP ( XEXP ( ind , <NUM_LIT> ) , <NUM_LIT> ) ) ) return true ; if ( type == <NUM_LIT> && GET_CODE ( ind ) == PLUS && REG_P ( XEXP ( ind , <NUM_LIT> ) ) && REG_MODE_OK_FOR_BASE_P ( XEXP ( ind , <NUM_LIT> ) , VOIDmode ) && CONST_INT_P ( XEXP ( ind , <NUM_LIT> ) ) && INTVAL ( XEXP ( ind , <NUM_LIT> ) ) > - <NUM_LIT> && ( INTVAL ( XEXP ( ind , <NUM_LIT> ) ) < ( VALID_NEON_QREG_MODE ( GET_MODE ( op ) ) ? <NUM_LIT> : <NUM_LIT> ) ) && ( INTVAL ( XEXP ( ind , <NUM_LIT> ) ) & <NUM_LIT> ) == <NUM_LIT> ) return TRUE ; return FALSE ;


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


<s> void thumb2_expand_return ( bool simple_return ) { int i , num_regs ; unsigned long saved_regs_mask ; arm_stack_offsets * offsets ; offsets = arm_get_frame_offsets ( ) ; saved_regs_mask = offsets -> saved_regs_mask ; for ( i = <NUM_LIT> , num_regs = <NUM_LIT> ; i <= LAST_ARM_REGNUM ; i ++ ) if ( saved_regs_mask & ( <NUM_LIT> << i ) ) num_regs ++ ; if ( ! simple_return && saved_regs_mask ) { if ( num_regs == <NUM_LIT> ) { rtx par = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( <NUM_LIT> ) ) ; rtx reg = gen_rtx_REG ( SImode , PC_REGNUM ) ; rtx addr = gen_rtx_MEM ( SImode , gen_rtx_POST_INC ( SImode , stack_pointer_rtx ) ) ;

set_mem_alias_set ( addr , get_frame_alias_set ( ) ) ;


<s> if ( TARGET_INTERWORK && saved_int_regs != <NUM_LIT> && ! IS_INTERRUPT ( func_type ) ) return <NUM_LIT> ; if ( iscond && arm_tune_strongarm ) { if ( saved_int_regs != <NUM_LIT> && saved_int_regs != ( <NUM_LIT> << LR_REGNUM ) ) return <NUM_LIT> ; if ( flag_pic && arm_pic_register != INVALID_REGNUM && df_regs_ever_live_p ( PIC_OFFSET_TABLE_REGNUM ) ) return <NUM_LIT> ; } if ( saved_int_regs && ! ( saved_int_regs & ( <NUM_LIT> << LR_REGNUM ) ) ) return <NUM_LIT> ; if ( TARGET_HARD_FLOAT && TARGET_VFP ) for ( regno = FIRST_VFP_REGNUM ; regno <= LAST_VFP_REGNUM ; regno ++ ) if ( df_regs_ever_live_p ( regno ) && ! call_used_regs [ regno ] ) return <NUM_LIT> ; if ( TARGET_REALLY_IWMMXT ) for ( regno = FIRST_IWMMXT_REGNUM ; regno <= LAST_IWMMXT_REGNUM ; regno ++ ) if ( df_regs_ever_live_p ( regno ) && ! call_used_regs [ regno ] ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> HOST_WIDE_INT value = real_to_integer ( & r0 ) ; value = value & <NUM_LIT> ; if ( ( value != <NUM_LIT> ) && ( ( value & ( value - <NUM_LIT> ) ) == <NUM_LIT> ) ) return int_log2 ( value ) ; }


<s> r0 = * CONST_DOUBLE_REAL_VALUE ( operand ) ; if ( exact_real_inverse ( DFmode , & r0 ) && ! REAL_VALUE_NEGATIVE ( r0 ) ) { if ( exact_real_truncate ( DFmode , & r0 ) ) { HOST_WIDE_INT value = real_to_integer ( & r0 ) ; value = value & <NUM_LIT> ; if ( ( value != <NUM_LIT> ) && ( ( value & ( value - <NUM_LIT> ) ) == <NUM_LIT> ) ) return int_log2 ( value ) ; } } return <NUM_LIT> ;


<s> if ( REAL_VALUE_ISINF ( r ) || REAL_VALUE_ISNAN ( r ) || REAL_VALUE_MINUS_ZERO ( r ) ) return - <NUM_LIT> ; sign = REAL_VALUE_NEGATIVE ( r ) ? <NUM_LIT> : <NUM_LIT> ; r = real_value_abs ( & r ) ; exponent = REAL_EXP ( & r ) ; real_ldexp ( & m , & r , point_pos - exponent ) ; wide_int w = real_to_integer ( & m , & fail , HOST_BITS_PER_WIDE_INT * <NUM_LIT> ) ; mantissa = w . elt ( <NUM_LIT> ) ; mant_hi = w . elt ( <NUM_LIT> ) ; if ( mantissa != <NUM_LIT> ) return - <NUM_LIT> ; point_pos -= HOST_BITS_PER_WIDE_INT ; mantissa = mant_hi ; mask = ( ( unsigned HOST_WIDE_INT ) <NUM_LIT> << ( point_pos - <NUM_LIT> ) ) - <NUM_LIT> ; if ( ( mantissa & mask ) != <NUM_LIT> ) return - <NUM_LIT> ; mantissa >>= point_pos - <NUM_LIT> ;

if ( mantissa == <NUM_LIT> ) return - <NUM_LIT> ;


<s> if ( REAL_VALUE_ISINF ( r ) || REAL_VALUE_ISNAN ( r ) || REAL_VALUE_MINUS_ZERO ( r ) ) return - <NUM_LIT> ; sign = REAL_VALUE_NEGATIVE ( r ) ? <NUM_LIT> : <NUM_LIT> ; r = real_value_abs ( & r ) ; exponent = REAL_EXP ( & r ) ; real_ldexp ( & m , & r , point_pos - exponent ) ; wide_int w = real_to_integer ( & m , & fail , HOST_BITS_PER_WIDE_INT * <NUM_LIT> ) ; mantissa = w . elt ( <NUM_LIT> ) ; mant_hi = w . elt ( <NUM_LIT> ) ; if ( mantissa != <NUM_LIT> ) return - <NUM_LIT> ; point_pos -= HOST_BITS_PER_WIDE_INT ; mantissa = mant_hi ;

mask = ( ( unsigned HOST_WIDE_INT ) <NUM_LIT> << ( point_pos - <NUM_LIT> ) ) - <NUM_LIT> ;


<s> for ( regno = <NUM_LIT> ; regno < NUM_VFP_ARG_REGS ; regno += shift ) if ( ( ( pcum -> aapcs_vfp_regs_free >> regno ) & mask ) == mask ) { pcum -> aapcs_vfp_reg_alloc = mask << regno ; if ( mode == BLKmode || ( mode == TImode && ! TARGET_NEON ) || ! arm_hard_regno_mode_ok ( FIRST_VFP_REGNUM + regno , mode ) ) { int i ; int rcount = pcum -> aapcs_vfp_rcount ; int rshift = shift ; machine_mode rmode = pcum -> aapcs_vfp_rmode ; rtx par ; if ( ! TARGET_NEON ) { if ( rmode == V2SImode ) rmode = DImode ; else if ( rmode == V4SImode ) { rmode = DImode ; rcount *= <NUM_LIT> ; rshift /= <NUM_LIT> ; } } par = gen_rtx_PARALLEL ( mode , rtvec_alloc ( rcount ) ) ; for ( i = <NUM_LIT> ; i < rcount ; i ++ ) { rtx tmp = gen_rtx_REG ( rmode , FIRST_VFP_REGNUM + regno + i * rshift ) ; tmp = gen_rtx_EXPR_LIST ( VOIDmode , tmp , GEN_INT ( i * GET_MODE_SIZE ( rmode ) ) ) ; XVECEXP ( par , <NUM_LIT> , i ) = tmp ; } pcum -> aapcs_reg = par ; }

else pcum -> aapcs_reg = gen_rtx_REG ( mode , FIRST_VFP_REGNUM + regno ) ;


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

count = count > sub_count ? count : sub_count ;


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


<s> if ( current_tune -> fusible_ops & tune_params :: FUSE_AES_AESMC && aarch_crypto_can_dual_issue ( prev , curr ) ) return true ; if ( current_tune -> fusible_ops & tune_params :: FUSE_MOVW_MOVT && arm_sets_movw_movt_fusible_p ( prev_set , curr_set ) ) return true ;


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


<s> if ( GET_MODE_CLASS ( mode ) == MODE_VECTOR_INT ) for ( i = <NUM_LIT> ; i < units ; i ++ ) { rtx elt = CONST_VECTOR_ELT ( x , i ) ; assemble_integer ( elt , size , i == <NUM_LIT> ? BIGGEST_ALIGNMENT : size * BITS_PER_UNIT , <NUM_LIT> ) ; } else for ( i = <NUM_LIT> ; i < units ; i ++ ) { rtx elt = CONST_VECTOR_ELT ( x , i ) ; assemble_real ( * CONST_DOUBLE_REAL_VALUE ( elt ) , GET_MODE_INNER ( mode ) , i == <NUM_LIT> ? BIGGEST_ALIGNMENT : size * BITS_PER_UNIT ) ; }


<s> if ( GET_MODE_CLASS ( mode ) == MODE_VECTOR_INT ) for ( i = <NUM_LIT> ; i < units ; i ++ ) { rtx elt = CONST_VECTOR_ELT ( x , i ) ; assemble_integer ( elt , size , i == <NUM_LIT> ? BIGGEST_ALIGNMENT : size * BITS_PER_UNIT , <NUM_LIT> ) ; } else for ( i = <NUM_LIT> ; i < units ; i ++ ) { rtx elt = CONST_VECTOR_ELT ( x , i ) ; assemble_real ( * CONST_DOUBLE_REAL_VALUE ( elt ) , GET_MODE_INNER ( mode ) , i == <NUM_LIT> ? BIGGEST_ALIGNMENT : size * BITS_PER_UNIT ) ;


<s> static rtx_insn * arm_call_tls_get_addr ( rtx x , rtx reg , rtx * valuep , int reloc ) { rtx label , labelno , sum ; gcc_assert ( reloc != TLS_DESCSEQ ) ; start_sequence ( ) ; labelno = GEN_INT ( pic_labelno ++ ) ; label = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , labelno ) , UNSPEC_PIC_LABEL ) ; label = gen_rtx_CONST ( VOIDmode , label ) ; sum = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , x , GEN_INT ( reloc ) , label , GEN_INT ( TARGET_ARM ? <NUM_LIT> : <NUM_LIT> ) ) , UNSPEC_TLS ) ;


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


<s> if ( * code == GT || * code == LE || ( ! TARGET_ARM && ( * code == GTU || * code == LEU ) ) ) { if ( CONST_INT_P ( * op1 ) ) { i = INTVAL ( * op1 ) ; switch ( * code ) { case GT : case LE : if ( i != maxval && arm_const_double_by_immediates ( GEN_INT ( i + <NUM_LIT> ) ) ) { * op1 = GEN_INT ( i + <NUM_LIT> ) ; * code = * code == GT ? GE : LT ; return ; } break ; case GTU : case LEU : if ( i != ~ ( ( unsigned HOST_WIDE_INT ) <NUM_LIT> ) && arm_const_double_by_immediates ( GEN_INT ( i + <NUM_LIT> ) ) ) { * op1 = GEN_INT ( i + <NUM_LIT> ) ; * code = * code == GTU ? GEU : LTU ; return ; } break ; default : gcc_unreachable ( ) ; } } if ( ! op0_preserve_value ) { std :: swap ( * op0 , * op1 ) ; * code = ( int ) swap_condition ( ( enum rtx_code ) * code ) ; } } return ; } if ( mode == SImode && GET_CODE ( * op0 ) == ZERO_EXTEND && GET_CODE ( XEXP ( * op0 , <NUM_LIT> ) ) == SUBREG && GET_MODE ( XEXP ( * op0 , <NUM_LIT> ) ) == QImode && GET_MODE ( SUBREG_REG ( XEXP ( * op0 , <NUM_LIT> ) ) ) == SImode && subreg_lowpart_p ( XEXP ( * op0 , <NUM_LIT> ) ) && * op1 == const0_rtx ) * op0 = gen_rtx_AND ( SImode , SUBREG_REG ( XEXP ( * op0 , <NUM_LIT> ) ) , GEN_INT ( <NUM_LIT> ) ) ; if ( ! CONST_INT_P ( * op1 ) || const_ok_for_arm ( INTVAL ( * op1 ) ) || const_ok_for_arm ( - INTVAL ( * op1 ) ) ) return ; i = INTVAL ( * op1 ) ; switch ( * code ) { case EQ : case NE : return ; case GT : case LE : if ( i != maxval && ( const_ok_for_arm ( i + <NUM_LIT> ) || const_ok_for_arm ( - ( i + <NUM_LIT> ) ) ) ) { * op1 = GEN_INT ( ARM_SIGN_EXTEND ( i + <NUM_LIT> ) ) ; * code = * code == GT ? GE : LT ; return ; }


<s> int regno ; if ( TARGET_THUMB1 && optimize_size ) { for ( regno = FIRST_HI_REGNUM ; regno <= LAST_HI_REGNUM ; ++ regno ) fixed_regs [ regno ] = call_used_regs [ regno ] = <NUM_LIT> ; } if ( TARGET_THUMB1 ) fixed_regs [ LR_REGNUM ] = call_used_regs [ LR_REGNUM ] = <NUM_LIT> ; if ( TARGET_32BIT && TARGET_HARD_FLOAT ) { for ( regno = FIRST_VFP_REGNUM ; regno <= LAST_VFP_REGNUM ; ++ regno ) { fixed_regs [ regno ] = <NUM_LIT> ; call_used_regs [ regno ] = regno < FIRST_VFP_REGNUM + <NUM_LIT> || regno >= FIRST_VFP_REGNUM + <NUM_LIT> ; } } if ( TARGET_REALLY_IWMMXT ) { regno = FIRST_IWMMXT_GR_REGNUM ; for ( regno = FIRST_IWMMXT_GR_REGNUM ; regno <= LAST_IWMMXT_GR_REGNUM ; ++ regno ) fixed_regs [ regno ] = <NUM_LIT> ; for ( regno = FIRST_IWMMXT_REGNUM ; regno <= LAST_IWMMXT_REGNUM ; ++ regno ) { fixed_regs [ regno ] = <NUM_LIT> ; call_used_regs [ regno ] = regno < FIRST_IWMMXT_REGNUM + <NUM_LIT> ; } }

if ( ( unsigned ) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM ) {


<s> if ( TARGET_32BIT && TARGET_HARD_FLOAT ) { for ( regno = FIRST_VFP_REGNUM ; regno <= LAST_VFP_REGNUM ; ++ regno ) { fixed_regs [ regno ] = <NUM_LIT> ; call_used_regs [ regno ] = regno < FIRST_VFP_REGNUM + <NUM_LIT> || regno >= FIRST_VFP_REGNUM + <NUM_LIT> ; } } if ( TARGET_REALLY_IWMMXT ) { regno = FIRST_IWMMXT_GR_REGNUM ; for ( regno = FIRST_IWMMXT_GR_REGNUM ; regno <= LAST_IWMMXT_GR_REGNUM ; ++ regno ) fixed_regs [ regno ] = <NUM_LIT> ; for ( regno = FIRST_IWMMXT_REGNUM ; regno <= LAST_IWMMXT_REGNUM ; ++ regno ) { fixed_regs [ regno ] = <NUM_LIT> ; call_used_regs [ regno ] = regno < FIRST_IWMMXT_REGNUM + <NUM_LIT> ; } } if ( ( unsigned ) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM ) { fixed_regs [ PIC_OFFSET_TABLE_REGNUM ] = <NUM_LIT> ; call_used_regs [ PIC_OFFSET_TABLE_REGNUM ] = <NUM_LIT> ; } else if ( TARGET_APCS_STACK ) { fixed_regs [ <NUM_LIT> ] = <NUM_LIT> ; call_used_regs [ <NUM_LIT> ] = <NUM_LIT> ; } if ( TARGET_APCS_FRAME || TARGET_CALLER_INTERWORKING || TARGET_TPCS_FRAME || TARGET_TPCS_LEAF_FRAME ) { fixed_regs [ ARM_HARD_FRAME_POINTER_REGNUM ] = <NUM_LIT> ; call_used_regs [ ARM_HARD_FRAME_POINTER_REGNUM ] = <NUM_LIT> ; if ( TARGET_CALLER_INTERWORKING ) global_regs [ ARM_HARD_FRAME_POINTER_REGNUM ] = <NUM_LIT> ; }