<s> static int autoinc_mode ( rtx x ) { if ( GET_CODE ( x ) != MEM ) return CONST ; x = XEXP ( x , <NUM_LIT> ) ;

if ( GET_CODE ( x ) == PRE_INC || GET_CODE ( x ) == PRE_DEC || GET_CODE ( x ) == POST_INC || GET_CODE ( x ) == POST_DEC ) return GET_CODE ( x ) ;


<s> x = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( x ) == PRE_INC || GET_CODE ( x ) == PRE_DEC || GET_CODE ( x ) == POST_INC || GET_CODE ( x ) == POST_DEC ) return GET_CODE ( x ) ; return CONST ;


<s> stack_push_word = gen_rtx_MEM ( HImode , gen_rtx_PRE_DEC ( HImode , gen_rtx_REG ( HImode , HARD_SP_REGNUM ) ) ) ;

stack_pop_word = gen_rtx_MEM ( HImode , gen_rtx_POST_INC ( HImode , gen_rtx_REG ( HImode , HARD_SP_REGNUM ) ) ) ;


<s> ix_reg = gen_rtx_REG ( HImode , HARD_X_REGNUM ) ; iy_reg = gen_rtx_REG ( HImode , HARD_Y_REGNUM ) ; d_reg = gen_rtx_REG ( HImode , HARD_D_REGNUM ) ;

m68hc11_soft_tmp_reg = gen_rtx_REG ( HImode , SOFT_TMP_REGNUM ) ;


<s> rtx p ; if ( D_REG_P ( reg ) ) x_reg = gen_rtx_REG ( SImode , HARD_X_REGNUM ) ; else x_reg = <NUM_LIT> ; for ( p = PREV_INSN ( x ) ; p && GET_CODE ( p ) != CODE_LABEL ; p = PREV_INSN ( p ) ) if ( INSN_P ( p ) ) { rtx body ; body = PATTERN ( p ) ; if ( GET_CODE ( body ) == CALL_INSN ) break ; if ( GET_CODE ( body ) == JUMP_INSN ) break ; if ( GET_CODE ( body ) == SET ) { rtx dst = XEXP ( body , <NUM_LIT> ) ; if ( GET_CODE ( dst ) == REG && REGNO ( dst ) == REGNO ( reg ) ) break ; if ( x_reg && rtx_equal_p ( dst , x_reg ) ) break ; if ( find_regno_note ( p , REG_DEAD , REGNO ( reg ) ) ) return <NUM_LIT> ; } else if ( reg_mentioned_p ( reg , p ) || ( x_reg && reg_mentioned_p ( x_reg , p ) ) ) break ; } for ( p = x ; p ; p = NEXT_INSN ( p ) ) { rtx body ; if ( GET_CODE ( p ) == CODE_LABEL || GET_CODE ( p ) == JUMP_INSN || GET_CODE ( p ) == CALL_INSN || GET_CODE ( p ) == BARRIER ) break ; if ( GET_CODE ( p ) != INSN ) continue ; body = PATTERN ( p ) ; if ( GET_CODE ( body ) == SET ) { rtx src = XEXP ( body , <NUM_LIT> ) ;


<s> insn = emit_move_insn ( to , scratch ) ; } if ( IS_STACK_PUSH ( to ) ) { REG_NOTES ( insn ) = gen_rtx_EXPR_LIST ( REG_INC , XEXP ( XEXP ( to , <NUM_LIT> ) , <NUM_LIT> ) , REG_NOTES ( insn ) ) ; } else if ( IS_STACK_POP ( from ) ) { REG_NOTES ( insn ) = gen_rtx_EXPR_LIST ( REG_INC , XEXP ( XEXP ( from , <NUM_LIT> ) , <NUM_LIT> ) , REG_NOTES ( insn ) ) ; } else if ( TARGET_M6811 && SP_REG_P ( from ) ) {

REG_NOTES ( insn ) = gen_rtx_EXPR_LIST ( REG_INC , from , REG_NOTES ( insn ) ) ;


<s> insn = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , gen_rtx_SET ( VOIDmode , stack_pointer_rtx , gen_rtx_PLUS ( HImode , stack_pointer_rtx , GEN_INT ( size ) ) ) , gen_rtx_CLOBBER ( VOIDmode , scratch ) ) ) ; emit_insn ( insn ) ; } else { int i ; for ( i = <NUM_LIT> ; i <= size ; i += <NUM_LIT> ) emit_move_after_reload ( scratch , stack_pop_word , scratch ) ; if ( size & <NUM_LIT> ) emit_insn ( gen_addhi3 ( stack_pointer_rtx , stack_pointer_rtx , const1_rtx ) ) ; } if ( current_function_interrupt ) { emit_move_after_reload ( gen_rtx_REG ( HImode , SOFT_SAVED_XY_REGNUM ) , stack_pop_word , scratch ) ; emit_move_after_reload ( gen_rtx_REG ( HImode , SOFT_Z_REGNUM ) , stack_pop_word , scratch ) ; emit_move_after_reload ( m68hc11_soft_tmp_reg , stack_pop_word , scratch ) ; } if ( frame_pointer_needed ) emit_move_after_reload ( hard_frame_pointer_rtx , stack_pop_word , scratch ) ; else if ( current_function_trap && return_size != <NUM_LIT> ) { rtx addr_reg = stack_pointer_rtx ; if ( ! TARGET_M6812 ) { emit_move_after_reload ( scratch , stack_pointer_rtx , <NUM_LIT> ) ; addr_reg = scratch ; } emit_move_after_reload ( gen_rtx_MEM ( HImode , gen_rtx_PLUS ( HImode , addr_reg , const1_rtx ) ) , d_reg , <NUM_LIT> ) ; if ( return_size > HARD_REG_SIZE ) emit_move_after_reload ( gen_rtx_MEM ( HImode , gen_rtx_PLUS ( HImode , addr_reg , GEN_INT ( <NUM_LIT> ) ) ) , ix_reg , <NUM_LIT> ) ; }


