<s> if ( ! crtl -> is_leaf && call_used_regs [ regno ] ) current_frame_info . save_regs [ regno ] = <NUM_LIT> ; else if ( df_regs_ever_live_p ( regno ) ) current_frame_info . save_regs [ regno ] = <NUM_LIT> ; else current_frame_info . save_regs [ regno ] = <NUM_LIT> ; } else { if ( df_regs_ever_live_p ( regno ) && ( ! call_used_regs [ regno ] || regno == RETURN_ADDRESS_REGNUM ) ) current_frame_info . save_regs [ regno ] = <NUM_LIT> ; else current_frame_info . save_regs [ regno ] = <NUM_LIT> ; } } if ( crtl -> calls_eh_return ) { unsigned int i ; for ( i = <NUM_LIT> ; ; ++ i ) {


<s> } if ( crtl -> calls_eh_return ) { unsigned int i ; for ( i = <NUM_LIT> ; ; ++ i ) { regno = EH_RETURN_DATA_REGNO ( i ) ; if ( INVALID_REGNUM == regno ) break ; current_frame_info . save_regs [ regno ] = <NUM_LIT> ; } } for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( current_frame_info . save_regs [ regno ] == <NUM_LIT> ) { current_frame_info . last_reg_to_save = regno ; if ( regno >= CR16_FIRST_DWORD_REGISTER ) current_frame_info . reg_size += CR16_UNITS_PER_DWORD ;


<s> REAL_VALUE_FROM_CONST_DOUBLE ( r , op ) ; REAL_VALUE_TO_TARGET_SINGLE ( r , l ) ; return UNSIGNED_INT_FITS_N_BITS ( l , <NUM_LIT> ) ? <NUM_LIT> : <NUM_LIT> ; } return ( ( UNSIGNED_INT_FITS_N_BITS ( CONST_DOUBLE_LOW ( op ) , <NUM_LIT> ) ) && ( UNSIGNED_INT_FITS_N_BITS ( CONST_DOUBLE_HIGH ( op ) , <NUM_LIT> ) ) ) ? <NUM_LIT> : <NUM_LIT> ;


<s> static void cr16_create_dwarf_for_multi_push ( rtx insn ) { rtx dwarf , reg , tmp ; int i , j , from , to , word_cnt , dwarf_par_index , inc ; machine_mode mode ; int num_regs = <NUM_LIT> , offset = <NUM_LIT> , split_here = <NUM_LIT> , total_push_bytes = <NUM_LIT> ; for ( i = <NUM_LIT> ; i <= current_frame_info . last_reg_to_save ; ++ i ) { if ( current_frame_info . save_regs [ i ] ) { ++ num_regs ; if ( i < CR16_FIRST_DWORD_REGISTER ) total_push_bytes += <NUM_LIT> ; else total_push_bytes += <NUM_LIT> ; } } if ( ! num_regs ) return ; dwarf = gen_rtx_SEQUENCE ( VOIDmode , rtvec_alloc ( num_regs + <NUM_LIT> ) ) ; dwarf_par_index = num_regs ; from = current_frame_info . last_reg_to_save + <NUM_LIT> ; to = current_frame_info . last_reg_to_save ; word_cnt = <NUM_LIT> ; for ( i = current_frame_info . last_reg_to_save ; i >= <NUM_LIT> ; ) { if ( ! current_frame_info . save_regs [ i ] || <NUM_LIT> == i || split_here ) { if ( <NUM_LIT> == i && current_frame_info . save_regs [ i ] ) from = <NUM_LIT> ; for ( j = to ; j >= from ; -- j ) { if ( j < CR16_FIRST_DWORD_REGISTER ) { mode = HImode ; inc = <NUM_LIT> ; } else { mode = SImode ; inc = <NUM_LIT> ; } reg = gen_rtx_REG ( mode , j ) ; offset += <NUM_LIT> * inc ; tmp = gen_rtx_SET ( VOIDmode , gen_frame_mem ( mode , plus_constant ( Pmode , stack_pointer_rtx , total_push_bytes - offset ) ) , reg ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( dwarf , <NUM_LIT> , dwarf_par_index -- ) = tmp ; }


<s> } } if ( ( MIN_REG_FOR_PASSING_ARGS + cum -> ints ) > MAX_REG_FOR_PASSING_ARGS ) return NULL_RTX ; else { if ( enough_regs_for_param ( cum , type , mode ) != <NUM_LIT> ) { cum -> last_parm_in_reg = <NUM_LIT> ; return gen_rtx_REG ( mode , MIN_REG_FOR_PASSING_ARGS + cum -> ints ) ;


<s> if ( type == void_type_node ) return NULL_RTX ; if ( targetm . calls . must_pass_in_stack ( mode , type ) || ( cum -> ints < <NUM_LIT> ) ) return NULL_RTX ; if ( mode == BLKmode ) { if ( enough_regs_for_param ( cum , type , mode ) != <NUM_LIT> ) { cum -> last_parm_in_reg = <NUM_LIT> ; return gen_rtx_REG ( mode , MIN_REG_FOR_PASSING_ARGS + cum -> ints ) ; }


<s> else if ( ( mode == SFmode ) || ( mode == DFmode ) ) cum -> ints += l ; else if ( ( mode ) == BLKmode ) { if ( ( l = enough_regs_for_param ( cum , type , mode ) ) != <NUM_LIT> ) cum -> ints += l ; }


<s> cr16_compute_frame ( ) ; if ( ( ( from ) == FRAME_POINTER_REGNUM ) && ( ( to ) == STACK_POINTER_REGNUM ) ) return ( ACCUMULATE_OUTGOING_ARGS ? crtl -> outgoing_args_size : <NUM_LIT> ) ; else if ( ( ( from ) == ARG_POINTER_REGNUM ) && ( ( to ) == FRAME_POINTER_REGNUM ) ) return ( current_frame_info . reg_size + current_frame_info . var_size ) ;

else if ( ( ( from ) == ARG_POINTER_REGNUM ) && ( ( to ) == STACK_POINTER_REGNUM ) ) return ( current_frame_info . reg_size + current_frame_info . var_size + ( ACCUMULATE_OUTGOING_ARGS ? crtl -> outgoing_args_size : <NUM_LIT> ) ) ;


<s> if ( ( ( from ) == FRAME_POINTER_REGNUM ) && ( ( to ) == STACK_POINTER_REGNUM ) ) return ( ACCUMULATE_OUTGOING_ARGS ? crtl -> outgoing_args_size : <NUM_LIT> ) ; else if ( ( ( from ) == ARG_POINTER_REGNUM ) && ( ( to ) == FRAME_POINTER_REGNUM ) ) return ( current_frame_info . reg_size + current_frame_info . var_size ) ;


<s> static void cr16_override_options ( void ) { flag_delete_null_pointer_checks = <NUM_LIT> ; if ( flag_exceptions ) flag_cse_follow_jumps = <NUM_LIT> ; if ( flag_pic == NEAR_PIC ) { data_model = DM_FAR ; } if ( cr16_data_model ) { if ( strcmp ( cr16_data_model , <STR_LIT> ) == <NUM_LIT> ) data_model = DM_DEFAULT ; else if ( strcmp ( cr16_data_model , <STR_LIT> ) == <NUM_LIT> ) data_model = DM_NEAR ; else if ( strcmp ( cr16_data_model , <STR_LIT> ) == <NUM_LIT> ) { if ( TARGET_CR16CP ) data_model = DM_FAR ; else error ( <STR_LIT> ) ;


<s> putc ( '$' , file ) ; return ; case 'p' : if ( GET_CODE ( x ) == REG ) { fprintf ( file , <STR_LIT> , reg_names [ REGNO ( x ) ] ) ; return ; } break ; case 'b' : fprintf ( file , <STR_LIT> , INTVAL ( x ) ) ; return ; case 'r' : fprintf ( file , <STR_LIT> , cr16_operand_bit_pos ( INTVAL ( x ) , <NUM_LIT> ) ) ; return ; case 's' : fprintf ( file , <STR_LIT> , cr16_operand_bit_pos ( INTVAL ( x ) , <NUM_LIT> ) ) ; return ; case 'g' : ptr_dereference = <NUM_LIT> ; case 'f' : case <NUM_LIT> : switch ( GET_CODE ( x ) ) { case REG : if ( GET_MODE_BITSIZE ( GET_MODE ( x ) ) > BITS_PER_WORD ) { if ( LONG_REG_P ( REGNO ( x ) ) ) fprintf ( file , <STR_LIT> , reg_names [ REGNO ( x ) ] ) ; else fprintf ( file , <STR_LIT> , reg_names [ REGNO ( x ) + <NUM_LIT> ] , reg_names [ REGNO ( x ) ] ) ; } else fprintf ( file , <STR_LIT> , reg_names [ REGNO ( x ) ] ) ; return ; case MEM : output_address ( XEXP ( x , <NUM_LIT> ) ) ; return ; case CONST_DOUBLE : { REAL_VALUE_TYPE r ; long l ; REAL_VALUE_FROM_CONST_DOUBLE ( r , x ) ; REAL_VALUE_TO_TARGET_SINGLE ( r , l ) ; fprintf ( file , <STR_LIT> , l ) ; return ; } case CONST_INT : { fprintf ( file , <STR_LIT> , INTVAL ( x ) ) ; return ; } case UNSPEC : switch ( XINT ( x , <NUM_LIT> ) ) { default :


<s> static int cr16_return_pops_args ( tree fundecl ATTRIBUTE_UNUSED , tree funtype ATTRIBUTE_UNUSED , int size ATTRIBUTE_UNUSED ) {


<s> static machine_mode cr16_unwind_word_mode ( void ) {


<s> if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS && ( GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF || GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == LABEL_REF ) && ( GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == CONST_INT ) ) return <NUM_LIT> ; break ; case MEM :

return legitimate_pic_operand_p ( XEXP ( x , <NUM_LIT> ) ) ;


<s> case LEU : cr16_cmp_str = <STR_LIT> ; break ; default : gcc_unreachable ( ) ; } fprintf ( file , <STR_LIT> , cr16_cmp_str ) ; return ; } case '$' : putc ( '$' , file ) ; return ; case 'p' : if ( GET_CODE ( x ) == REG ) { fprintf ( file , <STR_LIT> , reg_names [ REGNO ( x ) ] ) ; return ; } break ; case 'b' : fprintf ( file , <STR_LIT> , INTVAL ( x ) ) ; return ; case 'r' : fprintf ( file , <STR_LIT> , cr16_operand_bit_pos ( INTVAL ( x ) , <NUM_LIT> ) ) ; return ; case 's' : fprintf ( file , <STR_LIT> , cr16_operand_bit_pos ( INTVAL ( x ) , <NUM_LIT> ) ) ; return ; case 'g' : ptr_dereference = <NUM_LIT> ; case 'f' : case <NUM_LIT> : switch ( GET_CODE ( x ) ) { case REG : if ( GET_MODE_BITSIZE ( GET_MODE ( x ) ) > BITS_PER_WORD ) { if ( LONG_REG_P ( REGNO ( x ) ) ) fprintf ( file , <STR_LIT> , reg_names [ REGNO ( x ) ] ) ; else fprintf ( file , <STR_LIT> , reg_names [ REGNO ( x ) + <NUM_LIT> ] , reg_names [ REGNO ( x ) ] ) ; } else fprintf ( file , <STR_LIT> , reg_names [ REGNO ( x ) ] ) ; return ; case MEM : output_address ( GET_MODE ( x ) , XEXP ( x , <NUM_LIT> ) ) ; return ; case CONST_DOUBLE : { long l ; REAL_VALUE_TO_TARGET_SINGLE ( * CONST_DOUBLE_REAL_VALUE ( x ) , l ) ; fprintf ( file , <STR_LIT> , l ) ; return ; } case CONST_INT : { fprintf ( file , <STR_LIT> , INTVAL ( x ) ) ; return ; } case UNSPEC : switch ( XINT ( x , <NUM_LIT> ) ) { default : gcc_unreachable ( ) ; } break ; default : if ( ! ptr_dereference ) { putc ( '$' , file ) ; } cr16_print_operand_address ( file , VOIDmode , x ) ; return ; } default : output_operand_lossage ( <STR_LIT> ) ; } gcc_unreachable ( ) ;


<s> switch ( GET_CODE ( x ) ) { case REG : if ( GET_MODE_BITSIZE ( GET_MODE ( x ) ) > BITS_PER_WORD ) { if ( LONG_REG_P ( REGNO ( x ) ) ) fprintf ( file , <STR_LIT> , reg_names [ REGNO ( x ) ] ) ; else fprintf ( file , <STR_LIT> , reg_names [ REGNO ( x ) + <NUM_LIT> ] , reg_names [ REGNO ( x ) ] ) ; } else fprintf ( file , <STR_LIT> , reg_names [ REGNO ( x ) ] ) ; return ; case MEM : output_address ( GET_MODE ( x ) , XEXP ( x , <NUM_LIT> ) ) ; return ; case CONST_DOUBLE : { long l ; REAL_VALUE_TO_TARGET_SINGLE ( * CONST_DOUBLE_REAL_VALUE ( x ) , l ) ; fprintf ( file , <STR_LIT> , l ) ; return ; } case CONST_INT : { fprintf ( file , <STR_LIT> , INTVAL ( x ) ) ; return ; } case UNSPEC : switch ( XINT ( x , <NUM_LIT> ) ) { default : gcc_unreachable ( ) ; } break ; default : if ( ! ptr_dereference ) { putc ( '$' , file ) ; } cr16_print_operand_address ( file , VOIDmode , x ) ; return ; } default :


<s> break ; case CR16_REGP_REL : cost += <NUM_LIT> ; case CR16_REG_REL : cost += <NUM_LIT> ; if ( address . disp ) cost -= <NUM_LIT> ; break ; case CR16_INDEX_REGP_REL : cost += <NUM_LIT> ; if ( address . disp ) cost -= <NUM_LIT> ; default : break ; } if ( TARGET_DEBUG_ADDR ) { fprintf ( stderr , <STR_LIT> , cost ) ; debug_rtx ( addr ) ;


<s> if ( REG_P ( addr_reg ) ) reg = addr_reg ; else if ( ( GET_CODE ( addr_reg ) == SUBREG ) && REG_P ( SUBREG_REG ( addr_reg ) ) && ( GET_MODE_SIZE ( GET_MODE ( SUBREG_REG ( addr_reg ) ) ) <= UNITS_PER_WORD ) ) reg = SUBREG_REG ( addr_reg ) ;


<s> return ( to == STACK_POINTER_REGNUM ? ! frame_pointer_needed : true ) ;


<s> if ( ( rclass ) == SHORT_REGS || ( rclass ) == DOUBLE_BASE_REGS || ( rclass ) == LONG_REGS || ( rclass ) == GENERAL_REGS ) return true ;


<s> static bool cr16_class_likely_spilled_p ( reg_class_t rclass ) {

if ( ( rclass ) == SHORT_REGS || ( rclass ) == DOUBLE_BASE_REGS || ( rclass ) == LONG_REGS || ( rclass ) == GENERAL_REGS ) return true ;


<s> continue ; } if ( cr16_interrupt_function_p ( ) ) { if ( ! crtl -> is_leaf && call_used_or_fixed_reg_p ( regno ) ) current_frame_info . save_regs [ regno ] = <NUM_LIT> ; else if ( df_regs_ever_live_p ( regno ) ) current_frame_info . save_regs [ regno ] = <NUM_LIT> ; else current_frame_info . save_regs [ regno ] = <NUM_LIT> ; } else { if ( df_regs_ever_live_p ( regno ) && ( ! call_used_or_fixed_reg_p ( regno ) || regno == RETURN_ADDRESS_REGNUM ) ) current_frame_info . save_regs [ regno ] = <NUM_LIT> ; else current_frame_info . save_regs [ regno ] = <NUM_LIT> ; } } if ( crtl -> calls_eh_return ) { unsigned int i ; for ( i = <NUM_LIT> ; ; ++ i ) { regno = EH_RETURN_DATA_REGNO ( i ) ; if ( INVALID_REGNUM == regno ) break ; current_frame_info . save_regs [ regno ] = <NUM_LIT> ; } }

for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) if ( current_frame_info . save_regs [ regno ] == <NUM_LIT> ) {


<s> static void cr16_conditional_register_usage ( void ) { if ( flag_pic ) { fixed_regs [ <NUM_LIT> ] = call_used_regs [ <NUM_LIT> ] = <NUM_LIT> ; }


<s> int cr16_const_double_ok ( rtx op ) { if ( GET_MODE ( op ) == SFmode ) { long l ; REAL_VALUE_TO_TARGET_SINGLE ( * CONST_DOUBLE_REAL_VALUE ( op ) , l ) ; return UNSIGNED_INT_FITS_N_BITS ( l , <NUM_LIT> ) ? <NUM_LIT> : <NUM_LIT> ; } return ( ( UNSIGNED_INT_FITS_N_BITS ( CONST_DOUBLE_LOW ( op ) , <NUM_LIT> ) ) && ( UNSIGNED_INT_FITS_N_BITS ( CONST_DOUBLE_HIGH ( op ) , <NUM_LIT> ) ) ) ? <NUM_LIT> : <NUM_LIT> ;


<s> long l ; REAL_VALUE_TO_TARGET_SINGLE ( * CONST_DOUBLE_REAL_VALUE ( op ) , l ) ; return UNSIGNED_INT_FITS_N_BITS ( l , <NUM_LIT> ) ? <NUM_LIT> : <NUM_LIT> ;


<s> offset += <NUM_LIT> * inc ; tmp = gen_rtx_SET ( gen_frame_mem ( mode , plus_constant ( Pmode , stack_pointer_rtx , total_push_bytes - offset ) ) , reg ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( dwarf , <NUM_LIT> , dwarf_par_index -- ) = tmp ; } from = i ; to = -- i ; split_here = <NUM_LIT> ; word_cnt = <NUM_LIT> ; continue ; } if ( i != RETURN_ADDRESS_REGNUM ) { inc = ( i < CR16_FIRST_DWORD_REGISTER ) ? <NUM_LIT> : <NUM_LIT> ; if ( word_cnt + inc >= MAX_COUNT || FRAME_POINTER_REGNUM == i ) { split_here = <NUM_LIT> ; from = i ; continue ; } word_cnt += inc ; } from = i -- ; } tmp = gen_rtx_SET ( stack_pointer_rtx , gen_rtx_PLUS ( SImode , stack_pointer_rtx , GEN_INT ( - offset ) ) ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( dwarf , <NUM_LIT> , <NUM_LIT> ) = tmp ; add_reg_note ( insn , REG_FRAME_RELATED_EXPR , dwarf ) ;


<s> if ( ! current_frame_info . save_regs [ i ] || i == <NUM_LIT> || split_here ) { if ( i == <NUM_LIT> && current_frame_info . save_regs [ i ] ) from = <NUM_LIT> ; for ( j = to ; j >= from ; -- j ) { if ( j < CR16_FIRST_DWORD_REGISTER ) { mode = HImode ; inc = <NUM_LIT> ; } else { mode = SImode ; inc = <NUM_LIT> ; } reg = gen_rtx_REG ( mode , j ) ; offset += <NUM_LIT> * inc ; tmp = gen_rtx_SET ( gen_frame_mem ( mode , plus_constant ( Pmode , stack_pointer_rtx , total_push_bytes - offset ) ) , reg ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( dwarf , <NUM_LIT> , dwarf_par_index -- ) = tmp ; } from = i ; to = -- i ; split_here = <NUM_LIT> ; word_cnt = <NUM_LIT> ; continue ; } if ( i != RETURN_ADDRESS_REGNUM ) { inc = ( i < CR16_FIRST_DWORD_REGISTER ) ? <NUM_LIT> : <NUM_LIT> ; if ( word_cnt + inc >= MAX_COUNT || FRAME_POINTER_REGNUM == i ) { split_here = <NUM_LIT> ; from = i ; continue ; } word_cnt += inc ; } from = i -- ;


<s> case PLUS : case MINUS : if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) cr16_decompose_const ( XEXP ( x , <NUM_LIT> ) , code , data , treat_as_const ) ;

else if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) cr16_decompose_const ( XEXP ( x , <NUM_LIT> ) , code , data , treat_as_const ) ;


<s> else * data = ILLEGAL_DM ; } } return ; case LABEL_REF : * code = <NUM_LIT> ; return ; case PLUS : case MINUS : if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) cr16_decompose_const ( XEXP ( x , <NUM_LIT> ) , code , data , treat_as_const ) ; else if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) cr16_decompose_const ( XEXP ( x , <NUM_LIT> ) , code , data , treat_as_const ) ; return ;


<s> rtx lo_op [ <NUM_LIT> ] ; rtx hi0_op [ <NUM_LIT> ] ; rtx hi1_op [ <NUM_LIT> ] ; lo_op [ <NUM_LIT> ] = gen_lowpart ( SImode , operands [ <NUM_LIT> ] ) ; hi0_op [ <NUM_LIT> ] = simplify_gen_subreg ( HImode , operands [ <NUM_LIT> ] , DImode , <NUM_LIT> ) ; hi1_op [ <NUM_LIT> ] = simplify_gen_subreg ( HImode , operands [ <NUM_LIT> ] , DImode , <NUM_LIT> ) ; lo_op [ <NUM_LIT> ] = gen_lowpart ( SImode , operands [ <NUM_LIT> ] ) ; hi0_op [ <NUM_LIT> ] = simplify_gen_subreg ( HImode , operands [ <NUM_LIT> ] , DImode , <NUM_LIT> ) ; hi1_op [ <NUM_LIT> ] = simplify_gen_subreg ( HImode , operands [ <NUM_LIT> ] , DImode , <NUM_LIT> ) ; switch ( code ) { case PLUS : { output_asm_insn ( <STR_LIT> , lo_op ) ; output_asm_insn ( <STR_LIT> , hi0_op ) ; output_asm_insn ( <STR_LIT> , hi1_op ) ; break ; } case MINUS : { output_asm_insn ( <STR_LIT> , lo_op ) ; output_asm_insn ( <STR_LIT> , hi0_op ) ; output_asm_insn ( <STR_LIT> , hi1_op ) ; break ; }


<s> hi1_op [ <NUM_LIT> ] = simplify_gen_subreg ( HImode , operands [ <NUM_LIT> ] , DImode , <NUM_LIT> ) ; lo_op [ <NUM_LIT> ] = gen_lowpart ( SImode , operands [ <NUM_LIT> ] ) ; hi0_op [ <NUM_LIT> ] = simplify_gen_subreg ( HImode , operands [ <NUM_LIT> ] , DImode , <NUM_LIT> ) ; hi1_op [ <NUM_LIT> ] = simplify_gen_subreg ( HImode , operands [ <NUM_LIT> ] , DImode , <NUM_LIT> ) ; switch ( code ) { case PLUS :


<s> rtx lo_op [ <NUM_LIT> ] ; rtx hi_op [ <NUM_LIT> ] ; lo_op [ <NUM_LIT> ] = gen_lowpart ( SImode , operands [ <NUM_LIT> ] ) ; hi_op [ <NUM_LIT> ] = simplify_gen_subreg ( SImode , operands [ <NUM_LIT> ] , DImode , <NUM_LIT> ) ; lo_op [ <NUM_LIT> ] = gen_lowpart ( SImode , operands [ <NUM_LIT> ] ) ; hi_op [ <NUM_LIT> ] = simplify_gen_subreg ( SImode , operands [ <NUM_LIT> ] , DImode , <NUM_LIT> ) ; switch ( code ) { case AND : { output_asm_insn ( <STR_LIT> , lo_op ) ; output_asm_insn ( <STR_LIT> , hi_op ) ; return <STR_LIT> ; }


<s> if ( crtl -> calls_eh_return ) { insn = emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , EH_RETURN_STACKADJ_RTX ) ) ; } if ( cr16_interrupt_function_p ( ) ) { insn = emit_jump_insn ( gen_interrupt_return ( ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } else if ( crtl -> calls_eh_return ) { insn = emit_jump_insn ( gen_pop_and_popret_return ( GEN_INT ( current_frame_info . reg_size ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ;


<s> void cr16_expand_prologue ( void ) { rtx insn ; cr16_compute_frame ( ) ; cr16_compute_save_regs ( ) ; if ( ( current_frame_info . total_size + current_frame_info . reg_size ) == <NUM_LIT> ) return ; if ( current_frame_info . last_reg_to_save != - <NUM_LIT> ) { insn = emit_insn ( gen_push_for_prologue ( GEN_INT ( current_frame_info . reg_size ) ) ) ; cr16_create_dwarf_for_multi_push ( insn ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } if ( current_frame_info . total_size > <NUM_LIT> ) {


<s> if ( current_frame_info . last_reg_to_save != - <NUM_LIT> ) { insn = emit_insn ( gen_push_for_prologue ( GEN_INT ( current_frame_info . reg_size ) ) ) ; cr16_create_dwarf_for_multi_push ( insn ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ;


<s> static bool cr16_frame_pointer_required ( void ) { return ( cfun -> calls_alloca || crtl -> calls_eh_return || cfun -> has_nonlocal_label || crtl -> calls_eh_return ) ;


<s> CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; cum -> last_parm_in_reg = <NUM_LIT> ; if ( arg . end_marker_p ( ) ) return NULL_RTX ; if ( targetm . calls . must_pass_in_stack ( arg ) || ( cum -> ints < <NUM_LIT> ) ) return NULL_RTX ; if ( arg . mode == BLKmode ) { if ( enough_regs_for_param ( cum , arg . type , arg . mode ) != <NUM_LIT> ) { cum -> last_parm_in_reg = <NUM_LIT> ; return gen_rtx_REG ( arg . mode , MIN_REG_FOR_PASSING_ARGS + cum -> ints ) ; } } if ( ( MIN_REG_FOR_PASSING_ARGS + cum -> ints ) > MAX_REG_FOR_PASSING_ARGS ) return NULL_RTX ; else { if ( enough_regs_for_param ( cum , arg . type , arg . mode ) != <NUM_LIT> ) { cum -> last_parm_in_reg = <NUM_LIT> ; return gen_rtx_REG ( arg . mode , MIN_REG_FOR_PASSING_ARGS + cum -> ints ) ; } }


<s> if ( ( arg . mode == SImode ) || ( arg . mode == HImode ) || ( arg . mode == QImode ) || ( arg . mode == DImode ) ) { if ( l <= <NUM_LIT> ) cum -> ints += <NUM_LIT> ; else cum -> ints += l ; }

else if ( ( arg . mode == SFmode ) || ( arg . mode == DFmode ) ) cum -> ints += l ;


<s> int cr16_function_arg_regno_p ( int n ) { return ( ( n <= MAX_REG_FOR_PASSING_ARGS ) && ( n >= MIN_REG_FOR_PASSING_ARGS ) ) ;


<s> static bool cr16_function_value_regno_p ( const unsigned int regno ) { return ( regno == cr16_ret_register ( ) ) ;


<s> return ( regno == cr16_ret_register ( ) ) ;


<s> if ( ( GET_MODE_SIZE ( mode ) >= <NUM_LIT> ) && ( regno == <NUM_LIT> ) ) return false ; if ( mode == DImode || mode == DFmode ) { if ( ( regno > <NUM_LIT> ) || ( regno & <NUM_LIT> ) ) return false ; return true ; } if ( ( TARGET_INT32 ) && ( ( regno >= <NUM_LIT> ) && ( GET_MODE_SIZE ( mode ) < <NUM_LIT> ) ) ) return false ;

if ( GET_MODE_CLASS ( mode ) == MODE_CC ) return false ;


<s> if ( ( TARGET_INT32 ) && ( ( regno >= <NUM_LIT> ) && ( GET_MODE_SIZE ( mode ) < <NUM_LIT> ) ) ) return false ;


<s> if ( regno >= CR16_FIRST_DWORD_REGISTER ) return CEIL ( GET_MODE_SIZE ( mode ) , CR16_UNITS_PER_DWORD ) ;

return CEIL ( GET_MODE_SIZE ( mode ) , UNITS_PER_WORD ) ;


<s> if ( ( ( from ) == FRAME_POINTER_REGNUM ) && ( ( to ) == STACK_POINTER_REGNUM ) ) return ( ACCUMULATE_OUTGOING_ARGS ? ( HOST_WIDE_INT ) crtl -> outgoing_args_size : <NUM_LIT> ) ; else if ( ( ( from ) == ARG_POINTER_REGNUM ) && ( ( to ) == FRAME_POINTER_REGNUM ) ) return ( current_frame_info . reg_size + current_frame_info . var_size ) ;

else if ( ( ( from ) == ARG_POINTER_REGNUM ) && ( ( to ) == STACK_POINTER_REGNUM ) ) return ( current_frame_info . reg_size + current_frame_info . var_size + ( ACCUMULATE_OUTGOING_ARGS ? ( HOST_WIDE_INT ) crtl -> outgoing_args_size : <NUM_LIT> ) ) ;


<s> cr16_compute_frame ( ) ; if ( ( ( from ) == FRAME_POINTER_REGNUM ) && ( ( to ) == STACK_POINTER_REGNUM ) ) return ( ACCUMULATE_OUTGOING_ARGS ? ( HOST_WIDE_INT ) crtl -> outgoing_args_size : <NUM_LIT> ) ; else if ( ( ( from ) == ARG_POINTER_REGNUM ) && ( ( to ) == FRAME_POINTER_REGNUM ) ) return ( current_frame_info . reg_size + current_frame_info . var_size ) ; else if ( ( ( from ) == ARG_POINTER_REGNUM ) && ( ( to ) == STACK_POINTER_REGNUM ) ) return ( current_frame_info . reg_size + current_frame_info . var_size + ( ACCUMULATE_OUTGOING_ARGS ? ( HOST_WIDE_INT ) crtl -> outgoing_args_size : <NUM_LIT> ) ) ;


<s> param != NULL_TREE ; param = next_param ) { next_param = TREE_CHAIN ( param ) ; if ( ( next_param == NULL_TREE ) && ( TREE_VALUE ( param ) != void_type_node ) ) { cum -> ints = - <NUM_LIT> ; return ; } }


<s> int cr16_interrupt_function_p ( void ) { tree attributes ; attributes = TYPE_ATTRIBUTES ( TREE_TYPE ( current_function_decl ) ) ;

return ( lookup_attribute ( <STR_LIT> , attributes ) != NULL_TREE ) ;


<s> return ( lookup_attribute ( <STR_LIT> , attributes ) != NULL_TREE ) ;


<s> addrtype = cr16_decompose_address ( addr , & address , ( TARGET_DEBUG_ADDR ? <NUM_LIT> : <NUM_LIT> ) , FALSE ) ; if ( TARGET_DEBUG_ADDR ) { const char * typestr ; switch ( addrtype ) { case CR16_INVALID : typestr = <STR_LIT> ; break ; case CR16_ABSOLUTE : typestr = <STR_LIT> ; break ; case CR16_REG_REL : typestr = <STR_LIT> ; break ; case CR16_REGP_REL : typestr = <STR_LIT> ; break ; case CR16_INDEX_REGP_REL : typestr = <STR_LIT> ; break ;


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


<s> static rtx cr16_libcall_value ( machine_mode mode , const_rtx func ATTRIBUTE_UNUSED ) { return gen_rtx_REG ( mode , cr16_ret_register ( ) ) ;


<s> static rtx cr16_libcall_value ( machine_mode mode , const_rtx func ATTRIBUTE_UNUSED ) {

return gen_rtx_REG ( mode , cr16_ret_register ( ) ) ;


<s> } if ( cr16_data_model ) { if ( strcmp ( cr16_data_model , <STR_LIT> ) == <NUM_LIT> ) data_model = DM_DEFAULT ; else if ( strcmp ( cr16_data_model , <STR_LIT> ) == <NUM_LIT> ) data_model = DM_NEAR ; else if ( strcmp ( cr16_data_model , <STR_LIT> ) == <NUM_LIT> ) { if ( TARGET_CR16CP ) data_model = DM_FAR ; else error ( <STR_LIT> ) ; } else error ( <STR_LIT> , cr16_data_model ) ; }


<s> static void cr16_override_options ( void ) { flag_delete_null_pointer_checks = <NUM_LIT> ; if ( flag_exceptions ) flag_cse_follow_jumps = <NUM_LIT> ; if ( flag_pic == NEAR_PIC ) { data_model = DM_FAR ; } if ( cr16_data_model ) { if ( strcmp ( cr16_data_model , <STR_LIT> ) == <NUM_LIT> ) data_model = DM_DEFAULT ; else if ( strcmp ( cr16_data_model , <STR_LIT> ) == <NUM_LIT> ) data_model = DM_NEAR ;

else if ( strcmp ( cr16_data_model , <STR_LIT> ) == <NUM_LIT> ) {


<s> static char one_inst_str [ <NUM_LIT> ] ; int i , start_reg ; int word_cnt ; int print_ra ; char * return_str ; char * temp_str ; return_str = ( char * ) xmalloc ( <NUM_LIT> ) ; temp_str = ( char * ) xmalloc ( <NUM_LIT> ) ; memset ( return_str , <NUM_LIT> , <NUM_LIT> ) ; i = <NUM_LIT> ; while ( i <= current_frame_info . last_reg_to_save ) { one_inst_str [ <NUM_LIT> ] = <NUM_LIT> ; word_cnt = <NUM_LIT> ; start_reg = i ; print_ra = <NUM_LIT> ; while ( ( word_cnt < MAX_COUNT ) && ( i <= current_frame_info . last_reg_to_save ) ) { if ( ! current_frame_info . save_regs [ i ] ) { ++ i ; break ; } if ( i == RETURN_ADDRESS_REGNUM ) print_ra = <NUM_LIT> ; else { if ( ( word_cnt + ( ( i < CR16_FIRST_DWORD_REGISTER ) ? <NUM_LIT> : <NUM_LIT> ) ) >= MAX_COUNT ) break ; word_cnt += ( ( i < CR16_FIRST_DWORD_REGISTER ) ? <NUM_LIT> : <NUM_LIT> ) ; } ++ i ; } if ( ( word_cnt == <NUM_LIT> ) && ( print_ra == <NUM_LIT> ) ) continue ; if ( word_cnt > <NUM_LIT> ) { sprintf ( one_inst_str , <STR_LIT> , word_cnt , reg_names [ start_reg ] ) ; if ( print_ra ) strcat ( one_inst_str , <STR_LIT> ) ; } else strcat ( one_inst_str , <STR_LIT> ) ; if ( push_or_pop == <NUM_LIT> ) { if ( print_ra && ! cr16_interrupt_function_p ( ) && ! crtl -> calls_eh_return ) strcpy ( temp_str , <STR_LIT> ) ; else strcpy ( temp_str , <STR_LIT> ) ; strcat ( temp_str , one_inst_str ) ; strcat ( return_str , temp_str ) ; } else { strcpy ( temp_str , <STR_LIT> ) ; strcat ( temp_str , one_inst_str ) ; strcat ( temp_str , return_str ) ; strcpy ( return_str , temp_str ) ; } } if ( push_or_pop == <NUM_LIT> ) { if ( cr16_interrupt_function_p ( ) ) strcat ( return_str , <STR_LIT> ) ; else if ( crtl -> calls_eh_return ) { strcat ( return_str , <STR_LIT> ) ; strcat ( return_str , <STR_LIT> ) ; strcpy ( temp_str , <STR_LIT> ) ;


<s> ++ i ; } if ( ( word_cnt == <NUM_LIT> ) && ( print_ra == <NUM_LIT> ) ) continue ; if ( word_cnt > <NUM_LIT> ) { sprintf ( one_inst_str , <STR_LIT> , word_cnt , reg_names [ start_reg ] ) ; if ( print_ra ) strcat ( one_inst_str , <STR_LIT> ) ; } else strcat ( one_inst_str , <STR_LIT> ) ; if ( push_or_pop == <NUM_LIT> ) { if ( print_ra && ! cr16_interrupt_function_p ( ) && ! crtl -> calls_eh_return ) strcpy ( temp_str , <STR_LIT> ) ; else strcpy ( temp_str , <STR_LIT> ) ; strcat ( temp_str , one_inst_str ) ; strcat ( return_str , temp_str ) ; } else { strcpy ( temp_str , <STR_LIT> ) ; strcat ( temp_str , one_inst_str ) ; strcat ( temp_str , return_str ) ; strcpy ( return_str , temp_str ) ; } } if ( push_or_pop == <NUM_LIT> ) { if ( cr16_interrupt_function_p ( ) ) strcat ( return_str , <STR_LIT> ) ; else if ( crtl -> calls_eh_return ) { strcat ( return_str , <STR_LIT> ) ; strcat ( return_str , <STR_LIT> ) ; strcpy ( temp_str , <STR_LIT> ) ; strcat ( temp_str , return_str ) ; strcpy ( return_str , temp_str ) ; } else if ( ! FUNC_IS_NORETURN_P ( current_function_decl ) && ! ( current_frame_info . save_regs [ RETURN_ADDRESS_REGNUM ] ) ) strcat ( return_str , <STR_LIT> ) ; } return_str += <NUM_LIT> ;


<s> const char * cr16_cmp_str ; switch ( GET_CODE ( x ) ) { case EQ : cr16_cmp_str = <STR_LIT> ; break ; case NE : cr16_cmp_str = <STR_LIT> ; break ; case GT : cr16_cmp_str = <STR_LIT> ; break ; case GTU : cr16_cmp_str = <STR_LIT> ; break ; case LT : cr16_cmp_str = <STR_LIT> ; break ; case LTU : cr16_cmp_str = <STR_LIT> ; break ; case GE : cr16_cmp_str = <STR_LIT> ; break ; case GEU : cr16_cmp_str = <STR_LIT> ; break ; case LE : cr16_cmp_str = <STR_LIT> ; break ; case LEU : cr16_cmp_str = <STR_LIT> ; break ; default : gcc_unreachable ( ) ; } fprintf ( file , <STR_LIT> , cr16_cmp_str ) ; return ; } case '$' : putc ( '$' , file ) ; return ; case 'p' : if ( GET_CODE ( x ) == REG ) { fprintf ( file , <STR_LIT> , reg_names [ REGNO ( x ) ] ) ; return ; } break ; case 'b' : fprintf ( file , <STR_LIT> , INTVAL ( x ) ) ; return ; case 'r' : fprintf ( file , <STR_LIT> , cr16_operand_bit_pos ( INTVAL ( x ) , <NUM_LIT> ) ) ; return ; case 's' : fprintf ( file , <STR_LIT> , cr16_operand_bit_pos ( INTVAL ( x ) , <NUM_LIT> ) ) ; return ; case 'g' : ptr_dereference = <NUM_LIT> ; case 'f' : case <NUM_LIT> : switch ( GET_CODE ( x ) ) { case REG : if ( GET_MODE_BITSIZE ( GET_MODE ( x ) ) > BITS_PER_WORD ) { if ( LONG_REG_P ( REGNO ( x ) ) ) fprintf ( file , <STR_LIT> , reg_names [ REGNO ( x ) ] ) ; else fprintf ( file , <STR_LIT> , reg_names [ REGNO ( x ) + <NUM_LIT> ] , reg_names [ REGNO ( x ) ] ) ; } else fprintf ( file , <STR_LIT> , reg_names [ REGNO ( x ) ] ) ; return ; case MEM : output_address ( GET_MODE ( x ) , XEXP ( x , <NUM_LIT> ) ) ; return ; case CONST_DOUBLE : { long l ; REAL_VALUE_TO_TARGET_SINGLE ( * CONST_DOUBLE_REAL_VALUE ( x ) , l ) ; fprintf ( file , <STR_LIT> , l ) ; return ; } case CONST_INT : { fprintf ( file , <STR_LIT> , INTVAL ( x ) ) ; return ; } case UNSPEC : switch ( XINT ( x , <NUM_LIT> ) ) { default : gcc_unreachable ( ) ; } break ; default : if ( ! ptr_dereference ) { putc ( '$' , file ) ; } cr16_print_operand_address ( file , VOIDmode , x ) ; return ; } gcc_unreachable ( ) ; default :


<s> static void cr16_print_operand_address ( FILE * file , machine_mode , rtx addr ) { enum cr16_addrtype addrtype ; struct cr16_address address ; addrtype = cr16_decompose_address ( addr , & address , <NUM_LIT> , TRUE ) ; if ( address . disp && GET_CODE ( address . disp ) == UNSPEC ) { debug_rtx ( addr ) ; } switch ( addrtype ) { case CR16_REG_REL : if ( address . disp ) { if ( GET_CODE ( address . disp ) == UNSPEC ) cr16_print_operand ( file , address . disp , <NUM_LIT> ) ; else output_addr_const ( file , address . disp ) ; } else fprintf ( file , <STR_LIT> ) ; fprintf ( file , <STR_LIT> , reg_names [ REGNO ( address . base ) ] ) ; break ; case CR16_ABSOLUTE : if ( address . disp ) output_addr_const ( file , address . disp ) ; else fprintf ( file , <STR_LIT> ) ; break ; case CR16_INDEX_REGP_REL : fprintf ( file , <STR_LIT> , reg_names [ REGNO ( address . index ) ] ) ; case CR16_REGP_REL : if ( address . disp ) { if ( GET_CODE ( address . disp ) == UNSPEC ) cr16_print_operand ( file , address . disp , <NUM_LIT> ) ; else output_addr_const ( file , address . disp ) ; } else fprintf ( file , <STR_LIT> ) ; fprintf ( file , <STR_LIT> , reg_names [ REGNO ( address . base ) + <NUM_LIT> ] , reg_names [ REGNO ( address . base ) ] ) ; break ; default : debug_rtx ( addr ) ; gcc_unreachable ( ) ; } if ( flag_pic < NEAR_PIC && address . code == <NUM_LIT> ) { if ( address . data == DM_FAR ) fprintf ( file , <STR_LIT> ) ; else if ( address . data == DM_DEFAULT ) fprintf ( file , <STR_LIT> ) ;

else if ( address . data == DM_NEAR ) fprintf ( file , <STR_LIT> ) ;


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


return ( to != GENERAL_REGS ? <NUM_LIT> : <NUM_LIT> ) ;


<s> const HOST_WIDE_INT size = int_size_in_bytes ( type ) ;

return ( ( size == - <NUM_LIT> ) || ( size > <NUM_LIT> ) ) ;


<s> static poly_int64 cr16_return_pops_args ( tree , tree , poly_int64 ) { return <NUM_LIT> ;


<s> static inline unsigned int cr16_ret_register ( void ) {


<s> return gen_rtx_REG ( Pmode , cr16_ret_register ( ) ) ;


<s> static scalar_int_mode cr16_unwind_word_mode ( void ) {


<s> else type_size = int_size_in_bytes ( type ) * BITS_PER_UNIT ; remaining_size = BITS_PER_WORD * ( MAX_REG_FOR_PASSING_ARGS - ( MIN_REG_FOR_PASSING_ARGS + cum -> ints ) + <NUM_LIT> ) ; if ( ( remaining_size >= type_size ) && ( type_size <= <NUM_LIT> * BITS_PER_WORD ) ) return ( type_size + BITS_PER_WORD - <NUM_LIT> ) / BITS_PER_WORD ;


<s> if ( mode != BLKmode ) type_size = GET_MODE_BITSIZE ( mode ) ; else type_size = int_size_in_bytes ( type ) * BITS_PER_UNIT ; remaining_size = BITS_PER_WORD * ( MAX_REG_FOR_PASSING_ARGS - ( MIN_REG_FOR_PASSING_ARGS + cum -> ints ) + <NUM_LIT> ) ; if ( ( remaining_size >= type_size ) && ( type_size <= <NUM_LIT> * BITS_PER_WORD ) ) return ( type_size + BITS_PER_WORD - <NUM_LIT> ) / BITS_PER_WORD ;


<s> if ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == PLUS && XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) == pic_offset_table_rtx ) return orig ; if ( reg == <NUM_LIT> ) { gcc_assert ( can_create_pseudo_p ( ) ) ; reg = gen_reg_rtx ( Pmode ) ; } gcc_assert ( GET_CODE ( XEXP ( orig , <NUM_LIT> ) ) == PLUS ) ; base = legitimize_pic_address ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) , Pmode , reg ) ; offset = legitimize_pic_address ( XEXP ( XEXP ( orig , <NUM_LIT> ) , <NUM_LIT> ) , Pmode , base == reg ? <NUM_LIT> : reg ) ; emit_insn ( gen_addsi3 ( reg , base , offset ) ) ;


<s> void notice_update_cc ( rtx exp ) { if ( GET_CODE ( exp ) == SET ) { if ( SET_DEST ( exp ) == pc_rtx ) return ; if ( REG_P ( SET_DEST ( exp ) ) && ( REG_P ( SET_SRC ( exp ) ) || GET_CODE ( SET_SRC ( exp ) ) == MEM ) ) {