<s> address += get_attr_length ( insn ) ; if ( ( table = is_jump_table ( insn ) ) != NULL ) { address += get_jump_table_size ( table ) ; insn = table ; } } } fix = minipool_fix_head ; while ( fix ) { Mfix * ftmp ; Mfix * fdel ; Mfix * last_added_fix ; Mfix * last_barrier = NULL ; Mfix * this_fix ; while ( fix && GET_CODE ( fix -> insn ) == BARRIER ) fix = fix -> next ; if ( fix == NULL ) break ; last_added_fix = NULL ; for ( ftmp = fix ; ftmp ; ftmp = ftmp -> next ) { if ( GET_CODE ( ftmp -> insn ) == BARRIER ) { if ( ftmp -> address >= minipool_vector_head -> max_address ) break ; last_barrier = ftmp ; } else if ( ( ftmp -> minipool = add_minipool_forward_ref ( ftmp ) ) == NULL ) break ; last_added_fix = ftmp ; } if ( last_barrier != NULL ) { for ( fdel = last_barrier -> next ; fdel && fdel != ftmp ; fdel = fdel -> next ) { fdel -> minipool -> refcount -- ; fdel -> minipool = NULL ; } ftmp = last_barrier ; } else {


<s> field = TREE_CHAIN ( field ) ) continue ; if ( field == NULL ) return <NUM_LIT> ; if ( FLOAT_TYPE_P ( TREE_TYPE ( field ) ) ) return <NUM_LIT> ; if ( RETURN_IN_MEMORY ( TREE_TYPE ( field ) ) ) return <NUM_LIT> ; for ( field = TREE_CHAIN ( field ) ; field ; field = TREE_CHAIN ( field ) ) { if ( TREE_CODE ( field ) != FIELD_DECL ) continue ; if ( ! DECL_BIT_FIELD_TYPE ( field ) ) return <NUM_LIT> ; } return <NUM_LIT> ; } if ( TREE_CODE ( type ) == UNION_TYPE ) { tree field ; for ( field = TYPE_FIELDS ( type ) ; field ; field = TREE_CHAIN ( field ) ) { if ( TREE_CODE ( field ) != FIELD_DECL ) continue ; if ( FLOAT_TYPE_P ( TREE_TYPE ( field ) ) ) return <NUM_LIT> ; if ( RETURN_IN_MEMORY ( TREE_TYPE ( field ) ) ) return <NUM_LIT> ;


<s> static bool arm_return_in_msb ( tree valtype ) {

return ( TARGET_AAPCS_BASED && BYTES_BIG_ENDIAN && ( AGGREGATE_TYPE_P ( valtype ) || TREE_CODE ( valtype ) == COMPLEX_TYPE ) ) ;


<s> if ( GET_CODE ( x ) == IF_THEN_ELSE && ( XEXP ( x , <NUM_LIT> ) == const0_rtx || XEXP ( x , <NUM_LIT> ) == const1_rtx ) && COMPARISON_P ( XEXP ( x , <NUM_LIT> ) ) && COMPARISON_P ( XEXP ( x , <NUM_LIT> ) ) ) return arm_select_dominance_cc_mode ( XEXP ( x , <NUM_LIT> ) , XEXP ( x , <NUM_LIT> ) , INTVAL ( XEXP ( x , <NUM_LIT> ) ) ) ; if ( GET_CODE ( x ) == AND && COMPARISON_P ( XEXP ( x , <NUM_LIT> ) ) && COMPARISON_P ( XEXP ( x , <NUM_LIT> ) ) ) return arm_select_dominance_cc_mode ( XEXP ( x , <NUM_LIT> ) , XEXP ( x , <NUM_LIT> ) , DOM_CC_X_AND_Y ) ; if ( GET_CODE ( x ) == IOR && COMPARISON_P ( XEXP ( x , <NUM_LIT> ) ) && COMPARISON_P ( XEXP ( x , <NUM_LIT> ) ) ) return arm_select_dominance_cc_mode ( XEXP ( x , <NUM_LIT> ) , XEXP ( x , <NUM_LIT> ) , DOM_CC_X_OR_Y ) ; if ( TARGET_THUMB && GET_MODE ( x ) == SImode && ( op == EQ || op == NE ) && ( GET_CODE ( x ) == ZERO_EXTRACT ) ) return CC_Nmode ; if ( GET_MODE ( x ) == SImode && y == const0_rtx && ( op == EQ || op == NE || op == LT || op == GE ) && ( GET_CODE ( x ) == PLUS || GET_CODE ( x ) == MINUS || GET_CODE ( x ) == AND || GET_CODE ( x ) == IOR || GET_CODE ( x ) == XOR || GET_CODE ( x ) == MULT || GET_CODE ( x ) == NOT || GET_CODE ( x ) == NEG || GET_CODE ( x ) == LSHIFTRT || GET_CODE ( x ) == ASHIFT || GET_CODE ( x ) == ASHIFTRT || GET_CODE ( x ) == ROTATERT || ( TARGET_ARM && GET_CODE ( x ) == ZERO_EXTRACT ) ) ) return CC_NOOVmode ; if ( GET_MODE ( x ) == QImode && ( op == EQ || op == NE ) ) return CC_Zmode ; if ( GET_MODE ( x ) == SImode && ( op == LTU || op == GEU ) && GET_CODE ( x ) == PLUS && ( rtx_equal_p ( XEXP ( x , <NUM_LIT> ) , y ) || rtx_equal_p ( XEXP ( x , <NUM_LIT> ) , y ) ) ) return CC_Cmode ; return CCmode ;


<s> static void arm_setup_incoming_varargs ( CUMULATIVE_ARGS * cum , enum machine_mode mode ATTRIBUTE_UNUSED , tree type ATTRIBUTE_UNUSED , int * pretend_size , int second_time ATTRIBUTE_UNUSED ) { cfun -> machine -> uses_anonymous_args = <NUM_LIT> ;

if ( cum -> nregs < NUM_ARG_REGS ) * pretend_size = ( NUM_ARG_REGS - cum -> nregs ) * UNITS_PER_WORD ;


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


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


<s> enum machine_mode mode ; if ( current_function_return_rtx != <NUM_LIT> ) mode = GET_MODE ( current_function_return_rtx ) ; else mode = DECL_MODE ( DECL_RESULT ( current_function_decl ) ) ;


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


<s> case PLUS : if ( TARGET_HARD_FLOAT && GET_MODE_CLASS ( mode ) == MODE_FLOAT ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return false ; } case AND : case XOR : case IOR : if ( mode == SImode ) { enum rtx_code subcode = GET_CODE ( XEXP ( x , <NUM_LIT> ) ) ; if ( subcode == ROTATE || subcode == ROTATERT || subcode == ASHIFT || subcode == LSHIFTRT || subcode == ASHIFTRT || ( code == AND && subcode == NOT ) ) { * total = <NUM_LIT> ; return false ; } } * total = COSTS_N_INSNS ( ARM_NUM_REGS ( mode ) ) ; return false ; case MULT : * total = COSTS_N_INSNS ( ARM_NUM_REGS ( mode ) ) ; return false ; case NEG : if ( TARGET_HARD_FLOAT && GET_MODE_CLASS ( mode ) == MODE_FLOAT ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; case NOT : * total = COSTS_N_INSNS ( ARM_NUM_REGS ( mode ) ) ; return false ; case IF_THEN_ELSE : * total = <NUM_LIT> ; return false ; case COMPARE : if ( cc_register ( XEXP ( x , <NUM_LIT> ) , VOIDmode ) ) * total = <NUM_LIT> ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return false ; case ABS : if ( TARGET_HARD_FLOAT && GET_MODE_CLASS ( mode ) == MODE_FLOAT ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( <NUM_LIT> + ARM_NUM_REGS ( mode ) ) ; return false ; case SIGN_EXTEND : * total = <NUM_LIT> ; if ( GET_MODE_SIZE ( GET_MODE ( XEXP ( x , <NUM_LIT> ) ) ) < <NUM_LIT> ) { if ( ! ( arm_arch4 && MEM_P ( XEXP ( x , <NUM_LIT> ) ) ) ) * total += COSTS_N_INSNS ( arm_arch6 ? <NUM_LIT> : <NUM_LIT> ) ; } if ( mode == DImode ) * total += COSTS_N_INSNS ( <NUM_LIT> ) ; return false ; case ZERO_EXTEND : * total = <NUM_LIT> ; if ( ! ( arm_arch4 && MEM_P ( XEXP ( x , <NUM_LIT> ) ) ) ) { switch ( GET_MODE ( XEXP ( x , <NUM_LIT> ) ) ) { case QImode : * total += COSTS_N_INSNS ( <NUM_LIT> ) ; break ; case HImode : * total += COSTS_N_INSNS ( arm_arch6 ? <NUM_LIT> : <NUM_LIT> ) ; case SImode : break ; default : * total += COSTS_N_INSNS ( <NUM_LIT> ) ; } } if ( mode == DImode ) * total += COSTS_N_INSNS ( <NUM_LIT> ) ; return false ;


<s> unsigned HOST_WIDE_INT i = ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) & ( unsigned HOST_WIDE_INT ) <NUM_LIT> ) ; int cost , const_ok = const_ok_for_arm ( i ) ; int j , booth_unit_size ; cost = const_ok ? <NUM_LIT> : <NUM_LIT> ; booth_unit_size = <NUM_LIT> ; for ( j = <NUM_LIT> ; i && j < <NUM_LIT> ; j += booth_unit_size ) { i >>= booth_unit_size ; cost += <NUM_LIT> ; } * total = cost ; return true ; } * total = <NUM_LIT> + ( REG_OR_SUBREG_REG ( XEXP ( x , <NUM_LIT> ) ) ? <NUM_LIT> : <NUM_LIT> ) + ( REG_OR_SUBREG_REG ( XEXP ( x , <NUM_LIT> ) ) ? <NUM_LIT> : <NUM_LIT> ) ; return true ; default : * total = arm_rtx_costs_1 ( x , code , outer_code ) ; return true ;


<s> else cond = NULL_RTX ; if ( subtargets || code == SET || ( GET_CODE ( target ) == REG && GET_CODE ( source ) == REG && REGNO ( target ) != REGNO ( source ) ) ) { if ( ! after_arm_reorg && ! cond && ( arm_gen_constant ( code , mode , NULL_RTX , val , target , source , <NUM_LIT> , <NUM_LIT> ) > arm_constant_limit + ( code != SET ) ) ) { if ( code == SET ) { emit_insn ( gen_rtx_SET ( VOIDmode , target , GEN_INT ( val ) ) ) ;


return gen_rtx_REG ( Pmode , ARG_REGISTER ( <NUM_LIT> ) ) ;


<s> if ( c == REG ) return <NUM_LIT> ; if ( c == PLUS && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == REG && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) return <NUM_LIT> ;


<s> if ( GET_CODE ( * x ) == SYMBOL_REF ) return SYMBOL_REF_TLS_MODEL ( * x ) != <NUM_LIT> ; if ( GET_CODE ( * x ) == UNSPEC && XINT ( * x , <NUM_LIT> ) == UNSPEC_TLS ) return - <NUM_LIT> ; return <NUM_LIT> ;


<s> bool arm_tls_referenced_p ( rtx x ) {


<s> if ( ! TARGET_HAVE_TLS ) return false ;

if ( GET_CODE ( x ) != SYMBOL_REF ) return false ;


<s> static void arm_unwind_emit ( FILE * asm_out_file , rtx insn ) { rtx pat ; if ( ! ARM_EABI_UNWIND_TABLES ) return ; if ( GET_CODE ( insn ) == NOTE || ! RTX_FRAME_RELATED_P ( insn ) ) return ;

pat = find_reg_note ( insn , REG_FRAME_RELATED_EXPR , NULL_RTX ) ;


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

asm_fprintf ( asm_out_file , <STR_LIT> , REGNO ( e0 ) ) ;


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


<s> nregs = XVECLEN ( p , <NUM_LIT> ) - <NUM_LIT> ; reg = REGNO ( XEXP ( XVECEXP ( p , <NUM_LIT> , <NUM_LIT> ) , <NUM_LIT> ) ) ; if ( reg < <NUM_LIT> ) { if ( nregs * <NUM_LIT> == offset - <NUM_LIT> ) { fprintf ( asm_out_file , <STR_LIT> ) ; offset -= <NUM_LIT> ; } reg_size = <NUM_LIT> ; } else if ( IS_VFP_REGNUM ( reg ) ) { offset -= <NUM_LIT> ; reg_size = <NUM_LIT> ; } else if ( reg >= FIRST_FPA_REGNUM && reg <= LAST_FPA_REGNUM ) { asm_fprintf ( asm_out_file , <STR_LIT> , reg , nregs ) ; return ; } else abort ( ) ; if ( offset != nregs * reg_size ) abort ( ) ; fprintf ( asm_out_file , <STR_LIT> ) ; offset = <NUM_LIT> ; lastreg = <NUM_LIT> ; for ( i = <NUM_LIT> ; i <= nregs ; i ++ ) { e = XVECEXP ( p , <NUM_LIT> , i ) ; if ( GET_CODE ( e ) != SET || GET_CODE ( XEXP ( e , <NUM_LIT> ) ) != MEM || GET_CODE ( XEXP ( e , <NUM_LIT> ) ) != REG ) abort ( ) ; reg = REGNO ( XEXP ( e , <NUM_LIT> ) ) ; if ( reg < lastreg ) abort ( ) ; if ( i != <NUM_LIT> ) fprintf ( asm_out_file , <STR_LIT> ) ; if ( IS_VFP_REGNUM ( reg ) ) asm_fprintf ( asm_out_file , <STR_LIT> , ( reg - FIRST_VFP_REGNUM ) / <NUM_LIT> ) ; else asm_fprintf ( asm_out_file , <STR_LIT> , reg ) ; e = XEXP ( XEXP ( e , <NUM_LIT> ) , <NUM_LIT> ) ; if ( GET_CODE ( e ) == PLUS ) { offset += reg_size ; if ( GET_CODE ( XEXP ( e , <NUM_LIT> ) ) != REG || REGNO ( XEXP ( e , <NUM_LIT> ) ) != SP_REGNUM || GET_CODE ( XEXP ( e , <NUM_LIT> ) ) != CONST_INT || offset != INTVAL ( XEXP ( e , <NUM_LIT> ) ) ) abort ( ) ; }

else if ( i != <NUM_LIT> || GET_CODE ( e ) != REG || REGNO ( e ) != SP_REGNUM ) abort ( ) ;


<s> reg_size = <NUM_LIT> ; } else if ( reg >= FIRST_FPA_REGNUM && reg <= LAST_FPA_REGNUM ) { asm_fprintf ( asm_out_file , <STR_LIT> , reg , nregs ) ; return ; } else abort ( ) ; if ( offset != nregs * reg_size ) abort ( ) ; fprintf ( asm_out_file , <STR_LIT> ) ; offset = <NUM_LIT> ; lastreg = <NUM_LIT> ; for ( i = <NUM_LIT> ; i <= nregs ; i ++ ) { e = XVECEXP ( p , <NUM_LIT> , i ) ; if ( GET_CODE ( e ) != SET || GET_CODE ( XEXP ( e , <NUM_LIT> ) ) != MEM || GET_CODE ( XEXP ( e , <NUM_LIT> ) ) != REG ) abort ( ) ; reg = REGNO ( XEXP ( e , <NUM_LIT> ) ) ; if ( reg < lastreg ) abort ( ) ;

if ( i != <NUM_LIT> ) fprintf ( asm_out_file , <STR_LIT> ) ;


<s> bool arm_vector_mode_supported_p ( enum machine_mode mode ) { if ( ( mode == V2SImode ) || ( mode == V4HImode ) || ( mode == V8QImode ) ) return true ;


<s> case MULT : if ( mode == DImode && ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == GET_CODE ( XEXP ( x , <NUM_LIT> ) ) ) && ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == ZERO_EXTEND || GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == SIGN_EXTEND ) ) { * total = <NUM_LIT> ; return true ; } if ( GET_MODE_CLASS ( mode ) == MODE_FLOAT || mode == DImode ) { * total = <NUM_LIT> ; return true ; } if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) { unsigned HOST_WIDE_INT i = ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) & ( unsigned HOST_WIDE_INT ) <NUM_LIT> ) ; int cost , const_ok = const_ok_for_arm ( i ) ; unsigned HOST_WIDE_INT masked_const ; cost = <NUM_LIT> ; if ( ! const_ok ) cost += <NUM_LIT> ; masked_const = i & <NUM_LIT> ; if ( masked_const != <NUM_LIT> && masked_const != <NUM_LIT> ) { masked_const = i & <NUM_LIT> ; if ( masked_const == <NUM_LIT> || masked_const == <NUM_LIT> ) cost += <NUM_LIT> ;


<s> if ( GET_CODE ( op ) == MEM ) { rtx ind ; ind = XEXP ( op , <NUM_LIT> ) ; if ( GET_CODE ( ind ) == REG ) return <NUM_LIT> ; if ( GET_CODE ( ind ) == PLUS && GET_CODE ( XEXP ( ind , <NUM_LIT> ) ) == REG && REG_MODE_OK_FOR_BASE_P ( XEXP ( ind , <NUM_LIT> ) , VOIDmode ) && GET_CODE ( XEXP ( ind , <NUM_LIT> ) ) == CONST_INT ) return <NUM_LIT> ; } return <NUM_LIT> ;


<s> gcc_assert ( GET_CODE ( rhs ) == REG ) ; arm_regno = REGNO ( rhs ) ; } first = next_nonnote_insn ( first ) ; if ( ! arm_cirrus_insn_p ( first ) ) return ; body = PATTERN ( first ) ; if ( GET_CODE ( body ) == PARALLEL && XVECLEN ( body , <NUM_LIT> ) ) body = XVECEXP ( body , <NUM_LIT> , <NUM_LIT> ) ; if ( GET_CODE ( body ) == FLOAT ) body = XEXP ( body , <NUM_LIT> ) ; if ( get_attr_cirrus ( first ) == CIRRUS_MOVE && GET_CODE ( XEXP ( body , <NUM_LIT> ) ) == REG && arm_regno == REGNO ( XEXP ( body , <NUM_LIT> ) ) ) emit_insn_after ( gen_nop ( ) , first ) ; return ; } } if ( ! first || GET_CODE ( first ) != INSN || GET_CODE ( PATTERN ( first ) ) == USE || GET_CODE ( PATTERN ( first ) ) == CLOBBER ) return ;


<s> if ( ( i & ~ ( unsigned HOST_WIDE_INT ) <NUM_LIT> ) == <NUM_LIT> ) return TRUE ; lowbit = ( ffs ( ( int ) i ) - <NUM_LIT> ) & ~ <NUM_LIT> ; if ( ( i & ~ ( ( ( unsigned HOST_WIDE_INT ) <NUM_LIT> ) << lowbit ) ) == <NUM_LIT> ) return TRUE ; else if ( lowbit <= <NUM_LIT> && ( ( i & ~ <NUM_LIT> ) == <NUM_LIT> || ( i & ~ <NUM_LIT> ) == <NUM_LIT> || ( i & ~ <NUM_LIT> ) == <NUM_LIT> ) ) return TRUE ;


<s> case PLUS : return const_ok_for_arm ( ARM_SIGN_EXTEND ( - i ) ) ; case MINUS : case XOR : case IOR : return <NUM_LIT> ;


<s> case PLUS : return const_ok_for_arm ( ARM_SIGN_EXTEND ( - i ) ) ; case MINUS : case XOR : case IOR :


<s> gcc_assert ( GET_CODE ( from ) != BARRIER ) ; count += get_attr_length ( from ) ; tmp = is_jump_table ( from ) ; if ( tmp != NULL ) { count += get_jump_table_size ( tmp ) ; new_cost = arm_barrier_cost ( from ) ; if ( count < max_count && new_cost <= selected_cost ) { selected = tmp ; selected_cost = new_cost ; selected_address = fix -> address + count ; } from = NEXT_INSN ( tmp ) ; continue ; } new_cost = arm_barrier_cost ( from ) ; if ( count < max_count && new_cost <= selected_cost ) { selected = from ; selected_cost = new_cost ; selected_address = fix -> address + count ; } from = NEXT_INSN ( from ) ; } from = emit_jump_insn_after ( gen_jump ( label ) , selected ) ; JUMP_LABEL ( from ) = label ; barrier = emit_barrier_after ( from ) ; emit_label_after ( label , barrier ) ; new_fix = ( Mfix * ) obstack_alloc ( & minipool_obstack , sizeof ( * new_fix ) ) ; new_fix -> insn = barrier ; new_fix -> address = selected_address ; new_fix -> next = fix -> next ; fix -> next = new_fix ; return new_fix ;


<s> count += get_attr_length ( from ) ; tmp = is_jump_table ( from ) ; if ( tmp != NULL ) { count += get_jump_table_size ( tmp ) ; new_cost = arm_barrier_cost ( from ) ; if ( count < max_count && new_cost <= selected_cost ) { selected = tmp ; selected_cost = new_cost ; selected_address = fix -> address + count ; } from = NEXT_INSN ( tmp ) ; continue ; } new_cost = arm_barrier_cost ( from ) ; if ( count < max_count && new_cost <= selected_cost ) { selected = from ; selected_cost = new_cost ; selected_address = fix -> address + count ; } from = NEXT_INSN ( from ) ; } from = emit_jump_insn_after ( gen_jump ( label ) , selected ) ; JUMP_LABEL ( from ) = label ; barrier = emit_barrier_after ( from ) ; emit_label_after ( label , barrier ) ; new_fix = ( Mfix * ) obstack_alloc ( & minipool_obstack , sizeof ( * new_fix ) ) ; new_fix -> insn = barrier ; new_fix -> address = selected_address ; new_fix -> next = fix -> next ;


<s> static int current_file_function_operand ( rtx sym_ref ) {

if ( ENCODED_SHORT_CALL_ATTR_P ( XSTR ( sym_ref , <NUM_LIT> ) ) ) return <NUM_LIT> ;


<s> static int current_file_function_operand ( rtx sym_ref ) { if ( ENCODED_SHORT_CALL_ATTR_P ( XSTR ( sym_ref , <NUM_LIT> ) ) ) return <NUM_LIT> ;

if ( sym_ref == XEXP ( DECL_RTL ( current_function_decl ) , <NUM_LIT> ) && ! DECL_WEAK ( current_function_decl ) ) return <NUM_LIT> ;


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


<s> int regs [ <NUM_LIT> ] ; int base_reg ; HOST_WIDE_INT offset ; char buf [ <NUM_LIT> ] ; int i ; switch ( load_multiple_sequence ( operands , nops , regs , & base_reg , & offset ) ) { case <NUM_LIT> : strcpy ( buf , <STR_LIT> ) ; break ; case <NUM_LIT> : strcpy ( buf , <STR_LIT> ) ; break ; case <NUM_LIT> : strcpy ( buf , <STR_LIT> ) ; break ; case <NUM_LIT> : strcpy ( buf , <STR_LIT> ) ; break ;


<s> for ( i = <NUM_LIT> ; i <= LAST_ARM_REGNUM ; i ++ ) { if ( mask & ( <NUM_LIT> << i ) ) { reg = gen_rtx_REG ( SImode , i ) ; XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_SET ( VOIDmode , gen_frame_mem ( BLKmode , gen_rtx_PRE_DEC ( BLKmode , stack_pointer_rtx ) ) , gen_rtx_UNSPEC ( BLKmode , gen_rtvec ( <NUM_LIT> , reg ) , UNSPEC_PUSH_MULT ) ) ; if ( i != PC_REGNUM ) { tmp = gen_rtx_SET ( VOIDmode , gen_frame_mem ( SImode , stack_pointer_rtx ) , reg ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( dwarf , <NUM_LIT> , dwarf_par_index ) = tmp ; dwarf_par_index ++ ; } break ; } } for ( j = <NUM_LIT> , i ++ ; j < num_regs ; i ++ ) {


<s> XVECEXP ( dwarf , <NUM_LIT> , <NUM_LIT> ) = tmp ; for ( i = <NUM_LIT> ; i < count ; i ++ ) { reg = gen_rtx_REG ( XFmode , base_reg ++ ) ; XVECEXP ( par , <NUM_LIT> , i ) = gen_rtx_USE ( VOIDmode , reg ) ; tmp = gen_rtx_SET ( VOIDmode , gen_frame_mem ( XFmode , plus_constant ( stack_pointer_rtx , i * <NUM_LIT> ) ) , reg ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( dwarf , <NUM_LIT> , i + <NUM_LIT> ) = tmp ; } tmp = gen_rtx_SET ( VOIDmode , stack_pointer_rtx , gen_rtx_PLUS ( SImode , stack_pointer_rtx , GEN_INT ( - <NUM_LIT> * count ) ) ) ;


<s> HOST_WIDE_INT offset ; char buf [ <NUM_LIT> ] ; int i ; switch ( store_multiple_sequence ( operands , nops , regs , & base_reg , & offset ) ) { case <NUM_LIT> : strcpy ( buf , <STR_LIT> ) ; break ; case <NUM_LIT> : strcpy ( buf , <STR_LIT> ) ; break ; case <NUM_LIT> : strcpy ( buf , <STR_LIT> ) ; break ; case <NUM_LIT> : strcpy ( buf , <STR_LIT> ) ; break ; default : gcc_unreachable ( ) ; }

sprintf ( buf + strlen ( buf ) , <STR_LIT> , REGISTER_PREFIX , reg_names [ base_reg ] , REGISTER_PREFIX , reg_names [ regs [ <NUM_LIT> ] ] ) ;


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

for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( REAL_VALUES_EQUAL ( * r , values_fp [ i ] ) ) return strings_fp [ i ] ;


<s> for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( REAL_VALUES_EQUAL ( * r , values_fp [ i ] ) ) return strings_fp [ i ] ; gcc_unreachable ( ) ;


<s> case CC_DGTUmode : code = ARM_HI ; goto dominance ; case CC_DLEUmode : code = ARM_LS ; goto dominance ; case CC_DLTUmode : code = ARM_CC ; dominance : gcc_assert ( comp_code == EQ || comp_code == NE ) ; if ( comp_code == EQ ) return ARM_INVERSE_CONDITION_CODE ( code ) ; return code ; case CC_NOOVmode : switch ( comp_code ) { case NE : return ARM_NE ; case EQ : return ARM_EQ ; case GE : return ARM_PL ; case LT : return ARM_MI ; default : gcc_unreachable ( ) ; } case CC_Zmode : switch ( comp_code ) { case NE : return ARM_NE ; case EQ : return ARM_EQ ; default : gcc_unreachable ( ) ; } case CC_Nmode : switch ( comp_code ) { case NE : return ARM_MI ; case EQ : return ARM_PL ; default : gcc_unreachable ( ) ; } case CCFPEmode : case CCFPmode : switch ( comp_code ) { case GE : return ARM_GE ; case GT : return ARM_GT ; case LE : return ARM_LS ; case LT : return ARM_MI ; case NE : return ARM_NE ; case EQ : return ARM_EQ ; case ORDERED : return ARM_VC ; case UNORDERED : return ARM_VS ; case UNLT : return ARM_LT ; case UNLE : return ARM_LE ; case UNGT : return ARM_HI ; case UNGE : return ARM_PL ; case UNEQ : case LTGT : default : gcc_unreachable ( ) ; } case CC_SWPmode : switch ( comp_code ) { case NE : return ARM_NE ; case EQ : return ARM_EQ ; case GE : return ARM_LE ; case GT : return ARM_LT ; case LE : return ARM_GE ; case LT : return ARM_GT ; case GEU : return ARM_LS ; case GTU : return ARM_CC ; case LEU : return ARM_CS ; case LTU : return ARM_HI ; default : gcc_unreachable ( ) ; } case CC_Cmode : switch ( comp_code ) { case LTU : return ARM_CS ; case GEU : return ARM_CC ; default : gcc_unreachable ( ) ; } case CCmode : switch ( comp_code ) { case NE : return ARM_NE ; case EQ : return ARM_EQ ; case GE : return ARM_GE ; case GT : return ARM_GT ; case LE : return ARM_LE ;


<s> rtx body = PATTERN ( insn ) ; int elt = GET_CODE ( body ) == ADDR_DIFF_VEC ? <NUM_LIT> : <NUM_LIT> ; return GET_MODE_SIZE ( GET_MODE ( body ) ) * XVECLEN ( body , elt ) ; }


<s> static HOST_WIDE_INT get_jump_table_size ( rtx insn ) { if ( JUMP_TABLES_IN_TEXT_SECTION || <NUM_LIT> ) { rtx body = PATTERN ( insn ) ;

int elt = GET_CODE ( body ) == ADDR_DIFF_VEC ? <NUM_LIT> : <NUM_LIT> ;


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


<s> REAL_VALUE_TYPE r ; if ( TARGET_VFP ) fp_consts_inited = <NUM_LIT> ; else fp_consts_inited = <NUM_LIT> ; for ( i = <NUM_LIT> ; i < fp_consts_inited ; i ++ ) { r = REAL_VALUE_ATOF ( strings_fp [ i ] , DFmode ) ; values_fp [ i ] = r ;


<s> while ( ( ( ( HOST_WIDE_INT ) <NUM_LIT> << shift ) & power ) == <NUM_LIT> ) { gcc_assert ( shift <= <NUM_LIT> ) ; shift ++ ; } return shift ;


<s> while ( ( ( ( HOST_WIDE_INT ) <NUM_LIT> << shift ) & power ) == <NUM_LIT> ) {


<s> int is_called_in_ARM_mode ( tree func ) { gcc_assert ( TREE_CODE ( func ) == FUNCTION_DECL ) ; if ( TARGET_CALLEE_INTERWORKING && TREE_PUBLIC ( func ) ) return TRUE ; return lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( func ) ) != NULL_TREE ;


<s> if ( GET_CODE ( insn ) == JUMP_INSN && JUMP_LABEL ( insn ) != NULL && ( ( table = next_real_insn ( JUMP_LABEL ( insn ) ) ) == next_real_insn ( insn ) ) && table != NULL && GET_CODE ( table ) == JUMP_INSN && ( GET_CODE ( PATTERN ( table ) ) == ADDR_VEC || GET_CODE ( PATTERN ( table ) ) == ADDR_DIFF_VEC ) ) return table ;


<s> rtx table ; if ( GET_CODE ( insn ) == JUMP_INSN && JUMP_LABEL ( insn ) != NULL && ( ( table = next_real_insn ( JUMP_LABEL ( insn ) ) ) == next_real_insn ( insn ) ) && table != NULL && GET_CODE ( table ) == JUMP_INSN && ( GET_CODE ( PATTERN ( table ) ) == ADDR_VEC || GET_CODE ( PATTERN ( table ) ) == ADDR_DIFF_VEC ) ) return table ;


<s> int legitimate_pic_operand_p ( rtx x ) {

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


<s> current_function_uses_pic_offset_table = <NUM_LIT> ; REG_NOTES ( insn ) = gen_rtx_EXPR_LIST ( REG_EQUAL , orig , REG_NOTES ( insn ) ) ; return reg ; } else if ( GET_CODE ( orig ) == CONST ) { rtx base , offset ; if ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == PLUS && XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) == pic_offset_table_rtx ) return orig ; if ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == UNSPEC && XINT ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) == UNSPEC_TLS ) return orig ; if ( reg == <NUM_LIT> ) { gcc_assert ( ! no_new_pseudos ) ; reg = gen_reg_rtx ( Pmode ) ; } gcc_assert ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == PLUS ) ; base = legitimize_pic_address ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) , Pmode , reg ) ; offset = legitimize_pic_address ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) , Pmode , base == reg ? <NUM_LIT> : reg ) ; if ( GET_CODE ( offset ) == CONST_INT ) { if ( ! arm_legitimate_index_p ( mode , offset , SET , <NUM_LIT> ) ) { gcc_assert ( ! no_new_pseudos ) ; offset = force_reg ( Pmode , offset ) ; } if ( GET_CODE ( offset ) == CONST_INT ) return plus_constant ( base , INTVAL ( offset ) ) ; } if ( GET_MODE_SIZE ( mode ) > <NUM_LIT> && ( GET_MODE_CLASS ( mode ) == MODE_INT || TARGET_SOFT_FLOAT ) ) { emit_insn ( gen_addsi3 ( reg , base , offset ) ) ; return reg ; }

return gen_rtx_PLUS ( Pmode , base , offset ) ;


<s> if ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == UNSPEC && XINT ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) == UNSPEC_TLS ) return orig ; if ( reg == <NUM_LIT> ) { gcc_assert ( ! no_new_pseudos ) ; reg = gen_reg_rtx ( Pmode ) ; } gcc_assert ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == PLUS ) ; base = legitimize_pic_address ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) , Pmode , reg ) ; offset = legitimize_pic_address ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) , Pmode , base == reg ? <NUM_LIT> : reg ) ; if ( GET_CODE ( offset ) == CONST_INT ) { if ( ! arm_legitimate_index_p ( mode , offset , SET , <NUM_LIT> ) ) { gcc_assert ( ! no_new_pseudos ) ; offset = force_reg ( Pmode , offset ) ; } if ( GET_CODE ( offset ) == CONST_INT ) return plus_constant ( base , INTVAL ( offset ) ) ; } if ( GET_MODE_SIZE ( mode ) > <NUM_LIT> && ( GET_MODE_CLASS ( mode ) == MODE_INT || TARGET_SOFT_FLOAT ) ) { emit_insn ( gen_addsi3 ( reg , base , offset ) ) ; return reg ; } return gen_rtx_PLUS ( Pmode , base , offset ) ; } return orig ;