<s> emit_insn ( gen_addhi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - size ) ) ) ; } else if ( ( ! optimize_size && size > <NUM_LIT> ) || ( optimize_size && size > <NUM_LIT> ) ) { rtx insn ; insn = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , gen_rtx_SET ( VOIDmode , stack_pointer_rtx , gen_rtx_PLUS ( HImode , stack_pointer_rtx , GEN_INT ( - size ) ) ) , gen_rtx_CLOBBER ( VOIDmode , scratch ) ) ) ; emit_insn ( insn ) ; } else { int i ; for ( i = <NUM_LIT> ; i <= size ; i += <NUM_LIT> ) emit_move_after_reload ( stack_push_word , ix_reg , <NUM_LIT> ) ; if ( size & <NUM_LIT> ) emit_insn ( gen_addhi3 ( stack_pointer_rtx , stack_pointer_rtx , constm1_rtx ) ) ; } if ( frame_pointer_needed ) emit_move_after_reload ( hard_frame_pointer_rtx , stack_pointer_rtx , scratch ) ; for ( regno = SOFT_REG_FIRST ; regno <= SOFT_REG_LAST ; regno ++ ) { if ( regs_ever_live [ regno ] && ! call_used_regs [ regno ] ) { emit_move_after_reload ( stack_push_word , gen_rtx_REG ( HImode , regno ) , scratch ) ; }


<s> if ( m68hc11_valid_addressing_p ( operand , mode , addr_mode ) ) { return <NUM_LIT> ; } if ( PUSH_POP_ADDRESS_P ( operand ) ) { return <NUM_LIT> ; } if ( symbolic_memory_operand ( operand , mode ) ) { return <NUM_LIT> ; }


<s> static int go_if_legitimate_address_internal ( rtx operand , enum machine_mode mode , int strict ) { int addr_mode ; if ( CONSTANT_ADDRESS_P ( operand ) && TARGET_M6812 ) { if ( GET_MODE_SIZE ( mode ) == <NUM_LIT> ) return <NUM_LIT> ; return <NUM_LIT> ; } addr_mode = m68hc11_addr_mode | ( strict ? ADDR_STRICT : <NUM_LIT> ) ; if ( m68hc11_valid_addressing_p ( operand , mode , addr_mode ) ) { return <NUM_LIT> ; } if ( PUSH_POP_ADDRESS_P ( operand ) ) { return <NUM_LIT> ; } if ( symbolic_memory_operand ( operand , mode ) ) { return <NUM_LIT> ;


<s> case <NUM_LIT> : return S_REGNO_P ( regno ) && m68hc11_soft_reg_count >= <NUM_LIT> ; case <NUM_LIT> : return ( X_REGNO_P ( regno ) || ( S_REGNO_P ( regno ) && m68hc11_soft_reg_count >= <NUM_LIT> ) ) ; case <NUM_LIT> : return G_REGNO_P ( regno ) ; case <NUM_LIT> :

return G_REGNO_P ( regno ) && ! SP_REGNO_P ( regno ) ;


<s> break ; case PLUS : { register rtx plus0 = XEXP ( addr , <NUM_LIT> ) ; register rtx plus1 = XEXP ( addr , <NUM_LIT> ) ; if ( GET_CODE ( plus0 ) != REG ) break ; switch ( GET_CODE ( plus1 ) ) { case CONST_INT : if ( INTVAL ( plus1 ) >= <NUM_LIT> * m68hc11_max_offset || INTVAL ( plus1 ) < m68hc11_min_offset ) cost = <NUM_LIT> ; else if ( INTVAL ( plus1 ) >= m68hc11_max_offset ) cost = <NUM_LIT> ; else cost = <NUM_LIT> ; if ( REGNO ( plus0 ) < FIRST_PSEUDO_REGISTER ) cost += <NUM_LIT> ; else cost += <NUM_LIT> ; break ; case SYMBOL_REF : cost = <NUM_LIT> ; break ; case CONST : case LABEL_REF : cost = <NUM_LIT> ; break ; default : break ; } break ; } case PRE_DEC : case PRE_INC : if ( SP_REG_P ( XEXP ( addr , <NUM_LIT> ) ) ) cost = <NUM_LIT> ; break ; default :


<s> case SYMBOL_REF : cost = <NUM_LIT> ; break ; case CONST : case LABEL_REF : cost = <NUM_LIT> ; break ; default : break ; } break ; } case PRE_DEC : case PRE_INC : if ( SP_REG_P ( XEXP ( addr , <NUM_LIT> ) ) ) cost = <NUM_LIT> ; break ; default : break ; } if ( debug_m6811 ) { printf ( <STR_LIT> , cost ) ; fflush ( stdout ) ; debug_rtx ( addr ) ;


<s> fprintf ( asm_out_file , <STR_LIT> ) ;


<s> static void m68hc11_asm_out_destructor ( rtx symbol , int priority ) { default_dtor_section_asm_out_destructor ( symbol , priority ) ;


<s> static void m68hc11_asm_out_destructor ( rtx symbol , int priority ) {

default_dtor_section_asm_out_destructor ( symbol , priority ) ;


<s> void m68hc11_conditional_register_usage ( void ) { int i ; if ( m68hc11_soft_reg_count > SOFT_REG_LAST - SOFT_REG_FIRST ) m68hc11_soft_reg_count = SOFT_REG_LAST - SOFT_REG_FIRST ; for ( i = SOFT_REG_FIRST + m68hc11_soft_reg_count ; i < SOFT_REG_LAST ; i ++ ) { fixed_regs [ i ] = <NUM_LIT> ;


<s> int i ; if ( m68hc11_soft_reg_count > SOFT_REG_LAST - SOFT_REG_FIRST ) m68hc11_soft_reg_count = SOFT_REG_LAST - SOFT_REG_FIRST ; for ( i = SOFT_REG_FIRST + m68hc11_soft_reg_count ; i < SOFT_REG_LAST ; i ++ ) { fixed_regs [ i ] = <NUM_LIT> ; call_used_regs [ i ] = <NUM_LIT> ; } if ( TARGET_M6812 && flag_omit_frame_pointer && optimize ) { fixed_regs [ HARD_Z_REGNUM ] = <NUM_LIT> ; }


<s> libcall = gen_rtx_SYMBOL_REF ( Pmode , name ) ; switch ( noperands ) { case <NUM_LIT> : ret = emit_library_call_value ( libcall , NULL_RTX , LCT_CONST , dmode , <NUM_LIT> , operands [ <NUM_LIT> ] , smode ) ; equiv = gen_rtx_fmt_e ( code , dmode , operands [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> : ret = emit_library_call_value ( libcall , NULL_RTX , LCT_CONST , dmode , <NUM_LIT> , operands [ <NUM_LIT> ] , smode , operands [ <NUM_LIT> ] , smode ) ;

equiv = gen_rtx_fmt_ee ( code , dmode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ;


<s> ret = emit_library_call_value ( libcall , NULL_RTX , LCT_CONST , dmode , <NUM_LIT> , operands [ <NUM_LIT> ] , smode ) ; equiv = gen_rtx_fmt_e ( code , dmode , operands [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> : ret = emit_library_call_value ( libcall , NULL_RTX , LCT_CONST , dmode , <NUM_LIT> , operands [ <NUM_LIT> ] , smode , operands [ <NUM_LIT> ] , smode ) ; equiv = gen_rtx_fmt_ee ( code , dmode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; break ; default : gcc_unreachable ( ) ; } insns = get_insns ( ) ;


<s> if ( ! H_REG_P ( operands [ <NUM_LIT> ] ) && operands [ <NUM_LIT> ] && ( INTVAL ( result ) != <NUM_LIT> || IS_STACK_PUSH ( operands [ <NUM_LIT> ] ) ) ) { emit_move_insn ( operands [ <NUM_LIT> ] , result ) ; emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; } else { emit_move_insn ( operands [ <NUM_LIT> ] , result ) ; } } else if ( operands [ <NUM_LIT> ] != <NUM_LIT> && operands [ <NUM_LIT> ] != <NUM_LIT> ) { rtx insn ; if ( ! H_REG_P ( operands [ <NUM_LIT> ] ) && operands [ <NUM_LIT> ] ) { emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; emit_insn ( gen_rtx_SET ( mode , operands [ <NUM_LIT> ] , gen_rtx_fmt_ee ( code , mode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ) ;

insn = emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ;


<s> need_copy = ( rtx_equal_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) || rtx_equal_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ? <NUM_LIT> : <NUM_LIT> ; operands [ <NUM_LIT> ] = simplify_logical ( mode , code , operands [ <NUM_LIT> ] , & result ) ; operands [ <NUM_LIT> ] = simplify_logical ( mode , code , operands [ <NUM_LIT> ] , & result ) ; if ( result && GET_CODE ( result ) == CONST_INT ) { if ( ! H_REG_P ( operands [ <NUM_LIT> ] ) && operands [ <NUM_LIT> ] && ( INTVAL ( result ) != <NUM_LIT> || IS_STACK_PUSH ( operands [ <NUM_LIT> ] ) ) ) { emit_move_insn ( operands [ <NUM_LIT> ] , result ) ; emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; } else { emit_move_insn ( operands [ <NUM_LIT> ] , result ) ; } } else if ( operands [ <NUM_LIT> ] != <NUM_LIT> && operands [ <NUM_LIT> ] != <NUM_LIT> ) { rtx insn ; if ( ! H_REG_P ( operands [ <NUM_LIT> ] ) && operands [ <NUM_LIT> ] ) { emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; emit_insn ( gen_rtx_SET ( mode , operands [ <NUM_LIT> ] , gen_rtx_fmt_ee ( code , mode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ) ; insn = emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; } else { insn = emit_insn ( gen_rtx_SET ( mode , operands [ <NUM_LIT> ] , gen_rtx_fmt_ee ( code , mode , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ) ; } } else if ( need_copy ) { rtx src ; if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST_INT ) src = operands [ <NUM_LIT> ] ; else src = operands [ <NUM_LIT> ] ; if ( ! H_REG_P ( operands [ <NUM_LIT> ] ) && ! H_REG_P ( src ) ) { emit_move_insn ( operands [ <NUM_LIT> ] , src ) ; emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; }


<s> int len = strlen ( str ) ; char * newstr = alloca ( len + <NUM_LIT> ) ; newstr [ <NUM_LIT> ] = '@' ; strcpy ( & newstr [ <NUM_LIT> ] , str ) ; XSTR ( XEXP ( DECL_RTL ( decl ) , <NUM_LIT> ) , <NUM_LIT> ) = ggc_alloc_string ( newstr , len + <NUM_LIT> ) ;


<s> int trap_handler ; int is_far = <NUM_LIT> ; if ( TREE_CODE ( decl ) == VAR_DECL ) { if ( lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) != <NUM_LIT> ) m68hc11_encode_label ( decl ) ; return ; } if ( TREE_CODE ( decl ) != FUNCTION_DECL ) return ; func_attr = TYPE_ATTRIBUTES ( TREE_TYPE ( decl ) ) ; if ( lookup_attribute ( <STR_LIT> , func_attr ) != NULL_TREE ) is_far = <NUM_LIT> ; else if ( lookup_attribute ( <STR_LIT> , func_attr ) == NULL_TREE ) is_far = TARGET_LONG_CALLS != <NUM_LIT> ; trap_handler = lookup_attribute ( <STR_LIT> , func_attr ) != NULL_TREE ; if ( trap_handler && is_far ) { warning ( OPT_Wattributes , <STR_LIT> <STR_LIT> ) ; trap_handler = <NUM_LIT> ;


<s> static rtx m68hc11_expand_compare ( enum rtx_code code , rtx op0 , rtx op1 ) { rtx ret = <NUM_LIT> ; gcc_assert ( GET_MODE_CLASS ( GET_MODE ( op0 ) ) != MODE_FLOAT ) ; emit_insn ( gen_rtx_SET ( VOIDmode , cc0_rtx , gen_rtx_COMPARE ( VOIDmode , op0 , op1 ) ) ) ; ret = gen_rtx_fmt_ee ( code , VOIDmode , cc0_rtx , const0_rtx ) ;


<s> static rtx m68hc11_expand_compare ( enum rtx_code code , rtx op0 , rtx op1 ) { rtx ret = <NUM_LIT> ; gcc_assert ( GET_MODE_CLASS ( GET_MODE ( op0 ) ) != MODE_FLOAT ) ;

emit_insn ( gen_rtx_SET ( VOIDmode , cc0_rtx , gen_rtx_COMPARE ( VOIDmode , op0 , op1 ) ) ) ;


<s> tmp = gen_rtx_IF_THEN_ELSE ( VOIDmode , tmp , gen_rtx_LABEL_REF ( VOIDmode , label ) , pc_rtx ) ; tmp = gen_rtx_SET ( VOIDmode , pc_rtx , tmp ) ; use_fcomi = ix86_use_fcomi_compare ( code ) ; vec = rtvec_alloc ( <NUM_LIT> + ! use_fcomi ) ; RTVEC_ELT ( vec , <NUM_LIT> ) = tmp ; RTVEC_ELT ( vec , <NUM_LIT> ) = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( CCFPmode , <NUM_LIT> ) ) ; RTVEC_ELT ( vec , <NUM_LIT> ) = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( CCFPmode , <NUM_LIT> ) ) ; if ( ! use_fcomi ) RTVEC_ELT ( vec , <NUM_LIT> ) = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_SCRATCH ( HImode ) ) ; emit_jump_insn ( gen_rtx_PARALLEL ( VOIDmode , vec ) ) ; return ; } case SImode : { rtx lo [ <NUM_LIT> ] , hi [ <NUM_LIT> ] , label2 ; enum rtx_code code1 , code2 , code3 ; if ( CONSTANT_P ( op0 ) && ! CONSTANT_P ( op1 ) ) { tmp = op0 ; op0 = op1 ; op1 = tmp ; code = swap_condition ( code ) ; } lo [ <NUM_LIT> ] = m68hc11_gen_lowpart ( HImode , op0 ) ;

lo [ <NUM_LIT> ] = m68hc11_gen_lowpart ( HImode , op1 ) ;


<s> case DFmode : { rtvec vec ; int use_fcomi ; code = m68hc11_prepare_fp_compare_args ( code , & m68hc11_compare_op0 , & m68hc11_compare_op1 ) ; tmp = gen_rtx_fmt_ee ( code , m68hc11_fp_compare_mode ( code ) , m68hc11_compare_op0 , m68hc11_compare_op1 ) ; tmp = gen_rtx_IF_THEN_ELSE ( VOIDmode , tmp , gen_rtx_LABEL_REF ( VOIDmode , label ) , pc_rtx ) ; tmp = gen_rtx_SET ( VOIDmode , pc_rtx , tmp ) ; use_fcomi = ix86_use_fcomi_compare ( code ) ; vec = rtvec_alloc ( <NUM_LIT> + ! use_fcomi ) ; RTVEC_ELT ( vec , <NUM_LIT> ) = tmp ; RTVEC_ELT ( vec , <NUM_LIT> ) = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( CCFPmode , <NUM_LIT> ) ) ; RTVEC_ELT ( vec , <NUM_LIT> ) = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_REG ( CCFPmode , <NUM_LIT> ) ) ; if ( ! use_fcomi ) RTVEC_ELT ( vec , <NUM_LIT> ) = gen_rtx_CLOBBER ( VOIDmode , gen_rtx_SCRATCH ( HImode ) ) ; emit_jump_insn ( gen_rtx_PARALLEL ( VOIDmode , vec ) ) ; return ; } case SImode : { rtx lo [ <NUM_LIT> ] , hi [ <NUM_LIT> ] , label2 ; enum rtx_code code1 , code2 , code3 ; if ( CONSTANT_P ( op0 ) && ! CONSTANT_P ( op1 ) ) {


<s> static void m68hc11_file_start ( void ) { default_file_start ( ) ; fprintf ( asm_out_file , <STR_LIT> , TARGET_SHORT ? <STR_LIT> : <STR_LIT> ) ;


<s> info -> must_restore_reg = <NUM_LIT> ; info -> first = insn ; info -> x_used = <NUM_LIT> ; info -> y_used = <NUM_LIT> ; info -> can_use_d = TARGET_M6811 ? <NUM_LIT> : <NUM_LIT> ; info -> found_call = <NUM_LIT> ; info -> z_died = <NUM_LIT> ; info -> last = <NUM_LIT> ; info -> regno = - <NUM_LIT> ; info -> z_set_count = <NUM_LIT> ; info -> z_value = NULL_RTX ; info -> must_push_reg = <NUM_LIT> ; info -> save_before_last = <NUM_LIT> ; info -> z_loaded_with_sp = <NUM_LIT> ; for ( ; insn && info -> z_died == <NUM_LIT> ; insn = NEXT_INSN ( insn ) ) { if ( m68hc11_check_z_replacement ( insn , info ) == <NUM_LIT> ) break ; } if ( info -> z_set_count == <NUM_LIT> ) { rtx p = info -> first ; rtx v = <NUM_LIT> ; if ( info -> x_used ) { v = find_last_value ( iy_reg , & p , insn , <NUM_LIT> ) ; } else if ( info -> y_used ) { v = find_last_value ( ix_reg , & p , insn , <NUM_LIT> ) ; } if ( v && ( v != iy_reg && v != ix_reg ) && rtx_equal_p ( v , info -> z_value ) ) { if ( info -> x_used ) info -> regno = HARD_Y_REGNUM ; else info -> regno = HARD_X_REGNUM ; info -> must_load_z = <NUM_LIT> ; info -> must_save_reg = <NUM_LIT> ; info -> must_restore_reg = <NUM_LIT> ; info -> found_call = <NUM_LIT> ; } } if ( info -> z_set_count == <NUM_LIT> ) info -> need_save_z = <NUM_LIT> ; if ( insn == <NUM_LIT> ) info -> need_save_z = <NUM_LIT> ; if ( info -> last == <NUM_LIT> ) info -> last = insn ; if ( info -> regno >= <NUM_LIT> ) { reg = info -> regno ; info -> replace_reg = gen_rtx_REG ( HImode , reg ) ; } else if ( info -> can_use_d ) { reg = HARD_D_REGNUM ; info -> replace_reg = d_reg ; } else if ( info -> x_used ) { reg = HARD_Y_REGNUM ; info -> replace_reg = iy_reg ; } else { reg = HARD_X_REGNUM ;


<s> if ( mode != BLKmode ) { if ( GET_MODE_SIZE ( mode ) == <NUM_LIT> * HARD_REG_SIZE ) return gen_rtx_REG ( mode , HARD_X_REGNUM ) ; if ( GET_MODE_SIZE ( mode ) > HARD_REG_SIZE ) { return NULL_RTX ; } return gen_rtx_REG ( mode , HARD_D_REGNUM ) ;


<s> return NULL_RTX ; } if ( mode != BLKmode ) {

if ( GET_MODE_SIZE ( mode ) == <NUM_LIT> * HARD_REG_SIZE ) return gen_rtx_REG ( mode , HARD_X_REGNUM ) ;


<s> cum -> words = GET_MODE_SIZE ( mode ) ; } else { cum -> words += GET_MODE_SIZE ( mode ) ;

if ( cum -> words <= HARD_REG_SIZE ) cum -> nregs = <NUM_LIT> ;


<s> int m68hc11_function_arg_padding ( enum machine_mode mode , tree type ) { if ( type != <NUM_LIT> && AGGREGATE_TYPE_P ( type ) ) return upward ; return DEFAULT_FUNCTION_ARG_PADDING ( mode , type ) ;


<s> long l [ <NUM_LIT> ] ; if ( GET_MODE_CLASS ( GET_MODE ( x ) ) == MODE_FLOAT ) { REAL_VALUE_TYPE r ; if ( GET_MODE ( x ) == SFmode ) { REAL_VALUE_FROM_CONST_DOUBLE ( r , x ) ; REAL_VALUE_TO_TARGET_SINGLE ( r , l [ <NUM_LIT> ] ) ; } else { rtx first , second ; split_double ( x , & first , & second ) ; return first ; } if ( mode == SImode ) return GEN_INT ( l [ <NUM_LIT> ] ) ; return gen_int_mode ( ( l [ <NUM_LIT> ] >> <NUM_LIT> ) , HImode ) ; } else { l [ <NUM_LIT> ] = CONST_DOUBLE_HIGH ( x ) ; } switch ( mode ) { case SImode : return GEN_INT ( l [ <NUM_LIT> ] ) ; case HImode :

gcc_assert ( GET_MODE_CLASS ( GET_MODE ( x ) ) == MODE_FLOAT ) ;


<s> if ( mode == QImode && D_REG_P ( x ) ) return gen_rtx_REG ( mode , HARD_B_REGNUM ) ; if ( GET_CODE ( x ) == SUBREG && SUBREG_BYTE ( x ) != <NUM_LIT> ) { switch ( mode ) { case SImode : return gen_rtx_SUBREG ( mode , SUBREG_REG ( x ) , SUBREG_BYTE ( x ) + <NUM_LIT> ) ; case HImode : return gen_rtx_SUBREG ( mode , SUBREG_REG ( x ) , SUBREG_BYTE ( x ) + <NUM_LIT> ) ; default : gcc_unreachable ( ) ; } } x = gen_lowpart ( mode , x ) ; if ( GET_CODE ( x ) == MEM ) x = copy_rtx ( x ) ;


<s> output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; } val -= <NUM_LIT> ; } else if ( val >= <NUM_LIT> ) { val = val - <NUM_LIT> ; } if ( val > <NUM_LIT> ) { while ( -- val >= <NUM_LIT> ) { if ( GET_MODE ( operands [ <NUM_LIT> ] ) != QImode ) { output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; } if ( D_REG_P ( operands [ <NUM_LIT> ] ) ) output_asm_insn ( <STR_LIT> , operands ) ; if ( GET_MODE ( operands [ <NUM_LIT> ] ) != QImode || DA_REG_P ( operands [ <NUM_LIT> ] ) ) output_asm_insn ( <STR_LIT> , operands ) ; } } else { while ( ++ val <= <NUM_LIT> ) { if ( GET_MODE ( operands [ <NUM_LIT> ] ) != QImode ) output_asm_insn ( <STR_LIT> , operands ) ; if ( D_REG_P ( operands [ <NUM_LIT> ] ) ) output_asm_insn ( <STR_LIT> , operands ) ;


<s> if ( GET_CODE ( operands [ <NUM_LIT> ] ) != CONST_INT || ( ! D_REG_P ( operands [ <NUM_LIT> ] ) && ! DA_REG_P ( operands [ <NUM_LIT> ] ) ) ) fatal_insn ( <STR_LIT> , insn ) ; val = INTVAL ( operands [ <NUM_LIT> ] ) ; if ( code == ROTATERT ) val = GET_MODE_SIZE ( GET_MODE ( operands [ <NUM_LIT> ] ) ) * BITS_PER_UNIT - val ; if ( GET_MODE ( operands [ <NUM_LIT> ] ) != QImode ) CC_STATUS_INIT ; if ( val >= <NUM_LIT> && val <= <NUM_LIT> ) { if ( TARGET_M6812 ) output_asm_insn ( <STR_LIT> , operands ) ; else { output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; } val -= <NUM_LIT> ; } else if ( val >= <NUM_LIT> ) { val = val - <NUM_LIT> ; } if ( val > <NUM_LIT> ) { while ( -- val >= <NUM_LIT> ) { if ( GET_MODE ( operands [ <NUM_LIT> ] ) != QImode ) { output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; } if ( D_REG_P ( operands [ <NUM_LIT> ] ) ) output_asm_insn ( <STR_LIT> , operands ) ; if ( GET_MODE ( operands [ <NUM_LIT> ] ) != QImode || DA_REG_P ( operands [ <NUM_LIT> ] ) ) output_asm_insn ( <STR_LIT> , operands ) ; } } else { while ( ++ val <= <NUM_LIT> ) { if ( GET_MODE ( operands [ <NUM_LIT> ] ) != QImode ) output_asm_insn ( <STR_LIT> , operands ) ; if ( D_REG_P ( operands [ <NUM_LIT> ] ) ) output_asm_insn ( <STR_LIT> , operands ) ; if ( GET_MODE ( operands [ <NUM_LIT> ] ) != QImode || DA_REG_P ( operands [ <NUM_LIT> ] ) ) output_asm_insn ( <STR_LIT> , operands ) ; }


<s> if ( result == <NUM_LIT> ) { if ( debug_m6811 ) { printf ( <STR_LIT> , ( strict ? <STR_LIT> : <STR_LIT> ) , mode ) ; fflush ( stdout ) ;


<s> int result ; if ( debug_m6811 ) { printf ( <STR_LIT> ) ; fflush ( stdout ) ; debug_rtx ( operand ) ; } result = go_if_legitimate_address_internal ( operand , mode , strict ) ;


<s> static tree m68hc11_handle_fntype_attribute ( tree * node , tree name , tree args ATTRIBUTE_UNUSED , int flags ATTRIBUTE_UNUSED , bool * no_add_attrs ) { if ( TREE_CODE ( * node ) != FUNCTION_TYPE && TREE_CODE ( * node ) != METHOD_TYPE && TREE_CODE ( * node ) != FIELD_DECL && TREE_CODE ( * node ) != TYPE_DECL ) {

warning ( OPT_Wattributes , <STR_LIT> , IDENTIFIER_POINTER ( name ) ) ;


<s> static tree m68hc11_handle_page0_attribute ( tree * node , tree name , tree args ATTRIBUTE_UNUSED , int flags ATTRIBUTE_UNUSED , bool * no_add_attrs ) { tree decl = * node ; if ( TREE_STATIC ( decl ) || DECL_EXTERNAL ( decl ) ) { DECL_SECTION_NAME ( decl ) = build_string ( <NUM_LIT> , <STR_LIT> ) ; } else {


<s> if ( reg2 == HARD_Z_REGNUM ) return <NUM_LIT> ; if ( TARGET_M6811 && reg2 == HARD_Y_REGNUM && ( D_REGNO_P ( reg1 ) || X_REGNO_P ( reg1 ) ) ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> if ( reg2 == HARD_Z_REGNUM ) return <NUM_LIT> ; if ( TARGET_M6811 && reg2 == HARD_Y_REGNUM && ( D_REGNO_P ( reg1 ) || X_REGNO_P ( reg1 ) ) ) return <NUM_LIT> ;


<s> if ( symbolic_memory_operand ( op , mode ) ) return TARGET_M6812 ; if ( reload_in_progress ) return <NUM_LIT> ; operand = XEXP ( operand , <NUM_LIT> ) ;


<s> int m68hc11_indirect_p ( rtx operand , enum machine_mode mode ) { if ( GET_CODE ( operand ) == MEM && GET_MODE ( operand ) == mode ) { rtx op = XEXP ( operand , <NUM_LIT> ) ; int addr_mode ; if ( m68hc11_page0_symbol_p ( op ) ) return <NUM_LIT> ; if ( symbolic_memory_operand ( op , mode ) ) return TARGET_M6812 ; if ( reload_in_progress ) return <NUM_LIT> ; operand = XEXP ( operand , <NUM_LIT> ) ; addr_mode = m68hc11_addr_mode | ( reload_completed ? ADDR_STRICT : <NUM_LIT> ) ; return m68hc11_valid_addressing_p ( operand , mode , addr_mode ) ; } return <NUM_LIT> ;


<s> const char * static_chain_reg = reg_names [ STATIC_CHAIN_REGNUM ] ; if ( * static_chain_reg == '*' ) static_chain_reg ++ ; if ( TARGET_M6811 ) { emit_move_insn ( gen_rtx_MEM ( HImode , tramp ) , GEN_INT ( <NUM_LIT> ) ) ; emit_move_insn ( gen_rtx_MEM ( HImode , plus_constant ( tramp , <NUM_LIT> ) ) , cxt ) ; emit_move_insn ( gen_rtx_MEM ( HImode , plus_constant ( tramp , <NUM_LIT> ) ) , GEN_INT ( <NUM_LIT> ) ) ; emit_move_insn ( gen_rtx_MEM ( QImode , plus_constant ( tramp , <NUM_LIT> ) ) , gen_rtx_CONST ( QImode , gen_rtx_SYMBOL_REF ( Pmode , static_chain_reg ) ) ) ; emit_move_insn ( gen_rtx_MEM ( QImode , plus_constant ( tramp , <NUM_LIT> ) ) , GEN_INT ( <NUM_LIT> ) ) ; emit_move_insn ( gen_rtx_MEM ( HImode , plus_constant ( tramp , <NUM_LIT> ) ) , fnaddr ) ; } else { emit_move_insn ( gen_rtx_MEM ( HImode , tramp ) , GEN_INT ( <NUM_LIT> ) ) ; emit_move_insn ( gen_rtx_MEM ( HImode , plus_constant ( tramp , <NUM_LIT> ) ) , cxt ) ; emit_move_insn ( gen_rtx_MEM ( HImode , plus_constant ( tramp , <NUM_LIT> ) ) , gen_rtx_CONST ( HImode , gen_rtx_SYMBOL_REF ( Pmode , static_chain_reg ) ) ) ; emit_move_insn ( gen_rtx_MEM ( QImode , plus_constant ( tramp , <NUM_LIT> ) ) , GEN_INT ( <NUM_LIT> ) ) ; emit_move_insn ( gen_rtx_MEM ( HImode , plus_constant ( tramp , <NUM_LIT> ) ) , fnaddr ) ;


<s> emit_move_insn ( gen_rtx_MEM ( QImode , plus_constant ( tramp , <NUM_LIT> ) ) , GEN_INT ( <NUM_LIT> ) ) ; emit_move_insn ( gen_rtx_MEM ( HImode , plus_constant ( tramp , <NUM_LIT> ) ) , fnaddr ) ; } else { emit_move_insn ( gen_rtx_MEM ( HImode , tramp ) , GEN_INT ( <NUM_LIT> ) ) ; emit_move_insn ( gen_rtx_MEM ( HImode , plus_constant ( tramp , <NUM_LIT> ) ) , cxt ) ;

emit_move_insn ( gen_rtx_MEM ( HImode , plus_constant ( tramp , <NUM_LIT> ) ) , gen_rtx_CONST ( HImode , gen_rtx_SYMBOL_REF ( Pmode , static_chain_reg ) ) ) ;


<s> if ( lookup_attribute ( <STR_LIT> , func_attr ) != <NUM_LIT> ) current_function_far = <NUM_LIT> ; else if ( lookup_attribute ( <STR_LIT> , func_attr ) != <NUM_LIT> ) current_function_far = <NUM_LIT> ; else current_function_far = ( TARGET_LONG_CALLS != <NUM_LIT> && ! current_function_interrupt && ! trap_handler ) ; if ( trap_handler && from == ARG_POINTER_REGNUM ) size = <NUM_LIT> ; else if ( current_function_far && from == ARG_POINTER_REGNUM ) size = <NUM_LIT> ; else size = <NUM_LIT> ; if ( from == ARG_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM ) { return get_frame_size ( ) + <NUM_LIT> + m68hc11_sp_correction + size ; } if ( from == FRAME_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM ) { return m68hc11_sp_correction ;


<s> cum -> nregs = <NUM_LIT> ; if ( fntype == <NUM_LIT> ) { const char * name ; size_t len ; if ( libname == <NUM_LIT> || GET_CODE ( libname ) != SYMBOL_REF ) return ; name = XSTR ( libname , <NUM_LIT> ) ; len = strlen ( name ) ; if ( len > <NUM_LIT> && ( ( name [ len - <NUM_LIT> ] == 'd' && ( name [ len - <NUM_LIT> ] == 'f' || name [ len - <NUM_LIT> ] == 'i' ) ) || ( name [ len - <NUM_LIT> ] == 'd' && ( name [ len - <NUM_LIT> ] == 'i' || name [ len - <NUM_LIT> ] == 'f' ) ) ) ) { cum -> words = <NUM_LIT> ; cum -> nregs = <NUM_LIT> ;


<s> static void m68hc11_init_libfuncs ( void ) { memcpy_libfunc = init_one_libfunc ( <STR_LIT> ) ;


<s> if ( GET_CODE ( sym ) == MEM ) sym = XEXP ( sym , <NUM_LIT> ) ; return SYMBOL_REF_FLAG ( sym ) ;


<s> return trap_handler_symbol != <NUM_LIT> && rtx_equal_p ( trap_handler_symbol , sym ) ;


<s> case POST_DEC : case POST_INC : insn = ( rtx ) data ; REG_NOTES ( insn ) = alloc_EXPR_LIST ( REG_INC , XEXP ( * x , <NUM_LIT> ) , REG_NOTES ( insn ) ) ; return - <NUM_LIT> ; default :


<s> int m68hc11_memory_move_cost ( enum machine_mode mode , enum reg_class class , int in ATTRIBUTE_UNUSED ) { if ( class <= H_REGS && class > NO_REGS ) {

if ( GET_MODE_SIZE ( mode ) <= <NUM_LIT> ) return COSTS_N_INSNS ( <NUM_LIT> ) + ( reload_completed | reload_in_progress ) ;


<s> if ( GET_MODE_SIZE ( mode ) <= <NUM_LIT> ) return COSTS_N_INSNS ( <NUM_LIT> ) + ( reload_completed | reload_in_progress ) ; else return COSTS_N_INSNS ( <NUM_LIT> ) + ( reload_completed | reload_in_progress ) ;


<s> void m68hc11_notice_keep_cc ( rtx reg ) { if ( reg == <NUM_LIT> || cc_prev_status . value1 == <NUM_LIT> || rtx_equal_p ( reg , cc_prev_status . value1 ) || ( cc_prev_status . value2 && reg_mentioned_p ( reg , cc_prev_status . value2 ) ) ) CC_STATUS_INIT ; else cc_status = cc_prev_status ;


<s> if ( GET_CODE ( exp ) == SET ) { if ( SET_DEST ( exp ) == pc_rtx ) ; else if ( GET_CODE ( SET_SRC ( exp ) ) == CALL ) { CC_STATUS_INIT ; } else if ( SET_DEST ( exp ) == cc0_rtx ) { cc_status . flags = <NUM_LIT> ; cc_status . value1 = XEXP ( exp , <NUM_LIT> ) ; cc_status . value2 = XEXP ( exp , <NUM_LIT> ) ; } else { cc_status . flags = <NUM_LIT> ; cc_status . value1 = XEXP ( exp , <NUM_LIT> ) ; cc_status . value2 = XEXP ( exp , <NUM_LIT> ) ; } } else { CC_STATUS_INIT ; } if ( cc_status . value2 != <NUM_LIT> ) switch ( GET_CODE ( cc_status . value2 ) ) { case IOR : case XOR : case AND : break ; case NOT : if ( GET_MODE ( cc_status . value2 ) != QImode ) CC_STATUS_INIT ; break ; case PLUS : case MINUS : case MULT : case DIV : case UDIV : case MOD : case UMOD : case NEG : if ( GET_MODE ( cc_status . value2 ) != VOIDmode ) cc_status . flags |= CC_NO_OVERFLOW ; break ; case ASHIFT : case ROTATE : case ROTATERT : if ( GET_MODE ( cc_status . value2 ) != VOIDmode ) cc_status . flags |= CC_NO_OVERFLOW ; break ; case MEM : case SYMBOL_REF : case REG : case CONST_INT : cc_status . flags |= CC_NO_OVERFLOW ; break ; default : break ; } if ( cc_status . value1 && GET_CODE ( cc_status . value1 ) == REG && cc_status . value2 && reg_overlap_mentioned_p ( cc_status . value1 , cc_status . value2 ) ) cc_status . value2 = <NUM_LIT> ; else if ( cc_status . value1 && side_effects_p ( cc_status . value1 ) ) cc_status . value1 = <NUM_LIT> ;


<s> CC_STATUS_INIT ; } else if ( SET_DEST ( exp ) == cc0_rtx ) { cc_status . flags = <NUM_LIT> ; cc_status . value1 = XEXP ( exp , <NUM_LIT> ) ; cc_status . value2 = XEXP ( exp , <NUM_LIT> ) ; } else { cc_status . flags = <NUM_LIT> ; cc_status . value1 = XEXP ( exp , <NUM_LIT> ) ; cc_status . value2 = XEXP ( exp , <NUM_LIT> ) ; } } else { CC_STATUS_INIT ; } if ( cc_status . value2 != <NUM_LIT> ) switch ( GET_CODE ( cc_status . value2 ) ) { case IOR : case XOR : case AND : break ; case NOT : if ( GET_MODE ( cc_status . value2 ) != QImode ) CC_STATUS_INIT ; break ; case PLUS : case MINUS : case MULT : case DIV : case UDIV : case MOD : case UMOD : case NEG : if ( GET_MODE ( cc_status . value2 ) != VOIDmode ) cc_status . flags |= CC_NO_OVERFLOW ; break ; case ASHIFT : case ROTATE : case ROTATERT : if ( GET_MODE ( cc_status . value2 ) != VOIDmode ) cc_status . flags |= CC_NO_OVERFLOW ; break ; case MEM : case SYMBOL_REF : case REG : case CONST_INT : cc_status . flags |= CC_NO_OVERFLOW ; break ; default : break ;


<s> return GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT && INTVAL ( XEXP ( x , <NUM_LIT> ) ) < <NUM_LIT> && INTVAL ( XEXP ( x , <NUM_LIT> ) ) >= <NUM_LIT> ; default : return <NUM_LIT> ; }


<s> return GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT && INTVAL ( XEXP ( x , <NUM_LIT> ) ) < <NUM_LIT> && INTVAL ( XEXP ( x , <NUM_LIT> ) ) >= <NUM_LIT> ; default :


<s> ix_reg = gen_rtx_REG ( HImode , HARD_X_REGNUM ) ; iy_reg = gen_rtx_REG ( HImode , HARD_Y_REGNUM ) ; z_reg = gen_rtx_REG ( HImode , HARD_Z_REGNUM ) ; z_reg_qi = gen_rtx_REG ( QImode , HARD_Z_REGNUM ) ; for ( insn = first ; insn ; insn = NEXT_INSN ( insn ) ) { rtx body ;

if ( GET_CODE ( insn ) == CODE_LABEL || GET_CODE ( insn ) == NOTE || GET_CODE ( insn ) == BARRIER ) continue ;


<s> } if ( GET_CODE ( operand ) != MEM ) return <NUM_LIT> ; operand = XEXP ( operand , <NUM_LIT> ) ;


<s> operand = reg_equiv_memory_loc [ REGNO ( operand ) ] ; operand = eliminate_regs ( operand , <NUM_LIT> , NULL_RTX ) ; } if ( GET_CODE ( operand ) != MEM ) return <NUM_LIT> ; operand = XEXP ( operand , <NUM_LIT> ) ;


<s> int m68hc11_register_move_cost ( enum machine_mode mode , enum reg_class from , enum reg_class to ) { if ( from < to ) { enum reg_class tmp = to ; to = from , from = tmp ; }

if ( to >= S_REGS ) return m68hc11_memory_move_cost ( mode , S_REGS , <NUM_LIT> ) ;


<s> else if ( from <= S_REGS ) return COSTS_N_INSNS ( <NUM_LIT> ) + ( reload_completed | reload_in_progress ) ; else return COSTS_N_INSNS ( <NUM_LIT> ) ;


<s> enum machine_mode mode ; if ( regs_inited == <NUM_LIT> ) create_regs_rtx ( ) ; mode = GET_MODE ( operands [ <NUM_LIT> ] ) ; if ( A_REG_P ( operands [ <NUM_LIT> ] ) && memory_reload_operand ( operands [ <NUM_LIT> ] , mode ) ) { rtx big_offset = XEXP ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) , <NUM_LIT> ) ; rtx base = XEXP ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) , <NUM_LIT> ) ; if ( GET_CODE ( base ) != REG ) { rtx tmp = base ; base = big_offset ; big_offset = tmp ; } if ( ! VALID_CONSTANT_OFFSET_P ( big_offset , mode ) ) { int vh , vl ; rtx reg = operands [ <NUM_LIT> ] ; rtx offset ; int val = INTVAL ( big_offset ) ; if ( ! rtx_equal_p ( base , operands [ <NUM_LIT> ] ) ) { emit_move_insn ( reg , base ) ; } if ( val > <NUM_LIT> ) { vh = val >> <NUM_LIT> ; vl = val & <NUM_LIT> ; } else { vh = ( val >> <NUM_LIT> ) & <NUM_LIT> ; vl = val & <NUM_LIT> ; } offset = GEN_INT ( vl ) ; if ( ! VALID_CONSTANT_OFFSET_P ( offset , mode ) ) { emit_insn ( gen_rtx_SET ( VOIDmode , reg , gen_rtx_PLUS ( HImode , reg , big_offset ) ) ) ; offset = const0_rtx ; } else { emit_insn ( gen_rtx_SET ( VOIDmode , reg , gen_rtx_PLUS ( HImode , reg , GEN_INT ( vh << <NUM_LIT> ) ) ) ) ;


<s> unshare_all_rtl_again ( first ) ; split_all_insns_noflow ( ) ; split_done = <NUM_LIT> ; z_replacement_completed = <NUM_LIT> ; m68hc11_reassign_regs ( first ) ; if ( optimize ) compute_bb_for_insn ( ) ; if ( optimize > <NUM_LIT> && split_done ) { reload_cse_regs ( first ) ; } if ( optimize ) { for ( insn = first ; insn ; insn = NEXT_INSN ( insn ) ) { if ( INSN_P ( insn ) ) { rtx * pnote ; pnote = & REG_NOTES ( insn ) ; while ( * pnote != <NUM_LIT> ) { if ( REG_NOTE_KIND ( * pnote ) == REG_DEAD ) * pnote = XEXP ( * pnote , <NUM_LIT> ) ; else pnote = & XEXP ( * pnote , <NUM_LIT> ) ; } } } life_analysis ( <NUM_LIT> , PROP_REG_INFO | PROP_DEATH_NOTES ) ; } z_replacement_completed = <NUM_LIT> ; if ( optimize > <NUM_LIT> ) split_all_insns_noflow ( ) ; { rtx insn ; for ( insn = first ; insn ; insn = NEXT_INSN ( insn ) ) { rtx body ; if ( INSN_DELETED_P ( insn ) ) continue ; if ( ! INSN_P ( insn ) ) continue ; body = PATTERN ( insn ) ; if ( GET_CODE ( body ) == SET && rtx_equal_p ( SET_SRC ( body ) , SET_DEST ( body ) ) ) { PUT_CODE ( insn , NOTE ) ; NOTE_LINE_NUMBER ( insn ) = NOTE_INSN_DELETED ; NOTE_SOURCE_FILE ( insn ) = <NUM_LIT> ;


<s> if ( optimize ) { for ( insn = first ; insn ; insn = NEXT_INSN ( insn ) ) { if ( INSN_P ( insn ) ) { rtx * pnote ; pnote = & REG_NOTES ( insn ) ; while ( * pnote != <NUM_LIT> ) { if ( REG_NOTE_KIND ( * pnote ) == REG_DEAD ) * pnote = XEXP ( * pnote , <NUM_LIT> ) ; else pnote = & XEXP ( * pnote , <NUM_LIT> ) ; } } } life_analysis ( <NUM_LIT> , PROP_REG_INFO | PROP_DEATH_NOTES ) ; } z_replacement_completed = <NUM_LIT> ; if ( optimize > <NUM_LIT> ) split_all_insns_noflow ( ) ; { rtx insn ; for ( insn = first ; insn ; insn = NEXT_INSN ( insn ) ) { rtx body ; if ( INSN_DELETED_P ( insn ) ) continue ; if ( ! INSN_P ( insn ) ) continue ; body = PATTERN ( insn ) ; if ( GET_CODE ( body ) == SET && rtx_equal_p ( SET_SRC ( body ) , SET_DEST ( body ) ) ) {


<s> if ( TYPE_MODE ( type ) == BLKmode ) {

HOST_WIDE_INT size = int_size_in_bytes ( type ) ;


<s> switch ( code ) { case ROTATE : case ROTATERT : case ASHIFT : case LSHIFTRT : case ASHIFTRT : if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) { return m68hc11_shift_cost ( mode , XEXP ( x , <NUM_LIT> ) , INTVAL ( XEXP ( x , <NUM_LIT> ) ) ) ; } total = rtx_cost ( XEXP ( x , <NUM_LIT> ) , code ) + rtx_cost ( XEXP ( x , <NUM_LIT> ) , code ) ; total += m68hc11_cost -> shift_var ; return total ; case AND : case XOR : case IOR : total = rtx_cost ( XEXP ( x , <NUM_LIT> ) , code ) + rtx_cost ( XEXP ( x , <NUM_LIT> ) , code ) ; total += m68hc11_cost -> logical ; total *= GET_MODE_SIZE ( mode ) ; return total ; case MINUS : case PLUS : total = rtx_cost ( XEXP ( x , <NUM_LIT> ) , code ) + rtx_cost ( XEXP ( x , <NUM_LIT> ) , code ) ; total += m68hc11_cost -> add ; if ( GET_MODE_SIZE ( mode ) > <NUM_LIT> ) { total *= GET_MODE_SIZE ( mode ) / <NUM_LIT> ; } return total ; case UDIV : case DIV : case MOD : total = rtx_cost ( XEXP ( x , <NUM_LIT> ) , code ) + rtx_cost ( XEXP ( x , <NUM_LIT> ) , code ) ; switch ( mode ) { case QImode : total += m68hc11_cost -> divQI ; break ; case HImode : total += m68hc11_cost -> divHI ; break ; case SImode : default : total += m68hc11_cost -> divSI ; break ;


<s> else if ( mode == HImode ) total += m68hc11_cost -> shiftHI_const [ shift % <NUM_LIT> ] ; else if ( shift == <NUM_LIT> || shift == <NUM_LIT> || shift == <NUM_LIT> ) total += m68hc11_cost -> shiftHI_const [ <NUM_LIT> ] ; else if ( shift != <NUM_LIT> && shift != <NUM_LIT> && shift != <NUM_LIT> ) { total += m68hc11_cost -> shiftHI_const [ <NUM_LIT> ] * shift ; } if ( GET_MODE_SIZE ( mode ) > <NUM_LIT> && ( shift % <NUM_LIT> ) != <NUM_LIT> ) total *= GET_MODE_SIZE ( mode ) / <NUM_LIT> ;

if ( optimize_size && ( shift % <NUM_LIT> ) != <NUM_LIT> ) total *= <NUM_LIT> ;


<s> if ( GET_CODE ( operand ) == REG && reload_in_progress && REGNO ( operand ) >= FIRST_PSEUDO_REGISTER && reg_equiv_memory_loc [ REGNO ( operand ) ] ) { operand = reg_equiv_memory_loc [ REGNO ( operand ) ] ; operand = eliminate_regs ( operand , <NUM_LIT> , NULL_RTX ) ; } if ( GET_CODE ( operand ) != MEM ) return <NUM_LIT> ; operand = XEXP ( operand , <NUM_LIT> ) ; if ( CONSTANT_ADDRESS_P ( operand ) ) return <NUM_LIT> ; if ( PUSH_POP_ADDRESS_P ( operand ) ) return <NUM_LIT> ; addr_mode = m68hc11_mov_addr_mode | ( reload_completed ? ADDR_STRICT : <NUM_LIT> ) ; if ( ! m68hc11_valid_addressing_p ( operand , mode , addr_mode ) ) return <NUM_LIT> ;

if ( TARGET_M6812 && GET_CODE ( operand ) == PLUS && ( reload_completed | reload_in_progress ) ) {


<s> high [ <NUM_LIT> ] = m68hc11_gen_highpart ( mode , operands [ <NUM_LIT> ] ) ; high [ <NUM_LIT> ] = m68hc11_gen_highpart ( mode , operands [ <NUM_LIT> ] ) ; high [ <NUM_LIT> ] = m68hc11_gen_highpart ( mode , operands [ <NUM_LIT> ] ) ; low [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; high [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; if ( mode == SImode ) { m68hc11_split_logical ( HImode , code , low ) ; m68hc11_split_logical ( HImode , code , high ) ; return ;


<s> high [ <NUM_LIT> ] = m68hc11_gen_highpart ( mode , operands [ <NUM_LIT> ] ) ; low [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; high [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; if ( mode == SImode ) { m68hc11_split_logical ( HImode , code , low ) ; m68hc11_split_logical ( HImode , code , high ) ; return ; }

m68hc11_emit_logical ( mode , code , low ) ;


<s> m68hc11_split_move ( gen_rtx_MEM ( GET_MODE ( to ) , reg ) , from , scratch ) ; if ( code == POST_DEC ) emit_insn ( gen_addhi3 ( reg , reg , GEN_INT ( offset ) ) ) ; return ; } if ( ( autoinc_to != autoinc_from && autoinc_to != CONST && autoinc_from != CONST ) || ( autoinc_to != CONST && reg_mentioned_p ( XEXP ( XEXP ( to , <NUM_LIT> ) , <NUM_LIT> ) , from ) && ! IS_STACK_PUSH ( to ) ) ) { code = GET_CODE ( XEXP ( to , <NUM_LIT> ) ) ; reg = XEXP ( XEXP ( to , <NUM_LIT> ) , <NUM_LIT> ) ; offset = GET_MODE_SIZE ( GET_MODE ( to ) ) ; if ( code == PRE_DEC || code == POST_DEC ) offset = - offset ; if ( code == PRE_DEC || code == PRE_INC ) emit_insn ( gen_addhi3 ( reg , reg , GEN_INT ( offset ) ) ) ; m68hc11_split_move ( gen_rtx_MEM ( GET_MODE ( to ) , reg ) , from , scratch ) ; if ( code == POST_DEC || code == POST_INC ) emit_insn ( gen_addhi3 ( reg , reg , GEN_INT ( offset ) ) ) ; return ; } if ( autoinc_from != CONST && reg_mentioned_p ( XEXP ( XEXP ( from , <NUM_LIT> ) , <NUM_LIT> ) , to ) && ! IS_STACK_PUSH ( to ) ) { code = GET_CODE ( XEXP ( from , <NUM_LIT> ) ) ; reg = XEXP ( XEXP ( from , <NUM_LIT> ) , <NUM_LIT> ) ; offset = GET_MODE_SIZE ( GET_MODE ( from ) ) ; if ( code == PRE_DEC || code == POST_DEC ) offset = - offset ; if ( code == PRE_DEC || code == PRE_INC ) emit_insn ( gen_addhi3 ( reg , reg , GEN_INT ( offset ) ) ) ; m68hc11_split_move ( to , gen_rtx_MEM ( GET_MODE ( from ) , reg ) , scratch ) ; if ( code == POST_DEC || code == POST_INC ) emit_insn ( gen_addhi3 ( reg , reg , GEN_INT ( offset ) ) ) ; return ; } } if ( GET_MODE_SIZE ( mode ) == <NUM_LIT> ) mode = SImode ; else if ( GET_MODE_SIZE ( mode ) == <NUM_LIT> ) mode = HImode ; else mode = QImode ; if ( TARGET_M6812 && IS_STACK_PUSH ( to ) && reg_mentioned_p ( gen_rtx_REG ( HImode , HARD_SP_REGNUM ) , from ) ) { if ( mode == SImode ) { offset = <NUM_LIT> ; } else if ( mode == HImode ) { offset = <NUM_LIT> ; } else offset = <NUM_LIT> ; } low_to = m68hc11_gen_lowpart ( mode , to ) ;

high_to = m68hc11_gen_highpart ( mode , to ) ;


<s> static const char * m68hc11_strip_name_encoding ( const char * str ) { return str + ( * str == '*' || * str == '@' || * str == '&' ) ;


<s> static rtx m68hc11_struct_value_rtx ( tree fntype ATTRIBUTE_UNUSED , int incoming ATTRIBUTE_UNUSED ) { return gen_rtx_REG ( Pmode , HARD_D_REGNUM ) ;


<s> rtx op = XEXP ( operand , <NUM_LIT> ) ;

if ( symbolic_memory_operand ( op , mode ) ) return <NUM_LIT> ;


<s> size = get_frame_size ( ) ; if ( current_function_interrupt ) { size += <NUM_LIT> * HARD_REG_SIZE ; } if ( frame_pointer_needed ) size += HARD_REG_SIZE ; for ( regno = SOFT_REG_FIRST ; regno <= SOFT_REG_LAST ; regno ++ ) if ( regs_ever_live [ regno ] && ! call_used_regs [ regno ] ) size += HARD_REG_SIZE ;


<s> if ( frame_pointer_needed ) size += HARD_REG_SIZE ; for ( regno = SOFT_REG_FIRST ; regno <= SOFT_REG_LAST ; regno ++ ) if ( regs_ever_live [ regno ] && ! call_used_regs [ regno ] ) size += HARD_REG_SIZE ; return size ;


<s> base = XEXP ( operand , <NUM_LIT> ) ; if ( GET_CODE ( base ) == MEM ) return <NUM_LIT> ; offset = XEXP ( operand , <NUM_LIT> ) ; if ( GET_CODE ( offset ) == MEM ) return <NUM_LIT> ; if ( GET_CODE ( base ) == REG && GET_CODE ( offset ) == REG ) { if ( ! ( addr_mode & ADDR_INDEXED ) ) return <NUM_LIT> ; addr_mode &= ADDR_STRICT ; if ( REGNO_OK_FOR_BASE_P2 ( REGNO ( base ) , addr_mode ) && REGNO_OK_FOR_INDEX_P2 ( REGNO ( offset ) , addr_mode ) ) return <NUM_LIT> ; if ( REGNO_OK_FOR_BASE_P2 ( REGNO ( offset ) , addr_mode ) && REGNO_OK_FOR_INDEX_P2 ( REGNO ( base ) , addr_mode ) ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> base = XEXP ( operand , <NUM_LIT> ) ; if ( GET_CODE ( base ) == MEM ) return <NUM_LIT> ; offset = XEXP ( operand , <NUM_LIT> ) ; if ( GET_CODE ( offset ) == MEM ) return <NUM_LIT> ; if ( GET_CODE ( base ) == REG && GET_CODE ( offset ) == REG ) { if ( ! ( addr_mode & ADDR_INDEXED ) ) return <NUM_LIT> ; addr_mode &= ADDR_STRICT ; if ( REGNO_OK_FOR_BASE_P2 ( REGNO ( base ) , addr_mode ) && REGNO_OK_FOR_INDEX_P2 ( REGNO ( offset ) , addr_mode ) ) return <NUM_LIT> ; if ( REGNO_OK_FOR_BASE_P2 ( REGNO ( offset ) , addr_mode ) && REGNO_OK_FOR_INDEX_P2 ( REGNO ( base ) , addr_mode ) ) return <NUM_LIT> ; return <NUM_LIT> ; } if ( ! ( addr_mode & ADDR_OFFSET ) ) return <NUM_LIT> ; if ( GET_CODE ( base ) == REG ) { if ( ! VALID_CONSTANT_OFFSET_P ( offset , mode ) ) return <NUM_LIT> ;

if ( ! ( addr_mode & ADDR_STRICT ) ) return <NUM_LIT> ;


<s> if ( SP_REG_P ( src ) && Z_REG_P ( dst ) ) emit_insn_after ( gen_addhi3 ( dst , dst , const2_rtx ) , insn ) ; } if ( ! validate_replace_rtx ( z_reg , replace_reg , insn ) ) { INSN_CODE ( insn ) = - <NUM_LIT> ; if ( ! validate_replace_rtx ( z_reg , replace_reg , insn ) ) fatal_insn ( <STR_LIT> , insn ) ; } if ( reg_mentioned_p ( z_reg , insn ) ) { if ( replace_reg_qi == NULL_RTX ) replace_reg_qi = gen_rtx_REG ( QImode , REGNO ( replace_reg ) ) ; validate_replace_rtx ( z_reg_qi , replace_reg_qi , insn ) ; } for ( note = REG_NOTES ( insn ) ; note ; note = XEXP ( note , <NUM_LIT> ) ) { if ( REG_NOTE_KIND ( note ) == REG_INC && GET_CODE ( XEXP ( note , <NUM_LIT> ) ) == REG && REGNO ( XEXP ( note , <NUM_LIT> ) ) == REGNO ( z_reg ) ) { XEXP ( note , <NUM_LIT> ) = replace_reg ; } } } if ( GET_CODE ( insn ) == CALL_INSN || GET_CODE ( insn ) == JUMP_INSN ) break ; } if ( insn && info . need_save_z && ! info . must_push_reg ) { rtx save_pos_insn = insn ; if ( info . save_before_last ) save_pos_insn = PREV_INSN ( save_pos_insn ) ; emit_insn_before ( gen_movhi ( gen_rtx_REG ( HImode , SOFT_Z_REGNUM ) , gen_rtx_REG ( HImode , info . regno ) ) , save_pos_insn ) ; } if ( info . must_push_reg && info . last ) { rtx new_body , body ; body = PATTERN ( info . last ) ; new_body = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , body , gen_rtx_USE ( VOIDmode , replace_reg ) , gen_rtx_USE ( VOIDmode , gen_rtx_REG ( HImode , SOFT_Z_REGNUM ) ) ) ) ; PATTERN ( info . last ) = new_body ; INSN_CODE ( insn ) = - <NUM_LIT> ; if ( ! validate_replace_rtx ( z_reg , replace_reg , info . last ) ) { fatal_insn ( <STR_LIT> , insn ) ; } insn = NEXT_INSN ( info . last ) ; } if ( insn && info . must_restore_reg && ! info . must_push_reg ) { rtx dst ; if ( info . must_push_reg && <NUM_LIT> ) dst = gen_rtx_MEM ( HImode , gen_rtx_POST_INC ( HImode , gen_rtx_REG ( HImode , HARD_SP_REGNUM ) ) ) ;

else dst = gen_rtx_REG ( HImode , SOFT_SAVED_XY_REGNUM ) ;


<s> rtx body = PATTERN ( insn ) ; rtx src = XEXP ( body , <NUM_LIT> ) ; rtx dst = XEXP ( body , <NUM_LIT> ) ; if ( Z_REG_P ( dst ) && ( H_REG_P ( src ) && ! SP_REG_P ( src ) ) ) { XEXP ( body , <NUM_LIT> ) = gen_rtx_REG ( GET_MODE ( dst ) , SOFT_Z_REGNUM ) ; return ; } else if ( Z_REG_P ( src ) && ( ( H_REG_P ( dst ) && ! SP_REG_P ( src ) ) || dst == cc0_rtx ) ) { XEXP ( body , <NUM_LIT> ) = gen_rtx_REG ( GET_MODE ( src ) , SOFT_Z_REGNUM ) ; return ; } else if ( D_REG_P ( dst ) && m68hc11_arith_operator ( src , GET_MODE ( src ) ) && D_REG_P ( XEXP ( src , <NUM_LIT> ) ) && Z_REG_P ( XEXP ( src , <NUM_LIT> ) ) ) { XEXP ( src , <NUM_LIT> ) = gen_rtx_REG ( GET_MODE ( src ) , SOFT_Z_REGNUM ) ; return ; } else if ( Z_REG_P ( dst ) && GET_CODE ( src ) == CONST_INT && INTVAL ( src ) == <NUM_LIT> ) { XEXP ( body , <NUM_LIT> ) = gen_rtx_REG ( GET_MODE ( dst ) , SOFT_Z_REGNUM ) ; INSN_CODE ( insn ) = - <NUM_LIT> ; return ; } } m68hc11_find_z_replacement ( insn , & info ) ; replace_reg = info . replace_reg ; replace_reg_qi = NULL_RTX ; if ( info . must_save_reg && ! info . must_push_reg ) { rtx dst ; if ( info . must_push_reg && <NUM_LIT> ) dst = gen_rtx_MEM ( HImode , gen_rtx_PRE_DEC ( HImode , gen_rtx_REG ( HImode , HARD_SP_REGNUM ) ) ) ; else dst = gen_rtx_REG ( HImode , SOFT_SAVED_XY_REGNUM ) ; emit_insn_before ( gen_movhi ( dst , gen_rtx_REG ( HImode , info . regno ) ) , insn ) ; } if ( info . must_load_z && ! info . must_push_reg ) { emit_insn_before ( gen_movhi ( gen_rtx_REG ( HImode , info . regno ) , gen_rtx_REG ( HImode , SOFT_Z_REGNUM ) ) , insn ) ; } for ( ; insn && insn != info . last ; insn = NEXT_INSN ( insn ) ) { rtx body ; if ( GET_CODE ( insn ) == CODE_LABEL || GET_CODE ( insn ) == BARRIER ) break ; if ( GET_CODE ( insn ) != INSN && GET_CODE ( insn ) != CALL_INSN && GET_CODE ( insn ) != JUMP_INSN ) continue ; body = PATTERN ( insn ) ;

if ( GET_CODE ( body ) == SET || GET_CODE ( body ) == PARALLEL || GET_CODE ( body ) == ASM_OPERANDS || GET_CODE ( insn ) == CALL_INSN || GET_CODE ( insn ) == JUMP_INSN ) {


<s> int memory_indexed_operand ( rtx operand , enum machine_mode mode ATTRIBUTE_UNUSED ) { if ( GET_CODE ( operand ) != MEM ) return <NUM_LIT> ; operand = XEXP ( operand , <NUM_LIT> ) ; if ( GET_CODE ( operand ) == PLUS ) { if ( GET_CODE ( XEXP ( operand , <NUM_LIT> ) ) == REG ) operand = XEXP ( operand , <NUM_LIT> ) ; else if ( GET_CODE ( XEXP ( operand , <NUM_LIT> ) ) == REG ) operand = XEXP ( operand , <NUM_LIT> ) ;


<s> if ( GET_CODE ( XEXP ( operand , <NUM_LIT> ) ) == REG ) operand = XEXP ( operand , <NUM_LIT> ) ; else if ( GET_CODE ( XEXP ( operand , <NUM_LIT> ) ) == REG ) operand = XEXP ( operand , <NUM_LIT> ) ;


<s> int memory_reload_operand ( rtx operand , enum machine_mode mode ATTRIBUTE_UNUSED ) {

return GET_CODE ( operand ) == MEM && GET_CODE ( XEXP ( operand , <NUM_LIT> ) ) == PLUS && ( ( GET_CODE ( XEXP ( XEXP ( operand , <NUM_LIT> ) , <NUM_LIT> ) ) == REG && GET_CODE ( XEXP ( XEXP ( operand , <NUM_LIT> ) , <NUM_LIT> ) ) == CONST_INT ) || ( GET_CODE ( XEXP ( XEXP ( operand , <NUM_LIT> ) , <NUM_LIT> ) ) == REG && GET_CODE ( XEXP ( XEXP ( operand , <NUM_LIT> ) , <NUM_LIT> ) ) == CONST_INT ) ) ;


<s> name = XSTR ( op , <NUM_LIT> ) ; return ( strcasecmp ( name , <STR_LIT> ) == <NUM_LIT> || strcasecmp ( name , <STR_LIT> ) == <NUM_LIT> || strcasecmp ( name , <STR_LIT> ) == <NUM_LIT> || strcasecmp ( name , <STR_LIT> ) == <NUM_LIT> || strcasecmp ( name , <STR_LIT> ) == <NUM_LIT> || strcasecmp ( name , <STR_LIT> ) == <NUM_LIT> || strcasecmp ( name , <STR_LIT> ) == <NUM_LIT> || strcasecmp ( name , <STR_LIT> ) == <NUM_LIT> || strcasecmp ( name , <STR_LIT> ) == <NUM_LIT> || strcasecmp ( name , <STR_LIT> ) == <NUM_LIT> ) ? <NUM_LIT> : <NUM_LIT> ; case PLUS : case MINUS : return must_parenthesize ( XEXP ( op , <NUM_LIT> ) ) || must_parenthesize ( XEXP ( op , <NUM_LIT> ) ) ; case MEM : case CONST : case ZERO_EXTEND :


<s> rtx body ; insn = next_nonnote_insn ( insn ) ; if ( GET_CODE ( insn ) != INSN ) return <NUM_LIT> ; body = PATTERN ( insn ) ; if ( sets_cc0_p ( body ) != <NUM_LIT> ) return <NUM_LIT> ;

if ( rtx_equal_p ( XEXP ( body , <NUM_LIT> ) , reg ) == <NUM_LIT> ) return <NUM_LIT> ;


<s> int next_insn_test_reg ( rtx insn , rtx reg ) { rtx body ; insn = next_nonnote_insn ( insn ) ;

if ( GET_CODE ( insn ) != INSN ) return <NUM_LIT> ;


<s> break ; case POST_DEC : gcc_assert ( TARGET_M6812 ) ; fprintf ( file , <STR_LIT> , GET_MODE_SIZE ( GET_MODE ( op ) ) ) ; asm_print_register ( file , REGNO ( XEXP ( base , <NUM_LIT> ) ) ) ; fprintf ( file , <STR_LIT> ) ; break ; case POST_INC : gcc_assert ( TARGET_M6812 ) ; fprintf ( file , <STR_LIT> , GET_MODE_SIZE ( GET_MODE ( op ) ) ) ; asm_print_register ( file , REGNO ( XEXP ( base , <NUM_LIT> ) ) ) ; fprintf ( file , <STR_LIT> ) ; break ; case PRE_INC : gcc_assert ( TARGET_M6812 ) ; fprintf ( file , <STR_LIT> , GET_MODE_SIZE ( GET_MODE ( op ) ) ) ; asm_print_register ( file , REGNO ( XEXP ( base , <NUM_LIT> ) ) ) ; break ; case MEM : gcc_assert ( TARGET_M6812 ) ; fprintf ( file , <STR_LIT> ) ; print_operand_address ( file , XEXP ( base , <NUM_LIT> ) ) ; fprintf ( file , <STR_LIT> ) ; break ; default : if ( m68hc11_page0_symbol_p ( base ) ) fprintf ( file , <STR_LIT> ) ; output_address ( base ) ; break ; } } else if ( GET_CODE ( op ) == CONST_DOUBLE && GET_MODE ( op ) == SFmode ) { REAL_VALUE_TYPE r ; long l ; REAL_VALUE_FROM_CONST_DOUBLE ( r , op ) ; REAL_VALUE_TO_TARGET_SINGLE ( r , l ) ; asm_fprintf ( file , <STR_LIT> , l ) ; } else if ( GET_CODE ( op ) == CONST_DOUBLE && GET_MODE ( op ) == DFmode ) { char dstr [ <NUM_LIT> ] ; real_to_decimal ( dstr , CONST_DOUBLE_REAL_VALUE ( op ) , sizeof ( dstr ) , <NUM_LIT> , <NUM_LIT> ) ; asm_fprintf ( file , <STR_LIT> , dstr ) ; } else { int need_parenthesize = <NUM_LIT> ; if ( letter != 'i' ) asm_fprintf ( file , <STR_LIT> ) ; else need_parenthesize = must_parenthesize ( op ) ; if ( need_parenthesize ) fprintf ( file , <STR_LIT> ) ; output_addr_const ( file , op ) ; if ( need_parenthesize ) fprintf ( file , <STR_LIT> ) ; }


<s> asm_fprintf ( file , <STR_LIT> ) ; } if ( GET_CODE ( op ) == REG ) { if ( letter == 'b' && S_REG_P ( op ) ) { asm_print_register ( file , REGNO ( op ) ) ; fprintf ( file , <STR_LIT> ) ; } else if ( letter == 'b' && D_REG_P ( op ) ) { asm_print_register ( file , HARD_B_REGNUM ) ; } else { asm_print_register ( file , REGNO ( op ) ) ; } return ; } if ( GET_CODE ( op ) == SYMBOL_REF && ( letter == 'b' || letter == 'h' ) ) { if ( letter == 'b' ) asm_fprintf ( file , <STR_LIT> ) ; else asm_fprintf ( file , <STR_LIT> ) ; output_addr_const ( file , op ) ; fprintf ( file , <STR_LIT> ) ; return ; } if ( GET_MODE ( op ) == HImode || GET_MODE ( op ) == VOIDmode ) { if ( letter == 'b' ) { op = m68hc11_gen_lowpart ( QImode , op ) ; } else if ( letter == 'h' ) { op = m68hc11_gen_highpart ( QImode , op ) ; } } if ( GET_CODE ( op ) == MEM ) { rtx base = XEXP ( op , <NUM_LIT> ) ; switch ( GET_CODE ( base ) ) { case PRE_DEC : gcc_assert ( TARGET_M6812 ) ; fprintf ( file , <STR_LIT> , GET_MODE_SIZE ( GET_MODE ( op ) ) ) ; asm_print_register ( file , REGNO ( XEXP ( base , <NUM_LIT> ) ) ) ; break ; case POST_DEC : gcc_assert ( TARGET_M6812 ) ; fprintf ( file , <STR_LIT> , GET_MODE_SIZE ( GET_MODE ( op ) ) ) ; asm_print_register ( file , REGNO ( XEXP ( base , <NUM_LIT> ) ) ) ; fprintf ( file , <STR_LIT> ) ; break ; case POST_INC : gcc_assert ( TARGET_M6812 ) ; fprintf ( file , <STR_LIT> , GET_MODE_SIZE ( GET_MODE ( op ) ) ) ; asm_print_register ( file , REGNO ( XEXP ( base , <NUM_LIT> ) ) ) ; fprintf ( file , <STR_LIT> ) ; break ; case PRE_INC : gcc_assert ( TARGET_M6812 ) ; fprintf ( file , <STR_LIT> , GET_MODE_SIZE ( GET_MODE ( op ) ) ) ; asm_print_register ( file , REGNO ( XEXP ( base , <NUM_LIT> ) ) ) ; break ; case MEM : gcc_assert ( TARGET_M6812 ) ; fprintf ( file , <STR_LIT> ) ;

print_operand_address ( file , XEXP ( base , <NUM_LIT> ) ) ;


<s> break ; case PLUS : base = XEXP ( addr , <NUM_LIT> ) ; offset = XEXP ( addr , <NUM_LIT> ) ; if ( ! G_REG_P ( base ) && G_REG_P ( offset ) ) { base = XEXP ( addr , <NUM_LIT> ) ; offset = XEXP ( addr , <NUM_LIT> ) ; } if ( CONSTANT_ADDRESS_P ( base ) ) { need_parenthesis = must_parenthesize ( addr ) ; gcc_assert ( CONSTANT_ADDRESS_P ( offset ) ) ; if ( need_parenthesis ) fprintf ( file , <STR_LIT> ) ; output_addr_const ( file , base ) ; fprintf ( file , <STR_LIT> ) ; output_addr_const ( file , offset ) ; if ( need_parenthesis ) fprintf ( file , <STR_LIT> ) ; } else { gcc_assert ( REG_P ( base ) && REG_OK_FOR_BASE_STRICT_P ( base ) ) ; if ( REG_P ( offset ) ) { gcc_assert ( TARGET_M6812 ) ; asm_print_register ( file , REGNO ( offset ) ) ; fprintf ( file , <STR_LIT> ) ; asm_print_register ( file , REGNO ( base ) ) ; } else { need_parenthesis = must_parenthesize ( offset ) ; if ( need_parenthesis ) fprintf ( file , <STR_LIT> ) ; output_addr_const ( file , offset ) ; if ( need_parenthesis ) fprintf ( file , <STR_LIT> ) ; fprintf ( file , <STR_LIT> ) ; asm_print_register ( file , REGNO ( base ) ) ; } } break ; default : if ( GET_CODE ( addr ) == CONST_INT && INTVAL ( addr ) < <NUM_LIT> && INTVAL ( addr ) >= - <NUM_LIT> ) { fprintf ( file , HOST_WIDE_INT_PRINT_DEC , INTVAL ( addr ) ) ;


<s> } operand = XEXP ( operand , <NUM_LIT> ) ; return PUSH_POP_ADDRESS_P ( operand ) ;


<s> int val ; int mask ; * result = <NUM_LIT> ; if ( GET_CODE ( operand ) != CONST_INT ) return operand ; if ( mode == HImode ) mask = <NUM_LIT> ; else mask = <NUM_LIT> ; val = INTVAL ( operand ) ; switch ( code ) { case IOR : if ( ( val & mask ) == <NUM_LIT> ) return <NUM_LIT> ; if ( ( val & mask ) == mask ) * result = constm1_rtx ; break ; case AND : if ( ( val & mask ) == <NUM_LIT> ) * result = const0_rtx ; if ( ( val & mask ) == mask ) return <NUM_LIT> ; break ; case XOR : if ( ( val & mask ) == <NUM_LIT> ) return <NUM_LIT> ;


<s> val = INTVAL ( operand ) ; switch ( code ) { case IOR : if ( ( val & mask ) == <NUM_LIT> ) return <NUM_LIT> ; if ( ( val & mask ) == mask ) * result = constm1_rtx ; break ; case AND : if ( ( val & mask ) == <NUM_LIT> ) * result = const0_rtx ; if ( ( val & mask ) == mask ) return <NUM_LIT> ; break ; case XOR : if ( ( val & mask ) == <NUM_LIT> ) return <NUM_LIT> ;


<s> int symbolic_memory_operand ( rtx op , enum machine_mode mode ) { switch ( GET_CODE ( op ) ) { case SYMBOL_REF : case LABEL_REF : return <NUM_LIT> ; case CONST : op = XEXP ( op , <NUM_LIT> ) ; return ( ( GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == SYMBOL_REF || GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == LABEL_REF ) && GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == CONST_INT ) ; case CONST_DOUBLE : return GET_MODE ( op ) == mode ; case PLUS : return symbolic_memory_operand ( XEXP ( op , <NUM_LIT> ) , mode ) && symbolic_memory_operand ( XEXP ( op , <NUM_LIT> ) , mode ) ; default : return <NUM_LIT> ; }


<s> case CONST_DOUBLE : return GET_MODE ( op ) == mode ; case PLUS : return symbolic_memory_operand ( XEXP ( op , <NUM_LIT> ) , mode ) && symbolic_memory_operand ( XEXP ( op , <NUM_LIT> ) , mode ) ; default : return <NUM_LIT> ;


<s> ix_reg = gen_rtx ( REG , HImode , HARD_X_REGNUM ) ; iy_reg = gen_rtx ( REG , HImode , HARD_Y_REGNUM ) ; d_reg = gen_rtx ( REG , HImode , HARD_D_REGNUM ) ; da_reg = gen_rtx ( REG , QImode , HARD_A_REGNUM ) ; m68hc11_soft_tmp_reg = gen_rtx ( REG , HImode , SOFT_TMP_REGNUM ) ; stack_push_word = gen_rtx ( MEM , HImode , gen_rtx ( PRE_DEC , HImode , gen_rtx ( REG , HImode , HARD_SP_REGNUM ) ) ) ;

stack_pop_word = gen_rtx ( MEM , HImode , gen_rtx ( POST_INC , HImode , gen_rtx ( REG , HImode , HARD_SP_REGNUM ) ) ) ;


<s> void create_regs_rtx ( ) { ix_reg = gen_rtx ( REG , HImode , HARD_X_REGNUM ) ; iy_reg = gen_rtx ( REG , HImode , HARD_Y_REGNUM ) ; d_reg = gen_rtx ( REG , HImode , HARD_D_REGNUM ) ; da_reg = gen_rtx ( REG , QImode , HARD_A_REGNUM ) ;

m68hc11_soft_tmp_reg = gen_rtx ( REG , HImode , SOFT_TMP_REGNUM ) ;


<s> size = get_frame_size ( ) ; if ( current_function_return_rtx == <NUM_LIT> ) return_size = <NUM_LIT> ; else if ( GET_CODE ( current_function_return_rtx ) == MEM ) return_size = HARD_REG_SIZE ; else return_size = GET_MODE_SIZE ( GET_MODE ( current_function_return_rtx ) ) ; if ( return_size > HARD_REG_SIZE ) scratch = iy_reg ; else scratch = ix_reg ; for ( regno = SOFT_REG_LAST ; regno >= SOFT_REG_FIRST ; regno -- ) { if ( regs_ever_live [ regno ] && ! call_used_regs [ regno ] ) { emit_move_after_reload ( gen_rtx ( REG , HImode , regno ) , stack_pop_word , scratch ) ; } } if ( TARGET_M6812 && ( size > <NUM_LIT> || size == <NUM_LIT> ) ) { emit_insn ( gen_addhi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( size ) ) ) ; } else if ( size > <NUM_LIT> ) { rtx insn ; insn = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , gen_rtx_SET ( VOIDmode , stack_pointer_rtx , gen_rtx_PLUS ( HImode , stack_pointer_rtx , GEN_INT ( size ) ) ) , gen_rtx_CLOBBER ( VOIDmode , scratch ) ) ) ; emit_insn ( insn ) ; } else { int i ; for ( i = <NUM_LIT> ; i <= size ; i += <NUM_LIT> ) emit_move_after_reload ( scratch , stack_pop_word , scratch ) ; if ( size & <NUM_LIT> ) emit_insn ( gen_addhi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( <NUM_LIT> ) ) ) ; } if ( frame_pointer_needed ) emit_move_after_reload ( hard_frame_pointer_rtx , stack_pop_word , scratch ) ; if ( current_function_interrupt ) { emit_move_after_reload ( gen_rtx ( REG , HImode , SOFT_SAVED_XY_REGNUM ) , stack_pop_word , scratch ) ; emit_move_after_reload ( gen_rtx ( REG , HImode , SOFT_Z_REGNUM ) , stack_pop_word , scratch ) ; emit_move_after_reload ( m68hc11_soft_tmp_reg , stack_pop_word , scratch ) ; } else if ( current_function_trap && return_size != <NUM_LIT> ) { rtx addr_reg = stack_pointer_rtx ; if ( ! TARGET_M6812 ) {

emit_move_after_reload ( scratch , stack_pointer_rtx , <NUM_LIT> ) ;


<s> int i ; for ( i = <NUM_LIT> ; i <= size ; i += <NUM_LIT> ) emit_move_after_reload ( scratch , stack_pop_word , scratch ) ; if ( size & <NUM_LIT> ) emit_insn ( gen_addhi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( <NUM_LIT> ) ) ) ; } if ( frame_pointer_needed ) emit_move_after_reload ( hard_frame_pointer_rtx , stack_pop_word , scratch ) ; if ( current_function_interrupt ) { emit_move_after_reload ( gen_rtx ( REG , HImode , SOFT_SAVED_XY_REGNUM ) , stack_pop_word , scratch ) ; emit_move_after_reload ( gen_rtx ( REG , HImode , SOFT_Z_REGNUM ) , stack_pop_word , scratch ) ; emit_move_after_reload ( m68hc11_soft_tmp_reg , stack_pop_word , scratch ) ; } else if ( current_function_trap && return_size != <NUM_LIT> ) { rtx addr_reg = stack_pointer_rtx ; if ( ! TARGET_M6812 ) { emit_move_after_reload ( scratch , stack_pointer_rtx , <NUM_LIT> ) ; addr_reg = scratch ; } emit_move_after_reload ( gen_rtx ( MEM , HImode , gen_rtx ( PLUS , HImode , addr_reg , GEN_INT ( <NUM_LIT> ) ) ) , d_reg , <NUM_LIT> ) ; if ( return_size > HARD_REG_SIZE ) emit_move_after_reload ( gen_rtx ( MEM , HImode , gen_rtx ( PLUS , HImode , addr_reg , GEN_INT ( <NUM_LIT> ) ) ) , ix_reg , <NUM_LIT> ) ; }


<s> current_function_trap = lookup_attribute ( <STR_LIT> , func_attr ) != NULL_TREE ; if ( current_function_args_info . nregs == <NUM_LIT> ) scratch = iy_reg ; else scratch = ix_reg ; if ( current_function_interrupt ) { emit_move_after_reload ( stack_push_word , m68hc11_soft_tmp_reg , scratch ) ; emit_move_after_reload ( stack_push_word , gen_rtx ( REG , HImode , SOFT_Z_REGNUM ) , scratch ) ; emit_move_after_reload ( stack_push_word , gen_rtx ( REG , HImode , SOFT_SAVED_XY_REGNUM ) , scratch ) ; } if ( frame_pointer_needed ) emit_move_after_reload ( stack_push_word , hard_frame_pointer_rtx , scratch ) ; if ( TARGET_M6812 && ( size > <NUM_LIT> || size == <NUM_LIT> ) ) { emit_insn ( gen_addhi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - size ) ) ) ; } else if ( size > <NUM_LIT> ) { rtx insn ; insn = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , gen_rtx_SET ( VOIDmode , stack_pointer_rtx , gen_rtx_PLUS ( HImode , stack_pointer_rtx , GEN_INT ( - size ) ) ) , gen_rtx_CLOBBER ( VOIDmode , scratch ) ) ) ; emit_insn ( insn ) ; } else { int i ; for ( i = <NUM_LIT> ; i <= size ; i += <NUM_LIT> ) emit_move_after_reload ( stack_push_word , ix_reg , <NUM_LIT> ) ; if ( size & <NUM_LIT> ) emit_insn ( gen_addhi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( - <NUM_LIT> ) ) ) ; } if ( frame_pointer_needed ) emit_move_after_reload ( hard_frame_pointer_rtx , stack_pointer_rtx , scratch ) ; for ( regno = SOFT_REG_FIRST ; regno <= SOFT_REG_LAST ; regno ++ ) { if ( regs_ever_live [ regno ] && ! call_used_regs [ regno ] ) {

emit_move_after_reload ( stack_push_word , gen_rtx ( REG , HImode , regno ) , scratch ) ;


<s> void m68hc11_conditional_register_usage ( ) { int i ; int cnt = atoi ( m68hc11_soft_reg_count ) ; if ( cnt < <NUM_LIT> ) cnt = <NUM_LIT> ; if ( cnt > SOFT_REG_LAST - SOFT_REG_FIRST ) cnt = SOFT_REG_LAST - SOFT_REG_FIRST ; nb_soft_regs = cnt ;

for ( i = SOFT_REG_FIRST + cnt ; i < SOFT_REG_LAST ; i ++ ) {


<s> fixed_regs [ i ] = <NUM_LIT> ; call_used_regs [ i ] = <NUM_LIT> ; } if ( TARGET_M6812 && flag_omit_frame_pointer && optimize ) { fixed_regs [ HARD_Z_REGNUM ] = <NUM_LIT> ; }


<s> } if ( frame_pointer_needed ) size += HARD_REG_SIZE ; for ( regno = SOFT_REG_FIRST ; regno <= SOFT_REG_LAST ; regno ++ ) if ( regs_ever_live [ regno ] && ! call_used_regs [ regno ] ) size += HARD_REG_SIZE ; return size ;