<s> } f_ginv . map = ( f_ginv . map << <NUM_LIT> ) + x ; } if ( <NUM_LIT> == avr_map_metric ( f_ginv . map , MAP_NONFIXED_0_7 ) ) { 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 ) ; f_ginv . cost += val_const_p && val_used_p ? <NUM_LIT> : <NUM_LIT> ; } f_ginv . cost += g -> cost ; if ( avr_log . builtin ) avr_edump ( <STR_LIT> , g -> str , g -> arg , f_ginv . cost ) ;


<s> static unsigned avr_map_metric ( unsigned int a , int mode ) { unsigned i , metric = <NUM_LIT> ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) {


<s> for ( b = <NUM_LIT> ; b < <NUM_LIT> ; b ++ ) for ( bit_dest = <NUM_LIT> ; bit_dest < <NUM_LIT> ; bit_dest ++ ) { int bit_src = avr_map ( map , bit_dest ) ; if ( b != bit_src || bit_src >= <NUM_LIT> || ( bit_dest == bit_src && ! fixp_p ) ) continue ; if ( t_bit_src != bit_src ) { t_bit_src = bit_src ; xop [ <NUM_LIT> ] = GEN_INT ( bit_src ) ;

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


<s> if ( ! ADDR_SPACE_GENERIC_P ( as ) && ( ! TYPE_READONLY ( target ) || avr_addrspace [ as ] . segment >= avr_n_flash || ( ! AVR_HAVE_LPM && avr_addrspace [ as ] . pointer_size > <NUM_LIT> ) ) ) { return as ;


<s> if ( ! ADDR_SPACE_GENERIC_P ( as ) && ( ! TYPE_READONLY ( target ) || avr_addrspace [ as ] . segment >= avr_n_flash || ( ! AVR_HAVE_LPM && avr_addrspace [ as ] . pointer_size > <NUM_LIT> ) ) ) { return as ; }

return avr_nonconst_pointer_addrspace ( target ) ;


<s> 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 : 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 ) {


<s> static int avr_operand_rtx_cost ( rtx x , machine_mode mode , enum rtx_code outer , int opno , bool speed ) { enum rtx_code code = GET_CODE ( x ) ; int total ;


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


<s> else fprintf ( stream , <STR_LIT> , value ) ;


<s> } 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> 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 ( <NUM_LIT> == pop8 ) continue ; else if ( ld_reg_p ) avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; else if ( <NUM_LIT> == pop8 ) { 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 ( <NUM_LIT> == pop8 ) { 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 ( <NUM_LIT> == pop8 ) continue ; else if ( <NUM_LIT> == pop8 ) 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 ( <NUM_LIT> == pop8 ) { 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> ) ; }


<s> else if ( ld_reg_p ) avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; else if ( <NUM_LIT> == pop8 ) { 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 ( <NUM_LIT> == pop8 ) { 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 ( <NUM_LIT> == pop8 ) continue ; else if ( <NUM_LIT> == pop8 ) 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 ( <NUM_LIT> == pop8 ) { 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 ( <NUM_LIT> == pop8 ) continue ; else if ( <NUM_LIT> == pop8 ) 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> ) ; clobber_val = ( int ) val8 ; avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; } continue ; default : gcc_unreachable ( ) ; } }


<s> 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> ) ; } } for ( i = <NUM_LIT> ; i < n_bytes ; i ++ ) { rtx reg8 = simplify_gen_subreg ( QImode , xreg , mode , i ) ; rtx xval8 = simplify_gen_subreg ( QImode , xval , mode , i ) ; unsigned int val8 = UINTVAL ( xval8 ) & GET_MODE_MASK ( QImode ) ; bool ld_reg_p = test_hard_reg_class ( LD_REGS , reg8 ) ; xop [ <NUM_LIT> ] = reg8 ; xop [ <NUM_LIT> ] = gen_int_mode ( val8 , QImode ) ; if ( i == <NUM_LIT> && test_hard_reg_class ( ADDW_REGS , reg8 ) ) { int val16 = trunc_int_for_mode ( INTVAL ( xval ) , HImode ) ; if ( IN_RANGE ( val16 , <NUM_LIT> , <NUM_LIT> ) && ( val8 == <NUM_LIT> || reg_unused_after ( insn , xreg ) ) ) { if ( AVR_TINY ) avr_asm_len ( TINY_SBIW ( % A0 , % B0 , % <NUM_LIT> ) , xop , plen , <NUM_LIT> ) ; else avr_asm_len ( <STR_LIT> , xop , plen , <NUM_LIT> ) ; i ++ ; continue ; } if ( n_bytes == <NUM_LIT> && IN_RANGE ( val16 , - <NUM_LIT> , - <NUM_LIT> ) && compare_eq_p ( insn ) && reg_unused_after ( insn , xreg ) ) {

return AVR_TINY ? avr_asm_len ( TINY_ADIW ( % A0 , % B0 , % n1 ) , xop , plen , <NUM_LIT> ) : avr_asm_len ( <STR_LIT> , xop , plen , <NUM_LIT> ) ;


if ( reg_dest != ( reg_base - <NUM_LIT> ) && ! reg_unused_after ( insn , XEXP ( base , <NUM_LIT> ) ) ) avr_asm_len ( TINY_SBIW ( % I1 , % J1 , % o1 + <NUM_LIT> ) , op , plen , <NUM_LIT> ) ;


<s> rtx dest = op [ <NUM_LIT> ] ; rtx src = op [ <NUM_LIT> ] ; rtx base = XEXP ( src , <NUM_LIT> ) ; int reg_dest = true_regnum ( dest ) ; int reg_base = true_regnum ( base ) ; if ( reg_base == reg_dest ) { return avr_asm_len ( TINY_ADIW ( % E1 , % F1 , <NUM_LIT> ) CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB TINY_SBIW ( % E1 , % F1 , <NUM_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> ) ; 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 { avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , xop , plen , <NUM_LIT> ) ; } xop [ <NUM_LIT> ] = xstring_e ; if ( ! AVR_HAVE_ELPMX ) return avr_out_lpm_no_lpmx ( insn , xop , plen ) ; } 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> : return avr_asm_len ( <STR_LIT> , xop , plen , <NUM_LIT> ) ; case <NUM_LIT> : if ( REGNO ( dest ) == REG_Z ) return 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> ) return 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 ;


<s> 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> : return avr_asm_len ( <STR_LIT> , xop , plen , <NUM_LIT> ) ; case <NUM_LIT> : if ( REGNO ( dest ) == REG_Z ) return 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> ) return 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 ) { xop [ <NUM_LIT> ] = zero_reg_rtx ;


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


else if ( GET_CODE ( base ) == PRE_DEC ) {


<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> avr_asm_len ( <STR_LIT> , xop , plen , <NUM_LIT> ) ; switch ( as ) { default : gcc_unreachable ( ) ; case ADDR_SPACE_GENERIC : avr_asm_len ( <STR_LIT> , xop , plen , <NUM_LIT> ) ; break ; case ADDR_SPACE_FLASH : if ( AVR_HAVE_LPMX ) avr_asm_len ( <STR_LIT> , xop , plen , <NUM_LIT> ) ; else avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , xop , plen , <NUM_LIT> ) ; break ; case ADDR_SPACE_FLASH1 : case ADDR_SPACE_FLASH2 : case ADDR_SPACE_FLASH3 : case ADDR_SPACE_FLASH4 : case ADDR_SPACE_FLASH5 : if ( AVR_HAVE_ELPMX ) avr_asm_len ( <STR_LIT> , xop , plen , <NUM_LIT> ) ; else avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , xop , plen , <NUM_LIT> ) ; break ; } avr_asm_len ( <STR_LIT> , xop , plen , <NUM_LIT> ) ; if ( QImode == loop_mode ) { avr_asm_len ( <STR_LIT> , xop , plen , <NUM_LIT> ) ; }


<s> 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> static const char * avr_out_movqi_r_mr_reg_disp_tiny ( rtx_insn * insn , rtx op [ ] , int * plen ) { rtx dest = op [ <NUM_LIT> ] ; rtx src = op [ <NUM_LIT> ] ;


<s> 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> machine_mode mode = GET_MODE ( xdest ) ; machine_mode imode = int_mode_for_mode ( mode ) ; 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 ( <NUM_LIT> == n_bytes ) { 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> ] ) ; } else { if ( ! REG_P ( xop [ <NUM_LIT> ] ) && ! CONST_INT_P ( xop [ <NUM_LIT> ] ) && ! CONST_FIXED_P ( xop [ <NUM_LIT> ] ) ) { return avr_out_plus_symbol ( xop , code , plen , pcc ) ; } op [ <NUM_LIT> ] = avr_to_int_mode ( xop [ <NUM_LIT> ] ) ; op [ <NUM_LIT> ] = avr_to_int_mode ( xop [ <NUM_LIT> ] ) ; op [ <NUM_LIT> ] = avr_to_int_mode ( xop [ <NUM_LIT> ] ) ; } xpattern = INSN_P ( insn ) ? PATTERN ( insn ) : insn ; op [ <NUM_LIT> ] = PARALLEL == GET_CODE ( xpattern ) ? xop [ <NUM_LIT> ] : NULL_RTX ; rtx xmsb = simplify_gen_subreg ( QImode , op [ <NUM_LIT> ] , imode , n_bytes - <NUM_LIT> ) ;

int sign = INTVAL ( xmsb ) < <NUM_LIT> ? - <NUM_LIT> : <NUM_LIT> ;


<s> op [ <NUM_LIT> ] = avr_to_int_mode ( xop [ <NUM_LIT> ] ) ; } else { if ( ! REG_P ( xop [ <NUM_LIT> ] ) && ! CONST_INT_P ( xop [ <NUM_LIT> ] ) && ! CONST_FIXED_P ( xop [ <NUM_LIT> ] ) ) { return avr_out_plus_symbol ( xop , code , plen , pcc ) ; } op [ <NUM_LIT> ] = avr_to_int_mode ( xop [ <NUM_LIT> ] ) ; op [ <NUM_LIT> ] = avr_to_int_mode ( xop [ <NUM_LIT> ] ) ; op [ <NUM_LIT> ] = avr_to_int_mode ( xop [ <NUM_LIT> ] ) ; } xpattern = INSN_P ( insn ) ? PATTERN ( insn ) : insn ; op [ <NUM_LIT> ] = PARALLEL == GET_CODE ( xpattern ) ? xop [ <NUM_LIT> ] : NULL_RTX ; rtx xmsb = simplify_gen_subreg ( QImode , op [ <NUM_LIT> ] , imode , n_bytes - <NUM_LIT> ) ; int sign = INTVAL ( xmsb ) < <NUM_LIT> ? - <NUM_LIT> : <NUM_LIT> ; if ( MINUS == code ) op [ <NUM_LIT> ] = simplify_unary_operation ( NEG , imode , op [ <NUM_LIT> ] , imode ) ; avr_out_plus_1 ( op , & len_minus , MINUS , & cc_minus , code_sat , sign , out_label ) ; avr_out_plus_1 ( op , & len_plus , PLUS , & cc_plus , code_sat , sign , out_label ) ; if ( plen ) { * plen = ( len_minus <= len_plus ) ? len_minus : len_plus ; * pcc = ( len_minus <= len_plus ) ? cc_minus : cc_plus ; }

else if ( len_minus <= len_plus ) avr_out_plus_1 ( op , NULL , MINUS , pcc , code_sat , sign , out_label ) ;


<s> xpattern = gen_rtx_SET ( VOIDmode , 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 ( VOIDmode , xreg , gen_rtx_AND ( imode , xreg , xmask ) ) ; op [ <NUM_LIT> ] = xreg ; op [ <NUM_LIT> ] = xreg ; op [ <NUM_LIT> ] = xmask ; op [ <NUM_LIT> ] = gen_rtx_SCRATCH ( QImode ) ; avr_out_bitop ( xpattern , op , plen_and ) ; avr_asm_len ( <STR_LIT> , NULL , plen , <NUM_LIT> ) ;

if ( plen ) * plen = len_add + len_and ;


<s> if ( reg_base == REG_X ) { gcc_assert ( ! reg_overlap_mentioned_p ( XEXP ( base , <NUM_LIT> ) , src ) ) ; avr_asm_len ( <STR_LIT> CR_TAB <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 avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; } else if ( GET_CODE ( base ) == PRE_DEC ) return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ;


<s> 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> ) ; return <STR_LIT> ; } else return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; } else if ( GET_CODE ( base ) == PLUS ) { int disp = INTVAL ( XEXP ( base , <NUM_LIT> ) ) ; if ( AVR_TINY ) return avr_out_store_psi_reg_disp_tiny ( op , plen ) ; reg_base = REGNO ( XEXP ( base , <NUM_LIT> ) ) ; if ( disp > MAX_LD_OFFSET ( GET_MODE ( dest ) ) ) { if ( reg_base != REG_Y ) fatal_insn ( <STR_LIT> , insn ) ; if ( disp <= <NUM_LIT> + MAX_LD_OFFSET ( GET_MODE ( dest ) ) ) 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> ) ; return 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> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; } if ( reg_base == REG_X ) { gcc_assert ( ! reg_overlap_mentioned_p ( XEXP ( base , <NUM_LIT> ) , src ) ) ; avr_asm_len ( <STR_LIT> CR_TAB <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 avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; } else if ( GET_CODE ( base ) == PRE_DEC ) return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; else if ( GET_CODE ( base ) == POST_INC ) return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; fatal_insn ( <STR_LIT> , insn ) ; return <STR_LIT> ;


<s> 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_src == reg_base ) { return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB TINY_ADIW ( % I0 , % J0 , % o0 ) CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB TINY_SBIW ( % I0 , % J0 , % o0 + <NUM_LIT> ) , op , plen , - <NUM_LIT> ) ; }

else if ( reg_src == reg_base - <NUM_LIT> ) {


<s> 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 ; case POINTER_TYPE : if ( as = avr_nonconst_pointer_addrspace ( node ) , as ) reason = <STR_LIT> ; break ; } if ( reason ) { if ( avr_addrspace [ as ] . segment >= avr_n_flash ) { if ( TYPE_P ( node ) ) error ( <STR_LIT> , node , avr_addrspace [ as ] . name , avr_n_flash ) ; else error ( <STR_LIT> , reason , node , avr_addrspace [ as ] . name , avr_n_flash ) ; } else { if ( TYPE_P ( node ) ) error ( <STR_LIT> , avr_addrspace [ as ] . name , node ) ; else error ( <STR_LIT> <STR_LIT> , avr_addrspace [ as ] . name , reason , node ) ; }


<s> while ( val ) { val &= val - <NUM_LIT> ; pop ++ ; } return pop ;


<s> if ( VOIDmode == mode ) mode = SImode ; for ( 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> if ( VOIDmode == mode ) mode = SImode ; for ( 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 ) ;

if ( <NUM_LIT> == ( pop_mask & ( <NUM_LIT> << avr_popcount ( val8 ) ) ) ) return false ;


<s> case REG : fprintf ( file , 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 && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) { 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 { fprintf ( file , <STR_LIT> ) ; output_addr_const ( file , addr ) ;


<s> static void avr_register_passes ( void ) {


<s> 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> ; for ( reg = <NUM_LIT> ; reg < <NUM_LIT> ; reg ++ ) { if ( fixed_regs [ reg ] ) continue ; if ( ( int_or_sig_p && ! crtl -> is_leaf && call_used_regs [ reg ] ) || ( df_regs_ever_live_p ( reg ) && ( int_or_sig_p || ! call_used_regs [ reg ] ) && ! ( frame_pointer_needed && ( reg == REG_Y || reg == ( REG_Y + <NUM_LIT> ) ) ) ) ) { if ( set ) SET_HARD_REG_BIT ( * set , reg ) ; count ++ ;


<s> for ( reg = <NUM_LIT> ; reg < <NUM_LIT> ; reg ++ ) { if ( fixed_regs [ reg ] ) continue ; if ( ( int_or_sig_p && ! crtl -> is_leaf && call_used_regs [ reg ] ) || ( df_regs_ever_live_p ( reg ) && ( int_or_sig_p || ! call_used_regs [ reg ] ) && ! ( frame_pointer_needed && ( reg == REG_Y || reg == ( REG_Y + <NUM_LIT> ) ) ) ) ) {

if ( set ) SET_HARD_REG_BIT ( * set , reg ) ;


<s> rtx next = next_real_insn ( insn ) ; rtx pat = PATTERN ( next ) ; pattern = SET_SRC ( pattern ) ; if ( true_regnum ( XEXP ( pattern , <NUM_LIT> ) ) >= <NUM_LIT> && true_regnum ( XEXP ( pattern , <NUM_LIT> ) ) >= <NUM_LIT> ) { rtx x = XEXP ( pattern , <NUM_LIT> ) ; rtx src = SET_SRC ( pat ) ; rtx t = XEXP ( src , <NUM_LIT> ) ; PUT_CODE ( t , swap_condition ( GET_CODE ( t ) ) ) ; XEXP ( pattern , <NUM_LIT> ) = XEXP ( pattern , <NUM_LIT> ) ; XEXP ( pattern , <NUM_LIT> ) = x ; INSN_CODE ( next ) = - <NUM_LIT> ; } else if ( true_regnum ( XEXP ( pattern , <NUM_LIT> ) ) >= <NUM_LIT> && XEXP ( pattern , <NUM_LIT> ) == const0_rtx ) { rtx src = SET_SRC ( pat ) ; rtx t = XEXP ( src , <NUM_LIT> ) ;


<s> else if ( true_regnum ( XEXP ( pattern , <NUM_LIT> ) ) >= <NUM_LIT> && CONST_INT_P ( XEXP ( pattern , <NUM_LIT> ) ) ) { rtx x = XEXP ( pattern , <NUM_LIT> ) ; rtx src = SET_SRC ( pat ) ; rtx t = XEXP ( src , <NUM_LIT> ) ; machine_mode mode = GET_MODE ( XEXP ( pattern , <NUM_LIT> ) ) ; if ( avr_simplify_comparison_p ( mode , GET_CODE ( t ) , x ) ) { XEXP ( pattern , <NUM_LIT> ) = gen_int_mode ( INTVAL ( x ) + <NUM_LIT> , mode ) ; PUT_CODE ( t , avr_normalize_condition ( GET_CODE ( t ) ) ) ; INSN_CODE ( next ) = - <NUM_LIT> ;


<s> if ( count ) return NULL ; if ( AVR_3_BYTE_PC ) { r = gen_rtx_SYMBOL_REF ( Pmode , <STR_LIT> ) ; warning ( <NUM_LIT> , <STR_LIT> <STR_LIT> ) ; } else r = gen_rtx_SYMBOL_REF ( Pmode , <STR_LIT> ) ;


<s> 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 ( 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 ( i = <NUM_LIT> ; i < size ; i ++ ) if ( reg_overlap_mentioned_p ( move [ i ] . dst , operands [ <NUM_LIT> ] ) ) for ( 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> ;


<s> if ( avr_log . rtx_costs ) { avr_edump ( <STR_LIT> , done , speed ? <STR_LIT> : <STR_LIT> , * total , outer_code , x ) ;


<s> static bool avr_rtx_costs ( rtx x , int codearg , int outer_code , int opno , int * total , bool speed ) { bool done = avr_rtx_costs_1 ( x , codearg , outer_code , opno , total , speed ) ;


<s> static bool avr_scalar_mode_supported_p ( machine_mode mode ) {

if ( ALL_FIXED_POINT_MODE_P ( mode ) ) return true ;


<s> case HImode : sri -> icode = CODE_FOR_reload_inhi ; break ; case HQmode : sri -> icode = CODE_FOR_reload_inhq ; break ; case HAmode : sri -> icode = CODE_FOR_reload_inha ; break ; case UHQmode : sri -> icode = CODE_FOR_reload_inuhq ; break ; case UHAmode : sri -> icode = CODE_FOR_reload_inuha ; break ; case PSImode : sri -> icode = CODE_FOR_reload_inpsi ; break ;

case SImode : sri -> icode = CODE_FOR_reload_insi ; break ;


<s> else if ( <NUM_LIT> == strcmp ( mcu -> name , avr_mmcu ) && NULL == mcu -> macro ) { avr_arch = & avr_arch_types [ mcu -> arch_id ] ; if ( avr_n_flash < <NUM_LIT> ) avr_n_flash = mcu -> n_flash ; return true ; } }


<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 ( cfun -> machine -> is_interrupt ) cfun -> machine -> is_signal = <NUM_LIT> ; 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 ( ! STR_PREFIX_P ( name , <STR_LIT> ) ) warning_at ( loc , <NUM_LIT> , <STR_LIT> , name , isr ) ; } cfun -> machine -> attributes_checked_p = <NUM_LIT> ;


<s> return <NUM_LIT> + avr_outgoing_args_size ( ) ;


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


<s> rtx_insn * insn ; 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 ( VOIDmode , mem , reg ) ) ; if ( frame_related_p ) RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ;


<s> emit_push_byte ( AVR_TMP_REGNO , 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> if ( clr_p ) { insn = emit_move_insn ( sfr , const0_rtx ) ; if ( frame_related_p ) RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; }


<s> if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS && REG_P ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) && GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == CONST_INT && ( INTVAL ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) <= MAX_LD_OFFSET ( GET_MODE ( x ) ) ) ) { rtx xx = XEXP ( XEXP ( x , <NUM_LIT> ) , <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 ) ;


<s> int ok = <NUM_LIT> ; if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS && REG_P ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) && GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == CONST_INT && ( INTVAL ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) <= MAX_LD_OFFSET ( GET_MODE ( x ) ) ) ) {

rtx xx = XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ;


<s> for ( insn = insns , length = <NUM_LIT> ; insn ; insn = NEXT_INSN ( insn ) ) length += get_attr_length ( insn ) ;


<s> if ( avr_mem_flash_p ( src ) || avr_mem_flash_p ( dest ) ) { return avr_out_lpm ( insn , operands , plen ) ; } gcc_assert ( <NUM_LIT> == GET_MODE_SIZE ( GET_MODE ( dest ) ) ) ; if ( REG_P ( dest ) ) { if ( REG_P ( src ) ) { if ( test_hard_reg_class ( STACK_REG , dest ) ) return avr_asm_len ( <STR_LIT> , operands , plen , - <NUM_LIT> ) ; else if ( test_hard_reg_class ( STACK_REG , src ) ) return avr_asm_len ( <STR_LIT> , operands , plen , - <NUM_LIT> ) ; return avr_asm_len ( <STR_LIT> , operands , plen , - <NUM_LIT> ) ; } else if ( CONSTANT_P ( src ) ) { output_reload_in_const ( operands , NULL_RTX , plen , false ) ; return <STR_LIT> ; } 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 ;


<s> if ( true_regnum ( dest ) > true_regnum ( src ) ) { if ( AVR_HAVE_MOVW ) { * l = <NUM_LIT> ; return ( <STR_LIT> CR_TAB <STR_LIT> ) ; } * l = <NUM_LIT> ; return ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> ) ; } else { if ( AVR_HAVE_MOVW ) { * l = <NUM_LIT> ; return ( <STR_LIT> CR_TAB <STR_LIT> ) ; } * l = <NUM_LIT> ; return ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> ) ; } } 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 ; return <STR_LIT> ; } fatal_insn ( <STR_LIT> , insn ) ;


<s> { <STR_LIT> CR_TAB <STR_LIT> , <STR_LIT> } , { <STR_LIT> CR_TAB <STR_LIT> , <STR_LIT> } , { <STR_LIT> CR_TAB <STR_LIT> , <STR_LIT> } , { <STR_LIT> CR_TAB <STR_LIT> , <STR_LIT> } } ; xop [ <NUM_LIT> ] = xdest [ n ] ; xop [ <NUM_LIT> ] = src ; xop [ <NUM_LIT> ] = clobber_reg ; 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 ( <NUM_LIT> != INTVAL ( lo16 ) || ! 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 ( j = <NUM_LIT> ; j < n ; j ++ ) if ( ival [ j ] == ival [ n ] ) { xop [ <NUM_LIT> ] = xdest [ n ] ; xop [ <NUM_LIT> ] = xdest [ j ] ; avr_asm_len ( <STR_LIT> , xop , len , <NUM_LIT> ) ; done_byte = true ; break ; }


<s> if ( CONSTANT_ADDRESS_P ( base ) ) { int n_words = AVR_TINY ? <NUM_LIT> : <NUM_LIT> ; return optimize > <NUM_LIT> && 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 ) ; } if ( reg_base > <NUM_LIT> ) { if ( AVR_TINY ) return avr_out_movhi_mr_r_reg_no_disp_tiny ( insn , op , plen ) ; if ( reg_base != REG_X ) return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; if ( reg_src == REG_X ) return ! mem_volatile_p && reg_unused_after ( insn , 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> , op , plen , - <NUM_LIT> ) ; return ! mem_volatile_p && reg_unused_after ( insn , base ) ? avr_asm_len ( <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 ) == PLUS ) { int disp = INTVAL ( XEXP ( base , <NUM_LIT> ) ) ; if ( AVR_TINY ) return avr_out_movhi_mr_r_reg_disp_tiny ( op , plen ) ; reg_base = REGNO ( XEXP ( base , <NUM_LIT> ) ) ; if ( disp > MAX_LD_OFFSET ( GET_MODE ( dest ) ) ) { if ( reg_base != REG_Y ) fatal_insn ( <STR_LIT> , insn ) ; return disp <= <NUM_LIT> + MAX_LD_OFFSET ( GET_MODE ( dest ) ) ? 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> ) ;


<s> int reg_base = true_regnum ( XEXP ( base , <NUM_LIT> ) ) ; if ( AVR_TINY ) return avr_out_movhi_r_mr_reg_disp_tiny ( 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 ) return reg_base == reg_dest ? 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> , op , plen , - <NUM_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> ) ; } else if ( CONSTANT_ADDRESS_P ( base ) ) { int n_words = AVR_TINY ? <NUM_LIT> : <NUM_LIT> ; return optimize > <NUM_LIT> && 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 ) ; } fatal_insn ( <STR_LIT> , insn ) ;


<s> return optimize > <NUM_LIT> && io_address_operand ( x , QImode ) ? avr_asm_len ( <STR_LIT> , op , plen , - <NUM_LIT> ) : avr_asm_len ( <STR_LIT> , op , plen , - n_words ) ; } else 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_mr_r_reg_disp_tiny ( insn , op , plen ) ; if ( disp - GET_MODE_SIZE ( GET_MODE ( dest ) ) >= <NUM_LIT> ) { if ( REGNO ( XEXP ( x , <NUM_LIT> ) ) != REG_Y ) fatal_insn ( <STR_LIT> , insn ) ; if ( disp <= <NUM_LIT> + MAX_LD_OFFSET ( GET_MODE ( dest ) ) ) return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ;


<s> rtx src = op [ <NUM_LIT> ] ; rtx x = XEXP ( dest , <NUM_LIT> ) ; if ( CONSTANT_ADDRESS_P ( x ) ) { int n_words = AVR_TINY ? <NUM_LIT> : <NUM_LIT> ; return optimize > <NUM_LIT> && io_address_operand ( x , QImode ) ? avr_asm_len ( <STR_LIT> , op , plen , - <NUM_LIT> ) : avr_asm_len ( <STR_LIT> , op , plen , - n_words ) ; } else 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> ) ) ;


<s> int n_words = AVR_TINY ? <NUM_LIT> : <NUM_LIT> ; return optimize > <NUM_LIT> && 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> ) ;


<s> return ( dead_or_set_p ( insn , reg ) || ( REG_P ( reg ) && _reg_unused_after ( insn , reg ) ) ) ;


<s> int reg_unused_after ( rtx_insn * insn , rtx reg ) { return ( dead_or_set_p ( insn , reg ) || ( REG_P ( reg ) && _reg_unused_after ( insn , reg ) ) ) ;


<s> rtx set = single_set ( this_insn ) ; if ( CALL_P ( this_insn ) ) code = CALL_INSN ; else if ( JUMP_P ( this_insn ) ) { if ( INSN_ANNULLED_BRANCH_P ( this_insn ) ) return <NUM_LIT> ; code = JUMP_INSN ; } if ( set && reg_overlap_mentioned_p ( reg , SET_SRC ( set ) ) ) return <NUM_LIT> ; if ( set && reg_overlap_mentioned_p ( reg , SET_DEST ( set ) ) ) { if ( GET_CODE ( SET_DEST ( set ) ) != MEM ) retval = <NUM_LIT> ; else return <NUM_LIT> ; } if ( set == <NUM_LIT> && reg_overlap_mentioned_p ( reg , PATTERN ( this_insn ) ) ) return <NUM_LIT> ; } if ( retval == <NUM_LIT> ) return <NUM_LIT> ; else if ( code == JUMP_INSN ) return <NUM_LIT> ; } if ( code == CALL_INSN ) { rtx tem ; for ( tem = CALL_INSN_FUNCTION_USAGE ( insn ) ; tem ; tem = XEXP ( tem , <NUM_LIT> ) ) if ( GET_CODE ( XEXP ( tem , <NUM_LIT> ) ) == USE && REG_P ( XEXP ( XEXP ( tem , <NUM_LIT> ) , <NUM_LIT> ) ) && reg_overlap_mentioned_p ( reg , XEXP ( XEXP ( tem , <NUM_LIT> ) , <NUM_LIT> ) ) ) return <NUM_LIT> ; if ( call_used_regs [ REGNO ( reg ) ] ) return <NUM_LIT> ; } set = single_set ( insn ) ;


<s> rtx avr_eval_addr_attrib ( rtx x ) { if ( GET_CODE ( x ) == SYMBOL_REF && ( SYMBOL_REF_FLAGS ( x ) & SYMBOL_FLAG_ADDRESS ) ) { tree decl = SYMBOL_REF_DECL ( x ) ; 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 ) ) ;


<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> 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> int avr_hard_regno_call_part_clobbered ( unsigned regno , machine_mode mode ) { if ( ! avr_hard_regno_mode_ok ( regno , mode ) ) return <NUM_LIT> ;

return ( ( regno <= LAST_CALLEE_SAVED_REG && regno + GET_MODE_SIZE ( mode ) > ( LAST_CALLEE_SAVED_REG + <NUM_LIT> ) ) || ( regno < REG_Y && regno + GET_MODE_SIZE ( mode ) > REG_Y ) || ( regno < REG_Z && regno + GET_MODE_SIZE ( mode ) > REG_Z ) ) ;


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


<s> as = TYPE_ADDR_SPACE ( TREE_TYPE ( node ) ) ; if ( avr_addrspace [ as ] . segment >= avr_n_flash ) { error ( <STR_LIT> <STR_LIT> , node , avr_addrspace [ as ] . name , <NUM_LIT> * avr_n_flash ) ; } else if ( ! AVR_HAVE_LPM && avr_addrspace [ as ] . pointer_size > <NUM_LIT> ) { error ( <STR_LIT> <STR_LIT> , node , avr_addrspace [ as ] . name , avr_arch -> name ) ; } 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> static void avr_option_override ( void ) { flag_delete_null_pointer_checks = <NUM_LIT> ; if ( avr_strict_X ) flag_caller_saves = <NUM_LIT> ; maybe_set_param_value ( PARAM_ALLOW_STORE_DATA_RACES , <NUM_LIT> , global_options . x_param_values , global_options_set . x_param_values ) ; if ( ( flag_unwind_tables || flag_non_call_exceptions || flag_asynchronous_unwind_tables ) && ! ACCUMULATE_OUTGOING_ARGS ) { flag_omit_frame_pointer = <NUM_LIT> ; } if ( flag_pic == <NUM_LIT> ) warning ( OPT_fpic , <STR_LIT> ) ; if ( flag_pic == <NUM_LIT> ) warning ( OPT_fPIC , <STR_LIT> ) ; if ( flag_pie == <NUM_LIT> ) warning ( OPT_fpie , <STR_LIT> ) ; if ( flag_pie == <NUM_LIT> ) warning ( OPT_fPIE , <STR_LIT> ) ; if ( ! avr_set_core_architecture ( ) ) return ; avr_addr . sreg = <NUM_LIT> + avr_arch -> sfr_offset ; avr_addr . rampz = <NUM_LIT> + avr_arch -> sfr_offset ; avr_addr . rampy = <NUM_LIT> + avr_arch -> sfr_offset ;


<s> 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> 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 ; case POINTER_TYPE : if ( as = avr_nonconst_pointer_addrspace ( node ) , as ) reason = <STR_LIT> ;


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


<s> HOST_WIDE_INT size_max = ( HOST_WIDE_INT ) GET_MODE_MASK ( AVR_HAVE_8BIT_SP ? QImode : Pmode ) ; bool minimize = ( TARGET_CALL_PROLOGUES && size < size_max && live_seq && ! isr_p && ! cfun -> machine -> is_OS_task && ! cfun -> machine -> is_OS_main && ! AVR_TINY ) ; if ( minimize && ( frame_pointer_needed || avr_outgoing_args_size ( ) > <NUM_LIT> || ( AVR_2_BYTE_PC && live_seq > <NUM_LIT> ) || live_seq > <NUM_LIT> ) ) { rtx pattern ; int first_reg , reg , offset ; emit_move_insn ( gen_rtx_REG ( HImode , REG_X ) , gen_int_mode ( size , HImode ) ) ; pattern = gen_call_prologue_saves ( gen_int_mode ( live_seq , HImode ) , gen_int_mode ( live_seq + size , HImode ) ) ; insn = emit_insn ( pattern ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; add_reg_note ( insn , REG_CFA_ADJUST_CFA , gen_rtx_SET ( ( frame_pointer_needed ? frame_pointer_rtx : stack_pointer_rtx ) , plus_constant ( Pmode , stack_pointer_rtx , - ( size + live_seq ) ) ) ) ; first_reg = ( LAST_CALLEE_SAVED_REG + <NUM_LIT> ) - ( live_seq - <NUM_LIT> ) ; for ( reg = <NUM_LIT> , offset = - live_seq + <NUM_LIT> ; reg >= first_reg ; reg = ( reg == <NUM_LIT> ? LAST_CALLEE_SAVED_REG : reg - <NUM_LIT> ) , ++ offset ) { rtx m , r ; m = gen_rtx_MEM ( QImode , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) ; r = gen_rtx_REG ( QImode , reg ) ; add_reg_note ( insn , REG_CFA_OFFSET , gen_rtx_SET ( m , r ) ) ;


<s> if ( compare_diff_p ( insn ) ) { rtx_insn * next = next_real_insn ( insn ) ; rtx pat = PATTERN ( next ) ; pattern = SET_SRC ( pattern ) ; if ( true_regnum ( XEXP ( pattern , <NUM_LIT> ) ) >= <NUM_LIT> && true_regnum ( XEXP ( pattern , <NUM_LIT> ) ) >= <NUM_LIT> ) { rtx x = XEXP ( pattern , <NUM_LIT> ) ; rtx src = SET_SRC ( pat ) ; rtx t = XEXP ( src , <NUM_LIT> ) ; PUT_CODE ( t , swap_condition ( GET_CODE ( t ) ) ) ; XEXP ( pattern , <NUM_LIT> ) = XEXP ( pattern , <NUM_LIT> ) ; XEXP ( pattern , <NUM_LIT> ) = x ; INSN_CODE ( next ) = - <NUM_LIT> ; } else if ( true_regnum ( XEXP ( pattern , <NUM_LIT> ) ) >= <NUM_LIT> && XEXP ( pattern , <NUM_LIT> ) == const0_rtx ) { rtx src = SET_SRC ( pat ) ; rtx t = XEXP ( src , <NUM_LIT> ) ; PUT_CODE ( t , swap_condition ( GET_CODE ( t ) ) ) ; XEXP ( pattern , <NUM_LIT> ) = XEXP ( pattern , <NUM_LIT> ) ; XEXP ( pattern , <NUM_LIT> ) = const0_rtx ; INSN_CODE ( next ) = - <NUM_LIT> ; INSN_CODE ( insn ) = - <NUM_LIT> ; } else if ( true_regnum ( XEXP ( pattern , <NUM_LIT> ) ) >= <NUM_LIT> && CONST_INT_P ( XEXP ( pattern , <NUM_LIT> ) ) ) { rtx x = XEXP ( pattern , <NUM_LIT> ) ;


<s> 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> static int avr_address_cost ( rtx x , machine_mode mode ATTRIBUTE_UNUSED , addr_space_t as ATTRIBUTE_UNUSED , bool speed ATTRIBUTE_UNUSED ) { int cost = <NUM_LIT> ; if ( GET_CODE ( x ) == PLUS && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) && ( REG_P ( XEXP ( x , <NUM_LIT> ) ) || SUBREG_P ( XEXP ( x , <NUM_LIT> ) ) ) ) { if ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) > MAX_LD_OFFSET ( mode ) ) cost = <NUM_LIT> ; } else if ( CONSTANT_ADDRESS_P ( x ) ) { if ( optimize > <NUM_LIT> && io_address_operand ( x , QImode ) ) cost = <NUM_LIT> ;

if ( AVR_TINY && avr_address_tiny_absdata_p ( x , QImode ) ) cost = <NUM_LIT> ;


<s> else if ( CONSTANT_ADDRESS_P ( x ) ) { if ( optimize > <NUM_LIT> && io_address_operand ( x , QImode ) ) cost = <NUM_LIT> ; if ( AVR_TINY && avr_address_tiny_absdata_p ( x , QImode ) ) cost = <NUM_LIT> ; } if ( avr_log . address_cost ) avr_edump ( <STR_LIT> , cost , x ) ; return cost ;


<s> switch ( adjust_len ) { case ADJUST_LEN_RELOAD_IN16 : output_reload_inhi ( op , op [ <NUM_LIT> ] , & len ) ; break ; case ADJUST_LEN_RELOAD_IN24 : avr_out_reload_inpsi ( op , op [ <NUM_LIT> ] , & len ) ; break ; case ADJUST_LEN_RELOAD_IN32 : output_reload_insisf ( op , op [ <NUM_LIT> ] , & len ) ; break ; case ADJUST_LEN_OUT_BITOP : avr_out_bitop ( insn , op , & len ) ; break ; case ADJUST_LEN_PLUS : avr_out_plus ( insn , op , & len ) ; break ; case ADJUST_LEN_ADDTO_SP : avr_out_addto_sp ( op , & len ) ; break ; case ADJUST_LEN_MOV8 : output_movqi ( insn , op , & len ) ; break ; case ADJUST_LEN_MOV16 : output_movhi ( insn , op , & len ) ; break ; case ADJUST_LEN_MOV24 : avr_out_movpsi ( insn , op , & len ) ; break ; case ADJUST_LEN_MOV32 : output_movsisf ( insn , op , & len ) ; break ; case ADJUST_LEN_MOVMEM : avr_out_movmem ( insn , op , & len ) ; break ; case ADJUST_LEN_XLOAD : avr_out_xload ( insn , op , & len ) ; break ; case ADJUST_LEN_SEXT : avr_out_sign_extend ( insn , op , & len ) ; break ; case ADJUST_LEN_SFRACT : avr_out_fract ( insn , op , true , & len ) ; break ; case ADJUST_LEN_UFRACT : avr_out_fract ( insn , op , false , & len ) ; break ; case ADJUST_LEN_ROUND : avr_out_round ( insn , op , & len ) ; break ; case ADJUST_LEN_TSTHI : avr_out_tsthi ( insn , op , & len ) ; break ; case ADJUST_LEN_TSTPSI : avr_out_tstpsi ( insn , op , & len ) ; break ; case ADJUST_LEN_TSTSI : avr_out_tstsi ( insn , op , & len ) ; break ; case ADJUST_LEN_COMPARE : avr_out_compare ( insn , op , & len ) ; break ; case ADJUST_LEN_COMPARE64 : avr_out_compare64 ( insn , op , & len ) ; break ; case ADJUST_LEN_LSHRQI : lshrqi3_out ( insn , op , & len ) ; break ; case ADJUST_LEN_LSHRHI : lshrhi3_out ( insn , op , & len ) ; break ; case ADJUST_LEN_LSHRSI : lshrsi3_out ( insn , op , & len ) ; break ; case ADJUST_LEN_ASHRQI : ashrqi3_out ( insn , op , & len ) ; break ; case ADJUST_LEN_ASHRHI : ashrhi3_out ( insn , op , & len ) ; break ; case ADJUST_LEN_ASHRSI : ashrsi3_out ( insn , op , & len ) ; break ; case ADJUST_LEN_ASHLQI : ashlqi3_out ( insn , op , & len ) ; break ; case ADJUST_LEN_ASHLHI : ashlhi3_out ( insn , op , & len ) ; break ; case ADJUST_LEN_ASHLSI : ashlsi3_out ( insn , op , & len ) ; break ; case ADJUST_LEN_ASHLPSI : avr_out_ashlpsi3 ( insn , op , & len ) ; break ;

case ADJUST_LEN_ASHRPSI : avr_out_ashrpsi3 ( insn , op , & len ) ; break ;


<s> data_section -> unnamed . callback = avr_output_data_section_asm_op ;

bss_section -> unnamed . callback = avr_output_bss_section_asm_op ;


<s> static void avr_asm_init_sections ( void ) { readonly_data_section -> unnamed . callback = avr_output_data_section_asm_op ; data_section -> unnamed . callback = avr_output_data_section_asm_op ; bss_section -> unnamed . callback = avr_output_bss_section_asm_op ;


<s> static bool avr_assemble_integer ( rtx x , unsigned int size , int aligned_p ) { if ( size == POINTER_SIZE / BITS_PER_UNIT && aligned_p && text_segment_operand ( x , VOIDmode ) ) { fputs ( <STR_LIT> , asm_out_file ) ; output_addr_const ( asm_out_file , x ) ; fputs ( <STR_LIT> , asm_out_file ) ; return true ; } else if ( GET_MODE ( x ) == PSImode ) { fputs ( <STR_LIT> , asm_out_file ) ; output_addr_const ( asm_out_file , x ) ; fputs ( <STR_LIT> ASM_COMMENT_START <STR_LIT> , asm_out_file ) ;


<s> } else if ( GET_MODE ( x ) == PSImode ) { fputs ( <STR_LIT> , asm_out_file ) ; 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 ) ; 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 ) ;

default_assemble_integer ( xn , <NUM_LIT> , aligned_p ) ;


<s> rtx sub_5 = NULL_RTX ; 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> ) ; }

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


<s> sub_5 = XEXP ( xop [ <NUM_LIT> ] , <NUM_LIT> ) ; } if ( sub_5 && SUBREG_P ( sub_5 ) && <NUM_LIT> == SUBREG_BYTE ( sub_5 ) && rtx_equal_p ( xop [ <NUM_LIT> ] , SUBREG_REG ( sub_5 ) ) ) return true ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> ) ;


<s> tree type = TREE_TYPE ( decl ) ; tree attr = DECL_ATTRIBUTES ( decl ) ; if ( type == error_mark_node ) return ; addr_space_t as = TYPE_ADDR_SPACE ( type ) ; if ( ! AVR_TINY && - <NUM_LIT> == avr_progmem_p ( decl , attr ) ) as = ADDR_SPACE_FLASH ; AVR_SYMBOL_SET_ADDR_SPACE ( sym , as ) ; tree io_low_attr = lookup_attribute ( <STR_LIT> , attr ) ; 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 ;


<s> gcc_assert ( id < AVR_BUILTIN_COUNT ) ; switch ( id ) { 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 :


<s> 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 ) ; } 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 ( TMP_REGNO ) ; emit_move_insn ( rampz_rtx , tmp_reg_rtx ) ; } 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 ( TMP_REGNO ) ; emit_move_insn ( rampy_rtx , tmp_reg_rtx ) ; } if ( AVR_HAVE_RAMPX && TEST_HARD_REG_BIT ( set , REG_X ) && TEST_HARD_REG_BIT ( set , REG_X + <NUM_LIT> ) ) { emit_pop_byte ( TMP_REGNO ) ; emit_move_insn ( rampx_rtx , tmp_reg_rtx ) ; } if ( AVR_HAVE_RAMPD ) { emit_pop_byte ( TMP_REGNO ) ; emit_move_insn ( rampd_rtx , tmp_reg_rtx ) ; }


<s> if ( cfun -> machine -> is_interrupt ) emit_insn ( gen_enable_interrupt ( ) ) ; emit_push_byte ( AVR_ZERO_REGNO , true ) ; emit_push_byte ( AVR_TMP_REGNO , true ) ; emit_push_sfr ( sreg_rtx , false , false ) ; emit_move_insn ( zero_reg_rtx , const0_rtx ) ; emit_use ( zero_reg_rtx ) ; if ( AVR_HAVE_RAMPD ) emit_push_sfr ( rampd_rtx , false , true ) ; 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 ) ;


<s> static rtx avr_find_unused_d_reg ( rtx_insn * insn , rtx exclude ) { bool isr_p = ( avr_interrupt_function_p ( current_function_decl ) || avr_signal_function_p ( current_function_decl ) ) ; for ( int regno = <NUM_LIT> ; regno < <NUM_LIT> ; regno ++ ) { rtx reg = all_regs_rtx [ regno ] ; if ( ( exclude && reg_overlap_mentioned_p ( exclude , reg ) ) || fixed_regs [ regno ] ) { continue ; } if ( ! df_regs_ever_live_p ( regno ) && ( TREE_THIS_VOLATILE ( current_function_decl ) || cfun -> machine -> is_OS_task || cfun -> machine -> is_OS_main || ( ! isr_p && call_used_regs [ regno ] ) ) ) {


<s> changed = true ; } if ( TREE_CODE ( tbits ) != INTEGER_CST && <NUM_LIT> == avr_map_metric ( map , MAP_PREIMAGE_0_7 ) ) { tbits = build_int_cst ( val_type , <NUM_LIT> ) ; } if ( TREE_CODE ( tbits ) == INTEGER_CST ) { int bits = TREE_INT_CST_LOW ( tbits ) ; int mask_ior = <NUM_LIT> , mask_and = <NUM_LIT> ; for ( size_t i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { int mi = avr_map ( map , i ) ; if ( mi < <NUM_LIT> ) { if ( bits & ( <NUM_LIT> << mi ) ) mask_ior |= ( <NUM_LIT> << i ) ; else mask_and &= ~ ( <NUM_LIT> << i ) ; } } tval = fold_build2 ( BIT_IOR_EXPR , val_type , tval , build_int_cst ( val_type , mask_ior ) ) ; return fold_build2 ( BIT_AND_EXPR , val_type , tval , build_int_cst ( val_type , mask_and ) ) ; } if ( changed ) return build_call_expr ( fndecl , <NUM_LIT> , tmap , tbits , tval ) ; if ( <NUM_LIT> == avr_map_metric ( map , MAP_NONFIXED_0_7 ) ) { int mask_f = avr_map_metric ( map , MAP_MASK_PREIMAGE_F ) ; tree tres , tmask = build_int_cst ( val_type , mask_f ^ <NUM_LIT> ) ; tres = fold_build2 ( BIT_XOR_EXPR , val_type , tbits , tval ) ; tres = fold_build2 ( BIT_AND_EXPR , val_type , tres , tmask ) ; return fold_build2 ( BIT_XOR_EXPR , val_type , tres , tval ) ; } if ( avr_log . builtin ) avr_edump ( <STR_LIT> , map ) ; best_g = avr_map_op [ <NUM_LIT> ] ; best_g . cost = <NUM_LIT> ; for ( size_t i = <NUM_LIT> ; i < ARRAY_SIZE ( avr_map_op ) ; i ++ ) {

avr_map_op_t g = avr_map_decompose ( map , avr_map_op + i , TREE_CODE ( tval ) == INTEGER_CST ) ;


<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> int bytes = avr_num_arg_regs ( mode , type ) ; cum -> nregs -= bytes ; cum -> regno -= bytes ; if ( cum -> regno >= <NUM_LIT> && cum -> nregs >= <NUM_LIT> && ! call_used_regs [ cum -> regno ] ) { 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 ] ) ;


<s> int avr_hard_regno_call_part_clobbered ( unsigned regno , machine_mode mode ) {

if ( ! avr_hard_regno_mode_ok ( regno , mode ) ) return <NUM_LIT> ;


<s> 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> 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> } 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 ( <NUM_LIT> == recog_data . n_operands ) ; gcc_assert ( <NUM_LIT> == recog_data . n_dups ) ; 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 ] ) ; fprintf ( dump_file , <STR_LIT> ) ; }


<s> static avr_map_op_t avr_map_decompose ( unsigned int f , const avr_map_op_t * g , bool val_const_p ) { bool val_used_p = <NUM_LIT> != avr_map_metric ( f , MAP_MASK_PREIMAGE_F ) ; avr_map_op_t f_ginv = * g ; unsigned int ginv = g -> ginv ; f_ginv . cost = - <NUM_LIT> ; for ( int i = <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) { 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 ( <NUM_LIT> == avr_map_metric ( f_ginv . map , MAP_NONFIXED_0_7 ) ) { 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 ) ; f_ginv . cost += val_const_p && val_used_p ? <NUM_LIT> : <NUM_LIT> ; } f_ginv . cost += g -> cost ; if ( avr_log . builtin ) avr_edump ( <STR_LIT> , g -> str , g -> arg , f_ginv . cost ) ; return f_ginv ;


<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 ( <NUM_LIT> == avr_map_metric ( f_ginv . map , MAP_NONFIXED_0_7 ) ) { 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 ) ; f_ginv . cost += val_const_p && val_used_p ? <NUM_LIT> : <NUM_LIT> ; }


<s> rtx ( * gen_add ) ( rtx , rtx , rtx ) = QImode == mode ? gen_addqi3 : gen_addhi3 ; rtx ( * gen_cmp ) ( rtx , rtx ) = QImode == mode ? gen_cmpqi3 : gen_cmphi3 ; emit_insn ( gen_add ( reg , reg , gen_int_mode ( - low_idx , mode ) ) ) ; emit_insn ( gen_cmp ( reg , gen_int_mode ( num_idx , mode ) ) ) ; seq1 = get_insns ( ) ; last1 = get_last_insn ( ) ; end_sequence ( ) ; emit_insn_before ( 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> ] ) ) ; emit_insn ( pat_4 ) ; seq2 = get_insns ( ) ; last2 = get_last_insn ( ) ; end_sequence ( ) ;

