<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 ) ) ) ; 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 ) ) ) ; } else if ( IN_RANGE ( value1 , - <NUM_LIT> , <NUM_LIT> ) && IN_RANGE ( 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 ) ) ; } else gcc_unreachable ( ) ; }


<s> emit_insn ( gen_rtx_SET ( VOIDmode , cr_reg , gen_rtx_fmt_ee ( test_code , GET_MODE ( cr_reg ) , cc_reg , const0_rtx ) ) ) ; 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 ) ) ) ;


<s> machine_mode cr_mode = GET_MODE ( cr_reg ) ; start_sequence ( ) ; switch ( GET_CODE ( minmax ) ) { default : gcc_unreachable ( ) ; case SMIN : test_code = LT ; break ; case SMAX : test_code = GT ; break ; case UMIN : test_code = LTU ; break ; case UMAX : test_code = GTU ; break ; } emit_insn ( gen_rtx_SET ( VOIDmode , cc_reg , gen_rtx_COMPARE ( GET_MODE ( cc_reg ) , src1 , src2 ) ) ) ; emit_insn ( gen_rtx_SET ( VOIDmode , cr_reg , gen_rtx_fmt_ee ( test_code , GET_MODE ( cr_reg ) , cc_reg , const0_rtx ) ) ) ; if ( GET_CODE ( src2 ) == CONST_INT && INTVAL ( src2 ) != <NUM_LIT> ) { gcc_assert ( ! rtx_equal_p ( dest , src1 ) ) ;


<s> static void frv_trampoline_init ( rtx m_tramp , tree fndecl , rtx static_chain ) { rtx addr = XEXP ( m_tramp , <NUM_LIT> ) ; rtx fnaddr = XEXP ( DECL_RTL ( fndecl ) , <NUM_LIT> ) ; rtx sc_reg = force_reg ( Pmode , static_chain ) ;

emit_library_call ( gen_rtx_SYMBOL_REF ( SImode , <STR_LIT> ) , LCT_NORMAL , 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 ) ;


<s> } } 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 ) ; 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 ) && ( mode == SImode || mode == SFmode ) ) return <STR_LIT> ;


<s> 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 ) ; 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 ) && ( mode == SImode || mode == SFmode ) ) return <STR_LIT> ; } else if ( ZERO_P ( src ) ) { machine_mode mode = GET_MODE ( dest ) ; switch ( mode ) { default : break ; case QImode :


<s> 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 ) ; 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> ;


<s> if ( GET_CODE ( src ) == SYMBOL_REF ) { enum tls_model model = SYMBOL_REF_TLS_MODEL ( src ) ; if ( model != <NUM_LIT> ) src = frv_legitimize_tls_address ( src , model ) ; } switch ( mode ) { case SImode : 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 :


<s> rtx_insn * insn , * next_membar ; bool next_is_end_p ; memset ( next_io , <NUM_LIT> , sizeof ( * next_io ) ) ; next_is_end_p = true ; next_membar = <NUM_LIT> ; CLEAR_HARD_REG_SET ( used_regs ) ; 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 ;


<s> 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> ; delete_insn ( next_membar ) ; next_membar = <NUM_LIT> ;


<s> tree fndecl = TREE_OPERAND ( CALL_EXPR_FN ( exp ) , <NUM_LIT> ) ; unsigned fcode = ( unsigned ) DECL_FUNCTION_CODE ( fndecl ) ; unsigned i ; struct builtin_description * d ; if ( fcode < FRV_BUILTIN_FIRST_NONMEDIA && ! TARGET_MEDIA ) { error ( <STR_LIT> ) ; return NULL_RTX ; } switch ( fcode ) { case FRV_BUILTIN_MCOP1 : case FRV_BUILTIN_MCOP2 : case FRV_BUILTIN_MDUNPACKH : case FRV_BUILTIN_MBTOHE : if ( ! TARGET_MEDIA_REV1 ) { error ( <STR_LIT> ) ; return NULL_RTX ; } break ; case FRV_BUILTIN_MQXMACHS : case FRV_BUILTIN_MQXMACXHS : 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> ) ;


<s> for ( i = nptrs ; i >= <NUM_LIT> ; i -- ) __CTOR_LIST__ [ i ] ( ) ; atexit ( __do_global_dtors ) ;


<s> static int completed = <NUM_LIT> ; if ( completed ) return ;

if ( __deregister_frame_info ) __deregister_frame_info ( __EH_FRAME_BEGIN__ ) ;


<s> static int initialized ; if ( ! initialized ) { initialized = <NUM_LIT> ; __do_global_ctors ( ) ; }


<s> if ( GET_CODE ( op ) != MEM ) return FALSE ; addr = XEXP ( op , <NUM_LIT> ) ;

return frv_legitimate_address_p_1 ( mode , addr , reload_completed , TRUE , FALSE ) ;


<s> int direct_return_p ( void ) { frv_stack_t * info ; if ( ! reload_completed ) return FALSE ;


<s> frv_stack_t * info ; if ( ! reload_completed ) return FALSE ;


<s> if ( GET_CODE ( x ) == REG ) { unsigned int regno ; FOR_EACH_REGNO ( regno , x ) if ( ( frv_packet . regstate [ regno ] & REGSTATE_MODIFIED ) != <NUM_LIT> ) if ( frv_regstate_conflict_p ( frv_packet . regstate [ regno ] , cond ) ) return true ; } else if ( GET_CODE ( x ) == MEM ) { if ( frv_packet . num_mems > ARRAY_SIZE ( frv_packet . mems ) ) return <NUM_LIT> ;

for ( unsigned int i = <NUM_LIT> ; i < frv_packet . num_mems ; i ++ ) if ( frv_regstate_conflict_p ( frv_packet . mems [ i ] . cond , cond ) ) {


<s> subrtx_iterator :: array_type array ; FOR_EACH_SUBRTX ( iter , array , PATTERN ( insn ) , NONCONST ) if ( REG_P ( * iter ) ) { unsigned int regno = REGNO ( * iter ) ; if ( ACC_P ( regno ) ) return ( regno - ACC_FIRST ) & <NUM_LIT> ? ACC_GROUP_ODD : ACC_GROUP_EVEN ;

if ( ACCG_P ( regno ) ) return ( regno - ACCG_FIRST ) & <NUM_LIT> ? ACC_GROUP_ODD : ACC_GROUP_EVEN ;


<s> packet_group -> insns [ packet_group -> num_insns ++ ] = insn ; frv_packet . insns [ frv_packet . num_insns ++ ] = insn ;

frv_registers_update ( PATTERN ( insn ) ) ;


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

frv_packet . insns [ frv_packet . num_insns ++ ] = insn ;


<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> } 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> 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> for ( x = NEXT_INSN ( last ) ; x != <NUM_LIT> && ! INSN_P ( x ) ; x = NEXT_INSN ( x ) ) { if ( LABEL_P ( x ) ) { unsigned int subalign = <NUM_LIT> << label_to_alignment ( x ) . levels [ <NUM_LIT> ] . log ; 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> ] ;


<s> if ( ++ regno >= FIRST_PSEUDO_REGISTER ) regno = <NUM_LIT> ; 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 ) ;


<s> } nr = hard_regno_nregs ( regno , mode ) ; info -> next_reg [ ( int ) rclass ] = regno + nr ;


<s> 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> const char * name_lr = reg_names [ LR_REGNO ] ; const char * name_gppic = name_jmp ; const char * name_tmp = reg_names [ TEMP_REGNO ] ; fprintf ( file , <STR_LIT> , name_lr , name_tmp ) ; fprintf ( file , <STR_LIT> ) ; fprintf ( file , <STR_LIT> , name_lr , name_gppic ) ; fprintf ( file , <STR_LIT> , name_tmp , name_lr ) ; fprintf ( file , <STR_LIT> , parallel , name_tmp ) ; fprintf ( file , <STR_LIT> , name_tmp ) ; fprintf ( file , <STR_LIT> , name_gppic , name_tmp , name_gppic ) ; fprintf ( file , <STR_LIT> , parallel ) ; assemble_name ( file , name_func ) ; fprintf ( file , <STR_LIT> , name_tmp ) ; fprintf ( file , <STR_LIT> ) ; assemble_name ( file , name_func ) ; fprintf ( file , <STR_LIT> , name_tmp ) ; fprintf ( file , <STR_LIT> , name_gppic , name_tmp , name_jmp ) ; } fprintf ( file , <STR_LIT> , name_jmp , reg_names [ GPR_FIRST + <NUM_LIT> ] ) ;

assemble_end_function ( thunk_fndecl , fnname ) ;


<s> c = atoi ( ptr ) ; frv_print_operand ( f , frv_insn_operands [ c ] , letter ) ; while ( ( c = * ptr ) >= '0' && c <= '9' ) ptr ++ ; } else fputc ( c , f ) ; } fprintf ( f , <STR_LIT> ) ;


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


<s> switch_to_section ( dtors_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 ; }

assemble_integer_with_op ( <STR_LIT> , symbol ) ;


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


<s> if ( ( flag_pic || TARGET_FDPIC ) && size == UNITS_PER_WORD ) { if ( GET_CODE ( value ) == CONST || GET_CODE ( value ) == SYMBOL_REF || GET_CODE ( value ) == LABEL_REF ) { if ( TARGET_FDPIC && GET_CODE ( value ) == SYMBOL_REF && SYMBOL_REF_FUNCTION_P ( value ) ) { fputs ( <STR_LIT> , asm_out_file ) ; output_addr_const ( asm_out_file , value ) ; fputs ( <STR_LIT> , asm_out_file ) ; return true ; } else if ( TARGET_FDPIC && GET_CODE ( value ) == CONST && frv_function_symbol_referenced_p ( value ) ) return false ; if ( aligned_p && ! TARGET_FDPIC ) { static int label_num = <NUM_LIT> ; char buf [ <NUM_LIT> ] ; const char * p ; ASM_GENERATE_INTERNAL_LABEL ( buf , <STR_LIT> , label_num ++ ) ; p = ( * targetm . strip_name_encoding ) ( buf ) ; fprintf ( asm_out_file , <STR_LIT> , p ) ; fprintf ( asm_out_file , <STR_LIT> , FIXUP_SECTION_ASM_OP ) ; fprintf ( asm_out_file , <STR_LIT> , p ) ; fprintf ( asm_out_file , <STR_LIT> ) ; } assemble_integer_with_op ( <STR_LIT> , value ) ; return true ; } if ( ! aligned_p ) {


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


<s> static bool frv_cannot_force_const_mem ( machine_mode mode ATTRIBUTE_UNUSED , rtx x ATTRIBUTE_UNUSED ) { return TARGET_FDPIC ;


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


<s> } if ( ! ( * insn_data [ icode ] . operand [ opnum ] . predicate ) ( opval , VOIDmode ) ) {

error ( <STR_LIT> , insn_data [ icode ] . name ) ;


<s> default : break ; case GR8_REGS : case GR9_REGS : case GR89_REGS : case FDPIC_FPTR_REGS : case FDPIC_REGS : case ICC_REGS : case FCC_REGS : case CC_REGS : case ICR_REGS : case FCR_REGS : case CR_REGS : case LCR_REG : case LR_REG : case SPR_REGS :


<s> break ; case GR8_REGS : case GR9_REGS : case GR89_REGS : case FDPIC_FPTR_REGS : case FDPIC_REGS : case ICC_REGS : case FCC_REGS : case CC_REGS : case ICR_REGS : case FCR_REGS : case CR_REGS : case LCR_REG : case LR_REG : case SPR_REGS : case QUAD_ACC_REGS : case ACCG_REGS :


<s> static int frv_cond_flags ( rtx cond ) {

gcc_assert ( ( GET_CODE ( cond ) == EQ || GET_CODE ( cond ) == NE ) && GET_CODE ( XEXP ( cond , <NUM_LIT> ) ) == REG && CR_P ( REGNO ( XEXP ( cond , <NUM_LIT> ) ) ) && XEXP ( cond , <NUM_LIT> ) == const0_rtx ) ;


<s> unspec -> offset += INTVAL ( XEXP ( x , <NUM_LIT> ) ) ; x = XEXP ( x , <NUM_LIT> ) ; } 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> && unspec -> offset < g_switch_value ) return true ; } } return false ;


<s> unspec -> offset = <NUM_LIT> ; x = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( x ) == PLUS && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ) { unspec -> offset += INTVAL ( XEXP ( x , <NUM_LIT> ) ) ; x = XEXP ( x , <NUM_LIT> ) ; } 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> && unspec -> offset < g_switch_value ) return true ; } } return false ;


