<s> output_addr_const ( asm_out_file , x ) ; fputs ( <STR_LIT> ASM_COMMENT_START <STR_LIT> , asm_out_file ) ; fputs ( <STR_LIT> , asm_out_file ) ; output_addr_const ( asm_out_file , x ) ; fputs ( <STR_LIT> ASM_COMMENT_START <STR_LIT> , asm_out_file ) ; return true ; } else if ( CONST_FIXED_P ( x ) ) { for ( unsigned n = <NUM_LIT> ; n < size ; n ++ ) {

rtx xn = simplify_gen_subreg ( QImode , x , GET_MODE ( x ) , n ) ;


<s> if ( id < AVR_BUILTIN_COUNT ) return avr_bdesc [ id ] . fndecl ; return error_mark_node ;


<s> if ( reload_completed && cfun -> machine && cfun -> machine -> is_naked ) { return true ; } return false ;


<s> return ( ( frame_pointer_needed && to == FRAME_POINTER_REGNUM ) || ! frame_pointer_needed ) ;


<s> if ( AVR_HAVE_EIJMP_EICALL && xop [ <NUM_LIT> ] == all_regs_rtx [ <NUM_LIT> ] ) { sub_5 = xop [ <NUM_LIT> ] ; } if ( ! AVR_HAVE_EIJMP_EICALL && PLUS == GET_CODE ( xop [ <NUM_LIT> ] ) && LABEL_REF == GET_CODE ( XEXP ( xop [ <NUM_LIT> ] , <NUM_LIT> ) ) && rtx_equal_p ( xop [ <NUM_LIT> ] , XEXP ( XEXP ( xop [ <NUM_LIT> ] , <NUM_LIT> ) , <NUM_LIT> ) ) && xop [ <NUM_LIT> ] == const0_rtx ) {

sub_5 = XEXP ( xop [ <NUM_LIT> ] , <NUM_LIT> ) ;


<s> sub_5 = xop [ <NUM_LIT> ] ; } if ( ! AVR_HAVE_EIJMP_EICALL && PLUS == GET_CODE ( xop [ <NUM_LIT> ] ) && LABEL_REF == GET_CODE ( XEXP ( xop [ <NUM_LIT> ] , <NUM_LIT> ) ) && rtx_equal_p ( xop [ <NUM_LIT> ] , XEXP ( XEXP ( xop [ <NUM_LIT> ] , <NUM_LIT> ) , <NUM_LIT> ) ) && xop [ <NUM_LIT> ] == const0_rtx ) { sub_5 = XEXP ( xop [ <NUM_LIT> ] , <NUM_LIT> ) ; }

if ( sub_5 && SUBREG_P ( sub_5 ) && SUBREG_BYTE ( sub_5 ) == <NUM_LIT> && rtx_equal_p ( xop [ <NUM_LIT> ] , SUBREG_REG ( sub_5 ) ) ) return true ;


<s> static unsigned int avr_case_values_threshold ( void ) { return <NUM_LIT> ;


<s> static unsigned char avr_class_max_nregs ( reg_class_t rclass , machine_mode mode ) { if ( rclass == CC_REG && mode == CCmode ) return <NUM_LIT> ; return CEIL ( GET_MODE_SIZE ( mode ) , UNITS_PER_WORD ) ;


<s> machine_mode mode1 = GET_MODE ( XEXP ( SET_SRC ( pattern ) , <NUM_LIT> ) ) ; if ( ( mode0 == VOIDmode || GET_MODE_SIZE ( mode0 ) <= <NUM_LIT> ) && ( mode1 == VOIDmode || GET_MODE_SIZE ( mode1 ) <= <NUM_LIT> ) ) return pattern ;


<s> if ( AVR_TINY ) { const int tiny_reg_alloc_order [ ] = { <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> } ; for ( size_t i = <NUM_LIT> ; i <= <NUM_LIT> ; i ++ ) { fixed_regs [ i ] = <NUM_LIT> ; call_used_regs [ i ] = <NUM_LIT> ; } for ( size_t i = <NUM_LIT> ; i <= LAST_CALLEE_SAVED_REG ; i ++ ) { call_used_regs [ i ] = <NUM_LIT> ; } for ( size_t i = <NUM_LIT> ; i < ARRAY_SIZE ( tiny_reg_alloc_order ) ; i ++ ) { reg_alloc_order [ i ] = tiny_reg_alloc_order [ i ] ; } CLEAR_HARD_REG_SET ( reg_class_contents [ ( int ) ADDW_REGS ] ) ;

CLEAR_HARD_REG_SET ( reg_class_contents [ ( int ) NO_LD_REGS ] ) ;


<s> if ( avr_warn_addr_space_convert && expr != error_mark_node && POINTER_TYPE_P ( type ) && POINTER_TYPE_P ( TREE_TYPE ( expr ) ) ) { addr_space_t as_old = TYPE_ADDR_SPACE ( TREE_TYPE ( TREE_TYPE ( expr ) ) ) ; addr_space_t as_new = TYPE_ADDR_SPACE ( TREE_TYPE ( type ) ) ; if ( avr_log . progmem ) avr_edump ( <STR_LIT> , type , expr ) ; if ( as_new != ADDR_SPACE_MEMX && as_new != as_old ) { location_t loc = EXPR_LOCATION ( expr ) ; const char * name_old = avr_addrspace [ as_old ] . name ; const char * name_new = avr_addrspace [ as_new ] . name ; warning ( OPT_Waddr_space_convert , <STR_LIT> , ADDR_SPACE_GENERIC_P ( as_old ) ? <STR_LIT> : name_old , ADDR_SPACE_GENERIC_P ( as_new ) ? <STR_LIT> : name_new ) ;

return fold_build1_loc ( loc , ADDR_SPACE_CONVERT_EXPR , type , expr ) ;


<s> if ( as_new != ADDR_SPACE_MEMX && as_new != as_old ) { location_t loc = EXPR_LOCATION ( expr ) ; const char * name_old = avr_addrspace [ as_old ] . name ; const char * name_new = avr_addrspace [ as_new ] . name ;


<s> return ( TREE_CODE ( decl ) == VAR_DECL && NULL_TREE != lookup_attribute ( <STR_LIT> , attributes ) ) ;


<s> if ( TREE_READONLY ( node ) ) return false ; do node = TREE_TYPE ( node ) ;

while ( ARRAY_TYPE == TREE_CODE ( node ) ) ;


<s> if ( TREE_READONLY ( node ) ) return false ; do node = TREE_TYPE ( node ) ; while ( ARRAY_TYPE == TREE_CODE ( node ) ) ;

return ( node != error_mark_node && ! TYPE_READONLY ( node ) ) ;


<s> static bool avr_decl_memx_p ( tree decl ) { if ( TREE_CODE ( decl ) != VAR_DECL || TREE_TYPE ( decl ) == error_mark_node ) { return false ;


<s> gcc_assert ( opmode == mode || opmode == VOIDmode ) ; if ( ! insn_data [ icode ] . operand [ n + <NUM_LIT> ] . predicate ( op , mode ) ) op = copy_to_mode_reg ( mode , op ) ; xop [ n ] = op ; } switch ( n_args ) { case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target , xop [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target , xop [ <NUM_LIT> ] , xop [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target , xop [ <NUM_LIT> ] , xop [ <NUM_LIT> ] , xop [ <NUM_LIT> ] ) ; break ; default :


<s> machine_mode opmode = GET_MODE ( op ) ; machine_mode mode = insn_data [ icode ] . operand [ n + <NUM_LIT> ] . mode ; if ( ( opmode == SImode || opmode == VOIDmode ) && mode == HImode ) { opmode = HImode ; op = gen_lowpart ( HImode , op ) ; } gcc_assert ( opmode == mode || opmode == VOIDmode ) ; if ( ! insn_data [ icode ] . operand [ n + <NUM_LIT> ] . predicate ( op , mode ) ) op = copy_to_mode_reg ( mode , op ) ; xop [ n ] = op ; } switch ( n_args ) { case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target , xop [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target , xop [ <NUM_LIT> ] , xop [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target , xop [ <NUM_LIT> ] , xop [ <NUM_LIT> ] , xop [ <NUM_LIT> ] ) ; break ; default : gcc_unreachable ( ) ; }

if ( pat == NULL_RTX ) return NULL_RTX ;


<s> avr_fix_operands ( op , hreg , opmask , rmask ) ; lock = true ;

emit_insn ( gen ( op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ) ;


<s> a_src = XEXP ( xop [ <NUM_LIT> ] , <NUM_LIT> ) ; a_dest = XEXP ( xop [ <NUM_LIT> ] , <NUM_LIT> ) ; if ( PSImode == GET_MODE ( a_src ) ) { gcc_assert ( as == ADDR_SPACE_MEMX ) ; loop_mode = ( count < <NUM_LIT> ) ? QImode : HImode ; loop_reg = gen_rtx_REG ( loop_mode , <NUM_LIT> ) ; emit_move_insn ( loop_reg , gen_int_mode ( count , loop_mode ) ) ; addr1 = simplify_gen_subreg ( HImode , a_src , PSImode , <NUM_LIT> ) ; a_hi8 = simplify_gen_subreg ( QImode , a_src , PSImode , <NUM_LIT> ) ; } else { int segment = avr_addrspace [ as ] . segment ; if ( segment && avr_n_flash > <NUM_LIT> ) { a_hi8 = GEN_INT ( segment ) ; emit_move_insn ( rampz_rtx , a_hi8 = copy_to_mode_reg ( QImode , a_hi8 ) ) ; } else if ( ! ADDR_SPACE_GENERIC_P ( as ) ) { as = ADDR_SPACE_FLASH ; } addr1 = a_src ; loop_mode = ( count <= <NUM_LIT> ) ? QImode : HImode ; loop_reg = copy_to_mode_reg ( loop_mode , gen_int_mode ( count , loop_mode ) ) ; } xas = GEN_INT ( as ) ; emit_move_insn ( lpm_addr_reg_rtx , addr1 ) ; emit_move_insn ( gen_rtx_REG ( HImode , REG_X ) , a_dest ) ; gcc_assert ( TMP_REGNO == LPM_REGNO ) ; if ( as != ADDR_SPACE_MEMX ) { rtx ( * fun ) ( rtx , rtx , rtx ) = QImode == loop_mode ? gen_cpymem_qi : gen_cpymem_hi ; insn = fun ( xas , loop_reg , loop_reg ) ; } else { rtx ( * fun ) ( rtx , rtx ) = QImode == loop_mode ? gen_cpymemx_qi : gen_cpymemx_hi ; emit_move_insn ( gen_rtx_REG ( QImode , <NUM_LIT> ) , a_hi8 ) ; insn = fun ( xas , GEN_INT ( avr_addr . rampz ) ) ; } set_mem_addr_space ( SET_SRC ( XVECEXP ( insn , <NUM_LIT> , <NUM_LIT> ) ) , as ) ;


<s> tree io_attr = lookup_attribute ( <STR_LIT> , attr ) ; if ( io_low_attr && TREE_VALUE ( io_low_attr ) && TREE_VALUE ( TREE_VALUE ( io_low_attr ) ) ) addr_attr = io_attr ; else if ( io_attr && TREE_VALUE ( io_attr ) && TREE_VALUE ( TREE_VALUE ( io_attr ) ) ) addr_attr = io_attr ; else addr_attr = lookup_attribute ( <STR_LIT> , attr ) ; if ( io_low_attr || ( io_attr && addr_attr && low_io_address_operand ( GEN_INT ( TREE_INT_CST_LOW ( TREE_VALUE ( TREE_VALUE ( addr_attr ) ) ) ) , QImode ) ) ) SYMBOL_REF_FLAGS ( sym ) |= SYMBOL_FLAG_IO_LOW ; if ( io_attr || io_low_attr ) SYMBOL_REF_FLAGS ( sym ) |= SYMBOL_FLAG_IO ; if ( addr_attr && ! DECL_EXTERNAL ( decl ) ) SYMBOL_REF_FLAGS ( sym ) |= SYMBOL_FLAG_ADDRESS ; } if ( AVR_TINY && decl && VAR_DECL == TREE_CODE ( decl ) && MEM_P ( rtl ) && SYMBOL_REF_P ( XEXP ( rtl , <NUM_LIT> ) ) ) { rtx sym = XEXP ( rtl , <NUM_LIT> ) ; bool progmem_p = avr_progmem_p ( decl , DECL_ATTRIBUTES ( decl ) ) == - <NUM_LIT> ; if ( progmem_p ) { SYMBOL_REF_FLAGS ( sym ) |= AVR_SYMBOL_FLAG_TINY_PM ; } if ( avr_decl_absdata_p ( decl , DECL_ATTRIBUTES ( decl ) ) || ( TARGET_ABSDATA && ! progmem_p && ! addr_attr && avr_decl_maybe_lds_p ( decl ) ) || ( addr_attr && TREE_INT_CST_LOW ( TREE_VALUE ( TREE_VALUE ( addr_attr ) ) ) < <NUM_LIT> ) ) { SYMBOL_REF_FLAGS ( sym ) |= AVR_SYMBOL_FLAG_TINY_ABSDATA ; }

if ( progmem_p && avr_decl_absdata_p ( decl , DECL_ATTRIBUTES ( decl ) ) ) {


<s> if ( reload_completed && cfun -> machine && ( cfun -> machine -> is_interrupt || cfun -> machine -> is_signal ) ) return <NUM_LIT> ;


<s> tree attr = NULL_TREE ; if ( SYMBOL_REF_FLAGS ( x ) & SYMBOL_FLAG_IO ) { attr = lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ; if ( ! attr || ! TREE_VALUE ( attr ) ) attr = lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ; gcc_assert ( attr ) ;


<s> case AVR_BUILTIN_NOP : emit_insn ( gen_nopv ( GEN_INT ( <NUM_LIT> ) ) ) ; return <NUM_LIT> ; case AVR_BUILTIN_DELAY_CYCLES : { arg0 = CALL_EXPR_ARG ( exp , <NUM_LIT> ) ; op0 = expand_expr ( arg0 , NULL_RTX , VOIDmode , EXPAND_NORMAL ) ; if ( ! CONST_INT_P ( op0 ) ) error ( <STR_LIT> , bname ) ; else avr_expand_delay_cycles ( op0 ) ; return NULL_RTX ; } case AVR_BUILTIN_NOPS : { arg0 = CALL_EXPR_ARG ( exp , <NUM_LIT> ) ; op0 = expand_expr ( arg0 , NULL_RTX , VOIDmode , EXPAND_NORMAL ) ; if ( ! CONST_INT_P ( op0 ) ) error ( <STR_LIT> , bname ) ; else avr_expand_nops ( op0 ) ; return NULL_RTX ; } case AVR_BUILTIN_INSERT_BITS : { arg0 = CALL_EXPR_ARG ( exp , <NUM_LIT> ) ; op0 = expand_expr ( arg0 , NULL_RTX , VOIDmode , EXPAND_NORMAL ) ; if ( ! CONST_INT_P ( op0 ) ) { error ( <STR_LIT> <STR_LIT> , bname ) ; return target ; } break ; } case AVR_BUILTIN_ROUNDHR : case AVR_BUILTIN_ROUNDUHR : case AVR_BUILTIN_ROUNDR : case AVR_BUILTIN_ROUNDUR : case AVR_BUILTIN_ROUNDLR : case AVR_BUILTIN_ROUNDULR : case AVR_BUILTIN_ROUNDLLR : case AVR_BUILTIN_ROUNDULLR : case AVR_BUILTIN_ROUNDHK : case AVR_BUILTIN_ROUNDUHK : case AVR_BUILTIN_ROUNDK : case AVR_BUILTIN_ROUNDUK : case AVR_BUILTIN_ROUNDLK : case AVR_BUILTIN_ROUNDULK : case AVR_BUILTIN_ROUNDLLK : case AVR_BUILTIN_ROUNDULLK : if ( TREE_CODE ( CALL_EXPR_ARG ( exp , <NUM_LIT> ) ) != INTEGER_CST ) break ; int rbit = ( int ) TREE_INT_CST_LOW ( CALL_EXPR_ARG ( exp , <NUM_LIT> ) ) ; if ( rbit >= ( int ) GET_MODE_FBIT ( mode ) ) { warning ( OPT_Wextra , <STR_LIT> <STR_LIT> , rbit , GET_MODE_FBIT ( mode ) ) ; return expand_expr ( CALL_EXPR_ARG ( exp , <NUM_LIT> ) , NULL_RTX , mode , EXPAND_NORMAL ) ; } else if ( rbit <= - ( int ) GET_MODE_IBIT ( mode ) ) { warning ( <NUM_LIT> , <STR_LIT> ) ; return CONST0_RTX ( mode ) ; } break ; } if ( d -> icode == CODE_FOR_nothing && DECL_ASSEMBLER_NAME ( get_callee_fndecl ( exp ) ) != NULL_TREE ) { return expand_call ( exp , target , ignore ) ; } gcc_assert ( d -> icode != CODE_FOR_nothing ) ; gcc_assert ( d -> n_args == call_expr_nargs ( exp ) ) ; if ( d -> n_args == <NUM_LIT> ) { emit_insn ( ( GEN_FCN ( d -> icode ) ) ( target ) ) ;


<s> cycles -= cycles_used ; } if ( IN_RANGE ( cycles , <NUM_LIT> , <NUM_LIT> ) ) { loop_count = ( ( cycles - <NUM_LIT> ) / <NUM_LIT> ) + <NUM_LIT> ; if ( loop_count > <NUM_LIT> ) loop_count = <NUM_LIT> ; cycles_used = ( ( loop_count - <NUM_LIT> ) * <NUM_LIT> ) + <NUM_LIT> ; emit_insn ( gen_delay_cycles_2 ( gen_int_mode ( loop_count , HImode ) , avr_mem_clobber ( ) ) ) ; cycles -= cycles_used ; } if ( IN_RANGE ( cycles , <NUM_LIT> , <NUM_LIT> ) ) { loop_count = cycles / <NUM_LIT> ;


<s> size_max = ( HOST_WIDE_INT ) GET_MODE_MASK ( GET_MODE ( my_fp ) ) ; if ( size > size_max ) size = size_max ; size = trunc_int_for_mode ( size , GET_MODE ( my_fp ) ) ; start_sequence ( ) ; if ( ! frame_pointer_needed ) emit_move_insn ( fp , stack_pointer_rtx ) ; emit_move_insn ( my_fp , plus_constant ( GET_MODE ( my_fp ) , my_fp , size ) ) ; if ( TARGET_NO_INTERRUPTS ) irq_state = <NUM_LIT> ; if ( AVR_HAVE_8BIT_SP ) irq_state = <NUM_LIT> ; emit_insn ( gen_movhi_sp_r ( stack_pointer_rtx , fp , GEN_INT ( irq_state ) ) ) ; fp_plus_insns = get_insns ( ) ; end_sequence ( ) ; if ( avr_sp_immediate_operand ( gen_int_mode ( size , HImode ) , HImode ) ) { rtx_insn * sp_plus_insns ; start_sequence ( ) ; emit_move_insn ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , size ) ) ; sp_plus_insns = get_insns ( ) ; end_sequence ( ) ; emit_insn ( get_sequence_length ( sp_plus_insns ) < get_sequence_length ( fp_plus_insns ) ? sp_plus_insns : fp_plus_insns ) ; } else emit_insn ( fp_plus_insns ) ; } if ( frame_pointer_needed && ! ( cfun -> machine -> is_OS_task || cfun -> machine -> is_OS_main ) ) { emit_pop_byte ( REG_Y + <NUM_LIT> ) ; emit_pop_byte ( REG_Y ) ; } int treg = AVR_TMP_REGNO ; if ( isr_p && cfun -> machine -> gasisr . yes ) { treg = cfun -> machine -> gasisr . regno ; CLEAR_HARD_REG_BIT ( set , treg ) ; } for ( int reg = <NUM_LIT> ; reg >= <NUM_LIT> ; -- reg ) if ( TEST_HARD_REG_BIT ( set , reg ) ) emit_pop_byte ( reg ) ; if ( isr_p ) { if ( AVR_HAVE_RAMPZ && TEST_HARD_REG_BIT ( set , REG_Z ) && TEST_HARD_REG_BIT ( set , REG_Z + <NUM_LIT> ) ) { emit_pop_byte ( treg ) ; emit_move_insn ( rampz_rtx , all_regs_rtx [ treg ] ) ; } if ( AVR_HAVE_RAMPY && ( frame_pointer_needed || ( TEST_HARD_REG_BIT ( set , REG_Y ) && TEST_HARD_REG_BIT ( set , REG_Y + <NUM_LIT> ) ) ) ) { emit_pop_byte ( treg ) ; emit_move_insn ( rampy_rtx , all_regs_rtx [ treg ] ) ; } if ( AVR_HAVE_RAMPX && TEST_HARD_REG_BIT ( set , REG_X ) && TEST_HARD_REG_BIT ( set , REG_X + <NUM_LIT> ) ) { emit_pop_byte ( treg ) ; emit_move_insn ( rampx_rtx , all_regs_rtx [ treg ] ) ; } if ( AVR_HAVE_RAMPD ) { emit_pop_byte ( treg ) ;

emit_move_insn ( rampd_rtx , all_regs_rtx [ treg ] ) ;


<s> static void avr_expand_nops ( rtx operands0 ) { unsigned HOST_WIDE_INT n_nops = UINTVAL ( operands0 ) & GET_MODE_MASK ( HImode ) ; while ( n_nops -- ) { emit_insn ( gen_nopv ( const1_rtx ) ) ;


<s> static void avr_expand_nops ( rtx operands0 ) { unsigned HOST_WIDE_INT n_nops = UINTVAL ( operands0 ) & GET_MODE_MASK ( HImode ) ; while ( n_nops -- ) {


<s> cfun -> machine -> gasisr . yes = <NUM_LIT> ; treg = avr_hregs_split_reg ( & set ) ; if ( treg < <NUM_LIT> ) treg = AVR_TMP_REGNO ; cfun -> machine -> gasisr . regno = treg ; cfun -> machine -> stack_usage += <NUM_LIT> + ( treg != AVR_TMP_REGNO ) ; emit_insn ( gen_gasisr ( GEN_INT ( GASISR_Prologue ) , GEN_INT ( treg ) ) ) ; } else { emit_push_byte ( AVR_ZERO_REGNO , true ) ; emit_push_byte ( AVR_TMP_REGNO , true ) ; emit_push_sfr ( sreg_rtx , false , false , AVR_TMP_REGNO ) ; emit_move_insn ( zero_reg_rtx , const0_rtx ) ; emit_use ( zero_reg_rtx ) ; } if ( AVR_HAVE_RAMPD ) emit_push_sfr ( rampd_rtx , false , true , treg ) ; if ( AVR_HAVE_RAMPX && TEST_HARD_REG_BIT ( set , REG_X ) && TEST_HARD_REG_BIT ( set , REG_X + <NUM_LIT> ) ) { emit_push_sfr ( rampx_rtx , false , true , treg ) ; } if ( AVR_HAVE_RAMPY && ( frame_pointer_needed || ( TEST_HARD_REG_BIT ( set , REG_Y ) && TEST_HARD_REG_BIT ( set , REG_Y + <NUM_LIT> ) ) ) ) { emit_push_sfr ( rampy_rtx , false , true , treg ) ; } if ( AVR_HAVE_RAMPZ && TEST_HARD_REG_BIT ( set , REG_Z ) && TEST_HARD_REG_BIT ( set , REG_Z + <NUM_LIT> ) ) { emit_push_sfr ( rampz_rtx , false , AVR_HAVE_RAMPD , treg ) ; } } avr_prologue_setup_frame ( size , set ) ; if ( flag_stack_usage_info ) current_function_static_stack_size = cfun -> machine -> stack_usage + INCOMING_FRAME_SP_OFFSET ;


<s> treg = avr_hregs_split_reg ( & set ) ; if ( treg < <NUM_LIT> ) treg = AVR_TMP_REGNO ; cfun -> machine -> gasisr . regno = treg ; cfun -> machine -> stack_usage += <NUM_LIT> + ( treg != AVR_TMP_REGNO ) ; emit_insn ( gen_gasisr ( GEN_INT ( GASISR_Prologue ) , GEN_INT ( treg ) ) ) ; } else { emit_push_byte ( AVR_ZERO_REGNO , true ) ; emit_push_byte ( AVR_TMP_REGNO , true ) ; emit_push_sfr ( sreg_rtx , false , false , AVR_TMP_REGNO ) ; emit_move_insn ( zero_reg_rtx , const0_rtx ) ; emit_use ( zero_reg_rtx ) ; } if ( AVR_HAVE_RAMPD ) emit_push_sfr ( rampd_rtx , false , true , treg ) ;

if ( AVR_HAVE_RAMPX && TEST_HARD_REG_BIT ( set , REG_X ) && TEST_HARD_REG_BIT ( set , REG_X + <NUM_LIT> ) ) {


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

if ( avr_need_clear_bss_p ) fputs ( <STR_LIT> , asm_out_file ) ;


if ( avr_need_copy_data_p ) fputs ( <STR_LIT> , asm_out_file ) ;


<s> if ( AVR_HAVE_RAMPX ) fprintf ( asm_out_file , <STR_LIT> , avr_addr . rampx - sfr_offset ) ; if ( AVR_HAVE_RAMPD ) fprintf ( asm_out_file , <STR_LIT> , avr_addr . rampd - sfr_offset ) ; if ( AVR_XMEGA || AVR_TINY ) fprintf ( asm_out_file , <STR_LIT> , avr_addr . ccp - sfr_offset ) ; fprintf ( asm_out_file , <STR_LIT> , AVR_TMP_REGNO ) ;

fprintf ( asm_out_file , <STR_LIT> , AVR_ZERO_REGNO ) ;


<s> if ( avr_log . rtx_costs ) { rtx set = single_set ( insn ) ; if ( set ) fprintf ( asm_out_file , <STR_LIT> , set_src_cost ( SET_SRC ( set ) , GET_MODE ( SET_DEST ( set ) ) , optimize_insn_for_speed_p ( ) ) ) ;

else fprintf ( asm_out_file , <STR_LIT> , rtx_cost ( PATTERN ( insn ) , VOIDmode , INSN , <NUM_LIT> , optimize_insn_for_speed_p ( ) ) ) ;


<s> void avr_fix_inputs ( rtx * op , unsigned opmask , unsigned rmask ) {

avr_fix_operands ( op , NULL , opmask , rmask ) ;


<s> void avr_fix_inputs ( rtx * op , unsigned opmask , unsigned rmask ) { avr_fix_operands ( op , NULL , opmask , rmask ) ;


<s> rtx reg = * op ; if ( hreg ) * hreg = NULL_RTX ; if ( ( opmask & <NUM_LIT> ) && REG_P ( reg ) && REGNO ( reg ) < FIRST_PSEUDO_REGISTER && ( rmask & regmask ( GET_MODE ( reg ) , REGNO ( reg ) ) ) ) {

* op = gen_reg_rtx ( GET_MODE ( reg ) ) ;


<s> static void avr_fix_operands ( rtx * op , rtx * hreg , unsigned opmask , unsigned rmask ) { for ( ; opmask ; opmask >>= <NUM_LIT> , op ++ ) { rtx reg = * op ; if ( hreg ) * hreg = NULL_RTX ; if ( ( opmask & <NUM_LIT> ) && REG_P ( reg ) && REGNO ( reg ) < FIRST_PSEUDO_REGISTER && ( rmask & regmask ( GET_MODE ( reg ) , REGNO ( reg ) ) ) ) { * op = gen_reg_rtx ( GET_MODE ( reg ) ) ; if ( hreg == NULL ) emit_move_insn ( * op , reg ) ; else * hreg = reg ; } if ( hreg ) hreg ++ ; }


<s> fval . data = ( ival == double_int :: min_value ( bits , false ) . sext ( bits ) ) ? double_int :: max_value ( bits , false ) : - ival ; return build_fixed ( TREE_TYPE ( tval ) , fval ) ;


<s> static tree avr_fold_absfx ( tree tval ) { if ( FIXED_CST != TREE_CODE ( tval ) ) return NULL_TREE ; FIXED_VALUE_TYPE fval = TREE_FIXED_CST ( tval ) ;

unsigned int bits = GET_MODE_BITSIZE ( fval . mode ) ;


<s> static bool avr_frame_pointer_required_p ( void ) { return ( cfun -> calls_alloca || cfun -> calls_setjmp || cfun -> has_nonlocal_label || crtl -> args . info . nregs == <NUM_LIT> || get_frame_size ( ) > <NUM_LIT> ) ;


<s> static bool avr_frame_pointer_required_p ( void ) {

return ( cfun -> calls_alloca || cfun -> calls_setjmp || cfun -> has_nonlocal_label || crtl -> args . info . nregs == <NUM_LIT> || get_frame_size ( ) > <NUM_LIT> ) ;


<s> if ( cum -> nregs && bytes <= cum -> nregs ) return gen_rtx_REG ( arg . mode , cum -> regno - bytes ) ;


<s> cfun -> machine -> sibcall_fails = <NUM_LIT> ; } if ( cum -> regno >= <NUM_LIT> && cum -> nregs >= <NUM_LIT> ) { for ( int regno = cum -> regno ; regno < cum -> regno + bytes ; regno ++ ) if ( fixed_regs [ regno ] ) warning ( <NUM_LIT> , <STR_LIT> , reg_names [ regno ] ) ; } if ( cum -> nregs <= <NUM_LIT> ) { cum -> nregs = <NUM_LIT> ; cum -> regno = FIRST_CUM_REG ;


<s> return AVR_TINY ? IN_RANGE ( r , <NUM_LIT> , <NUM_LIT> ) : IN_RANGE ( r , <NUM_LIT> , <NUM_LIT> ) ;


<s> } fntype_callee = TREE_TYPE ( CALL_EXPR_FN ( exp_callee ) ) ; if ( decl_callee ) { decl_callee = TREE_TYPE ( decl_callee ) ; } else { decl_callee = fntype_callee ; while ( FUNCTION_TYPE != TREE_CODE ( decl_callee ) && METHOD_TYPE != TREE_CODE ( decl_callee ) ) { decl_callee = TREE_TYPE ( decl_callee ) ; } } if ( cfun -> machine -> is_interrupt || cfun -> machine -> is_signal || cfun -> machine -> is_naked || avr_naked_function_p ( decl_callee ) ) { return false ; } return true ;


<s> static rtx avr_function_value ( const_tree type , const_tree fn_decl_or_type ATTRIBUTE_UNUSED , bool outgoing ATTRIBUTE_UNUSED ) { unsigned int offs ; if ( TYPE_MODE ( type ) != BLKmode ) return avr_libcall_value ( TYPE_MODE ( type ) , NULL_RTX ) ; offs = int_size_in_bytes ( type ) ; if ( offs < <NUM_LIT> ) offs = <NUM_LIT> ;

if ( offs > <NUM_LIT> && offs < GET_MODE_SIZE ( SImode ) ) offs = GET_MODE_SIZE ( SImode ) ;


<s> if ( offs < <NUM_LIT> ) offs = <NUM_LIT> ; if ( offs > <NUM_LIT> && offs < GET_MODE_SIZE ( SImode ) ) offs = GET_MODE_SIZE ( SImode ) ;

else if ( offs > GET_MODE_SIZE ( SImode ) && offs < GET_MODE_SIZE ( DImode ) ) offs = GET_MODE_SIZE ( DImode ) ;


<s> static bool avr_function_value_regno_p ( const unsigned int regno ) { return ( regno == avr_ret_register ( ) ) ;


<s> } else if ( io_p && ( ! tree_fits_shwi_p ( arg ) || ! ( strcmp ( IDENTIFIER_POINTER ( name ) , <STR_LIT> ) == <NUM_LIT> ? low_io_address_operand : io_address_operand ) ( GEN_INT ( TREE_INT_CST_LOW ( arg ) ) , QImode ) ) ) { warning_at ( loc , OPT_Wattributes , <STR_LIT> <STR_LIT> , name ) ; * no_add = true ; } else { tree attribs = DECL_ATTRIBUTES ( * node ) ; const char * names [ ] = { <STR_LIT> , <STR_LIT> , <STR_LIT> , NULL } ; for ( const char * * p = names ; * p ; p ++ ) { tree other = lookup_attribute ( * p , attribs ) ; if ( other && TREE_VALUE ( other ) ) { warning_at ( loc , OPT_Wattributes , <STR_LIT> , * p , name ) ; * no_add = true ; break ; } } } }

if ( * no_add == false && io_p && ! TREE_THIS_VOLATILE ( * node ) ) warning_at ( loc , OPT_Wattributes , <STR_LIT> , name ) ;


<s> if ( TREE_CODE ( * node ) != FUNCTION_DECL ) {

warning ( OPT_Wattributes , <STR_LIT> , name ) ;


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


<s> tree attr = tree_cons ( name , args , TYPE_ATTRIBUTES ( type ) ) ; tree newtype = build_type_attribute_variant ( type , attr ) ; TYPE_MAIN_VARIANT ( newtype ) = TYPE_MAIN_VARIANT ( type ) ; TREE_TYPE ( * node ) = newtype ; * no_add_attrs = true ; } else if ( TREE_STATIC ( * node ) || DECL_EXTERNAL ( * node ) ) { * no_add_attrs = false ; } else { warning ( OPT_Wattributes , <STR_LIT> , name ) ;


<s> if ( ! avr_hard_regno_mode_ok ( regno , mode ) ) return <NUM_LIT> ; return ( ( regno <= LAST_CALLEE_SAVED_REG && regno + GET_MODE_SIZE ( mode ) > <NUM_LIT> + LAST_CALLEE_SAVED_REG ) || ( regno < REG_Y && regno + GET_MODE_SIZE ( mode ) > REG_Y ) || ( regno < REG_Z && regno + GET_MODE_SIZE ( mode ) > REG_Z ) ) ;


<s> if ( regno == REG_CC ) return mode == CCmode ; if ( GET_MODE_SIZE ( mode ) == <NUM_LIT> ) return true ; if ( GET_MODE_SIZE ( mode ) >= <NUM_LIT> && regno >= REG_X ) return false ; return ! ( regno & <NUM_LIT> ) ;


<s> static bool avr_hard_regno_mode_ok ( unsigned int regno , machine_mode mode ) { if ( regno == REG_CC ) return mode == CCmode ; if ( GET_MODE_SIZE ( mode ) == <NUM_LIT> ) return true ; if ( GET_MODE_SIZE ( mode ) >= <NUM_LIT> && regno >= REG_X ) return false ; return ! ( regno & <NUM_LIT> ) ;


<s> if ( regno == REG_CC && mode == CCmode ) return <NUM_LIT> ; return CEIL ( GET_MODE_SIZE ( mode ) , UNITS_PER_WORD ) ;


<s> if ( ( ! reload_completed || frame_pointer_needed ) && ( regno == REG_Y || regno == REG_Y + <NUM_LIT> ) ) { return false ; } return true ;


<s> bool avr_has_nibble_0xf ( rtx ival ) {

unsigned int map = UINTVAL ( ival ) & GET_MODE_MASK ( SImode ) ;


<s> if ( AVR_HAVE_RAMPY && ! frame_pointer_needed && ( REG_Y == regno || REG_Y + <NUM_LIT> == regno ) && TEST_HARD_REG_BIT ( * set , REG_Y ) && TEST_HARD_REG_BIT ( * set , REG_Y + <NUM_LIT> ) ) continue ; if ( AVR_HAVE_RAMPZ && ( REG_Z == regno || REG_Z + <NUM_LIT> == regno ) && TEST_HARD_REG_BIT ( * set , REG_Z ) && TEST_HARD_REG_BIT ( * set , REG_Z + <NUM_LIT> ) ) continue ; CLEAR_HARD_REG_BIT ( * set , regno ) ;


<s> if ( AVR_HAVE_RAMPY && ! frame_pointer_needed && ( REG_Y == regno || REG_Y + <NUM_LIT> == regno ) && TEST_HARD_REG_BIT ( * set , REG_Y ) && TEST_HARD_REG_BIT ( * set , REG_Y + <NUM_LIT> ) ) continue ; if ( AVR_HAVE_RAMPZ && ( REG_Z == regno || REG_Z + <NUM_LIT> == regno ) && TEST_HARD_REG_BIT ( * set , REG_Z ) && TEST_HARD_REG_BIT ( * set , REG_Z + <NUM_LIT> ) ) continue ; CLEAR_HARD_REG_BIT ( * set , regno ) ; return regno ; }


<s> rtx avr_incoming_return_addr_rtx ( void ) { return gen_frame_mem ( HImode , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> ) ) ;


<s> return gen_frame_mem ( HImode , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> ) ) ;


<s> int offset = frame_pointer_needed ? <NUM_LIT> : <NUM_LIT> ; int avr_pc_size = AVR_HAVE_EIJMP_EICALL ? <NUM_LIT> : <NUM_LIT> ; offset += avr_regs_to_save ( NULL ) ; return ( get_frame_size ( ) + avr_outgoing_args_size ( ) + avr_pc_size + <NUM_LIT> + offset ) ; }


<s> offset += avr_regs_to_save ( NULL ) ; return ( get_frame_size ( ) + avr_outgoing_args_size ( ) + avr_pc_size + <NUM_LIT> + offset ) ;


<s> tree uint24_type = make_unsigned_type ( GET_MODE_BITSIZE ( PSImode ) ) ;


<s> void avr_init_cumulative_args ( CUMULATIVE_ARGS * cum , tree fntype , rtx libname , tree fndecl ATTRIBUTE_UNUSED ) { cum -> nregs = AVR_TINY ? <NUM_LIT> : <NUM_LIT> ; cum -> regno = FIRST_CUM_REG ; if ( ! libname && stdarg_p ( fntype ) ) cum -> nregs = <NUM_LIT> ; cfun -> machine -> sibcall_fails = <NUM_LIT> ;


<s> lpm_reg_rtx = all_regs_rtx [ LPM_REGNO ] ; tmp_reg_rtx = all_regs_rtx [ AVR_TMP_REGNO ] ; zero_reg_rtx = all_regs_rtx [ AVR_ZERO_REGNO ] ; cc_reg_rtx = gen_rtx_REG ( CCmode , REG_CC ) ; lpm_addr_reg_rtx = gen_rtx_REG ( HImode , REG_Z ) ; sreg_rtx = gen_rtx_MEM ( QImode , GEN_INT ( avr_addr . sreg ) ) ; rampd_rtx = gen_rtx_MEM ( QImode , GEN_INT ( avr_addr . rampd ) ) ; rampx_rtx = gen_rtx_MEM ( QImode , GEN_INT ( avr_addr . rampx ) ) ; rampy_rtx = gen_rtx_MEM ( QImode , GEN_INT ( avr_addr . rampy ) ) ; rampz_rtx = gen_rtx_MEM ( QImode , GEN_INT ( avr_addr . rampz ) ) ; xstring_empty = gen_rtx_CONST_STRING ( VOIDmode , <STR_LIT> ) ;

xstring_e = gen_rtx_CONST_STRING ( VOIDmode , <STR_LIT> ) ;


<s> static struct machine_function * avr_init_machine_status ( void ) { return ggc_cleared_alloc < machine_function > ( ) ;


<s> while ( TREE_CODE ( node0 ) == ARRAY_TYPE ) ; if ( error_mark_node == node0 ) return ; as = TYPE_ADDR_SPACE ( TREE_TYPE ( node ) ) ; if ( ! TYPE_READONLY ( node0 ) && ! TREE_READONLY ( node ) ) { const char * reason = <STR_LIT> ; if ( ! ADDR_SPACE_GENERIC_P ( as ) ) reason = avr_addrspace [ as ] . name ; if ( avr_log . progmem ) avr_edump ( <STR_LIT> , node , node0 ) ; error ( <STR_LIT> <STR_LIT> , node , reason ) ; }


<s> while ( TREE_CODE ( node0 ) == ARRAY_TYPE ) ; if ( error_mark_node == node0 ) return ; as = TYPE_ADDR_SPACE ( TREE_TYPE ( node ) ) ; if ( ! TYPE_READONLY ( node0 ) && ! TREE_READONLY ( node ) ) { const char * reason = <STR_LIT> ; if ( ! ADDR_SPACE_GENERIC_P ( as ) ) reason = avr_addrspace [ as ] . name ;

if ( avr_log . progmem ) avr_edump ( <STR_LIT> , node , node0 ) ;


<s> static int avr_interrupt_function_p ( tree func ) {

return avr_lookup_function_attribute1 ( func , <STR_LIT> ) ;


<s> } if ( dump_file ) { fprintf ( dump_file , <STR_LIT> <STR_LIT> , bb -> index ) ; for ( int i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) print_rtl_single ( dump_file , insns [ i ] ) ; } rtx_insn * xinsn = avr_parallel_insn_from_insns ( insns ) ; INSN_CODE ( xinsn ) = recog ( PATTERN ( xinsn ) , xinsn , NULL ) ; if ( INSN_CODE ( xinsn ) < <NUM_LIT> ) { if ( dump_file ) fprintf ( dump_file , <STR_LIT> ) ; return false ; } gcc_assert ( CODE_FOR_casesi_qi_sequence == INSN_CODE ( xinsn ) || CODE_FOR_casesi_hi_sequence == INSN_CODE ( xinsn ) ) ; extract_insn ( xinsn ) ; gcc_assert ( recog_data . n_operands == <NUM_LIT> ) ; gcc_assert ( recog_data . n_dups == <NUM_LIT> ) ; if ( dump_file ) { fprintf ( dump_file , <STR_LIT> ) ;

for ( int i = <NUM_LIT> ; i < recog_data . n_operands ; i ++ ) avr_fdump ( dump_file , <STR_LIT> , i , recog_data . operand [ i ] ) ;


<s> case POST_INC : case PRE_DEC : ok = avr_reg_ok_for_addr_p ( XEXP ( x , <NUM_LIT> ) , ADDR_SPACE_GENERIC , GET_CODE ( x ) , strict ) ; break ; case PLUS : { rtx reg = XEXP ( x , <NUM_LIT> ) ; rtx op1 = XEXP ( x , <NUM_LIT> ) ; if ( REG_P ( reg ) && CONST_INT_P ( op1 ) && INTVAL ( op1 ) >= <NUM_LIT> ) { bool fit = IN_RANGE ( INTVAL ( op1 ) , <NUM_LIT> , MAX_LD_OFFSET ( mode ) ) ; if ( fit ) { ok = ( ! strict || avr_reg_ok_for_addr_p ( reg , ADDR_SPACE_GENERIC , PLUS , strict ) ) ; if ( reg == frame_pointer_rtx || reg == arg_pointer_rtx ) { ok = true ; } } else if ( frame_pointer_needed && reg == frame_pointer_rtx ) { ok = true ; } } } break ; default : break ; }

if ( AVR_TINY && CONSTANT_ADDRESS_P ( x ) ) {


<s> if ( SUBREG_P ( op ) && MEM_P ( SUBREG_REG ( op ) ) && ( GET_MODE_SIZE ( GET_MODE ( op ) ) > GET_MODE_SIZE ( GET_MODE ( SUBREG_REG ( op ) ) ) ) ) { return false ; } } return true ;


<s> if ( SUBREG_P ( op ) && MEM_P ( SUBREG_REG ( op ) ) && ( GET_MODE_SIZE ( GET_MODE ( op ) ) > GET_MODE_SIZE ( GET_MODE ( SUBREG_REG ( op ) ) ) ) ) {


<s> x = oldx ; if ( AVR_TINY ) { if ( CONSTANT_ADDRESS_P ( x ) && ! avr_address_tiny_absdata_p ( x , mode ) ) { x = force_reg ( Pmode , x ) ; } } if ( GET_CODE ( oldx ) == PLUS && REG_P ( XEXP ( oldx , <NUM_LIT> ) ) ) { if ( REG_P ( XEXP ( oldx , <NUM_LIT> ) ) ) x = force_reg ( GET_MODE ( oldx ) , oldx ) ; else if ( CONST_INT_P ( XEXP ( oldx , <NUM_LIT> ) ) ) { int offs = INTVAL ( XEXP ( oldx , <NUM_LIT> ) ) ; if ( frame_pointer_rtx != XEXP ( oldx , <NUM_LIT> ) && offs > MAX_LD_OFFSET ( mode ) ) { big_offset_p = true ;


<s> bool fit = INTVAL ( XEXP ( x , <NUM_LIT> ) ) <= MAX_LD_OFFSET ( mode ) ; if ( fit ) { if ( reg_equiv_address ( REGNO ( XEXP ( x , <NUM_LIT> ) ) ) != <NUM_LIT> ) { int regno = REGNO ( XEXP ( x , <NUM_LIT> ) ) ; rtx mem = mk_memloc ( x , regno ) ; push_reload ( XEXP ( mem , <NUM_LIT> ) , NULL_RTX , & XEXP ( mem , <NUM_LIT> ) , NULL , POINTER_REGS , Pmode , VOIDmode , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , ( enum reload_type ) addr_type ) ; if ( avr_log . legitimize_reload_address ) avr_edump ( <STR_LIT> , POINTER_REGS , XEXP ( mem , <NUM_LIT> ) , NULL_RTX ) ; push_reload ( mem , NULL_RTX , & XEXP ( x , <NUM_LIT> ) , NULL , BASE_POINTER_REGS , GET_MODE ( x ) , VOIDmode , <NUM_LIT> , <NUM_LIT> , opnum , ( enum reload_type ) type ) ; if ( avr_log . legitimize_reload_address ) avr_edump ( <STR_LIT> , BASE_POINTER_REGS , mem , NULL_RTX ) ; return x ; } } else if ( ! ( frame_pointer_needed && XEXP ( x , <NUM_LIT> ) == frame_pointer_rtx ) ) { push_reload ( x , NULL_RTX , px , NULL , POINTER_REGS , GET_MODE ( x ) , VOIDmode , <NUM_LIT> , <NUM_LIT> , opnum , ( enum reload_type ) type ) ;


<s> if ( offs <= <NUM_LIT> ) offs = ( offs + <NUM_LIT> ) & ~ <NUM_LIT> ;

return gen_rtx_REG ( mode , avr_ret_register ( ) + <NUM_LIT> - offs ) ;


<s> int n_bytes = GET_MODE_SIZE ( mode ) ;

return ( n_bytes > <NUM_LIT> && ! AVR_HAVE_LPMX && avr_mem_flash_p ( op ) ) ;


<s> if ( FUNCTION_DECL == TREE_CODE ( func ) ) { if ( NULL_TREE != lookup_attribute ( name , DECL_ATTRIBUTES ( func ) ) ) { return true ;


<s> } gcc_assert ( TREE_CODE ( func ) == FUNCTION_TYPE || TREE_CODE ( func ) == METHOD_TYPE ) ;

return NULL_TREE != lookup_attribute ( name , TYPE_ATTRIBUTES ( func ) ) ;


<s> return x < <NUM_LIT> ? ( f >> ( <NUM_LIT> * x ) ) & <NUM_LIT> : <NUM_LIT> ;


<s> if ( x > <NUM_LIT> ) return f_ginv ; } f_ginv . map = ( f_ginv . map << <NUM_LIT> ) + x ; } if ( avr_map_metric ( f_ginv . map , MAP_NONFIXED_0_7 ) == <NUM_LIT> ) f_ginv . cost = <NUM_LIT> + ( val_used_p && ! val_const_p ) ; else { rtx xop [ <NUM_LIT> ] ; xop [ <NUM_LIT> ] = all_regs_rtx [ <NUM_LIT> ] ; xop [ <NUM_LIT> ] = gen_int_mode ( f_ginv . map , SImode ) ; xop [ <NUM_LIT> ] = all_regs_rtx [ <NUM_LIT> ] ; xop [ <NUM_LIT> ] = val_used_p ? xop [ <NUM_LIT> ] : const0_rtx ;

avr_out_insert_bits ( xop , & f_ginv . cost ) ;


<s> int x = avr_map ( f , i ) ; if ( x <= <NUM_LIT> ) { x = avr_map ( ginv , x ) ; if ( x > <NUM_LIT> ) return f_ginv ; } f_ginv . map = ( f_ginv . map << <NUM_LIT> ) + x ; } if ( avr_map_metric ( f_ginv . map , MAP_NONFIXED_0_7 ) == <NUM_LIT> ) f_ginv . cost = <NUM_LIT> + ( val_used_p && ! val_const_p ) ; else {


<s> unsigned metric = <NUM_LIT> ; for ( unsigned i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { unsigned ai = avr_map ( a , i ) ; if ( mode == MAP_FIXED_0_7 ) metric += ai == i ; else if ( mode == MAP_NONFIXED_0_7 ) metric += ai < <NUM_LIT> && ai != i ; else if ( mode == MAP_MASK_FIXED_0_7 ) metric |= ( ( unsigned ) ( ai == i ) ) << i ; else if ( mode == MAP_PREIMAGE_0_7 ) metric += ai < <NUM_LIT> ; else if ( mode == MAP_MASK_PREIMAGE_F ) metric |= ( ( unsigned ) ( ai == <NUM_LIT> ) ) << i ;


<s> static rtx_insn * avr_md_asm_adjust ( vec < rtx > & , vec < rtx > & , vec < machine_mode > & , vec < const char * > & , vec < rtx > & clobbers , HARD_REG_SET & clobbered_regs , location_t ) {


<s> static rtx_insn * avr_md_asm_adjust ( vec < rtx > & , vec < rtx > & , vec < machine_mode > & , vec < const char * > & , vec < rtx > & clobbers , HARD_REG_SET & clobbered_regs , location_t ) { clobbers . safe_push ( cc_reg_rtx ) ; SET_HARD_REG_BIT ( clobbered_regs , REG_CC ) ;


<s> MEM_VOLATILE_P ( mem ) = <NUM_LIT> ;


<s> rtx mem = gen_rtx_MEM ( BLKmode , gen_rtx_SCRATCH ( Pmode ) ) ; MEM_VOLATILE_P ( mem ) = <NUM_LIT> ;


<s> return ( MEM_P ( x ) && ! ADDR_SPACE_GENERIC_P ( MEM_ADDR_SPACE ( x ) ) ) ;


<s> return ( MEM_P ( x ) && ADDR_SPACE_MEMX == MEM_ADDR_SPACE ( x ) ) ;


<s> bool avr_mem_memx_p ( rtx x ) { return ( MEM_P ( x ) && ADDR_SPACE_MEMX == MEM_ADDR_SPACE ( x ) ) ;


<s> } if ( ! avr_strict_X ) return reload_completed ? BASE_POINTER_REGS : POINTER_REGS ;


<s> if ( ! ADDR_SPACE_GENERIC_P ( as ) ) { return POINTER_Z_REGS ; } if ( ! avr_strict_X ) return reload_completed ? BASE_POINTER_REGS : POINTER_REGS ; return PLUS == outer_code ? BASE_POINTER_REGS : POINTER_REGS ;


<s> return ! ADDR_SPACE_GENERIC_P ( as ) ;


<s> for ( ; mask ; mask >>= <NUM_LIT> , op ++ , hreg ++ ) if ( ( mask & <NUM_LIT> ) && * hreg ) emit_move_insn ( * hreg , * op ) ; return true ;


<s> for ( ; mask ; mask >>= <NUM_LIT> , op ++ , hreg ++ ) if ( ( mask & <NUM_LIT> ) && * hreg ) emit_move_insn ( * hreg , * op ) ;


<s> if ( AVR_HAVE_MUL && LSHIFTRT == GET_CODE ( x ) && MULT == GET_CODE ( XEXP ( x , <NUM_LIT> ) ) && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) ) { machine_mode mode = GET_MODE ( x ) ; if ( HImode == mode || PSImode == mode || SImode == mode ) { return COSTS_N_INSNS ( <NUM_LIT> ) ; }


<s> static int avr_naked_function_p ( tree func ) {


<s> static int avr_naked_function_p ( tree func ) { return avr_lookup_function_attribute1 ( func , <STR_LIT> ) ;


<s> addr_space_t as ; tree target = TREE_TYPE ( typ ) ; if ( FUNCTION_TYPE == TREE_CODE ( target ) ) return avr_nonconst_pointer_addrspace ( TREE_TYPE ( target ) ) ; while ( TREE_CODE ( target ) == ARRAY_TYPE ) target = TREE_TYPE ( target ) ; as = TYPE_ADDR_SPACE ( target ) ; if ( ! ADDR_SPACE_GENERIC_P ( as ) && ! TYPE_READONLY ( target ) && avr_addr_space_supported_p ( as ) ) { return as ; } return avr_nonconst_pointer_addrspace ( target ) ; } return ADDR_SPACE_GENERIC ;


<s> RTX_CODE avr_normalize_condition ( RTX_CODE condition ) { switch ( condition ) { case GT : return GE ;


<s> default : break ; case CC_PLUS : case CC_LDI : { rtx * op = recog_data . operand ; int len_dummy , icc ; extract_constrain_insn_cached ( insn ) ; switch ( cc ) { default : gcc_unreachable ( ) ; case CC_PLUS : avr_out_plus ( insn , op , & len_dummy , & icc ) ; cc = ( enum attr_cc ) icc ; break ; case CC_LDI : cc = ( op [ <NUM_LIT> ] == CONST0_RTX ( GET_MODE ( op [ <NUM_LIT> ] ) ) && reg_overlap_mentioned_p ( op [ <NUM_LIT> ] , zero_reg_rtx ) ) ? CC_CLOBBER : CC_NONE ; break ; } break ; } } switch ( cc ) { default : gcc_unreachable ( ) ; break ; case CC_NONE : if ( cc_status . value1 || cc_status . value2 ) { HARD_REG_SET regs_used ; HARD_REG_SET regs_set ; CLEAR_HARD_REG_SET ( regs_used ) ; if ( cc_status . value1 && ! CONSTANT_P ( cc_status . value1 ) ) { find_all_hard_regs ( cc_status . value1 , & regs_used ) ; } if ( cc_status . value2 && ! CONSTANT_P ( cc_status . value2 ) ) { find_all_hard_regs ( cc_status . value2 , & regs_used ) ; } find_all_hard_reg_sets ( insn , & regs_set , false ) ; if ( hard_reg_set_intersect_p ( regs_used , regs_set ) ) { CC_STATUS_INIT ; } } break ; case CC_SET_N : CC_STATUS_INIT ; break ; case CC_SET_ZN : set = single_set ( insn ) ; CC_STATUS_INIT ; if ( set ) { cc_status . flags |= CC_NO_OVERFLOW ; cc_status . value1 = SET_DEST ( set ) ; } break ; case CC_SET_VZN : CC_STATUS_INIT ; break ; case CC_SET_CZN : set = single_set ( insn ) ; CC_STATUS_INIT ; if ( set ) { cc_status . value1 = SET_DEST ( set ) ; cc_status . flags |= CC_OVERFLOW_UNUSABLE ;


<s> break ; case CC_NONE : if ( cc_status . value1 || cc_status . value2 ) { HARD_REG_SET regs_used ; HARD_REG_SET regs_set ; CLEAR_HARD_REG_SET ( regs_used ) ; if ( cc_status . value1 && ! CONSTANT_P ( cc_status . value1 ) ) { find_all_hard_regs ( cc_status . value1 , & regs_used ) ; } if ( cc_status . value2 && ! CONSTANT_P ( cc_status . value2 ) ) { find_all_hard_regs ( cc_status . value2 , & regs_used ) ; } find_all_hard_reg_sets ( insn , & regs_set , false ) ; if ( hard_reg_set_intersect_p ( regs_used , regs_set ) ) { CC_STATUS_INIT ; } } break ; case CC_SET_N : CC_STATUS_INIT ; break ; case CC_SET_ZN : set = single_set ( insn ) ; CC_STATUS_INIT ; if ( set ) { cc_status . flags |= CC_NO_OVERFLOW ; cc_status . value1 = SET_DEST ( set ) ; } break ; case CC_SET_VZN : CC_STATUS_INIT ; break ; case CC_SET_CZN : set = single_set ( insn ) ; CC_STATUS_INIT ; if ( set ) { cc_status . value1 = SET_DEST ( set ) ; cc_status . flags |= CC_OVERFLOW_UNUSABLE ; } break ; case CC_COMPARE : set = single_set ( insn ) ; CC_STATUS_INIT ; if ( set ) cc_status . value1 = SET_SRC ( set ) ; break ; case CC_CLOBBER : CC_STATUS_INIT ; break ;


<s> return avr_lookup_function_attribute1 ( func , <STR_LIT> ) ;


<s> else size = GET_MODE_SIZE ( mode ) ;

return ( size + <NUM_LIT> ) & ~ <NUM_LIT> ;


if ( mode == BLKmode ) size = int_size_in_bytes ( type ) ;


<s> return COSTS_N_INSNS ( GET_MODE_SIZE ( mode ) ) ; default : break ; } total = <NUM_LIT> ; avr_rtx_costs ( x , mode , outer , opno , & total , speed ) ;


<s> int total ; switch ( code ) { case REG : case SUBREG : return <NUM_LIT> ; case CONST_INT : case CONST_FIXED : case CONST_DOUBLE :

return COSTS_N_INSNS ( GET_MODE_SIZE ( mode ) ) ;


<s> start_sequence ( ) ; rtx_insn * seq1 , * seq2 , * last1 , * last2 ; rtx reg = copy_to_mode_reg ( mode , xop [ <NUM_LIT> ] ) ; rtx ( * gen_add ) ( rtx , rtx , rtx ) = QImode == mode ? gen_addqi3 : gen_addhi3 ; rtx ( * gen_cbranch ) ( rtx , rtx , rtx , rtx ) = QImode == mode ? gen_cbranchqi4 : gen_cbranchhi4 ; emit_insn ( gen_add ( reg , reg , gen_int_mode ( - low_idx , mode ) ) ) ; rtx op0 = reg ; rtx op1 = gen_int_mode ( num_idx , mode ) ; rtx labelref = copy_rtx ( xop [ <NUM_LIT> ] ) ; emit_jump_insn ( gen_cbranch ( gen_rtx_fmt_ee ( GTU , VOIDmode , op0 , op1 ) , op0 , op1 , labelref ) ) ; seq1 = get_insns ( ) ; last1 = get_last_insn ( ) ; end_sequence ( ) ; emit_insn_after ( seq1 , insns [ <NUM_LIT> ] ) ; start_sequence ( ) ; if ( QImode == mode ) reg = force_reg ( HImode , gen_rtx_fmt_e ( code , HImode , reg ) ) ; rtx pat_4 = AVR_3_BYTE_PC ? gen_movhi ( xop [ <NUM_LIT> ] , reg ) : gen_addhi3 ( xop [ <NUM_LIT> ] , reg , gen_rtx_LABEL_REF ( VOIDmode , xop [ <NUM_LIT> ] ) ) ;


<s> if ( SIGN_EXTEND == code && low_idx >= imin && hig_idx <= imax ) { } else if ( ZERO_EXTEND == code && low_idx >= <NUM_LIT> && ( unsigned ) hig_idx <= umax ) { } else { if ( dump_file ) fprintf ( dump_file , <STR_LIT> ) ; return ; } start_sequence ( ) ; rtx_insn * seq1 , * seq2 , * last1 , * last2 ; rtx reg = copy_to_mode_reg ( mode , xop [ <NUM_LIT> ] ) ; rtx ( * gen_add ) ( rtx , rtx , rtx ) = QImode == mode ? gen_addqi3 : gen_addhi3 ; rtx ( * gen_cbranch ) ( rtx , rtx , rtx , rtx ) = QImode == mode ? gen_cbranchqi4 : gen_cbranchhi4 ; emit_insn ( gen_add ( reg , reg , gen_int_mode ( - low_idx , mode ) ) ) ; rtx op0 = reg ; rtx op1 = gen_int_mode ( num_idx , mode ) ; rtx labelref = copy_rtx ( xop [ <NUM_LIT> ] ) ; emit_jump_insn ( gen_cbranch ( gen_rtx_fmt_ee ( GTU , VOIDmode , op0 , op1 ) , op0 , op1 , labelref ) ) ; seq1 = get_insns ( ) ; last1 = get_last_insn ( ) ; end_sequence ( ) ; emit_insn_after ( seq1 , insns [ <NUM_LIT> ] ) ; start_sequence ( ) ;

if ( QImode == mode ) reg = force_reg ( HImode , gen_rtx_fmt_e ( code , HImode , reg ) ) ;


<s> static int avr_OS_main_function_p ( tree func ) { return avr_lookup_function_attribute1 ( func , <STR_LIT> ) ;


<s> return ( ACCUMULATE_OUTGOING_ARGS ? ( HOST_WIDE_INT ) crtl -> outgoing_args_size : <NUM_LIT> ) ;


<s> app_disable ( ) ; if ( DECL_SECTION_NAME ( current_function_decl ) && symtab_node :: get ( current_function_decl ) && ! symtab_node :: get ( current_function_decl ) -> implicit_section ) { switch_to_section ( current_function_section ( ) ) ; fprintf ( stream , <STR_LIT> ) ; } else { const char * sec_name = <STR_LIT> ; tree asm_name = DECL_ASSEMBLER_NAME ( current_function_decl ) ; const char * fname = IDENTIFIER_POINTER ( asm_name ) ; fname = targetm . strip_name_encoding ( fname ) ; sec_name = ACONCAT ( ( sec_name , <STR_LIT> , fname , NULL ) ) ; fprintf ( stream , <STR_LIT> , sec_name , AVR_HAVE_JMP_CALL ? <STR_LIT> : <STR_LIT> ) ; } ASM_OUTPUT_ALIGN ( stream , <NUM_LIT> ) ; targetm . asm_out . internal_label ( stream , <STR_LIT> , CODE_LABEL_NUMBER ( labl ) ) ; int vlen = XVECLEN ( table , <NUM_LIT> ) ;

for ( int idx = <NUM_LIT> ; idx < vlen ; idx ++ ) {


<s> else { const char * sec_name = <STR_LIT> ; tree asm_name = DECL_ASSEMBLER_NAME ( current_function_decl ) ; const char * fname = IDENTIFIER_POINTER ( asm_name ) ; fname = targetm . strip_name_encoding ( fname ) ; sec_name = ACONCAT ( ( sec_name , <STR_LIT> , fname , NULL ) ) ; fprintf ( stream , <STR_LIT> , sec_name , AVR_HAVE_JMP_CALL ? <STR_LIT> : <STR_LIT> ) ; } ASM_OUTPUT_ALIGN ( stream , <NUM_LIT> ) ;

targetm . asm_out . internal_label ( stream , <STR_LIT> , CODE_LABEL_NUMBER ( labl ) ) ;


<s> avr_need_clear_bss_p = true ; output_section_asm_op ( data ) ;


<s> static void avr_output_data_section_asm_op ( const char * data ) { avr_need_copy_data_p = true ;


<s> static void avr_output_progmem_section_asm_op ( const char * data ) { fprintf ( asm_out_file , <STR_LIT> , data ) ;


<s> addend += pc_len ; avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; } while ( addend ++ < <NUM_LIT> ) avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; } else if ( addend > <NUM_LIT> ) { if ( flag_verbose_asm || flag_print_asm_name ) avr_asm_len ( ASM_COMMENT_START <STR_LIT> , op , plen , <NUM_LIT> ) ; while ( addend -- > <NUM_LIT> ) avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; }


<s> addend += pc_len ; avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; } while ( addend ++ < <NUM_LIT> ) avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; } else if ( addend > <NUM_LIT> ) { if ( flag_verbose_asm || flag_print_asm_name ) avr_asm_len ( ASM_COMMENT_START <STR_LIT> , op , plen , <NUM_LIT> ) ; while ( addend -- > <NUM_LIT> ) avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; } return <STR_LIT> ;


<s> { int reg0 = REGNO ( op [ <NUM_LIT> ] ) ; int reg1 = REGNO ( op [ <NUM_LIT> ] ) ; if ( reg0 >= reg1 ) return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , <NUM_LIT> ) ; else return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , <NUM_LIT> ) ; } case <NUM_LIT> : { int reg0 = REGNO ( op [ <NUM_LIT> ] ) ;


<s> bool ld_reg_p = test_hard_reg_class ( LD_REGS , reg8 ) ; op [ <NUM_LIT> ] = reg8 ; op [ <NUM_LIT> ] = GEN_INT ( val8 ) ; switch ( code ) { case IOR : if ( pop8 == <NUM_LIT> ) continue ; else if ( ld_reg_p ) avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; else if ( pop8 == <NUM_LIT> ) { if ( set_t != <NUM_LIT> ) avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; set_t = <NUM_LIT> ; op [ <NUM_LIT> ] = GEN_INT ( exact_log2 ( val8 ) ) ; avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; } else if ( pop8 == <NUM_LIT> ) { if ( op [ <NUM_LIT> ] != NULL_RTX ) avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; else avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , op , plen , <NUM_LIT> ) ; op [ <NUM_LIT> ] = op [ <NUM_LIT> ] ; } else { if ( clobber_val != ( int ) val8 ) avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; clobber_val = ( int ) val8 ; avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; } continue ; case AND : if ( pop8 == <NUM_LIT> ) continue ; else if ( pop8 == <NUM_LIT> ) avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; else if ( ld_reg_p ) avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; else if ( pop8 == <NUM_LIT> ) { if ( set_t != <NUM_LIT> ) avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; set_t = <NUM_LIT> ; op [ <NUM_LIT> ] = GEN_INT ( exact_log2 ( GET_MODE_MASK ( QImode ) & ~ val8 ) ) ; avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; } else { if ( clobber_val != ( int ) val8 ) avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; clobber_val = ( int ) val8 ; avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; } continue ; case XOR : if ( pop8 == <NUM_LIT> ) continue ; else if ( pop8 == <NUM_LIT> ) avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; else if ( ld_reg_p && val8 == ( <NUM_LIT> << <NUM_LIT> ) ) avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; else { if ( clobber_val != ( int ) val8 ) avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ;


<s> rtx xreg = xop [ <NUM_LIT> ] ; rtx xval = xop [ <NUM_LIT> ] ; machine_mode mode ; int n_bytes = GET_MODE_SIZE ( GET_MODE ( xreg ) ) ; int clobber_val = - <NUM_LIT> ; if ( CONST_FIXED_P ( xval ) ) { xreg = avr_to_int_mode ( xop [ <NUM_LIT> ] ) ; xval = avr_to_int_mode ( xop [ <NUM_LIT> ] ) ; } mode = GET_MODE ( xreg ) ; gcc_assert ( REG_P ( xreg ) ) ; gcc_assert ( ( CONST_INT_P ( xval ) && n_bytes <= <NUM_LIT> ) || ( const_double_operand ( xval , VOIDmode ) && n_bytes == <NUM_LIT> ) ) ; if ( plen ) * plen = <NUM_LIT> ; if ( ! test_hard_reg_class ( LD_REGS , xreg ) && compare_eq_p ( insn ) && reg_unused_after ( insn , xreg ) ) { if ( xval == const1_rtx ) { avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , xop , plen , <NUM_LIT> ) ; if ( n_bytes >= <NUM_LIT> ) avr_asm_len ( <STR_LIT> , xop , plen , <NUM_LIT> ) ; if ( n_bytes >= <NUM_LIT> ) avr_asm_len ( <STR_LIT> , xop , plen , <NUM_LIT> ) ; return <STR_LIT> ; } else if ( xval == constm1_rtx ) { if ( n_bytes >= <NUM_LIT> ) avr_asm_len ( <STR_LIT> , xop , plen , <NUM_LIT> ) ; if ( n_bytes >= <NUM_LIT> ) avr_asm_len ( <STR_LIT> , xop , plen , <NUM_LIT> ) ; return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , xop , plen , <NUM_LIT> ) ; } } if ( n_bytes == <NUM_LIT> && xval != const0_rtx && test_hard_reg_class ( LD_REGS , xreg ) && compare_eq_p ( insn ) && ! reg_unused_after ( insn , xreg ) ) {

rtx xlo8 = simplify_gen_subreg ( QImode , xval , mode , <NUM_LIT> ) ;


<s> xop [ <NUM_LIT> ] = tmp_reg_rtx ; fixp_p = false ; } if ( avr_map_metric ( map , MAP_MASK_PREIMAGE_F ) ) { int n_fix = <NUM_LIT> , n_nofix = <NUM_LIT> ; gcc_assert ( REG_P ( xop [ <NUM_LIT> ] ) ) ; avr_move_bits ( xop , map , true , & n_fix ) ; avr_move_bits ( xop , map , false , & n_nofix ) ; if ( fixp_p && n_fix - n_nofix > <NUM_LIT> ) { xop [ <NUM_LIT> ] = gen_int_mode ( ~ mask_fixed , QImode ) ; avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , xop , plen , <NUM_LIT> ) ; fixp_p = false ; } } else { if ( fixp_p && mask_fixed ) {

avr_asm_len ( <STR_LIT> , xop , plen , <NUM_LIT> ) ;


<s> unsigned mask_fixed ; bool fixp_p = true ; rtx xop [ <NUM_LIT> ] ; xop [ <NUM_LIT> ] = op [ <NUM_LIT> ] ; xop [ <NUM_LIT> ] = op [ <NUM_LIT> ] ; xop [ <NUM_LIT> ] = op [ <NUM_LIT> ] ; gcc_assert ( REG_P ( xop [ <NUM_LIT> ] ) || CONST_INT_P ( xop [ <NUM_LIT> ] ) ) ; if ( plen ) * plen = <NUM_LIT> ; else if ( flag_print_asm_name ) fprintf ( asm_out_file , ASM_COMMENT_START <STR_LIT> , map ) ; mask_fixed = avr_map_metric ( map , MAP_MASK_FIXED_0_7 ) ; if ( REGNO ( xop [ <NUM_LIT> ] ) == REGNO ( xop [ <NUM_LIT> ] ) ) { avr_asm_len ( <STR_LIT> , xop , plen , <NUM_LIT> ) ; xop [ <NUM_LIT> ] = tmp_reg_rtx ; fixp_p = false ; } if ( avr_map_metric ( map , MAP_MASK_PREIMAGE_F ) ) { int n_fix = <NUM_LIT> , n_nofix = <NUM_LIT> ; gcc_assert ( REG_P ( xop [ <NUM_LIT> ] ) ) ; avr_move_bits ( xop , map , true , & n_fix ) ; avr_move_bits ( xop , map , false , & n_nofix ) ; if ( fixp_p && n_fix - n_nofix > <NUM_LIT> ) { xop [ <NUM_LIT> ] = gen_int_mode ( ~ mask_fixed , QImode ) ; avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , xop , plen , <NUM_LIT> ) ; fixp_p = false ; } } else { if ( fixp_p && mask_fixed ) { avr_asm_len ( <STR_LIT> , xop , plen , <NUM_LIT> ) ; fixp_p = false ; } }

avr_move_bits ( xop , map , fixp_p , plen ) ;


<s> avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; } } else if ( test_hard_reg_class ( LD_REGS , op [ <NUM_LIT> ] ) && ( INTVAL ( op [ <NUM_LIT> ] ) != INTVAL ( op [ <NUM_LIT> ] ) || ! reg_overlap_mentioned_p ( op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ) ) { avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; }


<s> } else { avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; } } else if ( test_hard_reg_class ( LD_REGS , op [ <NUM_LIT> ] ) && ( INTVAL ( op [ <NUM_LIT> ] ) != INTVAL ( op [ <NUM_LIT> ] ) || ! reg_overlap_mentioned_p ( op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ) ) { avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; } else { avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; if ( ! reg_unused_after ( insn , op [ <NUM_LIT> ] ) || reg_overlap_mentioned_p ( op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ) {

avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ;


<s> rtx base = XEXP ( src , <NUM_LIT> ) ; int reg_dest = true_regnum ( dest ) ; int reg_base = true_regnum ( base ) ; reg_base = true_regnum ( XEXP ( base , <NUM_LIT> ) ) ; if ( reg_base == reg_dest ) { return avr_asm_len ( TINY_ADIW ( % I1 , % J1 , % o1 + <NUM_LIT> ) CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB TINY_SBIW ( % I1 , % J1 , <NUM_LIT> ) CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; } else {


<s> else { avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; if ( reg_dest != reg_base - <NUM_LIT> && ! reg_unused_after ( insn , base ) ) {

avr_asm_len ( TINY_SBIW ( % E1 , % F1 , <NUM_LIT> ) , op , plen , <NUM_LIT> ) ;


<s> } else if ( ! AVR_HAVE_LPMX ) { return avr_out_lpm_no_lpmx ( insn , xop , plen ) ; } switch ( GET_CODE ( addr ) ) { default : gcc_unreachable ( ) ; case REG : gcc_assert ( REG_Z == REGNO ( addr ) ) ; switch ( n_bytes ) { default : gcc_unreachable ( ) ; case <NUM_LIT> : avr_asm_len ( <STR_LIT> , xop , plen , <NUM_LIT> ) ; break ; case <NUM_LIT> : if ( REGNO ( dest ) == REG_Z ) avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , xop , plen , <NUM_LIT> ) ; else { avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , xop , plen , <NUM_LIT> ) ; if ( ! reg_unused_after ( insn , addr ) ) avr_asm_len ( <STR_LIT> , xop , plen , <NUM_LIT> ) ; } break ; case <NUM_LIT> : avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , xop , plen , <NUM_LIT> ) ; if ( ! reg_unused_after ( insn , addr ) ) avr_asm_len ( <STR_LIT> , xop , plen , <NUM_LIT> ) ; break ; case <NUM_LIT> : avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , xop , plen , <NUM_LIT> ) ; if ( REGNO ( dest ) == REG_Z - <NUM_LIT> ) avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , xop , plen , <NUM_LIT> ) ; else { avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , xop , plen , <NUM_LIT> ) ; if ( ! reg_unused_after ( insn , addr ) ) avr_asm_len ( <STR_LIT> , xop , plen , <NUM_LIT> ) ; } break ; } break ; case POST_INC : gcc_assert ( REG_Z == REGNO ( XEXP ( addr , <NUM_LIT> ) ) && n_bytes <= <NUM_LIT> ) ; avr_asm_len ( <STR_LIT> , xop , plen , <NUM_LIT> ) ; if ( n_bytes >= <NUM_LIT> ) avr_asm_len ( <STR_LIT> , xop , plen , <NUM_LIT> ) ; if ( n_bytes >= <NUM_LIT> ) avr_asm_len ( <STR_LIT> , xop , plen , <NUM_LIT> ) ; if ( n_bytes >= <NUM_LIT> ) avr_asm_len ( <STR_LIT> , xop , plen , <NUM_LIT> ) ; break ; } if ( xop [ <NUM_LIT> ] == xstring_e && AVR_HAVE_RAMPD ) {


<s> const char * avr_out_lshrpsi3 ( rtx_insn * insn , rtx * op , int * plen ) { int dest = REGNO ( op [ <NUM_LIT> ] ) ; int src = REGNO ( op [ <NUM_LIT> ] ) ; if ( CONST_INT_P ( op [ <NUM_LIT> ] ) ) { if ( plen ) * plen = <NUM_LIT> ; switch ( INTVAL ( op [ <NUM_LIT> ] ) ) { case <NUM_LIT> : if ( dest <= src ) return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , <NUM_LIT> ) ; else return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , <NUM_LIT> ) ; case <NUM_LIT> : if ( dest != src + <NUM_LIT> ) avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , op , plen , <NUM_LIT> ) ; default : if ( INTVAL ( op [ <NUM_LIT> ] ) < <NUM_LIT> ) break ; case <NUM_LIT> : return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , <NUM_LIT> ) ; }


<s> int src = REGNO ( op [ <NUM_LIT> ] ) ; if ( CONST_INT_P ( op [ <NUM_LIT> ] ) ) { if ( plen ) * plen = <NUM_LIT> ; switch ( INTVAL ( op [ <NUM_LIT> ] ) ) { case <NUM_LIT> : if ( dest <= src ) return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , <NUM_LIT> ) ; else return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , <NUM_LIT> ) ; case <NUM_LIT> : if ( dest != src + <NUM_LIT> ) avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , op , plen , <NUM_LIT> ) ; default : if ( INTVAL ( op [ <NUM_LIT> ] ) < <NUM_LIT> ) break ; case <NUM_LIT> : return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , <NUM_LIT> ) ; } }


if ( ! mem_volatile_p ) return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ;


<s> static const char * avr_out_movhi_r_mr_pre_dec_tiny ( rtx_insn * insn , rtx op [ ] , int * plen ) { int mem_volatile_p = <NUM_LIT> ; rtx dest = op [ <NUM_LIT> ] ; rtx src = op [ <NUM_LIT> ] ; rtx base = XEXP ( src , <NUM_LIT> ) ;

mem_volatile_p = MEM_VOLATILE_P ( src ) ;


<s> rtx dest = op [ <NUM_LIT> ] ; rtx src = op [ <NUM_LIT> ] ; rtx base = XEXP ( src , <NUM_LIT> ) ; mem_volatile_p = MEM_VOLATILE_P ( src ) ; if ( reg_overlap_mentioned_p ( dest , XEXP ( base , <NUM_LIT> ) ) ) fatal_insn ( <STR_LIT> , insn ) ; if ( ! mem_volatile_p ) return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; return avr_asm_len ( TINY_SBIW ( % I1 , % J1 , <NUM_LIT> ) CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB TINY_SBIW ( % I1 , % J1 , <NUM_LIT> ) , op , plen , - <NUM_LIT> ) ;


<s> else { avr_asm_len ( TINY_ADIW ( % I1 , % J1 , % o1 ) CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; if ( ! reg_unused_after ( insn , XEXP ( base , <NUM_LIT> ) ) ) avr_asm_len ( TINY_SBIW ( % I1 , % J1 , % o1 + <NUM_LIT> ) , op , plen , <NUM_LIT> ) ; return <STR_LIT> ; }


<s> int reg_dest = true_regnum ( dest ) ; int reg_base = true_regnum ( base ) ; if ( reg_dest == reg_base ) return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ;


<s> if ( register_operand ( dest , VOIDmode ) ) { if ( register_operand ( src , VOIDmode ) ) { if ( true_regnum ( dest ) > true_regnum ( src ) ) { avr_asm_len ( <STR_LIT> , op , plen , - <NUM_LIT> ) ; if ( AVR_HAVE_MOVW ) return avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; else return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , op , plen , <NUM_LIT> ) ; } else { if ( AVR_HAVE_MOVW ) avr_asm_len ( <STR_LIT> , op , plen , - <NUM_LIT> ) ;


<s> rtx src = op [ <NUM_LIT> ] ; if ( avr_mem_flash_p ( src ) || avr_mem_flash_p ( dest ) ) { return avr_out_lpm ( insn , op , plen ) ; } if ( register_operand ( dest , VOIDmode ) ) { if ( register_operand ( src , VOIDmode ) ) { if ( true_regnum ( dest ) > true_regnum ( src ) ) { avr_asm_len ( <STR_LIT> , op , plen , - <NUM_LIT> ) ; if ( AVR_HAVE_MOVW ) return avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; else return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , op , plen , <NUM_LIT> ) ; } else { if ( AVR_HAVE_MOVW ) avr_asm_len ( <STR_LIT> , op , plen , - <NUM_LIT> ) ; else avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; return avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; } } else if ( CONSTANT_P ( src ) ) { return avr_out_reload_inpsi ( op , NULL_RTX , plen ) ; } else if ( MEM_P ( src ) ) return avr_out_load_psi ( insn , op , plen ) ;


<s> static const char * avr_out_movqi_mr_r_reg_disp_tiny ( rtx_insn * insn , rtx op [ ] , int * plen ) { rtx dest = op [ <NUM_LIT> ] ; rtx src = op [ <NUM_LIT> ] ; rtx x = XEXP ( dest , <NUM_LIT> ) ; if ( reg_overlap_mentioned_p ( src , XEXP ( x , <NUM_LIT> ) ) ) { avr_asm_len ( <STR_LIT> CR_TAB TINY_ADIW ( % I0 , % J0 , % o0 ) CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; } else { avr_asm_len ( TINY_ADIW ( % I0 , % J0 , % o0 ) CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; }

if ( ! reg_unused_after ( insn , XEXP ( x , <NUM_LIT> ) ) ) avr_asm_len ( TINY_SBIW ( % I0 , % J0 , % o0 ) , op , plen , <NUM_LIT> ) ;


<s> rtx dest = op [ <NUM_LIT> ] ; rtx src = op [ <NUM_LIT> ] ; rtx x = XEXP ( src , <NUM_LIT> ) ; avr_asm_len ( TINY_ADIW ( % I1 , % J1 , % o1 ) CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; if ( ! reg_overlap_mentioned_p ( dest , XEXP ( x , <NUM_LIT> ) ) && ! reg_unused_after ( insn , XEXP ( x , <NUM_LIT> ) ) ) avr_asm_len ( TINY_SBIW ( % I1 , % J1 , % o1 ) , op , plen , <NUM_LIT> ) ;


<s> static const char * avr_out_movsi_mr_r_reg_disp_tiny ( rtx op [ ] , int * l ) { rtx dest = op [ <NUM_LIT> ] ; rtx src = op [ <NUM_LIT> ] ; rtx base = XEXP ( dest , <NUM_LIT> ) ; int reg_base = REGNO ( XEXP ( base , <NUM_LIT> ) ) ; int reg_src = true_regnum ( src ) ; if ( reg_base == reg_src ) { * l = <NUM_LIT> ;


<s> rtx src = op [ <NUM_LIT> ] ; rtx base = XEXP ( dest , <NUM_LIT> ) ; int reg_base = true_regnum ( base ) ; int reg_src = true_regnum ( src ) ; if ( reg_base == reg_src ) { if ( reg_unused_after ( insn , base ) ) { return * l = <NUM_LIT> , ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB TINY_ADIW ( % E0 , % F0 , <NUM_LIT> ) CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> ) ; }


<s> int cc_plus , cc_minus , cc_dummy ; int len_plus , len_minus ; rtx op [ <NUM_LIT> ] ; rtx xpattern = INSN_P ( insn ) ? single_set ( as_a < rtx_insn * > ( insn ) ) : insn ; rtx xdest = SET_DEST ( xpattern ) ; machine_mode mode = GET_MODE ( xdest ) ; scalar_int_mode imode = int_mode_for_mode ( mode ) . require ( ) ; int n_bytes = GET_MODE_SIZE ( mode ) ; enum rtx_code code_sat = GET_CODE ( SET_SRC ( xpattern ) ) ; enum rtx_code code = ( PLUS == code_sat || SS_PLUS == code_sat || US_PLUS == code_sat ? PLUS : MINUS ) ; if ( ! pcc ) pcc = & cc_dummy ; if ( PLUS == code_sat || MINUS == code_sat ) code_sat = UNKNOWN ; if ( n_bytes <= <NUM_LIT> && REG_P ( xop [ <NUM_LIT> ] ) ) { avr_out_plus_1 ( xop , plen , code , pcc , code_sat , <NUM_LIT> , out_label ) ; return <STR_LIT> ; } if ( n_bytes == <NUM_LIT> ) { op [ <NUM_LIT> ] = gen_rtx_REG ( DImode , ACC_A ) ; op [ <NUM_LIT> ] = gen_rtx_REG ( DImode , ACC_A ) ; op [ <NUM_LIT> ] = avr_to_int_mode ( xop [ <NUM_LIT> ] ) ;


<s> rtx xdest = SET_DEST ( xpattern ) ; machine_mode mode = GET_MODE ( xdest ) ; scalar_int_mode imode = int_mode_for_mode ( mode ) . require ( ) ; int n_bytes = GET_MODE_SIZE ( mode ) ; enum rtx_code code_sat = GET_CODE ( SET_SRC ( xpattern ) ) ; enum rtx_code code = ( PLUS == code_sat || SS_PLUS == code_sat || US_PLUS == code_sat ? PLUS : MINUS ) ; if ( ! pcc ) pcc = & cc_dummy ; if ( PLUS == code_sat || MINUS == code_sat ) code_sat = UNKNOWN ; if ( n_bytes <= <NUM_LIT> && REG_P ( xop [ <NUM_LIT> ] ) ) { avr_out_plus_1 ( xop , plen , code , pcc , code_sat , <NUM_LIT> , out_label ) ; return <STR_LIT> ; } if ( n_bytes == <NUM_LIT> ) { op [ <NUM_LIT> ] = gen_rtx_REG ( DImode , ACC_A ) ; op [ <NUM_LIT> ] = gen_rtx_REG ( DImode , ACC_A ) ; op [ <NUM_LIT> ] = avr_to_int_mode ( xop [ <NUM_LIT> ] ) ; }


<s> static const char * avr_out_plus_symbol ( rtx * xop , enum rtx_code code , int * plen , int * pcc ) {

machine_mode mode = GET_MODE ( xop [ <NUM_LIT> ] ) ;


<s> output_reload_in_const ( op , clobber_reg , len , false ) ;


<s> wide_int wi_add = wi :: set_bit_in_zero ( fbit - <NUM_LIT> - INTVAL ( xop [ <NUM_LIT> ] ) , GET_MODE_PRECISION ( imode ) ) ; int len_add = <NUM_LIT> , * plen_add = plen ? & len_add : NULL ; int len_and = <NUM_LIT> , * plen_and = plen ? & len_and : NULL ; rtx xadd = const_fixed_from_double_int ( i_add , mode ) ; rtx xpattern , xsrc , op [ <NUM_LIT> ] ; xsrc = SIGNED_FIXED_POINT_MODE_P ( mode ) ? gen_rtx_SS_PLUS ( mode , xop [ <NUM_LIT> ] , xadd ) : gen_rtx_US_PLUS ( mode , xop [ <NUM_LIT> ] , xadd ) ; xpattern = gen_rtx_SET ( xop [ <NUM_LIT> ] , xsrc ) ; op [ <NUM_LIT> ] = xop [ <NUM_LIT> ] ; op [ <NUM_LIT> ] = xop [ <NUM_LIT> ] ; op [ <NUM_LIT> ] = xadd ; avr_out_plus ( xpattern , op , plen_add , NULL , false ) ; avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , NULL , plen_add , <NUM_LIT> ) ; rtx xreg = simplify_gen_subreg ( imode , xop [ <NUM_LIT> ] , mode , <NUM_LIT> ) ; rtx xmask = immed_wide_int_const ( - wi_add - wi_add , imode ) ; xpattern = gen_rtx_SET ( xreg , gen_rtx_AND ( imode , xreg , xmask ) ) ;


<s> switch ( GET_CODE ( operands [ <NUM_LIT> ] ) ) { default : gcc_unreachable ( ) ; case CONST_INT : case CONST : case SYMBOL_REF : if ( low_io_address_operand ( operands [ <NUM_LIT> ] , QImode ) ) { if ( comp == EQ ) output_asm_insn ( <STR_LIT> , operands ) ; else output_asm_insn ( <STR_LIT> , operands ) ; } else { gcc_assert ( io_address_operand ( operands [ <NUM_LIT> ] , QImode ) ) ; output_asm_insn ( <STR_LIT> , operands ) ; if ( comp == EQ ) output_asm_insn ( <STR_LIT> , operands ) ; else output_asm_insn ( <STR_LIT> , operands ) ; } break ;


<s> if ( n_src == <NUM_LIT> ) avr_asm_len ( AVR_HAVE_MOVW ? <STR_LIT> : <STR_LIT> , xop , plen , <NUM_LIT> ) ; if ( n_src == <NUM_LIT> || ! AVR_HAVE_MOVW ) avr_asm_len ( <STR_LIT> , xop , plen , <NUM_LIT> ) ; } if ( REGNO ( xop [ <NUM_LIT> ] ) == REGNO ( xop [ <NUM_LIT> ] ) || ! reg_unused_after ( insn , r_msb ) ) { avr_asm_len ( <STR_LIT> , & r_msb , plen , <NUM_LIT> ) ; r_msb = tmp_reg_rtx ; } avr_asm_len ( <STR_LIT> , & r_msb , plen , <NUM_LIT> ) ;

for ( unsigned n = n_src ; n < n_dest ; n ++ ) avr_asm_len ( <STR_LIT> , & all_regs_rtx [ REGNO ( xop [ <NUM_LIT> ] ) + n ] , plen , <NUM_LIT> ) ;


<s> } if ( REGNO ( xop [ <NUM_LIT> ] ) == REGNO ( xop [ <NUM_LIT> ] ) || ! reg_unused_after ( insn , r_msb ) ) { avr_asm_len ( <STR_LIT> , & r_msb , plen , <NUM_LIT> ) ; r_msb = tmp_reg_rtx ; } avr_asm_len ( <STR_LIT> , & r_msb , plen , <NUM_LIT> ) ; for ( unsigned n = n_src ; n < n_dest ; n ++ ) avr_asm_len ( <STR_LIT> , & all_regs_rtx [ REGNO ( xop [ <NUM_LIT> ] ) + n ] , plen , <NUM_LIT> ) ;


<s> static const char * avr_out_store_psi ( rtx_insn * insn , rtx * op , int * plen ) { rtx dest = op [ <NUM_LIT> ] ; rtx src = op [ <NUM_LIT> ] ; rtx base = XEXP ( dest , <NUM_LIT> ) ; int reg_base = true_regnum ( base ) ; if ( CONSTANT_ADDRESS_P ( base ) ) { int n_words = AVR_TINY ? <NUM_LIT> : <NUM_LIT> ; return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - n_words ) ; } if ( reg_base > <NUM_LIT> ) { if ( AVR_TINY ) return avr_out_store_psi_reg_no_disp_tiny ( insn , op , plen ) ; if ( reg_base == REG_X ) { gcc_assert ( ! reg_overlap_mentioned_p ( base , src ) ) ; avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ;

if ( ! reg_unused_after ( insn , base ) ) avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ;


if ( ! reg_unused_after ( insn , base ) ) avr_asm_len ( TINY_SBIW ( % E0 , % F0 , <NUM_LIT> ) , op , plen , <NUM_LIT> ) ;


<s> rtx src = op [ <NUM_LIT> ] ; rtx base = XEXP ( dest , <NUM_LIT> ) ; int reg_base = true_regnum ( base ) ; int reg_src = true_regnum ( src ) ; if ( reg_base == reg_src ) {


<s> } else if ( reg_unused_after ( insn , op [ <NUM_LIT> ] ) && compare_eq_p ( insn ) ) { avr_asm_len ( <STR_LIT> , op , plen , - <NUM_LIT> ) ; } else {


<s> avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; } else { avr_out_compare ( insn , op , plen ) ;


<s> else if ( reg_unused_after ( insn , op [ <NUM_LIT> ] ) && compare_eq_p ( insn ) ) { avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ;


<s> if ( compare_sign_p ( insn ) ) { avr_asm_len ( <STR_LIT> , op , plen , - <NUM_LIT> ) ; } else if ( reg_unused_after ( insn , op [ <NUM_LIT> ] ) && compare_eq_p ( insn ) ) { avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; } else { avr_out_compare ( insn , op , plen ) ; } return <STR_LIT> ;


<s> const char * avr_out_xload ( rtx_insn * insn ATTRIBUTE_UNUSED , rtx * op , int * plen ) { rtx xop [ <NUM_LIT> ] ; xop [ <NUM_LIT> ] = op [ <NUM_LIT> ] ; xop [ <NUM_LIT> ] = op [ <NUM_LIT> ] ; xop [ <NUM_LIT> ] = lpm_addr_reg_rtx ; xop [ <NUM_LIT> ] = AVR_HAVE_LPMX ? op [ <NUM_LIT> ] : lpm_reg_rtx ;


<s> rtvec vec = gen_rtvec ( <NUM_LIT> , PATTERN ( i [ <NUM_LIT> ] ) , PATTERN ( i [ <NUM_LIT> ] ) , PATTERN ( i [ <NUM_LIT> ] ) , PATTERN ( i [ <NUM_LIT> ] ) , PATTERN ( i [ <NUM_LIT> ] ) ) ; start_sequence ( ) ;

emit ( gen_rtx_PARALLEL ( VOIDmode , vec ) ) ;


<s> avr_pass_casesi ( gcc :: context * ctxt , const char * name ) : rtl_opt_pass ( avr_pass_data_casesi , ctxt ) { this -> name = name ;


<s> avr_pass_pre_proep ( gcc :: context * ctxt , const char * name ) : rtl_opt_pass ( avr_pass_data_pre_proep , ctxt ) {


<s> avr_pass_recompute_notes ( gcc :: context * ctxt , const char * name ) : rtl_opt_pass ( avr_pass_data_recompute_notes , ctxt ) { this -> name = name ;


<s> default : break ; case VAR_DECL : if ( as = avr_nonconst_pointer_addrspace ( TREE_TYPE ( node ) ) , as ) reason = _ ( <STR_LIT> ) ; break ; case PARM_DECL : if ( as = avr_nonconst_pointer_addrspace ( TREE_TYPE ( node ) ) , as ) reason = _ ( <STR_LIT> ) ; break ; case FIELD_DECL : if ( as = avr_nonconst_pointer_addrspace ( TREE_TYPE ( node ) ) , as ) reason = _ ( <STR_LIT> ) ; break ; case FUNCTION_DECL : if ( as = avr_nonconst_pointer_addrspace ( TREE_TYPE ( TREE_TYPE ( node ) ) ) , as ) reason = _ ( <STR_LIT> ) ; break ;


<s> unsigned int val8 = UINTVAL ( xval8 ) & GET_MODE_MASK ( QImode ) ; if ( ( pop_mask & ( <NUM_LIT> << popcount_hwi ( val8 ) ) ) == <NUM_LIT> ) return false ; } return true ;


<s> bool avr_popcount_each_byte ( rtx xval , int n_bytes , int pop_mask ) { machine_mode mode = GET_MODE ( xval ) ; if ( VOIDmode == mode ) mode = SImode ; for ( int i = <NUM_LIT> ; i < n_bytes ; i ++ ) { rtx xval8 = simplify_gen_subreg ( QImode , xval , mode , i ) ;

unsigned int val8 = UINTVAL ( xval8 ) & GET_MODE_MASK ( QImode ) ;


<s> else if ( MEM_P ( x ) ) { rtx addr = XEXP ( x , <NUM_LIT> ) ; if ( code == 'm' ) { if ( ! CONSTANT_P ( addr ) ) fatal_insn ( <STR_LIT> , addr ) ; if ( text_segment_operand ( addr , VOIDmode ) ) if ( warning ( <NUM_LIT> , <STR_LIT> <STR_LIT> ) ) { output_addr_const ( stderr , addr ) ; fprintf ( stderr , <STR_LIT> ) ; } output_addr_const ( file , addr ) ; } else if ( code == 'i' ) { avr_print_operand ( file , addr , 'i' ) ; } else if ( code == 'o' ) { if ( GET_CODE ( addr ) != PLUS ) fatal_insn ( <STR_LIT> , addr ) ; avr_print_operand ( file , XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ; } else if ( code == 'b' ) { if ( GET_CODE ( addr ) != PLUS ) fatal_insn ( <STR_LIT> , addr ) ; avr_print_operand_address ( file , VOIDmode , XEXP ( addr , <NUM_LIT> ) ) ; } else if ( code == 'p' || code == 'r' ) { if ( GET_CODE ( addr ) != POST_INC && GET_CODE ( addr ) != PRE_DEC ) fatal_insn ( <STR_LIT> , addr ) ; if ( code == 'p' ) avr_print_operand_address ( file , VOIDmode , XEXP ( addr , <NUM_LIT> ) ) ; else avr_print_operand ( file , XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ; } else if ( GET_CODE ( addr ) == PLUS ) { avr_print_operand_address ( file , VOIDmode , XEXP ( addr , <NUM_LIT> ) ) ; if ( REGNO ( XEXP ( addr , <NUM_LIT> ) ) == REG_X ) fatal_insn ( <STR_LIT> , addr ) ; fputc ( '+' , file ) ; avr_print_operand ( file , XEXP ( addr , <NUM_LIT> ) , code ) ; } else avr_print_operand_address ( file , VOIDmode , addr ) ; } else if ( code == 'i' ) { if ( SYMBOL_REF_P ( x ) && ( SYMBOL_REF_FLAGS ( x ) & SYMBOL_FLAG_IO ) ) avr_print_operand_address ( file , VOIDmode , plus_constant ( HImode , x , - avr_arch -> sfr_offset ) ) ; else fatal_insn ( <STR_LIT> , x ) ; } else if ( code == 'x' ) { if ( text_segment_operand ( x , VOIDmode ) == <NUM_LIT> ) if ( warning ( <NUM_LIT> , <STR_LIT> <STR_LIT> ) ) { output_addr_const ( stderr , x ) ; fprintf ( stderr , <STR_LIT> ) ; } output_addr_const ( file , x ) ; } else if ( CONST_FIXED_P ( x ) ) { HOST_WIDE_INT ival = INTVAL ( avr_to_int_mode ( x ) ) ; if ( code != <NUM_LIT> ) output_operand_lossage ( <STR_LIT> , code ) ; fprintf ( file , HOST_WIDE_INT_PRINT_DEC , ival ) ; } else if ( CONST_DOUBLE_P ( x ) ) {


<s> static void avr_print_operand_address ( FILE * file , machine_mode , rtx addr ) { if ( AVR_TINY && avr_address_tiny_pm_p ( addr ) ) { addr = plus_constant ( Pmode , addr , avr_arch -> flash_pm_offset ) ; } switch ( GET_CODE ( addr ) ) { case REG : fprintf ( file , <STR_LIT> , ptrreg_to_str ( REGNO ( addr ) ) ) ; break ; case PRE_DEC : fprintf ( file , <STR_LIT> , ptrreg_to_str ( REGNO ( XEXP ( addr , <NUM_LIT> ) ) ) ) ; break ; case POST_INC : fprintf ( file , <STR_LIT> , ptrreg_to_str ( REGNO ( XEXP ( addr , <NUM_LIT> ) ) ) ) ; break ; default :

if ( CONSTANT_ADDRESS_P ( addr ) && text_segment_operand ( addr , VOIDmode ) ) {


<s> } switch ( GET_CODE ( addr ) ) { case REG : fprintf ( file , <STR_LIT> , ptrreg_to_str ( REGNO ( addr ) ) ) ; break ; case PRE_DEC : fprintf ( file , <STR_LIT> , ptrreg_to_str ( REGNO ( XEXP ( addr , <NUM_LIT> ) ) ) ) ; break ; case POST_INC : fprintf ( file , <STR_LIT> , ptrreg_to_str ( REGNO ( XEXP ( addr , <NUM_LIT> ) ) ) ) ; break ; default : if ( CONSTANT_ADDRESS_P ( addr ) && text_segment_operand ( addr , VOIDmode ) ) { rtx x = addr ; if ( GET_CODE ( x ) == CONST ) x = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( x ) == PLUS && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) ) { fprintf ( file , <STR_LIT> ) ; output_addr_const ( file , XEXP ( x , <NUM_LIT> ) ) ; fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , <NUM_LIT> * INTVAL ( XEXP ( x , <NUM_LIT> ) ) ) ; if ( AVR_3_BYTE_PC ) if ( warning ( <NUM_LIT> , <STR_LIT> ) ) { output_addr_const ( stderr , addr ) ; fprintf ( stderr , <STR_LIT> ) ; } } else {


<s> int avr_progmem_p ( tree decl , tree attributes ) { tree a ; if ( TREE_CODE ( decl ) != VAR_DECL ) return <NUM_LIT> ; if ( avr_decl_memx_p ( decl ) ) return <NUM_LIT> ; if ( avr_decl_flash_p ( decl ) ) return <NUM_LIT> ; if ( NULL_TREE != lookup_attribute ( <STR_LIT> , attributes ) ) return - <NUM_LIT> ; a = decl ;


<s> tree a ; if ( TREE_CODE ( decl ) != VAR_DECL ) return <NUM_LIT> ; if ( avr_decl_memx_p ( decl ) ) return <NUM_LIT> ; if ( avr_decl_flash_p ( decl ) ) return <NUM_LIT> ; if ( NULL_TREE != lookup_attribute ( <STR_LIT> , attributes ) ) return - <NUM_LIT> ; a = decl ; do a = TREE_TYPE ( a ) ; while ( TREE_CODE ( a ) == ARRAY_TYPE ) ; if ( a == error_mark_node ) return <NUM_LIT> ; if ( NULL_TREE != lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( a ) ) ) return - <NUM_LIT> ;


<s> } if ( frame_pointer_needed && size == <NUM_LIT> ) { insn = emit_move_insn ( frame_pointer_rtx , stack_pointer_rtx ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } if ( size != <NUM_LIT> ) { int irq_state = - <NUM_LIT> ; HOST_WIDE_INT size_cfa = size , neg_size ; rtx_insn * fp_plus_insns ; rtx fp , my_fp ; gcc_assert ( frame_pointer_needed || ! isr_p || ! crtl -> is_leaf ) ; fp = my_fp = ( frame_pointer_needed ? frame_pointer_rtx : gen_rtx_REG ( Pmode , REG_X ) ) ; if ( AVR_HAVE_8BIT_SP ) { my_fp = all_regs_rtx [ FRAME_POINTER_REGNUM ] ; } if ( size > size_max ) { size = size_max ; } size = trunc_int_for_mode ( size , GET_MODE ( my_fp ) ) ; neg_size = trunc_int_for_mode ( - size , GET_MODE ( my_fp ) ) ; start_sequence ( ) ; insn = emit_move_insn ( fp , stack_pointer_rtx ) ; if ( frame_pointer_needed ) { RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; add_reg_note ( insn , REG_CFA_ADJUST_CFA , gen_rtx_SET ( fp , stack_pointer_rtx ) ) ; } insn = emit_move_insn ( my_fp , plus_constant ( GET_MODE ( my_fp ) , my_fp , neg_size ) ) ; if ( frame_pointer_needed ) { RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; add_reg_note ( insn , REG_CFA_ADJUST_CFA , gen_rtx_SET ( fp , plus_constant ( Pmode , fp , - size_cfa ) ) ) ; } if ( cfun -> machine -> is_interrupt ) irq_state = <NUM_LIT> ; if ( TARGET_NO_INTERRUPTS || cfun -> machine -> is_signal || cfun -> machine -> is_OS_main ) irq_state = <NUM_LIT> ; if ( AVR_HAVE_8BIT_SP ) irq_state = <NUM_LIT> ;

insn = emit_insn ( gen_movhi_sp_r ( stack_pointer_rtx , fp , GEN_INT ( irq_state ) ) ) ;


<s> if ( reg_renumber ) { regno = reg_renumber [ regno ] ; if ( regno == REG_Z ) { return true ; } } return false ; } if ( regno < FIRST_PSEUDO_REGISTER && ( regno == REG_X || regno == REG_Y || regno == REG_Z || regno == ARG_POINTER_REGNUM ) ) { ok = true ;


<s> if ( reg_renumber ) { regno = reg_renumber [ regno ] ; if ( regno == REG_Z ) { return true ; } } return false ; } if ( regno < FIRST_PSEUDO_REGISTER && ( regno == REG_X || regno == REG_Y || regno == REG_Z || regno == ARG_POINTER_REGNUM ) ) { ok = true ; } else if ( reg_renumber ) { regno = reg_renumber [ regno ] ; if ( regno == REG_X || regno == REG_Y || regno == REG_Z || regno == ARG_POINTER_REGNUM ) { ok = true ; } }

if ( avr_strict_X && PLUS == outer_code && regno == REG_X ) {


if ( r <= <NUM_LIT> ) return reg_class_tab [ r ] ;


<s> int int_or_sig_p = cfun -> machine -> is_interrupt || cfun -> machine -> is_signal ; if ( set ) CLEAR_HARD_REG_SET ( * set ) ; count = <NUM_LIT> ;

if ( TREE_THIS_VOLATILE ( current_function_decl ) || cfun -> machine -> is_OS_task || cfun -> machine -> is_OS_main ) return <NUM_LIT> ;


<s> static bool avr_reg_ok_for_pgm_addr ( rtx reg , bool strict ) { gcc_assert ( REG_P ( reg ) ) ; if ( strict ) { return REGNO ( reg ) == REG_Z ; } if ( can_create_pseudo_p ( ) && REGNO ( reg ) < REG_Z ) { return false ;


<s> } if ( can_create_pseudo_p ( ) && REGNO ( reg ) < REG_Z ) {


<s> comp1 = SET_SRC ( comp1 ) ; ifelse1 = SET_SRC ( xcond1 ) ; ifelse2 = SET_SRC ( xcond2 ) ; if ( EQ != GET_CODE ( XEXP ( ifelse1 , <NUM_LIT> ) ) || ! REG_P ( XEXP ( comp1 , <NUM_LIT> ) ) || ! CONST_INT_P ( XEXP ( comp1 , <NUM_LIT> ) ) || XEXP ( ifelse1 , <NUM_LIT> ) != pc_rtx || XEXP ( ifelse2 , <NUM_LIT> ) != pc_rtx || LABEL_REF != GET_CODE ( XEXP ( ifelse1 , <NUM_LIT> ) ) || LABEL_REF != GET_CODE ( XEXP ( ifelse2 , <NUM_LIT> ) ) || ! COMPARISON_P ( XEXP ( ifelse2 , <NUM_LIT> ) ) || REG_CC != REGNO ( XEXP ( XEXP ( ifelse1 , <NUM_LIT> ) , <NUM_LIT> ) ) || REG_CC != REGNO ( XEXP ( XEXP ( ifelse2 , <NUM_LIT> ) , <NUM_LIT> ) ) || const0_rtx != XEXP ( XEXP ( ifelse1 , <NUM_LIT> ) , <NUM_LIT> ) || const0_rtx != XEXP ( XEXP ( ifelse2 , <NUM_LIT> ) , <NUM_LIT> ) ) { return false ; } code = GET_CODE ( XEXP ( ifelse2 , <NUM_LIT> ) ) ; switch ( code ) { case EQ : case LT : case LTU : case GE : case GEU : break ; case LE : case LEU : case GT : case GTU : code = avr_normalize_condition ( code ) ; break ; default : return false ; } target = XEXP ( XEXP ( ifelse1 , <NUM_LIT> ) , <NUM_LIT> ) ; cond = XEXP ( ifelse1 , <NUM_LIT> ) ;

jump = emit_jump_insn_after ( gen_branch_unspec ( target , cond ) , insn1 ) ;


<s> FOR_BB_INSNS ( bb , insn ) { if ( avr_is_casesi_sequence ( bb , insn , insns ) ) {

avr_optimize_casesi ( insns , recog_data . operand ) ;


<s> rtx_insn * insn , * insns [ <NUM_LIT> ] ; FOR_BB_INSNS ( bb , insn ) { if ( avr_is_casesi_sequence ( bb , insn , insns ) ) { avr_optimize_casesi ( insns , recog_data . operand ) ; } }


<s> r = gen_rtx_PLUS ( Pmode , tem , r ) ; r = gen_frame_mem ( Pmode , memory_address ( Pmode , r ) ) ; r = gen_rtx_ROTATE ( HImode , r , GEN_INT ( <NUM_LIT> ) ) ;


<s> static bool avr_return_in_memory ( const_tree type , const_tree fntype ATTRIBUTE_UNUSED ) { HOST_WIDE_INT size = int_size_in_bytes ( type ) ; HOST_WIDE_INT ret_size_limit = AVR_TINY ? <NUM_LIT> : <NUM_LIT> ; if ( size == - <NUM_LIT> || size > ret_size_limit ) {


<s> static inline unsigned int avr_ret_register ( void ) { return <NUM_LIT> ;


<s> if ( SCRATCH != GET_CODE ( scratch ) && HImode == GET_MODE ( scratch ) && QImode == move_mode ) scratch = simplify_gen_subreg ( move_mode , scratch , HImode , <NUM_LIT> ) ; move_size = GET_MODE_SIZE ( move_mode ) ; offset = ( num >> <NUM_LIT> ) / move_size ; size = GET_MODE_SIZE ( mode ) / move_size ; if ( mode == HImode && same_reg ) { rtx src , dst ; src = simplify_gen_subreg ( move_mode , operands [ <NUM_LIT> ] , mode , <NUM_LIT> ) ; dst = simplify_gen_subreg ( move_mode , operands [ <NUM_LIT> ] , mode , <NUM_LIT> ) ; if ( ! rtx_equal_p ( dst , src ) ) { emit_move_insn ( dst , gen_rtx_XOR ( QImode , dst , src ) ) ; emit_move_insn ( src , gen_rtx_XOR ( QImode , src , dst ) ) ; emit_move_insn ( dst , gen_rtx_XOR ( QImode , dst , src ) ) ; } } else { struct { rtx src , dst ; int links ; } move [ MAX_SIZE + <NUM_LIT> ] ; int blocked , moves ; gcc_assert ( size <= MAX_SIZE ) ; for ( int i = <NUM_LIT> ; i < size ; i ++ ) { int from = i ; int to = ( from + offset ) % size ; move [ i ] . src = simplify_gen_subreg ( move_mode , operands [ <NUM_LIT> ] , mode , from * move_size ) ; move [ i ] . dst = simplify_gen_subreg ( move_mode , operands [ <NUM_LIT> ] , mode , to * move_size ) ; move [ i ] . links = - <NUM_LIT> ; } if ( overlapped ) for ( int i = <NUM_LIT> ; i < size ; i ++ ) if ( reg_overlap_mentioned_p ( move [ i ] . dst , operands [ <NUM_LIT> ] ) ) for ( int j = <NUM_LIT> ; j < size ; j ++ ) if ( j != i && rtx_equal_p ( move [ j ] . src , move [ i ] . dst ) ) { move [ i ] . links = j ; break ; } blocked = - <NUM_LIT> ; moves = <NUM_LIT> ; do { blocked = - <NUM_LIT> ; moves = <NUM_LIT> ;

for ( int i = <NUM_LIT> ; i < size ; i ++ ) if ( move [ i ] . src != NULL_RTX ) {


<s> } else { struct { rtx src , dst ; int links ; } move [ MAX_SIZE + <NUM_LIT> ] ; int blocked , moves ; gcc_assert ( size <= MAX_SIZE ) ; for ( int i = <NUM_LIT> ; i < size ; i ++ ) { int from = i ; int to = ( from + offset ) % size ; move [ i ] . src = simplify_gen_subreg ( move_mode , operands [ <NUM_LIT> ] , mode , from * move_size ) ; move [ i ] . dst = simplify_gen_subreg ( move_mode , operands [ <NUM_LIT> ] , mode , to * move_size ) ; move [ i ] . links = - <NUM_LIT> ; } if ( overlapped ) for ( int i = <NUM_LIT> ; i < size ; i ++ ) if ( reg_overlap_mentioned_p ( move [ i ] . dst , operands [ <NUM_LIT> ] ) ) for ( int j = <NUM_LIT> ; j < size ; j ++ ) if ( j != i && rtx_equal_p ( move [ j ] . src , move [ i ] . dst ) ) { move [ i ] . links = j ; break ; } blocked = - <NUM_LIT> ; moves = <NUM_LIT> ; do { blocked = - <NUM_LIT> ; moves = <NUM_LIT> ; for ( int i = <NUM_LIT> ; i < size ; i ++ ) if ( move [ i ] . src != NULL_RTX ) { if ( move [ i ] . links == - <NUM_LIT> || move [ move [ i ] . links ] . src == NULL_RTX ) { moves ++ ; if ( ! rtx_equal_p ( move [ i ] . dst , move [ i ] . src ) ) emit_move_insn ( move [ i ] . dst , move [ i ] . src ) ;


<s> avr_edump ( <STR_LIT> , done , speed ? <STR_LIT> : <STR_LIT> , * total , outer_code , x ) ; } return done ;


<s> static bool avr_rtx_costs ( rtx x , machine_mode mode , int outer_code , int opno , int * total , bool speed ) { bool done = avr_rtx_costs_1 ( x , mode , outer_code , opno , total , speed ) ; if ( avr_log . rtx_costs ) { avr_edump ( <STR_LIT> , done , speed ? <STR_LIT> : <STR_LIT> , * total , outer_code , x ) ;


<s> static bool avr_scalar_mode_supported_p ( scalar_mode mode ) { if ( ALL_FIXED_POINT_MODE_P ( mode ) ) return true ;


<s> if ( startswith ( name , <STR_LIT> ) ) { if ( decl && TREE_CODE ( decl ) == VAR_DECL && DECL_INITIAL ( decl ) == NULL_TREE ) flags |= SECTION_BSS ; else warning ( <NUM_LIT> , <STR_LIT> <STR_LIT> ) ; }

if ( decl && DECL_P ( decl ) && avr_progmem_p ( decl , DECL_ATTRIBUTES ( decl ) ) ) {


<s> if ( mcu -> name == NULL ) { error ( <STR_LIT> , avr_mmcu , <STR_LIT> ) ; avr_inform_core_architectures ( ) ; break ; } else if ( strcmp ( mcu -> name , avr_mmcu ) == <NUM_LIT> && mcu -> macro == NULL ) { avr_arch = & avr_arch_types [ mcu -> arch_id ] ;


<s> for ( const avr_mcu_t * mcu = avr_mcu_types ; ; mcu ++ ) { if ( mcu -> name == NULL ) { error ( <STR_LIT> , avr_mmcu , <STR_LIT> ) ; avr_inform_core_architectures ( ) ; break ; } else if ( strcmp ( mcu -> name , avr_mmcu ) == <NUM_LIT> && mcu -> macro == NULL ) { avr_arch = & avr_arch_types [ mcu -> arch_id ] ; if ( avr_n_flash < <NUM_LIT> ) avr_n_flash = <NUM_LIT> + ( mcu -> flash_size - <NUM_LIT> ) / <NUM_LIT> ;


<s> if ( cfun -> machine -> is_interrupt || cfun -> machine -> is_signal ) { tree args = TYPE_ARG_TYPES ( TREE_TYPE ( decl ) ) ; tree ret = TREE_TYPE ( TREE_TYPE ( decl ) ) ; const char * name ; name = DECL_ASSEMBLER_NAME_SET_P ( decl ) ? IDENTIFIER_POINTER ( DECL_ASSEMBLER_NAME ( decl ) ) : IDENTIFIER_POINTER ( DECL_NAME ( decl ) ) ; name = default_strip_name_encoding ( name ) ; if ( args && TREE_CODE ( TREE_VALUE ( args ) ) != VOID_TYPE ) error_at ( loc , <STR_LIT> , isr ) ; if ( TREE_CODE ( ret ) != VOID_TYPE ) error_at ( loc , <STR_LIT> , isr ) ; if ( cfun -> machine -> is_interrupt ) cfun -> machine -> is_signal = <NUM_LIT> ; if ( ! startswith ( name , <STR_LIT> ) ) warning_at ( loc , OPT_Wmisspelled_isr , <STR_LIT> <STR_LIT> , name , isr ) ; } const char * name = IDENTIFIER_POINTER ( DECL_NAME ( decl ) ) ; name = default_strip_name_encoding ( name ) ; if ( strcmp ( <STR_LIT> , name ) == <NUM_LIT> || strcmp ( <STR_LIT> , name ) == <NUM_LIT> || strcmp ( <STR_LIT> , name ) == <NUM_LIT> ) { warning_at ( loc , OPT_Wmisspelled_isr , <STR_LIT> <STR_LIT> <STR_LIT> , name , name ) ; }

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


<s> return ( ! frame_pointer_needed && get_frame_size ( ) == <NUM_LIT> && avr_outgoing_args_size ( ) == <NUM_LIT> && avr_regs_to_save ( NULL ) == <NUM_LIT> && ! cfun -> machine -> is_interrupt && ! cfun -> machine -> is_signal && ! cfun -> machine -> is_naked && ! TREE_THIS_VOLATILE ( current_function_decl ) ) ;


<s> if ( unsigned_condition ( op ) != op ) max >>= <NUM_LIT> ; if ( max != ( INTVAL ( x ) & max ) && INTVAL ( x ) != <NUM_LIT> ) return <NUM_LIT> ; } return <NUM_LIT> ;


<s> int avr_simplify_comparison_p ( machine_mode mode , RTX_CODE op , rtx x ) { unsigned int max = ( mode == QImode ? <NUM_LIT> : mode == HImode ? <NUM_LIT> : mode == PSImode ? <NUM_LIT> : mode == SImode ? <NUM_LIT> : <NUM_LIT> ) ;


<s> static HOST_WIDE_INT avr_starting_frame_offset ( void ) { return <NUM_LIT> + avr_outgoing_args_size ( ) ;


<s> char * lo0 = lo ; for ( ; * up ; up ++ , lo ++ ) * lo = TOLOWER ( * up ) ;


<s> machine_mode mode = GET_MODE ( x ) ;

return VOIDmode == mode ? x : simplify_gen_subreg ( int_mode_for_mode ( mode ) . require ( ) , x , mode , <NUM_LIT> ) ;


<s> rtx avr_to_int_mode ( rtx x ) { machine_mode mode = GET_MODE ( x ) ; return VOIDmode == mode ? x : simplify_gen_subreg ( int_mode_for_mode ( mode ) . require ( ) , x , mode , <NUM_LIT> ) ;


<s> static bool avr_use_by_pieces_infrastructure_p ( unsigned HOST_WIDE_INT size , unsigned int align ATTRIBUTE_UNUSED , enum by_pieces_operation op , bool speed_p ) { if ( op != MOVE_BY_PIECES || ( speed_p && size > MOVE_MAX_PIECES ) ) return default_use_by_pieces_infrastructure_p ( size , align , op , speed_p ) ; return size <= MOVE_MAX_PIECES ;


<s> int n_bytes = GET_MODE_SIZE ( mode ) ;


<s> return ( n_bytes > <NUM_LIT> || avr_n_flash > <NUM_LIT> ) ;


<s> static bool compare_diff_p ( rtx_insn * insn ) {

RTX_CODE cond = compare_condition ( insn ) ;


<s> static bool compare_diff_p ( rtx_insn * insn ) { RTX_CODE cond = compare_condition ( insn ) ;

return ( cond == GT || cond == GTU || cond == LE || cond == LEU ) ? cond : <NUM_LIT> ;


<s> return ( cond == EQ || cond == NE ) ;


<s> return ( cond == GE || cond == LT ) ;


<s> static bool compare_sign_p ( rtx_insn * insn ) { RTX_CODE cond = compare_condition ( insn ) ; return ( cond == GE || cond == LT ) ;


<s> for ( rtx_insn * insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) { if ( CALL_P ( insn ) ) return ; if ( AVR_HAVE_JMP_CALL && JUMP_TABLE_DATA_P ( insn ) ) return ; if ( JUMP_P ( insn ) && find_reg_note ( insn , REG_NON_LOCAL_GOTO , NULL_RTX ) ) return ; } fun -> machine -> gasisr . maybe = <NUM_LIT> ;


<s> case LT : if ( cc_overflow_unusable ) return <STR_LIT> ; else return <STR_LIT> ; case GEU : return <STR_LIT> ; case LTU :


<s> mem = gen_frame_mem ( QImode , mem ) ; reg = gen_rtx_REG ( QImode , regno ) ; emit_insn ( gen_rtx_SET ( reg , mem ) ) ;


<s> mem = gen_rtx_POST_DEC ( HImode , stack_pointer_rtx ) ; mem = gen_frame_mem ( QImode , mem ) ; reg = gen_rtx_REG ( QImode , regno ) ; insn = emit_insn ( gen_rtx_SET ( mem , reg ) ) ; if ( frame_related_p ) RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; cfun -> machine -> stack_usage ++ ;


<s> static void emit_push_byte ( unsigned regno , bool frame_related_p ) { rtx mem , reg ; rtx_insn * insn ; mem = gen_rtx_POST_DEC ( HImode , stack_pointer_rtx ) ;


<s> emit_push_byte ( treg , frame_related_p ) ; if ( clr_p ) { insn = emit_move_insn ( sfr , const0_rtx ) ; if ( frame_related_p ) RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; }


<s> virtual unsigned int execute ( function * fun ) {

if ( avr_gasisr_prologues && ! fun -> machine -> is_no_gccisr && ( fun -> machine -> is_interrupt || fun -> machine -> is_signal ) && ! cfun -> machine -> is_naked && ! cfun -> calls_setjmp && ! cfun -> has_nonlocal_label && ! cfun -> has_forced_label_in_static ) {


<s> rtx xx = XEXP ( plus , <NUM_LIT> ) ; int regno = REGNO ( xx ) ; ok = ( regno >= FIRST_PSEUDO_REGISTER || regno == REG_Z || regno == REG_Y || xx == frame_pointer_rtx || xx == arg_pointer_rtx ) ; if ( avr_log . constraints ) avr_edump ( <STR_LIT> , ok , reload_completed , reload_in_progress , x ) ; }


<s> rtx plus = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( plus ) == PLUS && REG_P ( XEXP ( plus , <NUM_LIT> ) ) && CONST_INT_P ( XEXP ( plus , <NUM_LIT> ) ) && ( INTVAL ( XEXP ( plus , <NUM_LIT> ) ) <= MAX_LD_OFFSET ( GET_MODE ( x ) ) ) ) {


<s> avr_optimize_casesi ( insns , recog_data . operand ) ; }


<s> FOR_EACH_BB_FN ( bb , func ) { rtx_insn * insn , * insns [ <NUM_LIT> ] ; FOR_BB_INSNS ( bb , insn ) { if ( avr_is_casesi_sequence ( bb , insn , insns ) ) { avr_optimize_casesi ( insns , recog_data . operand ) ; } }


<s> FOR_EACH_SUBRTX ( iter , array , PATTERN ( insn ) , NONCONST ) { const_rtx op = * iter ;

if ( SUBREG_P ( op ) && MEM_P ( SUBREG_REG ( op ) ) && ( GET_MODE_SIZE ( GET_MODE ( op ) ) > GET_MODE_SIZE ( GET_MODE ( SUBREG_REG ( op ) ) ) ) ) {


<s> FOR_EACH_SUBRTX ( iter , array , PATTERN ( insn ) , NONCONST ) { const_rtx op = * iter ; if ( SUBREG_P ( op ) && MEM_P ( SUBREG_REG ( op ) ) && ( GET_MODE_SIZE ( GET_MODE ( op ) ) > GET_MODE_SIZE ( GET_MODE ( SUBREG_REG ( op ) ) ) ) ) {


<s> int length = <NUM_LIT> ; for ( rtx_insn * insn = insns ; insn ; insn = NEXT_INSN ( insn ) ) length += get_attr_length ( insn ) ;


<s> int get_sequence_length ( rtx_insn * insns ) { int length = <NUM_LIT> ; for ( rtx_insn * insn = insns ; insn ; insn = NEXT_INSN ( insn ) ) length += get_attr_length ( insn ) ; return length ;


<s> int uid = INSN_UID ( GET_CODE ( dest ) == LABEL_REF ? XEXP ( dest , <NUM_LIT> ) : dest ) ; int jump_addr = INSN_ADDRESSES ( INSN_UID ( insn ) ) ; int dest_addr = INSN_ADDRESSES ( uid ) ; int jump_offset = dest_addr - jump_addr - get_attr_length ( insn ) ;

return ( jump_offset == <NUM_LIT> || ( jump_offset == <NUM_LIT> && avr_2word_insn_p ( next_active_insn ( insn ) ) ) ) ;


int reg1 = true_regnum ( operands [ <NUM_LIT> ] ) ;


<s> return new avr_pass_casesi ( ctxt , <STR_LIT> ) ;


<s> return new avr_pass_pre_proep ( ctxt , <STR_LIT> ) ;


<s> rtl_opt_pass * make_avr_pass_pre_proep ( gcc :: context * ctxt ) {

return new avr_pass_pre_proep ( ctxt , <STR_LIT> ) ;


<s> rtl_opt_pass * make_avr_pass_recompute_notes ( gcc :: context * ctxt ) {

return new avr_pass_recompute_notes ( ctxt , <STR_LIT> ) ;


<s> else if ( test_hard_reg_class ( STACK_REG , src ) ) { return ! AVR_HAVE_SPH ? avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , xop , plen , - <NUM_LIT> ) : avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , xop , plen , - <NUM_LIT> ) ; } return AVR_HAVE_MOVW ? avr_asm_len ( <STR_LIT> , xop , plen , - <NUM_LIT> ) : avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , xop , plen , - <NUM_LIT> ) ; } else if ( CONSTANT_P ( src ) ) { return output_reload_inhi ( xop , NULL , plen ) ; } else if ( MEM_P ( src ) ) { return out_movhi_r_mr ( insn , xop , plen ) ; } } else if ( MEM_P ( dest ) ) { rtx xop [ <NUM_LIT> ] ; xop [ <NUM_LIT> ] = dest ; xop [ <NUM_LIT> ] = src == CONST0_RTX ( GET_MODE ( dest ) ) ? zero_reg_rtx : src ; return out_movhi_mr_r ( insn , xop , plen ) ; }


<s> } else if ( MEM_P ( src ) ) return out_movqi_r_mr ( insn , operands , plen ) ; } else if ( MEM_P ( dest ) ) { rtx xop [ <NUM_LIT> ] ; xop [ <NUM_LIT> ] = dest ; xop [ <NUM_LIT> ] = src == CONST0_RTX ( GET_MODE ( dest ) ) ? zero_reg_rtx : src ; return out_movqi_mr_r ( insn , xop , plen ) ; } return <STR_LIT> ;


<s> else if ( CONSTANT_P ( src ) ) { return output_reload_insisf ( operands , NULL_RTX , real_l ) ; } else if ( MEM_P ( src ) ) return out_movsi_r_mr ( insn , operands , real_l ) ; } else if ( MEM_P ( dest ) ) { const char * templ ; if ( src == CONST0_RTX ( GET_MODE ( dest ) ) ) operands [ <NUM_LIT> ] = zero_reg_rtx ; templ = out_movsi_mr_r ( insn , operands , real_l ) ; if ( ! real_l ) output_asm_insn ( templ , operands ) ; operands [ <NUM_LIT> ] = src ;


<s> const char * output_reload_inhi ( rtx * op , rtx clobber_reg , int * plen ) { output_reload_in_const ( op , clobber_reg , plen , false ) ; return <STR_LIT> ;


<s> const char * output_reload_insisf ( rtx * op , rtx clobber_reg , int * len ) { if ( AVR_HAVE_MOVW && ! test_hard_reg_class ( LD_REGS , op [ <NUM_LIT> ] ) && ( CONST_INT_P ( op [ <NUM_LIT> ] ) || CONST_FIXED_P ( op [ <NUM_LIT> ] ) || CONST_DOUBLE_P ( op [ <NUM_LIT> ] ) ) ) { int len_clr , len_noclr ; output_reload_in_const ( op , clobber_reg , & len_clr , true ) ; output_reload_in_const ( op , clobber_reg , & len_noclr , false ) ; if ( len_noclr - len_clr == <NUM_LIT> ) { avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , & op [ <NUM_LIT> ] , len , <NUM_LIT> ) ; output_reload_in_const ( op , clobber_reg , len , true ) ; if ( len ) * len += <NUM_LIT> ; return <STR_LIT> ;


<s> avr_asm_len ( asm_code [ n ] [ ldreg_p ] , xop , len , ldreg_p ? <NUM_LIT> : <NUM_LIT> ) ; continue ; } xval = simplify_gen_subreg ( QImode , src , mode , n ) ; ival [ n ] = INTVAL ( xval ) ; if ( n == <NUM_LIT> && n_bytes >= <NUM_LIT> && AVR_HAVE_MOVW ) { rtx lo16 = simplify_gen_subreg ( HImode , src , mode , <NUM_LIT> ) ; rtx hi16 = simplify_gen_subreg ( HImode , src , mode , <NUM_LIT> ) ; if ( INTVAL ( lo16 ) == INTVAL ( hi16 ) ) { if ( INTVAL ( lo16 ) != <NUM_LIT> || ! clear_p ) avr_asm_len ( <STR_LIT> , & op [ <NUM_LIT> ] , len , <NUM_LIT> ) ; break ; } } if ( ival [ n ] == <NUM_LIT> ) { if ( ! clear_p ) avr_asm_len ( ldreg_p ? <STR_LIT> : AVR_ZERO_REGNO == REGNO ( xdest [ n ] ) ? <STR_LIT> : <STR_LIT> , & xdest [ n ] , len , <NUM_LIT> ) ; continue ; } if ( clobber_val == ival [ n ] && REGNO ( clobber_reg ) == REGNO ( xdest [ n ] ) ) { continue ; } if ( ldreg_p ) { xop [ <NUM_LIT> ] = xdest [ n ] ; xop [ <NUM_LIT> ] = xval ; avr_asm_len ( <STR_LIT> , xop , len , <NUM_LIT> ) ; continue ; } for ( int j = <NUM_LIT> ; j < n ; j ++ ) if ( ival [ j ] == ival [ n ] ) { xop [ <NUM_LIT> ] = xdest [ n ] ;


<s> if ( reg_dest == reg_base ) return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; if ( reg_base != REG_X ) return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; if ( ! reg_unused_after ( insn , base ) ) avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; return <STR_LIT> ; } else if ( GET_CODE ( base ) == PLUS ) { int disp = INTVAL ( XEXP ( base , <NUM_LIT> ) ) ; int reg_base = true_regnum ( XEXP ( base , <NUM_LIT> ) ) ; if ( AVR_TINY ) return avr_out_movhi_r_mr_reg_disp_tiny ( insn , op , plen ) ; if ( disp > MAX_LD_OFFSET ( GET_MODE ( src ) ) ) { if ( REGNO ( XEXP ( base , <NUM_LIT> ) ) != REG_Y ) fatal_insn ( <STR_LIT> , insn ) ; return disp <= <NUM_LIT> + MAX_LD_OFFSET ( GET_MODE ( src ) ) ? avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) : avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; } if ( reg_base == REG_X ) { if ( reg_base == reg_dest ) return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; if ( ! reg_unused_after ( insn , XEXP ( base , <NUM_LIT> ) ) ) avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; return <STR_LIT> ; } return reg_base == reg_dest ? avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) : avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; } else if ( GET_CODE ( base ) == PRE_DEC ) { if ( AVR_TINY ) return avr_out_movhi_r_mr_pre_dec_tiny ( insn , op , plen ) ; if ( reg_overlap_mentioned_p ( dest , XEXP ( base , <NUM_LIT> ) ) ) fatal_insn ( <STR_LIT> , insn ) ; if ( ! mem_volatile_p ) return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; return REGNO ( XEXP ( base , <NUM_LIT> ) ) == REG_X ? avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) : avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; } else if ( GET_CODE ( base ) == POST_INC ) { if ( reg_overlap_mentioned_p ( dest , XEXP ( base , <NUM_LIT> ) ) ) fatal_insn ( <STR_LIT> , insn ) ; return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ;


<s> return reg_base == reg_dest ? avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) : avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; } else if ( GET_CODE ( base ) == PRE_DEC ) { if ( AVR_TINY ) return avr_out_movhi_r_mr_pre_dec_tiny ( insn , op , plen ) ; if ( reg_overlap_mentioned_p ( dest , XEXP ( base , <NUM_LIT> ) ) ) fatal_insn ( <STR_LIT> , insn ) ; if ( ! mem_volatile_p ) return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; return REGNO ( XEXP ( base , <NUM_LIT> ) ) == REG_X ? avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) : avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; } else if ( GET_CODE ( base ) == POST_INC ) { if ( reg_overlap_mentioned_p ( dest , XEXP ( base , <NUM_LIT> ) ) ) fatal_insn ( <STR_LIT> , insn ) ; return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; } else if ( CONSTANT_ADDRESS_P ( base ) ) { int n_words = AVR_TINY ? <NUM_LIT> : <NUM_LIT> ;

return io_address_operand ( base , HImode ) ? avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) : avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , op , plen , - n_words ) ;


<s> rtx x = XEXP ( src , <NUM_LIT> ) ; if ( CONSTANT_ADDRESS_P ( x ) ) { int n_words = AVR_TINY ? <NUM_LIT> : <NUM_LIT> ; return io_address_operand ( x , QImode ) ? avr_asm_len ( <STR_LIT> , op , plen , - <NUM_LIT> ) : avr_asm_len ( <STR_LIT> , op , plen , - n_words ) ; } if ( GET_CODE ( x ) == PLUS && REG_P ( XEXP ( x , <NUM_LIT> ) ) && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) ) { int disp = INTVAL ( XEXP ( x , <NUM_LIT> ) ) ; if ( AVR_TINY ) return avr_out_movqi_r_mr_reg_disp_tiny ( insn , op , plen ) ; if ( disp - GET_MODE_SIZE ( GET_MODE ( src ) ) >= <NUM_LIT> ) { if ( REGNO ( XEXP ( x , <NUM_LIT> ) ) != REG_Y ) fatal_insn ( <STR_LIT> , insn ) ; if ( disp <= <NUM_LIT> + MAX_LD_OFFSET ( GET_MODE ( src ) ) ) return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; } else if ( REGNO ( XEXP ( x , <NUM_LIT> ) ) == REG_X ) { avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; if ( ! reg_overlap_mentioned_p ( dest , XEXP ( x , <NUM_LIT> ) ) && ! reg_unused_after ( insn , XEXP ( x , <NUM_LIT> ) ) ) { avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; }


<s> bool second_label = true ; bool saved_in_tmp = false ; bool use_zero_reg = false ; rtx op [ <NUM_LIT> ] ; op [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; op [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; op [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; op [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; if ( plen ) * plen = <NUM_LIT> ; if ( CONST_INT_P ( operands [ <NUM_LIT> ] ) ) { bool scratch = ( GET_CODE ( PATTERN ( insn ) ) == PARALLEL && XVECLEN ( PATTERN ( insn ) , <NUM_LIT> ) == <NUM_LIT> && REG_P ( operands [ <NUM_LIT> ] ) ) ; int count = INTVAL ( operands [ <NUM_LIT> ] ) ; int max_len = <NUM_LIT> ; if ( count <= <NUM_LIT> ) return ; if ( count < <NUM_LIT> && ! scratch ) use_zero_reg = true ; if ( optimize_size ) max_len = t_len + ( scratch ? <NUM_LIT> : ( use_zero_reg ? <NUM_LIT> : <NUM_LIT> ) ) ; if ( t_len * count <= max_len ) { while ( count -- > <NUM_LIT> ) avr_asm_len ( templ , op , plen , t_len ) ; return ; } if ( scratch ) { avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; } else if ( use_zero_reg ) { op [ <NUM_LIT> ] = zero_reg_rtx ; avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , op , plen , <NUM_LIT> ) ; } else { op [ <NUM_LIT> ] = all_regs_rtx [ ( ( REGNO ( op [ <NUM_LIT> ] ) - <NUM_LIT> ) & <NUM_LIT> ) + <NUM_LIT> ] ;


<s> switch ( regno ) { case REG_X : return <STR_LIT> ; case REG_Y : return <STR_LIT> ; case REG_Z : return <STR_LIT> ; default : output_operand_lossage ( <STR_LIT> <STR_LIT> ) ;


<s> if ( regno < <NUM_LIT> ) return <NUM_LIT> ; if ( TEST_HARD_REG_CLASS ( rclass , regno ) ) return <NUM_LIT> ; return <NUM_LIT> ;