<s> case TLS_MODEL_INITIAL_EXEC : labelno = GEN_INT ( pic_labelno ++ ) ; label = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , labelno ) , UNSPEC_PIC_LABEL ) ; label = gen_rtx_CONST ( VOIDmode , label ) ; sum = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , x , GEN_INT ( TLS_IE32 ) , label , GEN_INT ( TARGET_ARM ? <NUM_LIT> : <NUM_LIT> ) ) , UNSPEC_TLS ) ; reg = load_tls_operand ( sum , reg ) ; if ( TARGET_ARM ) emit_insn ( gen_tls_load_dot_plus_eight ( reg , reg , labelno ) ) ; else { emit_insn ( gen_pic_add_dot_plus_four ( reg , reg , labelno ) ) ; emit_move_insn ( reg , gen_const_mem ( SImode , reg ) ) ; } tp = arm_load_tp ( NULL_RTX ) ; return gen_rtx_PLUS ( Pmode , tp , reg ) ; case TLS_MODEL_LOCAL_EXEC :


<s> insns = arm_call_tls_get_addr ( x , reg , & ret , TLS_GD32 ) ; dest = gen_reg_rtx ( Pmode ) ; emit_libcall_block ( insns , dest , ret , x ) ; return dest ; case TLS_MODEL_LOCAL_DYNAMIC : insns = arm_call_tls_get_addr ( x , reg , & ret , TLS_LDM32 ) ; eqv = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , const1_rtx ) , UNSPEC_TLS ) ; dest = gen_reg_rtx ( Pmode ) ; emit_libcall_block ( insns , dest , ret , eqv ) ; addend = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , x , GEN_INT ( TLS_LDO32 ) ) , UNSPEC_TLS ) ; addend = force_reg ( SImode , gen_rtx_CONST ( SImode , addend ) ) ; return gen_rtx_PLUS ( Pmode , dest , addend ) ; case TLS_MODEL_INITIAL_EXEC : labelno = GEN_INT ( pic_labelno ++ ) ;

label = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , labelno ) , UNSPEC_PIC_LABEL ) ;


<s> order [ i ] = order [ i - <NUM_LIT> ] ; for ( j = <NUM_LIT> ; j < nops ; j ++ ) if ( unsorted_regs [ j ] > unsorted_regs [ order [ i - <NUM_LIT> ] ] && ( order [ i ] == order [ i - <NUM_LIT> ] || unsorted_regs [ j ] < unsorted_regs [ order [ i ] ] ) ) order [ i ] = j ; if ( order [ i ] == order [ i - <NUM_LIT> ] ) return <NUM_LIT> ; if ( unsorted_offsets [ order [ i ] ] != unsorted_offsets [ order [ i - <NUM_LIT> ] ] + <NUM_LIT> ) return <NUM_LIT> ; } if ( base ) { * base = base_reg ; for ( i = <NUM_LIT> ; i < nops ; i ++ ) regs [ i ] = unsorted_regs [ order [ i ] ] ; * load_offset = unsorted_offsets [ order [ <NUM_LIT> ] ] ; } if ( unsorted_offsets [ order [ <NUM_LIT> ] ] == <NUM_LIT> ) return <NUM_LIT> ; if ( unsorted_offsets [ order [ <NUM_LIT> ] ] == <NUM_LIT> ) return <NUM_LIT> ; if ( unsorted_offsets [ order [ nops - <NUM_LIT> ] ] == <NUM_LIT> ) return <NUM_LIT> ; if ( unsorted_offsets [ order [ nops - <NUM_LIT> ] ] == - <NUM_LIT> ) return <NUM_LIT> ; if ( nops == <NUM_LIT> && arm_ld_sched ) return <NUM_LIT> ;

return ( const_ok_for_arm ( unsorted_offsets [ order [ <NUM_LIT> ] ] ) || const_ok_for_arm ( - unsorted_offsets [ order [ <NUM_LIT> ] ] ) ) ? <NUM_LIT> : <NUM_LIT> ;


