<s> if ( frame ) RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } else do { int size = value ; rtx insn ; if ( size > <NUM_LIT> ) size = <NUM_LIT> ; else if ( size < - <NUM_LIT> ) size = - <NUM_LIT> ; insn = emit_insn ( gen_addsi3 ( spreg , spreg , GEN_INT ( size ) ) ) ; if ( frame ) RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; value -= size ; } while ( value !=


<s> static HOST_WIDE_INT arg_area_size ( void ) { if ( current_function_outgoing_args_size ) { if ( current_function_outgoing_args_size >= FIXED_STACK_AREA ) return current_function_outgoing_args_size ; else return FIXED_STACK_AREA ; } return <NUM_LIT>


<s> void asm_conditional_branch ( rtx insn , rtx * operands , int n_nops , int predict_taken ) { int offset = branch_dest ( insn ) - INSN_ADDRESSES ( INSN_UID ( insn ) ) ; int len = ( offset >= - <NUM_LIT> && offset <= <NUM_LIT> ? <NUM_LIT> : offset >= - <NUM_LIT> && offset <= <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ) ; int bp = predict_taken && len == <NUM_LIT> ? <NUM_LIT> : cbranch_predicted_taken_p ( insn ) ; int idx = ( bp << <NUM_LIT> ) | ( GET_CODE ( operands [ <NUM_LIT> ] ) == EQ ? BRF : BRT ) ; output_asm_insn ( ccbranch_templates [ idx ] [ len ] , operands ) ; gcc_assert ( n_nops == <NUM_LIT> || ! bp


<s> static int bfin_address_cost ( rtx addr ATTRIBUTE_UNUSED ) { return


<s> int bytes_left = cum -> nregs * UNITS_PER_WORD ; if ( bytes == - <NUM_LIT> ) return <NUM_LIT> ; if ( bytes_left == <NUM_LIT> ) return <NUM_LIT> ; if ( bytes > bytes_left ) return bytes_left ; return <NUM_LIT>


<s> if ( kind1 != kind2 ) return <NUM_LIT> ; if ( ! lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type1 ) ) != ! lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type2 ) ) ) return <NUM_LIT> ; if ( ! lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type1 ) ) != ! lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type2 ) ) ) return <NUM_LIT> ; if ( ! lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type1 ) ) != ! lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type2 ) ) ) return <NUM_LIT> ; if ( ! lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type1 ) ) != ! lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type2 ) ) ) return <NUM_LIT> ; return <NUM_LIT>