emit_insn_after ( seq2 , insns [ <NUM_LIT> ] ) ;


<s> flag_omit_frame_pointer = <NUM_LIT> ; } if ( flag_pic == <NUM_LIT> ) warning ( OPT_fpic , <STR_LIT> ) ; if ( flag_pic == <NUM_LIT> ) warning ( OPT_fPIC , <STR_LIT> ) ; if ( flag_pie == <NUM_LIT> ) warning ( OPT_fpie , <STR_LIT> ) ; if ( flag_pie == <NUM_LIT> ) warning ( OPT_fPIE , <STR_LIT> ) ; if ( ! avr_set_core_architecture ( ) ) return ; avr_addr . sreg = <NUM_LIT> + avr_arch -> sfr_offset ;


<s> const char * avr_out_bitop ( rtx insn , rtx * xop , int * plen ) { rtx xpattern = INSN_P ( insn ) ? single_set ( as_a < rtx_insn * > ( insn ) ) : insn ; enum rtx_code code = GET_CODE ( SET_SRC ( xpattern ) ) ; machine_mode mode = GET_MODE ( xop [ <NUM_LIT> ] ) ; int n_bytes = GET_MODE_SIZE ( mode ) ; int set_t = - <NUM_LIT> ; int clobber_val = - <NUM_LIT> ; rtx op [ <NUM_LIT> ] ; op [ <NUM_LIT> ] = QImode == mode ? NULL_RTX : xop [ <NUM_LIT> ] ; op [ <NUM_LIT> ] = NULL_RTX ; if ( plen ) * plen = <NUM_LIT> ; for ( int i = <NUM_LIT> ; i < n_bytes ; i ++ ) { rtx reg8 = simplify_gen_subreg ( QImode , xop [ <NUM_LIT> ] , mode , i ) ; rtx xval8 = simplify_gen_subreg ( QImode , xop [ <NUM_LIT> ] , mode , i ) ; unsigned int val8 = UINTVAL ( xval8 ) & GET_MODE_MASK ( QImode ) ; int pop8 = popcount_hwi ( val8 ) ; 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 ( <NUM_LIT> == pop8 ) continue ; else if ( ld_reg_p ) avr_asm_len ( <STR_LIT> , op , plen , <NUM_LIT> ) ; else if ( <NUM_LIT> == pop8 ) { 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 ) ) ;


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


<s> 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 { fprintf ( file , <STR_LIT> ) ; output_addr_const ( file , addr ) ; fprintf ( file , <STR_LIT> ) ;


<s> if ( fixed_regs [ reg ] ) continue ; if ( ( int_or_sig_p && ! crtl -> is_leaf && call_used_regs [ reg ] ) || ( df_regs_ever_live_p ( reg ) && ( int_or_sig_p || ! call_used_regs [ reg ] ) && ! ( frame_pointer_needed && ( reg == REG_Y || reg == REG_Y + <NUM_LIT> ) ) ) ) { if ( set ) SET_HARD_REG_BIT ( * set , reg ) ;


<s> else r = gen_rtx_SYMBOL_REF ( Pmode , <STR_LIT> ) ; 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> ) ) ; return r ;


<s> rtx r ; if ( count ) return NULL ; if ( AVR_3_BYTE_PC ) { r = gen_rtx_SYMBOL_REF ( Pmode , <STR_LIT> ) ; warning ( <NUM_LIT> , <STR_LIT> <STR_LIT> ) ; } else r = gen_rtx_SYMBOL_REF ( Pmode , <STR_LIT> ) ; r = gen_rtx_PLUS ( Pmode , tem , r ) ;

r = gen_frame_mem ( Pmode , memory_address ( Pmode , r ) ) ;


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


<s> if ( NULL == mcu -> name ) { error ( <STR_LIT> , avr_mmcu , <STR_LIT> ) ; avr_inform_core_architectures ( ) ; break ; } else if ( <NUM_LIT> == strcmp ( mcu -> name , avr_mmcu ) && NULL == mcu -> macro ) { 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> ; return true ;


<s> 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 ( cfun -> machine -> is_interrupt ) cfun -> machine -> is_signal = <NUM_LIT> ; 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 ( ! STR_PREFIX_P ( name , <STR_LIT> ) ) warning_at ( loc , OPT_Wmisspelled_isr , <STR_LIT> <STR_LIT> , name , isr ) ;


<s> location_t loc ; const char * isr ; if ( decl == NULL_TREE || current_function_decl == NULL_TREE || current_function_decl == error_mark_node || ! cfun -> machine || cfun -> machine -> attributes_checked_p ) return ; loc = DECL_SOURCE_LOCATION ( decl ) ; cfun -> machine -> is_naked = avr_naked_function_p ( decl ) ; cfun -> machine -> is_signal = avr_signal_function_p ( decl ) ; cfun -> machine -> is_interrupt = avr_interrupt_function_p ( decl ) ; cfun -> machine -> is_OS_task = avr_OS_task_function_p ( decl ) ; cfun -> machine -> is_OS_main = avr_OS_main_function_p ( decl ) ; isr = cfun -> machine -> is_interrupt ? <STR_LIT> : <STR_LIT> ; if ( cfun -> machine -> is_OS_task + cfun -> machine -> is_OS_main + ( cfun -> machine -> is_signal || cfun -> machine -> is_interrupt ) > <NUM_LIT> ) error_at ( loc , <STR_LIT> <STR_LIT> , <STR_LIT> , <STR_LIT> , isr ) ; if ( cfun -> machine -> is_naked && ( cfun -> machine -> is_OS_task || cfun -> machine -> is_OS_main ) ) warning_at ( loc , OPT_Wattributes , <STR_LIT> <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> ) ; 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 ) ) ;


<s> 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 ( <NUM_LIT> != INTVAL ( lo16 ) || ! 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 ] ; xop [ <NUM_LIT> ] = xdest [ j ] ; avr_asm_len ( <STR_LIT> , xop , len , <NUM_LIT> ) ; done_byte = true ; break ; } if ( done_byte ) continue ; if ( - <NUM_LIT> == ival [ n ] ) { if ( ! clear_p ) avr_asm_len ( <STR_LIT> , & xdest [ n ] , len , <NUM_LIT> ) ; avr_asm_len ( <STR_LIT> , & xdest [ n ] , len , <NUM_LIT> ) ; continue ; } else if ( <NUM_LIT> == ival [ n ] ) { if ( ! clear_p ) avr_asm_len ( <STR_LIT> , & xdest [ n ] , len , <NUM_LIT> ) ; avr_asm_len ( <STR_LIT> , & xdest [ n ] , len , <NUM_LIT> ) ; continue ; } if ( NULL_RTX == clobber_reg && single_one_operand ( xval , QImode ) ) { xop [ <NUM_LIT> ] = xdest [ n ] ; xop [ <NUM_LIT> ] = GEN_INT ( exact_log2 ( ival [ n ] & GET_MODE_MASK ( QImode ) ) ) ; gcc_assert ( constm1_rtx != xop [ <NUM_LIT> ] ) ; if ( ! set_p ) { set_p = true ; avr_asm_len ( <STR_LIT> , xop , len , <NUM_LIT> ) ; } if ( ! clear_p ) avr_asm_len ( <STR_LIT> , xop , len , <NUM_LIT> ) ; avr_asm_len ( <STR_LIT> , xop , len , <NUM_LIT> ) ; continue ; } gcc_assert ( NULL_RTX != clobber_reg ) ; xop [ <NUM_LIT> ] = xdest [ n ] ; xop [ <NUM_LIT> ] = xval ; xop [ <NUM_LIT> ] = clobber_reg ; clobber_val = ival [ n ] ;


