<s> for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; ++ i ) if ( TEST_HARD_REG_BIT ( set , i ) ) fixed_regs [ i ] = call_used_regs [ i ] = <NUM_LIT> ; } break ; default : gcc_unreachable ( ) ; } mep_save_register_info ( ) ; mep_reinit_regs ( ) ; if ( cfun == <NUM_LIT> ) { init_dummy_function_start ( ) ; init_caller_save ( ) ; expand_dummy_function_end ( ) ;


<s> type = mep_pragma_lex ( & val ) ; switch ( type ) { case CPP_NUMBER : if ( ! tree_fits_uhwi_p ( val ) ) break ; i = tree_to_uhwi ( val ) ; if ( i == <NUM_LIT> ) target_flags &= ~ MASK_64BIT_CR_REGS ; else if ( i == <NUM_LIT> ) target_flags |= MASK_64BIT_CR_REGS ; else break ; targetm . init_builtins ( ) ; if ( i != <NUM_LIT> && i != <NUM_LIT> ) break ; type = mep_pragma_lex ( & val ) ;

if ( type != CPP_PRAGMA_EOL ) warning ( <NUM_LIT> , <STR_LIT> ) ;


<s> static enum cpp_ttype mep_pragma_lex ( tree * valp ) {

enum cpp_ttype t = pragma_lex ( valp ) ;


<s> if ( t == CPP_EOF ) t = CPP_PRAGMA_EOL ; return t ;


<s> if ( regno >= FIRST_PSEUDO_REGISTER ) return INVALID_REGNUM ;

if ( ! TEST_HARD_REG_BIT ( reg_class_contents [ CR_REGS ] , regno ) ) return INVALID_REGNUM ;


<s> do_range = true ; } else if ( type == CPP_NAME || type == CPP_STRING ) { const char * str ; unsigned int regno , i ; if ( TREE_CODE ( val ) == IDENTIFIER_NODE ) str = IDENTIFIER_POINTER ( val ) ; else if ( TREE_CODE ( val ) == STRING_CST ) str = TREE_STRING_POINTER ( val ) ; else gcc_unreachable ( ) ; regno = parse_cr_reg ( str ) ; if ( regno == INVALID_REGNUM ) { error ( <STR_LIT> , val ) ; return false ; } if ( do_range ) {

if ( last_regno > regno ) i = regno , regno = last_regno ;


<s> insn = emit_move_insn ( gen_rtx_REG ( SImode , REGSAVE_CONTROL_TEMP ) , GEN_INT ( hi ) ) ; if ( lo ) { insn = emit_insn ( gen_iorsi3 ( gen_rtx_REG ( SImode , REGSAVE_CONTROL_TEMP ) , gen_rtx_REG ( SImode , REGSAVE_CONTROL_TEMP ) , GEN_INT ( lo ) ) ) ; } insn = emit_insn ( gen_addsi3 ( gen_rtx_REG ( SImode , dest ) , gen_rtx_REG ( SImode , src ) , gen_rtx_REG ( SImode , REGSAVE_CONTROL_TEMP ) ) ) ; if ( mark_frame ) { RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; add_reg_note ( insn , REG_FRAME_RELATED_EXPR , gen_rtx_SET ( gen_rtx_REG ( SImode , dest ) , gen_rtx_PLUS ( SImode , gen_rtx_REG ( SImode , dest ) , GEN_INT ( value ) ) ) ) ;


<s> } hi = trunc_int_for_mode ( value & <NUM_LIT> , SImode ) ; lo = value & <NUM_LIT> ; insn = emit_move_insn ( gen_rtx_REG ( SImode , REGSAVE_CONTROL_TEMP ) , GEN_INT ( hi ) ) ; if ( lo ) { insn = emit_insn ( gen_iorsi3 ( gen_rtx_REG ( SImode , REGSAVE_CONTROL_TEMP ) , gen_rtx_REG ( SImode , REGSAVE_CONTROL_TEMP ) , GEN_INT ( lo ) ) ) ; } insn = emit_insn ( gen_addsi3 ( gen_rtx_REG ( SImode , dest ) , gen_rtx_REG ( SImode , src ) , gen_rtx_REG ( SImode , REGSAVE_CONTROL_TEMP ) ) ) ; if ( mark_frame ) { RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; add_reg_note ( insn , REG_FRAME_RELATED_EXPR , gen_rtx_SET ( gen_rtx_REG ( SImode , dest ) , gen_rtx_PLUS ( SImode , gen_rtx_REG ( SImode , dest ) , GEN_INT ( value ) ) ) ) ;


<s> if ( GET_CODE ( operands [ <NUM_LIT> ] ) == SYMBOL_REF ) { tpsym = operands [ <NUM_LIT> ] ; n = gen_rtx_UNSPEC ( mode , gen_rtvec ( <NUM_LIT> , operands [ <NUM_LIT> ] ) , t == 'b' ? UNS_TPREL : UNS_GPREL ) ; n = gen_rtx_CONST ( mode , n ) ; } else if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST && GET_CODE ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) , <NUM_LIT> ) ) == SYMBOL_REF && GET_CODE ( XEXP ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) , <NUM_LIT> ) ) == CONST_INT ) { tpsym = XEXP ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) , <NUM_LIT> ) ; tpoffs = XEXP ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) , <NUM_LIT> ) ; n = gen_rtx_UNSPEC ( mode , gen_rtvec ( <NUM_LIT> , tpsym ) , t == 'b' ? UNS_TPREL : UNS_GPREL ) ; n = gen_rtx_PLUS ( mode , n , tpoffs ) ; n = gen_rtx_CONST ( mode , n ) ; } else if ( GET_CODE ( operands [ <NUM_LIT> ] ) == CONST && GET_CODE ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) == UNSPEC ) return false ; else { error ( <STR_LIT> ) ; return false ; } n = gen_rtx_PLUS ( mode , ( t == 'b' ? mep_tp_rtx ( ) : mep_gp_rtx ( ) ) , n ) ; n = emit_insn ( gen_rtx_SET ( operands [ <NUM_LIT> ] , n ) ) ; fprintf ( stderr , <STR_LIT> ) ; debug_rtx ( n ) ; return true ; } } for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { t = mep_section_tag ( operands [ i ] ) ; if ( GET_CODE ( operands [ i ] ) == MEM && ( t == 'b' || t == 't' ) ) { rtx sym , n , r ; int u ; sym = XEXP ( operands [ i ] , <NUM_LIT> ) ; if ( GET_CODE ( sym ) == CONST && GET_CODE ( XEXP ( sym , <NUM_LIT> ) ) == UNSPEC ) sym = XVECEXP ( XEXP ( sym , <NUM_LIT> ) , <NUM_LIT> , <NUM_LIT> ) ;


<s> really_need_stack_frame = frame_size ; really_need_stack_frame |= mep_assign_save_slots ( reg_save_size ) ; sp_offset = reg_save_size ; if ( sp_offset + frame_size < <NUM_LIT> ) sp_offset += frame_size ; add_constant ( SP_REGNO , SP_REGNO , - sp_offset , <NUM_LIT> ) ; for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( mep_call_saves_register ( i ) ) { rtx mem ; bool maybe_dead_p ; machine_mode rmode ; rss = cfun -> machine -> reg_save_slot [ i ] ; if ( ( i == TP_REGNO || i == GP_REGNO || i == LP_REGNO ) && ( ! mep_reg_set_in_function ( i ) && ! mep_interrupt_p ( ) ) ) continue ; if ( mep_reg_size ( i ) == <NUM_LIT> ) rmode = DImode ; else rmode = SImode ; mem = gen_rtx_MEM ( rmode , plus_constant ( Pmode , stack_pointer_rtx , sp_offset - rss ) ) ; maybe_dead_p = rtx_equal_p ( mem , has_hard_reg_initial_val ( rmode , i ) ) ; if ( GR_REGNO_P ( i ) || LOADABLE_CR_REGNO_P ( i ) ) F ( maybe_dead_move ( mem , gen_rtx_REG ( rmode , i ) , maybe_dead_p ) ) ; else if ( rmode == DImode ) { rtx_insn * insn ; int be = TARGET_BIG_ENDIAN ? <NUM_LIT> : <NUM_LIT> ; mem = gen_rtx_MEM ( SImode , plus_constant ( Pmode , stack_pointer_rtx , sp_offset - rss + be ) ) ; maybe_dead_move ( gen_rtx_REG ( SImode , REGSAVE_CONTROL_TEMP ) , gen_rtx_REG ( SImode , i ) , maybe_dead_p ) ; maybe_dead_move ( gen_rtx_REG ( SImode , REGSAVE_CONTROL_TEMP + <NUM_LIT> ) , gen_rtx_ZERO_EXTRACT ( SImode , gen_rtx_REG ( DImode , i ) , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) ) , maybe_dead_p ) ; insn = maybe_dead_move ( mem , gen_rtx_REG ( SImode , REGSAVE_CONTROL_TEMP ) , maybe_dead_p ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; add_reg_note ( insn , REG_FRAME_RELATED_EXPR , gen_rtx_SET ( copy_rtx ( mem ) , gen_rtx_REG ( rmode , i ) ) ) ; mem = gen_rtx_MEM ( SImode , plus_constant ( Pmode , stack_pointer_rtx , sp_offset - rss + ( <NUM_LIT> - be ) ) ) ; insn = maybe_dead_move ( mem , gen_rtx_REG ( SImode , REGSAVE_CONTROL_TEMP + <NUM_LIT> ) , maybe_dead_p ) ; } else { rtx_insn * insn ; maybe_dead_move ( gen_rtx_REG ( rmode , REGSAVE_CONTROL_TEMP ) , gen_rtx_REG ( rmode , i ) , maybe_dead_p ) ; insn = maybe_dead_move ( mem , gen_rtx_REG ( rmode , REGSAVE_CONTROL_TEMP ) , maybe_dead_p ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; add_reg_note ( insn , REG_FRAME_RELATED_EXPR , gen_rtx_SET ( copy_rtx ( mem ) , gen_rtx_REG ( rmode , i ) ) ) ; } }


<s> mep_expand_setcc_1 ( LTU , op2 , op1 , const1_rtx ) ; emit_insn ( gen_rtx_SET ( dest , gen_rtx_XOR ( SImode , op2 , const1_rtx ) ) ) ; return true ; case LE : if ( GET_CODE ( op2 ) != CONST_INT || INTVAL ( op2 ) == <NUM_LIT> ) return false ; op2 = GEN_INT ( INTVAL ( op2 ) + <NUM_LIT> ) ; return mep_expand_setcc_1 ( LT , dest , op1 , op2 ) ; case LEU : if ( GET_CODE ( op2 ) != CONST_INT || INTVAL ( op2 ) == - <NUM_LIT> ) return false ; op2 = GEN_INT ( trunc_int_for_mode ( INTVAL ( op2 ) + <NUM_LIT> , SImode ) ) ; return mep_expand_setcc_1 ( LTU , dest , op1 , op2 ) ; case GE : if ( GET_CODE ( op2 ) != CONST_INT || INTVAL ( op2 ) == trunc_int_for_mode ( <NUM_LIT> , SImode ) ) return false ; op2 = GEN_INT ( INTVAL ( op2 ) - <NUM_LIT> ) ; return mep_expand_setcc_1 ( GT , dest , op1 , op2 ) ; case GEU : if ( GET_CODE ( op2 ) != CONST_INT || op2 == const0_rtx ) return false ;

op2 = GEN_INT ( trunc_int_for_mode ( INTVAL ( op2 ) - <NUM_LIT> , SImode ) ) ;


<s> else * total = <NUM_LIT> ; return true ; case SYMBOL_REF : * total = optimize_size ? COSTS_N_INSNS ( <NUM_LIT> ) : COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case MULT : * total = ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ? COSTS_N_INSNS ( <NUM_LIT> ) : COSTS_N_INSNS ( <NUM_LIT> ) ) ;


<s> else if ( INTVAL ( x ) >= - <NUM_LIT> && INTVAL ( x ) < <NUM_LIT> ) * total = <NUM_LIT> ; else * total = <NUM_LIT> ; return true ; case SYMBOL_REF : * total = optimize_size ? COSTS_N_INSNS ( <NUM_LIT> ) : COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case MULT : * total = ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ? COSTS_N_INSNS ( <NUM_LIT> ) : COSTS_N_INSNS ( <NUM_LIT> ) ) ; return true ;


<s> if ( value == <NUM_LIT> ) { insn = emit_move_insn ( gen_rtx_REG ( SImode , dest ) , gen_rtx_REG ( SImode , src ) ) ; if ( mark_frame ) RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; return ; } if ( value >= - <NUM_LIT> && value <= <NUM_LIT> ) { insn = emit_insn ( gen_addsi3 ( gen_rtx_REG ( SImode , dest ) , gen_rtx_REG ( SImode , src ) , GEN_INT ( value ) ) ) ; if ( mark_frame ) RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; return ;


<s> return ; } if ( value >= - <NUM_LIT> && value <= <NUM_LIT> ) { insn = emit_insn ( gen_addsi3 ( gen_rtx_REG ( SImode , dest ) , gen_rtx_REG ( SImode , src ) , GEN_INT ( value ) ) ) ; if ( mark_frame ) RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; return ; } hi = trunc_int_for_mode ( value & <NUM_LIT> , SImode ) ; lo = value & <NUM_LIT> ; insn = emit_move_insn ( gen_rtx_REG ( SImode , REGSAVE_CONTROL_TEMP ) , GEN_INT ( hi ) ) ; if ( lo ) { insn = emit_insn ( gen_iorsi3 ( gen_rtx_REG ( SImode , REGSAVE_CONTROL_TEMP ) , gen_rtx_REG ( SImode , REGSAVE_CONTROL_TEMP ) , GEN_INT ( lo ) ) ) ; } insn = emit_insn ( gen_addsi3 ( gen_rtx_REG ( SImode , dest ) , gen_rtx_REG ( SImode , src ) , gen_rtx_REG ( SImode , REGSAVE_CONTROL_TEMP ) ) ) ; if ( mark_frame ) { RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ;

add_reg_note ( insn , REG_FRAME_RELATED_EXPR , gen_rtx_SET ( SImode , gen_rtx_REG ( SImode , dest ) , gen_rtx_PLUS ( SImode , gen_rtx_REG ( SImode , dest ) , GEN_INT ( value ) ) ) ) ;


<s> if ( REGNO ( XEXP ( SET_SRC ( pat ) , <NUM_LIT> ) ) != SP_REGNO ) return <NUM_LIT> ; if ( GET_CODE ( XEXP ( SET_SRC ( pat ) , <NUM_LIT> ) ) != CONST_INT ) return <NUM_LIT> ;

return INTVAL ( XEXP ( SET_SRC ( pat ) , <NUM_LIT> ) ) ;


for ( rv = <NUM_LIT> ; rv < <NUM_LIT> ; rv ++ ) if ( ( ( HOST_WIDE_INT ) <NUM_LIT> << rv ) > i ) return rv + <NUM_LIT> ;


<s> static int bit_size_for_clip ( HOST_WIDE_INT i ) { int rv ; for ( rv = <NUM_LIT> ; rv < <NUM_LIT> ; rv ++ ) if ( ( ( HOST_WIDE_INT ) <NUM_LIT> << rv ) > i ) return rv + <NUM_LIT> ; gcc_unreachable ( ) ;


<s> static bool const_in_range ( rtx x , int minv , int maxv ) {

return ( GET_CODE ( x ) == CONST_INT && INTVAL ( x ) >= minv && INTVAL ( x ) <= maxv ) ;


<s> if ( get_attr_slot ( insn ) == SLOT_CORE ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> if ( GET_CODE ( PATTERN ( insn ) ) == USE ) return <NUM_LIT> ; if ( get_attr_slot ( insn ) == SLOT_CORE ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> static void encode_pattern ( rtx x ) { patternp = pattern ; encode_pattern_1 ( x ) ;


<s> encode_pattern_1 ( XEXP ( x , <NUM_LIT> ) ) ; encode_pattern_1 ( XEXP ( x , <NUM_LIT> ) ) ; break ; case LO_SUM : * patternp ++ = 'L' ; encode_pattern_1 ( XEXP ( x , <NUM_LIT> ) ) ; encode_pattern_1 ( XEXP ( x , <NUM_LIT> ) ) ; break ; case HIGH : * patternp ++ = 'H' ; encode_pattern_1 ( XEXP ( x , <NUM_LIT> ) ) ; break ; case SYMBOL_REF : * patternp ++ = 's' ; break ; case LABEL_REF : * patternp ++ = 'l' ; break ; case CONST_INT : case CONST_DOUBLE : * patternp ++ = 'i' ; break ;


<s> break ; case LABEL_REF : * patternp ++ = 'l' ; break ; case CONST_INT : case CONST_DOUBLE : * patternp ++ = 'i' ; break ; case UNSPEC : * patternp ++ = 'u' ; * patternp ++ = '0' + XCINT ( x , <NUM_LIT> , UNSPEC ) ; for ( i = <NUM_LIT> ; i < XVECLEN ( x , <NUM_LIT> ) ; i ++ ) encode_pattern_1 ( XVECEXP ( x , <NUM_LIT> , i ) ) ; break ; case USE : * patternp ++ = 'U' ; break ;


<s> static bool equal_keys ( const char * a , const char * b ) {


<s> RTX_FRAME_RELATED_P ( x ) = <NUM_LIT> ;


<s> RTX_FRAME_RELATED_P ( x ) = <NUM_LIT> ; return x ;


if ( REG_P ( x ) && REGNO ( x ) != LO_REGNO && REGNO ( x ) != HI_REGNO && reg_set_p ( x , prev ) ) return false ;


<s> if ( REG_P ( x ) && REGNO ( x ) != LO_REGNO && REGNO ( x ) != HI_REGNO && reg_set_p ( x , prev ) ) return false ;


<s> if ( x == <NUM_LIT> ) return false ; } else x = PATTERN ( x ) ; } subrtx_iterator :: array_type array ;

FOR_EACH_SUBRTX ( iter , array , x , NONCONST ) if ( global_reg_mentioned_p_1 ( * iter ) ) return true ;


<s> case SUBREG : if ( REG_P ( SUBREG_REG ( x ) ) ) { if ( REGNO ( SUBREG_REG ( x ) ) < FIRST_PSEUDO_REGISTER && global_regs [ subreg_regno ( x ) ] ) return true ; return false ; } break ; case REG : regno = REGNO ( x ) ;

if ( regno < FIRST_PSEUDO_REGISTER && global_regs [ regno ] ) return true ;


<s> if ( REG_NOTE_KIND ( link ) != <NUM_LIT> ) { if ( REG_NOTE_KIND ( link ) == REG_DEP_OUTPUT && global_reg_mentioned_p ( PATTERN ( insn ) ) && global_reg_mentioned_p ( PATTERN ( dep_insn ) ) ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> if ( REGNO ( reg ) == TP_REGNO || REGNO ( reg ) == GP_REGNO ) if ( mep_interrupt_p ( ) ) return NULL_RTX ;

if ( ! cfun -> machine -> reg_save_slot [ REGNO ( reg ) ] ) {


<s> if ( ! cfun -> machine -> reg_save_slot [ REGNO ( reg ) ] ) { cfun -> machine -> reg_save_size += <NUM_LIT> ;

cfun -> machine -> reg_save_slot [ REGNO ( reg ) ] = cfun -> machine -> reg_save_size ;


<s> if ( l != <NUM_LIT> ) return false ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( ( u == ( ( HOST_WIDE_INT ) <NUM_LIT> << i ) - <NUM_LIT> ) ) return true ;


<s> bool mep_allow_clip ( rtx ux , rtx lx , int s ) { HOST_WIDE_INT u = INTVAL ( ux ) ; HOST_WIDE_INT l = INTVAL ( lx ) ; int i ; if ( ! TARGET_OPT_CLIP ) return false ; if ( s ) { for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( ( u == ( ( HOST_WIDE_INT ) <NUM_LIT> << i ) - <NUM_LIT> ) && ( l == - ( ( HOST_WIDE_INT ) <NUM_LIT> << i ) ) ) return true ; } else { if ( l != <NUM_LIT> ) return false ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( ( u == ( ( HOST_WIDE_INT ) <NUM_LIT> << i ) - <NUM_LIT> ) ) return true ; }


<s> if ( flags & SECTION_CODE ) * f ++ = 'x' ; if ( flags & SECTION_SMALL ) * f ++ = 's' ; if ( flags & SECTION_MEP_VLIW ) * f ++ = 'v' ; * f = '\0' ;

if ( flags & SECTION_BSS ) type = <STR_LIT> ;


<s> } if ( prev_opcode == op_stc && this_opcode == op_fsft ) hazard = <STR_LIT> ; if ( prev_opcode == op_stc && this_opcode == op_ret ) hazard = <STR_LIT> ; if ( hazard ) fprintf ( file , <STR_LIT> , hazard , opnames [ prev_opcode ] , opnames [ this_opcode ] ) ;


<s> while ( insn ) { if ( INSN_P ( insn ) && GET_CODE ( PATTERN ( insn ) ) == ASM_INPUT ) { cfun -> machine -> asms_without_operands = <NUM_LIT> ; break ; }


<s> cfun -> machine -> reg_save_slot [ i ] = cfun -> machine -> reg_save_size ; } else { cfun -> machine -> reg_save_slot [ i ] = reg_save_size - di_ofs ; di_ofs += <NUM_LIT> ; } } cfun -> machine -> frame_locked = <NUM_LIT> ; return really_need_stack_frame ;


<s> int regsize = mep_reg_size ( i ) ; if ( ( i != TP_REGNO && i != GP_REGNO && i != LP_REGNO ) || mep_reg_set_in_function ( i ) ) really_need_stack_frame = true ; if ( cfun -> machine -> reg_save_slot [ i ] ) continue ; if ( regsize < <NUM_LIT> ) {

cfun -> machine -> reg_save_size += regsize ;


<s> if ( is_attribute_p ( <STR_LIT> , TREE_PURPOSE ( list ) ) ) return 't' ; if ( is_attribute_p ( <STR_LIT> , TREE_PURPOSE ( list ) ) ) return 'n' ; if ( is_attribute_p ( <STR_LIT> , TREE_PURPOSE ( list ) ) ) return 'f' ; if ( is_attribute_p ( <STR_LIT> , TREE_PURPOSE ( list ) ) ) { if ( TREE_VALUE ( list ) && TREE_VALUE ( TREE_VALUE ( list ) ) && TREE_CODE ( TREE_VALUE ( TREE_VALUE ( list ) ) ) == INTEGER_CST ) { int location = TREE_INT_CST_LOW ( TREE_VALUE ( TREE_VALUE ( list ) ) ) ; if ( location >= <NUM_LIT> && location <= <NUM_LIT> ) return 'i' ; }


<s> bool mep_bit_position_p ( rtx x , bool looking_for ) { if ( GET_CODE ( x ) != CONST_INT ) return false ; switch ( ( int ) INTVAL ( x ) & <NUM_LIT> ) { case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : return looking_for ; case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : return ! looking_for ;


<s> SET_NEXT_INSN ( PREV_INSN ( note ) ) = note ; SET_PREV_INSN ( NEXT_INSN ( note ) ) = note ; } note = prev ; } } else if ( ! NONJUMP_INSN_P ( insn ) ) first = <NUM_LIT> ; } for ( insn = insns ; insn ; insn = NEXT_INSN ( insn ) ) { if ( NOTE_P ( insn ) ) continue ; if ( ! NONJUMP_INSN_P ( insn ) ) { last = <NUM_LIT> ; continue ; } if ( GET_MODE ( insn ) == TImode ) saw_scheduling = <NUM_LIT> ; if ( ! saw_scheduling ) continue ; if ( TARGET_IVC2 ) { rtx_insn * core_insn = NULL ; if ( NONJUMP_INSN_P ( insn ) && GET_CODE ( PATTERN ( insn ) ) != USE && GET_MODE ( insn ) == TImode ) { for ( last = insn ; NEXT_INSN ( last ) && GET_MODE ( NEXT_INSN ( last ) ) == VOIDmode && NONJUMP_INSN_P ( NEXT_INSN ( last ) ) ; last = NEXT_INSN ( last ) ) { if ( core_insn_p ( last ) ) core_insn = last ; } if ( core_insn_p ( last ) ) core_insn = last ; if ( core_insn && core_insn != insn ) {


<s> SET_PREV_INSN ( NEXT_INSN ( note ) ) = note ; } note = prev ; } } else if ( ! NONJUMP_INSN_P ( insn ) ) first = <NUM_LIT> ; } for ( insn = insns ; insn ; insn = NEXT_INSN ( insn ) ) { if ( NOTE_P ( insn ) ) continue ; if ( ! NONJUMP_INSN_P ( insn ) ) { last = <NUM_LIT> ; continue ; } if ( GET_MODE ( insn ) == TImode ) saw_scheduling = <NUM_LIT> ; if ( ! saw_scheduling ) continue ; if ( TARGET_IVC2 ) { rtx_insn * core_insn = NULL ; if ( NONJUMP_INSN_P ( insn ) && GET_CODE ( PATTERN ( insn ) ) != USE && GET_MODE ( insn ) == TImode ) { for ( last = insn ; NEXT_INSN ( last ) && GET_MODE ( NEXT_INSN ( last ) ) == VOIDmode && NONJUMP_INSN_P ( NEXT_INSN ( last ) ) ; last = NEXT_INSN ( last ) ) { if ( core_insn_p ( last ) ) core_insn = last ; } if ( core_insn_p ( last ) ) core_insn = last ; if ( core_insn && core_insn != insn ) { if ( PREV_INSN ( core_insn ) ) SET_NEXT_INSN ( PREV_INSN ( core_insn ) ) = NEXT_INSN ( core_insn ) ; if ( NEXT_INSN ( core_insn ) ) SET_PREV_INSN ( NEXT_INSN ( core_insn ) ) = PREV_INSN ( core_insn ) ; SET_PREV_INSN ( core_insn ) = PREV_INSN ( insn ) ; SET_NEXT_INSN ( core_insn ) = insn ; if ( PREV_INSN ( core_insn ) ) SET_NEXT_INSN ( PREV_INSN ( core_insn ) ) = core_insn ; SET_PREV_INSN ( insn ) = core_insn ; PUT_MODE ( core_insn , TImode ) ; PUT_MODE ( insn , VOIDmode ) ; } } if ( GET_MODE ( insn ) == TImode ) PUT_MODE ( insn , VOIDmode ) ; else PUT_MODE ( insn , BImode ) ; continue ; } PUT_MODE ( insn , VOIDmode ) ; if ( recog_memoized ( insn ) >= <NUM_LIT> && get_attr_slot ( insn ) == SLOT_COP ) { if ( JUMP_P ( insn ) || ! last || recog_memoized ( last ) < <NUM_LIT> || get_attr_slot ( last ) != SLOT_CORE || ( get_attr_length ( insn ) != ( TARGET_OPT_VL64 ? <NUM_LIT> : <NUM_LIT> ) - get_attr_length ( last ) ) || mep_insn_dependent_p ( insn , last ) ) { switch ( get_attr_length ( insn ) ) { case <NUM_LIT> : break ; case <NUM_LIT> : insn = mep_make_bundle ( gen_nop ( ) , insn ) ; break ; case <NUM_LIT> : if ( TARGET_OPT_VL64 ) insn = mep_make_bundle ( gen_nop32 ( ) , insn ) ; break ; case <NUM_LIT> : if ( TARGET_OPT_VL64 ) error ( <STR_LIT> <STR_LIT> ) ; else insn = mep_make_bundle ( gen_nop ( ) , insn ) ;


<s> int rv = MEP_SAVES_NO ; if ( cfun -> machine -> reg_save_slot [ r ] ) rv = MEP_SAVES_YES ; else if ( r == LP_REGNO && ( profile_arc_flag > <NUM_LIT> || profile_flag > <NUM_LIT> ) ) rv = MEP_SAVES_YES ; else if ( r == FRAME_POINTER_REGNUM && frame_pointer_needed ) rv = MEP_SAVES_YES ; else if ( ( ! call_used_regs [ r ] || r == LP_REGNO ) && df_regs_ever_live_p ( r ) ) rv = MEP_SAVES_YES ; else if ( crtl -> calls_eh_return && ( r == <NUM_LIT> || r == <NUM_LIT> ) ) rv = MEP_SAVES_YES ; else if ( mep_interrupt_saved_reg ( r ) ) rv = MEP_SAVES_YES ;

cfun -> machine -> reg_saved [ r ] = rv ;


<s> if ( ! cfun -> machine -> frame_locked ) { int rv = MEP_SAVES_NO ; if ( cfun -> machine -> reg_save_slot [ r ] ) rv = MEP_SAVES_YES ; else if ( r == LP_REGNO && ( profile_arc_flag > <NUM_LIT> || profile_flag > <NUM_LIT> ) ) rv = MEP_SAVES_YES ; else if ( r == FRAME_POINTER_REGNUM && frame_pointer_needed ) rv = MEP_SAVES_YES ; else if ( ( ! call_used_regs [ r ] || r == LP_REGNO ) && df_regs_ever_live_p ( r ) ) rv = MEP_SAVES_YES ; else if ( crtl -> calls_eh_return && ( r == <NUM_LIT> || r == <NUM_LIT> ) ) rv = MEP_SAVES_YES ; else if ( mep_interrupt_saved_reg ( r ) ) rv = MEP_SAVES_YES ; cfun -> machine -> reg_saved [ r ] = rv ; } return cfun -> machine -> reg_saved [ r ] == MEP_SAVES_YES ;


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


<s> static bool mep_can_inline_p ( tree caller , tree callee ) { if ( TREE_CODE ( callee ) == ADDR_EXPR ) callee = TREE_OPERAND ( callee , <NUM_LIT> ) ; if ( ! mep_vliw_function_p ( caller ) && mep_vliw_function_p ( callee ) ) { return false ; } return true ;


<s> if ( TREE_CODE ( callee ) == ADDR_EXPR ) callee = TREE_OPERAND ( callee , <NUM_LIT> ) ; if ( ! mep_vliw_function_p ( caller ) && mep_vliw_function_p ( callee ) ) { return false ; } return true ;


<s> static int mep_compatible_reg_class ( int r1 , int r2 ) { if ( GR_REGNO_P ( r1 ) && GR_REGNO_P ( r2 ) ) return <NUM_LIT> ;

if ( CR_REGNO_P ( r1 ) && CR_REGNO_P ( r2 ) ) return <NUM_LIT> ;


if ( vliw1 != vliw2 ) return <NUM_LIT> ;


for ( i = FIRST_SHADOW_REGISTER ; i <= LAST_SHADOW_REGISTER ; i ++ ) global_regs [ i ] = <NUM_LIT> ;


<s> if ( GET_MODE ( arg ) != mode && register_operand ( arg , VOIDmode ) && GET_MODE_SIZE ( GET_MODE ( arg ) ) == GET_MODE_SIZE ( mode ) ) return simplify_gen_subreg ( mode , arg , GET_MODE ( arg ) , <NUM_LIT> ) ;


<s> static rtx mep_convert_arg ( machine_mode mode , rtx arg ) { if ( GET_MODE ( arg ) != mode && register_operand ( arg , VOIDmode ) && GET_MODE_SIZE ( GET_MODE ( arg ) ) == GET_MODE_SIZE ( mode ) ) return simplify_gen_subreg ( mode , arg , GET_MODE ( arg ) , <NUM_LIT> ) ; return arg ;


<s> if ( regnum -> count == <NUM_LIT> ) return arg ;

if ( GET_CODE ( arg ) != CONST_INT || INTVAL ( arg ) < <NUM_LIT> || INTVAL ( arg ) >= regnum -> count ) return <NUM_LIT> ;


<s> if ( GET_CODE ( arg ) != CONST_INT || INTVAL ( arg ) < <NUM_LIT> || INTVAL ( arg ) >= regnum -> count ) return <NUM_LIT> ; return gen_rtx_REG ( SImode , INTVAL ( arg ) + regnum -> base ) ;


<s> rtx mem = XEXP ( set , opn ) ; rtx addr = XEXP ( mem , <NUM_LIT> ) ;

if ( GET_CODE ( mem ) != MEM ) return <NUM_LIT> ;


<s> rtx mem = XEXP ( set , opn ) ; rtx addr = XEXP ( mem , <NUM_LIT> ) ; if ( GET_CODE ( mem ) != MEM ) return <NUM_LIT> ; if ( register_operand ( addr , Pmode ) ) return <NUM_LIT> ; if ( GET_CODE ( addr ) == POST_INC ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> if ( GET_CODE ( addr ) == PLUS ) { rtx addend = XEXP ( addr , <NUM_LIT> ) ; gcc_assert ( REG_P ( XEXP ( addr , <NUM_LIT> ) ) ) ; switch ( REGNO ( XEXP ( addr , <NUM_LIT> ) ) ) { case STACK_POINTER_REGNUM : if ( GET_MODE_SIZE ( GET_MODE ( mem ) ) == <NUM_LIT> && mep_imm7a4_operand ( addend , VOIDmode ) ) return <NUM_LIT> ; break ; case <NUM_LIT> : gcc_assert ( REG_P ( other ) ) ; if ( REGNO ( other ) >= <NUM_LIT> ) break ; if ( GET_CODE ( addend ) == CONST && GET_CODE ( XEXP ( addend , <NUM_LIT> ) ) == UNSPEC && XINT ( XEXP ( addend , <NUM_LIT> ) , <NUM_LIT> ) == UNS_TPREL ) return <NUM_LIT> ; if ( GET_CODE ( addend ) == CONST_INT && INTVAL ( addend ) >= <NUM_LIT> && INTVAL ( addend ) <= <NUM_LIT> && INTVAL ( addend ) % GET_MODE_SIZE ( GET_MODE ( mem ) ) == <NUM_LIT> ) return <NUM_LIT> ;


<s> if ( REGNO ( other ) >= <NUM_LIT> ) break ; if ( GET_CODE ( addend ) == CONST && GET_CODE ( XEXP ( addend , <NUM_LIT> ) ) == UNSPEC && XINT ( XEXP ( addend , <NUM_LIT> ) , <NUM_LIT> ) == UNS_TPREL ) return <NUM_LIT> ; if ( GET_CODE ( addend ) == CONST_INT && INTVAL ( addend ) >= <NUM_LIT> && INTVAL ( addend ) <= <NUM_LIT> && INTVAL ( addend ) % GET_MODE_SIZE ( GET_MODE ( mem ) ) == <NUM_LIT> ) return <NUM_LIT> ;


<s> static bool mep_disinterrupt_p ( void ) { if ( cfun -> machine -> disable_interrupts == <NUM_LIT> ) {


<s> else cfun -> machine -> frame_filler = <NUM_LIT> ; if ( from == ARG_POINTER_REGNUM && to == FRAME_POINTER_REGNUM ) return reg_save_size + cfun -> machine -> regsave_filler ; if ( from == FRAME_POINTER_REGNUM && to == STACK_POINTER_REGNUM ) return cfun -> machine -> frame_filler + frame_size ;

if ( from == ARG_POINTER_REGNUM && to == STACK_POINTER_REGNUM ) return reg_save_size + cfun -> machine -> regsave_filler + cfun -> machine -> frame_filler + frame_size ;


<s> const char * mep_emit_bb_trace_ret ( void ) { fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ; fprintf ( asm_out_file , <STR_LIT> ) ;


<s> if ( GET_CODE ( operands [ <NUM_LIT> ] ) == REG ) return ne ? <STR_LIT> : <STR_LIT> ; else if ( INTVAL ( operands [ <NUM_LIT> ] ) == <NUM_LIT> && ! mep_vliw_function_p ( cfun -> decl ) ) return ne ? <STR_LIT> : <STR_LIT> ;

else return ne ? <STR_LIT> : <STR_LIT> ;


<s> rtx tag ; if ( cfun -> machine -> doloop_tags == <NUM_LIT> || cfun -> machine -> doloop_tag_from_end == is_end ) { cfun -> machine -> doloop_tags ++ ; cfun -> machine -> doloop_tag_from_end = is_end ; } tag = GEN_INT ( cfun -> machine -> doloop_tags - <NUM_LIT> ) ; if ( is_end ) emit_jump_insn ( gen_doloop_end_internal ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , tag ) ) ;

else emit_insn ( gen_doloop_begin_internal ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , tag ) ) ;


<s> if ( is_end ) emit_jump_insn ( gen_doloop_end_internal ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , tag ) ) ;


<s> int i ; if ( ! mep_get_intrinsic_insn ( intrinsic , & cgen_insn ) ) return false ; idata = & insn_data [ cgen_insn -> icode ] ; for ( i = <NUM_LIT> ; i < idata -> n_operands ; i ++ ) {

newop [ i ] = mep_convert_arg ( idata -> operand [ i ] . mode , operands [ i ] ) ;


<s> static void mep_encode_section_info ( tree decl , rtx rtl , int first ) { rtx rtlname ; const char * oldname ; const char * secname ; char encoding ; char * newname ; tree idp ; int maxsize ; tree type ; tree mep_attributes ; if ( ! first ) return ; if ( TREE_CODE ( decl ) != VAR_DECL && TREE_CODE ( decl ) != FUNCTION_DECL ) return ; rtlname = XEXP ( rtl , <NUM_LIT> ) ; if ( GET_CODE ( rtlname ) == SYMBOL_REF ) oldname = XSTR ( rtlname , <NUM_LIT> ) ; else if ( GET_CODE ( rtlname ) == MEM && GET_CODE ( XEXP ( rtlname , <NUM_LIT> ) ) == SYMBOL_REF ) oldname = XSTR ( XEXP ( rtlname , <NUM_LIT> ) , <NUM_LIT> ) ; else gcc_unreachable ( ) ; type = TREE_TYPE ( decl ) ; if ( type == error_mark_node ) return ; mep_attributes = MEP_ATTRIBUTES ( decl ) ; encoding = mep_attrlist_to_encoding ( mep_attributes , decl ) ; if ( encoding ) { newname = ( char * ) alloca ( strlen ( oldname ) + <NUM_LIT> ) ; sprintf ( newname , <STR_LIT> , encoding , oldname ) ; idp = get_identifier ( newname ) ; XEXP ( rtl , <NUM_LIT> ) = gen_rtx_SYMBOL_REF ( Pmode , IDENTIFIER_POINTER ( idp ) ) ;

SYMBOL_REF_WEAK ( XEXP ( rtl , <NUM_LIT> ) ) = DECL_WEAK ( decl ) ;


<s> bool mep_epilogue_uses ( int regno ) { if ( regno == LP_REGNO && ( profile_arc_flag > <NUM_LIT> || profile_flag > <NUM_LIT> ) ) return true ;

return ( reload_completed && mep_interrupt_saved_reg ( regno ) ) ;


<s> if ( TREE_CODE ( value ) == NOP_EXPR && SCALAR_FLOAT_TYPE_P ( TREE_TYPE ( value ) ) && SCALAR_FLOAT_TYPE_P ( TREE_TYPE ( TREE_OPERAND ( value , <NUM_LIT> ) ) ) && TYPE_MODE ( TREE_TYPE ( value ) ) == DFmode && TYPE_MODE ( TREE_TYPE ( TREE_OPERAND ( value , <NUM_LIT> ) ) ) == SFmode ) value = TREE_OPERAND ( value , <NUM_LIT> ) ; unsigned_p [ a ] = TYPE_UNSIGNED ( TREE_TYPE ( value ) ) ; arg [ a ] = expand_expr ( value , NULL , VOIDmode , EXPAND_NORMAL ) ; arg [ a ] = mep_convert_regnum ( & cgen_insn -> regnums [ a ] , arg [ a ] ) ; if ( cgen_insn -> regnums [ a ] . reference_p ) { tree pointed_to = TREE_TYPE ( TREE_TYPE ( value ) ) ; machine_mode pointed_mode = TYPE_MODE ( pointed_to ) ; arg [ a ] = gen_rtx_MEM ( pointed_mode , arg [ a ] ) ; } if ( arg [ a ] == <NUM_LIT> ) { error ( <STR_LIT> , a + <NUM_LIT> , fnname , <NUM_LIT> , cgen_insn -> regnums [ a ] . count - <NUM_LIT> ) ; return NULL_RTX ; } } for ( a = <NUM_LIT> ; a < first_arg ; a ++ ) { if ( a == <NUM_LIT> && target && GET_MODE ( target ) == idata -> operand [ <NUM_LIT> ] . mode ) arg [ a ] = target ; else arg [ a ] = gen_reg_rtx ( idata -> operand [ <NUM_LIT> ] . mode ) ; } for ( opindex = <NUM_LIT> ; opindex < idata -> n_operands ; opindex ++ ) { a = cgen_insn -> op_mapping [ opindex ] ; op [ opindex ] = mep_legitimize_arg ( & idata -> operand [ opindex ] , arg [ a ] , unsigned_p [ a ] ) ; if ( op [ opindex ] == <NUM_LIT> ) { mep_incompatible_arg ( & idata -> operand [ opindex ] , arg [ a ] , a + <NUM_LIT> - first_arg , fnname ) ; return NULL_RTX ; } } pat = idata -> genfun ( op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; if ( GET_CODE ( pat ) == SET && GET_CODE ( SET_DEST ( pat ) ) == PC && GET_CODE ( SET_SRC ( pat ) ) == IF_THEN_ELSE ) emit_jump_insn ( pat ) ; else emit_insn ( pat ) ; for ( opindex = <NUM_LIT> ; opindex < idata -> n_operands ; opindex ++ ) if ( idata -> operand [ opindex ] . constraint [ <NUM_LIT> ] == '=' ) { a = cgen_insn -> op_mapping [ opindex ] ; if ( a >= first_arg ) {

if ( GET_MODE_CLASS ( GET_MODE ( arg [ a ] ) ) != GET_MODE_CLASS ( GET_MODE ( op [ opindex ] ) ) ) emit_move_insn ( arg [ a ] , gen_lowpart ( GET_MODE ( arg [ a ] ) , op [ opindex ] ) ) ;


<s> rtx regbuf ; ns = cfun -> machine -> arg_regs_to_save ; if ( TARGET_IVC2 ) { bufsize = <NUM_LIT> * ( ( ns + <NUM_LIT> ) / <NUM_LIT> ) + <NUM_LIT> * ns ; regbuf = assign_stack_local ( SImode , bufsize , <NUM_LIT> ) ; } else { bufsize = ns * <NUM_LIT> ; regbuf = assign_stack_local ( SImode , bufsize , <NUM_LIT> ) ; } move_block_from_reg ( <NUM_LIT> - ns , regbuf , ns ) ; if ( TARGET_IVC2 ) { rtx tmp = gen_rtx_MEM ( DImode , XEXP ( regbuf , <NUM_LIT> ) ) ; int ofs = <NUM_LIT> * ( ( ns + <NUM_LIT> ) / <NUM_LIT> ) ; for ( i = <NUM_LIT> ; i < ns ; i ++ ) { int rn = ( <NUM_LIT> - ns ) + i + <NUM_LIT> ; rtx ptr ; ptr = offset_address ( tmp , GEN_INT ( ofs ) , <NUM_LIT> ) ; emit_move_insn ( ptr , gen_rtx_REG ( DImode , rn ) ) ;


<s> rtx tmp = gen_rtx_MEM ( DImode , XEXP ( regbuf , <NUM_LIT> ) ) ; int ofs = <NUM_LIT> * ( ( ns + <NUM_LIT> ) / <NUM_LIT> ) ; for ( i = <NUM_LIT> ; i < ns ; i ++ ) { int rn = ( <NUM_LIT> - ns ) + i + <NUM_LIT> ; rtx ptr ; ptr = offset_address ( tmp , GEN_INT ( ofs ) , <NUM_LIT> ) ; emit_move_insn ( ptr , gen_rtx_REG ( DImode , rn ) ) ;


<s> addr = XEXP ( addr , <NUM_LIT> ) ; if ( ! mep_call_address_operand ( addr , VOIDmode ) ) addr = force_reg ( SImode , addr ) ;

if ( ! operands [ returns_value + <NUM_LIT> ] ) operands [ returns_value + <NUM_LIT> ] = const0_rtx ;


<s> break ; case GE : if ( mep_imm4_operand ( op1 , SImode ) ) break ; tmp = gen_reg_rtx ( SImode ) ; gcc_assert ( mep_expand_setcc_1 ( LT , tmp , op0 , op1 ) ) ; code = EQ ; op0 = tmp ; op1 = const0_rtx ; break ; case EQ : case NE : if ( ! mep_reg_or_imm4_operand ( op1 , SImode ) ) op1 = force_reg ( SImode , op1 ) ; break ; case LE : case GT : if ( GET_CODE ( op1 ) == CONST_INT && INTVAL ( op1 ) != <NUM_LIT> ) { op1 = GEN_INT ( INTVAL ( op1 ) + <NUM_LIT> ) ; code = ( code == LE ? LT : GE ) ; goto restart ; } tmp = gen_reg_rtx ( SImode ) ; gcc_assert ( mep_expand_setcc_1 ( LT , tmp , op1 , op0 ) ) ; code = ( code == LE ? EQ : NE ) ; op0 = tmp ; op1 = const0_rtx ; break ; case LTU : if ( op1 == const1_rtx ) {


<s> code = NE ; op0 = tmp ; op1 = const0_rtx ; break ; case GE : if ( mep_imm4_operand ( op1 , SImode ) ) break ; tmp = gen_reg_rtx ( SImode ) ; gcc_assert ( mep_expand_setcc_1 ( LT , tmp , op0 , op1 ) ) ; code = EQ ; op0 = tmp ; op1 = const0_rtx ; break ; case EQ : case NE : if ( ! mep_reg_or_imm4_operand ( op1 , SImode ) ) op1 = force_reg ( SImode , op1 ) ; break ; case LE : case GT : if ( GET_CODE ( op1 ) == CONST_INT && INTVAL ( op1 ) != <NUM_LIT> ) { op1 = GEN_INT ( INTVAL ( op1 ) + <NUM_LIT> ) ; code = ( code == LE ? LT : GE ) ; goto restart ; } tmp = gen_reg_rtx ( SImode ) ; gcc_assert ( mep_expand_setcc_1 ( LT , tmp , op1 , op0 ) ) ; code = ( code == LE ? EQ : NE ) ; op0 = tmp ; op1 = const0_rtx ; break ; case LTU : if ( op1 == const1_rtx ) { code = EQ ; op1 = const0_rtx ; break ; } tmp = gen_reg_rtx ( SImode ) ; gcc_assert ( mep_expand_setcc_1 ( LTU , tmp , op0 , op1 ) ) ; code = NE ; op0 = tmp ; op1 = const0_rtx ; break ; case LEU : tmp = gen_reg_rtx ( SImode ) ; if ( mep_expand_setcc_1 ( LEU , tmp , op0 , op1 ) ) code = NE ; else if ( mep_expand_setcc_1 ( LTU , tmp , op1 , op0 ) ) code = EQ ; else gcc_unreachable ( ) ; op0 = tmp ; op1 = const0_rtx ; break ; case GTU : tmp = gen_reg_rtx ( SImode ) ; gcc_assert ( mep_expand_setcc_1 ( GTU , tmp , op0 , op1 ) || mep_expand_setcc_1 ( LTU , tmp , op1 , op0 ) ) ; code = NE ; op0 = tmp ; op1 = const0_rtx ; break ; case GEU : tmp = gen_reg_rtx ( SImode ) ; if ( mep_expand_setcc_1 ( GEU , tmp , op0 , op1 ) ) code = NE ;

else if ( mep_expand_setcc_1 ( LTU , tmp , op0 , op1 ) ) code = EQ ;


<s> if ( GET_CODE ( operands [ <NUM_LIT> ] ) != REG || REGNO ( operands [ <NUM_LIT> ] ) != LP_REGNO ) { rtx ra = gen_rtx_REG ( Pmode , LP_REGNO ) ; emit_move_insn ( ra , operands [ <NUM_LIT> ] ) ; operands [ <NUM_LIT> ] = ra ;


<s> rtx ra = gen_rtx_REG ( Pmode , LP_REGNO ) ; emit_move_insn ( ra , operands [ <NUM_LIT> ] ) ;


<s> else { emit_move_insn ( gen_rtx_REG ( rmode , REGSAVE_CONTROL_TEMP ) , gen_rtx_MEM ( rmode , plus_constant ( Pmode , stack_pointer_rtx , sp_offset - rss ) ) ) ; emit_move_insn ( gen_rtx_REG ( rmode , i ) , gen_rtx_REG ( rmode , REGSAVE_CONTROL_TEMP ) ) ; } } } if ( lp_slot != - <NUM_LIT> ) { emit_move_insn ( gen_rtx_REG ( SImode , REGSAVE_CONTROL_TEMP ) , gen_rtx_MEM ( SImode , plus_constant ( Pmode , stack_pointer_rtx , lp_slot ) ) ) ; lp_temp = REGSAVE_CONTROL_TEMP ; } add_constant ( SP_REGNO , SP_REGNO , sp_offset , <NUM_LIT> ) ; if ( crtl -> calls_eh_return && mep_prevent_lp_restore ) emit_insn ( gen_addsi3 ( gen_rtx_REG ( SImode , SP_REGNO ) , gen_rtx_REG ( SImode , SP_REGNO ) , cfun -> machine -> eh_stack_adjust ) ) ; if ( mep_sibcall_epilogue ) return ; if ( mep_disinterrupt_p ( ) ) emit_insn ( gen_mep_enable_int ( ) ) ; if ( mep_prevent_lp_restore ) { emit_jump_insn ( gen_eh_return_internal ( ) ) ;


<s> if ( GET_CODE ( operands [ i ] ) == MEM && ( t == 'b' || t == 't' ) ) { rtx sym , n , r ; int u ; sym = XEXP ( operands [ i ] , <NUM_LIT> ) ; if ( GET_CODE ( sym ) == CONST && GET_CODE ( XEXP ( sym , <NUM_LIT> ) ) == UNSPEC ) sym = XVECEXP ( XEXP ( sym , <NUM_LIT> ) , <NUM_LIT> , <NUM_LIT> ) ; if ( t == 'b' ) { r = mep_tp_rtx ( ) ; u = UNS_TPREL ; } else { r = mep_gp_rtx ( ) ; u = UNS_GPREL ; } n = gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , sym ) , u ) ; n = gen_rtx_CONST ( Pmode , n ) ; n = gen_rtx_PLUS ( Pmode , r , n ) ; operands [ i ] = replace_equiv_address ( operands [ i ] , n ) ; } } } if ( ( GET_CODE ( operands [ <NUM_LIT> ] ) != REG && MEP_CONTROL_REG ( operands [ <NUM_LIT> ] ) ) || ( GET_CODE ( operands [ <NUM_LIT> ] ) != REG && MEP_CONTROL_REG ( operands [ <NUM_LIT> ] ) ) ) { rtx temp ; fprintf ( stderr , <STR_LIT> ) ; temp = gen_reg_rtx ( mode ) ; emit_move_insn ( temp , operands [ <NUM_LIT> ] ) ; operands [ <NUM_LIT> ] = temp ; } if ( symbolref_p ( operands [ <NUM_LIT> ] ) && ( mep_section_tag ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) == 'f' || ( GET_MODE_SIZE ( mode ) != <NUM_LIT> ) ) ) { rtx temp ; gcc_assert ( ! reload_in_progress && ! reload_completed ) ; temp = force_reg ( Pmode , XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) ; operands [ <NUM_LIT> ] = replace_equiv_address ( operands [ <NUM_LIT> ] , temp ) ; emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; return true ; } if ( ! post_reload && ( tag [ <NUM_LIT> ] == 't' || tag [ <NUM_LIT> ] == 'b' ) ) tag [ <NUM_LIT> ] = <NUM_LIT> ; if ( symbol_p ( operands [ <NUM_LIT> ] ) && ( tag [ <NUM_LIT> ] == 'f' || tag [ <NUM_LIT> ] == 't' || tag [ <NUM_LIT> ] == 'b' ) ) { emit_insn ( gen_movsi_topsym_s ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; emit_insn ( gen_movsi_botsym_s ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; return true ;


<s> if ( sp_offset + frame_size < <NUM_LIT> ) sp_offset += frame_size ; add_constant ( SP_REGNO , SP_REGNO , - sp_offset , <NUM_LIT> ) ; for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) if ( mep_call_saves_register ( i ) ) { rtx mem ; bool maybe_dead_p ; machine_mode rmode ; rss = cfun -> machine -> reg_save_slot [ i ] ; if ( ( i == TP_REGNO || i == GP_REGNO || i == LP_REGNO ) && ( ! mep_reg_set_in_function ( i ) && ! mep_interrupt_p ( ) ) ) continue ; if ( mep_reg_size ( i ) == <NUM_LIT> ) rmode = DImode ; else rmode = SImode ; mem = gen_rtx_MEM ( rmode , plus_constant ( Pmode , stack_pointer_rtx , sp_offset - rss ) ) ; maybe_dead_p = rtx_equal_p ( mem , has_hard_reg_initial_val ( rmode , i ) ) ; if ( GR_REGNO_P ( i ) || LOADABLE_CR_REGNO_P ( i ) ) F ( maybe_dead_move ( mem , gen_rtx_REG ( rmode , i ) , maybe_dead_p ) ) ; else if ( rmode == DImode ) { rtx_insn * insn ; int be = TARGET_BIG_ENDIAN ? <NUM_LIT> : <NUM_LIT> ; mem = gen_rtx_MEM ( SImode , plus_constant ( Pmode , stack_pointer_rtx , sp_offset - rss + be ) ) ; maybe_dead_move ( gen_rtx_REG ( SImode , REGSAVE_CONTROL_TEMP ) , gen_rtx_REG ( SImode , i ) , maybe_dead_p ) ; maybe_dead_move ( gen_rtx_REG ( SImode , REGSAVE_CONTROL_TEMP + <NUM_LIT> ) , gen_rtx_ZERO_EXTRACT ( SImode , gen_rtx_REG ( DImode , i ) , GEN_INT ( <NUM_LIT> ) , GEN_INT ( <NUM_LIT> ) ) , maybe_dead_p ) ; insn = maybe_dead_move ( mem , gen_rtx_REG ( SImode , REGSAVE_CONTROL_TEMP ) , maybe_dead_p ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; add_reg_note ( insn , REG_FRAME_RELATED_EXPR , gen_rtx_SET ( VOIDmode , copy_rtx ( mem ) , gen_rtx_REG ( rmode , i ) ) ) ; mem = gen_rtx_MEM ( SImode , plus_constant ( Pmode , stack_pointer_rtx , sp_offset - rss + ( <NUM_LIT> - be ) ) ) ; insn = maybe_dead_move ( mem , gen_rtx_REG ( SImode , REGSAVE_CONTROL_TEMP + <NUM_LIT> ) , maybe_dead_p ) ; } else { rtx_insn * insn ; maybe_dead_move ( gen_rtx_REG ( rmode , REGSAVE_CONTROL_TEMP ) , gen_rtx_REG ( rmode , i ) , maybe_dead_p ) ; insn = maybe_dead_move ( mem , gen_rtx_REG ( rmode , REGSAVE_CONTROL_TEMP ) , maybe_dead_p ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; add_reg_note ( insn , REG_FRAME_RELATED_EXPR , gen_rtx_SET ( VOIDmode , copy_rtx ( mem ) , gen_rtx_REG ( rmode , i ) ) ) ; } } if ( frame_pointer_needed ) { add_constant ( FP_REGNO , SP_REGNO , sp_offset - reg_save_size , <NUM_LIT> ) ; }


<s> int s0 = mep_section_tag ( operands [ <NUM_LIT> ] ) == 'f' ; int s1 = mep_section_tag ( operands [ <NUM_LIT> ] ) == 'f' ; int c0 = mep_nongeneral_reg ( operands [ <NUM_LIT> ] ) ; int c1 = mep_nongeneral_reg ( operands [ <NUM_LIT> ] ) ; int which = ( s0 ? <NUM_LIT> : <NUM_LIT> ) + ( c0 ? <NUM_LIT> : <NUM_LIT> ) + ( s1 ? <NUM_LIT> : <NUM_LIT> ) + ( c1 ? <NUM_LIT> : <NUM_LIT> ) ; fprintf ( stderr , <STR_LIT> , mode_name [ mode ] ) ; debug_rtx ( operands [ <NUM_LIT> ] ) ; debug_rtx ( operands [ <NUM_LIT> ] ) ; switch ( which ) { case <NUM_LIT> : case <NUM_LIT> : emit_move_insn ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; return ; case <NUM_LIT> : case <NUM_LIT> :


return mep_expand_setcc_1 ( code , dest , op0 , op1 ) ;


<s> if ( GET_CODE ( op2 ) != CONST_INT || INTVAL ( op2 ) == <NUM_LIT> ) return false ; op2 = GEN_INT ( INTVAL ( op2 ) + <NUM_LIT> ) ; return mep_expand_setcc_1 ( LT , dest , op1 , op2 ) ; case LEU : if ( GET_CODE ( op2 ) != CONST_INT || INTVAL ( op2 ) == - <NUM_LIT> ) return false ; op2 = GEN_INT ( trunc_int_for_mode ( INTVAL ( op2 ) + <NUM_LIT> , SImode ) ) ; return mep_expand_setcc_1 ( LTU , dest , op1 , op2 ) ; case GE : if ( GET_CODE ( op2 ) != CONST_INT || INTVAL ( op2 ) == trunc_int_for_mode ( <NUM_LIT> , SImode ) ) return false ;


<s> expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; u = fold_build_pointer_plus_hwi ( u , <NUM_LIT> * ( ( ns + <NUM_LIT> ) / <NUM_LIT> ) ) ; t = build2 ( MODIFY_EXPR , ptr_type_node , next_cop , u ) ; TREE_SIDE_EFFECTS ( t ) = <NUM_LIT> ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; u = make_tree ( ptr_type_node , nextarg ) ; t = build2 ( MODIFY_EXPR , ptr_type_node , next_stack , u ) ; TREE_SIDE_EFFECTS ( t ) = <NUM_LIT> ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ;


<s> tree f_next_gp , f_next_gp_limit , f_next_cop , f_next_stack ; tree next_gp , next_gp_limit , next_cop , next_stack ; tree t , u ; int ns ; ns = cfun -> machine -> arg_regs_to_save ; f_next_gp = TYPE_FIELDS ( va_list_type_node ) ; f_next_gp_limit = DECL_CHAIN ( f_next_gp ) ; f_next_cop = DECL_CHAIN ( f_next_gp_limit ) ; f_next_stack = DECL_CHAIN ( f_next_cop ) ; next_gp = build3 ( COMPONENT_REF , TREE_TYPE ( f_next_gp ) , valist , f_next_gp , NULL_TREE ) ; next_gp_limit = build3 ( COMPONENT_REF , TREE_TYPE ( f_next_gp_limit ) , valist , f_next_gp_limit , NULL_TREE ) ; next_cop = build3 ( COMPONENT_REF , TREE_TYPE ( f_next_cop ) , valist , f_next_cop , NULL_TREE ) ; next_stack = build3 ( COMPONENT_REF , TREE_TYPE ( f_next_stack ) , valist , f_next_stack , NULL_TREE ) ; u = make_tree ( sizetype , expand_builtin_saveregs ( ) ) ; u = fold_convert ( ptr_type_node , u ) ; t = build2 ( MODIFY_EXPR , ptr_type_node , next_gp , u ) ; TREE_SIDE_EFFECTS ( t ) = <NUM_LIT> ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; u = fold_build_pointer_plus_hwi ( u , <NUM_LIT> * ns ) ; t = build2 ( MODIFY_EXPR , ptr_type_node , next_gp_limit , u ) ; TREE_SIDE_EFFECTS ( t ) = <NUM_LIT> ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; u = fold_build_pointer_plus_hwi ( u , <NUM_LIT> * ( ( ns + <NUM_LIT> ) / <NUM_LIT> ) ) ; t = build2 ( MODIFY_EXPR , ptr_type_node , next_cop , u ) ; TREE_SIDE_EFFECTS ( t ) = <NUM_LIT> ; expand_expr ( t , const0_rtx , VOIDmode , EXPAND_NORMAL ) ; u = make_tree ( ptr_type_node , nextarg ) ;

t = build2 ( MODIFY_EXPR , ptr_type_node , next_stack , u ) ;


if ( pragma_htab ) pragma_htab -> traverse < void * , note_unused_pragma_disinterrupt > ( NULL ) ;


<s> if ( pragma_htab ) pragma_htab -> traverse < void * , note_unused_pragma_disinterrupt > ( NULL ) ;


<s> if ( GET_MODE ( insn ) == BImode && get_attr_slots ( insn ) != SLOTS_CORE ) fputc ( '+' , asm_out_file ) ;


<s> void mep_final_prescan_insn ( rtx_insn * insn , rtx * operands ATTRIBUTE_UNUSED , int noperands ATTRIBUTE_UNUSED ) {

if ( GET_MODE ( insn ) == BImode && get_attr_slots ( insn ) != SLOTS_CORE ) fputc ( '+' , asm_out_file ) ;


<s> term = XEXP ( x , <NUM_LIT> ) ; if ( has_hard_reg_initial_val ( Pmode , TP_REGNO ) && base == mep_tp_rtx ( ) ) unspec = UNS_TPREL ; else if ( has_hard_reg_initial_val ( Pmode , GP_REGNO ) && base == mep_gp_rtx ( ) ) unspec = UNS_GPREL ; else return x ; if ( GET_CODE ( term ) != CONST ) return x ; term = XEXP ( term , <NUM_LIT> ) ; if ( GET_CODE ( term ) != UNSPEC || XINT ( term , <NUM_LIT> ) != unspec ) return x ;

return XVECEXP ( term , <NUM_LIT> , <NUM_LIT> ) ;


<s> else return x ; if ( GET_CODE ( term ) != CONST ) return x ; term = XEXP ( term , <NUM_LIT> ) ; if ( GET_CODE ( term ) != UNSPEC || XINT ( term , <NUM_LIT> ) != unspec ) return x ; return XVECEXP ( term , <NUM_LIT> , <NUM_LIT> ) ;


<s> if ( recog_memoized ( insn ) >= <NUM_LIT> && get_attr_slot ( insn ) == slot && get_attr_length ( insn ) == length ) return insn ; }


<s> int i ; for ( i = nready - <NUM_LIT> ; i >= <NUM_LIT> ; -- i ) { rtx_insn * insn = ready [ i ] ; if ( recog_memoized ( insn ) >= <NUM_LIT> && get_attr_slot ( insn ) == slot && get_attr_length ( insn ) == length ) return insn ;


<s> note = find_reg_note ( insn , REG_FRAME_RELATED_EXPR , <NUM_LIT> ) ; expr = ( note != <NUM_LIT> ? XEXP ( note , <NUM_LIT> ) : copy_rtx ( PATTERN ( insn ) ) ) ; RTX_FRAME_RELATED_P ( expr ) = <NUM_LIT> ;


<s> rtx note , expr ; note = find_reg_note ( insn , REG_FRAME_RELATED_EXPR , <NUM_LIT> ) ; expr = ( note != <NUM_LIT> ? XEXP ( note , <NUM_LIT> ) : copy_rtx ( PATTERN ( insn ) ) ) ; RTX_FRAME_RELATED_P ( expr ) = <NUM_LIT> ;


<s> CUMULATIVE_ARGS * cum = get_cumulative_args ( cum_v ) ; if ( mode == VOIDmode ) return GEN_INT ( cum -> vliw ) ; if ( cum -> nregs < <NUM_LIT> ) { if ( type && TARGET_IVC2 && VECTOR_TYPE_P ( type ) ) return gen_rtx_REG ( mode , cum -> nregs + <NUM_LIT> ) ; else return gen_rtx_REG ( mode , cum -> nregs + <NUM_LIT> ) ; } return NULL_RTX ;


<s> return ( lookup_attribute ( <STR_LIT> , attrs ) == <NUM_LIT> && lookup_attribute ( <STR_LIT> , attrs ) == <NUM_LIT> ) ;


<s> if ( decl == NULL ) return false ; if ( mep_section_tag ( DECL_RTL ( decl ) ) == 'f' ) return false ;

if ( mep_interrupt_p ( ) || mep_disinterrupt_p ( ) ) return false ;


<s> static bool mep_function_ok_for_sibcall ( tree decl , tree exp ATTRIBUTE_UNUSED ) { if ( decl == NULL ) return false ;

if ( mep_section_tag ( DECL_RTL ( decl ) ) == 'f' ) return false ;


<s> void mep_function_profiler ( FILE * file ) { fprintf ( file , <STR_LIT> ) ; fprintf ( file , <STR_LIT> ) ; fprintf ( file , <STR_LIT> ) ; fprintf ( file , <STR_LIT> ) ; fprintf ( file , <STR_LIT> ) ; fprintf ( file , <STR_LIT> ) ; fprintf ( file , <STR_LIT> ) ; fprintf ( file , <STR_LIT> ) ;


<s> if ( TARGET_IVC2 && VECTOR_TYPE_P ( type ) ) return gen_rtx_REG ( TYPE_MODE ( type ) , <NUM_LIT> ) ; return gen_rtx_REG ( TYPE_MODE ( type ) , RETURN_VALUE_REGNUM ) ;


<s> static bool mep_general_copro_reg ( rtx x ) {

while ( GET_CODE ( x ) == SUBREG ) x = XEXP ( x , <NUM_LIT> ) ;


<s> while ( GET_CODE ( x ) == SUBREG ) x = XEXP ( x , <NUM_LIT> ) ; return ( GET_CODE ( x ) == REG && CR_REGNO_P ( REGNO ( x ) ) ) ;


<s> while ( GET_CODE ( x ) == SUBREG ) x = XEXP ( x , <NUM_LIT> ) ;

return GET_CODE ( x ) == REG && GR_REGNO_P ( REGNO ( x ) ) ;


<s> static bool mep_general_reg ( rtx x ) {


<s> static bool mep_get_intrinsic_insn ( int intrinsic ATTRIBUTE_UNUSED , const struct cgen_insn * * insn_ptr ATTRIBUTE_UNUSED ) { int i ; i = mep_intrinsic_insn [ intrinsic ] ; while ( i >= <NUM_LIT> && ! CGEN_ENABLE_INSN_P ( i ) ) i = mep_intrinsic_chain [ i ] ; if ( i >= <NUM_LIT> ) { * insn_ptr = & cgen_insns [ i ] ; return true ; } return false ;


for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( mep_cmov_insns ) ; i ++ ) if ( mep_get_intrinsic_insn ( mep_cmov_insns [ i ] , cgen_insn ) ) return true ;


<s> else { tmp = build2 ( MODIFY_EXPR , void_type_node , res_addr , next_gp ) ; gimplify_and_add ( tmp , pre_p ) ; } tmp = fold_build_pointer_plus_hwi ( unshare_expr ( next_gp ) , <NUM_LIT> ) ; gimplify_assign ( unshare_expr ( next_gp ) , tmp , pre_p ) ; tmp = fold_build_pointer_plus_hwi ( unshare_expr ( next_cop ) , <NUM_LIT> ) ; gimplify_assign ( unshare_expr ( next_cop ) , tmp , pre_p ) ; tmp = build1 ( GOTO_EXPR , void_type_node , unshare_expr ( label_sover ) ) ; gimplify_and_add ( tmp , pre_p ) ; tmp = build1 ( LABEL_EXPR , void_type_node , unshare_expr ( label_selse ) ) ; gimplify_and_add ( tmp , pre_p ) ; tmp = build2 ( MODIFY_EXPR , void_type_node , res_addr , unshare_expr ( next_stack ) ) ; gimplify_and_add ( tmp , pre_p ) ; tmp = fold_build_pointer_plus_hwi ( unshare_expr ( next_stack ) , rsize ) ; gimplify_assign ( unshare_expr ( next_stack ) , tmp , pre_p ) ; tmp = build1 ( LABEL_EXPR , void_type_node , unshare_expr ( label_sover ) ) ; gimplify_and_add ( tmp , pre_p ) ; res_addr = fold_convert ( build_pointer_type ( type ) , res_addr ) ; if ( by_reference ) res_addr = build_va_arg_indirect_ref ( res_addr ) ; return build_va_arg_indirect_ref ( res_addr ) ;


<s> return get_hard_reg_initial_val ( Pmode , GP_REGNO ) ;


<s> for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( cgen_insns ) ; i ++ ) if ( ( cgen_insns [ i ] . groups & GROUP_KNOWN_CODE ) == <NUM_LIT> && mep_intrinsic_insn [ cgen_insns [ i ] . intrinsic ] >= <NUM_LIT> ) { tree ret_type = void_type_node ; tree bi_type ; if ( i > <NUM_LIT> && cgen_insns [ i ] . intrinsic == cgen_insns [ i - <NUM_LIT> ] . intrinsic ) continue ; if ( cgen_insns [ i ] . cret_p ) ret_type = mep_cgen_regnum_to_type ( cgen_insns [ i ] . regnums [ <NUM_LIT> ] . type ) ;


<s> add_builtin_type ( <STR_LIT> , cp_data_bus_int_type_node ) ; add_builtin_type ( <STR_LIT> , opaque_vector_type_node ) ; add_builtin_type ( <STR_LIT> , v8qi_type_node ) ; add_builtin_type ( <STR_LIT> , v4hi_type_node ) ; add_builtin_type ( <STR_LIT> , v2si_type_node ) ; add_builtin_type ( <STR_LIT> , v8uqi_type_node ) ; add_builtin_type ( <STR_LIT> , v4uhi_type_node ) ; add_builtin_type ( <STR_LIT> , v2usi_type_node ) ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( cgen_insns ) ; i ++ ) if ( ( cgen_insns [ i ] . groups & GROUP_KNOWN_CODE ) == <NUM_LIT> && mep_intrinsic_insn [ cgen_insns [ i ] . intrinsic ] >= <NUM_LIT> ) { tree ret_type = void_type_node ; tree bi_type ; if ( i > <NUM_LIT> && cgen_insns [ i ] . intrinsic == cgen_insns [ i - <NUM_LIT> ] . intrinsic ) continue ; if ( cgen_insns [ i ] . cret_p ) ret_type = mep_cgen_regnum_to_type ( cgen_insns [ i ] . regnums [ <NUM_LIT> ] . type ) ; bi_type = build_function_type_list ( ret_type , NULL_TREE ) ; add_builtin_function ( cgen_intrinsics [ cgen_insns [ i ] . intrinsic ] , bi_type , cgen_insns [ i ] . intrinsic , BUILT_IN_MD , NULL , NULL ) ;


<s> void mep_init_cumulative_args ( CUMULATIVE_ARGS * pcum , tree fntype , rtx libname ATTRIBUTE_UNUSED , tree fndecl ATTRIBUTE_UNUSED ) { pcum -> nregs = <NUM_LIT> ;

if ( fntype && lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( fntype ) ) ) pcum -> vliw = <NUM_LIT> ;


<s> mep_selected_isa = mep_configs [ <NUM_LIT> ] . isa ; if ( mep_config_string != <NUM_LIT> ) for ( i = <NUM_LIT> ; mep_configs [ i ] . config_name ; i ++ ) if ( strcmp ( mep_config_string , mep_configs [ i ] . config_name ) == <NUM_LIT> ) { mep_selected_isa = mep_configs [ i ] . isa ; break ; } for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( mep_intrinsic_insn ) ; i ++ ) mep_intrinsic_insn [ i ] = - <NUM_LIT> ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( cgen_insns ) ; i ++ ) if ( ( cgen_insns [ i ] . isas & mep_selected_isa ) != <NUM_LIT> ) { mep_intrinsic_chain [ i ] = mep_intrinsic_insn [ cgen_insns [ i ] . intrinsic ] ;

mep_intrinsic_insn [ cgen_insns [ i ] . intrinsic ] = i ;


<s> break ; } for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( mep_intrinsic_insn ) ; i ++ ) mep_intrinsic_insn [ i ] = - <NUM_LIT> ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( cgen_insns ) ; i ++ ) if ( ( cgen_insns [ i ] . isas & mep_selected_isa ) != <NUM_LIT> ) { mep_intrinsic_chain [ i ] = mep_intrinsic_insn [ cgen_insns [ i ] . intrinsic ] ;


<s> return ggc_cleared_alloc < machine_function > ( ) ;


<s> if ( GET_CODE ( PATTERN ( prev ) ) == SEQUENCE ) prev = as_a < rtx_insn * > ( XVECEXP ( PATTERN ( prev ) , <NUM_LIT> , <NUM_LIT> ) ) ; icode = recog_memoized ( prev ) ; if ( icode < <NUM_LIT> || icode == CODE_FOR_repeat || icode == CODE_FOR_erepeat || get_attr_may_trap ( prev ) == MAY_TRAP_YES ) break ; if ( GET_MODE ( prev ) != BImode ) { count ++ ; next = prev ; if ( dump_file ) print_rtl_single ( dump_file , next ) ; if ( count == <NUM_LIT> ) break ; } } prev = PREV_INSN ( prev ) ; } prev = prev_real_insn ( next ) ; if ( prev ) switch ( recog_memoized ( prev ) ) { case CODE_FOR_repeat : case CODE_FOR_erepeat : if ( dump_file ) fprintf ( dump_file , <STR_LIT> ) ; emit_insn_before ( gen_nop ( ) , next ) ; break ; default : break ; } emit_label_before ( label , next ) ; if ( dump_file && count < <NUM_LIT> ) fprintf ( dump_file , <STR_LIT> , <NUM_LIT> - count , count == <NUM_LIT> ? <STR_LIT> : <STR_LIT> ) ; for ( ; count < <NUM_LIT> ; count ++ ) if ( including ) last_insn = emit_insn_after ( gen_nop ( ) , last_insn ) ; else emit_insn_before ( gen_nop ( ) , last_insn ) ; return last_insn ;


<s> if ( tmp == NULL_RTX ) return <NUM_LIT> ; tmp = PATTERN ( x ) ; note_stores ( PATTERN ( y ) , mep_insn_dependent_p_1 , & tmp ) ; if ( tmp == NULL_RTX ) return <NUM_LIT> ;


<s> static void mep_insn_dependent_p_1 ( rtx x , const_rtx pat ATTRIBUTE_UNUSED , void * data ) { rtx * pinsn = ( rtx * ) data ;

if ( * pinsn && reg_mentioned_p ( x , * pinsn ) ) * pinsn = NULL_RTX ;


<s> if ( ! crtl -> is_leaf ) if ( r == LP_REGNO || IVC2_ISAVED_REG ( r ) ) return true ; if ( ! crtl -> is_leaf || cfun -> machine -> doloop_tags > <NUM_LIT> ) if ( r == RPB_REGNO || r == RPE_REGNO || r == RPC_REGNO ) return true ; if ( crtl -> is_leaf && call_used_regs [ r ] && ! df_regs_ever_live_p ( r ) ) return false ;

if ( call_used_regs [ r ] && ! fixed_regs [ r ] ) return true ;


<s> if ( ! mep_interrupt_p ( ) ) return false ; if ( r == REGSAVE_CONTROL_TEMP || ( TARGET_64BIT_CR_REGS && TARGET_COP && r == REGSAVE_CONTROL_TEMP + <NUM_LIT> ) ) return true ; if ( mep_asm_without_operands_p ( ) && ( ! fixed_regs [ r ] || ( r == RPB_REGNO || r == RPE_REGNO || r == RPC_REGNO || r == LP_REGNO ) || IVC2_ISAVED_REG ( r ) ) ) return true ; if ( ! crtl -> is_leaf ) if ( r == LP_REGNO || IVC2_ISAVED_REG ( r ) ) return true ; if ( ! crtl -> is_leaf || cfun -> machine -> doloop_tags > <NUM_LIT> ) if ( r == RPB_REGNO || r == RPE_REGNO || r == RPC_REGNO ) return true ; if ( crtl -> is_leaf && call_used_regs [ r ] && ! df_regs_ever_live_p ( r ) ) return false ; if ( call_used_regs [ r ] && ! fixed_regs [ r ] ) return true ; if ( IVC2_ISAVED_REG ( r ) ) return true ;


<s> static int already_reported_p [ ARRAY_SIZE ( cgen_intrinsics ) ] ; if ( already_reported_p [ intrinsic ] ) return ; if ( mep_intrinsic_insn [ intrinsic ] < <NUM_LIT> ) error ( <STR_LIT> , cgen_intrinsics [ intrinsic ] ) ; else if ( CGEN_CURRENT_GROUP == GROUP_VLIW ) error ( <STR_LIT> , cgen_intrinsics [ intrinsic ] ) ; else error ( <STR_LIT> , cgen_intrinsics [ intrinsic ] ) ;

already_reported_p [ intrinsic ] = <NUM_LIT> ;


<s> if ( mep_intrinsic_insn [ intrinsic ] < <NUM_LIT> ) error ( <STR_LIT> , cgen_intrinsics [ intrinsic ] ) ; else if ( CGEN_CURRENT_GROUP == GROUP_VLIW ) error ( <STR_LIT> , cgen_intrinsics [ intrinsic ] ) ;

else error ( <STR_LIT> , cgen_intrinsics [ intrinsic ] ) ;


<s> } label = gen_label_rtx ( ) ; emit_label_after ( label , after ) ; for ( i = <NUM_LIT> ; i <= <NUM_LIT> ; i ++ ) if ( GET_CODE ( XEXP ( XEXP ( set , <NUM_LIT> ) , i ) ) == LABEL_REF ) { rtx ref = XEXP ( XEXP ( set , <NUM_LIT> ) , i ) ; if ( LABEL_NUSES ( XEXP ( ref , <NUM_LIT> ) ) == <NUM_LIT> ) delete_insn ( XEXP ( ref , <NUM_LIT> ) ) ; XEXP ( ref , <NUM_LIT> ) = label ; LABEL_NUSES ( label ) ++ ; JUMP_LABEL ( insn ) = label ; }


<s> if ( ret_code == CODE_FOR_return_internal || ret_code == CODE_FOR_eh_return_internal ) { LABEL_NUSES ( label ) -- ; if ( LABEL_NUSES ( label ) == <NUM_LIT> ) delete_insn ( label ) ; PATTERN ( insn ) = copy_rtx ( PATTERN ( ret ) ) ; INSN_CODE ( insn ) = - <NUM_LIT> ; } } }


<s> rtx_insn * insn , * label , * ret ; int ret_code ; for ( insn = insns ; insn ; insn = NEXT_INSN ( insn ) ) if ( simplejump_p ( insn ) ) { label = ret = safe_as_a < rtx_insn * > ( JUMP_LABEL ( insn ) ) ; while ( ret && ( NOTE_P ( ret ) || LABEL_P ( ret ) || GET_CODE ( PATTERN ( ret ) ) == USE ) ) ret = NEXT_INSN ( ret ) ; if ( ret ) { ret_code = recog_memoized ( ret ) ; if ( ret_code == CODE_FOR_return_internal || ret_code == CODE_FOR_eh_return_internal ) { LABEL_NUSES ( label ) -- ; if ( LABEL_NUSES ( label ) == <NUM_LIT> ) delete_insn ( label ) ; PATTERN ( insn ) = copy_rtx ( PATTERN ( ret ) ) ; INSN_CODE ( insn ) = - <NUM_LIT> ; }


<s> fprintf ( stderr , <STR_LIT> ) ; return false ; } fprintf ( stderr , <STR_LIT> ) ; return true ; } if ( GET_CODE ( x ) == REG && GEN_REG ( REGNO ( x ) , strict ) ) { fprintf ( stderr , <STR_LIT> ) ; return true ; } if ( GET_CODE ( x ) == PLUS && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == REG && GEN_REG ( REGNO ( XEXP ( x , <NUM_LIT> ) ) , strict ) && const_in_range ( XEXP ( x , <NUM_LIT> ) , - <NUM_LIT> , <NUM_LIT> ) ) { fprintf ( stderr , <STR_LIT> ) ; return true ; } if ( GET_CODE ( x ) == PLUS && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == REG && GEN_REG ( REGNO ( XEXP ( x , <NUM_LIT> ) ) , strict ) && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST && ( GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == UNSPEC || ( GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) , <NUM_LIT> ) ) == UNSPEC && GET_CODE ( XEXP ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) , <NUM_LIT> ) ) == CONST_INT ) ) ) { fprintf ( stderr , <STR_LIT> ) ; return true ; } the_tag = mep_section_tag ( x ) ; if ( the_tag == 'f' ) {


<s> static bool mep_legitimate_constant_p ( machine_mode mode ATTRIBUTE_UNUSED , rtx x ) { if ( GET_CODE ( x ) == SYMBOL_REF && ( reload_in_progress || reload_completed ) ) { char e = mep_section_tag ( x ) ;


<s> arg = mep_convert_arg ( operand -> mode , arg ) ; if ( operand -> predicate ( arg , operand -> mode ) ) return arg ; if ( GET_CODE ( arg ) == CONST_INT || GET_CODE ( arg ) == CONST_DOUBLE ) arg = force_reg ( operand -> mode , arg ) ; else arg = mep_convert_arg ( operand -> mode , force_reg ( GET_MODE ( arg ) , arg ) ) ; if ( operand -> predicate ( arg , operand -> mode ) ) return arg ; return <NUM_LIT> ;


<s> int mep_legitimize_reload_address ( rtx * x , machine_mode mode , int opnum , int type_i , int ind_levels ATTRIBUTE_UNUSED ) { enum reload_type type = ( enum reload_type ) type_i ; if ( GET_CODE ( * x ) == PLUS && GET_CODE ( XEXP ( * x , <NUM_LIT> ) ) == MEM && GET_CODE ( XEXP ( * x , <NUM_LIT> ) ) == REG ) { push_reload ( * x , NULL_RTX , x , NULL , GENERAL_REGS , mode , VOIDmode , <NUM_LIT> , <NUM_LIT> , opnum , type ) ; return <NUM_LIT> ; } if ( GET_CODE ( * x ) == PLUS && GET_CODE ( XEXP ( * x , <NUM_LIT> ) ) == SYMBOL_REF && GET_CODE ( XEXP ( * x , <NUM_LIT> ) ) == CONST_INT ) { char e = mep_section_tag ( XEXP ( * x , <NUM_LIT> ) ) ;


<s> bool mep_lookup_pragma_disinterrupt ( const char * funcname ) { return mep_lookup_pragma_flag ( funcname , FUNC_DISINTERRUPT ) ;


<s> return mep_lookup_pragma_flag ( funcname , FUNC_DISINTERRUPT ) ;


<s> if ( ! pragma_htab ) return false ; if ( funcname [ <NUM_LIT> ] == '@' && funcname [ <NUM_LIT> ] == '.' ) funcname += <NUM_LIT> ; pragma_entry * slot = pragma_htab -> get ( funcname ) ; if ( slot && ( slot -> flag & flag ) ) { slot -> used |= flag ; return true ;


<s> SET_NEXT_INSN ( cop ) = NEXT_INSN ( insn ) ; PUT_MODE ( core_insn , VOIDmode ) ; PUT_MODE ( cop , BImode ) ; INSN_LOCATION ( insn ) = INSN_LOCATION ( INSN_LOCATION ( core_insn ) ? core_insn : cop ) ; INSN_LOCATION ( core_insn ) = <NUM_LIT> ;


<s> expr = mep_frame_expr ( insn2 ) ; if ( RTX_FRAME_RELATED_P ( insn1 ) ) expr = gen_rtx_SEQUENCE ( VOIDmode , gen_rtvec ( <NUM_LIT> , mep_frame_expr ( insn1 ) , expr ) ) ; set_unique_reg_note ( insn1 , REG_FRAME_RELATED_EXPR , expr ) ; RTX_FRAME_RELATED_P ( insn1 ) = <NUM_LIT> ; }

PATTERN ( insn1 ) = gen_rtx_PARALLEL ( VOIDmode , gen_rtvec ( <NUM_LIT> , PATTERN ( insn1 ) , PATTERN ( insn2 ) ) ) ;


<s> if ( ! reg ) return false ; if ( modes_too && ( GET_MODE ( in ) != GET_MODE ( reg ) ) ) return false ; return ( REGNO ( in ) == REGNO ( reg ) ) ; case SCRATCH : case CC0 : case PC : case CONST_INT : case CONST_DOUBLE : return false ; default : break ; } if ( code == SET && ! reg ) return mep_mentioned_p ( SET_DEST ( in ) , reg , modes_too ) ; fmt = GET_RTX_FORMAT ( code ) ; for ( i = GET_RTX_LENGTH ( code ) - <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) { if ( fmt [ i ] == 'E' ) { register int j ; for ( j = XVECLEN ( in , i ) - <NUM_LIT> ; j >= <NUM_LIT> ; j -- ) if ( mep_mentioned_p ( XVECEXP ( in , i , j ) , reg , modes_too ) ) return true ; } else if ( fmt [ i ] == 'e' && mep_mentioned_p ( XEXP ( in , i ) , reg , modes_too ) ) return true ; }


<s> static void mep_move_ready_insn ( rtx_insn * * ready , int nready , rtx_insn * insn ) { int i ; for ( i = <NUM_LIT> ; i < nready ; ++ i ) if ( ready [ i ] == insn ) {

for ( ; i < nready - <NUM_LIT> ; ++ i ) ready [ i ] = ready [ i + <NUM_LIT> ] ;


<s> int i ; for ( i = <NUM_LIT> ; i < nready ; ++ i ) if ( ready [ i ] == insn ) { for ( ; i < nready - <NUM_LIT> ; ++ i ) ready [ i ] = ready [ i + <NUM_LIT> ] ; ready [ i ] = insn ; return ;


<s> int i ; fprintf ( stderr , <STR_LIT> , mode_name [ mode ] , mep_section_tag ( operands [ <NUM_LIT> ] ) , mep_section_tag ( operands [ <NUM_LIT> ] ) ) ; debug_rtx ( operands [ <NUM_LIT> ] ) ; debug_rtx ( operands [ <NUM_LIT> ] ) ; if ( GET_CODE ( operands [ <NUM_LIT> ] ) == HIGH ) return false ; if ( mep_section_tag ( operands [ <NUM_LIT> ] ) == 'f' || mep_section_tag ( operands [ <NUM_LIT> ] ) == 'f' ) { fprintf ( stderr , <STR_LIT> ) ; return false ; } i = mep_section_tag ( operands [ <NUM_LIT> ] ) ; if ( ( i == 'b' || i == 't' ) && ! reload_completed && ! reload_in_progress ) { fprintf ( stderr , <STR_LIT> ) ; return false ; } for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { rtx x = operands [ i ] ; if ( GET_CODE ( x ) == SUBREG ) x = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( x ) == REG && ! MEP_CONTROL_REG ( x ) ) { fprintf ( stderr , <STR_LIT> ) ; return true ; }


<s> for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { rtx x = operands [ i ] ; if ( GET_CODE ( x ) == SUBREG ) x = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( x ) == REG && ! MEP_CONTROL_REG ( x ) ) { fprintf ( stderr , <STR_LIT> ) ; return true ; } } fprintf ( stderr , <STR_LIT> ) ; return false ;


<s> rtx mep_mulr_source ( rtx_insn * insn , rtx dest , rtx src1 , rtx src2 ) { if ( rtx_equal_p ( dest , src1 ) ) return src2 ; else if ( rtx_equal_p ( dest , src2 ) ) return src1 ; else { if ( insn == <NUM_LIT> ) emit_insn ( gen_movsi ( copy_rtx ( dest ) , src1 ) ) ; else emit_insn_before ( gen_movsi ( copy_rtx ( dest ) , src1 ) , insn ) ; return src2 ;


<s> static int mep_multiple_address_regions ( tree list , bool check_section_attr ) { tree a ; int count_sections = <NUM_LIT> ; int section_attr_count = <NUM_LIT> ;

for ( a = list ; a ; a = TREE_CHAIN ( a ) ) {


<s> bool mep_multi_slot ( rtx_insn * x ) { return get_attr_slot ( x ) == SLOT_MULTI ;


<s> pat = PATTERN ( insn ) ; if ( GET_CODE ( pat ) == PARALLEL ) pat = XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ; if ( GET_CODE ( pat ) != SET ) return false ; subrtx_iterator :: array_type array ;

FOR_EACH_SUBRTX ( iter , array , SET_SRC ( pat ) , NONCONST ) {


<s> if ( GET_CODE ( pat ) != SET ) return false ; subrtx_iterator :: array_type array ; FOR_EACH_SUBRTX ( iter , array , SET_SRC ( pat ) , NONCONST ) { const_rtx x = * iter ; if ( REG_P ( x ) && REGNO ( x ) != LO_REGNO && REGNO ( x ) != HI_REGNO && reg_set_p ( x , prev ) ) return false ; }


<s> static bool mep_nongeneral_reg ( rtx x ) {


<s> static bool mep_nonregister ( rtx x ) { while ( GET_CODE ( x ) == SUBREG ) x = XEXP ( x , <NUM_LIT> ) ; return ( GET_CODE ( x ) != REG || REGNO ( x ) >= FIRST_PSEUDO_REGISTER ) ;


<s> void mep_note_pragma_call ( const char * funcname ) { mep_note_pragma_flag ( funcname , FUNC_CALL ) ;


<s> mep_note_pragma_flag ( funcname , FUNC_DISINTERRUPT ) ;


<s> const char * name = ggc_strdup ( funcname ) ; pragma_entry * slot = & pragma_htab -> get_or_insert ( name , & existed ) ; if ( ! existed ) { slot -> flag = <NUM_LIT> ; slot -> used = <NUM_LIT> ; } slot -> flag |= flag ;


<s> vec < cl_deferred_option > * v = ( vec < cl_deferred_option > * ) mep_deferred_options ; if ( v ) FOR_EACH_VEC_ELT ( * v , i , opt ) { switch ( opt -> opt_index ) { case OPT_mivc2 : for ( j = <NUM_LIT> ; j < <NUM_LIT> ; j ++ ) fixed_regs [ j + <NUM_LIT> ] = <NUM_LIT> ; for ( j = <NUM_LIT> ; j < <NUM_LIT> ; j ++ ) call_used_regs [ j + <NUM_LIT> ] = <NUM_LIT> ; for ( j = <NUM_LIT> ; j < <NUM_LIT> ; j ++ ) call_used_regs [ j + <NUM_LIT> ] = <NUM_LIT> ; RN ( <NUM_LIT> , <STR_LIT> ) ; RN ( <NUM_LIT> , <STR_LIT> ) ; RN ( <NUM_LIT> , <STR_LIT> ) ; RN ( <NUM_LIT> , <STR_LIT> ) ; RN ( <NUM_LIT> , <STR_LIT> ) ; RN ( <NUM_LIT> , <STR_LIT> ) ; RN ( <NUM_LIT> , <STR_LIT> ) ; RN ( <NUM_LIT> , <STR_LIT> ) ; RN ( <NUM_LIT> , <STR_LIT> ) ; RN ( <NUM_LIT> , <STR_LIT> ) ; RN ( <NUM_LIT> , <STR_LIT> ) ; RN ( <NUM_LIT> , <STR_LIT> ) ; RN ( <NUM_LIT> , <STR_LIT> ) ; RN ( <NUM_LIT> , <STR_LIT> ) ; RN ( <NUM_LIT> , <STR_LIT> ) ; RN ( <NUM_LIT> , <STR_LIT> ) ; RN ( <NUM_LIT> , <STR_LIT> ) ; RN ( <NUM_LIT> , <STR_LIT> ) ; RN ( <NUM_LIT> , <STR_LIT> ) ; RN ( <NUM_LIT> , <STR_LIT> ) ; RN ( <NUM_LIT> , <STR_LIT> ) ; RN ( <NUM_LIT> , <STR_LIT> ) ; RN ( <NUM_LIT> , <STR_LIT> ) ; break ; default : gcc_unreachable ( ) ; } } if ( flag_pic == <NUM_LIT> ) warning ( OPT_fpic , <STR_LIT> ) ; if ( flag_pic == <NUM_LIT> ) warning ( OPT_fPIC , <STR_LIT> ) ;

if ( TARGET_S && TARGET_M ) error ( <STR_LIT> ) ;


<s> case 'f' : switch_to_section ( farbss_section ) ; sec = <STR_LIT> ; break ; } if ( sec ) { const char * name2 ; int p2align = <NUM_LIT> ; while ( align > BITS_PER_UNIT ) { align /= <NUM_LIT> ; p2align ++ ; } name2 = targetm . strip_name_encoding ( name ) ; if ( global ) fprintf ( stream , <STR_LIT> , name2 ) ; fprintf ( stream , <STR_LIT> , p2align ) ; fprintf ( stream , <STR_LIT> , name2 ) ; fprintf ( stream , <STR_LIT> , name2 , size ) ; fprintf ( stream , <STR_LIT> , name2 , size ) ; return ; } } if ( ! global ) { fprintf ( stream , <STR_LIT> ) ;


<s> if ( TARGET_IVC2 && get_cumulative_args ( cum ) -> nregs < <NUM_LIT> && type != NULL_TREE && VECTOR_TYPE_P ( type ) ) return false ; return true ;


<s> case LABEL_REF : if ( mep_section_tag ( x ) != 'f' && reg_class_subset_p ( TPREL_REGS , rclass ) ) rclass = TPREL_REGS ; break ; default : break ; } return rclass ;


<s> default : output_operand_lossage ( <STR_LIT> ) ; } } if ( code == 'M' ) { const struct cgen_insn * insn ; mep_print_operand ( file , x , <NUM_LIT> ) ; if ( mep_get_move_insn ( mep_cmov , & insn ) && insn_data [ insn -> icode ] . n_operands == <NUM_LIT> ) { fputs ( <STR_LIT> , file ) ; if ( insn_data [ insn -> icode ] . operand [ <NUM_LIT> ] . predicate ( x , VOIDmode ) ) mep_print_operand ( file , x , <NUM_LIT> ) ; else mep_print_operand ( file , const0_rtx , <NUM_LIT> ) ; } return ; } encode_pattern ( x ) ; for ( i = <NUM_LIT> ; conversions [ i ] . pattern ; i ++ ) if ( conversions [ i ] . code == code && strcmp ( conversions [ i ] . pattern , pattern ) == <NUM_LIT> ) { for ( j = <NUM_LIT> ; conversions [ i ] . format [ j ] ; j ++ ) if ( conversions [ i ] . format [ j ] == '\\' ) { fputc ( conversions [ i ] . format [ j + <NUM_LIT> ] , file ) ; j ++ ; } else if ( ISDIGIT ( conversions [ i ] . format [ j ] ) ) { rtx r = patternr [ conversions [ i ] . format [ j ] - '0' ] ; switch ( GET_CODE ( r ) ) { case REG : fprintf ( file , <STR_LIT> , reg_names [ REGNO ( r ) ] ) ; break ;


<s> break ; case CONST_INT : switch ( code ) { case 'b' : fprintf ( file , <STR_LIT> , unique_bit_in ( INTVAL ( r ) ) ) ; break ; case 'B' : fprintf ( file , <STR_LIT> , bit_size_for_clip ( INTVAL ( r ) ) ) ; break ; case 'h' : fprintf ( file , <STR_LIT> , ( ( int ) INTVAL ( r ) >> <NUM_LIT> ) & <NUM_LIT> ) ; break ; case 'U' : fprintf ( file , <STR_LIT> , bit_size_for_clip ( INTVAL ( r ) ) - <NUM_LIT> ) ; break ; case 'J' : fprintf ( file , <STR_LIT> , ( int ) INTVAL ( r ) & <NUM_LIT> ) ; break ; case 'x' : if ( INTVAL ( r ) & ~ ( HOST_WIDE_INT ) <NUM_LIT> && ! ( INTVAL ( r ) & <NUM_LIT> ) ) fprintf ( file , HOST_WIDE_INT_PRINT_HEX , INTVAL ( r ) ) ; else fprintf ( file , HOST_WIDE_INT_PRINT_DEC , INTVAL ( r ) ) ; break ; case 'I' : if ( INTVAL ( r ) & ~ ( HOST_WIDE_INT ) <NUM_LIT> && conversions [ i ] . format [ j + <NUM_LIT> ] == <NUM_LIT> ) { fprintf ( file , HOST_WIDE_INT_PRINT_DEC , INTVAL ( r ) ) ; fprintf ( file , <STR_LIT> , ( int ) INTVAL ( r ) & <NUM_LIT> ) ; } else fprintf ( file , HOST_WIDE_INT_PRINT_DEC , INTVAL ( r ) ) ; break ; default : fprintf ( file , HOST_WIDE_INT_PRINT_DEC , INTVAL ( r ) ) ; break ; } break ; case CONST_DOUBLE : fprintf ( file , <STR_LIT> , ( unsigned long ) CONST_DOUBLE_HIGH ( r ) ) ; break ; case SYMBOL_REF : real_name = targetm . strip_name_encoding ( XSTR ( r , <NUM_LIT> ) ) ; assemble_name ( file , real_name ) ; break ; case LABEL_REF : output_asm_label ( r ) ; break ; default : fprintf ( stderr , <STR_LIT> ) ; debug_rtx ( r ) ; gcc_unreachable ( ) ; } } else { if ( conversions [ i ] . format [ j ] == '+' && ( ! code || code == 'I' ) && ISDIGIT ( conversions [ i ] . format [ j + <NUM_LIT> ] ) && GET_CODE ( patternr [ conversions [ i ] . format [ j + <NUM_LIT> ] - '0' ] ) == CONST_INT && INTVAL ( patternr [ conversions [ i ] . format [ j + <NUM_LIT> ] - '0' ] ) < <NUM_LIT> ) continue ; fputc ( conversions [ i ] . format [ j ] , file ) ; } break ; } if ( ! conversions [ i ] . pattern ) { error ( <STR_LIT> , code ? code : '-' , pattern ) ; debug_rtx ( x ) ; }


<s> if ( GET_CODE ( address ) == MEM ) address = XEXP ( address , <NUM_LIT> ) ; else gcc_assert ( GET_CODE ( address ) == REG ) ; mep_print_operand ( stream , address , <NUM_LIT> ) ;


<s> slots = buf ; break ; } } if ( GET_CODE ( PATTERN ( insn ) ) == USE ) slots = <STR_LIT> ; code = INSN_CODE ( insn ) ; if ( code >= <NUM_LIT> ) name = get_insn_name ( code ) ; if ( ! name ) name = <STR_LIT> ;

fprintf ( dump , <STR_LIT> , code , INSN_UID ( insn ) , name , slots ) ;


<s> if ( CONTROL_REGNO_P ( regno ) ) return CONTROL_REGS ; if ( CR_REGNO_P ( regno ) ) { int i , j ; for ( i = USER0_REGS ; i <= USER3_REGS ; ++ i ) { if ( ! TEST_HARD_REG_BIT ( reg_class_contents [ i ] , regno ) ) continue ; for ( j = <NUM_LIT> ; j < N_REG_CLASSES ; ++ j ) { enum reg_class sub = reg_class_subclasses [ i ] [ j ] ; if ( sub == LIM_REG_CLASSES ) return i ;

if ( TEST_HARD_REG_BIT ( reg_class_contents [ sub ] , regno ) ) break ;


<s> if ( ! insn ) return false ; reg = gen_rtx_REG ( SImode , regno ) ;

for ( insn = NEXT_INSN ( insn ) ; insn ; insn = NEXT_INSN ( insn ) ) if ( INSN_P ( insn ) && mep_reg_set_p ( reg , insn ) ) return true ;


if ( GET_CODE ( insn ) == SET && GET_CODE ( XEXP ( insn , <NUM_LIT> ) ) == REG && GET_CODE ( XEXP ( insn , <NUM_LIT> ) ) == REG && REGNO ( XEXP ( insn , <NUM_LIT> ) ) == REGNO ( XEXP ( insn , <NUM_LIT> ) ) ) return false ;


<s> if ( INSN_P ( insn ) ) { if ( FIND_REG_INC_NOTE ( insn , reg ) ) return true ; insn = PATTERN ( insn ) ; }


<s> static int mep_reg_size ( int regno ) { if ( CR_REGNO_P ( regno ) && TARGET_64BIT_CR_REGS ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> reg = gen_rtx_REG ( SImode , regno ) ; sym = gen_rtx_SYMBOL_REF ( SImode , symbol ) ;

emit_insn ( gen_movsi_topsym_s ( reg , sym ) ) ;


<s> static void mep_reload_pointer ( int regno , const char * symbol ) { rtx reg , sym ; if ( ! df_regs_ever_live_p ( regno ) && crtl -> is_leaf ) return ; reg = gen_rtx_REG ( SImode , regno ) ; sym = gen_rtx_SYMBOL_REF ( SImode , symbol ) ; emit_insn ( gen_movsi_topsym_s ( reg , sym ) ) ;

emit_insn ( gen_movsi_botsym_s ( reg , reg , sym ) ) ;


<s> compute_bb_for_insn ( ) ; df_note_add_problem ( ) ; df_analyze ( ) ; mep_reorg_addcombine ( insns ) ; if ( ! mep_vliw_function_p ( cfun -> decl ) ) mep_reorg_regmove ( insns ) ; mep_jmp_return_reorg ( insns ) ; mep_bundle_insns ( insns ) ; mep_reorg_repeat ( insns ) ; if ( optimize && ! profile_flag && ! profile_arc_flag && TARGET_OPT_REPEAT && ( ! mep_interrupt_p ( ) || mep_interrupt_saved_reg ( RPB_REGNO ) ) ) mep_reorg_erepeat ( insns ) ; mep_reorg_noframe ( insns ) ; df_finish_pass ( false ) ;


<s> df_note_add_problem ( ) ; df_analyze ( ) ; mep_reorg_addcombine ( insns ) ; if ( ! mep_vliw_function_p ( cfun -> decl ) ) mep_reorg_regmove ( insns ) ; mep_jmp_return_reorg ( insns ) ; mep_bundle_insns ( insns ) ; mep_reorg_repeat ( insns ) ;

if ( optimize && ! profile_flag && ! profile_arc_flag && TARGET_OPT_REPEAT && ( ! mep_interrupt_p ( ) || mep_interrupt_saved_reg ( RPB_REGNO ) ) ) mep_reorg_erepeat ( insns ) ;


<s> if ( INSN_P ( n ) && INSN_CODE ( n ) == CODE_FOR_addsi3 && GET_CODE ( SET_DEST ( PATTERN ( n ) ) ) == REG && GET_CODE ( XEXP ( SET_SRC ( PATTERN ( n ) ) , <NUM_LIT> ) ) == REG && REGNO ( SET_DEST ( PATTERN ( n ) ) ) == REGNO ( XEXP ( SET_SRC ( PATTERN ( n ) ) , <NUM_LIT> ) ) && GET_CODE ( XEXP ( SET_SRC ( PATTERN ( n ) ) , <NUM_LIT> ) ) == CONST_INT ) { int ic = INTVAL ( XEXP ( SET_SRC ( PATTERN ( i ) ) , <NUM_LIT> ) ) ; int nc = INTVAL ( XEXP ( SET_SRC ( PATTERN ( n ) ) , <NUM_LIT> ) ) ; if ( REGNO ( SET_DEST ( PATTERN ( i ) ) ) == REGNO ( SET_DEST ( PATTERN ( n ) ) ) && ic + nc < <NUM_LIT> && ic + nc > - <NUM_LIT> ) { XEXP ( SET_SRC ( PATTERN ( i ) ) , <NUM_LIT> ) = GEN_INT ( ic + nc ) ; SET_NEXT_INSN ( i ) = NEXT_INSN ( n ) ; if ( NEXT_INSN ( i ) ) SET_PREV_INSN ( NEXT_INSN ( i ) ) = i ;


<s> rtx_insn * i , * n ; for ( i = insns ; i ; i = NEXT_INSN ( i ) ) if ( INSN_P ( i ) && INSN_CODE ( i ) == CODE_FOR_addsi3 && GET_CODE ( SET_DEST ( PATTERN ( i ) ) ) == REG && GET_CODE ( XEXP ( SET_SRC ( PATTERN ( i ) ) , <NUM_LIT> ) ) == REG && REGNO ( SET_DEST ( PATTERN ( i ) ) ) == REGNO ( XEXP ( SET_SRC ( PATTERN ( i ) ) , <NUM_LIT> ) ) && GET_CODE ( XEXP ( SET_SRC ( PATTERN ( i ) ) , <NUM_LIT> ) ) == CONST_INT ) { n = NEXT_INSN ( i ) ; if ( INSN_P ( n ) && INSN_CODE ( n ) == CODE_FOR_addsi3 && GET_CODE ( SET_DEST ( PATTERN ( n ) ) ) == REG && GET_CODE ( XEXP ( SET_SRC ( PATTERN ( n ) ) , <NUM_LIT> ) ) == REG && REGNO ( SET_DEST ( PATTERN ( n ) ) ) == REGNO ( XEXP ( SET_SRC ( PATTERN ( n ) ) , <NUM_LIT> ) ) && GET_CODE ( XEXP ( SET_SRC ( PATTERN ( n ) ) , <NUM_LIT> ) ) == CONST_INT ) {

int ic = INTVAL ( XEXP ( SET_SRC ( PATTERN ( i ) ) , <NUM_LIT> ) ) ;


<s> if ( simplejump_p ( insn ) ) { emit_insn_before ( gen_erepeat_end ( ) , insn ) ; delete_insn ( insn ) ; } else { mep_invert_branch ( insn , newlast ) ; emit_insn_after ( gen_erepeat_end ( ) , newlast ) ; } break ; } if ( LABEL_P ( prev ) ) { rtx_insn * user = <NUM_LIT> ; int safe = <NUM_LIT> ; if ( LABEL_NUSES ( prev ) == <NUM_LIT> ) { for ( user = PREV_INSN ( prev ) ; user && ( INSN_P ( user ) || NOTE_P ( user ) ) ; user = PREV_INSN ( user ) ) if ( JUMP_P ( user ) && JUMP_LABEL ( user ) == prev ) { safe = INSN_UID ( user ) ; break ; } } if ( ! safe ) break ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> , safe , INSN_UID ( prev ) ) ; } if ( INSN_P ( prev ) ) { count ++ ; } } }

if ( dump_file ) fprintf ( dump_file , <STR_LIT> ) ;


<s> int sp_adjust , sp2 ; rtx sp ; while ( insns && ! INSN_P ( insns ) ) insns = NEXT_INSN ( insns ) ; if ( ! insns ) return ; sp_adjust = add_sp_insn_p ( insns ) ; if ( sp_adjust == <NUM_LIT> ) return ; start_frame_insn = insns ; sp = SET_DEST ( PATTERN ( start_frame_insn ) ) ; insns = next_real_insn ( insns ) ; while ( insns ) { rtx_insn * next = next_real_insn ( insns ) ; if ( ! next ) break ; sp2 = add_sp_insn_p ( insns ) ; if ( sp2 ) { if ( end_frame_insn ) return ; end_frame_insn = insns ; if ( sp2 != - sp_adjust ) return ; } else if ( mep_mentioned_p ( insns , sp , <NUM_LIT> ) ) return ; else if ( CALL_P ( insns ) ) return ; insns = next ; } if ( end_frame_insn ) { delete_insn ( start_frame_insn ) ; delete_insn ( end_frame_insn ) ;


<s> if ( end_frame_insn ) return ; end_frame_insn = insns ; if ( sp2 != - sp_adjust ) return ; } else if ( mep_mentioned_p ( insns , sp , <NUM_LIT> ) ) return ; else if ( CALL_P ( insns ) ) return ; insns = next ; } if ( end_frame_insn ) { delete_insn ( start_frame_insn ) ; delete_insn ( end_frame_insn ) ;


<s> replace = <NUM_LIT> ; if ( GET_CODE ( pat ) == SET && GET_CODE ( SET_SRC ( pat ) ) == REG && GET_CODE ( SET_DEST ( pat ) ) == REG && find_regno_note ( insn , REG_DEAD , REGNO ( SET_SRC ( pat ) ) ) && mep_compatible_reg_class ( REGNO ( SET_SRC ( pat ) ) , REGNO ( SET_DEST ( pat ) ) ) ) { follow = next_nonnote_nondebug_insn ( insn ) ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> , INSN_UID ( insn ) ) ; while ( follow && NONJUMP_INSN_P ( follow ) && GET_CODE ( PATTERN ( follow ) ) == SET && ! dead_or_set_p ( follow , SET_SRC ( pat ) ) && ! mep_mentioned_p ( PATTERN ( follow ) , SET_SRC ( pat ) , <NUM_LIT> ) && ! mep_mentioned_p ( PATTERN ( follow ) , SET_DEST ( pat ) , <NUM_LIT> ) ) { if ( dump_file ) fprintf ( dump_file , <STR_LIT> , INSN_UID ( follow ) ) ; follow = next_nonnote_insn ( follow ) ; } if ( dump_file ) fprintf ( dump_file , <STR_LIT> , INSN_UID ( follow ) ) ; if ( follow && NONJUMP_INSN_P ( follow ) && GET_CODE ( PATTERN ( follow ) ) == SET && find_regno_note ( follow , REG_DEAD , REGNO ( SET_DEST ( pat ) ) ) ) { if ( GET_CODE ( SET_DEST ( PATTERN ( follow ) ) ) == REG ) { if ( mep_mentioned_p ( SET_SRC ( PATTERN ( follow ) ) , SET_DEST ( pat ) , <NUM_LIT> ) ) { replace = <NUM_LIT> ; where = & SET_SRC ( PATTERN ( follow ) ) ; } } else if ( GET_CODE ( SET_DEST ( PATTERN ( follow ) ) ) == MEM ) { if ( mep_mentioned_p ( PATTERN ( follow ) , SET_DEST ( pat ) , <NUM_LIT> ) ) { replace = <NUM_LIT> ; where = & PATTERN ( follow ) ; } } } } if ( replace ) { if ( dump_file ) { rtx_insn * x ; fprintf ( dump_file , <STR_LIT> ) ; for ( x = insn ; x ; x = NEXT_INSN ( x ) ) { print_rtl_single ( dump_file , x ) ; if ( x == follow ) break ; fprintf ( dump_file , <STR_LIT> ) ;


<s> break ; case CODE_FOR_doloop_end_internal : insn_extract ( insn ) ; loop = & loops [ INTVAL ( recog_data . operand [ <NUM_LIT> ] ) ] ; end = ( struct mep_doloop_end * ) alloca ( sizeof ( struct mep_doloop_end ) ) ; end -> insn = insn ; end -> fallthrough = next_real_insn ( insn ) ; end -> counter = recog_data . operand [ <NUM_LIT> ] ; end -> label = recog_data . operand [ <NUM_LIT> ] ; end -> scratch = recog_data . operand [ <NUM_LIT> ] ; if ( loop -> end != <NUM_LIT> && simplejump_p ( end -> fallthrough ) ) { end -> next = loop -> end -> next ; loop -> end -> next = end ; } else { end -> next = loop -> end ; loop -> end = end ; } break ; } for ( loop = loops ; loop < loops + cfun -> machine -> doloop_tags ; loop ++ ) if ( mep_repeat_loop_p ( loop ) ) { rtx_code_label * repeat_label ; rtx label_ref ; repeat_label = gen_label_rtx ( ) ; label_ref = gen_rtx_LABEL_REF ( VOIDmode , repeat_label ) ; emit_insn_before ( gen_repeat ( loop -> begin -> counter , label_ref ) , loop -> begin -> insn ) ; delete_insn ( loop -> begin -> insn ) ; mep_insert_repeat_label_last ( loop -> end -> insn , repeat_label , false , loop -> end -> next != <NUM_LIT> ) ; emit_insn_before ( gen_repeat_end ( ) , loop -> end -> insn ) ; delete_insn ( loop -> end -> insn ) ; for ( end = loop -> end -> next ; end != <NUM_LIT> ; end = end -> next ) { emit_jump_insn_before ( gen_jump ( repeat_label ) , end -> insn ) ; delete_insn ( end -> insn ) ;


<s> struct mep_doloop_end * end ; rtx fallthrough ; if ( loop -> begin == <NUM_LIT> || loop -> end == <NUM_LIT> || loop -> begin -> next != <NUM_LIT> ) return false ;

if ( prev_real_insn ( loop -> end -> label ) != loop -> begin -> insn ) return false ;


<s> static bool mep_repeat_loop_p ( struct mep_doloop * loop ) { struct mep_doloop_end * end ; rtx fallthrough ;

if ( loop -> begin == <NUM_LIT> || loop -> end == <NUM_LIT> || loop -> begin -> next != <NUM_LIT> ) return false ;


<s> return get_hard_reg_initial_val ( Pmode , LP_REGNO ) ;


<s> rtx mep_return_handler_rtx ( void ) { return gen_rtx_REG ( SImode , LP_REGNO ) ;


<s> return gen_rtx_REG ( SImode , LP_REGNO ) ;


<s> bool mep_return_in_memory ( const_tree type , const_tree decl ATTRIBUTE_UNUSED ) {

int size = bytesize ( type , BLKmode ) ;


<s> int size = bytesize ( type , BLKmode ) ;

if ( TARGET_IVC2 && VECTOR_TYPE_P ( type ) ) return size > <NUM_LIT> && size <= <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ;


<s> rtx mep_return_stackadj_rtx ( void ) {

return gen_rtx_REG ( SImode , <NUM_LIT> ) ;


<s> bool mep_reuse_lo_p ( rtx lo , rtx gpr , rtx_insn * insn , bool gpr_dead_p ) { bool result = mep_reuse_lo_p_1 ( lo , gpr , insn , gpr_dead_p ) ;


<s> case CODE_FOR_maddsi3 : extract_insn ( insn ) ; if ( rtx_equal_p ( recog_data . operand [ <NUM_LIT> ] , gpr ) ) { mep_rewrite_maddsi3 ( insn , gpr_dead_p ? NULL : recog_data . operand [ <NUM_LIT> ] , recog_data . operand [ <NUM_LIT> ] , recog_data . operand [ <NUM_LIT> ] , recog_data . operand [ <NUM_LIT> ] ) ; return true ; } return false ; case CODE_FOR_mulsi3r : case CODE_FOR_maddsi3r : extract_insn ( insn ) ; return rtx_equal_p ( recog_data . operand [ <NUM_LIT> ] , gpr ) ; default : if ( reg_set_p ( lo , insn ) || reg_set_p ( gpr , insn ) || volatile_insn_p ( PATTERN ( insn ) ) ) return false ; if ( gpr_dead_p && reg_referenced_p ( gpr , PATTERN ( insn ) ) ) gpr_dead_p = false ; break ;


<s> static void mep_rewrite_maddsi3 ( rtx_insn * insn , rtx dest , rtx src1 , rtx src2 , rtx src3 ) { rtx lo , pattern ; lo = gen_rtx_REG ( SImode , LO_REGNO ) ;

emit_insn_before ( gen_movsi ( copy_rtx ( lo ) , src3 ) , insn ) ;


<s> if ( dest ) pattern = gen_maddsi3r ( lo , dest , copy_rtx ( dest ) , mep_mulr_source ( insn , dest , src1 , src2 ) , copy_rtx ( lo ) ) ; else pattern = gen_maddsi3_lo ( lo , src1 , src2 , copy_rtx ( lo ) ) ;


<s> lo = gen_rtx_REG ( SImode , LO_REGNO ) ; if ( dest ) pattern = gen_mulsi3r ( lo , dest , copy_rtx ( dest ) , mep_mulr_source ( insn , dest , src1 , src2 ) ) ;

else pattern = gen_mulsi3_lo ( lo , src1 , src2 ) ;


<s> rtx lo , pattern ; lo = gen_rtx_REG ( SImode , LO_REGNO ) ; if ( dest ) pattern = gen_mulsi3r ( lo , dest , copy_rtx ( dest ) , mep_mulr_source ( insn , dest , src1 , src2 ) ) ; else pattern = gen_mulsi3_lo ( lo , src1 , src2 ) ;


<s> hi_clobber = XVECEXP ( pattern , <NUM_LIT> , XVECLEN ( pattern , <NUM_LIT> ) - <NUM_LIT> ) ; XEXP ( hi_clobber , <NUM_LIT> ) = gen_rtx_REG ( SImode , HI_REGNO ) ; PATTERN ( insn ) = pattern ;


<s> static void mep_rewrite_mult ( rtx_insn * insn , rtx pattern ) { rtx hi_clobber ; hi_clobber = XVECEXP ( pattern , <NUM_LIT> , XVECLEN ( pattern , <NUM_LIT> ) - <NUM_LIT> ) ; XEXP ( hi_clobber , <NUM_LIT> ) = gen_rtx_REG ( SImode , HI_REGNO ) ;


<s> switch ( code ) { case CONST_INT : if ( INTVAL ( x ) >= - <NUM_LIT> && INTVAL ( x ) < <NUM_LIT> ) * total = <NUM_LIT> ; else if ( INTVAL ( x ) >= - <NUM_LIT> && INTVAL ( x ) < <NUM_LIT> ) * total = <NUM_LIT> ; else * total = <NUM_LIT> ; return true ;


<s> switch ( code ) { case CONST_INT : if ( INTVAL ( x ) >= - <NUM_LIT> && INTVAL ( x ) < <NUM_LIT> ) * total = <NUM_LIT> ; else if ( INTVAL ( x ) >= - <NUM_LIT> && INTVAL ( x ) < <NUM_LIT> ) * total = <NUM_LIT> ; else * total = <NUM_LIT> ; return true ; case SYMBOL_REF : * total = optimize_size ? COSTS_N_INSNS ( <NUM_LIT> ) : COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case MULT : * total = ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT ? COSTS_N_INSNS ( <NUM_LIT> ) : COSTS_N_INSNS ( <NUM_LIT> ) ) ;


<s> if ( mep_general_reg ( x ) ) return NO_REGS ; if ( mep_general_copro_reg ( x ) ) { if ( mep_have_copro_copro_moves_p ) return NO_REGS ; if ( mep_have_core_copro_moves_p ) return GENERAL_REGS ; return NO_REGS ; }

if ( reg_class_subset_p ( rclass , LOADABLE_CR_REGS ) && constraint_satisfied_p ( x , CONSTRAINT_U ) ) return NO_REGS ;


<s> debug_rtx ( x ) ; if ( reg_class_subset_p ( rclass , CR_REGS ) ) rv = mep_secondary_copro_reload_class ( rclass , x ) ;

else if ( MEP_NONGENERAL_CLASS ( rclass ) && ( mep_nonregister ( x ) || mep_nongeneral_reg ( x ) ) ) rv = GENERAL_REGS ;


<s> else if ( MEP_NONGENERAL_CLASS ( rclass ) && ( mep_nonregister ( x ) || mep_nongeneral_reg ( x ) ) ) rv = GENERAL_REGS ; fprintf ( stderr , <STR_LIT> , reg_class_names [ rv ] ) ; return ( enum reg_class ) rv ;


<s> else if ( MEP_NONGENERAL_CLASS ( rclass ) && ( mep_nonregister ( x ) || mep_nongeneral_reg ( x ) ) ) rv = GENERAL_REGS ; fprintf ( stderr , <STR_LIT> , reg_class_names [ rv ] ) ;


<s> switch ( GET_CODE ( x ) ) { case MEM : case CONST : x = XEXP ( x , <NUM_LIT> ) ; break ; case UNSPEC : x = XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ; break ; case PLUS : if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) != CONST_INT ) return <NUM_LIT> ;


<s> const char * name ; while ( <NUM_LIT> ) { switch ( GET_CODE ( x ) ) { case MEM : case CONST : x = XEXP ( x , <NUM_LIT> ) ; break ; case UNSPEC : x = XVECEXP ( x , <NUM_LIT> , <NUM_LIT> ) ; break ; case PLUS : if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) != CONST_INT ) return <NUM_LIT> ; x = XEXP ( x , <NUM_LIT> ) ; break ; default : goto done ; } } done :

if ( GET_CODE ( x ) != SYMBOL_REF ) return <NUM_LIT> ;


<s> if ( decl && TREE_CODE ( decl ) == FUNCTION_DECL && lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( TREE_TYPE ( decl ) ) ) ) flags |= SECTION_MEP_VLIW ; return flags ;


<s> default : break ; } if ( TREE_CODE ( decl ) == FUNCTION_DECL ) { const char * name = XSTR ( XEXP ( DECL_RTL ( decl ) , <NUM_LIT> ) , <NUM_LIT> ) ; if ( name [ <NUM_LIT> ] == '@' && name [ <NUM_LIT> ] == '.' ) encoding = name [ <NUM_LIT> ] ; else encoding = <NUM_LIT> ; if ( flag_function_sections || DECL_COMDAT_GROUP ( decl ) ) mep_unique_section ( decl , <NUM_LIT> ) ; else if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( TREE_TYPE ( decl ) ) ) ) { if ( encoding == 'f' ) return vftext_section ; else return vtext_section ; } else if ( encoding == 'f' ) return ftext_section ; else return text_section ; } if ( TREE_CODE ( decl ) == VAR_DECL ) { const char * name = XSTR ( XEXP ( DECL_RTL ( decl ) , <NUM_LIT> ) , <NUM_LIT> ) ; if ( name [ <NUM_LIT> ] == '@' && name [ <NUM_LIT> ] == '.' ) switch ( name [ <NUM_LIT> ] ) { case 'b' : return based_section ; case 't' :

if ( readonly ) return srodata_section ;


<s> if ( ! TREE_CONSTANT ( decl ) ) readonly = <NUM_LIT> ; break ; default : break ; } if ( TREE_CODE ( decl ) == FUNCTION_DECL ) { const char * name = XSTR ( XEXP ( DECL_RTL ( decl ) , <NUM_LIT> ) , <NUM_LIT> ) ; if ( name [ <NUM_LIT> ] == '@' && name [ <NUM_LIT> ] == '.' ) encoding = name [ <NUM_LIT> ] ; else encoding = <NUM_LIT> ; if ( flag_function_sections || DECL_COMDAT_GROUP ( decl ) ) mep_unique_section ( decl , <NUM_LIT> ) ; else if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( TREE_TYPE ( decl ) ) ) ) { if ( encoding == 'f' ) return vftext_section ; else return vtext_section ; } else if ( encoding == 'f' ) return ftext_section ; else return text_section ; } if ( TREE_CODE ( decl ) == VAR_DECL ) { const char * name = XSTR ( XEXP ( DECL_RTL ( decl ) , <NUM_LIT> ) , <NUM_LIT> ) ; if ( name [ <NUM_LIT> ] == '@' && name [ <NUM_LIT> ] == '.' ) switch ( name [ <NUM_LIT> ] ) { case 'b' : return based_section ; case 't' : if ( readonly ) return srodata_section ; if ( DECL_INITIAL ( decl ) ) return sdata_section ; return tinybss_section ; case 'f' : if ( readonly ) return frodata_section ; return far_section ; case 'i' : case 'I' :

error_at ( DECL_SOURCE_LOCATION ( decl ) , <STR_LIT> , decl ) ;


<s> static void mep_setup_incoming_varargs ( cumulative_args_t cum , machine_mode mode ATTRIBUTE_UNUSED , tree type ATTRIBUTE_UNUSED , int * pretend_size , int second_time ATTRIBUTE_UNUSED ) { int nsave = <NUM_LIT> - ( get_cumulative_args ( cum ) -> nregs + <NUM_LIT> ) ; if ( nsave > <NUM_LIT> ) cfun -> machine -> arg_regs_to_save = nsave ;


<s> int i ; if ( mep_leaf_registers [ <NUM_LIT> ] != enable ) for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) mep_leaf_registers [ i ] = enable ;


<s> if ( symbolic ) { if ( move_needs_splitting ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , SImode ) ) return true ; return false ; } if ( GET_CODE ( operands [ <NUM_LIT> ] ) != CONST_INT ) return false ; if ( constraint_satisfied_p ( operands [ <NUM_LIT> ] , CONSTRAINT_I ) || constraint_satisfied_p ( operands [ <NUM_LIT> ] , CONSTRAINT_J ) || constraint_satisfied_p ( operands [ <NUM_LIT> ] , CONSTRAINT_O ) ) return false ;

if ( ( ( ! reload_completed && ! reload_in_progress ) || ( REG_P ( operands [ <NUM_LIT> ] ) && REGNO ( operands [ <NUM_LIT> ] ) < <NUM_LIT> ) ) && constraint_satisfied_p ( operands [ <NUM_LIT> ] , CONSTRAINT_K ) ) return false ;


<s> operands [ i + <NUM_LIT> ] = lo ; operands [ i + <NUM_LIT> ] = hi ; } if ( reg_mentioned_p ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) || GET_CODE ( operands [ <NUM_LIT> ] ) == ZERO_EXTRACT || GET_CODE ( operands [ <NUM_LIT> ] ) == ZERO_EXTRACT ) { rtx tmp ; tmp = operands [ <NUM_LIT> ] ; operands [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; operands [ <NUM_LIT> ] = tmp ; tmp = operands [ <NUM_LIT> ] ; operands [ <NUM_LIT> ] = operands [ <NUM_LIT> ] ; operands [ <NUM_LIT> ] = tmp ; } fprintf ( stderr , <STR_LIT> ) ; debug_rtx ( operands [ <NUM_LIT> ] ) ; debug_rtx ( operands [ <NUM_LIT> ] ) ; debug_rtx ( operands [ <NUM_LIT> ] ) ; debug_rtx ( operands [ <NUM_LIT> ] ) ;


<s> else reg_names [ FP_REGNO ] = <STR_LIT> ; if ( sp_offset == <NUM_LIT> ) return ; if ( debug_info_level == DINFO_LEVEL_NONE ) { fprintf ( file , <STR_LIT> , sp_offset ) ; if ( reg_save_size ) fprintf ( file , <STR_LIT> , reg_save_size ) ; if ( local ) fprintf ( file , <STR_LIT> , local ) ; if ( crtl -> outgoing_args_size ) fprintf ( file , <STR_LIT> , crtl -> outgoing_args_size ) ; fprintf ( file , <STR_LIT> ) ; return ; } fprintf ( file , <STR_LIT> ) ; fprintf ( file , <STR_LIT> ) ; if ( sp_offset || ! frame_pointer_needed ) fprintf ( file , <STR_LIT> ) ; for ( si = <NUM_LIT> ; si < FIRST_PSEUDO_REGISTER ; si ++ ) slot_map [ si ] = si ; for ( si = <NUM_LIT> ; si < FIRST_PSEUDO_REGISTER - <NUM_LIT> ; si ++ ) for ( sj = si + <NUM_LIT> ; sj < FIRST_PSEUDO_REGISTER ; sj ++ ) if ( cfun -> machine -> reg_save_slot [ slot_map [ si ] ] > cfun -> machine -> reg_save_slot [ slot_map [ sj ] ] ) { int t = slot_map [ si ] ; slot_map [ si ] = slot_map [ sj ] ; slot_map [ sj ] = t ; } sp = <NUM_LIT> ; for ( i = <NUM_LIT> ; i < FIRST_PSEUDO_REGISTER ; i ++ ) { int rsize ; int r = slot_map [ i ] ;

int rss = cfun -> machine -> reg_save_slot [ r ] ;


<s> rtx src ; int i ; src = SET_SRC ( pat ) ; for ( i = <NUM_LIT> ; i < XVECLEN ( src , <NUM_LIT> ) ; i ++ ) if ( mep_store_find_set ( XVECEXP ( src , <NUM_LIT> , i ) , prev ) ) return false ;


<s> bool mep_store_data_bypass_p ( rtx_insn * prev , rtx_insn * insn ) { return INSN_P ( insn ) ? mep_store_data_bypass_1 ( prev , PATTERN ( insn ) ) : false ;


<s> FOR_EACH_SUBRTX ( iter , array , x , NONCONST ) if ( REG_P ( x ) && reg_set_p ( x , prev ) ) return true ; return false ;


<s> FOR_EACH_SUBRTX ( iter , array , x , NONCONST ) if ( REG_P ( x ) && reg_set_p ( x , prev ) ) return true ;


<s> while ( <NUM_LIT> ) { if ( * sym == '*' ) sym ++ ;

else if ( * sym == '@' && sym [ <NUM_LIT> ] == '.' ) sym += <NUM_LIT> ;


return get_hard_reg_initial_val ( Pmode , TP_REGNO ) ;


<s> rtx fnaddr = XEXP ( DECL_RTL ( fndecl ) , <NUM_LIT> ) ; emit_library_call ( gen_rtx_SYMBOL_REF ( Pmode , <STR_LIT> ) , LCT_NORMAL , VOIDmode , <NUM_LIT> , addr , Pmode , fnaddr , Pmode , static_chain , Pmode ) ;


<s> emit_library_call ( gen_rtx_SYMBOL_REF ( Pmode , <STR_LIT> ) , LCT_NORMAL , VOIDmode , <NUM_LIT> , addr , Pmode , fnaddr , Pmode , static_chain , Pmode ) ;


<s> if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( TREE_TYPE ( decl ) ) ) ) sec = <NUM_LIT> ; else sec = <NUM_LIT> ; } else if ( decl_readonly_section ( decl , reloc ) ) sec = <NUM_LIT> ; if ( name [ <NUM_LIT> ] == '@' && name [ <NUM_LIT> ] == '.' ) { switch ( name [ <NUM_LIT> ] ) { case 'b' : sec = <NUM_LIT> ; break ; case 't' : if ( sec == <NUM_LIT> ) sec = <NUM_LIT> ; else sec = <NUM_LIT> ; break ; case 'f' : if ( sec == <NUM_LIT> ) sec = <NUM_LIT> ;

else if ( sec == <NUM_LIT> ) sec = <NUM_LIT> ;


<s> if ( GET_CODE ( set ) != SET ) return false ; if ( GET_CODE ( SET_DEST ( set ) ) == MEM ) { mem = & SET_DEST ( set ) ; reg = & SET_SRC ( set ) ; } else { reg = & SET_DEST ( set ) ; mem = & SET_SRC ( set ) ; if ( GET_CODE ( * mem ) == SIGN_EXTEND ) mem = & XEXP ( * mem , <NUM_LIT> ) ; } if ( GET_CODE ( * reg ) != REG || ! LOADABLE_CR_REGNO_P ( REGNO ( * reg ) ) ) return false ; if ( GET_CODE ( * mem ) != MEM || ! rtx_equal_p ( XEXP ( * mem , <NUM_LIT> ) , gpr ) ) return false ;

mem_bytes = GET_MODE_SIZE ( GET_MODE ( * mem ) ) ;


<s> do { insn = PREV_INSN ( insn ) ; if ( INSN_P ( insn ) ) { if ( mep_use_post_modify_for_set_p ( PATTERN ( insn ) , reg , offset ) ) {


<s> } else if ( args == NULL_TREE && TREE_CODE ( * node ) == VAR_DECL ) { if ( ! ( TREE_PUBLIC ( * node ) || TREE_STATIC ( * node ) ) ) { warning ( <NUM_LIT> , <STR_LIT> ) ; * no_add = true ;


<s> warning ( <NUM_LIT> , <STR_LIT> , name ) ; * no_add = true ; } else if ( args == NULL_TREE && TREE_CODE ( * node ) == VAR_DECL ) { if ( ! ( TREE_PUBLIC ( * node ) || TREE_STATIC ( * node ) ) ) { warning ( <NUM_LIT> , <STR_LIT> ) ; * no_add = true ; } if ( TREE_TYPE ( * node ) && TREE_CODE ( TREE_TYPE ( * node ) ) == POINTER_TYPE ) { warning ( <NUM_LIT> , <STR_LIT> ) ; * no_add = true ; } }


<s> if ( TREE_TYPE ( function_type ) != void_type_node ) error ( <STR_LIT> ) ; if ( prototype_p ( function_type ) && ( TREE_VALUE ( TYPE_ARG_TYPES ( function_type ) ) != void_type_node || TREE_CHAIN ( TYPE_ARG_TYPES ( function_type ) ) != NULL_TREE ) ) error ( <STR_LIT> ) ;


<s> static tree mep_validate_interrupt ( tree * node , tree name , tree args ATTRIBUTE_UNUSED , int flags ATTRIBUTE_UNUSED , bool * no_add ) { tree function_type ; if ( TREE_CODE ( * node ) != FUNCTION_DECL ) { warning ( <NUM_LIT> , <STR_LIT> , name ) ; * no_add = true ; return NULL_TREE ; } if ( DECL_DECLARED_INLINE_P ( * node ) ) error ( <STR_LIT> , DECL_NAME ( * node ) ) ; DECL_UNINLINABLE ( * node ) = <NUM_LIT> ; function_type = TREE_TYPE ( * node ) ; if ( TREE_TYPE ( function_type ) != void_type_node ) error ( <STR_LIT> ) ; if ( prototype_p ( function_type ) && ( TREE_VALUE ( TYPE_ARG_TYPES ( function_type ) ) != void_type_node || TREE_CHAIN ( TYPE_ARG_TYPES ( function_type ) ) != NULL_TREE ) ) error ( <STR_LIT> ) ;


<s> * no_add = true ; } if ( args != NULL_TREE ) { if ( TREE_CODE ( TREE_VALUE ( args ) ) == NON_LVALUE_EXPR ) TREE_VALUE ( args ) = TREE_OPERAND ( TREE_VALUE ( args ) , <NUM_LIT> ) ; if ( TREE_CODE ( TREE_VALUE ( args ) ) != INTEGER_CST ) { warning ( <NUM_LIT> , <STR_LIT> , name ) ; * no_add = true ; }


<s> static tree mep_validate_io_cb ( tree * node , tree name , tree args , int flags ATTRIBUTE_UNUSED , bool * no_add ) { if ( TREE_CODE ( * node ) != VAR_DECL ) {

warning ( <NUM_LIT> , <STR_LIT> , name ) ;


<s> if ( given_type ) warning ( <NUM_LIT> , <STR_LIT> , name , given_type ) ; else warning ( <NUM_LIT> , <STR_LIT> , name ) ; * no_add = true ; if ( TREE_CODE ( * node ) == POINTER_TYPE && ! gave_pointer_note ) { inform ( input_location , <STR_LIT> , <STR_LIT> ) ; gave_pointer_note = <NUM_LIT> ; }

if ( TREE_CODE ( * node ) == ARRAY_TYPE && ! gave_array_note ) {


<s> static bool mep_vector_mode_supported_p ( machine_mode mode ATTRIBUTE_UNUSED ) {


<s> bool mep_vliw_function_p ( tree decl ) { return lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( TREE_TYPE ( decl ) ) ) != <NUM_LIT> ;


<s> if ( mep_section_tag ( DECL_RTL ( cfun -> decl ) ) == 'f' ) return false ;


<s> if ( mep_section_tag ( DECL_RTL ( cfun -> decl ) ) == 'f' ) return false ; return src_vliw == tgt_vliw ;


<s> bool src_vliw = mep_vliw_function_p ( cfun -> decl ) ; bool tgt_vliw = INTVAL ( tgt ) ;


<s> int s = mep_section_tag ( src ) ; while ( <NUM_LIT> ) { if ( GET_CODE ( src ) == CONST || GET_CODE ( src ) == MEM ) src = XEXP ( src , <NUM_LIT> ) ; else if ( GET_CODE ( src ) == SYMBOL_REF || GET_CODE ( src ) == LABEL_REF || GET_CODE ( src ) == PLUS ) break ; else return false ; } if ( s == 'f' || ( GET_CODE ( src ) == PLUS && GET_CODE ( XEXP ( src , <NUM_LIT> ) ) == CONST_INT && ( INTVAL ( XEXP ( src , <NUM_LIT> ) ) < - <NUM_LIT> || INTVAL ( XEXP ( src , <NUM_LIT> ) ) > <NUM_LIT> ) ) || ( GET_CODE ( dest ) == REG && REGNO ( dest ) > <NUM_LIT> && REGNO ( dest ) < FIRST_PSEUDO_REGISTER ) ) return true ;


<s> if ( GET_CODE ( src ) == CONST || GET_CODE ( src ) == MEM ) src = XEXP ( src , <NUM_LIT> ) ; else if ( GET_CODE ( src ) == SYMBOL_REF || GET_CODE ( src ) == LABEL_REF || GET_CODE ( src ) == PLUS ) break ;


<s> if ( ( e . flag & FUNC_DISINTERRUPT ) && ! ( e . used & FUNC_DISINTERRUPT ) ) warning ( <NUM_LIT> , <STR_LIT> , s ) ;


<s> if ( GET_CODE ( x ) != MEM ) return false ; c = GET_CODE ( XEXP ( x , <NUM_LIT> ) ) ; return ( c == CONST_INT || c == CONST || c == SYMBOL_REF ) ;


<s> return ( c == CONST_INT || c == CONST || c == SYMBOL_REF ) ;


<s> switch ( i & <NUM_LIT> ) { case <NUM_LIT> : case <NUM_LIT> : return <NUM_LIT> ; case <NUM_LIT> : case <NUM_LIT> : return <NUM_LIT> ; case <NUM_LIT> : case <NUM_LIT> : return <NUM_LIT> ;