<s> void __cmovd ( long long * dest , const long long * src , unsigned len ) { unsigned i ; unsigned num = len >> <NUM_LIT> ; unsigned xlen = len & ~ <NUM_LIT> ; char * dest_byte = ( char * ) dest ; const char * src_byte = ( const char * ) src ; if ( dest_byte < src_byte || dest_byte > src_byte + len ) {

for ( i = <NUM_LIT> ; i < num ; i ++ ) dest [ i ] = src [ i ] ;


<s> char * dest_byte = ( char * ) dest ; const char * src_byte = ( const char * ) src ; if ( dest_byte < src_byte || dest_byte > src_byte + len ) { for ( i = <NUM_LIT> ; i < num ; i ++ ) dest [ i ] = src [ i ] ; if ( ( len & <NUM_LIT> ) != <NUM_LIT> ) dest_byte [ len - <NUM_LIT> ] = src_byte [ len - <NUM_LIT> ] ; } else {

while ( len -- > <NUM_LIT> ) dest_byte [ len ] = src_byte [ len ] ;


<s> for ( i = <NUM_LIT> ; i < num ; i ++ ) dest [ i ] = src [ i ] ; while ( len > xlen ) { dest_byte [ xlen ] = src_byte [ xlen ] ; xlen ++ ; }


<s> static void frv_setup_incoming_varargs ( cumulative_args_t cum_v , const function_arg_info & arg , int * pretend_size , int second_time ) { CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; if ( ! TYPE_NO_NAMED_ARGS_STDARG_P ( TREE_TYPE ( current_function_decl ) ) && TARGET_DEBUG_ARG ) fprintf ( stderr , <STR_LIT> , * cum , GET_MODE_NAME ( arg . mode ) , * pretend_size , second_time ) ;


<s> case LE : return <STR_LIT> ; case GT : return <STR_LIT> ; case GE : return is_nz_p ? <STR_LIT> : <STR_LIT> ; case LTU : return is_nz_p ? <STR_LIT> : <STR_LIT> ;

case LEU : return is_nz_p ? <STR_LIT> : <STR_LIT> ;


<s> if ( mode != VOIDmode && op_mode != mode ) return FALSE ; switch ( op_mode ) { default : return FALSE ; case QImode : case HImode : case SImode : case SFmode : break ; }

if ( GET_CODE ( op ) != MEM ) return FALSE ;


<s> case SImode : case SFmode : break ; } if ( GET_CODE ( op ) != MEM ) return FALSE ;


<s> if ( frv_cpu_type != FRV_CPU_FR550 ) return ACC_GROUP_NONE ; return for_each_rtx ( & PATTERN ( insn ) , frv_acc_group_1 , <NUM_LIT> ) ;


<s> if ( ACC_P ( REGNO ( * x ) ) ) return ( REGNO ( * x ) - ACC_FIRST ) & <NUM_LIT> ? ACC_GROUP_ODD : ACC_GROUP_EVEN ; if ( ACCG_P ( REGNO ( * x ) ) ) return ( REGNO ( * x ) - ACCG_FIRST ) & <NUM_LIT> ? ACC_GROUP_ODD : ACC_GROUP_EVEN ;


<s> struct frv_packet_group * packet_group ; packet_group = & frv_packet . groups [ frv_unit_groups [ frv_insn_unit ( insn ) ] ] ;

packet_group -> insns [ packet_group -> num_insns ++ ] = insn ;


<s> label = x ; } if ( BARRIER_P ( x ) ) barrier = x ; } if ( TARGET_ALIGN_LABELS && label != <NUM_LIT> && barrier == <NUM_LIT> && frv_packet . num_insns < frv_packet . issue_rate ) alignment = MAX ( alignment , <NUM_LIT> ) ; frv_packet_address += frv_packet . num_insns * <NUM_LIT> ; target = ( frv_packet_address + alignment - <NUM_LIT> ) & - alignment ; if ( barrier == <NUM_LIT> ) {

for ( nop = <NUM_LIT> ; nop < frv_num_nops ; nop ++ ) while ( frv_packet_address < target && frv_pack_insn_p ( frv_nops [ nop ] ) ) {


<s> int arg_num = * cum ; int ret ; ret = ( ( arg_num <= LAST_ARG_REGNUM && arg_num + words > LAST_ARG_REGNUM + <NUM_LIT> ) ? LAST_ARG_REGNUM - arg_num + <NUM_LIT> : <NUM_LIT> ) ; ret *= UNITS_PER_WORD ; if ( TARGET_DEBUG_ARG && ret ) fprintf ( stderr , <STR_LIT> , ret ) ;


<s> assemble_align ( POINTER_SIZE ) ; if ( TARGET_FDPIC ) { int ok = frv_assemble_integer ( symbol , POINTER_SIZE / BITS_PER_UNIT , <NUM_LIT> ) ; gcc_assert ( ok ) ;


<s> static void frv_asm_out_constructor ( rtx symbol , int priority ATTRIBUTE_UNUSED ) { ctors_section ( ) ; assemble_align ( POINTER_SIZE ) ; if ( TARGET_FDPIC ) { int ok = frv_assemble_integer ( symbol , POINTER_SIZE / BITS_PER_UNIT , <NUM_LIT> ) ; gcc_assert ( ok ) ; return ;


<s> int ok = frv_assemble_integer ( symbol , POINTER_SIZE / BITS_PER_UNIT , <NUM_LIT> ) ; gcc_assert ( ok ) ; return ;


<s> static bool frv_cannot_force_const_mem ( rtx x ATTRIBUTE_UNUSED ) {


<s> if ( class == ACCG_REGS ) return GET_MODE_SIZE ( mode ) ; else return ( GET_MODE_SIZE ( mode ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ;


<s> int frv_class_max_nregs ( enum reg_class class , enum machine_mode mode ) { if ( class == ACCG_REGS ) return GET_MODE_SIZE ( mode ) ; else return ( GET_MODE_SIZE ( mode ) + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ;


<s> if ( GET_CODE ( * ptr ) == REG ) { int regno = REGNO ( * ptr ) ; HARD_REG_SET * p_regs = ( HARD_REG_SET * ) data ; if ( regno < FIRST_PSEUDO_REGISTER ) { int reg_max = regno + HARD_REGNO_NREGS ( regno , GET_MODE ( * ptr ) ) ; while ( regno < reg_max ) { CLEAR_HARD_REG_BIT ( * p_regs , regno ) ;


<s> const rtx * insn1 = first , * insn2 = second ; return frv_insn_unit ( * insn1 ) - frv_insn_unit ( * insn2 ) ;


<s> static int frv_compare_insns ( const void * first , const void * second ) { const rtx * insn1 = first , * insn2 = second ; return frv_insn_unit ( * insn1 ) - frv_insn_unit ( * insn2 ) ;


<s> } if ( GET_CODE ( x ) == UNSPEC && XINT ( x , <NUM_LIT> ) == UNSPEC_GOT ) { unspec -> symbol = XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ; unspec -> reloc = INTVAL ( XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ) ; if ( unspec -> offset == <NUM_LIT> ) return true ; if ( frv_small_data_reloc_p ( unspec -> symbol , unspec -> reloc ) && unspec -> offset > <NUM_LIT> && ( unsigned HOST_WIDE_INT ) unspec -> offset < g_switch_value ) return true ; } } return false ;


<s> rtx set = gen_rtx_SET ( VOIDmode , gen_rtx_MEM ( GET_MODE ( reg ) , plus_constant ( stack_pointer_rtx , offset ) ) , reg ) ;

RTX_FRAME_RELATED_P ( set ) = <NUM_LIT> ;


label_ref = gen_rtx_LABEL_REF ( VOIDmode , label ) ;


<s> case HImode : case DImode : case SFmode : case DFmode : if ( ! reload_in_progress && ! reload_completed && ! register_operand ( dest , mode ) && ! reg_or_0_operand ( src , mode ) ) src = copy_to_mode_reg ( mode , src ) ;


<s> if ( frv_local_funcdesc_p ( sym ) ) unspec = R_FRV_FUNCDESC_GOTOFF12 ; else unspec = R_FRV_FUNCDESC_GOT12 ; } else { if ( CONSTANT_POOL_ADDRESS_P ( sym ) ) switch ( GET_CODE ( get_pool_constant ( sym ) ) ) { case CONST : case SYMBOL_REF : case LABEL_REF : if ( flag_pic ) { unspec = R_FRV_GOTOFF12 ; break ; } default : if ( TARGET_GPREL_RO ) unspec = R_FRV_GPREL12 ; else unspec = R_FRV_GOT12 ; break ; } else if ( SYMBOL_REF_LOCAL_P ( sym ) && ! SYMBOL_REF_EXTERNAL_P ( sym ) && SYMBOL_REF_DECL ( sym ) && ( ! DECL_P ( SYMBOL_REF_DECL ( sym ) ) || ! DECL_COMMON ( SYMBOL_REF_DECL ( sym ) ) ) ) { tree decl = SYMBOL_REF_DECL ( sym ) ; tree init = TREE_CODE ( decl ) == VAR_DECL ? DECL_INITIAL ( decl ) : TREE_CODE ( decl ) == CONSTRUCTOR ? decl : <NUM_LIT> ; int reloc = <NUM_LIT> ; bool named_section , readonly ; if ( init && init != error_mark_node ) reloc = compute_reloc_for_constant ( init ) ; named_section = TREE_CODE ( decl ) == VAR_DECL && lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( decl ) ) ; readonly = decl_readonly_section ( decl , reloc ) ; if ( named_section ) unspec = R_FRV_GOT12 ; else if ( ! readonly ) unspec = R_FRV_GOTOFF12 ; else if ( readonly && TARGET_GPREL_RO ) unspec = R_FRV_GPREL12 ; else unspec = R_FRV_GOT12 ; } else unspec = R_FRV_GOT12 ; } } else if ( SYMBOL_REF_SMALL_P ( sym ) ) base_regno = SDA_BASE_REG ; else if ( flag_pic ) base_regno = PIC_REGNO ; break ; } if ( base_regno >= <NUM_LIT> ) { if ( GET_CODE ( sym ) == SYMBOL_REF && SYMBOL_REF_SMALL_P ( sym ) ) emit_insn ( gen_symGOTOFF2reg ( dest , src , gen_rtx_REG ( Pmode , base_regno ) , GEN_INT ( R_FRV_GPREL12 ) ) ) ; else emit_insn ( gen_symGOTOFF2reg_hilo ( dest , src , gen_rtx_REG ( Pmode , base_regno ) , GEN_INT ( R_FRV_GPREL12 ) ) ) ; if ( base_regno == PIC_REGNO ) cfun -> uses_pic_offset_table = TRUE ; return TRUE ; } if ( unspec ) { rtx x ; gcc_assert ( ! reload_in_progress && ! reload_completed ) ; switch ( unspec ) { case R_FRV_GOTOFF12 : if ( ! frv_small_data_reloc_p ( sym , unspec ) ) x = gen_symGOTOFF2reg_hilo ( dest , src , OUR_FDPIC_REG , GEN_INT ( unspec ) ) ; else x = gen_symGOTOFF2reg ( dest , src , OUR_FDPIC_REG , GEN_INT ( unspec ) ) ; break ; case R_FRV_GPREL12 : if ( ! frv_small_data_reloc_p ( sym , unspec ) ) x = gen_symGPREL2reg_hilo ( dest , src , OUR_FDPIC_REG , GEN_INT ( unspec ) ) ;

else x = gen_symGPREL2reg ( dest , src , OUR_FDPIC_REG , GEN_INT ( unspec ) ) ;


<s> rtx set ; rtx test_rtx ; rtx clobber ; rtx cr_reg ; rtx cc_reg = frv_emit_comparison ( test , frv_compare_op0 , frv_compare_op1 ) ; test_rtx = gen_rtx_fmt_ee ( test , SImode , cc_reg , const0_rtx ) ; set = gen_rtx_SET ( VOIDmode , target , test_rtx ) ; cr_reg = ( ( TARGET_ALLOC_CC ) ? gen_reg_rtx ( CC_CCRmode ) : gen_rtx_REG ( CC_CCRmode , ( ( GET_MODE ( cc_reg ) == CC_FPmode ) ? FCR_FIRST : ICR_FIRST ) ) ) ; clobber = gen_rtx_CLOBBER ( VOIDmode , cr_reg ) ; emit_insn ( gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , set , clobber ) ) ) ; return TRUE ;


<s> rtx clobber ; rtx cr_reg ; rtx cc_reg = frv_emit_comparison ( test , frv_compare_op0 , frv_compare_op1 ) ; test_rtx = gen_rtx_fmt_ee ( test , SImode , cc_reg , const0_rtx ) ; set = gen_rtx_SET ( VOIDmode , target , test_rtx ) ;


<s> rtx op1 = frv_read_argument ( & arglist ) ; if ( ! frv_check_constant_argument ( icode , <NUM_LIT> , op1 ) ) return NULL_RTX ; target = frv_legitimize_target ( icode , target ) ; op0 = frv_legitimize_argument ( icode , <NUM_LIT> , op0 ) ; pat = GEN_FCN ( icode ) ( target , op0 , op1 ) ; if ( ! pat ) return NULL_RTX ; emit_insn ( pat ) ;


<s> if ( ! frv_check_constant_argument ( icode , <NUM_LIT> , op1 ) ) return NULL_RTX ; target = frv_legitimize_target ( icode , target ) ; op0 = frv_legitimize_argument ( icode , <NUM_LIT> , op0 ) ; pat = GEN_FCN ( icode ) ( target , op0 , op1 ) ; if ( ! pat ) return NULL_RTX ; emit_insn ( pat ) ;


<s> static rtx frv_expand_binop_builtin ( enum insn_code icode , tree arglist , rtx target ) { rtx pat ; rtx op0 = frv_read_argument ( & arglist ) ;

rtx op1 = frv_read_argument ( & arglist ) ;


<s> dest_addr = ( ( offset == <NUM_LIT> ) ? dest_reg : plus_constant ( dest_reg , offset ) ) ; if ( bytes >= <NUM_LIT> && align >= <NUM_LIT> ) mode = SImode ; else if ( bytes >= <NUM_LIT> && align >= <NUM_LIT> ) mode = HImode ; else mode = QImode ; clear_bytes = GET_MODE_SIZE ( mode ) ; dest_mem = change_address ( orig_dest , mode , dest_addr ) ; emit_insn ( gen_rtx_SET ( VOIDmode , dest_mem , const0_rtx ) ) ;


<s> rtx src_addr ; rtx dest_addr ; rtx src_mem ; rtx dest_mem ; rtx tmp_reg ; rtx stores [ MAX_MOVE_REG ] ; int move_bytes ; enum machine_mode mode ; if ( ! constp ) return FALSE ; gcc_assert ( GET_CODE ( align_rtx ) == CONST_INT ) ; align = INTVAL ( align_rtx ) ; bytes = INTVAL ( bytes_rtx ) ; if ( bytes <= <NUM_LIT> ) return TRUE ; if ( bytes > TOTAL_MOVE_REG * align ) return FALSE ; dest_reg = copy_addr_to_reg ( XEXP ( orig_dest , <NUM_LIT> ) ) ; src_reg = copy_addr_to_reg ( XEXP ( orig_src , <NUM_LIT> ) ) ; num_reg = offset = <NUM_LIT> ; for ( ; bytes > <NUM_LIT> ; ( bytes -= move_bytes ) , ( offset += move_bytes ) ) { if ( offset == <NUM_LIT> ) {


<s> case FRV_BUILTIN_MWTACC : return frv_expand_mwtacc_builtin ( CODE_FOR_mwtacc , arglist ) ; case FRV_BUILTIN_MWTACCG : return frv_expand_mwtacc_builtin ( CODE_FOR_mwtaccg , arglist ) ; case FRV_BUILTIN_MDPACKH : return frv_expand_mdpackh_builtin ( arglist , target ) ; case FRV_BUILTIN_IACCreadll : { rtx src = frv_read_iacc_argument ( DImode , & arglist ) ; if ( target == <NUM_LIT> || ! REG_P ( target ) ) target = gen_reg_rtx ( DImode ) ; frv_split_iacc_move ( target , src ) ; return target ; } case FRV_BUILTIN_IACCreadl : return frv_read_iacc_argument ( SImode , & arglist ) ; case FRV_BUILTIN_IACCsetll : { rtx dest = frv_read_iacc_argument ( DImode , & arglist ) ; rtx src = frv_read_argument ( & arglist ) ; frv_split_iacc_move ( dest , force_reg ( DImode , src ) ) ; return <NUM_LIT> ; } case FRV_BUILTIN_IACCsetl : { rtx dest = frv_read_iacc_argument ( SImode , & arglist ) ; rtx src = frv_read_argument ( & arglist ) ; emit_move_insn ( dest , force_reg ( SImode , src ) ) ; return <NUM_LIT> ; } default : break ; } for ( i = <NUM_LIT> , d = bdesc_set ; i < ARRAY_SIZE ( bdesc_set ) ; i ++ , d ++ ) if ( d -> code == fcode ) return frv_expand_set_builtin ( d -> icode , arglist , target ) ; for ( i = <NUM_LIT> , d = bdesc_1arg ; i < ARRAY_SIZE ( bdesc_1arg ) ; i ++ , d ++ ) if ( d -> code == fcode ) return frv_expand_unop_builtin ( d -> icode , arglist , target ) ; for ( i = <NUM_LIT> , d = bdesc_2arg ; i < ARRAY_SIZE ( bdesc_2arg ) ; i ++ , d ++ ) if ( d -> code == fcode ) return frv_expand_binop_builtin ( d -> icode , arglist , target ) ; for ( i = <NUM_LIT> , d = bdesc_cut ; i < ARRAY_SIZE ( bdesc_cut ) ; i ++ , d ++ ) if ( d -> code == fcode ) return frv_expand_cut_builtin ( d -> icode , arglist , target ) ;

for ( i = <NUM_LIT> , d = bdesc_2argimm ; i < ARRAY_SIZE ( bdesc_2argimm ) ; i ++ , d ++ ) if ( d -> code == fcode ) return frv_expand_binopimm_builtin ( d -> icode , arglist , target ) ;


<s> void frv_expand_builtin_va_start ( tree valist , rtx nextarg ) { tree t ; int num = cfun -> args_info - FIRST_ARG_REGNUM - FRV_NUM_ARG_REGS ; nextarg = gen_rtx_PLUS ( Pmode , virtual_incoming_args_rtx , GEN_INT ( UNITS_PER_WORD * num ) ) ; if ( TARGET_DEBUG_ARG ) { fprintf ( stderr , <STR_LIT> , cfun -> args_info , num ) ; debug_rtx ( nextarg ) ; } t = build ( MODIFY_EXPR , TREE_TYPE ( valist ) , valist , make_tree ( ptr_type_node , nextarg ) ) ; TREE_SIDE_EFFECTS ( t ) = <NUM_LIT> ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ;


<s> static rtx frv_expand_cut_builtin ( enum insn_code icode , tree arglist , rtx target ) { rtx pat ; rtx op0 = frv_read_argument ( & arglist ) ; rtx op1 = frv_read_argument ( & arglist ) ; rtx op2 ;

target = frv_legitimize_target ( icode , target ) ;


<s> rtx offset = frv_frame_offset_rtx ( info -> total_size ) ; emit_insn ( gen_stack_adjust ( sp , sp , offset ) ) ; } if ( current_function_calls_eh_return ) emit_insn ( gen_stack_adjust ( sp , sp , EH_RETURN_STACKADJ_RTX ) ) ; if ( emit_return ) emit_jump_insn ( gen_epilogue_return ( return_addr ) ) ; else { rtx lr = return_addr ; if ( REGNO ( return_addr ) != LR_REGNO ) { lr = gen_rtx_REG ( Pmode , LR_REGNO ) ; emit_move_insn ( lr , return_addr ) ; }

emit_insn ( gen_rtx_USE ( VOIDmode , lr ) ) ;


<s> lr_offset = info -> reg_offset [ LR_REGNO ] ; if ( frame_pointer_needed ) mem = frv_frame_mem ( Pmode , fp , lr_offset - fp_offset ) ; else mem = frv_frame_mem ( Pmode , sp , lr_offset ) ; return_addr = gen_rtx_REG ( Pmode , TEMP_REGNO ) ; emit_insn ( gen_rtx_SET ( VOIDmode , return_addr , mem ) ) ; } else return_addr = gen_rtx_REG ( Pmode , LR_REGNO ) ; if ( frame_pointer_needed ) { emit_insn ( gen_rtx_SET ( VOIDmode , fp , gen_rtx_MEM ( Pmode , fp ) ) ) ; emit_insn ( gen_rtx_USE ( VOIDmode , fp ) ) ; } if ( info -> total_size != <NUM_LIT> ) { rtx offset = frv_frame_offset_rtx ( info -> total_size ) ; emit_insn ( gen_stack_adjust ( sp , sp , offset ) ) ; } if ( current_function_calls_eh_return ) emit_insn ( gen_stack_adjust ( sp , sp , EH_RETURN_STACKADJ_RTX ) ) ; if ( emit_return ) emit_jump_insn ( gen_epilogue_return ( return_addr ) ) ; else { rtx lr = return_addr ; if ( REGNO ( return_addr ) != LR_REGNO ) { lr = gen_rtx_REG ( Pmode , LR_REGNO ) ; emit_move_insn ( lr , return_addr ) ; }


<s> rtx c , rvrtx = <NUM_LIT> ; rtx addr ; if ( ret_value ) { rvrtx = operands [ <NUM_LIT> ] ; operands ++ ; } addr = XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ; if ( GET_CODE ( addr ) == SYMBOL_REF && ( ( ! SYMBOL_REF_LOCAL_P ( addr ) && TARGET_INLINE_PLT ) || sibcall ) ) { rtx x , dest ; dest = gen_reg_rtx ( SImode ) ; if ( flag_pic != <NUM_LIT> ) x = gen_symGOTOFF2reg_hilo ( dest , addr , OUR_FDPIC_REG , GEN_INT ( R_FRV_FUNCDESC_GOTOFF12 ) ) ; else x = gen_symGOTOFF2reg ( dest , addr , OUR_FDPIC_REG , GEN_INT ( R_FRV_FUNCDESC_GOTOFF12 ) ) ; emit_insn ( x ) ; cfun -> uses_pic_offset_table = TRUE ; addr = dest ; } else if ( GET_CODE ( addr ) == SYMBOL_REF ) { if ( ret_value ) c = gen_call_value_fdpicsi ( rvrtx , addr , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , picreg , lr ) ; else c = gen_call_fdpicsi ( addr , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , picreg , lr ) ; emit_call_insn ( c ) ; return ; } else if ( ! ldd_address_operand ( addr , Pmode ) ) addr = force_reg ( Pmode , addr ) ;


<s> static rtx frv_expand_int_void2arg ( enum insn_code icode , tree arglist ) { rtx pat ; rtx op0 = frv_read_argument ( & arglist ) ;


<s> if ( target == <NUM_LIT> || ! REG_P ( target ) ) target = gen_reg_rtx ( target_mode ) ; op0 = frv_volatile_memref ( insn_data [ icode ] . operand [ <NUM_LIT> ] . mode , op0 ) ; convert_move ( target , op0 , <NUM_LIT> ) ;

emit_insn ( GEN_FCN ( icode ) ( copy_rtx ( op0 ) , cookie , GEN_INT ( FRV_IO_READ ) ) ) ;


<s> op0 = frv_volatile_memref ( insn_data [ icode ] . operand [ <NUM_LIT> ] . mode , op0 ) ; convert_move ( target , op0 , <NUM_LIT> ) ;


<s> rtx op0 = frv_read_argument ( & arglist ) ; op0 = frv_int_to_acc ( icode , <NUM_LIT> , op0 ) ;


<s> rtx op0 = frv_read_argument ( & arglist ) ; op0 = frv_int_to_acc ( icode , <NUM_LIT> , op0 ) ; if ( ! op0 ) return NULL_RTX ; pat = GEN_FCN ( icode ) ( op0 ) ;


<s> static rtx frv_expand_mdpackh_builtin ( tree arglist , rtx target ) { enum insn_code icode = CODE_FOR_mdpackh ; rtx pat , op0 , op1 ; rtx arg1 = frv_read_argument ( & arglist ) ; rtx arg2 = frv_read_argument ( & arglist ) ; rtx arg3 = frv_read_argument ( & arglist ) ;

rtx arg4 = frv_read_argument ( & arglist ) ;


<s> if ( ! op0 ) return NULL_RTX ; op1 = frv_legitimize_argument ( icode , <NUM_LIT> , op1 ) ; pat = GEN_FCN ( icode ) ( op0 , op1 ) ;


<s> pat = GEN_FCN ( icode ) ( force_reg ( Pmode , op0 ) ) ; if ( ! pat ) return <NUM_LIT> ;


<s> rtx insn ; accessor . base = gen_rtx_REG ( Pmode , OLD_SP_REGNO ) ; accessor . base_offset = info -> total_size ; insn = emit_insn ( gen_movsi ( accessor . base , sp ) ) ; } else { accessor . base = stack_pointer_rtx ; accessor . base_offset = <NUM_LIT> ; } { rtx asm_offset = frv_frame_offset_rtx ( - info -> total_size ) ; rtx dwarf_offset = GEN_INT ( - info -> total_size ) ; frv_frame_insn ( gen_stack_adjust ( sp , sp , asm_offset ) , gen_rtx_SET ( Pmode , sp , gen_rtx_PLUS ( Pmode , sp , dwarf_offset ) ) ) ; } if ( frame_pointer_needed ) { int fp_offset = info -> reg_offset [ FRAME_POINTER_REGNUM ] ; rtx asm_src = plus_constant ( accessor . base , fp_offset - accessor . base_offset ) ; rtx dwarf_src = plus_constant ( sp , fp_offset ) ; frv_frame_access ( & accessor , fp , fp_offset ) ;

frv_frame_insn ( gen_rtx_SET ( VOIDmode , fp , asm_src ) , gen_rtx_SET ( VOIDmode , fp , dwarf_src ) ) ;


<s> rtx pat ; rtx op0 = frv_read_argument ( & arglist ) ; if ( ! frv_check_constant_argument ( icode , <NUM_LIT> , op0 ) ) return NULL_RTX ; target = frv_legitimize_target ( icode , target ) ; pat = GEN_FCN ( icode ) ( target , op0 ) ;


<s> rtx cookie = frv_io_address_cookie ( op0 ) ; op0 = frv_volatile_memref ( insn_data [ icode ] . operand [ <NUM_LIT> ] . mode , op0 ) ; convert_move ( op0 , force_reg ( insn_data [ icode ] . operand [ <NUM_LIT> ] . mode , op1 ) , <NUM_LIT> ) ; emit_insn ( GEN_FCN ( icode ) ( copy_rtx ( op0 ) , cookie , GEN_INT ( FRV_IO_WRITE ) ) ) ; cfun -> machine -> has_membar_p = <NUM_LIT> ; return NULL_RTX ;


<s> rtx op0 = frv_read_argument ( & arglist ) ; target = frv_legitimize_target ( icode , target ) ;


<s> rtx op0 = frv_read_argument ( & arglist ) ; rtx op1 = frv_read_argument ( & arglist ) ; rtx op2 ; rtx op3 ; op0 = frv_int_to_acc ( icode , <NUM_LIT> , op0 ) ; if ( ! op0 ) return NULL_RTX ; op1 = frv_int_to_acc ( icode , <NUM_LIT> , op1 ) ; if ( ! op1 ) return NULL_RTX ; op2 = frv_matching_accg_for_acc ( op0 ) ;


<s> rtx addr ; if ( GET_CODE ( op0 ) != MEM ) { rtx reg = op0 ; if ( ! offsettable_address_p ( <NUM_LIT> , mode0 , op0 ) ) { reg = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_rtx_SET ( VOIDmode , reg , op0 ) ) ; } op0 = gen_rtx_MEM ( SImode , reg ) ;


<s> static rtx frv_expand_voidtriop_builtin ( enum insn_code icode , tree arglist ) { rtx pat ; rtx op0 = frv_read_argument ( & arglist ) ; rtx op1 = frv_read_argument ( & arglist ) ; rtx op2 = frv_read_argument ( & arglist ) ; rtx op3 ; op0 = frv_int_to_acc ( icode , <NUM_LIT> , op0 ) ; if ( ! op0 ) return NULL_RTX ; op1 = frv_legitimize_argument ( icode , <NUM_LIT> , op1 ) ; op2 = frv_legitimize_argument ( icode , <NUM_LIT> , op2 ) ; op3 = frv_matching_accg_for_acc ( op0 ) ; pat = GEN_FCN ( icode ) ( op0 , op1 , op2 , op3 ) ;


<s> io -> const_address = INTVAL ( recog_data . operand [ <NUM_LIT> ] ) ;

io -> var_address = XEXP ( recog_data . operand [ <NUM_LIT> ] , <NUM_LIT> ) ;


<s> io -> type = INTVAL ( recog_data . operand [ <NUM_LIT> ] ) ; io -> const_address = INTVAL ( recog_data . operand [ <NUM_LIT> ] ) ;


<s> else if ( recog_memoized ( insn ) >= <NUM_LIT> && get_attr_acc_group ( insn ) == ACC_GROUP_ODD ) fprintf ( asm_out_file , <STR_LIT> ) ;


if ( frv_const_unspec_p ( x , & unspec ) && frv_small_data_reloc_p ( unspec . symbol , unspec . reloc ) ) return plus_constant ( unspec . symbol , unspec . offset ) ;


<s> rtx frv_find_base_term ( rtx x ) { struct frv_unspec unspec ;


<s> eh_insn_p = ( find_reg_note ( insn , REG_EH_REGION , NULL ) != NULL ) ; if ( eh_insn_p && ! frv_issues_to_branch_unit_p ( insn ) ) frv_finish_packet ( handle_packet ) ; if ( ! frv_pack_insn_p ( insn ) ) { frv_finish_packet ( handle_packet ) ; while ( ! frv_pack_insn_p ( insn ) ) state_transition ( frv_packet . dfa_state , <NUM_LIT> ) ; } frv_add_insn_to_packet ( insn ) ; if ( code == CALL_INSN || code == JUMP_INSN || eh_insn_p ) frv_finish_packet ( handle_packet ) ; break ; } }


<s> dfa_start ( ) ; frv_packet . dfa_state = alloca ( state_size ( ) ) ; frv_start_packet_block ( ) ; for ( insn = get_insns ( ) ; insn != <NUM_LIT> ; insn = next_insn ) { enum rtx_code code ; bool eh_insn_p ; code = GET_CODE ( insn ) ; next_insn = NEXT_INSN ( insn ) ; if ( code == CODE_LABEL ) { frv_finish_packet ( handle_packet ) ; frv_start_packet_block ( ) ; } if ( INSN_P ( insn ) ) switch ( GET_CODE ( PATTERN ( insn ) ) ) { case USE : case CLOBBER : case ADDR_VEC : case ADDR_DIFF_VEC : break ; default : if ( GET_CODE ( insn ) == CALL_INSN && frv_cpu_type == FRV_CPU_TOMCAT ) frv_finish_packet ( handle_packet ) ; eh_insn_p = ( find_reg_note ( insn , REG_EH_REGION , NULL ) != NULL ) ; if ( eh_insn_p && ! frv_issues_to_branch_unit_p ( insn ) ) frv_finish_packet ( handle_packet ) ; if ( ! frv_pack_insn_p ( insn ) ) { frv_finish_packet ( handle_packet ) ; while ( ! frv_pack_insn_p ( insn ) ) state_transition ( frv_packet . dfa_state , <NUM_LIT> ) ; } frv_add_insn_to_packet ( insn ) ; if ( code == CALL_INSN || code == JUMP_INSN || eh_insn_p ) frv_finish_packet ( handle_packet ) ; break ; } } frv_finish_packet ( handle_packet ) ; dfa_finish ( ) ; return true ;


<s> rtx reg2 = gen_rtx_REG ( SImode , REGNO ( reg ) + <NUM_LIT> ) ; rtx set1 = frv_dwarf_store ( reg1 , stack_offset ) ; rtx set2 = frv_dwarf_store ( reg2 , stack_offset + <NUM_LIT> ) ; frv_frame_insn ( gen_rtx_SET ( Pmode , mem , reg ) , gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , set1 , set2 ) ) ) ; } else frv_frame_insn ( gen_rtx_SET ( Pmode , mem , reg ) , frv_dwarf_store ( reg , stack_offset ) ) ; }


<s> if ( SPR_P ( REGNO ( reg ) ) ) { rtx temp = gen_rtx_REG ( mode , TEMP_REGNO ) ; emit_insn ( gen_rtx_SET ( VOIDmode , temp , reg ) ) ; frv_frame_insn ( gen_rtx_SET ( Pmode , mem , temp ) , frv_dwarf_store ( reg , stack_offset ) ) ; } else if ( GET_MODE ( reg ) == DImode ) { rtx reg1 = gen_rtx_REG ( SImode , REGNO ( reg ) ) ; rtx reg2 = gen_rtx_REG ( SImode , REGNO ( reg ) + <NUM_LIT> ) ; rtx set1 = frv_dwarf_store ( reg1 , stack_offset ) ; rtx set2 = frv_dwarf_store ( reg2 , stack_offset + <NUM_LIT> ) ; frv_frame_insn ( gen_rtx_SET ( Pmode , mem , reg ) , gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , set1 , set2 ) ) ) ; }

else frv_frame_insn ( gen_rtx_SET ( Pmode , mem , reg ) , frv_dwarf_store ( reg , stack_offset ) ) ;


<s> return gen_rtx_MEM ( mode , gen_rtx_PLUS ( Pmode , base , frv_frame_offset_rtx ( offset ) ) ) ;


<s> if ( ! TARGET_LINKED_FP ) return ! current_function_sp_is_unchanging ; if ( ! current_function_is_leaf ) return TRUE ; if ( get_frame_size ( ) != <NUM_LIT> ) return TRUE ; if ( cfun -> stdarg ) return TRUE ; if ( ! current_function_sp_is_unchanging ) return TRUE ; if ( ! TARGET_FDPIC && flag_pic && cfun -> uses_pic_offset_table ) return TRUE ; if ( profile_flag ) return TRUE ;

if ( cfun -> machine -> frame_needed ) return TRUE ;


<s> if ( ! TARGET_LINKED_FP ) return ! current_function_sp_is_unchanging ; if ( ! current_function_is_leaf ) return TRUE ; if ( get_frame_size ( ) != <NUM_LIT> ) return TRUE ; if ( cfun -> stdarg ) return TRUE ; if ( ! current_function_sp_is_unchanging ) return TRUE ;

if ( ! TARGET_FDPIC && flag_pic && cfun -> uses_pic_offset_table ) return TRUE ;


<s> else if ( arg_num <= LAST_ARG_REGNUM ) { ret = gen_rtx_REG ( xmode , arg_num ) ; debstr = reg_names [ arg_num ] ; } else { ret = NULL_RTX ; debstr = <STR_LIT> ; }

if ( TARGET_DEBUG_ARG ) fprintf ( stderr , <STR_LIT> , arg_num , GET_MODE_NAME ( mode ) , named , GET_MODE_SIZE ( mode ) , debstr ) ;


<s> else { ret = NULL_RTX ; debstr = <STR_LIT> ; } if ( TARGET_DEBUG_ARG ) fprintf ( stderr , <STR_LIT> , arg_num , GET_MODE_NAME ( mode ) , named , GET_MODE_SIZE ( mode ) , debstr ) ; return ret ;


<s> void frv_function_arg_advance ( CUMULATIVE_ARGS * cum , enum machine_mode mode , tree type ATTRIBUTE_UNUSED , int named ) { enum machine_mode xmode = ( mode == BLKmode ) ? SImode : mode ; int bytes = GET_MODE_SIZE ( xmode ) ; int words = ( bytes + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ;


<s> int words = ( bytes + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ; int arg_num = * cum ; * cum = arg_num + words ;

if ( TARGET_DEBUG_ARG ) fprintf ( stderr , <STR_LIT> , arg_num , GET_MODE_NAME ( mode ) , named , words * UNITS_PER_WORD ) ;


<s> int frv_function_arg_boundary ( enum machine_mode mode ATTRIBUTE_UNUSED , tree type ATTRIBUTE_UNUSED ) { return BITS_PER_WORD ;


<s> int frv_function_arg_boundary ( enum machine_mode mode ATTRIBUTE_UNUSED , tree type ATTRIBUTE_UNUSED ) {


<s> rtx insn = get_insns ( ) ; while ( insn != NULL && ! ( GET_CODE ( insn ) == JUMP_INSN && GET_CODE ( PATTERN ( insn ) ) != ADDR_VEC && GET_CODE ( PATTERN ( insn ) ) != ADDR_DIFF_VEC && get_attr_far_jump ( insn ) == FAR_JUMP_YES ) ) insn = NEXT_INSN ( insn ) ; return ( insn != NULL ) ;


<s> static void frv_function_prologue ( FILE * file , HOST_WIDE_INT size ATTRIBUTE_UNUSED ) { if ( frv_stack_info ( ) -> total_size == <NUM_LIT> && frv_function_contains_far_jump ( ) ) { rtx insn ; gcc_assert ( ! regs_ever_live [ GPR_FIRST + <NUM_LIT> ] ) ; fprintf ( file , <STR_LIT> ) ; for ( insn = get_insns ( ) ; insn != NULL ; insn = NEXT_INSN ( insn ) ) if ( GET_CODE ( insn ) == JUMP_INSN ) { rtx pattern = PATTERN ( insn ) ; if ( GET_CODE ( pattern ) == PARALLEL && XVECLEN ( pattern , <NUM_LIT> ) >= <NUM_LIT> && GET_CODE ( XVECEXP ( pattern , <NUM_LIT> , <NUM_LIT> ) ) == RETURN && GET_CODE ( XVECEXP ( pattern , <NUM_LIT> , <NUM_LIT> ) ) == USE ) { rtx address = XEXP ( XVECEXP ( pattern , <NUM_LIT> , <NUM_LIT> ) , <NUM_LIT> ) ; if ( GET_CODE ( address ) == REG && REGNO ( address ) == LR_REGNO ) REGNO ( address ) = GPR_FIRST + <NUM_LIT> ; } } } frv_pack_insns ( ) ; memset ( frv_nops , <NUM_LIT> , sizeof ( frv_nops ) ) ;


<s> else if ( strcmp ( arg , <STR_LIT> ) == <NUM_LIT> ) frv_cpu_type = FRV_CPU_FR400 ; else if ( strcmp ( arg , <STR_LIT> ) == <NUM_LIT> ) frv_cpu_type = FRV_CPU_FR300 ; else if ( strcmp ( arg , <STR_LIT> ) == <NUM_LIT> ) frv_cpu_type = FRV_CPU_GENERIC ; else return false ; return true ;


<s> static void frv_ifcvt_add_insn ( rtx pattern , rtx insn , int before_p ) { rtx link = alloc_EXPR_LIST ( VOIDmode , pattern , insn ) ; link -> jump = before_p ; frv_ifcvt . added_insns_list = alloc_EXPR_LIST ( VOIDmode , link , frv_ifcvt . added_insns_list ) ;


<s> if ( dump_file ) { if ( GET_CODE ( value ) == CONST_INT ) fprintf ( dump_file , <STR_LIT> , reg_names [ REGNO ( reg ) ] , ( long ) INTVAL ( value ) ) ; else if ( GET_CODE ( value ) == REG && REGNO ( value ) == LR_REGNO ) fprintf ( dump_file , <STR_LIT> , reg_names [ REGNO ( reg ) ] ) ; else fprintf ( dump_file , <STR_LIT> , reg_names [ REGNO ( reg ) ] ) ; } return reg ;


<s> int i ; rtx reg ; if ( value == const0_rtx ) return gen_rtx_REG ( SImode , GPR_FIRST ) ; if ( CONSTANT_P ( value ) || ( GET_CODE ( value ) == REG && REGNO ( value ) == LR_REGNO ) ) { for ( i = <NUM_LIT> ; i < num_alloc ; i ++ ) { if ( rtx_equal_p ( SET_SRC ( frv_ifcvt . scratch_regs [ i ] ) , value ) ) return SET_DEST ( frv_ifcvt . scratch_regs [ i ] ) ; } } if ( num_alloc >= GPR_TEMP_NUM ) { if ( dump_file ) fprintf ( dump_file , <STR_LIT> ) ; return NULL_RTX ; } reg = frv_alloc_temp_reg ( & frv_ifcvt . tmp_reg , GPR_REGS , SImode , TRUE , TRUE ) ; if ( ! reg ) { if ( dump_file ) fputs ( <STR_LIT> , dump_file ) ; return NULL_RTX ; } frv_ifcvt . cur_scratch_regs ++ ;

frv_ifcvt . scratch_regs [ num_alloc ] = gen_rtx_SET ( VOIDmode , reg , value ) ;


<s> } frv_ifcvt_add_insn ( gen_rtx_USE ( VOIDmode , dest ) , insn , FALSE ) ; } else if ( frv_ifcvt . scratch_insns_bitmap && bitmap_bit_p ( frv_ifcvt . scratch_insns_bitmap , INSN_UID ( insn ) ) && REG_P ( SET_DEST ( set ) ) && ce_info -> join_bb && ! ( REGNO_REG_SET_P ( ce_info -> join_bb -> il . rtl -> global_live_at_start , REGNO ( SET_DEST ( set ) ) ) ) && ( ! ce_info -> else_bb || BLOCK_FOR_INSN ( insn ) == ce_info -> else_bb || ! ( REGNO_REG_SET_P ( ce_info -> else_bb -> il . rtl -> global_live_at_start , REGNO ( SET_DEST ( set ) ) ) ) ) ) pattern = set ; else if ( mode == QImode || mode == HImode || mode == SImode || mode == SFmode ) { int changed_p = FALSE ; if ( CONSTANT_P ( src ) && integer_register_operand ( dest , mode ) ) { src = frv_ifcvt_load_value ( src , insn ) ; if ( ! src ) goto fail ; changed_p = TRUE ; } if ( GET_CODE ( dest ) == MEM ) { rtx new_mem = frv_ifcvt_rewrite_mem ( dest , mode , insn ) ; if ( ! new_mem ) goto fail ; else if ( new_mem != dest ) { changed_p = TRUE ; dest = new_mem ; } } if ( GET_CODE ( src ) == MEM ) { rtx new_mem = frv_ifcvt_rewrite_mem ( src , mode , insn ) ; if ( ! new_mem ) goto fail ; else if ( new_mem != src ) { changed_p = TRUE ; src = new_mem ; } } if ( changed_p ) COND_EXEC_CODE ( pattern ) = gen_rtx_SET ( VOIDmode , dest , src ) ; } else if ( mode == CC_CCRmode && COMPARISON_P ( src ) ) { int regno = REGNO ( XEXP ( src , <NUM_LIT> ) ) ; rtx if_else ; if ( ce_info -> pass > <NUM_LIT> && regno != ( int ) REGNO ( frv_ifcvt . nested_cc_reg ) && TEST_HARD_REG_BIT ( frv_ifcvt . nested_cc_ok_rewrite , regno ) ) { src = gen_rtx_fmt_ee ( GET_CODE ( src ) , CC_CCRmode , frv_ifcvt . nested_cc_reg , XEXP ( src , <NUM_LIT> ) ) ;


<s> logical_func = ( GET_CODE ( old_true ) == EQ ) ? gen_andcr : gen_andncr ; * p_true = gen_rtx_NE ( CC_CCRmode , cr , const0_rtx ) ; * p_false = gen_rtx_EQ ( CC_CCRmode , cr , const0_rtx ) ; } else { old_test = old_false ; test_expr = false_expr ; logical_func = ( GET_CODE ( old_false ) == EQ ) ? gen_orcr : gen_orncr ; * p_true = gen_rtx_EQ ( CC_CCRmode , cr , const0_rtx ) ; * p_false = gen_rtx_NE ( CC_CCRmode , cr , const0_rtx ) ; } frv_ifcvt_add_insn ( ( * logical_func ) ( cr , cr , new_cr ) , BB_END ( bb ) , TRUE ) ; cc = XEXP ( test_expr , <NUM_LIT> ) ; compare = gen_rtx_fmt_ee ( GET_CODE ( test_expr ) , CC_CCRmode , cc , const0_rtx ) ; if_else = gen_rtx_IF_THEN_ELSE ( CC_CCRmode , old_test , compare , const0_rtx ) ; check_insn = gen_rtx_SET ( VOIDmode , new_cr , if_else ) ; frv_ifcvt_add_insn ( check_insn , BB_END ( bb ) , TRUE ) ; if ( TARGET_DEBUG_COND_EXEC ) { fputs ( <STR_LIT> , stderr ) ; debug_rtx ( * p_true ) ; fputs ( <STR_LIT> , stderr ) ; debug_rtx ( * p_false ) ; } return ; fail : * p_true = * p_false = NULL_RTX ; if ( new_cr ) { CLEAR_HARD_REG_BIT ( frv_ifcvt . tmp_reg . regs , REGNO ( new_cr ) ) ; * p_new_cr = NULL_RTX ; } if ( TARGET_DEBUG_COND_EXEC ) fputs ( <STR_LIT> , stderr ) ; return ;


<s> frv_ifcvt . num_nested_cond_exec ++ ; } } set = single_set_pattern ( pattern ) ; if ( set ) { rtx dest = SET_DEST ( set ) ; rtx src = SET_SRC ( set ) ; if ( GET_CODE ( dest ) == REG ) { int regno = REGNO ( dest ) ; enum rtx_code src_code = GET_CODE ( src ) ; if ( CC_P ( regno ) && src_code == COMPARE ) skip_nested_if = TRUE ; else if ( CR_P ( regno ) && ( src_code == IF_THEN_ELSE || COMPARISON_P ( src ) ) ) skip_nested_if = TRUE ; } } if ( ! skip_nested_if ) for_each_rtx ( & PATTERN ( insn ) , frv_clear_registers_used , ( void * ) & frv_ifcvt . nested_cc_ok_rewrite ) ; } if ( insn == last_insn ) break ; insn = NEXT_INSN ( insn ) ; } } if ( ce_info -> pass > <NUM_LIT> ) { for ( j = CC_FIRST ; j <= CC_LAST ; j ++ ) if ( TEST_HARD_REG_BIT ( frv_ifcvt . nested_cc_ok_rewrite , j ) ) SET_HARD_REG_BIT ( tmp_reg -> regs , j ) ; else CLEAR_HARD_REG_BIT ( tmp_reg -> regs , j ) ; } if ( dump_file ) { int num_gprs = <NUM_LIT> ; fprintf ( dump_file , <STR_LIT> ) ; for ( j = GPR_FIRST ; j <= GPR_LAST ; j ++ ) if ( TEST_HARD_REG_BIT ( tmp_reg -> regs , j ) ) { fprintf ( dump_file , <STR_LIT> , j , reg_names [ j ] ) ; if ( ++ num_gprs > GPR_TEMP_NUM + <NUM_LIT> ) break ; } fprintf ( dump_file , <STR_LIT> , ( num_gprs > GPR_TEMP_NUM + <NUM_LIT> ) ? <STR_LIT> : <STR_LIT> ) ; for ( j = CR_FIRST ; j <= CR_LAST ; j ++ ) if ( TEST_HARD_REG_BIT ( tmp_reg -> regs , j ) ) fprintf ( dump_file , <STR_LIT> , j , reg_names [ j ] ) ; fputs ( <STR_LIT> , dump_file ) ; if ( ce_info -> pass > <NUM_LIT> ) { fprintf ( dump_file , <STR_LIT> ) ; for ( j = CC_FIRST ; j <= CC_LAST ; j ++ ) if ( TEST_HARD_REG_BIT ( tmp_reg -> regs , j ) ) fprintf ( dump_file , <STR_LIT> , j , reg_names [ j ] ) ; fprintf ( dump_file , <STR_LIT> , frv_ifcvt . num_nested_cond_exec ) ; } } if ( mode == CCmode || mode == CC_UNSmode || mode == CC_NZmode ) { cr_class = ICR_REGS ; cc_class = ICC_REGS ; cc_first = ICC_FIRST ; cc_last = ICC_LAST ; } else if ( mode == CC_FPmode ) { cr_class = FCR_REGS ; cc_class = FCC_REGS ; cc_first = FCC_FIRST ; cc_last = FCC_LAST ; } else { cc_first = cc_last = <NUM_LIT> ; cr_class = cc_class = NO_REGS ; }


<s> rtx addr_op1 = XEXP ( addr , <NUM_LIT> ) ; if ( GET_CODE ( addr_op0 ) == REG && CONSTANT_P ( addr_op1 ) ) { rtx reg = frv_ifcvt_load_value ( addr_op1 , insn ) ; if ( ! reg ) return NULL_RTX ; addr = gen_rtx_PLUS ( Pmode , addr_op0 , reg ) ; } else return NULL_RTX ;


<s> rtx frv_index_memory ( rtx memref , enum machine_mode mode , int index ) { rtx base = XEXP ( memref , <NUM_LIT> ) ; if ( GET_CODE ( base ) == PRE_MODIFY ) base = XEXP ( base , <NUM_LIT> ) ; return change_address ( memref , mode , plus_constant ( base , index * GET_MODE_SIZE ( mode ) ) ) ;


<s> emit_library_call ( gen_rtx_SYMBOL_REF ( SImode , <STR_LIT> ) , FALSE , VOIDmode , <NUM_LIT> , addr , Pmode , GEN_INT ( frv_trampoline_size ( ) ) , SImode , fnaddr , Pmode , sc_reg , Pmode ) ;


<s> rtx sc_reg = force_reg ( Pmode , static_chain ) ;

emit_library_call ( gen_rtx_SYMBOL_REF ( SImode , <STR_LIT> ) , FALSE , VOIDmode , <NUM_LIT> , addr , Pmode , GEN_INT ( frv_trampoline_size ( ) ) , SImode , fnaddr , Pmode , sc_reg , Pmode ) ;


<s> if ( ! fndecl && fntype ) fputs ( <STR_LIT> , stderr ) ; if ( incoming ) fputs ( <STR_LIT> , stderr ) ; if ( fntype ) { tree ret_type = TREE_TYPE ( fntype ) ;

fprintf ( stderr , <STR_LIT> , tree_code_name [ ( int ) TREE_CODE ( ret_type ) ] ) ;


<s> static struct machine_function * frv_init_machine_status ( void ) {

return ggc_alloc_cleared ( sizeof ( struct machine_function ) ) ;


<s> struct frv_packet_group * packet_group ; rtx last ; packet_group = & frv_packet . groups [ frv_unit_groups [ frv_insn_unit ( insn ) ] ] ; last = frv_packet . insns [ frv_packet . num_insns - <NUM_LIT> ] ; if ( GET_CODE ( last ) != INSN ) { insn = emit_insn_before ( PATTERN ( insn ) , last ) ; frv_packet . insns [ frv_packet . num_insns - <NUM_LIT> ] = insn ; frv_packet . insns [ frv_packet . num_insns ++ ] = last ; } else { insn = emit_insn_after ( PATTERN ( insn ) , last ) ; frv_packet . insns [ frv_packet . num_insns ++ ] = insn ; } packet_group -> insns [ packet_group -> num_insns ++ ] = insn ;


<s> state = alloca ( state_size ( ) ) ; state_reset ( state ) ; state_transition ( state , insn ) ; for ( unit = <NUM_LIT> ; unit < ARRAY_SIZE ( frv_unit_codes ) ; unit ++ ) if ( cpu_unit_reservation_p ( state , frv_unit_codes [ unit ] ) ) break ; gcc_assert ( unit != ARRAY_SIZE ( frv_unit_codes ) ) ;


<s> reg = gen_rtx_REG ( insn_data [ icode ] . operand [ opnum ] . mode , ACC_FIRST + INTVAL ( opval ) ) ; if ( ! ( * insn_data [ icode ] . operand [ opnum ] . predicate ) ( reg , VOIDmode ) ) REGNO ( reg ) = ACCG_FIRST + INTVAL ( opval ) ; if ( ! ( * insn_data [ icode ] . operand [ opnum ] . predicate ) ( reg , VOIDmode ) ) { error ( <STR_LIT> , insn_data [ icode ] . name ) ; return NULL_RTX ; }


<s> rtx reg ; int i ; for ( i = <NUM_LIT> ; i <= ACC_MASK ; i ++ ) if ( ( i & ACC_MASK ) == i ) global_regs [ i + ACC_FIRST ] = global_regs [ i + ACCG_FIRST ] = <NUM_LIT> ; if ( GET_CODE ( opval ) != CONST_INT ) { error ( <STR_LIT> ) ; return NULL_RTX ; } if ( ( INTVAL ( opval ) & ~ ACC_MASK ) != <NUM_LIT> ) { error ( <STR_LIT> ) ;


<s> if ( frv_string_begins_with ( section_name , <STR_LIT> ) ) return true ; if ( frv_string_begins_with ( section_name , <STR_LIT> ) ) return true ; return false ; } size = int_size_in_bytes ( TREE_TYPE ( decl ) ) ; if ( size > <NUM_LIT> && ( unsigned HOST_WIDE_INT ) size <= g_switch_value ) return true ;


<s> HOST_WIDE_INT size ; tree section_name ; if ( TREE_CODE ( decl ) != VAR_DECL || DECL_ARTIFICIAL ( decl ) ) return false ; section_name = DECL_SECTION_NAME ( decl ) ; if ( section_name ) { gcc_assert ( TREE_CODE ( section_name ) == STRING_CST ) ; if ( frv_string_begins_with ( section_name , <STR_LIT> ) ) return true ; if ( frv_string_begins_with ( section_name , <STR_LIT> ) ) return true ; return false ; } size = int_size_in_bytes ( TREE_TYPE ( decl ) ) ;

if ( size > <NUM_LIT> && ( unsigned HOST_WIDE_INT ) size <= g_switch_value ) return true ;


if ( REG_P ( x ) && * other != <NUM_LIT> && reg_overlap_mentioned_p ( x , * other ) ) * other = <NUM_LIT> ;


<s> static void frv_io_check_address ( rtx x , rtx pat ATTRIBUTE_UNUSED , void * data ) { rtx * other = data ; if ( REG_P ( x ) && * other != <NUM_LIT> && reg_overlap_mentioned_p ( x , * other ) ) * other = <NUM_LIT> ;


<s> static void frv_io_handle_set ( rtx x , rtx pat ATTRIBUTE_UNUSED , void * data ) { HARD_REG_SET * set = data ; unsigned int regno ;

if ( REG_P ( x ) ) FOR_EACH_REGNO ( regno , x ) CLEAR_HARD_REG_BIT ( * set , regno ) ;


<s> HARD_REG_SET * set = data ; unsigned int regno ;


<s> for_each_rtx ( x , frv_io_handle_use_1 , data ) ;


<s> static int frv_io_handle_use_1 ( rtx * x , void * data ) { HARD_REG_SET * set = data ; unsigned int regno ;

if ( REG_P ( * x ) ) FOR_EACH_REGNO ( regno , * x ) SET_HARD_REG_BIT ( * set , regno ) ;


<s> static int frv_io_handle_use_1 ( rtx * x , void * data ) { HARD_REG_SET * set = data ; unsigned int regno ; if ( REG_P ( * x ) ) FOR_EACH_REGNO ( regno , * x ) SET_HARD_REG_BIT ( * set , regno ) ; return <NUM_LIT> ;


<s> static bool frv_issues_to_branch_unit_p ( rtx insn ) {

return frv_unit_groups [ frv_insn_unit ( insn ) ] == GROUP_B ;


<s> if ( GET_CODE ( x ) != REG ) break ; case REG : ret = frv_regno_ok_for_base_p ( REGNO ( x ) , strict_p ) ; break ; case PRE_MODIFY : x0 = XEXP ( x , <NUM_LIT> ) ; x1 = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( x0 ) != REG || ! frv_regno_ok_for_base_p ( REGNO ( x0 ) , strict_p ) || GET_CODE ( x1 ) != PLUS || ! rtx_equal_p ( x0 , XEXP ( x1 , <NUM_LIT> ) ) || GET_CODE ( XEXP ( x1 , <NUM_LIT> ) ) != REG || ! frv_regno_ok_for_base_p ( REGNO ( XEXP ( x1 , <NUM_LIT> ) ) , strict_p ) ) break ; ret = <NUM_LIT> ; break ; case CONST_INT : if ( condexec_p ) ret = FALSE ; else { ret = IN_RANGE_P ( INTVAL ( x ) , - <NUM_LIT> , <NUM_LIT> ) ; if ( ret && GET_MODE_SIZE ( mode ) > UNITS_PER_WORD ) ret = IN_RANGE_P ( INTVAL ( x ) + GET_MODE_SIZE ( mode ) - <NUM_LIT> , - <NUM_LIT> , <NUM_LIT> ) ; } break ; case PLUS : x0 = XEXP ( x , <NUM_LIT> ) ; x1 = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( x0 ) == SUBREG ) x0 = SUBREG_REG ( x0 ) ; if ( GET_CODE ( x0 ) != REG ) break ; regno0 = REGNO ( x0 ) ;

if ( ! frv_regno_ok_for_base_p ( regno0 , strict_p ) ) break ;


<s> int frv_legitimate_constant_p ( rtx x ) { enum machine_mode mode = GET_MODE ( x ) ; if ( TARGET_FDPIC ) return LEGITIMATE_PIC_OPERAND_P ( x ) ; if ( GET_CODE ( x ) != CONST_DOUBLE ) return TRUE ; if ( mode == VOIDmode || mode == DImode ) return TRUE ; if ( x == CONST0_RTX ( mode ) ) return TRUE ;


<s> int frv_legitimate_constant_p ( rtx x ) { enum machine_mode mode = GET_MODE ( x ) ; if ( TARGET_FDPIC ) return LEGITIMATE_PIC_OPERAND_P ( x ) ; if ( GET_CODE ( x ) != CONST_DOUBLE ) return TRUE ; if ( mode == VOIDmode || mode == DImode ) return TRUE ;

if ( x == CONST0_RTX ( mode ) ) return TRUE ;


<s> return ( ( GET_MODE ( op ) == mode || mode == VOIDmode ) && GET_CODE ( op ) == MEM && frv_legitimate_address_p ( mode , XEXP ( op , <NUM_LIT> ) , reload_completed , condexec_p , FALSE ) ) ;


<s> enum tls_model model = SYMBOL_REF_TLS_MODEL ( x ) ;

if ( model != <NUM_LIT> ) return frv_legitimize_tls_address ( x , model ) ;


<s> enum machine_mode mode = insn_data [ icode ] . operand [ opnum ] . mode ; if ( ( * insn_data [ icode ] . operand [ opnum ] . predicate ) ( arg , mode ) ) return arg ;

else return copy_to_mode_reg ( mode , arg ) ;


<s> enum machine_mode mode = insn_data [ icode ] . operand [ opnum ] . mode ;

if ( ( * insn_data [ icode ] . operand [ opnum ] . predicate ) ( arg , mode ) ) return arg ;


<s> enum machine_mode mode = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; if ( ! target || GET_MODE ( target ) != mode || ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( target , mode ) ) return gen_reg_rtx ( mode ) ; else return target ;


<s> dest = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_tlsoff_hilo ( tmp , addr , GEN_INT ( R_FRV_GOTTLSOFF_HI ) ) ) ; emit_insn ( gen_tls_tlsoff_ld ( dest , picreg , tmp , addr ) ) ; dest = gen_rtx_PLUS ( Pmode , tp , dest ) ; } break ; case TLS_MODEL_LOCAL_DYNAMIC : { rtx reg , retval ; if ( TARGET_INLINE_PLT ) retval = gen_inlined_tls_plt ( GEN_INT ( <NUM_LIT> ) ) ; else { retval = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_call_gettlsoff ( retval , GEN_INT ( <NUM_LIT> ) , picreg ) ) ; } reg = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_rtx_SET ( VOIDmode , reg , gen_rtx_PLUS ( Pmode , retval , tp ) ) ) ; dest = gen_tlsmoff ( addr , reg ) ; break ; }


<s> return HImode ; case SImode : return QImode ; default : gcc_unreachable ( ) ;


<s> static bool frv_must_pass_in_stack ( enum machine_mode mode , tree type ) {


<s> if ( level >= <NUM_LIT> ) { flag_schedule_insns_after_reload = <NUM_LIT> ; flag_rcsp = <NUM_LIT> ;


<s> compute_bb_for_insn ( ) ; first_io = xcalloc ( last_basic_block , sizeof ( struct frv_io ) ) ; last_membar = xcalloc ( last_basic_block , sizeof ( rtx ) ) ; FOR_EACH_BB ( bb ) frv_optimize_membar_local ( bb , & first_io [ bb -> index ] , & last_membar [ bb -> index ] ) ;

FOR_EACH_BB ( bb ) if ( last_membar [ bb -> index ] != <NUM_LIT> ) frv_optimize_membar_global ( bb , first_io , last_membar [ bb -> index ] ) ;


<s> FOR_EACH_BB ( bb ) if ( last_membar [ bb -> index ] != <NUM_LIT> ) frv_optimize_membar_global ( bb , first_io , last_membar [ bb -> index ] ) ; free ( first_io ) ; free ( last_membar ) ;


<s> CLEAR_HARD_REG_SET ( used_regs ) ; for ( insn = BB_END ( bb ) ; insn != BB_HEAD ( bb ) ; insn = PREV_INSN ( insn ) ) if ( GET_CODE ( insn ) == CALL_INSN ) { memset ( next_io , <NUM_LIT> , sizeof ( struct frv_io ) ) ; next_is_end_p = false ; CLEAR_HARD_REG_SET ( used_regs ) ; } else if ( INSN_P ( insn ) ) switch ( recog_memoized ( insn ) ) { case CODE_FOR_optional_membar_qi : case CODE_FOR_optional_membar_hi : case CODE_FOR_optional_membar_si : case CODE_FOR_optional_membar_di : next_membar = insn ; if ( next_is_end_p ) { * last_membar = insn ; frv_extract_membar ( next_io , insn ) ; next_is_end_p = false ; } else { struct frv_io prev_io ; frv_extract_membar ( & prev_io , insn ) ; if ( frv_io_fixed_order_p ( & prev_io , next_io ) ) { if ( dump_file ) fprintf ( dump_file , <STR_LIT> <STR_LIT> , INSN_UID ( next_membar ) ) ; insn = NEXT_INSN ( insn ) ; delete_insn ( next_membar ) ; next_membar = <NUM_LIT> ; } * next_io = prev_io ; } break ; default : if ( next_io -> var_address ) note_stores ( PATTERN ( insn ) , frv_io_check_address , & next_io -> var_address ) ; set = PATTERN ( insn ) ; if ( next_io -> type == FRV_IO_READ && next_io -> var_address != <NUM_LIT> && next_membar != <NUM_LIT> && GET_CODE ( set ) == SET && GET_CODE ( SET_DEST ( set ) ) == REG && TEST_HARD_REG_BIT ( used_regs , REGNO ( SET_DEST ( set ) ) ) ) {


<s> output_addr_const ( stream , plus_constant ( unspec -> symbol , unspec -> offset ) ) ; fputs ( <STR_LIT> , stream ) ;


<s> gcc_assert ( size == <NUM_LIT> ) ; fputs ( <STR_LIT> , file ) ; output_addr_const ( file , plus_constant ( x , TLS_BIAS ) ) ; fputs ( <STR_LIT> , file ) ;


<s> fputs ( <STR_LIT> , file ) ; output_addr_const ( file , plus_constant ( x , TLS_BIAS ) ) ;


<s> else if ( regno == LR_REGNO ) class = LR_REG ; else if ( regno == LCR_REGNO ) class = LCR_REG ; else if ( ICC_P ( regno ) ) class = ICC_REGS ; else if ( FCC_P ( regno ) ) class = FCC_REGS ; else if ( ICR_P ( regno ) ) class = ICR_REGS ; else if ( FCR_P ( regno ) ) class = FCR_REGS ; else if ( ACC_P ( regno ) ) { int r = regno - ACC_FIRST ; if ( ( r & <NUM_LIT> ) == <NUM_LIT> ) class = QUAD_ACC_REGS ; else if ( ( r & <NUM_LIT> ) == <NUM_LIT> ) class = EVEN_ACC_REGS ; else class = ACC_REGS ; } else if ( ACCG_P ( regno ) ) class = ACCG_REGS ; else class = NO_REGS ; regno_reg_class [ regno ] = class ; } if ( ! g_switch_set ) g_switch_value = SDATA_DEFAULT_SIZE ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) reg_class_from_letter [ i ] = NO_REGS ; reg_class_from_letter [ 'a' ] = ACC_REGS ; reg_class_from_letter [ 'b' ] = EVEN_ACC_REGS ; reg_class_from_letter [ 'c' ] = CC_REGS ; reg_class_from_letter [ 'd' ] = GPR_REGS ; reg_class_from_letter [ 'e' ] = EVEN_REGS ; reg_class_from_letter [ 'f' ] = FPR_REGS ; reg_class_from_letter [ 'h' ] = FEVEN_REGS ; reg_class_from_letter [ 'l' ] = LR_REG ; reg_class_from_letter [ 'q' ] = QUAD_REGS ; reg_class_from_letter [ 't' ] = ICC_REGS ; reg_class_from_letter [ 'u' ] = FCC_REGS ; reg_class_from_letter [ 'v' ] = ICR_REGS ; reg_class_from_letter [ 'w' ] = FCR_REGS ; reg_class_from_letter [ 'x' ] = QUAD_FPR_REGS ; reg_class_from_letter [ 'y' ] = LCR_REG ; reg_class_from_letter [ 'z' ] = SPR_REGS ; reg_class_from_letter [ 'A' ] = QUAD_ACC_REGS ; reg_class_from_letter [ 'B' ] = ACCG_REGS ; reg_class_from_letter [ 'C' ] = CR_REGS ; reg_class_from_letter [ 'W' ] = FDPIC_CALL_REGS ; reg_class_from_letter [ 'Z' ] = FDPIC_REGS ; if ( flag_pic || TARGET_FDPIC ) targetm . asm_out . unaligned_op . si = <NUM_LIT> ; if ( ( target_flags_explicit & MASK_LINKED_FP ) == <NUM_LIT> ) target_flags |= MASK_LINKED_FP ; if ( ( target_flags_explicit & MASK_OPTIMIZE_MEMBAR ) == <NUM_LIT> ) target_flags |= MASK_OPTIMIZE_MEMBAR ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( frv_unit_names ) ; i ++ ) frv_unit_codes [ i ] = get_cpu_unit_code ( frv_unit_names [ i ] ) ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( frv_type_to_unit ) ; i ++ ) frv_type_to_unit [ i ] = ARRAY_SIZE ( frv_unit_codes ) ;


<s> void frv_override_options ( void ) { int regno ; unsigned int i ; target_flags |= ( frv_default_flags_for_cpu ( ) & ~ target_flags_explicit ) ; if ( TARGET_LIBPIC ) { if ( ! flag_pic ) flag_pic = <NUM_LIT> ; if ( ! g_switch_set ) { g_switch_set = <NUM_LIT> ; g_switch_value = <NUM_LIT> ; } } for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) { enum reg_class class ; if ( GPR_P ( regno ) ) { int gpr_reg = regno - GPR_FIRST ; if ( gpr_reg == GR8_REG ) class = GR8_REGS ; else if ( gpr_reg == GR9_REG ) class = GR9_REGS ; else if ( gpr_reg == GR14_REG ) class = FDPIC_FPTR_REGS ; else if ( gpr_reg == FDPIC_REGNO ) class = FDPIC_REGS ; else if ( ( gpr_reg & <NUM_LIT> ) == <NUM_LIT> ) class = QUAD_REGS ; else if ( ( gpr_reg & <NUM_LIT> ) == <NUM_LIT> ) class = EVEN_REGS ; else class = GPR_REGS ; } else if ( FPR_P ( regno ) ) { int fpr_reg = regno - GPR_FIRST ; if ( ( fpr_reg & <NUM_LIT> ) == <NUM_LIT> ) class = QUAD_FPR_REGS ; else if ( ( fpr_reg & <NUM_LIT> ) == <NUM_LIT> ) class = FEVEN_REGS ; else class = FPR_REGS ; } else if ( regno == LR_REGNO ) class = LR_REG ; else if ( regno == LCR_REGNO ) class = LCR_REG ; else if ( ICC_P ( regno ) ) class = ICC_REGS ; else if ( FCC_P ( regno ) ) class = FCC_REGS ; else if ( ICR_P ( regno ) ) class = ICR_REGS ; else if ( FCR_P ( regno ) ) class = FCR_REGS ; else if ( ACC_P ( regno ) ) { int r = regno - ACC_FIRST ; if ( ( r & <NUM_LIT> ) == <NUM_LIT> ) class = QUAD_ACC_REGS ; else if ( ( r & <NUM_LIT> ) == <NUM_LIT> ) class = EVEN_ACC_REGS ; else class = ACC_REGS ; } else if ( ACCG_P ( regno ) ) class = ACCG_REGS ; else class = NO_REGS ; regno_reg_class [ regno ] = class ; } if ( ! g_switch_set ) g_switch_value = SDATA_DEFAULT_SIZE ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) reg_class_from_letter [ i ] = NO_REGS ; reg_class_from_letter [ 'a' ] = ACC_REGS ; reg_class_from_letter [ 'b' ] = EVEN_ACC_REGS ; reg_class_from_letter [ 'c' ] = CC_REGS ; reg_class_from_letter [ 'd' ] = GPR_REGS ; reg_class_from_letter [ 'e' ] = EVEN_REGS ; reg_class_from_letter [ 'f' ] = FPR_REGS ; reg_class_from_letter [ 'h' ] = FEVEN_REGS ; reg_class_from_letter [ 'l' ] = LR_REG ; reg_class_from_letter [ 'q' ] = QUAD_REGS ; reg_class_from_letter [ 't' ] = ICC_REGS ; reg_class_from_letter [ 'u' ] = FCC_REGS ;

reg_class_from_letter [ 'v' ] = ICR_REGS ;


<s> static bool frv_pack_insn_p ( rtx insn ) { if ( frv_packet . num_insns == frv_packet . issue_rate ) return false ; if ( frv_packet . num_insns > <NUM_LIT> && GET_CODE ( insn ) == INSN && GET_MODE ( insn ) == TImode && GET_CODE ( PATTERN ( insn ) ) != COND_EXEC ) return false ; if ( get_attr_type ( insn ) != TYPE_SETLO ) if ( frv_registers_conflict_p ( PATTERN ( insn ) ) ) return false ;

return state_transition ( frv_packet . dfa_state , insn ) < <NUM_LIT> ;


<s> if ( frv_packet . num_insns > <NUM_LIT> && GET_CODE ( insn ) == INSN && GET_MODE ( insn ) == TImode && GET_CODE ( PATTERN ( insn ) ) != COND_EXEC ) return false ; if ( get_attr_type ( insn ) != TYPE_SETLO ) if ( frv_registers_conflict_p ( PATTERN ( insn ) ) ) return false ; return state_transition ( frv_packet . dfa_state , insn ) < <NUM_LIT> ;


<s> assemble_name ( stream , XSTR ( x , <NUM_LIT> ) ) ; return ; case LABEL_REF : case CONST : output_addr_const ( stream , x ) ; return ; default : break ; }


<s> fputs ( reg_names [ REGNO ( x ) ] , stream ) ; return ; case CONST_INT : fprintf ( stream , <STR_LIT> , ( long ) INTVAL ( x ) ) ; return ; case SYMBOL_REF : assemble_name ( stream , XSTR ( x , <NUM_LIT> ) ) ; return ; case LABEL_REF :


<s> ret = ( ( prob >= ( REG_BR_PROB_BASE / <NUM_LIT> ) ) ? FRV_JUMP_LIKELY : FRV_JUMP_NOT_LIKELY ) ; } } if ( TARGET_DEBUG ) { char * direction ; switch ( jump_type ) { default : case UNKNOWN : direction = <STR_LIT> ; break ; case BACKWARD : direction = <STR_LIT> ; break ; case FORWARD : direction = <STR_LIT> ; break ; } fprintf ( stderr , <STR_LIT> , IDENTIFIER_POINTER ( DECL_NAME ( current_function_decl ) ) , ( long ) INSN_UID ( insn ) , direction , ( long ) prob , ( long ) REG_BR_PROB_BASE , ret ) ; }


<s> static rtx frv_read_argument ( tree * arglistptr ) {

tree next = TREE_VALUE ( * arglistptr ) ;


<s> tree next = TREE_VALUE ( * arglistptr ) ;

* arglistptr = TREE_CHAIN ( * arglistptr ) ;


<s> op = const0_rtx ; } regno = INTVAL ( op ) + IACC_FIRST ; for ( i = <NUM_LIT> ; i < HARD_REGNO_NREGS ( regno , mode ) ; i ++ ) global_regs [ regno + i ] = <NUM_LIT> ;


<s> if ( GET_CODE ( op ) != CONST_INT || INTVAL ( op ) < <NUM_LIT> || INTVAL ( op ) > IACC_LAST - IACC_FIRST || ( ( INTVAL ( op ) * <NUM_LIT> ) & ( GET_MODE_SIZE ( mode ) - <NUM_LIT> ) ) != <NUM_LIT> ) {


<s> regstate_t flags ; flags = <NUM_LIT> ; if ( GET_CODE ( x ) == COND_EXEC ) { if ( for_each_rtx ( & XEXP ( x , <NUM_LIT> ) , frv_registers_conflict_p_1 , & flags ) ) return true ; flags |= frv_cond_flags ( XEXP ( x , <NUM_LIT> ) ) ; x = XEXP ( x , <NUM_LIT> ) ; } return for_each_rtx ( & x , frv_registers_conflict_p_1 , & flags ) ;


<s> if ( GET_CODE ( x ) == COND_EXEC ) { if ( for_each_rtx ( & XEXP ( x , <NUM_LIT> ) , frv_registers_conflict_p_1 , & flags ) ) return true ; flags |= frv_cond_flags ( XEXP ( x , <NUM_LIT> ) ) ; x = XEXP ( x , <NUM_LIT> ) ; } return for_each_rtx ( & x , frv_registers_conflict_p_1 , & flags ) ;


<s> if ( true_dependence ( frv_packet . mems [ i ] . mem , VOIDmode , * x , rtx_varies_p ) ) return <NUM_LIT> ; if ( output_dependence ( frv_packet . mems [ i ] . mem , * x ) ) return <NUM_LIT> ; } } if ( GET_CODE ( * x ) == SET && GET_CODE ( SET_SRC ( * x ) ) == CALL ) {

if ( for_each_rtx ( & SET_SRC ( * x ) , frv_registers_conflict_p_1 , data ) ) return <NUM_LIT> ;


<s> flags = REGSTATE_MODIFIED ; if ( GET_CODE ( x ) == COND_EXEC ) { flags |= frv_cond_flags ( XEXP ( x , <NUM_LIT> ) ) ; x = XEXP ( x , <NUM_LIT> ) ;


<s> if ( GET_CODE ( x ) == REG ) FOR_EACH_REGNO ( regno , x ) frv_packet . regstate [ regno ] |= * ( regstate_t * ) data ; if ( GET_CODE ( x ) == MEM ) { if ( frv_packet . num_mems < ARRAY_SIZE ( frv_packet . mems ) ) { frv_packet . mems [ frv_packet . num_mems ] . mem = x ;

frv_packet . mems [ frv_packet . num_mems ] . cond = * ( regstate_t * ) data ;


<s> unsigned int regno ; if ( GET_CODE ( x ) == REG ) FOR_EACH_REGNO ( regno , x ) frv_packet . regstate [ regno ] |= * ( regstate_t * ) data ; if ( GET_CODE ( x ) == MEM ) { if ( frv_packet . num_mems < ARRAY_SIZE ( frv_packet . mems ) ) { frv_packet . mems [ frv_packet . num_mems ] . mem = x ; frv_packet . mems [ frv_packet . num_mems ] . cond = * ( regstate_t * ) data ; } frv_packet . num_mems ++ ; }


<s> case LR_REG : case SPR_REGS : return LOW_COST ; } case FEVEN_REGS : case FPR_REGS : switch ( to ) { default : break ; case QUAD_REGS : case EVEN_REGS : case GPR_REGS : case ACC_REGS : case EVEN_ACC_REGS : case QUAD_ACC_REGS : case ACCG_REGS : return MEDIUM_COST ; case FEVEN_REGS : case FPR_REGS : return LOW_COST ; } case LCR_REG : case LR_REG : case SPR_REGS : switch ( to ) { default : break ; case QUAD_REGS : case EVEN_REGS : case GPR_REGS : return MEDIUM_COST ; } case ACC_REGS : case EVEN_ACC_REGS : case QUAD_ACC_REGS : case ACCG_REGS :


<s> static void frv_register_nop ( rtx nop ) {


<s> for ( unit = <NUM_LIT> ; unit < ARRAY_SIZE ( frv_unit_groups ) ; unit ++ ) { group = frv_unit_groups [ unit ] ; packet_group = & frv_packet . groups [ group ] ; if ( cursor [ group ] < packet_group -> num_insns ) { gcc_assert ( packet_group -> sorted [ cursor [ group ] ] != packet_group -> nop ) ; insns [ to ++ ] = packet_group -> sorted [ cursor [ group ] ++ ] ; } } gcc_assert ( to == frv_packet . num_insns ) ; CLEAR_PACKING_FLAG ( insns [ to - <NUM_LIT> ] ) ; for ( from = <NUM_LIT> ; from < to - <NUM_LIT> ; from ++ ) { remove_insn ( insns [ from ] ) ; add_insn_before ( insns [ from ] , insns [ to - <NUM_LIT> ] ) ;


<s> if ( count != <NUM_LIT> ) return const0_rtx ; cfun -> machine -> frame_needed = <NUM_LIT> ; return gen_rtx_MEM ( Pmode , plus_constant ( frame , <NUM_LIT> ) ) ;


<s> } switch ( code ) { case CONST_INT : if ( IN_RANGE_P ( INTVAL ( x ) , - <NUM_LIT> , <NUM_LIT> ) ) { * total = <NUM_LIT> ; return true ; } case CONST : case LABEL_REF : case SYMBOL_REF : case CONST_DOUBLE : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case PLUS : case MINUS : case AND : case IOR : case XOR : case ASHIFT : case ASHIFTRT : case LSHIFTRT : case NOT : case NEG : case COMPARE : if ( GET_MODE ( x ) == SImode ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( GET_MODE ( x ) == DImode ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case MULT : if ( GET_MODE ( x ) == SImode ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ;


<s> case SYMBOL_REF : case CONST_DOUBLE : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case PLUS : case MINUS : case AND : case IOR : case XOR : case ASHIFT : case ASHIFTRT : case LSHIFTRT : case NOT : case NEG : case COMPARE : if ( GET_MODE ( x ) == SImode ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( GET_MODE ( x ) == DImode ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ;


<s> return y == const0_rtx ? CC_NZmode : CCmode ; case GTU : case GEU : case LTU : case LEU : return y == const0_rtx ? CC_NZmode : CC_UNSmode ; default :


<s> insn = packet_group -> sorted [ i ] ; memcpy ( test_state , state , dfa_size ) ; if ( state_transition ( test_state , insn ) < <NUM_LIT> && cpu_unit_reservation_p ( test_state , NTH_UNIT ( group , upper_slot - <NUM_LIT> ) ) && frv_sort_insn_group_1 ( group , lower_slot , upper_slot - <NUM_LIT> , issued | ( <NUM_LIT> << i ) , num_insns , test_state ) ) { packet_group -> sorted [ upper_slot - <NUM_LIT> ] = insn ;


<s> size_t dfa_size ; rtx insn ; if ( lower_slot == upper_slot ) return true ; packet_group = & frv_packet . groups [ group ] ; dfa_size = state_size ( ) ; test_state = alloca ( dfa_size ) ; for ( i = num_insns - <NUM_LIT> ; i + <NUM_LIT> != <NUM_LIT> ; i -- ) if ( ~ issued & ( <NUM_LIT> << i ) ) { insn = packet_group -> sorted [ i ] ; memcpy ( test_state , state , dfa_size ) ; if ( state_transition ( test_state , insn ) < <NUM_LIT> && cpu_unit_reservation_p ( test_state , NTH_UNIT ( group , upper_slot - <NUM_LIT> ) ) && frv_sort_insn_group_1 ( group , lower_slot , upper_slot - <NUM_LIT> , issued | ( <NUM_LIT> << i ) , num_insns , test_state ) ) { packet_group -> sorted [ upper_slot - <NUM_LIT> ] = insn ; return true ;


<s> rtx cr_reg = operands [ <NUM_LIT> ] ; rtx ret ; start_sequence ( ) ; emit_insn ( gen_rtx_SET ( VOIDmode , cc_reg , gen_rtx_COMPARE ( CCmode , src , const0_rtx ) ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , cr_reg , gen_rtx_fmt_ee ( LT , CC_CCRmode , cc_reg , const0_rtx ) ) ) ; emit_insn ( gen_rtx_COND_EXEC ( VOIDmode , gen_rtx_NE ( CC_CCRmode , cr_reg , const0_rtx ) , gen_negsi2 ( dest , src ) ) ) ;

if ( ! rtx_equal_p ( dest , src ) ) emit_insn ( gen_rtx_COND_EXEC ( VOIDmode , gen_rtx_EQ ( CC_CCRmode , cr_reg , const0_rtx ) , gen_rtx_SET ( VOIDmode , dest , src ) ) ) ;


<s> if ( GET_CODE ( src1 ) == CONST_INT && GET_CODE ( src2 ) == CONST_INT ) { HOST_WIDE_INT value1 = INTVAL ( src1 ) ; HOST_WIDE_INT value2 = INTVAL ( src2 ) ; if ( value1 == <NUM_LIT> ) { emit_move_insn ( dest , src2 ) ; emit_insn ( gen_rtx_COND_EXEC ( VOIDmode , gen_rtx_NE ( cr_mode , cr_reg , const0_rtx ) , gen_rtx_SET ( VOIDmode , dest , src1 ) ) ) ; } else if ( value2 == <NUM_LIT> ) { emit_move_insn ( dest , src1 ) ; emit_insn ( gen_rtx_COND_EXEC ( VOIDmode , gen_rtx_EQ ( cr_mode , cr_reg , const0_rtx ) , gen_rtx_SET ( VOIDmode , dest , src2 ) ) ) ; }


<s> HOST_WIDE_INT value1 = INTVAL ( src1 ) ; HOST_WIDE_INT value2 = INTVAL ( src2 ) ; if ( value1 == <NUM_LIT> ) { emit_move_insn ( dest , src2 ) ; emit_insn ( gen_rtx_COND_EXEC ( VOIDmode , gen_rtx_NE ( cr_mode , cr_reg , const0_rtx ) , gen_rtx_SET ( VOIDmode , dest , src1 ) ) ) ; } else if ( value2 == <NUM_LIT> ) { emit_move_insn ( dest , src1 ) ; emit_insn ( gen_rtx_COND_EXEC ( VOIDmode , gen_rtx_EQ ( cr_mode , cr_reg , const0_rtx ) , gen_rtx_SET ( VOIDmode , dest , src2 ) ) ) ; } else if ( IN_RANGE_P ( value1 , - <NUM_LIT> , <NUM_LIT> ) && IN_RANGE_P ( value2 - value1 , - <NUM_LIT> , <NUM_LIT> ) ) { rtx dest_si = ( ( GET_MODE ( dest ) == SImode ) ? dest : gen_rtx_SUBREG ( SImode , dest , <NUM_LIT> ) ) ; emit_move_insn ( dest_si , GEN_INT ( value2 - value1 ) ) ; emit_insn ( gen_rtx_COND_EXEC ( VOIDmode , gen_rtx_NE ( cr_mode , cr_reg , const0_rtx ) , gen_rtx_SET ( VOIDmode , dest_si , const0_rtx ) ) ) ; emit_insn ( gen_addsi3 ( dest_si , dest_si , src1 ) ) ;


<s> rtx address = XEXP ( source , <NUM_LIT> ) ; if ( GET_CODE ( address ) == PRE_MODIFY || ! refers_to_regno_p ( regno , regno + <NUM_LIT> , address , NULL ) ) { emit_move_insn ( dest1 , change_address ( source , SImode , NULL ) ) ; emit_move_insn ( dest2 , frv_index_memory ( source , SImode , <NUM_LIT> ) ) ; }


<s> int regno = REGNO ( dest ) ; rtx dest1 = gen_highpart ( SImode , dest ) ; rtx dest2 = gen_lowpart ( SImode , dest ) ; rtx address = XEXP ( source , <NUM_LIT> ) ; if ( GET_CODE ( address ) == PRE_MODIFY || ! refers_to_regno_p ( regno , regno + <NUM_LIT> , address , NULL ) ) { emit_move_insn ( dest1 , change_address ( source , SImode , NULL ) ) ; emit_move_insn ( dest2 , frv_index_memory ( source , SImode , <NUM_LIT> ) ) ; }


<s> if ( GET_CODE ( src2 ) == CONST_INT && INTVAL ( src2 ) != <NUM_LIT> ) { gcc_assert ( ! rtx_equal_p ( dest , src1 ) ) ; emit_move_insn ( dest , src2 ) ; emit_insn ( gen_rtx_COND_EXEC ( VOIDmode , gen_rtx_NE ( cr_mode , cr_reg , const0_rtx ) , gen_rtx_SET ( VOIDmode , dest , src1 ) ) ) ; } else { if ( ! rtx_equal_p ( dest , src1 ) ) emit_insn ( gen_rtx_COND_EXEC ( VOIDmode , gen_rtx_NE ( cr_mode , cr_reg , const0_rtx ) , gen_rtx_SET ( VOIDmode , dest , src1 ) ) ) ;

if ( ! rtx_equal_p ( dest , src2 ) ) emit_insn ( gen_rtx_COND_EXEC ( VOIDmode , gen_rtx_EQ ( cr_mode , cr_reg , const0_rtx ) , gen_rtx_SET ( VOIDmode , dest , src2 ) ) ) ;


<s> emit_insn ( gen_rtx_COND_EXEC ( VOIDmode , gen_rtx_EQ ( GET_MODE ( cr_reg ) , cr_reg , const0_rtx ) , gen_rtx_SET ( VOIDmode , dest , const0_rtx ) ) ) ; ret = get_insns ( ) ; end_sequence ( ) ;


<s> start_sequence ( ) ; emit_insn ( gen_rtx_SET ( VOIDmode , cr_reg , gen_rtx_fmt_ee ( GET_CODE ( test ) , GET_MODE ( cr_reg ) , cc_reg , const0_rtx ) ) ) ; emit_move_insn ( dest , GEN_INT ( value ) ) ;

emit_insn ( gen_rtx_COND_EXEC ( VOIDmode , gen_rtx_EQ ( GET_MODE ( cr_reg ) , cr_reg , const0_rtx ) , gen_rtx_SET ( VOIDmode , dest , const0_rtx ) ) ) ;


for ( group = <NUM_LIT> ; group < NUM_GROUPS ; group ++ ) frv_packet . groups [ group ] . num_insns = <NUM_LIT> ;


<s> for ( group = <NUM_LIT> ; group < NUM_GROUPS ; group ++ ) frv_packet . groups [ group ] . num_insns = <NUM_LIT> ;


<s> return ( TREE_STRING_LENGTH ( name ) > prefix_len && strncmp ( TREE_STRING_POINTER ( name ) , prefix , prefix_len ) == <NUM_LIT> ) ;


if ( ACC_P ( regno ) || ACCG_P ( regno ) ) ret = FPR_REGS ;


<s> if ( GET_CODE ( dest ) == REG ) { int dest_regno = REGNO ( dest ) ; enum machine_mode mode = GET_MODE ( dest ) ; if ( GPR_P ( dest_regno ) ) { if ( GET_CODE ( src ) == REG ) { int src_regno = REGNO ( src ) ; if ( GPR_P ( src_regno ) ) return <STR_LIT> ; else if ( FPR_P ( src_regno ) ) return <STR_LIT> ; } else if ( GET_CODE ( src ) == MEM ) { switch ( mode ) { default : break ; case QImode : return <STR_LIT> ; case HImode : return <STR_LIT> ; case SImode : case SFmode : return <STR_LIT> ; } } else if ( ZERO_P ( src ) ) return <STR_LIT> ; } else if ( FPR_P ( dest_regno ) ) { if ( GET_CODE ( src ) == REG ) { int src_regno = REGNO ( src ) ; if ( GPR_P ( src_regno ) ) return <STR_LIT> ; else if ( FPR_P ( src_regno ) ) { if ( TARGET_HARD_FLOAT ) return <STR_LIT> ; else return <STR_LIT> ; } } else if ( GET_CODE ( src ) == MEM ) { if ( mode == SImode || mode == SFmode ) return <STR_LIT> ; } else if ( ZERO_P ( src ) ) return <STR_LIT> ; } } else if ( GET_CODE ( dest ) == MEM ) { if ( GET_CODE ( src ) == REG ) { int src_regno = REGNO ( src ) ; enum machine_mode mode = GET_MODE ( dest ) ; if ( GPR_P ( src_regno ) ) { switch ( mode ) { default : break ; case QImode :


<s> if ( dbl_memory_one_insn_operand ( src , mode ) ) return <STR_LIT> ; return <STR_LIT> ; } else if ( ZERO_P ( src ) ) return <STR_LIT> ; } } else if ( GET_CODE ( dest ) == MEM ) { if ( GET_CODE ( src ) == REG ) { int src_regno = REGNO ( src ) ; if ( GPR_P ( src_regno ) ) { if ( ( ( src_regno - GPR_FIRST ) & <NUM_LIT> ) == <NUM_LIT> && dbl_memory_one_insn_operand ( dest , mode ) ) return <STR_LIT> ; return <STR_LIT> ; } if ( FPR_P ( src_regno ) ) { if ( ( ( src_regno - FPR_FIRST ) & <NUM_LIT> ) == <NUM_LIT> && dbl_memory_one_insn_operand ( dest , mode ) ) return <STR_LIT> ; return <STR_LIT> ; } } else if ( ZERO_P ( src ) ) { if ( dbl_memory_one_insn_operand ( dest , mode ) ) return <STR_LIT> ;


<s> default : break ; case QImode : return <STR_LIT> ; case HImode : return <STR_LIT> ; case SImode : case SFmode : return <STR_LIT> ; } } else if ( ZERO_P ( src ) ) return <STR_LIT> ; } else if ( SPR_P ( dest_regno ) ) { if ( GET_CODE ( src ) == REG ) { int src_regno = REGNO ( src ) ; if ( GPR_P ( src_regno ) ) return <STR_LIT> ; } else if ( ZERO_P ( src ) ) return <STR_LIT> ; } } else if ( GET_CODE ( dest ) == MEM ) { if ( GET_CODE ( src ) == REG ) { int src_regno = REGNO ( src ) ; enum machine_mode mode = GET_MODE ( dest ) ; if ( GPR_P ( src_regno ) ) { switch ( mode ) { default : break ; case QImode : return <STR_LIT> ; case HImode : return <STR_LIT> ; case SImode : case SFmode : return <STR_LIT> ; } } else if ( FPR_P ( src_regno ) ) { switch ( mode ) { default : break ; case QImode : return <STR_LIT> ; case HImode : return <STR_LIT> ; case SImode : case SFmode : return <STR_LIT> ; } } } else if ( ZERO_P ( src ) ) { switch ( GET_MODE ( dest ) ) { default : break ; case QImode : return <STR_LIT> ; case HImode : return <STR_LIT> ; case SImode :


<s> } else if ( GET_CODE ( src ) == MEM ) { switch ( mode ) { default : break ; case QImode : return <STR_LIT> ; case HImode : return <STR_LIT> ; case SImode : case SFmode : return <STR_LIT> ; } } else if ( GET_CODE ( src ) == CONST_INT || GET_CODE ( src ) == CONST_DOUBLE ) { HOST_WIDE_INT value ; if ( GET_CODE ( src ) == CONST_INT ) value = INTVAL ( src ) ; else if ( mode == SFmode ) { REAL_VALUE_TYPE rv ; long l ; REAL_VALUE_FROM_CONST_DOUBLE ( rv , src ) ; REAL_VALUE_TO_TARGET_SINGLE ( rv , l ) ; value = l ; } else value = CONST_DOUBLE_LOW ( src ) ; if ( IN_RANGE_P ( value , - <NUM_LIT> , <NUM_LIT> ) ) return <STR_LIT> ; return <STR_LIT> ; } else if ( GET_CODE ( src ) == SYMBOL_REF || GET_CODE ( src ) == LABEL_REF || GET_CODE ( src ) == CONST ) { return <STR_LIT> ; } } else if ( FPR_P ( dest_regno ) ) { if ( GET_CODE ( src ) == REG ) { int src_regno = REGNO ( src ) ; if ( GPR_P ( src_regno ) ) return <STR_LIT> ; else if ( FPR_P ( src_regno ) ) { if ( TARGET_HARD_FLOAT ) return <STR_LIT> ; else return <STR_LIT> ; } } else if ( GET_CODE ( src ) == MEM ) { switch ( mode ) { default : break ; case QImode : return <STR_LIT> ; case HImode : return <STR_LIT> ; case SImode : case SFmode : return <STR_LIT> ; } } else if ( ZERO_P ( src ) ) return <STR_LIT> ; } else if ( SPR_P ( dest_regno ) ) { if ( GET_CODE ( src ) == REG ) { int src_regno = REGNO ( src ) ; if ( GPR_P ( src_regno ) ) return <STR_LIT> ; } else if ( ZERO_P ( src ) ) return <STR_LIT> ; } } else if ( GET_CODE ( dest ) == MEM ) { if ( GET_CODE ( src ) == REG ) { int src_regno = REGNO ( src ) ; enum machine_mode mode = GET_MODE ( dest ) ; if ( GPR_P ( src_regno ) ) { switch ( mode ) { default : break ; case QImode : return <STR_LIT> ; case HImode : return <STR_LIT> ; case SImode : case SFmode : return <STR_LIT> ; } } else if ( FPR_P ( src_regno ) ) { switch ( mode ) { default : break ; case QImode : return <STR_LIT> ; case HImode : return <STR_LIT> ; case SImode : case SFmode : return <STR_LIT> ; } } } else if ( ZERO_P ( src ) ) { switch ( GET_MODE ( dest ) ) {


<s> rtx addr ; if ( mode != VOIDmode && op_mode != mode ) return FALSE ; switch ( op_mode ) { default : return FALSE ; case QImode : case HImode : case SImode :


<s> prev = cur ; } gcc_assert ( cur ) ; if ( prev && ! DECL_PACKED ( field ) && ! integer_zerop ( DECL_SIZE ( field ) ) && DECL_BIT_FIELD_TYPE ( field ) != DECL_BIT_FIELD_TYPE ( prev ) ) { int prev_align = TYPE_ALIGN ( TREE_TYPE ( prev ) ) ; int cur_align = TYPE_ALIGN ( TREE_TYPE ( field ) ) ; computed = ( prev_align > cur_align ) ? prev_align : cur_align ; } }


<s> tree parent = DECL_CONTEXT ( field ) ; tree prev = NULL_TREE ; tree cur ; for ( cur = TYPE_FIELDS ( parent ) ; cur && cur != field ; cur = DECL_CHAIN ( cur ) ) { if ( TREE_CODE ( cur ) != FIELD_DECL ) continue ; prev = cur ; } gcc_assert ( cur ) ; if ( prev && ! DECL_PACKED ( field ) && ! integer_zerop ( DECL_SIZE ( field ) ) && DECL_BIT_FIELD_TYPE ( field ) != DECL_BIT_FIELD_TYPE ( prev ) ) { int prev_align = TYPE_ALIGN ( TREE_TYPE ( prev ) ) ; int cur_align = TYPE_ALIGN ( TREE_TYPE ( field ) ) ; computed = ( prev_align > cur_align ) ? prev_align : cur_align ; } } return computed ;


<s> if ( LABEL_P ( x ) ) { unsigned int subalign = <NUM_LIT> << label_to_alignment ( x ) ; alignment = MAX ( alignment , subalign ) ; label = x ; } if ( BARRIER_P ( x ) ) barrier = x ; } if ( TARGET_ALIGN_LABELS && label != <NUM_LIT> && barrier == <NUM_LIT> && frv_packet . num_insns < frv_packet . issue_rate ) alignment = MAX ( alignment , <NUM_LIT> ) ; frv_packet_address += frv_packet . num_insns * <NUM_LIT> ; target = ( frv_packet_address + alignment - <NUM_LIT> ) & - alignment ; if ( barrier == <NUM_LIT> ) { for ( nop = <NUM_LIT> ; nop < frv_num_nops ; nop ++ ) while ( frv_packet_address < target && frv_pack_insn_p ( frv_nops [ nop ] ) ) { frv_insert_nop_in_packet ( frv_nops [ nop ] ) ; frv_packet_address += <NUM_LIT> ; } last = frv_packet . insns [ frv_packet . num_insns - <NUM_LIT> ] ; nop = <NUM_LIT> ; while ( frv_packet_address < target ) {

last = emit_insn_after ( PATTERN ( frv_nops [ nop ] ) , last ) ;


<s> alignment = MAX ( alignment , subalign ) ; label = x ; } if ( BARRIER_P ( x ) ) barrier = x ; } if ( TARGET_ALIGN_LABELS && label != <NUM_LIT> && barrier == <NUM_LIT> && frv_packet . num_insns < frv_packet . issue_rate ) alignment = MAX ( alignment , <NUM_LIT> ) ; frv_packet_address += frv_packet . num_insns * <NUM_LIT> ; target = ( frv_packet_address + alignment - <NUM_LIT> ) & - alignment ; if ( barrier == <NUM_LIT> ) { for ( nop = <NUM_LIT> ; nop < frv_num_nops ; nop ++ ) while ( frv_packet_address < target && frv_pack_insn_p ( frv_nops [ nop ] ) ) {

frv_insert_nop_in_packet ( frv_nops [ nop ] ) ;


<s> nr = HARD_REGNO_NREGS ( regno , mode ) ; info -> next_reg [ ( int ) rclass ] = regno + nr ; if ( mark_as_used ) for ( i = <NUM_LIT> ; i < nr ; i ++ ) CLEAR_HARD_REG_BIT ( info -> regs , regno + i ) ; return gen_rtx_REG ( mode , regno ) ;


<s> if ( regno == orig_regno ) { gcc_assert ( no_abort ) ; return NULL_RTX ; } } nr = HARD_REGNO_NREGS ( regno , mode ) ; info -> next_reg [ ( int ) rclass ] = regno + nr ; if ( mark_as_used ) for ( i = <NUM_LIT> ; i < nr ; i ++ ) CLEAR_HARD_REG_BIT ( info -> regs , regno + i ) ; return gen_rtx_REG ( mode , regno ) ;


<s> static int frv_arg_partial_bytes ( cumulative_args_t cum , machine_mode mode , tree type ATTRIBUTE_UNUSED , bool named ATTRIBUTE_UNUSED ) { machine_mode xmode = ( mode == BLKmode ) ? SImode : mode ; int bytes = GET_MODE_SIZE ( xmode ) ; int words = ( bytes + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ; int arg_num = * get_cumulative_args ( cum ) ; int ret ;


<s> const char * name_pic = reg_names [ FDPIC_REGNO ] ; name_jmp = reg_names [ FDPIC_FPTR_REGNO ] ; if ( flag_pic != <NUM_LIT> ) { fprintf ( file , <STR_LIT> , parallel ) ; assemble_name ( file , name_func ) ; fprintf ( file , <STR_LIT> , name_jmp ) ; fprintf ( file , <STR_LIT> ) ; assemble_name ( file , name_func ) ; fprintf ( file , <STR_LIT> , name_jmp ) ; fprintf ( file , <STR_LIT> , name_jmp , name_pic , name_jmp ) ; } else { fprintf ( file , <STR_LIT> , name_pic ) ; assemble_name ( file , name_func ) ; fprintf ( file , <STR_LIT> , name_jmp ) ; } } else if ( ! flag_pic ) { fprintf ( file , <STR_LIT> , parallel ) ; assemble_name ( file , name_func ) ; fprintf ( file , <STR_LIT> , name_jmp ) ; fprintf ( file , <STR_LIT> ) ; assemble_name ( file , name_func ) ; fprintf ( file , <STR_LIT> , name_jmp ) ;


<s> static rtx frv_dwarf_store ( rtx reg , int offset ) { rtx set = gen_rtx_SET ( VOIDmode , gen_rtx_MEM ( GET_MODE ( reg ) , plus_constant ( Pmode , stack_pointer_rtx , offset ) ) , reg ) ; RTX_FRAME_RELATED_P ( set ) = <NUM_LIT> ; return set ;


<s> rtx label_ref ; rtx if_else ; enum rtx_code test = GET_CODE ( operands [ <NUM_LIT> ] ) ; rtx cc_reg = frv_emit_comparison ( test , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; machine_mode cc_mode = GET_MODE ( cc_reg ) ;

label_ref = gen_rtx_LABEL_REF ( VOIDmode , operands [ <NUM_LIT> ] ) ;


<s> enum rtx_code test = GET_CODE ( operands [ <NUM_LIT> ] ) ; rtx cc_reg = frv_emit_comparison ( test , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; machine_mode cc_mode = GET_MODE ( cc_reg ) ; label_ref = gen_rtx_LABEL_REF ( VOIDmode , operands [ <NUM_LIT> ] ) ; test_rtx = gen_rtx_fmt_ee ( test , cc_mode , cc_reg , const0_rtx ) ;


<s> if ( frv_emit_movsi ( dest , src ) ) return ; break ; case QImode : case HImode : case DImode : case SFmode : case DFmode : if ( ! reload_in_progress && ! reload_completed && ! register_operand ( dest , mode ) && ! reg_or_0_operand ( src , mode ) ) src = copy_to_mode_reg ( mode , src ) ; break ; default : gcc_unreachable ( ) ;


<s> test_rtx = gen_rtx_fmt_ee ( test , SImode , cc_reg , const0_rtx ) ; set = gen_rtx_SET ( VOIDmode , operands [ <NUM_LIT> ] , test_rtx ) ;


<s> rtx dest_reg ; rtx dest_addr ; rtx dest_mem ; int clear_bytes ; machine_mode mode ; if ( ! constp ) return FALSE ; gcc_assert ( GET_CODE ( align_rtx ) == CONST_INT ) ; align = INTVAL ( align_rtx ) ; bytes = INTVAL ( bytes_rtx ) ; if ( bytes <= <NUM_LIT> ) return TRUE ; if ( bytes > TOTAL_MOVE_REG * align ) return FALSE ; dest_reg = copy_addr_to_reg ( XEXP ( orig_dest , <NUM_LIT> ) ) ; offset = <NUM_LIT> ; for ( ; bytes > <NUM_LIT> ; ( bytes -= clear_bytes ) , ( offset += clear_bytes ) ) {

dest_addr = ( ( offset == <NUM_LIT> ) ? dest_reg : plus_constant ( Pmode , dest_reg , offset ) ) ;


<s> else { src_addr = plus_constant ( Pmode , src_reg , offset ) ; dest_addr = plus_constant ( Pmode , dest_reg , offset ) ; } if ( bytes >= <NUM_LIT> && align >= <NUM_LIT> ) mode = SImode ; else if ( bytes >= <NUM_LIT> && align >= <NUM_LIT> ) mode = HImode ; else mode = QImode ; move_bytes = GET_MODE_SIZE ( mode ) ; tmp_reg = gen_reg_rtx ( mode ) ; src_mem = change_address ( orig_src , mode , src_addr ) ; dest_mem = change_address ( orig_dest , mode , dest_addr ) ; emit_insn ( gen_rtx_SET ( VOIDmode , tmp_reg , src_mem ) ) ;

stores [ num_reg ++ ] = gen_rtx_SET ( VOIDmode , dest_mem , tmp_reg ) ;


<s> case FRV_BUILTIN_MQMACXHS : case FRV_BUILTIN_MADDACCS : case FRV_BUILTIN_MSUBACCS : case FRV_BUILTIN_MASACCS : case FRV_BUILTIN_MDADDACCS : case FRV_BUILTIN_MDSUBACCS : case FRV_BUILTIN_MDASACCS : case FRV_BUILTIN_MABSHS : case FRV_BUILTIN_MDROTLI : case FRV_BUILTIN_MCPLHI : case FRV_BUILTIN_MCPLI : case FRV_BUILTIN_MDCUTSSI : case FRV_BUILTIN_MQSATHS : case FRV_BUILTIN_MHSETLOS : case FRV_BUILTIN_MHSETLOH : case FRV_BUILTIN_MHSETHIS : case FRV_BUILTIN_MHSETHIH : case FRV_BUILTIN_MHDSETS : case FRV_BUILTIN_MHDSETH : if ( ! TARGET_MEDIA_REV2 ) { error ( <STR_LIT> <STR_LIT> ) ; return NULL_RTX ; } break ; case FRV_BUILTIN_SMASS : case FRV_BUILTIN_SMSSS : case FRV_BUILTIN_SMU : case FRV_BUILTIN_ADDSS : case FRV_BUILTIN_SUBSS : case FRV_BUILTIN_SLASS : case FRV_BUILTIN_SCUTSS : case FRV_BUILTIN_IACCreadll : case FRV_BUILTIN_IACCreadl : case FRV_BUILTIN_IACCsetll : case FRV_BUILTIN_IACCsetl : if ( ! TARGET_FR405_BUILTINS ) { error ( <STR_LIT> <STR_LIT> ) ; return NULL_RTX ; } break ; case FRV_BUILTIN_PREFETCH : if ( ! TARGET_FR500_FR550_BUILTINS ) { error ( <STR_LIT> <STR_LIT> ) ; return NULL_RTX ; } break ; case FRV_BUILTIN_MQLCLRHS : case FRV_BUILTIN_MQLMTHS : case FRV_BUILTIN_MQSLLHI : case FRV_BUILTIN_MQSRAHI : if ( ! TARGET_MEDIA_FR450 ) { error ( <STR_LIT> ) ; return NULL_RTX ; } break ; default : break ; } switch ( fcode ) { case FRV_BUILTIN_MTRAP : return frv_expand_noargs_builtin ( CODE_FOR_mtrap ) ; case FRV_BUILTIN_MCLRACC : return frv_expand_mclracc_builtin ( exp ) ; case FRV_BUILTIN_MCLRACCA : if ( TARGET_ACC_8 ) return frv_expand_noargs_builtin ( CODE_FOR_mclracca8 ) ; else return frv_expand_noargs_builtin ( CODE_FOR_mclracca4 ) ; case FRV_BUILTIN_MRDACC : return frv_expand_mrdacc_builtin ( CODE_FOR_mrdacc , exp ) ; case FRV_BUILTIN_MRDACCG : return frv_expand_mrdacc_builtin ( CODE_FOR_mrdaccg , exp ) ; case FRV_BUILTIN_MWTACC : return frv_expand_mwtacc_builtin ( CODE_FOR_mwtacc , exp ) ; case FRV_BUILTIN_MWTACCG : return frv_expand_mwtacc_builtin ( CODE_FOR_mwtaccg , exp ) ; case FRV_BUILTIN_MDPACKH : return frv_expand_mdpackh_builtin ( exp , target ) ; case FRV_BUILTIN_IACCreadll : { rtx src = frv_read_iacc_argument ( DImode , exp , <NUM_LIT> ) ; if ( target == <NUM_LIT> || ! REG_P ( target ) ) target = gen_reg_rtx ( DImode ) ; frv_split_iacc_move ( target , src ) ; return target ; } case FRV_BUILTIN_IACCreadl : return frv_read_iacc_argument ( SImode , exp , <NUM_LIT> ) ; case FRV_BUILTIN_IACCsetll : { rtx dest = frv_read_iacc_argument ( DImode , exp , <NUM_LIT> ) ; rtx src = frv_read_argument ( exp , <NUM_LIT> ) ; frv_split_iacc_move ( dest , force_reg ( DImode , src ) ) ; return <NUM_LIT> ; } case FRV_BUILTIN_IACCsetl : { rtx dest = frv_read_iacc_argument ( SImode , exp , <NUM_LIT> ) ; rtx src = frv_read_argument ( exp , <NUM_LIT> ) ; emit_move_insn ( dest , force_reg ( SImode , src ) ) ; return <NUM_LIT> ; } default : break ; }

for ( i = <NUM_LIT> , d = bdesc_set ; i < ARRAY_SIZE ( bdesc_set ) ; i ++ , d ++ ) if ( d -> code == fcode ) return frv_expand_set_builtin ( d -> icode , exp , target ) ;


<s> for ( i = <NUM_LIT> , d = bdesc_cut ; i < ARRAY_SIZE ( bdesc_cut ) ; i ++ , d ++ ) if ( d -> code == fcode ) return frv_expand_cut_builtin ( d -> icode , exp , target ) ; for ( i = <NUM_LIT> , d = bdesc_2argimm ; i < ARRAY_SIZE ( bdesc_2argimm ) ; i ++ , d ++ ) if ( d -> code == fcode ) return frv_expand_binopimm_builtin ( d -> icode , exp , target ) ; for ( i = <NUM_LIT> , d = bdesc_void2arg ; i < ARRAY_SIZE ( bdesc_void2arg ) ; i ++ , d ++ ) if ( d -> code == fcode ) return frv_expand_voidbinop_builtin ( d -> icode , exp ) ; for ( i = <NUM_LIT> , d = bdesc_void3arg ; i < ARRAY_SIZE ( bdesc_void3arg ) ; i ++ , d ++ ) if ( d -> code == fcode ) return frv_expand_voidtriop_builtin ( d -> icode , exp ) ; for ( i = <NUM_LIT> , d = bdesc_voidacc ; i < ARRAY_SIZE ( bdesc_voidacc ) ; i ++ , d ++ ) if ( d -> code == fcode ) return frv_expand_voidaccop_builtin ( d -> icode , exp ) ; for ( i = <NUM_LIT> , d = bdesc_int_void2arg ; i < ARRAY_SIZE ( bdesc_int_void2arg ) ; i ++ , d ++ ) if ( d -> code == fcode ) return frv_expand_int_void2arg ( d -> icode , exp ) ; for ( i = <NUM_LIT> , d = bdesc_prefetches ; i < ARRAY_SIZE ( bdesc_prefetches ) ; i ++ , d ++ ) if ( d -> code == fcode ) return frv_expand_prefetches ( d -> icode , exp ) ; for ( i = <NUM_LIT> , d = bdesc_loads ; i < ARRAY_SIZE ( bdesc_loads ) ; i ++ , d ++ ) if ( d -> code == fcode ) return frv_expand_load_builtin ( d -> icode , TYPE_MODE ( TREE_TYPE ( exp ) ) , exp , target ) ; for ( i = <NUM_LIT> , d = bdesc_stores ; i < ARRAY_SIZE ( bdesc_stores ) ; i ++ , d ++ ) if ( d -> code == fcode ) return frv_expand_store_builtin ( d -> icode , exp ) ; return <NUM_LIT> ;


<s> frv_stack_t * info = frv_stack_info ( ) ; rtx fp = frame_pointer_rtx ; rtx sp = stack_pointer_rtx ; rtx return_addr ; int fp_offset ; fp_offset = info -> reg_offset [ FRAME_POINTER_REGNUM ] ; if ( ! crtl -> sp_is_unchanging ) emit_insn ( gen_addsi3 ( sp , fp , frv_frame_offset_rtx ( - fp_offset ) ) ) ; frv_frame_access_standard_regs ( FRV_LOAD , info ) ; if ( info -> save_p [ LR_REGNO ] ) { int lr_offset ; rtx mem ; lr_offset = info -> reg_offset [ LR_REGNO ] ; if ( frame_pointer_needed ) mem = frv_frame_mem ( Pmode , fp , lr_offset - fp_offset ) ; else mem = frv_frame_mem ( Pmode , sp , lr_offset ) ; return_addr = gen_rtx_REG ( Pmode , TEMP_REGNO ) ; emit_insn ( gen_rtx_SET ( VOIDmode , return_addr , mem ) ) ; } else return_addr = gen_rtx_REG ( Pmode , LR_REGNO ) ; if ( frame_pointer_needed ) { emit_insn ( gen_rtx_SET ( VOIDmode , fp , gen_rtx_MEM ( Pmode , fp ) ) ) ; emit_use ( fp ) ; } if ( info -> total_size != <NUM_LIT> ) { rtx offset = frv_frame_offset_rtx ( info -> total_size ) ;

emit_insn ( gen_stack_adjust ( sp , sp , offset ) ) ;


<s> frv_stack_t * info = frv_stack_info ( ) ; rtx sp = stack_pointer_rtx ; rtx fp = frame_pointer_rtx ; frv_frame_accessor_t accessor ; if ( TARGET_DEBUG_STACK ) frv_debug_stack ( info ) ; if ( flag_stack_usage_info ) current_function_static_stack_size = info -> total_size ; if ( info -> total_size == <NUM_LIT> ) return ; accessor . op = FRV_STORE ; if ( frame_pointer_needed && info -> total_size > <NUM_LIT> ) { accessor . base = gen_rtx_REG ( Pmode , OLD_SP_REGNO ) ; accessor . base_offset = info -> total_size ; emit_insn ( gen_movsi ( accessor . base , sp ) ) ; } else { accessor . base = stack_pointer_rtx ; accessor . base_offset = <NUM_LIT> ; } { rtx asm_offset = frv_frame_offset_rtx ( - info -> total_size ) ; rtx dwarf_offset = GEN_INT ( - info -> total_size ) ; frv_frame_insn ( gen_stack_adjust ( sp , sp , asm_offset ) , gen_rtx_SET ( Pmode , sp , gen_rtx_PLUS ( Pmode , sp , dwarf_offset ) ) ) ; } if ( frame_pointer_needed ) { int fp_offset = info -> reg_offset [ FRAME_POINTER_REGNUM ] ; rtx asm_src = plus_constant ( Pmode , accessor . base , fp_offset - accessor . base_offset ) ; rtx dwarf_src = plus_constant ( Pmode , sp , fp_offset ) ; frv_frame_access ( & accessor , fp , fp_offset ) ; frv_frame_insn ( gen_rtx_SET ( VOIDmode , fp , asm_src ) , gen_rtx_SET ( VOIDmode , fp , dwarf_src ) ) ; accessor . base = fp ; accessor . base_offset = fp_offset ; } frv_frame_access_multi ( & accessor , info , STACK_REGS_STRUCT ) ; frv_frame_access_multi ( & accessor , info , STACK_REGS_LR ) ; frv_frame_access_multi ( & accessor , info , STACK_REGS_STDARG ) ; frv_frame_access_standard_regs ( FRV_STORE , info ) ; if ( info -> stdarg_size > <NUM_LIT> ) emit_insn ( gen_blockage ( ) ) ; if ( ! TARGET_FDPIC && flag_pic && crtl -> uses_pic_offset_table ) emit_insn ( gen_pic_prologue ( gen_rtx_REG ( Pmode , PIC_REGNO ) , gen_rtx_REG ( Pmode , LR_REGNO ) , gen_rtx_REG ( SImode , OFFSET_REGNO ) ) ) ;


<s> frv_stack_t * info = frv_stack_info ( ) ; rtx sp = stack_pointer_rtx ; rtx fp = frame_pointer_rtx ; frv_frame_accessor_t accessor ; if ( TARGET_DEBUG_STACK ) frv_debug_stack ( info ) ; if ( flag_stack_usage_info ) current_function_static_stack_size = info -> total_size ; if ( info -> total_size == <NUM_LIT> ) return ; accessor . op = FRV_STORE ; if ( frame_pointer_needed && info -> total_size > <NUM_LIT> ) { accessor . base = gen_rtx_REG ( Pmode , OLD_SP_REGNO ) ; accessor . base_offset = info -> total_size ; emit_insn ( gen_movsi ( accessor . base , sp ) ) ; } else { accessor . base = stack_pointer_rtx ; accessor . base_offset = <NUM_LIT> ; } { rtx asm_offset = frv_frame_offset_rtx ( - info -> total_size ) ; rtx dwarf_offset = GEN_INT ( - info -> total_size ) ; frv_frame_insn ( gen_stack_adjust ( sp , sp , asm_offset ) , gen_rtx_SET ( Pmode , sp , gen_rtx_PLUS ( Pmode , sp , dwarf_offset ) ) ) ; } if ( frame_pointer_needed ) { int fp_offset = info -> reg_offset [ FRAME_POINTER_REGNUM ] ; rtx asm_src = plus_constant ( Pmode , accessor . base , fp_offset - accessor . base_offset ) ; rtx dwarf_src = plus_constant ( Pmode , sp , fp_offset ) ; frv_frame_access ( & accessor , fp , fp_offset ) ; frv_frame_insn ( gen_rtx_SET ( VOIDmode , fp , asm_src ) , gen_rtx_SET ( VOIDmode , fp , dwarf_src ) ) ; accessor . base = fp ; accessor . base_offset = fp_offset ;


<s> rtx op1 = frv_read_argument ( call , <NUM_LIT> ) ; machine_mode mode0 = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; rtx addr ; if ( GET_CODE ( op0 ) != MEM ) { rtx reg = op0 ; if ( ! offsettable_address_p ( <NUM_LIT> , mode0 , op0 ) ) { reg = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_rtx_SET ( VOIDmode , reg , op0 ) ) ;


<s> if ( mode == DImode && GET_CODE ( XEXP ( mem , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( mem , <NUM_LIT> ) , <NUM_LIT> ) ) == REG && GET_CODE ( XEXP ( XEXP ( mem , <NUM_LIT> ) , <NUM_LIT> ) ) == REG ) { rtx temp = gen_rtx_REG ( SImode , TEMP_REGNO ) ; emit_move_insn ( temp , gen_rtx_PLUS ( SImode , XEXP ( XEXP ( mem , <NUM_LIT> ) , <NUM_LIT> ) , XEXP ( XEXP ( mem , <NUM_LIT> ) , <NUM_LIT> ) ) ) ; mem = gen_rtx_MEM ( DImode , temp ) ; } emit_insn ( gen_rtx_SET ( VOIDmode , reg , mem ) ) ; } emit_use ( reg ) ; } else { if ( SPR_P ( REGNO ( reg ) ) ) {

rtx temp = gen_rtx_REG ( mode , TEMP_REGNO ) ;


<s> } else { if ( SPR_P ( REGNO ( reg ) ) ) { rtx temp = gen_rtx_REG ( mode , TEMP_REGNO ) ; emit_insn ( gen_rtx_SET ( VOIDmode , temp , reg ) ) ; frv_frame_insn ( gen_rtx_SET ( Pmode , mem , temp ) , frv_dwarf_store ( reg , stack_offset ) ) ; } else if ( mode == DImode ) { rtx reg1 = gen_rtx_REG ( SImode , REGNO ( reg ) ) ; rtx reg2 = gen_rtx_REG ( SImode , REGNO ( reg ) + <NUM_LIT> ) ; rtx set1 = frv_dwarf_store ( reg1 , stack_offset ) ; rtx set2 = frv_dwarf_store ( reg2 , stack_offset + <NUM_LIT> ) ; if ( GET_CODE ( XEXP ( mem , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( mem , <NUM_LIT> ) , <NUM_LIT> ) ) == REG && GET_CODE ( XEXP ( XEXP ( mem , <NUM_LIT> ) , <NUM_LIT> ) ) == REG ) { rtx temp = gen_rtx_REG ( SImode , TEMP_REGNO ) ; emit_move_insn ( temp , gen_rtx_PLUS ( SImode , XEXP ( XEXP ( mem , <NUM_LIT> ) , <NUM_LIT> ) , XEXP ( XEXP ( mem , <NUM_LIT> ) , <NUM_LIT> ) ) ) ;


<s> return frv_function_arg_1 ( cum , mode , type , named , false ) ;


<s> static rtx frv_function_arg ( cumulative_args_t cum , machine_mode mode , const_tree type , bool named ) {

return frv_function_arg_1 ( cum , mode , type , named , false ) ;


<s> machine_mode xmode = ( mode == BLKmode ) ? SImode : mode ; int arg_num = * cum ; rtx ret ; const char * debstr ; if ( xmode == VOIDmode ) { ret = const0_rtx ; debstr = <STR_LIT> ; } else if ( arg_num <= LAST_ARG_REGNUM ) { ret = gen_rtx_REG ( xmode , arg_num ) ;


<s> CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; machine_mode xmode = ( mode == BLKmode ) ? SImode : mode ; int bytes = GET_MODE_SIZE ( xmode ) ; int words = ( bytes + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ; int arg_num = * cum ; * cum = arg_num + words ; if ( TARGET_DEBUG_ARG ) fprintf ( stderr , <STR_LIT> , arg_num , GET_MODE_NAME ( mode ) , named , words * UNITS_PER_WORD ) ;


<s> static rtx frv_function_incoming_arg ( cumulative_args_t cum , machine_mode mode , const_tree type , bool named ) { return frv_function_arg_1 ( cum , mode , type , named , true ) ;


<s> if ( GET_CODE ( address ) == REG && REGNO ( address ) == LR_REGNO ) SET_REGNO ( address , GPR_FIRST + <NUM_LIT> ) ; } } } frv_pack_insns ( ) ; memset ( frv_nops , <NUM_LIT> , sizeof ( frv_nops ) ) ; last_call = NULL ; for ( insn = get_insns ( ) ; insn ; insn = next ) { next = NEXT_INSN ( insn ) ; if ( CALL_P ( insn ) || ( INSN_P ( insn ) && GET_CODE ( PATTERN ( insn ) ) == SEQUENCE && CALL_P ( XVECEXP ( PATTERN ( insn ) , <NUM_LIT> , <NUM_LIT> ) ) ) ) last_call = insn ; if ( ! NOTE_P ( insn ) || NOTE_KIND ( insn ) != NOTE_INSN_CALL_ARG_LOCATION ) continue ; if ( NEXT_INSN ( last_call ) == insn ) continue ; SET_NEXT_INSN ( PREV_INSN ( insn ) ) = NEXT_INSN ( insn ) ; SET_PREV_INSN ( NEXT_INSN ( insn ) ) = PREV_INSN ( insn ) ; SET_PREV_INSN ( insn ) = last_call ; SET_NEXT_INSN ( insn ) = NEXT_INSN ( last_call ) ; SET_PREV_INSN ( NEXT_INSN ( insn ) ) = insn ; SET_NEXT_INSN ( PREV_INSN ( insn ) ) = insn ;


<s> if ( GPR_P ( regno ) || regno == AP_FIRST ) base = GPR_FIRST ; else if ( FPR_P ( regno ) ) base = FPR_FIRST ; else if ( ACC_P ( regno ) ) base = ACC_FIRST ; else if ( SPR_P ( regno ) ) return mode == SImode ; else return <NUM_LIT> ; if ( GET_MODE_SIZE ( mode ) < <NUM_LIT> ) return <NUM_LIT> ; mask = ( GET_MODE_SIZE ( mode ) / <NUM_LIT> ) - <NUM_LIT> ; } return ( ( ( regno - base ) & mask ) == <NUM_LIT> ) ; } return <NUM_LIT> ;


<s> if ( changed_p ) COND_EXEC_CODE ( pattern ) = gen_rtx_SET ( VOIDmode , dest , src ) ; } else if ( mode == CC_CCRmode && COMPARISON_P ( src ) ) { int regno = REGNO ( XEXP ( src , <NUM_LIT> ) ) ; rtx if_else ; if ( ce_info -> pass > <NUM_LIT> && regno != ( int ) REGNO ( frv_ifcvt . nested_cc_reg ) && TEST_HARD_REG_BIT ( frv_ifcvt . nested_cc_ok_rewrite , regno ) ) { src = gen_rtx_fmt_ee ( GET_CODE ( src ) , CC_CCRmode , frv_ifcvt . nested_cc_reg , XEXP ( src , <NUM_LIT> ) ) ; } if_else = gen_rtx_IF_THEN_ELSE ( CC_CCRmode , test , src , const0_rtx ) ; pattern = gen_rtx_SET ( VOIDmode , dest , if_else ) ; } else if ( ce_info -> pass > <NUM_LIT> && GET_CODE ( dest ) == REG && CC_P ( REGNO ( dest ) ) && REGNO ( dest ) != REGNO ( frv_ifcvt . nested_cc_reg ) && TEST_HARD_REG_BIT ( frv_ifcvt . nested_cc_ok_rewrite , REGNO ( dest ) ) && GET_CODE ( src ) == COMPARE ) { PUT_MODE ( frv_ifcvt . nested_cc_reg , GET_MODE ( dest ) ) ; COND_EXEC_CODE ( pattern ) = gen_rtx_SET ( VOIDmode , frv_ifcvt . nested_cc_reg , copy_rtx ( src ) ) ; } } if ( TARGET_DEBUG_COND_EXEC ) { rtx orig_pattern = PATTERN ( insn ) ; PATTERN ( insn ) = pattern ; fprintf ( stderr , <STR_LIT> , ce_info -> pass ) ; debug_rtx ( insn ) ; PATTERN ( insn ) = orig_pattern ; } return pattern ; fail : if ( TARGET_DEBUG_COND_EXEC ) { rtx orig_pattern = PATTERN ( insn ) ; PATTERN ( insn ) = orig_ce_pattern ; fprintf ( stderr , <STR_LIT> , ce_info -> pass ) ; debug_rtx ( insn ) ;


<s> rtx compare ; rtx cc ; enum reg_class cr_class ; machine_mode mode = GET_MODE ( true_expr ) ; rtx ( * logical_func ) ( rtx , rtx , rtx ) ; if ( TARGET_DEBUG_COND_EXEC ) { fprintf ( stderr , <STR_LIT> , ce_info -> and_and_p ? <STR_LIT> : <STR_LIT> ) ; debug_rtx ( * p_true ) ; fputs ( <STR_LIT> , stderr ) ; debug_rtx ( * p_false ) ; } if ( ! TARGET_MULTI_CE ) goto fail ; if ( GET_CODE ( cr ) != REG ) goto fail ; if ( mode == CCmode || mode == CC_UNSmode || mode == CC_NZmode ) { cr_class = ICR_REGS ; p_new_cr = & frv_ifcvt . extra_int_cr ; } else if ( mode == CC_FPmode ) { cr_class = FCR_REGS ; p_new_cr = & frv_ifcvt . extra_fp_cr ; } else goto fail ; new_cr = * p_new_cr ; if ( ! new_cr ) { new_cr = * p_new_cr = frv_alloc_temp_reg ( & frv_ifcvt . tmp_reg , cr_class , CC_CCRmode , TRUE , TRUE ) ; if ( ! new_cr ) goto fail ; } if ( ce_info -> and_and_p ) { old_test = old_false ; test_expr = true_expr ; logical_func = ( GET_CODE ( old_true ) == EQ ) ? gen_andcr : gen_andncr ; * p_true = gen_rtx_NE ( CC_CCRmode , cr , const0_rtx ) ; * p_false = gen_rtx_EQ ( CC_CCRmode , cr , const0_rtx ) ; } else { old_test = old_false ; test_expr = false_expr ; logical_func = ( GET_CODE ( old_false ) == EQ ) ? gen_orcr : gen_orncr ; * p_true = gen_rtx_EQ ( CC_CCRmode , cr , const0_rtx ) ; * p_false = gen_rtx_NE ( CC_CCRmode , cr , const0_rtx ) ; } frv_ifcvt_add_insn ( ( * logical_func ) ( cr , cr , new_cr ) , BB_END ( bb ) , TRUE ) ; cc = XEXP ( test_expr , <NUM_LIT> ) ; compare = gen_rtx_fmt_ee ( GET_CODE ( test_expr ) , CC_CCRmode , cc , const0_rtx ) ; if_else = gen_rtx_IF_THEN_ELSE ( CC_CCRmode , old_test , compare , const0_rtx ) ; check_insn = gen_rtx_SET ( VOIDmode , new_cr , if_else ) ; frv_ifcvt_add_insn ( check_insn , BB_END ( bb ) , TRUE ) ; if ( TARGET_DEBUG_COND_EXEC ) { fputs ( <STR_LIT> , stderr ) ; debug_rtx ( * p_true ) ; fputs ( <STR_LIT> , stderr ) ; debug_rtx ( * p_false ) ; } return ; fail : * p_true = * p_false = NULL_RTX ; if ( new_cr ) { CLEAR_HARD_REG_BIT ( frv_ifcvt . tmp_reg . regs , REGNO ( new_cr ) ) ; * p_new_cr = NULL_RTX ;


<s> find_all_hard_regs ( PATTERN ( insn ) , & mentioned_regs ) ; AND_COMPL_HARD_REG_SET ( tmp_reg -> regs , mentioned_regs ) ; pattern = PATTERN ( insn ) ; if ( GET_CODE ( pattern ) == COND_EXEC ) { rtx reg = XEXP ( COND_EXEC_TEST ( pattern ) , <NUM_LIT> ) ; if ( reg != sub_cond_exec_reg ) { sub_cond_exec_reg = reg ; frv_ifcvt . num_nested_cond_exec ++ ; } } set = single_set_pattern ( pattern ) ; if ( set ) { rtx dest = SET_DEST ( set ) ; rtx src = SET_SRC ( set ) ; if ( GET_CODE ( dest ) == REG ) { int regno = REGNO ( dest ) ; enum rtx_code src_code = GET_CODE ( src ) ; if ( CC_P ( regno ) && src_code == COMPARE ) skip_nested_if = TRUE ; else if ( CR_P ( regno ) && ( src_code == IF_THEN_ELSE || COMPARISON_P ( src ) ) ) skip_nested_if = TRUE ; } } if ( ! skip_nested_if ) AND_COMPL_HARD_REG_SET ( frv_ifcvt . nested_cc_ok_rewrite , mentioned_regs ) ; } if ( insn == last_insn ) break ; insn = NEXT_INSN ( insn ) ; } } if ( ce_info -> pass > <NUM_LIT> ) { for ( j = CC_FIRST ; j <= CC_LAST ; j ++ ) if ( TEST_HARD_REG_BIT ( frv_ifcvt . nested_cc_ok_rewrite , j ) ) SET_HARD_REG_BIT ( tmp_reg -> regs , j ) ; else CLEAR_HARD_REG_BIT ( tmp_reg -> regs , j ) ; } if ( dump_file ) { int num_gprs = <NUM_LIT> ; fprintf ( dump_file , <STR_LIT> ) ; for ( j = GPR_FIRST ; j <= GPR_LAST ; j ++ ) if ( TEST_HARD_REG_BIT ( tmp_reg -> regs , j ) ) { fprintf ( dump_file , <STR_LIT> , j , reg_names [ j ] ) ; if ( ++ num_gprs > GPR_TEMP_NUM + <NUM_LIT> ) break ; } fprintf ( dump_file , <STR_LIT> , ( num_gprs > GPR_TEMP_NUM + <NUM_LIT> ) ? <STR_LIT> : <STR_LIT> ) ; for ( j = CR_FIRST ; j <= CR_LAST ; j ++ ) if ( TEST_HARD_REG_BIT ( tmp_reg -> regs , j ) ) fprintf ( dump_file , <STR_LIT> , j , reg_names [ j ] ) ; fputs ( <STR_LIT> , dump_file ) ; if ( ce_info -> pass > <NUM_LIT> ) { fprintf ( dump_file , <STR_LIT> ) ; for ( j = CC_FIRST ; j <= CC_LAST ; j ++ ) if ( TEST_HARD_REG_BIT ( tmp_reg -> regs , j ) ) fprintf ( dump_file , <STR_LIT> , j , reg_names [ j ] ) ; fprintf ( dump_file , <STR_LIT> , frv_ifcvt . num_nested_cond_exec ) ; } } if ( mode == CCmode || mode == CC_UNSmode || mode == CC_NZmode ) { cr_class = ICR_REGS ;


<s> static bool frv_must_pass_in_stack ( machine_mode mode , const_tree type ) { if ( mode == BLKmode ) return true ;


<s> static bool frv_must_pass_in_stack ( machine_mode mode , const_tree type ) { if ( mode == BLKmode ) return true ; if ( type == NULL ) return false ; return AGGREGATE_TYPE_P ( type ) ;


<s> for ( insn = BB_END ( bb ) ; insn != BB_HEAD ( bb ) ; insn = PREV_INSN ( insn ) ) if ( CALL_P ( insn ) ) { memset ( next_io , <NUM_LIT> , sizeof ( struct frv_io ) ) ; next_is_end_p = false ; CLEAR_HARD_REG_SET ( used_regs ) ; } else if ( INSN_P ( insn ) ) switch ( recog_memoized ( insn ) ) { case CODE_FOR_optional_membar_qi : case CODE_FOR_optional_membar_hi : case CODE_FOR_optional_membar_si : case CODE_FOR_optional_membar_di : next_membar = insn ; if ( next_is_end_p ) { * last_membar = insn ; frv_extract_membar ( next_io , insn ) ; next_is_end_p = false ; } else { struct frv_io prev_io ; frv_extract_membar ( & prev_io , insn ) ; if ( frv_io_fixed_order_p ( & prev_io , next_io ) ) { if ( dump_file ) fprintf ( dump_file , <STR_LIT> <STR_LIT> , INSN_UID ( next_membar ) ) ; insn = NEXT_INSN ( insn ) ; delete_insn ( next_membar ) ; next_membar = <NUM_LIT> ; } * next_io = prev_io ; } break ; default : if ( next_io -> var_address ) note_stores ( PATTERN ( insn ) , frv_io_check_address , & next_io -> var_address ) ;


<s> CLEAR_HARD_REG_SET ( used_regs ) ; } else if ( INSN_P ( insn ) ) switch ( recog_memoized ( insn ) ) { case CODE_FOR_optional_membar_qi : case CODE_FOR_optional_membar_hi : case CODE_FOR_optional_membar_si : case CODE_FOR_optional_membar_di : next_membar = insn ; if ( next_is_end_p ) { * last_membar = insn ; frv_extract_membar ( next_io , insn ) ; next_is_end_p = false ; } else { struct frv_io prev_io ; frv_extract_membar ( & prev_io , insn ) ; if ( frv_io_fixed_order_p ( & prev_io , next_io ) ) { if ( dump_file ) fprintf ( dump_file , <STR_LIT> <STR_LIT> , INSN_UID ( next_membar ) ) ; insn = NEXT_INSN ( insn ) ; delete_insn ( next_membar ) ; next_membar = <NUM_LIT> ; } * next_io = prev_io ; } break ; default : if ( next_io -> var_address ) note_stores ( PATTERN ( insn ) , frv_io_check_address , & next_io -> var_address ) ; set = PATTERN ( insn ) ; if ( next_io -> type == FRV_IO_READ && next_io -> var_address != <NUM_LIT> && next_membar != <NUM_LIT> && GET_CODE ( set ) == SET && GET_CODE ( SET_DEST ( set ) ) == REG && TEST_HARD_REG_BIT ( used_regs , REGNO ( SET_DEST ( set ) ) ) ) { rtx src ; src = SET_SRC ( set ) ; if ( GET_CODE ( src ) == ZERO_EXTEND ) src = XEXP ( src , <NUM_LIT> ) ; if ( GET_CODE ( src ) == MEM && rtx_equal_p ( XEXP ( src , <NUM_LIT> ) , next_io -> var_address ) ) { if ( dump_file ) fprintf ( dump_file , <STR_LIT> <STR_LIT> , INSN_UID ( next_membar ) , INSN_UID ( insn ) ) ; if ( next_membar == * last_membar ) * last_membar = <NUM_LIT> ;


<s> case REG : fputs ( reg_names [ REGNO ( x ) ] , stream ) ; return ; case CONST_INT : fprintf ( stream , <STR_LIT> , ( long ) INTVAL ( x ) ) ; return ; case SYMBOL_REF : assemble_name ( stream , XSTR ( x , <NUM_LIT> ) ) ; return ; case LABEL_REF :


<s> return ; case SYMBOL_REF : assemble_name ( stream , XSTR ( x , <NUM_LIT> ) ) ; return ; case LABEL_REF : case CONST : output_addr_const ( stream , x ) ; return ; case PLUS : frv_print_operand_memory_reference ( stream , x , <NUM_LIT> ) ;


<s> rtx labelref ; int ret ; int prob = - <NUM_LIT> ; enum { UNKNOWN , BACKWARD , FORWARD } jump_type = UNKNOWN ; gcc_assert ( JUMP_P ( insn ) ) ; if ( ! any_condjump_p ( insn ) ) ret = FRV_JUMP_LIKELY ; else { labelref = condjump_label ( insn ) ; if ( labelref ) { rtx label = XEXP ( labelref , <NUM_LIT> ) ; jump_type = ( insn_current_address > INSN_ADDRESSES ( INSN_UID ( label ) ) ? BACKWARD : FORWARD ) ; } note = find_reg_note ( insn , REG_BR_PROB , <NUM_LIT> ) ; if ( ! note ) ret = ( ( jump_type == BACKWARD ) ? FRV_JUMP_LIKELY : FRV_JUMP_NOT_LIKELY ) ; else { prob = XINT ( note , <NUM_LIT> ) ; ret = ( ( prob >= ( REG_BR_PROB_BASE / <NUM_LIT> ) ) ? FRV_JUMP_LIKELY : FRV_JUMP_NOT_LIKELY ) ; } } if ( TARGET_DEBUG ) { char * direction ; switch ( jump_type ) { default : case UNKNOWN : direction = <STR_LIT> ; break ; case BACKWARD : direction = <STR_LIT> ; break ; case FORWARD : direction = <STR_LIT> ; break ; } fprintf ( stderr , <STR_LIT> , IDENTIFIER_POINTER ( DECL_NAME ( current_function_decl ) ) , ( long ) INSN_UID ( insn ) , direction , prob , REG_BR_PROB_BASE , ret ) ; }


<s> op = frv_read_argument ( call , index ) ; if ( GET_CODE ( op ) != CONST_INT || INTVAL ( op ) < <NUM_LIT> || INTVAL ( op ) > IACC_LAST - IACC_FIRST || ( ( INTVAL ( op ) * <NUM_LIT> ) & ( GET_MODE_SIZE ( mode ) - <NUM_LIT> ) ) != <NUM_LIT> ) { error ( <STR_LIT> ) ; op = const0_rtx ;


<s> int i , regno ; rtx op ; op = frv_read_argument ( call , index ) ; if ( GET_CODE ( op ) != CONST_INT || INTVAL ( op ) < <NUM_LIT> || INTVAL ( op ) > IACC_LAST - IACC_FIRST || ( ( INTVAL ( op ) * <NUM_LIT> ) & ( GET_MODE_SIZE ( mode ) - <NUM_LIT> ) ) != <NUM_LIT> ) { error ( <STR_LIT> ) ; op = const0_rtx ; } regno = INTVAL ( op ) + IACC_FIRST ;

for ( i = <NUM_LIT> ; i < HARD_REGNO_NREGS ( regno , mode ) ; i ++ ) global_regs [ regno + i ] = <NUM_LIT> ;


<s> } to = <NUM_LIT> ; for ( unit = <NUM_LIT> ; unit < ARRAY_SIZE ( frv_unit_groups ) ; unit ++ ) { group = frv_unit_groups [ unit ] ; packet_group = & frv_packet . groups [ group ] ; if ( cursor [ group ] < packet_group -> num_insns ) { gcc_assert ( packet_group -> sorted [ cursor [ group ] ] != packet_group -> nop ) ; insns [ to ++ ] = packet_group -> sorted [ cursor [ group ] ++ ] ; }


<s> case LABEL_REF : case SYMBOL_REF : case CONST_DOUBLE : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case PLUS : case MINUS : case AND : case IOR : case XOR : case ASHIFT : case ASHIFTRT : case LSHIFTRT : case NOT : case NEG : case COMPARE : if ( GET_MODE ( x ) == SImode ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( GET_MODE ( x ) == DImode ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ;