<s> const char * msp430_select_hwmult_lib ( int argc ATTRIBUTE_UNUSED , const char * * argv ATTRIBUTE_UNUSED ) { int i ; switch ( argc ) { case <NUM_LIT> : if ( strcasecmp ( argv [ <NUM_LIT> ] , <STR_LIT> ) ) error ( <STR_LIT> , argv [ <NUM_LIT> ] ) ; break ; default : if ( strcasecmp ( argv [ <NUM_LIT> ] , <STR_LIT> ) == <NUM_LIT> ) { static struct hwmult_options { const char * name ; const char * lib ; } hwmult_options [ ] = { { <STR_LIT> , <STR_LIT> } , { <STR_LIT> , <STR_LIT> } , { <STR_LIT> , <STR_LIT> } , { <STR_LIT> , <STR_LIT> } , { <STR_LIT> , <STR_LIT> } } ; for ( i = ARRAY_SIZE ( hwmult_options ) ; i -- ; ) if ( strcasecmp ( argv [ argc - <NUM_LIT> ] , hwmult_options [ i ] . name ) == <NUM_LIT> ) return hwmult_options [ i ] . lib ; } else if ( strcasecmp ( argv [ <NUM_LIT> ] , <STR_LIT> ) == <NUM_LIT> ) { for ( i = ARRAY_SIZE ( msp430_mcu_data ) ; i -- ; ) if ( strcasecmp ( argv [ argc - <NUM_LIT> ] , msp430_mcu_data [ i ] . name ) == <NUM_LIT> ) { switch ( msp430_mcu_data [ i ] . hwmpy ) { case <NUM_LIT> : return <STR_LIT> ;


<s> if ( msp430_check_env_var_for_devices ( & devices_csv_path ) ) return NULL ; return concat ( <STR_LIT> , msp430_dirname ( devices_csv_path ) , NULL ) ;


<s> const char * msp430_get_linker_devices_include_path ( int argc ATTRIBUTE_UNUSED , const char * * argv ATTRIBUTE_UNUSED ) { char * devices_csv_path ; if ( msp430_check_env_var_for_devices ( & devices_csv_path ) ) return NULL ;

return concat ( <STR_LIT> , msp430_dirname ( devices_csv_path ) , NULL ) ;


<s> if ( strcmp ( argv [ <NUM_LIT> ] , <STR_LIT> ) != <NUM_LIT> ) return argv [ <NUM_LIT> ] ; else if ( ( argc == <NUM_LIT> ) && ( strcmp ( argv [ <NUM_LIT> ] , <STR_LIT> ) == <NUM_LIT> ) ) return argv [ <NUM_LIT> ] ; return <STR_LIT> ;


<s> error ( <STR_LIT> ) ; return NULL ; } msp430_extract_mcu_data ( argv [ <NUM_LIT> ] ) ; if ( extracted_mcu_data . name != NULL ) { switch ( extracted_mcu_data . revision ) { case <NUM_LIT> : return <STR_LIT> ;


<s> static struct hwmult_options { const char * name ; const char * lib ; } hwmult_options [ ] = { { <STR_LIT> , <STR_LIT> } , { <STR_LIT> , <STR_LIT> } , { <STR_LIT> , <STR_LIT> } , { <STR_LIT> , <STR_LIT> } , { <STR_LIT> , <STR_LIT> } } ; for ( i = ARRAY_SIZE ( hwmult_options ) ; i -- ; ) if ( strcasecmp ( argv [ argc - <NUM_LIT> ] , hwmult_options [ i ] . name ) == <NUM_LIT> ) return hwmult_options [ i ] . lib ; } else if ( strcasecmp ( argv [ <NUM_LIT> ] , <STR_LIT> ) == <NUM_LIT> ) { msp430_extract_mcu_data ( argv [ argc - <NUM_LIT> ] ) ; if ( extracted_mcu_data . name != NULL ) { switch ( extracted_mcu_data . hwmpy ) { case <NUM_LIT> : return <STR_LIT> ; case <NUM_LIT> : case <NUM_LIT> : return <STR_LIT> ; case <NUM_LIT> : return <STR_LIT> ; case <NUM_LIT> : return <STR_LIT> ; default : gcc_unreachable ( ) ; break ; } } } else error ( <STR_LIT> , argv [ <NUM_LIT> ] ) ; break ;


<s> else if ( strcmp ( argv [ <NUM_LIT> ] , <STR_LIT> ) == <NUM_LIT> ) msp430_warn_devices_csv = atoi ( argv [ <NUM_LIT> ] ) ; else if ( strcmp ( argv [ <NUM_LIT> ] , <STR_LIT> ) == <NUM_LIT> ) msp430_devices_csv_loc = argv [ <NUM_LIT> ] ; else error ( <STR_LIT> , argv [ <NUM_LIT> ] , argv [ <NUM_LIT> ] ) ;


<s> if ( argc != <NUM_LIT> ) error ( <STR_LIT> ) ; else if ( strcmp ( argv [ <NUM_LIT> ] , <STR_LIT> ) == <NUM_LIT> ) msp430_warn_devices_csv = atoi ( argv [ <NUM_LIT> ] ) ; else if ( strcmp ( argv [ <NUM_LIT> ] , <STR_LIT> ) == <NUM_LIT> ) msp430_devices_csv_loc = argv [ <NUM_LIT> ] ; else error ( <STR_LIT> , argv [ <NUM_LIT> ] , argv [ <NUM_LIT> ] ) ; return NULL ;


<s> char * t_path = * path ; int len = strlen ( t_path ) ; int i ;

for ( i = <NUM_LIT> ; i < len ; i ++ ) if ( IS_DIR_SEPARATOR ( t_path [ i ] ) ) t_path [ i ] = DIR_SEPARATOR ;


<s> char * t_path = * path ; int len = strlen ( t_path ) ; int i ; for ( i = <NUM_LIT> ; i < len ; i ++ ) if ( IS_DIR_SEPARATOR ( t_path [ i ] ) ) t_path [ i ] = DIR_SEPARATOR ;


<s> static void extract_devices_dir_from_collect_gcc ( char * * devices_loc ) { char * t_devices_loc = * devices_loc ;


<s> temp = gcc_exec_prefix + len - sizeof ( <STR_LIT> ) + <NUM_LIT> ; if ( IS_DIR_SEPARATOR ( * temp ) && filename_ncmp ( temp + <NUM_LIT> , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> && IS_DIR_SEPARATOR ( temp [ <NUM_LIT> ] ) && filename_ncmp ( temp + <NUM_LIT> , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) { len -= sizeof ( <STR_LIT> ) - <NUM_LIT> ; gcc_exec_prefix [ len + <NUM_LIT> ] = ( char ) <NUM_LIT> ; * devices_loc = concat ( gcc_exec_prefix , rest_of_devices_path , NULL ) ;


<s> int len = strlen ( gcc_exec_prefix ) ; if ( len > ( int ) sizeof ( <STR_LIT> ) - <NUM_LIT> && ( IS_DIR_SEPARATOR ( gcc_exec_prefix [ len - <NUM_LIT> ] ) ) ) { temp = gcc_exec_prefix + len - sizeof ( <STR_LIT> ) + <NUM_LIT> ; if ( IS_DIR_SEPARATOR ( * temp ) && filename_ncmp ( temp + <NUM_LIT> , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> && IS_DIR_SEPARATOR ( temp [ <NUM_LIT> ] ) && filename_ncmp ( temp + <NUM_LIT> , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) { len -= sizeof ( <STR_LIT> ) - <NUM_LIT> ; gcc_exec_prefix [ len + <NUM_LIT> ] = ( char ) <NUM_LIT> ; * devices_loc = concat ( gcc_exec_prefix , rest_of_devices_path , NULL ) ; return ; } }


<s> t_devices_loc = xstrdup ( val ) ; if ( i == MSP430_GCC_INCLUDE_DIR ) { if ( ! IS_DIR_SEPARATOR ( t_devices_loc [ strlen ( t_devices_loc ) - <NUM_LIT> ] ) ) t_devices_loc = concat ( t_devices_loc , dirsep , NULL ) ; } else if ( i == GCC_EXEC_PREFIX ) extract_devices_dir_from_exec_prefix ( & t_devices_loc ) ; else if ( i == COLLECT_GCC ) extract_devices_dir_from_collect_gcc ( & t_devices_loc ) ; t_devices_loc = concat ( t_devices_loc , <STR_LIT> , NULL ) ; devices_csv_file = fopen ( t_devices_loc , <STR_LIT> ) ; if ( devices_csv_file != NULL ) { fclose ( devices_csv_file ) ;


<s> const char dirsep [ <NUM_LIT> ] = { DIR_SEPARATOR , <NUM_LIT> } ; FILE * devices_file = NULL ; char * local_devices_csv_loc = NULL ; int i ; if ( msp430_devices_csv_loc || derived_devices_csv_loc ) return NULL ; for ( i = <NUM_LIT> ; i < argc ; i ++ ) { char * inc_path = xstrdup ( argv [ i ] ) ; canonicalize_path_dirsep ( & inc_path ) ; if ( ! IS_DIR_SEPARATOR ( inc_path [ strlen ( inc_path ) - <NUM_LIT> ] ) ) inc_path = concat ( inc_path , dirsep , NULL ) ; local_devices_csv_loc = concat ( inc_path , <STR_LIT> , NULL ) ; devices_file = fopen ( local_devices_csv_loc , <STR_LIT> ) ; if ( devices_file != NULL ) { fclose ( devices_file ) ; derived_devices_csv_loc = local_devices_csv_loc ; return concat ( <STR_LIT> , local_devices_csv_loc , NULL ) ; }


<s> for ( i = <NUM_LIT> ; i < argc ; i ++ ) { char * inc_path = xstrdup ( argv [ i ] ) ; canonicalize_path_dirsep ( & inc_path ) ; if ( ! IS_DIR_SEPARATOR ( inc_path [ strlen ( inc_path ) - <NUM_LIT> ] ) ) inc_path = concat ( inc_path , dirsep , NULL ) ; local_devices_csv_loc = concat ( inc_path , <STR_LIT> , NULL ) ; devices_file = fopen ( local_devices_csv_loc , <STR_LIT> ) ; if ( devices_file != NULL ) { fclose ( devices_file ) ; derived_devices_csv_loc = local_devices_csv_loc ; return concat ( <STR_LIT> , local_devices_csv_loc , NULL ) ;


<s> default : gcc_unreachable ( ) ; } for ( i = ARRAY_SIZE ( hard_msp430_mcu_data ) ; i -- ; ) if ( strcasecmp ( mcu_name , hard_msp430_mcu_data [ i ] . name ) == <NUM_LIT> ) { extracted_mcu_data = hard_msp430_mcu_data [ i ] ; break ; } if ( extracted_mcu_data . name != NULL ) { switch ( extracted_mcu_data . hwmpy ) { case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : break ; default : error ( <STR_LIT> <STR_LIT> , i , hard_msp430_mcu_data [ i ] . hwmpy ) ; break ; } switch ( extracted_mcu_data . revision ) { case <NUM_LIT> : case <NUM_LIT> :


<s> if ( mcu_name == NULL || executed == <NUM_LIT> ) return ; executed = <NUM_LIT> ; switch ( parse_devices_csv ( mcu_name ) ) { case <NUM_LIT> : return ; case <NUM_LIT> : break ; case <NUM_LIT> : devices_csv_not_found = <NUM_LIT> ; break ; default : gcc_unreachable ( ) ; } for ( i = ARRAY_SIZE ( hard_msp430_mcu_data ) ; i -- ; ) if ( strcasecmp ( mcu_name , hard_msp430_mcu_data [ i ] . name ) == <NUM_LIT> ) { extracted_mcu_data = hard_msp430_mcu_data [ i ] ; break ; } if ( extracted_mcu_data . name != NULL ) { switch ( extracted_mcu_data . hwmpy ) { case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : break ; default : error ( <STR_LIT> <STR_LIT> , i , hard_msp430_mcu_data [ i ] . hwmpy ) ;


<s> static int parse_devices_csv ( const char * mcu_name ) { if ( msp430_devices_csv_loc != NULL ) return parse_devices_csv_1 ( msp430_devices_csv_loc , mcu_name ) ; else if ( derived_devices_csv_loc != NULL ) return parse_devices_csv_1 ( derived_devices_csv_loc , mcu_name ) ; if ( msp430_check_env_var_for_devices ( & derived_devices_csv_loc ) ) return <NUM_LIT> ;


<s> if ( arg1mode == SImode ) { arg2 = <NUM_LIT> ; arg1sz = <NUM_LIT> ; } else if ( arg1mode == DImode ) { arg1 = <NUM_LIT> ; arg1sz = <NUM_LIT> ; arg2 = <NUM_LIT> ; } if ( const_variants && CONST_INT_P ( operands [ <NUM_LIT> ] ) && INTVAL ( operands [ <NUM_LIT> ] ) >= <NUM_LIT> && INTVAL ( operands [ <NUM_LIT> ] ) <= <NUM_LIT> ) { int len = strlen ( helper_name ) + <NUM_LIT> ; helper_const = ( char * ) xmalloc ( len ) ; snprintf ( helper_const , len , <STR_LIT> , helper_name , ( int ) INTVAL ( operands [ <NUM_LIT> ] ) ) ; } emit_move_insn ( gen_rtx_REG ( arg1mode , arg1 ) , operands [ <NUM_LIT> ] ) ; if ( ! helper_const ) emit_move_insn ( gen_rtx_REG ( arg2mode , arg2 ) , operands [ <NUM_LIT> ] ) ; if ( expand_mpy ) { if ( msp430_use_f5_series_hwmult ( ) ) fsym = gen_rtx_SYMBOL_REF ( VOIDmode , concat ( helper_name , <STR_LIT> , NULL ) ) ; else if ( msp430_use_32bit_hwmult ( ) ) { if ( arg1mode == HImode ) fsym = gen_rtx_SYMBOL_REF ( VOIDmode , concat ( helper_name , <STR_LIT> , NULL ) ) ; else fsym = gen_rtx_SYMBOL_REF ( VOIDmode , concat ( helper_name , <STR_LIT> , NULL ) ) ; } else if ( msp430_use_16bit_hwmult ( ) ) fsym = gen_rtx_SYMBOL_REF ( VOIDmode , concat ( helper_name , <STR_LIT> , NULL ) ) ; else fsym = gen_rtx_SYMBOL_REF ( VOIDmode , helper_name ) ; } else fsym = gen_rtx_SYMBOL_REF ( VOIDmode , helper_const ? helper_const : helper_name ) ; c = gen_call_value_internal ( gen_rtx_REG ( arg0mode , <NUM_LIT> ) , fsym , GEN_INT ( <NUM_LIT> ) ) ; c = emit_call_insn ( c ) ;


<s> int len = strlen ( helper_name ) + <NUM_LIT> ; helper_const = ( char * ) xmalloc ( len ) ; snprintf ( helper_const , len , <STR_LIT> , helper_name , ( int ) INTVAL ( operands [ <NUM_LIT> ] ) ) ; } emit_move_insn ( gen_rtx_REG ( arg1mode , arg1 ) , operands [ <NUM_LIT> ] ) ; if ( ! helper_const ) emit_move_insn ( gen_rtx_REG ( arg2mode , arg2 ) , operands [ <NUM_LIT> ] ) ; if ( expand_mpy ) { if ( msp430_use_f5_series_hwmult ( ) ) fsym = gen_rtx_SYMBOL_REF ( VOIDmode , concat ( helper_name , <STR_LIT> , NULL ) ) ; else if ( msp430_use_32bit_hwmult ( ) ) { if ( arg1mode == HImode ) fsym = gen_rtx_SYMBOL_REF ( VOIDmode , concat ( helper_name , <STR_LIT> , NULL ) ) ; else fsym = gen_rtx_SYMBOL_REF ( VOIDmode , concat ( helper_name , <STR_LIT> , NULL ) ) ; } else if ( msp430_use_16bit_hwmult ( ) ) fsym = gen_rtx_SYMBOL_REF ( VOIDmode , concat ( helper_name , <STR_LIT> , NULL ) ) ;

else fsym = gen_rtx_SYMBOL_REF ( VOIDmode , helper_name ) ;


else if ( ! TARGET_LARGE && msp430_code_region == MSP430_REGION_UPPER ) error ( <STR_LIT> <STR_LIT> ) ;


<s> else if ( strncmp ( name , either_prefix , strlen ( either_prefix ) ) == <NUM_LIT> ) name += strlen ( either_prefix ) ; return default_section_type_flags ( decl , name , reloc ) ;


<s> else if ( strncmp ( name , either_prefix , strlen ( either_prefix ) ) == <NUM_LIT> ) name += strlen ( either_prefix ) ;

return default_section_type_flags ( decl , name , reloc ) ;


<s> case MEM : if ( msp430_is_mem_indirect ( dst ) ) return cost_p -> ind ; else return cost_p -> mem ; case CONST_INT : case CONST_FIXED : case CONST_DOUBLE : case SYMBOL_REF : case CONST : return double_op_cost_p -> imm2r + cost_p -> reg ;


<s> static inline bool is_naked_func ( void ) { return is_attr_func ( <STR_LIT> ) ;


<s> return msp430_is_interrupt_func ( ) && is_attr_func ( <STR_LIT> ) ;


<s> if ( REGNO ( operands [ <NUM_LIT> ] ) == REGNO ( operands [ <NUM_LIT> ] ) ) return <STR_LIT> ; if ( ! msp430x ) return <STR_LIT> ; if ( REGNO ( operands [ <NUM_LIT> ] ) + <NUM_LIT> == REGNO ( operands [ <NUM_LIT> ] ) ) return <STR_LIT> ; return <STR_LIT> ;


<s> bool msp430_addr_space_legitimate_address_p ( machine_mode mode , rtx x , bool strict , addr_space_t as ATTRIBUTE_UNUSED ) { return msp430_legitimate_address_p ( mode , x , strict ) ;


<s> static machine_mode msp430_addr_space_pointer_mode ( addr_space_t addrspace ) { switch ( addrspace ) { default : case ADDR_SPACE_GENERIC : return Pmode ; case ADDR_SPACE_NEAR : return HImode ; case ADDR_SPACE_FAR : return PSImode ; }


<s> if ( ca -> reg_count && ca -> mem_count ) return ca -> reg_count * UNITS_PER_WORD ; return <NUM_LIT> ;


<s> CUMULATIVE_ARGS * ca = get_cumulative_args ( cap ) ; msp430_evaluate_arg ( cap , mode , type , named ) ; if ( ca -> reg_count && ca -> mem_count ) return ca -> reg_count * UNITS_PER_WORD ;


<s> case <NUM_LIT> : if ( c == SYMBOL_REF || c == CONST || c == LABEL_REF || c == CONST_INT ) { fprintf ( asm_out_file , <STR_LIT> ) ; output_addr_const ( asm_out_file , x ) ;


<s> static tree msp430_attr ( tree * node , tree name , tree args , int flags ATTRIBUTE_UNUSED , bool * no_add_attrs ) { gcc_assert ( DECL_P ( * node ) ) ; if ( args != NULL ) { tree value = TREE_VALUE ( args ) ; switch ( TREE_CODE ( value ) ) { case STRING_CST : if ( strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) && strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) && strcmp ( TREE_STRING_POINTER ( value ) , <STR_LIT> ) ) warning ( OPT_Wattributes , <STR_LIT> , name ) ; break ; case INTEGER_CST : if ( wi :: gtu_p ( value , <NUM_LIT> ) ) warning ( OPT_Wattributes , <STR_LIT> , name ) ; break ; default : warning ( OPT_Wattributes , <STR_LIT> , name ) ; * no_add_attrs = true ; break ; } } if ( TREE_CODE ( * node ) != FUNCTION_DECL ) { warning ( OPT_Wattributes , <STR_LIT> , name ) ; * no_add_attrs = true ; }


<s> static void msp430_compute_frame_info ( void ) { int i ; cfun -> machine -> computed = <NUM_LIT> ; cfun -> machine -> framesize_regs = <NUM_LIT> ; cfun -> machine -> framesize_locals = get_frame_size ( ) ; cfun -> machine -> framesize_outgoing = crtl -> outgoing_args_size ; for ( i = <NUM_LIT> ; i < ARG_POINTER_REGNUM ; i ++ ) if ( msp430_preserve_reg_p ( i ) ) {

cfun -> machine -> need_to_save [ i ] = <NUM_LIT> ;


<s> return ; } if ( ! ca -> reg_used [ <NUM_LIT> ] && ca -> can_split ) { ca -> reg_count = <NUM_LIT> ; ca -> mem_count = <NUM_LIT> ; ca -> start_reg = CA_FIRST_REG + <NUM_LIT> ; return ; } break ; case <NUM_LIT> : case <NUM_LIT> : ca -> can_split = <NUM_LIT> ; if ( ! ca -> reg_used [ <NUM_LIT> ] && ! ca -> reg_used [ <NUM_LIT> ] && ! ca -> reg_used [ <NUM_LIT> ] && ! ca -> reg_used [ <NUM_LIT> ] ) { ca -> reg_count = <NUM_LIT> ; ca -> start_reg = CA_FIRST_REG ; return ;


<s> } if ( ! REG_P ( arg1 ) && ! CONSTANT_P ( arg1 ) ) arg1 = force_reg ( mode , arg1 ) ; switch ( fcode ) { case MSP430_BUILTIN_BIC_SR : emit_insn ( gen_bic_SR ( arg1 ) ) ; break ; case MSP430_BUILTIN_BIS_SR : emit_insn ( gen_bis_SR ( arg1 ) ) ; break ; default : internal_error ( <STR_LIT> ) ; break ; }


<s> error ( <STR_LIT> ) ; return NULL_RTX ; } c = INTVAL ( arg ) ; if ( HOST_BITS_PER_WIDE_INT > <NUM_LIT> ) { if ( c < <NUM_LIT> ) { error ( <STR_LIT> ) ; return NULL_RTX ; } } emit_insn ( gen_delay_cycles_start ( arg ) ) ; if ( c > <NUM_LIT> * <NUM_LIT> + CYCX ( <NUM_LIT> , <NUM_LIT> ) ) { n = c ; if ( c >= <NUM_LIT> * <NUM_LIT> + CYCX ( <NUM_LIT> , <NUM_LIT> ) ) { i = <NUM_LIT> ; c -= CYCX ( <NUM_LIT> , <NUM_LIT> ) + <NUM_LIT> * <NUM_LIT> ; i += c / <NUM_LIT> ; c %= <NUM_LIT> ; if ( ( unsigned long long ) i > <NUM_LIT> ) { error ( <STR_LIT> ) ; return NULL_RTX ; } } else { i = ( c - CYCX ( <NUM_LIT> , <NUM_LIT> ) ) / <NUM_LIT> ; c -= CYCX ( <NUM_LIT> , <NUM_LIT> ) + i * <NUM_LIT> ; } if ( cg_magic_constant ( i & <NUM_LIT> ) ) c ++ ; if ( cg_magic_constant ( ( i >> <NUM_LIT> ) & <NUM_LIT> ) ) c ++ ; if ( msp430x ) emit_insn ( gen_delay_cycles_32x ( GEN_INT ( i ) , GEN_INT ( n - c ) ) ) ;

else emit_insn ( gen_delay_cycles_32 ( GEN_INT ( i ) , GEN_INT ( n - c ) ) ) ;


<s> for ( i = <NUM_LIT> ; i <= <NUM_LIT> ; i ++ ) if ( cfun -> machine -> need_to_save [ i ] ) { int seq , count ; for ( seq = i + <NUM_LIT> ; seq <= <NUM_LIT> && cfun -> machine -> need_to_save [ seq ] ; seq ++ ) ; count = seq - i ; if ( msp430x ) { emit_insn ( gen_popm ( stack_pointer_rtx , GEN_INT ( seq - <NUM_LIT> ) , GEN_INT ( count ) ) ) ; i += count - <NUM_LIT> ; } else if ( i == <NUM_LIT> - helper_n && ! msp430_is_interrupt_func ( ) && ! is_reentrant_func ( ) && ! is_critical_func ( ) && crtl -> args . pretend_args_size == <NUM_LIT> && helper_n > <NUM_LIT> && ! is_eh ) { emit_insn ( gen_epilogue_helper ( GEN_INT ( helper_n ) ) ) ; return ; } else emit_insn ( gen_pop ( gen_rtx_REG ( Pmode , i ) ) ) ;


<s> char * helper_const = NULL ; int arg2 = <NUM_LIT> ; int arg1sz = <NUM_LIT> ; machine_mode arg0mode = GET_MODE ( operands [ <NUM_LIT> ] ) ; machine_mode arg1mode = GET_MODE ( operands [ <NUM_LIT> ] ) ; machine_mode arg2mode = GET_MODE ( operands [ <NUM_LIT> ] ) ; int have_430x = msp430x ? <NUM_LIT> : <NUM_LIT> ; if ( CONST_INT_P ( operands [ <NUM_LIT> ] ) ) { int i ; for ( i = <NUM_LIT> ; const_shift_helpers [ i ] . name ; i ++ ) { if ( const_shift_helpers [ i ] . need_430x <= have_430x && strcmp ( helper_name , const_shift_helpers [ i ] . name ) == <NUM_LIT> && INTVAL ( operands [ <NUM_LIT> ] ) == const_shift_helpers [ i ] . count ) { emit_insn ( const_shift_helpers [ i ] . genfunc ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; return ; } } } if ( arg1mode == VOIDmode ) arg1mode = arg0mode ; if ( arg2mode == VOIDmode ) arg2mode = arg0mode ; if ( arg1mode == SImode ) { arg2 = <NUM_LIT> ; arg1sz = <NUM_LIT> ; } if ( const_variants && CONST_INT_P ( operands [ <NUM_LIT> ] ) && INTVAL ( operands [ <NUM_LIT> ] ) >= <NUM_LIT> && INTVAL ( operands [ <NUM_LIT> ] ) <= <NUM_LIT> ) { int len = strlen ( helper_name ) + <NUM_LIT> ; helper_const = ( char * ) xmalloc ( len ) ; snprintf ( helper_const , len , <STR_LIT> , helper_name , ( int ) INTVAL ( operands [ <NUM_LIT> ] ) ) ; } emit_move_insn ( gen_rtx_REG ( arg1mode , <NUM_LIT> ) , operands [ <NUM_LIT> ] ) ; if ( ! helper_const ) emit_move_insn ( gen_rtx_REG ( arg2mode , arg2 ) , operands [ <NUM_LIT> ] ) ;


<s> rtx sp = stack_pointer_rtx ; rtx p ; if ( is_naked_func ( ) ) { emit_insn ( gen_rtx_CLOBBER ( VOIDmode , GEN_INT ( <NUM_LIT> ) ) ) ; return ; } emit_insn ( gen_prologue_start_marker ( ) ) ; if ( is_critical_func ( ) ) { emit_insn ( gen_push_intr_state ( ) ) ; emit_insn ( gen_disable_interrupts ( ) ) ; } else if ( is_reentrant_func ( ) ) emit_insn ( gen_disable_interrupts ( ) ) ; if ( ! cfun -> machine -> computed ) msp430_compute_frame_info ( ) ; if ( flag_stack_usage_info ) current_function_static_stack_size = cfun -> machine -> framesize ; if ( crtl -> args . pretend_args_size ) { rtx note ; gcc_assert ( crtl -> args . pretend_args_size == <NUM_LIT> ) ; p = emit_insn ( gen_grow_and_swap ( ) ) ; note = F ( gen_rtx_SET ( Pmode , stack_pointer_rtx , gen_rtx_MINUS ( Pmode , stack_pointer_rtx , GEN_INT ( <NUM_LIT> ) ) ) ) ; add_reg_note ( p , REG_FRAME_RELATED_EXPR , note ) ; note = F ( gen_rtx_SET ( Pmode , gen_rtx_MEM ( Pmode , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , GEN_INT ( - <NUM_LIT> ) ) ) , pc_rtx ) ) ; add_reg_note ( p , REG_CFA_OFFSET , note ) ; F ( p ) ; } for ( i = <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) if ( cfun -> machine -> need_to_save [ i ] ) { int seq , count ; rtx note ; for ( seq = i - <NUM_LIT> ; seq >= <NUM_LIT> && cfun -> machine -> need_to_save [ seq ] ; seq -- ) ; count = i - seq ; if ( msp430x ) { p = F ( emit_insn ( gen_pushm ( gen_rtx_REG ( Pmode , i ) , GEN_INT ( count ) ) ) ) ; note = gen_rtx_SEQUENCE ( VOIDmode , rtvec_alloc ( count + <NUM_LIT> ) ) ; XVECEXP ( note , <NUM_LIT> , <NUM_LIT> ) = F ( gen_rtx_SET ( VOIDmode , stack_pointer_rtx , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , GEN_INT ( count * ( TARGET_LARGE ? - <NUM_LIT> : - <NUM_LIT> ) ) ) ) ) ; for ( j = <NUM_LIT> ; j < count ; j ++ ) { rtx addr ; int ofs = ( count - j - <NUM_LIT> ) * ( TARGET_LARGE ? <NUM_LIT> : <NUM_LIT> ) ; if ( ofs ) addr = gen_rtx_PLUS ( Pmode , sp , GEN_INT ( ofs ) ) ; else addr = stack_pointer_rtx ; XVECEXP ( note , <NUM_LIT> , j + <NUM_LIT> ) = F ( gen_rtx_SET ( VOIDmode , gen_rtx_MEM ( Pmode , addr ) , gen_rtx_REG ( Pmode , i - j ) ) ) ; } add_reg_note ( p , REG_FRAME_RELATED_EXPR , note ) ; i -= count - <NUM_LIT> ; }

else F ( emit_insn ( gen_push ( gen_rtx_REG ( Pmode , i ) ) ) ) ;


<s> rtx msp430_function_arg ( cumulative_args_t cap , machine_mode mode , const_tree type , bool named ) { CUMULATIVE_ARGS * ca = get_cumulative_args ( cap ) ; msp430_evaluate_arg ( cap , mode , type , named ) ;

if ( ca -> reg_count ) return gen_rtx_REG ( mode , ca -> start_reg ) ;


<s> int i ; msp430_evaluate_arg ( cap , mode , type , named ) ; if ( ca -> start_reg >= CA_FIRST_REG ) for ( i = <NUM_LIT> ; i < ca -> reg_count ; i ++ ) ca -> reg_used [ i + ca -> start_reg - CA_FIRST_REG ] = <NUM_LIT> ;


<s> if ( ca -> start_reg >= CA_FIRST_REG ) for ( i = <NUM_LIT> ; i < ca -> reg_count ; i ++ ) ca -> reg_used [ i + ca -> start_reg - CA_FIRST_REG ] = <NUM_LIT> ;


<s> if ( TARGET_LARGE && lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ) return get_section ( <STR_LIT> , SECTION_CODE | SECTION_WRITE , decl ) ; return default_function_section ( decl , freq , startup , exit ) ;


<s> static machine_mode msp430_get_raw_arg_mode ( int regno ) {

return ( regno == ARG_POINTER_REGNUM ) ? VOIDmode : Pmode ;


<s> static machine_mode msp430_get_raw_result_mode ( int regno ATTRIBUTE_UNUSED ) { return Pmode ;


<s> if ( boundary > align && ! integer_zerop ( TYPE_SIZE ( type ) ) ) { if ( ! POINTER_TYPE_P ( type ) ) { t = build2 ( MODIFY_EXPR , TREE_TYPE ( valist ) , valist_tmp , fold_build_pointer_plus_hwi ( valist_tmp , boundary - <NUM_LIT> ) ) ; gimplify_and_add ( t , pre_p ) ; t = build2 ( MODIFY_EXPR , TREE_TYPE ( valist ) , valist_tmp , fold_build2 ( BIT_AND_EXPR , TREE_TYPE ( valist ) , valist_tmp , build_int_cst ( TREE_TYPE ( valist ) , - boundary ) ) ) ; gimplify_and_add ( t , pre_p ) ; } } else boundary = align ; boundary *= BITS_PER_UNIT ; if ( boundary < TYPE_ALIGN ( type ) ) { type = build_variant_type_copy ( type ) ;


<s> int msp430_hard_regno_mode_ok ( int regno ATTRIBUTE_UNUSED , machine_mode mode ) {

return regno <= ( ARG_POINTER_REGNUM - msp430_hard_regno_nregs ( regno , mode ) ) ;


<s> if ( mode == PSImode && msp430x ) return <NUM_LIT> ; return ( ( GET_MODE_SIZE ( mode ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ) ;


<s> return ( ( GET_MODE_SIZE ( mode ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ) ;


<s> int msp430_hard_regno_nregs_has_padding ( int regno ATTRIBUTE_UNUSED , machine_mode mode ) { if ( mode == PSImode && msp430x ) return <NUM_LIT> ;

return ( ( GET_MODE_SIZE ( mode ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ) ;


<s> int msp430_hard_regno_nregs_with_padding ( int regno ATTRIBUTE_UNUSED , machine_mode mode ) { if ( mode == PSImode ) return <NUM_LIT> ;

return msp430_hard_regno_nregs ( regno , mode ) ;


<s> if ( mode == PSImode ) return <NUM_LIT> ;


<s> bool msp430_legitimate_address_p ( machine_mode mode ATTRIBUTE_UNUSED , rtx x ATTRIBUTE_UNUSED , bool strict ATTRIBUTE_UNUSED ) { switch ( GET_CODE ( x ) ) { case MEM : return false ; case PLUS : if ( REG_P ( XEXP ( x , <NUM_LIT> ) ) ) { if ( GET_MODE ( x ) != GET_MODE ( XEXP ( x , <NUM_LIT> ) ) ) return false ; if ( ! reg_ok_for_addr ( XEXP ( x , <NUM_LIT> ) , strict ) ) return false ; switch ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) ) { case CONST : case SYMBOL_REF : case CONST_INT : return true ; default : return false ; } } return false ; case REG :

if ( ! reg_ok_for_addr ( x , strict ) ) return false ;


<s> return ! CONST_INT_P ( x ) || mode != PSImode || ( INTVAL ( x ) < ( <NUM_LIT> << <NUM_LIT> ) && INTVAL ( x ) >= ( - <NUM_LIT> << <NUM_LIT> ) ) ;


<s> snprintf ( mcu_name , sizeof ( mcu_name ) - <NUM_LIT> , <STR_LIT> , target_mcu ) ; for ( i = strlen ( mcu_name ) ; i -- ; ) mcu_name [ i ] = TOUPPER ( mcu_name [ i ] ) ; return mcu_name ; } return msp430x ? <STR_LIT> : <STR_LIT> ;


if ( ( mode1 == PSImode || mode2 == SImode ) || ( mode1 == SImode || mode2 == PSImode ) ) return false ;


<s> else msp430x = false ; } else if ( target_mcu ) { int i ; msp430x = true ; for ( i = ARRAY_SIZE ( msp430_mcu_names ) ; i -- ; ) if ( strcasecmp ( msp430_mcu_names [ i ] , target_mcu ) == <NUM_LIT> ) { msp430x = false ; break ; } }

if ( TARGET_LARGE && ! msp430x ) error ( <STR_LIT> ) ;


<s> int i ; msp430x = true ; for ( i = ARRAY_SIZE ( msp430_mcu_names ) ; i -- ; ) if ( strcasecmp ( msp430_mcu_names [ i ] , target_mcu ) == <NUM_LIT> ) { msp430x = false ;


<s> if ( msp430_use_f5_series_hwmult ( ) ) name = <STR_LIT> ; else if ( ! msp430_no_hwmult ( ) ) name = <STR_LIT> ; } else if ( strcmp ( <STR_LIT> , name ) == <NUM_LIT> ) { if ( msp430_use_f5_series_hwmult ( ) ) name = <STR_LIT> ; else if ( use_32bit_hwmult ( ) ) name = <STR_LIT> ; else if ( ! msp430_no_hwmult ( ) ) name = <STR_LIT> ; } }


<s> static bool msp430_pass_by_reference ( cumulative_args_t cap ATTRIBUTE_UNUSED , machine_mode mode , const_tree type , bool named ATTRIBUTE_UNUSED ) {

return ( mode == BLKmode || ( type && TREE_CODE ( type ) == RECORD_TYPE ) || ( type && TREE_CODE ( type ) == UNION_TYPE ) ) ;


<s> if ( msp430_is_interrupt_func ( ) ) return ! crtl -> is_leaf || df_regs_ever_live_p ( regno ) ;

if ( ! call_used_regs [ regno ] && df_regs_ever_live_p ( regno ) ) return true ;


<s> static void msp430_print_operand ( FILE * file , rtx op , int letter ) { rtx addr ; switch ( letter ) { case 'Z' : gcc_assert ( CONST_INT_P ( op ) ) ; fprintf ( file , <STR_LIT> , INTVAL ( op ) - <NUM_LIT> ) ; return ; case 'Y' : gcc_assert ( CONST_INT_P ( op ) ) ; fprintf ( file , <STR_LIT> , INTVAL ( op ) - <NUM_LIT> ) ; return ; case 'I' : if ( GET_CODE ( op ) == CONST_INT ) { int i = INTVAL ( op ) ; fprintf ( file , <STR_LIT> , ~ i ) ; return ; } op = XEXP ( op , <NUM_LIT> ) ; break ; case 'r' : switch ( GET_CODE ( op ) ) { case EQ : fprintf ( file , <STR_LIT> ) ; break ; case NE : fprintf ( file , <STR_LIT> ) ; break ; case GEU : fprintf ( file , <STR_LIT> ) ; break ; case LTU : fprintf ( file , <STR_LIT> ) ; break ; case GE : fprintf ( file , <STR_LIT> ) ; break ; case LT : fprintf ( file , <STR_LIT> ) ; break ; case GTU : fprintf ( file , <STR_LIT> ) ; break ; case LEU : fprintf ( file , <STR_LIT> ) ; break ; case GT : fprintf ( file , <STR_LIT> ) ; break ; case LE : fprintf ( file , <STR_LIT> ) ; break ; default : msp430_print_operand_raw ( file , op ) ; break ; } return ; case 'R' : switch ( GET_CODE ( op ) ) { case GTU : fprintf ( file , <STR_LIT> ) ; break ; case LEU : fprintf ( file , <STR_LIT> ) ; break ; case GT : fprintf ( file , <STR_LIT> ) ; break ; case LE : fprintf ( file , <STR_LIT> ) ; break ; default : msp430_print_operand_raw ( file , op ) ; break ; } return ; case 'p' : gcc_assert ( CONST_INT_P ( op ) ) ; fprintf ( file , <STR_LIT> , <NUM_LIT> << INTVAL ( op ) ) ; return ; case 'b' : switch ( GET_MODE ( op ) ) { case QImode : fprintf ( file , <STR_LIT> ) ; return ; case HImode : fprintf ( file , <STR_LIT> ) ; return ; case PSImode : fprintf ( file , <STR_LIT> ) ; return ; case SImode : fprintf ( file , <STR_LIT> ) ; return ; default : return ; } case 'A' : case 'L' : switch ( GET_CODE ( op ) ) { case MEM : op = adjust_address ( op , Pmode , <NUM_LIT> ) ; break ; case REG : break ; case CONST_INT : op = GEN_INT ( INTVAL ( op ) & <NUM_LIT> ) ; letter = <NUM_LIT> ; break ; default : gcc_unreachable ( ) ; } break ; case 'B' : case 'H' :


<s> msp430_print_operand_raw ( file , XEXP ( addr , <NUM_LIT> ) ) ; gcc_assert ( REG_P ( XEXP ( addr , <NUM_LIT> ) ) ) ; fprintf ( file , <STR_LIT> , reg_names [ REGNO ( XEXP ( addr , <NUM_LIT> ) ) ] ) ; return ; case REG : fprintf ( file , <STR_LIT> ) ; break ; case CONST :


<s> break ; case CONST_INT : i = INTVAL ( op ) ; if ( TARGET_ASM_HEX ) fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT <STR_LIT> , i ) ; else fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT <STR_LIT> , i ) ; break ; case CONST : case PLUS : case MINUS : case SYMBOL_REF : case LABEL_REF : output_addr_const ( file , op ) ; break ;


<s> switch ( GET_CODE ( op ) ) { case REG : fprintf ( file , <STR_LIT> , reg_names [ REGNO ( op ) ] ) ; break ; case CONST_INT : i = INTVAL ( op ) ; if ( TARGET_ASM_HEX ) fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT <STR_LIT> , i ) ;

else fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT <STR_LIT> , i ) ;


<s> * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; } break ; case ASHIFT : case ASHIFTRT : case LSHIFTRT : if ( ! msp430x ) { * total = COSTS_N_INSNS ( <NUM_LIT> ) ;


<s> static bool msp430_scalar_mode_supported_p ( machine_mode m ) {

if ( m == PSImode && msp430x ) return true ;


<s> if ( m == TImode ) return true ; return default_scalar_mode_supported_p ( m ) ;


<s> static bool msp430_special_register_convention_p ( const char * name ) { int i ;

for ( i = <NUM_LIT> ; special_convention_function_names [ i ] ; i ++ ) if ( ! strcmp ( name , special_convention_function_names [ i ] ) ) return true ;


<s> rtx op00 , op02 , op10 , op12 ; op00 = msp430_subreg ( HImode , operands [ <NUM_LIT> ] , SImode , <NUM_LIT> ) ; op02 = msp430_subreg ( HImode , operands [ <NUM_LIT> ] , SImode , <NUM_LIT> ) ; if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST || GET_CODE ( operands [ <NUM_LIT> ] ) == SYMBOL_REF ) { op10 = gen_rtx_ZERO_EXTRACT ( HImode , operands [ <NUM_LIT> ] , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) ) ; op10 = gen_rtx_CONST ( HImode , op10 ) ; op12 = gen_rtx_ZERO_EXTRACT ( HImode , operands [ <NUM_LIT> ] , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) ) ; op12 = gen_rtx_CONST ( HImode , op12 ) ; } else { op10 = msp430_subreg ( HImode , operands [ <NUM_LIT> ] , SImode , <NUM_LIT> ) ; op12 = msp430_subreg ( HImode , operands [ <NUM_LIT> ] , SImode , <NUM_LIT> ) ; } if ( rtx_equal_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) { operands [ <NUM_LIT> ] = op02 ; operands [ <NUM_LIT> ] = op12 ; operands [ <NUM_LIT> ] = op00 ; operands [ <NUM_LIT> ] = op10 ; }

else if ( rtx_equal_p ( op00 , op12 ) || ( REG_P ( op00 ) && reg_mentioned_p ( op00 , op10 ) ) || ( REG_P ( op10 ) && reg_mentioned_p ( op10 , op00 ) ) ) {


<s> op00 = msp430_subreg ( HImode , operands [ <NUM_LIT> ] , SImode , <NUM_LIT> ) ; op02 = msp430_subreg ( HImode , operands [ <NUM_LIT> ] , SImode , <NUM_LIT> ) ; if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST || GET_CODE ( operands [ <NUM_LIT> ] ) == SYMBOL_REF ) { op10 = gen_rtx_ZERO_EXTRACT ( HImode , operands [ <NUM_LIT> ] , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) ) ; op10 = gen_rtx_CONST ( HImode , op10 ) ; op12 = gen_rtx_ZERO_EXTRACT ( HImode , operands [ <NUM_LIT> ] , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) ) ; op12 = gen_rtx_CONST ( HImode , op12 ) ; } else { op10 = msp430_subreg ( HImode , operands [ <NUM_LIT> ] , SImode , <NUM_LIT> ) ; op12 = msp430_subreg ( HImode , operands [ <NUM_LIT> ] , SImode , <NUM_LIT> ) ; } if ( rtx_equal_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) { operands [ <NUM_LIT> ] = op02 ; operands [ <NUM_LIT> ] = op12 ; operands [ <NUM_LIT> ] = op00 ; operands [ <NUM_LIT> ] = op10 ; } else if ( rtx_equal_p ( op00 , op12 ) || ( REG_P ( op00 ) && reg_mentioned_p ( op00 , op10 ) ) || ( REG_P ( op10 ) && reg_mentioned_p ( op10 , op00 ) ) ) { operands [ <NUM_LIT> ] = op02 ; operands [ <NUM_LIT> ] = op12 ; operands [ <NUM_LIT> ] = op00 ; operands [ <NUM_LIT> ] = op10 ; } else { operands [ <NUM_LIT> ] = op00 ; operands [ <NUM_LIT> ] = op10 ; operands [ <NUM_LIT> ] = op02 ; operands [ <NUM_LIT> ] = op12 ;


<s> void msp430_start_function ( FILE * file , const char * name , tree decl ) { tree int_attr ; int_attr = lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ; if ( int_attr != NULL_TREE ) { tree intr_vector = TREE_VALUE ( int_attr ) ; if ( intr_vector != NULL_TREE ) { char buf [ <NUM_LIT> ] ; intr_vector = TREE_VALUE ( intr_vector ) ; if ( TREE_CODE ( intr_vector ) == STRING_CST ) sprintf ( buf , <STR_LIT> , TREE_STRING_POINTER ( intr_vector ) ) ; else sprintf ( buf , <STR_LIT> , ( unsigned int ) TREE_INT_CST_LOW ( intr_vector ) ) ; switch_to_section ( get_section ( buf , SECTION_CODE , decl ) ) ;


<s> rtx ireg = SUBREG_REG ( r ) ; machine_mode imode = GET_MODE ( ireg ) ; if ( imode == PSImode && mode == HImode && byte == <NUM_LIT> ) rv = gen_rtx_SUBREG ( mode , ireg , byte ) ; else rv = simplify_gen_subreg ( mode , ireg , imode , byte ) ;


<s> static bool reg_ok_for_addr ( rtx r , bool strict ) { int rn = REGNO ( r ) ; if ( strict && rn >= FIRST_PSEUDO_REGISTER ) rn = reg_renumber [ rn ] ; if ( strict && <NUM_LIT> <= rn && rn < FIRST_PSEUDO_REGISTER ) return true ; if ( ! strict ) return true ;


<s> static const char * known_32bit_mult_mcus [ ] = { <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> } ; static const char * cached_match = NULL ; static bool cached_result ; int i ; if ( msp430_hwmult_type == LARGE ) return true ; if ( target_mcu == NULL || msp430_hwmult_type != AUTO ) return false ; if ( target_mcu == cached_match ) return cached_result ; cached_match = target_mcu ; for ( i = ARRAY_SIZE ( known_32bit_mult_mcus ) ; i -- ; ) if ( strcasecmp ( target_mcu , known_32bit_mult_mcus [ i ] ) == <NUM_LIT> ) return cached_result = true ;


<s> <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> , <STR_LIT> } ; static const char * cached_match = NULL ; static bool cached_result ; int i ; if ( msp430_hwmult_type == LARGE ) return true ; if ( target_mcu == NULL || msp430_hwmult_type != AUTO ) return false ; if ( target_mcu == cached_match ) return cached_result ; cached_match = target_mcu ; for ( i = ARRAY_SIZE ( known_32bit_mult_mcus ) ; i -- ; ) if ( strcasecmp ( target_mcu , known_32bit_mult_mcus [ i ] ) == <NUM_LIT> ) return cached_result = true ;


<s> if ( msp430_code_region == LOWER ) return lower_prefix ; if ( msp430_code_region == UPPER ) return upper_prefix ; if ( msp430_code_region == EITHER ) return either_prefix ; } else { if ( msp430_data_region == LOWER ) return lower_prefix ; if ( msp430_data_region == UPPER ) return upper_prefix ; if ( msp430_data_region == EITHER ) return either_prefix ; } return NULL ;


<s> static bool msp430_allocate_stack_slots_for_args ( void ) { return ! is_naked_func ( ) ;


<s> const char * message = NULL ; if ( TREE_CODE ( * node ) != FUNCTION_DECL ) { message = <STR_LIT> ; } else if ( TREE_NAME_EQ ( name , ATTR_INTR ) ) { if ( TREE_CODE ( TREE_TYPE ( * node ) ) == FUNCTION_TYPE && ! VOID_TYPE_P ( TREE_TYPE ( TREE_TYPE ( * node ) ) ) ) message = <STR_LIT> ; } else if ( TREE_NAME_EQ ( name , ATTR_REENT ) ) { if ( is_naked_func ( * node ) ) message = <STR_LIT> ; else if ( is_critical_func ( * node ) ) message = <STR_LIT> ; } else if ( TREE_NAME_EQ ( name , ATTR_CRIT ) ) { if ( is_naked_func ( * node ) ) message = <STR_LIT> ; else if ( is_reentrant_func ( * node ) ) message = <STR_LIT> ; } else if ( TREE_NAME_EQ ( name , ATTR_NAKED ) ) { if ( is_critical_func ( * node ) ) message = <STR_LIT> ;


<s> if ( TREE_CODE ( * node ) != VAR_DECL ) message = <STR_LIT> ; if ( DECL_SECTION_NAME ( * node ) ) message = <STR_LIT> ; if ( DECL_COMMON ( * node ) ) DECL_COMMON ( * node ) = <NUM_LIT> ; if ( message ) { warning ( OPT_Wattributes , message , name ) ; * no_add_attrs = true ;


<s> if ( DECL_SECTION_NAME ( * node ) ) message = <STR_LIT> ; if ( DECL_COMMON ( * node ) ) DECL_COMMON ( * node ) = <NUM_LIT> ; if ( message ) {

warning ( OPT_Wattributes , message , name ) ;


<s> return msp430_code_region == EITHER || msp430_code_region == LOWER || has_attr ( ATTR_EITHER , current_function_decl ) || has_attr ( ATTR_LOWER , current_function_decl ) ;


<s> bool msp430_do_not_relax_short_jumps ( void ) { return msp430_code_region == EITHER || msp430_code_region == LOWER || has_attr ( ATTR_EITHER , current_function_decl ) || has_attr ( ATTR_LOWER , current_function_decl ) ;


<s> note = gen_rtx_SEQUENCE ( VOIDmode , rtvec_alloc ( count + <NUM_LIT> ) ) ; XVECEXP ( note , <NUM_LIT> , <NUM_LIT> ) = F ( gen_rtx_SET ( stack_pointer_rtx , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , GEN_INT ( count * ( TARGET_LARGE ? - <NUM_LIT> : - <NUM_LIT> ) ) ) ) ) ; for ( j = <NUM_LIT> ; j < count ; j ++ ) { rtx addr ; int ofs = ( count - j - <NUM_LIT> ) * ( TARGET_LARGE ? <NUM_LIT> : <NUM_LIT> ) ; if ( ofs ) addr = gen_rtx_PLUS ( Pmode , sp , GEN_INT ( ofs ) ) ; else addr = stack_pointer_rtx ; XVECEXP ( note , <NUM_LIT> , j + <NUM_LIT> ) = F ( gen_rtx_SET ( gen_rtx_MEM ( Pmode , addr ) , gen_rtx_REG ( Pmode , i - j ) ) ) ; } add_reg_note ( p , REG_FRAME_RELATED_EXPR , note ) ; i -= count - <NUM_LIT> ; }

else F ( emit_insn ( gen_push ( gen_rtx_REG ( Pmode , i ) ) ) ) ;


<s> emit_insn ( gen_rtx_CLOBBER ( VOIDmode , GEN_INT ( <NUM_LIT> ) ) ) ; return ; } emit_insn ( gen_prologue_start_marker ( ) ) ; if ( is_critical_func ( ) ) { emit_insn ( gen_push_intr_state ( ) ) ; emit_insn ( gen_disable_interrupts ( ) ) ; } else if ( is_reentrant_func ( ) ) emit_insn ( gen_disable_interrupts ( ) ) ; if ( ! cfun -> machine -> computed ) msp430_compute_frame_info ( ) ; if ( flag_stack_usage_info ) current_function_static_stack_size = cfun -> machine -> framesize ; if ( crtl -> args . pretend_args_size ) { rtx note ; gcc_assert ( crtl -> args . pretend_args_size == <NUM_LIT> ) ; p = emit_insn ( gen_grow_and_swap ( ) ) ; note = F ( gen_rtx_SET ( stack_pointer_rtx , gen_rtx_MINUS ( Pmode , stack_pointer_rtx , GEN_INT ( <NUM_LIT> ) ) ) ) ; add_reg_note ( p , REG_FRAME_RELATED_EXPR , note ) ; note = F ( gen_rtx_SET ( gen_rtx_MEM ( Pmode , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , GEN_INT ( - <NUM_LIT> ) ) ) , pc_rtx ) ) ; add_reg_note ( p , REG_CFA_OFFSET , note ) ; F ( p ) ; } for ( i = <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) if ( cfun -> machine -> need_to_save [ i ] ) { int seq , count ; rtx note ; for ( seq = i - <NUM_LIT> ; seq >= <NUM_LIT> && cfun -> machine -> need_to_save [ seq ] ; seq -- ) ; count = i - seq ; if ( msp430x ) { p = F ( emit_insn ( gen_pushm ( gen_rtx_REG ( Pmode , i ) , GEN_INT ( count ) ) ) ) ; note = gen_rtx_SEQUENCE ( VOIDmode , rtvec_alloc ( count + <NUM_LIT> ) ) ; XVECEXP ( note , <NUM_LIT> , <NUM_LIT> ) = F ( gen_rtx_SET ( stack_pointer_rtx , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , GEN_INT ( count * ( TARGET_LARGE ? - <NUM_LIT> : - <NUM_LIT> ) ) ) ) ) ;

for ( j = <NUM_LIT> ; j < count ; j ++ ) {


<s> if ( target_mcu == NULL ) return true ; if ( target_mcu == cached_match ) return cached_result ; cached_match = target_mcu ;

for ( i = ARRAY_SIZE ( msp430_mcu_data ) ; i -- ; ) if ( strcasecmp ( target_mcu , msp430_mcu_data [ i ] . name ) == <NUM_LIT> ) return cached_result = msp430_mcu_data [ i ] . hwmpy == <NUM_LIT> ;


<s> static bool msp430_no_hwmult ( void ) { static const char * cached_match = NULL ; static bool cached_result ; int i ; if ( msp430_hwmult_type == NONE ) return true ; if ( msp430_hwmult_type != AUTO ) return false ;


<s> } msp430x = xisa ; break ; } if ( i < <NUM_LIT> ) { if ( msp430_hwmult_type == AUTO ) { if ( msp430_warn_mcu ) { if ( target_cpu == NULL ) warning ( <NUM_LIT> , <STR_LIT> , target_mcu ) ; else warning ( <NUM_LIT> , <STR_LIT> , target_mcu ) ; } msp430_hwmult_type = NONE ; } else if ( target_cpu == NULL ) { if ( msp430_warn_mcu ) warning ( <NUM_LIT> , <STR_LIT> , target_mcu ) ; msp430x = false ; } else if ( msp430_warn_mcu ) warning ( <NUM_LIT> , <STR_LIT> , target_mcu ) ; } } if ( target_cpu == NULL && target_mcu == NULL && msp430_hwmult_type == F5SERIES ) msp430x = true ; if ( TARGET_LARGE && ! msp430x ) error ( <STR_LIT> ) ;

if ( msp430_code_region == UPPER && ! msp430x ) error ( <STR_LIT> ) ;


<s> assemble_name ( stream , name ) ; fprintf ( stream , <STR_LIT> HOST_WIDE_INT_PRINT_UNSIGNED <STR_LIT> , size , align / BITS_PER_UNIT ) ; } else { section * sec ; if ( decl ) sec = msp430_select_section ( decl , <NUM_LIT> , align ) ; else switch ( msp430_data_region ) { case UPPER : sec = get_named_section ( NULL , <STR_LIT> , <NUM_LIT> ) ; break ; case LOWER : sec = get_named_section ( NULL , <STR_LIT> , <NUM_LIT> ) ; break ; case EITHER : sec = get_named_section ( NULL , <STR_LIT> , <NUM_LIT> ) ; break ; default : gcc_unreachable ( ) ; } gcc_assert ( sec != NULL ) ; switch_to_section ( sec ) ; ASM_OUTPUT_ALIGN ( stream , floor_log2 ( align / BITS_PER_UNIT ) ) ; targetm . asm_out . globalize_label ( stream , name ) ; ASM_WEAKEN_LABEL ( stream , name ) ; ASM_OUTPUT_LABEL ( stream , name ) ; ASM_OUTPUT_SKIP ( stream , size ? size : <NUM_LIT> ) ;


<s> section * sec ; if ( decl ) sec = msp430_select_section ( decl , <NUM_LIT> , align ) ; else switch ( msp430_data_region ) { case UPPER : sec = get_named_section ( NULL , <STR_LIT> , <NUM_LIT> ) ; break ; case LOWER : sec = get_named_section ( NULL , <STR_LIT> , <NUM_LIT> ) ; break ; case EITHER : sec = get_named_section ( NULL , <STR_LIT> , <NUM_LIT> ) ; break ; default : gcc_unreachable ( ) ; } gcc_assert ( sec != NULL ) ; switch_to_section ( sec ) ; ASM_OUTPUT_ALIGN ( stream , floor_log2 ( align / BITS_PER_UNIT ) ) ;

targetm . asm_out . globalize_label ( stream , name ) ;


<s> return ; case 'I' : if ( GET_CODE ( op ) == CONST_INT ) { int i = INTVAL ( op ) ; fprintf ( file , <STR_LIT> , ~ i ) ; return ; } op = XEXP ( op , <NUM_LIT> ) ; break ; case 'r' : switch ( GET_CODE ( op ) ) { case EQ : fprintf ( file , <STR_LIT> ) ; break ; case NE : fprintf ( file , <STR_LIT> ) ; break ; case GEU : fprintf ( file , <STR_LIT> ) ; break ; case LTU : fprintf ( file , <STR_LIT> ) ; break ; case GE : fprintf ( file , <STR_LIT> ) ; break ; case LT : fprintf ( file , <STR_LIT> ) ; break ; case GTU : fprintf ( file , <STR_LIT> ) ; break ; case LEU : fprintf ( file , <STR_LIT> ) ; break ; case GT : fprintf ( file , <STR_LIT> ) ; break ; case LE : fprintf ( file , <STR_LIT> ) ; break ; default : msp430_print_operand_raw ( file , op ) ; break ; } return ; case 'R' : switch ( GET_CODE ( op ) ) { case GTU : fprintf ( file , <STR_LIT> ) ; break ; case LEU : fprintf ( file , <STR_LIT> ) ; break ; case GT : fprintf ( file , <STR_LIT> ) ; break ; case LE : fprintf ( file , <STR_LIT> ) ; break ; default : msp430_print_operand_raw ( file , op ) ; break ; } return ; case 'p' : gcc_assert ( CONST_INT_P ( op ) ) ; fprintf ( file , <STR_LIT> , <NUM_LIT> << INTVAL ( op ) ) ; return ; case 'b' : switch ( GET_MODE ( op ) ) { case QImode : fprintf ( file , <STR_LIT> ) ; return ; case HImode : fprintf ( file , <STR_LIT> ) ; return ; case PSImode : fprintf ( file , <STR_LIT> ) ; return ; case SImode : fprintf ( file , <STR_LIT> ) ; return ; default :


<s> static void msp430_print_operand_addr ( FILE * file , machine_mode , rtx addr ) { switch ( GET_CODE ( addr ) ) { case PLUS : msp430_print_operand_raw ( file , XEXP ( addr , <NUM_LIT> ) ) ; gcc_assert ( REG_P ( XEXP ( addr , <NUM_LIT> ) ) ) ; fprintf ( file , <STR_LIT> , reg_names [ REGNO ( XEXP ( addr , <NUM_LIT> ) ) ] ) ; return ;


<s> msp430_print_operand_raw ( file , XEXP ( addr , <NUM_LIT> ) ) ; gcc_assert ( REG_P ( XEXP ( addr , <NUM_LIT> ) ) ) ; fprintf ( file , <STR_LIT> , reg_names [ REGNO ( XEXP ( addr , <NUM_LIT> ) ) ] ) ; return ; case REG : fprintf ( file , <STR_LIT> ) ; break ; case CONST : case CONST_INT : case SYMBOL_REF :


<s> static tree msp430_section_attr ( tree * node , tree name , tree args , int flags ATTRIBUTE_UNUSED , bool * no_add_attrs ATTRIBUTE_UNUSED ) { gcc_assert ( DECL_P ( * node ) ) ; gcc_assert ( args == NULL ) ; const char * message = NULL ; if ( TREE_NAME_EQ ( name , ATTR_UPPER ) ) { if ( has_attr ( ATTR_LOWER , * node ) ) message = <STR_LIT> ; else if ( has_attr ( ATTR_EITHER , * node ) ) message = <STR_LIT> ; else if ( ! msp430x ) message = <STR_LIT> ; } else if ( TREE_NAME_EQ ( name , ATTR_LOWER ) ) { if ( has_attr ( ATTR_UPPER , * node ) ) message = <STR_LIT> ; else if ( has_attr ( ATTR_EITHER , * node ) ) message = <STR_LIT> ;


<s> else if ( strncmp ( name , either_prefix , strlen ( either_prefix ) ) == <NUM_LIT> ) name += strlen ( either_prefix ) ; else if ( strcmp ( name , <STR_LIT> ) == <NUM_LIT> ) return SECTION_WRITE | SECTION_BSS | SECTION_NOTYPE ; else if ( strcmp ( name , <STR_LIT> ) == <NUM_LIT> ) return SECTION_WRITE | SECTION_NOTYPE ; return default_section_type_flags ( decl , name , reloc ) ;


<s> const char * prefix = gen_prefix ( decl ) ; if ( prefix == NULL ) { if ( TREE_CODE ( decl ) == FUNCTION_DECL ) return text_section ; else if ( has_attr ( ATTR_NOINIT , decl ) ) return noinit_section ; else if ( has_attr ( ATTR_PERSIST , decl ) ) return persist_section ; else return default_select_section ( decl , reloc , align ) ; } const char * sec ; switch ( categorize_decl_for_section ( decl , reloc ) ) { case SECCAT_TEXT : sec = <STR_LIT> ; break ; case SECCAT_DATA : sec = <STR_LIT> ; break ; case SECCAT_BSS : sec = <STR_LIT> ; break ; case SECCAT_RODATA : sec = <STR_LIT> ; break ; case SECCAT_RODATA_MERGE_STR : case SECCAT_RODATA_MERGE_STR_INIT : case SECCAT_RODATA_MERGE_CONST : case SECCAT_SRODATA : case SECCAT_DATA_REL : case SECCAT_DATA_REL_LOCAL : case SECCAT_DATA_REL_RO : case SECCAT_DATA_REL_RO_LOCAL : case SECCAT_SDATA : case SECCAT_SBSS : case SECCAT_TDATA : case SECCAT_TBSS : return default_select_section ( decl , reloc , align ) ; default : gcc_unreachable ( ) ; } const char * dec_name = DECL_SECTION_NAME ( decl ) ;

char * name = ACONCAT ( ( prefix , sec , dec_name , NULL ) ) ;


<s> if ( TREE_CODE ( intr_vector ) == STRING_CST ) sprintf ( buf , <STR_LIT> , TREE_STRING_POINTER ( intr_vector ) ) ; else sprintf ( buf , <STR_LIT> , ( unsigned int ) TREE_INT_CST_LOW ( intr_vector ) ) ; switch_to_section ( get_section ( buf , SECTION_CODE , decl ) ) ; fputs ( <STR_LIT> , file ) ; assemble_name ( file , name ) ; fputc ( '\n' , file ) ; fputc ( '\t' , file ) ; } } switch_to_section ( function_section ( decl ) ) ; ASM_OUTPUT_TYPE_DIRECTIVE ( file , name , <STR_LIT> ) ;

ASM_OUTPUT_FUNCTION_LABEL ( file , name , decl ) ;


<s> if ( GET_CODE ( r ) == SUBREG && SUBREG_BYTE ( r ) == <NUM_LIT> ) { rtx ireg = SUBREG_REG ( r ) ; machine_mode imode = GET_MODE ( ireg ) ; if ( imode == PSImode && mode == HImode && byte == <NUM_LIT> ) rv = gen_rtx_SUBREG ( mode , ireg , byte ) ; else rv = simplify_gen_subreg ( mode , ireg , imode , byte ) ; } else if ( GET_CODE ( r ) == MEM ) rv = adjust_address ( r , mode , byte ) ; else if ( GET_CODE ( r ) == SYMBOL_REF && ( byte == <NUM_LIT> || byte == <NUM_LIT> ) && mode == HImode ) { rv = gen_rtx_ZERO_EXTRACT ( HImode , r , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> * byte ) ) ; rv = gen_rtx_CONST ( HImode , r ) ;


<s> if ( imode == PSImode && mode == HImode && byte == <NUM_LIT> ) rv = gen_rtx_SUBREG ( mode , ireg , byte ) ; else rv = simplify_gen_subreg ( mode , ireg , imode , byte ) ; } else if ( GET_CODE ( r ) == MEM ) rv = adjust_address ( r , mode , byte ) ; else if ( GET_CODE ( r ) == SYMBOL_REF && ( byte == <NUM_LIT> || byte == <NUM_LIT> ) && mode == HImode ) { rv = gen_rtx_ZERO_EXTRACT ( HImode , r , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> * byte ) ) ; rv = gen_rtx_CONST ( HImode , r ) ;


<s> static void msp430_unique_section ( tree decl , int reloc ) { gcc_assert ( decl != NULL_TREE ) ; if ( TARGET_LARGE && TREE_CODE ( decl ) == FUNCTION_DECL && is_interrupt_func ( decl ) ) { set_decl_section_name ( decl , <STR_LIT> ) ; return ; } default_unique_section ( decl , reloc ) ;


<s> static machine_mode msp430_unwind_word_mode ( void ) {


<s> static const char * cached_match = NULL ; static bool cached_result ; if ( msp430_hwmult_type == F5SERIES ) return true ; if ( target_mcu == NULL || msp430_hwmult_type != AUTO ) return false ; if ( target_mcu == cached_match ) return cached_result ; cached_match = target_mcu ; if ( strncasecmp ( target_mcu , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) return cached_result = true ; if ( strncasecmp ( target_mcu , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) return cached_result = true ; if ( strncasecmp ( target_mcu , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) return cached_result = true ;


<s> static const char * cached_match = NULL ; static bool cached_result ; int i ; if ( msp430_hwmult_type == LARGE ) return true ;

if ( target_mcu == NULL || msp430_hwmult_type != AUTO ) return false ;


<s> static bool use_32bit_hwmult ( void ) { static const char * cached_match = NULL ; static bool cached_result ; int i ; if ( msp430_hwmult_type == LARGE ) return true ; if ( target_mcu == NULL || msp430_hwmult_type != AUTO ) return false ; if ( target_mcu == cached_match ) return cached_result ; cached_match = target_mcu ;


<s> if ( has_attr ( ATTR_EITHER , decl ) ) return either_prefix ; if ( TREE_CODE ( decl ) == FUNCTION_DECL ) { if ( msp430_code_region == MSP430_REGION_LOWER ) return lower_prefix ; if ( msp430_code_region == MSP430_REGION_UPPER ) return upper_prefix ; if ( msp430_code_region == MSP430_REGION_EITHER ) return either_prefix ; } else { if ( msp430_data_region == MSP430_REGION_LOWER ) return lower_prefix ; if ( msp430_data_region == MSP430_REGION_UPPER ) return upper_prefix ;

if ( msp430_data_region == MSP430_REGION_EITHER ) return either_prefix ;


<s> if ( has_attr ( ATTR_LOWER , decl ) ) return lower_prefix ; if ( ! msp430x ) return NULL ; if ( has_attr ( ATTR_UPPER , decl ) ) return upper_prefix ; if ( has_attr ( ATTR_EITHER , decl ) ) return either_prefix ; if ( TREE_CODE ( decl ) == FUNCTION_DECL ) { if ( msp430_code_region == MSP430_REGION_LOWER ) return lower_prefix ; if ( msp430_code_region == MSP430_REGION_UPPER ) return upper_prefix ; if ( msp430_code_region == MSP430_REGION_EITHER ) return either_prefix ; } else { if ( msp430_data_region == MSP430_REGION_LOWER ) return lower_prefix ; if ( msp430_data_region == MSP430_REGION_UPPER ) return upper_prefix ; if ( msp430_data_region == MSP430_REGION_EITHER ) return either_prefix ;


<s> } } const char * message = NULL ; if ( TREE_CODE ( * node ) != FUNCTION_DECL ) { message = <STR_LIT> ; } else if ( TREE_NAME_EQ ( name , ATTR_INTR ) ) { if ( TREE_CODE ( TREE_TYPE ( * node ) ) == FUNCTION_TYPE && ! VOID_TYPE_P ( TREE_TYPE ( TREE_TYPE ( * node ) ) ) ) message = <STR_LIT> ; if ( ! TREE_PUBLIC ( * node ) ) message = <STR_LIT> ; } else if ( TREE_NAME_EQ ( name , ATTR_REENT ) ) { if ( is_naked_func ( * node ) ) message = <STR_LIT> ; else if ( is_critical_func ( * node ) ) message = <STR_LIT> ; } else if ( TREE_NAME_EQ ( name , ATTR_CRIT ) ) { if ( is_naked_func ( * node ) ) message = <STR_LIT> ; else if ( is_reentrant_func ( * node ) ) message = <STR_LIT> ; } else if ( TREE_NAME_EQ ( name , ATTR_NAKED ) ) { if ( is_critical_func ( * node ) ) message = <STR_LIT> ;


<s> int i ; if ( msp430_hwmult_type == MSP430_HWMULT_NONE ) return true ; if ( msp430_hwmult_type != MSP430_HWMULT_AUTO ) return false ; if ( target_mcu == NULL ) return true ;

if ( target_mcu == cached_match ) return cached_result ;


<s> assemble_name ( stream , name ) ; fprintf ( stream , <STR_LIT> HOST_WIDE_INT_PRINT_UNSIGNED <STR_LIT> , size , align / BITS_PER_UNIT ) ; } else { section * sec ; if ( decl ) sec = msp430_select_section ( decl , <NUM_LIT> , align ) ; else switch ( msp430_data_region ) { case MSP430_REGION_UPPER : sec = get_named_section ( NULL , <STR_LIT> , <NUM_LIT> ) ; break ; case MSP430_REGION_LOWER : sec = get_named_section ( NULL , <STR_LIT> , <NUM_LIT> ) ; break ; case MSP430_REGION_EITHER : sec = get_named_section ( NULL , <STR_LIT> , <NUM_LIT> ) ; break ; default : gcc_unreachable ( ) ; } gcc_assert ( sec != NULL ) ; switch_to_section ( sec ) ; ASM_OUTPUT_ALIGN ( stream , floor_log2 ( align / BITS_PER_UNIT ) ) ; targetm . asm_out . globalize_label ( stream , name ) ; ASM_WEAKEN_LABEL ( stream , name ) ;


<s> fprintf ( stream , <STR_LIT> HOST_WIDE_INT_PRINT_UNSIGNED <STR_LIT> , size , align / BITS_PER_UNIT ) ; } else { section * sec ; if ( decl ) sec = msp430_select_section ( decl , <NUM_LIT> , align ) ; else switch ( msp430_data_region ) { case MSP430_REGION_UPPER : sec = get_named_section ( NULL , <STR_LIT> , <NUM_LIT> ) ; break ; case MSP430_REGION_LOWER : sec = get_named_section ( NULL , <STR_LIT> , <NUM_LIT> ) ; break ;

case MSP430_REGION_EITHER : sec = get_named_section ( NULL , <STR_LIT> , <NUM_LIT> ) ; break ;


<s> break ; } if ( msp430_hwmult_type != MSP430_HWMULT_NONE ) { if ( strcmp ( <STR_LIT> , name ) == <NUM_LIT> ) { if ( msp430_use_f5_series_hwmult ( ) ) name = <STR_LIT> ; else if ( ! msp430_no_hwmult ( ) ) name = <STR_LIT> ; } else if ( strcmp ( <STR_LIT> , name ) == <NUM_LIT> ) { if ( msp430_use_f5_series_hwmult ( ) ) name = <STR_LIT> ; else if ( use_32bit_hwmult ( ) ) name = <STR_LIT> ; else if ( ! msp430_no_hwmult ( ) ) name = <STR_LIT> ; }


<s> if ( TREE_CODE ( intr_vector ) == STRING_CST ) sprintf ( buf , <STR_LIT> , TREE_STRING_POINTER ( intr_vector ) ) ; else sprintf ( buf , <STR_LIT> , ( unsigned int ) TREE_INT_CST_LOW ( intr_vector ) ) ; switch_to_section ( get_section ( buf , SECTION_CODE , decl ) ) ; fputs ( <STR_LIT> , file ) ; assemble_name ( file , name ) ; fputc ( '\n' , file ) ; fputc ( '\t' , file ) ;


<s> cached_match = target_mcu ; if ( strncasecmp ( target_mcu , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) return cached_result = true ; if ( strncasecmp ( target_mcu , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) return cached_result = true ; if ( strncasecmp ( target_mcu , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) return cached_result = true ; int i ; for ( i = ARRAY_SIZE ( msp430_mcu_data ) ; i -- ; ) if ( strcasecmp ( target_mcu , msp430_mcu_data [ i ] . name ) == <NUM_LIT> ) return cached_result = msp430_mcu_data [ i ] . hwmpy == <NUM_LIT> ;


<s> if ( strncasecmp ( target_mcu , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) return cached_result = true ; if ( strncasecmp ( target_mcu , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) return cached_result = true ; int i ; for ( i = ARRAY_SIZE ( msp430_mcu_data ) ; i -- ; ) if ( strcasecmp ( target_mcu , msp430_mcu_data [ i ] . name ) == <NUM_LIT> ) return cached_result = msp430_mcu_data [ i ] . hwmpy == <NUM_LIT> ; return cached_result = false ;


<s> cached_match = target_mcu ; for ( i = ARRAY_SIZE ( msp430_mcu_data ) ; i -- ; ) if ( strcasecmp ( target_mcu , msp430_mcu_data [ i ] . name ) == <NUM_LIT> ) return cached_result = msp430_mcu_data [ i ] . hwmpy == <NUM_LIT> ;


<s> if ( has_attr ( ATTR_LOWER , decl ) ) return lower_prefix ; if ( ! msp430x ) return NULL ; if ( has_attr ( ATTR_UPPER , decl ) ) return upper_prefix ; if ( has_attr ( ATTR_EITHER , decl ) ) return either_prefix ; if ( TREE_CODE ( decl ) == FUNCTION_DECL ) { if ( msp430_code_region == MSP430_REGION_LOWER ) return lower_prefix ; if ( msp430_code_region == MSP430_REGION_UPPER ) return upper_prefix ; if ( msp430_code_region == MSP430_REGION_EITHER ) return either_prefix ; }


<s> else if ( TREE_NAME_EQ ( name , ATTR_INTR ) ) { if ( TREE_CODE ( TREE_TYPE ( * node ) ) == FUNCTION_TYPE && ! VOID_TYPE_P ( TREE_TYPE ( TREE_TYPE ( * node ) ) ) ) message = <STR_LIT> ; if ( ! TREE_PUBLIC ( * node ) ) message = <STR_LIT> ; TREE_USED ( * node ) = <NUM_LIT> ; DECL_PRESERVE_P ( * node ) = <NUM_LIT> ; } else if ( TREE_NAME_EQ ( name , ATTR_REENT ) ) { if ( is_naked_func ( * node ) ) message = <STR_LIT> ; else if ( is_critical_func ( * node ) ) message = <STR_LIT> ; } else if ( TREE_NAME_EQ ( name , ATTR_CRIT ) ) { if ( is_naked_func ( * node ) ) message = <STR_LIT> ;


<s> if ( TREE_CODE ( * node ) != VAR_DECL ) message = G_ ( <STR_LIT> ) ; if ( ( TREE_STATIC ( * node ) || DECL_EXTERNAL ( * node ) || in_lto_p ) && DECL_SECTION_NAME ( * node ) ) message = G_ ( <STR_LIT> ) ; if ( ! message && TREE_NAME_EQ ( name , ATTR_PERSIST ) && ! TREE_STATIC ( * node ) && ! TREE_PUBLIC ( * node ) && ! DECL_EXTERNAL ( * node ) ) message = G_ ( <STR_LIT> ) ; if ( ( TREE_STATIC ( * node ) || DECL_EXTERNAL ( * node ) || in_lto_p ) && TREE_NAME_EQ ( name , ATTR_PERSIST ) ) set_decl_section_name ( * node , <STR_LIT> ) ; if ( DECL_COMMON ( * node ) ) DECL_COMMON ( * node ) = <NUM_LIT> ; if ( message ) { warning ( OPT_Wattributes , message , name ) ; * no_add_attrs = true ; }


<s> if ( mode == PSImode ) return <NUM_LIT> ; if ( mode == CPSImode ) return <NUM_LIT> ; return msp430_hard_regno_nregs ( regno , mode ) ;


<s> flag_delete_null_pointer_checks = <NUM_LIT> ; init_machine_status = msp430_init_machine_status ; if ( target_cpu ) { if ( strcasecmp ( target_cpu , <STR_LIT> ) == <NUM_LIT> ) msp430x = true ; else msp430x = false ; } if ( target_mcu ) { int i ; for ( i = ARRAY_SIZE ( msp430_mcu_data ) ; i -- ; ) if ( strcasecmp ( msp430_mcu_data [ i ] . name , target_mcu ) == <NUM_LIT> ) { bool xisa = msp430_mcu_data [ i ] . revision >= <NUM_LIT> ; if ( msp430_warn_mcu ) { if ( target_cpu && msp430x != xisa ) warning ( <NUM_LIT> , <STR_LIT> , target_mcu , xisa ? <STR_LIT> : <STR_LIT> , msp430x ? <STR_LIT> : <STR_LIT> ) ; if ( msp430_mcu_data [ i ] . hwmpy == <NUM_LIT> && msp430_hwmult_type != MSP430_HWMULT_AUTO && msp430_hwmult_type != MSP430_HWMULT_NONE ) warning ( <NUM_LIT> , <STR_LIT> , target_mcu , msp430_hwmult_type == MSP430_HWMULT_SMALL ? <STR_LIT> : msp430_hwmult_type == MSP430_HWMULT_LARGE ? <STR_LIT> : <STR_LIT> ) ; else if ( msp430_hwmult_type == MSP430_HWMULT_SMALL && msp430_mcu_data [ i ] . hwmpy != <NUM_LIT> && msp430_mcu_data [ i ] . hwmpy != <NUM_LIT> ) warning ( <NUM_LIT> , <STR_LIT> , target_mcu , hwmult_name ( msp430_mcu_data [ i ] . hwmpy ) ) ; else if ( msp430_hwmult_type == MSP430_HWMULT_LARGE && msp430_mcu_data [ i ] . hwmpy != <NUM_LIT> ) warning ( <NUM_LIT> , <STR_LIT> , target_mcu , hwmult_name ( msp430_mcu_data [ i ] . hwmpy ) ) ; else if ( msp430_hwmult_type == MSP430_HWMULT_F5SERIES && msp430_mcu_data [ i ] . hwmpy != <NUM_LIT> ) warning ( <NUM_LIT> , <STR_LIT> , target_mcu , hwmult_name ( msp430_mcu_data [ i ] . hwmpy ) ) ;


<s> if ( is_critical_func ( ) ) fprintf ( outfile , <STR_LIT> ) ; if ( is_wakeup_func ( ) ) fprintf ( outfile , <STR_LIT> ) ; fprintf ( outfile , <STR_LIT> ) ; } fprintf ( outfile , <STR_LIT> , cfun -> machine -> framesize_regs ) ; fprintf ( outfile , <STR_LIT> , cfun -> machine -> framesize_locals ) ; fprintf ( outfile , <STR_LIT> , cfun -> machine -> framesize_outgoing ) ; fprintf ( outfile , <STR_LIT> , cfun -> machine -> framesize ) ; fprintf ( outfile , <STR_LIT> , msp430_initial_elimination_offset ( ARG_POINTER_REGNUM , FRAME_POINTER_REGNUM ) ) ; fprintf ( outfile , <STR_LIT> , msp430_initial_elimination_offset ( FRAME_POINTER_REGNUM , STACK_POINTER_REGNUM ) ) ; n = <NUM_LIT> ;


<s> if ( is_wakeup_func ( ) ) fprintf ( outfile , <STR_LIT> ) ; fprintf ( outfile , <STR_LIT> ) ; } fprintf ( outfile , <STR_LIT> , cfun -> machine -> framesize_regs ) ; fprintf ( outfile , <STR_LIT> , cfun -> machine -> framesize_locals ) ; fprintf ( outfile , <STR_LIT> , cfun -> machine -> framesize_outgoing ) ; fprintf ( outfile , <STR_LIT> , cfun -> machine -> framesize ) ; fprintf ( outfile , <STR_LIT> , msp430_initial_elimination_offset ( ARG_POINTER_REGNUM , FRAME_POINTER_REGNUM ) ) ; fprintf ( outfile , <STR_LIT> , msp430_initial_elimination_offset ( FRAME_POINTER_REGNUM , STACK_POINTER_REGNUM ) ) ; n = <NUM_LIT> ; fprintf ( outfile , <STR_LIT> ) ; for ( r = <NUM_LIT> ; r < ARG_POINTER_REGNUM ; r ++ ) if ( cfun -> machine -> need_to_save [ r ] ) {

fprintf ( outfile , <STR_LIT> , reg_names [ r ] ) ;


<s> } else if ( TREE_NAME_EQ ( name , ATTR_INTR ) ) { if ( TREE_CODE ( TREE_TYPE ( * node ) ) == FUNCTION_TYPE && ! VOID_TYPE_P ( TREE_TYPE ( TREE_TYPE ( * node ) ) ) ) message = <STR_LIT> ; else { TREE_USED ( * node ) = <NUM_LIT> ; DECL_PRESERVE_P ( * node ) = <NUM_LIT> ; } if ( is_critical_func ( * node ) ) { warning ( OPT_Wattributes , <STR_LIT> ) ; DECL_ATTRIBUTES ( * node ) = remove_attribute ( ATTR_CRIT , DECL_ATTRIBUTES ( * node ) ) ; } } else if ( TREE_NAME_EQ ( name , ATTR_REENT ) ) { if ( is_naked_func ( * node ) ) message = <STR_LIT> ; else if ( is_critical_func ( * node ) ) message = <STR_LIT> ; } else if ( TREE_NAME_EQ ( name , ATTR_CRIT ) ) {


<s> } if ( is_critical_func ( * node ) ) { warning ( OPT_Wattributes , <STR_LIT> ) ; DECL_ATTRIBUTES ( * node ) = remove_attribute ( ATTR_CRIT , DECL_ATTRIBUTES ( * node ) ) ; } } else if ( TREE_NAME_EQ ( name , ATTR_REENT ) ) { if ( is_naked_func ( * node ) ) message = <STR_LIT> ; else if ( is_critical_func ( * node ) ) message = <STR_LIT> ; } else if ( TREE_NAME_EQ ( name , ATTR_CRIT ) ) { if ( is_naked_func ( * node ) ) message = <STR_LIT> ; else if ( is_reentrant_func ( * node ) ) message = <STR_LIT> ; else if ( is_interrupt_func ( * node ) ) message = <STR_LIT> ; } else if ( TREE_NAME_EQ ( name , ATTR_NAKED ) ) { if ( is_critical_func ( * node ) ) message = <STR_LIT> ; else if ( is_reentrant_func ( * node ) ) message = <STR_LIT> ; } if ( message ) { warning ( OPT_Wattributes , message , name ) ; * no_add_attrs = true ; }


<s> const char * msp430_mcu_name ( void ) { if ( target_mcu ) { unsigned int i ; unsigned int start_upper ; unsigned int end_upper ; static char mcu_name [ <NUM_LIT> ] ; if ( strncmp ( target_mcu , <STR_LIT> , <NUM_LIT> ) == <NUM_LIT> ) { snprintf ( mcu_name , sizeof ( mcu_name ) - <NUM_LIT> , <STR_LIT> , target_mcu + <NUM_LIT> ) ; start_upper = <NUM_LIT> ; } else { snprintf ( mcu_name , sizeof ( mcu_name ) - <NUM_LIT> , <STR_LIT> , target_mcu ) ; start_upper = <NUM_LIT> ; } end_upper = strlen ( mcu_name ) - <NUM_LIT> ; for ( i = start_upper ; i < end_upper ; i ++ ) mcu_name [ i ] = TOUPPER ( mcu_name [ i ] ) ; return mcu_name ;


<s> if ( target_cpu && msp430x != xisa ) warning ( <NUM_LIT> , <STR_LIT> <STR_LIT> , target_mcu , xisa ? <STR_LIT> : <STR_LIT> , msp430x ? <STR_LIT> : <STR_LIT> ) ; if ( msp430_mcu_data [ i ] . hwmpy == <NUM_LIT> && msp430_hwmult_type != MSP430_HWMULT_AUTO && msp430_hwmult_type != MSP430_HWMULT_NONE ) warning ( <NUM_LIT> , <STR_LIT> <STR_LIT> , target_mcu , msp430_hwmult_type == MSP430_HWMULT_SMALL ? <STR_LIT> : msp430_hwmult_type == MSP430_HWMULT_LARGE ? <STR_LIT> : <STR_LIT> ) ; else if ( msp430_hwmult_type == MSP430_HWMULT_SMALL && msp430_mcu_data [ i ] . hwmpy != <NUM_LIT> && msp430_mcu_data [ i ] . hwmpy != <NUM_LIT> ) warning ( <NUM_LIT> , <STR_LIT> <STR_LIT> , target_mcu , hwmult_name ( msp430_mcu_data [ i ] . hwmpy ) ) ; else if ( msp430_hwmult_type == MSP430_HWMULT_LARGE && msp430_mcu_data [ i ] . hwmpy != <NUM_LIT> ) warning ( <NUM_LIT> , <STR_LIT> <STR_LIT> , target_mcu , hwmult_name ( msp430_mcu_data [ i ] . hwmpy ) ) ; else if ( msp430_hwmult_type == MSP430_HWMULT_F5SERIES && msp430_mcu_data [ i ] . hwmpy != <NUM_LIT> ) warning ( <NUM_LIT> , <STR_LIT> <STR_LIT> , target_mcu , hwmult_name ( msp430_mcu_data [ i ] . hwmpy ) ) ; } msp430x = xisa ; break ; } if ( i < <NUM_LIT> ) { if ( msp430_hwmult_type == MSP430_HWMULT_AUTO ) { if ( msp430_warn_mcu ) { if ( target_cpu == NULL ) warning ( <NUM_LIT> , <STR_LIT> <STR_LIT> <STR_LIT> <STR_LIT> , target_mcu ) ; else warning ( <NUM_LIT> , <STR_LIT> <STR_LIT> <STR_LIT> , target_mcu ) ; } msp430_hwmult_type = MSP430_HWMULT_NONE ; } else if ( target_cpu == NULL ) { if ( msp430_warn_mcu ) warning ( <NUM_LIT> , <STR_LIT> <STR_LIT> <STR_LIT> , target_mcu ) ; msp430x = false ; } else if ( msp430_warn_mcu ) warning ( <NUM_LIT> , <STR_LIT> , target_mcu ) ; } } if ( target_cpu == NULL && target_mcu == NULL && msp430_hwmult_type == MSP430_HWMULT_F5SERIES ) msp430x = true ; if ( TARGET_LARGE && ! msp430x ) error ( <STR_LIT> ) ;

if ( msp430_code_region == MSP430_REGION_UPPER && ! msp430x ) error ( <STR_LIT> ) ;


<s> int i ; for ( i = <NUM_LIT> ; helper_function_name_mappings [ i ] . gcc_name ; i ++ ) if ( strcmp ( helper_function_name_mappings [ i ] . gcc_name , name ) == <NUM_LIT> ) { name = helper_function_name_mappings [ i ] . ti_name ; break ; } if ( msp430_hwmult_type != MSP430_HWMULT_NONE ) { if ( strcmp ( <STR_LIT> , name ) == <NUM_LIT> ) { if ( msp430_use_f5_series_hwmult ( ) ) name = <STR_LIT> ; else if ( ! msp430_no_hwmult ( ) ) name = <STR_LIT> ; } else if ( strcmp ( <STR_LIT> , name ) == <NUM_LIT> ) {


<s> void msp430_output_labelref ( FILE * file , const char * name ) { int i ; for ( i = <NUM_LIT> ; helper_function_name_mappings [ i ] . gcc_name ; i ++ ) if ( strcmp ( helper_function_name_mappings [ i ] . gcc_name , name ) == <NUM_LIT> ) { name = helper_function_name_mappings [ i ] . ti_name ; break ; } if ( msp430_hwmult_type != MSP430_HWMULT_NONE ) { if ( strcmp ( <STR_LIT> , name ) == <NUM_LIT> ) { if ( msp430_use_f5_series_hwmult ( ) ) name = <STR_LIT> ; else if ( ! msp430_no_hwmult ( ) ) name = <STR_LIT> ;


<s> case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : return <NUM_LIT> ;


<s> static rtx F ( rtx x ) { RTX_FRAME_RELATED_P ( x ) = <NUM_LIT> ;


<s> if ( DECL_ONE_ONLY ( decl ) ) return NULL ; if ( has_attr ( <STR_LIT> , decl ) ) return NULL ; if ( has_section_name ( <STR_LIT> , decl ) ) return NULL ; if ( ! TARGET_LARGE ) return NULL ; if ( has_attr ( ATTR_LOWER , decl ) ) return lower_prefix ; if ( has_attr ( ATTR_UPPER , decl ) ) return upper_prefix ; if ( has_attr ( ATTR_EITHER , decl ) ) return either_prefix ; if ( TREE_CODE ( decl ) == FUNCTION_DECL ) { if ( ( msp430_code_region == MSP430_REGION_LOWER ) && TARGET_USE_LOWER_REGION_PREFIX ) return lower_prefix ; if ( msp430_code_region == MSP430_REGION_UPPER ) return upper_prefix ; if ( msp430_code_region == MSP430_REGION_EITHER ) return either_prefix ; } else { if ( ( msp430_data_region == MSP430_REGION_LOWER ) && TARGET_USE_LOWER_REGION_PREFIX ) return lower_prefix ; if ( msp430_data_region == MSP430_REGION_UPPER ) return upper_prefix ; if ( msp430_data_region == MSP430_REGION_EITHER ) return either_prefix ; } return NULL ;


<s> if ( decl == NULL_TREE ) return false ;

return lookup_attribute ( attr , DECL_ATTRIBUTES ( decl ) ) != NULL_TREE ;


<s> static inline bool has_attr ( const char * attr , tree decl ) { if ( decl == NULL_TREE ) return false ;


<s> static bool has_section_name ( const char * name , tree decl = current_function_decl ) {


<s> switch ( val ) { case <NUM_LIT> : return <STR_LIT> ;


<s> if ( TARGET_LARGE ) F ( emit_insn ( gen_subpsi3 ( sp , sp , inc ) ) ) ; else F ( emit_insn ( gen_subhi3 ( sp , sp , inc ) ) ) ; } else { inc = GEN_INT ( amount ) ; if ( TARGET_LARGE ) F ( emit_insn ( gen_addpsi3 ( sp , sp , inc ) ) ) ; else F ( emit_insn ( gen_addhi3 ( sp , sp , inc ) ) ) ;


<s> if ( TARGET_LARGE ) F ( emit_insn ( gen_subpsi3 ( sp , sp , inc ) ) ) ; else F ( emit_insn ( gen_subhi3 ( sp , sp , inc ) ) ) ; } else { inc = GEN_INT ( amount ) ; if ( TARGET_LARGE ) F ( emit_insn ( gen_addpsi3 ( sp , sp , inc ) ) ) ; else F ( emit_insn ( gen_addhi3 ( sp , sp , inc ) ) ) ; }


<s> return has_attr ( ATTR_CRIT , decl ) ;


<s> return has_attr ( ATTR_INTR , decl ) ;


<s> static bool is_interrupt_func ( tree decl = current_function_decl ) {


<s> return has_attr ( ATTR_NAKED , decl ) ;


<s> static inline bool is_reentrant_func ( tree decl = current_function_decl ) {


<s> return has_attr ( ATTR_REENT , decl ) ;


<s> return is_interrupt_func ( decl ) && has_attr ( ATTR_WAKEUP , decl ) ;


<s> return <NUM_LIT> ; } else if ( REGNO ( operands [ <NUM_LIT> ] ) + <NUM_LIT> == REGNO ( operands [ <NUM_LIT> ] ) ) { if ( ! return_length ) output_asm_insn ( <STR_LIT> , operands ) ; return <NUM_LIT> ; }


<s> } else if ( REGNO ( operands [ <NUM_LIT> ] ) + <NUM_LIT> == REGNO ( operands [ <NUM_LIT> ] ) ) { if ( ! return_length ) output_asm_insn ( <STR_LIT> , operands ) ; return <NUM_LIT> ;


<s> bool msp430x_insn_required ( rtx op ) { return ( GET_MODE ( op ) == PSImode || ! msp430_op_not_in_high_mem ( op ) ) ;


<s> if ( INTVAL ( amount ) > <NUM_LIT> && INTVAL ( amount ) < <NUM_LIT> ) return <STR_LIT> ; if ( INTVAL ( amount ) > <NUM_LIT> && INTVAL ( amount ) < <NUM_LIT> ) return <STR_LIT> ;


<s> const char * msp430x_logical_shift_right ( rtx amount ) { gcc_assert ( CONST_INT_P ( amount ) ) ; if ( INTVAL ( amount ) <= <NUM_LIT> || INTVAL ( amount ) >= <NUM_LIT> ) return <STR_LIT> ;

if ( INTVAL ( amount ) > <NUM_LIT> && INTVAL ( amount ) < <NUM_LIT> ) return <STR_LIT> ;


<s> if ( to_as != ADDR_SPACE_FAR && from_as == ADDR_SPACE_FAR ) { if ( CONSTANT_P ( op ) ) return gen_rtx_CONST ( HImode , op ) ; result = gen_reg_rtx ( HImode ) ; emit_insn ( gen_truncpsihi2 ( result , op ) ) ;


<s> msp430_addr_space_legitimate_address_p bool msp430_addr_space_legitimate_address_p ( machine_mode mode , rtx x , bool strict , addr_space_t as ATTRIBUTE_UNUSED ) {

return msp430_legitimate_address_p ( mode , x , strict ) ;


<s> switch ( addrspace ) { default : case ADDR_SPACE_GENERIC : return Pmode ; case ADDR_SPACE_NEAR : return HImode ; case ADDR_SPACE_FAR : return PSImode ; }


<s> msp430_allocate_stack_slots_for_args static bool msp430_allocate_stack_slots_for_args ( void ) {


<s> if ( ca -> reg_count && ca -> mem_count ) return ca -> reg_count * UNITS_PER_WORD ; return <NUM_LIT> ;


<s> int msp430_arg_partial_bytes ( cumulative_args_t cap , const function_arg_info & arg ) { CUMULATIVE_ARGS * ca = get_cumulative_args ( cap ) ;

msp430_evaluate_arg ( cap , arg . mode , arg . type , arg . named ) ;


<s> static bool msp430_asm_integer ( rtx x , unsigned int size , int aligned_p ) { int c = GET_CODE ( x ) ; if ( size == <NUM_LIT> && GET_MODE ( x ) == PSImode ) size = <NUM_LIT> ; switch ( size ) { case <NUM_LIT> : if ( c == SYMBOL_REF || c == CONST || c == LABEL_REF || c == CONST_INT || c == PLUS || c == MINUS ) { fprintf ( asm_out_file , <STR_LIT> ) ; output_addr_const ( asm_out_file , x ) ; fputc ( '\n' , asm_out_file ) ; return true ; } break ; } return default_assemble_integer ( x , size , aligned_p ) ;


<s> if ( wi :: gtu_p ( wi :: to_wide ( value ) , <NUM_LIT> ) ) warning ( OPT_Wattributes , <STR_LIT> , name ) ; break ; default : warning ( OPT_Wattributes , <STR_LIT> <STR_LIT> , name ) ; * no_add_attrs = true ; break ; } } const char * message = NULL ; if ( TREE_CODE ( * node ) != FUNCTION_DECL ) { message = <STR_LIT> ; } else if ( TREE_NAME_EQ ( name , ATTR_INTR ) ) { if ( TREE_CODE ( TREE_TYPE ( * node ) ) == FUNCTION_TYPE && ! VOID_TYPE_P ( TREE_TYPE ( TREE_TYPE ( * node ) ) ) ) message = <STR_LIT> ; else { TREE_USED ( * node ) = <NUM_LIT> ; DECL_PRESERVE_P ( * node ) = <NUM_LIT> ; } if ( is_critical_func ( * node ) ) { warning ( OPT_Wattributes , <STR_LIT> ) ; DECL_ATTRIBUTES ( * node ) = remove_attribute ( ATTR_CRIT , DECL_ATTRIBUTES ( * node ) ) ; } } else if ( TREE_NAME_EQ ( name , ATTR_CRIT ) ) { if ( is_interrupt_func ( * node ) ) message = <STR_LIT> ; }


<s> return msp430_builtins [ code ] ; default : return error_mark_node ;


<s> if ( CONST_INT_P ( op ) && IN_RANGE ( INTVAL ( op ) , HOST_WIDE_INT_M1U << <NUM_LIT> , ( <NUM_LIT> << <NUM_LIT> ) - <NUM_LIT> ) ) return true ;


<s> static bool msp430_check_index_not_high_mem ( rtx op ) { if ( CONST_INT_P ( op ) && IN_RANGE ( INTVAL ( op ) , HOST_WIDE_INT_M1U << <NUM_LIT> , ( <NUM_LIT> << <NUM_LIT> ) - <NUM_LIT> ) ) return true ;


<s> if ( SYMBOL_REF_P ( op0 ) && ( SYMBOL_REF_FLAGS ( op0 ) & SYMBOL_FLAG_LOW_MEM ) && msp430_check_index_not_high_mem ( op1 ) ) return true ; return false ;


<s> cfun -> machine -> need_to_save [ i ] = <NUM_LIT> ; cfun -> machine -> framesize_regs += ( TARGET_LARGE ? <NUM_LIT> : <NUM_LIT> ) ; } else cfun -> machine -> need_to_save [ i ] = <NUM_LIT> ; if ( ( cfun -> machine -> framesize_locals + cfun -> machine -> framesize_outgoing ) & <NUM_LIT> ) cfun -> machine -> framesize_locals ++ ; cfun -> machine -> framesize = ( cfun -> machine -> framesize_regs + cfun -> machine -> framesize_locals + cfun -> machine -> framesize_outgoing ) ;


<s> rtx msp430_eh_return_stackadj_rtx ( void ) { if ( ! cfun -> machine -> eh_stack_adjust ) { rtx sa ; sa = gen_rtx_REG ( Pmode , <NUM_LIT> ) ; cfun -> machine -> eh_stack_adjust = sa ;


<s> if ( ! MEM_P ( rtl ) ) return ; symbol = XEXP ( rtl , <NUM_LIT> ) ;

if ( GET_CODE ( symbol ) != SYMBOL_REF ) return ;


<s> if ( VAR_P ( decl ) && ( TREE_STATIC ( decl ) || DECL_EXTERNAL ( decl ) ) && msp430_var_in_low_mem ( decl ) ) SYMBOL_REF_FLAGS ( symbol ) = SYMBOL_FLAG_LOW_MEM ;


<s> ca -> mem_count = <NUM_LIT> ; if ( ! named ) return ; if ( mode == PSImode ) nregs = <NUM_LIT> ; else nregs = ( nregs + <NUM_LIT> ) / <NUM_LIT> ; if ( ca -> special_p ) { ca -> start_reg = <NUM_LIT> ; ca -> reg_count = <NUM_LIT> ; return ; } switch ( nregs ) { case <NUM_LIT> : for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( ! ca -> reg_used [ i ] ) { ca -> reg_count = <NUM_LIT> ; ca -> start_reg = CA_FIRST_REG + i ; return ; } break ; case <NUM_LIT> : for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( ! ca -> reg_used [ i ] && ! ca -> reg_used [ i + <NUM_LIT> ] ) { ca -> reg_count = <NUM_LIT> ; ca -> start_reg = CA_FIRST_REG + i ; return ;


<s> static rtx msp430_expand_builtin ( tree exp , rtx target ATTRIBUTE_UNUSED , rtx subtarget ATTRIBUTE_UNUSED , machine_mode mode ATTRIBUTE_UNUSED , int ignore ATTRIBUTE_UNUSED ) { tree fndecl = TREE_OPERAND ( CALL_EXPR_FN ( exp ) , <NUM_LIT> ) ; unsigned int fcode = DECL_MD_FUNCTION_CODE ( fndecl ) ; rtx arg1 = expand_normal ( CALL_EXPR_ARG ( exp , <NUM_LIT> ) ) ; if ( fcode == MSP430_BUILTIN_DELAY_CYCLES ) return msp430_expand_delay_cycles ( arg1 ) ; if ( ! msp430_is_interrupt_func ( ) ) { error ( <STR_LIT> ) ; return NULL_RTX ; } if ( ! REG_P ( arg1 ) && ! CONSTANT_P ( arg1 ) ) arg1 = force_reg ( mode , arg1 ) ; switch ( fcode ) {

case MSP430_BUILTIN_BIC_SR : emit_insn ( gen_bic_SR ( arg1 ) ) ; break ;


<s> if ( ! msp430_is_interrupt_func ( ) ) { error ( <STR_LIT> ) ; return NULL_RTX ; } if ( ! REG_P ( arg1 ) && ! CONSTANT_P ( arg1 ) ) arg1 = force_reg ( mode , arg1 ) ; switch ( fcode ) { case MSP430_BUILTIN_BIC_SR : emit_insn ( gen_bic_SR ( arg1 ) ) ; break ; case MSP430_BUILTIN_BIS_SR : emit_insn ( gen_bis_SR ( arg1 ) ) ; break ; default :


<s> if ( c >= <NUM_LIT> * <NUM_LIT> + CYCX ( <NUM_LIT> , <NUM_LIT> ) ) { i = <NUM_LIT> ; c -= CYCX ( <NUM_LIT> , <NUM_LIT> ) + <NUM_LIT> * <NUM_LIT> ; i += c / <NUM_LIT> ; c %= <NUM_LIT> ; if ( ( unsigned long long ) i > <NUM_LIT> ) { error ( <STR_LIT> ) ; return NULL_RTX ; } } else { i = ( c - CYCX ( <NUM_LIT> , <NUM_LIT> ) ) / <NUM_LIT> ; c -= CYCX ( <NUM_LIT> , <NUM_LIT> ) + i * <NUM_LIT> ; } if ( cg_magic_constant ( i & <NUM_LIT> ) ) c ++ ; if ( cg_magic_constant ( ( i >> <NUM_LIT> ) & <NUM_LIT> ) ) c ++ ; if ( msp430x ) emit_insn ( gen_delay_cycles_32x ( GEN_INT ( i ) , GEN_INT ( n - c ) ) ) ;

else emit_insn ( gen_delay_cycles_32 ( GEN_INT ( i ) , GEN_INT ( n - c ) ) ) ;


<s> n = c ; if ( c >= <NUM_LIT> * <NUM_LIT> + CYCX ( <NUM_LIT> , <NUM_LIT> ) ) { i = <NUM_LIT> ; c -= CYCX ( <NUM_LIT> , <NUM_LIT> ) + <NUM_LIT> * <NUM_LIT> ; i += c / <NUM_LIT> ; c %= <NUM_LIT> ; if ( ( unsigned long long ) i > <NUM_LIT> ) { error ( <STR_LIT> ) ; return NULL_RTX ; } } else { i = ( c - CYCX ( <NUM_LIT> , <NUM_LIT> ) ) / <NUM_LIT> ; c -= CYCX ( <NUM_LIT> , <NUM_LIT> ) + i * <NUM_LIT> ; } if ( cg_magic_constant ( i & <NUM_LIT> ) ) c ++ ; if ( cg_magic_constant ( ( i >> <NUM_LIT> ) & <NUM_LIT> ) ) c ++ ; if ( msp430x ) emit_insn ( gen_delay_cycles_32x ( GEN_INT ( i ) , GEN_INT ( n - c ) ) ) ; else emit_insn ( gen_delay_cycles_32 ( GEN_INT ( i ) , GEN_INT ( n - c ) ) ) ; }


<s> tmp = plus_constant ( Pmode , tmp , TARGET_LARGE ? - <NUM_LIT> : - <NUM_LIT> ) ; tmp = gen_rtx_MEM ( Pmode , tmp ) ; emit_move_insn ( tmp , ra ) ;


<s> void msp430_expand_eh_return ( rtx eh_handler ) { rtx ap , sa , ra , tmp ; ap = arg_pointer_rtx ; sa = msp430_eh_return_stackadj_rtx ( ) ; ra = eh_handler ; tmp = ap ; tmp = gen_rtx_PLUS ( Pmode , ap , sa ) ; tmp = plus_constant ( Pmode , tmp , TARGET_LARGE ? - <NUM_LIT> : - <NUM_LIT> ) ; tmp = gen_rtx_MEM ( Pmode , tmp ) ;


<s> if ( cfun -> machine -> need_to_save [ <NUM_LIT> ] ) { helper_n = <NUM_LIT> ; for ( i = <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) if ( ! cfun -> machine -> need_to_save [ i ] ) { helper_n = <NUM_LIT> - i ; for ( ; i >= <NUM_LIT> ; i -- ) if ( cfun -> machine -> need_to_save [ i ] ) { helper_n = <NUM_LIT> ; break ; } break ; } } emit_insn ( gen_epilogue_start_marker ( ) ) ; if ( cfun -> decl && strcmp ( IDENTIFIER_POINTER ( DECL_NAME ( cfun -> decl ) ) , <STR_LIT> ) == <NUM_LIT> ) emit_insn ( gen_msp430_refsym_need_exit ( ) ) ; if ( is_wakeup_func ( ) ) emit_insn ( gen_bic_SR ( GEN_INT ( <NUM_LIT> ) ) ) ; fs = cfun -> machine -> framesize_locals + cfun -> machine -> framesize_outgoing ; increment_stack ( fs ) ; if ( is_eh ) { rtx r12 = gen_rtx_REG ( Pmode , <NUM_LIT> ) ; rtx ( * addPmode ) ( rtx , rtx , rtx ) = TARGET_LARGE ? gen_addpsi3 : gen_addhi3 ; i = cfun -> machine -> framesize_regs ; emit_move_insn ( r12 , stack_pointer_rtx ) ; emit_insn ( addPmode ( r12 , r12 , EH_RETURN_STACKADJ_RTX ) ) ; emit_insn ( addPmode ( r12 , r12 , GEN_INT ( i ) ) ) ;

emit_move_insn ( gen_rtx_MEM ( Pmode , plus_constant ( Pmode , stack_pointer_rtx , i ) ) , r12 ) ;


<s> if ( cfun -> decl && strcmp ( IDENTIFIER_POINTER ( DECL_NAME ( cfun -> decl ) ) , <STR_LIT> ) == <NUM_LIT> ) emit_insn ( gen_msp430_refsym_need_exit ( ) ) ; if ( is_wakeup_func ( ) ) emit_insn ( gen_bic_SR ( GEN_INT ( <NUM_LIT> ) ) ) ; fs = cfun -> machine -> framesize_locals + cfun -> machine -> framesize_outgoing ; increment_stack ( fs ) ; if ( is_eh ) { rtx r12 = gen_rtx_REG ( Pmode , <NUM_LIT> ) ; rtx ( * addPmode ) ( rtx , rtx , rtx ) = TARGET_LARGE ? gen_addpsi3 : gen_addhi3 ; i = cfun -> machine -> framesize_regs ; emit_move_insn ( r12 , stack_pointer_rtx ) ; emit_insn ( addPmode ( r12 , r12 , EH_RETURN_STACKADJ_RTX ) ) ; emit_insn ( addPmode ( r12 , r12 , GEN_INT ( i ) ) ) ; emit_move_insn ( gen_rtx_MEM ( Pmode , plus_constant ( Pmode , stack_pointer_rtx , i ) ) , r12 ) ; } for ( i = <NUM_LIT> ; i <= <NUM_LIT> ; i ++ ) if ( cfun -> machine -> need_to_save [ i ] ) { int seq ; int count = <NUM_LIT> ; int helper_used = <NUM_LIT> ; rtx note , addr ; if ( msp430x ) { for ( seq = i + <NUM_LIT> ; seq <= <NUM_LIT> && cfun -> machine -> need_to_save [ seq ] ; seq ++ ) ; count = seq - i ; } if ( msp430x ) { p = F ( emit_insn ( gen_popm ( stack_pointer_rtx , GEN_INT ( seq - <NUM_LIT> ) , GEN_INT ( count ) ) ) ) ; } else if ( i == <NUM_LIT> - helper_n && ! msp430_is_interrupt_func ( ) && ! is_reentrant_func ( ) && ! is_critical_func ( ) && crtl -> args . pretend_args_size == <NUM_LIT> && helper_n > <NUM_LIT> && ! is_eh ) { p = F ( emit_jump_insn ( gen_epilogue_helper ( GEN_INT ( helper_n ) ) ) ) ; count = helper_n ;


<s> int arg1 = <NUM_LIT> ; int arg2 = <NUM_LIT> ; int arg1sz = <NUM_LIT> ; machine_mode arg0mode = GET_MODE ( operands [ <NUM_LIT> ] ) ; machine_mode arg1mode = GET_MODE ( operands [ <NUM_LIT> ] ) ; machine_mode arg2mode = GET_MODE ( operands [ <NUM_LIT> ] ) ; int expand_mpy = startswith ( helper_name , <STR_LIT> ) ; gcc_assert ( ! ( expand_mpy && const_variants ) ) ; if ( arg1mode != VOIDmode && arg2mode != VOIDmode ) gcc_assert ( arg1mode == arg2mode ) ; if ( arg1mode == VOIDmode ) arg1mode = arg0mode ; if ( arg2mode == VOIDmode ) arg2mode = arg0mode ; if ( arg1mode == SImode ) { arg2 = <NUM_LIT> ; arg1sz = <NUM_LIT> ; } else if ( arg1mode == DImode ) { arg1 = <NUM_LIT> ; arg1sz = <NUM_LIT> ; arg2 = <NUM_LIT> ; } if ( const_variants && CONST_INT_P ( operands [ <NUM_LIT> ] ) && INTVAL ( operands [ <NUM_LIT> ] ) >= <NUM_LIT> && INTVAL ( operands [ <NUM_LIT> ] ) <= <NUM_LIT> ) { int len = strlen ( helper_name ) + <NUM_LIT> ; helper_const = ( char * ) xmalloc ( len ) ; snprintf ( helper_const , len , <STR_LIT> , helper_name , ( int ) INTVAL ( operands [ <NUM_LIT> ] ) ) ; } emit_move_insn ( gen_rtx_REG ( arg1mode , arg1 ) , operands [ <NUM_LIT> ] ) ; if ( ! helper_const ) emit_move_insn ( gen_rtx_REG ( arg2mode , arg2 ) , operands [ <NUM_LIT> ] ) ; if ( expand_mpy ) { if ( msp430_use_f5_series_hwmult ( ) ) fsym = gen_rtx_SYMBOL_REF ( VOIDmode , concat ( helper_name , <STR_LIT> , NULL ) ) ; else if ( msp430_use_32bit_hwmult ( ) ) { if ( arg1mode == HImode ) fsym = gen_rtx_SYMBOL_REF ( VOIDmode , concat ( helper_name , <STR_LIT> , NULL ) ) ; else fsym = gen_rtx_SYMBOL_REF ( VOIDmode , concat ( helper_name , <STR_LIT> , NULL ) ) ; } else if ( msp430_use_16bit_hwmult ( ) ) fsym = gen_rtx_SYMBOL_REF ( VOIDmode , concat ( helper_name , <STR_LIT> , NULL ) ) ; else fsym = gen_rtx_SYMBOL_REF ( VOIDmode , helper_name ) ; } else fsym = gen_rtx_SYMBOL_REF ( VOIDmode , helper_const ? helper_const : helper_name ) ; c = gen_call_value_internal ( gen_rtx_REG ( arg0mode , <NUM_LIT> ) , fsym , GEN_INT ( <NUM_LIT> ) ) ; c = emit_call_insn ( c ) ; RTL_CONST_CALL_P ( c ) = <NUM_LIT> ; fusage = NULL ; use_regs ( & fusage , arg1 , arg1sz ) ; if ( ! helper_const ) { if ( ! expand_mpy ) use_regs ( & fusage , arg2 , <NUM_LIT> ) ; else use_regs ( & fusage , arg2 , arg1sz ) ;


<s> arg1sz = <NUM_LIT> ; arg2 = <NUM_LIT> ; } if ( const_variants && CONST_INT_P ( operands [ <NUM_LIT> ] ) && INTVAL ( operands [ <NUM_LIT> ] ) >= <NUM_LIT> && INTVAL ( operands [ <NUM_LIT> ] ) <= <NUM_LIT> ) { int len = strlen ( helper_name ) + <NUM_LIT> ; helper_const = ( char * ) xmalloc ( len ) ; snprintf ( helper_const , len , <STR_LIT> , helper_name , ( int ) INTVAL ( operands [ <NUM_LIT> ] ) ) ; } emit_move_insn ( gen_rtx_REG ( arg1mode , arg1 ) , operands [ <NUM_LIT> ] ) ; if ( ! helper_const ) emit_move_insn ( gen_rtx_REG ( arg2mode , arg2 ) , operands [ <NUM_LIT> ] ) ; if ( expand_mpy ) { if ( msp430_use_f5_series_hwmult ( ) ) fsym = gen_rtx_SYMBOL_REF ( VOIDmode , concat ( helper_name , <STR_LIT> , NULL ) ) ; else if ( msp430_use_32bit_hwmult ( ) ) { if ( arg1mode == HImode ) fsym = gen_rtx_SYMBOL_REF ( VOIDmode , concat ( helper_name , <STR_LIT> , NULL ) ) ; else fsym = gen_rtx_SYMBOL_REF ( VOIDmode , concat ( helper_name , <STR_LIT> , NULL ) ) ; } else if ( msp430_use_16bit_hwmult ( ) ) fsym = gen_rtx_SYMBOL_REF ( VOIDmode , concat ( helper_name , <STR_LIT> , NULL ) ) ;

else fsym = gen_rtx_SYMBOL_REF ( VOIDmode , helper_name ) ;


<s> if ( is_naked_func ( ) ) { emit_insn ( gen_rtx_CLOBBER ( VOIDmode , GEN_INT ( <NUM_LIT> ) ) ) ; return ; } emit_insn ( gen_prologue_start_marker ( ) ) ; if ( is_critical_func ( ) ) { emit_insn ( gen_push_intr_state ( ) ) ; emit_insn ( gen_disable_interrupts ( ) ) ; } else if ( is_reentrant_func ( ) ) emit_insn ( gen_disable_interrupts ( ) ) ; if ( ! cfun -> machine -> computed ) msp430_compute_frame_info ( ) ; if ( flag_stack_usage_info ) current_function_static_stack_size = cfun -> machine -> framesize ; if ( crtl -> args . pretend_args_size ) { rtx note ; gcc_assert ( crtl -> args . pretend_args_size == <NUM_LIT> ) ; p = emit_insn ( gen_grow_and_swap ( ) ) ; note = F ( gen_rtx_SET ( stack_pointer_rtx , gen_rtx_MINUS ( Pmode , stack_pointer_rtx , GEN_INT ( <NUM_LIT> ) ) ) ) ; add_reg_note ( p , REG_FRAME_RELATED_EXPR , note ) ; note = F ( gen_rtx_SET ( gen_rtx_MEM ( Pmode , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , GEN_INT ( - <NUM_LIT> ) ) ) , pc_rtx ) ) ; add_reg_note ( p , REG_CFA_OFFSET , note ) ; F ( p ) ; } for ( i = <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) if ( cfun -> machine -> need_to_save [ i ] ) { int seq , count ; rtx note ; for ( seq = i - <NUM_LIT> ; seq >= <NUM_LIT> && cfun -> machine -> need_to_save [ seq ] ; seq -- ) ; count = i - seq ; if ( msp430x ) { p = F ( emit_insn ( gen_pushm ( gen_rtx_REG ( Pmode , i ) , GEN_INT ( count ) ) ) ) ; note = gen_rtx_SEQUENCE ( VOIDmode , rtvec_alloc ( count + <NUM_LIT> ) ) ; XVECEXP ( note , <NUM_LIT> , <NUM_LIT> ) = F ( gen_rtx_SET ( stack_pointer_rtx , gen_rtx_PLUS ( Pmode , stack_pointer_rtx , GEN_INT ( count * ( TARGET_LARGE ? - <NUM_LIT> : - <NUM_LIT> ) ) ) ) ) ; for ( j = <NUM_LIT> ; j < count ; j ++ ) { rtx addr ; int ofs = ( count - j - <NUM_LIT> ) * ( TARGET_LARGE ? <NUM_LIT> : <NUM_LIT> ) ; if ( ofs ) addr = gen_rtx_PLUS ( Pmode , sp , GEN_INT ( ofs ) ) ; else addr = stack_pointer_rtx ; XVECEXP ( note , <NUM_LIT> , j + <NUM_LIT> ) = F ( gen_rtx_SET ( gen_rtx_MEM ( Pmode , addr ) , gen_rtx_REG ( Pmode , i - j ) ) ) ; } add_reg_note ( p , REG_FRAME_RELATED_EXPR , note ) ; i -= count - <NUM_LIT> ; } else F ( emit_insn ( gen_push ( gen_rtx_REG ( Pmode , i ) ) ) ) ; }

if ( frame_pointer_needed ) F ( emit_move_insn ( gen_rtx_REG ( Pmode , FRAME_POINTER_REGNUM ) , sp ) ) ;


<s> switch ( mode ) { case E_HImode : helper_name = ( code == ASHIFT ? <STR_LIT> : ( code == ASHIFTRT ? <STR_LIT> : ( code == LSHIFTRT ? <STR_LIT> : NULL ) ) ) ; break ; case E_PSImode : helper_name = ( code == ASHIFT ? <STR_LIT> : ( code == ASHIFTRT ? <STR_LIT> : ( code == LSHIFTRT ? <STR_LIT> : NULL ) ) ) ; const_variant = false ; break ; case E_SImode : helper_name = ( code == ASHIFT ? <STR_LIT> : ( code == ASHIFTRT ? <STR_LIT> : ( code == LSHIFTRT ? <STR_LIT> :


<s> if ( GET_CODE ( operands [ const_op_idx ] ) != REG && GET_CODE ( operands [ const_op_idx ] ) != MEM ) operands [ const_op_idx ] = copy_to_mode_reg ( my_mode , operands [ const_op_idx ] ) ;


<s> if ( msp430_reversible_cmp_operator ( operands [ <NUM_LIT> ] , VOIDmode ) ) const_op_idx = <NUM_LIT> ;

if ( GET_CODE ( operands [ const_op_idx ] ) != REG && GET_CODE ( operands [ const_op_idx ] ) != MEM ) operands [ const_op_idx ] = copy_to_mode_reg ( my_mode , operands [ const_op_idx ] ) ;


<s> static bool msp430_frame_pointer_required ( void ) {


<s> CUMULATIVE_ARGS * ca = get_cumulative_args ( cap ) ;


<s> msp430_evaluate_arg ( cap , arg . mode , arg . type , arg . named ) ;

if ( ca -> start_reg >= CA_FIRST_REG ) for ( i = <NUM_LIT> ; i < ca -> reg_count ; i ++ ) ca -> reg_used [ i + ca -> start_reg - CA_FIRST_REG ] = <NUM_LIT> ;


<s> msp430_evaluate_arg ( cap , arg . mode , arg . type , arg . named ) ; if ( ca -> start_reg >= CA_FIRST_REG ) for ( i = <NUM_LIT> ; i < ca -> reg_count ; i ++ ) ca -> reg_used [ i + ca -> start_reg - CA_FIRST_REG ] = <NUM_LIT> ; ca -> special_p = <NUM_LIT> ;


<s> static unsigned int msp430_function_arg_boundary ( machine_mode mode , const_tree type ) { if ( mode == BLKmode && int_size_in_bytes ( type ) > <NUM_LIT> ) return <NUM_LIT> ;

if ( GET_MODE_BITSIZE ( mode ) > <NUM_LIT> ) return <NUM_LIT> ;


<s> if ( mode == BLKmode && int_size_in_bytes ( type ) > <NUM_LIT> ) return <NUM_LIT> ;


<s> if ( prefix == NULL || startswith ( name , prefix ) ) return default_function_section ( decl , freq , startup , exit ) ; name = ACONCAT ( ( prefix , name , NULL ) ) ;

return get_named_section ( decl , name , <NUM_LIT> ) ;


<s> const char * prefix = gen_prefix ( decl ) ;

if ( prefix == NULL || startswith ( name , prefix ) ) return default_function_section ( decl , freq , startup , exit ) ;


<s> return gen_rtx_REG ( TYPE_MODE ( ret_type ) , <NUM_LIT> ) ;


<s> bool msp430_function_value_regno_p ( unsigned int regno ) { return regno == <NUM_LIT> ;


<s> return x ; case PLUS : if ( GET_CODE ( XEXP ( op0 , <NUM_LIT> ) ) == REG ) { if ( GET_CODE ( XEXP ( op0 , <NUM_LIT> ) ) == CONST_INT || GET_CODE ( XEXP ( op0 , <NUM_LIT> ) ) == CONST || GET_CODE ( XEXP ( op0 , <NUM_LIT> ) ) == LABEL_REF || GET_CODE ( XEXP ( op0 , <NUM_LIT> ) ) == SYMBOL_REF ) return x ; else return msp430_get_inner_dest_code ( op0 ) ; } return msp430_get_inner_dest_code ( op0 ) ; default : if ( GET_RTX_FORMAT ( code ) [ <NUM_LIT> ] != 'e' ) return x ; return msp430_get_inner_dest_code ( op0 ) ; }


<s> static fixed_size_mode msp430_get_raw_arg_mode ( int regno ) {

return as_a < fixed_size_mode > ( regno == ARG_POINTER_REGNUM ? VOIDmode : Pmode ) ;


<s> static fixed_size_mode msp430_get_raw_arg_mode ( int regno ) { return as_a < fixed_size_mode > ( regno == ARG_POINTER_REGNUM ? VOIDmode : Pmode ) ;


<s> static fixed_size_mode msp430_get_raw_result_mode ( int regno ATTRIBUTE_UNUSED ) {


<s> SET_TYPE_ALIGN ( type , boundary ) ; } type_size = size_in_bytes ( type ) ; rounded_size = round_up ( type_size , align ) ; gimplify_expr ( & rounded_size , pre_p , post_p , is_gimple_val , fb_rvalue ) ; addr = valist_tmp ; t = fold_build_pointer_plus ( valist_tmp , rounded_size ) ; t = build2 ( MODIFY_EXPR , TREE_TYPE ( valist ) , valist , t ) ; gimplify_and_add ( t , pre_p ) ; addr = fold_convert ( build_pointer_type ( type ) , addr ) ; if ( indirect ) addr = build_va_arg_indirect_ref ( addr ) ; addr = build_va_arg_indirect_ref ( addr ) ;


<s> if ( has_attr ( ATTR_LOWER , * node ) && ! ( TREE_NAME_EQ ( name , <STR_LIT> ) || TREE_NAME_EQ ( name , ATTR_PERSIST ) || TREE_NAME_EQ ( name , ATTR_NOINIT ) ) ) message = G_ ( <STR_LIT> <STR_LIT> ) ; else if ( has_attr ( ATTR_UPPER , * node ) ) message = G_ ( <STR_LIT> <STR_LIT> ) ; else if ( has_attr ( ATTR_EITHER , * node ) ) message = G_ ( <STR_LIT> <STR_LIT> ) ; if ( message ) { warning ( OPT_Wattributes , message , name ) ; * no_add_attrs = true ; }


<s> else if ( has_attr ( ATTR_UPPER , * node ) ) message = G_ ( <STR_LIT> <STR_LIT> ) ; else if ( has_attr ( ATTR_EITHER , * node ) ) message = G_ ( <STR_LIT> <STR_LIT> ) ; if ( message ) { warning ( OPT_Wattributes , message , name ) ;


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

return regno <= ( ARG_POINTER_REGNUM - ( unsigned int ) msp430_hard_regno_nregs ( regno , mode ) ) ;


<s> if ( mode == PSImode && msp430x ) return <NUM_LIT> ; if ( mode == CPSImode && msp430x ) return <NUM_LIT> ; return ( ( GET_MODE_SIZE ( mode ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ) ;


<s> if ( mode == PSImode && msp430x ) return <NUM_LIT> ;

if ( mode == CPSImode && msp430x ) return <NUM_LIT> ;


if ( extracted_mcu_data . name != NULL ) return cached_result = extracted_mcu_data . hwmpy != <NUM_LIT> ;


<s> rtx msp430_incoming_return_addr_rtx ( void ) { return gen_rtx_MEM ( Pmode , stack_pointer_rtx ) ;


<s> rv += cfun -> machine -> framesize_outgoing ; rv += cfun -> machine -> framesize_locals ; case FRAME_POINTER_REGNUM : rv += cfun -> machine -> framesize_regs ; rv += ( TARGET_LARGE ? <NUM_LIT> : <NUM_LIT> ) ;


<s> else if ( libname ) fname = XSTR ( libname , <NUM_LIT> ) ; else fname = NULL ;

if ( fname && msp430_special_register_convention_p ( fname ) ) ca -> special_p = <NUM_LIT> ;


<s> int i ; rtx addr = expand_normal ( address ) ; rtx mem = gen_rtx_MEM ( BLKmode , addr ) ; if ( ! msp430x ) return ; for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) { unsigned int dnum = DWARF_FRAME_REGNUM ( i ) ; unsigned int rnum = DWARF2_FRAME_REG_OUT ( dnum , <NUM_LIT> ) ;


<s> m = ggc_cleared_alloc < machine_function > ( ) ; return m ;


<s> static int msp430_insn_cost ( rtx_insn * insn , bool speed ATTRIBUTE_UNUSED ) {

if ( recog_memoized ( insn ) < <NUM_LIT> ) return <NUM_LIT> ;


<s> static int msp430_insn_cost ( rtx_insn * insn , bool speed ATTRIBUTE_UNUSED ) { if ( recog_memoized ( insn ) < <NUM_LIT> ) return <NUM_LIT> ; return COSTS_N_INSNS ( get_attr_length ( insn ) / <NUM_LIT> ) ;


<s> return ( GET_CODE ( op0 ) == REG || GET_CODE ( op0 ) == POST_INC ) ;


<s> static bool msp430_is_mem_indirect ( rtx x ) { gcc_assert ( GET_CODE ( x ) == MEM ) ; rtx op0 = XEXP ( x , <NUM_LIT> ) ; return ( GET_CODE ( op0 ) == REG || GET_CODE ( op0 ) == POST_INC ) ;


<s> case PLUS : case POST_INC : if ( REG_P ( XEXP ( x , <NUM_LIT> ) ) ) { if ( GET_MODE ( x ) != GET_MODE ( XEXP ( x , <NUM_LIT> ) ) ) return false ;

if ( ! reg_ok_for_addr ( XEXP ( x , <NUM_LIT> ) , strict ) ) return false ;


<s> static bool msp430_legitimate_constant ( machine_mode mode , rtx x ) {

return ! CONST_INT_P ( x ) || mode != PSImode || ( INTVAL ( x ) < ( <NUM_LIT> << <NUM_LIT> ) && INTVAL ( x ) >= ( HOST_WIDE_INT ) ( HOST_WIDE_INT_M1U << <NUM_LIT> ) ) ;


<s> rtx msp430_libcall_value ( machine_mode mode , const_rtx fun ATTRIBUTE_UNUSED ) { return gen_rtx_REG ( mode , <NUM_LIT> ) ;


<s> if ( startswith ( target_mcu , <STR_LIT> ) ) { snprintf ( mcu_name , sizeof ( mcu_name ) - <NUM_LIT> , <STR_LIT> , target_mcu + <NUM_LIT> ) ; start_upper = <NUM_LIT> ; } else { snprintf ( mcu_name , sizeof ( mcu_name ) - <NUM_LIT> , <STR_LIT> , target_mcu ) ; start_upper = <NUM_LIT> ; } end_upper = strlen ( mcu_name ) - <NUM_LIT> ;

for ( i = start_upper ; i < end_upper ; i ++ ) mcu_name [ i ] = TOUPPER ( mcu_name [ i ] ) ;


<s> if ( target_mcu ) { msp430_extract_mcu_data ( target_mcu ) ; unsigned int i ; unsigned int start_upper ; unsigned int end_upper ; static char mcu_name [ <NUM_LIT> ] ; if ( startswith ( target_mcu , <STR_LIT> ) ) {


<s> static int msp430_memory_move_cost ( machine_mode mode ATTRIBUTE_UNUSED , reg_class_t rclass ATTRIBUTE_UNUSED , bool in ) { int cost ; const struct double_op_cost * cost_p ; bool speed = ( ! optimize_size && optimize >= <NUM_LIT> ) ; cost_p = ( speed ? & cycle_cost_double_op_mov : & size_cost_double_op ) ; if ( in ) cost = cost_p -> ind2r ;


<s> const struct double_op_cost * cost_p ; bool speed = ( ! optimize_size && optimize >= <NUM_LIT> ) ; cost_p = ( speed ? & cycle_cost_double_op_mov : & size_cost_double_op ) ; if ( in ) cost = cost_p -> ind2r ; else cost = cost_p -> r2m ; return <NUM_LIT> * cost ;


<s> if ( ( mode1 == PSImode || mode2 == SImode ) || ( mode1 == SImode || mode2 == PSImode ) ) return false ;


<s> bool msp430_ms_bitfield_layout_p ( const_tree record_type ATTRIBUTE_UNUSED ) { return false ;


<s> static int msp430_muldiv_costs ( rtx src , rtx dst , bool speed , rtx outer_rtx , machine_mode outer_mode ) { enum rtx_code outer_code = GET_CODE ( outer_rtx ) ; const struct msp430_multlib_costs * cost_p ; cost_p = ( msp430_use_16bit_hwmult ( ) ? & cycle_cost_multlib_32bit : & cycle_cost_multlib_16bit ) ; int factor = <NUM_LIT> ; int mode_factor = <NUM_LIT> ; if ( outer_mode == SImode ) mode_factor = <NUM_LIT> ; else if ( outer_mode == PSImode ) mode_factor = <NUM_LIT> ; else if ( outer_mode == DImode ) mode_factor = <NUM_LIT> ;


<s> static int msp430_muldiv_costs ( rtx src , rtx dst , bool speed , rtx outer_rtx , machine_mode outer_mode ) { enum rtx_code outer_code = GET_CODE ( outer_rtx ) ; const struct msp430_multlib_costs * cost_p ; cost_p = ( msp430_use_16bit_hwmult ( ) ? & cycle_cost_multlib_32bit : & cycle_cost_multlib_16bit ) ; int factor = <NUM_LIT> ; int mode_factor = <NUM_LIT> ; if ( outer_mode == SImode ) mode_factor = <NUM_LIT> ; else if ( outer_mode == PSImode ) mode_factor = <NUM_LIT> ; else if ( outer_mode == DImode ) mode_factor = <NUM_LIT> ; if ( ! speed ) { if ( outer_code != MULT ) factor = <NUM_LIT> ; else if ( ( ( msp430_use_16bit_hwmult ( ) && outer_mode != DImode ) || msp430_use_32bit_hwmult ( ) || msp430_use_f5_series_hwmult ( ) ) ) factor = <NUM_LIT> ; else factor = <NUM_LIT> ; return factor * mode_factor * msp430_costs ( src , dst , speed , outer_rtx ) ; } if ( outer_code != MULT || ! msp430_has_hwmult ( ) || ( outer_mode == DImode && msp430_use_16bit_hwmult ( ) ) ) { factor = ( outer_code == MULT ? <NUM_LIT> : <NUM_LIT> ) ; return factor * mode_factor * msp430_costs ( src , dst , speed , outer_rtx ) ; } switch ( outer_mode ) { case E_QImode : case E_HImode : return cost_p -> mulhi + ( <NUM_LIT> * msp430_costs ( src , dst , speed , outer_rtx ) ) ; case E_PSImode : factor = <NUM_LIT> ; case E_SImode : return factor * ( cost_p -> mulsi + ( <NUM_LIT> * msp430_costs ( src , dst , speed , outer_rtx ) ) ) ;


<s> } if ( target_cpu == MSP430_CPU_MSP430X_DEFAULT ) msp430x = xisa ; } else { if ( msp430_hwmult_type == MSP430_HWMULT_AUTO ) { if ( msp430_warn_mcu ) { if ( target_cpu == MSP430_CPU_MSP430X_DEFAULT ) warning ( <NUM_LIT> , <STR_LIT> <STR_LIT> <STR_LIT> <STR_LIT> , target_mcu ) ; else warning ( <NUM_LIT> , <STR_LIT> <STR_LIT> <STR_LIT> , target_mcu ) ; } msp430_hwmult_type = MSP430_HWMULT_NONE ; } else if ( target_cpu == MSP430_CPU_MSP430X_DEFAULT ) { if ( msp430_warn_mcu ) warning ( <NUM_LIT> , <STR_LIT> <STR_LIT> <STR_LIT> , target_mcu ) ; } else if ( msp430_warn_mcu ) warning ( <NUM_LIT> , <STR_LIT> , target_mcu ) ; } } if ( TARGET_LARGE && ! msp430x ) error ( <STR_LIT> ) ; if ( ! TARGET_LARGE && msp430_code_region == MSP430_REGION_EITHER ) error ( <STR_LIT> <STR_LIT> ) ; else if ( ! TARGET_LARGE && msp430_code_region == MSP430_REGION_UPPER ) error ( <STR_LIT> <STR_LIT> ) ; if ( ! TARGET_LARGE && msp430_data_region == MSP430_REGION_EITHER ) error ( <STR_LIT> <STR_LIT> ) ; else if ( ! TARGET_LARGE && msp430_data_region == MSP430_REGION_UPPER ) error ( <STR_LIT> <STR_LIT> ) ; if ( flag_exceptions || flag_non_call_exceptions || flag_unwind_tables || flag_asynchronous_unwind_tables ) flag_omit_frame_pointer = false ; else flag_omit_frame_pointer = true ; if ( TARGET_OPT_SPACE && optimize < <NUM_LIT> ) optimize_size = <NUM_LIT> ; if ( flag_use_cxa_atexit ) error ( <STR_LIT> ) ; if ( TARGET_TINY_PRINTF ) error ( <STR_LIT> <STR_LIT> ) ;


<s> if ( ( CONST_INT_P ( op0 ) && ( IN_RANGE ( INTVAL ( op0 ) , <NUM_LIT> , ( <NUM_LIT> << <NUM_LIT> ) - <NUM_LIT> ) ) ) ) return true ; return false ;


<s> if ( ! TARGET_LARGE || ! MEM_P ( op ) ) return true ; op0 = XEXP ( op , <NUM_LIT> ) ;

if ( SYMBOL_REF_P ( op0 ) && ( SYMBOL_REF_FLAGS ( op0 ) & SYMBOL_FLAG_LOW_MEM ) ) return true ;


<s> void msp430_output_aligned_decl_common ( FILE * stream , const tree decl , const char * name , unsigned HOST_WIDE_INT size , unsigned int align , int local ) { if ( ( msp430_data_region == MSP430_REGION_ANY || ( ( msp430_data_region == MSP430_REGION_LOWER ) && ! TARGET_USE_LOWER_REGION_PREFIX ) ) && ! ( decl != NULL_TREE && DECL_SECTION_NAME ( decl ) ) && ! has_attr ( ATTR_EITHER , decl ) && ! has_attr ( ATTR_LOWER , decl ) && ! has_attr ( ATTR_UPPER , decl ) && ! has_attr ( ATTR_PERSIST , decl ) && ! has_attr ( ATTR_NOINIT , decl ) ) { if ( local ) { fprintf ( stream , LOCAL_ASM_OP ) ; assemble_name ( stream , name ) ; fprintf ( stream , <STR_LIT> ) ; } fprintf ( stream , COMMON_ASM_OP ) ; assemble_name ( stream , name ) ; fprintf ( stream , <STR_LIT> HOST_WIDE_INT_PRINT_UNSIGNED <STR_LIT> , size , align / BITS_PER_UNIT ) ; } else {


<s> fprintf ( stream , <STR_LIT> HOST_WIDE_INT_PRINT_UNSIGNED <STR_LIT> , size , align / BITS_PER_UNIT ) ; } else { section * sec ; if ( decl ) sec = msp430_select_section ( decl , <NUM_LIT> , align ) ; else switch ( msp430_data_region ) { case MSP430_REGION_UPPER : sec = get_named_section ( NULL , <STR_LIT> , <NUM_LIT> ) ; break ; case MSP430_REGION_LOWER : sec = get_named_section ( NULL , <STR_LIT> , <NUM_LIT> ) ; break ; case MSP430_REGION_EITHER : sec = get_named_section ( NULL , <STR_LIT> , <NUM_LIT> ) ; break ; default : gcc_unreachable ( ) ; } gcc_assert ( sec != NULL ) ; switch_to_section ( sec ) ; ASM_OUTPUT_ALIGN ( stream , floor_log2 ( align / BITS_PER_UNIT ) ) ; if ( ! local ) { targetm . asm_out . globalize_label ( stream , name ) ;


<s> } return <NUM_LIT> ; } if ( code == ASHIFT ) { if ( ! msp430x && mode == HImode ) { if ( return_length ) length = <NUM_LIT> + ( MEM_P ( operands [ <NUM_LIT> ] ) ? <NUM_LIT> : <NUM_LIT> ) ; else for ( i = <NUM_LIT> ; i < amt ; i ++ ) output_asm_insn ( <STR_LIT> , operands ) ; } else if ( mode == SImode ) { if ( return_length ) length = <NUM_LIT> + ( MEM_P ( operands [ <NUM_LIT> ] ) ? <NUM_LIT> : <NUM_LIT> ) + ( <NUM_LIT> * msp430x_insn_required ( operands [ <NUM_LIT> ] ) ) ; else for ( i = <NUM_LIT> ; i < amt ; i ++ ) output_asm_insn ( <STR_LIT> , operands ) ; } else gcc_unreachable ( ) ; } else if ( code == ASHIFTRT ) { if ( ! msp430x && mode == HImode ) { if ( return_length ) length = <NUM_LIT> + ( MEM_P ( operands [ <NUM_LIT> ] ) ? <NUM_LIT> : <NUM_LIT> ) ; else for ( i = <NUM_LIT> ; i < amt ; i ++ ) output_asm_insn ( <STR_LIT> , operands ) ; } else if ( mode == SImode ) { if ( return_length ) length = <NUM_LIT> + ( MEM_P ( operands [ <NUM_LIT> ] ) ? <NUM_LIT> : <NUM_LIT> ) + ( <NUM_LIT> * msp430x_insn_required ( operands [ <NUM_LIT> ] ) ) ; else for ( i = <NUM_LIT> ; i < amt ; i ++ ) output_asm_insn ( <STR_LIT> , operands ) ;