<s> if ( avr_arch -> macro ) cpp_define_formatted ( pfile , <STR_LIT> , avr_arch -> macro ) ; if ( AVR_HAVE_RAMPD ) cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_HAVE_RAMPX ) cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_HAVE_RAMPY ) cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_HAVE_RAMPZ ) cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_HAVE_ELPM ) cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_HAVE_ELPMX ) cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_HAVE_MOVW ) cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_HAVE_LPMX ) cpp_define ( pfile , <STR_LIT> ) ; if ( avr_arch -> asm_only ) cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_HAVE_MUL ) { cpp_define ( pfile , <STR_LIT> ) ; cpp_define ( pfile , <STR_LIT> ) ; } if ( avr_arch -> have_jmp_call ) { cpp_define ( pfile , <STR_LIT> ) ; cpp_define ( pfile , <STR_LIT> ) ; } if ( AVR_XMEGA ) cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_TINY ) { cpp_define ( pfile , <STR_LIT> ) ; cpp_define ( pfile , <STR_LIT> ) ;


<s> gcc_assert ( i == avr_addrspace [ i ] . id ) ; if ( ! ADDR_SPACE_GENERIC_P ( i ) ) c_register_addr_space ( avr_addrspace [ i ] . name , avr_addrspace [ i ] . id ) ;


<s> void avr_register_target_pragmas ( void ) { int i ; gcc_assert ( ADDR_SPACE_GENERIC == ADDR_SPACE_RAM ) ; for ( i = <NUM_LIT> ; i < ADDR_SPACE_COUNT ; i ++ ) { gcc_assert ( i == avr_addrspace [ i ] . id ) ; if ( ! ADDR_SPACE_GENERIC_P ( i ) ) c_register_addr_space ( avr_addrspace [ i ] . name , avr_addrspace [ i ] . id ) ;


<s> case UHQmode : case USQmode : case UDQmode : case UHAmode : case USAmode : case UDAmode : case UTAmode : warning_at ( loc , <NUM_LIT> , <STR_LIT> , <STR_LIT> ) ; return args [ <NUM_LIT> ] ; default : error_at ( loc , <STR_LIT> , <STR_LIT> ) ; fold = error_mark_node ; break ; } fold = targetm . builtin_decl ( id , true ) ; if ( fold != error_mark_node ) fold = build_function_call_vec ( loc , vNULL , fold , & args , NULL ) ; break ; case AVR_BUILTIN_ROUNDFX : if ( args . length ( ) != <NUM_LIT> ) { error_at ( loc , <STR_LIT> , <STR_LIT> , ( int ) args . length ( ) ) ; fold = error_mark_node ; break ; } type0 = TREE_TYPE ( args [ <NUM_LIT> ] ) ; type1 = TREE_TYPE ( args [ <NUM_LIT> ] ) ; if ( ! FIXED_POINT_TYPE_P ( type0 ) ) { error_at ( loc , <STR_LIT> , <STR_LIT> ) ; fold = error_mark_node ; } if ( ! INTEGRAL_TYPE_P ( type1 ) ) { error_at ( loc , <STR_LIT> , <STR_LIT> ) ; fold = error_mark_node ; } switch ( TYPE_MODE ( type0 ) ) { case QQmode : id = AVR_BUILTIN_ROUNDHR ; break ; case HQmode : id = AVR_BUILTIN_ROUNDR ; break ; case SQmode : id = AVR_BUILTIN_ROUNDLR ; break ; case DQmode : id = AVR_BUILTIN_ROUNDLLR ; break ; case UQQmode : id = AVR_BUILTIN_ROUNDUHR ; break ; case UHQmode : id = AVR_BUILTIN_ROUNDUR ; break ; case USQmode : id = AVR_BUILTIN_ROUNDULR ; break ; case UDQmode : id = AVR_BUILTIN_ROUNDULLR ; break ; case HAmode : id = AVR_BUILTIN_ROUNDHK ; break ; case SAmode : id = AVR_BUILTIN_ROUNDK ; break ; case DAmode : id = AVR_BUILTIN_ROUNDLK ; break ; case TAmode : id = AVR_BUILTIN_ROUNDLLK ; break ; case UHAmode : id = AVR_BUILTIN_ROUNDUHK ; break ; case USAmode : id = AVR_BUILTIN_ROUNDUK ; break ; case UDAmode : id = AVR_BUILTIN_ROUNDULK ; break ; case UTAmode : id = AVR_BUILTIN_ROUNDULLK ; break ; default : error_at ( loc , <STR_LIT> , <STR_LIT> ) ; fold = error_mark_node ; break ;


<s> } else { cpp_define ( pfile , <STR_LIT> ) ; } if ( AVR_HAVE_8BIT_SP ) cpp_define ( pfile , <STR_LIT> ) ; else cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_HAVE_SPH ) cpp_define ( pfile , <STR_LIT> ) ; else cpp_define ( pfile , <STR_LIT> ) ; if ( TARGET_NO_INTERRUPTS ) cpp_define ( pfile , <STR_LIT> ) ; if ( TARGET_SKIP_BUG ) { cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_HAVE_JMP_CALL ) cpp_define ( pfile , <STR_LIT> ) ; } if ( TARGET_RMW ) cpp_define ( pfile , <STR_LIT> ) ; cpp_define_formatted ( pfile , <STR_LIT> , avr_arch -> sfr_offset ) ; cpp_define ( pfile , <STR_LIT> ) ; if ( lang_GNU_C ( ) ) {

for ( int i = <NUM_LIT> ; i < ADDR_SPACE_COUNT ; i ++ ) if ( ! ADDR_SPACE_GENERIC_P ( i ) && avr_addr_space_supported_p ( ( addr_space_t ) i ) ) {


<s> if ( AVR_HAVE_RAMPD ) cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_HAVE_RAMPX ) cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_HAVE_RAMPY ) cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_HAVE_RAMPZ ) cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_HAVE_ELPM ) cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_HAVE_ELPMX ) cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_HAVE_MOVW ) cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_HAVE_LPMX ) cpp_define ( pfile , <STR_LIT> ) ; if ( avr_arch -> asm_only ) cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_HAVE_MUL ) { cpp_define ( pfile , <STR_LIT> ) ; cpp_define ( pfile , <STR_LIT> ) ; } if ( AVR_HAVE_JMP_CALL ) cpp_define ( pfile , <STR_LIT> ) ; if ( avr_arch -> have_jmp_call ) cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_SHORT_CALLS ) cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_XMEGA ) cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_TINY ) { cpp_define ( pfile , <STR_LIT> ) ; cpp_define_formatted ( pfile , <STR_LIT> , avr_arch -> flash_pm_offset ) ; } if ( avr_arch -> flash_pm_offset ) cpp_define_formatted ( pfile , <STR_LIT> , avr_arch -> flash_pm_offset ) ; if ( AVR_HAVE_EIJMP_EICALL ) { cpp_define ( pfile , <STR_LIT> ) ; cpp_define ( pfile , <STR_LIT> ) ; } else { cpp_define ( pfile , <STR_LIT> ) ; } if ( AVR_HAVE_8BIT_SP ) cpp_define ( pfile , <STR_LIT> ) ; else cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_HAVE_SPH ) cpp_define ( pfile , <STR_LIT> ) ; else cpp_define ( pfile , <STR_LIT> ) ; if ( TARGET_NO_INTERRUPTS ) cpp_define ( pfile , <STR_LIT> ) ; if ( TARGET_SKIP_BUG ) { cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_HAVE_JMP_CALL ) cpp_define ( pfile , <STR_LIT> ) ; } if ( TARGET_RMW ) cpp_define ( pfile , <STR_LIT> ) ; cpp_define_formatted ( pfile , <STR_LIT> , avr_arch -> sfr_offset ) ; cpp_define ( pfile , <STR_LIT> ) ; if ( lang_GNU_C ( ) ) { for ( int i = <NUM_LIT> ; i < ADDR_SPACE_COUNT ; i ++ ) if ( ! ADDR_SPACE_GENERIC_P ( i ) && avr_addr_space_supported_p ( ( addr_space_t ) i ) ) { const char * name = avr_addrspace [ i ] . name ; char * Name = ( char * ) alloca ( <NUM_LIT> + strlen ( name ) ) ; cpp_define ( pfile , avr_toupper ( Name , name ) ) ; }


<s> fold = error_mark_node ; } switch ( TYPE_MODE ( type0 ) ) { case E_QQmode : id = AVR_BUILTIN_ROUNDHR ; break ; case E_HQmode : id = AVR_BUILTIN_ROUNDR ; break ; case E_SQmode : id = AVR_BUILTIN_ROUNDLR ; break ; case E_DQmode : id = AVR_BUILTIN_ROUNDLLR ; break ; case E_UQQmode : id = AVR_BUILTIN_ROUNDUHR ; break ; case E_UHQmode : id = AVR_BUILTIN_ROUNDUR ; break ; case E_USQmode : id = AVR_BUILTIN_ROUNDULR ; break ; case E_UDQmode : id = AVR_BUILTIN_ROUNDULLR ; break ; case E_HAmode : id = AVR_BUILTIN_ROUNDHK ; break ; case E_SAmode : id = AVR_BUILTIN_ROUNDK ; break ; case E_DAmode : id = AVR_BUILTIN_ROUNDLK ; break ; case E_TAmode : id = AVR_BUILTIN_ROUNDLLK ; break ; case E_UHAmode : id = AVR_BUILTIN_ROUNDUHK ; break ; case E_USAmode : id = AVR_BUILTIN_ROUNDUK ; break ; case E_UDAmode : id = AVR_BUILTIN_ROUNDULK ; break ; case E_UTAmode : id = AVR_BUILTIN_ROUNDULLK ; break ; default : error_at ( loc , <STR_LIT> , <STR_LIT> ) ; fold = error_mark_node ; break ; } fold = targetm . builtin_decl ( id , true ) ; if ( fold != error_mark_node ) fold = build_function_call_vec ( loc , vNULL , fold , & args , NULL ) ; break ; case AVR_BUILTIN_COUNTLSFX : if ( args . length ( ) != <NUM_LIT> ) { error_at ( loc , <STR_LIT> , <STR_LIT> , ( int ) args . length ( ) ) ; fold = error_mark_node ; break ; } type0 = TREE_TYPE ( args [ <NUM_LIT> ] ) ; if ( ! FIXED_POINT_TYPE_P ( type0 ) ) { error_at ( loc , <STR_LIT> , <STR_LIT> ) ; fold = error_mark_node ; } switch ( TYPE_MODE ( type0 ) ) { case E_QQmode : id = AVR_BUILTIN_COUNTLSHR ; break ; case E_HQmode : id = AVR_BUILTIN_COUNTLSR ; break ; case E_SQmode : id = AVR_BUILTIN_COUNTLSLR ; break ; case E_DQmode : id = AVR_BUILTIN_COUNTLSLLR ; break ; case E_UQQmode : id = AVR_BUILTIN_COUNTLSUHR ; break ; case E_UHQmode : id = AVR_BUILTIN_COUNTLSUR ; break ; case E_USQmode : id = AVR_BUILTIN_COUNTLSULR ; break ; case E_UDQmode : id = AVR_BUILTIN_COUNTLSULLR ; break ; case E_HAmode : id = AVR_BUILTIN_COUNTLSHK ; break ; case E_SAmode : id = AVR_BUILTIN_COUNTLSK ; break ; case E_DAmode : id = AVR_BUILTIN_COUNTLSLK ; break ; case E_TAmode : id = AVR_BUILTIN_COUNTLSLLK ; break ; case E_UHAmode : id = AVR_BUILTIN_COUNTLSUHK ; break ; case E_USAmode : id = AVR_BUILTIN_COUNTLSUK ; break ; case E_UDAmode : id = AVR_BUILTIN_COUNTLSULK ; break ; case E_UTAmode : id = AVR_BUILTIN_COUNTLSULLK ; break ; default : error_at ( loc , <STR_LIT> , <STR_LIT> ) ; fold = error_mark_node ; break ; }


<s> if ( avr_arch -> asm_only ) cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_HAVE_MUL ) { cpp_define ( pfile , <STR_LIT> ) ; cpp_define ( pfile , <STR_LIT> ) ; } if ( AVR_HAVE_JMP_CALL ) cpp_define ( pfile , <STR_LIT> ) ; if ( avr_arch -> have_jmp_call ) cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_SHORT_CALLS ) cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_XMEGA ) cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_TINY ) { cpp_define ( pfile , <STR_LIT> ) ; cpp_define_formatted ( pfile , <STR_LIT> , avr_arch -> flash_pm_offset ) ; } if ( avr_arch -> flash_pm_offset ) cpp_define_formatted ( pfile , <STR_LIT> , avr_arch -> flash_pm_offset ) ; if ( AVR_HAVE_EIJMP_EICALL ) { cpp_define ( pfile , <STR_LIT> ) ; cpp_define ( pfile , <STR_LIT> ) ; } else { cpp_define ( pfile , <STR_LIT> ) ; } if ( AVR_HAVE_8BIT_SP ) cpp_define ( pfile , <STR_LIT> ) ; else cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_HAVE_SPH ) cpp_define ( pfile , <STR_LIT> ) ; else cpp_define ( pfile , <STR_LIT> ) ; if ( TARGET_NO_INTERRUPTS ) cpp_define ( pfile , <STR_LIT> ) ; if ( TARGET_SKIP_BUG ) { cpp_define ( pfile , <STR_LIT> ) ; if ( AVR_HAVE_JMP_CALL ) cpp_define ( pfile , <STR_LIT> ) ; } if ( TARGET_RMW ) cpp_define ( pfile , <STR_LIT> ) ; cpp_define_formatted ( pfile , <STR_LIT> , avr_arch -> sfr_offset ) ; cpp_define ( pfile , <STR_LIT> ) ; cpp_define ( pfile , <STR_LIT> ) ;