<s> return optimize > <NUM_LIT> && 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 ) ; } if ( reg_base > <NUM_LIT> ) { if ( AVR_TINY ) return avr_out_movhi_mr_r_reg_no_disp_tiny ( insn , op , plen ) ; if ( reg_base != REG_X ) return avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ; if ( reg_src == REG_X ) return ! mem_volatile_p && reg_unused_after ( insn , 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> , op , plen , - <NUM_LIT> ) ; return ! mem_volatile_p && reg_unused_after ( insn , base ) ? avr_asm_len ( <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 ) == PLUS ) { int disp = INTVAL ( XEXP ( base , <NUM_LIT> ) ) ; if ( AVR_TINY ) return avr_out_movhi_mr_r_reg_disp_tiny ( insn , op , plen ) ;

reg_base = REGNO ( XEXP ( base , <NUM_LIT> ) ) ;


<s> if ( reg_src == REG_X ) return ! mem_volatile_p && reg_unused_after ( insn , 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> , op , plen , - <NUM_LIT> ) ; return ! mem_volatile_p && reg_unused_after ( insn , base ) ? avr_asm_len ( <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 ) == PLUS ) { int disp = INTVAL ( XEXP ( base , <NUM_LIT> ) ) ; if ( AVR_TINY ) return avr_out_movhi_mr_r_reg_disp_tiny ( insn , op , plen ) ; reg_base = REGNO ( XEXP ( base , <NUM_LIT> ) ) ; if ( disp > MAX_LD_OFFSET ( GET_MODE ( dest ) ) ) { if ( reg_base != REG_Y ) fatal_insn ( <STR_LIT> , insn ) ;


<s> 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> ) ; } else if ( CONSTANT_ADDRESS_P ( base ) ) { int n_words = AVR_TINY ? <NUM_LIT> : <NUM_LIT> ; return optimize > <NUM_LIT> && 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 ) ; } fatal_insn ( <STR_LIT> , insn ) ; return <STR_LIT> ;


<s> rtx x = XEXP ( dest , <NUM_LIT> ) ; if ( CONSTANT_ADDRESS_P ( x ) ) { int n_words = AVR_TINY ? <NUM_LIT> : <NUM_LIT> ; return optimize > <NUM_LIT> && io_address_operand ( x , QImode ) ? avr_asm_len ( <STR_LIT> , op , plen , - <NUM_LIT> ) : avr_asm_len ( <STR_LIT> , op , plen , - n_words ) ; } else 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_mr_r_reg_disp_tiny ( insn , op , plen ) ; if ( disp - GET_MODE_SIZE ( GET_MODE ( dest ) ) >= <NUM_LIT> ) { if ( REGNO ( XEXP ( x , <NUM_LIT> ) ) != REG_Y ) fatal_insn ( <STR_LIT> , insn ) ; if ( disp <= <NUM_LIT> + MAX_LD_OFFSET ( GET_MODE ( dest ) ) ) 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 ) { if ( reg_overlap_mentioned_p ( src , XEXP ( x , <NUM_LIT> ) ) ) { avr_asm_len ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> , op , plen , - <NUM_LIT> ) ;


<s> } 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> return optimize > <NUM_LIT> && 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 ) {


<s> for ( int reg = <NUM_LIT> ; reg <= LAST_CALLEE_SAVED_REG ; ++ reg ) { if ( fixed_regs [ reg ] ) { if ( live_seq != <NUM_LIT> ) return <NUM_LIT> ; else continue ; } if ( ! call_used_regs [ reg ] ) { if ( df_regs_ever_live_p ( reg ) ) { ++ live_seq ; ++ cur_seq ; }


<s> if ( ! INSN_P ( insn ) ) continue ; if ( code == JUMP_INSN ) return <NUM_LIT> ; else if ( code == INSN && GET_CODE ( PATTERN ( insn ) ) == SEQUENCE ) { rtx_sequence * seq = as_a < rtx_sequence * > ( PATTERN ( insn ) ) ; int retval = <NUM_LIT> ; for ( int i = <NUM_LIT> ; i < seq -> len ( ) ; i ++ ) { rtx_insn * this_insn = seq -> insn ( i ) ; rtx set = single_set ( this_insn ) ; if ( CALL_P ( this_insn ) ) code = CALL_INSN ; else if ( JUMP_P ( this_insn ) ) { if ( INSN_ANNULLED_BRANCH_P ( this_insn ) ) return <NUM_LIT> ; code = JUMP_INSN ; } if ( set && reg_overlap_mentioned_p ( reg , SET_SRC ( set ) ) ) return <NUM_LIT> ; if ( set && reg_overlap_mentioned_p ( reg , SET_DEST ( set ) ) ) { if ( ! MEM_P ( SET_DEST ( set ) ) ) retval = <NUM_LIT> ; else return <NUM_LIT> ; } if ( set == <NUM_LIT> && reg_overlap_mentioned_p ( reg , PATTERN ( this_insn ) ) ) return <NUM_LIT> ; } if ( retval == <NUM_LIT> ) return <NUM_LIT> ;

else if ( code == JUMP_INSN ) return <NUM_LIT> ;


<s> } if ( retval == <NUM_LIT> ) return <NUM_LIT> ; else if ( code == JUMP_INSN ) return <NUM_LIT> ; } if ( code == CALL_INSN ) { rtx tem ; for ( tem = CALL_INSN_FUNCTION_USAGE ( insn ) ; tem ; tem = XEXP ( tem , <NUM_LIT> ) ) if ( GET_CODE ( XEXP ( tem , <NUM_LIT> ) ) == USE && REG_P ( XEXP ( XEXP ( tem , <NUM_LIT> ) , <NUM_LIT> ) ) && reg_overlap_mentioned_p ( reg , XEXP ( XEXP ( tem , <NUM_LIT> ) , <NUM_LIT> ) ) ) return <NUM_LIT> ; if ( call_used_regs [ REGNO ( reg ) ] ) return <NUM_LIT> ; } set = single_set ( insn ) ; if ( set && reg_overlap_mentioned_p ( reg , SET_SRC ( set ) ) ) return <NUM_LIT> ; if ( set && reg_overlap_mentioned_p ( reg , SET_DEST ( set ) ) ) return ! MEM_P ( SET_DEST ( set ) ) ;

if ( set == <NUM_LIT> && reg_overlap_mentioned_p ( reg , PATTERN ( insn ) ) ) return <NUM_LIT> ;


<s> emit_insn ( gen_subhi3 ( xval , virtual_stack_vars_rtx , gen_int_mode ( avr_starting_frame_offset ( ) , Pmode ) ) ) ; return xval ;


<s> avr_map_op_t best_g ; if ( TREE_CODE ( arg [ <NUM_LIT> ] ) != INTEGER_CST ) { break ; } tmap = wide_int_to_tree ( map_type , wi :: to_wide ( arg [ <NUM_LIT> ] ) ) ; map = TREE_INT_CST_LOW ( tmap ) ; if ( TREE_CODE ( tval ) != INTEGER_CST && avr_map_metric ( map , MAP_MASK_PREIMAGE_F ) == <NUM_LIT> ) { tval = build_int_cst ( val_type , <NUM_LIT> ) ; changed = true ; } if ( TREE_CODE ( tbits ) != INTEGER_CST && avr_map_metric ( map , MAP_PREIMAGE_0_7 ) == <NUM_LIT> ) { tbits = build_int_cst ( val_type , <NUM_LIT> ) ; } if ( TREE_CODE ( tbits ) == INTEGER_CST ) { int bits = TREE_INT_CST_LOW ( tbits ) ; int mask_ior = <NUM_LIT> , mask_and = <NUM_LIT> ; for ( size_t i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { int mi = avr_map ( map , i ) ; if ( mi < <NUM_LIT> ) { if ( bits & ( <NUM_LIT> << mi ) ) mask_ior |= ( <NUM_LIT> << i ) ; else mask_and &= ~ ( <NUM_LIT> << i ) ; } } tval = fold_build2 ( BIT_IOR_EXPR , val_type , tval , build_int_cst ( val_type , mask_ior ) ) ; return fold_build2 ( BIT_AND_EXPR , val_type , tval , build_int_cst ( val_type , mask_and ) ) ; } if ( changed ) return build_call_expr ( fndecl , <NUM_LIT> , tmap , tbits , tval ) ; if ( avr_map_metric ( map , MAP_NONFIXED_0_7 ) == <NUM_LIT> ) { int mask_f = avr_map_metric ( map , MAP_MASK_PREIMAGE_F ) ; tree tres , tmask = build_int_cst ( val_type , mask_f ^ <NUM_LIT> ) ; tres = fold_build2 ( BIT_XOR_EXPR , val_type , tbits , tval ) ; tres = fold_build2 ( BIT_AND_EXPR , val_type , tres , tmask ) ; return fold_build2 ( BIT_XOR_EXPR , val_type , tres , tval ) ; } if ( avr_log . builtin ) avr_edump ( <STR_LIT> , map ) ; best_g = avr_map_op [ <NUM_LIT> ] ; best_g . cost = <NUM_LIT> ;

for ( size_t i = <NUM_LIT> ; i < ARRAY_SIZE ( avr_map_op ) ; i ++ ) {


<s> static bool avr_hard_regno_call_part_clobbered ( unsigned regno , machine_mode mode ) {


<s> static void avr_option_override ( void ) { if ( avr_strict_X ) flag_caller_saves = <NUM_LIT> ; maybe_set_param_value ( PARAM_ALLOW_STORE_DATA_RACES , <NUM_LIT> , global_options . x_param_values , global_options_set . x_param_values ) ; if ( ( flag_unwind_tables || flag_non_call_exceptions || flag_asynchronous_unwind_tables ) && ! ACCUMULATE_OUTGOING_ARGS ) { flag_omit_frame_pointer = <NUM_LIT> ; } if ( flag_pic == <NUM_LIT> ) warning ( OPT_fpic , <STR_LIT> ) ; if ( flag_pic == <NUM_LIT> ) warning ( OPT_fPIC , <STR_LIT> ) ; if ( flag_pie == <NUM_LIT> ) warning ( OPT_fpie , <STR_LIT> ) ; if ( flag_pie == <NUM_LIT> ) warning ( OPT_fPIE , <STR_LIT> ) ; avr_gasisr_prologues = <NUM_LIT> ; if ( ! avr_set_core_architecture ( ) ) return ; avr_addr . sreg = <NUM_LIT> + avr_arch -> sfr_offset ;


<s> static void avr_option_override ( void ) { if ( avr_strict_X ) flag_caller_saves = <NUM_LIT> ; maybe_set_param_value ( PARAM_ALLOW_STORE_DATA_RACES , <NUM_LIT> , global_options . x_param_values , global_options_set . x_param_values ) ; if ( ( flag_unwind_tables || flag_non_call_exceptions || flag_asynchronous_unwind_tables ) && ! ACCUMULATE_OUTGOING_ARGS ) { flag_omit_frame_pointer = <NUM_LIT> ; } if ( flag_pic == <NUM_LIT> ) warning ( OPT_fpic , <STR_LIT> ) ; if ( flag_pic == <NUM_LIT> ) warning ( OPT_fPIC , <STR_LIT> ) ; if ( flag_pie == <NUM_LIT> ) warning ( OPT_fpie , <STR_LIT> ) ; if ( flag_pie == <NUM_LIT> ) warning ( OPT_fPIE , <STR_LIT> ) ; avr_gasisr_prologues = <NUM_LIT> ; if ( ! avr_set_core_architecture ( ) ) return ; avr_addr . sreg = <NUM_LIT> + avr_arch -> sfr_offset ; avr_addr . rampz = <NUM_LIT> + avr_arch -> sfr_offset ; avr_addr . rampy = <NUM_LIT> + avr_arch -> sfr_offset ;


out_shift_with_cnt ( <STR_LIT> CR_TAB <STR_LIT> , insn , operands , len , <NUM_LIT> ) ;


<s> * len = <NUM_LIT> ; return ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> ) ; case <NUM_LIT> : * len = <NUM_LIT> ; return ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> ) ; default : if ( INTVAL ( operands [ <NUM_LIT> ] ) < <NUM_LIT> ) break ; case <NUM_LIT> : * len = <NUM_LIT> ; return ( <STR_LIT> CR_TAB <STR_LIT> ) ; } } else if ( CONSTANT_P ( operands [ <NUM_LIT> ] ) ) fatal_insn ( <STR_LIT> , insn ) ; out_shift_with_cnt ( <STR_LIT> , insn , operands , len , <NUM_LIT> ) ;


<s> * len = <NUM_LIT> ; return ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> ) ; default : if ( INTVAL ( operands [ <NUM_LIT> ] ) < <NUM_LIT> ) break ; case <NUM_LIT> : * len = <NUM_LIT> ; return ( <STR_LIT> CR_TAB <STR_LIT> ) ; } } else if ( CONSTANT_P ( operands [ <NUM_LIT> ] ) ) fatal_insn ( <STR_LIT> , insn ) ;

out_shift_with_cnt ( <STR_LIT> , insn , operands , len , <NUM_LIT> ) ;


<s> if ( MEM_P ( dest ) && ( REG_P ( src ) || src == CONST0_RTX ( GET_MODE ( dest ) ) ) ) { return CONSTANT_ADDRESS_P ( XEXP ( dest , <NUM_LIT> ) ) ; } else if ( REG_P ( dest ) && MEM_P ( src ) ) {

return CONSTANT_ADDRESS_P ( XEXP ( src , <NUM_LIT> ) ) ;


<s> rtx set = single_set ( insn ) ; rtx src = SET_SRC ( set ) ; rtx dest = SET_DEST ( set ) ; if ( MEM_P ( dest ) && ( REG_P ( src ) || src == CONST0_RTX ( GET_MODE ( dest ) ) ) ) { return CONSTANT_ADDRESS_P ( XEXP ( dest , <NUM_LIT> ) ) ; } else if ( REG_P ( dest ) && MEM_P ( src ) ) { return CONSTANT_ADDRESS_P ( XEXP ( src , <NUM_LIT> ) ) ; } return false ; }


<s> int avr_accumulate_outgoing_args ( void ) { if ( ! cfun ) return TARGET_ACCUMULATE_OUTGOING_ARGS ; return ( TARGET_ACCUMULATE_OUTGOING_ARGS && ! ( cfun -> calls_setjmp || cfun -> has_nonlocal_label ) ) ;


<s> if ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) > MAX_LD_OFFSET ( mode ) ) cost = <NUM_LIT> ; } else if ( CONSTANT_ADDRESS_P ( x ) ) { if ( io_address_operand ( x , QImode ) ) cost = <NUM_LIT> ;

if ( AVR_TINY && avr_address_tiny_absdata_p ( x , QImode ) ) cost = <NUM_LIT> ;


<s> if ( CONST_INT_P ( x ) && IN_RANGE ( INTVAL ( x ) , <NUM_LIT> , <NUM_LIT> - GET_MODE_SIZE ( mode ) ) ) return true ;


<s> if ( CONST == GET_CODE ( x ) ) x = XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ;

if ( SYMBOL_REF_P ( x ) ) return SYMBOL_REF_FLAGS ( x ) & AVR_SYMBOL_FLAG_TINY_ABSDATA ;


<s> static bool avr_address_tiny_pm_p ( rtx x ) {

if ( CONST == GET_CODE ( x ) ) x = XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ;


<s> static bool avr_address_tiny_pm_p ( rtx x ) { if ( CONST == GET_CODE ( x ) ) x = XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ; if ( SYMBOL_REF_P ( x ) ) return SYMBOL_REF_FLAGS ( x ) & AVR_SYMBOL_FLAG_TINY_PM ; return false ;


<s> return avr_addrspace [ as ] . pointer_size == <NUM_LIT> ? PSImode : HImode ;


<s> rtx reg = gen_reg_rtx ( PSImode ) ; while ( CONST == GET_CODE ( sym ) || PLUS == GET_CODE ( sym ) ) sym = XEXP ( sym , <NUM_LIT> ) ; if ( SYMBOL_REF_P ( sym ) && ADDR_SPACE_FLASH == AVR_SYMBOL_GET_ADDR_SPACE ( sym ) ) { as_from = ADDR_SPACE_FLASH ; } msb = ADDR_SPACE_GENERIC_P ( as_from ) ? <NUM_LIT> : avr_addrspace [ as_from ] . segment ; src = force_reg ( Pmode , src ) ; emit_insn ( msb == <NUM_LIT> ? gen_zero_extendhipsi2 ( reg , src ) : gen_n_extendhipsi2 ( reg , gen_int_mode ( msb , QImode ) , src ) ) ; return reg ; } if ( as_from == ADDR_SPACE_MEMX && as_to != ADDR_SPACE_MEMX ) { rtx new_src = gen_reg_rtx ( Pmode ) ; src = force_reg ( PSImode , src ) ; emit_move_insn ( new_src , simplify_gen_subreg ( Pmode , src , PSImode , <NUM_LIT> ) ) ; return new_src ;


<s> static void avr_addr_space_diagnose_usage ( addr_space_t as , location_t loc ) { ( void ) avr_addr_space_supported_p ( as , loc ) ;


<s> } break ; case ADDR_SPACE_MEMX : if ( REG_P ( x ) ) ok = ( ! strict && can_create_pseudo_p ( ) ) ; if ( LO_SUM == GET_CODE ( x ) ) { rtx hi = XEXP ( x , <NUM_LIT> ) ; rtx lo = XEXP ( x , <NUM_LIT> ) ; ok = ( REG_P ( hi ) && ( ! strict || REGNO ( hi ) < FIRST_PSEUDO_REGISTER ) && REG_P ( lo ) && REGNO ( lo ) == REG_Z ) ; } break ; } if ( avr_log . legitimate_address_p ) { avr_edump ( <STR_LIT> <STR_LIT> , ok , mode , strict , reload_completed , reload_in_progress , reg_renumber ? <STR_LIT> : <STR_LIT> ) ; if ( GET_CODE ( x ) == PLUS && REG_P ( XEXP ( x , <NUM_LIT> ) ) && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) && IN_RANGE ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) , <NUM_LIT> , MAX_LD_OFFSET ( mode ) ) && reg_renumber ) { avr_edump ( <STR_LIT> , REGNO ( XEXP ( x , <NUM_LIT> ) ) , true_regnum ( XEXP ( x , <NUM_LIT> ) ) ) ; } avr_edump ( <STR_LIT> , x ) ;


<s> ok = ( REG_P ( hi ) && ( ! strict || REGNO ( hi ) < FIRST_PSEUDO_REGISTER ) && REG_P ( lo ) && REGNO ( lo ) == REG_Z ) ; } break ; } if ( avr_log . legitimate_address_p ) { avr_edump ( <STR_LIT> <STR_LIT> , ok , mode , strict , reload_completed , reload_in_progress , reg_renumber ? <STR_LIT> : <STR_LIT> ) ; if ( GET_CODE ( x ) == PLUS && REG_P ( XEXP ( x , <NUM_LIT> ) ) && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) && IN_RANGE ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) , <NUM_LIT> , MAX_LD_OFFSET ( mode ) ) && reg_renumber ) { avr_edump ( <STR_LIT> , REGNO ( XEXP ( x , <NUM_LIT> ) ) , true_regnum ( XEXP ( x , <NUM_LIT> ) ) ) ; } avr_edump ( <STR_LIT> , x ) ; } return ok ;


<s> static rtx avr_addr_space_legitimize_address ( rtx x , rtx old_x , machine_mode mode , addr_space_t as ) { if ( ADDR_SPACE_GENERIC_P ( as ) ) return avr_legitimize_address ( x , old_x , mode ) ; if ( avr_log . legitimize_address ) { avr_edump ( <STR_LIT> , mode , old_x ) ; }


<s> if ( ADDR_SPACE_GENERIC_P ( as ) ) return avr_legitimize_address ( x , old_x , mode ) ; if ( avr_log . legitimize_address ) { avr_edump ( <STR_LIT> , mode , old_x ) ;


<s> if ( loc != UNKNOWN_LOCATION ) error_at ( loc , <STR_LIT> <STR_LIT> , avr_addrspace [ as ] . name , <NUM_LIT> * avr_n_flash ) ;


<s> if ( loc != UNKNOWN_LOCATION ) error_at ( loc , <STR_LIT> <STR_LIT> ) ; return false ; } else if ( avr_addrspace [ as ] . segment >= avr_n_flash ) { if ( loc != UNKNOWN_LOCATION ) error_at ( loc , <STR_LIT> <STR_LIT> , avr_addrspace [ as ] . name , <NUM_LIT> * avr_n_flash ) ;


<s> case ADJUST_LEN_UFRACT : avr_out_fract ( insn , op , false , & len ) ; break ; case ADJUST_LEN_ROUND : avr_out_round ( insn , op , & len ) ; break ; case ADJUST_LEN_TSTHI : avr_out_tsthi ( insn , op , & len ) ; break ; case ADJUST_LEN_TSTPSI : avr_out_tstpsi ( insn , op , & len ) ; break ; case ADJUST_LEN_TSTSI : avr_out_tstsi ( insn , op , & len ) ; break ; case ADJUST_LEN_COMPARE : avr_out_compare ( insn , op , & len ) ; break ; case ADJUST_LEN_COMPARE64 : avr_out_compare64 ( insn , op , & len ) ; break ; case ADJUST_LEN_LSHRQI : lshrqi3_out ( insn , op , & len ) ; break ; case ADJUST_LEN_LSHRHI : lshrhi3_out ( insn , op , & len ) ; break ; case ADJUST_LEN_LSHRSI : lshrsi3_out ( insn , op , & len ) ; break ; case ADJUST_LEN_ASHRQI : ashrqi3_out ( insn , op , & len ) ; break ; case ADJUST_LEN_ASHRHI : ashrhi3_out ( insn , op , & len ) ; break ; case ADJUST_LEN_ASHRSI : ashrsi3_out ( insn , op , & len ) ; break ; case ADJUST_LEN_ASHLQI : ashlqi3_out ( insn , op , & len ) ; break ; case ADJUST_LEN_ASHLHI : ashlhi3_out ( insn , op , & len ) ; break ; case ADJUST_LEN_ASHLSI : ashlsi3_out ( insn , op , & len ) ; break ; case ADJUST_LEN_ASHLPSI : avr_out_ashlpsi3 ( insn , op , & len ) ; break ; case ADJUST_LEN_ASHRPSI : avr_out_ashrpsi3 ( insn , op , & len ) ; break ; case ADJUST_LEN_LSHRPSI : avr_out_lshrpsi3 ( insn , op , & len ) ; break ; case ADJUST_LEN_CALL : len = AVR_HAVE_JMP_CALL ? <NUM_LIT> : <NUM_LIT> ; break ; case ADJUST_LEN_INSERT_BITS : avr_out_insert_bits ( op , & len ) ; break ; case ADJUST_LEN_INSV_NOTBIT : avr_out_insert_notbit ( insn , op , NULL_RTX , & len ) ; break ; case ADJUST_LEN_INSV_NOTBIT_0 : avr_out_insert_notbit ( insn , op , const0_rtx , & len ) ; break ; case ADJUST_LEN_INSV_NOTBIT_7 : avr_out_insert_notbit ( insn , op , GEN_INT ( <NUM_LIT> ) , & len ) ; break ; default : gcc_unreachable ( ) ; }


<s> TYPE_SATURATING ( * node ) = sat_p ; TYPE_UNSIGNED ( * node ) = UNSIGNED_FIXED_POINT_MODE_P ( mode ) ; TYPE_IBIT ( * node ) = GET_MODE_IBIT ( mode ) ; TYPE_FBIT ( * node ) = GET_MODE_FBIT ( mode ) ; TYPE_PRECISION ( * node ) = GET_MODE_BITSIZE ( mode ) ;


<s> static bool avr_allocate_stack_slots_for_args ( void ) { return ! cfun -> machine -> is_naked ;


<s> void avr_asm_asm_output_aligned_bss ( FILE * file , tree decl , const char * name , unsigned HOST_WIDE_INT size , int align , void ( * default_func ) ( FILE * , tree , const char * , unsigned HOST_WIDE_INT , int ) ) { rtx mem = decl == NULL_TREE ? NULL_RTX : DECL_RTL ( decl ) ; rtx symbol ; if ( mem != NULL_RTX && MEM_P ( mem ) && SYMBOL_REF_P ( ( symbol = XEXP ( mem , <NUM_LIT> ) ) ) && ( SYMBOL_REF_FLAGS ( symbol ) & ( SYMBOL_FLAG_IO | SYMBOL_FLAG_ADDRESS ) ) ) { if ( ! ( SYMBOL_REF_FLAGS ( symbol ) & SYMBOL_FLAG_ADDRESS ) ) error_at ( DECL_SOURCE_LOCATION ( decl ) , <STR_LIT> , decl ) ; avr_asm_output_aligned_decl_common ( file , decl , name , size , align , false ) ;


<s> fprintf ( stream , <STR_LIT> , GASISR_Done , cfun -> machine -> gasisr . regno ) ;


<s> if ( cfun -> machine -> gasisr . yes && ! next_real_insn ( insn ) ) { app_disable ( ) ; fprintf ( stream , <STR_LIT> , GASISR_Done , cfun -> machine -> gasisr . regno ) ;


<s> app_disable ( ) ; fprintf ( file , <STR_LIT> ) ;


<s> static void avr_asm_function_begin_epilogue ( FILE * file ) {


<s> else { if ( cfun -> machine -> is_interrupt ) { fputs ( <STR_LIT> , file ) ; } else if ( cfun -> machine -> is_signal ) { fputs ( <STR_LIT> , file ) ; } else fputs ( <STR_LIT> , file ) ; } if ( ACCUMULATE_OUTGOING_ARGS ) fprintf ( file , <STR_LIT> , avr_outgoing_args_size ( ) ) ; fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , ( HOST_WIDE_INT ) get_frame_size ( ) ) ; if ( ! cfun -> machine -> gasisr . yes ) { fprintf ( file , <STR_LIT> , cfun -> machine -> stack_usage ) ; fprintf ( file , <STR_LIT> , cfun -> machine -> stack_usage ) ; } else {

int used_by_gasisr = <NUM_LIT> + ( cfun -> machine -> gasisr . regno != AVR_TMP_REGNO ) ;


<s> data_section -> unnamed . callback = avr_output_data_section_asm_op ; bss_section -> unnamed . callback = avr_output_bss_section_asm_op ;


<s> if ( plen == NULL ) output_asm_insn ( tpl , operands ) ; else {

if ( n_words < <NUM_LIT> ) * plen = - n_words ;


<s> static const char * avr_asm_len ( const char * tpl , rtx * operands , int * plen , int n_words ) { if ( plen == NULL ) output_asm_insn ( tpl , operands ) ; else {


<s> default_elf_asm_named_section ( sname , flags , decl ) ; return ; } default_elf_asm_named_section ( new_prefix , flags , decl ) ; return ; } if ( ! avr_need_copy_data_p ) avr_need_copy_data_p = ( startswith ( name , <STR_LIT> ) || startswith ( name , <STR_LIT> ) ) ;

if ( ! avr_need_copy_data_p && avr_arch -> flash_pm_offset == <NUM_LIT> ) avr_need_copy_data_p = ( startswith ( name , <STR_LIT> ) || startswith ( name , <STR_LIT> ) ) ;


<s> } else if ( local_p ) error_at ( DECL_SOURCE_LOCATION ( decl ) , <STR_LIT> , decl ) ; return ; } if ( ! startswith ( name , <STR_LIT> ) ) avr_need_clear_bss_p = true ; if ( local_p ) ASM_OUTPUT_ALIGNED_LOCAL ( stream , name , size , align ) ; else ASM_OUTPUT_ALIGNED_COMMON ( stream , name , size , align ) ;


<s> static void avr_asm_out_dtor ( rtx symbol , int priority ) { fputs ( <STR_LIT> , asm_out_file ) ;

default_dtor_section_asm_out_destructor ( symbol , priority ) ;


<s> fputs ( <STR_LIT> , asm_out_file ) ; default_dtor_section_asm_out_destructor ( symbol , priority ) ;


<s> return get_section ( sname , sect -> common . flags & ~ SECTION_DECLARED , sect -> named . decl ) ; } } if ( ! progmem_section [ as ] ) { progmem_section [ as ] = get_unnamed_section ( <NUM_LIT> , avr_output_progmem_section_asm_op , avr_addrspace [ as ] . section_name ) ; } return progmem_section [ as ] ; } return sect ;