<s> int ar0_mem_operand ( rtx op , enum machine_mode mode ) {

return c4x_arn_mem_operand ( op , mode , AR0_REGNO ) ;


<s> return c4x_arn_reg_operand ( op , mode , AR0_REGNO ) ;


<s> return c4x_arn_mem_operand ( op , mode , AR1_REGNO ) ;


<s> int ar2_reg_operand ( rtx op , enum machine_mode mode ) {

return c4x_arn_reg_operand ( op , mode , AR2_REGNO ) ;


<s> int ar4_mem_operand ( rtx op , enum machine_mode mode ) {

return c4x_arn_mem_operand ( op , mode , AR4_REGNO ) ;


<s> return c4x_arn_reg_operand ( op , mode , AR4_REGNO ) ;


<s> return c4x_arn_mem_operand ( op , mode , AR5_REGNO ) ;


<s> int ar5_mem_operand ( rtx op , enum machine_mode mode ) {

return c4x_arn_mem_operand ( op , mode , AR5_REGNO ) ;


<s> int ar6_mem_operand ( rtx op , enum machine_mode mode ) { return c4x_arn_mem_operand ( op , mode , AR6_REGNO ) ;


<s> int ar6_mem_operand ( rtx op , enum machine_mode mode ) {

return c4x_arn_mem_operand ( op , mode , AR6_REGNO ) ;


<s> int ar6_reg_operand ( rtx op , enum machine_mode mode ) { return c4x_arn_reg_operand ( op , mode , AR6_REGNO ) ;


<s> int ar6_reg_operand ( rtx op , enum machine_mode mode ) {

return c4x_arn_reg_operand ( op , mode , AR6_REGNO ) ;


<s> int ar7_mem_operand ( rtx op , enum machine_mode mode ) { return c4x_arn_mem_operand ( op , mode , AR7_REGNO ) ;


<s> return c4x_arn_mem_operand ( op , mode , AR7_REGNO ) ;


<s> int ar7_reg_operand ( rtx op , enum machine_mode mode ) {

return c4x_arn_reg_operand ( op , mode , AR7_REGNO ) ;


<s> int ar7_reg_operand ( rtx op , enum machine_mode mode ) { return c4x_arn_reg_operand ( op , mode , AR7_REGNO ) ;


<s> int arx_reg_operand ( rtx op , enum machine_mode mode ) { if ( mode != VOIDmode && mode != GET_MODE ( op ) ) return <NUM_LIT> ; if ( GET_CODE ( op ) == SUBREG ) op = SUBREG_REG ( op ) ; return REG_P ( op ) && ( ! reload_completed || IS_ADDR_REG ( op ) ) ;


<s> int arx_reg_operand ( rtx op , enum machine_mode mode ) {

if ( mode != VOIDmode && mode != GET_MODE ( op ) ) return <NUM_LIT> ;


<s> int incdec1 ; int index0 ; int index1 ; int disp0 ; int disp1 ; if ( MEM_VOLATILE_P ( op0 ) && MEM_VOLATILE_P ( op1 ) ) return <NUM_LIT> ; c4x_S_address_parse ( op0 , & base0 , & incdec0 , & index0 , & disp0 ) ; c4x_S_address_parse ( op1 , & base1 , & incdec1 , & index1 , & disp1 ) ; if ( store0 && store1 ) {


<s> int base0 ; int base1 ; int incdec0 ; int incdec1 ; int index0 ; int index1 ; int disp0 ; int disp1 ; if ( MEM_VOLATILE_P ( op0 ) && MEM_VOLATILE_P ( op1 ) ) return <NUM_LIT> ; c4x_S_address_parse ( op0 , & base0 , & incdec0 , & index0 , & disp0 ) ;


<s> rtx op1 = XEXP ( addr , <NUM_LIT> ) ; if ( GET_CODE ( op1 ) == LABEL_REF || GET_CODE ( op1 ) == SYMBOL_REF ) return TARGET_SMALL ? <NUM_LIT> : <NUM_LIT> ; if ( GET_CODE ( op1 ) == CONST ) { rtx offset = const0_rtx ; op1 = eliminate_constant_term ( op1 , & offset ) ; if ( GET_CODE ( op1 ) == LABEL_REF ) return <NUM_LIT> ; if ( GET_CODE ( op1 ) != SYMBOL_REF ) return <NUM_LIT> ; if ( INTVAL ( offset ) == <NUM_LIT> ) return <NUM_LIT> ; return <NUM_LIT> ; } fatal_insn ( <STR_LIT> , addr ) ; } break ; case PLUS : { register rtx op0 = XEXP ( addr , <NUM_LIT> ) ; register rtx op1 = XEXP ( addr , <NUM_LIT> ) ; if ( GET_CODE ( op0 ) != REG ) break ; switch ( GET_CODE ( op1 ) ) { default : break ; case REG : return <NUM_LIT> ; case CONST_INT : if ( TARGET_DEVEL && IS_UINT5_CONST ( INTVAL ( op1 ) ) ) return <NUM_LIT> ; if ( IS_DISP1_CONST ( INTVAL ( op1 ) ) ) return <NUM_LIT> ;

if ( ! TARGET_C3X && IS_UINT5_CONST ( INTVAL ( op1 ) ) ) return <NUM_LIT> ;


<s> return <NUM_LIT> ; case SYMBOL_REF : case LABEL_REF : case CONST : return <NUM_LIT> ; case LO_SUM : { rtx op1 = XEXP ( addr , <NUM_LIT> ) ; if ( GET_CODE ( op1 ) == LABEL_REF || GET_CODE ( op1 ) == SYMBOL_REF ) return TARGET_SMALL ? <NUM_LIT> : <NUM_LIT> ; if ( GET_CODE ( op1 ) == CONST ) { rtx offset = const0_rtx ; op1 = eliminate_constant_term ( op1 , & offset ) ; if ( GET_CODE ( op1 ) == LABEL_REF ) return <NUM_LIT> ; if ( GET_CODE ( op1 ) != SYMBOL_REF ) return <NUM_LIT> ; if ( INTVAL ( offset ) == <NUM_LIT> ) return <NUM_LIT> ; return <NUM_LIT> ; } fatal_insn ( <STR_LIT> , addr ) ; } break ; case PLUS : { register rtx op0 = XEXP ( addr , <NUM_LIT> ) ; register rtx op1 = XEXP ( addr , <NUM_LIT> ) ; if ( GET_CODE ( op0 ) != REG ) break ; switch ( GET_CODE ( op1 ) ) { default :


<s> if ( get_attr_setlda_ar5 ( dep_insn ) && get_attr_usear5 ( insn ) ) max = SETLDA_USE_COST > max ? SETLDA_USE_COST : max ; if ( get_attr_readar5 ( dep_insn ) && get_attr_usear5 ( insn ) ) max = READ_USE_COST > max ? READ_USE_COST : max ; if ( get_attr_setar6 ( dep_insn ) && get_attr_usear6 ( insn ) ) max = SET_USE_COST > max ? SET_USE_COST : max ; if ( get_attr_setlda_ar6 ( dep_insn ) && get_attr_usear6 ( insn ) ) max = SETLDA_USE_COST > max ? SETLDA_USE_COST : max ; if ( get_attr_readar6 ( dep_insn ) && get_attr_usear6 ( insn ) ) max = READ_USE_COST > max ? READ_USE_COST : max ; if ( get_attr_setar7 ( dep_insn ) && get_attr_usear7 ( insn ) ) max = SET_USE_COST > max ? SET_USE_COST : max ; if ( get_attr_setlda_ar7 ( dep_insn ) && get_attr_usear7 ( insn ) ) max = SETLDA_USE_COST > max ? SETLDA_USE_COST : max ; if ( get_attr_readar7 ( dep_insn ) && get_attr_usear7 ( insn ) ) max = READ_USE_COST > max ? READ_USE_COST : max ; if ( get_attr_setir0 ( dep_insn ) && get_attr_useir0 ( insn ) ) max = SET_USE_COST > max ? SET_USE_COST : max ; if ( get_attr_setlda_ir0 ( dep_insn ) && get_attr_useir0 ( insn ) ) max = SETLDA_USE_COST > max ? SETLDA_USE_COST : max ; if ( get_attr_setir1 ( dep_insn ) && get_attr_useir1 ( insn ) ) max = SET_USE_COST > max ? SET_USE_COST : max ; if ( get_attr_setlda_ir1 ( dep_insn ) && get_attr_useir1 ( insn ) ) max = SETLDA_USE_COST > max ? SETLDA_USE_COST : max ; } if ( max ) cost = max ; return cost ; } else if ( REG_NOTE_KIND ( link ) == REG_DEP_ANTI ) {


<s> if ( get_attr_setar5 ( dep_insn ) && get_attr_usear5 ( insn ) ) max = SET_USE_COST > max ? SET_USE_COST : max ; if ( get_attr_setlda_ar5 ( dep_insn ) && get_attr_usear5 ( insn ) ) max = SETLDA_USE_COST > max ? SETLDA_USE_COST : max ; if ( get_attr_readar5 ( dep_insn ) && get_attr_usear5 ( insn ) ) max = READ_USE_COST > max ? READ_USE_COST : max ; if ( get_attr_setar6 ( dep_insn ) && get_attr_usear6 ( insn ) ) max = SET_USE_COST > max ? SET_USE_COST : max ; if ( get_attr_setlda_ar6 ( dep_insn ) && get_attr_usear6 ( insn ) ) max = SETLDA_USE_COST > max ? SETLDA_USE_COST : max ; if ( get_attr_readar6 ( dep_insn ) && get_attr_usear6 ( insn ) ) max = READ_USE_COST > max ? READ_USE_COST : max ; if ( get_attr_setar7 ( dep_insn ) && get_attr_usear7 ( insn ) ) max = SET_USE_COST > max ? SET_USE_COST : max ; if ( get_attr_setlda_ar7 ( dep_insn ) && get_attr_usear7 ( insn ) ) max = SETLDA_USE_COST > max ? SETLDA_USE_COST : max ; if ( get_attr_readar7 ( dep_insn ) && get_attr_usear7 ( insn ) ) max = READ_USE_COST > max ? READ_USE_COST : max ; if ( get_attr_setir0 ( dep_insn ) && get_attr_useir0 ( insn ) ) max = SET_USE_COST > max ? SET_USE_COST : max ; if ( get_attr_setlda_ir0 ( dep_insn ) && get_attr_useir0 ( insn ) ) max = SETLDA_USE_COST > max ? SETLDA_USE_COST : max ; if ( get_attr_setir1 ( dep_insn ) && get_attr_useir1 ( insn ) ) max = SET_USE_COST > max ? SET_USE_COST : max ; if ( get_attr_setlda_ir1 ( dep_insn ) && get_attr_useir1 ( insn ) ) max = SETLDA_USE_COST > max ? SETLDA_USE_COST : max ; } if ( max ) cost = max ; return cost ; } else if ( REG_NOTE_KIND ( link ) == REG_DEP_ANTI ) { return <NUM_LIT> ; }

else if ( REG_NOTE_KIND ( link ) == REG_DEP_OUTPUT ) {


<s> case POST_MODIFY : if ( REG_P ( XEXP ( op , <NUM_LIT> ) ) && ( ! reload_completed || ( REGNO ( XEXP ( op , <NUM_LIT> ) ) == regno ) ) ) return <NUM_LIT> ; if ( REG_P ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) && ( ! reload_completed || ( REGNO ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) == regno ) ) ) return <NUM_LIT> ; break ; case PLUS : { rtx op0 = XEXP ( op , <NUM_LIT> ) ; rtx op1 = XEXP ( op , <NUM_LIT> ) ; if ( ( REG_P ( op0 ) && ( ! reload_completed || ( REGNO ( op0 ) == regno ) ) ) || ( REG_P ( op1 ) && ( ! reload_completed || ( REGNO ( op1 ) == regno ) ) ) ) return <NUM_LIT> ; } break ; default : break ; }


<s> if ( REG_P ( XEXP ( op , <NUM_LIT> ) ) && ( ! reload_completed || ( REGNO ( XEXP ( op , <NUM_LIT> ) ) == regno ) ) ) return <NUM_LIT> ; if ( REG_P ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) && ( ! reload_completed || ( REGNO ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) == regno ) ) ) return <NUM_LIT> ; break ; case PLUS : { rtx op0 = XEXP ( op , <NUM_LIT> ) ; rtx op1 = XEXP ( op , <NUM_LIT> ) ; if ( ( REG_P ( op0 ) && ( ! reload_completed || ( REGNO ( op0 ) == regno ) ) ) || ( REG_P ( op1 ) && ( ! reload_completed || ( REGNO ( op1 ) == regno ) ) ) ) return <NUM_LIT> ; }


<s> if ( GET_CODE ( op ) == SUBREG ) op = SUBREG_REG ( op ) ;

return REG_P ( op ) && ( ! reload_completed || ( REGNO ( op ) == regno ) ) ;


<s> static void c4x_asm_named_section ( const char * name , unsigned int flags ATTRIBUTE_UNUSED , tree decl ATTRIBUTE_UNUSED ) {

fprintf ( asm_out_file , <STR_LIT> , name ) ;


<s> if ( code == PRE_INC || code == PRE_DEC || code == POST_INC || code == POST_DEC || code == PRE_MODIFY || code == POST_MODIFY ) return <NUM_LIT> ; } return <NUM_LIT> ;


<s> if ( code == PRE_INC || code == PRE_DEC || code == POST_INC || code == POST_DEC || code == PRE_MODIFY || code == POST_MODIFY ) return <NUM_LIT> ;


<s> return REG_P ( op ) && IS_ADDR_OR_PSEUDO_REG ( op ) ;


<s> while ( list != NULL_TREE && IDENTIFIER_POINTER ( TREE_PURPOSE ( list ) ) != IDENTIFIER_POINTER ( DECL_NAME ( decl ) ) ) list = TREE_CHAIN ( list ) ; if ( list ) * attributes = tree_cons ( get_identifier ( attrib ) , TREE_VALUE ( list ) , * attributes ) ;


<s> static void c4x_check_attribute ( const char * attrib , tree list , tree decl , tree * attributes ) { while ( list != NULL_TREE && IDENTIFIER_POINTER ( TREE_PURPOSE ( list ) ) != IDENTIFIER_POINTER ( DECL_NAME ( decl ) ) ) list = TREE_CHAIN ( list ) ;

if ( list ) * attributes = tree_cons ( get_identifier ( attrib ) , TREE_VALUE ( list ) , * attributes ) ;


<s> if ( insn == <NUM_LIT> ) return <NUM_LIT> ; if ( GET_CODE ( insn ) == CODE_LABEL ) return <NUM_LIT> ; if ( c4x_r11_set_p ( insn ) ) return <NUM_LIT> ;


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


<s> void c4x_emit_libcall3 ( rtx libcall , enum rtx_code code , enum machine_mode mode , rtx * operands ) {

c4x_emit_libcall ( libcall , code , mode , mode , <NUM_LIT> , operands ) ;


<s> c4x_emit_libcall ( libcall , code , mode , mode , <NUM_LIT> , operands ) ;


<s> ret = emit_library_call_value ( libcall , NULL_RTX , <NUM_LIT> , mode , <NUM_LIT> , operands [ <NUM_LIT> ] , mode , operands [ <NUM_LIT> ] , mode ) ; equiv = gen_rtx_TRUNCATE ( mode , gen_rtx_LSHIFTRT ( HImode , gen_rtx_MULT ( HImode , gen_rtx_fmt_e ( code , HImode , operands [ <NUM_LIT> ] ) , gen_rtx_fmt_e ( code , HImode , operands [ <NUM_LIT> ] ) ) , GEN_INT ( <NUM_LIT> ) ) ) ; insns = get_insns ( ) ; end_sequence ( ) ;

emit_libcall_block ( insns , operands [ <NUM_LIT> ] , ret , equiv ) ;


<s> if ( TARGET_EXPOSE_LDP && ! ( reload_in_progress || reload_completed ) && GET_CODE ( op1 ) == MEM && symbolic_address_operand ( XEXP ( op1 , <NUM_LIT> ) , Pmode ) ) { rtx dp_reg = gen_rtx_REG ( Pmode , DP_REGNO ) ; if ( ! TARGET_SMALL ) emit_insn ( gen_set_ldp ( dp_reg , XEXP ( op1 , <NUM_LIT> ) ) ) ; op1 = change_address ( op1 , mode , gen_rtx_LO_SUM ( Pmode , dp_reg , XEXP ( op1 , <NUM_LIT> ) ) ) ; } if ( TARGET_EXPOSE_LDP && ! ( reload_in_progress || reload_completed ) && GET_CODE ( op0 ) == MEM && symbolic_address_operand ( XEXP ( op0 , <NUM_LIT> ) , Pmode ) ) { rtx dp_reg = gen_rtx_REG ( Pmode , DP_REGNO ) ; if ( ! TARGET_SMALL ) emit_insn ( gen_set_ldp ( dp_reg , XEXP ( op0 , <NUM_LIT> ) ) ) ; op0 = change_address ( op0 , mode , gen_rtx_LO_SUM ( Pmode , dp_reg , XEXP ( op0 , <NUM_LIT> ) ) ) ; } if ( GET_CODE ( op0 ) == SUBREG && mixed_subreg_operand ( op0 , mode ) ) { if ( reload_in_progress || reload_completed ) abort ( ) ; if ( GET_MODE ( SUBREG_REG ( op0 ) ) == QImode ) op0 = SUBREG_REG ( op0 ) ; else if ( GET_MODE ( SUBREG_REG ( op0 ) ) == HImode ) { op0 = copy_rtx ( op0 ) ; PUT_MODE ( op0 , QImode ) ; } else abort ( ) ; if ( mode == QFmode ) emit_insn ( gen_storeqf_int_clobber ( op0 , op1 ) ) ; else abort ( ) ; return <NUM_LIT> ; } if ( GET_CODE ( op1 ) == SUBREG && mixed_subreg_operand ( op1 , mode ) ) { if ( reload_in_progress || reload_completed ) abort ( ) ; if ( GET_MODE ( SUBREG_REG ( op1 ) ) == QImode ) op1 = SUBREG_REG ( op1 ) ; else if ( GET_MODE ( SUBREG_REG ( op1 ) ) == HImode ) { op1 = copy_rtx ( op1 ) ; PUT_MODE ( op1 , QImode ) ; } else abort ( ) ; if ( mode == QFmode ) emit_insn ( gen_loadqf_int_clobber ( op0 , op1 ) ) ; else abort ( ) ; return <NUM_LIT> ; } if ( mode == QImode && reg_operand ( op0 , mode ) && const_int_operand ( op1 , mode ) && ! IS_INT16_CONST ( INTVAL ( op1 ) ) && ! IS_HIGH_CONST ( INTVAL ( op1 ) ) ) { emit_insn ( gen_loadqi_big_constant ( op0 , op1 ) ) ; return <NUM_LIT> ; } if ( mode == HImode && reg_operand ( op0 , mode ) && const_int_operand ( op1 , mode ) ) { emit_insn ( gen_loadhi_big_constant ( op0 , op1 ) ) ; return <NUM_LIT> ;


<s> rtx op1 = operands [ <NUM_LIT> ] ; if ( ! reload_in_progress && ! REG_P ( op0 ) && ! REG_P ( op1 ) && ! ( stik_const_operand ( op1 , mode ) && ! push_operand ( op0 , mode ) ) ) op1 = force_reg ( mode , op1 ) ; if ( GET_CODE ( op1 ) == LO_SUM && GET_MODE ( op1 ) == Pmode && dp_reg_operand ( XEXP ( op1 , <NUM_LIT> ) , mode ) ) { op1 = XEXP ( op1 , <NUM_LIT> ) ; } if ( symbolic_address_operand ( op1 , mode ) ) { if ( TARGET_LOAD_ADDRESS ) { emit_insn ( gen_load_immed_address ( op0 , op1 ) ) ; return <NUM_LIT> ; } else { op1 = force_const_mem ( Pmode , op1 ) ; } } else if ( mode == HFmode && CONSTANT_P ( op1 ) && ! LEGITIMATE_CONSTANT_P ( op1 ) ) { op1 = force_const_mem ( mode , op1 ) ; } if ( TARGET_EXPOSE_LDP && ! ( reload_in_progress || reload_completed ) && GET_CODE ( op1 ) == MEM && symbolic_address_operand ( XEXP ( op1 , <NUM_LIT> ) , Pmode ) ) { rtx dp_reg = gen_rtx_REG ( Pmode , DP_REGNO ) ; if ( ! TARGET_SMALL ) emit_insn ( gen_set_ldp ( dp_reg , XEXP ( op1 , <NUM_LIT> ) ) ) ; op1 = change_address ( op1 , mode , gen_rtx_LO_SUM ( Pmode , dp_reg , XEXP ( op1 , <NUM_LIT> ) ) ) ; }

if ( TARGET_EXPOSE_LDP && ! ( reload_in_progress || reload_completed ) && GET_CODE ( op0 ) == MEM && symbolic_address_operand ( XEXP ( op0 , <NUM_LIT> ) , Pmode ) ) {


<s> if ( ! TARGET_C3X ) break ; arg0 = TREE_VALUE ( arglist ) ; arg1 = TREE_VALUE ( TREE_CHAIN ( arglist ) ) ; r0 = expand_expr ( arg0 , NULL_RTX , QImode , <NUM_LIT> ) ; r1 = expand_expr ( arg1 , NULL_RTX , QImode , <NUM_LIT> ) ; if ( ! target || ! register_operand ( target , QImode ) ) target = gen_reg_rtx ( QImode ) ; emit_insn ( gen_mulqi3_24_clobber ( target , r0 , r1 ) ) ; return target ; case C4X_BUILTIN_TOIEEE : if ( TARGET_C3X ) break ; arg0 = TREE_VALUE ( arglist ) ; r0 = expand_expr ( arg0 , NULL_RTX , QFmode , <NUM_LIT> ) ; if ( ! target || ! register_operand ( target , QFmode ) ) target = gen_reg_rtx ( QFmode ) ; emit_insn ( gen_toieee ( target , r0 ) ) ; return target ; case C4X_BUILTIN_FRIEEE : if ( TARGET_C3X ) break ; arg0 = TREE_VALUE ( arglist ) ; r0 = expand_expr ( arg0 , NULL_RTX , QFmode , <NUM_LIT> ) ; if ( register_operand ( r0 , QFmode ) ) { r1 = assign_stack_local ( QFmode , GET_MODE_SIZE ( QFmode ) , <NUM_LIT> ) ; emit_move_insn ( r1 , r0 ) ; r0 = r1 ; }


<s> insn = emit_jump_insn ( gen_return_from_interrupt_epilogue ( ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } else { if ( frame_pointer_needed ) { if ( ( size != <NUM_LIT> ) || ( current_function_args_size != <NUM_LIT> ) || ( optimize < <NUM_LIT> ) ) { insn = emit_insn ( gen_movqi ( gen_rtx_REG ( QImode , R2_REGNO ) , gen_rtx_MEM ( QImode , gen_rtx_PLUS ( QImode , gen_rtx_REG ( QImode , AR3_REGNO ) , constm1_rtx ) ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; size += <NUM_LIT> ; jump = <NUM_LIT> ; dont_pop_ar3 = <NUM_LIT> ; } else { dont_pop_ar3 = <NUM_LIT> ; } } else { dont_pop_ar3 = <NUM_LIT> ; if ( size || current_function_args_size ) { size += <NUM_LIT> ; } } for ( regno = FIRST_PSEUDO_REGISTER - <NUM_LIT> ; regno >= <NUM_LIT> ; regno -- ) { if ( regs_ever_live [ regno ] && ! call_used_regs [ regno ] ) { if ( regno == AR3_REGNO && dont_pop_ar3 ) continue ; if ( IS_FLOAT_CALL_SAVED_REGNO ( regno ) ) { insn = emit_insn ( gen_popqf_unspec ( gen_rtx_REG ( QFmode , regno ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; if ( TARGET_PRESERVE_FLOAT ) { insn = emit_insn ( gen_popqi_unspec ( gen_rtx_REG ( QImode , regno ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } } else { insn = emit_insn ( gen_popqi ( gen_rtx_REG ( QImode , regno ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } } } if ( frame_pointer_needed ) { if ( ( size != <NUM_LIT> ) || ( current_function_args_size != <NUM_LIT> ) || ( optimize < <NUM_LIT> ) ) { insn = emit_insn ( gen_movqi ( gen_rtx_REG ( QImode , AR3_REGNO ) , gen_rtx_MEM ( QImode , gen_rtx_REG ( QImode , AR3_REGNO ) ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } } if ( size > <NUM_LIT> ) { if ( TARGET_C3X ) { insn = emit_insn ( gen_movqi ( gen_rtx_REG ( QImode , R3_REGNO ) , GEN_INT ( size >> <NUM_LIT> ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; insn = emit_insn ( gen_lshrqi3 ( gen_rtx_REG ( QImode , R3_REGNO ) , gen_rtx_REG ( QImode , R3_REGNO ) , GEN_INT ( - <NUM_LIT> ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } else { insn = emit_insn ( gen_movqi ( gen_rtx_REG ( QImode , R3_REGNO ) , GEN_INT ( size & ~ <NUM_LIT> ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } insn = emit_insn ( gen_iorqi3 ( gen_rtx_REG ( QImode , R3_REGNO ) , gen_rtx_REG ( QImode , R3_REGNO ) , GEN_INT ( size & <NUM_LIT> ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; insn = emit_insn ( gen_subqi3 ( gen_rtx_REG ( QImode , SP_REGNO ) , gen_rtx_REG ( QImode , SP_REGNO ) , gen_rtx_REG ( QImode , R3_REGNO ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } else if ( size != <NUM_LIT> ) {

insn = emit_insn ( gen_subqi3 ( gen_rtx_REG ( QImode , SP_REGNO ) , gen_rtx_REG ( QImode , SP_REGNO ) , GEN_INT ( size ) ) ) ;


<s> RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } } } } if ( regs_ever_live [ RC_REGNO ] || regs_ever_live [ RS_REGNO ] || regs_ever_live [ RE_REGNO ] ) { insn = emit_insn ( gen_andn_st ( GEN_INT ( ~ <NUM_LIT> ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } if ( TARGET_SMALL && TARGET_PARANOID ) { insn = emit_insn ( gen_set_ldp_prologue ( gen_rtx_REG ( QImode , DP_REGNO ) , gen_rtx_SYMBOL_REF ( QImode , <STR_LIT> ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } } else { if ( frame_pointer_needed ) { if ( ( size != <NUM_LIT> ) || ( current_function_args_size != <NUM_LIT> ) || ( optimize < <NUM_LIT> ) ) { insn = emit_insn ( gen_pushqi ( gen_rtx_REG ( QImode , AR3_REGNO ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; insn = emit_insn ( gen_movqi ( gen_rtx_REG ( QImode , AR3_REGNO ) , gen_rtx_REG ( QImode , SP_REGNO ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; dont_push_ar3 = <NUM_LIT> ; } else { dont_push_ar3 = <NUM_LIT> ; } } else { dont_push_ar3 = <NUM_LIT> ; if ( ( size != <NUM_LIT> ) || ( current_function_args_size != <NUM_LIT> ) ) { size += <NUM_LIT> ; } } if ( size > <NUM_LIT> ) { if ( TARGET_C3X ) { insn = emit_insn ( gen_movqi ( gen_rtx_REG ( QImode , R1_REGNO ) , GEN_INT ( size >> <NUM_LIT> ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; insn = emit_insn ( gen_lshrqi3 ( gen_rtx_REG ( QImode , R1_REGNO ) , gen_rtx_REG ( QImode , R1_REGNO ) , GEN_INT ( - <NUM_LIT> ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } else { insn = emit_insn ( gen_movqi ( gen_rtx_REG ( QImode , R1_REGNO ) , GEN_INT ( size & ~ <NUM_LIT> ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } insn = emit_insn ( gen_iorqi3 ( gen_rtx_REG ( QImode , R1_REGNO ) , gen_rtx_REG ( QImode , R1_REGNO ) , GEN_INT ( size & <NUM_LIT> ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; insn = emit_insn ( gen_addqi3 ( gen_rtx_REG ( QImode , SP_REGNO ) , gen_rtx_REG ( QImode , SP_REGNO ) , gen_rtx_REG ( QImode , R1_REGNO ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ;


<s> rtx insn ; int dont_push_ar3 ; if ( c4x_naked_function_p ( ) ) { return ; } if ( c4x_interrupt_function_p ( ) ) { c4x_leaf_function = c4x_leaf_function_p ( ) ; insn = emit_insn ( gen_push_st ( ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; if ( size ) { insn = emit_insn ( gen_pushqi ( gen_rtx_REG ( QImode , AR3_REGNO ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; insn = emit_insn ( gen_movqi ( gen_rtx_REG ( QImode , AR3_REGNO ) , gen_rtx_REG ( QImode , SP_REGNO ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; if ( size > <NUM_LIT> ) error ( <STR_LIT> , current_function_name ( ) , size ) ; insn = emit_insn ( gen_addqi3 ( gen_rtx_REG ( QImode , SP_REGNO ) , gen_rtx_REG ( QImode , SP_REGNO ) , GEN_INT ( size ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } for ( regno = <NUM_LIT> ; regno < FIRST_PSEUDO_REGISTER ; regno ++ ) { if ( c4x_isr_reg_used_p ( regno ) ) { if ( regno == DP_REGNO ) { insn = emit_insn ( gen_push_dp ( ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } else { insn = emit_insn ( gen_pushqi ( gen_rtx_REG ( QImode , regno ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; if ( IS_EXT_REGNO ( regno ) ) { insn = emit_insn ( gen_pushqf ( gen_rtx_REG ( QFmode , regno ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } } } } if ( regs_ever_live [ RC_REGNO ] || regs_ever_live [ RS_REGNO ] || regs_ever_live [ RE_REGNO ] ) { insn = emit_insn ( gen_andn_st ( GEN_INT ( ~ <NUM_LIT> ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } if ( TARGET_SMALL && TARGET_PARANOID ) { insn = emit_insn ( gen_set_ldp_prologue ( gen_rtx_REG ( QImode , DP_REGNO ) , gen_rtx_SYMBOL_REF ( QImode , <STR_LIT> ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } } else { if ( frame_pointer_needed ) { if ( ( size != <NUM_LIT> ) || ( current_function_args_size != <NUM_LIT> ) || ( optimize < <NUM_LIT> ) ) { insn = emit_insn ( gen_pushqi ( gen_rtx_REG ( QImode , AR3_REGNO ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; insn = emit_insn ( gen_movqi ( gen_rtx_REG ( QImode , AR3_REGNO ) , gen_rtx_REG ( QImode , SP_REGNO ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; dont_push_ar3 = <NUM_LIT> ; } else { dont_push_ar3 = <NUM_LIT> ; } } else { dont_push_ar3 = <NUM_LIT> ; if ( ( size != <NUM_LIT> ) || ( current_function_args_size != <NUM_LIT> ) ) { size += <NUM_LIT> ; } }


<s> c4x_external_ref ( XSTR ( fun , <NUM_LIT> ) ) ;


<s> struct name_list * p ; p = extern_head ; while ( p ) { if ( strcmp ( p -> name , name ) == <NUM_LIT> ) return ;


<s> p = extern_head ; while ( p ) { fprintf ( asm_out_file , <STR_LIT> ) ;

assemble_name ( asm_out_file , p -> name ) ;


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


<s> else if ( ! TARGET_MEMPARM && ! type ) { if ( mode == QFmode || mode == HFmode ) reg = c4x_fp_reglist [ cum -> floats ] ; else if ( mode == QImode || mode == Pmode ) reg = c4x_int_reglist [ <NUM_LIT> ] [ cum -> ints ] ; } if ( TARGET_DEBUG ) { fprintf ( stderr , <STR_LIT> , GET_MODE_NAME ( mode ) , named ) ; if ( reg ) fprintf ( stderr , <STR_LIT> , reg_names [ reg ] ) ; else fprintf ( stderr , <STR_LIT> ) ;


<s> if ( mode == QFmode || mode == HFmode ) cum -> floats ++ ; else if ( mode == QImode || mode == Pmode ) cum -> ints ++ ; } else if ( ! TARGET_MEMPARM && ! type ) {


<s> rtx c4x_gen_compare_reg ( enum rtx_code code , rtx x , rtx y ) { enum machine_mode mode = SELECT_CC_MODE ( code , x , y ) ; rtx cc_reg ;

if ( mode == CC_NOOVmode && ( code == LE || code == GE || code == LT || code == GT ) ) return NULL_RTX ;


<s> rtx cc_reg ; if ( mode == CC_NOOVmode && ( code == LE || code == GE || code == LT || code == GT ) ) return NULL_RTX ;

cc_reg = gen_rtx_REG ( mode , ST_REGNO ) ;


<s> bool indirect ; indirect = pass_by_reference ( NULL , TYPE_MODE ( type ) , type , false ) ; if ( indirect ) type = build_pointer_type ( type ) ; t = build ( PREDECREMENT_EXPR , TREE_TYPE ( valist ) , valist , build_int_cst ( NULL_TREE , int_size_in_bytes ( type ) ) ) ; t = fold_convert ( build_pointer_type ( type ) , t ) ; t = build_va_arg_indirect_ref ( t ) ; if ( indirect ) t = build_va_arg_indirect_ref ( t ) ; return t ;


<s> static void c4x_globalize_label ( FILE * stream , const char * name ) {

default_globalize_label ( stream , name ) ;


<s> default_globalize_label ( stream , name ) ;


<s> warning ( OPT_Wattributes , <STR_LIT> , IDENTIFIER_POINTER ( name ) ) ; * no_add_attrs = true ;


<s> static tree c4x_handle_fntype_attribute ( tree * node , tree name , tree args ATTRIBUTE_UNUSED , int flags ATTRIBUTE_UNUSED , bool * no_add_attrs ) { if ( TREE_CODE ( * node ) != FUNCTION_TYPE ) { warning ( OPT_Wattributes , <STR_LIT> , IDENTIFIER_POINTER ( name ) ) ; * no_add_attrs = true ; }


<s> case OPT_m33 : c4x_cpu_version = <NUM_LIT> ; return true ; case OPT_m40 : c4x_cpu_version = <NUM_LIT> ; return true ; case OPT_m44 : c4x_cpu_version = <NUM_LIT> ; return true ; case OPT_mcpu_ : if ( arg [ <NUM_LIT> ] == 'c' || arg [ <NUM_LIT> ] == 'C' ) arg ++ ; value = atoi ( arg ) ; switch ( value ) { case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : c4x_cpu_version = value ; return true ; } return false ;


<s> case OPT_m40 : c4x_cpu_version = <NUM_LIT> ; return true ; case OPT_m44 : c4x_cpu_version = <NUM_LIT> ; return true ; case OPT_mcpu_ : if ( arg [ <NUM_LIT> ] == 'c' || arg [ <NUM_LIT> ] == 'C' ) arg ++ ; value = atoi ( arg ) ; switch ( value ) { case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : case <NUM_LIT> : c4x_cpu_version = value ; return true ; } return false ; default : return true ; }


<s> case CCmode : case CC_NOOVmode : return IS_ST_REGNO ( regno ) ; case HImode : return IS_INT_REGNO ( regno ) && IS_INT_REGNO ( regno + <NUM_LIT> ) && ( regno & <NUM_LIT> ) == <NUM_LIT> ; default : return <NUM_LIT> ; } return <NUM_LIT> ;


<s> switch ( mode ) { case Pmode : case QImode : return IS_INT_REGNO ( regno ) ; case QFmode : case HFmode : return IS_EXT_REGNO ( regno ) ; case CCmode : case CC_NOOVmode :


<s> int c4x_hard_regno_rename_ok ( unsigned int regno1 , unsigned int regno2 ) {

if ( IS_FLOAT_CALL_SAVED_REGNO ( regno1 ) && IS_INT_CALL_SAVED_REGNO ( regno2 ) ) return <NUM_LIT> ;


<s> static int c4x_immed_float_constant ( rtx op ) { if ( GET_CODE ( op ) != CONST_DOUBLE ) return <NUM_LIT> ;

return GET_MODE ( op ) == QFmode || GET_MODE ( op ) == HFmode ;


<s> long convval [ <NUM_LIT> ] ; int exponent ; REAL_VALUE_TYPE r ; REAL_VALUE_FROM_CONST_DOUBLE ( r , op ) ; if ( GET_MODE ( op ) == HFmode ) REAL_VALUE_TO_TARGET_DOUBLE ( r , convval ) ; else { REAL_VALUE_TO_TARGET_SINGLE ( r , convval [ <NUM_LIT> ] ) ; convval [ <NUM_LIT> ] = <NUM_LIT> ;


<s> if ( GET_CODE ( op ) != CONST_INT ) return <NUM_LIT> ;

return GET_MODE ( op ) == VOIDmode || GET_MODE_CLASS ( GET_MODE ( op ) ) == MODE_INT || GET_MODE_CLASS ( GET_MODE ( op ) ) == MODE_PARTIAL_INT ;


<s> fprintf ( stderr , <STR_LIT> ) ; if ( fntype ) { tree ret_type = TREE_TYPE ( fntype ) ; fprintf ( stderr , <STR_LIT> , tree_code_name [ ( int ) TREE_CODE ( fntype ) ] , tree_code_name [ ( int ) TREE_CODE ( ret_type ) ] ) ; } else fprintf ( stderr , <STR_LIT> ) ; if ( libname ) fprintf ( stderr , <STR_LIT> , XSTR ( libname , <NUM_LIT> ) ) ; } cum -> prototype = ( fntype && TYPE_ARG_TYPES ( fntype ) ) ; for ( param = fntype ? TYPE_ARG_TYPES ( fntype ) : <NUM_LIT> ; param ; param = next_param ) { tree type ; next_param = TREE_CHAIN ( param ) ; type = TREE_VALUE ( param ) ; if ( type && type != void_type_node ) { enum machine_mode mode ; if ( ! next_param ) cum -> var = <NUM_LIT> ; if ( ( mode = TYPE_MODE ( type ) ) ) { if ( ! targetm . calls . must_pass_in_stack ( mode , type ) ) { if ( mode == QFmode || mode == HFmode ) cum -> floats ++ ; else if ( mode == QImode || mode == Pmode ) cum -> ints ++ ; } } cum -> args ++ ; }


<s> c4x_check_attribute ( <STR_LIT> , pure_tree , decl , attributes ) ; c4x_check_attribute ( <STR_LIT> , noreturn_tree , decl , attributes ) ; c4x_check_attribute ( <STR_LIT> , interrupt_tree , decl , attributes ) ; c4x_check_attribute ( <STR_LIT> , naked_tree , decl , attributes ) ; break ; case VAR_DECL : c4x_check_attribute ( <STR_LIT> , data_tree , decl , attributes ) ; break ; default : break ; }


<s> if ( c4x_leaf_function ) return regs_ever_live [ regno ] && fixed_regs [ regno ] == <NUM_LIT> ; return IS_EXT_REGNO ( regno ) || ( ( regs_ever_live [ regno ] || call_used_regs [ regno ] ) && fixed_regs [ regno ] == <NUM_LIT> ) ;


<s> int c4x_I_constant ( rtx op ) { return c4x_immed_int_constant ( op ) && IS_INT16_CONST ( INTVAL ( op ) ) ;


return c4x_immed_int_constant ( op ) && IS_INT16_CONST ( INTVAL ( op ) ) ;


<s> return c4x_immed_int_constant ( op ) && IS_INT8_CONST ( INTVAL ( op ) ) ;


<s> if ( TARGET_C3X || ! c4x_immed_int_constant ( op ) ) return <NUM_LIT> ;

return IS_INT5_CONST ( INTVAL ( op ) ) ;


<s> return IS_INT5_CONST ( INTVAL ( op ) ) ;


<s> int c4x_label_conflict ( rtx insn , rtx jump , rtx db ) { while ( insn ) { if ( GET_CODE ( insn ) == CODE_LABEL ) {

if ( CODE_LABEL_NUMBER ( jump ) == CODE_LABEL_NUMBER ( insn ) ) return <NUM_LIT> ;


<s> } else if ( fmt [ i ] == 'E' ) for ( j = XVECLEN ( x , i ) - <NUM_LIT> ; j >= <NUM_LIT> ; j -- ) if ( c4x_label_ref_used_p ( XVECEXP ( x , i , j ) , code_label ) ) return <NUM_LIT> ; } return <NUM_LIT> ;


<s> if ( c4x_label_ref_used_p ( XEXP ( x , i ) , code_label ) ) return <NUM_LIT> ; }

else if ( fmt [ i ] == 'E' ) for ( j = XVECLEN ( x , i ) - <NUM_LIT> ; j >= <NUM_LIT> ; j -- ) if ( c4x_label_ref_used_p ( XVECEXP ( x , i , j ) , code_label ) ) return <NUM_LIT> ;


<s> static int c4x_leaf_function_p ( void ) {

if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( TREE_TYPE ( current_function_decl ) ) ) ) return <NUM_LIT> ;


<s> if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( TREE_TYPE ( current_function_decl ) ) ) ) return <NUM_LIT> ; if ( leaf_function_p ( ) ) return <NUM_LIT> ;


<s> rtx op0 = XEXP ( addr , <NUM_LIT> ) ; rtx op1 = XEXP ( addr , <NUM_LIT> ) ; enum rtx_code code0 = GET_CODE ( op0 ) ; switch ( code0 ) { case REG : if ( REG_P ( op1 ) ) { base = op0 ; indx = op1 ; if ( IS_INDEX_REG ( base ) || IS_ADDR_REG ( indx ) ) { base = op1 ; indx = op0 ; } } else { base = op0 ; disp = op1 ; } break ; default : return <NUM_LIT> ; } } break ; case LO_SUM : { rtx op0 = XEXP ( addr , <NUM_LIT> ) ; rtx op1 = XEXP ( addr , <NUM_LIT> ) ; if ( mode == HImode || mode == HFmode ) return <NUM_LIT> ; if ( ! REG_P ( op0 ) || REGNO ( op0 ) != DP_REGNO ) return <NUM_LIT> ; if ( ( GET_CODE ( op1 ) == SYMBOL_REF || GET_CODE ( op1 ) == LABEL_REF ) ) return <NUM_LIT> ; if ( GET_CODE ( op1 ) == CONST ) return <NUM_LIT> ; return <NUM_LIT> ; } break ; case CONST : case LABEL_REF : case SYMBOL_REF : if ( ! TARGET_EXPOSE_LDP && ! strict && mode != HFmode && mode != HImode ) return <NUM_LIT> ; return <NUM_LIT> ; case CONST_INT : return <NUM_LIT> ; case MEM : return <NUM_LIT> ; case CONST_DOUBLE : fatal_insn ( <STR_LIT> , addr ) ; default : return <NUM_LIT> ; } if ( base ) { if ( indx && ( mode == HImode || mode == HFmode ) ) return <NUM_LIT> ; if ( REGNO ( base ) == DP_REGNO ) return <NUM_LIT> ; if ( strict && ! REGNO_OK_FOR_BASE_P ( REGNO ( base ) ) ) return <NUM_LIT> ; else if ( ! strict && ! IS_ADDR_OR_PSEUDO_REG ( base ) ) return <NUM_LIT> ; } if ( indx ) { if ( GET_CODE ( indx ) != REG ) return <NUM_LIT> ; if ( strict && ! REGNO_OK_FOR_INDEX_P ( REGNO ( indx ) ) ) return <NUM_LIT> ; else if ( ! strict && ! IS_INDEX_OR_PSEUDO_REG ( indx ) ) return <NUM_LIT> ; } if ( disp ) { if ( GET_CODE ( disp ) != CONST_INT ) return <NUM_LIT> ; if ( mode == HImode || mode == HFmode ) { if ( ! IS_DISP8_OFF_CONST ( INTVAL ( disp ) ) ) return <NUM_LIT> ;


<s> rtx addr_reg = gen_reg_rtx ( Pmode ) ; emit_move_insn ( addr_reg , orig ) ; return addr_reg ; } else { rtx dp_reg = gen_rtx_REG ( Pmode , DP_REGNO ) ; if ( ! TARGET_SMALL ) emit_insn ( gen_set_ldp ( dp_reg , orig ) ) ; return gen_rtx_LO_SUM ( Pmode , dp_reg , orig ) ; } } return NULL_RTX ;


<s> return c4x_immed_int_constant ( op ) && IS_UINT16_CONST ( INTVAL ( op ) ) ;


<s> tree type ; type = TREE_TYPE ( current_function_decl ) ; return lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type ) ) != NULL ;


<s> type = TREE_TYPE ( current_function_decl ) ;

return lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type ) ) != NULL ;


<s> int c4x_null_epilogue_p ( void ) { int regno ; if ( reload_completed && ! c4x_naked_function_p ( ) && ! c4x_interrupt_function_p ( ) && ! current_function_calls_alloca && ! current_function_args_size && ! ( optimize < <NUM_LIT> ) && ! get_frame_size ( ) ) { for ( regno = FIRST_PSEUDO_REGISTER - <NUM_LIT> ; regno >= <NUM_LIT> ; regno -- ) if ( regs_ever_live [ regno ] && ! call_used_regs [ regno ] && ( regno != AR3_REGNO ) ) return <NUM_LIT> ; return <NUM_LIT> ; } return <NUM_LIT> ;


return c4x_immed_int_constant ( op ) && IS_NOT_UINT16_CONST ( INTVAL ( op ) ) ;


<s> int c4x_N_constant ( rtx op ) { return c4x_immed_int_constant ( op ) && IS_NOT_UINT16_CONST ( INTVAL ( op ) ) ;


<s> void c4x_optimization_options ( int level ATTRIBUTE_UNUSED , int size ATTRIBUTE_UNUSED ) { flag_schedule_insns = <NUM_LIT> ;


<s> } sbuf [ s ] = <NUM_LIT> ; fprintf ( stream , <STR_LIT> , sbuf ) ; l += s + <NUM_LIT> ; if ( TARGET_TI && l >= <NUM_LIT> && len > <NUM_LIT> ) { fprintf ( stream , <STR_LIT> ) ; first = <NUM_LIT> ; l = <NUM_LIT> ; } s = <NUM_LIT> ; } if ( onlys ) continue ; if ( first ) first = <NUM_LIT> ; else { fputc ( ',' , stream ) ; l ++ ; } fprintf ( stream , <STR_LIT> , * ptr ) ; l += <NUM_LIT> ;


<s> if ( final_sequence ) { delay = XVECEXP ( final_sequence , <NUM_LIT> , <NUM_LIT> ) ; delayed = ! INSN_ANNULLED_BRANCH_P ( seq ) ; annultrue = INSN_ANNULLED_BRANCH_P ( seq ) && ! INSN_FROM_TARGET_P ( delay ) ; annulfalse = INSN_ANNULLED_BRANCH_P ( seq ) && INSN_FROM_TARGET_P ( delay ) ; } strcpy ( str , form ) ; cp = & str [ strlen ( str ) ] ; if ( delayed ) { * cp ++ = '%' ; * cp ++ = '#' ; } if ( annultrue ) { * cp ++ = 'a' ; * cp ++ = 't' ;


<s> if ( ! TARGET_C3X ) target_flags |= MASK_MPYI | MASK_DB ;

if ( optimize < <NUM_LIT> ) target_flags &= ~ ( MASK_RPTB | MASK_PARALLEL ) ;


<s> int c4x_O_constant ( rtx op ) { return c4x_immed_int_constant ( op ) && IS_HIGH_CONST ( INTVAL ( op ) ) ;


<s> break ; case 'L' : if ( code != CONST_INT ) fatal_insn ( <STR_LIT> , op ) ; fprintf ( file , <STR_LIT> , exact_log2 ( INTVAL ( op ) ) ) ; return ; case 'N' : if ( code != CONST_INT ) fatal_insn ( <STR_LIT> , op ) ; fprintf ( file , HOST_WIDE_INT_PRINT_DEC , ~ INTVAL ( op ) ) ; return ; case 'K' : if ( ! TARGET_SMALL && code == MEM && GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == LO_SUM && GET_CODE ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) == REG && REGNO ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) == DP_REGNO ) { op1 = XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ; if ( GET_CODE ( op1 ) == CONST_INT || GET_CODE ( op1 ) == SYMBOL_REF ) { fprintf ( file , <STR_LIT> , TARGET_C3X ? <STR_LIT> : <STR_LIT> ) ; output_address ( XEXP ( adjust_address ( op , VOIDmode , <NUM_LIT> ) , <NUM_LIT> ) ) ; fprintf ( file , <STR_LIT> ) ; } } return ; case 'M' : if ( ! TARGET_SMALL && code == MEM && ( GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == CONST || GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == SYMBOL_REF ) ) { fprintf ( file , <STR_LIT> , TARGET_C3X ? <STR_LIT> : <STR_LIT> ) ; output_address ( XEXP ( op , <NUM_LIT> ) ) ; fprintf ( file , <STR_LIT> ) ; } return ; case 'O' : if ( code == MEM && c4x_autoinc_operand ( op , Pmode ) ) break ; else if ( code == MEM ) output_address ( XEXP ( adjust_address ( op , VOIDmode , <NUM_LIT> ) , <NUM_LIT> ) ) ; else if ( code == REG ) fprintf ( file , <STR_LIT> , reg_names [ REGNO ( op ) + <NUM_LIT> ] ) ; else fatal_insn ( <STR_LIT> , op ) ; return ; case 'C' : break ; case 'U' : if ( code != SYMBOL_REF ) fprintf ( file , <STR_LIT> ) ; return ; default : break ; } switch ( code ) { case REG : if ( GET_MODE_CLASS ( GET_MODE ( op ) ) == MODE_FLOAT && ! TARGET_TI ) fprintf ( file , <STR_LIT> , float_reg_names [ REGNO ( op ) ] ) ; else fprintf ( file , <STR_LIT> , reg_names [ REGNO ( op ) ] ) ; break ; case MEM : output_address ( XEXP ( op , <NUM_LIT> ) ) ; break ; case CONST_DOUBLE :


<s> else if ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == PLUS && INTVAL ( op1 ) > <NUM_LIT> ) fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , reg_names [ REGNO ( op0 ) ] , INTVAL ( op1 ) ) ; else if ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == PLUS && INTVAL ( op1 ) < <NUM_LIT> ) fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , reg_names [ REGNO ( op0 ) ] , - INTVAL ( op1 ) ) ; else if ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == MINUS && REG_P ( op1 ) ) fprintf ( file , <STR_LIT> , reg_names [ REGNO ( op0 ) ] , reg_names [ REGNO ( op1 ) ] ) ; else fatal_insn ( <STR_LIT> , addr ) ; } break ; case PRE_MODIFY : { rtx op0 = XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ; rtx op1 = XEXP ( XEXP ( addr , <NUM_LIT> ) , <NUM_LIT> ) ; if ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == PLUS && REG_P ( op1 ) ) fprintf ( file , <STR_LIT> , reg_names [ REGNO ( op0 ) ] , reg_names [ REGNO ( op1 ) ] ) ; else if ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == PLUS && INTVAL ( op1 ) > <NUM_LIT> ) fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , reg_names [ REGNO ( op0 ) ] , INTVAL ( op1 ) ) ; else if ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == PLUS && INTVAL ( op1 ) < <NUM_LIT> ) fprintf ( file , <STR_LIT> HOST_WIDE_INT_PRINT_DEC <STR_LIT> , reg_names [ REGNO ( op0 ) ] , - INTVAL ( op1 ) ) ; else if ( GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == MINUS && REG_P ( op1 ) ) fprintf ( file , <STR_LIT> , reg_names [ REGNO ( op0 ) ] , reg_names [ REGNO ( op1 ) ] ) ; else fatal_insn ( <STR_LIT> , addr ) ; } break ; case PRE_INC : fprintf ( file , <STR_LIT> , reg_names [ REGNO ( XEXP ( addr , <NUM_LIT> ) ) ] ) ; break ; case POST_DEC : fprintf ( file , <STR_LIT> , reg_names [ REGNO ( XEXP ( addr , <NUM_LIT> ) ) ] ) ; break ; case PLUS : { rtx op0 = XEXP ( addr , <NUM_LIT> ) ; rtx op1 = XEXP ( addr , <NUM_LIT> ) ; if ( REG_P ( op0 ) ) { if ( REG_P ( op1 ) ) { if ( IS_INDEX_REG ( op0 ) ) { fprintf ( file , <STR_LIT> , reg_names [ REGNO ( op1 ) ] , reg_names [ REGNO ( op0 ) ] ) ; }


<s> if ( GET_CODE ( op ) != MEM ) return <NUM_LIT> ; op = XEXP ( op , <NUM_LIT> ) ; switch ( GET_CODE ( op ) ) { case REG : return <NUM_LIT> ; case PLUS : { rtx op0 = XEXP ( op , <NUM_LIT> ) ; rtx op1 = XEXP ( op , <NUM_LIT> ) ; if ( ! REG_P ( op0 ) ) return <NUM_LIT> ; if ( REG_P ( op1 ) ) return <NUM_LIT> ; if ( GET_CODE ( op1 ) != CONST_INT ) return <NUM_LIT> ;

if ( mode == HImode || mode == HFmode ) return IS_DISP8_OFF_CONST ( INTVAL ( op1 ) ) ;


<s> if ( ! REG_P ( op0 ) ) return <NUM_LIT> ; if ( REG_P ( op1 ) ) return <NUM_LIT> ; if ( GET_CODE ( op1 ) != CONST_INT ) return <NUM_LIT> ; if ( mode == HImode || mode == HFmode ) return IS_DISP8_OFF_CONST ( INTVAL ( op1 ) ) ; return IS_DISP8_CONST ( INTVAL ( op1 ) ) ; } break ; default : break ;


<s> int i , j ; const char * fmt ; if ( x == <NUM_LIT> ) return <NUM_LIT> ; if ( INSN_P ( x ) && GET_CODE ( PATTERN ( x ) ) == SEQUENCE ) x = XVECEXP ( PATTERN ( x ) , <NUM_LIT> , XVECLEN ( PATTERN ( x ) , <NUM_LIT> ) - <NUM_LIT> ) ;

if ( INSN_P ( x ) && ( set = single_set ( x ) ) ) x = SET_DEST ( set ) ;


<s> insn_code_number = recog_memoized ( insn ) ; if ( insn_code_number < <NUM_LIT> ) continue ; if ( insn_code_number == CODE_FOR_rptb_end ) c4x_rptb_insert ( insn ) ; old = insn ; if ( ! INSN_DELETED_P ( old ) ) insn = try_split ( PATTERN ( old ) , old , <NUM_LIT> ) ; if ( INSN_DELETED_P ( old ) ) { PUT_CODE ( old , NOTE ) ; NOTE_LINE_NUMBER ( old ) = NOTE_INSN_DELETED ; NOTE_SOURCE_FILE ( old ) = <NUM_LIT> ; } } }


<s> if ( INSN_P ( insn ) ) { int insn_code_number ; rtx old ; insn_code_number = recog_memoized ( insn ) ; if ( insn_code_number < <NUM_LIT> ) continue ; if ( insn_code_number == CODE_FOR_rptb_end ) c4x_rptb_insert ( insn ) ; old = insn ; if ( ! INSN_DELETED_P ( old ) ) insn = try_split ( PATTERN ( old ) , old , <NUM_LIT> ) ; if ( INSN_DELETED_P ( old ) ) { PUT_CODE ( old , NOTE ) ; NOTE_LINE_NUMBER ( old ) = NOTE_INSN_DELETED ; NOTE_SOURCE_FILE ( old ) = <NUM_LIT> ; } }


<s> if ( ! c4x_rptb_valid_p ( insn , start_label ) ) { emit_insn_before ( gen_addqi3 ( count_reg , count_reg , constm1_rtx ) , insn ) ; emit_insn_before ( gen_cmpqi ( count_reg , const0_rtx ) , insn ) ; emit_insn_before ( gen_bge ( start_label ) , insn ) ; LABEL_NUSES ( start_label ) ++ ; delete_insn ( insn ) ; return ; } end_label = gen_label_rtx ( ) ; LABEL_NUSES ( end_label ) ++ ; emit_label_after ( end_label , insn ) ; new_start_label = gen_label_rtx ( ) ; LABEL_NUSES ( new_start_label ) ++ ; for ( ; insn ; insn = PREV_INSN ( insn ) ) { if ( insn == start_label ) break ; if ( GET_CODE ( insn ) == JUMP_INSN && JUMP_LABEL ( insn ) == start_label ) redirect_jump ( insn , new_start_label , <NUM_LIT> ) ; } if ( ! insn ) fatal_insn ( <STR_LIT> , start_label ) ; emit_label_after ( new_start_label , insn ) ; if ( TARGET_RPTS && c4x_rptb_rpts_p ( PREV_INSN ( insn ) , <NUM_LIT> ) ) emit_insn_after ( gen_rpts_top ( new_start_label , end_label ) , insn ) ; else emit_insn_after ( gen_rptb_top ( new_start_label , end_label ) , insn ) ;


<s> for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { while ( GET_CODE ( insn ) == NOTE || GET_CODE ( insn ) == CODE_LABEL || GET_CODE ( insn ) == USE || GET_CODE ( insn ) == CLOBBER ) {

if ( insn == start_label ) return i == <NUM_LIT> ;


<s> } while ( GET_CODE ( insn ) == NOTE || GET_CODE ( insn ) == USE || GET_CODE ( insn ) == CLOBBER ) ; if ( GET_CODE ( insn ) == CODE_LABEL ) return <NUM_LIT> ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { while ( GET_CODE ( insn ) == NOTE || GET_CODE ( insn ) == CODE_LABEL || GET_CODE ( insn ) == USE || GET_CODE ( insn ) == CLOBBER ) { if ( insn == start_label ) return i == <NUM_LIT> ; insn = previous_insn ( insn ) ; } ; if ( GET_CODE ( insn ) == JUMP_INSN ) return <NUM_LIT> ; insn = previous_insn ( insn ) ; }


<s> insn = next_nonnote_insn ( insn ) ; if ( ! INSN_P ( insn ) ) return <NUM_LIT> ; if ( recog_memoized ( insn ) != CODE_FOR_rptb_end ) return <NUM_LIT> ;


<s> if ( ! insn ) return <NUM_LIT> ; start = insn ; for ( insn = PREV_INSN ( start ) ; insn ; insn = PREV_INSN ( insn ) ) { if ( GET_CODE ( insn ) == CODE_LABEL ) { for ( tmp = NEXT_INSN ( start ) ; tmp != end ; tmp = NEXT_INSN ( tmp ) ) if ( GET_CODE ( tmp ) == JUMP_INSN && c4x_label_ref_used_p ( tmp , insn ) ) return <NUM_LIT> ; } } for ( insn = NEXT_INSN ( end ) ; insn ; insn = NEXT_INSN ( insn ) ) { if ( GET_CODE ( insn ) == CODE_LABEL ) { for ( tmp = NEXT_INSN ( start ) ; tmp != end ; tmp = NEXT_INSN ( tmp ) ) if ( GET_CODE ( tmp ) == JUMP_INSN && c4x_label_ref_used_p ( tmp , insn ) ) return <NUM_LIT> ; } } for ( insn = NEXT_INSN ( start ) ; insn != end ; insn = NEXT_INSN ( insn ) ) { if ( GET_CODE ( insn ) == CODE_LABEL ) { for ( tmp = NEXT_INSN ( end ) ; tmp ; tmp = NEXT_INSN ( tmp ) ) if ( GET_CODE ( tmp ) == JUMP_INSN && c4x_label_ref_used_p ( tmp , insn ) ) return <NUM_LIT> ; for ( tmp = PREV_INSN ( start ) ; tmp ; tmp = PREV_INSN ( tmp ) ) if ( GET_CODE ( tmp ) == JUMP_INSN && c4x_label_ref_used_p ( tmp , insn ) ) return <NUM_LIT> ;


<s> return true ; case CONST : case LABEL_REF : case SYMBOL_REF : * total = <NUM_LIT> ; return true ; case CONST_DOUBLE : if ( c4x_H_constant ( x ) ) * total = <NUM_LIT> ; else if ( GET_MODE ( x ) == QFmode ) * total = <NUM_LIT> ; else * total = <NUM_LIT> ; return true ; case PLUS : case MINUS : case AND : case IOR : case XOR : case ASHIFT : case ASHIFTRT : case LSHIFTRT : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ;


<s> else if ( ! TARGET_C3X && outer_code == AND && ( val == <NUM_LIT> || val == <NUM_LIT> ) ) * total = <NUM_LIT> ; else if ( ! TARGET_C3X && ( outer_code == ASHIFTRT || outer_code == LSHIFTRT ) && ( val == <NUM_LIT> || val == <NUM_LIT> ) ) * total = <NUM_LIT> ; else if ( TARGET_C3X && SHIFT_CODE_P ( outer_code ) ) * total = <NUM_LIT> ; else if ( LOGICAL_CODE_P ( outer_code ) ? c4x_L_constant ( x ) : c4x_I_constant ( x ) ) * total = <NUM_LIT> ; else * total = <NUM_LIT> ; return true ; case CONST : case LABEL_REF : case SYMBOL_REF : * total = <NUM_LIT> ; return true ; case CONST_DOUBLE : if ( c4x_H_constant ( x ) ) * total = <NUM_LIT> ; else if ( GET_MODE ( x ) == QFmode ) * total = <NUM_LIT> ; else * total = <NUM_LIT> ; return true ; case PLUS : case MINUS : case AND : case IOR : case XOR : case ASHIFT : case ASHIFTRT : case LSHIFTRT : * total = COSTS_N_INSNS ( <NUM_LIT> ) ; return true ; case MULT : * total = COSTS_N_INSNS ( GET_MODE_CLASS ( GET_MODE ( x ) ) == MODE_FLOAT || TARGET_MPYI ? <NUM_LIT> : <NUM_LIT> ) ; return true ; case DIV : case UDIV : case MOD : case UMOD :

* total = COSTS_N_INSNS ( GET_MODE_CLASS ( GET_MODE ( x ) ) == MODE_FLOAT ? <NUM_LIT> : <NUM_LIT> ) ;


<s> rtx op1 = XEXP ( op , <NUM_LIT> ) ; if ( ! REG_P ( op0 ) ) return <NUM_LIT> ; if ( GET_CODE ( op1 ) != CONST_INT ) return <NUM_LIT> ; if ( mode == HImode || mode == HFmode ) return IS_UINT5_CONST ( INTVAL ( op1 ) + <NUM_LIT> ) ; return IS_UINT5_CONST ( INTVAL ( op1 ) ) ;


<s> case REG : return IS_ADDR_OR_PSEUDO_REG ( op ) ; case PLUS : { rtx op0 = XEXP ( op , <NUM_LIT> ) ; rtx op1 = XEXP ( op , <NUM_LIT> ) ; if ( mode == HImode || mode == HFmode ) return IS_ADDR_OR_PSEUDO_REG ( op0 ) && GET_CODE ( op1 ) == CONST_INT && IS_UINT5_CONST ( INTVAL ( op1 ) + <NUM_LIT> ) ; return REG_P ( op0 ) && IS_ADDR_OR_PSEUDO_REG ( op0 ) && GET_CODE ( op1 ) == CONST_INT && IS_UINT5_CONST ( INTVAL ( op1 ) ) ; }


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

if ( mode == HImode || mode == HFmode ) return IS_ADDR_OR_PSEUDO_REG ( op0 ) && GET_CODE ( op1 ) == CONST_INT && IS_UINT5_CONST ( INTVAL ( op1 ) + <NUM_LIT> ) ;


<s> for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { if ( val & ( <NUM_LIT> << i ) ) break ; } mask = ( ( <NUM_LIT> >> i ) << <NUM_LIT> ) | <NUM_LIT> ; if ( IS_INT16_CONST ( val & ( <NUM_LIT> << <NUM_LIT> ) ? ( val >> i ) | ~ mask : ( val >> i ) & mask ) ) return i ;


<s> } mask = ( ( <NUM_LIT> >> i ) << <NUM_LIT> ) | <NUM_LIT> ; if ( IS_INT16_CONST ( val & ( <NUM_LIT> << <NUM_LIT> ) ? ( val >> i ) | ~ mask : ( val >> i ) & mask ) ) return i ;


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


<s> * disp = <NUM_LIT> ; return ; case PRE_INC : * base = REGNO ( XEXP ( op , <NUM_LIT> ) ) ; * incdec = <NUM_LIT> ; * disp = <NUM_LIT> ; return ; case POST_INC : * base = REGNO ( XEXP ( op , <NUM_LIT> ) ) ; * incdec = <NUM_LIT> ; * disp = <NUM_LIT> ; return ; case POST_MODIFY : * base = REGNO ( XEXP ( op , <NUM_LIT> ) ) ; if ( REG_P ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) ) { * index = REGNO ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) ; * disp = <NUM_LIT> ; } else * disp = INTVAL ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) ; * incdec = <NUM_LIT> ; return ; case PRE_MODIFY : * base = REGNO ( XEXP ( op , <NUM_LIT> ) ) ; if ( REG_P ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) ) { * index = REGNO ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) ; * disp = <NUM_LIT> ; } else * disp = INTVAL ( XEXP ( XEXP ( op , <NUM_LIT> ) , <NUM_LIT> ) ) ; * incdec = <NUM_LIT> ; return ; case REG : * base = REGNO ( op ) ; return ; case PLUS : { rtx op0 = XEXP ( op , <NUM_LIT> ) ; rtx op1 = XEXP ( op , <NUM_LIT> ) ; if ( c4x_a_register ( op0 ) ) { if ( c4x_x_register ( op1 ) ) { * base = REGNO ( op0 ) ; * index = REGNO ( op1 ) ; return ; } else if ( ( GET_CODE ( op1 ) == CONST_INT && IS_DISP1_CONST ( INTVAL ( op1 ) ) ) ) { * base = REGNO ( op0 ) ; * disp = INTVAL ( op1 ) ; return ; } } else if ( c4x_x_register ( op0 ) && c4x_a_register ( op1 ) ) { * base = REGNO ( op1 ) ; * index = REGNO ( op0 ) ; return ; } }


<s> case PLUS : { rtx op0 = XEXP ( op , <NUM_LIT> ) ; rtx op1 = XEXP ( op , <NUM_LIT> ) ; if ( ! REG_P ( op0 ) ) return <NUM_LIT> ; if ( REG_P ( op1 ) ) return <NUM_LIT> ; if ( GET_CODE ( op1 ) != CONST_INT ) return <NUM_LIT> ; if ( mode == HImode || mode == HFmode ) return IS_DISP1_OFF_CONST ( INTVAL ( op1 ) ) ; return IS_DISP1_CONST ( INTVAL ( op1 ) ) ; } break ; default :


<s> } break ; case PLUS : { rtx op0 = XEXP ( op , <NUM_LIT> ) ; rtx op1 = XEXP ( op , <NUM_LIT> ) ; if ( ! REG_P ( op0 ) ) return <NUM_LIT> ; if ( REG_P ( op1 ) ) return <NUM_LIT> ; if ( GET_CODE ( op1 ) != CONST_INT ) return <NUM_LIT> ;

if ( mode == HImode || mode == HFmode ) return IS_DISP1_OFF_CONST ( INTVAL ( op1 ) ) ;


<s> case PRE_DEC : case POST_DEC : if ( mode != QImode && mode != QFmode ) return <NUM_LIT> ; case PRE_INC : case POST_INC : op = XEXP ( op , <NUM_LIT> ) ; case REG : return IS_ADDR_OR_PSEUDO_REG ( op ) ; case PRE_MODIFY : case POST_MODIFY : { rtx op0 = XEXP ( op , <NUM_LIT> ) ; rtx op1 = XEXP ( op , <NUM_LIT> ) ; if ( mode != QImode && mode != QFmode ) return <NUM_LIT> ; if ( ( GET_CODE ( op1 ) != PLUS && GET_CODE ( op1 ) != MINUS ) || ( op0 != XEXP ( op1 , <NUM_LIT> ) ) ) return <NUM_LIT> ; op0 = XEXP ( op1 , <NUM_LIT> ) ; op1 = XEXP ( op1 , <NUM_LIT> ) ; return REG_P ( op0 ) && IS_ADDR_OR_PSEUDO_REG ( op0 ) && REG_P ( op1 ) && IS_INDEX_OR_PSEUDO_REG ( op1 ) ;


<s> case PRE_MODIFY : case POST_MODIFY : { rtx op0 = XEXP ( op , <NUM_LIT> ) ; rtx op1 = XEXP ( op , <NUM_LIT> ) ; if ( mode != QImode && mode != QFmode ) return <NUM_LIT> ; if ( ( GET_CODE ( op1 ) != PLUS && GET_CODE ( op1 ) != MINUS ) || ( op0 != XEXP ( op1 , <NUM_LIT> ) ) ) return <NUM_LIT> ; op0 = XEXP ( op1 , <NUM_LIT> ) ; op1 = XEXP ( op1 , <NUM_LIT> ) ; return REG_P ( op0 ) && IS_ADDR_OR_PSEUDO_REG ( op0 ) && REG_P ( op1 ) && IS_INDEX_OR_PSEUDO_REG ( op1 ) ; } case PLUS :


<s> int c4x_T_constraint ( rtx op ) { if ( GET_CODE ( op ) != MEM ) return <NUM_LIT> ; op = XEXP ( op , <NUM_LIT> ) ; if ( GET_CODE ( op ) != LO_SUM ) { return GET_CODE ( op ) == SYMBOL_REF && GET_MODE ( op ) == Pmode && SYMBOL_REF_FUNCTION_P ( op ) ; } if ( GET_MODE ( op ) == HImode || GET_CODE ( op ) == HFmode ) return <NUM_LIT> ; if ( ( GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == REG ) && ( REGNO ( XEXP ( op , <NUM_LIT> ) ) == DP_REGNO ) ) return c4x_U_constraint ( XEXP ( op , <NUM_LIT> ) ) ; return <NUM_LIT> ;


<s> op = XEXP ( op , <NUM_LIT> ) ; if ( GET_CODE ( op ) != LO_SUM ) { return GET_CODE ( op ) == SYMBOL_REF && GET_MODE ( op ) == Pmode && SYMBOL_REF_FUNCTION_P ( op ) ;


<s> static int c4x_valid_operands ( enum rtx_code code , rtx * operands , enum machine_mode mode ATTRIBUTE_UNUSED , int force ) { rtx op0 ; rtx op1 ; rtx op2 ; enum rtx_code code1 ; enum rtx_code code2 ; if ( code == IF_THEN_ELSE ) return <NUM_LIT> || ( operands [ <NUM_LIT> ] == operands [ <NUM_LIT> ] || operands [ <NUM_LIT> ] == operands [ <NUM_LIT> ] ) ; if ( code == COMPARE ) { op1 = operands [ <NUM_LIT> ] ; op2 = operands [ <NUM_LIT> ] ; } else { op1 = operands [ <NUM_LIT> ] ; op2 = operands [ <NUM_LIT> ] ; } op0 = operands [ <NUM_LIT> ] ; if ( GET_CODE ( op0 ) == SUBREG ) op0 = SUBREG_REG ( op0 ) ; if ( GET_CODE ( op1 ) == SUBREG ) op1 = SUBREG_REG ( op1 ) ; if ( GET_CODE ( op2 ) == SUBREG ) op2 = SUBREG_REG ( op2 ) ; code1 = GET_CODE ( op1 ) ; code2 = GET_CODE ( op2 ) ; if ( code1 == REG && code2 == REG ) return <NUM_LIT> ; if ( code1 == MEM && code2 == MEM ) { if ( c4x_S_indirect ( op1 ) && c4x_S_indirect ( op2 ) ) return <NUM_LIT> ; return c4x_R_indirect ( op1 ) && c4x_R_indirect ( op2 ) ; } if ( code1 == code2 ) return <NUM_LIT> ; if ( code1 == REG ) { switch ( code2 ) { case CONST_INT : if ( c4x_J_constant ( op2 ) && c4x_R_indirect ( op1 ) ) return <NUM_LIT> ; break ; case CONST_DOUBLE : if ( ! c4x_H_constant ( op2 ) ) return <NUM_LIT> ; break ; case MEM : break ; default : fatal_insn ( <STR_LIT> , op2 ) ; break ; } if ( GET_CODE ( op0 ) == SCRATCH ) return <NUM_LIT> ; if ( ! REG_P ( op0 ) ) return <NUM_LIT> ; return ! force || code == COMPARE || REGNO ( op1 ) == REGNO ( op0 ) ; } if ( code == ASHIFTRT || code == LSHIFTRT || code == ASHIFT || code == COMPARE ) return code2 == REG && ( c4x_S_indirect ( op1 ) || c4x_R_indirect ( op1 ) ) ; if ( code2 == REG ) { switch ( code1 ) { case CONST_INT : break ; case CONST_DOUBLE : if ( ! c4x_H_constant ( op1 ) ) return <NUM_LIT> ; break ; case MEM : break ; default : abort ( ) ; break ; } if ( GET_CODE ( op0 ) == SCRATCH ) return <NUM_LIT> ; if ( ! REG_P ( op0 ) ) return <NUM_LIT> ; return ! force || REGNO ( op1 ) == REGNO ( op0 ) ; } if ( c4x_J_constant ( op1 ) && c4x_R_indirect ( op2 ) ) return <NUM_LIT> ; return <NUM_LIT> ;


<s> if ( mode != VOIDmode && mode != GET_MODE ( op ) ) return <NUM_LIT> ; if ( GET_CODE ( op ) == MEM ) { op = XEXP ( op , <NUM_LIT> ) ; if ( GET_CODE ( op ) == PLUS ) { rtx op0 = XEXP ( op , <NUM_LIT> ) ;


<s> if ( mode != VOIDmode && mode != GET_MODE ( op ) ) return <NUM_LIT> ; if ( GET_CODE ( op ) == MEM ) { op = XEXP ( op , <NUM_LIT> ) ; if ( GET_CODE ( op ) == PLUS ) {


<s> int group1_reg_operand ( rtx op , enum machine_mode mode ) {

if ( mode != VOIDmode && mode != GET_MODE ( op ) ) return <NUM_LIT> ;


<s> if ( mode != VOIDmode && mode != GET_MODE ( op ) ) return <NUM_LIT> ;

if ( GET_CODE ( op ) == SUBREG ) op = SUBREG_REG ( op ) ;


<s> int ir0_mem_operand ( rtx op , enum machine_mode mode ) { return c4x_arn_mem_operand ( op , mode , IR0_REGNO ) ;


<s> int ir0_reg_operand ( rtx op , enum machine_mode mode ) {

return c4x_arn_reg_operand ( op , mode , IR0_REGNO ) ;


<s> int ir0_reg_operand ( rtx op , enum machine_mode mode ) { return c4x_arn_reg_operand ( op , mode , IR0_REGNO ) ;


<s> int ir1_mem_operand ( rtx op , enum machine_mode mode ) {

return c4x_arn_mem_operand ( op , mode , IR1_REGNO ) ;


<s> return c4x_arn_reg_operand ( op , mode , IR1_REGNO ) ;


<s> rtx op1 = XEXP ( op , <NUM_LIT> ) ; if ( ! REG_P ( op0 ) ) return <NUM_LIT> ; if ( REG_P ( op1 ) || GET_CODE ( op1 ) == CONST_INT ) return <NUM_LIT> ; } case LO_SUM : { rtx op0 = XEXP ( op , <NUM_LIT> ) ; if ( REG_P ( op0 ) && REGNO ( op0 ) == DP_REGNO ) return <NUM_LIT> ; } break ; case CONST : case SYMBOL_REF : case LABEL_REF : return <NUM_LIT> ; default : break ; } return <NUM_LIT> ;


<s> return ! optimize || c4x_valid_operands ( code , operands , mode , <NUM_LIT> ) ;


<s> int valid_parallel_load_store ( rtx * operands , enum machine_mode mode ATTRIBUTE_UNUSED ) { rtx op0 = operands [ <NUM_LIT> ] ; rtx op1 = operands [ <NUM_LIT> ] ; rtx op2 = operands [ <NUM_LIT> ] ; rtx op3 = operands [ <NUM_LIT> ] ; if ( GET_CODE ( op0 ) == SUBREG ) op0 = SUBREG_REG ( op0 ) ; if ( GET_CODE ( op1 ) == SUBREG ) op1 = SUBREG_REG ( op1 ) ; if ( GET_CODE ( op2 ) == SUBREG ) op2 = SUBREG_REG ( op2 ) ; if ( GET_CODE ( op3 ) == SUBREG ) op3 = SUBREG_REG ( op3 ) ;

if ( GET_CODE ( op0 ) == REG && ( ( GET_CODE ( op2 ) == MEM && reg_mentioned_p ( op0 , XEXP ( op2 , <NUM_LIT> ) ) ) || ( GET_CODE ( op3 ) == MEM && reg_mentioned_p ( op0 , XEXP ( op3 , <NUM_LIT> ) ) ) ) ) return <NUM_LIT> ;


<s> if ( GET_CODE ( op2 ) == SUBREG ) op2 = SUBREG_REG ( op2 ) ; if ( GET_CODE ( op3 ) == SUBREG ) op3 = SUBREG_REG ( op3 ) ; if ( GET_CODE ( op0 ) == REG && ( ( GET_CODE ( op2 ) == MEM && reg_mentioned_p ( op0 , XEXP ( op2 , <NUM_LIT> ) ) ) || ( GET_CODE ( op3 ) == MEM && reg_mentioned_p ( op0 , XEXP ( op3 , <NUM_LIT> ) ) ) ) ) return <NUM_LIT> ; if ( GET_CODE ( op0 ) == REG && GET_CODE ( op2 ) == REG ) return ( REGNO ( op0 ) != REGNO ( op2 ) ) && GET_CODE ( op1 ) == MEM && GET_CODE ( op3 ) == MEM && ! c4x_address_conflict ( op1 , op3 , <NUM_LIT> , <NUM_LIT> ) ; if ( GET_CODE ( op1 ) == REG && GET_CODE ( op3 ) == REG ) return GET_CODE ( op0 ) == MEM && GET_CODE ( op2 ) == MEM && ! c4x_address_conflict ( op0 , op2 , <NUM_LIT> , <NUM_LIT> ) ; if ( GET_CODE ( op0 ) == REG && GET_CODE ( op3 ) == REG ) return GET_CODE ( op1 ) == MEM && GET_CODE ( op2 ) == MEM && ! c4x_address_conflict ( op1 , op2 , <NUM_LIT> , <NUM_LIT> ) ;

if ( GET_CODE ( op1 ) == REG && GET_CODE ( op2 ) == REG ) return GET_CODE ( op0 ) == MEM && GET_CODE ( op3 ) == MEM && ! c4x_address_conflict ( op0 , op3 , <NUM_LIT> , <NUM_LIT> ) ;


<s> int valid_parallel_operands_4 ( rtx * operands , enum machine_mode mode ATTRIBUTE_UNUSED ) { rtx op0 = operands [ <NUM_LIT> ] ;


<s> rtx op3 = operands [ <NUM_LIT> ] ; if ( GET_CODE ( op0 ) == SUBREG ) op0 = SUBREG_REG ( op0 ) ; if ( GET_CODE ( op1 ) == SUBREG ) op1 = SUBREG_REG ( op1 ) ; if ( GET_CODE ( op2 ) == SUBREG ) op2 = SUBREG_REG ( op2 ) ; if ( GET_CODE ( op1 ) == REG ) regs ++ ; if ( GET_CODE ( op2 ) == REG ) regs ++ ; if ( regs != <NUM_LIT> ) return <NUM_LIT> ; if ( GET_CODE ( op0 ) == REG && GET_CODE ( op3 ) == MEM && reg_mentioned_p ( op0 , XEXP ( op3 , <NUM_LIT> ) ) ) return <NUM_LIT> ;


<s> if ( GET_CODE ( op5 ) == REG ) regs ++ ; if ( regs != <NUM_LIT> ) return <NUM_LIT> ;

if ( GET_CODE ( op0 ) == REG && ( ( GET_CODE ( op4 ) == MEM && reg_mentioned_p ( op0 , XEXP ( op4 , <NUM_LIT> ) ) ) || ( GET_CODE ( op5 ) == MEM && reg_mentioned_p ( op0 , XEXP ( op5 , <NUM_LIT> ) ) ) ) ) return <NUM_LIT> ;


<s> if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( TREE_TYPE ( current_function_decl ) ) ) ) return <NUM_LIT> ;

return current_function_name [ <NUM_LIT> ] == 'c' && current_function_name [ <NUM_LIT> ] == '_' && current_function_name [ <NUM_LIT> ] == 'i' && current_function_name [ <NUM_LIT> ] == 'n' && current_function_name [ <NUM_LIT> ] == 't' && ISDIGIT ( current_function_name [ <NUM_LIT> ] ) && ISDIGIT ( current_function_name [ <NUM_LIT> ] ) ;


if ( leaf_function_p ( ) ) return <NUM_LIT> ;


<s> static int c4x_leaf_function_p ( ) {

if ( lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( TREE_TYPE ( current_function_decl ) ) ) ) return <NUM_LIT> ;


<s> int regno ; if ( reload_completed && ! c4x_assembler_function_p ( ) && ! c4x_interrupt_function_p ( ) && ! current_function_calls_alloca && ! current_function_args_size && ! ( optimize < <NUM_LIT> ) && ! get_frame_size ( ) ) { for ( regno = FIRST_PSEUDO_REGISTER - <NUM_LIT> ; regno >= <NUM_LIT> ; regno -- ) if ( regs_ever_live [ regno ] && ! call_used_regs [ regno ] && ( regno != AR3_REGNO ) ) return <NUM_LIT> ;


<s> else c4x_rpts_cycles = <NUM_LIT> ; if ( TARGET_C30 ) c4x_cpu_version = <NUM_LIT> ; else if ( TARGET_C31 ) c4x_cpu_version = <NUM_LIT> ; else if ( TARGET_C32 ) c4x_cpu_version = <NUM_LIT> ; else if ( TARGET_C33 ) c4x_cpu_version = <NUM_LIT> ; else if ( TARGET_C40 ) c4x_cpu_version = <NUM_LIT> ; else if ( TARGET_C44 ) c4x_cpu_version = <NUM_LIT> ; else c4x_cpu_version = <NUM_LIT> ; if ( c4x_cpu_version_string ) { const char * p = c4x_cpu_version_string ; if ( * p == 'c' || * p == 'C' ) p ++ ; c4x_cpu_version = atoi ( p ) ; } target_flags &= ~ ( C30_FLAG | C31_FLAG | C32_FLAG | C33_FLAG | C40_FLAG | C44_FLAG ) ; switch ( c4x_cpu_version ) { case <NUM_LIT> : target_flags |= C30_FLAG ; break ; case <NUM_LIT> : target_flags |= C31_FLAG ; break ; case <NUM_LIT> : target_flags |= C32_FLAG ; break ; case <NUM_LIT> : target_flags |= C33_FLAG ; break ; case <NUM_LIT> : target_flags |= C40_FLAG ; break ; case <NUM_LIT> : target_flags |= C44_FLAG ; break ; default : warning ( <STR_LIT> , c4x_cpu_version ) ; c4x_cpu_version = <NUM_LIT> ; target_flags |= C40_FLAG ;


<s> else if ( TARGET_C31 ) c4x_cpu_version = <NUM_LIT> ; else if ( TARGET_C32 ) c4x_cpu_version = <NUM_LIT> ; else if ( TARGET_C33 ) c4x_cpu_version = <NUM_LIT> ; else if ( TARGET_C40 ) c4x_cpu_version = <NUM_LIT> ; else if ( TARGET_C44 ) c4x_cpu_version = <NUM_LIT> ; else c4x_cpu_version = <NUM_LIT> ; if ( c4x_cpu_version_string ) { const char * p = c4x_cpu_version_string ; if ( * p == 'c' || * p == 'C' ) p ++ ; c4x_cpu_version = atoi ( p ) ; } target_flags &= ~ ( C30_FLAG | C31_FLAG | C32_FLAG | C33_FLAG | C40_FLAG | C44_FLAG ) ;