<s> if ( REAL_VALUE_MINUS_ZERO ( r ) ) return <NUM_LIT> ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( REAL_VALUES_EQUAL ( r , values_fp [ i ] ) ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> int i ; if ( ! fp_consts_inited ) init_fp_table ( ) ; REAL_VALUE_FROM_CONST_DOUBLE ( r , x ) ; r = REAL_VALUE_NEGATE ( r ) ;

if ( REAL_VALUE_MINUS_ZERO ( r ) ) return <NUM_LIT> ;


<s> if ( recog_data . operand_type [ opno ] != OP_IN ) continue ; if ( recog_op_alt [ opno ] [ which_alternative ] . memory_ok ) { rtx op = recog_data . operand [ opno ] ; if ( CONSTANT_P ( op ) ) { if ( do_pushes ) push_minipool_fix ( insn , address , recog_data . operand_loc [ opno ] , recog_data . operand_mode [ opno ] , op ) ; result = true ; }

else if ( GET_CODE ( op ) == MEM && GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P ( XEXP ( op , <NUM_LIT> ) ) ) {


<s> else if ( GET_CODE ( op ) == MEM && GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P ( XEXP ( op , <NUM_LIT> ) ) ) { if ( do_pushes ) { rtx cop = avoid_constant_pool_reference ( op ) ; if ( op == cop ) cop = get_pool_constant ( XEXP ( op , <NUM_LIT> ) ) ; push_minipool_fix ( insn , address , recog_data . operand_loc [ opno ] , recog_data . operand_mode [ opno ] , cop ) ; }


<s> for ( bit = <NUM_LIT> ; ( mask & ( <NUM_LIT> << bit ) ) == <NUM_LIT> ;


<s> } output_asm_insn ( <STR_LIT> , operands ) ; if ( TARGET_INTERWORK || arm_arch4t ) output_asm_insn ( <STR_LIT> , operands ) ;

else output_asm_insn ( <STR_LIT> , operands ) ;


<s> const char * output_call_mem ( rtx * operands ) { if ( TARGET_INTERWORK && ! arm_arch5 ) { output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; }

else if ( regno_use_in ( LR_REGNUM , operands [ <NUM_LIT> ] ) ) {


<s> int arm_reg0 = REGNO ( operands [ <NUM_LIT> ] ) ; rtx ops [ <NUM_LIT> ] ; gcc_assert ( arm_reg0 != IP_REGNUM ) ; ops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , arm_reg0 ) ; ops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , <NUM_LIT> + arm_reg0 ) ; output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , ops ) ;


<s> gcc_assert ( arm_reg0 != IP_REGNUM ) ; ops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , arm_reg0 ) ; ops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , <NUM_LIT> + arm_reg0 ) ; output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , ops ) ;


<s> rtx ops [ <NUM_LIT> ] ; gcc_assert ( arm_reg0 != IP_REGNUM ) ; ops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , arm_reg0 ) ; ops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , <NUM_LIT> + arm_reg0 ) ; output_asm_insn ( <STR_LIT> , ops ) ; output_asm_insn ( <STR_LIT> , operands ) ; return <STR_LIT> ;


<s> const char * output_mov_double_fpa_from_arm ( rtx * operands ) { int arm_reg0 = REGNO ( operands [ <NUM_LIT> ] ) ; rtx ops [ <NUM_LIT> ] ; gcc_assert ( arm_reg0 != IP_REGNUM ) ; ops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , arm_reg0 ) ;

ops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , <NUM_LIT> + arm_reg0 ) ;


<s> ops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , <NUM_LIT> + arm_reg0 ) ; output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , ops ) ;


<s> ops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , arm_reg0 ) ; ops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , <NUM_LIT> + arm_reg0 ) ; ops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , <NUM_LIT> + arm_reg0 ) ; output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , ops ) ;


<s> rtx ops [ <NUM_LIT> ] ; gcc_assert ( arm_reg0 != IP_REGNUM ) ; ops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , arm_reg0 ) ; ops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , <NUM_LIT> + arm_reg0 ) ; ops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , <NUM_LIT> + arm_reg0 ) ; output_asm_insn ( <STR_LIT> , ops ) ; output_asm_insn ( <STR_LIT> , operands ) ;