<s> gcc_assert ( ADDR_SPACE_GENERIC == ADDR_SPACE_RAM ) ; for ( int i = <NUM_LIT> ; i < ADDR_SPACE_COUNT ; i ++ ) { gcc_assert ( i == avr_addrspace [ i ] . id ) ; if ( ! ADDR_SPACE_GENERIC_P ( i ) ) c_register_addr_space ( avr_addrspace [ i ] . name , avr_addrspace [ i ] . id ) ;


<s> char * up0 = up ; for ( ; * lo ; lo ++ , up ++ ) * up = TOUPPER ( * lo ) ;


<s> static char * avr_toupper ( char * up , const char * lo ) { char * up0 = up ;

for ( ; * lo ; lo ++ , up ++ ) * up = TOUPPER ( * lo ) ;


<s> void avr_inform_devices ( void ) { char * mcus = avr_mcus_str ( ) ;

inform ( input_location , <STR_LIT> , mcus ) ;


<s> for ( size_t i = <NUM_LIT> ; i < n_mcus ; i ++ ) mcus = concat ( mcus , <STR_LIT> , mcu_name [ i ] , NULL ) ; return mcus ;


<s> for ( size_t i = <NUM_LIT> ; i < n_mcus ; i ++ ) mcus = concat ( mcus , <STR_LIT> , mcu_name [ i ] , NULL ) ;


<s> const char * b = * ( const char * const * ) vb ; while ( * a && * b ) { if ( ISALPHA ( * a ) && ISDIGIT ( * b ) ) return - <NUM_LIT> ; if ( ISDIGIT ( * a ) && ISALPHA ( * b ) ) return <NUM_LIT> ; if ( * a != * b ) return * a - * b ;


<s> static char * avr_archs_str ( void ) { char * archs = concat ( <STR_LIT> , NULL ) ; for ( const avr_mcu_t * mcu = avr_mcu_types ; mcu -> name ; mcu ++ ) if ( ! mcu -> macro ) archs = concat ( archs , <STR_LIT> , avr_arch_types [ mcu -> arch_id ] . name , NULL ) ;


<s> inform ( input_location , <STR_LIT> , archs ) ; free ( archs ) ;


<s> bool all = TARGET_ALL_DEBUG != <NUM_LIT> ; if ( all ) avr_log_details = <STR_LIT> ; if ( all || avr_log_details ) { char * str = ( char * ) alloca ( <NUM_LIT> + strlen ( avr_log_details ) ) ; bool info ; str [ <NUM_LIT> ] = ',' ; strcat ( stpcpy ( str + <NUM_LIT> , avr_log_details ) , <STR_LIT> ) ;

all |= NULL != strstr ( str , <STR_LIT> ) ;


<s> strcat ( stpcpy ( str + <NUM_LIT> , avr_log_details ) , <STR_LIT> ) ; all |= NULL != strstr ( str , <STR_LIT> ) ; info = NULL != strstr ( str , <STR_LIT> ) ; if ( info ) fprintf ( stderr , <STR_LIT> ) ;

do { \ avr_log . S = ( all || NULL != strstr ( str , <STR_LIT> # S <STR_LIT> ) ) ; \ if ( info ) \ fprintf ( stderr , # S <STR_LIT> ) ; \ } while ( <NUM_LIT> ) SET_DUMP_DETAIL ( address_cost ) ;


<s> } case 'T' : print_node_brief ( file , <STR_LIT> , va_arg ( ap , tree ) , <NUM_LIT> ) ; break ; case 'd' : fprintf ( file , <STR_LIT> , va_arg ( ap , int ) ) ; break ; case 'x' : fprintf ( file , <STR_LIT> , va_arg ( ap , int ) ) ; break ; case 'b' : fprintf ( file , <STR_LIT> , va_arg ( ap , int ) ? <STR_LIT> : <STR_LIT> ) ; break ; case 'c' : fputc ( va_arg ( ap , int ) , file ) ; break ; case 'r' : print_inline_rtx ( file , va_arg ( ap , rtx ) , <NUM_LIT> ) ; break ; case 'L' : { rtx_insn * insn = safe_as_a < rtx_insn * > ( va_arg ( ap , rtx ) ) ; while ( insn ) { print_inline_rtx ( file , insn , <NUM_LIT> ) ; fprintf ( file , <STR_LIT> ) ; insn = NEXT_INSN ( insn ) ; } break ; } case 'f' : if ( cfun && cfun -> decl ) fputs ( current_function_name ( ) , file ) ; break ; case 's' : { const char * str = va_arg ( ap , char * ) ; fputs ( str ? str : <STR_LIT> , file ) ; } break ; case 'm' : fputs ( GET_MODE_NAME ( ( machine_mode ) va_arg ( ap , int ) ) , file ) ; break ; case 'C' : fputs ( rtx_name [ va_arg ( ap , int ) ] , file ) ; break ; case 'R' : fputs ( reg_class_names [ va_arg ( ap , int ) ] , file ) ; break ; case 'F' : fputs ( caller , file ) ; break ; case 'H' : { location_t loc = va_arg ( ap , location_t ) ; if ( BUILTINS_LOCATION == loc ) fprintf ( file , <STR_LIT> ) ; else if ( UNKNOWN_LOCATION == loc ) fprintf ( file , <STR_LIT> ) ; else fprintf ( file , <STR_LIT> , LOCATION_FILE ( loc ) , LOCATION_LINE ( loc ) ) ; break ;


<s> va_start ( ap , caller ) ; if ( stream ) avr_log_vadump ( stream , caller , ap ) ; va_end ( ap ) ; return <NUM_LIT> ;


<s> info = strstr ( str , <STR_LIT> ) != NULL ; if ( info ) fprintf ( stderr , <STR_LIT> ) ; do { \ avr_log . S = ( all || strstr ( str , <STR_LIT> # S <STR_LIT> ) != NULL ) ; \ if ( info ) \ fprintf ( stderr , # S <STR_LIT> ) ; \ } while ( <NUM_LIT> ) SET_DUMP_DETAIL ( address_cost ) ; SET_DUMP_DETAIL ( builtin ) ; SET_DUMP_DETAIL ( constraints ) ; SET_DUMP_DETAIL ( insn_addresses ) ; SET_DUMP_DETAIL ( legitimate_address_p ) ; SET_DUMP_DETAIL ( legitimize_address ) ; SET_DUMP_DETAIL ( legitimize_reload_address ) ; SET_DUMP_DETAIL ( progmem ) ; SET_DUMP_DETAIL ( rtx_costs ) ; if ( info ) fprintf ( stderr , <STR_LIT> ) ; }


<s> switch ( * fmt ++ ) { case '%' : fputc ( '%' , file ) ; break ; case 't' : { tree t = va_arg ( ap , tree ) ; if ( NULL_TREE == t ) fprintf ( file , <STR_LIT> ) ; else { if ( stderr == file ) debug_tree ( t ) ; else { print_node ( file , <STR_LIT> , t , <NUM_LIT> ) ; putc ( '\n' , file ) ; } } break ; } case 'T' : { tree t = va_arg ( ap , tree ) ; if ( NULL_TREE == t ) fprintf ( file , <STR_LIT> ) ; else print_node_brief ( file , <STR_LIT> , t , <NUM_LIT> ) ; } break ; case 'd' : fprintf ( file , <STR_LIT> , va_arg ( ap , int ) ) ; break ; case 'x' : fprintf ( file , <STR_LIT> , va_arg ( ap , int ) ) ; break ; case 'b' : fprintf ( file , <STR_LIT> , va_arg ( ap , int ) ? <STR_LIT> : <STR_LIT> ) ; break ; case 'c' : fputc ( va_arg ( ap , int ) , file ) ; break ; case 'r' : print_inline_rtx ( file , va_arg ( ap , rtx ) , <NUM_LIT> ) ; break ; case 'L' : { rtx_insn * insn = safe_as_a < rtx_insn * > ( va_arg ( ap , rtx ) ) ; while ( insn ) { print_inline_rtx ( file , insn , <NUM_LIT> ) ; fprintf ( file , <STR_LIT> ) ; insn = NEXT_INSN ( insn ) ; } break ; } case 'f' : if ( cfun && cfun -> decl ) fputs ( current_function_name ( ) , file ) ; break ; case 's' : { const char * str = va_arg ( ap , char * ) ; fputs ( str ? str : <STR_LIT> , file ) ; } break ; case 'm' : fputs ( GET_MODE_NAME ( ( machine_mode ) va_arg ( ap , int ) ) , file ) ; break ; case 'C' : fputs ( rtx_name [ va_arg ( ap , int ) ] , file ) ; break ; case 'R' : fputs ( reg_class_names [ va_arg ( ap , int ) ] , file ) ; break ; case 'F' : fputs ( caller , file ) ; break ; case 'H' :


<s> va_list ap ; if ( stream == NULL && dump_file ) stream = dump_file ;


<s> static inline unsigned regmask ( machine_mode mode , unsigned regno ) { return ( ( <NUM_LIT> << GET_MODE_SIZE ( mode ) ) - <NUM_LIT> ) << regno ;


<s> static inline unsigned regmask ( machine_mode mode , unsigned regno ) { return ( ( <NUM_LIT> << GET_MODE_SIZE ( as_a < fixed_size_mode > ( mode ) ) ) - <NUM_LIT> ) << regno ;


<s> tmp_reg_rtx = xmalloc ( sizeof ( struct rtx_def ) + <NUM_LIT> * sizeof ( rtunion ) ) ; memset ( tmp_reg_rtx , <NUM_LIT> , sizeof ( struct rtx_def ) + <NUM_LIT> * sizeof ( rtunion ) ) ; PUT_CODE ( tmp_reg_rtx , REG ) ; PUT_MODE ( tmp_reg_rtx , QImode ) ; XINT ( tmp_reg_rtx , <NUM_LIT> ) = TMP_REGNO ; zero_reg_rtx = xmalloc ( sizeof ( struct rtx_def ) + <NUM_LIT> * sizeof ( rtunion ) ) ; memset ( zero_reg_rtx , <NUM_LIT> , sizeof ( struct rtx_def ) + <NUM_LIT> * sizeof ( rtunion ) ) ; PUT_CODE ( zero_reg_rtx , REG ) ; PUT_MODE ( zero_reg_rtx , QImode ) ; XINT ( zero_reg_rtx , <NUM_LIT> ) = ZERO_REGNO ; ldi_reg_rtx = xmalloc ( sizeof ( struct rtx_def ) + <NUM_LIT> * sizeof ( rtunion ) ) ; memset ( ldi_reg_rtx , <NUM_LIT> , sizeof ( struct rtx_def ) + <NUM_LIT> * sizeof ( rtunion ) ) ; PUT_CODE ( ldi_reg_rtx , REG ) ; PUT_MODE ( ldi_reg_rtx , QImode ) ; XINT ( ldi_reg_rtx , <NUM_LIT> ) = LDI_REG_REGNO ;


<s> PUT_MODE ( zero_reg_rtx , QImode ) ; XINT ( zero_reg_rtx , <NUM_LIT> ) = ZERO_REGNO ; ldi_reg_rtx = xmalloc ( sizeof ( struct rtx_def ) + <NUM_LIT> * sizeof ( rtunion ) ) ; memset ( ldi_reg_rtx , <NUM_LIT> , sizeof ( struct rtx_def ) + <NUM_LIT> * sizeof ( rtunion ) ) ;


<s> fprintf ( stderr , <STR_LIT> , avr_mcu_name ) ; for ( t = avr_mcu_types ; t -> name ; t ++ ) fprintf ( stderr , <STR_LIT> , t -> name ) ; } switch ( t -> arch ) { case AVR1 : default : error ( <STR_LIT> , avr_mcu_name ) ; case AVR2 : avr_enhanced_p = <NUM_LIT> ; avr_mega_p = <NUM_LIT> ; break ; case AVR3 : avr_enhanced_p = <NUM_LIT> ; avr_mega_p = <NUM_LIT> ; break ; case AVR4 : avr_enhanced_p = <NUM_LIT> ; avr_mega_p = <NUM_LIT> ; break ; case AVR5 : avr_enhanced_p = <NUM_LIT> ; avr_mega_p = <NUM_LIT> ; break ; } if ( optimize && ! TARGET_NO_TABLEJUMP ) avr_case_values_threshold = ( ! AVR_MEGA || TARGET_CALL_PROLOGUES ) ? <NUM_LIT> : <NUM_LIT> ;


<s> switch ( t -> arch ) { case AVR1 : default : error ( <STR_LIT> , avr_mcu_name ) ; case AVR2 : avr_enhanced_p = <NUM_LIT> ; avr_mega_p = <NUM_LIT> ; break ; case AVR3 : avr_enhanced_p = <NUM_LIT> ; avr_mega_p = <NUM_LIT> ; break ; case AVR4 : avr_enhanced_p = <NUM_LIT> ; avr_mega_p = <NUM_LIT> ; break ; case AVR5 : avr_enhanced_p = <NUM_LIT> ; avr_mega_p = <NUM_LIT> ; break ; } if ( optimize && ! TARGET_NO_TABLEJUMP ) avr_case_values_threshold = ( ! AVR_MEGA || TARGET_CALL_PROLOGUES ) ? <NUM_LIT> : <NUM_LIT> ;


<s> return ( current_function_calls_alloca || current_function_args_info . nregs == <NUM_LIT> || current_function_varargs || get_frame_size ( ) > <NUM_LIT> ) ;


<s> void order_regs_for_local_alloc ( ) { unsigned int i ; static const int order_0 [ ] = {


<s> } else cur_seq = <NUM_LIT> ; } } if ( ! frame_pointer_needed ) { if ( regs_ever_live [ REG_Y ] ) { ++ live_seq ; ++ cur_seq ; } else cur_seq = <NUM_LIT> ; if ( regs_ever_live [ REG_Y + <NUM_LIT> ] ) { ++ live_seq ; ++ cur_seq ; } else cur_seq = <NUM_LIT> ; } else { cur_seq += <NUM_LIT> ; live_seq += <NUM_LIT> ; }


<s> } } else if ( GET_CODE ( op [ <NUM_LIT> ] ) == ASHIFT || GET_CODE ( op [ <NUM_LIT> ] ) == ASHIFTRT || GET_CODE ( op [ <NUM_LIT> ] ) == LSHIFTRT ) { rtx ops [ <NUM_LIT> ] ; ops [ <NUM_LIT> ] = op [ <NUM_LIT> ] ; ops [ <NUM_LIT> ] = XEXP ( op [ <NUM_LIT> ] , <NUM_LIT> ) ; ops [ <NUM_LIT> ] = XEXP ( op [ <NUM_LIT> ] , <NUM_LIT> ) ; switch ( GET_CODE ( op [ <NUM_LIT> ] ) ) { case ASHIFT : switch ( GET_MODE ( op [ <NUM_LIT> ] ) ) { case QImode : ashlqi3_out ( insn , ops , & len ) ; break ; case HImode : ashlhi3_out ( insn , ops , & len ) ; break ; case SImode : ashlsi3_out ( insn , ops , & len ) ; break ; default : break ; } break ; case ASHIFTRT : switch ( GET_MODE ( op [ <NUM_LIT> ] ) ) { case QImode : ashrqi3_out ( insn , ops , & len ) ; break ; case HImode : ashrhi3_out ( insn , ops , & len ) ; break ; case SImode : ashrsi3_out ( insn , ops , & len ) ; break ; default : break ; } break ; case LSHIFTRT : switch ( GET_MODE ( op [ <NUM_LIT> ] ) ) { case QImode : lshrqi3_out ( insn , ops , & len ) ; break ; case HImode : lshrhi3_out ( insn , ops , & len ) ; break ; case SImode : lshrsi3_out ( insn , ops , & len ) ; break ; default : break ; } break ; default : break ; }


<s> case <NUM_LIT> : * len = <NUM_LIT> ; return ( AS2 ( mov , % B0 , % A0 ) CR_TAB AS1 ( clr , % A0 ) CR_TAB AS1 ( lsl , % B0 ) CR_TAB AS1 ( lsl , % B0 ) ) ; case <NUM_LIT> : * len = <NUM_LIT> ; return ( AS2 ( mov , % B0 , % A0 ) CR_TAB AS1 ( clr , % A0 ) CR_TAB AS1 ( lsl , % B0 ) CR_TAB AS1 ( lsl , % B0 ) CR_TAB AS1 ( lsl , % B0 ) ) ; case <NUM_LIT> : if ( ldi_ok ) { * len = <NUM_LIT> ; return ( AS2 ( mov , % B0 , % A0 ) CR_TAB AS1 ( clr , % A0 ) CR_TAB AS1 ( swap , % B0 ) CR_TAB AS2 ( andi , % B0 , <NUM_LIT> ) ) ; } if ( scratch ) { * len = <NUM_LIT> ; return ( AS2 ( mov , % B0 , % A0 ) CR_TAB AS1 ( clr , % A0 ) CR_TAB AS1 ( swap , % B0 ) CR_TAB AS2 ( ldi , % <NUM_LIT> , <NUM_LIT> ) CR_TAB AS2 ( and , % B0 , % <NUM_LIT> ) ) ; } * len = <NUM_LIT> ; return ( AS2 ( mov , % B0 , % A0 ) CR_TAB AS1 ( clr , % A0 ) CR_TAB AS1 ( lsl , % B0 ) CR_TAB AS1 ( lsl , % B0 ) CR_TAB AS1 ( lsl , % B0 ) CR_TAB AS1 ( lsl , % B0 ) ) ; case <NUM_LIT> : if ( ldi_ok ) { * len = <NUM_LIT> ; return ( AS2 ( mov , % B0 , % A0 ) CR_TAB AS1 ( clr , % A0 ) CR_TAB AS1 ( swap , % B0 ) CR_TAB AS1 ( lsl , % B0 ) CR_TAB AS2 ( andi , % B0 , <NUM_LIT> ) ) ; } if ( AVR_ENHANCED && scratch ) { * len = <NUM_LIT> ; return ( AS2 ( ldi , % <NUM_LIT> , <NUM_LIT> ) CR_TAB AS2 ( mul , % A0 , % <NUM_LIT> ) CR_TAB AS2 ( mov , % B0 , r0 ) CR_TAB AS1 ( clr , % A0 ) CR_TAB AS1 ( clr , __zero_reg__ ) ) ; } if ( optimize_size && scratch ) break ; if ( scratch ) { * len = <NUM_LIT> ; return ( AS2 ( mov , % B0 , % A0 ) CR_TAB AS1 ( clr , % A0 ) CR_TAB AS1 ( swap , % B0 ) CR_TAB AS1 ( lsl , % B0 ) CR_TAB AS2 ( ldi , % <NUM_LIT> , <NUM_LIT> ) CR_TAB AS2 ( and , % B0 , % <NUM_LIT> ) ) ; } if ( AVR_ENHANCED ) { * len = <NUM_LIT> ;


<s> } * len = <NUM_LIT> ; return ( AS1 ( lsl , % <NUM_LIT> ) CR_TAB AS1 ( lsl , % <NUM_LIT> ) CR_TAB AS1 ( lsl , % <NUM_LIT> ) CR_TAB AS1 ( lsl , % <NUM_LIT> ) CR_TAB AS1 ( lsl , % <NUM_LIT> ) ) ; case <NUM_LIT> : if ( test_hard_reg_class ( LD_REGS , operands [ <NUM_LIT> ] ) ) { * len = <NUM_LIT> ; return ( AS1 ( swap , % <NUM_LIT> ) CR_TAB AS1 ( lsl , % <NUM_LIT> ) CR_TAB AS1 ( lsl , % <NUM_LIT> ) CR_TAB AS2 ( andi , % <NUM_LIT> , <NUM_LIT> ) ) ; } * len = <NUM_LIT> ; return ( AS1 ( lsl , % <NUM_LIT> ) CR_TAB AS1 ( lsl , % <NUM_LIT> ) CR_TAB AS1 ( lsl , % <NUM_LIT> ) CR_TAB AS1 ( lsl , % <NUM_LIT> ) CR_TAB AS1 ( lsl , % <NUM_LIT> ) CR_TAB AS1 ( lsl , % <NUM_LIT> ) ) ; case <NUM_LIT> : * len = <NUM_LIT> ; return ( AS1 ( ror , % <NUM_LIT> ) CR_TAB AS1 ( clr , % <NUM_LIT> ) CR_TAB AS1 ( ror , % <NUM_LIT> ) ) ; } } else if ( CONSTANT_P ( operands [ <NUM_LIT> ] ) ) fatal_insn ( <STR_LIT> , insn ) ;

out_shift_with_cnt ( AS1 ( lsl , % <NUM_LIT> ) , insn , operands , len , <NUM_LIT> ) ;


<s> int reg0 = true_regnum ( operands [ <NUM_LIT> ] ) ; int reg1 = true_regnum ( operands [ <NUM_LIT> ] ) ; * len = <NUM_LIT> ; if ( AVR_ENHANCED && ( reg0 + <NUM_LIT> != reg1 ) ) { * len = <NUM_LIT> ; return ( AS2 ( movw , % C0 , % A1 ) CR_TAB AS1 ( clr , % B0 ) CR_TAB AS1 ( clr , % A0 ) ) ; } if ( reg0 + <NUM_LIT> >= reg1 ) return ( AS2 ( mov , % D0 , % B1 ) CR_TAB AS2 ( mov , % C0 , % A1 ) CR_TAB AS1 ( clr , % B0 ) CR_TAB AS1 ( clr , % A0 ) ) ; if ( reg0 + <NUM_LIT> == reg1 ) { * len = <NUM_LIT> ; return ( AS1 ( clr , % B0 ) CR_TAB AS1 ( clr , % A0 ) ) ; } else return ( AS2 ( mov , % C0 , % A1 ) CR_TAB AS2 ( mov , % D0 , % B1 ) CR_TAB AS1 ( clr , % B0 ) CR_TAB AS1 ( clr , % A0 ) ) ; } case <NUM_LIT> : * len = <NUM_LIT> ; if ( true_regnum ( operands [ <NUM_LIT> ] ) + <NUM_LIT> != true_regnum ( operands [ <NUM_LIT> ] ) ) return ( AS2 ( mov , % D0 , % A1 ) CR_TAB AS1 ( clr , % C0 ) CR_TAB AS1 ( clr , % B0 ) CR_TAB AS1 ( clr , % A0 ) ) ; else {


<s> return ( AS2 ( ldi , % A0 , <NUM_LIT> ) CR_TAB AS2 ( muls , % B0 , % A0 ) CR_TAB AS2 ( mov , % A0 , r1 ) CR_TAB AS2 ( sbc , % B0 , % B0 ) CR_TAB AS1 ( clr , __zero_reg__ ) ) ; } if ( optimize_size && scratch ) break ; * len = <NUM_LIT> ; return ( AS2 ( mov , % A0 , % B0 ) CR_TAB AS1 ( lsl , % B0 ) CR_TAB AS2 ( sbc , % B0 , % B0 ) CR_TAB AS1 ( asr , % A0 ) CR_TAB AS1 ( asr , % A0 ) CR_TAB AS1 ( asr , % A0 ) CR_TAB AS1 ( asr , % A0 ) ) ; case <NUM_LIT> : if ( AVR_ENHANCED && ldi_ok ) { * len = <NUM_LIT> ; return ( AS2 ( ldi , % A0 , <NUM_LIT> ) CR_TAB AS2 ( muls , % B0 , % A0 ) CR_TAB AS2 ( mov , % A0 , r1 ) CR_TAB AS2 ( sbc , % B0 , % B0 ) CR_TAB AS1 ( clr , __zero_reg__ ) ) ; } if ( optimize_size ) break ; * len = <NUM_LIT> ; return ( AS2 ( mov , % A0 , % B0 ) CR_TAB AS1 ( lsl , % B0 ) CR_TAB AS2 ( sbc , % B0 , % B0 ) CR_TAB AS1 ( asr , % A0 ) CR_TAB AS1 ( asr , % A0 ) CR_TAB AS1 ( asr , % A0 ) CR_TAB AS1 ( asr , % A0 ) CR_TAB AS1 ( asr , % A0 ) ) ; case <NUM_LIT> : * len = <NUM_LIT> ; return ( AS1 ( lsl , % B0 ) CR_TAB AS2 ( sbc , % A0 , % A0 ) CR_TAB AS1 ( lsl , % B0 ) CR_TAB AS2 ( mov , % B0 , % A0 ) CR_TAB AS1 ( rol , % A0 ) ) ; default : if ( INTVAL ( operands [ <NUM_LIT> ] ) < <NUM_LIT> ) break ;


<s> * len = <NUM_LIT> ; return ( AS2 ( mov , % A0 , % B0 ) CR_TAB AS1 ( lsl , % B0 ) CR_TAB AS2 ( sbc , % B0 , % B0 ) CR_TAB AS1 ( asr , % A0 ) CR_TAB AS1 ( asr , % A0 ) CR_TAB AS1 ( asr , % A0 ) ) ; case <NUM_LIT> : if ( AVR_ENHANCED && ldi_ok ) { * len = <NUM_LIT> ; return ( AS2 ( ldi , % A0 , <NUM_LIT> ) CR_TAB AS2 ( muls , % B0 , % A0 ) CR_TAB AS2 ( mov , % A0 , r1 ) CR_TAB AS2 ( sbc , % B0 , % B0 ) CR_TAB AS1 ( clr , __zero_reg__ ) ) ; } if ( optimize_size && scratch ) break ; * len = <NUM_LIT> ; return ( AS2 ( mov , % A0 , % B0 ) CR_TAB AS1 ( lsl , % B0 ) CR_TAB AS2 ( sbc , % B0 , % B0 ) CR_TAB AS1 ( asr , % A0 ) CR_TAB AS1 ( asr , % A0 ) CR_TAB AS1 ( asr , % A0 ) CR_TAB AS1 ( asr , % A0 ) ) ; case <NUM_LIT> : if ( AVR_ENHANCED && ldi_ok ) { * len = <NUM_LIT> ; return ( AS2 ( ldi , % A0 , <NUM_LIT> ) CR_TAB AS2 ( muls , % B0 , % A0 ) CR_TAB AS2 ( mov , % A0 , r1 ) CR_TAB AS2 ( sbc , % B0 , % B0 ) CR_TAB AS1 ( clr , __zero_reg__ ) ) ; } if ( optimize_size ) break ; * len = <NUM_LIT> ; return ( AS2 ( mov , % A0 , % B0 ) CR_TAB AS1 ( lsl , % B0 ) CR_TAB AS2 ( sbc , % B0 , % B0 ) CR_TAB AS1 ( asr , % A0 ) CR_TAB AS1 ( asr , % A0 ) CR_TAB AS1 ( asr , % A0 ) CR_TAB AS1 ( asr , % A0 ) CR_TAB AS1 ( asr , % A0 ) ) ;


<s> if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT ) { int k ; if ( ! len ) len = & k ; switch ( INTVAL ( operands [ <NUM_LIT> ] ) ) { case <NUM_LIT> : * len = <NUM_LIT> ; return AS1 ( asr , % <NUM_LIT> ) ; case <NUM_LIT> : * len = <NUM_LIT> ; return ( AS1 ( asr , % <NUM_LIT> ) CR_TAB AS1 ( asr , % <NUM_LIT> ) ) ; case <NUM_LIT> : * len = <NUM_LIT> ; return ( AS1 ( asr , % <NUM_LIT> ) CR_TAB AS1 ( asr , % <NUM_LIT> ) CR_TAB AS1 ( asr , % <NUM_LIT> ) ) ; case <NUM_LIT> : * len = <NUM_LIT> ; return ( AS1 ( asr , % <NUM_LIT> ) CR_TAB AS1 ( asr , % <NUM_LIT> ) CR_TAB AS1 ( asr , % <NUM_LIT> ) CR_TAB AS1 ( asr , % <NUM_LIT> ) ) ; case <NUM_LIT> : * len = <NUM_LIT> ; return ( AS1 ( asr , % <NUM_LIT> ) CR_TAB AS1 ( asr , % <NUM_LIT> ) CR_TAB AS1 ( asr , % <NUM_LIT> ) CR_TAB AS1 ( asr , % <NUM_LIT> ) CR_TAB AS1 ( asr , % <NUM_LIT> ) ) ; case <NUM_LIT> : * len = <NUM_LIT> ; return ( AS2 ( bst , % <NUM_LIT> , <NUM_LIT> ) CR_TAB AS1 ( lsl , % <NUM_LIT> ) CR_TAB AS2 ( sbc , % <NUM_LIT> , % <NUM_LIT> ) CR_TAB AS2 ( bld , % <NUM_LIT> , <NUM_LIT> ) ) ; default : if ( INTVAL ( operands [ <NUM_LIT> ] ) < <NUM_LIT> ) break ; case <NUM_LIT> : * len = <NUM_LIT> ; return ( AS1 ( lsl , % <NUM_LIT> ) CR_TAB AS2 ( sbc , % <NUM_LIT> , % <NUM_LIT> ) ) ; } }

else if ( CONSTANT_P ( operands [ <NUM_LIT> ] ) ) fatal_insn ( <STR_LIT> , insn ) ;


<s> return ( AS1 ( asr , % <NUM_LIT> ) CR_TAB AS1 ( asr , % <NUM_LIT> ) CR_TAB AS1 ( asr , % <NUM_LIT> ) CR_TAB AS1 ( asr , % <NUM_LIT> ) ) ; case <NUM_LIT> : * len = <NUM_LIT> ; return ( AS1 ( asr , % <NUM_LIT> ) CR_TAB AS1 ( asr , % <NUM_LIT> ) CR_TAB AS1 ( asr , % <NUM_LIT> ) CR_TAB AS1 ( asr , % <NUM_LIT> ) CR_TAB AS1 ( asr , % <NUM_LIT> ) ) ; case <NUM_LIT> : * len = <NUM_LIT> ; return ( AS2 ( bst , % <NUM_LIT> , <NUM_LIT> ) CR_TAB AS1 ( lsl , % <NUM_LIT> ) CR_TAB AS2 ( sbc , % <NUM_LIT> , % <NUM_LIT> ) CR_TAB AS2 ( bld , % <NUM_LIT> , <NUM_LIT> ) ) ; default : if ( INTVAL ( operands [ <NUM_LIT> ] ) < <NUM_LIT> ) break ; case <NUM_LIT> : * len = <NUM_LIT> ;

return ( AS1 ( lsl , % <NUM_LIT> ) CR_TAB AS2 ( sbc , % <NUM_LIT> , % <NUM_LIT> ) ) ;


<s> * len = <NUM_LIT> ; return ( AS1 ( clr , % D0 ) CR_TAB AS2 ( sbrc , % C0 , <NUM_LIT> ) CR_TAB AS1 ( dec , % D0 ) ) ; } else return ( AS1 ( clr , % D0 ) CR_TAB AS2 ( sbrc , % D1 , <NUM_LIT> ) CR_TAB AS1 ( dec , % D0 ) CR_TAB AS2 ( mov , % C0 , % D1 ) CR_TAB AS2 ( mov , % B0 , % C1 ) CR_TAB AS2 ( mov , % A0 , % B1 ) ) ; } case <NUM_LIT> : { int reg0 = true_regnum ( operands [ <NUM_LIT> ] ) ; int reg1 = true_regnum ( operands [ <NUM_LIT> ] ) ; * len = <NUM_LIT> ; if ( AVR_ENHANCED && ( reg0 != reg1 + <NUM_LIT> ) ) { * len = <NUM_LIT> ; return ( AS2 ( movw , % A0 , % C1 ) CR_TAB AS1 ( clr , % D0 ) CR_TAB AS2 ( sbrc , % B0 , <NUM_LIT> ) CR_TAB AS1 ( com , % D0 ) CR_TAB AS2 ( mov , % C0 , % D0 ) ) ; } if ( reg0 <= reg1 + <NUM_LIT> ) return ( AS2 ( mov , % A0 , % C1 ) CR_TAB AS2 ( mov , % B0 , % D1 ) CR_TAB AS1 ( clr , % D0 ) CR_TAB AS2 ( sbrc , % B0 , <NUM_LIT> ) CR_TAB AS1 ( com , % D0 ) CR_TAB AS2 ( mov , % C0 , % D0 ) ) ; else if ( reg0 == reg1 + <NUM_LIT> ) return * len = <NUM_LIT> , ( AS1 ( clr , % D0 ) CR_TAB AS2 ( sbrc , % B0 , <NUM_LIT> ) CR_TAB AS1 ( com , % D0 ) CR_TAB AS2 ( mov , % C0 , % D0 ) ) ;

else return ( AS2 ( mov , % B0 , % D1 ) CR_TAB AS2 ( mov , % A0 , % C1 ) CR_TAB AS1 ( clr , % D0 ) CR_TAB AS2 ( sbrc , % B0 , <NUM_LIT> ) CR_TAB AS1 ( com , % D0 ) CR_TAB AS2 ( mov , % C0 , % D0 ) ) ;


<s> static int avr_address_cost ( rtx x ) { if ( GET_CODE ( x ) == PLUS && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT && ( REG_P ( XEXP ( x , <NUM_LIT> ) ) || GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == SUBREG ) && INTVAL ( XEXP ( x , <NUM_LIT> ) ) >= <NUM_LIT> ) return <NUM_LIT> ; if ( CONSTANT_ADDRESS_P ( x ) ) { if ( avr_io_address_p ( x , <NUM_LIT> ) ) return <NUM_LIT> ; return <NUM_LIT> ; } return <NUM_LIT> ;


<s> if ( GET_CODE ( x ) == PLUS && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT && ( REG_P ( XEXP ( x , <NUM_LIT> ) ) || GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == SUBREG ) && INTVAL ( XEXP ( x , <NUM_LIT> ) ) >= <NUM_LIT> ) return <NUM_LIT> ; if ( CONSTANT_ADDRESS_P ( x ) ) { if ( avr_io_address_p ( x , <NUM_LIT> ) ) return <NUM_LIT> ; return <NUM_LIT> ; }


<s> static bool avr_assemble_integer ( rtx x , unsigned int size , int aligned_p ) { if ( size == POINTER_SIZE / BITS_PER_UNIT && aligned_p && ( ( GET_CODE ( x ) == SYMBOL_REF && SYMBOL_REF_FUNCTION_P ( x ) ) || GET_CODE ( x ) == LABEL_REF ) ) {


<s> fputs ( <STR_LIT> , asm_out_file ) ; output_quoted_string ( asm_out_file , main_input_filename ) ;


<s> rtx avr_function_value ( tree type , tree func ATTRIBUTE_UNUSED ) { unsigned int offs ; if ( TYPE_MODE ( type ) != BLKmode ) return avr_libcall_value ( TYPE_MODE ( type ) ) ; offs = int_size_in_bytes ( type ) ; if ( offs < <NUM_LIT> ) offs = <NUM_LIT> ; if ( offs > <NUM_LIT> && offs < GET_MODE_SIZE ( SImode ) ) offs = GET_MODE_SIZE ( SImode ) ; else if ( offs > GET_MODE_SIZE ( SImode ) && offs < GET_MODE_SIZE ( DImode ) ) offs = GET_MODE_SIZE ( DImode ) ;

return gen_rtx_REG ( BLKmode , RET_REGISTER + <NUM_LIT> - offs ) ;


<s> const char * func_name = IDENTIFIER_POINTER ( DECL_NAME ( * node ) ) ; const char * attr = IDENTIFIER_POINTER ( name ) ; if ( strncmp ( attr , <STR_LIT> , strlen ( <STR_LIT> ) ) == <NUM_LIT> ) { if ( strncmp ( func_name , <STR_LIT> , strlen ( <STR_LIT> ) ) != <NUM_LIT> ) { warning ( <NUM_LIT> , <STR_LIT> , func_name ) ; }


<s> static tree avr_handle_progmem_attribute ( tree * node , tree name , tree args ATTRIBUTE_UNUSED , int flags ATTRIBUTE_UNUSED , bool * no_add_attrs ) { if ( DECL_P ( * node ) ) { if ( TREE_CODE ( * node ) == TYPE_DECL ) {


<s> if ( regno == REG_Y && mode == Pmode ) return <NUM_LIT> ;

if ( regno <= ( REG_Y + <NUM_LIT> ) && ( regno + GET_MODE_SIZE ( mode ) ) >= ( REG_Y + <NUM_LIT> ) ) return <NUM_LIT> ;


<s> static const char dsec [ ] = <STR_LIT> ;

* attributes = tree_cons ( get_identifier ( <STR_LIT> ) , build_tree_list ( NULL , build_string ( strlen ( dsec ) , dsec ) ) , * attributes ) ;


<s> if ( TREE_CODE ( node ) == VAR_DECL && ( TREE_STATIC ( node ) || DECL_EXTERNAL ( node ) ) && avr_progmem_p ( node , * attributes ) ) { static const char dsec [ ] = <STR_LIT> ; * attributes = tree_cons ( get_identifier ( <STR_LIT> ) , build_tree_list ( NULL , build_string ( strlen ( dsec ) , dsec ) ) , * attributes ) ; TREE_READONLY ( node ) = <NUM_LIT> ;


<s> if ( - <NUM_LIT> <= jump_distance && jump_distance <= <NUM_LIT> ) return <NUM_LIT> ; else if ( - <NUM_LIT> <= jump_distance && jump_distance <= <NUM_LIT> ) return <NUM_LIT> ; else if ( AVR_MEGA ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> int dest_addr = INSN_ADDRESSES ( INSN_UID ( GET_MODE ( x ) == LABEL_REF ? XEXP ( x , <NUM_LIT> ) : x ) ) ; int cur_addr = INSN_ADDRESSES ( INSN_UID ( insn ) ) ; int jump_distance = cur_addr - dest_addr ; if ( - <NUM_LIT> <= jump_distance && jump_distance <= <NUM_LIT> ) return <NUM_LIT> ;


<s> int offs = GET_MODE_SIZE ( mode ) ; if ( offs < <NUM_LIT> ) offs = <NUM_LIT> ; return gen_rtx_REG ( mode , RET_REGISTER + <NUM_LIT> - offs ) ;


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


<s> static int avr_naked_function_p ( tree func ) { tree a ; gcc_assert ( TREE_CODE ( func ) == FUNCTION_DECL ) ;

a = lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( func ) ) ;


<s> tree a ; gcc_assert ( TREE_CODE ( func ) == FUNCTION_DECL ) ; a = lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( func ) ) ;


<s> else size = GET_MODE_SIZE ( mode ) ;

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


<s> static int avr_operand_rtx_cost ( rtx x , enum machine_mode mode , enum rtx_code outer ) { enum rtx_code code = GET_CODE ( x ) ; int total ; switch ( code ) { case REG : case SUBREG : return <NUM_LIT> ; case CONST_INT : case CONST_DOUBLE : return COSTS_N_INSNS ( GET_MODE_SIZE ( mode ) ) ; default :


<s> if ( AVR_MEGA ) fprintf ( stream , <STR_LIT> , value ) ;

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


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


<s> s [ <NUM_LIT> ] = 'A' + ( bit_nr >> <NUM_LIT> ) ; s [ <NUM_LIT> ] = '0' + ( bit_nr & <NUM_LIT> ) ; output_asm_insn ( s , operands ) ;


<s> static char s [ ] = <STR_LIT> ; s [ <NUM_LIT> ] = 'A' + ( bit_nr >> <NUM_LIT> ) ; s [ <NUM_LIT> ] = '0' + ( bit_nr & <NUM_LIT> ) ;


<s> int main_p ; int function_size ; int live_seq ; int minimize ; rtx last = get_last_nonnote_insn ( ) ; function_size = jump_tables_size ; if ( last ) { rtx first = get_first_nonnote_insn ( ) ; function_size += ( INSN_ADDRESSES ( INSN_UID ( last ) ) - INSN_ADDRESSES ( INSN_UID ( first ) ) ) ; function_size += get_attr_length ( last ) ; } fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , size ) ; epilogue_size = <NUM_LIT> ; if ( avr_naked_function_p ( current_function_decl ) ) { fputs ( <STR_LIT> , file ) ; goto out ; } if ( last && GET_CODE ( last ) == BARRIER ) { fputs ( <STR_LIT> , file ) ; goto out ; } interrupt_func_p = interrupt_function_p ( current_function_decl ) ; signal_func_p = signal_function_p ( current_function_decl ) ; main_p = MAIN_NAME_P ( DECL_NAME ( current_function_decl ) ) ; live_seq = sequent_regs_live ( ) ; minimize = ( TARGET_CALL_PROLOGUES && ! interrupt_func_p && ! signal_func_p && live_seq ) ; if ( main_p ) { if ( AVR_MEGA ) { fputs ( <STR_LIT> AS1 ( jmp , exit ) <STR_LIT> , file ) ; epilogue_size += <NUM_LIT> ; } else { fputs ( <STR_LIT> AS1 ( rjmp , exit ) <STR_LIT> , file ) ; ++ epilogue_size ; } } else if ( minimize && ( frame_pointer_needed || live_seq > <NUM_LIT> ) ) { fprintf ( file , ( <STR_LIT> AS2 ( ldi , r30 , % d ) CR_TAB ) , live_seq ) ; ++ epilogue_size ; if ( frame_pointer_needed ) { epilogue_size += out_adj_frame_ptr ( file , - size ) ;


<s> } interrupt_func_p = interrupt_function_p ( current_function_decl ) ; signal_func_p = signal_function_p ( current_function_decl ) ; main_p = MAIN_NAME_P ( DECL_NAME ( current_function_decl ) ) ; live_seq = sequent_regs_live ( ) ; minimize = ( TARGET_CALL_PROLOGUES && ! interrupt_func_p && ! signal_func_p && live_seq ) ; if ( interrupt_func_p ) { fprintf ( file , <STR_LIT> ) ; ++ prologue_size ; } if ( interrupt_func_p || signal_func_p ) { fprintf ( file , <STR_LIT> AS1 ( push , __zero_reg__ ) CR_TAB AS1 ( push , __tmp_reg__ ) CR_TAB AS2 ( in , __tmp_reg__ , __SREG__ ) CR_TAB AS1 ( push , __tmp_reg__ ) CR_TAB AS1 ( clr , __zero_reg__ ) <STR_LIT> ) ; prologue_size += <NUM_LIT> ; } if ( main_p ) { fprintf ( file , ( <STR_LIT> AS1 ( ldi , r28 ) <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> CR_TAB AS1 ( ldi , r29 ) <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> CR_TAB AS2 ( out , __SP_H__ , r29 ) CR_TAB AS2 ( out , __SP_L__ , r28 ) <STR_LIT> ) , avr_init_stack , size , avr_init_stack , size ) ; prologue_size += <NUM_LIT> ; } else if ( minimize && ( frame_pointer_needed || live_seq > <NUM_LIT> ) ) { fprintf ( file , ( <STR_LIT> AS1 ( ldi , r26 ) <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> CR_TAB AS1 ( ldi , r27 ) <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> CR_TAB ) , size , size ) ; fputs ( ( AS2 ( ldi , r30 , pm_lo8 ( <NUM_LIT> ) ) CR_TAB AS2 ( ldi , r31 , pm_hi8 ( <NUM_LIT> ) ) CR_TAB ) , file ) ; prologue_size += <NUM_LIT> ; if ( AVR_MEGA ) { fprintf ( file , AS1 ( jmp , __prologue_saves__ + % d ) <STR_LIT> , ( <NUM_LIT> - live_seq ) * <NUM_LIT> ) ; prologue_size += <NUM_LIT> ; } else { fprintf ( file , AS1 ( rjmp , __prologue_saves__ + % d ) <STR_LIT> , ( <NUM_LIT> - live_seq ) * <NUM_LIT> ) ; ++ prologue_size ; } fputs ( <STR_LIT> , file ) ; } else { HARD_REG_SET set ; prologue_size += avr_regs_to_save ( & set ) ; for ( reg = <NUM_LIT> ; reg < <NUM_LIT> ; ++ reg ) { if ( TEST_HARD_REG_BIT ( set , reg ) ) { fprintf ( file , <STR_LIT> AS1 ( push , % s ) <STR_LIT> , avr_regnames [ reg ] ) ; } } if ( frame_pointer_needed ) { fprintf ( file , <STR_LIT> AS1 ( push , r28 ) CR_TAB AS1 ( push , r29 ) CR_TAB AS2 ( in , r28 , __SP_L__ ) CR_TAB AS2 ( in , r29 , __SP_H__ ) <STR_LIT> ) ; prologue_size += <NUM_LIT> ; if ( size ) {


<s> fprintf ( file , AS1 ( rjmp , __prologue_saves__ + % d ) <STR_LIT> , ( <NUM_LIT> - live_seq ) * <NUM_LIT> ) ; ++ prologue_size ; } fputs ( <STR_LIT> , file ) ; } else { HARD_REG_SET set ; prologue_size += avr_regs_to_save ( & set ) ; for ( reg = <NUM_LIT> ; reg < <NUM_LIT> ; ++ reg ) { if ( TEST_HARD_REG_BIT ( set , reg ) ) { fprintf ( file , <STR_LIT> AS1 ( push , % s ) <STR_LIT> , avr_regnames [ reg ] ) ; } } if ( frame_pointer_needed ) { fprintf ( file , <STR_LIT> AS1 ( push , r28 ) CR_TAB AS1 ( push , r29 ) CR_TAB AS2 ( in , r28 , __SP_L__ ) CR_TAB AS2 ( in , r29 , __SP_H__ ) <STR_LIT> ) ; prologue_size += <NUM_LIT> ; if ( size ) { fputs ( <STR_LIT> , file ) ; prologue_size += out_adj_frame_ptr ( file , size ) ; if ( interrupt_func_p ) { prologue_size += out_set_stack_ptr ( file , <NUM_LIT> , <NUM_LIT> ) ;


<s> int long_jump = ( get_attr_length ( insn ) >= <NUM_LIT> ) ; int reverse = long_jump || jump_over_one_insn_p ( insn , operands [ <NUM_LIT> ] ) ; if ( comp == GE ) comp = EQ ; else if ( comp == LT ) comp = NE ; if ( reverse ) comp = reverse_condition ( comp ) ; if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT ) { if ( INTVAL ( operands [ <NUM_LIT> ] ) < <NUM_LIT> ) { if ( comp == EQ ) output_asm_insn ( AS2 ( sbis , % <NUM_LIT> - <NUM_LIT> , % <NUM_LIT> ) , operands ) ;

else output_asm_insn ( AS2 ( sbic , % <NUM_LIT> - <NUM_LIT> , % <NUM_LIT> ) , operands ) ;


<s> else output_asm_insn ( AS2 ( sbrc , % <NUM_LIT> , % <NUM_LIT> ) , operands ) ; } else { static char buf [ ] = <STR_LIT> ; int bit_nr = exact_log2 ( INTVAL ( operands [ <NUM_LIT> ] ) & GET_MODE_MASK ( GET_MODE ( operands [ <NUM_LIT> ] ) ) ) ; buf [ <NUM_LIT> ] = ( comp == EQ ) ? 's' : 'c' ; buf [ <NUM_LIT> ] = 'A' + ( bit_nr >> <NUM_LIT> ) ; buf [ <NUM_LIT> ] = '0' + ( bit_nr & <NUM_LIT> ) ; output_asm_insn ( buf , operands ) ; } } if ( long_jump ) return ( AS1 ( rjmp , . + <NUM_LIT> ) CR_TAB AS1 ( jmp , % <NUM_LIT> ) ) ;

if ( ! reverse ) return AS1 ( rjmp , % <NUM_LIT> ) ;


<s> const struct base_arch_s * base ; for ( t = avr_mcu_types ; t -> name ; t ++ ) if ( strcmp ( t -> name , avr_mcu_name ) == <NUM_LIT> ) break ; if ( ! t -> name ) { fprintf ( stderr , <STR_LIT> , avr_mcu_name ) ;

for ( t = avr_mcu_types ; t -> name ; t ++ ) fprintf ( stderr , <STR_LIT> , t -> name ) ;


<s> for ( t = avr_mcu_types ; t -> name ; t ++ ) fprintf ( stderr , <STR_LIT> , t -> name ) ; } base = & avr_arch_types [ t -> arch ] ; avr_asm_only_p = base -> asm_only ; avr_enhanced_p = base -> enhanced ; avr_mega_p = base -> mega ; avr_base_arch_macro = base -> macro ; avr_extra_arch_macro = t -> macro ;

if ( optimize && ! TARGET_NO_TABLEJUMP ) avr_case_values_threshold = ( ! AVR_MEGA || TARGET_CALL_PROLOGUES ) ? <NUM_LIT> : <NUM_LIT> ;


<s> int reg ; for ( reg = first_reg ; reg <= last_reg ; reg ++ ) { if ( ! regs_ever_live [ reg ] ) return <NUM_LIT> ; } } return <NUM_LIT> ;


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


<s> if ( ( int_or_sig_p && ! leaf_func_p && call_used_regs [ reg ] ) || ( regs_ever_live [ 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> case 'x' : return POINTER_X_REGS ; case 'y' : return POINTER_Y_REGS ; case 'z' : return POINTER_Z_REGS ; case 'q' : return STACK_REG ; default : break ;


<s> pattern = PATTERN ( insn ) ; if ( GET_CODE ( pattern ) == PARALLEL ) pattern = XVECEXP ( pattern , <NUM_LIT> , <NUM_LIT> ) ; if ( GET_CODE ( pattern ) == SET && SET_DEST ( pattern ) == cc0_rtx && compare_diff_p ( insn ) ) { if ( GET_CODE ( SET_SRC ( pattern ) ) == COMPARE ) { 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 next = next_real_insn ( insn ) ; rtx pat = PATTERN ( next ) ; 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> ) ;


<s> static bool avr_return_in_memory ( tree type , tree fntype ATTRIBUTE_UNUSED ) { if ( TYPE_MODE ( type ) == BLKmode ) { HOST_WIDE_INT size = int_size_in_bytes ( type ) ; return ( size == - <NUM_LIT> || size > <NUM_LIT> ) ;


<s> HOST_WIDE_INT size = int_size_in_bytes ( type ) ; return ( size == - <NUM_LIT> || size > <NUM_LIT> ) ;


<s> if ( strncmp ( name , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) {

if ( decl && TREE_CODE ( decl ) == VAR_DECL && DECL_INITIAL ( decl ) == NULL_TREE ) flags |= SECTION_BSS ;


<s> return ( ! frame_pointer_needed && get_frame_size ( ) == <NUM_LIT> && avr_regs_to_save ( NULL ) == <NUM_LIT> && ! interrupt_function_p ( current_function_decl ) && ! signal_function_p ( current_function_decl ) && ! avr_naked_function_p ( current_function_decl ) && ! MAIN_NAME_P ( DECL_NAME ( current_function_decl ) ) && ! TREE_THIS_VOLATILE ( current_function_decl ) ) ;


<s> int avr_simple_epilogue ( void ) { return ( ! frame_pointer_needed && get_frame_size ( ) == <NUM_LIT> && avr_regs_to_save ( NULL ) == <NUM_LIT> && ! interrupt_function_p ( current_function_decl ) && ! signal_function_p ( current_function_decl ) && ! avr_naked_function_p ( current_function_decl ) && ! MAIN_NAME_P ( DECL_NAME ( current_function_decl ) ) && ! TREE_THIS_VOLATILE ( current_function_decl ) ) ;


<s> int avr_simplify_comparison_p ( enum machine_mode mode , RTX_CODE operator , rtx x ) { unsigned int max = ( mode == QImode ? <NUM_LIT> : mode == HImode ? <NUM_LIT> : mode == SImode ? <NUM_LIT> : <NUM_LIT> ) ; if ( max && operator && GET_CODE ( x ) == CONST_INT ) { if ( unsigned_condition ( operator ) != operator ) max >>= <NUM_LIT> ; if ( max != ( INTVAL ( x ) & max ) && INTVAL ( x ) != <NUM_LIT> ) return <NUM_LIT> ; }


<s> mode == SImode ? <NUM_LIT> : <NUM_LIT> ) ; if ( max && operator && GET_CODE ( x ) == CONST_INT ) { if ( unsigned_condition ( operator ) != operator ) max >>= <NUM_LIT> ; if ( max != ( INTVAL ( x ) & max ) && INTVAL ( x ) != <NUM_LIT> ) return <NUM_LIT> ; }


<s> return ( GET_CODE ( op ) == CONST_INT && INTVAL ( op ) <= <NUM_LIT> && INTVAL ( op ) >= <NUM_LIT> ) ;


<s> if ( register_operand ( inside , Pmode ) ) return <NUM_LIT> ; if ( CONSTANT_ADDRESS_P ( inside ) ) return <NUM_LIT> ; } return <NUM_LIT> ;


<s> enum reg_class class_likely_spilled_p ( int c ) { return ( c != ALL_REGS && c != ADDW_REGS ) ;


<s> return ( c != ALL_REGS && c != ADDW_REGS ) ;


<s> static RTX_CODE compare_condition ( rtx insn ) { rtx next = next_real_insn ( insn ) ; RTX_CODE cond = UNKNOWN ;

if ( next && GET_CODE ( next ) == JUMP_INSN ) {


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


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


RTX_CODE cond = compare_condition ( insn ) ;


<s> static int compare_sign_p ( rtx insn ) { RTX_CODE cond = compare_condition ( insn ) ; return ( cond == GE || cond == LT ) ;


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


<s> else return <STR_LIT> ; case LT : if ( cc_prev_status . flags & CC_OVERFLOW_UNUSABLE ) return <STR_LIT> ; else return <STR_LIT> ; case GEU : return <STR_LIT> ; case LTU : return <STR_LIT> ;


<s> HOST_WIDE_INT d = INTVAL ( x ) ; HOST_WIDE_INT abs_d = ( d >= <NUM_LIT> ) ? d : - d ;


<s> int regno = REGNO ( xx ) ; if ( TARGET_ALL_DEBUG ) { fprintf ( stderr , ( <STR_LIT> <STR_LIT> <STR_LIT> ) , reload_completed , reload_in_progress ) ; debug_rtx ( x ) ; } if ( regno >= FIRST_PSEUDO_REGISTER ) return <NUM_LIT> ; else if ( regno == REG_Z || regno == REG_Y ) return <NUM_LIT> ; else if ( xx == frame_pointer_rtx || xx == arg_pointer_rtx ) return <NUM_LIT> ; } }


<s> int uid = INSN_UID ( insn ) ; if ( TARGET_INSN_SIZE_DUMP || TARGET_ALL_DEBUG ) { fprintf ( asm_out_file , <STR_LIT> , INSN_ADDRESSES ( uid ) , INSN_ADDRESSES ( uid ) - last_insn_address , rtx_cost ( PATTERN ( insn ) , INSN ) ) ;


<s> void final_prescan_insn ( rtx insn , rtx * operand ATTRIBUTE_UNUSED , int num_operands ATTRIBUTE_UNUSED ) { int uid = INSN_UID ( insn ) ;

if ( TARGET_INSN_SIZE_DUMP || TARGET_ALL_DEBUG ) {


<s> rtx function_arg ( CUMULATIVE_ARGS * cum , enum machine_mode mode , tree type , int named ATTRIBUTE_UNUSED ) {

int bytes = avr_num_arg_regs ( mode , type ) ;


<s> rtx function_arg ( CUMULATIVE_ARGS * cum , enum machine_mode mode , tree type , int named ATTRIBUTE_UNUSED ) { int bytes = avr_num_arg_regs ( mode , type ) ;

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


<s> cum -> regno -= bytes ; if ( cum -> nregs <= <NUM_LIT> ) { cum -> nregs = <NUM_LIT> ; cum -> regno = FIRST_CUM_REG ; }


<s> void function_arg_advance ( CUMULATIVE_ARGS * cum , enum machine_mode mode , tree type , int named ATTRIBUTE_UNUSED ) { int bytes = avr_num_arg_regs ( mode , type ) ; cum -> nregs -= bytes ; cum -> regno -= bytes ; if ( cum -> nregs <= <NUM_LIT> ) {


<s> int function_arg_regno_p ( int r ) { return ( r >= <NUM_LIT> && r <= <NUM_LIT> ) ;


<s> unsigned ch ; fprintf ( file , <STR_LIT> , STRING_ASM_OP ) ; for ( ; ( ch = * _limited_str ) ; _limited_str ++ ) { int escape ; switch ( escape = ESCAPES [ ch ] ) { case <NUM_LIT> : putc ( ch , file ) ; break ; case <NUM_LIT> : fprintf ( file , <STR_LIT> , ch ) ; break ;


<s> int offset = frame_pointer_needed ? <NUM_LIT> : <NUM_LIT> ; offset += avr_regs_to_save ( NULL ) ;

return get_frame_size ( ) + <NUM_LIT> + <NUM_LIT> + offset ;


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


<s> void init_cumulative_args ( CUMULATIVE_ARGS * cum , tree fntype , rtx libname , tree fndecl ATTRIBUTE_UNUSED ) { cum -> nregs = <NUM_LIT> ; cum -> regno = FIRST_CUM_REG ; if ( ! libname && fntype ) { int stdarg = ( TYPE_ARG_TYPES ( fntype ) != <NUM_LIT> && ( TREE_VALUE ( tree_last ( TYPE_ARG_TYPES ( fntype ) ) ) != void_type_node ) ) ; if ( stdarg ) cum -> nregs = <NUM_LIT> ; }


<s> cum -> regno = FIRST_CUM_REG ; if ( ! libname && fntype ) {

int stdarg = ( TYPE_ARG_TYPES ( fntype ) != <NUM_LIT> && ( TREE_VALUE ( tree_last ( TYPE_ARG_TYPES ( fntype ) ) ) != void_type_node ) ) ;


<s> static int interrupt_function_p ( tree func ) { tree a ; if ( TREE_CODE ( func ) != FUNCTION_DECL ) return <NUM_LIT> ; a = lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( func ) ) ;


<s> int dest_addr = INSN_ADDRESSES ( uid ) ;


<s> } if ( REG_P ( x ) && ( strict ? REG_OK_FOR_BASE_STRICT_P ( x ) : REG_OK_FOR_BASE_NOSTRICT_P ( x ) ) ) r = POINTER_REGS ; else if ( CONSTANT_ADDRESS_P ( x ) ) r = ALL_REGS ; else if ( GET_CODE ( x ) == PLUS && REG_P ( XEXP ( x , <NUM_LIT> ) ) && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT && INTVAL ( XEXP ( x , <NUM_LIT> ) ) >= <NUM_LIT> ) { int fit = INTVAL ( XEXP ( x , <NUM_LIT> ) ) <= MAX_LD_OFFSET ( mode ) ; if ( fit ) { if ( ! strict || REGNO ( XEXP ( x , <NUM_LIT> ) ) == REG_Y || REGNO ( XEXP ( x , <NUM_LIT> ) ) == REG_Z ) r = BASE_POINTER_REGS ; if ( XEXP ( x , <NUM_LIT> ) == frame_pointer_rtx || XEXP ( x , <NUM_LIT> ) == arg_pointer_rtx ) r = BASE_POINTER_REGS ; } else if ( frame_pointer_needed && XEXP ( x , <NUM_LIT> ) == frame_pointer_rtx ) r = POINTER_Y_REGS ; } else if ( ( GET_CODE ( x ) == PRE_DEC || GET_CODE ( x ) == POST_INC ) && REG_P ( XEXP ( x , <NUM_LIT> ) ) && ( strict ? REG_OK_FOR_BASE_STRICT_P ( XEXP ( x , <NUM_LIT> ) ) : REG_OK_FOR_BASE_NOSTRICT_P ( XEXP ( x , <NUM_LIT> ) ) ) ) { r = POINTER_REGS ;


<s> if ( GET_CODE ( oldx ) == PLUS && REG_P ( XEXP ( oldx , <NUM_LIT> ) ) ) { if ( REG_P ( XEXP ( oldx , <NUM_LIT> ) ) ) x = force_reg ( GET_MODE ( oldx ) , oldx ) ;

else if ( GET_CODE ( XEXP ( oldx , <NUM_LIT> ) ) == CONST_INT ) {


<s> case <NUM_LIT> : * len = <NUM_LIT> ; return ( AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) ) ; case <NUM_LIT> : if ( test_hard_reg_class ( LD_REGS , operands [ <NUM_LIT> ] ) ) { * len = <NUM_LIT> ; return ( AS1 ( swap , % <NUM_LIT> ) CR_TAB AS2 ( andi , % <NUM_LIT> , <NUM_LIT> ) ) ; } * len = <NUM_LIT> ; return ( AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) ) ; case <NUM_LIT> : if ( test_hard_reg_class ( LD_REGS , operands [ <NUM_LIT> ] ) ) { * len = <NUM_LIT> ; return ( AS1 ( swap , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS2 ( andi , % <NUM_LIT> , <NUM_LIT> ) ) ; } * len = <NUM_LIT> ; return ( AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) ) ; case <NUM_LIT> : if ( test_hard_reg_class ( LD_REGS , operands [ <NUM_LIT> ] ) ) { * len = <NUM_LIT> ; return ( AS1 ( swap , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS2 ( andi , % <NUM_LIT> , <NUM_LIT> ) ) ; } * len = <NUM_LIT> ; return ( AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) ) ; case <NUM_LIT> : * len = <NUM_LIT> ; return ( AS1 ( rol , % <NUM_LIT> ) CR_TAB AS1 ( clr , % <NUM_LIT> ) CR_TAB AS1 ( rol , % <NUM_LIT> ) ) ; } } else if ( CONSTANT_P ( operands [ <NUM_LIT> ] ) ) fatal_insn ( <STR_LIT> , insn ) ; out_shift_with_cnt ( AS1 ( lsr , % <NUM_LIT> ) , insn , operands , len , <NUM_LIT> ) ;


<s> return ( AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) ) ; case <NUM_LIT> : * len = <NUM_LIT> ; return ( AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) ) ; case <NUM_LIT> : if ( test_hard_reg_class ( LD_REGS , operands [ <NUM_LIT> ] ) ) { * len = <NUM_LIT> ; return ( AS1 ( swap , % <NUM_LIT> ) CR_TAB AS2 ( andi , % <NUM_LIT> , <NUM_LIT> ) ) ; } * len = <NUM_LIT> ; return ( AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) ) ; case <NUM_LIT> : if ( test_hard_reg_class ( LD_REGS , operands [ <NUM_LIT> ] ) ) { * len = <NUM_LIT> ; return ( AS1 ( swap , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS2 ( andi , % <NUM_LIT> , <NUM_LIT> ) ) ; } * len = <NUM_LIT> ; return ( AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) ) ; case <NUM_LIT> : if ( test_hard_reg_class ( LD_REGS , operands [ <NUM_LIT> ] ) ) { * len = <NUM_LIT> ; return ( AS1 ( swap , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS2 ( andi , % <NUM_LIT> , <NUM_LIT> ) ) ; } * len = <NUM_LIT> ; return ( AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) CR_TAB AS1 ( lsr , % <NUM_LIT> ) ) ; case <NUM_LIT> : * len = <NUM_LIT> ; return ( AS1 ( rol , % <NUM_LIT> ) CR_TAB AS1 ( clr , % <NUM_LIT> ) CR_TAB AS1 ( rol , % <NUM_LIT> ) ) ; }


<s> if ( reg0 <= reg1 ) return ( AS2 ( mov , % A0 , % B1 ) CR_TAB AS2 ( mov , % B0 , % C1 ) CR_TAB AS2 ( mov , % C0 , % D1 ) CR_TAB AS1 ( clr , % D0 ) ) ; else if ( reg0 == reg1 + <NUM_LIT> ) return * len = <NUM_LIT> , AS1 ( clr , % D0 ) ; else return ( AS1 ( clr , % D0 ) CR_TAB AS2 ( mov , % C0 , % D1 ) CR_TAB AS2 ( mov , % B0 , % C1 ) CR_TAB AS2 ( mov , % A0 , % B1 ) ) ; } case <NUM_LIT> : { int reg0 = true_regnum ( operands [ <NUM_LIT> ] ) ; int reg1 = true_regnum ( operands [ <NUM_LIT> ] ) ; * len = <NUM_LIT> ; if ( AVR_ENHANCED && ( reg0 != reg1 + <NUM_LIT> ) ) { * len = <NUM_LIT> ; return ( AS2 ( movw , % A0 , % C1 ) CR_TAB AS1 ( clr , % C0 ) CR_TAB AS1 ( clr , % D0 ) ) ; } if ( reg0 <= reg1 + <NUM_LIT> ) return ( AS2 ( mov , % A0 , % C1 ) CR_TAB AS2 ( mov , % B0 , % D1 ) CR_TAB AS1 ( clr , % C0 ) CR_TAB AS1 ( clr , % D0 ) ) ; else if ( reg0 == reg1 + <NUM_LIT> ) return * len = <NUM_LIT> , ( AS1 ( clr , % C0 ) CR_TAB AS1 ( clr , % D0 ) ) ; else return ( AS2 ( mov , % B0 , % D1 ) CR_TAB AS2 ( mov , % A0 , % C1 ) CR_TAB AS1 ( clr , % C0 ) CR_TAB AS1 ( clr , % D0 ) ) ; } case <NUM_LIT> : if ( true_regnum ( operands [ <NUM_LIT> ] ) != true_regnum ( operands [ <NUM_LIT> ] ) + <NUM_LIT> ) return * len = <NUM_LIT> , ( AS2 ( mov , % A0 , % D1 ) CR_TAB AS1 ( clr , % B0 ) CR_TAB AS1 ( clr , % C0 ) CR_TAB AS1 ( clr , % D0 ) ) ; else return * len = <NUM_LIT> , ( AS1 ( clr , % B0 ) CR_TAB AS1 ( clr , % C0 ) CR_TAB AS1 ( clr , % D0 ) ) ; case <NUM_LIT> : * len = <NUM_LIT> ; return ( AS1 ( clr , % A0 ) CR_TAB AS2 ( sbrc , % D0 , <NUM_LIT> ) CR_TAB AS1 ( inc , % A0 ) CR_TAB AS1 ( clr , % B0 ) CR_TAB AS1 ( clr , % C0 ) CR_TAB AS1 ( clr , % D0 ) ) ; } len = t ; }

out_shift_with_cnt ( ( AS1 ( lsr , % D0 ) CR_TAB AS1 ( ror , % C0 ) CR_TAB AS1 ( ror , % B0 ) CR_TAB AS1 ( ror , % A0 ) ) , insn , operands , len , <NUM_LIT> ) ;


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


<s> switch ( get_attr_cc ( insn ) ) { 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_CZN : set = single_set ( insn ) ; CC_STATUS_INIT ; if ( set ) { cc_status . value1 = SET_DEST ( set ) ; cc_status . flags |= CC_OVERFLOW_UNUSABLE ; } break ; case CC_COMPARE : set = single_set ( insn ) ; CC_STATUS_INIT ; if ( set ) cc_status . value1 = SET_SRC ( set ) ; break ; case CC_CLOBBER : CC_STATUS_INIT ; set = single_set ( insn ) ; if ( set ) {


const int * order = ( TARGET_ORDER_1 ? order_1 :


<s> if ( register_operand ( src , QImode ) ) { if ( test_hard_reg_class ( STACK_REG , dest ) ) return AS2 ( out , % <NUM_LIT> , % <NUM_LIT> ) ; else if ( test_hard_reg_class ( STACK_REG , src ) ) return AS2 ( in , % <NUM_LIT> , % <NUM_LIT> ) ; return AS2 ( mov , % <NUM_LIT> , % <NUM_LIT> ) ; } else if ( CONSTANT_P ( src ) ) { if ( test_hard_reg_class ( LD_REGS , dest ) ) return AS2 ( ldi , % <NUM_LIT> , lo8 ( % <NUM_LIT> ) ) ; if ( GET_CODE ( src ) == CONST_INT ) { if ( src == const0_rtx ) return AS1 ( clr , % <NUM_LIT> ) ; else if ( src == const1_rtx ) { * l = <NUM_LIT> ; return ( AS1 ( clr , % <NUM_LIT> ) CR_TAB AS1 ( inc , % <NUM_LIT> ) ) ; } else if ( src == constm1_rtx ) { * l = <NUM_LIT> ; return ( AS1 ( clr , % <NUM_LIT> ) CR_TAB AS1 ( dec , % <NUM_LIT> ) ) ; } else { int bit_nr = exact_log2 ( INTVAL ( src ) ) ; if ( bit_nr >= <NUM_LIT> ) { * l = <NUM_LIT> ; if ( ! real_l ) output_asm_insn ( ( AS1 ( clr , % <NUM_LIT> ) CR_TAB <STR_LIT> ) , operands ) ; if ( ! real_l ) avr_output_bld ( operands , bit_nr ) ; return <STR_LIT> ; } } } * l = <NUM_LIT> ; return ( AS2 ( mov , __tmp_reg__ , r31 ) CR_TAB AS2 ( ldi , r31 , lo8 ( % <NUM_LIT> ) ) CR_TAB AS2 ( mov , % <NUM_LIT> , r31 ) CR_TAB AS2 ( mov , r31 , __tmp_reg__ ) ) ; } else if ( GET_CODE ( src ) == MEM ) return out_movqi_r_mr ( insn , operands , real_l ) ; } else if ( GET_CODE ( dest ) == MEM ) { const char * template ; if ( src == const0_rtx ) operands [ <NUM_LIT> ] = zero_reg_rtx ; template = out_movqi_mr_r ( insn , operands , real_l ) ; if ( ! real_l ) output_asm_insn ( template , operands ) ;


<s> int tmp ; if ( ! len ) len = & tmp ; if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT ) { int val = INTVAL ( operands [ <NUM_LIT> ] ) ; if ( ( val & <NUM_LIT> ) == <NUM_LIT> ) { * len = <NUM_LIT> ; return ( AS2 ( mov , % A0 , __zero_reg__ ) CR_TAB AS2 ( ldi , % <NUM_LIT> , hi8 ( % <NUM_LIT> ) ) CR_TAB AS2 ( mov , % B0 , % <NUM_LIT> ) ) ; } else if ( ( val & <NUM_LIT> ) == <NUM_LIT> ) { * len = <NUM_LIT> ; return ( AS2 ( ldi , % <NUM_LIT> , lo8 ( % <NUM_LIT> ) ) CR_TAB AS2 ( mov , % A0 , % <NUM_LIT> ) CR_TAB AS2 ( mov , % B0 , __zero_reg__ ) ) ; } else if ( ( val & <NUM_LIT> ) == ( ( val & <NUM_LIT> ) >> <NUM_LIT> ) ) { * len = <NUM_LIT> ; return ( AS2 ( ldi , % <NUM_LIT> , lo8 ( % <NUM_LIT> ) ) CR_TAB AS2 ( mov , % A0 , % <NUM_LIT> ) CR_TAB AS2 ( mov , % B0 , % <NUM_LIT> ) ) ; } } * len = <NUM_LIT> ; return ( AS2 ( ldi , % <NUM_LIT> , lo8 ( % <NUM_LIT> ) ) CR_TAB AS2 ( mov , % A0 , % <NUM_LIT> ) CR_TAB AS2 ( ldi , % <NUM_LIT> , hi8 ( % <NUM_LIT> ) ) CR_TAB AS2 ( mov , % B0 , % <NUM_LIT> ) ) ;


<s> if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT ) { int val = INTVAL ( operands [ <NUM_LIT> ] ) ; if ( ( val & <NUM_LIT> ) == <NUM_LIT> ) { * len = <NUM_LIT> ; return ( AS2 ( mov , % A0 , __zero_reg__ ) CR_TAB AS2 ( ldi , % <NUM_LIT> , hi8 ( % <NUM_LIT> ) ) CR_TAB AS2 ( mov , % B0 , % <NUM_LIT> ) ) ; } else if ( ( val & <NUM_LIT> ) == <NUM_LIT> ) { * len = <NUM_LIT> ; return ( AS2 ( ldi , % <NUM_LIT> , lo8 ( % <NUM_LIT> ) ) CR_TAB AS2 ( mov , % A0 , % <NUM_LIT> ) CR_TAB AS2 ( mov , % B0 , __zero_reg__ ) ) ;


<s> int cnst = ( GET_CODE ( src ) == CONST_INT ) ; if ( len ) { if ( cnst ) * len = <NUM_LIT> + ( ( INTVAL ( src ) & <NUM_LIT> ) != <NUM_LIT> ) + ( ( INTVAL ( src ) & <NUM_LIT> ) != <NUM_LIT> ) + ( ( INTVAL ( src ) & <NUM_LIT> ) != <NUM_LIT> ) + ( ( INTVAL ( src ) & <NUM_LIT> ) != <NUM_LIT> ) ; else * len = <NUM_LIT> ; return <STR_LIT> ; } if ( cnst && ( ( INTVAL ( src ) & <NUM_LIT> ) == <NUM_LIT> ) ) output_asm_insn ( AS2 ( mov , % A0 , __zero_reg__ ) , operands ) ; else { output_asm_insn ( AS2 ( ldi , % <NUM_LIT> , lo8 ( % <NUM_LIT> ) ) , operands ) ; output_asm_insn ( AS2 ( mov , % A0 , % <NUM_LIT> ) , operands ) ; } if ( cnst && ( ( INTVAL ( src ) & <NUM_LIT> ) == <NUM_LIT> ) ) output_asm_insn ( AS2 ( mov , % B0 , __zero_reg__ ) , operands ) ; else { output_asm_insn ( AS2 ( ldi , % <NUM_LIT> , hi8 ( % <NUM_LIT> ) ) , operands ) ; output_asm_insn ( AS2 ( mov , % B0 , % <NUM_LIT> ) , operands ) ;


<s> if ( cnst && ( ( INTVAL ( src ) & <NUM_LIT> ) == <NUM_LIT> ) ) output_asm_insn ( AS2 ( mov , % A0 , __zero_reg__ ) , operands ) ; else { output_asm_insn ( AS2 ( ldi , % <NUM_LIT> , lo8 ( % <NUM_LIT> ) ) , operands ) ; output_asm_insn ( AS2 ( mov , % A0 , % <NUM_LIT> ) , operands ) ; } if ( cnst && ( ( INTVAL ( src ) & <NUM_LIT> ) == <NUM_LIT> ) ) output_asm_insn ( AS2 ( mov , % B0 , __zero_reg__ ) , operands ) ; else { output_asm_insn ( AS2 ( ldi , % <NUM_LIT> , hi8 ( % <NUM_LIT> ) ) , operands ) ; output_asm_insn ( AS2 ( mov , % B0 , % <NUM_LIT> ) , operands ) ; } if ( cnst && ( ( INTVAL ( src ) & <NUM_LIT> ) == <NUM_LIT> ) ) output_asm_insn ( AS2 ( mov , % C0 , __zero_reg__ ) , operands ) ; else { output_asm_insn ( AS2 ( ldi , % <NUM_LIT> , hlo8 ( % <NUM_LIT> ) ) , operands ) ; output_asm_insn ( AS2 ( mov , % C0 , % <NUM_LIT> ) , operands ) ; } if ( cnst && ( ( INTVAL ( src ) & <NUM_LIT> ) == <NUM_LIT> ) ) output_asm_insn ( AS2 ( mov , % D0 , __zero_reg__ ) , operands ) ; else { output_asm_insn ( AS2 ( ldi , % <NUM_LIT> , hhi8 ( % <NUM_LIT> ) ) , operands ) ;

output_asm_insn ( AS2 ( mov , % D0 , % <NUM_LIT> ) , operands ) ;


<s> static int out_adj_frame_ptr ( FILE * file , int adj ) { int size = <NUM_LIT> ; if ( adj ) { if ( TARGET_TINY_STACK ) { if ( adj < - <NUM_LIT> || adj > <NUM_LIT> ) warning ( <NUM_LIT> , <STR_LIT> , adj ) ; fprintf ( file , ( AS2 ( subi , r28 , % d ) CR_TAB ) , adj ) ; size ++ ; } else if ( adj < - <NUM_LIT> || adj > <NUM_LIT> ) { fprintf ( file , ( AS2 ( subi , r28 , lo8 ( % d ) ) CR_TAB AS2 ( sbci , r29 , hi8 ( % d ) ) CR_TAB ) , adj , adj ) ; size += <NUM_LIT> ; } else if ( adj < <NUM_LIT> ) { fprintf ( file , ( AS2 ( adiw , r28 , % d ) CR_TAB ) , - adj ) ; size ++ ; } else { fprintf ( file , ( AS2 ( sbiw , r28 , % d ) CR_TAB ) , adj ) ; size ++ ; }


<s> static int out_adj_frame_ptr ( FILE * file , int adj ) { int size = <NUM_LIT> ; if ( adj ) { if ( TARGET_TINY_STACK ) { if ( adj < - <NUM_LIT> || adj > <NUM_LIT> ) warning ( <NUM_LIT> , <STR_LIT> , adj ) ; fprintf ( file , ( AS2 ( subi , r28 , % d ) CR_TAB ) , adj ) ; size ++ ; } else if ( adj < - <NUM_LIT> || adj > <NUM_LIT> ) { fprintf ( file , ( AS2 ( subi , r28 , lo8 ( % d ) ) CR_TAB AS2 ( sbci , r29 , hi8 ( % d ) ) CR_TAB ) , adj , adj ) ;


<s> 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 * l = <NUM_LIT> , ( AS2 ( adiw , r28 , % o0 - <NUM_LIT> ) CR_TAB AS2 ( std , Y + <NUM_LIT> , % B1 ) CR_TAB AS2 ( std , Y + <NUM_LIT> , % A1 ) CR_TAB AS2 ( sbiw , r28 , % o0 - <NUM_LIT> ) ) ; return * l = <NUM_LIT> , ( AS2 ( subi , r28 , lo8 ( - % o0 ) ) CR_TAB AS2 ( sbci , r29 , hi8 ( - % o0 ) ) CR_TAB AS2 ( std , Y + <NUM_LIT> , % B1 ) CR_TAB AS2 ( st , Y , % A1 ) CR_TAB AS2 ( subi , r28 , lo8 ( % o0 ) ) CR_TAB AS2 ( sbci , r29 , hi8 ( % o0 ) ) ) ; } if ( reg_base == REG_X ) { if ( reg_src == REG_X ) { * l = <NUM_LIT> ; return ( AS2 ( mov , __tmp_reg__ , r26 ) CR_TAB AS2 ( mov , __zero_reg__ , r27 ) CR_TAB AS2 ( adiw , r26 , % o0 + <NUM_LIT> ) CR_TAB AS2 ( st , X , __zero_reg__ ) CR_TAB AS2 ( st , - X , __tmp_reg__ ) CR_TAB AS1 ( clr , __zero_reg__ ) CR_TAB AS2 ( sbiw , r26 , % o0 ) ) ; } * l = <NUM_LIT> ; return ( AS2 ( adiw , r26 , % o0 + <NUM_LIT> ) CR_TAB AS2 ( st , X , % B1 ) CR_TAB AS2 ( st , - X , % A1 ) CR_TAB AS2 ( sbiw , r26 , % o0 ) ) ; } return * l = <NUM_LIT> , ( AS2 ( std , % B0 , % B1 ) CR_TAB AS2 ( std , % A0 , % A1 ) ) ; }

else if ( GET_CODE ( base ) == PRE_DEC ) return * l = <NUM_LIT> , ( AS2 ( st , % <NUM_LIT> , % B1 ) CR_TAB AS2 ( st , % <NUM_LIT> , % A1 ) ) ;


<s> else { * l = <NUM_LIT> ; return ( AS2 ( ld , % A0 , % <NUM_LIT> ) CR_TAB AS2 ( ldd , % B0 , % <NUM_LIT> + <NUM_LIT> ) ) ; } } else if ( GET_CODE ( base ) == PLUS ) { int disp = INTVAL ( XEXP ( base , <NUM_LIT> ) ) ; int reg_base = true_regnum ( XEXP ( base , <NUM_LIT> ) ) ; if ( disp > MAX_LD_OFFSET ( GET_MODE ( src ) ) ) { if ( REGNO ( XEXP ( base , <NUM_LIT> ) ) != REG_Y ) fatal_insn ( <STR_LIT> , insn ) ; if ( disp <= <NUM_LIT> + MAX_LD_OFFSET ( GET_MODE ( src ) ) ) return * l = <NUM_LIT> , ( AS2 ( adiw , r28 , % o1 - <NUM_LIT> ) CR_TAB AS2 ( ldd , % A0 , Y + <NUM_LIT> ) CR_TAB AS2 ( ldd , % B0 , Y + <NUM_LIT> ) CR_TAB AS2 ( sbiw , r28 , % o1 - <NUM_LIT> ) ) ; return * l = <NUM_LIT> , ( AS2 ( subi , r28 , lo8 ( - % o1 ) ) CR_TAB AS2 ( sbci , r29 , hi8 ( - % o1 ) ) CR_TAB AS2 ( ld , % A0 , Y ) CR_TAB AS2 ( ldd , % B0 , Y + <NUM_LIT> ) CR_TAB AS2 ( subi , r28 , lo8 ( % o1 ) ) CR_TAB AS2 ( sbci , r29 , hi8 ( % o1 ) ) ) ; } if ( reg_base == REG_X ) { * l = <NUM_LIT> ; if ( reg_base == reg_dest ) return ( AS2 ( adiw , r26 , % o1 ) CR_TAB AS2 ( ld , __tmp_reg__ , X + ) CR_TAB AS2 ( ld , % B0 , X ) CR_TAB AS2 ( mov , % A0 , __tmp_reg__ ) ) ; return ( AS2 ( adiw , r26 , % o1 ) CR_TAB AS2 ( ld , % A0 , X + ) CR_TAB AS2 ( ld , % B0 , X ) CR_TAB AS2 ( sbiw , r26 , % o1 + <NUM_LIT> ) ) ; } if ( reg_base == reg_dest ) { * l = <NUM_LIT> ; return ( AS2 ( ldd , __tmp_reg__ , % A1 ) CR_TAB AS2 ( ldd , % B0 , % B1 ) CR_TAB AS2 ( mov , % A0 , __tmp_reg__ ) ) ; } * l = <NUM_LIT> ; return ( AS2 ( ldd , % A0 , % A1 ) CR_TAB AS2 ( ldd , % B0 , % B1 ) ) ; } else if ( GET_CODE ( base ) == PRE_DEC ) { if ( reg_overlap_mentioned_p ( dest , XEXP ( base , <NUM_LIT> ) ) ) fatal_insn ( <STR_LIT> , insn ) ; if ( mem_volatile_p ) { if ( REGNO ( XEXP ( base , <NUM_LIT> ) ) == REG_X ) { * l = <NUM_LIT> ;

return ( AS2 ( sbiw , r26 , <NUM_LIT> ) CR_TAB AS2 ( ld , % A0 , X + ) CR_TAB AS2 ( ld , % B0 , X ) CR_TAB AS2 ( sbiw , r26 , <NUM_LIT> ) ) ;


<s> } else if ( REGNO ( XEXP ( x , <NUM_LIT> ) ) == REG_X ) { if ( reg_overlap_mentioned_p ( src , XEXP ( x , <NUM_LIT> ) ) ) { if ( reg_unused_after ( insn , XEXP ( x , <NUM_LIT> ) ) ) return * l = <NUM_LIT> , ( AS2 ( mov , __tmp_reg__ , % <NUM_LIT> ) CR_TAB AS2 ( adiw , r26 , % o0 ) CR_TAB AS2 ( st , X , __tmp_reg__ ) ) ; return * l = <NUM_LIT> , ( AS2 ( mov , __tmp_reg__ , % <NUM_LIT> ) CR_TAB AS2 ( adiw , r26 , % o0 ) CR_TAB AS2 ( st , X , __tmp_reg__ ) CR_TAB AS2 ( sbiw , r26 , % o0 ) ) ; } else { if ( reg_unused_after ( insn , XEXP ( x , <NUM_LIT> ) ) ) return * l = <NUM_LIT> , ( AS2 ( adiw , r26 , % o0 ) CR_TAB AS2 ( st , X , % <NUM_LIT> ) ) ; return * l = <NUM_LIT> , ( AS2 ( adiw , r26 , % o0 ) CR_TAB AS2 ( st , X , % <NUM_LIT> ) CR_TAB AS2 ( sbiw , r26 , % o0 ) ) ; }


<s> rtx x = XEXP ( dest , <NUM_LIT> ) ; int dummy ; if ( ! l ) l = & dummy ; if ( CONSTANT_ADDRESS_P ( x ) ) { if ( avr_io_address_p ( x , <NUM_LIT> ) ) { * l = <NUM_LIT> ; return AS2 ( out , % <NUM_LIT> - <NUM_LIT> , % <NUM_LIT> ) ; } * l = <NUM_LIT> ; return AS2 ( sts , % <NUM_LIT> , % <NUM_LIT> ) ; } else if ( GET_CODE ( x ) == PLUS && REG_P ( XEXP ( x , <NUM_LIT> ) ) && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) { if ( ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) - GET_MODE_SIZE ( GET_MODE ( dest ) ) ) >= <NUM_LIT> ) { int disp = INTVAL ( XEXP ( x , <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 * l = <NUM_LIT> , ( AS2 ( adiw , r28 , % o0 - <NUM_LIT> ) CR_TAB AS2 ( std , Y + <NUM_LIT> , % <NUM_LIT> ) CR_TAB AS2 ( sbiw , r28 , % o0 - <NUM_LIT> ) ) ; return * l = <NUM_LIT> , ( AS2 ( subi , r28 , lo8 ( - % o0 ) ) CR_TAB AS2 ( sbci , r29 , hi8 ( - % o0 ) ) CR_TAB AS2 ( st , Y , % <NUM_LIT> ) CR_TAB AS2 ( subi , r28 , lo8 ( % o0 ) ) CR_TAB AS2 ( sbci , r29 , hi8 ( % o0 ) ) ) ; } else if ( REGNO ( XEXP ( x , <NUM_LIT> ) ) == REG_X ) { if ( reg_overlap_mentioned_p ( src , XEXP ( x , <NUM_LIT> ) ) ) { if ( reg_unused_after ( insn , XEXP ( x , <NUM_LIT> ) ) ) return * l = <NUM_LIT> , ( AS2 ( mov , __tmp_reg__ , % <NUM_LIT> ) CR_TAB AS2 ( adiw , r26 , % o0 ) CR_TAB AS2 ( st , X , __tmp_reg__ ) ) ; return * l = <NUM_LIT> , ( AS2 ( mov , __tmp_reg__ , % <NUM_LIT> ) CR_TAB AS2 ( adiw , r26 , % o0 ) CR_TAB AS2 ( st , X , __tmp_reg__ ) CR_TAB AS2 ( sbiw , r26 , % o0 ) ) ;


<s> fprintf ( file , <STR_LIT> CR_TAB ) ; size ++ ; } if ( do_sph ) { fprintf ( file , AS2 ( out , __SP_H__ , r29 ) CR_TAB ) ; size ++ ; } if ( do_save ) { fprintf ( file , AS2 ( out , __SREG__ , __tmp_reg__ ) CR_TAB ) ; size ++ ; } else if ( do_sei ) { fprintf ( file , <STR_LIT> CR_TAB ) ; size ++ ; }

fprintf ( file , AS2 ( out , __SP_L__ , r28 ) <STR_LIT> ) ;


<s> } else if ( use_zero_reg ) { op [ <NUM_LIT> ] = zero_reg_rtx ; if ( len ) * len = <NUM_LIT> ; else strcat ( str , ( <STR_LIT> CR_TAB AS2 ( bld , % <NUM_LIT> , % <NUM_LIT> - <NUM_LIT> ) ) ) ; } else { op [ <NUM_LIT> ] = gen_rtx_REG ( QImode , ( ( true_regnum ( operands [ <NUM_LIT> ] ) - <NUM_LIT> ) & <NUM_LIT> ) + <NUM_LIT> ) ; op [ <NUM_LIT> ] = tmp_reg_rtx ; saved_in_tmp = <NUM_LIT> ; if ( len ) * len = <NUM_LIT> ; else strcat ( str , ( AS2 ( mov , % <NUM_LIT> , % <NUM_LIT> ) CR_TAB AS2 ( ldi , % <NUM_LIT> , % <NUM_LIT> ) ) ) ; } second_label = <NUM_LIT> ; } else if ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM ) { rtx op_mov [ <NUM_LIT> ] ; op [ <NUM_LIT> ] = op_mov [ <NUM_LIT> ] = tmp_reg_rtx ; op_mov [ <NUM_LIT> ] = op [ <NUM_LIT> ] ; if ( len ) out_movqi_r_mr ( insn , op_mov , len ) ; else output_asm_insn ( out_movqi_r_mr ( insn , op_mov , NULL ) , op_mov ) ; } else if ( register_operand ( operands [ <NUM_LIT> ] , QImode ) ) { if ( reg_unused_after ( insn , operands [ <NUM_LIT> ] ) ) op [ <NUM_LIT> ] = op [ <NUM_LIT> ] ;


<s> op [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; op [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; str [ <NUM_LIT> ] = <NUM_LIT> ; if ( len ) * len = <NUM_LIT> ; if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT ) { int scratch = ( GET_CODE ( PATTERN ( insn ) ) == PARALLEL ) ; int count = INTVAL ( operands [ <NUM_LIT> ] ) ; int max_len = <NUM_LIT> ; if ( count <= <NUM_LIT> ) { if ( len ) * len = <NUM_LIT> ; return ; } if ( count < <NUM_LIT> && ! scratch ) use_zero_reg = <NUM_LIT> ; if ( optimize_size ) max_len = t_len + ( scratch ? <NUM_LIT> : ( use_zero_reg ? <NUM_LIT> : <NUM_LIT> ) ) ; if ( t_len * count <= max_len ) { if ( len ) * len = t_len * count ; else { while ( count -- > <NUM_LIT> ) output_asm_insn ( template , op ) ; } return ; } if ( scratch ) { if ( ! len ) strcat ( str , AS2 ( ldi , % <NUM_LIT> , % <NUM_LIT> ) ) ; } else if ( use_zero_reg ) { op [ <NUM_LIT> ] = zero_reg_rtx ; if ( len ) * len = <NUM_LIT> ; else strcat ( str , ( <STR_LIT> CR_TAB AS2 ( bld , % <NUM_LIT> , % <NUM_LIT> - <NUM_LIT> ) ) ) ; } else { op [ <NUM_LIT> ] = gen_rtx_REG ( QImode , ( ( true_regnum ( operands [ <NUM_LIT> ] ) - <NUM_LIT> ) & <NUM_LIT> ) + <NUM_LIT> ) ; op [ <NUM_LIT> ] = tmp_reg_rtx ; saved_in_tmp = <NUM_LIT> ; if ( len ) * len = <NUM_LIT> ; else strcat ( str , ( AS2 ( mov , % <NUM_LIT> , % <NUM_LIT> ) CR_TAB AS2 ( ldi , % <NUM_LIT> , % <NUM_LIT> ) ) ) ; } second_label = <NUM_LIT> ; } else if ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM ) { rtx op_mov [ <NUM_LIT> ] ; op [ <NUM_LIT> ] = op_mov [ <NUM_LIT> ] = tmp_reg_rtx ; op_mov [ <NUM_LIT> ] = op [ <NUM_LIT> ] ; if ( len ) out_movqi_r_mr ( insn , op_mov , len ) ;

else output_asm_insn ( out_movqi_r_mr ( insn , op_mov , NULL ) , op_mov ) ;


<s> if ( test_hard_reg_class ( ADDW_REGS , SET_SRC ( PATTERN ( insn ) ) ) ) { if ( l ) * l = <NUM_LIT> ; return AS2 ( sbiw , % <NUM_LIT> , <NUM_LIT> ) ; } if ( l ) * l = <NUM_LIT> ; return ( AS2 ( cp , % A0 , __zero_reg__ ) CR_TAB AS2 ( cpc , % B0 , __zero_reg__ ) ) ;


<s> if ( compare_sign_p ( insn ) ) { if ( l ) * l = <NUM_LIT> ; return AS1 ( tst , % B0 ) ; } if ( reg_unused_after ( insn , SET_SRC ( PATTERN ( insn ) ) ) && compare_eq_p ( insn ) ) { if ( l ) * l = <NUM_LIT> ; return AS2 ( or , % A0 , % B0 ) ; } if ( test_hard_reg_class ( ADDW_REGS , SET_SRC ( PATTERN ( insn ) ) ) ) {


<s> } if ( test_hard_reg_class ( ADDW_REGS , SET_SRC ( PATTERN ( insn ) ) ) ) { if ( l ) * l = <NUM_LIT> ; return ( AS2 ( sbiw , % A0 , <NUM_LIT> ) CR_TAB AS2 ( cpc , % C0 , __zero_reg__ ) CR_TAB AS2 ( cpc , % D0 , __zero_reg__ ) ) ; } if ( l ) * l = <NUM_LIT> ;


<s> enum reg_class preferred_reload_class ( rtx x ATTRIBUTE_UNUSED , enum reg_class class ) { return class ;


<s> if ( code == 'p' ) print_operand_address ( file , XEXP ( addr , <NUM_LIT> ) ) ; else print_operand ( file , XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ; } else if ( GET_CODE ( addr ) == PLUS ) { print_operand_address ( file , XEXP ( addr , <NUM_LIT> ) ) ; if ( REGNO ( XEXP ( addr , <NUM_LIT> ) ) == REG_X ) fatal_insn ( <STR_LIT> , addr ) ; fputc ( '+' , file ) ; print_operand ( file , XEXP ( addr , <NUM_LIT> ) , code ) ; } else print_operand_address ( file , addr ) ; } else if ( GET_CODE ( x ) == CONST_DOUBLE ) { long val ; REAL_VALUE_TYPE rv ; if ( GET_MODE ( x ) != SFmode ) fatal_insn ( <STR_LIT> , x ) ; REAL_VALUE_FROM_CONST_DOUBLE ( rv , x ) ; REAL_VALUE_TO_TARGET_SINGLE ( rv , val ) ; fprintf ( file , <STR_LIT> , val ) ; } else if ( code == 'j' ) fputs ( cond_string ( GET_CODE ( x ) ) , file ) ; else if ( code == 'k' ) fputs ( cond_string ( reverse_condition ( GET_CODE ( x ) ) ) , file ) ; else print_operand_address ( file , x ) ;


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


<s> switch ( regno ) { case REG_X : return <STR_LIT> ;


<s> case REG_X : return <STR_LIT> ; case REG_Y : return <STR_LIT> ; case REG_Z : return <STR_LIT> ; default : gcc_unreachable ( ) ; } return NULL ;


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


<s> int reg_unused_after ( rtx insn , rtx reg ) {

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


<s> ( AS1 ( breq , . + <NUM_LIT> ) CR_TAB AS1 ( brpl , . + <NUM_LIT> ) CR_TAB AS1 ( jmp , % <NUM_LIT> ) ) ) ; else return ( len == <NUM_LIT> ? ( AS1 ( breq , % <NUM_LIT> ) CR_TAB AS1 ( brlt , % <NUM_LIT> ) ) : len == <NUM_LIT> ? ( AS1 ( breq , . + <NUM_LIT> ) CR_TAB AS1 ( brge , . + <NUM_LIT> ) CR_TAB AS1 ( rjmp , % <NUM_LIT> ) ) : ( AS1 ( breq , . + <NUM_LIT> ) CR_TAB AS1 ( brge , . + <NUM_LIT> ) CR_TAB AS1 ( jmp , % <NUM_LIT> ) ) ) ; case LEU : return ( len == <NUM_LIT> ? ( AS1 ( breq , % <NUM_LIT> ) CR_TAB AS1 ( brlo , % <NUM_LIT> ) ) : len == <NUM_LIT> ? ( AS1 ( breq , . + <NUM_LIT> ) CR_TAB AS1 ( brsh , . + <NUM_LIT> ) CR_TAB AS1 ( rjmp , % <NUM_LIT> ) ) : ( AS1 ( breq , . + <NUM_LIT> ) CR_TAB AS1 ( brsh , . + <NUM_LIT> ) CR_TAB AS1 ( jmp , % <NUM_LIT> ) ) ) ; default : if ( reverse ) { switch ( len ) { case <NUM_LIT> : return AS1 ( br % k1 , % <NUM_LIT> ) ; case <NUM_LIT> : return ( AS1 ( br % j1 , . + <NUM_LIT> ) CR_TAB AS1 ( rjmp , % <NUM_LIT> ) ) ; default :

return ( AS1 ( br % j1 , . + <NUM_LIT> ) CR_TAB AS1 ( jmp , % <NUM_LIT> ) ) ;


<s> int regno = true_regnum ( x ) ; if ( regno < <NUM_LIT> ) return <NUM_LIT> ; if ( TEST_HARD_REG_CLASS ( class , regno ) ) return <NUM_LIT> ;


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


<s> int k ; int * t = len ; if ( ! len ) len = & k ; switch ( INTVAL ( operands [ <NUM_LIT> ] ) ) { default : if ( INTVAL ( operands [ <NUM_LIT> ] ) < <NUM_LIT> ) break ; if ( AVR_HAVE_MOVW ) return * len = <NUM_LIT> , ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> ) ; * len = <NUM_LIT> ; return ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> ) ; case <NUM_LIT> : { int reg0 = true_regnum ( operands [ <NUM_LIT> ] ) ; int reg1 = true_regnum ( operands [ <NUM_LIT> ] ) ; * len = <NUM_LIT> ; if ( reg0 >= reg1 ) return ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> ) ; else return ( <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> CR_TAB <STR_LIT> ) ; } case <NUM_LIT> :


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


<s> if ( TARGET_SKIP_BUG || ! insn || <NUM_LIT> != get_attr_length ( insn ) ) { return false ; } switch ( INSN_CODE ( insn ) ) { default : return false ; case CODE_FOR_movqi_insn : case CODE_FOR_movuqq_insn : case CODE_FOR_movqq_insn : { 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 cost = <NUM_LIT> ; if ( GET_CODE ( x ) == PLUS && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) && ( REG_P ( XEXP ( x , <NUM_LIT> ) ) || GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == SUBREG ) ) { if ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) >= <NUM_LIT> ) cost = <NUM_LIT> ;


<s> if ( GET_CODE ( x ) == PLUS && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) && ( REG_P ( XEXP ( x , <NUM_LIT> ) ) || GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == SUBREG ) ) { if ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) >= <NUM_LIT> ) cost = <NUM_LIT> ; } else if ( CONSTANT_ADDRESS_P ( x ) ) {

if ( optimize > <NUM_LIT> && io_address_operand ( x , QImode ) ) cost = <NUM_LIT> ;


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


<s> int msb ; rtx sym = src ; rtx reg = gen_reg_rtx ( PSImode ) ; while ( CONST == GET_CODE ( sym ) || PLUS == GET_CODE ( sym ) ) sym = XEXP ( sym , <NUM_LIT> ) ; if ( SYMBOL_REF == GET_CODE ( 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 ) ;


<s> return avr_addr_space_address_mode ( as ) ;


<s> case ADJUST_LEN_LPM : avr_out_lpm ( 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 ;

case ADJUST_LEN_LSHRPSI : avr_out_lshrpsi3 ( insn , op , & len ) ; break ;


for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( order_0 ) ; ++ i ) reg_alloc_order [ i ] = order [ i ] ;


<s> rtx mem = decl == NULL_TREE ? NULL_RTX : DECL_RTL ( decl ) ; rtx symbol ;

if ( mem != NULL_RTX && MEM_P ( mem ) && GET_CODE ( ( symbol = XEXP ( mem , <NUM_LIT> ) ) ) == SYMBOL_REF && ( SYMBOL_REF_FLAGS ( symbol ) & ( SYMBOL_FLAG_IO | SYMBOL_FLAG_ADDRESS ) ) ) {


<s> static void avr_asm_function_begin_epilogue ( FILE * file ) { fprintf ( file , <STR_LIT> ) ;


<s> if ( cfun -> machine -> is_naked ) { fputs ( <STR_LIT> , file ) ; } 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> , get_frame_size ( ) ) ; fprintf ( file , <STR_LIT> , cfun -> machine -> stack_usage ) ;


<s> flag_data_sections = fdata ; flags = frodata -> common . flags ; } if ( frodata != readonly_data_section && flags & SECTION_NAMED ) { unsigned int i ; static const char * const prefix [ ] = { <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> } ; for ( i = <NUM_LIT> ; i < sizeof ( prefix ) / sizeof ( * prefix ) ; i += <NUM_LIT> ) { const char * old_prefix = prefix [ i ] ; const char * new_prefix = prefix [ i + <NUM_LIT> ] ; const char * name = frodata -> named . name ; if ( STR_PREFIX_P ( name , old_prefix ) ) { const char * rname = ACONCAT ( ( new_prefix , name + strlen ( old_prefix ) , NULL ) ) ; flags &= ~ SECTION_CODE ;


<s> frodata = default_function_rodata_section ( decl ) ; flag_data_sections = fdata ; flags = frodata -> common . flags ; } if ( frodata != readonly_data_section && flags & SECTION_NAMED ) { unsigned int i ; static const char * const prefix [ ] = { <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> } ; for ( i = <NUM_LIT> ; i < sizeof ( prefix ) / sizeof ( * prefix ) ; i += <NUM_LIT> ) { const char * old_prefix = prefix [ i ] ; const char * new_prefix = prefix [ i + <NUM_LIT> ] ; const char * name = frodata -> named . name ;

if ( STR_PREFIX_P ( name , old_prefix ) ) {


readonly_data_section -> unnamed . callback = avr_output_data_section_asm_op ;


<s> else { if ( n_words < <NUM_LIT> ) * plen = - n_words ; else * plen += n_words ; } return <STR_LIT> ;


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


<s> const char * new_prefix = avr_addrspace [ as ] . section_name ; if ( STR_PREFIX_P ( name , old_prefix ) ) { const char * sname = ACONCAT ( ( new_prefix , name + strlen ( old_prefix ) , NULL ) ) ; default_elf_asm_named_section ( sname , flags , decl ) ;


<s> assemble_name ( stream , name ) ; fprintf ( stream , <STR_LIT> ) ; } if ( SYMBOL_REF_FLAGS ( symbol ) & SYMBOL_FLAG_ADDRESS ) { assemble_name ( stream , name ) ; fprintf ( stream , <STR_LIT> , ( long ) INTVAL ( avr_eval_addr_attrib ( symbol ) ) ) ; } else if ( local_p ) error_at ( DECL_SOURCE_LOCATION ( decl ) , <STR_LIT> , decl ) ; return ;


<s> const char * sname = ACONCAT ( ( new_prefix , name + strlen ( old_prefix ) , NULL ) ) ; return get_section ( sname , sect -> common . flags , 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 ) ;


<s> rtx xval = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_subhi3 ( xval , virtual_stack_vars_rtx , gen_int_mode ( STARTING_FRAME_OFFSET , Pmode ) ) ) ; return xval ;


emit_insn ( gen_subhi3 ( xval , virtual_stack_vars_rtx , gen_int_mode ( STARTING_FRAME_OFFSET , Pmode ) ) ) ;


<s> call_used_regs [ i ] = <NUM_LIT> ; } for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( tiny_reg_alloc_order ) ; i ++ ) { reg_alloc_order [ i ] = tiny_reg_alloc_order [ i ] ; } CLEAR_HARD_REG_SET ( reg_class_contents [ ( int ) ADDW_REGS ] ) ; CLEAR_HARD_REG_SET ( reg_class_contents [ ( int ) NO_LD_REGS ] ) ; }


<s> if ( target == NULL_RTX || GET_MODE ( target ) != tmode || ! insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ( target , tmode ) ) { target = gen_reg_rtx ( tmode ) ; } for ( n = <NUM_LIT> ; n < n_args ; n ++ ) { tree arg = CALL_EXPR_ARG ( exp , n ) ; rtx op = expand_expr ( arg , NULL_RTX , VOIDmode , EXPAND_NORMAL ) ; machine_mode opmode = GET_MODE ( op ) ; machine_mode mode = insn_data [ icode ] . operand [ n + <NUM_LIT> ] . mode ; if ( ( opmode == SImode || opmode == VOIDmode ) && mode == HImode ) { opmode = HImode ; op = gen_lowpart ( HImode , op ) ; } gcc_assert ( opmode == mode || opmode == VOIDmode ) ; if ( ! insn_data [ icode ] . operand [ n + <NUM_LIT> ] . predicate ( op , mode ) ) op = copy_to_mode_reg ( mode , op ) ; xop [ n ] = op ; } switch ( n_args ) { case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target , xop [ <NUM_LIT> ] ) ; break ;

case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target , xop [ <NUM_LIT> ] , xop [ <NUM_LIT> ] ) ; break ;


<s> int n , n_args = call_expr_nargs ( exp ) ; machine_mode tmode = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; gcc_assert ( n_args >= <NUM_LIT> && n_args <= <NUM_LIT> ) ; if ( target == NULL_RTX || GET_MODE ( target ) != tmode || ! insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ( target , tmode ) ) { target = gen_reg_rtx ( tmode ) ; } for ( n = <NUM_LIT> ; n < n_args ; n ++ ) { tree arg = CALL_EXPR_ARG ( exp , n ) ; rtx op = expand_expr ( arg , NULL_RTX , VOIDmode , EXPAND_NORMAL ) ; machine_mode opmode = GET_MODE ( op ) ; machine_mode mode = insn_data [ icode ] . operand [ n + <NUM_LIT> ] . mode ; if ( ( opmode == SImode || opmode == VOIDmode ) && mode == HImode ) { opmode = HImode ;


<s> rtx a_hi8 = NULL_RTX ; if ( avr_mem_flash_p ( xop [ <NUM_LIT> ] ) ) return false ; if ( ! CONST_INT_P ( xop [ <NUM_LIT> ] ) ) return false ; count = INTVAL ( xop [ <NUM_LIT> ] ) ; if ( count <= <NUM_LIT> ) return false ; a_src = XEXP ( xop [ <NUM_LIT> ] , <NUM_LIT> ) ; a_dest = XEXP ( xop [ <NUM_LIT> ] , <NUM_LIT> ) ; if ( PSImode == GET_MODE ( a_src ) ) { gcc_assert ( as == ADDR_SPACE_MEMX ) ; loop_mode = ( count < <NUM_LIT> ) ? QImode : HImode ; loop_reg = gen_rtx_REG ( loop_mode , <NUM_LIT> ) ; emit_move_insn ( loop_reg , gen_int_mode ( count , loop_mode ) ) ; addr1 = simplify_gen_subreg ( HImode , a_src , PSImode , <NUM_LIT> ) ; a_hi8 = simplify_gen_subreg ( QImode , a_src , PSImode , <NUM_LIT> ) ; } else { int segment = avr_addrspace [ as ] . segment ; if ( segment && avr_n_flash > <NUM_LIT> ) { a_hi8 = GEN_INT ( segment ) ; emit_move_insn ( rampz_rtx , a_hi8 = copy_to_mode_reg ( QImode , a_hi8 ) ) ;


<s> tree io_low_attr = lookup_attribute ( <STR_LIT> , attr ) ; tree io_attr = lookup_attribute ( <STR_LIT> , attr ) ; tree addr_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> default_encode_section_info ( decl , rtl , new_decl_p ) ; if ( decl && DECL_P ( decl ) && TREE_CODE ( decl ) != FUNCTION_DECL && MEM_P ( rtl ) && SYMBOL_REF == GET_CODE ( XEXP ( rtl , <NUM_LIT> ) ) ) { rtx sym = XEXP ( rtl , <NUM_LIT> ) ; 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 ( - <NUM_LIT> == avr_progmem_p ( decl , attr ) ) as = ADDR_SPACE_FLASH ;


<s> if ( ! attr || ! TREE_VALUE ( attr ) ) attr = lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ; gcc_assert ( attr && TREE_VALUE ( attr ) && TREE_VALUE ( TREE_VALUE ( attr ) ) ) ; return GEN_INT ( TREE_INT_CST_LOW ( TREE_VALUE ( TREE_VALUE ( attr ) ) ) ) ; }


<s> 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_INSERT_BITS : { arg0 = CALL_EXPR_ARG ( exp , <NUM_LIT> ) ; op0 = expand_expr ( arg0 , NULL_RTX , VOIDmode , EXPAND_NORMAL ) ; if ( ! CONST_INT_P ( op0 ) ) { error ( <STR_LIT> <STR_LIT> , bname ) ; return target ; } break ; } case AVR_BUILTIN_ROUNDHR : case AVR_BUILTIN_ROUNDUHR : case AVR_BUILTIN_ROUNDR : case AVR_BUILTIN_ROUNDUR : case AVR_BUILTIN_ROUNDLR : case AVR_BUILTIN_ROUNDULR : case AVR_BUILTIN_ROUNDLLR : case AVR_BUILTIN_ROUNDULLR : case AVR_BUILTIN_ROUNDHK : case AVR_BUILTIN_ROUNDUHK : case AVR_BUILTIN_ROUNDK : case AVR_BUILTIN_ROUNDUK : case AVR_BUILTIN_ROUNDLK : case AVR_BUILTIN_ROUNDULK : case AVR_BUILTIN_ROUNDLLK : case AVR_BUILTIN_ROUNDULLK : if ( TREE_CODE ( CALL_EXPR_ARG ( exp , <NUM_LIT> ) ) != INTEGER_CST ) break ; int rbit = ( int ) TREE_INT_CST_LOW ( CALL_EXPR_ARG ( exp , <NUM_LIT> ) ) ; if ( rbit >= ( int ) GET_MODE_FBIT ( mode ) ) {

warning ( OPT_Wextra , <STR_LIT> <STR_LIT> , rbit , GET_MODE_FBIT ( mode ) ) ;


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


<s> void avr_expand_prologue ( void ) { HARD_REG_SET set ; HOST_WIDE_INT size ; size = get_frame_size ( ) + avr_outgoing_args_size ( ) ; cfun -> machine -> stack_usage = <NUM_LIT> ; if ( cfun -> machine -> is_naked ) { return ; } avr_regs_to_save ( & set ) ; if ( cfun -> machine -> is_interrupt || cfun -> machine -> is_signal ) { 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 ) ; } if ( AVR_HAVE_RAMPY && ( frame_pointer_needed || ( TEST_HARD_REG_BIT ( set , REG_Y ) && TEST_HARD_REG_BIT ( set , REG_Y + <NUM_LIT> ) ) ) ) {

emit_push_sfr ( rampy_rtx , false , true ) ;


<s> 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> else fprintf ( asm_out_file , <STR_LIT> , rtx_cost ( PATTERN ( insn ) , INSN , <NUM_LIT> , optimize_insn_for_speed_p ( ) ) ) ; }


<s> } 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 ] ) ) ) { return reg ; } if ( df_regs_ever_live_p ( regno ) && reg_unused_after ( insn , reg ) ) { return reg ; } }


<s> return ( AVR_TINY ? r >= <NUM_LIT> && r <= <NUM_LIT> : r >= <NUM_LIT> && r <= <NUM_LIT> ) ;


<s> decl_callee = TREE_TYPE ( decl_callee ) ; } else { decl_callee = fntype_callee ; while ( FUNCTION_TYPE != TREE_CODE ( decl_callee ) && METHOD_TYPE != TREE_CODE ( decl_callee ) ) { decl_callee = TREE_TYPE ( decl_callee ) ; } } if ( cfun -> machine -> is_interrupt || cfun -> machine -> is_signal || cfun -> machine -> is_naked || avr_naked_function_p ( decl_callee ) || ( avr_OS_task_function_p ( decl_callee ) != cfun -> machine -> is_OS_task ) || ( avr_OS_main_function_p ( decl_callee ) != cfun -> machine -> is_OS_main ) ) {


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


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

tree other = lookup_attribute ( * p , attribs ) ;


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


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


<s> int avr_hard_regno_mode_ok ( int regno , machine_mode mode ) { if ( GET_MODE_SIZE ( mode ) == <NUM_LIT> ) return <NUM_LIT> ;

if ( GET_MODE_SIZE ( mode ) >= <NUM_LIT> && regno >= REG_X ) return <NUM_LIT> ;


<s> unsigned int map = UINTVAL ( ival ) & GET_MODE_MASK ( SImode ) ; return <NUM_LIT> != avr_map_metric ( map , MAP_MASK_PREIMAGE_F ) ;


<s> rampy_rtx = gen_rtx_MEM ( QImode , GEN_INT ( avr_addr . rampy ) ) ; rampz_rtx = gen_rtx_MEM ( QImode , GEN_INT ( avr_addr . rampz ) ) ; xstring_empty = gen_rtx_CONST_STRING ( VOIDmode , <STR_LIT> ) ; xstring_e = gen_rtx_CONST_STRING ( VOIDmode , <STR_LIT> ) ;

if ( AVR_TINY ) avr_have_dimode = false ;


<s> error ( <STR_LIT> <STR_LIT> , node , avr_addrspace [ as ] . name , 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 ) ;


<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 , 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 ) ) {


<s> if ( - <NUM_LIT> <= jump_distance && jump_distance <= <NUM_LIT> ) return <NUM_LIT> ; else if ( - <NUM_LIT> <= jump_distance && jump_distance <= <NUM_LIT> ) return <NUM_LIT> ; else if ( AVR_HAVE_JMP_CALL ) return <NUM_LIT> ;


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


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


<s> if ( <NUM_LIT> && ( GET_CODE ( x ) == POST_INC || GET_CODE ( x ) == PRE_DEC ) ) { push_reload ( XEXP ( x , <NUM_LIT> ) , XEXP ( x , <NUM_LIT> ) , & XEXP ( x , <NUM_LIT> ) , & XEXP ( x , <NUM_LIT> ) , POINTER_REGS , GET_MODE ( x ) , GET_MODE ( x ) , <NUM_LIT> , <NUM_LIT> , opnum , RELOAD_OTHER ) ; if ( avr_log . legitimize_reload_address ) avr_edump ( <STR_LIT> , POINTER_REGS , XEXP ( x , <NUM_LIT> ) , XEXP ( x , <NUM_LIT> ) ) ; return x ; } if ( GET_CODE ( x ) == PLUS && REG_P ( XEXP ( x , <NUM_LIT> ) ) && <NUM_LIT> == reg_equiv_constant ( REGNO ( XEXP ( x , <NUM_LIT> ) ) ) && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) && INTVAL ( XEXP ( x , <NUM_LIT> ) ) >= <NUM_LIT> ) { bool fit = INTVAL ( XEXP ( x , <NUM_LIT> ) ) <= MAX_LD_OFFSET ( mode ) ; if ( fit ) { if ( reg_equiv_address ( REGNO ( XEXP ( x , <NUM_LIT> ) ) ) != <NUM_LIT> ) { int regno = REGNO ( XEXP ( x , <NUM_LIT> ) ) ; rtx mem = mk_memloc ( x , regno ) ; push_reload ( XEXP ( mem , <NUM_LIT> ) , NULL_RTX , & XEXP ( mem , <NUM_LIT> ) , NULL , POINTER_REGS , Pmode , VOIDmode , <NUM_LIT> , <NUM_LIT> , <NUM_LIT> , ( enum reload_type ) addr_type ) ; if ( avr_log . legitimize_reload_address ) avr_edump ( <STR_LIT> , POINTER_REGS , XEXP ( mem , <NUM_LIT> ) , NULL_RTX ) ; push_reload ( mem , NULL_RTX , & XEXP ( x , <NUM_LIT> ) , NULL , BASE_POINTER_REGS , GET_MODE ( x ) , VOIDmode , <NUM_LIT> , <NUM_LIT> , opnum , ( enum reload_type ) type ) ; if ( avr_log . legitimize_reload_address ) avr_edump ( <STR_LIT> , BASE_POINTER_REGS , mem , NULL_RTX ) ;