<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 [ <NUM_LIT> ] ) return true ;


<s> rtx_insn * insn = emit_move_insn ( predec , gen_rtx_REG ( SImode , REG_ASTAT ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; for ( dregno = REG_LT0 ; dregno <= REG_LB1 ; dregno ++ ) if ( ! crtl -> is_leaf || cfun -> machine -> has_hardware_loops || cfun -> machine -> has_loopreg_clobber || ( ENABLE_WA_05000257 && ( dregno == REG_LC0 || dregno == REG_LC1 ) ) ) { insn = emit_move_insn ( predec , gen_rtx_REG ( SImode , dregno ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } } if ( total_consec != <NUM_LIT> ) { 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 ( 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 ( memref , gen_rtx_REG ( word_mode , dregno ++ ) ) ; d_to_save -- ; } else { subpat = gen_rtx_SET ( 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 -- ; }


<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 ) == TYPE_MCLD ) return 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 ) != QImode ) ;


<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 ) ) == SImode ) insn = PREV_INSN ( insn ) ;


<s> } else if ( GET_MODE ( insn ) == SImode ) in_bundle = true ; } else if ( NOTE_P ( insn ) && NOTE_KIND ( insn ) == NOTE_INSN_VAR_LOCATION ) { if ( in_bundle ) { rtx_insn * prev = PREV_INSN ( insn ) ; SET_PREV_INSN ( next ) = prev ; SET_NEXT_INSN ( prev ) = next ; SET_PREV_INSN ( insn ) = queue ; queue = insn ;


<s> insn = emit_insn ( gen_movsi_high ( reg , cst ) ) ; if ( related ) RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; insn = emit_insn ( gen_movsi_low ( reg , reg , cst ) ) ;


<s> bool function_arg_regno_p ( int n ) { int i ; for ( i = <NUM_LIT> ; arg_regs [ i ] != - <NUM_LIT> ; i ++ ) if ( n == arg_regs [ i ] ) return true ; return false ;


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


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


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


<s> if ( TREE_CODE ( x ) == FUNCTION_DECL ) x = TREE_TYPE ( x ) ; if ( TREE_CODE ( x ) != FUNCTION_TYPE ) { warning ( OPT_Wattributes , <STR_LIT> , name ) ; * no_add_attrs = true ;


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


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


<s> 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 = <NUM_LIT> ; try_split ( PATTERN ( insn ) , safe_as_a < rtx_insn * > ( insn ) , <NUM_LIT> ) ; splitting_loops = <NUM_LIT> ; }


<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 {


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

if ( ! REG_P ( reg ) ) return NULL_RTX ;


<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 ) == CALL ) ;


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 ) ) ) cum -> call_cookie |= CALL_LONG ;


<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 , addr ) ;


<s> 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 , addr ) ; } return new_rtx ;


<s> return c != <NUM_LIT> && ( c & ( c - <NUM_LIT> ) ) == <NUM_LIT> ;


<s> int log2constp ( unsigned HOST_WIDE_INT c ) {


<s> static bool must_save_fp_p ( void ) {


<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> 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 = - <NUM_LIT> ;


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


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


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


<s> FILE * file = asm_out_file ; int i ;

fprintf ( file , <STR_LIT> , LOCATION_FILE ( input_location ) ) ;


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


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


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


<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 :


<s> rtx_insn * next_queue = PREV_INSN ( queue ) ; SET_PREV_INSN ( NEXT_INSN ( insn ) ) = queue ; SET_NEXT_INSN ( queue ) = NEXT_INSN ( insn ) ; SET_NEXT_INSN ( insn ) = queue ; SET_PREV_INSN ( queue ) = insn ; queue = next_queue ; } in_bundle = false ; } else if ( GET_MODE ( insn ) == SImode ) in_bundle = true ; } else if ( NOTE_P ( insn ) && NOTE_KIND ( insn ) == NOTE_INSN_VAR_LOCATION ) { if ( in_bundle ) { rtx_insn * prev = PREV_INSN ( insn ) ; SET_PREV_INSN ( next ) = prev ; SET_NEXT_INSN ( prev ) = next ; SET_PREV_INSN ( insn ) = queue ; queue = insn ;


<s> while ( queue ) { rtx_insn * next_queue = PREV_INSN ( queue ) ; SET_PREV_INSN ( NEXT_INSN ( insn ) ) = queue ; SET_NEXT_INSN ( queue ) = NEXT_INSN ( insn ) ; SET_NEXT_INSN ( insn ) = queue ; SET_PREV_INSN ( queue ) = insn ; queue = next_queue ; } in_bundle = false ; } else if ( GET_MODE ( insn ) == SImode ) in_bundle = true ; } else if ( NOTE_P ( insn ) && NOTE_KIND ( insn ) == NOTE_INSN_VAR_LOCATION ) { if ( in_bundle ) { rtx_insn * prev = PREV_INSN ( insn ) ; SET_PREV_INSN ( next ) = prev ; SET_NEXT_INSN ( prev ) = next ; SET_PREV_INSN ( insn ) = queue ; queue = insn ;


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


for ( i = get_cumulative_args ( cum ) -> words + <NUM_LIT> ; i < max_arg_registers ; i ++ ) {


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


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


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

dstmem = adjust_address_nv ( dst , mode , offset ) ;


<s> lo_half [ num ] = simplify_gen_subreg ( SImode , op , GET_MODE ( op ) == VOIDmode ? DImode : GET_MODE ( op ) , <NUM_LIT> ) ; hi_half [ num ] = simplify_gen_subreg ( SImode , op , GET_MODE ( op ) == VOIDmode ? DImode : GET_MODE ( op ) , <NUM_LIT> ) ; } }


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


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


<s> for ( j = XVECLEN ( op , i ) - <NUM_LIT> ; j >= <NUM_LIT> ; j -- ) if ( symbolic_reference_mentioned_p ( XVECEXP ( op , i , j ) ) ) return <NUM_LIT> ; } else if ( fmt [ i ] == 'e' && symbolic_reference_mentioned_p ( XEXP ( op , i ) ) ) return <NUM_LIT> ;


<s> if ( ! after_np_branch ) np_reg = - <NUM_LIT> ; return ( ( np_reg == - <NUM_LIT> || ! harmless_null_pointer_p ( mem , np_reg ) ) && may_trap_p ( mem ) ) ;


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


<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 ) {