<s> if ( really_return ) { rtx ops [ <NUM_LIT> ] ; ops [ <NUM_LIT> ] = operand ; ops [ <NUM_LIT> ] = gen_rtx_SYMBOL_REF ( Pmode , NEED_PLT_RELOC ? <STR_LIT> : <STR_LIT> ) ; assemble_external_libcall ( ops [ <NUM_LIT> ] ) ; output_asm_insn ( reverse ? <STR_LIT> : <STR_LIT> , ops ) ; } return <STR_LIT> ; } gcc_assert ( ! current_function_calls_alloca || really_return ) ; sprintf ( conditional , <STR_LIT> , reverse ? 'D' : 'd' ) ; return_used_this_function = <NUM_LIT> ; live_regs_mask = arm_compute_save_reg_mask ( ) ; if ( live_regs_mask ) { const char * return_reg ; if ( really_return && ! TARGET_INTERWORK ) return_reg = reg_names [ PC_REGNUM ] ; else return_reg = reg_names [ LR_REGNUM ] ; if ( ( live_regs_mask & ( <NUM_LIT> << IP_REGNUM ) ) == ( <NUM_LIT> << IP_REGNUM ) ) { if ( frame_pointer_needed ) { live_regs_mask &= ~ ( <NUM_LIT> << IP_REGNUM ) ; live_regs_mask |= ( <NUM_LIT> << SP_REGNUM ) ; } else gcc_assert ( IS_INTERRUPT ( func_type ) || TARGET_REALLY_IWMMXT ) ; } for ( reg = <NUM_LIT> ; reg <= LAST_ARM_REGNUM ; reg ++ ) if ( live_regs_mask == ( <NUM_LIT> << reg ) ) break ; if ( reg <= LAST_ARM_REGNUM && ( reg != LR_REGNUM || ! really_return || ! IS_INTERRUPT ( func_type ) ) ) { 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 ; offsets = arm_get_frame_offsets ( ) ; stack_adjust = offsets -> outgoing_args - offsets -> saved_regs ; gcc_assert ( stack_adjust == <NUM_LIT> || stack_adjust == <NUM_LIT> ) ; if ( stack_adjust && arm_arch5 ) 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> ) ;


<s> unsigned i ; bool not_first = FALSE ; fputc ( '\t' , stream ) ; asm_fprintf ( stream , instr , reg ) ; fputs ( <STR_LIT> , stream ) ; for ( i = <NUM_LIT> ; i <= LAST_ARM_REGNUM ; i ++ ) if ( mask & ( <NUM_LIT> << i ) ) { if ( not_first ) fprintf ( stream , <STR_LIT> ) ; asm_fprintf ( stream , <STR_LIT> , i ) ; not_first = TRUE ;


<s> fputc ( '\t' , stream ) ; asm_fprintf ( stream , instr , reg ) ; fputs ( <STR_LIT> , stream ) ; for ( i = <NUM_LIT> ; i <= LAST_ARM_REGNUM ; i ++ ) if ( mask & ( <NUM_LIT> << i ) ) { if ( not_first ) fprintf ( stream , <STR_LIT> ) ; asm_fprintf ( stream , <STR_LIT> , i ) ; not_first = TRUE ;


<s> static void push_minipool_barrier ( rtx insn , HOST_WIDE_INT address ) { Mfix * fix = ( Mfix * ) obstack_alloc ( & minipool_obstack , sizeof ( * fix ) ) ; fix -> insn = insn ; fix -> address = address ; fix -> next = NULL ;

if ( minipool_fix_head != NULL ) minipool_fix_tail -> next = fix ;


<s> fix -> address = address ; fix -> loc = loc ; fix -> mode = mode ; fix -> fix_size = MINIPOOL_FIX_SIZE ( mode ) ; fix -> value = value ; fix -> forwards = get_attr_pool_range ( insn ) ; fix -> backwards = get_attr_neg_pool_range ( insn ) ; fix -> minipool = NULL ; gcc_assert ( fix -> forwards || fix -> backwards ) ; if ( ARM_DOUBLEWORD_ALIGN && fix -> fix_size == <NUM_LIT> ) fix -> forwards -= <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 ) ;


<s> 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 ; minipool_fix_tail = fix ;


<s> break ; case MULT : gcc_assert ( * amountp != - <NUM_LIT> ) ; * amountp = int_log2 ( * amountp ) ; return <STR_LIT> ; default : gcc_unreachable ( ) ; } if ( * amountp != - <NUM_LIT> ) { if ( code == ROTATERT ) * amountp &= <NUM_LIT> ; else if ( * amountp != ( * amountp & <NUM_LIT> ) ) { if ( code == ASHIFT ) mnem = <STR_LIT> ; * amountp = <NUM_LIT> ; }

if ( * amountp == <NUM_LIT> ) return NULL ;


<s> for ( i = <NUM_LIT> ; i < nops ; i ++ ) { int j ; order [ i ] = order [ i - <NUM_LIT> ] ; for ( j = <NUM_LIT> ; j < nops ; j ++ ) if ( unsorted_regs [ j ] > unsorted_regs [ order [ i - <NUM_LIT> ] ] && ( order [ i ] == order [ i - <NUM_LIT> ] || unsorted_regs [ j ] < unsorted_regs [ order [ i ] ] ) ) order [ i ] = j ; if ( order [ i ] == order [ i - <NUM_LIT> ] ) return <NUM_LIT> ; if ( unsorted_offsets [ order [ i ] ] != unsorted_offsets [ order [ i - <NUM_LIT> ] ] + <NUM_LIT> ) return <NUM_LIT> ; } if ( base ) { * base = base_reg ; for ( i = <NUM_LIT> ; i < nops ; i ++ ) regs [ i ] = unsorted_regs [ order [ i ] ] ; * load_offset = unsorted_offsets [ order [ <NUM_LIT> ] ] ; } if ( unsorted_offsets [ order [ <NUM_LIT> ] ] == <NUM_LIT> ) return <NUM_LIT> ; if ( unsorted_offsets [ order [ <NUM_LIT> ] ] == <NUM_LIT> ) return <NUM_LIT> ; if ( unsorted_offsets [ order [ nops - <NUM_LIT> ] ] == <NUM_LIT> ) return <NUM_LIT> ; if ( unsorted_offsets [ order [ nops - <NUM_LIT> ] ] == - <NUM_LIT> ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> const char * thumb_call_via_reg ( rtx reg ) { int regno = REGNO ( reg ) ; rtx * labelp ; gcc_assert ( regno < LR_REGNUM ) ; if ( in_text_section ( ) ) { thumb_call_reg_needed = <NUM_LIT> ; if ( thumb_call_via_label [ regno ] == NULL ) thumb_call_via_label [ regno ] = gen_label_rtx ( ) ; labelp = thumb_call_via_label + regno ; } else { if ( cfun -> machine -> call_via [ regno ] == NULL ) cfun -> machine -> call_via [ regno ] = gen_label_rtx ( ) ; labelp = cfun -> machine -> call_via + regno ;


<s> else { if ( cfun -> machine -> call_via [ regno ] == NULL ) cfun -> machine -> call_via [ regno ] = gen_label_rtx ( ) ; labelp = cfun -> machine -> call_via + regno ; } output_asm_insn ( <STR_LIT> , labelp ) ;


<s> 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 ( ! call_used_regs [ reg ] ) mask |= <NUM_LIT> << reg ; } return mask ;


<s> 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_pushpop ( f , regs_available_for_popping , FALSE , NULL , 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 ) { int stack_pointer ; stack_pointer = number_of_first_bit_set ( regs_available_for_popping ) ; asm_fprintf ( f , <STR_LIT> , SP_REGNUM , stack_pointer ) ; } else { regs_available_for_popping |= ( <NUM_LIT> << frame_pointer ) ; } } if ( regs_available_for_popping == <NUM_LIT> && pops_needed > <NUM_LIT> ) { regs_available_for_popping |= <NUM_LIT> << reg_containing_return_addr ; asm_fprintf ( f , <STR_LIT> , LR_REGNUM , reg_containing_return_addr ) ; reg_containing_return_addr = LR_REGNUM ; } if ( pops_needed > <NUM_LIT> ) { int popped_into ; int move_to ; thumb_pushpop ( f , regs_available_for_popping , FALSE , NULL , regs_available_for_popping ) ;


<s> if ( frame_pointer_needed ) { emit_insn ( gen_movsi ( stack_pointer_rtx , hard_frame_pointer_rtx ) ) ; amount = offsets -> locals_base - offsets -> saved_regs ; } if ( amount ) { if ( amount < <NUM_LIT> ) emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( amount ) ) ) ; else { rtx reg = gen_rtx_REG ( SImode , LAST_ARG_REGNUM ) ; emit_insn ( gen_movsi ( reg , GEN_INT ( amount ) ) ) ; emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , reg ) ) ;


<s> if ( len >= <NUM_LIT> ) { emit_insn ( gen_movmem8b ( out , in , out , in ) ) ; len -= <NUM_LIT> ; } if ( len >= <NUM_LIT> ) { rtx reg = gen_reg_rtx ( SImode ) ; emit_insn ( gen_movsi ( reg , gen_rtx_MEM ( SImode , in ) ) ) ; emit_insn ( gen_movsi ( gen_rtx_MEM ( SImode , out ) , reg ) ) ; len -= <NUM_LIT> ; offset += <NUM_LIT> ; } if ( len >= <NUM_LIT> ) { rtx reg = gen_reg_rtx ( HImode ) ;

emit_insn ( gen_movhi ( reg , gen_rtx_MEM ( HImode , plus_constant ( in , offset ) ) ) ) ;


<s> while ( len >= <NUM_LIT> ) { emit_insn ( gen_movmem12b ( out , in , out , in ) ) ; len -= <NUM_LIT> ; } if ( len >= <NUM_LIT> ) { emit_insn ( gen_movmem8b ( out , in , out , in ) ) ; len -= <NUM_LIT> ; } if ( len >= <NUM_LIT> ) { rtx reg = gen_reg_rtx ( SImode ) ; emit_insn ( gen_movsi ( reg , gen_rtx_MEM ( SImode , in ) ) ) ; emit_insn ( gen_movsi ( gen_rtx_MEM ( SImode , out ) , reg ) ) ; len -= <NUM_LIT> ; offset += <NUM_LIT> ; } if ( len >= <NUM_LIT> ) { rtx reg = gen_reg_rtx ( HImode ) ; emit_insn ( gen_movhi ( reg , gen_rtx_MEM ( HImode , plus_constant ( in , offset ) ) ) ) ; emit_insn ( gen_movhi ( gen_rtx_MEM ( HImode , plus_constant ( 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 ( in , offset ) ) ) ) ;


<s> rtx reg ; for ( regno = LAST_ARG_REGNUM + <NUM_LIT> ; regno <= LAST_LO_REGNUM ; regno ++ ) if ( live_regs_mask & ( <NUM_LIT> << regno ) && ! ( frame_pointer_needed && ( regno == THUMB_HARD_FRAME_POINTER_REGNUM ) ) ) break ; if ( regno > LAST_LO_REGNUM ) { rtx spare = gen_rtx_REG ( SImode , IP_REGNUM ) ; reg = gen_rtx_REG ( SImode , LAST_LO_REGNUM ) ; emit_insn ( gen_movsi ( spare , reg ) ) ; emit_insn ( gen_prologue_use ( spare ) ) ; emit_insn ( gen_movsi ( reg , GEN_INT ( - amount ) ) ) ; insn = emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , reg ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; dwarf = gen_rtx_SET ( SImode , stack_pointer_rtx , plus_constant ( stack_pointer_rtx , - amount ) ) ; RTX_FRAME_RELATED_P ( dwarf ) = <NUM_LIT> ; REG_NOTES ( insn ) = gen_rtx_EXPR_LIST ( REG_FRAME_RELATED_EXPR , dwarf , REG_NOTES ( insn ) ) ; emit_insn ( gen_movsi ( reg , spare ) ) ; emit_insn ( gen_prologue_use ( reg ) ) ; } else { reg = gen_rtx_REG ( SImode , regno ) ; emit_insn ( gen_movsi ( reg , GEN_INT ( - amount ) ) ) ; insn = emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , reg ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; dwarf = gen_rtx_SET ( SImode , stack_pointer_rtx , plus_constant ( stack_pointer_rtx , - amount ) ) ; RTX_FRAME_RELATED_P ( dwarf ) = <NUM_LIT> ; REG_NOTES ( insn ) = gen_rtx_EXPR_LIST ( REG_FRAME_RELATED_EXPR , dwarf , REG_NOTES ( insn ) ) ; } } } if ( frame_pointer_needed ) { 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 ) ) ) ;


<s> static int thumb_far_jump_used_p ( void ) { rtx insn ; if ( cfun -> machine -> far_jump_used ) return <NUM_LIT> ; if ( ! ( ARM_DOUBLEWORD_ALIGN || reload_completed ) ) { if ( regs_ever_live [ ARG_POINTER_REGNUM ] ) cfun -> machine -> arg_pointer_live = <NUM_LIT> ; else if ( ! cfun -> machine -> arg_pointer_live ) return <NUM_LIT> ; }

for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) {


<s> void thumb_final_prescan_insn ( rtx insn ) {

if ( flag_print_asm_name ) asm_fprintf ( asm_out_file , <STR_LIT> , INSN_ADDRESSES ( INSN_UID ( insn ) ) ) ;


<s> if ( cfun -> machine -> uses_anonymous_args && current_function_pretend_args_size > <NUM_LIT> ) return LAST_ARG_REGNUM ; if ( ! cfun -> machine -> uses_anonymous_args && current_function_args_size >= <NUM_LIT> && current_function_args_size <= ( LAST_ARG_REGNUM * UNITS_PER_WORD ) && cfun -> 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 ; gcc_unreachable ( ) ;


<s> static bool thumb_force_lr_save ( void ) {

return ! cfun -> machine -> lr_save_eliminated && ( ! leaf_function_p ( ) || thumb_far_jump_used_p ( ) || regs_ever_live [ LR_REGNUM ] ) ;


<s> return thumb_base_register_rtx_p ( x , QImode , strict_p ) ;


<s> else if ( GET_MODE_SIZE ( mode ) >= <NUM_LIT> && reload_completed && ( GET_CODE ( x ) == LABEL_REF || ( GET_CODE ( x ) == CONST && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == LABEL_REF && GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == CONST_INT ) ) ) return <NUM_LIT> ; else if ( GET_CODE ( x ) == POST_INC && GET_MODE_SIZE ( mode ) >= <NUM_LIT> && thumb_index_register_rtx_p ( XEXP ( x , <NUM_LIT> ) , strict_p ) ) return <NUM_LIT> ; else if ( GET_CODE ( x ) == PLUS ) {

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


<s> else if ( ( thumb_index_register_rtx_p ( XEXP ( x , <NUM_LIT> ) , strict_p ) || XEXP ( x , <NUM_LIT> ) == arg_pointer_rtx ) && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT && thumb_legitimate_offset_p ( mode , INTVAL ( XEXP ( x , <NUM_LIT> ) ) ) ) return <NUM_LIT> ; else if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == REG && REGNO ( XEXP ( x , <NUM_LIT> ) ) == STACK_POINTER_REGNUM && GET_MODE_SIZE ( mode ) >= <NUM_LIT> && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT && 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 ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == REG && REGNO ( XEXP ( x , <NUM_LIT> ) ) == FRAME_POINTER_REGNUM && GET_MODE_SIZE ( mode ) >= <NUM_LIT> && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT && ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) & <NUM_LIT> ) == <NUM_LIT> ) return <NUM_LIT> ;


<s> switch ( GET_MODE_SIZE ( mode ) ) { case <NUM_LIT> : return val >= <NUM_LIT> && val < <NUM_LIT> ; case <NUM_LIT> : return val >= <NUM_LIT> && val < <NUM_LIT> && ( val & <NUM_LIT> ) == <NUM_LIT> ; default : return ( val >= <NUM_LIT> && ( val + GET_MODE_SIZE ( mode ) ) <= <NUM_LIT> && ( val & <NUM_LIT> ) == <NUM_LIT> ) ;


<s> default : return ( val >= <NUM_LIT> && ( val + GET_MODE_SIZE ( mode ) ) <= <NUM_LIT> && ( val & <NUM_LIT> ) == <NUM_LIT> ) ;


<s> 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> ) ) ; } if ( flag_pic ) { rtx new_x = legitimize_pic_address ( orig_x , mode , NULL_RTX ) ;


<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 && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT && ! 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 , 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 ) ;


<s> rtx x = * x_p ; if ( GET_CODE ( x ) == PLUS && GET_MODE_SIZE ( mode ) < <NUM_LIT> && REG_P ( XEXP ( x , <NUM_LIT> ) ) && XEXP ( x , <NUM_LIT> ) == stack_pointer_rtx && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT && ! 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 , type ) ; return x ;


<s> case CONST : operands [ <NUM_LIT> ] = adjust_address ( operands [ <NUM_LIT> ] , SImode , <NUM_LIT> ) ; output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; break ; case PLUS : arg1 = XEXP ( addr , <NUM_LIT> ) ; arg2 = XEXP ( addr , <NUM_LIT> ) ; if ( CONSTANT_P ( arg1 ) ) base = arg2 , offset = arg1 ; else base = arg1 , offset = arg2 ; gcc_assert ( GET_CODE ( base ) == REG ) ; if ( GET_CODE ( offset ) == REG ) { int reg_offset = REGNO ( offset ) ; int reg_base = REGNO ( base ) ; int reg_dest = REGNO ( operands [ <NUM_LIT> ] ) ; asm_fprintf ( asm_out_file , <STR_LIT> , reg_dest + <NUM_LIT> , reg_base , reg_offset ) ; asm_fprintf ( asm_out_file , <STR_LIT> , reg_dest , reg_dest + <NUM_LIT> ) ; asm_fprintf ( asm_out_file , <STR_LIT> , reg_dest + <NUM_LIT> , reg_dest + <NUM_LIT> ) ; } else { operands [ <NUM_LIT> ] = adjust_address ( operands [ <NUM_LIT> ] , SImode , <NUM_LIT> ) ; if ( REGNO ( operands [ <NUM_LIT> ] ) == REGNO ( base ) ) { output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; } else { output_asm_insn ( <STR_LIT> , operands ) ;


<s> work_register = thumb_find_work_register ( live_regs_mask ) ; if ( ARM_EABI_UNWIND_TABLES ) asm_fprintf ( f , <STR_LIT> ) ; asm_fprintf ( f , <STR_LIT> , SP_REGNUM , SP_REGNUM ) ; if ( dwarf2out_do_frame ( ) ) { char * l = dwarf2out_cfi_label ( ) ; cfa_offset = cfa_offset + <NUM_LIT> ; dwarf2out_def_cfa ( l , SP_REGNUM , cfa_offset ) ; } if ( l_mask ) { thumb_pushpop ( f , l_mask , <NUM_LIT> , & cfa_offset , l_mask ) ; offset = bit_count ( l_mask ) * UNITS_PER_WORD ; } else offset = <NUM_LIT> ; asm_fprintf ( f , <STR_LIT> , work_register , SP_REGNUM , offset + <NUM_LIT> + current_function_pretend_args_size ) ; asm_fprintf ( f , <STR_LIT> , work_register , SP_REGNUM , offset + <NUM_LIT> ) ; if ( l_mask ) { asm_fprintf ( f , <STR_LIT> , work_register , PC_REGNUM ) ; asm_fprintf ( f , <STR_LIT> , work_register , SP_REGNUM , offset + <NUM_LIT> ) ; asm_fprintf ( f , <STR_LIT> , work_register , ARM_HARD_FRAME_POINTER_REGNUM ) ; asm_fprintf ( f , <STR_LIT> , work_register , SP_REGNUM , offset ) ; } else { asm_fprintf ( f , <STR_LIT> , work_register , ARM_HARD_FRAME_POINTER_REGNUM ) ; asm_fprintf ( f , <STR_LIT> , work_register , SP_REGNUM , offset ) ; asm_fprintf ( f , <STR_LIT> , work_register , PC_REGNUM ) ; asm_fprintf ( f , <STR_LIT> , work_register , SP_REGNUM , offset + <NUM_LIT> ) ; } asm_fprintf ( f , <STR_LIT> , work_register , LR_REGNUM ) ; asm_fprintf ( f , <STR_LIT> , work_register , SP_REGNUM , offset + <NUM_LIT> ) ; asm_fprintf ( f , <STR_LIT> , work_register , SP_REGNUM , offset + <NUM_LIT> ) ; asm_fprintf ( f , <STR_LIT> , ARM_HARD_FRAME_POINTER_REGNUM , work_register ) ; } else if ( ( l_mask & <NUM_LIT> ) != <NUM_LIT> || ( high_regs_pushed == <NUM_LIT> && l_mask ) ) thumb_pushpop ( f , l_mask , <NUM_LIT> , & cfa_offset , l_mask ) ; if ( high_regs_pushed ) {


<s> thumb_pushpop ( f , l_mask , <NUM_LIT> , & cfa_offset , l_mask ) ; offset = bit_count ( l_mask ) * UNITS_PER_WORD ; } else offset = <NUM_LIT> ; asm_fprintf ( f , <STR_LIT> , work_register , SP_REGNUM , offset + <NUM_LIT> + current_function_pretend_args_size ) ; asm_fprintf ( f , <STR_LIT> , work_register , SP_REGNUM , offset + <NUM_LIT> ) ; if ( l_mask ) { asm_fprintf ( f , <STR_LIT> , work_register , PC_REGNUM ) ; asm_fprintf ( f , <STR_LIT> , work_register , SP_REGNUM , offset + <NUM_LIT> ) ; asm_fprintf ( f , <STR_LIT> , work_register , ARM_HARD_FRAME_POINTER_REGNUM ) ; asm_fprintf ( f , <STR_LIT> , work_register , SP_REGNUM , offset ) ; } else { asm_fprintf ( f , <STR_LIT> , work_register , ARM_HARD_FRAME_POINTER_REGNUM ) ; asm_fprintf ( f , <STR_LIT> , work_register , SP_REGNUM , offset ) ; asm_fprintf ( f , <STR_LIT> , work_register , PC_REGNUM ) ; asm_fprintf ( f , <STR_LIT> , work_register , SP_REGNUM , offset + <NUM_LIT> ) ; } asm_fprintf ( f , <STR_LIT> , work_register , LR_REGNUM ) ; asm_fprintf ( f , <STR_LIT> , work_register , SP_REGNUM , offset + <NUM_LIT> ) ; asm_fprintf ( f , <STR_LIT> , work_register , SP_REGNUM , offset + <NUM_LIT> ) ; asm_fprintf ( f , <STR_LIT> , ARM_HARD_FRAME_POINTER_REGNUM , work_register ) ; } else if ( ( l_mask & <NUM_LIT> ) != <NUM_LIT> || ( high_regs_pushed == <NUM_LIT> && l_mask ) ) thumb_pushpop ( f , l_mask , <NUM_LIT> , & cfa_offset , l_mask ) ; if ( high_regs_pushed ) { unsigned pushable_regs ; unsigned next_hi_reg ; for ( next_hi_reg = <NUM_LIT> ; next_hi_reg > LAST_LO_REGNUM ; next_hi_reg -- ) if ( live_regs_mask & ( <NUM_LIT> << next_hi_reg ) ) break ; pushable_regs = l_mask & <NUM_LIT> ; if ( pushable_regs == <NUM_LIT> ) pushable_regs = <NUM_LIT> << thumb_find_work_register ( live_regs_mask ) ; while ( high_regs_pushed > <NUM_LIT> ) { unsigned long real_regs_mask = <NUM_LIT> ; for ( regno = LAST_LO_REGNUM ; regno >= <NUM_LIT> ; regno -- ) { if ( pushable_regs & ( <NUM_LIT> << regno ) ) { asm_fprintf ( f , <STR_LIT> , regno , next_hi_reg ) ; high_regs_pushed -- ; real_regs_mask |= ( <NUM_LIT> << next_hi_reg ) ; if ( high_regs_pushed ) { for ( next_hi_reg -- ; next_hi_reg > LAST_LO_REGNUM ; next_hi_reg -- ) if ( live_regs_mask & ( <NUM_LIT> << next_hi_reg ) ) break ; }


<s> tmp = operands [ <NUM_LIT> ] ; operands [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; operands [ <NUM_LIT> ] = tmp ; } output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; break ; case <NUM_LIT> : if ( REGNO ( operands [ <NUM_LIT> ] ) > REGNO ( operands [ <NUM_LIT> ] ) ) { tmp = operands [ <NUM_LIT> ] ; operands [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; operands [ <NUM_LIT> ] = tmp ; } if ( REGNO ( operands [ <NUM_LIT> ] ) > REGNO ( operands [ <NUM_LIT> ] ) ) { tmp = operands [ <NUM_LIT> ] ; operands [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; operands [ <NUM_LIT> ] = tmp ; } if ( REGNO ( operands [ <NUM_LIT> ] ) > REGNO ( operands [ <NUM_LIT> ] ) ) { tmp = operands [ <NUM_LIT> ] ;


<s> switch ( code ) { case ASHIFT : case ASHIFTRT : case LSHIFTRT : case ROTATERT : case PLUS : case MINUS : case COMPARE : case NEG : case NOT : return COSTS_N_INSNS ( <NUM_LIT> ) ; case MULT : if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) { int cycles = <NUM_LIT> ; unsigned HOST_WIDE_INT i = INTVAL ( XEXP ( x , <NUM_LIT> ) ) ; while ( i ) { i >>= <NUM_LIT> ; cycles ++ ; } return COSTS_N_INSNS ( <NUM_LIT> ) + cycles ; } return COSTS_N_INSNS ( <NUM_LIT> ) + <NUM_LIT> ; case SET : return ( COSTS_N_INSNS ( <NUM_LIT> ) + <NUM_LIT> * ( ( GET_CODE ( SET_SRC ( x ) ) == MEM ) + GET_CODE ( SET_DEST ( x ) ) == MEM ) ) ; case CONST_INT : if ( outer == SET ) { if ( ( unsigned HOST_WIDE_INT ) INTVAL ( x ) < <NUM_LIT> ) return <NUM_LIT> ; if ( thumb_shiftable_const ( INTVAL ( x ) ) ) return COSTS_N_INSNS ( <NUM_LIT> ) ;


<s> if ( frame_pointer_needed ) { delta = offsets -> soft_frame - offsets -> saved_args ; reg = THUMB_HARD_FRAME_POINTER_REGNUM ; } else { delta = offsets -> outgoing_args - offsets -> saved_args ; reg = SP_REGNUM ; } if ( TARGET_BACKTRACE ) delta -= <NUM_LIT> ; delta -= <NUM_LIT> ; addr = gen_rtx_REG ( SImode , reg ) ; if ( ( reg != SP_REGNUM && delta >= <NUM_LIT> ) || delta >= <NUM_LIT> ) { emit_insn ( gen_movsi ( scratch , GEN_INT ( delta ) ) ) ; emit_insn ( gen_addsi3 ( scratch , scratch , stack_pointer_rtx ) ) ; addr = scratch ; } else addr = plus_constant ( addr , delta ) ; emit_move_insn ( gen_frame_mem ( Pmode , addr ) , source ) ; }

else emit_move_insn ( gen_rtx_REG ( Pmode , LR_REGNUM ) , source ) ;


<s> delta = offsets -> outgoing_args - offsets -> saved_args ; reg = SP_REGNUM ; } if ( TARGET_BACKTRACE ) delta -= <NUM_LIT> ; delta -= <NUM_LIT> ; addr = gen_rtx_REG ( SImode , reg ) ; if ( ( reg != SP_REGNUM && delta >= <NUM_LIT> ) || delta >= <NUM_LIT> ) { emit_insn ( gen_movsi ( scratch , GEN_INT ( delta ) ) ) ; emit_insn ( gen_addsi3 ( scratch , scratch , stack_pointer_rtx ) ) ;


<s> int thumb_shiftable_const ( unsigned HOST_WIDE_INT val ) { unsigned HOST_WIDE_INT mask = <NUM_LIT> ; int i ; if ( val == <NUM_LIT> ) return <NUM_LIT> ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( ( val & ( mask << i ) ) == val ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> offsets = arm_get_frame_offsets ( ) ; stack_adjust = offsets -> outgoing_args - offsets -> saved_regs ; if ( current_function_pretend_args_size || cfun -> machine -> uses_anonymous_args || current_function_calls_eh_return || current_function_calls_alloca || ! ( stack_adjust == <NUM_LIT> || ( frame_pointer_needed && stack_adjust == <NUM_LIT> ) ) ) return <NUM_LIT> ; saved_int_regs = arm_compute_save_reg_mask ( ) ; if ( stack_adjust == <NUM_LIT> && ! arm_arch5 ) { 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 ( GET_CODE ( sibling ) == CALL_INSN ) ; 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> ) return <NUM_LIT> ;


<s> rtx tmp , reg ; int i ; if ( count == <NUM_LIT> && ! arm_arch6 ) { if ( base_reg == LAST_VFP_REGNUM - <NUM_LIT> ) base_reg -= <NUM_LIT> ; count ++ ; } par = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( count ) ) ; dwarf = gen_rtx_SEQUENCE ( VOIDmode , rtvec_alloc ( count + <NUM_LIT> ) ) ; reg = gen_rtx_REG ( DFmode , base_reg ) ; base_reg += <NUM_LIT> ; XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_SET ( VOIDmode , gen_frame_mem ( BLKmode , gen_rtx_PRE_DEC ( BLKmode , stack_pointer_rtx ) ) , gen_rtx_UNSPEC ( BLKmode , gen_rtvec ( <NUM_LIT> , reg ) , UNSPEC_PUSH_MULT ) ) ; tmp = gen_rtx_SET ( VOIDmode , stack_pointer_rtx , gen_rtx_PLUS ( SImode , stack_pointer_rtx , GEN_INT ( - ( count * <NUM_LIT> + <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 ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( dwarf , <NUM_LIT> , <NUM_LIT> ) = tmp ; for ( i = <NUM_LIT> ; i < count ; i ++ ) { reg = gen_rtx_REG ( DFmode , base_reg ) ; base_reg += <NUM_LIT> ; XVECEXP ( par , <NUM_LIT> , i ) = gen_rtx_USE ( VOIDmode , reg ) ; tmp = gen_rtx_SET ( VOIDmode , gen_frame_mem ( DFmode , gen_rtx_PLUS ( SImode , stack_pointer_rtx , GEN_INT ( i * <NUM_LIT> ) ) ) , reg ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( dwarf , <NUM_LIT> , i + <NUM_LIT> ) = tmp ; } par = emit_insn ( par ) ; REG_NOTES ( par ) = gen_rtx_EXPR_LIST ( REG_FRAME_RELATED_EXPR , dwarf , REG_NOTES ( par ) ) ;

RTX_FRAME_RELATED_P ( par ) = <NUM_LIT> ;


<s> if ( count == <NUM_LIT> && ! arm_arch6 ) { if ( base_reg == LAST_VFP_REGNUM - <NUM_LIT> ) base_reg -= <NUM_LIT> ; count ++ ; } par = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( count ) ) ; dwarf = gen_rtx_SEQUENCE ( VOIDmode , rtvec_alloc ( count + <NUM_LIT> ) ) ; reg = gen_rtx_REG ( DFmode , base_reg ) ; base_reg += <NUM_LIT> ; XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_SET ( VOIDmode , gen_frame_mem ( BLKmode , gen_rtx_PRE_DEC ( BLKmode , stack_pointer_rtx ) ) , gen_rtx_UNSPEC ( BLKmode , gen_rtvec ( <NUM_LIT> , reg ) , UNSPEC_PUSH_MULT ) ) ; tmp = gen_rtx_SET ( VOIDmode , stack_pointer_rtx , gen_rtx_PLUS ( SImode , stack_pointer_rtx , GEN_INT ( - ( count * <NUM_LIT> + <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 ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( dwarf , <NUM_LIT> , <NUM_LIT> ) = tmp ; for ( i = <NUM_LIT> ; i < count ; i ++ ) { reg = gen_rtx_REG ( DFmode , base_reg ) ; base_reg += <NUM_LIT> ; XVECEXP ( par , <NUM_LIT> , i ) = gen_rtx_USE ( VOIDmode , reg ) ;

tmp = gen_rtx_SET ( VOIDmode , gen_frame_mem ( DFmode , gen_rtx_PLUS ( SImode , stack_pointer_rtx , GEN_INT ( i * <NUM_LIT> ) ) ) , reg ) ;


<s> gcc_assert ( GET_CODE ( operands [ <NUM_LIT> ] ) == REG ) ; base = ( REGNO ( operands [ <NUM_LIT> ] ) - FIRST_VFP_REGNUM ) / <NUM_LIT> ; for ( i = <NUM_LIT> ; i < XVECLEN ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ; i ++ ) { p += sprintf ( & pattern [ p ] , <STR_LIT> , base + i ) ; } strcpy ( & pattern [ p ] , <STR_LIT> ) ;

output_asm_insn ( pattern , operands ) ;


<s> int base ; int i ; strcpy ( pattern , <STR_LIT> ) ; p = strlen ( pattern ) ; gcc_assert ( GET_CODE ( operands [ <NUM_LIT> ] ) == REG ) ; base = ( REGNO ( operands [ <NUM_LIT> ] ) - FIRST_VFP_REGNUM ) / <NUM_LIT> ; for ( i = <NUM_LIT> ; i < XVECLEN ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ; i ++ ) { p += sprintf ( & pattern [ p ] , <STR_LIT> , base + i ) ; } strcpy ( & pattern [ p ] , <STR_LIT> ) ; output_asm_insn ( pattern , operands ) ;


<s> enum reg_class vfp_secondary_reload_class ( enum machine_mode mode , rtx x ) { if ( arm_coproc_mem_operand ( x , FALSE ) || s_register_operand ( x , mode ) ) return NO_REGS ; return GENERAL_REGS ;


<s> fndecl = fntype ; fntype = TREE_TYPE ( fntype ) ; } pcs_variant = arm_get_pcs_model ( fntype , fndecl ) ; } else pcs_variant = arm_pcs_default ; if ( type && INTEGRAL_TYPE_P ( type ) ) mode = arm_promote_function_mode ( type , mode , & unsignedp , fntype , <NUM_LIT> ) ; if ( pcs_variant != ARM_PCS_AAPCS ) { int i ;

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


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


<s> if ( pcum -> pcs_variant != ARM_PCS_AAPCS ) { int slot = aapcs_select_call_coproc ( pcum , mode , type ) ; pcum -> aapcs_cprc_slot = slot ; if ( slot >= <NUM_LIT> ) { if ( ! pcum -> aapcs_cprc_failed [ slot ] ) { if ( aapcs_cp_arg_layout [ slot ] . allocate ( pcum , mode , type ) ) return ; pcum -> aapcs_cprc_failed [ slot ] = true ; pcum -> can_split = false ; } gcc_assert ( pcum -> can_split == false ) ; return ; } } ncrn = pcum -> aapcs_ncrn ; if ( ( ncrn & <NUM_LIT> ) && arm_needs_doubleword_align ( mode , type ) ) ncrn ++ ; nregs = ARM_NUM_REGS2 ( mode , type ) ; gcc_assert ( nregs >= <NUM_LIT> ) ; nregs2 = nregs ? nregs : <NUM_LIT> ; if ( ncrn + nregs2 <= NUM_ARG_REGS ) { pcum -> aapcs_reg = gen_rtx_REG ( mode , ncrn ) ; pcum -> aapcs_next_ncrn = ncrn + nregs ; return ; } if ( ncrn < NUM_ARG_REGS && pcum -> can_split ) { pcum -> aapcs_reg = gen_rtx_REG ( mode , ncrn ) ; pcum -> aapcs_next_ncrn = NUM_ARG_REGS ; pcum -> aapcs_partial = ( NUM_ARG_REGS - ncrn ) * UNITS_PER_WORD ; return ; } pcum -> aapcs_next_ncrn = NUM_ARG_REGS ;


<s> static void aapcs_layout_arg ( CUMULATIVE_ARGS * pcum , machine_mode mode , const_tree type , bool named ) { int nregs , nregs2 ; int ncrn ; if ( pcum -> aapcs_arg_processed ) return ; pcum -> aapcs_arg_processed = true ; if ( ! named ) return ; if ( pcum -> pcs_variant != ARM_PCS_AAPCS ) { int slot = aapcs_select_call_coproc ( pcum , mode , type ) ; pcum -> aapcs_cprc_slot = slot ; if ( slot >= <NUM_LIT> ) { if ( ! pcum -> aapcs_cprc_failed [ slot ] ) { if ( aapcs_cp_arg_layout [ slot ] . allocate ( pcum , mode , type ) ) return ;

pcum -> aapcs_cprc_failed [ slot ] = true ;


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


<s> } } shift = GET_MODE_SIZE ( ag_mode ) / GET_MODE_SIZE ( SFmode ) ; par = gen_rtx_PARALLEL ( mode , rtvec_alloc ( count ) ) ; for ( i = <NUM_LIT> ; i < count ; i ++ ) { rtx tmp = gen_rtx_REG ( ag_mode , FIRST_VFP_REGNUM + i * shift ) ; tmp = gen_rtx_EXPR_LIST ( VOIDmode , tmp , GEN_INT ( i * GET_MODE_SIZE ( ag_mode ) ) ) ; XVECEXP ( par , <NUM_LIT> , i ) = tmp ; } return par ; } return gen_rtx_REG ( mode , FIRST_VFP_REGNUM ) ;


<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 ) ; tmp = gen_rtx_EXPR_LIST ( VOIDmode , tmp , GEN_INT ( i * GET_MODE_SIZE ( ag_mode ) ) ) ; XVECEXP ( par , <NUM_LIT> , i ) = tmp ; } return par ; }

return gen_rtx_REG ( mode , FIRST_VFP_REGNUM ) ;


<s> else if ( GET_MODE_CLASS ( mode ) == MODE_FLOAT || GET_MODE_CLASS ( mode ) == MODE_VECTOR_INT || GET_MODE_CLASS ( mode ) == MODE_VECTOR_FLOAT ) { * count = <NUM_LIT> ; new_mode = mode ; } else if ( GET_MODE_CLASS ( mode ) == MODE_COMPLEX_FLOAT ) { * count = <NUM_LIT> ; new_mode = ( mode == DCmode ? DFmode : SFmode ) ; } else return false ; if ( ! use_vfp_abi ( pcs_variant , ARM_NUM_REGS ( new_mode ) > <NUM_LIT> ) ) return false ; * base_mode = new_mode ;


<s> 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 ( ! prev_set || ! curr_set ) return false ; if ( any_condjump_p ( curr ) ) return false ; if ( ! arm_macro_fusion_p ( ) ) return false ; if ( current_tune -> fuseable_ops & ARM_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 ; } 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> 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 ; } 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 ; } return false ;


<s> edge_iterator ei ; edge e ; if ( ! crtl -> tail_call_emit ) return false ;

FOR_EACH_EDGE ( e , ei , EXIT_BLOCK_PTR_FOR_FN ( cfun ) -> preds ) if ( e -> flags & EDGE_SIBCALL ) {


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


<s> dwarf = gen_rtx_SET ( VOIDmode , dest , plus_constant ( Pmode , src , size ) ) ; add_reg_note ( insn , REG_CFA_ADJUST_CFA , dwarf ) ;


<s> if ( current_tune -> sched_adjust_cost != NULL ) { if ( ! current_tune -> sched_adjust_cost ( insn , link , dep , & cost ) ) return cost ; } if ( REG_NOTE_KIND ( link ) == REG_DEP_ANTI || REG_NOTE_KIND ( link ) == REG_DEP_OUTPUT ) return <NUM_LIT> ; if ( REG_NOTE_KIND ( link ) == <NUM_LIT> && CALL_P ( insn ) ) return <NUM_LIT> ; if ( ( i_pat = single_set ( insn ) ) != NULL && MEM_P ( SET_SRC ( i_pat ) ) && ( d_pat = single_set ( dep ) ) != NULL && MEM_P ( SET_DEST ( d_pat ) ) ) { rtx src_mem = XEXP ( SET_SRC ( i_pat ) , <NUM_LIT> ) ;


<s> if ( REG_NOTE_KIND ( link ) == REG_DEP_ANTI || REG_NOTE_KIND ( link ) == REG_DEP_OUTPUT ) return <NUM_LIT> ; if ( REG_NOTE_KIND ( link ) == <NUM_LIT> && CALL_P ( insn ) ) return <NUM_LIT> ; if ( ( i_pat = single_set ( insn ) ) != NULL && MEM_P ( SET_SRC ( i_pat ) ) && ( d_pat = single_set ( dep ) ) != NULL && MEM_P ( SET_DEST ( d_pat ) ) ) {

rtx src_mem = XEXP ( SET_SRC ( i_pat ) , <NUM_LIT> ) ;


<s> if ( TARGET_HARD_FLOAT_ABI && TARGET_VFP ) size += <NUM_LIT> ; if ( TARGET_IWMMXT_ABI ) size += <NUM_LIT> ; }


if ( TARGET_HARD_FLOAT_ABI && TARGET_VFP ) size += <NUM_LIT> ;


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


<s> static int arm_arg_partial_bytes ( cumulative_args_t pcum_v , machine_mode mode , tree type , bool named ) { CUMULATIVE_ARGS * pcum = get_cumulative_args ( pcum_v ) ; int nregs = pcum -> nregs ; if ( pcum -> pcs_variant <= ARM_PCS_AAPCS_LOCAL ) { aapcs_layout_arg ( pcum , mode , type , named ) ; return pcum -> aapcs_partial ; } if ( TARGET_IWMMXT_ABI && arm_vector_mode_supported_p ( mode ) ) return <NUM_LIT> ; if ( NUM_ARG_REGS > nregs && ( NUM_ARG_REGS < nregs + ARM_NUM_REGS2 ( mode , type ) ) && pcum -> can_split ) return ( NUM_ARG_REGS - nregs ) * UNITS_PER_WORD ; return <NUM_LIT> ;


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


<s> return ( unsigned HOST_WIDE_INT ) <NUM_LIT> << <NUM_LIT> ;


<s> 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> ) ; fprintf ( f , <STR_LIT> ) ; asm_fprintf ( f , <STR_LIT> ) ; asm_fprintf ( f , <STR_LIT> , PC_REGNUM ) ;

asm_fprintf ( f , <STR_LIT> , STATIC_CHAIN_REGNUM ) ;


<s> extract_insn_cached ( insn ) ; if ( REG_P ( recog_data . operand [ <NUM_LIT> ] ) && REG_P ( recog_data . operand [ <NUM_LIT> ] ) ) { mode = GET_MODE ( recog_data . operand [ <NUM_LIT> ] ) ; switch ( mode ) { case EImode : case OImode : return <NUM_LIT> ; case CImode : return <NUM_LIT> ; case XImode : return <NUM_LIT> ; default : gcc_unreachable ( ) ;


<s> return <NUM_LIT> ; default : gcc_unreachable ( ) ; } } load = REG_P ( recog_data . operand [ <NUM_LIT> ] ) ; reg = recog_data . operand [ ! load ] ; mem = recog_data . operand [ load ] ; gcc_assert ( MEM_P ( mem ) ) ; mode = GET_MODE ( reg ) ; addr = XEXP ( mem , <NUM_LIT> ) ; if ( GET_CODE ( addr ) == CONST && GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == PLUS ) addr = XEXP ( addr , <NUM_LIT> ) ; if ( GET_CODE ( addr ) == LABEL_REF || GET_CODE ( addr ) == PLUS ) { int insns = HARD_REGNO_NREGS ( REGNO ( reg ) , mode ) / <NUM_LIT> ; return insns * <NUM_LIT> ; }


<s> static int arm_barrier_cost ( rtx insn ) { int base_cost = <NUM_LIT> ; rtx next = next_nonnote_insn ( insn ) ; if ( next != NULL && LABEL_P ( next ) ) base_cost -= <NUM_LIT> ; switch ( GET_CODE ( insn ) ) { case CODE_LABEL : return <NUM_LIT> ;


<s> for ( j = <NUM_LIT> ; j < words ; j ++ ) { addr = plus_constant ( Pmode , dst , dstoffset + j * UNITS_PER_WORD - dst_autoinc ) ; mem = adjust_automodify_address ( dstbase , SImode , addr , dstoffset + j * UNITS_PER_WORD ) ; emit_insn ( gen_unaligned_storesi ( mem , regs [ j ] ) ) ; } dstoffset += words * UNITS_PER_WORD ; } remaining -= words * UNITS_PER_WORD ; gcc_assert ( remaining < <NUM_LIT> ) ; if ( remaining >= <NUM_LIT> ) { halfword_tmp = gen_reg_rtx ( SImode ) ; addr = plus_constant ( Pmode , src , srcoffset - src_autoinc ) ; mem = adjust_automodify_address ( srcbase , HImode , addr , srcoffset ) ; emit_insn ( gen_unaligned_loadhiu ( halfword_tmp , mem ) ) ; if ( interleave_factor == <NUM_LIT> ) { addr = plus_constant ( Pmode , dst , dstoffset - dst_autoinc ) ; mem = adjust_automodify_address ( dstbase , HImode , addr , dstoffset ) ; emit_insn ( gen_unaligned_storehi ( mem , gen_lowpart ( HImode , halfword_tmp ) ) ) ; halfword_tmp = NULL ; dstoffset += <NUM_LIT> ; } remaining -= <NUM_LIT> ; srcoffset += <NUM_LIT> ; } gcc_assert ( remaining < <NUM_LIT> ) ; if ( ( remaining & <NUM_LIT> ) != <NUM_LIT> ) { byte_tmp = gen_reg_rtx ( SImode ) ; addr = plus_constant ( Pmode , src , srcoffset - src_autoinc ) ; mem = adjust_automodify_address ( srcbase , QImode , addr , srcoffset ) ; emit_move_insn ( gen_lowpart ( QImode , byte_tmp ) , mem ) ; if ( interleave_factor == <NUM_LIT> ) { addr = plus_constant ( Pmode , dst , dstoffset - dst_autoinc ) ; mem = adjust_automodify_address ( dstbase , QImode , addr , dstoffset ) ; emit_move_insn ( mem , gen_lowpart ( QImode , byte_tmp ) ) ; byte_tmp = NULL ; dstoffset ++ ; } remaining -- ; srcoffset ++ ; } if ( halfword_tmp ) { addr = plus_constant ( Pmode , dst , dstoffset - dst_autoinc ) ; mem = adjust_automodify_address ( dstbase , HImode , addr , dstoffset ) ; emit_insn ( gen_unaligned_storehi ( mem , gen_lowpart ( HImode , halfword_tmp ) ) ) ; dstoffset += <NUM_LIT> ; } if ( byte_tmp ) { addr = plus_constant ( Pmode , dst , dstoffset - dst_autoinc ) ; mem = adjust_automodify_address ( dstbase , QImode , addr , dstoffset ) ; emit_move_insn ( mem , gen_lowpart ( QImode , byte_tmp ) ) ; dstoffset ++ ; } gcc_assert ( remaining == <NUM_LIT> && srcoffset == dstoffset ) ;


<s> val_reg = force_reg ( DImode , val_exp ) ; reg = val_reg ; for ( ; ( i + <NUM_LIT> <= length ) ; i += <NUM_LIT> ) { addr = plus_constant ( Pmode , dst , i ) ; mem = adjust_automodify_address ( dstbase , DImode , addr , i ) ; emit_move_insn ( mem , reg ) ; } } else val_reg = force_reg ( SImode , val_exp ) ; reg = ( use_strd_p ? gen_lowpart ( SImode , val_reg ) : val_reg ) ; for ( ; ( i + <NUM_LIT> <= length ) ; i += <NUM_LIT> ) { addr = plus_constant ( Pmode , dst , i ) ; mem = adjust_automodify_address ( dstbase , SImode , addr , i ) ; if ( ( align & <NUM_LIT> ) == <NUM_LIT> ) emit_move_insn ( mem , reg ) ; else emit_insn ( gen_unaligned_storesi ( mem , reg ) ) ; } if ( unaligned_access && i > <NUM_LIT> && ( i + <NUM_LIT> ) == length ) { addr = plus_constant ( Pmode , dst , i - <NUM_LIT> ) ; mem = adjust_automodify_address ( dstbase , SImode , addr , i - <NUM_LIT> ) ; if ( ( align & <NUM_LIT> ) == <NUM_LIT> ) set_mem_align ( mem , BITS_PER_UNIT ) ; emit_insn ( gen_unaligned_storesi ( mem , reg ) ) ; return true ; }


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


<s> unsigned HOST_WIDE_INT v = value ; gcc_assert ( ( align & <NUM_LIT> ) != <NUM_LIT> ) ; nelt_v8 = GET_MODE_NUNITS ( V8QImode ) ; nelt_v16 = GET_MODE_NUNITS ( V16QImode ) ; if ( length >= nelt_v16 ) { mode = V16QImode ; gen_func = gen_movmisalignv16qi ; } else { mode = V8QImode ; gen_func = gen_movmisalignv8qi ; } nelt_mode = GET_MODE_NUNITS ( mode ) ; gcc_assert ( length >= nelt_mode ) ; if ( ! arm_block_set_vect_profit_p ( length , align , mode ) ) return false ; dst = copy_addr_to_reg ( XEXP ( dstbase , <NUM_LIT> ) ) ; mem = adjust_automodify_address ( dstbase , mode , dst , <NUM_LIT> ) ; v = sext_hwi ( v , BITS_PER_WORD ) ; val_elt = GEN_INT ( v ) ; for ( j = <NUM_LIT> ; j < nelt_mode ; j ++ ) rval [ j ] = val_elt ; reg = gen_reg_rtx ( mode ) ; val_vec = gen_rtx_CONST_VECTOR ( mode , gen_rtvec_v ( nelt_mode , rval ) ) ; emit_move_insn ( reg , val_vec ) ; for ( i = <NUM_LIT> ; ( i + nelt_mode <= length ) ; i += nelt_mode ) { emit_insn ( ( * gen_func ) ( mem , reg ) ) ; if ( i + <NUM_LIT> * nelt_mode <= length ) emit_insn ( gen_add2_insn ( dst , GEN_INT ( nelt_mode ) ) ) ; } gcc_assert ( ( i + nelt_v8 ) > length || mode == V16QImode ) ; if ( i + nelt_v8 < length ) { emit_insn ( gen_add2_insn ( dst , GEN_INT ( length - i ) ) ) ; if ( ( length & <NUM_LIT> ) != <NUM_LIT> && align >= <NUM_LIT> ) set_mem_align ( mem , BITS_PER_UNIT ) ; emit_insn ( gen_movmisalignv16qi ( mem , reg ) ) ; } else if ( i < length && i + nelt_v8 >= length ) { if ( mode == V16QImode ) { reg = gen_lowpart ( V8QImode , reg ) ; mem = adjust_automodify_address ( dstbase , V8QImode , dst , <NUM_LIT> ) ; } emit_insn ( gen_add2_insn ( dst , GEN_INT ( ( length - i ) + ( nelt_mode - nelt_v8 ) ) ) ) ; if ( ( length & <NUM_LIT> ) != <NUM_LIT> && align >= <NUM_LIT> ) set_mem_align ( mem , BITS_PER_UNIT ) ; emit_insn ( gen_movmisalignv8qi ( mem , reg ) ) ; }


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


<s> labelno = GEN_INT ( pic_labelno ++ ) ; label = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , labelno ) , UNSPEC_PIC_LABEL ) ; label = gen_rtx_CONST ( VOIDmode , label ) ;

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


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


<s> if ( GET_CODE ( base ) == SYMBOL_REF && ! offset_within_block_p ( base , INTVAL ( offset ) ) ) return true ; } return arm_tls_referenced_p ( x ) ;


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


<s> gcc_assert ( TREE_CODE ( current_function_decl ) == FUNCTION_DECL ) ; if ( optimize > <NUM_LIT> && ( TREE_NOTHROW ( current_function_decl ) || ! ( flag_unwind_tables || ( flag_exceptions && arm_except_unwind_info ( & global_options ) != UI_SJLJ ) ) ) && TREE_THIS_VOLATILE ( current_function_decl ) ) type |= ARM_FT_VOLATILE ; if ( cfun -> static_chain_decl != NULL ) type |= ARM_FT_NESTED ; attr = DECL_ATTRIBUTES ( current_function_decl ) ; a = lookup_attribute ( <STR_LIT> , attr ) ; if ( a != NULL_TREE ) type |= ARM_FT_NAKED ; a = lookup_attribute ( <STR_LIT> , attr ) ; if ( a == NULL_TREE ) a = lookup_attribute ( <STR_LIT> , attr ) ; if ( a == NULL_TREE ) type |= TARGET_INTERWORK ? ARM_FT_INTERWORKED : ARM_FT_NORMAL ; else type |= arm_isr_value ( TREE_VALUE ( a ) ) ;


<s> unsigned long type = ARM_FT_UNKNOWN ; tree a ; tree attr ; gcc_assert ( TREE_CODE ( current_function_decl ) == FUNCTION_DECL ) ; if ( optimize > <NUM_LIT> && ( TREE_NOTHROW ( current_function_decl ) || ! ( flag_unwind_tables || ( flag_exceptions && arm_except_unwind_info ( & global_options ) != UI_SJLJ ) ) ) && TREE_THIS_VOLATILE ( current_function_decl ) ) type |= ARM_FT_VOLATILE ; if ( cfun -> static_chain_decl != NULL ) type |= ARM_FT_NESTED ; attr = DECL_ATTRIBUTES ( current_function_decl ) ; a = lookup_attribute ( <STR_LIT> , attr ) ; if ( a != NULL_TREE ) type |= ARM_FT_NAKED ; a = lookup_attribute ( <STR_LIT> , attr ) ;

if ( a == NULL_TREE ) a = lookup_attribute ( <STR_LIT> , attr ) ;


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


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


<s> static int arm_compute_static_chain_stack_bytes ( void ) {

if ( TARGET_APCS_FRAME && frame_pointer_needed && TARGET_ARM && IS_NESTED ( arm_current_func_type ( ) ) && arm_r3_live_at_start_p ( ) && crtl -> args . pretend_args_size == <NUM_LIT> ) return <NUM_LIT> ;


<s> if ( TARGET_APCS_FRAME && frame_pointer_needed && TARGET_ARM && IS_NESTED ( arm_current_func_type ( ) ) && arm_r3_live_at_start_p ( ) && crtl -> args . pretend_args_size == <NUM_LIT> ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> REAL_VALUE_FROM_CONST_DOUBLE ( r , x ) ;

if ( REAL_VALUE_MINUS_ZERO ( r ) ) return <NUM_LIT> ;


<s> if ( ( TREE_CODE ( decl_op1 ) == VAR_DECL || TREE_CODE ( decl_op1 ) == CONST_DECL ) && ( TREE_CODE ( decl_op0 ) == VAR_DECL || TREE_CODE ( decl_op0 ) == CONST_DECL ) ) return ( get_variable_section ( decl_op1 , false ) != get_variable_section ( decl_op0 , false ) ) ; if ( TREE_CODE ( decl_op1 ) == LABEL_DECL && TREE_CODE ( decl_op0 ) == LABEL_DECL ) return ( DECL_CONTEXT ( decl_op1 ) != DECL_CONTEXT ( decl_op0 ) ) ; }


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


<s> if ( ! SCALAR_FLOAT_TYPE_P ( fromtype ) || ! SCALAR_FLOAT_TYPE_P ( type ) ) return NULL_TREE ;

if ( ( TYPE_PRECISION ( fromtype ) == <NUM_LIT> && TYPE_PRECISION ( type ) > <NUM_LIT> ) || ( TYPE_PRECISION ( type ) == <NUM_LIT> && TYPE_PRECISION ( fromtype ) > <NUM_LIT> ) ) return convert ( type , convert ( float_type_node , expr ) ) ;


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

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


<s> if ( TARGET_VXWORKS_RTP && flag_pic && ! sibcall && GET_CODE ( addr ) == SYMBOL_REF && ( SYMBOL_REF_DECL ( addr ) ? ! targetm . binds_local_p ( SYMBOL_REF_DECL ( addr ) ) : ! SYMBOL_REF_LOCAL_P ( addr ) ) ) { require_pic_register ( ) ; use_reg ( & CALL_INSN_FUNCTION_USAGE ( insn ) , cfun -> machine -> pic_reg ) ;


<s> bits = real_to_target ( NULL , & r , HFmode ) ; if ( WORDS_BIG_ENDIAN ) assemble_zeros ( <NUM_LIT> ) ;


<s> assemble_integer ( GEN_INT ( bits ) , <NUM_LIT> , BITS_PER_WORD , <NUM_LIT> ) ;

if ( ! WORDS_BIG_ENDIAN ) assemble_zeros ( <NUM_LIT> ) ;


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


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

REG_NOTES ( tmp ) = alloc_reg_note ( REG_CFA_RESTORE , gen_rtx_REG ( SImode , j ) , NULL_RTX ) ;


<s> rtx ( * gen ) ( rtx , rtx ) ; if ( acq ) { switch ( mode ) { case QImode : gen = gen_arm_load_acquire_exclusiveqi ; break ; case HImode : gen = gen_arm_load_acquire_exclusivehi ; break ; case SImode : gen = gen_arm_load_acquire_exclusivesi ; break ; case DImode : gen = gen_arm_load_acquire_exclusivedi ; break ; default : gcc_unreachable ( ) ; } }


<s> static void arm_emit_multi_reg_pop ( unsigned long saved_regs_mask ) { int num_regs = <NUM_LIT> ; int i , j ; rtx par ; rtx dwarf = NULL_RTX ; rtx tmp , reg ; bool return_in_pc = saved_regs_mask & ( <NUM_LIT> << PC_REGNUM ) ; int offset_adj ; int emit_update ; offset_adj = return_in_pc ? <NUM_LIT> : <NUM_LIT> ; for ( i = <NUM_LIT> ; i <= LAST_ARM_REGNUM ; i ++ ) if ( saved_regs_mask & ( <NUM_LIT> << i ) ) num_regs ++ ; gcc_assert ( num_regs && num_regs <= <NUM_LIT> ) ; emit_update = ( saved_regs_mask & ( <NUM_LIT> << SP_REGNUM ) ) ? <NUM_LIT> : <NUM_LIT> ; par = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( num_regs + emit_update + offset_adj ) ) ;

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


<s> rtx dwarf = NULL_RTX ; rtx tmp , reg ; bool return_in_pc = saved_regs_mask & ( <NUM_LIT> << PC_REGNUM ) ; int offset_adj ; int emit_update ; offset_adj = return_in_pc ? <NUM_LIT> : <NUM_LIT> ; for ( i = <NUM_LIT> ; i <= LAST_ARM_REGNUM ; i ++ ) if ( saved_regs_mask & ( <NUM_LIT> << i ) ) num_regs ++ ; gcc_assert ( num_regs && num_regs <= <NUM_LIT> ) ; emit_update = ( saved_regs_mask & ( <NUM_LIT> << SP_REGNUM ) ) ? <NUM_LIT> : <NUM_LIT> ; par = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( num_regs + emit_update + offset_adj ) ) ; if ( return_in_pc ) XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = ret_rtx ;


<s> static void arm_emit_store_exclusive ( machine_mode mode , rtx bval , rtx rval , rtx mem , bool rel ) { rtx ( * gen ) ( rtx , rtx , rtx ) ; if ( rel ) { switch ( mode ) { case QImode : gen = gen_arm_store_release_exclusiveqi ; break ; case HImode : gen = gen_arm_store_release_exclusivehi ; break ; case SImode : gen = gen_arm_store_release_exclusivesi ; break ; case DImode : gen = gen_arm_store_release_exclusivedi ; break ; default : gcc_unreachable ( ) ; } } else { switch ( mode ) { case QImode : gen = gen_arm_store_exclusiveqi ; break ; case HImode : gen = gen_arm_store_exclusivehi ; break ; case SImode : gen = gen_arm_store_exclusivesi ; break ; case DImode : gen = gen_arm_store_exclusivedi ; break ; default : gcc_unreachable ( ) ; }


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