<s> case BFIN_BUILTIN_CSYNC : emit_insn ( gen_csync ( ) ) ; return <NUM_LIT> ; case BFIN_BUILTIN_SSYNC : emit_insn ( gen_ssync ( ) ) ; return <NUM_LIT> ; default : gcc_unreachable (


<s> call = gen_rtx_CALL ( VOIDmode , fnaddr , callarg1 ) ; if ( retval ) call = gen_rtx_SET ( VOIDmode , retval , call ) ; XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) = call ; XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_USE ( VOIDmode , cookie ) ; if ( sibcall ) XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_RETURN ( VOIDmode ) ; call = emit_call_insn (


<s> void bfin_expand_epilogue ( int need_return , int eh_return ) { rtx spreg = gen_rtx_REG ( Pmode , REG_SP ) ; e_funkind fkind = funkind ( TREE_TYPE ( current_function_decl ) ) ; if ( fkind != SUBROUTINE ) { expand_interrupt_handler_epilogue ( spreg , fkind ) ; return ; } do_unlink ( spreg , get_frame_size


<s> if ( fkind != SUBROUTINE ) { expand_interrupt_handler_epilogue ( spreg , fkind ) ; return ; } do_unlink ( spreg , get_frame_size ( ) , false ) ; expand_epilogue_reg_restore ( spreg , false , false ) ; if ( ! need_return )


<s> int bfin_frame_pointer_required ( void ) { e_funkind fkind = funkind ( TREE_TYPE ( current_function_decl ) ) ; if ( fkind !=


<s> e_funkind fkind = funkind ( TREE_TYPE ( current_function_decl ) ) ; if ( fkind != SUBROUTINE ) return <NUM_LIT> ; if ( TARGET_OMIT_LEAF_FRAME_POINTER && ! current_function_is_leaf ) return <NUM_LIT> ; return <NUM_LIT>


<s> static bool bfin_function_ok_for_sibcall ( tree decl ATTRIBUTE_UNUSED


<s> if ( GET_MODE ( op0 ) == BImode ) { gcc_assert ( ( code == NE || code == EQ ) && op1 == const0_rtx ) ; tem = op0 , code2 = code ; } else { switch ( code ) { case EQ : case LT : case LE : case LEU : case LTU : code1 =


<s> } if ( ( strcmp ( IDENTIFIER_POINTER ( name ) , <STR_LIT> ) == <NUM_LIT> && lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( * node ) ) ) || ( strcmp ( IDENTIFIER_POINTER ( name ) , <STR_LIT> ) == <NUM_LIT> && lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( * node ) ) ) ) { warning ( OPT_Wattributes , <STR_LIT> ) ; * no_add_attrs = true ; } return NULL_TREE


<s> if ( funkind ( TREE_TYPE ( current_function_decl ) ) != SUBROUTINE && ! regs_ever_live [ new_reg ] ) return <NUM_LIT> ; return


<s> if ( funkind ( TREE_TYPE ( current_function_decl ) ) != SUBROUTINE &&

! regs_ever_live [ new_reg ] ) return <NUM_LIT> ;


<s> static void bfin_init_builtins ( void ) { tree void_ftype_void = build_function_type ( void_type_node , void_list_node


<s> static void bfin_internal_label ( FILE * stream , const char * prefix , unsigned long num ) { fprintf ( stream , <STR_LIT> , LOCAL_LABEL_PREFIX , prefix


<s> else addr = gen_rtx_PLUS ( Pmode , pic_offset_table_rtx , gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , const0_rtx ) , UNSPEC_LIBRARY_OFFSET ) ) ; insn = emit_insn ( gen_movsi ( dest , gen_rtx_MEM ( Pmode , addr ) ) ) ; REG_NOTES ( insn ) = gen_rtx_EXPR_LIST ( REG_MAYBE_DEAD , const0_rtx , NULL ) ; return


<s> if ( call_cookie & CALL_LONG ) return <NUM_LIT> ; if ( TARGET_LONG_CALLS ) return <NUM_LIT> ; return


<s> if ( class1 == DREGS && class2 != DREGS ) return <NUM_LIT> * <NUM_LIT> ; return


<s> return size > <NUM_LIT> * UNITS_PER_WORD || size


<s> unsigned HOST_WIDE_INT v = value > <NUM_LIT> ? value : - value ; int sz = GET_MODE_SIZE ( mode ) ; int shift = sz == <NUM_LIT> ? <NUM_LIT> : sz == <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ; unsigned HOST_WIDE_INT mask = sz == <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ; return ( v & ~ ( mask << shift )


<s> static bool bfin_valid_reg_p ( unsigned int regno , int strict ) { return ( ( strict && REGNO_OK_FOR_BASE_STRICT_P ( regno ) ) || ( ! strict && REGNO_OK_FOR_BASE_NONSTRICT_P ( regno


<s> rtx dest ; int dest_uid ; rtx pat = PATTERN ( branch ) ; if ( GET_CODE ( pat ) == PARALLEL ) pat = XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ; dest = SET_SRC ( pat ) ; if ( GET_CODE ( dest ) == IF_THEN_ELSE ) dest = XEXP (


<s> void conditional_register_usage ( void ) { bfin_cc_rtx = gen_rtx_REG ( BImode


<s> bfin_rets_rtx = gen_rtx_REG ( Pmode ,


<s> mode = GET_MODE ( op ) ; op = XEXP ( op , <NUM_LIT> ) ; if ( GET_CODE ( op ) != PLUS ) { gcc_assert ( REG_P ( op ) || GET_CODE ( op ) == POST_INC || GET_CODE ( op ) == PRE_DEC || GET_CODE


<s> rtx insn ; int i ; if ( link_size > <NUM_LIT> ) link_size = <NUM_LIT> ; insn = emit_insn ( gen_link ( GEN_INT ( - <NUM_LIT> - link_size ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; for ( i = <NUM_LIT> ; i < XVECLEN ( PATTERN ( insn ) , <NUM_LIT> ) ; i ++ ) { rtx set = XVECEXP ( PATTERN ( insn ) , <NUM_LIT> , i ) ; gcc_assert ( GET_CODE ( set ) == SET ) ; RTX_FRAME_RELATED_P ( set )


<s> void emit_pic_move ( rtx * operands , enum machine_mode mode ATTRIBUTE_UNUSED ) { rtx temp = reload_in_progress ? operands [ <NUM_LIT> ] : gen_reg_rtx (


<s> else regno = REG_R7 + <NUM_LIT> ; for ( i = <NUM_LIT> ; i < total ; i ++ ) { rtx addr = ( i > <NUM_LIT> ? gen_rtx_PLUS ( Pmode , spreg , GEN_INT ( i * <NUM_LIT> ) ) : spreg ) ; rtx memref = gen_rtx_MEM ( word_mode , addr ) ; regno -- ; XVECEXP ( pat , <NUM_LIT> , i + <NUM_LIT> ) = gen_rtx_SET ( VOIDmode , gen_rtx_REG ( word_mode , regno ) , memref ) ; if ( npregs


<s> for ( i = REG_CC - <NUM_LIT> ; i > REG_P7 ; i -- ) if ( all || regs_ever_live [ i ] || ( ! leaf_function_p ( ) && call_used_regs [ i ] ) ) { if ( i == REG_A0 || i == REG_A1 ) { rtx mem = gen_rtx_MEM ( PDImode , postinc1 ) ; MEM_VOLATILE_P ( mem ) = <NUM_LIT> ; emit_move_insn ( gen_rtx_REG ( PDImode , i ) , mem ) ; } else emit_move_insn ( gen_rtx_REG ( SImode , i ) , postinc ) ; } expand_epilogue_reg_restore ( spreg , all , true ) ; emit_move_insn ( gen_rtx_REG ( SImode , REG_ASTAT )


<s> rtx predec = gen_rtx_MEM ( SImode , predec1 ) ; rtx insn ; tree attrs = TYPE_ATTRIBUTES ( TREE_TYPE ( current_function_decl ) ) ; bool all = lookup_attribute ( <STR_LIT> , attrs ) != NULL_TREE ; tree kspisusp = lookup_attribute ( <STR_LIT> , attrs ) ; if ( kspisusp ) { insn = emit_move_insn ( spreg , gen_rtx_REG ( Pmode , REG_USP ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } if ( fkind == EXCPT_HANDLER ) { insn = emit_insn ( gen_addsi3 ( spreg , spreg , GEN_INT ( - <NUM_LIT> ) ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } insn = emit_move_insn ( predec , gen_rtx_REG ( SImode , REG_ASTAT ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; if ( ! current_function_is_leaf ) all = true ; expand_prologue_reg_save ( spreg , all , true ) ; for ( i = REG_P7 + <NUM_LIT> ; i < REG_CC ; i ++ ) if ( all || regs_ever_live [ i ] || ( ! leaf_function_p ( ) && call_used_regs [ i ] ) ) { if ( i == REG_A0 || i == REG_A1 ) insn = emit_move_insn ( gen_rtx_MEM ( PDImode , predec1 ) , gen_rtx_REG ( PDImode , i ) ) ; else insn = emit_move_insn ( predec , gen_rtx_REG ( SImode , i ) ) ; RTX_FRAME_RELATED_P ( insn ) =


<s> void expand_move ( rtx * operands , enum machine_mode mode ) { if ( flag_pic && SYMBOLIC_CONST ( operands [ <NUM_LIT> ] ) ) emit_pic_move


<s> else if ( ( reload_in_progress | reload_completed ) == <NUM_LIT> && GET_CODE ( operands [ <NUM_LIT> ] ) == MEM && GET_CODE ( operands [ <NUM_LIT> ] ) != REG ) operands [ <NUM_LIT> ] = force_reg (


<s> bytes = ( mode == BLKmode ) ? int_size_in_bytes ( type ) : GET_MODE_SIZE ( mode ) ; words = ( bytes + UNITS_PER_WORD - <NUM_LIT> ) / UNITS_PER_WORD ; cum -> words += words ; cum -> nregs -= words ; if ( cum -> nregs <= <NUM_LIT> ) { cum -> nregs =


<s> if ( lookup_attribute ( <STR_LIT> , attrs ) ) return INTERRUPT_HANDLER ; else if ( lookup_attribute ( <STR_LIT> , attrs ) ) return EXCPT_HANDLER ; else if ( lookup_attribute ( <STR_LIT>


<s> if ( mode == SImode && TEST_HARD_REG_BIT ( reg_class_contents [ PROLOGUE_REGS ] , regno ) ) return <NUM_LIT> ; return TEST_HARD_REG_BIT ( reg_class_contents [ MOST_REGS ]


<s> if ( mode == V2HImode ) return D_REGNO_P ( regno ) ; if ( class == CCREGS ) return mode == BImode ; if ( mode == PDImode ) return regno


<s> rtx legitimize_address ( rtx x ATTRIBUTE_UNUSED , rtx oldx ATTRIBUTE_UNUSED , enum machine_mode mode


<s> rtx legitimize_address ( rtx x ATTRIBUTE_UNUSED , rtx oldx


<s> if ( regs_ever_live [ i ] && ( is_inthandler || ! call_used_regs [ i ] ) ) return REG_R7 - i + <NUM_LIT> ; if ( current_function_calls_eh_return ) { unsigned j ; for ( j = <NUM_LIT> ; ; j ++ ) { unsigned test = EH_RETURN_DATA_REGNO ( j ) ; if ( test == INVALID_REGNUM )


<s> for ( i = REG_P0 ; i <= REG_P5 ; i ++ ) if ( ( regs_ever_live [ i ] && ( is_inthandler || ! call_used_regs [ i ] ) ) || ( i == PIC_OFFSET_TABLE_REGNUM && ( current_function_uses_pic_offset_table || ( TARGET_ID_SHARED_LIBRARY && ! current_function_is_leaf ) ) ) ) return REG_P5 - i + <NUM_LIT> ; return <NUM_LIT>


<s> bool is_inthandler = fkind != SUBROUTINE ; tree attrs = TYPE_ATTRIBUTES ( TREE_TYPE ( current_function_decl ) ) ; bool all = ( lookup_attribute ( <STR_LIT> , attrs ) != NULL_TREE || ( is_inthandler && ! current_function_is_leaf ) ) ; int ndregs = all ? <NUM_LIT> : n_dregs_to_save ( is_inthandler ) ; int npregs = all ? <NUM_LIT> : n_pregs_to_save ( is_inthandler ) ; int n = ndregs + npregs ; if ( all || stack_frame_needed_p ( ) ) n += <NUM_LIT> ; else { if ( must_save_fp_p ( ) ) n ++ ; if ( ! current_function_is_leaf ) n ++ ; } if ( fkind != SUBROUTINE ) { int i ; n ++


<s> bool all = ( lookup_attribute ( <STR_LIT> , attrs ) != NULL_TREE || ( is_inthandler && ! current_function_is_leaf ) ) ; int ndregs = all ? <NUM_LIT> : n_dregs_to_save ( is_inthandler ) ; int npregs = all ? <NUM_LIT> : n_pregs_to_save ( is_inthandler ) ; int n = ndregs + npregs ; if ( all || stack_frame_needed_p ( ) ) n += <NUM_LIT> ; else { if ( must_save_fp_p ( ) ) n ++ ; if ( ! current_function_is_leaf ) n ++ ; } if ( fkind


<s> char buf [ <NUM_LIT> ] ; int ok ; ok = push_multiple_operation ( PATTERN ( insn ) , VOIDmode ) ; gcc_assert ( ok ) ; if ( first_dreg_to_save == <NUM_LIT> ) sprintf ( buf , <STR_LIT> , first_preg_to_save ) ; else if ( first_preg_to_save == <NUM_LIT> ) sprintf ( buf


<s> void override_options ( void ) { if ( TARGET_OMIT_LEAF_FRAME_POINTER ) flag_omit_frame_pointer = <NUM_LIT> ; if ( bfin_lib_id_given && ! TARGET_ID_SHARED_LIBRARY ) error ( <STR_LIT> ) ; if ( TARGET_ID_SHARED_LIBRARY ) flag_pic


<s> if ( i == <NUM_LIT> ) { if ( ! REG_P ( src ) || REGNO ( src ) != REG_SP ) return <NUM_LIT> ; } else if ( GET_CODE ( src ) != PLUS || ! REG_P ( XEXP ( src , <NUM_LIT> ) ) || REGNO ( XEXP ( src , <NUM_LIT> ) ) != REG_SP || GET_CODE ( XEXP ( src , <NUM_LIT> ) ) != CONST_INT || INTVAL ( XEXP ( src , <NUM_LIT> ) ) != ( i - <NUM_LIT> ) * <NUM_LIT> ) return <NUM_LIT> ; regno = REGNO ( dest ) ; if ( group == <NUM_LIT> ) { if ( regno ==


<s> output_address ( XEXP ( x , <NUM_LIT> ) ) ; fprintf ( file , <STR_LIT> ) ; output_address ( XEXP ( x , <NUM_LIT> ) ) ; break ; case PRE_DEC : fprintf ( file , <STR_LIT> ) ; output_address ( XEXP ( x , <NUM_LIT> ) ) ; break ; case POST_INC : output_address ( XEXP ( x , <NUM_LIT>


<s> case GE : fprintf ( file , <STR_LIT> ) ; break ; case LE : fprintf ( file , <STR_LIT> ) ; break ; case GTU : fprintf ( file , <STR_LIT> ) ; break ; case LTU : fprintf ( file , <STR_LIT> ) ; break ; case GEU : fprintf ( file , <STR_LIT> ) ; break ; case LEU : fprintf ( file , <STR_LIT> ) ; break ; default : output_operand_lossage ( <STR_LIT> ) ; } break ; case 'J' : switch ( GET_CODE ( x ) ) { case EQ : fprintf ( file , <STR_LIT> ) ; break ; case NE : fprintf ( file , <STR_LIT> ) ; break ; case GT : fprintf ( file , <STR_LIT> ) ; break ; case LT : fprintf ( file , <STR_LIT> ) ; break ; case GE : fprintf ( file , <STR_LIT> ) ; break ; case LE : fprintf ( file , <STR_LIT> ) ; break ; case GTU : fprintf ( file , <STR_LIT> ) ; break ; case LTU : fprintf ( file , <STR_LIT> ) ; break ; case GEU : fprintf ( file , <STR_LIT> ) ; break ; case LEU : fprintf ( file , <STR_LIT> ) ; break ; default : output_operand_lossage ( <STR_LIT> ) ; } break ; default : switch ( GET_CODE ( x ) ) { case REG : if ( code == 'h' ) { gcc_assert ( REGNO ( x ) < <NUM_LIT> ) ; fprintf ( file , <STR_LIT> , short_reg_names [ REGNO ( x ) ] ) ; break ; } else if ( code == 'd' ) { gcc_assert ( REGNO ( x ) < <NUM_LIT> ) ; fprintf ( file , <STR_LIT> , high_reg_names [ REGNO ( x ) ] ) ; break ; } else if ( code == 'w' ) { gcc_assert ( REGNO ( x ) == REG_A0 || REGNO ( x )


<s> gcc_assert ( REGNO ( x ) == REG_A0 || REGNO ( x ) == REG_A1 ) ; fprintf ( file , <STR_LIT> , reg_names [ REGNO ( x ) ] ) ; } else if ( code == 'x' ) { gcc_assert ( REGNO ( x ) == REG_A0 || REGNO ( x ) == REG_A1 ) ; fprintf ( file , <STR_LIT> , reg_names [ REGNO ( x ) ] ) ; } else if ( code == 'D' ) { fprintf ( file , <STR_LIT> , dregs_pair_names [ REGNO ( x ) ] ) ; } else if ( code == 'H' ) { gcc_assert ( mode == DImode || mode == DFmode ) ; gcc_assert ( REG_P ( x ) ) ; fprintf ( file , <STR_LIT> , reg_names [ REGNO ( x ) + <NUM_LIT> ] ) ; } else if ( code == 'T' ) { gcc_assert ( D_REGNO_P ( REGNO ( x ) ) ) ; fprintf ( file , <STR_LIT> , byte_reg_names [ REGNO ( x ) ] ) ; } else fprintf ( file , <STR_LIT> , reg_names [ REGNO ( x ) ] ) ; break ; case MEM : fputc ( '[' , file ) ; x = XEXP ( x , <NUM_LIT> ) ; print_address_operand ( file , x ) ; fputc ( ']' , file ) ; break ; case CONST_INT : if ( code == 'd' ) x = GEN_INT ( ( INTVAL ( x ) >> <NUM_LIT> ) & <NUM_LIT> ) ; else if ( code == 'h' ) x = GEN_INT ( INTVAL ( x ) & <NUM_LIT> ) ; else if ( code == 'X' ) x = GEN_INT ( exact_log2 ( <NUM_LIT> & INTVAL ( x ) ) ) ; else if ( code == 'Y' ) x = GEN_INT ( exact_log2 ( <NUM_LIT> & ~ INTVAL ( x ) ) ) ; else if ( code == 'Z' ) x = GEN_INT ( - <NUM_LIT> - INTVAL ( x ) ) ; case


<s> first_dreg_to_save = lastdreg ; for ( i = <NUM_LIT> , group = <NUM_LIT> ; i < XVECLEN ( op , <NUM_LIT> ) - <NUM_LIT> ; i ++ ) { rtx t = XVECEXP ( op , <NUM_LIT> , i ) ; rtx src , dest ; int regno ; if ( GET_CODE ( t ) != SET ) return <NUM_LIT> ; src = SET_SRC ( t ) ; dest = SET_DEST ( t ) ; if ( GET_CODE ( dest ) != MEM || ! REG_P ( src ) ) return <NUM_LIT> ; dest = XEXP ( dest , <NUM_LIT> ) ; if ( GET_CODE ( dest ) != PLUS || ! REG_P ( XEXP ( dest , <NUM_LIT> ) ) || REGNO ( XEXP ( dest , <NUM_LIT> ) ) != REG_SP || GET_CODE ( XEXP ( dest , <NUM_LIT> ) ) != CONST_INT || INTVAL ( XEXP ( dest , <NUM_LIT> ) ) != - i * <NUM_LIT> ) return <NUM_LIT> ; regno = REGNO ( src ) ; if ( group == <NUM_LIT> ) { if ( D_REGNO_P ( regno ) ) { group = <NUM_LIT> ; first_dreg_to_save = lastdreg = regno - REG_R0 ; } else if ( regno >= REG_P0 && regno <= REG_P7 ) { group = <NUM_LIT> ; first_preg_to_save = lastpreg = regno - REG_P0 ; } else return <NUM_LIT> ; continue ; } if ( group == <NUM_LIT> ) { if ( regno >= REG_P0 && regno <= REG_P7 ) { group = <NUM_LIT> ; first_preg_to_save = lastpreg = regno - REG_P0 ; } else if ( regno != REG_R0 + lastdreg + <NUM_LIT> ) return <NUM_LIT> ; else lastdreg


<s> } if ( fp_plus_const_operand ( x , mode ) ) { rtx op2 = XEXP ( x , <NUM_LIT> ) ; int large_constant_p = ! CONST_7BIT_IMM_P ( INTVAL ( op2 ) ) ; if ( class == PREGS || class == PREGS_CLOBBERED ) return NO_REGS ; if ( class == DREGS || class == DPREGS ) return large_constant_p ? PREGS : NO_REGS ; return PREGS ; } if ( x_class == AREGS ) return class == DREGS || class == AREGS ? NO_REGS : DREGS ; if ( class == AREGS ) { if ( x != const0_rtx && x_class != DREGS ) return DREGS ; else return NO_REGS ; } if ( class == CCREGS && x_class != DREGS ) return DREGS ; if ( x_class == CCREGS && class !=


<s> if ( class == PREGS || class == PREGS_CLOBBERED ) return NO_REGS ; if ( class == DREGS || class == DPREGS ) return large_constant_p ? PREGS : NO_REGS ; return PREGS ; } if ( x_class == AREGS ) return class == DREGS || class == AREGS ? NO_REGS : DREGS ; if ( class == AREGS ) { if ( x != const0_rtx && x_class != DREGS ) return DREGS ; else return NO_REGS ; } if ( class == CCREGS && x_class != DREGS ) return DREGS ; if ( x_class == CCREGS && class != DREGS ) return DREGS ; if ( code == MEM ) if ( ! reg_class_subset_p ( class , default_class


<s> return secondary_input_reload_class ( class , mode , x


<s> static void setup_incoming_varargs ( CUMULATIVE_ARGS * cum , enum machine_mode mode ATTRIBUTE_UNUSED , tree type ATTRIBUTE_UNUSED , int * pretend_size , int no_rtl ) { rtx mem ; int i ; if ( no_rtl ) return ; for ( i = cum -> words + <NUM_LIT> ; i < max_arg_registers ; i ++ ) { mem = gen_rtx_MEM ( Pmode , plus_constant ( arg_pointer_rtx , ( i * UNITS_PER_WORD ) ) ) ; emit_move_insn ( mem , gen_rtx_REG ( Pmode , i ) ) ; } * pretend_size


<s> static void single_move_for_strmov ( rtx dst , rtx src , enum machine_mode mode , HOST_WIDE_INT offset ) { rtx scratch = gen_reg_rtx ( mode ) ; rtx srcmem , dstmem ; srcmem = adjust_address_nv ( src , mode , offset ) ; dstmem = adjust_address_nv ( dst , mode


<s> static bool stack_frame_needed_p ( void ) { if ( current_function_calls_eh_return ) return


<s> if ( any_condjump_p ( insn ) && ! cbranch_predicted_taken_p ( insn ) ) { rtx n = next_real_insn ( insn ) ; emit_insn_before ( gen_stall ( GEN_INT ( <NUM_LIT> ) ) , n ) ; } } } for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) { if ( JUMP_P ( insn ) && any_condjump_p ( insn ) && ( cbranch_predicted_taken_p (


<s> if ( value > <NUM_LIT> || value < - <NUM_LIT> ) { rtx tmpreg ; rtx tmpreg2 ; rtx_insn * insn ; tmpreg2 = NULL_RTX ; if ( epilogue_p >= <NUM_LIT> ) tmpreg = gen_rtx_REG ( SImode , REG_P1 ) ; else { int i ; for ( i = REG_P0 ; i <= REG_P5 ; i ++ ) if ( ( df_regs_ever_live_p ( i ) && ! call_used_regs [ i ] ) || ( ! TARGET_FDPIC && i == PIC_OFFSET_TABLE_REGNUM && ( crtl -> uses_pic_offset_table || ( TARGET_ID_SHARED_LIBRARY && ! crtl -> is_leaf ) ) ) ) break ; if ( i <= REG_P5 ) tmpreg = gen_rtx_REG ( SImode , i ) ; else { tmpreg = gen_rtx_REG ( SImode , REG_P1 ) ; tmpreg2 = gen_rtx_REG ( SImode , REG_I0 ) ; emit_move_insn ( tmpreg2 , tmpreg ) ; } } if ( frame ) frame_related_constant_load ( tmpreg , value , TRUE ) ; else insn = emit_move_insn ( tmpreg , GEN_INT ( value ) ) ; insn = emit_insn ( gen_addsi3 ( reg , reg , tmpreg ) ) ; if ( frame ) RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; if ( tmpreg2 != NULL_RTX ) emit_move_insn ( tmpreg , tmpreg2 ) ; } else do { int size = value ; rtx_insn * insn ; if ( size > <NUM_LIT> ) size = <NUM_LIT> ; else if ( size < - <NUM_LIT> ) size = - <NUM_LIT> ; insn = emit_insn ( gen_addsi3 ( reg , reg , GEN_INT ( size ) ) ) ; if ( frame ) RTX_FRAME_RELATED_P ( insn )


<s> enum attr_type dep_insn_type ; int dep_insn_code_number ; if ( REG_NOTE_KIND ( link ) != <NUM_LIT> ) return <NUM_LIT> ; dep_insn_code_number = recog_memoized ( dep_insn ) ; if ( dep_insn_code_number < <NUM_LIT> || recog_memoized ( insn ) < <NUM_LIT> ) return cost ; dep_insn_type = get_attr_type ( dep_insn ) ; if ( dep_insn_type == TYPE_MOVE || dep_insn_type == TYPE_MCLD ) { rtx pat = PATTERN ( dep_insn ) ; rtx dest , src ; if ( GET_CODE ( pat ) == PARALLEL ) pat = XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ; dest = SET_DEST ( pat ) ; src = SET_SRC ( pat ) ; if ( ! ADDRESS_REGNO_P ( REGNO ( dest ) ) || ! ( MEM_P ( src ) || D_REGNO_P ( REGNO ( src ) ) ) ) return cost ; return cost + ( dep_insn_type == TYPE_MOVE ? <NUM_LIT>


<s> static bool bfin_can_use_doloop_p ( const widest_int & , const widest_int & iterations_max , unsigned int , bool ) { if ( ! flag_unsafe_loop_optimizations && wi :: geu_p ( iterations_max , <NUM_LIT> ) ) return false ; return


<s> void bfin_expand_call ( rtx retval , rtx fnaddr , rtx callarg1 , rtx cookie , int sibcall ) { rtx use = NULL , call ; rtx callee = XEXP ( fnaddr , <NUM_LIT> ) ; int nelts = <NUM_LIT> ; rtx pat ; rtx picreg = get_hard_reg_initial_val ( SImode , FDPIC_REGNO ) ; rtx retsreg = gen_rtx_REG ( Pmode , REG_RETS ) ; int n ; if ( cookie == NULL_RTX ) cookie = const0_rtx ; if ( ! TARGET_FDPIC && flag_pic && GET_CODE ( callee ) == SYMBOL_REF && ! SYMBOL_REF_LOCAL_P ( callee ) ) use_reg ( & use , pic_offset_table_rtx ) ; if ( TARGET_FDPIC ) { int caller_in_sram , callee_in_sram ; caller_in_sram = callee_in_sram = <NUM_LIT> ; if ( lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( cfun -> decl ) ) != NULL_TREE ) caller_in_sram = <NUM_LIT> ; else if ( lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( cfun -> decl ) ) != NULL_TREE ) caller_in_sram = <NUM_LIT> ; if ( GET_CODE ( callee ) == SYMBOL_REF && SYMBOL_REF_DECL ( callee ) && DECL_P ( SYMBOL_REF_DECL ( callee ) ) ) { if ( lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( SYMBOL_REF_DECL ( callee ) ) ) != NULL_TREE ) callee_in_sram = <NUM_LIT> ; else if ( lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( SYMBOL_REF_DECL ( callee ) ) ) != NULL_TREE ) callee_in_sram = <NUM_LIT> ; } if ( GET_CODE ( callee ) != SYMBOL_REF || bfin_longcall_p ( callee , INTVAL ( cookie ) ) || ( GET_CODE ( callee ) == SYMBOL_REF && ! SYMBOL_REF_LOCAL_P ( callee ) && TARGET_INLINE_PLT ) || caller_in_sram != callee_in_sram || ( caller_in_sram && callee_in_sram && ( GET_CODE ( callee ) != SYMBOL_REF || ! SYMBOL_REF_LOCAL_P ( callee ) ) ) ) { rtx addr = callee ; if ( ! address_operand ( addr , Pmode ) ) addr = force_reg ( Pmode , addr ) ; fnaddr = gen_reg_rtx ( SImode ) ; emit_insn ( gen_load_funcdescsi ( fnaddr , addr ) ) ; fnaddr = gen_rtx_MEM ( Pmode , fnaddr ) ; picreg = gen_reg_rtx ( SImode ) ; emit_insn ( gen_load_funcdescsi ( picreg , plus_constant ( Pmode , addr , <NUM_LIT> ) ) ) ; } nelts ++ ; } else if ( ( ! register_no_elim_operand ( callee , Pmode ) && GET_CODE ( callee ) != SYMBOL_REF ) || ( GET_CODE ( callee ) == SYMBOL_REF && ( ( TARGET_ID_SHARED_LIBRARY && ! TARGET_LEAF_ID_SHARED_LIBRARY ) || bfin_longcall_p ( callee , INTVAL ( cookie ) ) ) ) ) { callee = copy_to_mode_reg ( Pmode , callee ) ; fnaddr = gen_rtx_MEM ( Pmode


<s> } if ( crtl -> limit_stack || ( TARGET_STACK_CHECK_L1 && ! DECL_NO_LIMIT_STACK ( current_function_decl ) ) ) { HOST_WIDE_INT offset = bfin_initial_elimination_offset ( ARG_POINTER_REGNUM , STACK_POINTER_REGNUM ) ; rtx lim = crtl -> limit_stack ? stack_limit_rtx : NULL_RTX ; rtx tmp = gen_rtx_REG ( Pmode , REG_R3 ) ; rtx p2reg = gen_rtx_REG ( Pmode , REG_P2 ) ; emit_move_insn ( tmp , p2reg ) ; if ( ! lim ) { emit_move_insn ( p2reg , gen_int_mode ( <NUM_LIT> , SImode ) ) ; emit_move_insn ( p2reg , gen_rtx_MEM ( Pmode , p2reg ) ) ; lim = p2reg ; } if ( GET_CODE ( lim ) == SYMBOL_REF ) { if ( TARGET_ID_SHARED_LIBRARY ) { rtx p1reg = gen_rtx_REG ( Pmode , REG_P1 ) ; rtx val ; pic_reg_loaded = bfin_load_pic_reg ( p2reg ) ; val = legitimize_pic_address ( stack_limit_rtx , p1reg , pic_reg_loaded ) ; emit_move_insn ( p1reg , val ) ; frame_related_constant_load ( p2reg , offset , FALSE ) ; emit_insn ( gen_addsi3 ( p2reg , p2reg , p1reg )


<s> static bool bfin_function_ok_for_sibcall ( tree decl ATTRIBUTE_UNUSED , tree exp ATTRIBUTE_UNUSED ) { struct cgraph_local_info * this_func , * called_func ; e_funkind fkind = funkind ( TREE_TYPE ( current_function_decl


<s> struct cgraph_local_info * this_func , * called_func ; e_funkind fkind = funkind ( TREE_TYPE ( current_function_decl ) ) ; if ( fkind != SUBROUTINE ) return false ; if ( ! TARGET_ID_SHARED_LIBRARY || TARGET_SEP_DATA ) return true ; if ( ! decl )


<s> slot [ <NUM_LIT> ] = slot [ <NUM_LIT> ] = slot [ <NUM_LIT> ] = NULL ; for ( insn = BB_HEAD ( bb ) ; ; insn = next ) { int at_end ; rtx delete_this = NULL_RTX ; if ( NONDEBUG_INSN_P ( insn ) ) { enum attr_type type = get_attr_type ( insn ) ; if ( type == TYPE_STALL ) { gcc_assert ( n_filled == <NUM_LIT> ) ; delete_this = insn ; } else { if ( type == TYPE_DSP32 || type == TYPE_DSP32SHIFTIMM ) slot [ <NUM_LIT> ] = insn ; else if ( slot [ <NUM_LIT> ] == NULL_RTX ) slot [ <NUM_LIT> ] = insn ; else slot [ <NUM_LIT> ] = insn ; n_filled ++ ; } } next = NEXT_INSN ( insn ) ; while ( next && insn != BB_END ( bb ) && ! ( INSN_P ( next ) && GET_CODE ( PATTERN ( next ) ) != USE && GET_CODE ( PATTERN ( next ) ) != CLOBBER ) ) { insn = next ; next = NEXT_INSN (


<s> if ( type == TYPE_DSP32 || type == TYPE_DSP32SHIFTIMM ) slot [ <NUM_LIT> ] = insn ; else if ( slot [ <NUM_LIT> ] == NULL_RTX ) slot [ <NUM_LIT> ] = insn ; else slot [ <NUM_LIT> ] = insn ; n_filled ++ ; } } next = NEXT_INSN ( insn ) ; while ( next && insn != BB_END ( bb ) && ! ( INSN_P ( next ) && GET_CODE ( PATTERN ( next ) ) != USE && GET_CODE ( PATTERN ( next ) ) != CLOBBER ) ) { insn = next ; next = NEXT_INSN ( insn ) ; } at_end = insn == BB_END ( bb ) ; if ( delete_this == NULL_RTX && ( at_end || GET_MODE ( next ) == TImode ) ) { if ( ( n_filled < <NUM_LIT> || ! gen_one_bundle ( slot ) ) && slot [ <NUM_LIT> ] != NULL_RTX ) { rtx pat = PATTERN ( slot [ <NUM_LIT> ]


<s> break ; case PLUS : if ( REG_P ( XEXP ( x , <NUM_LIT> ) ) && bfin_valid_reg_p ( REGNO ( XEXP ( x , <NUM_LIT> ) ) , strict , mode , PLUS ) && ( ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == UNSPEC && mode == SImode ) || ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == CONST_INT && bfin_valid_add ( mode , INTVAL ( XEXP ( x , <NUM_LIT> ) ) ) ) ) ) return true ; break ; case POST_INC : case POST_DEC : if ( LEGITIMATE_MODE_FOR_AUTOINC_P ( mode ) && REG_P ( XEXP ( x , <NUM_LIT> ) ) && bfin_valid_reg_p ( REGNO ( XEXP ( x , <NUM_LIT> ) ) , strict , mode , POST_INC ) ) return true ; case


<s> struct cgraph_local_info * i = NULL ; rtx addr ; i = cgraph_node :: local_info ( current_function_decl ) ; if ( i && i -> local ) return pic_offset_table_rtx ; if ( global_options_set . x_bfin_library_id ) addr = plus_constant ( Pmode , pic_offset_table_rtx , - <NUM_LIT>


<s> if ( stack_limit_rtx && TARGET_FDPIC ) { warning ( <NUM_LIT> , <STR_LIT> ) ; stack_limit_rtx = NULL_RTX ; } if ( stack_limit_rtx && TARGET_STACK_CHECK_L1 ) error ( <STR_LIT> ) ; if ( TARGET_ID_SHARED_LIBRARY && TARGET_FDPIC ) error ( <STR_LIT> ) ; if ( TARGET_SEP_DATA && TARGET_ID_SHARED_LIBRARY ) error ( <STR_LIT> ) ; if ( TARGET_SEP_DATA ) target_flags |= MASK_ID_SHARED_LIBRARY | MASK_LEAF_ID_SHARED_LIBRARY ; if ( TARGET_ID_SHARED_LIBRARY && flag_pic == <NUM_LIT> ) flag_pic = <NUM_LIT> ; if ( TARGET_FDPIC ) targetm . asm_out . unaligned_op . si = <NUM_LIT> ; if ( flag_pic && ! TARGET_FDPIC && ! TARGET_ID_SHARED_LIBRARY ) flag_pic = <NUM_LIT> ; if ( TARGET_MULTICORE && bfin_cpu_type != BFIN_CPU_BF561 ) error ( <STR_LIT> ) ; if ( TARGET_COREA && ! TARGET_MULTICORE ) error ( <STR_LIT> ) ; if ( TARGET_COREB && ! TARGET_MULTICORE ) error ( <STR_LIT> ) ; if ( TARGET_COREA && TARGET_COREB ) error ( <STR_LIT> ) ; flag_schedule_insns =


<s> for ( i = <NUM_LIT> ; bfin_cpus [ i ] . name != NULL ; i ++ ) bfin_workarounds |= bfin_cpus [ i ] . workarounds ; bfin_si_revision = <NUM_LIT> ; } if ( bfin_csync_anomaly == <NUM_LIT> ) bfin_workarounds |= WA_SPECULATIVE_SYNCS ; else if ( bfin_csync_anomaly == <NUM_LIT> ) bfin_workarounds &= ~ WA_SPECULATIVE_SYNCS ; if ( bfin_specld_anomaly == <NUM_LIT> ) bfin_workarounds |= WA_SPECULATIVE_LOADS ; else if ( bfin_specld_anomaly == <NUM_LIT> ) bfin_workarounds &= ~ WA_SPECULATIVE_LOADS ; if ( TARGET_OMIT_LEAF_FRAME_POINTER ) flag_omit_frame_pointer = <NUM_LIT> ; if ( TARGET_FDPIC ) error ( <STR_LIT> ) ; if ( global_options_set . x_bfin_library_id && ! TARGET_ID_SHARED_LIBRARY ) error ( <STR_LIT> ) ; if ( stack_limit_rtx && TARGET_FDPIC ) { warning ( <NUM_LIT> , <STR_LIT> ) ; stack_limit_rtx = NULL_RTX ; } if ( stack_limit_rtx && TARGET_STACK_CHECK_L1 ) error ( <STR_LIT> ) ; if ( TARGET_ID_SHARED_LIBRARY && TARGET_FDPIC ) error ( <STR_LIT> ) ; if ( TARGET_SEP_DATA && TARGET_ID_SHARED_LIBRARY ) error ( <STR_LIT> ) ; if ( TARGET_SEP_DATA ) target_flags |= MASK_ID_SHARED_LIBRARY | MASK_LEAF_ID_SHARED_LIBRARY ; if ( TARGET_ID_SHARED_LIBRARY && flag_pic == <NUM_LIT> ) flag_pic = <NUM_LIT> ; if ( TARGET_FDPIC ) targetm . asm_out . unaligned_op . si = <NUM_LIT> ; if ( flag_pic && ! TARGET_FDPIC && ! TARGET_ID_SHARED_LIBRARY ) flag_pic = <NUM_LIT> ; if ( TARGET_MULTICORE && bfin_cpu_type != BFIN_CPU_BF561 ) error ( <STR_LIT> ) ; if ( TARGET_COREA && ! TARGET_MULTICORE ) error ( <STR_LIT> ) ; if ( TARGET_COREB && ! TARGET_MULTICORE ) error (


<s> MEM_VOLATILE_P ( postinc ) = <NUM_LIT> ; for ( i = REG_CC - <NUM_LIT> ; i > REG_P7 ; i -- ) if ( saveall || ( is_inthandler && ( df_regs_ever_live_p ( i ) || ( ! leaf_function_p ( ) && call_used_regs [ i ] ) ) ) ) { if ( i == REG_A0 || i == REG_A1 ) { rtx mem = gen_rtx_MEM ( PDImode , postinc1 ) ; MEM_VOLATILE_P ( mem ) = <NUM_LIT> ; emit_move_insn ( gen_rtx_REG ( PDImode , i ) , mem ) ; } else emit_move_insn ( gen_rtx_REG ( SImode , i ) , postinc ) ; } regno = REG_P5 - npregs_consec ; for ( ; npregs != npregs_consec ; regno -- ) { if ( must_save_p ( is_inthandler , regno ) ) { emit_move_insn ( gen_rtx_REG ( word_mode , regno ) , postinc ) ; npregs -- ; } } regno = REG_R7 - ndregs_consec ; for ( ; ndregs != ndregs_consec ; regno -- ) { if ( must_save_p ( is_inthandler , regno ) ) { emit_move_insn ( gen_rtx_REG ( word_mode , regno ) , postinc ) ; ndregs


<s> rtx_insn * insn ; rtx val = GEN_INT ( - total_consec * <NUM_LIT> ) ; rtx pat = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( total_consec + <NUM_LIT> ) ) ; XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_UNSPEC ( VOIDmode , gen_rtvec ( <NUM_LIT> , val ) , UNSPEC_PUSH_MULTIPLE ) ; XVECEXP ( pat , <NUM_LIT> , total_consec + <NUM_LIT> ) = gen_rtx_SET ( VOIDmode , spreg , gen_rtx_PLUS ( Pmode , spreg , val ) ) ; RTX_FRAME_RELATED_P ( XVECEXP ( pat , <NUM_LIT> , total_consec + <NUM_LIT> ) ) = <NUM_LIT> ; d_to_save = ndregs_consec ; dregno = REG_R7 + <NUM_LIT> - ndregs_consec ; pregno = REG_P5 + <NUM_LIT> - npregs_consec ; for ( i = <NUM_LIT> ; i < total_consec ; i ++ ) { rtx memref = gen_rtx_MEM ( word_mode , gen_rtx_PLUS ( Pmode , spreg , GEN_INT ( - i * <NUM_LIT> - <NUM_LIT> ) ) ) ; rtx subpat ; if ( d_to_save > <NUM_LIT> ) { subpat = gen_rtx_SET ( VOIDmode , memref , gen_rtx_REG ( word_mode , dregno ++ ) ) ; d_to_save -- ; } else { subpat = gen_rtx_SET ( VOIDmode , memref , gen_rtx_REG ( word_mode , pregno ++ ) ) ; } XVECEXP ( pat , <NUM_LIT> , i + <NUM_LIT> ) = subpat ; RTX_FRAME_RELATED_P ( subpat ) = <NUM_LIT> ; } insn = emit_insn ( pat ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } for ( dregno = REG_R0 ; ndregs != ndregs_consec ; dregno ++ ) { if ( must_save_p ( is_inthandler , dregno ) ) { rtx_insn * insn = emit_move_insn ( predec , gen_rtx_REG ( word_mode , dregno ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; ndregs -- ; } } for ( pregno = REG_P0 ; npregs != npregs_consec ; pregno ++ ) { if ( must_save_p ( is_inthandler , pregno ) ) { rtx_insn * insn = emit_move_insn ( predec , gen_rtx_REG ( word_mode , pregno ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; npregs -- ; } } for ( i = REG_P7 + <NUM_LIT> ; i < REG_CC ; i ++ ) if ( saveall || ( is_inthandler && ( df_regs_ever_live_p ( i ) || (

! leaf_function_p ( ) && call_used_regs [ i ] ) ) ) ) {


<s> else if ( slot [ <NUM_LIT> ] == NULL_RTX ) slot [ <NUM_LIT> ] = insn ; else slot [ <NUM_LIT> ] = insn ; n_filled ++ ; } } next = NEXT_INSN ( insn ) ; while ( next && insn != BB_END ( bb ) && ! ( INSN_P ( next ) && GET_CODE ( PATTERN ( next ) ) != USE && GET_CODE ( PATTERN ( next ) ) != CLOBBER ) ) { insn = next ; next = NEXT_INSN ( insn ) ; } at_end = insn == BB_END ( bb ) ; if ( delete_this == NULL_RTX && ( at_end || GET_MODE ( next


<s> if ( rclass == CCREGS ) return mode == BImode ; if ( mode == PDImode || mode == V2PDImode ) return regno == REG_A0 || regno == REG_A1 ; if ( mode == DImode )


<s> if ( crtl -> calls_eh_return ) { unsigned j ; for ( j = <NUM_LIT> ; ; j ++ ) { unsigned test = EH_RETURN_DATA_REGNO ( j ) ; if ( test == INVALID_REGNUM ) break ; if ( test == regno ) is_eh_return_reg = true ; } } return ( is_eh_return_reg || ( df_regs_ever_live_p ( regno ) && ! fixed_regs [ regno ] && ( is_inthandler || ! call_used_regs [ regno ] ) ) ) ; } else if ( P_REGNO_P ( regno ) ) { return ( ( df_regs_ever_live_p ( regno ) && ! fixed_regs [ regno ] && ( is_inthandler || ! call_used_regs [ regno ] ) ) || ( is_inthandler && ( ENABLE_WA_05000283 || ENABLE_WA_05000315 ) && regno == REG_P5 ) || ( ! TARGET_FDPIC && regno == PIC_OFFSET_TABLE_REGNUM && (

crtl -> uses_pic_offset_table || ( TARGET_ID_SHARED_LIBRARY && ! crtl -> is_leaf ) ) ) ) ;


<s> rtx mem ; int i ; if ( no_rtl ) return ; for ( i = get_cumulative_args ( cum ) -> words

+ <NUM_LIT> ; i < max_arg_registers ; i ++ ) {


<s> for ( i = get_cumulative_args ( cum ) -> words + <NUM_LIT> ; i < max_arg_registers ; i ++ ) { mem = gen_rtx_MEM ( Pmode , plus_constant ( Pmode , arg_pointer_rtx , ( i * UNITS_PER_WORD ) ) ) ; emit_move_insn ( mem , gen_rtx_REG ( Pmode , i ) ) ; } * pretend_size = <NUM_LIT>


<s> srcmem = adjust_address_nv ( src , mode , offset ) ; dstmem = adjust_address_nv ( dst


<s> ndregs -- ; } } if ( total_consec != <NUM_LIT> ) { rtx pat = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( total_consec + <NUM_LIT> ) ) ; XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_SET ( spreg , gen_rtx_PLUS ( Pmode , spreg , GEN_INT ( total_consec * <NUM_LIT> ) ) ) ; if ( npregs_consec > <NUM_LIT> ) regno = REG_P5 + <NUM_LIT> ; else regno = REG_R7 + <NUM_LIT> ; for ( i = <NUM_LIT> ; i < total_consec ; i ++ ) { rtx addr = ( i > <NUM_LIT> ? gen_rtx_PLUS ( Pmode , spreg , GEN_INT ( i * <NUM_LIT> ) ) : spreg ) ; rtx memref = gen_rtx_MEM ( word_mode , addr ) ; regno -- ; XVECEXP ( pat , <NUM_LIT> , i + <NUM_LIT> ) = gen_rtx_SET ( gen_rtx_REG ( word_mode , regno ) , memref ) ; if ( npregs_consec > <NUM_LIT> ) { if ( -- npregs_consec == <NUM_LIT> ) regno = REG_R7 + <NUM_LIT> ; } } insn = emit_insn ( pat ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } if ( saveall || is_inthandler ) { for ( regno = REG_LB1 ; regno >= REG_LT0 ; regno -- ) if ( ! crtl -> is_leaf || cfun -> machine -> has_hardware_loops || cfun -> machine -> has_loopreg_clobber || ( ENABLE_WA_05000257 && ( regno == REG_LC0 || regno == REG_LC1 ) ) ) emit_move_insn ( gen_rtx_REG ( SImode , regno ) , postinc ) ; emit_move_insn ( gen_rtx_REG ( SImode , REG_ASTAT )


<s> initialize_trampoline ( TRAMP , FNADDR , CXT ) { { ARG_POINTER_REGNUM , STACK_POINTER_REGNUM } , \ { ARG_POINTER_REGNUM , FRAME_POINTER_REGNUM

} , \ { FRAME_POINTER_REGNUM , STACK_POINTER_REGNUM } }


<s> initialize_trampoline ( TRAMP , FNADDR , CXT ) { { ARG_POINTER_REGNUM , STACK_POINTER_REGNUM } , \ { ARG_POINTER_REGNUM , FRAME_POINTER_REGNUM } , \ { FRAME_POINTER_REGNUM


<s> rtx_insn * insn , * next ; rtx_insn * last_condjump = NULL ; int cycles_since_jump = INT_MAX ; int delay_added = <NUM_LIT> ; if ( ! ENABLE_WA_SPECULATIVE_LOADS && ! ENABLE_WA_SPECULATIVE_SYNCS && ! ENABLE_WA_INDIRECT_CALLS ) return ; for ( insn = get_insns ( ) ; insn ; insn = next ) { rtx pat ; int delay_needed = <NUM_LIT> ; next = find_next_insn_start ( insn ) ; if ( NOTE_P ( insn ) || BARRIER_P ( insn ) ) continue ; if ( JUMP_TABLE_DATA_P ( insn ) ) continue ; if ( LABEL_P ( insn ) ) { np_check_regno = - <NUM_LIT> ; continue ; } pat = PATTERN ( insn ) ; if ( GET_CODE ( pat ) == USE || GET_CODE ( pat ) == CLOBBER ) continue ; if ( GET_CODE ( pat ) == ASM_INPUT || asm_noperands ( pat ) >= <NUM_LIT> ) { np_check_regno = - <NUM_LIT> ; continue ; } if ( JUMP_P ( insn ) ) { if ( np_check_regno != - <NUM_LIT> && recog_memoized ( insn ) == CODE_FOR_cbranchbi4 ) { rtx op = XEXP ( SET_SRC ( PATTERN ( insn ) ) , <NUM_LIT> ) ; gcc_assert ( GET_CODE ( op ) == EQ || GET_CODE ( op ) == NE ) ; if ( GET_CODE ( op ) == NE ) np_after_branch = true ; } if ( any_condjump_p ( insn ) && ! cbranch_predicted_taken_p ( insn ) ) { last_condjump = insn ; delay_added = <NUM_LIT> ; cycles_since_jump = <NUM_LIT> ; } else cycles_since_jump = INT_MAX ; } else if ( CALL_P ( insn ) ) { np_check_regno = - <NUM_LIT> ; if ( cycles_since_jump < INT_MAX ) cycles_since_jump ++ ; if ( indirect_call_p ( pat ) && ENABLE_WA_INDIRECT_CALLS ) { delay_needed = <NUM_LIT> ; } } else if ( NONDEBUG_INSN_P ( insn ) ) { rtx_insn * load_insn = find_load ( insn ) ; enum attr_type type = type_for_anomaly ( insn ) ; if ( cycles_since_jump < INT_MAX ) cycles_since_jump ++ ; if ( recog_memoized ( insn ) == CODE_FOR_compare_eq ) { rtx src = SET_SRC ( PATTERN ( insn ) ) ; if ( REG_P ( XEXP ( src , <NUM_LIT> ) ) && P_REGNO_P ( REGNO ( XEXP ( src , <NUM_LIT> ) ) ) && XEXP ( src , <NUM_LIT> ) == const0_rtx ) { np_check_regno = REGNO ( XEXP ( src , <NUM_LIT> ) ) ; np_after_branch = false ; } else np_check_regno = - <NUM_LIT> ; } if ( load_insn


<s> int analyze_pop_multiple_operation ( rtx op ) { int lastdreg = <NUM_LIT> , lastpreg = <NUM_LIT> ; int i , group ; for ( i = <NUM_LIT> , group = <NUM_LIT> ; i < XVECLEN ( op , <NUM_LIT> ) ; i ++ ) { rtx t = XVECEXP ( op , <NUM_LIT> , i ) ; rtx src , dest ; int regno ; if ( GET_CODE ( t ) != SET ) return <NUM_LIT> ; src = SET_SRC ( t ) ; dest = SET_DEST ( t ) ; if ( GET_CODE ( src ) != MEM || ! REG_P ( dest ) ) return <NUM_LIT> ; src = XEXP ( src , <NUM_LIT> ) ; if ( i == <NUM_LIT> ) { if ( ! REG_P ( src ) || REGNO ( src ) != REG_SP ) return <NUM_LIT> ; } else if ( GET_CODE ( src ) != PLUS || ! REG_P ( XEXP ( src , <NUM_LIT> ) ) || REGNO ( XEXP ( src , <NUM_LIT> ) ) != REG_SP || GET_CODE ( XEXP ( src , <NUM_LIT> ) ) != CONST_INT || INTVAL ( XEXP ( src , <NUM_LIT> ) ) != ( i - <NUM_LIT> ) * <NUM_LIT> ) return <NUM_LIT> ; regno = REGNO ( dest ) ; if ( group == <NUM_LIT> ) { if ( regno == REG_R7 ) { group = <NUM_LIT> ; lastdreg = <NUM_LIT> ; } else if ( regno != REG_P0 + lastpreg - <NUM_LIT> ) return <NUM_LIT> ; else lastpreg -- ; } else if ( group == <NUM_LIT>


<s> } else if ( GET_CODE ( src ) != PLUS || ! REG_P ( XEXP ( src , <NUM_LIT> ) ) || REGNO ( XEXP ( src , <NUM_LIT> ) ) != REG_SP || GET_CODE ( XEXP ( src , <NUM_LIT> ) ) != CONST_INT || INTVAL ( XEXP ( src , <NUM_LIT> ) ) != ( i - <NUM_LIT> ) * <NUM_LIT> ) return <NUM_LIT> ; regno = REGNO ( dest ) ; if ( group == <NUM_LIT> ) { if ( regno == REG_R7 ) { group = <NUM_LIT> ; lastdreg = <NUM_LIT> ; } else if ( regno != REG_P0 + lastpreg - <NUM_LIT> ) return <NUM_LIT> ; else lastpreg -- ; } else if ( group == <NUM_LIT> ) { if ( regno != REG_R0 + lastdreg - <NUM_LIT> ) return <NUM_LIT> ; else lastdreg -- ; } } first_dreg_to_save = lastdreg ; first_preg_to_save = lastpreg ; n_regs_to_save = <NUM_LIT> - first_dreg_to_save + <NUM_LIT> - first_preg_to_save ; return <NUM_LIT>


<s> dest = XEXP ( dest , <NUM_LIT> ) ; if ( GET_CODE ( dest ) != PLUS || ! REG_P ( XEXP ( dest , <NUM_LIT> ) ) || REGNO ( XEXP ( dest , <NUM_LIT> ) ) != REG_SP || GET_CODE ( XEXP ( dest , <NUM_LIT> ) ) != CONST_INT || INTVAL ( XEXP ( dest , <NUM_LIT> ) ) != - i * <NUM_LIT> ) return <NUM_LIT> ; regno = REGNO ( src ) ; if ( group == <NUM_LIT> ) { if ( D_REGNO_P ( regno ) ) { group = <NUM_LIT> ; first_dreg_to_save = lastdreg = regno - REG_R0 ; } else if ( regno >= REG_P0 && regno <= REG_P7 ) { group = <NUM_LIT> ; first_preg_to_save = lastpreg = regno - REG_P0 ; } else return <NUM_LIT> ; continue ; } if ( group == <NUM_LIT> ) { if ( regno >= REG_P0 && regno <= REG_P7 ) { group = <NUM_LIT> ; first_preg_to_save = lastpreg = regno - REG_P0 ; } else if ( regno != REG_R0 + lastdreg + <NUM_LIT> ) return <NUM_LIT> ; else lastdreg ++ ; } else if ( group == <NUM_LIT> ) { if ( regno != REG_P0 + lastpreg + <NUM_LIT> ) return <NUM_LIT> ; lastpreg ++ ; } } n_regs_to_save = <NUM_LIT> - first_dreg_to_save


<s> group = <NUM_LIT> ; first_dreg_to_save = lastdreg = regno - REG_R0 ; } else if ( regno >= REG_P0 && regno <= REG_P7 ) { group = <NUM_LIT> ; first_preg_to_save = lastpreg = regno - REG_P0 ; } else return <NUM_LIT> ; continue ; } if ( group == <NUM_LIT> ) { if ( regno >= REG_P0 && regno <= REG_P7 ) { group = <NUM_LIT> ; first_preg_to_save = lastpreg = regno - REG_P0 ; } else if ( regno != REG_R0 + lastdreg + <NUM_LIT> ) return <NUM_LIT> ; else lastdreg ++ ; } else if ( group == <NUM_LIT> ) { if ( regno != REG_P0 + lastpreg + <NUM_LIT> ) return <NUM_LIT> ; lastpreg ++ ; } } n_regs_to_save = <NUM_LIT> - first_dreg_to_save + <NUM_LIT>


<s> static HOST_WIDE_INT arg_area_size ( void ) { if ( crtl -> outgoing_args_size )


<s> void asm_conditional_branch ( rtx_insn * insn , rtx * operands , int n_nops , int predict_taken ) { int offset = branch_dest ( insn ) - INSN_ADDRESSES ( INSN_UID ( insn ) ) ; int len = ( offset >= - <NUM_LIT> && offset <= <NUM_LIT> ? <NUM_LIT> : offset >= - <NUM_LIT> && offset <= <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ) ; int bp = predict_taken && len == <NUM_LIT> ? <NUM_LIT> : cbranch_predicted_taken_p ( insn ) ; int idx = ( bp << <NUM_LIT> ) | ( GET_CODE ( operands [ <NUM_LIT> ] ) ==


<s> int bp = predict_taken && len == <NUM_LIT> ? <NUM_LIT> : cbranch_predicted_taken_p ( insn ) ; int idx = ( bp << <NUM_LIT> ) | ( GET_CODE ( operands [ <NUM_LIT> ] ) == EQ ? BRF : BRT ) ; output_asm_insn ( ccbranch_templates [ idx ] [ len ] , operands ) ; gcc_assert ( n_nops == <NUM_LIT> || ! bp ) ; if ( len == <NUM_LIT> ) while ( n_nops -- > <NUM_LIT>

) output_asm_insn ( <STR_LIT> , NULL ) ;


<s> static int bfin_address_cost ( rtx addr ATTRIBUTE_UNUSED , machine_mode mode ATTRIBUTE_UNUSED , addr_space_t as ATTRIBUTE_UNUSED , bool speed ATTRIBUTE_UNUSED ) { return <NUM_LIT>


<s> if ( dep_type != <NUM_LIT> ) return <NUM_LIT> ; dep_insn_code_number = recog_memoized ( dep_insn ) ; if ( dep_insn_code_number < <NUM_LIT> || recog_memoized ( insn ) < <NUM_LIT> ) return cost ; dep_insn_type = get_attr_type ( dep_insn ) ; if ( dep_insn_type == TYPE_MOVE || dep_insn_type == TYPE_MCLD ) { rtx pat = PATTERN ( dep_insn ) ; rtx dest , src ; if ( GET_CODE ( pat ) == PARALLEL ) pat = XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ; dest = SET_DEST ( pat ) ; src = SET_SRC


<s> if ( dep_insn_code_number < <NUM_LIT> || recog_memoized ( insn ) < <NUM_LIT> ) return cost ; dep_insn_type = get_attr_type ( dep_insn ) ; if ( dep_insn_type == TYPE_MOVE || dep_insn_type == TYPE_MCLD ) { rtx pat = PATTERN ( dep_insn ) ; rtx dest , src ; if ( GET_CODE ( pat ) == PARALLEL ) pat = XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ; dest = SET_DEST ( pat ) ; src = SET_SRC ( pat


<s> static int bfin_arg_partial_bytes ( cumulative_args_t cum , const function_arg_info & arg ) { int bytes = arg . promoted_size_in_bytes ( ) ; int bytes_left = get_cumulative_args ( cum ) -> nregs * UNITS_PER_WORD ; if ( bytes == - <NUM_LIT>


<s> if ( GET_CODE ( value ) == SYMBOL_REF && SYMBOL_REF_FUNCTION_P ( value ) ) { fputs ( <STR_LIT> , asm_out_file ) ; output_addr_const ( asm_out_file , value ) ; fputs ( <STR_LIT> , asm_out_file ) ; return true


<s> static bool bfin_cannot_force_const_mem ( machine_mode mode ATTRIBUTE_UNUSED , rtx x ATTRIBUTE_UNUSED ) { return true


<s> static bool bfin_can_eliminate ( const int from ATTRIBUTE_UNUSED , const int


<s> static bool bfin_can_eliminate ( const int from ATTRIBUTE_UNUSED ,


<s> static bool bfin_can_use_doloop_p ( const widest_int & , const widest_int

& iterations_max , unsigned int , bool ) {


<s> if ( kind1 != kind2 ) return <NUM_LIT> ; if ( ! lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type1 ) ) != ! lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type2 ) ) ) return <NUM_LIT> ; if ( ! lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type1 ) ) != ! lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES (


<s> if ( ! lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type1 ) ) != ! lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type2 ) ) ) return <NUM_LIT> ; if ( ! lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( type1 ) ) != ! lookup_attribute ( <STR_LIT>


<s> if ( ! TARGET_FDPIC && flag_pic ) { fixed_regs [ PIC_OFFSET_TABLE_REGNUM ] = <NUM_LIT> ; call_used_regs [ PIC_OFFSET_TABLE_REGNUM ] =


<s> rtx x = orig_x ; if ( GET_CODE ( x ) != MEM ) return orig_x ; x = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( x ) == PLUS && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == UNSPEC && XINT ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) == UNSPEC_MOVE_PIC && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == REG && REGNO ( XEXP ( x

, <NUM_LIT> ) ) == PIC_OFFSET_TABLE_REGNUM ) return XVECEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> , <NUM_LIT> ) ;


<s> if ( GET_CODE ( x ) != MEM ) return orig_x ; x = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( x ) == PLUS && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == UNSPEC && XINT ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) == UNSPEC_MOVE_PIC && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == REG && REGNO ( XEXP ( x , <NUM_LIT> ) ) == PIC_OFFSET_TABLE_REGNUM ) return XVECEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> , <NUM_LIT> ) ; return orig_x


<s> machine_mode tmode = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; machine_mode mode0 = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; machine_mode mode1 = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; if ( VECTOR_MODE_P ( mode0 ) ) op0 = safe_vector_operand ( op0 , mode0 ) ; if ( VECTOR_MODE_P ( mode1 ) ) op1 = safe_vector_operand ( op1 , mode1 ) ; if ( ! target || GET_MODE ( target ) != tmode || ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( target , tmode ) ) target = gen_reg_rtx ( tmode ) ; if ( ( op0mode == SImode || op0mode == VOIDmode ) && mode0 == HImode ) { op0mode = HImode ; op0 = gen_lowpart ( HImode , op0 ) ; } if ( ( op1mode == SImode || op1mode == VOIDmode ) && mode1 == HImode ) { op1mode = HImode ; op1 = gen_lowpart ( HImode , op1 ) ; } gcc_assert ( ( op0mode == mode0 || op0mode == VOIDmode ) && (

op1mode == mode1 || op1mode == VOIDmode ) ) ;


<s> rtx use = NULL , call ; rtx callee = XEXP ( fnaddr , <NUM_LIT> ) ; int nelts = <NUM_LIT> ; rtx pat ; rtx picreg = get_hard_reg_initial_val ( SImode , FDPIC_REGNO ) ; rtx retsreg = gen_rtx_REG ( Pmode , REG_RETS ) ; int n ; if ( cookie == NULL_RTX ) cookie = const0_rtx ; if ( ! TARGET_FDPIC && flag_pic && GET_CODE ( callee ) == SYMBOL_REF && ! SYMBOL_REF_LOCAL_P ( callee ) ) use_reg ( & use , pic_offset_table_rtx ) ; if ( TARGET_FDPIC ) { int caller_in_sram , callee_in_sram ; caller_in_sram = callee_in_sram = <NUM_LIT> ; if ( lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( cfun -> decl ) ) != NULL_TREE ) caller_in_sram = <NUM_LIT> ; else if ( lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( cfun -> decl ) ) != NULL_TREE ) caller_in_sram = <NUM_LIT> ; if ( GET_CODE ( callee ) == SYMBOL_REF && SYMBOL_REF_DECL ( callee ) && DECL_P ( SYMBOL_REF_DECL ( callee ) ) ) { if ( lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( SYMBOL_REF_DECL ( callee ) ) ) != NULL_TREE ) callee_in_sram = <NUM_LIT> ; else if ( lookup_attribute ( <STR_LIT> , DECL_ATTRIBUTES ( SYMBOL_REF_DECL ( callee ) ) ) != NULL_TREE ) callee_in_sram = <NUM_LIT> ; } if ( GET_CODE ( callee ) != SYMBOL_REF || bfin_longcall_p ( callee , INTVAL ( cookie ) ) || ( GET_CODE ( callee ) == SYMBOL_REF && ! SYMBOL_REF_LOCAL_P ( callee ) && TARGET_INLINE_PLT ) || caller_in_sram != callee_in_sram || ( caller_in_sram && callee_in_sram && ( GET_CODE ( callee ) != SYMBOL_REF || ! SYMBOL_REF_LOCAL_P ( callee ) ) ) ) { rtx addr = callee ; if ( ! address_operand ( addr , Pmode ) ) addr = force_reg ( Pmode , addr ) ; fnaddr = gen_reg_rtx ( SImode ) ; emit_insn ( gen_load_funcdescsi ( fnaddr , addr ) ) ; fnaddr = gen_rtx_MEM ( Pmode , fnaddr ) ; picreg = gen_reg_rtx ( SImode ) ; emit_insn ( gen_load_funcdescsi ( picreg , plus_constant ( Pmode , addr , <NUM_LIT> ) ) ) ; } nelts ++ ; } else if ( ( ! register_no_elim_operand ( callee , Pmode ) && GET_CODE ( callee ) != SYMBOL_REF ) || ( GET_CODE ( callee ) == SYMBOL_REF && ( ( TARGET_ID_SHARED_LIBRARY && ! TARGET_LEAF_ID_SHARED_LIBRARY ) || bfin_longcall_p ( callee , INTVAL ( cookie ) ) ) ) ) { callee = copy_to_mode_reg ( Pmode , callee ) ; fnaddr = gen_rtx_MEM ( Pmode , callee ) ; } call = gen_rtx_CALL ( VOIDmode , fnaddr , callarg1 ) ; if ( retval ) call = gen_rtx_SET ( retval , call ) ; pat = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( nelts ) ) ; n = <NUM_LIT> ; XVECEXP ( pat , <NUM_LIT> , n ++ ) = call ; if ( TARGET_FDPIC ) XVECEXP ( pat , <NUM_LIT> , n ++ ) = gen_rtx_USE ( VOIDmode , picreg ) ; XVECEXP ( pat , <NUM_LIT> , n ++ )


<s> } if ( optimize_size ) { if ( count == <NUM_LIT> && align < <NUM_LIT> ) return false ; if ( count == <NUM_LIT> && align < <NUM_LIT> ) return false ; if ( count != <NUM_LIT> && count != <NUM_LIT> && count != <NUM_LIT> ) return false ; } if ( align < <NUM_LIT> && count != <NUM_LIT> ) return false ; destreg = copy_to_mode_reg ( Pmode , XEXP ( dst , <NUM_LIT> ) ) ; if ( destreg != XEXP ( dst , <NUM_LIT> ) ) dst = replace_equiv_address_nv ( dst , destreg ) ; srcreg = copy_to_mode_reg ( Pmode , XEXP ( src , <NUM_LIT> ) ) ; if ( srcreg != XEXP ( src , <NUM_LIT> ) ) src = replace_equiv_address_nv ( src , srcreg ) ; if ( count != <NUM_LIT> && align >= <NUM_LIT> ) { unsigned HOST_WIDE_INT offset = <NUM_LIT> ; if ( align >= <NUM_LIT> ) { if ( ( count & ~ <NUM_LIT> ) == <NUM_LIT> ) { single_move_for_cpymem ( dst , src , SImode , offset ) ; offset = <NUM_LIT> ; } else if ( count & ~ <NUM_LIT> ) { HOST_WIDE_INT new_count = ( ( count >> <NUM_LIT> ) & <NUM_LIT> ) - <NUM_LIT> ; countreg = copy_to_mode_reg ( Pmode , GEN_INT ( new_count ) ) ; emit_insn ( gen_rep_movsi ( destreg , srcreg , countreg , destreg , srcreg ) ) ; cfun -> machine -> has_loopreg_clobber = true ; } if ( count & <NUM_LIT> ) { single_move_for_cpymem ( dst , src , HImode , offset ) ; offset += <NUM_LIT> ; } } else { if ( ( count & ~ <NUM_LIT> ) == <NUM_LIT> ) { single_move_for_cpymem ( dst , src , HImode , offset ) ; offset = <NUM_LIT> ; } else if ( count & ~ <NUM_LIT> ) { HOST_WIDE_INT new_count = ( ( count >> <NUM_LIT> ) & <NUM_LIT> ) - <NUM_LIT> ; countreg = copy_to_mode_reg ( Pmode , GEN_INT ( new_count


<s> int e = sibcall_p ? - <NUM_LIT> : <NUM_LIT> ; tree attrs = TYPE_ATTRIBUTES ( TREE_TYPE ( current_function_decl ) ) ; bool all = lookup_attribute ( <STR_LIT> , attrs ) != NULL_TREE ; if ( fkind != SUBROUTINE ) { expand_interrupt_handler_epilogue ( spreg , fkind , all ) ; return ; } do_unlink ( spreg , get_frame_size ( ) , all , e ) ; expand_epilogue_reg_restore ( spreg , all , false ) ; if ( !


<s> void bfin_expand_epilogue ( int need_return , int eh_return , bool sibcall_p ) { rtx spreg = gen_rtx_REG ( Pmode , REG_SP ) ; e_funkind fkind = funkind ( TREE_TYPE ( current_function_decl ) ) ; int e = sibcall_p ? - <NUM_LIT> : <NUM_LIT> ; tree attrs = TYPE_ATTRIBUTES ( TREE_TYPE


<s> static rtx bfin_expand_unop_builtin ( enum insn_code icode , tree exp , rtx target ) { rtx pat ; tree arg0 = CALL_EXPR_ARG ( exp , <NUM_LIT> ) ; rtx op0 = expand_normal ( arg0 ) ; machine_mode op0mode = GET_MODE ( op0 ) ; machine_mode tmode = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; machine_mode mode0 = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; if ( ! target || GET_MODE ( target ) != tmode || ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( target , tmode ) ) target = gen_reg_rtx ( tmode ) ; if ( VECTOR_MODE_P ( mode0 ) ) op0 = safe_vector_operand ( op0 , mode0 ) ; if ( op0mode == SImode


<s> if ( TARGET_OMIT_LEAF_FRAME_POINTER && ! crtl -> is_leaf ) return true ; return


<s> int bytes = arg . promoted_size_in_bytes ( ) ; if ( arg . end_marker_p ( ) ) return GEN_INT ( cum -> call_cookie ) ; if ( bytes == - <NUM_LIT> ) return NULL_RTX ; if ( cum -> nregs ) return gen_rtx_REG ( arg .


<s> static bool bfin_function_ok_for_sibcall ( tree decl ATTRIBUTE_UNUSED , tree exp ATTRIBUTE_UNUSED ) { cgraph_node * this_func , * called_func ; e_funkind fkind = funkind ( TREE_TYPE ( current_function_decl ) ) ; if ( fkind != SUBROUTINE ) return false ; if ( ! TARGET_ID_SHARED_LIBRARY || TARGET_SEP_DATA ) return true ; if ( ! decl )


<s> next = NEXT_INSN ( insn ) ; } at_end = insn == BB_END ( bb ) ; if ( delete_this == NULL_RTX && ( at_end || GET_MODE ( next ) == TImode ) ) { if ( ( n_filled < <NUM_LIT> || ! gen_one_bundle ( slot ) ) && slot [ <NUM_LIT> ] != NULL_RTX ) { rtx pat = PATTERN ( slot [ <NUM_LIT> ] ) ; if ( GET_CODE ( pat ) == SET && GET_CODE ( SET_SRC ( pat ) ) == UNSPEC && XINT ( SET_SRC ( pat ) , <NUM_LIT> ) == UNSPEC_32BIT ) { SET_SRC ( pat ) = XVECEXP ( SET_SRC ( pat ) , <NUM_LIT> , <NUM_LIT> ) ; INSN_CODE ( slot [ <NUM_LIT> ] ) = - <NUM_LIT> ; df_insn_rescan ( slot [ <NUM_LIT> ]


<s> enum rtx_code code1 , code2 ; rtx op0 = XEXP ( cmp , <NUM_LIT> ) , op1 = XEXP ( cmp , <NUM_LIT> ) ; rtx tem = bfin_cc_rtx ; enum rtx_code code = GET_CODE ( cmp ) ; if ( GET_MODE ( op0 ) == BImode ) { gcc_assert ( ( code == NE || code == EQ ) && op1 == const0_rtx ) ; tem = op0 , code2 = code ; } else { switch ( code ) { case EQ : case LT : case LE : case LEU : case LTU : code1 = code ; code2 = NE ; break ; default : code1 = reverse_condition ( code ) ; code2 = EQ ; break ; } emit_insn ( gen_rtx_SET ( tem , gen_rtx_fmt_ee ( code1 , BImode , op0 , op1 ) ) ) ; } return gen_rtx_fmt_ee ( code2 , BImode , tem , CONST0_RTX (


<s> tem = op0 , code2 = code ; } else { switch ( code ) { case EQ : case LT : case LE : case LEU : case LTU : code1 = code ; code2 = NE ; break ; default : code1 = reverse_condition ( code ) ; code2 = EQ ; break ; } emit_insn ( gen_rtx_SET ( tem , gen_rtx_fmt_ee ( code1 , BImode , op0 , op1 ) ) ) ; } return gen_rtx_fmt_ee ( code2 , BImode , tem ,


<s> static void bfin_globalize_label ( FILE * stream , const char * name ) { fputs ( <STR_LIT> , stream ) ; assemble_name ( stream , name ) ; fputc ( ';' , stream ) ; fputc ( '\n' , stream


<s> else { const char * section_name ; if ( strcmp ( IDENTIFIER_POINTER ( name ) , <STR_LIT> ) == <NUM_LIT> ) section_name = <STR_LIT> ; else if ( strcmp ( IDENTIFIER_POINTER ( name ) , <STR_LIT> ) == <NUM_LIT> ) section_name = <STR_LIT> ; else if ( strcmp ( IDENTIFIER_POINTER ( name ) , <STR_LIT> ) == <NUM_LIT> ) section_name = <STR_LIT> ; else gcc_unreachable (


<s> error ( <STR_LIT> , name ) ; * no_add_attrs = true ; } else if ( current_function_decl != NULL_TREE && ! TREE_STATIC ( decl ) ) { error ( <STR_LIT> , name ) ; * no_add_attrs = true ; } else { const char * section_name ; if ( strcmp ( IDENTIFIER_POINTER ( name ) , <STR_LIT> ) == <NUM_LIT> ) section_name = <STR_LIT> ; else if ( strcmp ( IDENTIFIER_POINTER ( name ) , <STR_LIT> ) == <NUM_LIT> ) section_name = <STR_LIT> ; else if ( strcmp ( IDENTIFIER_POINTER ( name ) , <STR_LIT> ) == <NUM_LIT> ) section_name = <STR_LIT> ; else gcc_unreachable ( ) ; if ( DECL_SECTION_NAME ( decl ) != NULL && strcmp ( DECL_SECTION_NAME ( decl ) , section_name ) != <NUM_LIT> ) { error ( <STR_LIT> , decl ) ; * no_add_attrs = true ; } else set_decl_section_name ( decl


<s> static tree bfin_handle_l1_text_attribute ( tree * node , tree name , tree ARG_UNUSED ( args ) , int ARG_UNUSED ( flags ) , bool * no_add_attrs ) { tree decl = * node ; if ( TREE_CODE ( decl ) != FUNCTION_DECL ) { error ( <STR_LIT> , name ) ; * no_add_attrs = true ; } else if ( DECL_SECTION_NAME ( decl ) != NULL && strcmp ( DECL_SECTION_NAME ( decl ) , <STR_LIT>


<s> if ( TREE_CODE ( decl ) != FUNCTION_DECL ) { error ( <STR_LIT> , name ) ; * no_add_attrs = true ; } else if ( DECL_SECTION_NAME ( decl ) != NULL && strcmp ( DECL_SECTION_NAME ( decl ) , <STR_LIT> ) != <NUM_LIT> ) { error ( <STR_LIT> ,


<s> } if ( ( strcmp ( IDENTIFIER_POINTER ( name ) , <STR_LIT> ) == <NUM_LIT> && lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( * node ) ) ) || ( strcmp ( IDENTIFIER_POINTER ( name ) , <STR_LIT> ) == <NUM_LIT> && lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( * node ) ) ) ) { warning ( OPT_Wattributes , <STR_LIT> <STR_LIT> ) ; * no_add_attrs = true ; } return NULL_TREE


<s> void bfin_hardware_loop ( void ) { cfun -> machine -> has_hardware_loops ++


<s> if ( rclass == CCREGS ) return mode == BImode ; if ( mode == PDImode || mode == V2PDImode ) return regno == REG_A0 || regno == REG_A1 ; if ( mode == DImode )


<s> if ( rclass == CCREGS ) return mode == BImode ; if ( mode == PDImode || mode == V2PDImode ) return regno == REG_A0 || regno == REG_A1 ; if ( mode == DImode ) return regno < REG_M3 ; if ( mode == SImode && TEST_HARD_REG_BIT ( reg_class_contents [ PROLOGUE_REGS ] , regno ) ) return true ; return TEST_HARD_REG_BIT ( reg_class_contents [


<s> if ( mode == PDImode && ( regno == REG_A0 ||


<s> if ( funkind ( TREE_TYPE ( current_function_decl ) ) != SUBROUTINE && ! df_regs_ever_live_p (


<s> if ( funkind ( TREE_TYPE ( current_function_decl ) ) != SUBROUTINE && ! df_regs_ever_live_p ( new_reg ) ) return <NUM_LIT> ; return


<s> if ( from == ARG_POINTER_REGNUM ) offset = n_regs_saved_by_prologue ( ) * <NUM_LIT> ; if ( to == STACK_POINTER_REGNUM ) { if ( crtl -> outgoing_args_size >= FIXED_STACK_AREA ) offset += crtl -> outgoing_args_size ; else if ( crtl -> outgoing_args_size ) offset += FIXED_STACK_AREA ; offset += get_frame_size ( ) ; } return offset


<s> HOST_WIDE_INT offset ; if ( GET_CODE ( x ) != CONST ) return true ; x = XEXP ( x , <NUM_LIT> ) ; gcc_assert ( GET_CODE ( x ) == PLUS ) ; sym = XEXP ( x , <NUM_LIT> ) ; x = XEXP ( x , <NUM_LIT> ) ; if ( GET_CODE ( sym ) != SYMBOL_REF || GET_CODE ( x ) != CONST_INT ) return true ; offset = INTVAL ( x ) ; if ( SYMBOL_REF_DECL ( sym ) == <NUM_LIT> ) return true ; if ( offset < <NUM_LIT> || offset >= int_size_in_bytes ( TREE_TYPE (

SYMBOL_REF_DECL ( sym ) ) ) ) return false ;


<s> rtx addr ; cgraph_node * local_info_node = cgraph_node :: local_info_node ( current_function_decl ) ; if ( local_info_node && local_info_node -> local ) return pic_offset_table_rtx ; if ( OPTION_SET_P ( bfin_library_id ) ) addr = plus_constant ( Pmode , pic_offset_table_rtx , - <NUM_LIT> - bfin_library_id * <NUM_LIT> ) ; else addr = gen_rtx_PLUS ( Pmode , pic_offset_table_rtx , gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , const0_rtx ) , UNSPEC_LIBRARY_OFFSET ) ) ; emit_insn ( gen_movsi ( dest , gen_rtx_MEM ( Pmode , addr ) ) ) ; return


<s> cgraph_node * local_info_node = cgraph_node :: local_info_node ( current_function_decl ) ; if ( local_info_node && local_info_node -> local ) return pic_offset_table_rtx ; if ( OPTION_SET_P ( bfin_library_id ) ) addr = plus_constant ( Pmode , pic_offset_table_rtx , - <NUM_LIT> - bfin_library_id * <NUM_LIT> ) ; else addr = gen_rtx_PLUS ( Pmode , pic_offset_table_rtx , gen_rtx_UNSPEC ( Pmode , gen_rtvec ( <NUM_LIT> , const0_rtx ) , UNSPEC_LIBRARY_OFFSET ) ) ; emit_insn ( gen_movsi ( dest , gen_rtx_MEM


<s> unsigned bfin_local_alignment ( tree type , unsigned align ) { if ( TYPE_SIZE ( type ) && TREE_CODE ( TYPE_SIZE ( type ) ) == INTEGER_CST && wi :: gtu_p ( wi :: to_wide ( TYPE_SIZE ( type ) ) , <NUM_LIT> ) && align < <NUM_LIT> ) return <NUM_LIT> ; return


<s> if ( ! reg_class_subset_p ( rclass , DPREGS ) ) return <NUM_LIT> ; return


!= BImode && mode2 != BImode && GET_MODE_SIZE ( mode1 ) <= UNITS_PER_WORD && GET_MODE_SIZE ( mode2 ) <= UNITS_PER_WORD ) ) ;


<s> if ( TARGET_SEP_DATA && TARGET_ID_SHARED_LIBRARY ) error ( <STR_LIT> ) ; if ( TARGET_SEP_DATA ) target_flags |= MASK_ID_SHARED_LIBRARY | MASK_LEAF_ID_SHARED_LIBRARY ; if ( TARGET_ID_SHARED_LIBRARY && flag_pic == <NUM_LIT> ) flag_pic = <NUM_LIT> ; if ( TARGET_FDPIC ) targetm . asm_out . unaligned_op . si = <NUM_LIT> ; if ( flag_pic && ! TARGET_FDPIC && ! TARGET_ID_SHARED_LIBRARY ) flag_pic = <NUM_LIT> ; if ( TARGET_MULTICORE && bfin_cpu_type != BFIN_CPU_BF561 ) error ( <STR_LIT> ) ; if ( TARGET_COREA && ! TARGET_MULTICORE ) error ( <STR_LIT> ) ; if ( TARGET_COREB && ! TARGET_MULTICORE ) error ( <STR_LIT> ) ; if ( TARGET_COREA && TARGET_COREB ) error ( <STR_LIT> ) ; flag_schedule_insns = <NUM_LIT>


<s> static bool bfin_pass_by_reference ( cumulative_args_t , const function_arg_info & arg ) { return arg . type && TREE_CODE ( TYPE_SIZE ( arg


<s> static int bfin_register_move_cost ( machine_mode mode , reg_class_t class1 , reg_class_t class2 ) { if ( ( class1 == CCREGS && ! reg_class_subset_p ( class2 , DREGS ) ) || ( class2 == CCREGS && ! reg_class_subset_p ( class1 , DREGS )


<s> splitting_for_sched = <NUM_LIT> ; add_sched_insns_for_speculation ( ) ; timevar_push ( TV_SCHED2 ) ; if ( flag_selective_scheduling2 && ! maybe_skip_selective_scheduling ( ) ) run_selective_scheduling ( ) ; else schedule_insns ( ) ; timevar_pop ( TV_SCHED2 ) ; bfin_gen_bundles ( ) ; } df_analyze ( ) ; if ( cfun -> machine -> has_hardware_loops ) bfin_reorg_loops (


<s> if ( cfun -> machine -> has_hardware_loops ) bfin_reorg_loops ( ) ; workaround_speculation ( ) ; if ( flag_var_tracking ) { timevar_push ( TV_VAR_TRACKING ) ; variable_tracking_main ( ) ; reorder_var_tracking_notes ( ) ; timevar_pop ( TV_VAR_TRACKING ) ; } df_finish_pass (


<s> reorg_loops ( true , & bfin_doloop_hooks


<s> rtx bfin_return_addr_rtx ( int count ) { if ( count != <NUM_LIT> ) return const0_rtx ; return get_hard_reg_initial_val ( Pmode ,


<s> return size > <NUM_LIT> * UNITS_PER_WORD || size ==


<s> static bool bfin_return_in_memory ( const_tree type , const_tree fntype ATTRIBUTE_UNUSED ) { int size = int_size_in_bytes ( type ) ; return size > <NUM_LIT> * UNITS_PER_WORD


<s> if ( code == SUBREG ) x = SUBREG_REG ( x ) , code = GET_CODE ( x ) ; if ( REG_P ( x ) ) { int regno = REGNO ( x ) ; if ( regno >= FIRST_PSEUDO_REGISTER ) regno = reg_renumber [ regno ] ; if ( regno == - <NUM_LIT> ) code = MEM ; else x_class = REGNO_REG_CLASS ( regno ) ; } if ( fp_plus_const_operand ( x , mode ) ) { rtx op2 = XEXP ( x , <NUM_LIT> ) ; int large_constant_p = ! satisfies_constraint_Ks7 ( op2 ) ; if ( rclass == PREGS || rclass == PREGS_CLOBBERED ) return NO_REGS ; if ( ( rclass == DREGS || rclass == DPREGS ) && ! large_constant_p ) return NO_REGS ; sri -> icode = CODE_FOR_reload_insi ; return NO_REGS ; } if ( x_class == AREGS || x_class == EVEN_AREGS || x_class == ODD_AREGS ) return ( rclass == DREGS || rclass == AREGS || rclass == EVEN_AREGS || rclass == ODD_AREGS ? NO_REGS : DREGS ) ; if ( rclass == AREGS || rclass == EVEN_AREGS || rclass


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


<s> emit_move_insn ( mem , a ) ; i = <NUM_LIT> ; } mem = adjust_address ( m_tramp , HImode , i + <NUM_LIT> ) ; emit_move_insn ( mem , gen_lowpart ( HImode , t1 ) ) ; emit_insn ( gen_ashrsi3 ( t1 , t1 , GEN_INT ( <NUM_LIT> ) ) ) ; mem = adjust_address ( m_tramp , HImode , i + <NUM_LIT> ) ; emit_move_insn ( mem , gen_lowpart ( HImode , t1 ) ) ; mem = adjust_address ( m_tramp , HImode , i + <NUM_LIT> ) ; emit_move_insn ( mem , gen_lowpart ( HImode , t2 ) ) ; emit_insn ( gen_ashrsi3 ( t2 , t2


<s> if ( value > <NUM_LIT> && sz == <NUM_LIT> ) v += <NUM_LIT> ; return ( v & ~ ( <NUM_LIT>


<s> int shift = sz == <NUM_LIT> ? <NUM_LIT> : sz == <NUM_LIT> ? <NUM_LIT> : <NUM_LIT> ; if ( value > <NUM_LIT> && sz == <NUM_LIT> ) v += <NUM_LIT> ; return ( v & ~ ( <NUM_LIT> << shift ) ) ==


<s> static bool bfin_vector_mode_supported_p ( machine_mode


<s> dest = SET_SRC ( pat ) ; if ( GET_CODE ( dest ) == IF_THEN_ELSE ) dest = XEXP ( dest , <NUM_LIT> ) ; dest = XEXP ( dest , <NUM_LIT> ) ; dest_uid = INSN_UID ( dest ) ; return INSN_ADDRESSES (


<s> int dest_uid ; rtx pat = PATTERN ( branch ) ; if ( GET_CODE ( pat ) == PARALLEL ) pat = XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ; dest = SET_SRC ( pat ) ; if ( GET_CODE ( dest ) == IF_THEN_ELSE ) dest = XEXP ( dest , <NUM_LIT> ) ; dest = XEXP ( dest ,


<s> if ( x ) { return profile_probability :: from_reg_br_prob_note ( XINT ( x , <NUM_LIT> ) ) >= profile_probability :: even ( ) ; } return <NUM_LIT>


<s> if ( stack_frame_needed_p ( ) ) emit_insn ( gen_unlink ( ) ) ; else { rtx postinc = gen_rtx_MEM ( Pmode , gen_rtx_POST_INC ( Pmode , spreg ) ) ; add_to_reg ( spreg , frame_size , <NUM_LIT> , epilogue_p ) ; if ( all || must_save_fp_p ( ) ) { rtx fpreg = gen_rtx_REG ( Pmode , REG_FP ) ; emit_move_insn ( fpreg , postinc ) ; emit_use (


<s> op = XEXP ( op , <NUM_LIT> ) ; if ( GET_CODE ( op ) != PLUS ) { gcc_assert ( REG_P ( op ) || GET_CODE ( op ) == POST_INC || GET_CODE ( op ) == PRE_DEC || GET_CODE ( op ) == POST_DEC ) ; return <NUM_LIT> ; } if ( GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == UNSPEC ) return <NUM_LIT> ; offset = INTVAL ( XEXP ( op , <NUM_LIT> ) ) ; if ( GET_MODE_SIZE ( mode ) == <NUM_LIT> ) return <NUM_LIT> ; if ( GET_MODE_SIZE ( mode ) == <NUM_LIT> ) { if ( XEXP ( op , <NUM_LIT> ) == frame_pointer_rtx ) return offset < -


<s> rtx temp = reload_in_progress ? operands [ <NUM_LIT> ] : gen_reg_rtx ( Pmode ) ; gcc_assert ( ! TARGET_FDPIC || ! ( reload_in_progress || reload_completed ) ) ; if ( GET_CODE ( operands [ <NUM_LIT> ] ) == MEM && SYMBOLIC_CONST ( operands [ <NUM_LIT> ] ) ) operands [ <NUM_LIT> ] = force_reg ( SImode , operands [ <NUM_LIT> ] ) ; else operands [ <NUM_LIT> ] = legitimize_pic_address ( operands [ <NUM_LIT> ] , temp , TARGET_FDPIC ? OUR_FDPIC_REG


<s> int npregs_consec = saveall ? <NUM_LIT> : n_pregs_to_save ( is_inthandler , true ) ; int total_consec = ndregs_consec + npregs_consec ; int i , regno ; rtx_insn * insn ; MEM_VOLATILE_P ( postinc ) = <NUM_LIT> ; for ( i = REG_CC - <NUM_LIT> ; i > REG_P7 ; i -- ) if ( saveall || ( is_inthandler && ( df_regs_ever_live_p ( i ) || ( ! leaf_function_p ( ) && call_used_or_fixed_reg_p ( i ) ) ) ) ) { if ( i == REG_A0 || i == REG_A1 ) { rtx mem = gen_rtx_MEM ( PDImode , postinc1 ) ; MEM_VOLATILE_P ( mem ) = <NUM_LIT> ; emit_move_insn ( gen_rtx_REG ( PDImode , i ) , mem ) ; } else emit_move_insn ( gen_rtx_REG ( SImode , i ) , postinc ) ; } regno = REG_P5 - npregs_consec ; for ( ; npregs != npregs_consec ; regno -- ) { if ( must_save_p ( is_inthandler , regno ) ) { emit_move_insn ( gen_rtx_REG ( word_mode , regno ) , postinc ) ; npregs -- ; } } regno = REG_R7 - ndregs_consec ; for ( ; ndregs != ndregs_consec ; regno -- ) { if ( must_save_p ( is_inthandler , regno ) ) { emit_move_insn ( gen_rtx_REG ( word_mode , regno ) , postinc ) ; ndregs -- ; } } if ( total_consec != <NUM_LIT> ) { rtx pat = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( total_consec + <NUM_LIT> ) ) ; XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_SET ( spreg , gen_rtx_PLUS ( Pmode , spreg , GEN_INT ( total_consec * <NUM_LIT> ) ) ) ; if ( npregs_consec > <NUM_LIT> ) regno = REG_P5 + <NUM_LIT> ; else regno = REG_R7 +


<s> rtx srcreg = gen_rtx_REG ( Pmode , ret_regs [ fkind ] ) ; emit_move_insn ( srcreg , postinc ) ; } if ( ! crtl -> is_leaf ) all = true ; expand_epilogue_reg_restore ( spreg , all , true ) ; if ( fkind == EXCPT_HANDLER ) emit_insn ( gen_addsi3 ( spreg , spreg , GEN_INT ( <NUM_LIT> ) ) ) ; emit_jump_insn ( gen_return_internal ( gen_rtx_REG ( Pmode , ret_regs [


<s> insn = emit_move_insn ( predec , srcreg ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } do_link ( spreg , frame_size , all ) ; if ( fkind == EXCPT_HANDLER ) { rtx r0reg = gen_rtx_REG ( SImode , REG_R0 ) ; rtx r1reg = gen_rtx_REG ( SImode , REG_R1 ) ; rtx r2reg = gen_rtx_REG ( SImode , REG_R2 ) ; emit_move_insn ( r0reg , gen_rtx_REG ( SImode , REG_SEQSTAT ) ) ; emit_insn ( gen_ashrsi3 ( r0reg , r0reg , GEN_INT ( <NUM_LIT> ) ) ) ; emit_insn ( gen_ashlsi3 ( r0reg , r0reg , GEN_INT ( <NUM_LIT> ) ) ) ; emit_move_insn ( r1reg , spreg ) ; emit_move_insn ( r2reg , gen_rtx_REG ( Pmode ,


<s> rtx dest = operands [ <NUM_LIT> ] ; rtx op0 , op1 ; gcc_assert ( ! reload_in_progress && ! reload_completed ) ; op = XEXP ( op , <NUM_LIT> ) ; op0 = force_reg ( mode , XEXP ( op , <NUM_LIT> ) ) ; op1 = XEXP ( op , <NUM_LIT> ) ; if ( ! insn_data [ CODE_FOR_addsi3 ] . operand [ <NUM_LIT> ] . predicate ( op1 , mode ) ) op1 = force_reg ( mode , op1 ) ; if ( GET_CODE ( dest ) == MEM ) dest = gen_reg_rtx ( mode ) ; emit_insn ( gen_addsi3 ( dest , op0 , op1 ) ) ; if ( dest == operands [


<s> if ( get_attr_type ( insn ) == TYPE_MCLD ) return insn ; if ( GET_MODE ( insn ) != SImode ) return NULL ; do { insn = NEXT_INSN ( insn ) ; if ( ( GET_MODE ( insn ) == SImode || GET_MODE ( insn ) == QImode ) && get_attr_type ( insn


<s> if ( ! NONDEBUG_INSN_P ( insn ) ) return NULL ; if ( get_attr_type ( insn ) == TYPE_MCLD ) return insn ; if ( GET_MODE ( insn ) != SImode ) return NULL ; do { insn = NEXT_INSN ( insn ) ; if ( ( GET_MODE ( insn ) == SImode || GET_MODE ( insn ) == QImode ) && get_attr_type ( insn ) == TYPE_MCLD ) return insn ; } while ( GET_MODE ( insn


<s> if ( GET_MODE ( insn ) == SImode ) { while ( GET_MODE ( insn ) != QImode ) insn = NEXT_INSN


<s> if ( GET_MODE ( insn ) == SImode ) { while ( GET_MODE ( insn ) != QImode ) insn = NEXT_INSN ( insn


<s> gcc_assert ( GET_MODE ( insn ) != SImode ) ; if ( GET_MODE ( insn ) == QImode ) { while ( GET_MODE ( PREV_INSN ( insn ) ) ==


<s> else if ( lookup_attribute ( <STR_LIT> , attrs ) ) return EXCPT_HANDLER ; else if ( lookup_attribute ( <STR_LIT> , attrs ) ) return NMI_HANDLER ; else return SUBROUTINE


<s> if ( optimize_size && ( slot [ <NUM_LIT> ] == NULL_RTX || slot [ <NUM_LIT> ] == NULL_RTX ) ) return false ; if ( slot [ <NUM_LIT> ] ) { rtx_insn * t = NEXT_INSN ( slot [ <NUM_LIT> ] ) ; while ( t != slot [ <NUM_LIT> ] ) { if ( ! NOTE_P ( t ) || NOTE_KIND ( t ) != NOTE_INSN_DELETED ) return false ; t = NEXT_INSN ( t ) ; } } if ( slot [ <NUM_LIT> ] ) { rtx_insn * t = NEXT_INSN ( slot [ <NUM_LIT> ] ) ; while ( t != slot [ <NUM_LIT> ] ) { if ( ! NOTE_P ( t ) || NOTE_KIND ( t ) != NOTE_INSN_DELETED ) return false ; t = NEXT_INSN ( t ) ; } } if ( slot [ <NUM_LIT> ] == NULL_RTX ) { slot [ <NUM_LIT> ] = emit_insn_before ( gen_mnop ( ) , slot [ <NUM_LIT> ] ) ; df_insn_rescan ( slot [ <NUM_LIT> ] ) ; } if ( slot [ <NUM_LIT> ] == NULL_RTX ) { slot [ <NUM_LIT> ] = emit_insn_after ( gen_forced_nop ( ) , slot [ <NUM_LIT> ] ) ; df_insn_rescan ( slot [ <NUM_LIT> ] ) ; } if ( INSN_LOCATION ( slot [ <NUM_LIT> ] ) && INSN_LOCATION ( slot [ <NUM_LIT> ] ) != INSN_LOCATION ( slot [ <NUM_LIT> ] ) ) INSN_LOCATION ( slot [ <NUM_LIT> ] ) = INSN_LOCATION ( slot [ <NUM_LIT> ] ) ; if ( INSN_LOCATION ( slot [ <NUM_LIT> ] ) && INSN_LOCATION ( slot [ <NUM_LIT> ] ) != INSN_LOCATION ( slot [ <NUM_LIT> ] ) ) INSN_LOCATION ( slot [ <NUM_LIT> ] ) = INSN_LOCATION


<s> df_insn_rescan ( slot [ <NUM_LIT> ] ) ; } if ( slot [ <NUM_LIT> ] == NULL_RTX ) { slot [ <NUM_LIT> ] = emit_insn_after ( gen_forced_nop ( ) , slot [ <NUM_LIT> ] ) ; df_insn_rescan ( slot [ <NUM_LIT> ] ) ; } if ( INSN_LOCATION ( slot [ <NUM_LIT> ] ) && INSN_LOCATION ( slot [ <NUM_LIT> ] ) != INSN_LOCATION ( slot [ <NUM_LIT> ] ) ) INSN_LOCATION ( slot [ <NUM_LIT> ] ) = INSN_LOCATION ( slot [ <NUM_LIT> ] ) ; if ( INSN_LOCATION ( slot [ <NUM_LIT> ] ) && INSN_LOCATION ( slot [ <NUM_LIT> ] ) != INSN_LOCATION ( slot [ <NUM_LIT> ] ) ) INSN_LOCATION ( slot [ <NUM_LIT> ] ) = INSN_LOCATION


<s> static bool harmless_null_pointer_p ( rtx mem , int np_reg ) { mem = XEXP ( mem , <NUM_LIT> ) ; if ( GET_CODE ( mem ) == POST_INC || GET_CODE ( mem ) == POST_DEC ) mem = XEXP ( mem , <NUM_LIT> ) ; if ( REG_P ( mem ) && ( int ) REGNO ( mem ) == np_reg ) return true ; if ( GET_CODE ( mem ) == PLUS && REG_P ( XEXP ( mem , <NUM_LIT> ) ) && ( int ) REGNO ( XEXP ( mem , <NUM_LIT> ) ) == np_reg ) { mem = XEXP ( mem , <NUM_LIT> ) ; if ( GET_CODE ( mem ) == CONST_INT && INTVAL ( mem ) > <NUM_LIT> ) return true ; } return false


<s> rtx insn , test ; emit_insn_before ( gen_addsi3 ( loop -> iter_reg , loop -> iter_reg , constm1_rtx ) , loop -> loop_end ) ; test = gen_rtx_NE ( VOIDmode , loop -> iter_reg , const0_rtx ) ; insn = emit_jump_insn_before ( gen_cbranchsi4 ( test , loop -> iter_reg , const0_rtx , loop -> start_label ) , loop -> loop_end ) ; JUMP_LABEL ( insn ) = loop -> start_label ; LABEL_NUSES ( loop -> start_label ) ++ ; delete_insn ( loop -> loop_end ) ; } else { splitting_loops =


<s> reg = SET_DEST ( XVECEXP ( PATTERN ( insn ) , <NUM_LIT> , <NUM_LIT> ) ) ; if ( ! REG_P ( reg )


<s> static bool indirect_call_p ( rtx pat ) { if ( GET_CODE ( pat ) == PARALLEL ) pat = XVECEXP ( pat , <NUM_LIT> , <NUM_LIT> ) ; if ( GET_CODE ( pat ) == SET ) pat = SET_SRC ( pat ) ; gcc_assert ( GET_CODE ( pat )


<s> cum -> call_cookie = CALL_NORMAL ; if ( fntype && lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( fntype

) ) ) cum -> call_cookie |= CALL_SHORT ;


<s> if ( fntype && lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( fntype ) ) ) cum -> call_cookie |= CALL_SHORT ; else if ( fntype && lookup_attribute ( <STR_LIT> , TYPE_ATTRIBUTES ( fntype ) ) )


<s> else if ( GET_CODE ( addr ) == CONST || GET_CODE ( addr ) == PLUS ) { rtx base ; if ( GET_CODE ( addr ) == CONST ) { addr = XEXP ( addr , <NUM_LIT> ) ; gcc_assert ( GET_CODE ( addr ) == PLUS ) ; } if ( XEXP ( addr , <NUM_LIT> ) == picreg ) return orig ; if ( reg == <NUM_LIT> ) { gcc_assert ( can_create_pseudo_p ( ) ) ; reg = gen_reg_rtx ( Pmode ) ; } base = legitimize_pic_address ( XEXP ( addr , <NUM_LIT> ) , reg , picreg ) ; addr = legitimize_pic_address ( XEXP ( addr , <NUM_LIT> ) , base == reg ? NULL_RTX : reg , picreg ) ; if ( GET_CODE ( addr ) == CONST_INT ) { gcc_assert ( ! reload_in_progress && ! reload_completed ) ; addr = force_reg ( Pmode , addr ) ; } if ( GET_CODE ( addr ) == PLUS && CONSTANT_P ( XEXP ( addr , <NUM_LIT> ) ) ) { base = gen_rtx_PLUS ( Pmode , base , XEXP ( addr , <NUM_LIT> ) ) ; addr = XEXP ( addr , <NUM_LIT> ) ; } return gen_rtx_PLUS ( Pmode , base ,


<s> int log2constp ( unsigned HOST_WIDE_INT c ) { c &=


<s> static bool must_save_fp_p ( void ) { return df_regs_ever_live_p ( REG_FP


<s> return ( ( df_regs_ever_live_p ( regno ) && ! fixed_regs [ regno ] && ( is_inthandler || ! call_used_or_fixed_reg_p ( regno ) ) ) || ( is_inthandler && ( ENABLE_WA_05000283 || ENABLE_WA_05000315 ) && regno == REG_P5 ) || ( ! TARGET_FDPIC

&& regno == PIC_OFFSET_TABLE_REGNUM && ( crtl -> uses_pic_offset_table || ( TARGET_ID_SHARED_LIBRARY && ! crtl -> is_leaf ) ) ) ) ;


<s> else if ( P_REGNO_P ( regno ) ) { return ( ( df_regs_ever_live_p ( regno ) && ! fixed_regs [ regno ] && ( is_inthandler || ! call_used_or_fixed_reg_p ( regno ) ) ) || ( is_inthandler && ( ENABLE_WA_05000283 || ENABLE_WA_05000315 ) && regno == REG_P5 ) || ( ! TARGET_FDPIC && regno == PIC_OFFSET_TABLE_REGNUM && ( crtl -> uses_pic_offset_table || ( TARGET_ID_SHARED_LIBRARY && ! crtl -> is_leaf ) ) ) ) ; } else return ( ( is_inthandler || ! call_used_or_fixed_reg_p ( regno ) ) && ( df_regs_ever_live_p ( regno ) || (

! leaf_function_p ( ) && call_used_or_fixed_reg_p ( regno ) ) ) ) ;


<s> return df_regs_ever_live_p ( REG_RETS )


<s> static void note_np_check_stores ( rtx x , const_rtx pat ATTRIBUTE_UNUSED , void * data ATTRIBUTE_UNUSED ) { if ( REG_P ( x ) && ( REGNO ( x ) == REG_CC || ( int ) REGNO ( x ) == np_check_regno )


<s> static void note_np_check_stores ( rtx x , const_rtx pat ATTRIBUTE_UNUSED , void * data ATTRIBUTE_UNUSED ) { if ( REG_P ( x ) && ( REGNO ( x ) == REG_CC || ( int ) REGNO ( x ) == np_check_regno ) ) np_check_regno


<s> for ( i = REG_R7 + <NUM_LIT> ; i -- != REG_R0 ; ) { if ( must_save_p ( is_inthandler , i ) ) count ++ ; else if ( consecutive ) return count ; } return


<s> static int n_pregs_to_save ( bool is_inthandler , bool consecutive ) { int count = <NUM_LIT> ; unsigned


<s> e_funkind fkind = funkind ( TREE_TYPE ( current_function_decl ) ) ; bool is_inthandler = fkind != SUBROUTINE ; tree attrs = TYPE_ATTRIBUTES ( TREE_TYPE ( current_function_decl ) ) ; bool all = ( lookup_attribute ( <STR_LIT> , attrs ) != NULL_TREE || ( is_inthandler && ! crtl -> is_leaf ) ) ; int ndregs = all ? <NUM_LIT> : n_dregs_to_save ( is_inthandler , false ) ; int npregs = all ? <NUM_LIT> : n_pregs_to_save ( is_inthandler , false ) ; int n = ndregs + npregs ; int i ; if ( all || stack_frame_needed_p ( ) ) n += <NUM_LIT> ; else { if ( must_save_fp_p ( ) ) n ++ ; if ( must_save_rets_p ( ) ) n ++ ; } if ( fkind != SUBROUTINE


<s> FILE * file = asm_out_file ; int i ; fprintf ( file , <STR_LIT> , LOCATION_FILE


<s> else if ( first_preg_to_save == <NUM_LIT> ) sprintf ( buf , <STR_LIT> , first_dreg_to_save ) ; else sprintf ( buf , <STR_LIT> , first_dreg_to_save , first_preg_to_save ) ; output_asm_insn ( buf , operands


<s> else if ( first_preg_to_save == <NUM_LIT> ) sprintf ( buf , <STR_LIT> , first_dreg_to_save ) ; else sprintf ( buf , <STR_LIT> ,


<s> if ( first_dreg_to_save == <NUM_LIT> ) sprintf ( buf , <STR_LIT> , first_preg_to_save ) ; else if ( first_preg_to_save == <NUM_LIT> ) sprintf ( buf , <STR_LIT> , first_dreg_to_save ) ; else sprintf ( buf , <STR_LIT> , first_dreg_to_save , first_preg_to_save ) ; output_asm_insn ( buf , operands


<s> break ; case PRE_DEC : fprintf ( file , <STR_LIT> ) ; output_address ( VOIDmode , XEXP ( x , <NUM_LIT> ) ) ; break ; case POST_INC : output_address ( VOIDmode , XEXP ( x , <NUM_LIT> ) ) ; fprintf ( file , <STR_LIT> ) ; break ; case POST_DEC : output_address ( VOIDmode , XEXP ( x ,


<s> emit_insn ( gen_movsi ( x , CONST0_RTX ( SImode ) ) ) ; return gen_lowpart ( mode ,


<s> int i ; if ( no_rtl ) return ; for ( i = get_cumulative_args ( cum ) -> words + <NUM_LIT>


<s> int n = <NUM_LIT> ; if ( tmp == <NUM_LIT> ) return <NUM_LIT> ; sgn = tmp & ( ( unsigned HOST_WIDE_INT ) <NUM_LIT> << ( HOST_BITS_PER_WIDE_INT - <NUM_LIT> ) ) ; while ( ( tmp & <NUM_LIT> ) == <NUM_LIT> && n <= <NUM_LIT> ) { tmp = ( tmp >> <NUM_LIT> ) | sgn ; n ++


<s> rtx srcmem , dstmem ; srcmem = adjust_address_nv ( src , mode , offset ) ; dstmem = adjust_address_nv ( dst , mode , offset ) ; emit_move_insn ( scratch ,


<s> rtx scratch = gen_reg_rtx ( mode ) ; rtx srcmem , dstmem ; srcmem = adjust_address_nv ( src , mode , offset ) ; dstmem = adjust_address_nv ( dst , mode ,


<s> return <NUM_LIT> ; } else if ( log2constp ( val | <NUM_LIT> ) && ( val & <NUM_LIT> ) != <NUM_LIT> ) { emit_insn ( gen_movsi ( operands [ <NUM_LIT> ] , GEN_INT ( tmp ) ) ) ; emit_insn ( gen_andsi3 ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , gen_int_mode ( val | <NUM_LIT> , SImode ) ) ) ; } } if ( D_REGNO_P ( regno ) ) { if ( tmp >= - <NUM_LIT> && tmp <= <NUM_LIT> ) { emit_insn ( gen_movsi ( operands [ <NUM_LIT> ] , GEN_INT ( tmp ) ) ) ; emit_insn ( gen_movstricthi_high ( operands [ <NUM_LIT> ] , gen_int_mode ( val & - <NUM_LIT> , SImode ) ) ) ; return <NUM_LIT> ; } if ( ( val & <NUM_LIT> ) == <NUM_LIT> ) { emit_insn ( gen_movsi ( operands [ <NUM_LIT> ] , const0_rtx ) ) ; emit_insn ( gen_movsi_low ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ; return <NUM_LIT> ; } if ( ( val & <NUM_LIT> ) == <NUM_LIT>


<s> if ( crtl -> calls_eh_return ) return true ; return frame_pointer_needed


<s> t = get_attr_type ( seq -> insn ( <NUM_LIT> ) ) ; if ( t == TYPE_MCLD ) return t ; t = get_attr_type ( seq -> insn ( <NUM_LIT> ) ) ; if ( t == TYPE_MCLD ) return t ; return TYPE_MCST ; } else return get_attr_type ( insn


<s> pat1 = gen_cbranch_with_nops ( op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , GEN_INT ( delay_needed ) ) ; delay_added = delay_needed ; } PATTERN ( last_condjump ) = pat1 ; INSN_CODE ( last_condjump ) = recog ( pat1 , insn , & num_clobbers ) ; } if ( CALL_P ( insn ) ) { cycles_since_jump = INT_MAX ; delay_added = <NUM_LIT> ; } } for ( insn = get_insns ( ) ; insn ; insn = NEXT_INSN ( insn ) ) { int cycles_since_jump ; if ( JUMP_P ( insn ) && any_condjump_p ( insn ) && ( INSN_CODE ( insn ) == CODE_FOR_cbranch_predicted_taken || cbranch_predicted_taken_p ( insn ) ) ) { rtx_insn * target = JUMP_LABEL_AS_INSN ( insn ) ; rtx_insn * label = target ; rtx_insn * next_tgt ; cycles_since_jump = <NUM_LIT> ; for ( ; target && cycles_since_jump < <NUM_LIT> ; target = next_tgt ) { rtx pat ; next_tgt = find_next_insn_start ( target ) ; if ( NOTE_P ( target ) || BARRIER_P ( target ) || LABEL_P ( target ) ) continue ; if ( JUMP_TABLE_DATA_P ( target ) ) continue ; pat = PATTERN ( target ) ; if ( GET_CODE ( pat ) == USE || GET_CODE ( pat ) == CLOBBER || GET_CODE ( pat ) == ASM_INPUT || asm_noperands ( pat ) >= <NUM_LIT> ) continue ; if ( NONDEBUG_INSN_P ( target ) ) { rtx_insn * load_insn = find_load ( target ) ; enum attr_type type = type_for_anomaly ( target ) ; int delay_needed = <NUM_LIT> ; if ( cycles_since_jump < INT_MAX ) cycles_since_jump ++ ; if ( load_insn && ENABLE_WA_SPECULATIVE_LOADS ) { if ( trapping_loads_p ( load_insn , - <NUM_LIT> , false ) ) delay_needed = <NUM_LIT> ; } else if ( type == TYPE_SYNC && ENABLE_WA_SPECULATIVE_SYNCS ) delay_needed = <NUM_LIT> ; if ( delay_needed > cycles_since_jump ) { rtx_insn * prev = prev_real_insn ( label ) ; delay_needed -= cycles_since_jump ; if ( dump_file ) fprintf ( dump_file , <STR_LIT> , delay_needed , INSN_UID ( label ) ) ; if ( JUMP_P ( prev ) && INSN_CODE ( prev ) == CODE_FOR_cbranch_with_nops ) { rtx x