<s> fprintf ( stderr , <STR_LIT> , info -> header_size ) ; fprintf ( stderr , <STR_LIT> , info -> pretend_size ) ; fprintf ( stderr , <STR_LIT> , info -> vars_offset ) ; fprintf ( stderr , <STR_LIT> , info -> regs_offset ) ; for ( range = <NUM_LIT> ; range < STACK_REGS_MAX ; range ++ ) { frv_stack_regs_t * regs = & ( info -> regs [ range ] ) ; if ( ( regs -> size_1word + regs -> size_2words ) > <NUM_LIT> ) { int first = regs -> first ; int last = regs -> last ; int regno ; fprintf ( stderr , <STR_LIT> , regs -> name , regs -> size_1word + regs -> size_2words , regs -> size_1word , regs -> size_2words ) ; for ( regno = first ; regno <= last ; regno ++ ) { if ( info -> save_p [ regno ] == REG_SAVE_1WORD ) fprintf ( stderr , <STR_LIT> , reg_names [ regno ] , info -> reg_offset [ regno ] ) ;

else if ( info -> save_p [ regno ] == REG_SAVE_2WORDS ) fprintf ( stderr , <STR_LIT> , reg_names [ regno ] , reg_names [ regno + <NUM_LIT> ] , info -> reg_offset [ regno ] ) ;


<s> if ( ( regs -> size_1word + regs -> size_2words ) > <NUM_LIT> ) { int first = regs -> first ; int last = regs -> last ; int regno ; fprintf ( stderr , <STR_LIT> , regs -> name , regs -> size_1word + regs -> size_2words , regs -> size_1word , regs -> size_2words ) ; for ( regno = first ; regno <= last ; regno ++ ) {

if ( info -> save_p [ regno ] == REG_SAVE_1WORD ) fprintf ( stderr , <STR_LIT> , reg_names [ regno ] , info -> reg_offset [ regno ] ) ;


<s> case FRV_CPU_FR400 : return MASK_DEFAULT_FR400 ; case FRV_CPU_FR300 : case FRV_CPU_SIMPLE : return MASK_DEFAULT_SIMPLE ; default :


<s> switch ( frv_cpu_type ) { case FRV_CPU_GENERIC : return MASK_DEFAULT_FRV ; case FRV_CPU_FR550 : return MASK_DEFAULT_FR550 ; case FRV_CPU_FR500 : case FRV_CPU_TOMCAT : return MASK_DEFAULT_FR500 ; case FRV_CPU_FR450 : return MASK_DEFAULT_FR450 ;


<s> static rtx frv_dwarf_store ( rtx reg , int offset ) { rtx set = gen_rtx_SET ( 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 frv_dynamic_chain_address ( rtx frame ) { cfun -> machine -> frame_needed = <NUM_LIT> ;


<s> rtx frv_dynamic_chain_address ( rtx frame ) { cfun -> machine -> frame_needed = <NUM_LIT> ; return frame ;


<s> label_ref = gen_rtx_LABEL_REF ( VOIDmode , operands [ <NUM_LIT> ] ) ; test_rtx = gen_rtx_fmt_ee ( test , cc_mode , cc_reg , const0_rtx ) ;


src2 = force_reg ( GET_MODE ( dest ) , src2 ) ;


<s> case E_DImode : case E_SFmode : case E_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 :


<s> enum rtx_code test = GET_CODE ( operands [ <NUM_LIT> ] ) ; rtx cc_reg = frv_emit_comparison ( test , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; test_rtx = gen_rtx_fmt_ee ( test , SImode , cc_reg , const0_rtx ) ; set = gen_rtx_SET ( operands [ <NUM_LIT> ] , 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 ) ) ) ;


<s> rtx op1 = frv_read_argument ( call , <NUM_LIT> ) ; if ( ! frv_check_constant_argument ( icode , <NUM_LIT> , op1 ) ) return NULL_RTX ;

target = frv_legitimize_target ( icode , target ) ;


<s> rtx op1 = frv_read_argument ( call , <NUM_LIT> ) ; target = frv_legitimize_target ( icode , target ) ; op0 = frv_legitimize_argument ( icode , <NUM_LIT> , op0 ) ; op1 = frv_legitimize_argument ( icode , <NUM_LIT> , op1 ) ; pat = GEN_FCN ( icode ) ( target , op0 , op1 ) ;


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


<s> int bytes ; int offset ; 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> for ( ; bytes > <NUM_LIT> ; ( bytes -= clear_bytes ) , ( offset += clear_bytes ) ) { dest_addr = ( ( offset == <NUM_LIT> ) ? dest_reg : 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 ; clear_bytes = GET_MODE_SIZE ( mode ) ; dest_mem = change_address ( orig_dest , mode , dest_addr ) ;


<s> static rtx frv_expand_builtin_saveregs ( void ) { int offset = UNITS_PER_WORD * FRV_NUM_ARG_REGS ; if ( TARGET_DEBUG_ARG ) fprintf ( stderr , <STR_LIT> , offset ) ;

return gen_rtx_PLUS ( Pmode , virtual_incoming_args_rtx , GEN_INT ( - offset ) ) ;


<s> if ( TARGET_DEBUG_ARG ) fprintf ( stderr , <STR_LIT> , offset ) ; return gen_rtx_PLUS ( Pmode , virtual_incoming_args_rtx , GEN_INT ( - offset ) ) ;


<s> nextarg = gen_rtx_PLUS ( Pmode , virtual_incoming_args_rtx , GEN_INT ( UNITS_PER_WORD * num ) ) ; if ( TARGET_DEBUG_ARG ) { fprintf ( stderr , <STR_LIT> , crtl -> args . info , num ) ;


<s> nextarg = gen_rtx_PLUS ( Pmode , virtual_incoming_args_rtx , GEN_INT ( UNITS_PER_WORD * num ) ) ; if ( TARGET_DEBUG_ARG ) { fprintf ( stderr , <STR_LIT> , crtl -> args . info , num ) ; debug_rtx ( nextarg ) ; } t = build2 ( MODIFY_EXPR , TREE_TYPE ( valist ) , valist , fold_convert ( TREE_TYPE ( valist ) , make_tree ( sizetype , nextarg ) ) ) ; TREE_SIDE_EFFECTS ( t ) = <NUM_LIT> ;

expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ;


<s> target = frv_legitimize_target ( icode , target ) ; op0 = frv_int_to_acc ( icode , <NUM_LIT> , op0 ) ; if ( ! op0 ) return NULL_RTX ; if ( icode == CODE_FOR_mdcutssi || GET_CODE ( op1 ) == CONST_INT ) { if ( ! frv_check_constant_argument ( icode , <NUM_LIT> , op1 ) ) return NULL_RTX ; } else op1 = frv_legitimize_argument ( icode , <NUM_LIT> , op1 ) ; op2 = frv_matching_accg_for_acc ( op0 ) ; pat = GEN_FCN ( icode ) ( target , op0 , op1 , op2 ) ; if ( ! pat ) return NULL_RTX ; emit_insn ( pat ) ; return target ;


<s> rtx op2 ; target = frv_legitimize_target ( icode , target ) ; op0 = frv_int_to_acc ( icode , <NUM_LIT> , op0 ) ; if ( ! op0 ) return NULL_RTX ; if ( icode == CODE_FOR_mdcutssi || GET_CODE ( op1 ) == CONST_INT ) { if ( ! frv_check_constant_argument ( icode , <NUM_LIT> , op1 ) ) return NULL_RTX ;


<s> 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 ( return_addr , mem ) ) ; }

else return_addr = gen_rtx_REG ( Pmode , LR_REGNO ) ;


<s> 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 ) ; crtl -> 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 ) ; picreg = gen_reg_rtx ( DImode ) ; emit_insn ( gen_movdi_ldd ( picreg , addr ) ) ; if ( sibcall && ret_value ) c = gen_sibcall_value_fdpicdi ( rvrtx , picreg , const0_rtx ) ; else if ( sibcall ) c = gen_sibcall_fdpicdi ( picreg , const0_rtx ) ; else if ( ret_value ) c = gen_call_value_fdpicdi ( rvrtx , picreg , const0_rtx , lr ) ;

else c = gen_call_fdpicdi ( picreg , const0_rtx , lr ) ;


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


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


<s> static rtx frv_expand_load_builtin ( enum insn_code icode , machine_mode target_mode , tree call , rtx target ) { rtx op0 = frv_read_argument ( call , <NUM_LIT> ) ;

rtx cookie = frv_io_address_cookie ( op0 ) ;


<s> convert_move ( target , op0 , <NUM_LIT> ) ; emit_insn ( GEN_FCN ( icode ) ( copy_rtx ( op0 ) , cookie , GEN_INT ( FRV_IO_READ ) ) ) ; cfun -> machine -> has_membar_p = <NUM_LIT> ; return target ;


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


<s> static rtx frv_expand_mclracc_builtin ( tree call ) { enum insn_code icode = CODE_FOR_mclracc ; rtx pat ; rtx op0 = frv_read_argument ( call , <NUM_LIT> ) ;


<s> emit_clobber ( op1 ) ; emit_move_insn ( simplify_gen_subreg ( HImode , op0 , DImode , <NUM_LIT> ) , arg1 ) ; emit_move_insn ( simplify_gen_subreg ( HImode , op0 , DImode , <NUM_LIT> ) , arg2 ) ; emit_move_insn ( simplify_gen_subreg ( HImode , op1 , DImode , <NUM_LIT> ) , arg3 ) ;

emit_move_insn ( simplify_gen_subreg ( HImode , op1 , DImode , <NUM_LIT> ) , arg4 ) ;


<s> pat = GEN_FCN ( icode ) ( target , op0 ) ; if ( ! pat ) return NULL_RTX ; emit_insn ( pat ) ;


<s> rtx pat ; rtx op0 = frv_read_argument ( call , <NUM_LIT> ) ; rtx op1 = frv_read_argument ( call , <NUM_LIT> ) ; op0 = frv_int_to_acc ( icode , <NUM_LIT> , op0 ) ; if ( ! op0 ) return NULL_RTX ;


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


<s> rtx pat = GEN_FCN ( icode ) ( const0_rtx ) ; if ( pat ) emit_insn ( pat ) ; return NULL_RTX ;


<s> rtx op0 = frv_read_argument ( call , <NUM_LIT> ) ; pat = GEN_FCN ( icode ) ( force_reg ( Pmode , op0 ) ) ;


<s> 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 ( 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 ( fp , asm_src ) , gen_rtx_SET ( fp , dwarf_src ) ) ; accessor . base = fp ;


<s> { 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 ( 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 ( fp , asm_src ) , gen_rtx_SET ( fp , dwarf_src ) ) ;


<s> target = frv_legitimize_target ( icode , target ) ; pat = GEN_FCN ( icode ) ( target , op0 ) ; if ( ! pat ) return NULL_RTX ;


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


<s> rtx op1 = frv_read_argument ( call , <NUM_LIT> ) ; 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> ;


<s> static rtx frv_expand_store_builtin ( enum insn_code icode , tree call ) { rtx op0 = frv_read_argument ( call , <NUM_LIT> ) ; rtx op1 = frv_read_argument ( call , <NUM_LIT> ) ;


<s> static rtx frv_expand_unop_builtin ( enum insn_code icode , tree call , rtx target ) { rtx pat ; rtx op0 = frv_read_argument ( call , <NUM_LIT> ) ; target = frv_legitimize_target ( icode , target ) ; op0 = frv_legitimize_argument ( icode , <NUM_LIT> , op0 ) ; pat = GEN_FCN ( icode ) ( target , op0 ) ; if ( ! pat ) return NULL_RTX ; emit_insn ( pat ) ;


<s> 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 ) ; op3 = frv_matching_accg_for_acc ( op1 ) ; pat = GEN_FCN ( icode ) ( op0 , op1 , op2 , op3 ) ;


<s> rtx reg = op0 ; if ( ! offsettable_address_p ( <NUM_LIT> , mode0 , op0 ) ) { reg = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_rtx_SET ( reg , op0 ) ) ; } op0 = gen_rtx_MEM ( SImode , reg ) ; } addr = XEXP ( op0 , <NUM_LIT> ) ; if ( ! offsettable_address_p ( <NUM_LIT> , mode0 , addr ) ) addr = copy_to_mode_reg ( Pmode , op0 ) ; op0 = change_address ( op0 , V4SImode , addr ) ; op1 = frv_legitimize_argument ( icode , <NUM_LIT> , op1 ) ; pat = GEN_FCN ( icode ) ( op0 , op1 ) ; if ( ! pat ) return <NUM_LIT> ; emit_insn ( pat ) ;


<s> 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 ) ; if ( ! pat ) return NULL_RTX ;


<s> 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 ) ; if ( ! pat ) return NULL_RTX ; emit_insn ( pat ) ; return NULL_RTX ;


<s> extract_insn ( insn ) ; io -> type = ( enum frv_io_type ) INTVAL ( recog_data . operand [ <NUM_LIT> ] ) ;

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


<s> static void frv_extract_membar ( struct frv_io * io , rtx_insn * insn ) { extract_insn ( insn ) ; io -> type = ( enum frv_io_type ) INTVAL ( recog_data . operand [ <NUM_LIT> ] ) ;


<s> struct frv_unspec unspec ; if ( frv_const_unspec_p ( x , & unspec ) && frv_small_data_reloc_p ( unspec . symbol , unspec . reloc ) ) return plus_constant ( Pmode , unspec . symbol , unspec . offset ) ;


<s> static void frv_finish_packet ( void ( * handle_packet ) ( void ) ) { if ( frv_packet . num_insns > <NUM_LIT> ) {


<s> frv_finish_packet ( handle_packet ) ; frv_start_packet_block ( ) ; } if ( INSN_P ( insn ) ) switch ( GET_CODE ( PATTERN ( insn ) ) ) { case USE : case CLOBBER : break ; default : if ( CALL_P ( 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 ; }


<s> emit_insn ( gen_rtx_SET ( reg , mem ) ) ; } emit_use ( reg ) ; } else { if ( SPR_P ( REGNO ( reg ) ) ) { rtx temp = gen_rtx_REG ( mode , TEMP_REGNO ) ; emit_insn ( gen_rtx_SET ( temp , reg ) ) ; frv_frame_insn ( gen_rtx_SET ( 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> ) ) ) ; mem = gen_rtx_MEM ( DImode , temp ) ; } frv_frame_insn ( gen_rtx_SET ( mem , reg ) , gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , set1 , set2 ) ) ) ;


<s> } emit_insn ( gen_rtx_SET ( reg , mem ) ) ; } emit_use ( reg ) ; } else { if ( SPR_P ( REGNO ( reg ) ) ) { rtx temp = gen_rtx_REG ( mode , TEMP_REGNO ) ; emit_insn ( gen_rtx_SET ( temp , reg ) ) ; frv_frame_insn ( gen_rtx_SET ( 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> for ( regno = regs_info -> first ; regno <= regs_info -> last ; regno ++ ) if ( info -> save_p [ regno ] ) frv_frame_access ( accessor , info -> save_p [ regno ] == REG_SAVE_2WORDS ? gen_rtx_REG ( DImode , regno ) : gen_rtx_REG ( SImode , regno ) , info -> reg_offset [ regno ] ) ;


<s> accessor . base = stack_pointer_rtx ; accessor . base_offset = <NUM_LIT> ; frv_frame_access_multi ( & accessor , info , STACK_REGS_GPR ) ; frv_frame_access_multi ( & accessor , info , STACK_REGS_FPR ) ; frv_frame_access_multi ( & accessor , info , STACK_REGS_LCR ) ;


<s> static void frv_frame_access_standard_regs ( enum frv_stack_op op , frv_stack_t * info ) { frv_frame_accessor_t accessor ; accessor . op = op ;


RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ;


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


<s> rtx reg_rtx = gen_rtx_REG ( SImode , OFFSET_REGNO ) ; if ( IN_RANGE ( offset , - <NUM_LIT> , <NUM_LIT> ) ) emit_insn ( gen_movsi ( reg_rtx , offset_rtx ) ) ; else { emit_insn ( gen_movsi_high ( reg_rtx , offset_rtx ) ) ; emit_insn ( gen_movsi_lo_sum ( reg_rtx , offset_rtx ) ) ;


<s> static bool frv_frame_pointer_required ( void ) { if ( ! TARGET_LINKED_FP ) return ! crtl -> sp_is_unchanging ; if ( ! crtl -> is_leaf ) return true ; if ( get_frame_size ( ) != <NUM_LIT> ) return true ; if ( cfun -> stdarg ) return true ; if ( ! crtl -> sp_is_unchanging ) return true ;

if ( ! TARGET_FDPIC && flag_pic && crtl -> uses_pic_offset_table ) return true ;


<s> if ( cfun -> stdarg ) return true ; if ( ! crtl -> sp_is_unchanging ) return true ; if ( ! TARGET_FDPIC && flag_pic && crtl -> uses_pic_offset_table ) return true ; if ( profile_flag ) return true ; if ( cfun -> machine -> frame_needed ) return true ; return false ;


<s> machine_mode xmode = ( arg . mode == BLKmode ) ? SImode : arg . 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 ( arg . mode ) , arg . named , words * UNITS_PER_WORD ) ;


<s> static unsigned int frv_function_arg_boundary ( machine_mode mode ATTRIBUTE_UNUSED , const_tree type ATTRIBUTE_UNUSED ) {


<s> while ( insn != NULL && ! ( JUMP_P ( insn ) && get_attr_far_jump ( insn ) == FAR_JUMP_YES ) ) insn = NEXT_INSN ( insn ) ; return ( insn != NULL ) ;


while ( insn != NULL && ! ( JUMP_P ( insn ) && get_attr_far_jump ( insn ) == FAR_JUMP_YES ) ) insn = NEXT_INSN ( insn ) ;


<s> static void frv_function_epilogue ( FILE * ) { frv_stack_cache = ( frv_stack_t * ) <NUM_LIT> ; memset ( & frv_ifcvt . tmp_reg , <NUM_LIT> , sizeof ( frv_ifcvt . tmp_reg ) ) ; BITMAP_FREE ( frv_ifcvt . scratch_insns_bitmap ) ;


<s> return frv_function_arg_1 ( cum , arg , true ) ;


<s> static bool frv_function_ok_for_sibcall ( tree decl ATTRIBUTE_UNUSED , tree exp ATTRIBUTE_UNUSED ) {


<s> rtx address = XEXP ( XVECEXP ( pattern , <NUM_LIT> , <NUM_LIT> ) , <NUM_LIT> ) ; 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 ) ) ;


<s> 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 ) SET_REGNO ( address , GPR_FIRST + <NUM_LIT> ) ; } }


<s> case 'e' : if ( frv_function_symbol_referenced_p ( XEXP ( x , j ) ) ) return TRUE ; break ; case 'V' : case 'E' : if ( XVEC ( x , j ) != <NUM_LIT> ) { int k ; for ( k = <NUM_LIT> ; k < XVECLEN ( x , j ) ; ++ k ) if ( frv_function_symbol_referenced_p ( XVECEXP ( x , j , k ) ) ) return TRUE ; } break ; default :


<s> static bool frv_function_symbol_referenced_p ( rtx x ) { const char * format ; int length ; int j ; if ( GET_CODE ( x ) == SYMBOL_REF ) return SYMBOL_REF_FUNCTION_P ( x ) ; length = GET_RTX_LENGTH ( GET_CODE ( x ) ) ; format = GET_RTX_FORMAT ( GET_CODE ( x ) ) ; for ( j = <NUM_LIT> ; j < length ; ++ j ) {


return gen_rtx_REG ( TYPE_MODE ( valtype ) , RETURN_VALUE_REGNUM ) ;


<s> return gen_symGOT2reg ( dest , gp_sym , src , GEN_INT ( R_FRV_GOT12 ) ) ;


<s> rtx gp_sym = gen_rtx_SYMBOL_REF ( Pmode , IDENTIFIER_POINTER ( gp ) ) ; return gen_symGOT2reg ( dest , gp_sym , src , GEN_INT ( R_FRV_GOT12 ) ) ;


<s> switch ( mode ) { case E_CCmode : case E_CC_UNSmode : case E_CC_NZmode : return ICC_P ( regno ) || GPR_P ( regno ) ; case E_CC_CCRmode : return CR_P ( regno ) || GPR_P ( regno ) ; case E_CC_FPmode : return FCC_P ( regno ) || GPR_P ( regno ) ; default : break ; } if ( INTEGRAL_MODE_P ( mode ) || FLOAT_MODE_P ( mode ) || VECTOR_MODE_P ( mode ) ) { if ( ACCG_P ( regno ) ) { base = ACCG_FIRST ; mask = GET_MODE_SIZE ( mode ) - <NUM_LIT> ; } else {

if ( GPR_P ( regno ) || regno == AP_FIRST ) base = GPR_FIRST ;


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

if ( ACCG_P ( regno ) ) return GET_MODE_SIZE ( mode ) ;


<s> if ( ACCG_P ( regno ) ) return GET_MODE_SIZE ( mode ) ;

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


fprintf ( stderr , <STR_LIT> , ( before_p ) ? <STR_LIT> : <STR_LIT> , ( int ) INSN_UID ( insn ) ) ;


<s> 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 ;


<s> 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 ( 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 ( 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 ( 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 ) ;


<s> 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 ( 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 ) ;


<s> } else return NULL_RTX ; } else if ( CONSTANT_P ( addr ) ) addr = frv_ifcvt_load_value ( addr , insn ) ; else return NULL_RTX ; if ( addr == NULL_RTX ) return NULL_RTX ;

else if ( XEXP ( mem , <NUM_LIT> ) != addr ) return change_address ( mem , mode , addr ) ;


<s> rtx base = XEXP ( memref , <NUM_LIT> ) ;

if ( GET_CODE ( base ) == PRE_MODIFY ) base = XEXP ( base , <NUM_LIT> ) ;


<s> return change_address ( memref , mode , plus_constant ( Pmode , base , index * GET_MODE_SIZE ( mode ) ) ) ;


<s> if ( to == STACK_POINTER_REGNUM && from == ARG_POINTER_REGNUM ) ret = info -> total_size - info -> pretend_size ; else if ( to == STACK_POINTER_REGNUM && from == FRAME_POINTER_REGNUM ) ret = info -> reg_offset [ FRAME_POINTER_REGNUM ] ; else if ( to == FRAME_POINTER_REGNUM && from == ARG_POINTER_REGNUM ) ret = ( info -> total_size - info -> reg_offset [ FRAME_POINTER_REGNUM ] - info -> pretend_size ) ; else gcc_unreachable ( ) ; if ( TARGET_DEBUG_STACK ) fprintf ( stderr , <STR_LIT> , reg_names [ from ] , reg_names [ to ] , ret ) ;


<s> if ( fntype ) { tree ret_type = TREE_TYPE ( fntype ) ; fprintf ( stderr , <STR_LIT> , get_tree_code_name ( TREE_CODE ( ret_type ) ) ) ; } if ( libname && GET_CODE ( libname ) == SYMBOL_REF ) fprintf ( stderr , <STR_LIT> , XSTR ( libname , <NUM_LIT> ) ) ;

if ( cfun -> returns_struct ) fprintf ( stderr , <STR_LIT> ) ;


<s> if ( TARGET_DEBUG_ARG ) { fprintf ( stderr , <STR_LIT> ) ; 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> , get_tree_code_name ( TREE_CODE ( ret_type ) ) ) ; } if ( libname && GET_CODE ( libname ) == SYMBOL_REF ) fprintf ( stderr , <STR_LIT> , XSTR ( libname , <NUM_LIT> ) ) ;


<s> set_optab_libfunc ( sdiv_optab , SFmode , <STR_LIT> ) ; set_optab_libfunc ( add_optab , DFmode , <STR_LIT> ) ; set_optab_libfunc ( sub_optab , DFmode , <STR_LIT> ) ; set_optab_libfunc ( smul_optab , DFmode , <STR_LIT> ) ; set_optab_libfunc ( sdiv_optab , DFmode , <STR_LIT> ) ; set_conv_libfunc ( sext_optab , DFmode , SFmode , <STR_LIT> ) ; set_conv_libfunc ( trunc_optab , SFmode , DFmode , <STR_LIT> ) ; set_conv_libfunc ( sfix_optab , SImode , SFmode , <STR_LIT> ) ; set_conv_libfunc ( sfix_optab , DImode , SFmode , <STR_LIT> ) ; set_conv_libfunc ( sfix_optab , SImode , DFmode , <STR_LIT> ) ; set_conv_libfunc ( sfix_optab , DImode , DFmode , <STR_LIT> ) ; set_conv_libfunc ( ufix_optab , SImode , SFmode , <STR_LIT> ) ; set_conv_libfunc ( ufix_optab , DImode , SFmode , <STR_LIT> ) ; set_conv_libfunc ( ufix_optab , SImode , DFmode , <STR_LIT> ) ; set_conv_libfunc ( ufix_optab , DImode , DFmode , <STR_LIT> ) ; set_conv_libfunc ( sfloat_optab , SFmode , SImode , <STR_LIT> ) ; set_conv_libfunc ( sfloat_optab , SFmode , DImode , <STR_LIT> ) ;

set_conv_libfunc ( sfloat_optab , DFmode , SImode , <STR_LIT> ) ;


<s> set_optab_libfunc ( umod_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( and_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( ior_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( xor_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( one_cmpl_optab , DImode , <STR_LIT> ) ; set_optab_libfunc ( add_optab , SFmode , <STR_LIT> ) ; set_optab_libfunc ( sub_optab , SFmode , <STR_LIT> ) ; set_optab_libfunc ( smul_optab , SFmode , <STR_LIT> ) ; set_optab_libfunc ( sdiv_optab , SFmode , <STR_LIT> ) ; set_optab_libfunc ( add_optab , DFmode , <STR_LIT> ) ; set_optab_libfunc ( sub_optab , DFmode , <STR_LIT> ) ; set_optab_libfunc ( smul_optab , DFmode , <STR_LIT> ) ; set_optab_libfunc ( sdiv_optab , DFmode , <STR_LIT> ) ; set_conv_libfunc ( sext_optab , DFmode , SFmode , <STR_LIT> ) ; set_conv_libfunc ( trunc_optab , SFmode , DFmode , <STR_LIT> ) ; set_conv_libfunc ( sfix_optab , SImode , SFmode , <STR_LIT> ) ; set_conv_libfunc ( sfix_optab , DImode , SFmode , <STR_LIT> ) ; set_conv_libfunc ( sfix_optab , SImode , DFmode , <STR_LIT> ) ; set_conv_libfunc ( sfix_optab , DImode , DFmode , <STR_LIT> ) ;

set_conv_libfunc ( ufix_optab , SImode , SFmode , <STR_LIT> ) ;


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


<s> rtx_insn * last ; packet_group = & frv_packet . groups [ frv_unit_groups [ frv_insn_unit ( insn ) ] ] ; last = frv_packet . insns [ frv_packet . num_insns - <NUM_LIT> ] ; if ( ! NONJUMP_INSN_P ( last ) ) { 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 ;


<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> if ( ( INTVAL ( opval ) & ~ ACC_MASK ) != <NUM_LIT> ) { error ( <STR_LIT> ) ; return NULL_RTX ; } reg = gen_rtx_REG ( insn_data [ icode ] . operand [ opnum ] . mode , ACC_FIRST + INTVAL ( opval ) ) ; if ( ! ( * insn_data [ icode ] . operand [ opnum ] . predicate ) ( reg , VOIDmode ) ) SET_REGNO ( reg , ACCG_FIRST + INTVAL ( opval ) ) ; if ( ! ( * insn_data [ icode ] . operand [ opnum ] . predicate ) ( reg , VOIDmode ) ) {

error ( <STR_LIT> , insn_data [ icode ] . name ) ;


<s> if ( startswith ( section_name , <STR_LIT> ) ) return true ; if ( startswith ( section_name , <STR_LIT> ) ) return true ; return false ; } size = int_size_in_bytes ( TREE_TYPE ( decl ) ) ;

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


<s> static rtx frv_io_address_cookie ( rtx address ) {

return ( GET_CODE ( address ) == CONST_INT ? GEN_INT ( INTVAL ( address ) / <NUM_LIT> * <NUM_LIT> ) : const0_rtx ) ;


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


<s> if ( io1 -> type == FRV_IO_WRITE && io2 -> type == FRV_IO_WRITE ) return true ; if ( io1 -> type != FRV_IO_WRITE && io2 -> type != FRV_IO_WRITE ) return false ;


<s> if ( io1 -> type == FRV_IO_WRITE && io2 -> type == FRV_IO_WRITE ) return true ;

if ( io1 -> type != FRV_IO_WRITE && io2 -> type != FRV_IO_WRITE ) return false ;


<s> unsigned int regno ; if ( REG_P ( x ) ) FOR_EACH_REGNO ( regno , x ) CLEAR_HARD_REG_BIT ( * set , regno ) ;


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

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


<s> static void frv_io_handle_use ( rtx * x , void * data ) { find_all_hard_regs ( * x , ( HARD_REG_SET * ) data ) ;


<s> if ( ! frv_same_doubleword_p ( x , y ) ) { x -> const_address = <NUM_LIT> ;


<s> static bool frv_issues_to_branch_unit_p ( rtx_insn * insn ) {

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


<s> bool frv_legitimate_address_p ( machine_mode mode , rtx x , bool strict_p ) { return frv_legitimate_address_p_1 ( mode , x , strict_p , FALSE , FALSE ) ;


<s> 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 ; switch ( GET_CODE ( x1 ) ) { default : break ; case SUBREG : x1 = SUBREG_REG ( x1 ) ; if ( GET_CODE ( x1 ) != REG ) break ; case REG : if ( ! allow_double_reg_p && GET_MODE_SIZE ( mode ) > UNITS_PER_WORD ) ret = FALSE ; else ret = frv_regno_ok_for_base_p ( REGNO ( x1 ) , strict_p ) ; break ; case CONST_INT : if ( condexec_p ) ret = FALSE ; else { value = INTVAL ( x1 ) ;

ret = IN_RANGE ( value , - <NUM_LIT> , <NUM_LIT> ) ;


<s> if ( GET_MODE ( x ) == VOIDmode || mode == DImode ) return TRUE ; if ( x == CONST0_RTX ( mode ) ) return TRUE ; if ( ! TARGET_HAS_FPRS ) return TRUE ; if ( mode == DFmode && ! TARGET_DOUBLE ) return TRUE ; return FALSE ;


<s> rtx frv_legitimize_address ( rtx x , rtx oldx ATTRIBUTE_UNUSED , machine_mode mode ATTRIBUTE_UNUSED ) {


<s> 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> static rtx frv_legitimize_argument ( enum insn_code icode , int opnum , rtx arg ) { machine_mode mode = insn_data [ icode ] . operand [ opnum ] . mode ;

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


<s> static rtx frv_legitimize_target ( enum insn_code icode , rtx target ) { 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> rtx picreg = get_hard_reg_initial_val ( Pmode , <NUM_LIT> ) ; switch ( model ) { case TLS_MODEL_INITIAL_EXEC : if ( flag_pic == <NUM_LIT> ) { dest = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_tls_load_gottlsoff12 ( dest , addr , picreg ) ) ; dest = gen_rtx_PLUS ( Pmode , tp , dest ) ; } else { rtx tmp = gen_reg_rtx ( Pmode ) ; 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 ( reg , gen_rtx_PLUS ( Pmode , retval , tp ) ) ) ; dest = gen_tlsmoff ( addr , reg ) ; break ; } case TLS_MODEL_LOCAL_EXEC : dest = gen_tlsmoff ( addr , gen_rtx_REG ( Pmode , <NUM_LIT> ) ) ; break ; case TLS_MODEL_GLOBAL_DYNAMIC : { rtx retval ; if ( TARGET_INLINE_PLT ) retval = gen_inlined_tls_plt ( addr ) ; else { retval = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_call_gettlsoff ( retval , addr , picreg ) ) ;


<s> if ( vis == VISIBILITY_PROTECTED ) vis = VISIBILITY_DEFAULT ; else if ( flag_shlib ) return TRUE ; ret = default_binds_local_p_1 ( fn , flag_pic ) ; DECL_VISIBILITY ( fn ) = vis ; return ret ;


<s> fn = SYMBOL_REF_DECL ( fnx ) ; if ( ! fn ) return FALSE ; vis = DECL_VISIBILITY ( fn ) ; if ( vis == VISIBILITY_PROTECTED ) vis = VISIBILITY_DEFAULT ; else if ( flag_shlib ) return TRUE ; ret = default_binds_local_p_1 ( fn , flag_pic ) ; DECL_VISIBILITY ( fn ) = vis ; return ret ;


<s> return gen_rtx_REG ( frv_matching_accg_mode ( GET_MODE ( acc ) ) , REGNO ( acc ) - ACC_FIRST + ACCG_FIRST ) ;


<s> case E_DImode : return HImode ; case E_SImode : return QImode ; default : gcc_unreachable ( ) ; }


<s> static int frv_memory_move_cost ( machine_mode mode ATTRIBUTE_UNUSED , reg_class_t rclass ATTRIBUTE_UNUSED , bool in ATTRIBUTE_UNUSED ) {


<s> static int frv_memory_move_cost ( machine_mode mode ATTRIBUTE_UNUSED , reg_class_t rclass ATTRIBUTE_UNUSED , bool in ATTRIBUTE_UNUSED ) { return <NUM_LIT> ;


<s> return arg . mode == BLKmode || arg . aggregate_type_p ( ) ;


<s> static bool frv_must_pass_in_stack ( const function_arg_info & arg ) { return arg . mode == BLKmode || arg . aggregate_type_p ( ) ;


<s> static void frv_optimize_membar ( void ) { basic_block bb ; struct frv_io * first_io ; rtx_insn * * last_membar ; compute_bb_for_insn ( ) ; first_io = XCNEWVEC ( struct frv_io , last_basic_block_for_fn ( cfun ) ) ; last_membar = XCNEWVEC ( rtx_insn * , last_basic_block_for_fn ( cfun ) ) ; FOR_EACH_BB_FN ( bb , cfun ) frv_optimize_membar_local ( bb , & first_io [ bb -> index ] , & last_membar [ bb -> index ] ) ;

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


<s> FOR_EACH_BB_FN ( bb , cfun ) frv_optimize_membar_local ( bb , & first_io [ bb -> index ] , & last_membar [ bb -> index ] ) ;


<s> for ( ei_next ( & ei ) ; ei_cond ( ei , & succ ) ; ei_next ( & ei ) ) frv_io_union ( & next_io , & first_io [ succ -> dest -> index ] ) ; } else gcc_unreachable ( ) ; frv_extract_membar ( & this_io , membar ) ; if ( frv_io_fixed_order_p ( & this_io , & next_io ) ) { if ( dump_file ) fprintf ( dump_file , <STR_LIT> <STR_LIT> , INSN_UID ( membar ) ) ; delete_insn ( membar ) ; }


<s> * next_io = prev_io ; } break ; default : if ( next_io -> var_address ) note_stores ( 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> ; delete_insn ( next_membar ) ; next_membar = <NUM_LIT> ; } } if ( volatile_refs_p ( PATTERN ( insn ) ) ) CLEAR_HARD_REG_SET ( used_regs ) ; else note_stores ( insn , frv_io_handle_set , & used_regs ) ; note_uses ( & PATTERN ( insn ) , frv_io_handle_use , & used_regs ) ;


<s> for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) { enum reg_class rclass ; if ( GPR_P ( regno ) ) { int gpr_reg = regno - GPR_FIRST ; if ( gpr_reg == GR8_REG ) rclass = GR8_REGS ; else if ( gpr_reg == GR9_REG ) rclass = GR9_REGS ; else if ( gpr_reg == GR14_REG ) rclass = FDPIC_FPTR_REGS ; else if ( gpr_reg == FDPIC_REGNO ) rclass = FDPIC_REGS ; else if ( ( gpr_reg & <NUM_LIT> ) == <NUM_LIT> ) rclass = QUAD_REGS ; else if ( ( gpr_reg & <NUM_LIT> ) == <NUM_LIT> ) rclass = EVEN_REGS ; else rclass = GPR_REGS ; } else if ( FPR_P ( regno ) ) { int fpr_reg = regno - GPR_FIRST ; if ( ( fpr_reg & <NUM_LIT> ) == <NUM_LIT> ) rclass = QUAD_FPR_REGS ; else if ( ( fpr_reg & <NUM_LIT> ) == <NUM_LIT> ) rclass = FEVEN_REGS ; else rclass = FPR_REGS ; }

else if ( regno == LR_REGNO ) rclass = LR_REG ;


<s> if ( ! flag_pic ) flag_pic = <NUM_LIT> ; if ( ! OPTION_SET_P ( g_switch_value ) ) { g_switch_value = <NUM_LIT> ; } } for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) { enum reg_class rclass ; if ( GPR_P ( regno ) ) { int gpr_reg = regno - GPR_FIRST ; if ( gpr_reg == GR8_REG ) rclass = GR8_REGS ; else if ( gpr_reg == GR9_REG ) rclass = GR9_REGS ; else if ( gpr_reg == GR14_REG ) rclass = FDPIC_FPTR_REGS ; else if ( gpr_reg == FDPIC_REGNO ) rclass = FDPIC_REGS ; else if ( ( gpr_reg & <NUM_LIT> ) == <NUM_LIT> ) rclass = QUAD_REGS ; else if ( ( gpr_reg & <NUM_LIT> ) == <NUM_LIT> ) rclass = EVEN_REGS ; else rclass = GPR_REGS ; } else if ( FPR_P ( regno ) ) { int fpr_reg = regno - GPR_FIRST ; if ( ( fpr_reg & <NUM_LIT> ) == <NUM_LIT> ) rclass = QUAD_FPR_REGS ; else if ( ( fpr_reg & <NUM_LIT> ) == <NUM_LIT> ) rclass = FEVEN_REGS ; else rclass = FPR_REGS ; } else if ( regno == LR_REGNO ) rclass = LR_REG ; else if ( regno == LCR_REGNO ) rclass = LCR_REG ; else if ( ICC_P ( regno ) ) rclass = ICC_REGS ; else if ( FCC_P ( regno ) ) rclass = FCC_REGS ; else if ( ICR_P ( regno ) ) rclass = ICR_REGS ; else if ( FCR_P ( regno ) ) rclass = FCR_REGS ; else if ( ACC_P ( regno ) ) { int r = regno - ACC_FIRST ; if ( ( r & <NUM_LIT> ) == <NUM_LIT> ) rclass = QUAD_ACC_REGS ;

else if ( ( r & <NUM_LIT> ) == <NUM_LIT> ) rclass = EVEN_ACC_REGS ;


<s> static void frv_output_dwarf_dtprel ( FILE * file , int size , rtx x ) { gcc_assert ( size == <NUM_LIT> ) ;


<s> if ( frv_for_each_packet ( frv_reorder_packet ) ) frv_insn_packing_flag = <NUM_LIT> ;


<s> static void frv_pack_insns ( void ) { if ( frv_for_each_packet ( frv_reorder_packet ) ) frv_insn_packing_flag = <NUM_LIT> ; else frv_insn_packing_flag = - <NUM_LIT> ;


<s> 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> && NONJUMP_INSN_P ( 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> switch ( GET_CODE ( x ) ) { 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> case LABEL_REF : case CONST : output_addr_const ( stream , x ) ; return ; case PLUS : frv_print_operand_memory_reference ( stream , x , <NUM_LIT> ) ; return ; default : break ; } fatal_insn ( <STR_LIT> , x ) ;


<s> case SUBREG : case REG : x0 = x ; break ; case PRE_MODIFY : x0 = XEXP ( x , <NUM_LIT> ) ; x1 = XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ; break ; case CONST_INT : x1 = x ; break ; case PLUS : x0 = XEXP ( x , <NUM_LIT> ) ; x1 = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( x0 ) == CONST_INT ) { x0 = XEXP ( x , <NUM_LIT> ) ; x1 = XEXP ( x , <NUM_LIT> ) ; } break ; default : fatal_insn ( <STR_LIT> , x ) ; break ; } if ( addr_offset ) { if ( ! x1 ) x1 = const0_rtx ; else if ( GET_CODE ( x1 ) != CONST_INT ) fatal_insn ( <STR_LIT> , x ) ; } fputs ( <STR_LIT> , stream ) ; if ( ! x0 ) fputs ( reg_names [ GPR_R0 ] , stream ) ; else if ( GET_CODE ( x0 ) == REG || GET_CODE ( x0 ) == SUBREG ) frv_print_operand_memory_reference_reg ( stream , x0 ) ; else fatal_insn ( <STR_LIT> , x ) ; fputs ( <STR_LIT> , stream ) ; if ( ! x1 ) fputs ( reg_names [ GPR_R0 ] , stream ) ; else { switch ( GET_CODE ( x1 ) ) {


<s> static void frv_print_operand_memory_reference_reg ( FILE * stream , rtx x ) {


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


<s> static rtx frv_read_argument ( tree exp , unsigned int index ) {

return expand_normal ( CALL_EXPR_ARG ( exp , index ) ) ;


<s> if ( frv_registers_conflict_p_1 ( XEXP ( x , <NUM_LIT> ) , flags ) ) return true ; flags |= frv_cond_flags ( XEXP ( x , <NUM_LIT> ) ) ; x = XEXP ( x , <NUM_LIT> ) ;


<s> else if ( GET_CODE ( x ) == MEM ) { if ( frv_packet . num_mems > ARRAY_SIZE ( frv_packet . mems ) ) return <NUM_LIT> ; for ( unsigned int i = <NUM_LIT> ; i < frv_packet . num_mems ; i ++ ) if ( frv_regstate_conflict_p ( frv_packet . mems [ i ] . cond , cond ) ) { if ( true_dependence ( frv_packet . mems [ i ] . mem , VOIDmode , x ) ) return true ; if ( output_dependence ( frv_packet . mems [ i ] . mem , x ) ) return true ; } } else if ( GET_CODE ( x ) == SET && GET_CODE ( SET_SRC ( x ) ) == CALL ) iter . substitute ( SET_SRC ( x ) ) ; }


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


<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> 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 ACCG_REGS : return MEDIUM_COST ; case QUAD_FPR_REGS : return LOW_COST ; } break ; case LCR_REG : case LR_REG : case SPR_REGS : switch ( to ) { default : break ; case QUAD_REGS : case GPR_REGS : case GR8_REGS : case GR9_REGS : case GR89_REGS : case FDPIC_REGS : case FDPIC_FPTR_REGS : case FDPIC_CALL_REGS : return MEDIUM_COST ; } break ; case QUAD_ACC_REGS : case ACCG_REGS : switch ( to ) { default : break ; case QUAD_FPR_REGS :


<s> if ( strict_p ) return ( reg_renumber [ regno ] >= <NUM_LIT> && GPR_P ( reg_renumber [ regno ] ) ) ; if ( regno == ARG_POINTER_REGNUM ) return TRUE ; return ( regno >= FIRST_PSEUDO_REGISTER ) ;


<s> static FRV_INLINE int frv_regno_ok_for_base_p ( int regno , int strict_p ) { if ( GPR_P ( regno ) ) return TRUE ; if ( strict_p ) return ( reg_renumber [ regno ] >= <NUM_LIT> && GPR_P ( reg_renumber [ regno ] ) ) ; if ( regno == ARG_POINTER_REGNUM ) return TRUE ; return ( regno >= FIRST_PSEUDO_REGISTER ) ;


<s> if ( ( cond1 & REGSTATE_IF_EITHER ) == <NUM_LIT> || ( cond2 & REGSTATE_IF_EITHER ) == <NUM_LIT> ) return true ; if ( ( cond1 & REGSTATE_CC_MASK ) != ( cond2 & REGSTATE_CC_MASK ) ) return true ; if ( ( cond1 & cond2 & REGSTATE_IF_EITHER ) != <NUM_LIT> ) return true ;


<s> static bool frv_regstate_conflict_p ( regstate_t cond1 , regstate_t cond2 ) { if ( ( cond1 & REGSTATE_IF_EITHER ) == <NUM_LIT> || ( cond2 & REGSTATE_IF_EITHER ) == <NUM_LIT> ) return true ; if ( ( cond1 & REGSTATE_CC_MASK ) != ( cond2 & REGSTATE_CC_MASK ) ) return true ; if ( ( cond1 & cond2 & REGSTATE_IF_EITHER ) != <NUM_LIT> ) return true ; return false ;


<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 ] ++ ] ; }


<s> cursor [ group ] = <NUM_LIT> ; frv_sort_insn_group ( group ) ; } 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> frv_register_nop ( gen_nop ( ) ) ; if ( TARGET_MEDIA ) frv_register_nop ( gen_mnop ( ) ) ; if ( TARGET_HARD_FLOAT ) frv_register_nop ( gen_fnop ( ) ) ; shorten_branches ( get_insns ( ) ) ; frv_packet_address = <NUM_LIT> ; frv_for_each_packet ( frv_reorg_packet ) ;


<s> static void frv_reorg_packet ( void ) {


<s> frv_fill_unused_units ( GROUP_FM ) ;


<s> case NOT : case NEG : case COMPARE : if ( mode == SImode ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else if ( mode == DImode ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case MULT : if ( mode == SImode ) * total = COSTS_N_INSNS ( <NUM_LIT> ) ; else * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case DIV :


if ( sri -> prev_sri && sri -> prev_sri -> t_icode != CODE_FOR_nothing ) {


<s> enum reg_class rclass = NO_REGS ; enum reg_class reload_class = ( enum reg_class ) reload_class_i ; if ( sri -> prev_sri && sri -> prev_sri -> t_icode != CODE_FOR_nothing ) { sri -> icode = sri -> prev_sri -> t_icode ; return NO_REGS ; } rclass = frv_secondary_reload_class ( reload_class , reload_mode , x ) ; if ( rclass != NO_REGS ) { enum insn_code icode = direct_optab_handler ( in_p ? reload_in_optab : reload_out_optab , reload_mode ) ; if ( icode == <NUM_LIT> ) { sri -> t_icode = CODE_FOR_nothing ; return rclass ;


<s> enum reg_class ret ; switch ( rclass ) { default : ret = NO_REGS ; break ; case QUAD_REGS : case GPR_REGS : ret = NO_REGS ; if ( x && GET_CODE ( x ) == REG ) { int regno = REGNO ( x ) ; if ( ACC_P ( regno ) || ACCG_P ( regno ) ) ret = FPR_REGS ; } break ; case QUAD_FPR_REGS : if ( x && CONSTANT_P ( x ) && ! ZERO_P ( x ) ) ret = GPR_REGS ; else ret = NO_REGS ; break ; case ICC_REGS : case FCC_REGS : case CC_REGS : case ICR_REGS : case FCR_REGS : case CR_REGS : case LCR_REG : case LR_REG : ret = GPR_REGS ; break ; case QUAD_ACC_REGS : case ACCG_REGS :


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


<s> CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ;

if ( TARGET_DEBUG_ARG ) fprintf ( stderr , <STR_LIT> , * cum , GET_MODE_NAME ( arg . mode ) , * pretend_size , second_time ) ;


<s> return ( GET_CODE ( symbol ) == SYMBOL_REF && SYMBOL_REF_SMALL_P ( symbol ) && ( ! TARGET_FDPIC || flag_pic == <NUM_LIT> ) && ( reloc == R_FRV_GOTOFF12 || reloc == R_FRV_GPREL12 ) ) ;


<s> if ( packet_group -> num_insns > <NUM_LIT> ) qsort ( packet_group -> sorted , packet_group -> num_insns , sizeof ( rtx ) , frv_compare_insns ) ; if ( group == GROUP_B || group == GROUP_C ) return ; dfa_size = state_size ( ) ; state = alloca ( dfa_size ) ; test_state = alloca ( dfa_size ) ; state_reset ( test_state ) ; for ( first = <NUM_LIT> ; first < packet_group -> num_insns ; first ++ ) { memcpy ( state , test_state , dfa_size ) ; if ( state_transition ( test_state , packet_group -> sorted [ first ] ) >= <NUM_LIT> || ! cpu_unit_reservation_p ( test_state , NTH_UNIT ( group , first ) ) ) break ; } if ( first == packet_group -> num_insns ) return ; for ( nop = <NUM_LIT> ; nop < frv_num_nops ; nop ++ ) { max_unit = frv_insn_unit ( frv_nops [ nop ] ) ; if ( frv_unit_groups [ max_unit ] == group ) { packet_group -> nop = frv_nops [ nop ] ; num_slots = UNIT_NUMBER ( max_unit ) + <NUM_LIT> ; for ( i = packet_group -> num_insns ; i < num_slots ; i ++ ) packet_group -> sorted [ i ] = frv_nops [ nop ] ; if ( frv_sort_insn_group_1 ( group , first , num_slots , ( <NUM_LIT> << first ) - <NUM_LIT> , num_slots , state ) ) return ;


<s> state_t test_state ; size_t dfa_size ; rtx_insn * 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 ) ) {


<s> rtx_insn * 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 ) ) {


<s> emit_insn ( gen_rtx_SET ( cc_reg , gen_rtx_COMPARE ( CCmode , src , const0_rtx ) ) ) ; emit_insn ( gen_rtx_SET ( 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 ( dest , src ) ) ) ; ret = get_insns ( ) ; end_sequence ( ) ; return ret ;


<s> emit_insn ( gen_rtx_SET ( 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 ( dest , src ) ) ) ; ret = get_insns ( ) ;


<s> emit_insn ( gen_rtx_COND_EXEC ( VOIDmode , gen_rtx_EQ ( cr_mode , cr_reg , const0_rtx ) , gen_rtx_SET ( dest , src2 ) ) ) ; } else if ( IN_RANGE ( value1 , - <NUM_LIT> , <NUM_LIT> ) && IN_RANGE ( 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 ( dest_si , const0_rtx ) ) ) ; emit_insn ( gen_addsi3 ( dest_si , dest_si , src1 ) ) ; } else gcc_unreachable ( ) ; }


<s> rtx src1 = operands [ <NUM_LIT> ] ; rtx src2 = operands [ <NUM_LIT> ] ; rtx cr_reg = operands [ <NUM_LIT> ] ; rtx ret ; machine_mode cr_mode = GET_MODE ( cr_reg ) ; start_sequence ( ) ; emit_insn ( gen_rtx_SET ( cr_reg , gen_rtx_fmt_ee ( GET_CODE ( test ) , GET_MODE ( cr_reg ) , cc_reg , const0_rtx ) ) ) ; 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 ( dest , src1 ) ) ) ; } else if ( value2 == <NUM_LIT> ) {


<s> void frv_split_double_load ( rtx dest , rtx source ) { 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 , address ) ) {


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


<s> rtx dest2 = frv_index_memory ( dest , SImode , <NUM_LIT> ) ; if ( ZERO_P ( source ) ) {

emit_move_insn ( dest1 , CONST0_RTX ( SImode ) ) ;


for ( i = <NUM_LIT> ; i < GET_MODE_SIZE ( inner ) ; i += GET_MODE_SIZE ( SImode ) ) emit_move_insn ( simplify_gen_subreg ( SImode , dest , inner , i ) , simplify_gen_subreg ( SImode , src , inner , i ) ) ;


<s> rtx frv_split_scc ( rtx dest , rtx test , rtx cc_reg , rtx cr_reg , HOST_WIDE_INT value ) { rtx ret ; start_sequence ( ) ; emit_insn ( gen_rtx_SET ( 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 ( dest , const0_rtx ) ) ) ; ret = get_insns ( ) ; end_sequence ( ) ; return ret ;


<s> rtx ret ; start_sequence ( ) ; emit_insn ( gen_rtx_SET ( cr_reg , gen_rtx_fmt_ee ( GET_CODE ( test ) , GET_MODE ( cr_reg ) , cc_reg , const0_rtx ) ) ) ;

emit_move_insn ( dest , GEN_INT ( value ) ) ;


<s> static void frv_start_packet ( void ) { enum frv_insn_group group ; memset ( frv_packet . regstate , <NUM_LIT> , sizeof ( frv_packet . regstate ) ) ; frv_packet . num_mems = <NUM_LIT> ; frv_packet . num_insns = <NUM_LIT> ;

for ( group = GROUP_I ; group < NUM_GROUPS ;


<s> enum frv_insn_group group ; memset ( frv_packet . regstate , <NUM_LIT> , sizeof ( frv_packet . regstate ) ) ; frv_packet . num_mems = <NUM_LIT> ;


<s> static void frv_start_packet_block ( void ) {


<s> const int prefix_len = strlen ( prefix ) ;

return ( strncmp ( name , prefix , prefix_len ) == <NUM_LIT> ) ;


<s> const int prefix_len = strlen ( prefix ) ; return ( strncmp ( name , prefix , prefix_len ) == <NUM_LIT> ) ;


<s> return gen_rtx_REG ( Pmode , FRV_STRUCT_VALUE_REGNUM ) ;


<s> rtx sc_reg = force_reg ( Pmode , static_chain ) ; emit_library_call ( gen_rtx_SYMBOL_REF ( SImode , <STR_LIT> ) , LCT_NORMAL , VOIDmode , addr , Pmode , GEN_INT ( frv_trampoline_size ( ) ) , SImode , fnaddr , Pmode , sc_reg , Pmode ) ;


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


<s> int frv_trampoline_size ( void ) { if ( TARGET_FDPIC ) return <NUM_LIT> + <NUM_LIT> * <NUM_LIT> ;


<s> mem = gen_rtx_MEM ( mode , memory_address ( mode , arg ) ) ; MEM_VOLATILE_P ( mem ) = <NUM_LIT> ; return mem ;


<s> rtx retval , dest ; rtx picreg = get_hard_reg_initial_val ( Pmode , FDPIC_REG ) ; dest = gen_reg_rtx ( DImode ) ; if ( flag_pic == <NUM_LIT> ) { emit_insn ( gen_tls_lddi ( dest , addr , picreg ) ) ; } else { rtx reguse = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_tlsoff_hilo ( reguse , addr , GEN_INT ( R_FRV_GOTTLSDESCHI ) ) ) ; emit_insn ( gen_tls_tlsdesc_ldd ( dest , picreg , reguse , addr ) ) ; } retval = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_tls_indirect_call ( retval , addr , dest , picreg ) ) ; return retval ;


<s> rtx dest = gen_reg_rtx ( Pmode ) ; if ( TARGET_BIG_TLS ) { dest = gen_reg_rtx ( Pmode ) ; emit_insn ( gen_tlsoff_hilo ( dest , addr , GEN_INT ( R_FRV_TLSMOFFHI ) ) ) ; dest = gen_rtx_PLUS ( Pmode , dest , reg ) ; }


<s> break ; case E_QImode : return <STR_LIT> ; case E_HImode : return <STR_LIT> ; case E_SImode : case E_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 ) ; machine_mode mode = GET_MODE ( dest ) ; if ( GPR_P ( src_regno ) ) { switch ( mode ) { default : break ; case E_QImode : return <STR_LIT> ; case E_HImode : return <STR_LIT> ;


<s> else if ( FPR_P ( src_regno ) ) { if ( TARGET_DOUBLE && ( ( dest_regno - FPR_FIRST ) & <NUM_LIT> ) == <NUM_LIT> && ( ( src_regno - FPR_FIRST ) & <NUM_LIT> ) == <NUM_LIT> ) return <STR_LIT> ; return <STR_LIT> ; } } else if ( GET_CODE ( src ) == MEM ) { 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> ; return <STR_LIT> ;


<s> 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 ) { long l ; REAL_VALUE_TO_TARGET_SINGLE ( * CONST_DOUBLE_REAL_VALUE ( src ) , l ) ; value = l ; } else value = CONST_DOUBLE_LOW ( src ) ; if ( IN_RANGE ( 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 E_QImode : return <STR_LIT> ; case E_HImode : return <STR_LIT> ; case E_SImode : case E_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 ) ; machine_mode mode = GET_MODE ( dest ) ; if ( GPR_P ( src_regno ) ) { switch ( mode ) { default : break ; case E_QImode : return <STR_LIT> ; case E_HImode : return <STR_LIT> ; case E_SImode : case E_SFmode : return <STR_LIT> ; } } else if ( FPR_P ( src_regno ) ) { switch ( mode ) { default : break ; case E_QImode : return <STR_LIT> ; case E_HImode : return <STR_LIT> ; case E_SImode : case E_SFmode : return <STR_LIT> ; } } } else if ( ZERO_P ( src ) ) { switch ( GET_MODE ( dest ) ) { default : break ; case E_QImode : return <STR_LIT> ; case E_HImode : return <STR_LIT> ;


<s> rtx sub = XVECEXP ( pattern , <NUM_LIT> , i ) ; switch ( GET_CODE ( sub ) ) { case USE : case CLOBBER : break ; case SET : if ( set ) return <NUM_LIT> ; else set = sub ; break ; default :


<s> switch ( i ) { case R_FRV_GOT12 : return <STR_LIT> ; case R_FRV_GOTHI : return <STR_LIT> ; case R_FRV_GOTLO : return <STR_LIT> ; case R_FRV_FUNCDESC : return <STR_LIT> ; case R_FRV_FUNCDESC_GOT12 : return <STR_LIT> ; case R_FRV_FUNCDESC_GOTHI : return <STR_LIT> ; case R_FRV_FUNCDESC_GOTLO : return <STR_LIT> ; case R_FRV_FUNCDESC_VALUE : return <STR_LIT> ; case R_FRV_FUNCDESC_GOTOFF12 : return <STR_LIT> ; case R_FRV_FUNCDESC_GOTOFFHI : return <STR_LIT> ; case R_FRV_FUNCDESC_GOTOFFLO : return <STR_LIT> ; case R_FRV_GOTOFF12 : return <STR_LIT> ;

case R_FRV_GOTOFFHI : return <STR_LIT> ;


<s> double __ulltod ( unsigned long long a ) { return a ;


<s> float __ulltof ( unsigned long long a ) {