<s> int h8300_eightbit_data_p ( tree decl ) { tree a ;

if ( TREE_CODE ( decl ) != VAR_DECL ) return <NUM_LIT> ;


<s> static void h8300_emit_stack_adjustment ( int sign , HOST_WIDE_INT size ) { if ( size == <NUM_LIT> ) return ; if ( Pmode == HImode ) { rtx_insn * x = emit_insn ( gen_addhi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( sign * size ) ) ) ; if ( size < <NUM_LIT> ) F ( x , <NUM_LIT> ) ; }

else F ( emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( sign * size ) ) ) , <NUM_LIT> ) ;


<s> int extra_flags = <NUM_LIT> ; default_encode_section_info ( decl , rtl , first ) ; if ( TREE_CODE ( decl ) == FUNCTION_DECL && h8300_funcvec_function_p ( decl ) ) extra_flags = SYMBOL_FLAG_FUNCVEC_FUNCTION ; else if ( TREE_CODE ( decl ) == VAR_DECL && ( TREE_STATIC ( decl ) || DECL_EXTERNAL ( decl ) ) ) { if ( h8300_eightbit_data_p ( decl ) ) extra_flags = SYMBOL_FLAG_EIGHTBIT_DATA ; else if ( first && h8300_tiny_data_p ( decl ) ) extra_flags = SYMBOL_FLAG_TINY_DATA ; }

if ( extra_flags ) SYMBOL_REF_FLAGS ( XEXP ( rtl , <NUM_LIT> ) ) |= extra_flags ;


<s> static void h8300_encode_section_info ( tree decl , rtx rtl , int first ) { int extra_flags = <NUM_LIT> ; default_encode_section_info ( decl , rtl , first ) ;

if ( TREE_CODE ( decl ) == FUNCTION_DECL && h8300_funcvec_function_p ( decl ) ) extra_flags = SYMBOL_FLAG_FUNCVEC_FUNCTION ;


<s> rtx op0 = operands [ <NUM_LIT> ] ; rtx op1 = operands [ <NUM_LIT> ] ; rtx label = operands [ <NUM_LIT> ] ; rtx tmp ; tmp = gen_rtx_COMPARE ( VOIDmode , op0 , op1 ) ; emit_insn ( gen_rtx_SET ( cc0_rtx , tmp ) ) ; tmp = gen_rtx_fmt_ee ( code , VOIDmode , cc0_rtx , const0_rtx ) ;

tmp = gen_rtx_IF_THEN_ELSE ( VOIDmode , tmp , gen_rtx_LABEL_REF ( VOIDmode , label ) , pc_rtx ) ;


<s> if ( saved_regs & ( <NUM_LIT> << regno ) ) { if ( TARGET_H8300S ) { if ( ( TARGET_H8300SX || ( regno & <NUM_LIT> ) == <NUM_LIT> ) && ( ( saved_regs << <NUM_LIT> >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) n_regs = <NUM_LIT> ; else if ( ( TARGET_H8300SX || ( regno & <NUM_LIT> ) == <NUM_LIT> ) && ( ( saved_regs << <NUM_LIT> >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) n_regs = <NUM_LIT> ; else if ( ( TARGET_H8300SX || ( regno & <NUM_LIT> ) == <NUM_LIT> ) && ( ( saved_regs << <NUM_LIT> >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) n_regs = <NUM_LIT> ; } if ( TARGET_H8300SX && ! sibcall_p && ! frame_pointer_needed && frame_size == <NUM_LIT> && ( saved_regs & ( ( <NUM_LIT> << ( regno - n_regs + <NUM_LIT> ) ) - <NUM_LIT> ) ) == <NUM_LIT> ) returned_p = true ; h8300_push_pop ( regno - n_regs + <NUM_LIT> , n_regs , true , returned_p ) ; } } if ( frame_pointer_needed ) {

if ( TARGET_H8300SX && ! sibcall_p ) returned_p = true ;


<s> if ( ! reload_in_progress && ! reload_completed ) { if ( ! register_operand ( dst , GET_MODE ( dst ) ) ) { rtx tmp = gen_reg_rtx ( GET_MODE ( dst ) ) ; emit_move_insn ( tmp , src ) ;


<s> int regno ; int saved_regs ; int n_regs ; if ( h8300_os_task_function_p ( current_function_decl ) ) return ; if ( h8300_monitor_function_p ( current_function_decl ) ) emit_insn ( gen_monitor_prologue ( ) ) ; if ( frame_pointer_needed ) { push ( HARD_FRAME_POINTER_REGNUM ) ; F ( emit_move_insn ( hard_frame_pointer_rtx , stack_pointer_rtx ) , <NUM_LIT> ) ; } saved_regs = compute_saved_regs ( ) ; for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno += n_regs ) { n_regs = <NUM_LIT> ; if ( saved_regs & ( <NUM_LIT> << regno ) ) { if ( TARGET_H8300S ) { if ( ( TARGET_H8300SX || ( regno & <NUM_LIT> ) == <NUM_LIT> ) && ( ( saved_regs >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) n_regs = <NUM_LIT> ; else if ( ( TARGET_H8300SX || ( regno & <NUM_LIT> ) == <NUM_LIT> ) && ( ( saved_regs >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) n_regs = <NUM_LIT> ; else if ( ( TARGET_H8300SX || ( regno & <NUM_LIT> ) == <NUM_LIT> ) && ( ( saved_regs >> regno ) & <NUM_LIT> ) == <NUM_LIT> ) n_regs = <NUM_LIT> ; } h8300_push_pop ( regno , n_regs , false , false ) ; }


<s> rtx dest = operands [ <NUM_LIT> ] ; enum rtx_code code = GET_CODE ( operands [ <NUM_LIT> ] ) ; rtx op0 = operands [ <NUM_LIT> ] ; rtx op1 = operands [ <NUM_LIT> ] ;


<s> rtx op1 = operands [ <NUM_LIT> ] ; rtx tmp ; tmp = gen_rtx_COMPARE ( VOIDmode , op0 , op1 ) ;

emit_insn ( gen_rtx_SET ( cc0_rtx , tmp ) ) ;


<s> static void h8300_file_end ( void ) {


<s> if ( TARGET_H8300SX ) fputs ( TARGET_NORMAL_MODE ? <STR_LIT> : <STR_LIT> , asm_out_file ) ; else if ( TARGET_H8300S ) fputs ( TARGET_NORMAL_MODE ? <STR_LIT> : <STR_LIT> , asm_out_file ) ;

else if ( TARGET_H8300H ) fputs ( TARGET_NORMAL_MODE ? <STR_LIT> : <STR_LIT> , asm_out_file ) ;


<s> default_file_start ( ) ; if ( TARGET_H8300SX ) fputs ( TARGET_NORMAL_MODE ? <STR_LIT> : <STR_LIT> , asm_out_file ) ;

else if ( TARGET_H8300S ) fputs ( TARGET_NORMAL_MODE ? <STR_LIT> : <STR_LIT> , asm_out_file ) ;


<s> int regpass = <NUM_LIT> ; if ( ! arg . named ) return NULL_RTX ; if ( TARGET_QUICKCALL ) regpass = <NUM_LIT> ; if ( cum -> libcall ) { const char * const * p ; fname = XSTR ( cum -> libcall , <NUM_LIT> ) ; for ( p = hand_list ; * p && strcmp ( * p , fname ) != <NUM_LIT> ; p ++ ) ;


<s> static void h8300_function_arg_advance ( cumulative_args_t cum_v , const function_arg_info & arg ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ;

cum -> nbytes += ( ( arg . promoted_size_in_bytes ( ) + UNITS_PER_WORD - <NUM_LIT> ) & - UNITS_PER_WORD ) ;


<s> static bool h8300_function_value_regno_p ( const unsigned int regno ) { return ( regno == R0_REG ) ;


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


<s> a = lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( func ) ) ; return a != NULL_TREE ;


<s> index = XEXP ( x , <NUM_LIT> ) ; * size = ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) >= <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ) ; } else { index = x ; * size = <NUM_LIT> ; } if ( GET_CODE ( index ) == MULT && GET_CODE ( XEXP ( index , <NUM_LIT> ) ) == CONST_INT && ( factor == <NUM_LIT> || factor == INTVAL ( XEXP ( index , <NUM_LIT> ) ) ) ) return XEXP ( index , <NUM_LIT> ) ;


<s> } else { warning ( OPT_Wattributes , <STR_LIT> , name ) ; * no_add_attrs = true ; } return NULL_TREE ;


<s> static tree h8300_handle_eightbit_data_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 ) ) { set_decl_section_name ( decl , <STR_LIT> ) ; } else { warning ( OPT_Wattributes , <STR_LIT> , name ) ; * no_add_attrs = true ; }


<s> warning ( OPT_Wattributes , <STR_LIT> , name ) ; * no_add_attrs = true ; } return NULL_TREE ;


<s> static tree h8300_handle_fndecl_attribute ( tree * node , tree name , tree args ATTRIBUTE_UNUSED , int flags ATTRIBUTE_UNUSED , bool * no_add_attrs ) { if ( TREE_CODE ( * node ) != FUNCTION_DECL ) { warning ( OPT_Wattributes , <STR_LIT> , name ) ;


<s> tree decl = * node ; if ( TREE_STATIC ( decl ) || DECL_EXTERNAL ( decl ) ) { set_decl_section_name ( decl , <STR_LIT> ) ;


<s> static bool h8300_hard_regno_mode_ok ( unsigned int regno , machine_mode mode ) { return regno == MAC_REG ? mode == SImode : <NUM_LIT> ;


<s> int fp_size = frame_pointer_needed * UNITS_PER_WORD ; int saved_regs_size = <NUM_LIT> ; int frame_size = round_frame_size ( get_frame_size ( ) ) ; int regno ; for ( regno = <NUM_LIT> ; regno <= HARD_FRAME_POINTER_REGNUM ; regno ++ ) if ( WORD_REG_USED ( regno ) ) saved_regs_size += UNITS_PER_WORD ; saved_regs_size -= fp_size ; switch ( to ) { case HARD_FRAME_POINTER_REGNUM : switch ( from ) { case ARG_POINTER_REGNUM : return pc_size + fp_size ; case RETURN_ADDRESS_POINTER_REGNUM : return fp_size ; case FRAME_POINTER_REGNUM : return - saved_regs_size ; default : gcc_unreachable ( ) ; } break ; case STACK_POINTER_REGNUM :


<s> case ARG_POINTER_REGNUM : return pc_size + fp_size ; case RETURN_ADDRESS_POINTER_REGNUM : return fp_size ; case FRAME_POINTER_REGNUM : return - saved_regs_size ; default : gcc_unreachable ( ) ; } break ; case STACK_POINTER_REGNUM : switch ( from ) { case ARG_POINTER_REGNUM : return pc_size + saved_regs_size + frame_size ; case RETURN_ADDRESS_POINTER_REGNUM : return saved_regs_size + frame_size ; case FRAME_POINTER_REGNUM : return frame_size ; default : gcc_unreachable ( ) ; }


<s> set_optab_libfunc ( sdiv_optab , HImode , <STR_LIT> ) ; set_optab_libfunc ( udiv_optab , HImode , <STR_LIT> ) ; set_optab_libfunc ( smod_optab , HImode , <STR_LIT> ) ;

set_optab_libfunc ( umod_optab , HImode , <STR_LIT> ) ;


<s> set_optab_libfunc ( udiv_optab , HImode , <STR_LIT> ) ;

set_optab_libfunc ( smod_optab , HImode , <STR_LIT> ) ;


<s> static void h8300_insert_attributes ( tree node , tree * attributes ) { if ( TREE_CODE ( node ) == FUNCTION_DECL ) { if ( pragma_interrupt ) { pragma_interrupt = <NUM_LIT> ; * attributes = tree_cons ( get_identifier ( <STR_LIT> ) , NULL , * attributes ) ; } if ( pragma_saveall ) { pragma_saveall = <NUM_LIT> ; * attributes = tree_cons ( get_identifier ( <STR_LIT> ) , NULL , * attributes ) ; } }


<s> return h8300_move_length ( operands , & movl_length_table ) ; case LENGTH_TABLE_MOVA : return h8300_mova_length ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; case LENGTH_TABLE_MOVA_ZERO : return h8300_mova_length ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , const0_rtx ) ; case LENGTH_TABLE_UNARY : return h8300_unary_length ( operands [ <NUM_LIT> ] ) ; case LENGTH_TABLE_MOV_IMM4 : return <NUM_LIT> + h8300_classify_operand ( operands [ <NUM_LIT> ] , <NUM_LIT> , <NUM_LIT> ) ; case LENGTH_TABLE_SHORT_IMMEDIATE : return h8300_short_immediate_length ( operands [ <NUM_LIT> ] ) ; case LENGTH_TABLE_BITFIELD : return h8300_bitfield_length ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ;


<s> case LENGTH_TABLE_NONE : gcc_unreachable ( ) ; case LENGTH_TABLE_ADD : if ( GET_MODE ( operands [ <NUM_LIT> ] ) == QImode ) return h8300_binary_length ( insn , & addb_length_table ) ; else if ( GET_MODE ( operands [ <NUM_LIT> ] ) == HImode ) return h8300_binary_length ( insn , & addw_length_table ) ; else if ( GET_MODE ( operands [ <NUM_LIT> ] ) == SImode ) return h8300_binary_length ( insn , & addl_length_table ) ; gcc_unreachable ( ) ; case LENGTH_TABLE_LOGICB : return h8300_binary_length ( insn , & logicb_length_table ) ; case LENGTH_TABLE_MOVB : return h8300_move_length ( operands , & movb_length_table ) ; case LENGTH_TABLE_MOVW : return h8300_move_length ( operands , & movw_length_table ) ; case LENGTH_TABLE_MOVL : return h8300_move_length ( operands , & movl_length_table ) ; case LENGTH_TABLE_MOVA : return h8300_mova_length ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; case LENGTH_TABLE_MOVA_ZERO : return h8300_mova_length ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , const0_rtx ) ;


<s> int nregs , i , regno , adjust ; if ( GET_NUM_ELEM ( vec ) < <NUM_LIT> ) return false ; nregs = GET_NUM_ELEM ( vec ) - first - <NUM_LIT> ; regno = h8300_ldm_stm_regno ( RTVEC_ELT ( vec , first ) , load_p , <NUM_LIT> , nregs ) ; if ( regno < <NUM_LIT> || regno + nregs > <NUM_LIT> ) return false ; if ( ! TARGET_H8300SX ) { if ( ( regno & <NUM_LIT> ) != <NUM_LIT> ) return false ; if ( nregs > <NUM_LIT> && ( regno & <NUM_LIT> ) != <NUM_LIT> ) return false ;


<s> if ( ! TARGET_H8300SX ) { if ( ( regno & <NUM_LIT> ) != <NUM_LIT> ) return false ; if ( nregs > <NUM_LIT> && ( regno & <NUM_LIT> ) != <NUM_LIT> ) return false ; } for ( i = <NUM_LIT> ; i < nregs ; i ++ ) if ( h8300_ldm_stm_regno ( RTVEC_ELT ( vec , first + i ) , load_p , i , nregs ) != regno + i ) return false ;

last = RTVEC_ELT ( vec , first + nregs ) ;


<s> if ( load_p ) regindex = <NUM_LIT> , memindex = <NUM_LIT> , offset = ( nregs - index - <NUM_LIT> ) * <NUM_LIT> ; else memindex = <NUM_LIT> , regindex = <NUM_LIT> , offset = ( index + <NUM_LIT> ) * - <NUM_LIT> ;

if ( GET_CODE ( x ) == SET && GET_CODE ( XEXP ( x , regindex ) ) == REG && GET_CODE ( XEXP ( x , memindex ) ) == MEM && h8300_stack_offset_p ( XEXP ( XEXP ( x , memindex ) , <NUM_LIT> ) , offset ) ) return REGNO ( XEXP ( x , regindex ) ) ;


<s> else memindex = <NUM_LIT> , regindex = <NUM_LIT> , offset = ( index + <NUM_LIT> ) * - <NUM_LIT> ;


<s> static bool h8300_legitimate_address_p ( machine_mode mode , rtx x , bool strict ) { if ( h8300_rtx_ok_for_base_p ( x , strict ) ) return <NUM_LIT> ; if ( CONSTANT_ADDRESS_P ( x ) ) return <NUM_LIT> ;

if ( TARGET_H8300SX && ( GET_CODE ( x ) == PRE_INC || GET_CODE ( x ) == PRE_DEC || GET_CODE ( x ) == POST_INC || GET_CODE ( x ) == POST_DEC ) && h8300_rtx_ok_for_base_p ( XEXP ( x , <NUM_LIT> ) , strict ) ) return <NUM_LIT> ;


<s> static unsigned int h8300_length_from_table ( rtx op1 , rtx op2 , const h8300_length_table * table ) { enum h8300_operand_class op1_class , op2_class ; unsigned int size , immediate_length ;

size = GET_MODE_SIZE ( GET_MODE ( op1 ) ) ;


<s> return ( mode1 == mode2 || ( ( mode1 == QImode || mode1 == HImode || mode1 == SImode ) && ( mode2 == QImode || mode2 == HImode || mode2 == SImode ) ) ) ;


<s> if ( GET_CODE ( addr ) == PLUS && h8300_get_index ( XEXP ( addr , <NUM_LIT> ) , VOIDmode , <NUM_LIT> ) != XEXP ( addr , <NUM_LIT> ) ) return true ; return false ;


if ( TREE_CODE ( func ) != FUNCTION_DECL ) return <NUM_LIT> ;


<s> size = ( <NUM_LIT> + h8300_constant_length ( offset ) + h8300_classify_operand ( src , GET_MODE_SIZE ( GET_MODE ( src ) ) , <NUM_LIT> ) ) ; if ( ! REG_P ( dest ) || ! REG_P ( src ) || REGNO ( src ) != REGNO ( dest ) ) size += <NUM_LIT> ;


<s> unsigned int size ; size = h8300_length_from_table ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , table ) ;

if ( REG_P ( operands [ <NUM_LIT> ] ) && h8300_short_move_mem_p ( operands [ <NUM_LIT> ] , POST_INC ) ) size -= <NUM_LIT> ;


<s> if ( MEM_P ( dest ) ) { if ( MEM_P ( src ) || CONSTANT_P ( src ) ) return false ; addr = XEXP ( dest , <NUM_LIT> ) ; other = src ; } else if ( MEM_P ( src ) ) { addr = XEXP ( src , <NUM_LIT> ) ; other = dest ;


<s> static bool h8300_ok_for_sibcall_p ( tree fndecl , tree ) { if ( ! fndecl || h8300_os_task_function_p ( fndecl ) || h8300_monitor_function_p ( fndecl ) || h8300_interrupt_function_p ( fndecl ) || h8300_saveall_function_p ( fndecl ) || h8300_os_task_function_p ( current_function_decl ) || h8300_monitor_function_p ( current_function_decl ) || h8300_interrupt_function_p ( current_function_decl ) || h8300_saveall_function_p ( current_function_decl ) ) return false ;


<s> bool h8300_operands_match_p ( rtx * operands ) { if ( register_operand ( operands [ <NUM_LIT> ] , VOIDmode ) && register_operand ( operands [ <NUM_LIT> ] , VOIDmode ) ) return true ; if ( h8sx_mergeable_memrefs_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) return true ;


<s> if ( TREE_CODE ( func ) != FUNCTION_DECL ) return <NUM_LIT> ;

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


<s> case <NUM_LIT> : h8300_print_operand_address ( file , mode , index ) ; break ; case <NUM_LIT> : h8300_print_operand ( file , index , 'X' ) ; fputs ( <STR_LIT> , file ) ; break ; case <NUM_LIT> : h8300_print_operand ( file , index , 'T' ) ; fputs ( <STR_LIT> , file ) ; break ; case <NUM_LIT> : h8300_print_operand ( file , index , 'S' ) ; fputs ( <STR_LIT> , file ) ; break ; } } else { h8300_print_operand_address ( file , mode , XEXP ( addr , <NUM_LIT> ) ) ; fprintf ( file , <STR_LIT> ) ; h8300_print_operand_address ( file , mode , XEXP ( addr , <NUM_LIT> ) ) ; } fprintf ( file , <STR_LIT> ) ; break ; case CONST_INT : { int n = INTVAL ( addr ) ; fprintf ( file , <STR_LIT> , n ) ; break ; }


<s> break ; case <NUM_LIT> : h8300_print_operand ( file , index , 'X' ) ; fputs ( <STR_LIT> , file ) ; break ; case <NUM_LIT> : h8300_print_operand ( file , index , 'T' ) ; fputs ( <STR_LIT> , file ) ; break ; case <NUM_LIT> : h8300_print_operand ( file , index , 'S' ) ; fputs ( <STR_LIT> , file ) ; break ; } } else { h8300_print_operand_address ( file , mode , XEXP ( addr , <NUM_LIT> ) ) ; fprintf ( file , <STR_LIT> ) ; h8300_print_operand_address ( file , mode , XEXP ( addr , <NUM_LIT> ) ) ; } fprintf ( file , <STR_LIT> ) ; break ; case CONST_INT : { int n = INTVAL ( addr ) ; fprintf ( file , <STR_LIT> , n ) ; break ; } default :


<s> static bool h8300_print_operand_punct_valid_p ( unsigned char code ) {


<s> void h8300_pr_saveall ( struct cpp_reader * pfile ATTRIBUTE_UNUSED ) {


<s> void h8300_pr_saveall ( struct cpp_reader * pfile ATTRIBUTE_UNUSED ) { pragma_saveall = <NUM_LIT> ;


<s> vec = rtvec_alloc ( ( return_p ? <NUM_LIT> : <NUM_LIT> ) + nregs + <NUM_LIT> ) ; sp = stack_pointer_rtx ; i = <NUM_LIT> ; if ( return_p ) { RTVEC_ELT ( vec , i ) = ret_rtx ; i ++ ; } for ( j = <NUM_LIT> ; j < nregs ; j ++ ) { rtx lhs , rhs ; if ( pop_p ) { lhs = gen_rtx_REG ( SImode , regno + j ) ; rhs = gen_rtx_MEM ( SImode , plus_constant ( Pmode , sp , ( nregs - j - <NUM_LIT> ) * <NUM_LIT> ) ) ; } else { lhs = gen_rtx_MEM ( SImode , plus_constant ( Pmode , sp , ( j + <NUM_LIT> ) * - <NUM_LIT> ) ) ; rhs = gen_rtx_REG ( SImode , regno + j ) ; } RTVEC_ELT ( vec , i + j ) = gen_rtx_SET ( lhs , rhs ) ; } offset = GEN_INT ( ( pop_p ? nregs : - nregs ) * <NUM_LIT> ) ; RTVEC_ELT ( vec , i + j ) = gen_rtx_SET ( sp , gen_rtx_PLUS ( Pmode , sp , offset ) ) ;

x = gen_rtx_PARALLEL ( VOIDmode , vec ) ;


<s> int i , j ; rtvec vec ; rtx sp , offset , x ; if ( ! return_p && nregs == <NUM_LIT> ) { if ( pop_p ) pop ( regno ) ; else push ( regno ) ; return ; } vec = rtvec_alloc ( ( return_p ? <NUM_LIT> : <NUM_LIT> ) + nregs + <NUM_LIT> ) ; sp = stack_pointer_rtx ; i = <NUM_LIT> ; if ( return_p ) { RTVEC_ELT ( vec , i ) = ret_rtx ; i ++ ; } for ( j = <NUM_LIT> ; j < nregs ; j ++ ) { rtx lhs , rhs ; if ( pop_p ) { lhs = gen_rtx_REG ( SImode , regno + j ) ; rhs = gen_rtx_MEM ( SImode , plus_constant ( Pmode , sp , ( nregs - j - <NUM_LIT> ) * <NUM_LIT> ) ) ; } else { lhs = gen_rtx_MEM ( SImode , plus_constant ( Pmode , sp , ( j + <NUM_LIT> ) * - <NUM_LIT> ) ) ; rhs = gen_rtx_REG ( SImode , regno + j ) ;


<s> return ( ( bytes + PARM_BOUNDARY / <NUM_LIT> - <NUM_LIT> ) & ( - PARM_BOUNDARY / <NUM_LIT> ) ) ;


return ( ( bytes + PARM_BOUNDARY / <NUM_LIT> - <NUM_LIT> ) & ( - PARM_BOUNDARY / <NUM_LIT> ) ) ;


<s> if ( flag_delayed_branch ) shorten_branches ( get_insns ( ) ) ;


<s> if ( count == <NUM_LIT> ) ret = gen_rtx_MEM ( Pmode , gen_rtx_REG ( Pmode , RETURN_ADDRESS_POINTER_REGNUM ) ) ; else if ( flag_omit_frame_pointer ) return ( rtx ) <NUM_LIT> ; else ret = gen_rtx_MEM ( Pmode , memory_address ( Pmode , plus_constant ( Pmode , frame , UNITS_PER_WORD ) ) ) ;

set_mem_alias_set ( ret , get_frame_alias_set ( ) ) ;


<s> return ( TYPE_MODE ( type ) == BLKmode || GET_MODE_SIZE ( TYPE_MODE ( type ) ) > <NUM_LIT> ) ;


<s> case EQ : case GE : case GT : case LE : case LT : case GEU : case GTU : case LEU : case LTU : if ( XEXP ( x , <NUM_LIT> ) == const0_rtx ) * total = <NUM_LIT> ; return false ; case AND : if ( ! h8300_dst_operand ( XEXP ( x , <NUM_LIT> ) , VOIDmode ) || ! h8300_src_operand ( XEXP ( x , <NUM_LIT> ) , VOIDmode ) ) return false ; * total = COSTS_N_INSNS ( h8300_and_costs ( x ) ) ; return true ; case MOD : case DIV : case UMOD : case UDIV : if ( TARGET_H8300SX ) switch ( GET_MODE ( x ) ) { case E_QImode : case E_HImode : * total = COSTS_N_INSNS ( ! speed ? <NUM_LIT> : <NUM_LIT> ) ; return false ; case E_SImode : * total = COSTS_N_INSNS ( ! speed ? <NUM_LIT> : <NUM_LIT> ) ; return false ; default : break ; } * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case MULT : if ( TARGET_H8300SX ) switch ( GET_MODE ( x ) ) { case E_QImode : case E_HImode : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return false ; case E_SImode : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return false ; default : break ; } * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ;


<s> static int h8300_rtx_ok_for_base_p ( rtx x , int strict ) { if ( GET_CODE ( x ) == SUBREG ) x = SUBREG_REG ( x ) ; return ( REG_P ( x ) && ( strict ? REG_OK_FOR_BASE_STRICT_P ( x ) : REG_OK_FOR_BASE_NONSTRICT_P ( x ) ) ) ;


<s> return ( REG_P ( x ) && ( strict ? REG_OK_FOR_BASE_STRICT_P ( x ) : REG_OK_FOR_BASE_NONSTRICT_P ( x ) ) ) ;


<s> tree a ; if ( TREE_CODE ( func ) != FUNCTION_DECL ) return <NUM_LIT> ;


<s> machine_mode h8300_select_cc_mode ( enum rtx_code cond , rtx op0 , rtx op1 ) { if ( op1 == const0_rtx && ( cond == EQ || cond == NE || cond == LT || cond == GE ) && ( GET_CODE ( op0 ) == PLUS || GET_CODE ( op0 ) == MINUS || GET_CODE ( op0 ) == NEG || GET_CODE ( op0 ) == AND || GET_CODE ( op0 ) == IOR || GET_CODE ( op0 ) == XOR || GET_CODE ( op0 ) == NOT || GET_CODE ( op0 ) == ASHIFT || GET_CODE ( op0 ) == ASHIFTRT || GET_CODE ( op0 ) == LSHIFTRT || GET_CODE ( op0 ) == MULT || GET_CODE ( op0 ) == SYMBOL_REF || GET_CODE ( op0 ) == SIGN_EXTEND || GET_CODE ( op0 ) == ZERO_EXTEND || REG_P ( op0 ) || MEM_P ( op0 ) ) ) return CCZNmode ;


<s> operands [ <NUM_LIT> ] = NULL ; operands [ <NUM_LIT> ] = XEXP ( x , <NUM_LIT> ) ; return compute_a_shift_length ( operands , GET_CODE ( x ) ) / <NUM_LIT> ;


<s> if ( GET_MODE ( x ) != QImode && GET_MODE ( x ) != HImode && GET_MODE ( x ) != SImode ) return <NUM_LIT> ; operands [ <NUM_LIT> ] = gen_rtx_REG ( GET_MODE ( x ) , <NUM_LIT> ) ; operands [ <NUM_LIT> ] = NULL ; operands [ <NUM_LIT> ] = XEXP ( x , <NUM_LIT> ) ;

return compute_a_shift_length ( operands , GET_CODE ( x ) ) / <NUM_LIT> ;


<s> if ( TARGET_H8300S ) cpu = H8_S ; else cpu = H8_300H ; switch ( mode ) { case E_QImode : a = shift_alg_qi [ cpu ] [ SHIFT_ASHIFT ] [ count ] ; lr = shift_alg_qi [ cpu ] [ SHIFT_LSHIFTRT ] [ count ] ; ar = shift_alg_qi [ cpu ] [ SHIFT_ASHIFTRT ] [ count ] ; break ; case E_HImode : a = shift_alg_hi [ cpu ] [ SHIFT_ASHIFT ] [ count ] ; lr = shift_alg_hi [ cpu ] [ SHIFT_LSHIFTRT ] [ count ] ; ar = shift_alg_hi [ cpu ] [ SHIFT_ASHIFTRT ] [ count ] ; break ; case E_SImode : a = shift_alg_si [ cpu ] [ SHIFT_ASHIFT ] [ count ] ; lr = shift_alg_si [ cpu ] [ SHIFT_LSHIFTRT ] [ count ] ; ar = shift_alg_si [ cpu ] [ SHIFT_ASHIFTRT ] [ count ] ;


<s> ar = shift_alg_si [ cpu ] [ SHIFT_ASHIFTRT ] [ count ] ; break ; default : gcc_unreachable ( ) ; } if ( type == CLOBBER ) return ( a == SHIFT_LOOP || lr == SHIFT_LOOP || ar == SHIFT_LOOP || ( TARGET_H8300H && mode == SImode && count == <NUM_LIT> ) ) ; else if ( type == ASHIFT ) return ( a == SHIFT_LOOP || ( TARGET_H8300H && mode == SImode && count == <NUM_LIT> ) ) ; else if ( type == LSHIFTRT ) return ( lr == SHIFT_LOOP || ( TARGET_H8300H && mode == SImode && count == <NUM_LIT> ) ) ;

else if ( type == ASHIFTRT ) return ( ar == SHIFT_LOOP || ( TARGET_H8300H && mode == SImode && count == <NUM_LIT> ) ) ;


<s> unsigned int size , operand_length ; size = GET_MODE_SIZE ( GET_MODE ( op ) ) ; operand_length = h8300_classify_operand ( op , size , & opclass ) ; switch ( opclass ) { case H8OP_REGISTER : return <NUM_LIT> ; case H8OP_MEM_BASE : case H8OP_MEM_ABSOLUTE :


<s> unsigned int size ; if ( GET_CODE ( op ) != MEM ) return false ; addr = XEXP ( op , <NUM_LIT> ) ;

size = GET_MODE_SIZE ( GET_MODE ( op ) ) ;


<s> size = GET_MODE_SIZE ( GET_MODE ( op ) ) ; if ( size != <NUM_LIT> && size != <NUM_LIT> ) return false ;

return ( GET_CODE ( addr ) == inc_code || ( GET_CODE ( addr ) == PLUS && GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == REG && h8300_displacement_length ( addr , size ) == <NUM_LIT> ) ) ;


<s> static int h8300_stack_offset_p ( rtx x , int offset ) {

if ( offset == <NUM_LIT> ) return x == stack_pointer_rtx ;


<s> addr = INTVAL ( x ) ; return ( TARGET_NORMAL_MODE || ( TARGET_H8300H && ( IN_RANGE ( addr , h1 , h2 ) || IN_RANGE ( addr , h3 , h4 ) ) ) || ( TARGET_H8300S && ( IN_RANGE ( addr , s1 , s2 ) || IN_RANGE ( addr , s3 , s4 ) ) ) ) ; case CONST : return TARGET_NORMAL_MODE ;


<s> a = lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ;


<s> static void h8300_trampoline_init ( rtx m_tramp , tree fndecl , rtx cxt ) { rtx fnaddr = XEXP ( DECL_RTL ( fndecl ) , <NUM_LIT> ) ; rtx mem ; if ( Pmode == HImode ) { mem = adjust_address ( m_tramp , HImode , <NUM_LIT> ) ; emit_move_insn ( mem , GEN_INT ( <NUM_LIT> ) ) ; mem = adjust_address ( m_tramp , Pmode , <NUM_LIT> ) ; emit_move_insn ( mem , cxt ) ; mem = adjust_address ( m_tramp , HImode , <NUM_LIT> ) ;


<s> mem = adjust_address ( m_tramp , HImode , <NUM_LIT> ) ; emit_move_insn ( mem , GEN_INT ( <NUM_LIT> ) ) ; mem = adjust_address ( m_tramp , Pmode , <NUM_LIT> ) ; emit_move_insn ( mem , cxt ) ; mem = adjust_address ( m_tramp , HImode , <NUM_LIT> ) ; emit_move_insn ( mem , GEN_INT ( <NUM_LIT> ) ) ; mem = adjust_address ( m_tramp , Pmode , <NUM_LIT> ) ; emit_move_insn ( mem , fnaddr ) ; } else { rtx tem ; mem = adjust_address ( m_tramp , HImode , <NUM_LIT> ) ; emit_move_insn ( mem , GEN_INT ( <NUM_LIT> ) ) ; mem = adjust_address ( m_tramp , Pmode , <NUM_LIT> ) ; emit_move_insn ( mem , cxt ) ; tem = copy_to_reg ( fnaddr ) ; emit_insn ( gen_andsi3 ( tem , tem , GEN_INT ( <NUM_LIT> ) ) ) ;

emit_insn ( gen_iorsi3 ( tem , tem , GEN_INT ( <NUM_LIT> ) ) ) ;


<s> case H8OP_REGISTER : return <NUM_LIT> ; case H8OP_MEM_BASE : return ( size == <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ) ; case H8OP_MEM_ABSOLUTE : return operand_length + ( size == <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ) ; case H8OP_MEM_COMPLEX : return operand_length + <NUM_LIT> ; default : gcc_unreachable ( ) ; }


<s> if ( GET_CODE ( op ) != CONST_INT ) return H8SX_SHIFT_BINARY ; if ( INTVAL ( op ) <= <NUM_LIT> || INTVAL ( op ) >= GET_MODE_BITSIZE ( mode ) ) return H8SX_SHIFT_NONE ; if ( exact_log2 ( INTVAL ( op ) ) >= <NUM_LIT> ) return H8SX_SHIFT_UNARY ; return H8SX_SHIFT_BINARY ; case ASHIFTRT : if ( op == const1_rtx || op == const2_rtx ) return H8SX_SHIFT_UNARY ; return H8SX_SHIFT_NONE ;


<s> if ( op == const1_rtx || op == const2_rtx ) return H8SX_SHIFT_UNARY ; return H8SX_SHIFT_NONE ; case ROTATE :

if ( GET_CODE ( op ) == CONST_INT && ( INTVAL ( op ) == <NUM_LIT> || INTVAL ( op ) == <NUM_LIT> || INTVAL ( op ) == GET_MODE_BITSIZE ( mode ) - <NUM_LIT> || INTVAL ( op ) == GET_MODE_BITSIZE ( mode ) - <NUM_LIT> ) ) return H8SX_SHIFT_UNARY ;


<s> bool h8sx_mergeable_memrefs_p ( rtx lhs , rtx rhs ) { if ( GET_CODE ( rhs ) == MEM && GET_CODE ( lhs ) == MEM ) { rhs = XEXP ( rhs , <NUM_LIT> ) ; lhs = XEXP ( lhs , <NUM_LIT> ) ; if ( GET_CODE ( rhs ) == PRE_INC || GET_CODE ( rhs ) == PRE_DEC ) return rtx_equal_p ( XEXP ( rhs , <NUM_LIT> ) , lhs ) ; if ( GET_CODE ( lhs ) == POST_INC || GET_CODE ( lhs ) == POST_DEC ) return rtx_equal_p ( rhs , XEXP ( lhs , <NUM_LIT> ) ) ;

if ( rtx_equal_p ( rhs , lhs ) ) return true ;


<s> if ( SET_DEST ( set ) != cc0_rtx ) { if ( GET_CODE ( SET_DEST ( set ) ) == STRICT_LOW_PART ) cc_status . value2 = XEXP ( SET_DEST ( set ) , <NUM_LIT> ) ; else cc_status . value2 = SET_DEST ( set ) ; } break ; case CC_COMPARE : CC_STATUS_INIT ; cc_status . value1 = SET_SRC ( body ) ; break ; case CC_CLOBBER : CC_STATUS_INIT ;


<s> switch ( mode ) { case E_QImode : rotate_mode = QIshift ; break ; case E_HImode : rotate_mode = HIshift ; break ; case E_SImode : rotate_mode = SIshift ; break ; default : gcc_unreachable ( ) ; } switch ( code ) { case ROTATERT : rotate_type = SHIFT_ASHIFT ; break ; case ROTATE : rotate_type = SHIFT_LSHIFTRT ; break ; default : gcc_unreachable ( ) ; } amount = INTVAL ( rotate_amount ) ; if ( amount < <NUM_LIT> ) amount = <NUM_LIT> ; if ( ( unsigned int ) amount > GET_MODE_BITSIZE ( mode ) ) amount = GET_MODE_BITSIZE ( mode ) ; if ( ( unsigned int ) amount > GET_MODE_BITSIZE ( mode ) / ( unsigned ) <NUM_LIT> ) { amount = GET_MODE_BITSIZE ( mode ) - amount ;


<s> if ( INTVAL ( operands [ <NUM_LIT> ] ) > <NUM_LIT> ) { operands [ <NUM_LIT> ] = GEN_INT ( GET_MODE_BITSIZE ( GET_MODE ( operands [ <NUM_LIT> ] ) ) - INTVAL ( operands [ <NUM_LIT> ] ) ) ; stem = <STR_LIT> ; } break ; default : gcc_unreachable ( ) ; } if ( operands [ <NUM_LIT> ] == const1_rtx ) sprintf ( buffer , <STR_LIT> , stem , suffix , optype ) ; else sprintf ( buffer , <STR_LIT> , stem , suffix , optype ) ;


<s> break ; case E_HImode : if ( cc_meaningful || ( b0 != <NUM_LIT> && b1 != <NUM_LIT> ) ) { sprintf ( insn_buf , <STR_LIT> , opname ) ; output_asm_insn ( insn_buf , operands ) ; } else { if ( b0 != <NUM_LIT> ) { sprintf ( insn_buf , <STR_LIT> , opname ) ; output_asm_insn ( insn_buf , operands ) ; } if ( b1 != <NUM_LIT> ) { sprintf ( insn_buf , <STR_LIT> , opname ) ; output_asm_insn ( insn_buf , operands ) ; } } break ; case E_SImode : lower_half_easy_p = ( b0 == <NUM_LIT> || b1 == <NUM_LIT> || ( code != IOR && w0 == <NUM_LIT> ) ) ; upper_half_easy_p = ( ( code != IOR && w1 == <NUM_LIT> ) || ( code == AND && w1 == <NUM_LIT> ) ) ; if ( cc_meaningful || ( w0 != <NUM_LIT> && w1 != <NUM_LIT> && ! ( lower_half_easy_p && upper_half_easy_p ) && ! ( code == IOR && w1 == <NUM_LIT> && ( w0 & <NUM_LIT> ) != <NUM_LIT> && lower_half_easy_p ) ) ) { sprintf ( insn_buf , <STR_LIT> , opname ) ; output_asm_insn ( insn_buf , operands ) ; } else { if ( w0 == <NUM_LIT> && ( code != IOR ) ) output_asm_insn ( ( code == AND ) ? <STR_LIT> : <STR_LIT> , operands ) ; else if ( ( b0 != <NUM_LIT> ) && ( b1 != <NUM_LIT> ) ) { sprintf ( insn_buf , <STR_LIT> , opname ) ; output_asm_insn ( insn_buf , operands ) ; } else { if ( b0 != <NUM_LIT> ) { sprintf ( insn_buf , <STR_LIT> , opname ) ; output_asm_insn ( insn_buf , operands ) ; } if ( b1 != <NUM_LIT> ) { sprintf ( insn_buf , <STR_LIT> , opname ) ; output_asm_insn ( insn_buf , operands ) ; } } if ( ( w1 == <NUM_LIT> ) && ( code != IOR ) ) output_asm_insn ( ( code == AND ) ? <STR_LIT> : <STR_LIT> , operands ) ; else if ( code == IOR && w1 == <NUM_LIT> && ( w0 & <NUM_LIT> ) != <NUM_LIT> ) { output_asm_insn ( <STR_LIT> , operands ) ; } else if ( code == AND && w1 == <NUM_LIT> ) { output_asm_insn ( <STR_LIT> , operands ) ; } else { if ( w1 != <NUM_LIT> ) { sprintf ( insn_buf , <STR_LIT> , opname ) ; output_asm_insn ( insn_buf , operands ) ; } } } break ; default :


<s> else return <STR_LIT> ; case <NUM_LIT> : if ( need_flags ) return <STR_LIT> ; else return <STR_LIT> ; case <NUM_LIT> : if ( need_flags ) return <STR_LIT> ; else return <STR_LIT> ; case <NUM_LIT> : if ( ! need_flags ) return <STR_LIT> ; case <NUM_LIT> : if ( ! need_flags ) return <STR_LIT> ; case <NUM_LIT> : case <NUM_LIT> : if ( ! need_flags ) { operands [ <NUM_LIT> ] = GEN_INT ( intval >> <NUM_LIT> ) ; return <STR_LIT> ; } case <NUM_LIT> : case <NUM_LIT> : if ( ! need_flags ) { operands [ <NUM_LIT> ] = GEN_INT ( intval >> <NUM_LIT> ) ;


<s> const char * output_simode_bld ( int bild , rtx operands [ ] ) { int clear_first = ( REG_P ( operands [ <NUM_LIT> ] ) && REG_P ( operands [ <NUM_LIT> ] ) && REGNO ( operands [ <NUM_LIT> ] ) != REGNO ( operands [ <NUM_LIT> ] ) ) ; if ( clear_first ) output_asm_insn ( <STR_LIT> , operands ) ; if ( bild ) output_asm_insn ( <STR_LIT> , operands ) ;

else output_asm_insn ( <STR_LIT> , operands ) ;


<s> if ( bild ) output_asm_insn ( <STR_LIT> , operands ) ; else output_asm_insn ( <STR_LIT> , operands ) ; if ( ! clear_first ) output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; return <STR_LIT> ;


<s> if ( ! TARGET_NORMAL_MODE ) x = gen_pop_h8300hs_advanced ( reg ) ; else x = gen_pop_h8300hs_normal ( reg ) ; x = emit_insn ( x ) ; add_reg_note ( x , REG_INC , stack_pointer_rtx ) ; return x ;


<s> if ( ! TARGET_NORMAL_MODE ) x = gen_pop_h8300hs_advanced ( reg ) ; else x = gen_pop_h8300hs_normal ( reg ) ; x = emit_insn ( x ) ; add_reg_note ( x , REG_INC , stack_pointer_rtx ) ;


<s> rtx x ; if ( ! TARGET_NORMAL_MODE ) x = gen_push_h8300hs_advanced ( reg ) ; else x = gen_push_h8300hs_normal ( reg ) ; x = F ( emit_insn ( x ) , <NUM_LIT> ) ;

add_reg_note ( x , REG_INC , stack_pointer_rtx ) ;


<s> return ( ( size + STACK_BOUNDARY / BITS_PER_UNIT - <NUM_LIT> ) & - STACK_BOUNDARY / BITS_PER_UNIT ) ;


<s> static HOST_WIDE_INT round_frame_size ( HOST_WIDE_INT size ) {

return ( ( size + STACK_BOUNDARY / BITS_PER_UNIT - <NUM_LIT> ) & - STACK_BOUNDARY / BITS_PER_UNIT ) ;


<s> if ( i2 == NULL ) return <NUM_LIT> ; i3 = next_nonnote_insn ( i2 ) ; if ( i3 == NULL ) return <NUM_LIT> ;

return ( INSN_P ( i3 ) && rtx_equal_p ( PATTERN ( i1 ) , PATTERN ( i3 ) ) && any_condjump_p ( i2 ) && onlyjump_p ( i2 ) ) ;


<s> return ( INSN_P ( i1 ) && rtx_equal_p ( PATTERN ( i1 ) , PATTERN ( i3 ) ) && any_condjump_p ( i2 ) && onlyjump_p ( i2 ) ) ;


<s> rtx reg = operands [ <NUM_LIT> ] ; HOST_WIDE_INT sign = <NUM_LIT> ; HOST_WIDE_INT amount ; rtx ( * gen_add ) ( rtx , rtx , rtx ) ; if ( val < <NUM_LIT> ) { val = - val ; sign = - <NUM_LIT> ; } switch ( mode ) { case E_HImode : gen_add = gen_addhi3 ; break ; case E_SImode :


<s> } switch ( mode ) { case E_HImode : gen_add = gen_addhi3 ; break ; case E_SImode : gen_add = gen_addsi3 ; break ; default : gcc_unreachable ( ) ; } for ( amount = <NUM_LIT> ; amount > <NUM_LIT> ; amount /= <NUM_LIT> ) { for ( ; val >= amount ; val -= amount ) emit_insn ( gen_add ( reg , reg , GEN_INT ( sign * amount ) ) ) ; } return ;


<s> int __parityhi2 ( unsigned short x ) { int i ;


<s> int i ; int count = <NUM_LIT> ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( x & ( ( unsigned short ) <NUM_LIT> << i ) ) count ++ ;